add method to check if a solver implement fast mode integrate

Author: szaghi

src/lib/foodie_integrator_adams_bashforth.f90

@@ -53,6 +53,8 @@ module foodie_integrator_adams_bashforth
                                                           trim(class_name_)//'_15', &
                                                           trim(class_name_)//'_16'] !< List of supported schemes.
 
+logical, parameter :: has_fast_mode_=.true. !< Flag to check if integrator provides *fast mode* integrate.
+
 type, extends(integrator_object) :: integrator_adams_bashforth
   !< FOODIE integrator: provide an explicit class of Adams-Bashforth multi-step schemes, from 1st to 16th order accurate.
   !<
@@ -64,6 +66,7 @@ module foodie_integrator_adams_bashforth
     ! deferred methods
     procedure, pass(self) :: class_name           !< Return the class name of schemes.
     procedure, pass(self) :: description          !< Return pretty-printed object description.
+    procedure, pass(self) :: has_fast_mode        !< Return .true. if the integrator class has *fast mode* integrate.
     procedure, pass(lhs)  :: integr_assign_integr !< Operator `=`.
     procedure, pass(self) :: is_supported         !< Return .true. if the integrator class support the given scheme.
     procedure, pass(self) :: supported_schemes    !< Return the list of supported schemes.
@@ -104,6 +107,14 @@ pure function description(self, prefix) result(desc)
   desc = desc//prefix_//'    + '//supported_schemes_(ubound(supported_schemes_, dim=1))
   endfunction description
 
+  elemental function has_fast_mode(self)
+  !< Return .true. if the integrator class has *fast mode* integrate.
+  class(integrator_adams_bashforth), intent(in) :: self          !< Integrator.
+  logical                                       :: has_fast_mode !< Inquire result.
+
+  has_fast_mode = has_fast_mode_
+  endfunction has_fast_mode
+
   pure subroutine integr_assign_integr(lhs, rhs)
   !< Operator `=`.
   class(integrator_adams_bashforth), intent(inout) :: lhs !< Left hand side.

src/lib/foodie_integrator_adams_bashforth_moulton.f90

@@ -105,6 +105,8 @@ module foodie_integrator_adams_bashforth_moulton
                                                           trim(class_name_)//'_15', &
                                                           trim(class_name_)//'_16'] !< List of supported schemes.
 
+logical, parameter :: has_fast_mode_=.false. !< Flag to check if integrator provides *fast mode* integrate.
+
 type, extends(integrator_object) :: integrator_adams_bashforth_moulton
   !< FOODIE integrator: provide an explicit class of Adams-Bashforth-Moulton multi-step schemes, from 1st to 4rd order accurate.
   !<
@@ -117,6 +119,7 @@ module foodie_integrator_adams_bashforth_moulton
     ! deferred methods
     procedure, pass(self) :: class_name           !< Return the class name of schemes.
     procedure, pass(self) :: description          !< Return pretty-printed object description.
+    procedure, pass(self) :: has_fast_mode        !< Return .true. if the integrator class has *fast mode* integrate.
     procedure, pass(lhs)  :: integr_assign_integr !< Operator `=`.
     procedure, pass(self) :: is_supported         !< Return .true. if the integrator class support the given scheme.
     procedure, pass(self) :: supported_schemes    !< Return the list of supported schemes.
@@ -156,6 +159,14 @@ pure function description(self, prefix) result(desc)
   desc = desc//prefix_//'    + '//supported_schemes_(ubound(supported_schemes_, dim=1))
   endfunction description
 
+  elemental function has_fast_mode(self)
+  !< Return .true. if the integrator class has *fast mode* integrate.
+  class(integrator_adams_bashforth_moulton), intent(in) :: self          !< Integrator.
+  logical                                               :: has_fast_mode !< Inquire result.
+
+  has_fast_mode = has_fast_mode_
+  endfunction has_fast_mode
+
   pure subroutine integr_assign_integr(lhs, rhs)
   !< Operator `=`.
   class(integrator_adams_bashforth_moulton), intent(inout) :: lhs !< Left hand side.

