testAugerCoordinateSystem.cc

Go to the documentation of this file.

// header for unit test testCS
#include <utl/AugerCoordinateSystem.h>
#include <utl/CoordinateSystem.h>
#include <utl/Point.h>
#include <utl/UTMPoint.h>
#include <utl/AugerUnits.h>
#include <tst/Verify.h>
#include <utl/Triple.h>

#include <cppunit/extensions/HelperMacros.h>

using namespace utl;
using namespace tst;


class testAugerCoordinateSystem : public CppUnit::TestFixture {

  CPPUNIT_TEST_SUITE(testAugerCoordinateSystem);
  CPPUNIT_TEST(testCS);
  CPPUNIT_TEST(testSiteCS);
  CPPUNIT_TEST_SUITE_END();

private:
  void
  checkOnePoint(const Point& p)
  {
    const ReferenceEllipsoid e =
      ReferenceEllipsoid::Get(ReferenceEllipsoid::eWGS84);
    double lat, lon, h;
    boost::tie(lat, lon, h) = e.PointToLatitudeLongitudeHeight(p);

    const CoordinateSystemPtr ecef = e.GetECEF();
    const CoordinateSystemPtr cs = AugerCoordinateSystem::Create(p, e, ecef);

    const Point o(0,0,0, cs);           // origin in local CS
                                        // should be the same point ...
    CPPUNIT_ASSERT(Verify<CloseTo>(
      o.GetCoordinates(ecef), p.GetCoordinates(ecef)));

    CPPUNIT_ASSERT(Verify<CloseTo>(
      p.GetCoordinates(cs), Triple(0,0,0)));

    const Point pNorth(0, 10*m, 0, cs);
    // going north should not change longitude
    CPPUNIT_ASSERT(Verify<CloseTo>(
      lon, e.PointToLatitudeLongitudeHeight(pNorth).get<1>()));
    // going north should change height only to second order
    CPPUNIT_ASSERT(Verify<CloseTo>(
      h - e.PointToLatitudeLongitudeHeight(pNorth).get<2>(), 0., 10*micrometer));

    const Point pUp(0, 0, 1*km, cs);
    // going up should change neither latitude
    CPPUNIT_ASSERT(Verify<CloseTo>(
      lat, e.PointToLatitudeLongitudeHeight(pUp).get<0>()));
    // nor longitude
    CPPUNIT_ASSERT(Verify<CloseTo>(
      lon, e.PointToLatitudeLongitudeHeight(pUp).get<1>()));
  }

public:
  void setUp() { }

  void tearDown() { }

  void
  testCS()
  {
    const ReferenceEllipsoid e =
      ReferenceEllipsoid::Get(ReferenceEllipsoid::eWGS84);
    const CoordinateSystemPtr ecef = e.GetECEF();

    const UTMPoint centralCampusUTM(6075445*m, 446954*m, 1444*m, 19, 'H', e);
    const Point centralCampus(centralCampusUTM.GetPoint());
    checkOnePoint(centralCampus);

    const CoordinateSystemPtr cs =
      AugerCoordinateSystem::Create(centralCampus, e, ecef);
    const CoordinateSystemPtr csu =
      AugerCoordinateSystem::Create(centralCampusUTM, ecef);

    CPPUNIT_ASSERT(Verify<CloseTo>(
      cs->GetTransformation().Distance(csu->GetTransformation()), 0.));

    const UTMPoint malargueOriginUTM(6060000*m, 440000*m, 0*m, 19, 'H', e);
    const Point malargueOrigin(malargueOriginUTM.GetPoint());
    checkOnePoint(malargueOrigin);
  }

  void
  testSiteCS()            // mimick the use of the auger site CS
  {
    const ReferenceEllipsoid e =
      ReferenceEllipsoid::Get(ReferenceEllipsoid::eWGS84);
    const CoordinateSystemPtr ecef = e.GetECEF();

    const UTMPoint malargueOriginUTM(6060000*m, 440000*m, 0*m, 19, 'H', e);
    const Point malargueOrigin(malargueOriginUTM.GetPoint());

    const UTMPoint centralCampusUTM(6075445*m, 446954*m, 1444*m, 19, 'H', e);
    const Point centralCampus(centralCampusUTM.GetPoint());

    // regular site CS is a base CS
    const CoordinateSystemPtr siteCS =
      AugerBaseCoordinateSystem::Create(malargueOriginUTM, ecef);

    CPPUNIT_ASSERT(Verify<CloseTo>(
      malargueOrigin.GetCoordinates(siteCS), Triple(0,0,0)));

    const CoordinateSystemPtr localCS =
      AugerCoordinateSystem::Create(centralCampus, e, siteCS);

    CPPUNIT_ASSERT(Verify<CloseTo>(
      centralCampus.GetCoordinates(localCS), Triple(0,0,0)));

    // test again for regular (non-base) CS
    const CoordinateSystemPtr siteCSnonBase =
      AugerCoordinateSystem::Create(malargueOriginUTM, ecef);

    CPPUNIT_ASSERT(Verify<CloseTo>(
      malargueOrigin.GetCoordinates(siteCSnonBase), Triple(0,0,0)));

    const CoordinateSystemPtr localCS2 =
      AugerCoordinateSystem::Create(centralCampus, e, siteCSnonBase);

    CPPUNIT_ASSERT(Verify<CloseTo>(
      centralCampus.GetCoordinates(localCS2), Triple(0,0,0)));

    // this should use the same reference system and transformation as
    // localCS2 since localCS2 is relative to a non-base CS that uses
    // the ecef as a reference system
    const CoordinateSystemPtr localCSecef =
      AugerCoordinateSystem::Create(centralCampus, e, ecef);

    CPPUNIT_ASSERT(Verify<Equal>(
      localCS2->GetReferenceSystem(), localCSecef->GetReferenceSystem()));
    CPPUNIT_ASSERT(Verify<CloseTo>(
      localCS2->GetTransformation().Distance(localCSecef->GetTransformation()), 0.));

    // now remove the CS two levels of base systems from the ECEF
    const CoordinateSystemPtr campusCS =
      AugerBaseCoordinateSystem::Create(centralCampusUTM, siteCS);

    const UTMPoint losLeonesUTM(6071794*m, 459218*m, 1444*m, 19, 'H', e);
    const Point losLeones = losLeonesUTM.GetPoint();

    const CoordinateSystemPtr llCS =
      AugerCoordinateSystem::Create(losLeonesUTM, campusCS);

    CPPUNIT_ASSERT(Verify<CloseTo>(
      losLeones.GetCoordinates(llCS), Triple(0,0,0)));

    const CoordinateSystemPtr llBaseCS =
      AugerBaseCoordinateSystem::Create(losLeonesUTM, campusCS);

    CPPUNIT_ASSERT(Verify<CloseTo>(
      losLeones.GetCoordinates(llBaseCS), Triple(0,0,0)));
  }

};


CPPUNIT_TEST_SUITE_REGISTRATION(testAugerCoordinateSystem);


// Configure (x)emacs for this file ...
// Local Variables:
// mode:c++
// compile-command: "make -C .. -k testGeometry && ../testGeometry"
// End: