Merge branch 'release/0.1.0'

Author: szaghi

fobos

@@ -3,15 +3,18 @@ modes = shared-gnu static-gnu shared-gnu-debug static-gnu-debug
         shared-intel static-intel shared-intel-debug static-intel-debug
         tests-gnu tests-gnu-debug
         tests-intel tests-intel-debug
+        tests-pgi tests-pgi-debug
 
 [common-variables]
 $CSHARED_GNU = -cpp -c -fPIC -frealloc-lhs
 $CSHARED_INT = -cpp -c -fpic -assume realloc_lhs
 $LSHARED     = -shared
 $CSTATIC_GNU = -cpp -c -frealloc-lhs
 $CSTATIC_INT = -cpp -c -assume realloc_lhs
+$CSTATIC_PGI = -c -Mallocatable=03
 $DEBUG_GNU   = -O0 -g3 -Warray-bounds -Wcharacter-truncation -Wline-truncation -Wimplicit-interface -Wimplicit-procedure -Wunderflow -fcheck=all -fmodule-private -ffree-line-length-132 -fimplicit-none -fbacktrace -fdump-core -finit-real=nan -std=f2008 -fall-intrinsics
 $DEBUG_INT   = -O0 -debug all -check all -warn all -extend-source 132 -traceback -gen-interfaces#-fpe-all=0 -fp-stack-check -fstack-protector-all -ftrapuv -no-ftz -std08
+$DEBUG_PGI   = -C -g -gopt -Mchkfpstk -Mchkptr -Mchkstk -Mcoff -traceback
 $OPTIMIZE    = -O2
 $EXDIRS      = PENF/src/tests/
                FACE/src/tests/ FACE/src/third_party/
@@ -96,6 +99,15 @@ build_dir = ./exe/
 template  = template-static-intel-debug
 build_dir = ./exe/
 
+# PGI
+[tests-pgi]
+template  = template-static-pgi
+build_dir = ./exe/
+
+[tests-pgi-debug]
+template  = template-static-pgi-debug
+build_dir = ./exe/
+
 #templates
 [template-shared-gnu]
 compiler     = gnu
@@ -207,6 +219,33 @@ quiet        = False
 log          = True
 jobs         = 2
 
+[template-static-pgi]
+compiler     = pgi
+cflags       = $CSTATIC_PGI $OPTIMIZE
+lflags       = $OPTIMIZE
+exclude_dirs = $EXDIRS
+mod_dir      = ./mod/
+obj_dir      = ./obj/
+src          = ./src/
+colors       = True
+quiet        = False
+log          = True
+jobs         = 2
+
+[template-static-pgi-debug]
+compiler     = pgi
+cflags       = $CSTATIC_PGI $DEBUG_PGI
+lflags       = $DEBUG_PGI
+preproc      = -DDEBUG
+exclude_dirs = $EXDIRS
+mod_dir      = ./mod/
+obj_dir      = ./obj/
+src          = ./src/
+colors       = True
+quiet        = False
+log          = True
+jobs         = 2
+
 # rules
 [rule-makedoc]
 help   = Build documentation from source files

src/lib/foreseer_riemann_solver_compressible_exact.F90

@@ -22,8 +22,9 @@ module foreseer_riemann_solver_compressible_exact
    real(R8P) :: tolerance=1.e-10_R8P !< Tolerance on Newton convergence.
    contains
       ! public deferred methods
-      procedure, pass(self) :: initialize !< Initialize solver.
-      procedure, pass(self) :: solve      !< Solve Riemann Problem.
+      procedure, pass(self) :: initialize       !< Initialize solver.
+      procedure, pass(lhs)  :: riem_assign_riem !< `=` operator.
+      procedure, pass(self) :: solve            !< Solve Riemann Problem.
 endtype riemann_solver_compressible_exact
 
 contains
