IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 28043 for trunk


Ignore:
Timestamp:
May 19, 2010, 5:13:52 PM (16 years ago)
Author:
watersc1
Message:

Merging czw_branch (maskstats and software versions) back into the trunk

Location:
trunk
Files:
84 edited
10 copied

Legend:

Unmodified
Added
Removed

  • trunk

  • trunk/Ohana/src/relastro

    • Property svn:mergeinfo deleted

  • trunk/PS-IPP-PStamp/lib/PS/IPP/PStamp/Job.pm

    r28015 r28043  
    742742#        print "Time to run dvoImagesAtCoords: $dtime_dvo\n";
    743743        unless ($success) {
     744
    744745            my $result_code = $error_code >> 8;
    745746            if ($result_code == $PSTAMP_NO_OVERLAP) {

  • trunk/dbconfig/cam.md

    r25835 r28043  
    1414    end_stage   STR         64      # Key
    1515    magicked    S64         0
     16    software_ver    STR         16
     17    maskfrac_npix S32       0
     18    maskfrac_static F32     0.0
     19    maskfrac_dynamic F32    0.0
     20    maskfrac_magic  F32     0.0
     21    maskfrac_advisory F32   0.0
    1622    note        STR         255
    1723END
    … …  
    9197    path_base      STR      255
    9298    fault          S16      0       # Key NOT NULL
     99    software_ver    STR         16
     100    maskfrac_npix S32       0
     101    maskfrac_static F32     0.0
     102    maskfrac_dynamic F32    0.0
     103    maskfrac_magic  F32     0.0
     104    maskfrac_advisory F32   0.0
    93105    quality        S16      0
    94106END

  • trunk/dbconfig/changes.txt

    r27874 r28043  
    16051605ALTER TABLE distTarget ADD KEY(stage), ADD KEY(dist_group), ADD KEY(filter), ADD KEY(state);
    16061606
     1607-- Version 1.1.67
     1608
    16071609CREATE TABLE Label (
    16081610    label       VARCHAR(64),
    … …  
    16161618
    16171619ALTER TABLE pstampRequest ADD COLUMN outdir VARCHAR(64) after uri;
     1620
     1621-- Version 1.1.68
     1622ALTER TABLE chipRun ADD COLUMN software_ver VARCHAR(16) after magicked;
     1623ALTER TABLE chipRun ADD COLUMN maskfrac_npix INT after software_ver;
     1624ALTER TABLE chipRun ADD COLUMN maskfrac_static FLOAT after maskfrac_npix;
     1625ALTER TABLE chipRun ADD COLUMN maskfrac_dynamic FLOAT after maskfrac_static;
     1626ALTER TABLE chipRun ADD COLUMN maskfrac_magic FLOAT after maskfrac_dynamic;
     1627ALTER TABLE chipRun ADD COLUMN maskfrac_advisory FLOAT after maskfrac_magic;
     1628
     1629ALTER TABLE chipProcessedImfile ADD COLUMN software_ver VARCHAR(16) after magicked;
     1630ALTER TABLE chipProcessedImfile ADD COLUMN maskfrac_npix INT after software_ver;
     1631ALTER TABLE chipProcessedImfile ADD COLUMN maskfrac_static FLOAT after maskfrac_npix;
     1632ALTER TABLE chipProcessedImfile ADD COLUMN maskfrac_dynamic FLOAT after maskfrac_static;
     1633ALTER TABLE chipProcessedImfile ADD COLUMN maskfrac_magic FLOAT after maskfrac_dynamic;
     1634ALTER TABLE chipProcessedImfile ADD COLUMN maskfrac_advisory FLOAT after maskfrac_magic;
     1635
     1636ALTER TABLE camRun ADD COLUMN software_ver VARCHAR(16) after magicked;
     1637ALTER TABLE camRun ADD COLUMN maskfrac_npix INT after software_ver;
     1638ALTER TABLE camRun ADD COLUMN maskfrac_static FLOAT after maskfrac_npix;
     1639ALTER TABLE camRun ADD COLUMN maskfrac_dynamic FLOAT after maskfrac_static;
     1640ALTER TABLE camRun ADD COLUMN maskfrac_magic FLOAT after maskfrac_dynamic;
     1641ALTER TABLE camRun ADD COLUMN maskfrac_advisory FLOAT after maskfrac_magic;
     1642
     1643ALTER TABLE camProcessedExp ADD COLUMN software_ver VARCHAR(16) after fault;
     1644ALTER TABLE camProcessedExp ADD COLUMN maskfrac_npix INT after software_ver;
     1645ALTER TABLE camProcessedExp ADD COLUMN maskfrac_static FLOAT after maskfrac_npix;
     1646ALTER TABLE camProcessedExp ADD COLUMN maskfrac_dynamic FLOAT after maskfrac_static;
     1647ALTER TABLE camProcessedExp ADD COLUMN maskfrac_magic FLOAT after maskfrac_dynamic;
     1648ALTER TABLE camProcessedExp ADD COLUMN maskfrac_advisory FLOAT after maskfrac_magic;
     1649
     1650ALTER TABLE warpRun ADD COLUMN software_ver VARCHAR(16) after magicked;
     1651ALTER TABLE warpRun ADD COLUMN maskfrac_npix INT after software_ver;
     1652ALTER TABLE warpRun ADD COLUMN maskfrac_static FLOAT after maskfrac_npix;
     1653ALTER TABLE warpRun ADD COLUMN maskfrac_dynamic FLOAT after maskfrac_static;
     1654ALTER TABLE warpRun ADD COLUMN maskfrac_magic FLOAT after maskfrac_dynamic;
     1655ALTER TABLE warpRun ADD COLUMN maskfrac_advisory FLOAT after maskfrac_magic;
     1656
     1657ALTER TABLE warpSkyfile ADD COLUMN software_ver VARCHAR(16) after magicked;
     1658ALTER TABLE warpSkyfile ADD COLUMN maskfrac_npix INT after software_ver;
     1659ALTER TABLE warpSkyfile ADD COLUMN maskfrac_static FLOAT after maskfrac_npix;
     1660ALTER TABLE warpSkyfile ADD COLUMN maskfrac_dynamic FLOAT after maskfrac_static;
     1661ALTER TABLE warpSkyfile ADD COLUMN maskfrac_magic FLOAT after maskfrac_dynamic;
     1662ALTER TABLE warpSkyfile ADD COLUMN maskfrac_advisory FLOAT after maskfrac_magic;
     1663
     1664ALTER TABLE stackRun ADD COLUMN software_ver VARCHAR(16) after filter;
     1665
     1666ALTER TABLE stackSumSkyfile ADD COLUMN software_ver VARCHAR(16) after fault;
     1667
     1668ALTER TABLE diffRun ADD COLUMN software_ver VARCHAR(16) after magicked;
     1669ALTER TABLE diffRun ADD COLUMN maskfrac_npix INT after software_ver;
     1670ALTER TABLE diffRun ADD COLUMN maskfrac_static FLOAT after maskfrac_npix;
     1671ALTER TABLE diffRun ADD COLUMN maskfrac_dynamic FLOAT after maskfrac_static;
     1672ALTER TABLE diffRun ADD COLUMN maskfrac_magic FLOAT after maskfrac_dynamic;
     1673ALTER TABLE diffRun ADD COLUMN maskfrac_advisory FLOAT after maskfrac_magic;
     1674
     1675ALTER TABLE diffSkyfile ADD COLUMN software_ver VARCHAR(16) after magicked;
     1676ALTER TABLE diffSkyfile ADD COLUMN maskfrac_npix INT after software_ver;
     1677ALTER TABLE diffSkyfile ADD COLUMN maskfrac_static FLOAT after maskfrac_npix;
     1678ALTER TABLE diffSkyfile ADD COLUMN maskfrac_dynamic FLOAT after maskfrac_static;
     1679ALTER TABLE diffSkyfile ADD COLUMN maskfrac_magic FLOAT after maskfrac_dynamic;
     1680ALTER TABLE diffSkyfile ADD COLUMN maskfrac_advisory FLOAT after maskfrac_magic;
     1681

  • trunk/dbconfig/chip.md

    r25835 r28043  
    1414    end_stage   STR         64      # Key
    1515    magicked    S64         0
     16    software_ver    STR         16
     17    maskfrac_npix S32       0
     18    maskfrac_static F32     0.0
     19    maskfrac_dynamic F32    0.0
     20    maskfrac_magic  F32     0.0
     21    maskfrac_advisory F32   0.0
    1622    note        STR         255
    1723END
    … …  
    9399    quality         S16     0
    94100    magicked        S64     0
     101    software_ver    STR         16
     102    maskfrac_npix S32       0
     103    maskfrac_static F32     0.0
     104    maskfrac_dynamic F32    0.0
     105    maskfrac_magic  F32     0.0
     106    maskfrac_advisory F32   0.0
    95107END
    96108

  • trunk/dbconfig/diff.md

    r27020 r28043  
    1515    exposure    BOOL        f
    1616    magicked    S64         0
     17    software_ver    STR         16
     18    maskfrac_npix S32       0
     19    maskfrac_static F32     0.0
     20    maskfrac_dynamic F32    0.0
     21    maskfrac_magic  F32     0.0
     22    maskfrac_advisory F32   0.0
    1723    diff_mode   S16         0
    1824    note        STR         255
    … …  
    6268    quality      S16        0
    6369    magicked    S64         0
     70    software_ver     STR        16
     71    maskfrac_npix S32       0
     72    maskfrac_static F32     0.0
     73    maskfrac_dynamic F32    0.0
     74    maskfrac_magic  F32     0.0
     75    maskfrac_advisory F32   0.0
    6476END

  • trunk/dbconfig/stack.md

    r25835 r28043  
    1414    tess_id     STR         64      # Key
    1515    filter      STR         64
     16    software_ver    STR         16
    1617    note        STR         255
    1718END
    … …  
    4950    good_frac          F32    0.0     # Key
    5051    fault              S16    0       # Key
     52    software_ver    STR         16
    5153    quality            S16    0
    5254END

  • trunk/dbconfig/warp.md

    r25835 r28043  
    2525    registered  TAI         NULL
    2626    magicked    S64         0
     27    software_ver    STR         16
     28    maskfrac_npix S32       0
     29    maskfrac_static F32     0.0
     30    maskfrac_dynamic F32    0.0
     31    maskfrac_magic  F32     0.0
     32    maskfrac_advisory F32   0.0
    2733    note        STR         255
    2834END
    … …  
    6268    quality        S16      0
    6369    magicked       S64      0
     70    software_ver    STR         16
     71    maskfrac_npix S32       0
     72    maskfrac_static F32     0.0
     73    maskfrac_dynamic F32    0.0
     74    maskfrac_magic  F32     0.0
     75    maskfrac_advisory F32   0.0
    6476END
    6577

  • trunk/ippMonitor/def/detProcessedExp_failure.d

    r19726 r28043  
    1313ARGS  ARG1 basename=$detProcessedExp.path_base
    1414
    15 OP    OP1  $detProcessedExp.bg / $detProcessedExp.bg_stdev
     15OP    OP1  $detProcessedExp.bg_stdev > 0.0 ? $detProcessedExp.bg / $detProcessedExp.bg_stdev : NAN
    1616
    1717#     field                    size     format  name       show          link to                 extras

  • trunk/ippMonitor/def/rawImfile_failed.d

    r24867 r28043  
    11TABLE rawImfile
    22TITLE Failed Raw Image Files
    3 FILE  rawImfile.php
     3FILE  rawImfile_failed.php
    44MENU  ipp.load.dat
    55

  • trunk/ippMonitor/raw/getimage.php

    r26888 r28043  
    88// global $BINDIR;
    99// global $SITE;
     10// global $PSCONFDIR
     11// global $PSCONFIG
    1012
    1113### these need to be set to the correct locations!!
    … …  
    1820}
    1921
     22
     23putenv("PSCONFDIR=$PSCONFDIR");
     24putenv("PSCONFIG=$PSCONFIG");
    2025putenv("PERL5LIB=$PERLLIB:");
    2126$PATH = getenv("PATH");

  • trunk/ippMonitor/raw/ipp.php

    r27054 r28043  
    722722    global $BINDIR;
    723723    global $SITE;
    724 
     724    global $PSCONFDIR;
     725    global $PSCONFIG;
     726
     727    putenv("PSCONFDIR=$PSCONFDIR");
     728    putenv("PSCONFIG=$PSCONFIG");
    725729    putenv("PERL5LIB=$PERLLIB:");
    726730    $PATH = getenv("PATH");

  • trunk/ippMonitor/raw/site.php.in

    r27113 r28043  
    1111$SITE    = "@SITE@";
    1212
     13$PSCONFDIR = "@PSCONFDIR@";
     14$PSCONFIG  = "@PSCONFIG@";
     15
    1316$DBI     = "@DBI@";
    1417?>

  • trunk/ippScripts/scripts/camera_exp.pl

    r27718 r28043  
    280280        unless ($success) {
    281281            $error_code = (($error_code >> 8) or $PS_EXIT_PROG_ERROR);
     282            print STDERR (join "\n", @$stderr_buf);
    282283            &my_die("Unable to perform psastro: $error_code", $cam_id, $error_code);
    283284        }

  • trunk/ippScripts/scripts/diff_skycell.pl

    r27918 r28043  
    292292    $command .= " -recipe PPSUB $recipe_ppSub";
    293293    $command .= " -recipe PSPHOT $recipe_psphot";
    294     $command .= " -recipe PPSTATS WARPSTATS";
     294    $command .= " -recipe PPSTATS DIFFSTATS";
    295295    $command .= " -F PSPHOT.PSF.SAVE PSPHOT.PSF.SKY.SAVE";
    296296    $command .= " -F PSPHOT.OUTPUT PSPHOT.OUT.CMF.MEF";

  • trunk/ippScripts/scripts/stack_skycell.pl

    r27718 r28043  
    232232    $command .= " -recipe PPSUB $recipe_ppSub";
    233233    $command .= " -recipe PSPHOT $recipe_psphot";
    234     $command .= " -recipe PPSTATS WARPSTATS" if $do_stats;;
     234    $command .= " -recipe PPSTATS STACKSTATS" if $do_stats;;
    235235    $command .= " -F PSPHOT.PSF.SAVE PSPHOT.PSF.SKY.SAVE";
    236236    $command .= " -F PSPHOT.OUTPUT PSPHOT.OUT.CMF.MEF";

  • trunk/ippToPsps/src/ippToPspsVersion.c

    r27345 r28043  
    5858    psString source = ippToPsps_Source();   // Software source
    5959
     60    psMetadataAddStr(header, PS_LIST_TAIL, "IPP2PS_V", PS_META_REPLACE, NULL, IPPTOPSPS_VERSION);
     61   
    6062    psStringPrepend(&version, "ippToPsps version: ");
    6163    psStringPrepend(&source, "ippToPsps source: ");

  • trunk/ippTools/share/Makefile.am

    r27982 r28043  
    2828     chiptool_change_imfile_data_state.sql \
    2929     chiptool_completely_processed_exp.sql \
     30     chiptool_coalesce_run.sql \
    3031     chiptool_definecopy.sql \
    3132     chiptool_donecleanup.sql \
    … …  
    9798     difftool_change_run_state.sql \
    9899     difftool_completed_runs.sql \
     100     difftool_coalesce_run.sql \
    99101     difftool_definewarpstack_part1.sql \
    100102     difftool_definewarpstack_part2.sql \
    … …  
    298300     warptool_finished_run_select.sql \
    299301     warptool_finish_run.sql \
     302     warptool_coalesce_run.sql \
    300303     warptool_imfile.sql \
    301304     warptool_listrun.sql \

  • trunk/ippTools/share/camtool_queue_chip_id.sql

    r26567 r28043  
    1717        '%s',           -- end_stage
    1818        %lld,           -- magicked
     19        '%s',           -- software ver
     20        '%s',           -- maskfrac_npix
     21        '%s',           --         _static
     22        '%s',           --         _dynamic
     23        '%s',           --         _magic
     24        '%s',           --         _advisory
    1925        '%s'            -- note
    2026    FROM chipRun

  • trunk/ippTools/share/pxadmin_create_tables.sql

    r27874 r28043  
    276276    end_stage VARCHAR(64),
    277277    magicked BIGINT,
     278    software_ver VARCHAR(16),
     279    maskfrac_npix INT,
     280    maskfrac_static FLOAT,
     281    maskfrac_dynamic FLOAT,
     282    maskfrac_magic FLOAT,
     283    maskfrac_advisory FLOAT,
    278284    note VARCHAR(255),
    279285    PRIMARY KEY(chip_id),
    … …  
    359365    fault SMALLINT NOT NULL,
    360366    magicked BIGINT,
     367    software_ver VARCHAR(16),
     368    maskfrac_npix INT,
     369    maskfrac_static FLOAT,
     370    maskfrac_dynamic FLOAT,
     371    maskfrac_magic FLOAT,
     372    maskfrac_advisory FLOAT,
    361373    PRIMARY KEY(chip_id, exp_id, class_id),
    362374    KEY(data_state),
    … …  
    387399    end_stage VARCHAR(64),
    388400    magicked BIGINT,
     401    software_ver VARCHAR(16),
     402    maskfrac_npix INT,
     403    maskfrac_static FLOAT,
     404    maskfrac_dynamic FLOAT,
     405    maskfrac_magic FLOAT,
     406    maskfrac_advisory FLOAT,
    389407    note VARCHAR(255),
    390408    PRIMARY KEY(cam_id),
    … …  
    464482    quality SMALLINT NOT NULL DEFAULT 0,
    465483    fault SMALLINT NOT NULL,
     484    software_ver VARCHAR(16),
     485    maskfrac_npix INT,
     486    maskfrac_static FLOAT,
     487    maskfrac_dynamic FLOAT,
     488    maskfrac_magic FLOAT,
     489    maskfrac_advisory FLOAT,
    466490    PRIMARY KEY(cam_id),
    467491    KEY(fault),
    … …  
    867891    registered DATETIME,
    868892    magicked BIGINT,
     893    software_ver VARCHAR(16),
     894    maskfrac_npix INT,
     895    maskfrac_static FLOAT,
     896    maskfrac_dynamic FLOAT,
     897    maskfrac_magic FLOAT,
     898    maskfrac_advisory FLOAT,
    869899    note VARCHAR(255),
    870900    PRIMARY KEY(warp_id),
    … …  
    923953    fault SMALLINT,
    924954    magicked BIGINT,
     955    software_ver VARCHAR(16),
     956    maskfrac_npix INT,
     957    maskfrac_static FLOAT,
     958    maskfrac_dynamic FLOAT,
     959    maskfrac_magic FLOAT,
     960    maskfrac_advisory FLOAT,
    925961    PRIMARY KEY(warp_id, skycell_id, tess_id),
    926962    KEY(good_frac),
    … …  
    948984        tess_id VARCHAR(64),
    949985        filter VARCHAR(64),
     986        software_ver VARCHAR(16),
    950987        note VARCHAR(255),
    951988        PRIMARY KEY(stack_id),
    … …  
    9951032        quality SMALLINT NOT NULL DEFAULT 0,
    9961033        fault SMALLINT,
     1034        software_ver VARCHAR(16),
    9971035        PRIMARY KEY(stack_id),
    9981036        KEY(dtime_stack),
    … …  
    10171055        exposure TINYINT DEFAULT 0,
    10181056        magicked BIGINT,
     1057        software_ver VARCHAR(16),
     1058        maskfrac_npix INT,
     1059        maskfrac_static FLOAT,
     1060        maskfrac_dynamic FLOAT,
     1061        maskfrac_magic FLOAT,
     1062        maskfrac_advisory FLOAT,
    10191063        diff_mode SMALLINT NOT NULL,
    10201064        note VARCHAR(255),
    … …  
    10801124        fault SMALLINT,
    10811125        magicked BIGINT,
     1126        software_ver VARCHAR(16),
     1127        maskfrac_npix INT,
     1128        maskfrac_static FLOAT,
     1129        maskfrac_dynamic FLOAT,
     1130        maskfrac_magic FLOAT,
     1131        maskfrac_advisory FLOAT,
    10821132        PRIMARY KEY(diff_id, skycell_id),
    10831133        KEY(good_frac),

  • trunk/ippTools/src/camtool.c

    r27739 r28043  
    481481    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    482482    PXOPT_LOOKUP_S16(quality, config->args, "-quality", false, false);
     483
     484    PXOPT_LOOKUP_STR(ver_pslib, config->args, "-ver_pslib", false, false);
     485    PXOPT_LOOKUP_STR(ver_psmodules, config->args, "-ver_psmodules", false, false);
     486    PXOPT_LOOKUP_STR(ver_psphot, config->args, "-ver_psphot", false, false);
     487    PXOPT_LOOKUP_STR(ver_psastro, config->args, "-ver_psastro", false, false);
     488    PXOPT_LOOKUP_STR(ver_ppstats, config->args, "-ver_ppstats", false, false);
     489    PXOPT_LOOKUP_STR(ver_ppimage, config->args, "-ver_ppimage", false, false);
     490    PXOPT_LOOKUP_STR(ver_streaks, config->args, "-ver_streaks", false, false);
     491
     492    PXOPT_LOOKUP_S32(maskfrac_npix, config->args, "-maskfrac_npix", false, false);
     493    PXOPT_LOOKUP_F32(maskfrac_static, config->args, "-maskfrac_static", false, false);
     494    PXOPT_LOOKUP_F32(maskfrac_dynamic, config->args, "-maskfrac_dynamic", false, false);
     495    PXOPT_LOOKUP_F32(maskfrac_magic, config->args, "-maskfrac_magic", false, false);
     496    PXOPT_LOOKUP_F32(maskfrac_advisory, config->args, "-maskfrac_advisory", false, false);
     497
     498    psTrace("czw.test",1,"Received versions: pslib %s psmodules %s psphot %s psastro %s ppstats %s ppImage %s streaks %s\n",
     499            ver_pslib,ver_psmodules,ver_psphot,ver_psastro,ver_ppstats,ver_ppimage,ver_streaks);
     500    psString software_ver = NULL;
     501    if ((ver_pslib)&&(ver_psmodules)) {
     502      software_ver = pxMergeCodeVersions(ver_pslib,ver_psmodules);
     503    }
     504    if (ver_psphot) {
     505      software_ver = pxMergeCodeVersions(software_ver,ver_psphot);
     506    }
     507    if (ver_psastro) {
     508      software_ver = pxMergeCodeVersions(software_ver,ver_psastro);
     509    }
     510    if (ver_ppstats) {
     511      software_ver = pxMergeCodeVersions(software_ver,ver_ppstats);
     512    }
     513    if (ver_ppimage) {
     514      software_ver = pxMergeCodeVersions(software_ver,ver_ppimage);
     515    }
     516    if (ver_streaks) {
     517      software_ver = pxMergeCodeVersions(software_ver,ver_streaks);
     518    }
    483519
    484520//    Get this from the chipRun
    … …  
    595631        path_base,
    596632        fault,
    597         quality
     633        software_ver,
     634        maskfrac_npix,
     635        maskfrac_static,
     636        maskfrac_dynamic,
     637        maskfrac_magic,
     638        maskfrac_advisory,
     639        quality
    598640        );
    599641
    … …  
    620662    // else continue on...
    621663
     664
     665    // Set camRun.software_ver to the appropriate value
     666    if (!pxSetRunSoftware(config, "camRun", "cam_id", cam_id, software_ver)) {
     667      if (!psDBRollback(config->dbh)) {
     668        psError(PS_ERR_UNKNOWN, false, "database error");
     669      }
     670      psError(PS_ERR_UNKNOWN, false, "failed to set camRun.software_ver for cam_id: %" PRId64,
     671              cam_id);
     672      psFree(output);
     673      return(false);
     674    }
     675    // Set chipRun.maskfrac* to the appropriate values.
     676    if (maskfrac_npix) {
     677      if (!pxSetRunMaskfrac(config, "camRun", "cam_id",cam_id, maskfrac_npix, maskfrac_static,
     678                            maskfrac_dynamic, maskfrac_magic, maskfrac_advisory)) {
     679        if (!psDBRollback(config->dbh)) {
     680          psError(PS_ERR_UNKNOWN, false, "database error");
     681        }
     682        psError(PS_ERR_UNKNOWN, false, "failed to set camRun.maskstats for cam_id: %" PRId64,
     683                cam_id);
     684        psFree(output);
     685        return(false);
     686      }
     687    }
     688
    622689    // since there is only one exp per 'new' set camRun.state = 'full'
    623690    // propagate magicked state from chipRun
    … …  
    628695        return false;
    629696    }
     697   
    630698    psFree(row);
    631699

  • trunk/ippTools/src/camtoolConfig.c

    r27739 r28043  
    174174    psMetadataAddS64(addprocessedexpArgs, PS_LIST_TAIL, "-magicked",   0,         "set magicked", 0);
    175175
     176    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_pslib", 0, "define psLib version", NULL);
     177    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_psmodules", 0, "define psModules version", NULL);
     178    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_psphot", 0, "define psphot version", NULL);
     179    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_psastro", 0, "define psastro version", NULL);
     180    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_ppstats", 0, "define ppStats version", NULL);
     181    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_ppimage", 0, "define ppImage version", NULL);
     182    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-ver_streaks", 0, "define streaksremove version", NULL);
     183
     184    psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_npix", 0, "define number of pixels used for maskstats", 0);
     185    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_static", 0, "define static mask fraction", NAN);
     186    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_dynamic", 0, "define dynamic mask fraction", NAN);
     187    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_magic", 0, "define magic mask fraction", NAN);
     188    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-maskfrac_advisory", 0, "define advisory mask fraction", NAN);
     189
     190
    176191    // -processedexp
    177192    psMetadata *processedexpArgs = psMetadataAlloc();

  • trunk/ippTools/src/chiptool.c

    r27893 r28043  
    585585    PXOPT_LOOKUP_S64(magicked, config->args,       "-magicked", false, false);
    586586
     587    PXOPT_LOOKUP_STR(ver_pslib, config->args, "-ver_pslib", false, false);
     588    PXOPT_LOOKUP_STR(ver_psmodules, config->args, "-ver_psmodules", false, false);
     589    PXOPT_LOOKUP_STR(ver_psphot, config->args, "-ver_psphot", false, false);
     590    PXOPT_LOOKUP_STR(ver_psastro, config->args, "-ver_psastro", false, false);
     591    PXOPT_LOOKUP_STR(ver_ppstats, config->args, "-ver_ppstats", false, false);
     592    PXOPT_LOOKUP_STR(ver_ppimage, config->args, "-ver_ppimage", false, false);
     593    PXOPT_LOOKUP_STR(ver_streaks, config->args, "-ver_streaks", false, false);
     594
     595    PXOPT_LOOKUP_S32(maskfrac_npix, config->args, "-maskfrac_npix", false, false);
     596    PXOPT_LOOKUP_F32(maskfrac_static, config->args, "-maskfrac_static", false, false);
     597    PXOPT_LOOKUP_F32(maskfrac_dynamic, config->args, "-maskfrac_dynamic", false, false);
     598    PXOPT_LOOKUP_F32(maskfrac_magic, config->args, "-maskfrac_magic", false, false);
     599    PXOPT_LOOKUP_F32(maskfrac_advisory, config->args, "-maskfrac_advisory", false, false);
     600
     601    psTrace("czw.test",1,"Received versions: pslib %s psmodules %s psphot %s psastro %s ppstats %s ppImage %s streaks %s\n",
     602            ver_pslib,ver_psmodules,ver_psphot,ver_psastro,ver_ppstats,ver_ppimage,ver_streaks);
     603    psString ver_code = NULL;
     604    if ((ver_pslib)&&(ver_psmodules)) {
     605      ver_code = pxMergeCodeVersions(ver_pslib,ver_psmodules);
     606    }
     607    if (ver_psphot) {
     608      ver_code = pxMergeCodeVersions(ver_code,ver_psphot);
     609    }
     610    if (ver_psastro) {
     611      ver_code = pxMergeCodeVersions(ver_code,ver_psastro);
     612    }
     613    if (ver_ppstats) {
     614      ver_code = pxMergeCodeVersions(ver_code,ver_ppstats);
     615    }
     616    if (ver_ppimage) {
     617      ver_code = pxMergeCodeVersions(ver_code,ver_ppimage);
     618    }
     619    if (ver_streaks) {
     620      ver_code = pxMergeCodeVersions(ver_code,ver_streaks);
     621    }
     622   
    587623    // default values
    588624    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    … …  
    661697                                   fault,
    662698                                   quality,
    663                                    magicked
     699                                   magicked,
     700                                   ver_code,
     701                                   maskfrac_npix,
     702                                   maskfrac_static,
     703                                   maskfrac_dynamic,
     704                                   maskfrac_magic,
     705                                   maskfrac_advisory
    664706            )) {
    665707        // rollback
    … …  
    13531395        psMetadata *row = output->data[i];
    13541396
     1397        psS64 chip_id = psMetadataLookupS64(NULL,row,"chip_id");
     1398       
     1399        psString software_ver = NULL;
     1400        psS32 maskfrac_npix = 0;
     1401        psF32 maskfrac_static = 0;
     1402        psF32 maskfrac_dynamic = 0;
     1403        psF32 maskfrac_magic = 0;
     1404        psF32 maskfrac_advisory = 0;
     1405
     1406        // Calculate run level masking and software state
     1407        if (!pxCoalesceRunStatus(config,"chiptool_coalesce_run.sql",chip_id,
     1408                                 &software_ver,&maskfrac_npix,
     1409                                 &maskfrac_static,&maskfrac_dynamic,
     1410                                 &maskfrac_magic,&maskfrac_advisory)) {
     1411          psError(PS_ERR_UNKNOWN, false, "failed to generate run level statistics");
     1412          psFree(output);
     1413          if (!psDBRollback(config->dbh)) {
     1414            psError(PS_ERR_UNKNOWN, false, "database error");
     1415          }
     1416          return(false);
     1417        }
     1418        psMetadataAddStr(row, PS_LIST_TAIL, "software_ver",  0, "Software version", software_ver);
     1419        psMetadataAddS32(row, PS_LIST_TAIL, "maskfrac_npix",  0, "Number of pixels used for mask stats", maskfrac_npix);
     1420        psMetadataAddF32(row, PS_LIST_TAIL, "maskfrac_static",  0, "Fraction of static masked pixels", maskfrac_static);
     1421        psMetadataAddF32(row, PS_LIST_TAIL, "maskfrac_dynamic",  0, "Fraction of dynamic masked pixels", maskfrac_dynamic);
     1422        psMetadataAddF32(row, PS_LIST_TAIL, "maskfrac_magic",  0, "Fraction of magic masked pixels", maskfrac_magic);
     1423        psMetadataAddF32(row, PS_LIST_TAIL, "maskfrac_advisory",  0, "Fraction of advisory pixels", maskfrac_advisory);
     1424        psWarning("ADVANCE %ld %s %d %f %f %f %f\n",chip_id,software_ver,maskfrac_npix,maskfrac_static,maskfrac_dynamic,maskfrac_magic,maskfrac_advisory);
    13551425        chipRunRow *chipRun = chipRunObjectFromMetadata(row);
    13561426        if (!psDBTransaction(config->dbh)) {
    … …  
    13591429        }
    13601430
     1431        // Set chipRun.software_ver to the appropriate value
     1432        if (!pxSetRunSoftware(config, "chipRun", "chip_id", chip_id, software_ver)) {
     1433          psError(PS_ERR_UNKNOWN, false, "failed to set chipRun.software_ver for chip_id: %" PRId64,
     1434                  chip_id);
     1435          psFree(output);
     1436          if (!psDBRollback(config->dbh)) {
     1437            psError(PS_ERR_UNKNOWN, false, "database error");
     1438          }
     1439          return(false);
     1440        }
     1441        // Set chipRun.maskfrac* to the appropriate values.
     1442        if (!pxSetRunMaskfrac(config, "chipRun", "chip_id",chip_id, maskfrac_npix, maskfrac_static,
     1443                              maskfrac_dynamic, maskfrac_magic, maskfrac_advisory)) {
     1444          psError(PS_ERR_UNKNOWN, false, "failed to set chipRun.software_ver for chip_id: %" PRId64,
     1445                  chip_id);
     1446          psFree(output);
     1447          if (!psDBRollback(config->dbh)) {
     1448            psError(PS_ERR_UNKNOWN, false, "database error");
     1449          }
     1450          return(false);
     1451        }
    13611452        // set chipRun.state to 'stop' and update the magicked state
    13621453        if (!pxchipRunSetState(config, chipRun->chip_id, "full", chipRun->magicked)) {
    … …  
    13831474        // stop
    13841475        if (!pxcamQueueByChipID(config,
    1385                     chipRun->chip_id,
    1386                     chipRun->workdir,
    1387                     chipRun->label,
    1388                     chipRun->data_group,
    1389                     chipRun->dist_group,
    1390                     chipRun->reduction,
    1391                     chipRun->expgroup,
    1392                     chipRun->dvodb,
    1393                     chipRun->tess_id,
    1394                     chipRun->end_stage,
    1395                     chipRun->magicked,
    1396                     NULL    // note does not propagate
     1476                                chipRun->chip_id,
     1477                                chipRun->workdir,
     1478                                chipRun->label,
     1479                                chipRun->data_group,
     1480                                chipRun->dist_group,
     1481                                chipRun->reduction,
     1482                                chipRun->expgroup,
     1483                                chipRun->dvodb,
     1484                                chipRun->tess_id,
     1485                                chipRun->end_stage,
     1486                                chipRun->magicked,
     1487                                NULL    // note does not propagate
    13971488        )) {
    13981489           if (!psDBRollback(config->dbh)) {

  • trunk/ippTools/src/chiptoolConfig.c

    r27738 r28043  
    181181    psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
    182182    psMetadataAddS64(addprocessedimfileArgs, PS_LIST_TAIL, "-magicked",  0,        "define magicked status", 0);
     183
     184    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-ver_pslib", 0, "define psLib version", NULL);
     185    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-ver_psmodules", 0, "define psModules version", NULL);
     186    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-ver_psphot", 0, "define psphot version", NULL);
     187    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-ver_psastro", 0, "define psastro version", NULL);
     188    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-ver_ppstats", 0, "define ppStats version", NULL);
     189    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-ver_ppimage", 0, "define ppImage version", NULL);
     190    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-ver_streaks", 0, "define streaksremove version", NULL);
     191   
     192    psMetadataAddS32(addprocessedimfileArgs, PS_LIST_TAIL, "-maskfrac_npix", 0, "define number of pixels used for maskstats", 0);
     193    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-maskfrac_static", 0, "define static mask fraction", NAN);
     194    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-maskfrac_dynamic", 0, "define dynamic mask fraction", NAN);
     195    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-maskfrac_magic", 0, "define magic mask fraction", NAN);
     196    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-maskfrac_advisory", 0, "define advisory mask fraction", NAN);
    183197
    184198    // -processedimfile

  • trunk/ippTools/src/difftool.c

    r27794 r28043  
    162162            exposure,
    163163            false,
     164            NULL, // software version
     165            0,    // mask stat npix
     166            NAN,    // static
     167            NAN,    // dynamic
     168            NAN,    // magic
     169            NAN,    // advisory
    164170            diff_mode,
    165171            note
    … …  
    549555    PXOPT_LOOKUP_F32(good_frac, config->args, "-good_frac", false, false);
    550556    PXOPT_LOOKUP_S64(magicked, config->args, "-magicked", false, false);
     557
     558    PXOPT_LOOKUP_STR(ver_pslib, config->args, "-ver_pslib", false, false);
     559    PXOPT_LOOKUP_STR(ver_psmodules, config->args, "-ver_psmodules", false, false);
     560    PXOPT_LOOKUP_STR(ver_psphot, config->args, "-ver_psphot", false, false);
     561    PXOPT_LOOKUP_STR(ver_ppstats, config->args, "-ver_ppstats", false, false);
     562    PXOPT_LOOKUP_STR(ver_ppsub, config->args, "-ver_ppsub", false, false);
     563    PXOPT_LOOKUP_STR(ver_streaks, config->args, "-ver_streaks", false, false);
     564
     565    PXOPT_LOOKUP_S32(maskfrac_npix, config->args, "-maskfrac_npix", false, false);
     566    PXOPT_LOOKUP_F32(maskfrac_static, config->args, "-maskfrac_static", false, false);
     567    PXOPT_LOOKUP_F32(maskfrac_dynamic, config->args, "-maskfrac_dynamic", false, false);
     568    PXOPT_LOOKUP_F32(maskfrac_magic, config->args, "-maskfrac_magic", false, false);
     569    PXOPT_LOOKUP_F32(maskfrac_advisory, config->args, "-maskfrac_advisory", false, false);
     570   
     571    psTrace("czw.test",1,"Received versions: pslib %s psmodules %s psphot %s ppstats %s ppsub %s streaks %s\n",
     572            ver_pslib,ver_psmodules,ver_psphot,ver_ppstats,ver_ppsub,ver_streaks);
     573    psString ver_code = NULL;
     574    if ((ver_pslib)&&(ver_psmodules)) {
     575      ver_code = pxMergeCodeVersions(ver_pslib,ver_psmodules);
     576    }
     577    if (ver_psphot) {
     578      ver_code = pxMergeCodeVersions(ver_code,ver_psphot);
     579    }
     580    if (ver_ppstats) {
     581      ver_code = pxMergeCodeVersions(ver_code,ver_ppstats);
     582    }
     583    if (ver_ppsub) {
     584      ver_code = pxMergeCodeVersions(ver_code,ver_ppsub);
     585    }
     586    if (ver_streaks) {
     587      ver_code = pxMergeCodeVersions(ver_code,ver_streaks);
     588    }
    551589
    552590    if (!psDBTransaction(config->dbh)) {
    … …  
    582620                           fault,
    583621                           quality,
    584                            magicked
     622                           magicked,
     623                           ver_code,
     624                           maskfrac_npix,
     625                           maskfrac_static,
     626                           maskfrac_dynamic,
     627                           maskfrac_magic,
     628                           maskfrac_advisory
    585629          )) {
    586630        if (!psDBRollback(config->dbh)) {
    … …  
    671715        psS64 magicked = psMetadataLookupS64(NULL, row, "magicked");
    672716
     717        psString software_ver = NULL;
     718        psS32 maskfrac_npix = 0;
     719        psF32 maskfrac_static = 0;
     720        psF32 maskfrac_dynamic = 0;
     721        psF32 maskfrac_magic = 0;
     722        psF32 maskfrac_advisory = 0;
     723
     724        // Calculate run level masking and software state
     725        if (!pxCoalesceRunStatus(config,"difftool_coalesce_run.sql",diff_id,
     726                                 &software_ver,&maskfrac_npix,
     727                                 &maskfrac_static,&maskfrac_dynamic,
     728                                 &maskfrac_magic,&maskfrac_advisory)) {
     729          psError(PS_ERR_UNKNOWN, false, "failed to generate run level statistics");
     730          psFree(output);
     731          if (!psDBRollback(config->dbh)) {
     732            psError(PS_ERR_UNKNOWN, false, "database error");
     733          }
     734          return(false);
     735        }
     736        // Set diffRun.software_ver to the appropriate value
     737        if (software_ver) {
     738          if (!pxSetRunSoftware(config, "diffRun", "diff_id", diff_id, software_ver)) {
     739            psError(PS_ERR_UNKNOWN, false, "failed to set diffRun.software_ver for diff_id: %" PRId64,
     740                    diff_id);
     741            psFree(output);
     742            if (!psDBRollback(config->dbh)) {
     743              psError(PS_ERR_UNKNOWN, false, "database error");
     744            }
     745            return(false);
     746          }
     747        }
     748        // Set diffRun.maskfrac* to the appropriate values.
     749        if (maskfrac_npix) {
     750          if (!pxSetRunMaskfrac(config, "diffRun", "diff_id", diff_id, maskfrac_npix, maskfrac_static,
     751                                maskfrac_dynamic, maskfrac_magic, maskfrac_advisory)) {
     752            psError(PS_ERR_UNKNOWN, false, "failed to set diffRun.software_ver for diff_id: %" PRId64,
     753                    diff_id);
     754            psFree(output);
     755            if (!psDBRollback(config->dbh)) {
     756              psError(PS_ERR_UNKNOWN, false, "database error");
     757            }
     758            return(false);
     759          }
     760        }
    673761        // set diffRun.state to 'full'
    674762        if (!setdiffRunState(config, diff_id, "full", magicked)) {
    … …  
    9851073            false,
    9861074            0,       // magicked
     1075            NULL, // software version
     1076            0,    // mask stat npix
     1077            NAN,    // static
     1078            NAN,    // dynamic
     1079            NAN,    // magic
     1080            NAN,    // advisory
    9871081            diff_mode, // diff_mode
    9881082            note
    … …  
    14121506                true,                   // exposure
    14131507                0,       // magicked
     1508                NULL, // software version
     1509                0,    // mask stat npix
     1510                NAN,    // static
     1511                NAN,    // dynamic
     1512                NAN,    // magic
     1513                NAN,    // advisory
    14141514                IPP_DIFF_MODE_WARP_STACK,
    14151515                note
    … …  
    17641864                                          true,  // exposure
    17651865                                          false, // magicked
     1866                                          NULL, // software version
     1867                                          0,    // mask stat npix
     1868                                          NAN,    // static
     1869                                          NAN,    // dynamic
     1870                                          NAN,    // magic
     1871                                          NAN,    // advisory                                   
    17661872                                          IPP_DIFF_MODE_WARP_WARP,
    17671873                                          note); // Run to insert
    … …  
    20462152                                      false,                 // exposure
    20472153                                      0,       // magicked
     2154                                      NULL, // software version
     2155                                      0,    // mask stat npix
     2156                                      NAN,    // static
     2157                                      NAN,    // dynamic
     2158                                      NAN,    // magic
     2159                                      NAN,    // advisory                                   
    20482160                                      IPP_DIFF_MODE_STACK_STACK, // diff_mode
    20492161                                      note

  • trunk/ippTools/src/difftoolConfig.c

    r27794 r28043  
    126126    psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-good_frac",  0, "define %% of good pixels", NAN);
    127127    psMetadataAddS64(adddiffskyfileArgs, PS_LIST_TAIL, "-magicked",  0, "define magicked state", 0);
     128    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-ver_pslib", 0, "define psLib version", NULL);
     129    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-ver_psmodules", 0, "define psModules version", NULL);
     130    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-ver_psphot", 0, "define psphot version", NULL);
     131    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-ver_ppstats", 0, "define ppStats version", NULL);
     132    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-ver_ppsub", 0, "define ppSub version", NULL);
     133    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-ver_streaks", 0, "define streaksremove version", NULL);
     134    psMetadataAddS32(adddiffskyfileArgs, PS_LIST_TAIL, "-maskfrac_npix", 0, "define number of pixels used for maskstats", 0);
     135    psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-maskfrac_static", 0, "define static mask fraction", NAN);
     136    psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-maskfrac_dynamic", 0, "define dynamic mask fraction", NAN);
     137    psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-maskfrac_magic", 0, "define magic mask fraction", NAN);
     138    psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-maskfrac_advisory", 0, "define advisory mask fraction", NAN);
    128139
    129140    // -advance

  • trunk/ippTools/src/pxcam.c

    r27210 r28043  
    152152                    char *tess_id,
    153153                    char *end_stage,
    154                     psS64 magicked,
     154                    psS64 magicked,
    155155                    char *note)
    156156{
    … …  
    184184                end_stage ? end_stage : "NULL",
    185185                (long long) magicked,
     186                         "NULL", // This shouldn't be propagated
     187                         "NULL",
     188                         "NULL",
     189                         "NULL",
     190                         "NULL",
     191                         "NULL",
    186192                note     ? note     : "NULL",
    187193                (long long)chip_id

  • trunk/ippTools/src/pxchip.c

    r27894 r28043  
    277277            end_stage,
    278278            0,          // magicked
     279                       NULL,
     280                       0,
     281                       NAN,
     282                       NAN,
     283                       NAN,
     284                       NAN,
    279285            note
    280286            )

  • trunk/ippTools/src/pxtools.c

    r27417 r28043  
    4646    if (!strcmp(state, "scrubbed")) return true;
    4747    return false;
     48}
     49
     50psString pxMergeCodeVersions(psString version1, psString version2) {
     51  psString out = NULL;
     52
     53  bool mod1 = false;
     54  bool mod2 = false;
     55
     56  psS32 num1;
     57  psS32 num2;
     58  psS32 numO;
     59
     60  if (!version1) {
     61    psStringAppend(&out,version2);
     62    return(out);
     63  }
     64  if (!version2) {
     65    psStringAppend(&out,version1);
     66    return(out);
     67  }
     68 
     69  if (strchr(version1,'M')) {
     70    psStringSubstitute(&version1,"M","");
     71    mod1 = true;
     72  }
     73  if (strchr(version2,'M')) {
     74    psStringSubstitute(&version2,"M","");
     75    mod2 = true;
     76  }
     77
     78  num1 = strtol(version1,NULL,10);
     79  num2 = strtol(version2,NULL,10);
     80
     81  if (num1 >= num2) {
     82    numO = num1;
     83  }
     84  else {
     85    numO = num2;
     86  }
     87 
     88  psStringAppend(&out,"%" PRId32,numO);
     89  if (mod1 || mod2) {
     90    psStringAppend(&out,"M");
     91  }
     92  return(out);
     93}
     94
     95bool pxCoalesceRunStatus(pxConfig *config, const psString dbQFile, psS64 stage_id, psString *software_ver,
     96                         psS32 *maskfrac_npix, psF32 *maskfrac_static, psF32 *maskfrac_dynamic,
     97                         psF32 *maskfrac_magic, psF32 *maskfrac_advisory) {
     98  psString query = pxDataGet(dbQFile);
     99/*   psString text_id = NULL; */
     100/*   psStringAppend(&text_id," %" PRId64,stage_id); */
     101/*   psStringSubstitute(&query,text_id,"@STAGE_ID@"); */
     102/*   psFree(text_id); */
     103  if (!p_psDBRunQueryF(config->dbh, query, stage_id)) {
     104    psError(PS_ERR_UNKNOWN, false, "database error");
     105    psFree(query);
     106    return(false);
     107  }
     108  psFree(query);
     109  psArray *output = p_psDBFetchResult(config->dbh);
     110  if (!output) {
     111    psError(PS_ERR_UNKNOWN, false, "database error");
     112    return(false);
     113  }
     114 
     115  for (long i = 0; i < psArrayLength(output); i++) {
     116    psMetadata *row = output->data[i];
     117
     118    psS32 this_npix = psMetadataLookupS32(NULL, row, "maskfrac_npix");
     119    psF32 this_static = psMetadataLookupF32(NULL, row, "maskfrac_static");
     120    psF32 this_dynamic = psMetadataLookupF32(NULL, row, "maskfrac_dynamic");
     121    psF32 this_magic = psMetadataLookupF32(NULL, row, "maskfrac_magic");
     122    psF32 this_advisory = psMetadataLookupF32(NULL, row, "maskfrac_advisory");
     123    psString this_version = psMetadataLookupStr(NULL, row, "software_ver");
     124
     125    *software_ver = pxMergeCodeVersions(*software_ver,this_version);
     126
     127    *maskfrac_static = ((*maskfrac_static * *maskfrac_npix) + (this_npix * this_static)) / (this_npix + *maskfrac_npix);
     128    *maskfrac_dynamic = ((*maskfrac_dynamic * *maskfrac_npix) + (this_npix * this_dynamic)) / (this_npix + *maskfrac_npix);
     129    *maskfrac_magic = ((*maskfrac_magic * *maskfrac_npix) + (this_npix * this_magic)) / (this_npix + *maskfrac_npix);
     130    *maskfrac_advisory = ((*maskfrac_advisory * *maskfrac_npix) + (this_npix * this_advisory)) / (this_npix + *maskfrac_npix);
     131    *maskfrac_npix += this_npix;
     132  }
     133  psFree(output);
     134  return(true);
     135}
     136
     137bool pxSetRunSoftware(pxConfig *config, const psString tableName, const psString stage_id_name, const psS64 stage_id,
     138                      psString software_ver) {
     139  char *query = "UPDATE %s SET software_ver = '%s' WHERE %s = %" PRId64;
     140  printf(query,tableName,software_ver,stage_id_name,stage_id);
     141  if (!p_psDBRunQueryF(config->dbh,query,tableName,software_ver,stage_id_name,stage_id)) {
     142    psError(PS_ERR_UNKNOWN, false,
     143            "failed to set software version for %s %" PRId64,stage_id_name,stage_id);
     144    return(false);
     145  }
     146 
     147  return(true);
     148}
     149bool pxSetRunMaskfrac(pxConfig *config, const psString tableName, const psString stage_id_name, const psS64 stage_id,
     150                      psS32 maskfrac_npix, psF32 maskfrac_static, psF32 maskfrac_dynamic,
     151                      psF32 maskfrac_magic, psF32 maskfrac_advisory) {
     152  char *query = "UPDATE %s SET maskfrac_npix = %d, maskfrac_static = %f, maskfrac_dynamic = %f, maskfrac_magic = %f, maskfrac_advisory = %f WHERE %s = %" PRId64;
     153  if (!p_psDBRunQueryF(config->dbh,query,tableName,maskfrac_npix,maskfrac_static,
     154                       maskfrac_dynamic, maskfrac_magic,maskfrac_advisory,stage_id_name,stage_id)) {
     155    psError(PS_ERR_UNKNOWN, false,
     156            "failed to set maskfrac stats for %s %" PRId64,stage_id_name,stage_id);
     157    return(false);
     158  }
     159 
     160
     161
     162  return(true);
    48163}
    49164

  • trunk/ippTools/src/pxtools.h

    r27983 r28043  
    5353
    5454bool pxIsValidState(const char *state);
     55psString pxMergeCodeVersions(psString version1, psString version2);
     56bool pxCoalesceRunStatus(pxConfig *config, const psString dbQFile, psS64 stage_id, psString *software_ver,
     57                         psS32 *maskfrac_npix, psF32 *maskfrac_static, psF32 *maskfrac_dynamic,
     58                         psF32 *maskfrac_magic, psF32 *maskfrac_advisory);
     59bool pxSetRunSoftware(pxConfig *config, const psString tableName, const psString stage_id_name, const psS64 stage_id,
     60                      psString software_ver);
     61bool pxSetRunMaskfrac(pxConfig *config, const psString tableName, const psString stage_id_name, const psS64 stage_id,
     62                      psS32 maskfrac_npix, psF32 maskfrac_static, psF32 maskfrac_dynamic,
     63                      psF32 maskfrac_magic, psF32 maskfrac_advisory);
     64
    5565bool pxSetStateCleaned(const psString tableName, const psString columnName, psArray *rows);
    5666bool pxAddLabelSearchArgs (pxConfig *config, psMetadata *where, char *field, char *name, char *op);

  • trunk/ippTools/src/pxwarp.c

    r25835 r28043  
    6060        NULL,      // registered
    6161        0,         // magicked set to zero when created may get updated when warpRun goes to 'full'
     62                       NULL, // version
     63                       0,   // maskfrac_npix
     64                       NAN, // static
     65                       NAN, // dynamic
     66                       NAN, // magic
     67                       NAN, // advisory               
    6268        NULL        // note
    6369    )) {

  • trunk/ippTools/src/stacktool.c

    r27722 r28043  
    370370            tess_id,
    371371            filter,
     372            NULL, // software_ver
    372373            note);
    373374
    … …  
    526527        tess_id,
    527528        filter,
     529        NULL, // software_ver
    528530        note);
    529531
    … …  
    844846    PXOPT_LOOKUP_F32(good_frac, config->args, "-good_frac", false, false);
    845847
     848    PXOPT_LOOKUP_STR(ver_pslib, config->args, "-ver_pslib", false, false);
     849    PXOPT_LOOKUP_STR(ver_psmodules, config->args, "-ver_psmodules", false, false);
     850    PXOPT_LOOKUP_STR(ver_psphot, config->args, "-ver_psphot", false, false);
     851    PXOPT_LOOKUP_STR(ver_ppstats, config->args, "-ver_ppstats", false, false);
     852    PXOPT_LOOKUP_STR(ver_ppstack, config->args, "-ver_ppstack", false, false);
     853    PXOPT_LOOKUP_STR(ver_streaks, config->args, "-ver_streaks", false, false);
     854
     855    psTrace("czw.test",1,"Received versions: pslib %s psmodules %s psphot %s ppstats %s ppstack %s streaks %s\n",
     856            ver_pslib,ver_psmodules,ver_psphot,ver_ppstats,ver_ppstack,ver_streaks);
     857    psString software_ver = NULL;
     858    if ((ver_pslib)&&(ver_psmodules)) {
     859      software_ver = pxMergeCodeVersions(ver_pslib,ver_psmodules);
     860    }
     861    if (ver_psphot) {
     862      software_ver = pxMergeCodeVersions(software_ver,ver_psphot);
     863    }
     864    if (ver_ppstats) {
     865      software_ver = pxMergeCodeVersions(software_ver,ver_ppstats);
     866    }
     867    if (ver_ppstack) {
     868      software_ver = pxMergeCodeVersions(software_ver,ver_ppstack);
     869    }
     870    if (ver_streaks) {
     871      software_ver = pxMergeCodeVersions(software_ver,ver_streaks);
     872    }
     873   
    846874    // default values
    847875    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    … …  
    883911                               good_frac,
    884912                               fault,
     913                               software_ver,
    885914                               quality
    886915          )) {
    … …  
    893922
    894923    if (fault == 0) {
     924        // Set stackRun software if we are finished.
     925        if (!pxSetRunSoftware(config, "stackRun", "stack_id", stack_id, software_ver)) {
     926          if (!psDBRollback(config->dbh)) {
     927            psError(PS_ERR_UNKNOWN, false, "database error");
     928          }
     929          psError(PS_ERR_UNKNOWN, false, "failed to set stackRun.software_ver for stack_id: %" PRId64,
     930                  stack_id);
     931          return(false);
     932        }
     933
    895934        if (!setstackRunState(config, stack_id, "full")) {
    896935            if (!psDBRollback(config->dbh)) {

  • trunk/ippTools/src/stacktoolConfig.c

    r27722 r28043  
    171171    psMetadataAddS16(addsumskyfileArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
    172172
     173    psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-ver_pslib", 0, "define psLib version", NULL);
     174    psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-ver_psmodules", 0, "define psModules version", NULL);
     175    psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-ver_psphot", 0, "define psphot version", NULL);
     176    psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-ver_ppstats", 0, "define ppStats version", NULL);
     177    psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-ver_ppstack", 0, "define ppStack version", NULL);
     178    psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-ver_streaks", 0, "define streaksremove version", NULL);
     179
    173180    // -sumskyfile
    174181    psMetadata *sumskyfileArgs= psMetadataAlloc();

  • trunk/ippTools/src/warptool.c

    r28001 r28043  
    177177            registered,
    178178            0,       // magicked
    179             note
     179            NULL,     // software version
     180            0,       // mask stat npix
     181            NAN,        // static
     182            NAN,        // dynamic
     183            NAN,        // magic
     184            NAN,        // advisory
     185            note
    180186    );
    181187    if (!warpRun) {
    … …  
    10191025    PXOPT_LOOKUP_S64(magicked, config->args, "-set_magicked", false, false);
    10201026
     1027    PXOPT_LOOKUP_STR(ver_pslib, config->args, "-ver_pslib", false, false);
     1028    PXOPT_LOOKUP_STR(ver_psmodules, config->args, "-ver_psmodules", false, false);
     1029    PXOPT_LOOKUP_STR(ver_psphot, config->args, "-ver_psphot", false, false);
     1030    PXOPT_LOOKUP_STR(ver_ppstats, config->args, "-ver_ppstats", false, false);
     1031    PXOPT_LOOKUP_STR(ver_pswarp, config->args, "-ver_pswarp", false, false);
     1032    PXOPT_LOOKUP_STR(ver_streaks, config->args, "-ver_streaks", false, false);
     1033
     1034    PXOPT_LOOKUP_S32(maskfrac_npix, config->args, "-maskfrac_npix", false, false);
     1035    PXOPT_LOOKUP_F32(maskfrac_static, config->args, "-maskfrac_static", false, false);
     1036    PXOPT_LOOKUP_F32(maskfrac_dynamic, config->args, "-maskfrac_dynamic", false, false);
     1037    PXOPT_LOOKUP_F32(maskfrac_magic, config->args, "-maskfrac_magic", false, false);
     1038    PXOPT_LOOKUP_F32(maskfrac_advisory, config->args, "-maskfrac_advisory", false, false);
     1039
     1040    psTrace("czw.test",1,"Received versions: pslib %s psmodules %s psphot %s ppstats %s pswarp %s streaks %s\n",
     1041            ver_pslib,ver_psmodules,ver_psphot,ver_ppstats,ver_pswarp,ver_streaks);
     1042    psString ver_code = NULL;
     1043    if ((ver_pslib)&&(ver_psmodules)) {
     1044      ver_code = pxMergeCodeVersions(ver_pslib,ver_psmodules);
     1045    }
     1046    if (ver_psphot) {
     1047      ver_code = pxMergeCodeVersions(ver_code,ver_psphot);
     1048    }
     1049    if (ver_ppstats) {
     1050      ver_code = pxMergeCodeVersions(ver_code,ver_ppstats);
     1051    }
     1052    if (ver_pswarp) {
     1053      ver_code = pxMergeCodeVersions(ver_code,ver_pswarp);
     1054    }
     1055    if (ver_streaks) {
     1056      ver_code = pxMergeCodeVersions(ver_code,ver_streaks);
     1057    }
     1058   
    10211059    // default values
    10221060    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    10231061    PXOPT_LOOKUP_S16(quality, config->args, "-quality", false, false);
    10241062
     1063
     1064   
    10251065    // we don't want to insert the last skyfile in a run but then not mark the
    10261066    // run as 'stop'
    … …  
    10501090                           fault,
    10511091                           quality,
    1052                            magicked
     1092                           magicked,
     1093                           ver_code,
     1094                           maskfrac_npix,
     1095                           maskfrac_static,
     1096                           maskfrac_dynamic,
     1097                           maskfrac_magic,
     1098                           maskfrac_advisory
    10531099        )) {
    10541100        if (!psDBRollback(config->dbh)) {
    … …  
    11151161        bool status;
    11161162        psS64 warp_id = psMetadataLookupS64(&status, row, "warp_id");
     1163
     1164        psString software_ver = NULL;
     1165        psS32 maskfrac_npix = 0;
     1166        psF32 maskfrac_static = 0;
     1167        psF32 maskfrac_dynamic = 0;
     1168        psF32 maskfrac_magic = 0;
     1169        psF32 maskfrac_advisory = 0;
     1170
     1171        // Calculate run level masking and software state
     1172        if (!pxCoalesceRunStatus(config,"warptool_coalesce_run.sql",warp_id,
     1173                                 &software_ver,&maskfrac_npix,
     1174                                 &maskfrac_static,&maskfrac_dynamic,
     1175                                 &maskfrac_magic,&maskfrac_advisory)) {
     1176          psError(PS_ERR_UNKNOWN, false, "failed to generate run level statistics");
     1177          psFree(output);
     1178          if (!psDBRollback(config->dbh)) {
     1179            psError(PS_ERR_UNKNOWN, false, "database error");
     1180          }
     1181          return(false);
     1182        }
     1183        // Set warpRun.software_ver to the appropriate value
     1184        if (!pxSetRunSoftware(config, "warpRun", "warp_id", warp_id, software_ver)) {
     1185          psError(PS_ERR_UNKNOWN, false, "failed to set warpRun.software_ver for warp_id: %" PRId64,
     1186                  warp_id);
     1187          psFree(output);
     1188          if (!psDBRollback(config->dbh)) {
     1189            psError(PS_ERR_UNKNOWN, false, "database error");
     1190          }
     1191          return(false);
     1192        }
     1193        // Set warpRun.maskfrac* to the appropriate values.
     1194        if (!pxSetRunMaskfrac(config, "warpRun", "warp_id", warp_id, maskfrac_npix, maskfrac_static,
     1195                              maskfrac_dynamic, maskfrac_magic, maskfrac_advisory)) {
     1196          psError(PS_ERR_UNKNOWN, false, "failed to set warpRun.software_ver for warp_id: %" PRId64,
     1197                  warp_id);
     1198          psFree(output);
     1199          if (!psDBRollback(config->dbh)) {
     1200            psError(PS_ERR_UNKNOWN, false, "database error");
     1201          }
     1202          return(false);
     1203        }       
     1204
     1205       
    11171206        if (!status) {
    11181207            psError(PS_ERR_UNKNOWN, false, "failed to look up value for warp_id");

  • trunk/ippTools/src/warptoolConfig.c

    r28001 r28043  
    224224    psMetadataAddS16(addwarpedArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
    225225
     226    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-ver_pslib", 0, "define psLib version", NULL);
     227    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-ver_psmodules", 0, "define psModules version", NULL);
     228    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-ver_psphot", 0, "define psphot version", NULL);
     229    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-ver_ppstats", 0, "define ppStats version", NULL);
     230    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-ver_pswarp", 0, "define pswarp version", NULL);
     231    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-ver_streaks", 0, "define streaksremove version", NULL);
     232
     233    psMetadataAddS32(addwarpedArgs, PS_LIST_TAIL, "-maskfrac_npix", 0, "define number of pixels used for maskstats", 0);
     234    psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-maskfrac_static", 0, "define static mask fraction", NAN);
     235    psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-maskfrac_dynamic", 0, "define dynamic mask fraction", NAN);
     236    psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-maskfrac_magic", 0, "define magic mask fraction", NAN);
     237    psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-maskfrac_advisory", 0, "define advisory mask fraction", NAN);
     238
     239   
    226240    // -warped
    227241    psMetadata *warpedArgs = psMetadataAlloc();

  • trunk/ippconfig/gpc1/camera.config

    r28014 r28043  
    150150PHOTCODE.RULE           STR     {DETECTOR}.{FILTER.ID}.{CHIP.NAME}      # Rule for generating photcode
    151151
    152 BURNTOOL.STATE.GOOD     S16     14  # Value for burntool_state with the most recent bt version.
    153 BURNTOOL.STATE.GOOD.UPDATE S16     13  # for upddate processing accept earlier version
     152BURNTOOL.STATE.GOOD        S16  14  # Value for burntool_state with the most recent bt version.
     153BURNTOOL.STATE.GOOD.UPDATE S16  13  # for upddate processing accept earlier version
     154
     155FOV                     F32     15000   # Field of view of unvignetted region in FPA pixels.
     156NPIX_INTERCHIP          S32     0

  • trunk/ippconfig/recipes/ppImage.config

    r27395 r28043  
    3535USE.BEST.BURNTOOL  BOOL    FALSE           # require the best burntooled data
    3636TILTYSTREAK.APPLY  BOOL    FALSE           # apply the 'tiltystreak' tool
    37 
     37MASK.STATS         BOOL    FALSE           # calculate mask statistics.
    3838GAIN.OVERRIDE           BOOL    TRUE            # Override a non-finite gain?
    3939
    … …  
    6767# Which regions identified by burntool to mask. 0x01 : only unfit trails, 0x02 "up" trails, 0x04 "down" trails
    6868BURNTOOL.TRAILS     U16 0x07
     69
     70MASKSTAT.STATIC     U32 0x01f
     71MASKSTAT.DYNAMIC    U32 0x060
     72MASKSTAT.MAGIC      U32 0x800
     73MASKSTAT.ADVISORY   U32 0x080
    6974
    7075# Non-linearity correction
    … …  
    169174  ASTROM.MOSAIC      BOOL    FALSE           # Astrometry for mosaic?
    170175  BACKGROUND         BOOL    TRUE            # Subtract background?
     176  MASK.STATS         BOOL    TRUE            # Calculate Mask statistics.
    171177END
    172178
    … …  
    18221828  ASTROM.MOSAIC      BOOL    FALSE           # Astrometry for mosaic?
    18231829  BACKGROUND         BOOL    FALSE           # Subtract background?
     1830  MASK.STATS         BOOL    TRUE            # Calculate Mask statistics
    18241831END
    18251832
    … …  
    18461853  ASTROM.MOSAIC      BOOL    FALSE           # Astrometry for mosaic?
    18471854  BACKGROUND         BOOL    TRUE            # Subtract background?
     1855  MASK.STATS         BOOL    TRUE            # Calculate Mask statistics
    18481856END
    18491857
    … …  
    18701878  ASTROM.MOSAIC      BOOL    FALSE           # Astrometry for mosaic?
    18711879  BACKGROUND         BOOL    TRUE            # Subtract background?
     1880  MASK.STATS         BOOL    TRUE            # Calculate Mask statistics
    18721881  PATTERN.ROW      BOOL    TRUE           # Subtract pattern noise
    18731882  PATTERN.CELL     BOOL    FALSE           # Subtract pattern noise

  • trunk/ippconfig/recipes/ppStats.config

    r27728 r28043  
    8585  HEADER        STR     IQ_M4_UQ
    8686
     87  HEADER        STR     PSLIB_V
     88  HEADER        STR     MODULE_V
     89  HEADER        STR     PHOT_V
     90  HEADER        STR     ASTRO_V
     91  HEADER        STR     STATS_V
     92  HEADER        STR     IMAGE_V
     93  HEADER        STR     STREAK_V
     94
    8795  HEADER        STR     DETREND.MASK DETREND.BIAS DETREND.DARK DETREND.SHUTTER DETREND.FLAT DETREND.FRINGE
    8896
    … …  
    9199  ANALYSIS      STR     PSASTRO.HEADER
    92100  ANALYSIS      STR     DETREND
     101
     102  SUMMARY       STR     MASKFRAC_STATIC
     103  SUMMARY       STR     MASKFRAC_MAGIC
     104  SUMMARY       STR     MASKFRAC_ADVISORY
     105  SUMMARY       STR     MASKFRAC_DYNAMIC
     106  SUMMARY       STR     MASKFRAC_NPIX
     107
    93108END
    94109
    … …  
    103118  HEADER        STR     ZPT_ERR
    104119
     120  HEADER        STR     PSLIB_V
     121  HEADER        STR     MODULE_V
     122  HEADER        STR     PHOT_V
     123  HEADER        STR     ASTRO_V
     124  HEADER        STR     STATS_V
     125  HEADER        STR     IMAGE_V
     126  HEADER        STR     STREAK_V
     127
    105128  ANALYSIS      MULTI   # metadata blocks to search in chip/cell/readout->analysis
    106129  ANALYSIS      STR     PSPHOT.HEADER
    107130  ANALYSIS      STR     PSASTRO.HEADER
     131
     132  ANALYSIS      STR     MASKFRAC_STATIC
     133  ANALYSIS      STR     MASKFRAC_MAGIC
     134  ANALYSIS      STR     MASKFRAC_ADVISORY
     135  ANALYSIS      STR     MASKFRAC_DYNAMIC
     136  ANALYSIS      STR     MASKFRAC_NPIX
    108137END
    109138
    … …  
    241270  SUMMARY       MULTI
    242271
     272  HEADER        STR     PSLIB_V
     273  HEADER        STR     MODULE_V
     274  HEADER        STR     PHOT_V
     275  HEADER        STR     STATS_V
     276  HEADER        STR     WARP_V
     277  HEADER        STR     STREAK_V
     278
    243279  STAT          STR     ROBUST_MEDIAN
    244280  STAT          STR     ROBUST_STDEV    # Background statistics estimators
    245281  SUMMARY       STR     GOOD_PIXEL_NUM  # Number of good pixels
    246282  SUMMARY       STR     GOOD_PIXEL_FRAC # Fraction of good pixels
    247 END
     283
     284  ANALYSIS      MULTI
     285  ANALYSIS      STR     MASKFRAC_STATIC
     286  ANALYSIS      STR     MASKFRAC_MAGIC
     287  ANALYSIS      STR     MASKFRAC_ADVISORY
     288  ANALYSIS      STR     MASKFRAC_DYNAMIC
     289  ANALYSIS      STR     MASKFRAC_NPIX
     290END
     291
     292# Based on WARPSTATS
     293# basic stats for stacked images
     294STACKSTATS      METADATA
     295  HEADER        MULTI
     296  CONCEPT       MULTI
     297  STAT          MULTI
     298  SUMMARY       MULTI
     299
     300  HEADER        STR     PSLIB_V
     301  HEADER        STR     MODULE_V
     302  HEADER        STR     PHOT_V
     303  HEADER        STR     STATS_V
     304  HEADER        STR     STACK_V
     305
     306  STAT          STR     ROBUST_MEDIAN
     307  STAT          STR     ROBUST_STDEV    # Background statistics estimators
     308  SUMMARY       STR     GOOD_PIXEL_NUM  # Number of good pixels
     309  SUMMARY       STR     GOOD_PIXEL_FRAC # Fraction of good pixels
     310
     311  ANALYSIS      MULTI
     312  ANALYSIS      STR     MASKFRAC_STATIC
     313  ANALYSIS      STR     MASKFRAC_MAGIC
     314  ANALYSIS      STR     MASKFRAC_ADVISORY
     315  ANALYSIS      STR     MASKFRAC_DYNAMIC
     316  ANALYSIS      STR     MASKFRAC_NPIX
     317END
     318
     319# basic stats for diffed images
     320DIFFSTATS       METADATA
     321  HEADER        MULTI
     322  CONCEPT       MULTI
     323  STAT          MULTI
     324  SUMMARY       MULTI
     325
     326  HEADER        STR     PSLIB_V
     327  HEADER        STR     MODULE_V
     328  HEADER        STR     PHOT_V
     329  HEADER        STR     STATS_V
     330  HEADER        STR     PPSUB_V
     331  HEADER        STR     STREAK_V
     332
     333  STAT          STR     ROBUST_MEDIAN
     334  STAT          STR     ROBUST_STDEV    # Background statistics estimators
     335  SUMMARY       STR     GOOD_PIXEL_NUM  # Number of good pixels
     336  SUMMARY       STR     GOOD_PIXEL_FRAC # Fraction of good pixels
     337
     338  ANALYSIS      MULTI
     339  ANALYSIS      STR     MASKFRAC_STATIC
     340  ANALYSIS      STR     MASKFRAC_MAGIC
     341  ANALYSIS      STR     MASKFRAC_ADVISORY
     342  ANALYSIS      STR     MASKFRAC_DYNAMIC
     343  ANALYSIS      STR     MASKFRAC_NPIX
     344END

  • trunk/ippconfig/recipes/ppStatsFromMetadata.config

    r27569 r28043  
    171171  ENTRY  VAL  IQ_M2S_U            F32  SAMPLE_MEAN      -iq_m2s_uq           
    172172  ENTRY  VAL  QUALITY             S32  CONSTANT          -quality             # Bad quality flag
     173
     174  # Revision values
     175  ENTRY  VAL  PSLIB_V             STR  CONSTANT         -ver_pslib
     176  ENTRY  VAL  MODULE_V            STR  CONSTANT         -ver_psmodules
     177  ENTRY  VAL  PHOT_V              STR  CONSTANT         -ver_psphot
     178  ENTRY  VAL  ASTRO_V             STR  CONSTANT         -ver_psastro
     179  ENTRY  VAL  STATS_V             STR  CONSTANT         -ver_ppstats
     180  ENTRY  VAL  IMAGE_V             STR  CONSTANT         -ver_ppimage
     181  ENTRY  VAL  STREAK_V            STR  CONSTANT         -ver_streaks
     182 
     183  # Mask stats values
     184  ENTRY VAL MASKFRAC_NPIX         S32  CONSTANT         -maskfrac_npix
     185  ENTRY VAL MASKFRAC_STATIC       F32  CONSTANT         -maskfrac_static
     186  ENTRY VAL MASKFRAC_DYNAMIC      F32  CONSTANT         -maskfrac_dynamic
     187  ENTRY VAL MASKFRAC_MAGIC        F32  CONSTANT         -maskfrac_magic
     188  ENTRY VAL MASKFRAC_ADVISORY     F32  CONSTANT         -maskfrac_advisory
    173189END
    174190
    … …  
    230246
    231247  ENTRY  VAL  QUALITY             S32  CONSTANT          -quality             # Bad quality flag
     248
     249  # Revision values
     250  ENTRY  VAL  PSLIB_V             STR  CONSTANT         -ver_pslib
     251  ENTRY  VAL  MODULE_V            STR  CONSTANT         -ver_psmodules
     252  ENTRY  VAL  PHOT_V              STR  CONSTANT         -ver_psphot
     253  ENTRY  VAL  ASTRO_V             STR  CONSTANT         -ver_psastro
     254  ENTRY  VAL  STATS_V             STR  CONSTANT         -ver_ppstats
     255  ENTRY  VAL  IMAGE_V             STR  CONSTANT         -ver_ppimage
     256  ENTRY  VAL  STREAK_V            STR  CONSTANT         -ver_streaks
    232257END
    233258
    … …  
    246271
    247272  ENTRY  VAL  QUALITY             S32  CONSTANT          -quality             # Bad quality flag
     273
     274  # Revision values
     275  ENTRY  VAL  PSLIB_V             STR  CONSTANT         -ver_pslib
     276  ENTRY  VAL  MODULE_V            STR  CONSTANT         -ver_psmodules
     277  ENTRY  VAL  PHOT_V              STR  CONSTANT         -ver_psphot
     278  ENTRY  VAL  ASTRO_V             STR  CONSTANT         -ver_psastro
     279  ENTRY  VAL  STATS_V             STR  CONSTANT         -ver_ppstats
     280  ENTRY  VAL  IMAGE_V             STR  CONSTANT         -ver_ppimage
     281  ENTRY  VAL  STREAK_V            STR  CONSTANT         -ver_streaks
     282
     283  # Mask stats values
     284  ENTRY VAL MASKFRAC_NPIX         S32  CONSTANT         -maskfrac_npix
     285  ENTRY VAL MASKFRAC_STATIC       F32  CONSTANT         -maskfrac_static
     286  ENTRY VAL MASKFRAC_DYNAMIC      F32  CONSTANT         -maskfrac_dynamic
     287  ENTRY VAL MASKFRAC_MAGIC        F32  CONSTANT         -maskfrac_magic
     288  ENTRY VAL MASKFRAC_ADVISORY     F32  CONSTANT         -maskfrac_advisory
    248289END
    249290
    … …  
    261302  ENTRY  VAL  ACCEPT              BOOL CONSTANT          -accept
    262303  ENTRY  VAL  QUALITY             S32  CONSTANT          -quality             # Bad quality flag
     304
     305  # Revision values
     306  ENTRY  VAL  PSLIB_V             STR  CONSTANT         -ver_pslib
     307  ENTRY  VAL  MODULE_V            STR  CONSTANT         -ver_psmodules
     308  ENTRY  VAL  PHOT_V              STR  CONSTANT         -ver_psphot
     309  ENTRY  VAL  STATS_V             STR  CONSTANT         -ver_ppstats
     310  ENTRY  VAL  WARP_V              STR  CONSTANT         -ver_pswarp
     311  ENTRY  VAL  STREAK_V            STR  CONSTANT         -ver_streaks
     312
     313  # Mask stats values
     314  ENTRY VAL MASKFRAC_NPIX         S32  CONSTANT         -maskfrac_npix
     315  ENTRY VAL MASKFRAC_STATIC       F32  CONSTANT         -maskfrac_static
     316  ENTRY VAL MASKFRAC_DYNAMIC      F32  CONSTANT         -maskfrac_dynamic
     317  ENTRY VAL MASKFRAC_MAGIC        F32  CONSTANT         -maskfrac_magic
     318  ENTRY VAL MASKFRAC_ADVISORY     F32  CONSTANT         -maskfrac_advisory
     319
    263320END
    264321
    … …  
    288345  ENTRY  VAL  GOOD_PIXEL_FRAC     F32  MEAN              -good_frac                     
    289346  ENTRY  VAL  QUALITY             S32  CONSTANT          -quality             # Bad quality flag
     347
     348  # Revision values
     349  ENTRY  VAL  PSLIB_V             STR  CONSTANT         -ver_pslib
     350  ENTRY  VAL  MODULE_V            STR  CONSTANT         -ver_psmodules
     351  ENTRY  VAL  PHOT_V              STR  CONSTANT         -ver_psphot
     352  ENTRY  VAL  STATS_V             STR  CONSTANT         -ver_ppstats
     353  ENTRY  VAL  STACK_V             STR  CONSTANT         -ver_ppstack
     354  ENTRY  VAL  STREAK_V            STR  CONSTANT         -ver_streaks
    290355END
    291356
    … …  
    312377  ENTRY  VAL  GOOD_PIXEL_FRAC        F32  MEAN              -good_frac     
    313378  ENTRY  VAL  QUALITY                S32  CONSTANT          -quality             # Bad quality flag
     379
     380  # Revision values
     381  ENTRY  VAL  PSLIB_V             STR  CONSTANT         -ver_pslib
     382  ENTRY  VAL  MODULE_V            STR  CONSTANT         -ver_psmodules
     383  ENTRY  VAL  PHOT_V              STR  CONSTANT         -ver_psphot
     384  ENTRY  VAL  STATS_V             STR  CONSTANT         -ver_ppstats
     385  ENTRY  VAL  PPSUB_V             STR  CONSTANT         -ver_ppsub     
     386  ENTRY  VAL  STREAK_V            STR  CONSTANT         -ver_streaks
     387
     388  # Mask stats values
     389  ENTRY VAL MASKFRAC_NPIX         S32  CONSTANT         -maskfrac_npix
     390  ENTRY VAL MASKFRAC_STATIC       F32  CONSTANT         -maskfrac_static
     391  ENTRY VAL MASKFRAC_DYNAMIC      F32  CONSTANT         -maskfrac_dynamic
     392  ENTRY VAL MASKFRAC_MAGIC        F32  CONSTANT         -maskfrac_magic
     393  ENTRY VAL MASKFRAC_ADVISORY     F32  CONSTANT         -maskfrac_advisory
    314394END
    315395

  • trunk/ippconfig/recipes/ppSub.config

    r27596 r28043  
    2121MASK.BAD        STR     CONV.BAD        # Mask value to give bad pixels
    2222MASK.POOR       STR     CONV.POOR       # Mask value to give poor pixels
     23
     24MASK.STATS         BOOL    TRUE            # calculate mask statistics.
     25MASKSTAT.STATIC     U32 0x01f
     26MASKSTAT.DYNAMIC    U32 0x060
     27MASKSTAT.MAGIC      U32 0x800
     28MASKSTAT.ADVISORY   U32 0x080
     29
    2330
    2431LOW.THRESHOLD   F32     4.0             # Mask pixels below this threshold (std dev)

  • trunk/ippconfig/recipes/psastro.config

    r26902 r28043  
    163163EXTRACT_MAX_MAG                 F32 -15.0
    164164
     165MASK.STATS          BOOL TRUE
     166MASKSTAT.STATIC     U32 0x01f
     167MASKSTAT.DYNAMIC    U32 0x060
     168MASKSTAT.MAGIC      U32 0x800
     169MASKSTAT.ADVISORY   U32 0x080
     170
     171
     172
    165173# 2MASS default configuration (use 2MASS_J as ref magnitude)
    166174PSASTRO.CATDIR                STR      2MASS

  • trunk/ippconfig/recipes/pswarp.config

    r25537 r28043  
    1212PSF                     BOOL    TRUE            # Measure PSF for warped image?
    1313
     14MASK.STATS         BOOL    TRUE            # calculate mask statistics.
     15MASKSTAT.STATIC     U32 0x01f
     16MASKSTAT.DYNAMIC    U32 0x060
     17MASKSTAT.MAGIC      U32 0x800
     18MASKSTAT.ADVISORY   U32 0x080
     19
     20
    1421# Default recipe for warping
    1522WARP    METADATA

  • trunk/magic/censorObjects/src/censorVersion.c

    r24692 r28043  
    5858    psString source = censorSource();   // Software source
    5959
     60    psMetadataAddStr(header, PS_LIST_TAIL, "CENSOR_V", 0, NULL, source);
     61   
    6062    psStringPrepend(&version, "censor version: ");
    6163    psStringPrepend(&source, "censor source: ");

  • trunk/magic/remove/src/streaksVersion.c

    r26477 r28043  
    5858    psString source = streaksSource();   // Software source
    5959
     60    psMetadataAddStr(header, PS_LIST_TAIL, "STREAK_V", 0, NULL, source);
     61   
    6062    psStringPrepend(&version, "%s version: ", streaksProgram);
    6163    psStringPrepend(&source, "%s source: ", streaksProgram);

  • trunk/ppArith/src/ppArithVersion.c

    r23795 r28043  
    8383    psString source  = ppArithSource();  // Software source
    8484
     85    psMetadataAddStr(header, PS_LIST_TAIL, "ARITH_V", PS_META_REPLACE, NULL, PPARITH_VERSION);
     86   
    8587    psStringPrepend(&version, "ppArith version: ");
    8688    psStringPrepend(&version, "ppArith source: ");

  • trunk/ppImage/src/Makefile.am

    r25930 r28043  
    4444        ppImageRebinReadout.c \
    4545        ppImageMosaic.c \
     46        ppImageMaskStats.c \
    4647        ppImagePhotom.c \
    4748        ppImageAstrom.c \

  • trunk/ppImage/src/ppImage.h

    r26895 r28043  
    4949    bool applyParity;                   // Apply Cell parities
    5050
     51  bool doMaskStats;                      // Calculate mask statistics
     52 
    5153    bool doCrosstalkMeasure;            // measure crosstalk signal
    5254    bool doCrosstalkCorrect;            // apply crosstalk correction
    … …  
    110112
    111113    char *normClass;                    // class to use for per-class normalization
     114
     115  psU16 maskstat_static;
     116  psU16 maskstat_dynamic;
     117  psU16 maskstat_magic;
     118  psU16 maskstat_advisory;
     119 
    112120} ppImageOptions;
    113121
    … …  
    268276    );
    269277
     278// Calculate Mask statistics
     279bool ppImageMaskStats(pmConfig *config, pmFPAview *view, psMetadata *stats);
     280
    270281// calculate stats from headers and concepts
    271282bool ppImageMetadataStats(pmConfig *config, // Configuration

  • trunk/ppImage/src/ppImageLoop.c

    r27556 r28043  
    196196        }
    197197
     198        if (options->doMaskStats) {
     199          //if (!ppImageMaskStats(config, view, options)) {
     200          if (!ppImageMaskStats(config, view, stats)) {
     201            ESCAPE("Unable to do Mask stats");
     202          }
     203        }
     204       
    198205        // these may be used by ppImageSubtractBackground.
    199206        // if these are defined as internal files, drop them here
    … …  
    252259        ppImageFileCheck(config);
    253260    }
    254 
     261   
    255262    // Calculate summary statistics from FPA Metadata
    256263    if (!ppImageMetadataStats(config, stats, options)) {

  • trunk/ppImage/src/ppImageOptions.c

    r26895 r28043  
    4141    options->checkCTE        = false;   // Measure pixel-based variance
    4242    options->applyParity     = false;   // Apply Cell parities
    43 
     43    options->doMaskStats     = false;   // Calculate mask fractions
     44   
    4445    // output files requested
    4546    options->BaseFITS        = false;   // create output image
    … …  
    243244    options->doPatternRow = psMetadataLookupBool(NULL, recipe, "PATTERN.ROW");
    244245    options->doPatternCell = psMetadataLookupBool(NULL, recipe, "PATTERN.CELL");
     246    options->doMaskStats = psMetadataLookupBool(NULL, recipe, "MASK.STATS");
    245247
    246248    options->doStats = false;
    … …  
    341343    options->normClass = psMetadataLookupStr(NULL, recipe, "NORM.CLASS");
    342344
     345    options->maskstat_static   = psMetadataLookupU16(NULL, recipe, "MASKSTAT.STATIC");
     346    options->maskstat_dynamic  = psMetadataLookupU16(NULL, recipe, "MASKSTAT.DYNAMIC");
     347    options->maskstat_magic    = psMetadataLookupU16(NULL, recipe, "MASKSTAT.MAGIC");
     348    options->maskstat_advisory = psMetadataLookupU16(NULL, recipe, "MASKSTAT.ADVISORY");
     349
     350   
    343351    return options;
    344352}

  • trunk/ppImage/src/ppImageVersion.c

    r23796 r28043  
    6868    psString source  = ppImageSource();  // ppImage software source
    6969
     70    psMetadataAddStr(header, PS_LIST_TAIL, "IMAGE_V", PS_META_REPLACE, NULL, PPIMAGE_VERSION);
     71   
    7072    psStringPrepend(&version, "ppImage version: ");
    7173    psStringPrepend(&source, "ppImage source: ");

  • trunk/ppMerge/src/ppMergeVersion.c

    r23800 r28043  
    8383    psString source  = ppMergeSource();  // Software source
    8484
     85    psMetadataAddStr(header, PS_LIST_TAIL, "MERGE_V", PS_META_REPLACE, NULL, PPMERGE_VERSION);
     86   
    8587    psStringPrepend(&version, "ppMerge version: ");
    8688    psStringPrepend(&source, "ppMerge source: ");

  • trunk/ppNoiseMap/src/ppNoiseMapVersion.c

    r24453 r28043  
    6161    psString source  = ppNoiseMapSource();  // ppNoiseMap software source
    6262
     63    psMetadataAddStr(header, PS_LIST_TAIL, "NOISEM_V", PS_META_REPLACE, NULL, PPNOISEMAP_VERSION);
     64   
    6365    psStringPrepend(&version, "ppNoiseMap version: ");
    6466    psStringPrepend(&source, "ppNoiseMap source: ");

  • trunk/ppSkycell/src/ppSkycellVersion.c

    r23992 r28043  
    8181    psString source  = ppSkycellSource();  // Software source
    8282
     83    psMetadataAddStr(header, PS_LIST_TAIL, "SKYCELL_V", PS_META_REPLACE, NULL, PPSKYCELL_VERSION);
     84   
    8385    psStringPrepend(&version, "ppSkycell version: ");
    8486    psStringPrepend(&version, "ppSkycell source: ");
    … …  
    8991    psFree(version);
    9092    psFree(source);
    91 
     93   
    9294    return true;
    9395}

  • trunk/ppSmooth/src/ppSmoothVersion.c

    r25976 r28043  
    7575    psString source  = ppSmoothSource();  // ppSmooth software source
    7676
     77    psMetadataAddStr(header, PS_LIST_TAIL, "SMOOTH_V", PS_META_REPLACE, NULL, PPSMOOTH_VERSION);
     78   
    7779    psStringPrepend(&version, "ppSmooth version: ");
    7880    psStringPrepend(&source, "ppSmooth source: ");
    … …  
    8385    psFree(version);
    8486    psFree(source);
    85 
     87   
    8688    return true;
    8789}

  • trunk/ppStack/src/ppStackVersion.c

    r23801 r28043  
    7474    psString source  = ppStackSource();  // Software source
    7575
     76    psMetadataAddStr(header, PS_LIST_TAIL, "STACK_V", PS_META_REPLACE, NULL, PPSTACK_VERSION);
     77   
    7678    psStringPrepend(&version, "ppStack version: ");
    7779    psStringPrepend(&source, "ppStack source: ");
    … …  
    8284    psFree(version);
    8385    psFree(source);
    84 
     86   
    8587    return true;
    8688}

  • trunk/ppStats/src/ppStatsVersion.c

    r23802 r28043  
    4949    psString source = ppStatsSource();   // Software source
    5050
     51    psMetadataAddStr(header, PS_LIST_TAIL, "STATS_V", PS_META_REPLACE, NULL, PPSTATS_VERSION);
     52   
    5153    psStringPrepend(&version, "ppStats version: ");
    5254    psStringPrepend(&source, "ppStats source: ");

  • trunk/ppSub/src/Makefile.am

    r27365 r28043  
    4141        ppSubMakePSF.c                  \
    4242        ppSubMatchPSFs.c                \
     43        ppSubMaskStats.c                \
    4344        ppSubReadoutInverse.c           \
    4445        ppSubReadoutJpeg.c              \

  • trunk/ppSub/src/ppSub.h

    r27596 r28043  
    7474bool ppSubSetMasks(pmConfig *config     ///< Configuration
    7575    );
     76
     77// Calculate mask statistics
     78bool ppSubMaskStats(pmConfig *config, pmFPAview *view, psMetadata *stats);
    7679
    7780/// Generate the PSF-matching kernel and convolve the images as needed.  Most of this function involves

  • trunk/ppSub/src/ppSubLoop.c

    r27691 r28043  
    144144        return false;
    145145    }
    146 
     146    // Do Mask Stats
     147    {
     148      pmFPAview *view = ppSubViewReadout(); // View to readout
     149      if (!ppSubMaskStats(config, view,data->stats)) {
     150        psError(psErrorCodeLast(), false, "Unable to generate mask statistics");
     151        return(false);
     152      }
     153    }
     154   
    147155    // generate the binned image used to write the jpeg
    148156    if (!ppSubReadoutJpeg(config)) {

  • trunk/ppSub/src/ppSubVersion.c

    r23803 r28043  
    8686    psString source  = ppSubSource();  // Software source
    8787
     88    psMetadataAddStr(header, PS_LIST_TAIL, "PPSUB_V", PS_META_REPLACE, NULL, PPSUB_VERSION);
     89   
    8890    psStringPrepend(&version, "ppSub version: ");
    8991    psStringPrepend(&source, "ppSub source: ");

  • trunk/ppTranslate/src/ppTranslateVersion.c

    r26266 r28043  
    6767    psString source  = ppTranslateSource();  // Software source
    6868
     69    psMetadataAddStr(header, PS_LIST_TAIL, "TRANSL_V", PS_META_REPLACE, NULL, PPTRANSLATE_VERSION);
     70   
    6971    psStringPrepend(&version, "ppTranslate version: ");
    7072    psStringPrepend(&source, "ppTranslate source: ");

  • trunk/ppViz/src/ppCoord/ppCoordVersion.c

    r26377 r28043  
    8181    psString source  = ppCoordSource();  // Software source
    8282
     83    psMetadataAddStr(header, PS_LIST_TAIL, "COORD_V", PS_META_REPLACE, NULL, PPCOORD_VERSION);
     84   
    8385    psStringPrepend(&version, "ppCoord version: ");
    8486    psStringPrepend(&version, "ppCoord source: ");

  • trunk/ppViz/src/ppVizPSF/ppVizPSFVersion.c

    r26352 r28043  
    8181    psString source  = ppVizPSFSource();  // Software source
    8282
     83    psMetadataAddStr(header, PS_LIST_TAIL, "VIZPSF_V", PS_META_REPLACE, NULL, PPVIZPSF_VERSION);
     84   
    8385    psStringPrepend(&version, "ppVizPSF version: ");
    8486    psStringPrepend(&version, "ppVizPSF source: ");

  • trunk/ppViz/src/ppVizPattern/ppVizPatternVersion.c

    r26837 r28043  
    8181    psString source  = ppVizPatternSource();  // Software source
    8282
     83    psMetadataAddStr(header, PS_LIST_TAIL, "VIZPAT_V", PS_META_REPLACE, NULL, PPVIZPATTERN_VERSION);
     84   
    8385    psStringPrepend(&version, "ppVizPattern version: ");
    8486    psStringPrepend(&version, "ppVizPattern source: ");

  • trunk/ppbgrestore/src/ppbgrestoreVersion.c

    r25973 r28043  
    6464    psString source  = ppbgrestoreSource();  // ppbgrestore software source
    6565
     66    psMetadataAddStr(header, PS_LIST_TAIL, "BGREST_V", PS_META_REPLACE, NULL, PPBGRESTORE_VERSION);
     67       
    6668    psStringPrepend(&version, "ppbgrestore version: ");
    6769    psStringPrepend(&source, "ppbgrestore source: ");

  • trunk/psLib/src/sys/psConfigure.c

    r23793 r28043  
    6666}
    6767
     68psString psLibRevision(void)
     69{
     70    char *value = NULL;
     71    psStringAppend(&value, "%s", PSLIB_VERSION);
     72    return value;
     73}
     74
    6875psString psLibSource(void)
    6976{

  • trunk/psLib/src/sys/psConfigure.h

    r23148 r28043  
    3232 */
    3333psString psLibVersion(void);
     34
     35/** Get current psLib revision number
     36 *
     37 *  Returns the current psLib revision number as a string.
     38 *
     39 *  @return psString: String with revision number.
     40 */
     41psString psLibRevision(void);
    3442
    3543/** Get current psLib source

  • trunk/psLib/src/types/psMetadataHeader.c

    r23289 r28043  
    1717    psString version = psLibVersion();  // Software version
    1818    psString source = psLibSource();    // Software source
    19 
     19    psString revision = psLibRevision();
     20    psMetadataAddStr(header, PS_LIST_TAIL, "PSLIB_V", PS_META_REPLACE, NULL, revision);
     21   
    2022    psStringPrepend(&version, "psLib version: ");
    2123    psStringPrepend(&source, "psLib source: ");
    … …  
    2628    psFree(version);
    2729    psFree(source);
    28 
     30    psFree(revision);
    2931    return true;
    3032}

  • trunk/psModules

  • trunk/psModules/src/config/pmVersion.c

    r23794 r28043  
    6464    psString source = psModulesSource();   // Software source
    6565
     66    psMetadataAddStr(header, PS_LIST_TAIL, "MODULE_V", PS_META_REPLACE, NULL, PSMODULES_VERSION);
     67   
    6668    psStringPrepend(&version, "psModules version: ");
    6769    psStringPrepend(&source, "psModules source: ");

  • trunk/psModules/src/detrend/Makefile.am

    r26893 r28043  
    88        pmFringeStats.c \
    99        pmMaskBadPixels.c \
     10        pmMaskStats.c \
    1011        pmNonLinear.c \
    1112        pmBias.c \
    … …  
    2728        pmFringeStats.h \
    2829        pmMaskBadPixels.h \
     30        pmMaskStats.h \
    2931        pmNonLinear.h \
    3032        pmBias.h \

  • trunk/psModules/src/psmodules.h

    r27750 r28043  
    7373#include <pmFringeStats.h>
    7474#include <pmMaskBadPixels.h>
     75#include <pmMaskStats.h>
    7576#include <pmNonLinear.h>
    7677#include <pmOverscan.h>

  • trunk/psastro/src/psastro.h

    r27639 r28043  
    7171bool              psastroAstromGuess (int *nStars, pmConfig *config);
    7272bool              psastroAstromGuessCheck (pmConfig *config);
    73 bool              psastroMaskUpdates (pmConfig *config);
     73bool              psastroMaskUpdates (pmConfig *config, psMetadata *stats);
    7474
    7575bool              psastroLoadGlints (pmConfig *config);
    … …  
    179179bool              psastroFPAtoChip (double *xChip, double *yChip, pmFPA *fpa, int nChip, double xFPA, double yFPA);
    180180
     181//bool              psastroMaskStats(pmConfig *config, psMetadata *stats);
    181182
    182183// psastroExtract functions

  • trunk/psastro/src/psastroAnalysis.c

    r27552 r28043  
    154154    }
    155155
    156     if (!psastroMaskUpdates (config)) {
     156    if (!psastroMaskUpdates (config, stats)) {
    157157        psError(psErrorCodeLast(), false, "Failed to generate dynamic masks.");
    158158        return false;

  • trunk/psastro/src/psastroMaskUpdates.c

    r26897 r28043  
    1919}
    2020
     21
     22int colStart(psU16 corner_list,int i,int x_0,int y_0,int R,int max) {
     23  if ((corner_list == 0x04)||(corner_list == 0x05)) {
     24    return(0);
     25  }
     26  else {
     27    return((int) fabs(x_0 - sqrt(pow(R,2) - pow(y_0 - i,2))));
     28  }   
     29}
     30int colEnd(psU16 corner_list,int i,int x_0,int y_0,int R,int max) {
     31  if ((corner_list == 0x04)||(corner_list == 0x05)) {
     32    return((int) fabs(x_0 - sqrt(pow(R,2) - pow(y_0 - i,2))));
     33  }
     34  else {
     35    return(max);
     36  }   
     37 
     38}
     39int rowStart(psU16 corner_list,int j,int x_0,int y_0,int R,int max) {
     40  if ((corner_list == 0x01)||(corner_list == 0x02)||
     41      (corner_list == 0x03)||(corner_list == 0x0b)||
     42      (corner_list == 0x07)||(corner_list == 0x0f)) {
     43    return(0);
     44  }
     45  else {
     46    return((int) fabs(y_0 - sqrt(pow(R,2) - pow(x_0 - j,2))));
     47  }
     48}
     49int rowEnd(psU16 corner_list,int j,int x_0,int y_0,int R, int max) {
     50  if (corner_list == 0x0f) {
     51    return(max);
     52  }
     53  else if ((corner_list == 0x01)||(corner_list == 0x02)||
     54           (corner_list == 0x03)||(corner_list == 0x0b)||
     55           (corner_list == 0x07)) {
     56    return((int) fabs(y_0 - sqrt(pow(R,2) - pow(x_0 - j,2))));
     57  }
     58  else {
     59    return(max);
     60  }
     61 
     62}
     63
    2164/**
    2265 * create a mask or mask regions based on the collection of reference stars that * are in the vicinity of each chip
    2366 */
    24 bool psastroMaskUpdates (pmConfig *config) {
     67bool psastroMaskUpdates (pmConfig *config, psMetadata *stats) {
    2568
    2669    bool status;
    … …  
    88131    double REFSTAR_MASK_CROSSTALK_MAG_SLOPE= psMetadataLookupF32 (&status, recipe, "REFSTAR_MASK_CROSSTALK_MAG_SLOPE");
    89132
     133    // Mask stats variables
     134    psU16 staticMaskVal = psMetadataLookupU32(&status, recipe, "MASKSTAT.STATIC");
     135    psU16 magicMaskVal = psMetadataLookupU32(&status, recipe, "MASKSTAT.MAGIC");
     136    psU16 dynamicMaskVal = psMetadataLookupU32(&status, recipe, "MASKSTAT.DYNAMIC");
     137    psU16 advisoryMaskVal = psMetadataLookupU32(&status, recipe, "MASKSTAT.ADVISORY");
     138
     139    psS32 Npix_valid = 0;
     140    psS32 Npix_static = 0;
     141    psS32 Npix_magic = 0;
     142    psS32 Npix_dynamic = 0;
     143    psS32 Npix_advisory = 0;
     144   
     145    psU16 corner_list = 0x00;
     146   
    90147    // select the input data sources
    91148    pmFPAfile *input = psMetadataLookupPtr (NULL, config->files, "PSASTRO.INPUT");
    … …  
    119176    pmFPA *fpaMask = outMask->fpa;
    120177
     178    // Get camera specific mask stat options
     179    psF32 FOV = psMetadataLookupF32(&status, fpaMask->camera, "FOV"); // Almost certainly doesn't exist. Placeholder for now.
     180    psS32 CONSTANT_BLANK = psMetadataLookupS32(&status, fpaMask->camera, "NPIX_INTERCHIP"); // Need to add this as well.
     181   
     182    Npix_valid += CONSTANT_BLANK;
     183    Npix_static += CONSTANT_BLANK;
     184
     185   
    121186    // select the reference mask fpa :: we use this to determine cell boundaries
    122187    pmFPAfile *refMask = psMetadataLookupPtr (NULL, config->files, "PSASTRO.REFMASK");
    … …  
    363428                }
    364429            }
    365         }
    366 
     430        }
     431
     432        // Do the mask stats bit from cell down.
     433        if (psMetadataLookupBool(&status,recipe,"MASK.STATS")) {
     434          if (!pmFPAfileIOChecks (config, view, PM_FPA_BEFORE)) ESCAPE;
     435          while ((cell = pmFPAviewNextCell(view, fpa, 1)) != NULL) {
     436            if (!pmFPAfileIOChecks (config, view, PM_FPA_BEFORE)) ESCAPE;
     437            psWarning("In CELL: FOV: %f CONSTANT: %d Mask bits: %d %d %d %d\n",
     438                      FOV,CONSTANT_BLANK,staticMaskVal,magicMaskVal,dynamicMaskVal,advisoryMaskVal);
     439           
     440            if (!cell->process || !cell->file_exists) {continue; }
     441            while ((readout = pmFPAviewNextReadout(view, fpa, 1)) != NULL) {
     442              pmReadout *readoutMask = pmFPAviewThisReadout (view, outMask->fpa);
     443              if (!pmFPAfileIOChecks (config, viewMask, PM_FPA_BEFORE)) ESCAPE;
     444              psWarning("In READOUT: FOV: %f CONSTANT: %d Mask bits: %d %d %d %d\n",
     445                        FOV,CONSTANT_BLANK,staticMaskVal,magicMaskVal,dynamicMaskVal,advisoryMaskVal);
     446             
     447              if (!readoutMask->data_exists) {continue; }
     448              psPlane coordFPA;
     449              psPlane coordCell;
     450             
     451              psImage *mask = readoutMask->mask;
     452              if (!mask) {continue;}
     453              psImageMaskType **maskData = mask->data.PS_TYPE_IMAGE_MASK_DATA;
     454              // Dance coordinates around
     455              // Calculate which corners fall within the field of view.
     456              // 0x04   0x08
     457              // 0x01   0x02
     458             
     459              coordFPA.x = 0.0;
     460              coordFPA.y = 0.0;
     461              psPlaneTransformApply(&coordCell,chip->fromFPA,&coordFPA);
     462              if (pow(coordFPA.x,2) + pow(coordFPA.y,2) <= pow(FOV,2)) {
     463                corner_list = corner_list | 0x01;
     464              }
     465             
     466              coordCell.x = mask->numCols - 1;
     467              psPlaneTransformApply(&coordCell,chip->fromFPA,&coordFPA);
     468              if (pow(coordFPA.x,2) + pow(coordFPA.y,2) <= pow(FOV,2)) {
     469                corner_list = corner_list | 0x02;
     470              }
     471             
     472              coordCell.y = mask->numRows - 1;
     473              psPlaneTransformApply(&coordCell,chip->fromFPA,&coordFPA);
     474              if (pow(coordFPA.x,2) + pow(coordFPA.y,2) <= pow(FOV,2)) {
     475                corner_list = corner_list | 0x08;
     476              }
     477             
     478              coordCell.x = 0;
     479              psPlaneTransformApply(&coordCell,chip->fromFPA,&coordFPA);
     480              if (pow(coordFPA.x,2) + pow(coordFPA.y,2) <= pow(FOV,2)) {
     481                corner_list = corner_list | 0x04;
     482              }
     483             
     484              int x_0 = coordFPA.x;
     485              int y_0 = coordFPA.y;
     486             
     487             
     488              // Scan over the valid regions of the image and count masked pixels
     489              if ((corner_list == 0x04)||(corner_list == 0x08)||
     490                  (corner_list == 0x05)||(corner_list == 0x0a)) {
     491                for (int i = 0; i < mask->numRows - 1; i++) {
     492                  for (int j = colStart(corner_list,i,x_0,y_0,FOV,mask->numCols - 1);
     493                       j < colEnd(corner_list,i,x_0,y_0,FOV,mask->numCols - 1); j++) {
     494                    Npix_valid++;
     495                    if (maskData[i][j] & staticMaskVal) {
     496                      Npix_static++;
     497                      continue;
     498                    }
     499                    if (maskData[i][j] & dynamicMaskVal) {
     500                      Npix_dynamic++;
     501                      continue;
     502                    }
     503                    if (maskData[i][j] & magicMaskVal) {
     504                      Npix_magic++;
     505                      continue;
     506                    }
     507                    if (maskData[i][j] & advisoryMaskVal) {
     508                      Npix_advisory++;
     509                      continue;
     510                    }
     511                  }
     512                }
     513              }
     514              else {
     515                for (int j = 0; j < mask->numCols - 1; j++) {
     516                  for (int i = rowStart(corner_list,j,x_0,y_0,FOV,mask->numRows - 1);
     517                       i < rowEnd(corner_list,j,x_0,y_0,FOV,mask->numRows - 1); i++) {
     518                    Npix_valid++;
     519                    if (maskData[i][j] & staticMaskVal) {
     520                      Npix_static++;
     521                      continue;
     522                    }
     523                    if (maskData[i][j] & dynamicMaskVal) {
     524                      Npix_dynamic++;
     525                      continue;
     526                    }
     527                    if (maskData[i][j] & magicMaskVal) {
     528                      Npix_magic++;
     529                      continue;
     530                    }
     531                    if (maskData[i][j] & advisoryMaskVal) {
     532                      Npix_advisory++;
     533                      continue;
     534                    }
     535                  }
     536                }
     537              }
     538            }
     539          }
     540        }
    367541        // output sequence for mask corresponding to this chip (XXX this may not be needed...)
    368542        *viewMask = *view;
    … …  
    392566    }
    393567
     568    psMetadataAddS32(stats,PS_LIST_TAIL, "MASKFRAC_NPIX", 0,
     569                     "Number of valid pixels", Npix_valid);
     570    psMetadataAddF32(stats,PS_LIST_TAIL, "MASKFRAC_STATIC", 0,
     571                     "Fraction of pixels statically masked", (float) Npix_static / Npix_valid);
     572    psMetadataAddF32(stats,PS_LIST_TAIL, "MASKFRAC_DYNAMIC", 0,
     573                     "Fraction of pixels dynamically masked", (float) Npix_dynamic / Npix_valid);
     574    psMetadataAddF32(stats,PS_LIST_TAIL, "MASKFRAC_MAGIC", 0,
     575                     "Fraction of pixels magically masked", (float) Npix_magic / Npix_valid);
     576    psMetadataAddF32(stats,PS_LIST_TAIL, "MASKFRAC_ADVISORY", 0,
     577                     "Fraction of pixels masked as an advisory", (float) Npix_advisory / Npix_valid);
     578   
    394579    // deactivate all files
    395580    pmFPAfileActivate (config->files, false, NULL);

  • trunk/psastro/src/psastroVersion.c

    r23804 r28043  
    5858    psString source = psastroSource();   // Software source
    5959
     60    psMetadataAddStr(header, PS_LIST_TAIL, "ASTRO_V", PS_META_REPLACE, NULL, PSASTRO_VERSION);
     61   
    6062    psStringPrepend(&version, "psastro version: ");
    6163    psStringPrepend(&source, "psastro source: ");

  • trunk/psphot

  • trunk/psphot/src/psphotVersion.c

    r25738 r28043  
    6969    psString source = psphotSource();   // Software source
    7070
     71    psMetadataAddStr(header, PS_LIST_TAIL, "PHOT_V", PS_META_REPLACE, NULL, PSPHOT_VERSION);
     72   
    7173    psStringPrepend(&version, "psphot version: ");
    7274    psStringPrepend(&source, "psphot source: ");

  • trunk/pstamp/scripts/detect_query_create

    r28038 r28043  
    6161                    comment => 'site identifier (MPC observatory code)',
    6262                    value => undef
    63         }
     63        },
     64       { name =>  'STAGE',
     65                   writetype => TSTRING,
     66                   comment => 'processing stage to examine',
     67                   value => undef
     68       }
    6469];
    6570unless(defined($nostage)) {

  • trunk/pswarp/src/Makefile.am

    r27126 r28043  
    3434        pswarpErrorCodes.c              \
    3535        pswarpMapGrid.c                 \
     36        pswarpMaskStats.c               \
    3637        pswarpMatchRange.c              \
    3738        pswarpParseCamera.c             \

  • trunk/pswarp/src/pswarp.h

    r28006 r28043  
    109109    );
    110110
     111bool pswarpMaskStats(const pmReadout *readout,
     112                     psMetadata *stats,
     113                     const pmConfig *config);
     114
     115
    111116/**
    112117 * define threads for this program

  • trunk/pswarp/src/pswarpLoop.c

    r28010 r28043  
    266266        goto DONE;
    267267    }
    268 
     268    bool doStats = psMetadataLookupBool(&mdok,recipe,"MASK.STATS");
     269    if (doStats) {
     270      if (!pswarpMaskStats(output, stats, config)) {
     271        psError(psErrorCodeLast(), false, "Unable to calculate mask stats.");
     272        psFree(cells);
     273        psFree(view);
     274        goto DONE;
     275      }
     276    }
    269277    // Set covariance matrix for output
    270278    {
    … …  
    332340
    333341    pswarpVersionHeader(hdu->header);
    334 
     342   
    335343    if (!pmAstromWriteWCS(hdu->header, outFPA, outChip, WCS_NONLIN_TOL)) {
    336344        psError(psErrorCodeLast(), false, "Unable to generate WCS header.");
    … …  
    347355    pswarpFileActivation(config, detectorFiles, false);
    348356    pswarpFileActivation(config, independentFiles, false);
     357
    349358
    350359    // We need a new PSF model for the warped frame.  It would be good to generate this analytically, but
    … …  
    421430        }
    422431    }
     432   
    423433
    424434    // Add MD5 information for readout

  • trunk/pswarp/src/pswarpVersion.c

    r23806 r28043  
    8585    psString source  = pswarpSource();  // Software source
    8686
     87    psMetadataAddStr(header, PS_LIST_TAIL, "WARP_V", PS_META_REPLACE, NULL, PSWARP_VERSION);
     88   
    8789    psStringPrepend(&version, "pswarp version: ");
    8890    psStringPrepend(&source, "pswarp source: ");
Note: See TracChangeset for help on using the changeset viewer.