TrackingGeometryClosureTests.cpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file TrackingGeometryClosureTests.cpp

// This file is part of the Acts project.
//
// Copyright (C) 2017-2018 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include <boost/test/unit_test.hpp>

#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Utilities/Helpers.hpp"
#include "Acts/Utilities/Units.hpp"

#include "TrackingVolumeCreation.hpp"

using namespace Acts::UnitLiterals;

namespace Acts {
namespace Test {

// Create a test context
GeometryContext tgContext = GeometryContext();


// sensitive surface definitions
double surfaceHalfLengthZ = 50_mm;
double surfaceRstagger = 5_mm;
double surfaceZoverlap = 10_mm;
double layerEnvelope = 0.5_mm;
double volumeEnvelope = 10_mm;

// inner inner volume definitions
double iiv_surfaceR = 25_mm;
double iiv_volumeR =
    iiv_surfaceR + 0.5 * surfaceRstagger + layerEnvelope + volumeEnvelope;

double iov_surfaceR = 100_mm;
double iov_volumeR =
    iov_surfaceR + 0.5 * surfaceRstagger + layerEnvelope + volumeEnvelope;

auto iiVolume = constructCylinderVolume(
    tgContext, surfaceHalfLengthZ, iiv_surfaceR, surfaceRstagger,
    surfaceZoverlap, layerEnvelope, volumeEnvelope, 0., iiv_volumeR,
    "InnerInnerVolume");
auto ioVolume = constructCylinderVolume(
    tgContext, surfaceHalfLengthZ, iov_surfaceR, surfaceRstagger,
    surfaceZoverlap, layerEnvelope, volumeEnvelope, iiv_volumeR, iov_volumeR,
    "InnerOuterVolume");

// now create the Inner Container volume
double volumeHalfZ =
    (4 * surfaceHalfLengthZ - surfaceZoverlap) + volumeEnvelope;
auto iVolume = constructContainerVolume(
    tgContext, iiVolume, ioVolume, iov_volumeR, volumeHalfZ, "InnerVolume");

// outer volume definitions
double ov_surfaceR = 150_mm;
double ov_volumeR =
    ov_surfaceR + 0.5 * surfaceRstagger + layerEnvelope + volumeEnvelope;

auto oVolume = constructCylinderVolume(
    tgContext, surfaceHalfLengthZ, ov_surfaceR, surfaceRstagger,
    surfaceZoverlap, layerEnvelope, volumeEnvelope, iov_volumeR, ov_volumeR,
    "OuterVolume");
auto volume = constructContainerVolume(tgContext, iVolume, oVolume, ov_volumeR,
                                       volumeHalfZ, "WorldVolume");

// creating a TrackingGeometry
// -> closs the geometry, this should set the GeometryIdentifier
TrackingGeometry tGeometry(volume);
// get the world back
auto world = tGeometry.highestTrackingVolume();

BOOST_AUTO_TEST_CASE(GeometryIdentifier_closeGeometry_test) {
  // the lambda for checking
  auto check_vol = [](const TrackingVolume& vol,
                      GeometryIdentifier::Value geoid) {
    // check the geometry id of the volume
    BOOST_CHECK_EQUAL(geoid, vol.geometryId().volume());
    // check the geometry id of all boundary surfaces of the volume
    // - this is strictly only possible when glueing if OFF
    GeometryIdentifier::Value bsurface_id = 0;
    for (auto bSf : vol.boundarySurfaces()) {
      // check the bsurface volume id
      auto bs_vol_id = bSf->surfaceRepresentation().geometryId().volume();
      BOOST_CHECK_EQUAL(geoid, bs_vol_id);
      // check the bsurface boundary id
      auto bs_bsf_id = bSf->surfaceRepresentation().geometryId().boundary();
      BOOST_CHECK_EQUAL(++bsurface_id, bs_bsf_id);
    }
    // testing the layer and it's approach surfaces
    if (vol.confinedLayers() != nullptr) {
      // layers start are counted from 1 - n
      GeometryIdentifier::Value layer_id = 0;
      for (auto lay : vol.confinedLayers()->arrayObjects()) {
        // check the layer volume id and layer layer id
        auto lay_vol_id = lay->geometryId().volume();
        auto lay_lay_id = lay->geometryId().layer();
        BOOST_CHECK_EQUAL(++layer_id, lay_lay_id);
        BOOST_CHECK_EQUAL(geoid, lay_vol_id);
        // test the layer approach surfaces
        if (lay->approachDescriptor() != nullptr) {
          // approach surfacesare counted from 1 - n
          GeometryIdentifier::Value asurface_id = 0;
          for (auto asf : lay->approachDescriptor()->containedSurfaces()) {
            // check the approach volume id, approach layer id, approach
            // approach
            // id
            auto asf_vol_id = asf->geometryId().volume();
            auto asf_lay_id = asf->geometryId().layer();
            auto asf_asf_id = asf->geometryId().approach();
            BOOST_CHECK_EQUAL(layer_id, asf_lay_id);
            BOOST_CHECK_EQUAL(geoid, asf_vol_id);
            BOOST_CHECK_EQUAL(++asurface_id, asf_asf_id);
          }
        }
        // test the sensitive surfaces
        if (lay->surfaceArray() != nullptr) {
          // sensitive surfaces are counted from 1 - n
          GeometryIdentifier::Value ssurface_id = 0;
          for (auto ssf : lay->surfaceArray()->surfaces()) {
            // check the approach volume id, approach layer id, approach
            // approach
            // id
            auto ssf_vol_id = ssf->geometryId().volume();
            auto ssf_lay_id = ssf->geometryId().layer();
            auto ssf_ssf_id = ssf->geometryId().sensitive();
            BOOST_CHECK_EQUAL(layer_id, ssf_lay_id);
            BOOST_CHECK_EQUAL(geoid, ssf_vol_id);
            BOOST_CHECK_EQUAL(++ssurface_id, ssf_ssf_id);
          }
        }
      }
    }
  };

  // get the two volumes the world is built of
  auto ioVolumes = world->confinedVolumes()->arrayObjects();
  // check the size - has to be two volumes
  BOOST_CHECK_EQUAL(2ul, ioVolumes.size());
  // get the innermost volumes
  auto iioVolumes = ioVolumes[0]->confinedVolumes()->arrayObjects();
  // check the size - has to be two volumes
  BOOST_CHECK_EQUAL(2ul, iioVolumes.size());

  // check the world
  check_vol(*world, 1);
  // - check InnerVolume
  check_vol(*ioVolumes[0], 2);
  // -- check the InnerInnerVolume
  check_vol(*iioVolumes[0], 3);
  // -- check the InenerOuterVolume
  check_vol(*iioVolumes[1], 4);
  // - check the OuterVolume
  check_vol(*ioVolumes[1], 5);
}

BOOST_AUTO_TEST_CASE(TrackingGeometry_testVisitSurfaces) {
  // this will also cover TrackingVolume::visitSurfaces
  // its a pretty bare bones test, and only asserts that the
  // method is called on the expected number of surfaces
  size_t nSurfaces = 0;
  tGeometry.visitSurfaces([&nSurfaces](const auto*) { nSurfaces++; });

  BOOST_CHECK_EQUAL(nSurfaces, 9u);
}

}  //  end of namespace Test
}  //  end of namespace Acts