Adds a way to provide a random seed to STRUCTURE

Author: StuntsPT

structure_threader/argparser.py

@@ -128,8 +128,9 @@ def argument_parser(args):
     misc_opts.add_argument("--extra_opts", dest="extra_options", type=str,
                            required=False,
                            help="Add extra arguments to pass to the "
-                           "wrapped program here.\nExample: "
-                           "prior=logistic seed=123",
+                           "wrapped program here (between quotes).\nExamples: "
+                           "\"prior=logistic seed=123\" for fastStructure\n"
+                           "\"-D 12345\" for STRUCTURE",
                            metavar="string", default="")
 
     plot_opts.add_argument("--no_plots", dest="noplot", type=bool,
@@ -246,9 +247,11 @@ def argument_sanity(arguments, parser):
 
         # Handle argparse limitations with "--" options.
         if arguments.extra_options != "":
-            arguments.extra_options = "--{0}".format(arguments.extra_options)
-            arguments.extra_options = \
-                " --".join(arguments.extra_options.split())
+            if "-st" not in sys.argv:
+                arguments.extra_options = \
+                    "--{0}".format(arguments.extra_options)
+                arguments.extra_options = \
+                    " --".join(arguments.extra_options.split())
 
         # fastStructure is really only usefull with either a pop or indfile...
         if "-fs" in sys.argv and\

structure_threader/structure_threader.py

@@ -72,10 +72,14 @@ def runprogram(wrapped_prog, iterations, arg):
     """
     worker_status = (None, None)
 
-    k_val, rep_num = iterations
+    try:
+        seed, k_val, rep_num = iterations
+    except ValueError:
+        k_val, rep_num = iterations
+        seed = None
 
     if wrapped_prog == "structure":  # Run STRUCTURE
-        cli, output_file = sw.str_cli_generator(arg, k_val, rep_num)
+        cli, output_file = sw.str_cli_generator(arg, k_val, rep_num, seed)
 
     elif wrapped_prog == "maverick":  # Run MavericK
         mav_params = mw.mav_params_parser(arg.params)
@@ -122,10 +126,10 @@ def structure_threader(wrapped_prog, arg):
 
     if wrapped_prog != "structure":
         arg.replicates = [1]
+        jobs = list(itertools.product(arg.k_list, arg.replicates))[::-1]
     else:
         sw.str_param_checker(arg)
-
-    jobs = list(itertools.product(arg.k_list, arg.replicates))[::-1]
+        jobs = sw.seed_generator(arg.extra_options, arg.k_list, arg.replicates)
 
     # This allows us to pass partial arguments to a function so we can later
     # use it with multiprocessing map().

structure_threader/wrappers/structure_wrapper.py

@@ -1,6 +1,6 @@
 #!/usr/bin/python3
 
-# Copyright 2017 Francisco Pina Martins <f.pinamartins@gmail.com>
+# Copyright 2017-2018 Francisco Pina Martins <f.pinamartins@gmail.com>
 # This file is part of structure_threader.
 # structure_threader is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -17,24 +17,33 @@
 
 import os
 import logging
+import itertools
+import random
+
 
 try:
     import colorer.colorer as colorer
 except ImportError:
     import structure_threader.colorer.colorer as colorer
 
 
-def str_cli_generator(arg, k_val, rep_num):
+def str_cli_generator(arg, k_val, rep_num, seed):
     """
     Generates and returns command line for running STRUCTURE.
     """
     output_file = os.path.join(arg.outpath, "str_K" + str(k_val) + "_rep" +
                                str(rep_num))
     cli = [arg.external_prog, "-K", str(k_val), "-i", arg.infile, "-o",
            output_file]
+
+    if seed is not None:
+        cli += ["-D", seed]
+
     if arg.params is not None:
         cli += arg.params
 
+    print(cli)
+
     return cli, output_file
 
 
@@ -54,3 +63,20 @@ def str_param_checker(arg):
             touch = open(extraparams, 'w')
             touch.close()
         arg.params = ["-m", mainparams, "-e", extraparams]
+
+
+def seed_generator(extra_options, k_list, replicates):
+    """
+    Uses a user input seed value to generate *N* seeds, one for each run.
+    Takes a seed value and the number of iterations as input and returns a
+    job list: [(seed, K, replicate), ...].
+    """
+    jobs = list(itertools.product(k_list, replicates))[::-1]
+
+    extra_options = extra_options.split()
+    if "-D" in extra_options:
+        seed = int(extra_options[extra_options.index("-D") + 1])
+        random.seed(seed)
+        jobs = [(str(random.randrange(10000000)),) + x for x in jobs]
+
+    return jobs