G4tgbGeometryDumper Class Reference

#include <G4tgbGeometryDumper.hh>

Public Member Functions
void	DumpBooleanVolume (const G4String &solidType, G4VSolid *so)
void	DumpElement (G4Element *ele)
void	DumpGeometry (const G4String &fname)
void	DumpIsotope (G4Isotope *ele)
G4String	DumpLogVol (G4LogicalVolume *lv, const G4String &extraName="", G4VSolid *solid=nullptr, G4Material *mate=nullptr)
G4String	DumpMaterial (G4Material *mat)
void	DumpMultiUnionVolume (G4VSolid *so)
void	DumpPhysVol (G4VPhysicalVolume *pv)
void	DumpPolySections (G4int zPlanes, G4double *z, G4double *rmin, G4double *rmax)
void	DumpPVParameterised (G4PVParameterised *pv)
void	DumpPVPlacement (G4VPhysicalVolume *pv, const G4String &lvName, G4int copyNo=-999)
void	DumpPVReplica (G4PVReplica *pv, const G4String &lvName)
G4String	DumpRotationMatrix (G4RotationMatrix *rotm)
void	DumpScaledVolume (G4VSolid *so)
G4String	DumpSolid (G4VSolid *solid, const G4String &extraName="")
void	DumpSolidParams (G4VSolid *so)
std::vector< G4double >	GetSolidParams (const G4VSolid *so)
G4VPhysicalVolume *	GetTopPhysVol ()
	~G4tgbGeometryDumper ()

Static Public Member Functions
static G4tgbGeometryDumper *	GetInstance ()

Private Member Functions
G4String	AddQuotes (const G4String &str)
G4double	approxTo0 (G4double val)
G4bool	CheckIfLogVolExists (const G4String &name, G4LogicalVolume *pt)
G4bool	CheckIfPhysVolExists (const G4String &name, G4VPhysicalVolume *)
const G4String &	FindSolidName (G4VSolid *solid)
	G4tgbGeometryDumper ()
G4String	GetIsotopeName (G4Isotope *)
template<class TYP >
G4String	GetObjectName (TYP *obj, std::map< G4String, TYP * > objectsDumped)
std::vector< G4VPhysicalVolume * >	GetPVChildren (G4LogicalVolume *lv)
G4String	GetTGSolidType (const G4String &solidtype)
G4String	LookForExistingRotation (const G4RotationMatrix *rotm)
G4double	MatDeterminant (G4RotationMatrix *ro)
G4bool	Same2G4Isotopes (G4Isotope *ele1, G4Isotope *ele2)
G4String	SubstituteRefl (G4String name)
G4String	SupressRefl (G4String name)

Private Attributes
std::map< G4String, G4Element * >	theElements
std::ofstream *	theFile = nullptr
std::map< G4String, G4Isotope * >	theIsotopes
std::map< G4String, G4LogicalVolume * >	theLogVols
std::map< G4String, G4Material * >	theMaterials
std::map< G4String, G4VPhysicalVolume * >	thePhysVols
G4int	theRotationNumber = 0
std::map< G4String, G4RotationMatrix * >	theRotMats
std::map< G4String, G4VSolid * >	theSolids

Static Private Attributes
static G4ThreadLocal G4tgbGeometryDumper *	theInstance = nullptr

Detailed Description

Definition at line 53 of file G4tgbGeometryDumper.hh.

Constructor & Destructor Documentation

~G4tgbGeometryDumper()

G4tgbGeometryDumper::~G4tgbGeometryDumper

(

)

Definition at line 131 of file G4tgbGeometryDumper.cc.

{
}

G4tgbGeometryDumper()

G4tgbGeometryDumper::G4tgbGeometryDumper ( )

private

Definition at line 80 of file G4tgbGeometryDumper.cc.

{
}

Referenced by GetInstance().

Member Function Documentation

AddQuotes()

G4String G4tgbGeometryDumper::AddQuotes ( const G4String &  str )

private

Definition at line 1226 of file G4tgbGeometryDumper.cc.

{
  //--- look if there is a separating blank
 
  G4bool bBlank = FALSE;
  std::size_t siz = str.length();
  for(std::size_t ii = 0; ii < siz; ++ii)
  {
    if(str.substr(ii, 1) == " ")
    {
      bBlank = TRUE;
      break;
    }
  }
  G4String str2 = str;
  if(bBlank)
  {
    str2 = G4String("\"") + str2 + G4String("\"");
  }
  return str2;
}

References FALSE, and TRUE.

Referenced by DumpBooleanVolume(), DumpElement(), DumpIsotope(), DumpLogVol(), DumpMaterial(), DumpMultiUnionVolume(), DumpPVPlacement(), DumpPVReplica(), DumpRotationMatrix(), DumpScaledVolume(), and DumpSolid().

approxTo0()

G4double G4tgbGeometryDumper::approxTo0 ( G4double  val )

private

Definition at line 1213 of file G4tgbGeometryDumper.cc.

{
  G4double precision =
    G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
 
  if(std::fabs(val) < precision)
  {
    val = 0.0;
  }
  return val;
}

References G4GeometryTolerance::GetInstance(), and G4GeometryTolerance::GetSurfaceTolerance().

Referenced by DumpBooleanVolume(), DumpMultiUnionVolume(), and DumpRotationMatrix().

CheckIfLogVolExists()

G4bool G4tgbGeometryDumper::CheckIfLogVolExists ( const G4String &  name, G4LogicalVolume *  pt  )

private

Definition at line 1372 of file G4tgbGeometryDumper.cc.

{
  if(theLogVols.find(name) != theLogVols.cend())
  {
    G4LogicalVolume* lvnew = (*(theLogVols.find(name))).second;
    if(lvnew != pt)
    {
      /*
      //---- Reflected volumes are repeated
 
      G4ReflectionFactory* reffact = G4ReflectionFactory::Instance();
      if( !reffact->IsReflected( pt ) && !reffact->IsReflected( lvnew ) )
      {
        G4String ErrMessage = "LogVol found but not same as before: " + name;
        G4Exception("G4tgbGeometryDumper::CheckIfLogVolExists()",
                    "InvalidSetup", FatalException, ErrMessage);
      }
      */
    }
    return true;
  }
  else
  {
    return false;
  }
}

References G4InuclParticleNames::name(), and theLogVols.

Referenced by DumpPhysVol().

CheckIfPhysVolExists()

G4bool G4tgbGeometryDumper::CheckIfPhysVolExists ( const G4String &  name, G4VPhysicalVolume *  pt  )

private

Definition at line 1401 of file G4tgbGeometryDumper.cc.

{
#ifdef G4VERBOSE
  if(G4tgrMessenger::GetVerboseLevel() >= 1)
  {
    G4cout << " G4tgbGeometryDumper::CheckIfPhysVolExists() - " << name
           << G4endl;
  }
#endif
  if(thePhysVols.find(name) != thePhysVols.cend())
  {
    if((*(thePhysVols.find(name))).second != pt)
    {
      // G4String ErrMessage = "Placement found but not same as before: "
      //                     + name;
      // G4Exception("G4tgbGeometryDumper::CheckIfPhysVolExists()",
      //             "InvalidSetup", FatalException, ErrMessage);
      G4cerr << " G4tgbGeometryDumper::CheckIfPhysVolExists () -"
             << " Placement found but not same as before : " << name << G4endl;
    }
    return true;
  }
  else
  {
    return false;
  }
}

References G4cerr, G4cout, G4endl, G4tgrMessenger::GetVerboseLevel(), G4InuclParticleNames::name(), and thePhysVols.

Referenced by DumpPVPlacement(), and DumpPVReplica().

DumpBooleanVolume()

void G4tgbGeometryDumper::DumpBooleanVolume	(	const G4String &	solidType,
		G4VSolid *	so
	)

Definition at line 687 of file G4tgbGeometryDumper.cc.

{
  G4BooleanSolid* bso = dynamic_cast<G4BooleanSolid*>(so);
  if(bso == nullptr)
  {
    return;
  }
  G4VSolid* solid0             = bso->GetConstituentSolid(0);
  G4VSolid* solid1             = bso->GetConstituentSolid(1);
  G4DisplacedSolid* solid1Disp = nullptr;
  G4bool displaced             = dynamic_cast<G4DisplacedSolid*>(solid1);
  if(displaced)
  {
    solid1Disp = dynamic_cast<G4DisplacedSolid*>(solid1);
    if(solid1Disp != nullptr)
    {
      solid1 = solid1Disp->GetConstituentMovedSolid();
    }
    else
    {
      return;
    }
  }
  DumpSolid(solid0);
  DumpSolid(solid1);
 
  G4String rotName;
  G4ThreeVector pos;
  if(displaced)
  {
    pos = solid1Disp->GetObjectTranslation();  // translation is of mother frame
    rotName = DumpRotationMatrix(new G4RotationMatrix(
      (solid1Disp->GetTransform().NetRotation()).inverse()));
  }
  else  // no displacement
  {
    rotName = DumpRotationMatrix(new G4RotationMatrix);
    pos     = G4ThreeVector();
  }
 
  G4String bsoName = GetObjectName(so, theSolids);
  if(theSolids.find(bsoName) != theSolids.cend())
    return;  // alredy dumped
  G4String solid0Name = FindSolidName(solid0);
  G4String solid1Name = FindSolidName(solid1);
 
  (*theFile) << ":SOLID " << AddQuotes(bsoName) << " " << AddQuotes(solidType)
             << " " << AddQuotes(solid0Name) << " " << AddQuotes(solid1Name)
             << " " << AddQuotes(rotName) << " " << approxTo0(pos.x()) << " "
             << approxTo0(pos.y()) << " " << approxTo0(pos.z()) << " "
             << G4endl;
 
  theSolids[bsoName] = bso;
}

