Belle II Software  release-05-01-25
GeoECLCreator.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2019 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributor: Alexei Sibidanov e-mail:sibid@uvic.ca *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 #include "G4Transform3D.hh"
12 #include "G4PVPlacement.hh"
13 #include "G4SDManager.hh"
14 #include "G4UserLimits.hh"
15 #include <G4VisAttributes.hh>
16 #include <G4Box.hh>
17 
18 #include <ecl/geometry/GeoECLCreator.h>
19 #include <ecl/geometry/shapes.h>
20 #include <ecl/simulation/SensitiveDetector.h>
21 #include <geometry/CreatorFactory.h>
22 #include <geometry/Materials.h>
23 #include <framework/gearbox/GearDir.h>
24 #include "ecl/dbobjects/ECLCrystalsShapeAndPosition.h"
25 #include <framework/database/IntervalOfValidity.h>
26 #include <framework/database/Database.h>
27 #include <framework/database/DBObjPtr.h>
28 #include <framework/logging/Logger.h>
29 
30 using namespace Belle2;
31 using namespace Belle2::geometry;
32 using namespace ECL;
33 
34 //-----------------------------------------------------------------
35 // Register the GeoCreator
36 //-----------------------------------------------------------------
37 
38 CreatorFactory<GeoECLCreator> GeoECLFactory("ECLCreator");
39 
40 //-----------------------------------------------------------------
41 // Implementation
42 //-----------------------------------------------------------------
43 
44 
45 GeoECLCreator::GeoECLCreator(): m_sap(0), m_overlap(0)
46 {
47  m_sensediode = NULL;
48  m_sensitive = new SensitiveDetector("ECLSensitiveDetector", (2 * 24)*CLHEP::eV, 10 * CLHEP::MeV);
49  G4SDManager::GetSDMpointer()->AddNewDetector(m_sensitive);
50  defineVisAttributes();
51 }
52 
53 
54 GeoECLCreator::~GeoECLCreator()
55 {
56  for (auto a : m_atts) delete a.second;
57 }
58 
59 void GeoECLCreator::createFromDB(const std::string&, G4LogicalVolume& topVolume, geometry::GeometryTypes)
60 {
61  m_sensediode = new SensitiveDiode("ECLSensitiveDiode");
62  G4SDManager::GetSDMpointer()->AddNewDetector(m_sensediode);
63 
64  DBObjPtr<ECLCrystalsShapeAndPosition> crystals;
65  if (!crystals.isValid()) B2FATAL("No crystal's data in the database.");
66  m_sap = &(*crystals);
67 
68  forward(topVolume);
69  barrel(topVolume);
70  backward(topVolume);
71 }
72 
73 void GeoECLCreator::createPayloads(const GearDir&, const IntervalOfValidity& iov)
74 {
75  ECLCrystalsShapeAndPosition crystals = loadCrystalsShapeAndPosition();
76  Database::Instance().storeData<ECLCrystalsShapeAndPosition>(&crystals, iov);
77 }
78 
79 void GeoECLCreator::create(const GearDir&, G4LogicalVolume& topVolume, geometry::GeometryTypes)
80 {
81  m_sensediode = new SensitiveDiode("ECLSensitiveDiode");
82  G4SDManager::GetSDMpointer()->AddNewDetector(m_sensediode);
83 
84  ECLCrystalsShapeAndPosition crystals = loadCrystalsShapeAndPosition();
85  m_sap = &crystals;
86 
87  forward(topVolume);
88  barrel(topVolume);
89  backward(topVolume);
90 }
91 
92 G4LogicalVolume* GeoECLCreator::wrapped_crystal(const shape_t* s, const std::string& endcap, double wrapthickness)
93 {
94  std::string prefix("sv_"); prefix += endcap; prefix += "_wrap";
95  G4Translate3D tw;
96  G4VSolid* wrapped_crystal = s->get_solid(prefix, wrapthickness, tw);
97  std::string name("lv_"); name += endcap + "_wrap_" + std::to_string(s->nshape);
98  G4Material* wrap = NULL;
99  if (wrapthickness < 0.170)
100  wrap = Materials::get("WRAP170");
101  else if (wrapthickness < 0.200)
102  wrap = Materials::get("WRAP200");
103  else
104  wrap = Materials::get("WRAP250");
105  G4LogicalVolume* wrapped_logical = new G4LogicalVolume(wrapped_crystal, wrap, name.c_str(), 0, 0, 0);
106  wrapped_logical->SetVisAttributes(att("wrap"));
107 
108  prefix = "sv_"; prefix += endcap; prefix += "_crystal";
109  G4Translate3D tc;
110  G4VSolid* crystal_solid = s->get_solid(prefix, 0, tc);
111  name = "lv_" + endcap + "_crystal_" + std::to_string(s->nshape);
112  G4LogicalVolume* crystal_logical = new G4LogicalVolume(crystal_solid, Materials::get("G4_CESIUM_IODIDE"), name.c_str(),
113  0, 0, 0);
114  crystal_logical->SetVisAttributes(att("cryst"));
115  crystal_logical->SetSensitiveDetector(m_sensitive);
116 
117  new G4PVPlacement(NULL, G4ThreeVector(), crystal_logical, name.c_str(), wrapped_logical, false, 0, 0);
118  return wrapped_logical;
119 }
120 
121 void GeoECLCreator::defineVisAttributes()
122 {
123  m_atts["wrap"] = new G4VisAttributes(G4Colour(0.5, 0.5, 1.0));
124  m_atts["cryst"] = new G4VisAttributes(G4Colour(0.7, 0.7, 1.0));
125 
126  m_atts["iron"] = new G4VisAttributes(G4Colour(1., 0.1, 0.1));
127  m_atts["iron2"] = new G4VisAttributes(G4Colour(1., 0.5, 0.5));
128  m_atts["alum"] = new G4VisAttributes(G4Colour(0.25, 0.25, 1.0, 0.5));
129  m_atts["alum2"] = new G4VisAttributes(G4Colour(0.5, 0.5, 1.0));
130  m_atts["silv"] = new G4VisAttributes(G4Colour(0.9, 0., 0.9));
131  m_atts["air"] = new G4VisAttributes(G4Colour(1., 1., 1.)); m_atts["air"]->SetVisibility(false);
132  m_atts["preamp"] = new G4VisAttributes(G4Colour(0.1, 0.1, 0.8));
133  m_atts["plate"] = new G4VisAttributes(G4Colour(0.2, 0.8, 0.2));
134  m_atts["connector"] = new G4VisAttributes(G4Colour(0.1, 0.1, 0.1));
135  m_atts["capacitor"] = new G4VisAttributes(G4Colour(0.1, 0.1, 0.8));
136  m_atts["holder"] = new G4VisAttributes(G4Colour(0.4, 0.8, 0.8));
137 }
138 
139 const G4VisAttributes* GeoECLCreator::att(const std::string& n) const
140 {
141  auto p = m_atts.find(n);
142  assert(p != m_atts.end());
143  return p->second;
144 }
145 
146 G4LogicalVolume* GeoECLCreator::get_preamp() const
147 {
148  static G4LogicalVolume* lv_preamplifier = NULL;
149  if (lv_preamplifier == NULL) {
150  G4VSolid* sv_preamplifier = new G4Box("sv_preamplifier", 58. / 2, 51. / 2, get_pa_box_height() / 2);
151  lv_preamplifier = new G4LogicalVolume(sv_preamplifier, Materials::get("A5052"), "lv_preamplifier", 0, 0, 0);
152  G4VSolid* sv_diode = new G4Box("sv_diode", 20. / 2, 20. / 2, 0.3 / 2);
153  G4LogicalVolume* lv_diode = new G4LogicalVolume(sv_diode, Materials::get("G4_Si"), "lv_diode", 0, 0, 0);
154  lv_diode->SetUserLimits(new G4UserLimits(0.01));
155  lv_diode->SetSensitiveDetector(m_sensediode);
156  new G4PVPlacement(G4TranslateZ3D(-get_pa_box_height() / 2 + 0.3 / 2), lv_diode, "pv_diode", lv_preamplifier, false, 0, m_overlap);
157 
158  // G4VSolid* sv_diode = new G4Box("sv_diode", 10. / 2, 20. / 2, 0.3 / 2);
159  // G4LogicalVolume* lv_diode = new G4LogicalVolume(sv_diode, Materials::get("G4_Si"), "lv_diode", 0, 0, 0);
160  // lv_diode->SetUserLimits(new G4UserLimits(0.01));
161  // new G4PVPlacement(G4Translate3D(-5, 0, -pa_box_height / 2 + 0.3 / 2), lv_diode, "pv_diode1", lv_preamplifier, false, 1, overlap);
162  // new G4PVPlacement(G4Translate3D(5, 0, -pa_box_height / 2 + 0.3 / 2), lv_diode, "pv_diode2", lv_preamplifier, false, 2, overlap);
163 
164  lv_preamplifier->SetVisAttributes(att("preamp"));
165  }
166  return lv_preamplifier;
167 }
168 
Belle2::IntervalOfValidity
A class that describes the interval of experiments/runs for which an object in the database is valid.
Definition: IntervalOfValidity.h:35
Belle2::ECL::GeoECLCreator::m_sensediode
Simulation::SensitiveDetectorBase * m_sensediode
Sensitive diode.
Definition: GeoECLCreator.h:97
Belle2::ECL::GeoECLCreator::m_sap
const ECLCrystalsShapeAndPosition * m_sap
pointer to a storage with crystal shapes and positions
Definition: GeoECLCreator.h:92
Belle2::ECL::SensitiveDetector
Class for ECL Sensitive Detector.
Definition: SensitiveDetector.h:43
Belle2::ECL::GeoECLCreator::create
virtual void create(const GearDir &content, G4LogicalVolume &topVolume, geometry::GeometryTypes type) override
Function to actually create the geometry, has to be overridden by derived classes.
Definition: GeoECLCreator.cc:79
Belle2::ECL::GeoECLCreator::forward
void forward(G4LogicalVolume &)
Place elements inside the forward endcap.
Definition: forward.cc:29
Belle2::ECL::GeoECLCreator::wrapped_crystal
G4LogicalVolume * wrapped_crystal(const shape_t *s, const std::string &endcap, double wrapthickness)
Wrapped crystal.
Definition: GeoECLCreator.cc:92
Belle2::ECL::GeoECLCreator::GeoECLCreator
GeoECLCreator()
Constructor of the GeoECLCreator class.
Definition: GeoECLCreator.cc:45
Belle2::ECL::shape_t
Definition: shapes.h:39
Belle2::ECL::GeoECLCreator::~GeoECLCreator
~GeoECLCreator()
The destructor of the GeoECLCreator class.
Definition: GeoECLCreator.cc:54
Belle2::Database::storeData
bool storeData(const std::string &name, TObject *object, const IntervalOfValidity &iov)
Store an object in the database.
Definition: Database.cc:152
Belle2::ECL::SensitiveDiode
Class for ECL Sensitive Detector.
Definition: SensitiveDetector.h:85
Belle2::geometry
Common code concerning the geometry representation of the detector.
Definition: CreatorBase.h:28
Belle2::ECL::GeoECLCreator::backward
void backward(G4LogicalVolume &)
Place elements inside the backward endcap.
Definition: backward.cc:24
Belle2::geometry::Materials::get
static G4Material * get(const std::string &name)
Find given material.
Definition: Materials.h:65
Belle2::DBObjPtr
Class for accessing objects in the database.
Definition: DBObjPtr.h:31
Belle2::ECL::GeoECLCreator::createFromDB
virtual void createFromDB(const std::string &name, G4LogicalVolume &topVolume, geometry::GeometryTypes type) override
Function to create the geometry from the Database.
Definition: GeoECLCreator.cc:59
Belle2::ECL::GeoECLCreator::m_overlap
int m_overlap
overlap
Definition: GeoECLCreator.h:101
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::ECL::GeoECLCreator::barrel
void barrel(G4LogicalVolume &)
Make the ECL barrel and then place elements inside it.
Definition: barrel.cc:56
Belle2::GearDir
GearDir is the basic class used for accessing the parameter store.
Definition: GearDir.h:41
Belle2::ECL::GeoECLCreator::att
const G4VisAttributes * att(const std::string &n) const
Define visual attributes.
Definition: GeoECLCreator.cc:139
Belle2::ECL::GeoECLCreator::m_sensitive
Simulation::SensitiveDetectorBase * m_sensitive
Sensitive detector.
Definition: GeoECLCreator.h:95
Belle2::DBAccessorBase::isValid
bool isValid() const
Check whether a valid object was obtained from the database.
Definition: DBAccessorBase.h:75
Belle2::ECL::GeoECLCreator::m_atts
std::map< std::string, G4VisAttributes * > m_atts
Vector of background-Sensitive detectors.
Definition: GeoECLCreator.h:99
Belle2::Database::Instance
static Database & Instance()
Instance of a singleton Database.
Definition: Database.cc:54
Belle2::ECL::GeoECLCreator::defineVisAttributes
void defineVisAttributes()
Define visual attributes.
Definition: GeoECLCreator.cc:121
Belle2::ECLCrystalsShapeAndPosition
Crystal shapes and positions.
Definition: ECLCrystalsShapeAndPosition.h:37
Belle2::ECL::GeoECLCreator::createPayloads
virtual void createPayloads(const GearDir &content, const IntervalOfValidity &iov) override
Function to create the geometry database.
Definition: GeoECLCreator.cc:73
Belle2::geometry::CreatorFactory
Very simple class to provide an easy way to register creators with the CreatorManager.
Definition: CreatorFactory.h:42
Belle2::geometry::GeometryTypes
GeometryTypes
Flag indiciating the type of geometry to be used.
Definition: GeometryManager.h:39