The SLAM (Simultaneous Localization and Mapping) packages in ROS (Robot Operating System) are quite sophisticated and typically involve several nodes communicating over ROS topics. The codes for these are extensive and cannot be fully covered in a brief message, but I can give you an overview of the common SLAM packages and a gist of how you would generally set them up and run them within the ROS ecosystem.

Common SLAM Packages in ROS:

1. gmapping: This is a widely used package for 2D SLAM. It uses a particle filter to keep track of the robot’s pose while creating a grid map of the environment.
2. Cartographer: This is a more recent package that supports both 2D and 3D SLAM. It can perform SLAM in real-time and is designed to work well with data from a variety of sensors.
3. hector_slam: This package is well suited for environments with flat floors and can perform SLAM with only laser scan data.
4. rtabmap_ros: This is used for 2D or 3D SLAM with visual features from RGB-D or stereo cameras.

Now using gmapping as example, first installation: sudo apt-get install ros–gmapping

Launch the SLAM node: roslaunch gmapping slam_gmapping.launch

This launch file starts the slam_gmapping node which subscribes to topics like /tf, /scan etc., to receive transformation data and laser scans.

3. Mapping: As your robot moves through the environment, gmapping will process the laser scan data and perform SLAM. The node will publish the map along with the transformations.
4. Saving Map: Once you have a satisfactory map, you can save it using the map_server package.

#!/usr/bin/env python
import rospy
from gmapping import SlamGMapping

def start_slam():
    rospy.init_node('slam_gmapping')

    # Create a SLAM object
    slam = SlamGMapping()
    
    # Assuming the robot is already being driven around and /scan topics are published
    # SlamGMapping will use the /tf and /scan topics to perform SLAM
    
    rospy.spin()  # Keep the program alive

if __name__ == '__main__':
    try:
        start_slam()
    except rospy.ROSInterruptException:
        pass

gmapping is usually executed as a compiled C++ node in ROS

Take a peek at the C++ codes:

#include "ros/ros.h"
#include "gmapping/slam_gmapping.h"
#include "signal.h"

// Signal-handling function for proper node shutdown
void sigintHandler(int sig) {
  // Your cleanup code here (if needed)
  ros::shutdown();
}

int main(int argc, char** argv) {
  // Initialize the ROS node
  ros::init(argc, argv, "slam_gmapping", ros::init_options::NoSigintHandler);
  signal(SIGINT, sigintHandler);

  // Create a node handle
  ros::NodeHandle n;

  // Parameters for gmapping can be loaded from parameter server
  // (e.g., private_nh.getParam(...))

  // Instantiate GMapping's wrapper
  SlamGMapping *slam_gmapping = new SlamGMapping();

  // Initialize gmapping
  slam_gmapping->init();

  // Start the mapping process
  slam_gmapping->startMapping();

  // Spin to process callbacks
  ros::spin();

  // Clean up
  delete slam_gmapping;

  return 0;
}