References AddQuotes(), approxTo0(), DumpRotationMatrix(), DumpSolid(), FindSolidName(), G4endl, G4DisplacedSolid::GetConstituentMovedSolid(), G4BooleanSolid::GetConstituentSolid(), GetObjectName(), G4DisplacedSolid::GetObjectTranslation(), G4DisplacedSolid::GetTransform(), G4AffineTransform::NetRotation(), pos, and theSolids.

Referenced by DumpSolid().

DumpElement()

void G4tgbGeometryDumper::DumpElement

(

G4Element *

ele

)

Definition at line 560 of file G4tgbGeometryDumper.cc.

{
  G4String elemName = GetObjectName(ele, theElements);
 
  if(theElements.find(elemName) != theElements.cend())  // alredy dumped
  {
    return;
  }
 
  //--- Add symbol name: Material mixtures store the components as elements
  //    (even if the input are materials), but without symbol
  //
  G4String symbol = ele->GetSymbol();
  if(symbol == "" || symbol == " ")
  {
    symbol = elemName;
  }
 
  if(ele->GetNumberOfIsotopes() == 0)
  {
    (*theFile) << ":ELEM " << AddQuotes(elemName) << " " << AddQuotes(symbol)
               << " " << ele->GetZ() << " " << ele->GetA() / (g / mole) << " "
               << G4endl;
  }
  else
  {
    const G4IsotopeVector* isots = ele->GetIsotopeVector();
    for(std::size_t ii = 0; ii < ele->GetNumberOfIsotopes(); ++ii)
    {
      DumpIsotope((*isots)[ii]);
    }
 
    (*theFile) << ":ELEM_FROM_ISOT " << AddQuotes(elemName) << " "
               << AddQuotes(symbol) << " " << ele->GetNumberOfIsotopes()
               << G4endl;
    const G4double* fractions = ele->GetRelativeAbundanceVector();
    for(std::size_t ii = 0; ii < ele->GetNumberOfIsotopes(); ++ii)
    {
      (*theFile) << "   " << AddQuotes(GetObjectName((*isots)[ii], theIsotopes))
                 << " " << fractions[ii] << G4endl;
    }
  }
  theElements[elemName] = ele;
}

References AddQuotes(), DumpIsotope(), ele, g, G4endl, GetObjectName(), mole, theElements, and theIsotopes.

Referenced by DumpMaterial().

DumpGeometry()

void G4tgbGeometryDumper::DumpGeometry

(

const G4String &

fname

)

Definition at line 95 of file G4tgbGeometryDumper.cc.

{
  theFile = new std::ofstream(fname);
 
  G4VPhysicalVolume* pv = GetTopPhysVol();
  DumpPhysVol(pv);  // dump volume and recursively it will dump all hierarchy
}

References DumpPhysVol(), test::fname, GetTopPhysVol(), and theFile.

DumpIsotope()

void G4tgbGeometryDumper::DumpIsotope

(

G4Isotope *

ele

)

Definition at line 606 of file G4tgbGeometryDumper.cc.

{
  G4String isotName = GetObjectName(isot, theIsotopes);
  if(theIsotopes.find(isotName) != theIsotopes.cend())  // alredy dumped
  {
    return;
  }
 
  (*theFile) << ":ISOT " << AddQuotes(isotName) << " " << isot->GetZ() << " "
             << isot->GetN() << " " << isot->GetA() / (g / mole) << " "
             << G4endl;
 
  theIsotopes[isotName] = isot;
}

References AddQuotes(), g, G4endl, G4Isotope::GetA(), G4Isotope::GetN(), GetObjectName(), G4Isotope::GetZ(), mole, and theIsotopes.

Referenced by DumpElement().

DumpLogVol()

G4String G4tgbGeometryDumper::DumpLogVol	(	G4LogicalVolume *	lv,
		const G4String &	extraName = "",
		G4VSolid *	solid = nullptr,
		G4Material *	mate = nullptr
	)

Definition at line 439 of file G4tgbGeometryDumper.cc.

{
  G4String lvName;
 
  if(extraName == "")  //--- take out the '_refl' in the name
  {
    lvName = GetObjectName(lv, theLogVols);
  }
  else
  {
    lvName = lv->GetName() + extraName;
  }
 
  if(theLogVols.find(lvName) != theLogVols.cend())  // alredy dumped
  {
    return lvName;
  }
 
  if(solid == nullptr)
  {
    solid = lv->GetSolid();
  }
 
  //---- Dump solid
  G4String solidName = DumpSolid(solid, extraName);
 
  //---- Dump material
  if(mate == nullptr)
  {
    mate = lv->GetMaterial();
  }
  G4String mateName = DumpMaterial(mate);
 
  //---- Dump logical volume (solid + material)
  (*theFile) << ":VOLU " << SubstituteRefl(AddQuotes(lvName)) << " "
             << SupressRefl(AddQuotes(solidName)) << " " << AddQuotes(mateName)
             << G4endl;
 
  theLogVols[lvName] = lv;
 
  return lvName;
}

References AddQuotes(), DumpMaterial(), DumpSolid(), G4endl, G4LogicalVolume::GetMaterial(), G4LogicalVolume::GetName(), GetObjectName(), G4LogicalVolume::GetSolid(), SubstituteRefl(), SupressRefl(), and theLogVols.

Referenced by DumpPhysVol(), and DumpPVParameterised().

DumpMaterial()

G4String G4tgbGeometryDumper::DumpMaterial

(

G4Material *

mat

)

Definition at line 486 of file G4tgbGeometryDumper.cc.

{
  G4String mateName = GetObjectName(mat, theMaterials);
  if(theMaterials.find(mateName) != theMaterials.cend())  // alredy dumped
  {
    return mateName;
  }
 
  std::size_t numElements = mat->GetNumberOfElements();
  G4double density   = mat->GetDensity() / g * cm3;
 
  // start tag
  //
  if(numElements == 1)
  {
    (*theFile) << ":MATE " << AddQuotes(mateName) << " " << mat->GetZ() << " "
               << mat->GetA() / (g / mole) << " " << density << G4endl;
  }
  else
  {
    const G4ElementVector* elems = mat->GetElementVector();
    const G4double* fractions    = mat->GetFractionVector();
    for(std::size_t ii = 0; ii < numElements; ++ii)
    {
      DumpElement(const_cast<G4Element*>((*elems)[ii]));
    }
 
    (*theFile) << ":MIXT " << AddQuotes(mateName) << " " << density << " "
               << numElements << G4endl;
    // close start element tag and get ready to do composit "parts"
    for(std::size_t ii = 0; ii < numElements; ++ii)
    {
      (*theFile) << "   " << AddQuotes(GetObjectName(const_cast<G4Element*>((*elems)[ii]), theElements))
                 << " " << fractions[ii] << G4endl;
    }
  }
 
  (*theFile) << ":MATE_MEE " << AddQuotes(mateName) << " "
             << mat->GetIonisation()->GetMeanExcitationEnergy() / eV << "*eV"
             << G4endl;
 
  (*theFile) << ":MATE_TEMPERATURE " << AddQuotes(mateName) << " "
             << mat->GetTemperature() / kelvin << "*kelvin" << G4endl;
 
  (*theFile) << ":MATE_PRESSURE " << AddQuotes(mateName) << " "
             << mat->GetPressure() / atmosphere << "*atmosphere" << G4endl;
 
  G4State state = mat->GetState();
  G4String stateStr;
  switch(state)
  {
    case kStateUndefined:
      stateStr = "Undefined";
      break;
    case kStateSolid:
      stateStr = "Solid";
      break;
    case kStateLiquid:
      stateStr = "Liquid";
      break;
    case kStateGas:
      stateStr = "Gas";
      break;
  }
 
  (*theFile) << ":MATE_STATE " << AddQuotes(mateName) << " " << stateStr
             << G4endl;
 
  theMaterials[mateName] = mat;
 
  return mateName;
}

