IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 31385


Ignore:
Timestamp:
Apr 26, 2011, 6:38:11 PM (15 years ago)
Author:
watersc1
Message:

First draft of 'complete' large area processing code.

Location:
branches/czw_branch/20110406
Files:
7 added
5 edited

Legend:

Unmodified
Added
Removed

  • branches/czw_branch/20110406/Nebulous/bin/neb-shift

    r28446 r31385  
    1616use Pod::Usage qw( pod2usage );
    1717
    18 my ($volume, $server);
     18my ($volume, $server, $nocull, $cull);
    1919
    2020$server = $ENV{'NEB_SERVER'} unless $server;
    … …  
    2323    'volume=s'      => \$volume,
    2424    'server|s=s'    => \$server,
     25    'nocull'        => \$nocull,
     26    'cull'          => \$cull,
    2527) || pod2usage( 2 );
    2628
    2729my $src = shift;
    2830my $abandon_vol = shift;
     31my $do_cull = 0;
    2932
     33if ($nocull) {
     34    $do_cull = 0;
     35}
     36if ($cull) {
     37    $do_cull = 1;
     38}
    3039pod2usage( -msg => "Unknown option: @ARGV", -exitval => 2 ) if @ARGV;
    3140pod2usage( -msg => "Required options: --server <source key> <source volume>",
    … …  
    5463die "Replicate phase failed for $src ($abandon_vol) ($volume)" unless $status;
    5564
    56 $status = $neb->cull($src,$abandon_vol);
     65if ($do_cull) {
     66    $status = $neb->cull($src,$abandon_vol);
    5767
    58 warn "Cull phase failed for $src from $abandon_vol" unless $status;
     68    warn "Cull phase failed for $src from $abandon_vol" unless $status;
     69}
     70
     71
    5972
    6073__END__

  • branches/czw_branch/20110406/ippTools/src/laptool.c

    r31338 r31385  
    11/*
    2  * reproctool.c
     2 * laptool.c
    33 */
    44
    … …  
    1313#include "pxtools.h"
    1414#include "pxdata.h"
    15 #include "reproctool.h"
     15#include "laptool.h"
    1616
    1717
    … …  
    3838  psLibInit(NULL);
    3939
    40   pxConfig *config = reproctoolConfig(NULL, argc, argv);
     40  pxConfig *config = laptoolConfig(NULL, argc, argv);
    4141  if (!config) {
    4242    psError(PXTOOLS_ERR_CONFIG, false, "failed to configure");
    … …  
    4545
    4646  switch (config->mode) {
    47     MODECASE(REPROCTOOL_MODE_DEFINERUN,     definerunMode);
    48     MODECASE(REPROCTOOL_MODE_PENDINGRUN,    pendingrunMode);
    49     MODECASE(REPROCTOOL_MODE_UPDATERUN,     updaterunMode);
    50 
    51     MODECASE(REPROCTOOL_MODE_PENDINGCHIPEXP,   pendingchipexpMode);
    52     MODECASE(REPROCTOOL_MODE_PENDINGQUICKSTACK,pendingquickstackMode);
    53     MODECASE(REPROCTOOL_MODE_PENDINGDIFF,      pendingdiffMode);
    54     MODECASE(REPROCTOOL_MODE_PENDINGFINALSTACK,pendingfinalstackMode);
    55     MODECASE(REPROCTOOL_MODE_UPDATEEXP,        updateexpMode);
     47    MODECASE(LAPTOOL_MODE_DEFINERUN,     definerunMode);
     48    MODECASE(LAPTOOL_MODE_PENDINGRUN,    pendingrunMode);
     49    MODECASE(LAPTOOL_MODE_UPDATERUN,     updaterunMode);
     50
     51    MODECASE(LAPTOOL_MODE_PENDINGCHIPEXP,   pendingchipexpMode);
     52    MODECASE(LAPTOOL_MODE_PENDINGQUICKSTACK,pendingquickstackMode);
     53    MODECASE(LAPTOOL_MODE_PENDINGDIFF,      pendingdiffMode);
     54    MODECASE(LAPTOOL_MODE_PENDINGFINALSTACK,pendingfinalstackMode);
     55    MODECASE(LAPTOOL_MODE_UPDATEEXP,        updateexpMode);
    5656  default:
    5757    psAbort("invalid option (this should not happen)");
    5858  }
    59   psTrace("reproctool", 9, "Attempting to free config\n");
     59  psTrace("laptool", 9, "Attempting to free config\n");
    6060  psFree(config);
    6161  pmConfigDone();
    … …  
    8686
    8787  // Insert the run
    88   if (!reprocRunInsert(config->dbh,
    89                        NULL,  // re_id
     88  if (!lapRunInsert(config->dbh,
     89                       NULL,  // lap_id
    9090                       projection_cell,
    9191                       tess_id,
    … …  
    105105    return false;
    106106  }
    107   psS64 re_id = psDBLastInsertID(config->dbh);
     107  psS64 lap_id = psDBLastInsertID(config->dbh);
    108108
    109109
    110110  // Find the input exposures
    111   psString query = pxDataGet("reproctool_definerun.sql");
     111  psString query = pxDataGet("laptool_definerun.sql");
    112112  if (!query) {
    113113    psError(PXTOOL_ERR_SYS, false, "failed to retrieve SQL statement");
    … …  
    135135  }
    136136  if (!psArrayLength(output)) {
    137     psTrace("reproctool", PS_LOG_INFO, "no rows found");
     137    psTrace("laptool", PS_LOG_INFO, "no rows found");
    138138    psFree(output);
    139139    return(true);
    … …  
    145145    psMetadata *row = output->data[i]; // Row from select
    146146    bool status;
    147     reprocExpRow *reExp = reprocExpObjectFromMetadata(row);
    148     reExp->re_id = re_id;
    149 
    150     if (!reprocExpInsertObject(config->dbh,reExp)) {
     147    lapExpRow *reExp = lapExpObjectFromMetadata(row);
     148    reExp->lap_id = lap_id;
     149
     150    if (!lapExpInsertObject(config->dbh,reExp)) {
    151151      if (!psDBRollback(config->dbh)) {
    152152        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    169169 
    170170  psmetadata *where = psMetadataAlloc();
    171   PXOPT_COPY_S64(config->args, where, "-re_id", "re_id", "==");
     171  PXOPT_COPY_S64(config->args, where, "-lap_id", "lap_id", "==");
    172172  PXOPT_COPY_STR(config->args, where, "-projection_cell", "projection_cell", "==");
    173173
    174   psString query = pxDataGet("reproctool_pendingrun.sql");
     174  psString query = pxDataGet("laptool_pendingrun.sql");
    175175  if (!query) {
    176176    psError(PXTOOL_ERR_SYS, false, "failed to retrieve SQL statement");
    … …  
    205205  }
    206206  if (!psArrayLength(output)) {
    207     psTrace("reproctool", PS_LOG_INFO, "no rows found");
    208     psFree(output);
    209     return(true);
    210   }
    211  
    212   if (!ippdbPrintMetadatas(stdout, output, "reprocExp", !simple)) {
     207    psTrace("laptool", PS_LOG_INFO, "no rows found");
     208    psFree(output);
     209    return(true);
     210  }
     211 
     212  if (!ippdbPrintMetadatas(stdout, output, "lapExp", !simple)) {
    213213    psError(PS_ERR_UNKNOWN, false, "failed to print array");
    214214    psFree(output);
    … …  
    225225
    226226  psMetadata *where = psMetadataAlloc();
    227   PXOPT_LOOKUP_S64(re_id, config->args, "-re_id", true, false);
     227  PXOPT_LOOKUP_S64(lap_id, config->args, "-lap_id", true, false);
    228228  PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    229229  PXOPT_LOOKUP_STR(set_state, config->args, "-set_state", false, false);
    … …  
    235235
    236236  psMetadata *where = psMetadataAlloc();
    237   PXOPT_COPY_S64(config->args, where, "-re_id", "re_id", "==");
     237  PXOPT_COPY_S64(config->args, where, "-lap_id", "lap_id", "==");
    238238
    239239  // Set a fault
    240240  if (fault != INT16_MAX) {
    241241    // this is fairly dangerous : can set all if the where is not set...
    242     if (!pxSetFaultCode(config->dbh, "reprocRun", where, fault, 0)) {
     242    if (!pxSetFaultCode(config->dbh, "lapRun", where, fault, 0)) {
    243243      psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    244244      psFree (where);
    … …  
    255255    // Deactivate exposures
    256256
    257     psString query = pxDataGet("reproctool_updaterun_deactivate.sql");
     257    psString query = pxDataGet("laptool_updaterun_deactivate.sql");
    258258    if (!query) {
    259259      psError(PXTOOL_ERR_SYS, false, "failed to retrieve SQL statement");
    … …  
    270270  }
    271271
    272   char *query = "UPDATE reprocRun SET state = '%s' WHERE re_id = %"PRId64;
    273   if (!p_psDBRunQueryF(config->dbh, query, state, re_id)) {
     272  char *query = "UPDATE lapRun SET state = '%s' WHERE lap_id = %"PRId64;
     273  if (!p_psDBRunQueryF(config->dbh, query, state, lap_id)) {
    274274    psError(PS_ERR_UNKNOWN, false,
    275             "failed to change state for re_id %"PRId64, re_id);
     275            "failed to change state for lap_id %"PRId64, lap_id);
    276276    return(false);
    277277  }
    … …  
    280280}
    281281// Exposure level
    282 static bool pendingchipexpMode(pxConfig *config)
    283 {
    284   PS_ASSERT_PTR_NON_NULL(config, false);
    285  
     282
     283static bool exposuresMode(pxConfig *config)
     284{
     285  PS_ASSERT_PTR_NON_NULL(config, false);
    286286  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    287287 
    288288  psmetadata *where = psMetadataAlloc();
    289   PXOPT_COPY_S64(config->args, where, "-re_id", "re_id", "==");
    290   PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    291 
    292   psString query = pxDataGet("reproctool_pendingchipexp.sql");
     289  PXOPT_COPY_S64(config->args, where, "-lap_id", "lap_id", "==");
     290
     291  psString query = pxDataGet("laptool_exposures.sql");
    293292  if (!query) {
    294293    psError(PXTOOL_ERR_SYS, false, "failed to retrieve SQL statement");
    … …  
    323322  }
    324323  if (!psArrayLength(output)) {
    325     psTrace("reproctool", PS_LOG_INFO, "no rows found");
    326     psFree(output);
    327     return(true);
    328   }
    329  
    330   if (!ippdbPrintMetadatas(stdout, output, "reprocExp", !simple)) {
     324    psTrace("laptool", PS_LOG_INFO, "no rows found");
     325    psFree(output);
     326    return(true);
     327  }
     328 
     329  if (!ippdbPrintMetadatas(stdout, output, "lapExp", !simple)) {
    331330    psError(PS_ERR_UNKNOWN, false, "failed to print array");
    332331    psFree(output);
    … …  
    337336  return(true);
    338337 
    339 
    340 }
    341 static bool pendingquickstackMode(pxConfig *config)
    342 {
    343   PS_ASSERT_PTR_NON_NULL(config, false);
     338}
     339
     340
     341static bool pendingchipexpMode(pxConfig *config)
     342{
     343  PS_ASSERT_PTR_NON_NULL(config, false);
     344 
    344345  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    345346 
    346347  psmetadata *where = psMetadataAlloc();
    347   PXOPT_COPY_S64(config->args, where, "-re_id", "re_id", "==");
     348  PXOPT_COPY_S64(config->args, where, "-lap_id", "lap_id", "==");
    348349  PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    349350
    350   psString query = pxDataGet("reproctool_pendingquickstack.sql");
     351  psString query = pxDataGet("laptool_pendingchipexp.sql");
    351352  if (!query) {
    352353    psError(PXTOOL_ERR_SYS, false, "failed to retrieve SQL statement");
    … …  
    381382  }
    382383  if (!psArrayLength(output)) {
    383     psTrace("reproctool", PS_LOG_INFO, "no rows found");
    384     psFree(output);
    385     return(true);
    386   }
    387  
    388   if (!ippdbPrintMetadatas(stdout, output, "reprocExp", !simple)) {
     384    psTrace("laptool", PS_LOG_INFO, "no rows found");
     385    psFree(output);
     386    return(true);
     387  }
     388 
     389  if (!ippdbPrintMetadatas(stdout, output, "lapExp", !simple)) {
    389390    psError(PS_ERR_UNKNOWN, false, "failed to print array");
    390391    psFree(output);
    … …  
    397398
    398399}
    399 static bool pendingdiffMode(pxConfig *config)
     400static bool pendingquickstackMode(pxConfig *config)
    400401{
    401402  PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    403404 
    404405  psmetadata *where = psMetadataAlloc();
    405   PXOPT_COPY_S64(config->args, where, "-re_id", "re_id", "==");
     406  PXOPT_COPY_S64(config->args, where, "-lap_id", "lap_id", "==");
    406407  PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    407408
    408   psString query = pxDataGet("reproctool_pendingdiff.sql");
     409  psString query = pxDataGet("laptool_pendingquickstack.sql");
    409410  if (!query) {
    410411    psError(PXTOOL_ERR_SYS, false, "failed to retrieve SQL statement");
    … …  
    439440  }
    440441  if (!psArrayLength(output)) {
    441     psTrace("reproctool", PS_LOG_INFO, "no rows found");
    442     psFree(output);
    443     return(true);
    444   }
    445  
    446   if (!ippdbPrintMetadatas(stdout, output, "reprocExp", !simple)) {
     442    psTrace("laptool", PS_LOG_INFO, "no rows found");
     443    psFree(output);
     444    return(true);
     445  }
     446 
     447  if (!ippdbPrintMetadatas(stdout, output, "lapExp", !simple)) {
    447448    psError(PS_ERR_UNKNOWN, false, "failed to print array");
    448449    psFree(output);
    … …  
    455456
    456457}
    457 static bool pendingfinalstackMode(pxConfig *config)
     458static bool pendingdiffMode(pxConfig *config)
    458459{
    459460  PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    461462 
    462463  psmetadata *where = psMetadataAlloc();
    463   PXOPT_COPY_S64(config->args, where, "-re_id", "re_id", "==");
     464  PXOPT_COPY_S64(config->args, where, "-lap_id", "lap_id", "==");
    464465  PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    465466
    466   psString query = pxDataGet("reproctool_pendingfinalstack.sql");
     467  psString query = pxDataGet("laptool_pendingdiff.sql");
    467468  if (!query) {
    468469    psError(PXTOOL_ERR_SYS, false, "failed to retrieve SQL statement");
    … …  
    497498  }
    498499  if (!psArrayLength(output)) {
    499     psTrace("reproctool", PS_LOG_INFO, "no rows found");
    500     psFree(output);
    501     return(true);
    502   }
    503  
    504   if (!ippdbPrintMetadatas(stdout, output, "reprocExp", !simple)) {
     500    psTrace("laptool", PS_LOG_INFO, "no rows found");
     501    psFree(output);
     502    return(true);
     503  }
     504 
     505  if (!ippdbPrintMetadatas(stdout, output, "lapExp", !simple)) {
    505506    psError(PS_ERR_UNKNOWN, false, "failed to print array");
    506507    psFree(output);
    … …  
    513514
    514515}
     516static bool pendingfinalstackMode(pxConfig *config)
     517{
     518  PS_ASSERT_PTR_NON_NULL(config, false);
     519  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     520 
     521  psmetadata *where = psMetadataAlloc();
     522  PXOPT_COPY_S64(config->args, where, "-lap_id", "lap_id", "==");
     523  PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
     524
     525  psString query = pxDataGet("laptool_pendingfinalstack.sql");
     526  if (!query) {
     527    psError(PXTOOL_ERR_SYS, false, "failed to retrieve SQL statement");
     528    return(false);
     529  }
     530  psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     531  if (whereClause) {
     532    psStringPrepend(&whereClause, "\n AND ");
     533  }
     534 
     535  psString limitString = NULL;
     536  if (limit) {
     537    limitString = psDBGenerateLimitSQL(limit);
     538    psStringPrepend(&limitString, "\n");
     539  }
     540
     541  if (!p_psDBRunQueryF(config->dbh, query, whereClause, limitString ? limitString : "")) {
     542    psError(PXTOOLS_ERR_PROG, false, "database error");
     543    psFree(limitString);
     544    psFree(query);
     545    psFree(whereClause);
     546    return(false);
     547  }
     548  psFree(limitString);
     549  psFree(query);
     550  psFree(whereClause);
     551 
     552  psArray *output = p_psDBFetchResult(config->dbh);
     553  if (!output) {
     554    psError(PS_ERR_UNKNOWN, false, "database error");
     555    return(false);
     556  }
     557  if (!psArrayLength(output)) {
     558    psTrace("laptool", PS_LOG_INFO, "no rows found");
     559    psFree(output);
     560    return(true);
     561  }
     562 
     563  if (!ippdbPrintMetadatas(stdout, output, "lapExp", !simple)) {
     564    psError(PS_ERR_UNKNOWN, false, "failed to print array");
     565    psFree(output);
     566    return(false);
     567  }
     568
     569  psFree(output);
     570  return(true);
     571 
     572
     573}
    515574static bool updateexpMode(pxConfig *config)
    516575{
    … …  
    518577
    519578  psMetadata *where = psMetadataAlloc();
    520   PXOPT_LOOKUP_S64(re_id, config->args, "-re_id", true, false);
     579  PXOPT_LOOKUP_S64(lap_id, config->args, "-lap_id", true, false);
    521580  PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", true, false);
    522581  PXOPT_LOOKUP_S64(chip_id, config->args, "-chip_id", false, false);
    … …  
    532591
    533592  psMetadata *where = psMetadataAlloc();
    534   PXOPT_COPY_S64(config->args, where, "-re_id", "re_id", "==");
     593  PXOPT_COPY_S64(config->args, where, "-lap_id", "lap_id", "==");
    535594  PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    536595  PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
    … …  
    550609  }
    551610
    552   long rows = psDBUpdateRows(config->dbh,"reprocExp",where,values);
     611  long rows = psDBUpdateRows(config->dbh,"lapExp",where,values);
    553612  if (rows) {
    554613    return(true);

  • branches/czw_branch/20110406/ippTools/src/laptool.h

    r31338 r31385  
    11/*
    2  * reproctool.h
     2 * laptool.h
    33 */
    44
    5 #ifndef REPROCTOOL_H
    6 #define REPROCTOOL_H 1
     5#ifndef LAPTOOL_H
     6#define LAPTOOL_H 1
    77
    88#include "pxtools.h"
    99
    1010typedef enum {
    11   REPROCTOOL_MODE_DEFINERUN          = 0x0,
    12   REPROCTOOL_MODE_PENDINGRUN,       
    13   REPROCTOOL_MODE_PENDINGCHIPEXP,   
    14   REPROCTOOL_MODE_PENDINGQUICKSTACK,
    15   REPROCTOOL_MODE_PENDINGDIFF,     
    16   REPROCTOOL_MODE_PENDINGFINALSTACK,
    17   REPROCTOOL_MODE_UPDATERUN,       
    18   REPROCTOOL_MODE_UPDATEEXP
    19 } reproctoolMode;
     11  LAPTOOL_MODE_DEFINERUN          = 0x0,
     12  LAPTOOL_MODE_PENDINGRUN,
     13  LAPTOOL_MODE_EXPOSURES,
     14  LAPTOOL_MODE_PENDINGCHIPEXP,   
     15  LAPTOOL_MODE_PENDINGQUICKSTACK,
     16  LAPTOOL_MODE_PENDINGDIFF,     
     17  LAPTOOL_MODE_PENDINGFINALSTACK,
     18  LAPTOOL_MODE_UPDATERUN,       
     19  LAPTOOL_MODE_UPDATEEXP
     20} laptoolMode;
    2021
    21 pxConfig *reproctoolConfig(pxConfig *config, int argc, char **argv);
     22pxConfig *laptoolConfig(pxConfig *config, int argc, char **argv);
    2223
    23 #endif // REPROCTOOL_H
     24#endif // LAPTOOL_H
    2425
    2526

  • branches/czw_branch/20110406/ippTools/src/laptoolConfig.c

    r31338 r31385  
    11/*
    2  * reproctoolConfig.c
     2 * laptoolConfig.c
    33 */
    44
    … …  
    1616#define ADD_OPT(TYPE,TARG,NAME,COMMENT,DEFAULT) psMetadataAdd##TYPE(TARG, PS_LIST_TAIL, NAME, 0, COMMENT, DEFAULT)
    1717
    18 pxConfig *reproctoolConfig(pxConfig *config, int argc, char **argv)
     18pxConfig *laptoolConfig(pxConfig *config, int argc, char **argv)
    1919{
    2020  if (!config) {
    … …  
    4343  psMetadata *pendingrunArgs = psMetadataAlloc();
    4444  ADD_OPT(Str, pendingrunArgs, "-projection_cell",            "projection cell to consider", NULL);
    45   ADD_OPT(S64, pendingrunArgs, "-re_id",                      "reprocessing run ID", 0);
     45  ADD_OPT(S64, pendingrunArgs, "-lap_id",                      "lap run ID", 0);
    4646  ADD_OPT(U64, pendingrunArgs, "-limit",                      "limit result set to N items", 0);
    4747  ADD_OPT(Bool,pendingrunArgs, "-simple",                     "use the simple output format", false);
    48  
    49   // -pendingchipexp
     48
     49  // -exposures
     50  psMetadata *exposuresArgs = psMetadataAlloc();
     51  ADD_OPT(S64, exposuresArgs, "-lap_id",                       "search by lap run ID", 0);
     52  ADD_OPT(Bool,exposuresArgs, "-simple",                       "use the simple output format", false);
     53
     54  // -pendingexp
    5055  psMetadata *pendingchipexpArgs = psMetadataAlloc();
    51   ADD_OPT(S64, pendingchipexpArgs, "-re_id",                  "search by reprocessing run ID", 0);
     56  ADD_OPT(S64, pendingchipexpArgs, "-lap_id",                  "search by lap run ID", 0);
    5257  ADD_OPT(Str, pendingchipexpArgs, "-filter",                 "search by filter", 0);
    5358  ADD_OPT(Bool,pendingchipexpArgs, "-simple",                 "use the simple output format", false);
     59
    5460 
    5561  // -pendingquickstack
    5662  psMetadata *pendingquickstackArgs = psMetadataAlloc();
    57   ADD_OPT(S64, pendingquickstackArgs, "-re_id",               "search by reprocessing run ID", 0);
     63  ADD_OPT(S64, pendingquickstackArgs, "-lap_id",               "search by lap run ID", 0);
    5864  ADD_OPT(Str, pendingquickstackArgs, "-filter",              "search by filter", 0);
    5965  ADD_OPT(Bool,pendingquickstackArgs, "-simple",              "use the simple output format", false);
    … …  
    6167  // -pendingdiff
    6268  psMetadata *pendingdiffArgs = psMetadataAlloc();
    63   ADD_OPT(S64, pendingdiffArgs, "-re_id",                    "search by reprocessing run ID", 0);
     69  ADD_OPT(S64, pendingdiffArgs, "-lap_id",                    "search by lap run ID", 0);
    6470  ADD_OPT(Str, pendingdiffArgs, "-filter",                   "search by filter", 0);
    6571  ADD_OPT(Bool,pendingdiffArgs, "-simple",                   "use the simple output format", false);
    … …  
    6773  // -pendingfinalstack
    6874  psMetadata *pendingfinalstackArgs = psMetadataAlloc();
    69   ADD_OPT(S64, pendingfinalstackArgs, "-re_id",               "search by reprocessing run ID", 0);
     75  ADD_OPT(S64, pendingfinalstackArgs, "-lap_id",               "search by lap run ID", 0);
    7076  ADD_OPT(Str, pendingfinalstackArgs, "-filter",              "search by filter", 0);
    7177  ADD_OPT(Bool,pendingfinalstackArgs, "-simple",              "use the simple output format", false);
    … …  
    7379  // -updaterun
    7480  psMetadata *updaterunArgs = psMetadataAlloc();
    75   ADD_OPT(S64, updaterunArgs, "-re_id",                       "search by reprocessing run ID", 0);
     81  ADD_OPT(S64, updaterunArgs, "-lap_id",                       "search by lap run ID", 0);
    7682  ADD_OPT(Str, updaterunArgs, "-set_state",                   "set state", NULL);
    7783  ADD_OPT(S16, updaterunArgs, "-fault",                       "set fault code", INT16_MAX);
    … …  
    7985  // -updateexp
    8086  psMetadata *updateexpArgs = psMetadataAlloc();
    81   ADD_OPT(S64, updateexpArgs, "-re_id",                       "search by reprocessing run ID", 0);
     87  ADD_OPT(S64, updateexpArgs, "-lap_id",                       "search by lap run ID", 0);
    8288  ADD_OPT(S64, updateexpArgs, "-exp_id",                      "search by exposure ID", 0);
    8389  ADD_OPT(S64, updateexpArgs, "-chip_id",                     "search by chip ID", 0);
    … …  
    9298  psMetadata *modes = psMetadataAlloc();
    9399
    94   PXOPT_ADD_MODE("-definerun",               "", REPROCTOOL_MODE_DEFINERUN,        definerunArgs);
    95   PXOPT_ADD_MODE("-pendingrun",              "", REPROCTOOL_MODE_PENDINGRUN,       pendingrunArgs);
    96   PXOPT_ADD_MODE("-pendingchipexp",          "", REPROCTOOL_MODE_PENDINGCHIPEXP,   pendingchipexpArgs);
    97   PXOPT_ADD_MODE("-pendingquickstack",       "", REPROCTOOL_MODE_PENDINGQUICKSTACK,pendingquickstackArgs);
    98   PXOPT_ADD_MODE("-pendingdiff",             "", REPROCTOOL_MODE_PENDINGDIFF,      pendingdiffArgs);
    99   PXOPT_ADD_MODE("-pendingfinalstack",       "", REPROCTOOL_MODE_PENDINGFINALSTACK,pendingfinalstackArgs);
    100   PXOPT_ADD_MODE("-updaterun",               "", REPROCTOOL_MODE_UPDATERUN,        updaterunArgs);
    101   PXOPT_ADD_MODE("-updateexp",               "", REPROCTOOL_MODE_UPDATEEXP,        updateexpArgs);
     100  PXOPT_ADD_MODE("-definerun",               "", LAPTOOL_MODE_DEFINERUN,        definerunArgs);
     101  PXOPT_ADD_MODE("-pendingrun",              "", LAPTOOL_MODE_PENDINGRUN,       pendingrunArgs);
     102  PXOPT_ADD_MODE("-exposures",               "", LAPTOOL_MODE_EXPOSURES,        exposuresArgs);
     103  PXOPT_ADD_MODE("-pendingchipexp",          "", LAPTOOL_MODE_PENDINGCHIPEXP,   pendingchipexpArgs);
     104  PXOPT_ADD_MODE("-pendingquickstack",       "", LAPTOOL_MODE_PENDINGQUICKSTACK,pendingquickstackArgs);
     105  PXOPT_ADD_MODE("-pendingdiff",             "", LAPTOOL_MODE_PENDINGDIFF,      pendingdiffArgs);
     106  PXOPT_ADD_MODE("-pendingfinalstack",       "", LAPTOOL_MODE_PENDINGFINALSTACK,pendingfinalstackArgs);
     107  PXOPT_ADD_MODE("-updaterun",               "", LAPTOOL_MODE_UPDATERUN,        updaterunArgs);
     108  PXOPT_ADD_MODE("-updateexp",               "", LAPTOOL_MODE_UPDATEEXP,        updateexpArgs);
    102109
    103110  if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/czw_branch/20110406/pstamp/scripts/detectability_respond.pl

    r31217 r31385  
    217217            $query{$fpa_id}{FAULT}[$i] = 'no_fault';
    218218            $query{$fpa_id}{BURNTOOL_STATE}[$i] = 'no_btstate';
     219            $query{$fpa_id}{PROC_ERROR}[$i] = 0;
    219220        }
    220221
    … …  
    227228        }
    228229        elsif ($fpa_id eq 'Not_Set') {
     230           
    229231            next;
    230232        }
    … …  
    413415        my $stage = $query{$fpa_id}{STAGE}[$index];
    414416        # if there's a fault, then we can't process this image.
    415         if (($fault != 0)||($query{$fpa_id}{BAD_COMPONENT}[$index] == 1)) {
     417        if (($fault != 0)||($query{$fpa_id}{BAD_COMPONENT}[$index] == 1)||
     418            ($fpa_id eq 'Not_Set')) {
    416419            $query{$fpa_id}{PROC_ERROR}[$index] = 23;
    417420           
    … …  
    713716   
    714717    # Fill the table columns with the data, making sure the flux is defined
    715     foreach my $fpa_id (keys %query) {
     718    foreach my $fpa_id (sort {$query{$a}{ROWNUM}[0] <=> $query{$b}{ROWNUM}[0] } (keys %query)) {
     719        if ($fpa_id eq 'Not_Set') {
     720            foreach my $index (@{ $query{$a}{ROWNUM} }) {
     721                push @{ $query{$fpa_id}{PROC_ERROR} }, 23;
     722                push @{ $query{$fpa_id}{NPIX} }, -1;
     723                push @{ $query{$fpa_id}{QFACTOR} }, -1;
     724                push @{ $query{$fpa_id}{FLUX} }, -9999;
     725                push @{ $query{$fpa_id}{FLUX_SIG} }, -9999;
     726            }
     727        }
    716728        $inHeader->{QUERY_ID}->{value} = $query{$fpa_id}{QUERY_ID}[0];
    717729        if ($EXTVER_IS_1 == 1) {
    … …  
    720732        }
    721733       
     734        print "BADPLACE: $fpa_id\n";
    722735        push @{$colData{'ROWNUM'}}, @{ $query{$fpa_id}{ROWNUM} };
    723736        push @{$colData{'ERROR_CODE'}}, @{ $query{$fpa_id}{PROC_ERROR} };
Note: See TracChangeset for help on using the changeset viewer.