Tempus_UnitTest_TimeEventRangeIndex.cpp

Go to the documentation of this file.

// @HEADER
// ****************************************************************************
//                Tempus: Copyright (2017) Sandia Corporation
//
// Distributed under BSD 3-clause license (See accompanying file Copyright.txt)
// ****************************************************************************
// @HEADER

#include "Tempus_UnitTest_Utils.hpp"

#include "Tempus_TimeEventRangeIndex.hpp"

namespace Tempus_Unit_Test {

using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::rcp_const_cast;
using Teuchos::rcp_dynamic_cast;

// ************************************************************
// ************************************************************
TEUCHOS_UNIT_TEST(TimeEventRangeIndex, Default_Construction)
{
  auto te = rcp(new Tempus::TimeEventRangeIndex<double>());

  TEST_COMPARE(te->getName(), ==, "TimeEventRangeIndex (0; 0; 1)");

  // Test when everything is zero.
  TEST_COMPARE(te->getIndexStart(), ==, 0);
  TEST_COMPARE(te->getIndexStop(), ==, 0);
  TEST_COMPARE(te->getIndexStride(), ==, 1);
  TEST_COMPARE(te->getNumEvents(), ==, 1);

  // Check base class defaults (functions not implemented in
  // TimeEventRangeIndex).
  TEST_COMPARE(te->isTime(1.0), ==, false);
  TEST_COMPARE(te->timeToNextEvent(1.0), ==, te->getDefaultTime());
  TEST_COMPARE(te->timeOfNextEvent(1.0), ==, te->getDefaultTime());
  TEST_COMPARE(te->eventInRange(1.0, 4.0), ==, false);
}

// ************************************************************
// ************************************************************
TEUCHOS_UNIT_TEST(TimeEventRangeIndex, Construction)
{
  auto te = rcp(new Tempus::TimeEventRangeIndex<double>(-1, 10, 2, "TestName"));

  TEST_COMPARE(te->getName(), ==, "TestName");

  // Test when everything is zero.
  TEST_COMPARE(te->getIndexStart(), ==, -1);
  TEST_COMPARE(te->getIndexStop(), ==, 10);
  TEST_COMPARE(te->getIndexStride(), ==, 2);
  TEST_COMPARE(te->getNumEvents(), ==, 6);
}

// ************************************************************
// ************************************************************
TEUCHOS_UNIT_TEST(TimeEventRangeIndex, Basic_Accesors)
{
  auto te = rcp(new Tempus::TimeEventRangeIndex<double>());

  te->setName("TestName");
  TEST_COMPARE(te->getName(), ==, "TestName");

  // Reset start after stop.
  te->setIndexStart(1);
  TEST_COMPARE(te->getIndexStart(), ==, 1);
  TEST_COMPARE(te->getIndexStop(), ==, 1);
  TEST_COMPARE(te->getIndexStride(), ==, 1);
  TEST_COMPARE(te->getNumEvents(), ==, 1);

  // Reset stop.
  te->setIndexStop(5);
  TEST_COMPARE(te->getIndexStart(), ==, 1);
  TEST_COMPARE(te->getIndexStop(), ==, 5);
  TEST_COMPARE(te->getIndexStride(), ==, 1);
  TEST_COMPARE(te->getNumEvents(), ==, 5);

  // Reset stride.
  te->setIndexStride(2);
  TEST_COMPARE(te->getIndexStart(), ==, 1);
  TEST_COMPARE(te->getIndexStop(), ==, 5);
  TEST_COMPARE(te->getIndexStride(), ==, 2);
  TEST_COMPARE(te->getNumEvents(), ==, 3);

  // Set with index range.
  te->setIndexRange(-5, 5, 3);
  TEST_COMPARE(te->getIndexStart(), ==, -5);
  TEST_COMPARE(te->getIndexStop(), ==, 5);
  TEST_COMPARE(te->getIndexStride(), ==, 3);
  TEST_COMPARE(te->getNumEvents(), ==, 4);
}

// ************************************************************
// ************************************************************
TEUCHOS_UNIT_TEST(TimeEventRangeIndex, Stride)
{
  auto te = rcp(new Tempus::TimeEventRangeIndex<double>());
  te->setIndexStart(1);
  te->setIndexStop(5);
  TEST_COMPARE(te->getIndexStart(), ==, 1);
  TEST_COMPARE(te->getIndexStop(), ==, 5);

  // Negative stride should be reset to stop_-start_.
  te->setIndexStride(-1);
  TEST_COMPARE(te->getIndexStride(), ==, 1);
  TEST_COMPARE(te->getNumEvents(), ==, 5);

  // Large stride should be reset to stop_-start_.
  te->setIndexStride(5);
  TEST_COMPARE(te->getIndexStride(), ==, 4);
  TEST_COMPARE(te->getNumEvents(), ==, 2);
}

// ************************************************************
// ************************************************************
TEUCHOS_UNIT_TEST(TimeEventRangeIndex, isIndex)
{
  auto te = rcp(new Tempus::TimeEventRangeIndex<double>());
  te->setIndexRange(-5, 5, 3);

  // Test isIndex.
  TEST_COMPARE(te->isIndex(-6), ==, false);  // Around first event.
  TEST_COMPARE(te->isIndex(-5), ==, true);
  TEST_COMPARE(te->isIndex(-4), ==, false);

  TEST_COMPARE(te->isIndex(0), ==, false);  // Around mid event.
  TEST_COMPARE(te->isIndex(1), ==, true);
  TEST_COMPARE(te->isIndex(2), ==, false);

  TEST_COMPARE(te->isIndex(3), ==, false);  // Around last event.
  TEST_COMPARE(te->isIndex(4), ==, true);
  TEST_COMPARE(te->isIndex(5), ==, false);
}

// ************************************************************
// ************************************************************
TEUCHOS_UNIT_TEST(TimeEventRangeIndex, indexToNextEvent)
{
  auto te = rcp(new Tempus::TimeEventRangeIndex<double>());
  te->setIndexRange(-5, 5, 3);

  // Test indexToNextEvent.
  TEST_COMPARE(te->indexToNextEvent(-9), ==, 4);  //   Around first event.
  TEST_COMPARE(te->indexToNextEvent(-5), ==, 3);
  TEST_COMPARE(te->indexToNextEvent(-4), ==, 2);

  TEST_COMPARE(te->indexToNextEvent(-1), ==, 2);  //   Around mid event.
  TEST_COMPARE(te->indexToNextEvent(1), ==, 3);
  TEST_COMPARE(te->indexToNextEvent(3), ==, 1);

  TEST_COMPARE(te->indexToNextEvent(2), ==, 2);  //   Around last event.
  TEST_COMPARE(te->indexToNextEvent(4), ==, te->getDefaultIndex() - 4);
  TEST_COMPARE(te->indexToNextEvent(8), ==, te->getDefaultIndex() - 8);
}

// ************************************************************
// ************************************************************
TEUCHOS_UNIT_TEST(TimeEventRangeIndex, indexOfNextEvent)
{
  auto te = rcp(new Tempus::TimeEventRangeIndex<double>());
  te->setIndexRange(-5, 5, 3);

  // Test indexOfNextEvent.
  TEST_COMPARE(te->indexOfNextEvent(-9), ==, -5);  //   Around first event.
  TEST_COMPARE(te->indexOfNextEvent(-5), ==, -2);
  TEST_COMPARE(te->indexOfNextEvent(-4), ==, -2);

  TEST_COMPARE(te->indexOfNextEvent(-1), ==, 1);  //   Around mid event.
  TEST_COMPARE(te->indexOfNextEvent(1), ==, 4);
  TEST_COMPARE(te->indexOfNextEvent(3), ==, 4);

  TEST_COMPARE(te->indexOfNextEvent(2), ==, 4);  //   Around last event.
  TEST_COMPARE(te->indexOfNextEvent(4), ==, te->getDefaultIndex());
  TEST_COMPARE(te->indexOfNextEvent(8), ==, te->getDefaultIndex());
}

// ************************************************************
// ************************************************************
TEUCHOS_UNIT_TEST(TimeEventRangeIndex, eventInRangeIndex)
{
  auto te = rcp(new Tempus::TimeEventRangeIndex<double>());
  te->setIndexRange(-5, 5, 3);

  // Test eventInRangeIndex.
  //   Right end.
  TEST_COMPARE(te->eventInRangeIndex(-9, -6), ==,
               false);  // Around first event.
  TEST_COMPARE(te->eventInRangeIndex(-9, -5), ==, true);
  TEST_COMPARE(te->eventInRangeIndex(-9, -4), ==, true);

  TEST_COMPARE(te->eventInRangeIndex(-1, 0), ==, false);  // Around mid event.
  TEST_COMPARE(te->eventInRangeIndex(-1, 1), ==, true);
  TEST_COMPARE(te->eventInRangeIndex(-1, 2), ==, true);

  TEST_COMPARE(te->eventInRangeIndex(2, 3), ==, false);  // Around last event.
  TEST_COMPARE(te->eventInRangeIndex(2, 4), ==, true);
  TEST_COMPARE(te->eventInRangeIndex(2, 5), ==, true);

  //   Left end.
  TEST_COMPARE(te->eventInRangeIndex(-6.0, -3), ==,
               true);  // Around first event.
  TEST_COMPARE(te->eventInRangeIndex(-5.0, -3), ==, false);
  TEST_COMPARE(te->eventInRangeIndex(-4.0, -3), ==, false);

  TEST_COMPARE(te->eventInRangeIndex(-3, 0), ==, true);  // Around mid event.
  TEST_COMPARE(te->eventInRangeIndex(-2, 0), ==, false);
  TEST_COMPARE(te->eventInRangeIndex(-1, 0), ==, false);

  TEST_COMPARE(te->eventInRangeIndex(3, 8), ==, true);  // Around last event.
  TEST_COMPARE(te->eventInRangeIndex(4, 8), ==, false);
  TEST_COMPARE(te->eventInRangeIndex(5, 8), ==, false);
}

// ************************************************************
// ************************************************************
TEUCHOS_UNIT_TEST(TimeEventRangeIndex, getValidParameters)
{
  auto teri = rcp(new Tempus::TimeEventRangeIndex<double>());

  auto pl = teri->getValidParameters();

  TEST_COMPARE(pl->get<std::string>("Type"), ==, "Range Index");
  TEST_COMPARE(pl->get<std::string>("Name"), ==,
               "TimeEventRangeIndex (0; 0; 1)");
  TEST_COMPARE(pl->get<int>("Start Index"), ==, 0);
  TEST_COMPARE(pl->get<int>("Stop Index"), ==, 0);
  TEST_COMPARE(pl->get<int>("Stride Index"), ==, 1);

  {  // Ensure that parameters are "used", excluding sublists.
    std::ostringstream unusedParameters;
    pl->unused(unusedParameters);
    TEST_COMPARE(unusedParameters.str(), ==, "");
  }
}

// ************************************************************
// ************************************************************
TEUCHOS_UNIT_TEST(TimeEventRangeIndex, createTimeEventRange)
{
  // Construct parameterList similar to getValidParameters().
  Teuchos::RCP<Teuchos::ParameterList> pl =
      Teuchos::parameterList("Time Event Range Index");

  pl->set("Name", "Unit Test Time Event Range Index");
  pl->set("Type", "Range Index");
  pl->set("Start Index", -1);
  pl->set("Stop Index", 11);
  pl->set("Stride Index", 2);

  // Construct TimeEventRangeIndex from ParameterList.
  auto teri = Tempus::createTimeEventRangeIndex<double>(pl);

  teri->describe(out, Teuchos::VERB_EXTREME);

  TEST_COMPARE(teri->getName(), ==, "Unit Test Time Event Range Index");
  TEST_COMPARE(teri->getType(), ==, "Range Index");
  TEST_COMPARE(teri->getIndexStart(), ==, -1);
  TEST_COMPARE(teri->getIndexStop(), ==, 11);
  TEST_COMPARE(teri->getIndexStride(), ==, 2);
  TEST_COMPARE(teri->getNumEvents(), ==, 7);
}

}  // namespace Tempus_Unit_Test