IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 13649


Ignore:
Timestamp:
Jun 5, 2007, 11:55:11 AM (19 years ago)
Author:
eugene
Message:

added various chip and camera level metadata fields (bias stdev, ap resid, etc)

Location:
trunk
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/dbconfig/cam.md

    r12568 r13649  
    1313camProcessedExp METADATA
    1414# the camPendingExp row gets deleted so we can not put a fkey on cam_id
    15     cam_id      S64         0       # Primary Key
    16     chip_id     S64         0       # Primary Key fkey(chip_id) ref chipProcessedExp(chip_id)
    17     workdir     STR         255
    18     label       STR         64      # key
    19     recipe      STR         64
    20     expgroup    STR         64      # key
    21     dvodb       STR         255
    22     uri         STR         255
    23     bg          F64         0.0
    24     bg_stdev    F64         0.0
    25     bg_mean_stdev   F64     0.0
    26     sigma_ra    F32         0.0
    27     sigma_dec   F32         0.0
    28     nastro      S32         0
    29     path_base   STR         255
    30     zp_mean     F32         0.0
    31     zp_stdev    F32         0.0
    32     fault       S16         0       # Key NOT NULL
     15    cam_id         S64      0       # Primary Key
     16    chip_id        S64      0       # Primary Key fkey(chip_id) ref chipProcessedExp(chip_id)
     17    workdir        STR      255
     18    label          STR      64      # key
     19    recipe         STR      64
     20    expgroup       STR      64      # key
     21    dvodb          STR      255
     22    uri            STR      255
     23    bg             F32      0.0
     24    bg_stdev       F32      0.0
     25    bg_mean_stdev  F32      0.0
     26    sigma_ra       F32      0.0
     27    sigma_dec      F32      0.0
     28    zp_mean        F32      0.0
     29    zp_stdev       F32      0.0
     30    fwhm           F32      0.0
     31    fwhm_range     F32      0.0
     32    n_stars        S32      0
     33    n_extended     S32      0
     34    n_cr           S32      0
     35    n_astrom       S32      0
     36    path_base      STR      255
     37    fault          S16      0       # Key NOT NULL
    3338END
    3439

  • trunk/dbconfig/chip.md

    r12531 r13649  
    4848# fixed) but guide_id needs to wait until we know if this can be tracked at
    4949# just the exp level.
    50     class_id    STR         64      # Primary Key
    51     uri         STR         255
    52     bg          F64         0.0
    53     bg_stdev    F64         0.0
    54     bg_mean_stdev   F64     0.0
    55     path_base   STR         255
    56     fault       S16         0       # Key NOT NULL
     50    class_id        STR     64      # Primary Key
     51    uri             STR     255
     52    bg              F32     0.0
     53    bg_stdev        F32     0.0
     54    bg_mean_stdev   F32     0.0
     55    bias            F32     0.0
     56    bias_stdev      F32     0.0
     57    fringe_0        F32     0.0
     58    fringe_1        F32     0.0
     59    fringe_2        F32     0.0
     60    sigma_ra        F32     0.0
     61    sigma_dec       F32     0.0
     62    ap_resid        F32     0.0
     63    ap_resid_stdev  F32     0.0
     64    fwhm            F32     0.0
     65    fwhm_range      F32     0.0
     66    n_stars         S32     0
     67    n_extended      S32     0
     68    n_cr            S32     0
     69    n_astrom        S32     0
     70    path_base       STR     255
     71    fault           S16     0       # Key NOT NULL
    5772END

  • trunk/dbconfig/config.md

    r13620 r13649  
    22    pkg_name        STR     ippdb
    33    pkg_namespace   STR     ippdb
    4     pkg_version     STR     1.1.20
     4    pkg_version     STR     1.1.21
    55END

  • trunk/ippTools/configure.ac

    r13622 r13649  
    11AC_PREREQ(2.59)
    22
    3 AC_INIT([ipptools], [1.1.20], [ipp-support@ifa.hawaii.edu])
     3AC_INIT([ipptools], [1.1.21], [ipp-support@ifa.hawaii.edu])
    44AC_CONFIG_SRCDIR([autogen.sh])
    55
    … …  
    1818PKG_CHECK_MODULES([PSLIB], [pslib >= 1.1.0])
    1919PKG_CHECK_MODULES([PSMODULES], [psmodules >= 1.1.0])
    20 PKG_CHECK_MODULES([IPPDB], [ippdb >= 1.1.19])
     20PKG_CHECK_MODULES([IPPDB], [ippdb >= 1.1.21])
    2121
    2222PXTOOLS_CFLAGS="${PSLIB_CFLAGS=} ${PSMODULES_CFLAGS=} ${IPPDB_CFLAGS=}"

  • trunk/ippTools/src/camtool.c

    r13633 r13649  
    483483    }
    484484
    485     psS32 nastro = psMetadataLookupS32(&status, config->args, "-nastro");
    486     if (!status) {
    487         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -nastro");
    488         return false;
    489     }
    490     if (nastro < 0) {
    491         psError(PS_ERR_UNKNOWN, true, "-nastro is required");
    492         return false;
    493     }
    494 
    495485    psF32 zp_mean = psMetadataLookupF32(&status, config->args, "-zp_mean");
    496486    if (!status) {
    … …  
    510500    if (isnan(zp_stdev)) {
    511501        psError(PS_ERR_UNKNOWN, true, "-zp_stdev is required");
     502        return false;
     503    }
     504
     505    psF32 fwhm = psMetadataLookupF32(&status, config->args, "-fwhm");
     506    if (!status) {
     507        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fwhm");
     508        return false;
     509    }
     510    if (isnan(fwhm)) {
     511        psError(PS_ERR_UNKNOWN, true, "-fwhm is required");
     512        return false;
     513    }
     514
     515    psF32 fwhm_range = psMetadataLookupF32(&status, config->args, "-fwhm_range");
     516    if (!status) {
     517        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fwhm_range");
     518        return false;
     519    }
     520    if (isnan(fwhm_range)) {
     521        psError(PS_ERR_UNKNOWN, true, "-fwhm_range is required");
     522        return false;
     523    }
     524
     525    psS32 n_stars = psMetadataLookupS32(&status, config->args, "-n_stars");
     526    if (!status) {
     527        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -n_stars");
     528        return false;
     529    }
     530    if (n_stars < 0) {
     531        psError(PS_ERR_UNKNOWN, true, "-n_stars is required");
     532        return false;
     533    }
     534
     535    psS32 n_extended = psMetadataLookupS32(&status, config->args, "-n_extended");
     536    if (!status) {
     537        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -n_extended");
     538        return false;
     539    }
     540    if (n_extended < 0) {
     541        psError(PS_ERR_UNKNOWN, true, "-n_extended is required");
     542        return false;
     543    }
     544
     545    psS32 n_cr = psMetadataLookupS32(&status, config->args, "-n_cr");
     546    if (!status) {
     547        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -n_cr");
     548        return false;
     549    }
     550    if (n_cr < 0) {
     551        psError(PS_ERR_UNKNOWN, true, "-n_cr is required");
     552        return false;
     553    }
     554
     555    psS32 n_astrom = psMetadataLookupS32(&status, config->args, "-n_astrom");
     556    if (!status) {
     557        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -n_astrom");
     558        return false;
     559    }
     560    if (n_astrom < 0) {
     561        psError(PS_ERR_UNKNOWN, true, "-n_astrom is required");
    512562        return false;
    513563    }
    … …  
    576626        sigma_ra,
    577627        sigma_dec,
    578         nastro,
    579         path_base,
    580628        zp_mean,
    581629        zp_stdev,
     630        fwhm,
     631        fwhm_range,
     632        n_stars,
     633        n_extended,
     634        n_cr,
     635        n_astrom,
     636        path_base,
    582637        code
    583638    );

  • trunk/ippTools/src/camtoolConfig.c

    r13633 r13649  
    7777            "search by exposure time", NAN);
    7878    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg",  0,
    79             "search by exposue background", NAN);
     79            "search by exposure background", NAN);
    8080    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    81             "search by exposue background stdev", NAN);
     81            "search by exposure background stdev", NAN);
    8282    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    83             "search by exposue background mean stdev", NAN);
     83            "search by exposure background mean stdev", NAN);
    8484    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-alt",  0,
    8585            "search by altitute", NAN);
    … …  
    136136            "define URI (required)", NULL);
    137137    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg", 0,
    138             "define exposue background", NAN);
     138            "define exposure background", NAN);
    139139    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_stdev", 0,
    140             "define exposue background stdev", NAN);
     140            "define exposure background stdev", NAN);
    141141    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev", 0,
    142             "define exposue background mean stdev", NAN);
     142            "define exposure background mean stdev", NAN);
    143143    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-sigma_ra", 0,
    144144            "define exposure E ra (required)", NAN);
    145145    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-sigma_dec", 0,
    146146            "define exposure E dec (required)", NAN);
    147     psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-nastro", 0,
    148             "define number of objects (required)", -1);
    149147    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-zp_mean", 0,
    150148            "define zero point mean (required)", NAN);
    151149    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-zp_stdev", 0,
    152150            "define zero point stdev (required)", NAN);
     151    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fwhm", 0,
     152            "define FWHM in arcsec (required)", NAN);
     153    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fhwm_range", 0,
     154            "define FWHM range in arcsec (required)", NAN);
     155    psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_stars", 0,
     156            "define number of stars (required)", -1);
     157    psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_extended", 0,
     158            "define number of extended objects (required)", -1);
     159    psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_cr", 0,
     160            "define number of cosmic rays (required)", -1);
     161    psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_astrom", 0,
     162            "define number of astrometry reference objects (required)", -1);
    153163    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-path_base", 0,
    154164            "define banana 1", NULL);

  • trunk/ippTools/src/chiptool.c

    r13580 r13649  
    145145    ADDPARAMF(config->args, where, F32, "decl");
    146146    ADDPARAMF(config->args, where, F32, "exp_time");
    147     ADDPARAMF(config->args, where, F64, "bg");
    148     ADDPARAMF(config->args, where, F64, "bg_stdev");
    149     ADDPARAMF(config->args, where, F64, "bg_mean_stdev");
     147    ADDPARAMF(config->args, where, F32, "bg");
     148    ADDPARAMF(config->args, where, F32, "bg_stdev");
     149    ADDPARAMF(config->args, where, F32, "bg_mean_stdev");
    150150    ADDPARAMF(config->args, where, F64, "alt");
    151151    ADDPARAMF(config->args, where, F64, "az");
    … …  
    838838    }
    839839
    840     psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
     840    psF32 bg = psMetadataLookupF32(&status, config->args, "-bg");
    841841    if (!status) {
    842842        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
    … …  
    844844    }
    845845
    846     psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg_stdev");
     846    psF32 bg_stdev = psMetadataLookupF32(&status, config->args, "-bg_stdev");
    847847    if (!status) {
    848848        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
    … …  
    850850    }
    851851
    852     psF64 bg_mean_stdev = psMetadataLookupF64(&status, config->args, "-bg_mean_stdev");
     852    psF32 bg_mean_stdev = psMetadataLookupF32(&status, config->args, "-bg_mean_stdev");
    853853    if (!status) {
    854854        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_mean_stdev");
     855        return false;
     856    }
     857
     858    psF32 bias = psMetadataLookupF32(&status, config->args, "-bias");
     859    if (!status) {
     860        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bias");
     861        return false;
     862    }
     863
     864    psF32 bias_stdev = psMetadataLookupF32(&status, config->args, "-bias_stdev");
     865    if (!status) {
     866        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bias_stdev");
     867        return false;
     868    }
     869
     870    psF32 fringe_0 = psMetadataLookupF32(&status, config->args, "-fringe_0");
     871    if (!status) {
     872        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_0");
     873        return false;
     874    }
     875
     876    psF32 fringe_1 = psMetadataLookupF32(&status, config->args, "-fringe_1");
     877    if (!status) {
     878        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_1");
     879        return false;
     880    }
     881
     882    psF32 fringe_2 = psMetadataLookupF32(&status, config->args, "-fringe_2");
     883    if (!status) {
     884        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fringe_2");
     885        return false;
     886    }
     887
     888    psF32 sigma_ra = psMetadataLookupF32(&status, config->args, "-sigma_ra");
     889    if (!status) {
     890        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -sigma_ra");
     891        return false;
     892    }
     893
     894    psF32 sigma_dec = psMetadataLookupF32(&status, config->args, "-sigma_dec");
     895    if (!status) {
     896        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -sigma_dec");
     897        return false;
     898    }
     899
     900    psF32 ap_resid = psMetadataLookupF32(&status, config->args, "-ap_resid");
     901    if (!status) {
     902        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ap_resid");
     903        return false;
     904    }
     905
     906    psF32 ap_resid_stdev = psMetadataLookupF32(&status, config->args, "-ap_resid_stdev");
     907    if (!status) {
     908        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ap_resid_stdev");
     909        return false;
     910    }
     911
     912    psF32 fwhm = psMetadataLookupF32(&status, config->args, "-fwhm");
     913    if (!status) {
     914        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fwhm");
     915        return false;
     916    }
     917
     918    psF32 fwhm_range = psMetadataLookupF32(&status, config->args, "-fwhm_range");
     919    if (!status) {
     920        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fwhm_range");
     921        return false;
     922    }
     923
     924    psS32 n_stars = psMetadataLookupS32(&status, config->args, "-n_stars");
     925    if (!status) {
     926        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -n_stars");
     927        return false;
     928    }
     929
     930    psS32 n_extended = psMetadataLookupS32(&status, config->args, "-n_extended");
     931    if (!status) {
     932        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -n_extended");
     933        return false;
     934    }
     935
     936    psS32 n_cr = psMetadataLookupS32(&status, config->args, "-n_cr");
     937    if (!status) {
     938        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -n_cr");
     939        return false;
     940    }
     941
     942    psS32 n_astrom = psMetadataLookupS32(&status, config->args, "-n_astrom");
     943    if (!status) {
     944        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -n_astrom");
    855945        return false;
    856946    }
    … …  
    877967        bg_stdev,
    878968        bg_mean_stdev,
     969        bias,
     970        bias_stdev,
     971        fringe_0,
     972        fringe_1,
     973        fringe_2,
     974        sigma_ra,
     975        sigma_dec,
     976        ap_resid,
     977        ap_resid_stdev,
     978        fwhm,
     979        fwhm_range,
     980        n_stars,
     981        n_extended,
     982        n_cr,
     983        n_astrom,
    879984        path_base,
    880985        code
    881     );
     986        );
    882987}
    883988

  • trunk/ippTools/src/chiptoolConfig.c

    r13580 r13649  
    7272    psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-exp_time",  0,
    7373            "search by exposure time", NAN);
     74
     75    // XXX EAM : are these selecting based on the rawExp value or the chipImfile value?
    7476    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg",  0,
    75             "search by exposue background", NAN);
     77            "search by exposure background", NAN);
    7678    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    77             "search by exposue background stdev", NAN);
     79            "search by exposure background stdev", NAN);
    7880    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    79             "search by exposue background mean stdev", NAN);
     81            "search by exposure background mean stdev", NAN);
    8082    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-alt",  0,
    8183            "search by altitute", NAN);
    … …  
    129131    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-uri",  0,
    130132            "define URL", NULL);
    131     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-bg",  0,
    132             "define exposue background", NAN);
    133     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    134             "define exposue background stdev", NAN);
    135     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    136             "define exposue background mean stdev", NAN);
     133    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-bg",  0,
     134            "define exposure background", NAN);
     135    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,
     136            "define exposure background stdev", NAN);
     137    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
     138            "define exposure background mean stdev", NAN);
     139
     140    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-bias",  0,
     141            "define bias", NAN);
     142    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-bias_stdev",  0,
     143            "define bias stdev", NAN);
     144    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-fringe_0",  0,
     145            "define fringe term 0", NAN);
     146    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-fringe_1",  0,
     147            "define fringe term 1", NAN);
     148    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-fringe_2",  0,
     149            "define fringe term 2", NAN);
     150    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-sigma_ra",  0,
     151            "define error in RA", NAN);
     152    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-sigma_dec",  0,
     153            "define error in DEC", NAN);
     154    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-ap_resid",  0,
     155            "define aperture residual", NAN);
     156    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-ap_resid_stdev",  0,
     157            "define aperture residual stdev", NAN);
     158    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-fwhm",  0,
     159            "define fwhm (arcsec)", NAN);
     160    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-fwhm_range",  0,
     161            "define fwhm range (min to max)", NAN);
     162
     163    psMetadataAddS32(addprocessedimfileArgs, PS_LIST_TAIL, "-n_stars",  0,
     164            "define number of stars in image", 0);
     165    psMetadataAddS32(addprocessedimfileArgs, PS_LIST_TAIL, "-n_extended",  0,
     166            "define number of extended objects in image", 0);
     167    psMetadataAddS32(addprocessedimfileArgs, PS_LIST_TAIL, "-n_cr",  0,
     168            "define number of cosmic rays in image", 0);
     169    psMetadataAddS32(addprocessedimfileArgs, PS_LIST_TAIL, "-n_astrom",  0,
     170            "define number of astrometry stars used", 0);
     171
    137172    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-path_base",  0,
    138             "define banana 1", NULL);
     173            "define base output location", NULL);
    139174    psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,
    140175            "set fault code", 0);

  • trunk/ippdb/configure.ac

    r13621 r13649  
    77AC_PREREQ(2.59)
    88
    9 AC_INIT([ippdb], [1.1.20], [pan-starrs.ifa.hawaii.edu])
     9AC_INIT([ippdb], [1.1.21], [pan-starrs.ifa.hawaii.edu])
    1010AC_CONFIG_SRCDIR([ippdb.pc.in])
    1111

  • trunk/ippdb/src/ippdb.c

    r13621 r13649  
    69846984static void chipProcessedImfileRowFree(chipProcessedImfileRow *object);
    69856985
    6986 chipProcessedImfileRow *chipProcessedImfileRowAlloc(psS64 chip_id, const char *class_id, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
     6986chipProcessedImfileRow *chipProcessedImfileRowAlloc(psS64 chip_id, const char *class_id, const char *uri, psF32 bg, psF32 bg_stdev, psF32 bg_mean_stdev, psF32 bias, psF32 bias_stdev, psF32 fringe_0, psF32 fringe_1, psF32 fringe_2, psF32 sigma_ra, psF32 sigma_dec, psF32 ap_resid, psF32 ap_resid_stdev, psF32 fwhm, psF32 fwhm_range, psS32 n_stars, psS32 n_extended, psS32 n_cr, psS32 n_astrom, const char *path_base, psS16 fault)
    69876987{
    69886988    chipProcessedImfileRow *_object;
    … …  
    69976997    _object->bg_stdev = bg_stdev;
    69986998    _object->bg_mean_stdev = bg_mean_stdev;
     6999    _object->bias = bias;
     7000    _object->bias_stdev = bias_stdev;
     7001    _object->fringe_0 = fringe_0;
     7002    _object->fringe_1 = fringe_1;
     7003    _object->fringe_2 = fringe_2;
     7004    _object->sigma_ra = sigma_ra;
     7005    _object->sigma_dec = sigma_dec;
     7006    _object->ap_resid = ap_resid;
     7007    _object->ap_resid_stdev = ap_resid_stdev;
     7008    _object->fwhm = fwhm;
     7009    _object->fwhm_range = fwhm_range;
     7010    _object->n_stars = n_stars;
     7011    _object->n_extended = n_extended;
     7012    _object->n_cr = n_cr;
     7013    _object->n_astrom = n_astrom;
    69997014    _object->path_base = psStringCopy(path_base);
    70007015    _object->fault = fault;
    … …  
    70287043        return false;
    70297044    }
    7030     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) {
     7045    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F32, NULL, 0.0)) {
    70317046        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
    70327047        psFree(md);
    70337048        return false;
    70347049    }
    7035     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, 0.0)) {
     7050    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F32, NULL, 0.0)) {
    70367051        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev");
    70377052        psFree(md);
    70387053        return false;
    70397054    }
    7040     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) {
     7055    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F32, NULL, 0.0)) {
    70417056        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
     7057        psFree(md);
     7058        return false;
     7059    }
     7060    if (!psMetadataAdd(md, PS_LIST_TAIL, "bias", PS_DATA_F32, NULL, 0.0)) {
     7061        psError(PS_ERR_UNKNOWN, false, "failed to add item bias");
     7062        psFree(md);
     7063        return false;
     7064    }
     7065    if (!psMetadataAdd(md, PS_LIST_TAIL, "bias_stdev", PS_DATA_F32, NULL, 0.0)) {
     7066        psError(PS_ERR_UNKNOWN, false, "failed to add item bias_stdev");
     7067        psFree(md);
     7068        return false;
     7069    }
     7070    if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_0", PS_DATA_F32, NULL, 0.0)) {
     7071        psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_0");
     7072        psFree(md);
     7073        return false;
     7074    }
     7075    if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_1", PS_DATA_F32, NULL, 0.0)) {
     7076        psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_1");
     7077        psFree(md);
     7078        return false;
     7079    }
     7080    if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_2", PS_DATA_F32, NULL, 0.0)) {
     7081        psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_2");
     7082        psFree(md);
     7083        return false;
     7084    }
     7085    if (!psMetadataAdd(md, PS_LIST_TAIL, "sigma_ra", PS_DATA_F32, NULL, 0.0)) {
     7086        psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_ra");
     7087        psFree(md);
     7088        return false;
     7089    }
     7090    if (!psMetadataAdd(md, PS_LIST_TAIL, "sigma_dec", PS_DATA_F32, NULL, 0.0)) {
     7091        psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_dec");
     7092        psFree(md);
     7093        return false;
     7094    }
     7095    if (!psMetadataAdd(md, PS_LIST_TAIL, "ap_resid", PS_DATA_F32, NULL, 0.0)) {
     7096        psError(PS_ERR_UNKNOWN, false, "failed to add item ap_resid");
     7097        psFree(md);
     7098        return false;
     7099    }
     7100    if (!psMetadataAdd(md, PS_LIST_TAIL, "ap_resid_stdev", PS_DATA_F32, NULL, 0.0)) {
     7101        psError(PS_ERR_UNKNOWN, false, "failed to add item ap_resid_stdev");
     7102        psFree(md);
     7103        return false;
     7104    }
     7105    if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm", PS_DATA_F32, NULL, 0.0)) {
     7106        psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm");
     7107        psFree(md);
     7108        return false;
     7109    }
     7110    if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm_range", PS_DATA_F32, NULL, 0.0)) {
     7111        psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm_range");
     7112        psFree(md);
     7113        return false;
     7114    }
     7115    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_stars", PS_DATA_S32, NULL, 0)) {
     7116        psError(PS_ERR_UNKNOWN, false, "failed to add item n_stars");
     7117        psFree(md);
     7118        return false;
     7119    }
     7120    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_extended", PS_DATA_S32, NULL, 0)) {
     7121        psError(PS_ERR_UNKNOWN, false, "failed to add item n_extended");
     7122        psFree(md);
     7123        return false;
     7124    }
     7125    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_cr", PS_DATA_S32, NULL, 0)) {
     7126        psError(PS_ERR_UNKNOWN, false, "failed to add item n_cr");
     7127        psFree(md);
     7128        return false;
     7129    }
     7130    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_astrom", PS_DATA_S32, NULL, 0)) {
     7131        psError(PS_ERR_UNKNOWN, false, "failed to add item n_astrom");
    70427132        psFree(md);
    70437133        return false;
    … …  
    70667156}
    70677157
    7068 bool chipProcessedImfileInsert(psDB * dbh, psS64 chip_id, const char *class_id, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
     7158bool chipProcessedImfileInsert(psDB * dbh, psS64 chip_id, const char *class_id, const char *uri, psF32 bg, psF32 bg_stdev, psF32 bg_mean_stdev, psF32 bias, psF32 bias_stdev, psF32 fringe_0, psF32 fringe_1, psF32 fringe_2, psF32 sigma_ra, psF32 sigma_dec, psF32 ap_resid, psF32 ap_resid_stdev, psF32 fwhm, psF32 fwhm_range, psS32 n_stars, psS32 n_extended, psS32 n_cr, psS32 n_astrom, const char *path_base, psS16 fault)
    70697159{
    70707160    psMetadata *md = psMetadataAlloc();
    … …  
    70847174        return false;
    70857175    }
    7086     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) {
     7176    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F32, NULL, bg)) {
    70877177        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
    70887178        psFree(md);
    70897179        return false;
    70907180    }
    7091     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, bg_stdev)) {
     7181    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F32, NULL, bg_stdev)) {
    70927182        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev");
    70937183        psFree(md);
    70947184        return false;
    70957185    }
    7096     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) {
     7186    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F32, NULL, bg_mean_stdev)) {
    70977187        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
     7188        psFree(md);
     7189        return false;
     7190    }
     7191    if (!psMetadataAdd(md, PS_LIST_TAIL, "bias", PS_DATA_F32, NULL, bias)) {
     7192        psError(PS_ERR_UNKNOWN, false, "failed to add item bias");
     7193        psFree(md);
     7194        return false;
     7195    }
     7196    if (!psMetadataAdd(md, PS_LIST_TAIL, "bias_stdev", PS_DATA_F32, NULL, bias_stdev)) {
     7197        psError(PS_ERR_UNKNOWN, false, "failed to add item bias_stdev");
     7198        psFree(md);
     7199        return false;
     7200    }
     7201    if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_0", PS_DATA_F32, NULL, fringe_0)) {
     7202        psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_0");
     7203        psFree(md);
     7204        return false;
     7205    }
     7206    if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_1", PS_DATA_F32, NULL, fringe_1)) {
     7207        psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_1");
     7208        psFree(md);
     7209        return false;
     7210    }
     7211    if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_2", PS_DATA_F32, NULL, fringe_2)) {
     7212        psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_2");
     7213        psFree(md);
     7214        return false;
     7215    }
     7216    if (!psMetadataAdd(md, PS_LIST_TAIL, "sigma_ra", PS_DATA_F32, NULL, sigma_ra)) {
     7217        psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_ra");
     7218        psFree(md);
     7219        return false;
     7220    }
     7221    if (!psMetadataAdd(md, PS_LIST_TAIL, "sigma_dec", PS_DATA_F32, NULL, sigma_dec)) {
     7222        psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_dec");
     7223        psFree(md);
     7224        return false;
     7225    }
     7226    if (!psMetadataAdd(md, PS_LIST_TAIL, "ap_resid", PS_DATA_F32, NULL, ap_resid)) {
     7227        psError(PS_ERR_UNKNOWN, false, "failed to add item ap_resid");
     7228        psFree(md);
     7229        return false;
     7230    }
     7231    if (!psMetadataAdd(md, PS_LIST_TAIL, "ap_resid_stdev", PS_DATA_F32, NULL, ap_resid_stdev)) {
     7232        psError(PS_ERR_UNKNOWN, false, "failed to add item ap_resid_stdev");
     7233        psFree(md);
     7234        return false;
     7235    }
     7236    if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm", PS_DATA_F32, NULL, fwhm)) {
     7237        psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm");
     7238        psFree(md);
     7239        return false;
     7240    }
     7241    if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm_range", PS_DATA_F32, NULL, fwhm_range)) {
     7242        psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm_range");
     7243        psFree(md);
     7244        return false;
     7245    }
     7246    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_stars", PS_DATA_S32, NULL, n_stars)) {
     7247        psError(PS_ERR_UNKNOWN, false, "failed to add item n_stars");
     7248        psFree(md);
     7249        return false;
     7250    }
     7251    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_extended", PS_DATA_S32, NULL, n_extended)) {
     7252        psError(PS_ERR_UNKNOWN, false, "failed to add item n_extended");
     7253        psFree(md);
     7254        return false;
     7255    }
     7256    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_cr", PS_DATA_S32, NULL, n_cr)) {
     7257        psError(PS_ERR_UNKNOWN, false, "failed to add item n_cr");
     7258        psFree(md);
     7259        return false;
     7260    }
     7261    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_astrom", PS_DATA_S32, NULL, n_astrom)) {
     7262        psError(PS_ERR_UNKNOWN, false, "failed to add item n_astrom");
    70987263        psFree(md);
    70997264        return false;
    … …  
    71327297bool chipProcessedImfileInsertObject(psDB *dbh, chipProcessedImfileRow *object)
    71337298{
    7134     return chipProcessedImfileInsert(dbh, object->chip_id, object->class_id, object->uri, object->bg, object->bg_stdev, object->bg_mean_stdev, object->path_base, object->fault);
     7299    return chipProcessedImfileInsert(dbh, object->chip_id, object->class_id, object->uri, object->bg, object->bg_stdev, object->bg_mean_stdev, object->bias, object->bias_stdev, object->fringe_0, object->fringe_1, object->fringe_2, object->sigma_ra, object->sigma_dec, object->ap_resid, object->ap_resid_stdev, object->fwhm, object->fwhm_range, object->n_stars, object->n_extended, object->n_cr, object->n_astrom, object->path_base, object->fault);
    71357300}
    71367301
    … …  
    72207385        return false;
    72217386    }
    7222     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) {
     7387    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F32, NULL, object->bg)) {
    72237388        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
    72247389        psFree(md);
    72257390        return false;
    72267391    }
    7227     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, object->bg_stdev)) {
     7392    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F32, NULL, object->bg_stdev)) {
    72287393        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev");
    72297394        psFree(md);
    72307395        return false;
    72317396    }
    7232     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) {
     7397    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F32, NULL, object->bg_mean_stdev)) {
    72337398        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
     7399        psFree(md);
     7400        return false;
     7401    }
     7402    if (!psMetadataAdd(md, PS_LIST_TAIL, "bias", PS_DATA_F32, NULL, object->bias)) {
     7403        psError(PS_ERR_UNKNOWN, false, "failed to add item bias");
     7404        psFree(md);
     7405        return false;
     7406    }
     7407    if (!psMetadataAdd(md, PS_LIST_TAIL, "bias_stdev", PS_DATA_F32, NULL, object->bias_stdev)) {
     7408        psError(PS_ERR_UNKNOWN, false, "failed to add item bias_stdev");
     7409        psFree(md);
     7410        return false;
     7411    }
     7412    if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_0", PS_DATA_F32, NULL, object->fringe_0)) {
     7413        psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_0");
     7414        psFree(md);
     7415        return false;
     7416    }
     7417    if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_1", PS_DATA_F32, NULL, object->fringe_1)) {
     7418        psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_1");
     7419        psFree(md);
     7420        return false;
     7421    }
     7422    if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_2", PS_DATA_F32, NULL, object->fringe_2)) {
     7423        psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_2");
     7424        psFree(md);
     7425        return false;
     7426    }
     7427    if (!psMetadataAdd(md, PS_LIST_TAIL, "sigma_ra", PS_DATA_F32, NULL, object->sigma_ra)) {
     7428        psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_ra");
     7429        psFree(md);
     7430        return false;
     7431    }
     7432    if (!psMetadataAdd(md, PS_LIST_TAIL, "sigma_dec", PS_DATA_F32, NULL, object->sigma_dec)) {
     7433        psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_dec");
     7434        psFree(md);
     7435        return false;
     7436    }
     7437    if (!psMetadataAdd(md, PS_LIST_TAIL, "ap_resid", PS_DATA_F32, NULL, object->ap_resid)) {
     7438        psError(PS_ERR_UNKNOWN, false, "failed to add item ap_resid");
     7439        psFree(md);
     7440        return false;
     7441    }
     7442    if (!psMetadataAdd(md, PS_LIST_TAIL, "ap_resid_stdev", PS_DATA_F32, NULL, object->ap_resid_stdev)) {
     7443        psError(PS_ERR_UNKNOWN, false, "failed to add item ap_resid_stdev");
     7444        psFree(md);
     7445        return false;
     7446    }
     7447    if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm", PS_DATA_F32, NULL, object->fwhm)) {
     7448        psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm");
     7449        psFree(md);
     7450        return false;
     7451    }
     7452    if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm_range", PS_DATA_F32, NULL, object->fwhm_range)) {
     7453        psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm_range");
     7454        psFree(md);
     7455        return false;
     7456    }
     7457    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_stars", PS_DATA_S32, NULL, object->n_stars)) {
     7458        psError(PS_ERR_UNKNOWN, false, "failed to add item n_stars");
     7459        psFree(md);
     7460        return false;
     7461    }
     7462    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_extended", PS_DATA_S32, NULL, object->n_extended)) {
     7463        psError(PS_ERR_UNKNOWN, false, "failed to add item n_extended");
     7464        psFree(md);
     7465        return false;
     7466    }
     7467    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_cr", PS_DATA_S32, NULL, object->n_cr)) {
     7468        psError(PS_ERR_UNKNOWN, false, "failed to add item n_cr");
     7469        psFree(md);
     7470        return false;
     7471    }
     7472    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_astrom", PS_DATA_S32, NULL, object->n_astrom)) {
     7473        psError(PS_ERR_UNKNOWN, false, "failed to add item n_astrom");
    72347474        psFree(md);
    72357475        return false;
    … …  
    72697509        return false;
    72707510    }
    7271     psF64 bg = psMetadataLookupF64(&status, md, "bg");
     7511    psF32 bg = psMetadataLookupF32(&status, md, "bg");
    72727512    if (!status) {
    72737513        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
    72747514        return false;
    72757515    }
    7276     psF64 bg_stdev = psMetadataLookupF64(&status, md, "bg_stdev");
     7516    psF32 bg_stdev = psMetadataLookupF32(&status, md, "bg_stdev");
    72777517    if (!status) {
    72787518        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev");
    72797519        return false;
    72807520    }
    7281     psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev");
     7521    psF32 bg_mean_stdev = psMetadataLookupF32(&status, md, "bg_mean_stdev");
    72827522    if (!status) {
    72837523        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
    72847524        return false;
    72857525    }
     7526    psF32 bias = psMetadataLookupF32(&status, md, "bias");
     7527    if (!status) {
     7528        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bias");
     7529        return false;
     7530    }
     7531    psF32 bias_stdev = psMetadataLookupF32(&status, md, "bias_stdev");
     7532    if (!status) {
     7533        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bias_stdev");
     7534        return false;
     7535    }
     7536    psF32 fringe_0 = psMetadataLookupF32(&status, md, "fringe_0");
     7537    if (!status) {
     7538        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_0");
     7539        return false;
     7540    }
     7541    psF32 fringe_1 = psMetadataLookupF32(&status, md, "fringe_1");
     7542    if (!status) {
     7543        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_1");
     7544        return false;
     7545    }
     7546    psF32 fringe_2 = psMetadataLookupF32(&status, md, "fringe_2");
     7547    if (!status) {
     7548        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_2");
     7549        return false;
     7550    }
     7551    psF32 sigma_ra = psMetadataLookupF32(&status, md, "sigma_ra");
     7552    if (!status) {
     7553        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item sigma_ra");
     7554        return false;
     7555    }
     7556    psF32 sigma_dec = psMetadataLookupF32(&status, md, "sigma_dec");
     7557    if (!status) {
     7558        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item sigma_dec");
     7559        return false;
     7560    }
     7561    psF32 ap_resid = psMetadataLookupF32(&status, md, "ap_resid");
     7562    if (!status) {
     7563        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ap_resid");
     7564        return false;
     7565    }
     7566    psF32 ap_resid_stdev = psMetadataLookupF32(&status, md, "ap_resid_stdev");
     7567    if (!status) {
     7568        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ap_resid_stdev");
     7569        return false;
     7570    }
     7571    psF32 fwhm = psMetadataLookupF32(&status, md, "fwhm");
     7572    if (!status) {
     7573        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fwhm");
     7574        return false;
     7575    }
     7576    psF32 fwhm_range = psMetadataLookupF32(&status, md, "fwhm_range");
     7577    if (!status) {
     7578        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fwhm_range");
     7579        return false;
     7580    }
     7581    psS32 n_stars = psMetadataLookupS32(&status, md, "n_stars");
     7582    if (!status) {
     7583        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item n_stars");
     7584        return false;
     7585    }
     7586    psS32 n_extended = psMetadataLookupS32(&status, md, "n_extended");
     7587    if (!status) {
     7588        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item n_extended");
     7589        return false;
     7590    }
     7591    psS32 n_cr = psMetadataLookupS32(&status, md, "n_cr");
     7592    if (!status) {
     7593        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item n_cr");
     7594        return false;
     7595    }
     7596    psS32 n_astrom = psMetadataLookupS32(&status, md, "n_astrom");
     7597    if (!status) {
     7598        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item n_astrom");
     7599        return false;
     7600    }
    72867601    char* path_base = psMetadataLookupPtr(&status, md, "path_base");
    72877602    if (!status) {
    … …  
    72957610    }
    72967611
    7297     return chipProcessedImfileRowAlloc(chip_id, class_id, uri, bg, bg_stdev, bg_mean_stdev, path_base, fault);
     7612    return chipProcessedImfileRowAlloc(chip_id, class_id, uri, bg, bg_stdev, bg_mean_stdev, bias, bias_stdev, fringe_0, fringe_1, fringe_2, sigma_ra, sigma_dec, ap_resid, ap_resid_stdev, fwhm, fwhm_range, n_stars, n_extended, n_cr, n_astrom, path_base, fault);
    72987613}
    72997614psArray *chipProcessedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    78118126static void camProcessedExpRowFree(camProcessedExpRow *object);
    78128127
    7813 camProcessedExpRow *camProcessedExpRowAlloc(psS64 cam_id, psS64 chip_id, const char *workdir, const char *label, const char *recipe, const char *expgroup, const char *dvodb, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF32 sigma_ra, psF32 sigma_dec, psS32 nastro, const char *path_base, psF32 zp_mean, psF32 zp_stdev, psS16 fault)
     8128camProcessedExpRow *camProcessedExpRowAlloc(psS64 cam_id, psS64 chip_id, const char *workdir, const char *label, const char *recipe, const char *expgroup, const char *dvodb, const char *uri, psF32 bg, psF32 bg_stdev, psF32 bg_mean_stdev, psF32 sigma_ra, psF32 sigma_dec, psF32 zp_mean, psF32 zp_stdev, psF32 fwhm, psF32 fwhm_range, psS32 n_stars, psS32 n_extended, psS32 n_cr, psS32 n_astrom, const char *path_base, psS16 fault)
    78148129{
    78158130    camProcessedExpRow *_object;
    … …  
    78318146    _object->sigma_ra = sigma_ra;
    78328147    _object->sigma_dec = sigma_dec;
    7833     _object->nastro = nastro;
    7834     _object->path_base = psStringCopy(path_base);
    78358148    _object->zp_mean = zp_mean;
    78368149    _object->zp_stdev = zp_stdev;
     8150    _object->fwhm = fwhm;
     8151    _object->fwhm_range = fwhm_range;
     8152    _object->n_stars = n_stars;
     8153    _object->n_extended = n_extended;
     8154    _object->n_cr = n_cr;
     8155    _object->n_astrom = n_astrom;
     8156    _object->path_base = psStringCopy(path_base);
    78378157    _object->fault = fault;
    78388158
    … …  
    78948214        return false;
    78958215    }
    7896     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) {
     8216    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F32, NULL, 0.0)) {
    78978217        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
    78988218        psFree(md);
    78998219        return false;
    79008220    }
    7901     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, 0.0)) {
     8221    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F32, NULL, 0.0)) {
    79028222        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev");
    79038223        psFree(md);
    79048224        return false;
    79058225    }
    7906     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) {
     8226    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F32, NULL, 0.0)) {
    79078227        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
    79088228        psFree(md);
    … …  
    79198239        return false;
    79208240    }
    7921     if (!psMetadataAdd(md, PS_LIST_TAIL, "nastro", PS_DATA_S32, NULL, 0)) {
    7922         psError(PS_ERR_UNKNOWN, false, "failed to add item nastro");
     8241    if (!psMetadataAdd(md, PS_LIST_TAIL, "zp_mean", PS_DATA_F32, NULL, 0.0)) {
     8242        psError(PS_ERR_UNKNOWN, false, "failed to add item zp_mean");
     8243        psFree(md);
     8244        return false;
     8245    }
     8246    if (!psMetadataAdd(md, PS_LIST_TAIL, "zp_stdev", PS_DATA_F32, NULL, 0.0)) {
     8247        psError(PS_ERR_UNKNOWN, false, "failed to add item zp_stdev");
     8248        psFree(md);
     8249        return false;
     8250    }
     8251    if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm", PS_DATA_F32, NULL, 0.0)) {
     8252        psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm");
     8253        psFree(md);
     8254        return false;
     8255    }
     8256    if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm_range", PS_DATA_F32, NULL, 0.0)) {
     8257        psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm_range");
     8258        psFree(md);
     8259        return false;
     8260    }
     8261    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_stars", PS_DATA_S32, NULL, 0)) {
     8262        psError(PS_ERR_UNKNOWN, false, "failed to add item n_stars");
     8263        psFree(md);
     8264        return false;
     8265    }
     8266    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_extended", PS_DATA_S32, NULL, 0)) {
     8267        psError(PS_ERR_UNKNOWN, false, "failed to add item n_extended");
     8268        psFree(md);
     8269        return false;
     8270    }
     8271    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_cr", PS_DATA_S32, NULL, 0)) {
     8272        psError(PS_ERR_UNKNOWN, false, "failed to add item n_cr");
     8273        psFree(md);
     8274        return false;
     8275    }
     8276    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_astrom", PS_DATA_S32, NULL, 0)) {
     8277        psError(PS_ERR_UNKNOWN, false, "failed to add item n_astrom");
    79238278        psFree(md);
    79248279        return false;
    … …  
    79298284        return false;
    79308285    }
    7931     if (!psMetadataAdd(md, PS_LIST_TAIL, "zp_mean", PS_DATA_F32, NULL, 0.0)) {
    7932         psError(PS_ERR_UNKNOWN, false, "failed to add item zp_mean");
    7933         psFree(md);
    7934         return false;
    7935     }
    7936     if (!psMetadataAdd(md, PS_LIST_TAIL, "zp_stdev", PS_DATA_F32, NULL, 0.0)) {
    7937         psError(PS_ERR_UNKNOWN, false, "failed to add item zp_stdev");
    7938         psFree(md);
    7939         return false;
    7940     }
    79418286    if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key NOT NULL", 0)) {
    79428287        psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    … …  
    79578302}
    79588303
    7959 bool camProcessedExpInsert(psDB * dbh, psS64 cam_id, psS64 chip_id, const char *workdir, const char *label, const char *recipe, const char *expgroup, const char *dvodb, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF32 sigma_ra, psF32 sigma_dec, psS32 nastro, const char *path_base, psF32 zp_mean, psF32 zp_stdev, psS16 fault)
     8304bool camProcessedExpInsert(psDB * dbh, psS64 cam_id, psS64 chip_id, const char *workdir, const char *label, const char *recipe, const char *expgroup, const char *dvodb, const char *uri, psF32 bg, psF32 bg_stdev, psF32 bg_mean_stdev, psF32 sigma_ra, psF32 sigma_dec, psF32 zp_mean, psF32 zp_stdev, psF32 fwhm, psF32 fwhm_range, psS32 n_stars, psS32 n_extended, psS32 n_cr, psS32 n_astrom, const char *path_base, psS16 fault)
    79608305{
    79618306    psMetadata *md = psMetadataAlloc();
    … …  
    80008345        return false;
    80018346    }
    8002     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) {
     8347    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F32, NULL, bg)) {
    80038348        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
    80048349        psFree(md);
    80058350        return false;
    80068351    }
    8007     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, bg_stdev)) {
     8352    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F32, NULL, bg_stdev)) {
    80088353        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev");
    80098354        psFree(md);
    80108355        return false;
    80118356    }
    8012     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) {
     8357    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F32, NULL, bg_mean_stdev)) {
    80138358        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
    80148359        psFree(md);
    … …  
    80258370        return false;
    80268371    }
    8027     if (!psMetadataAdd(md, PS_LIST_TAIL, "nastro", PS_DATA_S32, NULL, nastro)) {
    8028         psError(PS_ERR_UNKNOWN, false, "failed to add item nastro");
     8372    if (!psMetadataAdd(md, PS_LIST_TAIL, "zp_mean", PS_DATA_F32, NULL, zp_mean)) {
     8373        psError(PS_ERR_UNKNOWN, false, "failed to add item zp_mean");
     8374        psFree(md);
     8375        return false;
     8376    }
     8377    if (!psMetadataAdd(md, PS_LIST_TAIL, "zp_stdev", PS_DATA_F32, NULL, zp_stdev)) {
     8378        psError(PS_ERR_UNKNOWN, false, "failed to add item zp_stdev");
     8379        psFree(md);
     8380        return false;
     8381    }
     8382    if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm", PS_DATA_F32, NULL, fwhm)) {
     8383        psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm");
     8384        psFree(md);
     8385        return false;
     8386    }
     8387    if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm_range", PS_DATA_F32, NULL, fwhm_range)) {
     8388        psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm_range");
     8389        psFree(md);
     8390        return false;
     8391    }
     8392    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_stars", PS_DATA_S32, NULL, n_stars)) {
     8393        psError(PS_ERR_UNKNOWN, false, "failed to add item n_stars");
     8394        psFree(md);
     8395        return false;
     8396    }
     8397    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_extended", PS_DATA_S32, NULL, n_extended)) {
     8398        psError(PS_ERR_UNKNOWN, false, "failed to add item n_extended");
     8399        psFree(md);
     8400        return false;
     8401    }
     8402    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_cr", PS_DATA_S32, NULL, n_cr)) {
     8403        psError(PS_ERR_UNKNOWN, false, "failed to add item n_cr");
     8404        psFree(md);
     8405        return false;
     8406    }
     8407    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_astrom", PS_DATA_S32, NULL, n_astrom)) {
     8408        psError(PS_ERR_UNKNOWN, false, "failed to add item n_astrom");
    80298409        psFree(md);
    80308410        return false;
    … …  
    80328412    if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, path_base)) {
    80338413        psError(PS_ERR_UNKNOWN, false, "failed to add item path_base");
    8034         psFree(md);
    8035         return false;
    8036     }
    8037     if (!psMetadataAdd(md, PS_LIST_TAIL, "zp_mean", PS_DATA_F32, NULL, zp_mean)) {
    8038         psError(PS_ERR_UNKNOWN, false, "failed to add item zp_mean");
    8039         psFree(md);
    8040         return false;
    8041     }
    8042     if (!psMetadataAdd(md, PS_LIST_TAIL, "zp_stdev", PS_DATA_F32, NULL, zp_stdev)) {
    8043         psError(PS_ERR_UNKNOWN, false, "failed to add item zp_stdev");
    80448414        psFree(md);
    80458415        return false;
    … …  
    80738443bool camProcessedExpInsertObject(psDB *dbh, camProcessedExpRow *object)
    80748444{
    8075     return camProcessedExpInsert(dbh, object->cam_id, object->chip_id, object->workdir, object->label, object->recipe, object->expgroup, object->dvodb, object->uri, object->bg, object->bg_stdev, object->bg_mean_stdev, object->sigma_ra, object->sigma_dec, object->nastro, object->path_base, object->zp_mean, object->zp_stdev, object->fault);
     8445    return camProcessedExpInsert(dbh, object->cam_id, object->chip_id, object->workdir, object->label, object->recipe, object->expgroup, object->dvodb, object->uri, object->bg, object->bg_stdev, object->bg_mean_stdev, object->sigma_ra, object->sigma_dec, object->zp_mean, object->zp_stdev, object->fwhm, object->fwhm_range, object->n_stars, object->n_extended, object->n_cr, object->n_astrom, object->path_base, object->fault);
    80768446}
    80778447
    … …  
    81868556        return false;
    81878557    }
    8188     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) {
     8558    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F32, NULL, object->bg)) {
    81898559        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
    81908560        psFree(md);
    81918561        return false;
    81928562    }
    8193     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, object->bg_stdev)) {
     8563    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F32, NULL, object->bg_stdev)) {
    81948564        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev");
    81958565        psFree(md);
    81968566        return false;
    81978567    }
    8198     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) {
     8568    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F32, NULL, object->bg_mean_stdev)) {
    81998569        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
    82008570        psFree(md);
    … …  
    82118581        return false;
    82128582    }
    8213     if (!psMetadataAdd(md, PS_LIST_TAIL, "nastro", PS_DATA_S32, NULL, object->nastro)) {
    8214         psError(PS_ERR_UNKNOWN, false, "failed to add item nastro");
     8583    if (!psMetadataAdd(md, PS_LIST_TAIL, "zp_mean", PS_DATA_F32, NULL, object->zp_mean)) {
     8584        psError(PS_ERR_UNKNOWN, false, "failed to add item zp_mean");
     8585        psFree(md);
     8586        return false;
     8587    }
     8588    if (!psMetadataAdd(md, PS_LIST_TAIL, "zp_stdev", PS_DATA_F32, NULL, object->zp_stdev)) {
     8589        psError(PS_ERR_UNKNOWN, false, "failed to add item zp_stdev");
     8590        psFree(md);
     8591        return false;
     8592    }
     8593    if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm", PS_DATA_F32, NULL, object->fwhm)) {
     8594        psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm");
     8595        psFree(md);
     8596        return false;
     8597    }
     8598    if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm_range", PS_DATA_F32, NULL, object->fwhm_range)) {
     8599        psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm_range");
     8600        psFree(md);
     8601        return false;
     8602    }
     8603    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_stars", PS_DATA_S32, NULL, object->n_stars)) {
     8604        psError(PS_ERR_UNKNOWN, false, "failed to add item n_stars");
     8605        psFree(md);
     8606        return false;
     8607    }
     8608    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_extended", PS_DATA_S32, NULL, object->n_extended)) {
     8609        psError(PS_ERR_UNKNOWN, false, "failed to add item n_extended");
     8610        psFree(md);
     8611        return false;
     8612    }
     8613    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_cr", PS_DATA_S32, NULL, object->n_cr)) {
     8614        psError(PS_ERR_UNKNOWN, false, "failed to add item n_cr");
     8615        psFree(md);
     8616        return false;
     8617    }
     8618    if (!psMetadataAdd(md, PS_LIST_TAIL, "n_astrom", PS_DATA_S32, NULL, object->n_astrom)) {
     8619        psError(PS_ERR_UNKNOWN, false, "failed to add item n_astrom");
    82158620        psFree(md);
    82168621        return false;
    … …  
    82218626        return false;
    82228627    }
    8223     if (!psMetadataAdd(md, PS_LIST_TAIL, "zp_mean", PS_DATA_F32, NULL, object->zp_mean)) {
    8224         psError(PS_ERR_UNKNOWN, false, "failed to add item zp_mean");
    8225         psFree(md);
    8226         return false;
    8227     }
    8228     if (!psMetadataAdd(md, PS_LIST_TAIL, "zp_stdev", PS_DATA_F32, NULL, object->zp_stdev)) {
    8229         psError(PS_ERR_UNKNOWN, false, "failed to add item zp_stdev");
    8230         psFree(md);
    8231         return false;
    8232     }
    82338628    if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) {
    82348629        psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    … …  
    82858680        return false;
    82868681    }
    8287     psF64 bg = psMetadataLookupF64(&status, md, "bg");
     8682    psF32 bg = psMetadataLookupF32(&status, md, "bg");
    82888683    if (!status) {
    82898684        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
    82908685        return false;
    82918686    }
    8292     psF64 bg_stdev = psMetadataLookupF64(&status, md, "bg_stdev");
     8687    psF32 bg_stdev = psMetadataLookupF32(&status, md, "bg_stdev");
    82938688    if (!status) {
    82948689        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev");
    82958690        return false;
    82968691    }
    8297     psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev");
     8692    psF32 bg_mean_stdev = psMetadataLookupF32(&status, md, "bg_mean_stdev");
    82988693    if (!status) {
    82998694        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
    … …  
    83108705        return false;
    83118706    }
    8312     psS32 nastro = psMetadataLookupS32(&status, md, "nastro");
    8313     if (!status) {
    8314         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item nastro");
     8707    psF32 zp_mean = psMetadataLookupF32(&status, md, "zp_mean");
     8708    if (!status) {
     8709        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item zp_mean");
     8710        return false;
     8711    }
     8712    psF32 zp_stdev = psMetadataLookupF32(&status, md, "zp_stdev");
     8713    if (!status) {
     8714        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item zp_stdev");
     8715        return false;
     8716    }
     8717    psF32 fwhm = psMetadataLookupF32(&status, md, "fwhm");
     8718    if (!status) {
     8719        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fwhm");
     8720        return false;
     8721    }
     8722    psF32 fwhm_range = psMetadataLookupF32(&status, md, "fwhm_range");
     8723    if (!status) {
     8724        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fwhm_range");
     8725        return false;
     8726    }
     8727    psS32 n_stars = psMetadataLookupS32(&status, md, "n_stars");
     8728    if (!status) {
     8729        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item n_stars");
     8730        return false;
     8731    }
     8732    psS32 n_extended = psMetadataLookupS32(&status, md, "n_extended");
     8733    if (!status) {
     8734        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item n_extended");
     8735        return false;
     8736    }
     8737    psS32 n_cr = psMetadataLookupS32(&status, md, "n_cr");
     8738    if (!status) {
     8739        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item n_cr");
     8740        return false;
     8741    }
     8742    psS32 n_astrom = psMetadataLookupS32(&status, md, "n_astrom");
     8743    if (!status) {
     8744        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item n_astrom");
    83158745        return false;
    83168746    }
    … …  
    83208750        return false;
    83218751    }
    8322     psF32 zp_mean = psMetadataLookupF32(&status, md, "zp_mean");
    8323     if (!status) {
    8324         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item zp_mean");
    8325         return false;
    8326     }
    8327     psF32 zp_stdev = psMetadataLookupF32(&status, md, "zp_stdev");
    8328     if (!status) {
    8329         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item zp_stdev");
    8330         return false;
    8331     }
    83328752    psS16 fault = psMetadataLookupS16(&status, md, "fault");
    83338753    if (!status) {
    … …  
    83368756    }
    83378757
    8338     return camProcessedExpRowAlloc(cam_id, chip_id, workdir, label, recipe, expgroup, dvodb, uri, bg, bg_stdev, bg_mean_stdev, sigma_ra, sigma_dec, nastro, path_base, zp_mean, zp_stdev, fault);
     8758    return camProcessedExpRowAlloc(cam_id, chip_id, workdir, label, recipe, expgroup, dvodb, uri, bg, bg_stdev, bg_mean_stdev, sigma_ra, sigma_dec, zp_mean, zp_stdev, fwhm, fwhm_range, n_stars, n_extended, n_cr, n_astrom, path_base, fault);
    83398759}
    83408760psArray *camProcessedExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)

  • trunk/ippdb/src/ippdb.h

    r13621 r13649  
    35813581    char            *class_id;
    35823582    char            *uri;
    3583     psF64           bg;
    3584     psF64           bg_stdev;
    3585     psF64           bg_mean_stdev;
     3583    psF32           bg;
     3584    psF32           bg_stdev;
     3585    psF32           bg_mean_stdev;
     3586    psF32           bias;
     3587    psF32           bias_stdev;
     3588    psF32           fringe_0;
     3589    psF32           fringe_1;
     3590    psF32           fringe_2;
     3591    psF32           sigma_ra;
     3592    psF32           sigma_dec;
     3593    psF32           ap_resid;
     3594    psF32           ap_resid_stdev;
     3595    psF32           fwhm;
     3596    psF32           fwhm_range;
     3597    psS32           n_stars;
     3598    psS32           n_extended;
     3599    psS32           n_cr;
     3600    psS32           n_astrom;
    35863601    char            *path_base;
    35873602    psS16           fault;
    … …  
    35973612    const char      *class_id,
    35983613    const char      *uri,
    3599     psF64           bg,
    3600     psF64           bg_stdev,
    3601     psF64           bg_mean_stdev,
     3614    psF32           bg,
     3615    psF32           bg_stdev,
     3616    psF32           bg_mean_stdev,
     3617    psF32           bias,
     3618    psF32           bias_stdev,
     3619    psF32           fringe_0,
     3620    psF32           fringe_1,
     3621    psF32           fringe_2,
     3622    psF32           sigma_ra,
     3623    psF32           sigma_dec,
     3624    psF32           ap_resid,
     3625    psF32           ap_resid_stdev,
     3626    psF32           fwhm,
     3627    psF32           fwhm_range,
     3628    psS32           n_stars,
     3629    psS32           n_extended,
     3630    psS32           n_cr,
     3631    psS32           n_astrom,
    36023632    const char      *path_base,
    36033633    psS16           fault
    … …  
    36343664    const char      *class_id,
    36353665    const char      *uri,
    3636     psF64           bg,
    3637     psF64           bg_stdev,
    3638     psF64           bg_mean_stdev,
     3666    psF32           bg,
     3667    psF32           bg_stdev,
     3668    psF32           bg_mean_stdev,
     3669    psF32           bias,
     3670    psF32           bias_stdev,
     3671    psF32           fringe_0,
     3672    psF32           fringe_1,
     3673    psF32           fringe_2,
     3674    psF32           sigma_ra,
     3675    psF32           sigma_dec,
     3676    psF32           ap_resid,
     3677    psF32           ap_resid_stdev,
     3678    psF32           fwhm,
     3679    psF32           fwhm_range,
     3680    psS32           n_stars,
     3681    psS32           n_extended,
     3682    psS32           n_cr,
     3683    psS32           n_astrom,
    36393684    const char      *path_base,
    36403685    psS16           fault
    … …  
    40154060    char            *dvodb;
    40164061    char            *uri;
    4017     psF64           bg;
    4018     psF64           bg_stdev;
    4019     psF64           bg_mean_stdev;
     4062    psF32           bg;
     4063    psF32           bg_stdev;
     4064    psF32           bg_mean_stdev;
    40204065    psF32           sigma_ra;
    40214066    psF32           sigma_dec;
    4022     psS32           nastro;
    4023     char            *path_base;
    40244067    psF32           zp_mean;
    40254068    psF32           zp_stdev;
     4069    psF32           fwhm;
     4070    psF32           fwhm_range;
     4071    psS32           n_stars;
     4072    psS32           n_extended;
     4073    psS32           n_cr;
     4074    psS32           n_astrom;
     4075    char            *path_base;
    40264076    psS16           fault;
    40274077} camProcessedExpRow;
    … …  
    40414091    const char      *dvodb,
    40424092    const char      *uri,
    4043     psF64           bg,
    4044     psF64           bg_stdev,
    4045     psF64           bg_mean_stdev,
     4093    psF32           bg,
     4094    psF32           bg_stdev,
     4095    psF32           bg_mean_stdev,
    40464096    psF32           sigma_ra,
    40474097    psF32           sigma_dec,
    4048     psS32           nastro,
    4049     const char      *path_base,
    40504098    psF32           zp_mean,
    40514099    psF32           zp_stdev,
     4100    psF32           fwhm,
     4101    psF32           fwhm_range,
     4102    psS32           n_stars,
     4103    psS32           n_extended,
     4104    psS32           n_cr,
     4105    psS32           n_astrom,
     4106    const char      *path_base,
    40524107    psS16           fault
    40534108);
    … …  
    40884143    const char      *dvodb,
    40894144    const char      *uri,
    4090     psF64           bg,
    4091     psF64           bg_stdev,
    4092     psF64           bg_mean_stdev,
     4145    psF32           bg,
     4146    psF32           bg_stdev,
     4147    psF32           bg_mean_stdev,
    40934148    psF32           sigma_ra,
    40944149    psF32           sigma_dec,
    4095     psS32           nastro,
    4096     const char      *path_base,
    40974150    psF32           zp_mean,
    40984151    psF32           zp_stdev,
     4152    psF32           fwhm,
     4153    psF32           fwhm_range,
     4154    psS32           n_stars,
     4155    psS32           n_extended,
     4156    psS32           n_cr,
     4157    psS32           n_astrom,
     4158    const char      *path_base,
    40994159    psS16           fault
    41004160);

  • trunk/ippdb/tests/alloc.c

    r13621 r13649  
    716716        chipProcessedImfileRow *object;
    717717
    718         object = chipProcessedImfileRowAlloc(-64, "a string", "a string", 64.64, 64.64, 64.64, "a string", -16    );
     718        object = chipProcessedImfileRowAlloc(-64, "a string", "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, -32, -32, -32, -32, "a string", -16    );
    719719
    720720        if (!object) {
    … …  
    734734            exit(EXIT_FAILURE);
    735735        }
    736         if (!object->bg == 64.64) {
    737             psFree(object);
    738             exit(EXIT_FAILURE);
    739         }
    740         if (!object->bg_stdev == 64.64) {
    741             psFree(object);
    742             exit(EXIT_FAILURE);
    743         }
    744         if (!object->bg_mean_stdev == 64.64) {
     736        if (!object->bg == 32.32) {
     737            psFree(object);
     738            exit(EXIT_FAILURE);
     739        }
     740        if (!object->bg_stdev == 32.32) {
     741            psFree(object);
     742            exit(EXIT_FAILURE);
     743        }
     744        if (!object->bg_mean_stdev == 32.32) {
     745            psFree(object);
     746            exit(EXIT_FAILURE);
     747        }
     748        if (!object->bias == 32.32) {
     749            psFree(object);
     750            exit(EXIT_FAILURE);
     751        }
     752        if (!object->bias_stdev == 32.32) {
     753            psFree(object);
     754            exit(EXIT_FAILURE);
     755        }
     756        if (!object->fringe_0 == 32.32) {
     757            psFree(object);
     758            exit(EXIT_FAILURE);
     759        }
     760        if (!object->fringe_1 == 32.32) {
     761            psFree(object);
     762            exit(EXIT_FAILURE);
     763        }
     764        if (!object->fringe_2 == 32.32) {
     765            psFree(object);
     766            exit(EXIT_FAILURE);
     767        }
     768        if (!object->sigma_ra == 32.32) {
     769            psFree(object);
     770            exit(EXIT_FAILURE);
     771        }
     772        if (!object->sigma_dec == 32.32) {
     773            psFree(object);
     774            exit(EXIT_FAILURE);
     775        }
     776        if (!object->ap_resid == 32.32) {
     777            psFree(object);
     778            exit(EXIT_FAILURE);
     779        }
     780        if (!object->ap_resid_stdev == 32.32) {
     781            psFree(object);
     782            exit(EXIT_FAILURE);
     783        }
     784        if (!object->fwhm == 32.32) {
     785            psFree(object);
     786            exit(EXIT_FAILURE);
     787        }
     788        if (!object->fwhm_range == 32.32) {
     789            psFree(object);
     790            exit(EXIT_FAILURE);
     791        }
     792        if (!object->n_stars == -32) {
     793            psFree(object);
     794            exit(EXIT_FAILURE);
     795        }
     796        if (!object->n_extended == -32) {
     797            psFree(object);
     798            exit(EXIT_FAILURE);
     799        }
     800        if (!object->n_cr == -32) {
     801            psFree(object);
     802            exit(EXIT_FAILURE);
     803        }
     804        if (!object->n_astrom == -32) {
    745805            psFree(object);
    746806            exit(EXIT_FAILURE);
    … …  
    802862        camProcessedExpRow *object;
    803863
    804         object = camProcessedExpRowAlloc(-64, -64, "a string", "a string", "a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, 32.32, 32.32, -32, "a string", 32.32, 32.32, -16    );
     864        object = camProcessedExpRowAlloc(-64, -64, "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, -32, -32, -32, -32, "a string", -16    );
    805865
    806866        if (!object) {
    … …  
    840900            exit(EXIT_FAILURE);
    841901        }
    842         if (!object->bg == 64.64) {
    843             psFree(object);
    844             exit(EXIT_FAILURE);
    845         }
    846         if (!object->bg_stdev == 64.64) {
    847             psFree(object);
    848             exit(EXIT_FAILURE);
    849         }
    850         if (!object->bg_mean_stdev == 64.64) {
     902        if (!object->bg == 32.32) {
     903            psFree(object);
     904            exit(EXIT_FAILURE);
     905        }
     906        if (!object->bg_stdev == 32.32) {
     907            psFree(object);
     908            exit(EXIT_FAILURE);
     909        }
     910        if (!object->bg_mean_stdev == 32.32) {
    851911            psFree(object);
    852912            exit(EXIT_FAILURE);
    … …  
    860920            exit(EXIT_FAILURE);
    861921        }
    862         if (!object->nastro == -32) {
     922        if (!object->zp_mean == 32.32) {
     923            psFree(object);
     924            exit(EXIT_FAILURE);
     925        }
     926        if (!object->zp_stdev == 32.32) {
     927            psFree(object);
     928            exit(EXIT_FAILURE);
     929        }
     930        if (!object->fwhm == 32.32) {
     931            psFree(object);
     932            exit(EXIT_FAILURE);
     933        }
     934        if (!object->fwhm_range == 32.32) {
     935            psFree(object);
     936            exit(EXIT_FAILURE);
     937        }
     938        if (!object->n_stars == -32) {
     939            psFree(object);
     940            exit(EXIT_FAILURE);
     941        }
     942        if (!object->n_extended == -32) {
     943            psFree(object);
     944            exit(EXIT_FAILURE);
     945        }
     946        if (!object->n_cr == -32) {
     947            psFree(object);
     948            exit(EXIT_FAILURE);
     949        }
     950        if (!object->n_astrom == -32) {
    863951            psFree(object);
    864952            exit(EXIT_FAILURE);
    865953        }
    866954        if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) {
    867             psFree(object);
    868             exit(EXIT_FAILURE);
    869         }
    870         if (!object->zp_mean == 32.32) {
    871             psFree(object);
    872             exit(EXIT_FAILURE);
    873         }
    874         if (!object->zp_stdev == 32.32) {
    875955            psFree(object);
    876956            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/insert.c

    r13621 r13649  
    253253        }
    254254
    255         if (!chipProcessedImfileInsert(dbh, -64, "a string", "a string", 64.64, 64.64, 64.64, "a string", -16)) {
     255        if (!chipProcessedImfileInsert(dbh, -64, "a string", "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, -32, -32, -32, -32, "a string", -16)) {
    256256            exit(EXIT_FAILURE);
    257257        }
    … …  
    283283        }
    284284
    285         if (!camProcessedExpInsert(dbh, -64, -64, "a string", "a string", "a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, 32.32, 32.32, -32, "a string", 32.32, 32.32, -16)) {
     285        if (!camProcessedExpInsert(dbh, -64, -64, "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, -32, -32, -32, -32, "a string", -16)) {
    286286            exit(EXIT_FAILURE);
    287287        }

  • trunk/ippdb/tests/insertobject.c

    r13621 r13649  
    366366        }
    367367
    368         object = chipProcessedImfileRowAlloc(-64, "a string", "a string", 64.64, 64.64, 64.64, "a string", -16);
     368        object = chipProcessedImfileRowAlloc(-64, "a string", "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, -32, -32, -32, -32, "a string", -16);
    369369        if (!object) {
    370370            exit(EXIT_FAILURE);
    … …  
    410410        }
    411411
    412         object = camProcessedExpRowAlloc(-64, -64, "a string", "a string", "a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, 32.32, 32.32, -32, "a string", 32.32, 32.32, -16);
     412        object = camProcessedExpRowAlloc(-64, -64, "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, -32, -32, -32, -32, "a string", -16);
    413413        if (!object) {
    414414            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/metadatafromobject.c

    r13621 r13649  
    837837        bool            status;
    838838
    839         object = chipProcessedImfileRowAlloc(-64, "a string", "a string", 64.64, 64.64, 64.64, "a string", -16);
     839        object = chipProcessedImfileRowAlloc(-64, "a string", "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, -32, -32, -32, -32, "a string", -16);
    840840        if (!object) {
    841841            exit(EXIT_FAILURE);
    … …  
    860860            exit(EXIT_FAILURE);
    861861        }
    862         if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
    863             psFree(md);
    864             exit(EXIT_FAILURE);
    865         }
    866         if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
    867             psFree(md);
    868             exit(EXIT_FAILURE);
    869         }
    870         if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
     862        if (!psMetadataLookupF32(&status, md, "bg") == 32.32) {
     863            psFree(md);
     864            exit(EXIT_FAILURE);
     865        }
     866        if (!psMetadataLookupF32(&status, md, "bg_stdev") == 32.32) {
     867            psFree(md);
     868            exit(EXIT_FAILURE);
     869        }
     870        if (!psMetadataLookupF32(&status, md, "bg_mean_stdev") == 32.32) {
     871            psFree(md);
     872            exit(EXIT_FAILURE);
     873        }
     874        if (!psMetadataLookupF32(&status, md, "bias") == 32.32) {
     875            psFree(md);
     876            exit(EXIT_FAILURE);
     877        }
     878        if (!psMetadataLookupF32(&status, md, "bias_stdev") == 32.32) {
     879            psFree(md);
     880            exit(EXIT_FAILURE);
     881        }
     882        if (!psMetadataLookupF32(&status, md, "fringe_0") == 32.32) {
     883            psFree(md);
     884            exit(EXIT_FAILURE);
     885        }
     886        if (!psMetadataLookupF32(&status, md, "fringe_1") == 32.32) {
     887            psFree(md);
     888            exit(EXIT_FAILURE);
     889        }
     890        if (!psMetadataLookupF32(&status, md, "fringe_2") == 32.32) {
     891            psFree(md);
     892            exit(EXIT_FAILURE);
     893        }
     894        if (!psMetadataLookupF32(&status, md, "sigma_ra") == 32.32) {
     895            psFree(md);
     896            exit(EXIT_FAILURE);
     897        }
     898        if (!psMetadataLookupF32(&status, md, "sigma_dec") == 32.32) {
     899            psFree(md);
     900            exit(EXIT_FAILURE);
     901        }
     902        if (!psMetadataLookupF32(&status, md, "ap_resid") == 32.32) {
     903            psFree(md);
     904            exit(EXIT_FAILURE);
     905        }
     906        if (!psMetadataLookupF32(&status, md, "ap_resid_stdev") == 32.32) {
     907            psFree(md);
     908            exit(EXIT_FAILURE);
     909        }
     910        if (!psMetadataLookupF32(&status, md, "fwhm") == 32.32) {
     911            psFree(md);
     912            exit(EXIT_FAILURE);
     913        }
     914        if (!psMetadataLookupF32(&status, md, "fwhm_range") == 32.32) {
     915            psFree(md);
     916            exit(EXIT_FAILURE);
     917        }
     918        if (!psMetadataLookupS32(&status, md, "n_stars") == -32) {
     919            psFree(md);
     920            exit(EXIT_FAILURE);
     921        }
     922        if (!psMetadataLookupS32(&status, md, "n_extended") == -32) {
     923            psFree(md);
     924            exit(EXIT_FAILURE);
     925        }
     926        if (!psMetadataLookupS32(&status, md, "n_cr") == -32) {
     927            psFree(md);
     928            exit(EXIT_FAILURE);
     929        }
     930        if (!psMetadataLookupS32(&status, md, "n_astrom") == -32) {
    871931            psFree(md);
    872932            exit(EXIT_FAILURE);
    … …  
    935995        bool            status;
    936996
    937         object = camProcessedExpRowAlloc(-64, -64, "a string", "a string", "a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, 32.32, 32.32, -32, "a string", 32.32, 32.32, -16);
     997        object = camProcessedExpRowAlloc(-64, -64, "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, -32, -32, -32, -32, "a string", -16);
    938998        if (!object) {
    939999            exit(EXIT_FAILURE);
    … …  
    9771037            exit(EXIT_FAILURE);
    9781038        }
    979         if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
    980             psFree(md);
    981             exit(EXIT_FAILURE);
    982         }
    983         if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
    984             psFree(md);
    985             exit(EXIT_FAILURE);
    986         }
    987         if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
     1039        if (!psMetadataLookupF32(&status, md, "bg") == 32.32) {
     1040            psFree(md);
     1041            exit(EXIT_FAILURE);
     1042        }
     1043        if (!psMetadataLookupF32(&status, md, "bg_stdev") == 32.32) {
     1044            psFree(md);
     1045            exit(EXIT_FAILURE);
     1046        }
     1047        if (!psMetadataLookupF32(&status, md, "bg_mean_stdev") == 32.32) {
    9881048            psFree(md);
    9891049            exit(EXIT_FAILURE);
    … …  
    9971057            exit(EXIT_FAILURE);
    9981058        }
    999         if (!psMetadataLookupS32(&status, md, "nastro") == -32) {
     1059        if (!psMetadataLookupF32(&status, md, "zp_mean") == 32.32) {
     1060            psFree(md);
     1061            exit(EXIT_FAILURE);
     1062        }
     1063        if (!psMetadataLookupF32(&status, md, "zp_stdev") == 32.32) {
     1064            psFree(md);
     1065            exit(EXIT_FAILURE);
     1066        }
     1067        if (!psMetadataLookupF32(&status, md, "fwhm") == 32.32) {
     1068            psFree(md);
     1069            exit(EXIT_FAILURE);
     1070        }
     1071        if (!psMetadataLookupF32(&status, md, "fwhm_range") == 32.32) {
     1072            psFree(md);
     1073            exit(EXIT_FAILURE);
     1074        }
     1075        if (!psMetadataLookupS32(&status, md, "n_stars") == -32) {
     1076            psFree(md);
     1077            exit(EXIT_FAILURE);
     1078        }
     1079        if (!psMetadataLookupS32(&status, md, "n_extended") == -32) {
     1080            psFree(md);
     1081            exit(EXIT_FAILURE);
     1082        }
     1083        if (!psMetadataLookupS32(&status, md, "n_cr") == -32) {
     1084            psFree(md);
     1085            exit(EXIT_FAILURE);
     1086        }
     1087        if (!psMetadataLookupS32(&status, md, "n_astrom") == -32) {
    10001088            psFree(md);
    10011089            exit(EXIT_FAILURE);
    10021090        }
    10031091        if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) {
    1004             psFree(md);
    1005             exit(EXIT_FAILURE);
    1006         }
    1007         if (!psMetadataLookupF32(&status, md, "zp_mean") == 32.32) {
    1008             psFree(md);
    1009             exit(EXIT_FAILURE);
    1010         }
    1011         if (!psMetadataLookupF32(&status, md, "zp_stdev") == 32.32) {
    10121092            psFree(md);
    10131093            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/objectfrommetadata.c

    r13621 r13649  
    12881288            exit(EXIT_FAILURE);
    12891289        }
    1290         if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) {
    1291             psFree(md);
    1292             exit(EXIT_FAILURE);
    1293         }
    1294         if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) {
    1295             psFree(md);
    1296             exit(EXIT_FAILURE);
    1297         }
    1298         if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) {
     1290        if (!psMetadataAddF32(md, PS_LIST_TAIL, "bg", 0, NULL, 32.32)) {
     1291            psFree(md);
     1292            exit(EXIT_FAILURE);
     1293        }
     1294        if (!psMetadataAddF32(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 32.32)) {
     1295            psFree(md);
     1296            exit(EXIT_FAILURE);
     1297        }
     1298        if (!psMetadataAddF32(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 32.32)) {
     1299            psFree(md);
     1300            exit(EXIT_FAILURE);
     1301        }
     1302        if (!psMetadataAddF32(md, PS_LIST_TAIL, "bias", 0, NULL, 32.32)) {
     1303            psFree(md);
     1304            exit(EXIT_FAILURE);
     1305        }
     1306        if (!psMetadataAddF32(md, PS_LIST_TAIL, "bias_stdev", 0, NULL, 32.32)) {
     1307            psFree(md);
     1308            exit(EXIT_FAILURE);
     1309        }
     1310        if (!psMetadataAddF32(md, PS_LIST_TAIL, "fringe_0", 0, NULL, 32.32)) {
     1311            psFree(md);
     1312            exit(EXIT_FAILURE);
     1313        }
     1314        if (!psMetadataAddF32(md, PS_LIST_TAIL, "fringe_1", 0, NULL, 32.32)) {
     1315            psFree(md);
     1316            exit(EXIT_FAILURE);
     1317        }
     1318        if (!psMetadataAddF32(md, PS_LIST_TAIL, "fringe_2", 0, NULL, 32.32)) {
     1319            psFree(md);
     1320            exit(EXIT_FAILURE);
     1321        }
     1322        if (!psMetadataAddF32(md, PS_LIST_TAIL, "sigma_ra", 0, NULL, 32.32)) {
     1323            psFree(md);
     1324            exit(EXIT_FAILURE);
     1325        }
     1326        if (!psMetadataAddF32(md, PS_LIST_TAIL, "sigma_dec", 0, NULL, 32.32)) {
     1327            psFree(md);
     1328            exit(EXIT_FAILURE);
     1329        }
     1330        if (!psMetadataAddF32(md, PS_LIST_TAIL, "ap_resid", 0, NULL, 32.32)) {
     1331            psFree(md);
     1332            exit(EXIT_FAILURE);
     1333        }
     1334        if (!psMetadataAddF32(md, PS_LIST_TAIL, "ap_resid_stdev", 0, NULL, 32.32)) {
     1335            psFree(md);
     1336            exit(EXIT_FAILURE);
     1337        }
     1338        if (!psMetadataAddF32(md, PS_LIST_TAIL, "fwhm", 0, NULL, 32.32)) {
     1339            psFree(md);
     1340            exit(EXIT_FAILURE);
     1341        }
     1342        if (!psMetadataAddF32(md, PS_LIST_TAIL, "fwhm_range", 0, NULL, 32.32)) {
     1343            psFree(md);
     1344            exit(EXIT_FAILURE);
     1345        }
     1346        if (!psMetadataAddS32(md, PS_LIST_TAIL, "n_stars", 0, NULL, -32)) {
     1347            psFree(md);
     1348            exit(EXIT_FAILURE);
     1349        }
     1350        if (!psMetadataAddS32(md, PS_LIST_TAIL, "n_extended", 0, NULL, -32)) {
     1351            psFree(md);
     1352            exit(EXIT_FAILURE);
     1353        }
     1354        if (!psMetadataAddS32(md, PS_LIST_TAIL, "n_cr", 0, NULL, -32)) {
     1355            psFree(md);
     1356            exit(EXIT_FAILURE);
     1357        }
     1358        if (!psMetadataAddS32(md, PS_LIST_TAIL, "n_astrom", 0, NULL, -32)) {
    12991359            psFree(md);
    13001360            exit(EXIT_FAILURE);
    … …  
    13271387            exit(EXIT_FAILURE);
    13281388        }
    1329         if (!object->bg == 64.64) {
    1330             psFree(object);
    1331             exit(EXIT_FAILURE);
    1332         }
    1333         if (!object->bg_stdev == 64.64) {
    1334             psFree(object);
    1335             exit(EXIT_FAILURE);
    1336         }
    1337         if (!object->bg_mean_stdev == 64.64) {
     1389        if (!object->bg == 32.32) {
     1390            psFree(object);
     1391            exit(EXIT_FAILURE);
     1392        }
     1393        if (!object->bg_stdev == 32.32) {
     1394            psFree(object);
     1395            exit(EXIT_FAILURE);
     1396        }
     1397        if (!object->bg_mean_stdev == 32.32) {
     1398            psFree(object);
     1399            exit(EXIT_FAILURE);
     1400        }
     1401        if (!object->bias == 32.32) {
     1402            psFree(object);
     1403            exit(EXIT_FAILURE);
     1404        }
     1405        if (!object->bias_stdev == 32.32) {
     1406            psFree(object);
     1407            exit(EXIT_FAILURE);
     1408        }
     1409        if (!object->fringe_0 == 32.32) {
     1410            psFree(object);
     1411            exit(EXIT_FAILURE);
     1412        }
     1413        if (!object->fringe_1 == 32.32) {
     1414            psFree(object);
     1415            exit(EXIT_FAILURE);
     1416        }
     1417        if (!object->fringe_2 == 32.32) {
     1418            psFree(object);
     1419            exit(EXIT_FAILURE);
     1420        }
     1421        if (!object->sigma_ra == 32.32) {
     1422            psFree(object);
     1423            exit(EXIT_FAILURE);
     1424        }
     1425        if (!object->sigma_dec == 32.32) {
     1426            psFree(object);
     1427            exit(EXIT_FAILURE);
     1428        }
     1429        if (!object->ap_resid == 32.32) {
     1430            psFree(object);
     1431            exit(EXIT_FAILURE);
     1432        }
     1433        if (!object->ap_resid_stdev == 32.32) {
     1434            psFree(object);
     1435            exit(EXIT_FAILURE);
     1436        }
     1437        if (!object->fwhm == 32.32) {
     1438            psFree(object);
     1439            exit(EXIT_FAILURE);
     1440        }
     1441        if (!object->fwhm_range == 32.32) {
     1442            psFree(object);
     1443            exit(EXIT_FAILURE);
     1444        }
     1445        if (!object->n_stars == -32) {
     1446            psFree(object);
     1447            exit(EXIT_FAILURE);
     1448        }
     1449        if (!object->n_extended == -32) {
     1450            psFree(object);
     1451            exit(EXIT_FAILURE);
     1452        }
     1453        if (!object->n_cr == -32) {
     1454            psFree(object);
     1455            exit(EXIT_FAILURE);
     1456        }
     1457        if (!object->n_astrom == -32) {
    13381458            psFree(object);
    13391459            exit(EXIT_FAILURE);
    … …  
    14551575            exit(EXIT_FAILURE);
    14561576        }
    1457         if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) {
    1458             psFree(md);
    1459             exit(EXIT_FAILURE);
    1460         }
    1461         if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) {
    1462             psFree(md);
    1463             exit(EXIT_FAILURE);
    1464         }
    1465         if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) {
     1577        if (!psMetadataAddF32(md, PS_LIST_TAIL, "bg", 0, NULL, 32.32)) {
     1578            psFree(md);
     1579            exit(EXIT_FAILURE);
     1580        }
     1581        if (!psMetadataAddF32(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 32.32)) {
     1582            psFree(md);
     1583            exit(EXIT_FAILURE);
     1584        }
     1585        if (!psMetadataAddF32(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 32.32)) {
    14661586            psFree(md);
    14671587            exit(EXIT_FAILURE);
    … …  
    14751595            exit(EXIT_FAILURE);
    14761596        }
    1477         if (!psMetadataAddS32(md, PS_LIST_TAIL, "nastro", 0, NULL, -32)) {
     1597        if (!psMetadataAddF32(md, PS_LIST_TAIL, "zp_mean", 0, NULL, 32.32)) {
     1598            psFree(md);
     1599            exit(EXIT_FAILURE);
     1600        }
     1601        if (!psMetadataAddF32(md, PS_LIST_TAIL, "zp_stdev", 0, NULL, 32.32)) {
     1602            psFree(md);
     1603            exit(EXIT_FAILURE);
     1604        }
     1605        if (!psMetadataAddF32(md, PS_LIST_TAIL, "fwhm", 0, NULL, 32.32)) {
     1606            psFree(md);
     1607            exit(EXIT_FAILURE);
     1608        }
     1609        if (!psMetadataAddF32(md, PS_LIST_TAIL, "fwhm_range", 0, NULL, 32.32)) {
     1610            psFree(md);
     1611            exit(EXIT_FAILURE);
     1612        }
     1613        if (!psMetadataAddS32(md, PS_LIST_TAIL, "n_stars", 0, NULL, -32)) {
     1614            psFree(md);
     1615            exit(EXIT_FAILURE);
     1616        }
     1617        if (!psMetadataAddS32(md, PS_LIST_TAIL, "n_extended", 0, NULL, -32)) {
     1618            psFree(md);
     1619            exit(EXIT_FAILURE);
     1620        }
     1621        if (!psMetadataAddS32(md, PS_LIST_TAIL, "n_cr", 0, NULL, -32)) {
     1622            psFree(md);
     1623            exit(EXIT_FAILURE);
     1624        }
     1625        if (!psMetadataAddS32(md, PS_LIST_TAIL, "n_astrom", 0, NULL, -32)) {
    14781626            psFree(md);
    14791627            exit(EXIT_FAILURE);
    … …  
    14831631            exit(EXIT_FAILURE);
    14841632        }
    1485         if (!psMetadataAddF32(md, PS_LIST_TAIL, "zp_mean", 0, NULL, 32.32)) {
    1486             psFree(md);
    1487             exit(EXIT_FAILURE);
    1488         }
    1489         if (!psMetadataAddF32(md, PS_LIST_TAIL, "zp_stdev", 0, NULL, 32.32)) {
    1490             psFree(md);
    1491             exit(EXIT_FAILURE);
    1492         }
    14931633            psFree(md);
    14941634            exit(EXIT_FAILURE);
    … …  
    15331673            exit(EXIT_FAILURE);
    15341674        }
    1535         if (!object->bg == 64.64) {
    1536             psFree(object);
    1537             exit(EXIT_FAILURE);
    1538         }
    1539         if (!object->bg_stdev == 64.64) {
    1540             psFree(object);
    1541             exit(EXIT_FAILURE);
    1542         }
    1543         if (!object->bg_mean_stdev == 64.64) {
     1675        if (!object->bg == 32.32) {
     1676            psFree(object);
     1677            exit(EXIT_FAILURE);
     1678        }
     1679        if (!object->bg_stdev == 32.32) {
     1680            psFree(object);
     1681            exit(EXIT_FAILURE);
     1682        }
     1683        if (!object->bg_mean_stdev == 32.32) {
    15441684            psFree(object);
    15451685            exit(EXIT_FAILURE);
    … …  
    15531693            exit(EXIT_FAILURE);
    15541694        }
    1555         if (!object->nastro == -32) {
     1695        if (!object->zp_mean == 32.32) {
     1696            psFree(object);
     1697            exit(EXIT_FAILURE);
     1698        }
     1699        if (!object->zp_stdev == 32.32) {
     1700            psFree(object);
     1701            exit(EXIT_FAILURE);
     1702        }
     1703        if (!object->fwhm == 32.32) {
     1704            psFree(object);
     1705            exit(EXIT_FAILURE);
     1706        }
     1707        if (!object->fwhm_range == 32.32) {
     1708            psFree(object);
     1709            exit(EXIT_FAILURE);
     1710        }
     1711        if (!object->n_stars == -32) {
     1712            psFree(object);
     1713            exit(EXIT_FAILURE);
     1714        }
     1715        if (!object->n_extended == -32) {
     1716            psFree(object);
     1717            exit(EXIT_FAILURE);
     1718        }
     1719        if (!object->n_cr == -32) {
     1720            psFree(object);
     1721            exit(EXIT_FAILURE);
     1722        }
     1723        if (!object->n_astrom == -32) {
    15561724            psFree(object);
    15571725            exit(EXIT_FAILURE);
    15581726        }
    15591727        if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) {
    1560             psFree(object);
    1561             exit(EXIT_FAILURE);
    1562         }
    1563         if (!object->zp_mean == 32.32) {
    1564             psFree(object);
    1565             exit(EXIT_FAILURE);
    1566         }
    1567         if (!object->zp_stdev == 32.32) {
    15681728            psFree(object);
    15691729            exit(EXIT_FAILURE);
Note: See TracChangeset for help on using the changeset viewer.