void he_write_healpix_map(float **tmap,int nfields,long nside,char *fname)
{
fitsfile *fptr;
int ii,status=0;
char *ttype[]={"T","Q","U"};
char *tform[]={"1E","1E","1E"};
char *tunit[]={"mK","mK","mK"};
if((nfields!=1)&&(nfields!=3)) {
fprintf(stderr,"CRIME: nfields must be 1 or 3\n");
exit(1);
}
fits_create_file(&fptr,fname,&status);
fits_create_tbl(fptr,BINARY_TBL,0,nfields,ttype,tform,
tunit,"BINTABLE",&status);
fits_write_key(fptr,TSTRING,"PIXTYPE","HEALPIX","HEALPIX Pixelisation",
&status);
fits_write_key(fptr,TSTRING,"ORDERING","RING",
"Pixel ordering scheme, either RING or NESTED",&status);
fits_write_key(fptr,TLONG,"NSIDE",&nside,
"Resolution parameter for HEALPIX",&status);
fits_write_key(fptr,TSTRING,"COORDSYS","G",
"Pixelisation coordinate system",&status);
fits_write_comment(fptr,
"G = Galactic, E = ecliptic, C = celestial = equatorial",
&status);
for(ii=0;ii<nfields;ii++) {
fits_write_col(fptr,TFLOAT,ii+1,1,1,nside2npix(nside),tmap[ii],&status);
}
fits_close_file(fptr, &status);
}
int ngp_keyword_all_write(NGP_HDU *ngph, fitsfile *ffp, int mode)
{ int i, r, ib;
char buf[200];
long l;
if (NULL == ngph) return(NGP_NUL_PTR);
if (NULL == ffp) return(NGP_NUL_PTR);
r = NGP_OK;
for (i=0; i<ngph->tokcnt; i++)
{ if ((NGP_REALLY_ALL & mode) || (NGP_OK == ngp_keyword_is_write(&(ngph->tok[i]))))
{ switch (ngph->tok[i].type)
{ case NGP_TTYPE_BOOL:
ib = ngph->tok[i].value.b;
fits_write_key(ffp, TLOGICAL, ngph->tok[i].name, &ib, ngph->tok[i].comment, &r);
break;
case NGP_TTYPE_STRING:
fits_write_key_longstr(ffp, ngph->tok[i].name, ngph->tok[i].value.s, ngph->tok[i].comment, &r);
break;
case NGP_TTYPE_INT:
l = ngph->tok[i].value.i; /* bugfix - 22-Jan-99, BO - nonalignment of OSF/Alpha */
fits_write_key(ffp, TLONG, ngph->tok[i].name, &l, ngph->tok[i].comment, &r);
break;
case NGP_TTYPE_REAL:
fits_write_key(ffp, TDOUBLE, ngph->tok[i].name, &(ngph->tok[i].value.d), ngph->tok[i].comment, &r);
break;
case NGP_TTYPE_COMPLEX:
fits_write_key(ffp, TDBLCOMPLEX, ngph->tok[i].name, &(ngph->tok[i].value.c), ngph->tok[i].comment, &r);
break;
case NGP_TTYPE_NULL:
fits_write_key_null(ffp, ngph->tok[i].name, ngph->tok[i].comment, &r);
break;
case NGP_TTYPE_RAW:
if (0 == strcmp("HISTORY", ngph->tok[i].name))
{ fits_write_history(ffp, ngph->tok[i].comment, &r);
break;
}
if (0 == strcmp("COMMENT", ngph->tok[i].name))
{ fits_write_comment(ffp, ngph->tok[i].comment, &r);
break;
}
sprintf(buf, "%-8.8s%s", ngph->tok[i].name, ngph->tok[i].comment);
fits_write_record(ffp, buf, &r);
break;
}
if (r) return(r);
}
}
fits_set_hdustruc(ffp, &r); /* resync cfitsio */
return(r);
}
void
writeWCS(fitsfile *fptr, const int i, int axesOrder[4], float cdelt[4], double crpix[4], double crval[4], char ctype[4][9], char cunit[4][9]){
char myStr[9];
int status = 0;
sprintf(myStr, "CTYPE%d ", i+1);
fits_write_key(fptr, TSTRING, myStr, &ctype[axesOrder[i]], "", &status);
sprintf(myStr, "CDELT%d ", i+1);
fits_write_key(fptr, TFLOAT, myStr, &cdelt[axesOrder[i]], "", &status);
sprintf(myStr, "CRPIX%d ", i+1);
fits_write_key(fptr, TDOUBLE, myStr, &crpix[axesOrder[i]], "", &status);
sprintf(myStr, "CRVAL%d ", i+1);
fits_write_key(fptr, TDOUBLE, myStr, &crval[axesOrder[i]], "", &status);
sprintf(myStr, "CUNIT%d ", i+1);
fits_write_key(fptr, TSTRING, myStr, &cunit[axesOrder[i]], "", &status);
}
int write_map(const char *filename, double *intensity, double *q, double *u, long nrows)
{
fitsfile *fptr;
int status = 0;
int hdutype;
int tfields=3;
char extname[] = "BINTABLE"; /* extension name */
char *ttype[] = { "I","Q","U" };
char *tform[] = { "1E","1E","1E" };
char *tunit[] = { " "," ", " " };
if (fits_create_file(&fptr, filename, &status))
fprintf(stderr, "%s (%d): Could not create new fits file.\n",
__FILE__, __LINE__);
/* move to 1st HDU */
fits_movabs_hdu(fptr, 1, &hdutype, &status);
//long nrows = 12L*nside*nside*2;
//long nside = sqrtl(nrows/12L);
long nside = 1024; //FIXME compute it
/* append a new empty binary table onto the FITS file */
fits_create_tbl( fptr, BINARY_TBL, nrows, tfields, ttype, tform,
tunit, extname, &status);
fits_write_key(fptr, TSTRING, "ORDERING", "NESTED",
"Pixel ordering scheme, either RING or NESTED", &status);
fits_write_key(fptr, TLONG, "NSIDE", &nside, "Resolution parameter for HEALPIX", &status);
long firstrow = 1; /* first row in table to write */
long firstelem = 1; /* first element in row (ignored in ASCII tables) */
if (fits_write_col(fptr, TDOUBLE, 1, firstrow, firstelem, nrows, intensity,
&status))
fprintf(stderr, "%s (%d): Could not write signal.\n", __FILE__, __LINE__);
if (fits_write_col(fptr, TDOUBLE, 2, firstrow, firstelem, nrows, q,
&status))
fprintf(stderr, "%s (%d): Could not write signal.\n", __FILE__, __LINE__);
if (fits_write_col(fptr, TDOUBLE, 3, firstrow, firstelem, nrows, u,
&status))
fprintf(stderr, "%s (%d): Could not write signal.\n", __FILE__, __LINE__);
fits_close_file(fptr, &status);
return true;
}
int init_filter_file(const char *fname, int nspec, int nchan, int nphase,
int imjd0, double fmjd0) {
int status=0;
fitsfile *fptr;
fits_create_file(&fptr, fname, &status);
fits_movabs_hdu(fptr, 1, NULL, &status);
long naxes[3] = {2, nchan, nspec};
fits_create_img(fptr, FLOAT_IMG, 3, naxes, &status);
fits_write_key(fptr, TINT, "IMJD", &imjd0, NULL, &status);
fits_write_key(fptr, TDOUBLE, "FMJD", &fmjd0, NULL, &status);
naxes[0] = nphase;
naxes[1] = nspec;
fits_create_img(fptr, FLOAT_IMG, 2, naxes, &status);
fits_movabs_hdu(fptr, 2, NULL, &status);
fits_write_key(fptr, TSTRING, "EXTNAME", "PROFILE", NULL, &status);
fits_close_file(fptr, &status);
if (status) {
fprintf(stderr, "Error in init_filter_file:\n");
fits_report_error(stderr, status);
return(-1);
}
return(0);
}
void write_fits(fitsfile* fptr, int datatype, size_t width, size_t height,
size_t num, void** images, const char* names[], int* status)
{
// total number of pixels
long npix = width*height;
// dimensions
int naxis = 2;
long naxes[2] = { width, height };
// writing offset
long fpixel[2] = { 1, 1 };
// write primary HDU
fits_create_img(fptr, SHORT_IMG, 0, NULL, status);
// record file origin
fits_write_key(fptr, TSTRING, "ORIGIN", "Lensed " LENSED_VERSION, "FITS file originator", status);
fits_write_comment(fptr, "for more information, see http://glenco.github.io/lensed/", status);
// record the date of FITS creation
fits_write_date(fptr, status);
// write images
for(size_t n = 0; n < num; ++n)
{
// create image extension
fits_create_img(fptr, FLOAT_IMG, naxis, naxes, status);
// write pixels
fits_write_pix(fptr, datatype, fpixel, npix, images[n], status);
// give extension name
if(names && names[n])
fits_write_key(fptr, TSTRING, "EXTNAME", (void*)names[n], "extension name", status);
}
}
int append_filter(const char *fname, int ispec, int imjd, double fmjd,
struct filter_freq *hf) {
int status=0;
fitsfile *fptr;
fits_open_file(&fptr, fname, READWRITE, &status);
fits_movabs_hdu(fptr, 1, NULL, &status);
int naxis;
long naxes[3];
fits_get_img_dim(fptr, &naxis, &status);
if (naxis!=3) {
fits_close_file(fptr, &status);
return(-1);
}
fits_get_img_size(fptr, 3, naxes, &status);
if (naxes[0]!=2 || naxes[1]!=hf->nchan || naxes[2]<ispec) {
fits_close_file(fptr, &status);
return(-2);
}
int imjd0;
double fmjd0;
fits_read_key(fptr, TINT, "IMJD", &imjd0, NULL, &status);
fits_read_key(fptr, TDOUBLE, "FMJD", &fmjd0, NULL, &status);
double toffs = (double)(imjd-imjd0) + (fmjd-fmjd0);
toffs *= 86400.0;
char key[80];
sprintf(key, "DT%5.5d", ispec);
fits_write_key(fptr, TDOUBLE, key, &toffs, "[s]", &status);
naxes[0] = naxes[1] = 1;
naxes[2] = ispec;
fits_write_pix(fptr, TFLOAT, naxes, 2*hf->nchan,
(float *)hf->data, &status);
fits_close_file(fptr, &status);
if (status) {
fprintf(stderr, "Error in append_filter:\n");
fits_report_error(stderr, status);
return(-1);
}
return(0);
}
void
writefits(int im, inputPars *par, molData *m, image *img){
double bscale,bzero,epoch,lonpole,equinox,restfreq;
double cdelt1,crpix1,crval1,cdelt2,crpix2,crval2;
double cdelt3,crpix3,crval3,ru3;
int velref;
float *row;
int px,py,ichan;
fitsfile *fptr;
int status = 0;
int naxis=3, bitpix=-32;
long naxes[3];
long int fpixels[3],lpixels[3];
char negfile[100]="! ";
row = malloc(sizeof(*row)*img[im].pxls);
naxes[0]=img[im].pxls;
naxes[1]=img[im].pxls;
if(img[im].doline==1) naxes[2]=img[im].nchan;
else if(img[im].doline==0 && par->polarization) naxes[2]=3;
else naxes[2]=1;
fits_create_file(&fptr, img[im].filename, &status);
if(status!=0){
if(!silent) warning("Overwriting existing fits file ");
status=0;
strcat(negfile,img[im].filename);
fits_create_file(&fptr, negfile, &status);
}
/* Write FITS header */
fits_create_img(fptr, bitpix, naxis, naxes, &status);
epoch =2.0e3;
lonpole =1.8e2;
equinox =2.0e3;
restfreq=img[im].freq;
velref =257;
cdelt1 =-1.8e2*img[im].imgres/PI;
crpix1 =(double) img[im].pxls/2+0.5;
crval1 =0.0e0;
cdelt2 =1.8e2*img[im].imgres/PI;
crpix2 =(double) img[im].pxls/2+0.5;
crval2 =0.0e0;
cdelt3 =img[im].velres;
crpix3 =(double) (img[im].nchan-1)/2.+1;
crval3 =0.0e0;
bscale =1.0e0;
bzero =0.0e0;
fits_write_key(fptr, TSTRING, "OBJECT ", &"LIMEMDL ", "", &status);
fits_write_key(fptr, TDOUBLE, "EPOCH ", &epoch, "", &status);
fits_write_key(fptr, TDOUBLE, "LONPOLE ", &lonpole, "", &status);
fits_write_key(fptr, TDOUBLE, "EQUINOX ", &equinox, "", &status);
fits_write_key(fptr, TSTRING, "SPECSYS ", &"LSRK ", "", &status);
fits_write_key(fptr, TDOUBLE, "RESTFREQ", &restfreq, "", &status);
fits_write_key(fptr, TINT, "VELREF ", &velref, "", &status);
fits_write_key(fptr, TSTRING, "CTYPE1 ", &"RA---SIN", "", &status);
fits_write_key(fptr, TDOUBLE, "CDELT1 ", &cdelt1, "", &status);
fits_write_key(fptr, TDOUBLE, "CRPIX1 ", &crpix1, "", &status);
fits_write_key(fptr, TDOUBLE, "CRVAL1 ", &crval1, "", &status);
fits_write_key(fptr, TSTRING, "CUNIT1 ", &"DEG ", "", &status);
fits_write_key(fptr, TSTRING, "CTYPE2 ", &"DEC--SIN", "", &status);
fits_write_key(fptr, TDOUBLE, "CDELT2 ", &cdelt2, "", &status);
fits_write_key(fptr, TDOUBLE, "CRPIX2 ", &crpix2, "", &status);
fits_write_key(fptr, TDOUBLE, "CRVAL2 ", &crval2, "", &status);
fits_write_key(fptr, TSTRING, "CUNIT2 ", &"DEG ", "", &status);
fits_write_key(fptr, TSTRING, "CTYPE3 ", &"VELO-LSR", "", &status);
fits_write_key(fptr, TDOUBLE, "CDELT3 ", &cdelt3, "", &status);
fits_write_key(fptr, TDOUBLE, "CRPIX3 ", &crpix3, "", &status);
fits_write_key(fptr, TDOUBLE, "CRVAL3 ", &crval3, "", &status);
fits_write_key(fptr, TSTRING, "CUNIT3 ", &"M/S ", "", &status);
fits_write_key(fptr, TDOUBLE, "BSCALE ", &bscale, "", &status);
fits_write_key(fptr, TDOUBLE, "BZERO ", &bzero, "", &status);
if(img[im].unit==0) fits_write_key(fptr, TSTRING, "BUNIT", &"K ", "", &status);
if(img[im].unit==1) fits_write_key(fptr, TSTRING, "BUNIT", &"JY/PIXEL", "", &status);
if(img[im].unit==2) fits_write_key(fptr, TSTRING, "BUNIT", &"WM2HZSR ", "", &status);
if(img[im].unit==3) fits_write_key(fptr, TSTRING, "BUNIT", &"Lsun/PX ", "", &status);
if(img[im].unit==3) fits_write_key(fptr, TSTRING, "BUNIT", &" ", "", &status);
/* Write FITS data */
for(py=0;py<img[im].pxls;py++){
for(ichan=0;ichan<img[im].nchan;ichan++){
for(px=0;px<img[im].pxls;px++){
if(img[im].unit==0) row[px]=(float) img[im].pixel[px+py*img[im].pxls].intense[ichan]*(CLIGHT/img[im].freq)*(CLIGHT/img[im].freq)/2./KBOLTZ*m[0].norm;
else if(img[im].unit==1) row[px]=(float) img[im].pixel[px+py*img[im].pxls].intense[ichan]*1e26*img[im].imgres*img[im].imgres*m[0].norm;
else if(img[im].unit==2) row[px]=(float) img[im].pixel[px+py*img[im].pxls].intense[ichan]*m[0].norm;
else if(img[im].unit==3) {
ru3 = img[im].distance/1.975e13;
row[px]=(float) img[im].pixel[px+py*img[im].pxls].intense[ichan]*4.*PI*ru3*ru3*img[im].freq*img[im].imgres*img[im].imgres*m[0].norm;
}
else if(img[im].unit==4) row[px]=(float) img[im].pixel[px+py*img[im].pxls].tau[ichan];
else {
if(!silent) bail_out("Image unit number invalid");
exit(0);
}
if (fabs(row[px])<(float) eps) row[px]=(float)eps;
}
fpixels[0]=1;
fpixels[1]=py+1;
fpixels[2]=ichan+1;
lpixels[0]=img[im].pxls;
lpixels[1]=py+1;
lpixels[2]=ichan+1;
fits_write_subset(fptr, TFLOAT, fpixels, lpixels, row, &status);
}
}
fits_close_file(fptr, &status);
free(row);
if(!silent) done(13);
}
int put_header(fitsfile *fptr, struct uvf_header *header, int gcount,
double refdat, char *origin)
{
int naxis = 7;
long pcount = 6;
long naxes[7] = {0, 3, 1, 1, 1, 1, 1};
float bscale = 1.0, bzero = 0.0;
int one = 1, zero = 0;
double dfac1, dfac2, dref1, dref2, frac;
char str[80];
int status = 0;
int ier, year, month, day;
char datobs[16];
/* Create the DATOBS string */
slaDjcl(refdat, &year, &month, &day, &frac, &ier);
if (ier != 0)
fputs("Invalid DATOBS for FITS file.\n", stderr);
sprintf(datobs, "%4.4d-%2.2d-%2.2d", year, month, day);
/* Check for presence of INTTIM */
if (header->index_inttim >=0)
pcount = 7;
/* Write required keywords. */
naxes[2] = header->nstokes;
naxes[4] = header->nif;
fits_write_grphdr(fptr, 1, FLOAT_IMG, naxis, naxes, pcount, gcount,
1, &status);
fits_write_key(fptr, TFLOAT, "BSCALE", &bscale, 0, &status);
fits_write_key(fptr, TFLOAT, "BZERO", &bzero, 0, &status);
/* Additional keywords. */
fits_write_key(fptr, TSTRING, "OBJECT", header->object,
"Source name", &status);
fits_write_key(fptr, TSTRING, "TELESCOP", header->telescop,
0, &status);
fits_write_key(fptr, TSTRING, "INSTRUME", header->instrume,
0, &status);
fits_write_key(fptr, TSTRING, "OBSERVER", header->observer,
0, &status);
fits_write_key(fptr, TSTRING, "DATE-OBS", datobs,
0, &status);
fits_write_key(fptr, TSTRING, "BUNIT", header->bunit,
0, &status);
fits_write_key(fptr, TSTRING, "RADECSYS", header->radecsys,
0, &status);
fits_write_key(fptr, TDOUBLE, "EQUINOX", &header->equinox,
"Equinox of RA/Dec", &status);
fits_write_key(fptr, TDOUBLE, "EPOCH", &header->equinox,
"Alternate name for EQUINOX", &status);
fits_write_key(fptr, TDOUBLE, "OBSRA", &header->obsra,
"Antenna pointing RA", &status);
fits_write_key(fptr, TDOUBLE, "OBSDEC", &header->obsdec,
"Antenna pointing Dec", &status);
/* FITS coordinate parameters */
fits_write_key(fptr, TSTRING, "CTYPE2", "COMPLEX", "1=real, 2=imag, 3=weight", &status);
fits_write_key(fptr, TINT, "CRVAL2", &one, 0, &status);
fits_write_key(fptr, TINT, "CDELT2", &one, 0, &status);
fits_write_key(fptr, TINT, "CRPIX2", &one, 0, &status);
fits_write_key(fptr, TSTRING, "CTYPE3", "STOKES", "Correlator: -1=RR, -2=LL, -3=RL, -4=LR",&status);
fits_write_key(fptr, TINT, "CRVAL3", &header->stokes, 0, &status);
fits_write_key(fptr, TINT, "CDELT3", &header->delta_stokes, 0, &status);
fits_write_key(fptr, TINT, "CRPIX3", &one, 0, &status);
fits_write_key(fptr, TSTRING, "CTYPE4", "FREQ","Frequency, Hz", &status);
fits_write_key(fptr, TDOUBLE, "CRVAL4", &header->freq, 0, &status);
fits_write_key(fptr, TDOUBLE, "CDELT4", &header->bw, 0, &status);
fits_write_key(fptr, TINT, "CRPIX4", &one, 0, &status);
fits_write_key(fptr, TSTRING, "CTYPE5", "IF", "IF number",&status);
fits_write_key(fptr, TINT, "CRVAL5", &one, 0, &status);
fits_write_key(fptr, TINT, "CDELT5", &one, 0, &status);
fits_write_key(fptr, TINT, "CRPIX5", &one, 0, &status);
fits_write_key(fptr, TSTRING, "CTYPE6", "RA", "Right ascension, degrees", &status);
fits_write_key(fptr, TDOUBLE, "CRVAL6", &header->ra, 0, &status);
fits_write_key(fptr, TINT, "CDELT6", &zero, 0, &status);
fits_write_key(fptr, TINT, "CRPIX6", &one, 0, &status);
fits_write_key(fptr, TSTRING, "CTYPE7", "DEC", "Declination, degrees", &status);
fits_write_key(fptr, TDOUBLE, "CRVAL7", &header->dec, 0, &status);
fits_write_key(fptr, TINT, "CDELT7", &zero, 0, &status);
fits_write_key(fptr, TINT, "CRPIX7", &one, 0, &status);
/* FITS random parameters. */
fits_write_key(fptr, TSTRING, "PTYPE1", "UU", "baseline u projection, seconds", &status);
fits_write_key(fptr, TINT, "PSCAL1", &one, 0, &status);
fits_write_key(fptr, TINT, "PZERO1", &zero, 0, &status);
fits_write_key(fptr, TSTRING, "PTYPE2", "VV", "baseline v projection, seconds", &status);
fits_write_key(fptr, TINT, "PSCAL2", &one, 0, &status);
fits_write_key(fptr, TINT, "PZERO2", &zero, 0, &status);
fits_write_key(fptr, TSTRING, "PTYPE3", "WW", "baseline w projection, seconds", &status);
fits_write_key(fptr, TINT, "PSCAL3", &one, 0, &status);
fits_write_key(fptr, TINT, "PZERO3", &zero, 0, &status);
fits_write_key(fptr, TSTRING, "PTYPE4", "BASELINE", "256*ANT1 + ANT2", &status);
fits_write_key(fptr, TINT, "PSCAL4", &one, 0, &status);
fits_write_key(fptr, TINT, "PZERO4", &zero, 0, &status);
dfac1 = 1.0;
dref1 = refdat + 2400000.5; /* convert MJD to JD */
fits_write_key(fptr, TSTRING, "PTYPE5", "DATE", "UTC Julian Date part 1", &status);
fits_write_key(fptr, TDOUBLE, "PSCAL5", &dfac1, "Days", &status);
fits_write_key(fptr, TDOUBLE, "PZERO5", &dref1, 0, &status);
dfac2 = 1.0/86400.0;
dref2 = 0.0;
fits_write_key(fptr, TSTRING, "PTYPE6", "DATE", "UTC Julian Date part 2", &status);
fits_write_key(fptr, TDOUBLE, "PSCAL6", &dfac2, "Days/86400 (sec)", &status);
fits_write_key(fptr, TFLOAT, "PZERO6", &dref2, 0, &status);
if (pcount >= 7) {
fits_write_key(fptr, TSTRING, "PTYPE7", "INTTIM", "Integration time (sec)", &status);
fits_write_key(fptr, TINT, "PSCAL7", &one, 0, &status);
fits_write_key(fptr, TINT, "PZERO7", &zero, 0, &status);
}
sprintf(str, "%.12s (run by %.12s on %.12s)", origin,
getenv("USER"), getenv("HOST"));
fits_write_key(fptr, TSTRING, "ORIGIN", str," ", &status);
/* Date/time of file creation */
fits_write_date(fptr, &status);
fits_report_error(stderr, status);
return status;
}
void write(const char *key, const char *val, const char *comment) {
fits_write_key(fptr, TSTRING, const_cast<char *>(key), const_cast<char *>(val), const_cast<char *>(comment), status);
}
void write(const char *key, unsigned int val, const char *comment) {
fits_write_key(fptr, TUINT, const_cast<char *>(key), &val, const_cast<char *>(comment), status);
}
void write(const char *key, float val, const char *comment) {
fits_write_key(fptr, TFLOAT, const_cast<char *>(key), &val, const_cast<char *>(comment), status);
}
/*******************************************************************************
* gaussian_test
* This function creates a fits table, then populates it with the mean, sigma,
* and error on the mean from experiments sampling from a gaussian num_samples
* number of times.
* Input:
* fptr: Fits file to write the table to
* num_iter: Number of experiments to run
* num_samples: Number of samples for each experiment
* mean: Mean for the distibution in the experiments
* sigma: Sigma for the distribution in the experiments
* Output:
* status: Fits error status
******************************************************************************/
void gaussian_test(fitsfile *fptr, long num_iter, long num_samples, double mean,
double sigma, int *status){
long nrows, i, num_sigma;
double *stats, ratio_sigma, ave_mean, mean_sd, *all_means;
/* Fits file columns */
char *ttype[] = {"mean", "sigma", "error"};
char *tform[] = {"D", "D", "D"};
char *tunit[] = {NULL, NULL, NULL};
char *key[] = {"NSAMPLES", "MEAN", "SIGMA", "MEANAVE", "MEANSD"};
char *comment[] = {"Number of samples per iteration",
"True mean of the gaussian",
"True standard deviation of the gaussian",
"Average mean",
"Standard deviation of all means"};
/* Create the fits table */
fits_create_tbl(fptr, BINARY_TBL, 0, 3, ttype, tform, tunit, NULL, status);
if (*status){
printf("Error creating fits table in guassian_test.\n");
exit(*status);
}
/* Get mean, sigma, and error, then save to a fits file */
all_means = (double *) malloc(num_iter * sizeof(double));
ave_mean = 0;
for (nrows = 0; nrows < num_iter; nrows++){
stats = sample_gauss(num_samples, mean, sigma);
ave_mean += stats[0];
all_means[nrows] = stats[0];
/* Write to file */
for (i=0; i < 3; i++){
fits_write_col(fptr, TDOUBLE, i+1, nrows+1, 1L,1L, stats+i, status);
if (*status){
printf("Error writing to fits table in gaussian_test.\n");
exit(1);
}
}
free(stats); /* free memory for next iteration */
}
ave_mean /= num_iter;
/* Get standard deviation of all means */
mean_sd = 0;
for (i=0; i<num_iter; i++)
mean_sd += pow(ave_mean - all_means[i], 2);
mean_sd /= num_iter - 1;
mean_sd = sqrt(mean_sd);
/* Get percentage of experiments within 2 sigma */
num_sigma = 0;
for (i=0; i<num_iter; i++){
if (fabs(all_means[i] - ave_mean) < 2 * mean_sd)
num_sigma++;
}
ratio_sigma = (double) num_sigma / num_iter;
free(all_means);
/* print some results */
printf("Average mean: %g\n", ave_mean);
printf("Sigma of all means: %g\n", mean_sd);
printf("Percentage of experiments within 2 sigma: ");
printf("%g%c\n", 100 * ratio_sigma, (char) 37);
/* Write the number of samples to the fits table */
fits_write_key(fptr, TLONG, key[0], &num_samples, comment[0], status);
fits_write_key(fptr, TDOUBLE, key[1], &mean, comment[1], status);
fits_write_key(fptr, TDOUBLE, key[2], &num_sigma, comment[2], status);
fits_write_key(fptr, TDOUBLE, key[3], &ave_mean, comment[3], status);
fits_write_key(fptr, TDOUBLE, key[4], &mean_sd, comment[4], status);
if (*status){
printf("Error writing to fits header.\n");
exit(*status);
}
}
/* does the actual write of the file */
static void file_write_rays2fits(long fileNum, long firstTask, long lastTask, MPI_Comm fileComm)
{
const char *ttype[] =
{ "nest", "ra", "dec", "A00", "A01", "A10", "A11"
#ifdef OUTPUTRAYDEFLECTIONS
, "alpha0", "alpha1"
#endif
#ifdef OUTPUTPHI
, "phi"
#endif
};
const char *tform[] =
{ "K", "D", "D", "D", "D", "D", "D"
#ifdef OUTPUTRAYDEFLECTIONS
, "D", "D"
#endif
#ifdef OUTPUTPHI
, "D"
#endif
};
char name[MAX_FILENAME];
char bangname[MAX_FILENAME];
long NumRaysInFile,i,j;
long *NumRaysInPeanoCell,*StartRaysInPeanoCell,peano;
fitsfile *fptr;
int status = 0;
int naxis = 1;
long naxes[1],fpixel[1];
LONGLONG nrows;
int tfields,colnum;
long k,chunkInd,firstInd,lastInd,NumRaysInChunkBase,NumRaysInChunk,NumChunks;
LONGLONG firstrow,firstelem,nelements;
double *darr;
long *larr;
char *buff;
double ra,dec;
long nwc=0,NtotToRecv,nw=0,nwg=0,rpeano,rowloc;
MPI_Status mpistatus;
double t0 = 0.0;
sprintf(name,"%s/%s%04ld.%04ld",rayTraceData.OutputPath,rayTraceData.RayOutputName,rayTraceData.CurrentPlaneNum,fileNum);
sprintf(bangname,"!%s",name);
/* build fits table layout*/
tfields = 7;
#ifdef OUTPUTRAYDEFLECTIONS
tfields += 2;
#endif
#ifdef OUTPUTPHI
tfields += 1;
#endif
/* build file layout*/
NumRaysInPeanoCell = (long*)malloc(sizeof(long)*NbundleCells);
assert(NumRaysInPeanoCell != NULL);
StartRaysInPeanoCell = (long*)malloc(sizeof(long)*NbundleCells);
assert(StartRaysInPeanoCell != NULL);
for(i=0;i<NbundleCells;++i)
StartRaysInPeanoCell[i] = 0;
for(i=0;i<NbundleCells;++i)
{
if(ISSETBITFLAG(bundleCells[i].active,PRIMARY_BUNDLECELL))
{
peano = nest2peano(bundleCells[i].nest,rayTraceData.bundleOrder);
StartRaysInPeanoCell[peano] = bundleCells[i].Nrays;
nwc += bundleCells[i].Nrays;
}
}
MPI_Allreduce(StartRaysInPeanoCell,NumRaysInPeanoCell,(int) NbundleCells,MPI_LONG,MPI_SUM,fileComm);
j = 0;
for(i=0;i<NbundleCells;++i)
{
StartRaysInPeanoCell[i] = j;
j += NumRaysInPeanoCell[i];
}
NumRaysInFile = j;
/* make the file and write header info */
if(ThisTask == firstTask)
{
t0 = -MPI_Wtime();
remove(name);
fits_create_file(&fptr,bangname,&status);
if(status)
fits_report_error(stderr,status);
naxes[0] = 2l*NbundleCells;
fits_create_img(fptr,LONGLONG_IMG,naxis,naxes,&status);
if(status)
fits_report_error(stderr,status);
fpixel[0] = 0+1;
fits_write_pix(fptr,TLONG,fpixel,(LONGLONG) (NbundleCells),NumRaysInPeanoCell,&status);
if(status)
fits_report_error(stderr,status);
fpixel[0] = NbundleCells+1;
fits_write_pix(fptr,TLONG,fpixel,(LONGLONG) (NbundleCells),StartRaysInPeanoCell,&status);
if(status)
fits_report_error(stderr,status);
fits_write_key(fptr,TLONG,"NumFiles",&(rayTraceData.NumRayOutputFiles),"number of files that rays are split into",&status);
if(status)
fits_report_error(stderr,status);
fits_write_key(fptr,TLONG,"PeanoCellHEALPixOrder",&(rayTraceData.bundleOrder),"HEALPix order of peano indexed cells rays are organized into",&status);
if(status)
fits_report_error(stderr,status);
fits_write_key(fptr,TLONG,"RayHEALPixOrder",&(rayTraceData.rayOrder),"HEALPix order of ray grid",&status);
if(status)
fits_report_error(stderr,status);
nrows = (LONGLONG) (NumRaysInFile);
fits_create_tbl(fptr,BINARY_TBL,nrows,tfields,ttype,tform,NULL,"Rays",&status);
if(status)
fits_report_error(stderr,status);
fits_get_rowsize(fptr,&NumRaysInChunkBase,&status);
if(status)
fits_report_error(stderr,status);
}
MPI_Bcast(&NumRaysInChunkBase,1,MPI_LONG,0,fileComm);
if(sizeof(long) > sizeof(double))
buff = (char*)malloc(sizeof(long)*NumRaysInChunkBase);
else
buff = (char*)malloc(sizeof(double)*NumRaysInChunkBase);
assert(buff != NULL);
darr = (double*) buff;
larr = (long*) buff;
for(i=firstTask;i<=lastTask;++i)
{
if(ThisTask == i)
{
#ifdef DEBUG
#if DEBUG_LEVEL > 0
fprintf(stderr,"%d: fileNum = %ld, first,last = %ld|%ld\n",ThisTask,fileNum,firstTask,lastTask);
#endif
#endif
if(ThisTask != firstTask)
MPI_Send(&nwc,1,MPI_LONG,(int) firstTask,TAG_RAYIO_TOTNUM,MPI_COMM_WORLD);
for(rpeano=0;rpeano<NrestrictedPeanoInd;++rpeano)
{
j = bundleCellsRestrictedPeanoInd2Nest[rpeano];
if(ISSETBITFLAG(bundleCells[j].active,PRIMARY_BUNDLECELL))
{
peano = nest2peano(bundleCells[j].nest,rayTraceData.bundleOrder);
assert(NumRaysInPeanoCell[peano] == ((1l) << (2*(rayTraceData.rayOrder-rayTraceData.bundleOrder))));
assert((StartRaysInPeanoCell[peano] -
((StartRaysInPeanoCell[peano])/(((1l) << (2*(rayTraceData.rayOrder-rayTraceData.bundleOrder)))))
*(((1l) << (2*(rayTraceData.rayOrder-rayTraceData.bundleOrder))))) == 0);
NumChunks = NumRaysInPeanoCell[peano]/NumRaysInChunkBase;
if(NumChunks*NumRaysInChunkBase < NumRaysInPeanoCell[peano])
NumChunks += 1;
firstrow = (LONGLONG) (StartRaysInPeanoCell[peano]) + (LONGLONG) 1;
firstelem = 1;
for(chunkInd=0;chunkInd<NumChunks;++chunkInd)
{
firstInd = chunkInd*NumRaysInChunkBase;
lastInd = (chunkInd+1)*NumRaysInChunkBase-1;
if(lastInd >= NumRaysInPeanoCell[peano]-1)
lastInd = NumRaysInPeanoCell[peano]-1;
NumRaysInChunk = lastInd - firstInd + 1;
nelements = (LONGLONG) NumRaysInChunk;
nw += NumRaysInChunk;
if(ThisTask != firstTask)
{
rowloc = firstrow;
MPI_Send(&rowloc,1,MPI_LONG,(int) firstTask,TAG_RAYIO_CHUNKDATA,MPI_COMM_WORLD);
MPI_Send(&NumRaysInChunk,1,MPI_LONG,(int) firstTask,TAG_RAYIO_NUMCHUNK,MPI_COMM_WORLD);
colnum = TAG_RAYIO_CHUNKDATA+1;
for(k=firstInd;k<=lastInd;++k)
larr[k-firstInd] = bundleCells[j].rays[k].nest;
MPI_Ssend(larr,(int) NumRaysInChunk,MPI_LONG,(int) firstTask,colnum,MPI_COMM_WORLD);
++colnum;
for(k=firstInd;k<=lastInd;++k)
{
vec2radec(bundleCells[j].rays[k].n,&ra,&dec);
darr[k-firstInd] = ra;
}
MPI_Ssend(darr,(int) NumRaysInChunk,MPI_DOUBLE,(int) firstTask,colnum,MPI_COMM_WORLD);
++colnum;
for(k=firstInd;k<=lastInd;++k)
{
vec2radec(bundleCells[j].rays[k].n,&ra,&dec);
darr[k-firstInd] = dec;
}
MPI_Ssend(darr,(int) NumRaysInChunk,MPI_DOUBLE,(int) firstTask,colnum,MPI_COMM_WORLD);
++colnum;
for(k=firstInd;k<=lastInd;++k)
darr[k-firstInd] = bundleCells[j].rays[k].A[2*0+0];
MPI_Ssend(darr,(int) NumRaysInChunk,MPI_DOUBLE,(int) firstTask,colnum,MPI_COMM_WORLD);
++colnum;
for(k=firstInd;k<=lastInd;++k)
darr[k-firstInd] = bundleCells[j].rays[k].A[2*0+1];
MPI_Ssend(darr,(int) NumRaysInChunk,MPI_DOUBLE,(int) firstTask,colnum,MPI_COMM_WORLD);
++colnum;
for(k=firstInd;k<=lastInd;++k)
darr[k-firstInd] = bundleCells[j].rays[k].A[2*1+0];
MPI_Ssend(darr,(int) NumRaysInChunk,MPI_DOUBLE,(int) firstTask,colnum,MPI_COMM_WORLD);
++colnum;
for(k=firstInd;k<=lastInd;++k)
darr[k-firstInd] = bundleCells[j].rays[k].A[2*1+1];
MPI_Ssend(darr,(int) NumRaysInChunk,MPI_DOUBLE,(int) firstTask,colnum,MPI_COMM_WORLD);
++colnum;
#ifdef OUTPUTRAYDEFLECTIONS
for(k=firstInd;k<=lastInd;++k)
darr[k-firstInd] = bundleCells[j].rays[k].alpha[0];
MPI_Ssend(darr,(int) NumRaysInChunk,MPI_DOUBLE,(int) firstTask,colnum,MPI_COMM_WORLD);
++colnum;
for(k=firstInd;k<=lastInd;++k)
darr[k-firstInd] = bundleCells[j].rays[k].alpha[1];
MPI_Ssend(darr,(int) NumRaysInChunk,MPI_DOUBLE,(int) firstTask,colnum,MPI_COMM_WORLD);
++colnum;
#endif
#ifdef OUTPUTPHI
for(k=firstInd;k<=lastInd;++k)
darr[k-firstInd] = bundleCells[j].rays[k].phi;
MPI_Ssend(darr,(int) NumRaysInChunk,MPI_DOUBLE,(int) firstTask,colnum,MPI_COMM_WORLD);
++colnum;
#endif
firstrow += nelements;
}
else
{
colnum = 1;
for(k=firstInd;k<=lastInd;++k)
larr[k-firstInd] = bundleCells[j].rays[k].nest;
fits_write_col(fptr,TLONG,colnum,firstrow,firstelem,nelements,larr,&status);
if(status)
fits_report_error(stderr,status);
++colnum;
for(k=firstInd;k<=lastInd;++k)
{
vec2radec(bundleCells[j].rays[k].n,&ra,&dec);
darr[k-firstInd] = ra;
}
fits_write_col(fptr,TDOUBLE,colnum,firstrow,firstelem,nelements,darr,&status);
if(status)
fits_report_error(stderr,status);
++colnum;
for(k=firstInd;k<=lastInd;++k)
{
vec2radec(bundleCells[j].rays[k].n,&ra,&dec);
darr[k-firstInd] = dec;
}
fits_write_col(fptr,TDOUBLE,colnum,firstrow,firstelem,nelements,darr,&status);
if(status)
fits_report_error(stderr,status);
++colnum;
for(k=firstInd;k<=lastInd;++k)
darr[k-firstInd] = bundleCells[j].rays[k].A[2*0+0];
fits_write_col(fptr,TDOUBLE,colnum,firstrow,firstelem,nelements,darr,&status);
if(status)
fits_report_error(stderr,status);
++colnum;
for(k=firstInd;k<=lastInd;++k)
darr[k-firstInd] = bundleCells[j].rays[k].A[2*0+1];
fits_write_col(fptr,TDOUBLE,colnum,firstrow,firstelem,nelements,darr,&status);
if(status)
fits_report_error(stderr,status);
++colnum;
for(k=firstInd;k<=lastInd;++k)
darr[k-firstInd] = bundleCells[j].rays[k].A[2*1+0];
fits_write_col(fptr,TDOUBLE,colnum,firstrow,firstelem,nelements,darr,&status);
if(status)
fits_report_error(stderr,status);
++colnum;
for(k=firstInd;k<=lastInd;++k)
darr[k-firstInd] = bundleCells[j].rays[k].A[2*1+1];
fits_write_col(fptr,TDOUBLE,colnum,firstrow,firstelem,nelements,darr,&status);
if(status)
fits_report_error(stderr,status);
++colnum;
#ifdef OUTPUTRAYDEFLECTIONS
for(k=firstInd;k<=lastInd;++k)
darr[k-firstInd] = bundleCells[j].rays[k].alpha[0];
fits_write_col(fptr,TDOUBLE,colnum,firstrow,firstelem,nelements,darr,&status);
if(status)
fits_report_error(stderr,status);
++colnum;
for(k=firstInd;k<=lastInd;++k)
darr[k-firstInd] = bundleCells[j].rays[k].alpha[1];
fits_write_col(fptr,TDOUBLE,colnum,firstrow,firstelem,nelements,darr,&status);
if(status)
fits_report_error(stderr,status);
++colnum;
#endif
#ifdef OUTPUTPHI
for(k=firstInd;k<=lastInd;++k)
darr[k-firstInd] = bundleCells[j].rays[k].phi;
fits_write_col(fptr,TDOUBLE,colnum,firstrow,firstelem,nelements,darr,&status);
if(status)
fits_report_error(stderr,status);
++colnum;
#endif
firstrow += nelements;
}
}// for(chunkInd=0;chunkInd<NumChunks;++chunkInd)
} //if(ISSETBITFLAG(bundleCells[j].active,PRIMARY_BUNDLECELL)).
} //for(j=0;j<NbundleCells;++j)
} //if(ThisTask == i)
if(i != firstTask && ThisTask == firstTask)
{
MPI_Recv(&NtotToRecv,1,MPI_LONG,(int) i,TAG_RAYIO_TOTNUM,MPI_COMM_WORLD,&mpistatus);
firstelem = 1;
while(NtotToRecv > 0)
{
MPI_Recv(&rowloc,1,MPI_LONG,(int) i,TAG_RAYIO_CHUNKDATA,MPI_COMM_WORLD,&mpistatus);
MPI_Recv(&NumRaysInChunk,1,MPI_LONG,(int) i,TAG_RAYIO_NUMCHUNK,MPI_COMM_WORLD,&mpistatus);
firstrow = (LONGLONG) (rowloc);
nelements = (LONGLONG) NumRaysInChunk;
colnum = 1;
MPI_Recv(larr,(int) NumRaysInChunk,MPI_LONG,(int) i,colnum+TAG_RAYIO_CHUNKDATA,MPI_COMM_WORLD,&mpistatus);
fits_write_col(fptr,TLONG,colnum,firstrow,firstelem,nelements,larr,&status);
if(status)
fits_report_error(stderr,status);
++colnum;
MPI_Recv(darr,(int) NumRaysInChunk,MPI_DOUBLE,(int) i,colnum+TAG_RAYIO_CHUNKDATA,MPI_COMM_WORLD,&mpistatus);
fits_write_col(fptr,TDOUBLE,colnum,firstrow,firstelem,nelements,darr,&status);
if(status)
fits_report_error(stderr,status);
++colnum;
MPI_Recv(darr,(int) NumRaysInChunk,MPI_DOUBLE,(int) i,colnum+TAG_RAYIO_CHUNKDATA,MPI_COMM_WORLD,&mpistatus);
fits_write_col(fptr,TDOUBLE,colnum,firstrow,firstelem,nelements,darr,&status);
if(status)
fits_report_error(stderr,status);
++colnum;
MPI_Recv(darr,(int) NumRaysInChunk,MPI_DOUBLE,(int) i,colnum+TAG_RAYIO_CHUNKDATA,MPI_COMM_WORLD,&mpistatus);
fits_write_col(fptr,TDOUBLE,colnum,firstrow,firstelem,nelements,darr,&status);
if(status)
fits_report_error(stderr,status);
++colnum;
MPI_Recv(darr,(int) NumRaysInChunk,MPI_DOUBLE,(int) i,colnum+TAG_RAYIO_CHUNKDATA,MPI_COMM_WORLD,&mpistatus);
fits_write_col(fptr,TDOUBLE,colnum,firstrow,firstelem,nelements,darr,&status);
if(status)
fits_report_error(stderr,status);
++colnum;
MPI_Recv(darr,(int) NumRaysInChunk,MPI_DOUBLE,(int) i,colnum+TAG_RAYIO_CHUNKDATA,MPI_COMM_WORLD,&mpistatus);
fits_write_col(fptr,TDOUBLE,colnum,firstrow,firstelem,nelements,darr,&status);
if(status)
fits_report_error(stderr,status);
++colnum;
MPI_Recv(darr,(int) NumRaysInChunk,MPI_DOUBLE,(int) i,colnum+TAG_RAYIO_CHUNKDATA,MPI_COMM_WORLD,&mpistatus);
fits_write_col(fptr,TDOUBLE,colnum,firstrow,firstelem,nelements,darr,&status);
if(status)
fits_report_error(stderr,status);
++colnum;
#ifdef OUTPUTRAYDEFLECTIONS
MPI_Recv(darr,(int) NumRaysInChunk,MPI_DOUBLE,(int) i,colnum+TAG_RAYIO_CHUNKDATA,MPI_COMM_WORLD,&mpistatus);
fits_write_col(fptr,TDOUBLE,colnum,firstrow,firstelem,nelements,darr,&status);
if(status)
fits_report_error(stderr,status);
++colnum;
MPI_Recv(darr,(int) NumRaysInChunk,MPI_DOUBLE,(int) i,colnum+TAG_RAYIO_CHUNKDATA,MPI_COMM_WORLD,&mpistatus);
fits_write_col(fptr,TDOUBLE,colnum,firstrow,firstelem,nelements,darr,&status);
if(status)
fits_report_error(stderr,status);
++colnum;
#endif
#ifdef OUTPUTPHI
MPI_Recv(darr,(int) NumRaysInChunk,MPI_DOUBLE,(int) i,colnum+TAG_RAYIO_CHUNKDATA,MPI_COMM_WORLD,&mpistatus);
fits_write_col(fptr,TDOUBLE,colnum,firstrow,firstelem,nelements,darr,&status);
if(status)
fits_report_error(stderr,status);
++colnum;
#endif
nwg += NumRaysInChunk;
NtotToRecv -= NumRaysInChunk;
}
}
//////////////////////////////
MPI_Barrier(fileComm);
//////////////////////////////
}
if(ThisTask == firstTask)
{
fits_close_file(fptr,&status);
if(status)
fits_report_error(stderr,status);
t0 += MPI_Wtime();
#ifdef DEBUG
fprintf(stderr,"writing %ld rays to file '%s' took %g seconds.\n",NumRaysInFile,name,t0);
#endif
assert(nwg == NumRaysInFile-nw); //error check # of rays recvd
}
//error check # of rays written
MPI_Allreduce(&nw,&nwg,1,MPI_LONG,MPI_SUM,fileComm);
assert(nw == nwc);
assert(nwg == NumRaysInFile);
//clean up and close files for this task
free(buff);
free(StartRaysInPeanoCell);
free(NumRaysInPeanoCell);
}
static void write_data_to_file(pi16u * buf, struct metadata * md, char * prepend, lua_State *L)
{
fitsfile *ff;
int status = 0, retcode = 0;
long naxes[2] = {2048, 2048};
char outdir[STR_BUF_SIZE];
char outfile[STR_BUF_SIZE];
float bscale1 = 1.0, bzero32768 = 32768.0;
SYSTEMTIME str_t;
/* Create output directory */
GetLocalTime(&str_t);
sprintf_s(outdir, STR_BUF_SIZE, "%s\\%4d%s%2d", path_prefix,
str_t.wYear, months[str_t.wMonth], str_t.wDay);
if(!DirectoryExists((LPCTSTR) outdir)) {
printf("Creating directory %s\n", outdir);
if(!mkdir(outdir)) {
lua_pushstring(L,"Could not create path\n");
lua_error(L);
return;
}
}
sprintf_s(outfile, STR_BUF_SIZE, "!%s\\%s%4.4d%2.2d%2.2d_%2.2i_%2.2i_%2.2i.fits", outdir, prepend,
str_t.wYear, str_t.wMonth, str_t.wDay, str_t.wHour, str_t.wMinute, str_t.wSecond);
/* FITS housekeeping */
retcode = fits_create_file(&ff, outfile, &status);
if(retcode) {
lua_pushstring(L,"Could not create FITS file\n");
fits_report_error(stderr, status);
lua_error(L);
return;
}
retcode = fits_create_img(ff,
SHORT_IMG , // bitpix
2, // naxis
naxes, // naxes
&status);
if(retcode) {
lua_pushstring(L,"Could not create image \n");
fits_report_error(stderr, status);
lua_error(L);
fits_close_file(ff, &status);
return;
}
// Following line is required to handle ushort, see:
// "Support for Unsigned Integers and Signed Bytes" in
// cfitsio manual
fits_write_key(ff, TFLOAT, "BSCALE", &bscale1, NULL, &status);
fits_write_key(ff, TFLOAT, "BZERO", &bzero32768, NULL, &status);
fits_set_bscale(ff, 1, //BSCALE Factor
32768, // BZERO factor
&status);
fits_write_key(ff, TDOUBLE, "EXPTIME", &md->exptime, "Exposure time in s", &status);
fits_write_key(ff, TDOUBLE, "ADCSPEED", &md->adcspeed, "Readout speed in MHz", &status);
fits_write_key(ff, TDOUBLE, "TEMP", &md->temp, "Detector temp in deg C", &status);
fits_write_key(ff, TINT, "BITDEPTH", &md->bitdepth, "Bit depth", &status);
fits_write_key(ff, TINT, "GAIN_SET", &md->gain, "1: low, 2: medium, 3: high gain", &status);
fits_write_key(ff, TINT, "ADC", &md->adc, "1: Low noise, 2: high capacity", &status);
fits_write_key(ff, TINT, "MODEL", &md->id->model, "PI Model #", &status);
fits_write_key(ff, TINT, "INTERFC", &md->id->computer_interface, "PI Computer Interface", &status);
fits_write_key(ff, TSTRING, "SNSR_NM", &md->id->sensor_name, "PI sensor name", &status);
fits_write_key(ff, TSTRING, "SER_NO", &md->id->serial_number, "PI serial #", &status);
retcode = fits_write_img(ff,
TUSHORT, // (T)ype is unsigned short (USHORT)
1, // Copy from [0, 0] but fits format is indexed by 1
naxes[0] * naxes[1], // Number of elements
buf,
&status);
if(retcode && status==412) {
printf("Overflow\n");
} else if(retcode) {
lua_pushstring(L,"Could not copy data over \n");
fits_report_error(stderr, status);
lua_error(L);
fits_close_file(ff, &status);
return;
}
fits_close_file(ff, &status);
printf("Wrote '%s'.\n", outfile);
}
int WrtPSRFITSHdr(struct ASPHdr *hdr,
fitsfile *Fout)
{
int status=0, ival, i, ii, colnum, indx, retval=-1;
double ra_hr, ra_min, ra_sec, dec_deg, dec_min, dec_sec;
// char *tunit[4*NCHMAX+10], *tform[4*NCHMAX+10], *ttype[4*NCHMAX+10];
char junkch1[2048], junkch2[2048], junkch3[2048];
time_t cur_time;
struct tm *utctime;
// junkch1 = (char *) calloc(20, sizeof(char));
/* ival = 1; fits_update_key(Fout, TLOGICAL, "SIMPLE", &ival, NULL, &status); status = 0;
ival = 32; fits_update_key(Fout, TINT, "BITPIX", &ival, "FITS COMPATIBLE", &status); status = 0;
ival = 0; fits_update_key(Fout, TINT, "NAXIS", &ival, "FITS COMPATIBLE", &status); status = 0; */
/* Fill in primary header with current header variables, and change what
is needed */
/* Create primary header */
if(fits_create_img(Fout, 8, 0, NULL, &status) != 0) {
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot create primary table.\n");
return -1;
}
/* Start adding keywords */
/* Header version */
sprintf(junkch1, "5.0");
if(fits_write_key(Fout, TSTRING, "HDRVER", junkch1, "Header version", &status) != 0) {
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword HDRVER.\n");
return -1;
}
/* Type of FITS file */
sprintf(dummy_txt, "PSRFITS");
if(fits_write_key(Fout, TSTRING, "FITSTYPE", junkch1, "FITS definition for pulsar data files", &status) != 0) {
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword FITSTYPE.\n");
return -1;
}
/* File creation date (YYYY-MM-DDThh:mm:ss UTC) */
/* Get current time */
curtime = time(NULL);
/* Convert time to gmtine representation */
utctime = gmtime(&curtime);
/* String it up */
strftime(junkch1, 256, "%Y-%m-%dT%H:%M:%S");
// sprintf(junkch1, "%sT%s", hdr->filecont.FileDate, hdr->filecont.FileUT);
if(fits_write_key(Fout, TSTRING, "DATE", junkch1, "File creation date (YYYY-MM-DDThh:mm:ss UTC)", &status) != 0) {
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword DATE.\n");
return -1;
}
/* Observer name */
if(fits_write_key(Fout, TSTRING, "OBSERVER", hdr->gen.Observer, "Observer name(s)", &status) != 0) {
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword OBSERVER.\n");
return -1;
}
/* Project ID */
if(fits_write_key(Fout, TSTRING, "PROJID", hdr->gen.ProjID, "Project name", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword PROJID.\n");
return -1;
}
/* Telescope identifier */
if(fits_write_key(Fout, TSTRING, "TELESCOP", hdr->obs.ObsvtyCode, "Telescope name", &status) != 0) {
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword TELESCOP.\n");
return -1;
}
/* Antenna ITRF X, Y, and Z coordinates */
if(fits_write_key(Fout, TDOUBLE, "ANT_X", &hdr->target.Ant_X, "Antenna ITRF X-coordinate", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword ANT_X.\n");
return -1;
}
if(fits_write_key_unit(Fout, "ANT_X", "m", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write units for keyword ANT_X.\n");
return -1;
}
if(fits_write_key(Fout, TDOUBLE, "ANT_Y", &hdr->target.Ant_Y, "Antenna ITRF Y-coordinate", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword ANT_Y.\n");
return -1;
}
if(fits_write_key_unit(Fout, "ANT_Y", "m", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write units for keyword ANT_Y.\n");
return -1;
}
if(fits_write_key(Fout, TDOUBLE, "ANT_Z", &hdr->target.Ant_Z, "Antenna ITRF Z-coordinate", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword ANT_Z.\n");
return -1;
}
if(fits_write_key_unit(Fout, "ANT_Z", "m", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write units for keyword ANT_Z.\n");
return -1;
}
/* Frontend name GREG/CH etc */
if(fits_write_key(Fout, TSTRING, "FRONTEND", hdr->gen.FEName, "Receiver ID", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword FRONTEND.\n");
return -1;
}
/* Beam ID for multiple-beam systems */
if(fits_write_key(Fout, TSTRING, "IBEAM", hdr->gen.IBeam, "Beam ID for multibeam systems", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword IBEAM.\n");
return -1;
}
/* Number of receiver polarisation channels */
if(fits_write_key(Fout, TSTRING, "NRCVR", hdr->gen.NRcvr, "Number of receiver polarisation channels", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword NRCVR.\n");
return -1;
}
/* Polarisation type CIRC/LIN */
if (!strncmp(hdr->gen.FEPol, "L", 1))
strcpy(junkch1, "LIN");
else if (!strncmp(hdr->gen.FEPol, "C", 1))
strcpy(junkch1, "CIRC");
else {
fprintf(stderr,"WrtPSRFITSHdr ERROR: Unrecognized polarization basis %s\n",
hdr->gen.FEPol);
return -1;
}
if(fits_write_key(Fout, TSTRING, "FD_POLN", hdr->gen.FEPol, "Polarisation type CIRC/LIN", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword FD_POLN.\n");
return -1;
}
/* A/B polarization swap -- +/- 1. +1 is LIN: A=X, B=Y, CIRC:A=L, B=R */
if(fits_write_key(Fout, TINT, "FD_HAND", &hdr->gen.FDHand, "+/- 1. +1 is LIN: A=X, B=Y, CIRC:A=L, B=R", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword FD_HAND.\n");
return -1;
}
/* FA of E vector for equal sig in A&B */
if(fits_write_key(Fout, TFLOAT, "FD_SANG", &hdr->gen.FDSang, "FA of E vector for equal sig in A&B", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword FD_SANG.\n");
return -1;
}
if(fits_write_key_unit(Fout, "FD_SANG", "deg", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write units for keyword FD_SANG.\n");
return -1;
}
/* Phase of A*B for injected cal */
if(fits_write_key(Fout, TFLOAT, "FD_XYPH", &hdr->gen.FDXYph, "Phase of A^* B for injected cal", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword FD_XYPH.\n");
return -1;
}
if(fits_write_key_unit(Fout, "FD_XYPH", "deg", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write units for keyword FD_XYPH.\n");
return -1;
}
/* Name of backend instrument used */
if(fits_write_key(Fout, TSTRING, "BACKEND", hdr->gen.BEName, "Backend ID", &status) != 0) {
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword BACKEND.\n");
return -1;
}
/* Backend Config filename */
if(fits_write_key(Fout, TSTRING, "BECONFIG", hdr->gen.BEConfFile, "Backend configuration file name", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword BECONFIG.\n");
return -1;
}
/* 0/+1/-1 BE cross-phase: 0 unknown, +/-1 std/rev */
if(fits_write_key(Fout, TINT, "BE_PHASE", &hdr->gen.BEPhase, "0/+1/-1 BE cross-phase: 0 unknown, +/-1 std/rev", &status) != 0) {
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword BE_PHASE.\n");
return -1;
}
/* 0/1 BE downconversion conjugation */
if(fits_write_key(Fout, TINT, "BE_DCC", &hdr->gen.BEDownConv, "0/1 BE downconversion conjugation", &status) != 0) {
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword BE_DCC.\n");
return -1;
}
/* Backend propn delay from digitiser in seconds */
if(fits_write_key(Fout, TFLOAT, "BE_DELAY", &hdr->gen.BEDelay, "Backend propn delay from digitiser in seconds", &status) != 0) {
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword BE_DELAY.\n");
return -1;
}
if(fits_write_key_unit(Fout, "BE_DELAY", "s", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write units for keyword BE_DELAY.\n");
return -1;
}
/* On-line cycle time */
if(fits_write_key(Fout, TDOUBLE, "TCYCLE", &hdr->gen.TCycle, "On-line cycle time", &status) != 0) {
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword TCYCLE.\n");
return -1;
}
if(fits_write_key_unit(Fout, "TCYCLE", "s", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write units for keyword TCYCLE.\n");
return -1;
}
/* Mode of observing (usually PSR or CAL) */
if(fits_write_key(Fout, TSTRING, "OBS_MODE", hdr->gen.ObsMode, "", &status) != 0) {
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword OBS_MODE.\n");
return -1;
}
/* Date of observation (YYYY-MM-DDThh:mm:ss UTC) */
sprintf(junkch1, "%sT%s", hdr->obs.StartDate, hdr->obs.StartUT);
if(fits_write_key(Fout, TSTRING, "DATE-OBS", tempstr1, "Date of observation (YYYY-MM-DDThh:mm:ss UTC)", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword DATE-OBS.\n");
return -1;
}
/* Centre observing frequency */
if(fits_write_key(Fout, TDOUBLE, "OBSFREQ", hdr->obs.FSkyCent, "Centre frequency for observation", &status) != 0) {
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword OBSFREQ.\n");
return -1;
}
if(fits_write_key_unit(Fout, "OBSFREQ", "MHz", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write units for keyword OBSFREQ.\n");
return -1;
}
/* Bandwidth for observation [MHz] */
/* Multiply by Sideband to get it in proper format for psrfits definition */
hdr->obs.BW *= (double)hdr->obs.Sideband;
if(fits_write_key(Fout, TDOUBLE, "OBSBW", &hdr->obs.BW, "Bandwidth for observation", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword OBSBW.\n");
return -1;
}
if(fits_write_key_unit(Fout, "OBSBW", "MHz", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write units for keyword OBSBW.\n");
return -1;
}
/* Number of frequency channels (original number) */
if(fits_write_key(Fout, TINT, "OBSNCHAN", &hdr->obs.NChanOrig, "Number of frequency channels (original number)", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword OBSNCHAN.\n");
return -1;
}
/* DM used for online dedispaersion [cm-3 pc] */
if(fits_write_key(Fout, TDOUBLE, "CHAN_DM", &hdr->obs.ChanDM, "DM used for online dedispaersion", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword CHAN_DM.\n");
return -1;
}
if(fits_write_key_unit(Fout, "CHAN_DM", "cm-3 pc", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write units for keyword CHAN_DM.\n");
return -1;
}
/* Name or ID for pointing centre (multibeam feeds) */
if(fits_write_key(Fout, TSTRING, "PNT_ID", hdr->gen.PntID, "Name or ID for pointing centre (multibeam feeds)", &status) != 0){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword PNT_ID.\n");
return -1;
}
/* Pulsar or source name */
if(fits_write_key(Fout, TSTRING, "SRC_NAME", hdr->target.PSRName, "Source or scan ID", &status) != 0) {
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword SRC_NAME.\n");
return -1;
}
/*===========================================*/
/* Coordinate mode for following 4 entries J2000/GAL/ECLIPTIC/AZEL etc. */
if(fits_write_key(Fout, TSTRING, "COORD_MD", hdr->target.CoordMode, "Coordinate mode (J2000/GAL/ECLIPTIC/AZEL etc.)", &status) !=0 ){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword COORD_MD.\n");
return -1;
}
/* Epoch of the coordinates */
/* Read in as string and convert depending on PSRFITS version */
if(fits_write_key(Fout, TFLOAT, "EQUINOX", &hdr->target.Epoch, "Epoch of the coordinates", &status) !=0 ){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword EQUINOX.\n");
return -1;
}
/* Right Assention hh:mm:ss.sss */
ra_hr = floor(hdr->target.RA);
ra_min = floor((hdr->target.RA - ra_hr)*60.);
ra_sec = ((hdr->target.RA - ra_hr)*60. - ra_min) * 60.;
sprintf(junkch1, "%2d:%2d:%lf", (int)ra_hr, (int)ra_min, ra_sec);
if(fits_write_key(Fout, TSTRING, "RA", junkch1, "Right Assention (hh:mm:ss.sss)", &status) !=0 ){
fprintf(stderr, "WrtPSRFITSHdr ERROR: Cannot write keyword RA.\n");
return -1;
}
/* Declination -dd:mm:ss.sss */
dec_deg = floor(hdr->target.Dec);
dec_min = floor((hdr->target.Dec - dec_deg)*60.);
dec_sec = ((hdr->target.Dec - dec_deg)*60. - dec_min) * 60.;
if(hdr->target.Dec < 0):
sprintf(junkch1, "-%2d:%2d:%lf", (int)dec_deg, (int)dec_min, dec_sec);
else
int append_image_FITS(void *image,SID_Datatype dtype,int n_D,int *D_in,const char *filename,const char *ext_name){
fitsfile *fp;
FILE *fp_test;
int naxis=2;
int fpixel=1;
int anynull;
int i,j;
long naxes[2];
long *D;
char keyname[50];
char error_msg[80];
int status=0;
long n_pixels=1;
int i_D;
int bit_pix;
// Fits files store data in FORTRAN order, so we need to perform a transpose
transpose_array(image,dtype,n_D,D_in);
// Convert the array dimensions to a type-long array
D=(long *)SID_malloc(sizeof(long)*n_D);
for(i_D=0;i_D<n_D;i_D++)
D[i_D]=(long)(D_in[i_D]);
// Open the file
fits_open_file(&fp,filename,1,&status);
if(status){
ffgmsg(error_msg);
SID_trap_error("FITS open file: filename={%s} status=%d message={%s}",ERROR_IO_OPEN,filename,status,error_msg);
}
// Count the number of pixels
for(i_D=0;i_D<n_D;i_D++)
n_pixels*=D[i_D];
// Creeate FLOAT image
if(dtype==SID_FLOAT){
fits_create_img(fp,FLOAT_IMG,n_D,D,&status);
if(status){
ffgmsg(error_msg);
SID_trap_error("FITS create image: filename={%s} status=%d message={%s}",ERROR_IO_OPEN,filename,status,error_msg);
}
fits_write_img(fp,TFLOAT,fpixel,n_pixels,image,&status);
if(status){
ffgmsg(error_msg);
SID_trap_error("FITS write image: filename={%s} status=%d message={%s}",ERROR_IO_OPEN,filename,status,error_msg);
}
bit_pix=FLOAT_IMG;
}
// Creeate FLOAT image
else if(dtype==SID_DOUBLE){
fits_create_img(fp,DOUBLE_IMG,n_D,D,&status);
if(status){
ffgmsg(error_msg);
SID_trap_error("FITS create image: filename={%s} status=%d message={%s}",ERROR_IO_OPEN,filename,status,error_msg);
}
fits_write_img(fp,TDOUBLE,fpixel,n_pixels,image,&status);
if(status){
ffgmsg(error_msg);
SID_trap_error("FITS write image: filename={%s} status=%d message={%s}",ERROR_IO_OPEN,filename,status,error_msg);
}
bit_pix=DOUBLE_IMG;
}
// Creeate INTEGER image
else if(dtype==SID_INT){
fits_create_img(fp,LONG_IMG,n_D,D,&status);
if(status){
ffgmsg(error_msg);
SID_trap_error("FITS create image: filename={%s} status=%d message={%s}",ERROR_IO_OPEN,filename,status,error_msg);
}
fits_write_img(fp,TINT,fpixel,n_pixels,image,&status);
if(status){
ffgmsg(error_msg);
SID_trap_error("FITS write image: filename={%s} status=%d message={%s}",ERROR_IO_OPEN,filename,status,error_msg);
}
bit_pix=LONG_IMG;
}
// Throw error if the given dtype is not supported
else
SID_trap_error("Unsupported datatype in write_image_FITS",ERROR_LOGIC);
// Set extension name
if(ext_name!=NULL)
fits_write_key(fp,TSTRING,"EXTNAME",(void *)ext_name,NULL,&status);
// Close the file
fits_close_file(fp,&status);
// Fits files store data in FORTRAN order, so we need to perform a transpose
transpose_array(image,dtype,n_D,D_in);
SID_free(SID_FARG D);
return(status);
}
void
write4Dfits(int im, int unit_index, configInfo *par, imageInfo *img){
/*
Users have complained that downstream packages (produced by lazy coders >:8) will not deal with FITS cubes having less that 4 axes. Thus all LIME output images are now sent to the present function.
*/
const int numAxes=4;
double bscale,bzero,epoch,lonpole,equinox,restfreq;
int axesOrder[] = {0,1,2,3};
char ctype[numAxes][9],cunit[numAxes][9];
double crpix[numAxes],crval[numAxes];
float cdelt[numAxes];
double ru3,scale=1.0;
int velref,unitI,i;
float *row;
int px,py,ichan;
fitsfile *fptr;
int status = 0;
int naxis=numAxes, bitpix=-32;
long naxes[numAxes];
long int fpixels[numAxes],lpixels[numAxes];
char negfile[100]="! ",message[STR_LEN_0];
unsigned long ppi;
unitI = img[im].imgunits[unit_index];
row = malloc(sizeof(*row)*img[im].pxls);
naxes[axesOrder[0]] = img[im].pxls;
naxes[axesOrder[1]] = img[im].pxls;
if(img[im].doline)
naxes[axesOrder[2]] = img[im].nchan;
else
naxes[axesOrder[2]] = 1; /* In this case nchan can =3, the number of active Stokes parameters, if the dust is polarized. */
if(!img[im].doline && par->polarization)
naxes[axesOrder[3]]=4;
else
naxes[axesOrder[3]]=1;
fits_create_file(&fptr, img[im].filename, &status);
if(status!=0){
if(!silent) warning("Overwriting existing fits file ");
status=0;
strcat(negfile,img[im].filename);
fits_create_file(&fptr, negfile, &status);
}
/* Write FITS header */
fits_create_img(fptr, bitpix, naxis, naxes, &status);
epoch =2.0e3;
lonpole =1.8e2;
equinox =2.0e3;
restfreq=img[im].freq;
velref =257;
sprintf(ctype[axesOrder[0]], "RA---SIN");
cdelt[axesOrder[0]] = -1.8e2*(float)(img[im].imgres/M_PI);
crpix[axesOrder[0]] = ((double)img[im].pxls)/2.0 + 0.5;
crval[axesOrder[0]] = 0.0e0;
sprintf(cunit[axesOrder[0]], "DEG ");
sprintf(ctype[axesOrder[1]], "DEC--SIN");
cdelt[axesOrder[1]] = 1.8e2*(float)(img[im].imgres/M_PI);
crpix[axesOrder[1]] = ((double)img[im].pxls)/2.0 + 0.5;
crval[axesOrder[1]] = 0.0e0;
sprintf(cunit[axesOrder[1]], "DEG ");
sprintf(ctype[axesOrder[2]], "VELO-LSR");
if(img[im].doline)
cdelt[axesOrder[2]] = (float)img[im].velres;
else
cdelt[axesOrder[2]] = 1.0;
crpix[axesOrder[2]] = (double) (naxes[axesOrder[2]]-1)/2.+1;
crval[axesOrder[2]] = 0.0e0;
sprintf(cunit[axesOrder[2]], "M/S ");
sprintf(ctype[axesOrder[3]], "STOKES ");
cdelt[axesOrder[3]] = 1.0;
crpix[axesOrder[3]] = (double) (naxes[axesOrder[3]]-1)/2.+1;
crval[axesOrder[3]] = 1.0e0;
sprintf(cunit[axesOrder[3]], " ");
bscale =1.0e0;
bzero =0.0e0;
fits_write_key(fptr, TSTRING, "OBJECT ", &"LIMEMDL ", "", &status);
fits_write_key(fptr, TDOUBLE, "EPOCH ", &epoch, "", &status);
fits_write_key(fptr, TDOUBLE, "LONPOLE ", &lonpole, "", &status);
fits_write_key(fptr, TDOUBLE, "EQUINOX ", &equinox, "", &status);
fits_write_key(fptr, TSTRING, "SPECSYS ", &"LSRK ", "", &status);
fits_write_key(fptr, TDOUBLE, "RESTFREQ", &restfreq, "", &status);
fits_write_key(fptr, TINT, "VELREF ", &velref, "", &status);
for(i=0;i<numAxes;i++)
writeWCS(fptr, i, axesOrder, cdelt, crpix, crval, ctype, cunit);
fits_write_key(fptr, TDOUBLE, "BSCALE ", &bscale, "", &status);
fits_write_key(fptr, TDOUBLE, "BZERO ", &bzero, "", &status);
if(unitI==0) fits_write_key(fptr, TSTRING, "BUNIT", &"K ", "", &status);
if(unitI==1) fits_write_key(fptr, TSTRING, "BUNIT", &"JY/PIXEL", "", &status);
if(unitI==2) fits_write_key(fptr, TSTRING, "BUNIT", &"WM2HZSR ", "", &status);
if(unitI==3) fits_write_key(fptr, TSTRING, "BUNIT", &"Lsun/PX ", "", &status);
if(unitI==4) fits_write_key(fptr, TSTRING, "BUNIT", &" ", "", &status);
if( unitI==0)
scale=0.5*(CLIGHT/img[im].freq)*(CLIGHT/img[im].freq)/KBOLTZ;
else if(unitI==1)
scale=1e26*img[im].imgres*img[im].imgres;
else if(unitI==2)
scale=1.0;
else if(unitI==3) {
ru3 = img[im].distance/1.975e13;
scale=4.*M_PI*ru3*ru3*img[im].freq*img[im].imgres*img[im].imgres;
}
else if(unitI!=4) {
if(!silent) bail_out("Image unit number invalid");
exit(0);
}
/* Write FITS data */
if(img[im].doline){
for(ichan=0;ichan<img[im].nchan;ichan++){
for(py=0;py<img[im].pxls;py++){
for(px=0;px<img[im].pxls;px++){
ppi = py*img[im].pxls + px;
if(unitI>-1 && unitI<4)
row[px]=(float) img[im].pixel[ppi].intense[ichan]*scale;
else if(unitI==4)
row[px]=(float) img[im].pixel[ppi].tau[ichan];
else {
if(!silent) bail_out("Image unit number invalid");
exit(0);
}
if (fabs(row[px])<IMG_MIN_ALLOWED) row[px]=IMG_MIN_ALLOWED;
}
fpixels[axesOrder[0]] = 1;
fpixels[axesOrder[1]] = py+1;
fpixels[axesOrder[2]] = ichan+1;
fpixels[axesOrder[3]] = 1;
lpixels[axesOrder[0]] = img[im].pxls;
lpixels[axesOrder[1]] = py+1;
lpixels[axesOrder[2]] = ichan+1;
lpixels[axesOrder[3]] = 1;
fits_write_subset(fptr, TFLOAT, fpixels, lpixels, row, &status);
}
}
}else{
for(ichan=0;ichan<img[im].nchan;ichan++){
for(py=0;py<img[im].pxls;py++){
for(px=0;px<img[im].pxls;px++){
ppi = py*img[im].pxls + px;
if(unitI>-1 && unitI<4)
row[px]=(float) img[im].pixel[ppi].intense[ichan]*scale;
else if(unitI==4)
row[px]=(float) img[im].pixel[ppi].tau[ichan];
else {
if(!silent) bail_out("Image unit number invalid");
exit(0);
}
if (fabs(row[px])<IMG_MIN_ALLOWED) row[px]=IMG_MIN_ALLOWED;
}
fpixels[axesOrder[0]] = 1;
fpixels[axesOrder[1]] = py+1;
fpixels[axesOrder[3]] = ichan+1;
fpixels[axesOrder[2]] = 1;
lpixels[axesOrder[0]] = img[im].pxls;
lpixels[axesOrder[1]] = py+1;
lpixels[axesOrder[3]] = ichan+1;
lpixels[axesOrder[2]] = 1;
fits_write_subset(fptr, TFLOAT, fpixels, lpixels, row, &status);
}
}
if(par->polarization){ /* ichan should have run from 0 to 2 in this case. Stokes I, Q and U but no V. Load zeros into the last pol channel: */
if(img[im].nchan!=3){
if(!silent){
sprintf(message, "%d pol channels found but %d expected.", img[im].nchan, 3);
bail_out(message);
}
exit(1);
}
ichan = 3;
for(px=0;px<img[im].pxls;px++)
row[px] = IMG_MIN_ALLOWED;
for(py=0;py<img[im].pxls;py++){
fpixels[axesOrder[0]] = 1;
fpixels[axesOrder[1]] = py+1;
fpixels[axesOrder[3]] = ichan+1;
fpixels[axesOrder[2]] = 1;
lpixels[axesOrder[0]] = img[im].pxls;
lpixels[axesOrder[1]] = py+1;
lpixels[axesOrder[3]] = ichan+1;
lpixels[axesOrder[2]] = 1;
fits_write_subset(fptr, TFLOAT, fpixels, lpixels, row, &status);
}
}
}
fits_close_file(fptr, &status);
free(row);
}
int HPXhdr(fitsfile *fptr, struct healpix *hpxdat)
{
char comment[64], cval[16], *ctype1, *ctype2, *descr1, *descr2, *pcode;
int status;
float cos45, crpix1, crpix2, crval1, crval2, lonpole;
double cdelt1, cdelt2;
status = 0;
fits_update_key_log(fptr, "EXTEND", 0,
"No FITS extensions are present", &status);
fits_write_date(fptr, &status);
/* Set pixel transformation parameters. */
if (hpxdat->layout == 0) {
crpix1 = (5 * hpxdat->nside + 1) / 2.0f;
} else {
crpix1 = (4 * hpxdat->nside + 1) / 2.0f;
}
crpix2 = crpix1;
fits_write_key(fptr, TFLOAT, "CRPIX1", &crpix1,
"Coordinate reference pixel", &status);
fits_write_key(fptr, TFLOAT, "CRPIX2", &crpix2,
"Coordinate reference pixel", &status);
cos45 = (float)sqrt(2.0) / 2.0f;
if (hpxdat->layout == 0) {
fits_write_key_flt(fptr, "PC1_1", cos45, -8,
"Transformation matrix element", &status);
fits_write_key_flt(fptr, "PC1_2", cos45, -8,
"Transformation matrix element", &status);
fits_write_key_flt(fptr, "PC2_1", -cos45, -8,
"Transformation matrix element", &status);
fits_write_key_flt(fptr, "PC2_2", cos45, -8,
"Transformation matrix element", &status);
}
cdelt1 = -90.0 / hpxdat->nside / sqrt(2.0);
cdelt2 = -cdelt1;
fits_write_key_dbl(fptr, "CDELT1", cdelt1, -8,
"[deg] Coordinate increment", &status);
fits_write_key_dbl(fptr, "CDELT2", cdelt2, -8,
"[deg] Coordinate increment", &status);
/* Celestial transformation parameters. */
if (hpxdat->layout == 0) {
pcode = "HPX";
} else {
pcode = "XPH";
}
if (hpxdat->crdsys == 'G') {
/* Galactic. */
ctype1 = "GLON";
ctype2 = "GLAT";
descr1 = "Galactic longitude";
descr2 = "Galactic latitude";
} else if (hpxdat->crdsys == 'E') {
/* Ecliptic, who-knows-what. */
ctype1 = "ELON";
ctype2 = "ELAT";
descr1 = "Ecliptic longitude";
descr2 = "Ecliptic latitude";
} else if (hpxdat->crdsys == 'Q') {
/* Equatorial, who-knows-what. */
ctype1 = "RA--";
ctype2 = "DEC-";
descr1 = "Right ascension";
descr2 = "Declination";
} else {
/* Unknown. */
ctype1 = "XLON";
ctype2 = "XLAT";
descr1 = "Longitude";
descr2 = " Latitude";
}
sprintf(cval, "%s-%s", ctype1, pcode);
sprintf(comment, "%s in an %s projection", descr1, pcode);
fits_write_key_str(fptr, "CTYPE1", cval, comment, &status);
sprintf(cval, "%s-%s", ctype2, pcode);
sprintf(comment, "%s in an %s projection", descr2, pcode);
fits_write_key_str(fptr, "CTYPE2", cval, comment, &status);
crval1 = 0.0f + 90.0f * hpxdat->quad;
if (hpxdat->layout == 0) {
crval2 = 0.0f;
} else if (hpxdat->layout == 1) {
crval1 += 180.0f;
crval2 = 90.0f;
} else {
crval1 += 180.0f;
crval2 = -90.0f;
}
if (360.0f < crval1) crval1 -= 360.0f;
sprintf(comment, "[deg] %s at the reference point", descr1);
fits_write_key(fptr, TFLOAT, "CRVAL1", &crval1, comment, &status);
sprintf(comment, "[deg] %s at the reference point", descr2);
fits_write_key(fptr, TFLOAT, "CRVAL2", &crval2, comment, &status);
if (hpxdat->layout) {
lonpole = 180.0f;
sprintf(comment, "[deg] Native longitude of the celestial pole");
fits_write_key(fptr, TFLOAT, "LONPOLE", &lonpole, comment, &status);
}
if (hpxdat->layout == 0) {
fits_write_key_lng(fptr, "PV2_1", (LONGLONG)4,
"HPX H parameter (longitude)", &status);
fits_write_key_lng(fptr, "PV2_2", (LONGLONG)3,
"HPX K parameter (latitude)", &status);
}
/* Commentary. */
fits_write_record(fptr, " ", &status);
if (hpxdat->layout == 0) {
fits_write_comment(fptr,
"Celestial map with FITS-standard HPX coordinate system generated by",
&status);
} else {
fits_write_comment(fptr,
"Celestial map with XPH coordinate system (polar HPX) generated by",
&status);
}
fits_write_comment(fptr,
"'HPXcvt' which reorganises HEALPix data without interpolation as",
&status);
fits_write_comment(fptr,
"described in \"Mapping on the HEALPix grid\" by Mark Calabretta and",
&status);
fits_write_comment(fptr,
"Boud Roukema. See http://www.atnf.csiro.au/people/Mark.Calabretta",
&status);
return status;
}
int ngp_read_xtension(fitsfile *ff, int parent_hn, int simple_mode)
{ int r, exflg, l, my_hn, tmp0, incrementor_index, i, j;
int ngph_dim, ngph_bitpix, ngph_node_type, my_version;
char incrementor_name[NGP_MAX_STRING], ngph_ctmp;
char *ngph_extname = 0;
long ngph_size[NGP_MAX_ARRAY_DIM];
NGP_HDU ngph;
long lv;
incrementor_name[0] = 0; /* signal no keyword+'#' found yet */
incrementor_index = 0;
if (NGP_OK != (r = ngp_hdu_init(&ngph))) return(r);
if (NGP_OK != (r = ngp_read_line(0))) return(r); /* EOF always means error here */
switch (NGP_XTENSION_SIMPLE & simple_mode)
{
case 0: if (NGP_TOKEN_XTENSION != ngp_keyidx) return(NGP_TOKEN_NOT_EXPECT);
break;
default: if (NGP_TOKEN_SIMPLE != ngp_keyidx) return(NGP_TOKEN_NOT_EXPECT);
break;
}
if (NGP_OK != (r = ngp_hdu_insert_token(&ngph, &ngp_linkey))) return(r);
for (;;)
{ if (NGP_OK != (r = ngp_read_line(0))) return(r); /* EOF always means error here */
exflg = 0;
switch (ngp_keyidx)
{
case NGP_TOKEN_SIMPLE:
r = NGP_TOKEN_NOT_EXPECT;
break;
case NGP_TOKEN_END:
case NGP_TOKEN_XTENSION:
case NGP_TOKEN_GROUP:
r = ngp_unread_line(); /* WARNING - not break here .... */
case NGP_TOKEN_EOF:
exflg = 1;
break;
default: l = strlen(ngp_linkey.name);
if ((l >= 2) && (l <= 6))
{ if ('#' == ngp_linkey.name[l - 1])
{ if (0 == incrementor_name[0])
{ memcpy(incrementor_name, ngp_linkey.name, l - 1);
incrementor_name[l - 1] = 0;
}
if (((l - 1) == (int)strlen(incrementor_name)) && (0 == memcmp(incrementor_name, ngp_linkey.name, l - 1)))
{ incrementor_index++;
}
sprintf(ngp_linkey.name + l - 1, "%d", incrementor_index);
}
}
r = ngp_hdu_insert_token(&ngph, &ngp_linkey);
break;
}
if ((NGP_OK != r) || exflg) break;
}
if (NGP_OK == r)
{ /* we should scan keywords, and calculate HDU's */
/* structure ourselves .... */
ngph_node_type = NGP_NODE_INVALID; /* init variables */
ngph_bitpix = 0;
ngph_extname = NULL;
for (i=0; i<NGP_MAX_ARRAY_DIM; i++) ngph_size[i] = 0;
ngph_dim = 0;
for (i=0; i<ngph.tokcnt; i++)
{ if (!strcmp("XTENSION", ngph.tok[i].name))
{ if (NGP_TTYPE_STRING == ngph.tok[i].type)
{ if (!ngp_strcasencmp("BINTABLE", ngph.tok[i].value.s,8)) ngph_node_type = NGP_NODE_BTABLE;
if (!ngp_strcasencmp("TABLE", ngph.tok[i].value.s,5)) ngph_node_type = NGP_NODE_ATABLE;
if (!ngp_strcasencmp("IMAGE", ngph.tok[i].value.s,5)) ngph_node_type = NGP_NODE_IMAGE;
}
}
else if (!strcmp("SIMPLE", ngph.tok[i].name))
{ if (NGP_TTYPE_BOOL == ngph.tok[i].type)
{ if (ngph.tok[i].value.b) ngph_node_type = NGP_NODE_IMAGE;
}
}
else if (!strcmp("BITPIX", ngph.tok[i].name))
{ if (NGP_TTYPE_INT == ngph.tok[i].type) ngph_bitpix = ngph.tok[i].value.i;
}
else if (!strcmp("NAXIS", ngph.tok[i].name))
{ if (NGP_TTYPE_INT == ngph.tok[i].type) ngph_dim = ngph.tok[i].value.i;
}
else if (!strcmp("EXTNAME", ngph.tok[i].name)) /* assign EXTNAME, I hope struct does not move */
{ if (NGP_TTYPE_STRING == ngph.tok[i].type) ngph_extname = ngph.tok[i].value.s;
}
else if (1 == sscanf(ngph.tok[i].name, "NAXIS%d%c", &j, &ngph_ctmp))
{ if (NGP_TTYPE_INT == ngph.tok[i].type)
if ((j>=1) && (j <= NGP_MAX_ARRAY_DIM))
{ ngph_size[j - 1] = ngph.tok[i].value.i;
}
}
}
switch (ngph_node_type)
{ case NGP_NODE_IMAGE:
if (NGP_XTENSION_FIRST == ((NGP_XTENSION_FIRST | NGP_XTENSION_SIMPLE) & simple_mode))
{ /* if caller signals that this is 1st HDU in file */
/* and it is IMAGE defined with XTENSION, then we */
/* need create dummy Primary HDU */
fits_create_img(ff, 16, 0, NULL, &r);
}
/* create image */
fits_create_img(ff, ngph_bitpix, ngph_dim, ngph_size, &r);
/* update keywords */
if (NGP_OK == r) r = ngp_keyword_all_write(&ngph, ff, NGP_NON_SYSTEM_ONLY);
break;
case NGP_NODE_ATABLE:
case NGP_NODE_BTABLE:
/* create table, 0 rows and 0 columns for the moment */
fits_create_tbl(ff, ((NGP_NODE_ATABLE == ngph_node_type)
? ASCII_TBL : BINARY_TBL),
0, 0, NULL, NULL, NULL, NULL, &r);
if (NGP_OK != r) break;
/* add columns ... */
r = ngp_append_columns(ff, &ngph, 0);
if (NGP_OK != r) break;
/* add remaining keywords */
r = ngp_keyword_all_write(&ngph, ff, NGP_NON_SYSTEM_ONLY);
if (NGP_OK != r) break;
/* if requested add rows */
if (ngph_size[1] > 0) fits_insert_rows(ff, 0, ngph_size[1], &r);
break;
default: r = NGP_BAD_ARG;
break;
}
}
if ((NGP_OK == r) && (NULL != ngph_extname))
{ r = ngp_get_extver(ngph_extname, &my_version); /* write correct ext version number */
lv = my_version; /* bugfix - 22-Jan-99, BO - nonalignment of OSF/Alpha */
fits_write_key(ff, TLONG, "EXTVER", &lv, "auto assigned by template parser", &r);
}
if (NGP_OK == r)
{ if (parent_hn > 0)
{ fits_get_hdu_num(ff, &my_hn);
fits_movabs_hdu(ff, parent_hn, &tmp0, &r); /* link us to parent */
fits_add_group_member(ff, NULL, my_hn, &r);
fits_movabs_hdu(ff, my_hn, &tmp0, &r);
if (NGP_OK != r) return(r);
}
}
if (NGP_OK != r) /* in case of error - delete hdu */
{ tmp0 = 0;
fits_delete_hdu(ff, NULL, &tmp0);
}
ngp_hdu_clear(&ngph);
return(r);
}
void GuiderOneStar::SaveStarFITS()
{
double StarX = m_star.X;
double StarY = m_star.Y;
usImage *pImage = CurrentImage();
usImage tmpimg;
tmpimg.Init(60,60);
int start_x = ROUND(StarX)-30;
int start_y = ROUND(StarY)-30;
if ((start_x + 60) > pImage->Size.GetWidth())
start_x = pImage->Size.GetWidth() - 60;
if ((start_y + 60) > pImage->Size.GetHeight())
start_y = pImage->Size.GetHeight() - 60;
int x,y, width;
width = pImage->Size.GetWidth();
unsigned short *usptr = tmpimg.ImageData;
for (y=0; y<60; y++)
for (x=0; x<60; x++, usptr++)
*usptr = *(pImage->ImageData + (y+start_y)*width + (x+start_x));
wxString fname = Debug.GetLogDir() + PATHSEPSTR + "PHD_GuideStar" + wxDateTime::Now().Format(_T("_%j_%H%M%S")) + ".fit";
fitsfile *fptr; // FITS file pointer
int status = 0; // CFITSIO status value MUST be initialized to zero!
long fpixel[3] = {1,1,1};
long fsize[3];
char keyname[9]; // was 9
char keycomment[100];
char keystring[100];
int output_format=USHORT_IMG;
fsize[0] = 60;
fsize[1] = 60;
fsize[2] = 0;
PHD_fits_create_file(&fptr, fname, false, &status);
if (!status)
{
fits_create_img(fptr,output_format, 2, fsize, &status);
time_t now;
struct tm *timestruct;
time(&now);
timestruct=gmtime(&now);
sprintf(keyname,"DATE");
sprintf(keycomment,"UTC date that FITS file was created");
sprintf(keystring,"%.4d-%.2d-%.2d %.2d:%.2d:%.2d",timestruct->tm_year+1900,timestruct->tm_mon+1,timestruct->tm_mday,timestruct->tm_hour,timestruct->tm_min,timestruct->tm_sec);
if (!status) fits_write_key(fptr, TSTRING, keyname, keystring, keycomment, &status);
sprintf(keyname,"DATE-OBS");
sprintf(keycomment,"YYYY-MM-DDThh:mm:ss observation start, UT");
sprintf(keystring,"%s", (const char *) pImage->GetImgStartTime().c_str());
if (!status) fits_write_key(fptr, TSTRING, keyname, keystring, keycomment, &status);
sprintf(keyname,"EXPOSURE");
sprintf(keycomment,"Exposure time [s]");
float dur = (float) pImage->ImgExpDur / 1000.0;
if (!status) fits_write_key(fptr, TFLOAT, keyname, &dur, keycomment, &status);
unsigned int tmp = 1;
sprintf(keyname,"XBINNING");
sprintf(keycomment,"Camera binning mode");
fits_write_key(fptr, TUINT, keyname, &tmp, keycomment, &status);
sprintf(keyname,"YBINNING");
sprintf(keycomment,"Camera binning mode");
fits_write_key(fptr, TUINT, keyname, &tmp, keycomment, &status);
sprintf(keyname,"XORGSUB");
sprintf(keycomment,"Subframe x position in binned pixels");
tmp = start_x;
fits_write_key(fptr, TINT, keyname, &tmp, keycomment, &status);
sprintf(keyname,"YORGSUB");
sprintf(keycomment,"Subframe y position in binned pixels");
tmp = start_y;
fits_write_key(fptr, TINT, keyname, &tmp, keycomment, &status);
if (!status) fits_write_pix(fptr,TUSHORT,fpixel,tmpimg.NPixels,tmpimg.ImageData,&status);
}
PHD_fits_close_file(fptr);
}
bool Fits2D::writeKeywords(fitsfile *fptr){
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% FITS 2D Keywords template %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1. SIMPLE = T / file does conform to FITS standard
2. BITPIX = 8 / number of bits per pixel
3. NAXIS = 2 / number of data axes
4. NAXIS1 = 1280 / length of data axis 1
5. NAXIS2 = 960 / length of data axis 2
6. EXTEND = T / FITS dataset may contain extensions
7. FILENAME = 'stationOrsay_YYYYMMJJ_HHMMSS_UT.fits' / name of the fits file
8. DATE = 'YYYY-MM-JJT HH:MM:SS.SS' / date of the creation of the fits file
9. DATE-OBS = 'YYYY-MM-JJT HH:MM:SS.SS' / acquisition date of the first frame
10. OBS_MODE = 'SINGLE' / observation method used to get this fits file 'SINGLE' 'SUM' 'AVERAGE' ('MEDIAN')
11. ELAPTIME = 60 / end observation date - start observation date (sec.)
12. EXPOSURE = 0.033 / frame exp (sec). 999999 if different exposure.
13. ONTIME = 0.033 / total integration time, sum of each frame exp (sec)
14. FILTER = "NONE"
15. TELESCOP = "<Code station>" / station <stationName>
16. OBSERVER = "<responsable camera>"
17. INSTRUME = 'FRIPON-CAM'
18. CAMERA = 'BASLER 1300gm'
19. FOCAL = 1.25
20. APERTURE = 2.0
21. SITELONG = 2.1794397 / geodetic WGS84 longitude (DD)
22. SITELAT = 48.7063906 / geodetic WGS84 latitude (DD)
23. SITEELEV = 90 / geodetic WGS84 elevation (m)
24. XPIXEL = 3.75
25. YPIXEL = 3.75
26. GAINDB = 400 / detector gain
27. SATURATE = 4095 / saturation value
28. PROGRAM = 'FreeTure v0.1' / name of the acquisition software
29. CREATOR = 'FRIPON TEAM' / http://fripon.org
30. BZERO = 0
31. BSCALE = 1
32. RADESYS = 'ICRS'
33. TIMESYS = 'UTC'
34. EQUINOX = 2.000000000000E+03 / equinox of equatorial coordinates
35. CTYPE1 = 'RA---ARC' / projection and reference system
36. CTYPE2 = 'DEC--ARC' / projection and reference system
37. TIMEUNIT = 's '
38. CD1_1 = 0.0 / deg/px
39. CD1_2 = 0.17 / deg/px
40. CD2_1 = 0.17 / deg/pix
41. CD2_2 = 0.0 / deg/pix
42. CD3_3 = 30 / fps
43. CRPIX1 = 640
44. CRPIX2 = 480
45. CRVAL1 = / Sidereal time (decimal degree)
46. CRVAL2 = / geodetic WGS84 latitude (DD)
47. K1 =
48. K2 =
*/
int status = 0;
// DELETE DEFAULT COMMENTS.
if(ffdkey(fptr, "COMMENT", &status))
printerror( status );
if(ffdkey(fptr, "COMMENT", &status))
printerror( status );
/// 7. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% FILENAME %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * filename = new char[kFILENAME.length()+1];
strcpy(filename,kFILENAME.c_str());
char * cfilename = new char[cFILENAME.length()+1];
strcpy(cfilename,cFILENAME.c_str());
if(fits_write_key(fptr, TSTRING, "FILENAME", filename, cfilename, &status)){
delete filename;
delete cfilename;
printerror(status, "Error fits_write_key(FILENAME)");
return false;
}
delete cfilename;
delete filename;
/// 8. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% DATE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * date = new char[kDATE.length()+1];
strcpy(date,kDATE.c_str());
char * cdate = new char[cDATE.length()+1];
strcpy(cdate,cDATE.c_str());
if(fits_write_key(fptr,TSTRING,"DATE",date,cdate,&status)){
delete date;
delete cdate;
printerror(status, "Error fits_write_key(DATE)");
return false;
}
delete cdate;
delete date;
/// 9. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% DATE-OBS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * dateobs = new char[kDATEOBS.length()+1];
strcpy(dateobs,kDATEOBS.c_str());
char * cdateobs = new char[cDATEOBS.length()+1];
strcpy(cdateobs,cDATEOBS.c_str());
if(fits_write_key(fptr,TSTRING,"DATE-OBS",dateobs,cdateobs,&status)){
delete dateobs;
delete cdateobs;
printerror(status, "Error fits_write_key(DATE-OBS)");
return false;
}
delete cdateobs;
delete dateobs;
/// 10. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% OBS_MODE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * cobsmode = new char[cOBSMODE.length()+1];
strcpy(cobsmode,cOBSMODE.c_str());
char * obsmode = new char[kOBSMODE.length()+1];
strcpy(obsmode,kOBSMODE.c_str());
if(fits_write_key(fptr,TSTRING,"OBS_MODE",obsmode,cobsmode,&status)){
delete cobsmode;
delete obsmode;
printerror(status, "Error fits_write_key(OBS_MODE)");
return false;
}
delete cobsmode;
delete obsmode;
/// 11. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% ELAPTIME %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * celaptime = new char[cELAPTIME.length()+1];
strcpy(celaptime,cELAPTIME.c_str());
if(fits_write_key(fptr,TDOUBLE,"ELAPTIME",&kELAPTIME,celaptime,&status)){
delete celaptime;
printerror(status, "Error fits_write_key(ELAPTIME)");
return false;
}
delete celaptime;
/// 12. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% EXPOSURE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * ceposure = new char[cEXPOSURE.length()+1];
strcpy(ceposure,cEXPOSURE.c_str());
if(fits_write_key(fptr,TDOUBLE,"EXPOSURE",&kEXPOSURE,ceposure,&status)){
delete ceposure;
printerror(status, "Error fits_write_key(EXPOSURE)");
return false;
}
delete ceposure;
/// 13. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% ONTIME %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * contime = new char[cONTIME.length()+1];
strcpy(contime,cONTIME.c_str());
if(fits_write_key(fptr,TDOUBLE,"ONTIME",&kONTIME,contime,&status)){
delete contime;
printerror(status, "Error fits_write_key(ONTIME)");
return false;
}
delete contime;
/// 14. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% FILTER %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * cfilter = new char[cFILTER.length()+1];
strcpy(cfilter,cFILTER.c_str());
char * f = new char[kFILTER.length()+1];
strcpy(f,kFILTER.c_str());
if(fits_write_key(fptr,TSTRING,"FILTER",f,cfilter,&status)){
delete cfilter;
delete f;
printerror(status, "Error fits_write_key(FILTER)");
return false;
}
delete cfilter;
delete f;
/// 15. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% TELESCOP %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * ctelescop = new char[cTELESCOP.length()+1];
strcpy(ctelescop,cTELESCOP.c_str());
char * t = new char[kTELESCOP.length()+1];
strcpy(t,kTELESCOP.c_str());
if(fits_write_key(fptr,TSTRING,"TELESCOP",t,ctelescop,&status)){
delete ctelescop;
delete t;
printerror(status, "Error fits_write_key(TELESCOP)");
return false;
}
delete ctelescop;
delete t;
/// 16. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% OBSERVER %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * cobserver = new char[cOBSERVER.length()+1];
strcpy(cobserver,cOBSERVER.c_str());
char * o = new char[kOBSERVER.length()+1];
strcpy(o,kOBSERVER.c_str());
if(fits_write_key(fptr,TSTRING,"OBSERVER",o,cobserver,&status)){
delete cobserver;
delete o;
printerror(status, "Error fits_write_key(OBSERVER)");
return false;
}
delete cobserver;
delete o;
/// 17. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% INSTRUME %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * cinstrume = new char[cINSTRUME.length()+1];
strcpy(cinstrume,cINSTRUME.c_str());
char * i = new char[kINSTRUME.length()+1];
strcpy(i,kINSTRUME.c_str());
if(fits_write_key(fptr,TSTRING,"INSTRUME",i,cinstrume,&status)){
delete cinstrume;
delete i;
printerror(status, "Error fits_write_key(OBSERVER)");
return false;
}
delete cinstrume;
delete i;
/// 18. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% CAMERA %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * ccamera = new char[cCAMERA.length()+1];
strcpy(ccamera,cCAMERA.c_str());
char * cam = new char[kCAMERA.length()+1];
strcpy(cam,kCAMERA.c_str());
if(fits_write_key(fptr,TSTRING,"CAMERA",cam,ccamera,&status)){
delete ccamera;
delete cam;
printerror(status, "Error fits_write_key(CAMERA)");
return false;
}
delete ccamera;
delete cam;
/// 19. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% FOCAL %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * cfocal = new char[cFOCAL.length()+1];
strcpy(cfocal,cFOCAL.c_str());
if(fits_write_key(fptr,TDOUBLE,"FOCAL",&kFOCAL,cfocal,&status)){
delete cfocal;
printerror(status, "Error fits_write_key(FOCAL)");
return false;
}
delete cfocal;
/// 20. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% APERTURE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * caperture = new char[cAPERTURE.length()+1];
strcpy(caperture,cAPERTURE.c_str());
if(fits_write_key(fptr,TDOUBLE,"APERTURE",&kAPERTURE,caperture,&status)){
delete caperture;
printerror(status, "Error fits_write_key(APERTURE)");
return false;
}
delete caperture;
/// 21. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% SITELONG %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * csitelong = new char[cSITELONG.length()+1];
strcpy(csitelong,cSITELONG.c_str());
if(fits_write_key(fptr,TDOUBLE,"SITELONG",&kSITELONG,csitelong,&status)){
delete csitelong;
printerror(status, "Error fits_write_key(APERTURE)");
return false;
}
delete csitelong;
/// 22. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% SITELAT %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * csitelat = new char[cSITELAT.length()+1];
strcpy(csitelat,cSITELAT.c_str());
if(fits_write_key(fptr,TDOUBLE,"SITELAT",&kSITELAT,csitelat,&status)){
delete csitelat;
printerror(status, "Error fits_write_key(SITELAT)");
return false;
}
delete csitelat;
/// 23. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% SITEELEV %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * csiteelev = new char[cSITEELEV.length()+1];
strcpy(csiteelev,cSITEELEV.c_str());
if(fits_write_key(fptr,TDOUBLE,"SITEELEV",&kSITEELEV,csiteelev,&status)){
delete csiteelev;
printerror(status, "Error fits_write_key(SITEELEV)");
return false;
}
delete csiteelev;
/// 24. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% XPIXEL %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * cxpixel = new char[cXPIXEL.length()+1];
strcpy(cxpixel,cXPIXEL.c_str());
if(fits_write_key(fptr,TDOUBLE,"XPIXEL",&kXPIXEL,cxpixel,&status)){
delete cxpixel;
printerror(status, "Error fits_write_key(XPIXEL)");
return false;
}
delete cxpixel;
/// 25. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% YPIXEL %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * cypixel = new char[cYPIXEL.length()+1];
strcpy(cypixel,cYPIXEL.c_str());
if(fits_write_key(fptr,TDOUBLE,"YPIXEL",&kYPIXEL,cypixel,&status)){
delete cypixel;
printerror(status, "Error fits_write_key(YPIXEL)");
return false;
}
delete cypixel;
/// 26. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% GAINDB %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * cgaindb = new char[cGAINDB.length()+1];
strcpy(cgaindb,cGAINDB.c_str());
if(fits_write_key(fptr,TINT,"GAINDB",&kGAINDB,cgaindb,&status)){
delete cgaindb;
printerror(status, "Error fits_write_key(GAINDB)");
return false;
}
delete cgaindb;
/// 27. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% SATURATE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * csaturate = new char[cSATURATE.length()+1];
strcpy(csaturate,cSATURATE.c_str());
if(fits_write_key(fptr,TDOUBLE,"SATURATE",&kSATURATE,csaturate,&status)){
delete csaturate;
printerror(status, "Error fits_write_key(SATURATE)");
return false;
}
delete csaturate;
/// 28. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% PROGRAM %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * cprograme = new char[cPROGRAM.length()+1];
strcpy(cprograme,cPROGRAM.c_str());
char * p = new char[kPROGRAM.length()+1];
strcpy(p,kPROGRAM.c_str());
if(fits_write_key(fptr,TSTRING,"PROGRAM",p,cprograme,&status)){
delete cprograme;
delete p;
printerror(status, "Error fits_write_key(PROGRAM)");
return false;
}
delete cprograme;
delete p;
/// 29. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% CREATOR %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * ccreator = new char[cCREATOR.length()+1];
strcpy(ccreator,cCREATOR.c_str());
char * c = new char[kCREATOR.length()+1];
strcpy(c,kCREATOR.c_str());
if(fits_write_key(fptr,TSTRING,"CREATOR",c,ccreator,&status)){
delete ccreator;
delete c;
printerror(status, "Error fits_write_key(CREATOR)");
return false;
}
delete ccreator;
delete c;
/// 30. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% BZERO %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * cbzero = new char[cBZERO.length()+1];
strcpy(cbzero,cBZERO.c_str());
if(fits_write_key(fptr,TDOUBLE,"BZERO",&kBZERO,cbzero,&status)){
delete cbzero;
printerror(status, "Error fits_write_key(BZERO)");
return false;
}
delete cbzero;
/// 31. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% BSCALE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * cbscale = new char[cBSCALE.length()+1];
strcpy(cbscale,cBSCALE.c_str());
if(fits_write_key(fptr,TDOUBLE,"BSCALE",&kBSCALE,cbscale,&status)){
delete cbscale;
printerror(status, "Error fits_write_key(BSCALE)");
return false;
}
delete cbscale;
/// 32. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% RADESYS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * radesys = new char[kRADESYS.length()+1];
strcpy(radesys,kRADESYS.c_str());
char * cradesys = new char[cRADESYS.length()+1];
strcpy(cradesys,cRADESYS.c_str());
if(fits_write_key(fptr,TSTRING,"RADESYS",radesys,cradesys,&status)){
delete cradesys;
delete radesys;
printerror(status, "Error fits_write_key(RADESYS)");
return false;
}
delete cradesys;
delete radesys;
/// 33. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% TIMESYS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * ctimesys = new char[cTIMESYS.length()+1];
strcpy(ctimesys,cTIMESYS.c_str());
char * timesys = new char[kTIMESYS.length()+1];
strcpy(timesys,kTIMESYS.c_str());
if(fits_write_key(fptr,TSTRING,"TIMESYS",timesys,ctimesys,&status)){
delete ctimesys;
delete timesys;
printerror(status, "Error fits_write_key(TIMESYS)");
return false;
}
delete ctimesys;
delete timesys;
/// 34. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% EQUINOX %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * cequinox = new char[cEQUINOX.length()+1];
strcpy(cequinox,cEQUINOX.c_str());
if(fits_write_key(fptr,TDOUBLE,"EQUINOX",&kEQUINOX,cequinox,&status)){
delete cequinox;
printerror(status, "Error fits_write_key(EQUINOX)");
return false;
}
delete cequinox;
/// 35. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% CTYPE1 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * ctype1 = new char[cCTYPE1.length()+1];
strcpy(ctype1,cCTYPE1.c_str());
char * ktype1 = new char[kCTYPE1.length()+1];
strcpy(ktype1,kCTYPE1.c_str());
if(fits_write_key(fptr,TSTRING,"CTYPE1",ktype1,ctype1,&status)){
delete ctype1;
delete ktype1;
printerror(status, "Error fits_write_key(CTYPE1)");
return false;
}
delete ctype1;
delete ktype1;
/// 36. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% CTYPE2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * ctype2 = new char[cCTYPE2.length()+1];
strcpy(ctype2,cCTYPE2.c_str());
char * ktype2 = new char[kCTYPE2.length()+1];
strcpy(ktype2,kCTYPE2.c_str());
if(fits_write_key(fptr,TSTRING,"CTYPE2",ktype2,ctype2,&status)){
delete ctype2;
delete ktype2;
printerror(status, "Error fits_write_key(CTYPE2)");
return false;
}
delete ctype2;
delete ktype2;
/// 37. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% TIMEUNIT %%%%%%%%%%%%%%%%%%%%%%%%%%%
char * ctimeunit = new char[cTIMEUNIT.length()+1];
strcpy(ctimeunit,cTIMEUNIT.c_str());
char * ktimeunit = new char[kTIMEUNIT.length()+1];
strcpy(ktimeunit,kTIMEUNIT.c_str());
if(fits_write_key(fptr,TSTRING,"TIMEUNIT",ktimeunit,ctimeunit,&status)){
delete ctimeunit;
delete ktimeunit;
printerror(status, "Error fits_write_key(TIMEUNIT)");
return false;
}
delete ctimeunit;
delete ktimeunit;
/// 38. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% CD1_1 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * ccd1_1 = new char[cCD1_1.length()+1];
strcpy(ccd1_1,cCD1_1.c_str());
if(fits_write_key(fptr,TDOUBLE,"CD1_1",&kCD1_1,ccd1_1,&status)){
delete ccd1_1;
printerror(status, "Error fits_write_key(CD1_1)");
return false;
}
delete ccd1_1;
/// 39. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% CD1_2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * ccd1_2 = new char[cCD1_2.length()+1];
strcpy(ccd1_2,cCD1_2.c_str());
if(fits_write_key(fptr,TDOUBLE,"CD1_2",&kCD1_2,ccd1_2,&status)){
delete ccd1_2;
printerror(status, "Error fits_write_key(CD1_2)");
return false;
}
delete ccd1_2;
/// 40. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% CD2_1 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * ccd2_1 = new char[cCD2_1.length()+1];
strcpy(ccd2_1,cCD2_1.c_str());
if(fits_write_key(fptr,TDOUBLE,"CD2_1",&kCD2_1,ccd2_1,&status)){
delete ccd2_1;
printerror(status, "Error fits_write_key(CD2_1)");
return false;
}
delete ccd2_1;
/// 41. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% CD2_2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * ccd2_2 = new char[cCD2_2.length()+1];
strcpy(ccd2_2,cCD2_2.c_str());
if(fits_write_key(fptr,TDOUBLE,"CD2_2",&kCD2_2,ccd2_2,&status)){
delete ccd2_2;
printerror(status, "Error fits_write_key(CD2_2)");
return false;
}
delete ccd2_2;
/// 42. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% CD3_3 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * ccd3_3 = new char[cCD3_3.length()+1];
strcpy(ccd3_3,cCD3_3.c_str());
if(fits_write_key(fptr,TDOUBLE,"CD3_3",&kCD3_3,ccd3_3,&status)){
delete ccd3_3;
printerror(status, "Error fits_write_key(CD3_3)");
return false;
}
delete ccd3_3;
/// 43. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% CRPIX1 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * ccrpix1 = new char[cCRPIX1.length()+1];
strcpy(ccrpix1,cCRPIX1.c_str());
if(fits_write_key(fptr,TINT,"CRPIX1",&kCRPIX1,ccrpix1,&status)){
delete ccrpix1;
printerror(status, "Error fits_write_key(CRPIX1)");
return false;
}
delete ccrpix1;
/// 44. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% CRPIX2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * ccrpix2 = new char[cCRPIX2.length()+1];
strcpy(ccrpix2,cCRPIX2.c_str());
if(fits_write_key(fptr,TINT,"CRPIX2",&kCRPIX2,ccrpix2,&status)){
delete ccrpix2;
printerror(status, "Error fits_write_key(CRPIX2)");
return false;
}
delete ccrpix2;
/// 45. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% CRVAL1 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * ccrval1 = new char[cCRVAL1.length()+1];
strcpy(ccrval1,cCRVAL1.c_str());
if(fits_write_key(fptr,TDOUBLE,"CRVAL1",&kCRVAL1,ccrval1,&status)){
delete ccrval1;
printerror(status, "Error fits_write_key(CRVAL1)");
return false;
}
delete ccrval1;
/// 46. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% CRVAL2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * ccrval2 = new char[cCRVAL2.length()+1];
strcpy(ccrval2,cCRVAL2.c_str());
if(fits_write_key(fptr,TDOUBLE,"CRVAL2",&kSITELAT,ccrval2,&status)){
delete ccrval2;
printerror(status, "Error fits_write_key(CRVAL2)");
return false;
}
delete ccrval2;
/// 47. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% K1 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * ck1 = new char[cK1.length()+1];
strcpy(ck1,cK1.c_str());
if(fits_write_key(fptr,TDOUBLE,"K1",&kK1,ck1,&status)){
delete ck1;
printerror(status, "Error fits_write_key(K1)");
return false;
}
delete ck1;
/// 48. %%%%%%%%%%%%%%%%%%%%%%%%%%%%% K2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
char * ck2 = new char[cK2.length()+1];
strcpy(ck2,cK2.c_str());
if(fits_write_key(fptr,TDOUBLE,"K2",&kK2,ck2,&status)){
delete ck2;
printerror(status, "Error fits_write_key(K2)");
return false;
}
delete ck2;
return true;
}
int ngp_keyword_all_write(NGP_HDU *ngph, fitsfile *ffp, int mode)
{ int i, r, ib;
char buf[200];
long l;
if (NULL == ngph) return(NGP_NUL_PTR);
if (NULL == ffp) return(NGP_NUL_PTR);
r = NGP_OK;
for (i=0; i<ngph->tokcnt; i++)
{ r = ngp_keyword_is_write(&(ngph->tok[i]));
if ((NGP_REALLY_ALL & mode) || (NGP_OK == r))
{ switch (ngph->tok[i].type)
{ case NGP_TTYPE_BOOL:
ib = ngph->tok[i].value.b;
fits_write_key(ffp, TLOGICAL, ngph->tok[i].name, &ib, ngph->tok[i].comment, &r);
break;
case NGP_TTYPE_STRING:
fits_write_key_longstr(ffp, ngph->tok[i].name, ngph->tok[i].value.s, ngph->tok[i].comment, &r);
break;
case NGP_TTYPE_INT:
l = ngph->tok[i].value.i; /* bugfix - 22-Jan-99, BO - nonalignment of OSF/Alpha */
fits_write_key(ffp, TLONG, ngph->tok[i].name, &l, ngph->tok[i].comment, &r);
break;
case NGP_TTYPE_REAL:
fits_write_key(ffp, TDOUBLE, ngph->tok[i].name, &(ngph->tok[i].value.d), ngph->tok[i].comment, &r);
break;
case NGP_TTYPE_COMPLEX:
fits_write_key(ffp, TDBLCOMPLEX, ngph->tok[i].name, &(ngph->tok[i].value.c), ngph->tok[i].comment, &r);
break;
case NGP_TTYPE_NULL:
fits_write_key_null(ffp, ngph->tok[i].name, ngph->tok[i].comment, &r);
break;
case NGP_TTYPE_RAW:
if (0 == strcmp("HISTORY", ngph->tok[i].name))
{ fits_write_history(ffp, ngph->tok[i].comment, &r);
break;
}
if (0 == strcmp("COMMENT", ngph->tok[i].name))
{ fits_write_comment(ffp, ngph->tok[i].comment, &r);
break;
}
sprintf(buf, "%-8.8s%s", ngph->tok[i].name, ngph->tok[i].comment);
fits_write_record(ffp, buf, &r);
break;
}
}
else if (NGP_BAD_ARG == r) /* enhancement 10 dec 2003, James Peachey: template comments replace defaults */
{ r = NGP_OK; /* update comments of special keywords like TFORM */
if (ngph->tok[i].comment && *ngph->tok[i].comment) /* do not update with a blank comment */
{ fits_modify_comment(ffp, ngph->tok[i].name, ngph->tok[i].comment, &r);
}
}
else /* other problem, typically a blank token */
{ r = NGP_OK; /* skip this token, but continue */
}
if (r) return(r);
}
fits_set_hdustruc(ffp, &r); /* resync cfitsio */
return(r);
}
int hpic_fits_vecindx_write(char *filename, char *creator, char *extname,
char *comment, hpic_vec_int * indx,
hpic_vec_fltarr * vecs, char **vecnames,
char **vecunits, hpic_keys * keys)
{
size_t i, j, k, m;
fitsfile *fp;
int ret = 0;
int bitpix = SHORT_IMG;
int nax = 0;
long axes[] = { 0, 0 };
int total;
int type;
long rows;
long frow = 1;
long fsamp = 1;
size_t veclen;
char **vectypes;
char **names;
char **units;
size_t nvecs = hpic_vec_fltarr_n_get(vecs);
hpic_vec_float *tempvec;
if (nvecs == 0) {
HPIC_ERROR(HPIC_ERR_FITS, "must specify more than zero vectors!");
}
if (!indx) {
HPIC_ERROR(HPIC_ERR_ACCESS, "index vector is not allocated");
}
for (i = 0; i < nvecs; i++) {
tempvec = hpic_vec_fltarr_get(vecs, i);
if (!tempvec) {
HPIC_ERROR(HPIC_ERR_ACCESS, "input vector is not allocated");
}
}
vectypes = hpic_strarr_alloc(nvecs + 1);
names = hpic_strarr_alloc(nvecs + 1);
units = hpic_strarr_alloc(nvecs + 1);
veclen = hpic_vec_int_n_get(indx);
for (i = 0; i < nvecs; i++) {
tempvec = hpic_vec_fltarr_get(vecs, i);
if (veclen != hpic_vec_float_n_get(tempvec)) {
HPIC_ERROR(HPIC_ERR_FITS, "all vectors must have the same length");
}
}
/* setup column parameters */
strncpy(vectypes[0], "1J", HPIC_STRNL);
strncpy(names[0], "INDEX", HPIC_STRNL);
strncpy(units[0], "", HPIC_STRNL);
for (i = 1; i < nvecs + 1; i++) {
strncpy(vectypes[i], "1E", HPIC_STRNL);
strncpy(names[i], vecnames[i - 1], HPIC_STRNL);
strncpy(units[i], vecunits[i - 1], HPIC_STRNL);
}
/* create file */
if (fits_create_file(&fp, filename, &ret)) {
fitserr(ret, "hpic_fits_vecindx_write: creating file");
}
/* create empty primary image */
if (fits_create_img(fp, bitpix, nax, axes, &ret)) {
fitserr(ret, "hpic_fits_vecindx_write: creating primary image");
}
/* write header */
if (fits_write_comment(fp, " ", &ret)) {
fitserr(ret, "hpic_fits_vecindx_write: writing header comment 1");
}
if (fits_write_comment(fp, comment, &ret)) {
fitserr(ret, "hpic_fits_vecindx_write: writing header comment 2");
}
if (fits_write_comment(fp, " ", &ret)) {
fitserr(ret, "hpic_fits_vecindx_write: writing header comment 3");
}
if (fits_write_date(fp, &ret)) {
fitserr(ret, "hpic_fits_vecindx_write: writing date");
}
if (fits_write_key
(fp, TSTRING, "CREATOR", creator, "Software creating the map", &ret)) {
fitserr(ret, "hpic_fits_vecindx_write: writing creator");
}
/* write extension */
if (fits_create_tbl
(fp, BINARY_TBL, (long)veclen, (int)(nvecs + 1), names, vectypes, units,
extname, &ret)) {
fitserr(ret, "hpic_fits_vecindx_write: creating binary table");
}
if (fits_movabs_hdu(fp, 2, &type, &ret)) {
fitserr(ret, "hpic_fits_vecindx_write: moving to extension");
}
/* write mandatory keywords */
if (fits_write_comment(fp, " ", &ret)) {
fitserr(ret, "hpic_fits_vecindx_write: writing ext comment 1");
}
if (fits_write_comment
(fp, "-----------------------------------------------", &ret)) {
fitserr(ret, "hpic_fits_vecindx_write: writing ext comment 2");
}
if (fits_write_comment(fp, " Data Specific Keywords ", &ret)) {
fitserr(ret, "hpic_fits_vecindx_write: writing ext comment 3");
}
if (fits_write_comment
(fp, "-----------------------------------------------", &ret)) {
fitserr(ret, "hpic_fits_vecindx_write: writing ext comment 4");
}
if (fits_write_comment(fp, " ", &ret)) {
fitserr(ret, "hpic_fits_vecindx_write: writing comment 5");
}
/* write optional keywords */
hpic_keys_write(keys, fp, &ret);
/* write the data and clean up */
if (fits_write_col
(fp, TINT, 1, frow, fsamp, (long)veclen, indx->data, &ret)) {
fitserr(ret, "hpic_fits_vecindx_write: writing index column");
}
for (i = 0; i < nvecs; i++) {
tempvec = hpic_vec_fltarr_get(vecs, i);
if (fits_write_col
(fp, TFLOAT, (int)(i + 2), frow, fsamp, (long)veclen, tempvec->data,
&ret)) {
fitserr(ret, "hpic_fits_vecindx_write: writing data column");
}
}
hpic_strarr_free(vectypes, nvecs + 1);
hpic_strarr_free(names, nvecs + 1);
hpic_strarr_free(units, nvecs + 1);
if (fits_close_file(fp, &ret)) {
fitserr(ret, "hpic_fits_vecindx_write: closing file");
}
return ret;
}