References AddQuotes(), atmosphere, cm3, DumpElement(), eV, g, G4endl, G4Material::GetA(), G4Material::GetDensity(), G4Material::GetElementVector(), G4Material::GetFractionVector(), G4Material::GetIonisation(), G4IonisParamMat::GetMeanExcitationEnergy(), G4Material::GetNumberOfElements(), GetObjectName(), G4Material::GetPressure(), G4Material::GetState(), G4Material::GetTemperature(), G4Material::GetZ(), kelvin, kStateGas, kStateLiquid, kStateSolid, kStateUndefined, mole, theElements, and theMaterials.

Referenced by DumpLogVol().

DumpMultiUnionVolume()

void G4tgbGeometryDumper::DumpMultiUnionVolume

(

G4VSolid *

so

)

Definition at line 744 of file G4tgbGeometryDumper.cc.

{
  const G4MultiUnion* muun = dynamic_cast<const G4MultiUnion*>(so);
  if(muun != nullptr)
    {
      G4int nSolids = muun->GetNumberOfSolids();
      std::vector<G4String> rotList;
      for( G4int iso = 0; iso < nSolids; iso++ ) {
    G4Transform3D trans = muun->GetTransformation(iso);
    G4String rotName = DumpRotationMatrix( new G4RotationMatrix(trans.getRotation()));
    rotList.push_back(rotName);
    G4VSolid* solN = muun->GetSolid(iso);
    DumpSolid(solN);
      }
      G4String bsoName = GetObjectName(const_cast<G4VSolid*>(so), theSolids);
      (*theFile) << ":SOLID " << AddQuotes(bsoName) << " MULTIUNION "
         << nSolids;
      
      for( G4int iso = 0; iso < nSolids; iso++ ) {
    G4VSolid* solN = muun->GetSolid(iso);
    G4Transform3D trans = muun->GetTransformation(iso);
    G4ThreeVector pos = trans.getTranslation();  // translation is of mother frame
    (*theFile) << " " <<  solN->GetName()
           << " " << " " << rotList[iso]
           << " " << approxTo0(pos.x())
           << " " << approxTo0(pos.y())
           << " " << approxTo0(pos.z());
      }
      (*theFile) << G4endl;
      
    }
}

References AddQuotes(), approxTo0(), DumpRotationMatrix(), DumpSolid(), G4endl, G4VSolid::GetName(), G4MultiUnion::GetNumberOfSolids(), GetObjectName(), HepGeom::Transform3D::getRotation(), G4MultiUnion::GetSolid(), G4MultiUnion::GetTransformation(), HepGeom::Transform3D::getTranslation(), pos, and theSolids.

Referenced by DumpSolid().

DumpPhysVol()

void G4tgbGeometryDumper::DumpPhysVol

(

G4VPhysicalVolume *

pv

)

Definition at line 136 of file G4tgbGeometryDumper.cc.

{
  //--- Dump logical volume first
  G4LogicalVolume* lv = pv->GetLogicalVolume();
 
  G4ReflectionFactory* reffact = G4ReflectionFactory::Instance();
 
  //--- It is not needed to dump _refl volumes created when parent is reflected
  // !!WARNING : it must be avoided to reflect a volume hierarchy if children
  //             has also been reflected, as both will have same name
 
  if(reffact->IsReflected(lv) && reffact->IsReflected(pv->GetMotherLogical()))
  {
    return;
  }
 
  G4bool bVolExists = CheckIfLogVolExists(lv->GetName(), lv);
 
  //---- Construct this PV
  if(pv->GetMotherLogical() != nullptr)  // not WORLD volume
  {
    if(!pv->IsReplicated())
    {
      G4String lvName = lv->GetName();
      if(!bVolExists)
      {
        lvName = DumpLogVol(lv);
      }
      DumpPVPlacement(pv, lvName);
    }
    else if(pv->IsParameterised())
    {
      G4PVParameterised* pvparam = (G4PVParameterised*) (pv);
      DumpPVParameterised(pvparam);
    }
    else
    {
      G4String lvName = lv->GetName();
      if(!bVolExists)
      {
        lvName = DumpLogVol(lv);
      }
      G4PVReplica* pvrepl = (G4PVReplica*) (pv);
      DumpPVReplica(pvrepl, lvName);
    }
  }
  else
  {
    DumpLogVol(lv);
  }
 
  if(!bVolExists)
  {
    //---- Construct PV's who has this LV as mother
    std::vector<G4VPhysicalVolume*> pvChildren = GetPVChildren(lv);
    for(auto ite = pvChildren.cbegin(); ite != pvChildren.cend(); ++ite)
    {
      DumpPhysVol(*ite);
    }
  }
}

References CheckIfLogVolExists(), DumpLogVol(), DumpPhysVol(), DumpPVParameterised(), DumpPVPlacement(), DumpPVReplica(), G4VPhysicalVolume::GetLogicalVolume(), G4VPhysicalVolume::GetMotherLogical(), G4LogicalVolume::GetName(), GetPVChildren(), G4ReflectionFactory::Instance(), G4VPhysicalVolume::IsParameterised(), G4ReflectionFactory::IsReflected(), and G4VPhysicalVolume::IsReplicated().

Referenced by DumpGeometry(), and DumpPhysVol().

DumpPolySections()

void G4tgbGeometryDumper::DumpPolySections	(	G4int	zPlanes,
		G4double *	z,
		G4double *	rmin,
		G4double *	rmax
	)

DumpPVParameterised()

void G4tgbGeometryDumper::DumpPVParameterised

(

G4PVParameterised *

pv

)

Definition at line 257 of file G4tgbGeometryDumper.cc.

{
  G4String pvName = pv->GetName();
 
  EAxis axis;
  G4int nReplicas;
  G4double width;
  G4double offset;
  G4bool consuming;
  pv->GetReplicationData(axis, nReplicas, width, offset, consuming);
 
  G4VPVParameterisation* param = pv->GetParameterisation();
 
  G4LogicalVolume* lv             = pv->GetLogicalVolume();
  G4VSolid* solid1st              = param->ComputeSolid(0, pv);
  G4Material* mate1st             = param->ComputeMaterial(0, pv);
  std::vector<G4double> params1st = GetSolidParams(solid1st);
  std::vector<G4double> newParams;
  G4VSolid* newSolid = solid1st;
  G4String lvName;
 
  for(G4int ii = 0; ii < nReplicas; ++ii)
  {
    G4Material* newMate = param->ComputeMaterial(ii, pv);
    if(solid1st->GetEntityType() == "G4Box")
    {
      G4Box* box = (G4Box*) (solid1st);
      param->ComputeDimensions(*box, ii, pv);
      newParams = GetSolidParams(box);
      newSolid  = (G4VSolid*) box;
    }
    else if(solid1st->GetEntityType() == "G4Tubs")
    {
      G4Tubs* tubs = (G4Tubs*) (solid1st);
      param->ComputeDimensions(*tubs, ii, pv);
      newParams = GetSolidParams(tubs);
      newSolid  = (G4VSolid*) tubs;
    }
    else if(solid1st->GetEntityType() == "G4Trd")
    {
      G4Trd* trd = (G4Trd*) (solid1st);
      param->ComputeDimensions(*trd, ii, pv);
      newParams = GetSolidParams(trd);
      newSolid  = (G4VSolid*) trd;
    }
    else if(solid1st->GetEntityType() == "G4Trap")
    {
      G4Trap* trap = (G4Trap*) (solid1st);
      param->ComputeDimensions(*trap, ii, pv);
      newParams = GetSolidParams(trap);
      newSolid  = (G4VSolid*) trap;
    }
    else if(solid1st->GetEntityType() == "G4Cons")
    {
      G4Cons* cons = (G4Cons*) (solid1st);
      param->ComputeDimensions(*cons, ii, pv);
      newParams = GetSolidParams(cons);
      newSolid  = (G4VSolid*) cons;
    }
    else if(solid1st->GetEntityType() == "G4Sphere")
    {
      G4Sphere* sphere = (G4Sphere*) (solid1st);
      param->ComputeDimensions(*sphere, ii, pv);
      newParams = GetSolidParams(sphere);
      newSolid  = (G4VSolid*) sphere;
    }
    else if(solid1st->GetEntityType() == "G4Orb")
    {
      G4Orb* orb = (G4Orb*) (solid1st);
      param->ComputeDimensions(*orb, ii, pv);
      newParams = GetSolidParams(orb);
      newSolid  = (G4VSolid*) orb;
    }
    else if(solid1st->GetEntityType() == "G4Torus")
    {
      G4Torus* torus = (G4Torus*) (solid1st);
      param->ComputeDimensions(*torus, ii, pv);
      newParams = GetSolidParams(torus);
      newSolid  = (G4VSolid*) torus;
    }
    else if(solid1st->GetEntityType() == "G4Para")
    {
      G4Para* para = (G4Para*) (solid1st);
      param->ComputeDimensions(*para, ii, pv);
      newParams = GetSolidParams(para);
      newSolid  = (G4VSolid*) para;
    }
    else if(solid1st->GetEntityType() == "G4Polycone")
    {
      G4Polycone* polycone = (G4Polycone*) (solid1st);
      param->ComputeDimensions(*polycone, ii, pv);
      newParams = GetSolidParams(polycone);
      newSolid  = (G4VSolid*) polycone;
    }
    else if(solid1st->GetEntityType() == "G4Polyhedra")
    {
      G4Polyhedra* polyhedra = (G4Polyhedra*) (solid1st);
      param->ComputeDimensions(*polyhedra, ii, pv);
      newParams = GetSolidParams(polyhedra);
      newSolid  = (G4VSolid*) polyhedra;
    }
    else if(solid1st->GetEntityType() == "G4Hype")
    {
      G4Hype* hype = (G4Hype*) (solid1st);
      param->ComputeDimensions(*hype, ii, pv);
      newParams = GetSolidParams(hype);
      newSolid  = (G4VSolid*) hype;
    }
    if(ii == 0 || mate1st != newMate || params1st[0] != newParams[0])
    {
      G4String extraName = "";
      if(ii != 0)
      {
        extraName = "#" + G4UIcommand::ConvertToString(ii) + "/" +
                    pv->GetMotherLogical()->GetName();
      }
      lvName = DumpLogVol(lv, extraName, newSolid, newMate);
    }
 
    param->ComputeTransformation(ii, pv);
    DumpPVPlacement(pv, lvName, ii);
  }
}

