CylinderVolumeBuilder.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2016-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/.

#pragma once

#include "Acts/Definitions/Units.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/ITrackingVolumeBuilder.hpp"
#include "Acts/Geometry/ITrackingVolumeHelper.hpp"
#include "Acts/Utilities/BinningType.hpp"
#include "Acts/Utilities/Logger.hpp"

#include <algorithm>
#include <array>
#include <limits>
#include <memory>
#include <ostream>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

namespace Acts {

class IVolumeMaterial;
class ISurfaceMaterial;
class ILayerBuilder;
class IConfinedTrackingVolumeBuilder;

enum WrappingCondition {
  Undefined = 0,         
  Attaching = 1,         
  Inserting = 2,         
  Wrapping = 3,          
  CentralInserting = 4,  
  CentralWrapping = 5,   
  NoWrapping = 6         
};

struct VolumeConfig {
  bool present{false};                  
  bool wrapping{false};                 
  double rMin;                          
  double rMax;                          
  double zMin;                          
  double zMax;                          
  LayerVector layers;                   
  MutableTrackingVolumeVector volumes;  

  VolumeConfig()
      : rMin(std::numeric_limits<double>::max()),
        rMax(std::numeric_limits<double>::lowest()),
        zMin(std::numeric_limits<double>::max()),
        zMax(std::numeric_limits<double>::lowest()),
        layers() {}

  void adaptZ(const VolumeConfig& lConfig) {
    if (lConfig) {
      zMin = std::min(zMin, lConfig.zMin);
      zMax = std::max(zMax, lConfig.zMax);
    }
  }

  void adaptR(const VolumeConfig& lConfig) {
    if (lConfig) {
      rMin = std::min(rMin, lConfig.rMin);
      rMax = std::max(rMax, lConfig.rMax);
    }
  }

  void adapt(const VolumeConfig& lConfig) {
    adaptZ(lConfig);
    adaptR(lConfig);
  }

  void midPointAttachZ(VolumeConfig& lConfig) {
    if (lConfig.zMin >= zMax) {
      double zMid = 0.5 * (lConfig.zMin + zMax);
      lConfig.zMin = zMid;
      zMax = zMid;
    } else {
      double zMid = 0.5 * (zMin + lConfig.zMax);
      lConfig.zMax = zMid;
      zMin = zMid;
    }
  }

  void attachZ(const VolumeConfig& lConfig) {
    if (lConfig.zMin >= zMax) {
      zMax = lConfig.zMin;
    } else {
      zMin = lConfig.zMax;
    }
  }

  bool overlapsInR(const VolumeConfig& vConfig) const {
    if (!present) {
      return false;
    }
    return std::max(rMin, vConfig.rMin) <= std::min(rMax, vConfig.rMax);
  }

  bool overlapsInZ(const VolumeConfig& vConfig) const {
    if (!present) {
      return false;
    }
    return std::max(zMin, vConfig.zMin) <= std::min(zMax, vConfig.zMax);
  }

  bool wraps(const VolumeConfig& vConfig) const {
    if ((zMax <= vConfig.zMin) || (zMin >= vConfig.zMax)) {
      return true;
    }
    return containsInR(vConfig);
  }

  bool contains(const VolumeConfig& vConfig) const {
    return (containsInR(vConfig) && containsInZ(vConfig));
  }

  bool containsInR(const VolumeConfig& vConfig) const {
    return (rMin >= vConfig.rMax);
  }

  bool containsInZ(const VolumeConfig& vConfig) const {
    return (vConfig.zMin > zMin && vConfig.zMax < zMax);
  }

  std::string toString() const {
    std::stringstream sl;
    sl << rMin << ", " << rMax << " / " << zMin << ", " << zMax;
    return sl.str();
  }

  operator bool() const { return present; }
};

struct WrappingConfig {
 public:
  VolumeConfig nVolumeConfig;
  VolumeConfig cVolumeConfig;
  VolumeConfig pVolumeConfig;

  VolumeConfig containerVolumeConfig;

  VolumeConfig existingVolumeConfig;
  VolumeConfig fGapVolumeConfig;
  VolumeConfig sGapVolumeConfig;

  VolumeConfig externalVolumeConfig;

