Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/run/src/G4VUserDetectorConstruction.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /run/src/G4VUserDetectorConstruction.cc (Version 11.3.0) and /run/src/G4VUserDetectorConstruction.cc (Version 10.7.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 // G4VUserDetectorConstruction implementation  << 
 27 //                                                 26 //
 28 // Original author: M.Asai, 1999               <<  27 //
 29 // ------------------------------------------- << 
 30                                                    28 
 31 #include "G4VUserDetectorConstruction.hh"          29 #include "G4VUserDetectorConstruction.hh"
 32                                                << 
 33 #include "G4FieldManager.hh"                       30 #include "G4FieldManager.hh"
 34 #include "G4LogicalVolume.hh"                      31 #include "G4LogicalVolume.hh"
 35 #include "G4LogicalVolumeStore.hh"                 32 #include "G4LogicalVolumeStore.hh"
 36 #include "G4MultiSensitiveDetector.hh"             33 #include "G4MultiSensitiveDetector.hh"
 37 #include "G4RunManager.hh"                     << 
 38 #include "G4SDManager.hh"                          34 #include "G4SDManager.hh"
 39 #include "G4VPhysicalVolume.hh"                    35 #include "G4VPhysicalVolume.hh"
 40 #include "G4VSensitiveDetector.hh"                 36 #include "G4VSensitiveDetector.hh"
 41 #include "G4VUserParallelWorld.hh"                 37 #include "G4VUserParallelWorld.hh"
 42                                                <<  38 #include <assert.h>
 43 #include <cassert>                             << 
 44 #include <map>                                 << 
 45 #include <sstream>                                 39 #include <sstream>
 46                                                    40 
 47 // ------------------------------------------- <<  41 G4VUserDetectorConstruction::G4VUserDetectorConstruction() { ; }
 48 void G4VUserDetectorConstruction::RegisterPara <<  42 
                                                   >>  43 G4VUserDetectorConstruction::~G4VUserDetectorConstruction() { ; }
                                                   >>  44 
                                                   >>  45 void G4VUserDetectorConstruction::RegisterParallelWorld(
                                                   >>  46   G4VUserParallelWorld* aPW)
 49 {                                                  47 {
 50   auto pwItr = std::find(parallelWorld.cbegin( <<  48   std::vector<G4VUserParallelWorld*>::iterator pwItr;
 51   if (pwItr != parallelWorld.cend()) {         <<  49   for(pwItr = parallelWorld.begin(); pwItr != parallelWorld.end(); pwItr++)
 52     G4String eM = "A parallel world <";        <<  50   {
 53     eM += aPW->GetName();                      <<  51     if((*pwItr)->GetName() == aPW->GetName())
 54     eM += "> is already registered to the user <<  52     {
 55     G4Exception("G4VUserDetectorConstruction:: <<  53       G4String eM = "A parallel world <";
 56                 FatalErrorInArgument, eM);     <<  54       eM += aPW->GetName();
                                                   >>  55       eM += "> is already registered to the user detector construction.";
                                                   >>  56       G4Exception("G4VUserDetectorConstruction::RegisterParallelWorld",
                                                   >>  57                   "Run0051", FatalErrorInArgument, eM);
                                                   >>  58     }
 57   }                                                59   }
 58   parallelWorld.push_back(aPW);                    60   parallelWorld.push_back(aPW);
 59 }                                                  61 }
 60                                                    62 
 61 // ------------------------------------------- << 
 62 G4int G4VUserDetectorConstruction::ConstructPa     63 G4int G4VUserDetectorConstruction::ConstructParallelGeometries()
 63 {                                                  64 {
 64   G4int nP = 0;                                    65   G4int nP = 0;
 65   for (const auto& pwItr : parallelWorld) {    <<  66   std::vector<G4VUserParallelWorld*>::iterator pwItr;
 66     pwItr->Construct();                        <<  67   for(pwItr = parallelWorld.begin(); pwItr != parallelWorld.end(); pwItr++)
 67     ++nP;                                      <<  68   {
                                                   >>  69     (*pwItr)->Construct();
                                                   >>  70     nP++;
 68   }                                                71   }
 69   return nP;                                       72   return nP;
 70 }                                                  73 }
 71                                                    74 
 72 // ------------------------------------------- << 
 73 void G4VUserDetectorConstruction::ConstructPar     75 void G4VUserDetectorConstruction::ConstructParallelSD()
 74 {                                                  76 {
 75   for (const auto& pwItr : parallelWorld) {    <<  77   std::vector<G4VUserParallelWorld*>::iterator pwItr;
 76     pwItr->ConstructSD();                      <<  78   for(pwItr = parallelWorld.begin(); pwItr != parallelWorld.end(); pwItr++)
                                                   >>  79   {
                                                   >>  80     (*pwItr)->ConstructSD();
 77   }                                                81   }
 78 }                                                  82 }
 79                                                    83 
 80 // ------------------------------------------- << 
 81 G4int G4VUserDetectorConstruction::GetNumberOf     84 G4int G4VUserDetectorConstruction::GetNumberOfParallelWorld() const
 82 {                                                  85 {
 83   return (G4int)parallelWorld.size();          <<  86   return parallelWorld.size();
 84 }                                                  87 }
 85                                                    88 
 86 // ------------------------------------------- <<  89 G4VUserParallelWorld* G4VUserDetectorConstruction::GetParallelWorld(
 87 G4VUserParallelWorld* G4VUserDetectorConstruct <<  90   G4int i) const
 88 {                                                  91 {
 89   if (i < 0 || i >= GetNumberOfParallelWorld() <<  92   if(i < 0 || i >= GetNumberOfParallelWorld())
                                                   >>  93     return 0;
 90   return parallelWorld[i];                         94   return parallelWorld[i];
 91 }                                                  95 }
 92                                                    96 
 93 // ------------------------------------------- <<  97 #include "G4RunManager.hh"
 94 void G4VUserDetectorConstruction::ConstructSDa <<  98 
                                                   >>  99 void G4VUserDetectorConstruction::ConstructSDandField()
                                                   >> 100 {
                                                   >> 101   //   G4RunManager::RMType rmtype =
                                                   >> 102   //   G4RunManager::GetRunManager()->GetRunManagerType(); if(rmtype !=
                                                   >> 103   //   G4RunManager::sequentialRM)
                                                   >> 104   //   {
                                                   >> 105   //    G4cout
                                                   >> 106   //    << "User-derived detector construction class does not implement \n"
                                                   >> 107   //    << "ConstructSDandFiled method: i.e. workers will not have SD and
                                                   >> 108   //    fields!\n"
                                                   >> 109   //    << "The user can safely ignore this message if (s)he has no sensitive\n"
                                                   >> 110   //    << "detector or field in her/his application." << G4endl;
                                                   >> 111   //   }
                                                   >> 112 }
 95                                                   113 
 96 // ------------------------------------------- << 114 #include <map>
 97 void G4VUserDetectorConstruction::CloneF()        115 void G4VUserDetectorConstruction::CloneF()
 98 {                                                 116 {
 99   using FMtoFMmap = std::map<G4FieldManager*,  << 117   typedef std::map<G4FieldManager*, G4FieldManager*> FMtoFMmap;
100   using FMpair = std::pair<G4FieldManager*, G4 << 118   typedef std::pair<G4FieldManager*, G4FieldManager*> FMpair;
101                                                << 
102   FMtoFMmap masterToWorker;                       119   FMtoFMmap masterToWorker;
103   G4LogicalVolumeStore* const logVolStore = G4    120   G4LogicalVolumeStore* const logVolStore = G4LogicalVolumeStore::GetInstance();
104   for (const auto& g4LogicalVolume : *logVolSt << 121   assert(logVolStore != NULL);
                                                   >> 122   for(G4LogicalVolumeStore::const_iterator it = logVolStore->begin();
                                                   >> 123       it != logVolStore->end(); ++it)
                                                   >> 124   {
                                                   >> 125     G4LogicalVolume* g4LogicalVolume = *it;
105     // Use shadow of master to get instance of    126     // Use shadow of master to get instance of FM
106     G4FieldManager* masterFM = nullptr;  // g4 << 127     G4FieldManager* masterFM = 0;  // g4LogicalVolume->fFieldManager;
107     G4FieldManager* clonedFM = nullptr;        << 128     G4FieldManager* clonedFM = 0;
108     if (masterFM != nullptr) {                 << 129     if(masterFM)
109       auto fmFound = masterToWorker.find(maste << 130     {
110       if (fmFound == masterToWorker.cend()) {  << 131       FMtoFMmap::iterator fmFound = masterToWorker.find(masterFM);
                                                   >> 132       if(fmFound == masterToWorker.end())
                                                   >> 133       {
111         // First time we see this SD, let's cl    134         // First time we see this SD, let's clone and remember...
112         try {                                  << 135         try
113           auto insertedEl = masterToWorker.ins << 136         {
                                                   >> 137           std::pair<FMtoFMmap::iterator, bool> insertedEl =
                                                   >> 138             masterToWorker.insert(FMpair(masterFM, masterFM->Clone()));
114           clonedFM = (insertedEl.first)->secon    139           clonedFM = (insertedEl.first)->second;
115         }                                      << 140         } catch(...)
116         catch (...) {                          << 141         {
117           G4ExceptionDescription msg;             142           G4ExceptionDescription msg;
118           msg << "Cloning of G4FieldManager fa    143           msg << "Cloning of G4FieldManager failed."
119               << " But derived class does not     144               << " But derived class does not implement cloning. Cannot "
120                  "continue.";                     145                  "continue.";
121           G4Exception("G4VUserDetectorConstruc << 146           G4Exception("G4VUserDetectorConstruction::CloneSD", "Run0053",
                                                   >> 147                       FatalException, msg);
122         }                                         148         }
123       }                                           149       }
124       else {                                   << 150       else
125         // We have already seen this SD attach << 151       {
                                                   >> 152         // We have already seen this SD attached to a fifferent LogicalVolume,
126         // let's re-use previous clone            153         // let's re-use previous clone
127         clonedFM = (*fmFound).second;             154         clonedFM = (*fmFound).second;
128       }                                           155       }
129     }  // masterFM != 0                           156     }  // masterFM != 0
130     // Note that we do not push FM to daughter << 157     // Note that we do not push FM to doughters (false argument), however, since
131     // we area looping on all logical volumes     158     // we area looping on all logical volumes and we implemented the "trick" of
132     // the map master<->cloned the final effec    159     // the map master<->cloned the final effect is the same as using here the
133     // correct Boolean flag: log-volumes that  << 160     // correct boolean flag: log-volumes that originally were sharing the same
134     // FM they will have cloned ones              161     // FM they will have cloned ones
135     g4LogicalVolume->SetFieldManager(clonedFM,    162     g4LogicalVolume->SetFieldManager(clonedFM, false);
136   }                                               163   }
137 }                                                 164 }
138                                                   165 
139 // ------------------------------------------- << 
140 void G4VUserDetectorConstruction::CloneSD()       166 void G4VUserDetectorConstruction::CloneSD()
141 {                                                 167 {
142   // Loop on ALL logial volumes to search for     168   // Loop on ALL logial volumes to search for attached SD
143   G4LogicalVolumeStore* const logVolStore = G4    169   G4LogicalVolumeStore* const logVolStore = G4LogicalVolumeStore::GetInstance();
                                                   >> 170   assert(logVolStore != NULL);
144                                                   171 
145   using SDtoSDmap = std::map<G4VSensitiveDetec << 172   typedef std::map<G4VSensitiveDetector*, G4VSensitiveDetector*> SDtoSDmap;
146   using SDpair = std::pair<G4VSensitiveDetecto << 173   typedef std::pair<G4VSensitiveDetector*, G4VSensitiveDetector*> SDpair;
147   SDtoSDmap masterToWorker;                       174   SDtoSDmap masterToWorker;
148                                                   175 
149   for (const auto& g4LogicalVolume : *logVolSt << 176   for(G4LogicalVolumeStore::const_iterator it = logVolStore->begin();
                                                   >> 177       it != logVolStore->end(); ++it)
                                                   >> 178   {
                                                   >> 179     G4LogicalVolume* g4LogicalVolume = *it;
150     // Use shadow of master to get the instanc    180     // Use shadow of master to get the instance of SD
151     G4VSensitiveDetector* masterSD = nullptr;  << 181     G4VSensitiveDetector* masterSD = 0;  // g4LogicalVolume->fSensitiveDetector;
152     G4VSensitiveDetector* clonedSD = nullptr;  << 182     G4VSensitiveDetector* clonedSD = 0;
153     if (masterSD != nullptr) {                 << 183     if(masterSD)
154       auto sdFound = masterToWorker.find(maste << 184     {
155       if (sdFound == masterToWorker.cend()) {  << 185       SDtoSDmap::iterator sdFound = masterToWorker.find(masterSD);
                                                   >> 186       if(sdFound == masterToWorker.end())
                                                   >> 187       {
156         // First time we see this SD, let's cl    188         // First time we see this SD, let's clone and remember...
157         try {                                  << 189         try
158           auto insertedEl = masterToWorker.ins << 190         {
                                                   >> 191           std::pair<SDtoSDmap::iterator, bool> insertedEl =
                                                   >> 192             masterToWorker.insert(SDpair(masterSD, masterSD->Clone()));
159           clonedSD = (insertedEl.first)->secon    193           clonedSD = (insertedEl.first)->second;
160         }                                      << 194         } catch(...)
161         catch (...) {                          << 195         {
162           G4ExceptionDescription msg;             196           G4ExceptionDescription msg;
163           msg << "Cloning of G4VSensitiveDetec << 197           msg << "Cloning of G4VSensitiveDetector requested for:"
                                                   >> 198               << masterSD->GetName() << "\n"
164 #ifndef WIN32                                     199 #ifndef WIN32
165               << " (full path name: " << maste    200               << " (full path name: " << masterSD->GetFullPathName() << ").\n"
166 #endif                                            201 #endif
167               << " But derived class does not     202               << " But derived class does not implement cloning. Cannot "
168                  "continue.";                     203                  "continue.";
169           G4Exception("G4VUserDetectorConstruc << 204           G4Exception("G4VUserDetectorConstruction::CloneSD", "Run0053",
                                                   >> 205                       FatalException, msg);
170         }                                         206         }
171       }                                           207       }
172       else {                                   << 208       else
173         // We have already seen this SD attach << 209       {
                                                   >> 210         // We have already seen this SD attached to a fifferent LogicalVolume,
174         // let's re-use previous clone            211         // let's re-use previous clone
175         clonedSD = (*sdFound).second;             212         clonedSD = (*sdFound).second;
176       }                                           213       }
177     }  // masterSD!=0                             214     }  // masterSD!=0
178     g4LogicalVolume->SetSensitiveDetector(clon    215     g4LogicalVolume->SetSensitiveDetector(clonedSD);
179   }                                               216   }
180 }                                                 217 }
181                                                   218 
182 // ------------------------------------------- << 219 void G4VUserDetectorConstruction::SetSensitiveDetector(
183 void G4VUserDetectorConstruction::SetSensitive << 220   const G4String& logVolName, G4VSensitiveDetector* aSD, G4bool multi)
184                                                << 
185 {                                                 221 {
186   G4bool found = false;                        << 222   G4bool found                = false;
187   G4LogicalVolumeStore* store = G4LogicalVolum    223   G4LogicalVolumeStore* store = G4LogicalVolumeStore::GetInstance();
188   auto volmap = store->GetMap();               << 224   for(G4LogicalVolumeStore::iterator pos = store->begin(); pos != store->end();
189   auto pos = volmap.find(logVolName);          << 225       pos++)
190   if (pos != volmap.cend()) {                  << 226   {
191     if ((pos->second.size() > 1) && !multi) {  << 227     if((*pos)->GetName() == logVolName)
192       G4String eM = "More than one logical vol << 228     {
193       eM += pos->first;                        << 229       if(found && !multi)
194       eM += "> are found and thus the sensitiv << 230       {
195       eM += aSD->GetName();                    << 231         G4String eM = "More than one logical volumes of the name <";
196       eM += "> cannot be uniquely assigned.";  << 232         eM += (*pos)->GetName();
197       G4Exception("G4VUserDetectorConstruction << 233         eM += "> are found and thus the sensitive detector <";
198                   FatalErrorInArgument, eM);   << 234         eM += aSD->GetName();
199     }                                          << 235         eM += "> cannot be uniquely assigned.";
200     found = true;                              << 236         G4Exception("G4VUserDetectorConstruction::SetSensitiveDetector",
201     for (auto& i : pos->second) {              << 237                     "Run0052", FatalErrorInArgument, eM);
202       SetSensitiveDetector(i, aSD);            << 238       }
                                                   >> 239       found = true;
                                                   >> 240       SetSensitiveDetector(*pos, aSD);
203     }                                             241     }
204   }                                               242   }
205   if (!found) {                                << 243   if(!found)
206     G4String eM2 = "No logical volume of name  << 244   {
                                                   >> 245     G4String eM2 = "No logical volume of the name <";
207     eM2 += logVolName;                            246     eM2 += logVolName;
208     eM2 += "> is found. The specified sensitiv    247     eM2 += "> is found. The specified sensitive detector <";
209     eM2 += aSD->GetName();                        248     eM2 += aSD->GetName();
210     eM2 += "> couldn't be assigned to any volu    249     eM2 += "> couldn't be assigned to any volume.";
211     G4Exception("G4VUserDetectorConstruction:: << 250     G4Exception("G4VUserDetectorConstruction::SetSensitiveDetector", "Run0053",
212                 FatalErrorInArgument, eM2);       251                 FatalErrorInArgument, eM2);
213   }                                               252   }
214 }                                                 253 }
215                                                   254 
216 // ------------------------------------------- << 255 void G4VUserDetectorConstruction::SetSensitiveDetector(
217 void G4VUserDetectorConstruction::SetSensitive << 256   G4LogicalVolume* logVol, G4VSensitiveDetector* aSD)
218                                                << 
219 {                                                 257 {
220   assert(logVol != nullptr && aSD != nullptr);    258   assert(logVol != nullptr && aSD != nullptr);
221                                                   259 
222   // The aSD has already been added by user to    260   // The aSD has already been added by user to the manager if needed
223   // G4SDManager::GetSDMpointer()->AddNewDetec    261   // G4SDManager::GetSDMpointer()->AddNewDetector(aSD);
224                                                   262 
225   // New Logic: allow for "multiple" SDs being    263   // New Logic: allow for "multiple" SDs being attached to a single LV.
226   // To do that we use a special proxy SD call    264   // To do that we use a special proxy SD called G4MultiSensitiveDetector
227                                                   265 
228   // Get existing SD if already set and check     266   // Get existing SD if already set and check if it is of the special type
229   G4VSensitiveDetector* originalSD = logVol->G    267   G4VSensitiveDetector* originalSD = logVol->GetSensitiveDetector();
230   if (originalSD == aSD) {                     << 268   if(originalSD == aSD)
                                                   >> 269   {
231     G4ExceptionDescription msg;                   270     G4ExceptionDescription msg;
232     msg << "Attempting to add multiple times t    271     msg << "Attempting to add multiple times the same sensitive detector (\"";
233     msg << originalSD->GetName() << "\") is no    272     msg << originalSD->GetName() << "\") is not allowed, skipping.";
234     G4Exception("G4VUserDetectorConstruction:: << 273     G4Exception("G4VUserDetectorConstruction::SetSensitiveDetector", "Run0054",
                                                   >> 274                 JustWarning, msg);
235     return;                                       275     return;
236   }                                               276   }
237   if (originalSD == nullptr) {                 << 277   if(originalSD == nullptr)
                                                   >> 278   {
238     logVol->SetSensitiveDetector(aSD);            279     logVol->SetSensitiveDetector(aSD);
239   }                                               280   }
240   else {                                       << 281   else
241     auto msd = dynamic_cast<G4MultiSensitiveDe << 282   {
242     if (msd != nullptr) {                      << 283     G4MultiSensitiveDetector* msd =
                                                   >> 284       dynamic_cast<G4MultiSensitiveDetector*>(originalSD);
                                                   >> 285     if(msd != nullptr)
                                                   >> 286     {
243       msd->AddSD(aSD);                            287       msd->AddSD(aSD);
244     }                                             288     }
245     else {                                     << 289     else
                                                   >> 290     {
246       std::ostringstream mn;                      291       std::ostringstream mn;
247       mn << "/MultiSD_" << logVol->GetName() <    292       mn << "/MultiSD_" << logVol->GetName() << "_" << logVol;
248       const G4String msdname = mn.str();          293       const G4String msdname = mn.str();
249       msd = new G4MultiSensitiveDetector(msdna << 294       msd                    = new G4MultiSensitiveDetector(msdname);
250       // We need to register the proxy to have    295       // We need to register the proxy to have correct handling of IDs
251       G4SDManager::GetSDMpointer()->AddNewDete    296       G4SDManager::GetSDMpointer()->AddNewDetector(msd);
252       msd->AddSD(originalSD);                     297       msd->AddSD(originalSD);
253       msd->AddSD(aSD);                            298       msd->AddSD(aSD);
254       logVol->SetSensitiveDetector(msd);          299       logVol->SetSensitiveDetector(msd);
255     }                                             300     }
256   }                                               301   }
257 }                                                 302 }
258                                                   303