Disabled mesh-dependent time stepping for unstructured meshes (08ad6971) · Commits · TNL / tnl-dev

src/TNL/Solvers/PDE/CMakeLists.txt

+1 −0

Original line number	Diff line number	Diff line
		@@ -4,6 +4,7 @@ SET( headers BackwardTimeDiscretisation.h
		ExplicitTimeStepper_impl.h
		ExplicitUpdater.h
		LinearSystemAssembler.h
		MeshDependentTimeSteps.h
		NoTimeDiscretisation.h
		PDESolver.h
		PDESolver_impl.h

src/TNL/Solvers/PDE/MeshDependentTimeSteps.h

0 → 100644

+92 −0

Original line number	Diff line number	Diff line
		/***************************************************************************
		MeshDependentTimeSteps.h - description
		-------------------
		begin : Jan 26, 2017
		copyright : (C) 2017 by Tomas Oberhuber et al.
		email : tomas.oberhuber@fjfi.cvut.cz
		***************************************************************************/

		/* See Copyright Notice in tnl/Copyright */

		#pragma once

		#include <TNL/Meshes/Grid.h>
		#include <TNL/Meshes/Mesh.h>

		namespace TNL {
		namespace Solvers {
		namespace PDE {

		template< typename Mesh, typename Real >
		class MeshDependentTimeSteps
		{
		};

		template< int Dimension,
		typename MeshReal,
		typename Device,
		typename MeshIndex,
		typename Real >
		class MeshDependentTimeSteps< TNL::Meshes::Grid< Dimension, MeshReal, Device, MeshIndex >, Real >
		{
		public:
		using MeshType = TNL::Meshes::Grid< Dimension, MeshReal, Device, MeshIndex >;

		bool setTimeStepOrder( const Real& timeStepOrder )
		{
		if( timeStepOrder < 0 ) {
		std::cerr << "The time step order for PDESolver must be zero or positive value." << std::endl;
		return false;
		}
		this->timeStepOrder = timeStepOrder;
		return true;
		}

		const Real& getTimeStepOrder() const
		{
		return timeStepOrder;
		}

		Real getRefinedTimeStep( const MeshType& mesh, const Real& timeStep )
		{
		return timeStep * std::pow( mesh.getSmallestSpaceStep(), this->timeStepOrder );
		}

		protected:
		Real timeStepOrder = 0.0;
		};

		template< typename MeshConfig,
		typename Real >
		class MeshDependentTimeSteps< TNL::Meshes::Mesh< MeshConfig >, Real >
		{
		public:
		using MeshType = TNL::Meshes::Mesh< MeshConfig >;

		bool setTimeStepOrder( const Real& timeStepOrder )
		{
		if( timeStepOrder != 0.0 ) {
		std::cerr << "Mesh-dependent time stepping is not available on unstructured meshes, so the time step order must be 0." << std::endl;
		return false;
		}
		this->timeStepOrder = timeStepOrder;
		return true;
		}

		const Real& getTimeStepOrder() const
		{
		return timeStepOrder;
		}

		Real getRefinedTimeStep( const MeshType& mesh, const Real& timeStep )
		{
		return timeStep;
		}

		protected:
		Real timeStepOrder = 0.0;
		};

		} // namespace PDE
		} // namespace Solvers
		} // namespace TNL

src/TNL/Solvers/PDE/TimeDependentPDESolver.h

+7 −7

Original line number	Diff line number	Diff line
		@@ -15,6 +15,7 @@
		#include <TNL/Logger.h>
		#include <TNL/SharedPointer.h>
		#include <TNL/Solvers/PDE/PDESolver.h>
		#include <TNL/Solvers/PDE/MeshDependentTimeSteps.h>

		namespace TNL {
		namespace Solvers {
		@@ -23,8 +24,11 @@ namespace PDE {
		template< typename Problem,
		typename DiscreteSolver,
		typename TimeStepper >
		class TimeDependentPDESolver : public PDESolver< typename Problem::RealType,
		typename Problem::IndexType >
		class TimeDependentPDESolver
		: public PDESolver< typename Problem::RealType,
		typename Problem::IndexType >,
		public MeshDependentTimeSteps< typename Problem::MeshType,
		typename TimeStepper::RealType >
		{
		public:

		@@ -68,10 +72,6 @@ class TimeDependentPDESolver : public PDESolver< typename Problem::RealType,

		const RealType& getTimeStep() const;

		bool setTimeStepOrder( const RealType& timeStepOrder );

		const RealType& getTimeStepOrder() const;

		bool setSnapshotPeriod( const RealType& period );

		const RealType& getSnapshotPeriod() const;
		@@ -94,7 +94,7 @@ class TimeDependentPDESolver : public PDESolver< typename Problem::RealType,

		ProblemType* problem;

		RealType initialTime, finalTime, snapshotPeriod, timeStep, timeStepOrder;
		RealType initialTime, finalTime, snapshotPeriod, timeStep;
		};

		} // namespace PDE

src/TNL/Solvers/PDE/TimeDependentPDESolver_impl.h

+12 −35

Original line number	Diff line number	Diff line
		@@ -11,6 +11,7 @@
		#pragma once

		#include "TimeDependentPDESolver.h"
		#include <TNL/Meshes/TypeResolver/TypeResolver.h>

		namespace TNL {
		namespace Solvers {
		@@ -25,8 +26,7 @@ TimeDependentPDESolver()
		initialTime( 0.0 ),
		finalTime( 0.0 ),
		snapshotPeriod( 0.0 ),
		timeStep( 1.0 ),
		timeStepOrder( 0.0 )
		timeStep( 1.0 )
		{
		}

		@@ -100,11 +100,14 @@ setup( const Config::ParameterContainer& parameters,
		/****
		* Initialize the time discretisation
		*/
		this->setFinalTime( parameters.getParameter< double >( "final-time" ) );
		bool status = true;
		status &= this->setFinalTime( parameters.getParameter< double >( "final-time" ) );
		this->setInitialTime( parameters.getParameter< double >( "initial-time" ) );
		this->setSnapshotPeriod( parameters.getParameter< double >( "snapshot-period" ) );
		this->setTimeStep( parameters.getParameter< double >( "time-step") );
		this->setTimeStepOrder( parameters.getParameter< double >( "time-step-order" ) );
		status &= this->setSnapshotPeriod( parameters.getParameter< double >( "snapshot-period" ) );
		status &= this->setTimeStep( parameters.getParameter< double >( "time-step") );
		status &= this->setTimeStepOrder( parameters.getParameter< double >( "time-step-order" ) );
		if( ! status )
		return false;

		/****
		* Set-up the discrete solver
		@@ -136,7 +139,7 @@ writeProlog( Logger& logger,
		meshPointer->writeProlog( logger );
		logger.writeSeparator();
		logger.writeParameter< String >( "Time discretisation:", "time-discretisation", parameters );
		logger.writeParameter< double >( "Initial time step:", this->timeStep * std::pow( meshPointer->getSmallestSpaceStep(), this->timeStepOrder ) );
		logger.writeParameter< double >( "Initial time step:", this->getRefinedTimeStep( this->meshPointer.getData(), this->timeStep ) );
		logger.writeParameter< double >( "Initial time:", "initial-time", parameters );
		logger.writeParameter< double >( "Final time:", "final-time", parameters );
		logger.writeParameter< double >( "Snapshot period:", "snapshot-period", parameters );
		@@ -268,32 +271,6 @@ getTimeStep() const
		return this->timeStep;
		}

		template< typename Problem,
		typename DiscreteSolver,
		typename TimeStepper >
		bool
		TimeDependentPDESolver< Problem, DiscreteSolver, TimeStepper >::
		setTimeStepOrder( const RealType& timeStepOrder )
		{
		if( timeStepOrder < 0 )
		{
		std::cerr << "The time step order for TimeDependentPDESolver must be zero or positive value." << std::endl;
		return false;
		}
		this->timeStepOrder = timeStepOrder;
		return true;
		}

		template< typename Problem,
		typename DiscreteSolver,
		typename TimeStepper >
		const typename Problem::RealType&
		TimeDependentPDESolver< Problem, DiscreteSolver, TimeStepper >::
		getTimeStepOrder() const
		{
		return this->timeStepOrder;
		}

		template< typename Problem,
		typename DiscreteSolver,
		typename TimeStepper >
		@@ -329,7 +306,7 @@ solve()
		*/
		this->timeStepper.setProblem( * ( this->problem ) );
		this->timeStepper.init( this->meshPointer );
		this->timeStepper.setTimeStep( this->timeStep * std::pow( this->meshPointer.getData().getSmallestSpaceStep(), this->timeStepOrder ) );
		this->timeStepper.setTimeStep( this->getRefinedTimeStep( this->meshPointer.getData(), this->timeStep ) );
		while( step < allSteps )
		{
		RealType tau = min( this->snapshotPeriod,