References G4VPVParameterisation::ComputeDimensions(), G4VPVParameterisation::ComputeMaterial(), G4VPVParameterisation::ComputeSolid(), G4VPVParameterisation::ComputeTransformation(), G4UIcommand::ConvertToString(), DumpLogVol(), DumpPVPlacement(), G4VSolid::GetEntityType(), G4VPhysicalVolume::GetLogicalVolume(), G4VPhysicalVolume::GetMotherLogical(), G4LogicalVolume::GetName(), G4VPhysicalVolume::GetName(), G4PVParameterised::GetParameterisation(), G4PVParameterised::GetReplicationData(), and GetSolidParams().

Referenced by DumpPhysVol().

DumpPVPlacement()

void G4tgbGeometryDumper::DumpPVPlacement	(	G4VPhysicalVolume *	pv,
		const G4String &	lvName,
		G4int	copyNo = -999
	)

Definition at line 199 of file G4tgbGeometryDumper.cc.

{
  G4String pvName = pv->GetName();
 
  G4RotationMatrix* rotMat = pv->GetRotation();
  if(rotMat == nullptr)
    rotMat = new G4RotationMatrix();
 
  //---- Check if it is reflected
  G4ReflectionFactory* reffact = G4ReflectionFactory::Instance();
  G4LogicalVolume* lv          = pv->GetLogicalVolume();
  if(reffact->IsReflected(lv))
  {
#ifdef G4VERBOSE
    if(G4tgrMessenger::GetVerboseLevel() >= 1)
    {
      G4cout << " G4tgbGeometryDumper::DumpPVPlacement() - Reflected volume: "
             << pv->GetName() << G4endl;
    }
#endif
    G4ThreeVector colx = rotMat->colX();
    G4ThreeVector coly = rotMat->colY();
    G4ThreeVector colz = rotMat->colZ();
    // apply a Z reflection (reflection matrix is decomposed in new
    // reflection-free rotation + z-reflection)
    colz *= -1.;
    G4Rep3x3 rottemp(colx.x(), coly.x(), colz.x(), colx.y(), coly.y(), colz.y(),
                     colx.z(), coly.z(), colz.z());
    // matrix representation (inverted)
    *rotMat = G4RotationMatrix(rottemp);
    *rotMat = (*rotMat).inverse();
    pvName += "_refl";
  }
  G4String rotName  = DumpRotationMatrix(rotMat);
  G4ThreeVector pos = pv->GetTranslation();
 
  if(copyNo == -999)  // for parameterisations copy number is provided
  {
    copyNo = pv->GetCopyNo();
  }
 
  G4String fullname = pvName + "#" + G4UIcommand::ConvertToString(copyNo) +
                      "/" + pv->GetMotherLogical()->GetName();
 
  if(!CheckIfPhysVolExists(fullname, pv))
  {
    (*theFile) << ":PLACE " << SubstituteRefl(AddQuotes(lvName)) << " "
               << copyNo << " "
               << SubstituteRefl(AddQuotes(pv->GetMotherLogical()->GetName()))
               << " " << AddQuotes(rotName) << " " << pos.x() << " " << pos.y()
               << " " << pos.z() << G4endl;
 
    thePhysVols[fullname] = pv;
  }
}

References AddQuotes(), CheckIfPhysVolExists(), CLHEP::HepRotation::colX(), CLHEP::HepRotation::colY(), CLHEP::HepRotation::colZ(), G4UIcommand::ConvertToString(), DumpRotationMatrix(), G4cout, G4endl, G4VPhysicalVolume::GetCopyNo(), G4VPhysicalVolume::GetLogicalVolume(), G4VPhysicalVolume::GetMotherLogical(), G4LogicalVolume::GetName(), G4VPhysicalVolume::GetName(), G4VPhysicalVolume::GetRotation(), G4VPhysicalVolume::GetTranslation(), G4tgrMessenger::GetVerboseLevel(), G4ReflectionFactory::Instance(), CLHEP::HepRotation::inverse(), G4ReflectionFactory::IsReflected(), pos, SubstituteRefl(), thePhysVols, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by DumpPhysVol(), and DumpPVParameterised().

DumpPVReplica()

void G4tgbGeometryDumper::DumpPVReplica	(	G4PVReplica *	pv,
		const G4String &	lvName
	)

Definition at line 382 of file G4tgbGeometryDumper.cc.

{
  EAxis axis;
  G4int nReplicas;
  G4double width;
  G4double offset;
  G4bool consuming;
  pv->GetReplicationData(axis, nReplicas, width, offset, consuming);
  G4String axisName;
  switch(axis)
  {
    case kXAxis:
      axisName = "X";
      break;
    case kYAxis:
      axisName = "Y";
      break;
    case kZAxis:
      axisName = "Z";
      break;
    case kRho:
      axisName = "R";
      break;
    case kPhi:
      axisName = "PHI";
      break;
    case kRadial3D:
    case kUndefined:
      G4String ErrMessage =
        "Unknown axis of replication for volume" + pv->GetName();
      G4Exception("G4tgbGeometryDumper::DumpPVReplica", "Wrong axis ",
                  FatalException, ErrMessage);
      break;
  }
 
  G4String fullname = lvName + "/" + pv->GetMotherLogical()->GetName();
 
  if(!CheckIfPhysVolExists(fullname, pv))
  {
    (*theFile) << ":REPL " << SubstituteRefl(AddQuotes(lvName)) << " "
               << SubstituteRefl(AddQuotes(pv->GetMotherLogical()->GetName()))
               << " " << axisName << " " << nReplicas;
    if(axis != kPhi)
    {
      (*theFile) << " " << width << " " << offset << G4endl;
    }
    else
    {
      (*theFile) << " " << width / deg << "*deg"
                 << " " << offset / deg << "*deg" << G4endl;
    }
 
    thePhysVols[fullname] = pv;
  }
}

References AddQuotes(), CheckIfPhysVolExists(), deg, FatalException, G4endl, G4Exception(), G4VPhysicalVolume::GetMotherLogical(), G4LogicalVolume::GetName(), G4VPhysicalVolume::GetName(), G4PVReplica::GetReplicationData(), kPhi, kRadial3D, kRho, kUndefined, kXAxis, kYAxis, kZAxis, SubstituteRefl(), and thePhysVols.

Referenced by DumpPhysVol().

DumpRotationMatrix()

G4String G4tgbGeometryDumper::DumpRotationMatrix

(

G4RotationMatrix *

rotm

)

Definition at line 1121 of file G4tgbGeometryDumper.cc.

{
  if(rotm == nullptr)
  {
    rotm = new G4RotationMatrix();
  }
 
  G4double de      = MatDeterminant(rotm);
  G4String rotName = LookForExistingRotation(rotm);
  if(rotName != "")
  {
    return rotName;
  }
 
  G4ThreeVector v(1., 1., 1.);
  if(de < -0.9)  // a reflection ....
  {
    (*theFile) << ":ROTM ";
    rotName = "RRM";
    rotName += G4UIcommand::ConvertToString(theRotationNumber++);
 
    (*theFile) << AddQuotes(rotName) << std::setprecision(9) << " "
               << approxTo0(rotm->xx()) << " " << approxTo0(rotm->yx()) << " "
               << approxTo0(rotm->zx()) << " " << approxTo0(rotm->xy()) << " "
               << approxTo0(rotm->yy()) << " " << approxTo0(rotm->zy()) << " "
               << approxTo0(rotm->xz()) << " " << approxTo0(rotm->yz()) << " "
               << approxTo0(rotm->zz()) << G4endl;
  }
  else if(de > 0.9)  // a rotation ....
  {
    (*theFile) << ":ROTM ";
    rotName = "RM";
    rotName += G4UIcommand::ConvertToString(theRotationNumber++);
 
    (*theFile) << AddQuotes(rotName) << " " << approxTo0(rotm->thetaX() / deg)
               << " " << approxTo0(rotm->phiX() / deg) << " "
               << approxTo0(rotm->thetaY() / deg) << " "
               << approxTo0(rotm->phiY() / deg) << " "
               << approxTo0(rotm->thetaZ() / deg) << " "
               << approxTo0(rotm->phiZ() / deg) << G4endl;
  }
 
  theRotMats[rotName] = rotm;
 
  return rotName;
}

