Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/volumes/src/G4PVParameterised.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/G4PVParameterised.cc (Version 11.3.0) and /geometry/volumes/src/G4PVParameterised.cc (Version 10.3)


  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 // $Id: G4PVParameterised.cc 73250 2013-08-22 13:22:23Z gcosmo $
                                                   >>  28 //
 25 //                                                 29 // 
 26 // class G4PVParameterised implementation      <<  30 // class G4PVParameterised
                                                   >>  31 //
                                                   >>  32 // Implementation
 27 //                                                 33 //
 28 // 29.07.95, P.Kent - first non-stub version   << 
 29 // -------------------------------------------     34 // ----------------------------------------------------------------------
 30                                                    35 
 31 #include "G4PVParameterised.hh"                    36 #include "G4PVParameterised.hh"
 32 #include "G4VPVParameterisation.hh"                37 #include "G4VPVParameterisation.hh"
 33 #include "G4AffineTransform.hh"                    38 #include "G4AffineTransform.hh"
 34 #include "G4UnitsTable.hh"                         39 #include "G4UnitsTable.hh"
 35 #include "G4VSolid.hh"                             40 #include "G4VSolid.hh"
 36 #include "G4LogicalVolume.hh"                      41 #include "G4LogicalVolume.hh"
 37                                                    42 
 38 // -------------------------------------------     43 // ----------------------------------------------------------------------
 39 // Constructor                                     44 // Constructor
 40 //                                                 45 //
 41 G4PVParameterised::G4PVParameterised( const G4     46 G4PVParameterised::G4PVParameterised( const G4String& pName,
 42                                             G4     47                                             G4LogicalVolume* pLogical,
 43                                             G4 <<  48                                             G4VPhysicalVolume* pMother,
 44                                       const EA     49                                       const EAxis pAxis,
 45                                       const G4     50                                       const G4int nReplicas,
 46                                             G4 <<  51                                             G4VPVParameterisation *pParam,
 47                                             G4     52                                             G4bool pSurfChk )
 48 : G4PVReplica(pName, nReplicas, pAxis, pLogica <<  53   : G4PVReplica(pName, pLogical, pMother, pAxis, nReplicas, 0, 0),
 49               pMotherPhysical != nullptr ? pMo << 
 50     fparam(pParam)                                 54     fparam(pParam)
 51 {                                                  55 {
 52   G4LogicalVolume* motherLogical= pMotherPhysi << 
 53       pMotherPhysical->GetLogicalVolume() : nu << 
 54                                                << 
 55   SetMotherLogical( motherLogical );           << 
 56   if( motherLogical != nullptr )               << 
 57   {                                            << 
 58     // Registration moved here to ensure that  << 
 59     motherLogical->AddDaughter(this);          << 
 60   }                                            << 
 61                                                << 
 62 #ifdef G4VERBOSE                                   56 #ifdef G4VERBOSE  
 63   if ((pMotherPhysical != nullptr) && (pMother <<  57   if ((pMother) && (pMother->IsParameterised()))
 64   {                                                58   {
 65     std::ostringstream message, hint;              59     std::ostringstream message, hint;
 66     message << "A parameterised volume is bein     60     message << "A parameterised volume is being placed" << G4endl
 67             << "inside another parameterised v     61             << "inside another parameterised volume !";
 68     hint << "To make sure that no overlaps are     62     hint << "To make sure that no overlaps are generated," << G4endl
 69          << "you should verify the mother repl     63          << "you should verify the mother replicated shapes" << G4endl
 70          << "are of the same type and dimensio     64          << "are of the same type and dimensions." << G4endl
 71          << "   Mother physical volume: " << p <<  65          << "   Mother physical volume: " << pMother->GetName() << G4endl
 72          << "   Parameterised volume: " << pNa     66          << "   Parameterised volume: " << pName << G4endl
 73          << "  (To switch this warning off, co     67          << "  (To switch this warning off, compile with G4_NO_VERBOSE)";
 74     G4Exception("G4PVParameterised::G4PVParame     68     G4Exception("G4PVParameterised::G4PVParameterised()", "GeomVol1002",
 75                 JustWarning, message, G4String     69                 JustWarning, message, G4String(hint.str()));
 76   }                                                70   }
 77 #endif                                             71 #endif
 78   if (pSurfChk) { CheckOverlaps(); }               72   if (pSurfChk) { CheckOverlaps(); }
 79 }                                                  73 }
 80                                                    74 
 81 // -------------------------------------------     75 // ----------------------------------------------------------------------
 82 // Constructor                                     76 // Constructor
 83 //                                                 77 //
 84 G4PVParameterised::G4PVParameterised( const G4     78 G4PVParameterised::G4PVParameterised( const G4String& pName,
 85                                             G4     79                                             G4LogicalVolume* pLogical,
 86                                             G4     80                                             G4LogicalVolume* pMotherLogical,
 87                                       const EA     81                                       const EAxis pAxis,
 88                                       const G4     82                                       const G4int nReplicas,
 89                                             G4 <<  83                                             G4VPVParameterisation *pParam,
 90                                             G4     84                                             G4bool pSurfChk )
 91   : G4PVReplica(pName, nReplicas, pAxis, pLogi <<  85   : G4PVReplica(pName, pLogical, pMotherLogical, pAxis, nReplicas, 0, 0),
 92     fparam(pParam)                                 86     fparam(pParam)
 93 {                                                  87 {
 94   SetMotherLogical( pMotherLogical );          << 
 95   if( pMotherLogical != nullptr )              << 
 96   {                                            << 
 97     // Registration moved here to ensure that  << 
 98     pMotherLogical->AddDaughter(this);         << 
 99   }                                            << 
100   if (pSurfChk) { CheckOverlaps(); }               88   if (pSurfChk) { CheckOverlaps(); }
101 }                                                  89 }
102                                                    90 
103 // -------------------------------------------     91 // ----------------------------------------------------------------------
104 // Fake default constructor - sets only member     92 // Fake default constructor - sets only member data and allocates memory
105 //                            for usage restri     93 //                            for usage restricted to object persistency.
106 //                                                 94 //
107 G4PVParameterised::G4PVParameterised( __void__     95 G4PVParameterised::G4PVParameterised( __void__& a )
108   : G4PVReplica(a)                             <<  96   : G4PVReplica(a), fparam(0)
109 {                                                  97 {
110 }                                                  98 }
111                                                    99 
112 // -------------------------------------------    100 // ----------------------------------------------------------------------
113 // Destructor                                     101 // Destructor
114 //                                                102 //
115 G4PVParameterised::~G4PVParameterised() = defa << 103 G4PVParameterised::~G4PVParameterised()
                                                   >> 104 {
                                                   >> 105 }
116                                                   106 
117 // -------------------------------------------    107 // ----------------------------------------------------------------------
118 // GetParameterisation                            108 // GetParameterisation
119 //                                                109 //
120 G4VPVParameterisation* G4PVParameterised::GetP    110 G4VPVParameterisation* G4PVParameterised::GetParameterisation() const
121 {                                                 111 {
122   return fparam;                                  112   return fparam;
123 }                                                 113 }
124                                                   114 
125 // -------------------------------------------    115 // ----------------------------------------------------------------------
126 // IsParameterised                                116 // IsParameterised
127 //                                                117 //
128 G4bool G4PVParameterised::IsParameterised() co    118 G4bool G4PVParameterised::IsParameterised() const
129 {                                                 119 {
130   return true;                                    120   return true;
131 }                                                 121 }
132                                                   122 
133 // -------------------------------------------    123 // ----------------------------------------------------------------------
134 // VolumeType                                  << 
135 //                                             << 
136 EVolume G4PVParameterised::VolumeType() const  << 
137 {                                              << 
138   return kParameterised;                       << 
139 }                                              << 
140                                                << 
141 // ------------------------------------------- << 
142 // GetReplicationData                             124 // GetReplicationData
143 //                                                125 //
144 void G4PVParameterised::GetReplicationData( EA    126 void G4PVParameterised::GetReplicationData( EAxis& axis,
145                                             G4    127                                             G4int& nReplicas,
146                                             G4    128                                             G4double& width,
147                                             G4    129                                             G4double& offset,
148                                             G4    130                                             G4bool& consuming) const
149 {                                                 131 {
150   axis = faxis;                                   132   axis = faxis;
151   nReplicas = fnReplicas;                         133   nReplicas = fnReplicas;
152   width = fwidth;                                 134   width = fwidth;
153   offset = foffset;                               135   offset = foffset;
154   consuming = false;                              136   consuming = false;
155 }                                                 137 }
156                                                   138 
157 // -------------------------------------------    139 // ----------------------------------------------------------------------
158 // SetRegularStructureId                          140 // SetRegularStructureId
159 //                                                141 //
160 void  G4PVParameterised::SetRegularStructureId << 142 void  G4PVParameterised::SetRegularStructureId( G4int Code )
161 {                                                 143 {
162   G4PVReplica::SetRegularStructureId( code );  << 144   G4PVReplica::SetRegularStructureId( Code );
163   // To undertake additional preparation, a de    145   // To undertake additional preparation, a derived volume must
164   // redefine this method, while calling also  << 146   //   redefine this method, while calling also the above method.
165 }                                                 147 }
166                                                   148 
167                                                   149 
168 // -------------------------------------------    150 // ----------------------------------------------------------------------
169 // CheckOverlaps                                  151 // CheckOverlaps
170 //                                                152 //
171 G4bool                                            153 G4bool
172 G4PVParameterised::CheckOverlaps(G4int res, G4    154 G4PVParameterised::CheckOverlaps(G4int res, G4double tol,
173                                  G4bool verbos    155                                  G4bool verbose, G4int maxErr)
174 {                                                 156 {
175   if (res<=0) { return false; }                   157   if (res<=0) { return false; }
176                                                   158 
177   G4int trials = 0;                               159   G4int trials = 0;
178   G4bool retval = false;                          160   G4bool retval = false;
179   G4VSolid *solidA = nullptr, *solidB = nullpt << 161   G4VSolid *solidA = 0, *solidB = 0;
180   G4LogicalVolume* motherLog = GetMotherLogica << 162   G4LogicalVolume *motherLog = GetMotherLogical();
181   G4VSolid *motherSolid = motherLog->GetSolid(    163   G4VSolid *motherSolid = motherLog->GetSolid();
182   std::vector<G4ThreeVector> points;              164   std::vector<G4ThreeVector> points;
183                                                   165 
184   if (verbose)                                    166   if (verbose)
185   {                                               167   {
186     G4cout << "Checking overlaps for parameter    168     G4cout << "Checking overlaps for parameterised volume "
187            << GetName() << " ... ";               169            << GetName() << " ... ";
188   }                                               170   }
189                                                   171 
190   for (auto i=0; i<GetMultiplicity(); ++i)     << 172   for (G4int i=0; i<GetMultiplicity(); i++)
191   {                                               173   {
192     solidA = fparam->ComputeSolid(i, this);       174     solidA = fparam->ComputeSolid(i, this);
193     solidA->ComputeDimensions(fparam, i, this)    175     solidA->ComputeDimensions(fparam, i, this);
194     fparam->ComputeTransformation(i, this);       176     fparam->ComputeTransformation(i, this);
195                                                   177 
196     // Create the transformation from daughter    178     // Create the transformation from daughter to mother
197     //                                            179     //
198     G4AffineTransform Tm( GetRotation(), GetTr    180     G4AffineTransform Tm( GetRotation(), GetTranslation() );
199                                                   181 
200     // Generate random points on surface accor    182     // Generate random points on surface according to the given resolution,
201     // transform them to the mother's coordina    183     // transform them to the mother's coordinate system and if no overlaps
202     // with the mother volume, cache them in a    184     // with the mother volume, cache them in a vector for later use with
203     // the daughters                              185     // the daughters
204     //                                            186     //
205     for (auto n=0; n<res; ++n)                 << 187     for (G4int n=0; n<res; n++)
206     {                                             188     {
207       G4ThreeVector mp = Tm.TransformPoint(sol    189       G4ThreeVector mp = Tm.TransformPoint(solidA->GetPointOnSurface());
208                                                   190 
209       // Checking overlaps with the mother vol    191       // Checking overlaps with the mother volume
210       //                                          192       //
211       if (motherSolid->Inside(mp)==kOutside)      193       if (motherSolid->Inside(mp)==kOutside)
212       {                                           194       {
213         G4double distin = motherSolid->Distanc    195         G4double distin = motherSolid->DistanceToIn(mp);
214         if (distin > tol)                         196         if (distin > tol)
215         {                                         197         {
216           ++trials; retval = true;             << 198           trials++; retval = true;
217           std::ostringstream message;             199           std::ostringstream message;
218           message << "Overlap with mother volu    200           message << "Overlap with mother volume !" << G4endl
219                   << "         Overlap is dete    201                   << "         Overlap is detected for volume "
220                   << GetName() << ", parameter    202                   << GetName() << ", parameterised instance: " << i << G4endl
221                   << "          with its mothe    203                   << "          with its mother volume "
222                   << motherLog->GetName() << G    204                   << motherLog->GetName() << G4endl
223                   << "          at mother loca    205                   << "          at mother local point " << mp << ", "
224                   << "overlapping by at least:    206                   << "overlapping by at least: "
225                   << G4BestUnit(distin, "Lengt    207                   << G4BestUnit(distin, "Length");
226           if (trials>=maxErr)                     208           if (trials>=maxErr)
227           {                                       209           {
228             message << G4endl                     210             message << G4endl
229                     << "NOTE: Reached maximum     211                     << "NOTE: Reached maximum fixed number -" << maxErr
230                     << "- of overlaps reports     212                     << "- of overlaps reports for this volume !";
231           }                                       213           }
232           G4Exception("G4PVParameterised::Chec    214           G4Exception("G4PVParameterised::CheckOverlaps()",
233                       "GeomVol1002", JustWarni    215                       "GeomVol1002", JustWarning, message);
234           if (trials>=maxErr)  { return true;     216           if (trials>=maxErr)  { return true; }
235         }                                         217         }
236       }                                           218       }
237       points.push_back(mp);                       219       points.push_back(mp);
238     }                                             220     }
239                                                   221 
240     // Checking overlaps with each other param    222     // Checking overlaps with each other parameterised instance
241     //                                            223     //
242     for (auto j=i+1; j<GetMultiplicity(); ++j) << 224     std::vector<G4ThreeVector>::iterator pos;
                                                   >> 225     for (G4int j=i+1; j<GetMultiplicity(); j++)
243     {                                             226     {
244       solidB = fparam->ComputeSolid(j,this);      227       solidB = fparam->ComputeSolid(j,this);
245       solidB->ComputeDimensions(fparam, j, thi    228       solidB->ComputeDimensions(fparam, j, this);
246       fparam->ComputeTransformation(j, this);     229       fparam->ComputeTransformation(j, this);
247                                                   230 
248       // Create the transformation for daughte    231       // Create the transformation for daughter volume
249       //                                          232       //
250       G4AffineTransform Td( GetRotation(), Get    233       G4AffineTransform Td( GetRotation(), GetTranslation() );
251                                                   234 
252       for (const auto & point : points)        << 235       for (pos=points.begin(); pos!=points.end(); pos++)
253       {                                           236       {
254         // Transform each point according to d    237         // Transform each point according to daughter's frame
255         //                                        238         //
256         G4ThreeVector md = Td.InverseTransform << 239         G4ThreeVector md = Td.Inverse().TransformPoint(*pos);
257                                                   240 
258         if (solidB->Inside(md)==kInside)          241         if (solidB->Inside(md)==kInside)
259         {                                         242         {
260           G4double distout = solidB->DistanceT    243           G4double distout = solidB->DistanceToOut(md);
261           if (distout > tol)                      244           if (distout > tol)
262           {                                       245           {
263             ++trials; retval = true;           << 246             trials++; retval = true;
264             std::ostringstream message;           247             std::ostringstream message;
265             message << "Overlap within paramet    248             message << "Overlap within parameterised volumes !" << G4endl
266                     << "          Overlap is d    249                     << "          Overlap is detected for volume "
267                     << GetName() << ", paramet    250                     << GetName() << ", parameterised instance: " << i << G4endl
268                     << "          with paramet    251                     << "          with parameterised volume instance: " << j
269                     << G4endl                     252                     << G4endl
270                     << "          at local poi    253                     << "          at local point " << md << ", "
271                     << "overlapping by at leas    254                     << "overlapping by at least: "
272                     << G4BestUnit(distout, "Le    255                     << G4BestUnit(distout, "Length")
273                     << ", related to volume in    256                     << ", related to volume instance: " << j << ".";
274             if (trials>=maxErr)                   257             if (trials>=maxErr)
275             {                                     258             {
276               message << G4endl                   259               message << G4endl
277                       << "NOTE: Reached maximu    260                       << "NOTE: Reached maximum fixed number -" << maxErr
278                       << "- of overlaps report    261                       << "- of overlaps reports for this volume !";
279             }                                     262             }
280             G4Exception("G4PVParameterised::Ch    263             G4Exception("G4PVParameterised::CheckOverlaps()",
281                         "GeomVol1002", JustWar    264                         "GeomVol1002", JustWarning, message);
282             if (trials>=maxErr)  { return true    265             if (trials>=maxErr)  { return true; }
283           }                                       266           }
284         }                                         267         }
285       }                                           268       }
286     }                                             269     }
287   }                                               270   }
288   if (verbose)                                    271   if (verbose)
289   {                                               272   {
290     G4cout << "OK! " << G4endl;                   273     G4cout << "OK! " << G4endl;
291   }                                               274   }
292                                                   275 
293   return retval;                                  276   return retval;
294 }                                                 277 }
295                                                   278