**
** ROUTINE: taCalibObjsReadFromTbl
**
**
** Read objects from a TBLCOL
** and append them to a CHAIN of TA_CALIB_OBJs. It is assumed that
** all objects come from the same field, and so each object has a
** pointer set to the input field info structure.
**
** If "calibrated" = 1 then it is assumed we are reading a "tsObj" TBLCOL;
** if 0 then it is assumed we are reading an "fpObjc" TBLCOL and only
** those fields are read in (but they are still read into a TA_CALIB_OBJ
** chain).
**
** NOTE: On error, new elements may have been added to the CHAIN.
**
**
******************************************************************************
******************************************************************************
*/
RET_CODE
taCalibObjsReadFromTbl(TBLCOL *tblCol, /* IN: TBLCOL to read */
TA_FIELD_INFO *field, /* IN: pointer to field info */
int calibrated, /* IN: 1=tsObj, 0=fpObjc */
CHAIN *chain /* MOD: CHAIN of objects */)
{
ARRAY* array[N_OBJ_FIELDS];
int newArray[N_OBJ_FIELDS];
TA_CALIB_OBJ *obj = NULL;
int fldIdx, dimIdx, k, m, p, nProf, kk;
/* Locate each field in the TBLCOL, saving its array pointer. */
for (fldIdx = 0; fldIdx < N_OBJ_FIELDS; fldIdx++)
{
/* Skip calibrated-only fields if this is an fpObjc file */
newArray[fldIdx] = 0;
if (calibrated == 0 && objFields[fldIdx].raw == 0) continue;
/* Locate the field */
if (shTblFldLoc(tblCol, -1, objFields[fldIdx].name, 0,
SH_CASE_INSENSITIVE, &(array[fldIdx]), NULL, NULL)
!= SH_SUCCESS)
{
#ifdef OPTIONAL_FIELDS
/* If there are optional fields that you want to be able to
* handle, then remove the IFDEF (and the one below) and update the
* list of optional fields. */
if (fldIdx == OBJC_FLAGS2 || fldIdx == FLAGS2 || fldIdx == ROWV ||
fldIdx == ROWVERR || fldIdx == COLV || fldIdx == COLVERR ||
fldIdx == FIRSTID || fldIdx == FIRSTLAMBDA ||
fldIdx == FIRSTETA || fldIdx == ROSATPOSERR ||
fldIdx == ROSATCPSERR || fldIdx == ROSATHR1ERR ||
fldIdx == ROSATHR2ERR || fldIdx == ROSATEXTLIKE ||
fldIdx == ROSATDETECTLIKE || fldIdx == ROSATEXPOSURE ||
fldIdx == RUN || fldIdx == CAMCOL || fldIdx == RERUN ||
fldIdx == FIELD || fldIdx == MATCHID ||
fldIdx == PROPERMOTIONANGLE || fldIdx == USNOBLUE ||
fldIdx == USNORED)
{
/* Allocate the field */
newArray[fldIdx] = 1;
array[fldIdx] = shArrayNew();
if (array[fldIdx] == 0)
{
for (kk = 0; kk < fldIdx; kk++)
if (newArray[kk])
shArrayDel(array[kk]);
shErrStackPush("taCalibObjsReadFromTbl: couldn't make field");
return SH_GENERIC_ERROR;
}
/* Set the array dimensions */
array[fldIdx]->dim[0] = tblCol->rowCnt;
array[fldIdx]->dimCnt = 1;
for (dimIdx = 0; dimIdx < objFields[fldIdx].dimCnt; dimIdx++)
{
array[fldIdx]->dim[array[fldIdx]->dimCnt++] =
objFields[fldIdx].dim[dimIdx];
}
/* Allocate storage for the array */
if (shArrayDataAlloc(array[fldIdx],objFields[fldIdx].type)
!= SH_SUCCESS)
{
for (kk = 0; kk <= fldIdx; kk++)
if (newArray[kk])
shArrayDel(array[kk]);
shErrStackPush("taCalibObjsReadFromTbl: couldn't allocate array");
return SH_GENERIC_ERROR;
}
}
else
{
#endif
for (kk = 0; kk < fldIdx; kk++)
if (newArray[kk])
shArrayDel(array[kk]);
shErrStackPush("taCalibObjsReadFromTbl: couldn't locate field in FITS file");
return SH_GENERIC_ERROR;
#ifdef OPTIONAL_FIELDS
}
#endif
}
else
{
newArray[fldIdx] = 0;
/* Verify its dimensions */
for (dimIdx = 0; dimIdx < objFields[fldIdx].dimCnt; dimIdx++)
{
if (array[fldIdx]->dim[dimIdx+1] != objFields[fldIdx].dim[dimIdx])
{
for (kk = 0; kk < fldIdx; kk++)
if (newArray[kk])
shArrayDel(array[kk]);
shErrStackPush("taCalibObjsReadFromTbl: incorrect field dimensions in FITS file");
return SH_GENERIC_ERROR;
}
}
}
}
/* For each object ... */
for (k = 0; k < tblCol->rowCnt; k++)
{
/* Create a new object and append it to the CHAIN*/
TA_CALIB_OBJ *obj = shMalloc(sizeof(TA_CALIB_OBJ));
if (shChainElementAddByPos(chain, obj, "TA_CALIB_OBJ", TAIL, AFTER)
!= SH_SUCCESS)
{
for (kk = 0; kk < N_OBJ_FIELDS; kk++)
if (newArray[kk])
shArrayDel(array[kk]);
shErrStackPush("taCalibObjsReadFromTbl: couldn't append object to chain");
return SH_GENERIC_ERROR;
}
/* Copy its contents from the TBLCOL */
obj->field = field;
obj->parent = ioff(PARENT,k);
obj->id = ioff(ID,k);
obj->nchild = ioff(NCHILD,k);
obj->objc_type = (AR_OBJECT_TYPE) ioff(OBJC_TYPE,k);
obj->catId = ioff(CATID,k);
obj->objc_flags = ioff(OBJC_FLAGS,k);
obj->objc_flags2 = ioff(OBJC_FLAGS2,k);
obj->objc_rowc.val = foff(OBJC_ROWC,k);
obj->objc_rowc.err = foff(OBJC_ROWCERR,k);
obj->objc_colc.val = foff(OBJC_COLC,k);
obj->objc_colc.err = foff(OBJC_COLCERR,k);
obj->rowv.val = foff(ROWV,k);
obj->rowv.err = foff(ROWVERR,k);
obj->colv.val = foff(COLV,k);
obj->colv.err = foff(COLVERR,k);
if (calibrated == 1)
{
obj->run = ioff(RUN,k);
obj->camCol = ioff(CAMCOL,k);
obj->rerun = ioff(RERUN,k);
obj->fieldId = ioff(FIELD,k);
obj->status = ioff(STATUS,k);
obj->ra = doff(RA,k);
obj->dec = doff(DEC,k);
obj->lambda = doff(LAMBDA,k);
obj->eta = doff(ETA,k);
obj->l = doff(L,k);
obj->b = doff(B,k);
obj->primTarget = ioff(PRIM_TARGET,k);
obj->secTarget = ioff(SEC_TARGET,k);
obj->properMotionMatch = ioff(PROPERMOTIONMATCH,k);
obj->properMotionDelta = foff(PROPERMOTIONDELTA,k);
obj->properMotion = foff(PROPERMOTION,k);
obj->properMotionAngle = foff(PROPERMOTIONANGLE,k);
obj->usnoBlue = foff(USNOBLUE,k);
obj->usnoRed = foff(USNORED,k);
obj->firstMatch = ioff(FIRSTMATCH,k);
obj->firstId = ioff(FIRSTID,k);
obj->firstLambda = doff(FIRSTLAMBDA,k);
obj->firstEta = doff(FIRSTETA,k);
obj->firstDelta = foff(FIRSTDELTA,k);
obj->firstPeak = foff(FIRSTPEAK,k);
obj->firstInt = foff(FIRSTINT,k);
obj->firstrms = foff(FIRSTRMS,k);
obj->firstmajor = foff(FIRSTMAJOR,k);
obj->firstminor = foff(FIRSTMINOR,k);
obj->firstpa = foff(FIRSTPA,k);
obj->rosatMatch = ioff(ROSATMATCH,k);
obj->rosatDelta = foff(ROSATDELTA,k);
obj->rosatPosErr = foff(ROSATPOSERR,k);
obj->rosatCPS.val = foff(ROSATCPS,k);
obj->rosatCPS.err = foff(ROSATCPSERR,k);
obj->rosatHR1.val = foff(ROSATHR1,k);
obj->rosatHR1.err = foff(ROSATHR1ERR,k);
obj->rosatHR2.val = foff(ROSATHR2,k);
obj->rosatHR2.err = foff(ROSATHR2ERR,k);
obj->rosatExt = foff(ROSATEXT,k);
obj->rosatExtLike = foff(ROSATEXTLIKE,k);
obj->rosatDetectLike = foff(ROSATDETECTLIKE,k);
obj->rosatExposure = foff(ROSATEXPOSURE,k);
obj->priority = ioff(PRIORITY,k);
for (p = 0; p < 10; p++)
for (m = 0; m < 5; m++) obj->matchId[p][m] = i3off(MATCHID,k,p,m);
}
else
{
obj->run = 0;
obj->camCol = 0;
obj->rerun = 0;
obj->fieldId = 0;
obj->status = 0;
obj->ra = 0;
obj->dec = 0;
obj->lambda = 0;
obj->eta = 0;
obj->l = 0;
obj->b = 0;
obj->primTarget = 0;
obj->secTarget = 0;
obj->properMotionMatch = 0;
obj->properMotionDelta = 0;
obj->properMotion = 0;
obj->properMotionAngle = 0;
obj->usnoBlue = 0;
obj->usnoRed = 0;
obj->firstMatch = 0;
obj->firstId = 0;
obj->firstLambda = 0;
obj->firstEta = 0;
obj->firstDelta = 0;
obj->firstPeak = 0;
obj->firstInt = 0;
obj->firstrms = 0;
obj->firstmajor = 0;
obj->firstminor = 0;
obj->firstpa = 0;
obj->rosatMatch = 0;
obj->rosatDelta = 0;
obj->rosatPosErr = 0;
obj->rosatCPS.val = 0;
obj->rosatCPS.err = 0;
obj->rosatHR1.val = 0;
obj->rosatHR1.err = 0;
obj->rosatHR2.val = 0;
obj->rosatHR2.err = 0;
obj->rosatExt = 0;
obj->rosatExtLike = 0;
obj->rosatDetectLike = 0;
obj->rosatExposure = 0;
obj->priority = 0;
for (p = 0; p < 10; p++)
for (m = 0; m < 5; m++) obj->matchId[p][m] = 0;
}
/* For each filter ... */
for (m = 0; m < TA_NFILTERS; m++)
{
obj->detection[m].rowc.val = f2off(ROWC,k,m);
obj->detection[m].rowc.err = f2off(ROWCERR,k,m);
obj->detection[m].colc.val = f2off(COLC,k,m);
obj->detection[m].colc.err = f2off(COLCERR,k,m);
obj->detection[m].sky.val = f2off(SKY,k,m);
obj->detection[m].sky.err = f2off(SKYERR,k,m);
obj->detection[m].psfCounts.val = f2off(PSFCOUNTS,k,m);
obj->detection[m].psfCounts.err = f2off(PSFCOUNTSERR,k,m);
obj->detection[m].fiberCounts.val = f2off(FIBERCOUNTS,k,m);
obj->detection[m].fiberCounts.err = f2off(FIBERCOUNTSERR,k,m);
obj->detection[m].petroCounts.val = f2off(PETROCOUNTS,k,m);
obj->detection[m].petroCounts.err = f2off(PETROCOUNTSERR,k,m);
obj->detection[m].petroRad.val = f2off(PETRORAD,k,m);
obj->detection[m].petroRad.err = f2off(PETRORADERR,k,m);
obj->detection[m].petroR50.val = f2off(PETROR50,k,m);
obj->detection[m].petroR50.err = f2off(PETROR50ERR,k,m);
obj->detection[m].petroR90.val = f2off(PETROR90,k,m);
obj->detection[m].petroR90.err = f2off(PETROR90ERR,k,m);
obj->detection[m].q.val = f2off(Q,k,m);
obj->detection[m].q.err = f2off(QERR,k,m);
obj->detection[m].u.val = f2off(U,k,m);
obj->detection[m].u.err = f2off(UERR,k,m);
obj->detection[m].iso_rowc.val = f2off(ISO_ROWC,k,m);
obj->detection[m].iso_rowc.err = f2off(ISO_ROWCERR,k,m);
obj->detection[m].iso_rowc.grad = f2off(ISO_ROWCGRAD,k,m);
obj->detection[m].iso_colc.val = f2off(ISO_COLC,k,m);
obj->detection[m].iso_colc.err = f2off(ISO_COLCERR,k,m);
obj->detection[m].iso_colc.grad = f2off(ISO_COLCGRAD,k,m);
obj->detection[m].iso_a.val = f2off(ISO_A,k,m);
obj->detection[m].iso_a.err = f2off(ISO_AERR,k,m);
obj->detection[m].iso_a.grad = f2off(ISO_AGRAD,k,m);
obj->detection[m].iso_b.val = f2off(ISO_B,k,m);
obj->detection[m].iso_b.err = f2off(ISO_BERR,k,m);
obj->detection[m].iso_b.grad = f2off(ISO_BGRAD,k,m);
obj->detection[m].iso_phi.val = f2off(ISO_PHI,k,m);
obj->detection[m].iso_phi.err = f2off(ISO_PHIERR,k,m);
obj->detection[m].iso_phi.grad = f2off(ISO_PHIGRAD,k,m);
obj->detection[m].r_deV.val = f2off(R_DEV,k,m);
obj->detection[m].r_deV.err = f2off(R_DEVERR,k,m);
obj->detection[m].ab_deV.val = f2off(AB_DEV,k,m);
obj->detection[m].ab_deV.err = f2off(AB_DEVERR,k,m);
obj->detection[m].phi_deV.val = f2off(PHI_DEV,k,m);
obj->detection[m].phi_deV.err = f2off(PHI_DEVERR,k,m);
obj->detection[m].counts_deV.val = f2off(COUNTS_DEV,k,m);
obj->detection[m].counts_deV.err = f2off(COUNTS_DEVERR,k,m);
obj->detection[m].r_exp.val = f2off(R_EXP,k,m);
obj->detection[m].r_exp.err = f2off(R_EXPERR,k,m);
obj->detection[m].ab_exp.val = f2off(AB_EXP,k,m);
obj->detection[m].ab_exp.err = f2off(AB_EXPERR,k,m);
obj->detection[m].phi_exp.val = f2off(PHI_EXP,k,m);
obj->detection[m].phi_exp.err = f2off(PHI_EXPERR,k,m);
obj->detection[m].counts_exp.val = f2off(COUNTS_EXP,k,m);
obj->detection[m].counts_exp.err = f2off(COUNTS_EXPERR,k,m);
obj->detection[m].counts_model.val = f2off(COUNTS_MODEL,k,m);
obj->detection[m].counts_model.err = f2off(COUNTS_MODELERR,k,m);
obj->detection[m].texture = f2off(TEXTURE,k,m);
obj->detection[m].star_L = f2off(STAR_L,k,m);
obj->detection[m].exp_L = f2off(EXP_L,k,m);
obj->detection[m].deV_L = f2off(DEV_L,k,m);
obj->detection[m].fracPSF = f2off(FRACPSF,k,m);
obj->detection[m].flags = i2off(FLAGS,k,m);
obj->detection[m].flags2 = i2off(FLAGS2,k,m);
obj->detection[m].type = (AR_OBJECT_TYPE) i2off(OTYPE,k,m);
nProf = i2off(NPROF,k,m);
obj->detection[m].nProf = nProf;
for (p = 0; p < nProf; p++)
{
obj->detection[m].profile[p].val = f3off(PROFMEAN,k,m,p);
obj->detection[m].profile[p].err = f3off(PROFERR,k,m,p);
}
for (p = nProf; p < MAX_PROFILES; p++)
{
obj->detection[m].profile[p].val = 0.;
obj->detection[m].profile[p].err = 0.;
}
if (calibrated == 1)
{
obj->offsetRa[m] = f2off(OFFSETRA,k,m);
obj->offsetDec[m] = f2off(OFFSETDEC,k,m);
obj->reddening[m] = f2off(REDDENING,k,m);
}
else
{
obj->offsetRa[m] = 0;
obj->offsetDec[m] = 0;
obj->reddening[m] = 0;
}
}
}
/* Delete arrays for missing fields */
for (kk = 0; kk < N_OBJ_FIELDS; kk++)
if (newArray[kk] == 1)
shArrayDel(array[kk]);
/* Return */
return SH_SUCCESS;
}
/*****************************************************************************
******************************************************************************
**
** ROUTINE: taGenericChainDestroy
**
**
** Delete a chain, destroying (freeing the memory) for all elements
** on the chain. The elements are destroyed using shFree; their
** specific destructor is not called.
**
******************************************************************************
******************************************************************************
*/
void
taGenericChainDestroy(CHAIN *chain)
{
CURSOR_T curse;
void *elem;
if (chain == NULL) return;
curse = shChainCursorNew(chain);
while ((elem = shChainWalk(chain, curse, NEXT)) != NULL)
shFree(elem);
shChainCursorDel(chain, curse);
shChainDel(chain);
}