Belle II Software  release-05-01-25
Materials.cc
1 #include <geometry/Materials.h>
2 #include <gtest/gtest.h>
3 #include <iostream>
4 #include <string>
5 
6 #include <framework/gearbox/Gearbox.h>
7 #include <framework/gearbox/GearDir.h>
8 #include <framework/utilities/TestHelpers.h>
9 
10 #include <G4Element.hh>
11 #include <G4Material.hh>
12 #include <G4OpticalSurface.hh>
13 #include <G4MaterialPropertiesTable.hh>
14 
15 using namespace std;
16 
17 namespace Belle2 {
22  namespace geometry {
23 
26  TEST(Materials, Element)
27  {
28  Materials& m = Materials::getInstance();
29  G4Element* e1 = m.getElement("H");
30  ASSERT_TRUE(e1);
31  EXPECT_EQ("H", e1->GetName());
32  EXPECT_EQ("H", e1->GetSymbol());
33  EXPECT_EQ(1., e1->GetZ());
34  }
35 
39  TEST(Materials, Material)
40  {
41  G4Material* m1 = Materials::get("Air");
42  G4Material* m2 = Materials::get("G4_AIR");
43  EXPECT_EQ(m1, m2);
44  ASSERT_TRUE(m1);
45  EXPECT_EQ("G4_AIR", m1->GetName());
46  EXPECT_TRUE(Materials::get("Si"));
47  }
48 
52  TEST(Materials, Create)
53  {
54  Gearbox& gb = Gearbox::getInstance();
55  vector<string> backends;
56  backends.emplace_back("string:<Material name='Test'><state>Gas</state><Components>"
57  "<Material fraction='1.5'>Si</Material>"
58  "<Material fraction='2.5612'>Au</Material>"
59  "</Components></Material>");
60  gb.setBackends(backends);
61  gb.open();
62  Materials& m = Materials::getInstance();
63  ASSERT_EQ(0, gb.getNumberNodes("/Material/density"));
64  ASSERT_EQ(1, gb.getNumberNodes("/Material/@name"));
65 
66  G4Material* au = Materials::get("Au");
67  G4Material* si = Materials::get("Si");
68  G4Material* mat = m.createMaterial(GearDir("/Material"));
69  ASSERT_TRUE(mat);
70  EXPECT_EQ("Test", mat->GetName());
71  EXPECT_DOUBLE_EQ((2.5612 * au->GetDensity() + 1.5 * si->GetDensity()) / 4.0612, mat->GetDensity());
72  gb.close();
73  }
74 
77  TEST(Materials, CreateDensityError)
78  {
79  Gearbox& gb = Gearbox::getInstance();
80  vector<string> backends;
81  backends.emplace_back("string:<Material name='Test1'><state>Solid</state><Components>"
82  "<Material fraction='0.5'>Si</Material>"
83  "<Element fraction='0.5'>Au</Element>"
84  "</Components></Material>");
85  gb.setBackends(backends);
86  gb.open();
87 
88  Materials& m = Materials::getInstance();
89  G4Material* mat = m.createMaterial(GearDir("/Material"));
90  ASSERT_FALSE(mat);
91  gb.close();
92  }
93 
96  TEST(Materials, CreateDensity)
97  {
98  Gearbox& gb = Gearbox::getInstance();
99  vector<string> backends;
100  backends.emplace_back("string:<Material name='Test2'><state>Liquid</state><density>1</density><Components>"
101  "<Material>Si</Material>"
102  "<Element>Au</Element>"
103  "</Components></Material>");
104  gb.setBackends(backends);
105  gb.open();
106 
107  Materials& m = Materials::getInstance();
108  G4Material* mat = m.createMaterial(GearDir("/Material"));
109  ASSERT_TRUE(mat);
110  gb.close();
111  }
112 
115  TEST(Materials, CreateMaterialError)
116  {
117  Gearbox& gb = Gearbox::getInstance();
118  vector<string> backends;
119  backends.emplace_back("string:<Material name='Test3'><Components>"
120  "<Material>Foo</Material>"
121  "</Components></Material>");
122  gb.setBackends(backends);
123  gb.open();
124 
125  Materials& m = Materials::getInstance();
126  G4Material* mat = m.createMaterial(GearDir("/Material"));
127  ASSERT_FALSE(mat);
128  gb.close();
129  }
130 
133  TEST(Materials, CreateElementError)
134  {
135  Gearbox& gb = Gearbox::getInstance();
136  vector<string> backends;
137  backends.emplace_back("string:<Material name='Test4'><density>1</density><Components>"
138  "<Element>Foo</Element>"
139  "</Components></Material>");
140  gb.setBackends(backends);
141  gb.open();
142 
143  Materials& m = Materials::getInstance();
144  G4Material* mat = m.createMaterial(GearDir("/Material"));
145  ASSERT_FALSE(mat);
146  gb.close();
147  }
148 
151  TEST(Materials, OpticalSurface)
152  {
153  Gearbox& gb = Gearbox::getInstance();
154  vector<string> backends;
155  backends.emplace_back("string:<test><Surface/>"
156  "<Surface name='test'><Model>unified</Model><Finish>Ground</Finish>"
157  "<Type>x_ray</Type><Value>2.0</Value></Surface>"
158  "<Surface><Model>not existing</Model></Surface>"
159  "<Surface><Finish>not existing</Finish></Surface>"
160  "<Surface><Type>not existing</Type></Surface></test>"
161  );
162  gb.setBackends(backends);
163  gb.open();
164 
165  Materials& m = Materials::getInstance();
166 
167  G4OpticalSurface* surf1 = m.createOpticalSurface(GearDir("/test/Surface[1]"));
168  ASSERT_TRUE(surf1);
169  EXPECT_EQ("OpticalSurface", surf1->GetName());
170  EXPECT_EQ(glisur, surf1->GetModel());
171  EXPECT_EQ(polished, surf1->GetFinish());
172  EXPECT_EQ(dielectric_dielectric, surf1->GetType());
173  EXPECT_EQ(1.0, surf1->GetPolish());
174 
175  G4OpticalSurface* surf2 = m.createOpticalSurface(GearDir("/test/Surface[2]"));
176  ASSERT_TRUE(surf2);
177  EXPECT_EQ("test", surf2->GetName());
178  EXPECT_EQ(unified, surf2->GetModel());
179  EXPECT_EQ(ground, surf2->GetFinish());
180  EXPECT_EQ(x_ray, surf2->GetType());
181  EXPECT_EQ(2.0, surf2->GetSigmaAlpha());
182 
183  EXPECT_B2FATAL(m.createOpticalSurface(GearDir("/test/Surface[3]")));
184  EXPECT_B2FATAL(m.createOpticalSurface(GearDir("/test/Surface[4]")));
185  EXPECT_B2FATAL(m.createOpticalSurface(GearDir("/test/Surface[5]")));
186  }
187 
190  TEST(Materials, Properties)
191  {
192  Gearbox& gb = Gearbox::getInstance();
193  vector<string> backends;
194  backends.emplace_back("string:<Material name='TestProperties'>"
195  "<Components><Material>Si</Material></Components>"
196  "<Property name='RINDEX' unit='eV'>"
197  "<value energy='1.0'>1.40</value>"
198  "<value energy='1.5'>1.41</value>"
199  "<value energy='2.0'>1.42</value>"
200  "<value energy='3.5'>1.43</value>"
201  "</Property>"
202  "</Material>");
203  gb.setBackends(backends);
204  gb.open();
205  Materials& m = Materials::getInstance();
206 
207  G4Material* mat = m.createMaterial(GearDir("/Material"));
208  ASSERT_TRUE(mat);
209  G4MaterialPropertiesTable* properties = mat->GetMaterialPropertiesTable();
210  ASSERT_TRUE(properties);
211  G4MaterialPropertyVector* property = properties->GetProperty("RINDEX");
212  ASSERT_TRUE(property);
213  EXPECT_EQ(4u, property->GetVectorLength());
214  EXPECT_DOUBLE_EQ(1.40, property->GetMinValue());
215  EXPECT_DOUBLE_EQ(1.43, property->GetMaxValue());
216  EXPECT_DOUBLE_EQ(1 * CLHEP::eV, property->GetMinLowEdgeEnergy());
217  EXPECT_DOUBLE_EQ(3.5 * CLHEP::eV, property->GetMaxLowEdgeEnergy());
218  EXPECT_DOUBLE_EQ(1.0 * CLHEP::eV, property->Energy(0));
219  EXPECT_DOUBLE_EQ(1.5 * CLHEP::eV, property->Energy(1));
220  EXPECT_DOUBLE_EQ(2.0 * CLHEP::eV, property->Energy(2));
221  EXPECT_DOUBLE_EQ(3.5 * CLHEP::eV, property->Energy(3));
222  EXPECT_DOUBLE_EQ(1.40, (*property)[0]);
223  EXPECT_DOUBLE_EQ(1.41, (*property)[1]);
224  EXPECT_DOUBLE_EQ(1.42, (*property)[2]);
225  EXPECT_DOUBLE_EQ(1.43, (*property)[3]);
226  gb.close();
227  }
228  } // namespace geometry
230 } // namespace Belle2
Belle2::Gearbox::getNumberNodes
virtual int getNumberNodes(const std::string &path="") const override
Return the number of nodes a given path will expand to.
Definition: Gearbox.h:122
Belle2::Gearbox::close
void close()
Free internal structures of previously parsed tree and clear cache.
Definition: Gearbox.cc:162
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::Gearbox
Singleton class responsible for loading detector parameters from an XML file.
Definition: Gearbox.h:44
Belle2::GearDir
GearDir is the basic class used for accessing the parameter store.
Definition: GearDir.h:41
Belle2::geometry::Materials
Thin wrapper around the Geant4 Material system.
Definition: Materials.h:50
Belle2::TEST
TEST(TestgetDetectorRegion, TestgetDetectorRegion)
Test Constructors.
Definition: utilityFunctions.cc:18
Belle2::Gearbox::open
void open(const std::string &name="Belle2.xml", size_t cacheSize=c_DefaultCacheSize)
Open connection to backend and parse tree.
Definition: Gearbox.cc:126
Belle2::Gearbox::setBackends
void setBackends(const std::vector< std::string > &backends)
Select the backends to use to find resources.
Definition: Gearbox.cc:92