eval 'exec $PERL_PATH/perl -w -S $0 ${1+"$@"}' if 0;  

# save intermediate files in separate folders, easier to delete afterwards

  # Force all variables to be declared.
  
use strict;
# Get other required libraries.
if (! (defined $ENV{WRAPPER_UTILS})) {
  die "*** Env. var. WRAPPER_UTILS not set; quitting...\n";
}

use lib "$ENV{WRAPPER_UTILS}";
use POSIX qw(ceil);

require 'PSEutils.pl';

# Import module for command-line inputs.
# Added "w" switch for using data uncertainties, TYB 5/01/07.
# Corrected indexing problem for $tile_uncertainty_list_for_SNR - 9/9/08 (TYB)

use Getopt::Std;

my %options = ();
getopts("n:o:O:m:M:d:S:p:I:F:P:brwR:cG:",\%options);
#n - namelist;
#O - output directory;
#M - Pmask;
#d - DCE status masks list (d or b mask)
#I - input image list file name;
#S - Sigma List file name
#F - FIF filename
#P - Mosaic PRF
#p - single frame PRF
#m - PRF Map filename
#o - output extract table filename
#b - switch for background fitting in sourcestimate
#r - use refined pointing switch
#R - Rmask list file name
#c - switch to use uncertainties to coadd
#G - Static Gain Correction image name (for blue reflattening)
#w - use data uncertainties for fitted SNR

my $verbose = 1;
my $version = '4.4';
my $iam = "apex.pl";
my $heading = "Wrapper-script: ${iam}, ".
            "Version $version\n\n".
            "By David Makovoz (davidm\@ipac.caltech.edu)\n".
            "Copyright (C) 2006 California Institute of ".
            "Technology";
 
 if ($verbose) {
    print "=================================================================";
    print "\nWrapper-script $iam, Version $version\n\n";
 }

my $NL_name = $options{"n"} || "apex.nl";
my $NLpath = my_set_path("SIRTF_CDF","./cdf");
my $NL_file_name = $NLpath.$NL_name;
my @NL_file;
ReadFileIntoList($NL_file_name, \@NL_file, $iam, $verbose);
check_commas(@NL_file);

$verbose = read_namelist( "verbose", 1,@NL_file );

my $OUTPUT_DIR = $options{"O"} ||read_namelist( "OUTPUT_DIR", "", @NL_file );

if($OUTPUT_DIR ne "" && !($OUTPUT_DIR =~ /\/$/)){$OUTPUT_DIR .= '/'};
# set up subdirectories for intermediate files
if (! (-e $OUTPUT_DIR)) {
  my $sys_command = "mkdir -p $OUTPUT_DIR";
  system($sys_command);
}
# { mkdir $OUTPUT_DIR, 0777;}

my $IMAGE_STACK_FILE_NAME = $options{"I"} || 
  read_namelist( "IMAGE_STACK_FILE_NAME", "image_stack.txt", @NL_file );

my $BASE_FILE_NAME = strip_pathname($IMAGE_STACK_FILE_NAME);

my $PRFpath = my_set_path("SIRTF_CAL","./cal");

my $MOSAIC_PRF_file_name = $options{"P"} ||
  read_namelist( "MOSAIC_PRF_file_name", "", @NL_file );

if ( (! (-e $MOSAIC_PRF_file_name)) && ($MOSAIC_PRF_file_name ne "")){
  $MOSAIC_PRF_file_name = $PRFpath.$MOSAIC_PRF_file_name;
}

my $PRF_file_name = $options{"p"} ||
  read_namelist( "PRF_file_name", "", @NL_file );

if( (! (-e $PRF_file_name)) && ($PRF_file_name ne "")){
  $PRF_file_name = $PRFpath.$PRF_file_name;
}

my $PRFMAP_FILE_NAME = $options{"m"} ||
  read_namelist( "PRFMAP_FILE_NAME", "", @NL_file );
if($PRFMAP_FILE_NAME eq ""){
  $PRFMAP_FILE_NAME = $OUTPUT_DIR."PRF_Map.tbl";
}

my $SIGMALIST_FILE_NAME = $options{"S"} ||
  read_namelist( "SIGMALIST_FILE_NAME", "", @NL_file );
my $Default_SIGMALIST_FILE_NAME = "SigmaList.txt";


my $DCE_STATUS_MASK_LIST = $options{"d"} || 
  read_namelist( "DCE_STATUS_MASK_LIST", "", @NL_file );
my $have_dmask = 1;
if($DCE_STATUS_MASK_LIST eq ""){
  $have_dmask = 0;
}

my $RMASK_LIST = $options{"R"} || 
  read_namelist( "RMASK_LIST", "", @NL_file );
my $have_rmask = 1;
if($RMASK_LIST eq ""){
  $have_rmask = 0;
}

my $PMASK_FILE_NAME = $options{"M"} ||
  read_namelist( "PMASK_FILE_NAME", "", @NL_file );
my $have_pmask = 1;
if($PMASK_FILE_NAME eq ""){
  $have_pmask = 0;
}

my $GAIN_CORRECTION_FILE_NAME = $options{"G"} ||
  read_namelist( "GAIN_CORRECTION_FILE_NAME", "", @NL_file );
my $have_gain_correction = 1;
if($GAIN_CORRECTION_FILE_NAME eq ""){
  $have_gain_correction = 0;
}

my $FIF_FILE_NAME = $options{"F"} ||read_namelist( "FIF_FILE_NAME", "", @NL_file );
if($FIF_FILE_NAME eq ""){
  $FIF_FILE_NAME = $OUTPUT_DIR."FIF.tbl";
}
my $OUTPUT_FILE = $options{"o"} ||
  read_namelist( "OUTPUT_FILE", "extract.tbl", @NL_file );

my $raw_extract_file =  $OUTPUT_DIR."extract_raw.tbl";

$OUTPUT_FILE = $OUTPUT_DIR. $OUTPUT_FILE;

my $MOSAIC_PIXEL_RATIO_X = read_namelist( "MOSAIC_PIXEL_RATIO_X", 1, @NL_file );
my $MOSAIC_PIXEL_RATIO_Y = read_namelist( "MOSAIC_PIXEL_RATIO_Y", 1, @NL_file );

my $MOSAIC_PIXEL_SIZE_X = read_namelist( "MOSAIC_PIXEL_SIZE_X", 0, @NL_file );
my $MOSAIC_PIXEL_SIZE_Y = read_namelist( "MOSAIC_PIXEL_SIZE_Y", 0, @NL_file );

my $PROBABILITY_THRESHOLD = read_namelist( "PROBABILITY_THRESHOLD", 0, @NL_file );
my $use_probability_threshold = 0;
if($PROBABILITY_THRESHOLD > 0){
  $use_probability_threshold = 1;
}
my $DCE_Status_Mask_Fatal_BitPattern = read_namelist( "DCE_Status_Mask_Fatal_BitPattern", 0, @NL_file );
my $PMask_Fatal_BitPattern = read_namelist( "PMask_Fatal_BitPattern", 0, @NL_file );
my $RMask_Fatal_BitPattern = read_namelist( "RMask_Fatal_BitPattern", 0, @NL_file );

