Belle2::geometry Namespace Reference

Common code concerning the geometry representation of the detector. More...

Classes
class	CreatorBase
	Pure virtual base class for all geometry creators. More...
struct	CreatorFactory
	Very simple class to provide an easy way to register creators with the CreatorManager. More...
class	CreatorManager
	Class to manage all creators and provide factory access. More...
class	GeometryManager
	Class to manage the creation and conversion of the geometry. More...
class	Materials
	Thin wrapper around the Geant4 Material system. More...

Enumerations
enum	GeometryTypes {   FullGeometry ,   TrackingGeometry ,   DisplayGeometry }
	Flag indiciating the type of geometry to be used. More...

Functions
void	setColor (G4LogicalVolume &volume, const std::string &color)
	Set the color of a logical volume.
void	setVisibility (G4LogicalVolume &volume, bool visible)
	Helper function to quickly set the visibility of a given volume.
G4Polycone *	createPolyCone (const std::string &name, const GearDir &params, double &minZ, double &maxZ)
	Create Polycone Shape from XML Parameters.
G4Polycone *	createRotationSolid (const std::string &name, const GearDir &params, double &minZ, double &maxZ)
	Create a solid by roating two polylines around the Z-Axis.
G4Polycone *	createRotationSolid (const std::string &name, std::list< std::pair< double, double > > innerPoints, std::list< std::pair< double, double > > outerPoints, double minPhi, double maxPhi, double &minZ, double &maxZ)
	Create a solid by rotating two polylines around the Z-Axis.
G4Colour	parseColor (std::string colorString)
	Parse a color string of the form "#rgb", "#rrggbb", "#rgba", "#rrggbbaa" or "rgb(r, g, b)" and return a corresponding G4Colour.
	TEST (Materials, Element)
	Check that we can find hydrogen and that the basic Parameters are correct.
	TEST (Materials, Material)
	Check if we find the Air Material which is named G4_AIR in Geant4 So check if Air and G4_AIR refer to the same material.
	TEST (Materials, Create)
	Check creation of a simple mixture with fractions of other materials The density of the new material should be equal to the weighted sum of the original densities.
	TEST (Materials, CreateDensityError)
	When adding elements one has to specify a density since elements do not have a density.
	TEST (Materials, CreateDensity)
	Same as above, but with density so it should work.
	TEST (Materials, CreateMaterialError)
	When adding unknown materials we should get NULL.
	TEST (Materials, CreateElementError)
	When adding unknown elements we should get NULL.
	TEST (Materials, OpticalSurface)
	Check the OpticalSurface setting.
	TEST (Materials, Properties)
	Check the material properties (need to be checked)

Detailed Description

Common code concerning the geometry representation of the detector.

Enumeration Type Documentation

GeometryTypes

enum GeometryTypes

Flag indiciating the type of geometry to be used.

Enumerator
FullGeometry	Full geometry for simulation.
TrackingGeometry	Simplified geometry for tracking purposes.
DisplayGeometry	Simplified geometry for display purposes.

Definition at line 36 of file GeometryManager.h.

                       {
      FullGeometry,     
      TrackingGeometry, 
      DisplayGeometry   
    };

Function Documentation

createPolyCone()

G4Polycone * createPolyCone	(	const std::string &	name,
		const GearDir &	params,
		double &	minZ,
		double &	maxZ
	)

Create Polycone Shape from XML Parameters.

This function will create a polycone shape directly from Gearbox Parameters of the form

<minPhi unit="deg">  0</minPhi>
<maxPhi unit="deg">360</maxPhi>
<Plane>
  <posZ unit="mm">-10.0</posZ>
  <innerRadius unit="mm"> 20.000</innerRadius>
  <outerRadius unit="mm"> 20.000</outerRadius>
</Plane>
...
<Plane>
  <posZ unit="mm">10.0</posZ>
  <innerRadius unit="mm"> 15.000</innerRadius>
  <outerRadius unit="mm"> 30.000</outerRadius>
