EventShapeContainer.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <framework/datastore/RelationsObject.h>
#include <framework/logging/Logger.h>
 
#include <TVector3.h>
#include <TLorentzVector.h>
#include <vector>
 
namespace Belle2 {
  class EventShapeContainer : public RelationsObject {
 
  public:
 
    EventShapeContainer()
    {
      m_thrustAxis.SetXYZ(0., 0., 0.);
      m_spherocityAxis.SetXYZ(0., 0., 0.);
      m_forwardHemisphere4Momentum.SetXYZT(0., 0., 0., 0.);
      m_backwardHemisphere4Momentum.SetXYZT(0., 0., 0., 0.);
 
      m_thrustAxis.SetXYZ(0., 0., 0.);
      for (int i = 0; i < 3; i++)
        m_sphericityEigenvector[i].SetXYZ(0., 0., 0.);
    };
 
 
    // --------------------------------------
    // Setters
    // --------------------------------------
 
 
    void setSphericityEigenvector(short i, TVector3 eigenvector)
    {
      if (i < 0 || i > 2)
        B2ERROR("Invalid  EigenVector number  (n = " << i << "). You can set only 3 eigenvectors.");
      else
        m_sphericityEigenvector[i] = eigenvector;
    };
 
    void setSphericityEigenvalue(short i, float eigenvalue)
    {
      if (i < 0 || i > 2)
        B2ERROR("Invalid  EigenVector number  (n = " << i << "). You can set only 3 eigenvectors.");
      else
        m_sphericityEigenvalue[i] = eigenvalue;
    };
 
    void setFWMoment(short order, float moment)
    {
      if (order < 0 || order > 9)
        B2ERROR("Invalid Fox-Wolfram moment order (n = " << order << "). The order must be in the [0,9] range.");
      else
        m_foxWolframMoments[order] = moment;
    };
 
    void setThrust(float thrust)
    {
      m_thrust = thrust;
    };
 
    void setThrustAxis(TVector3 thrustAxis)
    {
      if (thrustAxis.Mag() < 1.E-10)
        B2WARNING("The thrust axis you are trying to set has magnitude numerically compatible with 0.");
      m_thrustAxis = (1. / thrustAxis.Mag()) * thrustAxis;
    };
 
    void setSpherocityAxis(TVector3 spherocityAxis)
    {
      if (spherocityAxis.Mag() < 1.E-10)
        B2WARNING("The spherocity axis you are trying to set has magnitude numerically compatible with 0.");
      m_spherocityAxis = (1. / spherocityAxis.Mag()) * spherocityAxis;
    };
 
    void setHarmonicMomentThrust(short order, float moment)
    {
      if (order < 0 || order > 9)
        B2ERROR("Invalid harmonic moment order. It  must be in the [0,9] range.");
      else
        m_harmonicMomentsThrust[order] = moment;
    };
 
    void setHarmonicMomentCollision(short order, float moment)
    {
      if (order < 0 || order > 9)
        B2ERROR("Invalid harmonic moment order. It  must be in the [0,9] range.");
      else
        m_harmonicMomentsCollision[order] = moment;
    };
 
    void setCleoConeThrust(short order, float moment)
    {
      if (order < 0 || order > 9)
        B2ERROR("Invalid Cleo cone order. It  must be in the [0,9] range.");
      else
        m_cleoConesThrust[order] = moment;
    };
 
    void setCleoConeCollision(short order, float moment)
    {
      if (order < 0 || order > 9)
        B2ERROR("Invalid Cleo cone order. It must be in the [0,9] range.");
      else
        m_cleoConesCollision[order] = moment;
    };
 
    void setForwardHemisphere4Momentum(TLorentzVector mom)
    {
      m_forwardHemisphere4Momentum = mom;
    };
 