my $last_run;
my $delete_intermediate_files = read_namelist("delete_intermediate_files",0, @NL_file );
my $use_psp_to_detect = read_namelist( "use_psp_to_detect", 1,@NL_file );
my $use_background_subtracted_image_for_fitting = 
  read_namelist( "use_background_subtracted_image_for_fitting", 1, @NL_file );

my $use_background_subtracted_image_for_aperture = 
  read_namelist( "use_background_subtracted_image_for_aperture", 1, @NL_file );
# Added switch to use data unc. for fitted flux SNR, TYB 5/01/07

my $use_data_unc_for_fitted_SNR = $options{"w"} ||
    read_namelist( "use_data_unc_for_fitted_SNR", 0, @NL_file );

my $create_std_mosaic = read_namelist("create_std_mosaic",0, @NL_file );
my $create_unc_mosaic = read_namelist("create_unc_mosaic",1, @NL_file );
my $use_std_to_detect =read_namelist("use_std_to_detect",0, @NL_file );
my $use_unc_to_detect = read_namelist("use_unc_to_detect",1, @NL_file );

my $save_namelist = read_namelist("save_namelist",0, @NL_file );
my $sigma_weighted_coadd    = $options{"c"} ||read_namelist( "sigma_weighted_coadd",   0,@NL_file );
my $use_refined_pointing = $options{"r"} ||read_namelist( "USE_REFINED_POINTING", 0, @NL_file );
my $NICE = read_namelist( "NICE", 0, @NL_file );
if($NICE){
  $NICE = 19;
}

my $select_conditions =  read_namelist("select_conditions", "", @NL_file );
my $select_columns =  read_namelist("select_columns", ",", @NL_file );

my $select_detect_conditions =  read_namelist("select_detect_conditions", "", @NL_file );
my $select_detect_columns =  read_namelist("select_detect_columns", ",", @NL_file );

 # Set auto-flush.
  
  select STDERR; $| = 1; select STDOUT; $| = 1;

my($status, $sys_command, $input_files, $output_files, $commandline);

#to do list
my $run_fiducial_image_frame = read_namelist( "run_fiducial_image_frame", 0,@NL_file );
my $have_sigma = read_namelist( "have_uncertainties", 0,@NL_file );
my $run_snestimator_sigma = read_namelist( "compute_uncertainties_internally", 0,@NL_file );
my $run_mosaic_int = read_namelist( "run_mosaic_int", 0,@NL_file );
my $run_mosaic_coadd = read_namelist( "run_mosaic_coadd", 0,@NL_file );
my $run_mosaic_combiner = read_namelist( "run_mosaic_combiner", 0,@NL_file );
my $run_detect_medfilter = read_namelist( "run_detect_medfilter", 0,@NL_file );
my $run_pointsourceprob = read_namelist( "run_pointsourceprob", 0,@NL_file );
my $run_bright_detect = read_namelist( "run_bright_detect", 0,@NL_file );
my $use_bright_object_mask = read_namelist( "use_bright_object_mask", 0,@NL_file );
my $run_detect = read_namelist( "run_detect", 0,@NL_file );
my $run_select_detect = read_namelist( "run_select_detect", 0,@NL_file );
my $run_gaussnoise = read_namelist( "run_gaussnoise", 0,@NL_file );
my $run_extract_medfilter = read_namelist( "run_extract_medfilter", 0,@NL_file );
my $run_fit_radius = read_namelist( "run_fit_radius", 0,@NL_file );
my $run_sourcestimate = read_namelist( "run_sourcestimate", 0,@NL_file );
my $run_aperture = read_namelist( "run_aperture", 0,@NL_file );
my $run_select = read_namelist( "run_select", 0,@NL_file );

if($sigma_weighted_coadd && !$have_sigma && !$run_snestimator_sigma){
  $sigma_weighted_coadd = 0;
    print "WARNING: sigma_weighted_coadd will be ignored since no sigma is given or requested\n\n\n";
}

#end to do list
my $med_dir            = read_namelist( "MEDFILTER_DIR",     "Medfilter",     @NL_file );
setup_subdir(\$med_dir,$OUTPUT_DIR,$run_extract_medfilter || $run_detect_medfilter);

my $sigma_dir          = read_namelist( "SIGMA_DIR",         "Sigma",         @NL_file );
setup_subdir(\$sigma_dir,$OUTPUT_DIR,$run_snestimator_sigma);

my $interp_dir         = read_namelist( "INTERP_DIR",        "Interp",        @NL_file );
setup_subdir(\$interp_dir,$OUTPUT_DIR,$run_mosaic_int);

my $coadder_dir        = read_namelist( "COADDER_DIR",       "Coadd",         @NL_file );
setup_subdir(\$coadder_dir,$OUTPUT_DIR,$run_mosaic_coadd);

my $combiner_dir       = read_namelist( "COMBINER_DIR",      "Combine",       @NL_file );
setup_subdir(\$combiner_dir,$OUTPUT_DIR,$run_mosaic_combiner);

my $medsub_image_list = $med_dir."medsub_".$BASE_FILE_NAME;
my $header_list_table = $OUTPUT_DIR."header_list.tbl";
my $fif_file_name = $OUTPUT_DIR."mosaic_fif.tbl";

my $interp_prefix  = $interp_dir."interp";
my $interp_covg_suffix  = "covg";
my $coadd_prefix  = $coadder_dir."coadd";
my $combine_prefix  = $combiner_dir."combine";

my $interpolated_images_table = $interp_prefix."_".$BASE_FILE_NAME.".tbl";
my $interpolated_images_list = $interp_prefix."_".$BASE_FILE_NAME;
my $interpolated_uncertainty_list; # set later
my $interpolated_covgmap_list= $interp_prefix."_covgmap_".$BASE_FILE_NAME;

my $tile_file_name;
my $tile_bcd_file_name = $coadd_prefix."_tile_bcd.txt";
my $tile_table = $coadd_prefix."_tiles.tbl";
my $tile_list = $coadd_prefix."_Tiles_List";  #hard coded
my $tile_minback_list = $coadd_prefix."_MinBack_Tiles_List";  #hard coded
my $tile_uncertainty_list = $coadd_prefix."_Sigma_Tiles_List";
my $tile_coverage_list = $coadd_prefix."_Cov_Tiles_List";
my $tile_std_list = $coadd_prefix."_Std_Tiles_List";

# Added for data unc. switch, TYB 8/27/07
my $tile_uncertainty_list_for_SNR = $coadd_prefix."_Sigma_Tiles_List_for_SNR";

