Commit 2a52773d authored by Tomáš Oberhuber's avatar Tomáš Oberhuber
Browse files

Working on PDE solver.

parent 0dd6d122

src/implementation/solvers/pde/CMakeLists.txt

+2 −1
Original line number Diff line number Diff line 
SET( headers tnlExplicitTimeStepper_impl.h )

SET( headers tnlExplicitTimeStepper_impl.h

             tnlPDESolver_impl.h  )



INSTALL( FILES ${headers} DESTINATION include/tnl-${tnlVersion}/implementation/solvers/pde )

src/implementation/solvers/pde/tnlExplicitTimeStepper_impl.h

+38 −1
Original line number Diff line number Diff line
@@ -21,7 +21,8 @@ 
template< typename Problem,

          template < typename OdeProblem > class OdeSolver >

tnlExplicitTimeStepper< Problem, OdeSolver > :: tnlExplicitTimeStepper()

: odeSolver( 0 )

: odeSolver( 0 ),

  problem( 0 )

{

};
@@ -32,6 +33,42 @@ void tnlExplicitTimeStepper< Problem, OdeSolver > :: setSolver( OdeSolver< Probl 
   this -> odeSolver = &odeSolver;

};



template< typename Problem,

          template < typename OdeProblem > class OdeSolver >

void tnlExplicitTimeStepper< Problem, OdeSolver > :: setProblem( ProblemType& problem )

{

   this -> problem = &problem;

};



template< typename Problem,

          template < typename OdeProblem > class OdeSolver >

Problem* tnlExplicitTimeStepper< Problem, OdeSolver > :: getProblem() const

{

    return this -> problem;

};



template< typename Problem,

          template < typename OdeProblem > class OdeSolver >

bool tnlExplicitTimeStepper< Problem, OdeSolver > :: setTau( const RealType& tau )

{

   if( tau <= 0.0 )

   {

      cerr << "Tau for tnlExplicitTimeStepper must be positive. " << endl;

      return false;

   }

   this -> tau = tau;

};



template< typename Problem,

          template < typename OdeProblem > class OdeSolver >

bool tnlExplicitTimeStepper< Problem, OdeSolver > :: solve( const RealType& time,

                                                            const RealType& stopTime )

{

   this -> odeSolver -> setTau( this -> tau );

   this -> odeSolver -> setProblem( * this -> problem );

   DofVectorType& u = problem -> getDofVector();

   this -> odeSolver -> setTime( time );

   return this -> odeSolver -> solve( u );

}



#endif /* TNLEXPLICITTIMESTEPPER_IMPL_H_ */

src/implementation/solvers/pde/tnlPDESolver_impl.h

0 → 100644
+107 −0
Original line number Diff line number Diff line 
/***************************************************************************

                          tnlPDESolver_impl.h  -  description

                             -------------------

    begin                : Jan 15, 2013

    copyright            : (C) 2013 by Tomas Oberhuber

    email                : tomas.oberhuber@fjfi.cvut.cz

 ***************************************************************************/



/***************************************************************************

 *                                                                         *

 *   This program is free software; you can redistribute it and/or modify  *

 *   it under the terms of the GNU General Public License as published by  *

 *   the Free Software Foundation; either version 2 of the License, or     *

 *   (at your option) any later version.                                   *

 *                                                                         *

 ***************************************************************************/



#ifndef TNLPDESOLVER_IMPL_H_

#define TNLPDESOLVER_IMPL_H_



template< typename Problem, typename TimeStepper >

tnlPDESolver< Problem, TimeStepper > :: tnlPDESolver()

: timeStepper( 0 ),

  finalTime( 0.0 ),

  snapshotTau( 0.0 ),

  problem( 0 )

{

}



template< typename Problem, typename TimeStepper >

void tnlPDESolver< Problem, TimeStepper > :: setTimeStepper( TimeStepper& timeStepper )

{

   this -> timeStepper = timeStepper;

}



template< typename Problem, typename TimeStepper >

void tnlPDESolver< Problem, TimeStepper > :: setProblem( ProblemType& problem )

{

   this -> problem = &problem;

}



template< typename Problem, typename TimeStepper >

bool tnlPDESolver< Problem, TimeStepper > :: setFinalTime( const RealType& finalT )

{

   if( finalT <= 0 )

   {

      cerr << "Final time for tnlPDESolver must be positive value." << endl;

      return false;

   }

   this -> finalTime = finalT;

}



template< typename Problem, typename TimeStepper >

const typename TimeStepper :: RealType& tnlPDESolver< Problem, TimeStepper > :: getFinalTine() const

{

   return this -> finalTime;

}



template< typename Problem, typename TimeStepper >

bool tnlPDESolver< Problem, TimeStepper > :: setSnapshotTau( const RealType& tau )

{

   if( tau <= 0 )

   {

      cerr << "Snapshot tau for tnlPDESolver must be positive value." << endl;

      return false;

   }

   this -> snapshotTau = tau;

}

   

template< typename Problem, typename TimeStepper >

const typename TimeStepper :: RealType& tnlPDESolver< Problem, TimeStepper > :: getSnapshotTau() const

{

   return this -> snapshotTau;

}



template< typename Problem, typename TimeStepper >

bool tnlPDESolver< Problem, TimeStepper > :: solve()

{

   tnlAssert( timeStepper,

              cerr << "No time stepper was set in tnlPDESolver with name " << this -> getName() );

   tnlAssert( problem,

              cerr << "No problem was set in tnlPDESolver with name " << this -> getName() );



   if( snapshotTau == 0 )

   {

      cerr << "No snapshot tau was set in tnlPDESolver " << this -> getName() << "." << endl;

      return false;

   }

   RealType t( 0.0 );

   IndexType step( 0 );

   IndexType allSteps = ceil( this -> finalTime / this -> snapshotTau );

   this -> timeStepper -> setProblem( * this -> problem );

   while( step < allSteps )

   {

      RealType tau = Min( this -> snapshotTau,

                          this -> finalTime - t - this -> snapshotTau );

      if( ! this -> timeStepper -> solve( t, t + tau ) )

         return false;

      step ++;

      t += tau;

      if( ! this -> problem -> makeSnapshot( t, step ) )

         return false;

   }

   return true;

}



#endif /* TNLPDESOLVER_IMPL_H_ */

src/solvers/pde/tnlExplicitTimeStepper.h

+19 −0
Original line number Diff line number Diff line
@@ -26,14 +26,33 @@ class tnlExplicitTimeStepper 


   typedef Problem ProblemType;

   typedef OdeSolver< ProblemType > OdeSolverType;

   typedef typename Problem :: RealType RealType;

   typedef typename Problem :: DeviceType DeviceType;

   typedef typename Problem :: IndexType IndexType;

   typedef typename ProblemType :: DofVectorType DofVectorType;



   tnlExplicitTimeStepper();



   void setSolver( OdeSolverType& odeSolver );



   void setProblem( ProblemType& problem );



   ProblemType* getProblem() const;



   bool setTau( const RealType& tau );



   const RealType& getTau() const;



   bool solve( const RealType& time,

               const RealType& stopTime );



   protected:



   OdeSolverType* odeSolver;



   Problem* problem;



   RealType tau;

};



#include <implementation/solvers/pde/tnlExplicitTimeStepper_impl.h>

src/solvers/pde/tnlPDESolver.h

+29 −2
Original line number Diff line number Diff line
@@ -18,18 +18,45 @@ 
#ifndef TNLPDESOLVER_H_

#define TNLPDESOLVER_H_



template< typename TimeStepper >

class tnlPDESolver

#include <core/tnlObject.h>



template< typename Problem,

          typename TimeStepper >

class tnlPDESolver : public tnlObject

{

   public:



   typedef typename TimeStepper :: RealType RealType;

   typedef typename TimeStepper :: DeviceType DeviceType;

   typedef typename TimeStepper :: IndexType IndexType;

   typedef typename TimeStepper :: ProblemType ProblemType;

   

   tnlPDESolver();



   void setTimeStepper( TimeStepper& timeStepper );



   void setProblem( ProblemType& problem );



   bool setFinalTime( const RealType& finalT );



   const RealType& getFinalTine() const;



   bool setSnapshotTau( const RealType& tau );

   

   const RealType& getSnapshotTau() const;



   bool solve();



   protected:



   TimeStepper* timeStepper;



   RealType finalTime, snapshotTau;



   ProblemType* problem;



};



#include <implementation/solvers/pde/tnlPDESolver_impl.h>



#endif /* TNLPDESOLVER_H_ */