</Plane>

There must be at least two Plane definitions, minPhi and maxPhi can be omitted. minZ and maxZ will return the extents of the Polycone along z

Parameters

	name	Name of the shape to create
	params	GearDir pointing to the parameters
[out]	minZ	will contain the minimal z coordinate of the polycone
[out]	maxZ	will contain the maximal z coordinate of the polycone

Definition at line 116 of file utilities.cc.

    {
      if (!params) return nullptr;
 
      double minPhi = params.getAngle("minPhi", 0);
      double dPhi   = params.getAngle("maxPhi", 2 * M_PI) - minPhi;
      const std::vector<GearDir> planes = params.getNodes("Plane");
      int nPlanes = planes.size();
      if (nPlanes < 2) {
        B2ERROR("Polycone needs at least two planes");
        return nullptr;
      }
      std::vector<double> z(nPlanes, 0);
      std::vector<double> rMin(nPlanes, 0);
      std::vector<double> rMax(nPlanes, 0);
      int index(0);
      minZ = std::numeric_limits<double>::infinity();
      maxZ = -std::numeric_limits<double>::infinity();
      for (const GearDir& plane : planes) {
        z[index]    = plane.getLength("posZ") / Unit::mm;
        minZ = std::min(minZ, z[index]);
        maxZ = std::max(maxZ, z[index]);
        rMin[index] = plane.getLength("innerRadius") / Unit::mm;
        rMax[index] = plane.getLength("outerRadius") / Unit::mm;
        ++index;
      }
      G4Polycone* polycone = new G4Polycone(name, minPhi, dPhi, nPlanes, z.data(), rMin.data(), rMax.data());
      return polycone;
    }

createRotationSolid() [1/2]

G4Polycone * createRotationSolid	(	const std::string &	name,
		const GearDir &	params,
		double &	minZ,
		double &	maxZ
	)

Create a solid by roating two polylines around the Z-Axis.

This function will create a polycone shape directly from Gearbox Parameters describing the inner and the outer envelope of the polycone. The XML Parameters should be of the form

<minPhi unit="deg">  0</minPhi>
<maxPhi unit="deg">360</maxPhi>
<OuterPoints>
  <point><z unit="mm">-393.000</z><x unit="mm">100.000</x></point>
  <point><z unit="mm">-337.000</z><x unit="mm"> 85.500</x></point>
  ...
  <point><z unit="mm">-138.000</z><x unit="mm"> 35.000</x></point>
</OuterPoints>
<InnerPoints>
  <point><z unit="mm">-393.000</z><x unit="mm"> 97.934</x></point>
  <point><z unit="mm">-339.000</z><x unit="mm"> 83.952</x></point>
  ...
  <point><z unit="mm">-138.000</z><x unit="mm"> 33.000</x></point>
</InnerPoints>

Where OuterPoints and InnerPoints specify a polyline which is the outer respective inner envelope of the Polycone. The number of points doe s not have to be the same for Outer- and InnerPoints. Needed positions will be interpolated when creating the Polycone.

The Positions for Outer- and InnerPoints have to be in ascending Z coordinates. The first and last point of OuterPoints will be connected to the first respective last point of InnerPoints. The resulting shape will be rotated around the z axis to create the polycone.

Parameters

	name	Name of the Solid
	params	Parameters to use for the Solid
[out]	minZ	will contain the minimal z coordinate of the polycone
[out]	maxZ	will contain the maximal z coordinate of the polycone

