IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 28043 for trunk/ippTools


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:
19 edited
3 copied

Legend:

Unmodified
Added
Removed

  • trunk

  • 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();
Note: See TracChangeset for help on using the changeset viewer.