G3toG4MANY.hh File Reference

#include <vector>
#include "G3VolTableEntry.hh"
#include "G4Transform3D.hh"

Go to the source code of this file.

Typedefs
typedef std::vector< G3VolTableEntry * >	G3VolTableEntryVector

Functions
void	G3toG4MANY (G3VolTableEntry *curVTE)
G4Transform3D	GetTransform3D (G3Pos *)
void	MakeBooleanSolids (G3VolTableEntry *curVTE, G3VolTableEntryVector *overlaps, const G4Transform3D &transform)
void	SubstractSolids (G3VolTableEntry *vte1, G3VolTableEntry *vte2, G4int copy, const G4Transform3D &transform)

Typedef Documentation

G3VolTableEntryVector

typedef std::vector<G3VolTableEntry*> G3VolTableEntryVector

Definition at line 68 of file G3toG4MANY.hh.

Function Documentation

G3toG4MANY()

void G3toG4MANY

(

G3VolTableEntry *

curVTE

)

Definition at line 38 of file G3toG4MANY.cc.

{
  if (curVTE->GetNoOverlaps() > 0) {
  
    // check consistency 
    if (!curVTE->HasMANY()) { 
      G4String text = "G3toG4MANY: volume ";
      text = text + curVTE->GetName() + " has specified overlaps \n";
      text = text + " but is not defined as MANY.";
      G4Exception("G3toG4MANY()", "G3toG40009",
                  FatalException, text);
      return;
    }  
 
    // only MANY volumes with one position are supported
    if (curVTE->NPCopies() != 1) {
      G4String text = "G3toG4MANY: volume ";
      text = text + curVTE->GetName() + " which has MANY has not just one position.";
      G4Exception("G3toG4MANY()", "G3toG40010",
                  FatalException, text);
      return;
    }  
 
    #ifdef G3G4DEBUG
    G4cout << "G3toG4MANY  " << curVTE->GetName() << " boolean" << G4endl;
    #endif
 
    G4Transform3D transform = GetTransform3D(curVTE->GetG3PosCopy(0)); 
    
    MakeBooleanSolids(curVTE, curVTE->GetOverlaps(), transform.inverse());
  }
 
  // process daughters
  for (G4int i=0; i<curVTE->GetNoDaughters(); i++)
    G3toG4MANY(curVTE->GetDaughter(i));
}

References FatalException, G3toG4MANY(), G4cout, G4endl, G4Exception(), G3VolTableEntry::GetDaughter(), G3VolTableEntry::GetG3PosCopy(), G3VolTableEntry::GetName(), G3VolTableEntry::GetNoDaughters(), G3VolTableEntry::GetNoOverlaps(), G3VolTableEntry::GetOverlaps(), GetTransform3D(), G3VolTableEntry::HasMANY(), MakeBooleanSolids(), G3VolTableEntry::NPCopies(), and G4coutFormatters::anonymous_namespace{G4coutFormatters.cc}::transform().

Referenced by G3toG4MANY().

GetTransform3D()

G4Transform3D GetTransform3D

(

G3Pos *

g3pos

)

Definition at line 145 of file G3toG4MANY.cc.

{
  G4int irot = g3pos->GetIrot();
  G4RotationMatrix* theMatrix = 0;
  if (irot>0) theMatrix = G3Rot.Get(irot);
  
  G4Rotate3D rotation;
  if (theMatrix) {            
     rotation = G4Rotate3D(*theMatrix);
  }
 
  G4Translate3D translation(*(g3pos->GetPos()));
  G4Transform3D transform3D = translation * (rotation.inverse());
  
  return transform3D;
}

References G3Rot, G3RotTable::Get(), G3Pos::GetIrot(), G3Pos::GetPos(), and HepGeom::Transform3D::inverse().

Referenced by G3toG4MANY(), and SubstractSolids().

MakeBooleanSolids()

