BeamParameters.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/dataobjects/MCInitialParticles.h>
#include <framework/logging/Logger.h>
#include <TMatrixDSym.h>
#include <Math/Vector4D.h>
 
namespace Belle2 {
  class BeamParameters: public MCInitialParticles {
 
  public:
 
    using MCInitialParticles::setLER;
    using MCInitialParticles::setHER;
    using MCInitialParticles::setVertex;
 
    BeamParameters(): MCInitialParticles(), m_covHER{0}, m_covLER{0}, m_covVertex{0}
    {
      // 14 means all the smearings turned on
      m_generationFlags = 14;
    }
 
    BeamParameters(const BeamParameters& b): MCInitialParticles(b)
    {
      std::copy_n(b.m_covHER, 6, m_covHER);
      std::copy_n(b.m_covLER, 6, m_covLER);
      std::copy_n(b.m_covVertex, 6, m_covVertex);
    }
 
    BeamParameters& operator=(const BeamParameters& b)
    {
      MCInitialParticles::operator=(b);
      std::copy_n(b.m_covHER, 6, m_covHER);
      std::copy_n(b.m_covLER, 6, m_covLER);
      std::copy_n(b.m_covVertex, 6, m_covVertex);
      return *this;
    }
 
    bool operator==(const BeamParameters& b) const
    {
      // since we only save the covariance matrices with float precision we
      // need to also do the comparison with float precision.
      auto floatcmp = [](double dbl_a, double dbl_b) { return (float)dbl_a == (float)dbl_b; };
      return MCInitialParticles::operator==(b) &&
             std::equal(m_covHER, m_covHER + 6, b.m_covHER, floatcmp) &&
             std::equal(m_covLER, m_covLER + 6, b.m_covLER, floatcmp) &&
             std::equal(m_covVertex, m_covVertex + 6, b.m_covVertex, floatcmp);
    }
 
    void setGenerationFlags(int flags) override
    {
      if (flags != 14)
        B2WARNING(R"RAW(The generation flags are not set to the default value.
 
    The default value for the generation flags is 14: a different value means
    that some smearings (beam energy, vertex position, etc.) may be turned off.
 
    This is fine only for local tests or for special MC productions, but not
    for default MC productions.)RAW");
      m_generationFlags = flags;
    }
 
    void setCovHER(const TMatrixDSym& cov) { setCovMatrix(m_covHER, cov); }
 
    void setCovLER(const TMatrixDSym& cov) { setCovMatrix(m_covLER, cov); }
 
    void setCovVertex(const TMatrixDSym& cov) { setCovMatrix(m_covVertex, cov); }
 
    void setHER(double energy, double angleX, double angleY, const std::vector<double>& cov);
 
    void setLER(double energy, double angleX, double angleY, const std::vector<double>& cov);
 
    void setVertex(const ROOT::Math::XYZVector& vertex, const std::vector<double>& cov);
 
    TMatrixDSym getCovHER() const { return getCovMatrix(m_covHER); }
 
    TMatrixDSym getCovLER() const { return getCovMatrix(m_covLER); }
 
    TMatrixDSym getCovVertex() const { return getCovMatrix(m_covVertex); }
 
    static ROOT::Math::PxPyPzEVector getFourVector(double energy, double angleX, double angleY, bool isHER);
 
  private:
 
    static void setCovMatrix(Double32_t* member, const std::vector<double>& cov, bool common);
 
    static void setCovMatrix(Double32_t* member, const TMatrixDSym& cov);
 
    static TMatrixDSym getCovMatrix(const Double32_t* member);
 
    Double32_t m_covHER[6];
 
    Double32_t m_covLER[6];
 
    Double32_t m_covVertex[6];
 
    ClassDefOverride(BeamParameters, 3);
  };
 
} //Belle2 namespace