docs: def _process_qtls_genomic_location(
              self, raw, txid, build_id, build_label, common_name, limit=None):
          """
          This method
  
          Triples created:
  
          :param limit:
          :return:
          """
          if self.test_mode:
              graph = self.testgraph
          else:
              graph = self.graph
          model = Model(graph)
          line_counter = 0
          geno = Genotype(graph)
          # assume that chrs get added to the genome elsewhere
  
          taxon_curie = 'NCBITaxon:' + txid
          eco_id = self.globaltt['quantitative trait analysis evidence']
          LOG.info("Processing QTL locations for %s from %s", taxon_curie, raw)
          with gzip.open(raw, 'rt', encoding='ISO-8859-1') as tsvfile:
              reader = csv.reader(tsvfile, delimiter="\t")
              for row in reader:
                  line_counter += 1
                  if re.match(r'^#', ' '.join(row)):
                      continue
  
                  (chromosome, qtl_source, qtl_type, start_bp, stop_bp, frame, strand,
                   score, attr) = row
                  example = '''
  Chr.Z   Animal QTLdb    Production_QTL  33954873      34023581...
  QTL_ID=2242;Name="Spleen percentage";Abbrev="SPLP";PUBMED_ID=17012160;trait_ID=2234;
  trait="Spleen percentage";breed="leghorn";"FlankMarkers=ADL0022";VTO_name="spleen mass";
  MO_name="spleen weight to body weight ratio";Map_Type="Linkage";Model="Mendelian";
  Test_Base="Chromosome-wise";Significance="Significant";P-value="<0.05";F-Stat="5.52";
  Variance="2.94";Dominance_Effect="-0.002";Additive_Effect="0.01
                  '''
                  str(example)
                  # make dictionary of attributes
                  # keys are:
                  # QTL_ID,Name,Abbrev,PUBMED_ID,trait_ID,trait,FlankMarkers,
                  # VTO_name,Map_Type,Significance,P-value,Model,
                  # Test_Base,Variance, Bayes-value,PTO_name,gene_IDsrc,peak_cM,
                  # CMO_name,gene_ID,F-Stat,LOD-score,Additive_Effect,
                  # Dominance_Effect,Likelihood_Ratio,LS-means,Breed,
                  # trait (duplicate with Name),Variance,Bayes-value,
                  # F-Stat,LOD-score,Additive_Effect,Dominance_Effect,
                  # Likelihood_Ratio,LS-means
  
                  # deal with poorly formed attributes
                  if re.search(r'"FlankMarkers";', attr):
                      attr = re.sub(r'FlankMarkers;', '', attr)
                  attr_items = re.sub(r'"', '', attr).split(";")
                  bad_attrs = set()
                  for attributes in attr_items:
                      if not re.search(r'=', attributes):
                          # remove this attribute from the list
                          bad_attrs.add(attributes)
  
                  attr_set = set(attr_items) - bad_attrs
                  attribute_dict = dict(item.split("=") for item in attr_set)
  
                  qtl_num = attribute_dict.get('QTL_ID')
                  if self.test_mode and int(qtl_num) not in self.test_ids:
                      continue
                  # make association between QTL and trait based on taxon
  
                  qtl_id = common_name + 'QTL:' + str(qtl_num)
                  model.addIndividualToGraph(qtl_id, None, self.globaltt['QTL'])
                  geno.addTaxon(taxon_curie, qtl_id)
  
                  #
                  trait_id = 'AQTLTrait:' + attribute_dict.get('trait_ID')
  
                  # if pub is in attributes, add it to the association
                  pub_id = None
                  if 'PUBMED_ID' in attribute_dict.keys():
                      pub_id = attribute_dict.get('PUBMED_ID')
                      if re.match(r'ISU.*', pub_id):
                          pub_id = 'AQTLPub:' + pub_id.strip()
                          reference = Reference(graph, pub_id)
                      else:
                          pub_id = 'PMID:' + pub_id.strip()
                          reference = Reference(
                              graph, pub_id, self.globaltt['journal article'])
                      reference.addRefToGraph()
  
                  # Add QTL to graph
                  assoc = G2PAssoc(
                      graph, self.name, qtl_id, trait_id,
                      self.globaltt['is marker for'])
                  assoc.add_evidence(eco_id)
                  assoc.add_source(pub_id)
                  if 'P-value' in attribute_dict.keys():
                      scr = re.sub(r'<', '', attribute_dict.get('P-value'))
                      if ',' in scr:
                          scr = re.sub(r',', '.', scr)
                      if scr.isnumeric():
                          score = float(scr)
                          assoc.set_score(score)
  
                  assoc.add_association_to_graph()
                  # TODO make association to breed
                  # (which means making QTL feature in Breed background)
  
                  # get location of QTL
                  chromosome = re.sub(r'Chr\.', '', chromosome)
                  chrom_id = makeChromID(chromosome, taxon_curie, 'CHR')
  
                  chrom_in_build_id = makeChromID(chromosome, build_id, 'MONARCH')
                  geno.addChromosomeInstance(
                      chromosome, build_id, build_label, chrom_id)
                  qtl_feature = Feature(graph, qtl_id, None, self.globaltt['QTL'])
                  if start_bp == '':
                      start_bp = None
                  qtl_feature.addFeatureStartLocation(
                      start_bp, chrom_in_build_id, strand,
                      [self.globaltt['FuzzyPosition']])
                  if stop_bp == '':
                      stop_bp = None
                  qtl_feature.addFeatureEndLocation(
                      stop_bp, chrom_in_build_id, strand,
                      [self.globaltt['FuzzyPosition']])
                  qtl_feature.addTaxonToFeature(taxon_curie)
                  qtl_feature.addFeatureToGraph()
  
                  if not self.test_mode and limit is not None and line_counter > limit:
                      break
  
          # LOG.warning("Bad attribute flags in this file")  # what does this even mean??
          LOG.info("Done with QTL genomic mappings for %s", taxon_curie)
          return