my $combine_tile_bcd_file_name = $combine_prefix."_tile_bcd.txt";
my $combine_tile_table = $combine_prefix."_tiles.tbl";
my $combine_tile_list = $combine_prefix."_Tiles_List";  #hard coded

my $mosaic_image_file_name  = $combiner_dir."mosaic.fits";
my $mosaic_minback_image_file_name  = $combiner_dir."mosaic_minback.fits";
my $mosaic_uncertainty_file_name  = $combiner_dir."mosaic_unc.fits";
my $mosaic_std_file_name  = $combiner_dir."mosaic_std.fits";
my $mosaic_coverage_file_name  = $combiner_dir."mosaic_cov.fits";

my @tile_numbers;
my @tile_bcd_file;
my @tile_list_file;
my $tile_number;
my $number_of_tiles;
my ($tile_detect_file_name, @tile_detect_bright_file_name, $tile_detect_bright_mask);
my $mosaic_detect_file_name = $OUTPUT_DIR."mosaic_detect.tbl";
my $mosaic_detect_raw_file_name = $OUTPUT_DIR."mosaic_detect_raw.tbl";
my $mosaic_detect_bright_file_name = $OUTPUT_DIR."mosaic_detect_bright.tbl";
my $sigma_file_name;
my $input_file_name;
my @image_stack;
my @Dmask_stack;
my $DCE_Status_Mask;
my @Rmask_stack;
my $RMask;
my $line;
my $list_mosaic_noise_file_name = $coadd_prefix."_noise_list.txt";
my $tile_noise_file_name;
my $tile_snr_file_name;
my $snr_Filtered_file_name;
my $Filtered_file_name;
my $tile_minus_median_file_name;
my $tile_coverage_map_file_name;
my @tile_uncertainty_list_file;
my $aperture_file_name =  $OUTPUT_DIR."aperture.tbl";
my $input_minus_median_file_name;
my $i;
my $nmask;  

#loop over ImageStack to create a list of sigma files

# create lists if warranted
ReadFileIntoList($IMAGE_STACK_FILE_NAME, \@image_stack, $iam, $verbose);
my $N_Images = @image_stack;

if($run_mosaic_int){
  open(OUT,">$interpolated_covgmap_list") or
    myexit64($iam,"Couldn't open $interpolated_covgmap_list; quitting",$verbose);
  for($i=0;$i<$N_Images;$i++){ 
    chomp ($input_file_name = $image_stack[$i]);
    $input_file_name =  $interp_prefix."_".strip_pathname($input_file_name);
    $input_file_name  =~ s/\.fits/_$interp_covg_suffix.fits/;  
    print OUT "$input_file_name\n";
  }
  close(OUT) or myexit64($iam,"Couldn't close $interpolated_covgmap_list; quitting",$verbose);
}

if($run_mosaic_int){
  open(OUT,">$interpolated_images_list") or
    myexit64($iam,"Couldn't open $interpolated_images_list; quitting",$verbose);
  for($i=0;$i<$N_Images;$i++){ 
    chomp ($input_file_name = $image_stack[$i]);
    $input_file_name =  $interp_prefix."_".strip_pathname($input_file_name);
    print OUT "$input_file_name\n";
  }
  close(OUT) or myexit64($iam,"Couldn't close $interpolated_images_list; quitting",$verbose);
}

#end of list creation

if($have_dmask){
  ReadFileIntoList($DCE_STATUS_MASK_LIST, \@Dmask_stack, $iam, $verbose); 
}

if($have_rmask){
  ReadFileIntoList($RMASK_LIST, \@Rmask_stack, $iam, $verbose); 
}

#if $have_sigma is set then $SIGMALIST_FILE_NAME should be present
# it could be one produced by snestimator during a previous run
#or an external file. $iam expects to find it and use it
# if both $have_sigma and $run_snestimator_sigma are set
# then issue a warning message that $run_snestimator_sigma setting
#will be ignored
# if only $run_snestimator_sigma is set run it and use sigma file
# if neither is set don't use sigma file

my $use_sigma = $run_snestimator_sigma || $have_sigma;

if($use_unc_to_detect && !$use_sigma){
  print "WARNING!!! Cannot use unc to detect, input unc are not given\n";
  $use_unc_to_detect = 0;
}

if($use_unc_to_detect && $use_std_to_detect){
  $use_std_to_detect = 0;
  print "WARNING!!! Using unc to detect\n";
}

if($create_unc_mosaic && !$use_sigma){
  print "WARNING!!! mosaic_unc will not be created, no input unc are given\n";
}

if($use_unc_to_detect && !$create_unc_mosaic){
  print "WARNING!!! Make sure mosaic unc has been created\n";
}

if($use_std_to_detect && !$create_std_mosaic){
  print "WARNING!!! Make sure mosaic std has been created\n";
}



if($use_sigma && $SIGMALIST_FILE_NAME eq ""){
  $SIGMALIST_FILE_NAME = $sigma_dir.$Default_SIGMALIST_FILE_NAME; 
}

if($use_sigma){
    $interpolated_uncertainty_list = $interp_prefix."_".strip_pathname($SIGMALIST_FILE_NAME); 
}

if($have_sigma){
  if (! (-e $SIGMALIST_FILE_NAME )) {
      myexit64($iam,"$SIGMALIST_FILE_NAME does not exist; quitting",$verbose);
  }


  if($run_snestimator_sigma && $verbose){
    print "using $SIGMALIST_FILE_NAME, ignore \"compute_uncertainties_internally\" setting!\n";
  }
}
elsif($run_snestimator_sigma){

  open(OUTSIGMA,">$SIGMALIST_FILE_NAME") or
    myexit64($iam,"Couldn't open $SIGMALIST_FILE_NAME; quitting",$verbose);

  for($i=0;$i<$N_Images;$i++){ 
    chomp ($input_file_name = $image_stack[$i]);
    $sigma_file_name = $sigma_dir.strip_pathname($input_file_name); 
    $sigma_file_name =~ s/\.fits/_sigma\.fits/;
  
    if($have_dmask){
      $DCE_Status_Mask = $Dmask_stack[$i];
      chomp $DCE_Status_Mask;
      if(!defined $DCE_Status_Mask ) 
	{myexit64($iam,"Ran out of mask images in $DCE_STATUS_MASK_LIST; quitting",$verbose);}
      # the bit pattern for the masks is set in the namefile
    }

    $commandline = "a=&n=$NL_name"."&log=$NLpath"."/log_snestimator_sigma"."&den=4";
    $input_files = "i=$input_file_name";
    if($have_pmask){
      $input_files .= "&p=$PMASK_FILE_NAME";
      $commandline .= "&pm=$PMask_Fatal_BitPattern";
    }
    if($have_dmask){
      $input_files .= "&d=$DCE_Status_Mask";
      $commandline .= "&dm=$DCE_Status_Mask_Fatal_BitPattern";
   }

    $output_files = "on=$sigma_file_name";
    if($status = run_all("snestimator", $input_files,$output_files,$commandline,$verbose-$NICE)){
      exit($status);}
    print OUTSIGMA "$sigma_file_name\n";
  }
  close(OUTSIGMA) or myexit64($iam,"Couldn't close $SIGMALIST_FILE_NAME; quitting",$verbose);

  reset_last(\$last_run,\$run_snestimator_sigma);
#keep track of the last step run, not to delete it as an intermediate product
#run_something = -1 means something was the last step
}

