Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/persistency/ascii/src/G4tgbRotationMatrixMgr.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 /persistency/ascii/src/G4tgbRotationMatrixMgr.cc (Version 11.3.0) and /persistency/ascii/src/G4tgbRotationMatrixMgr.cc (Version 10.0.p4)


  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 // G4tgbRotationMatrixMgr implementation       << 
 27 //                                                 26 //
 28 // Author: P.Arce, CIEMAT (November 2007)      <<  27 // $Id: G4tgbRotationMatrixMgr.cc 66872 2013-01-15 01:25:57Z japost $
 29 // ------------------------------------------- <<  28 //
                                                   >>  29 //
                                                   >>  30 // class G4tgbRotationMatrixMgr
                                                   >>  31 
                                                   >>  32 // History:
                                                   >>  33 // - Created.                                 P.Arce, CIEMAT (November 2007)
                                                   >>  34 // -------------------------------------------------------------------------
 30                                                    35 
 31 #include "G4tgbRotationMatrixMgr.hh"               36 #include "G4tgbRotationMatrixMgr.hh"
 32                                                    37 
 33 #include "G4SystemOfUnits.hh"                      38 #include "G4SystemOfUnits.hh"
 34 #include "G4tgrRotationMatrixFactory.hh"           39 #include "G4tgrRotationMatrixFactory.hh"
 35 #include "G4tgrMessenger.hh"                       40 #include "G4tgrMessenger.hh"
 36                                                    41 
 37 G4ThreadLocal G4tgbRotationMatrixMgr*          <<  42 // -------------------------------------------------------------------------
 38               G4tgbRotationMatrixMgr::theInsta <<  43 
                                                   >>  44 G4ThreadLocal G4tgbRotationMatrixMgr * G4tgbRotationMatrixMgr::theInstance = 0;
                                                   >>  45 
 39                                                    46 
 40 // ------------------------------------------- <<  47 // -------------------------------------------------------------------------
 41 G4tgbRotationMatrixMgr::G4tgbRotationMatrixMgr     48 G4tgbRotationMatrixMgr::G4tgbRotationMatrixMgr()
 42 {                                                  49 {
 43 }                                                  50 }
 44                                                    51 
 45 // ------------------------------------------- <<  52 
                                                   >>  53 // -------------------------------------------------------------------------
 46 G4tgbRotationMatrixMgr* G4tgbRotationMatrixMgr     54 G4tgbRotationMatrixMgr* G4tgbRotationMatrixMgr::GetInstance()
 47 {                                                  55 {
 48   if(theInstance == nullptr)                   <<  56   if( !theInstance )
 49   {                                                57   {
 50     theInstance = new G4tgbRotationMatrixMgr;      58     theInstance = new G4tgbRotationMatrixMgr;
 51     theInstance->CopyRotMats();                    59     theInstance->CopyRotMats();
 52   }                                                60   }
 53   return theInstance;                              61   return theInstance;
 54 }                                                  62 }
 55                                                    63 
 56 // ------------------------------------------- <<  64 
                                                   >>  65 // -------------------------------------------------------------------------
 57 G4tgbRotationMatrixMgr::~G4tgbRotationMatrixMg     66 G4tgbRotationMatrixMgr::~G4tgbRotationMatrixMgr()
 58 {                                                  67 {
 59   for(auto tgbcite = theTgbRotMats.cbegin();   <<  68   G4mstgbrotm::const_iterator tgbcite;
 60            tgbcite != theTgbRotMats.cend(); ++ <<  69   for( tgbcite = theTgbRotMats.begin();
                                                   >>  70        tgbcite != theTgbRotMats.end(); tgbcite++)
 61   {                                                71   {
 62     delete(*tgbcite).second;                   <<  72     delete (*tgbcite).second;
 63   }                                                73   }
 64   theTgbRotMats.clear();                           74   theTgbRotMats.clear();
 65   delete theInstance;                              75   delete theInstance;
 66 }                                                  76 }
 67                                                    77 
 68 // ------------------------------------------- <<  78 
                                                   >>  79 // -------------------------------------------------------------------------
 69 void G4tgbRotationMatrixMgr::CopyRotMats()         80 void G4tgbRotationMatrixMgr::CopyRotMats()
 70 {                                                  81 {
 71   G4mstgrrotm tgrRotms =                           82   G4mstgrrotm tgrRotms =
 72     G4tgrRotationMatrixFactory::GetInstance()-     83     G4tgrRotationMatrixFactory::GetInstance()->GetRotMatMap();
 73   for(auto cite = tgrRotms.cbegin(); cite != t <<  84   G4mstgrrotm::iterator cite;
                                                   >>  85   for( cite = tgrRotms.begin(); cite != tgrRotms.end(); cite++ )
 74   {                                                86   {
 75     G4tgrRotationMatrix* tgr      = (*cite).se <<  87     G4tgrRotationMatrix* tgr = (*cite).second;
 76     G4tgbRotationMatrix* tgb      = new G4tgbR <<  88     G4tgbRotationMatrix* tgb = new G4tgbRotationMatrix( tgr );
 77     theTgbRotMats[tgb->GetName()] = tgb;           89     theTgbRotMats[tgb->GetName()] = tgb;
 78   }                                                90   }
 79 }                                                  91 }
 80                                                    92 
 81 // ------------------------------------------- <<  93 
 82 G4RotationMatrix* G4tgbRotationMatrixMgr::Find <<  94 // -------------------------------------------------------------------------
 83   const G4String& name)                        <<  95 G4RotationMatrix*
                                                   >>  96 G4tgbRotationMatrixMgr::FindOrBuildG4RotMatrix(const G4String& name)
 84 {                                                  97 {
 85 #ifdef G4VERBOSE                                   98 #ifdef G4VERBOSE
 86   if(G4tgrMessenger::GetVerboseLevel() >= 2)   <<  99   if( G4tgrMessenger::GetVerboseLevel() >= 2 )
 87   {                                               100   {
 88     G4cout << " G4tgbRotationMatrixMgr::FindOr << 101     G4cout << " G4tgbRotationMatrixMgr::FindOrBuildG4RotMatrix() - "
 89            << G4endl;                          << 102            << name << G4endl;
 90   }                                               103   }
 91 #endif                                            104 #endif
 92   G4RotationMatrix* g4rotm = FindG4RotMatrix(n << 105   G4RotationMatrix* g4rotm = FindG4RotMatrix( name );
 93   if(g4rotm == nullptr)                        << 106   if( g4rotm == 0 )
 94   {                                               107   {
 95     G4tgbRotationMatrix* hrotm = FindOrBuildTg << 108     G4tgbRotationMatrix* hrotm = FindOrBuildTgbRotMatrix( name );
 96     // GetRotMatrix() never returns 0, otherwi    109     // GetRotMatrix() never returns 0, otherwise if not found, it crashes
 97     g4rotm = hrotm->BuildG4RotMatrix();           110     g4rotm = hrotm->BuildG4RotMatrix();
 98   }                                               111   }
 99   return g4rotm;                                  112   return g4rotm;
100 }                                              << 113 }        
                                                   >> 114 
101                                                   115 
102 // ------------------------------------------- << 116 // -------------------------------------------------------------------------
103 G4RotationMatrix* G4tgbRotationMatrixMgr::Find    117 G4RotationMatrix* G4tgbRotationMatrixMgr::FindG4RotMatrix(const G4String& name)
104 {                                                 118 {
105   G4RotationMatrix* g4rotm = nullptr;          << 119   G4RotationMatrix* g4rotm = 0;
106                                                   120 
107   G4msg4rotm::const_iterator cite = theG4RotMa << 121   G4msg4rotm::const_iterator cite = theG4RotMats.find( name );
108   if(cite != theG4RotMats.cend())              << 122   if( cite != theG4RotMats.end() )
109   {                                               123   {
110     g4rotm = (*cite).second;                      124     g4rotm = (*cite).second;
111   }                                            << 125   } 
112                                                   126 
113 #ifdef G4VERBOSE                                  127 #ifdef G4VERBOSE
114   if(G4tgrMessenger::GetVerboseLevel() >= 2)   << 128   if( G4tgrMessenger::GetVerboseLevel() >= 2 )
115   {                                               129   {
116     G4cout << " G4tgbRotationMatrixMgr::FindG4    130     G4cout << " G4tgbRotationMatrixMgr::FindG4RotMatrix(): " << G4endl
117            << "   Name: " << name << " = " <<     131            << "   Name: " << name << " = " << g4rotm << G4endl;
118   }                                               132   }
119 #endif                                            133 #endif
120                                                << 134   
121   return g4rotm;                                  135   return g4rotm;
122 }                                                 136 }
123                                                   137 
124 // ------------------------------------------- << 138 
                                                   >> 139 // -------------------------------------------------------------------------
125 G4tgbRotationMatrix*                              140 G4tgbRotationMatrix*
126 G4tgbRotationMatrixMgr::FindOrBuildTgbRotMatri    141 G4tgbRotationMatrixMgr::FindOrBuildTgbRotMatrix(const G4String& name)
127 {                                                 142 {
128   G4tgbRotationMatrix* rotm = FindTgbRotMatrix << 143   G4tgbRotationMatrix* rotm = FindTgbRotMatrix( name );
129                                                   144 
130   if(rotm == nullptr)                          << 145   if( rotm == 0 )
131   {                                               146   {
132     G4String ErrMessage = "Rotation Matrix " +    147     G4String ErrMessage = "Rotation Matrix " + name + " not found !";
133     G4Exception("G4tgbRotationMatrixFactory::F    148     G4Exception("G4tgbRotationMatrixFactory::FindOrBuildRotMatrix()",
134                 "InvalidSetup", FatalException << 149                 "InvalidSetup", FatalException, ErrMessage); 
135   }                                               150   }
136   return rotm;                                    151   return rotm;
137 }                                                 152 }
138                                                   153 
139 // ------------------------------------------- << 154 
140 G4tgbRotationMatrix* G4tgbRotationMatrixMgr::F << 155 // -------------------------------------------------------------------------
141   const G4String& name)                        << 156 G4tgbRotationMatrix*
                                                   >> 157 G4tgbRotationMatrixMgr::FindTgbRotMatrix(const G4String& name)
142 {                                                 158 {
143   G4tgbRotationMatrix* rotm = nullptr;         << 159   G4tgbRotationMatrix* rotm = 0;
144                                                   160 
145   G4mstgbrotm::const_iterator cite = theTgbRot << 161   G4mstgbrotm::const_iterator cite = theTgbRotMats.find( name );
146   if(cite != theTgbRotMats.cend())             << 162   if( cite != theTgbRotMats.end() )
147   {                                               163   {
148     rotm = (*cite).second;                        164     rotm = (*cite).second;
149   }                                               165   }
150   return rotm;                                    166   return rotm;
151 }                                                 167 }
152                                                   168 
153 // ------------------------------------------- << 169 
154 std::ostream& operator<<(std::ostream& os, con << 170 // -------------------------------------------------------------------------
                                                   >> 171 std::ostream& operator<<(std::ostream& os , const G4RotationMatrix & rot)
155 {                                                 172 {
156   os << "[ " << rot.thetaX() / deg << '\t' <<  << 173   os << "[ " 
157      << rot.thetaY() / deg << '\t' << rot.phiY << 174      << rot.thetaX()/deg << '\t' << rot.phiX()/deg << '\t'
158      << rot.thetaZ() / deg << '\t' << rot.phiZ << 175      << rot.thetaY()/deg << '\t' << rot.phiY()/deg << '\t'
                                                   >> 176      << rot.thetaZ()/deg << '\t' << rot.phiZ()/deg << " ]"
                                                   >> 177      << G4endl;
159   return os;                                      178   return os;
160 }                                                 179 }
161                                                   180