Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/examples/extended/biasing/B02/src/B02ImportanceDetectorConstruction.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 /examples/extended/biasing/B02/src/B02ImportanceDetectorConstruction.cc (Version 11.3.0) and /examples/extended/biasing/B02/src/B02ImportanceDetectorConstruction.cc (Version 9.6.p4)


  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 /// \file biasing/B02/src/B02ImportanceDetecto     26 /// \file biasing/B02/src/B02ImportanceDetectorConstruction.cc
 27 /// \brief Implementation of the B02Importance     27 /// \brief Implementation of the B02ImportanceDetectorConstruction class
 28 //                                                 28 //
 29 //                                                 29 //
                                                   >>  30 // $Id$
 30 //                                                 31 //
 31                                                    32 
                                                   >>  33 #include "globals.hh"
                                                   >>  34 #include <sstream>
                                                   >>  35 
 32 #include "B02ImportanceDetectorConstruction.hh     36 #include "B02ImportanceDetectorConstruction.hh"
 33                                                    37 
 34 #include "G4LogicalVolume.hh"                  << 
 35 #include "G4Material.hh"                           38 #include "G4Material.hh"
                                                   >>  39 #include "G4Tubs.hh"
                                                   >>  40 #include "G4LogicalVolume.hh"
                                                   >>  41 #include "G4ThreeVector.hh"
 36 #include "G4PVPlacement.hh"                        42 #include "G4PVPlacement.hh"
 37 #include "G4PhysicalConstants.hh"                  43 #include "G4PhysicalConstants.hh"
 38 #include "G4SystemOfUnits.hh"                      44 #include "G4SystemOfUnits.hh"
 39 #include "G4ThreeVector.hh"                    << 
 40 #include "G4Tubs.hh"                           << 
 41 #include "globals.hh"                          << 
 42                                                << 
 43 #include <sstream>                             << 
 44                                                    45 
 45 // For Primitive Scorers                           46 // For Primitive Scorers
                                                   >>  47 #include "G4SDManager.hh"
 46 #include "G4MultiFunctionalDetector.hh"            48 #include "G4MultiFunctionalDetector.hh"
                                                   >>  49 #include "G4SDParticleFilter.hh"
 47 #include "G4PSNofCollision.hh"                     50 #include "G4PSNofCollision.hh"
 48 #include "G4PSPopulation.hh"                       51 #include "G4PSPopulation.hh"
 49 #include "G4PSTrackCounter.hh"                     52 #include "G4PSTrackCounter.hh"
 50 #include "G4PSTrackLength.hh"                      53 #include "G4PSTrackLength.hh"
 51 #include "G4SDManager.hh"                      << 
 52 #include "G4SDParticleFilter.hh"               << 
 53                                                    54 
 54 // for importance biasing                      << 
 55 #include "G4IStore.hh"                         << 
 56                                                    55 
 57 // for weight window technique                 << 
 58 #include "G4WeightWindowStore.hh"              << 
 59                                                    56 
 60 //....oooOO0OOooo........oooOO0OOooo........oo <<  57 B02ImportanceDetectorConstruction::B02ImportanceDetectorConstruction(G4String worldName) 
 61                                                <<  58 :G4VUserParallelWorld(worldName),fLogicalVolumeVector()
 62 B02ImportanceDetectorConstruction::B02Importan << 
 63   : G4VUserParallelWorld(worldName), fLogicalV << 
 64 {                                                  59 {
 65   //  Construct();                                 60   //  Construct();
 66 }                                                  61 }
 67                                                    62 
 68 //....oooOO0OOooo........oooOO0OOooo........oo << 
 69                                                << 
 70 B02ImportanceDetectorConstruction::~B02Importa     63 B02ImportanceDetectorConstruction::~B02ImportanceDetectorConstruction()
 71 {                                                  64 {
 72   fLogicalVolumeVector.clear();                    65   fLogicalVolumeVector.clear();
 73 }                                                  66 }
 74                                                    67 
 75 //....oooOO0OOooo........oooOO0OOooo........oo << 
 76                                                << 
 77 void B02ImportanceDetectorConstruction::Constr     68 void B02ImportanceDetectorConstruction::Construct()
 78 {                                              <<  69 {  
 79   G4cout << " constructing parallel world " <<     70   G4cout << " constructing parallel world " << G4endl;
 80                                                    71 
 81   G4Material* dummyMat = 0;                    <<  72   //GetWorld methods create a clone of the mass world to the parallel world (!)
 82                                                <<  73   // via the transportation manager
 83   // GetWorld methods create a clone of the ma <<  74   ghostWorld = GetWorld();
 84   //  via the transportation manager           <<  75   G4LogicalVolume* worldLogical = ghostWorld->GetLogicalVolume();
 85   fGhostWorld = GetWorld();                    << 
 86   G4cout << " B02ImportanceDetectorConstructio << 
 87          << G4endl;                            << 
 88   G4LogicalVolume* worldLogical = fGhostWorld- << 
 89   fLogicalVolumeVector.push_back(worldLogical)     76   fLogicalVolumeVector.push_back(worldLogical);
 90                                                    77 
                                                   >>  78   G4String name("none");
                                                   >>  79   G4double density(universe_mean_density), temperature(0), pressure(0);
                                                   >>  80 
                                                   >>  81   name = "Galactic";
                                                   >>  82   density     = universe_mean_density;            //from PhysicalConstants.h
                                                   >>  83   pressure    = 3.e-18*pascal;
                                                   >>  84   temperature = 2.73*kelvin;
                                                   >>  85   G4cout << density << " " << kStateGas << G4endl;
                                                   >>  86   G4Material *Galactic = 
                                                   >>  87     new G4Material(name, 1., 1.01*g/mole, density,
                                                   >>  88                    kStateGas,temperature,pressure);
                                                   >>  89 
                                                   >>  90 
 91   //  fPVolumeStore.AddPVolume(G4GeometryCell(     91   //  fPVolumeStore.AddPVolume(G4GeometryCell(*pWorldVolume, 0));
 92   fPVolumeStore.AddPVolume(G4GeometryCell(*fGh <<  92   fPVolumeStore.AddPVolume(G4GeometryCell(*ghostWorld, 0));
                                                   >>  93 
 93                                                    94 
 94   // creating 18 slobs of 10 cm thicknes       << 
 95                                                    95 
 96   G4double innerRadiusShield = 0 * cm;         << 
 97   G4double outerRadiusShield = 100 * cm;       << 
 98   G4double heightShield = 5 * cm;              << 
 99   G4double startAngleShield = 0 * deg;         << 
100   G4double spanningAngleShield = 360 * deg;    << 
101                                                    96 
102   G4Tubs* aShield = new G4Tubs("aShield", inne <<  97   // creating 18 slobs of 10 cm thicknes
103                                startAngleShiel << 
104                                                    98 
                                                   >>  99   G4double innerRadiusShield = 0*cm;
                                                   >> 100   G4double outerRadiusShield = 100*cm;
                                                   >> 101   G4double hightShield       = 5*cm;
                                                   >> 102   G4double startAngleShield  = 0*deg;
                                                   >> 103   G4double spanningAngleShield    = 360*deg;
                                                   >> 104 
                                                   >> 105   G4Tubs *aShield = new G4Tubs("aShield",
                                                   >> 106                                innerRadiusShield,
                                                   >> 107                                outerRadiusShield,
                                                   >> 108                                hightShield,
                                                   >> 109                                startAngleShield,
                                                   >> 110                                spanningAngleShield);
                                                   >> 111   
105   // logical parallel cells                       112   // logical parallel cells
106                                                   113 
107   G4LogicalVolume* aShield_log_imp = new G4Log << 114   G4LogicalVolume *aShield_log = 
108   fLogicalVolumeVector.push_back(aShield_log_i << 115     new G4LogicalVolume(aShield, Galactic, "aShield_log");
                                                   >> 116   fLogicalVolumeVector.push_back(aShield_log);
109                                                   117 
110   // physical parallel cells                      118   // physical parallel cells
111   G4String name = "none";                      << 119 
112   G4int i = 1;                                    120   G4int i = 1;
113   G4double startz = -85 * cm;                  << 121   G4double startz = -85*cm; 
114   //  for (i=1; i<=18; ++i) {                     122   //  for (i=1; i<=18; ++i) {
115   for (i = 1; i <= 18; i++) {                  << 123   for (i=1; i<=18; i++) {
                                                   >> 124    
116     name = GetCellName(i);                        125     name = GetCellName(i);
117                                                << 126     
118     G4double pos_x = 0 * cm;                   << 127     G4double pos_x = 0*cm;
119     G4double pos_y = 0 * cm;                   << 128     G4double pos_y = 0*cm;
120     G4double pos_z = startz + (i - 1) * (2 * h << 129     G4double pos_z = startz + (i-1) * (2*hightShield);
121     G4VPhysicalVolume* pvol = new G4PVPlacemen << 130     G4VPhysicalVolume *pvol = 
122                                                << 131       new G4PVPlacement(0, 
                                                   >> 132                         G4ThreeVector(pos_x, pos_y, pos_z),
                                                   >> 133                         aShield_log, 
                                                   >> 134                         name, 
                                                   >> 135                         worldLogical, 
                                                   >> 136                         false, 
                                                   >> 137                         i);
123     //                        0);                 138     //                        0);
124     G4GeometryCell cell(*pvol, i);                139     G4GeometryCell cell(*pvol, i);
125     //    G4GeometryCell cell(*pvol, 0);          140     //    G4GeometryCell cell(*pvol, 0);
126     fPVolumeStore.AddPVolume(cell);               141     fPVolumeStore.AddPVolume(cell);
127   }                                               142   }
128                                                   143 
129   // filling the rest of the world volumr behi    144   // filling the rest of the world volumr behind the concrete with
130   // another slob which should get the same im << 145   // another slob which should get the same importance value as the 
131   // last slob                                    146   // last slob
132   innerRadiusShield = 0 * cm;                  << 147   innerRadiusShield = 0*cm;
133   //  outerRadiusShield = 110*cm; exceeds worl    148   //  outerRadiusShield = 110*cm; exceeds world volume!!!!
134   outerRadiusShield = 100 * cm;                << 149   outerRadiusShield = 101*cm;
135   //  heightShield       = 10*cm;              << 150   //  hightShield       = 10*cm;
136   heightShield = 5 * cm;                       << 151   hightShield       = 5*cm;
137   startAngleShield = 0 * deg;                  << 152   startAngleShield  = 0*deg;
138   spanningAngleShield = 360 * deg;             << 153   spanningAngleShield    = 360*deg;
139                                                << 154 
140   G4Tubs* aRest = new G4Tubs("Rest", innerRadi << 155   G4Tubs *aRest = new G4Tubs("Rest",
141                              startAngleShield, << 156                              innerRadiusShield,
142                                                << 157                              outerRadiusShield,
143   G4LogicalVolume* aRest_log = new G4LogicalVo << 158                              hightShield,
                                                   >> 159                              startAngleShield,
                                                   >> 160                              spanningAngleShield);
                                                   >> 161   
                                                   >> 162   G4LogicalVolume *aRest_log = 
                                                   >> 163     new G4LogicalVolume(aRest, Galactic, "aRest_log");
144                                                   164 
145   fLogicalVolumeVector.push_back(aRest_log);      165   fLogicalVolumeVector.push_back(aRest_log);
146                                                   166 
147   name = GetCellName(19);                         167   name = GetCellName(19);
148                                                << 168     
149   G4double pos_x = 0 * cm;                     << 169   G4double pos_x = 0*cm;
150   G4double pos_y = 0 * cm;                     << 170   G4double pos_y = 0*cm;
151   //  G4double pos_z = 100*cm;                    171   //  G4double pos_z = 100*cm;
152   G4double pos_z = 95 * cm;                    << 172   G4double pos_z = 95*cm;
153   G4VPhysicalVolume* pvol = new G4PVPlacement( << 173   G4VPhysicalVolume *pvol = 
154                                                << 174     new G4PVPlacement(0, 
                                                   >> 175                       G4ThreeVector(pos_x, pos_y, pos_z),
                                                   >> 176                       aRest_log, 
                                                   >> 177                       name, 
                                                   >> 178                       worldLogical, 
                                                   >> 179                       false, 
                                                   >> 180                       19);
155   //                      0);                     181   //                      0);
156   G4GeometryCell cell(*pvol, 19);                 182   G4GeometryCell cell(*pvol, 19);
157   //  G4GeometryCell cell(*pvol, 0);              183   //  G4GeometryCell cell(*pvol, 0);
158   fPVolumeStore.AddPVolume(cell);                 184   fPVolumeStore.AddPVolume(cell);
159                                                   185 
160   SetSensitive();                                 186   SetSensitive();
161 }                                              << 
162                                                   187 
163 //....oooOO0OOooo........oooOO0OOooo........oo << 188 }
164                                                   189 
165 const G4VPhysicalVolume&                       << 190 const G4VPhysicalVolume &B02ImportanceDetectorConstruction::
166 B02ImportanceDetectorConstruction::GetPhysical << 191 GetPhysicalVolumeByName(const G4String& name) const {
167 {                                              << 
168   return *fPVolumeStore.GetPVolume(name);         192   return *fPVolumeStore.GetPVolume(name);
169 }                                                 193 }
170                                                   194 
171 //....oooOO0OOooo........oooOO0OOooo........oo << 
172                                                   195 
173 G4String B02ImportanceDetectorConstruction::Li << 196 G4String B02ImportanceDetectorConstruction::ListPhysNamesAsG4String(){
174 {                                              << 
175   G4String names(fPVolumeStore.GetPNames());      197   G4String names(fPVolumeStore.GetPNames());
176   return names;                                   198   return names;
177 }                                                 199 }
178                                                   200 
179 //....oooOO0OOooo........oooOO0OOooo........oo << 
180                                                   201 
181 G4String B02ImportanceDetectorConstruction::Ge << 202 G4String B02ImportanceDetectorConstruction::GetCellName(G4int i) {
182 {                                              << 
183   std::ostringstream os;                          203   std::ostringstream os;
184   os << "cell_";                                  204   os << "cell_";
185   if (i < 10) {                                << 205   if (i<10) {
186     os << "0";                                    206     os << "0";
187   }                                               207   }
188   os << i;                                        208   os << i;
189   G4String name = os.str();                       209   G4String name = os.str();
190   return name;                                    210   return name;
191 }                                                 211 }
192                                                   212 
193 //....oooOO0OOooo........oooOO0OOooo........oo << 213 G4GeometryCell B02ImportanceDetectorConstruction::GetGeometryCell(G4int i){
194                                                << 
195 G4GeometryCell B02ImportanceDetectorConstructi << 
196 {                                              << 
197   G4String name(GetCellName(i));                  214   G4String name(GetCellName(i));
198   const G4VPhysicalVolume* p = 0;              << 215   const G4VPhysicalVolume *p=0;
199   p = fPVolumeStore.GetPVolume(name);             216   p = fPVolumeStore.GetPVolume(name);
200   if (p) {                                        217   if (p) {
201     return G4GeometryCell(*p, 0);              << 218     return G4GeometryCell(*p,0);
202   }                                               219   }
203   else {                                          220   else {
204     G4cout << "B02ImportanceDetectorConstructi << 221     G4cout << "B02ImportanceDetectorConstruction::GetGeometryCell: couldn't get G4GeometryCell" << G4endl;
205            << " couldn't get G4GeometryCell" < << 222     return G4GeometryCell(*ghostWorld,-2);
206     return G4GeometryCell(*fGhostWorld, -2);   << 
207   }                                               223   }
208 }                                                 224 }
209                                                   225 
210 //....oooOO0OOooo........oooOO0OOooo........oo << 
211                                                   226 
212 G4VPhysicalVolume& B02ImportanceDetectorConstr << 227 G4VPhysicalVolume &B02ImportanceDetectorConstruction::GetWorldVolumeAddress() const{
213 {                                              << 228    return *ghostWorld;
214   return *fGhostWorld;                         << 
215 }                                                 229 }
216                                                   230 
217 //....oooOO0OOooo........oooOO0OOooo........oo << 231 G4VPhysicalVolume *B02ImportanceDetectorConstruction::GetWorldVolume() {
218                                                << 232   return ghostWorld;
219 G4VPhysicalVolume* B02ImportanceDetectorConstr << 
220 {                                              << 
221   return fGhostWorld;                          << 
222 }                                                 233 }
223                                                   234 
224 //....oooOO0OOooo........oooOO0OOooo........oo << 
225                                                   235 
226 void B02ImportanceDetectorConstruction::SetSen << 236 void B02ImportanceDetectorConstruction::SetSensitive(){
227 {                                              << 237 
228   //  ----------------------------------------    238   //  -------------------------------------------------
229   //   The collection names of defined Primiti    239   //   The collection names of defined Primitives are
230   //   0       ConcreteSD/Collisions              240   //   0       ConcreteSD/Collisions
231   //   1       ConcreteSD/CollWeight              241   //   1       ConcreteSD/CollWeight
232   //   2       ConcreteSD/Population              242   //   2       ConcreteSD/Population
233   //   3       ConcreteSD/TrackEnter              243   //   3       ConcreteSD/TrackEnter
234   //   4       ConcreteSD/SL                      244   //   4       ConcreteSD/SL
235   //   5       ConcreteSD/SLW                     245   //   5       ConcreteSD/SLW
236   //   6       ConcreteSD/SLWE                    246   //   6       ConcreteSD/SLWE
237   //   7       ConcreteSD/SLW_V                   247   //   7       ConcreteSD/SLW_V
238   //   8       ConcreteSD/SLWE_V                  248   //   8       ConcreteSD/SLWE_V
239   //  ----------------------------------------    249   //  -------------------------------------------------
240                                                   250 
241   // moved to ConstructSD() for MT compliance  << 
242 }                                              << 
243                                                   251 
244 //....oooOO0OOooo........oooOO0OOooo........oo << 252   //================================================
245 void B02ImportanceDetectorConstruction::Constr << 253   // Sensitive detectors : MultiFunctionalDetector
246 {                                              << 254   //================================================
                                                   >> 255   //
                                                   >> 256   //  Sensitive Detector Manager.
                                                   >> 257 
247   G4SDManager* SDman = G4SDManager::GetSDMpoin    258   G4SDManager* SDman = G4SDManager::GetSDMpointer();
248   //                                              259   //
249   // Sensitive Detector Name                      260   // Sensitive Detector Name
250   G4String concreteSDname = "ConcreteSD";         261   G4String concreteSDname = "ConcreteSD";
251                                                   262 
252   //------------------------                      263   //------------------------
253   // MultiFunctionalDetector                      264   // MultiFunctionalDetector
254   //------------------------                      265   //------------------------
255   //                                              266   //
256   // Define MultiFunctionalDetector with name.    267   // Define MultiFunctionalDetector with name.
257   G4MultiFunctionalDetector* MFDet = new G4Mul    268   G4MultiFunctionalDetector* MFDet = new G4MultiFunctionalDetector(concreteSDname);
258   SDman->AddNewDetector(MFDet);  // Register S << 269   SDman->AddNewDetector( MFDet );                 // Register SD to SDManager
                                                   >> 270 
259                                                   271 
260   G4String fltName, particleName;              << 272   G4String fltName,particleName;
261   G4SDParticleFilter* neutronFilter =          << 273   G4SDParticleFilter* neutronFilter = 
262     new G4SDParticleFilter(fltName = "neutronF << 274       new G4SDParticleFilter(fltName="neutronFilter", particleName="neutron");
263                                                   275 
264   MFDet->SetFilter(neutronFilter);                276   MFDet->SetFilter(neutronFilter);
265                                                   277 
266   for (std::vector<G4LogicalVolume*>::iterator << 278 
267        it != fLogicalVolumeVector.end(); it++) << 279   for (std::vector<G4LogicalVolume *>::iterator it =  fLogicalVolumeVector.begin();
268   {                                            << 280        it != fLogicalVolumeVector.end(); it++){
269     //      (*it)->SetSensitiveDetector(MFDet) << 281       (*it)->SetSensitiveDetector(MFDet);
270     SetSensitiveDetector((*it)->GetName(), MFD << 
271   }                                               282   }
272                                                   283 
273   G4String psName;                                284   G4String psName;
274   G4PSNofCollision* scorer0 = new G4PSNofColli << 285   G4PSNofCollision*   scorer0 = new G4PSNofCollision(psName="Collisions");  
275   MFDet->RegisterPrimitive(scorer0);              286   MFDet->RegisterPrimitive(scorer0);
276                                                   287 
277   G4PSNofCollision* scorer1 = new G4PSNofColli << 288 
                                                   >> 289   G4PSNofCollision*   scorer1 = new G4PSNofCollision(psName="CollWeight");  
278   scorer1->Weighted(true);                        290   scorer1->Weighted(true);
279   MFDet->RegisterPrimitive(scorer1);              291   MFDet->RegisterPrimitive(scorer1);
280                                                   292 
281   G4PSPopulation* scorer2 = new G4PSPopulation << 293 
                                                   >> 294   G4PSPopulation*   scorer2 = new G4PSPopulation(psName="Population");  
282   MFDet->RegisterPrimitive(scorer2);              295   MFDet->RegisterPrimitive(scorer2);
283                                                   296 
284   G4PSTrackCounter* scorer3 = new G4PSTrackCou << 297   G4PSTrackCounter* scorer3 = new G4PSTrackCounter(psName="TrackEnter",fCurrent_In);  
285   MFDet->RegisterPrimitive(scorer3);              298   MFDet->RegisterPrimitive(scorer3);
286                                                   299 
287   G4PSTrackLength* scorer4 = new G4PSTrackLeng << 300   G4PSTrackLength* scorer4 = new G4PSTrackLength(psName="SL");  
288   MFDet->RegisterPrimitive(scorer4);              301   MFDet->RegisterPrimitive(scorer4);
289                                                   302 
290   G4PSTrackLength* scorer5 = new G4PSTrackLeng << 303   G4PSTrackLength* scorer5 = new G4PSTrackLength(psName="SLW");  
291   scorer5->Weighted(true);                        304   scorer5->Weighted(true);
292   MFDet->RegisterPrimitive(scorer5);              305   MFDet->RegisterPrimitive(scorer5);
293                                                   306 
294   G4PSTrackLength* scorer6 = new G4PSTrackLeng << 307   G4PSTrackLength* scorer6 = new G4PSTrackLength(psName="SLWE");  
295   scorer6->Weighted(true);                        308   scorer6->Weighted(true);
296   scorer6->MultiplyKineticEnergy(true);           309   scorer6->MultiplyKineticEnergy(true);
297   MFDet->RegisterPrimitive(scorer6);              310   MFDet->RegisterPrimitive(scorer6);
298                                                   311 
299   G4PSTrackLength* scorer7 = new G4PSTrackLeng << 312   G4PSTrackLength* scorer7 = new G4PSTrackLength(psName="SLW_V");  
300   scorer7->Weighted(true);                        313   scorer7->Weighted(true);
301   scorer7->DivideByVelocity(true);                314   scorer7->DivideByVelocity(true);
302   MFDet->RegisterPrimitive(scorer7);              315   MFDet->RegisterPrimitive(scorer7);
303                                                   316 
304   G4PSTrackLength* scorer8 = new G4PSTrackLeng << 317   G4PSTrackLength* scorer8 = new G4PSTrackLength(psName="SLWE_V");  
305   scorer8->Weighted(true);                        318   scorer8->Weighted(true);
306   scorer8->MultiplyKineticEnergy(true);           319   scorer8->MultiplyKineticEnergy(true);
307   scorer8->DivideByVelocity(true);                320   scorer8->DivideByVelocity(true);
308   MFDet->RegisterPrimitive(scorer8);              321   MFDet->RegisterPrimitive(scorer8);
309 }                                              << 
310                                                << 
311 //....oooOO0OOooo........oooOO0OOooo........oo << 
312 G4VIStore* B02ImportanceDetectorConstruction:: << 
313 {                                              << 
314   G4cout << " B02ImportanceDetectorConstructio << 
315   if (!fPVolumeStore.Size()) {                 << 
316     G4Exception("B02ImportanceDetectorConstruc << 
317                 RunMustBeAborted, "no physical << 
318   }                                            << 
319                                                << 
320   // creating and filling the importance store << 
321                                                << 
322   //  G4IStore *istore = new G4IStore(*fWorldV << 
323                                                << 
324   G4IStore* istore = G4IStore::GetInstance(Get << 
325                                                << 
326   G4GeometryCell gWorldVolumeCell(GetWorldVolu << 
327                                                << 
328   G4double imp = 1;                            << 
329                                                << 
330   istore->AddImportanceGeometryCell(1, gWorldV << 
331                                                << 
332   // set importance values and create scorers  << 
333   G4int cell(1);                               << 
334   for (cell = 1; cell <= 18; cell++) {         << 
335     G4GeometryCell gCell = GetGeometryCell(cel << 
336     G4cout << " adding cell: " << cell << " re << 
337            << " name: " << gCell.GetPhysicalVo << 
338     imp = std::pow(2.0, cell - 1);             << 
339                                                << 
340     G4cout << "Going to assign importance: " < << 
341            << ", to volume: " << gCell.GetPhys << 
342     // x    aIstore.AddImportanceGeometryCell( << 
343     istore->AddImportanceGeometryCell(imp, gCe << 
344   }                                            << 
345                                                << 
346   // creating the geometry cell and add both t << 
347   //  G4GeometryCell gCell = GetGeometryCell(1 << 
348                                                << 
349   // create importance geometry cell pair for  << 
350   // with the same importance as the last conc << 
351   G4GeometryCell gCell = GetGeometryCell(19);  << 
352   //  G4double imp = std::pow(2.0,18);         << 
353   imp = std::pow(2.0, 17);                     << 
354   istore->AddImportanceGeometryCell(imp, gCell << 
355                                                << 
356   return istore;                               << 
357 }                                              << 
358                                                << 
359 //....oooOO0OOooo........oooOO0OOooo........oo << 
360                                                << 
361 G4VWeightWindowStore* B02ImportanceDetectorCon << 
362 {                                              << 
363   G4cout << " B02ImportanceDetectorConstructio << 
364   if (!fPVolumeStore.Size()) {                 << 
365     G4Exception("B02ImportanceDetectorConstruc << 
366                 RunMustBeAborted, "no physical << 
367   }                                            << 
368                                                << 
369   // creating and filling the importance store << 
370                                                << 
371   //  G4IStore *istore = new G4IStore(*fWorldV << 
372                                                << 
373   G4WeightWindowStore* wwstore = G4WeightWindo << 
374                                                << 
375   // create one energy region covering the ene << 
376   //                                           << 
377   std::set<G4double, std::less<G4double>> enBo << 
378   enBounds.insert(1 * GeV);                    << 
379   wwstore->SetGeneralUpperEnergyBounds(enBound << 
380                                                << 
381   G4int n = 0;                                 << 
382   G4double lowerWeight = 1;                    << 
383   std::vector<G4double> lowerWeights;          << 
384                                                << 
385   lowerWeights.push_back(1);                   << 
386   G4GeometryCell gWorldCell(GetWorldVolumeAddr << 
387   wwstore->AddLowerWeights(gWorldCell, lowerWe << 
388                                                << 
389   G4int cell(1);                               << 
390   for (cell = 1; cell <= 18; cell++) {         << 
391     G4GeometryCell gCell = GetGeometryCell(cel << 
392     G4cout << " adding cell: " << cell << " re << 
393            << " name: " << gCell.GetPhysicalVo << 
394                                                << 
395     lowerWeight = 1. / std::pow(2., n++);      << 
396     G4cout << "Going to assign lower weight: " << 
397            << ", to volume: " << gCell.GetPhys << 
398     lowerWeights.clear();                      << 
399     lowerWeights.push_back(lowerWeight);       << 
400     wwstore->AddLowerWeights(gCell, lowerWeigh << 
401   }                                            << 
402                                                << 
403   // the remaining part pf the geometry (rest) << 
404   // lower weight bound  as the last conrete c << 
405   //                                           << 
406                                                << 
407   // create importance geometry cell pair for  << 
408   // with the same importance as the last conc << 
409   G4GeometryCell gCell = GetGeometryCell(19);  << 
410   wwstore->AddLowerWeights(gCell, lowerWeights << 
411                                                   322 
412   return wwstore;                              << 
413 }                                                 323 }
414                                                   324