Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/solids/specific/src/G4TwistedTrd.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/solids/specific/src/G4TwistedTrd.cc (Version 11.3.0) and /geometry/solids/specific/src/G4TwistedTrd.cc (Version 10.2.p3)


  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 // G4TwistedTrd                                << 
 27 //                                                 26 //
 28 // Author: 18/03/2005 - O.Link (Oliver.Link@ce <<  27 // $Id: G4TwistedTrd.cc 79492 2014-03-05 15:25:30Z gcosmo $
                                                   >>  28 //
                                                   >>  29 // 
                                                   >>  30 // --------------------------------------------------------------------
                                                   >>  31 // GEANT 4 class source file
                                                   >>  32 //
                                                   >>  33 //
                                                   >>  34 // G4TwistedTrd.cc
                                                   >>  35 //
                                                   >>  36 // Author:
                                                   >>  37 //
                                                   >>  38 //   18/03/2005 - O.Link (Oliver.Link@cern.ch)
                                                   >>  39 //
 29 // -------------------------------------------     40 // --------------------------------------------------------------------
 30                                                    41 
 31 #include "G4TwistedTrd.hh"                         42 #include "G4TwistedTrd.hh"
 32 #include "G4SystemOfUnits.hh"                      43 #include "G4SystemOfUnits.hh"
 33 #include "G4Polyhedron.hh"                         44 #include "G4Polyhedron.hh"
 34                                                    45 
 35 //============================================ << 
 36 //* Constructor ------------------------------ << 
 37                                                << 
 38 G4TwistedTrd::G4TwistedTrd( const G4String& pN     46 G4TwistedTrd::G4TwistedTrd( const G4String& pName,
 39                                   G4double  pD <<  47                                   G4double  pDx1, 
 40                                   G4double  pD     48                                   G4double  pDx2,
 41                                   G4double  pD <<  49                                   G4double  pDy1, 
 42                                   G4double  pD     50                                   G4double  pDy2,
 43                                   G4double  pD     51                                   G4double  pDz,
 44                                   G4double  pP     52                                   G4double  pPhiTwist )
 45   : G4VTwistedFaceted( pName, pPhiTwist,pDz,0.     53   : G4VTwistedFaceted( pName, pPhiTwist,pDz,0.,0.,
 46                        pDy1, pDx1, pDx1, pDy2,     54                        pDy1, pDx1, pDx1, pDy2, pDx2, pDx2,0.)
 47 {                                                  55 {
 48 }                                                  56 }
 49                                                    57 
 50 //============================================ << 
 51 // Fake default constructor - sets only member     58 // Fake default constructor - sets only member data and allocates memory
 52 //                            for usage restri     59 //                            for usage restricted to object persistency.
 53                                                <<  60 //
 54 G4TwistedTrd::G4TwistedTrd( __void__& a )          61 G4TwistedTrd::G4TwistedTrd( __void__& a )
 55   : G4VTwistedFaceted(a)                           62   : G4VTwistedFaceted(a)
 56 {                                                  63 {
 57 }                                                  64 }
 58                                                    65 
 59 //============================================ <<  66 G4TwistedTrd::~G4TwistedTrd()
 60 //* Destructor ------------------------------- <<  67 {
 61                                                <<  68 }
 62 G4TwistedTrd::~G4TwistedTrd() = default;       << 
 63                                                << 
 64 //============================================ << 
 65 //* Copy constructor ------------------------- << 
 66                                                    69 
                                                   >>  70 // Copy constructor
                                                   >>  71 //
 67 G4TwistedTrd::G4TwistedTrd(const G4TwistedTrd&     72 G4TwistedTrd::G4TwistedTrd(const G4TwistedTrd& rhs)
 68   : G4VTwistedFaceted(rhs)                         73   : G4VTwistedFaceted(rhs)
 69 {                                                  74 {
 70   fpPolyhedron = GetPolyhedron();                  75   fpPolyhedron = GetPolyhedron();
 71 }                                                  76 }
 72                                                    77 
 73 //============================================ <<  78 // Assignment operator
 74 //* Assignment operator ---------------------- <<  79 //
 75                                                <<  80 G4TwistedTrd& G4TwistedTrd::operator = (const G4TwistedTrd& rhs) 
 76 G4TwistedTrd& G4TwistedTrd::operator = (const  << 
 77 {                                                  81 {
 78    // Check assignment to self                     82    // Check assignment to self
 79    //                                              83    //
 80    if (this == &rhs)  { return *this; }            84    if (this == &rhs)  { return *this; }
 81                                                    85 
 82    // Copy base class data                         86    // Copy base class data
 83    //                                              87    //
 84    G4VTwistedFaceted::operator=(rhs);              88    G4VTwistedFaceted::operator=(rhs);
 85    fpPolyhedron = GetPolyhedron();                 89    fpPolyhedron = GetPolyhedron();
 86                                                    90 
 87    return *this;                                   91    return *this;
 88 }                                                  92 }
 89                                                    93 
 90 //============================================ << 
 91 //* StreamInfo ------------------------------- << 
 92                                                << 
 93 std::ostream& G4TwistedTrd::StreamInfo(std::os     94 std::ostream& G4TwistedTrd::StreamInfo(std::ostream& os) const
 94 {                                                  95 {
 95   //                                               96   //
 96   // Stream object contents to an output strea     97   // Stream object contents to an output stream
 97   //                                               98   //
 98   os << "-------------------------------------     99   os << "-----------------------------------------------------------\n"
 99      << "    *** Dump for solid - " << GetName    100      << "    *** Dump for solid - " << GetName() << " ***\n"
100      << "    =================================    101      << "    ===================================================\n"
101      << " Solid type: G4TwistedTrd\n"             102      << " Solid type: G4TwistedTrd\n"
102      << " Parameters: \n"                         103      << " Parameters: \n"
103      << "    pDx1 = " << GetX1HalfLength()/cm     104      << "    pDx1 = " << GetX1HalfLength()/cm << " cm" << G4endl
104      << "    pDx2 = " << GetX2HalfLength()/cm     105      << "    pDx2 = " << GetX2HalfLength()/cm << " cm" << G4endl
105      << "    pDy1 = " << GetY1HalfLength()/cm     106      << "    pDy1 = " << GetY1HalfLength()/cm << " cm" << G4endl
106      << "    pDy2 = " << GetY2HalfLength()/cm     107      << "    pDy2 = " << GetY2HalfLength()/cm << " cm" << G4endl
107      << "    pDz = "  << GetZHalfLength()/cm <    108      << "    pDz = "  << GetZHalfLength()/cm << " cm" << G4endl
108      << "    pPhiTwist = " << GetPhiTwist()/de << 109      << "    pPhiTwist = " << GetPhiTwist()/degree << " deg" << G4endl 
109      << "-------------------------------------    110      << "-----------------------------------------------------------\n";
110                                                   111 
111   return os;                                      112   return os;
112 }                                                 113 }
113                                                   114 
                                                   >> 115 
114 //============================================    116 //=====================================================================
115 //* GetEntityType ----------------------------    117 //* GetEntityType -----------------------------------------------------
116                                                   118 
117 G4GeometryType G4TwistedTrd::GetEntityType() c    119 G4GeometryType G4TwistedTrd::GetEntityType() const
118 {                                                 120 {
119   return {"G4TwistedTrd"};                     << 121   return G4String("G4TwistedTrd");
120 }                                                 122 }
121                                                   123 
122 //============================================    124 //=====================================================================
123 //* Clone ------------------------------------    125 //* Clone -------------------------------------------------------------
124                                                   126 
125 G4VSolid* G4TwistedTrd::Clone() const             127 G4VSolid* G4TwistedTrd::Clone() const
126 {                                                 128 {
127   return new G4TwistedTrd(*this);                 129   return new G4TwistedTrd(*this);
128 }                                              << 
129                                                << 
130 //============================================ << 
131 //* GetCubicVolume --------------------------- << 
132                                                << 
133 double G4TwistedTrd::GetCubicVolume()          << 
134 {                                              << 
135   if (fCubicVolume == 0.)                      << 
136   {                                            << 
137     G4double x1 = GetX1HalfLength();           << 
138     G4double x2 = GetX2HalfLength();           << 
139     G4double y1 = GetY1HalfLength();           << 
140     G4double y2 = GetY2HalfLength();           << 
141     G4double h = 2.*GetZHalfLength();          << 
142     fCubicVolume = h*((x1 + x2)*(y1 + y2) + (x << 
143   }                                            << 
144   return fCubicVolume;                         << 
145 }                                              << 
146                                                << 
147 //============================================ << 
148 //* GetSurfaceArea --------------------------- << 
149                                                << 
150 double G4TwistedTrd::GetSurfaceArea()          << 
151 {                                              << 
152   if (fSurfaceArea == 0.)                      << 
153   {                                            << 
154     G4double ang = GetPhiTwist();              << 
155     G4double x1 = GetX1HalfLength();           << 
156     G4double x2 = GetX2HalfLength();           << 
157     G4double y1 = GetY1HalfLength();           << 
158     G4double y2 = GetY2HalfLength();           << 
159     G4double h = 2.*GetZHalfLength();          << 
160     G4double hh = h*h;                         << 
161     G4double delX = x2 - x1;                   << 
162     G4double delY = y2 - y1;                   << 
163     if (ang == 0.)                             << 
164     {                                          << 
165       G4double hx = std::sqrt(delY*delY + hh); << 
166       G4double hy = std::sqrt(delX*delX + hh); << 
167       return fSurfaceArea =                    << 
168         2.*(x1 + x2)*hx + 2.*(y1 + y2)*hy + 4. << 
169     }                                          << 
170                                                << 
171     // compute area of x-faces                 << 
172     G4double U1, U2, V1, V2;                   << 
173     G4double areaX = 0.;                       << 
174     U1 = delY + x1*ang;                        << 
175     U2 = delY + x2*ang;                        << 
176     V1 = delY - x1*ang;                        << 
177     V2 = delY - x2*ang;                        << 
178     if (std::abs(delX) < kCarTolerance) // cas << 
179     {                                          << 
180       areaX = (U1*std::sqrt(hh + U1*U1) + hh*s << 
181                V1*std::sqrt(hh + V1*V1) - hh*s << 
182     }                                          << 
183     else                                       << 
184     {                                          << 
185       // U contribution                        << 
186       areaX += ((hh + U2*U2)*std::sqrt(hh + U2 << 
187                 (hh + U1*U1)*std::sqrt(hh + U1 << 
188         + hh*(U2*std::asinh(U2/h) - U1*std::as << 
189         - hh*(std::sqrt(hh + U2*U2) - std::sqr << 
190       // V contribution                        << 
191       areaX += ((hh + V2*V2)*std::sqrt(hh + V2 << 
192                 (hh + V1*V1)*std::sqrt(hh + V1 << 
193         + hh*(V2*std::asinh(V2/h) - V1*std::as << 
194         - hh*(std::sqrt(hh + V2*V2) - std::sqr << 
195       areaX /= delX*ang*ang;                   << 
196     }                                          << 
197                                                << 
198     // compute area of y-faces                 << 
199     G4double areaY = 0.;                       << 
200     U1 = delX + y1*ang;                        << 
201     U2 = delX + y2*ang;                        << 
202     V1 = delX - y1*ang;                        << 
203     V2 = delX - y2*ang;                        << 
204     if (std::abs(delY) < kCarTolerance) // cas << 
205     {                                          << 
206       areaY = (U1*std::sqrt(hh + U1*U1) + hh*s << 
207                V1*std::sqrt(hh + V1*V1) - hh*s << 
208     }                                          << 
209     else                                       << 
210     {                                          << 
211       // U contribution                        << 
212       areaY += ((hh + U2*U2)*std::sqrt(hh + U2 << 
213                 (hh + U1*U1)*std::sqrt(hh + U1 << 
214         + hh*(U2*std::asinh(U2/h) - U1*std::as << 
215         - hh*(std::sqrt(hh + U2*U2) - std::sqr << 
216       // V contribution                        << 
217       areaY += ((hh + V2*V2)*std::sqrt(hh + V2 << 
218                 (hh + V1*V1)*std::sqrt(hh + V1 << 
219         + hh*(V2*std::asinh(V2/h) - V1*std::as << 
220         - hh*(std::sqrt(hh + V2*V2) - std::sqr << 
221       areaY /= delY*ang*ang;                   << 
222     }                                          << 
223     fSurfaceArea = areaX + areaY + 4.*(x1*y1 + << 
224   }                                            << 
225   return fSurfaceArea;                         << 
226 }                                                 130 }
227                                                   131