Import Geant4 4.0.0 source tree

source/g3tog4/src/G3VolTableEntry.cc

@@ -21,29 +21,32 @@
 // ********************************************************************
 //
 //
-// $Id: G3VolTableEntry.cc,v 1.7.2.1 2001/06/28 19:08:04 gunter Exp $
-// GEANT4 tag $Name:  $
+// $Id: G3VolTableEntry.cc,v 1.10 2001/11/08 16:08:00 gcosmo Exp $
+// GEANT4 tag $Name: geant4-04-00 $
 //
 // modified by I.Hrivnacova, 13.10.99
 
 #include "globals.hh"
 #include "G3VolTableEntry.hh"
 #include "G3VolTable.hh"
+#include "G3RotTable.hh"
 #include "G4LogicalVolume.hh"
+#include "G4SubtractionSolid.hh"
 #include "G3Pos.hh"
 #include "G3toG4.hh"
 
 G3VolTableEntry::G3VolTableEntry(G4String& vname, G4String& shape, 
-			     G4double* rpar, G4int npar, G4int nmed, 
-			     G4VSolid* solid, G4bool hasNegPars)
+			         G4double* rpar, G4int npar, G4int nmed, 
+			         G4VSolid* solid, G4bool hasNegPars)
   : fVname(vname), fShape(shape), fRpar(0), fNpar(npar), fNmed(nmed), 
