CalorimeterConstants.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-3.0-or-later
// Copyright (C) CERN for the benefit of the SHiP Collaboration
 
#pragma once
 
#include <array>
#include <span>
 
namespace SHiPGeometry::Calo {
 
enum class LayerCode {
    WidePVT_H,   
    WidePVT_V,   
    ThinPS_H,    
    ThinPS_V,    
    FibreHPL_Y,  
    FibreHPL_X,  
    Absorber,    
    AirGap,      
};
 
// ── Module geometry (mm) ────────────────────────────────────────────────
inline constexpr double kPlateXY = 2160.0;
inline constexpr double kLeadThickness = 3.0;
inline constexpr double kScintThickness = 10.0;
inline constexpr double kHplThickness = 10.0;
inline constexpr double kFiberDiameter = 1.2;
inline constexpr double kFiberCoreDiameter = 1.0;
inline constexpr double kIronThickness = 170.0;
 
inline constexpr double kAirGap = 1000.0;
inline constexpr double kGapEcalHcal = 100.0;
 
// Bar pitch (physical constant, independent of plate size)
inline constexpr double kWidePVTBarPitch = 60.0;
inline constexpr double kThinPSBarPitch = 10.0;
 
// Module tiling: modules touch (pitch = plate size)
inline constexpr int kModuleNX = 2;
inline constexpr int kModuleNY = 3;
inline constexpr double kModulePitchX = kPlateXY;
inline constexpr double kModulePitchY = kPlateXY;
 
// ── Layer sequences ─────────────────────────────────────────────────────
//
//  The `using enum` is confined to each initialiser: at namespace scope in a
//  public header it would make Absorber, AirGap, WidePVT_H ... visible
//  unqualified throughout SHiPGeometry::Calo for every includer, which is most
//  of what enum class is for.
 
inline constexpr auto kEcalLayers = [] {
    using enum LayerCode;
    return std::array{
        // clang-format off
    Absorber, WidePVT_H, Absorber, WidePVT_V, Absorber, ThinPS_H, Absorber, ThinPS_V,
    Absorber, WidePVT_H, Absorber, WidePVT_V, Absorber, ThinPS_H, Absorber, ThinPS_V,
    Absorber, WidePVT_H, Absorber, WidePVT_V,
    FibreHPL_Y, FibreHPL_X, AirGap,
    Absorber, ThinPS_H, Absorber, ThinPS_V, Absorber, WidePVT_H, Absorber, WidePVT_V,
    FibreHPL_Y, FibreHPL_X,
    Absorber, ThinPS_H, Absorber, ThinPS_V, Absorber, WidePVT_H, Absorber, WidePVT_V,
    FibreHPL_Y, FibreHPL_X,
    Absorber, ThinPS_H, Absorber, ThinPS_V, Absorber, WidePVT_H, Absorber, WidePVT_V,
    FibreHPL_Y, FibreHPL_X,
    Absorber, ThinPS_H, Absorber, ThinPS_V, Absorber, WidePVT_H, Absorber, WidePVT_V,
    Absorber, ThinPS_H, Absorber, ThinPS_V, Absorber, WidePVT_H, Absorber, WidePVT_V,
    Absorber, ThinPS_H, Absorber, ThinPS_V, Absorber, WidePVT_H, Absorber, WidePVT_V,
    Absorber, ThinPS_H, Absorber, ThinPS_V,
    Absorber, WidePVT_H, Absorber, WidePVT_V, Absorber, ThinPS_H, Absorber, ThinPS_V,
        // clang-format on
    };
}();
 
inline constexpr auto kHcalLayers = [] {
    using enum LayerCode;
    return std::array{
        Absorber,  WidePVT_H, Absorber,  WidePVT_V, Absorber,
        WidePVT_H, Absorber,  WidePVT_V, Absorber,  WidePVT_H,
    };
}();
 
// ── Fixed container envelope ────────────────────────────────────────────
// These match the SHiP subsystem envelope from subsystem_envelopes.csv
// and must not change — tests and the consistency check depend on them.
inline constexpr double kContainerHalfX = 3000.0;  // 3.00 m
inline constexpr double kContainerHalfY = 3500.0;  // 3.50 m
inline constexpr double kContainerHalfZ = 1450.0;  // 1.45 m
 
// ── Derived quantities ──────────────────────────────────────────────────
 
constexpr double layerThickness(LayerCode code, double absorberThickness) {
    using enum LayerCode;
    switch (code) {
        case Absorber:
            return absorberThickness;
        case WidePVT_H:
        case WidePVT_V:
        case ThinPS_H:
        case ThinPS_V:
            return kScintThickness;
        case FibreHPL_Y:
        case FibreHPL_X:
            return kHplThickness;
        case AirGap:
            return kAirGap;
    }
    return 0.0;  // unreachable: all enumerators covered (-Wswitch)
}
 
constexpr double sectionZ(std::span<const LayerCode> codes, double absorberThickness) {
    double z = 0.0;
    for (LayerCode code : codes)
        z += layerThickness(code, absorberThickness);
    return z;
}
 
inline constexpr double kTotalStackZ =
    sectionZ(kEcalLayers, kLeadThickness) + kGapEcalHcal + sectionZ(kHcalLayers, kIronThickness);
 
constexpr int sectionVolumeCount(std::span<const LayerCode> codes) {
    using enum LayerCode;
    int n = 0;
    for (LayerCode code : codes)
        n += code == AirGap ? 0 : 1;
    return n;
}
 
inline constexpr int kVolsPerModule =
    sectionVolumeCount(kEcalLayers) + sectionVolumeCount(kHcalLayers);
 
inline constexpr int kWidePVTBarCount = static_cast<int>(kPlateXY / kWidePVTBarPitch);
inline constexpr int kThinPSBarCount = static_cast<int>(kPlateXY / kThinPSBarPitch);
 
// ── Compile-time validation ──────────────────────────────────────────────
static_assert(!kEcalLayers.empty() && !kHcalLayers.empty());
static_assert(kEcalLayers.size() == 89, "transcription guard: 89 entries in the ECAL sequence");
static_assert(kModuleNX > 0 && kModuleNY > 0);
static_assert(kFiberCoreDiameter > 0.0 && kFiberCoreDiameter <= kFiberDiameter);
static_assert(kWidePVTBarCount * kWidePVTBarPitch == kPlateXY,
              "plate size must be a whole number of wide PVT bars");
static_assert(kThinPSBarCount * kThinPSBarPitch == kPlateXY,
              "plate size must be a whole number of thin PS bars");
static_assert(kTotalStackZ <= 2.0 * kContainerHalfZ, "layer stack exceeds the container in Z");
static_assert(0.5 * kPlateXY + 0.5 * (kModuleNX - 1) * kModulePitchX <= kContainerHalfX,
              "module array exceeds the container in X");
static_assert(0.5 * kPlateXY + 0.5 * (kModuleNY - 1) * kModulePitchY <= kContainerHalfY,
              "module array exceeds the container in Y");
 
}  // namespace SHiPGeometry::Calo