diff --git a/CMakeLists.txt b/CMakeLists.txt
index c8aaca80..3c53de8f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.10)
-project(amg4psblas VERSION 1.0 LANGUAGES C Fortran)
+project(amg4psblas VERSION 1.0 LANGUAGES C CXX Fortran)
 
 
 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake")
@@ -21,6 +21,10 @@ message(STATUS "psblas directory is ${PSBLAS_INSTALL_DIR};;")
 
 message(STATUS "PSBLAS DIRECTORY INC ${INCDIR}; MOD ${MODDIR}; LIB ${LIBDIR};")
 
+
+#set(CMAKE_CXX_STANDARD 17) # Set cxx standard for the c++ part of the library
+
+
 # Find the psblas package
 find_package(psblas REQUIRED PATHS ${PSBLAS_INSTALL_DIR})
 
@@ -30,6 +34,19 @@ else()
     message(STATUS "Found PSBLAS: ${psblas_LIBRARIES}")
 endif()
 
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # Add -g to the Fortran compiler flags.
+    # We use STRING(APPEND) to ensure we don't overwrite other important flags.
+    string(APPEND CMAKE_Fortran_FLAGS " -g")
+    string(APPEND CMAKE_CXX_FLAGS " -g")
+    message(STATUS "Fortran and CXX debug flags added: -g")
+endif()
+
+    string(APPEND CMAKE_Fortran_FLAGS " -O2")
+    string(APPEND CMAKE_CXX_FLAGS " -O2")
+    message(STATUS "Fortran and CXX optimization flags added: -O2")
+
+
 
 # Set the include and library directories based on the provided path
 #set(TEST_INSTALLDIR "${PSBLAS_INSTALL_DIR}")
@@ -39,7 +56,7 @@ set(LIBDIR "${PSBLAS_INSTALL_DIR}/${PSB_CMAKE_INSTALL_LIBDIR}")
 
 
 # Include directories for the project
-include_directories(${PSBLAS_INSTALL_DIR})
+include_directories(${PSBLAS_INSTALL_DIR} ${MPI_INCLUDE_PATH} )
 
 
 # Include directories for the Fortran compiler
@@ -142,7 +159,7 @@ write_basic_package_version_file(
   COMPATIBILITY SameMajorVersion
   )
 
