Tempus_UnitTest_TimeStepControlStrategyBasicVS.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_StepperFactory.hpp"
#include "Tempus_TimeStepControl.hpp"
#include "Tempus_TimeStepControlStrategyBasicVS.hpp"

#include "../TestModels/DahlquistTestModel.hpp"


namespace Tempus_Unit_Test {

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


// ************************************************************
// ************************************************************
TEUCHOS_UNIT_TEST(TimeStepControlStrategyBasicVS, Default_Construction)
{
  auto tscs = rcp(new Tempus::TimeStepControlStrategyBasicVS<double>());
  TEUCHOS_TEST_FOR_EXCEPT(!tscs->isInitialized());

  // Test the get functions (i.e., defaults).
  TEUCHOS_TEST_FOR_EXCEPT(tscs->getStrategyType() != "Basic VS");
  TEUCHOS_TEST_FOR_EXCEPT(tscs->getStepType() != "Variable");
  TEUCHOS_TEST_FOR_EXCEPT(tscs->getAmplFactor() != 1.75);
  TEUCHOS_TEST_FOR_EXCEPT(tscs->getReductFactor() != 0.5);
  TEUCHOS_TEST_FOR_EXCEPT(tscs->getMinEta() != 0.0);
  TEUCHOS_TEST_FOR_EXCEPT(tscs->getMaxEta() != 1.0e+16);

  // Test the set functions.
  tscs->setAmplFactor(1.33);    tscs->initialize();  TEUCHOS_TEST_FOR_EXCEPT(!tscs->isInitialized());
  tscs->setReductFactor(0.75);  tscs->initialize();  TEUCHOS_TEST_FOR_EXCEPT(!tscs->isInitialized());
  tscs->setMinEta(0.01);        tscs->initialize();  TEUCHOS_TEST_FOR_EXCEPT(!tscs->isInitialized());
  tscs->setMaxEta(0.05);        tscs->initialize();  TEUCHOS_TEST_FOR_EXCEPT(!tscs->isInitialized());

  TEUCHOS_TEST_FOR_EXCEPT(tscs->getAmplFactor() != 1.33);
  TEUCHOS_TEST_FOR_EXCEPT(tscs->getReductFactor() != 0.75);
  TEUCHOS_TEST_FOR_EXCEPT(tscs->getMinEta() != 0.01);
  TEUCHOS_TEST_FOR_EXCEPT(tscs->getMaxEta() != 0.05);
}


// ************************************************************
// ************************************************************
TEUCHOS_UNIT_TEST(TimeStepControlStrategyBasicVS, Full_Construction)
{
  auto tscs = rcp(new Tempus::TimeStepControlStrategyBasicVS<double>(
    1.33, 0.75, 0.01, 0.05));
  TEUCHOS_TEST_FOR_EXCEPT(!tscs->isInitialized());

  TEUCHOS_TEST_FOR_EXCEPT(tscs->getStrategyType() != "Basic VS");
  TEUCHOS_TEST_FOR_EXCEPT(tscs->getStepType() != "Variable");
  TEUCHOS_TEST_FOR_EXCEPT(tscs->getAmplFactor() != 1.33);
  TEUCHOS_TEST_FOR_EXCEPT(tscs->getReductFactor() != 0.75);
  TEUCHOS_TEST_FOR_EXCEPT(tscs->getMinEta() != 0.01);
  TEUCHOS_TEST_FOR_EXCEPT(tscs->getMaxEta() != 0.05);
}


// ************************************************************
// ************************************************************
TEUCHOS_UNIT_TEST(TimeStepControlStrategyBasicVS, Create_Construction)
{
  auto pl = Tempus::getTimeStepControlStrategyBasicVS_PL<double>();

  pl->set<double>("Amplification Factor", 1.33);
  pl->set<double>("Reduction Factor"    , 0.75);
  pl->set<double>("Minimum Value Monitoring Function", 0.01);
  pl->set<double>("Maximum Value Monitoring Function", 0.05);

  auto tscs = Tempus::createTimeStepControlStrategyBasicVS<double>(pl);

  TEUCHOS_TEST_FOR_EXCEPT(tscs->getStrategyType() != "Basic VS");
  TEUCHOS_TEST_FOR_EXCEPT(tscs->getStepType() != "Variable");
  TEUCHOS_TEST_FOR_EXCEPT(tscs->getAmplFactor() != 1.33);
  TEUCHOS_TEST_FOR_EXCEPT(tscs->getReductFactor() != 0.75);
  TEUCHOS_TEST_FOR_EXCEPT(tscs->getMinEta() != 0.01);
  TEUCHOS_TEST_FOR_EXCEPT(tscs->getMaxEta() != 0.05);
}


// ************************************************************
// ************************************************************
TEUCHOS_UNIT_TEST(TimeStepControlStrategyBasicVS, setNextTimeStep)
{
  auto tscs = rcp(new Tempus::TimeStepControlStrategyBasicVS<double>());
  tscs->setAmplFactor(1.1);
  tscs->setReductFactor(0.5);
  tscs->setMinEta(0.01);
  tscs->setMaxEta(0.05);
  tscs->initialize();
  TEUCHOS_TEST_FOR_EXCEPT(!tscs->isInitialized());

  // Setup the TimeStepControl --------------------------------
  auto tsc = rcp(new Tempus::TimeStepControl<double>());
  tsc->setTimeStepControlStrategy(tscs);
  tsc->setInitTime(0.0);
  tsc->setFinalTime(10.0);
  tsc->setMinTimeStep (0.01);
  tsc->setInitTimeStep(0.1);
  tsc->setMaxTimeStep (1.0);
  tsc->setFinalIndex(100);
  tsc->initialize();
  TEUCHOS_TEST_FOR_EXCEPT(!tsc->isInitialized());
  Tempus::Status status = Tempus::Status::WORKING;

  // Setup the SolutionHistory --------------------------------
  auto model = rcp(new Tempus_Test::DahlquistTestModel<double>());
  auto inArgsIC = model->getNominalValues();
  auto icSolution = rcp_const_cast<Thyra::VectorBase<double> >(inArgsIC.get_x());
  auto icState = Tempus::createSolutionStateX<double>(icSolution);
  auto solutionHistory = rcp(new Tempus::SolutionHistory<double>());

  // Test Reducing timestep
  {
    solutionHistory->addState(icState);
    solutionHistory->getCurrentState()->setTimeStep(0.5);
    solutionHistory->getCurrentState()->setTime(0.0);
    solutionHistory->getCurrentState()->setIndex(0);

    // Set up solution history with two time steps.
    for (int i = 0; i < 2; i++) {
      solutionHistory->initWorkingState();

      tsc->setNextTimeStep(solutionHistory, status);

      { // Mock takeStep
        auto currentState = solutionHistory->getCurrentState();
        auto workingState = solutionHistory->getWorkingState();
        auto xN   = workingState->getX();
        Thyra::Vp_S(xN.ptr(), 1.0);
        workingState->setSolutionStatus(Tempus::Status::PASSED);
        workingState->computeNorms(currentState);
      }

      solutionHistory->promoteWorkingState();
      //out << "  x = " << get_ele(*(x), 0) << std::endl;
    }

    auto currentState = solutionHistory->getCurrentState();
    TEST_FLOATING_EQUALITY( currentState->getTimeStep(), 0.25, 1.0e-14);
    TEST_FLOATING_EQUALITY( currentState->getTime(), 0.75, 1.0e-14);
  }

  // Test increasing timestep
  {
    solutionHistory->clear();
    solutionHistory->addState(icState);
    solutionHistory->getCurrentState()->setTimeStep(0.5);
    solutionHistory->getCurrentState()->setTime(0.0);
    solutionHistory->getCurrentState()->setIndex(0);

    // Set up solution history with two time steps.
    for (int i = 0; i < 2; i++) {
      solutionHistory->initWorkingState();

      tsc->setNextTimeStep(solutionHistory, status);

      { // Mock takeStep
        auto currentState = solutionHistory->getCurrentState();
        auto workingState = solutionHistory->getWorkingState();
        auto xN   = workingState->getX();
        Thyra::Vp_S(xN.ptr(), 0.0);
        workingState->setSolutionStatus(Tempus::Status::PASSED);
        workingState->computeNorms(currentState);
      }

      solutionHistory->promoteWorkingState();
      //auto x = solutionHistory->getCurrentState()->getX();
      //out << "  x = " << get_ele(*(x), 0) << std::endl;
    }

    auto currentState = solutionHistory->getCurrentState();
    TEST_FLOATING_EQUALITY( currentState->getTimeStep(), 0.55, 1.0e-14);
    TEST_FLOATING_EQUALITY( currentState->getTime(), 1.05, 1.0e-14);
  }
}


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

  auto pl = tscs->getValidParameters();

  TEST_COMPARE          ( pl->get<std::string>("Strategy Type"), ==,"Basic VS");
  TEST_FLOATING_EQUALITY( pl->get<double>("Amplification Factor"), 1.75, 1.0e-14);
  TEST_FLOATING_EQUALITY( pl->get<double>("Reduction Factor"), 0.5, 1.0e-14);
  TEST_FLOATING_EQUALITY( pl->get<double>("Minimum Value Monitoring Function"), 0.0, 1.0e-14);
  TEST_FLOATING_EQUALITY( pl->get<double>("Maximum Value Monitoring Function"), 1.0e+16, 1.0e-14);

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


} // namespace Tempus_Unit_Test