AccumulatedSurfaceMaterial.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2016-2020 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/Algebra.hpp"
#include "Acts/Material/AccumulatedMaterialSlab.hpp"
#include "Acts/Material/MaterialSlab.hpp"
#include "Acts/Utilities/BinUtility.hpp"

#include <array>
#include <cstddef>
#include <memory>
#include <vector>

namespace Acts {

class ISurfaceMaterial;

class AccumulatedSurfaceMaterial {
 public:
  using AccumulatedVector = std::vector<AccumulatedMaterialSlab>;
  using AccumulatedMatrix = std::vector<AccumulatedVector>;

  AccumulatedSurfaceMaterial(double splitFactor = 0.);

  AccumulatedSurfaceMaterial(const BinUtility& binUtility,
                             double splitFactor = 0.);

  AccumulatedSurfaceMaterial(const AccumulatedSurfaceMaterial& asma) = default;

  AccumulatedSurfaceMaterial(AccumulatedSurfaceMaterial&& asma) = default;

  AccumulatedSurfaceMaterial& operator=(AccumulatedSurfaceMaterial&& asma) =
      default;

  AccumulatedSurfaceMaterial& operator=(
      const AccumulatedSurfaceMaterial& asma) = default;

  ~AccumulatedSurfaceMaterial() = default;

  const BinUtility& binUtility() const;

  std::array<size_t, 3> accumulate(const Vector2& lp, const MaterialSlab& mp,
                                   double pathCorrection = 1.);

  std::array<size_t, 3> accumulate(const Vector3& gp, const MaterialSlab& mp,
                                   double pathCorrection = 1.);

  void trackVariance(const std::vector<std::array<size_t, 3>>& trackBins,
                     MaterialSlab slabReference, bool emptyHit = false);

  void trackVariance(const Vector3& gp, MaterialSlab slabReference,
                     bool emptyHit = false);

  void trackAverage(const std::vector<std::array<size_t, 3>>& trackBins = {},
                    bool emptyHit = false);

  void trackAverage(const Vector3& gp, bool emptyHit = false);

  std::unique_ptr<const ISurfaceMaterial> totalAverage();

  const AccumulatedMatrix& accumulatedMaterial() const;

  double splitFactor() const;

 private:
  BinUtility m_binUtility{};

  double m_splitFactor{0.};

  AccumulatedMatrix m_accumulatedMaterial;
};

inline const BinUtility& AccumulatedSurfaceMaterial::binUtility() const {
  return (m_binUtility);
}

inline const AccumulatedSurfaceMaterial::AccumulatedMatrix&
AccumulatedSurfaceMaterial::accumulatedMaterial() const {
  return (m_accumulatedMaterial);
}

inline double AccumulatedSurfaceMaterial::splitFactor() const {
  return m_splitFactor;
}
}  // namespace Acts