DD4hep  1.37.0
Detector Description Toolkit for High Energy Physics
Geant4Converter.cpp
Go to the documentation of this file.
1 //==========================================================================
2 // AIDA Detector description implementation
3 //--------------------------------------------------------------------------
4 // Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
5 // All rights reserved.
6 //
7 // For the licensing terms see $DD4hepINSTALL/LICENSE.
8 // For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
9 //
10 // Author : M.Frank
11 //
12 //==========================================================================
13 
14 // Framework include files
15 #include <DD4hep/Shapes.h>
16 #include <DD4hep/Volumes.h>
17 #include <DD4hep/Plugins.h>
18 #include <DD4hep/Printout.h>
19 #include <DD4hep/Detector.h>
20 #include <DD4hep/DD4hepUnits.h>
21 #include <DD4hep/PropertyTable.h>
22 #include <DD4hep/DetectorTools.h>
23 #include <DD4hep/detail/ShapesInterna.h>
24 #include <DD4hep/detail/ObjectsInterna.h>
25 #include <DD4hep/detail/DetectorInterna.h>
26 
27 #include <DDG4/Geant4Field.h>
28 #include <DDG4/Geant4Helpers.h>
29 #include <DDG4/Geant4Converter.h>
30 #include <DDG4/Geant4UserLimits.h>
31 #include <DDG4/Geant4AssemblyVolume.h>
32 #include <DDG4/Geant4PlacementParameterisation.h>
33 #include "Geant4ShapeConverter.h"
34 
35 // ROOT includes
36 #include <TClass.h>
37 #include <TTimeStamp.h>
38 #include <TGeoBoolNode.h>
39 
40 // Geant4 include files
41 #include <G4Version.hh>
42 #include <G4VisAttributes.hh>
43 #include <G4PVParameterised.hh>
44 #include <G4ProductionCuts.hh>
45 #include <G4VUserRegionInformation.hh>
46 
47 #include <G4Box.hh>
48 #include <G4Tubs.hh>
49 #include <G4Ellipsoid.hh>
50 #include <G4UnionSolid.hh>
51 #include <G4ReflectedSolid.hh>
52 #include <G4SubtractionSolid.hh>
53 #include <G4IntersectionSolid.hh>
54 #include <G4VSensitiveDetector.hh>
55 
56 #include <G4Region.hh>
57 #include <G4Element.hh>
58 #include <G4Isotope.hh>
59 #include <G4Material.hh>
60 #include <G4UserLimits.hh>
61 #include <G4RegionStore.hh>
62 #include <G4FieldManager.hh>
63 #include <G4LogicalVolume.hh>
64 #include <G4OpticalSurface.hh>
65 #include <G4ReflectionFactory.hh>
66 #include <G4LogicalSkinSurface.hh>
67 #include <G4ElectroMagneticField.hh>
68 #include <G4LogicalBorderSurface.hh>
69 #include <G4MaterialPropertiesTable.hh>
70 #if G4VERSION_NUMBER >= 1040
71 #include <G4MaterialPropertiesIndex.hh>
72 #endif
73 #include <G4ScaledSolid.hh>
74 #include <CLHEP/Units/SystemOfUnits.h>
75 
76 // C/C++ include files
77 #include <iostream>
78 #include <iomanip>
79 #include <sstream>
80 #include <limits>
81 
82 namespace units = dd4hep;
83 using namespace dd4hep::sim;
84 using namespace dd4hep;
85 
86 namespace {
87 
88  static constexpr const double CM_2_MM = (CLHEP::centimeter/dd4hep::centimeter);
89  static constexpr const char* GEANT4_TAG_CUSTOM = "Geant4-custom";
90  static constexpr const char* GEANT4_TAG_IGNORE = "Geant4-ignore";
91  static constexpr const char* GEANT4_TAG_PLUGIN = "Geant4-plugin";
92  static constexpr const char* GEANT4_TAG_BIRKSCONSTANT = "BirksConstant";
93  static constexpr const char* GEANT4_TAG_MEE = "MeanExcitationEnergy";
94  static constexpr const char* GEANT4_TAG_ENE_PER_ION_PAIR = "MeanEnergyPerIonPair";
95 
96  static std::string indent = "";
97 
98  template <typename O, typename C, typename F> void handleRefs(const O* o, const C& c, F pmf) {
99  for (typename C::const_iterator i = c.begin(); i != c.end(); ++i) {
100  //(o->*pmf)((*i)->GetName(), *i);
101  (o->*pmf)("", *i);
102  }
103  }
104 
105  template <typename O, typename C, typename F> void handle(const O* o, const C& c, F pmf) {
106  for (typename C::const_iterator i = c.begin(); i != c.end(); ++i) {
107  (o->*pmf)((*i)->GetName(), *i);
108  }
109  }
110 
111  template <typename O, typename F> void handleArray(const O* o, const TObjArray* c, F pmf) {
112  TObjArrayIter arr(c);
113  for(TObject* i = arr.Next(); i; i=arr.Next())
114  (o->*pmf)(i);
115  }
116 
117  template <typename O, typename C, typename F> void handleMap(const O* o, const C& c, F pmf) {
118  for (typename C::const_iterator i = c.begin(); i != c.end(); ++i)
119  (o->*pmf)((*i).first, (*i).second);
120  }
121 
122  template <typename O, typename C, typename F> void handleRMap(const O* o, const C& c, F pmf) {
123  for (typename C::const_reverse_iterator i = c.rbegin(); i != c.rend(); ++i) {
124  //cout << "Handle RMAP [ " << (*i).first << " ]" << std::endl;
125  handle(o, i->second, pmf);
126  }
127  }
128  template <typename O, typename C, typename F> void handleRMap_(const O* o, const C& c, F pmf) {
129  for (typename C::const_iterator i = c.begin(); i != c.end(); ++i) {
130  const auto& cc = (*i).second;
131  for (const auto& j : cc) {
132  (o->*pmf)(j);
133  }
134  }
135  }
136 
137  std::string make_NCName(const std::string& in) {
138  std::string res = detail::str_replace(in, "/", "_");
139  res = detail::str_replace(res, "#", "_");
140  return res;
141  }
142 
143  bool is_left_handed(const TGeoMatrix* m) {
144  const Double_t* r = m->GetRotationMatrix();
145  if ( r ) {
146  Double_t det =
147  r[0]*r[4]*r[8] + r[3]*r[7]*r[2] + r[6]*r[1]*r[5] -
148  r[2]*r[4]*r[6] - r[5]*r[7]*r[0] - r[8]*r[1]*r[3];
149  return det < 0e0;
150  }
151  return false;
152  }
153 
154  class G4UserRegionInformation : public G4VUserRegionInformation {
155  public:
156  Region region;
157  double threshold;
158  bool storeSecondaries;
159  G4UserRegionInformation()
160  : threshold(0.0), storeSecondaries(false) {
161  }
162  virtual ~G4UserRegionInformation() {
163  }
164  virtual void Print() const {
165  if (region.isValid())
166  printout(DEBUG, "Region", "Name:%s", region.name());
167  }
168  };
169 
170  std::pair<double,double> g4PropertyConversion(int index) {
171 #if G4VERSION_NUMBER >= 1040
172  switch(index) {
173  case kRINDEX: return std::make_pair(CLHEP::keV/units::keV, 1.0);
174  case kREFLECTIVITY: return std::make_pair(CLHEP::keV/units::keV, 1.0);
175  case kREALRINDEX: return std::make_pair(CLHEP::keV/units::keV, 1.0);
176  case kIMAGINARYRINDEX: return std::make_pair(CLHEP::keV/units::keV, 1.0);
177  case kEFFICIENCY: return std::make_pair(CLHEP::keV/units::keV, 1.0);
178  case kTRANSMITTANCE: return std::make_pair(CLHEP::keV/units::keV, 1.0);
179  case kSPECULARLOBECONSTANT: return std::make_pair(CLHEP::keV/units::keV, 1.0);
180  case kSPECULARSPIKECONSTANT: return std::make_pair(CLHEP::keV/units::keV, 1.0);
181  case kBACKSCATTERCONSTANT: return std::make_pair(CLHEP::keV/units::keV, 1.0);
182  case kGROUPVEL: return std::make_pair(CLHEP::keV/units::keV, (CLHEP::m/CLHEP::s)/(units::m/units::s)); // meter/second
183  case kMIEHG: return std::make_pair(CLHEP::keV/units::keV, CLHEP::m/units::m);
184  case kRAYLEIGH: return std::make_pair(CLHEP::keV/units::keV, CLHEP::m/units::m); // ??? says its a length
185  case kWLSCOMPONENT: return std::make_pair(CLHEP::keV/units::keV, 1.0);
186  case kWLSABSLENGTH: return std::make_pair(CLHEP::keV/units::keV, CLHEP::m/units::m);
187  case kABSLENGTH: return std::make_pair(CLHEP::keV/units::keV, CLHEP::m/units::m);
188 #if G4VERSION_NUMBER >= 1100
189  case kWLSCOMPONENT2: return std::make_pair(CLHEP::keV/units::keV, 1.0);
190  case kWLSABSLENGTH2: return std::make_pair(CLHEP::keV/units::keV, CLHEP::m/units::m);
191  case kSCINTILLATIONCOMPONENT1: return std::make_pair(CLHEP::keV/units::keV, units::keV/CLHEP::keV);
192  case kSCINTILLATIONCOMPONENT2: return std::make_pair(CLHEP::keV/units::keV, units::keV/CLHEP::keV);
193  case kSCINTILLATIONCOMPONENT3: return std::make_pair(CLHEP::keV/units::keV, units::keV/CLHEP::keV);
194 #else
195  case kFASTCOMPONENT: return std::make_pair(CLHEP::keV/units::keV, 1.0);
196  case kSLOWCOMPONENT: return std::make_pair(CLHEP::keV/units::keV, 1.0);
197 #endif
198  case kPROTONSCINTILLATIONYIELD: return std::make_pair(CLHEP::keV/units::keV, units::keV/CLHEP::keV); // Yields: 1/energy
199  case kDEUTERONSCINTILLATIONYIELD: return std::make_pair(CLHEP::keV/units::keV, units::keV/CLHEP::keV);
200  case kTRITONSCINTILLATIONYIELD: return std::make_pair(CLHEP::keV/units::keV, units::keV/CLHEP::keV);
201  case kALPHASCINTILLATIONYIELD: return std::make_pair(CLHEP::keV/units::keV, units::keV/CLHEP::keV);
202  case kIONSCINTILLATIONYIELD: return std::make_pair(CLHEP::keV/units::keV, units::keV/CLHEP::keV);
203  case kELECTRONSCINTILLATIONYIELD: return std::make_pair(CLHEP::keV/units::keV, units::keV/CLHEP::keV);
204  default:
205  break;
206  }
207  printout(FATAL,"Geant4Converter", "+++ Cannot convert material property with index: %d", index);
208 #else
209  printout(FATAL,"Geant4Converter", "+++ Cannot convert material property with index: %d [Need Geant4 > 10.03]", index);
210 #endif
211  return std::make_pair(0e0,0e0);
212  }
213 
214  double g4ConstPropertyConversion(int index) {
215 #if G4VERSION_NUMBER >= 1040
216  switch(index) {
217  case kSURFACEROUGHNESS: return CLHEP::m/units::m; // Length
218  case kISOTHERMAL_COMPRESSIBILITY: return (CLHEP::m3/CLHEP::keV)/(units::m3/CLHEP::keV); // Volume/Energy
219  case kRS_SCALE_FACTOR: return 1.0; // ??
220  case kWLSMEANNUMBERPHOTONS: return 1.0; // ??
221  case kWLSTIMECONSTANT: return CLHEP::second/units::second; // Time
222  case kMIEHG_FORWARD: return 1.0;
223  case kMIEHG_BACKWARD: return 1.0;
224  case kMIEHG_FORWARD_RATIO: return 1.0;
225  case kSCINTILLATIONYIELD: return units::keV/CLHEP::keV; // Energy
226  case kRESOLUTIONSCALE: return 1.0;
227  case kFERMIPOT: return CLHEP::keV/units::keV; // Energy
228  case kDIFFUSION: return 1.0;
229  case kSPINFLIP: return 1.0;
230  case kLOSS: return 1.0; // ??
231  case kLOSSCS: return CLHEP::barn/units::barn; // ??
232  case kABSCS: return CLHEP::barn/units::barn; // ??
233  case kSCATCS: return CLHEP::barn/units::barn; // ??
234  case kMR_NBTHETA: return 1.0;
235  case kMR_NBE: return 1.0;
236  case kMR_RRMS: return 1.0; // ??
237  case kMR_CORRLEN: return CLHEP::m/units::m; // Length
238  case kMR_THETAMIN: return 1.0;
239  case kMR_THETAMAX: return 1.0;
240  case kMR_EMIN: return CLHEP::keV/units::keV; // Energy
241  case kMR_EMAX: return CLHEP::keV/units::keV; // Energy
242  case kMR_ANGNOTHETA: return 1.0;
243  case kMR_ANGNOPHI: return 1.0;
244  case kMR_ANGCUT: return 1.0;
245 
246 #if G4VERSION_NUMBER >= 1100
247  case kSCINTILLATIONTIMECONSTANT1: return CLHEP::second/units::second; // Time
248  case kSCINTILLATIONTIMECONSTANT2: return CLHEP::second/units::second; // Time
249  case kSCINTILLATIONTIMECONSTANT3: return CLHEP::second/units::second; // Time
250  case kSCINTILLATIONRISETIME1: return CLHEP::second/units::second; // Time
251  case kSCINTILLATIONRISETIME2: return CLHEP::second/units::second; // Time
252  case kSCINTILLATIONRISETIME3: return CLHEP::second/units::second; // Time
253  case kSCINTILLATIONYIELD1: return 1.0;
254  case kSCINTILLATIONYIELD2: return 1.0;
255  case kSCINTILLATIONYIELD3: return 1.0;
256  case kPROTONSCINTILLATIONYIELD1: return 1.0;
257  case kPROTONSCINTILLATIONYIELD2: return 1.0;
258  case kPROTONSCINTILLATIONYIELD3: return 1.0;
259  case kDEUTERONSCINTILLATIONYIELD1: return 1.0;
260  case kDEUTERONSCINTILLATIONYIELD2: return 1.0;
261  case kDEUTERONSCINTILLATIONYIELD3: return 1.0;
262  case kALPHASCINTILLATIONYIELD1: return 1.0;
263  case kALPHASCINTILLATIONYIELD2: return 1.0;
264  case kALPHASCINTILLATIONYIELD3: return 1.0;
265  case kIONSCINTILLATIONYIELD1: return 1.0;
266  case kIONSCINTILLATIONYIELD2: return 1.0;
267  case kIONSCINTILLATIONYIELD3: return 1.0;
268  case kELECTRONSCINTILLATIONYIELD1: return 1.0;
269  case kELECTRONSCINTILLATIONYIELD2: return 1.0;
270  case kELECTRONSCINTILLATIONYIELD3: return 1.0;
271 #else
272  case kFASTTIMECONSTANT: return CLHEP::second/units::second; // Time
273  case kFASTSCINTILLATIONRISETIME: return CLHEP::second/units::second; // Time
274  case kSLOWTIMECONSTANT: return CLHEP::second/units::second; // Time
275  case kSLOWSCINTILLATIONRISETIME: return CLHEP::second/units::second; // Time
276  case kYIELDRATIO: return 1.0;
277 #endif
278  default:
279  break;
280  }
281  printout(FATAL,"Geant4Converter", "+++ Cannot convert CONST material property with index: %d", index);
282 #else
283  printout(FATAL,"Geant4Converter", "+++ Cannot convert material property with index: %d [Need Geant4 > 10.03]", index);
284 #endif
285  return 0.0;
286  }
287 }
288 
290 Geant4Converter::Geant4Converter(const Detector& description_ref)
291  : Geant4Mapping(description_ref), checkOverlaps(true) {
292  this->Geant4Mapping::init();
293  m_propagateRegions = true;
294  outputLevel = PrintLevel(printLevel() - 1);
295 }
296 
298 Geant4Converter::Geant4Converter(const Detector& description_ref, PrintLevel level)
299  : Geant4Mapping(description_ref), outputLevel(level) {
300  this->Geant4Mapping::init();
301  m_propagateRegions = true;
302 }
303 
305 Geant4Converter::~Geant4Converter() {
306 }
307 
309 void* Geant4Converter::handleIsotope(const std::string& /* name */, const TGeoIsotope* iso) const {
310  G4Isotope* g4i = data().g4Isotopes[iso];
311  if ( !g4i ) {
312  double a_conv = (CLHEP::g / CLHEP::mole);
313  g4i = new G4Isotope(iso->GetName(), iso->GetZ(), iso->GetN(), iso->GetA()*a_conv);
314  printout(debugElements ? ALWAYS : outputLevel,
315  "Geant4Converter", "++ Created G4 Isotope %s from data: Z=%d N=%d A=%.3f [g/mole]",
316  iso->GetName(), iso->GetZ(), iso->GetN(), iso->GetA());
317  data().g4Isotopes[iso] = g4i;
318  }
319  return g4i;
320 }
321 
323 void* Geant4Converter::handleElement(const std::string& name, const Atom element) const {
324  G4Element* g4e = data().g4Elements[element];
325  if ( !g4e ) {
326  PrintLevel lvl = debugElements ? ALWAYS : outputLevel;
327  if (element->GetNisotopes() > 0) {
328  g4e = new G4Element(name, element->GetTitle(), element->GetNisotopes());
329  for (int i = 0, n = element->GetNisotopes(); i < n; ++i) {
330  TGeoIsotope* iso = element->GetIsotope(i);
331  G4Isotope* g4iso = (G4Isotope*)handleIsotope(iso->GetName(), iso);
332  g4e->AddIsotope(g4iso, element->GetRelativeAbundance(i));
333  }
334  }
335  else {
336  // This adds in Geant4 the natural isotopes, which we normally do not want. We want to steer it outselves.
337  double a_conv = (CLHEP::g / CLHEP::mole);
338  g4e = new G4Element(element->GetTitle(), name, element->Z(), element->A()*a_conv);
339  printout(lvl, "Geant4Converter", "++ Created G4 Isotope %s from data: Z=%d N=%d A=%.3f [g/mole]",
340  element->GetName(), element->Z(), element->N(), element->A());
341  }
342  std::stringstream str;
343  str << (*g4e) << std::endl;
344  printout(lvl, "Geant4Converter", "++ Created G4 element %s", str.str().c_str());
345  data().g4Elements[element] = g4e;
346  }
347  return g4e;
348 }
349 
351 void* Geant4Converter::handleMaterial(const std::string& name, Material medium) const {
352  Geant4GeometryInfo& info = data();
353  G4Material* mat = info.g4Materials[medium];
354  if ( !mat ) {
355  PrintLevel lvl = debugMaterials ? ALWAYS : outputLevel;
356  TGeoMaterial* material = medium->GetMaterial();
357  G4State state = kStateUndefined;
358  double density = material->GetDensity() * (CLHEP::gram / CLHEP::cm3);
359  if ( density < 1e-25 )
360  density = 1e-25;
361  switch ( material->GetState() ) {
362  case TGeoMaterial::kMatStateSolid:
363  state = kStateSolid;
364  break;
365  case TGeoMaterial::kMatStateLiquid:
366  state = kStateLiquid;
367  break;
368  case TGeoMaterial::kMatStateGas:
369  state = kStateGas;
370  break;
371  default:
372  case TGeoMaterial::kMatStateUndefined:
373  state = kStateUndefined;
374  break;
375  }
376  printout(lvl,"Geant4Material","+++ Setting up material %s", name.c_str());
377  if ( material->IsMixture() ) {
378  double A_total = 0.0;
379  double W_total = 0.0;
380  TGeoMixture* mix = (TGeoMixture*) material;
381  int nElements = mix->GetNelements();
382  mat = new G4Material(name, density, nElements, state,
383  material->GetTemperature(), material->GetPressure());
384  for (int i = 0; i < nElements; ++i) {
385  A_total += (mix->GetAmixt())[i];
386  W_total += (mix->GetWmixt())[i];
387  }
388  for (int i = 0; i < nElements; ++i) {
389  TGeoElement* e = mix->GetElement(i);
390  G4Element* g4e = (G4Element*) handleElement(e->GetName(), Atom(e));
391  if (!g4e) {
392  printout(ERROR, name,
393  "Missing element component %s for material %s. A=%f W=%f",
394  e->GetName(), mix->GetName(), A_total, W_total);
395  }
396  //mat->AddElement(g4e, (mix->GetAmixt())[i] / A_total);
397  mat->AddElement(g4e, (mix->GetWmixt())[i] / W_total);
398  }
399  }
400  else {
401  double z = material->GetZ(), a = material->GetA();
402  if ( z < 1.0000001 ) z = 1.0;
403  if ( a < 0.5000001 ) a = 1.0;
404  mat = new G4Material(name, z, a, density, state,
405  material->GetTemperature(), material->GetPressure());
406  }
407 
408  std::string plugin_name { };
409  double value = 0e0;
410  double ionisation_mee = -2e100;
411  double ionisation_birks_constant = -2e100;
412  double ionisation_ene_per_ion_pair = -2e100;
413 
415  G4MaterialPropertiesTable* tab = 0;
416  TListIter propIt(&material->GetProperties());
417  for(TObject* obj=propIt.Next(); obj; obj = propIt.Next()) {
418  std::string exc_str;
419  bool custom_property = false;
420  TNamed* named = (TNamed*)obj;
421  TGDMLMatrix* matrix = info.manager->GetGDMLMatrix(named->GetTitle());
422  const char* cptr = ::strstr(matrix->GetName(), GEANT4_TAG_IGNORE);
423  if( nullptr != cptr ) {
424  printout(INFO,name,"++ Ignore property %s [%s]. Not Suitable for Geant4.",
425  matrix->GetName(), matrix->GetTitle());
426  continue;
427  }
428  cptr = ::strstr(matrix->GetTitle(), GEANT4_TAG_IGNORE);
429  if( nullptr != cptr ) {
430  printout(INFO,name,"++ Ignore property %s [%s]. Not Suitable for Geant4.",
431  matrix->GetName(), matrix->GetTitle());
432  continue;
433  }
434  cptr = ::strstr(matrix->GetName(), GEANT4_TAG_CUSTOM);
435  if( nullptr != cptr ) {
436  custom_property = true;
437  }
438  cptr = ::strstr(matrix->GetTitle(), GEANT4_TAG_CUSTOM);
439  if( nullptr != cptr ) {
440  custom_property = true;
441  }
442 
443  Geant4GeometryInfo::PropertyVector* v =
444  (Geant4GeometryInfo::PropertyVector*)handleMaterialProperties(matrix);
445  if( nullptr == v ) {
446  except("Geant4Converter", "++ FAILED to create G4 material %s [Cannot convert property:%s]",
447  material->GetName(), named->GetName());
448  }
449  if( nullptr == tab ) {
450  tab = new G4MaterialPropertiesTable();
451  mat->SetMaterialPropertiesTable(tab);
452  }
453  int idx = -1;
454  try {
455  if( !custom_property ) {
456  const auto& pn = tab->GetMaterialPropertyNames();
457  if( std::find(std::begin(pn), std::end(pn), named->GetName()) != pn.end() ) {
458  idx = tab->GetPropertyIndex(named->GetName());
459  }
460  }
461  }
462  catch(const std::exception& e) {
463  exc_str = e.what();
464  idx = -1;
465  }
466  catch(...) {
467  idx = -1;
468  }
469  if ( idx < 0 && !custom_property ) {
470  printout(ERROR, "Geant4Converter",
471  "++ UNKNOWN Geant4 Property: %-20s %s [IGNORED]",
472  exc_str.c_str(), named->GetName());
473  continue;
474  }
475  // We need to convert the property from TGeo units to Geant4 units
476  std::vector<double> bins(v->bins), vals(v->values);
477  std::pair<double, double> conv = { 1e0, 1e0 };
478  if( !custom_property ) {
479  conv = g4PropertyConversion(idx);
480  for(std::size_t i=0, count=bins.size(); i<count; ++i)
481  bins[i] *= conv.first, vals[i] *= conv.second;
482  }
483  G4MaterialPropertyVector* vec =
484  new G4MaterialPropertyVector(&bins[0], &vals[0], bins.size());
485 #if G4VERSION_NUMBER >= 1100
486  tab->AddProperty(named->GetName(), vec, custom_property);
487 #else
488  tab->AddProperty(named->GetName(), vec);
489 #endif
490  printout(lvl, name, "++ %sProperty: %-20s [%ld x %ld] -> %s ",
491  custom_property ? "CUSTOM " : "", named->GetName(),
492  matrix->GetRows(), matrix->GetCols(), named->GetTitle());
493  for(std::size_t i=0, count=v->bins.size(); i<count; ++i)
494  printout(lvl, name, " Geant4: %s %8.3g [MeV] TGeo: %8.3g [GeV] Conversion: %8.3g",
495  named->GetName(), bins[i], v->bins[i], conv.first);
496  }
497 
499  TListIter cpropIt(&material->GetConstProperties());
500  for(TObject* obj=cpropIt.Next(); obj; obj = cpropIt.Next()) {
501  std::string exc_str;
502  Bool_t err = kFALSE;
503  TNamed* named = (TNamed*)obj;
504  bool custom_property = false;
505 
506  const char* cptr = ::strstr(named->GetName(), GEANT4_TAG_IGNORE);
507  if( nullptr != cptr ) {
508  printout(INFO, name, "++ Ignore CONST property %s [%s].",
509  named->GetName(), named->GetTitle());
510  continue;
511  }
512  cptr = ::strstr(named->GetTitle(), GEANT4_TAG_IGNORE);
513  if( nullptr != cptr ) {
514  printout(INFO, name,"++ Ignore CONST property %s [%s].",
515  named->GetName(), named->GetTitle());
516  continue;
517  }
518  cptr = ::strstr(named->GetName(), GEANT4_TAG_PLUGIN);
519  if( nullptr != cptr ) {
520  printout(INFO, name, "++ Ignore CONST property %s [%s] --> Plugin.",
521  named->GetName(), named->GetTitle());
522  plugin_name = named->GetTitle();
523  continue;
524  }
525  cptr = ::strstr(named->GetName(), GEANT4_TAG_BIRKSCONSTANT);
526  if( nullptr != cptr ) {
527  err = kFALSE;
528  value = material->GetConstProperty(GEANT4_TAG_BIRKSCONSTANT,&err);
529  if ( err == kFALSE ) ionisation_birks_constant = value * (CLHEP::mm/CLHEP::MeV)/(units::mm/units::MeV);
530  continue;
531  }
532  cptr = ::strstr(named->GetName(), GEANT4_TAG_MEE);
533  if( nullptr != cptr ) {
534  err = kFALSE;
535  value = material->GetConstProperty(GEANT4_TAG_MEE, &err);
536  if ( err == kFALSE ) ionisation_mee = value * (CLHEP::MeV/units::MeV);
537  continue;
538  }
539  cptr = ::strstr(named->GetName(), GEANT4_TAG_ENE_PER_ION_PAIR);
540  if( nullptr != cptr ) {
541  err = kFALSE;
542  value = material->GetConstProperty(GEANT4_TAG_ENE_PER_ION_PAIR,&err);
543  if ( err == kFALSE ) ionisation_ene_per_ion_pair = value * (CLHEP::MeV/units::MeV);
544  continue;
545  }
546  cptr = ::strstr(named->GetName(), GEANT4_TAG_CUSTOM);
547  if ( nullptr != cptr ) {
548  custom_property = true;
549  }
550  cptr = ::strstr(named->GetTitle(), GEANT4_TAG_CUSTOM);
551  if ( nullptr != cptr ) {
552  custom_property = true;
553  }
554 
555  err = kFALSE;
556  value = info.manager->GetProperty(named->GetTitle(), &err);
557  if ( err != kFALSE ) {
558  except(name,
559  "++ FAILED to create G4 material %s [Cannot convert const property: %s]",
560  material->GetName(), named->GetName());
561  }
562  if ( nullptr == tab ) {
563  tab = new G4MaterialPropertiesTable();
564  mat->SetMaterialPropertiesTable(tab);
565  }
566  int idx = -1;
567  try {
568  if( !custom_property ) {
569  const auto& pn = tab->GetMaterialConstPropertyNames();
570  if( std::find(std::begin(pn), std::end(pn), named->GetName()) != pn.end() ) {
571  idx = tab->GetConstPropertyIndex(named->GetName());
572  }
573  }
574  }
575  catch(const std::exception& e) {
576  exc_str = e.what();
577  idx = -1;
578  }
579  catch(...) {
580  idx = -1;
581  }
582  if ( idx < 0 && !custom_property ) {
583  printout(ERROR, name,
584  "++ UNKNOWN Geant4 CONST Property: %-20s %s [IGNORED]",
585  exc_str.c_str(), named->GetName());
586  continue;
587  }
588  // We need to convert the property from TGeo units to Geant4 units
589  if ( !custom_property ) {
590  double conv = g4ConstPropertyConversion(idx);
591  value = value * conv;
592  }
593  printout(lvl, name, "++ %sCONST Property: %-20s %g ",
594  custom_property ? "CUSTOM " : "", named->GetName(), value);
595  tab->AddConstProperty(named->GetName(), value);
596  }
597  //
598  // Set Birk's constant if it was supplied in the material table of the TGeoMaterial
599  auto* ionisation = mat->GetIonisation();
600  std::stringstream str;
601  str << (*mat);
602  if ( ionisation ) {
603  if ( ionisation_birks_constant > 0e0 ) {
604  ionisation->SetBirksConstant(ionisation_birks_constant);
605  }
606  if ( ionisation_mee > -1e100 ) {
607  ionisation->SetMeanExcitationEnergy(ionisation_mee);
608  }
609  if ( ionisation_ene_per_ion_pair > 0e0 ) {
610  ionisation->SetMeanEnergyPerIonPair(ionisation_ene_per_ion_pair);
611  }
612  str << " log(MEE): " << std::setprecision(4) << ionisation->GetLogMeanExcEnergy();
613  if ( ionisation_birks_constant > 0e0 )
614  str << " Birk's constant: " << std::setprecision(4) << ionisation->GetBirksConstant() << " [mm/MeV]";
615  if ( ionisation_ene_per_ion_pair > 0e0 )
616  str << " Mean Energy Per Ion Pair: " << std::setprecision(4) << ionisation->GetMeanEnergyPerIonPair()/CLHEP::eV << " [eV]";
617  }
618  else {
619  str << " No ionisation parameters available.";
620  }
621  printout(lvl, name, "++ Created G4 material %s", str.str().c_str());
622 
623  if ( !plugin_name.empty() ) {
624  // Call plugin to create extended material if requested
625  Detector* det = const_cast<Detector*>(&m_detDesc);
626  G4Material* extended_mat = PluginService::Create<G4Material*>(plugin_name, det, medium, mat);
627  if ( !extended_mat ) {
628  except("G4Cnv::material["+name+"]","++ FATAL Failed to call plugin to create material.");
629  }
630  mat = extended_mat;
631  }
632  info.g4Materials[medium] = mat;
633  }
634  return mat;
635 }
636 
638 void* Geant4Converter::handleSolid(const std::string& name, const TGeoShape* shape) const {
639  G4VSolid* solid = nullptr;
640  if ( shape ) {
641  if ( nullptr != (solid = data().g4Solids[shape]) ) {
642  return solid;
643  }
644  TClass* isa = shape->IsA();
645  PrintLevel lvl = debugShapes ? ALWAYS : outputLevel;
646  if (isa == TGeoShapeAssembly::Class()) {
647  // Assemblies have no corresponding 'shape' in Geant4. Ignore the shape translation.
648  // It does not harm, since this 'shape' is never accessed afterwards.
649  data().g4Solids[shape] = solid = convertShape<TGeoShapeAssembly>(shape);
650  return solid;
651  }
652  else if (isa == TGeoBBox::Class())
653  solid = convertShape<TGeoBBox>(shape);
654  else if (isa == TGeoTube::Class())
655  solid = convertShape<TGeoTube>(shape);
656  else if (isa == TGeoTubeSeg::Class())
657  solid = convertShape<TGeoTubeSeg>(shape);
658  else if (isa == TGeoCtub::Class())
659  solid = convertShape<TGeoCtub>(shape);
660  else if (isa == TGeoEltu::Class())
661  solid = convertShape<TGeoEltu>(shape);
662  else if (isa == TwistedTubeObject::Class())
663  solid = convertShape<TwistedTubeObject>(shape);
664  else if (isa == TGeoTrd1::Class())
665  solid = convertShape<TGeoTrd1>(shape);
666  else if (isa == TGeoTrd2::Class())
667  solid = convertShape<TGeoTrd2>(shape);
668  else if (isa == TGeoHype::Class())
669  solid = convertShape<TGeoHype>(shape);
670  else if (isa == TGeoXtru::Class())
671  solid = convertShape<TGeoXtru>(shape);
672  else if (isa == TGeoPgon::Class())
673  solid = convertShape<TGeoPgon>(shape);
674  else if (isa == TGeoPcon::Class())
675  solid = convertShape<TGeoPcon>(shape);
676  else if (isa == TGeoCone::Class())
677  solid = convertShape<TGeoCone>(shape);
678  else if (isa == TGeoConeSeg::Class())
679  solid = convertShape<TGeoConeSeg>(shape);
680  else if (isa == TGeoParaboloid::Class())
681  solid = convertShape<TGeoParaboloid>(shape);
682  else if (isa == TGeoSphere::Class())
683  solid = convertShape<TGeoSphere>(shape);
684  else if (isa == TGeoTorus::Class())
685  solid = convertShape<TGeoTorus>(shape);
686  else if (isa == TGeoTrap::Class())
687  solid = convertShape<TGeoTrap>(shape);
688  else if (isa == TGeoArb8::Class())
689  solid = convertShape<TGeoArb8>(shape);
690  else if (isa == TGeoPara::Class())
691  solid = convertShape<TGeoPara>(shape);
692  else if (isa == TGeoTessellated::Class())
693  solid = convertShape<TGeoTessellated>(shape);
694  else if (isa == TGeoScaledShape::Class()) {
695  TGeoScaledShape* sh = (TGeoScaledShape*) shape;
696  TGeoShape* sol = sh->GetShape();
697  if ( sol->IsA() == TGeoShapeAssembly::Class() ) {
698  return solid;
699  }
700  const double* vals = sh->GetScale()->GetScale();
701  G4Scale3D scal(vals[0], vals[1], vals[2]);
702  G4VSolid* g4solid = (G4VSolid*)handleSolid(sol->GetName(), sol);
703  if ( scal.xx()>0e0 && scal.yy()>0e0 && scal.zz()>0e0 )
704  solid = new G4ScaledSolid(sh->GetName(), g4solid, scal);
705  else
706  solid = new G4ReflectedSolid(g4solid->GetName()+"_refl", g4solid, scal);
707  }
708  else if ( isa == TGeoCompositeShape::Class() ) {
709  const TGeoCompositeShape* sh = (const TGeoCompositeShape*) shape;
710  const TGeoBoolNode* boolean = sh->GetBoolNode();
711  TGeoBoolNode::EGeoBoolType oper = boolean->GetBooleanOperator();
712  TGeoMatrix* matrix = boolean->GetRightMatrix();
713  G4VSolid* left = (G4VSolid*) handleSolid(name + "_left", boolean->GetLeftShape());
714  G4VSolid* right = (G4VSolid*) handleSolid(name + "_right", boolean->GetRightShape());
715 
716  if (!left) {
717  except("Geant4Converter","++ No left Geant4 Solid present for composite shape: %s",name.c_str());
718  }
719  if (!right) {
720  except("Geant4Converter","++ No right Geant4 Solid present for composite shape: %s",name.c_str());
721  }
722 
723  TGeoShape* ls = boolean->GetLeftShape();
724  TGeoShape* rs = boolean->GetRightShape();
725  if (strcmp(ls->ClassName(), "TGeoScaledShape") == 0 &&
726  strcmp(rs->ClassName(), "TGeoBBox") == 0) {
727  if (strcmp(((TGeoScaledShape *)ls)->GetShape()->ClassName(), "TGeoSphere") == 0) {
728  if (oper == TGeoBoolNode::kGeoIntersection) {
729  TGeoScaledShape* lls = (TGeoScaledShape *)ls;
730  TGeoBBox* rrs = (TGeoBBox*)rs;
731  double sx = lls->GetScale()->GetScale()[0];
732  double sy = lls->GetScale()->GetScale()[1];
733  double radius = ((TGeoSphere *)lls->GetShape())->GetRmax();
734  double dz = rrs->GetDZ();
735  double zorig = rrs->GetOrigin()[2];
736  double zcut2 = dz + zorig;
737  double zcut1 = 2 * zorig - zcut2;
738  solid = new G4Ellipsoid(name,
739  sx * radius * CM_2_MM,
740  sy * radius * CM_2_MM,
741  radius * CM_2_MM,
742  zcut1 * CM_2_MM,
743  zcut2 * CM_2_MM);
744  data().g4Solids[shape] = solid;
745  return solid;
746  }
747  }
748  }
749 
750  if ( matrix->IsRotation() ) {
751  G4Transform3D transform;
752  g4Transform(matrix, transform);
753  if (oper == TGeoBoolNode::kGeoSubtraction)
754  solid = new G4SubtractionSolid(name, left, right, transform);
755  else if (oper == TGeoBoolNode::kGeoUnion)
756  solid = new G4UnionSolid(name, left, right, transform);
757  else if (oper == TGeoBoolNode::kGeoIntersection)
758  solid = new G4IntersectionSolid(name, left, right, transform);
759  }
760  else {
761  const Double_t *t = matrix->GetTranslation();
762  G4ThreeVector transform(t[0] * CM_2_MM, t[1] * CM_2_MM, t[2] * CM_2_MM);
763  if (oper == TGeoBoolNode::kGeoSubtraction)
764  solid = new G4SubtractionSolid(name, left, right, 0, transform);
765  else if (oper == TGeoBoolNode::kGeoUnion)
766  solid = new G4UnionSolid(name, left, right, 0, transform);
767  else if (oper == TGeoBoolNode::kGeoIntersection)
768  solid = new G4IntersectionSolid(name, left, right, 0, transform);
769  }
770  }
771 
772  if ( !solid )
773  except("Geant4Converter","++ Failed to handle unknown solid shape: %s of type %s",
774  name.c_str(), isa->GetName());
775  printout(lvl,"Geant4Converter","++ Successessfully converted shape [%p] of type:%s to %s.",
776  solid,isa->GetName(),typeName(typeid(*solid)).c_str());
777  data().g4Solids[shape] = solid;
778  }
779  return solid;
780 }
781 
783 void* Geant4Converter::handleVolume(const std::string& name, const TGeoVolume* volume) const {
784  Volume _v(volume);
785  Geant4GeometryInfo& info = data();
786  PrintLevel lvl = debugVolumes ? ALWAYS : outputLevel;
787  Geant4GeometryMaps::VolumeMap::const_iterator volIt = info.g4Volumes.find(volume);
788  if ( _v.testFlagBit(Volume::VETO_SIMU) ) {
789  printout(lvl, "Geant4Converter",
790  "++ Volume %s not converted [Veto'ed for simulation]",
791  volume->GetName());
792  return nullptr;
793  }
794  else if (volIt == info.g4Volumes.end() ) {
795  const char* vnam = volume->GetName();
796  TGeoMedium* med = volume->GetMedium();
797  Solid sh = volume->GetShape();
798  bool is_assembly = sh->IsA() == TGeoShapeAssembly::Class() || volume->IsAssembly();
799 
800  printout(lvl, "Geant4Converter", "++ Convert Volume %-32s: %p %s/%s assembly:%s",
801  vnam, volume, sh.type(), _v.type(), yes_no(is_assembly));
802  if ( is_assembly ) {
803  return nullptr;
804  }
805  Region reg = _v.region();
806  LimitSet lim = _v.limitSet();
807  VisAttr vis = _v.visAttributes();
808  G4Region* g4region = reg.isValid() ? info.g4Regions[reg] : nullptr;
809  G4UserLimits* g4limits = lim.isValid() ? info.g4Limits[lim] : nullptr;
810  G4VSolid* g4solid = (G4VSolid*) handleSolid(sh->GetName(), sh);
811  G4Material* g4medium = (G4Material*) handleMaterial(med->GetName(), Material(med));
813  if ( !g4solid ) {
814  except("G4Converter","++ No Geant4 Solid present for volume: %s", vnam);
815  }
816  else if ( !g4medium ) {
817  except("G4Converter","++ No Geant4 material present for volume: %s", vnam);
818  }
819  else if ( reg.isValid() && !g4region ) {
820  except("G4Cnv::volume["+name+"]"," ++ Failed to access Geant4 region %s.", reg.name());
821  }
822  else if ( lim.isValid() && !g4limits ) {
823  except("G4Cnv::volume["+name+"]","++ FATAL Failed to access Geant4 user limits %s.", lim.name());
824  }
825  else if ( g4limits ) {
826  printout(lvl, "Geant4Converter", "++ Volume + Apply LIMITS settings: %-24s to volume %s.",
827  lim.name(), vnam);
828  }
829 
830  G4LogicalVolume* g4vol = nullptr;
831  if( _v.hasProperties() && !_v.getProperty(GEANT4_TAG_PLUGIN,"").empty() ) {
832  Detector* det = const_cast<Detector*>(&m_detDesc);
833  std::string plugin = _v.getProperty(GEANT4_TAG_PLUGIN,"");
834  g4vol = PluginService::Create<G4LogicalVolume*>(plugin, det, _v, g4solid, g4medium);
835  if ( !g4vol ) {
836  except("G4Cnv::volume["+name+"]","++ FATAL Failed to call plugin to create logical volume.");
837  }
838  }
839  else {
840  g4vol = new G4LogicalVolume(g4solid, g4medium, vnam, nullptr, nullptr, nullptr);
841  }
842  PrintLevel plevel = (debugVolumes||debugRegions||debugLimits) ? ALWAYS : outputLevel;
844  unsigned char smart_less_value = _v.smartlessValue();
845  if( smart_less_value != Volume::NO_SMARTLESS_OPTIMIZATION ) {
846  printout(ALWAYS, "Geant4Converter",
847  "++ Volume %s Set Smartless value to %d",
848  vnam, int(smart_less_value));
849  g4vol->SetSmartless( smart_less_value );
850  }
852  if( g4limits ) {
853  g4vol->SetUserLimits(g4limits);
854  }
855  if( g4region ) {
856  printout(plevel, "Geant4Converter",
857  "++ Volume + Apply REGION settings: %-24s to volume %s.",
858  reg.name(), vnam);
859  // Handle the region settings for the world volume seperately.
860  // Geant4 does NOT WANT any regions assigned to the workd volume.
861  // The world's region is created in the G4RunManagerKernel!
862  if ( _v == m_detDesc.worldVolume() ) {
863  const char* wrd_nam = "DefaultRegionForTheWorld";
864  const char* src_nam = g4region->GetName().c_str();
865  auto* world_region = G4RegionStore::GetInstance()->GetRegion(wrd_nam, false);
866  if ( auto* cuts = g4region->GetProductionCuts() ) {
867  world_region->SetProductionCuts(cuts);
868  printout(plevel, "Geant4Converter",
869  "++ Volume %s Region: %s. Apply production cuts from %s",
870  vnam, wrd_nam, src_nam);
871  }
872  if ( auto* lims = g4region->GetUserLimits() ) {
873  world_region->SetUserLimits(lims);
874  printout(plevel, "Geant4Converter",
875  "++ Volume %s Region: %s. Apply user limits from %s",
876  vnam, wrd_nam, src_nam);
877  }
878  }
879  else {
880  g4vol->SetRegion(g4region);
881  g4region->AddRootLogicalVolume(g4vol);
882  }
883  }
884  G4VisAttributes* g4vattr = vis.isValid()
885  ? (G4VisAttributes*)handleVis(vis.name(), vis) : nullptr;
886  if ( g4vattr ) {
887  g4vol->SetVisAttributes(g4vattr);
888  }
889  info.g4Volumes[volume] = g4vol;
890  printout(lvl, "Geant4Converter",
891  "++ Volume + %s converted: %p ---> G4: %p", vnam, volume, g4vol);
892  }
893  return nullptr;
894 }
895 
897 void* Geant4Converter::collectVolume(const std::string& /* name */, const TGeoVolume* volume) const {
898  Geant4GeometryInfo& info = data();
899  Volume _v(volume);
900  Region reg = _v.region();
901  LimitSet lim = _v.limitSet();
902  SensitiveDetector det = _v.sensitiveDetector();
903  bool world = (volume == m_detDesc.worldVolume().ptr());
904 
905  if ( !world ) {
906  if ( lim.isValid() )
907  info.limits[lim].insert(volume);
908  if ( reg.isValid() )
909  info.regions[reg].insert(volume);
910  if ( det.isValid() )
911  info.sensitives[det].insert(volume);
912  }
913  return (void*)volume;
914 }
915 
917 void* Geant4Converter::handleAssembly(const std::string& name, const TGeoNode* node) const {
918  TGeoVolume* mot_vol = node->GetVolume();
919  PrintLevel lvl = debugVolumes ? ALWAYS : outputLevel;
920  if ( mot_vol->IsA() != TGeoVolumeAssembly::Class() ) {
921  return nullptr;
922  }
923  Volume _v(mot_vol);
924  if ( _v.testFlagBit(Volume::VETO_SIMU) ) {
925  printout(lvl, "Geant4Converter", "++ AssemblyNode %s not converted [Veto'ed for simulation]",node->GetName());
926  return nullptr;
927  }
928  Geant4GeometryInfo& info = data();
929  Geant4AssemblyVolume* g4 = info.g4AssemblyVolumes[node];
930  if ( g4 ) {
931  printout(ALWAYS, "Geant4Converter", "+++ Assembly: **** : Re-using existing assembly: %s",node->GetName());
932  }
933  if ( !g4 ) {
934  g4 = new Geant4AssemblyVolume();
935  for(Int_t i=0; i < mot_vol->GetNdaughters(); ++i) {
936  TGeoNode* dau = mot_vol->GetNode(i);
937  TGeoVolume* dau_vol = dau->GetVolume();
938  TGeoMatrix* tr = dau->GetMatrix();
939  G4Transform3D transform;
940 
941  g4Transform(tr, transform);
942  if ( is_left_handed(tr) ) {
943  G4Scale3D scale;
944  G4Rotate3D rot;
945  G4Translate3D trans;
946  transform.getDecomposition(scale, rot, trans);
947  printout(debugReflections ? ALWAYS : lvl, "Geant4Converter",
948  "++ Placing reflected ASSEMBLY. dau:%s to mother %s "
949  "Tr:x=%8.1f y=%8.1f z=%8.1f Scale:x=%4.2f y=%4.2f z=%4.2f",
950  dau_vol->GetName(), mot_vol->GetName(),
951  transform.dx(), transform.dy(), transform.dz(),
952  scale.xx(), scale.yy(), scale.zz());
953  }
954 
955  if ( dau_vol->IsA() == TGeoVolumeAssembly::Class() ) {
956  Geant4GeometryMaps::AssemblyMap::iterator ia = info.g4AssemblyVolumes.find(dau);
957  if ( ia == info.g4AssemblyVolumes.end() ) {
958  printout(FATAL, "Geant4Converter", "+++ Invalid child assembly at %s : %d parent: %s child:%s",
959  __FILE__, __LINE__, name.c_str(), dau->GetName());
960  delete g4;
961  return nullptr;
962  }
963  g4->placeAssembly(dau, (*ia).second, transform);
964  printout(lvl, "Geant4Converter", "+++ Assembly: AddPlacedAssembly %p: dau:%s "
965  "to mother %s Tr:x=%8.3f y=%8.3f z=%8.3f",
966  (void*)dau_vol, dau_vol->GetName(), mot_vol->GetName(),
967  transform.dx(), transform.dy(), transform.dz());
968  }
969  else {
970  Geant4GeometryMaps::VolumeMap::iterator iv = info.g4Volumes.find(dau_vol);
971  if ( iv == info.g4Volumes.end() ) {
972  printout(FATAL,"Geant4Converter", "+++ Invalid child volume at %s : %d parent: %s child:%s",
973  __FILE__, __LINE__, name.c_str(), dau->GetName());
974  except("Geant4Converter", "+++ Invalid child volume at %s : %d parent: %s child:%s",
975  __FILE__, __LINE__, name.c_str(), dau->GetName());
976  }
977  g4->placeVolume(dau,(*iv).second, transform);
978  printout(lvl, "Geant4Converter", "+++ Assembly: AddPlacedVolume %p: dau:%s "
979  "to mother %s Tr:x=%8.3f y=%8.3f z=%8.3f",
980  (void*)dau_vol, dau_vol->GetName(), mot_vol->GetName(),
981  transform.dx(), transform.dy(), transform.dz());
982  }
983  }
984  info.g4AssemblyVolumes[node] = g4;
985  }
986  return g4;
987 }
988 
990 void* Geant4Converter::handlePlacement(const std::string& name, const TGeoNode* node) const {
991  Geant4GeometryInfo& info = this->data();
992  PrintLevel lvl = this->debugPlacements ? ALWAYS : this->outputLevel;
993  Geant4GeometryMaps::PlacementMap::const_iterator g4it = info.g4Placements.find(node);
994  G4VPhysicalVolume* g4 = (g4it == info.g4Placements.end()) ? 0 : (*g4it).second;
995  TGeoVolume* vol = node->GetVolume();
996  Volume _v(vol);
997 
998  if ( _v.testFlagBit(Volume::VETO_SIMU) ) {
999  printout(lvl, "Geant4Converter", "++ Placement %s not converted [Veto'ed for simulation]",node->GetName());
1000  return nullptr;
1001  }
1002  //g4 = nullptr;
1003  if ( !g4 ) {
1004  TGeoVolume* mot_vol = node->GetMotherVolume();
1005  TGeoMatrix* tr = node->GetMatrix();
1006  if ( !tr ) {
1007  except("Geant4Converter",
1008  "++ Attempt to handle placement without transformation:%p %s of type %s vol:%p",
1009  node, node->GetName(), node->IsA()->GetName(), vol);
1010  }
1011  else if (nullptr == vol) {
1012  except("Geant4Converter", "++ Unknown G4 volume:%p %s of type %s ptr:%p",
1013  node, node->GetName(), node->IsA()->GetName(), vol);
1014  }
1015  else {
1016  int copy = node->GetNumber();
1017  bool node_is_reflected = is_left_handed(tr);
1018  bool node_is_assembly = vol->IsA() == TGeoVolumeAssembly::Class();
1019  bool mother_is_assembly = mot_vol ? mot_vol->IsA() == TGeoVolumeAssembly::Class() : false;
1020 
1021  if ( mother_is_assembly ) {
1022  //
1023  // Mother is an assembly:
1024  // Nothing to do here, because:
1025  // -- placed volumes were already added before in "handleAssembly"
1026  // -- imprint cannot be made, because this requires a logical volume as a mother
1027  //
1028  printout(lvl, "Geant4Converter", "+++ Assembly: **** : daughter %s to mother %s",
1029  vol->GetName(), mot_vol ? mot_vol->GetName() : "????");
1030  return nullptr;
1031  }
1032 
1033  G4LogicalVolume* g4mot = nullptr;
1034  auto volIt = info.g4Volumes.find(mot_vol);
1035  if ( volIt != info.g4Volumes.end() ) {
1036  // Rational: Conversion/scanning was steered from top->down.
1037  //
1038  // Hence all mothers have proper relationship also to re-aligned daughters.
1039  // However, only the re-aligned daughters have the proper mother-relationship.
1040  // --> If a mother was found, the converted mother is the real one.
1041  g4mot = (*volIt).second;
1042  }
1043  else if ( node != info.manager->GetTopNode() ) {
1048  TGeoNode *n1;
1049  TGeoIterator iter(info.manager->GetTopVolume());
1050  iter.SetType(1);
1051  printout(ALWAYS, "Geant4Converter", "+++ (SHOULD NOT ENTER HERE) Assembly: no G4 mother: %s org mot: %p",
1052  node->GetName(), mot_vol);
1053  while ( (n1=iter.Next()) ) {
1054  if ( n1 == node ) {
1055  TGeoNode* nmot = iter.GetNode(iter.GetLevel()-1);
1056  TGeoVolume* mmot = nmot->GetVolume();
1057  volIt = info.g4Volumes.find(mmot);
1058  if ( volIt != info.g4Volumes.end() ) {
1059  TString path;
1060  iter.GetPath(path);
1061  g4mot = (*volIt).second;
1062  printout(ALWAYS, "Geant4Converter", "+++ Assembly: Realigned mother: %s org mot: %p aligned: %p",
1063  path.Data(), mot_vol, mmot);
1064  break;
1065  }
1066  }
1067  }
1068  }
1069 
1070  G4Scale3D scale;
1071  G4Rotate3D rotate;
1072  G4Translate3D trans;
1073  G4Transform3D transform;
1074  g4Transform(tr, transform);
1075  transform.getDecomposition(scale, rotate, trans);
1076  if ( node_is_assembly ) {
1077  //
1078  // Node is an assembly:
1079  // Imprint the assembly. The mother MUST already be transformed.
1080  //
1081  printout(lvl, "Geant4Converter", "++ Assembly: makeImprint: dau:%-12s %s in mother %-12s "
1082  "Tr:x=%8.1f y=%8.1f z=%8.1f Scale:x=%4.2f y=%4.2f z=%4.2f",
1083  node->GetName(), node_is_reflected ? "(REFLECTED)" : "",
1084  mot_vol ? mot_vol->GetName() : "<unknown>",
1085  transform.dx(), transform.dy(), transform.dz(),
1086  scale.xx(), scale.yy(), scale.zz());
1087  Geant4AssemblyVolume* ass = info.g4AssemblyVolumes[node];
1088  Geant4AssemblyVolume::Chain chain;
1089  chain.emplace_back(node);
1090  if ( !ass ) {
1091  except("Geant4Converter",
1092  "+++ Assembly: %s mother: %s Geant4AssemblyVolume not present!",
1093  node->GetName(), mot_vol ? mot_vol->GetName() : "<unknown>");
1094  }
1095  ass->imprint(*this, node, chain, ass, g4mot, transform, checkOverlaps);
1096  return nullptr;
1097  }
1098  else if ( node != info.manager->GetTopNode() && nullptr == g4mot ) {
1099  //throw std::logic_error("Geant4Converter: Invalid mother volume found!");
1100  }
1101  PlacedVolume pv(node);
1102  const auto* pv_data = pv.data();
1103  G4LogicalVolume* g4vol = info.g4Volumes[vol];
1104  //G4LogicalVolume* g4mot = info.g4Volumes[mot_vol];
1105  G4PhysicalVolumesPair pvPlaced { nullptr, nullptr };
1106 
1107  if ( pv_data && pv_data->params && (pv_data->params->flags&Volume::REPLICATED) ) {
1108  EAxis axis = kUndefined;
1109  double width = 0e0, offset = 0e0;
1110  auto flags = pv_data->params->flags;
1111  auto count = pv_data->params->trafo1D.second;
1112  auto start = pv_data->params->start.Translation().Vect();
1113  auto delta = pv_data->params->trafo1D.first.Translation().Vect();
1114 
1115  if ( flags&Volume::X_axis )
1116  { axis = kXAxis; width = delta.X(); offset = start.X(); }
1117  else if ( flags&Volume::Y_axis )
1118  { axis = kYAxis; width = delta.Y(); offset = start.Y(); }
1119  else if ( flags&Volume::Z_axis )
1120  { axis = kZAxis; width = delta.Z(); offset = start.Z(); }
1121  else
1122  except("Geant4Converter",
1123  "++ Replication around unknown axis is not implemented. flags: %16X", flags);
1124  printout(INFO,"Geant4Converter","++ Replicate: Axis: %ld Count: %ld offset: %f width: %f",
1125  axis, count, offset, width);
1126  auto* g4pv = new G4PVReplica(name, // its name
1127  g4vol, // its logical volume
1128  g4mot, // its mother (logical) volume
1129  axis, // its replication axis
1130  count, // Number of replicas
1131  width, // Distance between 2 replicas
1132  offset); // Placement offset in axis direction
1133  pvPlaced = { g4pv, nullptr };
1134 #if 0
1135  pvPlaced =
1136  G4ReflectionFactory::Instance()->Replicate(name, // its name
1137  g4vol, // its logical volume
1138  g4mot, // its mother (logical) volume
1139  axis, // its replication axis
1140  count, // Number of replicas
1141  width, // Distance between 2 replicas
1142  offset); // Placement offset in axis direction
1144  auto* g4pv = pvPlaced.second ? pvPlaced.second : pvPlaced.first;
1145 #endif
1146  for( auto& handle : pv_data->params->placements )
1147  info.g4Placements[handle.ptr()] = g4pv;
1148  }
1149  else if ( pv_data && pv_data->params ) {
1150  auto* g4par = new Geant4PlacementParameterisation(pv);
1151  auto* g4pv = new G4PVParameterised(name, // its name
1152  g4vol, // its logical volume
1153  g4mot, // its mother (logical) volume
1154  g4par->axis(), // its replication axis
1155  g4par->count(), // Number of replicas
1156  g4par); // G4 parametrization
1157  pvPlaced = { g4pv, nullptr };
1159  for( auto& handle : pv_data->params->placements )
1160  info.g4Placements[handle.ptr()] = g4pv;
1161  }
1162  else {
1163  pvPlaced =
1164  G4ReflectionFactory::Instance()->Place(transform, // no rotation
1165  name, // its name
1166  g4vol, // its logical volume
1167  g4mot, // its mother (logical) volume
1168  false, // no boolean operations
1169  copy, // its copy number
1170  checkOverlaps);
1171  }
1172  printout(debugReflections||debugPlacements ? ALWAYS : lvl, "Geant4Converter",
1173  "++ Place %svolume %-12s in mother %-12s "
1174  "Tr:x=%8.1f y=%8.1f z=%8.1f Scale:x=%4.2f y=%4.2f z=%4.2f",
1175  node_is_reflected ? "REFLECTED " : "", _v.name(),
1176  mot_vol ? mot_vol->GetName() : "<unknown>",
1177  transform.dx(), transform.dy(), transform.dz(),
1178  scale.xx(), scale.yy(), scale.zz());
1179  // First 2 cases can be combined.
1180  // Leave them separated for debugging G4ReflectionFactory for now...
1181  if ( node_is_reflected && !pvPlaced.second )
1182  return info.g4Placements[node] = pvPlaced.first;
1183  else if ( !node_is_reflected && !pvPlaced.second )
1184  return info.g4Placements[node] = pvPlaced.first;
1185  // Now deal with valid pvPlaced.second ...
1186  if ( node_is_reflected )
1187  return info.g4Placements[node] = pvPlaced.first;
1188  else if ( !node_is_reflected )
1189  return info.g4Placements[node] = pvPlaced.first;
1190  g4 = pvPlaced.second ? pvPlaced.second : pvPlaced.first;
1191  }
1192  info.g4Placements[node] = g4;
1193  printout(ERROR, "Geant4Converter", "++ DEAD code. Should not end up here!");
1194  }
1195  return g4;
1196 }
1197 
1199 void* Geant4Converter::handleRegion(Region region, const std::set<const TGeoVolume*>& /* volumes */) const {
1200  G4Region* g4 = data().g4Regions[region];
1201  if ( !g4 ) {
1202  PrintLevel lvl = debugRegions ? ALWAYS : outputLevel;
1203  Region r = region;
1204  g4 = new G4Region(region.name());
1205 
1206  // create region info with storeSecondaries flag
1207  if( not r.wasThresholdSet() and r.storeSecondaries() ) {
1208  throw std::runtime_error("G4Region: StoreSecondaries is True, but no explicit threshold set:");
1209  }
1210  printout(lvl, "Geant4Converter", "++ Setting up region: %s", r.name());
1211  G4UserRegionInformation* info = new G4UserRegionInformation();
1212  info->region = r;
1213  info->threshold = r.threshold()*CLHEP::MeV/units::MeV;
1214  info->storeSecondaries = r.storeSecondaries();
1215  g4->SetUserInformation(info);
1216 
1217  printout(lvl, "Geant4Converter", "++ Converted region settings of:%s.", r.name());
1218  std::vector < std::string > &limits = r.limits();
1219  G4ProductionCuts* cuts = 0;
1220  // set production cut
1221  if( not r.useDefaultCut() ) {
1222  cuts = new G4ProductionCuts();
1223  cuts->SetProductionCut(r.cut()*CLHEP::mm/units::mm);
1224  printout(lvl, "Geant4Converter", "++ %s: Using default cut: %f [mm]",
1225  r.name(), r.cut()*CLHEP::mm/units::mm);
1226  }
1227  for( const auto& nam : limits ) {
1228  LimitSet ls = m_detDesc.limitSet(nam);
1229  if ( ls.isValid() ) {
1230  const LimitSet::Set& cts = ls.cuts();
1231  for (const auto& c : cts ) {
1232  int pid = 0;
1233  if ( c.particles == "*" ) pid = -1;
1234  else if ( c.particles == "e-" ) pid = idxG4ElectronCut;
1235  else if ( c.particles == "e+" ) pid = idxG4PositronCut;
1236  else if ( c.particles == "e[+-]" ) pid = -idxG4PositronCut-idxG4ElectronCut;
1237  else if ( c.particles == "e[-+]" ) pid = -idxG4PositronCut-idxG4ElectronCut;
1238  else if ( c.particles == "gamma" ) pid = idxG4GammaCut;
1239  else if ( c.particles == "proton" ) pid = idxG4ProtonCut;
1240  else throw std::runtime_error("G4Region: Invalid production cut particle-type:" + c.particles);
1241  if ( !cuts ) cuts = new G4ProductionCuts();
1242  if ( pid == -(idxG4PositronCut+idxG4ElectronCut) ) {
1243  cuts->SetProductionCut(c.value*CLHEP::mm/units::mm, idxG4PositronCut);
1244  cuts->SetProductionCut(c.value*CLHEP::mm/units::mm, idxG4ElectronCut);
1245  }
1246  else {
1247  cuts->SetProductionCut(c.value*CLHEP::mm/units::mm, pid);
1248  }
1249  printout(lvl, "Geant4Converter", "++ %s: Set cut [%s/%d] = %f [mm]",
1250  r.name(), c.particles.c_str(), pid, c.value*CLHEP::mm/units::mm);
1251  }
1252  bool found = false;
1253  const auto& lm = data().g4Limits;
1254  for (const auto& j : lm ) {
1255  if (nam == j.first->GetName()) {
1256  g4->SetUserLimits(j.second);
1257  printout(lvl, "Geant4Converter", "++ %s: Set limits %s to region type %s",
1258  r.name(), nam.c_str(), j.second->GetType().c_str());
1259  found = true;
1260  break;
1261  }
1262  }
1263  if ( found ) {
1264  continue;
1265  }
1266  }
1267  except("Geant4Converter", "++ G4Region: Failed to resolve limitset: " + nam);
1268  }
1270  if ( cuts ) g4->SetProductionCuts(cuts);
1271  data().g4Regions[region] = g4;
1272  }
1273  return g4;
1274 }
1275 
1277 void* Geant4Converter::handleLimitSet(LimitSet limitset, const std::set<const TGeoVolume*>& /* volumes */) const {
1278  G4UserLimits* g4 = data().g4Limits[limitset];
1279  if ( !g4 ) {
1280  PrintLevel lvl = debugLimits || debugRegions ? ALWAYS : outputLevel;
1281  struct LimitPrint {
1282  const LimitSet& ls;
1283  LimitPrint(const LimitSet& lset) : ls(lset) {}
1284  const LimitPrint& operator()(const std::string& pref, const Geant4UserLimits::Handler& h) const {
1285  if ( !h.particleLimits.empty() ) {
1286  printout(ALWAYS,"Geant4Converter",
1287  "+++ LimitSet: Explicit Limit %s.%s applied for particles:",ls.name(), pref.c_str());
1288  for(const auto& p : h.particleLimits)
1289  printout(ALWAYS,"Geant4Converter","+++ LimitSet: Particle type: %-18s PDG: %-6d : %f",
1290  p.first->GetParticleName().c_str(), p.first->GetPDGEncoding(), p.second);
1291  }
1292  else if ( h.defaultValue > std::numeric_limits<double>::epsilon() ) {
1293  printout(ALWAYS,"Geant4Converter",
1294  "+++ LimitSet: Implicit Limit %s.%s for wildcard particles: %f",
1295  ls.name(), pref.c_str(), float(h.defaultValue));
1296  }
1297  return *this;
1298  }
1299  };
1300  Geant4UserLimits* limits = new Geant4UserLimits(limitset);
1301  g4 = limits;
1302  printout(lvl, "Geant4Converter",
1303  "++ Successfully converted LimitSet: %s [%ld cuts, %ld limits]",
1304  limitset.name(), limitset.cuts().size(), limitset.limits().size());
1305  if ( debugRegions || debugLimits ) {
1306  LimitPrint print(limitset);
1307  print("maxTime", limits->maxTime)
1308  ("minEKine", limits->minEKine)
1309  ("minRange", limits->minRange)
1310  ("maxStepLength", limits->maxStepLength)
1311  ("maxTrackLength",limits->maxTrackLength);
1312  }
1313  data().g4Limits[limitset] = g4;
1314  }
1315  return g4;
1316 }
1317 
1319 void* Geant4Converter::handleVis(const std::string& /* name */, VisAttr attr) const {
1320  Geant4GeometryInfo& info = data();
1321  G4VisAttributes* g4 = info.g4Vis[attr];
1322  if ( !g4 ) {
1323  float red = 0, green = 0, blue = 0;
1324  int style = attr.lineStyle();
1325  attr.rgb(red, green, blue);
1326  g4 = new G4VisAttributes(attr.visible(), G4Colour(red, green, blue, attr.alpha()));
1327  //g4->SetLineWidth(attr->GetLineWidth());
1328  g4->SetDaughtersInvisible(!attr.showDaughters());
1329  if ( style == VisAttr::SOLID ) {
1330  g4->SetLineStyle(G4VisAttributes::unbroken);
1331  g4->SetForceWireframe(false);
1332  g4->SetForceSolid(true);
1333  }
1334  else if ( style == VisAttr::WIREFRAME || style == VisAttr::DASHED ) {
1335  g4->SetLineStyle(G4VisAttributes::dashed);
1336  g4->SetForceSolid(false);
1337  g4->SetForceWireframe(true);
1338  }
1339  info.g4Vis[attr] = g4;
1340  }
1341  return g4;
1342 }
1343 
1345 void Geant4Converter::handleProperties(Detector::Properties& prp) const {
1346  std::map < std::string, std::string > processors;
1347  static int s_idd = 9999999;
1348  for( const auto& [nam, vals] : prp ) {
1349  if ( nam.substr(0, 6) == "geant4" ) {
1350  auto id_it = vals.find("id");
1351  std::string id = (id_it == vals.end()) ? _toString(++s_idd,"%d") : (*id_it).second;
1352  processors.emplace(id, nam);
1353  }
1354  }
1355  for( const auto& p : processors ) {
1356  const GeoHandler* hdlr = this;
1357  const Detector::PropertyValues& vals = prp[p.second];
1358  auto iter = vals.find("type");
1359  if ( iter != vals.end() ) {
1360  std::string type = iter->second;
1361  std::string tag = type + "_Geant4_action";
1362  Detector* det = const_cast<Detector*>(&m_detDesc);
1363  long res = PluginService::Create<long>(tag, det, hdlr, &vals);
1364  if ( 0 == res ) {
1365  throw std::runtime_error("Failed to locate plugin to interprete files of type"
1366  " \"" + tag + "\" - no factory:" + type);
1367  }
1368  res = *(long*)res;
1369  if ( res != 1 ) {
1370  throw std::runtime_error("Failed to invoke the plugin " + tag + " of type " + type);
1371  }
1372  printout(outputLevel, "Geant4Converter", "+++++ Executed Successfully Geant4 setup module *%s*.", type.c_str());
1373  continue;
1374  }
1375  printout(outputLevel, "Geant4Converter", "+++++ FAILED to execute Geant4 setup module *%s*.", p.second.c_str());
1376  }
1377 }
1378 
1380 void* Geant4Converter::handleMaterialProperties(TObject* mtx) const {
1381  Geant4GeometryInfo& info = data();
1382  TGDMLMatrix* matrix = (TGDMLMatrix*)mtx;
1383  const char* cptr = ::strstr(matrix->GetName(), GEANT4_TAG_IGNORE);
1384  Geant4GeometryInfo::PropertyVector* g4 = info.g4OpticalProperties[matrix];
1385 
1386  if ( nullptr != cptr ) { // Check if the property should not be passed to Geant4
1387  printout(INFO,"Geant4MaterialProperties","++ Ignore property %s [%s].",
1388  matrix->GetName(), matrix->GetTitle());
1389  return nullptr;
1390  }
1391  cptr = ::strstr(matrix->GetTitle(), GEANT4_TAG_IGNORE);
1392  if ( nullptr != cptr ) { // Check if the property should not be passed to Geant4
1393  printout(INFO,"Geant4MaterialProperties","++ Ignore property %s [%s].",
1394  matrix->GetName(), matrix->GetTitle());
1395  return nullptr;
1396  }
1397 
1398  if ( !g4 ) {
1399  PrintLevel lvl = debugMaterials ? ALWAYS : outputLevel;
1400  g4 = new Geant4GeometryInfo::PropertyVector();
1401  std::size_t rows = matrix->GetRows();
1402  g4->name = matrix->GetName();
1403  g4->title = matrix->GetTitle();
1404  g4->bins.reserve(rows);
1405  g4->values.reserve(rows);
1406  for( std::size_t i=0; i<rows; ++i ) {
1407  g4->bins.emplace_back(matrix->Get(i,0) /* *CLHEP::eV/units::eV */);
1408  g4->values.emplace_back(matrix->Get(i,1));
1409  }
1410  printout(lvl, "Geant4Converter",
1411  "++ Successfully converted material property:%s : %s [%ld rows]",
1412  matrix->GetName(), matrix->GetTitle(), rows);
1413  info.g4OpticalProperties[matrix] = g4;
1414  }
1415  return g4;
1416 }
1417 
1418 static G4OpticalSurfaceFinish geant4_surface_finish(TGeoOpticalSurface::ESurfaceFinish f) {
1419 #define TO_G4_FINISH(x) case TGeoOpticalSurface::kF##x : return x;
1420  switch(f) {
1421  TO_G4_FINISH(polished); // smooth perfectly polished surface
1422  TO_G4_FINISH(polishedfrontpainted); // smooth top-layer (front) paint
1423  TO_G4_FINISH(polishedbackpainted); // same is 'polished' but with a back-paint
1424 
1425  TO_G4_FINISH(ground); // rough surface
1426  TO_G4_FINISH(groundfrontpainted); // rough top-layer (front) paint
1427  TO_G4_FINISH(groundbackpainted); // same as 'ground' but with a back-paint
1428 
1429  TO_G4_FINISH(polishedlumirrorair); // mechanically polished surface, with lumirror
1430  TO_G4_FINISH(polishedlumirrorglue); // mechanically polished surface, with lumirror & meltmount
1431  TO_G4_FINISH(polishedair); // mechanically polished surface
1432  TO_G4_FINISH(polishedteflonair); // mechanically polished surface, with teflon
1433  TO_G4_FINISH(polishedtioair); // mechanically polished surface, with tio paint
1434  TO_G4_FINISH(polishedtyvekair); // mechanically polished surface, with tyvek
1435  TO_G4_FINISH(polishedvm2000air); // mechanically polished surface, with esr film
1436  TO_G4_FINISH(polishedvm2000glue); // mechanically polished surface, with esr film & meltmount
1437 
1438  TO_G4_FINISH(etchedlumirrorair); // chemically etched surface, with lumirror
1439  TO_G4_FINISH(etchedlumirrorglue); // chemically etched surface, with lumirror & meltmount
1440  TO_G4_FINISH(etchedair); // chemically etched surface
1441  TO_G4_FINISH(etchedteflonair); // chemically etched surface, with teflon
1442  TO_G4_FINISH(etchedtioair); // chemically etched surface, with tio paint
1443  TO_G4_FINISH(etchedtyvekair); // chemically etched surface, with tyvek
1444  TO_G4_FINISH(etchedvm2000air); // chemically etched surface, with esr film
1445  TO_G4_FINISH(etchedvm2000glue); // chemically etched surface, with esr film & meltmount
1446 
1447  TO_G4_FINISH(groundlumirrorair); // rough-cut surface, with lumirror
1448  TO_G4_FINISH(groundlumirrorglue); // rough-cut surface, with lumirror & meltmount
1449  TO_G4_FINISH(groundair); // rough-cut surface
1450  TO_G4_FINISH(groundteflonair); // rough-cut surface, with teflon
1451  TO_G4_FINISH(groundtioair); // rough-cut surface, with tio paint
1452  TO_G4_FINISH(groundtyvekair); // rough-cut surface, with tyvek
1453  TO_G4_FINISH(groundvm2000air); // rough-cut surface, with esr film
1454  TO_G4_FINISH(groundvm2000glue); // rough-cut surface, with esr film & meltmount
1455 
1456  // for DAVIS model
1457  TO_G4_FINISH(Rough_LUT); // rough surface
1458  TO_G4_FINISH(RoughTeflon_LUT); // rough surface wrapped in Teflon tape
1459  TO_G4_FINISH(RoughESR_LUT); // rough surface wrapped with ESR
1460  TO_G4_FINISH(RoughESRGrease_LUT); // rough surface wrapped with ESR and coupled with opical grease
1461  TO_G4_FINISH(Polished_LUT); // polished surface
1462  TO_G4_FINISH(PolishedTeflon_LUT); // polished surface wrapped in Teflon tape
1463  TO_G4_FINISH(PolishedESR_LUT); // polished surface wrapped with ESR
1464  TO_G4_FINISH(PolishedESRGrease_LUT); // polished surface wrapped with ESR and coupled with opical grease
1465  TO_G4_FINISH(Detector_LUT); // polished surface with optical grease
1466  default:
1467  printout(ERROR,"Geant4Surfaces","++ Unknown finish style: %d [%s]. Assume polished!",
1468  int(f), TGeoOpticalSurface::FinishToString(f));
1469  return polished;
1470  }
1471 #undef TO_G4_FINISH
1472 }
1473 
1474 static G4SurfaceType geant4_surface_type(TGeoOpticalSurface::ESurfaceType t) {
1475 #define TO_G4_TYPE(x) case TGeoOpticalSurface::kT##x : return x;
1476  switch(t) {
1477  TO_G4_TYPE(dielectric_metal); // dielectric-metal interface
1478  TO_G4_TYPE(dielectric_dielectric); // dielectric-dielectric interface
1479  TO_G4_TYPE(dielectric_LUT); // dielectric-Look-Up-Table interface
1480  TO_G4_TYPE(dielectric_LUTDAVIS); // dielectric-Look-Up-Table DAVIS interface
1481  TO_G4_TYPE(dielectric_dichroic); // dichroic filter interface
1482  TO_G4_TYPE(firsov); // for Firsov Process
1483  TO_G4_TYPE(x_ray); // for x-ray mirror process
1484  default:
1485  printout(ERROR,"Geant4Surfaces","++ Unknown surface type: %d [%s]. Assume dielectric_metal!",
1486  int(t), TGeoOpticalSurface::TypeToString(t));
1487  return dielectric_metal;
1488  }
1489 #undef TO_G4_TYPE
1490 }
1491 
1492 static G4OpticalSurfaceModel geant4_surface_model(TGeoOpticalSurface::ESurfaceModel surfMod) {
1493 #define TO_G4_MODEL(x) case TGeoOpticalSurface::kM##x : return x;
1494  switch(surfMod) {
1495  TO_G4_MODEL(glisur); // original GEANT3 model
1496  TO_G4_MODEL(unified); // UNIFIED model
1497  TO_G4_MODEL(LUT); // Look-Up-Table model
1498  TO_G4_MODEL(DAVIS); // DAVIS model
1499  TO_G4_MODEL(dichroic); // dichroic filter
1500  default:
1501  printout(ERROR,"Geant4Surfaces","++ Unknown surface model: %d [%s]. Assume glisur!",
1502  int(surfMod), TGeoOpticalSurface::ModelToString(surfMod));
1503  return glisur;
1504  }
1505 #undef TO_G4_MODEL
1506 }
1507 
1509 void* Geant4Converter::handleOpticalSurface(TObject* surface) const {
1510  TGeoOpticalSurface* optSurf = (TGeoOpticalSurface*)surface;
1511  Geant4GeometryInfo& info = data();
1512  G4OpticalSurface* g4 = info.g4OpticalSurfaces[optSurf];
1513  if ( !g4 ) {
1514  G4SurfaceType type = geant4_surface_type(optSurf->GetType());
1515  G4OpticalSurfaceModel model = geant4_surface_model(optSurf->GetModel());
1516  G4OpticalSurfaceFinish finish = geant4_surface_finish(optSurf->GetFinish());
1517  std::string name = make_NCName(optSurf->GetName());
1518  PrintLevel lvl = debugSurfaces ? ALWAYS : DEBUG;
1519  g4 = new G4OpticalSurface(name, model, finish, type, optSurf->GetValue());
1520  g4->SetSigmaAlpha(optSurf->GetSigmaAlpha());
1521  g4->SetPolish(optSurf->GetPolish());
1522 
1523  printout(lvl, "Geant4Converter",
1524  "++ Created OpticalSurface: %-18s type:%s model:%s finish:%s SigmaAlphs: %.3e Polish: %.3e",
1525  optSurf->GetName(),
1526  TGeoOpticalSurface::TypeToString(optSurf->GetType()),
1527  TGeoOpticalSurface::ModelToString(optSurf->GetModel()),
1528  TGeoOpticalSurface::FinishToString(optSurf->GetFinish()),
1529  optSurf->GetSigmaAlpha(), optSurf->GetPolish());
1532  G4MaterialPropertiesTable* tab = nullptr;
1533  TListIter itp(&optSurf->GetProperties());
1534  for(TObject* obj = itp.Next(); obj; obj = itp.Next()) {
1535  std::string exc_str;
1536  TNamed* named = (TNamed*)obj;
1537  TGDMLMatrix* matrix = info.manager->GetGDMLMatrix(named->GetTitle());
1538  const char* cptr = ::strstr(matrix->GetName(), GEANT4_TAG_IGNORE);
1539  if ( nullptr != cptr ) // Check if the property should not be passed to Geant4
1540  continue;
1541 
1542  if ( nullptr == tab ) {
1543  tab = new G4MaterialPropertiesTable();
1544  g4->SetMaterialPropertiesTable(tab);
1545  }
1546 
1547  Geant4GeometryInfo::PropertyVector* v =
1548  (Geant4GeometryInfo::PropertyVector*)handleMaterialProperties(matrix);
1549  if ( !v ) { // Error!
1550  except("Geant4OpticalSurface","++ Failed to convert opt.surface %s. Property table %s is not defined!",
1551  optSurf->GetName(), named->GetTitle());
1552  }
1553  int idx = -1;
1554  try {
1555  idx = tab->GetPropertyIndex(named->GetName());
1556  }
1557  catch(const std::exception& e) {
1558  exc_str = e.what();
1559  }
1560  catch(...) {
1561  }
1562  if ( idx < 0 ) {
1563  printout(ERROR, "Geant4Converter",
1564  "++ UNKNOWN Geant4 Property: %-20s %s [IGNORED]",
1565  exc_str.c_str(), named->GetName());
1566  continue;
1567  }
1568  // We need to convert the property from TGeo units to Geant4 units
1569  auto conv = g4PropertyConversion(idx);
1570  std::vector<double> bins(v->bins), vals(v->values);
1571  for(std::size_t i=0, count=v->bins.size(); i<count; ++i)
1572  bins[i] *= conv.first, vals[i] *= conv.second;
1573  G4MaterialPropertyVector* vec = new G4MaterialPropertyVector(&bins[0], &vals[0], bins.size());
1574  tab->AddProperty(named->GetName(), vec);
1575 
1576  printout(lvl, "Geant4Converter",
1577  "++ Property: %-20s [%ld x %ld] --> %s",
1578  named->GetName(), matrix->GetRows(), matrix->GetCols(), named->GetTitle());
1579  for(std::size_t i=0, count=v->bins.size(); i<count; ++i)
1580  printout(lvl, named->GetName(),
1581  " Geant4: %8.3g [MeV] TGeo: %8.3g [GeV] Conversion: %8.3g",
1582  bins[i], v->bins[i], conv.first);
1583  }
1586 #if ROOT_VERSION_CODE >= ROOT_VERSION(6,31,1)
1587  TListIter itc(&optSurf->GetConstProperties());
1588  for(TObject* obj = itc.Next(); obj; obj = itc.Next()) {
1589  std::string exc_str;
1590  TNamed* named = (TNamed*)obj;
1591  const char* cptr = ::strstr(named->GetName(), GEANT4_TAG_IGNORE);
1592  if ( nullptr != cptr ) {
1593  printout(INFO, name, "++ Ignore CONST property %s [%s].",
1594  named->GetName(), named->GetTitle());
1595  continue;
1596  }
1597  cptr = ::strstr(named->GetTitle(), GEANT4_TAG_IGNORE);
1598  if ( nullptr != cptr ) {
1599  printout(INFO, name,"++ Ignore CONST property %s [%s].",
1600  named->GetName(), named->GetTitle());
1601  continue;
1602  }
1603  Bool_t err = kFALSE;
1604  Double_t value = info.manager->GetProperty(named->GetTitle(),&err);
1605  if ( err != kFALSE ) {
1606  except(name,
1607  "++ FAILED to create G4 material %s [Cannot convert const property: %s]",
1608  optSurf->GetName(), named->GetName());
1609  }
1610  if ( nullptr == tab ) {
1611  tab = new G4MaterialPropertiesTable();
1612  g4->SetMaterialPropertiesTable(tab);
1613  }
1614  int idx = -1;
1615  try {
1616  idx = tab->GetConstPropertyIndex(named->GetName());
1617  }
1618  catch(const std::exception& e) {
1619  exc_str = e.what();
1620  }
1621  catch(...) {
1622  }
1623  if ( idx < 0 ) {
1624  printout(ERROR, name,
1625  "++ UNKNOWN Geant4 CONST Property: %-20s %s [IGNORED]",
1626  exc_str.c_str(), named->GetName());
1627  continue;
1628  }
1629  // We need to convert the property from TGeo units to Geant4 units
1630  double conv = g4ConstPropertyConversion(idx);
1631  printout(lvl, name, "++ CONST Property: %-20s %g * %g --> %g ",
1632  named->GetName(), value, conv, value * conv);
1633  tab->AddConstProperty(named->GetName(), value * conv);
1634  }
1635 #endif // ROOT_VERSION >= 6.31.1
1636  info.g4OpticalSurfaces[optSurf] = g4;
1637  }
1638  return g4;
1639 }
1640 
1642 void* Geant4Converter::handleSkinSurface(TObject* surface) const {
1643  TGeoSkinSurface* surf = (TGeoSkinSurface*)surface;
1644  Geant4GeometryInfo& info = data();
1645  G4LogicalSkinSurface* g4 = info.g4SkinSurfaces[surf];
1646  if ( !g4 ) {
1647  G4OpticalSurface* optSurf = info.g4OpticalSurfaces[OpticalSurface(surf->GetSurface())];
1648  G4LogicalVolume* v = info.g4Volumes[surf->GetVolume()];
1649  std::string name = make_NCName(surf->GetName());
1650  g4 = new G4LogicalSkinSurface(name, v, optSurf);
1651  printout(debugSurfaces ? ALWAYS : DEBUG, "Geant4Converter",
1652  "++ Created SkinSurface: %-18s optical:%s",
1653  surf->GetName(), surf->GetSurface()->GetName());
1654  info.g4SkinSurfaces[surf] = g4;
1655  }
1656  return g4;
1657 }
1658 
1660 void* Geant4Converter::handleBorderSurface(TObject* surface) const {
1661  TGeoBorderSurface* surf = (TGeoBorderSurface*)surface;
1662  Geant4GeometryInfo& info = data();
1663  G4LogicalBorderSurface* g4 = info.g4BorderSurfaces[surf];
1664  if ( !g4 ) {
1665  G4OpticalSurface* optSurf = info.g4OpticalSurfaces[OpticalSurface(surf->GetSurface())];
1666  G4VPhysicalVolume* n1 = info.g4Placements[surf->GetNode1()];
1667  G4VPhysicalVolume* n2 = info.g4Placements[surf->GetNode2()];
1668  std::string name = make_NCName(surf->GetName());
1669  g4 = new G4LogicalBorderSurface(name, n1, n2, optSurf);
1670  printout(debugSurfaces ? ALWAYS : DEBUG, "Geant4Converter",
1671  "++ Created BorderSurface: %-18s optical:%s",
1672  surf->GetName(), surf->GetSurface()->GetName());
1673  info.g4BorderSurfaces[surf] = g4;
1674  }
1675  return g4;
1676 }
1677 
1679 void Geant4Converter::printSensitive(SensitiveDetector sens_det, const std::set<const TGeoVolume*>& /* volumes */) const {
1680  Geant4GeometryInfo& info = data();
1681  std::set<const TGeoVolume*>& volset = info.sensitives[sens_det];
1682  SensitiveDetector sd = sens_det;
1683  std::stringstream str;
1684 
1685  printout(INFO, "Geant4Converter", "++ SensitiveDetector: %-18s %-20s Hits:%-16s", sd.name(), ("[" + sd.type() + "]").c_str(),
1686  sd.hitsCollection().c_str());
1687  str << " | " << "Cutoff:" << std::setw(6) << std::left
1688  << sd.energyCutoff() << std::setw(5) << std::right << volset.size()
1689  << " volumes ";
1690  if (sd.region().isValid())
1691  str << " Region:" << std::setw(12) << std::left << sd.region().name();
1692  if (sd.limits().isValid())
1693  str << " Limits:" << std::setw(12) << std::left << sd.limits().name();
1694  str << ".";
1695  printout(INFO, "Geant4Converter", str.str().c_str());
1696 
1697  for (const auto i : volset ) {
1698  std::map<Volume, G4LogicalVolume*>::iterator v = info.g4Volumes.find(i);
1699  if ( v != info.g4Volumes.end() ) {
1700  G4LogicalVolume* vol = (*v).second;
1701  str.str("");
1702  str << " | " << "Volume:" << std::setw(24) << std::left << vol->GetName() << " "
1703  << vol->GetNoDaughters() << " daughters.";
1704  printout(INFO, "Geant4Converter", str.str().c_str());
1705  }
1706  }
1707 }
1708 
1709 std::string printSolid(G4VSolid* sol) {
1710  std::stringstream str;
1711  if (typeid(*sol) == typeid(G4Box)) {
1712  const G4Box* b = (G4Box*) sol;
1713  str << "++ Box: x=" << b->GetXHalfLength() << " y=" << b->GetYHalfLength() << " z=" << b->GetZHalfLength();
1714  }
1715  else if (typeid(*sol) == typeid(G4Tubs)) {
1716  const G4Tubs* t = (const G4Tubs*) sol;
1717  str << " Tubs: Ri=" << t->GetInnerRadius() << " Ra=" << t->GetOuterRadius() << " z/2=" << t->GetZHalfLength() << " Phi="
1718  << t->GetStartPhiAngle() << "..." << t->GetDeltaPhiAngle();
1719  }
1720  return str.str();
1721 }
1722 
1724 void* Geant4Converter::printPlacement(const std::string& name, const TGeoNode* node) const {
1725  Geant4GeometryInfo& info = data();
1726  G4VPhysicalVolume* g4 = info.g4Placements[node];
1727  G4LogicalVolume* vol = info.g4Volumes[node->GetVolume()];
1728  G4LogicalVolume* mot = info.g4Volumes[node->GetMotherVolume()];
1729  G4VSolid* sol = vol->GetSolid();
1730  G4ThreeVector tr = g4->GetObjectTranslation();
1731  G4VSensitiveDetector* sd = vol->GetSensitiveDetector();
1732  if ( !sd ) {
1733  return g4;
1734  }
1735  std::stringstream str;
1736  str << "G4Cnv::placement: + " << name << " No:" << node->GetNumber() << " Vol:" << vol->GetName() << " Solid:"
1737  << sol->GetName();
1738  printout(outputLevel, "G4Placement", str.str().c_str());
1739  str.str("");
1740  str << " |" << " Loc: x=" << tr.x() << " y=" << tr.y() << " z=" << tr.z();
1741  printout(outputLevel, "G4Placement", str.str().c_str());
1742  printout(outputLevel, "G4Placement", printSolid(sol).c_str());
1743  str.str("");
1744  str << " |" << " Ndau:" << vol->GetNoDaughters()
1745  << " physvols." << " Mat:" << vol->GetMaterial()->GetName()
1746  << " Mother:" << (char*) (mot ? mot->GetName().c_str() : "---");
1747  printout(outputLevel, "G4Placement", str.str().c_str());
1748  str.str("");
1749  str << " |" << " SD:" << sd->GetName();
1750  printout(outputLevel, "G4Placement", str.str().c_str());
1751  return g4;
1752 }
1753 
1755 Geant4Converter& Geant4Converter::create(DetElement top) {
1756  typedef std::map<const TGeoNode*, std::vector<TGeoNode*> > _DAU;
1757  TTimeStamp start;
1758  _DAU daughters;
1759  Geant4GeometryInfo& geo = this->init();
1760  World wrld = top.world();
1761 
1762  m_data->clear();
1763  m_set_data->clear();
1764  m_daughters = &daughters;
1765  geo.manager = &wrld.detectorDescription().manager();
1766  this->collect(top, geo);
1767  this->checkOverlaps = false;
1768  // We do not have to handle defines etc.
1769  // All positions and the like are not really named.
1770  // Hence, start creating the G4 objects for materials, solids and log volumes.
1771  handleArray(this, geo.manager->GetListOfGDMLMatrices(), &Geant4Converter::handleMaterialProperties);
1772  handleArray(this, geo.manager->GetListOfOpticalSurfaces(), &Geant4Converter::handleOpticalSurface);
1773 
1774  handle(this, geo.volumes, &Geant4Converter::collectVolume);
1775  handle(this, geo.solids, &Geant4Converter::handleSolid);
1776  printout(outputLevel, "Geant4Converter", "++ Handled %ld solids.", geo.solids.size());
1777  handleRefs(this, geo.vis, &Geant4Converter::handleVis);
1778  printout(outputLevel, "Geant4Converter", "++ Handled %ld visualization attributes.", geo.vis.size());
1779  handleMap(this, geo.limits, &Geant4Converter::handleLimitSet);
1780  printout(outputLevel, "Geant4Converter", "++ Handled %ld limit sets.", geo.limits.size());
1781  handleMap(this, geo.regions, &Geant4Converter::handleRegion);
1782  printout(outputLevel, "Geant4Converter", "++ Handled %ld regions.", geo.regions.size());
1783  handle(this, geo.volumes, &Geant4Converter::handleVolume);
1784  printout(outputLevel, "Geant4Converter", "++ Handled %ld volumes.", geo.volumes.size());
1785  handleRMap(this, *m_data, &Geant4Converter::handleAssembly);
1786  // Now place all this stuff appropriately
1787  //handleRMap(this, *m_data, &Geant4Converter::handlePlacement);
1788  std::map<int, std::vector<const TGeoNode*> >::const_reverse_iterator i = m_data->rbegin();
1789  for ( ; i != m_data->rend(); ++i ) {
1790  for ( const TGeoNode* node : i->second ) {
1791  this->handlePlacement(node->GetName(), node);
1792  }
1793  }
1795  handleArray(this, geo.manager->GetListOfSkinSurfaces(), &Geant4Converter::handleSkinSurface);
1796  handleArray(this, geo.manager->GetListOfBorderSurfaces(), &Geant4Converter::handleBorderSurface);
1797  //==================== Fields
1798  handleProperties(m_detDesc.properties());
1799  if ( printSensitives ) {
1800  handleMap(this, geo.sensitives, &Geant4Converter::printSensitive);
1801  }
1802  if ( printPlacements ) {
1803  handleRMap(this, *m_data, &Geant4Converter::printPlacement);
1804  }
1805 
1806  m_daughters = nullptr;
1807  geo.setWorld(top.placement().ptr());
1808  geo.valid = true;
1809  TTimeStamp stop;
1810  printout(INFO, "Geant4Converter",
1811  "+++ Successfully converted geometry to Geant4. [%7.3f seconds]",
1812  stop.AsDouble()-start.AsDouble() );
1813  return *this;
1814 }
dd4hep::World
Handle class to hold the information of the top DetElement object 'world'.
Definition: World.h:30
dd4hep::detail::GeoHandler::m_daughters
std::map< const TGeoNode *, std::vector< TGeoNode * > > * m_daughters
Definition: GeoHandler.h:97
Geant4Field.h
dd4hep::Detector::manager
virtual TGeoManager & manager() const =0
Access the geometry manager of this instance.
dd4hep::sim::Geant4Converter::debugRegions
bool debugRegions
Property: Flag to debug regions during conversion mechanism.
Definition: Geant4Converter.h:47
dd4hep::sim::Geant4GeometryInfo::sensitives
std::map< SensitiveDetector, std::set< const TGeoVolume * > > sensitives
Definition: Geant4GeometryInfo.h:135
dd4hep::sim::convertShape< TGeoTrd2 >
G4VSolid * convertShape< TGeoTrd2 >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:132
dd4hep::sim::convertShape< TGeoPgon >
G4VSolid * convertShape< TGeoPgon >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:181
dd4hep::sim::Geant4Converter::debugMaterials
bool debugMaterials
Property: Flag to debug materials during conversion mechanism.
Definition: Geant4Converter.h:35
dd4hep::sim::Geant4UserLimits::minRange
Handler minRange
Handler map for MinRange limit.
Definition: Geant4UserLimits.h:71
dd4hep::Volume::Z_axis
@ Z_axis
Definition: Volumes.h:387
dd4hep::sim::Geant4Mapping::init
Geant4GeometryInfo & init()
Create and attach new data block. Delete old data block if present.
Definition: Geant4Mapping.cpp:50
dd4hep::detail::GeoHandlerTypes::GeometryInfo::solids
std::vector< TGeoShape * > solids
Definition: GeoHandler.h:62
dd4hep::sim::Geant4Converter::handleLimitSet
virtual void * handleLimitSet(LimitSet limitset, const std::set< const TGeoVolume * > &volumes) const
Convert the geometry type LimitSet into the corresponding Geant4 object(s).
Definition: Geant4Converter.cpp:1277
dd4hep::sim::convertShape< TGeoTrd1 >
G4VSolid * convertShape< TGeoTrd1 >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:124
dd4hep::LimitSet::cuts
const std::set< Limit > & cuts() const
Accessor to limits container.
Definition: Objects.cpp:508
dd4hep::Atom
Handle class describing an element in the periodic table.
Definition: Objects.h:241
dd4hep::sim::Geant4Converter
Geometry converter from dd4hep to Geant 4.
Definition: Geant4Converter.h:32
dd4hep::sim::Geant4Converter::Geant4Converter
Geant4Converter(const Detector &description)
Initializing Constructor.
Definition: Geant4Converter.cpp:290
dd4hep::Region::wasThresholdSet
bool wasThresholdSet() const
Access was_threshold_set flag.
Definition: Objects.cpp:565
Volumes.h
dd4hep::Volume::NO_SMARTLESS_OPTIMIZATION
@ NO_SMARTLESS_OPTIMIZATION
Definition: Volumes.h:392
dd4hep::Volume::hasProperties
bool hasProperties() const
Check for existence of properties.
Definition: Volumes.cpp:1327
dd4hep::World::detectorDescription
Detector & detectorDescription() const
Access the detector description tree.
Definition: World.cpp:19
dd4hep::sim::convertShape< TGeoPcon >
G4VSolid * convertShape< TGeoPcon >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:193
v
View * v
Definition: MultiView.cpp:28
dd4hep::sim::convertShape< TGeoHype >
G4VSolid * convertShape< TGeoHype >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:140
dd4hep::SensitiveDetector
Handle class to hold the information of a sensitive detector.
Definition: DetElement.h:43
dd4hep::sim::Geant4GeometryInfo::g4Regions
std::map< Region, G4Region * > g4Regions
Definition: Geant4GeometryInfo.h:131
dd4hep::sim::Geant4Converter::debugLimits
bool debugLimits
Property: Flag to debug LimitSets during conversion mechanism.
Definition: Geant4Converter.h:49
Detector.h
dd4hep::sim::Geant4Converter::debugElements
bool debugElements
Property: Flag to debug elements during conversion mechanism.
Definition: Geant4Converter.h:37
dd4hep::sim::convertShape< TGeoBBox >
G4VSolid * convertShape< TGeoBBox >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:75
dd4hep::info
std::size_t info(const std::string &src, const std::string &msg)
Definition: RootDictionary.h:65
dd4hep::Detector::Properties
std::map< std::string, PropertyValues > Properties
Definition: Detector.h:94
dd4hep::exception
void exception(const std::string &src, const std::string &msg)
Definition: RootDictionary.h:69
dd4hep::sim::Geant4Mapping::data
Geant4GeometryInfo & data() const
Access to the data pointer.
Definition: Geant4Mapping.h:65
dd4hep::sim::convertShape< TGeoTessellated >
G4VSolid * convertShape< TGeoTessellated >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:253
dd4hep::PlacedVolume
Handle class holding a placed volume (also called physical volume)
Definition: Volumes.h:164
dd4hep::VisAttr
Handle class describing visualization attributes.
Definition: Objects.h:331
dd4hep::Region::storeSecondaries
bool storeSecondaries() const
Access secondaries flag.
Definition: Objects.cpp:557
dd4hep::sim::Geant4PlacementParameterisation
Class to dump the records of the intrinsic Geant4 event model.
Definition: Geant4PlacementParameterisation.h:39
dd4hep::DetElement::placement
PlacedVolume placement() const
Access to the physical volume of this detector element.
Definition: DetElement.cpp:321
dd4hep::sim::Geant4AssemblyVolume
Hack! Wrapper around G4AssemblyVolume to access protected members.
Definition: Geant4AssemblyVolume.h:41
CM_2_MM
#define CM_2_MM
Definition: ParticleActors.cpp:37
dd4hep::LimitSet::limits
const std::set< Limit > & limits() const
Accessor to limits container.
Definition: Objects.cpp:496
dd4hep::sim::Geant4Converter::handleSkinSurface
void * handleSkinSurface(TObject *surface) const
Convert the skin surface to Geant4.
Definition: Geant4Converter.cpp:1642
dd4hep::sim::convertShape< TGeoEltu >
G4VSolid * convertShape< TGeoEltu >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:103
Geant4ShapeConverter.h
delta
const Delta * delta
Definition: AlignmentsCalculator.cpp:67
printSolid
std::string printSolid(G4VSolid *sol)
Definition: Geant4Converter.cpp:1709
dd4hep::sim::Geant4AssemblyVolume::placeVolume
long placeVolume(const TGeoNode *n, G4LogicalVolume *pPlacedVolume, G4Transform3D &transformation)
Place logical daughter volume into the assembly.
Definition: Geant4AssemblyVolume.cpp:44
dd4hep::sim::Geant4Converter::outputLevel
PrintLevel outputLevel
Property: Output level for debug printing.
Definition: Geant4Converter.h:61
dd4hep::sim::Geant4Converter::debugSurfaces
bool debugSurfaces
Property: Flag to debug surfaces during conversion mechanism.
Definition: Geant4Converter.h:51
dd4hep::Detector::PropertyValues
std::map< std::string, std::string > PropertyValues
Definition: Detector.h:93
dd4hep::Handle::isValid
bool isValid() const
Check the validity of the object held by the handle.
Definition: Handle.h:126
DetectorInterna.h
dd4hep::_toString
std::string _toString(bool value)
String conversions: boolean value to string.
Definition: Handle.cpp:332
dd4hep::sim::Geant4Converter::debugShapes
bool debugShapes
Property: Flag to debug shapes during conversion mechanism.
Definition: Geant4Converter.h:39
dd4hep::sim::Geant4AssemblyVolume::Chain
std::vector< const TGeoNode * > Chain
Definition: Geant4AssemblyVolume.h:45
dd4hep::Solid_type< TGeoShape >
dd4hep::Detector::worldVolume
virtual Volume worldVolume() const =0
Return handle to the world volume containing everything.
dd4hep::detail::GeoHandlerTypes::GeometryInfo::vis
std::set< VisAttr > vis
Definition: GeoHandler.h:66
dd4hep::sim::Geant4GeometryInfo::PropertyVector::bins
std::vector< double > bins
Definition: Geant4GeometryInfo.h:121
dd4hep::Handle::name
const char * name() const
Access the object name (or "" if not supported by the object)
Geant4UserLimits.h
dd4hep::sim::convertShape< TGeoXtru >
G4VSolid * convertShape< TGeoXtru >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:164
dd4hep::Region::limits
std::vector< std::string > & limits() const
Access references to user limits.
Definition: Objects.cpp:542
dd4hep::sim::Geant4GeometryInfo::manager
TGeoManager * manager
Definition: Geant4GeometryInfo.h:108
dd4hep::sim::convertShape< TGeoCone >
G4VSolid * convertShape< TGeoCone >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:205
epsilon
const double epsilon
Definition: test_cellid_position_converter.cpp:41
dd4hep::sim::Geant4GeometryInfo::setWorld
void setWorld(const TGeoNode *node)
Set the world volume.
Definition: Geant4GeometryInfo.cpp:44
dd4hep::VisAttr::alpha
float alpha() const
Get alpha value.
Definition: Objects.cpp:394
dd4hep::sim::Geant4UserLimits::minEKine
Handler minEKine
Handler map for MinEKine limit.
Definition: Geant4UserLimits.h:69
dd4hep::sim::Geant4UserLimits::maxTrackLength
Handler maxTrackLength
Handler map for MaxTrackLength limit.
Definition: Geant4UserLimits.h:65
G4UserLimits
Class of the Geant4 toolkit. See http://www-geant4.kek.jp/Reference.
Definition: Geant4Classes.h:23
dd4hep::detail::GeoHandler::m_propagateRegions
bool m_propagateRegions
Definition: GeoHandler.h:90
dd4hep::VisAttr::lineStyle
int lineStyle() const
Get line style.
Definition: Objects.cpp:374
dd4hep::Material
Handle class describing a material.
Definition: Objects.h:271
dd4hep::sim::Geant4AssemblyVolume::imprint
void imprint(const Geant4Converter &cnv, const TGeoNode *n, Chain chain, Geant4AssemblyVolume *pAssembly, G4LogicalVolume *pMotherLV, G4Transform3D &transformation, G4bool surfCheck)
Expand all daughter placements and expand the contained assemblies to imprints.
Definition: Geant4AssemblyVolume.cpp:68
dd4hep::sim::Geant4Converter::debugPlacements
bool debugPlacements
Property: Flag to debug placements during conversion mechanism.
Definition: Geant4Converter.h:43
dd4hep::VisAttr::showDaughters
bool showDaughters() const
Get Flag to show/hide daughter elements.
Definition: Objects.cpp:354
dd4hep::Region::threshold
double threshold() const
Access production threshold.
Definition: Objects.cpp:552
dd4hep::detail::GeoHandler::m_set_data
std::map< int, std::set< const TGeoNode * > > * m_set_data
redundant container with std::set (for lookup purpose)
Definition: GeoHandler.h:95
dd4hep::sim::Geant4GeometryInfo::PropertyVector::title
std::string title
Definition: Geant4GeometryInfo.h:123
dd4hep::sim::Geant4Converter::create
Geant4Converter & create(DetElement top)
Create geometry conversion.
Definition: Geant4Converter.cpp:1755
dd4hep::Volume::VETO_SIMU
@ VETO_SIMU
Definition: Volumes.h:376
Geant4AssemblyVolume.h
dd4hep::sim::convertShape< TwistedTubeObject >
G4VSolid * convertShape< TwistedTubeObject >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:108
dd4hep::DetElement
Handle class describing a detector element.
Definition: DetElement.h:187
dd4hep::sim::Geant4Converter::handleBorderSurface
void * handleBorderSurface(TObject *surface) const
Convert the border surface to Geant4.
Definition: Geant4Converter.cpp:1660
dd4hep::Volume::REPLICATED
@ REPLICATED
Definition: Volumes.h:382
dd4hep::sim::Geant4UserLimits::maxTime
Handler maxTime
Handler map for MaxTime limit.
Definition: Geant4UserLimits.h:67
dd4hep::Volume
Handle class holding a placed volume (also called physical volume)
Definition: Volumes.h:371
dd4hep::Volume::Y_axis
@ Y_axis
Definition: Volumes.h:386
dd4hep::detail::GeoHandler
The base class for all dd4hep geometry crawlers.
Definition: GeoHandler.h:87
dd4hep::sim::Geant4GeometryInfo::limits
std::map< LimitSet, std::set< const TGeoVolume * > > limits
Definition: Geant4GeometryInfo.h:137
dd4hep::sim::Geant4Mapping
Geometry mapping from dd4hep to Geant 4.
Definition: Geant4Mapping.h:35
dd4hep::sim::Geant4Converter::checkOverlaps
bool checkOverlaps
Property: Check geometrical overlaps for volume placements and G4 imprints.
Definition: Geant4Converter.h:59
mix
#define mix(a, b, c)
Definition: Geant4EventSeed.h:103
dd4hep::sim::Geant4Converter::~Geant4Converter
virtual ~Geant4Converter()
Standard destructor.
Definition: Geant4Converter.cpp:305
dd4hep::sim::Geant4GeometryInfo::PropertyVector::values
std::vector< double > values
Definition: Geant4GeometryInfo.h:122
dd4hep::sim::g4Transform
void g4Transform(const double *translation, const double *rotation, G4Transform3D &transform)
These conversions automatically apply the conversion from CM to MM!
Definition: Geant4Helpers.cpp:91
G4VSensitiveDetector
Class of the Geant4 toolkit. See http://www-geant4.kek.jp/Reference.
Definition: Geant4Classes.h:59
dd4hep::LimitSet
Handle class describing a set of limits as they are used for simulation.
Definition: Objects.h:432
dd4hep::sim::Geant4GeometryInfo::PropertyVector::name
std::string name
Definition: Geant4GeometryInfo.h:123
dd4hep::SensitiveDetector::hitsCollection
const std::string & hitsCollection() const
Access the hits collection name.
Definition: DetElement.cpp:447
dd4hep::sim::Geant4Converter::handleMaterial
virtual void * handleMaterial(const std::string &name, Material medium) const
Convert the geometry type material into the corresponding Geant4 object(s).
Definition: Geant4Converter.cpp:351
ShapesInterna.h
dd4hep::Volume::limitSet
LimitSet limitSet() const
Access to the limit set.
Definition: Volumes.cpp:1304
dd4hep::VisAttr::DASHED
@ DASHED
Definition: Objects.h:334
DetectorTools.h
TO_G4_TYPE
#define TO_G4_TYPE(x)
dd4hep::Volume::region
Region region() const
Access to the handle to the region structure.
Definition: Volumes.cpp:1285
dd4hep::sim::Geant4UserLimits::Handler::particleLimits
std::map< const G4ParticleDefinition *, double > particleLimits
Handler particle ids for the limit (pdgID)
Definition: Geant4UserLimits.h:51
dd4hep::sim::convertShape< TGeoParaboloid >
G4VSolid * convertShape< TGeoParaboloid >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:219
Geant4PlacementParameterisation.h
TNamed
Class of the ROOT toolkit. See http://root.cern.ch/root/htmldoc/ClassIndex.html.
Definition: ROOTClasses.h:37
dd4hep::Volume::testFlagBit
bool testFlagBit(unsigned int bit) const
Test the user flag bit.
Definition: Volumes.cpp:709
Plugins.h
dd4hep::sim::Geant4Converter::handleProperties
void handleProperties(Detector::Properties &prp) const
Handle the geant 4 specific properties.
Definition: Geant4Converter.cpp:1345
dd4hep::LimitSet::Set
std::set< Limit > Set
Iterator definitions.
Definition: Objects.h:435
dd4hep::Region
Handle class describing a region as used in simulation.
Definition: Objects.h:469
dd4hep::sim::convertShape< TGeoPara >
G4VSolid * convertShape< TGeoPara >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:156
dd4hep::sim::Geant4Converter::printSensitive
virtual void printSensitive(SensitiveDetector sens_det, const std::set< const TGeoVolume * > &volumes) const
Print the geometry type SensitiveDetector.
Definition: Geant4Converter.cpp:1679
dd4hep::VisAttr::rgb
bool rgb(float &red, float &green, float &blue) const
Get RGB values of the color (if valid)
Definition: Objects.cpp:428
Shapes.h
dd4hep::sim::Geant4GeometryInfo::g4Isotopes
Geant4GeometryMaps::IsotopeMap g4Isotopes
Definition: Geant4GeometryInfo.h:110
dd4hep::detail::GeoHandler::m_data
std::map< int, std::vector< const TGeoNode * > > * m_data
actual container with std::vector (preserves order)
Definition: GeoHandler.h:93
dd4hep::sim::Geant4UserLimits::maxStepLength
Handler maxStepLength
Handler map for MaxStepLength limit.
Definition: Geant4UserLimits.h:63
Geant4Helpers.h
dd4hep::Volume::smartlessValue
unsigned char smartlessValue() const
access the smartless option for G4 voxelization
Definition: Volumes.cpp:736
dd4hep::sim::convertShape< TGeoTrap >
G4VSolid * convertShape< TGeoTrap >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:237
dd4hep::sim::convertShape< TGeoArb8 >
G4VSolid * convertShape< TGeoArb8 >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:147
TO_G4_FINISH
#define TO_G4_FINISH(x)
dd4hep::Detector::limitSet
virtual LimitSet limitSet(const std::string &name) const =0
Retrieve a limitset by its name from the detector description.
dd4hep::sim::Geant4UserLimits::Handler::defaultValue
double defaultValue
Default value (either from base class or value if Limit.particles='*')
Definition: Geant4UserLimits.h:49
dd4hep::sim::Geant4Converter::handleOpticalSurface
void * handleOpticalSurface(TObject *surface) const
Convert the optical surface to Geant4.
Definition: Geant4Converter.cpp:1509
dd4hep::sim::convertShape< TGeoShapeAssembly >
G4VSolid * convertShape< TGeoShapeAssembly >(const TGeoShape *)
Definition: Geant4ShapeConverter.cpp:71
dd4hep::sim::convertShape< TGeoConeSeg >
G4VSolid * convertShape< TGeoConeSeg >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:211
dd4hep::sim::Geant4Converter::handleAssembly
virtual void * handleAssembly(const std::string &name, const TGeoNode *node) const
Dump volume placement in GDML format to output stream.
Definition: Geant4Converter.cpp:917
dd4hep::sim::Geant4Converter::handleVis
virtual void * handleVis(const std::string &name, VisAttr vis) const
Convert the geometry visualisation attributes to the corresponding Geant4 object(s).
Definition: Geant4Converter.cpp:1319
dd4hep::Region::cut
double cut() const
Access cut value.
Definition: Objects.cpp:547
dd4hep::sim::Geant4Converter::handleVolume
virtual void * handleVolume(const std::string &name, const TGeoVolume *volume) const
Convert the geometry type logical volume into the corresponding Geant4 object(s).
Definition: Geant4Converter.cpp:783
dd4hep::SensitiveDetector::limits
LimitSet limits() const
Access to the limit set of the sensitive detector (not mandatory).
Definition: DetElement.cpp:493
dd4hep::sim::convertShape< TGeoCtub >
G4VSolid * convertShape< TGeoCtub >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:91
dd4hep::sim::convertShape< TGeoTubeSeg >
G4VSolid * convertShape< TGeoTubeSeg >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:85
dd4hep::sim::Geant4GeometryInfo::g4Limits
std::map< LimitSet, G4UserLimits * > g4Limits
Definition: Geant4GeometryInfo.h:133
dd4hep::sim::Geant4Converter::debugVolumes
bool debugVolumes
Property: Flag to debug volumes during conversion mechanism.
Definition: Geant4Converter.h:41
dd4hep::sim::Geant4Converter::handleSolid
virtual void * handleSolid(const std::string &name, const TGeoShape *volume) const
Convert the geometry type solid into the corresponding Geant4 object(s).
Definition: Geant4Converter.cpp:638
dd4hep::SensitiveDetector::type
std::string type() const
Access the type of the sensitive detector.
Definition: DetElement.cpp:409
dd4hep::sim::Geant4Converter::collectVolume
virtual void * collectVolume(const std::string &name, const TGeoVolume *volume) const
Dump logical volume in GDML format to output stream.
Definition: Geant4Converter.cpp:897
dd4hep::sim::Geant4Mapping::m_detDesc
const Detector & m_detDesc
Definition: Geant4Mapping.h:37
dd4hep::SensitiveDetector::region
Region region() const
Access to the region setting of the sensitive detector (not mandatory)
Definition: DetElement.cpp:482
dd4hep::sim::Geant4Converter::printSensitives
bool printSensitives
Property: Flag to dump all sensitives after the conversion procedure.
Definition: Geant4Converter.h:56
dd4hep::sim::Geant4GeometryInfo::g4Solids
Geant4GeometryMaps::SolidMap g4Solids
Definition: Geant4GeometryInfo.h:113
dd4hep::sim::Geant4GeometryInfo::valid
bool valid
Definition: Geant4GeometryInfo.h:141
dd4hep::sim
Namespace for the Geant4 based simulation part of the AIDA detector description toolkit.
Definition: EDM4hepFileReader.cpp:46
dd4hep::sim::convertShape< TGeoTorus >
G4VSolid * convertShape< TGeoTorus >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:231
dd4hep::VisAttr::visible
bool visible() const
Get visibility flag.
Definition: Objects.cpp:364
dd4hep::sim::Geant4Converter::handlePlacement
virtual void * handlePlacement(const std::string &name, const TGeoNode *node) const
Convert the geometry type volume placement into the corresponding Geant4 object(s).
Definition: Geant4Converter.cpp:990
dd4hep::sim::Geant4Converter::handleIsotope
virtual void * handleIsotope(const std::string &name, const TGeoIsotope *iso) const
Handle the conversion of isotopes.
Definition: Geant4Converter.cpp:309
dd4hep::sim::Geant4GeometryInfo
Concreate class holding the relation information between geant4 objects and dd4hep objects.
Definition: Geant4GeometryInfo.h:91
dd4hep::VisAttr::SOLID
@ SOLID
Definition: Objects.h:334
dd4hep::Handle::ptr
T * ptr() const
Access to the held object.
Definition: Handle.h:151
ObjectsInterna.h
dd4hep::Volume::type
const char * type() const
Access the object type from the class information.
Definition: Volumes.cpp:663
PropertyTable.h
dd4hep::Region::useDefaultCut
bool useDefaultCut() const
Access use_default_cut flag.
Definition: Objects.cpp:561
dd4hep::SensitiveDetector::energyCutoff
double energyCutoff() const
Access energy cut off.
Definition: DetElement.cpp:436
TObject
Class of the ROOT toolkit. See http://root.cern.ch/root/htmldoc/ClassIndex.html.
Definition: ROOTClasses.h:41
dd4hep::sim::Geant4Converter::handleMaterialProperties
virtual void * handleMaterialProperties(TObject *matrix) const
Convert the geometry type material into the corresponding Geant4 object(s).
Definition: Geant4Converter.cpp:1380
dd4hep
Namespace for the AIDA detector description toolkit.
Definition: AlignmentsCalib.h:28
dd4hep::sim::Geant4Converter::debugReflections
bool debugReflections
Property: Flag to debug reflections during conversion mechanism.
Definition: Geant4Converter.h:45
dd4hep::VisAttr::WIREFRAME
@ WIREFRAME
Definition: Objects.h:334
dd4hep::sim::Geant4Converter::handleRegion
virtual void * handleRegion(Region region, const std::set< const TGeoVolume * > &volumes) const
Convert the geometry type region into the corresponding Geant4 object(s).
Definition: Geant4Converter.cpp:1199
det
DetElement::Object * det
Definition: AlignmentsCalculator.cpp:66
dd4hep::Solid_type::type
const char * type() const
Access to shape type (The TClass name of the ROOT implementation)
Definition: Shapes.cpp:82
dd4hep::PlacedVolume::data
Object * data() const
Check if placement is properly instrumented.
Definition: Volumes.cpp:447
dd4hep::Detector
The main interface to the dd4hep detector description package.
Definition: Detector.h:89
dd4hep::sim::Geant4GeometryInfo::regions
std::map< Region, std::set< const TGeoVolume * > > regions
Definition: Geant4GeometryInfo.h:136
dd4hep::Volume::getProperty
std::string getProperty(const std::string &nam, const std::string &default_val="") const
Access property value. Returns default_value if the property is not present.
Definition: Volumes.cpp:1348
dd4hep::sim::Geant4AssemblyVolume::placeAssembly
long placeAssembly(const TGeoNode *n, Geant4AssemblyVolume *pPlacedVolume, G4Transform3D &transformation)
Place daughter assembly into the assembly
Definition: Geant4AssemblyVolume.cpp:56
TO_G4_MODEL
#define TO_G4_MODEL(x)
dd4hep::detail::tools::copy
void copy(Alignment from, Alignment to)
Copy alignment object from source object.
Definition: AlignmentTools.cpp:43
dd4hep::sim::Geant4GeometryInfo::g4Elements
Geant4GeometryMaps::ElementMap g4Elements
Definition: Geant4GeometryInfo.h:111
dd4hep::sim::Geant4UserLimits
Helper to dump Geant4 volume hierarchy.
Definition: Geant4UserLimits.h:38
dd4hep::Volume::visAttributes
VisAttr visAttributes() const
Access the visualisation attributes.
Definition: Volumes.cpp:1239
DD4hepUnits.h
dd4hep::sim::Geant4Converter::printPlacements
bool printPlacements
Property: Flag to dump all placements after the conversion procedure.
Definition: Geant4Converter.h:54
dd4hep::detail::GeoHandlerTypes::GeometryInfo::volumes
std::vector< Volume > volumes
Definition: GeoHandler.h:65
dd4hep::DetElement::world
DetElement world() const
Access to the world object. Only possible once the geometry is closed.
Definition: DetElement.cpp:245
Printout.h
dd4hep::sim::Geant4GeometryInfo::PropertyVector
Definition: Geant4GeometryInfo.h:120
dd4hep::Volume::X_axis
@ X_axis
Definition: Volumes.h:385
dd4hep::sim::convertShape< TGeoSphere >
G4VSolid * convertShape< TGeoSphere >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:224
dd4hep::sim::Geant4Converter::handleElement
virtual void * handleElement(const std::string &name, Atom element) const
Convert the geometry type element into the corresponding Geant4 object(s).
Definition: Geant4Converter.cpp:323
Geant4Converter.h
dd4hep::sim::convertShape< TGeoTube >
G4VSolid * convertShape< TGeoTube >(const TGeoShape *shape)
Definition: Geant4ShapeConverter.cpp:80
dd4hep::OpticalSurface
Class to support the handling of optical surfaces.
Definition: OpticalSurfaces.h:42
dd4hep::Volume::sensitiveDetector
Handle< NamedObject > sensitiveDetector() const
Access to the handle to the sensitive detector.
Definition: Volumes.cpp:1316
dd4hep::Detector::properties
virtual Properties & properties() const =0
Access to properties map.
dd4hep::sim::Geant4Converter::printPlacement
virtual void * printPlacement(const std::string &name, const TGeoNode *node) const
Print Geant4 placement.
Definition: Geant4Converter.cpp:1724
dd4hep::detail::GeoHandler::collect
GeoHandler & collect(DetElement top)
Collect geometry information from traversal.
Definition: GeoHandler.cpp:99
dd4hep::sim::Geant4UserLimits::Handler
Helper class to one limit type.
Definition: Geant4UserLimits.h:46
Generated on Mon Jun 8 2026 15:52:49 for DD4hep by   doxygen 1.8.18