docs: def _process_qtls_genetic_location(
              self, raw, txid, common_name, limit=None):
          """
          This function processes
  
          Triples created:
  
          :param limit:
          :return:
  
          """
          aql_curie = self.files[common_name + '_cm']['curie']
  
          if self.test_mode:
              graph = self.testgraph
          else:
              graph = self.graph
          line_counter = 0
          geno = Genotype(graph)
          model = Model(graph)
          eco_id = self.globaltt['quantitative trait analysis evidence']
  
          taxon_curie = 'NCBITaxon:' + txid
  
          LOG.info("Processing genetic location for %s from %s", taxon_curie, raw)
          with open(raw, 'r', encoding="iso-8859-1") as csvfile:
              filereader = csv.reader(csvfile, delimiter='\t', quotechar='\"')
              for row in filereader:
                  line_counter += 1
                  (qtl_id,
                   qtl_symbol,
                   trait_name,
                   assotype,
                   empty,
                   chromosome,
                   position_cm,
                   range_cm,
                   flankmark_a2,
                   flankmark_a1,
                   peak_mark,
                   flankmark_b1,
                   flankmark_b2,
                   exp_id,
                   model_id,
                   test_base,
                   sig_level,
                   lod_score,
                   ls_mean,
                   p_values,
                   f_statistics,
                   variance,
                   bayes_value,
                   likelihood_ratio,
                   trait_id, dom_effect,
                   add_effect,
                   pubmed_id,
                   gene_id,
                   gene_id_src,
                   gene_id_type,
                   empty2) = row
  
                  if self.test_mode and int(qtl_id) not in self.test_ids:
                      continue
  
                  qtl_id = common_name + 'QTL:' + qtl_id.strip()
                  trait_id = ':'.join((aql_curie, trait_id.strip()))
  
                  # Add QTL to graph
                  feature = Feature(graph, qtl_id, qtl_symbol, self.globaltt['QTL'])
                  feature.addTaxonToFeature(taxon_curie)
  
                  # deal with the chromosome
                  chrom_id = makeChromID(chromosome, taxon_curie, 'CHR')
  
                  # add a version of the chromosome which is defined as
                  # the genetic map
                  build_id = 'MONARCH:'+common_name.strip()+'-linkage'
                  build_label = common_name+' genetic map'
                  geno.addReferenceGenome(build_id, build_label, taxon_curie)
                  chrom_in_build_id = makeChromID(chromosome, build_id, 'MONARCH')
                  geno.addChromosomeInstance(
                      chromosome, build_id, build_label, chrom_id)
                  start = stop = None
                  # range_cm sometimes ends in "(Mb)"  (i.e pig 2016 Nov)
                  range_mb = re.split(r'\(', range_cm)
                  if range_mb is not None:
                      range_cm = range_mb[0]
  
                  if re.search(r'[0-9].*-.*[0-9]', range_cm):
                      range_parts = re.split(r'-', range_cm)
  
                      # check for poorly formed ranges
                      if len(range_parts) == 2 and\
                              range_parts[0] != '' and range_parts[1] != '':
                          (start, stop) = [
                              int(float(x.strip())) for x in re.split(r'-', range_cm)]
                      else:
                          LOG.info(
                              "A cM range we can't handle for QTL %s: %s",
                              qtl_id, range_cm)
                  elif position_cm != '':
                      match = re.match(r'([0-9]*\.[0-9]*)', position_cm)
                      if match is not None:
                          position_cm = match.group()
                          start = stop = int(float(position_cm))
  
                  # FIXME remove converion to int for start/stop
                  # when schema can handle floats add in the genetic location
                  # based on the range
                  feature.addFeatureStartLocation(
                      start, chrom_in_build_id, None,
                      [self.globaltt['FuzzyPosition']])
                  feature.addFeatureEndLocation(
                      stop, chrom_in_build_id, None,
                      [self.globaltt['FuzzyPosition']])
                  feature.addFeatureToGraph()
  
                  # sometimes there's a peak marker, like a rsid.
                  # we want to add that as a variant of the gene,
                  # and xref it to the qtl.
                  dbsnp_id = None
                  if peak_mark != '' and peak_mark != '.' and \
                          re.match(r'rs', peak_mark.strip()):
                      dbsnp_id = 'dbSNP:'+peak_mark.strip()
  
                      model.addIndividualToGraph(
                          dbsnp_id, None,
                          self.globaltt['sequence_alteration'])
                      model.addXref(qtl_id, dbsnp_id)
  
                  gene_id = gene_id.replace('uncharacterized ', '').strip()
                  if gene_id is not None and gene_id != '' and gene_id != '.'\
                          and re.fullmatch(r'[^ ]*', gene_id) is not None:
  
                      # we assume if no src is provided and gene_id is an integer,
                      # then it is an NCBI gene ... (okay, lets crank that back a notch)
                      if gene_id_src == '' and gene_id.isdigit() and \
                              gene_id in self.gene_info:
                          # LOG.info(
                          #    'Warm & Fuzzy saying %s is a NCBI gene for %s',
                          #    gene_id, common_name)
                          gene_id_src = 'NCBIgene'
                      elif gene_id_src == '' and gene_id.isdigit():
                          LOG.warning(
                              'Cold & Prickely saying %s is a NCBI gene for %s',
                              gene_id, common_name)
                          gene_id_src = 'NCBIgene'
                      elif gene_id_src == '':
                          LOG.error(
                              ' "%s" is a NOT NCBI gene for %s', gene_id, common_name)
                          gene_id_src = None
  
                      if gene_id_src == 'NCBIgene':
                          gene_id = 'NCBIGene:' + gene_id
                          # we will expect that these will get labels elsewhere
                          geno.addGene(gene_id, None)
                          # FIXME what is the right relationship here?
                          geno.addAffectedLocus(qtl_id, gene_id)
  
                          if dbsnp_id is not None:
                              # add the rsid as a seq alt of the gene_id
                              vl_id = '_:' + re.sub(
                                  r':', '', gene_id) + '-' + peak_mark.strip()
                              geno.addSequenceAlterationToVariantLocus(
                                  dbsnp_id, vl_id)
                              geno.addAffectedLocus(vl_id, gene_id)
  
                  # add the trait
                  model.addClassToGraph(trait_id, trait_name)
  
                  # Add publication
                  reference = None
                  if re.match(r'ISU.*', pubmed_id):
                      pub_id = 'AQTLPub:'+pubmed_id.strip()
                      reference = Reference(graph, pub_id)
                  elif pubmed_id != '':
                      pub_id = 'PMID:' + pubmed_id.strip()
                      reference = Reference(
                          graph, pub_id, self.globaltt['journal article'])
  
                  if reference is not None:
                      reference.addRefToGraph()
  
                  # make the association to the QTL
                  assoc = G2PAssoc(
                      graph, self.name, qtl_id, trait_id, self.globaltt['is marker for'])
                  assoc.add_evidence(eco_id)
                  assoc.add_source(pub_id)
  
                  # create a description from the contents of the file
                  # desc = ''
  
                  # assoc.addDescription(g, assoc_id, desc)
  
                  # TODO add exp_id as evidence
                  # if exp_id != '':
                  #     exp_id = 'AQTLExp:'+exp_id
                  #     gu.addIndividualToGraph(g, exp_id, None, eco_id)
  
                  if p_values != '':
                      scr = re.sub(r'<', '', p_values)
                      scr = re.sub(r',', '.', scr)  # international notation
                      if scr.isnumeric():
                          score = float(scr)
                          assoc.set_score(score)  # todo add score type
                  # TODO add LOD score?
                  assoc.add_association_to_graph()
  
                  # make the association to the dbsnp_id, if found
                  if dbsnp_id is not None:
                      # make the association to the dbsnp_id
                      assoc = G2PAssoc(
                          graph, self.name, dbsnp_id, trait_id,
                          self.globaltt['is marker for'])
                      assoc.add_evidence(eco_id)
                      assoc.add_source(pub_id)
  
                      # create a description from the contents of the file
                      # desc = ''
                      # assoc.addDescription(g, assoc_id, desc)
  
                      # TODO add exp_id
                      # if exp_id != '':
                      #     exp_id = 'AQTLExp:'+exp_id
                      #     gu.addIndividualToGraph(g, exp_id, None, eco_id)
  
                      if p_values != '':
                          scr = re.sub(r'<', '', p_values)
                          scr = re.sub(r',', '.', scr)
                          if scr.isnumeric():
                              score = float(scr)
                              assoc.set_score(score)  # todo add score type
                      # TODO add LOD score?
  
                      assoc.add_association_to_graph()
  
                  if not self.test_mode and limit is not None and line_counter > limit:
                      break
  
          LOG.info("Done with QTL genetic info")
          return