G3toG4BuildTree.hh File Reference

#include "G3VolTableEntry.hh"

Go to the source code of this file.

Functions
void	G3toG4BuildLVTree (G3VolTableEntry *curVTE, G3VolTableEntry *motherVTE)
void	G3toG4BuildPVTree (G3VolTableEntry *curVTE)
void	G3toG4BuildTree (G3VolTableEntry *curVTE, G3VolTableEntry *motherVTE)

Function Documentation

G3toG4BuildLVTree()

void G3toG4BuildLVTree	(	G3VolTableEntry *	curVTE,
		G3VolTableEntry *	motherVTE
	)

Definition at line 48 of file G3toG4BuildTree.cc.

{
  // check existence of the solid
  if (curVTE->GetSolid()) {
    G4LogicalVolume* curLog = curVTE->GetLV();
    if (!curLog) {
      // skip creating logical volume
      // in case it already exists
    
      // material
      G4Material* material = 0;
      G3MedTableEntry* mte = G3Med.get(curVTE->GetNmed());
      if (mte) material = mte->GetMaterial();
      if (!material) {
        G4String err_message = "VTE " + curVTE->GetName()
                             + " has not defined material!!";
        G4Exception("G3toG4BuildLVTree()", "G3toG40001",
                    FatalException, err_message);
        return;
      } 
 
      // logical volume
      curLog = 
        new G4LogicalVolume(curVTE->GetSolid(), material, curVTE->GetName());
      curVTE->SetLV(curLog);
      
      // insert logical volume to G3SensVol vector
      // in case it is sensitive
      if (mte->GetISVOL()) G3SensVol.push_back(curLog);
    }  
  }
  else {
    if ( !(curVTE->GetDivision() && motherVTE->GetMasterClone() == motherVTE &&
           motherVTE->GetNoClones()>1)) {
      // ignore dummy vte's 
      // (this should be the only case when the vte is dummy but
      // is present in mother <-> daughters tree
      G4String err_message = "VTE " + curVTE->GetName()
                           + " has not defined solid!!";
      G4Exception("G3toG4BuildLVTree()", "G3toG40002",
                  FatalException, err_message);
      return;
    }
  }  
  
  // process daughters
  G4int Ndau = curVTE->GetNoDaughters();
  for (int Idau=0; Idau<Ndau; Idau++){
    G3toG4BuildLVTree(curVTE->GetDaughter(Idau), curVTE);
  }
}

References FatalException, G3Med, G3SensVol, G3toG4BuildLVTree(), G4Exception(), G3MedTable::get(), G3VolTableEntry::GetDaughter(), G3VolTableEntry::GetDivision(), G3MedTableEntry::GetISVOL(), G3VolTableEntry::GetLV(), G3VolTableEntry::GetMasterClone(), G3MedTableEntry::GetMaterial(), G3VolTableEntry::GetName(), G3VolTableEntry::GetNmed(), G3VolTableEntry::GetNoClones(), G3VolTableEntry::GetNoDaughters(), G3VolTableEntry::GetSolid(), eplot::material, and G3VolTableEntry::SetLV().

Referenced by G3toG4BuildLVTree(), and G3toG4BuildTree().

G3toG4BuildPVTree()

void G3toG4BuildPVTree

(

G3VolTableEntry *

curVTE

)

Definition at line 100 of file G3toG4BuildTree.cc.