# run fiducial_image_frame

  if($run_fiducial_image_frame){
#first run the script to create the input file for the fiducial_image_frame module
    my $sys_command = " -I $IMAGE_STACK_FILE_NAME -O $header_list_table";
    print "$sys_command \n";
    if($status = run_script("fiducial_frame.pl ",$sys_command,$verbose)){
      exit($status)};  
    
    
    #now run fiducial_image_frame itself
    $commandline = "n=$NL_name";
    $input_files = "i=$header_list_table";
    $output_files = "o=$FIF_FILE_NAME";
    if($status = run_all("fiducial_image_frame", $input_files,$output_files,$commandline,
			 $verbose-$NICE)){
      exit($status);}  
  }

# run mosaicer

#run mosaic_int
if($run_mosaic_int){
  $input_files = "fi=$FIF_FILE_NAME&id=$IMAGE_STACK_FILE_NAME";
  $commandline = "n=$NL_name&o=$interp_prefix"; 
  if($MOSAIC_PIXEL_SIZE_X != 0){
    $commandline .= "&ms1=$MOSAIC_PIXEL_SIZE_X"; 
  }
  else{
    $commandline .= "&mr1=$MOSAIC_PIXEL_RATIO_X"; 
  }
  if($MOSAIC_PIXEL_SIZE_Y != 0){
    $commandline .= "&ms2=$MOSAIC_PIXEL_SIZE_Y"; 
  }
  else{
    $commandline .= "&mr2=$MOSAIC_PIXEL_RATIO_Y"; 
  }
  if($use_sigma){
    $input_files .= "&iu=$SIGMALIST_FILE_NAME";
  }
  if($have_dmask){
    $input_files .= "&d=$DCE_STATUS_MASK_LIST";
    $commandline .= "&td=$DCE_Status_Mask_Fatal_BitPattern";
  }
  if($have_pmask){
    $input_files .= "&p=$PMASK_FILE_NAME";
    $commandline .= "&tp=$PMask_Fatal_BitPattern";
  }
  if($have_gain_correction){
    $commandline .= "&gain=$GAIN_CORRECTION_FILE_NAME";
  }
  if($have_rmask){
    $input_files .= "&b=$RMASK_LIST";
    $commandline .= "&tb=$RMask_Fatal_BitPattern";
  }
  $output_files = "g=$interpolated_images_table&fo=$fif_file_name";
  $commandline .= "&c=$interp_covg_suffix";
  if($use_refined_pointing){
    $commandline .= "&r=";
  }
  if($status = run_all("mosaic_int", $input_files,$output_files,$commandline,$verbose-$NICE)){
    exit($status);}
  reset_last(\$last_run,\$run_mosaic_int);
}

#run mosaic_coadd
if($run_mosaic_coadd){
  $input_files = "f=$fif_file_name&g=$interpolated_images_list&c=$interpolated_covgmap_list";

  if($use_sigma){
    $input_files .="&u=$interpolated_uncertainty_list";
  }
  $output_files = "ti=$tile_bcd_file_name&to=$tile_table";

  if($create_unc_mosaic){
    $output_files .="&tu=$tile_uncertainty_list";
  }
  if($create_std_mosaic){
    $output_files .="&ts=$tile_std_list";
  }

  $commandline = "n=$NL_name&o=$coadd_prefix"; 
  if($sigma_weighted_coadd){
    $commandline .= "&uu="; 
  }
  if($status = run_all("mosaic_coadd", $input_files,$output_files,$commandline,$verbose-$NICE)){
    exit($status)};
  reset_last(\$last_run,\$run_mosaic_coadd);
}



# check $tile_bcd_file_name file for the tiles available; set @tile_numbers and $number_of_tiles
ReadFileIntoList($tile_bcd_file_name, \@tile_bcd_file, $iam, $verbose);

$number_of_tiles = 0;
for $line (@tile_bcd_file){
  if($line =~/^(\d+),(\d+)/){
    if($2>0){  #mosaic_coadd now writes out all tiles, even with 0 images
      $tile_numbers[$number_of_tiles] = $1;
      $number_of_tiles++;
    }
  }
}
if($number_of_tiles == 0){
  myexit64($iam,"no tiles have been generated in $tile_bcd_file_name",$verbose);}

ReadFileIntoList($tile_list, \@tile_list_file, $iam, $verbose);

# Input_Type is set for Detect module
my $detect_input_type = read_namelist( "Input_Type", "image_input", @NL_file );

# loop over tile; do detection
$i = 0;
if($run_gaussnoise){
  open(OUT,">$list_mosaic_noise_file_name") or 
    myexit64($iam,"Couldn't open $list_mosaic_noise_file_name; quitting",$verbose);
}