Definition at line 203 of file utilities.cc.

    {
 
      //Make a list of all the points (ZX coordinates)
      PointList innerPoints;
      PointList outerPoints;
      for (const GearDir& point : params.getNodes("InnerPoints/point")) {
        innerPoints.push_back(ZXPoint(point.getLength("z") / Unit::mm, point.getLength("x") / Unit::mm));
      }
      for (const GearDir& point : params.getNodes("OuterPoints/point")) {
        outerPoints.push_back(ZXPoint(point.getLength("z") / Unit::mm, point.getLength("x") / Unit::mm));
      }
      //Subdivide the segments to have an x position for each z specified for
      //either inner or outer boundary
      subdivideSegments(innerPoints, outerPoints);
      subdivideSegments(outerPoints, innerPoints);
      minZ = innerPoints.front().first;
      maxZ = outerPoints.front().first;
 
      //Now we create the array of planes needed for the polycone
      std::vector<double> z;
      std::vector<double> rMin;
      std::vector<double> rMax;
 
      double innerZ{0};
      double innerX{0};
      double outerZ{0};
      double outerX{0};
      //We go through both lists until both are empty
      while (!(innerPoints.empty() && outerPoints.empty())) {
        bool popInner = false;
        //We could have more than one point at the same z position for segments
        //going directly along x. because of that we check that the z
        //coordinates for inner and outer line are always the same, reusing one
        //point if neccessary
        if (!innerPoints.empty() && innerPoints.front().first <= outerPoints.front().first) {
          boost::tie(innerZ, innerX) = innerPoints.front();
          popInner = true;
        }
        if (!outerPoints.empty() && outerPoints.front().first <= innerPoints.front().first) {
          boost::tie(outerZ, outerX) = outerPoints.front();
          outerPoints.pop_front();
        }
        if (popInner) innerPoints.pop_front();
        if (innerZ != outerZ) {
          B2ERROR("createRotationSolid: Something is wrong, z values should be identical");
          return nullptr;
        }
        z.push_back(innerZ);
        rMin.push_back(innerX);
        rMax.push_back(outerX);
      }
 
      //Finally create the Polycone
      int nPlanes = z.size();
      double minPhi = params.getAngle("minPhi", 0);
      double dPhi   = params.getAngle("maxPhi", 2 * M_PI) - minPhi;
      return new G4Polycone(name, minPhi, dPhi, nPlanes, &z.front(), &rMin.front(), &rMax.front());
    }

createRotationSolid() [2/2]

G4Polycone * createRotationSolid	(	const std::string &	name,
		std::list< std::pair< double, double > >	innerPoints,
		std::list< std::pair< double, double > >	outerPoints,
		double	minPhi,
		double	maxPhi,
		double &	minZ,
		double &	maxZ
	)

Create a solid by rotating two polylines around the Z-Axis.

This function will create a polycone shape. The InnerPoints and OuterPoints are passed directly as stl::lists to avoid dependence on gearbox.

Where OuterPoints and InnerPoints specify a polyline which is the outer respective inner envelope of the Polycone. The number of points does not have to be the same for Outer- and InnerPoints. Needed positions will be interpolated when creating the Polycone.

The Positions for Outer- and InnerPoints have to be in ascending Z coordinates. The first and last point of OuterPoints will be connected to the first respective last point of InnerPoints. The resulting shape will be rotated around the z axis to create the polycone.

Parameters

[in]	name	Name of the solid.
[in]	innerPoints	List of inner points.
[in]	outerPoints	List of outer points.
[in]	minPhi	Minimum phi angle.
[in]	maxPhi	Maximum phi angle.
[out]	minZ	Minimum z coordinate.
[out]	maxZ	Maximum z coordinate.

