IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 14115


Ignore:
Timestamp:
Jul 10, 2007, 3:18:44 PM (19 years ago)
Author:
eugene
Message:

applying the update to Stats.pm using dtype and new methods

Location:
trunk/ippScripts/scripts
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/ippScripts/scripts/camera_exp.pl

    r13824 r14115  
    1616use IPC::Cmd 0.36 qw( can_run run );
    1717use PS::IPP::Metadata::Config;
     18use PS::IPP::Metadata::Stats;
    1819use PS::IPP::Metadata::List qw( parse_md_list );
    19 use Statistics::Descriptive;
     20
    2021use File::Temp qw( tempfile );
    2122
     
    3435use Pod::Usage qw( pod2usage );
    3536
    36 my ($exp_id, $cam_id, $recipe, $camera, $dbname, $workdir, $dvodb, $no_update, $no_op);
     37my ($exp_tag, $cam_id, $recipe, $camera, $dbname, $workdir, $reduction, $dvodb, $no_update, $no_op);
    3738GetOptions(
    38            'exp_id=s'          => \$exp_id, # Exposure identifier
     39           'exp_tag=s'          => \$exp_tag, # Exposure identifier
    3940           'cam_id=s'          => \$cam_id, # Camtool identifier
    4041           'recipe=s'          => \$recipe, # Recipe to use
     
    4243           'dbname|d=s'        => \$dbname, # Database name
    4344           'workdir|w=s'       => \$workdir, # Working directory
     45           'reduction=s'       => \$reduction, # Reduction class                       
    4446           'dvodb|w=s'         => \$dvodb,  # output DVO database
    4547           'no-update'         => \$no_update, # Update the database?
     
    4951pod2usage( -msg => "Unknown option: @ARGV", -exitval => 2 ) if @ARGV;
    5052pod2usage(
    51     -msg => "Required options: --exp_id --cam_id --camera",
     53    -msg => "Required options: --exp_tag --cam_id --camera",
    5254    -exitval => 3,
    53 ) unless defined $exp_id
     55) unless defined $exp_tag
    5456    and defined $cam_id
    5557    and defined $camera;
     
    5759$ipprc->define_camera($camera);
    5860
    59 use constant RECIPE1 => 'PPIMAGE_J1'; # Recipe to use for ppImage to make JPEGs
    60 use constant RECIPE2 => 'PPIMAGE_J2'; # Recipe to use for ppImage to make JPEGs
    61 
     61# Recipes to use based on reduction class
     62$reduction = 'DEFAULT' unless defined $reduction;
     63
     64my $recipe1 = $ipprc->reduction($reduction, 'JPEG_BIN1'); # Recipe to use
     65&my_die("Unrecognised JPEG recipe", $cam_id, $PS_EXIT_PROG_ERROR) unless defined $recipe1;
     66
     67my $recipe2 = $ipprc->reduction($reduction, 'JPEG_BIN2'); # Recipe to use
     68&my_die("Unrecognised JPEG recipe", $cam_id, $PS_EXIT_PROG_ERROR) unless defined $recipe2;
     69
     70# values to extract from output metadata and the stats to calculate
     71my $CHIPSTATS =
     72   [   
     73       #          PPSTATS KEYWORD         STATISTIC          CHIPTOOL FLAG
     74        { name => "bg",             type => "mean",  flag => "-bg",             dtype => "float" },
     75        { name => "bg_mean_stdev",  type => "stdev", flag => "-bg_mean_stdev",  dtype => "float" },
     76        { name => "bg_stdev",       type => "rms",   flag => "-bg_stdev",       dtype => "float" }, 
     77
     78# these should be coming from the psastro results for Nimfile > 1,
     79        { name => "sigma_ra",       type => "rms",   flag => "-sigma_ra",       dtype => "float" }, 
     80        { name => "sigma_dec",      type => "rms",   flag => "-sigma_dec",      dtype => "float" }, 
     81        { name => "n_stars",        type => "sum",   flag => "-n_stars",        dtype => "int"   }, 
     82        { name => "n_astrom",       type => "sum",   flag => "-n_astrom",       dtype => "int"   }, 
     83
     84        { name => "fwhm",           type => "mean",  flag => "-fwhm",           dtype => "float" }, 
     85
     86# these are not defined for the database table camProcessedExp
     87#       { name => "ap_resid",       type => "mean",  flag => "-ap_resid",       dtype => "float" }, 
     88#       { name => "ap_resid_stdev", type => "rms",   flag => "-ap_resid_stdev", dtype => "float" }, 
     89#       { name => "fringe_0",       type => "mean",  flag => "-fringe_0",       dtype => "float" }, 
     90#       { name => "fringe_1",       type => "rms",   flag => "-fringe_1",       dtype => "float" }, 
     91#       { name => "fringe_0",       type => "stdev", flag => "-fringe_2",       dtype => "float" }, 
     92   ];
     93my $chipStats = PS::IPP::Metadata::Stats->new($CHIPSTATS); # Stats parser
    6294
    6395# Look for programs we need
     
    90122    my $metadata = $mdcParser->parse(join "", @$stdout_buf) or
    91123        &my_die("Unable to parse metadata config doc", $cam_id, $PS_EXIT_PROG_ERROR);
     124
     125    # extract the metadata for the files into a hash list
    92126    $files = parse_md_list($metadata) or
    93127        &my_die("Unable to parse metadata list", $cam_id, $PS_EXIT_PROG_ERROR);
    94 }
    95 
    96 # Gather the statistics
    97 my ($bg, $bg_stdev, $bg_mean_stdev); # The statistics triplet
    98 {
    99     my @backgrounds;            # Array of backgrounds in each component
    100     my @variances;              # Array of variances for each component
    101 #    my @ra;                    # Array of ra errors
    102 #    my @dec;                   # Array of dec errors
    103 #    my @zp;                    # Array of photometric zero points
    104     foreach my $file (@$files) {
    105         &my_die("Unable to find class id", $cam_id, $PS_EXIT_SYS_ERROR) unless defined $file->{class_id};
    106         my $class_id = $file->{class_id};
    107         &my_die("Unable to find bg for class_id=$class_id", $cam_id, $PS_EXIT_SYS_ERROR) unless defined $file->{bg};
    108         &my_die("Unable to find bg_mean_stdev for class_id=$class_id", $cam_id, $PS_EXIT_SYS_ERROR) unless defined $file->{bg_mean_stdev};
    109 #       &my_die("Unable to find sigma_ra for class_id=$class_id", $cam_id, $PS_EXIT_SYS_ERROR) unless defined $file->{sigma_ra};
    110 #       &my_die("Unable to find sigma_dec for class_id=$class_id", $cam_id, $PS_EXIT_SYS_ERROR) unless defined $file->{sigma_dec};
    111 #       &my_die("Unable to find zp for class_id=$class_id", $cam_id, $PS_EXIT_SYS_ERROR) unless defined $file->{zp};
    112         push @backgrounds, $file->{bg};
    113         push @variances, $file->{bg_stdev}**2;
    114     }
    115 
    116     {
    117         my $stats = Statistics::Descriptive::Sparse->new; # Statistics calculator
    118         $stats->add_data(@backgrounds);
    119         $bg = ($stats->mean() or 'NAN');
    120         $bg_mean_stdev = ($stats->standard_deviation() or 'NAN');
    121     }
    122     {
    123         my $stats = Statistics::Descriptive::Sparse->new; # Statistics calculator
    124         $stats->add_data(@variances);
    125         $bg_stdev = (sqrt( $stats->mean() ) or 'NAN');
    126     }
    127 }
    128 
    129 my ($list1File, $list1Name) = tempfile( "$exp_id.cam$cam_id.b1.list.XXXX", UNLINK => 1 ); # For binning 1
    130 my ($list2File, $list2Name) = tempfile( "$exp_id.cam$cam_id.b2.list.XXXX", UNLINK => 1 ); # For binning 2
    131 my ($list3File, $list3Name) = tempfile( "$exp_id.cam$cam_id.b3.list.XXXX", UNLINK => 1 ); # For astrometry
    132 
    133 my @means;                      # Array of means
    134 my @stdevs;                     # Array of stdevs
     128
     129    # extract the stats from the metadata
     130    unless ($chipStats->parse($metadata)) {
     131        &my_die("Unable to find all values in statistics output.\n", $cam_id, $PS_EXIT_PROG_ERROR);
     132    }
     133}
     134
     135my ($list1File, $list1Name) = tempfile( "$exp_tag.cm.$cam_id.b1.list.XXXX", UNLINK => 1 ); # For binning 1
     136my ($list2File, $list2Name) = tempfile( "$exp_tag.cm.$cam_id.b2.list.XXXX", UNLINK => 1 ); # For binning 2
     137my ($list3File, $list3Name) = tempfile( "$exp_tag.cm.$cam_id.b3.list.XXXX", UNLINK => 1 ); # For astrometry
     138
    135139my $chipObjects;
    136140foreach my $file (@$files) {
     
    143147    print $list2File ($ipprc->filename("PPIMAGE.BIN2", $file->{path_base}, $class_id) . "\n");
    144148    print $list3File ($chipObjects . "\n");
    145     push @means, $file->{bg};
    146     push @stdevs, $file->{bg_stdev};
    147149}
    148150close $list1File;
     
    151153
    152154# Output products
    153 $workdir = caturi( $workdir, $exp_id ) if defined $workdir;
    154 my $outputRoot = $ipprc->file_prepare( "$exp_id.cam$cam_id", $workdir, ${$files}[0]->{path_base} );
    155 my $jpeg1 = $ipprc->filename("PPIMAGE.JPEG1", $outputRoot); # Binned JPEG #1
    156 my $jpeg2 = $ipprc->filename("PPIMAGE.JPEG2", $outputRoot); # Binned JPEG #2
     155$workdir = caturi( $workdir, $exp_tag ) if defined $workdir;
     156my $outputRoot = $ipprc->file_prepare( "$exp_tag.cm.$cam_id", $workdir, ${$files}[0]->{path_base} );
     157
     158my $jpeg1      = $ipprc->filename("PPIMAGE.JPEG1", $outputRoot); # Binned JPEG #1
     159my $jpeg2      = $ipprc->filename("PPIMAGE.JPEG2", $outputRoot); # Binned JPEG #2
    157160my $fpaObjects = $ipprc->filename("PSASTRO.OUTPUT.MEF", $outputRoot); # MEF psastro output
    158161
     
    167170    # run psastro +mosastro on the set of chips
    168171    # XXX note that this is wrong if imfiles are cells
     172    # XXX add a ppStats call which will collect the astrometry stats
    169173    if (scalar @$files > 1) {
    170174        my $command = "$psastro -list $list3Name $outputRoot +mosastro -chipastro " .
     
    202206    # Make the jpeg for binning 1
    203207    {
    204         my $command = "$ppImage -list $list1Name $outputRoot -recipe PPIMAGE " . RECIPE1; # Command to run
     208        my $command = "$ppImage -list $list1Name $outputRoot -recipe PPIMAGE $recipe1"; # Command to run
    205209        my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
    206210            run(command => $command, verbose => 1);
     
    214218    # Make the jpeg for binning 2
    215219    {
    216         my $command = "$ppImage -list $list2Name $outputRoot -recipe PPIMAGE " . RECIPE2; # Command to run
     220        my $command = "$ppImage -list $list2Name $outputRoot -recipe PPIMAGE $recipe2"; # Command to run
    217221        my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
    218222            run(command => $command, verbose => 1);
     
    224228    }
    225229}
     230
     231my $fpaCommand = "$camtool -addprocessedexp";
     232$fpaCommand .= " -cam_id $cam_id";
     233$fpaCommand .= " -uri UNKNOWN";
     234$fpaCommand .= " -path_base $outputRoot";
     235$fpaCommand .= " -dbname $dbname" if defined $dbname;
     236$fpaCommand .= $chipStats->cmdflags();
    226237
    227238# Add the result into the database
    228239unless ($no_update) {
    229 
    230     my $command = "$camtool -addprocessedexp";
    231     $command .= " -cam_id $cam_id -uri UNKNOWN -path_base $outputRoot";
    232     $command .= " -bg $bg -bg_stdev $bg_stdev -bg_mean_stdev $bg_mean_stdev";
    233     $command .= " -sigma_ra 0.0 -sigma_dec 0.0";
    234     $command .= " -zp_mean 0.0 -zp_stdev 0.0";
    235     $command .= " -fwhm 0.0 -fwhm_range 0.0";
    236     $command .= " -n_stars 0 -n_extended 0 -n_cr 0 -n_astrom 0";
    237     $command .= " -dbname $dbname" if defined $dbname;
    238 
    239240    my ( $success, $error_code, $full_buf, $stdout_buf, $stderr_buf ) =
    240         run(command => $command, verbose => 1);
     241        run(command => $fpaCommand, verbose => 1);
    241242    unless ($success) {
    242243        $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
     
    244245        exit($error_code);
    245246    }
     247} else {
     248    print "skipping command: $fpaCommand\n";
    246249}
    247250
  • trunk/ippScripts/scripts/chip_imfile.pl

    r14093 r14115  
    6868   [   
    6969       #          PPSTATS KEYWORD         STATISTIC          CHIPTOOL FLAG
    70        { name => "ROBUST_MEDIAN",  type => "mean",  flag => "-bg" },
    71        { name => "ROBUST_MEDIAN",  type => "stdev", flag => "-bg_mean_stdev" },
    72        { name => "ROBUST_STDEV",   type => "rms",   flag => "-bg_stdev" },
    73        { name => "FRINGE_0",       type => "rms",   flag => "-fringe_0" },
    74        { name => "FRINGE_RESID_0", type => "rms",   flag => "-fringe_1" },
    75        { name => "FRINGE_ERR_0",   type => "rms",   flag => "-fringe_2" },
    76        { name => "OVER_VAL",       type => "mean",  flag => "-bias" },
    77        { name => "FWHM",           type => "mean",  flag => "-fwhm" },
    78        { name => "APMIFIT",        type => "mean",  flag => "-ap_resid" },
    79        { name => "DAPMIFIT",       type => "rms",   flag => "-ap_resid_stdev" },
    80        { name => "CERROR",         type => "rms",   flag => "-sigma_ra" },
    81        { name => "CERROR",         type => "rms",   flag => "-sigma_dec" },
    82        { name => "NSTARS",         type => "sum",   flag => "-n_stars" },
    83        { name => "NASTRO",         type => "sum",   flag => "-n_astrom" },
     70       { name => "ROBUST_MEDIAN",  type => "mean",  flag => "-bg",             dtype => "float" },
     71       { name => "ROBUST_MEDIAN",  type => "stdev", flag => "-bg_mean_stdev",  dtype => "float" },
     72       { name => "ROBUST_STDEV",   type => "rms",   flag => "-bg_stdev",       dtype => "float" },
     73       { name => "FRINGE_0",       type => "rms",   flag => "-fringe_0",       dtype => "float" },
     74       { name => "FRINGE_RESID_0", type => "rms",   flag => "-fringe_1",       dtype => "float" },
     75       { name => "FRINGE_ERR_0",   type => "rms",   flag => "-fringe_2",       dtype => "float" },
     76       { name => "OVER_VAL",       type => "mean",  flag => "-bias",           dtype => "float" },
     77       { name => "FWHM",           type => "mean",  flag => "-fwhm",           dtype => "float" },
     78       { name => "APMIFIT",        type => "mean",  flag => "-ap_resid",       dtype => "float" },
     79       { name => "DAPMIFIT",       type => "rms",   flag => "-ap_resid_stdev", dtype => "float" },
     80       { name => "CERROR",         type => "rms",   flag => "-sigma_ra",       dtype => "float" },
     81       { name => "CERROR",         type => "rms",   flag => "-sigma_dec",      dtype => "float" },
     82       { name => "NSTARS",         type => "sum",   flag => "-n_stars",        dtype => "int"  },
     83       { name => "NASTRO",         type => "sum",   flag => "-n_astrom",       dtype => "int"  },
    8484   ];
     85my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
    8586
    8687# Look for programs we need
     
    140141
    141142    # extract the stats from the metadata
    142     my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
    143143    unless ($stats->parse($metadata)) {
    144144        &my_die("Unable to find all values in statistics output.\n", $chip_id, $class_id, $PS_EXIT_PROG_ERROR);
     
    154154$command .= " -path_base $outputRoot";
    155155$command .= " -dbname $dbname" if defined $dbname;
    156 
    157 # add in the elements from the selected stats above
    158 foreach my $entry (@$STATS) {
    159     my $value = $entry->{value};
    160     my $flag = $entry->{flag};
    161     $command .= " $flag $value";
    162 }
     156$command .= $stats->cmdflags();
    163157
    164158# Add the processed file to the database
  • trunk/ippScripts/scripts/detrend_norm_apply.pl

    r14009 r14115  
    6868   [   
    6969       #          PPSTATS KEYWORD         STATISTIC          CHIPTOOL FLAG
    70        { name => "ROBUST_MEDIAN",  type => "mean",  flag => "-bg" },
    71        { name => "ROBUST_MEDIAN",  type => "stdev", flag => "-bg_mean_stdev" },
    72        { name => "ROBUST_STDEV",   type => "rms",   flag => "-bg_stdev" },
     70       { name => "ROBUST_MEDIAN",  type => "mean",  flag => "-bg",            dtype => "float" },
     71       { name => "ROBUST_MEDIAN",  type => "stdev", flag => "-bg_mean_stdev", dtype => "float" },
     72       { name => "ROBUST_STDEV",   type => "rms",   flag => "-bg_stdev",      dtype => "float" },
    7373   ];
     74my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
    7475
    7576# Look for programs we need
     
    127128
    128129    # extract the stats from the metadata
    129     my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
    130130    unless ($stats->parse($metadata)) {
    131131        &my_die("Unable to find all values in statistics output.", $det_id, $iter, $class_id, $PS_EXIT_PROG_ERROR);
     
    141141$command .= " -path_base $outputRoot";
    142142$command .= " -dbname $dbname" if defined $dbname;
    143 
    144 # add in the elements from the selected stats above
    145 foreach my $entry (@$STATS) {
    146     my $value = $entry->{value};
    147     my $flag = $entry->{flag};
    148     $command .= " $flag $value";
    149 }
     143$command .= $stats->cmdflags();
    150144
    151145# Add the processed file to the database
  • trunk/ippScripts/scripts/detrend_norm_exp.pl

    r14048 r14115  
    7474    [   
    7575        #          KEYWORD                 STATISTIC          CHIPTOOL FLAG
    76         { name => "bg",             type => "mean",  flag => "-bg" },
    77         { name => "bg",             type => "stdev", flag => "-bg_mean_stdev" },
    78         { name => "bg_stdev",       type => "rms",   flag => "-bg_stdev" },
     76        { name => "bg",             type => "mean",  flag => "-bg",            dtype => "float" },
     77        { name => "bg",             type => "stdev", flag => "-bg_mean_stdev", dtype => "float" },
     78        { name => "bg_stdev",       type => "rms",   flag => "-bg_stdev",      dtype => "float" },
    7979        # { name => "bg_mean_stdev",  type => "rms",   flag => "-bg_mean_stdev" },
    8080        ];
     81my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
    8182
    8283# Look for programs we need
     
    111112
    112113    # parse the stats in the metadata
    113     my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
    114114    unless ($stats->parse($metadata)) {
    115115        &my_die("Unable to find all values in statistics output.\n", $det_id, $iter, $PS_EXIT_PROG_ERROR);
     
    154154$command .= " -path_base $outputRoot ";
    155155$command .= " -dbname $dbname" if defined $dbname;
    156 
    157 # add in the elements from the selected stats above
    158 foreach my $entry (@$STATS) {
    159     my $value = $entry->{value};
    160     my $flag = $entry->{flag};
    161     $command .= " $flag $value";
    162 }
     156$command .= $stats->cmdflags();
    163157
    164158# Add the processed file to the database
  • trunk/ippScripts/scripts/detrend_process_exp.pl

    r14048 r14115  
    7676   [   
    7777       #          KEYWORD                 STATISTIC          CHIPTOOL FLAG
    78        { name => "bg",             type => "mean",  flag => "-bg" },
    79        { name => "bg",             type => "stdev", flag => "-bg_mean_stdev" },
    80        { name => "bg_stdev",       type => "rms",   flag => "-bg_stdev" },
     78       { name => "bg",             type => "mean",  flag => "-bg",            dtype => "float" },
     79       { name => "bg",             type => "stdev", flag => "-bg_mean_stdev", dtype => "float" },
     80       { name => "bg_stdev",       type => "rms",   flag => "-bg_stdev",      dtype => "float" },
    8181       # { name => "bg_mean_stdev",  type => "rms",   flag => "-bg_mean_stdev" },
    8282   ];
     83my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
    8384
    8485# Look for programs we need
     
    113114
    114115    # parse the stats in the metadata
    115     my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
    116116    unless ($stats->parse($metadata)) {
    117117        &my_die("Unable to find all values in statistics output.\n", $det_id, $exp_id, $PS_EXIT_PROG_ERROR);
     
    163163$command .= " -recip $recipe1,$recipe2 -path_base $outputRoot";
    164164$command .= " -dbname $dbname" if defined $dbname;
    165 
    166 # add in the elements from the selected stats above
    167 foreach my $entry (@$STATS) {
    168     my $value = $entry->{value};
    169     my $flag = $entry->{flag};
    170     $command .= " $flag $value";
    171 }
     165$command .= $stats->cmdflags();
    172166
    173167# Add the processed file to the database
  • trunk/ippScripts/scripts/detrend_process_imfile.pl

    r14048 r14115  
    7070   [   
    7171       #          PPSTATS KEYWORD         STATISTIC          CHIPTOOL FLAG
    72        { name => "ROBUST_MEDIAN",  type => "mean",  flag => "-bg" },
    73        { name => "ROBUST_MEDIAN",  type => "stdev", flag => "-bg_mean_stdev" },
    74        { name => "ROBUST_STDEV",   type => "rms",   flag => "-bg_stdev" },
     72       { name => "ROBUST_MEDIAN",  type => "mean",  flag => "-bg",            dtype => "float" },
     73       { name => "ROBUST_MEDIAN",  type => "stdev", flag => "-bg_mean_stdev", dtype => "float" },
     74       { name => "ROBUST_STDEV",   type => "rms",   flag => "-bg_stdev",      dtype => "float" },
    7575   ];
     76my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
    7677
    7778# Look for programs we need
     
    127128
    128129    # extract the stats from the metadata
    129     my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
    130130    $stats->parse($metadata) or &my_die("Unable to find all values in statistics output.", $det_id, $exp_id, $class_id, $PS_EXIT_PROG_ERROR);
    131131}
     
    139139$command .= " -uri $outputImage -path_base $outputRoot";
    140140$command .= " -dbname $dbname" if defined $dbname;
    141 
    142 # add in the elements from the selected stats above
    143 foreach my $entry (@$STATS) {
    144     my $value = $entry->{value};
    145     my $flag = $entry->{flag};
    146     $command .= " $flag $value";
    147 }
     141$command .= $stats->cmdflags();
    148142
    149143# Add the processed file to the database
  • trunk/ippScripts/scripts/detrend_reject_exp.pl

    r14083 r14115  
    6363   [   
    6464       #          KEYWORD                 STATISTIC          CHIPTOOL FLAG
    65        { name => "bg",             type => "mean",  flag => "-bg" },
    66        { name => "bg_mean_stdev",  type => "stdev", flag => "-bg_mean_stdev" },
    67        { name => "bg_stdev",       type => "rms",   flag => "-bg_stdev" },
     65       { name => "bg",             type => "mean",  flag => "-bg",            dtype => "float" },
     66       { name => "bg_mean_stdev",  type => "stdev", flag => "-bg_mean_stdev", dtype => "float" },
     67       { name => "bg_stdev",       type => "rms",   flag => "-bg_stdev",      dtype => "float" },
    6868   ];
    69 
     69my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
     70
     71# these stats are used it the rejections but not passed to the database
     72# there is some duplication with the above, but the calculation time is minimal
    7073my $REJSTATS =
    7174   [   
    7275       #          KEYWORD                 STATISTIC          CHIPTOOL FLAG
    73        { name => "bg",             type => "mean",   flag => "ensMeanMean" },
    74        { name => "bg",             type => "stdev",  flag => "ensMeanStdev" },
    75        { name => "bg_mean_stdev",  type => "mean",   flag => "ensMeanStdevMean" },
    76        { name => "bg_mean_stdev",  type => "stdev",  flag => "ensMeanStdevStdev" },
    77        { name => "bg_stdev",       type => "mean",   flag => "ensStdevMean" },
    78        { name => "bg_stdev",       type => "stdev",  flag => "ensStdevStdev" },
     76       { name => "bg",             type => "mean",  flag => "ensMeanMean",       dtype => "float" },
     77       { name => "bg",             type => "stdev", flag => "ensMeanStdev",      dtype => "float" },
     78       { name => "bg_mean_stdev",  type => "mean",  flag => "ensMeanStdevMean",  dtype => "float" },
     79       { name => "bg_mean_stdev",  type => "stdev", flag => "ensMeanStdevStdev", dtype => "float" },
     80       { name => "bg_stdev",       type => "mean",  flag => "ensStdevMean",      dtype => "float" },
     81       { name => "bg_stdev",       type => "stdev", flag => "ensStdevStdev",     dtype => "float" },
    7982   ];
     83my $rejstats = PS::IPP::Metadata::Stats->new($REJSTATS); # Stats parser
    8084
    8185# Look for programs we need
     
    112116
    113117    # Parse the statistics on the residual image
    114     my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
    115118    $stats->parse($metadata) or &my_die("Unable to find all values in statistics output.", $det_id, $iter, $PS_EXIT_PROG_ERROR);
    116119
    117120    # Parse the statistics for rejections
    118     my $rejstats = PS::IPP::Metadata::Stats->new($REJSTATS); # Stats parser
    119121    $rejstats->parse($metadata) or &my_die("Unable to find all values in statistics output.", $det_id, $iter, $PS_EXIT_PROG_ERROR);
    120122}
    121123
    122124# we use the statistics of the ensemble to accept/reject exposurs
    123 my $ensMeanMean       = &STATS_value_for_flag ($REJSTATS, "ensMeanMean");     
    124 my $ensMeanStdev      = &STATS_value_for_flag ($REJSTATS, "ensMeanStdev");     
    125 my $ensMeanStdevMean  = &STATS_value_for_flag ($REJSTATS, "ensMeanStdevMean");
    126 my $ensMeanStdevStdev = &STATS_value_for_flag ($REJSTATS, "ensMeanStdevStdev");
    127 my $ensStdevMean      = &STATS_value_for_flag ($REJSTATS, "ensStdevMean");     
    128 my $ensStdevStdev     = &STATS_value_for_flag ($REJSTATS, "ensStdevStdev");   
     125my $ensMeanMean       = $rejstats->value_for_flag ("ensMeanMean");     
     126my $ensMeanStdev      = $rejstats->value_for_flag ("ensMeanStdev");     
     127my $ensMeanStdevMean  = $rejstats->value_for_flag ("ensMeanStdevMean");
     128my $ensMeanStdevStdev = $rejstats->value_for_flag ("ensMeanStdevStdev");
     129my $ensStdevMean      = $rejstats->value_for_flag ("ensStdevMean");     
     130my $ensStdevStdev     = $rejstats->value_for_flag ("ensStdevStdev");   
    129131
    130132$ipprc->define_camera($camera);
     
    283285$command .= " -dbname $dbname" if defined $dbname;
    284286$command .= " -again" unless $stop;
    285 
    286 # add in the elements from the selected stats above
    287 foreach my $entry (@$STATS) {
    288     my $value = $entry->{value};
    289     my $flag = $entry->{flag};
    290     $command .= " $flag $value";
    291 }
     287$command .= $stats->cmdflags();
    292288
    293289# Put results into the database
     
    347343}
    348344
    349 sub STATS_value_for_flag
    350 {
    351     my $STATS = shift;
    352     my $flag  = shift;
    353 
    354     foreach my $entry (@$STATS) {
    355         if ($flag eq $entry->{flag}) {
    356             return $entry->{value};
    357         }
    358     }
    359     return 'NAN';
    360 }
    361 
    362345__END__
  • trunk/ippScripts/scripts/detrend_reject_imfile.pl

    r14048 r14115  
    8989    [   
    9090        #          KEYWORD                 STATISTIC          CHIPTOOL FLAG
    91         { name => "bg",             type => "mean",  flag => "-bg" },
    92         { name => "bg_mean_stdev",  type => "stdev", flag => "-bg_mean_stdev" },
    93         { name => "bg_stdev",       type => "rms",   flag => "-bg_stdev" },
    94         { name => "bin_stdev",      type => "rms",   flag => "-bin_stdev" },
    95         { name => "fringe_0",       type => "mean",  flag => "-fringe_0" },
    96         { name => "fringe_1",       type => "rms",   flag => "-fringe_1" },
    97         { name => "fringe_0",       type => "stdev", flag => "-fringe_2" },
    98         { name => "user_1",         type => "mean",  flag => "-user_1" }, # fringe residual
    99         { name => "user_2",         type => "rms",   flag => "-user_2" }, # fringe residual
    100         { name => "user_3",         type => "stdev", flag => "-user_1" }, # fringe residual
     91        { name => "bg",             type => "mean",  flag => "-bg",            dtype => "float" },
     92        { name => "bg_mean_stdev",  type => "stdev", flag => "-bg_mean_stdev", dtype => "float" },
     93        { name => "bg_stdev",       type => "rms",   flag => "-bg_stdev",      dtype => "float" }, 
     94        { name => "bin_stdev",      type => "rms",   flag => "-bin_stdev",     dtype => "float" },
     95        { name => "fringe_0",       type => "mean",  flag => "-fringe_0",      dtype => "float" },
     96        { name => "fringe_1",       type => "rms",   flag => "-fringe_1",      dtype => "float" },
     97        { name => "fringe_0",       type => "stdev", flag => "-fringe_2",      dtype => "float" },
     98        { name => "user_1",         type => "mean",  flag => "-user_1",        dtype => "float" }, # fringe residual
     99        { name => "user_2",         type => "rms",   flag => "-user_2",        dtype => "float" }, # fringe residual
     100        { name => "user_1",         type => "stdev", flag => "-user_3",        dtype => "float" }, # fringe residual
    101101        ];
     102my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
    102103
    103104# Look for programs we need
     
    138139
    139140    # Parse the statistics on the residual image
    140     my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
    141141    $stats->parse($metadata) or &my_die("Unable to find all values in statistics output.", $det_id, $iter, $exp_id, $PS_EXIT_PROG_ERROR);
    142142}
     
    338338
    339339# basic ensemble stats
    340 my $mean               = &STATS_value_for_flag ($STATS, "-bg");
    341 my $meanStdev          = &STATS_value_for_flag ($STATS, "-bg_mean_stdev");
    342 my $stdev              = &STATS_value_for_flag ($STATS, "-bg_stdev");
    343 my $binStdev           = &STATS_value_for_flag ($STATS, "-bin_stdev");
    344 my $fringe_mean        = &STATS_value_for_flag ($STATS, "-fringe_0");
    345 my $fringe_err         = &STATS_value_for_flag ($STATS, "-fringe_1");
    346 my $fringe_mean_stdev  = &STATS_value_for_flag ($STATS, "-fringe_2");
    347 my $dfringe_mean       = &STATS_value_for_flag ($STATS, "-user_1");
    348 my $dfringe_err        = &STATS_value_for_flag ($STATS, "-user_2");
    349 my $dfringe_mean_stdev = &STATS_value_for_flag ($STATS, "-user_3");
     340my $mean               = $stats->value_for_flag ("-bg");
     341my $meanStdev          = $stats->value_for_flag ("-bg_mean_stdev");
     342my $stdev              = $stats->value_for_flag ("-bg_stdev");
     343my $binStdev           = $stats->value_for_flag ("-bin_stdev");
     344my $fringe_mean        = $stats->value_for_flag ("-fringe_0");
     345my $fringe_err         = $stats->value_for_flag ("-fringe_1");
     346my $fringe_mean_stdev  = $stats->value_for_flag ("-fringe_2");
     347my $dfringe_mean       = $stats->value_for_flag ("-user_1");
     348my $dfringe_err        = $stats->value_for_flag ("-user_2");
     349my $dfringe_mean_stdev = $stats->value_for_flag ("-user_3");
    350350
    351351# other stats (flux depends on bg and exp_time)
     
    469469$command .= ' -reject' if $reject;
    470470$command .= " -dbname $dbname" if defined $dbname;
    471 
    472 # add in the elements from the selected stats above
    473 foreach my $entry (@$STATS) {
    474     my $value = $entry->{value};
    475     my $flag = $entry->{flag};
    476     $command .= " $flag $value";
    477 }
     471$command .= $stats->cmdflags();
    478472
    479473unless ($no_update) {
     
    532526
    533527    return $value;
    534 }
    535 
    536 sub STATS_value_for_flag
    537 {
    538     my $STATS = shift;
    539     my $flag  = shift;
    540 
    541     foreach my $entry (@$STATS) {
    542         if ($flag eq $entry->{flag}) {
    543             return $entry->{value};
    544         }
    545     }
    546     return 'NAN';
    547528}
    548529
  • trunk/ippScripts/scripts/detrend_resid.pl

    r14048 r14115  
    8383   [   
    8484       #          PPSTATS KEYWORD         STATISTIC          CHIPTOOL FLAG
    85        { name => "ROBUST_MEDIAN",      type => "mean",  flag => "-bg" },
    86        { name => "ROBUST_MEDIAN",      type => "stdev", flag => "-bg_mean_stdev" },
    87        { name => "ROBUST_STDEV",       type => "rms",   flag => "-bg_stdev" },
    88        { name => "FRINGE_0",           type => "mean",  flag => "-fringe_0" },
    89        { name => "FRINGE_ERR_0",       type => "rms",   flag => "-fringe_1" },
    90        { name => "FRINGE_0",           type => "stdev", flag => "-fringe_2" },
    91        { name => "FRINGE_RESID_0",     type => "mean",  flag => "-user_1" },
    92        { name => "FRINGE_RESID_ERR_0", type => "rms",   flag => "-user_2" },
    93        { name => "FRINGE_RESID_0",     type => "stdev", flag => "-user_3" },
     85       { name => "ROBUST_MEDIAN",      type => "mean",  flag => "-bg",            dtype => "float" },
     86       { name => "ROBUST_MEDIAN",      type => "stdev", flag => "-bg_mean_stdev", dtype => "float" },
     87       { name => "ROBUST_STDEV",       type => "rms",   flag => "-bg_stdev",      dtype => "float" },
     88       { name => "FRINGE_0",           type => "mean",  flag => "-fringe_0",      dtype => "float" },
     89       { name => "FRINGE_ERR_0",       type => "rms",   flag => "-fringe_1",      dtype => "float" },
     90       { name => "FRINGE_0",           type => "stdev", flag => "-fringe_2",      dtype => "float" },
     91       { name => "FRINGE_RESID_0",     type => "mean",  flag => "-user_1",        dtype => "float" },
     92       { name => "FRINGE_RESID_ERR_0", type => "rms",   flag => "-user_2",        dtype => "float" },
     93       { name => "FRINGE_RESID_0",     type => "stdev", flag => "-user_3",        dtype => "float" },
    9494   ];
     95my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
     96
    9597my $BINNED_STATS =
    9698   [   
    9799       { name => "ROBUST_STDEV",   type => "rms",   flag => "-bin_stdev" },
    98100   ];
     101my $binnedStats = PS::IPP::Metadata::Stats->new($BINNED_STATS); # Stats parser
    99102
    100103# Flags to specify the particular detrend to use
     
    167170
    168171    # Parse the statistics on the residual image
    169     my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
    170172    $stats->parse($metadata) or &my_die("Unable to find all values in statistics output.", $det_id, $iter, $exp_id, $class_id, $PS_EXIT_PROG_ERROR);
    171173
     
    179181    }
    180182
     183    # Parse the output contents into a metadata
     184    my $binnedMetadata = $mdcParser->parse(join "", @$stdout_buf) or &my_die("Unable to parse metadata output", $det_id, $iter, $exp_id, $class_id, $PS_EXIT_PROG_ERROR);
     185
    181186    # parse the binned image statistics
    182     my $binnedMetadata = $mdcParser->parse(join "", @$stdout_buf) or &my_die("Unable to parse metadata output", $det_id, $iter, $exp_id, $class_id, $PS_EXIT_PROG_ERROR);
    183 
    184     my $binnedStats = PS::IPP::Metadata::Stats->new($BINNED_STATS); # Stats parser
    185187    $binnedStats->parse($binnedMetadata) or &my_die("Unable to find all values in statistics output.", $det_id, $iter, $exp_id, $class_id, $PS_EXIT_PROG_ERROR);
    186188}
     
    196198$command .= " -path_base $outputRoot";
    197199$command .= " -dbname $dbname" if defined $dbname;
    198 
    199 # add in the elements from the selected stats above
    200 foreach my $entry (@$STATS, @$BINNED_STATS) {
    201     my $value = $entry->{value};
    202     my $flag = $entry->{flag};
    203     $command .= " $flag $value";
    204 }
     200$command .= $stats->cmdflags();
     201$command .= $binnedStats->cmdflags();
    205202
    206203# Add the processed file to the database
  • trunk/ippScripts/scripts/detrend_stack.pl

    r14048 r14115  
    7373   [   
    7474       #          KEYWORD                 STATISTIC          CHIPTOOL FLAG
    75        { name => "bg",             type => "mean",  flag => "-bg" },
    76        { name => "bg",             type => "stdev", flag => "-bg_mean_stdev" },
    77        { name => "bg_stdev",       type => "rms",   flag => "-bg_stdev" },
     75       { name => "bg",             type => "mean",  flag => "-bg",             dtype => "float" },
     76       { name => "bg",             type => "stdev", flag => "-bg_mean_stdev",  dtype => "float" },
     77       { name => "bg_stdev",       type => "rms",   flag => "-bg_stdev",       dtype => "float" },
    7878       # { name => "bg_mean_stdev",  type => "rms",   flag => "-bg_mean_stdev" },
    7979   ];
     80my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
    8081
    8182# Look for programs we need
     
    147148        &my_die("Unable to parse metadata config doc", $det_id, $iter, $class_id, $PS_EXIT_SYS_ERROR);
    148149
    149     my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
    150150    $stats->parse($metadata)  or
    151151        &my_die("Unable to find all values in statistics output.", $det_id, $iter, $class_id, $PS_EXIT_SYS_ERROR);
     
    159159$command .= " -recip $recipe";
    160160$command .= " -dbname $dbname" if defined $dbname;
    161 
    162 # add in the elements from the selected stats above
    163 foreach my $entry (@$STATS) {
    164     my $value = $entry->{value};
    165     my $flag = $entry->{flag};
    166     $command .= " $flag $value";
    167 }
     161$command .= $stats->cmdflags();
    168162
    169163# Add the resultant into the database
  • trunk/ippScripts/scripts/register_exp.pl

    r14080 r14115  
    5959   [   
    6060       #          PPSTATS KEYWORD         STATISTIC          CHIPTOOL FLAG
    61        { name => "exp_name",       type => "constant",   flag => "-exp_name" }, # File level
    62        { name => "telescope",      type => "constant",   flag => "-telescope" }, # File level
    63        { name => "camera",         type => "constant",   flag => "-inst" }, # File level
    64        { name => "filelevel",      type => "constant",   flag => "-filelevel" }, # File level
    65        { name => "object",         type => "constant",   flag => "-object" },
    66        { name => "exp_type",       type => "constant",   flag => "-exp_type" }, # File level
    67        { name => "filter",         type => "constant",   flag => "-filter" }, # File level
    68        { name => "dateobs",        type => "constant",   flag => "-dateobs" }, # File level
    69        { name => "ccd_temp",       type => "mean",       flag => "-ccd_temp" }, # CCD temperature
    70        { name => "exp_time",       type => "mean",       flag => "-exp_time" }, # Exposure time
    71        { name => "sat_pixel_frac", type => "mean",       flag => "-sat_pixel_frac" }, # Fraction of saturated pixels
    72        { name => "airmass",        type => "mean",       flag => "-airmass" }, # Airmass
    73        { name => "ra",             type => "mean",       flag => "-ra" }, # Right ascension
    74        { name => "decl",           type => "mean",       flag => "-decl" }, # Declination
    75        { name => "posang",         type => "mean",       flag => "-posang" }, # Position angle
    76        { name => "alt",            type => "mean",       flag => "-alt" }, # Altitude
    77        { name => "az",             type => "mean",       flag => "-az" }, # Azimuth
    78        { name => "bg",             type => "mean",       flag => "-bg" }, # Azimuth
    79        { name => "bg",             type => "stdev",      flag => "-bg_mean_stdev" }, # Azimuth
    80        { name => "bg_stdev",       type => "rms",        flag => "-bg_stdev" }, # Azimuth
     61       { name => "exp_name",       type => "constant",   flag => "-exp_name",       dtype => "string" }, # File level
     62       { name => "telescope",      type => "constant",   flag => "-telescope",      dtype => "string" }, # File level
     63       { name => "camera",         type => "constant",   flag => "-inst",           dtype => "string" }, # File level
     64       { name => "filelevel",      type => "constant",   flag => "-filelevel",      dtype => "string" }, # File level
     65       { name => "object",         type => "constant",   flag => "-object",         dtype => "string" },
     66       { name => "exp_type",       type => "constant",   flag => "-exp_type",       dtype => "string" }, # File level
     67       { name => "filter",         type => "constant",   flag => "-filter",         dtype => "string" }, # File level
     68       { name => "dateobs",        type => "constant",   flag => "-dateobs",        dtype => "string" }, # File level
     69       { name => "ccd_temp",       type => "mean",       flag => "-ccd_temp",       dtype => "float" }, # CCD temperature
     70       { name => "exp_time",       type => "mean",       flag => "-exp_time",       dtype => "float" }, # Exposure time
     71       { name => "sat_pixel_frac", type => "mean",       flag => "-sat_pixel_frac", dtype => "float" }, # Fraction of saturated pixels
     72       { name => "airmass",        type => "mean",       flag => "-airmass",        dtype => "float" }, # Airmass
     73       { name => "ra",             type => "mean",       flag => "-ra",             dtype => "float" }, # Right ascension
     74       { name => "decl",           type => "mean",       flag => "-decl",           dtype => "float" }, # Declination
     75       { name => "posang",         type => "mean",       flag => "-posang",         dtype => "float" }, # Position angle
     76       { name => "alt",            type => "mean",       flag => "-alt",            dtype => "float" }, # Altitude
     77       { name => "az",             type => "mean",       flag => "-az",             dtype => "float" }, # Azimuth
     78       { name => "bg",             type => "mean",       flag => "-bg",             dtype => "float"  }, # background
     79       { name => "bg",             type => "stdev",      flag => "-bg_mean_stdev",  dtype => "float" }, # Azimuth
     80       { name => "bg_stdev",       type => "rms",        flag => "-bg_stdev",       dtype => "float" }, # Azimuth
    8181       ];
     82my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
    8283
    8384# Look for commands we need
     
    117118
    118119    # extract the stats from the metadata
    119     my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
    120120    unless ($stats->parse($metadata)) {
    121121        &my_die ("Unable to find all values", $exp_id, $PS_EXIT_CONFIG_ERROR);
     
    124124
    125125# we require at a minimum: -telescope, -inst, -filelevel, -class_id, -exp_type
    126 if (uc(&STATS_value_for_flag ($STATS, "-telescope")) eq "NAN") { &my_die ("telescope not found", $exp_id, $PS_EXIT_CONFIG_ERROR); }
    127 if (uc(&STATS_value_for_flag ($STATS, "-inst"))      eq "NAN") { &my_die ("inst      not found", $exp_id, $PS_EXIT_CONFIG_ERROR); }
    128 if (uc(&STATS_value_for_flag ($STATS, "-filelevel")) eq "NAN") { &my_die ("filelevel not found", $exp_id, $PS_EXIT_CONFIG_ERROR); }
    129 if (uc(&STATS_value_for_flag ($STATS, "-exp_type"))  eq "NAN") { &my_die ("exp_type  not found", $exp_id, $PS_EXIT_CONFIG_ERROR); }
    130 if (uc(&STATS_value_for_flag ($STATS, "-exp_name"))  eq "NAN") { &my_die ("exp_name  not found", $exp_id, $PS_EXIT_CONFIG_ERROR); }
     126if (uc($stats->value_for_flag ("-telescope")) eq "NULL") { &my_die ("telescope not found", $exp_id, $PS_EXIT_CONFIG_ERROR); }
     127if (uc($stats->value_for_flag ("-inst"))      eq "NULL") { &my_die ("inst      not found", $exp_id, $PS_EXIT_CONFIG_ERROR); }
     128if (uc($stats->value_for_flag ("-filelevel")) eq "NULL") { &my_die ("filelevel not found", $exp_id, $PS_EXIT_CONFIG_ERROR); }
     129if (uc($stats->value_for_flag ("-exp_type"))  eq "NULL") { &my_die ("exp_type  not found", $exp_id, $PS_EXIT_CONFIG_ERROR); }
     130if (uc($stats->value_for_flag ("-exp_name"))  eq "NULL") { &my_die ("exp_name  not found", $exp_id, $PS_EXIT_CONFIG_ERROR); }
    131131
    132132my $command = "$regtool -addprocessedexp";
     
    134134$command .= " -exp_tag $exp_tag";
    135135$command .= " -dbname $dbname" if defined $dbname;
     136$command .= $stats->cmdflags();
    136137
    137 # add in the elements from the selected stats above
    138 foreach my $entry (@$STATS) {
    139     my $value = $entry->{value};
    140     my $flag = $entry->{flag};
    141     $command .= " $flag '$value'";
    142 }
    143 
    144 my $exp_type = &STATS_value_for_flag ($STATS, "-exp_type");
     138my $exp_type = $stats->value_for_flag ("-exp_type");
    145139
    146140# Add the detrend flag, if needed
     
    196190}
    197191
    198 sub STATS_value_for_flag
    199 {
    200     my $STATS = shift;
    201     my $flag  = shift;
    202 
    203     foreach my $entry (@$STATS) {
    204         if ($flag eq $entry->{flag}) {
    205             return $entry->{value};
    206         }
    207     }
    208     return 'NAN';
    209 }
    210 
    211192END {
    212193    my $exit = $?;
  • trunk/ippScripts/scripts/register_imfile.pl

    r14080 r14115  
    5252pod2usage( -msg => "Unknown option: @ARGV", -exitval => 2 ) if @ARGV;
    5353pod2usage( -msg => "Required options: --exp_id --tmp_class_id --tmp_exp_name --uri",
    54            -exitval => 3) unless
     54           -exitval => 3) unless
    5555    defined $exp_id and
    5656    defined $tmp_class_id and
     
    6464   [   
    6565       #          PPSTATS KEYWORD         STATISTIC          CHIPTOOL FLAG
    66        { name => "FILE.LEVEL",     type => "constant", flag => "-filelevel" }, # File level
    67        { name => "CLASS.ID",       type => "constant", flag => "-class_id" }, # Real Class ID
    68        { name => "FPA.OBJECT",     type => "constant", flag => "-object" },    # Object
    69        { name => "FPA.OBSTYPE",    type => "constant", flag => "-exp_type" }, # Exposure type
    70        { name => "FPA.FILTER",     type => "constant", flag => "-filter" },    # Filter used
    71        { name => "FPA.AIRMASS",    type => "constant", flag => "-airmass" },  # Airmass
    72        { name => "FPA.RA",         type => "constant", flag => "-ra" },        # Right ascension
    73        { name => "FPA.DEC",        type => "constant", flag => "-decl" },      # Declination
    74        { name => "FPA.ALT",        type => "constant", flag => "-alt" },      # Altitude
    75        { name => "FPA.AZ",         type => "constant", flag => "-az" },        # Azimuth
    76        { name => "FPA.POSANGLE",   type => "constant", flag => "-posang" },    # Position angle
    77        { name => "FPA.TIME",       type => "constant", flag => "-dateobs" },  # Date of observation (UTC)
    78        { name => "FPA.TELESCOPE",  type => "constant", flag => "-telescope" }, # Telescope
    79        { name => "FPA.INSTRUMENT", type => "constant", flag => "-inst" },      # Instrument
    80        { name => "CHIP.TEMP",      type => "mean",     flag => "-ccd_temp" }, # CCD temperature
    81        { name => "CELL.EXPOSURE",  type => "mean",     flag => "-exp_time" }, # Exposure time
    82        { name => "SAT_PIXEL_FRAC", type => "mean",     flag => "-sat_pixel_frac" }, # fraction of saturated pixels
    83        { name => "ROBUST_MEDIAN",  type => "mean",     flag => "-bg" },
    84        { name => "ROBUST_MEDIAN",  type => "stdev",    flag => "-bg_mean_stdev" },
    85        { name => "ROBUST_STDEV",   type => "rms",      flag => "-bg_stdev" },
     66       { name => "FILE.LEVEL",     type => "constant", flag => "-filelevel",      dtype => "string" }, # File level
     67       { name => "CLASS.ID",       type => "constant", flag => "-class_id",       dtype => "string" }, # Real Class ID
     68       { name => "FPA.OBJECT",     type => "constant", flag => "-object",         dtype => "string" }, # Object
     69       { name => "FPA.OBSTYPE",    type => "constant", flag => "-exp_type",       dtype => "string" }, # Exposure type
     70       { name => "FPA.FILTER",     type => "constant", flag => "-filter",         dtype => "string" }, # Filter used
     71       { name => "FPA.AIRMASS",    type => "constant", flag => "-airmass",        dtype => "float"  }, # Airmass
     72       { name => "FPA.RA",         type => "constant", flag => "-ra",             dtype => "float"  }, # Right ascension
     73       { name => "FPA.DEC",        type => "constant", flag => "-decl",           dtype => "float"  }, # Declination
     74       { name => "FPA.ALT",        type => "constant", flag => "-alt",            dtype => "float"  }, # Altitude
     75       { name => "FPA.AZ",         type => "constant", flag => "-az",             dtype => "float"  }, # Azimuth
     76       { name => "FPA.POSANGLE",   type => "constant", flag => "-posang",         dtype => "float"  }, # Position angle
     77       { name => "FPA.TIME",       type => "constant", flag => "-dateobs",        dtype => "string" }, # Date of observation (UTC)
     78       { name => "FPA.TELESCOPE",  type => "constant", flag => "-telescope",      dtype => "string" }, # Telescope
     79       { name => "FPA.INSTRUMENT", type => "constant", flag => "-inst",           dtype => "string" }, # Instrument
     80       { name => "CHIP.TEMP",      type => "mean",     flag => "-ccd_temp",       dtype => "float" }, # CCD temperature
     81       { name => "CELL.EXPOSURE",  type => "mean",     flag => "-exp_time",       dtype => "float" }, # Exposure time
     82       { name => "SAT_PIXEL_FRAC", type => "mean",     flag => "-sat_pixel_frac", dtype => "float" }, # fraction of saturated pixels
     83       { name => "ROBUST_MEDIAN",  type => "mean",     flag => "-bg",             dtype => "float" },
     84       { name => "ROBUST_MEDIAN",  type => "stdev",    flag => "-bg_mean_stdev",  dtype => "float" },
     85       { name => "ROBUST_STDEV",   type => "rms",      flag => "-bg_stdev",       dtype => "float" },
    8686   ];
     87my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
    8788
    8889# Look for programs we need
     
    112113        cache_run(command => $command, verbose => 1);
    113114    unless ($success) {
    114         $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
     115        $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
    115116        &my_die ("Unable to perform ppStats on exposure id $exp_id: $error_code", $exp_id, $tmp_exp_name, $tmp_class_id, $error_code);
    116117    }
     
    124125
    125126    # extract the stats from the metadata
    126     my $stats = PS::IPP::Metadata::Stats->new($STATS); # Stats parser
    127127    unless ($stats->parse($metadata)) {
    128128        &my_die ("Unable to find all values", $exp_id, $tmp_exp_name, $tmp_class_id, $PS_EXIT_CONFIG_ERROR);
     
    131131
    132132# we require at a minimum: -telescope, -inst, -filelevel, -class_id, -exp_type
    133 if (uc(&STATS_value_for_flag ($STATS, "-telescope")) eq "NAN") { &my_die ("telescope not found", $exp_id, $tmp_exp_name, $tmp_class_id, $PS_EXIT_CONFIG_ERROR); }
    134 if (uc(&STATS_value_for_flag ($STATS, "-inst"))      eq "NAN") { &my_die ("inst      not found", $exp_id, $tmp_exp_name, $tmp_class_id, $PS_EXIT_CONFIG_ERROR); }
    135 if (uc(&STATS_value_for_flag ($STATS, "-filelevel")) eq "NAN") { &my_die ("filelevel not found", $exp_id, $tmp_exp_name, $tmp_class_id, $PS_EXIT_CONFIG_ERROR); }
    136 if (uc(&STATS_value_for_flag ($STATS, "-class_id"))  eq "NAN") { &my_die ("class_id  not found", $exp_id, $tmp_exp_name, $tmp_class_id, $PS_EXIT_CONFIG_ERROR); }
    137 if (uc(&STATS_value_for_flag ($STATS, "-exp_type"))  eq "NAN") { &my_die ("exp_type  not found", $exp_id, $tmp_exp_name, $tmp_class_id, $PS_EXIT_CONFIG_ERROR); }
     133if (uc($stats->value_for_flag ("-telescope")) eq "NULL") { &my_die ("telescope not found", $exp_id, $tmp_exp_name, $tmp_class_id, $PS_EXIT_CONFIG_ERROR); }
     134if (uc($stats->value_for_flag ("-inst"))      eq "NULL") { &my_die ("inst      not found", $exp_id, $tmp_exp_name, $tmp_class_id, $PS_EXIT_CONFIG_ERROR); }
     135if (uc($stats->value_for_flag ("-filelevel")) eq "NULL") { &my_die ("filelevel not found", $exp_id, $tmp_exp_name, $tmp_class_id, $PS_EXIT_CONFIG_ERROR); }
     136if (uc($stats->value_for_flag ("-class_id"))  eq "NULL") { &my_die ("class_id  not found", $exp_id, $tmp_exp_name, $tmp_class_id, $PS_EXIT_CONFIG_ERROR); }
     137if (uc($stats->value_for_flag ("-exp_type"))  eq "NULL") { &my_die ("exp_type  not found", $exp_id, $tmp_exp_name, $tmp_class_id, $PS_EXIT_CONFIG_ERROR); }
    138138
    139139my $command = "$regtool -addprocessedimfile";
     
    142142$command .= " -tmp_class_id $tmp_class_id"; # the original class_id supplied by the user, replace by ppStats CLASS.ID
    143143$command .= " -dbname $dbname" if defined $dbname;
    144 
    145 # add in the elements from the selected stats above
    146 foreach my $entry (@$STATS) {
    147     my $value = $entry->{value};
    148     my $flag = $entry->{flag};
    149     $command .= " $flag '$value'";
    150 }
     144$command .= $stats->cmdflags();
    151145
    152146# Push the results into the database
     
    155149        run(command => $command, verbose => 1);
    156150    unless ($success) {
    157         $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
     151        $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
    158152        warn ("Unable to perform regtool -addprocessedimfile: $error_code");
    159153        exit($error_code);
     
    189183    carp($msg);
    190184    if ($exp_id && $tmp_class_id and not $no_update) {
    191         my $command = "$regtool -addprocessedimfile";
    192         $command .= " -exp_id $exp_id";
    193         $command .= " -exp_name $exp_name";
    194         $command .= " -tmp_class_id $tmp_class_id";
    195         $command .= " -telescope UNKNOWN";
    196         $command .= " -inst UNKNOWN";
    197         $command .= " -class_id $tmp_class_id";
    198         $command .= " -code $exit_code";
    199         $command .= " -dbname $dbname" if defined $dbname;
     185        my $command = "$regtool -addprocessedimfile";
     186        $command .= " -exp_id $exp_id";
     187        $command .= " -exp_name $exp_name";
     188        $command .= " -tmp_class_id $tmp_class_id";
     189        $command .= " -telescope UNKNOWN";
     190        $command .= " -inst UNKNOWN";
     191        $command .= " -class_id $tmp_class_id";
     192        $command .= " -code $exit_code";
     193        $command .= " -dbname $dbname" if defined $dbname;
    200194        system ($command);
    201195    }
    202196    exit $exit_code;
    203 }
    204 
    205 sub STATS_value_for_flag
    206 {
    207     my $STATS = shift;
    208     my $flag  = shift;
    209 
    210     foreach my $entry (@$STATS) {
    211         if ($flag eq $entry->{flag}) {
    212             return $entry->{value};
    213         }
    214     }
    215     return 'NAN';
    216197}
    217198
Note: See TracChangeset for help on using the changeset viewer.