for $tile_number(@tile_numbers){
  my $PSP_file_name;
  my $snr_PSP_file_name;
  chomp ($tile_file_name = $tile_list_file[$i]);
  if($use_unc_to_detect){
    ($sigma_file_name = $tile_file_name) =~ s/Image/Unc/;
  }
  elsif($use_std_to_detect ){
    ($sigma_file_name = $tile_file_name) =~ s/Image/Std_Unc/;
  }

  ($tile_coverage_map_file_name = $tile_file_name)  =~ s/Image/Cov/;
  ($tile_minus_median_file_name = $tile_file_name)  =~ s/\.fits/_minback.fits/;
  ($tile_noise_file_name = $tile_file_name)  =~ s/\.fits/_noise\.fits/;
  ($tile_snr_file_name = $tile_file_name)  =~ s/\.fits/_snr\.fits/;
  ($Filtered_file_name = $tile_file_name)  =~ s/\.fits/_Filtered\.fits/;
  ($snr_Filtered_file_name = $tile_file_name)  =~ s/\.fits/_Filtered_snr\.fits/;
  ($PSP_file_name = $tile_file_name)  =~ s/\.fits/_PSP\.fits/;
  ($snr_PSP_file_name = $tile_file_name)  =~ s/\.fits/_PSP_snr\.fits/;
  ($tile_detect_file_name = $tile_file_name)  =~ s/\.fits/_detect\.tbl/;
  ($tile_detect_bright_file_name[$i] = $tile_file_name)  =~ s/\.fits/_detect_bright\.tbl/;
  ($tile_detect_bright_mask = $tile_file_name)  =~ s/\.fits/_detect_bright_mask\.fits/;
  # the parameters in the namelist are for the input images, should be rescaled by the
  # mosaic_ratio
  # 02/03/06 the above is changed for 2 reasons
  # 1. one may want to have separate window size for the mosaic 
  # which is used for detection and for the bcd' which is used for fitting.
  #2. It caused confusion when people commented out old Window_X (Y)
  # settings but they got used anyway, because they preceeded the new 
  #settings in the namelist

  if($run_detect_medfilter){
    $commandline = "a=&otype=2&n=$NL_name&namelist_prefix=DETECT_"."&log=$NLpath"."/log_detect_medfilter";
    $input_files = "i=$tile_file_name";
    $output_files = "o2=$tile_minus_median_file_name";
    if($status = run_all("medfilter", $input_files,$output_files,$commandline,$verbose-$NICE)){
      exit($status);}
    reset_last(\$last_run,\$run_detect_medfilter);
  }
  
  if($run_pointsourceprob){
    $commandline = "a=&n=$NL_name"."&log=$NLpath"."/log_pointsourceprob"; 
    $commandline .= '&0=';
    $input_files = "i=$tile_minus_median_file_name&prfi=$MOSAIC_PRF_file_name";  

    if($use_unc_to_detect || $use_std_to_detect ){
      $input_files .="&si=$sigma_file_name";
    }
    else{
      $commandline .= "&noise=internal_noise";
    }
    if($use_psp_to_detect){
      $output_files = "o=$PSP_file_name";
    }
    else{
      $output_files = "of=$Filtered_file_name";
    }
    if($status = run_all("pointsourceprob", $input_files,$output_files,
			 $commandline,$verbose-$NICE)){
      exit($status);}
    reset_last(\$last_run,\$run_pointsourceprob);
  }
  
  # run gaussnoise on background subtracted tile to create tile_noise images
  if($run_gaussnoise){
    printf OUT "$tile_number $tile_noise_file_name\n";
    $commandline = "a=&n=$NL_name"."&log=$NLpath"."/log_gaussnoise";
    $input_files = "i=$tile_minus_median_file_name&covmap=$tile_coverage_map_file_name";
    $output_files = "on=$tile_noise_file_name";
    if($status = run_all("gaussnoise", $input_files,$output_files,$commandline,$verbose-$NICE)){
      exit($status);}
  
    reset_last(\$last_run,\$run_gaussnoise);
  }

  if($run_bright_detect){
    $commandline = "a=&n=$NL_name"."&log=$NLpath"."/log_detect_bright&namelist_prefix=BRIGHT_";
	$commandline .= "&tyo=centroids_and_pixels_output";
    $input_files = "i=$tile_minus_median_file_name";
    $input_files .= "&ic=$tile_coverage_map_file_name";
    if($use_unc_to_detect || $use_std_to_detect ){
      $input_files .= "&is=$sigma_file_name";
    }
    $output_files = "obrt=$tile_detect_bright_file_name[$i]&of=$tile_detect_bright_mask";
    
    if($status = run_all("detect",$input_files,$output_files,$commandline,$verbose-$NICE)){
      exit($status);}
    reset_last(\$last_run,\$run_bright_detect);

#run c2s_trans
#Required arguments:
#-n      Namelist filename
#-r      Filename containing the Reference Frame
#-i      Filename containing the input table
#-o      Filename containing the outlput table 
    my $tile_fif_file_name = $coadder_dir."tile_fif.tbl";
    my @tile_detect_file = `cat $tile_detect_bright_file_name[$i]`;
    my ($tile_x, $tile_y);
    if( read_key(\$tile_x,"Tile_OffsetX",@tile_detect_file) or 
	read_key(\$tile_y,"Tile_OffsetY",@tile_detect_file) ){
      print "key Tile_OffsetX or Tile_OffsetY was not found in file $tile_detect_bright_file_name[$i] ..\n";
    }
    my @FIF_FILE = `cat $fif_file_name`;
    my ($rest, $key_value);
    open(OUTFIFFILE,">$tile_fif_file_name") or
      myexit64($iam,"Couldn't open $tile_fif_file_name; quitting",$verbose);
    for $line(@FIF_FILE){
      if( $line =~ /CRPIX1/){
	($rest,$key_value) = split("=",$line);
	$key_value =~ s/^\s*(\S*)\s*\n?/$1/; 
	$key_value =~ s/,//;	
	$key_value -= $tile_x;	
	print OUTFIFFILE "$rest = $key_value\n";	
      }
      elsif( $line =~ /CRPIX2/){
	($rest,$key_value) = split("=",$line);
	$key_value =~ s/^\s*(\S*)\s*\n?/$1/; 
	$key_value =~ s/,//;	
	$key_value -= $tile_y;		
	print OUTFIFFILE "$rest = $key_value\n";	
      }
      else{
	print OUTFIFFILE $line;
      }
    }
    close(OUTFIFFILE) or myexit64($iam,"Couldn't close $tile_fif_file_name; quitting",$verbose);
    
    $commandline = "";
    
    $input_files = "i=$tile_detect_bright_file_name[$i]&r=$tile_fif_file_name";
    $output_files = "o=' '";
    
    if($status = run_all("c2s_trans", $input_files,$output_files,$commandline,$verbose-$NICE)){
      exit($status)};
    
  } 


  if($run_detect){
    my $detect_input_file_name;
    if($detect_input_type eq 'snr_input'){
      #run gaussnoise on the PSP file
      if($use_psp_to_detect == 1){
	$commandline = "a=&n=$NL_name&namelist_prefix=PSP_".
	  "&otype=2&log=$NLpath"."/log_gaussnoise_PSP";
	$input_files = "i=$PSP_file_name";
	$output_files = "os=$snr_PSP_file_name";
	$detect_input_file_name = $snr_PSP_file_name;
	if($status = run_all("gaussnoise", $input_files,$output_files,$commandline,$verbose)){
	  exit($status)};
      }
      elsif($use_psp_to_detect == 0){
	$commandline = "a=&n=$NL_name&namelist_prefix=PSP_".
	  "&otype=2&log=$NLpath"."/log_gaussnoise_PSP";
	$input_files = "i=$Filtered_file_name";
	$output_files = "os=$snr_Filtered_file_name";
	$detect_input_file_name = $snr_PSP_file_name;
	if($status = run_all("gaussnoise", $input_files,$output_files,$commandline,$verbose)){
	  exit($status)};
      }
      else{
	$commandline = "a=&n=$NL_name&namelist_prefix=PSP_".
	  "&otype=2&log=$NLpath"."/log_gaussnoise_PSP";
	$input_files = "i=$tile_minus_median_file_name";
	$output_files = "os=$tile_snr_file_name";
	$detect_input_file_name = $tile_snr_file_name;
	if($status = run_all("gaussnoise", $input_files,$output_files,$commandline,$verbose)){
	  exit($status)};
      }
      
    }
    else{
      if($use_psp_to_detect == 1){
	$detect_input_file_name = $PSP_file_name;
      }
      elsif($use_psp_to_detect == 0){
	$detect_input_file_name = $Filtered_file_name;
      }
      else{
	$detect_input_file_name = $tile_minus_median_file_name;
      }
    }

    $commandline = "a=&n=$NL_name"."&log=$NLpath"."/log_detect";
    $input_files = "i=$detect_input_file_name";
    $input_files .= "&ic=$tile_coverage_map_file_name";

    $output_files = "o=$tile_detect_file_name";
    
    if($use_probability_threshold){
      $commandline .= "&prob=$PROBABILITY_THRESHOLD";
    }
     if($use_bright_object_mask){
      $input_files .= "&m1=$tile_detect_bright_mask";
      $commandline .= "&nmask=1&mv1=1023";
    }
   
    if($status = run_all("detect",$input_files,$output_files,$commandline,$verbose-$NICE)){
      exit($status);}
    reset_last(\$last_run,\$run_detect);
    
  } 
   $i++;

}
if($run_gaussnoise){ 
  close(OUT) or myexit64($iam,"Couldn't close $list_mosaic_noise_file_name; quitting",
			 $verbose);
}