References AddQuotes(), approxTo0(), G4UIcommand::ConvertToString(), deg, G4endl, LookForExistingRotation(), MatDeterminant(), CLHEP::HepRotation::phiX(), CLHEP::HepRotation::phiY(), CLHEP::HepRotation::phiZ(), theRotationNumber, theRotMats, CLHEP::HepRotation::thetaX(), CLHEP::HepRotation::thetaY(), CLHEP::HepRotation::thetaZ(), CLHEP::HepRotation::xx(), CLHEP::HepRotation::xy(), CLHEP::HepRotation::xz(), CLHEP::HepRotation::yx(), CLHEP::HepRotation::yy(), CLHEP::HepRotation::yz(), CLHEP::HepRotation::zx(), CLHEP::HepRotation::zy(), and CLHEP::HepRotation::zz().

Referenced by DumpBooleanVolume(), DumpMultiUnionVolume(), and DumpPVPlacement().

DumpScaledVolume()

void G4tgbGeometryDumper::DumpScaledVolume

(

G4VSolid *

so

)

Definition at line 778 of file G4tgbGeometryDumper.cc.

{
  const G4ScaledSolid* ssol = dynamic_cast<const G4ScaledSolid*>(so);
  if(ssol != nullptr)
    {
      G4VSolid* unscaledSolid = ssol->GetUnscaledSolid();
      G4Scale3D scaleTransf = ssol->GetScaleTransform();
      G4String bsoName = GetObjectName(const_cast<G4VSolid*>(so), theSolids);
      (*theFile) << ":SOLID " << AddQuotes(bsoName) << " SCALED "
         << unscaledSolid->GetName() << " "
         << scaleTransf.xx() << " "
         << scaleTransf.yy() << " "
         << scaleTransf.zz() << G4endl;
    }
}

References AddQuotes(), G4endl, G4VSolid::GetName(), GetObjectName(), G4ScaledSolid::GetScaleTransform(), G4ScaledSolid::GetUnscaledSolid(), theSolids, HepGeom::Transform3D::xx(), HepGeom::Transform3D::yy(), and HepGeom::Transform3D::zz().

Referenced by DumpSolid().

DumpSolid()

G4String G4tgbGeometryDumper::DumpSolid	(	G4VSolid *	solid,
		const G4String &	extraName = ""
	)

Definition at line 622 of file G4tgbGeometryDumper.cc.

{
  G4String solidName;
  if(extraName == "")
  {
    solidName = GetObjectName(solid, theSolids);
  }
  else
  {
    solidName = solid->GetName() + extraName;
  }
 
  if(theSolids.find(solidName) != theSolids.cend())  // alredy dumped
  {
    return solidName;
  }
 
  G4String solidType = solid->GetEntityType();
  solidType          = GetTGSolidType(solidType);
  
  if(solidType == "UNIONSOLID")
  {
    DumpBooleanVolume("UNION", solid);
  }
  else if(solidType == "SUBTRACTIONSOLID")
  {
    DumpBooleanVolume("SUBTRACTION", solid);
  }
  else if(solidType == "INTERSECTIONSOLID")
  {
    DumpBooleanVolume("INTERSECTION", solid);
  }
  else if(solidType == "REFLECTEDSOLID")
  {
    G4ReflectedSolid* solidrefl = dynamic_cast<G4ReflectedSolid*>(solid);
    if(solidrefl == nullptr)
    {
      G4Exception("G4tgbGeometryDumper::DumpSolid()", "InvalidType",
                  FatalException, "Invalid reflected solid!");
      return solidName;
    }
    G4VSolid* solidori = solidrefl->GetConstituentMovedSolid();
    DumpSolid(solidori);
  }
  else if(solidType == "MULTIUNION")
  {
    DumpMultiUnionVolume(solid);
  }
  else if(solidType == "SCALEDSOLID")
  {
    DumpScaledVolume(solid);
  }
  else
  {
    (*theFile) << ":SOLID " << AddQuotes(solidName) << " ";
    (*theFile) << AddQuotes(solidType) << " ";
    DumpSolidParams( solid );
    theSolids[solidName] = solid;
  }
 
  return solidName;
}

References AddQuotes(), DumpBooleanVolume(), DumpMultiUnionVolume(), DumpScaledVolume(), DumpSolid(), DumpSolidParams(), FatalException, G4Exception(), G4ReflectedSolid::GetConstituentMovedSolid(), G4VSolid::GetEntityType(), G4VSolid::GetName(), GetObjectName(), GetTGSolidType(), and theSolids.

Referenced by DumpBooleanVolume(), DumpLogVol(), DumpMultiUnionVolume(), and DumpSolid().

DumpSolidParams()

void G4tgbGeometryDumper::DumpSolidParams

(

G4VSolid *

so

)

Definition at line 795 of file G4tgbGeometryDumper.cc.

{
  std::vector<G4double> params = GetSolidParams(so);
  for(std::size_t ii = 0; ii < params.size(); ++ii)
  {
    (*theFile) << params[ii] << " ";
  }
  (*theFile) << G4endl;
}

References G4endl, and GetSolidParams().

Referenced by DumpSolid().

FindSolidName()

const G4String & G4tgbGeometryDumper::FindSolidName ( G4VSolid *  solid )

private

Definition at line 1462 of file G4tgbGeometryDumper.cc.

{
  std::map<G4String, G4VSolid*>::const_iterator ite;
  for(ite = theSolids.cbegin(); ite != theSolids.cend(); ++ite)
  {
    if(solid == (*ite).second)
    {
      return (*ite).first;
    }
  }
 
  if(ite == theSolids.cend())
  {
    G4Exception("G4tgbGeometryDumper::FindSolidName()", "ReadError",
                FatalException, "Programming error.");
  }
  return (*ite).first;
}

References FatalException, G4Exception(), and theSolids.

Referenced by DumpBooleanVolume().

GetInstance()

G4tgbGeometryDumper * G4tgbGeometryDumper::GetInstance ( )

static

Definition at line 85 of file G4tgbGeometryDumper.cc.

{
  if(theInstance == nullptr)
  {
    theInstance = new G4tgbGeometryDumper;
  }
  return theInstance;
}

References G4tgbGeometryDumper(), and theInstance.

GetIsotopeName()

G4String G4tgbGeometryDumper::GetIsotopeName ( G4Isotope *  isot )

private

Definition at line 1271 of file G4tgbGeometryDumper.cc.

{
  G4String isotName = isot->GetName();
  // first look if this is isotope is already dumped,
  // with original isotope name or new one
  //
  std::map<G4String, G4Isotope*>::const_iterator ite;
  for(ite = theIsotopes.cbegin(); ite != theIsotopes.cend(); ++ite)
  {
    if(isot == (*ite).second)
    {
      return (*ite).first;
    }
  }
 
  // Now look if there is another isotope dumped with same name,
  // and if found add _N to the name
  //
  ite = theIsotopes.find(isotName);
  if(ite != theIsotopes.cend())  // Isotope found with same name
  {
    G4Isotope* isotold = (*ite).second;
    if(isot != isotold)  // new isotope it is not the really
    {                    // the same one as isotope found
      if(!Same2G4Isotopes(isot, isotold))
      {                // if the two have same data, use the old one
        G4int ii = 2;  // G4Nist does names isotopes of same element
                       // with same name
        for(;; ++ii)
        {
          G4String newIsotName =
            isotName + "_" + G4UIcommand::ConvertToString(ii);
          std::map<G4String, G4Isotope*>::const_iterator ite2 =
            theIsotopes.find(newIsotName);
          if(ite2 == theIsotopes.cend())
          {
            isotName = newIsotName;
            break;
          }
          else
          {
            if(Same2G4Isotopes(isot, (*ite2).second))
            {
              isotName = newIsotName;
              break;
            }
          }
        }
      }
    }
  }
  return isotName;
}

References G4UIcommand::ConvertToString(), G4Isotope::GetName(), Same2G4Isotopes(), and theIsotopes.

GetObjectName()

template<class TYP >