src/lib/foodie_integrator_adams_moulton.f90

@@ -54,6 +54,8 @@ module foodie_integrator_adams_moulton
                                                           trim(class_name_)//'_14', &
                                                           trim(class_name_)//'_15'] !< List of supported schemes.
 
+logical, parameter :: has_fast_mode_=.false. !< Flag to check if integrator provides *fast mode* integrate.
+
 type, extends(integrator_object) :: integrator_adams_moulton
   !< FOODIE integrator: provide an explicit class of Adams-Moulton multi-step schemes, from 1st to 16th order accurate.
   !<
@@ -66,6 +68,7 @@ module foodie_integrator_adams_moulton
     procedure, pass(self) :: class_name           !< Return the class name of schemes.
     procedure, pass(self) :: description          !< Return pretty-printed object description.
     procedure, pass(lhs)  :: integr_assign_integr !< Operator `=`.
+    procedure, pass(self) :: has_fast_mode        !< Return .true. if the integrator class has *fast mode* integrate.
     procedure, pass(self) :: is_supported         !< Return .true. if the integrator class support the given scheme.
     procedure, pass(self) :: supported_schemes    !< Return the list of supported schemes.
     ! public methods
@@ -104,6 +107,14 @@ pure function description(self, prefix) result(desc)
   desc = desc//prefix_//'    + '//supported_schemes_(ubound(supported_schemes_, dim=1))
   endfunction description
 
+  elemental function has_fast_mode(self)
+  !< Return .true. if the integrator class has *fast mode* integrate.
+  class(integrator_adams_moulton), intent(in) :: self          !< Integrator.
+  logical                                     :: has_fast_mode !< Inquire result.
+
+  has_fast_mode = has_fast_mode_
+  endfunction has_fast_mode
+
   pure subroutine integr_assign_integr(lhs, rhs)
   !< Operator `=`.
   class(integrator_adams_moulton), intent(inout) :: lhs !< Left hand side.

src/lib/foodie_integrator_backward_differentiation_formula.f90

@@ -50,6 +50,8 @@ module foodie_integrator_backward_differentiation_formula
                                                          trim(class_name_)//'_5', &
                                                          trim(class_name_)//'_6'] !< List of supported schemes.
 
+logical, parameter :: has_fast_mode_=.false. !< Flag to check if integrator provides *fast mode* integrate.
+
 type, extends(integrator_object) :: integrator_back_df
   !< FOODIE integrator: provide an implicit class of Backward-Differentiation-Formula multi-step schemes, from 1st to 6th order
   !< accurate.
@@ -63,6 +65,7 @@ module foodie_integrator_backward_differentiation_formula
     ! deferred methods
     procedure, pass(self) :: class_name           !< Return the class name of schemes.
     procedure, pass(self) :: description          !< Return pretty-printed object description.
+    procedure, pass(self) :: has_fast_mode        !< Return .true. if the integrator class has *fast mode* integrate.
     procedure, pass(lhs)  :: integr_assign_integr !< Operator `=`.
     procedure, pass(self) :: is_supported         !< Return .true. if the integrator class support the given scheme.
     procedure, pass(self) :: supported_schemes    !< Return the list of supported schemes.
@@ -102,6 +105,14 @@ pure function description(self, prefix) result(desc)
   desc = desc//prefix_//'    + '//supported_schemes_(ubound(supported_schemes_, dim=1))
   endfunction description
 
+  elemental function has_fast_mode(self)
+  !< Return .true. if the integrator class has *fast mode* integrate.
+  class(integrator_back_df), intent(in) :: self          !< Integrator.
+  logical                               :: has_fast_mode !< Inquire result.
+
+  has_fast_mode = has_fast_mode_
+  endfunction has_fast_mode
+
   pure subroutine integr_assign_integr(lhs, rhs)
   !< Operator `=`.
   class(integrator_back_df), intent(inout) :: lhs !< Left hand side.

