/***********************************************************************//**
* @brief Compute position angle between sky directions in radians
*
* @param[in] dir Sky direction.
*
* Computes the position angle using
* \f[PA = \arctan \left(
* \frac{\sin( \alpha_1 - \alpha_0 )}
* {\cos \delta_0 \tan \delta_1 -
* \sin \delta_0 \cos(\alpha_1 - \alpha_0)} \right)\f]
* where
* \f$(\alpha_0,\delta_0)\f$ are the coordinates of the reference point, and
* \f$(\alpha_1,\delta_1)\f$ are the coordinates of sky direction for which
* the position angle is to be computed.
*
* The position angle is counted counterclockwise from north.
***************************************************************************/
double GSkyDir::posang(const GSkyDir& dir) const
{
// Initialise arguments of arctan
double arg_1;
double arg_2;
// Compute dependent on coordinate system availability. This speeds
// up things by avoiding unnecessary coordinate transformations.
if (m_has_lb && dir.m_has_lb) {
arg_1 = std::sin(dir.m_l - m_l);
arg_2 = std::cos(m_b)*std::tan(dir.m_b) - std::sin(m_b)*std::cos(dir.m_l - m_l);
}
else if (m_has_radec && dir.m_has_radec) {
arg_1 = std::sin(dir.m_ra - m_ra);
arg_2 = std::cos(m_dec)*std::tan(dir.m_dec) - std::sin(m_dec)*std::cos(dir.m_ra - m_ra);
}
else if (m_has_lb) {
arg_1 = std::sin(dir.l() - m_l);
arg_2 = std::cos(m_b)*std::tan(dir.b()) - std::sin(m_b)*std::cos(dir.l() - m_l);
}
else if (m_has_radec) {
arg_1 = std::sin(dir.ra() - m_ra);
arg_2 = std::cos(m_dec)*std::tan(dir.dec()) - std::sin(m_dec)*std::cos(dir.ra() - m_ra);
}
else {
arg_1 = std::sin(dir.ra() - ra());
arg_2 = std::cos(dec())*std::tan(dir.dec()) - std::sin(dec())*std::cos(dir.ra() - ra());
}
// Compute position angle
double pa = std::atan2(arg_1, arg_2);
// Return position angle
return pa;
}
/***********************************************************************//**
* @brief Compute angular distance between sky directions in radians
*
* @param[in] dir Sky direction to which distance is to be computed.
***************************************************************************/
double GSkyDir::dist(const GSkyDir& dir) const
{
// Initialise cosine of distance
double cosdis;
// Compute dependent on coordinate system availability. This speeds
// up things by avoiding unnecessary coordinate transformations.
if (m_has_lb && dir.m_has_lb) {
cosdis = std::sin(m_b)*std::sin(dir.m_b) +
std::cos(m_b)*std::cos(dir.m_b) * std::cos(dir.m_l - m_l);
}
else if (m_has_radec && dir.m_has_radec) {
cosdis = std::sin(m_dec)*std::sin(dir.m_dec) +
std::cos(m_dec)*std::cos(dir.m_dec) * std::cos(dir.m_ra - m_ra);
}
else if (m_has_lb) {
cosdis = std::sin(m_b)*std::sin(dir.b()) +
std::cos(m_b)*std::cos(dir.b()) * std::cos(dir.l() - m_l);
}
else if (m_has_radec) {
cosdis = sin(m_dec)*sin(dir.dec()) +
cos(m_dec)*cos(dir.dec()) * std::cos(dir.ra() - m_ra);
}
else {
cosdis = std::sin(dec())*std::sin(dir.dec()) +
std::cos(dec())*std::cos(dir.dec()) * std::cos(dir.ra() - ra());
}
// Compute distance (use argument save GTools function)
double dist = arccos(cosdis);
// Return distance
return dist;
}
/***********************************************************************//**
* @brief Equality operator
*
* @param[in] a First sky direction.
* @param[in] b Second sky direction.
*
* Compare two sky directions. If the coordinate is at the pole, the Right
* Ascension or Longitude value is irrelevant.
*
* Comparisons are done dependent on the available coordinate system. This
* speeds up things and avoids unnecessary coordinate transformations.
***************************************************************************/
bool operator==(const GSkyDir &a, const GSkyDir &b)
{
// Initialise result
bool equal = false;
// Compute dependent on coordinate system availability. This speeds
// up things by avoiding unnecessary coordinate transformations.
if (a.m_has_lb && b.m_has_lb) {
if (std::abs(a.m_b) == 90.0)
equal = (a.m_b == b.m_b);
else
equal = (a.m_b == b.m_b && a.m_l == b.m_l);
}
else if (a.m_has_radec && b.m_has_radec) {
if (std::abs(a.m_dec) == 90.0)
equal = (a.m_dec == b.m_dec);
else
equal = (a.m_dec == b.m_dec && a.m_ra == b.m_ra);
}
else if (a.m_has_lb) {
if (std::abs(a.m_b) == 90.0)
equal = (a.m_b == b.b());
else
equal = (a.m_b == b.b() && a.m_l == b.l());
}
else if (a.m_has_radec) {
if (std::abs(a.m_dec) == 90.0)
equal = (a.m_dec == b.dec());
else
equal = (a.m_dec == b.dec() && a.m_ra == b.ra());
}
else {
if (std::abs(b.dec()) == 90.0)
equal = (b.dec() == a.dec());
else
equal = (b.dec() == a.dec() && b.ra() == a.ra());
}
// Return equality
return equal;
}