Definition at line 263 of file utilities.cc.

    {
      //Subdivide the segments to have an x position for each z specified for
      //either inner or outer boundary
      subdivideSegments(innerPoints, outerPoints);
      subdivideSegments(outerPoints, innerPoints);
      minZ = innerPoints.front().first;
      maxZ = outerPoints.front().first;
 
      //Now we create the array of planes needed for the polycone
      std::vector<double> z;
      std::vector<double> rMin;
      std::vector<double> rMax;
 
      double innerZ{0};
      double innerX{0};
      double outerZ{0};
      double outerX{0};
      //We go through both lists until both are empty
      while (!(innerPoints.empty() && outerPoints.empty())) {
        bool popInner = false;
        //We could have more than one point at the same z position for segments
        //going directly along x. because of that we check that the z
        //coordinates for inner and outer line are always the same, reusing one
        //point if necessary
        // cppcheck-suppress knownConditionTrueFalse
        if (!innerPoints.empty() && innerPoints.front().first <= outerPoints.front().first) {
          boost::tie(innerZ, innerX) = innerPoints.front();
          popInner = true;
        }
        if (!outerPoints.empty() && outerPoints.front().first <= innerPoints.front().first) {
          boost::tie(outerZ, outerX) = outerPoints.front();
          outerPoints.pop_front();
        }
        if (popInner) innerPoints.pop_front();
        if (innerZ != outerZ) {
          B2ERROR("createRotationSolid: Something is wrong, z values should be identical");
          return nullptr;
        }
        z.push_back(innerZ / Unit::mm);
        rMin.push_back(innerX / Unit::mm);
        rMax.push_back(outerX / Unit::mm);
      }
 
      //Finally create the Polycone
      int nPlanes = z.size();
      double dPhi = maxPhi - minPhi;
      return new G4Polycone(name, minPhi, dPhi, nPlanes, &z.front(), &rMin.front(), &rMax.front());
 
    }

parseColor()

G4Colour parseColor

(

std::string

colorString

)

Parse a color string of the form "#rgb", "#rrggbb", "#rgba", "#rrggbbaa" or "rgb(r, g, b)" and return a corresponding G4Colour.

For "#rgb" and "#rgba" the color for red, green, blue (and optionally alpha) is each represented by one hexadecimal digit, "#rrggbb" and "#rrggbbaa" is the same with two digits per colour.

"rgb(r, g, b)" expects the fraction of red, green and blue as float between 0 and 1.

Definition at line 44 of file utilities.cc.

    {
      boost::to_lower(colorString);
      double red(0), green(0), blue(0), alpha(0);
      if (colorString[0] == '#') {
        size_t size = colorString.size();
        unsigned int colorValue;
        std::stringstream in(colorString);
        in.get();
        in >> std::hex >> colorValue;
        if (in.fail()) size = 0;
        switch (size) {
          case 4: //#rgb, add alpha since none was specified
            colorValue = (colorValue << 4) + 15;
            // and then continue with rgba case
            [[fallthrough]];
          case 5: //#rgba
            red   = ((colorValue & 0xf000) >> 12) / 15.;
            green = ((colorValue & 0x0f00) >>  8) / 15.;
            blue  = ((colorValue & 0x00f0) >>  4) / 15.;
            alpha = ((colorValue & 0x000f) >>  0) / 15.;
            break;
          case 7: //#rrggbb, add alpha since none was specified
            colorValue = (colorValue << 8) + 255;
            // and then continue with #rrggbbaa case
            [[fallthrough]];
          case 9: //#rrggbbaa
            red   = ((colorValue & 0xff000000) >> 24) / 255.;
            green = ((colorValue & 0x00ff0000) >> 16) / 255.;
            blue  = ((colorValue & 0x0000ff00) >>  8) / 255.;
            alpha = ((colorValue & 0x000000ff) >>  0) / 255.;
            break;
          default:
            B2WARNING("Could not parse color string '" + colorString + "'");
        }
      } else if (colorString.substr(0, 3) == "rgb") {
        //Parse value of the type rgb(1.0,1.0,1.0)
        size_t startPos = colorString.find('(');
        size_t stopPos = colorString.find(')');
        std::string ws(" \t\r\n,");
        std::stringstream in(colorString.substr(startPos + 1, stopPos - startPos - 1));
        in >> red;
        while (ws.find(in.peek()) != std::string::npos) in.get();
        in >> green;
        while (ws.find(in.peek()) != std::string::npos) in.get();
        in >> blue;
        while (ws.find(in.peek()) != std::string::npos) in.get();
        in >> alpha;
        red   = std::min(1.0, std::max(0.0, red));
        green = std::min(1.0, std::max(0.0, green));
        blue  = std::min(1.0, std::max(0.0, blue));
        alpha = std::min(1.0, std::max(0.0, alpha));
      }
      return G4Colour(red, green, blue, alpha);
    }

