Users guide update

example.

.gitignore

@@ -5,6 +5,7 @@
 
 # header files generated
 cbind/*.h
+amgprec/amg_config.h
 
 # Make.inc generated
 /Make.inc
@@ -20,3 +21,5 @@ autom4te.cache
 # the executable from tests
 runs
 
+# Documentation temporary files
+docs/src/userguide.pdf

CMakeLists.txt

@@ -0,0 +1,383 @@
+cmake_minimum_required(VERSION 3.10)
+project(amg4psblas VERSION 1.0 LANGUAGES C Fortran)
+
+
+set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake")
+
+
+set(PSBLAS_INSTALL_DIR "" CACHE PATH "Path to the PSBLAS installation
+directory")
+if(PSBLAS_INSTALL_DIR STREQUAL "")
+     message(FATAL_ERROR "Please specify the path to the PSBLAS installation directory using -DPSBLAS_INSTALL_DIR=<path> or set it in ccmake.")
+endif()
+
+
+# Check for the installation path for psblas
+#if(NOT DEFINED PSBLAS_INSTALL_DIR)
+#    message(FATAL_ERROR "Please specify the path to the psblas installation directory using -DPSBLAS_INSTALL_DIR=<path>")
+#endif()
+message(STATUS "psblas directory is ${PSBLAS_INSTALL_DIR};;")
+
+
+message(STATUS "PSBLAS DIRECTORY INC ${INCDIR}; MOD ${MODDIR}; LIB ${LIBDIR};")
+
+# Find the psblas package
+find_package(psblas REQUIRED PATHS ${PSBLAS_INSTALL_DIR})
+
+if(NOT psblas_FOUND)
+    message(FATAL_ERROR "PSBLAS not found!")
+else()
+    message(STATUS "Found PSBLAS: ${psblas_LIBRARIES}")
+endif()
+
+
+# Set the include and library directories based on the provided path
+#set(TEST_INSTALLDIR "${PSBLAS_INSTALL_DIR}")
+set(INCDIR "${PSBLAS_INSTALL_DIR}/${PSB_CMAKE_INSTALL_INCLUDEDIR}")
+set(MODDIR "${PSBLAS_INSTALL_DIR}/${PSB_CMAKE_INSTALL_MODULDIR}")
+set(LIBDIR "${PSBLAS_INSTALL_DIR}/${PSB_CMAKE_INSTALL_LIBDIR}")
+
+
+# Include directories for the project
+include_directories(${PSBLAS_INSTALL_DIR})
+
+
+# Include directories for the Fortran compiler
+include_directories(${INCDIR} ${MODDIR} ${LIBDIR})
+
+
+
+message(STATUS "Using IPK size: ${PSB_IPK_SIZE}")
+message(STATUS "Using LPK size: ${PSB_LPK_SIZE}")
+
+# Add PSB_IPK/LPK flag only for fortran files.
+set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -DPSB_IPK${PSB_IPK_SIZE}")
+set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -DPSB_LPK${PSB_LPK_SIZE}")
+
+
+
+
+# Specify the installation directory
+
+#set(${CMAKE_INSTALL_LIBDIR} "lib")
+#message(STATUS "\t\t install libdir ${CMAKE_INSTALL_LIBDIR};")
+#set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_BINDIR}/${${CMAKE_PROJECT_NAME}_dist_string}-tests")
+#set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}")
+#set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}")
+
+
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_BINDIR}/${${CMAKE_PROJECT_NAME}_dist_string}-tests")
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}")
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}")
+#set(CMAKE_INSTALL_LIBDIR "lib" CACHE STRING "Library install directory")
+#set(CMAKE_INSTALL_INCLUDEDIR "include" CACHE STRING "Include directory")
+#set(CMAKE_INSTALL_MODULDIR "modules" CACHE STRING "Module directory")
+
+message(STATUS "Initial CMAKE_INSTALL_LIBDIR: ${CMAKE_INSTALL_LIBDIR}")
+set(AMG_CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})
+
+if(NOT AMG_CMAKE_INSTALL_LIBDIR)
+    message(STATUS "CMAKE_INSTALL_LIBDIR is set to default value lib")
+    #set(CMAKE_INSTALL_LIBDIR "lib" CACHE STRING "Library install directory" FORCE)
+    set(CMAKE_INSTALL_LIBDIR ${PSB_CMAKE_INSTALL_LIBDIR})
+    set(AMG_CMAKE_INSTALL_LIBDIR ${PSB_CMAKE_INSTALL_LIBDIR})
+else()
+    set(CMAKE_INSTALL_LIBDIR ${AMG_CMAKE_INSTALL_LIBDIR})
+    message(STATUS "CMAKE_INSTALL_LIBDIR is set to: ${CMAKE_INSTALL_LIBDIR}")
+endif()
+
+if(NOT AMG_CMAKE_INSTALL_INCLUDEDIR)
+    message(STATUS "CMAKE_INSTALL_INCLUDEDIR is set to default value lib")
+    #set(CMAKE_INSTALL_INCLUDEDIR "include" CACHE STRING "Include directory" FORCE)
+    set(CMAKE_INSTALL_INCLUDEDIR ${PSB_CMAKE_INSTALL_INCLUDEDIR})
+    set(AMG_CMAKE_INSTALL_INCLUDEDIR ${PSB_CMAKE_INSTALL_INCLUDEDIR})
+else()
+    set(CMAKE_INSTALL_INCLUDEDIR ${AMG_CMAKE_INSTALL_INCLUDEDIR})
+    message(STATUS "CMAKE_INSTALL_INCLUDEDIR is set to: ${CMAKE_INSTALL_INCLUDEDIR}")
+endif()
+
+if(NOT AMG_CMAKE_INSTALL_MODULDIR)
+    message(STATUS "CMAKE_INSTALL_MODULDIR is set to default value lib")
+    #set(CMAKE_INSTALL_MODULDIR "modules" CACHE STRING "Modules directory" FORCE)
+    set(CMAKE_INSTALL_MODULDIR ${PSB_CMAKE_INSTALL_MODULDIR})
+    set(AMG_CMAKE_INSTALL_LIBDIR ${PSB_CMAKE_INSTALL_MODULDIR})
+else()
+    set(CMAKE_INSTALL_MODULDIR ${AMG_CMAKE_INSTALL_MODULDIR})
+    message(STATUS "CMAKE_INSTALL_MODULDIR is set to: ${CMAKE_INSTALL_MODULDIR}")
+endif()
+
+
+
+
+
+
+
+
+
+
+  
+
+
+#-----------------------------------------------------
+# Publicize installed location to other CMake projects
+#-----------------------------------------------------
+#install(EXPORT ${CMAKE_PROJECT_NAME}-targets
+#  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake"
+#)
+
+
+message(STATUS "NAME project ${CMAKE_PROJECT_NAME};")
+
+install(EXPORT ${CMAKE_PROJECT_NAME}-targets
+  FILE ${CMAKE_PROJECT_NAME}Config.cmake
+  NAMESPACE ${CMAKE_PROJECT_NAME}::
+  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake"
+)
+
+
+include(CMakePackageConfigHelpers) # standard CMake module
+write_basic_package_version_file(
+  "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}ConfigVersion.cmake"
+  VERSION "${amg4psblas_VERSION}"
+  COMPATIBILITY SameMajorVersion
+  )
+
+configure_file("${CMAKE_SOURCE_DIR}/cmake/pkg/${CMAKE_PROJECT_NAME}Config.cmake.in"
+  "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${CMAKE_PROJECT_NAME}Config.cmake" @ONLY)
+
+install(
+  FILES
+    "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${CMAKE_PROJECT_NAME}Config.cmake"
+    "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}ConfigVersion.cmake"
+    "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}Targets.cmake"
+  DESTINATION
+    "${CMAKE_INSTALL_LIBDIR}/cmake/${CMAKE_PROJECT_NAME}"
+)
+
+
+
+
+
+
+
+#------------------------------------------
+# Add portable unistall command to makefile
+#------------------------------------------
+# Adapted from the CMake Wiki FAQ
+configure_file ( "${CMAKE_SOURCE_DIR}/cmake/uninstall.cmake.in" "${CMAKE_BINARY_DIR}/uninstall.cmake"
+  @ONLY)
+
+add_custom_target ( uninstall
+  COMMAND ${CMAKE_COMMAND} -P "${CMAKE_BINARY_DIR}/uninstall.cmake" )
+
+add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure)
+# See JSON-Fortran's CMakeLists.txt file to find out how to get the check target to depend
+# on the test executables
+
+#----------------------------------
+# Determine if we're using Open MPI
+#---------------------------------
+if(MPI_FOUND)
+  execute_process(COMMAND ${MPIEXEC} --version
+    OUTPUT_VARIABLE mpi_version_out)
+  if (mpi_version_out MATCHES "[Oo]pen[ -][Mm][Pp][Ii]")
+    message( STATUS "OpenMPI detected")
+    set ( openmpi true )
+  endif()
+endif()
+
+
+
+#------------------------------------------
+# Configure the amg_config.h file
+#------------------------------------------
+
+message(STATUS "bin dir ${CMAKE_CURRENT_BINARY_DIR}; source dir ${CMAKE_CURRENT_SOURCE_DIR};;")
+configure_file(
+    ${CMAKE_CURRENT_SOURCE_DIR}/amgprec/amg_config.h.in 
+    ${CMAKE_CURRENT_BINARY_DIR}/include/amg_config.h 	
+    @ONLY  # Replace variables only
+)
+
+
+
+#---------------------------------------
+# Add the AMG libraries
+#---------------------------------------
+
+
+
+
+
+
+include(${CMAKE_CURRENT_LIST_DIR}/amgprec/CMakeLists.txt)  # include amgprec_source_files and amgprec_source_C_files source files
+
+include_directories("${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}")
+
+add_library(amgprec_C OBJECT ${amgprec_source_C_files})
+
+target_link_libraries(amgprec_C
+  #PUBLIC ${LAPACK_LINKER_FLAGS} ${LAPACK_LIBRARIES} ${LAPACK95_LIBRARIES}
+  #PUBLIC ${BLAS_LINKER_FLAGS} ${BLAS_LIBRARIES} ${BLAS95_LIBRARIES}
+  psblas::util psblas::linsolve psblas::prec psblas::ext psblas::cbind psblas::base)  #TODO  check actual libraries needed
+
+add_library(amgprec ${amgprec_source_files} $<TARGET_OBJECTS:amgprec_C>)
+
+set_target_properties(amgprec
+  PROPERTIES
+  Fortran_MODULE_DIRECTORY "${CMAKE_BINARY_DIR}/modules"  
+  POSITION_INDEPENDENT_CODE TRUE
+  OUTPUT_NAME psb_amgprec
+  LINKER_LANGUAGE Fortran
+  )
+
+target_include_directories(amgprec PUBLIC
+  $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/modules> 
+  $<INSTALL_INTERFACE:modules>)
+
+message(STATUS "include dir := ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}")
+
+#target_include_directories(base PUBLIC ${CMAKE_Fortran_MODULE_DIRECTORY})
+
+target_include_directories(amgprec PUBLIC ${INCDIR} ${MODDIR})
+target_link_libraries(amgprec
+  #PUBLIC ${LAPACK_LINKER_FLAGS} ${LAPACK_LIBRARIES} ${LAPACK95_LIBRARIES}
+  #PUBLIC ${BLAS_LINKER_FLAGS} ${BLAS_LIBRARIES} ${BLAS95_LIBRARIES}
+  psblas::util psblas::linsolve psblas::prec psblas::ext psblas::cbind psblas::base)  #TODO  check actual libraries needed
+
+
+
+
+
+
+
+include(${CMAKE_CURRENT_LIST_DIR}/cbind/CMakeLists.txt)  # include amgprec_source_files and amgprec_source_C_files source files
+
+
+foreach(path IN LISTS amgcbind_header_C_files)
+  # Copy the header file to the include directory
+  file(COPY "${path}" DESTINATION "${CMAKE_BINARY_DIR}/include")
+endforeach()
+
+
+add_library(amgcbind_C OBJECT ${amgprec_source_C_files})
+
+target_link_libraries(amgcbind_C
+  #PUBLIC ${LAPACK_LINKER_FLAGS} ${LAPACK_LIBRARIES} ${LAPACK95_LIBRARIES}
+  #PUBLIC ${BLAS_LINKER_FLAGS} ${BLAS_LIBRARIES} ${BLAS95_LIBRARIES}
+  psblas::util psblas::linsolve psblas::prec psblas::ext psblas::cbind psblas::base)  #TODO  check actual libraries needed
+
+add_library(amgcbind ${amgprec_source_files} $<TARGET_OBJECTS:amgcbind_C>)
+
+set_target_properties(amgcbind
+  PROPERTIES
+  Fortran_MODULE_DIRECTORY "${CMAKE_BINARY_DIR}/modules"  
+  POSITION_INDEPENDENT_CODE TRUE
+  OUTPUT_NAME psb_amgcbind
+  LINKER_LANGUAGE Fortran
+  )
+
+target_include_directories(amgcbind PUBLIC
+  $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/modules> 
+  $<INSTALL_INTERFACE:modules>)
+
+message(STATUS "include dir := ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}")
+
+#target_include_directories(base PUBLIC ${CMAKE_Fortran_MODULE_DIRECTORY})
+
+target_include_directories(amgcbind PUBLIC ${INCDIR} ${MODDIR})
+target_link_libraries(amgcbind
+  #PUBLIC ${LAPACK_LINKER_FLAGS} ${LAPACK_LIBRARIES} ${LAPACK95_LIBRARIES}
+  #PUBLIC ${BLAS_LINKER_FLAGS} ${BLAS_LIBRARIES} ${BLAS95_LIBRARIES}
+  PUBLIC amgprec psblas::util psblas::linsolve psblas::prec psblas::ext psblas::cbind psblas::base)  #TODO  check actual libraries needed
+
+
+
+
+
+
+install(DIRECTORY ${CMAKE_BINARY_DIR}/include/ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+  FILES_MATCHING PATTERN "*.h")
+
+install(DIRECTORY ${CMAKE_BINARY_DIR}/modules/ DESTINATION "${CMAKE_INSTALL_MODULDIR}"
+  FILES_MATCHING PATTERN "*.mod")
+
+
+
+
+
+
+# Install the library
+install(TARGETS amgprec amgcbind
+  EXPORT ${CMAKE_PROJECT_NAME}-targets
+  DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+  LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+)
+
+
+
+if(WIN32) #TODO
+#  install(TARGETS psb_base_C
+#    EXPORT ${CMAKE_PROJECT_NAME}-targets
+#    DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+#    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+#    )
+#  if(METIS_FOUND)
+#    install(TARGETS psb_util_C
+#      EXPORT ${CMAKE_PROJECT_NAME}-targets
+#      DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+#      LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+#      )
+#  endif()
+endif()
+
+
+message(STATUS "install directory is ${CMAKE_INSTALL_LIBDIR};;;")
+
+# Step 2: Create the configuration file from the template
+#configure_package_config_file(
+#  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/amg4psblasConfig.cmake.in"
+#  "${CMAKE_CURRENT_BINARY_DIR}/amg4psblasConfig.cmake"
+#  INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/amg4psblas"
+#)
+
+# Step 3: Install the generated config files
+#install(FILES 
+#  "${CMAKE_CURRENT_BINARY_DIR}/amg4psblasConfig.cmake"
+#  "${CMAKE_CURRENT_BINARY_DIR}/amg4psblasConfigVersion.cmake"
+#  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/amg4psblas"
+#)
+
+# Step 4: Export targets so that the build directory can be used directly
+#export(
+#  EXPORT ${CMAKE_PROJECT_NAME}-targets
+#  FILE "${CMAKE_CURRENT_BINARY_DIR}/amg4psblasTargets.cmake"
+#    NAMESPACE psblas::
+#)
+export(
+  EXPORT ${CMAKE_PROJECT_NAME}-targets
+  FILE "${CMAKE_CURRENT_BINARY_DIR}/psblasTargets.cmake"
+    NAMESPACE ${CMAKE_PROJECT_NAME}::
+)
+
+export(
+  EXPORT ${CMAKE_PROJECT_NAME}-targets
+  FILE "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}Targets.cmake"
+    NAMESPACE ${CMAKE_PROJECT_NAME}::
+)
+
+		
+ 
+
+# Optionally, you can install the headers
+#install(DIRECTORY include/
+#    DESTINATION include
+#)
+
+
+
+message(STATUS "CMAKE_INSTALL_PREFIX: ${CMAKE_INSTALL_PREFIX} - ${PSB_CMAKE_INSTALL_PREFIX};")
+message(STATUS "CMAKE_INSTALL_LIBDIR: ${CMAKE_INSTALL_LIBDIR} - ${PSB_CMAKE_INSTALL_LIBDIR};")
+message(STATUS "CMAKE_INSTALL_INCLUDEDIR: ${CMAKE_INSTALL_INCLUDEDIR} - ${PSB_CMAKE_INSTALL_INCLUDEDIR};")
+message(STATUS "CMAKE_INSTALL_MODULDIR: ${CMAKE_INSTALL_MODULDIR} - ${PSB_CMAKE_INSTALL_MODULDIR};")
+

Changelog

@@ -1,165 +0,0 @@
-Changelog. A lot less detailed than usual, at least for past
-	history.
-2022/05/20: Restart ChangeLog. Updated to new name AMG4PSBLAS, now using PSB3.8	
-2018/10/28: Fix interface to MUMPS and configry machinery. Require PSB 3.6.
-2018/10/10: ICTXT argument in prec%init().	
-2018/07/30: Fixes for Intel compilers. BootCMatch interface in examples. 	
-2018/05/14: Interface for extension of aggregation methods. 	
-2018/02/28: New cartesian distribution for sample programs.	
-2017/12/15: New WRK component of preconditioner levels, preallocation.	
-2017/10/25: New example input file formats. Added sample matrices.	
-2017/10/02: New CBIND in PSBLAS 3.5.0	
-2017/07/30: Refactored examples. Change default thresholds. 
-2017/05/31: New internal description of ML. 
-2017/05/16: Improve build process. 
-2017/04/20: Force %set interface. Update docs.	
-2017/04/03: Remove obsolete stuff. 	
-2017/03/17: Fixed level%cnv;  add coarse _solver tracker.	
-2017/02/18: Take out clean_zeros; changed NOFILTER; defined FBGS; take out
-	n_prec_levs.
-2017/02/12: Updated mat_dist usage, dubious SP shell for UMFPACK, fixes
-	for RPM packaging.      
-2017/02/02: Fix superlu configury	
-2016/11/12: Fix hierarchy/smoothers build to handle 1 level.	
-2016/10/03: Merged changes to hierearchy building.	
-2016/08/20: Reimplemented decoupled aggregation	
-2016/07/20: Refactored application of multilevel. Defined V,W and
-	K-cycles. 	
-2016/05/18: Reworked internals of PRECSET. Defined  Forward-Backward
-	Gauss-Seidel solver. Now available separate PRE and POST smoother
-	objects. 
-2016/03/30: MUMPS interface.	
-2016/02/28: Hybrid Gauss-Seidel method. 	
-2016/02/03: unify integer argument checks.	
-2015/12/15: defaults single vs. double precision. Use clean_zeros.	
-2015/12/08: new matdist interface	
-2015/10/17: configry fixes	
-2015/10/13: Fixes for SLUDIST versions 3 and 4
-2015/05/03: New heap interface	
-2015/04/21: INTENT fixes
-	
-2014/12/21: New error handling
-	
-2014/10/27: Added versioncheck to configure.
-	
-2014/03/31: New get_diag. 
-	 
-2013/11/07: Merged changes from experimental branch. Fix INCDIR in
-	    makefiles. 
-       
-2013/07/15: Fixes for UMFPACK 5.4, SuperLU 4.3, SuperLU_Dist 3.3
-	
-2013/04/05: CLONE method.	
-	
-2013/03/08: Reworked SET routines. 	
-	
-2012/12/10: Enable long_integers.
-	
-2012/12/05: Split smoother/solver objects.	
-	
-2012/04/30: New scheme to find dynamically the number of level based on
-	    the size of the coarse matrix
-	
-2012/01/10: Done split interface/implementation, plus subdir restructure.
-	
-2011/12/13: Start split interface/implementation to improve build time. 	
-	
-2011/11/25: Now works with _vect methods from PSBLAS. 	
-	
-2011/10/24: New test generation methods.
-	
-2011/06/15: Dump prolongator/restrictor
-	
-2011/04/14: Added MOLD argument(s) to precbld.       
-	
-2011/03/30: Fixed: descriptive methods, example programs.
-	
-2011/03/08: Re-factored modules for ILU methods.	
-	
-2011/03/04: Make X intent(inout) in APPLY to allow for preconditioners
-            using SPMM. 	
-	
-2011/03/02: New set methods.
-	
-2011/01/07: Fixed UMF interfacing for Z data.
-
-2011/01/04: Added UMF inteface for D data.
-	
-2011/01/02: Fix usage of DESC_DATA. Switched all names to F90 ending. 
-
-2010/12/16: Fix usage of replicated space descriptor.
-
-2010/11/16: Fix Jacobi smoother in case of empty off-diagonal. 	
-
-2010/11/04: Defined and tested single real and complex.
-
-2010/11/02: Aligned usage of sparse data type with psblas3.
-
-2009/12/22: Aligned constants with mld2p4 v1.2
-
-2009/12/11: First working version of double multilevel.
-
-2009/12/05: Inttroduction of Smoother/Solver object hierarchy.
-
-2009/09/23: Initial F2003 version. 	
-      
-	
-2009/01/28: Changed names from XbaseprcY to XbaseprecY.
-2009/01/27: Changed names from mld_transfer to mld_move_alloc.
-	
-2009/01/13: Repackaged the one-level preconditioners. Reorganized the
-            build routines, taking out mlprec_bld, and switching the
-	    number of levels when needed. 
-2008/10/27: Changed the definition of prec_type: repackaged with a
-	    onelev-prec-type, containing a baseprec and maps between
-	    index spaces. No performance impact; no changes to
-	    user-level interfaces.
-	
-2008/09/18: Changed mld_sizeof to integer(8); updated samples.	
-	
-2008/08/26: Fixed matrix generation in sample programs. 
-	
-2008/07/25: missing implicit none in mld_prec_type.	
-	
-2008/07/23: added HTML documentation  
-	
-2008/06/13: Fixed aggregation for replicated index spaces.
-
-2008/06/02: Threshold into decoupled aggregation algorithm.
-	
-2008/05/27: Single precision version.
-
-2008/03/09: Introduced configure script. 
-	
-2008/02/08: Merged changes from intermesh branch: we now have an
-	    inter_desc_type object. Cleaned up data allocation and
-	    variable initialization in multilevel prec application.
-
-2008/01/10: Merged various fixes for: prologues, unused variables,
-	    interface details.	
-2007/12/21: Merge version with prologues and internal docs.
-	
-2007/11/15: Created pargen example.	
-
-2007/11/14: Fix INTENT(IN) on X vector in preconditioner routines.
-
-2007/10/19: Merged in ILU(P,T). To be tested extensively.
-
-2007/10/17: Merged ILU(K) into trunk.
-
-2007/10/16: Fixed ILU(K), it now performs satisfactorily. Also updated
-	    ILU(0) to be more legible. 
-	
-2007/10/11: First working version of ILU(K). Still slow, there should
-	    be room for improvement. 
-	
-2007/10/09: Added benchmark code.
-
-2007/10/09: Added MILU_N_. Beware: values for UMF_ etc. have been
-	    shifted. 
-
-2007/10/02: To do: decide whether to name MLD_KRYLOV_MOD or
-	    PSB_KRYLOV_MOD. 
-
-2007/10/01: Start of this changelog. MLD2P4 now has a different
-	    structure, to enable a build not embedded in PSBLAS.

LICENSE

@@ -1,10 +1,10 @@
   
    
-                             AMG4PSBLAS version 1.1
+                             AMG4PSBLAS version 1.2
     Algebraic Multigrid Package
-               based on PSBLAS (Parallel Sparse BLAS version 3.8)
+               based on PSBLAS (Parallel Sparse BLAS version 3.9)
     
-    (C) Copyright 2022
+    (C) Copyright 2025
   
         Salvatore Filippone  
         Pasqua D'Ambra   

Make_n.inc.in

@@ -49,7 +49,7 @@ PSBLAS_INCLUDES=@PSBLAS_INCLUDES@
 PSBLAS_LIBS=@PSBLAS_LIBS@	
 PSBBASEMODNAME=psb_base_mod
 PSBPRECMODNAME=psb_prec_mod
-PSBMETHDMODNAME=psb_krylov_mod
+PSBMETHDMODNAME=psb_linsolve_mod
 PSBUTILMODNAME=psb_util_mod
 
 

Makefile

@@ -3,9 +3,9 @@ include Make.inc
 
 all:  objs lib
 
-objs: amgp cbnd
+objs: libdir amgp cbnd
 
-lib: libdir objs
+lib:  objs
 	cd amgprec && $(MAKE) lib
 	cd cbind && $(MAKE)  lib
 
@@ -21,7 +21,7 @@ amgp:
 cbnd: amgp
 	cd cbind && $(MAKE)  objs
 
-install: lib
+install: all
 	mkdir -p $(INSTALL_LIBDIR) &&\
 	   $(INSTALL_DATA) lib/*.a  $(INSTALL_LIBDIR)
 	mkdir -p  $(INSTALL_INCLUDEDIR) &&\
@@ -44,8 +44,10 @@ cleanlib:
 	(cd include; /bin/rm -f *.a *$(.mod) *$(.fh))
 	(cd modules; /bin/rm -f *.a *$(.mod) *$(.fh))
 
-veryclean: cleanlib
-	(cd amgprec && $(MAKE) veryclean)
+distclean: clean samplesclean
+	/bin/rm -fr Make.inc amgprec/amg_config.h
+
+samplesclean: clean
 	(cd samples/simple/fileread && $(MAKE) clean)
 	(cd samples/simple/pdegen && $(MAKE) clean)
 	(cd samples/advanced/fileread && $(MAKE) clean)
@@ -54,5 +56,6 @@ veryclean: cleanlib
 check: all
 	make check -C samples/advanced/pdegen
 
-clean:
-	(cd amgprec && $(MAKE) clean)
+clean:  cleanlib
+	(cd amgprec && $(MAKE) veryclean)
+	(cd cbind && $(MAKE) veryclean)

README.md

@@ -1,54 +1,82 @@
-                         AMG4PSBLAS  
- Algebraic Multigrid Package  based on PSBLAS (Parallel Sparse BLAS version 3.8)
-    
-Salvatore Filippone    (University of Rome Tor Vergata and IAC-CNR)
-Pasqua D'Ambra         (IAC-CNR, Naples, IT)
-Fabio Durastante       (IAC-CNR, Naples, IT)
+# AMG4PSBLAS  v1.2
+Algebraic Multigrid Package  based on [PSBLAS](https://github.com/sfilippone/psblas3) (Parallel Sparse BLAS version 3.9)
 
----------------------------------------------------------------------
+AMG4PSBLAS is a package of parallel algebraic multilevel preconditioners included in the PSCToolkit (Parallel Sparse Computation Toolkit) software framework.
 
-AMG4PSBLAS is a package of Algebraic MultiGrid (AMG)
-preconditioners for  the iterative solution of large and sparse linear systems.
+It is a progress of a software development project started in 2007, named MLD2P4, which originally implemented a multilevel version of some domain decomposition preconditioners of additive-Schwarz type and was based on a parallel decoupled version of the well known smoothed aggregation method to generate the multilevel hierarchy of coarser matrices.
 
-It is an evolution of MLD2P4 (see LICENSE.MLD2P4), but it has been
-thoroughly reworked, and it is sufficiently different to warrant a new
-project name.
+In the last years the package was extended for including new algorithms and functionalities for the setup and application new AMG preconditioners with the final aims of improving efficiency and scalability when tens of thousands cores are used and of boosting reliability in dealing with general symmetric positive definite linear systems.
 
+It is an evolution of MLD2P4 (see [LICENSE.MLD2P4](LICENSE.MLD2P4)), but due to the significant number of changes and the increase in scope, we decided to rename the package as AMG4PSBLAS.
 
-MAIN REFERENCES:
+AMG4PSBLAS has been designed to provide scalable and easy-to-use preconditioners in the context of the PSBLAS (Parallel Sparse Basic Linear Algebra Subprograms) computational framework and can be used in conjuction with the Krylov solvers available in this framework. Our package is based on a completely algebraic approach; therefore users level interfaces assume that the system matrix and preconditioners are represented as PSBLAS distributed sparse matrices.
 
-     
+AMG4PSBLAS enables the user to easily specify different features of an algebraic multilevel preconditioner, thus allowing to experiment with different preconditioners for the problem and parallel computers at hand.
 
-P. D'Ambra, D. di Serafino, S. Filippone,
-MLD2P4: a Package of Parallel Algebraic Multilevel Domain Decomposition
-Preconditioners in Fortran 95,
-ACM Transactions on Mathematical Software, 37 (3), 2010, art. 30,
-doi: 10.1145/1824801.1824808.
+The package employs object-oriented design techniques in Fortran 2008, with interfaces to additional third party libraries such as MUMPS, UMFPACK, SuperLU, and SuperLU_Dist, which can be exploited in building multilevel preconditioners. The parallel implementation is based on a Single Program Multiple Data (SPMD) paradigm; the inter-process communication is based on MPI and is managed mainly through PSBLAS.
 
+## Main Refrerences:
 
-TO COMPILE
+The main reference for this project is
+> D'Ambra, P., Durastante, F., & Filippone, S. (2021). AMG preconditioners for linear solvers towards extreme scale. SIAM Journal on Scientific Computing, 43(5), S679-S703.
+
+AMG4PSBLAS is the suite of preconditioners for the Parallel Sparse Computation Toolkit ([PSCToolkit](https://psctoolkit.github.io/)) suite of libraries. See the paper:
+> D’Ambra, P., Durastante, F., & Filippone, S. (2023). Parallel Sparse Computation Toolkit. Software Impacts, 15, 100463.
+
+The main reference for features inherited from MLD2P4 is
+> P. D'Ambra, D. di Serafino, S. Filippone,
+> MLD2P4: a Package of Parallel Algebraic Multilevel Domain Decomposition
+> Preconditioners in Fortran 95,
+> ACM Transactions on Mathematical Software, 37 (3), 2010, art. 30,
+> doi: 10.1145/1824801.1824808.
+
+## Installing
+
+Installation requires having a working version of the [PSBLAS](https://github.com/sfilippone/psblas3) library installed.
+AMG4PSBLAS has several interfaces to third-party libraries that can be used in the construction and application phases of preconditioners. 
+In particular, it is possible to link AMG4PSBLAS with the libraries: MUMPS, SuperLU, SuperLU_Dist, UMFPACK. This is _not mandatory_ and the library can run 
+in isolation and without these features.
 
 0. Unpack the tar file in a directory of your choice (preferrably
    outside the main PSBLAS directory).
-1. run configure --with-psblas=<ABSOLUTE path of the PSBLAS install directory>
+1. run configure `--with-psblas=<ABSOLUTE path of the PSBLAS install directory>`
    adding the options for MUMPS, SuperLU, SuperLU_Dist, UMFPACK as desired.
-   See MLD2P4 User's and Reference Guide (Section 3) for details.
-2. Tweak Make.inc if you are not satisfied.
-3. make; 
+   See [AMG4PSBLAS User's and Reference Guide](docs/amg4psblas_1.0-guide.pdf) (Section 3) for details.
+2. Tweak `Make.inc` if you are not satisfied.
+3. run `make`; 
 4. Go into the test subdirectory and build the examples of your choice.
-5. (if desired): make install 
+5. (if desired): `make install` 
 
+>[!CAUTION]
+>The single precision version is supported only by MUMPS and SuperLU;
+>thus, even if you specify at configure time to use UMFPACK or SuperLU_Dist,
+>the corresponding preconditioner options will be available only from
+>the double precision version.
 
-NOTES
+### CUDA, OpeMP, OpenACC
 
-- The single precision version is supported only by MUMPS and SuperLU;
-  thus, even if you specify at configure time to use UMFPACK or SuperLU_Dist, 
-  the corresponding preconditioner options will be available only from
-  the double precision version.
+CUDA, OpenMP and OpenACC features are transparently inherited by PSBLAS installation. If PSBLAS has been configured (and installed) with these supports then AMG4PSBLAS will transparently inherit them. It will then be possible to move the computation to GPU accelerator simply by selecting the appropriate variable types. If these have not been activated or installed for PSBLAS then they will not be available for AMG4PSBLAS either and the operation will be purely on CPU/MPI. See also the samples/cuda folder.
 
+### EoCoE - Software as service portal
 
-The AMG4PSBLAS team. 
----------------
-Salvatore Filippone
-Pasqua     D'Ambra
-Fabio     Durastante
+In the European project “Energy oriented Center of Excellence: toward exascale for energy” we made available a software as service portal: [https://eocoe.psnc.pl/](https://eocoe.psnc.pl/). This permits to test several cutting-edge computational methods for accelerating the transition to the production, storage and management of clean, decarbonized energy. Among them you have the possibility of running PSBLAS+AMG4PSBLAS on some test problems to become familiar with using the software.
+
+## TODO and bugs
+ 
+- [X] Fix all reamining bugs. Bugs? We dont' have any ! 🤓
+
+> [!NOTE]
+> To report bugs 🐛 or issues ❓ please use the [GitHub issue system](https://github.com/sfilippone/amg4psblas/issues).
+
+## The AMG4PSBLAS team. 
+
+- Pasqua D'Ambra         (IAC-CNR, Naples, IT)
+- Fabio Durastante       (University of Pisa and IAC-CNR, IT)
+- Salvatore Filippone    (University of Rome Tor Vergata and IAC-CNR, IT)
+
+**Contributors** (_roughly reverse cronological order_):
+
+- Luca       Pepè Sciarria
+- Andea      Di Iorio
+- Ambra	     Abdullahi Hassan
+- Alfredo    Buttari

ReleaseNews

@@ -1,5 +1,19 @@
 WHAT'S NEW
 
+AMG4PSBLAS
+Version 1.2
+   1. New polynomial smoothers.
+   2. Introduced L1-variants
+   3. Reorganization of sample programs.
+   
+Version 1.1
+   1. Reworked approximate inverse solvers.
+   
+
+Version 1.0
+   1. Transitioned from MLD2P4
+
+MLD2P4
 Version 2.1
    1. The multigrid preconditioner now include fully general V- and
       W-cycles. We also support K-cycles, both for symmetric and 

amgprec/CMakeLists.txt

@@ -0,0 +1,880 @@
+set(AMG_amgprec_source_files
+  amg_s_ainv_solver.F90
+  amg_d_ainv_solver.F90
+  amg_z_base_solver_mod.f90
+  amg_z_slu_solver.F90
+  amg_z_gs_solver.f90
+  amg_d_ilu_fact_mod.f90
+#  amg_z_hybrid_aggregator_mod.F90
+  amg_c_base_smoother_mod.f90
+  amg_s_matchboxp_mod.F90
+  amg_c_gs_solver.f90
+  amg_z_prec_type.f90
+  amg_s_base_solver_mod.f90
+  amg_d_slu_solver.F90
+  amg_z_inner_mod.f90
+  amg_d_base_aggregator_mod.f90
+  amg_c_diag_solver.f90
+  amg_z_krm_solver.f90
+  impl/amg_zfile_prec_descr.f90
+  impl/amg_c_hierarchy_rebld.f90
+  impl/amg_dcprecset.F90
+  impl/amg_sprecinit.F90
+  impl/amg_cprecinit.F90
+  impl/amg_smlprec_aply.f90
+  impl/level/amg_s_base_onelev_map_rstr.F90
+  impl/level/amg_c_base_onelev_csetr.f90
+  impl/level/amg_d_base_onelev_map_rstr.F90
+  impl/level/amg_z_base_onelev_setsv.F90
+  impl/level/amg_d_base_onelev_descr.f90
+  impl/level/amg_d_base_onelev_setag.f90
+  impl/level/amg_s_base_onelev_dump.f90
+  impl/level/amg_s_base_onelev_build.f90
+  impl/level/amg_c_base_onelev_map_rstr.F90
+  impl/level/amg_z_base_onelev_memory_use.f90
+  impl/level/amg_s_base_onelev_map_prol.F90
+  impl/level/amg_d_base_onelev_csetc.F90
+  impl/level/amg_d_base_onelev_cnv.f90
+  impl/level/amg_c_base_onelev_setsv.F90
+  impl/level/amg_c_base_onelev_descr.f90
+  impl/level/amg_z_base_onelev_setsm.F90
+  impl/level/amg_d_base_onelev_csetr.f90
+  impl/level/amg_s_base_onelev_descr.f90
+  impl/level/amg_c_base_onelev_build.f90
+  impl/level/amg_c_base_onelev_setag.f90
+  impl/level/amg_c_base_onelev_free_smoothers.f90
+  impl/level/amg_c_base_onelev_memory_use.f90
+  impl/level/amg_s_base_onelev_csetr.f90
+  impl/level/amg_s_base_onelev_mat_asb.f90
+  impl/level/amg_c_base_onelev_free.f90
+  impl/level/amg_d_base_onelev_free_smoothers.f90
+  impl/level/amg_z_base_onelev_map_prol.F90
+  impl/level/amg_s_base_onelev_free_smoothers.f90
+  impl/level/amg_d_base_onelev_map_prol.F90
+  impl/level/amg_d_base_onelev_free.f90
+  impl/level/amg_z_base_onelev_cnv.f90
+  impl/level/amg_s_base_onelev_cseti.F90
+  impl/level/amg_s_base_onelev_csetc.F90
+  impl/level/amg_c_base_onelev_map_prol.F90
+  impl/level/amg_d_base_onelev_check.f90
+  impl/level/amg_d_base_onelev_setsm.F90
+  impl/level/amg_s_base_onelev_setsv.F90
+  impl/level/amg_z_base_onelev_mat_asb.f90
+  impl/level/amg_c_base_onelev_mat_asb.f90
+  impl/level/amg_z_base_onelev_cseti.F90
+  impl/level/amg_z_base_onelev_descr.f90
+  impl/level/amg_z_base_onelev_map_rstr.F90
+  impl/level/amg_z_base_onelev_check.f90
+  impl/level/amg_c_base_onelev_cnv.f90
+  impl/level/amg_z_base_onelev_build.f90
+  impl/level/amg_d_base_onelev_build.f90
+  impl/level/amg_c_base_onelev_cseti.F90
+  impl/level/amg_c_base_onelev_check.f90
+  impl/level/amg_s_base_onelev_check.f90
+  impl/level/amg_s_base_onelev_memory_use.f90
+  impl/level/amg_s_base_onelev_cnv.f90
+  impl/level/amg_z_base_onelev_setag.f90
+  impl/level/amg_s_base_onelev_free.f90
+  impl/level/amg_z_base_onelev_dump.f90
+  impl/level/amg_z_base_onelev_csetr.f90
+  impl/level/amg_z_base_onelev_free_smoothers.f90
+  impl/level/amg_c_base_onelev_csetc.F90
+  impl/level/amg_d_base_onelev_dump.f90
+  impl/level/amg_z_base_onelev_csetc.F90
+  impl/level/amg_d_base_onelev_setsv.F90
+  impl/level/amg_s_base_onelev_setsm.F90
+  impl/level/amg_d_base_onelev_mat_asb.f90
+  impl/level/amg_s_base_onelev_setag.f90
+  impl/level/amg_d_base_onelev_cseti.F90
+  impl/level/amg_d_base_onelev_memory_use.f90
+  impl/level/amg_c_base_onelev_setsm.F90
+  impl/level/amg_z_base_onelev_free.f90
+  impl/level/amg_c_base_onelev_dump.f90
+  impl/amg_z_hierarchy_bld.F90
+  impl/amg_zfile_prec_memory_use.f90
+  impl/amg_c_smoothers_bld.f90
+  impl/amg_dmlprec_aply.f90
+  impl/amg_cprecaply.f90
+  impl/amg_zcprecset.F90
+  impl/amg_z_smoothers_bld.f90
+  impl/amg_cprecset.F90
+  impl/amg_cfile_prec_memory_use.f90
+  impl/amg_z_extprol_bld.F90
+  impl/amg_sprecbld.f90
+  impl/amg_s_hierarchy_rebld.f90
+  impl/amg_s_smoothers_bld.f90
+  impl/amg_dprecinit.F90
+  impl/amg_zmlprec_bld.f90
+  impl/amg_smlprec_bld.f90
+  impl/amg_sfile_prec_memory_use.f90
+  impl/amg_dprecaply.f90
+  impl/amg_zprecbld.f90
+  impl/amg_z_hierarchy_rebld.f90
+  impl/amg_c_extprol_bld.F90
+  impl/amg_zprecaply.f90
+  impl/amg_s_extprol_bld.F90
+  impl/amg_dfile_prec_memory_use.f90
+  impl/solver/amg_z_invt_solver_clone_settings.f90
+  impl/solver/amg_c_gs_solver_clear_data.f90
+  impl/solver/amg_d_base_solver_apply.f90
+  impl/solver/amg_s_ilu_solver_apply.f90
+  impl/solver/amg_d_jac_solver_apply.f90
+  impl/solver/amg_z_base_solver_csetr.f90
+  impl/solver/amg_z_ilu_solver_dmp.f90
+  impl/solver/amg_d_diag_solver_dmp.f90
+  impl/solver/amg_c_invt_solver_check.f90
+  impl/solver/amg_z_base_solver_descr.f90
+  impl/solver/amg_d_mumps_solver_apply_vect.F90
+  impl/solver/amg_d_l1_jac_solver_bld.f90
+  impl/solver/amg_z_base_solver_cseti.f90
+  impl/solver/amg_d_ainv_solver_check.f90
+  impl/solver/amg_s_invt_solver_bld.f90
+  impl/solver/amg_z_ainv_solver_clone_settings.f90
+  impl/solver/amg_c_bwgs_solver_bld.f90
+  impl/solver/amg_z_base_ainv_solver_apply_vect.f90
+  impl/solver/amg_d_id_solver_apply.f90
+  impl/solver/amg_s_base_solver_apply_vect.f90
+  impl/solver/amg_s_base_solver_clone.f90
+  impl/solver/amg_c_base_ainv_update_a.f90
+  impl/solver/amg_s_id_solver_clone.f90
+  impl/solver/amg_s_invk_solver_clone_settings.f90
+  impl/solver/amg_z_ainv_solver_bld.f90
+  impl/solver/amg_z_diag_solver_cnv.f90
+  impl/solver/amg_d_mumps_solver_bld.F90
+  impl/solver/amg_d_jac_solver_clear_data.f90
+  impl/solver/amg_c_jac_solver_clone_settings.f90
+  impl/solver/amg_z_gs_solver_clear_data.f90
+  impl/solver/amg_c_ainv_solver_cseti.f90
+  impl/solver/amg_z_base_solver_cnv.f90
+  impl/solver/amg_s_bwgs_solver_bld.f90
+  impl/solver/amg_s_id_solver_apply_vect.f90
+  impl/solver/amg_z_jac_solver_clone.f90
+  impl/solver/amg_z_ainv_solver_check.f90
+  impl/solver/amg_d_ilu_solver_clear_data.f90
+  impl/solver/amg_s_invk_solver_cseti.f90
+  impl/solver/amg_s_ainv_solver_csetc.f90
+  impl/solver/amg_z_base_ainv_solver_apply.f90
+  impl/solver/amg_c_gs_solver_clone.f90
+  impl/solver/amg_d_base_ainv_solver_apply.f90
+#  impl/solver/amg_d_ainv_solver_setr.f90
+  impl/solver/amg_d_invt_solver_clone.f90
+  impl/solver/amg_d_gs_solver_apply_vect.f90
+  impl/solver/amg_s_base_solver_dmp.f90
+  impl/solver/amg_d_ainv_solver_descr.f90
+  impl/solver/amg_d_jac_solver_clone_settings.f90
+  impl/solver/amg_z_base_solver_check.f90
+  impl/solver/amg_z_diag_solver_clone.f90
+  impl/solver/amg_s_invk_solver_clone.f90
+#  impl/solver/amg_d_ainv_solver_setc.f90
+  impl/solver/amg_d_gs_solver_clear_data.f90
+  impl/solver/amg_c_invt_solver_bld.f90
+  impl/solver/amg_s_jac_solver_clear_data.f90
+  impl/solver/amg_d_jac_solver_dmp.f90
+  
+  impl/solver/amg_c_base_solver_dmp.f90
+  impl/solver/amg_s_diag_solver_dmp.f90
+  impl/solver/amg_d_invt_solver_check.f90
+  impl/solver/amg_c_ilu_solver_clear_data.f90
+  impl/solver/amg_z_invt_solver_descr.f90
+  impl/solver/amg_d_diag_solver_clone.f90
+  impl/solver/amg_s_jac_solver_bld.f90
+  impl/solver/amg_s_mumps_solver_apply.F90
+  impl/solver/amg_z_jac_solver_clone_settings.f90
+#  impl/solver/amg_d_invt_solver_seti.f90
+  impl/solver/amg_s_base_ainv_solver_apply_vect.f90
+  impl/solver/amg_z_diag_solver_apply.f90
+  impl/solver/amg_s_base_solver_free.f90
+  impl/solver/amg_d_ainv_solver_clone.f90
+  impl/solver/amg_s_krm_solver_impl.f90
+#  impl/solver/amg_d_ainv_solver_seti.f90
+  impl/solver/amg_z_ainv_solver_clone.f90
+  impl/solver/amg_d_base_ainv_solver_free.f90
+#  impl/solver/amg_c_invk_solver_seti.f90
+  impl/solver/amg_s_ilu_solver_dmp.f90
+  impl/solver/amg_z_base_solver_apply.f90
+  impl/solver/amg_d_ilu_solver_apply_vect.f90
+  impl/solver/amg_z_jac_solver_dmp.f90
+  impl/solver/amg_c_base_ainv_solver_cnv.f90
+  impl/solver/amg_s_gs_solver_cnv.f90
+  impl/solver/amg_s_id_solver_apply.f90
+  impl/solver/amg_d_jac_solver_apply_vect.f90
+  impl/solver/amg_s_base_solver_bld.f90
+  impl/solver/amg_z_base_solver_csetc.f90
+  impl/solver/amg_d_gs_solver_cnv.f90
+  impl/solver/amg_d_bwgs_solver_apply.f90
+  impl/solver/amg_c_diag_solver_dmp.f90
+  impl/solver/amg_d_ilu_solver_dmp.f90
+  impl/solver/amg_s_base_solver_check.f90
+  impl/solver/amg_c_invk_solver_clone.f90
+  impl/solver/amg_d_invk_solver_check.f90
+  impl/solver/amg_z_ilu_solver_clone.f90
+  impl/solver/amg_d_base_solver_cseti.f90
+  impl/solver/amg_c_base_solver_bld.f90
+  impl/solver/amg_z_jac_solver_apply_vect.f90
+  impl/solver/amg_z_id_solver_apply.f90
+  impl/solver/amg_d_base_solver_bld.f90
+#  impl/solver/amg_s_ainv_solver_seti.f90
+  impl/solver/amg_z_jac_solver_bld.f90
+  impl/solver/amg_z_base_solver_apply_vect.f90
+  impl/solver/amg_d_base_solver_clone.f90
+  impl/solver/amg_d_ainv_solver_csetr.f90
+  impl/solver/amg_s_invt_solver_cseti.f90
+  impl/solver/amg_c_id_solver_apply_vect.f90
+  impl/solver/amg_s_mumps_solver_apply_vect.F90
+  impl/solver/amg_z_ilu_solver_apply.f90
+  impl/solver/amg_c_diag_solver_apply_vect.f90
+  impl/solver/amg_s_gs_solver_dmp.f90
+  impl/solver/amg_z_base_ainv_solver_dmp.f90
+  impl/solver/amg_c_diag_solver_cnv.f90
+#  impl/solver/amg_z_invt_solver_setr.f90
+  impl/solver/amg_z_diag_solver_apply_vect.f90
+  impl/solver/amg_d_ainv_solver_cseti.f90
+  impl/solver/amg_z_ilu_solver_clear_data.f90
+  impl/solver/amg_d_base_solver_csetc.f90
+  impl/solver/amg_c_invk_solver_descr.f90
+  impl/solver/amg_d_invt_solver_csetr.f90
+  impl/solver/amg_d_invt_solver_cseti.f90
+  impl/solver/amg_z_invk_solver_bld.f90
+  impl/solver/amg_s_jac_solver_clone.f90
+  impl/solver/amg_d_bwgs_solver_bld.f90
+  impl/solver/amg_z_diag_solver_bld.f90
+  impl/solver/amg_s_l1_jac_solver_bld.f90
+  impl/solver/amg_s_invt_solver_descr.f90
+  impl/solver/amg_s_ilu_solver_bld.f90
+  impl/solver/amg_c_gs_solver_clone_settings.f90
+  impl/solver/amg_c_jac_solver_bld.f90
+  impl/solver/amg_d_gs_solver_clone_settings.f90
+  impl/solver/amg_d_base_solver_descr.f90
+  impl/solver/amg_d_base_solver_dmp.f90
+  impl/solver/amg_c_ainv_solver_bld.f90
+  impl/solver/amg_s_invt_solver_check.f90
+  impl/solver/amg_z_gs_solver_apply_vect.f90
+  impl/solver/amg_z_ainv_solver_descr.f90
+#  impl/solver/amg_c_invt_solver_seti.f90
+  impl/solver/amg_c_base_solver_apply.f90
+  impl/solver/amg_z_gs_solver_dmp.f90
+  impl/solver/amg_d_ainv_solver_clone_settings.f90
+  impl/solver/amg_c_id_solver_apply.f90
+  impl/solver/amg_z_base_solver_clone.f90
+  impl/solver/amg_s_invk_solver_check.f90
+  impl/solver/amg_c_gs_solver_bld.f90
+  impl/solver/amg_s_ilu_solver_cnv.f90
+  impl/solver/amg_z_ainv_solver_csetc.f90
+  impl/solver/amg_s_ainv_solver_clone_settings.f90
+  impl/solver/amg_c_base_ainv_solver_apply_vect.f90
+  impl/solver/amg_s_diag_solver_apply.f90
+  impl/solver/amg_s_base_ainv_update_a.f90
+  impl/solver/amg_c_base_solver_csetc.f90
+  impl/solver/amg_c_jac_solver_clone.f90
+  impl/solver/amg_c_base_solver_descr.f90
+  impl/solver/amg_c_invt_solver_clone.f90
+  impl/solver/amg_c_ilu_solver_bld.f90
+  impl/solver/amg_d_base_ainv_solver_apply_vect.f90
+  impl/solver/amg_d_base_solver_apply_vect.f90
+  impl/solver/amg_z_invt_solver_check.f90
+  impl/solver/amg_c_base_solver_cseti.f90
+  impl/solver/amg_s_jac_solver_dmp.f90
+#  impl/solver/amg_s_invk_solver_seti.f90
+  impl/solver/amg_s_ainv_solver_check.f90
+  impl/solver/amg_d_base_solver_clear_data.f90
+  impl/solver/amg_z_gs_solver_clone_settings.f90
+  impl/solver/amg_c_invk_solver_check.f90
+  impl/solver/amg_s_base_solver_cseti.f90
+  impl/solver/amg_z_base_ainv_solver_free.f90
+  impl/solver/amg_z_invk_solver_clone_settings.f90
+  impl/solver/amg_c_base_ainv_solver_dmp.f90
+  impl/solver/amg_s_gs_solver_clear_data.f90
+  impl/solver/amg_s_base_ainv_solver_apply.f90
+  impl/solver/amg_c_base_solver_apply_vect.f90
+  impl/solver/amg_d_diag_solver_cnv.f90
+  impl/solver/amg_d_id_solver_apply_vect.f90
+  impl/solver/amg_z_base_solver_bld.f90
+  impl/solver/amg_z_base_solver_dmp.f90
+  impl/solver/amg_d_invt_solver_clone_settings.f90
+  impl/solver/amg_c_diag_solver_clone.f90
+  impl/solver/amg_z_gs_solver_apply.f90
+  impl/solver/amg_c_invt_solver_clone_settings.f90
+  impl/solver/amg_z_base_solver_free.f90
+  impl/solver/amg_d_diag_solver_clear_data.f90
+  impl/solver/amg_d_ilu_solver_clone_settings.f90
+#  impl/solver/amg_z_invt_solver_seti.f90
+#  impl/solver/amg_z_ainv_solver_seti.f90
+  impl/solver/amg_c_diag_solver_apply.f90
+  impl/solver/amg_d_base_ainv_solver_dmp.f90
+  impl/solver/amg_c_invt_solver_csetr.f90
+#  impl/solver/amg_c_invt_solver_setr.f90
+  impl/solver/amg_c_jac_solver_clear_data.f90
+  impl/solver/amg_c_invk_solver_bld.f90
+  impl/solver/amg_c_ainv_solver_csetc.f90
+  impl/solver/amg_s_ainv_solver_cseti.f90
+  impl/solver/amg_z_base_solver_clear_data.f90
+  impl/solver/amg_z_invk_solver_check.f90
+  impl/solver/amg_c_diag_solver_bld.f90
+  impl/solver/amg_d_invk_solver_clone_settings.f90
+  impl/solver/amg_s_ainv_solver_clone.f90
+  impl/solver/amg_s_diag_solver_clear_data.f90
+  impl/solver/amg_d_gs_solver_clone.f90
+  impl/solver/amg_s_base_solver_csetr.f90
+  impl/solver/amg_c_ilu_solver_dmp.f90
+  impl/solver/amg_c_base_solver_cnv.f90
+#  impl/solver/amg_z_ainv_solver_setc.f90
+  impl/solver/amg_z_jac_solver_apply.f90
+  impl/solver/amg_s_ainv_solver_descr.f90
+  impl/solver/amg_z_base_ainv_solver_cnv.f90
+  impl/solver/amg_c_ilu_solver_apply.f90
+  impl/solver/amg_c_ilu_solver_cnv.f90
+  impl/solver/amg_z_bwgs_solver_bld.f90
+  impl/solver/amg_c_base_ainv_solver_free.f90
+  impl/solver/amg_s_base_solver_clone_settings.f90
+  impl/solver/amg_z_invt_solver_bld.f90
+  impl/solver/amg_s_base_ainv_solver_free.f90
+  impl/solver/amg_s_base_solver_clear_data.f90
+  impl/solver/amg_s_invt_solver_csetr.f90
+  impl/solver/amg_d_diag_solver_apply_vect.f90
+  impl/solver/amg_s_diag_solver_bld.f90
+  impl/solver/amg_s_diag_solver_cnv.f90
+  impl/solver/amg_d_diag_solver_apply.f90
+  impl/solver/amg_d_invk_solver_descr.f90
+  impl/solver/amg_z_mumps_solver_apply.F90
+  impl/solver/amg_s_base_solver_descr.f90
+  impl/solver/amg_c_jac_solver_apply_vect.f90
+  impl/solver/amg_s_base_ainv_solver_dmp.f90
+  impl/solver/amg_z_krm_solver_impl.f90
+  impl/solver/amg_z_invt_solver_csetr.f90
+  impl/solver/amg_c_ainv_solver_check.f90
+#  impl/solver/amg_s_invt_solver_seti.f90
+  impl/solver/amg_z_ainv_solver_cseti.f90
+  impl/solver/amg_z_invk_solver_clone.f90
+  impl/solver/amg_s_base_solver_csetc.f90
+  impl/solver/amg_z_bwgs_solver_apply_vect.f90
+  impl/solver/amg_c_bwgs_solver_apply.f90
+  impl/solver/amg_c_base_solver_csetr.f90
+  impl/solver/amg_c_invk_solver_cseti.f90
+  impl/solver/amg_d_krm_solver_impl.f90
+  impl/solver/amg_s_invk_solver_bld.f90
+  impl/solver/amg_c_mumps_solver_apply.F90
+  impl/solver/amg_z_jac_solver_cnv.f90
+#  impl/solver/amg_s_ainv_solver_setr.f90
+  impl/solver/amg_d_gs_solver_bld.f90
+  impl/solver/amg_c_ilu_solver_clone_settings.f90
+  impl/solver/amg_z_base_solver_clone_settings.f90
+  impl/solver/amg_d_ilu_solver_clone.f90
+  impl/solver/amg_c_ilu_solver_clone.f90
+  impl/solver/amg_d_ainv_solver_bld.f90
+  impl/solver/amg_c_gs_solver_apply.f90
+  impl/solver/amg_z_mumps_solver_apply_vect.F90
+  impl/solver/amg_c_ainv_solver_clone.f90
+  impl/solver/amg_c_base_solver_clear_data.f90
+  impl/solver/amg_z_diag_solver_dmp.f90
+  impl/solver/amg_z_id_solver_apply_vect.f90
+  impl/solver/amg_d_ilu_solver_bld.f90
+  impl/solver/amg_s_base_solver_apply.f90
+  impl/solver/amg_s_ainv_solver_csetr.f90
+  impl/solver/amg_z_ilu_solver_cnv.f90
+  impl/solver/amg_s_invk_solver_descr.f90
+  impl/solver/amg_d_jac_solver_bld.f90
+  impl/solver/amg_z_invk_solver_cseti.f90
+  impl/solver/amg_z_id_solver_clone.f90
+  impl/solver/amg_d_id_solver_clone.f90
+  impl/solver/amg_z_diag_solver_clear_data.f90
+  impl/solver/amg_s_gs_solver_bld.f90
+  impl/solver/amg_s_bwgs_solver_apply.f90
+  impl/solver/amg_s_gs_solver_clone.f90
+  impl/solver/amg_s_jac_solver_apply.f90
+  impl/solver/amg_z_ilu_solver_clone_settings.f90
+  impl/solver/amg_c_mumps_solver_bld.F90
+  impl/solver/amg_d_mumps_solver_apply.F90
+#  impl/solver/amg_s_ainv_solver_setc.f90
+  impl/solver/amg_d_base_solver_cnv.f90
+  impl/solver/amg_s_ilu_solver_clear_data.f90
+  impl/solver/amg_d_bwgs_solver_apply_vect.f90
+  impl/solver/amg_s_jac_solver_apply_vect.f90
+  impl/solver/amg_c_invk_solver_clone_settings.f90
+  impl/solver/amg_c_base_solver_clone_settings.f90
+  impl/solver/amg_z_gs_solver_cnv.f90
+  impl/solver/amg_s_invt_solver_clone.f90
+#  impl/solver/amg_z_invk_solver_seti.f90
+  impl/solver/amg_c_ainv_solver_csetr.f90
+  impl/solver/amg_c_jac_solver_apply.f90
+  impl/solver/amg_c_gs_solver_dmp.f90
+  impl/solver/amg_z_ilu_solver_bld.f90
+  impl/solver/amg_c_invt_solver_descr.f90
+  impl/solver/amg_z_invt_solver_clone.f90
+  impl/solver/amg_d_base_ainv_update_a.f90
+  impl/solver/amg_c_base_solver_clone.f90
+  impl/solver/amg_s_diag_solver_clone.f90
+  impl/solver/amg_d_invt_solver_bld.f90
+#  impl/solver/amg_c_ainv_solver_setc.f90
+  impl/solver/amg_d_gs_solver_dmp.f90
+  impl/solver/amg_s_gs_solver_apply.f90
+  impl/solver/amg_d_jac_solver_clone.f90
+  impl/solver/amg_z_jac_solver_clear_data.f90
+  impl/solver/amg_c_invt_solver_cseti.f90
+  impl/solver/amg_d_ilu_solver_apply.f90
+#  impl/solver/amg_c_ainv_solver_setr.f90
+  impl/solver/amg_c_gs_solver_cnv.f90
+  impl/solver/amg_c_diag_solver_clear_data.f90
+  impl/solver/amg_c_base_solver_check.f90
+  impl/solver/amg_c_base_solver_free.f90
+  impl/solver/amg_z_invt_solver_cseti.f90
+  impl/solver/amg_d_base_solver_check.f90
+  impl/solver/amg_d_invk_solver_clone.f90
+  impl/solver/amg_c_krm_solver_impl.f90
+  impl/solver/amg_d_base_ainv_solver_cnv.f90
+  impl/solver/amg_d_invk_solver_cseti.f90
+  impl/solver/amg_z_mumps_solver_bld.F90
+  impl/solver/amg_z_gs_solver_bld.f90
+#  impl/solver/amg_z_ainv_solver_setr.f90
+  impl/solver/amg_s_gs_solver_apply_vect.f90
+  impl/solver/amg_s_jac_solver_clone_settings.f90
+  impl/solver/amg_z_gs_solver_clone.f90
+  impl/solver/amg_c_gs_solver_apply_vect.f90
+  impl/solver/amg_d_base_solver_csetr.f90
+  impl/solver/amg_s_ainv_solver_bld.f90
+  impl/solver/amg_z_l1_jac_solver_bld.f90
+  impl/solver/amg_z_base_ainv_update_a.f90
+  impl/solver/amg_z_ainv_solver_csetr.f90
+  impl/solver/amg_s_ilu_solver_apply_vect.f90
+#  impl/solver/amg_s_invt_solver_setr.f90
+#  impl/solver/amg_d_invt_solver_setr.f90
+  impl/solver/amg_d_invk_solver_bld.f90
+  impl/solver/amg_s_jac_solver_cnv.f90
+  impl/solver/amg_z_bwgs_solver_apply.f90
+  impl/solver/amg_s_bwgs_solver_apply_vect.f90
+#  impl/solver/amg_d_invk_solver_seti.f90
+  impl/solver/amg_d_ilu_solver_cnv.f90
+  impl/solver/amg_s_mumps_solver_bld.F90
+  impl/solver/amg_s_gs_solver_clone_settings.f90
+  impl/solver/amg_c_jac_solver_dmp.f90
+  impl/solver/amg_d_jac_solver_cnv.f90
+  impl/solver/amg_c_ilu_solver_apply_vect.f90
+  impl/solver/amg_c_mumps_solver_apply_vect.F90
+  impl/solver/amg_z_ilu_solver_apply_vect.f90
+  impl/solver/amg_s_ilu_solver_clone_settings.f90
+  impl/solver/amg_c_ainv_solver_clone_settings.f90
+#  impl/solver/amg_c_ainv_solver_seti.f90
+  impl/solver/amg_s_ilu_solver_clone.f90
+  impl/solver/amg_d_diag_solver_bld.f90
+  impl/solver/amg_c_l1_jac_solver_bld.f90
+  impl/solver/amg_c_bwgs_solver_apply_vect.f90
+  impl/solver/amg_c_jac_solver_cnv.f90
+  impl/solver/amg_c_id_solver_clone.f90
+  impl/solver/amg_d_gs_solver_apply.f90
+  impl/solver/amg_z_invk_solver_descr.f90
+  impl/solver/amg_s_diag_solver_apply_vect.f90
+  impl/solver/amg_s_base_solver_cnv.f90
+  impl/solver/amg_d_base_solver_clone_settings.f90
+  impl/solver/amg_s_invt_solver_clone_settings.f90
+  impl/solver/amg_d_ainv_solver_csetc.f90
+  impl/solver/amg_d_invt_solver_descr.f90
+  impl/solver/amg_d_base_solver_free.f90
+  impl/solver/amg_c_base_ainv_solver_apply.f90
+  impl/solver/amg_s_base_ainv_solver_cnv.f90
+  impl/solver/amg_c_ainv_solver_descr.f90
+  impl/amg_sfile_prec_descr.f90
+  impl/amg_zprecinit.F90
+  impl/amg_dprecbld.f90
+  impl/amg_sprecaply.f90
+  impl/amg_cprecbld.f90
+  impl/amg_cfile_prec_descr.f90
+  impl/amg_s_hierarchy_bld.F90
+  impl/amg_dfile_prec_descr.f90
+  impl/amg_ccprecset.F90
+  impl/amg_d_hierarchy_bld.F90
+  impl/amg_c_hierarchy_bld.F90
+  impl/smoother/amg_d_base_smoother_clone_settings.f90
+  impl/smoother/amg_d_as_smoother_check.f90
+  impl/smoother/amg_c_l1_jac_smoother_clone.f90
+  impl/smoother/amg_z_l1_jac_smoother_bld.f90
+  impl/smoother/amg_s_poly_smoother_clear_data.f90
+  impl/smoother/amg_s_poly_smoother_apply_vect.f90
+  impl/smoother/amg_z_jac_smoother_clone_settings.f90
+  impl/smoother/amg_s_poly_smoother_csetc.f90
+  impl/smoother/amg_s_as_smoother_prol_a.f90
+  impl/smoother/amg_s_base_smoother_csetc.f90
+  impl/smoother/amg_s_as_smoother_apply.f90
+  impl/smoother/amg_z_base_smoother_csetr.f90
+  impl/smoother/amg_c_jac_smoother_apply.f90
+  impl/smoother/amg_s_base_smoother_clone.f90
+  impl/smoother/amg_d_jac_smoother_dmp.f90
+  impl/smoother/amg_z_base_smoother_cnv.f90
+  impl/smoother/amg_s_jac_smoother_apply.f90
+  impl/smoother/amg_z_jac_smoother_bld.f90
+  impl/smoother/amg_c_as_smoother_clone.f90
+  impl/smoother/amg_d_as_smoother_apply_vect.f90
+  impl/smoother/amg_d_poly_smoother_descr.f90
+  impl/smoother/amg_s_as_smoother_csetc.f90
+  impl/smoother/amg_z_base_smoother_cseti.f90
+  impl/smoother/amg_s_base_smoother_cseti.f90
+  impl/smoother/amg_s_base_smoother_free.f90
+  impl/smoother/amg_d_jac_smoother_clone.f90
+  impl/smoother/amg_d_jac_smoother_apply_vect.f90
+  impl/smoother/amg_c_as_smoother_clear_data.f90
+  impl/smoother/amg_s_poly_smoother_descr.f90
+  impl/smoother/amg_z_as_smoother_cseti.f90
+  impl/smoother/amg_s_as_smoother_apply_vect.f90
+  impl/smoother/amg_c_jac_smoother_csetr.f90
+  impl/smoother/amg_d_base_smoother_free.f90
+  impl/smoother/amg_z_as_smoother_bld.f90
+  impl/smoother/amg_s_base_smoother_clear_data.f90
+  impl/smoother/amg_c_jac_smoother_bld.f90
+  impl/smoother/amg_d_as_smoother_restr_v.f90
+  impl/smoother/amg_c_as_smoother_check.f90
+  impl/smoother/amg_d_poly_smoother_cseti.f90
+  impl/smoother/amg_d_as_smoother_clone.f90
+  impl/smoother/amg_z_as_smoother_clear_data.f90
+  impl/smoother/amg_d_as_smoother_free.f90
+  impl/smoother/amg_s_as_smoother_cnv.f90
+  impl/smoother/amg_s_base_smoother_dmp.f90
+  impl/smoother/amg_d_l1_jac_smoother_descr.f90
+  impl/smoother/amg_s_poly_smoother_cnv.f90
+  impl/smoother/amg_d_jac_smoother_csetr.f90
+  impl/smoother/amg_d_base_smoother_apply.f90
+  impl/smoother/amg_s_as_smoother_cseti.f90
+  impl/smoother/amg_s_base_smoother_apply_vect.f90
+  impl/smoother/amg_c_base_smoother_cseti.f90
+  impl/smoother/amg_c_as_smoother_cnv.f90
+  impl/smoother/amg_z_jac_smoother_cnv.f90
+  impl/smoother/amg_s_poly_smoother_bld.f90
+  impl/smoother/amg_d_jac_smoother_cseti.f90
+  impl/smoother/amg_s_as_smoother_prol_v.f90
+  impl/smoother/amg_c_as_smoother_restr_a.f90
+  impl/smoother/amg_d_base_smoother_bld.f90
+  impl/smoother/amg_c_jac_smoother_clone.f90
+  impl/smoother/amg_d_jac_smoother_bld.f90
+  impl/smoother/amg_z_jac_smoother_apply_vect.f90
+  impl/smoother/amg_c_as_smoother_prol_v.f90
+  impl/smoother/amg_z_jac_smoother_csetc.f90
+  impl/smoother/amg_z_as_smoother_prol_v.f90
+  impl/smoother/amg_d_base_smoother_cnv.f90
+  impl/smoother/amg_c_l1_jac_smoother_bld.f90
+  impl/smoother/amg_z_as_smoother_apply_vect.f90
+  impl/smoother/amg_s_as_smoother_restr_v.f90
+  impl/smoother/amg_d_l1_jac_smoother_bld.f90
+  impl/smoother/amg_s_jac_smoother_bld.f90
+  impl/smoother/amg_s_poly_smoother_clone_settings.f90
+  impl/smoother/amg_d_base_smoother_check.f90
+  impl/smoother/amg_z_base_smoother_bld.f90
+  impl/smoother/amg_s_l1_jac_smoother_clone.f90
+  impl/smoother/amg_c_jac_smoother_clone_settings.f90
+  impl/smoother/amg_s_poly_smoother_dmp.f90
+  impl/smoother/amg_c_base_smoother_csetr.f90
+  impl/smoother/amg_d_poly_smoother_clone_settings.f90
+  impl/smoother/amg_z_as_smoother_clone_settings.f90
+  impl/smoother/amg_z_jac_smoother_csetr.f90
+  impl/smoother/amg_d_jac_smoother_csetc.f90
+  impl/smoother/amg_z_base_smoother_dmp.f90
+  impl/smoother/amg_s_jac_smoother_csetr.f90
+  impl/smoother/amg_s_base_smoother_bld.f90
+  impl/smoother/amg_z_jac_smoother_descr.f90
+  impl/smoother/amg_z_jac_smoother_cseti.f90
+  impl/smoother/amg_d_as_smoother_dmp.f90
+  impl/smoother/amg_d_jac_smoother_apply.f90
+  impl/smoother/amg_c_jac_smoother_dmp.f90
+  impl/smoother/amg_z_as_smoother_apply.f90
+  impl/smoother/amg_z_as_smoother_check.f90
+  impl/smoother/amg_z_jac_smoother_clear_data.f90
+  impl/smoother/amg_s_base_smoother_descr.f90
+  impl/smoother/amg_s_jac_smoother_clone.f90
+  impl/smoother/amg_z_jac_smoother_clone.f90
+  impl/smoother/amg_c_as_smoother_clone_settings.f90
+  impl/smoother/amg_c_base_smoother_check.f90
+  impl/smoother/amg_d_poly_smoother_apply_vect.f90
+  impl/smoother/amg_s_l1_jac_smoother_bld.f90
+  impl/smoother/amg_c_as_smoother_apply_vect.f90
+  impl/smoother/amg_z_as_smoother_cnv.f90
+  impl/smoother/amg_z_as_smoother_csetc.f90
+  impl/smoother/amg_d_as_smoother_csetc.f90
+  impl/smoother/amg_d_jac_smoother_cnv.f90
+  impl/smoother/amg_c_as_smoother_csetc.f90
+  impl/smoother/amg_z_base_smoother_clone_settings.f90
+  impl/smoother/amg_s_as_smoother_free.f90
+  impl/smoother/amg_z_base_smoother_free.f90
+  impl/smoother/amg_c_base_smoother_apply.f90
+  impl/smoother/amg_z_l1_jac_smoother_descr.f90
+  impl/smoother/amg_s_as_smoother_clone_settings.f90
+  impl/smoother/amg_d_base_smoother_csetr.f90
+  impl/smoother/amg_c_jac_smoother_clear_data.f90
+  impl/smoother/amg_d_poly_smoother_bld.f90
+  impl/smoother/amg_z_base_smoother_csetc.f90
+  impl/smoother/amg_z_base_smoother_clone.f90
+  impl/smoother/amg_s_jac_smoother_apply_vect.f90
+  impl/smoother/amg_z_base_smoother_clear_data.f90
+  impl/smoother/amg_c_base_smoother_clone_settings.f90
+  impl/smoother/amg_d_base_smoother_clone.f90
+  impl/smoother/amg_d_base_smoother_cseti.f90
+  impl/smoother/amg_z_l1_jac_smoother_clone.f90
+  impl/smoother/amg_s_l1_jac_smoother_descr.f90
+  impl/smoother/amg_c_jac_smoother_descr.f90
+  impl/smoother/amg_z_base_smoother_check.f90
+  impl/smoother/amg_d_jac_smoother_clear_data.f90
+  impl/smoother/amg_d_as_smoother_prol_a.f90
+  impl/smoother/amg_c_as_smoother_apply.f90
+  impl/smoother/amg_c_base_smoother_cnv.f90
+  impl/smoother/amg_c_jac_smoother_cnv.f90
+  impl/smoother/amg_c_base_smoother_csetc.f90
+  impl/smoother/amg_d_base_smoother_csetc.f90
+  impl/smoother/amg_d_poly_smoother_csetr.f90
+  impl/smoother/amg_c_jac_smoother_cseti.f90
+  impl/smoother/amg_s_base_smoother_cnv.f90
+  impl/smoother/amg_s_poly_smoother_csetr.f90
+  impl/smoother/amg_s_base_smoother_clone_settings.f90
+  impl/smoother/amg_s_as_smoother_restr_a.f90
+  impl/smoother/amg_d_base_smoother_dmp.f90
+  impl/smoother/amg_d_jac_smoother_descr.f90
+  impl/smoother/amg_c_base_smoother_free.f90
+  impl/smoother/amg_c_as_smoother_free.f90
+  impl/smoother/amg_s_jac_smoother_clear_data.f90
+  impl/smoother/amg_s_jac_smoother_cseti.f90
+  impl/smoother/amg_d_poly_smoother_clone.f90
+  impl/smoother/amg_s_jac_smoother_csetc.f90
+  impl/smoother/amg_s_as_smoother_dmp.f90
+  impl/smoother/amg_s_base_smoother_apply.f90
+  impl/smoother/amg_s_as_smoother_clone.f90
+  impl/smoother/amg_c_l1_jac_smoother_descr.f90
+  impl/smoother/amg_s_jac_smoother_cnv.f90
+  impl/smoother/amg_z_as_smoother_free.f90
+  impl/smoother/amg_s_poly_smoother_clone.f90
+  impl/smoother/amg_s_as_smoother_clear_data.f90
+  impl/smoother/amg_s_jac_smoother_dmp.f90
+  impl/smoother/amg_c_base_smoother_clone.f90
+  impl/smoother/amg_d_poly_smoother_csetc.f90
+  impl/smoother/amg_d_as_smoother_cseti.f90
+  impl/smoother/amg_z_base_smoother_descr.f90
+  impl/smoother/amg_d_as_smoother_restr_a.f90
+  impl/smoother/amg_s_base_smoother_check.f90
+  impl/smoother/amg_c_as_smoother_restr_v.f90
+  impl/smoother/amg_d_poly_smoother_cnv.f90
+  impl/smoother/amg_c_jac_smoother_csetc.f90
+  impl/smoother/amg_z_jac_smoother_dmp.f90
+  impl/smoother/amg_z_base_smoother_apply.f90
+  impl/smoother/amg_s_base_smoother_csetr.f90
+  impl/smoother/amg_d_as_smoother_apply.f90
+  impl/smoother/amg_c_as_smoother_prol_a.f90
+  impl/smoother/amg_d_poly_smoother_clear_data.f90
+  impl/smoother/amg_c_base_smoother_descr.f90
+  impl/smoother/amg_d_as_smoother_bld.f90
+  impl/smoother/amg_c_as_smoother_bld.f90
+  impl/smoother/amg_c_as_smoother_cseti.f90
+  impl/smoother/amg_s_as_smoother_bld.f90
+  impl/smoother/amg_z_as_smoother_restr_a.f90
+  impl/smoother/amg_d_as_smoother_clear_data.f90
+  impl/smoother/amg_d_l1_jac_smoother_clone.f90
+  impl/smoother/amg_c_base_smoother_dmp.f90
+  impl/smoother/amg_d_base_smoother_descr.f90
+  impl/smoother/amg_c_base_smoother_apply_vect.f90
+  impl/smoother/amg_d_base_smoother_apply_vect.f90
+  impl/smoother/amg_c_base_smoother_clear_data.f90
+  impl/smoother/amg_d_poly_smoother_dmp.f90
+  impl/smoother/amg_s_poly_smoother_cseti.f90
+  impl/smoother/amg_s_as_smoother_check.f90
+  impl/smoother/amg_s_jac_smoother_descr.f90
+  impl/smoother/amg_d_jac_smoother_clone_settings.f90
+  impl/smoother/amg_d_as_smoother_prol_v.f90
+  impl/smoother/amg_z_jac_smoother_apply.f90
+  impl/smoother/amg_d_as_smoother_cnv.f90
+  impl/smoother/amg_c_jac_smoother_apply_vect.f90
+  impl/smoother/amg_c_as_smoother_dmp.f90
+  impl/smoother/amg_c_base_smoother_bld.f90
+  impl/smoother/amg_d_as_smoother_clone_settings.f90
+  impl/smoother/amg_d_base_smoother_clear_data.f90
+  impl/smoother/amg_s_jac_smoother_clone_settings.f90
+  impl/smoother/amg_z_as_smoother_dmp.f90
+  impl/smoother/amg_z_as_smoother_clone.f90
+  impl/smoother/amg_z_as_smoother_restr_v.f90
+  impl/smoother/amg_z_as_smoother_prol_a.f90
+  impl/smoother/amg_z_base_smoother_apply_vect.f90
+  impl/amg_d_smoothers_bld.f90
+  impl/amg_zprecset.F90
+  impl/amg_d_hierarchy_rebld.f90
+  impl/amg_d_extprol_bld.F90
+  impl/amg_dprecset.F90
+  impl/amg_scprecset.F90
+  impl/amg_sprecset.F90
+  impl/amg_dmlprec_bld.f90
+  impl/amg_zmlprec_aply.f90
+  impl/aggregator/amg_d_dec_aggregator_tprol.f90
+  impl/aggregator/amg_s_parmatch_aggregator_mat_asb.F90
+  impl/aggregator/amg_s_parmatch_aggregator_tprol.F90
+  impl/aggregator/amg_z_dec_aggregator_tprol.f90
+  impl/aggregator/amg_saggrmat_smth_bld.f90
+  impl/aggregator/amg_s_soc2_map_bld.F90
+  impl/aggregator/amg_s_parmatch_spmm_bld_inner.F90
+  impl/aggregator/amg_caggrmat_minnrg_bld.f90
+  impl/aggregator/amg_d_soc2_map_bld.F90
+  impl/aggregator/amg_s_dec_aggregator_tprol.f90
+  impl/aggregator/amg_s_parmatch_aggregator_inner_mat_asb.F90
+  impl/aggregator/amg_s_dec_aggregator_mat_bld.f90
+  impl/aggregator/amg_c_dec_aggregator_mat_asb.f90
+  impl/aggregator/amg_s_rap.f90
+  impl/aggregator/amg_s_map_to_tprol.f90
+  impl/aggregator/amg_d_parmatch_aggregator_tprol.F90
+  impl/aggregator/amg_saggrmat_nosmth_bld.f90
+  impl/aggregator/amg_c_soc1_map_bld.F90
+  impl/aggregator/amg_d_parmatch_aggregator_mat_asb.F90
+  impl/aggregator/amg_zaggrmat_smth_bld.f90
+  impl/aggregator/amg_d_parmatch_smth_bld.F90
+  impl/aggregator/amg_caggrmat_nosmth_bld.f90
+  impl/aggregator/amg_c_map_to_tprol.f90
+  impl/aggregator/amg_d_rap.f90
+  impl/aggregator/amg_d_map_to_tprol.f90
+  impl/aggregator/amg_daggrmat_minnrg_bld.f90
+  impl/aggregator/amg_d_dec_aggregator_mat_asb.f90
+  impl/aggregator/amg_z_dec_aggregator_mat_bld.f90
+  impl/aggregator/amg_d_parmatch_spmm_bld.F90
+  impl/aggregator/amg_d_parmatch_aggregator_mat_bld.F90
+  impl/aggregator/amg_d_ptap_bld.f90
+  impl/aggregator/amg_z_symdec_aggregator_tprol.f90
+  impl/aggregator/amg_s_symdec_aggregator_tprol.f90
+  impl/aggregator/amg_z_soc1_map_bld.F90
+  impl/aggregator/amg_d_parmatch_unsmth_bld.F90
+  impl/aggregator/amg_z_map_to_tprol.f90
+  impl/aggregator/amg_d_soc1_map_bld.F90
+  impl/aggregator/amg_d_parmatch_spmm_bld_ov.F90
+  impl/aggregator/amg_s_parmatch_aggregator_mat_bld.F90
+  impl/aggregator/amg_s_parmatch_unsmth_bld.F90
+  impl/aggregator/amg_d_parmatch_aggregator_inner_mat_asb.F90
+  impl/aggregator/amg_s_parmatch_spmm_bld.F90
+  impl/aggregator/amg_c_symdec_aggregator_tprol.f90
+  impl/aggregator/amg_zaggrmat_minnrg_bld.f90
+  impl/aggregator/amg_c_dec_aggregator_tprol.f90
+  impl/aggregator/amg_z_dec_aggregator_mat_asb.f90
+  impl/aggregator/amg_c_rap.f90
+  impl/aggregator/amg_s_parmatch_spmm_bld_ov.F90
+  impl/aggregator/amg_s_ptap_bld.f90
+  impl/aggregator/amg_s_soc1_map_bld.F90
+  impl/aggregator/amg_d_dec_aggregator_mat_bld.f90
+  impl/aggregator/amg_z_ptap_bld.f90
+  impl/aggregator/amg_daggrmat_smth_bld.f90
+  impl/aggregator/amg_z_soc2_map_bld.F90
+  impl/aggregator/amg_caggrmat_smth_bld.f90
+  impl/aggregator/amg_saggrmat_minnrg_bld.f90
+  impl/aggregator/amg_c_soc2_map_bld.F90
+  impl/aggregator/amg_s_dec_aggregator_mat_asb.f90
+  impl/aggregator/amg_z_rap.f90
+  impl/aggregator/amg_s_parmatch_smth_bld.F90
+  impl/aggregator/amg_c_dec_aggregator_mat_bld.f90
+  impl/aggregator/amg_daggrmat_nosmth_bld.f90
+  impl/aggregator/amg_d_symdec_aggregator_tprol.f90
+  impl/aggregator/amg_d_parmatch_spmm_bld_inner.F90
+  impl/aggregator/amg_c_ptap_bld.f90
+  impl/aggregator/amg_zaggrmat_nosmth_bld.f90
+  impl/amg_cmlprec_aply.f90
+  impl/amg_cmlprec_bld.f90
+  amg_d_invt_solver.f90
+  amg_c_id_solver.f90
+  amg_base_ainv_mod.F90
+  amg_d_matchboxp_mod.F90
+  amg_z_base_smoother_mod.f90
+  amg_s_invk_solver.f90
+  amg_c_base_solver_mod.f90
+  amg_s_ilu_solver.f90
+  amg_z_ilu_fact_mod.f90
+  amg_prec_mod.f90
+  amg_d_gs_solver.f90
+  amg_d_jac_smoother.f90
+  amg_z_symdec_aggregator_mod.f90
+  amg_s_gs_solver.f90
+  amg_ainv_mod.f90
+  amg_d_parmatch_aggregator_mod.F90
+  amg_z_as_smoother.f90
+  amg_c_inner_mod.f90
+  amg_d_poly_smoother.f90
+  amg_z_onelev_mod.f90
+  amg_z_diag_solver.f90
+  amg_c_symdec_aggregator_mod.f90
+  amg_c_prec_mod.f90
+  amg_d_sludist_solver.F90
+  amg_d_base_solver_mod.f90
+  amg_c_dec_aggregator_mod.f90
+  amg_c_ilu_fact_mod.f90
+  amg_s_onelev_mod.f90
+  amg_d_base_ainv_mod.f90
+  amg_d_invk_solver.f90
+  amg_z_invt_solver.f90
+  amg_z_prec_mod.f90
+  amg_s_prec_mod.f90
+  amg_d_mumps_solver.F90
+  amg_d_umf_solver.F90
+#  amg_d_hybrid_aggregator_mod.F90
+  amg_d_id_solver.f90
+#  amg_c_hybrid_aggregator_mod.F90
+  amg_z_base_ainv_mod.f90
+  amg_z_sludist_solver.F90
+  amg_d_ilu_solver.f90
+  amg_s_base_ainv_mod.f90
+  amg_c_invt_solver.f90
+#  amg_s_hybrid_aggregator_mod.F90
+  amg_d_prec_type.f90
+  amg_d_base_smoother_mod.f90
+  amg_c_base_ainv_mod.f90
+  amg_s_prec_type.f90
+  amg_s_diag_solver.f90
+  amg_z_base_aggregator_mod.f90
+  amg_z_dec_aggregator_mod.f90
+  amg_prec_type.f90
+  amg_s_invt_solver.f90
+  amg_s_base_smoother_mod.f90
+  amg_c_ainv_solver.F90
+  amg_d_dec_aggregator_mod.f90
+  amg_s_slu_solver.F90
+  amg_d_diag_solver.f90
+  amg_z_id_solver.f90
+  amg_c_slu_solver.F90
+  amg_s_jac_smoother.f90
+  amg_s_dec_aggregator_mod.f90
+  amg_d_inner_mod.f90
+  amg_s_mumps_solver.F90
+  amg_d_jac_solver.f90
+  amg_s_krm_solver.f90
+  amg_s_as_smoother.f90
+  amg_d_onelev_mod.f90
+  amg_z_jac_solver.f90
+  amg_d_symdec_aggregator_mod.f90
+  amg_c_onelev_mod.f90
+  amg_s_parmatch_aggregator_mod.F90
+  amg_c_ilu_solver.f90
+  amg_d_poly_coeff_mod.f90
+  amg_s_jac_solver.f90
+  amg_base_prec_type.F90
+  amg_s_base_aggregator_mod.f90
+  amg_z_ainv_solver.F90
+  amg_d_prec_mod.f90
+  amg_c_prec_type.f90
+  amg_d_as_smoother.f90
+  amg_z_ilu_solver.f90
+  amg_c_base_aggregator_mod.f90
+  amg_s_id_solver.f90
+  amg_c_krm_solver.f90
+  amg_z_jac_smoother.f90
+  amg_c_as_smoother.f90
+  amg_z_invk_solver.f90
+  amg_d_krm_solver.f90
+  amg_c_invk_solver.f90
+  amg_c_mumps_solver.F90
+  amg_c_jac_solver.f90
+  amg_z_umf_solver.F90
+  amg_s_symdec_aggregator_mod.f90
+  amg_s_poly_smoother.f90
+  amg_s_inner_mod.f90
+  amg_s_ilu_fact_mod.f90
+  amg_z_mumps_solver.F90
+  amg_c_jac_smoother.f90
+)
+foreach(file IN LISTS AMG_amgprec_source_files)
+  list(APPEND amgprec_source_files ${CMAKE_CURRENT_LIST_DIR}/${file})
+endforeach()
+
+
+list(APPEND AMG_amgprec_source_C_files impl/amg_dslu_interface.c)
+list(APPEND AMG_amgprec_source_C_files impl/amg_zslu_interface.c)
+list(APPEND AMG_amgprec_source_C_files  impl/amg_sslu_interface.c)
+list(APPEND AMG_amgprec_source_C_files  impl/amg_dumf_interface.c)
+list(APPEND AMG_amgprec_source_C_files  impl/amg_cslu_interface.c)
+list(APPEND AMG_amgprec_source_C_files  impl/amg_dslud_interface.c)
+list(APPEND AMG_amgprec_source_C_files  impl/amg_zumf_interface.c)
+list(APPEND AMG_amgprec_source_C_files  impl/amg_zslud_interface.c)
+
+foreach(file IN LISTS AMG_amgprec_source_C_files)
+  list(APPEND amgprec_source_C_files ${CMAKE_CURRENT_LIST_DIR}/${file})
+endforeach()

amgprec/Makefile

@@ -66,7 +66,7 @@ LIBNAME=libamg_prec.a
 all: objs impld
 
 objs: $(OBJS)
-	/bin/cp -p amg_const.h $(INCDIR)
+	/bin/cp -p amg_const.h amg_config.h $(INCDIR)
 	/bin/cp -p *$(.mod) $(MODDIR)
 
 impld: objs

amgprec/amg_base_ainv_mod.F90

@@ -55,10 +55,6 @@ module amg_base_ainv_mod
   integer, parameter   :: amg_ainv_llk_noth_ = amg_ainv_s_ft_llk_  + 1
   integer, parameter   :: amg_ainv_mlk_      = amg_ainv_llk_noth_  + 1
   integer, parameter   :: amg_ainv_lmx_      = amg_ainv_mlk_
-#if defined(HAVE_TUMA_SAINV)
-  integer, parameter   :: amg_ainv_s_tuma_    = amg_ainv_lmx_  + 1
-  integer, parameter   :: amg_ainv_l_tuma_    = amg_ainv_s_tuma_  + 1
-#endif
 
 
 end module amg_base_ainv_mod

amgprec/amg_base_prec_type.F90

@@ -81,9 +81,9 @@ module amg_base_prec_type
   !
   ! Version numbers
   !
-  character(len=*), parameter   :: amg_version_string_ = "1.1.0"
+  character(len=*), parameter   :: amg_version_string_ = "1.2.0"
   integer(psb_ipk_), parameter  :: amg_version_major_  = 1
-  integer(psb_ipk_), parameter  :: amg_version_minor_  = 1
+  integer(psb_ipk_), parameter  :: amg_version_minor_  = 2
   integer(psb_ipk_), parameter  :: amg_patchlevel_     = 0
 
   type amg_ml_parms
@@ -288,17 +288,19 @@ module amg_base_prec_type
   !
   ! Legal values for entry: amg_aggr_prol_
   !
-  integer(psb_ipk_), parameter :: amg_no_smooth_   = 0
-  integer(psb_ipk_), parameter :: amg_smooth_prol_ = 1
-  integer(psb_ipk_), parameter :: amg_min_energy_  = 2
+  integer(psb_ipk_), parameter :: amg_no_smooth_      = 0
+  integer(psb_ipk_), parameter :: amg_smooth_prol_    = 1
+  integer(psb_ipk_), parameter :: amg_l1_smooth_prol_ = 2
+  integer(psb_ipk_), parameter :: amg_min_energy_     = 3
   ! Disabling min_energy  for the time being.
-  integer(psb_ipk_), parameter :: amg_max_aggr_prol_=amg_smooth_prol_
+  integer(psb_ipk_), parameter :: amg_max_aggr_prol_= amg_l1_smooth_prol_
   !
   ! Legal values for entry: amg_aggr_filter_
   !
-  integer(psb_ipk_), parameter :: amg_no_filter_mat_  = 0
-  integer(psb_ipk_), parameter :: amg_filter_mat_     = 1
-  integer(psb_ipk_), parameter :: amg_max_filter_mat_ = amg_filter_mat_
+  integer(psb_ipk_), parameter :: amg_no_filter_mat_   = 0
+  integer(psb_ipk_), parameter :: amg_filter_mat_      = 1
+  integer(psb_ipk_), parameter :: amg_filter_prow_mat_ = 2
+  integer(psb_ipk_), parameter :: amg_max_filter_mat_  = amg_filter_prow_mat_
   !
   ! Legal values for entry: amg_aggr_ord_
   !
@@ -323,10 +325,10 @@ module amg_base_prec_type
   !
   ! Legal values for entry: amg_poly_variant_
   !
-  integer(psb_ipk_), parameter :: amg_poly_lottes_      = 0
-  integer(psb_ipk_), parameter :: amg_poly_lottes_beta_ = 1
-  integer(psb_ipk_), parameter :: amg_poly_new_         = 2
-  integer(psb_ipk_), parameter :: amg_poly_dbg_         = 8
+  integer(psb_ipk_), parameter :: amg_cheb_4_     = 0
+  integer(psb_ipk_), parameter :: amg_cheb_4_opt_ = 1
+  integer(psb_ipk_), parameter :: amg_cheb_1_opt_ = 2
+  integer(psb_ipk_), parameter :: amg_poly_dbg_   = 8
   
   integer(psb_ipk_), parameter :: amg_poly_rho_est_power_ = 0
 
@@ -376,10 +378,11 @@ module amg_base_prec_type
   character(len=19), parameter, private :: &
        &  eigen_estimates(0:0)=(/'infinity norm     '/)
   character(len=15), parameter, private :: &
-       &  aggr_prols(0:3)=(/'unsmoothed    ','smoothed      ',&
-       &           'min energy    ','bizr. smoothed'/)
+       &  aggr_prols(0:4)=(/'unsmoothed    ','smoothed      ',&
+       &  'l1-smoothed   ','min energy    ','bizr. smoothed'/)
   character(len=15), parameter, private :: &
-       &  aggr_filters(0:1)=(/'no filtering  ','filtering     '/)
+       &  aggr_filters(0:2)=(/'no filtering  ','filtering     ',&
+       &  'filtering rsum'/)
   character(len=15), parameter, private :: &
        &  matrix_names(0:1)=(/'distributed   ','replicated    '/)
   character(len=18), parameter, private :: &
@@ -548,6 +551,8 @@ contains
       val = amg_no_smooth_
     case('SMOOTHED')
       val = amg_smooth_prol_
+    case('L1-SMOOTHED','L1SMOOTHED')
+      val = amg_l1_smooth_prol_
     case('MINENERGY')
       val = amg_min_energy_
     case('NOPREC')
@@ -570,12 +575,12 @@ contains
       val = amg_as_
     case('POLY')
       val = amg_poly_
-    case('POLY_LOTTES')
-      val = amg_poly_lottes_
-    case('POLY_LOTTES_BETA')
-      val = amg_poly_lottes_beta_
-    case('POLY_NEW')
-      val = amg_poly_new_
+    case('CHEB_4')
+      val = amg_cheb_4_
+    case('CHEB_4_OPT')
+      val = amg_cheb_4_opt_
+    case('CHEB_1_OPT')
+      val = amg_cheb_1_opt_
     case('POLY_DBG')
       val = amg_poly_dbg_
     case('POLY_RHO_EST_POWER')
@@ -588,6 +593,8 @@ contains
       val = amg_eig_est_
     case('FILTER')
       val = amg_filter_mat_
+    case('FILTERROWSUM')
+      val = amg_filter_prow_mat_
     case('NOFILTER','NO_FILTER')
       val = amg_no_filter_mat_
     case('OUTER_SWEEPS')
@@ -614,9 +621,13 @@ contains
 
   subroutine amg_warn_coarse_mat(val,expected)
     integer(psb_ipk_) :: val, expected
+    integer(psb_mpk_) :: mval, mexp
     if (val /= expected) then
+      mval = val
+      mexp = expected
       write(0,*) 'Warning: resetting COARSE_MAT on an existing hierarchy from ',&
-           & amg_get_coarse_mat_name(val), ' to ',amg_get_coarse_mat_name(expected)
+           & amg_get_coarse_mat_name(mval), &
+           & ' to ',amg_get_coarse_mat_name(mexp)
     end if
   end subroutine amg_warn_coarse_mat
 
@@ -1200,7 +1211,7 @@ contains
     implicit none
     type(psb_ctxt_type), intent(in) :: ctxt
     type(amg_ml_parms), intent(inout)   :: dat
-    integer(psb_ipk_), intent(in), optional :: root
+    integer(psb_mpk_), intent(in), optional :: root
 
     call psb_bcast(ctxt,dat%sweeps_pre,root)
     call psb_bcast(ctxt,dat%sweeps_post,root)
@@ -1222,7 +1233,7 @@ contains
     implicit none
     type(psb_ctxt_type), intent(in) :: ctxt
     type(amg_sml_parms), intent(inout)   :: dat
-    integer(psb_ipk_), intent(in), optional :: root
+    integer(psb_mpk_), intent(in), optional :: root
 
     call psb_bcast(ctxt,dat%amg_ml_parms,root)
     call psb_bcast(ctxt,dat%aggr_omega_val,root)
@@ -1233,7 +1244,7 @@ contains
     implicit none
     type(psb_ctxt_type), intent(in) :: ctxt
     type(amg_dml_parms), intent(inout)   :: dat
-    integer(psb_ipk_), intent(in), optional :: root
+    integer(psb_mpk_), intent(in), optional :: root
 
     call psb_bcast(ctxt,dat%amg_ml_parms,root)
     call psb_bcast(ctxt,dat%aggr_omega_val,root)

amgprec/amg_c_ainv_solver.F90

@@ -62,9 +62,6 @@ module amg_c_ainv_solver
     procedure, pass(sv) :: cseti   => amg_c_ainv_solver_cseti
     procedure, pass(sv) :: csetc   => amg_c_ainv_solver_csetc
     procedure, pass(sv) :: csetr   => amg_c_ainv_solver_csetr
-!!$    procedure, pass(sv) :: seti    => amg_c_ainv_solver_seti
-!!$    procedure, pass(sv) :: setc    => amg_c_ainv_solver_setc
-!!$    procedure, pass(sv) :: setr    => amg_c_ainv_solver_setr
     procedure, pass(sv) :: descr   => amg_c_ainv_solver_descr
     procedure, pass(sv) :: default => c_ainv_solver_default
     procedure, nopass   :: stringval  => c_ainv_stringval
@@ -91,9 +88,9 @@ module amg_c_ainv_solver
       import :: psb_desc_type, psb_cspmat_type,  psb_c_base_sparse_mat, &
        & amg_c_base_solver_type, psb_dpk_, amg_c_ainv_solver_type, psb_ipk_
       Implicit None
-      class(amg_c_ainv_solver_type), intent(inout)              :: sv
-      class(amg_c_base_solver_type), allocatable, intent(inout) :: svout
-      integer(psb_ipk_), intent(out)                            :: info
+      class(amg_c_ainv_solver_type), intent(inout) :: sv
+      class(amg_c_base_solver_type), intent(inout) :: svout
+      integer(psb_ipk_), intent(out)                 :: info
     end subroutine amg_c_ainv_solver_clone_settings
   end interface
 

amgprec/amg_c_base_aggregator_mod.f90

@@ -302,7 +302,7 @@ contains
     integer(psb_ipk_), intent(out) :: info
 
     ! Do nothing
-    
+    info = psb_success_    
     return
   end subroutine amg_c_base_aggregator_set_aggr_type
 
@@ -486,6 +486,7 @@ contains
     integer(psb_ipk_) :: err_act
     character(len=20) :: name='c_base_aggregator_bld_map'
 
+    info = psb_success_
     call psb_erractionsave(err_act)
     !
     ! Copy the prolongation/restriction matrices into the descriptor map.

amgprec/amg_c_dec_aggregator_mod.f90

@@ -150,7 +150,7 @@ contains
     class(amg_c_dec_aggregator_type), intent(inout) :: ag
     type(amg_sml_parms), intent(in)   :: parms
     integer(psb_ipk_), intent(out) :: info
-
+    info = psb_success_
     select case(parms%aggr_type)
     case (amg_noalg_)
       ag%soc_map_bld => null()
@@ -192,6 +192,7 @@ contains
     integer(psb_ipk_), intent(out) :: info
     character(len=*), intent(in), optional  :: prefix
     character(1024)    :: prefix_
+    info = psb_success_
     if (present(prefix)) then
       prefix_ = prefix
     else

amgprec/amg_c_hybrid_aggregator_mod.F90

@@ -1,125 +0,0 @@
-!  
-!   
-!                             AMG4PSBLAS version 1.0
-!    Algebraic Multigrid Package
-!               based on PSBLAS (Parallel Sparse BLAS version 3.7)
-!    
-!    (C) Copyright 2020 
-!  
-!        Salvatore Filippone  
-!        Pasqua D'Ambra   
-!        Fabio Durastante        
-!   
-!    Redistribution and use in source and binary forms, with or without
-!    modification, are permitted provided that the following conditions
-!    are met:
-!      1. Redistributions of source code must retain the above copyright
-!         notice, this list of conditions and the following disclaimer.
-!      2. Redistributions in binary form must reproduce the above copyright
-!         notice, this list of conditions, and the following disclaimer in the
-!         documentation and/or other materials provided with the distribution.
-!      3. The name of the AMG4PSBLAS group or the names of its contributors may
-!         not be used to endorse or promote products derived from this
-!         software without specific written permission.
-!   
-!    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-!    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-!    TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-!    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AMG4PSBLAS GROUP OR ITS CONTRIBUTORS
-!    BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-!    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-!    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-!    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-!    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-!    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-!    POSSIBILITY OF SUCH DAMAGE.
-!   
-!  
-!
-!
-!  The aggregator object hosts the aggregation method for building
-!  the multilevel hierarchy. This variant is based on the hybrid method
-!  presented in 
-!
-!    S. Gratton, P. Henon, P. Jiranek and X. Vasseur:
-!    Reducing complexity of algebraic multigrid by aggregation
-!    Numerical Lin. Algebra with Applications, 2016, 23:501-518
-!    
-module amg_c_hybrid_aggregator_mod
-
-  use amg_c_dec_aggregator_mod
-  !
-  !   sm           -  class(amg_T_base_smoother_type), allocatable
-  !                   The current level preconditioner (aka smoother).
-  !   parms        -  type(amg_RTml_parms)
-  !                   The parameters defining the multilevel strategy.
-  !   ac           -  The local part of the current-level matrix, built by
-  !                   coarsening the previous-level matrix.
-  !   desc_ac      -  type(psb_desc_type).
-  !                   The communication descriptor associated to the matrix
-  !                   stored in ac.
-  !   base_a       -  type(psb_Tspmat_type), pointer.
-  !                   Pointer (really a pointer!) to the local part of the current 
-  !                   matrix (so we have a unified treatment of residuals).
-  !                   We need this to avoid passing explicitly the current matrix
-  !                   to the routine which applies the preconditioner.
-  !   base_desc    -  type(psb_desc_type), pointer.
-  !                   Pointer to the communication descriptor associated to the
-  !                   matrix pointed by base_a.
-  !   map          -  Stores the maps (restriction and prolongation) between the
-  !                   vector spaces associated to the index spaces of the previous
-  !                   and current levels.
-  !
-  !   Methods:  
-  !     Most methods follow the encapsulation hierarchy: they take whatever action
-  !     is appropriate for the current object, then call the corresponding method for
-  !     the contained object.
-  !     As an example: the descr() method prints out a description of the
-  !     level. It starts by invoking the descr() method of the parms object,
-  !     then calls the descr() method of the smoother object. 
-  !
-  !    descr      -   Prints a description of the object.
-  !    default    -   Set default values
-  !    dump       -   Dump to file object contents
-  !    set        -   Sets various parameters; when a request is unknown
-  !                   it is passed to the smoother object for further processing.
-  !    check      -   Sanity checks.
-  !    sizeof     -   Total memory occupation in bytes
-  !    get_nzeros -   Number of nonzeros 
-  !
-  !
-  type, extends(amg_c_dec_aggregator_type) :: amg_c_hybrid_aggregator_type
-    
-  contains
-    procedure, pass(ag) :: bld_tprol    => amg_c_hybrid_aggregator_build_tprol
-    procedure, nopass   :: fmt          => amg_c_hybrid_aggregator_fmt
-  end type amg_c_hybrid_aggregator_type
-
-
-  interface
-    subroutine  amg_c_hybrid_aggregator_build_tprol(ag,parms,a,desc_a,ilaggr,nlaggr,op_prol,info)
-      import :: amg_c_hybrid_aggregator_type, psb_desc_type, psb_cspmat_type, psb_spk_,  &
-           & psb_ipk_, psb_long_int_k_, amg_sml_parms
-      implicit none
-      class(amg_c_hybrid_aggregator_type), target, intent(inout) :: ag
-      type(amg_sml_parms), intent(inout)  :: parms 
-      type(psb_cspmat_type), intent(in)   :: a
-      type(psb_desc_type), intent(in)     :: desc_a
-      integer(psb_ipk_), allocatable, intent(out) :: ilaggr(:),nlaggr(:)
-      type(psb_cspmat_type), intent(out)  :: op_prol
-      integer(psb_ipk_), intent(out)      :: info
-    end subroutine amg_c_hybrid_aggregator_build_tprol
-  end interface
-
-contains
-
-
-  function amg_c_hybrid_aggregator_fmt() result(val)
-    implicit none 
-    character(len=32)  :: val
-
-    val = "Hybrid Decoupled aggregation"
-  end function amg_c_hybrid_aggregator_fmt
-
-  
-end module amg_c_hybrid_aggregator_mod

amgprec/amg_c_inner_mod.f90

@@ -109,11 +109,12 @@ module amg_c_inner_mod
   end interface amg_map_to_tprol
 
   abstract interface
-    subroutine amg_caggrmat_var_bld(a,desc_a,ilaggr,nlaggr,parms,&
+    subroutine amg_caggrmat_var_bld(dol1smoothing,a,desc_a,ilaggr,nlaggr,parms,&
          & ac,desc_ac,op_prol,op_restr,t_prol,info)
       import :: psb_cspmat_type, psb_desc_type, psb_spk_, psb_ipk_, psb_lpk_, psb_lcspmat_type
       import ::  amg_c_onelev_type, amg_sml_parms
       implicit none 
+      integer(psb_ipk_), intent(in)               :: dol1smoothing
       type(psb_cspmat_type), intent(in)         :: a
       type(psb_desc_type), intent(inout)          :: desc_a
       integer(psb_lpk_), intent(inout)            :: ilaggr(:), nlaggr(:)

amgprec/amg_c_invk_solver.f90

@@ -79,9 +79,9 @@ module amg_c_invk_solver
       import :: psb_desc_type, psb_cspmat_type,  psb_c_base_sparse_mat, &
        & amg_c_base_solver_type, psb_spk_, amg_c_invk_solver_type, psb_ipk_
       Implicit None
-      class(amg_c_invk_solver_type), intent(inout)              :: sv
-      class(amg_c_base_solver_type), allocatable, intent(inout) :: svout
-      integer(psb_ipk_), intent(out)                            :: info
+      class(amg_c_invk_solver_type), intent(inout) :: sv
+      class(amg_c_base_solver_type), intent(inout) :: svout
+      integer(psb_ipk_), intent(out)                 :: info
     end subroutine amg_c_invk_solver_clone_settings
   end interface
 

amgprec/amg_c_invt_solver.f90

@@ -79,9 +79,9 @@ module amg_c_invt_solver
       import :: psb_desc_type, psb_cspmat_type,  psb_c_base_sparse_mat, &
        & amg_c_base_solver_type, psb_spk_, amg_c_invt_solver_type, psb_ipk_
       Implicit None
-      class(amg_c_invt_solver_type), intent(inout)              :: sv
-      class(amg_c_base_solver_type), allocatable, intent(inout) :: svout
-      integer(psb_ipk_), intent(out)                            :: info
+      class(amg_c_invt_solver_type), intent(inout) :: sv
+      class(amg_c_base_solver_type), intent(inout) :: svout
+      integer(psb_ipk_), intent(out)                 :: info
     end subroutine amg_c_invt_solver_clone_settings
   end interface
 

amgprec/amg_c_jac_smoother.f90

@@ -203,8 +203,8 @@ module amg_c_jac_smoother
     subroutine amg_c_jac_smoother_clone_settings(sm,smout,info)
       import :: amg_c_jac_smoother_type, psb_spk_, &
            & amg_c_base_smoother_type, psb_ipk_
-      class(amg_c_jac_smoother_type), intent(inout)               :: sm
-      class(amg_c_base_smoother_type), allocatable, intent(inout) :: smout
+      class(amg_c_jac_smoother_type), intent(inout)  :: sm
+      class(amg_c_base_smoother_type), intent(inout) :: smout
       integer(psb_ipk_), intent(out)                :: info
     end subroutine amg_c_jac_smoother_clone_settings
   end interface

amgprec/amg_c_mumps_solver.F90

@@ -52,10 +52,10 @@
 !
 module amg_c_mumps_solver
   use amg_c_base_solver_mod
-#if defined(HAVE_MUMPS_) && defined(HAVE_MUMPS_MODULES_)
+#if defined(AMG_HAVE_MUMPS) && defined(AMG_HAVE_MUMPS_MODULES)
   use cmumps_struc_def
 #endif
-#if defined(HAVE_MUMPS_) && defined(HAVE_MUMPS_INCLUDES_)
+#if defined(AMG_HAVE_MUMPS) && defined(AMG_HAVE_MUMPS_INCLUDES)
   include 'cmumps_struc.h'
 #endif  
   
@@ -68,7 +68,7 @@ module amg_c_mumps_solver
   end type amg_c_mumps_rcntl_item
 
   type, extends(amg_c_base_solver_type) :: amg_c_mumps_solver_type
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     type(cmumps_struc), allocatable  :: id
 #else
     integer, allocatable :: id
@@ -189,7 +189,7 @@ contains
 
     info = 0
 
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     
     call psb_erractionsave(err_act)
 
@@ -239,7 +239,7 @@ contains
     character(len=20)  :: name='c_mumps_solver_clear_data'
 
     info = 0
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     call psb_erractionsave(err_act)
     if (allocated(sv%id)) then      
       if (sv%built) then 
@@ -279,7 +279,7 @@ contains
     character(len=20)  :: name='c_mumps_solver_free'
 
     info = 0
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     call psb_erractionsave(err_act)
     call sv%clear_data(info)
     if ((info == 0).and.allocated(sv%icntl)) deallocate(sv%icntl,stat=info)
@@ -383,7 +383,7 @@ subroutine c_mumps_solver_csetc(sv,what,val,info,idx)
 
 
   select case(psb_toupper(trim(what)))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_LOC_GLOB')
     sv%ipar(1) = sv%stringval(psb_toupper(trim(val)))
 #endif
@@ -421,7 +421,7 @@ subroutine c_mumps_solver_cseti(sv,what,val,info,idx)
   call psb_erractionsave(err_act)
 
   select case(psb_toupper(what))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_LOC_GLOB')
     sv%ipar(1) = val
   case('MUMPS_PRINT_ERR')
@@ -467,7 +467,7 @@ subroutine c_mumps_solver_csetr(sv,what,val,info,idx)
   call psb_erractionsave(err_act)
 
   select case(psb_toupper(what))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_RPAR_ENTRY')
     if(present(idx)) then 
       ! Note: this will allocate %item
@@ -504,7 +504,7 @@ subroutine c_mumps_solver_default(sv)
   info = psb_success_
   call psb_erractionsave(err_act)
 
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   if (.not.allocated(sv%id)) then 
     allocate(sv%id,stat=info)
     if (info /= psb_success_) then
@@ -561,7 +561,7 @@ function c_mumps_solver_sizeof(sv) result(val)
   class(amg_c_mumps_solver_type), intent(in) :: sv
   integer(psb_epk_) :: val
   integer             :: i
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   val = (sv%id%INFOG(22)+sv%id%INFOG(32))*1d+6
 #else
   val = 0 

amgprec/amg_c_prec_type.f90

@@ -113,6 +113,7 @@ module amg_c_prec_type
     procedure, pass(prec)               :: free           => amg_c_prec_free
     procedure, pass(prec)               :: allocate_wrk   => amg_c_allocate_wrk
     procedure, pass(prec)               :: free_wrk       => amg_c_free_wrk
+    procedure, pass(prec)               :: deallocate_wrk => amg_c_free_wrk
     procedure, pass(prec)               :: is_allocated_wrk => amg_c_is_allocated_wrk
     procedure, pass(prec)               :: get_complexity => amg_c_get_compl
     procedure, pass(prec)               :: cmp_complexity => amg_c_cmp_compl

amgprec/amg_c_slu_solver.F90

@@ -51,7 +51,7 @@ module amg_c_slu_solver
   use iso_c_binding
   use amg_c_base_solver_mod
 
-#if defined(IPK8)
+#if defined(PSB_IPK8)
 
   type, extends(amg_c_base_solver_type) :: amg_c_slu_solver_type
 

amgprec/amg_c_symdec_aggregator_mod.f90

@@ -97,7 +97,7 @@ contains
     character(len=*), intent(in), optional  :: prefix
 
     character(1024)    :: prefix_
-
+    info = psb_success_
     if (present(prefix)) then
       prefix_ = prefix
     else

amgprec/amg_config.h.in

@@ -0,0 +1,17 @@
+#ifndef AMG_CONFIG_H
+#define AMG_CONFIG_H
+
+#include "psb_config.h"
+
+@CHAVEUMF@
+@CHAVESLU@
+@CSLUVERSION@
+@CHAVESLUDIST@
+@CSLUDISTVERSION@
+@CHAVEMUMPS@
+@CHAVEMUMPSMODULES@
+@CHAVEMUMPSINCLUDES@
+@CXXMATCHBOXBIT@
+
+
+#endif

amgprec/amg_d_ainv_solver.F90

@@ -62,9 +62,6 @@ module amg_d_ainv_solver
     procedure, pass(sv) :: cseti   => amg_d_ainv_solver_cseti
     procedure, pass(sv) :: csetc   => amg_d_ainv_solver_csetc
     procedure, pass(sv) :: csetr   => amg_d_ainv_solver_csetr
-!!$    procedure, pass(sv) :: seti    => amg_d_ainv_solver_seti
-!!$    procedure, pass(sv) :: setc    => amg_d_ainv_solver_setc
-!!$    procedure, pass(sv) :: setr    => amg_d_ainv_solver_setr
     procedure, pass(sv) :: descr   => amg_d_ainv_solver_descr
     procedure, pass(sv) :: default => d_ainv_solver_default
     procedure, nopass   :: stringval  => d_ainv_stringval
@@ -91,9 +88,9 @@ module amg_d_ainv_solver
       import :: psb_desc_type, psb_dspmat_type,  psb_d_base_sparse_mat, &
        & amg_d_base_solver_type, psb_dpk_, amg_d_ainv_solver_type, psb_ipk_
       Implicit None
-      class(amg_d_ainv_solver_type), intent(inout)              :: sv
-      class(amg_d_base_solver_type), allocatable, intent(inout) :: svout
-      integer(psb_ipk_), intent(out)                            :: info
+      class(amg_d_ainv_solver_type), intent(inout) :: sv
+      class(amg_d_base_solver_type), intent(inout) :: svout
+      integer(psb_ipk_), intent(out)                 :: info
     end subroutine amg_d_ainv_solver_clone_settings
   end interface
 

amgprec/amg_d_base_aggregator_mod.f90

@@ -302,7 +302,7 @@ contains
     integer(psb_ipk_), intent(out) :: info
 
     ! Do nothing
-    
+    info = psb_success_    
     return
   end subroutine amg_d_base_aggregator_set_aggr_type
 
@@ -486,6 +486,7 @@ contains
     integer(psb_ipk_) :: err_act
     character(len=20) :: name='d_base_aggregator_bld_map'
 
+    info = psb_success_
     call psb_erractionsave(err_act)
     !
     ! Copy the prolongation/restriction matrices into the descriptor map.

amgprec/amg_d_dec_aggregator_mod.f90

@@ -150,7 +150,7 @@ contains
     class(amg_d_dec_aggregator_type), intent(inout) :: ag
     type(amg_dml_parms), intent(in)   :: parms
     integer(psb_ipk_), intent(out) :: info
-
+    info = psb_success_
     select case(parms%aggr_type)
     case (amg_noalg_)
       ag%soc_map_bld => null()
@@ -192,6 +192,7 @@ contains
     integer(psb_ipk_), intent(out) :: info
     character(len=*), intent(in), optional  :: prefix
     character(1024)    :: prefix_
+    info = psb_success_
     if (present(prefix)) then
       prefix_ = prefix
     else

amgprec/amg_d_hybrid_aggregator_mod.F90

@@ -1,125 +0,0 @@
-!  
-!   
-!                             AMG4PSBLAS version 1.0
-!    Algebraic Multigrid Package
-!               based on PSBLAS (Parallel Sparse BLAS version 3.7)
-!    
-!    (C) Copyright 2020 
-!  
-!        Salvatore Filippone  
-!        Pasqua D'Ambra   
-!        Fabio Durastante        
-!   
-!    Redistribution and use in source and binary forms, with or without
-!    modification, are permitted provided that the following conditions
-!    are met:
-!      1. Redistributions of source code must retain the above copyright
-!         notice, this list of conditions and the following disclaimer.
-!      2. Redistributions in binary form must reproduce the above copyright
-!         notice, this list of conditions, and the following disclaimer in the
-!         documentation and/or other materials provided with the distribution.
-!      3. The name of the AMG4PSBLAS group or the names of its contributors may
-!         not be used to endorse or promote products derived from this
-!         software without specific written permission.
-!   
-!    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-!    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-!    TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-!    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AMG4PSBLAS GROUP OR ITS CONTRIBUTORS
-!    BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-!    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-!    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-!    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-!    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-!    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-!    POSSIBILITY OF SUCH DAMAGE.
-!   
-!  
-!
-!
-!  The aggregator object hosts the aggregation method for building
-!  the multilevel hierarchy. This variant is based on the hybrid method
-!  presented in 
-!
-!    S. Gratton, P. Henon, P. Jiranek and X. Vasseur:
-!    Reducing complexity of algebraic multigrid by aggregation
-!    Numerical Lin. Algebra with Applications, 2016, 23:501-518
-!    
-module amg_d_hybrid_aggregator_mod
-
-  use amg_d_dec_aggregator_mod
-  !
-  !   sm           -  class(amg_T_base_smoother_type), allocatable
-  !                   The current level preconditioner (aka smoother).
-  !   parms        -  type(amg_RTml_parms)
-  !                   The parameters defining the multilevel strategy.
-  !   ac           -  The local part of the current-level matrix, built by
-  !                   coarsening the previous-level matrix.
-  !   desc_ac      -  type(psb_desc_type).
-  !                   The communication descriptor associated to the matrix
-  !                   stored in ac.
-  !   base_a       -  type(psb_Tspmat_type), pointer.
-  !                   Pointer (really a pointer!) to the local part of the current 
-  !                   matrix (so we have a unified treatment of residuals).
-  !                   We need this to avoid passing explicitly the current matrix
-  !                   to the routine which applies the preconditioner.
-  !   base_desc    -  type(psb_desc_type), pointer.
-  !                   Pointer to the communication descriptor associated to the
-  !                   matrix pointed by base_a.
-  !   map          -  Stores the maps (restriction and prolongation) between the
-  !                   vector spaces associated to the index spaces of the previous
-  !                   and current levels.
-  !
-  !   Methods:  
-  !     Most methods follow the encapsulation hierarchy: they take whatever action
-  !     is appropriate for the current object, then call the corresponding method for
-  !     the contained object.
-  !     As an example: the descr() method prints out a description of the
-  !     level. It starts by invoking the descr() method of the parms object,
-  !     then calls the descr() method of the smoother object. 
-  !
-  !    descr      -   Prints a description of the object.
-  !    default    -   Set default values
-  !    dump       -   Dump to file object contents
-  !    set        -   Sets various parameters; when a request is unknown
-  !                   it is passed to the smoother object for further processing.
-  !    check      -   Sanity checks.
-  !    sizeof     -   Total memory occupation in bytes
-  !    get_nzeros -   Number of nonzeros 
-  !
-  !
-  type, extends(amg_d_dec_aggregator_type) :: amg_d_hybrid_aggregator_type
-    
-  contains
-    procedure, pass(ag) :: bld_tprol    => amg_d_hybrid_aggregator_build_tprol
-    procedure, nopass   :: fmt          => amg_d_hybrid_aggregator_fmt
-  end type amg_d_hybrid_aggregator_type
-
-
-  interface
-    subroutine  amg_d_hybrid_aggregator_build_tprol(ag,parms,a,desc_a,ilaggr,nlaggr,op_prol,info)
-      import :: amg_d_hybrid_aggregator_type, psb_desc_type, psb_dspmat_type, psb_dpk_,  &
-           & psb_ipk_, psb_long_int_k_, amg_dml_parms
-      implicit none
-      class(amg_d_hybrid_aggregator_type), target, intent(inout) :: ag
-      type(amg_dml_parms), intent(inout)  :: parms 
-      type(psb_dspmat_type), intent(in)   :: a
-      type(psb_desc_type), intent(in)     :: desc_a
-      integer(psb_ipk_), allocatable, intent(out) :: ilaggr(:),nlaggr(:)
-      type(psb_dspmat_type), intent(out)  :: op_prol
-      integer(psb_ipk_), intent(out)      :: info
-    end subroutine amg_d_hybrid_aggregator_build_tprol
-  end interface
-
-contains
-
-
-  function amg_d_hybrid_aggregator_fmt() result(val)
-    implicit none 
-    character(len=32)  :: val
-
-    val = "Hybrid Decoupled aggregation"
-  end function amg_d_hybrid_aggregator_fmt
-
-  
-end module amg_d_hybrid_aggregator_mod

amgprec/amg_d_inner_mod.f90

@@ -109,11 +109,12 @@ module amg_d_inner_mod
   end interface amg_map_to_tprol
 
   abstract interface
-    subroutine amg_daggrmat_var_bld(a,desc_a,ilaggr,nlaggr,parms,&
+    subroutine amg_daggrmat_var_bld(dol1smoothing,a,desc_a,ilaggr,nlaggr,parms,&
          & ac,desc_ac,op_prol,op_restr,t_prol,info)
       import :: psb_dspmat_type, psb_desc_type, psb_dpk_, psb_ipk_, psb_lpk_, psb_ldspmat_type
       import ::  amg_d_onelev_type, amg_dml_parms
       implicit none 
+      integer(psb_ipk_), intent(in)               :: dol1smoothing
       type(psb_dspmat_type), intent(in)         :: a
       type(psb_desc_type), intent(inout)          :: desc_a
       integer(psb_lpk_), intent(inout)            :: ilaggr(:), nlaggr(:)

amgprec/amg_d_invk_solver.f90

@@ -79,9 +79,9 @@ module amg_d_invk_solver
       import :: psb_desc_type, psb_dspmat_type,  psb_d_base_sparse_mat, &
        & amg_d_base_solver_type, psb_dpk_, amg_d_invk_solver_type, psb_ipk_
       Implicit None
-      class(amg_d_invk_solver_type), intent(inout)              :: sv
-      class(amg_d_base_solver_type), allocatable, intent(inout) :: svout
-      integer(psb_ipk_), intent(out)                            :: info
+      class(amg_d_invk_solver_type), intent(inout) :: sv
+      class(amg_d_base_solver_type), intent(inout) :: svout
+      integer(psb_ipk_), intent(out)                 :: info
     end subroutine amg_d_invk_solver_clone_settings
   end interface
 

amgprec/amg_d_invt_solver.f90

@@ -79,9 +79,9 @@ module amg_d_invt_solver
       import :: psb_desc_type, psb_dspmat_type,  psb_d_base_sparse_mat, &
        & amg_d_base_solver_type, psb_dpk_, amg_d_invt_solver_type, psb_ipk_
       Implicit None
-      class(amg_d_invt_solver_type), intent(inout)              :: sv
-      class(amg_d_base_solver_type), allocatable, intent(inout) :: svout
-      integer(psb_ipk_), intent(out)                            :: info
+      class(amg_d_invt_solver_type), intent(inout) :: sv
+      class(amg_d_base_solver_type), intent(inout) :: svout
+      integer(psb_ipk_), intent(out)                 :: info
     end subroutine amg_d_invt_solver_clone_settings
   end interface
 

amgprec/amg_d_jac_smoother.f90

@@ -203,8 +203,8 @@ module amg_d_jac_smoother
     subroutine amg_d_jac_smoother_clone_settings(sm,smout,info)
       import :: amg_d_jac_smoother_type, psb_dpk_, &
            & amg_d_base_smoother_type, psb_ipk_
-      class(amg_d_jac_smoother_type), intent(inout)               :: sm
-      class(amg_d_base_smoother_type), allocatable, intent(inout) :: smout
+      class(amg_d_jac_smoother_type), intent(inout)  :: sm
+      class(amg_d_base_smoother_type), intent(inout) :: smout
       integer(psb_ipk_), intent(out)                :: info
     end subroutine amg_d_jac_smoother_clone_settings
   end interface

amgprec/amg_d_matchboxp_mod.F90

@@ -73,6 +73,22 @@ module amg_d_matchboxp_mod
   use iso_c_binding
   use psb_base_cbind_mod
 
+#if defined(PSB_SERIAL_MPI)
+  interface MatchingC
+    subroutine dMatchingC(nlver,nledge,verlocptr,verlocind,edgelocweight,&
+         & verdistance, mate) bind(c,name='dMatching')
+      use iso_c_binding
+      import :: psb_c_ipk_, psb_c_lpk_
+      implicit none
+
+      integer(psb_c_lpk_), value :: nlver,nledge
+      integer(psb_c_lpk_) :: verlocptr(*),verlocind(*), verdistance(*)
+      integer(psb_c_lpk_) :: mate(*)
+      real(c_double) :: edgelocweight(*)
+    end subroutine dMatchingC
+  end interface MatchingC
+
+#else
   interface MatchBoxPC
     subroutine dMatchBoxPC(nlver,nledge,verlocptr,verlocind,edgelocweight,&
          & verdistance, mate, myrank, numprocs, icomm,&
@@ -93,7 +109,7 @@ module amg_d_matchboxp_mod
       real(c_double)     :: msgpercent(*)
     end subroutine dMatchBoxPC
   end interface MatchBoxPC
-
+#endif
   interface amg_i_aggr_assign
     module procedure amg_i_d_aggr_assign
   end interface amg_i_aggr_assign
@@ -145,7 +161,7 @@ contains
     logical, parameter  :: dump=.false., debug=.false., dump_mate=.false., &
          & debug_ilaggr=.false., debug_sync=.false., debug_mate=.false.
     integer(psb_ipk_), save :: idx_bldmtc=-1, idx_phase1=-1, idx_phase2=-1, idx_phase3=-1
-    logical, parameter :: do_timings=.true.
+    logical, parameter :: do_timings=.false.
     integer, parameter :: ilaggr_neginit=-1, ilaggr_nonlocal=-2
 
     ictxt = desc_a%get_ctxt()
@@ -608,7 +624,7 @@ contains
     logical, parameter :: old_style=.false., sort_minp=.true.
     character(len=40) :: name='build_matching', fname
     integer(psb_ipk_), save :: idx_cmboxp=-1, idx_bldahat=-1, idx_phase2=-1, idx_phase3=-1
-    logical, parameter :: do_timings=.true.
+    logical, parameter :: do_timings=.false.
 
     ictxt = desc_a%get_ctxt()
     call psb_info(ictxt,iam,np)
@@ -810,7 +826,7 @@ contains
     character(len=80) :: aname
     real(psb_dpk_), parameter :: eps=epsilon(1.d0)
     integer(psb_ipk_), save   :: idx_glbt=-1, idx_phase1=-1, idx_phase2=-1
-    logical, parameter :: do_timings=.true.
+    logical, parameter :: do_timings=.false.
     logical, parameter :: debug_symmetry = .false., check_size=.false.
     logical, parameter :: unroll_logtrans=.false.
 
@@ -863,7 +879,7 @@ contains
     nr = tcoo1%get_nrows()
     nc = tcoo1%get_ncols()
     nz = tcoo1%get_nzeros()
-    call tcoo2%allocate(nr,nc,int(1.25*nz))
+    call tcoo2%allocate(nr,nc,int(1.25*nz,psb_ipk_))
     k2 = 0
     !
     ! Build the entries of \^A for matching
@@ -1040,7 +1056,8 @@ contains
     integer(psb_c_lpk_) :: ph1_card(*),ph2_card(*)
     real(c_double)  :: edgelocweight(:)
     real(c_double)      :: msgpercent(*)
-    integer(psb_ipk_)   :: info, me, np
+    integer(psb_ipk_)   :: info
+    integer(psb_mpk_)   :: me, np
     integer(psb_c_mpk_) :: icomm, mrank, mnp
     logical, optional   :: display_inp
     !
@@ -1129,11 +1146,15 @@ contains
       call psb_barrier(ictxt)
       if (me == 0) write(0,*)' Calling MatchBoxP '
     end if
-
+#if defined(PSB_SERIAL_MPI)
+    call MatchingC(nlver,nledge,verlocptr,verlocind,edgelocweight,&
+         & verdistance, mate)
+#else
     call MatchBoxPC(nlver,nledge,verlocptr,verlocind,edgelocweight,&
          & verdistance, mate, mrank, mnp, icomm,&
          & msgindsent,msgactualsent,msgpercent,&
          & ph0_time, ph1_time, ph2_time, ph1_card, ph2_card)
+#endif
     verlocptr(:)   = verlocptr(:)  + 1
     verlocind(:)   = verlocind(:) + 1
     verdistance(:) = verdistance(:) + 1

amgprec/amg_d_mumps_solver.F90

@@ -52,10 +52,10 @@
 !
 module amg_d_mumps_solver
   use amg_d_base_solver_mod
-#if defined(HAVE_MUMPS_) && defined(HAVE_MUMPS_MODULES_)
+#if defined(AMG_HAVE_MUMPS) && defined(AMG_HAVE_MUMPS_MODULES)
   use dmumps_struc_def
 #endif
-#if defined(HAVE_MUMPS_) && defined(HAVE_MUMPS_INCLUDES_)
+#if defined(AMG_HAVE_MUMPS) && defined(AMG_HAVE_MUMPS_INCLUDES)
   include 'dmumps_struc.h'
 #endif  
   
@@ -68,7 +68,7 @@ module amg_d_mumps_solver
   end type amg_d_mumps_rcntl_item
 
   type, extends(amg_d_base_solver_type) :: amg_d_mumps_solver_type
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     type(dmumps_struc), allocatable  :: id
 #else
     integer, allocatable :: id
@@ -189,7 +189,7 @@ contains
 
     info = 0
 
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     
     call psb_erractionsave(err_act)
 
@@ -239,7 +239,7 @@ contains
     character(len=20)  :: name='d_mumps_solver_clear_data'
 
     info = 0
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     call psb_erractionsave(err_act)
     if (allocated(sv%id)) then      
       if (sv%built) then 
@@ -279,7 +279,7 @@ contains
     character(len=20)  :: name='d_mumps_solver_free'
 
     info = 0
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     call psb_erractionsave(err_act)
     call sv%clear_data(info)
     if ((info == 0).and.allocated(sv%icntl)) deallocate(sv%icntl,stat=info)
@@ -383,7 +383,7 @@ subroutine d_mumps_solver_csetc(sv,what,val,info,idx)
 
 
   select case(psb_toupper(trim(what)))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_LOC_GLOB')
     sv%ipar(1) = sv%stringval(psb_toupper(trim(val)))
 #endif
@@ -421,7 +421,7 @@ subroutine d_mumps_solver_cseti(sv,what,val,info,idx)
   call psb_erractionsave(err_act)
 
   select case(psb_toupper(what))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_LOC_GLOB')
     sv%ipar(1) = val
   case('MUMPS_PRINT_ERR')
@@ -467,7 +467,7 @@ subroutine d_mumps_solver_csetr(sv,what,val,info,idx)
   call psb_erractionsave(err_act)
 
   select case(psb_toupper(what))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_RPAR_ENTRY')
     if(present(idx)) then 
       ! Note: this will allocate %item
@@ -504,7 +504,7 @@ subroutine d_mumps_solver_default(sv)
   info = psb_success_
   call psb_erractionsave(err_act)
 
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   if (.not.allocated(sv%id)) then 
     allocate(sv%id,stat=info)
     if (info /= psb_success_) then
@@ -561,7 +561,7 @@ function d_mumps_solver_sizeof(sv) result(val)
   class(amg_d_mumps_solver_type), intent(in) :: sv
   integer(psb_epk_) :: val
   integer             :: i
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   val = (sv%id%INFOG(22)+sv%id%INFOG(32))*1d+6
 #else
   val = 0 

amgprec/amg_d_parmatch_aggregator_mod.F90

@@ -119,10 +119,6 @@
 module amg_d_parmatch_aggregator_mod
   use amg_d_base_aggregator_mod
   use amg_d_matchboxp_mod
-#if defined(SERIAL_MPI)
-  type, extends(amg_d_base_aggregator_type) :: amg_d_parmatch_aggregator_type
-  end type amg_d_parmatch_aggregator_type
-#else 
   type, extends(amg_d_base_aggregator_type) :: amg_d_parmatch_aggregator_type
     integer(psb_ipk_) :: matching_alg
     integer(psb_ipk_) :: n_sweeps   ! When n_sweeps >1 we need an auxiliary descriptor
@@ -244,11 +240,12 @@ module amg_d_parmatch_aggregator_mod
   end interface
 
   interface
-    subroutine amg_d_parmatch_unsmth_bld(ag,a,desc_a,ilaggr,nlaggr,parms,&
+    subroutine amg_d_parmatch_unsmth_bld(dol1smoothing,ag,a,desc_a,ilaggr,nlaggr,parms,&
          & ac,desc_ac,op_prol,op_restr,t_prol,info)
       import :: amg_d_parmatch_aggregator_type, psb_desc_type, psb_dspmat_type,&
            & psb_ldspmat_type, psb_dpk_, psb_ipk_, psb_lpk_, amg_dml_parms, amg_daggr_data
       implicit none
+      integer(psb_ipk_), intent(in) :: dol1smoothing
       class(amg_d_parmatch_aggregator_type), target, intent(inout) :: ag
       type(psb_dspmat_type), intent(in)       :: a
       type(psb_desc_type), intent(inout)      :: desc_a
@@ -262,11 +259,12 @@ module amg_d_parmatch_aggregator_mod
   end interface
 
   interface
-    subroutine amg_d_parmatch_smth_bld(ag,a,desc_a,ilaggr,nlaggr,parms,&
+    subroutine amg_d_parmatch_smth_bld(dol1smoothing,ag,a,desc_a,ilaggr,nlaggr,parms,&
          & ac,desc_ac,op_prol,op_restr,t_prol,info)
       import :: amg_d_parmatch_aggregator_type, psb_desc_type, psb_dspmat_type,&
            & psb_ldspmat_type, psb_dpk_, psb_ipk_, psb_lpk_, amg_dml_parms, amg_daggr_data
       implicit none
+      integer(psb_ipk_), intent(in) :: dol1smoothing
       class(amg_d_parmatch_aggregator_type), target, intent(inout) :: ag
       type(psb_dspmat_type), intent(in)       :: a
       type(psb_desc_type), intent(inout)      :: desc_a
@@ -398,6 +396,7 @@ contains
     integer(psb_ipk_), intent(out) :: info
     character(len=*), intent(in), optional  :: prefix
     character(1024)    :: prefix_
+    info = psb_success_
     if (present(prefix)) then
       prefix_ = prefix
     else
@@ -449,6 +448,7 @@ contains
     class(amg_d_base_aggregator_type), target, intent(inout) :: agnext
     integer(psb_ipk_), intent(out)       :: info
 
+    info = psb_success_
     !
     !
     select type(agnext)
@@ -588,7 +588,7 @@ contains
     class(amg_d_parmatch_aggregator_type), intent(inout) :: ag
     integer(psb_ipk_), intent(out)       :: info
 
-    info = 0
+    info = psb_success_
     if ((info == 0).and.allocated(ag%w)) deallocate(ag%w,stat=info)
     if ((info == 0).and.allocated(ag%w_nxt)) deallocate(ag%w_nxt,stat=info)
     if ((info == 0).and.allocated(ag%prol)) then
@@ -627,7 +627,7 @@ contains
     class(amg_d_base_aggregator_type), allocatable, intent(inout) :: agnext
     integer(psb_ipk_), intent(out)       :: info
 
-    info = 0
+    info = psb_success_
     if (allocated(agnext)) then
       call agnext%free(info)
       if (info == 0) deallocate(agnext,stat=info)
@@ -656,6 +656,7 @@ contains
     integer(psb_ipk_) :: err_act
     character(len=20) :: name='d_parmatch_aggregator_bld_map'
 
+    info = psb_success_
     call psb_erractionsave(err_act)
     !
     ! Copy the prolongation/restriction matrices into the descriptor map.
@@ -673,11 +674,6 @@ contains
       map = psb_linmap(psb_map_gen_linear_,desc_a,&
            & desc_ac,op_restr,op_prol,ilaggr,nlaggr)
     end if
-    if(info /= psb_success_) then
-      call psb_errpush(psb_err_from_subroutine_,name,a_err='sp_Free')
-      goto 9999
-    end if
-
     call psb_erractionrestore(err_act)
     return
 
@@ -685,5 +681,4 @@ contains
 
     return
   end subroutine amg_d_parmatch_aggregator_bld_map
-#endif
 end module amg_d_parmatch_aggregator_mod

amgprec/amg_d_poly_smoother.f90

@@ -192,8 +192,8 @@ module amg_d_poly_smoother
     subroutine amg_d_poly_smoother_clone_settings(sm,smout,info)
       import :: amg_d_poly_smoother_type, psb_dpk_, &
            & amg_d_base_smoother_type, psb_ipk_
-      class(amg_d_poly_smoother_type), intent(inout)               :: sm
-      class(amg_d_base_smoother_type), allocatable, intent(inout) :: smout
+      class(amg_d_poly_smoother_type), intent(inout) :: sm
+      class(amg_d_base_smoother_type), intent(inout) :: smout
       integer(psb_ipk_), intent(out)                :: info
     end subroutine amg_d_poly_smoother_clone_settings
   end interface
@@ -322,7 +322,7 @@ contains
     !
     sm%pdegree      = 1
     sm%rho_ba       = -done
-    sm%variant      = amg_poly_lottes_
+    sm%variant      = amg_cheb_4_
     sm%rho_estimate = amg_poly_rho_est_power_
     sm%rho_estimate_iterations = 20
     if (allocated(sm%sv)) then

amgprec/amg_d_prec_type.f90

@@ -113,6 +113,7 @@ module amg_d_prec_type
     procedure, pass(prec)               :: free           => amg_d_prec_free
     procedure, pass(prec)               :: allocate_wrk   => amg_d_allocate_wrk
     procedure, pass(prec)               :: free_wrk       => amg_d_free_wrk
+    procedure, pass(prec)               :: deallocate_wrk => amg_d_free_wrk
     procedure, pass(prec)               :: is_allocated_wrk => amg_d_is_allocated_wrk
     procedure, pass(prec)               :: get_complexity => amg_d_get_compl
     procedure, pass(prec)               :: cmp_complexity => amg_d_cmp_compl

amgprec/amg_d_slu_solver.F90

@@ -51,7 +51,7 @@ module amg_d_slu_solver
   use iso_c_binding
   use amg_d_base_solver_mod
 
-#if defined(IPK8)
+#if defined(PSB_IPK8)
 
   type, extends(amg_d_base_solver_type) :: amg_d_slu_solver_type
 

amgprec/amg_d_sludist_solver.F90

@@ -52,7 +52,7 @@ module amg_d_sludist_solver
   use iso_c_binding
   use amg_d_base_solver_mod
 
-#if (!defined(HAVE_SLUDIST_)) || defined(IPK8) 
+#if (!defined(AMG_HAVE_SLUDIST)) || defined(PSB_IPK8) 
 
   type, extends(amg_d_base_solver_type) :: amg_d_sludist_solver_type
 

amgprec/amg_d_symdec_aggregator_mod.f90

@@ -97,7 +97,7 @@ contains
     character(len=*), intent(in), optional  :: prefix
 
     character(1024)    :: prefix_
-
+    info = psb_success_
     if (present(prefix)) then
       prefix_ = prefix
     else

amgprec/amg_d_umf_solver.F90

@@ -51,7 +51,7 @@ module amg_d_umf_solver
   use iso_c_binding
   use amg_d_base_solver_mod
 
-#if defined(IPK8)
+#if defined(PSB_IPK8)
   type, extends(amg_d_base_solver_type) :: amg_d_umf_solver_type
 
   end type amg_d_umf_solver_type

amgprec/amg_s_ainv_solver.F90

@@ -62,9 +62,6 @@ module amg_s_ainv_solver
     procedure, pass(sv) :: cseti   => amg_s_ainv_solver_cseti
     procedure, pass(sv) :: csetc   => amg_s_ainv_solver_csetc
     procedure, pass(sv) :: csetr   => amg_s_ainv_solver_csetr
-!!$    procedure, pass(sv) :: seti    => amg_s_ainv_solver_seti
-!!$    procedure, pass(sv) :: setc    => amg_s_ainv_solver_setc
-!!$    procedure, pass(sv) :: setr    => amg_s_ainv_solver_setr
     procedure, pass(sv) :: descr   => amg_s_ainv_solver_descr
     procedure, pass(sv) :: default => s_ainv_solver_default
     procedure, nopass   :: stringval  => s_ainv_stringval
@@ -91,9 +88,9 @@ module amg_s_ainv_solver
       import :: psb_desc_type, psb_sspmat_type,  psb_s_base_sparse_mat, &
        & amg_s_base_solver_type, psb_dpk_, amg_s_ainv_solver_type, psb_ipk_
       Implicit None
-      class(amg_s_ainv_solver_type), intent(inout)              :: sv
-      class(amg_s_base_solver_type), allocatable, intent(inout) :: svout
-      integer(psb_ipk_), intent(out)                            :: info
+      class(amg_s_ainv_solver_type), intent(inout) :: sv
+      class(amg_s_base_solver_type), intent(inout) :: svout
+      integer(psb_ipk_), intent(out)                 :: info
     end subroutine amg_s_ainv_solver_clone_settings
   end interface
 

amgprec/amg_s_base_aggregator_mod.f90

@@ -302,7 +302,7 @@ contains
     integer(psb_ipk_), intent(out) :: info
 
     ! Do nothing
-    
+    info = psb_success_    
     return
   end subroutine amg_s_base_aggregator_set_aggr_type
 
@@ -486,6 +486,7 @@ contains
     integer(psb_ipk_) :: err_act
     character(len=20) :: name='s_base_aggregator_bld_map'
 
+    info = psb_success_
     call psb_erractionsave(err_act)
     !
     ! Copy the prolongation/restriction matrices into the descriptor map.

amgprec/amg_s_dec_aggregator_mod.f90

@@ -150,7 +150,7 @@ contains
     class(amg_s_dec_aggregator_type), intent(inout) :: ag
     type(amg_sml_parms), intent(in)   :: parms
     integer(psb_ipk_), intent(out) :: info
-
+    info = psb_success_
     select case(parms%aggr_type)
     case (amg_noalg_)
       ag%soc_map_bld => null()
@@ -192,6 +192,7 @@ contains
     integer(psb_ipk_), intent(out) :: info
     character(len=*), intent(in), optional  :: prefix
     character(1024)    :: prefix_
+    info = psb_success_
     if (present(prefix)) then
       prefix_ = prefix
     else

amgprec/amg_s_hybrid_aggregator_mod.F90

@@ -1,125 +0,0 @@
-!  
-!   
-!                             AMG4PSBLAS version 1.0
-!    Algebraic Multigrid Package
-!               based on PSBLAS (Parallel Sparse BLAS version 3.7)
-!    
-!    (C) Copyright 2020 
-!  
-!        Salvatore Filippone  
-!        Pasqua D'Ambra   
-!        Fabio Durastante        
-!   
-!    Redistribution and use in source and binary forms, with or without
-!    modification, are permitted provided that the following conditions
-!    are met:
-!      1. Redistributions of source code must retain the above copyright
-!         notice, this list of conditions and the following disclaimer.
-!      2. Redistributions in binary form must reproduce the above copyright
-!         notice, this list of conditions, and the following disclaimer in the
-!         documentation and/or other materials provided with the distribution.
-!      3. The name of the AMG4PSBLAS group or the names of its contributors may
-!         not be used to endorse or promote products derived from this
-!         software without specific written permission.
-!   
-!    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-!    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-!    TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-!    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AMG4PSBLAS GROUP OR ITS CONTRIBUTORS
-!    BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-!    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-!    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-!    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-!    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-!    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-!    POSSIBILITY OF SUCH DAMAGE.
-!   
-!  
-!
-!
-!  The aggregator object hosts the aggregation method for building
-!  the multilevel hierarchy. This variant is based on the hybrid method
-!  presented in 
-!
-!    S. Gratton, P. Henon, P. Jiranek and X. Vasseur:
-!    Reducing complexity of algebraic multigrid by aggregation
-!    Numerical Lin. Algebra with Applications, 2016, 23:501-518
-!    
-module amg_s_hybrid_aggregator_mod
-
-  use amg_s_dec_aggregator_mod
-  !
-  !   sm           -  class(amg_T_base_smoother_type), allocatable
-  !                   The current level preconditioner (aka smoother).
-  !   parms        -  type(amg_RTml_parms)
-  !                   The parameters defining the multilevel strategy.
-  !   ac           -  The local part of the current-level matrix, built by
-  !                   coarsening the previous-level matrix.
-  !   desc_ac      -  type(psb_desc_type).
-  !                   The communication descriptor associated to the matrix
-  !                   stored in ac.
-  !   base_a       -  type(psb_Tspmat_type), pointer.
-  !                   Pointer (really a pointer!) to the local part of the current 
-  !                   matrix (so we have a unified treatment of residuals).
-  !                   We need this to avoid passing explicitly the current matrix
-  !                   to the routine which applies the preconditioner.
-  !   base_desc    -  type(psb_desc_type), pointer.
-  !                   Pointer to the communication descriptor associated to the
-  !                   matrix pointed by base_a.
-  !   map          -  Stores the maps (restriction and prolongation) between the
-  !                   vector spaces associated to the index spaces of the previous
-  !                   and current levels.
-  !
-  !   Methods:  
-  !     Most methods follow the encapsulation hierarchy: they take whatever action
-  !     is appropriate for the current object, then call the corresponding method for
-  !     the contained object.
-  !     As an example: the descr() method prints out a description of the
-  !     level. It starts by invoking the descr() method of the parms object,
-  !     then calls the descr() method of the smoother object. 
-  !
-  !    descr      -   Prints a description of the object.
-  !    default    -   Set default values
-  !    dump       -   Dump to file object contents
-  !    set        -   Sets various parameters; when a request is unknown
-  !                   it is passed to the smoother object for further processing.
-  !    check      -   Sanity checks.
-  !    sizeof     -   Total memory occupation in bytes
-  !    get_nzeros -   Number of nonzeros 
-  !
-  !
-  type, extends(amg_s_dec_aggregator_type) :: amg_s_hybrid_aggregator_type
-    
-  contains
-    procedure, pass(ag) :: bld_tprol    => amg_s_hybrid_aggregator_build_tprol
-    procedure, nopass   :: fmt          => amg_s_hybrid_aggregator_fmt
-  end type amg_s_hybrid_aggregator_type
-
-
-  interface
-    subroutine  amg_s_hybrid_aggregator_build_tprol(ag,parms,a,desc_a,ilaggr,nlaggr,op_prol,info)
-      import :: amg_s_hybrid_aggregator_type, psb_desc_type, psb_sspmat_type, psb_spk_,  &
-           & psb_ipk_, psb_long_int_k_, amg_sml_parms
-      implicit none
-      class(amg_s_hybrid_aggregator_type), target, intent(inout) :: ag
-      type(amg_sml_parms), intent(inout)  :: parms 
-      type(psb_sspmat_type), intent(in)   :: a
-      type(psb_desc_type), intent(in)     :: desc_a
-      integer(psb_ipk_), allocatable, intent(out) :: ilaggr(:),nlaggr(:)
-      type(psb_sspmat_type), intent(out)  :: op_prol
-      integer(psb_ipk_), intent(out)      :: info
-    end subroutine amg_s_hybrid_aggregator_build_tprol
-  end interface
-
-contains
-
-
-  function amg_s_hybrid_aggregator_fmt() result(val)
-    implicit none 
-    character(len=32)  :: val
-
-    val = "Hybrid Decoupled aggregation"
-  end function amg_s_hybrid_aggregator_fmt
-
-  
-end module amg_s_hybrid_aggregator_mod

amgprec/amg_s_inner_mod.f90

@@ -109,11 +109,12 @@ module amg_s_inner_mod
   end interface amg_map_to_tprol
 
   abstract interface
-    subroutine amg_saggrmat_var_bld(a,desc_a,ilaggr,nlaggr,parms,&
+    subroutine amg_saggrmat_var_bld(dol1smoothing,a,desc_a,ilaggr,nlaggr,parms,&
          & ac,desc_ac,op_prol,op_restr,t_prol,info)
       import :: psb_sspmat_type, psb_desc_type, psb_spk_, psb_ipk_, psb_lpk_, psb_lsspmat_type
       import ::  amg_s_onelev_type, amg_sml_parms
       implicit none 
+      integer(psb_ipk_), intent(in)               :: dol1smoothing
       type(psb_sspmat_type), intent(in)         :: a
       type(psb_desc_type), intent(inout)          :: desc_a
       integer(psb_lpk_), intent(inout)            :: ilaggr(:), nlaggr(:)

amgprec/amg_s_invk_solver.f90

@@ -79,9 +79,9 @@ module amg_s_invk_solver
       import :: psb_desc_type, psb_sspmat_type,  psb_s_base_sparse_mat, &
        & amg_s_base_solver_type, psb_spk_, amg_s_invk_solver_type, psb_ipk_
       Implicit None
-      class(amg_s_invk_solver_type), intent(inout)              :: sv
-      class(amg_s_base_solver_type), allocatable, intent(inout) :: svout
-      integer(psb_ipk_), intent(out)                            :: info
+      class(amg_s_invk_solver_type), intent(inout) :: sv
+      class(amg_s_base_solver_type), intent(inout) :: svout
+      integer(psb_ipk_), intent(out)                 :: info
     end subroutine amg_s_invk_solver_clone_settings
   end interface
 

amgprec/amg_s_invt_solver.f90

@@ -79,9 +79,9 @@ module amg_s_invt_solver
       import :: psb_desc_type, psb_sspmat_type,  psb_s_base_sparse_mat, &
        & amg_s_base_solver_type, psb_spk_, amg_s_invt_solver_type, psb_ipk_
       Implicit None
-      class(amg_s_invt_solver_type), intent(inout)              :: sv
-      class(amg_s_base_solver_type), allocatable, intent(inout) :: svout
-      integer(psb_ipk_), intent(out)                            :: info
+      class(amg_s_invt_solver_type), intent(inout) :: sv
+      class(amg_s_base_solver_type), intent(inout) :: svout
+      integer(psb_ipk_), intent(out)                 :: info
     end subroutine amg_s_invt_solver_clone_settings
   end interface
 

amgprec/amg_s_jac_smoother.f90

@@ -203,8 +203,8 @@ module amg_s_jac_smoother
     subroutine amg_s_jac_smoother_clone_settings(sm,smout,info)
       import :: amg_s_jac_smoother_type, psb_spk_, &
            & amg_s_base_smoother_type, psb_ipk_
-      class(amg_s_jac_smoother_type), intent(inout)               :: sm
-      class(amg_s_base_smoother_type), allocatable, intent(inout) :: smout
+      class(amg_s_jac_smoother_type), intent(inout)  :: sm
+      class(amg_s_base_smoother_type), intent(inout) :: smout
       integer(psb_ipk_), intent(out)                :: info
     end subroutine amg_s_jac_smoother_clone_settings
   end interface

amgprec/amg_s_matchboxp_mod.F90

@@ -73,6 +73,22 @@ module amg_s_matchboxp_mod
   use iso_c_binding
   use psb_base_cbind_mod
 
+#if defined(PSB_SERIAL_MPI)
+  interface MatchingC
+    subroutine sMatchingC(nlver,nledge,verlocptr,verlocind,edgelocweight,&
+         & verdistance, mate) bind(c,name='sMatching')
+      use iso_c_binding
+      import :: psb_c_ipk_, psb_c_lpk_
+      implicit none
+
+      integer(psb_c_lpk_), value :: nlver,nledge
+      integer(psb_c_lpk_) :: verlocptr(*),verlocind(*), verdistance(*)
+      integer(psb_c_lpk_) :: mate(*)
+      real(c_float) :: edgelocweight(*)
+    end subroutine sMatchingC
+  end interface MatchingC
+
+#else
   interface MatchBoxPC
     subroutine sMatchBoxPC(nlver,nledge,verlocptr,verlocind,edgelocweight,&
          & verdistance, mate, myrank, numprocs, icomm,&
@@ -93,7 +109,7 @@ module amg_s_matchboxp_mod
       real(c_double)     :: msgpercent(*)
     end subroutine sMatchBoxPC
   end interface MatchBoxPC
-
+#endif
   interface amg_i_aggr_assign
     module procedure amg_i_s_aggr_assign
   end interface amg_i_aggr_assign
@@ -145,7 +161,7 @@ contains
     logical, parameter  :: dump=.false., debug=.false., dump_mate=.false., &
          & debug_ilaggr=.false., debug_sync=.false., debug_mate=.false.
     integer(psb_ipk_), save :: idx_bldmtc=-1, idx_phase1=-1, idx_phase2=-1, idx_phase3=-1
-    logical, parameter :: do_timings=.true.
+    logical, parameter :: do_timings=.false.
     integer, parameter :: ilaggr_neginit=-1, ilaggr_nonlocal=-2
 
     ictxt = desc_a%get_ctxt()
@@ -272,7 +288,9 @@ contains
           write(0,*) 'Impossible: mate(k) > nc'
           cycle
         else
+
           if (ilaggr(k) == ilaggr_neginit) then
+
             wk   = w(k)
             widx = w(idx)
             wmax = max(abs(wk),abs(widx))
@@ -606,7 +624,7 @@ contains
     logical, parameter :: old_style=.false., sort_minp=.true.
     character(len=40) :: name='build_matching', fname
     integer(psb_ipk_), save :: idx_cmboxp=-1, idx_bldahat=-1, idx_phase2=-1, idx_phase3=-1
-    logical, parameter :: do_timings=.true.
+    logical, parameter :: do_timings=.false.
 
     ictxt = desc_a%get_ctxt()
     call psb_info(ictxt,iam,np)
@@ -808,7 +826,7 @@ contains
     character(len=80) :: aname
     real(psb_spk_), parameter :: eps=epsilon(1.d0)
     integer(psb_ipk_), save   :: idx_glbt=-1, idx_phase1=-1, idx_phase2=-1
-    logical, parameter :: do_timings=.true.
+    logical, parameter :: do_timings=.false.
     logical, parameter :: debug_symmetry = .false., check_size=.false.
     logical, parameter :: unroll_logtrans=.false.
 
@@ -861,7 +879,7 @@ contains
     nr = tcoo1%get_nrows()
     nc = tcoo1%get_ncols()
     nz = tcoo1%get_nzeros()
-    call tcoo2%allocate(nr,nc,int(1.25*nz))
+    call tcoo2%allocate(nr,nc,int(1.25*nz,psb_ipk_))
     k2 = 0
     !
     ! Build the entries of \^A for matching
@@ -1038,7 +1056,8 @@ contains
     integer(psb_c_lpk_) :: ph1_card(*),ph2_card(*)
     real(c_float)  :: edgelocweight(:)
     real(c_double)      :: msgpercent(*)
-    integer(psb_ipk_)   :: info, me, np
+    integer(psb_ipk_)   :: info
+    integer(psb_mpk_)   :: me, np
     integer(psb_c_mpk_) :: icomm, mrank, mnp
     logical, optional   :: display_inp
     !
@@ -1127,11 +1146,15 @@ contains
       call psb_barrier(ictxt)
       if (me == 0) write(0,*)' Calling MatchBoxP '
     end if
-
+#if defined(PSB_SERIAL_MPI)
+    call MatchingC(nlver,nledge,verlocptr,verlocind,edgelocweight,&
+         & verdistance, mate)
+#else
     call MatchBoxPC(nlver,nledge,verlocptr,verlocind,edgelocweight,&
          & verdistance, mate, mrank, mnp, icomm,&
          & msgindsent,msgactualsent,msgpercent,&
          & ph0_time, ph1_time, ph2_time, ph1_card, ph2_card)
+#endif
     verlocptr(:)   = verlocptr(:)  + 1
     verlocind(:)   = verlocind(:) + 1
     verdistance(:) = verdistance(:) + 1

amgprec/amg_s_mumps_solver.F90

@@ -52,10 +52,10 @@
 !
 module amg_s_mumps_solver
   use amg_s_base_solver_mod
-#if defined(HAVE_MUMPS_) && defined(HAVE_MUMPS_MODULES_)
+#if defined(AMG_HAVE_MUMPS) && defined(AMG_HAVE_MUMPS_MODULES)
   use smumps_struc_def
 #endif
-#if defined(HAVE_MUMPS_) && defined(HAVE_MUMPS_INCLUDES_)
+#if defined(AMG_HAVE_MUMPS) && defined(AMG_HAVE_MUMPS_INCLUDES)
   include 'smumps_struc.h'
 #endif  
   
@@ -68,7 +68,7 @@ module amg_s_mumps_solver
   end type amg_s_mumps_rcntl_item
 
   type, extends(amg_s_base_solver_type) :: amg_s_mumps_solver_type
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     type(smumps_struc), allocatable  :: id
 #else
     integer, allocatable :: id
@@ -189,7 +189,7 @@ contains
 
     info = 0
 
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     
     call psb_erractionsave(err_act)
 
@@ -239,7 +239,7 @@ contains
     character(len=20)  :: name='s_mumps_solver_clear_data'
 
     info = 0
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     call psb_erractionsave(err_act)
     if (allocated(sv%id)) then      
       if (sv%built) then 
@@ -279,7 +279,7 @@ contains
     character(len=20)  :: name='s_mumps_solver_free'
 
     info = 0
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     call psb_erractionsave(err_act)
     call sv%clear_data(info)
     if ((info == 0).and.allocated(sv%icntl)) deallocate(sv%icntl,stat=info)
@@ -383,7 +383,7 @@ subroutine s_mumps_solver_csetc(sv,what,val,info,idx)
 
 
   select case(psb_toupper(trim(what)))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_LOC_GLOB')
     sv%ipar(1) = sv%stringval(psb_toupper(trim(val)))
 #endif
@@ -421,7 +421,7 @@ subroutine s_mumps_solver_cseti(sv,what,val,info,idx)
   call psb_erractionsave(err_act)
 
   select case(psb_toupper(what))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_LOC_GLOB')
     sv%ipar(1) = val
   case('MUMPS_PRINT_ERR')
@@ -467,7 +467,7 @@ subroutine s_mumps_solver_csetr(sv,what,val,info,idx)
   call psb_erractionsave(err_act)
 
   select case(psb_toupper(what))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_RPAR_ENTRY')
     if(present(idx)) then 
       ! Note: this will allocate %item
@@ -504,7 +504,7 @@ subroutine s_mumps_solver_default(sv)
   info = psb_success_
   call psb_erractionsave(err_act)
 
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   if (.not.allocated(sv%id)) then 
     allocate(sv%id,stat=info)
     if (info /= psb_success_) then
@@ -561,7 +561,7 @@ function s_mumps_solver_sizeof(sv) result(val)
   class(amg_s_mumps_solver_type), intent(in) :: sv
   integer(psb_epk_) :: val
   integer             :: i
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   val = (sv%id%INFOG(22)+sv%id%INFOG(32))*1d+6
 #else
   val = 0 

amgprec/amg_s_parmatch_aggregator_mod.F90

@@ -119,10 +119,6 @@
 module amg_s_parmatch_aggregator_mod
   use amg_s_base_aggregator_mod
   use amg_s_matchboxp_mod
-#if defined(SERIAL_MPI)
-  type, extends(amg_s_base_aggregator_type) :: amg_s_parmatch_aggregator_type
-  end type amg_s_parmatch_aggregator_type
-#else 
   type, extends(amg_s_base_aggregator_type) :: amg_s_parmatch_aggregator_type
     integer(psb_ipk_) :: matching_alg
     integer(psb_ipk_) :: n_sweeps   ! When n_sweeps >1 we need an auxiliary descriptor
@@ -244,11 +240,12 @@ module amg_s_parmatch_aggregator_mod
   end interface
 
   interface
-    subroutine amg_s_parmatch_unsmth_bld(ag,a,desc_a,ilaggr,nlaggr,parms,&
+    subroutine amg_s_parmatch_unsmth_bld(dol1smoothing,ag,a,desc_a,ilaggr,nlaggr,parms,&
          & ac,desc_ac,op_prol,op_restr,t_prol,info)
       import :: amg_s_parmatch_aggregator_type, psb_desc_type, psb_sspmat_type,&
            & psb_lsspmat_type, psb_dpk_, psb_ipk_, psb_lpk_, amg_sml_parms, amg_saggr_data
       implicit none
+      integer(psb_ipk_), intent(in) :: dol1smoothing
       class(amg_s_parmatch_aggregator_type), target, intent(inout) :: ag
       type(psb_sspmat_type), intent(in)       :: a
       type(psb_desc_type), intent(inout)      :: desc_a
@@ -262,11 +259,12 @@ module amg_s_parmatch_aggregator_mod
   end interface
 
   interface
-    subroutine amg_s_parmatch_smth_bld(ag,a,desc_a,ilaggr,nlaggr,parms,&
+    subroutine amg_s_parmatch_smth_bld(dol1smoothing,ag,a,desc_a,ilaggr,nlaggr,parms,&
          & ac,desc_ac,op_prol,op_restr,t_prol,info)
       import :: amg_s_parmatch_aggregator_type, psb_desc_type, psb_sspmat_type,&
            & psb_lsspmat_type, psb_dpk_, psb_ipk_, psb_lpk_, amg_sml_parms, amg_saggr_data
       implicit none
+      integer(psb_ipk_), intent(in) :: dol1smoothing
       class(amg_s_parmatch_aggregator_type), target, intent(inout) :: ag
       type(psb_sspmat_type), intent(in)       :: a
       type(psb_desc_type), intent(inout)      :: desc_a
@@ -398,6 +396,7 @@ contains
     integer(psb_ipk_), intent(out) :: info
     character(len=*), intent(in), optional  :: prefix
     character(1024)    :: prefix_
+    info = psb_success_
     if (present(prefix)) then
       prefix_ = prefix
     else
@@ -449,6 +448,7 @@ contains
     class(amg_s_base_aggregator_type), target, intent(inout) :: agnext
     integer(psb_ipk_), intent(out)       :: info
 
+    info = psb_success_
     !
     !
     select type(agnext)
@@ -588,7 +588,7 @@ contains
     class(amg_s_parmatch_aggregator_type), intent(inout) :: ag
     integer(psb_ipk_), intent(out)       :: info
 
-    info = 0
+    info = psb_success_
     if ((info == 0).and.allocated(ag%w)) deallocate(ag%w,stat=info)
     if ((info == 0).and.allocated(ag%w_nxt)) deallocate(ag%w_nxt,stat=info)
     if ((info == 0).and.allocated(ag%prol)) then
@@ -627,7 +627,7 @@ contains
     class(amg_s_base_aggregator_type), allocatable, intent(inout) :: agnext
     integer(psb_ipk_), intent(out)       :: info
 
-    info = 0
+    info = psb_success_
     if (allocated(agnext)) then
       call agnext%free(info)
       if (info == 0) deallocate(agnext,stat=info)
@@ -656,6 +656,7 @@ contains
     integer(psb_ipk_) :: err_act
     character(len=20) :: name='s_parmatch_aggregator_bld_map'
 
+    info = psb_success_
     call psb_erractionsave(err_act)
     !
     ! Copy the prolongation/restriction matrices into the descriptor map.
@@ -673,11 +674,6 @@ contains
       map = psb_linmap(psb_map_gen_linear_,desc_a,&
            & desc_ac,op_restr,op_prol,ilaggr,nlaggr)
     end if
-    if(info /= psb_success_) then
-      call psb_errpush(psb_err_from_subroutine_,name,a_err='sp_Free')
-      goto 9999
-    end if
-
     call psb_erractionrestore(err_act)
     return
 
@@ -685,5 +681,4 @@ contains
 
     return
   end subroutine amg_s_parmatch_aggregator_bld_map
-#endif
 end module amg_s_parmatch_aggregator_mod

amgprec/amg_s_poly_smoother.f90

@@ -192,8 +192,8 @@ module amg_s_poly_smoother
     subroutine amg_s_poly_smoother_clone_settings(sm,smout,info)
       import :: amg_s_poly_smoother_type, psb_spk_, &
            & amg_s_base_smoother_type, psb_ipk_
-      class(amg_s_poly_smoother_type), intent(inout)               :: sm
-      class(amg_s_base_smoother_type), allocatable, intent(inout) :: smout
+      class(amg_s_poly_smoother_type), intent(inout) :: sm
+      class(amg_s_base_smoother_type), intent(inout) :: smout
       integer(psb_ipk_), intent(out)                :: info
     end subroutine amg_s_poly_smoother_clone_settings
   end interface
@@ -322,7 +322,7 @@ contains
     !
     sm%pdegree      = 1
     sm%rho_ba       = -sone
-    sm%variant      = amg_poly_lottes_
+    sm%variant      = amg_cheb_4_
     sm%rho_estimate = amg_poly_rho_est_power_
     sm%rho_estimate_iterations = 20
     if (allocated(sm%sv)) then

amgprec/amg_s_prec_type.f90

@@ -113,6 +113,7 @@ module amg_s_prec_type
     procedure, pass(prec)               :: free           => amg_s_prec_free
     procedure, pass(prec)               :: allocate_wrk   => amg_s_allocate_wrk
     procedure, pass(prec)               :: free_wrk       => amg_s_free_wrk
+    procedure, pass(prec)               :: deallocate_wrk => amg_s_free_wrk
     procedure, pass(prec)               :: is_allocated_wrk => amg_s_is_allocated_wrk
     procedure, pass(prec)               :: get_complexity => amg_s_get_compl
     procedure, pass(prec)               :: cmp_complexity => amg_s_cmp_compl

amgprec/amg_s_slu_solver.F90

@@ -51,7 +51,7 @@ module amg_s_slu_solver
   use iso_c_binding
   use amg_s_base_solver_mod
 
-#if defined(IPK8)
+#if defined(PSB_IPK8)
 
   type, extends(amg_s_base_solver_type) :: amg_s_slu_solver_type
 

amgprec/amg_s_symdec_aggregator_mod.f90

@@ -97,7 +97,7 @@ contains
     character(len=*), intent(in), optional  :: prefix
 
     character(1024)    :: prefix_
-
+    info = psb_success_
     if (present(prefix)) then
       prefix_ = prefix
     else

amgprec/amg_z_ainv_solver.F90

@@ -62,9 +62,6 @@ module amg_z_ainv_solver
     procedure, pass(sv) :: cseti   => amg_z_ainv_solver_cseti
     procedure, pass(sv) :: csetc   => amg_z_ainv_solver_csetc
     procedure, pass(sv) :: csetr   => amg_z_ainv_solver_csetr
-!!$    procedure, pass(sv) :: seti    => amg_z_ainv_solver_seti
-!!$    procedure, pass(sv) :: setc    => amg_z_ainv_solver_setc
-!!$    procedure, pass(sv) :: setr    => amg_z_ainv_solver_setr
     procedure, pass(sv) :: descr   => amg_z_ainv_solver_descr
     procedure, pass(sv) :: default => z_ainv_solver_default
     procedure, nopass   :: stringval  => z_ainv_stringval
@@ -91,9 +88,9 @@ module amg_z_ainv_solver
       import :: psb_desc_type, psb_zspmat_type,  psb_z_base_sparse_mat, &
        & amg_z_base_solver_type, psb_dpk_, amg_z_ainv_solver_type, psb_ipk_
       Implicit None
-      class(amg_z_ainv_solver_type), intent(inout)              :: sv
-      class(amg_z_base_solver_type), allocatable, intent(inout) :: svout
-      integer(psb_ipk_), intent(out)                            :: info
+      class(amg_z_ainv_solver_type), intent(inout) :: sv
+      class(amg_z_base_solver_type), intent(inout) :: svout
+      integer(psb_ipk_), intent(out)                 :: info
     end subroutine amg_z_ainv_solver_clone_settings
   end interface
 

amgprec/amg_z_base_aggregator_mod.f90

@@ -302,7 +302,7 @@ contains
     integer(psb_ipk_), intent(out) :: info
 
     ! Do nothing
-    
+    info = psb_success_    
     return
   end subroutine amg_z_base_aggregator_set_aggr_type
 
@@ -486,6 +486,7 @@ contains
     integer(psb_ipk_) :: err_act
     character(len=20) :: name='z_base_aggregator_bld_map'
 
+    info = psb_success_
     call psb_erractionsave(err_act)
     !
     ! Copy the prolongation/restriction matrices into the descriptor map.

amgprec/amg_z_dec_aggregator_mod.f90

@@ -150,7 +150,7 @@ contains
     class(amg_z_dec_aggregator_type), intent(inout) :: ag
     type(amg_dml_parms), intent(in)   :: parms
     integer(psb_ipk_), intent(out) :: info
-
+    info = psb_success_
     select case(parms%aggr_type)
     case (amg_noalg_)
       ag%soc_map_bld => null()
@@ -192,6 +192,7 @@ contains
     integer(psb_ipk_), intent(out) :: info
     character(len=*), intent(in), optional  :: prefix
     character(1024)    :: prefix_
+    info = psb_success_
     if (present(prefix)) then
       prefix_ = prefix
     else

amgprec/amg_z_hybrid_aggregator_mod.F90

@@ -1,125 +0,0 @@
-!  
-!   
-!                             AMG4PSBLAS version 1.0
-!    Algebraic Multigrid Package
-!               based on PSBLAS (Parallel Sparse BLAS version 3.7)
-!    
-!    (C) Copyright 2020 
-!  
-!        Salvatore Filippone  
-!        Pasqua D'Ambra   
-!        Fabio Durastante        
-!   
-!    Redistribution and use in source and binary forms, with or without
-!    modification, are permitted provided that the following conditions
-!    are met:
-!      1. Redistributions of source code must retain the above copyright
-!         notice, this list of conditions and the following disclaimer.
-!      2. Redistributions in binary form must reproduce the above copyright
-!         notice, this list of conditions, and the following disclaimer in the
-!         documentation and/or other materials provided with the distribution.
-!      3. The name of the AMG4PSBLAS group or the names of its contributors may
-!         not be used to endorse or promote products derived from this
-!         software without specific written permission.
-!   
-!    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-!    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-!    TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-!    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AMG4PSBLAS GROUP OR ITS CONTRIBUTORS
-!    BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-!    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-!    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-!    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-!    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-!    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-!    POSSIBILITY OF SUCH DAMAGE.
-!   
-!  
-!
-!
-!  The aggregator object hosts the aggregation method for building
-!  the multilevel hierarchy. This variant is based on the hybrid method
-!  presented in 
-!
-!    S. Gratton, P. Henon, P. Jiranek and X. Vasseur:
-!    Reducing complexity of algebraic multigrid by aggregation
-!    Numerical Lin. Algebra with Applications, 2016, 23:501-518
-!    
-module amg_z_hybrid_aggregator_mod
-
-  use amg_z_dec_aggregator_mod
-  !
-  !   sm           -  class(amg_T_base_smoother_type), allocatable
-  !                   The current level preconditioner (aka smoother).
-  !   parms        -  type(amg_RTml_parms)
-  !                   The parameters defining the multilevel strategy.
-  !   ac           -  The local part of the current-level matrix, built by
-  !                   coarsening the previous-level matrix.
-  !   desc_ac      -  type(psb_desc_type).
-  !                   The communication descriptor associated to the matrix
-  !                   stored in ac.
-  !   base_a       -  type(psb_Tspmat_type), pointer.
-  !                   Pointer (really a pointer!) to the local part of the current 
-  !                   matrix (so we have a unified treatment of residuals).
-  !                   We need this to avoid passing explicitly the current matrix
-  !                   to the routine which applies the preconditioner.
-  !   base_desc    -  type(psb_desc_type), pointer.
-  !                   Pointer to the communication descriptor associated to the
-  !                   matrix pointed by base_a.
-  !   map          -  Stores the maps (restriction and prolongation) between the
-  !                   vector spaces associated to the index spaces of the previous
-  !                   and current levels.
-  !
-  !   Methods:  
-  !     Most methods follow the encapsulation hierarchy: they take whatever action
-  !     is appropriate for the current object, then call the corresponding method for
-  !     the contained object.
-  !     As an example: the descr() method prints out a description of the
-  !     level. It starts by invoking the descr() method of the parms object,
-  !     then calls the descr() method of the smoother object. 
-  !
-  !    descr      -   Prints a description of the object.
-  !    default    -   Set default values
-  !    dump       -   Dump to file object contents
-  !    set        -   Sets various parameters; when a request is unknown
-  !                   it is passed to the smoother object for further processing.
-  !    check      -   Sanity checks.
-  !    sizeof     -   Total memory occupation in bytes
-  !    get_nzeros -   Number of nonzeros 
-  !
-  !
-  type, extends(amg_z_dec_aggregator_type) :: amg_z_hybrid_aggregator_type
-    
-  contains
-    procedure, pass(ag) :: bld_tprol    => amg_z_hybrid_aggregator_build_tprol
-    procedure, nopass   :: fmt          => amg_z_hybrid_aggregator_fmt
-  end type amg_z_hybrid_aggregator_type
-
-
-  interface
-    subroutine  amg_z_hybrid_aggregator_build_tprol(ag,parms,a,desc_a,ilaggr,nlaggr,op_prol,info)
-      import :: amg_z_hybrid_aggregator_type, psb_desc_type, psb_zspmat_type, psb_dpk_,  &
-           & psb_ipk_, psb_long_int_k_, amg_dml_parms
-      implicit none
-      class(amg_z_hybrid_aggregator_type), target, intent(inout) :: ag
-      type(amg_dml_parms), intent(inout)  :: parms 
-      type(psb_zspmat_type), intent(in)   :: a
-      type(psb_desc_type), intent(in)     :: desc_a
-      integer(psb_ipk_), allocatable, intent(out) :: ilaggr(:),nlaggr(:)
-      type(psb_zspmat_type), intent(out)  :: op_prol
-      integer(psb_ipk_), intent(out)      :: info
-    end subroutine amg_z_hybrid_aggregator_build_tprol
-  end interface
-
-contains
-
-
-  function amg_z_hybrid_aggregator_fmt() result(val)
-    implicit none 
-    character(len=32)  :: val
-
-    val = "Hybrid Decoupled aggregation"
-  end function amg_z_hybrid_aggregator_fmt
-
-  
-end module amg_z_hybrid_aggregator_mod

amgprec/amg_z_inner_mod.f90

@@ -109,11 +109,12 @@ module amg_z_inner_mod
   end interface amg_map_to_tprol
 
   abstract interface
-    subroutine amg_zaggrmat_var_bld(a,desc_a,ilaggr,nlaggr,parms,&
+    subroutine amg_zaggrmat_var_bld(dol1smoothing,a,desc_a,ilaggr,nlaggr,parms,&
          & ac,desc_ac,op_prol,op_restr,t_prol,info)
       import :: psb_zspmat_type, psb_desc_type, psb_dpk_, psb_ipk_, psb_lpk_, psb_lzspmat_type
       import ::  amg_z_onelev_type, amg_dml_parms
       implicit none 
+      integer(psb_ipk_), intent(in)               :: dol1smoothing
       type(psb_zspmat_type), intent(in)         :: a
       type(psb_desc_type), intent(inout)          :: desc_a
       integer(psb_lpk_), intent(inout)            :: ilaggr(:), nlaggr(:)

amgprec/amg_z_invk_solver.f90

@@ -79,9 +79,9 @@ module amg_z_invk_solver
       import :: psb_desc_type, psb_zspmat_type,  psb_z_base_sparse_mat, &
        & amg_z_base_solver_type, psb_dpk_, amg_z_invk_solver_type, psb_ipk_
       Implicit None
-      class(amg_z_invk_solver_type), intent(inout)              :: sv
-      class(amg_z_base_solver_type), allocatable, intent(inout) :: svout
-      integer(psb_ipk_), intent(out)                            :: info
+      class(amg_z_invk_solver_type), intent(inout) :: sv
+      class(amg_z_base_solver_type), intent(inout) :: svout
+      integer(psb_ipk_), intent(out)                 :: info
     end subroutine amg_z_invk_solver_clone_settings
   end interface
 

amgprec/amg_z_invt_solver.f90

@@ -79,9 +79,9 @@ module amg_z_invt_solver
       import :: psb_desc_type, psb_zspmat_type,  psb_z_base_sparse_mat, &
        & amg_z_base_solver_type, psb_dpk_, amg_z_invt_solver_type, psb_ipk_
       Implicit None
-      class(amg_z_invt_solver_type), intent(inout)              :: sv
-      class(amg_z_base_solver_type), allocatable, intent(inout) :: svout
-      integer(psb_ipk_), intent(out)                            :: info
+      class(amg_z_invt_solver_type), intent(inout) :: sv
+      class(amg_z_base_solver_type), intent(inout) :: svout
+      integer(psb_ipk_), intent(out)                 :: info
     end subroutine amg_z_invt_solver_clone_settings
   end interface
 

amgprec/amg_z_jac_smoother.f90

@@ -203,8 +203,8 @@ module amg_z_jac_smoother
     subroutine amg_z_jac_smoother_clone_settings(sm,smout,info)
       import :: amg_z_jac_smoother_type, psb_dpk_, &
            & amg_z_base_smoother_type, psb_ipk_
-      class(amg_z_jac_smoother_type), intent(inout)               :: sm
-      class(amg_z_base_smoother_type), allocatable, intent(inout) :: smout
+      class(amg_z_jac_smoother_type), intent(inout)  :: sm
+      class(amg_z_base_smoother_type), intent(inout) :: smout
       integer(psb_ipk_), intent(out)                :: info
     end subroutine amg_z_jac_smoother_clone_settings
   end interface

amgprec/amg_z_mumps_solver.F90

@@ -52,10 +52,10 @@
 !
 module amg_z_mumps_solver
   use amg_z_base_solver_mod
-#if defined(HAVE_MUMPS_) && defined(HAVE_MUMPS_MODULES_)
+#if defined(AMG_HAVE_MUMPS) && defined(AMG_HAVE_MUMPS_MODULES)
   use zmumps_struc_def
 #endif
-#if defined(HAVE_MUMPS_) && defined(HAVE_MUMPS_INCLUDES_)
+#if defined(AMG_HAVE_MUMPS) && defined(AMG_HAVE_MUMPS_INCLUDES)
   include 'zmumps_struc.h'
 #endif  
   
@@ -68,7 +68,7 @@ module amg_z_mumps_solver
   end type amg_z_mumps_rcntl_item
 
   type, extends(amg_z_base_solver_type) :: amg_z_mumps_solver_type
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     type(zmumps_struc), allocatable  :: id
 #else
     integer, allocatable :: id
@@ -189,7 +189,7 @@ contains
 
     info = 0
 
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     
     call psb_erractionsave(err_act)
 
@@ -239,7 +239,7 @@ contains
     character(len=20)  :: name='z_mumps_solver_clear_data'
 
     info = 0
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     call psb_erractionsave(err_act)
     if (allocated(sv%id)) then      
       if (sv%built) then 
@@ -279,7 +279,7 @@ contains
     character(len=20)  :: name='z_mumps_solver_free'
 
     info = 0
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
     call psb_erractionsave(err_act)
     call sv%clear_data(info)
     if ((info == 0).and.allocated(sv%icntl)) deallocate(sv%icntl,stat=info)
@@ -383,7 +383,7 @@ subroutine z_mumps_solver_csetc(sv,what,val,info,idx)
 
 
   select case(psb_toupper(trim(what)))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_LOC_GLOB')
     sv%ipar(1) = sv%stringval(psb_toupper(trim(val)))
 #endif
@@ -421,7 +421,7 @@ subroutine z_mumps_solver_cseti(sv,what,val,info,idx)
   call psb_erractionsave(err_act)
 
   select case(psb_toupper(what))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_LOC_GLOB')
     sv%ipar(1) = val
   case('MUMPS_PRINT_ERR')
@@ -467,7 +467,7 @@ subroutine z_mumps_solver_csetr(sv,what,val,info,idx)
   call psb_erractionsave(err_act)
 
   select case(psb_toupper(what))
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   case('MUMPS_RPAR_ENTRY')
     if(present(idx)) then 
       ! Note: this will allocate %item
@@ -504,7 +504,7 @@ subroutine z_mumps_solver_default(sv)
   info = psb_success_
   call psb_erractionsave(err_act)
 
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   if (.not.allocated(sv%id)) then 
     allocate(sv%id,stat=info)
     if (info /= psb_success_) then
@@ -561,7 +561,7 @@ function z_mumps_solver_sizeof(sv) result(val)
   class(amg_z_mumps_solver_type), intent(in) :: sv
   integer(psb_epk_) :: val
   integer             :: i
-#if defined(HAVE_MUMPS_)
+#if defined(AMG_HAVE_MUMPS)
   val = (sv%id%INFOG(22)+sv%id%INFOG(32))*1d+6
 #else
   val = 0 

amgprec/amg_z_prec_type.f90

@@ -113,6 +113,7 @@ module amg_z_prec_type
     procedure, pass(prec)               :: free           => amg_z_prec_free
     procedure, pass(prec)               :: allocate_wrk   => amg_z_allocate_wrk
     procedure, pass(prec)               :: free_wrk       => amg_z_free_wrk
+    procedure, pass(prec)               :: deallocate_wrk => amg_z_free_wrk
     procedure, pass(prec)               :: is_allocated_wrk => amg_z_is_allocated_wrk
     procedure, pass(prec)               :: get_complexity => amg_z_get_compl
     procedure, pass(prec)               :: cmp_complexity => amg_z_cmp_compl

amgprec/amg_z_slu_solver.F90

@@ -51,7 +51,7 @@ module amg_z_slu_solver
   use iso_c_binding
   use amg_z_base_solver_mod
 
-#if defined(IPK8)
+#if defined(PSB_IPK8)
 
   type, extends(amg_z_base_solver_type) :: amg_z_slu_solver_type
 

amgprec/amg_z_sludist_solver.F90

@@ -52,7 +52,7 @@ module amg_z_sludist_solver
   use iso_c_binding
   use amg_z_base_solver_mod
 
-#if (!defined(HAVE_SLUDIST_)) || defined(IPK8) 
+#if (!defined(AMG_HAVE_SLUDIST)) || defined(PSB_IPK8) 
 
   type, extends(amg_z_base_solver_type) :: amg_z_sludist_solver_type
 

amgprec/amg_z_symdec_aggregator_mod.f90

@@ -97,7 +97,7 @@ contains
     character(len=*), intent(in), optional  :: prefix
 
     character(1024)    :: prefix_
-
+    info = psb_success_
     if (present(prefix)) then
       prefix_ = prefix
     else

amgprec/amg_z_umf_solver.F90

@@ -51,7 +51,7 @@ module amg_z_umf_solver
   use iso_c_binding
   use amg_z_base_solver_mod
 
-#if defined(IPK8)
+#if defined(PSB_IPK8)
   type, extends(amg_z_base_solver_type) :: amg_z_umf_solver_type
 
   end type amg_z_umf_solver_type

amgprec/impl/Makefile

@@ -5,6 +5,7 @@ MODDIR=../../modules
 HERE=..
 
 FINCLUDES=$(FMFLAG)$(HERE) $(FMFLAG)$(MODDIR) $(FMFLAG)$(INCDIR) $(PSBLAS_INCLUDES)
+CINCLUDES=-I. -I.. -I$(PSBLAS_INCDIR)
 
 
 

amgprec/impl/aggregator/Makefile

@@ -5,7 +5,8 @@ MODDIR=../../../modules
 HERE=../..
 
 FINCLUDES=$(FMFLAG)$(HERE) $(FMFLAG)$(MODDIR) $(FMFLAG)$(INCDIR) $(PSBLAS_INCLUDES)
-CXXINCLUDES=$(FMFLAG)$(HERE) $(FMFLAG)$(INCDIR) $(FMFLAG)/.
+CXXINCLUDES=$(FMFLAG)$(HERE) $(FMFLAG)$(INCDIR) $(FMFLAG)/. -I$(PSBLAS_INCDIR)
+CINCLUDES=$(FMFLAG)$(HERE) $(FMFLAG)$(INCDIR) $(FMFLAG)/. -I$(PSBLAS_INCDIR)
 
 #CINCLUDES= -I${SUPERLU_INCDIR} -I${HSL_INCDIR}  -I${SPRAL_INCDIR} -I/home/users/pasqua/Ambra/BootCMatch/include -lBCM -L/home/users/pasqua/Ambra/BootCMatch/lib  -lm
 
@@ -61,7 +62,8 @@ amg_s_parmatch_unsmth_bld.o \
 amg_s_parmatch_smth_bld.o \
 amg_s_parmatch_spmm_bld_inner.o
 
-MPCOBJS=MatchBoxPC.o \
+MPCOBJS=Matching.o \
+MatchBoxPC.o \
 sendBundledMessages.o \
 initialize.o \
 extractUChunk.o \

amgprec/impl/aggregator/MatchBoxPC.cpp

@@ -40,15 +40,17 @@
 // ************************************************************************
 #include <stdio.h>
 #include <stdlib.h>
-#if !defined(SERIAL_MPI)
+#include "amg_config.h"
+#include "MatchBoxPC.h"
+#if !defined(PSB_SERIAL_MPI)
 #include <mpi.h>
 #endif
 
-#include "MatchBoxPC.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+#if !defined(PSB_SERIAL_MPI)
 
 void dMatchBoxPC(MilanLongInt NLVer, MilanLongInt NLEdge,
 		MilanLongInt* verLocPtr, MilanLongInt* verLocInd, MilanReal* edgeLocWeight,
@@ -58,7 +60,6 @@ void dMatchBoxPC(MilanLongInt NLVer, MilanLongInt NLEdge,
 		MilanLongInt* msgIndSent, MilanLongInt* msgActualSent, MilanReal* msgPercent,
 		MilanReal* ph0_time, MilanReal* ph1_time, MilanReal* ph2_time,
 		MilanLongInt* ph1_card, MilanLongInt* ph2_card ) {
-#if !defined(SERIAL_MPI)
   MPI_Comm C_comm=MPI_Comm_f2c(icomm);
 
 #ifdef DEBUG
@@ -72,7 +73,7 @@ void dMatchBoxPC(MilanLongInt NLVer, MilanLongInt NLEdge,
   double tmr = MPI_Wtime();
 #endif
 
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
 	//fprintf(stderr,"Warning: using buggy OpenMP matching!\n");
         dalgoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateCMP(NLVer, NLEdge,
 							   verLocPtr, verLocInd, edgeLocWeight,
@@ -97,7 +98,6 @@ void dMatchBoxPC(MilanLongInt NLVer, MilanLongInt NLEdge,
 	fprintf(stderr, "Elaboration time: %f for %ld nodes\n", tmr, NLVer);
 #endif
 	
-#endif
 }
 
 void sMatchBoxPC(MilanLongInt NLVer, MilanLongInt NLEdge,
@@ -108,13 +108,12 @@ void sMatchBoxPC(MilanLongInt NLVer, MilanLongInt NLEdge,
 		MilanLongInt* msgIndSent, MilanLongInt* msgActualSent, MilanReal* msgPercent,
 		MilanReal* ph0_time, MilanReal* ph1_time, MilanReal* ph2_time,
 		MilanLongInt* ph1_card, MilanLongInt* ph2_card ) {
-#if !defined(SERIAL_MPI)
   MPI_Comm C_comm=MPI_Comm_f2c(icomm);
 #ifdef DEBUG
   fprintf(stderr,"MatchBoxPC: rank %d nlver %ld nledge %ld [ %ld %ld ]\n",
 	  myRank,NLVer, NLEdge,verDistance[0],verDistance[1]);
 #endif
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
 	//fprintf(stderr,"Warning: using buggy OpenMP matching!\n");
   salgoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateCMP(NLVer, NLEdge,
 							      verLocPtr, verLocInd, edgeLocWeight,
@@ -132,9 +131,10 @@ void sMatchBoxPC(MilanLongInt NLVer, MilanLongInt NLEdge,
 							    ph0_time, ph1_time, ph2_time,
 							    ph1_card, ph2_card );
 #endif
-#endif
 }
 
+#endif
+  
 #ifdef __cplusplus
 }
 #endif

amgprec/impl/aggregator/MatchBoxPC.h

@@ -59,7 +59,10 @@
 #include <assert.h>
 #include <map>
 #include <vector>
-#ifdef OPENMP
+#include "amg_config.h"
+#if !defined(PSB_SERIAL_MPI)
+
+#ifdef PSB_OPENMP
 // OpenMP is included and used if and only if the OpenMP version of the matching
 // is required
 #include "omp.h"
@@ -82,6 +85,7 @@ const int BundleTag = 9;  // Predefined tag
 
 static vector<MilanLongInt> DEFAULT_VECTOR;
 
+
 // MPI type map
 template <typename T>
 MPI_Datatype TypeMap();
@@ -99,7 +103,6 @@ extern "C"
 {
 #endif
 
-#if !defined(SERIAL_MPI)
 
 #define MilanMpiLongInt MPI_LONG_LONG
 
@@ -114,7 +117,7 @@ extern "C"
 // Regular long integer:
 #ifndef LONG_INT_H
 #define LONG_INT_H
-#ifdef BIT64
+#ifdef AMG_MATCHBOXP_BIT64
     typedef int64_t MilanLongInt;
     typedef MPI_LONG MilanMpiLongInt;
 #else
@@ -160,7 +163,7 @@ extern "C"
 #define MilanIntMax INT32_MAX
 #define MilanIntMin INT32_MIN
 
-#ifdef BIT64
+#ifdef AMG_MATCHBOXP_BIT64
 #define MilanLongIntMax INT64_MAX
 #define MilanLongIntMin -INT64_MAX
 #else
@@ -627,8 +630,9 @@ is disabled there is no reason to actually compile or reference them. */
                      MilanReal *ph0_time, MilanReal *ph1_time, MilanReal *ph2_time,
                      MilanLongInt *ph1_card, MilanLongInt *ph2_card);
 
