Inheritance diagram for Bio::EnsEMBL::IdMapping::InternalIdMapper:

Public Member Functions
public	map_genes ()

public	map_transcripts ()

public	map_exons ()

public	map_translations ()

public	delegate_to_plugin ()

public	has_plugin ()

public	get_plugin ()

public	add_plugin ()

public	log_ambiguous ()

public	write_ambiguous ()

Public Member Functions inherited from Bio::EnsEMBL::IdMapping::BaseObject
public $this	new ()

public Filehandle	get_filehandle ()

public Boolean	file_exists ()

public SQLStatement	fetch_value_from_db ()

public Int	dump_table_to_file ()

public Int	upload_file_into_table ()

public Bio::EnsEMBL::Utils::Logger	logger ()

public Bio::EnsEMBL::Utils::ConfParser	conf ()

public Bio::EnsEMBL::IdMapping::Cache	cache ()

Detailed Description

Synopsis

Description

Definition at line 18 of file InternalIdMapper.pm.

Member Function Documentation

◆ add_plugin()

public Bio::EnsEMBL::IdMapping::InternalIdMapper::add_plugin ( )

Undocumented method

Code:

click to view

◆ delegate_to_plugin()

public Bio::EnsEMBL::IdMapping::InternalIdMapper::delegate_to_plugin ( )

Undocumented method

Code:

click to view

◆ get_plugin()

public Bio::EnsEMBL::IdMapping::InternalIdMapper::get_plugin ( )

Undocumented method

Code:

click to view

◆ has_plugin()

public Bio::EnsEMBL::IdMapping::InternalIdMapper::has_plugin ( )

Undocumented method

Code:

click to view

◆ log_ambiguous()

public Bio::EnsEMBL::IdMapping::InternalIdMapper::log_ambiguous ( )

Undocumented method

Code:

click to view

◆ map_exons()

public Bio::EnsEMBL::IdMapping::InternalIdMapper::map_exons ( )

Undocumented method

Code:

click to view

sub map_exons {
  my $self = shift;
  my $exon_scores = shift;
  my $transcript_mappings = shift;
  my $esb = shift;
 
  # argument checks
  unless ($exon_scores and
      $exon_scores->isa('Bio::EnsEMBL::IdMapping::ScoredMappingMatrix')) {
    throw('Need a Bio::EnsEMBL::IdMapping::ScoredMappingMatrix of exons.');
  }
 
  unless ($transcript_mappings and
          $transcript_mappings->isa('Bio::EnsEMBL::IdMapping::MappingList')) {
    throw('Need a Bio::EnsEMBL::IdMapping::MappingList of transcripts.');
  }
  
  unless ($esb and
          $esb->isa('Bio::EnsEMBL::IdMapping::ExonScoreBuilder')) {
    throw('Need a Bio::EnsEMBL::IdMapping::ExonScoreBuilder.');
  }
  
  $self->logger->info("== Internal ID mapping for exons...\n\n", 0, 'stamped');
 
  my $dump_path = path_append($self->conf->param('basedir'), 'mapping');
 
  my $mappings = Bio::EnsEMBL::IdMapping::MappingList->new(
    -DUMP_PATH   => $dump_path,
    -CACHE_FILE  => 'exon_mappings.ser',
  );
 
  my $mapping_cache = $mappings->cache_file;
 
  if (-s $mapping_cache) {
    
    # read from file
    $self->logger->info("Reading exon mappings from file...\n", 0,
      'stamped');
    $self->logger->debug("Cache file $mapping_cache.\n", 1);
    $mappings->read_from_file;
    $self->logger->info("Done.\n\n", 0, 'stamped');
    
  } else {
    
    # create exon mappings
    $self->logger->info("No exon mappings found. Will calculate them now.\n");
 
    # determine which plugin methods to run
    my @default_plugins = (qw(
      Bio::EnsEMBL::IdMapping::InternalIdMapper::EnsemblExonGeneric::init_basic
      Bio::EnsEMBL::IdMapping::InternalIdMapper::EnsemblExonGeneric::mapped_transcript
      Bio::EnsEMBL::IdMapping::InternalIdMapper::EnsemblExonGeneric::single_transcript
      Bio::EnsEMBL::IdMapping::InternalIdMapper::EnsemblExonGeneric::internal_id
    ));
 
    my @plugins = $self->conf->param('plugin_internal_id_mappers_exon');
    @plugins = @default_plugins unless (defined($plugins[0]));
 
    my $new_mappings = Bio::EnsEMBL::IdMapping::MappingList->new(
      -DUMP_PATH   => $dump_path,
      -CACHE_FILE  => 'exon_mappings0.ser',
    );
    my @mappings = ();
    my $i = 0;
 
    #
    # run the scoring chain
    #
    foreach my $plugin (@plugins) {
      ($exon_scores, $new_mappings) = $self->delegate_to_plugin($plugin, $i++,
        $esb, $new_mappings, $exon_scores, $transcript_mappings);
 
      push(@mappings, $new_mappings);
    }
 
    # report remaining ambiguities
    $self->logger->info($exon_scores->get_source_count.
      " source exons are ambiguous with ".
      $exon_scores->get_target_count." target exons.\n\n");
 
    $self->log_ambiguous($exon_scores, 'exon');
 
    # merge mappings and write to file
    $mappings->add_all(@mappings);
    $mappings->write_to_file;
 
    if ($self->logger->loglevel eq 'debug') {
      $mappings->log('exon', $self->conf->param('basedir'));
    }
 
    $self->logger->info("Done.\n\n", 0, 'stamped');
 
  }
 
  return $mappings;
 
}