@@ -38,6 +39,17 @@ subroutine initialize(self, config)
    self%tolerance = cton(config_, knd=1._R8P)
    endsubroutine initialize
 
+   pure subroutine riem_assign_riem(lhs, rhs)
+   !< `=` operator.
+   class(riemann_solver_compressible_exact), intent(inout) :: lhs !< Left hand side.
+   class(riemann_solver_object),             intent(in)    :: rhs !< Right hand side.
+
+   select type(rhs)
+   type is(riemann_solver_compressible_exact)
+      lhs%tolerance = rhs%tolerance
+   endselect
+   endsubroutine riem_assign_riem
+
    pure subroutine solve(self, eos_left, state_left, eos_right, state_right, normal, fluxes)
    !< Solve Riemann Problem.
    !<
@@ -49,12 +61,16 @@ pure subroutine solve(self, eos_left, state_left, eos_right, state_right, normal
    class(conservative_object),               intent(in)    :: state_right     !< Right Riemann state.
    type(vector),                             intent(in)    :: normal          !< Normal (versor) of face where fluxes are given.
    class(conservative_object),               intent(inout) :: fluxes          !< Fluxes of the Riemann Problem solution.
+   type(conservative_compressible)                         :: state_left_  !< Left Riemann state, local variable.
+   type(conservative_compressible)                         :: state_right_ !< Right Riemann state, local variable.
    type(riemann_pattern_compressible_pvl)                  :: pattern         !< Riemann (states) pattern solution.
    real(R8P)                                               :: dum, alfa, beta !< Dummies coefficients.
    real(R8P)                                               :: p_2, p_3        !< Pessure of state 2 and 3.
    real(R8P)                                               :: dp2, dp3        !< Derivate of pessure (dp/du) of state 2 and 3.
 
-   call pattern%initialize(eos_left=eos_left, state_left=state_left, eos_right=eos_right, state_right=state_right, normal=normal)
+   state_left_ = state_left ; call state_left_%normalize(eos=eos_left, normal=normal)
+   state_right_ = state_right ; call state_right_%normalize(eos=eos_right, normal=normal)
+   call pattern%initialize(eos_left=eos_left, state_left=state_left_, eos_right=eos_right, state_right=state_right_, normal=normal)
 
    ! initiale u23 speed
    if (pattern%p_1 < pattern%p_4) then

src/lib/foreseer_riemann_solver_compressible_hllc.F90

@@ -21,8 +21,9 @@ module foreseer_riemann_solver_compressible_hllc
    !< @note This is the implemention for [[conservative_compressible]] Riemann states.
    contains
       ! public deferred methods
-      procedure, pass(self) :: initialize !< Initialize solver.
-      procedure, pass(self) :: solve      !< Solve Riemann Problem.
+      procedure, pass(self) :: initialize       !< Initialize solver.
+      procedure, pass(lhs)  :: riem_assign_riem !< `=` operator.
+      procedure, pass(self) :: solve            !< Solve Riemann Problem.
 endtype riemann_solver_compressible_hllc
 
 contains
@@ -37,6 +38,14 @@ subroutine initialize(self, config)
    ! call self%solver_pvl%initialize(config=config_)
    endsubroutine initialize
 
+   pure subroutine riem_assign_riem(lhs, rhs)
+   !< `=` operator.
+   !<
+   !< @TODO Update this if solver is updated.
+   class(riemann_solver_compressible_hllc), intent(inout) :: lhs !< Left hand side.
+   class(riemann_solver_object),            intent(in)    :: rhs !< Right hand side.
+   endsubroutine riem_assign_riem
+
    subroutine solve(self, eos_left, state_left, eos_right, state_right, normal, fluxes)
    !< Solve Riemann Problem.
    !<
@@ -49,15 +58,15 @@ subroutine solve(self, eos_left, state_left, eos_right, state_right, normal, flu
    type(vector),                            intent(in)    :: normal       !< Normal (versor) of face where fluxes are given.
    class(conservative_object),              intent(inout) :: fluxes       !< Fluxes of the Riemann Problem solution.
    type(conservative_compressible)                        :: state23      !< Intermediate states.
-   type(conservative_compressible), pointer               :: state_left_  !< Left Riemann state, local variable.
-   type(conservative_compressible), pointer               :: state_right_ !< Right Riemann state, local variable.
+   type(conservative_compressible)                        :: state_left_  !< Left Riemann state, local variable.
+   type(conservative_compressible)                        :: state_right_ !< Right Riemann state, local variable.
    type(riemann_pattern_compressible_pvl)                 :: pattern      !< Riemann (states) PVL pattern solution.
    real(R8P)                                              :: u23          !< Maximum wave speed estimation.
 
-   call pattern%initialize(eos_left=eos_left, state_left=state_left, eos_right=eos_right, state_right=state_right, normal=normal)
+   state_left_ = state_left ; call state_left_%normalize(eos=eos_left, normal=normal)
+   state_right_ = state_right ; call state_right_%normalize(eos=eos_right, normal=normal)
+   call pattern%initialize(eos_left=eos_left, state_left=state_left_, eos_right=eos_right, state_right=state_right_, normal=normal)
    call pattern%compute_waves_extrema
-   state_left_ => conservative_compressible_pointer(to=state_left)
-   state_right_ => conservative_compressible_pointer(to=state_right)
    associate(r_1=>pattern%r_1, u_1=>pattern%u_1, p_1=>pattern%p_1, g_1=>pattern%eos_1%g(), &
              r_4=>pattern%r_4, u_4=>pattern%u_4, p_4=>pattern%p_4, g_4=>pattern%eos_4%g(), &
              s_1=>pattern%s_1, s_4=>pattern%s_4,                                           &
@@ -66,35 +75,35 @@ subroutine solve(self, eos_left, state_left, eos_right, state_right, normal, flu
             (r_4 * (s_4 - u_4) - r_1 * (s_1 - u_1))
       select case(minloc([-s_1, s_1 * u23, u23 * s_4, s_4], dim=1))
       case(1)
-         call state_left%compute_fluxes(eos=eos_left, normal=normal, fluxes=fluxes)
+         call state_left_%compute_fluxes(eos=eos_left, normal=normal, fluxes=fluxes)
       case(2)
-         call state_left%compute_fluxes(eos=eos_left, normal=normal, fluxes=fluxes)
+         call state_left_%compute_fluxes(eos=eos_left, normal=normal, fluxes=fluxes)
          state23%density  = r_1 * (s_1 - u_1) / (s_1 - u23)
          state23%momentum = state23%density * u23 * normal
          state23%energy   = state23%density * (E_1 + (u23 - u_1) * (u23 + p_1 / (r_1 * (s_1 - u_1))))
          select type(fluxes)
          type is(conservative_compressible)
 #ifdef __GFORTRAN__
-            fluxes = fluxes + s_1 * (state23 - state_left_)
+            fluxes = fluxes + (s_1 * (state23 - state_left_))
 #else
             error stop 'error: Intel fortran still does not support abstract math!'
 #endif
          endselect
       case(3)
-         call state_right%compute_fluxes(eos=eos_right, normal=normal, fluxes=fluxes)
+         call state_right_%compute_fluxes(eos=eos_right, normal=normal, fluxes=fluxes)
          state23%density  = r_4 * (s_4 - u_4) / (s_4 - u23)
          state23%momentum = state23%density * u23 * normal
          state23%energy   = state23%density * (E_4 + (u23 - u_4) * (u23 + p_4 / (r_4 * (s_4 - u_4))))
          select type(fluxes)
          type is(conservative_compressible)
 #ifdef __GFORTRAN__
-            fluxes = fluxes + s_4 * (state23 - state_right_)
+            fluxes = fluxes + (s_4 * (state23 - state_right_))
 #else
             error stop 'error: Intel fortran still does not support abstract math!'
 #endif
          endselect
       case(4)
-         call state_right%compute_fluxes(eos=eos_right, normal=normal, fluxes=fluxes)
+         call state_right_%compute_fluxes(eos=eos_right, normal=normal, fluxes=fluxes)
       endselect
    endassociate
    endsubroutine solve

src/lib/foreseer_riemann_solver_compressible_llf.F90

@@ -21,8 +21,9 @@ module foreseer_riemann_solver_compressible_llf
    !< @note This is the implemention for [[conservative_compressible]] Riemann states.
    contains
       ! public deferred methods
-      procedure, pass(self) :: initialize !< Initialize solver.
-      procedure, pass(self) :: solve      !< Solve Riemann Problem.
+      procedure, pass(self) :: initialize       !< Initialize solver.
+      procedure, pass(lhs)  :: riem_assign_riem !< `=` operator.
+      procedure, pass(self) :: solve            !< Solve Riemann Problem.
 endtype riemann_solver_compressible_llf
 
 contains
@@ -37,6 +38,14 @@ subroutine initialize(self, config)
    ! call self%solver_pvl%initialize(config=config_)
    endsubroutine initialize
 
+   pure subroutine riem_assign_riem(lhs, rhs)
+   !< `=` operator.
+   !<
+   !< @TODO Update this if solver is updated.
+   class(riemann_solver_compressible_llf), intent(inout) :: lhs !< Left hand side.
+   class(riemann_solver_object),           intent(in)    :: rhs !< Right hand side.
+   endsubroutine riem_assign_riem
+
    subroutine solve(self, eos_left, state_left, eos_right, state_right, normal, fluxes)
    !< Solve Riemann Problem.
    !<
@@ -49,19 +58,19 @@ subroutine solve(self, eos_left, state_left, eos_right, state_right, normal, flu
    type(vector),                           intent(in)    :: normal       !< Normal (versor) of face where fluxes are given.
    class(conservative_object),             intent(inout) :: fluxes       !< Fluxes of the Riemann Problem solution.
    type(riemann_pattern_compressible_pvl)                :: pattern      !< Riemann (states) PVL pattern solution.
-   type(conservative_compressible), pointer              :: state_left_  !< Left Riemann state, local variable.
-   type(conservative_compressible), pointer              :: state_right_ !< Right Riemann state, local variable.
+   type(conservative_compressible)                       :: state_left_  !< Left Riemann state, local variable.
+   type(conservative_compressible)                       :: state_right_ !< Right Riemann state, local variable.
    type(conservative_compressible)                       :: fluxes_left  !< Fluxes of left state.
    type(conservative_compressible)                       :: fluxes_right !< Fluxes of right state.
    real(R8P)                                             :: lmax         !< Maximum wave speed estimation.
 
-   call pattern%initialize(eos_left=eos_left, state_left=state_left, eos_right=eos_right, state_right=state_right, normal=normal)
+   state_left_ = state_left ; call state_left_%normalize(eos=eos_left, normal=normal)
+   state_right_ = state_right ; call state_right_%normalize(eos=eos_right, normal=normal)
+   call pattern%initialize(eos_left=eos_left, state_left=state_left_, eos_right=eos_right, state_right=state_right_, normal=normal)
    call pattern%compute_waves_extrema
    lmax = max(abs(pattern%s_1), abs(pattern%s_4))
-   call state_left%compute_fluxes(eos=eos_left, normal=normal, fluxes=fluxes_left)
-   call state_right%compute_fluxes(eos=eos_right, normal=normal, fluxes=fluxes_right)
-   state_left_ => conservative_compressible_pointer(to=state_left)
-   state_right_ => conservative_compressible_pointer(to=state_right)
+   call state_left_%compute_fluxes(eos=eos_left, normal=normal, fluxes=fluxes_left)
+   call state_right_%compute_fluxes(eos=eos_right, normal=normal, fluxes=fluxes_right)
    select type(fluxes)
    type is(conservative_compressible)
 #ifdef __GFORTRAN__

src/lib/foreseer_riemann_solver_compressible_pvl.f90

@@ -21,8 +21,9 @@ module foreseer_riemann_solver_compressible_pvl
    !< @note This is the implemention for [[conservative_compressible]] Riemann states.
    contains
       ! public deferred methods
-      procedure, pass(self) :: initialize !< Initialize solver.
-      procedure, pass(self) :: solve      !< Solve Riemann Problem.
+      procedure, pass(self) :: initialize       !< Initialize solver.
+      procedure, pass(lhs)  :: riem_assign_riem !< `=` operator.
+      procedure, pass(self) :: solve            !< Solve Riemann Problem.
 endtype riemann_solver_compressible_pvl
 
 contains
@@ -43,18 +44,30 @@ subroutine initialize(self, config)
    endselect
    endsubroutine initialize
 
+   pure subroutine riem_assign_riem(lhs, rhs)
+   !< `=` operator.
+   !<
+   !< @TODO Update this if solver is updated.
+   class(riemann_solver_compressible_pvl), intent(inout) :: lhs !< Left hand side.
+   class(riemann_solver_object),           intent(in)    :: rhs !< Right hand side.
+   endsubroutine riem_assign_riem
+
    pure subroutine solve(self, eos_left, state_left, eos_right, state_right, normal, fluxes)
    !< Solve Riemann problem by PVL algorithm.
-   class(riemann_solver_compressible_pvl), intent(in)    :: self        !< Solver.
-   class(eos_object),                      intent(in)    :: eos_left    !< Equation of state for left state.
-   class(conservative_object),             intent(in)    :: state_left  !< Left Riemann state.
-   class(eos_object),                      intent(in)    :: eos_right   !< Equation of state for right state.
-   class(conservative_object),             intent(in)    :: state_right !< Right Riemann state.
-   type(vector),                           intent(in)    :: normal      !< Normal (versor) of face where fluxes are given.
-   class(conservative_object),             intent(inout) :: fluxes      !< Fluxes of the Riemann Problem solution.
-   type(riemann_pattern_compressible_pvl)                :: pattern     !< Riemann (states) pattern solution.
-
-   call pattern%initialize(eos_left=eos_left, state_left=state_left, eos_right=eos_right, state_right=state_right, normal=normal)
+   class(riemann_solver_compressible_pvl), intent(in)    :: self         !< Solver.
+   class(eos_object),                      intent(in)    :: eos_left     !< Equation of state for left state.
+   class(conservative_object),             intent(in)    :: state_left   !< Left Riemann state.
+   class(eos_object),                      intent(in)    :: eos_right    !< Equation of state for right state.
+   class(conservative_object),             intent(in)    :: state_right  !< Right Riemann state.
+   type(vector),                           intent(in)    :: normal       !< Normal (versor) of face where fluxes are given.
+   class(conservative_object),             intent(inout) :: fluxes       !< Fluxes of the Riemann Problem solution.
+   type(conservative_compressible)                       :: state_left_  !< Left Riemann state, local variable.
+   type(conservative_compressible)                       :: state_right_ !< Right Riemann state, local variable.
+   type(riemann_pattern_compressible_pvl)                :: pattern      !< Riemann (states) pattern solution.
+
+   state_left_ = state_left ; call state_left_%normalize(eos=eos_left, normal=normal)
+   state_right_ = state_right ; call state_right_%normalize(eos=eos_right, normal=normal)
+   call pattern%initialize(eos_left=eos_left, state_left=state_left_, eos_right=eos_right, state_right=state_right_, normal=normal)
    call pattern%compute
    call pattern%compute_fluxes(normal=normal, fluxes=fluxes)
    endsubroutine solve