Inheritance diagram for Bio::EnsEMBL::IdMapping::StableIdMapper:

Public Member Functions
public	new ()

public	generate_mapping_session ()

public	map_stable_ids ()

public	generate_similarity_events ()

public	filter_same_gene_transcript_similarities ()

public	generate_translation_similarity_events ()

public	write_stable_ids_to_file ()

public	generate_mapping_stats ()

public	dump_debug_mappings ()

public	write_stable_id_events ()

public	add_stable_id_event ()

public	get_all_stable_id_events ()

public	mapping_session_id ()

public	mapping_session_date ()

public	mapping_session_date_fmt ()

public	stable_id_generator ()

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 16 of file StableIdMapper.pm.

Member Function Documentation

◆ add_stable_id_event()

public Bio::EnsEMBL::IdMapping::StableIdMapper::add_stable_id_event ( )

Undocumented method

Code:

click to view

◆ dump_debug_mappings()

public Bio::EnsEMBL::IdMapping::StableIdMapper::dump_debug_mappings ( )

Undocumented method

Code:

click to view

◆ filter_same_gene_transcript_similarities()

public Bio::EnsEMBL::IdMapping::StableIdMapper::filter_same_gene_transcript_similarities ( )

Undocumented method

Code:

click to view

◆ generate_mapping_session()

public Bio::EnsEMBL::IdMapping::StableIdMapper::generate_mapping_session ( )

Undocumented method

Code:

click to view

sub generate_mapping_session {
  my $self = shift;
 
  # only run this method once
  return if ($self->mapping_session_date);
 
  $self->logger->info("Generating new mapping_session...\n");
 
  $self->mapping_session_date(time);
  $self->mapping_session_date_fmt(strftime("%Y-%m-%d %T",
    localtime($self->mapping_session_date)));
  
  my $s_dba = $self->cache->get_DBAdaptor('source');
  my $s_dbh = $s_dba->dbc->db_handle;
  my $t_dba = $self->cache->get_DBAdaptor('target');
  my $t_dbh = $t_dba->dbc->db_handle;
 
  # check if mapping_session_id was manually set by the configuration
  my $mapping_session_id = $self->conf->param('mapping_session_id');
  
  if ($mapping_session_id) {
    
    $self->logger->debug("Using manually configured mapping_session_id $mapping_session_id\n", 1);
  
  } else {
 
    # calculate mapping_session_id from db
    my $sql = qq(SELECT MAX(mapping_session_id) FROM mapping_session);
    $mapping_session_id = $self->fetch_value_from_db($s_dbh, $sql);
 
    unless ($mapping_session_id) {
      $self->logger->debug("No previous mapping_session found.\n", 1);
    }
    
    # increment last mapping_session_id
    $mapping_session_id++;
 
    $self->logger->debug("Using mapping_session_id $mapping_session_id\n", 1);
  }
 
  $self->mapping_session_id($mapping_session_id);
 
  # write old mapping_session table to a file
  my $i;
  my $fh = $self->get_filehandle('mapping_session.txt', 'tables');
 
  my $sth1 = $s_dbh->prepare("SELECT * FROM mapping_session");
  $sth1->execute;
 
  while (my @row = $sth1->fetchrow_array) {
    $i++;
    print $fh join("\t", @row);
    print $fh "\n";
  }
 
  $sth1->finish;
  
  # append the new mapping_session to the file
  my $release_sql = qq(
    SELECT meta_value FROM meta WHERE meta_key = 'schema_version'
  );
  my $old_release = $self->fetch_value_from_db($s_dbh, $release_sql);
  my $new_release = $self->fetch_value_from_db($t_dbh, $release_sql);
  
  my $assembly_sql = qq(
    SELECT meta_value FROM meta WHERE meta_key = 'assembly.default'
  );
  my $old_assembly = $self->fetch_value_from_db($s_dbh, $assembly_sql);
  my $new_assembly = $self->fetch_value_from_db($t_dbh, $assembly_sql);
 
  unless ($old_release and $new_release and $old_assembly and $new_assembly) {
    $self->logger->warning("Not all data for new mapping_session found:\n", 1);
    $self->logger->info("old_release: $old_release, new_release: $new_release");
    $self->logger->info("old_assembly: $old_assembly, new_assembly $new_assembly\n", 2);
  }
 
  print $fh join("\t",
                 $mapping_session_id,
                 $self->conf->param('sourcedbname'),
                 $self->conf->param('targetdbname'),
                 $old_release,
                 $new_release,
                 $old_assembly,
                 $new_assembly,
                 $self->mapping_session_date_fmt);
 
  print $fh "\n";
  close($fh);
  
  $self->logger->info("Done writing ".++$i." mapping_session entries.\n\n");
}