src/lib/foodie_integrator_euler_explicit.f90

@@ -25,6 +25,8 @@ module foodie_integrator_euler_explicit
 character(len=99), parameter :: class_name_='euler_explicit'                !< Name of the class of schemes.
 character(len=99), parameter :: supported_schemes_(1:1)=[trim(class_name_)] !< List of supported schemes.
 
+logical, parameter :: has_fast_mode_=.false. !< Flag to check if integrator provides *fast mode* integrate.
+
 type, extends(integrator_object) :: integrator_euler_explicit
   !< FOODIE integrator: provide explicit Euler scheme, it being 1st order accurate.
   !<
@@ -33,6 +35,7 @@ module foodie_integrator_euler_explicit
     ! deferred methods
     procedure, pass(self) :: class_name           !< Return the class name of schemes.
     procedure, pass(self) :: description          !< Return pretty-printed object description.
+    procedure, pass(self) :: has_fast_mode        !< Return .true. if the integrator class has *fast mode* integrate.
     procedure, pass(lhs)  :: integr_assign_integr !< Operator `=`.
     procedure, pass(self) :: is_supported         !< Return .true. if the integrator class support the given scheme.
     procedure, pass(self) :: supported_schemes    !< Return the list of supported schemes.
@@ -61,6 +64,14 @@ pure function description(self, prefix) result(desc)
   desc = prefix_//'Euler, Explicit (1 step/stage) 1st order scheme'
   endfunction description
 
+  elemental function has_fast_mode(self)
+  !< Return .true. if the integrator class has *fast mode* integrate.
+  class(integrator_euler_explicit), intent(in) :: self          !< Integrator.
+  logical                                      :: has_fast_mode !< Inquire result.
+
+  has_fast_mode = has_fast_mode_
+  endfunction has_fast_mode
+
   pure subroutine integr_assign_integr(lhs, rhs)
   !< Operator `=`.
   class(integrator_euler_explicit), intent(inout) :: lhs !< Left hand side.

src/lib/foodie_integrator_leapfrog.f90