-#endif
+
 #ifdef __cplusplus
 }
 #endif
 #endif
+#endif

amgprec/impl/aggregator/Matching.c

@@ -0,0 +1,504 @@
+/*
+                             AMG4PSBLAS version 1.2
+    Algebraic Multigrid Package
+               based on PSBLAS (Parallel Sparse BLAS version 3.9)
+
+    (C) Copyright 2021
+
+        Salvatore Filippone
+        Pasqua D'Ambra
+        Fabio Durastante
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+      1. Redistributions of source code must retain the above copyright
+         notice, this list of conditions and the following disclaimer.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, this list of conditions, and the following disclaimer in the
+         documentation and/or other materials provided with the distribution.
+      3. The name of the AMG4PSBLAS group or the names of its contributors may
+         not be used to endorse or promote products derived from this
+         software without specific written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+    TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AMG4PSBLAS GROUP OR ITS CONTRIBUTORS
+    BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+
+    Includes material from BootCMatch, see copyright below.
+*/
+
+/*
+                BootCMatch
+     Bootstrap AMG based on Compatible weighted Matching, version 0.9
+    (C) Copyright 2017
+                       Pasqua D'Ambra         IAC-CNR, IT
+                       Panayot S. Vassilevski Portland State University, OR USA
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions, and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+    3. The name of the BootCMatch group or the names of its contributors may
+       not be used to endorse or promote products derived from this
+       software without specific written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE BootCMatch GROUP OR ITS CONTRIBUTORS
+  BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+  POSSIBILITY OF SUCH DAMAGE.
+
+*/
+#include "amg_config.h"
+#if defined(PSB_SERIAL_MPI)
+#include <stdlib.h>
+#include "psb_types.h"
+
+psb_l_t d_trymatch(psb_l_t rowindex, psb_l_t colindex,
+		     psb_l_t nrows_W, psb_l_t *W_i, psb_l_t *W_j, psb_d_t *W_data,
+		     psb_l_t *jrowindex, psb_l_t ljrowindex,
+		     psb_l_t *jcolindex, psb_l_t ljcolindex, psb_l_t *rmatch)
+{
+
+  psb_l_t tryrowmatch, trycolmatch;
+  psb_l_t i, j, k, nzrow_W, startj, kindex;
+  psb_d_t cweight, nweight; 
+
+  //  psb_l_t     *W_i = bcm_CSRMatrixI(W);
+  //  psb_l_t     *W_j = bcm_CSRMatrixJ(W);
+  //  psb_l_t     nrows_W  =  bcm_CSRMatrixNumRows(W);
+  //  psb_d_t  *W_data=bcm_CSRMatrixData(W);
+
+  k=-1;
+  i=0;
+  while (i<ljrowindex && k ==-1)
+    {
+      if(jrowindex[i]==colindex) k=i;
+      i++;
+    }
+  if(k >= 0)
+    {
+      ljrowindex=ljrowindex-1;
+      for(i=k; i<ljrowindex; ++i) jrowindex[i]=jrowindex[i+1];
+    }
+
+  k=-1;
+  i=0;
+  while(i<ljcolindex && k==-1)
+    {
+      if(jcolindex[i]==rowindex) k=i;
+      i++;
+    }
+  if(k >= 0)
+    {
+      ljcolindex=ljcolindex-1;
+      for(i=k; i<ljcolindex; ++i) jcolindex[i]=jcolindex[i+1];
+    }
+
+  nzrow_W=W_i[rowindex+1]-W_i[rowindex];
+  startj=W_i[rowindex];
+  kindex=-1;
+  k=0;
+  while(k<nzrow_W && kindex==-1) 
+    {
+      if(W_j[startj+k]==colindex) kindex=startj+k;
+      k++;
+    }
+  cweight=W_data[kindex];
+
+  while((rmatch[rowindex]==-1 && rmatch[colindex]==-1)
+	&& (ljrowindex !=0 || ljcolindex !=0))    
+    {
+
+      if (rmatch[rowindex] == -1 && ljrowindex !=0)
+	{
+	  tryrowmatch=jrowindex[0];
+	  nzrow_W=W_i[rowindex+1]-W_i[rowindex];
+	  startj=W_i[rowindex];
+	  k=0;
+	  kindex=-1;
+	  while(k<nzrow_W && kindex==-1) 
+	    {
+	      if(W_j[startj+k]==tryrowmatch) kindex=startj+k;
+	      k++;
+	    }
+	  nweight=W_data[kindex];
+
+	  ljrowindex=ljrowindex-1;
+	  for(i=0; i<ljrowindex; ++i) jrowindex[i]=jrowindex[i+1];
+        
+	  if(nweight > cweight && rmatch[tryrowmatch]==-1)
+	    {
+          
+              nzrow_W=W_i[tryrowmatch+1]-W_i[tryrowmatch];
+	      psb_l_t *trymatchindexrow;
+	      trymatchindexrow= (psb_l_t *) calloc(nzrow_W, sizeof(psb_l_t));
+
+	      startj=W_i[tryrowmatch];
+	      for(k=0; k<nzrow_W; ++k) trymatchindexrow[k]=W_j[startj+k]; 
+
+	      d_trymatch(rowindex,tryrowmatch,
+			   nrows_W, W_i, W_j, W_data,
+			   jrowindex,ljrowindex,
+			   trymatchindexrow,nzrow_W,rmatch);
+	      free(trymatchindexrow);
+	    }
+	}
+
+      if(rmatch[colindex]==-1 && ljcolindex!=0)
+	{
+	  trycolmatch=jcolindex[0];
+	  nzrow_W=W_i[colindex+1]-W_i[colindex];
+	  startj=W_i[colindex];
+	  k=0;
+	  kindex=-1;
+	  while(k<nzrow_W && kindex==-1) 
+	    {
+	      if(W_j[startj+k]==trycolmatch) kindex=startj+k;
+	      k++;
+	    }
+	  nweight=W_data[kindex];
+
+	  ljcolindex=ljcolindex-1;
+	  for(i=0; i<ljcolindex; ++i) jcolindex[i]=jcolindex[i+1];
+        
+	  if(nweight > cweight && rmatch[trycolmatch]==-1)
+	    {
+	      nzrow_W=W_i[trycolmatch+1]-W_i[trycolmatch];
+	      psb_l_t *trymatchindexcol;
+	      trymatchindexcol= (psb_l_t *) calloc(nzrow_W, sizeof(psb_l_t));
+
+	      startj=W_i[trycolmatch];
+	      for(k=0; k<nzrow_W; ++k) trymatchindexcol[k]=W_j[startj+k];
+
+	      d_trymatch(colindex,trycolmatch,
+			   nrows_W, W_i, W_j, W_data,			   
+			   jcolindex,ljcolindex,
+			   trymatchindexcol,nzrow_W,rmatch);
+	      free(trymatchindexcol);
+	    }
+	}
+    }
+        
+  if(rmatch[rowindex]==-1 & rmatch[colindex]==-1)
+    {
+      rmatch[rowindex]=colindex;
+      rmatch[colindex]=rowindex;
+    }
+
+  return 0;
+}
+
+
+
+
+psb_l_t *d_CSRMatrixHMatch( psb_l_t  nrows_B,  psb_l_t  ncols_B,
+			       psb_l_t  nnz_B,  psb_l_t     *B_i,
+			       psb_l_t     *B_j, psb_d_t  *B_data)
+{
+
+  psb_l_t i, j, k, *rmatch;
+  psb_d_t  *c, alpha;
+  psb_l_t jbp, nzrows_B;
+  psb_d_t tmp=0.0;
+  psb_l_t rno, cno, nzrows_cno, startj, ljrowindex, ljjrowindex;
+  psb_l_t *jrowindex, *jjrowindex;
+
+#if 0
+  psb_l_t     *B_i = bcm_CSRMatrixI(B);
+  psb_l_t     *B_j = bcm_CSRMatrixJ(B);
+  psb_d_t  *B_data = bcm_CSRMatrixData(B);
+  psb_l_t  nrows_B  =  bcm_CSRMatrixNumRows(B);
+  psb_l_t  ncols_B  =  bcm_CSRMatrixNumCols(B);
+  psb_l_t  nnz_B  =  bcm_CSRMatrixNumNonzeros(B);
+#endif
+  //  assert(nrows_B==ncols_B);
+
+  rmatch = (psb_l_t *) calloc(nrows_B, sizeof(psb_l_t));
+
+  for(i=0; i<nrows_B; ++i)  rmatch[i]=-1;
+
+  jrowindex = (psb_l_t *) calloc(nrows_B, sizeof(psb_l_t));
+  jjrowindex = (psb_l_t *) calloc(nrows_B, sizeof(psb_l_t));
+
+  jbp=0;
+  for(i=0; i< nrows_B; ++i)
+    { 
+      nzrows_B=B_i[i+1]-B_i[i];
+
+      for(j=0; j<nzrows_B; ++j) jrowindex[j]=B_j[jbp+j];
+      for(j=0; j<nzrows_B; ++j)
+	{
+	  rno=i;
+	  cno=B_j[jbp+j];
+
+	  startj=B_i[cno];
+	  nzrows_cno=B_i[cno+1]-startj;
+
+	  for(k=0; k<nzrows_cno; ++k) jjrowindex[k]=B_j[startj+k];
+
+	  if(rmatch[rno] == -1 && rmatch[cno] == -1)
+	    d_trymatch(rno,cno,nrows_B,B_i,B_j,B_data,
+			 jrowindex,nzrows_B,jjrowindex,nzrows_cno,rmatch);
+        
+	}
+
+      jbp=jbp+nzrows_B;
+    }
+   
+  free(jrowindex);
+  free(jjrowindex);
+  
+  return rmatch;
+}
+
+
+void dMatching(psb_l_t NLVer, psb_l_t NLEdge,
+	       psb_l_t *verLocPtr, psb_l_t *verLocInd, psb_d_t *edgeLocWeight,
+	       psb_l_t *verDistance, psb_l_t *Mate)
+{
+  psb_l_t *lmate;
+  lmate = d_CSRMatrixHMatch( NLVer, NLVer,   NLEdge,
+			       verLocPtr, verLocInd,edgeLocWeight);
+  for (psb_l_t i=0; i<NLVer; i++){
+    Mate[i] = lmate[i];
+  }
+  free(lmate);
+  return;
+}
+
+
+psb_l_t s_trymatch(psb_l_t rowindex, psb_l_t colindex,
+		     psb_l_t nrows_W, psb_l_t *W_i, psb_l_t *W_j, psb_s_t *W_data,
+		     psb_l_t *jrowindex, psb_l_t ljrowindex,
+		     psb_l_t *jcolindex, psb_l_t ljcolindex, psb_l_t *rmatch)
+{
+
+  psb_l_t tryrowmatch, trycolmatch;
+  psb_l_t i, j, k, nzrow_W, startj, kindex;
+  psb_s_t cweight, nweight; 
+
+  //  psb_l_t     *W_i = bcm_CSRMatrixI(W);
+  //  psb_l_t     *W_j = bcm_CSRMatrixJ(W);
+  //  psb_l_t     nrows_W  =  bcm_CSRMatrixNumRows(W);
+  //  psb_s_t  *W_data=bcm_CSRMatrixData(W);
+
+  k=-1;
+  i=0;
+  while (i<ljrowindex && k ==-1)
+    {
+      if(jrowindex[i]==colindex) k=i;
+      i++;
+    }
+  if(k >= 0)
+    {
+      ljrowindex=ljrowindex-1;
+      for(i=k; i<ljrowindex; ++i) jrowindex[i]=jrowindex[i+1];
+    }
+
+  k=-1;
+  i=0;
+  while(i<ljcolindex && k==-1)
+    {
+      if(jcolindex[i]==rowindex) k=i;
+      i++;
+    }
+  if(k >= 0)
+    {
+      ljcolindex=ljcolindex-1;
+      for(i=k; i<ljcolindex; ++i) jcolindex[i]=jcolindex[i+1];
+    }
+
+  nzrow_W=W_i[rowindex+1]-W_i[rowindex];
+  startj=W_i[rowindex];
+  kindex=-1;
+  k=0;
+  while(k<nzrow_W && kindex==-1) 
+    {
+      if(W_j[startj+k]==colindex) kindex=startj+k;
+      k++;
+    }
+  cweight=W_data[kindex];
+
+  while((rmatch[rowindex]==-1 && rmatch[colindex]==-1)
+	&& (ljrowindex !=0 || ljcolindex !=0))    
+    {
+
+      if (rmatch[rowindex] == -1 && ljrowindex !=0)
+	{
+	  tryrowmatch=jrowindex[0];
+	  nzrow_W=W_i[rowindex+1]-W_i[rowindex];
+	  startj=W_i[rowindex];
+	  k=0;
+	  kindex=-1;
+	  while(k<nzrow_W && kindex==-1) 
+	    {
+	      if(W_j[startj+k]==tryrowmatch) kindex=startj+k;
+	      k++;
+	    }
+	  nweight=W_data[kindex];
+
+	  ljrowindex=ljrowindex-1;
+	  for(i=0; i<ljrowindex; ++i) jrowindex[i]=jrowindex[i+1];
+        
+	  if(nweight > cweight && rmatch[tryrowmatch]==-1)
+	    {
+          
+              nzrow_W=W_i[tryrowmatch+1]-W_i[tryrowmatch];
+	      psb_l_t *trymatchindexrow;
+	      trymatchindexrow= (psb_l_t *) calloc(nzrow_W, sizeof(psb_l_t));
+
+	      startj=W_i[tryrowmatch];
+	      for(k=0; k<nzrow_W; ++k) trymatchindexrow[k]=W_j[startj+k]; 
+
+	      s_trymatch(rowindex,tryrowmatch,
+			   nrows_W, W_i, W_j, W_data,
+			   jrowindex,ljrowindex,
+			   trymatchindexrow,nzrow_W,rmatch);
+	      free(trymatchindexrow);
+	    }
+	}
+
+      if(rmatch[colindex]==-1 && ljcolindex!=0)
+	{
+	  trycolmatch=jcolindex[0];
+	  nzrow_W=W_i[colindex+1]-W_i[colindex];
+	  startj=W_i[colindex];
+	  k=0;
+	  kindex=-1;
+	  while(k<nzrow_W && kindex==-1) 
+	    {
+	      if(W_j[startj+k]==trycolmatch) kindex=startj+k;
+	      k++;
+	    }
+	  nweight=W_data[kindex];
+
+	  ljcolindex=ljcolindex-1;
+	  for(i=0; i<ljcolindex; ++i) jcolindex[i]=jcolindex[i+1];
+        
+	  if(nweight > cweight && rmatch[trycolmatch]==-1)
+	    {
+	      nzrow_W=W_i[trycolmatch+1]-W_i[trycolmatch];
+	      psb_l_t *trymatchindexcol;
+	      trymatchindexcol= (psb_l_t *) calloc(nzrow_W, sizeof(psb_l_t));
+
+	      startj=W_i[trycolmatch];
+	      for(k=0; k<nzrow_W; ++k) trymatchindexcol[k]=W_j[startj+k];
+
+	      s_trymatch(colindex,trycolmatch,
+			   nrows_W, W_i, W_j, W_data,			   
+			   jcolindex,ljcolindex,
+			   trymatchindexcol,nzrow_W,rmatch);
+	      free(trymatchindexcol);
+	    }
+	}
+    }
+        
+  if(rmatch[rowindex]==-1 & rmatch[colindex]==-1)
+    {
+      rmatch[rowindex]=colindex;
+      rmatch[colindex]=rowindex;
+    }
+
+  return 0;
+}
+
+
+
+
+psb_l_t *s_CSRMatrixHMatch( psb_l_t  nrows_B,  psb_l_t  ncols_B,
+			       psb_l_t  nnz_B,  psb_l_t     *B_i,
+			       psb_l_t     *B_j, psb_s_t  *B_data)
+{
+
+  psb_l_t i, j, k, *rmatch;
+  psb_s_t  *c, alpha;
+  psb_l_t jbp, nzrows_B;
+  psb_s_t tmp=0.0;
+  psb_l_t rno, cno, nzrows_cno, startj, ljrowindex, ljjrowindex;
+  psb_l_t *jrowindex, *jjrowindex;
+
+#if 0
+  psb_l_t     *B_i = bcm_CSRMatrixI(B);
+  psb_l_t     *B_j = bcm_CSRMatrixJ(B);
+  psb_s_t  *B_data = bcm_CSRMatrixData(B);
+  psb_l_t  nrows_B  =  bcm_CSRMatrixNumRows(B);
+  psb_l_t  ncols_B  =  bcm_CSRMatrixNumCols(B);
+  psb_l_t  nnz_B  =  bcm_CSRMatrixNumNonzeros(B);
+#endif
+  //  assert(nrows_B==ncols_B);
+
+  rmatch = (psb_l_t *) calloc(nrows_B, sizeof(psb_l_t));
+
+  for(i=0; i<nrows_B; ++i)  rmatch[i]=-1;
+
+  jrowindex = (psb_l_t *) calloc(nrows_B, sizeof(psb_l_t));
+  jjrowindex = (psb_l_t *) calloc(nrows_B, sizeof(psb_l_t));
+
+  jbp=0;
+  for(i=0; i< nrows_B; ++i)
+    { 
+      nzrows_B=B_i[i+1]-B_i[i];
+
+      for(j=0; j<nzrows_B; ++j) jrowindex[j]=B_j[jbp+j];
+      for(j=0; j<nzrows_B; ++j)
+	{
+	  rno=i;
+	  cno=B_j[jbp+j];
+
+	  startj=B_i[cno];
+	  nzrows_cno=B_i[cno+1]-startj;
+
+	  for(k=0; k<nzrows_cno; ++k) jjrowindex[k]=B_j[startj+k];
+
+	  if(rmatch[rno] == -1 && rmatch[cno] == -1)
+	    s_trymatch(rno,cno,nrows_B,B_i,B_j,B_data,
+			 jrowindex,nzrows_B,jjrowindex,nzrows_cno,rmatch);
+        
+	}
+
+      jbp=jbp+nzrows_B;
+    }
+   
+  free(jrowindex);
+  free(jjrowindex);
+  
+  return rmatch;
+}
+
+
+void sMatching(psb_l_t NLVer, psb_l_t NLEdge,
+	       psb_l_t *verLocPtr, psb_l_t *verLocInd, psb_s_t *edgeLocWeight,
+	       psb_l_t *verDistance, psb_l_t *Mate)
+{
+
+  psb_l_t *lmate;
+  lmate = s_CSRMatrixHMatch( NLVer, NLVer,   NLEdge,
+			       verLocPtr, verLocInd,edgeLocWeight);
+  for (psb_l_t i=0; i<NLVer; i++){
+    Mate[i] = lmate[i];
+  }
+  free(lmate);
+  return;
+}
+
+#endif

