Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/g3tog4/src/G3toG4MANY.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 /g3tog4/src/G3toG4MANY.cc (Version 11.3.0) and /g3tog4/src/G3toG4MANY.cc (Version 5.2.p2)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
 26 //                                                 23 //
                                                   >>  24 // $Id: G3toG4MANY.cc,v 1.1 2001/11/08 16:08:01 gcosmo Exp $
                                                   >>  25 // GEANT4 tag $Name: geant4-05-02-patch-01 $
 27 //                                                 26 //
 28 // By I. Hrivnacova, 22.10.01                      27 // By I. Hrivnacova, 22.10.01 
 29                                                    28 
 30 //#define G3G4DEBUG 1                              29 //#define G3G4DEBUG 1
 31                                                    30 
 32 #include "globals.hh"                              31 #include "globals.hh"
 33 #include "G3toG4MANY.hh"                           32 #include "G3toG4MANY.hh"
 34 #include "G3Pos.hh"                                33 #include "G3Pos.hh"
 35 #include "G3RotTable.hh"                           34 #include "G3RotTable.hh"
 36 #include "G4SubtractionSolid.hh"                   35 #include "G4SubtractionSolid.hh"
 37                                                    36 
 38 void G3toG4MANY(G3VolTableEntry* curVTE)           37 void G3toG4MANY(G3VolTableEntry* curVTE)
 39 {                                                  38 {
 40   if (curVTE->GetNoOverlaps() > 0) {               39   if (curVTE->GetNoOverlaps() > 0) {
 41                                                    40   
 42     // check consistency                           41     // check consistency 
 43     if (!curVTE->HasMANY()) {                      42     if (!curVTE->HasMANY()) { 
 44       G4String text = "G3toG4MANY: volume ";       43       G4String text = "G3toG4MANY: volume ";
 45       text = text + curVTE->GetName() + " has      44       text = text + curVTE->GetName() + " has specified overlaps \n";
 46       text = text + " but is not defined as MA     45       text = text + " but is not defined as MANY.";
 47       G4Exception("G3toG4MANY()", "G3toG40009" <<  46       G4Exception(text);
 48                   FatalException, text);       << 
 49       return;                                  << 
 50     }                                              47     }  
 51                                                    48 
 52     // only MANY volumes with one position are     49     // only MANY volumes with one position are supported
 53     if (curVTE->NPCopies() != 1) {                 50     if (curVTE->NPCopies() != 1) {
 54       G4String text = "G3toG4MANY: volume ";       51       G4String text = "G3toG4MANY: volume ";
 55       text = text + curVTE->GetName() + " whic     52       text = text + curVTE->GetName() + " which has MANY has not just one position.";
 56       G4Exception("G3toG4MANY()", "G3toG40010" <<  53       G4Exception(text);
 57                   FatalException, text);       << 
 58       return;                                  << 
 59     }                                              54     }  
 60                                                    55 
 61     #ifdef G3G4DEBUG                               56     #ifdef G3G4DEBUG
 62     G4cout << "G3toG4MANY  " << curVTE->GetNam     57     G4cout << "G3toG4MANY  " << curVTE->GetName() << " boolean" << G4endl;
 63     #endif                                         58     #endif
 64                                                    59 
 65     G4Transform3D transform = GetTransform3D(c     60     G4Transform3D transform = GetTransform3D(curVTE->GetG3PosCopy(0)); 
 66                                                    61     
 67     MakeBooleanSolids(curVTE, curVTE->GetOverl     62     MakeBooleanSolids(curVTE, curVTE->GetOverlaps(), transform.inverse());
 68   }                                                63   }
 69                                                    64 
 70   // process daughters                             65   // process daughters
 71   for (G4int i=0; i<curVTE->GetNoDaughters();      66   for (G4int i=0; i<curVTE->GetNoDaughters(); i++)
 72     G3toG4MANY(curVTE->GetDaughter(i));            67     G3toG4MANY(curVTE->GetDaughter(i));
 73 }                                                  68 }
 74                                                    69 
 75 void MakeBooleanSolids(G3VolTableEntry* curVTE     70 void MakeBooleanSolids(G3VolTableEntry* curVTE, G3VolTableEntryVector* overlaps,
 76            const G4Transform3D& transform)         71            const G4Transform3D& transform)
 77 {                                                  72 {          
 78   // loop over overlap VTEs                        73   // loop over overlap VTEs
 79   for (size_t i=0; i<overlaps->size(); i++){       74   for (size_t i=0; i<overlaps->size(); i++){
 80                                                    75    
 81     G3VolTableEntry* overlapVTE = (*overlaps)[     76     G3VolTableEntry* overlapVTE = (*overlaps)[i]; 
 82                                                    77 
 83      // loop over clone VTEs                       78      // loop over clone VTEs
 84     for (G4int ij=0; ij<overlapVTE->GetMasterC     79     for (G4int ij=0; ij<overlapVTE->GetMasterClone()->GetNoClones(); ij++){
 85                                                    80     
 86       G3VolTableEntry* cloneVTE = overlapVTE->     81       G3VolTableEntry* cloneVTE = overlapVTE->GetMasterClone()->GetClone(ij);   
 87                                                    82    
 88       // loop over clone positions                 83       // loop over clone positions
 89       for (G4int j=0; j<cloneVTE->NPCopies();      84       for (G4int j=0; j<cloneVTE->NPCopies(); j++){
 90                                                    85 
 91         #ifdef G3G4DEBUG                           86         #ifdef G3G4DEBUG
 92         G4cout << "From '" << curVTE->GetName(     87         G4cout << "From '" << curVTE->GetName() << "' "
 93          << "cut '" << cloneVTE->GetName() <<      88          << "cut '" << cloneVTE->GetName() << "' :"
 94          << i  << "th overlap (from " << overl     89          << i  << "th overlap (from " << overlaps->size() << ") "
 95          << ij << "th clone (from " << overlap     90          << ij << "th clone (from " << overlapVTE->GetMasterClone()->GetNoClones() << ") "
 96          << j  << "th copy (from " << cloneVTE     91          << j  << "th copy (from " << cloneVTE->NPCopies() << ")  "
 97          << G4endl;                                92          << G4endl;
 98         #endif                                     93         #endif
 99                                                    94 
100         SubstractSolids(curVTE, cloneVTE, j, t     95         SubstractSolids(curVTE, cloneVTE, j, transform); 
101       }                                            96       }
102     }                                              97     }    
103   }                                                98   }         
104 }                                                  99 }     
105                                                   100 
106 void SubstractSolids(G3VolTableEntry* vte1, G3    101 void SubstractSolids(G3VolTableEntry* vte1, G3VolTableEntry* vte2,
107                G4int copy, const G4Transform3D    102                G4int copy, const G4Transform3D& transform)
108 {                                                 103 {          
109   // vte2 transformation                          104   // vte2 transformation
110   G4Transform3D transform2 = GetTransform3D(vt    105   G4Transform3D transform2 = GetTransform3D(vte2->GetG3PosCopy(copy));
111                                                   106    
112   // compose new name                             107   // compose new name 
113   G4String newName = vte1->GetSolid()->GetName    108   G4String newName = vte1->GetSolid()->GetName();
114   newName = newName + "-" + vte2->GetSolid()->    109   newName = newName + "-" + vte2->GetSolid()->GetName();   
115                                                   110 
116   #ifdef G3G4DEBUG                                111   #ifdef G3G4DEBUG
117   G4cout << "   " << newName << G4endl;           112   G4cout << "   " << newName << G4endl; 
118   #endif                                          113   #endif
119                                                   114 
120   G4VSolid* newSolid                              115   G4VSolid* newSolid 
121     = new G4SubtractionSolid(newName, vte1->Ge    116     = new G4SubtractionSolid(newName, vte1->GetSolid(), vte2->GetSolid(),
122                              transform*transfo    117                              transform*transform2);
123                                                   118          
124   // update vte1                                  119   // update vte1
125   vte1->SetSolid(newSolid);                       120   vte1->SetSolid(newSolid);
126                                                   121 
127   // process daughters                            122   // process daughters
128   for (G4int k=0; k<vte1->GetNoDaughters(); k+    123   for (G4int k=0; k<vte1->GetNoDaughters(); k++){
129                                                   124           
130     G3VolTableEntry* dVTE = vte1->GetDaughter(    125     G3VolTableEntry* dVTE = vte1->GetDaughter(k);       
131                                                   126    
132     if (dVTE->NPCopies() != 1) {                  127     if (dVTE->NPCopies() != 1) {
133       G4String text = "G3toG4MANY: volume ";      128       G4String text = "G3toG4MANY: volume ";
134       text = text + dVTE->GetName() + " which     129       text = text + dVTE->GetName() + " which has MANY has not just one position.";
135       G4Exception("G3toG4MANY()", "G3toG40011" << 130       G4Exception(text);
136                   FatalException, text);       << 
137       return;                                  << 
138     }                                             131     }
139                                                   132     
140     G4Transform3D dt = GetTransform3D(dVTE->Ge    133     G4Transform3D dt = GetTransform3D(dVTE->GetG3PosCopy(0)); 
141     SubstractSolids(dVTE, vte2, copy, dt.inver    134     SubstractSolids(dVTE, vte2, copy, dt.inverse()*transform);
142   }                                               135   } 
143 }                                                 136 }     
144                                                   137 
145 G4Transform3D GetTransform3D(G3Pos* g3pos)        138 G4Transform3D GetTransform3D(G3Pos* g3pos)
146 {                                                 139 {
147   G4int irot = g3pos->GetIrot();                  140   G4int irot = g3pos->GetIrot();
148   G4RotationMatrix* theMatrix = 0;                141   G4RotationMatrix* theMatrix = 0;
149   if (irot>0) theMatrix = G3Rot.Get(irot);        142   if (irot>0) theMatrix = G3Rot.Get(irot);
150                                                   143   
151   G4Rotate3D rotation;                            144   G4Rotate3D rotation;
152   if (theMatrix) {                                145   if (theMatrix) {            
153      rotation = G4Rotate3D(*theMatrix);           146      rotation = G4Rotate3D(*theMatrix);
154   }                                               147   }
155                                                   148 
156   G4Translate3D translation(*(g3pos->GetPos())    149   G4Translate3D translation(*(g3pos->GetPos()));
157   G4Transform3D transform3D = translation * (r    150   G4Transform3D transform3D = translation * (rotation.inverse());
158                                                   151   
159   return transform3D;                             152   return transform3D;
160 }                                                 153 }
161                                                   154 
162                                                   155 
163                                                   156