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