◆ map_genes()

public Bio::EnsEMBL::IdMapping::InternalIdMapper::map_genes ( )

Undocumented method

Code:

click to view

sub map_genes {
  my $self = shift;
  my $gene_scores = shift;
  my $transcript_scores = shift;
  my $gsb = shift;
 
  # argument checks
  unless ($gene_scores and
          $gene_scores->isa('Bio::EnsEMBL::IdMapping::ScoredMappingMatrix')) {
    throw('Need a gene Bio::EnsEMBL::IdMapping::ScoredMappingMatrix.');
  }
  
  unless ($transcript_scores and
          $transcript_scores->isa('Bio::EnsEMBL::IdMapping::ScoredMappingMatrix')) {
    throw('Need a transcript Bio::EnsEMBL::IdMapping::ScoredMappingMatrix.');
  }
 
  unless ($gsb and
          $gsb->isa('Bio::EnsEMBL::IdMapping::GeneScoreBuilder')) {
    throw('Need a Bio::EnsEMBL::IdMapping::GeneScoreBuilder.');
  }
  
  $self->logger->info("== Internal ID mapping for genes...\n\n", 0, 'stamped');
 
  my $dump_path = path_append($self->conf->param('basedir'), 'mapping');
 
  my $mappings = Bio::EnsEMBL::IdMapping::MappingList->new(
    -DUMP_PATH   => $dump_path,
    -CACHE_FILE  => 'gene_mappings.ser',
  );
 
  my $mapping_cache = $mappings->cache_file;
 
  if (-s $mapping_cache) {
    
    # read from file
    $self->logger->info("Reading gene mappings from file...\n", 0, 'stamped');
    $self->logger->debug("Cache file $mapping_cache.\n", 1);
    $mappings->read_from_file;
    $self->logger->info("Done.\n\n", 0, 'stamped');
    
  } else {
    
    # create gene mappings
    $self->logger->info("No gene mappings found. Will calculate them now.\n");
 
    # determine which plugin methods to run
    my @default_plugins = (qw(
      Bio::EnsEMBL::IdMapping::InternalIdMapper::EnsemblGeneGeneric::init_basic
      Bio::EnsEMBL::IdMapping::InternalIdMapper::EnsemblGeneGeneric::location
      Bio::EnsEMBL::IdMapping::InternalIdMapper::EnsemblGeneGeneric::best_transcript
      Bio::EnsEMBL::IdMapping::InternalIdMapper::EnsemblGeneGeneric::biotype
      Bio::EnsEMBL::IdMapping::InternalIdMapper::EnsemblGeneGeneric::synteny
      Bio::EnsEMBL::IdMapping::InternalIdMapper::EnsemblGeneGeneric::internal_id
    ));
 
    my @plugins = $self->conf->param('plugin_internal_id_mappers_gene');
    @plugins = @default_plugins unless (defined($plugins[0]));
 
    my $new_mappings = Bio::EnsEMBL::IdMapping::MappingList->new(
      -DUMP_PATH   => $dump_path,
      -CACHE_FILE  => 'gene_mappings0.ser',
    );
    my @mappings = ();
    my $i = 0;
 
    #
    # run the scoring chain
    #
    foreach my $plugin (@plugins) {
      ($gene_scores, $new_mappings) = $self->delegate_to_plugin($plugin, $i++,
        $gsb, $new_mappings, $gene_scores, $transcript_scores);
 
      push(@mappings, $new_mappings);
    }
 
    # report remaining ambiguities
    $self->logger->info($gene_scores->get_source_count.
      " source genes are ambiguous with ".
      $gene_scores->get_target_count." target genes.\n\n");
 
    $self->log_ambiguous($gene_scores, 'gene');
    
    # merge mappings and write to file
    $mappings->add_all(@mappings);
    $mappings->write_to_file;
 
    if ($self->logger->loglevel eq 'debug') {
      $mappings->log('gene', $self->conf->param('basedir'));
    }
 
    $self->logger->info("Done.\n\n", 0, 'stamped');
 
  }
 
  return $mappings;
}