{
  // check existence of the solid
  if (curVTE->GetSolid()) {
    G4LogicalVolume* curLog = curVTE->GetLV();
  
    // positions in motherVTE
    for (G4int i=0; i<curVTE->NPCopies(); i++){
 
      G3Pos* theG3Pos = curVTE->GetG3PosCopy(i);
      if (theG3Pos) {
 
        // loop over all mothers 
        for (G4int im=0; im<curVTE->GetNoMothers(); im++) {
 
          G3VolTableEntry* motherVTE = curVTE->GetMother(im);
          if (theG3Pos->GetMotherName() == motherVTE->GetMasterClone()->GetName()) {
     
            // get mother logical volume
            G4LogicalVolume* mothLV=0;
            G4String motherName = motherVTE->GetName();    
            if (!curVTE->FindMother(motherName)) continue;
            if (curVTE->FindMother(motherName)->GetName() != motherName) {
              // check consistency - tbr
              G4String err_message =
                       "G3toG4BuildTree: Inconsistent mother <-> daughter !!";
              G4Exception("G3toG4BuildPVTree()", "G3toG40003",
                          FatalException, err_message);
              return;
            }
            mothLV = motherVTE->GetLV();
    
            // copy number
            // (in G3 numbering starts from 1 but in G4 from 0)
            G4int copyNo = theG3Pos->GetCopy() - 1;
      
            // position it if not top-level volume
 
        if (mothLV != 0) {
 
              // transformation
              G4int irot = theG3Pos->GetIrot();
              G4RotationMatrix* theMatrix = 0;
              if (irot>0) theMatrix = G3Rot.Get(irot);
              G4Rotate3D rotation;
              if (theMatrix) {            
            rotation = G4Rotate3D(*theMatrix);
          }
 
              #ifndef G3G4_NO_REFLECTION
              G4Translate3D translation(*(theG3Pos->GetPos()));
          G4Transform3D transform3D = translation * (rotation.inverse());
 
              G4ReflectionFactory::Instance()
            ->Place(transform3D,       // transformation
                    curVTE->GetName(), // PV name
            curLog,            // its logical volume 
            mothLV,            // mother logical volume
            false,             // only
            copyNo);           // copy
              #else
              new G4PVPlacement(theMatrix,            // rotation matrix
                              *(theG3Pos->GetPos()),  // its position
                              curLog,                 // its LogicalVolume 
                              curVTE->GetName(),      // PV name
                              mothLV,                 // Mother LV
                              0,                      // only
                              copyNo);                // copy
              #endif
 
              // verbose
          #ifdef G3G4DEBUG
            G4cout << "PV: " << i << "th copy of " << curVTE->GetName()
               << "  in " << motherVTE->GetName() << "  copyNo: " 
               << copyNo << "  irot: " << irot << "  pos: " 
               << *(theG3Pos->GetPos()) << G4endl;
          #endif
            }       
      }
        }
        // clear this position
        curVTE->ClearG3PosCopy(i);
        i--;
      }
    }
 
    // divisions     
    if (curVTE->GetDivision()) {
      curVTE->GetDivision()->CreatePVReplica();
      // verbose
      #ifdef G3G4DEBUG
    G4cout << "CreatePVReplica: " << curVTE->GetName() 
           << " in "  <<  curVTE->GetMother()->GetName() << G4endl;
      #endif
 
      // clear this divison
      curVTE->ClearDivision(); 
    }
  }
  
  // process daughters
  G4int Ndau = curVTE->GetNoDaughters();
  for (int Idau=0; Idau<Ndau; Idau++){
    G3toG4BuildPVTree(curVTE->GetDaughter(Idau));
  }
}

References G3VolTableEntry::ClearDivision(), G3VolTableEntry::ClearG3PosCopy(), G3Division::CreatePVReplica(), FatalException, G3VolTableEntry::FindMother(), G3Rot, G3toG4BuildPVTree(), G4cout, G4endl, G4Exception(), G3RotTable::Get(), G3Pos::GetCopy(), G3VolTableEntry::GetDaughter(), G3VolTableEntry::GetDivision(), G3VolTableEntry::GetG3PosCopy(), G3Pos::GetIrot(), G3VolTableEntry::GetLV(), G3VolTableEntry::GetMasterClone(), G3VolTableEntry::GetMother(), G3Pos::GetMotherName(), G3VolTableEntry::GetName(), G3VolTableEntry::GetNoDaughters(), G3VolTableEntry::GetNoMothers(), G3Pos::GetPos(), G3VolTableEntry::GetSolid(), G4ReflectionFactory::Instance(), HepGeom::Transform3D::inverse(), G3VolTableEntry::NPCopies(), and G4ReflectionFactory::Place().

Referenced by G3toG4BuildPVTree(), and G3toG4BuildTree().

G3toG4BuildTree()

void G3toG4BuildTree	(	G3VolTableEntry *	curVTE,
		G3VolTableEntry *	motherVTE
	)

Definition at line 42 of file G3toG4BuildTree.cc.

{
  G3toG4BuildLVTree(curVTE, motherVTE);
  G3toG4BuildPVTree(curVTE);
}  

References G3toG4BuildLVTree(), and G3toG4BuildPVTree().

Referenced by G4BuildGeom().