G3toG4BuildTree.cc File Reference

#include "globals.hh"
#include "G3toG4BuildTree.hh"
#include "G3RotTable.hh"
#include "G3MedTable.hh"
#include "G3VolTable.hh"
#include "G3SensVolVector.hh"
#include "G3Pos.hh"
#include "G4LogicalVolume.hh"
#include "G4PVPlacement.hh"
#include "G4ReflectionFactory.hh"
#include "G4Transform3D.hh"

Go to the source code of this file.

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

---

Function Documentation

void G3toG4BuildLVTree	(	G3VolTableEntry *	curVTE,
		G3VolTableEntry *	motherVTE
	)

Definition at line 49 of file G3toG4BuildTree.cc.

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(), and G3VolTableEntry::SetLV().

Referenced by G3toG4BuildLVTree(), and G3toG4BuildTree().

{
  // 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);
  }
}

void G3toG4BuildPVTree

(

G3VolTableEntry *

curVTE

)

Definition at line 101 of file G3toG4BuildTree.cc.

References G3VolTableEntry::ClearDivision(), G3VolTableEntry::ClearG3PosCopy(), G3Division::CreatePVReplica(), FatalException, G3VolTableEntry::FindMother(), G3Rot, G3toG4BuildPVTree(), G4cout, G4endl, G4Exception(), G3RotTable::Get(), G3VolTableEntry::GetDaughter(), G3VolTableEntry::GetDivision(), G3VolTableEntry::GetG3PosCopy(), G3VolTableEntry::GetLV(), G3VolTableEntry::GetMother(), G3VolTableEntry::GetName(), G3VolTableEntry::GetNoDaughters(), G3VolTableEntry::GetNoMothers(), G3VolTableEntry::GetSolid(), G4ReflectionFactory::Instance(), G3VolTableEntry::NPCopies(), and G4ReflectionFactory::Place().

Referenced by G3toG4BuildPVTree(), and G3toG4BuildTree().

{
  // 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));
  }
}

void G3toG4BuildTree	(	G3VolTableEntry *	curVTE,
		G3VolTableEntry *	motherVTE
	)

Definition at line 43 of file G3toG4BuildTree.cc.

References G3toG4BuildLVTree(), and G3toG4BuildPVTree().

Referenced by G4BuildGeom().

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

---