lib/CXGN/Cview/MapFactory/SGN.pm

   1
   2
   3
   4 =head1 NAME
   5
   6 CXGN::Cview::MapFactory - a factory object for CXGN::Cview::Map objects
   7
   8 =head1 SYNOPSYS
   9
  10 my $map_factory  = CXGN::Cview::MapFactory->new($dbh);
  11 $map = $map_factory->create({map_version_id=>"u1"});
  12
  13 =head1 DESCRIPTION
  14
  15 The MapFactory object is part of a compatibility layer that defines the data sources of the comparative mapviewer. If there are different types of maps that can be distinguished by their ids, the MapFactory should be implemented to return the right map object for the given id. Of course, the corresponding map object also needs to be implemented, using the interface defined in CXGN::Cview::Map .
  16
  17 The MapFactory constructor takes a database handle (preferably constructed using CXGN::DB::Connection object). The map objects can then be constructed using the create function, which takes a hashref as a parameter, containing either map_id or map_version_id as a key (but not both). map_ids will be converted to map_version_ids immediately. Map_version_ids are then analyzed and depending on its format, CXGN::Cview::Map object of the proper type is returned.
  18
  19 The function get_all_maps returns all maps as list of appropriate CXGN::Cview::Map::* objects.
  20
  21 For the current SGN implementation, the following identifier formats are defined and yield following corresponding map objects
  22
  23  \d+       refers to a map id in the database and yields either a
  24            CXGN::Cview::Map::SGN::Genetic (type genetic)
  25            CXGN::Cview::Map::SGN::FISH (type fish)
  26            CXGN::Cview::Map::SGN::Sequence (type sequence)
  27  u\d+      refers to a user defined map and returns:
  28            CXGN::Cview::Map::SGN::User object
  29  filepath  refers to a map defined in a file and returns a
  30            CXGN::Cview::Map::SGN::File object
  31  il\d+      refers to a population id in the phenome.population table
  32            (which must be of type IL) and returns a
  33            CXGN::Cview::Map::SGN::IL object
  34  p\d+      CXGN::Cview::Map::SGN::Physical
  35  c\d+      CXGN::Cview::Map::SGN::Contig
  36  o         CXGN::Cview::Map::SGN::ProjectStats map object
  37
  38 The actual map objects returned are defined in the CXGN::Cview::Maps namespace. Because this is really a compatibility layer, an additional namespace of the resource is appended, such that a genetic map at SGN could be defined as CXGN::Cview::Maps::SGN::Genetic . If no corresponding map is found, undef is returned.
  39
  40 =head1 AUTHOR(S)
  41
  42 Lukas Mueller (lam87@cornell.edu)
  43
  44 =head1 VERSION
  45
  46 1.0, March 2007
  47
  48 =head1 LICENSE
  49
  50 Refer to the L<CXGN::LICENSE> file.
  51
  52 =head1 FUNCTIONS
  53
  54 This class implements the following functions:
  55
  56 =cut
  57
  58 use strict;
  59
  60 package CXGN::Cview::MapFactory::SGN;
  61
  62 use base qw| CXGN::DB::Object |;
  63
  64 use SGN::Context;
  65 use CXGN::Cview::Map::SGN::Genetic;
  66 #use CXGN::Cview::Map::SGN::User;
  67 use CXGN::Cview::Map::SGN::Fish;
  68 use CXGN::Cview::Map::SGN::Sequence;
  69 use CXGN::Cview::Map::SGN::IL;
  70 use CXGN::Cview::Map::SGN::Physical;
  71 use CXGN::Cview::Map::SGN::ProjectStats;
  72 use CXGN::Cview::Map::SGN::AGP;
  73 use CXGN::Cview::Map::SGN::ITAG;
  74 use CXGN::Cview::Map::SGN::Contig;
  75
  76 =head2 function new()
  77
  78   Synopsis:     constructor
  79   Arguments:    a database handle
  80   Returns:      a CXGN::Cview::MapFactory::SGN object
  81   Side effects: none
  82   Description:  none
  83
  84 =cut
  85
  86 sub new {
  87     my $class = shift;
  88     my $dbh = shift;
  89
  90     my $self = $class->SUPER::new($dbh);
  91
  92     return $self;
  93 }
  94
  95 =head2 function create()
  96
  97   Description:  creates a map based on the hashref given, which
  98                 should either contain the key map_id or map_version_id
  99                 and an appropriate identifier. The function returns undef
 100                 if a map of the given id cannot be found/created.
 101   Example:
 102
 103 =cut
 104
 105 sub create {
 106     my $self = shift;
 107     my $hashref = shift;
 108
 109     my $c = SGN::Context->new();
 110     #print STDERR "Hashref = map_id => $hashref->{map_id}, map_version_id => $hashref->{map_version_id}\n";
 111
 112     my $temp_dir =  File::Spec->catfile($c->get_conf('basepath'), $c->get_conf('tempfiles_subdir'), 'cview');
 113
 114     if (!exists($hashref->{map_id}) && !exists($hashref->{map_version_id})) {
 115         die "[CXGN::Cview::MapFactory] Need either a map_id or map_version_id.\n";
 116     }
 117     if ($hashref->{map_id} && $hashref->{map_version_id}) {
 118         die "[CXGN::Cview::MapFactory] Need either a map_id or map_version_id - not both.\n";
 119     }
 120     if ($hashref->{map_id}) {
 121         $hashref->{map_version_id}=CXGN::Cview::Map::Tools::find_current_version($self->get_dbh(), $hashref->{map_id});
 122     }
 123
 124     # now, we only deal with map_versions...
 125     #
 126     my $id = $hashref->{map_version_id};
 127
 128     #print STDERR "MapFactory: dealing with id = $id\n";
 129
 130     # if the map_version_id is purely numeric,
 131     # check if the map is in the maps table and generate the
 132     # appropriate map
 133
 134     if ($id=~/^\d+$/) {
 135         my $query = "SELECT map_version_id, map_type, map_id, short_name FROM sgn.map join sgn.map_version using(map_id) WHERE map_version_id=?";
 136         my $sth = $self->get_dbh()->prepare($query);
 137         $sth->execute($id);
 138         my ($id, $map_type) = $sth->fetchrow_array();
 139         if ($map_type =~ /genetic/i) {
 140             return CXGN::Cview::Map::SGN::Genetic->new($self->get_dbh(), $id);
 141         }
 142         elsif ($map_type =~ /fish/) {
 143             #print STDERR "Creating a fish map...\n";
 144             return CXGN::Cview::Map::SGN::Fish->new($self->get_dbh(), $id);
 145         }
 146         elsif ($map_type =~ /seq/) {
 147             #print STDERR "Creating a seq map...\n";
 148             return CXGN::Cview::Map::SGN::Sequence->new($self->get_dbh(), $id);
 149         }
 150     }
 151     elsif ($id =~ /^u/i) {
 152         return CXGN::Cview::Map::SGN::User->new($self->get_dbh(), $id);
 153     }
 154     elsif ($id =~ /^il/i) {
 155         my $abstract =
 156         "The tomato Introgression lines (ILs) are a set of nearly isogenic lines (NILs) developed by Dani Zamir through a succession of backcrosses, where each line carries a single genetically defined chromosome segment from a divergent genome. The ILs, representing whole-genome coverage of S. pennellii in overlapping segments in the genetic background of S. lycopersicum cv. M82, were first phenotyped in 1993, and presently this library consists of 76 genotypes. ";
 157
 158         my ($population_id, $map_id) = $self->get_db_ids($id);
 159         if ($map_id == 9) {
 160             $abstract .= " This IL map is based on markers of the F2-2000 map. ILs have also been mapped <a href=\"map.pl?map_id=il6.5&amp;show_ruler=1&amp;show_offsets=1\" >with the ExPEN1992 map as a reference</a>.";
 161         }
 162         elsif ($map_id ==5) {
 163             $abstract .= " The IL lines on this map have been characterized based on the markers on the 1992 tomato map. ILs have also been mapped <a href=\"map.pl?map_id=il6.9&amp;show_ruler=1&amp;show_offsets=1\" >with the ExPEN2000 map as a reference</a>. ";
 164         }
 165
 166         my $ref_map = "ExPEN2000";
 167         if ($id==5) { $ref_map = "ExPEN1992";}
 168         my $long_name =qq | <i>Solanum lycopersicum</i> Zamir Introgression Lines (IL) based on $ref_map |;
 169
 170         return CXGN::Cview::Map::SGN::IL->new($self->get_dbh(), $id,
 171                                               { short_name => "Tomato IL map",
 172                                                 long_name => $long_name,
 173                                                 abstract => $abstract
 174                                               });
 175     }
 176     elsif ($id =~ /^\//) {
 177         #return CXGN::Cview::Map::SGN::File->new($dbh, $id);
 178     }
 179     elsif ($id =~ /^p\d+/) {
 180         return CXGN::Cview::Map::SGN::Physical->new($self->get_dbh(), $id);
 181     }
 182     elsif ($id =~ /^o$/i) {
 183
 184         return CXGN::Cview::Map::SGN::ProjectStats->new($self->get_dbh(), {
 185             short_name=>"Tomato Sequencing Progress",
 186             long_name=>"Tomato Sequencing Statistics by Chromosome",
 187             abstract => $self->get_abstract(),
 188
 189         });
 190     }
 191
 192     elsif ($id =~ /^agp$/i) {
 193         return CXGN::Cview::Map::SGN::AGP->new($self->get_dbh(), $id, {
 194                                                short_name => "Tomato AGP map",
 195                                                long_name => "Tomato (Solanum lycopersicum) Accessioned Golden Path map",
 196                                                abstract => "<p>The AGP map shows the sequencing progress of the international tomato genome sequencing project by listing all finished clones by estimated physical map position . Each sequencing center generates one or more AGP (Accessioned Golden Path) files and uploads them to SGN. These files contain all the sequenced BACs, their position on the chromosome, the overlaps with other BACs and other information. For a complete specification, please refer to the <a href=\"http://www.sanger.ac.uk/Projects/C_elegans/DOCS/agp_files.shtml\">Sanger AGP specification</a>. The AGP files can also be downloaded from the SGN FTP site, at <a href=\"ftp://ftp.sgn.cornell.edu/tomato_genome/agp/\">ftp://ftp.sgn.cornell.edu/tomato_genome/agp/</a>.</p> <p>Note that this map is in testing (beta), and not all features may be functional.</p>" ,
 197                                                temp_dir => $temp_dir } );
 198     }
 199     elsif ($id =~ /^itag$/i) {
 200         return CXGN::Cview::Map::SGN::ITAG->new($self->get_dbh(), $id, {
 201                                                 short_name => "Tomato ITAG map",
 202                                                 long_name=>"Tomato (Solanum lycopersicum) ITAG map",
 203                                                 abstract=>"<p>The ITAG map shows the contig assembly and the corresponding BACs as used by the most recent annotation from the International Tomato Annotation Group (ITAG, see <a href=\"http://www.ab.wur.nl/TomatoWiki\">ITAG Wiki</a>). Clicking on the contigs will show the ITAG annotation in the genome browser.",
 204                                                 temp_dir => $temp_dir }
 205             );
 206     }
 207 #    elsif ($id =~ /^u\d+$/i) {
 208 #       return CXGN::Cview::Map::SGN::User->new($self->get_dbh(), $id);
 209 #    }
 210     elsif ($id =~ /^c\d+$/i) {
 211         return CXGN::Cview::Map::SGN::Contig->new($self->get_dbh(), $id, {
 212             berkeley_db_path=>'/data/prod/public/tomato_genome/physical_mapping/fpc/SGN_2009/gbrowse/curr/',
 213             short_name => "Tomato FPC map SGN2009",
 214             long_name => "Solanum lycopersicum Contig Map SGN2009",
 215             temp_dir => $temp_dir,
 216             marker_link => "/gbrowse/gbrowse/fpc_tomato_sgn_2009/?name=",
 217
 218             abstract => qq|
 219
 220 <p>This map shows the contig positions of the SGN2009 physical map constructed at the Arizona Genome Institute in late 2009. The marker positions shown are from the latest <a href="/cview/map.pl?map_id=9">EXPEN2000 map</a>.</p>
 221
 222     <p>This physical map contains clones from the HindIII, EcoRI, MboI and sheared BAC library.</p>
 223
 224     <p>This overview shows the counts of contigs along the chromosome. Click on any chromosome to view the individual contigs. More information on each contig can be obtained by by clicking on a specific contig.
 225
 226     <p>Specific contig IDs, including contigs that are not mapped, can be searched on the <a href="/gbrowse/gbrowse/fpc_tomato_sgn_2009/">FPC viewer page</a>.</p>
 227     <br />
 228
 229
 230 |
 231
 232                                                   }
 233             );
 234     }
 235
 236     print STDERR "Map NOT FOUND!!!!!!!!!!!!!!!!!!\n\n";
 237     return undef;
 238
 239 }
 240
 241 =head2 function get_all_maps()
 242
 243   Synopsis:
 244   Arguments:    none
 245   Returns:      a list of all maps currently defined, as
 246                 CXGN::Cview::Map objects (and subclasses)
 247   Side effects: Queries the database for certain maps
 248   Description:
 249
 250 =cut
 251
 252 sub get_all_maps {
 253     my $self = shift;
 254
 255     my @system_maps = $self->get_system_maps();
 256     my @user_maps = $self->get_user_maps();
 257     my @maps = (@system_maps, @user_maps);
 258     return @maps;
 259
 260 }
 261
 262
 263 =head2 get_system_maps
 264
 265   Usage:        my @system_maps = $map_factory->get_system_maps();
 266   Desc:         retrieves a list of system maps (from the sgn
 267                 database) as a list of CXGN::Cview::Map objects
 268   Ret:
 269   Args:
 270   Side Effects:
 271   Example:
 272
 273 =cut
 274
 275 sub get_system_maps {
 276     my $self = shift;
 277
 278     my @maps = ();
 279
 280     my $query = "SELECT map.map_id FROM sgn.map LEFT JOIN sgn.map_version USING(map_id) LEFT JOIN sgn.accession on(parent_1=accession.accession_id) LEFT JOIN sgn.organism USING(organism_id) LEFT JOIN common_name USING(common_name_id) WHERE current_version='t' ORDER by common_name.common_name";
 281     my $sth = $self->get_dbh()->prepare($query);
 282     $sth->execute();
 283
 284     while (my ($map_id) = $sth->fetchrow_array()) {
 285         my $map = $self->create({ map_id => $map_id });
 286         if ($map) { push @maps, $map; }
 287     }
 288
 289     # push il, physical, contig, and agp map
 290     #
 291     foreach my $id ("il6.5", "il6.9", "p9", "c9", "agp", "itag") {
 292         my $map = $self->create( {map_id=>$id} );
 293         if ($map) { push @maps, $map; }
 294     }
 295
 296     return @maps;
 297 }
 298
 299
 300
 301 =head2 get_user_maps
 302
 303  Status:       DEPRECATED. Does nothing now, as user maps have been disabled.
 304  Usage:
 305  Desc:         retrieves the current user maps of the logged in user.
 306  Ret:          a list of CXGN::Cview::Map objects
 307  Args:         none
 308  Side Effects: none
 309  Example:
 310
 311 =cut
 312
 313 sub get_user_maps {
 314     my $self = shift;
 315     # push the maps that are specific to that user and not public, if somebody is logged in...
 316     #
 317     my @maps = ();
 318 #     my $login = CXGN::Login->new($self->get_dbh());
 319 #     my $user_id = $login->has_session();
 320 #     if ($user_id) {
 321 #       my $q3 = "SELECT user_map_id FROM sgn_people.user_map WHERE obsolete='f' AND sp_person_id=?";
 322 #       my $h3 = $self->get_dbh()->prepare($q3);
 323 #       $h3->execute($user_id);
 324 #       while (my ($user_map_id) = $h3->fetchrow_array()) {
 325 #           my $map = $self->create( {map_id=>"u".$user_map_id} );
 326
 327 #           if ($map) { push @maps, $map; }
 328 #       }
 329 #     }
 330     return @maps;
 331 }
 332
 333
 334 sub get_db_ids {
 335     my $self = shift;
 336     my $id = shift;
 337
 338     my $population_id = 6;
 339     my $reference_map_id=5;
 340
 341     if ($id=~/il(\d+)\.?(\d*)?/) {
 342         $population_id=$1;
 343         $reference_map_id=$2;
 344     }
 345     if (!$reference_map_id) { $reference_map_id=5; }
 346     if (!$population_id) { $population_id=6; }
 347     print STDERR "Population ID: $population_id, reference_map_id = $reference_map_id\n";
 348
 349     return ($population_id, $reference_map_id);
 350 }
 351
 352 return 1;