def _process_morbidmap(self, limit):
        """
        This will process the morbidmap file to get the links between
        omim genes and diseases. Here, we create anonymous nodes for some
        variant loci that are variants of the gene that causes the disease.
        Triples created:
        <some_anonymous_variant_locus>
            is_allele_of
                    <omim_gene_id>
        <some_anonymous_variant_locus> causes condition <omim_disease_id>
        <assoc> hasSubject <some_anonymous_variant_locus>
        <assoc> hasObject <omim_disease_id>
        <assoc> hasPredicate <causes condition>
        <assoc> DC:evidence <eco_id>
        :param limit:
        :return:
        """
        if self.test_mode:
            graph = self.testgraph
        else:
            graph = self.graph
        line_counter = 0
        assoc_count = 0
        src_key = 'morbidmap'
        col = self.files[src_key]['columns']
        raw = '/'.join((self.rawdir, self.files[src_key]['file']))
        with open(raw) as reader:
            line = reader.readline()  # Copyright
            line = reader.readline()  # Generated: 2016-04-11
            line = reader.readline()  # EOF for field spec
            line = reader.readline().strip()  # columns header
            line_counter = 4
            row = line.split('\t')  # includes funky leading octothorpe
            if row != col:  # assert
                LOG.error('Expected  %s to have columns: %s', raw, col)
                LOG.error('But Found %s to have columns: %s', raw, row)
                raise AssertionError('Incomming data headers have changed.')

            for line in reader:
                line_counter += 1
                line = line.strip()
                # since there are comments at the end of the file as well,
                if line[0] == '#':
                    continue
                row = line.split('\t')
                if len(row) != len(col):
                    LOG.warning(
                        'Unexpected input on line: %i  got: %s', line_counter, row)
                    continue

                disorder = row[col.index('# Phenotype')]
                gene_symbols = row[col.index('Gene Symbols')]
                gene_num = row[col.index('MIM Number')]
                # loc = row[col.index('Cyto Location')]

                # LOG.info("morbidmap disorder:  %s", disorder)  # too verbose

                # disorder = disorder label , number (mapping key)
                # 3-M syndrome 1, 273750 (3)|CUL7, 3M1|609577|6p21.1

                # but note that for those diseases where they are genomic loci
                # (not genes though), the omim id is only listed as the gene
                # Alopecia areata 1 (2)|AA1|104000|18p11.3-p11.2
                # when there's a gene and disease

                disorder_match = self.disorder_regex.match(disorder)
                nogene_match = self.nogene_regex.match(disorder)

                if disorder_match is not None:
                    disorder_parts = disorder_match.groups()
                    (disorder_label, disorder_num, phene_key) = disorder_parts

                    if self.test_mode and (
                            int(disorder_num) not in self.test_ids or
                            int(gene_num) not in self.test_ids):
                        continue
                    assoc_count += 1
                    gene_symbols = gene_symbols.split(', ')
                    gene_id = 'OMIM:' + str(gene_num)
                    self._make_pheno_assoc(
                        graph, gene_id, disorder_num, disorder_label, phene_key)
                elif nogene_match is not None:
                    # this is a case where the disorder
                    # a blended gene/phenotype
                    # we lookup the NCBIGene feature and make the association
                    (disorder_label, phene_key) = nogene_match.groups()
                    disorder_num = gene_num
                    # make what's in the gene column the disease
                    disorder_id = 'OMIM:' + str(disorder_num)
                    if self.test_mode and int(disorder_num) not in self.test_ids:
                        continue
                    if disorder_id in self.omim_ncbigene_idmap:
                        # get the gene ids
                        gene_ids = self.omim_ncbigene_idmap[disorder_id]
                        if gene_ids is None:
                            continue
                        for gene_num in gene_ids:
                            # TODO add gene filter for testMode and NCBIGenes
                            gene_id = 'NCBIGene:' + str(gene_num).strip()
                            assoc_count += 1
                            self._make_pheno_assoc(
                                graph, gene_id, disorder_num, disorder_label, phene_key)
                    else:
                        # we can create an anonymous feature
                        # to house this thing for example, 158900
                        feature_id = self._make_anonymous_feature(gene_num)
                        assoc_count += 1
                        self._make_pheno_assoc(
                            graph, feature_id, disorder_num, disorder_label, phene_key)

                        LOG.info(
                            "We don't have an NCBIGene feature id to link %s with %s",
                            disorder_id, disorder_label)

                    if self.test_mode and gene_num not in self.test_ids:
                        continue

                else:
                    LOG.warning(
                        "There are misformatted rows %i:%s", line_counter, line)
                if not self.test_mode and limit is not None and line_counter > limit:
                    break
            LOG.info("Added %d G2P associations", assoc_count)