    void setBackwardHemisphere4Momentum(TLorentzVector mom)
    {
      m_backwardHemisphere4Momentum = mom;
    };
 
 
    // --------------------------------------
    // Getters
    // --------------------------------------
 
 
    float getThrust() const
    {
      return m_thrust;
    };
 
    TVector3 getThrustAxis() const
    {
      return m_thrustAxis;
    };
 
    TVector3 getSpherocityAxis() const
    {
      return m_spherocityAxis;
    };
 
    float getSphericityEigenvalue(short i) const
    {
      if (i < 0 || i > 2) {
        B2ERROR("Invalid  Eigenvalue number  (n = " << i << "). There are only 3 eigenvalues...");
        return std::numeric_limits<float>::quiet_NaN();
      } else
        return m_sphericityEigenvalue[i];
    };
 
 
    TVector3 getSphericityEigenvector(short i) const
    {
      if (i < 0 || i > 2) {
        B2ERROR("Invalid  Eigenvalue number  (n = " << i << "). There are only 3 eigenvalues...");
        return TVector3(std::numeric_limits<float>::quiet_NaN(), std::numeric_limits<float>::quiet_NaN(),
                        std::numeric_limits<float>::quiet_NaN());
      } else
        return m_sphericityEigenvector[i];
    };
 
 
 
    float getFWMoment(short order) const
    {
      if (order < 0 || order > 9) {
        B2ERROR("Invalid Fox-Wolfram moment order. It must be in the [0,9] range.");
        return std::numeric_limits<float>::quiet_NaN();
      } else
        return m_foxWolframMoments[order];
    };
 
    float getHarmonicMomentCollision(short order) const
    {
      if (order < 0 || order > 9) {
        B2ERROR("Invalid harmonic moment order. It  must be in the [0,9] range.");
        return std::numeric_limits<float>::quiet_NaN();
      } else
        return m_harmonicMomentsCollision[order];
    };
 
    float getHarmonicMomentThrust(short order) const
    {
      if (order < 0 || order > 9) {
        B2ERROR("Invalid harmonic moment order. The order must be in the [0,9] range.");
        return std::numeric_limits<float>::quiet_NaN();
      } else
        return m_harmonicMomentsThrust[order];
    };
 
 
    float getCleoConeCollision(short order) const
    {
      if (order < 0 || order > 9) {
        B2ERROR("Invalid CLEO cone order. The order must be in the [0,9] range.");
        return std::numeric_limits<float>::quiet_NaN();
      } else
        return m_cleoConesCollision[order];
    };
 
    float getCleoConeThrust(short order) const
    {
      if (order < 0 || order > 9) {
        B2ERROR("Invalid CLEO cone order. The order must be in the [0,9] range.");
        return std::numeric_limits<float>::quiet_NaN();
      } else
        return m_cleoConesThrust[order];
    };
 
 
    TLorentzVector getForwardHemisphere4Momentum() const
    {
      return m_forwardHemisphere4Momentum;
    };
 
    TLorentzVector getBackwardHemisphere4Momentum() const
    {
      return m_backwardHemisphere4Momentum;
    };
 
 
  private:
 
    // Axes
    TVector3 m_thrustAxis; 
    TVector3 m_spherocityAxis; 
    // Axis-independent quantities
    TVector3 m_sphericityEigenvector[3]; 
    float m_sphericityEigenvalue[3] = {0.}; 
    float m_foxWolframMoments[10] = {0.}; 
    // Axis-dependent quantities
    float m_thrust = 0; 
    float m_harmonicMomentsThrust[10] = {0.}; 
    float m_cleoConesThrust[10] = {0.}; 
    float m_harmonicMomentsCollision[10] = {0.}; 
    float m_cleoConesCollision[10] = {0.}; 
    // Hemisphere related quantities
    TLorentzVector m_forwardHemisphere4Momentum; 
    TLorentzVector m_backwardHemisphere4Momentum; 
    ClassDef(EventShapeContainer, 1) 
  };
 
 
} // end namespace Belle2