docs: def sweeper_output(self):
          """This method outputs all of the config files in the configs directory
          within the current working directory. It names the config files based on
          the following format:
  
          a = assembly prefix <default = as>
          i = assembly start index <default = 000>
          d = date in format YYYYMMDD <default=today>
          z = assembler type - ME for Meraculous in this case
          g = first four letters of genus. Truncates if species name is too long.
          s = first four letters of species. Truncates if genus name is too long.
          k = kmer size
          p = ploid-type (diploid_mode)
  
          ai_d_z_g_s_k_p
  
          For example, if I enter the following parameters for a k=21 run on
          20160811:
            - g = "Malacosteus"
            - s = "niger"
  
          The assembly directory will be saved in the current working
          directory as:
            - configs/as000_20160811_ME_mala_nige_k21_p0
  
          Steps for this method:
          1. Check if configs is a directory that exists, if not, make it.
          2. For loop
            - Assign assembly numbers to sweep param
            - Output config file for each sweep param
          3. return dict of {"<run string>": "<config abs path>"}
          """
          # 1. check if configs directory exists, if not, make it
          config_dir = os.path.join(os.getcwd(), "configs")
          if not os.path.exists(config_dir):
              os.makedirs(config_dir)
  
          # 2. Assign assembly numbers to sweep param 
          if self.triplet:
              self.sList = [k for sublist in [[x] * 3 for x in self.sList] for k in sublist]
  
          self.subParams = []
          diploid_counter = 0
          asNumCounter = self.as_i
          for kmer in self.sList:
              subPDict = {}
              #set mer_size
              if self.sweep == "mer_size":
                  subPDict["mer_size"] = kmer
              else:
                  subPDict["mer_size"] = self.params.get("mer_size")
              #set diploid_mode
              if self.triplet:
                  subPDict["diploid_mode"] = diploid_counter
              else:
                  subPDict["diploid_mode"] = self.params.get("diploid_mode")
              #set assembly number
              subPDict["assem_num"] = asNumCounter
              #set assembly name
              subPDict["assem_name"] = self.name_gen(subPDict.get("assem_num"),
                                                     subPDict.get("mer_size"),
                                                     subPDict.get("diploid_mode"))
              self.subParams.append(subPDict)
              #keep track of the diploid modes to use in case of self.triplet
              if diploid_counter == 3:
                  diploid_counter = 0
              else:
                  diploid_counter += 1
              #increment the assembly number counter
              asNumCounter += 1
  
          #This block actually saves the config files
          for assemParam in self.subParams:
              with open(os.path.join(config_dir, "{0}.config".format(
                      assemParam.get("assem_name"))),
                      "w") as f:
                  for key in self.params:
                      if key == "lib_seq":
                          for each in self.params["lib_seq"]:
                              #print(str(each))
                              print("lib_seq {0}".format(str(each)), file = f)
                      else:
                          if key in assemParam:
                              print("{0} {1}".format(key, assemParam.get(key)),
                                    file=f)
                          else:
                              print("{0} {1}".format(key, self.params[key]),
                                    file=f)
  
          # 3 return dict of {"<run string>": "<config abs path>"}.
          # THIS IS THE FINAL FUNCTIONAL OUTPUT OF THIS CLASS.
          return {name:os.path.join(config_dir, "{0}.config".format(name))
                  for name in [subDict["assem_name"] for subDict in self.subParams]}