◆ generate_mapping_stats()

public Bio::EnsEMBL::IdMapping::StableIdMapper::generate_mapping_stats ( )

Undocumented method

Code:

click to view

◆ generate_similarity_events()

public Bio::EnsEMBL::IdMapping::StableIdMapper::generate_similarity_events ( )

Undocumented method

Code:

click to view

sub generate_similarity_events {
  my ( $self, $mappings, $scores, $type ) = @_;
 
  # argument checks
  unless ( $mappings and
           $mappings->isa('Bio::EnsEMBL::IdMapping::MappingList') )
  {
    throw('Need a gene Bio::EnsEMBL::IdMapping::MappingList.');
  }
 
  unless ( $scores and
          $scores->isa('Bio::EnsEMBL::IdMapping::ScoredMappingMatrix') )
  {
    throw('Need a Bio::EnsEMBL::IdMapping::ScoredMappingMatrix.');
  }
 
  throw("Need a type (gene|transcript|translation).") unless ($type);
 
  my $mapped;
 
  foreach my $e ( @{ $mappings->get_all_Entries } ) {
 
    # create lookup hash for mapped sources and targets; we'll need this
    # later
    $mapped->{'source'}->{ $e->source } = 1;
    $mapped->{'target'}->{ $e->target } = 1;
 
  } ## end foreach my $e ( @{ $mappings...})
 
  #
  # similarities for other entries
  #
  foreach my $dbtype ( keys %$mapped ) {
 
    # note: $dbtype will be either 'source' or 'target'
    my $m1 = "get_all_${dbtype}s";
    my $m2 = "get_Entries_for_${dbtype}";
 
    foreach my $id ( @{ $scores->$m1 } ) {
 
      # skip if this is a mapped source/target
      if ( $mapped->{$dbtype}->{$id} ) { next }
 
      my @entries =
        sort { $b->score <=> $a->score } @{ $scores->$m2($id) };
 
      unless (@entries) { next }
 
      # skip if top score < 0.75
      my $top_score = $entries[0]->score;
      if ( $top_score < 0.75 ) { next }
 
      # add similarities for all entries within 5% of top scorer
      while ( my $e = shift(@entries) ) {
 
        if ( $mapped->{'source'}->{$e->source} ) { next ; }
        if ( $mapped->{'target'}->{$e->target} ) { next ; }
 
        if ( $e->score > ( $top_score*0.95 ) ) {
 
          my $s_obj =
            $self->cache->get_by_key( "${type}s_by_id", 'source',
                                      $e->source );
          my $t_obj =
            $self->cache->get_by_key( "${type}s_by_id", 'target',
                                      $e->target );
 
          my $key = join( "\t",
                          $s_obj->stable_id,         $s_obj->version,
                          $t_obj->stable_id,         $t_obj->version,
                          $self->mapping_session_id, $type,
                          $e->score );
          $self->add_stable_id_event( 'similarity', $key );
 
        }
      }
 
    } ## end foreach my $id ( @{ $scores...})
  } ## end foreach my $dbtype ( keys %$mapped)
 
} ## end sub generate_similarity_events

◆ generate_translation_similarity_events()