G4String G4tgbGeometryDumper::GetObjectName ( TYP *  obj, std::map< G4String, TYP * >  objectsDumped  )

private

Definition at line 1327 of file G4tgbGeometryDumper.cc.

{
  G4String objName = obj->GetName();
 
  // first look if this is objecy is already dumped,
  // with original object name or new one
  //
  typename std::map<G4String, TYP*>::const_iterator ite;
  for(ite = objectsDumped.cbegin(); ite != objectsDumped.cend(); ++ite)
  {
    if(obj == (*ite).second)
    {
      return (*ite).first;
    }
  }
 
  // Now look if there is another object dumped with same name,
  // and if found add _N to the name
  //
  ite = objectsDumped.find(objName);
 
  if(ite != objectsDumped.cend())  // Object found with same name
  {
    TYP* objold = (*ite).second;
    if(obj != objold)  // new object it is not the really
    {                  // the same one as object found
      G4int ii = 2;
      for(;; ++ii)
      {
        G4String newObjName = objName + "_" + G4UIcommand::ConvertToString(ii);
        typename std::map<G4String, TYP*>::const_iterator ite2 =
          objectsDumped.find(newObjName);
        if(ite2 == objectsDumped.cend())
        {
          objName = newObjName;
          break;
        }
      }
    }
  }
  return objName;
}

References G4UIcommand::ConvertToString().

Referenced by DumpBooleanVolume(), DumpElement(), DumpIsotope(), DumpLogVol(), DumpMaterial(), DumpMultiUnionVolume(), DumpScaledVolume(), and DumpSolid().

GetPVChildren()

std::vector< G4VPhysicalVolume * > G4tgbGeometryDumper::GetPVChildren ( G4LogicalVolume *  lv )

private

Definition at line 1170 of file G4tgbGeometryDumper.cc.

{
  G4PhysicalVolumeStore* pvstore = G4PhysicalVolumeStore::GetInstance();
  std::vector<G4VPhysicalVolume*> children;
  for(auto ite = pvstore->cbegin(); ite != pvstore->cend(); ++ite)
  {
    if((*ite)->GetMotherLogical() == lv)
    {
      children.push_back(*ite);
#ifdef G4VERBOSE
      if(G4tgrMessenger::GetVerboseLevel() >= 1)
      {
        G4cout << " G4tgbGeometryDumper::GetPVChildren() - adding children: "
               << (*ite)->GetName() << " of " << lv->GetName() << G4endl;
      }
#endif
    }
  }
 
  return children;
}

References G4cout, G4endl, G4PhysicalVolumeStore::GetInstance(), G4LogicalVolume::GetName(), and G4tgrMessenger::GetVerboseLevel().

Referenced by DumpPhysVol().

GetSolidParams()

std::vector< G4double > G4tgbGeometryDumper::GetSolidParams

(

const G4VSolid *

so

)

Definition at line 806 of file G4tgbGeometryDumper.cc.

{
  std::vector<G4double> params;
 
  G4String solidType = so->GetEntityType();
  solidType          = GetTGSolidType(solidType);
 
  if(solidType == "BOX")
  {
    const G4Box* sb = dynamic_cast<const G4Box*>(so);
    if(sb != nullptr)
    {
      params.push_back(sb->GetXHalfLength());
      params.push_back(sb->GetYHalfLength());
      params.push_back(sb->GetZHalfLength());
    }
  }
  else if(solidType == "TUBS")
  {
    const G4Tubs* tu = dynamic_cast<const G4Tubs*>(so);
    if(tu != nullptr)
    {
      params.push_back(tu->GetInnerRadius());
      params.push_back(tu->GetOuterRadius());
      params.push_back(tu->GetZHalfLength());
      params.push_back(tu->GetStartPhiAngle() / deg);
      params.push_back(tu->GetDeltaPhiAngle() / deg);
    }
  }
  else if(solidType == "TRAP")
  {
    const G4Trap* trp = dynamic_cast<const G4Trap*>(so);
    if(trp != nullptr)
    {
      G4ThreeVector symAxis(trp->GetSymAxis());
      params.push_back(trp->GetZHalfLength());
      params.push_back(symAxis.theta() / deg);
      params.push_back(symAxis.phi() / deg);
      params.push_back(trp->GetYHalfLength1());
      params.push_back(trp->GetXHalfLength1());
      params.push_back(trp->GetXHalfLength2());
      params.push_back(std::atan(trp->GetTanAlpha1()) / deg);
      params.push_back(trp->GetYHalfLength2());
      params.push_back(trp->GetXHalfLength3());
      params.push_back(trp->GetXHalfLength4());
      params.push_back(std::atan(trp->GetTanAlpha2()) / deg);
    }
  }
  else if(solidType == "TRD")
  {
    const G4Trd* tr = dynamic_cast<const G4Trd*>(so);
    if(tr != nullptr)
    {
      params.push_back(tr->GetXHalfLength1());
      params.push_back(tr->GetXHalfLength2());
      params.push_back(tr->GetYHalfLength1());
      params.push_back(tr->GetYHalfLength2());
      params.push_back(tr->GetZHalfLength());
    }
  }
  else if(solidType == "PARA")
  {
    const G4Para* para = dynamic_cast<const G4Para*>(so);
    if(para != nullptr)
    {
      G4ThreeVector symAxis(para->GetSymAxis());
      params.push_back(para->GetXHalfLength());
      params.push_back(para->GetYHalfLength());
      params.push_back(para->GetZHalfLength());
      params.push_back(std::atan(para->GetTanAlpha()) / deg);
      params.push_back(symAxis.theta() / deg);
      params.push_back(symAxis.phi() / deg);
    }
  }
  else if(solidType == "CONS")
  {
    const G4Cons* cn = dynamic_cast<const G4Cons*>(so);
    if(cn != nullptr)
    {
      params.push_back(cn->GetInnerRadiusMinusZ());
      params.push_back(cn->GetOuterRadiusMinusZ());
      params.push_back(cn->GetInnerRadiusPlusZ());
      params.push_back(cn->GetOuterRadiusPlusZ());
      params.push_back(cn->GetZHalfLength());
      params.push_back(cn->GetStartPhiAngle() / deg);
      params.push_back(cn->GetDeltaPhiAngle() / deg);
    }
  }
  else if(solidType == "SPHERE")
  {
    const G4Sphere* sphere = dynamic_cast<const G4Sphere*>(so);
    if(sphere != nullptr)
    {
      params.push_back(sphere->GetInnerRadius());
      params.push_back(sphere->GetOuterRadius());
      params.push_back(sphere->GetStartPhiAngle() / deg);
      params.push_back(sphere->GetDeltaPhiAngle() / deg);
      params.push_back(sphere->GetStartThetaAngle() / deg);
      params.push_back(sphere->GetDeltaThetaAngle() / deg);
    }
  }
  else if(solidType == "ORB")
  {
    const G4Orb* orb = dynamic_cast<const G4Orb*>(so);
    if(orb != nullptr)
    {
      params.push_back(orb->GetRadius());
    }
  }
  else if(solidType == "TORUS")
  {
    const G4Torus* torus = dynamic_cast<const G4Torus*>(so);
    if(torus != nullptr)
    {
      params.push_back(torus->GetRmin());
      params.push_back(torus->GetRmax());
      params.push_back(torus->GetRtor());
      params.push_back(torus->GetSPhi() / deg);
      params.push_back(torus->GetDPhi() / deg);
    }
  }
  else if(solidType == "POLYCONE")
  {
    //--- Dump RZ corners, as original parameters will not be present
    //    if it was build from RZ corners
    const G4Polycone* plc = dynamic_cast<const G4Polycone*>(so);
    if(plc != nullptr)
    {
      G4double angphi = plc->GetStartPhi() / deg;
      if(angphi > 180 * deg)
      {
        angphi -= 360 * deg;
      }
      G4double endphi = plc->GetEndPhi() / deg;
      if(endphi > 180 * deg)
      {
        endphi -= 360 * deg;
      }
      params.push_back(angphi);
      params.push_back(endphi - angphi);
      //      params.push_back(plc->GetOriginalParameters()->Opening_angle / deg);
      G4int ncor = plc->GetNumRZCorner();
      params.push_back(ncor);
 
      for(G4int ii = 0; ii < ncor; ++ii)
      {
        params.push_back(plc->GetCorner(ii).r);
        params.push_back(plc->GetCorner(ii).z);
      }
    }
  }
  else if(solidType == "GENERICPOLYCONE")
  {
    //--- Dump RZ corners
    const G4GenericPolycone* plc = dynamic_cast<const G4GenericPolycone*>(so);
    if(plc != nullptr)
    {
      G4double angphi = plc->GetStartPhi() / deg;
      if(angphi > 180 * deg)
      {
        angphi -= 360 * deg;
      }
      G4double endphi = plc->GetEndPhi() / deg;
      if(endphi > 180 * deg)
      {
        endphi -= 360 * deg;
      }
      params.push_back(angphi);
      params.push_back(endphi - angphi);
      G4int ncor = plc->GetNumRZCorner();
      params.push_back(ncor);
 
      for(G4int ii = 0; ii < ncor; ++ii)
      {
        params.push_back(plc->GetCorner(ii).r);
        params.push_back(plc->GetCorner(ii).z);
      }
    }
  }
  else if(solidType == "POLYHEDRA")
  {
    //--- Dump RZ corners, as original parameters will not be present
    //    if it was build from RZ corners
    const G4Polyhedra* ph = (dynamic_cast<const G4Polyhedra*>(so));
    if(ph != nullptr)
    {
      G4double angphi = ph->GetStartPhi() / deg;
      if(angphi > 180 * deg)
        angphi -= 360 * deg;
 
      G4int ncor = ph->GetNumRZCorner();
 
      params.push_back(angphi);
      params.push_back(ph->GetOriginalParameters()->Opening_angle / deg);
      params.push_back(ph->GetNumSide());
      params.push_back(ncor);
 
      for(G4int ii = 0; ii < ncor; ++ii)
      {
        params.push_back(ph->GetCorner(ii).r);
        params.push_back(ph->GetCorner(ii).z);
      }
    }
  }
  else if(solidType == "ELLIPTICALTUBE")
  {
    const G4EllipticalTube* eltu = dynamic_cast<const G4EllipticalTube*>(so);
    if(eltu != nullptr)
    {
      params.push_back(eltu->GetDx());
      params.push_back(eltu->GetDy());
      params.push_back(eltu->GetDz());
    }
  }
  else if(solidType == "ELLIPSOID")
  {
    const G4Ellipsoid* dso = dynamic_cast<const G4Ellipsoid*>(so);
    if(dso != nullptr)
    {
      params.push_back(dso->GetSemiAxisMax(0));
      params.push_back(dso->GetSemiAxisMax(1));
      params.push_back(dso->GetSemiAxisMax(2));
      params.push_back(dso->GetZBottomCut());
      params.push_back(dso->GetZTopCut());
    }
  }
  else if(solidType == "ELLIPTICAL_CONE")
  {
    const G4EllipticalCone* elco = dynamic_cast<const G4EllipticalCone*>(so);
    if(elco != nullptr)
    {
      params.push_back(elco->GetSemiAxisX());
      params.push_back(elco->GetSemiAxisY());
      params.push_back(elco->GetZMax());
      params.push_back(elco->GetZTopCut());
    }
  }
  else if(solidType == "HYPE")
  {
    const G4Hype* hype = dynamic_cast<const G4Hype*>(so);
    if(hype != nullptr)
    {
      params.push_back(hype->GetInnerRadius());
      params.push_back(hype->GetOuterRadius());
      params.push_back(hype->GetInnerStereo() / deg);
      params.push_back(hype->GetOuterStereo() / deg);
      params.push_back(2 * hype->GetZHalfLength());
    }
    //  } else if( solidType == "TET" ) {
  }
  else if(solidType == "TWISTEDBOX")
  {
    const G4TwistedBox* tbox = dynamic_cast<const G4TwistedBox*>(so);
    if(tbox != nullptr)
    {
      params.push_back(tbox->GetPhiTwist() / deg);
      params.push_back(tbox->GetXHalfLength());
      params.push_back(tbox->GetYHalfLength());
      params.push_back(tbox->GetZHalfLength());
    }
  }
  else if(solidType == "TWISTEDTRAP")
  {
    const G4TwistedTrap* ttrap = dynamic_cast<const G4TwistedTrap*>(so);
    if(ttrap != nullptr)
    {
      params.push_back(ttrap->GetPhiTwist() / deg);
      params.push_back(ttrap->GetZHalfLength());
      params.push_back(ttrap->GetPolarAngleTheta() / deg);
      params.push_back(ttrap->GetAzimuthalAnglePhi() / deg);
      params.push_back(ttrap->GetY1HalfLength());
      params.push_back(ttrap->GetX1HalfLength());
      params.push_back(ttrap->GetX2HalfLength());
      params.push_back(ttrap->GetY2HalfLength());
      params.push_back(ttrap->GetX3HalfLength());
      params.push_back(ttrap->GetX4HalfLength());
      params.push_back(ttrap->GetTiltAngleAlpha() / deg);
    }
  }
  else if(solidType == "TWISTEDTRD")
  {
    const G4TwistedTrd* ttrd = dynamic_cast<const G4TwistedTrd*>(so);
    if(ttrd != nullptr)
    {
      params.push_back(ttrd->GetX1HalfLength());
      params.push_back(ttrd->GetX2HalfLength());
      params.push_back(ttrd->GetY1HalfLength());
      params.push_back(ttrd->GetY2HalfLength());
      params.push_back(ttrd->GetZHalfLength());
      params.push_back(ttrd->GetPhiTwist() / deg);
    }
  }
  else if(solidType == "TWISTEDTUBS")
  {
    const G4TwistedTubs* ttub = dynamic_cast<const G4TwistedTubs*>(so);
    if(ttub != nullptr)
    {
      params.push_back(ttub->GetInnerRadius());
      params.push_back(ttub->GetOuterRadius());
      params.push_back(ttub->GetZHalfLength());
      params.push_back(ttub->GetDPhi() / deg);
      params.push_back(ttub->GetPhiTwist() / deg);
    }
  }
  else
  {
    G4String ErrMessage = "Solid type not supported, sorry... " + solidType;
    G4Exception("G4tgbGeometryDumper::DumpSolidParams()", "NotImplemented",
                FatalException, ErrMessage);
  }
 
  return params;
}

