ISurfaceMaterial.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file ISurfaceMaterial.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/Definitions/Common.hpp"
#include "Acts/Definitions/Direction.hpp"
#include "Acts/Geometry/GeometryIdentifier.hpp"
#include "Acts/Material/MaterialSlab.hpp"

#include <memory>
#include <vector>

namespace Acts {

enum MappingType { PreMapping = -1, Default = 0, PostMapping = 1, Sensor = 2 };

class ISurfaceMaterial {
 public:
  ISurfaceMaterial() = default;

  ISurfaceMaterial(double splitFactor) : m_splitFactor(splitFactor) {}

  ISurfaceMaterial(double splitFactor, Acts::MappingType mappingType)
      : m_splitFactor(splitFactor), m_mappingType(mappingType) {}

  virtual ~ISurfaceMaterial() = default;

  virtual ISurfaceMaterial& operator*=(double scale) = 0;

  virtual const MaterialSlab& materialSlab(const Vector2& lp) const = 0;

  virtual const MaterialSlab& materialSlab(const Vector3& gp) const = 0;

  virtual const MaterialSlab& materialSlab(size_t bin0, size_t bin1) const = 0;

  double factor(Direction pDir, MaterialUpdateStage mStage) const;

  MappingType mappingType() const { return m_mappingType; }

  MaterialSlab materialSlab(const Vector2& lp, Direction pDir,
                            MaterialUpdateStage mStage) const;

  MaterialSlab materialSlab(const Vector3& gp, Direction pDir,
                            MaterialUpdateStage mStage) const;

  friend std::ostream& operator<<(std::ostream& out,
                                  const ISurfaceMaterial& sm) {
    sm.toStream(out);
    return out;
  }

  virtual std::ostream& toStream(std::ostream& sl) const = 0;

 protected:
  double m_splitFactor{1.};  
  MappingType m_mappingType{
      Acts::MappingType::Default};  
};

inline double ISurfaceMaterial::factor(Direction pDir,
                                       MaterialUpdateStage mStage) const {
  if (mStage == Acts::MaterialUpdateStage::FullUpdate) {
    return 1.;
  } else if (mStage == Acts::MaterialUpdateStage::PreUpdate) {
    return pDir == Direction::Negative ? m_splitFactor : 1 - m_splitFactor;
  } else /*if (mStage == Acts::MaterialUpdateStage::PostUpdate)*/ {
    return pDir == Direction::Positive ? m_splitFactor : 1 - m_splitFactor;
  }
}

inline MaterialSlab ISurfaceMaterial::materialSlab(
    const Vector2& lp, Direction pDir, MaterialUpdateStage mStage) const {
  // The plain material properties associated to this bin
  MaterialSlab plainMatProp = materialSlab(lp);
  // Scale if you have material to scale
  if (plainMatProp) {
    double scaleFactor = factor(pDir, mStage);
    if (scaleFactor == 0.) {
      return MaterialSlab();
    }
    plainMatProp.scaleThickness(scaleFactor);
  }
  return plainMatProp;
}

inline MaterialSlab ISurfaceMaterial::materialSlab(
    const Vector3& gp, Direction pDir, MaterialUpdateStage mStage) const {
  // The plain material properties associated to this bin
  MaterialSlab plainMatProp = materialSlab(gp);
  // Scale if you have material to scale
  if (plainMatProp) {
    double scaleFactor = factor(pDir, mStage);
    if (scaleFactor == 0.) {
      return MaterialSlab();
    }
    plainMatProp.scaleThickness(scaleFactor);
  }
  return plainMatProp;
}

}  // namespace Acts