void MakeBooleanSolids	(	G3VolTableEntry *	curVTE,
		G3VolTableEntryVector *	overlaps,
		const G4Transform3D &	transform
	)

Definition at line 75 of file G3toG4MANY.cc.

{                
  // loop over overlap VTEs
  for (size_t i=0; i<overlaps->size(); i++){
   
    G3VolTableEntry* overlapVTE = (*overlaps)[i]; 
 
     // loop over clone VTEs
    for (G4int ij=0; ij<overlapVTE->GetMasterClone()->GetNoClones(); ij++){
    
      G3VolTableEntry* cloneVTE = overlapVTE->GetMasterClone()->GetClone(ij);   
   
      // loop over clone positions
      for (G4int j=0; j<cloneVTE->NPCopies(); j++){
 
        #ifdef G3G4DEBUG
        G4cout << "From '" << curVTE->GetName() << "' "
           << "cut '" << cloneVTE->GetName() << "' :"
           << i  << "th overlap (from " << overlaps->size() << ") "
           << ij << "th clone (from " << overlapVTE->GetMasterClone()->GetNoClones() << ") "
           << j  << "th copy (from " << cloneVTE->NPCopies() << ")  "
           << G4endl;
        #endif
 
        SubstractSolids(curVTE, cloneVTE, j, transform); 
      }
    }    
  }               
}           

References G4cout, G4endl, G3VolTableEntry::GetClone(), G3VolTableEntry::GetMasterClone(), G3VolTableEntry::GetName(), G3VolTableEntry::GetNoClones(), G3VolTableEntry::NPCopies(), SubstractSolids(), and G4coutFormatters::anonymous_namespace{G4coutFormatters.cc}::transform().

Referenced by G3toG4MANY().

SubstractSolids()

void SubstractSolids	(	G3VolTableEntry *	vte1,
		G3VolTableEntry *	vte2,
		G4int	copy,
		const G4Transform3D &	transform
	)

Definition at line 106 of file G3toG4MANY.cc.

{                
  // vte2 transformation
  G4Transform3D transform2 = GetTransform3D(vte2->GetG3PosCopy(copy));
   
  // compose new name 
  G4String newName = vte1->GetSolid()->GetName();
  newName = newName + "-" + vte2->GetSolid()->GetName();   
 
  #ifdef G3G4DEBUG
  G4cout << "   " << newName << G4endl; 
  #endif
 
  G4VSolid* newSolid 
    = new G4SubtractionSolid(newName, vte1->GetSolid(), vte2->GetSolid(),
                             transform*transform2);
                 
  // update vte1
  vte1->SetSolid(newSolid);
 
  // process daughters
  for (G4int k=0; k<vte1->GetNoDaughters(); k++){
            
    G3VolTableEntry* dVTE = vte1->GetDaughter(k);               
     
    if (dVTE->NPCopies() != 1) {
      G4String text = "G3toG4MANY: volume ";
      text = text + dVTE->GetName() + " which has MANY has not just one position.";
      G4Exception("G3toG4MANY()", "G3toG40011",
                  FatalException, text);
      return;
    }
      
    G4Transform3D dt = GetTransform3D(dVTE->GetG3PosCopy(0)); 
    SubstractSolids(dVTE, vte2, copy, dt.inverse()*transform);
  } 
}           

References field_utils::copy(), FatalException, G4cout, G4endl, G4Exception(), G3VolTableEntry::GetDaughter(), G3VolTableEntry::GetG3PosCopy(), G3VolTableEntry::GetName(), G4VSolid::GetName(), G3VolTableEntry::GetNoDaughters(), G3VolTableEntry::GetSolid(), GetTransform3D(), HepGeom::Transform3D::inverse(), G3VolTableEntry::NPCopies(), G3VolTableEntry::SetSolid(), SubstractSolids(), and G4coutFormatters::anonymous_namespace{G4coutFormatters.cc}::transform().

Referenced by MakeBooleanSolids(), and SubstractSolids().