HelicityKinematics.hpp

Go to the documentation of this file.

// Copyright (c) 2013, 2017 The ComPWA Team.
// This file is part of the ComPWA framework, check
// https://github.com/ComPWA/ComPWA/license.txt for details.

#ifndef PHYSICS_HELICITYFORMALISM_HELICITYKINEMATICS_HPP_
#define PHYSICS_HELICITYFORMALISM_HELICITYKINEMATICS_HPP_

#include <vector>

#include "Core/Kinematics.hpp"
#include "Physics/ParticleStateTransitionKinematicsInfo.hpp"
#include "Physics/SubSystem.hpp"

namespace ComPWA {
namespace Physics {
namespace HelicityFormalism {

class HelicityKinematics : public ComPWA::Kinematics {
public:
  HelicityKinematics(ParticleStateTransitionKinematicsInfo KinInfo,
                     double PhspVol);
  HelicityKinematics(ParticleStateTransitionKinematicsInfo KinInfo);
  HelicityKinematics(ComPWA::ParticleList partL, std::vector<pid> initialState,
                     std::vector<pid> finalState,
                     ComPWA::FourMomentum cmsP4 = ComPWA::FourMomentum(0, 0, 0,
                                                                       0));

  HelicityKinematics(const HelicityKinematics &that) = delete;
  // explicitly default the move constructor because copy constructor was
  // explicitly deleted and that prevents the automatic creation
  HelicityKinematics(HelicityKinematics &&that) = default;

  std::pair<double, double>
  calculateHelicityAngles(const Event &Event, const SubSystem &SubSys) const;

  double calculateInvariantMassSquared(const Event &Event,
                                       const IndexList &FinalStateIDs) const;

  ComPWA::Data::DataSet convert(const EventCollection &Events) const final;

  EventCollection reduceToPhaseSpace(const EventCollection &Events) const final;

  std::string registerInvariantMassSquared(IndexList System);
  std::pair<std::string, std::string> registerHelicityAngles(SubSystem System);

  void createAllSubsystems();

  std::tuple<std::string, std::string, std::string>
  registerSubSystem(const SubSystem &NewSys);

  std::tuple<std::string, std::string, std::string>
  registerSubSystem(const std::vector<unsigned int> &FinalA,
                    const std::vector<unsigned int> &FinalB,
                    const std::vector<unsigned int> &Recoil,
                    const std::vector<unsigned int> &ParentRecoil);

  const std::pair<double, double> &
  getInvariantMassBounds(const std::string &InvariantMassName) const;

  double phspVolume() const;

  const ParticleStateTransitionKinematicsInfo &
  getParticleStateTransitionKinematicsInfo() const {
    return KinematicsInfo;
  }

  const std::vector<pid> &getFinalStatePIDs() const override {
    return KinematicsInfo.getFinalStatePIDs();
  }

private:
  ParticleStateTransitionKinematicsInfo KinematicsInfo;

  double PhspVolume;

  std::unordered_map<SubSystem, std::pair<std::string, std::string>> Subsystems;

  std::unordered_map<IndexList, std::string> InvariantMassesSquared;

  std::unordered_map<std::string, std::pair<double, double>> InvMassBounds;

  std::pair<double, double>
  calculateInvMassBounds(const IndexList &FinalStateIDs) const;
};

} // namespace HelicityFormalism
} // namespace Physics
} // namespace ComPWA

#endif