diff --git a/README.md b/README.md
index 562f1778..6ef9aee0 100644
--- a/README.md
+++ b/README.md
@@ -5,6 +5,7 @@
 2.  [Data production](#dataprod)
     1.  [Skimming](#skim)
     2.  [Data sources](#sources)
+    3.  [Job Submission](#job-submission)
 3.  [Reconstruction Chain](#org0bc224d)
     1.  [Cluster Size Studies](#orgc33e2a6)
 4.  [Event Visualization](#org44a4071)
@@ -99,6 +100,66 @@ This framework relies on photon-, electron- and pion-gun samples produced via CR
 
 The `PU0` files above were merged and are stored under `/data_CMS/cms/alves/L1HGCAL/`, accessible to LLR users and under `/eos/user/b/bfontana/FPGAs/new_algos/`, accessible to all lxplus and LLR users. The latter is used since it is well interfaced with CERN services. The `PU200` files were merged and stored under `/eos/user/i/iehle/data/PU200/<particle>/`.
 
+<a id="job-submission"></a>
+## Job Submission
+
+Job submission to HT Condor is handled through `bye_splits/production/submit_scripts/job_submit.py` using the section of `config.yaml` for its configuration. The configuration should include usual condor variables, i.e `user`, `proxy`, `queue`, and `local`, as well as a path to the `script` you would like to run on condor. The `arguments` sub-section should contain `key/value` pairs matching the expected arguments that `script` accepts. You can also pass arguments directly in the command line, in which case these values will superseed the defaults set in the configuration file. The new `Arguments` class in `bye_splits/utils/job_helpers.py` verifies that the passed arguments are accepted by `script` and that all required arguments have assigned values. For now, this requires that `script` uses `Arguments` to import its arguments, using a dictionary called `arg_dict`; an example can be found in `tests/submission/dummy_submit.py`. The variable that you would like to iterate over should be set in `iterOver` and its value should correspond to a `key` in the `arguments` sub-section whose value is a list containing the values the script should iterate over. It then contains a section for each particle type which should contain a `submit_dir`, i.e. the directory in which to read and write submission related files, and `args_per_batch` which can be any number between 1 and `len(arguments[<iterOver>])`. An example of the `job` configuration settings is as such:
+
+```yaml
+job:
+    user: iehle
+    proxy: ~/.t3/proxy.cert
+    queue: short
+    local: False
+    script: /grid_mnt/vol_home/llr/cms/ehle/NewRepos/bye_splits/tests/submission/dummy_submit.py
+    iterOver: gen_arg
+    arguments:
+        float_arg: 0.11
+        str_arg: a_string
+        gen_arg: [gen, 3.14, work, broke, 9, False, 12.9, hello]
+    test:
+        submit_dir: /home/llr/cms/ehle/NewRepos/bye_splits/tests/submission/
+        args_per_batch: 2
+```
+
+After setting the configuration variables, the jobs are created and launched via
+
+    python bye_splits/production/submit_scripts/job_submit.py
+
+while will produce the executable `.sh` file in `<submit_dir>/subs/` that looks like:
+
+    #!/usr/bin/env bash
+    export VO_CMS_SW_DIR=/cvmfs/cms.cern.ch
+    export SITECONFIG_PATH=$VO_CMS_SW_DIR/SITECONF/T2_FR_GRIF_LLR/GRIF-LLR/
+    source $VO_CMS_SW_DIR/cmsset_default.sh
+    list=$1
+    cleaned_list=$(echo $list | tr -d '[]' | tr ';' '
+    ')
+    while IFS=";" read -r val; do
+        python /grid_mnt/vol_home/llr/cms/ehle/NewRepos/bye_splits/tests/submission/dummy_submit.py --gen_arg "$val" --float_arg 0.11 --str_arg a_string
+    done <<< "$cleaned_list"
+
+and the `.sub` file submitted to HT Condor in `<subdmit_dir>/jobs/` that looks like:
+
+    executable = /home/llr/cms/ehle/NewRepos/bye_splits/tests/submission/subs/dummy_submit_exec_v5.sh
+    Universe              = vanilla
+    Arguments = $(gen_arg) $(float_arg) $(str_arg)
+    output = /home/llr/cms/ehle/NewRepos/bye_splits/tests/submission/logs/dummy_submit_C$(Cluster)P$(Process).out
+    error = /home/llr/cms/ehle/NewRepos/bye_splits/tests/submission/logs/dummy_submit_C$(Cluster)P$(Process).err
+    log = /home/llr/cms/ehle/NewRepos/bye_splits/tests/submission/logs/dummy_submit_C$(Cluster)P$(Process).log
+    getenv                = true
+    T3Queue = short
+    WNTag                 = el7
+    +SingularityCmd       = ""
+    include: /opt/exp_soft/cms/t3/t3queue |
+    queue gen_arg, float_arg, str_arg from (
+    ['gen';3.14], 0.11, a_string
+    ['work';'broke'], 0.11, a_string
+    [9;False], 0.11, a_string
+    [12.9;'hello'], 0.11, a_string
+    )
+
+All logs, outputs, and errors are written to their respective files in `<submit_dir>/logs/`. Some primary uses of `job_submit.py` include running the [skimming procedure](#skimming), iterating over each particle type, and running the [cluster studies](#cluster-size-studies) over a list of radii.
 
 <a id="org0bc224d"></a>
 # Reconstruction Chain
@@ -120,33 +181,51 @@ The above will create `html` files with interactive outputs.
 
 ## Cluster Size Studies
 
-The script `bye_splits/scripts/cluster_size.py` reads a configuration file `bye_splits/scripts/cl_size_params.yaml` and runs the Reconstruction Chain on the `.root` inside corresponding to the chosen particle, where the clustering step is repeated for a range of cluster radii that is specified in the parameter file under `cl_size: Coeffs`.
-
-The most convenient way of running the study is to do:
-
-    bash run_cluster_size.sh <username>
-
-where `<username>` is your lxplus username, creating `.hdf5` files containing Pandas DFs containing cluster properties (notably energy, eta, phi) and associated gen-level particle information for each radius. The bash script acts as a wrapper for the python script, setting a few options that are convenient for the cluster size studies that are not the default options for the general reconstruction chain. As of now, the output `.hdf5` files will be written to your local directory using the structure:
-
-    ├── /<base_dir>
-    │            ├── out
-    │            ├── data
-    │            │   ├──new_algos
+The optimization of the clustering radius is done via the scripts in `bye_splits/scripts/cluster_size/`. The configuration is done in the `config.yaml` file under `clusterStudies`.
+The initial steps of the reconstruction chain (fill, smooth, seed) are run via
+
+    python run_init_tasks.py --pileup <PU0/PU200>
+
+which will produce the files required for `bye_splits/scripts/cluster_size/condor/run_cluster.py` (default value for `pileup==PU0`). One can run the script on a single radius:
+
+    python run_cluster.py --radius <float> --particles <photons/electrons/pions> --pileup <PU0/PU200>
+
+As the directory name suggests, `run_cluster.py` can and should be run as a `script` passed to an HTCondor job as described by [Job Submission](#job-submission) if you wish
+to run over all radii. The configuration would look something like this:
+
+```yaml
+job:
+user: iehle
+proxy: ~/.t3/proxy.cert
+queue: short
+local: False
+script: /grid_mnt/vol_home/llr/cms/ehle/NewRepos/bye_splits/bye_splits/scripts/cluster_size/condor/run_cluster.py
+iterOver: radius
+arguments:
+    radius: [0.001, 0.002, 0.003, 0.004, 0.005, 0.006, 0.007, 0.008, 0.009,
+            0.01 , 0.011, 0.012, 0.013, 0.014, 0.015, 0.016, 0.017, 0.018,
+            0.019, 0.02 , 0.021, 0.022, 0.023, 0.024, 0.025, 0.026, 0.027,
+            0.028, 0.029, 0.03 , 0.031, 0.032, 0.033, 0.034, 0.035, 0.036,
+            0.037, 0.038, 0.039, 0.04 , 0.041, 0.042, 0.043, 0.044, 0.045,
+            0.046, 0.047, 0.048, 0.049, 0.05]
+    particles: pions
+    pileup: PU0
+photons:
+    submit_dir: /data_CMS/cms/ehle/L1HGCAL/PU0/photons/
+    args_per_batch: 10
+electrons:
+    submit_dir: /data_CMS/cms/ehle/L1HGCAL/PU0/electrons/
+    args_per_batch: 10
+pions:
+    submit_dir: /data_CMS/cms/ehle/L1HGCAL/PU0/pions/
+    args_per_batch: 10
+```
 
-with the files ending up in `new_algos/`. Currently working on implementing an option to send the files directly to your `eos/` directory, assuming the structure:
+This will produce the output of `cluster.cluster_default()` for each radius. These files are then combined into one larger `.hdf5` file whose keys correspond to the various radii, and combined and normalized with the gen-level data via:
 
-    ├── /eos/user/<first_letter>/<username>
-    │                                   ├── out
-    │                                   ├── data
-    │                                   │   ├──PU0
-    │                                   │   │   ├──electrons
-    │                                   │   │   ├──photons
-    │                                   │   │   ├──pions
-    │                                   │   ├──PU200
-    │                                   │   │   ├──electrons
-    │                                   │   │   ├──photons
-    │                                   │   │   ├──pions
+    python run_combine.py
 
+The optional `--file` argument performs the combination and normalization with the gen-level data on only `<file>`.
 
 <a id="org44a4071"></a>
 
diff --git a/bye_splits/production/produce.cc b/bye_splits/production/produce.cc
deleted file mode 100644
index cef61f1f..00000000
--- a/bye_splits/production/produce.cc
+++ /dev/null
@@ -1,94 +0,0 @@
-#include <iostream>
-#include "include/skim.h"
-
-#include <stdio.h>  // for printf()
-#include <stdlib.h> // for strtol()
-#include <errno.h>  // for errno
-#include <limits.h> // for INT_MIN and INT_MAX
-#include <string.h>  // for strlen
-
-int convert_to_int(char** argv, int idx) {
-  char* p;
-  errno = 0; // not 'int errno', because the '#include' already defined it
-  long arg = strtol(argv[idx], &p, 10);
-  if (*p != '\0' || errno != 0) {
-	return 1; // In main(), returning non-zero means failure
-  }
-
-  if (arg < INT_MIN || arg > INT_MAX) {
-	return 1;
-  }
-  int arg_int = arg;
-
-  // Everything went well, print it as a regular number plus a newline
-  return arg_int;
-}
-
-void show_help(const po::options_description&, const std::string&);
-po::variables_map process_program_options(int argc, char **argv);
-
-void validate(po::variables_map args) {
-  std::string particles = args["particles"].as<string>();
-  if(!(particles=="photons" || particles=="electrons" || particles=="pions")) {
-    throw po::validation_error(po::validation_error::invalid_option_value, "particles");
-  }
-}
-
-void show_help(const po::options_description& desc,
-			   const std::string& topic = "") {
-  std::cout << desc << '\n';
-  if (topic != "") {
-	std::cout << "You asked for help on: " << topic << '\n';
-  }
-}
-
-po::variables_map process_program_options(int argc, char **argv)
-{
-  po::options_description desc("Usage");
-  desc.add_options()
-	("help,h",
-	 po::value<string>()->implicit_value("")
-	 ->notifier([&desc](const std::string &topic) {show_help(desc, topic);}),
-	 "Show help. If given, show help on the specified topic.")
-	("nevents", po::value<int>()->default_value(-1),
-	 "number of entries to consider, useful for debugging (-1 means all)")
-	("particles", po::value<string>()->required(),
-	 "type of particle");
-  
-  if (argc <= 1) {
-	show_help(desc); // does not return
-	exit( EXIT_SUCCESS );
-  }
-
-  po::variables_map args;
-  try {
-	po::store(po::parse_command_line(argc, argv, desc), args);
-  }
-  catch (po::error const& e) {
-	std::cerr << e.what() << '\n';
-	exit( EXIT_FAILURE );
-  }
-  po::notify(args);
-  validate(args);
-  return args;
-}
-
-//Run with ./produce.exe photons
-int main(int argc, char **argv) {
-  std::string dir = "/eos/user/b/bfontana/FPGAs/new_algos/";
-  std::string tree_name = "FloatingpointMixedbcstcrealsig4DummyHistomaxxydr015GenmatchGenclustersntuple/HGCalTriggerNtuple";
-
-  po::variables_map args = process_program_options(argc, argv);
-  if (args.count("help")) {
-    return 1;
-  }
-
-  string particles = args["particles"].as<string>();
-  int nevents = args["nevents"].as<int>();
-
-  std::string infile = particles + "_0PU_bc_stc_hadd.root";
-  std::string events_str = nevents > 0 ? std::to_string(nevents) + "events_" : "";
-  std::string outfile = "skim_" + events_str + infile;
-  skim(tree_name, dir + infile, dir + outfile, particles, nevents);
-  return 0;
-}
diff --git a/bye_splits/production/submit_scripts/job_submit.py b/bye_splits/production/submit_scripts/job_submit.py
new file mode 100644
index 00000000..ddc114a9
--- /dev/null
+++ b/bye_splits/production/submit_scripts/job_submit.py
@@ -0,0 +1,270 @@
+#!/usr/bin/env python
+
+import os
+import sys
+
+parent_dir = os.path.abspath(__file__ + 5 * "../")
+sys.path.insert(0, parent_dir)
+
+from bye_splits.utils import params, common, job_helpers
+from bye_splits.utils.job_helpers import Arguments
+
+from datetime import datetime
+import re
+import subprocess
+import argparse
+import yaml
+
+class JobBatches:
+    """Class for setting up job batches and setting configuration
+    variables. The function setup_batches() will take the list in
+    config[arguments[<iterOver>]] and return a list of lists containing
+    <args_per_batch> values in each sublist. Example for five total values
+    with <args_per_batch> = 2:
+    [0.01, 0.02, 0.03, 0.04, 0.05] --> [[0.01, 0.02], [0.03, 0.04], [0.05]]"""
+
+    def __init__(self, particle, config):
+        self.particle = particle
+        self.config   = config
+        self.iterOver = config["job"]["iterOver"]
+        self.particle_var = lambda part, var: config["job"][part][var]
+
+    def setup_batches(self):
+        total_vals = self.config["job"]["arguments"][self.iterOver]
+
+        vals_per_batch = self.particle_var(self.particle, "args_per_batch")    
+
+        batches = [total_vals[i: i + vals_per_batch] for i in range(0, len(total_vals), vals_per_batch)]
+        
+        return batches
+    
+class CondJobBase:
+    def __init__(self, particle, config):
+        self.script       = config["job"]["script"]
+        self.queue        = config["job"]["queue"]
+        self.proxy        = config["job"]["proxy"]
+        self.local        = config["job"]["local"]
+        self.user         = config["job"]["user"]
+
+        self.true_args    = Arguments(self.script)
+        self.default_args = {}
+        for arg, val in config["job"]["arguments"].items():
+            self.default_args["--"+arg] = val
+        self.combined_args = self.true_args.verify_args(self.default_args)
+
+        if "--particles" in self.combined_args:
+            self.particle = self.combined_args["--particles"]
+        else:
+            self.particle     = particle
+
+        self.batch        = JobBatches(particle, config)
+        self.particle_dir = self.batch.particle_var(self.particle, "submit_dir")
+        self.iterOver     = "--"+config["job"]["iterOver"]
+        self.batches      = self.batch.setup_batches()
+
+    def _get_condor_args(self):
+        condor_args   = []
+        for arg in self.combined_args:
+            if "action" in self.true_args.accepted_args[arg] and self.true_args.accepted_args[arg]["action"]=="store_true":
+                continue
+            else:
+                condor_args.append(arg.replace("--", ""))
+        
+        return condor_args
+
+    def _write_arg_values(self, current_version):
+        """Adds the argument values, where the batch lists are converted
+        to strings as [val_1, val_2, ...] --> "[val_1;val_2]".
+        The choice of a semicolon as the delimiter is arbitrary but it
+        cannot be a comma because this is the delimeter condor itself uses.
+
+        Example:
+
+        queue radius, particle from (
+        [0.01, 0.02], photon
+        )
+        incorrectly assigns radius="[0.01", particle="0.02]"
+
+        queue radius, particle from (
+            [0.01;0.02], photon
+        )
+        correctly assigns radius="[0.01, 0.02]", particle="photon"
+        """
+        
+        condor_args = self._get_condor_args()
+
+        arg_keys = "queue " + ", ".join(condor_args) + " from (\n"
+        current_version.append(arg_keys)
+        
+        batch_strs = [str(batch).replace(", ", ";") for batch in self.batches]
+        
+        for batch in batch_strs:
+            inner_test = []
+            for key, val in self.combined_args.items():
+                if "action" in self.true_args.accepted_args[key] and self.true_args.accepted_args[key]["action"]=="store_true":
+                    continue
+                else:
+                    if key != self.iterOver:
+                        inner_test.append(val)
+                    else:
+                        inner_test.append(batch)
+            inner_test = ", ".join(map(str, inner_test)) + "\n"
+            current_version.append(inner_test)
+        
+        current_version.append(")")
+
+    def write_exec_file(self):
+        """Writes the .sh file that the condor .sub file runs as the
+        <executable>. This constitutes a few common exports and sourcing,
+        and follows by writing the Python call to <script>, passing the given
+        arguments and values. The contents of this file is written to a buffer
+        list first, and conditional_write() will check the contents of other scripts
+        in the same directory that contain the same basename. If an identical script
+        already exists, will use this script. Otherwise, it will increment the version
+        number (<script_name> + _v<#>). If no versions exist, the v0 version will be written."""
+
+        script_dir, script_name = os.path.split(self.script)
+        basename, ext = os.path.splitext(script_name)
+        
+        sub_dir = os.path.join(self.particle_dir, "subs/")
+
+        common.create_dir(sub_dir)
+
+        script_basename = os.path.basename(self.script).replace(".sh", "").replace(".py", "")
+
+        exec_file_name_template = "{}{}_exec.sh".format(sub_dir, script_basename)
+        exec_file_versions = job_helpers.grab_most_recent(exec_file_name_template, return_all=True)
+
+        current_version = []
+        current_version.append("#!/usr/bin/env bash\n")
+        current_version.append("export VO_CMS_SW_DIR=/cvmfs/cms.cern.ch\n")
+        current_version.append("export SITECONFIG_PATH=$VO_CMS_SW_DIR/SITECONF/T2_FR_GRIF_LLR/GRIF-LLR/\n")
+        current_version.append("source $VO_CMS_SW_DIR/cmsset_default.sh\n")
+        
+        condor_args = self._get_condor_args()
+        if self.iterOver is not None:
+            iter_arg_pos = condor_args.index(self.iterOver.replace("--", ""))
+            current_version.append('list=${}\n'.format(iter_arg_pos + 1))
+
+            current_version.append("cleaned_list=$(echo $list | tr -d '[]' | tr ';' '\n')\n")
+            current_version.append('while IFS=";" read -r val; do\n')
+
+            batch_strs = [str(batch).replace(", ", ";") for batch in self.batches]
+
+            self.default_args[self.iterOver] = '"$val"'
+            
+
+            """write_comm() combines default_args with the command-line arguments,
+            verifies that they're accepted by the script, and then returns the python command."""
+            python_call = "    " + " ".join(self.true_args.write_comm(self.default_args)) + "\n"
+
+            current_version.append(python_call)
+            current_version.append('done <<< "$cleaned_list"')
+
+        else:
+            python_call = 'python {}'.format(self.script)
+
+            for arg in sub_args:
+                python_call +=' --{} {}'.format(arg, self.default_args[arg])   
+
+            current_version.append(python_call)
+
+        self.sub_file = job_helpers.conditional_write(exec_file_versions, exec_file_name_template, current_version)
+
+    def write_sub_file(self):
+        """Writes the .sub script that is submitted to HT Condor.
+        Follows the same naming convention and conditional_write()
+        procedure as the previous function."""
+
+        log_dir = os.path.join(self.particle_dir, "logs/")
+
+        script_basename = os.path.basename(self.script).replace(".sh", "").replace(".py", "")
+
+        job_file_name_template = "{}/jobs/{}.sub".format(self.particle_dir, script_basename)
+
+        job_file_versions = job_helpers.grab_most_recent(job_file_name_template, return_all=True)
+
+        current_version = []
+        current_version.append("executable = {}\n".format(self.sub_file))
+        current_version.append("Universe              = vanilla\n")
+
+        arg_keys = "Arguments ="
+        condor_args = self._get_condor_args()
+        for arg in self._get_condor_args():
+            arg_keys += " $({})".format(arg)
+        arg_keys += "\n"
+
+        current_version.append(arg_keys)          
+
+        current_version.append("output = {}{}_C$(Cluster)P$(Process).out\n".format(log_dir, script_basename))
+        current_version.append("error = {}{}_C$(Cluster)P$(Process).err\n".format(log_dir, script_basename))
+        current_version.append("log = {}{}_C$(Cluster)P$(Process).log\n".format(log_dir, script_basename))
+        current_version.append("getenv                = true\n")
+        current_version.append("T3Queue = {}\n".format(self.queue))
+        current_version.append("WNTag                 = el7\n")
+        current_version.append('+SingularityCmd       = ""\n')
+        current_version.append("include: /opt/exp_soft/cms/t3/t3queue |\n")
+        
+        if len(self.default_args.keys()) > 0:
+            self._write_arg_values(current_version)
+
+        # Write the file only if an identical file doesn't already exist
+        self.submission_file = job_helpers.conditional_write(job_file_versions, job_file_name_template, current_version) # Save to launch later
+
+class CondJob:
+    """Creates the job directories and files
+    with prepare_jobs() and runs the jobs with
+    launch_jobs()."""
+
+    def __init__(self, particle, config):
+        self.base = CondJobBase(particle=particle, config=config)
+
+    def prepare_jobs(self):
+
+        for d in ("jobs", "logs"):
+            d = os.path.join(self.base.particle_dir, d)
+            common.create_dir(d)
+
+        self.base.write_exec_file()
+        self.base.write_sub_file()
+
+    def launch_jobs(self):
+
+        if self.base.local:
+            machine = "local"
+        else:
+            machine = "llrt3.in2p3.fr"
+
+        sub_comm = ["condor_submit"]
+
+        if not self.base.local:
+            print(
+                "\nSending {} jobs on {}".format(self.base.particle, self.base.queue + "@{}".format(machine))
+            )
+            print("===============")
+            print("\n")
+
+        sub_args = []
+
+        sub_args.append(self.base.submission_file)
+
+        if self.base.local:
+            comm = sub_args
+        else:
+            comm = sub_comm + sub_args
+
+        print(str(datetime.now()), " ".join(comm))
+        subprocess.run(comm)
+
+if __name__ == "__main__":    
+    with open(params.CfgPath, "r") as afile:
+        config = yaml.safe_load(afile)
+
+    job = CondJob("test", config)
+    job.prepare_jobs()
+    job.launch_jobs()
+
+    '''for particle in ("photons", "electrons", "pions"):
+        job = CondJob(particle, config)
+        job.prepare_jobs()
+        job.launch_jobs()'''
\ No newline at end of file
diff --git a/bye_splits/scripts/cluster_size/condor/run_cluster.py b/bye_splits/scripts/cluster_size/condor/run_cluster.py
new file mode 100644
index 00000000..26b9abc2
--- /dev/null
+++ b/bye_splits/scripts/cluster_size/condor/run_cluster.py
@@ -0,0 +1,87 @@
+# coding: utf-8
+
+_all_ = ['cluster_radius']
+
+import os
+import sys
+
+parent_dir = os.path.abspath(__file__ + 4 * "/..")
+sys.path.insert(0, parent_dir)
+
+import tasks
+from utils import params, common, parsing, cl_helpers
+from utils.job_helpers import Arguments
+
+import numpy as np
+import pandas as pd
+import yaml
+
+arg_dict = {
+    "--radius": {
+        "help": "Coefficient to use as the max cluster radius",
+        "required": True,
+        "type": float
+    },
+    "--particles": {
+        "choices": ("photons", "electrons", "pions"),
+        "required": True
+    }, 
+    "--pileup": {
+        "help": "tag for PU200 vs PU0",
+        "choices": ("PU0", "PU200"),
+        "required": True
+    },
+    "--weighted": {
+        "help": "Apply pre-calculated layer weights",
+        "action": "store_true"
+    }
+}
+
+def cluster_radius(pars, cfg):
+    """Runs the default clustering algorithm using the
+    specified radius. Runs on both negative and positive
+    eta files, and adds layer weights to the cluster
+    kwargs if specified."""
+    
+    cluster_d = params.read_task_params("cluster")
+
+    particles = pars["particles"]
+    pileup = pars["pileup"]
+    radius = pars["radius"]
+
+    cl_size_radius = "{}_radius_{}".format(
+        cfg["clusterStudies"]["clusterSizeBaseName"],
+        str(round(radius, 3)).replace(".", "p"),
+    )
+    cluster_d["ClusterOutPlot"], cluster_d["ClusterOutValidation"] = cl_size_radius, cl_size_radius+"_valid"
+    cluster_d["CoeffA"] = [radius] * (cfg["geometry"]["nlayersCEE"]+cfg["geometry"]["nlayersCEH"]) # Radii in each of the HGCAL layers
+    
+    if "weights" in cfg:
+        cluster_d["weights"] = cfg["weights"]
+
+    for eta_tag in ("negEta", "posEta"):
+        for key in ("ClusterInTC", "ClusterInSeeds", "ClusterOutPlot", "ClusterOutValidation"):
+            name = cluster_d[key]
+
+            cluster_d[key] =  "{}_{}_{}_{}".format(particles, pileup, name, eta_tag)
+        
+        nevents_end = tasks.cluster.cluster_default(pars, **cluster_d)
+
+if __name__ == "__main__":
+
+    args = Arguments(script=__file__)
+    FLAGS = args.add_args(description="Cluster size script.", arg_dict=arg_dict)
+    pars = common.dot_dict(FLAGS)
+
+    radius_str = round(pars.radius, 3)
+
+    with open(params.CfgPath, "r") as afile:
+        cfg = yaml.safe_load(afile)
+
+    if pars.weighted:
+        weight_dir = os.path.join(params.LocalStorage, "PU0/")
+        weights_by_particle = cl_helpers.read_weights(weight_dir, cfg)
+        weights = weights_by_particle[pars.particles][radius_str]
+        cfg["weights"] = weights
+
+    cluster_radius(pars, cfg)
\ No newline at end of file
diff --git a/bye_splits/scripts/cluster_size/run_combine.py b/bye_splits/scripts/cluster_size/run_combine.py
new file mode 100644
index 00000000..33bfba39
--- /dev/null
+++ b/bye_splits/scripts/cluster_size/run_combine.py
@@ -0,0 +1,142 @@
+# coding: utf-8
+
+_all_ = ['split_dfs', 'combine_normalize', 'combine_files_by_coef', 'split_and_norm', 'combine_cluster']
+
+import os
+import sys
+
+parent_dir = os.path.abspath(__file__ + 3 * "/..")
+sys.path.insert(0, parent_dir)
+
+from utils import params, common, parsing
+from data_handle.data_process import get_data_reco_chain_start
+
+import argparse
+import re
+import numpy as np
+import pandas as pd
+import yaml
+from tqdm import tqdm
+
+def split_dfs(cl_df):
+    """Splits the dataframe created by cluster() into an
+    unweighted dataframe and a weighted dataframe."""
+
+    weighted_cols = [col for col in cl_df.keys() if "weighted" in col]
+    weighted_cols += [col for col in cl_df.keys() if "layer" in col]
+    original_cols = [col.replace("weighted_","") for col in weighted_cols]
+    weighted_cols += ["event"]
+    original_cols += ["event"]
+
+    original_df = cl_df[original_cols]
+    weighted_df = cl_df[weighted_cols].rename(dict(zip(weighted_cols, original_cols)), axis=1)
+
+    return original_df, weighted_df
+
+def combine_normalize(cl_df, gen_df, dRThresh):
+    """Combines a cluster dataframe with an associated
+    gen-level dataframe. Useful variables that may or may not
+    be present are added to the combined dataframe before
+    normalized energy and pt columns are added."""
+
+    cl_df=cl_df.reset_index().set_index(["event","seed_idx"])
+    combined_df = cl_df.join(
+        gen_df.set_index("event"), on="event", how="inner"
+    )
+
+    if "dR" not in combined_df.keys():
+        combined_df["dR"] = np.sqrt((abs(combined_df["eta"])-abs(combined_df["gen_eta"]))**2+(combined_df["phi"]-combined_df["gen_phi"])**2)
+    if "matches" not in combined_df.keys():
+        combined_df["matches"] = combined_df["dR"] <= dRThresh
+
+    combined_df["pt"] = combined_df["en"] / np.cosh(combined_df["eta"])
+    combined_df["gen_pt"] = combined_df["gen_en"] / np.cosh(combined_df["gen_eta"])
+
+    combined_df["pt_norm"] = combined_df["pt"] / combined_df["gen_pt"]
+    combined_df["en_norm"] = combined_df["en"] / combined_df["gen_en"]
+
+    return combined_df
+
+def combine_files_by_coef(in_dir, file_pattern):
+    """Combines .hdf5 cluster files of individual
+    radii into one .hdf5 file containing dataframes
+    for all radii."""
+
+    files = [
+        file for file in os.listdir(in_dir) if re.search(file_pattern, file) is not None and "valid" not in file
+    ]
+    coef_pattern = r"coef_0p(\d+)"
+    out_path = common.fill_path(file_pattern, data_dir=in_dir)
+    with pd.HDFStore(out_path, "w") as clusterSizeOut:
+        print("\nCombining Files:\n")
+        for file in tqdm(files):
+            key = re.search(coef_pattern, file).group()
+            with pd.HDFStore(in_dir + "/" + file, "r") as clSizeCoef:
+                clusterSizeOut[key] = clSizeCoef["/data"]
+
+def split_and_norm(df_cl, df_gen, dRthresh):
+    o_df, w_df = split_dfs(df_cl)
+    normed_df, normed_w_df = combine_normalize(o_df, df_gen, dRthresh), combine_normalize(w_df, df_gen, dRthresh)
+    df_dict = {"original": normed_df,
+                "weighted": normed_w_df}
+    return pd.Series(df_dict)
+
+def combine_cluster(cfg, **pars):
+    """Originally designed to combine the files returned by cluster for each radii,
+    and to normalize each by the gen_particle information. Now accepts an optional --file
+    parameter to normalize this, skipping the combinination step."""
+
+    input_file_path = pars["file"] if "file" in pars.keys() else None
+    unweighted = pars["unweighted"] if "unweighted" in pars.keys() else False
+
+    particles = cfg["particles"]
+    nevents = pars.nevents
+
+    if input_file_path is None:
+        pileup = "PU0" if not cfg["clusterStudies"]["pileup"] else "PU200"
+
+        basename = cfg["clusterStudies"]["combination"][pileup][particles]["basename"]
+        sub_dir = cfg["clusterStudies"]["combination"][pileup][particles]["sub_dir"]
+
+        dir = "{}/{}/{}".format(params.LocalStorage, pileup, sub_dir)
+
+        combine_files_by_coef(dir, basename)
+
+        cl_size_out = common.fill_path(basename, data_dir=dir)
+
+    else:
+        cl_size_out = input_file_path
+
+    with pd.HDFStore(cl_size_out, mode="a") as clSizeOut:
+        df_gen, _, _ = get_data_reco_chain_start(
+            particles=particles, nevents=nevents, reprocess=False, tag = cfg["clusterStudies"]["parquetTag"]
+        )
+        if "negEta" in cl_size_out:
+            df_gen = df_gen[ df_gen.gen_eta < 0 ]
+            df_gen["gen_eta"] = abs(df_gen.gen_eta)
+        else:
+            df_gen = df_gen[ df_gen.gen_eta > 0 ]
+        dRthresh = cfg["selection"]["deltarThreshold"]
+        if input_file_path is not None:
+            clSizeOut["data"] = split_and_norm(clSizeOut["data"], df_gen, dRthresh) if not unweighted else combine_normalize(clSizeOut["data"], df_gen, dRthresh)
+        else:
+            coef_keys = clSizeOut.keys()
+            print("\nNormalizing Files:\n")
+            for coef in tqdm(coef_keys):
+                clSizeOut[coef] = split_and_norm(clSizeOut[coef], df_gen, dRthresh) if not unweighted else combine_normalize(clSizeOut[coef], df_gen, dRthresh)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="")
+    parser.add_argument("--file", type=str)
+    parser.add_argument("--unweighted", action="store_true")
+    parsing.add_parameters(parser)
+
+    FLAGS = parser.parse_args()
+    pars = common.dot_dict(vars(FLAGS))
+
+    with open(params.CfgPath, "r") as afile:
+        cfg = yaml.safe_load(afile)
+
+    for particles in ("photons", "electrons", "pions"):
+        cfg.update({"particles": particles})
+        combine_cluster(cfg, pars)
\ No newline at end of file
diff --git a/bye_splits/scripts/cluster_size/run_init_tasks.py b/bye_splits/scripts/cluster_size/run_init_tasks.py
new file mode 100644
index 00000000..c312f3bc
--- /dev/null
+++ b/bye_splits/scripts/cluster_size/run_init_tasks.py
@@ -0,0 +1,83 @@
+# coding: utf-8
+
+_all_ = ['start_chain']
+
+import os
+import sys
+
+parent_dir = os.path.abspath(__file__ + 3 * "/..")
+sys.path.insert(0, parent_dir)
+
+import tasks
+from utils import params, common, parsing
+from data_handle.data_process import get_data_reco_chain_start
+
+import argparse
+import random
+import yaml
+
+def start_chain(pars, cfg):
+    """Runs the first three steps of the TPG on
+    negative and positive eta samples."""
+
+    particles = cfg["selection"]["particles"]
+    reprocess = cfg["clusterStudies"]["reprocess"]
+    tag       = cfg["clusterStudies"]["parquetTag"]
+    nevents   = pars.nevents
+    pileup    = pars.pileup
+
+    df_gen, df_cl, df_tc = get_data_reco_chain_start(
+        particles=particles, nevents=nevents, reprocess=reprocess, tag=tag
+    )
+
+    df_gen_pos, df_gen_neg = df_gen[ df_gen.gen_eta > 0 ], df_gen[ df_gen.gen_eta < 0 ]
+    df_cl_pos, df_cl_neg   = df_cl[ df_cl.cl3d_eta > 0 ],  df_cl[ df_cl.cl3d_eta < 0 ]
+    df_tc_pos, df_tc_neg   = df_tc[ df_tc.tc_eta > 0 ],    df_tc[ df_tc.tc_eta < 0 ]
+
+    eta_dict = {"negEta": {"df_gen": df_gen_neg,
+                           "df_cl": df_cl_neg,
+                           "df_tc": df_tc_neg},
+                "posEta": {"df_gen": df_gen_pos,
+                           "df_cl": df_cl_pos,
+                           "df_tc": df_tc_pos}  
+                }
+
+    for eta_tag, dfs in eta_dict.items():
+        df_gen, df_cl, df_tc = dfs.values()
+
+        if eta_tag=="negEta":
+            df_gen["gen_eta"], df_cl["cl3d_eta"], df_tc["tc_eta"], df_tc["tc_z"] = abs(df_gen.gen_eta), abs(df_cl.cl3d_eta), abs(df_tc.tc_eta), abs(df_tc.tc_z)
+
+        print(f"{particles}: {eta_tag}")
+
+        fill_d = params.read_task_params("fill")
+        for key in ("FillOut", "FillOutGenCl", "FillOutTcAll"):
+            name = fill_d[key]
+            fill_d[key] = "{}_{}_{}_{}".format(particles, pileup, name, eta_tag)
+        tasks.fill.fill(pars, df_gen, df_cl, df_tc, **fill_d)
+
+        smooth_d = params.read_task_params("smooth")
+        for key in ("SmoothIn", "SmoothOut"):
+            name = smooth_d[key]
+            smooth_d[key] =  "{}_{}_{}_{}".format(particles, pileup, name, eta_tag)
+        tasks.smooth.smooth(pars, **smooth_d)
+
+        seed_d = params.read_task_params("seed")
+        for key in ("SeedIn", "SeedOut"):
+            name = seed_d[key]
+            seed_d[key] = "{}_{}_{}_{}".format(particles, pileup, name, eta_tag)
+        tasks.seed.seed(pars, **seed_d)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="")
+    parser.add_argument("--pileup", help="tag for pileup choice", default="PU0")
+    parsing.add_parameters(parser)
+
+    FLAGS = parser.parse_args()
+
+    with open(params.CfgPath, "r") as afile:
+        cfg = yaml.safe_load(afile)
+
+    for particles in ("photons", "electrons", "pions"):
+        cfg["selection"]["particles"] = particles
+        start_chain(common.dot_dict(vars(FLAGS)), cfg)
\ No newline at end of file
diff --git a/bye_splits/utils/cl_helpers.py b/bye_splits/utils/cl_helpers.py
index 27a24eb9..465aba86 100644
--- a/bye_splits/utils/cl_helpers.py
+++ b/bye_splits/utils/cl_helpers.py
@@ -1,20 +1,15 @@
 import os
 import sys
-import re
-import argparse
 
 parent_dir = os.path.abspath(__file__ + 3 * "/..")
 sys.path.insert(0, parent_dir)
 
+from bye_splits.utils import common, params
+
 import numpy as np
 import pandas as pd
-
-from bye_splits.utils import common, parsing, params
-
-parser = argparse.ArgumentParser(description="Seeding standalone step.")
-parsing.add_parameters(parser)
-FLAGS = parser.parse_args()
-
+import re
+import argparse
 
 def get_last_version(name):
     """Takes a template path, such as '/full/path/to/my_file.ext' and returns the path to the latest version
@@ -24,42 +19,32 @@ def get_last_version(name):
     base, ext = os.path.splitext(base)
     dir = os.path.dirname(name)
     if os.path.exists:
-        # pattern = rf"{base}_v(\d{ext})"
-        pattern = r"{}_v(\d{})".format(base, ext)
+        pattern = r"{}_v(\d){}".format(base, ext)
         matches = [re.match(pattern, file) for file in os.listdir(dir)]
         version = max(
             [
-                int(match.group(1).replace(ext, ""))
+                int(match.group(1))
                 for match in matches
                 if not match is None
             ]
         )
     return version
 
-
 def update_version_name(name):
     """Takes the same template path as get_last_version(), and uses it to update the version number."""
     base, ext = os.path.splitext(name)
     version = 0 if not os.path.exists(name) else get_last_version(name)
     return f"{base}_v{str(version+1)}{ext}"
 
-
-# def_k = 0.0
-
-
-def closest(list, k=0.0):
+def closest(coef_list, k=0.0):
     """Find the element of a list containing strings ['coef_{float_1}', 'coef_{float_2}', ...] which is closest to some float_i"""
-    try:
-        list = np.reshape(np.asarray(list), 1)
-    except ValueError:
-        list = np.asarray(list)
+    coef_list = np.asarray(coef_list)
     if isinstance(k, str):
         k_num = float(re.split("coef_", k)[1].replace("p", "."))
     else:
         k_num = k
-    id = (np.abs(list - k_num)).argmin()
-    return list[id]
-
+    id = (np.abs(coef_list - k_num)).argmin()
+    return coef_list[id]
 
 def get_str(coef, df_dict):
     """Accepts a coefficient, either as a float or string starting with coef_, along with a dictionary of coefficient:DataFrame pairs.
@@ -77,7 +62,6 @@ def get_str(coef, df_dict):
         coef_str = "/coef_{}".format(str(new_coef).replace(".", "p"))
     return coef_str
 
-
 # Old Naming Conventions used different column names in the dataframes
 column_matching = {
     "etanew": "eta",
@@ -154,44 +138,27 @@ def get_input_files(base_path, pile_up=False):
 
     return input_files
 
-
-def get_output_files(cfg):
-    """Accepts a configuration file containing the base directory, a file basename, local (Bool) and pileUp (Bool).
-    Finds the full paths of the files created by cluster_size.py, and returns
-    a dictionary corresponding to particles:[file_paths]."""
-
-    output_files = {"photons": [], "pions": [], "electrons": []}
-    template = os.path.basename(
-        common.fill_path(cfg["clusterStudies"]["fileBaseName"], **vars(FLAGS))
-    )
-    template = re.split("_", template)
-    if cfg["clusterStudies"]["local"]:
-        base_path = cfg["clusterStudies"]["localDir"]
-    else:
-        base_path = (
-            params.EOSStorage(FLAGS.user, "data/PU0/")
-            if not cfg["clusterStudies"]["pileUp"]
-            else params.EOSStorage(FLAGS.user, "data/PU200/")
-        )
-    for particles in output_files.keys():
-        particle_dir = (
-            base_path + particles + "/" if cfg["clusterStudies"]["local"] else base_path
-        )
-        files = [re.split("_", file) for file in os.listdir(particle_dir)]
-        for filename in files:
-            if set(template).issubset(set(filename)):
-                path = os.path.join(f"{particle_dir}{'_'.join(filename)}")
-                with pd.HDFStore(path, "r") as File:
-                    if len(File.keys()) > 0:
-                        if ("photon" in filename) or ("photons" in filename):
-                            output_files["photons"].append(path)
-                        elif ("electron" in filename) or ("electrons" in filename):
-                            output_files["electrons"].append(path)
-                        else:
-                            output_files["pions"].append(path)
-
-        # Get rid of duplicates that the dictionary filling produced
-        for key in output_files.keys():
-            output_files[key] = list(set(output_files[key]))
-
-    return output_files
+def read_weights(dir, cfg, version="layer", mode="weights"):
+    weights_by_particle = {}
+    weight_path_templates = cfg["clusterStudies"]["weights"][version]
+    for particle, basename in weight_path_templates.items():
+        
+        particle_dir = os.path.join(dir, particle, cfg["clusterStudies"]["weights"]["subDir"])
+
+        files = [f for f in os.listdir(particle_dir) if basename in f]
+        weights_by_radius = {}
+        for file in files:
+            radius = float(file.replace(".hdf5","").replace(f"{basename}_","").replace("r0","0").replace("p","."))
+            infile = particle_dir+file
+            with pd.HDFStore(infile, "r") as optWeights:
+                weights_by_radius[radius] = optWeights[mode]
+    
+        weights_by_particle[particle] = weights_by_radius
+    
+    '''Weights are calculated from pt_norm distributions, which
+    are distorted by brem events for electrons. As this is
+    a physics effect uncorrelated to the TPG response, we correct
+    electrons with weights derived from photon pt_norm distributions'''
+    weights_by_particle["electrons"] = weights_by_particle["photons"]
+    
+    return weights_by_particle
\ No newline at end of file
diff --git a/bye_splits/utils/common.py b/bye_splits/utils/common.py
index eef36c71..d362e5df 100644
--- a/bye_splits/utils/common.py
+++ b/bye_splits/utils/common.py
@@ -16,7 +16,6 @@
 import numpy as np
 import pandas as pd
 
-
 def binConv(vals, dist, amin):
     """
     Converts bin indexes back to values (central values in the bin).
@@ -149,4 +148,4 @@ def std_eff(values, c=0.68):
 def seed_extra_name(cfg):
     s = '_hexdist' if cfg['seed_cs']['hexDist'] else ''
     s += '_' + cfg['seed_cs']['InputName']
-    return s
+    return s
\ No newline at end of file
diff --git a/bye_splits/utils/job_helpers.py b/bye_splits/utils/job_helpers.py
new file mode 100644
index 00000000..531d6035
--- /dev/null
+++ b/bye_splits/utils/job_helpers.py
@@ -0,0 +1,183 @@
+#!/usr/bin/env python
+
+import os
+import sys
+
+parent_dir = os.path.abspath(__file__ + 5 * "../")
+sys.path.insert(0, parent_dir)
+
+import re
+import argparse
+import subprocess
+import inspect
+import importlib.util
+
+_all_ = ['increment_version', 'grab_most_recent', 'compare_file_contents', 'write_file_version', 'conditional_write']
+
+def increment_version(file_path):
+    """Accepts a template for a full path to a file and increments the version"""
+    dir, file = os.path.split(file_path)
+    base, ext = os.path.splitext(file)
+    i = 0
+    file_path = "{}/{}_v{}{}".format(dir, base, i, ext)
+    while os.path.exists(file_path):
+        i += 1
+        file_path = "{}/{}_v{}{}".format(dir, base, i, ext)
+    return file_path
+
+def grab_most_recent(file_path, return_all=False):
+    """Grab the most recent version of the file corresponding to the template file_path (or return all matches).
+    Returns None if no files mathing template <file_path> have been written."""
+    dir, file = os.path.split(file_path)
+    base, ext = os.path.splitext(file)
+    files = os.listdir(dir)
+    version_pattern = re.compile("{}_v(\\d+)\\{}".format(base, ext))
+    matches = [version_pattern.search(file) for file in files]
+    matches = [match for match in matches if not match is None]
+    if len(matches) > 0:
+        matches = [int(match.group(1)) for match in matches]
+        most_recent = max(matches)
+        if not return_all:
+            file_path = dir + "/" + base + "_v" + str(most_recent) + ext
+        else:
+            file_path = [dir + "/" + base + "_v" + str(f) + ext for f in matches]
+        return file_path
+    else:
+        return None
+
+def compare_file_contents(file_path, buffer_list):
+    """
+    Compares the content in <file_path> with <buffer_list>,
+    which should be a list of strings that you wish to write
+    to a new file.
+    """
+    with open(file_path, "r") as file:
+        contents = file.readlines()
+    return contents==buffer_list
+
+def write_file_version(template, version):
+    file_name = increment_version(template)
+    with open(file_name, "w") as job_file:
+        job_file.writelines(version)
+    st = os.stat(file_name)
+    os.chmod(file_name, st.st_mode | 0o744)
+    return file_name
+
+def conditional_write(file_versions, file_template, current_version):
+    """
+    Loops through the files in <file_versions>, comparing their contents
+    to the current version. If an identical version is found, the function
+    breaks and does nothing. Otherwise, it will write the contents in
+    <current_version> to an updated version number whose basename corresponds to
+    <file_template>. If file_versions is None, writes the v0 version.
+    """
+    if file_versions is not None:
+        identical_version = False
+        for file in file_versions:
+            if not compare_file_contents(file, current_version):
+                continue
+            else:
+                identical_version = True
+                file_path = file
+                break
+        if not identical_version:
+            file_path = write_file_version(file_template, current_version)
+    
+    else:
+        file_path = write_file_version(file_template, current_version)
+    return file_path
+
+class Arguments:
+
+  def __init__(self, script):
+    self.script       = script
+    self.called_file  = inspect.stack()[1].filename
+    if self.script != self.called_file:
+      spec = importlib.util.spec_from_file_location("script", self.script)
+      original_script = importlib.util.module_from_spec(spec)
+      spec.loader.exec_module(original_script)
+      self.accepted_args = original_script.arg_dict
+
+  def _get_options(self):
+    return subprocess.run(["python", self.script, "-h"], capture_output=True, text=True).stdout
+
+  def get_running_args(self):
+    """Returns dictionary of command-line
+    argument key/value pairs."""
+    running_args = sys.argv[1:]
+    run_arg_dict = {}
+    for i, arg in enumerate(running_args):
+      if arg.startswith("--"):
+        arg_name = arg
+        if i + 1 < len(running_args):
+          if running_args[i + 1].startswith("--"):
+            run_arg_dict[arg_name] = True
+          else:
+            run_arg_dict[arg_name] = running_args[i + 1]
+        else:
+          run_arg_dict[arg_name] = True
+
+    return run_arg_dict
+
+  def combine_args(self, passed_args_dict):
+    """Combines the passed argument dictionary
+    with the command-line argument dictionary."""
+    running_args = self.get_running_args()
+
+    combined_args = {}
+    for key in set(passed_args_dict.keys()).union(set(running_args.keys())):
+      if key in running_args:
+        combined_args[key] = running_args[key]
+      else:
+        combined_args[key] = passed_args_dict[key]
+    
+    return combined_args
+
+
+  def verify_args(self, passed_args_dict):
+    """Verifies that the arguments dictionary (passed+command_line)
+    is a valid set of arguments for the script."""
+    
+    combined_args = self.combine_args(passed_args_dict)
+
+    true_keys     = set(self.accepted_args.keys()).union({'"--$val"'})
+    combined_keys = set(combined_args.keys())
+
+    if combined_keys.issubset(true_keys):
+      for arg, arg_info in self.accepted_args.items():
+        if "required" in arg_info.keys() and arg not in \
+        combined_keys and arg_info["required"] is True:
+          raise Exception("Required argument not passed: {}".format(arg))
+      return combined_args
+    else:
+      raise Exception("Passed arguments not in script: {}\n{}".format(
+          combined_keys.difference(true_keys), self._get_options()))
+
+  def write_comm(self, arg_dict):
+    """Verifies arguments and writes python command."""
+    full_args = self.verify_args(arg_dict)
+    comm = ["python", self.script]
+    for arg_name, arg_value in full_args.items():
+      if "action" in self.accepted_args[arg_name] and \
+      self.accepted_args[arg_name]["action"] == "store_true":
+        if arg_value is True:
+          comm.append(arg_name)
+      else:
+        comm.append(arg_name)
+        comm.append(str(arg_value))
+    return comm
+
+  def add_args(self, arg_dict, description=None):
+    """Adds the arguments to the script's argument list,
+    and returns the updated argument list."""
+
+    parser = argparse.ArgumentParser(description=description)
+    for arg_name, arg_info in arg_dict.items():
+        parser.add_argument(arg_name, **arg_info)
+
+    self.args = vars(parser.parse_args())
+    return self.args
+
+  def run_script(self, arg_dict):
+    comm = self.write_comm(arg_dict)
+    subprocess.run(comm)
\ No newline at end of file
diff --git a/config.yaml b/config.yaml
index e8b02b00..3a9b4325 100644
--- a/config.yaml
+++ b/config.yaml
@@ -135,19 +135,56 @@ varGeometry:
   reprocess: False
   coefs: [0.010, 0.015, 0.020, 0.025]
 
+job:
+  user: iehle
+  proxy: ~/.t3/proxy.cert
+  queue: short
+  local: False
+#  script: /grid_mnt/vol_home/llr/cms/ehle/NewRepos/bye_splits/bye_splits/scripts/cluster_size/condor/run_cluster.py
+#  iterOver: radius
+#  arguments:
+#    radius: [0.001, 0.002, 0.003, 0.004, 0.005, 0.006, 0.007, 0.008, 0.009,
+#            0.01 , 0.011, 0.012, 0.013, 0.014, 0.015, 0.016, 0.017, 0.018,
+#            0.019, 0.02 , 0.021, 0.022, 0.023, 0.024, 0.025, 0.026, 0.027,
+#            0.028, 0.029, 0.03 , 0.031, 0.032, 0.033, 0.034, 0.035, 0.036,
+#            0.037, 0.038, 0.039, 0.04 , 0.041, 0.042, 0.043, 0.044, 0.045,
+#            0.046, 0.047, 0.048, 0.049, 0.05]
+#    particles: pions
+#    pileup: PU0
+#    weighted: False
+  script: /grid_mnt/vol_home/llr/cms/ehle/NewRepos/bye_splits/tests/submission/dummy_submit.py
+  iterOver: gen_arg
+  arguments:
+    float_arg: 0.11
+    str_arg: a_string
+    gen_arg: [gen, 3.14, work, broke, 9, False, 12.9, hello]
+    flag: False
+  test:
+    submit_dir: /home/llr/cms/ehle/NewRepos/bye_splits/tests/submission/
+    args_per_batch: 2
+  photons:
+    submit_dir: /data_CMS/cms/ehle/L1HGCAL/PU0/photons/
+    args_per_batch: 10
+  electrons:
+    submit_dir: /data_CMS/cms/ehle/L1HGCAL/PU0/electrons/
+    args_per_batch: 5
+  pions:
+    submit_dir: /data_CMS/cms/ehle/L1HGCAL/PU0/pions/
+    args_per_batch: 5
+
 clusterStudies:
-  localDir: /home/llr/cms/mchiusi/event_display/bye_splits/data/new_algos/
+  localDir: /home/llr/cms/ehle/NewRepos/bye_splits/data/new_algos/
   ehleDir: /eos/user/i/iehle/
   dataFolder: data/
-  reinit: True #False
-  clusterSizeBaseName: cluster_size
-  coeffs: [0.0, 0.5, 50]
-  nevents: 100
-  pileUp: False
-  tree: FloatingpointMixedbcstcrealsig4DummyHistomaxxydr015GenmatchGenclustersntuple/HGCalTriggerNtuple
-  #coeffs: [0.0, 0.05, 50]
-  fileBaseName: energy_out
-  local: False
+  reprocess: True # Reproduce .parquet file
+  parquetTag: pt_test
+  clusterSizeBaseName: cluster_size_jobTest_yesWeight
+  pileup: False
+  weights:
+    subDir: optimization/official/final/
+    layer:
+      photons: optimization_selectOneStd_adjustMaxWeight_maxSeed
+      pions:  optimization_selectOneEffRms_maxSeed_bc_stc
 
 base:
   NbinsRz: 42
diff --git a/tests/submission/dummy_run.py b/tests/submission/dummy_run.py
new file mode 100644
index 00000000..1223f6ec
--- /dev/null
+++ b/tests/submission/dummy_run.py
@@ -0,0 +1,16 @@
+import os
+import sys
+
+parent_dir = os.path.abspath(__file__ + 3 * "/..")
+sys.path.insert(0, parent_dir)
+
+from bye_splits.utils.job_helpers import Arguments
+
+if __name__ == "__main__":
+    script = "/home/llr/cms/ehle/NewRepos/bye_splits/tests/submission/dummy_submit.py"
+
+    arg_dict = {"--float_arg": 0.5, "--str_arg": "woop", "--flag": False}
+
+    arg_object = Arguments(script=script)
+
+    arg_object.run_script(arg_dict)
\ No newline at end of file
diff --git a/tests/submission/dummy_submit.py b/tests/submission/dummy_submit.py
new file mode 100644
index 00000000..9cb366f5
--- /dev/null
+++ b/tests/submission/dummy_submit.py
@@ -0,0 +1,51 @@
+# coding: utf-8
+
+_all_ = ['dummy']
+
+import os
+import sys
+
+parent_dir = os.path.abspath(__file__ + 3 * "/..")
+sys.path.insert(0, parent_dir)
+
+from bye_splits.utils import common
+from bye_splits.utils.job_helpers import Arguments
+
+import argparse
+
+arg_dict = {
+    "--float_arg": {
+        "help": "Dummy float",
+        "type": float,
+        "required": True
+    },
+    "--str_arg": {
+        "help": "Dummy string.",
+        "type": str,
+        "required": True,
+    },
+    # Generic argument will be interpreted as a string
+    "--gen_arg": {
+        "help": "Dummy generic.",
+        "required": False,
+        "default": None
+    },
+    "--flag": {
+        "help": "Dummy flag number 2.",
+        "action": "store_true",
+        "required": False
+    }
+}
+
+def dummy(pars):
+    """Dummy script for testing HT Condor job submission.
+    Prints passed argument key/vals and the type of <val>."""
+
+    for key, val in pars.items():
+        print("Passed {} for --{}, read as type {}.".format(val, key, type(val)))
+
+
+if __name__ == "__main__":
+    args = Arguments(script=__file__)
+    FLAGS = args.add_args(description="A dummy script to submit.", arg_dict=arg_dict)
+    dummy(FLAGS)
\ No newline at end of file