MDNormalization.cpp

        if (((kStart - ki) * (kEnd - ki) < 0)) {
          // if ki is between kStart and kEnd, then hi and li will be between
          // hStart, hEnd and lStart, lEnd and momi will be between kfmin and
          // kfmax
          double hi = fh * (ki - kStart) + hStart;
          double li = fl * (ki - kStart) + lStart;
          if ((hi >= m_hX[0]) && (hi <= m_hX[hNBins-1]) && (li >= m_lX[0]) &&
              (li <= m_lX[lNBins-1])) {
            double momi = fmom * (ki - kStart) + kfmin;
            intersections.push_back({{hi, ki, li, momi}});
          }
        }
      }
    }

    // calculate intersections with planes perpendicular to l
    if (fabs(lStart - lEnd) > eps) {
      double fmom = (kfmax - kfmin) / (lEnd - lStart);
      double fh = (hEnd - hStart) / (lEnd - lStart);
      double fk = (kEnd - kStart) / (lEnd - lStart);

      for (size_t i = 0; i < lNBins; i++) {
        double li = m_lX[i];
        if (((lStart - li) * (lEnd - li) < 0)) {
          double hi = fh * (li - lStart) + hStart;
          double ki = fk * (li - lStart) + kStart;
          if ((hi >= m_hX[0]) && (hi <= m_hX[hNBins-1]) && (ki >= m_kX[0]) &&
               (ki <= m_kX[kNBins-1])) {
            double momi = fmom * (li - lStart) + kfmin;
            intersections.push_back({{hi, ki, li, momi}});
          }
        }
      }
    }
    // intersections with dE
    if (!m_dEIntegrated) {
      for (size_t i = 0; i < eNBins; i++) {
        double kfi = m_eX[i];
        if ((kfi - kfmin) * (kfi - kfmax) <= 0) {
          double h = qin.X() - qout.X() * kfi;
          double k = qin.Y() - qout.Y() * kfi;
          double l = qin.Z() - qout.Z() * kfi;
          if ((h >= m_hX[0]) && (h <= m_hX[hNBins-1]) && (k >= m_kX[0]) && (k <= m_kX[kNBins-1]) &&
              (l >= m_lX[0]) && (l <= m_lX[lNBins-1])) {
            intersections.push_back({{h, k, l, kfi}});
          }
        }
      }
    }

    // endpoints
    if ((hStart >= m_hX[0]) && (hStart <= m_hX[hNBins-1]) && (kStart >= m_kX[0]) &&
        (kStart <= m_kX[kNBins-1]) && (lStart >= m_lX[0]) && (lStart <= m_lX[lNBins-1])) {
      intersections.push_back({{hStart, kStart, lStart, kfmin}});
    }
    if ((hEnd >= m_hX[0]) && (hEnd <= m_hX[hNBins-1]) && (kEnd >= m_kX[0]) &&
        (kEnd <= m_kX[kNBins-1]) && (lEnd >= m_lX[0]) && (lEnd <= m_lX[lNBins-1])) {
      intersections.push_back({{hEnd, kEnd, lEnd, kfmax}});
    }

    // sort intersections by final momentum
    std::stable_sort(intersections.begin(), intersections.end(), compareMomentum);
}

} // namespace MDAlgorithms
} // namespace Mantid