Particle.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2018 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/Geometry/GeometryID.hpp"
#include "Acts/Surfaces/Surface.hpp"
#include "Acts/Utilities/Definitions.hpp"
#include "Acts/Utilities/Helpers.hpp"
#include "Acts/Utilities/Units.hpp"
#include <cmath>

namespace Fatras {

typedef int pdg_type;

typedef unsigned int process_code;

typedef unsigned int barcode_type;

namespace Test {

class Particle {

public:
  Particle() = default;

  Particle(const Acts::Vector3D &position, const Acts::Vector3D &momentum,
           double m, double q, pdg_type pdg = 0, barcode_type barcode = 0,
           double startTime = 0.)
      : m_position(position), m_momentum(momentum), m_m(m), m_q(q),
        m_p(momentum.norm()), m_pT(Acts::VectorHelpers::perp(momentum)),
        m_pdg(pdg), m_barcode(barcode), m_timeStamp(startTime) {
    m_E = std::sqrt(m_p * m_p + m_m * m_m);
    m_beta = (m_p / m_E);
    m_gamma = (m_E / m_m);
  }

  void setLimits(double x0Limit, double l0Limit,
                 double timeLimit = std::numeric_limits<double>::max()) {
    m_limitInX0 = x0Limit;
    m_limitInL0 = l0Limit;
    m_timeLimit = timeLimit;
  }

  void scatter(Acts::Vector3D nmomentum) {
    m_momentum = std::move(nmomentum);
    m_pT = Acts::VectorHelpers::perp(m_momentum);
  }

  void energyLoss(double deltaE) {
    // particle falls to rest
    if (m_E - deltaE < m_m) {
      m_E = m_m;
      m_p = 0.;
      m_pT = 0.;
      m_beta = 0.;
      m_gamma = 1.;
      m_momentum = Acts::Vector3D(0., 0., 0.);
      m_alive = false;
    }
    // updatet the parameters
    m_E -= deltaE;
    m_p = std::sqrt(m_E * m_E - m_m * m_m);
    m_momentum = m_p * m_momentum.normalized();
    m_pT = Acts::VectorHelpers::perp(m_momentum);
    m_beta = (m_p / m_E);
    m_gamma = (m_E / m_m);
  }

  bool update(const Acts::Vector3D &position, const Acts::Vector3D &momentum,
              double deltaPahtX0 = 0., double deltaPahtL0 = 0.,
              double deltaTime = 0.) {
    m_position = position;
    m_momentum = momentum;
    m_p = momentum.norm();
    if (m_p) {
      m_pT = Acts::VectorHelpers::perp(momentum);
      m_E = std::sqrt(m_p * m_p + m_m * m_m);
      m_timeStamp += deltaTime;
      m_beta = (m_p / m_E);
      m_gamma = (m_E / m_m);

      // set parameters and check limits
      m_pathInX0 += deltaPahtX0;
      m_pathInL0 += deltaPahtL0;
      m_timeStamp += deltaTime;
      if (m_pathInX0 >= m_limitInX0 || m_pathInL0 >= m_limitInL0 ||
          m_timeStamp > m_timeLimit) {
        m_alive = false;
      }
    }
    return !m_alive;
  }

  const Acts::Vector3D &position() const { return m_position; }

  const Acts::Vector3D &momentum() const { return m_momentum; }

  const double p() const { return m_p; }

  const double pT() const { return m_pT; }

  const double E() const { return m_E; }

  const double m() const { return m_m; }

  const double beta() const { return m_beta; }

  const double gamma() const { return m_gamma; }

  const double q() const { return m_q; }

  const pdg_type pdg() const { return m_pdg; }

  const barcode_type barcode() const { return m_barcode; }

  const double pathInX0() const { return m_pathInX0; }

  const double limitInX0() const { return m_limitInX0; }

  const double pathInL0() const { return m_limitInX0; }

  const double limitInL0() const { return m_limitInL0; }

  operator bool() { return m_alive; }

private:
  Acts::Vector3D m_position = Acts::Vector3D(0., 0., 0.); 
  Acts::Vector3D m_momentum = Acts::Vector3D(0., 0., 0.); 

  double m_m = 0.;            
  double m_E = 0.;            
  double m_q = 0.;            
  double m_beta = 0.;         
  double m_gamma = 1.;        
  double m_p = 0.;            
  double m_pT = 0.;           
  pdg_type m_pdg = 0;         
  barcode_type m_barcode = 0; 

  double m_pathInX0 = 0.; 
  double m_limitInX0 = std::numeric_limits<double>::max(); 

  double m_pathInL0 = 0.; 
  double m_limitInL0 = std::numeric_limits<double>::max(); 

  double m_timeStamp = 0.; 
  double m_timeLimit = std::numeric_limits<double>::max(); // time limit

  bool m_alive = true; 
};

} // end of namespace Test
} // end of namespace Fatras