public Bio::EnsEMBL::IdMapping::StableIdMapper::generate_translation_similarity_events ( )

Undocumented method

Code:

click to view

◆ get_all_stable_id_events()

public Bio::EnsEMBL::IdMapping::StableIdMapper::get_all_stable_id_events ( )

Undocumented method

Code:

click to view

◆ map_stable_ids()

public Bio::EnsEMBL::IdMapping::StableIdMapper::map_stable_ids ( )

Undocumented method

Code:

click to view

sub map_stable_ids {
  my $self = shift;
  my $mappings = shift;
  my $type = shift;
  
  unless ($mappings and
          $mappings->isa('Bio::EnsEMBL::IdMapping::MappingList')) {
    throw("Need a Bio::EnsEMBL::IdMapping::MappingList of ${type}s.");
  }
 
  # generate a new mapping_session and write all mapping_session data to a file
  $self->generate_mapping_session;
 
  $self->logger->info("== Stable ID mapping for $type...\n\n", 0, 'stamped');
 
  # check if there are any objects of this type at all
  my %all_sources = %{ $self->cache->get_by_name("${type}s_by_id", 'source') };
  my %all_targets = %{ $self->cache->get_by_name("${type}s_by_id", 'target') };
  unless (scalar(keys %all_sources)) {
    $self->logger->info("No cached ${type}s found.\n\n");
    return;
  }
 
  my %stats = map { $_ => 0 }
    qw(mapped new lost);
 
  # create some lookup hashes from the mappings
  my %sources_mapped = ();
  my %targets_mapped = ();
  my %scores_by_target = ();
 
  foreach my $e (@{ $mappings->get_all_Entries }) {
    $sources_mapped{$e->source} = $e->target;
    $targets_mapped{$e->target} = $e->source;
    $scores_by_target{$e->target} = $e->score;
  }
 
  # determine starting stable ID for new assignments
  my $new_stable_id = $self->stable_id_generator->initial_stable_id($type);
 
  #
  # assign mapped and new stable IDs
  #
  foreach my $tid (keys %all_targets) {
 
    my $t_obj = $all_targets{$tid};
    
    # a mapping exists, assign stable ID accordingly
    if (my $sid = $targets_mapped{$tid}) {
      
      my $s_obj = $all_sources{$sid};
 
      # set target's stable ID and created_date
      $t_obj->stable_id($s_obj->stable_id);
      $t_obj->created_date($s_obj->created_date);
 
      # calculate and set version
      my $old_version = $s_obj->version();
      my $new_version = $self->stable_id_generator->calculate_version($s_obj, $t_obj) ;
      $t_obj->version($new_version);
 
      # change modified_date if version changed
      if ($old_version == $new_version) {
        $t_obj->modified_date($s_obj->modified_date);
      } else {
        $t_obj->modified_date($self->mapping_session_date);
        # If version changed, score cannot be 1
        if ($scores_by_target{$tid} == 1) {
          $scores_by_target{$tid} = 0.99;
        }
      }
 
      # create a stable_id_event entry (not for exons)
      unless ( $type eq 'exon' ) {
        # Only add events when something changed.
        if ( !( $s_obj->stable_id eq $t_obj->stable_id &&
                $s_obj->version == $t_obj->version &&
                $scores_by_target{$tid} > 0.9999 ) )
        {
          my $key = join( "\t",
                          $s_obj->stable_id,         $s_obj->version,
                          $t_obj->stable_id,         $t_obj->version,
                          $self->mapping_session_id, $type,
                          $scores_by_target{$tid} );
          $self->add_stable_id_event( 'new', $key );
        }
      }
 
      # add to debug hash
      push @{ $debug_mappings{$type} }, [ $sid, $tid, $t_obj->stable_id ];
 
      # stats
      $stats{'mapped'}++;
 
    # no mapping was found, assign a new stable ID
    } else {
      
      $t_obj->stable_id($new_stable_id);
      $t_obj->version(1);
      $t_obj->created_date($self->mapping_session_date);
      $t_obj->modified_date($self->mapping_session_date);
 
      # create a stable_id_event entry (not for exons)
      unless ($type eq 'exon') {
        my $key = join("\t",
                       '\N',
                       0,
                       $t_obj->stable_id,
                       $t_obj->version,
                       $self->mapping_session_id,
                       $type,
                       0
        );
        $self->add_stable_id_event('new', $key);
      }
 
      # increment the stable Id (to be assigned to the next unmapped object)
      $new_stable_id = $self->stable_id_generator->increment_stable_id(
        $new_stable_id);
 
      # stats
      $stats{'new'}++;
 
    }
 
  }
  
  #
  # deletion events for lost sources
  # 
  my $fh;
  if ($type eq 'gene' or $type eq 'transcript') {
    $fh = $self->get_filehandle("${type}s_lost.txt", 'debug');
  }
  
  foreach my $sid (keys %all_sources) {
 
    my $s_obj = $all_sources{$sid};
    
    # no mapping exists, add deletion event
    unless ($sources_mapped{$sid}) {
      unless ($type eq 'exon') {
        my $key = join("\t",
                       $s_obj->stable_id,
                       $s_obj->version,
                       '\N',
                       0,
                       $self->mapping_session_id,
                       $type,
                       0
        );
        $self->add_stable_id_event('new', $key);
      }
 
      # stats
      my $status;
      $stats{'lost'}++;
 
      # log lost genes and transcripts (for debug purposes)
      #
      # The Java app did this with a separate method
      # (StableIdMapper.dumpLostGeneAndTranscripts()) which also claims to log
      # losses due to merge. Since at that point this data isn't available yet
      # the logging can be done much more efficient here
      if ($type eq 'gene' or $type eq 'transcript') {
        print $fh $s_obj->stable_id, "\t$status\n";
      }
    }
  }
 
  close($fh) if (defined($fh));
 
  #
  # write stable IDs to file
  #
  $self->write_stable_ids_to_file($type, \%all_targets);
 
  # also generate and write stats to file
  $self->generate_mapping_stats($type, \%stats);
 
  $self->logger->info("Done.\n\n");
}

