MaterialComposition.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file MaterialComposition.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 <algorithm>
#include <cassert>
#include <cstdint>
#include <vector>

namespace Acts {

class ElementFraction {
 public:
  constexpr ElementFraction(unsigned int e, float f)
      : m_element(static_cast<uint8_t>(e)),
        m_fraction(static_cast<uint8_t>(f * UINT8_MAX)) {
    assert((0u < e) and ("The atomic number must be positive"));
    assert((0.0f <= f) and (f <= 1.0f) and
           "Relative fraction must be in [0,1]");
  }
  constexpr explicit ElementFraction(unsigned int e, unsigned int w)
      : m_element(static_cast<uint8_t>(e)),
        m_fraction(static_cast<uint8_t>(w)) {
    assert((0u < e) and ("The atomic number must be positive"));
    assert((w < 256u) and "Integer weight must be in [0,256)");
  }

  ElementFraction() = delete;
  ElementFraction(ElementFraction&&) = default;
  ElementFraction(const ElementFraction&) = default;
  ~ElementFraction() = default;
  ElementFraction& operator=(ElementFraction&&) = default;
  ElementFraction& operator=(const ElementFraction&) = default;

  constexpr uint8_t element() const { return m_element; }
  constexpr float fraction() const {
    return static_cast<float>(m_fraction) / UINT8_MAX;
  }

 private:
  // element atomic number
  uint8_t m_element;
  // element fraction in the compound scaled to the [0,256) range.
  uint8_t m_fraction;

  friend constexpr bool operator==(ElementFraction lhs, ElementFraction rhs) {
    return (lhs.m_fraction == rhs.m_fraction) and
           (lhs.m_element == rhs.m_element);
  }
  friend constexpr bool operator<(ElementFraction lhs, ElementFraction rhs) {
    return lhs.m_fraction < rhs.m_fraction;
  }
  friend class MaterialComposition;
};

class MaterialComposition {
 public:
  MaterialComposition() = default;
  MaterialComposition(std::vector<ElementFraction> elements)
      : m_elements(std::move(elements)) {
    std::sort(m_elements.begin(), m_elements.end());
    // compute the total weight first
    unsigned total = 0u;
    for (auto element : m_elements) {
      total += element.m_fraction;
    }
    // compute scale factor into the [0, 256) range
    float scale = float(UINT8_MAX) / float(total);
    for (auto& element : m_elements) {
      element.m_fraction = static_cast<uint8_t>(element.m_fraction * scale);
    }
  }

  MaterialComposition(MaterialComposition&&) = default;
  MaterialComposition(const MaterialComposition&) = default;
  ~MaterialComposition() = default;
  MaterialComposition& operator=(MaterialComposition&&) = default;
  MaterialComposition& operator=(const MaterialComposition&) = default;

  // Support range-based iteration over contained elements.
  auto begin() const { return m_elements.begin(); }
  auto end() const { return m_elements.end(); }

  operator bool() const { return !m_elements.empty(); }
  std::size_t size() const { return m_elements.size(); }

 private:
  std::vector<ElementFraction> m_elements;

  friend inline bool operator==(const MaterialComposition& lhs,
                                const MaterialComposition& rhs) {
    return (lhs.m_elements == rhs.m_elements);
  }
};

}  // namespace Acts