setColor()

void setColor	(	G4LogicalVolume &	volume,
		const std::string &	color
	)

Set the color of a logical volume.

This function will set the visualization color of a logical volume from a string representation of the color. Recognized formats for the color are:

• "#rgb" where r,g,b are hexadecimal values from 0 to f representing the color values for red, green and blue respectively
• "#rgba" where r,g,b,a are hexadecimal values from 0 to f and a represents the alpha value
• "#rrggbb" where rr,gg,bb are hexadecimal values from 00 to ff representing the color values for red, green and blue respectively
• "#rrggbbaa" where rr,gg,bb,aa are hexadecimal values from 00 to ff and aa represents the alpha value
• "rgb(r,g,b)" where r,g,b are float values between 0.0 and 1.0 representing the color values for red, green and blue respectively
• "rgb(r,g,b,a)" where r,g,b,a are float values between 0.0 and 1.0 representing the color values for red, green, blue and alpha respectively

Parameters

volume	Volume for which to set the color
color	String representation of the color

Definition at line 100 of file utilities.cc.

    {
      auto* attr = const_cast<G4VisAttributes*>(volume.GetVisAttributes());
      if (!attr) attr = GeometryManager::getInstance().newVisAttributes();
      attr->SetColor(parseColor(color));
      volume.SetVisAttributes(attr);
    }

setVisibility()

void setVisibility	(	G4LogicalVolume &	volume,
		bool	visible
	)

Helper function to quickly set the visibility of a given volume.

Parameters

volume	Volume for which to set the visibility
visible	true if the volume should be visible, false otherwise

Definition at line 108 of file utilities.cc.

    {
      auto* attr = const_cast<G4VisAttributes*>(volume.GetVisAttributes());
      if (!attr) attr = GeometryManager::getInstance().newVisAttributes();
      attr->SetVisibility(visible);
      volume.SetVisAttributes(attr);
    }

TEST() [1/9]

TEST	(	Materials	,
		Create
	)

Check creation of a simple mixture with fractions of other materials The density of the new material should be equal to the weighted sum of the original densities.

Definition at line 59 of file Materials.cc.

    {
      Gearbox& gb = Gearbox::getInstance();
      vector<string> backends;
      backends.emplace_back("string:<Material name='Test'><state>Gas</state><Components>"
                            "<Material fraction='1.5'>Si</Material>"
                            "<Material fraction='2.5612'>Au</Material>"
                            "</Components></Material>");
      gb.setBackends(backends);
      gb.open();
      Materials& m = Materials::getInstance();
      ASSERT_EQ(0, gb.getNumberNodes("/Material/density"));
      ASSERT_EQ(1, gb.getNumberNodes("/Material/@name"));
 
      G4Material* au = Materials::get("Au");
      G4Material* si = Materials::get("Si");
      G4Material* mat = m.createMaterial(GearDir("/Material"));
      ASSERT_TRUE(mat);
      EXPECT_EQ("Test", mat->GetName());
      EXPECT_DOUBLE_EQ((2.5612 * au->GetDensity() + 1.5 * si->GetDensity()) / 4.0612, mat->GetDensity());
      gb.close();
    }

TEST() [2/9]

TEST	(	Materials	,
		CreateDensity
	)

Same as above, but with density so it should work.