  // WrappingCondition
  WrappingCondition wCondition = Undefined;
  std::string wConditionScreen = "[left untouched]";

  WrappingConfig() = default;

  void configureContainerVolume() {
    // set the container to be present
    containerVolumeConfig.present = true;
    std::string wConditionAddon = "";
    // if we have more than one config present
    if ((nVolumeConfig && cVolumeConfig) || (cVolumeConfig && pVolumeConfig) ||
        (nVolumeConfig && pVolumeConfig)) {
      wCondition = Wrapping;
      wConditionScreen = "grouped to ";
    }
    // adapt the new volume config to the existing configs
    if (nVolumeConfig) {
      containerVolumeConfig.adapt(nVolumeConfig);
      wConditionScreen += "[n]";
    }
    if (cVolumeConfig) {
      containerVolumeConfig.adapt(cVolumeConfig);
      wConditionScreen += "[c]";
    }
    if (pVolumeConfig) {
      containerVolumeConfig.adapt(pVolumeConfig);
      wConditionScreen += "[p]";
    }
    // adapt the external one
    if (externalVolumeConfig) {
      containerVolumeConfig.adapt(externalVolumeConfig);
    }
    // attach the volume configs
    if (nVolumeConfig && cVolumeConfig) {
      nVolumeConfig.midPointAttachZ(cVolumeConfig);
    }
    if (cVolumeConfig && pVolumeConfig) {
      cVolumeConfig.midPointAttachZ(pVolumeConfig);
    }
    // adapt r afterwards
    // - easy if no existing volume
    // - possible if no central volume
    if (!existingVolumeConfig || !cVolumeConfig) {
      nVolumeConfig.adaptR(containerVolumeConfig);
      cVolumeConfig.adaptR(containerVolumeConfig);
      pVolumeConfig.adaptR(containerVolumeConfig);
    }
  }