# run mosaic_combiner four times, once for the images, once for the uncertainty, 
# once for the coverage, if aperture is run, one more time for mosaic_minback
  if($run_mosaic_combiner){
    $input_files = "g=$tile_table&f=$fif_file_name";
  $output_files = "o=$mosaic_image_file_name";
  $commandline = ""; 
  
  if($status = run_all("mosaic_combine", $input_files,$output_files,$commandline,
		       $verbose-$NICE)){
    exit($status);}
  
  if($create_unc_mosaic){
    $input_files = "g=$tile_uncertainty_list&f=$fif_file_name";
    $output_files = "o=$mosaic_uncertainty_file_name";
    $commandline = ""; 
    
    if($status = run_all("mosaic_combine", $input_files,$output_files,$commandline,
			 $verbose-$NICE)){
      exit($status);}
  }

  if($create_std_mosaic){
    $input_files = "g=$tile_std_list&f=$fif_file_name";
    $output_files = "o=$mosaic_std_file_name";
    $commandline = ""; 
    
    if($status = run_all("mosaic_combine", $input_files,$output_files,$commandline,
			 $verbose-$NICE)){
      exit($status);}
  }
  
  if($run_aperture){
    ReadReplaceWriteList($tile_list, $tile_minback_list, '.fits','_minback.fits',$iam, $verbose);
    $input_files = "g=$tile_minback_list&f=$fif_file_name";
    $output_files = "o=$mosaic_minback_image_file_name";
    $commandline = ""; 
    
    if($status = run_all("mosaic_combine", $input_files,$output_files,$commandline,
			 $verbose-$NICE)){
      exit($status);}
  }
  
  #first create $tile_coverage_list 
  
  open(OUT,">$tile_coverage_list") or
    myexit64($iam,"Couldn't open $tile_coverage_list; quitting",$verbose);
  for($i=0;$i<$number_of_tiles;$i++){ 
    chomp ($tile_coverage_map_file_name = $tile_list_file[$i]);
    $tile_coverage_map_file_name =~ s/Image/Cov/;
    print OUT "$tile_coverage_map_file_name\n";
  }
  close(OUT) or myexit64($iam,"Couldn't close $tile_coverage_list; quitting",$verbose);
  
#now run combine
  
  $input_files = "g=$tile_coverage_list&f=$fif_file_name";
  $output_files = "o=$mosaic_coverage_file_name";
  $commandline = ""; 
  
  if($status = run_all("mosaic_combine", $input_files,$output_files,$commandline,
		       $verbose-$NICE)){
    exit($status);}

  my $totalbcd_comment = "Total number of BCD\'s used in this mosaic";
  my $totalbcd_keyword = "TOTALBCD";

  write_keyword_inheader($mosaic_coverage_file_name, $totalbcd_keyword, $N_Images, 
			 $totalbcd_comment, $verbose);
  if($create_unc_mosaic){
     write_keyword_inheader($mosaic_uncertainty_file_name, $totalbcd_keyword, $N_Images,
			    $totalbcd_comment, $verbose);
  }
  if($create_std_mosaic){
     write_keyword_inheader($mosaic_std_file_name, $totalbcd_keyword, $N_Images,
			    $totalbcd_comment, $verbose);
  }
  write_keyword_inheader($mosaic_image_file_name, $totalbcd_keyword, $N_Images,
			 $totalbcd_comment, $verbose);

   reset_last(\$last_run,\$run_mosaic_combiner);
}




#loop over ImageStack to do background subtraction
#create $medsub_image_list
if($run_extract_medfilter){
 
  open(OUT,">$medsub_image_list") or myexit64($iam,"Couldn't open $medsub_image_list; quitting"
					      ,$verbose);
  
  for($i=0;$i<$N_Images;$i++){ 
    chomp ($input_file_name = $image_stack[$i]);
    ($input_minus_median_file_name = $med_dir.strip_pathname($input_file_name) )
      =~ s/\.fits/_minback.fits/;
    $nmask = 0;
 
    $commandline = "a=&otype=2&n=$NL_name&namelist_prefix=EXTRACT_"."&log=$NLpath"."/log_extract_medfilter";
    $input_files = "i=$input_file_name";
    $output_files = "o2=$input_minus_median_file_name";
    
    if($have_pmask){
      $nmask++;
      $input_files .= "&m$nmask=$PMASK_FILE_NAME";
      $commandline .= "&mv$nmask=$PMask_Fatal_BitPattern";
    }
    if($have_dmask){
      $nmask++;
      chomp ($DCE_Status_Mask = $Dmask_stack[$i]);
      if(!defined $DCE_Status_Mask ){ 
	print "input_file_name = $input_file_name\n";
	myexit64($iam,"Ran out of mask images in $DCE_STATUS_MASK_LIST; quitting",$verbose);}
      # the bit pattern for the masks is set in the namefile
      $input_files .= "&m$nmask=$DCE_Status_Mask";
      $commandline .= "&mv$nmask=$DCE_Status_Mask_Fatal_BitPattern";
      
    }
    if($have_rmask){
      $nmask++;
      chomp ($RMask = $Rmask_stack[$i]);
      if(!defined $RMask ){ 
	print "input_file_name = $input_file_name\n";
	myexit64($iam,"Ran out of mask images in $RMASK_LIST; quitting",$verbose);}
      # the bit pattern for the masks is set in the namefile
      $input_files .= "&m$nmask=$RMask";
      $commandline .= "&mv$nmask=$RMask_Fatal_BitPattern";
      
    }
    $commandline .= "&nmask=$nmask";     
    if($status = run_all("medfilter", $input_files,$output_files,$commandline,$verbose-$NICE)){
      exit($status);}
    
    print OUT "$input_minus_median_file_name\n";
  }
    close(OUT) or myexit64($iam,"Couldn't close $medsub_image_list; quitting",$verbose);
   reset_last(\$last_run,\$run_extract_medfilter);
}


