Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/materials/src/G4LatticePhysical.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 /materials/src/G4LatticePhysical.cc (Version 11.3.0) and /materials/src/G4LatticePhysical.cc (Version 10.0.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                                                <<  25 //
 26 /// \file materials/src/G4LatticePhysical.cc       26 /// \file materials/src/G4LatticePhysical.cc
 27 /// \brief Implementation of the G4LatticePhys     27 /// \brief Implementation of the G4LatticePhysical class
 28 //                                                 28 //
                                                   >>  29 // $Id: G4LatticePhysical.cc 76883 2013-11-18 12:50:08Z gcosmo $
 29 //                                                 30 //
 30 // 20131115  Save rotation results in local va     31 // 20131115  Save rotation results in local variable, report verbosely
 31 // 20131116  Replace G4Transform3D with G4Rota     32 // 20131116  Replace G4Transform3D with G4RotationMatrix
 32                                                    33 
 33 #include "G4LatticePhysical.hh"                    34 #include "G4LatticePhysical.hh"
 34                                                << 
 35 #include "G4LatticeLogical.hh"                     35 #include "G4LatticeLogical.hh"
 36 #include "G4PhysicalConstants.hh"                  36 #include "G4PhysicalConstants.hh"
 37 #include "G4RotationMatrix.hh"                     37 #include "G4RotationMatrix.hh"
 38 #include "G4SystemOfUnits.hh"                      38 #include "G4SystemOfUnits.hh"
 39                                                    39 
                                                   >>  40 
 40 // Unit vectors defined for convenience (avoid     41 // Unit vectors defined for convenience (avoid memory churn)
 41                                                    42 
 42 namespace                                      <<  43 namespace {
 43 {                                              <<  44   G4ThreeVector xhat(1,0,0), yhat(0,1,0), zhat(0,0,1), nullVec(0,0,0);
 44 G4ThreeVector xhat(1, 0, 0), yhat(0, 1, 0), zh << 
 45 }                                                  45 }
 46                                                    46 
 47                                                    47 
 48 G4LatticePhysical::G4LatticePhysical(const G4L <<  48 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 49   : fLattice(Lat)                              <<  49 
 50 {                                              <<  50 G4LatticePhysical::G4LatticePhysical(const G4LatticeLogical* Lat,
                                                   >>  51              const G4RotationMatrix* Rot)
                                                   >>  52   : verboseLevel(0), fTheta(0), fPhi(0), fLattice(Lat) {
 51   SetPhysicalOrientation(Rot);                     53   SetPhysicalOrientation(Rot);
 52 }                                                  54 }
 53                                                    55 
                                                   >>  56 G4LatticePhysical::~G4LatticePhysical() {;}
                                                   >>  57 
 54                                                    58 
 55 void G4LatticePhysical::SetPhysicalOrientation <<  59 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 56 {                                              <<  60 
 57   if (Rot == nullptr) {  // No orientation spe <<  61 void G4LatticePhysical::SetPhysicalOrientation(const G4RotationMatrix* Rot) {
                                                   >>  62   if (!Rot) {         // No orientation specified
 58     fLocalToGlobal = fGlobalToLocal = G4Rotati     63     fLocalToGlobal = fGlobalToLocal = G4RotationMatrix::IDENTITY;
 59   }                                            <<  64   } else {
 60   else {                                       <<  65     fLocalToGlobal = fGlobalToLocal = *Rot;   // Frame rotation
 61     fLocalToGlobal = fGlobalToLocal = *Rot;  / << 
 62     fGlobalToLocal.invert();                       66     fGlobalToLocal.invert();
 63   }                                                67   }
 64                                                    68 
 65   if (verboseLevel > 0) {                      <<  69   if (verboseLevel) {
 66     G4cout << "G4LatticePhysical::SetPhysicalO <<  70     G4cout << "G4LatticePhysical::SetPhysicalOrientation " << *Rot
 67     if (Rot != nullptr) { G4cout << *Rot; }    <<  71      << "\nfLocalToGlobal: " << fLocalToGlobal
 68     else { G4cout << " 0 "; }                  <<  72      << "\nfGlobalToLocal: " << fGlobalToLocal
 69     G4cout << "\nfLocalToGlobal: " << fLocalTo <<  73      << G4endl;
 70            << G4endl;                          << 
 71   }                                                74   }
 72 }                                                  75 }
 73                                                    76 
                                                   >>  77 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 74                                                    78 
 75 void G4LatticePhysical::SetLatticeOrientation( <<  79 void G4LatticePhysical::SetLatticeOrientation(G4double t_rot, G4double p_rot) {
 76 {                                              << 
 77   fTheta = t_rot;                                  80   fTheta = t_rot;
 78   fPhi = p_rot;                                    81   fPhi = p_rot;
 79                                                    82 
 80   if (verboseLevel != 0) {                     <<  83   if (verboseLevel) 
 81     G4cout << "G4LatticePhysical::SetLatticeOr <<  84     G4cout << "G4LatticePhysical::SetLatticeOrientation " << fTheta << " "
 82   }                                            <<  85      << fPhi << G4endl;
 83 }                                                  86 }
 84                                                    87 
                                                   >>  88 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 85                                                    89 
 86 void G4LatticePhysical::SetMillerOrientation(G <<  90 void G4LatticePhysical::SetMillerOrientation(G4int l, G4int k, G4int n) {
 87 {                                              <<  91   fTheta = halfpi - std::atan2(n+0.000001,l+0.000001);
 88   fTheta = halfpi - std::atan2(n + 0.000001, l <<  92   fPhi = halfpi - std::atan2(l+0.000001,k+0.000001);
 89   fPhi = halfpi - std::atan2(l + 0.000001, k + <<  93 
 90                                                <<  94   if (verboseLevel) 
 91   if (verboseLevel != 0) {                     <<  95     G4cout << "G4LatticePhysical::SetMillerOrientation(" << l << k << n 
 92     G4cout << "G4LatticePhysical::SetMillerOri <<  96      << ") : " << fTheta << " " << fPhi << G4endl;
 93            << fPhi << G4endl;                  << 
 94   }                                            << 
 95 }                                                  97 }
 96                                                    98 
 97                                                    99 
                                                   >> 100 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
                                                   >> 101 
 98 ///////////////////////////////                   102 ///////////////////////////////
 99 // Loads the group velocity in m/s             << 103 //Loads the group velocity in m/s
100 /////////////////////////////                     104 /////////////////////////////
101 G4double G4LatticePhysical::MapKtoV(G4int pola << 105 G4double G4LatticePhysical::MapKtoV(G4int polarizationState,
102 {                                              << 106             G4ThreeVector k) const {
103   if (verboseLevel > 1) {                      << 107   if (verboseLevel>1) G4cout << "G4LatticePhysical::MapKtoV " << k << G4endl;
104     G4cout << "G4LatticePhysical::MapKtoV " << << 
105   }                                            << 
106                                                   108 
107   k.rotate(yhat, fTheta).rotate(zhat, fPhi);   << 109   k.rotate(yhat,fTheta).rotate(zhat, fPhi);
108   return fLattice->MapKtoV(polarizationState,     110   return fLattice->MapKtoV(polarizationState, k);
109 }                                                 111 }
110                                                   112 
111 ///////////////////////////////                   113 ///////////////////////////////
112 // Loads the normalized direction vector along << 114 //Loads the normalized direction vector along VG
113 ///////////////////////////////                   115 ///////////////////////////////
114 G4ThreeVector G4LatticePhysical::MapKtoVDir(G4 << 116 G4ThreeVector G4LatticePhysical::MapKtoVDir(G4int polarizationState,
115 {                                              << 117               G4ThreeVector k) const {
116   if (verboseLevel > 1) {                      << 118   if (verboseLevel>1) G4cout << "G4LatticePhysical::MapKtoVDir " << k << G4endl;
117     G4cout << "G4LatticePhysical::MapKtoVDir " << 
118   }                                            << 
119                                                   119 
120   k.rotate(yhat, fTheta).rotate(zhat, fPhi);   << 120   k.rotate(yhat,fTheta).rotate(zhat,fPhi);
121                                                   121 
122   G4ThreeVector VG = fLattice->MapKtoVDir(pola << 122   G4ThreeVector VG = fLattice->MapKtoVDir(polarizationState, k);  
123                                                   123 
124   return VG.rotate(zhat, -fPhi).rotate(yhat, - << 124   return VG.rotate(zhat,-fPhi).rotate(yhat,-fTheta);
125 }                                                 125 }
126                                                   126 
                                                   >> 127 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
127                                                   128 
128 // Apply orientation transforms to specified v    129 // Apply orientation transforms to specified vector
129                                                   130 
130 G4ThreeVector G4LatticePhysical::RotateToGloba << 131 G4ThreeVector 
131 {                                              << 132 G4LatticePhysical::RotateToGlobal(const G4ThreeVector& dir) const {
132   if (verboseLevel > 1) {                      << 133   if (verboseLevel>1) {
133     G4cout << "G4LatticePhysical::RotateToGlob << 134     G4cout << "G4LatticePhysical::RotateToGlobal " << dir
134            << fLocalToGlobal << G4endl;        << 135      << "\nusing fLocalToGlobal " << fLocalToGlobal
                                                   >> 136      << G4endl;
135   }                                               137   }
136                                                   138 
137   G4ThreeVector result = fLocalToGlobal * dir; << 139   G4ThreeVector result = fLocalToGlobal*dir;
138   if (verboseLevel > 1) {                      << 140   if (verboseLevel>1) G4cout << " result " << result << G4endl;
139     G4cout << " result " << result << G4endl;  << 
140   }                                            << 
141                                                   141 
142   return result;                                  142   return result;
143 }                                                 143 }
144                                                   144 
145 G4ThreeVector G4LatticePhysical::RotateToLocal << 145 G4ThreeVector 
146 {                                              << 146 G4LatticePhysical::RotateToLocal(const G4ThreeVector& dir) const {
147   if (verboseLevel > 1) {                      << 147   if (verboseLevel>1) {
148     G4cout << "G4LatticePhysical::RotateToLoca << 148     G4cout << "G4LatticePhysical::RotateToLocal " << dir
149            << fGlobalToLocal << G4endl;        << 149      << "\nusing fGlobalToLocal " << fGlobalToLocal
                                                   >> 150      << G4endl;
150   }                                               151   }
151                                                   152 
152   G4ThreeVector result = fGlobalToLocal * dir; << 153   G4ThreeVector result = fGlobalToLocal*dir;
153   if (verboseLevel > 1) {                      << 154   if (verboseLevel>1) G4cout << " result " << result << G4endl;
154     G4cout << " result " << result << G4endl;  << 
155   }                                            << 
156                                                   155 
157   return result;                                  156   return result;
158 }                                                 157 }
159                                                   158