  void wrapInsertAttach() {
    // action is only needed if an existing volume
    // is present
    if (existingVolumeConfig) {
      // 0 - simple attachment case
      if (!cVolumeConfig) {
        // check if it can be easily attached
        if (nVolumeConfig && nVolumeConfig.zMax < existingVolumeConfig.zMin) {
          nVolumeConfig.attachZ(existingVolumeConfig);
          // will attach the new volume(s)
          wCondition = Attaching;
          wConditionScreen = "[n attached]";
        }
        if (pVolumeConfig && pVolumeConfig.zMin > existingVolumeConfig.zMax) {
          pVolumeConfig.attachZ(existingVolumeConfig);
          // will attach the new volume(s)
          wCondition = Attaching;
          wConditionScreen = "[p attached]";
        }
        // see if inner glue volumes are needed
        if (containerVolumeConfig.rMin > existingVolumeConfig.rMin) {
          nVolumeConfig.rMin = existingVolumeConfig.rMin;
          pVolumeConfig.rMin = existingVolumeConfig.rMin;
        } else {
          fGapVolumeConfig.present = true;
          // get the zMin/zMax boundaries
          fGapVolumeConfig.adaptZ(existingVolumeConfig);
          fGapVolumeConfig.rMin = containerVolumeConfig.rMin;
          fGapVolumeConfig.rMax = existingVolumeConfig.rMin;
        }
        // see if outer glue volumes are needed
        if (containerVolumeConfig.rMax < existingVolumeConfig.rMax) {
          nVolumeConfig.rMax = existingVolumeConfig.rMax;
          pVolumeConfig.rMax = existingVolumeConfig.rMax;
        } else {
          sGapVolumeConfig.present = true;
          // get the zMin/zMax boundaries
          sGapVolumeConfig.adaptZ(existingVolumeConfig);
          sGapVolumeConfig.rMin = existingVolumeConfig.rMax;
          sGapVolumeConfig.rMax = containerVolumeConfig.rMax;
        }
      } else {
        // full wrapping or full insertion case
        if (existingVolumeConfig.rMax < containerVolumeConfig.rMin) {
          // Full wrapping case
          // - set the rMin
          nVolumeConfig.rMin = existingVolumeConfig.rMax;
          cVolumeConfig.rMin = existingVolumeConfig.rMax;
          pVolumeConfig.rMin = existingVolumeConfig.rMax;
          // - set the rMax
          nVolumeConfig.rMax = containerVolumeConfig.rMax;
          cVolumeConfig.rMax = containerVolumeConfig.rMax;
          pVolumeConfig.rMax = containerVolumeConfig.rMax;
          // will wrap the new volume(s) around existing
          wCondition = Wrapping;
          wConditionScreen = "[fully wrapped]";
        } else if (existingVolumeConfig.rMin > containerVolumeConfig.rMax) {
          // full insertion case
          // set the rMax
          nVolumeConfig.rMax = existingVolumeConfig.rMin;
          cVolumeConfig.rMax = existingVolumeConfig.rMin;
          pVolumeConfig.rMax = existingVolumeConfig.rMin;
          // set the rMin
          nVolumeConfig.rMin = containerVolumeConfig.rMin;
          cVolumeConfig.rMin = containerVolumeConfig.rMin;
          pVolumeConfig.rMin = containerVolumeConfig.rMin;
          // will insert the new volume(s) into existing
          wCondition = Inserting;
          wConditionScreen = "[fully inserted]";
        } else if (cVolumeConfig.wraps(existingVolumeConfig)) {
          // central wrapping case
          // set the rMax
          nVolumeConfig.rMax = containerVolumeConfig.rMax;
          cVolumeConfig.rMax = containerVolumeConfig.rMax;
          pVolumeConfig.rMax = containerVolumeConfig.rMax;
          // set the rMin
          nVolumeConfig.rMin = existingVolumeConfig.rMin;
          cVolumeConfig.rMin = existingVolumeConfig.rMax;
          pVolumeConfig.rMin = existingVolumeConfig.rMin;
          // set the Central Wrapping
          wCondition = CentralWrapping;
          wConditionScreen = "[centrally wrapped]";
        } else if (existingVolumeConfig.wraps(cVolumeConfig)) {
          // central insertion case
          // set the rMax
          nVolumeConfig.rMax = containerVolumeConfig.rMax;
          cVolumeConfig.rMax = existingVolumeConfig.rMin;
          pVolumeConfig.rMax = containerVolumeConfig.rMax;
          // set the rMin
          nVolumeConfig.rMin = containerVolumeConfig.rMin;
          cVolumeConfig.rMin = containerVolumeConfig.rMin;
          pVolumeConfig.rMin = containerVolumeConfig.rMin;
          // set the Central Wrapping
          wCondition = CentralWrapping;
          wConditionScreen = "[centrally inserted]";
        } else if ((existingVolumeConfig.rMax > containerVolumeConfig.rMin &&
                    existingVolumeConfig.rMin < containerVolumeConfig.rMin) ||
                   (existingVolumeConfig.rMax > containerVolumeConfig.rMax &&
                    existingVolumeConfig.rMin < containerVolumeConfig.rMax)) {
          // The volumes are overlapping this shouldn't be happening return an
          // error
          throw std::invalid_argument(
              "Volumes are overlapping, this shouldn't be happening. Please "
              "check your geometry building.");
        }

        // check if gaps are needed
        //
        // the gap reference is either the container for FULL wrapping,
        // insertion
        // or it is the centralVolume for central wrapping, insertion
        VolumeConfig referenceVolume =
            (wCondition == Wrapping || wCondition == Inserting)
                ? containerVolumeConfig
                : cVolumeConfig;
        // - at the negative sector
        if (existingVolumeConfig.zMin > referenceVolume.zMin) {
          fGapVolumeConfig.present = true;
          fGapVolumeConfig.adaptR(existingVolumeConfig);
          fGapVolumeConfig.zMin = referenceVolume.zMin;
          fGapVolumeConfig.zMax = existingVolumeConfig.zMin;
        } else {
          // adapt lower z boundary
          if (nVolumeConfig) {
            nVolumeConfig.zMin = existingVolumeConfig.zMin;
          } else if (cVolumeConfig) {
            cVolumeConfig.zMin = existingVolumeConfig.zMin;
          }
        }
        // - at the positive sector
        if (existingVolumeConfig.zMax < referenceVolume.zMax) {
          sGapVolumeConfig.present = true;
          sGapVolumeConfig.adaptR(existingVolumeConfig);
          sGapVolumeConfig.zMin = existingVolumeConfig.zMax;
          sGapVolumeConfig.zMax = referenceVolume.zMax;
        } else {
          // adapt higher z boundary
          if (pVolumeConfig) {
            pVolumeConfig.zMax = existingVolumeConfig.zMax;
          } else if (cVolumeConfig) {
            cVolumeConfig.zMax = existingVolumeConfig.zMax;
          }
        }
      }
    }
    return;
  }