if(!$use_sigma && $run_fit_radius){
  $run_fit_radius = 0;
  print "Warning! fit_radius will not be executed without uncertainty images.";
}

if($run_fit_radius){
  
  $i=0;
  for $tile_number(@tile_numbers){  
    chomp ($tile_file_name = $tile_list_file[$i++]);
    ($tile_detect_file_name = $tile_file_name)  =~ s/\.fits/_detect\.tbl/;
    ($tile_minus_median_file_name = $tile_file_name)  =~ s/\.fits/_minback\.fits/;
    if($use_unc_to_detect){
      ($sigma_file_name = $tile_file_name) =~ s/Image/Unc/;
    }
    elsif($use_std_to_detect ){
      ($sigma_file_name = $tile_file_name) =~ s/Image/Std_Unc/;
    }
    ($tile_coverage_map_file_name =$tile_file_name) =~ s/Image/Cov/;
    
    $commandline = "a=&n=$NL_name";
    $input_files = "i=$tile_minus_median_file_name&il=$tile_detect_file_name&is=$sigma_file_name";
    $input_files .= "&ic=$tile_coverage_map_file_name";
    
    $output_files = "o=$tile_detect_file_name";

    if($use_bright_object_mask){
      $input_files .= "&m1=$tile_detect_bright_mask";
      $commandline .= "&nmask=1&mv1=1023";
    }
    if($status = run_all("fit_radius",$input_files,$output_files,$commandline,$verbose-$NICE)){
      exit($status);}
   reset_last(\$last_run,\$run_fit_radius);
  }
}

# combine the detection lists into  $mosaic_detect_file_name,$tile_list
if($run_detect || $run_fit_radius){
   combine_detection_lists($mosaic_detect_raw_file_name,$tile_list,\@tile_numbers, $iam, $verbose);
   $sys_command = "cp $mosaic_detect_raw_file_name $mosaic_detect_file_name";
   print "$sys_command";
   system($sys_command);
}
if($run_select_detect){
  my $select_detect_command = " with complete_header";
  $sys_command = "$select_detect_command from $mosaic_detect_raw_file_name into $mosaic_detect_file_name";
  if($select_detect_conditions ne ""){
    chomp $select_detect_conditions;
    $sys_command .= " for $select_detect_conditions";
  }
  if($select_detect_columns ne ""){
    chomp $select_detect_columns;
    $sys_command .= " col $select_detect_columns";
  }
  else{
    $sys_command .= " col all";
  }
  if($status = run_script("select",$sys_command,$verbose)){
    exit($status)};
}  


if($run_bright_detect){
   combine_bright_detection_lists($mosaic_detect_bright_file_name,\@tile_detect_bright_file_name, $iam, $verbose);
}



# run estimation 
#files needed: medsub_image_list, PRF, PRF_Map, MosaicDetectionList, ImageStack, SigmaList, MosaicHeaderFile
# list of noise images 
if($run_sourcestimate){
  if($PRF_file_name eq ""){
#PRF_file is not given, must have a PRF_Map file already created
  }
  else{
    $input_file_name = shift @image_stack;  # need it for write_prf_map
    # now create a prf map file
    write_prf_map($PRFMAP_FILE_NAME,$PRF_file_name,$input_file_name);
  }
   
  $nmask = 0;
  $commandline = "a=&radec=&n=$NL_name"."&log=$NLpath"."/log_sourcestimate";

#  Check for the data unc for fitted SNR switch, TYB 5/01/07 

  my $unc_list_file_name = $list_mosaic_noise_file_name;
  if ($use_data_unc_for_fitted_SNR){
     if($tile_uncertainty_list eq ""){
         myexit64($iam,"Tile unc. list is not present; quitting",$verbose);
    }
     elsif (! (-e $tile_uncertainty_list )) {
         myexit64($iam,"Tile unc. list is not present; quitting",$verbose);
    }
     open(IN1,$tile_uncertainty_list) or
         myexit64($iam,"Tile unc. list is not present; quitting",$verbose);
     open(OUT1,">$tile_uncertainty_list_for_SNR");
     my $tile_count = 0;
     while (<IN1>) {
#
#  Changed to get indexing right - 9/9/08 (TYB)
#	 $tile_count += 1;
#         chomp($_);
#         print OUT1 "$tile_count $_\n";
	chomp($_);
        print OUT1 "$tile_numbers[$tile_count] $_\n";
        $tile_count += 1;
#
     }
     close(IN1) or
         myexit64($iam,"Couldn't close tile unc. list; quitting",$verbose);
     close(OUT1) or
         myexit64($iam,"Couldn't close new tile unc. list; quitting",$verbose);

     $unc_list_file_name = $tile_uncertainty_list_for_SNR;
  }

  $input_files = "id=$mosaic_detect_file_name&prfi=$PRFMAP_FILE_NAME".
    "&fif=$fif_file_name&noiselist=$unc_list_file_name";
  if($use_background_subtracted_image_for_fitting){
    $input_files .= "&i=$medsub_image_list";
  }
  else{
    $input_files .= "&i=$IMAGE_STACK_FILE_NAME";
  }
   $output_files = "o=$raw_extract_file";
  $input_files .= "&tmap=$tile_bcd_file_name";
  if($use_sigma){
    $input_files .= "&sigma=$SIGMALIST_FILE_NAME";
  }
#  Added TYB 4/30/08
#
  if( (-e $tile_coverage_list) ){
    my $tile_coverage_list_for_SNR = $tile_coverage_list."_for_SNR";
    open(IN1,$tile_coverage_list);
    open(OUT1,">$tile_coverage_list_for_SNR");
    my $tile_count = 0;
    while (<IN1>) {
#
#  Changed to match $tile_uncertainty_list_for_SNR  - 9/9/08 (TYB)
#	 $tile_count += 1;
#         chomp($_);
#         print OUT1 "$tile_count $_\n";
	chomp($_);
        print OUT1 "$tile_numbers[$tile_count] $_\n";
        $tile_count += 1;
#
    }
    close(IN1) or
        myexit64($iam,"Couldn't close tile cov. list; quitting",$verbose);
    close(OUT1) or
        myexit64($iam,"Couldn't close new tile cov. list; quitting",$verbose);
    $input_files .= "&iclist=$tile_coverage_list_for_SNR";
  }


  if(!$use_background_subtracted_image_for_fitting){
    if($have_pmask){
      $input_files .= "&pm=$PMASK_FILE_NAME";
      $commandline .= "&pv=$PMask_Fatal_BitPattern";
    }
    
    if($have_dmask){
      $nmask++;
      $input_files .= "&m$nmask=$DCE_STATUS_MASK_LIST";
      $commandline .= "&mv$nmask=$DCE_Status_Mask_Fatal_BitPattern";
    }
    if($have_rmask){
      $nmask++;
      $input_files .= "&m$nmask=$RMASK_LIST";
      $commandline .= "&mv$nmask=$RMask_Fatal_BitPattern";
    }
    $commandline .= "&nmask=$nmask";
  }     
  if($use_refined_pointing){
    $commandline .= "&refpoint=";
  }
 
  if($have_gain_correction){
    $commandline .= "&gain=$GAIN_CORRECTION_FILE_NAME";
  }
  if($status = run_all("sourcestimate",$input_files,$output_files,$commandline,$verbose-$NICE)){
    exit($status);}
   reset_last(\$last_run,\$run_sourcestimate);

}