-    fSolid(solid), fLV(0), fHasNegPars(hasNegPars), fDivision(0)		  		     
+    fSolid(solid), fLV(0), fHasNegPars(hasNegPars), fHasMANY(false),
+    fDivision(0)		  		     
 {
   if (npar>0 && rpar!=0) {
     fRpar = new G4double[npar];
     for (G4int i=0; i<npar; i++) fRpar[i] = rpar[i];
   }
-  fClones.insert(this);
+  fClones.push_back(this);
 }
 
 G3VolTableEntry::~G3VolTableEntry(){
@@ -58,31 +61,42 @@ G3VolTableEntry::operator == ( const G3VolTableEntry& lv) const {
 
 void 
 G3VolTableEntry::AddG3Pos(G3Pos* aG3Pos){
+
+  // insert this position to the vector
   G3Vol.CountG3Pos();
-  fG3Pos.insert(aG3Pos);
+  fG3Pos.push_back(aG3Pos);
+
+  // pass MANY info 
+  G4String vonly = aG3Pos->GetOnly();
+  if (vonly == "MANY") SetHasMANY(true);
 }
 
 void 
 G3VolTableEntry::AddDaughter(G3VolTableEntry* aDaughter){
   if (FindDaughter(aDaughter->GetName()) == 0) {
-    fDaughters.insert(aDaughter);
+    fDaughters.push_back(aDaughter);
   }
 }
 
 void 
 G3VolTableEntry::AddMother(G3VolTableEntry* itsMother){
   if (FindMother(itsMother->GetName()) == 0) {
-    fMothers.insert(itsMother);
+    fMothers.push_back(itsMother);
   }  
 }
 
 void 
 G3VolTableEntry::AddClone(G3VolTableEntry* itsClone){
   if (FindClone(itsClone->GetName()) == 0) {
-    fClones.insert(itsClone);
+    fClones.push_back(itsClone);
   }  
 }
 
+void 
+G3VolTableEntry::AddOverlap(G3VolTableEntry* overlap){
+    fOverlaps.push_back(overlap);
+}
+
 void 
 G3VolTableEntry::ReplaceDaughter(G3VolTableEntry* vteOld, 
                                  G3VolTableEntry* vteNew)
@@ -117,7 +131,7 @@ G3VolTableEntry::ReplaceMother(G3VolTableEntry* vteOld,
 
 G3VolTableEntry*
 G3VolTableEntry::FindDaughter(const G4String& Dname){
-  for (int idau=0; idau<GetNoDaughters(); idau++){
+  for (G4int idau=0; idau<GetNoDaughters(); idau++){
     if (GetDaughter(idau)->GetName() == Dname) return GetDaughter(idau);
   }
   return 0;
@@ -150,6 +164,7 @@ void G3VolTableEntry::PrintSolidInfo() {
   for (G4int i=0; i<fNpar; i++) G4cout << fRpar[i] << " ";
   G4cout << G4endl;
   G4cout << "HasNegPars: " << fHasNegPars << G4endl;
+  G4cout << "HasMANY: " << fHasMANY << G4endl;
   G4cout << "================================= " << G4endl;
 }
 
@@ -185,9 +200,20 @@ void G3VolTableEntry::SetHasNegPars(G4bool hasNegPars) {
   fHasNegPars = hasNegPars;
 }
 
+void G3VolTableEntry::SetHasMANY(G4bool hasMANY) {
+  fHasMANY = hasMANY;
+}
+
 void G3VolTableEntry::ClearG3PosCopy(G4int copy) {
-  if (fG3Pos.entries()>0 && copy>=0 && copy<G4int(fG3Pos.entries())) 
-    fG3Pos.removeAt(copy);
+  if (fG3Pos.size()>0 && copy>=0 && copy<G4int(fG3Pos.size())) {
+    G3Pos* tmp=0;
+     G4std::vector<G3Pos*>::iterator it=fG3Pos.begin();
+     for(G4int j=0;j<copy;j++) it++;
+     if(it!=fG3Pos.end()) {
+         tmp = fG3Pos[copy];
+         fG3Pos.erase(it);
+     }
+  }
 }
 
 void G3VolTableEntry::ClearDivision() {
@@ -222,12 +248,12 @@ G3VolTableEntry::GetRpar() {
 
 G4int 
 G3VolTableEntry::NPCopies() {
-  return fG3Pos.entries();
+  return fG3Pos.size();
 }
 
 G3Pos* 
 G3VolTableEntry::GetG3PosCopy(G4int copy) {
-  if (fG3Pos.entries()>0 && copy>=0)
+  if (fG3Pos.size()>0 && copy>=0)
     return fG3Pos[copy];
   else
     return 0;
@@ -238,6 +264,11 @@ G3VolTableEntry::HasNegPars(){
   return fHasNegPars;
 }
 
+G4bool 
+G3VolTableEntry::HasMANY(){
+  return fHasMANY;
+}
+
 G4VSolid*
 G3VolTableEntry::GetSolid() {
   return fSolid;
@@ -250,22 +281,27 @@ G3VolTableEntry::GetLV() {
 
 G4int
 G3VolTableEntry::GetNoDaughters() {
-  return fDaughters.entries();
+  return fDaughters.size();
 }
 
 G4int
 G3VolTableEntry::GetNoMothers() {
-  return fMothers.entries();
+  return fMothers.size();
 }
 
 G4int
 G3VolTableEntry::GetNoClones() {
-  return fClones.entries();
+  return fClones.size();
+}
+
+G4int
+G3VolTableEntry::GetNoOverlaps() {
+  return fOverlaps.size();
 }
 
 G3VolTableEntry* 
 G3VolTableEntry::GetDaughter(G4int i) {
-  if (i<G4int(fDaughters.entries()) && i>=0)
+  if (i<G4int(fDaughters.size()) && i>=0)
     return fDaughters[i];
   else 
     return 0;
@@ -273,7 +309,7 @@ G3VolTableEntry::GetDaughter(G4int i) {
 
 G3VolTableEntry*
 G3VolTableEntry::GetMother(G4int i){
-  if (i<G4int(fMothers.entries()) && i>=0)
+  if (i<G4int(fMothers.size()) && i>=0)
     return fMothers[i];
   else
     return 0;
@@ -282,7 +318,7 @@ G3VolTableEntry::GetMother(G4int i){
 // to be removed
 G3VolTableEntry*
 G3VolTableEntry::GetMother(){
-  if (fMothers.entries()>0)
+  if (fMothers.size()>0)
     return fMothers[0];
   else
     return 0;  
@@ -290,7 +326,7 @@ G3VolTableEntry::GetMother(){
 
 G3VolTableEntry*
 G3VolTableEntry::GetClone(G4int i){
-  if (i<G4int(fClones.entries()) && i>=0)
+  if (i<G4int(fClones.size()) && i>=0)
     return fClones[i];
   else
     return 0;
@@ -309,3 +345,8 @@ G3VolTableEntry::GetMasterClone(){
 
   return master;
 }
+
+G4std::vector<G3VolTableEntry*>*
+G3VolTableEntry::GetOverlaps(){
+  return &fOverlaps;
+}