Index: trunk/ippScripts/Build.PL
===================================================================
--- trunk/ippScripts/Build.PL	(revision 30042)
+++ trunk/ippScripts/Build.PL	(revision 30049)
@@ -105,6 +105,8 @@
         scripts/whichimage
         scripts/automate_stacks.pl
+        scripts/nightly_science.pl
         scripts/lossy_compress_imfile.pl
         scripts/ipp_apply_burntool.pl
+        scripts/ipp_apply_burntool_single.pl
         scripts/make_burntool_pcontrol.pl
         scripts/bundle_detrends.pl
Index: trunk/ippScripts/MANIFEST
===================================================================
--- trunk/ippScripts/MANIFEST	(revision 30042)
+++ trunk/ippScripts/MANIFEST	(revision 30049)
@@ -37,6 +37,8 @@
 scripts/ds9_cmf_regions.pl
 scripts/automate_stacks.pl
+scripts/nightly_science.pl
 scripts/lossy_compress_imfile.pl
 scripts/ipp_apply_burntool.pl
+scripts/ipp_apply_burntool_single.pl
 scripts/make_burntool_pcontrol.pl
 scripts/bundle_detrends.pl
Index: trunk/ippScripts/scripts/ipp_apply_burntool_single.pl
===================================================================
--- trunk/ippScripts/scripts/ipp_apply_burntool_single.pl	(revision 30049)
+++ trunk/ippScripts/scripts/ipp_apply_burntool_single.pl	(revision 30049)
@@ -0,0 +1,187 @@
+#!/usr/bin/env perl
+
+use warnings;
+use strict;
+use Carp;
+
+use IPC::Cmd 0.36 qw( can_run run );
+#use IPC::Run 0.36 qw( run );
+use PS::IPP::Metadata::List qw( parse_md_list );
+use PS::IPP::Config 1.01 qw( :standard );
+use File::Temp qw( tempfile );
+use Getopt::Long qw( GetOptions :config auto_help auto_version gnu_getopt );
+use Pod::Usage qw( pod2usage );
+
+my $REALRUN = 1;
+
+my ( $class_id, $exp_id, $this_uri, $previous_uri, $imfile_state, $camera, $dbname, $logfile, $verbose, $save_temps, $rerun );
+GetOptions(
+    'exp_id=s'         => \$exp_id,   # exposure identifier
+    'class_id=s'       => \$class_id, # chip identifier
+    'this_uri=s'       => \$this_uri, # uri for this image
+    'previous_uri=s'   => \$previous_uri, # uri for the previous image
+    'imfile_state=s'   => \$imfile_state, # current state of the imfile.
+    'camera=s'          => \$camera,     # Camera
+    'dbname|d=s'        => \$dbname, # Database name
+    'logfile=s'         => \$logfile,
+    'rerun'             => \$rerun,
+    'verbose'           => \$verbose,   # Print to stdout
+    'save-temps'        => \$save_temps, # Save temporary files?
+
+    ) or pod2usage( 2 );
+
+pod2usage( -msg => "Unknown option: @ARGV", -exitval => 2 ) if @ARGV;
+pod2usage(
+    -msg => "Required options: --class_id --this_uri --dbname",
+    -exitval => 3,
+    ) unless
+    defined $class_id and
+    defined $this_uri and
+    defined $dbname;
+
+unless (defined $camera) {
+    $camera = "GPC1";
+}
+
+my $missing_tools;
+my $regtool  = can_run('regtool')  or (warn "Can't find regtool" and $missing_tools = 1);
+my $funpack  = can_run('funpack')  or (warn "Can't find funpack" and $missing_tools = 1);
+my $burntool = can_run('burntool') or (warn "Can't find burntool" and $missing_tools = 1);
+my $ppConfigDump = can_run('ppConfigDump') or (warn "Can't find ppConfigDump" and $missing_tools = 1);
+my $nebXattr = can_run('neb-xattr') or (warn "Can't find neb-xattr" and $missing_tools = 1);
+my $nebreplicate = can_run('neb-replicate') or (warn "Can't find neb-replicate" and $missing_tools = 1);
+#my $fpack    = can_run('fpack')    or (warn "Can't find fpack" and $missing_tools = 1);
+if ($missing_tools) {
+    warn("Can't find required tools.");
+    exit($PS_EXIT_CONFIG_ERROR);
+}
+
+my $mdcParser = PS::IPP::Metadata::Config->new; # Parser for metadata config files
+
+# IPP configuration (including nebulous)
+my $ipprc = PS::IPP::Config->new( $camera ) or my_die("Unable to set up");
+
+unless (defined $logfile) {
+    $logfile = $this_uri;
+    $logfile =~ s/fits/burn.log/;
+}
+$ipprc->redirect_output($logfile) if $logfile;
+
+# Determine the value of a "good" burntool run.
+my $config_cmd = "$ppConfigDump -camera $camera -dump-camera - | grep BURNTOOL | uniq";
+my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+    run ( command => $config_cmd, verbose => $verbose);
+unless ($success) {
+    $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+    &my_die("Unable to perform ppConfigDump: $error_code", 0, 0, $class_id, $PS_EXIT_SYS_ERROR);
+}
+
+my $recipeData = $mdcParser->parse(join "", @$stdout_buf) or
+    &my_die("Unable to parse metadata config doc", 0, 0, $class_id, $PS_EXIT_SYS_ERROR);
+
+my $burntoolStateGood = 999;
+foreach my $cfg (@$recipeData) {
+    if ($cfg->{name} eq 'BURNTOOL.STATE.GOOD') {
+        $burntoolStateGood = $cfg->{value};
+    }
+}
+if ($burntoolStateGood == 999) {
+    &my_die("Failed to determine BURNTOOL.STATE.GOOD", $burntoolStateGood, $class_id, 0, $PS_EXIT_SYS_ERROR);
+}
+my $outState = -1 * abs($burntoolStateGood);
+
+print ">>$burntoolStateGood<<\n";
+
+# Set up files
+my $rawImfile = $this_uri;
+my $rawImfileReal = $ipprc->file_resolve($rawImfile, 0);
+
+my $outTable  = $this_uri;
+$outTable  =~ s/fits$/burn.tbl/;
+my $outTableReal = $ipprc->file_resolve($outTable, 1);
+
+my $previousTable;
+my $previousTableReal;
+if ($previous_uri) {
+    $previousTable = $previous_uri;
+    $previousTable =~ s/fits$/burn.tbl/;
+    $previousTableReal = $ipprc->file_resolve($previousTable, 0);
+}
+
+# Set state to processing:
+my $burntool_state = 0;
+
+my $status = vsystem ("$regtool -dbname $dbname -updateprocessedimfile -exp_id $exp_id -class_id $class_id -burntool_state -1", $REALRUN);
+if ($status) {
+    &my_die("failed to update imfile");
+}
+$burntool_state = 1;
+
+
+# funpack
+my $tempfile = new File::Temp ( TEMPLATE => "burntool.${exp_id}.${class_id}.XXXX",
+				DIR => '/tmp/',
+				UNLINK => !$save_temps,
+				SUFFIX => '.fits');
+my $tempPixels = $tempfile->filename;
+
+$status = vsystem ("$funpack -S $rawImfileReal > $tempPixels", $REALRUN);
+if ($status) {
+    &my_die("failed on funpack",$exp_id,$class_id);
+}
+
+# burntool
+if (($previousTableReal)&&($previousTableReal ne '')) {
+    $status = vsystem ("$burntool $tempPixels in=$previousTableReal out=$outTableReal tableonly=t persist=t", $REALRUN);
+}
+else {
+    $status = vsystem ("$burntool $tempPixels out=$outTableReal tableonly=t persist=t", $REALRUN);
+}
+if ($status) {
+    &my_die("failed on burntool",$exp_id,$class_id);
+}
+&my_die("Unable to find output file: $outTableReal", $exp_id, $class_id) unless $ipprc->file_exists($outTableReal);
+
+# Replicate files
+$status = vsystem ("$nebXattr --write $outTable user.copies:2",$REALRUN);
+$status = vsystem ("$nebreplicate --set_copies 2 $outTable",$REALRUN);
+
+# Set state to finished.
+my $command = "$regtool -dbname $dbname -updateprocessedimfile -exp_id $exp_id -class_id $class_id -burntool_state $outState";
+if ($imfile_state ne 'full') {
+    $command .= " -set_state full ";
+}
+$status = vsystem ($command, $REALRUN);
+if ($status) {
+    &my_die("failed to update imfile");
+}
+
+exit 0;
+
+sub vsystem {
+    my $command = shift;
+    my $realrun = shift;
+
+    print "$command\n";
+
+    my $status = 0;
+    if ($realrun) {
+        $status = system ($command);
+    }
+
+    return $status;
+}
+
+sub my_die {
+    my $message = shift;
+    if ($#_ != -1) {
+        my $exp_id = shift;
+        my $class_id = shift;
+        vsystem("$regtool -dbname $dbname -updateprocessedimfile -exp_id $exp_id -class_id $class_id -burntool_state -3",1);
+    }
+    printf STDERR "$message\n";
+    exit 1;
+}
+
+
+    
Index: trunk/ippScripts/scripts/nightly_science.pl
===================================================================
--- trunk/ippScripts/scripts/nightly_science.pl	(revision 30049)
+++ trunk/ippScripts/scripts/nightly_science.pl	(revision 30049)
@@ -0,0 +1,1635 @@
+#!/usr/bin/env perl
+
+use warnings;
+use strict;
+use Carp;
+use IPC::Cmd 0.36 qw( can_run run);
+use PS::IPP::Metadata::List qw( parse_md_list );
+use PS::IPP::Config 1.01 qw( :standard );
+use Getopt::Long qw( GetOptions :config auto_help auto_version gnu_getopt );
+use Pod::Usage qw( pod2usage );
+use DateTime;
+
+#
+# Set up
+################################################################################
+
+my $missing_tools = 0;
+my $regtool = can_run('regtool') or (warn "Can't find regtool" and $missing_tools = 1);
+my $chiptool = can_run('chiptool') or (warn "Can't find chiptool" and $missing_tools = 1);
+my $dqstatstool = can_run('dqstatstool') or (warn "Can't find dqstatstool" and $missing_tools = 1);
+my $warptool = can_run('warptool') or (warn "Can't find warptool" and $missing_tools = 1);
+my $stacktool= can_run('stacktool') or (warn "Can't find stacktool" and $missing_tools = 1);
+my $difftool = can_run('difftool') or (warn "Can't find difftool" and $missing_tools = 1);
+my $magicdstool = can_run('magicdstool') or (warn "Can't find magicdstool" and $missing_tools = 1);
+my $dettool = can_run('dettool') or (warn "Can't find dettool" and $missing_tools = 1);
+my $ppConfigDump = can_run('ppConfigDump') or (warn "Can't find ppConfigDump" and $missing_tools = 1);
+my $mkBTpcontrol = can_run('make_burntool_pcontrol.pl') or (warn "Can't find make_burntool_pcontrol.pl" and $missing_tools = 1);
+my $moondata = can_run('moondata') or (warn "Can't find moondata" and $missing_tools = 1);
+
+if ($missing_tools) {
+    warn("Can't find required tools.");
+    exit($PS_EXIT_CONFIG_ERROR);
+}
+
+my $db;
+my $debug = 0;
+my %metadata_out = ();
+$metadata_out{nsState} = 'UNDEFINEDERROR';
+my $loghead;
+chomp($loghead = `date`);
+print STDERR 'Starting: ' . $loghead . ' ' . $0 . ' ' . (join ' ', @ARGV) . "\n";
+
+# Grab options
+my ( $date, $datetime, $camera, $dbname, $logfile, $verbose, $manual);
+my ( $help, $isburning, $force_stack_count, $force_diff_count, $test_mode, $this_target_only, $this_filter_only, $this_mode_only, $check_mode);
+my ( $registration_status, $burntool_status, $observing_status);
+my ( $check_registration, $define_burntool, $queue_burntool, $check_chips, $queue_chips);
+my ( $check_stacks, $queue_stacks, $check_sweetspot, $queue_sweetspot, $check_diffs, $queue_diffs, $clean_old);
+my ( $check_detrends, $queue_detrends, $check_dqstats, $queue_dqstats);
+my ( $confirm_stacks, $check_confirm_stacks );
+
+GetOptions(
+    'help|h'               => \$help,
+    'date=s'               => \$date, # night to make stacks for
+    'camera=s'             => \$camera, # camera
+    'dbname=s'             => \$dbname, # Database name
+    'logfile=s'            => \$logfile,
+    'verbose'              => \$verbose,
+    'debug'                => \$debug,
+    'test_mode'            => \$test_mode,
+    'force_stack_count'    => \$force_stack_count,
+    'force_diff_count'    => \$force_diff_count,
+    'this_target_only=s'   => \$this_target_only,
+    'this_filter_only=s'   => \$this_filter_only,
+    'this_mode_only=s'     => \$this_mode_only,
+    'registraion_status'   => \$registration_status,
+    'burntool_status'      => \$burntool_status,
+    'check_stacks'         => \$check_stacks,
+    'queue_stacks'         => \$queue_stacks,
+    'confirm_stacks'       => \$confirm_stacks,
+    'check_confirm_stacks' => \$check_confirm_stacks,
+    'check_diffs'          => \$check_diffs,
+    'queue_diffs'          => \$queue_diffs,
+    'check_sweetspot'      => \$check_sweetspot,
+    'queue_sweetspot'      => \$queue_sweetspot,
+    'check_detrends'       => \$check_detrends,
+    'queue_detrends'       => \$queue_detrends,
+    'check_dqstats'        => \$check_dqstats,
+    'queue_dqstats'        => \$queue_dqstats,
+    'clean_old'            => \$clean_old,
+    ) or pod2usage ( 2 );
+pod2usage( -msg =>
+"USAGE: automate_stacks.pl <options...> <mode>
+        Options:
+           --help                 This help.
+           --date YYYY-MM-DD      Work on this date (defaults to today GMT).
+           --camera <camera>      Default GPC1.
+           --dbname <db>          Default gpc1.
+           --verbose
+           --force_stack_count    Force the chip/warp counts.
+           --force_diff_count    Force the chip/warp counts.
+           --this_target_only     Process only a single target.
+           --this_filter_only     Process only a single filter.
+           --this_mode_only       Process only a single clean mode.
+           --burntool_status       Display Nexp Nimfile Nburntooled Nqueued for check_chips.
+        Modes:
+           --check_stacks         Confirm that stacks can be built.
+           --queue_stacks         Issue stacktool commands to queue stacks.
+           --check_diffs          Confirm that diffs can be done.
+           --queue_diffs          Issue difftool commands to queue diffs.
+           --check_sweetspot      See if we should queue SweetSpot stacks.
+           --queue_sweetspot      Issue stacktool commands to queue SweetSpot stacks.
+           --check_detrends       Confirm that detrend verify runs can be built.
+           --queue_detrends       Issue dettool commands to queue detrend verify runs.
+           --check_dqstats        Confirm that dqstats tables can be built.
+           --queue_dqstats        Issue dqstatstool commands to queue dqstat tables.
+           --clean_old            Mark old data 'goto_cleanup'.\n",
+           -exitval => 2, ) if (defined($help));
+pod2usage( -msg => "Unknown option: @ARGV", -exitval => 2 ) if @ARGV;
+pod2usage(
+          -msg => "Choose a mode: --check_registration --check_burntool --queue_chips --queue_stacks",
+          -exitval => 3,
+          ) unless
+    defined $check_registration or defined $define_burntool or defined $queue_burntool or
+    defined $queue_chips or defined $queue_stacks or $queue_sweetspot or $queue_detrends or $queue_dqstats or 
+    defined $check_chips or defined $check_stacks or $check_sweetspot or $check_detrends or $check_dqstats or
+    defined $test_mode or defined $clean_old or defined $check_mode or
+    defined $confirm_stacks or defined $burntool_status;
+
+# Configurable parameters from our config file.
+my %science_config = ();
+my %clean_config   = ();
+my %detrend_config = ();
+my %eon_config     = ();
+my %cleanmods_list = ();
+my %macro_config = ();
+my @unrecoverable_quality = ();
+my @filter_list = ();
+
+# Grab the configuration data.
+my $conf_cmd = "$ppConfigDump -dump-recipe NIGHTLY_SCIENCE -";
+my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+    run(command => $conf_cmd, verbose => $verbose);
+unless ($success) {
+    $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+    &my_die("Unable to perform ppConfigDump: $error_code", $date, $PS_EXIT_SYS_ERROR);
+}
+
+my $mdcParser = PS::IPP::Metadata::Config->new;
+my $metadata = $mdcParser->parse(join "", @$stdout_buf);
+foreach my $entry (@{ $metadata }) {
+    if (@{ $entry }{name} eq 'CLEAN_MODES') {
+	my @mode_data = @{ ${ $entry }{value} };
+	my $this_mode = '';
+	foreach my $mentry (@mode_data) {
+	    if (${ $mentry }{name} eq 'MODE') {
+		$this_mode = ${ $mentry }{value};
+	    }
+	    elsif (${ $mentry }{name} eq 'COMMAND') {
+		$clean_config{$this_mode}{COMMAND} = ${ $mentry }{value};
+	    }
+	    elsif (${ $mentry }{name} eq 'RETENTION_TIME') {
+		$clean_config{$this_mode}{RETENTION_TIME} = ${ $mentry }{value};
+	    }
+	}
+    }
+    elsif (${ $entry }{name} eq 'FILTERS') {
+        push @filter_list, ${ $entry }{value};
+    }
+    elsif (${ $entry }{name} eq 'UNRECOVERABLE_QUALITY') {
+        push @unrecoverable_quality, ${ $entry }{value};
+    }
+    elsif (${ $entry }{name} eq 'MACRO_DEFINITIONS') {
+	my @macro_data = @{ ${ $entry }{value} };
+	my $this_mode = '';
+	foreach my $mentry (@macro_data) {
+	    if (${ $mentry }{name} eq 'PROC_MODE') {
+		$this_mode = ${ $mentry }{value};
+	    }
+	    elsif (${ $mentry }{name} eq 'MACRO') {
+		$macro_config{$this_mode} = ${ $mentry }{value};
+	    }
+	}
+    }
+    elsif (${ $entry }{name} eq 'TARGETS') {
+        my @target_data = @{ ${ $entry }{value} };
+        my $this_target = '';
+        foreach my $tentry (@target_data) {
+            if (${ $tentry }{name} eq 'NAME') {
+                $this_target = ${ $tentry }{value};
+		$science_config{$this_target}{DISTRIBUTION} = $this_target; # Set the default dist_group
+            }
+	    else {
+		$science_config{$this_target}{ ${ $tentry }{name} } = ${ $tentry }{value};
+	    }
+        }
+    }
+    elsif (${ $entry }{name} eq 'DETRENDS') {
+	my @detrend_data = @{ ${ $entry }{value} };
+	my $this_detrend = '';
+	foreach my $dentry (@detrend_data) {
+	    if (${ $dentry }{name} eq 'NAME') {
+		$this_detrend = ${ $dentry }{value};
+	    }
+	    else {
+		$detrend_config{$this_detrend}{ ${ $dentry }{name} } = ${ $dentry }{value};
+	    }
+	}
+    }		
+    elsif (${ $entry }{name} eq 'END_OF_NIGHT') {
+	my @eon_data = @{ ${ $entry }{value} };
+	my $this_eon = '';
+	foreach my $tentry (@eon_data) {
+	    if (${ $tentry }{name} eq 'NAME') {
+		$this_eon = ${ $tentry }{value};
+	    }
+	    else {
+		$eon_config{$this_eon}{ ${ $tentry }{name} } = ${ $tentry }{value};
+	    }
+	}
+    }
+}
+
+if (defined($date)) {
+    my $time;
+    if ($date =~ / /) {
+	($date,$time) = split / /, $date;
+    }
+    elsif ($date =~ /T/) {
+	($date,$time) = split /T/, $date;
+    }
+    my ($year,$month,$day) = split /-/, $date;
+    if (defined($time)) {
+	my ($hour,$min,$sec) = split /\:/, $time; #/;
+	$datetime = DateTime->new( year => $year,
+				   month => $month,
+				   day => $day,
+				   hour => $hour,
+				   min => $min,
+				   second => $sec,
+				   time_zone => 'UTC');
+    }
+    else {
+	$datetime = DateTime->now(time_zone => 'UTC');
+	$datetime->set_year($year);
+	$datetime->set_month($month);
+	$datetime->set_day($day);
+    }
+}    
+else {
+    $datetime = DateTime->now(time_zone => 'UTC'); # time_zone   => 'Pacific/Honolulu');
+    $date = $datetime->ymd();
+}
+unless(defined($camera)) {
+    $camera = 'GPC1';
+}
+unless(defined($dbname)) {
+    $dbname = 'gpc1';
+}
+
+if (defined($this_target_only)) {
+    foreach my $t (keys %science_config) {
+        if ($t ne $this_target_only) {
+	    undef($science_config{$t});
+        }
+    }
+    die("$this_target_only is invalid.") if (scalar keys %science_config < 1);
+}
+
+if (defined($this_filter_only)) {
+    foreach my $t (@filter_list) {
+        if ($t eq $this_filter_only) {
+            @filter_list = ($this_filter_only);
+            last;
+        }
+    }
+    die("$this_filter_only is invalid.") if ($#filter_list != 0);
+}
+
+if (defined($this_mode_only)) {
+    foreach my $t (keys %clean_config) {
+        if ($t ne $this_mode_only) {
+	    undef($clean_config{$t});
+        }
+    }
+    die("$this_mode_only is invalid.") if (scalar keys %clean_config < 1);
+}
+
+$metadata_out{nsObservingState} = &get_observing_state($date);
+#
+# Mode selection
+################################################################################
+
+if (defined($test_mode)) {
+    $debug = 1;
+    my $z;
+    my $v;
+    foreach $z (sort (keys %science_config)) {
+	foreach $v (keys %{ $science_config{$z} }) {
+	    print "SCIENCE: $z $v $science_config{$z}{$v}\n";
+	}
+    }
+    foreach $z (sort (keys %detrend_config)) {
+	foreach $v (keys %{ $detrend_config{$z} }) {
+	    print "DETREND: $z $v $detrend_config{$z}{$v}\n";
+	}
+    }
+    foreach $z (keys (%clean_config)) {
+	foreach $v (keys %{ $clean_config{$z} }) {
+	    print "CLEAN: $z $v $clean_config{$z}{$v}\n";
+	}
+    }
+    foreach $z (@filter_list) {
+	print "FILTER: $z\n";
+    }
+    foreach $z (keys (%macro_config)) {
+	print "MACROS: $z $macro_config{$z}\n";
+    }
+}
+if (defined($observing_status) || defined($test_mode)) {
+    $metadata_out{nsState} = 'CHECK_OBSERVING_STATUS';
+    return_metadata($date);
+    unless (defined($test_mode)) { exit(0); }
+}
+
+if (defined($registration_status) || defined($test_mode)) {
+    &check_summit_copy($date);
+    return_metadata($date);
+    unless (defined($test_mode)) { exit(0); }
+}
+
+if (defined($burntool_status) || defined($test_mode)) {
+    &burntool_status($date);
+    unless (defined($test_mode)) { exit(0); }
+}
+
+if (defined($check_dqstats) || defined($test_mode)) {
+    &execute_dqstats($date,"pretend");
+    return_metadata($date);
+    unless (defined($test_mode)) { exit(0); }
+}
+if (defined($queue_dqstats)) {
+    &execute_dqstats($date);
+    return_metadata($date);
+    unless (defined($test_mode)) { exit(0); }
+}
+
+if (defined($check_detrends) || defined($test_mode)) {
+    $metadata_out{nsDetState} = 'CHECKDETRENDS';
+    &execute_detrends($date,"pretend");
+    return_metadata($date);
+    unless (defined($test_mode)) { exit(0); }
+}
+if (defined($queue_detrends)) {
+    $metadata_out{nsDetState} = 'QUEUEDETRENDS';
+    &execute_detrends($date);
+    return_metadata($date);
+    unless (defined($test_mode)) { exit(0); }
+}
+
+if (defined($clean_old) || defined($test_mode)) {
+    if (defined($test_mode)) {
+        &execute_cleans($date,"pretend");
+    }
+    else {
+        &execute_cleans($date);
+    }
+    unless (defined($test_mode)) { exit(0); }
+}
+
+if (defined($check_stacks) || defined($test_mode)) {
+    $metadata_out{nsStackState} = 'TOWARP';
+    &execute_stacks($date,$metadata_out{nsObservingState},"pretend");
+    if ($metadata_out{nsStackState} eq 'FORCETOWARP') {
+        $metadata_out{nsStackState} = 'TOWARP';
+    }
+    return_metadata($date);
+    unless (defined($test_mode)) { exit(0); }
+}
+if (defined($queue_stacks)) {
+    $metadata_out{nsStackState} = 'STACKING';
+    &execute_stacks($date,$metadata_out{nsObservingState});
+    if ($metadata_out{nsStackState} eq 'QUEUESTACKING') {
+	$metadata_out{nsStackState} = 'STACKING_POSSIBLE_ERROR';
+    }
+    return_metadata($date);
+    exit(0);
+}
+
+if (defined($check_diffs) || defined($test_mode)) {
+    $metadata_out{nsDiffState} = 'TOWARP';
+    &execute_diffs($date,$metadata_out{nsObservingState},"pretend");
+    if ($metadata_out{nsDiffState} eq 'FORCETOWARP') {
+        $metadata_out{nsDiffState} = 'TOWARP';
+    }
+    return_metadata($date);
+    unless (defined($test_mode)) { exit(0); }
+}
+if (defined($queue_diffs)) {
+    $metadata_out{nsDiffState} = 'DIFFING';
+    &execute_diffs($date,$metadata_out{nsObservingState});
+    if ($metadata_out{nsDiffState} eq 'QUEUESTACKING') {
+	$metadata_out{nsDiffState} = 'STACKING_POSSIBLE_ERROR';
+    }
+    return_metadata($date);
+    exit(0);
+}
+exit(10);
+if (defined($check_confirm_stacks) || defined($test_mode)) {
+    $metadata_out{nsStackState} = 'CONFIRM_STACKING';
+    &confirm_stacks($date,"pretend");
+    return_metadata($date);
+    unless (defined($test_mode)) { exit(0); }
+}
+if (defined($confirm_stacks)) {
+    $metadata_out{nsStackState} = 'CONFIRM_STACKING';
+    &confirm_stacks($date);
+    return_metadata($date);
+    exit(0);
+}
+
+if (defined($check_sweetspot) || defined($test_mode) || defined($check_mode)) {
+    $metadata_out{nsSSState} = 'CHECKSWEETSPOT';
+    &execute_sweetspot($date,"pretend");
+    return_metadata($date);
+    unless (defined($test_mode) || defined($check_mode)) { exit(0); }
+}
+if (defined($queue_sweetspot)) {
+    $metadata_out{nsSSState} = 'CHECKSWEETSPOT';
+    &execute_sweetspot($date);
+    return_metadata($date);
+    exit(0);
+}
+
+exit(0);
+#
+# Registration
+################################################################################
+# This isn't used, but might be useful to keep.
+
+sub check_summit_copy {
+    my $date = shift;
+    my $db = init_gpc_db();
+
+    # largely stolen from Bill's checkexp program.
+
+    my $sth = " SELECT exp_name, summitExp.dateobs AS registered, rawExp.dateobs, summitExp.imfiles, ";
+    $sth .= " summitExp.fault AS summit_fault, pzDownloadExp.state AS download_state, ";
+    $sth .= " count(pzDownloadImfile.class_id) AS download_count, newExp.state AS newExp_state, newExp.exp_id, summitExp.exp_type";
+    $sth .= " FROM summitExp LEFT JOIN pzDownloadExp USING(exp_name) LEFT JOIN pzDownloadImfile USING(exp_name) ";
+    $sth .= " LEFT JOIN newExp ON exp_name = tmp_exp_name LEFT JOIN rawExp USING(exp_id, exp_name) ";
+    $sth .= " WHERE date(summitExp.dateobs) >= '${date}T00:00:00' AND date(summitExp.dateobs) <= '${date}T23:59:59' ";
+    $sth .= " GROUP BY exp_name ORDER BY summitExp.dateobs ";
+
+    my $data_ref = $db->selectall_arrayref( $sth );
+
+    my $Nsummit_exps = 0;
+    my $Nsummit_faults = 0;
+    my $Ndownload_faults = 0;
+    my $Nregister_faults = 0;
+    my $Ndownload_imfiles = 0;
+    my $Nsummit_imfiles = 0;
+#    my_trace($sth,$data_ref,$#{ $data_ref });
+
+    foreach my $row_ref (@{ $data_ref }) {
+        my ($exp_name,$registered,$dateobs,$imfiles,$summit_fault,
+            $download_state,$download_count,$new_state,$exp_id,$exp_type) = @{ $row_ref };
+	$Nsummit_imfiles += $imfiles;
+	$Ndownload_imfiles += $download_count;
+        $Nsummit_exps++;
+        if ($summit_fault) {
+	    print STDERR "check_summit_copy: $date $exp_name has summit_fault $summit_fault";
+            if (($exp_type ne 'OBJECT')||($exp_name =~ /^c.*/)) {
+                print STDERR " (but I don't care).\n";
+            }
+            else {
+                print STDERR "\n";
+                $Nsummit_faults++;
+            }
+        }
+        elsif (!$download_state or $download_state eq 'run') {
+            print STDERR "check_summit_copy: $date $exp_name has download_state $download_state";
+            if (($exp_type ne 'OBJECT')||($exp_name =~ /^c.*/)) {
+                print STDERR " (but I don't care).\n";
+            }
+            else {
+                print STDERR "\n";
+                $Ndownload_faults++;
+            }
+        }
+        elsif (!$new_state or $new_state eq 'run' ) {
+            print STDERR "check_summit_copy: $date $exp_name has new_state $new_state";
+            if (($exp_type ne 'OBJECT')||($exp_name =~ /^c.*/)) {
+                print STDERR " (but I don't care).\n";
+            }
+            else {
+                print STDERR "\n";
+                $Nregister_faults++;
+            }
+        }
+    }
+
+    my $Nfaults = $Nsummit_faults + $Ndownload_faults + $Nregister_faults;
+    if ($Nsummit_exps == 0) {
+        print STDERR "No exposures were found on the summit for $date.\n";
+        $metadata_out{nsRegState} = 'DROP';
+    }
+    elsif ($Nfaults != 0) {
+        print STDERR "There were faults while downloading the exposures for $date.\n";
+        $metadata_out{nsRegState} = 'NEW';
+    }
+    elsif ($Ndownload_imfiles != $Nsummit_imfiles) {
+	print STDERR "Not done downloading from the summit for $date (Summit: $Nsummit_imfiles, Downloaded: $Ndownload_imfiles)\n";
+	$metadata_out{nsRegState} = 'NEW';
+    }
+    else {
+        print STDERR "Summit copy and Registration have succeeded for $date.\n";
+        $metadata_out{nsRegState} = 'REGISTERED';
+    }
+
+    return($Nsummit_exps,$Nfaults);
+}
+
+#
+# Burntool
+################################################################################
+
+sub get_goodBTvalue {
+    my $mdcParser = PS::IPP::Metadata::Config->new;
+
+    my $config_cmd = "$ppConfigDump -camera $camera -dump-camera - | grep BURNTOOL.STATE.GOOD | uniq";
+    my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+        run ( command => $config_cmd, verbose => $verbose);
+    unless ($success) {
+        $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+        &my_die("Unable to perform ppConfigDump: $error_code", 0, 0, 0, $PS_EXIT_SYS_ERROR);
+    }
+    my $recipeData = $mdcParser->parse(join "", @$stdout_buf) or
+        &my_die("Unable to parse metadata config doc", 0, 0, 0, $PS_EXIT_SYS_ERROR);
+    my $burntoolStateGood = 999;
+    foreach my $cfg (@$recipeData) {
+        if ($cfg->{name} eq 'BURNTOOL.STATE.GOOD') {
+            $burntoolStateGood = $cfg->{value};
+        }
+    }
+    if ($burntoolStateGood == 999) {
+        &my_die("Failed to determine BURNTOOL.STATE.GOOD", $burntoolStateGood, 0, 0, $PS_EXIT_SYS_ERROR);
+    }
+    return($burntoolStateGood);
+}
+
+sub verify_burntool {
+    my $exp_id = shift;
+    my $burntoolStateGood = shift;
+
+    my $db = init_gpc_db();
+
+    my $sth = "SELECT exp_id,exp_name,obs_mode,dateobs,class_id,burntool_state,comment FROM rawImfile WHERE exp_id = $exp_id";
+    my $data_ref = $db->selectall_arrayref( $sth );
+
+    my $Nimfiles = 0;
+    my $Nburntooled = 0;
+
+    foreach my $row_ref (@{ $data_ref }) {
+        my ($exp_id,$exp_name, $obs_mode,$dateobs,$class_id,$burntool_state,$comment) = @{ $row_ref };
+        $Nimfiles++;
+        if (abs($burntool_state) == $burntoolStateGood) {
+            $Nburntooled++;
+        }
+    }
+    return($Nimfiles,$Nburntooled);
+}
+
+#
+# Chips
+################################################################################
+# This no longer queues chips, it only checks the counts and returns that.
+sub construct_chiptool_cmd {
+    my $date = shift;
+    my $target = shift;
+
+    my ($label,$workdir,$obs_mode,$object,$comment,$tess_id,$dist_group,$data_group,$reduction) = get_tool_parameters($date,$target);
+
+    my $select =  "-dateobs_begin ${date}T00:00:00 -dateobs_end ${date}T23:59:59 ";
+    $date =~ s/-//g;
+
+    my $cmd = "$chiptool";
+    $cmd .= " -simple -dbname $dbname -definebyquery -set_end_stage warp ";
+    $cmd .= " -set_label $label ";
+    $cmd .= " -set_workdir $workdir -set_dist_group $dist_group ";
+    $cmd .= " -set_tess_id $tess_id -set_data_group $data_group ";
+    if (defined($obs_mode)) {
+        $cmd .= " -obs_mode '$obs_mode' ";
+    }
+    if (defined($object)) {
+        $cmd .= " -object '$object' ";
+    }
+    if (defined($comment)) {
+        $cmd .= " -comment '$comment' ";
+    }
+    if (defined($reduction)) {
+	$cmd .= " -set_reduction $reduction ";
+    }
+    $cmd .= " $select ";
+    if ($debug == 1) {
+        $cmd .= " -pretend ";
+    }
+    print STDERR "$cmd\n";
+    return($cmd);
+}
+
+sub verify_uniqueness_chip {
+    my $exp_id = shift;
+    my $date = shift;
+    my $target = shift;
+
+    my $db = init_gpc_db();
+    $date =~ s/-//g;
+    my ($label,$workdir,$obs_mode,$object,$comment,$tess_id,$dist_group,$data_group,$reduction) = get_tool_parameters($date,$target);
+
+    my $sth = "SELECT exp_id from chipRun where data_group = '$data_group' AND exp_id = $exp_id";
+    my $data_ref = $db->selectall_arrayref( $sth );
+
+    return($#{ $data_ref } + 1);
+}
+
+sub check_chip_status {
+    my $date = shift;
+    my $target = shift;
+
+    my $command = construct_chiptool_cmd($date,$target) . ' -pretend ';
+    my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+        run ( command => $command, verbose => $verbose );
+    unless ($success) {
+        $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+        &my_die("Unable to perform chiptool: $error_code", 0,0,$date, $PS_EXIT_SYS_ERROR);
+    }
+
+    my $burntoolStateGood = get_goodBTvalue();
+    my $Nimfiles = 0; 
+    my $Nburntooled = 0;
+    my $Nalready = 0;
+    my @input_exposures = split /\n/, (join '', @$stdout_buf);
+    foreach my $entry (@input_exposures) {
+        my ($exp_id, @trash) = split /\s+/, $entry;
+        @trash = verify_burntool($exp_id,$burntoolStateGood);
+        $Nimfiles += $trash[0];
+        $Nburntooled += $trash[1];
+
+        @trash = verify_uniqueness_chip($exp_id,$date,$target);
+        $Nalready += $trash[0];
+    }
+    return($#input_exposures + 1,$Nimfiles,$Nburntooled,$Nalready);
+}
+
+sub burntool_status {
+    my $date = shift;
+    my $exposures = 0;
+
+    foreach my $target (sort (keys %science_config)) {
+	my ($Nexposures,$Nimfiles,$Nburntooled,$Nalready) = check_chip_status($date,$target);
+	print "BTSTATS: $date $target $Nexposures $Nimfiles $Nburntooled $Nalready\n";
+    }
+}
+
+
+#
+# DQstats
+################################################################################
+
+sub construct_dqstats_cmd {
+    my $date = shift;
+
+    my $select = "-dateobs_end ${date}T23:59:59 ";
+
+    my $cmd = "$dqstatstool";
+    $cmd .= " -simple -dbname $dbname -definebyquery ";
+    $cmd .= " $select ";
+    $cmd .= " -label %.nightlyscience ";
+    $cmd .= " -set_label dqstats.nightlyscience ";
+    if ($debug == 1) {
+	$cmd .= ' -pretend ';
+    }
+    print STDERR "$cmd\n";
+    return($cmd);
+}
+
+sub pre_dqstats_queue {
+    my $date = shift;
+    
+    my $command = construct_dqstats_cmd($date) . ' -pretend ';
+    my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+        run ( command => $command, verbose => $verbose );
+    unless ($success) {
+        $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+        &my_die("Unable to perform dqstatstool: $error_code",1,1,,$date, $PS_EXIT_SYS_ERROR);
+    }
+    
+    my @input_exposures = split /\n/, (join '', @$stdout_buf);
+
+    return($#input_exposures + 1,1,1); 
+}
+ 
+sub dqstats_queue {
+    my $date = shift;
+
+    my $command = construct_dqstats_cmd($date);
+    my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+        run ( command => $command, verbose => $verbose );
+    unless ($success) {
+        $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+        &my_die("Unable to perform dqstatstool: $error_code", 0,0,$date, $PS_EXIT_SYS_ERROR);
+    }
+    return(0);
+
+}
+sub execute_dqstats {
+    my $date = shift;
+    my $pretend = shift;
+    my ($Nexposures,$Nchips,$Ncams) = pre_dqstats_queue($date);
+    if ($Nexposures == 0) {
+	print STDERR "execute_dqstats: No exposures on date $date.\n";
+    }
+    elsif ($Ncams != $Nchips) {
+	print STDERR "execute_dqstats: Not done processing data through camera stage.\n";
+    }
+    else {
+	unless(defined($pretend)) {
+	    dqstats_queue($date);
+	}
+	if (defined($pretend)) {
+	    add_to_macro_list('check_dqstats',1,$date);
+	}
+	else {
+	    add_to_macro_list('queue_dqstats',1,$date);
+	}
+    }
+}   
+#
+# Detrend verification
+################################################################################
+
+sub construct_dettool_cmd {
+    my $date = shift;
+    my $target = shift;
+
+    my ($label,$workdir,$filter,$exp_type,$det_type,$ref_det_id,$ref_iter,$maxN) = get_dettool_parameters($date,$target);
+    
+    my $select = "-select_dateobs_begin ${date}T00:00:00 -select_dateobs_end ${date}T23:59:59 ";
+    my $use_limits = " -use_begin ${date}T00:00:00 -use_end ${date}T23:59:59 ";
+    $date =~ s/-//g;
+
+    my $cmd = "$dettool";
+#    $cmd .= " -pretend ";
+    $cmd .= " -simple -dbname $dbname -definebyquery -det_type $det_type ";
+    $cmd .= " -mode verify -ref_det_id $ref_det_id -ref_iter $ref_iter ";
+    $cmd .= " $select ";
+    $cmd .= " -inst $camera ";
+    $cmd .= " -select_exp_type $exp_type ";
+    $cmd .= " -select_filter $filter " if defined($filter);
+    $cmd .= " -workdir $workdir ";
+    $cmd .= " -label $label ";
+    $cmd .= " $use_limits ";
+    if ($maxN > 0) {
+	$cmd .= " -random_subset -random_limit $maxN ";
+    }
+    if ($debug == 1) {
+	$cmd .= ' -pretend ';
+    }
+    print STDERR "$cmd\n";
+    return($cmd);
+}    
+
+sub verify_uniqueness_detverify {
+    my $date = shift;
+    my $target = shift;
+
+    my ($label,$workdir,$filter,$exp_type,$det_type,$ref_det_id,$ref_iter,$maxN) = get_dettool_parameters($date,$target);
+    
+    my $db = init_gpc_db();
+    my $sth = "SELECT * FROM detRun WHERE workdir = '$workdir' AND ref_det_id = $ref_det_id AND ref_iter = $ref_iter";
+    my $data_ref = $db->selectall_arrayref( $sth );
+
+    return($#{ $data_ref } + 1);
+}
+
+sub pre_detrend_queue {
+    my $date = shift;
+    my $target = shift;
+    
+    my $command = construct_dettool_cmd($date,$target) . ' -pretend ';
+    my ($success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+	run ( command => $command, verbose => $verbose);
+    unless ($success) {
+	$error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+	&my_die("Unable to perform dettool: $error_code", 0,0, $date, $PS_EXIT_SYS_ERROR);
+    }
+    
+    my @input_exposures = split /\n/, (join '', @$stdout_buf);
+    return($#input_exposures + 1);
+}
+
+sub detrend_queue {
+    my $date = shift;
+    my $target = shift;
+    
+    my $command = construct_dettool_cmd($date,$target);
+    my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+	run ( command => $command, verbose => $verbose);
+    unless ($success) {
+	$error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+	&my_die("Unable to perform chiptool: $error_code", 0,0,$date, $PS_EXIT_SYS_ERROR);
+    }
+    $metadata_out{nsDetState} = 'DETREND_QUEUED';
+    return(0);
+
+}
+sub execute_detrends {
+    my $date = shift;
+    my $pretend = shift;
+    my $exposures = 0;
+    foreach my $target (sort (keys %detrend_config)) {
+	my ($Nexposures) = pre_detrend_queue($date,$target);
+	if ($Nexposures == 0) {
+	    print STDERR "execute_detrends: Target $target on $date had no exposures.\n";
+	    next;
+	}
+	$exposures++;
+	unless(defined($pretend)) {
+	    detrend_queue($date,$target);
+	}
+	if (defined($pretend)) {
+	    add_to_macro_list('check_detrends',1,$date,$target,"dettool");
+	}
+	else {
+	    add_to_macro_list('queue_detrends',1,$date,$target,"dettool");
+	}
+    }
+    if ($exposures == 0) {
+	$metadata_out{nsDetState} = 'DETREND_DROP';
+    }
+    if (($metadata_out{nsDetState} eq 'CHECKDETRENDS') && ($exposures > 0)) {
+	$metadata_out{nsDetState} eq 'QUEUEDETRENDS';
+    }
+}
+
+# #
+# # SweetSpot Stacking
+# ################################################################################
+# sub construct_sweetspot_cmd {
+#     my $date = shift;
+#     my $target = 'SweetSpot';
+#     my $filter = 'w.00000';
+
+#     my ($label,$workdir,$obs_mode,$object,$comment,$tess_id,$dist_group,$data_group,$reduction) = get_tool_parameters($date,$target);
+
+#     # Dateobs begin end?
+#     my ($dateobs_begin,$dateobs_end) = get_lunation_extent($date);
+#     my $select = "-select_dateobs_begin ${dateobs_begin}T00:00:00 -select_dateobs_end ${dateobs_end}T00:00:00";
+#     my $cmd = "$stacktool";
+#     $cmd .= " -simple -dbname $dbname -definebyquery ";
+#     $cmd .= " -set_label SweetSpot.refstack -select_label $label ";
+#     $cmd .= " -set_workdir $workdir -set_dist_group $dist_group ";
+#     $cmd .= " -select_filter $filter -set_data_group $data_group ";
+#     $cmd .= " -select_good_frac_min 0.1 -select_fwhm_major_max 8.0 ";
+#     $cmd .= " -min_num 7 -min_new 4";
+#     $cmd .= " $select ";
+#     if ($debug == 1) {
+# 	$cmd .= ' -pretend ';
+#     }
+#     print STDERR "$cmd\n";
+#     return($cmd);
+# }
+
+# sub get_lunation_extent {
+#     my $date = shift;
+#     my ($year,$month,$day) = split /-/,$date;
+#     my $dateobs_begin;
+#     my $dateobs_end;
+
+#     my $dt = DateTime->new(year => $year, month => $month, day => $day,
+# 			   hour => 0, minute => 0, second => 0, nanosecond => 0,
+# 			   time_zone => 'Pacific/Honolulu');
+#     do {
+# 	$dt->subtract(days => 1);
+# 	my $ymd = $dt->ymd;
+# 	my $md_cmd = "moondata $ymd 0 0";
+# 	my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+# 	    run ( command => $md_cmd, verbose => $verbose);
+# 	unless ($success) {
+# 	    $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+# 	    &my_die("Unable to perform moondata: $error_code", 0,0, $date, $PS_EXIT_SYS_ERROR);
+# 	}
+# 	my @result = split /\s+/,(join "\n", @$stdout_buf);
+# 	if (abs($result[6]) <= 0.5) {
+# 	    $dateobs_end = $ymd;
+# 	}
+#     } while (!defined($dateobs_end));
+    
+#     do {
+# 	$dt->subtract(days => 1);
+# 	my $ymd = $dt->ymd;
+# 	my $md_cmd = "moondata $ymd 0 0";
+# 	my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+# 	    run ( command => $md_cmd, verbose => $verbose);
+# 	unless ($success) {
+# 	    $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+# 	    &my_die("Unable to perform moondata: $error_code", 0,0, $date, $PS_EXIT_SYS_ERROR);
+# 	}
+# 	my @result = split /\s+/,(join "", @$stdout_buf);
+# 	if (abs($result[6]) <= 0.5) {
+# 	    $dateobs_begin = $ymd;
+# 	}
+#     } while (!defined($dateobs_begin));
+	
+#     return($dateobs_begin,$dateobs_end);
+# }
+
+# sub pre_sweetspot_queue { 
+#     my $date = shift;
+#     my $command = construct_sweetspot_cmd($date) . ' -pretend ';
+#     my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+# 	run ( command => $command, verbose => $verbose );
+#     unless ($success) {
+#         $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+#         &my_die("Unable to perform sweetspot stacktool: $error_code", 0,0,$date, $PS_EXIT_SYS_ERROR);
+#     }
+#     my @stacks = split /\n/, (join '', @$stdout_buf);
+#     my $Nstacks = $#stacks + 1;
+        
+#     return(1,$Nstacks);
+# }
+
+# sub sweetspot_queue {
+#     my $date = shift;
+#     my $command = construct_sweetspot_cmd($date);
+#     my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+# 	run ( command => $command, verbose => $verbose );
+#     unless ($success) {
+#         $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+#         &my_die("Unable to perform sweetspot stacktool: $error_code", 0,0,$date, $PS_EXIT_SYS_ERROR);
+#     }
+#     my @stacks = split /\n/, (join '', @$stdout_buf);
+#     my $Nstacks = $#stacks + 1;
+    
+#     return(1,$Nstacks);
+# }
+
+# sub execute_sweetspot {    
+#     my $date = shift;
+#     my $pretend = shift;
+    
+#     my ($is_lunation_date,$Nstacks) = pre_sweetspot_queue($date);
+#     if ($Nstacks == 0) {
+# 	print STDERR "execute_sweetspot: No new stacks to make ($Nstacks)\n";
+# 	$metadata_out{nsSSState} = 'SS_EMPTY';
+# 	return();
+#     }
+#     if ($Nstacks < 10) {
+# 	print STDERR "execute_sweetspot: Too few new stacks to make ($Nstacks)\n";
+# 	$metadata_out{nsSSState} = 'SS_FEW';
+# 	return();
+#     }
+#     if ($is_lunation_date == 0) {
+# 	print STDERR "execute_sweetspot: Invalid lunation date. ($date $is_lunation_date)\n";
+# 	$metadata_out{nsSSState} = 'SS_ERROR';
+# 	return();
+#     }
+#     $metadata_out{nsSSState} = 'SS_QUEUE';
+#     $metadata_out{nsSweetSpot} = $Nstacks;
+#     unless(defined($pretend)) {
+# 	$metadata_out{nsSSState} = 'SS_DONE';
+# 	sweetspot_queue($date);
+#     }
+#     if (defined($pretend)) {
+# 	add_to_macro_list('check_sweetspot',1,$date);
+#     }
+#     else {
+# 	add_to_macro_list('queue_sweetspot',1,$date);
+#     }
+# }
+
+#
+# Stacking
+################################################################################
+
+
+sub construct_stacktool_cmd {
+    my $date = shift;
+    my $target = shift;
+    my $filter = shift;
+
+    my ($label,$workdir,$obs_mode,$object,$comment,$tess_id,$dist_group,$data_group,$reduction) = get_tool_parameters($date,$target);
+
+    my $select =  "-select_dateobs_begin ${date}T00:00:00 -select_dateobs_end ${date}T23:59:59 ";
+    $date =~ s/-//g;
+
+    my $cmd = "$stacktool";
+#    $cmd .= ' -pretend -simple -dbname gpc1 -definebyquery -min_new 4 ';  # Probably silly, but I want to be safe and not overwrite
+    $cmd .= " -simple -dbname $dbname -definebyquery ";
+    $cmd .= " -set_label $label -select_label $label ";
+    $cmd .= " -set_workdir $workdir -set_dist_group $dist_group ";
+    $cmd .= " -select_filter $filter -set_data_group $data_group ";
+    $cmd .= " -min_num 4";
+    $cmd .= " -select_good_frac_min 0.05";
+    $cmd .= " $select ";
+    if ($debug == 1) {
+        $cmd .= ' -pretend ';
+    }
+    print STDERR "$cmd\n";
+    return($cmd);
+}
+
+sub verify_uniqueness_stack {
+    my $skycell = shift;
+    my $date = shift;
+    my $target = shift;
+    my $filter = shift;
+
+    my $db = init_gpc_db();
+    $date =~ s/-//g;
+    my ($label,$workdir,$obs_mode,$object,$comment,$tess_id,$dist_group,$data_group,$reduction) = get_tool_parameters($date,$target);
+
+    my $sth = "SELECT skycell_id from stackRun where data_group = '$data_group' AND skycell_id = '$skycell' AND filter = '$filter' AND tess_id = '$tess_id'";
+    my $data_ref = $db->selectall_arrayref( $sth );
+
+    return($#{ $data_ref } + 1);
+}
+
+sub pre_stack_queue {
+    my $date = shift;
+    my $observing_state = shift;
+    my $target = shift;
+    my $filter = shift;
+
+    my ($label,$workdir,$obs_mode,$object,$comment,$tess_id,$dist_group,$data_group,$reduction) = get_tool_parameters($date,$target);
+
+    my $db = init_gpc_db();
+
+    my $trunc_date = $date; $trunc_date =~ s/-//g;
+
+    my $where = " label = '$label' AND data_group = '$data_group' ";
+
+    my $where_possibly_faulted = $where . " AND ( " ;
+    foreach my $acceptable_quality (@unrecoverable_quality) {
+	$where_possibly_faulted .= " quality = $acceptable_quality OR ";
+    }
+    $where_possibly_faulted .= " 0 )";
+
+    my $chip_sth = "SELECT * from chipRun WHERE (state = 'full' OR state = 'new') AND $where ";
+    my $cam_sth  = "SELECT * from camRun JOIN camProcessedExp USING(cam_id) WHERE state = 'full' AND $where_possibly_faulted ";
+    my $warp_sth = "SELECT * from warpRun WHERE state = 'full' AND $where ";
+
+    my $chip_ref = $db->selectall_arrayref( $chip_sth );
+    my $cam_ref  = $db->selectall_arrayref( $cam_sth );
+    my $warp_ref = $db->selectall_arrayref( $warp_sth );
+
+    # check that we will be able to queue them up
+    my $command = construct_stacktool_cmd($date,$target,$filter) . ' -pretend ';
+    my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+        run ( command => $command, verbose => $verbose );
+    unless ($success) {
+        $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+        &my_die("Unable to perform stacktool: $error_code", $#{ $chip_ref },$#{ $warp_ref },$date, $PS_EXIT_SYS_ERROR);
+    }
+
+    my $Nalready = 0;
+
+    my @input_exposures = split /\n/, (join '', @$stdout_buf);
+    foreach my $entry (@input_exposures) {
+        my ($warp_tess_id,$skycell, @trash) = split /\s+/, $entry;
+        @trash = verify_uniqueness_stack($skycell,$date,$target,$filter);
+        $Nalready += $trash[0];
+    }
+    
+    my $minimum_required_warp;
+    if ($observing_state eq 'OBSERVING') {
+	$minimum_required_warp = $science_config{$target}{MIN_STACK};
+    }
+    unless (defined($minimum_required_warp)) {
+	$minimum_required_warp = 0;
+    }
+
+    return($#input_exposures  + 1, $#{ $chip_ref } + 1, $#{ $cam_ref } + $#{ $warp_ref } + 2, $minimum_required_warp, $Nalready);
+}
+
+sub stack_queue {
+    my $date = shift;
+    my $target = shift;
+    my $filter = shift;
+
+    my $command = construct_stacktool_cmd($date,$target,$filter);
+    my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+        run ( command => $command, verbose => $verbose );
+    unless ($success) {
+        $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+        &my_die("Unable to perform stacktool: $error_code", 0,0,$date, $PS_EXIT_SYS_ERROR);
+    }
+    
+    
+    return(0);
+}
+
+sub execute_stacks {
+    my $date = shift;
+    my $observing_state = shift;
+    my $pretend = shift;
+
+    foreach my $target (sort (keys %science_config)) {
+	if ($science_config{$target}{STACKABLE} == 1) {
+	    foreach my $filter (@filter_list) {
+                my ($Nexposures,$NprocChips,$NprocWarps,$NrequiredWarps,$Nalready) = pre_stack_queue($date,$observing_state,$target,$filter);
+                if ((!defined($force_stack_count))&&($NprocChips != $NprocWarps)) { # This makes me sad. :(
+		    if ($debug == 1) {
+			print STDERR "execute_stacks: Target $target on $date is not fully processed. ($NprocChips $NprocWarps)\n";
+		    }
+                    $metadata_out{nsStackState} = 'FORCETOWARP';
+                    next;
+                }
+                if ($Nexposures == 0) {
+		    if ($debug == 1) {
+			print STDERR "execute_stacks: Target $target in filter $filter on $date has no exposures.\n";
+		    }
+                    next;
+                }
+		if ($NprocWarps < $NrequiredWarps) {
+		    if ($debug == 1) {
+			print STDERR "execute_stacks: Target $target in filter $filter on $date has too few warps to begin stacking. ($NprocWarps $NrequiredWarps)\n";
+		    }
+		    next;
+		}
+                if ($Nalready != 0) {
+		    if ($debug == 1) {
+			print STDERR "execute_stacks: Not queueing $target in filter $filter on $date due to already existing stacks.\n";
+		    }
+		    unless ($metadata_out{nsStackState} eq 'FORCETOWARP') {
+			$metadata_out{nsStackState} = 'STACKING';
+		    }
+                    next;
+                }
+                unless (($metadata_out{nsStackState} eq 'FORCETOWARP')||($metadata_out{nsStackState} eq 'STACKING')) {
+                    $metadata_out{nsStackState} = 'QUEUESTACKS';
+                }
+                unless(defined($pretend)) {
+		    if ($debug == 1) {
+			print STDERR "execute_stacks: Target $target in filter $filter on $date has exposures and will be queued.\n";
+		    }
+                    stack_queue($date,$target,$filter);
+                }
+		if (defined($pretend)) {
+		    add_to_macro_list('check_stacks',$science_config{$target}{STACKABLE},$date,$target,$filter);
+		}
+		else {
+		    add_to_macro_list('queue_stacks',$science_config{$target}{STACKABLE},$date,$target,$filter);
+		}
+            }
+	}
+	else {
+	    if ($debug == 1) {
+		print STDERR "execute_stacks: Target $target is not auto-stackable.\n";
+	    }
+        }
+    }
+}
+
+sub post_stack_queue {
+    my $date = shift;
+    my $target = shift;
+
+    my ($label,$workdir,$obs_mode,$object,$comment,$tess_id,$dist_group,$data_group,$reduction) = get_tool_parameters($date,$target);
+    # check warp stage == chip stage
+    my $db = init_gpc_db();
+
+    my $trunc_date = $date; $trunc_date =~ s/-//g;
+
+    my $where = " label = '$label' AND data_group = '$data_group' ";
+
+    my $stack_full_sth = "SELECT * from stackRun where $where ";
+    my $stack_done_sth = "SELECT * from stackRun LEFT JOIN stackSumSkyfile USING(stack_id) WHERE $where ";
+    $stack_done_sth .= " AND ((state = 'full') OR (state = 'new' && fault != 0)) ";
+    if ($debug == 1) {
+	print STDERR "post_stack_queue: database queries:\n";
+	print STDERR "$stack_full_sth\n";
+	print STDERR "$stack_done_sth\n";
+    }
+    my $stack_full_ref = $db->selectall_arrayref( $stack_full_sth );
+    my $stack_done_ref = $db->selectall_arrayref( $stack_done_sth );
+
+    return($#{ $stack_full_ref } + 1, $#{ $stack_done_ref } + 1);
+}
+
+sub confirm_stacks {
+    my $date = shift;
+    my $pretend = shift;
+    
+    foreach my $target (sort (keys %science_config)) {
+        if ($science_config{$target}{STACKABLE} == 1) {
+	    my ($Nstacks, $Nattempted) = post_stack_queue($date,$target);
+	    if ($debug == 1) {
+		print STDERR "confirm_stacks: Target $target on $date has $Nattempted attempts on $Nstacks.\n";
+	    }
+	    if ($Nstacks != $Nattempted) {
+		if ($debug == 1) {
+		    print STDERR "confirm_stacks: Target $target on $date is not done stacking. $Nstacks $Nattempted\n";
+		}
+		if ($metadata_out{nsStackState} eq 'CONFIRM_STACKING') {
+		    $metadata_out{nsStackState} = 'STACKING';
+		}
+		next;
+	    }
+	    if ($Nstacks == 0) {
+		if ($debug == 1) {
+		    print STDERR "confirm_stacks: Target $target on $date has no stacks. Skipping.\n";
+		}
+		next;
+	    }
+	    if ($metadata_out{nsStackState} eq 'CONFIRM_STACKING') {
+		if (defined($pretend)) {
+		    add_to_macro_list('check_confirm_stacks',$science_config{$target}{STACKABLE},$date,$target);
+		}
+		else {
+		    add_to_macro_list('confirm_stacks',$science_config{$target}{STACKABLE},$date,$target);
+		}
+	    }
+	}
+    }
+}	    
+
+#
+# Extra processing
+################################################################################
+
+sub verify_uniqueness_diff {
+    my $warp_id_1 = shift;
+    my $warp_id_2 = shift;
+    my $date = shift;
+    my $target = shift;
+
+    my $db = init_gpc_db();
+    $date =~ s/-//g;
+    my ($label,$workdir,$obs_mode,$object,$comment,$tess_id,$dist_group,$data_group,$reduction) = get_tool_parameters($date,$target);
+
+    my $sth = "SELECT diff_id from diffRun JOIN diffInputSkyfile USING(diff_id) where data_group = '$data_group' AND warp1 = $warp_id_1 AND warp2 = $warp_id_2";
+    my $data_ref = $db->selectall_arrayref( $sth );
+
+    return($#{ $data_ref } + 1);
+}
+
+sub pre_diff_queue {
+    my $date = shift;
+    my $observing_state = shift;
+    my $target = shift;
+    my $filter = shift;
+    my ($label,$workdir,$obs_mode,$object,$comment,$tess_id,$dist_group,$data_group,$reduction) = get_tool_parameters($date,$target);
+    
+    my $db = init_gpc_db();
+
+    my $trunc_date = $date; $trunc_date =~ s/-//g;
+
+    my $where = " label = '$label' AND data_group = '$data_group' ";
+
+    my $where_possibly_faulted = $where . " AND ( " ;
+    foreach my $acceptable_quality (@unrecoverable_quality) {
+	$where_possibly_faulted .= " quality = $acceptable_quality OR ";
+    }
+    $where_possibly_faulted .= " 0 )";
+
+    my $chip_sth = "SELECT * from chipRun WHERE (state = 'full' OR state = 'new') AND $where ";
+    my $cam_sth  = "SELECT * from camRun JOIN camProcessedExp USING(cam_id) WHERE state = 'full' AND $where_possibly_faulted ";
+    my $warp_sth = "SELECT * from warpRun WHERE state = 'full' AND $where ";
+
+    my $chip_ref = $db->selectall_arrayref( $chip_sth );
+    my $cam_ref  = $db->selectall_arrayref( $cam_sth );
+    my $warp_ref = $db->selectall_arrayref( $warp_sth );
+
+    return($#{ $chip_ref } + 1, $#{ $cam_ref } + $#{ $warp_ref } + 2);
+}
+
+sub execute_diffs {
+    my $date = shift;
+    my $observing_state = shift;
+    my $pretend = shift;
+
+    foreach my $target (sort (keys %science_config)) {
+	if ($science_config{$target}{DIFFABLE} == 1) {
+	    foreach my $filter (@filter_list) {
+		my ($NprocChips,$NprocWarps) = pre_diff_queue($date,$observing_state,$target,$filter);
+		if ((!defined($force_diff_count))&&($NprocChips != $NprocWarps)) {
+		    if ($debug == 1) {
+			print STDERR "execute_diffs: Target $target on $date is not fully processed. ($NprocChips $NprocWarps)\n";
+		    }
+                    $metadata_out{nsDiffState} = 'FORCETOWARP';
+                    next;
+                }
+                if ($NprocChips == 0) {
+		    if ($debug == 1) {
+			print STDERR "execute_diffs: Target $target in filter $filter on $date has no exposures.\n";
+		    }
+                    next;
+                }
+                unless (($metadata_out{nsDiffState} eq 'FORCETOWARP')||($metadata_out{nsDiffState} eq 'DIFFING')) {
+                    $metadata_out{nsDiffState} = 'QUEUEDIFFS';
+                }
+		if ($debug == 1) {
+		    print STDERR "execute_diffs: Target $target in filter $filter on $date has exposures and will be queued.\n";
+		}
+		diff_queue($date,$target,$filter,$pretend);
+
+		if (defined($pretend)) {
+		    add_to_macro_list('check_diffs',$science_config{$target}{DIFFABLE},$date,$target,$filter);
+		}
+		else {
+		    add_to_macro_list('queue_diffs',$science_config{$target}{DIFFABLE},$date,$target,$filter);
+		}
+            }
+	}
+	else {
+	    if ($debug == 1) {
+		print STDERR "execute_diffs: Target $target is not auto-diffable.\n";
+	    }
+        }
+    }
+}
+
+sub diff_queue {
+    my $date = shift;
+    my $target = shift;
+    my $filter = shift;
+    my $pretend = shift;
+    my ($label,$workdir,$obs_mode,$object,$comment,$tess_id,$dist_group,$data_group,$reduction) = get_tool_parameters($date,$target);
+
+    my $db = init_gpc_db();
+
+    my $obj_sth = "select DISTINCT rawExp.object from warpRun JOIN fakeRun USING(fake_id) JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id) ";
+    $obj_sth .= " WHERE warpRun.state = 'full' AND warpRun.label = '$label' AND warpRun.data_group = '$data_group' AND rawExp.filter = '$filter' ORDER BY rawExp.object";
+
+    my $object_ref = $db->selectall_arrayref( $obj_sth );
+    
+    foreach my $object_row (@{ $object_ref }) {
+	my $this_object = shift @{ $object_row };
+	my $input_sth = "select exp_id,warp_id,dateobs from warpRun JOIN fakeRun USING(fake_id) JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id) ";
+	$input_sth .= " WHERE warpRun.state = 'full' AND warpRun.label = '$label' AND warpRun.data_group = '$data_group' AND rawExp.filter = '$filter' AND rawExp.object = '$this_object' ";
+	$input_sth .= " ORDER BY dateobs ";
+	
+	my $warps = $db->selectall_arrayref( $input_sth );
+	
+	if (($#{ $warps } + 1) % 2 != 0) {
+	    print STDERR "diff_queue: Number of input warps to make diffs is not even for target $target and object $this_object! $#{ $warps }\n";
+	    next;
+	}
+	
+	while ($#{ $warps } > -1) {
+	    my $input_warp = shift @{ $warps };
+	    my $template_warp = shift @{ $warps };
+	    my $input_exp_id = ${ $input_warp }[0];
+	    my $template_exp_id = ${ $template_warp }[0];
+	    
+	    my $input_warp_id = ${ $input_warp }[1];
+	    my $template_warp_id = ${ $template_warp }[1];
+	    
+	    if (verify_uniqueness_diff($input_warp_id,$template_warp_id,$date,$target) != 0) {
+		print STDERR "Diffs already queued for this $date $target $input_exp_id $template_exp_id\n";
+		next;
+	    }
+	    
+	    my $cmd = "$difftool -dbname $dbname  -definewarpwarp ";
+	    $cmd .= "-input_label $label  -template_label $label ";
+	    $cmd .= "-backwards "; # Needed because difftool assumes a different date sorting.
+	    $cmd .= "-set_workdir $workdir  -set_dist_group $dist_group  -set_data_group $data_group ";
+	    $cmd .= " -simple  -set_label $label -exp_id $input_exp_id -template_exp_id $template_exp_id ";
+#		$cmd .= " -pretend ";
+	    if (defined($pretend)) {
+		$cmd .= ' -pretend ';
+	    }
+	    if ($debug == 1) {
+		$cmd .= ' -pretend ';
+		print STDERR "diff_queue: $cmd\n";
+	    }
+	    
+	    if (($debug == 0)&&(!defined($pretend))) {
+		my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+		    run ( command => $cmd, verbose => $verbose );
+		unless ($success) {
+		    $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+		    &my_die("Unable to perform difftool: $error_code", 0,0,$date, $PS_EXIT_SYS_ERROR);
+		}
+	    }
+	}
+    }
+}
+	    
+
+
+#
+# Auto-Clean
+################################################################################
+
+sub construct_cleantool_args {
+    my $date = shift;
+    my $target = shift;
+    my $mode = shift;
+
+    my $command = $clean_config{$mode}{COMMAND};
+    my $retention_time;
+    if (exists($science_config{$target}{$mode})) {
+	$retention_time = $science_config{$target}{$mode};
+    }
+    else {
+	$retention_time = $clean_config{$mode}{RETENTION_TIME};
+    }
+    if ($retention_time <= 0) {
+	return("no clean","true");
+    }
+
+    my ($year,$month,$day) = split /-/,$date;
+    my $dt = DateTime->new(year => $year, month => $month, day => $day,
+			   hour => 0, minute => 0, second => 0, nanosecond => 0,
+			   time_zone => 'Pacific/Honolulu');
+	
+    $dt->subtract(days => $retention_time);
+    my $cleaning_date = $dt->ymd;
+
+    my ($label,$workdir,$obs_mode,$object,$comment,$tess_id,$dist_group,$data_group,$reduction) = get_tool_parameters($cleaning_date,$target);
+    
+    $command =~ s/\@DBNAME\@/$dbname/;
+    $command =~ s/\@LABEL\@/$label/;
+    $command =~ s/\@WORKDIR\@/$workdir/;
+    $command =~ s/\@OBSMODE\@/$obs_mode/;
+    $command =~ s/\@OBJECT\@/$object/;
+    $command =~ s/\@TESS_ID\@/$tess_id/;
+    $command =~ s/\@DIST_GROUP\@/$dist_group/;
+    $command =~ s/\@DATA_GROUP\@/$data_group/;
+    $command =~ s/\@REDUCTION\@/$reduction/;
+    $command =~ s/\@CURRENT_DATE\@/$cleaning_date/;
+    
+    if ($debug == 1) {
+        $command .= ' -pretend ';
+    }
+    return($cleaning_date,$command);
+}
+
+sub execute_cleans {
+    my $date = shift;
+    my $pretend = shift;
+
+    foreach my $mode (sort (keys %clean_config)) {
+	foreach my $target (sort (keys %science_config)) {
+	    if (exists($science_config{$target}{NOCLEAN})) {
+		next;
+	    }
+	    my ($cleaning_date,$command) = construct_cleantool_args($date,$target,$mode);
+	    if ($cleaning_date eq 'no clean') {
+		next;
+	    }		
+	    print STDERR "$command\n";
+	    if (!(defined($pretend) || $debug == 1)) {
+#           print STDERR "BEAR IS DRIVING!?\n";
+		my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+		    run ( command => $command, verbose => $verbose );
+		unless ($success) {
+		    $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+		    &my_die("Unable to perform cleantool ($command): $error_code", 0,0,$date, $PS_EXIT_SYS_ERROR);
+		}
+		add_to_macro_list('clean_old',1,$date,$target,$mode);
+	    }
+	}
+    }
+    return(0);
+}
+
+#
+# Utilities
+################################################################################
+
+sub get_observing_state {
+    my $date = shift;
+    my $eon_dt = DateTime->new( year   => $datetime->year,
+				month  => $datetime->month,
+				day    => $datetime->day,
+				hour   => 6,
+				minute => 30,
+				second => 0,
+				time_zone => 'Pacific/Honolulu');
+    
+    foreach my $eon (keys %eon_config) {
+	my $command = "$regtool -processedexp -simple ";
+	$command .= " -dbname $dbname ";
+	$command .= " -dateobs_begin ${date}T00:00:00 -dateobs_end ${date}T23:59:59 ";
+	$command .= " -object $eon_config{$eon}{OBJECT} " if defined($eon_config{$eon}{OBJECT});
+	$command .= " -obs_mode $eon_config{$eon}{OBSMODE} " if defined($eon_config{$eon}{OBSMODE});
+	$command .= " -exp_type $eon_config{$eon}{EXPTYPE} " if defined($eon_config{$eon}{EXPTYPE});
+	$command .= " -comment $eon_config{$eon}{COMMENT} " if defined($eon_config{$eon}{COMMENT});
+
+	my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+	    run ( command => $command, verbose => $verbose );
+	unless ($success) {
+	    $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+	    &my_die("Unable to perform regtool: $error_code", 0,0,$date, $PS_EXIT_SYS_ERROR);
+	}
+	my @eon_exposures = split /\n/, (join '', @$stdout_buf);
+	if ($#eon_exposures >= 0) {
+	    return("END_OF_NIGHT");
+	}
+    }	
+
+    if (DateTime->compare($datetime,$eon_dt) < 1) {
+	return("OBSERVING");
+    }
+    else {
+	return("END_OF_NIGHT");
+    }
+}
+
+sub get_tool_parameters {
+    my $date = shift;
+    my $target = shift;
+    my $workdir_date = $date; $workdir_date =~ s%-%/%g;
+    my $trunc_date = $date; $trunc_date =~ s/-//g;
+
+    my $label      = "${target}.nightlyscience";
+    my $workdir    = "neb://\@HOST\@.0/${dbname}/${target}.nt/${workdir_date}";
+    my $obs_mode   = $science_config{$target}{OBSMODE};
+    my $object     = $science_config{$target}{OBJECT};
+    my $comment    = $science_config{$target}{COMMENT};
+    my $dist_group = $science_config{$target}{DISTRIBUTION};
+    my $data_group = "${target}.${trunc_date}";
+    my $tess_id    = $science_config{$target}{TESS};
+    my $reduction  = $science_config{$target}{REDUCTION};
+    return($label,$workdir,$obs_mode,$object,$comment,$tess_id,$dist_group,$data_group,$reduction);
+}
+
+sub get_dettool_parameters {
+    my $date = shift;
+    my $target = shift;
+    my $workdir_date = $date; $workdir_date =~ s%-%/%g;
+    my $trunc_date = $date; $trunc_date =~ s/-//g;
+
+    my $exp_type   = $detrend_config{$target}{EXPTYPE};
+    my $det_type   = $detrend_config{$target}{DETTYPE};
+    my $ref_det_id = $detrend_config{$target}{REF_ID};
+    my $ref_iter   = $detrend_config{$target}{REF_ITER};
+    my $maxN       = $detrend_config{$target}{MAX_EXP};
+    my $det_filter = $detrend_config{$target}{DET_FILTER};
+    my $internal_filter;
+    if (defined($det_filter)) {
+	$internal_filter = $det_filter; $internal_filter =~ s/\..*//;
+	$internal_filter = '.' . $internal_filter;
+    }
+    else {
+	$internal_filter = '';
+    }
+    unless (defined($maxN)) {
+	$maxN = 0;
+    }
+    my $lc_type = lc($exp_type);
+    my $label = "${lc_type}${internal_filter}.$trunc_date";
+    my $workdir = 'neb://@HOST@.0/' . $dbname . "/detverify.nt/${workdir_date}/${lc_type}${internal_filter}";
+    return($label,$workdir,$det_filter,$exp_type,$det_type,$ref_det_id,$ref_iter,$maxN);
+}
+
+sub add_to_macro_list {
+    my $proc_mode = shift;
+    my $do_or_do_not = shift;
+    my $date = shift;
+    my $target = shift;
+    my $mode = shift;
+
+    if ((defined($macro_config{$proc_mode}))&&($do_or_do_not)) {
+	unless (defined($metadata_out{N_MACROS})) {
+	    $metadata_out{N_MACROS} = 0;
+	}
+	my $N = $metadata_out{N_MACROS};
+	$metadata_out{"ns${N}Macro"} = $macro_config{$proc_mode};
+	if ($debug == 1) {
+	    print STDERR "WORKING ON A MACRO: ns${N}Macro $proc_mode $macro_config{$proc_mode}\n";
+	}
+	if (defined($date)&&(defined($target))) {
+
+	    my ($label,$workdir,$obs_mode,$object,$comment,$tess_id,$dist_group,$data_group,$reduction) 
+		= get_tool_parameters($date,$target);
+	    $metadata_out{"ns${N}Macro"} =~ s/\@LABEL\@/$label/;
+	    $metadata_out{"ns${N}Macro"} =~ s/\@WORKDIR\@/$workdir/;
+	    $metadata_out{"ns${N}Macro"} =~ s/\@OBSMODE\@/$obs_mode/;
+	    $metadata_out{"ns${N}Macro"} =~ s/\@OBJECT\@/$object/;
+	    $metadata_out{"ns${N}Macro"} =~ s/\@COMMENT\@/$comment/;
+	    $metadata_out{"ns${N}Macro"} =~ s/\@TESS_ID\@/$tess_id/;
+	    $metadata_out{"ns${N}Macro"} =~ s/\@DIST_GROUP\@/$dist_group/;
+	    $metadata_out{"ns${N}Macro"} =~ s/\@DATA_GROUP\@/$data_group/;
+	    $metadata_out{"ns${N}Macro"} =~ s/\@REDUCTION\@/$reduction/;
+	}
+	if (defined($mode)) {
+	    $metadata_out{"ns${N}Macro"} =~ s/\@EXTRA\@/$mode/;
+	}
+	if (defined($date)) {
+	    $metadata_out{"ns${N}Macro"} =~ s/\@DATE\@/$date/;
+	}
+	if ($debug == 1) {
+	    print STDERR "DONE WITH A MACRO: ns${N}Macro $proc_mode $macro_config{$proc_mode}\n";
+	}
+	$metadata_out{N_MACROS} ++;
+    }
+}
+
+sub init_gpc_db {
+    use constant DB_SOCKET => '/var/run/mysqld/mysqld.sock';
+    my $dbserver = 'ippdb01';
+    my $dbuser = 'ippuser';
+    my $dbpass = 'ippuser';
+    $db = DBI->connect("DBI:mysql:database=${dbname};host=${dbserver};" .
+                       "mysql_socket=" . DB_SOCKET(),
+                       ${dbuser},${dbpass},
+                       { RaiseError => 1, AutoCommit => 1}
+        ) or die "Unable to connect to database $DBI::errstr\n";
+    return($db);
+}
+
+sub return_metadata {
+    my $date = shift;
+    print STDOUT "autoStack MULTI\n\n";
+    print STDOUT "autoStack METADATA\n";
+    print STDOUT "   date                  STR          $date\n";
+    foreach my $k (sort(keys %metadata_out)) {
+        print STDOUT "   $k                STR          $metadata_out{$k}\n";
+    }
+    print STDOUT "END\n";
+}
+
+sub my_die {
+    my $msg = shift; # Warning message on die
+    my $stage = shift; # stage name
+    my $stage_id = shift; #  identifier
+    my $exit_code = shift; # Exit code
+    # outputImage and path_base are globals
+
+    carp($msg);
+    exit $exit_code;
+}
+
+sub my_trace {
+    if ($debug == 1) {
+        foreach my $thing (@_) {
+            carp($thing);
+        }
+    }
+}
Index: trunk/ippScripts/scripts/register_exp.pl
===================================================================
--- trunk/ippScripts/scripts/register_exp.pl	(revision 30042)
+++ trunk/ippScripts/scripts/register_exp.pl	(revision 30049)
@@ -30,4 +30,5 @@
 my $regtool = can_run('regtool') or (warn "can't find regtool" and $missing_tools = 1);
 my $ppStatsFromMetadata = can_run('ppStatsFromMetadata') or (warn "Can't find ppStatsFromMetadata" and $missing_tools = 1);
+my $ppConfigDump = can_run('ppConfigDump') or (warn "Can't find ppConfigDump" and $missing_tools = 1);
 if ($missing_tools) {
     warn ("Can't find required tools");
@@ -118,4 +119,12 @@
 if (uc($exp_type) eq "NULL") { &my_die ("exp_type  not found", $exp_id, $PS_EXIT_CONFIG_ERROR); }
 
+my ($data_group,$dist_group,$chip_workdir,$reduction);
+($label,$data_group,$dist_group,$end_stage,
+ $tess_id,$chip_workdir,$reduction) = advance_decisions(&value_for_flag($cmdflags,"-dateobs"),
+							&value_for_flag($cmdflags,"-exp_type"),
+							&value_for_flag($cmdflags,"-obs_mode"),
+							&value_for_flag($cmdflags,"-object"),
+							&value_for_flag($cmdflags,"-comment"),
+							$dbname);
 my $command = "$regtool -addprocessedexp";
 $command .= " -exp_id $exp_id";
@@ -127,4 +136,8 @@
 $command .= " -end_stage $end_stage" if defined $end_stage;
 $command .= " -tess_id   $tess_id"   if defined $tess_id;
+$command .= " -data_group $data_group" if defined $data_group;
+$command .= " -dist_group $dist_group" if defined $dist_group;
+$command .= " -chip_workdir $chip_workdir" if defined $chip_workdir;
+$command .= " -reduction  $reduction"  if defined $reduction;
 $command .= " -state full";
 $command .= " $cmdflags";
@@ -156,4 +169,145 @@
 
 ### Pau.
+sub advance_decisions {
+    my $dateobs = shift;
+    my $exptype = shift;
+    my $obsmode = shift;
+    my $object  = shift;
+    my $comment = shift;
+    my $dbname  = shift;
+
+    # The strings come pre-quoted.
+    $dateobs =~ s/\'//g;
+    $exptype =~ s/\'//g;
+    $obsmode =~ s/\'//g;
+    $object =~ s/\'//g;
+    $comment =~ s/\'//g;
+
+    print "Inside decision engine\n";
+    my ($label,$data_group,$dist_group,$end_stage,$tess_id,$chip_workdir,$reduction);
+    my $target;
+
+    if ($exptype ne 'OBJECT') {
+	print "Aborting because exptype doesn't claim to be OBJECT: $exptype\n";
+	return(undef,undef,undef,"reg",undef,undef,undef);
+    }
+    if ($obsmode eq 'ENGINEERING') {
+	print "Aborting because we don't queue engineering data to chip\n";
+	return(undef,undef,undef,"reg",undef,undef,undef);
+    }
+    # Grab the configuration data.
+    my %nightlyscience_config = ();
+    my $conf_cmd = "$ppConfigDump -dump-recipe NIGHTLY_SCIENCE -";
+    my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+	run(command => $conf_cmd, verbose => $verbose);
+    unless ($success) {
+	$error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+	&my_die("Unable to perform ppConfigDump: $error_code", $date, $PS_EXIT_SYS_ERROR);
+    }
+    print "data loaded\n";
+    my $mdcParser = PS::IPP::Metadata::Config->new;
+    my $metadata = $mdcParser->parse(join "", @$stdout_buf);
+    foreach my $entry (@{ $metadata }) {
+	if (${ $entry }{name} eq 'TARGETS') {
+	    my @target_data = @{ ${ $entry }{value} };
+	    my $this_target = '';
+	    foreach my $tentry (@target_data) {
+		if (${ $tentry }{name} eq 'NAME') {
+		    $this_target = ${ $tentry }{value};
+		    $nightlyscience_config{$this_target}{DISTRIBUTION} = $this_target;
+		}
+		elsif (${ $tentry }{name} eq 'DISTRIBUTION') {
+		    $nightlyscience_config{$this_target}{DISTRIBUTION} = ${ $tentry }{value};
+		}
+		elsif (${ $tentry }{name} eq 'TESS') {
+		    $nightlyscience_config{$this_target}{TESS_ID} = ${ $tentry }{value};
+		}
+		elsif (${ $tentry }{name} eq 'OBSMODE') {
+		    $nightlyscience_config{$this_target}{OBSMODE} = ${ $tentry }{value};
+		    $nightlyscience_config{$this_target}{OBSMODE} =~ s/%/\.\*/g;
+		}
+		elsif (${ $tentry }{name} eq 'OBJECT') {
+		    $nightlyscience_config{$this_target}{OBJECT} = ${ $tentry }{value};
+		    $nightlyscience_config{$this_target}{OBJECT} =~ s/%/\.\*/g;
+		}
+		elsif (${ $tentry }{name} eq 'COMMENT') {
+		    $nightlyscience_config{$this_target}{COMMENT} = ${ $tentry }{value};
+		    $nightlyscience_config{$this_target}{COMMENT} =~ s/%/\.\*/g;
+		}
+		elsif (${ $tentry }{name} eq 'STACKABLE') {
+		    $nightlyscience_config{$this_target}{STACKABLE} = ${ $tentry }{value};
+		}
+		elsif (${ $tentry }{name} eq 'DIFFABLE') {
+		    $nightlyscience_config{$this_target}{DIFFABLE} = ${ $tentry }{value};
+		}
+		elsif (${ $tentry }{name} eq 'REDUCTION') {
+		    $nightlyscience_config{$this_target}{REDUCTION} = ${ $tentry }{value};
+		}
+	    }
+	}
+    }
+    print "data parsed\n";
+    my $found_target;
+    foreach $target (keys %nightlyscience_config) {
+#	print "TEST: $target ($obsmode $object $comment) ($nightlyscience_config{$target}{OBSMODE} $nightlyscience_config{$target}{OBJECT} $nightlyscience_config{$target}{COMMENT}\t";
+	my $match = 0;
+	my $possible = 0;
+	if (exists($nightlyscience_config{$target}{OBSMODE})) {
+	    $possible++;
+	    if ($obsmode =~ /$nightlyscience_config{$target}{OBSMODE}/) {
+		$match++;
+	    }
+	}
+	if (exists($nightlyscience_config{$target}{OBJECT})) {
+	    $possible++;
+	    if ($object =~ /$nightlyscience_config{$target}{OBJECT}/) {
+		$match++;
+	    }
+	}
+	if (exists($nightlyscience_config{$target}{COMMENT})) {
+	    $possible++;
+	    if ($comment =~ /$nightlyscience_config{$target}{COMMENT}/) {
+		$match++;
+	    }
+	}
+	print "$possible $match\n";
+	if (($possible > 0)&&($match == $possible)) {
+	    $found_target = $target;
+	    last;
+	}
+    }
+    unless ($found_target) {
+	print "No acceptible target found.\n";
+	return(undef,undef,undef,"reg",undef,undef,undef);
+    }
+    print "Found this target: $found_target\n";
+    print "$dateobs\n";
+    $target = $found_target;
+    
+    my $date  = $dateobs;
+    $date =~ s/T.*//;
+    my $workdir_date = $date;
+    $date =~ s/-//g;
+    $workdir_date =~ s%-%/%g;
+    print "$dateobs $date $workdir_date\n";    
+    $label = "${target}.nightlyscience";
+    $data_group = "${target}.${date}";
+    $dist_group = $nightlyscience_config{$target}{DISTRIBUTION};
+    $end_stage  = 'warp';
+    $tess_id    = $nightlyscience_config{$target}{TESS_ID};
+    $chip_workdir = "neb://\@HOST\@.0/${dbname}/${target}.nt/${workdir_date}/";
+    if (exists($nightlyscience_config{$target}{REDUCTION})) {
+	$reduction  = $nightlyscience_config{$target}{REDUCTION};
+    }
+    else {
+	undef($reduction);
+    }
+
+    
+    return ($label,$data_group,$dist_group,$end_stage,$tess_id,$chip_workdir,$reduction);
+}
+	    
+	    
+	    
 
 sub cache_run
Index: trunk/ippScripts/scripts/register_imfile.pl
===================================================================
--- trunk/ippScripts/scripts/register_imfile.pl	(revision 30042)
+++ trunk/ippScripts/scripts/register_imfile.pl	(revision 30049)
@@ -19,6 +19,7 @@
 use File::Basename qw( basename);
 use IPC::Run;
-use IPC::Cmd 0.36 qw( can_run );
+use IPC::Cmd 0.36 qw( can_run run );
 use PS::IPP::Config 1.01 qw( :standard );
+use PS::IPP::Metadata::List qw( parse_md_list );
 use PS::IPP::Metadata::Config;
 use Math::Trig;
@@ -35,4 +36,5 @@
 my $ppStatsFromMetadata = can_run( 'ppStatsFromMetadata' ) or (warn "Can't find ppStatsFromMetadata" and $missing_tools = 1);
 my $ppConfigDump = can_run( 'ppConfigDump' ) or (warn "Can't find ppConfigDump" and $missing_tools = 1);
+my $ippApplyBurntoolSingle = can_run( 'ipp_apply_burntool_single.pl' ) or (warn "Can't find ipp_apply_burntool_single" and $missing_tools = 1);
 
 my ($cache, $exp_id, $tmp_class_id, $tmp_exp_name, $uri, $bytes, $md5sum, $dbname, $verbose, $no_update, $no_op, $logfile);
@@ -82,4 +84,5 @@
 
 my $cmdflags;
+my $burntoolStateGood;
 # Run ppStats on the input file
 {
@@ -114,5 +117,5 @@
     my $burntoolState = 0;
     my $isGPC1 = 0;
-    my $burntoolStateGood = 0;
+    $burntoolStateGood = 0;
     foreach my $line (split /\n/, $out1) {
         if ($line =~ /FPA.BURNTOOL.APPLIED/) {
@@ -174,7 +177,8 @@
 $command .= " -hostname $host" if defined $host;
 $command .= " -dbname $dbname" if defined $dbname;
-$command .= " -data_state full";
+$command .= " -data_state check_burntool";
 $command .= " $cmdflags";
 
+print "$command\n";
 # determine solar-system parameters
 my $longitude = &value_for_flag($cmdflags, 0.0, "-longitude");
@@ -206,4 +210,11 @@
     }
 }
+
+# This might have a race condition
+# $date_end = $dateobs;
+# $date_start = $dateobs - 30 minutes ? dateobs_UTC_midnight?
+# lock file?
+# if exp_type = DARK and date > MIDNIGHT HST { wait }
+# system("ipp_apply_burntool.pl --class_id $class_id --dateobs_begin $date_start --dateobs_end $date_end --dbname gpc1 --logfile /data/$host.0/burntool_logs/$class_id.$start_date.log"); 
 
 $now_time = localtime();
@@ -222,4 +233,91 @@
     print "skipping command: $command\n";
 }
+
+# We now have an imfile in the database, check if we can burntool it.  If not, continue on.
+
+{ 
+    my $mdcParser  = PS::IPP::Metadata::Config->new;
+
+    my $class_id   = &value_for_flag($cmdflags, 0.0, "-class_id");
+    my $check_date       = &value_for_flag($cmdflags, 0.0, "-dateobs");
+    $check_date =~ s/T.*$//;
+    my $exp_name   = $tmp_exp_name;
+    
+
+    my $bt_check_command = "$regtool -checkburntoolimfile ";
+    $bt_check_command .= " -class_id $class_id ";
+    $bt_check_command .= " -date $check_date ";
+    $bt_check_command .= " -valid_burntool $burntoolStateGood ";
+    $bt_check_command .= " -exp_name $exp_name ";
+    $bt_check_command .= " -dbname $dbname" if defined $dbname;
+
+    my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+	run ( command => $bt_check_command, verbose => $verbose);
+    unless ($success) {
+	$error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+	&my_die("Unable to perform regtool: $error_code", 
+		$class_id, $exp_name, $date, $PS_EXIT_SYS_ERROR);
+    }
+
+    my @whole = split /\n/, (join "", @$stdout_buf);
+    my @single = ();
+    my $exposures;
+    while ( scalar @whole > 0 ) {
+	my $value = shift @whole;
+	push @single, $value;
+	if ($value =~ /^\s*END\s*$/) {
+	    push @single, "\n";
+	    
+	    my $list = parse_md_list( $mdcParser->parse( join( "\n", @single ) ) );
+	    &my_die("Unable to parse output from regtool", 
+		    $class_id, $exp_name, $date, $PS_EXIT_SYS_ERROR) unless
+			defined $list;
+	    push @{ $exposures }, @$list;
+	    @single = ();
+	}
+    }
+    
+    # We only care about the final entry, as that contains the exposure we are.
+    
+    my $regtool_update = "$regtool -updateprocessedimfile ";
+    $regtool_update .= "-dbname $dbname " if defined $dbname;
+    $regtool_update .= "-exp_id $exp_id -class_id $class_id ";
+
+    my $burntool_data = pop(@{ $exposures });
+    if ($burntool_data->{burnable} == 0) {
+	$regtool_update .= " -burntool_state 0 -set_state pending_burntool ";
+    }
+    else {
+	my $apply_command = "$ippApplyBurntoolSingle --dbname $dbname ";
+	$apply_command .= " --class_id $class_id --exp_id $exp_id ";
+	$apply_command .= " --this_uri $burntool_data->{uri} ";
+	$apply_command .= " --previous_uri $burntool_data->{previous_uri} " if defined $burntool_data->{previous_uri};
+	$apply_command .= " --imfile_state $burntool_data->{imfile_state} ";
+	$apply_command .= " --verbose " if $verbose;
+	print "$apply_command\n";
+	my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+	    IPC::Cmd::run(command => $apply_command, verbose => $verbose);
+	unless ($success) {
+	    $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+	    warn ("Unable to perform ipp_apply_burntool_single.pl: $error_code");
+	    exit($error_code);
+	}
+    }    
+
+    unless ($no_update) {
+	my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
+	    IPC::Cmd::run(command => $regtool_update, verbose => $verbose);
+	unless ($success) {
+	    $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
+	    warn ("Unable to perform regtool -addprocessedimfile: $error_code");
+	    exit($error_code);
+	}
+    } else {
+	print "skipping command: $command\n";
+    }
+
+}
+
+
 
 $now_time = localtime();