testMonthlyAvgDBProfileModel.cc

Go to the documentation of this file.

#include <det/Detector.h>
#include <atm/AerosolDB.h>
#include <atm/AerosolZone.h>
#include <atm/AttSlice.h>
#include <atm/PFSlice.h>
#include <atm/MolecularZone.h>
#include <atm/ProfileResult.h>
#include <atm/MonthlyAvgDBProfileModel.h>

#include <atm/RadiosondeDBProfileModel.h>

#include <fwk/CentralConfig.h>

#include <utl/TimeStamp.h>
#include <utl/UTCDateTime.h>
#include <utl/ErrorLogger.h>

#include <cppunit/extensions/HelperMacros.h>
#include <tst/Verify.h>

#include <iostream>

using namespace std;
using namespace det;
using namespace atm;
using namespace fwk;
using namespace utl;
using namespace tst;


class testMonthlyAvgDBProfileModel : public CppUnit::TestFixture {

  CPPUNIT_TEST_SUITE(testMonthlyAvgDBProfileModel);

  CPPUNIT_TEST(testCheckUpdates);
  CPPUNIT_TEST(testHasData);
  CPPUNIT_TEST_EXCEPTION(testNoDataForTimeStamp, NoDataForModelException);
  //  CPPUNIT_TEST_EXCEPTION(testOutOfBoundsHeightVsDepth, OutOfBoundException);
  CPPUNIT_TEST_EXCEPTION(testOutOfBoundsDepthVsHeight, OutOfBoundException);
  CPPUNIT_TEST_EXCEPTION(testOutOfBoundsTemperatureVsHeight, OutOfBoundException);

  CPPUNIT_TEST(testEvaluateDepthVsHeight);
  CPPUNIT_TEST(testEvaluateHeightVsDepth);
  CPPUNIT_TEST(testEvaluateTemperatureVsHeight);
  CPPUNIT_TEST(testEvaluateDensityVsHeight);
  CPPUNIT_TEST(testEvaluateRefractionIndexVsHeight);

  CPPUNIT_TEST_SUITE_END();

private:

public:

  void setUp()
  {
    CentralConfig::GetInstance(BOOTSTRAPFILE);
    ErrorLogger::GetInstance().SetVerbosity(Verbosity::eVerbose);
  }

  void tearDown()
  {
  }

  void testHasData()
  {
    Detector::GetInstance().Update(TimeStamp());
    MonthlyAvgDBProfileModel modelWithoutData;
    modelWithoutData.Init();
    CPPUNIT_ASSERT(Verify<Equal>(modelWithoutData.HasData(), false));

    Detector::GetInstance().Update(UTCDateTime(2005, 1, 1).GetTimeStamp());
    MonthlyAvgDBProfileModel modelWithData;
    modelWithData.Init();
    CPPUNIT_ASSERT(Verify<Equal>(modelWithData.HasData(), true));
  }

  void testEvaluateDepthVsHeight()
  {
    Detector::GetInstance().Update(TimeStamp(1111112));
    const Atmosphere& theAtm = Detector::GetInstance().GetAtmosphere();
    ProfileResult prof = theAtm.EvaluateDepthVsHeight();

    CPPUNIT_ASSERT(Verify<CloseTo>(prof.Y(0.5*km), 973.732*g/cm2, 1e-3));

    CPPUNIT_ASSERT(Verify<CloseTo>(prof.Y(11.*km), 230.918*g/cm2, 1e-3));

    CPPUNIT_ASSERT(Verify<CloseTo>(prof.Y(26.5*km), 20.3484*g/cm2, 1e-3));

    CPPUNIT_ASSERT(Verify<CloseTo>(prof.Y(0.), 1033.93*g/cm2, 1e-3));

    CPPUNIT_ASSERT(Verify<CloseTo>(prof.MinX(), 0.0*m));

    // Tables extended 'by hand' in MonthlyAvgDBProfileModel at request of
    // Bruce, Bianca et al
    CPPUNIT_ASSERT(Verify<CloseTo>(prof.MaxX(), 100.*km));

// Try for heights above range officially defined in DB.  TheMonthlyAvgDBPRofileModel
// extends height vs depth and depth vs height to heights of 100km
//
    CPPUNIT_ASSERT(Verify<CloseTo>(prof.Y(100.*km), 0.001*g/cm2));
  }

  void testEvaluateHeightVsDepth()
  {
    Detector::GetInstance().Update(TimeStamp(1111112));
    const Atmosphere& theAtm = Detector::GetInstance().GetAtmosphere();
    ProfileResult heightVsDepth = theAtm.EvaluateHeightVsDepth();

    CPPUNIT_ASSERT(Verify<CloseTo>(heightVsDepth.Y(20.3484*g/cm2), 26.5*km, 1e-3));

    CPPUNIT_ASSERT(Verify<CloseTo>(heightVsDepth.Y(973.732*g/cm2), 0.5*km, 1e-3));

    CPPUNIT_ASSERT(Verify<CloseTo>(heightVsDepth.Y(230.918*g/cm2), 11.*km, 1e-3));

    ProfileResult depthVsHeight = theAtm.EvaluateDepthVsHeight();
    CPPUNIT_ASSERT(Verify<CloseTo>(
        depthVsHeight.MaxX(), heightVsDepth.Y(heightVsDepth.MinX())
        ));
    CPPUNIT_ASSERT(Verify<CloseTo>(
        depthVsHeight.MinX(), heightVsDepth.Y(heightVsDepth.MaxX())
        ));

    // Try for heights above range officially defined in DB.
    // The MonthlyAvgDBPRofileModel extends height vs depth and depth vs height
    // to heights of 100km
    CPPUNIT_ASSERT(Verify<CloseTo>(heightVsDepth.Y(0.001*g/cm2), 100.*km));
  }