◆ map_transcripts()

public Bio::EnsEMBL::IdMapping::InternalIdMapper::map_transcripts ( )

Undocumented method

Code:

click to view

sub map_transcripts {
  my $self = shift;
  my $transcript_scores = shift;
  my $gene_mappings = shift;
  my $tsb = shift;
 
  # argument checks
  unless ($transcript_scores and
      $transcript_scores->isa('Bio::EnsEMBL::IdMapping::ScoredMappingMatrix')) {
    throw('Need a transcript Bio::EnsEMBL::IdMapping::ScoredMappingMatrix.');
  }
 
  unless ($gene_mappings and
          $gene_mappings->isa('Bio::EnsEMBL::IdMapping::MappingList')) {
    throw('Need a gene Bio::EnsEMBL::IdMapping::MappingList.');
  }
  
  unless ($tsb and
          $tsb->isa('Bio::EnsEMBL::IdMapping::TranscriptScoreBuilder')) {
    throw('Need a Bio::EnsEMBL::IdMapping::TranscriptScoreBuilder.');
  }
  
  $self->logger->info("== Internal ID mapping for transcripts...\n\n", 0, 'stamped');
 
  my $dump_path = path_append($self->conf->param('basedir'), 'mapping');
 
  my $mappings = Bio::EnsEMBL::IdMapping::MappingList->new(
    -DUMP_PATH   => $dump_path,
    -CACHE_FILE  => 'transcript_mappings.ser',
  );
 
  my $mapping_cache = $mappings->cache_file;
 
  if (-s $mapping_cache) {
    
    # read from file
    $self->logger->info("Reading transcript mappings from file...\n", 0,
      'stamped');
    $self->logger->debug("Cache file $mapping_cache.\n", 1);
    $mappings->read_from_file;
    $self->logger->info("Done.\n\n", 0, 'stamped');
    
  } else {
    
    # create transcript mappings
    $self->logger->info("No transcript mappings found. Will calculate them now.\n");
 
    # determine which plugin methods to run
    my @default_plugins = (qw(
      Bio::EnsEMBL::IdMapping::InternalIdMapper::EnsemblTranscriptGeneric::init_basic
      Bio::EnsEMBL::IdMapping::InternalIdMapper::EnsemblTranscriptGeneric::non_exact_translation
      Bio::EnsEMBL::IdMapping::InternalIdMapper::EnsemblTranscriptGeneric::biotype
      Bio::EnsEMBL::IdMapping::InternalIdMapper::EnsemblTranscriptGeneric::mapped_gene
      Bio::EnsEMBL::IdMapping::InternalIdMapper::EnsemblTranscriptGeneric::single_gene
      Bio::EnsEMBL::IdMapping::InternalIdMapper::EnsemblTranscriptGeneric::internal_id
    ));
 
    my @plugins = $self->conf->param('plugin_internal_id_mappers_transcript');
    @plugins = @default_plugins unless (defined($plugins[0]));
 
    my $new_mappings = Bio::EnsEMBL::IdMapping::MappingList->new(
      -DUMP_PATH   => $dump_path,
      -CACHE_FILE  => 'transcript_mappings0.ser',
    );
    my @mappings = ();
    my $i = 0;
 
    #
    # run the scoring chain
    #
    foreach my $plugin (@plugins) {
      ($transcript_scores, $new_mappings) = $self->delegate_to_plugin($plugin,
        $i++, $tsb, $new_mappings, $transcript_scores, $gene_mappings);
 
      push(@mappings, $new_mappings);
    }
 
    # report remaining ambiguities
    $self->logger->info($transcript_scores->get_source_count.
      " source transcripts are ambiguous with ".
      $transcript_scores->get_target_count." target transcripts.\n\n");
 
    $self->log_ambiguous($transcript_scores, 'transcript');
 
    # merge mappings and write to file
    $mappings->add_all(@mappings);
    $mappings->write_to_file;
 
    if ($self->logger->loglevel eq 'debug') {
      $mappings->log('transcript', $self->conf->param('basedir'));
    }
 
    $self->logger->info("Done.\n\n", 0, 'stamped');
 
  }
 
  return $mappings;
 
}