  std::string toString() const {
    // for screen output
    std::stringstream sl;
    if (containerVolumeConfig) {
      sl << "New container built with       configuration: "
         << containerVolumeConfig.toString() << '\n';
    }
    // go through the new ones first
    if (nVolumeConfig) {
      sl << " - n: Negative Endcap, current configuration: "
         << nVolumeConfig.toString() << '\n';
    }
    if (cVolumeConfig) {
      sl << " - c: Barrel, current          configuration: "
         << cVolumeConfig.toString() << '\n';
    }
    if (pVolumeConfig) {
      sl << " - p: Negative Endcap, current configuration: "
         << pVolumeConfig.toString() << '\n';
    }
    if (existingVolumeConfig) {
      sl << "Existing volume with           configuration: "
         << existingVolumeConfig.toString() << '\n';
      if (fGapVolumeConfig) {
        sl << " - g1: First gap volume,       configuration : "
           << fGapVolumeConfig.toString() << '\n';
      }
      if (sGapVolumeConfig) {
        sl << " - g2: Second gap volume,      configuration : "
           << sGapVolumeConfig.toString() << '\n';
      }
      if (wCondition != Undefined) {
        sl << "WrappingCondition = " << wCondition << '\n';
      }
    }
    return sl.str();
  }
};

class CylinderVolumeBuilder : public ITrackingVolumeBuilder {
 public:
  struct Config {
    std::shared_ptr<const ITrackingVolumeHelper> trackingVolumeHelper = nullptr;
    std::string volumeName = "";
    std::shared_ptr<const IVolumeMaterial> volumeMaterial = nullptr;
    bool buildToRadiusZero = false;
    bool checkRingLayout = false;
    double ringTolerance = 0 * UnitConstants::mm;
    std::shared_ptr<const ILayerBuilder> layerBuilder = nullptr;
    std::shared_ptr<const IConfinedTrackingVolumeBuilder> ctVolumeBuilder =
        nullptr;
    std::pair<double, double> layerEnvelopeR = {1. * UnitConstants::mm,
                                                1. * UnitConstants::mm};
    double layerEnvelopeZ = 1. * UnitConstants::mm;

    // The potential boundary material (MB) options - there are 6 at maximum
    std::array<std::shared_ptr<const ISurfaceMaterial>, 6> boundaryMaterial{
        nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};

    int volumeSignature = -1;
  };

  CylinderVolumeBuilder(const Config& cvbConfig,
                        std::unique_ptr<const Logger> logger = getDefaultLogger(
                            "CylinderVolumeBuilder", Logging::INFO));

  ~CylinderVolumeBuilder() override;

  MutableTrackingVolumePtr trackingVolume(
      const GeometryContext& gctx, TrackingVolumePtr existingVolume = nullptr,
      VolumeBoundsPtr externalBounds = nullptr) const override;

  void setConfiguration(const Config& cvbConfig);

  Config getConfiguration() const;

  void setLogger(std::unique_ptr<const Logger> newLogger);

  VolumeConfig analyzeContent(
      const GeometryContext& gctx, const LayerVector& lVector,
      const MutableTrackingVolumeVector& mtvVector) const;

 private:
  Config m_cfg;

  const Logger& logger() const { return *m_logger; }

  std::unique_ptr<const Logger> m_logger;

  bool checkLayerContainment(const GeometryContext& gctx,
                             VolumeConfig& layerConfig,
                             const VolumeConfig& insideConfig,
                             const VolumeConfig& volumeConfig, int sign) const;
};

inline CylinderVolumeBuilder::Config CylinderVolumeBuilder::getConfiguration()
    const {
  return m_cfg;
}

}  // namespace Acts