amgprec/impl/aggregator/Matching.h

@@ -0,0 +1,81 @@
+/*
+                             AMG4PSBLAS version 1.2
+    Algebraic Multigrid Package
+               based on PSBLAS (Parallel Sparse BLAS version 3.9)
+
+    (C) Copyright 2021
+
+        Salvatore Filippone
+        Pasqua D'Ambra
+        Fabio Durastante
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+      1. Redistributions of source code must retain the above copyright
+         notice, this list of conditions and the following disclaimer.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, this list of conditions, and the following disclaimer in the
+         documentation and/or other materials provided with the distribution.
+      3. The name of the AMG4PSBLAS group or the names of its contributors may
+         not be used to endorse or promote products derived from this
+         software without specific written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+    TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AMG4PSBLAS GROUP OR ITS CONTRIBUTORS
+    BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+
+    Includes material from BootCMatch, see copyright below.
+*/
+
+/*
+                BootCMatch
+     Bootstrap AMG based on Compatible weighted Matching, version 0.9
+    (C) Copyright 2017
+                       Pasqua D'Ambra         IAC-CNR, IT
+                       Panayot S. Vassilevski Portland State University, OR USA
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions, and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+    3. The name of the BootCMatch group or the names of its contributors may
+       not be used to endorse or promote products derived from this
+       software without specific written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE BootCMatch GROUP OR ITS CONTRIBUTORS
+  BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+  POSSIBILITY OF SUCH DAMAGE.
+
+*/
+#include "amg_config.h"
+
+#if defined(PSB_SERIAL_MPI)
+#include "psb_types.h"
+void dMatching(psb_l_t NLVer, psb_l_t NLEdge,
+	       psb_l_t *verLocPtr, psb_l_t *verLocInd, psb_d_t *edgeLocWeight,
+	       psb_l_t *verDistance, psb_l_t *Mate);
+void sMatching(psb_l_t NLVer, psb_l_t NLEdge,
+	       psb_l_t *verLocPtr, psb_l_t *verLocInd, psb_s_t *edgeLocWeight,
+	       psb_l_t *verDistance, psb_l_t *Mate);
+#endif