◆ map_translations()

public Bio::EnsEMBL::IdMapping::InternalIdMapper::map_translations ( )

Undocumented method

Code:

click to view

sub map_translations {
  my $self = shift;
  my $transcript_mappings = shift;
 
  # argument checks
  unless ($transcript_mappings and
          $transcript_mappings->isa('Bio::EnsEMBL::IdMapping::MappingList')) {
    throw('Need a Bio::EnsEMBL::IdMapping::MappingList of transcripts.');
  }
  
  $self->logger->info("== Internal ID mapping for translations...\n\n", 0, 'stamped');
 
  my $dump_path = path_append($self->conf->param('basedir'), 'mapping');
 
  my $mappings = Bio::EnsEMBL::IdMapping::MappingList->new(
    -DUMP_PATH   => $dump_path,
    -CACHE_FILE  => 'translation_mappings.ser',
  );
 
  my $mapping_cache = $mappings->cache_file;
 
  if (-s $mapping_cache) {
    
    # read from file
    $self->logger->info("Reading translation mappings from file...\n", 0,
      'stamped');
    $self->logger->debug("Cache file $mapping_cache.\n", 1);
    $mappings->read_from_file;
    $self->logger->info("Done.\n\n", 0, 'stamped');
    
  } else {
    
    # create translation mappings
    $self->logger->info("No translation mappings found. Will calculate them now.\n");
 
    $self->logger->info("Translation mapping...\n", 0, 'stamped');
 
    #
    # map translations for mapped transcripts
    #
    my $i = 0;
 
    foreach my $entry (@{ $transcript_mappings->get_all_Entries }) {
 
      my $source_tl = $self->cache->get_by_key('transcripts_by_id',
        'source', $entry->source)->translation;
      my $target_tl = $self->cache->get_by_key('transcripts_by_id',
        'target', $entry->target)->translation;
 
      if ($source_tl and $target_tl) {
      
        # add mapping for the translations; note that the score is taken from
        # the transcript mapping
        my $tl_entry = Bio::EnsEMBL::IdMapping::Entry->new_fast([
          $source_tl->id, $target_tl->id, $entry->score
        ]);
        $mappings->add_Entry($tl_entry);
      
      } else {
        $i++;
      }
 
    }
 
    $self->logger->debug("Skipped transcripts without translation: $i\n", 1);
    $self->logger->info("New mappings: ".$mappings->get_entry_count."\n\n");
 
    $mappings->write_to_file;
 
    if ($self->logger->loglevel eq 'debug') {
      $mappings->log('translation', $self->conf->param('basedir'));
    }
 
    $self->logger->info("Done.\n\n", 0, 'stamped');
 
  }
 
  return $mappings;
 
}

◆ write_ambiguous()

public Bio::EnsEMBL::IdMapping::InternalIdMapper::write_ambiguous ( )

Undocumented method

Code:

click to view

The documentation for this class was generated from the following file:

ensembl/modules/Bio/EnsEMBL/IdMapping/InternalIdMapper.pm

Public Member Functions

Detailed Description

Synopsis

Description

Member Function Documentation

◆ add_plugin()

◆ delegate_to_plugin()

◆ get_plugin()

◆ has_plugin()

◆ log_ambiguous()

◆ map_exons()

◆ map_genes()

◆ map_transcripts()

◆ map_translations()

◆ write_ambiguous()