Tempus_BackwardEuler_ASA.cpp

Go to the documentation of this file.

//@HEADER
// *****************************************************************************
//          Tempus: Time Integration and Sensitivity Analysis Package
//
// Copyright 2017 NTESS and the Tempus contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
//@HEADER
 
#include "Teuchos_UnitTestHarness.hpp"
#include "Teuchos_XMLParameterListHelpers.hpp"
#include "Teuchos_TimeMonitor.hpp"
#include "Teuchos_DefaultComm.hpp"
 
#include "Tempus_config.hpp"
#include "Tempus_IntegratorBasic.hpp"
#include "Tempus_IntegratorAdjointSensitivity.hpp"
 
#include "Thyra_VectorStdOps.hpp"
#include "Thyra_MultiVectorStdOps.hpp"
 
#include "../TestModels/SinCosModel.hpp"
#include "../TestUtils/Tempus_ConvergenceTestUtils.hpp"
#include "../TestUtils/Tempus_AdjointResponseTestUtils.hpp"
 
#include "Thyra_DefaultMultiVectorProductVector.hpp"
 
#include <algorithm>
#include <vector>
#include <fstream>
#include <sstream>
#include <limits>
 
namespace Tempus_Test {
 
using Teuchos::getParametersFromXmlFile;
using Teuchos::ParameterList;
using Teuchos::RCP;
using Teuchos::sublist;
 
using Tempus::IntegratorBasic;
using Tempus::SolutionHistory;
using Tempus::SolutionState;
 
// ************************************************************
// ************************************************************
TEUCHOS_UNIT_TEST(BackwardEuler, SinCos_ASA)
{
  std::vector<double> StepSize;
  std::vector<double> ErrorNorm;
  const int nTimeStepSizes = 7;
  double dt                = 0.2;
  double order             = 0.0;
  Teuchos::RCP<const Teuchos::Comm<int> > comm =
      Teuchos::DefaultComm<int>::getComm();
  for (int n = 0; n < nTimeStepSizes; n++) {
    // Read params from .xml file
    RCP<ParameterList> pList =
        getParametersFromXmlFile("Tempus_BackwardEuler_SinCos_ASA.xml");
 
    // Setup the SinCosModel
    // Here we test using an explicit adjoint model for adjoint sensitivities
    RCP<ParameterList> scm_pl = sublist(pList, "SinCosModel", true);
    RCP<SinCosModel<double> > model =
        Teuchos::rcp(new SinCosModel<double>(scm_pl));
    RCP<SinCosModelAdjoint<double> > adjoint_model =
        Teuchos::rcp(new SinCosModelAdjoint<double>(scm_pl));
 
    dt /= 2;
 
    // Setup sensitivities
    RCP<ParameterList> pl  = sublist(pList, "Tempus", true);
    ParameterList& sens_pl = pl->sublist("Sensitivities");
    sens_pl.set("Mass Matrix Is Identity", false);  // Just for testing
    ParameterList& interp_pl = pl->sublist("Default Integrator")
                                   .sublist("Solution History")
                                   .sublist("Interpolator");
    interp_pl.set("Interpolator Type", "Lagrange");
    interp_pl.set("Order", 0);
 
    // Set FSAL to false, because it is not currently setup for ASA.
    pl->sublist("Default Stepper").set("Use FSAL", false);
 
    // Set IC consistency check to false, because it is not currently
    // setup for ASA.
    pl->sublist("Default Stepper")
        .set("Initial Condition Consistency Check", false);
 
    // Setup the Integrator and reset initial time step
    pl->sublist("Default Integrator")
        .sublist("Time Step Control")
        .set("Initial Time Step", dt);
    RCP<Tempus::IntegratorAdjointSensitivity<double> > integrator =
        Tempus::createIntegratorAdjointSensitivity<double>(pl, model,
                                                           adjoint_model);
    order = integrator->getStepper()->getOrder();
 
    // Initial Conditions
    double t0 = pl->sublist("Default Integrator")
                    .sublist("Time Step Control")
                    .get<double>("Initial Time");
    RCP<const Thyra::VectorBase<double> > x0 =
        model->getExactSolution(t0).get_x();
    const int num_param = model->get_p_space(0)->dim();
    RCP<Thyra::MultiVectorBase<double> > DxDp0 =
        Thyra::createMembers(model->get_x_space(), num_param);
    for (int i = 0; i < num_param; ++i)
      Thyra::assign(DxDp0->col(i).ptr(),
                    *(model->getExactSensSolution(i, t0).get_x()));
    integrator->initializeSolutionHistory(t0, x0, Teuchos::null, Teuchos::null,
                                          DxDp0, Teuchos::null, Teuchos::null);
 
    // Integrate to timeMax
    bool integratorStatus = integrator->advanceTime();
    TEST_ASSERT(integratorStatus)
 
    // Test if at 'Final Time'
    double time      = integrator->getTime();
    double timeFinal = pl->sublist("Default Integrator")
                           .sublist("Time Step Control")
                           .get<double>("Final Time");
    TEST_FLOATING_EQUALITY(time, timeFinal, 1.0e-14);
 
    // Time-integrated solution and the exact solution along with
    // sensitivities (relying on response g(x) = x).  Note we must transpose
    // dg/dp since the integrator returns it in gradient form.
    RCP<const Thyra::VectorBase<double> > x         = integrator->getX();
    RCP<const Thyra::MultiVectorBase<double> > DgDp = integrator->getDgDp();
    RCP<Thyra::MultiVectorBase<double> > DxDp =
        Thyra::createMembers(model->get_x_space(), num_param);
    {
      Thyra::ConstDetachedMultiVectorView<double> dgdp_view(*DgDp);
      Thyra::DetachedMultiVectorView<double> dxdp_view(*DxDp);
      const int num_g = DgDp->domain()->dim();
      for (int i = 0; i < num_g; ++i)
        for (int j = 0; j < num_param; ++j) dxdp_view(i, j) = dgdp_view(j, i);
    }
    RCP<const Thyra::VectorBase<double> > x_exact =
        model->getExactSolution(time).get_x();
    RCP<Thyra::MultiVectorBase<double> > DxDp_exact =
        Thyra::createMembers(model->get_x_space(), num_param);
    for (int i = 0; i < num_param; ++i)
      Thyra::assign(DxDp_exact->col(i).ptr(),
                    *(model->getExactSensSolution(i, time).get_x()));
 
    // Plot sample solution, exact solution, and adjoint solution
    if (comm->getRank() == 0 && n == nTimeStepSizes - 1) {
      typedef Thyra::DefaultProductVector<double> DPV;
      typedef Thyra::DefaultMultiVectorProductVector<double> DMVPV;
 
      std::ofstream ftmp("Tempus_BackwardEuler_SinCos_AdjSens.dat");
      RCP<const SolutionHistory<double> > solutionHistory =
          integrator->getSolutionHistory();
      for (int i = 0; i < solutionHistory->getNumStates(); i++) {
        RCP<const SolutionState<double> > solutionState = (*solutionHistory)[i];
        const double time_i                             = solutionState->getTime();
        RCP<const DPV> x_prod_plot =
            Teuchos::rcp_dynamic_cast<const DPV>(solutionState->getX());
        RCP<const Thyra::VectorBase<double> > x_plot =
            x_prod_plot->getVectorBlock(0);
        RCP<const DMVPV> adjoint_prod_plot =
            Teuchos::rcp_dynamic_cast<const DMVPV>(
                x_prod_plot->getVectorBlock(1));
        RCP<const Thyra::MultiVectorBase<double> > adjoint_plot =
            adjoint_prod_plot->getMultiVector();
        RCP<const Thyra::VectorBase<double> > x_exact_plot =
            model->getExactSolution(time_i).get_x();
        ftmp << std::fixed << std::setprecision(7) << time_i << std::setw(11)
             << get_ele(*(x_plot), 0) << std::setw(11) << get_ele(*(x_plot), 1)
             << std::setw(11) << get_ele(*(adjoint_plot->col(0)), 0)
             << std::setw(11) << get_ele(*(adjoint_plot->col(0)), 1)
             << std::setw(11) << get_ele(*(adjoint_plot->col(1)), 0)
             << std::setw(11) << get_ele(*(adjoint_plot->col(1)), 1)
             << std::setw(11) << get_ele(*(x_exact_plot), 0) << std::setw(11)
             << get_ele(*(x_exact_plot), 1) << std::endl;
      }
      ftmp.close();
    }
 
    // Calculate the error
    RCP<Thyra::VectorBase<double> > xdiff         = x->clone_v();
    RCP<Thyra::MultiVectorBase<double> > DxDpdiff = DxDp->clone_mv();
    Thyra::V_StVpStV(xdiff.ptr(), 1.0, *x_exact, -1.0, *(x));
    Thyra::V_VmV(DxDpdiff.ptr(), *DxDp_exact, *DxDp);
    StepSize.push_back(dt);
    double L2norm = Thyra::norm_2(*xdiff);
    L2norm *= L2norm;
    Teuchos::Array<double> L2norm_DxDp(num_param);
    Thyra::norms_2(*DxDpdiff, L2norm_DxDp());
    for (int i = 0; i < num_param; ++i)
      L2norm += L2norm_DxDp[i] * L2norm_DxDp[i];
    L2norm = std::sqrt(L2norm);
    ErrorNorm.push_back(L2norm);
 
    // out << " n = " << n << " dt = " << dt << " error = " << L2norm
    //     << std::endl;
  }
 
  // Check the order and intercept
  double slope = computeLinearRegressionLogLog<double>(StepSize, ErrorNorm);
  out << "  Stepper = BackwardEuler" << std::endl;
  out << "  =========================" << std::endl;
  out << "  Expected order: " << order << std::endl;
  out << "  Observed order: " << slope << std::endl;
  out << "  =========================" << std::endl;
  TEST_FLOATING_EQUALITY(slope, order, 0.015);
  TEST_FLOATING_EQUALITY(ErrorNorm[0], 0.142525, 1.0e-4);
 
  if (comm->getRank() == 0) {
    std::ofstream ftmp("Tempus_BackwardEuler_SinCos_AdjSens-Error.dat");
    double error0 = 0.8 * ErrorNorm[0];
    for (int n = 0; n < nTimeStepSizes; n++) {
      ftmp << StepSize[n] << "   " << ErrorNorm[n] << "   "
           << error0 * (StepSize[n] / StepSize[0]) << std::endl;
    }
    ftmp.close();
  }
}
 
// ************************************************************
// ************************************************************
// Adjoint sensitivities of the time-integrated response
// J = int_{t0}^{T} x(t) dt.
TEUCHOS_UNIT_TEST(BackwardEuler, SinCos_ASA_TimeIntegral)
{
  std::vector<double> StepSize, ErrorNorm;
  double order = 0.0;
  computeSinCosAdjointResponseErrors(
      "Tempus_BackwardEuler_SinCos_ASA.xml",
      [](ParameterList& pl) {
        pl.sublist("Sensitivities").set("Mass Matrix Is Identity", false);
      },
      "Time Integral", std::vector<double>(), 6, 0.1, true, StepSize,
      ErrorNorm, order, out, success);
 
  const double slope = computeLinearRegressionLogLog<double>(StepSize, ErrorNorm);
  out << "  Expected order: " << order << "  Observed order: " << slope << std::endl;
  TEST_FLOATING_EQUALITY(slope, order, 0.04);
}
 
// ************************************************************
// ************************************************************
// Adjoint sensitivities of the response J = sum_k x(t_k), with response times
// on the time grid, including the initial and final times.
TEUCHOS_UNIT_TEST(BackwardEuler, SinCos_ASA_SumOverTimes)
{
  std::vector<double> StepSize, ErrorNorm;
  double order = 0.0;
  computeSinCosAdjointResponseErrors(
      "Tempus_BackwardEuler_SinCos_ASA.xml",
      [](ParameterList& pl) {
        pl.sublist("Sensitivities").set("Mass Matrix Is Identity", false);
      },
      "Sum Over Times", {0.1, 0.4, 0.7, 1.0}, 6, 0.1, true, StepSize,
      ErrorNorm, order, out, success);
 
  const double slope = computeLinearRegressionLogLog<double>(StepSize, ErrorNorm);
  out << "  Expected order: " << order << "  Observed order: " << slope << std::endl;
  TEST_FLOATING_EQUALITY(slope, order, 0.04);
}
 
// ************************************************************
// ************************************************************
// Same as SinCos_ASA_SumOverTimes, with a response time that is not on the
// time grid.  With "Variable" time steps the forward time steps land on it.
TEUCHOS_UNIT_TEST(BackwardEuler, SinCos_ASA_SumOverTimes_Variable)
{
  std::vector<double> StepSize, ErrorNorm;
  double order = 0.0;
  computeSinCosAdjointResponseErrors(
      "Tempus_BackwardEuler_SinCos_ASA.xml",
      [](ParameterList& pl) {
        pl.sublist("Sensitivities").set("Mass Matrix Is Identity", false);
        // Variable time steps, which only change to land on time events
        ParameterList& tscs = pl.sublist("Default Integrator")
                                  .sublist("Time Step Control")
                                  .sublist("Time Step Control Strategy");
        tscs.set("Strategy Type", "Basic VS");
        tscs.set("Amplification Factor", 1.5);
        tscs.set("Reduction Factor", 0.5);
        tscs.set("Minimum Value Monitoring Function", 0.0);
        tscs.set("Maximum Value Monitoring Function", 1.0e+10);
      },
      "Sum Over Times", {0.1 + 1.0 / 3.0, 0.8, 1.0}, 6, 0.1, true, StepSize,
      ErrorNorm, order, out, success);
 
  const double slope = computeLinearRegressionLogLog<double>(StepSize, ErrorNorm);
  out << "  Expected order: " << order << "  Observed order: " << slope << std::endl;
  TEST_FLOATING_EQUALITY(slope, order, 0.04);
}
 
// ************************************************************
// ************************************************************
// With "Constant" time steps (the default time step control strategy), a
// response time that is not on the time grid is an error.
TEUCHOS_UNIT_TEST(BackwardEuler, SinCos_ASA_SumOverTimes_OffGrid)
{
  std::vector<double> StepSize, ErrorNorm;
  double order = 0.0;
  TEST_THROW(computeSinCosAdjointResponseErrors(
                 "Tempus_BackwardEuler_SinCos_ASA.xml",
                 [](ParameterList& pl) {
                   pl.sublist("Sensitivities")
                       .set("Mass Matrix Is Identity", false);
                 },
                 "Sum Over Times", {0.1 + 1.0 / 3.0, 1.0}, 1, 0.1, true,
                 StepSize, ErrorNorm, order, out, success),
             std::logic_error);
}
 
// ************************************************************
// ************************************************************
// NOX row sum scaling ("Function Scaling" = "Row Sum") of the nonlinear solves
// of the forward and adjoint problems, with the explicit adjoint model.  The
// forward and adjoint integrators are created from the same parameters, in
// which the forward solver stores its row sum scaling objects (in the forward
// residual space), and the adjoint operator, a blocked operator with a scaled
// identity block, must support the row sums and the scaling.  The problem is
// linear and the linear solves are direct, so the errors are those without
// scaling.
TEUCHOS_UNIT_TEST(BackwardEuler, SinCos_ASA_RowSumScaling)
{
  const std::vector<double> responseTimes = {0.4, 1.0};
 
  // Parameters with or without row sum scaling
  auto configure = [](const bool rowSumScaling) {
    return [rowSumScaling](ParameterList& pl) {
      pl.sublist("Sensitivities").set("Mass Matrix Is Identity", false);
      if (rowSumScaling)
        pl.sublist("Default Stepper")
            .sublist("Default Solver")
            .sublist("NOX")
            .sublist("Thyra Group Options")
            .set("Function Scaling", "Row Sum");
    };
  };
 
  std::vector<double> StepSize, ErrorNorm, StepSizeScaled, ErrorNormScaled;
  double order = 0.0;
  computeSinCosAdjointResponseErrors(
      "Tempus_BackwardEuler_SinCos_ASA.xml", configure(false),
      "Sum Over Times", responseTimes, 3, 0.1, true, StepSize, ErrorNorm,
      order, out, success);
  computeSinCosAdjointResponseErrors(
      "Tempus_BackwardEuler_SinCos_ASA.xml", configure(true), "Sum Over Times",
      responseTimes, 3, 0.1, true, StepSizeScaled, ErrorNormScaled, order, out,
      success);
 
  TEST_EQUALITY(ErrorNormScaled.size(), ErrorNorm.size());
  for (std::size_t n = 0; n < std::min(ErrorNorm.size(), ErrorNormScaled.size());
       ++n)
    TEST_FLOATING_EQUALITY(ErrorNormScaled[n], ErrorNorm[n], 1.0e-8);
}
 
}  // namespace Tempus_Test