IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 36441 for trunk/psModules


Ignore:
Timestamp:
Jan 14, 2014, 2:28:47 PM (12 years ago)
Author:
bills
Message:

Iniital implementation of the full force stages to the pipeline.
Maginitude and galactic coordinate limits on extended source fits

Location:
trunk
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk

  • trunk/psModules

  • trunk/psModules/src/camera/pmFPAfile.c

    r36375 r36441  
    565565      case PM_FPA_FILE_CMF:
    566566        return ("CMF");
     567      case PM_FPA_FILE_CFF:
     568        return ("CFF");
    567569      case PM_FPA_FILE_WCS:
    568570        return ("WCS");

  • trunk/psModules/src/objects/pmModelClass.c

    r34259 r36441  
    6666
    6767static pmModelClass *models = NULL;
     68static psVector *modelClassLookupTable = NULL;  // translation between model types in header and here
    6869static int Nmodels = 0;
    6970
    … …  
    135136    models = NULL;
    136137    Nmodels = 0;
     138    psFree(modelClassLookupTable);
     139    modelClassLookupTable = NULL;
    137140    return;
    138141}
    … …  
    193196}
    194197
     198
     199bool pmModelClassWriteHeader(psMetadata *header)
     200{
     201    psMetadataAddS32(header, PS_LIST_TAIL, "MTNUM", PS_META_REPLACE, "number of model types", Nmodels);
     202    for (int i = 0; i < Nmodels; i++) {
     203        char modelNameKey[16];
     204        char modelValKey[16];
     205        sprintf(modelNameKey, "MTNAM%02d", i);
     206        sprintf(modelValKey,  "MTVAL%02d", i);
     207        psMetadataAddStr(header, PS_LIST_TAIL, modelNameKey, PS_META_REPLACE, "", models[i].name);
     208        psMetadataAddS32(header, PS_LIST_TAIL, modelValKey, PS_META_REPLACE, "", i);
     209    }
     210
     211    return true;
     212}
     213
     214bool pmModelClassReadHeader(psMetadata *header) {
     215    psFree(modelClassLookupTable);
     216
     217    bool status;
     218    int numHeaderModels = psMetadataLookupS32(&status, header, "MTNUM");
     219    if (!status) {
     220        return false;
     221    }
     222
     223    psVector *inputTypes = psVectorAlloc(numHeaderModels, PS_TYPE_S32);
     224    psVector *localTypes = psVectorAlloc(numHeaderModels, PS_TYPE_S32);
     225    int max_val = -1;
     226    for (int i = 0; i < numHeaderModels; i++) {
     227        char modelNameKey[16];
     228        char modelValKey[16];
     229        sprintf(modelNameKey, "MTNAM%02d", i);
     230        sprintf(modelValKey,  "MTVAL%02d", i);
     231        psString thisName = psMetadataLookupStr(&status, header, modelNameKey);
     232        int thisVal = psMetadataLookupS32(&status, header, modelValKey);
     233        if (thisVal > max_val) {
     234            max_val = thisVal;
     235        }
     236        inputTypes->data.S32[i] = thisVal;
     237        localTypes->data.S32[i] = pmModelClassGetType(thisName);
     238    }
     239    if (max_val < 0) {
     240        psFree(inputTypes);
     241        psFree(localTypes);
     242        return false;
     243    }
     244
     245    modelClassLookupTable = psVectorAlloc(max_val + 1, PS_TYPE_S32);
     246    psVectorInit(modelClassLookupTable, -1);
     247
     248    for (int i = 0; i < numHeaderModels; i++) {
     249        int thisVal = inputTypes->data.S32[i];
     250        int localVal = localTypes->data.S32[i];
     251        modelClassLookupTable->data.S32[thisVal] = localVal;
     252    }
     253    psFree(inputTypes);
     254    psFree(localTypes);
     255
     256    return true;
     257}
     258
     259pmModelType pmModelClassGetLocalType(pmModelType inputType) {
     260    pmModelType localType = -1;
     261
     262    if (modelClassLookupTable) {
     263        if (inputType >= 0 && inputType < modelClassLookupTable->n) {
     264            localType = modelClassLookupTable->data.S32[inputType];
     265        }
     266    } else {
     267        // no lookup table defined
     268        // for backwards compatability if inputType refers to a defined model, return it
     269        if (inputType >= 0 && pmModelClassGetName(inputType)) {
     270            localType = inputType;
     271        }
     272    }
     273
     274    return localType;
     275}

  • trunk/psModules/src/objects/pmModelClass.h

    r29004 r36441  
    7676void pmModelClassSetLimits(pmModelLimitsType type);
    7777
     78// write keywords to header definining the model type values used by this program
     79bool pmModelClassWriteHeader(psMetadata *header);
     80// create a lookup table for translating input model type values to local model type values
     81bool pmModelClassReadHeader(psMetadata *header);
     82// translate input model type value to local value
     83pmModelType pmModelClassGetLocalType(pmModelType inputType);
    7884
    7985/// @}

  • trunk/psModules/src/objects/pmSourceIO.c

    r36375 r36441  
    6161static bool pmReadoutReadXFIT(pmFPAfile *file, pmReadout *readout, char * exttype, psMetadata *hduHeader, psString xfitname, psArray *sources, long *sourceIndex);
    6262static bool pmReadoutReadXRAD(pmFPAfile *file, pmReadout *readout, char * exttype, psMetadata *hduHeader, psString xfitname, psArray *sources, long *sourceIndex);
     63static bool pmReadoutReadXGAL(pmFPAfile *file, pmReadout *readout, char * exttype, psMetadata *hduHeader, psString xfitname, psArray *sources, long *sourceIndex);
    6364
    6465// lookup the EXTNAME values used for table data and image header segments
    … …  
    374375        }                                                               \
    375376        if (xgalname) {                                                 \
    376             status &= pmSourcesWrite_##TYPE##_XGAL (file->fits, sources, xgalname, recipe); \
     377            status &= pmSourcesWrite_##TYPE##_XGAL (file->fits, readout, sources, xgalname, recipe); \
    377378        }                                                               \
    378379    }
    … …  
    10361037        bool XFIT_OUTPUT = psMetadataLookupBool(&status, recipe, "EXTENDED_SOURCE_FITS");
    10371038        bool XRAD_OUTPUT = psMetadataLookupBool(&status, recipe, "RADIAL_APERTURES");
    1038         bool XGAL_OUTPUT = false; // psMetadataLookupBool(&status, recipe, "GALAXY_SHAPES");
     1039        bool XGAL_OUTPUT = psMetadataLookupBool(&status, recipe, "GALAXY_SHAPES");
    10391040
    10401041        if (!pmSourceIOextnames(&headname, &dataname, &deteffname,
    … …  
    11221123
    11231124            long *sourceIndex = NULL;
    1124             if (XSRC_OUTPUT || XFIT_OUTPUT || XRAD_OUTPUT) {
     1125            if (XSRC_OUTPUT || XFIT_OUTPUT || XRAD_OUTPUT || XGAL_OUTPUT) {
     1126                // Build sourceIndex. Lookup table from source->seq to index in sources array.
     1127                // Consists of an array of length max(source->seq) + 1.
     1128
     1129                // find maximum sequence number
    11251130                long seq_max = -1;
    11261131                for (long i = sources->n -1; i >= 0; i--) {
    … …  
    11351140                    }
    11361141                }
     1142                // allocate and initialize the index
    11371143                sourceIndex = psAlloc((seq_max + 1) * sizeof(long));
    11381144                for (long i = 0; i < seq_max; i++) {
    11391145                    sourceIndex[i] = -1;
    11401146                }
     1147                // populate the index
    11411148                for (long i = 0; i < sources->n; i++) {
    11421149                    pmSource *source = sources->data[i];
    … …  
    11651172                psFree(xradname);
    11661173            }
     1174            if (XGAL_OUTPUT && xgalname) {
     1175                // a cmf file may have an XGAL extension, but it is not required
     1176                if (!pmReadoutReadXGAL(file, readout, exttype, hdu->header, xgalname, sources, sourceIndex)) {
     1177                    // do anything?
     1178                }
     1179                psFree(xgalname);
     1180            }
    11671181            psFree(sourceIndex);
    11681182
    … …  
    14611475    return status;
    14621476}
     1477static bool pmReadoutReadXGAL(pmFPAfile *file, pmReadout *readout, char *exttype, psMetadata *hduHeader, psString xgalname, psArray *sources, long *sourceIndex)
     1478{
     1479    if (!psFitsMoveExtNameClean (file->fits, xgalname)) {
     1480        psTrace ("pmFPAfile", 1, "cannot find xgal extension %s in %s, skipping", xgalname, file->filename);
     1481        return false;
     1482    }
     1483
     1484    psMetadata *tableHeader = psFitsReadHeader(NULL, file->fits); // The FITS header
     1485    if (!tableHeader) psAbort("cannot read table header");
     1486
     1487    char *xtension = psMetadataLookupStr (NULL, tableHeader, "XTENSION");
     1488    if (!xtension) psAbort("cannot read table type");
     1489    if (strcmp (xtension, "BINTABLE")) {
     1490        psFree(tableHeader);
     1491        psWarning ("no binary table in extension %s, skipping\n", xgalname);
     1492        return false;
     1493    }
     1494
     1495# define PM_SOURCES_READ_XGAL(NAME,TYPE)                                \
     1496    if (!strcmp (exttype, NAME)) {                                      \
     1497        status = pmSourcesRead_##TYPE##_XGAL(file->fits, readout, hduHeader, tableHeader, sources, sourceIndex); \
     1498    }                                                                   
     1499
     1500    bool status = false;
     1501    if (file->type == PM_FPA_FILE_CMF) {
     1502        PM_SOURCES_READ_XGAL("PS1_V1",    CMF_PS1_V1);
     1503        PM_SOURCES_READ_XGAL("PS1_V2",    CMF_PS1_V2);
     1504        PM_SOURCES_READ_XGAL("PS1_V3",    CMF_PS1_V3);
     1505        PM_SOURCES_READ_XGAL("PS1_V4",    CMF_PS1_V4);
     1506        PM_SOURCES_READ_XGAL("PS1_SV1",   CMF_PS1_SV1);
     1507        PM_SOURCES_READ_XGAL("PS1_SV2",   CMF_PS1_SV2);
     1508        PM_SOURCES_READ_XGAL("PS1_DV1",   CMF_PS1_DV1);
     1509        PM_SOURCES_READ_XGAL("PS1_DV2",   CMF_PS1_DV2);
     1510        PM_SOURCES_READ_XGAL("PS1_DV3",   CMF_PS1_DV3);
     1511    }
     1512    psFree(tableHeader);
     1513    return status;
     1514}

  • trunk/psModules/src/objects/pmSourceIO.h

    r36375 r36441  
    2121  bool pmSourcesWrite_##TYPE##_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname); \
    2222  bool pmSourcesWrite_##TYPE##_XRAD(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe); \
    23   bool pmSourcesWrite_##TYPE##_XGAL(psFits *fits, psArray *sources, char *extname, psMetadata *recipe); \
     23  bool pmSourcesWrite_##TYPE##_XGAL(psFits *fits, pmReadout *readout, psArray *sources, char *extname, psMetadata *recipe); \
    2424  psArray *pmSourcesRead_##TYPE (psFits *fits, psMetadata *header); \
    2525  bool pmSourcesRead_##TYPE##_XSRC (psFits *fits, pmReadout *readout, psMetadata *header, psMetadata *tableHeader, psArray *sources, long *index); \
    2626  bool pmSourcesRead_##TYPE##_XFIT (psFits *fits, pmReadout *readout, psMetadata *header, psMetadata *tableHeader, psArray *sources, long *index); \
    2727  bool pmSourcesRead_##TYPE##_XRAD (psFits *fits, pmReadout *readout, psMetadata *header, psMetadata *tableHeader, psArray *sources, long *index);\
     28  bool pmSourcesRead_##TYPE##_XGAL (psFits *fits, pmReadout *readout, psMetadata *header, psMetadata *tableHeader, psArray *sources, long *index);\
    2829 
    2930// All of these functions need to use the same API, even if not all elements are used in a specific case

  • trunk/psModules/src/objects/pmSourceIO_CFF.c

    r36375 r36441  
    6565    int modelType = pmModelClassGetType ("PS_MODEL_GAUSS");
    6666
     67    // Read lookup table for model classes (if defined)
     68    pmModelClassReadHeader(header);
     69
    6770    char *PSF_NAME = psMetadataLookupStr (&status, header, "PSFMODEL");
    6871    if (PSF_NAME != NULL) {
    … …  
    111114        float theta      = psMetadataLookupF32 (&status, row, "THETA");
    112115
    113         // XXX: we need to put a lookup table in the cff header to define the correspondence of the
    114         // model type values in the cff with our models. (We want to use an interger for efficiency
    115         // but the value for each model type is set on the organization of the the array in pmModelClass.c
    116         // For now use the input values verbatim and trust the user that this is valid value
    117116        int   galaxyModelType = psMetadataLookupS32(&status, row, "MODEL_TYPE");
     117        if (status) {
     118            galaxyModelType = pmModelClassGetLocalType(galaxyModelType);
     119        } else {
     120            galaxyModelType = -1;
     121        }
    118122        float Sindex     = psMetadataLookupF32 (&status, row, "INDEX"); // Should this be PAR_07 not sersic index
    119123
    … …  
    123127        source->type = PM_SOURCE_TYPE_STAR; // XXX this should be added to the flags
    124128
    125         // XXX we can set this in general, but for a specific image, we need to weed out SATSTARS
     129        // XXX we can set this in general, but for a specific image, we need to weed out SATSTARS and
     130        // stars that are masked
    126131        if (psfStar) {
    127132            source->tmpFlags |= PM_SOURCE_TMPF_CANDIDATE_PSFSTAR;
    … …  
    180185        }
    181186
    182         // XXX: should use < 0 as invalid galaxyModelType
    183 
    184         if (fitGalaxy && galaxyModelType > 0) {
     187        if (fitGalaxy && galaxyModelType >= 0) {
    185188            source->modelFits = psArrayAllocEmpty (1);
    186189            pmModel *model = pmModelAlloc(galaxyModelType);
    … …  
    235238    PS_ASSERT(mdok, false);
    236239
     240    // write the definition of the model class type values to the header
     241    psMetadata *outputHeader = psMetadataAlloc();
     242    pmModelClassWriteHeader(outputHeader);
     243
    237244    psArray *table = psArrayAllocEmpty(sources->n);
    238245
    … …  
    246253        psS32 modelType = 0;
    247254        bool fitGalaxy = false;
    248         bool psfStar = false;
     255        bool psfStar = (source->mode & PM_SOURCE_MODE_PSFSTAR) ? true : false;
    249256        psF32 sersicIndex = 0;
    250         if (source->modelFits == NULL) {
     257        // For now only perform galaxy fits on extended objects
     258        if (source->modelEXT == NULL) {
    251259            pmModel *model = source->modelPSF;
    252260            if (model == NULL) continue;
    … …  
    260268            yPos = model->params->data.F32[PM_PAR_YPOS];
    261269            flux = source->psfFlux;
    262             psfStar = (source->mode & PM_SOURCE_MODE_PSFSTAR) ? true : false;
    263270            rMajor = 0;
    264271            rMinor = 0;
    … …  
    329336
    330337        psArrayAdd(table, 100, row);
     338        psFree(row);
    331339    }
    332340
    333     if (!psFitsWriteTable(fits, NULL, table, extname)) {
     341    if (!psFitsWriteTable(fits, outputHeader, table, extname)) {
    334342        psError(psErrorCodeLast(), false, "writing ext data %s\n", extname);
    335343        psFree(table);
    336         psFree(header);
     344        psFree(outputHeader);
    337345        return false;
    338346    }
    339347    psFree(table);
    340     // psFree(header);
     348    psFree(outputHeader);
    341349
    342350    return true;

  • trunk/psModules/src/objects/pmSourceIO_CMF.c.in

    r36375 r36441  
    708708            return false;
    709709        }
    710         // Find the source with this sequence number.
    711         // XXX: I am assuming that sources is sorted in order of seq
     710        // Find the source with this sequence number using the sourceIndex.
    712711        long seq = psMetadataLookupU32 (&status, row, "IPP_IDET");
    713         pmSource *source = NULL;
    714 #ifndef ASSUME_SORTED
    715         long j = seq < sources->n ? seq : sources->n - 1;
    716         for (; j >= 0; j--) {
    717             source = sources->data[j];
    718             if (source->seq == seq) {
    719                 break;
    720             }
    721         }
    722 #else
    723712        long j = sourceIndex[seq];
    724713        psAssert(j >= 0 && j < sources->n, "invalid sourceIndex");
    725         source = sources->data[j];
    726 #endif
     714        pmSource *source = sources->data[j];
    727715        if (!source) {
    728716            psError(PS_ERR_UNKNOWN, false, "Failed to find source for row %ld sequence number %ld\n", i, seq);
    … …  
    793781    // create a header to hold the output data
    794782    psMetadata *outhead = psMetadataAlloc ();
     783
     784    pmModelClassWriteHeader(outhead);
    795785
    796786    // write the links to the image header
    … …  
    10341024        return false;
    10351025    }
     1026    // set up the lookup table to translate between input model types and output model types
     1027    // if not defined it is assumed that the tables are the same
     1028    pmModelClassReadHeader(tableHeader);
    10361029
    10371030    for (long i = 0; i < numSources; i++) {
    … …  
    10421035            return false;
    10431036        }
    1044         // Find the source with this sequence number.
    1045         // XXX: I am assuming that sources is sorted in order of seq.
    10461037        long seq = psMetadataLookupU32 (&status, row, "IPP_IDET");
    1047         long j = seq < sources->n ? seq : sources->n - 1;
    1048         pmSource *source = NULL;
    1049         for (; j >= 0; j--) {
    1050             source = sources->data[j];
    1051             if (source->seq == seq) {
    1052                 break;
    1053             }
    1054         }
     1038        long j = sourceIndex[seq];
     1039        psAssert(j >= 0 && j < sources->n, "invalid sourceIndex");
     1040        pmSource *source = sources->data[j];
    10551041        if (!source) {
    10561042            psError(PS_ERR_UNKNOWN, false, "Failed to find source for row %ld sequence number %ld\n", i, seq);
    … …  
    10951081        // in the psf table.
    10961082        psS32 extModelType = psMetadataLookupS32(&status, row, "EXT_MODEL_TYPE");
    1097         if (!status) {
     1083        if (status) {
     1084            // translate between the type value in xfit and values used by this program
     1085            extModelType = pmModelClassGetLocalType(extModelType);
     1086        } else {
    10981087            // older cmfs don't have this column
    10991088            extModelType = -1;
    1100         }
     1089        } 
    11011090
    11021091        psEllipseAxes axes;
    … …  
    13391328            return false;
    13401329        }
    1341         // Find the source with this sequence number.
    1342         // XXX: I am assuming that sources is sorted in order of seq.
    13431330        long seq = psMetadataLookupU32 (&status, row, "IPP_IDET");
    1344         long j = seq < sources->n ? seq : sources->n - 1;
    1345         pmSource *source = NULL;
    1346         for (; j >= 0; j--) {
    1347             source = sources->data[j];
    1348             if (source->seq == seq) {
    1349                 break;
    1350             }
    1351         }
     1331        long j = sourceIndex[seq];
     1332        psAssert(j >= 0 && j < sources->n, "invalid sourceIndex");
     1333        pmSource *source = sources->data[j];
    13521334        if (!source) {
    13531335            psError(PS_ERR_UNKNOWN, false, "Failed to find source for row %ld sequence number %ld\n", i, seq);
    … …  
    14071389
    14081390// XXX where should I record the number of columns??
    1409 bool pmSourcesWrite_CMF_@CMFMODE@_XGAL (psFits *fits, psArray *sources, char *extname, psMetadata *recipe)
     1391bool pmSourcesWrite_CMF_@CMFMODE@_XGAL (psFits *fits, pmReadout *readout, psArray *sources, char *extname, psMetadata *recipe)
    14101392{
    14111393    bool status = false;
    … …  
    14221404    // write the links to the image header
    14231405    psMetadataAddStr (outhead, PS_LIST_TAIL, "EXTNAME", PS_META_REPLACE, "galaxy table extension", extname);
     1406
     1407    psMetadataAddStr (outhead, PS_LIST_TAIL, "HI", PS_META_REPLACE, "does this get through?", "THERE");
    14241408
    14251409    // let's write these out in S/N order
    … …  
    14911475}
    14921476
     1477bool pmSourcesRead_CMF_@CMFMODE@_XGAL(psFits *fits, pmReadout *readout, psMetadata *hduHeader, psMetadata *tableHeader, psArray *sources, long *sourceIndex)
     1478{
     1479    PS_ASSERT_PTR_NON_NULL(fits, false);
     1480    PS_ASSERT_PTR_NON_NULL(sources, false);
     1481
     1482    bool status;
     1483    long numSources = psFitsTableSize(fits); // Number of sources in table
     1484    if (numSources == 0) {
     1485        psError(psErrorCodeLast(), false, "XGAL Table contains no entries\n");
     1486        return false;
     1487    }
     1488
     1489    for (long i = 0; i < numSources; i++) {
     1490        psMetadata *row = psFitsReadTableRow(fits, i); // Table row
     1491        if (!row) {
     1492            psError(psErrorCodeLast(), false, "Unable to read row %ld of sources", i);
     1493            psFree(row);
     1494            return false;
     1495        }
     1496        // Find the source with this sequence number.
     1497        // XXX: I am assuming that sources is sorted in order of seq
     1498        long seq = psMetadataLookupU32 (&status, row, "IPP_IDET");
     1499        long j = sourceIndex[seq];
     1500        psAssert(j >= 0 && j < sources->n, "invalid sourceIndex");
     1501
     1502        pmSource *source = sources->data[j];
     1503        if (!source) {
     1504            psError(PS_ERR_UNKNOWN, false, "Failed to find source for row %ld sequence number %ld\n", i, seq);
     1505            psFree(row);
     1506            return false;
     1507        }
     1508
     1509        psVector *Flux  = psMetadataLookupVector(&status, row, "GAL_FLUX");
     1510        psVector *dFlux = psMetadataLookupVector(&status, row, "GAL_FLUX_ERR");
     1511        psVector *chisq = psMetadataLookupVector(&status, row, "GAL_CHISQ");
     1512
     1513        if (Flux && Flux->n > 0) {
     1514            psFree(source->galaxyFits);
     1515            source->galaxyFits = pmSourceGalaxyFitsAlloc();
     1516            source->galaxyFits->nPix = psMetadataLookupF32(&status, row, "NPIX");
     1517
     1518            psFree(source->galaxyFits->Flux);
     1519            source->galaxyFits->Flux  = psMemIncrRefCounter(Flux);
     1520            psFree(source->galaxyFits->dFlux);
     1521            source->galaxyFits->dFlux = psMemIncrRefCounter(dFlux);
     1522            psFree(source->galaxyFits->chisq);
     1523            source->galaxyFits->chisq = psMemIncrRefCounter(chisq);
     1524        }
     1525
     1526        psFree(row);
     1527    }
     1528
     1529    return true;
     1530}

  • trunk/psModules/src/objects/pmSourceIO_PS1_CAL_0.c

    r36375 r36441  
    714714}
    715715
    716 bool pmSourcesWrite_PS1_CAL_0_XGAL (psFits *fits, psArray *sources, char *extname, psMetadata *recipe)
     716bool pmSourcesWrite_PS1_CAL_0_XGAL (psFits *fits, pmReadout *readout, psArray *sources, char *extname, psMetadata *recipe)
    717717{
    718718    return true;

  • trunk/psModules/src/objects/pmSourceIO_PS1_DEV_0.c

    r36375 r36441  
    256256}
    257257
    258 bool pmSourcesWrite_PS1_DEV_0_XGAL(psFits *fits, psArray *sources, char *extname, psMetadata *recipe)
    259 {
    260     return true;
    261 }
     258bool pmSourcesWrite_PS1_DEV_0_XGAL(psFits *fits, pmReadout *readout, psArray *sources, char *extname, psMetadata *recipe)
     259{
     260    return true;
     261}

  • trunk/psModules/src/objects/pmSourceIO_PS1_DEV_1.c

    r36375 r36441  
    596596}
    597597
    598 bool pmSourcesWrite_PS1_DEV_1_XGAL(psFits *fits, psArray *sources, char *extname, psMetadata *recipe)
     598bool pmSourcesWrite_PS1_DEV_1_XGAL(psFits *fits, pmReadout *readout, psArray *sources, char *extname, psMetadata *recipe)
    599599{
    600600    return true;

  • trunk/psModules/src/objects/pmSourceIO_SMPDATA.c

    r36375 r36441  
    226226}
    227227
    228 bool pmSourcesWrite_SMPDATA_XGAL(psFits *fits, psArray *sources, char *extname, psMetadata *recipe)
     228bool pmSourcesWrite_SMPDATA_XGAL(psFits *fits, pmReadout *readout, psArray *sources, char *extname, psMetadata *recipe)
    229229{
    230230    return true;
Note: See TracChangeset for help on using the changeset viewer.