amgprec/impl/aggregator/algoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateC.cpp

@@ -70,7 +70,7 @@
  Statistics: ph1_card, ph2_card : Size: |P| number of processes in the comm-world (number of matched edges in Phase 1 and Phase 2)
  */
 
-#ifdef SERIAL_MPI
+#ifdef PSB_SERIAL_MPI
 #else
 
 // DOUBLE PRECISION VERSION
@@ -86,7 +86,7 @@ void dalgoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateC(
 							      MilanReal* msgPercent,
                                                               MilanReal* ph0_time, MilanReal* ph1_time, MilanReal* ph2_time,
                                                               MilanLongInt* ph1_card, MilanLongInt* ph2_card ) {
-#if !defined(SERIAL_MPI)
+#if !defined(PSB_SERIAL_MPI)
 #ifdef PRINT_DEBUG_INFO_
     cout<<"\n("<<myRank<<")Within algoEdgeApproxDominatingEdgesLinearSearchMessageBundling()"; fflush(stdout);
 #endif
@@ -1313,7 +1313,7 @@ void salgoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateC(
       MilanReal* msgPercent,
       MilanReal* ph0_time, MilanReal* ph1_time, MilanReal* ph2_time,
       MilanLongInt* ph1_card, MilanLongInt* ph2_card ) {
-#if !defined(SERIAL_MPI)
+#if !defined(PSB_SERIAL_MPI)
 #ifdef PRINT_DEBUG_INFO_
     cout<<"\n("<<myRank<<")Within algoEdgeApproxDominatingEdgesLinearSearchMessageBundling()"; fflush(stdout);
 #endif

amgprec/impl/aggregator/algoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateCMP.cpp

@@ -70,7 +70,7 @@
  Statistics: ph1_card, ph2_card : Size: |P| number of processes in the comm-world (number of matched edges in Phase 1 and Phase 2)
  */
 //#define DEBUG_HANG_
-#ifdef SERIAL_MPI
+#ifdef PSB_SERIAL_MPI
 #else
 
 // DOUBLE PRECISION VERSION
@@ -102,7 +102,7 @@ void dalgoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateCMP(
      *            i+1-th value is the position of the first element on the i+1-th row
      */
 
-#if !defined(SERIAL_MPI)
+#if !defined(PSB_SERIAL_MPI)
 #ifdef PRINT_DEBUG_INFO_
     cout << "\n(" << myRank << ")Within algoEdgeApproxDominatingEdgesLinearSearchMessageBundling()";
     fflush(stdout);
@@ -583,7 +583,7 @@ void salgoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateCMP(
      *            i+1-th value is the position of the first element on the i+1-th row
      */
 
-#if !defined(SERIAL_MPI)
+#if !defined(PSB_SERIAL_MPI)
 #ifdef PRINT_DEBUG_INFO_
     cout << "\n(" << myRank << ")Within algoEdgeApproxDominatingEdgesLinearSearchMessageBundling()";
     fflush(stdout);

amgprec/impl/aggregator/amg_c_dec_aggregator_mat_bld.f90

@@ -177,23 +177,24 @@ subroutine  amg_c_dec_aggregator_mat_bld(ag,parms,a,desc_a,ilaggr,nlaggr,&
   select case (parms%aggr_prol)
   case (amg_no_smooth_) 
 
-    call amg_caggrmat_nosmth_bld(a,desc_a,ilaggr,nlaggr,&
-         & parms,ac,desc_ac,op_prol,op_restr,t_prol,info)
+    call amg_caggrmat_nosmth_bld(parms%aggr_prol,a,desc_a,ilaggr,&
+            nlaggr,parms,ac,desc_ac,op_prol,op_restr,t_prol,info)
 
-  case(amg_smooth_prol_) 
+  case(amg_smooth_prol_,amg_l1_smooth_prol_) 
 
-    call amg_caggrmat_smth_bld(a,desc_a,ilaggr,nlaggr, &
-         & parms,ac,desc_ac,op_prol,op_restr,t_prol,info)
+    call amg_caggrmat_smth_bld(parms%aggr_prol,a,desc_a,&
+            ilaggr,nlaggr,parms,ac,desc_ac,op_prol,&
+            op_restr,t_prol,info)
 
 !!$  case(amg_biz_prol_) 
 !!$
 !!$    call amg_caggrmat_biz_bld(a,desc_a,ilaggr,nlaggr, &
 !!$         & parms,ac,desc_ac,op_prol,op_restr,t_prol,info)
-
+  
   case(amg_min_energy_) 
 
-    call amg_caggrmat_minnrg_bld(a,desc_a,ilaggr,nlaggr, &
-         & parms,ac,desc_ac,op_prol,op_restr,t_prol,info)
+    call amg_caggrmat_minnrg_bld(parms%aggr_prol,a,desc_a,ilaggr,&
+            nlaggr,parms,ac,desc_ac,op_prol,op_restr,t_prol,info)
 
   case default
     info = psb_err_internal_error_

amgprec/impl/aggregator/amg_c_ptap_bld.f90

@@ -216,6 +216,7 @@ subroutine amg_c_ptap_bld(a_csr,desc_a,nlaggr,parms,ac,&
 
   call ac_csr%set_nrows(desc_ac%get_local_rows())
   call ac_csr%set_ncols(desc_ac%get_local_cols())
+  call ac_csr%clean_zeros(info)
   call ac%mv_from(ac_csr)
   call ac%set_asb()
 
@@ -420,6 +421,7 @@ subroutine amg_c_lc_ptap_bld(a_csr,desc_a,nlaggr,parms,ac,&
 
   call ac_csr%set_nrows(desc_ac%get_local_rows())
   call ac_csr%set_ncols(desc_ac%get_local_cols())
+  call ac_csr%clean_zeros(info)
   call ac%mv_from(ac_csr)
   call ac%set_asb()
 
@@ -486,7 +488,7 @@ subroutine amg_lc_ptap_bld(a_csr,desc_a,nlaggr,parms,ac,&
   integer(psb_lpk_) :: nrow, nglob, ncol, ntaggr, nrl, nzl, ip, &
        &  nzt, naggrm1, naggrp1, i, k
   integer(psb_lpk_) ::  nrsave, ncsave, nzsave, nza
-  logical, parameter :: do_timings=.true., oldstyle=.false., debug=.false.  
+  logical, parameter :: do_timings=.false., oldstyle=.false., debug=.false.  
   integer(psb_ipk_), save :: idx_spspmm=-1
 
   name='amg_ptap_bld'
@@ -629,6 +631,7 @@ subroutine amg_lc_ptap_bld(a_csr,desc_a,nlaggr,parms,ac,&
 
   call ac_csr%set_nrows(desc_ac%get_local_rows())
   call ac_csr%set_ncols(desc_ac%get_local_cols())
+  call ac_csr%clean_zeros(info)
   call ac%mv_from(ac_csr)
   call ac%set_asb()
 

amgprec/impl/aggregator/amg_c_rap.f90

@@ -142,6 +142,7 @@ subroutine amg_c_rap(a_csr,desc_a,nlaggr,parms,ac,&
 
   call ac_csr%set_nrows(desc_ac%get_local_rows())
   call ac_csr%set_ncols(desc_ac%get_local_cols())
+  call ac_csr%clean_zeros(info)
   call ac%mv_from(ac_csr)
   call ac%set_asb()
 

amgprec/impl/aggregator/amg_c_soc1_map_bld.F90

@@ -72,7 +72,7 @@ subroutine amg_c_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   use psb_base_mod
   use amg_base_prec_type
   use amg_c_inner_mod
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   use omp_lib
 #endif
   implicit none
@@ -103,7 +103,7 @@ subroutine amg_c_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   character(len=20)   :: name, ch_err
   integer(psb_ipk_), save :: idx_soc1_p1=-1, idx_soc1_p2=-1, idx_soc1_p3=-1
   integer(psb_ipk_), save :: idx_soc1_p0=-1
-  logical, parameter      :: do_timings=.true.
+  logical, parameter      :: do_timings=.false.
 
   info=psb_success_
   name = 'amg_soc1_map_bld'
@@ -172,7 +172,7 @@ subroutine amg_c_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   ! Phase one: Start with disjoint groups.
   ! 
   naggr = 0
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   block
     integer(psb_ipk_), allocatable  :: bnds(:), locnaggr(:)
     integer(psb_ipk_) :: myth,nths, kk
@@ -250,7 +250,7 @@ subroutine amg_c_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
               ! we will not reset. 
               if (j>nr) cycle step1
               if (ilaggr(j) > 0) cycle step1
-              if (abs(val(k)) > theta*sqrt(abs(diag(i)*diag(j)))) then
+              if ((abs(val(k)) > theta*sqrt(abs(diag(i)*diag(j)))).and.(diag(i).ne.czero)) then
                 ip = ip + 1
                 icol(ip) = icol(k)
               end if
@@ -357,7 +357,7 @@ subroutine amg_c_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
       do k=1, nz
         j   = icol(k)
         if ((1<=j).and.(j<=nr)) then 
-          if (abs(val(k)) > theta*sqrt(abs(diag(i)*diag(j)))) then
+          if ((abs(val(k)) > theta*sqrt(abs(diag(i)*diag(j)))).and.(diag(i).ne.czero)) then
             ip = ip + 1
             icol(ip) = icol(k)
           end if
@@ -545,4 +545,3 @@ subroutine amg_c_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   return
 
 end subroutine amg_c_soc1_map_bld
-

amgprec/impl/aggregator/amg_c_soc2_map_bld.F90

@@ -71,7 +71,7 @@ subroutine amg_c_soc2_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   use psb_base_mod 
   use amg_base_prec_type
   use amg_c_inner_mod
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   use omp_lib
 #endif
 
@@ -104,7 +104,7 @@ subroutine amg_c_soc2_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   character(len=20)  :: name, ch_err
   integer(psb_ipk_), save :: idx_soc2_p1=-1, idx_soc2_p2=-1, idx_soc2_p3=-1
   integer(psb_ipk_), save :: idx_soc2_p0=-1
-  logical, parameter      :: do_timings=.true.
+  logical, parameter      :: do_timings=.false.
 
   info=psb_success_
   name = 'amg_soc2_map_bld'
@@ -211,7 +211,7 @@ subroutine amg_c_soc2_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   ! Phase one: Start with disjoint groups.
   ! 
   naggr = 0
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   block
     integer(psb_ipk_), allocatable  :: bnds(:), locnaggr(:)
     integer(psb_ipk_) :: myth,nths, kk

amgprec/impl/aggregator/amg_caggrmat_minnrg_bld.f90

@@ -69,6 +69,7 @@
 !
 !
 ! Arguments:
+!    dol1smoothing - fictitious integer argument, it is not used inside
 !    a          -  type(psb_cspmat_type), input.     
 !                  The sparse matrix structure containing the local part of
 !                  the fine-level matrix.
@@ -104,8 +105,8 @@
 !                  Error code.
 !
 !
-subroutine amg_caggrmat_minnrg_bld(a,desc_a,ilaggr,nlaggr,parms,&
-     & ac,desc_ac,op_prol,op_restr,t_prol,info)
+subroutine amg_caggrmat_minnrg_bld(dol1smoothing,a,desc_a,ilaggr,nlaggr,&
+                parms,ac,desc_ac,op_prol,op_restr,t_prol,info)
   use psb_base_mod
   use amg_base_prec_type
   use amg_c_inner_mod, amg_protect_name => amg_caggrmat_minnrg_bld
@@ -113,6 +114,7 @@ subroutine amg_caggrmat_minnrg_bld(a,desc_a,ilaggr,nlaggr,parms,&
   implicit none
 
   ! Arguments
+  integer(psb_ipk_), intent(in)                 :: dol1smoothing
   type(psb_cspmat_type), intent(in)           :: a
   type(psb_desc_type), intent(inout)            :: desc_a
   integer(psb_lpk_), intent(inout)              :: ilaggr(:), nlaggr(:)
@@ -171,6 +173,13 @@ subroutine amg_caggrmat_minnrg_bld(a,desc_a,ilaggr,nlaggr,parms,&
 
   filter_mat = (parms%aggr_filter == amg_filter_mat_)
 
+  if (dol1smoothing.ne.amg_no_smooth_) then
+    info=psb_err_fatal_; 
+    call psb_errpush(info,name,a_err='Are you trying to smooth an unsmoothed aggregation?')
+    goto 9999
+  end if
+
+
   !NEEDS TO BE REWORKED !!
   
   ! naggr: number of local aggregates
@@ -300,7 +309,7 @@ subroutine amg_caggrmat_minnrg_bld(a,desc_a,ilaggr,nlaggr,parms,&
 !!$        endif
 !!$      enddo
 !!$      if (jd == -1) then 
-!!$        write(0,*) 'Wrong input: we need the diagonal!!!!', i
+!!$                write(0,*) name,': Warning: there is no diagonal element', i
 !!$      else
 !!$        acsrf%val(jd)=acsrf%val(jd)-tmp
 !!$      end if

amgprec/impl/aggregator/amg_caggrmat_nosmth_bld.f90

@@ -94,10 +94,11 @@
 !               
 !    info       -  integer, output.
 !                  Error code.
+!    dol1smoothing - optional, this is here just for interfacing reasons. It is not used by the
+!                    code
 !
-!
-subroutine amg_caggrmat_nosmth_bld(a,desc_a,ilaggr,nlaggr,parms,&
-     & ac,desc_ac,op_prol,op_restr,t_prol,info)
+subroutine amg_caggrmat_nosmth_bld(dol1smoothing,a,desc_a,ilaggr,nlaggr,&
+                parms,ac,desc_ac,op_prol,op_restr,t_prol,info)
   use psb_base_mod
   use amg_base_prec_type
   use amg_c_inner_mod, amg_protect_name => amg_caggrmat_nosmth_bld
@@ -105,6 +106,7 @@ subroutine amg_caggrmat_nosmth_bld(a,desc_a,ilaggr,nlaggr,parms,&
   implicit none
 
   ! Arguments
+  integer(psb_ipk_), intent(in)              :: dol1smoothing 
   type(psb_cspmat_type), intent(in)        :: a
   type(psb_desc_type), intent(inout)         :: desc_a
   integer(psb_lpk_), intent(inout)           :: ilaggr(:), nlaggr(:)
@@ -137,6 +139,12 @@ subroutine amg_caggrmat_nosmth_bld(a,desc_a,ilaggr,nlaggr,parms,&
 
   ctxt = desc_a%get_context()
   call psb_info(ctxt, me, np)
+  if (dol1smoothing.ne.amg_no_smooth_) then
+    info=psb_err_fatal_;         
+    call psb_errpush(info,name,a_err='Are you trying to smooth an unsmoothed aggregation?')
+    goto 9999
+  end if
+
   nglob = desc_a%get_global_rows()
   nrow  = desc_a%get_local_rows()
   ncol  = desc_a%get_local_cols()

amgprec/impl/aggregator/amg_caggrmat_smth_bld.f90

@@ -69,6 +69,8 @@
 !
 !
 ! Arguments:
+!    dol1smooth -  Integer taking the type of smoother that has to be used
+!                  on the tentative prolongator
 !    a          -  type(psb_cspmat_type), input.     
 !                  The sparse matrix structure containing the local part of
 !                  the fine-level matrix.
@@ -102,16 +104,18 @@
 !    info       -  integer, output.
 !                  Error code.
 !
-subroutine amg_caggrmat_smth_bld(a,desc_a,ilaggr,nlaggr,parms,&
-     & ac,desc_ac,op_prol,op_restr,t_prol,info)
+subroutine amg_caggrmat_smth_bld(dol1smoothing,a,desc_a,ilaggr,nlaggr,&
+                parms,ac,desc_ac,op_prol,op_restr,t_prol,info)
   use psb_base_mod
   use amg_base_prec_type
   use amg_c_inner_mod, amg_protect_name => amg_caggrmat_smth_bld
   use amg_c_base_aggregator_mod
+!  use, intrinsic :: ieee_arithmetic
 
   implicit none
 
   ! Arguments
+  integer(psb_ipk_), intent(in)            :: dol1smoothing
   type(psb_cspmat_type), intent(in)      :: a
   type(psb_desc_type), intent(inout)       :: desc_a
   integer(psb_lpk_), intent(inout)         :: ilaggr(:), nlaggr(:)
@@ -132,7 +136,7 @@ subroutine amg_caggrmat_smth_bld(a,desc_a,ilaggr,nlaggr,parms,&
   type(psb_c_coo_sparse_mat) :: coo_prol, coo_restr
   type(psb_c_csr_sparse_mat) :: acsr1,  acsrf, csr_prol, acsr
   complex(psb_spk_), allocatable :: adiag(:)
-  real(psb_spk_), allocatable :: arwsum(:)
+  real(psb_spk_), allocatable :: arwsum(:),l1rwsum(:)
   integer(psb_ipk_)  :: ierr(5)
   logical            :: filter_mat
   integer(psb_ipk_)            :: debug_level, debug_unit, err_act
@@ -141,6 +145,7 @@ subroutine amg_caggrmat_smth_bld(a,desc_a,ilaggr,nlaggr,parms,&
   logical, parameter :: debug_new=.false.
   character(len=80) :: filename
   logical, parameter :: do_timings=.false.
+  logical :: do_l1correction=.false.
   integer(psb_ipk_), save :: idx_spspmm=-1, idx_phase1=-1, idx_gtrans=-1, idx_phase2=-1, idx_refine=-1
   integer(psb_ipk_), save :: idx_phase3=-1, idx_cdasb=-1, idx_ptap=-1
 
@@ -173,6 +178,9 @@ subroutine amg_caggrmat_smth_bld(a,desc_a,ilaggr,nlaggr,parms,&
   if ((do_timings).and.(idx_ptap==-1)) &
        & idx_ptap = psb_get_timer_idx("DEC_SMTH_BLD: ptap_bld  ")
 
+  ! check if we have to use Jacobi or l1-Jacobi to smooth the tentative prolongator
+  if (dol1smoothing.eq.amg_l1_smooth_prol_) do_l1correction=.true.
+
 
   nglob = desc_a%get_global_rows()
   nrow  = desc_a%get_local_rows()
@@ -185,7 +193,7 @@ subroutine amg_caggrmat_smth_bld(a,desc_a,ilaggr,nlaggr,parms,&
 
   naggrm1 = sum(nlaggr(1:me))
   naggrp1 = sum(nlaggr(1:me+1))
-  filter_mat = (parms%aggr_filter == amg_filter_mat_)
+  filter_mat = (parms%aggr_filter == amg_filter_mat_).or.(parms%aggr_filter == amg_filter_prow_mat_)
 
   !
   ! naggr: number of local aggregates
@@ -200,6 +208,24 @@ subroutine amg_caggrmat_smth_bld(a,desc_a,ilaggr,nlaggr,parms,&
   if (info == psb_success_) &
        & call psb_halo(adiag,desc_a,info)
   if (info == psb_success_) call a%cp_to(acsr)
+  !
+  ! Do the l1-correction on the diagonal if it is requested
+  !
+  if (do_l1correction) then
+    allocate(l1rwsum(nrow))
+    call acsr%arwsum(l1rwsum)
+    if (info == psb_success_) &
+      & call psb_realloc(ncol,l1rwsum,info)
+    if (info == psb_success_) &
+      & call psb_halo(l1rwsum,desc_a,info)
+    ! \tilde{D}_{i,i} = \sum_{j \ne i} |a_{i,j}|
+    !$OMP parallel do private(i) schedule(static)
+    do i=1,size(adiag)
+        adiag(i) = adiag(i) + l1rwsum(i) - abs(adiag(i))
+    end do
+    !$OMP end parallel do
+  end if
+
 
   if(info /= psb_success_) then
     call psb_errpush(psb_err_from_subroutine_,name,a_err='sp_getdiag')
@@ -230,9 +256,15 @@ subroutine amg_caggrmat_smth_bld(a,desc_a,ilaggr,nlaggr,parms,&
 
       enddo
       if (jd == -1) then 
+        ! if (.not.do_l1correction) 
         write(0,*) 'Wrong input: we need the diagonal!!!!', i
-      else
+      else if (parms%aggr_filter == amg_filter_mat_) then
+        ! We perform filtering in the standard way assuming that A is an M-matrix
         acsrf%val(jd)=acsrf%val(jd)-tmp
+      else if (parms%aggr_filter == amg_filter_prow_mat_) then
+        ! We are probably doing l1-correction, hence we want to preserve the
+        ! row sum of the matrix: note the change in sign
+        acsrf%val(jd)=acsrf%val(jd)+tmp
       end if
     enddo
     !$OMP end parallel do 
@@ -240,7 +272,6 @@ subroutine amg_caggrmat_smth_bld(a,desc_a,ilaggr,nlaggr,parms,&
     call acsrf%clean_zeros(info)
   end if
 
-
   !$OMP parallel do private(i) schedule(static)
   do i=1,size(adiag)
     if (adiag(i) /= czero) then
@@ -252,14 +283,17 @@ subroutine amg_caggrmat_smth_bld(a,desc_a,ilaggr,nlaggr,parms,&
   !$OMP end parallel do 
   if (parms%aggr_omega_alg == amg_eig_est_) then 
 
-    if (parms%aggr_eig == amg_max_norm_) then 
+    if ( (parms%aggr_filter == amg_filter_prow_mat_).and.(do_l1correction) ) then
+      ! For l1-Jacobi this can be estimated with 1:
+      ! this makes sense only if we are preserving the row-sum!
+      parms%aggr_omega_val = done
+    else if (parms%aggr_eig == amg_max_norm_) then 
       allocate(arwsum(nrow))
       call acsr%arwsum(arwsum)      
       anorm = maxval(abs(adiag(1:nrow)*arwsum(1:nrow)))
       call psb_amx(ctxt,anorm)
       omega = 4.d0/(3.d0*anorm)
       parms%aggr_omega_val = omega 
-
     else 
       info = psb_err_internal_error_
       call psb_errpush(info,name,a_err='invalid amg_aggr_eig_')
@@ -322,6 +356,7 @@ subroutine amg_caggrmat_smth_bld(a,desc_a,ilaggr,nlaggr,parms,&
   if (debug_level >= psb_debug_outer_) &
        & write(debug_unit,*) me,' ',trim(name),&
        & 'Done smooth_aggregate '
+  if (allocated(l1rwsum)) deallocate(l1rwsum)
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_d_dec_aggregator_mat_bld.f90

@@ -177,23 +177,24 @@ subroutine  amg_d_dec_aggregator_mat_bld(ag,parms,a,desc_a,ilaggr,nlaggr,&
   select case (parms%aggr_prol)
   case (amg_no_smooth_) 
 
-    call amg_daggrmat_nosmth_bld(a,desc_a,ilaggr,nlaggr,&
-         & parms,ac,desc_ac,op_prol,op_restr,t_prol,info)
+    call amg_daggrmat_nosmth_bld(parms%aggr_prol,a,desc_a,ilaggr,&
+            nlaggr,parms,ac,desc_ac,op_prol,op_restr,t_prol,info)
 
-  case(amg_smooth_prol_) 
+  case(amg_smooth_prol_,amg_l1_smooth_prol_) 
 
-    call amg_daggrmat_smth_bld(a,desc_a,ilaggr,nlaggr, &
-         & parms,ac,desc_ac,op_prol,op_restr,t_prol,info)
+    call amg_daggrmat_smth_bld(parms%aggr_prol,a,desc_a,&
+            ilaggr,nlaggr,parms,ac,desc_ac,op_prol,&
+            op_restr,t_prol,info)
 
 !!$  case(amg_biz_prol_) 
 !!$
 !!$    call amg_daggrmat_biz_bld(a,desc_a,ilaggr,nlaggr, &
 !!$         & parms,ac,desc_ac,op_prol,op_restr,t_prol,info)
-
+  
   case(amg_min_energy_) 
 
-    call amg_daggrmat_minnrg_bld(a,desc_a,ilaggr,nlaggr, &
-         & parms,ac,desc_ac,op_prol,op_restr,t_prol,info)
+    call amg_daggrmat_minnrg_bld(parms%aggr_prol,a,desc_a,ilaggr,&
+            nlaggr,parms,ac,desc_ac,op_prol,op_restr,t_prol,info)
 
   case default
     info = psb_err_internal_error_

amgprec/impl/aggregator/amg_d_parmatch_aggregator_inner_mat_asb.F90

@@ -98,11 +98,7 @@ subroutine  amg_d_parmatch_aggregator_inner_mat_asb(ag,parms,a,desc_a,&
      & ac,desc_ac, op_prol,op_restr,info)
   use psb_base_mod
   use amg_base_prec_type
-#if defined(SERIAL_MPI)
-    use amg_d_parmatch_aggregator_mod
-#else
   use amg_d_parmatch_aggregator_mod, amg_protect_name => amg_d_parmatch_aggregator_inner_mat_asb
-#endif
   implicit none
   class(amg_d_parmatch_aggregator_type), target, intent(inout) :: ag
   type(amg_dml_parms), intent(inout)    :: parms
@@ -133,8 +129,6 @@ subroutine  amg_d_parmatch_aggregator_inner_mat_asb(ag,parms,a,desc_a,&
   ictxt = desc_a%get_context()
   call psb_info(ictxt,me,np)
 
-#if !defined(SERIAL_MPI)
-
   if (debug) write(0,*) me,' ',trim(name),' Start:',&
        & allocated(ag%ac),allocated(ag%desc_ac), allocated(ag%prol),allocated(ag%restr)
 
@@ -146,16 +140,17 @@ subroutine  amg_d_parmatch_aggregator_inner_mat_asb(ag,parms,a,desc_a,&
   case(amg_repl_mat_)
     !
     !
-    info = psb_err_internal_error_
-    call psb_errpush(info,name,a_err='no repl coarse_mat_ here')
-    goto 9999
-
+    if (np>1) then 
+      info = psb_err_internal_error_
+      call psb_errpush(info,name,a_err='no repl coarse_mat_ here')
+      goto 9999
+    end if
   case default
     info = psb_err_internal_error_
     call psb_errpush(info,name,a_err='invalid amg_coarse_mat_')
     goto 9999
   end select
-#endif
+
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_d_parmatch_aggregator_mat_asb.F90

@@ -98,11 +98,7 @@ subroutine  amg_d_parmatch_aggregator_mat_asb(ag,parms,a,desc_a,&
      & ac,desc_ac, op_prol,op_restr,info)
   use psb_base_mod
   use amg_base_prec_type
-#if defined(SERIAL_MPI)
-    use amg_d_parmatch_aggregator_mod
-#else
   use amg_d_parmatch_aggregator_mod, amg_protect_name => amg_d_parmatch_aggregator_mat_asb
-#endif
   implicit none
   class(amg_d_parmatch_aggregator_type), target, intent(inout) :: ag
   type(amg_dml_parms), intent(inout)    :: parms
@@ -112,7 +108,7 @@ subroutine  amg_d_parmatch_aggregator_mat_asb(ag,parms,a,desc_a,&
   type(psb_desc_type), intent(inout)    :: desc_ac
   integer(psb_ipk_), intent(out)        :: info
   !
-  type(psb_ctxt_type)         :: ictxt
+  type(psb_ctxt_type)         :: ctxt
   integer(psb_ipk_)           :: np, me
   type(psb_ld_coo_sparse_mat) :: tmpcoo
   type(psb_ldspmat_type)      :: tmp_ac
@@ -128,15 +124,13 @@ subroutine  amg_d_parmatch_aggregator_mat_asb(ag,parms,a,desc_a,&
   debug_unit  = psb_get_debug_unit()
   debug_level = psb_get_debug_level()
   info  = psb_success_
-  ictxt = desc_a%get_context()
-  call psb_info(ictxt,me,np)
+  ctxt = desc_a%get_context()
+  call psb_info(ctxt,me,np)
   if (psb_get_errstatus().ne.0) then
     write(0,*) me,' From:',trim(name),':',psb_get_errstatus()
     return
   end if
 
-
-#if !defined(SERIAL_MPI)
   if (debug) write(0,*) me,' ',trim(name),' Start:',&
        & allocated(ag%ac),allocated(ag%desc_ac), allocated(ag%prol),allocated(ag%restr)
 
@@ -169,22 +163,21 @@ subroutine  amg_d_parmatch_aggregator_mat_asb(ag,parms,a,desc_a,&
     call op_prol%mv_to(tmpcoo)
     nzl = tmpcoo%get_nzeros()
     call psb_loc_to_glob(tmpcoo%ja(1:nzl),desc_ac,info,'I')
+    call tmpcoo%set_ncols(i_nr)
     call op_prol%mv_from(tmpcoo)
 
     call op_restr%mv_to(tmpcoo)
     nzl = tmpcoo%get_nzeros()
     call psb_loc_to_glob(tmpcoo%ia(1:nzl),desc_ac,info,'I')
+    call tmpcoo%set_nrows(i_nr)
     call op_restr%mv_from(tmpcoo)
 
-    call op_prol%set_ncols(i_nr)
-    call op_restr%set_nrows(i_nr)
-
     call psb_gather(tmp_ac,ac,desc_ac,info,root=-ione,&
          & dupl=psb_dupl_add_,keeploc=.false.)
     call tmp_ac%mv_to(tmpcoo)
     call ac%mv_from(tmpcoo)
 
-    call psb_cdall(ictxt,desc_ac,info,mg=ntaggr,repl=.true.)
+    call psb_cdall(ctxt,desc_ac,info,mg=ntaggr,repl=.true.)
     if (info == psb_success_) call psb_cdasb(desc_ac,info)
     !
     ! Now that we have the descriptors and the restrictor, we should
@@ -199,7 +192,7 @@ subroutine  amg_d_parmatch_aggregator_mat_asb(ag,parms,a,desc_a,&
     call psb_errpush(info,name,a_err='invalid amg_coarse_mat_')
     goto 9999
   end select
-#endif
+
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_d_parmatch_aggregator_mat_bld.F90

@@ -135,11 +135,7 @@ subroutine  amg_d_parmatch_aggregator_mat_bld(ag,parms,a,desc_a,ilaggr,nlaggr,&
   use psb_base_mod
   use amg_d_inner_mod
   use amg_base_prec_type
-#if defined(SERIAL_MPI)
-    use amg_d_parmatch_aggregator_mod
-#else
   use amg_d_parmatch_aggregator_mod, amg_protect_name => amg_d_parmatch_aggregator_mat_bld
-#endif
   implicit none
 
   class(amg_d_parmatch_aggregator_type), target, intent(inout) :: ag
@@ -176,7 +172,6 @@ subroutine  amg_d_parmatch_aggregator_mat_bld(ag,parms,a,desc_a,ilaggr,nlaggr,&
   ! algorithm specified by
   !
 
-#if !defined(SERIAL_MPI)
   call clean_shortcuts(ag)
   !
   ! When requesting smoothed aggregation we cannot use the
@@ -184,20 +179,23 @@ subroutine  amg_d_parmatch_aggregator_mat_bld(ag,parms,a,desc_a,ilaggr,nlaggr,&
   !
   select case (parms%aggr_prol)
   case (amg_no_smooth_)
-    call amg_d_parmatch_unsmth_bld(ag,a,desc_a,ilaggr,nlaggr,parms,&
-         & ac,desc_ac,op_prol,op_restr,t_prol,info)
+    call amg_d_parmatch_unsmth_bld(parms%aggr_prol,ag,a,desc_a,&
+            ilaggr,nlaggr,parms,ac,desc_ac,op_prol,op_restr,&
+            t_prol,info)
 
-  case(amg_smooth_prol_)
-    call amg_d_parmatch_smth_bld(ag,a,desc_a,ilaggr,nlaggr,parms,&
-         & ac,desc_ac,op_prol,op_restr,t_prol,info)
+  case(amg_smooth_prol_,amg_l1_smooth_prol_)
+    call amg_d_parmatch_smth_bld(parms%aggr_prol,ag,a,desc_a,&
+            ilaggr,nlaggr,parms,ac,desc_ac,op_prol,op_restr,&
+            t_prol,info)
 
 !!$  case(amg_biz_prol_)
 !!$    call amg_daggrmat_biz_bld(a,desc_a,ilaggr,nlaggr, &
 !!$         & parms,ac,desc_ac,op_prol,op_restr,info)
 
   case(amg_min_energy_)
-    call amg_daggrmat_minnrg_bld(a,desc_a,ilaggr,nlaggr, &
-         & parms,ac,desc_ac,op_prol,op_restr,t_prol,info)
+    call amg_daggrmat_minnrg_bld(parms%aggr_prol,a,desc_a,&
+            ilaggr,nlaggr,parms,ac,desc_ac,op_prol,op_restr,&
+            t_prol,info)
 
   case default
     info = psb_err_internal_error_
@@ -209,14 +207,12 @@ subroutine  amg_d_parmatch_aggregator_mat_bld(ag,parms,a,desc_a,ilaggr,nlaggr,&
     call psb_errpush(psb_err_from_subroutine_,name,a_err='Inner aggrmat asb')
     goto 9999
   end if
-#endif
   call psb_erractionrestore(err_act)
   return
 
 9999 call psb_error_handler(err_act)
   return
 
-#if !defined(SERIAL_MPI)
 
 contains
   subroutine clean_shortcuts(ag)
@@ -245,5 +241,4 @@ contains
       end if
     end if
   end subroutine clean_shortcuts
-#endif
 end subroutine amg_d_parmatch_aggregator_mat_bld

amgprec/impl/aggregator/amg_d_parmatch_aggregator_tprol.F90

@@ -47,11 +47,7 @@ subroutine  amg_d_parmatch_aggregator_build_tprol(ag,parms,ag_data,&
   use psb_base_mod
   use amg_base_prec_type
   use amg_d_inner_mod
-#if defined(SERIAL_MPI)
-  use amg_d_parmatch_aggregator_mod
-#else
   use amg_d_parmatch_aggregator_mod, amg_protect_name => amg_d_parmatch_aggregator_build_tprol
-#endif
   use iso_c_binding
   implicit none
   class(amg_d_parmatch_aggregator_type), target, intent(inout) :: ag
@@ -88,7 +84,7 @@ subroutine  amg_d_parmatch_aggregator_build_tprol(ag,parms,ag_data,&
   type(psb_ldspmat_type)              :: tmp_prol, tmp_pg, tmp_restr
   type(psb_desc_type)                 :: tmp_desc_ac, tmp_desc_ax, tmp_desc_p
   integer(psb_ipk_), save             :: idx_mboxp=-1, idx_spmmbld=-1, idx_sweeps_mult=-1
-  logical, parameter :: dump=.false., do_timings=.true., debug=.false., &
+  logical, parameter :: dump=.false., do_timings=.false., debug=.false., &
        & dump_prol_restr=.false.
 
   name='d_parmatch_tprol'
@@ -120,8 +116,6 @@ subroutine  amg_d_parmatch_aggregator_build_tprol(ag,parms,ag_data,&
        &   amg_aggr_ord_nat_,is_legal_ml_aggr_ord)
   call amg_check_def(parms%aggr_thresh,'Aggr_Thresh',dzero,is_legal_d_aggr_thrs)
 
-#if !defined(SERIAL_MPI)
-
   match_algorithm = ag%matching_alg
   n_sweeps        = ag%n_sweeps
   if (2**n_sweeps /= ag%orig_aggr_size) then
@@ -466,7 +460,7 @@ subroutine  amg_d_parmatch_aggregator_build_tprol(ag,parms,ag_data,&
     call psb_errpush(psb_err_from_subroutine_,name,a_err='amg_bootCMatch_if')
     goto 9999
   end if
-#endif
+
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_d_parmatch_smth_bld.F90

@@ -69,6 +69,8 @@
 !
 !
 ! Arguments:
+!    dol1smoothing - Select between l1-Jacobi and Jacobi as smoother for the
+!                  tentative prolongator
 !    a          -  type(psb_dspmat_type), input.
 !                  The sparse matrix structure containing the local part of
 !                  the fine-level matrix.
@@ -102,20 +104,17 @@
 !    info       -  integer, output.
 !                  Error code.
 !
-subroutine amg_d_parmatch_smth_bld(ag,a,desc_a,ilaggr,nlaggr,parms,&
-     & ac,desc_ac,op_prol,op_restr,t_prol,info)
+subroutine amg_d_parmatch_smth_bld(dol1smoothing,ag,a,desc_a,ilaggr,nlaggr,&
+                parms,ac,desc_ac,op_prol,op_restr,t_prol,info)
   use psb_base_mod
   use amg_base_prec_type
   use amg_d_inner_mod
   use amg_d_base_aggregator_mod
-#if defined(SERIAL_MPI)
-    use amg_d_parmatch_aggregator_mod
-#else
   use amg_d_parmatch_aggregator_mod, amg_protect_name => amg_d_parmatch_smth_bld
-#endif
   implicit none
 
   ! Arguments
+  integer(psb_ipk_), intent(in)            :: dol1smoothing
   class(amg_d_parmatch_aggregator_type), target, intent(inout) :: ag
   type(psb_dspmat_type), intent(in)      :: a
   type(psb_desc_type), intent(inout)     :: desc_a
@@ -137,7 +136,7 @@ subroutine amg_d_parmatch_smth_bld(ag,a,desc_a,ilaggr,nlaggr,parms,&
   type(psb_d_coo_sparse_mat)  :: coo_prol, coo_restr
   type(psb_d_csr_sparse_mat)  :: acsrf, csr_prol, acsr, tcsr
   real(psb_dpk_), allocatable :: adiag(:)
-  real(psb_dpk_), allocatable :: arwsum(:)
+  real(psb_dpk_), allocatable :: arwsum(:),l1rwsum(:)
   logical            :: filter_mat
   integer(psb_ipk_)            :: debug_level, debug_unit, err_act
   integer(psb_ipk_), parameter :: ncmax=16
@@ -145,6 +144,7 @@ subroutine amg_d_parmatch_smth_bld(ag,a,desc_a,ilaggr,nlaggr,parms,&
   logical, parameter :: debug_new=.false., dump_r=.false., dump_p=.false., debug=.false.
   character(len=80) :: filename
   logical, parameter :: do_timings=.false.
+  logical :: do_l1correction=.false.
   integer(psb_ipk_), save :: idx_spspmm=-1, idx_phase1=-1, idx_gtrans=-1, idx_phase2=-1, idx_refine=-1, idx_phase3=-1
   integer(psb_ipk_), save :: idx_cdasb=-1, idx_ptap=-1
 
@@ -166,6 +166,10 @@ subroutine amg_d_parmatch_smth_bld(ag,a,desc_a,ilaggr,nlaggr,parms,&
   ncol  = desc_a%get_local_cols()
 
   theta = parms%aggr_thresh
+  ! Check if we have to perform l1-Jacobi or Jacobi as smoother
+  if(dol1smoothing.eq.amg_l1_smooth_prol_) do_l1correction=.true.
+
+
   !write(0,*) me,' ',trim(name),' Start ',idx_spspmm
   if ((do_timings).and.(idx_spspmm==-1)) &
        & idx_spspmm = psb_get_timer_idx("PMC_SMTH_BLD: par_spspmm")
@@ -186,8 +190,6 @@ subroutine amg_d_parmatch_smth_bld(ag,a,desc_a,ilaggr,nlaggr,parms,&
 
   if (do_timings) call psb_tic(idx_phase1)
 
-#if !defined(SERIAL_MPI)
-
   naggr  = nlaggr(me+1)
   ntaggr = sum(nlaggr)
   naggrm1 = sum(nlaggr(1:me))
@@ -217,6 +219,19 @@ subroutine amg_d_parmatch_smth_bld(ag,a,desc_a,ilaggr,nlaggr,parms,&
   if (info == psb_success_) &
        & call psb_halo(adiag,desc_a,info)
   if (info == psb_success_) call a%cp_to(acsr)
+  ! Get the l1-diagonal of D
+  if (do_l1correction) then
+    allocate(l1rwsum(nrow))
+    call acsr%arwsum(l1rwsum)
+    if (info == psb_success_) &
+      & call psb_realloc(ncol,l1rwsum,info)
+    if (info == psb_success_) &
+      & call psb_halo(l1rwsum,desc_a,info)
+    ! \tilde{D}_{i,i} = \sum_{j \ne i} |a_{i,j}|
+    do i=1,size(adiag)
+      adiag(i) = adiag(i) + l1rwsum(i) - abs(adiag(i))
+    end do
+  end if
 
   if(info /= psb_success_) then
     call psb_errpush(psb_err_from_subroutine_,name,a_err='sp_getdiag')
@@ -246,7 +261,7 @@ subroutine amg_d_parmatch_smth_bld(ag,a,desc_a,ilaggr,nlaggr,parms,&
 
       enddo
       if (jd == -1) then
-        write(0,*) 'Wrong input: we need the diagonal!!!!', i
+        write(0,*) name,': Warning: there is no diagonal element', i
       else
         acsrf%val(jd)=acsrf%val(jd)-tmp
       end if
@@ -267,7 +282,10 @@ subroutine amg_d_parmatch_smth_bld(ag,a,desc_a,ilaggr,nlaggr,parms,&
 
   if (parms%aggr_omega_alg == amg_eig_est_) then
 
-    if (parms%aggr_eig == amg_max_norm_) then
+    if (do_l1correction) then
+      ! For l1-Jacobi this can be estimated with 1
+      parms%aggr_omega_val = done
+    else if (parms%aggr_eig == amg_max_norm_) then
       allocate(arwsum(nrow))
       call acsr%arwsum(arwsum)
       anorm = maxval(abs(adiag(1:nrow)*arwsum(1:nrow)))
@@ -373,12 +391,13 @@ subroutine amg_d_parmatch_smth_bld(ag,a,desc_a,ilaggr,nlaggr,parms,&
 
     end block
   end if
+  if (allocated(l1rwsum)) deallocate(l1rwsum)
   if (do_timings) call psb_toc(idx_phase2)
 
   if (debug_level >= psb_debug_outer_) &
        & write(debug_unit,*) me,' ',trim(name),&
        & 'Done smooth_aggregate '
-#endif
+
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_d_parmatch_spmm_bld.F90

@@ -99,11 +99,7 @@ subroutine amg_d_parmatch_spmm_bld(a,desc_a,ilaggr,nlaggr,parms,&
      & ac,desc_ac,op_prol,op_restr,t_prol,info)
   use psb_base_mod
   use amg_d_inner_mod
-#if defined(SERIAL_MPI)
-    use amg_d_parmatch_aggregator_mod
-#else
   use amg_d_parmatch_aggregator_mod, amg_protect_name => amg_d_parmatch_spmm_bld
-#endif
   implicit none
 
   ! Arguments
@@ -140,7 +136,6 @@ subroutine amg_d_parmatch_spmm_bld(a,desc_a,ilaggr,nlaggr,parms,&
   debug_unit  = psb_get_debug_unit()
   debug_level = psb_get_debug_level()
 
-#if !defined(SERIAL_MPI)
   call a%cp_to(acsr)
 
   call  amg_d_parmatch_spmm_bld_inner(acsr,desc_a,ilaggr,nlaggr,parms,&
@@ -154,7 +149,7 @@ subroutine amg_d_parmatch_spmm_bld(a,desc_a,ilaggr,nlaggr,parms,&
   if (debug_level >= psb_debug_outer_) &
        & write(debug_unit,*) me,' ',trim(name),&
        & 'Done spmm_bld '
-#endif
+
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_d_parmatch_spmm_bld_inner.F90

@@ -99,11 +99,7 @@ subroutine amg_d_parmatch_spmm_bld_inner(a_csr,desc_a,ilaggr,nlaggr,parms,&
      & ac,desc_ac,op_prol,op_restr,t_prol,info)
   use psb_base_mod
   use amg_d_inner_mod
-#if defined(SERIAL_MPI)
-    use amg_d_parmatch_aggregator_mod
-#else
   use amg_d_parmatch_aggregator_mod, amg_protect_name => amg_d_parmatch_spmm_bld_inner
-#endif
   implicit none
 
   ! Arguments
@@ -131,7 +127,7 @@ subroutine amg_d_parmatch_spmm_bld_inner(a_csr,desc_a,ilaggr,nlaggr,parms,&
        &  nzt, naggrm1, naggrp1, i, k
   integer(psb_lpk_), allocatable :: ia(:),ja(:)
   !integer(psb_lpk_) ::  nrsave, ncsave, nzsave, nza, nrpsave, ncpsave, nzpsave
-  logical, parameter :: do_timings=.true., oldstyle=.false., debug=.false.
+  logical, parameter :: do_timings=.false., oldstyle=.false., debug=.false.
   integer(psb_ipk_), save :: idx_spspmm=-1, idx_prolcnv=-1, idx_proltrans=-1, idx_asb=-1
 
   name='amg_parmatch_spmm_bld_inner'
@@ -139,7 +135,6 @@ subroutine amg_d_parmatch_spmm_bld_inner(a_csr,desc_a,ilaggr,nlaggr,parms,&
   info=psb_success_
   call psb_erractionsave(err_act)
 
-
   ictxt = desc_a%get_context()
   call psb_info(ictxt, me, np)
   debug_unit  = psb_get_debug_unit()
@@ -163,7 +158,6 @@ subroutine amg_d_parmatch_spmm_bld_inner(a_csr,desc_a,ilaggr,nlaggr,parms,&
   naggrm1 = sum(nlaggr(1:me))
   naggrp1 = sum(nlaggr(1:me+1))
 
-#if !defined(SERIAL_MPI)
   !
   ! Here T_PROL should be arriving with GLOBAL indices on the cols
   ! and LOCAL indices on the rows.
@@ -203,11 +197,10 @@ subroutine amg_d_parmatch_spmm_bld_inner(a_csr,desc_a,ilaggr,nlaggr,parms,&
     goto 9999
   end if
 
-
   if (debug_level >= psb_debug_outer_) &
        & write(debug_unit,*) me,' ',trim(name),&
        & 'Done smooth_aggregate '
-#endif
+
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_d_parmatch_spmm_bld_ov.F90

@@ -99,11 +99,7 @@ subroutine amg_d_parmatch_spmm_bld_ov(a,desc_a,ilaggr,nlaggr,parms,&
      & ac,desc_ac,op_prol,op_restr,t_prol,info)
   use psb_base_mod
   use amg_d_inner_mod
-#if defined(SERIAL_MPI)
-    use amg_d_parmatch_aggregator_mod
-#else
   use amg_d_parmatch_aggregator_mod, amg_protect_name => amg_d_parmatch_spmm_bld_ov
-#endif
   implicit none
 
   ! Arguments
@@ -141,8 +137,6 @@ subroutine amg_d_parmatch_spmm_bld_ov(a,desc_a,ilaggr,nlaggr,parms,&
   debug_unit  = psb_get_debug_unit()
   debug_level = psb_get_debug_level()
 
-#if !defined(SERIAL_MPI)
-
   call a%mv_to(acsr)
 
   call  amg_d_parmatch_spmm_bld_inner(acsr,desc_a,ilaggr,nlaggr,parms,&
@@ -158,7 +152,6 @@ subroutine amg_d_parmatch_spmm_bld_ov(a,desc_a,ilaggr,nlaggr,parms,&
   if (debug_level >= psb_debug_outer_) &
        & write(debug_unit,*) me,' ',trim(name),&
        & 'Done spmm_bld '
-#endif
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_d_parmatch_unsmth_bld.F90

@@ -68,6 +68,8 @@
 !
 !
 ! Arguments:
+!    dol1smoothing - this not actually used inside unsmoothed aggregation, it
+!                  is used just to perform a check
 !    a          -  type(psb_dspmat_type), input.
 !                  The sparse matrix structure containing the local part of
 !                  the fine-level matrix.
@@ -101,20 +103,17 @@
 !    info       -  integer, output.
 !                  Error code.
 !
-subroutine amg_d_parmatch_unsmth_bld(ag,a,desc_a,ilaggr,nlaggr,parms,&
-     & ac,desc_ac,op_prol,op_restr,t_prol,info)
+subroutine amg_d_parmatch_unsmth_bld(dol1smoothing,ag,a,desc_a,ilaggr,nlaggr,&
+                parms,ac,desc_ac,op_prol,op_restr,t_prol,info)
   use psb_base_mod
   use amg_base_prec_type
   use amg_d_inner_mod
   use amg_d_base_aggregator_mod
-#if defined(SERIAL_MPI)
-    use amg_d_parmatch_aggregator_mod
-#else
   use amg_d_parmatch_aggregator_mod, amg_protect_name => amg_d_parmatch_unsmth_bld
-#endif
   implicit none
 
   ! Arguments
+  integer(psb_ipk_), intent(in) :: dol1smoothing
   class(amg_d_parmatch_aggregator_type), target, intent(inout) :: ag
   type(psb_dspmat_type), intent(in)      :: a
   type(psb_desc_type), intent(inout)     :: desc_a
@@ -159,8 +158,12 @@ subroutine amg_d_parmatch_unsmth_bld(ag,a,desc_a,ilaggr,nlaggr,parms,&
   ictxt = desc_a%get_context()
 
   call psb_info(ictxt, me, np)
+  if (dol1smoothing.ne.amg_no_smooth_) then
+    info=psb_err_fatal_;         
+    call psb_errpush(info,name,a_err='Are you trying to smooth an unsmoothed aggregation?')
+    goto 9999
+  end if
 
-#if !defined(SERIAL_MPI)
   nglob = desc_a%get_global_rows()
   nrow  = desc_a%get_local_rows()
   ncol  = desc_a%get_local_cols()
@@ -201,7 +204,8 @@ subroutine amg_d_parmatch_unsmth_bld(ag,a,desc_a,ilaggr,nlaggr,parms,&
   call op_prol%mv_from(coo_prol)
 
   if (debug) write(0,*)  me,' ',trim(name),' After  mv_from',psb_get_errstatus()
-  if (debug) write(0,*)  me,' ',trim(name),' ',ac%get_fmt(),ac%get_nrows(),ac%get_ncols(),ac%get_nzeros(),naggr,ntaggr
+  if (debug) write(0,*)  me,' ',trim(name),' ',ac%get_fmt(),ac%get_nrows(),&
+       & ac%get_ncols(),ac%get_nzeros(),naggr,ntaggr
   ! write(0,*)  me,' ',trim(name),' Final AC newstyle ',ac%get_fmt(),ac%get_nrows(),ac%get_ncols(),ac%get_nzeros()
 
   if (debug) then
@@ -228,7 +232,6 @@ subroutine amg_d_parmatch_unsmth_bld(ag,a,desc_a,ilaggr,nlaggr,parms,&
     goto 9999
   end if
 
-#endif
   call psb_erractionrestore(err_act)
   return
 

amgprec/impl/aggregator/amg_d_ptap_bld.f90

@@ -216,6 +216,7 @@ subroutine amg_d_ptap_bld(a_csr,desc_a,nlaggr,parms,ac,&
 
   call ac_csr%set_nrows(desc_ac%get_local_rows())
   call ac_csr%set_ncols(desc_ac%get_local_cols())
+  call ac_csr%clean_zeros(info)
   call ac%mv_from(ac_csr)
   call ac%set_asb()
 
@@ -420,6 +421,7 @@ subroutine amg_d_ld_ptap_bld(a_csr,desc_a,nlaggr,parms,ac,&
 
   call ac_csr%set_nrows(desc_ac%get_local_rows())
   call ac_csr%set_ncols(desc_ac%get_local_cols())
+  call ac_csr%clean_zeros(info)
   call ac%mv_from(ac_csr)
   call ac%set_asb()
 
@@ -486,7 +488,7 @@ subroutine amg_ld_ptap_bld(a_csr,desc_a,nlaggr,parms,ac,&
   integer(psb_lpk_) :: nrow, nglob, ncol, ntaggr, nrl, nzl, ip, &
        &  nzt, naggrm1, naggrp1, i, k
   integer(psb_lpk_) ::  nrsave, ncsave, nzsave, nza
-  logical, parameter :: do_timings=.true., oldstyle=.false., debug=.false.  
+  logical, parameter :: do_timings=.false., oldstyle=.false., debug=.false.  
   integer(psb_ipk_), save :: idx_spspmm=-1
 
   name='amg_ptap_bld'
@@ -629,6 +631,7 @@ subroutine amg_ld_ptap_bld(a_csr,desc_a,nlaggr,parms,ac,&
 
   call ac_csr%set_nrows(desc_ac%get_local_rows())
   call ac_csr%set_ncols(desc_ac%get_local_cols())
+  call ac_csr%clean_zeros(info)
   call ac%mv_from(ac_csr)
   call ac%set_asb()
 

amgprec/impl/aggregator/amg_d_rap.f90

@@ -142,6 +142,7 @@ subroutine amg_d_rap(a_csr,desc_a,nlaggr,parms,ac,&
 
   call ac_csr%set_nrows(desc_ac%get_local_rows())
   call ac_csr%set_ncols(desc_ac%get_local_cols())
+  call ac_csr%clean_zeros(info)
   call ac%mv_from(ac_csr)
   call ac%set_asb()
 

amgprec/impl/aggregator/amg_d_soc1_map_bld.F90

@@ -72,7 +72,7 @@ subroutine amg_d_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   use psb_base_mod
   use amg_base_prec_type
   use amg_d_inner_mod
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   use omp_lib
 #endif
   implicit none
@@ -103,7 +103,7 @@ subroutine amg_d_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   character(len=20)   :: name, ch_err
   integer(psb_ipk_), save :: idx_soc1_p1=-1, idx_soc1_p2=-1, idx_soc1_p3=-1
   integer(psb_ipk_), save :: idx_soc1_p0=-1
-  logical, parameter      :: do_timings=.true.
+  logical, parameter      :: do_timings=.false.
 
   info=psb_success_
   name = 'amg_soc1_map_bld'
@@ -172,7 +172,7 @@ subroutine amg_d_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   ! Phase one: Start with disjoint groups.
   ! 
   naggr = 0
-#if defined(OPENMP)
+#if defined(PSB_OPENMP)
   block
     integer(psb_ipk_), allocatable  :: bnds(:), locnaggr(:)
     integer(psb_ipk_) :: myth,nths, kk
@@ -250,7 +250,7 @@ subroutine amg_d_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
               ! we will not reset. 
               if (j>nr) cycle step1
               if (ilaggr(j) > 0) cycle step1
-              if (abs(val(k)) > theta*sqrt(abs(diag(i)*diag(j)))) then
+              if ((abs(val(k)) > theta*sqrt(abs(diag(i)*diag(j)))).and.(diag(i).ne.dzero)) then
                 ip = ip + 1
                 icol(ip) = icol(k)
               end if
@@ -357,7 +357,7 @@ subroutine amg_d_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
       do k=1, nz
         j   = icol(k)
         if ((1<=j).and.(j<=nr)) then 
-          if (abs(val(k)) > theta*sqrt(abs(diag(i)*diag(j)))) then
+          if ((abs(val(k)) > theta*sqrt(abs(diag(i)*diag(j)))).and.(diag(i).ne.dzero)) then
             ip = ip + 1
             icol(ip) = icol(k)
           end if
@@ -545,4 +545,3 @@ subroutine amg_d_soc1_map_bld(iorder,theta,clean_zeros,a,desc_a,nlaggr,ilaggr,in
   return
 
 end subroutine amg_d_soc1_map_bld
-