Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/divisions/src/G4VDivisionParameterisation.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/divisions/src/G4VDivisionParameterisation.cc (Version 11.3.0) and /geometry/divisions/src/G4VDivisionParameterisation.cc (Version 11.2.1)


  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 // G4VDivisionParameterisation implementation      26 // G4VDivisionParameterisation implementation
 27 //                                                 27 //
 28 // 26.05.03 - P.Arce, Initial version              28 // 26.05.03 - P.Arce, Initial version
 29 // 08.04.04 - I.Hrivnacova, Implemented reflec     29 // 08.04.04 - I.Hrivnacova, Implemented reflection
 30 // 21.04.10 - M.Asai, Added gaps                   30 // 21.04.10 - M.Asai, Added gaps
 31 // -------------------------------------------     31 // --------------------------------------------------------------------
 32                                                    32 
 33 #include "G4VDivisionParameterisation.hh"          33 #include "G4VDivisionParameterisation.hh" 
 34 #include "G4VSolid.hh"                             34 #include "G4VSolid.hh"
 35 #include "G4VPhysicalVolume.hh"                    35 #include "G4VPhysicalVolume.hh"
 36 #include "G4RotationMatrix.hh"                     36 #include "G4RotationMatrix.hh"
 37 #include "G4ReflectedSolid.hh"                     37 #include "G4ReflectedSolid.hh"
 38 #include "G4GeometryTolerance.hh"                  38 #include "G4GeometryTolerance.hh"
 39 #include "G4AutoDelete.hh"                         39 #include "G4AutoDelete.hh"
 40                                                    40 
 41 const G4int G4VDivisionParameterisation::verbo     41 const G4int G4VDivisionParameterisation::verbose = 5;
 42 G4ThreadLocal G4RotationMatrix* G4VDivisionPar     42 G4ThreadLocal G4RotationMatrix* G4VDivisionParameterisation::fRot = nullptr;
 43                                                    43 
 44 //--------------------------------------------     44 //--------------------------------------------------------------------------
 45 G4VDivisionParameterisation::                      45 G4VDivisionParameterisation::
 46 G4VDivisionParameterisation( EAxis axis, G4int     46 G4VDivisionParameterisation( EAxis axis, G4int nDiv,
 47                              G4double step, G4     47                              G4double step, G4double offset,
 48                              DivisionType divT     48                              DivisionType divType, G4VSolid* motherSolid )
 49   : faxis(axis), fnDiv( nDiv), fwidth(step), f     49   : faxis(axis), fnDiv( nDiv), fwidth(step), foffset(offset),
 50     fDivisionType(divType), fmotherSolid( moth     50     fDivisionType(divType), fmotherSolid( motherSolid )
 51 {                                                  51 {
 52 #ifdef G4DIVDEBUG                                  52 #ifdef G4DIVDEBUG
 53   if (verbose >= 1)                                53   if (verbose >= 1)
 54   {                                                54   {
 55     G4cout << " G4VDivisionParameterisation  n     55     G4cout << " G4VDivisionParameterisation  no divisions " << fnDiv
 56            << " = " << nDiv << G4endl              56            << " = " << nDiv << G4endl
 57            << " offset " << foffset << " = " <     57            << " offset " << foffset << " = " << offset << G4endl
 58            << " step " << fwidth << " = " << s     58            << " step " << fwidth << " = " << step << G4endl;
 59   }                                                59   }
 60 #endif                                             60 #endif
 61   kCarTolerance = G4GeometryTolerance::GetInst     61   kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
 62 }                                                  62 }
 63                                                    63 
 64 //--------------------------------------------     64 //--------------------------------------------------------------------------
 65 G4VDivisionParameterisation::~G4VDivisionParam     65 G4VDivisionParameterisation::~G4VDivisionParameterisation()
 66 {                                                  66 {
 67   if (fDeleteSolid)  { delete fmotherSolid; }      67   if (fDeleteSolid)  { delete fmotherSolid; }
 68 }                                                  68 }
 69                                                    69 
 70 //--------------------------------------------     70 //--------------------------------------------------------------------------
 71 G4VSolid*                                          71 G4VSolid* 
 72 G4VDivisionParameterisation::                      72 G4VDivisionParameterisation::
 73 ComputeSolid( const G4int i, G4VPhysicalVolume     73 ComputeSolid( const G4int i, G4VPhysicalVolume* pv )
 74 {                                                  74 {
 75   G4VSolid* solid = G4VPVParameterisation::Com     75   G4VSolid* solid = G4VPVParameterisation::ComputeSolid(i, pv);
 76   if (solid->GetEntityType() == "G4ReflectedSo     76   if (solid->GetEntityType() == "G4ReflectedSolid")
 77   {                                                77   {
 78     solid = ((G4ReflectedSolid*)solid)->GetCon     78     solid = ((G4ReflectedSolid*)solid)->GetConstituentMovedSolid();
 79   }                                                79   }
 80   return solid;                                    80   return solid;
 81 }                                                  81 }      
 82                                                    82 
 83 //--------------------------------------------     83 //--------------------------------------------------------------------------
 84 void                                               84 void
 85 G4VDivisionParameterisation::                      85 G4VDivisionParameterisation::
 86 ChangeRotMatrix( G4VPhysicalVolume* physVol, G     86 ChangeRotMatrix( G4VPhysicalVolume* physVol, G4double rotZ ) const
 87 {                                                  87 {
 88   if (fRot == nullptr)                             88   if (fRot == nullptr)
 89   {                                                89   {
 90     fRot = new G4RotationMatrix();                 90     fRot = new G4RotationMatrix();
 91     G4AutoDelete::Register(fRot);                  91     G4AutoDelete::Register(fRot);
 92   }                                                92   }
 93   fRot->rotateZ( rotZ );                           93   fRot->rotateZ( rotZ );
 94   physVol->SetRotation(fRot);                      94   physVol->SetRotation(fRot);
 95 }                                                  95 }
 96                                                    96 
 97 //--------------------------------------------     97 //--------------------------------------------------------------------------
 98 G4int                                              98 G4int
 99 G4VDivisionParameterisation::                      99 G4VDivisionParameterisation::
100 CalculateNDiv( G4double motherDim, G4double wi    100 CalculateNDiv( G4double motherDim, G4double width, G4double offset ) const
101 {                                                 101 {
102 #ifdef G4DIVDEBUG                                 102 #ifdef G4DIVDEBUG
103   G4cout << " G4VDivisionParameterisation::Cal    103   G4cout << " G4VDivisionParameterisation::CalculateNDiv: "
104          << ( motherDim - offset ) / width        104          << ( motherDim - offset ) / width 
105          << " Motherdim: " <<  motherDim << ",    105          << " Motherdim: " <<  motherDim << ", Offset: " << offset
106          << ", Width: " << width << G4endl;       106          << ", Width: " << width << G4endl;
107 #endif                                            107 #endif
108                                                   108 
109   return G4int( ( motherDim - offset ) / width    109   return G4int( ( motherDim - offset ) / width );
110 }                                                 110 }
111                                                   111 
112 //--------------------------------------------    112 //--------------------------------------------------------------------------
113 G4double                                          113 G4double
114 G4VDivisionParameterisation::                     114 G4VDivisionParameterisation::
115 CalculateWidth( G4double motherDim, G4int nDiv    115 CalculateWidth( G4double motherDim, G4int nDiv, G4double offset ) const
116 {                                                 116 { 
117 #ifdef G4DIVDEBUG                                 117 #ifdef G4DIVDEBUG
118   G4cout << " G4VDivisionParameterisation::Cal    118   G4cout << " G4VDivisionParameterisation::CalculateWidth: "
119          << ( motherDim - offset ) / nDiv         119          << ( motherDim - offset ) / nDiv
120          << ", Motherdim: " << motherDim << ",    120          << ", Motherdim: " << motherDim << ", Offset: " << offset
121          << ", Number of divisions: " << nDiv     121          << ", Number of divisions: " << nDiv << G4endl;
122 #endif                                            122 #endif
123                                                   123 
124   return ( motherDim - offset ) / nDiv;           124   return ( motherDim - offset ) / nDiv;
125 }                                                 125 }
126                                                   126 
127 //--------------------------------------------    127 //--------------------------------------------------------------------------
128 void G4VDivisionParameterisation::CheckParamet    128 void G4VDivisionParameterisation::CheckParametersValidity()
129 {                                                 129 {
130   G4double maxPar = GetMaxParameter();            130   G4double maxPar = GetMaxParameter();
131   CheckOffset( maxPar );                          131   CheckOffset( maxPar );
132   CheckNDivAndWidth( maxPar );                    132   CheckNDivAndWidth( maxPar );
133 }                                                 133 }
134                                                   134 
135 //--------------------------------------------    135 //--------------------------------------------------------------------------
136 void G4VDivisionParameterisation::CheckOffset(    136 void G4VDivisionParameterisation::CheckOffset( G4double maxPar )
137 {                                                 137 {
138   if( foffset >= maxPar )                         138   if( foffset >= maxPar )
139   {                                               139   {
140     std::ostringstream message;                   140     std::ostringstream message;
141     message << "Configuration not supported."     141     message << "Configuration not supported." << G4endl
142             << "Division of solid " << fmother    142             << "Division of solid " << fmotherSolid->GetName()
143             << " has too big offset = " << G4e    143             << " has too big offset = " << G4endl
144             << "        " << foffset << " > "     144             << "        " << foffset << " > " << maxPar << " !";
145     G4Exception("G4VDivisionParameterisation::    145     G4Exception("G4VDivisionParameterisation::CheckOffset()",
146                 "GeomDiv0001", FatalException,    146                 "GeomDiv0001", FatalException, message);
147   }                                               147   }
148 }                                                 148 }
149                                                   149 
150 //--------------------------------------------    150 //--------------------------------------------------------------------------
151 void G4VDivisionParameterisation::CheckNDivAnd    151 void G4VDivisionParameterisation::CheckNDivAndWidth( G4double maxPar )
152 {                                                 152 {
153   if( (fDivisionType == DivNDIVandWIDTH)          153   if( (fDivisionType == DivNDIVandWIDTH)
154       && (foffset + fwidth*fnDiv - maxPar > kC    154       && (foffset + fwidth*fnDiv - maxPar > kCarTolerance ) )
155   {                                               155   {
156     std::ostringstream message;                   156     std::ostringstream message;
157     message << "Configuration not supported."     157     message << "Configuration not supported." << G4endl
158             << "Division of solid " << fmother    158             << "Division of solid " << fmotherSolid->GetName()
159            << " has too big offset + width*nDi    159            << " has too big offset + width*nDiv = " << G4endl
160            << "        " << foffset + fwidth*f    160            << "        " << foffset + fwidth*fnDiv << " > "
161            << foffset << ". Width = "             161            << foffset << ". Width = "
162            << G4endl                              162            << G4endl
163            << "        " << fwidth << ". nDiv     163            << "        " << fwidth << ". nDiv = " << fnDiv << " !";
164     G4Exception("G4VDivisionParameterisation::    164     G4Exception("G4VDivisionParameterisation::CheckNDivAndWidth()",
165                 "GeomDiv0001", FatalException,    165                 "GeomDiv0001", FatalException, message);
166   }                                               166   }
167 }                                                 167 }
168                                                   168 
169 //--------------------------------------------    169 //--------------------------------------------------------------------------
170 G4double G4VDivisionParameterisation::OffsetZ(    170 G4double G4VDivisionParameterisation::OffsetZ() const
171 {                                                 171 {
172   // take into account reflection in the offse    172   // take into account reflection in the offset
173                                                   173 
174   G4double offset = foffset;                      174   G4double offset = foffset;
175   if (fReflectedSolid)                            175   if (fReflectedSolid)
176   {                                               176   {
177     offset = GetMaxParameter() - fwidth*fnDiv     177     offset = GetMaxParameter() - fwidth*fnDiv - foffset;
178   }                                               178   }
179                                                   179 
180   return offset;                                  180   return offset;
181 }                                                 181 }  
182                                                   182 
183                                                   183   
184                                                   184