Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/volumes/src/G4AssemblyVolume.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 /geometry/volumes/src/G4AssemblyVolume.cc (Version 11.3.0) and /geometry/volumes/src/G4AssemblyVolume.cc (Version 10.5.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 //
                                                   >>  26 //
                                                   >>  27 //
 25 //                                                 28 // 
 26 // Class G4AssemblyVolume - implementation         29 // Class G4AssemblyVolume - implementation
 27 //                                                 30 //
 28 // Author: Radovan Chytracek, CERN - November  <<  31 // ----------------------------------------------------------------------
 29 // ------------------------------------------- << 
 30                                                    32 
 31 #include "G4AssemblyVolume.hh"                     33 #include "G4AssemblyVolume.hh"
 32 #include "G4AssemblyStore.hh"                      34 #include "G4AssemblyStore.hh"
 33 #include "G4PVPlacement.hh"                        35 #include "G4PVPlacement.hh"
 34 #include "G4RotationMatrix.hh"                     36 #include "G4RotationMatrix.hh"
 35 #include "G4AffineTransform.hh"                    37 #include "G4AffineTransform.hh"
 36 #include "G4LogicalVolume.hh"                      38 #include "G4LogicalVolume.hh"
 37 #include "G4VPhysicalVolume.hh"                    39 #include "G4VPhysicalVolume.hh"
 38 #include "G4ReflectionFactory.hh"                  40 #include "G4ReflectionFactory.hh"
 39                                                    41 
 40 #include <sstream>                                 42 #include <sstream>
 41                                                    43 
 42 G4ThreadLocal unsigned int G4AssemblyVolume::f     44 G4ThreadLocal unsigned int G4AssemblyVolume::fsInstanceCounter = 0;
 43                                                    45 
 44 // ------------------------------------------- << 
 45 // Default constructor                             46 // Default constructor
 46 //                                                 47 //
 47 G4AssemblyVolume::G4AssemblyVolume()               48 G4AssemblyVolume::G4AssemblyVolume()
                                                   >>  49   : fAssemblyID( 0 )
 48 {                                                  50 {
 49   InstanceCountPlus();                             51   InstanceCountPlus();
 50   SetAssemblyID( GetInstanceCount() );             52   SetAssemblyID( GetInstanceCount() );
 51   SetImprintsCount( 0 );                           53   SetImprintsCount( 0 );
 52   G4AssemblyStore* aStore = G4AssemblyStore::G     54   G4AssemblyStore* aStore = G4AssemblyStore::GetInstance();
 53   if (aStore->GetAssembly(fAssemblyID,false) ! <<  55   if (aStore->GetAssembly(fAssemblyID,false))
 54   {                                                56   {
 55     std::ostringstream message;                    57     std::ostringstream message;
 56     message << "The assembly has NOT been regi     58     message << "The assembly has NOT been registered !" << G4endl
 57             << "          Assembly " << fAssem     59             << "          Assembly " << fAssemblyID
 58             << " already existing in store !"      60             << " already existing in store !" << G4endl;
 59     G4Exception("G4AssemblyVolume::G4AssemblyV     61     G4Exception("G4AssemblyVolume::G4AssemblyVolume()", "GeomVol1001",
 60                 JustWarning, message);             62                 JustWarning, message);
 61   }                                                63   }
 62   else                                             64   else
 63   {                                                65   {
 64     aStore->Register(this);                        66     aStore->Register(this);
 65   }                                                67   }
 66 }                                                  68 }
 67                                                    69 
 68 // ------------------------------------------- << 
 69 // Composing constructor                           70 // Composing constructor
 70 //                                                 71 //
 71 G4AssemblyVolume::G4AssemblyVolume( G4LogicalV     72 G4AssemblyVolume::G4AssemblyVolume( G4LogicalVolume* volume,
 72                                     G4ThreeVec     73                                     G4ThreeVector& translation,
 73                                     G4Rotation     74                                     G4RotationMatrix* rotation )
                                                   >>  75   : fAssemblyID( 0 )
 74 {                                                  76 {
 75   InstanceCountPlus();                             77   InstanceCountPlus();
 76   SetAssemblyID( GetInstanceCount() );             78   SetAssemblyID( GetInstanceCount() );
 77   SetImprintsCount( 0 );                           79   SetImprintsCount( 0 );
 78   AddPlacedVolume(volume, translation, rotatio     80   AddPlacedVolume(volume, translation, rotation);
 79   G4AssemblyStore* aStore = G4AssemblyStore::G     81   G4AssemblyStore* aStore = G4AssemblyStore::GetInstance();
 80   if (aStore->GetAssembly(fAssemblyID,false) ! <<  82   if (aStore->GetAssembly(fAssemblyID,false))
 81   {                                                83   {
 82     std::ostringstream message;                    84     std::ostringstream message;
 83     message << "The assembly has NOT been regi     85     message << "The assembly has NOT been registered !" << G4endl
 84             << "          Assembly " << fAssem     86             << "          Assembly " << fAssemblyID
 85             << " already existing in store !"      87             << " already existing in store !" << G4endl;
 86     G4Exception("G4Assembly::G4Assembly()", "G     88     G4Exception("G4Assembly::G4Assembly()", "GeomVol1001",
 87                 JustWarning, message);             89                 JustWarning, message);
 88   }                                                90   }
 89   else                                             91   else
 90   {                                                92   {
 91     aStore->Register(this);                        93     aStore->Register(this);
 92   }                                                94   }
 93 }                                                  95 }
 94                                                    96 
 95 // ------------------------------------------- << 
 96 // Destructor                                      97 // Destructor
 97 //                                                 98 //
 98 G4AssemblyVolume::~G4AssemblyVolume()              99 G4AssemblyVolume::~G4AssemblyVolume()
 99 {                                                 100 {
100   std::size_t howmany = fTriplets.size();      << 101   unsigned int howmany = fTriplets.size();
101   if( howmany != 0 )                              102   if( howmany != 0 )
102   {                                               103   {
103     for( std::size_t i = 0; i < howmany; ++i ) << 104     for( unsigned int i = 0; i < howmany; ++i )
104     {                                             105     {
105       G4RotationMatrix* pRotToClean = fTriplet    106       G4RotationMatrix* pRotToClean = fTriplets[i].GetRotation();
106       delete pRotToClean;                      << 107       if( pRotToClean != 0 )
                                                   >> 108       {
                                                   >> 109         delete pRotToClean;
                                                   >> 110       }
107     }                                             111     }
108   }                                               112   }
109   fTriplets.clear();                              113   fTriplets.clear();
110                                                   114   
111   // No need to delete physical volumes, as th    115   // No need to delete physical volumes, as these are deleted
112   // by physical-volumes store.                   116   // by physical-volumes store.
113   //                                              117   //
114   fPVStore.clear();                               118   fPVStore.clear();
115   InstanceCountMinus();                           119   InstanceCountMinus();
116   G4AssemblyStore::GetInstance()->DeRegister(t    120   G4AssemblyStore::GetInstance()->DeRegister(this);
117 }                                                 121 }
118                                                   122 
119 // ------------------------------------------- << 
120 // Add and place the given volume according to    123 // Add and place the given volume according to the specified
121 // translation and rotation.                      124 // translation and rotation.
122 //                                                125 //
123 // The rotation matrix passed in can be 0 = id    126 // The rotation matrix passed in can be 0 = identity or an address even of an
124 // object on the upper stack frame. During ass    127 // object on the upper stack frame. During assembly imprint, it creates anyway
125 // a new matrix and keeps track of it so it ca    128 // a new matrix and keeps track of it so it can delete it later at destruction
126 // time.                                          129 // time.
127 // This policy has been adopted since user has    130 // This policy has been adopted since user has no control on the way the
128 // rotations are combined.                        131 // rotations are combined.
129 //                                                132 //
130 void G4AssemblyVolume::AddPlacedVolume( G4Logi    133 void G4AssemblyVolume::AddPlacedVolume( G4LogicalVolume*  pVolume,
131                                         G4Thre    134                                         G4ThreeVector&    translation,
132                                         G4Rota    135                                         G4RotationMatrix* pRotation )
133 {                                                 136 {
134   auto toStore = new G4RotationMatrix;         << 137   G4RotationMatrix*  toStore  = new G4RotationMatrix;
135                                                   138   
136   if( pRotation != nullptr )  { *toStore = *pR << 139   if( pRotation != 0 )  { *toStore = *pRotation; }
137                                                   140   
138   G4AssemblyTriplet toAdd( pVolume, translatio    141   G4AssemblyTriplet toAdd( pVolume, translation, toStore );
139   fTriplets.push_back( toAdd );                   142   fTriplets.push_back( toAdd );
140 }                                                 143 }
141                                                   144 
142 // ------------------------------------------- << 
143 // Add and place the given volume according to    145 // Add and place the given volume according to the specified transformation
144 //                                                146 //
145 void G4AssemblyVolume::AddPlacedVolume( G4Logi    147 void G4AssemblyVolume::AddPlacedVolume( G4LogicalVolume*  pVolume,
146                                         G4Tran    148                                         G4Transform3D&    transformation )
147 {                                                 149 {
148   // Decompose transformation                     150   // Decompose transformation
149   G4Scale3D     scale;                            151   G4Scale3D     scale;
150   G4Rotate3D    rotation;                         152   G4Rotate3D    rotation;
151   G4Translate3D translation;                      153   G4Translate3D translation;
152   transformation.getDecomposition(scale, rotat    154   transformation.getDecomposition(scale, rotation, translation);
153                                                   155 
154   G4ThreeVector v = translation.getTranslation << 156   G4ThreeVector      v = translation.getTranslation();
155   auto r = new G4RotationMatrix;               << 157   G4RotationMatrix*  r = new G4RotationMatrix;
156       *r = rotation.getRotation();             << 158                     *r = rotation.getRotation();
157                                                   159   
158   G4bool isReflection = false;                    160   G4bool isReflection = false;
159   if (scale(0,0)*scale(1,1)*scale(2,2) < 0.)      161   if (scale(0,0)*scale(1,1)*scale(2,2) < 0.)  { isReflection = true; }
160                                                   162 
161   G4AssemblyTriplet toAdd( pVolume, v, r, isRe    163   G4AssemblyTriplet toAdd( pVolume, v, r, isReflection );
162   fTriplets.push_back( toAdd );                   164   fTriplets.push_back( toAdd );
163 }                                                 165 }
164                                                   166 
165 // ------------------------------------------- << 
166 // Add and place the given assembly volume acc    167 // Add and place the given assembly volume according to the specified
167 // translation and rotation.                      168 // translation and rotation.
168 //                                                169 //
169 void G4AssemblyVolume::AddPlacedAssembly( G4As    170 void G4AssemblyVolume::AddPlacedAssembly( G4AssemblyVolume* pAssembly,
170                                           G4Th    171                                           G4ThreeVector&    translation,
171                                           G4Ro    172                                           G4RotationMatrix* pRotation )
172 {                                                 173 {
173   auto toStore = new G4RotationMatrix;         << 174   G4RotationMatrix*  toStore  = new G4RotationMatrix;
174                                                   175   
175   if( pRotation != nullptr )  { *toStore = *pR << 176   if( pRotation != 0 )  { *toStore = *pRotation; }
176                                                   177   
177   G4AssemblyTriplet toAdd( pAssembly, translat    178   G4AssemblyTriplet toAdd( pAssembly, translation, toStore );
178   fTriplets.push_back( toAdd );                   179   fTriplets.push_back( toAdd );
179 }                                                 180 }
180                                                   181 
181 // ------------------------------------------- << 
182 // Add and place the given assembly volume acc    182 // Add and place the given assembly volume according to the specified 
183 // transformation                                 183 // transformation
184 //                                                184 //
185 void G4AssemblyVolume::AddPlacedAssembly( G4As    185 void G4AssemblyVolume::AddPlacedAssembly( G4AssemblyVolume* pAssembly,
186                                           G4Tr    186                                           G4Transform3D&    transformation )
187 {                                                 187 {
188   // Decompose transformation                     188   // Decompose transformation
189   //                                              189   //
190   G4Scale3D     scale;                            190   G4Scale3D     scale;
191   G4Rotate3D    rotation;                         191   G4Rotate3D    rotation;
192   G4Translate3D translation;                      192   G4Translate3D translation;
193   transformation.getDecomposition(scale, rotat    193   transformation.getDecomposition(scale, rotation, translation);
194                                                   194 
195   G4ThreeVector      v = translation.getTransl    195   G4ThreeVector      v = translation.getTranslation();
196   auto r = new G4RotationMatrix;               << 196   G4RotationMatrix*  r = new G4RotationMatrix;
197       *r = rotation.getRotation();             << 197                     *r = rotation.getRotation();
198                                                   198   
199   G4bool isReflection = false;                    199   G4bool isReflection = false;
200   if (scale(0,0)*scale(1,1)*scale(2,2) < 0.)      200   if (scale(0,0)*scale(1,1)*scale(2,2) < 0.)  { isReflection = true; }
201                                                   201   
202   G4AssemblyTriplet toAdd( pAssembly, v, r, is    202   G4AssemblyTriplet toAdd( pAssembly, v, r, isReflection );
203   fTriplets.push_back( toAdd );                   203   fTriplets.push_back( toAdd );
204 }                                                 204 }
205                                                   205 
206 // ------------------------------------------- << 
207 // Create an instance of an assembly volume in    206 // Create an instance of an assembly volume inside of the specified
208 // mother volume. This works analogically to m    207 // mother volume. This works analogically to making stamp imprints.
209 // This method makes use of the Geant4 affine     208 // This method makes use of the Geant4 affine transformation class.
210 // The algorithm is defined as follows:           209 // The algorithm is defined as follows:
211 //                                                210 //  
212 // Having rotation matrix Rm and translation v    211 // Having rotation matrix Rm and translation vector Tm to be applied
213 // inside the mother and rotation matrix Ra an    212 // inside the mother and rotation matrix Ra and translation vector Ta
214 // to be applied inside the assembly itself fo    213 // to be applied inside the assembly itself for each of the participating
215 // volumes the resulting transformation is        214 // volumes the resulting transformation is
216 //                                                215 //  
217 // Tfinal = Ta * Tm                               216 // Tfinal = Ta * Tm
218 //                                                217 //  
219 // where Ta and Tm are constructed as             218 // where Ta and Tm are constructed as
220 //                                                219 //  
221 //        -1                                      220 //        -1                                     -1
222 // Ta = Ra  * Ta           and            Tm =    221 // Ta = Ra  * Ta           and            Tm = Rm  * Tm
223 //                                                222 //  
224 // which in words means that we create first t    223 // which in words means that we create first the affine transformations
225 // by inverse rotation matrices and translatio    224 // by inverse rotation matrices and translations for mother and assembly.
226 // The resulting final transformation to be ap    225 // The resulting final transformation to be applied to each of the
227 // participating volumes is their product.        226 // participating volumes is their product.
228 //                                                227 //
229 // IMPORTANT NOTE!                                228 // IMPORTANT NOTE!
230 // The order of multiplication is reversed whe    229 // The order of multiplication is reversed when comparing to CLHEP 3D
231 // transformation matrix(G4Transform3D class).    230 // transformation matrix(G4Transform3D class).
232 //                                                231 //  
233 // The rotation matrix passed in can be 0 = id    232 // The rotation matrix passed in can be 0 = identity or an address even of an
234 // object on the upper stack frame. During ass    233 // object on the upper stack frame. During assembly imprint, it creates anyway
235 // a new matrix and keeps track of it so it ca    234 // a new matrix and keeps track of it so it can delete it later at destruction
236 // time.                                          235 // time.
237 // This policy has been adopted since user has    236 // This policy has been adopted since user has no control on the way the
238 // rotations are combined.                        237 // rotations are combined.
239 //                                                238 // 
240 // If the assembly volume contains assembly (a    239 // If the assembly volume contains assembly (a'), the function is called
241 // recursively with composed transformation:      240 // recursively with composed transformation:
242 //                                                241 //
243 // Tanew =  Ta * Ta'                              242 // Tanew =  Ta * Ta'
244 //                                                243 //
245 void G4AssemblyVolume::MakeImprint( G4Assembly    244 void G4AssemblyVolume::MakeImprint( G4AssemblyVolume* pAssembly,
246                                     G4LogicalV    245                                     G4LogicalVolume*  pMotherLV,
247                                     G4Transfor    246                                     G4Transform3D&    transformation,
248                                     G4int copy    247                                     G4int copyNumBase,
249                                     G4bool sur    248                                     G4bool surfCheck )
250 {                                                 249 {
251   std::size_t numberOfDaughters;               << 250   unsigned int  numberOfDaughters;
252                                                << 251   
253   if( copyNumBase == 0 )                          252   if( copyNumBase == 0 )
254   {                                               253   {
255     numberOfDaughters = pMotherLV->GetNoDaught    254     numberOfDaughters = pMotherLV->GetNoDaughters();
256   }                                               255   }
257   else                                            256   else
258   {                                               257   {
259     numberOfDaughters = copyNumBase;              258     numberOfDaughters = copyNumBase;
260   }                                               259   }
261                                                   260 
262   // We start from the first available index      261   // We start from the first available index
263   //                                              262   //
264   ++numberOfDaughters;                         << 263   numberOfDaughters++;
265                                                   264 
266   ImprintsCountPlus();                            265   ImprintsCountPlus();
267                                                   266   
268   auto triplets = pAssembly->fTriplets;        << 267   std::vector<G4AssemblyTriplet> triplets = pAssembly->fTriplets;
269                                                   268 
270   // store the transformation in a container ( << 269   for( unsigned int   i = 0; i < triplets.size(); i++ )
271   fImprintsTransf[GetImprintsCount()] = transf << 
272                                                << 
273   for( std::size_t i = 0; i < triplets.size(); << 
274   {                                               270   {
275     G4Transform3D Ta( *(triplets[i].GetRotatio    271     G4Transform3D Ta( *(triplets[i].GetRotation()),
276                       triplets[i].GetTranslati    272                       triplets[i].GetTranslation() );
277     if ( triplets[i].IsReflection() )  { Ta =     273     if ( triplets[i].IsReflection() )  { Ta = Ta * G4ReflectZ3D(); }
278                                                   274 
279     G4Transform3D Tfinal = transformation * Ta    275     G4Transform3D Tfinal = transformation * Ta;
280                                                   276     
281     if ( triplets[i].GetVolume() != nullptr )  << 277     if ( triplets[i].GetVolume() )
282     {                                             278     {
283       // Generate the unique name for the next    279       // Generate the unique name for the next PV instance
284       // The name has format:                     280       // The name has format:
285       //                                          281       //
286       // av_WWW_impr_XXX_YYY_ZZZ                  282       // av_WWW_impr_XXX_YYY_ZZZ
287       // where the fields mean:                   283       // where the fields mean:
288       // WWW - assembly volume instance number    284       // WWW - assembly volume instance number
289       // XXX - assembly volume imprint number     285       // XXX - assembly volume imprint number
290       // YYY - the name of a log. volume we wa    286       // YYY - the name of a log. volume we want to make a placement of
291       // ZZZ - the log. volume index inside th    287       // ZZZ - the log. volume index inside the assembly volume
292       //                                          288       //
293       std::stringstream pvName;                   289       std::stringstream pvName;
294       pvName << "av_"                             290       pvName << "av_"
295              << GetAssemblyID()                   291              << GetAssemblyID()
296              << "_impr_"                          292              << "_impr_"
297              << GetImprintsCount()                293              << GetImprintsCount()
298              << "_"                               294              << "_"
299              << triplets[i].GetVolume()->GetNa    295              << triplets[i].GetVolume()->GetName().c_str()
300              << "_pv_"                            296              << "_pv_"
301              << i                                 297              << i
302              << std::ends;                        298              << std::ends;
303                                                   299 
304       // Generate a new physical volume instan    300       // Generate a new physical volume instance inside a mother
305       // (as we allow 3D transformation use G4    301       // (as we allow 3D transformation use G4ReflectionFactory to 
306       //  take into account eventual reflectio    302       //  take into account eventual reflection)
307       //                                          303       //
308       G4PhysicalVolumesPair pvPlaced              304       G4PhysicalVolumesPair pvPlaced
309         = G4ReflectionFactory::Instance()->Pla    305         = G4ReflectionFactory::Instance()->Place( Tfinal,
310                                                   306                                                   pvName.str().c_str(),
311                                                   307                                                   triplets[i].GetVolume(),
312                                                   308                                                   pMotherLV,
313                                                   309                                                   false,
314                                                << 310                                                   numberOfDaughters + i,
315                                                   311                                                   surfCheck );
316                                                   312 
317       // Register the physical volume created     313       // Register the physical volume created by us so we can delete it later
318       //                                          314       //
319       fPVStore.push_back( pvPlaced.first );       315       fPVStore.push_back( pvPlaced.first );
320       if ( pvPlaced.second != nullptr )  { fPV << 316       if ( pvPlaced.second )  { fPVStore.push_back( pvPlaced.second ); }
321                                                << 
322       // Here I want to save the imprint trans << 
323       // imprintTrans[GetImprintsCount()] = tr << 
324                                                << 
325     }                                             317     }
326     else if ( triplets[i].GetAssembly() != nul << 318     else if ( triplets[i].GetAssembly() )
327     {                                             319     {
328       // Place volumes in this assembly with c    320       // Place volumes in this assembly with composed transformation
329       //                                          321       //
330       MakeImprint( triplets[i].GetAssembly(),     322       MakeImprint( triplets[i].GetAssembly(), pMotherLV,
331                    Tfinal, (G4int)i*100+copyNu << 323                    Tfinal, i*100+copyNumBase, surfCheck ); 
332     }                                             324     }
333     else                                          325     else
334     {                                             326     {
335       G4Exception("G4AssemblyVolume::MakeImpri    327       G4Exception("G4AssemblyVolume::MakeImprint(..)",
336                   "GeomVol0003", FatalExceptio    328                   "GeomVol0003", FatalException,
337                   "Triplet has no volume and n    329                   "Triplet has no volume and no assembly");
338     }                                             330     }  
339   }                                               331   }  
340 }                                                 332 }    
341                                                   333 
342 // ------------------------------------------- << 
343 void G4AssemblyVolume::MakeImprint( G4LogicalV    334 void G4AssemblyVolume::MakeImprint( G4LogicalVolume*  pMotherLV,
344                                     G4ThreeVec    335                                     G4ThreeVector&    translationInMother,
345                                     G4Rotation    336                                     G4RotationMatrix* pRotationInMother,
346                                     G4int copy    337                                     G4int copyNumBase,
347                                     G4bool sur    338                                     G4bool surfCheck )
348 {                                                 339 {
349   // If needed user can specify explicitely th    340   // If needed user can specify explicitely the base count from which to start
350   // off for the generation of phys. vol. copy    341   // off for the generation of phys. vol. copy numbers.
351   // The old behaviour is preserved when copyN    342   // The old behaviour is preserved when copyNumBase == 0, e.g. the generated
352   // copy numbers start from the count equal t    343   // copy numbers start from the count equal to current number of daughter
353   // volumes before an imprint is made            344   // volumes before an imprint is made
354                                                   345 
355   // Compose transformation                       346   // Compose transformation
356   //                                              347   //
357   if( pRotationInMother == nullptr )           << 348   if( pRotationInMother == 0 )
358   {                                               349   {
359     // Make it by default an indentity matrix     350     // Make it by default an indentity matrix
360     //                                            351     //
361     pRotationInMother =                           352     pRotationInMother =
362       const_cast<G4RotationMatrix*>( &G4Rotati    353       const_cast<G4RotationMatrix*>( &G4RotationMatrix::IDENTITY );
363   }                                               354   }
364                                                   355 
365   G4Transform3D transform( *pRotationInMother,    356   G4Transform3D transform( *pRotationInMother,
366                             translationInMothe    357                             translationInMother );
367   MakeImprint(this, pMotherLV, transform, copy    358   MakeImprint(this, pMotherLV, transform, copyNumBase, surfCheck);
368 }                                                 359 }
369                                                   360 
370 // ------------------------------------------- << 
371 void G4AssemblyVolume::MakeImprint( G4LogicalV    361 void G4AssemblyVolume::MakeImprint( G4LogicalVolume*  pMotherLV,
372                                     G4Transfor    362                                     G4Transform3D&    transformation,
373                                     G4int copy    363                                     G4int copyNumBase,
374                                     G4bool sur    364                                     G4bool surfCheck )
375 {                                                 365 {
376   // If needed user can specify explicitely th    366   // If needed user can specify explicitely the base count from which to start
377   // off for the generation of phys. vol. copy    367   // off for the generation of phys. vol. copy numbers.
378   // The old behaviour is preserved when copyN    368   // The old behaviour is preserved when copyNumBase == 0, e.g. the generated
379   // copy numbers start from the count equal t    369   // copy numbers start from the count equal to current number of daughter
380   // volumes before a imprint is made             370   // volumes before a imprint is made
381                                                   371 
382   MakeImprint(this, pMotherLV, transformation,    372   MakeImprint(this, pMotherLV, transformation, copyNumBase, surfCheck);
383 }                                                 373 }
384                                                   374 
385 // ------------------------------------------- << 
386 unsigned int G4AssemblyVolume::GetInstanceCoun    375 unsigned int G4AssemblyVolume::GetInstanceCount() const
387 {                                                 376 {
388   return G4AssemblyVolume::fsInstanceCounter;     377   return G4AssemblyVolume::fsInstanceCounter;
389 }                                                 378 }
390                                                   379 
391 // ------------------------------------------- << 
392 void G4AssemblyVolume::SetInstanceCount( unsig    380 void G4AssemblyVolume::SetInstanceCount( unsigned int value )
393 {                                                 381 {
394   G4AssemblyVolume::fsInstanceCounter = value;    382   G4AssemblyVolume::fsInstanceCounter = value;
395 }                                                 383 }
396                                                   384 
397 // ------------------------------------------- << 
398 void G4AssemblyVolume::InstanceCountPlus()        385 void G4AssemblyVolume::InstanceCountPlus()
399 {                                                 386 {
400   G4AssemblyVolume::fsInstanceCounter++;          387   G4AssemblyVolume::fsInstanceCounter++;
401 }                                                 388 }
402                                                   389 
403 // ------------------------------------------- << 
404 void G4AssemblyVolume::InstanceCountMinus()       390 void G4AssemblyVolume::InstanceCountMinus()
405 {                                                 391 {
406   G4AssemblyVolume::fsInstanceCounter--;          392   G4AssemblyVolume::fsInstanceCounter--;
407 }                                                 393 }
408                                                   394