lib/SGN/Controller/solGS/combinedTrials.pm

   1 package SGN::Controller::solGS::combinedTrials;
   2
   3 use Moose;
   4 use namespace::autoclean;
   5
   6 use Algorithm::Combinatorics qw /combinations/;
   7 use Array::Utils qw(:all);
   8 use Cache::File;
   9 use Carp qw/ carp confess croak /;
  10 use CXGN::Tools::Run;
  11 use File::Path qw / mkpath  /;
  12 use File::Spec::Functions qw / catfile catdir/;
  13 use File::Temp qw / tempfile tempdir /;
  14 use File::Slurp qw /write_file read_file/;
  15 use File::Copy;
  16 use File::Basename;
  17 use JSON;
  18 use List::MoreUtils qw /uniq/;
  19 use Scalar::Util qw /weaken reftype/;
  20 use Storable qw/ nstore retrieve /;
  21 use String::CRC;
  22 use Try::Tiny;
  23 use URI::FromHash 'uri';
  24
  25 BEGIN { extends 'Catalyst::Controller' }
  26
  27 sub get_combined_pops_id : Path('/solgs/get/combined/populations/id') Args() {
  28     my ( $self, $c ) = @_;
  29
  30     my @pops_ids = $c->req->param('trials[]');
  31
  32     @pops_ids = uniq(@pops_ids);
  33
  34     my $protocol_id = $c->req->param('genotyping_protocol_id');
  35
  36     $c->controller('solGS::genotypingProtocol')
  37       ->stash_protocol_id( $c, $protocol_id );
  38
  39     my $combo_pops_id;
  40     my $ret->{status} = 0;
  41
  42     if ( @pops_ids > 1 ) {
  43         $c->stash->{pops_ids_list} = \@pops_ids;
  44         $self->create_combined_pops_id($c);
  45         my $combo_pops_id = $c->stash->{combo_pops_id};
  46
  47         $self->catalogue_combined_pops( $c, \@pops_ids );
  48         $ret->{combo_pops_id}          = $combo_pops_id;
  49         $ret->{status}                 = 1;
  50         $ret->{genotyping_protocol_id} = $c->stash->{genotyping_protocol_id};
  51     }
  52
  53     $ret = to_json($ret);
  54
  55     $c->res->content_type('application/json');
  56     $c->res->body($ret);
  57
  58 }
  59
  60 sub prepare_data_for_trials : Path('/solgs/retrieve/populations/data') Args() {
  61     my ( $self, $c ) = @_;
  62
  63     my @pops_ids    = $c->req->param('trials[]');
  64     my $protocol_id = $c->req->param('genotyping_protocol_id');
  65
  66     $c->controller('solGS::genotypingProtocol')
  67       ->stash_protocol_id( $c, $protocol_id );
  68     $protocol_id = $c->stash->{genotyping_protocol_id};
  69
  70     my $combo_pops_id;
  71     my $ret->{status} = 0;
  72
  73     my $not_matching_pops;
  74     my @g_files;
  75
  76     if ( scalar(@pops_ids) > 1 ) {
  77         $c->stash->{pops_ids_list} = \@pops_ids;
  78         $self->create_combined_pops_id($c);
  79         $combo_pops_id = $c->stash->{combo_pops_id};
  80         $c->stash->{training_pop_id} = $combo_pops_id;
  81
  82         $self->catalogue_combined_pops( $c, \@pops_ids );
  83
  84 # $c->controller('solGS::solGS')->submit_cluster_training_pop_data_query($c, \@pops_ids);
  85
  86         $self->multi_pops_geno_files( $c, \@pops_ids );
  87         my $geno_files = $c->stash->{multi_pops_geno_files};
  88         @g_files = split( /\t/, $geno_files );
  89
  90         $c->controller('solGS::Search')
  91           ->compare_genotyping_platforms( $c, \@g_files );
  92         $not_matching_pops = $c->stash->{pops_with_no_genotype_match};
  93
  94         if ( !$not_matching_pops ) {
  95             $self->save_common_traits_acronyms($c);
  96         }
  97         else {
  98             $ret->{not_matching_pops} = $not_matching_pops;
  99         }
 100
 101         $ret->{combined_pops_id}       = $combo_pops_id;
 102         $ret->{genotyping_protocol_id} = $protocol_id;
 103     }
 104     else {
 105         my $pop_id = $pops_ids[0];
 106         $c->stash->{training_pop_id} = $pop_id;
 107
 108 # $c->controller('solGS::solGS')->submit_cluster_training_pop_data_query($c, \@pops_ids);
 109
 110         my $args = {
 111             'training_pop_id'        => $pop_id,
 112             'genotyping_protocol_id' => $protocol_id,
 113             'data_set_type'          => 'single_population'
 114         };
 115
 116         my $training_pop_page =
 117           $c->controller('solGS::Path')->training_page_url($args);
 118
 119         $ret->{redirect_url}           = $training_pop_page;
 120         $ret->{pop_id}                 = $pop_id;
 121         $ret->{genotyping_protocol_id} = $protocol_id;
 122     }
 123
 124     $ret = to_json($ret);
 125
 126     $c->res->content_type('application/json');
 127     $c->res->body($ret);
 128
 129 }
 130
 131 sub combined_trials_page : Path('/solgs/populations/combined') Args() {
 132     my ( $self, $c, $combo_pops_id, $gp, $protocol_id ) = @_;
 133
 134     $c->stash->{training_pop_id} = $combo_pops_id;
 135     $c->stash->{combo_pops_id}   = $combo_pops_id;
 136     $c->stash->{data_set_type}   = 'combined_populations';
 137     $c->stash->{analysis_type}   = $c->controller('solGS::Path')->page_type($c);
 138
 139     $c->controller('solGS::genotypingProtocol')
 140       ->stash_protocol_id( $c, $protocol_id );
 141     $self->get_combined_pops_list( $c, $combo_pops_id );
 142     my $pops_list = $c->stash->{combined_pops_list};
 143
 144     my $cached;
 145
 146     if ($pops_list) {
 147         $cached = $c->controller('solGS::CachedResult')
 148           ->check_multi_trials_training_data( $c, $pops_list, $protocol_id );
 149     }
 150
 151     if ( !$cached ) {
 152         my $msg =
 153 "Cached output for this training population  does not exist anymore.\n"
 154           . "Please go to <a href=\"/solgs/search/\">the search page</a>"
 155           . " and create the training population data.";
 156
 157         $c->controller('solGS::Utils')->generic_message( $c, $msg );
 158     }
 159     else {
 160         $self->save_common_traits_acronyms($c);
 161
 162         $c->controller('solGS::Trait')->get_all_traits( $c, $combo_pops_id );
 163         $c->controller('solGS::Trait')->get_acronym_pairs( $c, $combo_pops_id );
 164
 165         $self->combined_pops_summary($c);
 166         $c->stash->{template} = $c->controller('solGS::Files')
 167           ->template('/population/training_population.mas');
 168     }
 169 }
 170
 171 sub models_combined_trials : Path('/solgs/models/combined/trials') Args() {
 172     my ( $self, $c, $combo_pops_id, $tr_txt, $traits_selection_id, $gp,
 173         $protocol_id )
 174       = @_;
 175
 176     my $data_set_type = 'combined_populations';
 177
 178     $c->stash->{combo_pops_id} = $combo_pops_id;
 179     $c->stash->{model_id}      = $combo_pops_id;
 180     $c->stash->{pop_id}        = $combo_pops_id;
 181     $c->stash->{data_set_type} = $data_set_type;
 182     $c->stash->{analysis_type} = $c->controller('solGS::Path')->page_type($c);
 183
 184     $c->controller('solGS::genotypingProtocol')
 185       ->stash_protocol_id( $c, $protocol_id );
 186
 187     my @traits_ids;
 188
 189     if ( $traits_selection_id =~ /^\d+$/ ) {
 190         $c->controller('solGS::Gebvs')
 191           ->get_traits_selection_list( $c, $traits_selection_id );
 192         @traits_ids = @{ $c->stash->{traits_selection_list} }
 193           if $c->stash->{traits_selection_list};
 194     }
 195
 196     $self->combined_pops_summary($c);
 197     my $training_pop_name = $c->stash->{training_pop_name};
 198     my $training_pop_desc = $c->stash->{training_pop_desc};
 199
 200     #my $training_pop_page = $c->stash->{training_pop_page};
 201
 202     my @select_analysed_traits;
 203     my $args = {
 204         'training_pop_id'        => $combo_pops_id,
 205         'genotyping_protocol_id' => $protocol_id,
 206         'data_set_type'          => $data_set_type
 207     };
 208
 209     my $training_pop_page =
 210       $c->controller('solGS::Path')->training_page_url($args);
 211     $training_pop_page =
 212       qq | <a href="$training_pop_page">$training_pop_name</a> |;
 213
 214     if ( !@traits_ids ) {
 215         $c->stash->{message} =
 216             "Cached output for this page does not exist anymore.\n"
 217           . " Please go to $training_pop_page and run the analysis.";
 218
 219         $c->stash->{template} = "/generic_message.mas";
 220     }
 221     else {
 222         my @traits_pages;
 223         if ( scalar(@traits_ids) == 1 ) {
 224             my $trait_id = $traits_ids[0];
 225             my $args     = {
 226                 'trait_id'               => $trait_id,
 227                 'training_pop_id'        => $combo_pops_id,
 228                 'genotyping_protocol_id' => $protocol_id,
 229                 'data_set_type'          => $data_set_type
 230             };
 231
 232             my $model_page =
 233               $c->controller('solGS::Path')->model_page_url($args);
 234             $c->res->redirect($model_page);
 235             $c->detach();
 236         }
 237         else {
 238             foreach my $trait_id (@traits_ids) {
 239                 $c->stash->{trait_id} = $trait_id;
 240
 241                 $c->controller('solGS::modelAccuracy')
 242                   ->create_model_summary( $c, $combo_pops_id, $trait_id );
 243                 my $model_summary = $c->stash->{model_summary};
 244
 245                 push @traits_pages, $model_summary;
 246             }
 247         }
 248
 249         $c->stash->{training_pop_id}      = $combo_pops_id;
 250         $c->stash->{training_pop_name}    = $training_pop_name;
 251         $c->stash->{training_pop_desc}    = $training_pop_desc;
 252         $c->stash->{training_pop_page}    = $training_pop_page;
 253         $c->stash->{training_traits_ids}  = \@traits_ids;
 254         $c->stash->{training_traits_code} = $traits_selection_id;
 255
 256         $c->controller('solGS::Gebvs')->training_pop_analyzed_traits($c);
 257         my $analyzed_traits = $c->stash->{training_pop_analyzed_traits_ids};
 258
 259         $c->stash->{trait_pages} = \@traits_pages;
 260
 261         my @training_pop_data =
 262           ( [ $training_pop_page, $training_pop_desc, \@traits_pages ] );
 263
 264         $c->stash->{model_data} = \@training_pop_data;
 265
 266         $c->controller('solGS::Trait')->get_acronym_pairs( $c, $combo_pops_id );
 267         $c->stash->{template} = '/solgs/population/models/detail.mas';
 268     }
 269 }
 270
 271 sub display_combined_pops_result : Path('/solgs/model/combined/trials/') Args()
 272 {
 273     my ( $self, $c, $combo_pops_id, $trait_key, $trait_id, $gp, $protocol_id )
 274       = @_;
 275
 276     my $data_set_type = 'combined_populations';
 277
 278     $c->stash->{data_set_type}   = $data_set_type;
 279     $c->stash->{combo_pops_id}   = $combo_pops_id;
 280     $c->stash->{training_pop_id} = $combo_pops_id;
 281     $c->stash->{analysis_type}   = $c->controller('solGS::Path')->page_type($c);
 282
 283     $c->controller('solGS::genotypingProtocol')
 284       ->stash_protocol_id( $c, $protocol_id );
 285
 286     my $cached =
 287       $c->controller('solGS::CachedResult')
 288       ->check_single_trial_model_output( $c, $combo_pops_id, $trait_id,
 289         $protocol_id );
 290
 291     if ( !$cached ) {
 292
 293         my $args = {
 294             'training_pop_id'        => $combo_pops_id,
 295             'genotyping_protocol_id' => $protocol_id,
 296             'data_set_type'          => $data_set_type
 297         };
 298
 299         my $training_pop_page =
 300           $c->controller('solGS::Path')->training_page_url($args);
 301         $training_pop_page =
 302           qq | <a href="$training_pop_page">training population page </a>|;
 303
 304         my $msg = "Cached output for this model does not exist anymore.\n"
 305           . " Please go to the $training_pop_page and run the analysis.";
 306
 307         $c->controller('solGS::Utils')->generic_message( $c, $msg );
 308
 309     }
 310     else {
 311
 312         my $pops_cvs = $c->req->param('combined_populations');
 313
 314         if ($pops_cvs) {
 315             my @pops = split( ',', $pops_cvs );
 316             $c->stash->{trait_combo_pops} = \@pops;
 317         }
 318         else {
 319             $self->get_combined_pops_list( $c, $combo_pops_id );
 320             $c->stash->{trait_combo_pops} = $c->stash->{combined_pops_list};
 321         }
 322
 323         $c->controller('solGS::Trait')->get_trait_details( $c, $trait_id );
 324
 325         $self->combined_pops_summary($c);
 326
 327         $c->controller('solGS::solGS')->model_phenotype_stat($c);
 328         $c->controller('solGS::Files')->validation_file($c);
 329         $c->controller('solGS::modelAccuracy')->model_accuracy_report($c);
 330         $c->controller('solGS::Files')->rrblup_training_gebvs_file($c);
 331         $c->controller('solGS::solGS')
 332           ->top_blups( $c, $c->stash->{rrblup_training_gebvs_file} );
 333
 334      # $c->controller('solGS::Download')->training_prediction_download_urls($c);
 335         $c->controller('solGS::Files')->marker_effects_file($c);
 336         $c->controller('solGS::solGS')
 337           ->top_markers( $c, $c->stash->{marker_effects_file} );
 338         $c->controller('solGS::solGS')->variance_components($c);
 339
 340 #$c->stash->{template} = $c->controller('solGS::Files')->template('/model/combined/populations/trait.mas');
 341         $c->stash->{template} = $c->controller('solGS::Files')
 342           ->template('/population/models/model/detail.mas');
 343     }
 344 }
 345
 346 sub selection_combined_pops_trait : Path('/solgs/combined/model/') Args() {
 347     my (
 348         $self,     $c,                $model_id,
 349         $sel_key,  $selection_pop_id, $trait_key,
 350         $trait_id, $gp,               $protocol_id
 351     ) = @_;
 352
 353     my $data_set_type = 'combined_populations';
 354
 355     $c->stash->{combo_pops_id}        = $model_id;
 356     $c->stash->{training_pop_id}      = $model_id;
 357     $c->stash->{trait_id}             = $trait_id;
 358     $c->stash->{selection_pop_id}     = $selection_pop_id;
 359     $c->stash->{data_set_type}        = $data_set_type;
 360     $c->stash->{combined_populations} = 1;
 361     $c->stash->{analysis_type} = $c->controller('solGS::Path')->page_type($c);
 362
 363     $c->controller('solGS::genotypingProtocol')
 364       ->stash_protocol_id( $c, $protocol_id );
 365     $protocol_id = $c->stash->{genotyping_protocol_id};
 366
 367     $c->controller('solGS::Trait')->get_trait_details( $c, $trait_id );
 368     my $trait_abbr = $c->stash->{trait_abbr};
 369
 370     if ( $selection_pop_id =~ /list/ ) {
 371         $c->stash->{list_id} = $selection_pop_id =~ s/\w+_//r;
 372         $c->controller('solGS::List')
 373           ->list_population_summary( $c, $selection_pop_id );
 374         $c->stash->{selection_pop_id}    = $c->stash->{project_id};
 375         $c->stash->{selection_pop_name}  = $c->stash->{project_name};
 376         $c->stash->{selection_pop_desc}  = $c->stash->{project_desc};
 377         $c->stash->{selection_pop_owner} = $c->stash->{owner};
 378     }
 379     elsif ( $selection_pop_id =~ /dataset/ ) {
 380         $c->stash->{dataset_id} = $selection_pop_id =~ s/\w+_//r;
 381         $c->controller('solGS::Dataset')->dataset_population_summary($c);
 382         $c->stash->{selection_pop_id}    = $c->stash->{project_id};
 383         $c->stash->{selection_pop_name}  = $c->stash->{project_name};
 384         $c->stash->{selection_pop_desc}  = $c->stash->{project_desc};
 385         $c->stash->{selection_pop_owner} = $c->stash->{owner};
 386     }
 387     else {
 388         $c->controller('solGS::Search')
 389           ->get_project_details( $c, $selection_pop_id );
 390         $c->stash->{selection_pop_id}   = $c->stash->{project_id};
 391         $c->stash->{selection_pop_name} = $c->stash->{project_name};
 392         $c->stash->{selection_pop_desc} = $c->stash->{project_desc};
 393
 394         $c->controller('solGS::Search')
 395           ->get_project_owners( $c, $selection_pop_id );
 396         $c->stash->{selection_pop_owner} = $c->stash->{project_owners};
 397     }
 398
 399     my $mr_cnt_args =
 400       { 'selection_pop' => 1, 'selection_pop_id' => $selection_pop_id };
 401     my $sel_pop_mr_cnt =
 402       $c->controller('solGS::solGS')->get_markers_count( $c, $mr_cnt_args );
 403     $c->stash->{selection_markers_cnt} = $sel_pop_mr_cnt;
 404
 405     my $protocol = $c->controller('solGS::genotypingProtocol')
 406       ->create_protocol_url( $c, $protocol_id );
 407     $c->stash->{protocol_url} = $protocol;
 408
 409     my $args = {
 410         'training_pop_id'        => $model_id,
 411         'trait_id'               => $trait_id,
 412         'genotyping_protocol_id' => $protocol_id,
 413         'data_set_type'          => $data_set_type
 414     };
 415
 416     my $training_pop_page =
 417       $c->controller('solGS::Path')->training_page_url($args);
 418     my $training_pop = "Training population $model_id";
 419     my $pop_link     = qq | <a href="$training_pop_page">$training_pop </a>|;
 420
 421     $c->stash->{pop_link}          = $pop_link;
 422     $c->stash->{training_pop_name} = $training_pop;
 423
 424     my $training_model_page =
 425       $c->controller('solGS::Path')->model_page_url($args);
 426     my $model_link =
 427       qq | <a href="$training_model_page">$training_pop -- $trait_abbr </a>|;
 428     $c->stash->{model_page_url} = $model_link;
 429
 430     $c->controller('solGS::Files')
 431       ->rrblup_selection_gebvs_file( $c, $model_id, $selection_pop_id,
 432         $trait_id );
 433     my $gebvs_file = $c->stash->{rrblup_selection_gebvs_file};
 434
 435     my @stock_rows = read_file( $gebvs_file, { binmode => ':utf8' } );
 436     $c->stash->{selection_stocks_cnt} = scalar(@stock_rows) - 1;
 437
 438     $c->controller('solGS::solGS')->top_blups( $c, $gebvs_file );
 439
 440 # my $training_pop_name = $c->stash->{training_pop_name};
 441 # my $model_link = "$training_pop_name -- $trait_abbr";
 442 # $model_page = $c->controller('solGS::Path')->create_hyperlink($model_page, $model_link);
 443 # $c->stash->{model_page_url} = $model_page;
 444
 445     $c->stash->{template} = $c->controller('solGS::Files')
 446       ->template('/population/selection_prediction_detail.mas');
 447
 448 }
 449
 450 sub combine_populations : Path('/solgs/combine/populations/trait') Args() {
 451     my ( $self, $c, $trait_id, $protocol_id ) = @_;
 452
 453     my ( @pop_ids, $ids );
 454
 455     if ( $trait_id =~ /\d+/ ) {
 456         $ids     = $c->req->param($trait_id);
 457         @pop_ids = split( /,/, $ids );
 458
 459         $c->controller('solGS::Trait')->get_trait_details( $c, $trait_id );
 460     }
 461
 462     my $combo_pops_id;
 463     my $ret->{status} = 0;
 464
 465     if ( scalar(@pop_ids) > 1 ) {
 466         $combo_pops_id                = crc( join( '', @pop_ids ) );
 467         $c->stash->{combo_pops_id}    = $combo_pops_id;
 468         $c->stash->{trait_combo_pops} = $ids;
 469
 470         $c->stash->{trait_combine_populations} = \@pop_ids;
 471
 472         $self->multi_pops_phenotype_data( $c, \@pop_ids );
 473         $self->multi_pops_genotype_data( $c, \@pop_ids );
 474         $self->multi_pops_geno_files( $c, \@pop_ids );
 475         $self->multi_pops_pheno_files( $c, \@pop_ids );
 476
 477         my $geno_files = $c->stash->{multi_pops_geno_files};
 478         my @g_files    = split( /\t/, $geno_files );
 479
 480         $c->controller('solGS::Search')
 481           ->compare_genotyping_platforms( $c, \@g_files );
 482         my $not_matching_pops = $c->stash->{pops_with_no_genotype_match};
 483
 484         if ( !$not_matching_pops ) {
 485             $self->cache_combined_pops_data($c);
 486
 487             my $combined_pops_pheno_file =
 488               $c->stash->{trait_combined_pheno_file};
 489             my $combined_pops_geno_file = $c->stash->{trait_combined_geno_file};
 490
 491             unless ( -s $combined_pops_geno_file
 492                 && -s $combined_pops_pheno_file )
 493             {
 494                 $self->r_combine_populations($c);
 495
 496                 $combined_pops_pheno_file =
 497                   $c->stash->{trait_combined_pheno_file};
 498                 $combined_pops_geno_file =
 499                   $c->stash->{trait_combined_geno_file};
 500             }
 501
 502             if ( -s $combined_pops_pheno_file && -s $combined_pops_geno_file ) {
 503                 my $tr_abbr = $c->stash->{trait_abbr};
 504                 $c->stash->{data_set_type} = 'combined_populations';
 505                 $c->controller('solGS::solGS')->get_rrblup_output($c);
 506                 my $analysis_result = $c->stash->{combo_pops_analysis_result};
 507
 508                 $ret->{pop_ids}       = $ids;
 509                 $ret->{combo_pops_id} = $combo_pops_id;
 510                 $ret->{status}        = $analysis_result;
 511
 512                 $self->catalogue_combined_pops( $c, $ids );
 513             }
 514         }
 515         else {
 516             $ret->{not_matching_pops} = $not_matching_pops;
 517         }
 518     }
 519     else {
 520         my $pop_id = $pop_ids[0];
 521         $ret->{pop_id} = $pop_id;
 522         my $args = {
 523             'trait_id'               => $trait_id,
 524             'training_pop_id'        => $pop_id,
 525             'genotyping_protocol_id' => $protocol_id,
 526             'data_set_type'          => 'single_population'
 527         };
 528
 529         my $model_page = $c->controller('solGS::Path')->model_page_url($args);
 530         $ret->{redirect_url} = $model_page;
 531     }
 532
 533     $ret = to_json($ret);
 534
 535     $c->res->content_type('application/json');
 536     $c->res->body($ret);
 537
 538 }
 539
 540 sub combine_populations_confrim :
 541   Path('/solgs/combine/populations/trait/confirm') Args() {
 542     my ( $self, $c, $trait_id, $protocol_id ) = @_;
 543
 544     my ( @pop_ids, $ids );
 545
 546     if ( $trait_id =~ /\d+/ ) {
 547         $ids     = $c->req->param('confirm_populations');
 548         @pop_ids = split( /,/, $ids );
 549         if ( !@pop_ids ) { @pop_ids = $ids; }
 550
 551         $c->stash->{trait_id} = $trait_id;
 552     }
 553
 554     my $pop_links;
 555     my @selected_pops_details;
 556
 557     foreach my $pop_id (@pop_ids) {
 558         my $markers = $c->controller('solGS::Search')->model($c)
 559           ->get_project_genotyping_markers($pop_id);
 560         my @markers     = split( /\t/, $markers );
 561         my $markers_num = scalar(@markers);
 562
 563         $c->controller('solGS::Search')
 564           ->trial_compatibility_table( $c, $markers_num );
 565         my $match_code = $c->stash->{trial_compatibility_code};
 566
 567         my $pop_rs = $c->model('solGS::Search')->project_details($pop_id);
 568
 569         $c->controller('solGS::Search')->get_projects_details( $c, $pop_rs );
 570
 571         #my $pop_details  = $self->get_projects_details($c, $pop_rs);
 572         my $pop_details  = $c->stash->{projects_details};
 573         my $pop_name     = $pop_details->{$pop_id}{project_name};
 574         my $pop_desc     = $pop_details->{$pop_id}{project_desc};
 575         my $pop_year     = $pop_details->{$pop_id}{project_year};
 576         my $pop_location = $pop_details->{$pop_id}{project_location};
 577
 578         my $checkbox =
 579 qq |<form> <input style="background-color: $match_code;" type="checkbox" checked="checked" name="project" value="$pop_id" /> </form> |;
 580
 581         my $args = {
 582             'trait_id'               => $trait_id,
 583             'training_pop_id'        => $pop_id,
 584             'genotyping_protocol_id' => $protocol_id,
 585             'data_set_type'          => 'single_population'
 586         };
 587
 588         my $model_page = $c->controller('solGS::Path')->model_page_url($args);
 589         $match_code =
 590 qq | <div class=trial_code style="color: $match_code; background-color: $match_code; height: 100%; width:100%">code</div> |;
 591
 592         push @selected_pops_details,
 593           [
 594             $checkbox,
 595             qq|<a href="$model_page" onclick="solGS.waitPage()">$pop_name</a>|,
 596             $pop_desc,
 597             $pop_location,
 598             $pop_year,
 599             $match_code
 600           ];
 601
 602     }
 603
 604     $c->stash->{selected_pops_details} = \@selected_pops_details;
 605     $c->stash->{template}              = $c->controller('solGS::Files')
 606       ->template('/search/result/confirm/populations.mas');
 607
 608 }
 609
 610 sub multi_pops_pheno_files {
 611     my ( $self, $c, $pop_ids ) = @_;
 612
 613     $pop_ids = $c->stash->{pops_ids_list} if !$pop_ids;
 614
 615     my $trait_id = $c->stash->{trait_id};
 616     my $files;
 617
 618     if ( defined reftype($pop_ids) && reftype($pop_ids) eq 'ARRAY' ) {
 619         my @pheno_files;
 620         foreach my $pop_id (@$pop_ids) {
 621             $c->controller('solGS::Files')->phenotype_file_name( $c, $pop_id );
 622             push @pheno_files, $c->stash->{phenotype_file_name};
 623         }
 624
 625         $files = join( "\t", @pheno_files );
 626         $c->stash->{multi_pops_pheno_files} = $files;
 627     }
 628     else {
 629         $c->controller('solGS::Files')->phenotype_file_name( $c, $pop_ids );
 630         $files = $c->stash->{phenotype_file_name};
 631     }
 632
 633     if ($trait_id) {
 634         my $name     = "trait_${trait_id}_multi_pheno_files";
 635         my $temp_dir = $c->stash->{solgs_tempfiles_dir};
 636         my $tempfile =
 637           $c->controller('solGS::Files')->create_tempfile( $temp_dir, $name );
 638         write_file( $tempfile, { binmode => ':utf8' }, $files );
 639     }
 640
 641 }
 642
 643 sub multi_pops_geno_files {
 644     my ( $self, $c, $pop_ids ) = @_;
 645
 646     $pop_ids = $c->stash->{pops_ids_list} if !$pop_ids;
 647
 648     my $trait_id = $c->stash->{trait_id};
 649     my $files;
 650
 651     if ( defined reftype($pop_ids) && reftype($pop_ids) eq 'ARRAY' ) {
 652         my @geno_files;
 653         foreach my $pop_id (@$pop_ids) {
 654             $c->controller('solGS::Files')->genotype_file_name( $c, $pop_id );
 655             push @geno_files, $c->stash->{genotype_file_name};
 656         }
 657
 658         $files = join( "\t", @geno_files );
 659         $c->stash->{multi_pops_geno_files} = $files;
 660     }
 661     else {
 662         $c->controller('solGS::Files')->genotype_file_name( $c, $pop_ids );
 663         $files = $c->stash->{genotype_file_name};
 664     }
 665
 666     if ($trait_id) {
 667         my $name     = "trait_${trait_id}_multi_geno_files";
 668         my $temp_dir = $c->stash->{solgs_tempfiles_dir};
 669         my $tempfile =
 670           $c->controller('solGS::Files')->create_tempfile( $temp_dir, $name );
 671         write_file( $tempfile, { binmode => ':utf8' }, $files );
 672     }
 673
 674 }
 675
 676 sub multi_pops_phenotype_data {
 677     my ( $self, $c, $pop_ids ) = @_;
 678
 679     $pop_ids = $c->stash->{pops_ids_list} if !$pop_ids;
 680
 681     no warnings 'uninitialized';
 682     my @job_ids;
 683     if (@$pop_ids) {
 684         foreach my $pop_id (@$pop_ids) {
 685             $c->stash->{pop_id} = $pop_id;
 686             $c->controller('solGS::solGS')->phenotype_file( $c, $pop_id );
 687             push @job_ids, $c->stash->{r_job_id};
 688         }
 689
 690         if (@job_ids) {
 691             @job_ids = uniq(@job_ids);
 692             $c->stash->{multi_pops_pheno_jobs_ids} = \@job_ids;
 693         }
 694     }
 695
 696 }
 697
 698 sub multi_pops_genotype_data {
 699     my ( $self, $c, $pop_ids ) = @_;
 700
 701     $pop_ids = $c->stash->{pops_ids_list} if !$pop_ids;
 702
 703     no warnings 'uninitialized';
 704     my @job_ids;
 705     if (@$pop_ids) {
 706         foreach my $pop_id (@$pop_ids) {
 707             $c->stash->{pop_id} = $pop_id;
 708             $c->controller('solGS::solGS')->genotype_file( $c, $pop_id );
 709             push @job_ids, $c->stash->{r_job_id};
 710         }
 711
 712         if (@job_ids) {
 713             @job_ids = uniq(@job_ids);
 714             $c->stash->{multi_pops_geno_jobs_ids} = \@job_ids;
 715         }
 716     }
 717
 718 }
 719
 720 sub combined_pops_catalogue_file {
 721     my ( $self, $c ) = @_;
 722
 723     my $cache_data = {
 724         key       => 'combined_pops_catalogue_file',
 725         file      => 'combined_pops_catalogue_file',
 726         stash_key => 'combined_pops_catalogue_file',
 727         cache_dir => $c->stash->{solgs_cache_dir}
 728     };
 729
 730     $c->controller('solGS::Files')->cache_file( $c, $cache_data );
 731
 732 }
 733
 734 sub catalogue_combined_pops {
 735     my ( $self, $c, $trials_ids ) = @_;
 736
 737     my $combo_pops_id = $c->stash->{combo_pops_id};
 738
 739     if ( !$combo_pops_id ) {
 740         $c->stash->{pops_ids_list} = $trials_ids;
 741         $self->create_combined_pops_id($c);
 742         $combo_pops_id = $c->stash->{combo_pops_id};
 743     }
 744
 745     my $entry = join( ',', @$trials_ids );
 746
 747     $entry = $combo_pops_id . "\t" . $entry;
 748     my @entry = ($entry);
 749
 750     $self->combined_pops_catalogue_file($c);
 751     my $file = $c->stash->{combined_pops_catalogue_file};
 752
 753     if ( !-s $file ) {
 754         my $header = 'combo_pops_id' . "\t" . 'trials_ids' . "\n";
 755         write_file( $file, { binmode => ':utf8' }, ( $header, $entry ) );
 756     }
 757     else {
 758         my (@entries) = map { $_ =~ s/\n// ? $_ : undef }
 759           read_file( $file, { binmode => ':utf8' } );
 760         my @intersect = intersect( @entry, @entries );
 761         unless (@intersect) {
 762             write_file(
 763                 $file,
 764                 { append => 1, binmode => ':utf8' },
 765                 "\n" . $entry
 766             );
 767         }
 768     }
 769
 770 }
 771
 772 sub get_combined_pops_list {
 773     my ( $self, $c, $id ) = @_;
 774
 775     $id = $c->stash->{combo_pops_id} if !$id;
 776
 777     $self->combined_pops_catalogue_file($c);
 778     my $combo_pops_catalogue_file = $c->stash->{combined_pops_catalogue_file};
 779
 780     my @combos =
 781       uniq( read_file( $combo_pops_catalogue_file, { binmode => ':utf8' } ) );
 782
 783     my @pops_list;
 784     foreach my $entry (@combos) {
 785         if ( $entry =~ m/$id/ ) {
 786             chomp($entry);
 787             my ( $combo_pops_id, $pops ) = split( /\t/, $entry );
 788
 789             if ( $id == $combo_pops_id ) {
 790                 @pops_list                      = split( ',', $pops );
 791                 $c->stash->{combined_pops_list} = \@pops_list;
 792                 $c->stash->{trait_combo_pops}   = \@pops_list;
 793             }
 794         }
 795     }
 796
 797     return \@pops_list;
 798 }
 799
 800 sub combined_pops_summary {
 801     my ( $self, $c ) = @_;
 802
 803     my $combo_pops_id = $c->stash->{combo_pops_id};
 804     my $protocol_id   = $c->stash->{genotyping_protocol_id};
 805
 806     $self->get_combined_pops_list( $c, $combo_pops_id );
 807     my @pops_ids = @{ $c->stash->{trait_combo_pops} };
 808
 809     my $desc = 'This training population is a combination of ';
 810     my $projects_owners;
 811
 812     my $tr_page_args = { 'genotyping_protocol_id' => $protocol_id, };
 813
 814     my $training_pop_page;
 815     foreach my $pop_id (@pops_ids) {
 816         $c->controller('solGS::Search')->get_project_details( $c, $pop_id );
 817         my $pr_name = $c->stash->{project_name};
 818
 819         $tr_page_args->{training_pop_id} = $pop_id;
 820         $tr_page_args->{'data_set_type'} = 'single_population';
 821
 822         $training_pop_page =
 823           $c->controller('solGS::Path')->training_page_url($tr_page_args);
 824
 825         $desc .= '<a href=' . $training_pop_page . '> ' . $pr_name . '</a>';
 826         $desc .= $pop_id == $pops_ids[-1] ? '.' : ' and ';
 827
 828         $c->controller('solGS::Search')->get_project_owners( $c, $pop_id );
 829         my $project_owner = $c->stash->{project_owners};
 830
 831         if ($project_owner) {
 832             $projects_owners .=
 833               $projects_owners ? ', ' . $project_owner : $project_owner;
 834         }
 835     }
 836
 837     my $marker_args = {
 838         'training_pop'    => 1,
 839         'training_pop_id' => $combo_pops_id,
 840         'data_set_type'   => 'combined_populations'
 841     };
 842
 843     my $markers_no =
 844       $c->controller('solGS::solGS')->get_markers_count( $c, $marker_args );
 845
 846     my $trait_abbr = $c->stash->{trait_abbr};
 847     my $trait_id   = $c->stash->{trait_id};
 848
 849     my $model_link;
 850     if ($trait_id) {
 851         my $model_page_args = {
 852             'training_pop_id'        => $combo_pops_id,
 853             'trait_id'               => $trait_id,
 854             'genotyping_protocol_id' => $protocol_id,
 855             'data_set_type'          => 'combined_populations'
 856         };
 857
 858         $model_link =
 859           $c->controller('solGS::Path')->model_page_url($model_page_args);
 860     }
 861
 862     my $stocks_no =
 863       $self->count_combined_trials_lines( $c, $combo_pops_id, $trait_id );
 864     my $training_pop_name = "Training population $combo_pops_id";
 865
 866     $tr_page_args->{'training_pop_id'} = $combo_pops_id;
 867     $tr_page_args->{'data_set_type'}   = 'combined_populations';
 868
 869     $training_pop_page =
 870       $c->controller('solGS::Path')->training_page_url($tr_page_args);
 871
 872     my $pop_link    = qq | <a href="$training_pop_page">$training_pop_name</a>|;
 873     my $protocol    = $c->controller('solGS::genotypingProtocol')
 874       ->create_protocol_url( $c, $protocol_id );
 875
 876     $c->controller('solGS::Files')->traits_acronym_file( $c, $combo_pops_id );
 877     my $traits_list_file = $c->stash->{traits_acronym_file};
 878
 879     my @traits_list = read_file( $traits_list_file, { binmode => ':utf8' } );
 880     my $traits_no   = scalar(@traits_list) - 1;
 881
 882     $c->stash(
 883         markers_no        => $markers_no,
 884         stocks_no         => $stocks_no,
 885         traits_no         => $traits_no,
 886         training_pop_id   => $combo_pops_id,
 887         training_pop_desc => $desc,
 888         training_pop_name => $training_pop_name,
 889         training_pop_page => $pop_link,
 890         owner             => $projects_owners,
 891         protocol_url      => $protocol,
 892         training_pop_url  => $pop_link,
 893         model_page_url    => $model_link
 894     );
 895
 896 }
 897
 898 sub cache_combined_pops_data {
 899     my ( $self, $c ) = @_;
 900
 901     my $trait_id      = $c->stash->{trait_id};
 902     my $trait_abbr    = $c->stash->{trait_abbr};
 903     my $combo_pops_id = $c->stash->{combo_pops_id};
 904
 905     if ($trait_abbr) {
 906         $c->stash->{data_set_type}   = 'combined_populations';
 907         $c->stash->{training_pop_id} = $combo_pops_id;
 908         $c->controller('solGS::Files')->model_phenodata_file($c);
 909         $c->stash->{trait_combined_pheno_file} =
 910           $c->stash->{model_phenodata_file};
 911     }
 912
 913     $c->controller('solGS::Files')->genotype_file_name( $c, $combo_pops_id );
 914     $c->stash->{trait_combined_geno_file} = $c->stash->{genotype_file_name};
 915
 916 }
 917
 918 sub build_model_combined_trials_trait {
 919     my ( $self, $c ) = @_;
 920
 921     $c->stash->{data_set_type} = 'combined_populations';
 922     $c->stash->{pop_id}        = $c->stash->{combo_pops_id};
 923     $c->controller('solGS::Files')->rrblup_training_gebvs_file($c);
 924     my $gebv_file = $c->stash->{rrblup_training_gebvs_file};
 925
 926     unless ( -s $gebv_file ) {
 927         $self->get_combine_populations_args_file($c);
 928         my $combine_job_file = $c->stash->{combine_populations_args_file};
 929
 930         $c->stash->{prerequisite_jobs} =
 931           $c->stash->{combine_populations_args_file};
 932         $c->stash->{prerequisite_type} = 'combine_populations';
 933
 934         $c->controller('solGS::AsyncJob')->get_gs_modeling_jobs_args_file($c);
 935         $c->stash->{dependent_jobs} = $c->stash->{gs_modeling_jobs_args_file};
 936
 937         $c->controller('solGS::AsyncJob')->run_async($c);
 938     }
 939 }
 940
 941 sub combine_data_build_multiple_traits_models {
 942     my ( $self, $c ) = @_;
 943
 944     my @selected_traits = @{ $c->stash->{training_traits_ids} };
 945     my $combo_pops_id   = $c->stash->{combo_pops_id};
 946
 947     if ( !@selected_traits ) {
 948         croak "No traits to predict: $!\n";
 949     }
 950
 951     my @unpredicted_traits;
 952     foreach my $trait_id (@selected_traits) {
 953         $c->controller('solGS::Files')
 954           ->rrblup_training_gebvs_file( $c, $combo_pops_id, $trait_id );
 955         my $gebv_file = $c->stash->{rrblup_training_gebvs_file};
 956
 957         push @unpredicted_traits, $trait_id if !-s $gebv_file;
 958     }
 959
 960     if (@unpredicted_traits) {
 961         $c->stash->{training_traits_ids} = \@unpredicted_traits;
 962
 963         $self->get_combine_populations_args_file($c);
 964         my $combine_job_file = $c->stash->{combine_populations_args_file};
 965
 966         $c->stash->{prerequisite_jobs} =
 967           $c->stash->{combine_populations_args_file};
 968         $c->stash->{prerequisite_type} = 'combine_populations';
 969
 970         $c->stash->{training_pop_id} = $combo_pops_id;
 971         $c->stash->{data_set_type}   = 'combined_populations';
 972         $c->controller('solGS::AsyncJob')->get_gs_modeling_jobs_args_file($c);
 973         $c->stash->{dependent_jobs} = $c->stash->{gs_modeling_jobs_args_file};
 974
 975         $c->controller('solGS::AsyncJob')->run_async($c);
 976     }
 977
 978 }
 979
 980 sub predict_selection_pop_combined_pops_model {
 981     my ( $self, $c ) = @_;
 982
 983     my $data_set_type = $c->stash->{data_set_type};
 984     my $training_pop_id =
 985          $c->stash->{training_pop_id}
 986       || $c->stash->{combo_pops_id}
 987       || $c->stash->{model_id};
 988     my $selection_pop_id = $c->stash->{selection_pop_id};
 989
 990     $c->stash->{training_pop_id} = $training_pop_id;
 991     $c->stash->{pop_id}          = $training_pop_id;
 992
 993     my @selected_traits = @{ $c->stash->{training_traits_ids} }
 994       if $c->stash->{training_traits_ids};
 995
 996     $c->controller('solGS::solGS')->traits_with_valid_models($c);
 997     my @traits_with_valid_models =
 998       @{ $c->stash->{traits_ids_with_valid_models} };
 999     $c->stash->{training_traits_ids} = \@traits_with_valid_models;
1000
1001     my @prediction_traits;
1002     foreach my $trait_id (@selected_traits) {
1003         $c->controller('solGS::Files')
1004           ->rrblup_selection_gebvs_file( $c, $training_pop_id,
1005             $selection_pop_id, $trait_id );
1006
1007         if ( !-s $c->stash->{rrblup_selection_gebvs_file} ) {
1008             push @prediction_traits, $trait_id;
1009         }
1010     }
1011
1012     if (@prediction_traits) {
1013         $c->stash->{training_traits_ids} = \@prediction_traits;
1014
1015         $c->controller('solGS::AsyncJob')
1016           ->get_selection_pop_query_args_file($c);
1017         my $pre_req = $c->stash->{selection_pop_query_args_file};
1018
1019         $c->controller('solGS::Files')
1020           ->selection_population_file( $c, $selection_pop_id );
1021
1022         $c->controller('solGS::AsyncJob')->get_gs_modeling_jobs_args_file($c);
1023         my $dep_jobs = $c->stash->{gs_modeling_jobs_args_file};
1024
1025         $c->stash->{prerequisite_jobs} = $pre_req;
1026         $c->stash->{prerequisite_type} = 'selection_pop_download_data';
1027         $c->stash->{dependent_jobs}    = $dep_jobs;
1028
1029         $c->controller('solGS::AsyncJob')->run_async($c);
1030     }
1031     else {
1032         croak "No traits to predict: $!\n";
1033     }
1034
1035 }
1036
1037 sub combine_trait_data {
1038     my ( $self, $c ) = @_;
1039
1040     my $combo_pops_id = $c->stash->{combo_pops_id};
1041     my $trait_id      = $c->stash->{trait_id};
1042
1043     my $solgs_controller = $c->controller('solGS::solGS');
1044     $solgs_controller->get_trait_details( $c, $trait_id );
1045
1046     $self->cache_combined_pops_data($c);
1047
1048     my $combined_pops_pheno_file = $c->stash->{trait_combined_pheno_file};
1049     my $combined_pops_geno_file  = $c->stash->{trait_combined_geno_file};
1050
1051     my $geno_cnt = ( split( /\s+/, qx / wc -l $combined_pops_geno_file / ) )[0];
1052     my $pheno_cnt =
1053       ( split( /\s+/, qx / wc -l $combined_pops_pheno_file / ) )[0];
1054
1055     unless ( $geno_cnt > 10 && $pheno_cnt > 10 ) {
1056         $self->get_combined_pops_list($c);
1057         my $combined_pops_list = $c->stash->{combined_pops_list};
1058         $c->stash->{trait_combine_populations} = $combined_pops_list;
1059
1060         $self->prepare_multi_pops_data($c);
1061
1062         my $background_job    = $c->stash->{background_job};
1063         my $prerequisite_jobs = $c->stash->{multi_pops_data_jobs};
1064
1065         if ($background_job) {
1066             if ( $prerequisite_jobs =~ /^:+$/ ) {
1067                 $prerequisite_jobs = undef;
1068             }
1069
1070             if ($prerequisite_jobs) {
1071                 ###Needs work####
1072                 $c->stash->{prerequisite_jobs} = $prerequisite_jobs;
1073                 $c->stash->{prerequisite_type} = 'download_data';
1074
1075             }
1076         }
1077     }
1078
1079 }
1080
1081 sub combine_data_build_model {
1082     my ( $self, $c ) = @_;
1083
1084     my $trait_id = $c->stash->{trait_id};
1085     $c->controller('solGS::Trait')->get_trait_details( $c, $trait_id );
1086
1087     $c->stash->{prerequisite_type} = 'combine_populations';
1088
1089     #$self->r_combine_populations_args($c);
1090     $self->build_model_combined_trials_trait($c);
1091
1092 }
1093
1094 sub r_combine_populations_args {
1095     my ( $self, $c ) = @_;
1096
1097     $self->combine_trait_data_input($c);
1098     my $input_files        = $c->stash->{combine_input_files};
1099     my $output_files       = $c->stash->{combine_output_files};
1100     my $temp_file_template = $c->stash->{combine_r_temp_file};
1101     my $r_script           = 'R/solGS/combine_populations.r';
1102
1103     my $temp_dir       = $c->stash->{solgs_tempfiles_dir};
1104     my $background_job = $c->stash->{background_job};
1105
1106     my $cluster_files = $c->controller('solGS::AsyncJob')
1107       ->create_cluster_accessible_tmp_files( $c, $temp_file_template );
1108     my $out_file = $cluster_files->{out_file_temp};
1109     my $err_file = $cluster_files->{err_file_temp};
1110     my $in_file  = $cluster_files->{in_file_temp};
1111
1112     {
1113         my $r_cmd_file = $c->path_to($r_script);
1114         copy( $r_cmd_file, $in_file )
1115           or die "could not copy '$r_cmd_file' to '$in_file'";
1116     }
1117
1118     my $config_args = {
1119         'temp_dir' => $temp_dir,
1120         'out_file' => $out_file,
1121         'err_file' => $err_file
1122     };
1123
1124     my $job_config = $c->controller('solGS::AsyncJob')
1125       ->create_cluster_config( $c, $config_args );
1126
1127     my $cmd =
1128       "Rscript --slave $in_file $out_file --args $input_files $output_files";
1129
1130     my $args = {
1131         'cmd'            => $cmd,
1132         'temp_dir'       => $temp_dir,
1133         'config'         => $job_config,
1134         'background_job' => $background_job,
1135     };
1136
1137     $c->stash->{combine_populations_args} = $args;
1138
1139 }
1140
1141 sub get_combine_populations_args_file {
1142     my ( $self, $c ) = @_;
1143
1144     my $traits = $c->stash->{training_traits_ids} || [ $c->stash->{trait_id} ];
1145     my $protocol_id = $c->stash->{genotyping_protocol_id};
1146
1147     my $combine_jobs = [];
1148
1149     $self->get_combined_pops_list($c);
1150     my $trials = $c->stash->{combo_pops_list};
1151
1152     $c->controller('solGS::AsyncJob')
1153       ->training_pop_data_query_job_args( $c, $trials, $protocol_id );
1154     my $query_jobs = $c->stash->{training_pop_data_query_job_args};
1155
1156     my $preq_jobs = {};
1157
1158     foreach my $trait_id (@$traits) {
1159         $c->stash->{trait_id} = $trait_id;
1160         $c->controller('solGS::Trait')->get_trait_details($c);
1161         $self->r_combine_populations_args($c);
1162         push @$combine_jobs, $c->stash->{combine_populations_args};
1163     }
1164
1165     if ( $query_jobs->[0] ) {
1166         $preq_jobs->{1} = $query_jobs;
1167         $preq_jobs->{2} = $combine_jobs;
1168     }
1169     else {
1170         $preq_jobs = $combine_jobs;
1171     }
1172
1173     my $temp_dir  = $c->stash->{solgs_tempfiles_dir};
1174     my $args_file = $c->controller('solGS::Files')
1175       ->create_tempfile( $temp_dir, 'combine_pops_args_file' );
1176
1177     nstore $preq_jobs, $args_file
1178       or croak
1179 "combine pops args file: $! serializing combine pops args  to $args_file ";
1180
1181     $c->stash->{combine_populations_args_file} = $args_file;
1182
1183 }
1184
1185 sub combined_pops_gs_input_files {
1186     my ( $self, $c ) = @_;
1187
1188     $self->cache_combined_pops_data($c);
1189     my $combined_pops_pheno_file = $c->stash->{trait_combined_pheno_file};
1190     my $combined_pops_geno_file  = $c->stash->{trait_combined_geno_file};
1191
1192     #$c->controller('solGS::solGS')->save_model_info_file($c);
1193
1194     $c->controller('solGS::Files')->model_info_file($c);
1195     my $model_info_file = $c->stash->{model_info_file};
1196
1197     my $trait_abbr   = $c->stash->{trait_abbr};
1198     my $temp_dir     = $c->stash->{solgs_tempfiles_dir};
1199     my $dataset_file = $c->controller('solGS::Files')
1200       ->create_tempfile( $temp_dir, "dataset_info_${trait_abbr}" );
1201     write_file( $dataset_file, { binmode => ':utf8' }, 'combined_populations' );
1202
1203     my $training_pop_id  = $c->stash->{training_pop_id};
1204     my $selection_pop_id = $c->stash->{selection_pop_id};
1205     my $selection_population_file;
1206
1207     if ($selection_pop_id) {
1208         $c->controller('solGS::Files')
1209           ->selection_population_file( $c, $selection_pop_id );
1210         $selection_population_file = $c->stash->{selection_population_file};
1211     }
1212
1213     my $input_files = join( "\t",
1214         $combined_pops_pheno_file, $combined_pops_geno_file, $model_info_file,
1215         $dataset_file, $selection_population_file, );
1216
1217     my $input_file =
1218       $c->controller('solGS::Files')
1219       ->create_tempfile( $temp_dir,
1220         "input_files_${trait_abbr}_${training_pop_id}" );
1221     write_file( $input_file, { binmode => ':utf8' }, $input_files );
1222
1223     $c->stash->{combined_pops_gs_input_files} = $input_file;
1224
1225 }
1226
1227 sub count_combined_trials_lines {
1228     my ( $self, $c, $combo_pops_id, $trait_id ) = @_;
1229
1230     $combo_pops_id = $c->stash->{combo_pops_id} if !$combo_pops_id;
1231     $trait_id      = $c->stash->{trait_id}      if !$trait_id;
1232
1233     my $genos_cnt;
1234     my @geno_lines;
1235     my @genotypes;
1236
1237     if ( $c->req->path =~ /solgs\/model\/combined\/populations\// ) {
1238
1239         $self->cache_combined_pops_data($c);
1240         my $combined_pops_geno_file = $c->stash->{trait_combined_geno_file};
1241
1242         if ( -s $combined_pops_geno_file ) {
1243             my $args = {
1244                 'training_pop_id' => $combo_pops_id,
1245                 'trait_id'        => $trait_id
1246             };
1247
1248             $genos_cnt = $c->controller('solGS::solGS')
1249               ->count_predicted_lines( $c, $args );
1250         }
1251     }
1252     else {
1253         $self->get_combined_pops_list($c);
1254         my $pops_ids = $c->stash->{combined_pops_list};
1255
1256         $self->multi_pops_geno_files( $c, $pops_ids );
1257         my $geno_files = $c->stash->{multi_pops_geno_files};
1258
1259         my @geno_files = split( /\t/, $geno_files );
1260
1261         foreach my $geno_file (@geno_files) {
1262             my $genos = qx /cut -f 1 $geno_file/;
1263             my @genos = split( " ", $genos );
1264             push @genotypes, @genos;
1265         }
1266
1267         $genos_cnt = scalar( uniq(@genotypes) );
1268     }
1269
1270     return $genos_cnt;
1271
1272 }
1273
1274 sub process_trials_list_details {
1275     my ( $self, $c ) = @_;
1276
1277     my $data_str = $c->stash->{data_structure};
1278
1279     if ( $data_str =~ /list/ ) {
1280         $c->controller('solGS::List')->get_list_trials_ids($c);
1281     }
1282     elsif ( $data_str =~ /dataset/ ) {
1283         $c->controller('solGS::Dataset')->get_dataset_trials_ids($c);
1284     }
1285
1286     my $pops_ids =
1287          $c->stash->{pops_ids_list}
1288       || $c->stash->{trials_ids}
1289       || [ $c->stash->{pop_id} ];
1290
1291     my %pops_names = ();
1292
1293     if ( $pops_ids->[0] ) {
1294         foreach my $p_id (@$pops_ids) {
1295             my $pr_rs =
1296               $c->controller('solGS::Search')->get_project_details( $c, $p_id );
1297             $pops_names{$p_id} = $c->stash->{project_name};
1298         }
1299
1300         if ( scalar(@$pops_ids) > 1 ) {
1301             $c->stash->{pops_ids_list} = $pops_ids;
1302             $c->controller('solGS::combinedTrials')
1303               ->create_combined_pops_id($c);
1304         }
1305     }
1306
1307     $c->stash->{trials_names} = \%pops_names;
1308
1309 }
1310
1311 sub find_common_traits {
1312     my ( $self, $c ) = @_;
1313
1314     my $combo_pops_id = $c->stash->{combo_pops_id};
1315
1316     $self->get_combined_pops_list($c);
1317     my $combined_pops_list = $c->stash->{combined_pops_list};
1318
1319     my @common_traits;
1320     foreach my $trial_id (@$combined_pops_list) {
1321
1322 #       my $trial_traits = $c->controller('solGS::Search')->model($c)->trial_traits($pop_id);
1323 #       my $clean_traits = $c->controller('solGS::Utils')->remove_ontology($c, $trial_traits);
1324         my $trait_names = $c->controller('solGS::Utils')
1325           ->get_clean_trial_trait_names( $c, $trial_id );
1326
1327         # foreach my $tr (@$clean_traits)
1328         # {
1329         #     push @trait_names, $tr->{trait_name};
1330         # }
1331
1332         if (@common_traits) {
1333             @common_traits = intersect( @common_traits, @$trait_names );
1334         }
1335         else {
1336             @common_traits = @$trait_names;
1337         }
1338     }
1339
1340     $c->stash->{common_traits} = \@common_traits;
1341 }
1342
1343 sub save_common_traits_acronyms {
1344     my ( $self, $c ) = @_;
1345
1346     my $combo_pops_id = $c->stash->{combo_pops_id};
1347
1348     $self->find_common_traits($c);
1349     my $common_traits = $c->stash->{common_traits};
1350
1351     $c->stash->{training_pop_id} = $combo_pops_id;
1352     $c->controller('solGS::Files')->traits_list_file( $c, $combo_pops_id );
1353     my $traits_file = $c->stash->{traits_list_file};
1354     $common_traits = join( "\t", @$common_traits );
1355     write_file( $traits_file, { binmode => ':utf8' }, $common_traits )
1356       if $traits_file;
1357
1358 }
1359
1360 sub prepare_multi_pops_data {
1361     my ( $self, $c ) = @_;
1362
1363     $self->get_combined_pops_list($c);
1364     my $combined_pops_list = $c->stash->{combined_pops_list};
1365
1366     $self->multi_pops_phenotype_data( $c, $combined_pops_list );
1367     $self->multi_pops_genotype_data( $c, $combined_pops_list );
1368     $self->multi_pops_geno_files( $c, $combined_pops_list );
1369     $self->multi_pops_pheno_files( $c, $combined_pops_list );
1370
1371     my @all_jobs = (
1372         @{ $c->stash->{multi_pops_pheno_jobs_ids} },
1373         @{ $c->stash->{multi_pops_geno_jobs_ids} }
1374     );
1375
1376     my $prerequisite_jobs;
1377
1378     if ( @all_jobs && scalar(@all_jobs) > 1 ) {
1379         $prerequisite_jobs = join( ':', @all_jobs );
1380
1381     }
1382     else {
1383         if ( @all_jobs && scalar(@all_jobs) == 1 ) {
1384             $prerequisite_jobs = $all_jobs[0];
1385         }
1386     }
1387
1388     if ( $prerequisite_jobs =~ /^:+$/ ) { $prerequisite_jobs = undef; }
1389
1390     #$c->stash->{prerequisite_jobs} = $prerequisite_jobs;
1391     $c->stash->{multi_pops_data_jobs} = $prerequisite_jobs;
1392 }
1393
1394 sub combine_trait_data_input {
1395     my ( $self, $c ) = @_;
1396
1397     my $combo_pops_id = $c->stash->{combo_pops_id};
1398     my $trait_id      = $c->stash->{trait_id};
1399     my $trait_abbr    = $c->stash->{trait_abbr};
1400
1401     $self->get_combined_pops_list($c);
1402     my $combo_pops_list = $c->stash->{combined_pops_list};
1403     $self->multi_pops_geno_files( $c, $combo_pops_list );
1404     $self->multi_pops_pheno_files( $c, $combo_pops_list );
1405     my $pheno_files = $c->stash->{multi_pops_pheno_files};
1406     my $geno_files  = $c->stash->{multi_pops_geno_files};
1407
1408     $self->cache_combined_pops_data($c);
1409     my $combined_pops_pheno_file = $c->stash->{trait_combined_pheno_file};
1410     my $combined_pops_geno_file  = $c->stash->{trait_combined_geno_file};
1411
1412 # my $trait_info  = $trait_id . "\t" . $trait_abbr;
1413 # my $trait_file  = $c->controller('solGS::Files')->create_tempfile($temp_dir, "trait_info_${trait_id}");
1414 # write_file($trait_file, {binmode => ':utf8'}, $trait_info);
1415
1416     $c->controller('solGS::solGS')->save_model_info_file($c);
1417
1418     $c->controller('solGS::Files')->model_info_file($c);
1419     my $model_info_file = $c->stash->{model_info_file};
1420
1421     $c->stash->{cache_dir} = $c->stash->{solgs_cache_dir};
1422     $c->controller('solGS::Files')->analysis_report_file($c);
1423     my $analysis_type = $c->stash->{analysis_type};
1424     $analysis_type =~ s/\s+/_/g;
1425     my $analysis_report_file = $c->stash->{"${analysis_type}_report_file"};
1426
1427     $c->controller("solGS::Files")->trait_raw_phenodata_file($c);
1428     my $trait_raw_phenodatafile = $c->stash->{trait_raw_phenodata_file};
1429     my $input_files =
1430       join( "\t", $pheno_files, $geno_files, $model_info_file, );
1431
1432     my $output_files = join( "\t",
1433         $combined_pops_pheno_file, $combined_pops_geno_file,
1434         $trait_raw_phenodatafile,  $analysis_report_file );
1435
1436     my $temp_dir = $c->stash->{solgs_tempfiles_dir};
1437     my $tempfile_input =
1438       $c->controller('solGS::Files')
1439       ->create_tempfile( $temp_dir,
1440         "input_files_${trait_abbr}_${combo_pops_id}_combine" );
1441     write_file( $tempfile_input, { binmode => ':utf8' }, $input_files );
1442
1443     my $tempfile_output =
1444       $c->controller('solGS::Files')
1445       ->create_tempfile( $temp_dir,
1446         "output_files_${trait_abbr}_${combo_pops_id}_combine" );
1447     write_file( $tempfile_output, { binmode => ':utf8' }, $output_files );
1448
1449     die "\nCan't call combine populations R script without a trait id."
1450       if !$trait_id;
1451     die "\nCan't call combine populations R script without input files."
1452       if !$input_files;
1453     die "\nCan't call combine populations R script without output files."
1454       if !$output_files;
1455
1456     $c->stash->{combine_input_files}  = $tempfile_input;
1457     $c->stash->{combine_output_files} = $tempfile_output;
1458     $c->stash->{combine_r_temp_file} =
1459       "combine-pops-${combo_pops_id}_${trait_abbr}";
1460 }
1461
1462 sub r_combine_populations {
1463     my ( $self, $c ) = @_;
1464
1465     $self->combine_trait_data_input($c);
1466     $c->stash->{r_script} = 'R/solGS/combine_populations.r';
1467
1468     $c->controller('solGS::AsyncJob')->run_r_script($c);
1469
1470 }
1471
1472 sub create_combined_pops_id {
1473     my ( $self, $c ) = @_;
1474
1475     $c->stash->{combo_pops_id} =
1476       crc( join( '', @{ $c->stash->{pops_ids_list} } ) );
1477
1478 }
1479
1480 sub begin : Private {
1481     my ( $self, $c ) = @_;
1482
1483     $c->controller('solGS::Files')->get_solgs_dirs($c);
1484
1485 }
1486
1487 #####
1488 1;
1489 #####