Definition at line 103 of file Materials.cc.

    {
      Gearbox& gb = Gearbox::getInstance();
      vector<string> backends;
      backends.emplace_back("string:<Material name='Test2'><state>Liquid</state><density>1</density><Components>"
                            "<Material>Si</Material>"
                            "<Element>Au</Element>"
                            "</Components></Material>");
      gb.setBackends(backends);
      gb.open();
 
      Materials& m = Materials::getInstance();
      G4Material* mat = m.createMaterial(GearDir("/Material"));
      ASSERT_TRUE(mat);
      gb.close();
    }

TEST() [3/9]

TEST	(	Materials	,
		CreateDensityError
	)

When adding elements one has to specify a density since elements do not have a density.

Definition at line 84 of file Materials.cc.

    {
      Gearbox& gb = Gearbox::getInstance();
      vector<string> backends;
      backends.emplace_back("string:<Material name='Test1'><state>Solid</state><Components>"
                            "<Material fraction='0.5'>Si</Material>"
                            "<Element fraction='0.5'>Au</Element>"
                            "</Components></Material>");
      gb.setBackends(backends);
      gb.open();
 
      Materials& m = Materials::getInstance();
      G4Material* mat = m.createMaterial(GearDir("/Material"));
      ASSERT_FALSE(mat);
      gb.close();
    }

TEST() [4/9]

TEST	(	Materials	,
		CreateElementError
	)

When adding unknown elements we should get NULL.

Definition at line 140 of file Materials.cc.

    {
      Gearbox& gb = Gearbox::getInstance();
      vector<string> backends;
      backends.emplace_back("string:<Material name='Test4'><density>1</density><Components>"
                            "<Element>Foo</Element>"
                            "</Components></Material>");
      gb.setBackends(backends);
      gb.open();
 
      Materials& m = Materials::getInstance();
      G4Material* mat = m.createMaterial(GearDir("/Material"));
      ASSERT_FALSE(mat);
      gb.close();
    }

TEST() [5/9]

TEST	(	Materials	,
		CreateMaterialError
	)

When adding unknown materials we should get NULL.

Definition at line 122 of file Materials.cc.

    {
      Gearbox& gb = Gearbox::getInstance();
      vector<string> backends;
      backends.emplace_back("string:<Material name='Test3'><Components>"
                            "<Material>Foo</Material>"
                            "</Components></Material>");
      gb.setBackends(backends);
      gb.open();
 
      Materials& m = Materials::getInstance();
      G4Material* mat = m.createMaterial(GearDir("/Material"));
      ASSERT_FALSE(mat);
      gb.close();
    }

TEST() [6/9]

TEST	(	Materials	,
		Element
	)

Check that we can find hydrogen and that the basic Parameters are correct.

Definition at line 33 of file Materials.cc.

    {
      Materials& m = Materials::getInstance();
      G4Element* e1 = m.getElement("H");
      ASSERT_TRUE(e1);
      EXPECT_EQ("H", e1->GetName());
      EXPECT_EQ("H", e1->GetSymbol());
      EXPECT_EQ(1., e1->GetZ());
    }

TEST() [7/9]

TEST	(	Materials	,
		Material
	)

Check if we find the Air Material which is named G4_AIR in Geant4 So check if Air and G4_AIR refer to the same material.

Definition at line 46 of file Materials.cc.

    {
      G4Material* m1 = Materials::get("Air");
      G4Material* m2 = Materials::get("G4_AIR");
      EXPECT_EQ(m1, m2);
      ASSERT_TRUE(m1);
      EXPECT_EQ("G4_AIR", m1->GetName());
      EXPECT_TRUE(Materials::get("Si"));
    }

TEST() [8/9]

TEST	(	Materials	,
		OpticalSurface
	)

Check the OpticalSurface setting.