  void testEvaluateTemperatureVsHeight()
  {
    Detector::GetInstance().Update(TimeStamp(1111112));
    const Atmosphere& theAtm = Detector::GetInstance().GetAtmosphere();
    ProfileResult tempVsHeight = theAtm.EvaluateTemperatureVsHeight();

    CPPUNIT_ASSERT(Verify<CloseTo>(tempVsHeight.Y(0.), 288.15*kelvin, 1e-3));

    CPPUNIT_ASSERT(Verify<CloseTo>(tempVsHeight.Y(11.5*km), 216.65*kelvin, 1e-3));

    CPPUNIT_ASSERT(Verify<CloseTo>( tempVsHeight.Y(29.5*km), 226.15*kelvin, 1e-3));
  }

  void testEvaluateDensityVsHeight()
  {
    Detector::GetInstance().Update(TimeStamp(1111112));
    const Atmosphere& theAtm = Detector::GetInstance().GetAtmosphere();
    ProfileResult densityVsHeight = theAtm.EvaluateDensityVsHeight();

    CPPUNIT_ASSERT(Verify<CloseTo>(densityVsHeight.Y(0.), 1.23*kg/m3));

    CPPUNIT_ASSERT(Verify<CloseTo>(densityVsHeight.Y(11.5*km), 0.336458*kg/m3));

    CPPUNIT_ASSERT(Verify<CloseTo>(densityVsHeight.Y(29.*km), 0.021*kg/m3));
  }

  void testEvaluateRefractionIndexVsHeight()
  {
    Detector::GetInstance().Update(TimeStamp(1111112));
    const Atmosphere& theAtm = Detector::GetInstance().GetAtmosphere();
    ProfileResult refracVsHeight = theAtm.EvaluateRefractionIndexVsHeight();

    CPPUNIT_ASSERT(Verify<CloseTo>(refracVsHeight.Y(0.), 1.00029, 1.e-3));
  }

  // deprecated

  void testCheckUpdates()
  {
    const Atmosphere& theAtm = Detector::GetInstance().GetAtmosphere();

    Detector::GetInstance().Update(UTCDateTime(2005, 1, 2, 0, 0, 0).GetTimeStamp());
    CPPUNIT_ASSERT(Verify<CloseTo>(
        theAtm.EvaluateTemperatureVsHeight().Y(1*km), 281.65*kelvin, 1e-3));

    Detector::GetInstance().Update(UTCDateTime(2005, 4, 2, 0, 0, 0).GetTimeStamp());
    CPPUNIT_ASSERT(Verify<CloseTo>(
        theAtm.EvaluateTemperatureVsHeight().Y(1*km), 2.*281.65*kelvin, 1e-3));
  }

  void testNoDataForTimeStamp()
  {
    const Atmosphere& theAtm = Detector::GetInstance().GetAtmosphere();
    Detector::GetInstance().Update(TimeStamp());
    theAtm.EvaluateTemperatureVsHeight().Y(1*km);
  }

  void testOutOfBoundsHeightVsDepth()
  {
    const Atmosphere& theAtm = Detector::GetInstance().GetAtmosphere();
    Detector::GetInstance().Update(UTCDateTime(2005, 1, 2, 0, 0, 0).GetTimeStamp());
    ProfileResult heightVsDepth = theAtm.EvaluateHeightVsDepth();

    // extended to 100 km by MonthlyAvgDBProfileModel
    heightVsDepth.Y(0.*g/cm2);
  }

  void testOutOfBoundsDepthVsHeight()
  {
    const Atmosphere& theAtm = Detector::GetInstance().GetAtmosphere();
    Detector::GetInstance().Update(UTCDateTime(2005, 1, 2, 0, 0, 0).GetTimeStamp());
    ProfileResult depthVsHeight = theAtm.EvaluateDepthVsHeight();

    // extended to 100 km by MonthlyAvgDBProfileModel
    depthVsHeight.Y(500.*km);
  }

  void testOutOfBoundsTemperatureVsHeight()
  {
    const Atmosphere& theAtm = Detector::GetInstance().GetAtmosphere();
    Detector::GetInstance().Update(UTCDateTime(2005, 1, 2, 0, 0, 0).GetTimeStamp());
    ProfileResult temperatureVsHeight = theAtm.EvaluateTemperatureVsHeight();

    // extended to 100 km by MonthlyAvgDBProfileModel
    temperatureVsHeight.Y(500.*km);
  }

};

CPPUNIT_TEST_SUITE_REGISTRATION(testMonthlyAvgDBProfileModel);