◆ mapping_session_date()

public Bio::EnsEMBL::IdMapping::StableIdMapper::mapping_session_date ( )

Undocumented method

Code:

click to view

◆ mapping_session_date_fmt()

public Bio::EnsEMBL::IdMapping::StableIdMapper::mapping_session_date_fmt ( )

Undocumented method

Code:

click to view

◆ mapping_session_id()

public Bio::EnsEMBL::IdMapping::StableIdMapper::mapping_session_id ( )

Undocumented method

Code:

click to view

◆ new()

public Bio::EnsEMBL::IdMapping::StableIdMapper::new ( )

Undocumented method

Code:

click to view

◆ stable_id_generator()

public Bio::EnsEMBL::IdMapping::StableIdMapper::stable_id_generator ( )

Undocumented method

Code:

click to view

◆ write_stable_id_events()

public Bio::EnsEMBL::IdMapping::StableIdMapper::write_stable_id_events ( )

Undocumented method

Code:

click to view

◆ write_stable_ids_to_file()

public Bio::EnsEMBL::IdMapping::StableIdMapper::write_stable_ids_to_file ( )

Undocumented method

Code:

click to view

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

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

Public Member Functions

Detailed Description

Synopsis

Description

Member Function Documentation

◆ add_stable_id_event()

◆ dump_debug_mappings()

◆ filter_same_gene_transcript_similarities()

◆ generate_mapping_session()

◆ generate_mapping_stats()

◆ generate_similarity_events()

◆ generate_translation_similarity_events()

◆ get_all_stable_id_events()

◆ map_stable_ids()

◆ mapping_session_date()

◆ mapping_session_date_fmt()

◆ mapping_session_id()

◆ new()

◆ stable_id_generator()

◆ write_stable_id_events()

◆ write_stable_ids_to_file()