References deg, FatalException, G4Exception(), G4TwistedTrap::GetAzimuthalAnglePhi(), G4Polyhedra::GetCorner(), G4GenericPolycone::GetCorner(), G4Polycone::GetCorner(), G4Cons::GetDeltaPhiAngle(), G4Sphere::GetDeltaPhiAngle(), G4Tubs::GetDeltaPhiAngle(), G4Sphere::GetDeltaThetaAngle(), G4Torus::GetDPhi(), G4TwistedTubs::GetDPhi(), G4EllipticalTube::GetDx(), G4EllipticalTube::GetDy(), G4EllipticalTube::GetDz(), G4GenericPolycone::GetEndPhi(), G4Polycone::GetEndPhi(), G4VSolid::GetEntityType(), G4Sphere::GetInnerRadius(), G4Tubs::GetInnerRadius(), G4Hype::GetInnerRadius(), G4TwistedTubs::GetInnerRadius(), G4Cons::GetInnerRadiusMinusZ(), G4Cons::GetInnerRadiusPlusZ(), G4Hype::GetInnerStereo(), G4GenericPolycone::GetNumRZCorner(), G4Polycone::GetNumRZCorner(), G4Polyhedra::GetNumRZCorner(), G4Polyhedra::GetNumSide(), G4Polyhedra::GetOriginalParameters(), G4Sphere::GetOuterRadius(), G4Tubs::GetOuterRadius(), G4Hype::GetOuterRadius(), G4TwistedTubs::GetOuterRadius(), G4Cons::GetOuterRadiusMinusZ(), G4Cons::GetOuterRadiusPlusZ(), G4Hype::GetOuterStereo(), G4TwistedBox::GetPhiTwist(), G4TwistedTrap::GetPhiTwist(), G4TwistedTrd::GetPhiTwist(), G4TwistedTubs::GetPhiTwist(), G4TwistedTrap::GetPolarAngleTheta(), G4Orb::GetRadius(), G4Torus::GetRmax(), G4Torus::GetRmin(), G4Torus::GetRtor(), G4Ellipsoid::GetSemiAxisMax(), G4EllipticalCone::GetSemiAxisX(), G4EllipticalCone::GetSemiAxisY(), G4Torus::GetSPhi(), G4GenericPolycone::GetStartPhi(), G4Polycone::GetStartPhi(), G4Polyhedra::GetStartPhi(), G4Cons::GetStartPhiAngle(), G4Sphere::GetStartPhiAngle(), G4Tubs::GetStartPhiAngle(), G4Sphere::GetStartThetaAngle(), G4Para::GetSymAxis(), G4Trap::GetSymAxis(), G4Para::GetTanAlpha(), G4Trap::GetTanAlpha1(), G4Trap::GetTanAlpha2(), GetTGSolidType(), G4TwistedTrap::GetTiltAngleAlpha(), G4TwistedTrap::GetX1HalfLength(), G4TwistedTrd::GetX1HalfLength(), G4TwistedTrap::GetX2HalfLength(), G4TwistedTrd::GetX2HalfLength(), G4TwistedTrap::GetX3HalfLength(), G4TwistedTrap::GetX4HalfLength(), G4Box::GetXHalfLength(), G4Para::GetXHalfLength(), G4TwistedBox::GetXHalfLength(), G4Trap::GetXHalfLength1(), G4Trd::GetXHalfLength1(), G4Trap::GetXHalfLength2(), G4Trd::GetXHalfLength2(), G4Trap::GetXHalfLength3(), G4Trap::GetXHalfLength4(), G4TwistedTrap::GetY1HalfLength(), G4TwistedTrd::GetY1HalfLength(), G4TwistedTrap::GetY2HalfLength(), G4TwistedTrd::GetY2HalfLength(), G4Box::GetYHalfLength(), G4Para::GetYHalfLength(), G4TwistedBox::GetYHalfLength(), G4Trap::GetYHalfLength1(), G4Trd::GetYHalfLength1(), G4Trap::GetYHalfLength2(), G4Trd::GetYHalfLength2(), G4Ellipsoid::GetZBottomCut(), G4Box::GetZHalfLength(), G4Cons::GetZHalfLength(), G4Para::GetZHalfLength(), G4Trap::GetZHalfLength(), G4Trd::GetZHalfLength(), G4Tubs::GetZHalfLength(), G4Hype::GetZHalfLength(), G4TwistedBox::GetZHalfLength(), G4TwistedTrap::GetZHalfLength(), G4TwistedTrd::GetZHalfLength(), G4TwistedTubs::GetZHalfLength(), G4EllipticalCone::GetZMax(), G4Ellipsoid::GetZTopCut(), G4EllipticalCone::GetZTopCut(), G4PolyhedraHistorical::Opening_angle, CLHEP::Hep3Vector::phi(), G4PolyconeSideRZ::r, G4PolyhedraSideRZ::r, CLHEP::Hep3Vector::theta(), G4PolyconeSideRZ::z, and G4PolyhedraSideRZ::z.

