formfactors.h

Go to the documentation of this file.

/*
 *    Copyright (c) 2015-2018
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 */
 
#ifndef SRC_INCLUDE_FORMFACTORS_H_
#define SRC_INCLUDE_FORMFACTORS_H_
 
#include <complex>
#include <string>
 
#include "constants.h"
#include "pdgcode_constants.h"
 
namespace smash {
 
inline double blatt_weisskopf_sqr(const double p_ab, const int L) {
  if (L == 0) {
    return 1.;
  }
  constexpr double R = 1. / hbarc; /* interaction radius = 1 fm */
  const double x = p_ab * R;
  const double x2 = x * x;
  if (L == 1) {
    return x2 / (1. + x2);
  }
  std::complex<double> g_prevprev(1, 0);
  std::complex<double> g_prev(1, -x);
  double numer = x2;
  for (int l = 1; l < L; l++) {
    numer *= x2;
    const auto new_g =
        static_cast<double>(2 * l + 1) * g_prev - x2 * g_prevprev;
    g_prevprev = g_prev;
    g_prev = new_g;
  }
  const double denom = std::norm(g_prev);
  return numer / denom;
}
 
inline double post_ff_sqr(double m, double M0, double srts0, double L) {
  const auto L4 = L * L * L * L;
  const auto M2 = M0 * M0;
  const auto s0 = srts0 * srts0;
  const auto sminus = (s0 - M2) * 0.5;
  const auto splus = m * m - (s0 + M2) * 0.5;
  const auto FF = (L4 + sminus * sminus) / (L4 + splus * splus);
  return FF * FF;
}
 
// electromagnetic transition form factors for the dilepton dalitz decays
 
inline double em_form_factor_ps(PdgCode pdg, double mass) {
  switch (pdg.code()) {
    case pdg::pi_z:
      return 1. + 5.5 * mass * mass;
    case pdg::eta: {
      const double lambda_eta = 0.716;
      const double m_over_eta = mass / lambda_eta;
      return 1. / (1. - m_over_eta * m_over_eta);
    }
    default:      /* η' etc */
      return 1.;  // use QED approximation
  }
}
 
inline double em_form_factor_sqr_vec(PdgCode pdg, double mass) {
  switch (pdg.code()) {
    case pdg::omega: {
      constexpr double lambda = 0.65;
      constexpr double gamma = 0.075;
      constexpr double lambda_sqr = lambda * lambda;
      constexpr double gamma_sqr = gamma * gamma;
      const double tmp = lambda_sqr - mass * mass;
      const double denom = tmp * tmp + lambda_sqr * gamma_sqr;
      return lambda_sqr * lambda_sqr / denom;
    }
    default:      /* φ etc */
      return 1.;  // use QED approximation
  }
}
 
inline double form_factor_delta(double m) {
  SMASH_UNUSED(m);
  return 3.12;
}
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_FORMFACTORS_H_