if($run_aperture){
   $commandline = "a=&n=$NL_name&log=$NLpath/log_aperture";
   if($use_background_subtracted_image_for_aperture){
     $input_files = "i=$mosaic_minback_image_file_name&il=$raw_extract_file";
   }
   else{
     $input_files = "i=$mosaic_image_file_name&il=$raw_extract_file";
   }
   if( -e $mosaic_uncertainty_file_name) {
       $input_files .= "&noise=$mosaic_uncertainty_file_name";
   }
   else{
       print "Warning (not fatal):  Mosaic uncertainty file not found.\n";
       print "No aperture uncertainties will be calculated.\n";
   }

   $output_files = "o=$aperture_file_name";
   if($status = run_all("aperture",$input_files,$output_files,$commandline,$verbose-$NICE)){
     exit($status)};
   my $columns_to_skip = 3;
   append_columns($raw_extract_file, $aperture_file_name, $columns_to_skip);
   reset_last(\$last_run,\$run_aperture);
 }

if($run_select){
  my $select_command = " col all with complete_header";
  $sys_command = "$select_command from $raw_extract_file into $OUTPUT_FILE";
  if($select_conditions ne ""){
    chomp $select_conditions;
    $sys_command .= " for $select_conditions";
  }
  if($select_columns ne ""){
    chomp $select_columns;
    $sys_command .= " col $select_columns";
  }
  if($status = run_script("select",$sys_command,$verbose)){
    exit($status)};
}  


#copy the namelist to the output directory
if($save_namelist){
  my ($sec,$min,$hours) = (localtime)[0,1,2];
  my $copy_NL_file_name = $OUTPUT_DIR.$hours.'h'.$min.'m'.$sec.'s_'.strip_pathname($NL_file_name);
  $sys_command = "cp $NL_file_name $copy_NL_file_name";
}
else{
  $sys_command = "cp $NL_file_name $OUTPUT_DIR";
}
system($sys_command);

#  delete if necessary 
  
if($delete_intermediate_files == 1){
  if( $run_snestimator_sigma > 0){
    $sys_command = "rm -r $sigma_dir";
    system($sys_command);
    if($verbose){print "$sys_command \n";}
  }
  if( $run_mosaic_int > 0){
    $sys_command = "rm -r $interp_dir";
    system($sys_command);
    if($verbose){print "$sys_command \n";}
  }
  if( $run_mosaic_coadd > 0 || $run_detect_medfilter > 0 
      || $run_pointsourceprob > 0 || $run_detect > 0 || $run_gaussnoise > 0){
    $sys_command = "rm -r $coadder_dir";
    system($sys_command);
    if($verbose){print "$sys_command \n";}
  }
  
  if( $run_extract_medfilter > 0 || $run_detect_medfilter > 0){
    $sys_command = "rm -r $med_dir";
    system($sys_command);
    if($verbose){print "$sys_command \n";}
  } 
}

print "Wrapper-script $iam terminated normally.\n";



########################################################################################
sub combine_bright_detection_lists{
########################################################################################
  my ($mosaic_detect_file_name,$TILE_detect_file_name, $iam,$verbose) = @_;

  my @tile_detect_file_name = @$TILE_detect_file_name;
  open(OUT,">$mosaic_detect_file_name") or myexit64($iam,
           "Couldn't open $mosaic_detect_file_name; quitting",$verbose);
  printf OUT "\\Comment = Combined outputs from DETECT_BRIGHT\n";
  
  my @tile_detect_file;
  my $line;
  my $mosaic_srcid = 0;
  my $i;
  my $N = @tile_detect_file_name;
  for ($i=0; $i < $N; $i++){     
    @tile_detect_file = `cat $tile_detect_file_name[$i]`;    
    for $line (@tile_detect_file){
      chomp $line;
      if($i==0){
     	if( $line =~ /^\\/ ){
			print OUT "$line\n";
		}
    	if( $line =~ /^\|/ ){
    	  $line =~ s/srcid\|/srcid\|          detid\|/;
    	  $line =~ s/^\|i              \|/\|i              \|i              \|/;
    	  printf OUT "$line\n";
    	}
      }
      if( !($line =~ /^\\/) && !($line =~ /^\|/) ){
    	$mosaic_srcid++;
    	printf OUT " %15d", $mosaic_srcid;
    	printf OUT "$line \n";  
      }
    }
  }
  if($mosaic_srcid ==0 ){ 
    print "combine_detection_lists: no point sources detected...\n";
    return 7;
  }
  close(OUT) or myexit64($iam,"Couldn't close $mosaic_detect_file_name; quitting",$verbose);
  return 0;
}

sub ComputePixelRatio(){
  my ($bcd_file_name,$MOSAIC_PIXEL_SIZE_X,$MOSAIC_PIXEL_SIZE_Y,
		      $MOSAIC_PIXEL_RATIO_X,$MOSAIC_PIXEL_RATIO_Y) = @_;

  my %hdr;
  
  chomp ($bcd_file_name);
  %hdr = ReadFitsHdr($bcd_file_name);
  
  my $CD1_1 = $hdr{"CD1_1"};
  my $CD1_2 = $hdr{"CD1_2"};
  my $CD2_1 = $hdr{"CD2_1"};
  my $CD2_2 = $hdr{"CD2_2"};
  my ($CDELT1, $CDELT2, $crota2);
  
  if(defined($CD1_1) && defined($CD1_2) && defined($CD2_1) && defined($CD2_2)){
    $crota2 = atan2(-$CD1_2,$CD2_2);
    

    $CDELT1 = cos($crota2)*$CD1_1 + sin($crota2)*$CD2_1;
    $CDELT2 = -sin($crota2)*$CD1_2 + cos($crota2)*$CD2_2;
  }
  else{
    $CDELT1 = $hdr{"CDELT1"};
    $CDELT2 = $hdr{"CDELT2"};
    
    if(!defined($CDELT1) || !defined($CDELT2) ){
      print "WARNING!! input bcd has neither complete CD matrix nor both CDELTa's\n";
      return;
    }
  }
  if($MOSAIC_PIXEL_SIZE_X != 0){
    $$MOSAIC_PIXEL_RATIO_X = $CDELT1/ $MOSAIC_PIXEL_SIZE_X;
  }
  if($MOSAIC_PIXEL_SIZE_Y != 0){
    $$MOSAIC_PIXEL_RATIO_Y = $CDELT2/ $MOSAIC_PIXEL_SIZE_Y;
  }

}