IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 11723


Ignore:
Timestamp:
Feb 8, 2007, 3:21:15 PM (19 years ago)
Author:
jhoblitt
Message:

partial impliementation of new p4 design

Location:
trunk/ippTools
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/configure.ac

    r11625 r11723  
    1616AC_PROG_LIBTOOL
    1717
    18 PKG_CHECK_MODULES([PSLIB], [pslib >= 1.0.0])
    19 PKG_CHECK_MODULES([PSMODULES], [psmodules >= 1.0.0])
    20 PKG_CHECK_MODULES([IPPDB], [ippdb >= 1.0.0])
     18PKG_CHECK_MODULES([PSLIB], [pslib >= 1.1.0])
     19PKG_CHECK_MODULES([PSMODULES], [psmodules >= 1.1.0])
     20PKG_CHECK_MODULES([IPPDB], [ippdb >= 1.1.3])
    2121
    2222PXTOOLS_CFLAGS="${PSLIB_CFLAGS=} ${PSMODULES_CFLAGS=} ${IPPDB_CFLAGS=}"

  • trunk/ippTools/src/pxtables.c

    r11047 r11723  
    7979    CREATE_TABLE(detResidExpCreateTable);
    8080    CREATE_TABLE(detRunSummaryCreateTable);
     81    CREATE_TABLE(skyCellCreateTable);
     82    CREATE_TABLE(skyCellMapCreateTable);
    8183    CREATE_TABLE(p4RunCreateTable);
    82     CREATE_TABLE(p4InputImfileCreateTable);
    83     CREATE_TABLE(p4WarpedImfileCreateTable);
    84     CREATE_TABLE(p4StackedImfileCreateTable);
    85     CREATE_TABLE(p4DiffImfileCreateTable);
    86     CREATE_TABLE(p4MagicMaskImfileCreateTable);
     84    CREATE_TABLE(p4InputExpCreateTable);
     85    CREATE_TABLE(p4ScfileCreateTable);
     86    CREATE_TABLE(p4InputScfileCreateTable);
     87    CREATE_TABLE(p4DiffScfileCreateTable);
    8788
    8889    return true;
    … …  
    152153    DROP_TABLE(detRunSummaryDropTable);
    153154    DROP_TABLE(p4RunDropTable);
    154     DROP_TABLE(p4InputImfileDropTable);
    155     DROP_TABLE(p4WarpedImfileDropTable);
    156     DROP_TABLE(p4StackedImfileDropTable);
    157     DROP_TABLE(p4DiffImfileDropTable);
    158     DROP_TABLE(p4MagicMaskImfileDropTable);
     155    DROP_TABLE(p4InputExpDropTable);
     156    DROP_TABLE(p4ScfileDropTable);
     157    DROP_TABLE(p4InputScfileDropTable);
     158    DROP_TABLE(p4DiffScfileDropTable);
    159159
    160160    return status;

  • trunk/ippTools/src/warptool.c

    r11702 r11723  
    3232
    3333static bool definerunMode(pxConfig *config);
    34 static bool addinputimfileMode(pxConfig *config);
    35 static bool towarpedimfileMode(pxConfig *config);
    36 static bool addwarpedimfileMode(pxConfig *config);
    37 static bool warpedimfileMode(pxConfig *config);
     34static bool addinputexpMode(pxConfig *config);
     35static bool toscfileMode(pxConfig *config);
     36static bool addscfileMode(pxConfig *config);
     37static bool scfileMode(pxConfig *config);
    3838static bool tostackedimfileMode(pxConfig *config);
    39 static bool addstackedimfileMode(pxConfig *config);
     39//static bool addstackedimfileMode(pxConfig *config);
    4040static bool stackedimfileMode(pxConfig *config);
    4141static bool todiffimfileMode(pxConfig *config);
    42 static bool adddiffimfileMode(pxConfig *config);
     42//static bool adddiffimfileMode(pxConfig *config);
    4343static bool diffimfileMode(pxConfig *config);
    4444
    … …  
    5858    switch (config->mode) {
    5959        MODECASE(P4TOOL_MODE_DEFINERUN,         definerunMode);
    60         MODECASE(P4TOOL_MODE_ADDINPUTIMFILE,    addinputimfileMode);
    61         MODECASE(P4TOOL_MODE_TOWARPEDIMFILE,    towarpedimfileMode);
    62         MODECASE(P4TOOL_MODE_ADDWARPEDIMFILE,   addwarpedimfileMode);
    63         MODECASE(P4TOOL_MODE_WARPEDIMFILE,      warpedimfileMode);
     60        MODECASE(P4TOOL_MODE_ADDINPUTEXP,       addinputexpMode);
     61        MODECASE(P4TOOL_MODE_TOSCFILE,          toscfileMode);
     62        MODECASE(P4TOOL_MODE_ADDSCFILE,         addscfileMode);
     63        MODECASE(P4TOOL_MODE_SCFILE,            scfileMode);
    6464        MODECASE(P4TOOL_MODE_TOSTACKEDIMFILE,   tostackedimfileMode);
    65         MODECASE(P4TOOL_MODE_ADDSTACKEDIMFILE,  addstackedimfileMode);
     65//        MODECASE(P4TOOL_MODE_ADDSTACKEDIMFILE,  addstackedimfileMode);
    6666        MODECASE(P4TOOL_MODE_STACKEDIMFILE,     stackedimfileMode);
    6767        MODECASE(P4TOOL_MODE_TODIFFIMFILE,      todiffimfileMode);
    68         MODECASE(P4TOOL_MODE_ADDDIFFIMFILE,     adddiffimfileMode);
     68//        MODECASE(P4TOOL_MODE_ADDDIFFIMFILE,     adddiffimfileMode);
    6969        MODECASE(P4TOOL_MODE_DIFFIMFILE,        diffimfileMode);
    7070        default:
    … …  
    9494    // required options
    9595    bool status = false;
    96     psString survey_mode = psMetadataLookupStr(&status, config->args, "-survey_mode");
     96    psString mode = psMetadataLookupStr(&status, config->args, "-mode");
    9797    if (!status) {
    9898        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -survey_mode");
    9999        return false;
    100100    }
    101     if (!survey_mode) {
    102         psError(PS_ERR_UNKNOWN, true, "-survery_mode is required");
     101    if (!mode) {
     102        psError(PS_ERR_UNKNOWN, true, "-mode is required");
    103103        return false;
    104104    }
    … …  
    111111    if (!workdir) {
    112112        psError(PS_ERR_UNKNOWN, true, "-workdir is required");
    113         return false;
    114     }
    115 
    116     psString filter = psMetadataLookupStr(&status, config->args, "-filter");
    117     if (!status) {
    118         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filter");
    119         return false;
    120     }
    121     if (!filter) {
    122         psError(PS_ERR_UNKNOWN, true, "-survery_mode is required");
    123         return false;
    124     }
    125 
    126     psString skycell_id = psMetadataLookupStr(&status, config->args, "-skycell_id");
    127     if (!status) {
    128         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -skycell_id");
    129         return false;
    130     }
    131     if (!skycell_id) {
    132         psError(PS_ERR_UNKNOWN, true, "-survery_mode is required");
    133         return false;
    134     }
    135 
    136     psString tess_id = psMetadataLookupStr(&status, config->args, "-tess_id");
    137     if (!status) {
    138         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -tess_id");
    139         return false;
    140     }
    141     if (!tess_id) {
    142         psError(PS_ERR_UNKNOWN, true, "-survery_mode is required");
    143         return false;
    144     }
    145 
    146     psS32 imfiles = psMetadataLookupS32(&status, config->args, "-imfiles");
    147     if (!status) {
    148         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -imfiles");
    149         return false;
    150     }
    151     if (imfiles < 1) {
    152         psError(PS_ERR_UNKNOWN, true, "-imfiles is required");
    153         return false;
    154     }
    155 
    156     // optional options
    157     psF64 ra = psMetadataLookupS32(&status, config->args, "-ra");
    158     if (!status) {
    159         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ra");
    160         return false;
    161     }
    162 
    163     psF64 decl = psMetadataLookupS32(&status, config->args, "-decl");
    164     if (!status) {
    165         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -decl");
    166         return false;
    167     }
    168 
    169     psString input_ss = psMetadataLookupStr(&status, config->args, "-input_ss");
    170     if (!status) {
    171         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -input_ss");
    172         return false;
    173     }
    174 
    175     psString output_ss = psMetadataLookupStr(&status, config->args, "-output_ss");
    176     if (!status) {
    177         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -output_ss");
    178113        return false;
    179114    }
    … …  
    195130
    196131    p4RunRow *p4Run = p4RunRowAlloc(
    197             0,
    198             survey_mode,
    199             "run",
     132            0,          // ID
     133            mode,
     134            "reg",      // state
    200135            workdir,
    201             filter,
    202             skycell_id,
    203             tess_id,
    204             ra,
    205             decl,
    206             input_ss,
    207             output_ss
     136            registered
    208137    );
    209138    psFree(registered);
    … …  
    240169}
    241170
    242 static bool addinputimfileMode(pxConfig *config)
     171static bool addinputexpMode(pxConfig *config)
    243172{
    244173    PS_ASSERT_PTR_NON_NULL(config, NULL);
    … …  
    265194    }
    266195
    267     psString class_id = psMetadataLookupStr(&status, config->args, "-class_id");
    268     if (!status) {
    269         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -class_id");
    270         return false;
    271     }
    272     if (!class_id) {
    273         psError(PS_ERR_UNKNOWN, true, "-class_id is required");
    274         return false;
    275     }
    276 
    277196    // defaults to 0
    278197    psS32 p3_version = psMetadataLookupS32(&status, config->args, "-p3_version");
    … …  
    282201    }
    283202
     203    // defaults to false
     204    bool magiced = psMetadataLookupBool(&status, config->args, "-p3_version");
     205    if (!status) {
     206        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -p3_version");
     207        return false;
     208    }
     209
    284210    // XXX need to validate the p4_id here
    285     if (!p4InputImfileInsert(config->dbh,
     211    if (!p4InputExpInsert(config->dbh,
    286212            (psS32)atoi(p4_id),
    287213            exp_tag,
    288214            p3_version,
    289             class_id
     215            magiced
    290216        )) {
    291217        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    296222}
    297223
    298 static bool towarpedimfileMode(pxConfig *config)
     224static bool toscfileMode(pxConfig *config)
    299225{
    300226    PS_ASSERT_PTR_NON_NULL(config, NULL);
    … …  
    326252
    327253    if (config->where) {
    328         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "p4InputImfile");
     254        psString whereClause = psDBGenerateWhereConditionSQL(config->where, "p4InputExp");
    329255        psStringAppend(&query, " AND %s", whereClause);
    330256        psFree(whereClause);
    … …  
    360286
    361287    // negative simple so the default is true
    362     if (!ippdbPrintMetadatas(stdout, output, "p4InputImfile", !simple)) {
     288    if (!ippdbPrintMetadatas(stdout, output, "p4InputExp", !simple)) {
    363289        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    364290        psFree(output);
    … …  
    371297}
    372298
    373 static bool addwarpedimfileMode(pxConfig *config)
     299static bool addscfileMode(pxConfig *config)
    374300{
    375301    PS_ASSERT_PTR_NON_NULL(config, NULL);
    … …  
    386312    }
    387313
     314    psString skycell_id = psMetadataLookupStr(&status, config->args, "-skycell_id");
     315    if (!status) {
     316        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -skycell_id");
     317        return false;
     318    }
     319    if (!skycell_id) {
     320        psError(PS_ERR_UNKNOWN, true, "-skycell_id is required");
     321        return false;
     322    }
     323
     324    psString tess_id = psMetadataLookupStr(&status, config->args, "-tess_id");
     325    if (!status) {
     326        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -tess_id");
     327        return false;
     328    }
     329    if (!tess_id) {
     330        psError(PS_ERR_UNKNOWN, true, "-tess_id is required");
     331        return false;
     332    }
     333
    388334    psString exp_tag = psMetadataLookupStr(&status, config->args, "-exp_tag");
    389335    if (!status) {
    … …  
    396342    }
    397343
    398     psString class_id = psMetadataLookupStr(&status, config->args, "-class_id");
    399     if (!status) {
    400         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -class_id");
    401         return false;
    402     }
    403     if (!class_id) {
    404         psError(PS_ERR_UNKNOWN, true, "-class_id is required");
    405         return false;
    406     }
    407 
    408344    psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    409345    if (!status) {
    … …  
    424360
    425361    // optional
    426     psString b1_uri = psMetadataLookupStr(&status, config->args, "-b1_uri");
    427     if (!status) {
    428         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -b1_uri");
    429         return false;
    430     }
    431 
    432     psString b2_uri = psMetadataLookupStr(&status, config->args, "-b2_uri");
    433     if (!status) {
    434         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -b2_uri");
    435         return false;
    436     }
     362    psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
     363    if (!status) {
     364        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
     365        return false;
     366    }
     367
     368    psF64 bg_mean_stdev = psMetadataLookupF64(&status, config->args, "-bg_mean_stdev");
     369    if (!status) {
     370        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_mean_stdev");
     371        return false;
     372    }
     373
    437374
    438375    // XXX need to validate that this coresponds to an p4InputImfile
    439     if (!p4WarpedImfileInsert(config->dbh,
     376    if (!p4ScfileInsert(config->dbh,
    440377            (psS32)atoi(p4_id),
     378            skycell_id,
     379            tess_id,
    441380            exp_tag,
    442381            p3_version,
    443             class_id,
    444382            uri,
    445             b1_uri,
    446             b2_uri
     383            bg,
     384            bg_mean_stdev
    447385        )) {
    448386        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    453391}
    454392
    455 static bool warpedimfileMode(pxConfig *config)
     393static bool scfileMode(pxConfig *config)
    456394{
    457395    PS_ASSERT_PTR_NON_NULL(config, NULL);
    … …  
    459397    psString query = psStringCopy(
    460398        " SELECT DISTINCT"
    461         "   p4WarpedImfile.*"
     399        "   p4Scfile.*"
    462400        " FROM p4Run"
    463         " JOIN p4WarpedImfile"
     401        " JOIN p4Scfile"
    464402        "   USING(p4_id)"
    465403        " WHERE"
    … …  
    468406
    469407    if (config->where) {
    470         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "p4WarpedImfile");
     408        psString whereClause = psDBGenerateWhereConditionSQL(config->where, "p4Scfile");
    471409        psStringAppend(&query, " AND %s", whereClause);
    472410        psFree(whereClause);
    … …  
    486424    }
    487425    if (!psArrayLength(output)) {
    488         psError(PS_ERR_UNKNOWN, false, "no p4WarpedImfile rows found");
     426        psError(PS_ERR_UNKNOWN, false, "no p4Scfile rows found");
    489427        psFree(output);
    490428        return true;
    … …  
    502440
    503441    // negative simple so the default is true
    504     if (!ippdbPrintMetadatas(stdout, output, "p4WarpedImfile", !simple)) {
     442    if (!ippdbPrintMetadatas(stdout, output, "p4Scfile", !simple)) {
    505443        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    506444        psFree(output);
    … …  
    578516}
    579517
     518#if 0
    580519static bool addstackedimfileMode(pxConfig *config)
    581520{
    … …  
    640579    return true;
    641580}
     581#endif
    642582
    643583static bool stackedimfileMode(pxConfig *config)
    … …  
    774714}
    775715
     716#if 0
    776717static bool adddiffimfileMode(pxConfig *config)
    777718{
    … …  
    855796    return true;
    856797}
     798#endif
    857799
    858800static bool diffimfileMode(pxConfig *config)

  • trunk/ippTools/src/warptool.h

    r10642 r11723  
    2626    P4TOOL_MODE_NONE           = 0x0,
    2727    P4TOOL_MODE_DEFINERUN,
    28     P4TOOL_MODE_ADDINPUTIMFILE,
    29     P4TOOL_MODE_TOWARPEDIMFILE,
    30     P4TOOL_MODE_ADDWARPEDIMFILE,
    31     P4TOOL_MODE_WARPEDIMFILE,
     28    P4TOOL_MODE_ADDINPUTEXP,
     29    P4TOOL_MODE_TOSCFILE,
     30    P4TOOL_MODE_ADDSCFILE,
     31    P4TOOL_MODE_SCFILE,
    3232    P4TOOL_MODE_TOSTACKEDIMFILE,
    3333    P4TOOL_MODE_ADDSTACKEDIMFILE,

  • trunk/ippTools/src/warptoolConfig.c

    r11702 r11723  
    4848    // -definerun
    4949    psMetadata *definerunArgs = psMetadataAlloc();
    50     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-survey_mode", 0,
    51             "define the type of suvery (required)", NULL);
     50    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-mode", 0,
     51            "define mode (required)", NULL);
    5252    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,
    5353            "define workdir (required)", NULL);
    54     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-filter",  0,
    55             "define filter (required)", NULL);
    56     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-skycell_id",  0,
    57             "define skycell ID (required)", NULL);
    58     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id",  0,
    59             "define tessellation ID (required)", NULL);
    60     psMetadataAddF64(definerunArgs, PS_LIST_TAIL, "-ra",  0,
    61             "define RA", NAN);
    62     psMetadataAddF64(definerunArgs, PS_LIST_TAIL, "-decl",  0,
    63             "define DEC", NAN);
    64     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-input_ss",  0,
    65             "define input static sky ", NULL);
    66     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-output_ss",  0,
    67             "define output static sky ", NULL);
    68     psMetadataAddF64(definerunArgs, PS_LIST_TAIL, "-imfiles",  0,
    69             "define number of imfiles in the sky cell", 0);
    7054    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-registered",  0,
    7155            "time detrend run was registered", now);
    … …  
    7357            "use the simple output format", false);
    7458
    75     // -addinputimfile
    76     psMetadata *addinputimfileArgs = psMetadataAlloc();
    77     psMetadataAddStr(addinputimfileArgs, PS_LIST_TAIL, "-p4_id", 0,
    78             "define p4 ID (required)", NULL);
    79     psMetadataAddStr(addinputimfileArgs, PS_LIST_TAIL, "-exp_tag", 0,
    80             "define exposure tag (required)", NULL);
    81     psMetadataAddS32(addinputimfileArgs, PS_LIST_TAIL, "-p3_version", 0,
    82             "define phase 3 version of exposure tag (required)", 0);
    83     psMetadataAddStr(addinputimfileArgs, PS_LIST_TAIL, "-class_id", 0,
    84             "define class ID (required)", 0);
     59    // -addinputexp
     60    psMetadata *addinputexpArgs = psMetadataAlloc();
     61    psMetadataAddStr(addinputexpArgs, PS_LIST_TAIL, "-p4_id", 0,
     62            "define p4 ID (required)", NULL);
     63    psMetadataAddStr(addinputexpArgs, PS_LIST_TAIL, "-exp_tag", 0,
     64            "define exposure tag (required)", NULL);
     65    psMetadataAddS32(addinputexpArgs, PS_LIST_TAIL, "-p3_version", 0,
     66            "define phase 3 version of exposure tag (required)", 0);
     67    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-magiced", 0,
     68            "has this exposure been magiced", false);
    8569   
    86     // -towarpedimfile
    87     psMetadata *towarpedimfileArgs = psMetadataAlloc();
    88     psMetadataAddStr(towarpedimfileArgs, PS_LIST_TAIL, "-p4_id", 0,
    89             "search by p4 ID", NULL);
    90     psMetadataAddBool(towarpedimfileArgs, PS_LIST_TAIL, "-simple",  0,
    91             "use the simple output format", false);
    92  
    93     // -addwarpedimfile
    94     psMetadata *addwarpedimfileArgs = psMetadataAlloc();
    95     psMetadataAddStr(addwarpedimfileArgs, PS_LIST_TAIL, "-p4_id", 0,
    96             "define p4 ID (required)", NULL);
    97     psMetadataAddStr(addwarpedimfileArgs, PS_LIST_TAIL, "-exp_tag", 0,
    98             "define exposure tag (required)", NULL);
    99     psMetadataAddS32(addwarpedimfileArgs, PS_LIST_TAIL, "-p3_version", 0,
    100             "define phase 3 version of exposure tag (required)", 0);
    101     psMetadataAddStr(addwarpedimfileArgs, PS_LIST_TAIL, "-class_id", 0,
    102             "define class ID (required)", 0);
    103     psMetadataAddStr(addwarpedimfileArgs, PS_LIST_TAIL, "-uri", 0,
     70    // -toscfile
     71    psMetadata *toscfileArgs = psMetadataAlloc();
     72    psMetadataAddStr(toscfileArgs, PS_LIST_TAIL, "-p4_id", 0,
     73            "search by p4 ID", NULL);
     74    psMetadataAddBool(toscfileArgs, PS_LIST_TAIL, "-simple",  0,
     75            "use the simple output format", false);
     76 
     77    // -addscfile
     78    psMetadata *addscfileArgs = psMetadataAlloc();
     79    psMetadataAddStr(addscfileArgs, PS_LIST_TAIL, "-p4_id", 0,
     80            "define p4 ID (required)", NULL);
     81    psMetadataAddStr(addscfileArgs, PS_LIST_TAIL, "-skycell_id",  0,
     82            "define skycell ID (required)", NULL);
     83    psMetadataAddStr(addscfileArgs, PS_LIST_TAIL, "-tess_id",  0,
     84            "define tessellation ID (required)", NULL);
     85    psMetadataAddStr(addscfileArgs, PS_LIST_TAIL, "-exp_tag", 0,
     86            "define exposure tag (required)", NULL);
     87    psMetadataAddS32(addscfileArgs, PS_LIST_TAIL, "-p3_version", 0,
     88            "define phase 3 version of exposure tag (required)", 0);
     89    psMetadataAddStr(addscfileArgs, PS_LIST_TAIL, "-uri", 0,
    10490            "define URI of file (required)", 0);
    105     psMetadataAddStr(addwarpedimfileArgs, PS_LIST_TAIL, "-b1_uri",  0,
    106             "define banana 1", NULL);
    107     psMetadataAddStr(addwarpedimfileArgs, PS_LIST_TAIL, "-b2_uri",  0,
    108             "define banana 2", NULL);
    109  
    110     // -warpedimfile
    111     psMetadata *warpedimfileArgs = psMetadataAlloc();
    112     psMetadataAddStr(warpedimfileArgs, PS_LIST_TAIL, "-p4_id", 0,
    113             "search by p4 ID", NULL);
    114     psMetadataAddBool(warpedimfileArgs, PS_LIST_TAIL, "-simple",  0,
     91    psMetadataAddF64(addscfileArgs, PS_LIST_TAIL, "-bg",  0,
     92            "define exposue background", NAN);
     93    psMetadataAddF64(addscfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposue background mean stdev", NAN);
     94
     95 
     96    // -scfile
     97    psMetadata *scfileArgs = psMetadataAlloc();
     98    psMetadataAddStr(scfileArgs, PS_LIST_TAIL, "-p4_id", 0,
     99            "search by p4 ID", NULL);
     100    psMetadataAddStr(scfileArgs, PS_LIST_TAIL, "-skycell_id",  0,
     101            "define skycell ID (required)", NULL);
     102    psMetadataAddStr(scfileArgs, PS_LIST_TAIL, "-tess_id",  0,
     103            "define tessellation ID (required)", NULL);
     104    psMetadataAddStr(scfileArgs, PS_LIST_TAIL, "-exp_tag", 0,
     105            "define exposure tag (required)", NULL);
     106    psMetadataAddS32(scfileArgs, PS_LIST_TAIL, "-p3_version", 0,
     107            "define phase 3 version of exposure tag (required)", 0);
     108    psMetadataAddBool(scfileArgs, PS_LIST_TAIL, "-simple",  0,
    115109            "use the simple output format", false);
    116110
    … …  
    199193    psMetadata *argSets = psMetadataAlloc();
    200194    // find which mode we're running under
    201     PXTOOL_MODE("-definerun",       P4TOOL_MODE_DEFINERUN,   definerunArgs);
    202     PXTOOL_MODE("-addinputimfile",  P4TOOL_MODE_ADDINPUTIMFILE, addinputimfileArgs);
    203     PXTOOL_MODE("-towarpedimfile",  P4TOOL_MODE_TOWARPEDIMFILE, towarpedimfileArgs);
    204     PXTOOL_MODE("-addwarpedimfile", P4TOOL_MODE_ADDWARPEDIMFILE, addwarpedimfileArgs);
    205     PXTOOL_MODE("-warpedimfile",    P4TOOL_MODE_WARPEDIMFILE,   warpedimfileArgs);
     195    PXTOOL_MODE("-definerun",       P4TOOL_MODE_DEFINERUN,      definerunArgs);
     196    PXTOOL_MODE("-addinputexp",     P4TOOL_MODE_ADDINPUTEXP,    addinputexpArgs);
     197    PXTOOL_MODE("-toscfile",        P4TOOL_MODE_TOSCFILE,       toscfileArgs);
     198    PXTOOL_MODE("-addscfile",       P4TOOL_MODE_ADDSCFILE,      addscfileArgs);
     199    PXTOOL_MODE("-scfile",          P4TOOL_MODE_SCFILE,         scfileArgs);
    206200    PXTOOL_MODE("-tostackedimfile", P4TOOL_MODE_TOSTACKEDIMFILE, tostackedimfileArgs);
    207201    PXTOOL_MODE("-addstackedimfile", P4TOOL_MODE_ADDSTACKEDIMFILE, addstackedimfileArgs);
Note: See TracChangeset for help on using the changeset viewer.