diff --git a/babs/babs.py b/babs/babs.py
index 4f50cdb4..af1745a5 100644
--- a/babs/babs.py
+++ b/babs/babs.py
@@ -2,7 +2,6 @@
 
 import os
 import os.path as op
-# from re import L
 import subprocess
 import warnings
 import pandas as pd
@@ -23,7 +22,6 @@
 
 from babs.utils import (get_immediate_subdirectories,
                         check_validity_unzipped_input_dataset,
-                        if_input_ds_from_osf,
                         generate_cmd_set_envvar,
                         generate_cmd_filterfile,
                         generate_cmd_singularityRun_from_config, generate_cmd_unzip_inputds,
@@ -40,10 +38,8 @@
                         get_list_sub_ses,
                         submit_one_job,
                         submit_one_test_job,
-                        create_job_status_csv,
                         read_job_status_csv,
                         report_job_status,
-                        request_job_status,
                         request_all_job_status,
                         calcu_runtime,
                         get_last_line,
@@ -55,7 +51,6 @@
                         get_git_show_ref_shasum,
                         ceildiv)
 
-# import pandas as pd
 
 # @build_doc
 class BABS():
@@ -483,11 +478,11 @@ def babs_bootstrap(self, input_ds,
         print("\nGenerating a template for job submission calls...")
         print("The template text file will be named as `submit_job_template.yaml`.")
         yaml_path = op.join(self.analysis_path, "code", "submit_job_template.yaml")
-        container.generate_job_submit_template(yaml_path, input_ds, self, system)
+        container.generate_job_submit_template(yaml_path, self, system)
 
         # also, generate template for testing job used by `babs-check-setup`:
         yaml_test_path = op.join(self.analysis_path, "code/check_setup", "submit_test_job_template.yaml")
-        container.generate_test_job_submit_template(yaml_test_path, self, system)
+        container.generate_job_submit_template(yaml_test_path, self, system, test=True)
 
         # datalad save:
         self.datalad_save(path=["code/submit_job_template.yaml",
@@ -888,7 +883,7 @@ def babs_check_setup(self, input_ds, flag_job_test):
                   " in the designated environment"
                   " and will make sure jobs can finish successfully on current cluster.")
 
-            _, job_id_str, log_filename = submit_one_test_job(self.analysis_path)
+            _, job_id_str, log_filename = submit_one_test_job(self.analysis_path, self.type_system)
             log_fn = op.join(self.analysis_path, "logs", log_filename)  # abs path
             o_fn = log_fn.replace(".*", ".o")
             # write this information in a YAML file:
@@ -913,7 +908,7 @@ def babs_check_setup(self, input_ds, flag_job_test):
                 time.sleep(60)   # Sleep for 60 seconds
 
                 # check the job status
-                df_all_job_status = request_all_job_status()
+                df_all_job_status = request_all_job_status(self.type_system)
                 d_now_str = str(datetime.now())
                 to_print = d_now_str + ": "
                 if job_id_str in df_all_job_status.index.to_list():
@@ -1051,6 +1046,7 @@ def babs_submit(self, count=1, df_job_specified=None):
                         if not df_job["has_submitted"][i_job]:  # to run
                             job_id, _, log_filename = submit_one_job(self.analysis_path,
                                                                      self.type_session,
+                                                                     self.type_system,
                                                                      sub, ses)
 
                             # assign into `df_job_updated`:
@@ -1100,6 +1096,7 @@ def babs_submit(self, count=1, df_job_specified=None):
                                 job_id, _, log_filename = \
                                     submit_one_job(self.analysis_path,
                                                    self.type_session,
+                                                   self.type_system,
                                                    sub, ses)
 
                                 # assign into `df_job_updated`:
@@ -1207,7 +1204,7 @@ def babs_status(self, flags_resubmit,
                 df_job_updated = df_job.copy()
 
                 # Get all jobs' status:
-                df_all_job_status = request_all_job_status()
+                df_all_job_status = request_all_job_status(self.type_system)
 
                 # For jobs that have been submitted but not successful yet:
                 # Update job status, and resubmit if requested:
@@ -1321,6 +1318,7 @@ def babs_status(self, flags_resubmit,
                                     job_id_updated, _, log_filename = \
                                         submit_one_job(self.analysis_path,
                                                        self.type_session,
+                                                       self.type_system,
                                                        sub, ses)
                                     # update fields:
                                     df_job_updated.at[i_job, "job_id"] = job_id_updated
@@ -1337,8 +1335,11 @@ def babs_status(self, flags_resubmit,
                                     df_job_updated.at[i_job, "job_state_category"] = state_category
                                     df_job_updated.at[i_job, "job_state_code"] = state_code
                                     # get the duration:
-                                    duration = calcu_runtime(
-                                        df_all_job_status.at[job_id_str, "JAT_start_time"])
+                                    if "duration" in df_all_job_status:
+                                        duration = df_all_job_status.at[job_id_str, "duration"]
+                                    else:
+                                        duration = calcu_runtime(
+                                            df_all_job_status.at[job_id_str, "JAT_start_time"])
                                     df_job_updated.at[i_job, "duration"] = duration
 
                                     # do nothing else, just wait
@@ -1364,6 +1365,7 @@ def babs_status(self, flags_resubmit,
                                     job_id_updated, _, log_filename = \
                                         submit_one_job(self.analysis_path,
                                                        self.type_session,
+                                                       self.type_system,
                                                        sub, ses)
                                     # update fields:
                                     df_job_updated.at[i_job, "job_id"] = job_id_updated
@@ -1402,6 +1404,7 @@ def babs_status(self, flags_resubmit,
                                     job_id_updated, _, log_filename = \
                                         submit_one_job(self.analysis_path,
                                                        self.type_session,
+                                                       self.type_system,
                                                        sub, ses)
                                     # update fields:
                                     df_job_updated.at[i_job, "job_id"] = job_id_updated
@@ -1449,6 +1452,7 @@ def babs_status(self, flags_resubmit,
                                 job_id_updated, _, log_filename = \
                                     submit_one_job(self.analysis_path,
                                                    self.type_session,
+                                                   self.type_system,
                                                    sub, ses)
 
                                 # update fields:
@@ -1467,7 +1471,7 @@ def babs_status(self, flags_resubmit,
                                     #   message found in log files:
                                     job_name = log_filename.split(".*")[0]
                                     msg_job_account = \
-                                        check_job_account(job_id_str, job_name, username_lowercase)
+                                        check_job_account(job_id_str, job_name, username_lowercase, self.type_system)
                                     df_job_updated.at[i_job, "job_account"] = msg_job_account
                 # Done: submitted jobs that not 'is_done'
 
@@ -1542,6 +1546,7 @@ def babs_status(self, flags_resubmit,
                         job_id_updated, _, log_filename = \
                             submit_one_job(self.analysis_path,
                                            self.type_session,
+                                           self.type_system,
                                            sub, ses)
                         # update fields:
                         df_job_updated.at[i_job, "job_id"] = job_id_updated
@@ -2800,22 +2805,24 @@ def generate_bash_test_job(self, folder_check_setup,
             )
         proc_chmod_pyfile.check_returncode()
 
-    def generate_job_submit_template(self, yaml_path, input_ds, babs, system):
+    def generate_job_submit_template(self, yaml_path, babs, system, test=False):
         """
         This is to generate a YAML file that serves as a template
-        of job submission of one participant (or session).
+        of job submission of one participant (or session),
+        or test job submission in `babs-check-setup`.
 
         Parameters:
         -------------
         yaml_path: str
             The path to the yaml file to be generated. It should be in the `analysis/code` folder.
             It has several fields: 1) cmd_template; 2) job_name_template
-        input_ds: class `Input_ds`
-            input dataset(s) information
         babs: class `BABS`
             information about the BABS project
         system: class `System`
             information on cluster management system
+        test: bool
+            flag to set to True if generating the test job submit template
+            for `babs-check-setup`.
         """
 
         # Section 1: Command for submitting the job: ---------------------------
@@ -2823,8 +2830,9 @@ def generate_job_submit_template(self, yaml_path, input_ds, babs, system):
         if system.type == "sge":
             submit_head = "qsub -cwd"
             env_flags = "-v DSLOCKFILE=" + babs.analysis_path + "/.SGE_datalad_lock"
-            eo_args = "-e " + babs.analysis_path + "/logs " \
-                + "-o " + babs.analysis_path + "/logs"
+        elif system.type == "slurm":
+            submit_head = "sbatch"
+            env_flags = "--export=DSLOCKFILE=" + babs.analysis_path + "/.SLURM_datalad_lock"
         else:
             warnings.warn("not supporting systems other than sge...")
 
@@ -2834,95 +2842,55 @@ def generate_job_submit_template(self, yaml_path, input_ds, babs, system):
 
         # Write into the bash file:
         yaml_file = open(yaml_path, "a")   # open in append mode
-        yaml_file.write("# '${sub_id}' and '${ses_id}' are placeholders." + "\n")
-
-        # Variables to use:
-        # `dssource`: Input RIA:
-        dssource = babs.input_ria_url + "#" + babs.analysis_dataset_id
-        # `pushgitremote`: Output RIA:
-        pushgitremote = babs.output_ria_data_dir
+        if not test:
+            yaml_file.write("# '${sub_id}' and '${ses_id}' are placeholders." + "\n")
+            # Variables to use:
+            # `dssource`: Input RIA:
+            dssource = babs.input_ria_url + "#" + babs.analysis_dataset_id
+            # `pushgitremote`: Output RIA:
+            pushgitremote = babs.output_ria_data_dir
 
         # Generate the command:
-        #   several rows in the text file; in between, to insert sub and ses id.
-        if babs.type_session == "single-ses":
-            cmd = submit_head + " " + env_flags \
-                + " -N " + self.container_name[0:3] + "_" + "${sub_id}"
-            cmd += " " \
-                + eo_args + " " \
-                + babs.analysis_path + "/code/participant_job.sh" + " " \
-                + dssource + " " \
-                + pushgitremote + " " + "${sub_id}"
-
-        elif babs.type_session == "multi-ses":
-            cmd = submit_head + " " + env_flags \
-                + " -N " + self.container_name[0:3] + "_" + "${sub_id}_${ses_id}"
-            cmd += " " \
-                + eo_args + " " \
-                + babs.analysis_path + "/code/participant_job.sh" + " " \
-                + dssource + " " \
-                + pushgitremote + " " + "${sub_id} ${ses_id}"
-
-        yaml_file.write("cmd_template: '" + cmd + "'" + "\n")
-
-        # TODO: currently only support SGE.
+        # TODO: TBD: adding below to `dict_cluster_systems.yaml` or another YAML file?
+        if system.type == "sge":
+            name_flag_str = " -N "
+        if system.type == "slurm":
+            name_flag_str = " --job-name "
 
         # Section 2: Job name: ---------------------------
-        job_name = self.container_name[0:3] + "_" + "${sub_id}"
-        if babs.type_session == "multi-ses":
-            job_name += "_${ses_id}"
-
-        yaml_file.write("job_name_template: '" + job_name + "'\n")
-
-        yaml_file.close()
-
-    def generate_test_job_submit_template(self, yaml_path, babs, system):
-        """
-        This is to generate a YAML file that serves as a template
-        of *test* job submission, which will be used in `babs-check-setup`.
-
-        Parameters:
-        ------------
-        yaml_path: str
-            The path to the yaml file to be generated.
-            It should be in the `analysis/code/check_setup` folder.
-            It has several fields: 1) cmd_template; 2) job_name_template
-        babs: class `BABS`
-            information about the BABS project
-        system: class `System`
-            information on cluster management system
-        """
+        # Job name:
+        if test:
+            job_name = self.container_name[0:3] + "_" + "test_job"
+        else:
+            job_name = self.container_name[0:3] + "_" + "${sub_id}"
+            if babs.type_session == "multi-ses":
+                job_name += "_${ses_id}"
 
-        # Section 1: Command for submitting the job: ---------------------------
-        # Flags when submitting the job:
+        # Now, we can define stdout and stderr file names/paths:
         if system.type == "sge":
-            submit_head = "qsub -cwd"
-            env_flags = "-v DSLOCKFILE=" + babs.analysis_path + "/.SGE_datalad_lock"
+            # sge clusters only need logs folder path; filename is not needed:
             eo_args = "-e " + babs.analysis_path + "/logs " \
                 + "-o " + babs.analysis_path + "/logs"
+        elif system.type == "slurm":
+            # slurm clusters also need exact filenames:
+            eo_args = "-e " + babs.analysis_path + f"/logs/{job_name}.e%A " \
+                + "-o " + babs.analysis_path + f"/logs/{job_name}.o%A"
+
+        # Generate the job submission command, with sub ID and ses ID as placeholders:
+        cmd = submit_head + " " + env_flags + name_flag_str + job_name + " " + eo_args + " "
+        if test:
+            cmd += babs.analysis_path + "/code/check_setup/call_test_job.sh"
         else:
-            warnings.warn("not supporting systems other than sge...")
-
-        # Check if the bash file already exist:
-        if op.exists(yaml_path):
-            os.remove(yaml_path)  # remove it
-
-        # Write into the bash file:
-        yaml_file = open(yaml_path, "a")   # open in append mode
-
-        # Generate the command:
-        cmd = submit_head + " " + env_flags \
-            + " -N " + self.container_name[0:3] + "_" + "test_job"
-        cmd += " " \
-            + eo_args + " " \
-            + babs.analysis_path + "/code/check_setup/call_test_job.sh"
+            # if test is False, the type of session will be checked
+            if babs.type_session == "single-ses":
+                cmd += babs.analysis_path + "/code/participant_job.sh" + " " \
+                    + dssource + " " \
+                    + pushgitremote + " " + "${sub_id}"
+            elif babs.type_session == "multi-ses":
+                cmd += babs.analysis_path + "/code/participant_job.sh" + " " \
+                    + dssource + " " \
+                    + pushgitremote + " " + "${sub_id} ${ses_id}"
 
         yaml_file.write("cmd_template: '" + cmd + "'" + "\n")
-
-        # TODO: currently only support SGE.
-
-        # Section 2: Job name: ---------------------------
-        job_name = self.container_name[0:3] + "_" + "test_job"
-
         yaml_file.write("job_name_template: '" + job_name + "'\n")
-
         yaml_file.close()
diff --git a/babs/dict_cluster_systems.yaml b/babs/dict_cluster_systems.yaml
index ff8bc04a..29392207 100644
--- a/babs/dict_cluster_systems.yaml
+++ b/babs/dict_cluster_systems.yaml
@@ -10,4 +10,11 @@ sge:
   soft_memory_limit: "-l s_vmem=$VALUE"   # "-l s_vmem=23.5G" on cubic
   temporary_disk_space: "-l tmpfree=$VALUE"   # "-l tmpfree=200G" on cubic
   number_of_cpus: "-pe threaded $VALUE"   # "-pe threaded N" or a range: "-pe threaded N-M", N<M on cubic
-  hard_runtime_limit: "-l h_rt=$VALUE"    # "-l h_rt=24:00:00" on cubic
\ No newline at end of file
+  hard_runtime_limit: "-l h_rt=$VALUE"    # "-l h_rt=24:00:00" on cubic
+slurm:
+  interpreting_shell: ""
+  hard_memory_limit: "--mem=$VALUE"
+  soft_memory_limit: ""
+  temporary_disk_space: "--tmp=$VALUE"   # "--tmp=20g" on MSI
+  number_of_cpus: "--cpus-per-task=$VALUE"
+  hard_runtime_limit: "--time=$VALUE"
\ No newline at end of file
diff --git a/babs/utils.py b/babs/utils.py
index 59a5f86a..0b3014e8 100644
--- a/babs/utils.py
+++ b/babs/utils.py
@@ -5,11 +5,8 @@
 import sys
 import warnings   # built-in, no need to install
 import pkg_resources
-# from ruamel.yaml import YAML
 import yaml
-import pprint
 import glob
-import regex
 import copy
 import pandas as pd
 import numpy as np
@@ -158,7 +155,7 @@ def validate_type_system(type_system):
     For valid ones, the type string will be changed to lower case.
     If not valid, raise error message.
     """
-    list_supported = ['sge']  # TODO: add 'slurm'
+    list_supported = ['sge', 'slurm']
     if type_system.lower() in list_supported:
         type_system = type_system.lower()   # change to lower case, if needed
     else:
@@ -659,8 +656,9 @@ def generate_one_bashhead_resources(system, key, value):
     """
     cmd = "#"
     if system.type == "sge":
-        cmd += "$ "
-    # TODO: add slurm's
+        cmd += "$ "    # e.g., `#$ -l h_vmem=xxx`
+    elif system.type == "slurm":
+        cmd += "SBATCH "   # e.g., `#SBATCH --xxx=yyy`
 
     # find the key in the `system.dict`:
     if key not in system.dict:
@@ -1312,7 +1310,7 @@ def get_list_sub_ses(input_ds, config, babs):
     elif babs.type_session == "multi-ses":
         return dict_sub_ses
 
-def submit_one_job(analysis_path, type_session, sub, ses=None,
+def submit_one_job(analysis_path, type_session, type_system, sub, ses=None,
                    flag_print_message=True):
     """
     This is to submit one job.
@@ -1323,6 +1321,8 @@ def submit_one_job(analysis_path, type_session, sub, ses=None,
         path to the `analysis` folder. One attribute in class `BABS`
     type_session: str
         multi-ses or single-ses
+    type_system: str
+        the type of job scheduling system, "sge" or "slurm"
     sub: str
         subject id
     ses: str or None
@@ -1372,8 +1372,16 @@ def submit_one_job(analysis_path, type_session, sub, ses=None,
                               stdout=subprocess.PIPE)
     proc_cmd.check_returncode()
     msg = proc_cmd.stdout.decode('utf-8')
-    # ^^ e.g., on cubic: Your job 2275903 ("test.sh") has been submitted
-    job_id_str = msg.split()[2]   # <- NOTE: this is HARD-CODED!
+
+    if type_system == "sge":
+        job_id_str = msg.split()[2]   # <- NOTE: this is HARD-CODED!
+        # e.g., on cubic: Your job 2275903 ("test.sh") has been submitted
+    elif type_system == "slurm":
+        job_id_str = msg.split()[-1]
+        # e.g., on MSI: 1st line is about the group; 2nd line: 'Submitted batch job 30723107'
+        # e.g., on MIT OpenMind: no 1st line from MSI; only 2nd line.
+    else:
+        raise Exception("type system can be slurm or sge")
     job_id = int(job_id_str)
 
     # log filename:
@@ -1386,7 +1394,7 @@ def submit_one_job(analysis_path, type_session, sub, ses=None,
     return job_id, job_id_str, log_filename
 
 
-def submit_one_test_job(analysis_path, flag_print_message=True):
+def submit_one_test_job(analysis_path, type_system, flag_print_message=True):
     """
     This is to submit one *test* job.
     This is used by `babs-check-setup`.
@@ -1395,6 +1403,8 @@ def submit_one_test_job(analysis_path, flag_print_message=True):
     ----------------
     analysis_path: str
         path to the `analysis` folder. One attribute in class `BABS`
+    type_system: str
+        the type of job scheduling system, "sge" or "slurm"
     flag_print_message: bool
         to print a message (True) or not (False)
 
@@ -1433,8 +1443,16 @@ def submit_one_test_job(analysis_path, flag_print_message=True):
 
     proc_cmd.check_returncode()
     msg = proc_cmd.stdout.decode('utf-8')
-    # ^^ e.g., on cubic: Your job 2275903 ("test.sh") has been submitted
-    job_id_str = msg.split()[2]   # <- NOTE: this is HARD-CODED!
+
+    if type_system == "sge":
+        job_id_str = msg.split()[2]   # <- NOTE: this is HARD-CODED!
+        # e.g., on cubic: Your job 2275903 ("test.sh") has been submitted
+    elif type_system == "slurm":
+        job_id_str = msg.split()[-1]
+        # e.g., on MSI: 1st line is about the group; 2nd line: 'Submitted batch job 30723107'
+        # e.g., on MIT OpenMind: no 1st line from MSI; only 2nd line.
+    else:
+        raise Exception("type system can be slurm or sge")
     job_id = int(job_id_str)
 
     # log filename:
@@ -1554,10 +1572,10 @@ def report_job_status(df, analysis_path, config_msg_alert):
         if total_is_done == total_jobs:
             print("All jobs are completed!")
         else:
-            total_pending = int((df['job_state_category'] == 'pending').sum())
+            total_pending = int((df['job_state_code'] == 'qw').sum())
             print(str(total_pending) + ' job(s) are pending;')
 
-            total_pending = int((df['job_state_category'] == 'running').sum())
+            total_pending = int((df['job_state_code'] == 'r').sum())
             print(str(total_pending) + ' job(s) are running;')
 
             # TODO: add stalled one
@@ -1623,14 +1641,15 @@ def report_job_status(df, analysis_path, config_msg_alert):
         print("\nAll log files are located in folder: "
               + op.join(analysis_path, "logs"))
 
-def request_all_job_status():
+def request_all_job_status(type_system):
     """
     This is to get all jobs' status
-    using e.g., `qstat` (for SGE clusters)
+    using `qstat` for SGE clusters and squeue for Slurm
 
     Parameters:
     --------------
-    TODO: add type_system!
+    type_system: str
+        the type of job scheduling system, "sge" or "slurm"
 
     Returns:
     --------------
@@ -1638,10 +1657,17 @@ def request_all_job_status():
         All jobs' status, including running and pending (waiting) jobs'.
         If there is no job in the queue, df will be an empty DataFrame
         (i.e., Columns: [], Index: [])
+    """
+    if type_system == "sge":
+        return _request_all_job_status_sge()
+    elif type_system == "slurm":
+        return _request_all_job_status_slurm()
 
-    Notes:
-    ----------------
-    SGE: using package [`qstat`](https://github.com/relleums/qstat)
+
+def _request_all_job_status_sge():
+    """
+    This is to get all jobs' status for SGE
+    using package [`qstat`](https://github.com/relleums/qstat)
     """
     queue_info, job_info = qstat()
     # ^^ queue_info: dict of jobs that are running
@@ -1663,26 +1689,54 @@ def request_all_job_status():
 
     return df
 
-def request_job_status(job_id):
-    """
-    This is to determine the job status
-    using e.g., `qstat` (for SGE clusters)
-    THIS IS DEPRECATED.
 
-    Parameters:
-    --------------
-    job_id: int
-        The job ID.
-        The data type is fixed when reading in the pd.dataframe of job status.
-    TODO: add type_system!
+def _request_all_job_status_slurm():
+    """
+    This is to get all jobs' status for Slurm
     """
-    proc_qstat = subprocess.run(
-        ["qstat", "-xml"],
+    username = get_username()
+    sacct_proc = subprocess.run(
+        ["squeue", "-u", username, "-o", "%.18i %.9P %.8j %.8u %.2t %T %.10M"],
         stdout=subprocess.PIPE
     )
-    proc_qstat.check_returncode()
-    msg = proc_qstat.stdout.decode('utf-8')
-    print(msg)
+    std = sacct_proc.stdout.decode('utf-8')
+
+    sacct_out_df = _parsing_sacct_out(std)
+    return sacct_out_df
+
+
+def _parsing_sacct_out(sacct_std):
+    header_l = sacct_std.splitlines()[0].split()
+    datarows = sacct_std.splitlines()[1:]
+
+    dict_ind = {"jobid": 0, "st": 4, "state": 5, "time": 6}
+    dict_val = dict((key, []) for key in dict_ind)
+
+
+    for fld in ["jobid", "st", "state", "time"]:
+        if header_l[dict_ind[fld]].lower() != fld:
+            raise Exception(f"error in the squeue output, expected {fld} and got {header_l[dict_ind[fld]].lower()}")
+
+    for row in datarows:
+        if "." not in row.split()[0]:
+            for key, ind in dict_ind.items():
+                dict_val[key].append(row.split()[ind])
+
+    # renaming the keys
+    dict_val["JB_job_number"] = dict_val.pop("jobid")
+    dict_val["@state"] =dict_val.pop("state")
+    dict_val["duration"] =dict_val.pop("time")
+
+
+    state_slurm2sge = {"R": "r", "PD": "qw"}
+    dict_val["state"] = [state_slurm2sge.get(sl_st, "NA") for sl_st in dict_val.pop("st")]
+
+    df = pd.DataFrame(data=dict_val)
+    if dict_val["JB_job_number"]:
+        df = df.set_index('JB_job_number')
+
+    return df
+
 
 def calcu_runtime(start_time_str):
     """
@@ -1909,10 +1963,10 @@ def get_username():
 
     return username_lowercase
 
-def check_job_account(job_id_str, job_name, username_lowercase):
+def check_job_account(job_id_str, job_name, username_lowercase, type_system):
     """
     This is to get information for a finished job
-    by calling job account command, e.g., `qacct` for SGE
+    by calling job account command, e.g., `qacct` for SGE, `sacct` for Slurm
 
     Parameters:
     ------------
@@ -1922,6 +1976,8 @@ def check_job_account(job_id_str, job_name, username_lowercase):
         Name of the job
     username_lowercase: str
         username that this job was requested to run
+    type_system: str
+        the type of job scheduling system, "sge" or "slurm"
 
     Returns:
     ------------
@@ -1939,6 +1995,43 @@ def check_job_account(job_id_str, job_name, username_lowercase):
     jobs under qw, r, etc, or does not exist (not submitted);
     Also, the current username should be the same one as that used for job submission.
     """
+    if type_system == "sge":
+        return _check_job_account_sge(job_id_str, job_name, username_lowercase)
+    elif type_system == "slurm":
+        return _check_job_account_slurm(job_id_str, job_name, username_lowercase)
+
+
+def _check_job_account_slurm(job_id_str, job_name, username_lowercase):
+    """
+    get information for a finished job in Slurm by calling `sacct`
+    """
+    proc_qacct = subprocess.run(
+        ["sacct", "-u", username_lowercase,
+         "-j", job_id_str],
+        stdout=subprocess.PIPE
+    )
+
+    proc_qacct.check_returncode()
+    msg_l = proc_qacct.stdout.decode('utf-8').split("\n")
+    msg_head = msg_l[0].split()
+    if "State" not in msg_head or "JobID" not in msg_head or "JobName" not in msg_head:
+        return "sacct doesn't provide information about the job"
+
+    st_ind = msg_head.index("State")
+    jobid_ind = msg_head.index("JobID")
+    jobnm_ind = msg_head.index("JobName")
+    job_saact = msg_l[2].split() # the 2nd row should have the main job
+
+    if job_saact[jobid_ind] != job_id_str or job_saact[jobnm_ind] != job_name:
+        return "sacct doesn't have the info for the specific job or the format is different"
+
+    return "sacct state: " + job_saact[st_ind]
+
+
+def _check_job_account_sge(job_id_str, job_name, username_lowercase):
+    """
+    get information for a finished job in SGE by calling `qacct`
+    """
     msg_no_alert_qacct_failed = "qacct: no alert message in field 'failed'"
     msg_failed_to_call_qacct = "BABS: failed to call 'qacct'"