Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/management/src/G4ErrorPlaneSurfaceTarget.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/management/src/G4ErrorPlaneSurfaceTarget.cc (Version 11.3.0) and /geometry/management/src/G4ErrorPlaneSurfaceTarget.cc (Version 9.5.p2)


  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 // G4ErrorPlaneSurfaceTarget class implementat << 
 27 //                                                 26 //
 28 // Created: P.Arce, September 2004             <<  27 // $Id: G4ErrorPlaneSurfaceTarget.cc,v 1.2 2007-06-19 11:28:39 gcosmo Exp $
                                                   >>  28 // GEANT4 tag $Name: not supported by cvs2svn $
                                                   >>  29 //
                                                   >>  30 //
                                                   >>  31 // --------------------------------------------------------------------
                                                   >>  32 //      GEANT 4 class implementation file 
 29 // -------------------------------------------     33 // --------------------------------------------------------------------
 30                                                    34 
 31 #include "G4ErrorPlaneSurfaceTarget.hh"            35 #include "G4ErrorPlaneSurfaceTarget.hh"
 32                                                    36 
 33 #ifdef G4VERBOSE                                   37 #ifdef G4VERBOSE
 34 #include "G4ErrorPropagatorData.hh" // for ver <<  38 #include "G4ErrorPropagatorData.hh" //for verbosity checking
 35 #endif                                             39 #endif
 36                                                    40 
 37 #include "G4Point3D.hh"                            41 #include "G4Point3D.hh"
 38 #include "G4ThreeVector.hh"                        42 #include "G4ThreeVector.hh"
 39                                                    43 
 40 //--------------------------------------------     44 //---------------------------------------------------------------------
 41                                                    45 
 42 G4ErrorPlaneSurfaceTarget::                        46 G4ErrorPlaneSurfaceTarget::
 43 G4ErrorPlaneSurfaceTarget(G4double aa, G4doubl     47 G4ErrorPlaneSurfaceTarget(G4double aa, G4double ab, G4double ac, G4double ad)
 44   : G4Plane3D( aa, ab, ac, ad )                    48   : G4Plane3D( aa, ab, ac, ad ) 
 45 {                                                  49 {
 46   theType = G4ErrorTarget_PlaneSurface;            50   theType = G4ErrorTarget_PlaneSurface;
 47                                                    51 
 48 #ifdef G4VERBOSE                                   52 #ifdef G4VERBOSE
 49   if(G4ErrorPropagatorData::verbose() >= 2 )       53   if(G4ErrorPropagatorData::verbose() >= 2 )
 50   {                                                54   { 
 51     Dump( " $$$ creating G4ErrorPlaneSurfaceTa     55     Dump( " $$$ creating G4ErrorPlaneSurfaceTarget from parameters");
 52   }                                                56   }
 53 #endif                                             57 #endif
 54 }                                                  58 }
 55                                                    59 
 56 //--------------------------------------------     60 //---------------------------------------------------------------------
 57                                                    61 
 58 G4ErrorPlaneSurfaceTarget::                        62 G4ErrorPlaneSurfaceTarget::
 59 G4ErrorPlaneSurfaceTarget(const G4Normal3D &no     63 G4ErrorPlaneSurfaceTarget(const G4Normal3D &norm, const G4Point3D &pt)
 60   : G4Plane3D( norm, pt )                          64   : G4Plane3D( norm, pt ) 
 61 {                                                  65 {
 62   theType = G4ErrorTarget_PlaneSurface;            66   theType = G4ErrorTarget_PlaneSurface;
 63                                                    67 
 64 #ifdef G4VERBOSE                                   68 #ifdef G4VERBOSE
 65   if(G4ErrorPropagatorData::verbose() >= 2 )       69   if(G4ErrorPropagatorData::verbose() >= 2 )
 66   {                                                70   { 
 67     Dump( " $$$ creating G4ErrorPlaneSurfaceTa     71     Dump( " $$$ creating G4ErrorPlaneSurfaceTarget from point and normal");
 68   }                                                72   }
 69 #endif                                             73 #endif
 70 }                                                  74 }
 71                                                    75 
 72 //--------------------------------------------     76 //---------------------------------------------------------------------
 73                                                    77 
 74 G4ErrorPlaneSurfaceTarget::                        78 G4ErrorPlaneSurfaceTarget::
 75 G4ErrorPlaneSurfaceTarget(const G4Point3D &p1,     79 G4ErrorPlaneSurfaceTarget(const G4Point3D &p1,
 76                           const G4Point3D &p2,     80                           const G4Point3D &p2,
 77                           const G4Point3D &p3)     81                           const G4Point3D &p3)
 78   : G4Plane3D( p1, p2, p3 )                        82   : G4Plane3D( p1, p2, p3 )
 79 {                                                  83 {
 80   theType = G4ErrorTarget_PlaneSurface;            84   theType = G4ErrorTarget_PlaneSurface;
 81                                                    85 
 82 #ifdef G4VERBOSE                                   86 #ifdef G4VERBOSE
 83   if(G4ErrorPropagatorData::verbose() >= 2 )       87   if(G4ErrorPropagatorData::verbose() >= 2 )
 84   {                                                88   { 
 85     Dump( " $$$ creating G4ErrorPlaneSurfaceTa     89     Dump( " $$$ creating G4ErrorPlaneSurfaceTarget from three points");
 86   }                                                90   }
 87 #endif                                             91 #endif
 88 }                                                  92 }
 89                                                    93 
 90 //--------------------------------------------     94 //---------------------------------------------------------------------
 91                                                    95 
                                                   >>  96 G4ErrorPlaneSurfaceTarget::~G4ErrorPlaneSurfaceTarget()
                                                   >>  97 {
                                                   >>  98 }
                                                   >>  99 
                                                   >> 100 //---------------------------------------------------------------------
                                                   >> 101 
 92 G4ThreeVector G4ErrorPlaneSurfaceTarget::         102 G4ThreeVector G4ErrorPlaneSurfaceTarget::
 93 Intersect( const G4ThreeVector& pt, const G4Th    103 Intersect( const G4ThreeVector& pt, const G4ThreeVector& dir ) const
 94 {                                                 104 {
 95   G4double lam = GetDistanceFromPoint( pt, dir    105   G4double lam = GetDistanceFromPoint( pt, dir );
 96   G4Point3D inters = pt + lam * dir;              106   G4Point3D inters = pt + lam * dir;
 97                                                   107 
 98 #ifdef G4VERBOSE                                  108 #ifdef G4VERBOSE
 99   if(G4ErrorPropagatorData::verbose() >= 4 )      109   if(G4ErrorPropagatorData::verbose() >= 4 )
100   {                                               110   { 
101     G4cout << " $$$ creating G4ErrorPlaneSurfa    111     G4cout << " $$$ creating G4ErrorPlaneSurfaceTarget::Intersect "
102            << inters << G4endl;                   112            << inters << G4endl;
103   }                                               113   }
104 #endif                                            114 #endif
105                                                   115 
106   return inters;                                  116   return inters;
107 }                                                 117 }
108                                                   118 
109 //--------------------------------------------    119 //---------------------------------------------------------------------
110                                                   120 
111 G4double G4ErrorPlaneSurfaceTarget::              121 G4double G4ErrorPlaneSurfaceTarget::
112 GetDistanceFromPoint( const G4ThreeVector& pt,    122 GetDistanceFromPoint( const G4ThreeVector& pt, const G4ThreeVector& dir ) const
113 {                                                 123 {
114   if( std::fabs( dir.mag() -1. ) > 1.E-6 )        124   if( std::fabs( dir.mag() -1. ) > 1.E-6 )
115   {                                               125   {
116     std::ostringstream message;                   126     std::ostringstream message;
117     message << "Direction is not a unit vector    127     message << "Direction is not a unit vector: " << dir << " !";
118     G4Exception("G4ErrorPlaneSurfaceTarget::Ge    128     G4Exception("G4ErrorPlaneSurfaceTarget::GetDistanceFromPoint()",
119                 "GeomMgt1002", JustWarning, me    129                 "GeomMgt1002", JustWarning, message);
120   }                                               130   }
121   G4double dist = -(a_ * pt.x() + b_ * pt.y()     131   G4double dist = -(a_ * pt.x() + b_ * pt.y() + c_ * pt.z() + d_)
122                  / (a_ * dir.x() + b_ * dir.y(    132                  / (a_ * dir.x() + b_ * dir.y() + c_ * dir.z() );
123                                                   133 
124 #ifdef G4VERBOSE                                  134 #ifdef G4VERBOSE
125   if(G4ErrorPropagatorData::verbose() >= 3 )      135   if(G4ErrorPropagatorData::verbose() >= 3 )
126   {                                               136   {
127     G4cout << " G4ErrorPlaneSurfaceTarget::Get    137     G4cout << " G4ErrorPlaneSurfaceTarget::GetDistanceFromPoint()" << G4endl
128            << "   Point: " << pt << ", Directi    138            << "   Point: " << pt << ", Direction: " << dir << G4endl
129            << "   Distance: " << dist << G4end    139            << "   Distance: " << dist << G4endl;
130   }                                               140   }
131 #endif                                            141 #endif
132                                                   142   
133   return dist;                                    143   return dist;
134 }                                                 144 }
135                                                   145 
136 //--------------------------------------------    146 //---------------------------------------------------------------------
137                                                   147 
138 G4double G4ErrorPlaneSurfaceTarget::              148 G4double G4ErrorPlaneSurfaceTarget::
139 GetDistanceFromPoint( const G4ThreeVector& pt     149 GetDistanceFromPoint( const G4ThreeVector& pt ) const
140 {                                                 150 {
141   G4ThreeVector vec = point() - pt;               151   G4ThreeVector vec = point() - pt;
142   G4double dist = std::fabs(vec * normal() / n << 152   G4double alpha = std::acos( vec * normal() / vec.mag() / normal().mag() );
                                                   >> 153   G4double dist = std::fabs(vec.mag() * std::cos( alpha ));
143                                                   154   
144 #ifdef G4VERBOSE                                  155 #ifdef G4VERBOSE
145   if(G4ErrorPropagatorData::verbose() >= 3 )      156   if(G4ErrorPropagatorData::verbose() >= 3 )
146   {                                               157   {
147     G4cout << " G4ErrorPlaneSurfaceTarget::Get    158     G4cout << " G4ErrorPlaneSurfaceTarget::GetDistanceFromPoint()" << G4endl
148            << "   Point: " << pt << G4endl        159            << "   Point: " << pt << G4endl
149            << "   Distance: " << dist << G4end    160            << "   Distance: " << dist << G4endl;
150   }                                               161   }
151 #endif                                            162 #endif
152                                                   163 
153   return dist;                                    164   return dist;
154 }                                                 165 }
155                                                   166 
156 //--------------------------------------------    167 //---------------------------------------------------------------------
157                                                   168 
158 G4Plane3D G4ErrorPlaneSurfaceTarget::             169 G4Plane3D G4ErrorPlaneSurfaceTarget::
159 GetTangentPlane( const G4ThreeVector& ) const     170 GetTangentPlane( const G4ThreeVector& ) const
160 {                                                 171 {
161   return *this;                                   172   return *this;
162 }                                                 173 }
163                                                   174 
164 //-------------------------------------------- << 
165                                                   175 
166 void G4ErrorPlaneSurfaceTarget::Dump( const G4    176 void G4ErrorPlaneSurfaceTarget::Dump( const G4String& msg ) const
167 {                                                 177 {
168   G4cout << msg << " point = " << point()         178   G4cout << msg << " point = " << point()
169                 << " normal = " << normal() <<    179                 << " normal = " << normal() << G4endl;
170 }                                                 180 }
171                                                   181