@@ -49,6 +49,8 @@ module foodie_integrator_leapfrog
 character(len=99), parameter :: supported_schemes_(1:2)=[trim(class_name_)//'    ', &
                                                          trim(class_name_)//'_raw'] !< List of supported schemes.
 
+logical, parameter :: has_fast_mode_=.false. !< Flag to check if integrator provides *fast mode* integrate.
+
 type, extends(integrator_object) :: integrator_leapfrog
   !< FOODIE integrator: provide an explicit class of leapfrog multi-step schemes, 2nd order accurate.
   !<
@@ -62,6 +64,7 @@ module foodie_integrator_leapfrog
     ! deferred methods
     procedure, pass(self) :: class_name           !< Return the class name of schemes.
     procedure, pass(self) :: description          !< Return pretty-printed object description.
+    procedure, pass(self) :: has_fast_mode        !< Return .true. if the integrator class has *fast mode* integrate.
     procedure, pass(lhs)  :: integr_assign_integr !< Operator `=`.
     procedure, pass(self) :: is_supported         !< Return .true. if the integrator class support the given scheme.
     procedure, pass(self) :: supported_schemes    !< Return the list of supported schemes.
@@ -92,6 +95,14 @@ pure function description(self, prefix) result(desc)
   desc = desc//prefix_//'Explicit leapfrog multi-step 2nd order scheme'
   endfunction description
 
+  elemental function has_fast_mode(self)
+  !< Return .true. if the integrator class has *fast mode* integrate.
+  class(integrator_leapfrog), intent(in) :: self          !< Integrator.
+  logical                                :: has_fast_mode !< Inquire result.
+
+  has_fast_mode = has_fast_mode_
+  endfunction has_fast_mode
+
   pure subroutine integr_assign_integr(lhs, rhs)
   !< Operator `=`.
   class(integrator_leapfrog), intent(inout) :: lhs !< Left hand side.

src/lib/foodie_integrator_lmm_ssp.f90

@@ -40,6 +40,8 @@ module foodie_integrator_lmm_ssp
                                                          trim(class_name_)//'_steps_4_order_3', &
                                                          trim(class_name_)//'_steps_5_order_3'] !< List of supported schemes.
 
+logical, parameter :: has_fast_mode_=.false. !< Flag to check if integrator provides *fast mode* integrate.
+
 type, extends(integrator_object) :: integrator_lmm_ssp
   !< FOODIE integrator: provide an explicit class of Linear Multi-step Methods (LLM) with Strong Stability Preserving property,
   !< from 2nd to 3rd order accurate.
@@ -53,6 +55,7 @@ module foodie_integrator_lmm_ssp
     ! deferred methods
     procedure, pass(self) :: class_name           !< Return the class name of schemes.
     procedure, pass(self) :: description          !< Return pretty-printed object description.
+    procedure, pass(self) :: has_fast_mode        !< Return .true. if the integrator class has *fast mode* integrate.
     procedure, pass(lhs)  :: integr_assign_integr !< Operator `=`.
     procedure, pass(self) :: is_supported         !< Return .true. if the integrator class support the given scheme.
     procedure, pass(self) :: supported_schemes    !< Return the list of supported schemes.
@@ -92,6 +95,14 @@ pure function description(self, prefix) result(desc)
   desc = desc//prefix_//'    + '//supported_schemes_(ubound(supported_schemes_, dim=1))
   endfunction description
 
+  elemental function has_fast_mode(self)
+  !< Return .true. if the integrator class has *fast mode* integrate.
+  class(integrator_lmm_ssp), intent(in) :: self          !< Integrator.
+  logical                               :: has_fast_mode !< Inquire result.
+
+  has_fast_mode = has_fast_mode_
+  endfunction has_fast_mode
+
   pure subroutine integr_assign_integr(lhs, rhs)
   !< Operator `=`.
   class(integrator_lmm_ssp), intent(inout) :: lhs !< Left hand side.

src/lib/foodie_integrator_lmm_ssp_vss.f90

@@ -53,6 +53,8 @@ module foodie_integrator_lmm_ssp_vss
                                                          trim(class_name_)//'_steps_4_order_3', &
                                                          trim(class_name_)//'_steps_5_order_3'] !< List of supported schemes.
 
+logical, parameter :: has_fast_mode_=.false. !< Flag to check if integrator provides *fast mode* integrate.
+
 type, extends(integrator_object) :: integrator_lmm_ssp_vss
   !< FOODIE integrator: provide an explicit class of Linear Multi-step Methods (LLM) with Strong Stability Preserving property and
   !< variable stepsize (VSS), from 2nd to 3rd order accurate.
@@ -65,6 +67,7 @@ module foodie_integrator_lmm_ssp_vss
     ! deferred methods
     procedure, pass(self) :: class_name           !< Return the class name of schemes.
     procedure, pass(self) :: description          !< Return pretty-printed object description.
+    procedure, pass(self) :: has_fast_mode        !< Return .true. if the integrator class has *fast mode* integrate.
     procedure, pass(lhs)  :: integr_assign_integr !< Operator `=`.
     procedure, pass(self) :: is_supported         !< Return .true. if the integrator class support the given scheme.
     procedure, pass(self) :: supported_schemes    !< Return the list of supported schemes.
@@ -121,6 +124,14 @@ pure function description(self, prefix) result(desc)
   desc = desc//prefix_//'    + '//supported_schemes_(ubound(supported_schemes_, dim=1))
   endfunction description
 
+  elemental function has_fast_mode(self)
+  !< Return .true. if the integrator class has *fast mode* integrate.
+  class(integrator_lmm_ssp_vss), intent(in) :: self          !< Integrator.
+  logical                                   :: has_fast_mode !< Inquire result.
+
+  has_fast_mode = has_fast_mode_
+  endfunction has_fast_mode
+
   pure subroutine integr_assign_integr(lhs, rhs)
   !< Operator `=`.
   class(integrator_lmm_ssp_vss), intent(inout) :: lhs !< Left hand side.

src/lib/foodie_integrator_ms_runge_kutta_ssp.f90

@@ -49,6 +49,8 @@ module foodie_integrator_ms_runge_kutta_ssp
                                                          trim(class_name_)//'_steps_4_stages_5_order_8'] !< List of supported
                                                                                                          !< schemes.
 
+logical, parameter :: has_fast_mode_=.false. !< Flag to check if integrator provides *fast mode* integrate.
+
 type, extends(integrator_object) :: integrator_ms_runge_kutta_ssp
   !< FOODIE integrator: provide an explicit class of Multi-step Runge-Kutta Methods with Strong Stability Preserving property,
   !< from 3rd to 8th order accurate.
@@ -67,6 +69,7 @@ module foodie_integrator_ms_runge_kutta_ssp
     ! deferred methods
     procedure, pass(self) :: class_name           !< Return the class name of schemes.
     procedure, pass(self) :: description          !< Return pretty-printed object description.
+    procedure, pass(self) :: has_fast_mode        !< Return .true. if the integrator class has *fast mode* integrate.
     procedure, pass(lhs)  :: integr_assign_integr !< Operator `=`.
     procedure, pass(self) :: is_supported         !< Return .true. if the integrator class support the given scheme.
     procedure, pass(self) :: supported_schemes    !< Return the list of supported schemes.
@@ -106,6 +109,14 @@ pure function description(self, prefix) result(desc)
   desc = desc//prefix_//'    + '//supported_schemes_(ubound(supported_schemes_, dim=1))
   endfunction description
 
+  elemental function has_fast_mode(self)
+  !< Return .true. if the integrator class has *fast mode* integrate.
+  class(integrator_ms_runge_kutta_ssp), intent(in) :: self          !< Integrator.
+  logical                                          :: has_fast_mode !< Inquire result.
+
+  has_fast_mode = has_fast_mode_
+  endfunction has_fast_mode
+
   pure subroutine integr_assign_integr(lhs, rhs)
   !< Operator `=`.
   class(integrator_ms_runge_kutta_ssp), intent(inout) :: lhs !< Left hand side.

src/lib/foodie_integrator_object.f90

@@ -23,6 +23,8 @@ module foodie_integrator_object
     ! deferred methods
     procedure(class_name_interface),        pass(self), deferred :: class_name           !< Return the class name of schemes.
     procedure(description_interface),       pass(self), deferred :: description          !< Return pretty-printed obj. description.
+    procedure(has_fast_mode_interface),     pass(self), deferred :: has_fast_mode        !< Return .true. if the integrator class
+                                                                                         !< has *fast mode* integrate.
     procedure(assignment_interface),        pass(lhs),  deferred :: integr_assign_integr !< Operator `=`.
     procedure(is_supported_interface),      pass(self), deferred :: is_supported         !< Return .true. if the integrator class
                                                                                          !< support the given scheme.
@@ -55,6 +57,13 @@ pure subroutine assignment_interface(lhs, rhs)
   class(integrator_object), intent(in)    :: rhs !< Right hand side.
   endsubroutine assignment_interface
 
+  elemental function has_fast_mode_interface(self) result(has_fast_mode)
+  !< Return .true. if the integrator class has *fast mode* integrate.
+  import :: integrator_object
+  class(integrator_object), intent(in) :: self          !< Integrator.
+  logical                              :: has_fast_mode !< Inquire result.
+  endfunction has_fast_mode_interface
+
   elemental function is_supported_interface(self, scheme) result(is_supported)
   !< Return .true. if the integrator class support the given scheme.
   import :: integrator_object