-configure_file("${CMAKE_SOURCE_DIR}/cmake/pkg/${CMAKE_PROJECT_NAME}Config.cmake.in"
+configure_file("${CMAKE_SOURCE_DIR}/cmake/${CMAKE_PROJECT_NAME}Config.cmake.in"
   "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${CMAKE_PROJECT_NAME}Config.cmake" @ONLY)
 
 install(
@@ -177,6 +194,80 @@ add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure)
 #----------------------------------
 # Determine if we're using Open MPI
 #---------------------------------
+
+
+
+find_package( MPI REQUIRED Fortran C CXX )
+
+if(MPI_FOUND)
+  #-----------------------------------------------
+  # Work around an issue present on fedora systems
+  #-----------------------------------------------
+  if( (MPI_CXX_LINK_FLAGS MATCHES "noexecstack") OR (MPI_Fortran_LINK_FLAGS MATCHES "noexecstack") )
+    message ( WARNING
+      "The `noexecstack` linker flag was found in the MPI_<lang>_LINK_FLAGS variable. This is
+known to cause segmentation faults for some Fortran codes. See, e.g.,
+https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71729 or
+https://github.com/sourceryinstitute/OpenCoarrays/issues/317.
+
+`noexecstack` is being replaced with `execstack`"
+      )
+    string(REPLACE "noexecstack"
+      "execstack" MPI_CXX_LINK_FLAGS_FIXED ${MPI_CXX_LINK_FLAGS})
+    string(REPLACE "noexecstack"
+      "execstack" MPI_C_LINK_FLAGS_FIXED ${MPI_C_LINK_FLAGS})
+    string(REPLACE "noexecstack"
+      "execstack" MPI_Fortran_LINK_FLAGS_FIXED ${MPI_Fortran_LINK_FLAGS})
+    set(MPI_CXX_LINK_FLAGS "${MPI_CXX_LINK_FLAGS_FIXED}" CACHE STRING
+      "MPI CXX linking flags" FORCE)
+    set(MPI_C_LINK_FLAGS "${MPI_C_LINK_FLAGS_FIXED}" CACHE STRING
+      "MPI C linking flags" FORCE)
+    set(MPI_Fortran_LINK_FLAGS "${MPI_Fortran_LINK_FLAGS_FIXED}" CACHE STRING
+      "MPI Fortran linking flags" FORCE)
+      
+  endif()
+
+    message(STATUS "Found MPI: ${MPI_C_LIBRARIES} - ${MPI_CXX_LIBRARIES} - ${MPI_Fortran_LIBRARIES}")
+    
+    
+  #----------------
+  # Setup MPI compilers
+  #----------------  
+  set(CMAKE_C_COMPILER ${MPI_C_COMPILER} CACHE FILEPATH "C compiler" FORCE)
+  set(CMAKE_CXX_COMPILER ${MPI_CXX_COMPILER} CACHE FILEPATH "C++ compiler" FORCE)
+  set(CMAKE_Fortran_COMPILER ${MPI_Fortran_COMPILER} CACHE FILEPATH "Fortran compiler" FORCE)
+    
+  #----------------
+  # Setup MPI flags
+  #----------------
+  list(REMOVE_DUPLICATES MPI_Fortran_INCLUDE_PATH)
+  set(CMAKE_C_COMPILE_FLAGS ${CMAKE_C_COMPILE_FLAGS} ${MPI_C_COMPILE_FLAGS})
+  set(CMAKE_C_LINK_FLAGS ${CMAKE_C_LINK_FLAGS} ${MPI_C_LINK_FLAGS})
+  set(CMAKE_CXX_COMPILE_FLAGS ${CMAKE_CXX_COMPILE_FLAGS} ${MPI_CXX_COMPILE_FLAGS})
+  set(CMAKE_CXX_LINK_FLAGS ${CMAKE_CXX_LINK_FLAGS} ${MPI_CXX_LINK_FLAGS})
+  set(CMAKE_Fortran_COMPILE_FLAGS ${CMAKE_Fortran_COMPILE_FLAGS} ${MPI_Fortran_COMPILE_FLAGS})
+  set(CMAKE_Fortran_LINK_FLAGS ${CMAKE_Fortran_LINK_FLAGS} ${MPI_Fortran_LINK_FLAGS})
+  include_directories(BEFORE ${MPI_C_INCLUDE_PATH} ${MPI_CXX_INCLUDE_PATH} ${MPI_Fortran_INCLUDE_PATH})
+message(STATUS "${MPI_C_INCLUDE_PATH}; ${MPI_Fortran_INCLUDE_PATH};; ${CMAKE_Fortran_LINK_FLAGS} ;")
+  if(MPI_Fortran_HAVE_F90_MODULE OR MPI_Fortran_HAVE_F08_MODULE)
+    add_compile_options(-DPSB_MPI_MOD)
+    message(STATUS "-DPSB_MPI_MOD")
+    #add_compile_options(-DSERIAL_MPI) # Is it right??
+    #message(STATUS "-DSERIAL_MPI")
+  endif()
+  set(PSB_SERIAL_MPI OFF)
+  
+else()
+  message(STATUS "MPI  not found, serial ahead")
+  add_compile_options(-DPSB_SERIAL_MPI)
+  add_compile_options(-DPSB_MPI_MOD)
+  set(PSB_SERIAL_MPI ON)
+  set(CSERIALMPI "#define PSB_SERIAL_MPI")
+endif()
+
+add_compile_options(-O3)
+add_compile_options($<$<COMPILE_LANGUAGE:Fortran>:-frecursive>)
+
 if(MPI_FOUND)
   execute_process(COMMAND ${MPIEXEC} --version
     OUTPUT_VARIABLE mpi_version_out)
@@ -184,6 +275,34 @@ if(MPI_FOUND)
     message( STATUS "OpenMPI detected")
     set ( openmpi true )
   endif()
+  
+  
+  set(MPI_H_COPIED FALSE)
+  set(MPI_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/include") # Define the include directory
+
+  # Create the include directory if it doesn't exist
+  file(MAKE_DIRECTORY "${MPI_INCLUDE_DIR}")
+
+  foreach(path IN LISTS MPI_INCLUDE_PATH)
+    # Construct the full path to the mpi.h file
+    set(mpi_h_path "${path}/mpi.h")
+    
+    # Check if the mpi.h file exists
+    if(EXISTS "${mpi_h_path}")
+        # Copy the mpi.h file to the include directory
+        file(COPY "${mpi_h_path}" DESTINATION "${MPI_INCLUDE_DIR}")
+        message(STATUS "Copied mpi.h from ${mpi_h_path} to ${MPI_INCLUDE_DIR}")
+        set(MPI_H_COPIED TRUE)
+        break()  # Exit the loop once we've copied the file
+    endif()
+  endforeach()
+
+  if(NOT MPI_H_COPIED)
+    message(WARNING "mpi.h not found in any of the specified paths: ${MPI_INCLUDE_PATH}")
+  endif()
+
+  # Add the created include directory to the project's include directories
+  #include_directories("${MPI_INCLUDE_DIR}")
 endif()
 
 
@@ -205,8 +324,11 @@ configure_file(
 # Add the AMG libraries
 #---------------------------------------
 
+# In your CMakeLists.txt
+set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -ffree-line-length-256")
 
-
+message(STATUS "MPI_LIBRARIES: ${MPI_LIBRARIES}")
+message(STATUS "MPI_CXX_LIBRARIES: ${MPI_CXX_LIBRARIES}")
 
 
 
@@ -215,19 +337,29 @@ include(${CMAKE_CURRENT_LIST_DIR}/amgprec/CMakeLists.txt)  # include amgprec_sou
 include_directories("${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}")
 
 add_library(amgprec_C OBJECT ${amgprec_source_C_files})
+add_library(amgprec_CPP OBJECT ${amgprec_source_CPP_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
+  psblas::util psblas::linsolve psblas::prec psblas::ext psblas::cbind psblas::base
+  #${MPI_C_LIBRARIES}
+  )  #TODO  check actual libraries needed
+
+target_link_libraries(amgprec_CPP
+  #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
+  stdc++
+  ${MPI_CXX_LIBRARIES})  #TODO  check actual libraries needed
 
-add_library(amgprec ${amgprec_source_files} $<TARGET_OBJECTS:amgprec_C>)
+add_library(amgprec ${amgprec_source_files} $<TARGET_OBJECTS:amgprec_CPP> $<TARGET_OBJECTS:amgprec_C> )
 
 set_target_properties(amgprec
   PROPERTIES
   Fortran_MODULE_DIRECTORY "${CMAKE_BINARY_DIR}/modules"  
   POSITION_INDEPENDENT_CODE TRUE
-  OUTPUT_NAME psb_amgprec
+  OUTPUT_NAME amg_prec
   LINKER_LANGUAGE Fortran
   )
 
@@ -243,7 +375,9 @@ 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
+  psblas::util psblas::linsolve psblas::prec psblas::ext psblas::cbind psblas::base
+  #${MPI_Fortran_LIBRARIES} ${MPI_CXX_LIBRARIES} ${MPI_C_LIBRARIES}
+  )  #TODO  check actual libraries needed
 
 
 
@@ -260,20 +394,20 @@ foreach(path IN LISTS amgcbind_header_C_files)
 endforeach()
 
 
-add_library(amgcbind_C OBJECT ${amgprec_source_C_files})
+add_library(amgcbind_C OBJECT ${amgcbind_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>)
+add_library(amgcbind ${amgcbind_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
+  OUTPUT_NAME amg_cbind
   LINKER_LANGUAGE Fortran
   )
 
@@ -354,25 +488,50 @@ message(STATUS "install directory is ${CMAKE_INSTALL_LIBDIR};;;")
 #  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}::
 )
 
+#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
-#)
+# Set the installation directory for the test files
+set(INSTALL_TEST_DIR "${CMAKE_INSTALL_PREFIX}/samples" CACHE PATH "Installation directory for sample files")
+
+function(install_directory_recursive source_dir install_base_dir) # Function to install a directory and its subdirectories recursively
+    file(GLOB_RECURSE ALL_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/${source_dir}" "${source_dir}/*")
+
+    foreach(FILE_PATH IN LISTS ALL_FILES)
+        # Construct the full source and destination paths
+        set(FULL_SOURCE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/${source_dir}/${FILE_PATH}")
+        set(FULL_INSTALL_PATH "${install_base_dir}/${FILE_PATH}")
+
+        # Check if it's a directory
+        if(IS_DIRECTORY "${FULL_SOURCE_PATH}")
+            # Create the directory in the install destination
+            file(MAKE_DIRECTORY "${FULL_INSTALL_PATH}")
+        else()
+            # Install the file
+            install(FILES "${FULL_SOURCE_PATH}" DESTINATION "${install_base_dir}" RENAME "${FILE_PATH}")
+        endif()
+    endforeach()
+endfunction()
+
+
+
+# Install test/fileread directory
+install_directory_recursive(samples/simple "${INSTALL_TEST_DIR}/simple")
+
+# Install test/pdegen directory
+install_directory_recursive(samples/advanced "${INSTALL_TEST_DIR}/advanced")
 
 
 
diff --git a/amgprec/CMakeLists.txt b/amgprec/CMakeLists.txt
index 87a91b72..f47de40b 100644
--- a/amgprec/CMakeLists.txt
+++ b/amgprec/CMakeLists.txt
@@ -875,6 +875,33 @@ 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)
 
+
+set(AMG_amgprec_source_CPP_files
+impl/aggregator/computeCandidateMate.cpp
+impl/aggregator/processExposedVertex.cpp
+impl/aggregator/processMatchedVertices.cpp
+impl/aggregator/algoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateCMP.cpp
+impl/aggregator/processCrossEdge.cpp
+impl/aggregator/findOwnerOfGhost.cpp
+impl/aggregator/MatchBoxPC.cpp
+impl/aggregator/queueTransfer.cpp
+impl/aggregator/clean.cpp
+impl/aggregator/algoDistEdgeApproxDomEdgesLinearSearchMesgBndlSmallMateC.cpp
+impl/aggregator/extractUChunk.cpp
+impl/aggregator/processMatchedVerticesAndSendMessages.cpp
+impl/aggregator/sendBundledMessages.cpp
+impl/aggregator/initialize.cpp
+impl/aggregator/isAlreadyMatched.cpp
+impl/aggregator/processMessages.cpp
+impl/aggregator/parallelComputeCandidateMateB.cpp
+)
+
+
 foreach(file IN LISTS AMG_amgprec_source_C_files)
   list(APPEND amgprec_source_C_files ${CMAKE_CURRENT_LIST_DIR}/${file})
 endforeach()
+
+
+foreach(file IN LISTS AMG_amgprec_source_CPP_files)
+  list(APPEND amgprec_source_CPP_files ${CMAKE_CURRENT_LIST_DIR}/${file})
+endforeach()
diff --git a/samples/advanced/fileread/CMakeLists.txt b/samples/advanced/fileread/CMakeLists.txt
new file mode 100644
index 00000000..c25ca2d5
--- /dev/null
+++ b/samples/advanced/fileread/CMakeLists.txt
@@ -0,0 +1,117 @@
+cmake_minimum_required(VERSION 3.15)
+project(AMGExamples Fortran)
+
+# Installation directories (passed as CMake variables)
+set(AMG4PSBLAS_INSTALL_DIR "" CACHE PATH "Path to AMG installation")
+set(PSBLAS_INSTALL_DIR "" CACHE PATH "Path to PSBLAS installation")
+
+# Check if installation directories are set
+if(NOT AMG4PSBLAS_INSTALL_DIR)
+    message(FATAL_ERROR "AMG_INSTALL_DIR must be set.  Use -DAMG_INSTALL_DIR=/path/to/amg when running CMake.")
+endif()
+
+if(NOT PSBLAS_INSTALL_DIR)
+    message(FATAL_ERROR "PSBLAS_INSTALL_DIR must be set.  Use -DPSBLAS_INSTALL_DIR=/path/to/psblas when running CMake.")
+endif()
+
+
+find_package(psblas REQUIRED PATHS ${PSBLAS_INSTALL_DIR})
+find_package(amg4psblas REQUIRED PATHS ${AMG4PSBLAS_INSTALL_DIR})
+
+
+# Include directories
+include_directories(
+    "."
+    "${AMG4PSBLAS_INSTALL_DIR}/include"
+    "${AMG4PSBLAS_INSTALL_DIR}/modules"
+    "${PSBLAS_INSTALL_DIR}/include" 
+)
+
+# Fortran module directory
+set(CMAKE_Fortran_MODULE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/modules")
+set(FMFLAG "-I") 
+
+# Library directories
+link_directories(
+    "${AMG4PSBLAS_INSTALL_DIR}/lib"
+    "${PSBLAS_INSTALL_DIR}/lib"
+)
+
+# Libraries
+set(AMG_LIBS amg4psblas::amgprec)
+set(PSBLAS_LIBS  psblas::util psblas::linsolve psblas::prec psblas::base) 
+
+# Executable directory
+set(EXEDIR "${CMAKE_CURRENT_BINARY_DIR}/runs")
+file(MAKE_DIRECTORY "${EXEDIR}")
+
+set(COMMON_SOURCE data_input.f90)
+
+# Source files
+set(DFSOBJS ${COMMON_SOURCE} amg_df_sample.f90)
+set(SFSOBJS ${COMMON_SOURCE} amg_sf_sample.f90)
+set(CFSOBJS ${COMMON_SOURCE} amg_cf_sample.f90)
+set(ZFSOBJS ${COMMON_SOURCE} amg_zf_sample.f90)
+
+
+
+# Function to create executable
+macro(create_amg_executable target sources)
+    add_executable(${target} ${sources})
+    target_link_libraries(${target} PUBLIC
+        ${AMG_LIBS}
+        ${PSBLAS_LIBS}
+
+    )
+
+    # Move executable to EXEDIR (post-build)
+    #add_custom_command(TARGET ${target} POST_BUILD
+    #    COMMAND ${CMAKE_COMMAND} -E move $<TARGET_FILE:${target}> ${EXEDIR}
+    #)
+    set_target_properties(${target} PROPERTIES
+        RUNTIME_OUTPUT_DIRECTORY ${EXEDIR}
+        )
+endmacro()
+
+
+# Create executables
+create_amg_executable(amg_df_sample "${DFSOBJS}")
+create_amg_executable(amg_sf_sample "${SFSOBJS}")
+create_amg_executable(amg_cf_sample "${CFSOBJS}")
+create_amg_executable(amg_zf_sample "${ZFSOBJS}")
+
+# Create "runs" directory (if it doesn't exist)
+add_custom_target(create_runs_dir
+    COMMAND ${CMAKE_COMMAND} -E make_directory "${EXEDIR}"
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    COMMENT "Creating runs directory"
+)
+add_dependencies(amg_df_sample create_runs_dir)
+add_dependencies(amg_sf_sample create_runs_dir)
+add_dependencies(amg_cf_sample create_runs_dir)
+add_dependencies(amg_zf_sample create_runs_dir)
+
+
+
+# lib target
+add_custom_target(lib
+    COMMAND ${CMAKE_COMMAND} -E chdir "../../" ${CMAKE_COMMAND} --build . --target library
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    COMMENT "Building library"
+)
+
+# verycleanlib target
+add_custom_target(verycleanlib
+    COMMAND ${CMAKE_COMMAND} -E chdir "../../" ${CMAKE_COMMAND} --build . --target veryclean
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    COMMENT "Cleaning library"
+)
+
+# Install target (optional)
+install(TARGETS
+    amg_sf_sample
+    amg_df_sample
+    amg_cf_sample
+    amg_zf_sample
+    DESTINATION bin
+)
diff --git a/samples/advanced/pdegen/CMakeLists.txt b/samples/advanced/pdegen/CMakeLists.txt
new file mode 100644
index 00000000..355ec855
--- /dev/null
+++ b/samples/advanced/pdegen/CMakeLists.txt
@@ -0,0 +1,229 @@
+cmake_minimum_required(VERSION 3.15)
+project(AMGExamples Fortran CXX)
+
+# Installation directories (passed as CMake variables)
+set(AMG4PSBLAS_INSTALL_DIR "" CACHE PATH "Path to AMG installation")
+set(PSBLAS_INSTALL_DIR "" CACHE PATH "Path to PSBLAS installation")
+
+# Check if installation directories are set
+if(NOT AMG4PSBLAS_INSTALL_DIR)
+    message(FATAL_ERROR "AMG_INSTALL_DIR must be set.  Use -DAMG_INSTALL_DIR=/path/to/amg when running CMake.")
+endif()
+
+if(NOT PSBLAS_INSTALL_DIR)
+    message(FATAL_ERROR "PSBLAS_INSTALL_DIR must be set.  Use -DPSBLAS_INSTALL_DIR=/path/to/psblas when running CMake.")
+endif()
+
+
+find_package(psblas REQUIRED PATHS ${PSBLAS_INSTALL_DIR})
+find_package(amg4psblas REQUIRED PATHS ${AMG4PSBLAS_INSTALL_DIR})
+
+
+
+find_package(MPI REQUIRED Fortran CXX )
+
+if(MPI_FOUND)
+
+
+  if( (MPI_CXX_LINK_FLAGS MATCHES "noexecstack") OR (MPI_Fortran_LINK_FLAGS MATCHES "noexecstack") )
+    message ( WARNING
+      "The `noexecstack` linker flag was found in the MPI_<lang>_LINK_FLAGS variable. This is
+known to cause segmentation faults for some Fortran codes. See, e.g.,
+https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71729 or
+https://github.com/sourceryinstitute/OpenCoarrays/issues/317.
+
+`noexecstack` is being replaced with `execstack`"
+      )
+    string(REPLACE "noexecstack"
+      "execstack" MPI_CXX_LINK_FLAGS_FIXED ${MPI_CXX_LINK_FLAGS})
+    string(REPLACE "noexecstack"
+      "execstack" MPI_C_LINK_FLAGS_FIXED ${MPI_C_LINK_FLAGS})
+    string(REPLACE "noexecstack"
+      "execstack" MPI_Fortran_LINK_FLAGS_FIXED ${MPI_Fortran_LINK_FLAGS})
+    set(MPI_CXX_LINK_FLAGS "${MPI_CXX_LINK_FLAGS_FIXED}" CACHE STRING
+      "MPI CXX linking flags" FORCE)
+    set(MPI_C_LINK_FLAGS "${MPI_C_LINK_FLAGS_FIXED}" CACHE STRING
+      "MPI C linking flags" FORCE)
+    set(MPI_Fortran_LINK_FLAGS "${MPI_Fortran_LINK_FLAGS_FIXED}" CACHE STRING
+      "MPI Fortran linking flags" FORCE)
+      
+  endif()
+
+    message(STATUS "Found MPI: ${MPI_C_LIBRARIES} - ${MPI_CXX_LIBRARIES} - ${MPI_Fortran_LIBRARIES}")
+    
+    
+  #----------------
+  # Setup MPI compiler
+  #----------------  
+  set(CMAKE_C_COMPILER ${MPI_C_COMPILER} CACHE FILEPATH "C compiler" FORCE)
+  set(CMAKE_CXX_COMPILER ${MPI_CXX_COMPILER} CACHE FILEPATH "C++ compiler" FORCE)
+  set(CMAKE_Fortran_COMPILER ${MPI_Fortran_COMPILER} CACHE FILEPATH "Fortran compiler" FORCE)
+endif()
+
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    # Add -g to the Fortran compiler flags.
+    # We use STRING(APPEND) to ensure we don't overwrite other important flags.
+    string(APPEND CMAKE_Fortran_FLAGS " -g")
+    message(STATUS "Fortran debug flags added: -g")
+endif()
+
+# Include directories
+include_directories(
+    "."
+    "${AMG4PSBLAS_INSTALL_DIR}/include"
+    "${AMG4PSBLAS_INSTALL_DIR}/modules"
+    "${PSBLAS_INSTALL_DIR}/include"
+    "${PSBLAS_INSTALL_DIR}/modules"
+)
+
+# Fortran module directory
+set(CMAKE_Fortran_MODULE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/modules")
+set(FMFLAG "-I") 
+
+# Library directories
+link_directories(
+    "${AMG4PSBLAS_INSTALL_DIR}/lib"
+    "${PSBLAS_INSTALL_DIR}/lib"
+)
+
+# Libraries
+set(AMG_LIBS amg4psblas::amgprec)
+set(PSBLAS_LIBS  psblas::util psblas::linsolve psblas::prec psblas::base) 
+
+# Executable directory
+set(EXEDIR "${CMAKE_CURRENT_BINARY_DIR}/runs")
+file(MAKE_DIRECTORY "${EXEDIR}")
+
+set(COMMON_SOURCE data_input.f90)
+
+# Source files
+set(DFSOBJS ${COMMON_SOURCE} amg_df_sample.f90)
+set(SFSOBJS ${COMMON_SOURCE} amg_sf_sample.f90)
+set(CFSOBJS ${COMMON_SOURCE} amg_cf_sample.f90)
+set(ZFSOBJS ${COMMON_SOURCE} amg_zf_sample.f90)
+
+
+# Source files
+set(DGEN2D
+    amg_d_pde2d_poisson_mod.f90
+    amg_d_pde2d_exp_mod.f90
+    amg_d_pde2d_gauss_mod.f90
+    amg_d_pde2d_box_mod.f90
+)
+set(DGEN3D
+    amg_d_pde3d_poisson_mod.f90
+    amg_d_pde3d_exp_mod.f90
+    amg_d_pde3d_gauss_mod.f90
+    amg_d_pde3d_box_mod.f90
+)
+set(SGEN2D
+    amg_s_pde2d_poisson_mod.f90
+    amg_s_pde2d_exp_mod.f90
+    amg_s_pde2d_gauss_mod.f90
+    amg_s_pde2d_box_mod.f90
+)
+set(SGEN3D
+    amg_s_pde3d_poisson_mod.f90
+    amg_s_pde3d_exp_mod.f90
+    amg_s_pde3d_gauss_mod.f90
+    amg_s_pde3d_box_mod.f90
+)
+
+# Define executables and their sources
+set(amg_d_pde3d_SOURCES
+    ${COMMON_SOURCE} 
+    amg_d_pde3d.F90
+    amg_d_genpde_mod.F90
+    ${DGEN3D}
+)
+set(amg_s_pde3d_SOURCES
+    ${COMMON_SOURCE} 
+    amg_s_pde3d.F90
+    amg_s_genpde_mod.F90
+    ${SGEN3D}
+)
+set(amg_d_pde2d_SOURCES
+    ${COMMON_SOURCE} 
+    amg_d_pde2d.F90
+    amg_d_genpde_mod.F90
+    ${DGEN2D}
+)
+set(amg_s_pde2d_SOURCES
+    ${COMMON_SOURCE} 
+    amg_s_pde2d.F90
+    amg_s_genpde_mod.F90
+    ${SGEN2D}
+)
+
+
+
+
+# Function to create executable
+function(create_amg_executable target sources)
+    add_executable(${target} ${sources})
+    target_link_libraries(${target} PUBLIC
+        ${AMG_LIBS}
+        ${PSBLAS_LIBS}
+        ${MPI_LIBRARIES}
+    )
+
+    # Move executable to EXEDIR (post-build)
+    #add_custom_command(TARGET ${target} POST_BUILD
+    #    COMMAND ${CMAKE_COMMAND} -E move $<TARGET_FILE:${target}> ${EXEDIR}
+    #)
+    set_target_properties(${target} PROPERTIES
+        RUNTIME_OUTPUT_DIRECTORY ${EXEDIR}
+        LINKER_LANGUAGE Fortran
+        )
+endfunction()
+
+
+# Create executables
+create_amg_executable(amg_d_pde3d "${amg_d_pde3d_SOURCES}")
+create_amg_executable(amg_s_pde3d "${amg_s_pde3d_SOURCES}")
+create_amg_executable(amg_d_pde2d "${amg_d_pde2d_SOURCES}")
+create_amg_executable(amg_s_pde2d "${amg_s_pde2d_SOURCES}")
+
+# Create "runs" directory (if it doesn't exist)
+add_custom_target(create_runs_dir
+    COMMAND ${CMAKE_COMMAND} -E make_directory "${EXEDIR}"
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    COMMENT "Creating runs directory"
+)
+add_dependencies(amg_d_pde3d create_runs_dir)
+add_dependencies(amg_s_pde3d create_runs_dir)
+add_dependencies(amg_d_pde2d create_runs_dir)
+add_dependencies(amg_s_pde2d create_runs_dir)
+
+
+# lib target
+add_custom_target(lib
+    COMMAND ${CMAKE_COMMAND} -E chdir "../../" ${CMAKE_COMMAND} --build . --target library
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    COMMENT "Building library"
+)
+
+# verycleanlib target
+add_custom_target(verycleanlib
+    COMMAND ${CMAKE_COMMAND} -E chdir "../../" ${CMAKE_COMMAND} --build . --target veryclean
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    COMMENT "Cleaning library"
+)
+
+# Check target (simulated)
+add_custom_target(check
+    COMMAND ${CMAKE_COMMAND} -E chdir "${EXEDIR}" "${EXEDIR}/amg_d_pde2d" < "amg_pde2d.inp"
+    COMMAND ${CMAKE_COMMAND} -E chdir "${EXEDIR}" "${EXEDIR}/amg_s_pde2d" < "amg_pde2d.inp"
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    DEPENDS amg_d_pde2d amg_s_pde2d
+    COMMENT "Running check"
+)
+
+# Install target (optional)
+install(TARGETS
+    amg_d_pde3d
+    amg_s_pde3d
+    amg_d_pde2d
+    amg_s_pde2d
+    DESTINATION bin
+)
diff --git a/samples/simple/fileread/CMakeLists.txt b/samples/simple/fileread/CMakeLists.txt
new file mode 100644
index 00000000..a3e24f3e
--- /dev/null
+++ b/samples/simple/fileread/CMakeLists.txt
@@ -0,0 +1,129 @@
+cmake_minimum_required(VERSION 3.15)
+project(AMGExamples Fortran)
+
+# Installation directories (passed as CMake variables)
+set(AMG4PSBLAS_INSTALL_DIR "" CACHE PATH "Path to AMG installation")
+set(PSBLAS_INSTALL_DIR "" CACHE PATH "Path to PSBLAS installation")
+
+# Check if installation directories are set
+if(NOT AMG4PSBLAS_INSTALL_DIR)
+    message(FATAL_ERROR "AMG_INSTALL_DIR must be set.  Use -DAMG_INSTALL_DIR=/path/to/amg when running CMake.")
+endif()
+
+if(NOT PSBLAS_INSTALL_DIR)
+    message(FATAL_ERROR "PSBLAS_INSTALL_DIR must be set.  Use -DPSBLAS_INSTALL_DIR=/path/to/psblas when running CMake.")
+endif()
+
+
+find_package(psblas REQUIRED PATHS ${PSBLAS_INSTALL_DIR})
+find_package(amg4psblas REQUIRED PATHS ${AMG4PSBLAS_INSTALL_DIR})
+
+
+# Include directories
+include_directories(
+    "."
+    "${AMG4PSBLAS_INSTALL_DIR}/include"
+    "${AMG4PSBLAS_INSTALL_DIR}/modules"
+    "${PSBLAS_INSTALL_DIR}/include" 
+)
+
+# Fortran module directory
+set(CMAKE_Fortran_MODULE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/modules")
+set(FMFLAG "-I") 
+
+# Library directories
+link_directories(
+    "${AMG4PSBLAS_INSTALL_DIR}/lib"
+    "${PSBLAS_INSTALL_DIR}/lib"
+)
+
+# Libraries
+set(AMG_LIBS amg4psblas::amgprec)
+set(PSBLAS_LIBS  psblas::util psblas::linsolve psblas::prec psblas::base) 
+
+# Executable directory
+set(EXEDIR "${CMAKE_CURRENT_BINARY_DIR}/runs")
+file(MAKE_DIRECTORY "${EXEDIR}")
+
+set(COMMON_SOURCE data_input.f90)
+
+# Source files
+set(DMOBJS ${COMMON_SOURCE} amg_dexample_ml.f90)
+set(D1OBJS ${COMMON_SOURCE} amg_dexample_1lev.f90)
+set(ZMOBJS ${COMMON_SOURCE} amg_zexample_ml.f90)
+set(Z1OBJS ${COMMON_SOURCE} amg_zexample_1lev.f90)
+set(SMOBJS ${COMMON_SOURCE} amg_sexample_ml.f90)
+set(S1OBJS ${COMMON_SOURCE} amg_sexample_1lev.f90)
+set(CMOBJS ${COMMON_SOURCE} amg_cexample_ml.f90)
+set(C1OBJS ${COMMON_SOURCE} amg_cexample_1lev.f90)
+
+# Function to create executable
+macro(create_amg_executable target sources)
+    add_executable(${target} ${sources})
+    target_link_libraries(${target} PUBLIC
+        ${AMG_LIBS}
+        ${PSBLAS_LIBS}
+
+    )
+
+    # Move executable to EXEDIR (post-build)
+    #add_custom_command(TARGET ${target} POST_BUILD
+    #    COMMAND ${CMAKE_COMMAND} -E move $<TARGET_FILE:${target}> ${EXEDIR}
+    #)
+    set_target_properties(${target} PROPERTIES
+        RUNTIME_OUTPUT_DIRECTORY ${EXEDIR}
+        )
+endmacro()
+
+# Create executables
+create_amg_executable(amg_dexample_ml "${DMOBJS}")
+create_amg_executable(amg_dexample_1lev "${D1OBJS}")
+create_amg_executable(amg_zexample_ml "${ZMOBJS}")
+create_amg_executable(amg_zexample_1lev "${Z1OBJS}")
+create_amg_executable(amg_sexample_ml "${SMOBJS}")
+create_amg_executable(amg_sexample_1lev "${S1OBJS}")
+create_amg_executable(amg_cexample_ml "${CMOBJS}")
+create_amg_executable(amg_cexample_1lev "${C1OBJS}")
+
+# Create "runs" directory (if it doesn't exist)
+add_custom_target(create_runs_dir
+    COMMAND ${CMAKE_COMMAND} -E make_directory "${EXEDIR}"
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    COMMENT "Creating runs directory"
+)
+add_dependencies(amg_dexample_ml create_runs_dir)
+add_dependencies(amg_dexample_1lev create_runs_dir)
+add_dependencies(amg_zexample_ml create_runs_dir)
+add_dependencies(amg_zexample_1lev create_runs_dir)
+add_dependencies(amg_sexample_ml create_runs_dir)
+add_dependencies(amg_sexample_1lev create_runs_dir)
+add_dependencies(amg_cexample_ml create_runs_dir)
+add_dependencies(amg_cexample_1lev create_runs_dir)
+
+
+# lib target
+add_custom_target(lib
+    COMMAND ${CMAKE_COMMAND} -E chdir "../../" ${CMAKE_COMMAND} --build . --target library
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    COMMENT "Building library"
+)
+
+# verycleanlib target
+add_custom_target(verycleanlib
+    COMMAND ${CMAKE_COMMAND} -E chdir "../../" ${CMAKE_COMMAND} --build . --target veryclean
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    COMMENT "Cleaning library"
+)
+
+# Install target (optional)
+install(TARGETS
+    amg_dexample_ml
+    amg_dexample_1lev
+    amg_zexample_ml
+    amg_zexample_1lev
+    amg_sexample_ml
+    amg_sexample_1lev
+    amg_cexample_ml
+    amg_cexample_1lev
+    DESTINATION bin
+)
diff --git a/samples/simple/pdegen/CMakeLists.txt b/samples/simple/pdegen/CMakeLists.txt
new file mode 100644
index 00000000..025138ca
--- /dev/null
+++ b/samples/simple/pdegen/CMakeLists.txt
@@ -0,0 +1,114 @@
+cmake_minimum_required(VERSION 3.15)
+project(AMGExamples Fortran)
+
+# Installation directories (passed as CMake variables)
+set(AMG4PSBLAS_INSTALL_DIR "" CACHE PATH "Path to AMG installation")
+set(PSBLAS_INSTALL_DIR "" CACHE PATH "Path to PSBLAS installation")
+
+# Check if installation directories are set
+if(NOT AMG4PSBLAS_INSTALL_DIR)
+    message(FATAL_ERROR "AMG_INSTALL_DIR must be set.  Use -DAMG_INSTALL_DIR=/path/to/amg when running CMake.")
+endif()
+
+if(NOT PSBLAS_INSTALL_DIR)
+    message(FATAL_ERROR "PSBLAS_INSTALL_DIR must be set.  Use -DPSBLAS_INSTALL_DIR=/path/to/psblas when running CMake.")
+endif()
+
+
+find_package(psblas REQUIRED PATHS ${PSBLAS_INSTALL_DIR})
+find_package(amg4psblas REQUIRED PATHS ${AMG4PSBLAS_INSTALL_DIR})
+
+
+# Include directories
+include_directories(
+    "."
+    "${AMG4PSBLAS_INSTALL_DIR}/include"
+    "${AMG4PSBLAS_INSTALL_DIR}/modules"
+    "${PSBLAS_INSTALL_DIR}/include" 
+)
+
+# Fortran module directory
+set(CMAKE_Fortran_MODULE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/modules")
+set(FMFLAG "-I") 
+
+# Library directories
+link_directories(
+    "${AMG4PSBLAS_INSTALL_DIR}/lib"
+    "${PSBLAS_INSTALL_DIR}/lib"
+)
+
+# Libraries
+set(AMG_LIBS amg4psblas::amgprec)
+set(PSBLAS_LIBS  psblas::util psblas::linsolve psblas::prec psblas::base) 
+
+# Executable directory
+set(EXEDIR "${CMAKE_CURRENT_BINARY_DIR}/runs")
+file(MAKE_DIRECTORY "${EXEDIR}")
+
+set(COMMON_SOURCE data_input.f90)
+
+
+# Source files
+set(DMOBJS ${COMMON_SOURCE} amg_dexample_ml.f90 amg_dpde_mod.f90)
+set(D1OBJS ${COMMON_SOURCE} amg_dexample_1lev.f90 amg_dpde_mod.f90)
+set(SMOBJS ${COMMON_SOURCE} amg_sexample_ml.f90 amg_spde_mod.f90)
+set(S1OBJS ${COMMON_SOURCE} amg_sexample_1lev.f90 amg_spde_mod.f90)
+
+
+# Function to create executable
+macro(create_amg_executable target sources)
+    add_executable(${target} ${sources})
+    target_link_libraries(${target} PUBLIC
+        ${AMG_LIBS}
+        ${PSBLAS_LIBS}
+
+    )
+
+    # Move executable to EXEDIR (post-build)
+    #add_custom_command(TARGET ${target} POST_BUILD
+    #    COMMAND ${CMAKE_COMMAND} -E move $<TARGET_FILE:${target}> ${EXEDIR}
+    #)
+    set_target_properties(${target} PROPERTIES
+        RUNTIME_OUTPUT_DIRECTORY ${EXEDIR}
+        )
+endmacro()
+# Create executables
+create_amg_executable(amg_dexample_ml "${DMOBJS}")
+create_amg_executable(amg_dexample_1lev "${D1OBJS}")
+create_amg_executable(amg_sexample_ml "${SMOBJS}")
+create_amg_executable(amg_sexample_1lev "${S1OBJS}")
+
+# Create "runs" directory (if it doesn't exist)
+add_custom_target(create_runs_dir
+    COMMAND ${CMAKE_COMMAND} -E make_directory "${EXEDIR}"
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    COMMENT "Creating runs directory"
+)
+add_dependencies(amg_dexample_ml create_runs_dir)
+add_dependencies(amg_dexample_1lev create_runs_dir)
+add_dependencies(amg_sexample_ml create_runs_dir)
+add_dependencies(amg_sexample_1lev create_runs_dir)
+
+
+# lib target
+add_custom_target(lib
+    COMMAND ${CMAKE_COMMAND} -E chdir "../../" ${CMAKE_COMMAND} --build . --target library
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    COMMENT "Building library"
+)
+
+# verycleanlib target
+add_custom_target(verycleanlib
+    COMMAND ${CMAKE_COMMAND} -E chdir "../../" ${CMAKE_COMMAND} --build . --target veryclean
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    COMMENT "Cleaning library"
+)
+
+# Install target (optional)
+install(TARGETS
+    amg_dexample_ml
+    amg_dexample_1lev
+    amg_sexample_ml
+    amg_sexample_1lev
+    DESTINATION bin
+)