Definition at line 158 of file Materials.cc.

    {
      Gearbox& gb = Gearbox::getInstance();
      vector<string> backends;
      backends.emplace_back("string:<test><Surface/>"
                            "<Surface name='test'><Model>unified</Model><Finish>Ground</Finish>"
                            "<Type>x_ray</Type><Value>2.0</Value></Surface>"
                            "<Surface><Model>not existing</Model></Surface>"
                            "<Surface><Finish>not existing</Finish></Surface>"
                            "<Surface><Type>not existing</Type></Surface></test>"
                           );
      gb.setBackends(backends);
      gb.open();
 
      Materials& m = Materials::getInstance();
 
      G4OpticalSurface* surf1 = m.createOpticalSurface(GearDir("/test/Surface[1]"));
      ASSERT_TRUE(surf1);
      EXPECT_EQ("OpticalSurface", surf1->GetName());
      EXPECT_EQ(glisur, surf1->GetModel());
      EXPECT_EQ(polished, surf1->GetFinish());
      EXPECT_EQ(dielectric_dielectric, surf1->GetType());
      EXPECT_EQ(1.0, surf1->GetPolish());
 
      G4OpticalSurface* surf2 = m.createOpticalSurface(GearDir("/test/Surface[2]"));
      ASSERT_TRUE(surf2);
      EXPECT_EQ("test", surf2->GetName());
      EXPECT_EQ(unified, surf2->GetModel());
      EXPECT_EQ(ground, surf2->GetFinish());
      EXPECT_EQ(x_ray, surf2->GetType());
      EXPECT_EQ(2.0, surf2->GetSigmaAlpha());
 
      EXPECT_B2FATAL(m.createOpticalSurface(GearDir("/test/Surface[3]")));
      EXPECT_B2FATAL(m.createOpticalSurface(GearDir("/test/Surface[4]")));
      EXPECT_B2FATAL(m.createOpticalSurface(GearDir("/test/Surface[5]")));
    }

TEST() [9/9]

TEST	(	Materials	,
		Properties
	)

Check the material properties (need to be checked)

Definition at line 197 of file Materials.cc.

    {
      Gearbox& gb = Gearbox::getInstance();
      vector<string> backends;
      backends.emplace_back("string:<Material name='TestProperties'>"
                            "<Components><Material>Si</Material></Components>"
                            "<Property name='RINDEX' unit='eV'>"
                            "<value energy='1.0'>1.40</value>"
                            "<value energy='1.5'>1.41</value>"
                            "<value energy='2.0'>1.42</value>"
                            "<value energy='3.5'>1.43</value>"
                            "</Property>"
                            "</Material>");
      gb.setBackends(backends);
      gb.open();
      Materials& m = Materials::getInstance();
 
      G4Material* mat = m.createMaterial(GearDir("/Material"));
      ASSERT_TRUE(mat);
      G4MaterialPropertiesTable* properties = mat->GetMaterialPropertiesTable();
      ASSERT_TRUE(properties);
      G4MaterialPropertyVector* property = properties->GetProperty("RINDEX");
      ASSERT_TRUE(property);
      EXPECT_EQ(4u, property->GetVectorLength());
      EXPECT_DOUBLE_EQ(1.40, property->GetMinValue());
      EXPECT_DOUBLE_EQ(1.43, property->GetMaxValue());
      EXPECT_DOUBLE_EQ(1 * CLHEP::eV, property->GetMinEnergy());
      EXPECT_DOUBLE_EQ(3.5 * CLHEP::eV, property->GetMaxEnergy());
      EXPECT_DOUBLE_EQ(1.0 * CLHEP::eV, property->Energy(0));
      EXPECT_DOUBLE_EQ(1.5 * CLHEP::eV, property->Energy(1));
      EXPECT_DOUBLE_EQ(2.0 * CLHEP::eV, property->Energy(2));
      EXPECT_DOUBLE_EQ(3.5 * CLHEP::eV, property->Energy(3));
      EXPECT_DOUBLE_EQ(1.40, (*property)[0]);
      EXPECT_DOUBLE_EQ(1.41, (*property)[1]);
      EXPECT_DOUBLE_EQ(1.42, (*property)[2]);
      EXPECT_DOUBLE_EQ(1.43, (*property)[3]);
      gb.close();
    }