Referenced by DumpPVParameterised(), and DumpSolidParams().

GetTGSolidType()

G4String G4tgbGeometryDumper::GetTGSolidType ( const G4String &  solidtype )

private

Definition at line 1193 of file G4tgbGeometryDumper.cc.

{
  G4String newsolidType = solidType.substr(2, solidType.length());
  for(std::size_t ii = 0; ii < newsolidType.length(); ++ii)
  {
    newsolidType[ii] = toupper(newsolidType[ii]);
  }
  return newsolidType;
}

Referenced by DumpSolid(), and GetSolidParams().

GetTopPhysVol()

G4VPhysicalVolume * G4tgbGeometryDumper::GetTopPhysVol

(

)

Definition at line 104 of file G4tgbGeometryDumper.cc.

{
  G4PhysicalVolumeStore* pvstore = G4PhysicalVolumeStore::GetInstance();
  G4VPhysicalVolume* pv = *(pvstore->cbegin());
  for(;;)
  {
    G4LogicalVolume* lv = pv->GetMotherLogical();
    if(lv == 0)
    {
      break;
    }
 
    //----- look for one PV of this LV
    for(auto ite = pvstore->cbegin(); ite != pvstore->cend(); ++ite)
    {
      pv = (*ite);
      if(pv->GetLogicalVolume() == lv)
      {
        break;
      }
    }
  }
 
  return pv;
}

References G4PhysicalVolumeStore::GetInstance(), G4VPhysicalVolume::GetLogicalVolume(), and G4VPhysicalVolume::GetMotherLogical().

Referenced by DumpGeometry().

LookForExistingRotation()

G4String G4tgbGeometryDumper::LookForExistingRotation ( const G4RotationMatrix *  rotm )

private

Definition at line 1432 of file G4tgbGeometryDumper.cc.

{
  G4String rmName = "";
 
  for(auto ite = theRotMats.cbegin(); ite != theRotMats.cend(); ++ite)
  {
    if((*ite).second->isNear(*rotm))
    {
      rmName = (*ite).first;
      break;
    }
  }
  return rmName;
}

References theRotMats.

Referenced by DumpRotationMatrix().

MatDeterminant()

G4double G4tgbGeometryDumper::MatDeterminant ( G4RotationMatrix *  ro )

private

Definition at line 1204 of file G4tgbGeometryDumper.cc.

{
  G4Rep3x3 r = ro->rep3x3();
  return r.xx_ * (r.yy_ * r.zz_ - r.zy_ * r.yz_) -
         r.yx_ * (r.xy_ * r.zz_ - r.zy_ * r.xz_) +
         r.zx_ * (r.xy_ * r.yz_ - r.yy_ * r.xz_);
}

References CLHEP::HepRotation::rep3x3(), CLHEP::HepRep3x3::xx_, CLHEP::HepRep3x3::xy_, CLHEP::HepRep3x3::xz_, CLHEP::HepRep3x3::yx_, CLHEP::HepRep3x3::yy_, CLHEP::HepRep3x3::yz_, CLHEP::HepRep3x3::zx_, CLHEP::HepRep3x3::zy_, and CLHEP::HepRep3x3::zz_.

Referenced by DumpRotationMatrix().

Same2G4Isotopes()

G4bool G4tgbGeometryDumper::Same2G4Isotopes ( G4Isotope *  ele1, G4Isotope *  ele2  )

private

Definition at line 1448 of file G4tgbGeometryDumper.cc.

{
  if((isot1->GetZ() != isot2->GetZ()) || (isot1->GetN() != isot2->GetN()) ||
     (isot1->GetA() != isot2->GetA()))
  {
    return false;
  }
  else
  {
    return true;
  }
}

References G4Isotope::GetA(), G4Isotope::GetN(), and G4Isotope::GetZ().

Referenced by GetIsotopeName().

SubstituteRefl()

G4String G4tgbGeometryDumper::SubstituteRefl ( G4String  name )

private

Definition at line 1260 of file G4tgbGeometryDumper.cc.

{
  G4int irefl = name.rfind("_refl");
  if(irefl != -1)
  {
    name = name.substr(0, irefl) + "_REFL";
  }
  return name;
}

References G4InuclParticleNames::name().

Referenced by DumpLogVol(), DumpPVPlacement(), and DumpPVReplica().

SupressRefl()

G4String G4tgbGeometryDumper::SupressRefl ( G4String  name )

private

Definition at line 1249 of file G4tgbGeometryDumper.cc.

{
  G4int irefl = name.rfind("_refl");
  if(irefl != -1)
  {
    name = name.substr(0, irefl);
  }
  return name;
}

References G4InuclParticleNames::name().

Referenced by DumpLogVol().

Field Documentation

theElements

std::map<G4String, G4Element*> G4tgbGeometryDumper::theElements

private

Definition at line 110 of file G4tgbGeometryDumper.hh.

Referenced by DumpElement(), and DumpMaterial().

theFile

std::ofstream* G4tgbGeometryDumper::theFile = nullptr

private

Definition at line 107 of file G4tgbGeometryDumper.hh.

Referenced by DumpGeometry().

theInstance

G4ThreadLocal G4tgbGeometryDumper * G4tgbGeometryDumper::theInstance = nullptr

staticprivate

Definition at line 105 of file G4tgbGeometryDumper.hh.

Referenced by GetInstance().

theIsotopes

std::map<G4String, G4Isotope*> G4tgbGeometryDumper::theIsotopes

private

Definition at line 111 of file G4tgbGeometryDumper.hh.

Referenced by DumpElement(), DumpIsotope(), and GetIsotopeName().

theLogVols

std::map<G4String, G4LogicalVolume*> G4tgbGeometryDumper::theLogVols

private

Definition at line 113 of file G4tgbGeometryDumper.hh.

Referenced by CheckIfLogVolExists(), and DumpLogVol().

theMaterials

std::map<G4String, G4Material*> G4tgbGeometryDumper::theMaterials

private

Definition at line 109 of file G4tgbGeometryDumper.hh.

Referenced by DumpMaterial().

thePhysVols

std::map<G4String, G4VPhysicalVolume*> G4tgbGeometryDumper::thePhysVols

private

Definition at line 114 of file G4tgbGeometryDumper.hh.

Referenced by CheckIfPhysVolExists(), DumpPVPlacement(), and DumpPVReplica().

theRotationNumber

G4int G4tgbGeometryDumper::theRotationNumber = 0

private

Definition at line 117 of file G4tgbGeometryDumper.hh.

Referenced by DumpRotationMatrix().

theRotMats

std::map<G4String, G4RotationMatrix*> G4tgbGeometryDumper::theRotMats

private

Definition at line 115 of file G4tgbGeometryDumper.hh.

Referenced by DumpRotationMatrix(), and LookForExistingRotation().

theSolids

std::map<G4String, G4VSolid*> G4tgbGeometryDumper::theSolids

private

Definition at line 112 of file G4tgbGeometryDumper.hh.

Referenced by DumpBooleanVolume(), DumpMultiUnionVolume(), DumpScaledVolume(), DumpSolid(), and FindSolidName().

---

The documentation for this class was generated from the following files:

• source/persistency/ascii/include/G4tgbGeometryDumper.hh
• source/persistency/ascii/src/G4tgbGeometryDumper.cc