/***********************************************************************//**
* @brief Kernel for IRF azimuth angle integration of the diffuse source model
*
* @param[in] phi Azimuth angle around observed photon direction (radians).
*
* This method provides the kernel for the IRF azimuth angle integration of
* the diffuse source model.
*
* It computes
*
* \f[irf = M(\theta, \phi) Aeff(\theta, \phi) Edisp(\theta, \phi)\f]
*
* where \f$M(\theta, \phi)\f$ is the spatial component of the diffuse
* source model, \f$Aeff(\theta, \phi)\f$ is the effective area, and
* \f$Edisp(\theta, \phi)\f$ is the energy dispersion.
*
* As the coordinates \f$(\theta, \phi)\f$ are given in the reference frame
* of the observed photon direction, some coordinate transformations have
* to be performed.
*
* First, \f$(\theta, \phi)\f$ are transformed into the celestial reference
* frame using the rotation matrix.
*
* Then, the offset angle of the true photon direction is computed in the
* camera system (so far we do not compute the azimuth angle as we assume an
* azimuthally symmetric response).
*
* @todo Optimize computation of sky direction in native coordinates
* @todo Implement azimuth angle computation of true photon in camera
* @todo Replace (theta,phi) by (delta,alpha)
***************************************************************************/
double cta_irf_diffuse_kern_phi::eval(double phi)
{
// Initialise result
double irf = 0.0;
// Compute sine and cosine of azimuth angle
double sin_phi = std::sin(phi);
double cos_phi = std::cos(phi);
// Compute sky direction vector in native coordinates
GVector native(-cos_phi*m_sin_theta, sin_phi*m_sin_theta, m_cos_theta);
// Rotate from native into celestial system
GVector cel = *m_rot * native;
// Set sky direction
GSkyDir srcDir;
srcDir.celvector(cel);
// Get sky intensity for this sky direction
double intensity = m_model->eval(srcDir);
// Continue only if sky intensity is positive
if (intensity > 0.0) {
// Compute true photon offset angle in camera system [radians]
double offset = std::acos(m_cos_ph + m_sin_ph * cos_phi);
//TODO: Compute true photon azimuth angle in camera system [radians]
double azimuth = 0.0;
// Evaluate model times the effective area
irf = intensity *
m_rsp->aeff(offset, azimuth, m_zenith, m_azimuth, m_srcLogEng);
// Optionally take energy dispersion into account
if (m_rsp->hasedisp() && irf > 0.0) {
irf *= m_rsp->edisp(m_obsLogEng, offset, azimuth, m_zenith, m_azimuth, m_srcLogEng);
}
// Compile option: Check for NaN/Inf
#if defined(G_NAN_CHECK)
if (isnotanumber(irf) || isinfinite(irf)) {
std::cout << "*** ERROR: cta_irf_diffuse_kern_phi::eval";
std::cout << "(phi=" << phi << "):";
std::cout << " NaN/Inf encountered";
std::cout << " (irf=" << irf;
std::cout << ", intensity=" << intensity;
std::cout << ", offset=" << offset;
std::cout << ", azimuth=" << azimuth;
std::cout << ")";
std::cout << std::endl;
}
#endif
} // endif: sky intensity was positive
// Return
return irf;
}
/***********************************************************************//**
* @brief Kernel for Npred azimuth angle integration of diffuse model
*
* @param[in] phi Azimuth angle with respect to ROI centre (radians).
*
* @todo Re-consider formula for possible simplification (dumb matrix
* multiplication is definitely not the fastest way to do that
* computation).
***************************************************************************/
double cta_npred_diffuse_kern_phi::eval(double phi)
{
// Initialise Npred value
double npred = 0.0;
// Compute sky direction vector in native coordinates
double cos_phi = std::cos(phi);
double sin_phi = std::sin(phi);
GVector native(-cos_phi*m_sin_theta, sin_phi*m_sin_theta, m_cos_theta);
// Rotate from native into celestial system
GVector cel = *m_rot * native;
// Set sky direction
GSkyDir srcDir;
srcDir.celvector(cel);
// Get sky intensity for this sky direction
double intensity = m_model->eval(srcDir);
// Continue only if sky intensity is positive
if (intensity > 0.0) {
// Set Photon
GPhoton photon(srcDir, *m_srcEng, *m_srcTime);
// Compute Npred for this sky direction
npred = m_rsp->npred(photon, *m_obs) * intensity;
// Debug: Check for NaN
#if defined(G_NAN_CHECK)
if (isnotanumber(npred) || isinfinite(npred)) {
std::cout << "*** ERROR: cta_npred_diffuse_kern_phi::eval";
std::cout << "(phi=" << phi << "):";
std::cout << " NaN/Inf encountered";
std::cout << " (npred=" << npred;
std::cout << ", intensity=" << intensity;
std::cout << ", cos_phi=" << cos_phi;
std::cout << ", sin_phi=" << sin_phi;
std::cout << ")" << std::endl;
}
#endif
} // endif: sky intensity was positive
// Return Npred
return npred;
}
/***********************************************************************//**
* @brief Kernel for Npred azimuth angle integration of background model
*
* @param[in] phi Azimuth angle around ROI centre (radians).
*
* Computes
*
* \f[
* S_{\rm p}(\theta, \phi | E, t) \, N_{\rm pred}(\theta, \phi)
* \f]
*
* @todo Re-consider formula for possible simplification (dumb matrix
* multiplication is definitely not the fastest way to do that
* computation).
***************************************************************************/
double GCTAModelBackground::npred_roi_kern_phi::eval(const double& phi)
{
// Initialise value
double value = 0.0;
// Compute sky direction vector in native coordinates
double cos_phi = std::cos(phi);
double sin_phi = std::sin(phi);
GVector native(-cos_phi*m_sin_theta, sin_phi*m_sin_theta, m_cos_theta);
// Rotate from native into celestial system
GVector cel = m_rot * native;
// Set sky direction
GSkyDir obsDir;
obsDir.celvector(cel);
// Set Photon
GPhoton photon(obsDir, m_obsEng, m_obsTime);
// Get sky intensity for this photon
value = m_model->eval(photon);
// Debug: Check for NaN
#if defined(G_NAN_CHECK)
if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
std::cout << "*** ERROR: GCTAModelBackground::npred_roi_kern_phi::eval";
std::cout << "(phi=" << phi << "):";
std::cout << " NaN/Inf encountered";
std::cout << " (value=" << value;
std::cout << ", cos_phi=" << cos_phi;
std::cout << ", sin_phi=" << sin_phi;
std::cout << ")" << std::endl;
}
#endif
// Return Npred
return value;
}
/***********************************************************************//**
* @brief Kernel for azimuth angle Npred integration of radial model
*
* @param[in] phi Azimuth angle (radians).
*
* @todo Re-consider formula for possible simplification (dumb matrix
* multiplication is definitely not the fastest way to do that
* computation).
***************************************************************************/
double cta_npred_radial_kern_phi::eval(double phi)
{
// Compute sky direction vector in native coordinates
double cos_phi = std::cos(phi);
double sin_phi = std::sin(phi);
GVector native(-cos_phi*m_sin_theta, sin_phi*m_sin_theta, m_cos_theta);
// Rotate from native into celestial system
GVector cel = *m_rot * native;
// Set sky direction
GSkyDir srcDir;
srcDir.celvector(cel);
// Set Photon
GPhoton photon(srcDir, *m_srcEng, *m_srcTime);
// Compute Npred for this sky direction
double npred = m_rsp->npred(photon, *m_obs);
// Debug: Check for NaN
#if defined(G_NAN_CHECK)
if (isnotanumber(npred) || isinfinite(npred)) {
std::cout << "*** ERROR: cta_npred_radial_kern_phi::eval";
std::cout << "(phi=" << phi << "):";
std::cout << " NaN/Inf encountered";
std::cout << " (npred=" << npred;
std::cout << ", cos_phi=" << cos_phi;
std::cout << ", sin_phi=" << sin_phi;
std::cout << ")" << std::endl;
}
#endif
// Return Npred
return npred;
}
