def _process_gxd_allele_pair_view(self, limit):
        """
        This assumes that the genotype and alleles
        have already been added to the id hashmap.
        We use the Genotype methods to add all the parts we need.
        Triples added:
        <genotype_id> has_part <vslc>
        <vslc> has_part <allele1>
        <vslc> has_part <allele2>
        <vslc> has_zygosity <zygosity>

        :param limit:
        :return:

        """
        if self.test_mode:
            graph = self.testgraph
        else:
            graph = self.graph
        model = Model(graph)
        geno = Genotype(graph)
        line_counter = 0
        raw = '/'.join((self.rawdir, 'gxd_allelepair_view'))
        LOG.info("processing allele pairs (VSLCs) for genotypes")
        geno_hash = {}
        with open(raw, 'r') as f:
            f.readline()  # read the header row; skip
            for line in f:
                line = line.rstrip("\n")
                line_counter += 1

                (allelepair_key, genotype_key, allele_key_1, allele_key_2,
                 allele1, allele2, allelestate) = line.split('\t')
                # NOTE: symbol = gene/marker,
                # allele1 + allele2 = VSLC,
                # allele1/allele2 = variant locus,
                # allelestate = zygosity
                # FIXME Need to handle alleles not in the *<*> format,
                # incl gene traps, induced mut, & transgenics

                if self.test_mode is True:
                    if int(genotype_key) not in self.test_keys.get('genotype'):
                        continue

                genotype_id = self.idhash['genotype'].get(genotype_key)
                if genotype_id not in geno_hash:
                    geno_hash[genotype_id] = set()
                if genotype_id is None:
                    LOG.error(
                        "genotype_id not found for key %s; skipping", genotype_key)
                    continue

                allele1_id = self.idhash['allele'].get(allele_key_1)
                allele2_id = self.idhash['allele'].get(allele_key_2)

                # Need to map the allelestate to a zygosity term
                zygosity_id = self.resolve(allelestate.strip())
                ivslc_id = self._makeInternalIdentifier('vslc', allelepair_key)

                geno_hash[genotype_id].add(ivslc_id)
                # TODO: VSLC label likely needs processing similar to
                # the processing in the all_allele_view
                # FIXME: handle null alleles
                vslc_label = allele1+'/'
                if allele2_id is None:
                    if zygosity_id in [
                            self.globaltt['hemizygous insertion-linked'],
                            self.globaltt['hemizygous-x'],
                            self.globaltt['hemizygous-y'],
                            self.globaltt['hemizygous']]:
                        vslc_label += '0'
                    elif zygosity_id == self.globaltt['heterozygous']:
                        vslc_label += '+'
                    elif zygosity_id == self.globaltt['indeterminate']:
                        vslc_label += '?'
                    elif zygosity_id == self.globaltt['homozygous']:
                        # we shouldn't get here, but for testing this is handy
                        vslc_label += allele1
                    else:  # heteroplasmic,  homoplasmic,  FIXME add these if possible
                        LOG.info(
                            "A different kind of zygosity found is: %s",
                            self.globaltcid[zygosity_id])
                        vslc_label += '?'
                else:
                    vslc_label += allele2

                model.addIndividualToGraph(
                    ivslc_id, vslc_label,
                    self.globaltt['variant single locus complement'])
                self.label_hash[ivslc_id] = vslc_label
                rel1 = rel2 = self.globaltt['has_variant_part']
                if allele1_id in self.wildtype_alleles:
                    rel1 = self.globaltt['has_reference_part']
                if allele2_id in self.wildtype_alleles:
                    rel2 = self.globaltt['has_reference_part']
                geno.addPartsToVSLC(
                    ivslc_id, allele1_id, allele2_id, zygosity_id, rel1, rel2)

                # if genotype_id not in geno_hash:
                #     geno_hash[genotype_id] = [vslc_label]
                # else:
                #     geno_hash[genotype_id] += [vslc_label]

                if not self.test_mode and limit is not None and line_counter > limit:
                    break

        # build the gvc and the genotype label
        for gt in geno_hash.keys():
            if gt is None:   # not sure why, but sometimes this is the case
                continue
            vslcs = sorted(list(geno_hash[gt]))
            gvc_label = None
            if len(vslcs) > 1:
                gvc_id = re.sub(r'_', '', ('-'.join(vslcs)))
                gvc_id = re.sub(r':', '', gvc_id)
                gvc_id = '_:'+gvc_id
                vslc_labels = []
                for v in vslcs:
                    vslc_labels.append(self.label_hash[v])
                gvc_label = '; '.join(vslc_labels)

                model.addIndividualToGraph(
                    gvc_id, gvc_label, self.globaltt['genomic_variation_complement'])
                self.label_hash[gvc_id] = gvc_label
                for v in vslcs:
                    geno.addParts(v, gvc_id, self.globaltt['has_variant_part'])
                    geno.addVSLCtoParent(v, gvc_id)
                geno.addParts(gvc_id, gt, self.globaltt['has_variant_part'])
            elif len(vslcs) == 1:
                gvc_id = vslcs[0]
                gvc_label = self.label_hash[gvc_id]
                # type the VSLC as also a GVC
                model.addIndividualToGraph(
                    gvc_id, gvc_label, self.globaltt['genomic_variation_complement'])
                geno.addVSLCtoParent(gvc_id, gt)
            else:
                LOG.info("No VSLCs for %s", gt)

            # make the genotype label = gvc + background
            bkgd_id = self.geno_bkgd.get(gt)
            if bkgd_id is not None:
                bkgd_label = self.label_hash.get(bkgd_id)
                if bkgd_label is None:
                    bkgd_label = bkgd_id  # just in case
            else:
                bkgd_label = 'n.s.'
            if gvc_label is not None:
                genotype_label = gvc_label + ' ['+bkgd_label+']'
            else:
                genotype_label = '['+bkgd_label+']'

            model.addIndividualToGraph(gt, genotype_label)
            self.label_hash[gt] = genotype_label

        return
This assumes that the genotype and alleles
        have already been added to the id hashmap.
        We use the Genotype methods to add all the parts we need.
        Triples added:
        <genotype_id> has_part <vslc>
        <vslc> has_part <allele1>
        <vslc> has_part <allele2>
        <vslc> has_zygosity <zygosity>

        :param limit:
        :return: