AccumulatedMaterialProperties.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2018-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/Material/MaterialProperties.hpp"

namespace Acts {

class AccumulatedMaterialProperties {
 public:
  AccumulatedMaterialProperties() = default;

  ~AccumulatedMaterialProperties() = default;

  AccumulatedMaterialProperties(const AccumulatedMaterialProperties& amp) =
      default;

  AccumulatedMaterialProperties(AccumulatedMaterialProperties&& amp) = default;

  AccumulatedMaterialProperties& operator=(
      const AccumulatedMaterialProperties& amp) = default;

  AccumulatedMaterialProperties& operator=(
      AccumulatedMaterialProperties&& amp) = default;

  void accumulate(const MaterialProperties& amp, double pathCorrection = 1.);

  void trackAverage(bool emptyHit = false);

  std::pair<MaterialProperties, unsigned int> totalAverage();

 private:
  double m_eventPathInX0{0.};  
  double m_eventPathInL0{0.};  
  double m_eventAr{0.};        
  double m_eventZ{0.};         
  double m_eventRho{0.};       
  double m_eventPath{0.};      
  double m_eventPathCorrection{0.};  

  double m_totalPathInX0{0.};  
  double m_totalPathInL0{0.};  
  double m_totalAr{0.};        
  double m_totalZ{0.};         
  double m_totalRho{0.};       

  unsigned int m_totalEvents{0};  
};

inline void AccumulatedMaterialProperties::accumulate(
    const MaterialProperties& amp, double pathCorrection) {
  m_eventPathInX0 += amp.thicknessInX0();
  m_eventPathInL0 += amp.thicknessInL0();
  double t = amp.thickness();
  double r = amp.material().massDensity();
  m_eventPath += t;
  m_eventRho += r * t;

  m_eventAr += amp.material().Ar() * r * t;
  m_eventZ += amp.material().Z() * r * t;

  m_eventPathCorrection += pathCorrection * t;
}

inline void AccumulatedMaterialProperties::trackAverage(bool emptyHit) {
  // Increase the total event count either for empty hit or by touched hit
  if (emptyHit || m_eventPath > 0.) {
    ++m_totalEvents;
  }

  // Average the event quantities
  if (m_eventPath > 0. && m_eventRho > 0.) {
    m_eventPathCorrection /= m_eventPath;
    m_totalPathInX0 += m_eventPathInX0 / m_eventPathCorrection;
    m_totalPathInL0 += m_eventPathInL0 / m_eventPathCorrection;
    m_totalAr += (m_eventAr / m_eventRho);
    m_totalZ += (m_eventZ / m_eventRho);
    m_totalRho += (m_eventRho);
  }
  m_eventPathInX0 = 0.;
  m_eventPathInL0 = 0.;
  m_eventAr = 0.;
  m_eventZ = 0.;
  m_eventRho = 0.;
  m_eventPath = 0.;
  m_eventPathCorrection = 0.;
}

inline std::pair<MaterialProperties, unsigned int>
AccumulatedMaterialProperties::totalAverage() {
  if (m_totalEvents > 0 && m_totalPathInX0 > 0.) {
    double eventScalor = 1. / m_totalEvents;
    m_totalPathInX0 *= eventScalor;
    m_totalPathInL0 *= eventScalor;
    m_totalRho *= eventScalor;
    m_totalAr *= eventScalor;
    m_totalZ *= eventScalor;
    // Create the material
    double X0 = 1. / m_totalPathInX0;
    double L0 = 1. / m_totalPathInL0;
    // Create the material properties - fixed to unit path length
    MaterialProperties averageMat(X0, L0, m_totalAr, m_totalZ, m_totalRho, 1.);
    return std::pair<MaterialProperties, unsigned int>(std::move(averageMat),
                                                       m_totalEvents);
  }
  return std::pair<MaterialProperties, unsigned int>(
      MaterialProperties{Material(), 0.}, m_totalEvents);
}

}  // end of namespace Acts