IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 37992


Ignore:
Timestamp:
Mar 23, 2015, 8:13:04 AM (11 years ago)
Author:
eugene
Message:

adding lensing ps1_v5_r2

Location:
trunk/Ohana/src
Files:
5 edited
6 moved

Legend:

Unmodified
Added
Removed

  • trunk/Ohana/src/addstar/src/ReadStarsFITS.c

    r37967 r37992  
    44// (excluding SDSS data and reference database info, such as 2MASS)
    55// NOTE: these must also be listed in MatchHeaders.c (line ~ 62)
    6 Stars     *Convert_SMPDATA        PROTO((FTable *table, unsigned int *nstars));
    7 Stars     *Convert_PS1_DEV_0      PROTO((FTable *table, unsigned int *nstars));
    8 Stars     *Convert_PS1_DEV_1      PROTO((FTable *table, unsigned int *nstars));
    9 Stars     *Convert_PS1_V1         PROTO((FTable *table, unsigned int *nstars));
    10 Stars     *Convert_PS1_V1_Alt     PROTO((FTable *table, unsigned int *nstars));
    11 Stars     *Convert_PS1_V2         PROTO((FTable *table, unsigned int *nstars));
    12 Stars     *Convert_PS1_V3         PROTO((FTable *table, unsigned int *nstars));
    13 Stars     *Convert_PS1_V4         PROTO((FTable *table, unsigned int *nstars));
    14 Stars     *Convert_PS1_V5         PROTO((FTable *table, unsigned int *nstars));
    15 Stars     *Convert_PS1_V5_Lensing PROTO((FTable *table, unsigned int *nstars));
    16 Stars     *Convert_PS1_V5_Lensing_Alt PROTO((FTable *table, unsigned int *nstars));
    17 Stars     *Convert_PS1_SV1        PROTO((FTable *table, unsigned int *nstars));
    18 Stars     *Convert_PS1_SV1_Alt    PROTO((FTable *table, unsigned int *nstars));
    19 Stars     *Convert_PS1_SV2        PROTO((FTable *table, unsigned int *nstars));
    20 Stars     *Convert_PS1_SV3        PROTO((FTable *table, unsigned int *nstars));
    21 Stars     *Convert_PS1_SV4        PROTO((FTable *table, unsigned int *nstars));
    22 Stars     *Convert_PS1_DV3        PROTO((FTable *table, unsigned int *nstars));
    23 Stars     *Convert_PS1_DV4        PROTO((FTable *table, unsigned int *nstars));
    24 Stars     *Convert_PS1_DV5        PROTO((FTable *table, unsigned int *nstars));
     6Stars     *Convert_SMPDATA           PROTO((FTable *table, unsigned int *nstars));
     7Stars     *Convert_PS1_DEV_0         PROTO((FTable *table, unsigned int *nstars));
     8Stars     *Convert_PS1_DEV_1         PROTO((FTable *table, unsigned int *nstars));
     9Stars     *Convert_PS1_V1            PROTO((FTable *table, unsigned int *nstars));
     10Stars     *Convert_PS1_V1_Alt        PROTO((FTable *table, unsigned int *nstars));
     11Stars     *Convert_PS1_V2            PROTO((FTable *table, unsigned int *nstars));
     12Stars     *Convert_PS1_V3            PROTO((FTable *table, unsigned int *nstars));
     13Stars     *Convert_PS1_V4            PROTO((FTable *table, unsigned int *nstars));
     14Stars     *Convert_PS1_V5            PROTO((FTable *table, unsigned int *nstars));
     15Stars     *Convert_PS1_V5_R0_Lensing PROTO((FTable *table, unsigned int *nstars));
     16Stars     *Convert_PS1_V5_R1_Lensing PROTO((FTable *table, unsigned int *nstars));
     17Stars     *Convert_PS1_V5_R2_Lensing PROTO((FTable *table, unsigned int *nstars));
     18Stars     *Convert_PS1_SV1           PROTO((FTable *table, unsigned int *nstars));
     19Stars     *Convert_PS1_SV1_Alt       PROTO((FTable *table, unsigned int *nstars));
     20Stars     *Convert_PS1_SV2           PROTO((FTable *table, unsigned int *nstars));
     21Stars     *Convert_PS1_SV3           PROTO((FTable *table, unsigned int *nstars));
     22Stars     *Convert_PS1_SV4           PROTO((FTable *table, unsigned int *nstars));
     23Stars     *Convert_PS1_DV3           PROTO((FTable *table, unsigned int *nstars));
     24Stars     *Convert_PS1_DV4           PROTO((FTable *table, unsigned int *nstars));
     25Stars     *Convert_PS1_DV5           PROTO((FTable *table, unsigned int *nstars));
    2526
    2627// given a file with the pointer at the start of the table block and the
    … …  
    8687        break;
    8788      case 312:
    88         stars = Convert_PS1_V5_Lensing_Alt (&table, &Nstars);
     89        stars = Convert_PS1_V5_R0_Lensing (&table, &Nstars);
    8990        break;
    9091      case 320:
    91         stars = Convert_PS1_V5_Lensing (&table, &Nstars);
     92        stars = Convert_PS1_V5_R1_Lensing (&table, &Nstars);
     93        break;
     94      case 328:
     95        stars = Convert_PS1_V5_R2_Lensing (&table, &Nstars);
    9296        break;
    9397      default:
    … …  
    864868}
    865869
    866 Stars *Convert_PS1_V5_Lensing (FTable *table, unsigned int *nstars) {
     870Stars *Convert_PS1_V5_R0_Lensing (FTable *table, unsigned int *nstars) {
    867871
    868872  off_t Nstars;
    … …  
    870874  double ZeroPt;
    871875  Stars *stars;
    872   CMF_PS1_V5_Lensing *ps1data;
    873 
    874   ps1data = gfits_table_get_CMF_PS1_V5_Lensing (table, &Nstars, NULL);
     876  CMF_PS1_V5_R0_Lensing *ps1data;
     877
     878  ps1data = gfits_table_get_CMF_PS1_V5_R0_Lensing (table, &Nstars, NULL);
    875879  if (!ps1data) {
    876880    fprintf (stderr, "skipping inconsistent entry\n");
    … …  
    989993}
    990994
    991 Stars *Convert_PS1_V5_Lensing_Alt (FTable *table, unsigned int *nstars) {
     995Stars *Convert_PS1_V5_R1_Lensing (FTable *table, unsigned int *nstars) {
    992996
    993997  off_t Nstars;
    … …  
    995999  double ZeroPt;
    9961000  Stars *stars;
    997   CMF_PS1_V5_Lensing_Alt *ps1data;
    998 
    999   ps1data = gfits_table_get_CMF_PS1_V5_Lensing_Alt (table, &Nstars, NULL);
     1001  CMF_PS1_V5_R1_Lensing *ps1data;
     1002
     1003  ps1data = gfits_table_get_CMF_PS1_V5_R1_Lensing (table, &Nstars, NULL);
    10001004  if (!ps1data) {
    10011005    fprintf (stderr, "skipping inconsistent entry\n");
    … …  
    11141118}
    11151119
    1116 Stars *Convert_PS1_SV1 (FTable *table, unsigned int *nstars) {
     1120Stars *Convert_PS1_V5_R2_Lensing (FTable *table, unsigned int *nstars) {
    11171121
    11181122  off_t Nstars;
    … …  
    11201124  double ZeroPt;
    11211125  Stars *stars;
    1122   CMF_PS1_SV1 *ps1data;
    1123 
    1124   if (table[0].header[0].Naxis[0] == 196) {
    1125     stars = Convert_PS1_SV1_Alt (table, nstars);
    1126     return (stars);
    1127   }
    1128 
    1129   ps1data = gfits_table_get_CMF_PS1_SV1 (table, &Nstars, NULL);
     1126  CMF_PS1_V5_R2_Lensing *ps1data;
     1127
     1128  ps1data = gfits_table_get_CMF_PS1_V5_R2_Lensing (table, &Nstars, NULL);
    11301129  if (!ps1data) {
    11311130    fprintf (stderr, "skipping inconsistent entry\n");
    … …  
    11531152    stars[i].measure.dMcal      = ps1data[i].dMcal;
    11541153    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
     1154    stars[i].measure.dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
     1155                       
     1156    stars[i].measure.Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
     1157    stars[i].measure.dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
     1158                       
     1159    // these fluxes are converted from counts to counts/sec in FilterStars.c
     1160    stars[i].measure.FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M);
     1161    stars[i].measure.dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM);
     1162    stars[i].measure.FluxKron   = ps1data[i].kronFlux;
     1163    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
     1164    stars[i].measure.FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map);
     1165    stars[i].measure.dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, stars[i].measure.FluxAp, stars[i].measure.dMap);
     1166
     1167    stars[i].measure.Sky        = ps1data[i].sky;
     1168    stars[i].measure.dSky       = ps1data[i].dSky;
     1169                       
     1170    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
     1171    stars[i].measure.psfQF      = ps1data[i].psfQF;
     1172    stars[i].measure.psfQFperf  = ps1data[i].psfQFperf;
     1173
     1174    stars[i].measure.psfNdof    = ps1data[i].psfNdof;
     1175    stars[i].measure.psfNpix    = ps1data[i].psfNpix;
     1176    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
     1177
     1178    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
     1179    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
     1180    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
     1181
     1182    stars[i].measure.Mxx        = ToShortPixels(ps1data[i].Mxx);
     1183    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
     1184    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
     1185                       
     1186    stars[i].measure.photFlags  = ps1data[i].flags;
     1187    stars[i].measure.photFlags2 = ps1data[i].flags2;
     1188
     1189    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
     1190    stars[i].measure.detID      = ps1data[i].detID;
     1191
     1192    ALLOCATE (stars[i].lensing, Lensing, 1);
     1193    dvo_lensing_init (stars[i].lensing);
     1194
     1195    stars[i].lensing->X11_sm_obj  = ps1data[i].X11_sm_obj;
     1196    stars[i].lensing->X12_sm_obj  = ps1data[i].X12_sm_obj;
     1197    stars[i].lensing->X22_sm_obj  = ps1data[i].X22_sm_obj;
     1198    stars[i].lensing->E1_sm_obj   = ps1data[i].E1_sm_obj;
     1199    stars[i].lensing->E2_sm_obj   = ps1data[i].E2_sm_obj;
     1200
     1201    stars[i].lensing->X11_sh_obj  = ps1data[i].X11_sh_obj;
     1202    stars[i].lensing->X12_sh_obj  = ps1data[i].X12_sh_obj;
     1203    stars[i].lensing->X22_sh_obj  = ps1data[i].X22_sh_obj;
     1204    stars[i].lensing->E1_sh_obj   = ps1data[i].E1_sh_obj;
     1205    stars[i].lensing->E2_sh_obj   = ps1data[i].E2_sh_obj;
     1206
     1207    stars[i].lensing->X11_sm_psf  = ps1data[i].X11_sm_psf;
     1208    stars[i].lensing->X12_sm_psf  = ps1data[i].X12_sm_psf;
     1209    stars[i].lensing->X22_sm_psf  = ps1data[i].X22_sm_psf;
     1210    stars[i].lensing->E1_sm_psf   = ps1data[i].E1_sm_psf;
     1211    stars[i].lensing->E2_sm_psf   = ps1data[i].E2_sm_psf;
     1212
     1213    stars[i].lensing->X11_sh_psf  = ps1data[i].X11_sh_psf;
     1214    stars[i].lensing->X12_sh_psf  = ps1data[i].X12_sh_psf;
     1215    stars[i].lensing->X22_sh_psf  = ps1data[i].X22_sh_psf;
     1216    stars[i].lensing->E1_sh_psf   = ps1data[i].E1_sh_psf;
     1217    stars[i].lensing->E2_sh_psf   = ps1data[i].E2_sh_psf;
     1218
     1219    // stars[i].lensing->F_ApR5    = ps1data[i].F_ApR5;
     1220    // stars[i].lensing->dF_ApR5   = ps1data[i].dF_ApR5;
     1221    // stars[i].lensing->sF_ApR5   = ps1data[i].sF_ApR5;
     1222    // stars[i].lensing->fF_ApR5   = ps1data[i].fF_ApR5;
     1223    //
     1224    // stars[i].lensing->F_ApR6    = ps1data[i].F_ApR6;
     1225    // stars[i].lensing->dF_ApR6   = ps1data[i].dF_ApR6;
     1226    // stars[i].lensing->sF_ApR6   = ps1data[i].sF_ApR6;
     1227    // stars[i].lensing->fF_ApR6   = ps1data[i].fF_ApR6;
     1228
     1229    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
     1230    stars[i].lensing->detID      = ps1data[i].detID;
     1231
     1232    // the Average fields and the following Measure fields are set in FilterStars after
     1233    // the image metadata is in hand:  dR, dD, Mcal, dt, airmass, az, t, imageID, extID.
     1234
     1235    // averef is set in find_matches
     1236
     1237    // dbFlags is zero on ingest.
     1238
     1239    // the following fields are currently not being set anywhere: t_msec
     1240  }   
     1241  *nstars = Nstars;
     1242  return (stars);
     1243}
     1244
     1245Stars *Convert_PS1_SV1 (FTable *table, unsigned int *nstars) {
     1246
     1247  off_t Nstars;
     1248  unsigned int i;
     1249  double ZeroPt;
     1250  Stars *stars;
     1251  CMF_PS1_SV1 *ps1data;
     1252
     1253  if (table[0].header[0].Naxis[0] == 196) {
     1254    stars = Convert_PS1_SV1_Alt (table, nstars);
     1255    return (stars);
     1256  }
     1257
     1258  ps1data = gfits_table_get_CMF_PS1_SV1 (table, &Nstars, NULL);
     1259  if (!ps1data) {
     1260    fprintf (stderr, "skipping inconsistent entry\n");
     1261    return (NULL);
     1262  }
     1263  ZeroPt = GetZeroPoint();
     1264
     1265  ALLOCATE (stars, Stars, Nstars);
     1266  for (i = 0; i < Nstars; i++) {
     1267    InitStar (&stars[i]);
     1268    stars[i].measure.Xccd       = ps1data[i].X;
     1269    stars[i].measure.Yccd       = ps1data[i].Y;
     1270    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
     1271    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
     1272
     1273    stars[i].measure.posangle   = ToShortDegrees(ps1data[i].posangle);
     1274    stars[i].measure.pltscale   = ps1data[i].pltscale;
     1275
     1276    if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
     1277      stars[i].measure.M      = NAN;
     1278    } else {
     1279      stars[i].measure.M      = ps1data[i].M + ZeroPt;
     1280    }
     1281    stars[i].measure.dM         = ps1data[i].dM;
     1282    stars[i].measure.dMcal      = ps1data[i].dMcal;
     1283    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
    11551284    stars[i].measure.dMap       = ps1data[i].dM; // a proxy measure
    11561285                       

  • trunk/Ohana/src/libautocode/def/lensing-ps1-v5-r0.d

    r37985 r37992  
    1 STRUCT       Lensing_PS1_V5_ALT
    2 EXTNAME      DVO_LENSING_PS1_V5_ALT
     1STRUCT       Lensing_PS1_V5_R0
     2EXTNAME      DVO_LENSING_PS1_V5_R0
    33TYPE         BINTABLE
    44SIZE         128

  • trunk/Ohana/src/libautocode/def/lensing-ps1-v5-r1.d

    r37985 r37992  
    1 STRUCT       Lensing_PS1_V5
     1STRUCT       Lensing_PS1_V5_R1
    22EXTNAME      DVO_LENSING_PS1_V5
    33TYPE         BINTABLE

  • trunk/Ohana/src/libautocode/def/lensing.d

    r37807 r37992  
    22EXTNAME      DVO_LENSING
    33TYPE         BINTABLE
    4 SIZE         136
     4SIZE         144
    55DESCRIPTION  DVO Lensing Table
    66
    … …  
    2929FIELD  E2_sh_psf,      E2_SH_PSF,    float,          lensing shear psf stars E2
    3030
     31FIELD  E1_psf,         E1_PSF,       float,          polarization psf stars E1
     32FIELD  E2_psf,         E2_PSF,       float,          polarization psf stars E2
     33
    3134FIELD F_ApR5,        FLUX_AP_R5,     float,          Flux inside r = 5
    3235FIELD dF_ApR5,       FLUX_ERR_AP_R5, float,          error on Flux inside r = 5

  • trunk/Ohana/src/libdvo/Makefile

    r37807 r37992  
    4343$(DESTINC)/cmf-ps1-sv3.h \
    4444$(DESTINC)/cmf-ps1-sv4.h \
    45 $(DESTINC)/cmf-ps1-v5-lensing.h \
    46 $(DESTINC)/cmf-ps1-v5-lensing-alt.h
     45$(DESTINC)/cmf-ps1-v5-r0-lensing.h \
     46$(DESTINC)/cmf-ps1-v5-r1-lensing.h \
     47$(DESTINC)/cmf-ps1-v5-r2-lensing.h
    4748
    4849INCS = $(DEFS) $(DESTINC)/dvo.h $(DESTINC)/autocode.h $(DESTINC)/dvo_util.h $(DESTINC)/dvodb.h $(DESTINC)/libdvo_astro.h $(DESTINC)/convert.h $(DESTINC)/get_graphdata.h
    … …  
    102103$(SRC)/cmf-ps1-sv4.$(ARCH).o \
    103104$(SRC)/cmf-ps1-v5.$(ARCH).o \
    104 $(SRC)/cmf-ps1-v5-lensing.$(ARCH).o \
    105 $(SRC)/cmf-ps1-v5-lensing-alt.$(ARCH).o \
     105$(SRC)/cmf-ps1-v5-r0-lensing.$(ARCH).o \
     106$(SRC)/cmf-ps1-v5-r1-lensing.$(ARCH).o \
     107$(SRC)/cmf-ps1-v5-r2-lensing.$(ARCH).o \
    106108$(SRC)/dvo_util.$(ARCH).o \
    107109$(SRC)/dbBooleanCond.$(ARCH).o          \

  • trunk/Ohana/src/libdvo/include/cmf-ps1-v5-r0-lensing.h

    r37985 r37992  
    8484  short            nFrames;              // images overlapping peak
    8585  short            padding;              // padding for 8byte records
    86 } CMF_PS1_V5_Lensing_Alt;
     86} CMF_PS1_V5_R0_Lensing;
    8787
    88 CMF_PS1_V5_Lensing_Alt *gfits_table_get_CMF_PS1_V5_Lensing_Alt (FTable *table, off_t *Ndata, char *swapped);
    89 int      gfits_table_set_CMF_PS1_V5_Lensing_Alt (FTable *ftable, CMF_PS1_V5_Lensing_Alt *data, off_t Ndata);
    90 int      gfits_table_mkheader_CMF_PS1_V5_Lensing_Alt (Header *header);
    91 int      gfits_convert_CMF_PS1_V5_Lensing_Alt (unsigned char *data, off_t size, off_t nitems, char toStruct);
    92 int      Send_CMF_PS1_V5_Lensing_Alt (int device, CMF_PS1_V5_Lensing_Alt *data, int Ndata, int copy);
    93 int      Recv_CMF_PS1_V5_Lensing_Alt (int device, CMF_PS1_V5_Lensing_Alt **data, int *Ndata);
     88CMF_PS1_V5_R0_Lensing *gfits_table_get_CMF_PS1_V5_R0_Lensing (FTable *table, off_t *Ndata, char *swapped);
     89int      gfits_table_set_CMF_PS1_V5_R0_Lensing (FTable *ftable, CMF_PS1_V5_R0_Lensing *data, off_t Ndata);
     90int      gfits_table_mkheader_CMF_PS1_V5_R0_Lensing (Header *header);
     91int      gfits_convert_CMF_PS1_V5_R0_Lensing (unsigned char *data, off_t size, off_t nitems, char toStruct);
     92int      Send_CMF_PS1_V5_R0_Lensing (int device, CMF_PS1_V5_R0_Lensing *data, int Ndata, int copy);
     93int      Recv_CMF_PS1_V5_R0_Lensing (int device, CMF_PS1_V5_R0_Lensing **data, int *Ndata);

  • trunk/Ohana/src/libdvo/include/cmf-ps1-v5-r1-lensing.h

    r37985 r37992  
    7474  short            srcChipX;
    7575  short            srcChipY;
     76  short            padding3;
    7677
    7778  float            Mr1;                  // first radial moment (pixels)
    … …  
    8889  short            nFrames;              // images overlapping peak
    8990  short            padding;              // padding for 8byte records
    90 } CMF_PS1_V5_Lensing;
     91} CMF_PS1_V5_R1_Lensing;
    9192
    92 CMF_PS1_V5_Lensing *gfits_table_get_CMF_PS1_V5_Lensing (FTable *table, off_t *Ndata, char *swapped);
    93 int      gfits_table_set_CMF_PS1_V5_Lensing (FTable *ftable, CMF_PS1_V5_Lensing *data, off_t Ndata);
    94 int      gfits_table_mkheader_CMF_PS1_V5_Lensing (Header *header);
    95 int      gfits_convert_CMF_PS1_V5_Lensing (unsigned char *data, off_t size, off_t nitems, char toStruct);
    96 int      Send_CMF_PS1_V5_Lensing (int device, CMF_PS1_V5_Lensing *data, int Ndata, int copy);
    97 int      Recv_CMF_PS1_V5_Lensing (int device, CMF_PS1_V5_Lensing **data, int *Ndata);
     93CMF_PS1_V5_R1_Lensing *gfits_table_get_CMF_PS1_V5_R1_Lensing (FTable *table, off_t *Ndata, char *swapped);
     94int      gfits_table_set_CMF_PS1_V5_R1_Lensing (FTable *ftable, CMF_PS1_V5_R1_Lensing *data, off_t Ndata);
     95int      gfits_table_mkheader_CMF_PS1_V5_R1_Lensing (Header *header);
     96int      gfits_convert_CMF_PS1_V5_R1_Lensing (unsigned char *data, off_t size, off_t nitems, char toStruct);
     97int      Send_CMF_PS1_V5_R1_Lensing (int device, CMF_PS1_V5_R1_Lensing *data, int Ndata, int copy);
     98int      Recv_CMF_PS1_V5_R1_Lensing (int device, CMF_PS1_V5_R1_Lensing **data, int *Ndata);

  • trunk/Ohana/src/libdvo/include/dvo.h

    r37807 r37992  
    334334# include "cmf-ps1-sv4.h"
    335335# include "cmf-ps1-v5.h"
    336 # include "cmf-ps1-v5-lensing.h"
    337 # include "cmf-ps1-v5-lensing-alt.h"
     336# include "cmf-ps1-v5-r0-lensing.h"
     337# include "cmf-ps1-v5-r1-lensing.h"
     338# include "cmf-ps1-v5-r2-lensing.h"
    338339
    339340typedef struct {

  • trunk/Ohana/src/libdvo/src/cmf-ps1-v5-r0-lensing.c

    r37985 r37992  
    33
    44// this function is based on the one generated by the autocode of cmf-ps1-v5.d
    5 int gfits_convert_CMF_PS1_V5_Lensing_Alt (unsigned char *data, off_t size, off_t nitems, char toStruct) {
     5int gfits_convert_CMF_PS1_V5_R0_Lensing (unsigned char *data, off_t size, off_t nitems, char toStruct) {
    66
    77  off_t i;
    … …  
    99
    1010  if (size != ST_SIZE) {
    11     fprintf (stderr, "WARNING: mismatch in data types CMF_PS1_V5_Lensing_Alt: "OFF_T_FMT" vs %d\n",  size,  ST_SIZE);
     11    fprintf (stderr, "WARNING: mismatch in data types CMF_PS1_V5_R0_Lensing: "OFF_T_FMT" vs %d\n",  size,  ST_SIZE);
    1212    return (FALSE);
    1313  }
    … …  
    191191/*** add test of EXTNAME and header-defined columns? ***/
    192192/* return internal structure representation */
    193 CMF_PS1_V5_Lensing_Alt *gfits_table_get_CMF_PS1_V5_Lensing_Alt (FTable *ftable, off_t *Ndata, char *swapped) {
     193CMF_PS1_V5_R0_Lensing *gfits_table_get_CMF_PS1_V5_R0_Lensing (FTable *ftable, off_t *Ndata, char *swapped) {
    194194
    195195  int Ncols;
    196   CMF_PS1_V5_Lensing_Alt *data;
     196  CMF_PS1_V5_R0_Lensing *data;
    197197
    198198  Ncols = ftable[0].header[0].Naxis[0];
    … …  
    203203
    204204  *Ndata = ftable[0].header[0].Naxis[1];
    205   data = (CMF_PS1_V5_Lensing_Alt *) ftable[0].buffer;
     205  data = (CMF_PS1_V5_R0_Lensing *) ftable[0].buffer;
    206206  if ((swapped == NULL) || (*swapped == FALSE)) {
    207     if (!gfits_convert_CMF_PS1_V5_Lensing_Alt ((unsigned char *) data, sizeof (CMF_PS1_V5_Lensing_Alt), *Ndata, TRUE)) {
     207    if (!gfits_convert_CMF_PS1_V5_R0_Lensing ((unsigned char *) data, sizeof (CMF_PS1_V5_R0_Lensing), *Ndata, TRUE)) {
    208208      return NULL;
    209209    }
    … …  
    214214}
    215215
    216 int gfits_table_set_CMF_PS1_V5_Lensing_Alt (FTable *ftable, CMF_PS1_V5_Lensing_Alt *data, off_t Ndata) {
     216int gfits_table_set_CMF_PS1_V5_R0_Lensing (FTable *ftable, CMF_PS1_V5_R0_Lensing *data, off_t Ndata) {
    217217
    218218  Header *header;
    … …  
    221221
    222222  /* create table header */
    223   if (!gfits_create_table_header (header, "BINTABLE", "CMF_PS1_V5_Lensing_Alt")) return (FALSE);
     223  if (!gfits_create_table_header (header, "BINTABLE", "CMF_PS1_V5_R0_Lensing")) return (FALSE);
    224224
    225225  /* define table layout */
    … …  
    308308  /* add data values */
    309309  if (!gfits_table_scale_data (ftable)) return (FALSE);
    310   if (!gfits_convert_CMF_PS1_V5_Lensing_Alt ((unsigned char *) data, sizeof (CMF_PS1_V5_Lensing_Alt), Ndata, FALSE)) return (FALSE);
    311   if (!gfits_add_rows (ftable, (char *) data, Ndata, sizeof (CMF_PS1_V5_Lensing_Alt))) return (FALSE);
     310  if (!gfits_convert_CMF_PS1_V5_R0_Lensing ((unsigned char *) data, sizeof (CMF_PS1_V5_R0_Lensing), Ndata, FALSE)) return (FALSE);
     311  if (!gfits_add_rows (ftable, (char *) data, Ndata, sizeof (CMF_PS1_V5_R0_Lensing))) return (FALSE);
    312312
    313313  return (TRUE);
    314314}
    315315
    316 int gfits_table_mkheader_CMF_PS1_V5_Lensing_Alt (Header *header) {
     316int gfits_table_mkheader_CMF_PS1_V5_R0_Lensing (Header *header) {
    317317
    318318  /* create table header */
    319   if (!gfits_create_table_header (header, "BINTABLE", "CMF_PS1_V5_Lensing_Alt")) return (FALSE);
     319  if (!gfits_create_table_header (header, "BINTABLE", "CMF_PS1_V5_R0_Lensing")) return (FALSE);
    320320
    321321  /* define table layout */
    … …  
    402402}
    403403
    404 int Send_CMF_PS1_V5_Lensing_Alt (int device, CMF_PS1_V5_Lensing_Alt *data, int Ndata, int copy) {
     404int Send_CMF_PS1_V5_R0_Lensing (int device, CMF_PS1_V5_R0_Lensing *data, int Ndata, int copy) {
    405405
    406406  int Nwrite, Nbytes;
    407   CMF_PS1_V5_Lensing_Alt *tmpdata;
    408 
    409   Nbytes = Ndata * sizeof (CMF_PS1_V5_Lensing_Alt);
     407  CMF_PS1_V5_R0_Lensing *tmpdata;
     408
     409  Nbytes = Ndata * sizeof (CMF_PS1_V5_R0_Lensing);
    410410
    411411  if (copy) {
    412     ALLOCATE (tmpdata, CMF_PS1_V5_Lensing_Alt, Ndata);
     412    ALLOCATE (tmpdata, CMF_PS1_V5_R0_Lensing, Ndata);
    413413    memcpy (tmpdata, data, Nbytes);
    414414  } else {
    … …  
    416416  }
    417417
    418   if (!gfits_convert_CMF_PS1_V5_Lensing_Alt ((unsigned char *) tmpdata, sizeof (CMF_PS1_V5_Lensing_Alt), Ndata, FALSE)) return (FALSE);
     418  if (!gfits_convert_CMF_PS1_V5_R0_Lensing ((unsigned char *) tmpdata, sizeof (CMF_PS1_V5_R0_Lensing), Ndata, FALSE)) return (FALSE);
    419419
    420420  SendCommand (device, 16, "NVALUE: %6d", Ndata);
    … …  
    430430}
    431431
    432 int Recv_CMF_PS1_V5_Lensing_Alt (int device, CMF_PS1_V5_Lensing_Alt **data, int *Ndata) {
     432int Recv_CMF_PS1_V5_R0_Lensing (int device, CMF_PS1_V5_R0_Lensing **data, int *Ndata) {
    433433
    434434  int ndata;
    435435  IOBuffer message;
    436   CMF_PS1_V5_Lensing_Alt *tmpdata;
     436  CMF_PS1_V5_R0_Lensing *tmpdata;
    437437
    438438  ExpectCommand (device, 16, 1.0, &message);
    … …  
    443443  ExpectMessage (device, 1.0, &message);
    444444 
    445   tmpdata = (CMF_PS1_V5_Lensing_Alt *) message.buffer;
    446   if (!gfits_convert_CMF_PS1_V5_Lensing_Alt ((unsigned char *) tmpdata, sizeof (CMF_PS1_V5_Lensing_Alt), ndata, TRUE)) return (FALSE);
     445  tmpdata = (CMF_PS1_V5_R0_Lensing *) message.buffer;
     446  if (!gfits_convert_CMF_PS1_V5_R0_Lensing ((unsigned char *) tmpdata, sizeof (CMF_PS1_V5_R0_Lensing), ndata, TRUE)) return (FALSE);
    447447
    448448  /* double-check data length? */

  • trunk/Ohana/src/libdvo/src/cmf-ps1-v5-r2-lensing.c

    r37985 r37992  
    11# include "dvo.h"
    2 # define ST_SIZE 320
     2# define ST_SIZE 328
    33
    44// this function is based on the one generated by the autocode of cmf-ps1-v5.d
    5 int gfits_convert_CMF_PS1_V5_Lensing (unsigned char *data, off_t size, off_t nitems, char toStruct) {
     5int gfits_convert_CMF_PS1_V5_R2_Lensing (unsigned char *data, off_t size, off_t nitems, char toStruct) {
    66
    77  off_t i;
    … …  
    99
    1010  if (size != ST_SIZE) {
    11     fprintf (stderr, "WARNING: mismatch in data types CMF_PS1_V5_Lensing: "OFF_T_FMT" vs %d\n",  size,  ST_SIZE);
     11    fprintf (stderr, "WARNING: mismatch in data types CMF_PS1_V5_R2_Lensing: "OFF_T_FMT" vs %d\n",  size,  ST_SIZE);
    1212    return (FALSE);
    1313  }
    … …  
    101101    SWAP_WORD (260); // E2_SH_PSF
    102102
    103     SWAP_BYTE (264); // SRC_CHIP_NUM
    104     SWAP_BYTE (266); // SRC_CHIP_X
    105     SWAP_BYTE (268); // SRC_CHIP_Y
    106 
    107     SWAP_WORD (272); // MOMENTS_R1
    108     SWAP_WORD (276); // MOMENTS_RH
    109     SWAP_WORD (280); // KRON_FLUX
    110     SWAP_WORD (284); // KRON_FLUX_ERR
    111     SWAP_WORD (288); // KRON_FLUX_INNER
    112     SWAP_WORD (292); // KRON_FLUX_OUTER
    113     SWAP_WORD (296); // SKY_LIMIT_RAD
    114     SWAP_WORD (300); // SKY_LIMIT_FLUX
    115     SWAP_WORD (304); // SKY_LIMIT_SLOPE
    116     SWAP_WORD (308); // FLAGS
    117     SWAP_WORD (312); // FLAGS2
    118     SWAP_BYTE (316); // N_FRAMES
    119     SWAP_BYTE (318); // PADDING                       
     103    SWAP_WORD (264); // E1_PSF
     104    SWAP_WORD (268); // E2_PSF
     105
     106    SWAP_BYTE (272); // SRC_CHIP_NUM
     107    SWAP_BYTE (274); // SRC_CHIP_X
     108    SWAP_BYTE (276); // SRC_CHIP_Y
     109    // SWAP_BYTE (278); // PADDING3, not swapped
     110
     111    SWAP_WORD (280); // MOMENTS_R1
     112    SWAP_WORD (284); // MOMENTS_RH
     113    SWAP_WORD (288); // KRON_FLUX
     114    SWAP_WORD (292); // KRON_FLUX_ERR
     115    SWAP_WORD (296); // KRON_FLUX_INNER
     116    SWAP_WORD (300); // KRON_FLUX_OUTER
     117    SWAP_WORD (304); // SKY_LIMIT_RAD
     118    SWAP_WORD (308); // SKY_LIMIT_FLUX
     119    SWAP_WORD (312); // SKY_LIMIT_SLOPE
     120    SWAP_WORD (316); // FLAGS
     121    SWAP_WORD (320); // FLAGS2
     122    SWAP_BYTE (324); // N_FRAMES
     123    // SWAP_BYTE (326); // PADDING, not swapped                       
    120124  }
    121125# endif 
    … …  
    196200/*** add test of EXTNAME and header-defined columns? ***/
    197201/* return internal structure representation */
    198 CMF_PS1_V5_Lensing *gfits_table_get_CMF_PS1_V5_Lensing (FTable *ftable, off_t *Ndata, char *swapped) {
     202CMF_PS1_V5_R2_Lensing *gfits_table_get_CMF_PS1_V5_R2_Lensing (FTable *ftable, off_t *Ndata, char *swapped) {
    199203
    200204  int Ncols;
    201   CMF_PS1_V5_Lensing *data;
     205  CMF_PS1_V5_R2_Lensing *data;
    202206
    203207  Ncols = ftable[0].header[0].Naxis[0];
    … …  
    208212
    209213  *Ndata = ftable[0].header[0].Naxis[1];
    210   data = (CMF_PS1_V5_Lensing *) ftable[0].buffer;
     214  data = (CMF_PS1_V5_R2_Lensing *) ftable[0].buffer;
    211215  if ((swapped == NULL) || (*swapped == FALSE)) {
    212     if (!gfits_convert_CMF_PS1_V5_Lensing ((unsigned char *) data, sizeof (CMF_PS1_V5_Lensing), *Ndata, TRUE)) {
     216    if (!gfits_convert_CMF_PS1_V5_R2_Lensing ((unsigned char *) data, sizeof (CMF_PS1_V5_R2_Lensing), *Ndata, TRUE)) {
    213217      return NULL;
    214218    }
    … …  
    219223}
    220224
    221 int gfits_table_set_CMF_PS1_V5_Lensing (FTable *ftable, CMF_PS1_V5_Lensing *data, off_t Ndata) {
     225int gfits_table_set_CMF_PS1_V5_R2_Lensing (FTable *ftable, CMF_PS1_V5_R2_Lensing *data, off_t Ndata) {
    222226
    223227  Header *header;
    … …  
    226230
    227231  /* create table header */
    228   if (!gfits_create_table_header (header, "BINTABLE", "CMF_PS1_V5_Lensing")) return (FALSE);
     232  if (!gfits_create_table_header (header, "BINTABLE", "CMF_PS1_V5_R2_Lensing")) return (FALSE);
    229233
    230234  /* define table layout */
    … …  
    294298  gfits_define_bintable_column (header, "E",    "E1_SH_PSF",        "lensing shear",                   "",                  1.0, 0.0);
    295299  gfits_define_bintable_column (header, "E",    "E2_SH_PSF",        "lensing shear",                   "",                  1.0, 0.0);
     300  gfits_define_bintable_column (header, "E",    "E1_PSF",           "psf polarization",                "",                  1.0, 0.0);
     301  gfits_define_bintable_column (header, "E",    "E2_PSF",           "psf polarization",                "",                  1.0, 0.0);
    296302
    297303  gfits_define_bintable_column (header, "I",    "SRC_CHIP_NUM",     "number of source chip for warp",  "",                  1.0, 0.0);
    … …  
    319325  /* add data values */
    320326  if (!gfits_table_scale_data (ftable)) return (FALSE);
    321   if (!gfits_convert_CMF_PS1_V5_Lensing ((unsigned char *) data, sizeof (CMF_PS1_V5_Lensing), Ndata, FALSE)) return (FALSE);
    322   if (!gfits_add_rows (ftable, (char *) data, Ndata, sizeof (CMF_PS1_V5_Lensing))) return (FALSE);
     327  if (!gfits_convert_CMF_PS1_V5_R2_Lensing ((unsigned char *) data, sizeof (CMF_PS1_V5_R2_Lensing), Ndata, FALSE)) return (FALSE);
     328  if (!gfits_add_rows (ftable, (char *) data, Ndata, sizeof (CMF_PS1_V5_R2_Lensing))) return (FALSE);
    323329
    324330  return (TRUE);
    325331}
    326332
    327 int gfits_table_mkheader_CMF_PS1_V5_Lensing (Header *header) {
     333int gfits_table_mkheader_CMF_PS1_V5_R2_Lensing (Header *header) {
    328334
    329335  /* create table header */
    330   if (!gfits_create_table_header (header, "BINTABLE", "CMF_PS1_V5_Lensing")) return (FALSE);
     336  if (!gfits_create_table_header (header, "BINTABLE", "CMF_PS1_V5_R2_Lensing")) return (FALSE);
    331337
    332338  /* define table layout */
    … …  
    396402  gfits_define_bintable_column (header, "E",    "E1_SH_PSF",        "lensing shear",                   "",                  1.0, 0.0);
    397403  gfits_define_bintable_column (header, "E",    "E2_SH_PSF",        "lensing shear",                   "",                  1.0, 0.0);
     404  gfits_define_bintable_column (header, "E",    "E1_PSF",           "psf polarization",                "",                  1.0, 0.0);
     405  gfits_define_bintable_column (header, "E",    "E2_PSF",           "psf polarization",                "",                  1.0, 0.0);
    398406
    399407  gfits_define_bintable_column (header, "I",    "SRC_CHIP_NUM",     "number of source chip for warp",  "",                  1.0, 0.0);
    … …  
    419427}
    420428
    421 int Send_CMF_PS1_V5_Lensing (int device, CMF_PS1_V5_Lensing *data, int Ndata, int copy) {
     429int Send_CMF_PS1_V5_R2_Lensing (int device, CMF_PS1_V5_R2_Lensing *data, int Ndata, int copy) {
    422430
    423431  int Nwrite, Nbytes;
    424   CMF_PS1_V5_Lensing *tmpdata;
    425 
    426   Nbytes = Ndata * sizeof (CMF_PS1_V5_Lensing);
     432  CMF_PS1_V5_R2_Lensing *tmpdata;
     433
     434  Nbytes = Ndata * sizeof (CMF_PS1_V5_R2_Lensing);
    427435
    428436  if (copy) {
    429     ALLOCATE (tmpdata, CMF_PS1_V5_Lensing, Ndata);
     437    ALLOCATE (tmpdata, CMF_PS1_V5_R2_Lensing, Ndata);
    430438    memcpy (tmpdata, data, Nbytes);
    431439  } else {
    … …  
    433441  }
    434442
    435   if (!gfits_convert_CMF_PS1_V5_Lensing ((unsigned char *) tmpdata, sizeof (CMF_PS1_V5_Lensing), Ndata, FALSE)) return (FALSE);
     443  if (!gfits_convert_CMF_PS1_V5_R2_Lensing ((unsigned char *) tmpdata, sizeof (CMF_PS1_V5_R2_Lensing), Ndata, FALSE)) return (FALSE);
    436444
    437445  SendCommand (device, 16, "NVALUE: %6d", Ndata);
    … …  
    447455}
    448456
    449 int Recv_CMF_PS1_V5_Lensing (int device, CMF_PS1_V5_Lensing **data, int *Ndata) {
     457int Recv_CMF_PS1_V5_R2_Lensing (int device, CMF_PS1_V5_R2_Lensing **data, int *Ndata) {
    450458
    451459  int ndata;
    452460  IOBuffer message;
    453   CMF_PS1_V5_Lensing *tmpdata;
     461  CMF_PS1_V5_R2_Lensing *tmpdata;
    454462
    455463  ExpectCommand (device, 16, 1.0, &message);
    … …  
    460468  ExpectMessage (device, 1.0, &message);
    461469 
    462   tmpdata = (CMF_PS1_V5_Lensing *) message.buffer;
    463   if (!gfits_convert_CMF_PS1_V5_Lensing ((unsigned char *) tmpdata, sizeof (CMF_PS1_V5_Lensing), ndata, TRUE)) return (FALSE);
     470  tmpdata = (CMF_PS1_V5_R2_Lensing *) message.buffer;
     471  if (!gfits_convert_CMF_PS1_V5_R2_Lensing ((unsigned char *) tmpdata, sizeof (CMF_PS1_V5_R2_Lensing), ndata, TRUE)) return (FALSE);
    464472
    465473  /* double-check data length? */

  • trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V5.c

    r37807 r37992  
    532532    out[i].E2_sh_psf   = in[i].E2_sh_psf;
    533533
     534    out[i].E1_psf      = in[i].E1_psf;
     535    out[i].E2_psf      = in[i].E2_psf;
     536
    534537    out[i].F_ApR5      = in[i].F_ApR5;
    535538    out[i].dF_ApR5     = in[i].dF_ApR5;
    … …  
    580583    out[i].E2_sm_psf   = in[i].E2_sm_psf;     
    581584                                         
     585    out[i].E1_psf      = in[i].E1_psf;
     586    out[i].E2_psf      = in[i].E2_psf;     
     587
    582588    out[i].X11_sh_psf  = in[i].X11_sh_psf;
    583589    out[i].X12_sh_psf  = in[i].X12_sh_psf;
    … …  
    12641270}
    12651271
    1266 
    1267 Lensing *Lensing_PS1_V5_ALT_ToInternal (Lensing_PS1_V5_ALT *in, off_t Nvalues) {
     1272Lensing *Lensing_PS1_V5_R0_ToInternal (Lensing_PS1_V5_R0 *in, off_t Nvalues) {
    12681273
    12691274  off_t i;
    … …  
    13181323}
    13191324
     1325Lensing *Lensing_PS1_V5_R1_ToInternal (Lensing_PS1_V5_R1 *in, off_t Nvalues) {
     1326
     1327  off_t i;
     1328  Lensing *out;
     1329
     1330  ALLOCATE_ZERO (out, Lensing, Nvalues);
     1331
     1332  for (i = 0; i < Nvalues; i++) {
     1333    dvo_lensing_init (&out[i]);
     1334
     1335    out[i].X11_sm_obj  = in[i].X11_sm_obj;     
     1336    out[i].X12_sm_obj  = in[i].X12_sm_obj;     
     1337    out[i].X22_sm_obj  = in[i].X22_sm_obj;     
     1338    out[i].E1_sm_obj   = in[i].E1_sm_obj;     
     1339    out[i].E2_sm_obj   = in[i].E2_sm_obj;     
     1340                                         
     1341    out[i].X11_sh_obj  = in[i].X11_sh_obj;     
     1342    out[i].X12_sh_obj  = in[i].X12_sh_obj;     
     1343    out[i].X22_sh_obj  = in[i].X22_sh_obj;     
     1344    out[i].E1_sh_obj   = in[i].E1_sh_obj;     
     1345    out[i].E2_sh_obj   = in[i].E2_sh_obj;     
     1346                                         
     1347    out[i].X11_sm_psf  = in[i].X11_sm_psf;
     1348    out[i].X12_sm_psf  = in[i].X12_sm_psf;
     1349    out[i].X22_sm_psf  = in[i].X22_sm_psf;
     1350    out[i].E1_sm_psf   = in[i].E1_sm_psf;
     1351    out[i].E2_sm_psf   = in[i].E2_sm_psf;     
     1352                                         
     1353    out[i].X11_sh_psf  = in[i].X11_sh_psf;
     1354    out[i].X12_sh_psf  = in[i].X12_sh_psf;
     1355    out[i].X22_sh_psf  = in[i].X22_sh_psf;
     1356    out[i].E1_sh_psf   = in[i].E1_sh_psf;
     1357    out[i].E2_sh_psf   = in[i].E2_sh_psf;
     1358
     1359    out[i].F_ApR5      = in[i].F_ApR5;
     1360    out[i].dF_ApR5     = in[i].dF_ApR5;
     1361    out[i].sF_ApR5     = in[i].sF_ApR5;
     1362    out[i].fF_ApR5     = in[i].fF_ApR5;
     1363                                   
     1364    out[i].F_ApR6      = in[i].F_ApR6;
     1365    out[i].dF_ApR6     = in[i].dF_ApR6;
     1366    out[i].sF_ApR6     = in[i].sF_ApR6;
     1367    out[i].fF_ApR6     = in[i].fF_ApR6;
     1368                                   
     1369    out[i].detID       = in[i].detID;
     1370    out[i].objID       = in[i].objID;
     1371    out[i].catID       = in[i].catID;
     1372
     1373    out[i].averef      = in[i].averef;
     1374  }
     1375  return (out);
     1376}
     1377
Note: See TracChangeset for help on using the changeset viewer.