int get_fqtable(fitsfile *fptr, int hdu, struct uvf_header *header) { int status = 0, i; int hdutype, col_iff, type_iff; long nrows, rpt_iff, wid_iff; double f; fits_movabs_hdu(fptr, hdu, &hdutype, &status); fits_get_num_rows(fptr, &nrows, &status); fits_get_colnum(fptr, CASEINSEN, "IF FREQ", &col_iff, &status); fits_get_coltype(fptr, col_iff, &type_iff, &rpt_iff, &wid_iff, &status); if (status || type_iff != TDOUBLE || nrows != 1 || rpt_iff != header->nif) fprintf(stderr, " Warning: Invalid AIPS frequency table\n"); for (i=0; i < rpt_iff; i++) { fits_read_col(fptr, TDOUBLE, col_iff, 1, i+1, 1, NULL, &f, NULL, &status); header->iffreq[i] = header->freq + f; } fprintf(stderr, " %d IFs ", header->nif); for (i=0; i < header->nif; i++) fprintf(stderr, " %.2f", header->iffreq[i]*1e-9); fprintf(stderr, "\n"); return status ? 1 : 0; }
int get_subint ( char *name ) { //double *read_arrival_time( char *input, long *nrows ) fitsfile *fptr; // pointer to the FITS file, defined in fitsio.h int status; long int nrows; status = 0; if ( fits_open_file(&fptr, name, READONLY, &status) ) // open the file { printf( "error while openning file\n" ); } if ( fits_get_num_rows(fptr, &nrows, &status) ) // get the row number { printf( "error while getting the row number\n" ); } printf ("number of subint: %ld\n", nrows); /////////////////////////////////////////////////////////////////////////// if ( fits_close_file(fptr, &status) ) { printf( " error while closing the file " ); } return nrows; }
int FitsFile::GetRowCount() { CheckOpen(); long rowCount; int status = 0; fits_get_num_rows(_fptr, &rowCount, &status); CheckStatus(status); return rowCount; }
float * supcam_read_data( fitsfile * fits, size_t * numRows, size_t * numChans, int * status ) { int colnum = 0; /* DATA column */ int fitsStatus = 0; /* CFITSIO status */ long nRows = 0; long nChans = 0; long dummy; float * data = NULL; int typecode = 0; /* Initialise the return values */ *numChans = 0; *numRows = 0; if (*status != SAI__OK) return NULL; /* Prepare to read the Binary Table */ /* Check number of rows */ CALLCFITSIO( fits_get_num_rows(fits, &nRows, &fitsStatus), "Error getting number of rows" ); /* Find DATA column and check its repeat count */ /* cast because cfitsio does not use const */ CALLCFITSIO( fits_get_colnum(fits, CASEINSEN, (char *)"DATA", &colnum, &fitsStatus), "Error getting column number for DATA" ); CALLCFITSIO( fits_get_coltype(fits, colnum, &typecode, &nChans, &dummy, &fitsStatus), "Error getting column information" ); if (*status != SAI__OK) return NULL; /* Get some memory */ data = astMalloc( nChans * nRows * sizeof(*data) ); /* Read DATA column */ CALLCFITSIO( fits_read_col(fits, TFLOAT, colnum, 1, 1, nChans*nRows, NULL, data, NULL, &fitsStatus), "Error reading spectra from Binary Column DATA" ); if (*status == SAI__OK) { /* It looks like there is a bad value of (-1)*VAL__BADI */ size_t i; size_t nelems = nChans * nRows; for (i = 0; i < nelems; i++ ) { if (data[i] >= (float)(VAL__MAXI - 1)) { data[i] = VAL__BADR; } } *numChans = nChans; *numRows = nRows; } return data; }
long InputFileFITS::getNRows() { int status = 0; if(!isOpened()) throwException("Error in InputFileFITS::getNRows() ", status); long nrows; fits_get_num_rows(infptr, &nrows, &status); if (status) throwException("Error in InputFileFITS::getNRows() ", status); return nrows; }
int get_antable(fitsfile *fptr, int hdu, struct uvf_header *header) { int status = 0, i; int hdutype, col_name, col_xyz, type_name, type_xyz; long nrows, rpt_name, rpt_xyz, wid_name, wid_xyz; char *string[1]; int anynull; fits_movabs_hdu(fptr, hdu, &hdutype, &status); fits_get_num_rows(fptr, &nrows, &status); header->n_antennas = (int) nrows; fits_get_colnum(fptr, CASEINSEN, "ANNAME", &col_name, &status); fits_get_coltype(fptr, col_name, &type_name, &rpt_name, &wid_name, &status); fits_get_colnum(fptr, CASEINSEN, "STABXYZ", &col_xyz, &status); fits_get_coltype(fptr, col_xyz, &type_xyz, &rpt_xyz, &wid_xyz, &status); if (status || type_name != TSTRING || type_xyz != TDOUBLE || rpt_xyz != 3) fprintf(stderr, " Warning: Invalid AIPS antenna table: %d %ld %d %ld\n", type_name, rpt_name, type_xyz, rpt_xyz); for (i=0; i < nrows; i++) { string[0] = header->antenna[i].name; fits_read_col(fptr, TSTRING, col_name, i+1, 1, 1, "NONAME", string, &anynull, &status); fits_read_col(fptr, TDOUBLE, col_xyz, i+1, 1, 1, NULL, &(header->antenna[i].x), NULL, &status); fits_read_col(fptr, TDOUBLE, col_xyz, i+1, 2, 1, NULL, &(header->antenna[i].y), NULL, &status); fits_read_col(fptr, TDOUBLE, col_xyz, i+1, 3, 1, NULL, &(header->antenna[i].z), NULL, &status); if (DEBUG) fprintf(stderr, " %s %8.3f %8.3f %8.3f\n", header->antenna[i].name, header->antenna[i].x, header->antenna[i].y, header->antenna[i].z); } fprintf(stderr, " %d antennas ", (int) nrows); for (i=0; i < nrows; i++) fprintf(stderr, " %s", header->antenna[i].name); fprintf(stderr, "\n"); return status ? 1 : 0; }
// filterTableToImage: filter a binary table, create a temp image fitsfile *filterTableToImage(fitsfile *fptr, char *filter, char **cols, int *dims, double *cens, int bin, int *status){ int i, dim1, dim2; int imagetype=TINT, naxis=IDIM, recip=0; int tstatus; long nirow, norow; float weight=1; float xcen, ycen; double dvalue; double minin[IDIM], maxin[IDIM], binsizein[IDIM]; char comment[81]; char *rowselect=NULL; char *outfile=IFILE; char wtcol[FLEN_VALUE]; char colname[IDIM][FLEN_VALUE]; char minname[IDIM][FLEN_VALUE]; char maxname[IDIM][FLEN_VALUE]; char binname[IDIM][FLEN_VALUE]; int colnum[IDIM]; long haxes[IDIM]; float amin[IDIM]; float amax[IDIM]; float binsize[IDIM]; fitsfile *ofptr; // set up defaults if( !bin ) bin = 1; wtcol[0] = '\0'; if( cols && cols[0] && cols[1] ){ strcpy(colname[0], cols[0]); strcpy(colname[1], cols[1]); } else { colname[0][0] = '\0'; colname[1][0] = '\0'; } for(i=0; i<IDIM; i++){ minin[i] = DOUBLENULLVALUE; maxin[i] = DOUBLENULLVALUE; binsizein[i] = (double)bin; minname[i][0] = '\0'; maxname[i][0] = '\0'; binname[i][0] = '\0'; } // get total number of rows in input file fits_get_num_rows(fptr, &nirow, status); // and allocate memory for selected rows array rowselect = malloc(nirow+1); // filter the input file and generate selected rows array if( filter && *filter ){ fits_find_rows(fptr, filter, 0, nirow, &norow, rowselect, status); } else { for(i=0; i<nirow+1; i++){ rowselect[i] = TRUE; } } // get binning parameters so we can know the image dims for these cols // and from that, get the default center of the image fits_calc_binning(fptr, naxis, colname, minin, maxin, binsizein, minname, maxname, binname, colnum, haxes, amin, amax, binsize, status); // why truncate to int? otherwise, cfitsio is 0.5 pixels off from js9 ... xcen = (int)(amax[0] - amin[0])/2; ycen = (int)(amax[1] - amin[1])/2; dim1 = haxes[0]; dim2 = haxes[0]; // get limits of extracted section if( dims && dims[0] && dims[1] ){ // read image section if( cens && cens[0] && cens[1] ){ xcen = cens[0]; ycen = cens[1]; dim1 = dims[0]; dim2 = dims[1]; } else { if( haxes[0] >= dims[0] ){ dim1 = dims[0]; } if( haxes[1] >= dims[1] ){ dim2 = dims[1]; } } minin[0] = (int)(xcen - ((dim1+1)/2) + 1); minin[1] = (int)(ycen - ((dim2+1)/2) + 1); maxin[0] = (int)(xcen + (dim1/2)); maxin[1] = (int)(ycen + (dim2/2)); } // make 2D section histogram from selected rows ofptr = ffhist3(fptr, outfile, imagetype, naxis, colname, minin, maxin, binsizein, minname, maxname, binname, weight, wtcol, recip, rowselect, status); // update/add LTM and LTV header params dvalue = 0.0; *comment = '\0'; tstatus = 0; fits_read_key(fptr, TDOUBLE, "LTV1", &dvalue, comment, &tstatus); dvalue = (dim1 / 2) - xcen; tstatus = 0; fits_update_key(ofptr, TDOUBLE, "LTV1", &dvalue, comment, &tstatus); dvalue = 0.0; *comment = '\0'; tstatus = 0; fits_read_key(fptr, TDOUBLE, "LTV2", &dvalue, comment, &tstatus); dvalue = (dim2 / 2) - ycen; tstatus = 0; fits_update_key(ofptr, TDOUBLE, "LTV2", &dvalue, comment, &tstatus); dvalue = 1.0 / bin; *comment = '\0'; tstatus = 0; fits_read_key(fptr, TDOUBLE, "LTM1_1", &dvalue, comment, &tstatus); tstatus = 0; fits_update_key(ofptr, TDOUBLE, "LTM1_1", &dvalue, comment, &tstatus); dvalue = 0.0; *comment = '\0'; tstatus = 0; fits_read_key(fptr, TDOUBLE, "LTM1_2", &dvalue, comment, &tstatus); tstatus = 0; fits_update_key(ofptr, TDOUBLE, "LTM1_2", &dvalue, comment, &tstatus); dvalue = 0.0; *comment = '\0'; tstatus = 0; fits_read_key(fptr, TDOUBLE, "LTM2_1", &dvalue, comment, &tstatus); tstatus = 0; fits_update_key(ofptr, TDOUBLE, "LTM2_1", &dvalue, comment, &tstatus); dvalue = 1.0 / bin; *comment = '\0'; tstatus = 0; fits_read_key(fptr, TDOUBLE, "LTM2_2", &dvalue, comment, &tstatus); tstatus = 0; fits_update_key(ofptr, TDOUBLE, "LTM2_2", &dvalue, comment, &tstatus); // return the center and dims used if( dims ){ dims[0] = dim1; dims[1] = dim2; } if( cens ){ cens[0] = xcen; cens[1] = ycen; } // free up space if( rowselect ) free(rowselect); // return new file pointer return ofptr; }
int main(int argc, char **argv) { int i_file,i_scan,i_chan,i_bin,n_omit,status=0; int NFirstTable, NumHDU, NDumps, TotDumps=0, hdutype; // int OutChans; int spk; int got_bins=0, got_mjd1=0; //, zeroed_outprofs=0; long NPtsProf=0, FirstNPtsProf=0; float Weight=1.0, TotWeight=0.; // int ProfSum=0; double x, ptype; double MJD_first=0., MJD_last=0., MJD_mid; double IMJDMid, MJDSecsMid; double SBase,Srms,Duty,SPeak,FinalMask[NBINMAX]; double OutFreq; char ProgName[32]; char Outfile[128]; char Header[256]; struct ASPHdr *Hdr; struct SubHdr Subhdr; struct StdProfs *InProfile, OutProfile; struct RunVars RunMode; fitsfile **Fin; FILE *Fout, *Fcheck; Cmdline *Cmd; /* Get command line variables */ Cmd = parseCmdline(argc, argv); /* Normally use this somewhere, and not showOptionValues */ Cmd->tool = Cmd->tool; strcpy(ProgName, argv[0]); Fin = (fitsfile **)malloc(Cmd->InfileC*sizeof(fitsfile)); Hdr = (struct ASPHdr *)malloc(Cmd->InfileC*sizeof(struct ASPHdr)); /* Dynamically allocate RunMode variables */ if (AllocRunMode(&RunMode) < 0){ printf("Could not allocate RunMode structure. Exiting...\n"); exit(2); } strcpy(RunMode.Infile,Cmd->Infile); // if(!zeroed_outprofs) { /* if(Cmd->SortChansP){ OutChans=Hdr[0].obs.NChan; } else{ */ // OutChans=1; // } // OutProfile=(struct StdProfs *)malloc(OutChans*sizeof(struct StdProfs)); // TotWeight=(float *)malloc(OutChans*sizeof(float)); /* Zero out profiles */ // for(i_chan=0;i_chan<OutChans;i_chan++){ FZero(OutProfile.rstds,NBINMAX); FZero(OutProfile.rstdq,NBINMAX); FZero(OutProfile.rstdu,NBINMAX); FZero(OutProfile.rstdv,NBINMAX); // } //zeroed_outprofs=1; // } /* Create an output file to check omissions if in vebose mode */ if (Cmd->VerboseP || Cmd->CheckOmitP){ if((Fcheck = fopen("check_omit.dat","w")) == 0) { printf("Cannot open %s. Exiting...\n",Outfile); exit(1); } } /* read in all input files and add each to the final profile */ /* read in all input file headers */ NPtsProf=0; for (i_file=0;i_file<Cmd->InfileC;i_file++){ n_omit=0; status=0; if(fits_open_file(&Fin[i_file], Cmd->Infile[i_file], READONLY, &status)){ printf("Error opening FITS file %s !!!\n", Cmd->Infile[i_file]); exit(1); } if(ReadASPHdr(&Hdr[i_file], Fin[i_file]) < 0){ printf("%s> Unable to read Header from file %s. Exiting...\n", ProgName,Cmd->Infile[i_file]); exit(1); } /* Write file name in verbose-mode omit check file */ if(Cmd->VerboseP || Cmd->CheckOmitP) fprintf(Fcheck, "\n%s\n",Cmd->Infile[i_file]); /* for now just check if all files have same number of channels */ /* if(Cmd->SortChansP) if(i_file>0 && Hdr[i_file].obs.NChan!=Hdr[0].obs.NChan){ fprintf(stderr,"%s> Different numbers of channels in different files:\n\n", ProgName); fprintf(stderr,"%s: %d channels, %s: %d channels\n", Cmd->Infile[0],Hdr[0].obs.NChan, Cmd->Infile[i_file],Hdr[i_file].obs.NChan); } */ /* now find the number of dumps in the file */ fits_get_num_hdus(Fin[i_file], &NumHDU, &status); if(!strcmp(Hdr[i_file].gen.HdrVer,"Ver1.0")){ NDumps = NumHDU-3; /* the "3" is temporary, depending on how many non-data tables we will be using */ } else if(!strcmp(Hdr[i_file].gen.HdrVer,"Ver1.0.1")){ NDumps = (NumHDU-3)/2; } else{ fprintf(stderr,"%s> Do not recognize FITS file version in header.\n", ProgName); fprintf(stderr,"This header is %s. Exiting...\n",Hdr[i_file].gen.HdrVer); exit(1); } printf("File %s:\n",Cmd->Infile[i_file]); printf(" Number of channels: %d\n",Hdr[i_file].obs.NChan) ; printf(" Number of dumps: %d\n",NDumps); /* Move to the first data table HDU in the fits file */ if(!strcmp(Hdr[i_file].gen.HdrVer,"Ver1.0")) fits_movnam_hdu(Fin[i_file], BINARY_TBL, "STOKES0", 0, &status); else if (!strcmp(Hdr[i_file].gen.HdrVer,"Ver1.0.1")) fits_movnam_hdu(Fin[i_file], ASCII_TBL, "DUMPREF0", 0, &status); /* Get the current HDU number */ fits_get_hdu_num(Fin[i_file], &NFirstTable); /* Set up Profile structure size */ for(i_scan=0;i_scan<NDumps;i_scan++){ InProfile=(struct StdProfs *)malloc(Hdr[i_file].obs.NChan* sizeof(struct StdProfs)); /* move to next dump's data */ if(!strcmp(Hdr[i_file].gen.HdrVer,"Ver1.0")){ fits_movabs_hdu(Fin[i_file], NFirstTable+i_scan, &hdutype, &status); } else if(!strcmp(Hdr[i_file].gen.HdrVer,"Ver1.0.1")){ /* if we've reached the end of the FITS file then increase FileNo */ fits_movabs_hdu(Fin[i_file],NFirstTable+(i_scan%MAXDUMPS)*2+1,&hdutype, &status); fits_get_num_rows(Fin[i_file], &NPtsProf, &status);status=0; fits_movrel_hdu(Fin[i_file], -1, NULL, &status); } /* IF not done so, use number of bins from first file to compare to the rest of the files */ if(got_bins==0){ FirstNPtsProf=NPtsProf; got_bins=1; } /********** FIX: SKIP THIS WITHOUT DOING THE OMIT THING ***********/ /********** AND DON'T ADD TO NUMBER COUNT ************/ if(NPtsProf != FirstNPtsProf) { fprintf(stderr,"Warning: Skipping scan %d (%ld bins ", i_scan,NPtsProf); fprintf(stderr,"vs. %ld bins in others).\n",FirstNPtsProf); n_omit += Hdr[i_file].obs.NChan; } else{ /* find NPtsProf */ ReadASPStokes(&Hdr[i_file], &Subhdr, Fin[i_file], NPtsProf, InProfile, i_scan, Cmd->VerboseP); /* Add this profile onto running output profile */ for(i_chan=0;i_chan<Hdr[i_file].obs.NChan;i_chan++){ /* Bad scans are zeroed so if summ of the profile is zero, it's not to be used in summation */ // ProfSum = FSum(&InProfile[i_chan].rstds[0], NPtsProf); // ProfSum = 0; // ProfSum = ArrayZero(InProfile[i_chan].rstds, NPtsProf); // if(ProfSum != 0.0) { // i.e. good data /* Test that all bins in current profile are not zeroed */ if(!ArrayZero(InProfile[i_chan].rstds, NPtsProf)) { // i.e. good data // if(InProfile[i_chan].rstds[0] > -99998.) { // i.e. good data /* If first MJD has not been registered, then do so since this would be the first non-omitted scan */ if (got_mjd1==0) { MJD_first = (double)Hdr[i_file].obs.IMJDStart + Subhdr.DumpMiddleSecs/86400.; got_mjd1=1; } if (i_scan==NDumps-1) { /* Just keep overwriting MJD_last every i_file -- that way we ensure getting the last MJD of the FINAL non-omitted scan used */ MJD_last = (double)Hdr[i_file].obs.IMJDStart + Subhdr.DumpMiddleSecs/86400.; } /* Get SNR for each Profile if we want to use weighting; otherwise weights will all be 1.0 */ if(Cmd->WeightP) { Duty = DutyLookup(Hdr[i_file].target.PSRName); BMask(InProfile[i_chan].rstds,&Hdr[i_file].redn.RNBinTimeDump, &Duty,FinalMask); Baseline(InProfile[i_chan].rstds,FinalMask, &Hdr[i_file].redn.RNBinTimeDump,&SBase,&Srms); SPeak = FindPeak(InProfile[i_chan].rstds, &Hdr[i_file].redn.RNBinTimeDump,&spk); InProfile[i_chan].SNR = SPeak*Srms; // Weight = InProfile[i_chan].SNR; Weight = Srms; // which is actually 1/RMS. } // printf("SNR %d = %lf\n",i_chan,InProfile[i_chan].SNR); /* Need to figure out how to organize input channels to match * output channels */ /* if(Cmd->SortChansP){ for(i_bin=0;i_bin<NPtsProf;i_bin++) { OutProfile[i_chan].rstds[i_bin] += Weight*InProfile[i_chan].rstds[i_bin]; OutProfile[i_chan].rstdq[i_bin] += Weight*InProfile[i_chan].rstdq[i_bin]; OutProfile[i_chan].rstdu[i_bin] += Weight*InProfile[i_chan].rstdu[i_bin]; OutProfile[i_chan].rstdv[i_bin] += Weight*InProfile[i_chan].rstdv[i_bin]; } } else{ */ for(i_bin=0;i_bin<NPtsProf;i_bin++) { OutProfile.rstds[i_bin] += Weight*InProfile[i_chan].rstds[i_bin]; OutProfile.rstdq[i_bin] += Weight*InProfile[i_chan].rstdq[i_bin]; OutProfile.rstdu[i_bin] += Weight*InProfile[i_chan].rstdu[i_bin]; OutProfile.rstdv[i_bin] += Weight*InProfile[i_chan].rstdv[i_bin]; // printf("%f\n",OutProfile[0].rstds[i_bin]);fflush(stdout); } // } TotWeight += Weight; // for now keep at zero index /* Print profile weights for each scan, for each channel */ if(RunMode.Verbose) { if(i_chan==0) printf("Profile weights -- scan %d: \n ",i_scan); printf("%6.2f ",Weight); if(i_chan==Hdr[i_file].obs.NChan-1) printf("\n");fflush(stdout); } } else { n_omit++; if(Cmd->VerboseP || Cmd->CheckOmitP){ fprintf(Fcheck, "%6d %.1lf\n", i_scan,Hdr[i_file].obs.ChanFreq[i_chan]); /* printf("File %d, Dump %d, Channel %d (%lf MHz) were found to be\n", i_file,i_scan,i_chan,Hdr[i_file].obs.ChanFreq[i_chan]); printf(" zeroed and so are not included.\n");fflush(stdout); */ } } // if(i_chan==0) {for(i=0;i<50;i++) printf("%lf ",OutProfile[0].rstds[i]);printf("\n\n");fflush(stdout);}; } /*****************/ /* } */ } /* else from positive check on NPtsProf */ free(InProfile); } /****** maybe bring this inside the ELSE where entire scans aren't being omitted ******/ /* if (Cmd->SortChansP) TotDumps += (NDumps - n_omit); else */ TotDumps += (NDumps*Hdr[i_file].obs.NChan - n_omit); //free(InProfile); printf("Reading of file %s complete and successful.\n", Cmd->Infile[i_file]); printf("%d scans omitted.\n\n",n_omit);fflush(stdout); } if(Cmd->VerboseP || Cmd->CheckOmitP) fclose(Fcheck); /* Appease the format of the MakePol routine by making up these RunMode structure members */ strcpy(RunMode.Source,Hdr[0].target.PSRName); RunMode.Verbose = Cmd->VerboseP; RunMode.FlipPA = 0; RunMode.NoBase = Cmd->NoBaseP; /* divide out total number of dumps to get the average */ // for(i_chan=0;i_chan<OutChans;i_chan++){ printf("Totdumps = %d\n",TotDumps); fflush(stdout); for(i_bin=0;i_bin<NPtsProf;i_bin++) { OutProfile.rstds[i_bin] /= TotWeight; OutProfile.rstdq[i_bin] /= TotWeight; OutProfile.rstdu[i_bin] /= TotWeight; OutProfile.rstdv[i_bin] /= TotWeight; } MakePol(&RunMode, (int)NPtsProf, &OutProfile); /* Open file for writing */ sprintf(Outfile,"AddProf.out"); /* now write the output ascii added profile */ if ((Fout = fopen(Outfile,"w")) == 0) { printf("Cannot open %s. Exiting...\n",Outfile); exit(1); } /* take average MJD of first to last scan */ MJD_mid = (MJD_first + MJD_last)/2.; IMJDMid = floor(MJD_mid); MJDSecsMid = (MJD_mid - IMJDMid)*86400.; printf("MJD_mid = %lf, IMJDMid = %lf, MJDSecsMid = %lf\n",MJD_mid,IMJDMid,MJDSecsMid);fflush(stdout); /* to choose a channel to put in the header for now, ust use the average of the first datafile's channels */ OutFreq=0.; for(i_chan=0; i_chan<Hdr[0].obs.NChan; i_chan++){ OutFreq += Hdr[0].obs.ChanFreq[i_chan]; } OutFreq /= Hdr[0].obs.NChan; /* Create and print header line for output file(s) */ sprintf(Header,"# %.1f %.7f %.10f %ld %.3f %.3f %d %s %d %9s %.10f", IMJDMid, MJDSecsMid, // Subhdr.DumpRefPeriod[i_chan], 0., (long)1, OutFreq, // Hdr[0].obs.DM, Hdr[i_file].redn.RNBinTimeDump, Hdr[0].obs.DM, (int)NPtsProf, Hdr[0].obs.ObsvtyCode, 1, Hdr[0].target.PSRName, 0.); // Subhdr.DumpRefPhase[i_chan]); fprintf(Fout,"%s\n",Header); for(i_bin=0;i_bin<NPtsProf;i_bin++) { /* see how strong the linear polarization is */ x = OutProfile.stdlin[i_bin]*OutProfile.Srms; ptype = 43.1; if (x > 1.) ptype=43.2; if (x > 2.) ptype=43.3; if (x > 3.) ptype=43.4; if (x > 4.) ptype=43.5; if (x > 5.) ptype=43.6; fprintf(Fout,"%5d%15.7f%15.7f%15.7f%15.7f%15.7f%15.7f%15.7f%6.1f\n",i_bin, OutProfile.rstds[i_bin],OutProfile.rstdq[i_bin], OutProfile.rstdu[i_bin], OutProfile.rstdv[i_bin], /* phi in degrees */ OutProfile.stdlin[i_bin], OutProfile.stdphi[i_bin]*180.0/TWOPI, OutProfile.stdphierr[i_bin]*180.0/TWOPI,ptype); } printf("Created output file %s\n",Outfile); fclose(Fout); // } /* Write all this to file */ printf("\nCompleted successfully.\n\n");fflush(stdout); exit(0); }
int psrfits_write_polycos(struct psrfits *pf, struct polyco *pc, int npc) { // Usual setup int *status = &(pf->status); // If mode!=fold, exit? // Save current HDU, move to polyco table int hdu; fits_get_hdu_num(pf->fptr, &hdu); fits_movnam_hdu(pf->fptr, BINARY_TBL, "POLYCO", 0, status); int itmp; double dtmp; char datestr[32], ctmp[32]; char *cptr; fits_get_system_time(datestr, &itmp, status); int i, col, n_written=0; long row; fits_get_num_rows(pf->fptr, &row, status); // Start at end of table for (i=0; i<npc; i++) { // Only write polycos that were used if (!pc[i].used) continue; // Go to next row (1-based index) row++; cptr = datestr; fits_get_colnum(pf->fptr,CASEINSEN,"DATE_PRO",&col,status); fits_write_col(pf->fptr,TSTRING,col,row,1,1,&cptr,status); sprintf(ctmp, "11.005"); // Tempo version? cptr = ctmp; fits_get_colnum(pf->fptr,CASEINSEN,"POLYVER",&col,status); fits_write_col(pf->fptr,TSTRING,col,row,1,1,&cptr,status); fits_get_colnum(pf->fptr,CASEINSEN,"NSPAN",&col,status); fits_write_col(pf->fptr,TINT,col,row,1,1,&(pc[i].nmin),status); fits_get_colnum(pf->fptr,CASEINSEN,"NCOEF",&col,status); fits_write_col(pf->fptr,TINT,col,row,1,1,&(pc[i].nc),status); sprintf(ctmp,"%d", pc[i].nsite); // XXX convert to letter? cptr = ctmp; fits_get_colnum(pf->fptr,CASEINSEN,"NSITE",&col,status); fits_write_col(pf->fptr,TSTRING,col,row,1,1,&cptr,status); fits_get_colnum(pf->fptr,CASEINSEN,"REF_FREQ",&col,status); fits_write_col(pf->fptr,TFLOAT,col,row,1,1,&(pc[i].rf),status); // XXX needs to be accurate?? dtmp=0.0; fits_get_colnum(pf->fptr,CASEINSEN,"PRED_PHS",&col,status); fits_write_col(pf->fptr,TDOUBLE,col,row,1,1,&dtmp,status); dtmp = (double)pc[i].mjd + pc[i].fmjd; fits_get_colnum(pf->fptr,CASEINSEN,"REF_MJD",&col,status); fits_write_col(pf->fptr,TDOUBLE,col,row,1,1,&dtmp,status); fits_get_colnum(pf->fptr,CASEINSEN,"REF_PHS",&col,status); fits_write_col(pf->fptr,TDOUBLE,col,row,1,1,&(pc[i].rphase),status); fits_get_colnum(pf->fptr,CASEINSEN,"REF_F0",&col,status); fits_write_col(pf->fptr,TDOUBLE,col,row,1,1,&(pc[i].f0),status); // XXX don't parse this yet dtmp=-6.0; fits_get_colnum(pf->fptr,CASEINSEN,"LGFITERR",&col,status); fits_write_col(pf->fptr,TDOUBLE,col,row,1,1,&dtmp,status); fits_get_colnum(pf->fptr,CASEINSEN,"COEFF",&col,status); fits_write_col(pf->fptr,TDOUBLE,col,row,1,pc[i].nc,pc[i].c,status); n_written++; } // Update polyco block count, only if new info was added if (n_written) { itmp = row; fits_get_colnum(pf->fptr,CASEINSEN,"NPBLK",&col,status); for (i=1; i<=row; i++) fits_write_col(pf->fptr,TINT,col,i,1,1,&itmp,status); } // Flush buffers (so files are valid as they are created) fits_flush_file(pf->fptr, status); // Go back to orig HDU fits_movabs_hdu(pf->fptr, hdu, NULL, status); return *status; }
int main(int argc, char *argv[]) { fitsfile *infile; int ii, jj, kk, status = 0; int nchan, nchan2, npol, wgts_col, offs_col; long nrows; float *weights, *offsets; char comment[120]; // Read the weights and offsets read_wgts_and_offs(argv[1], &nchan, &weights, &offsets); printf("Read in %d channels of weights and offsets from\n\t'%s'\n", nchan, argv[1]); // Step through the FITS files for (ii = 0 ; ii < argc-2 ; ii++) { printf("Updating '%s'\n", argv[ii+2]); // Is the file a PSRFITS file? if (!is_PSRFITS(argv[ii+2])) { fprintf(stderr, " Error! '%s' does not appear to be PSRFITS!\n", argv[ii+2]); exit(1); } // Open the PSRFITS file fits_open_file(&infile, argv[ii+2], READWRITE, &status); if (status) { printf(" Error! Cannot open '%s'!\n", argv[ii+2]); exit(1); } // Move to the SUBINT HDU fits_movnam_hdu(infile, BINARY_TBL, "SUBINT", 0, &status); if (status) { printf(" Warning! Cannot find NPOL in '%s'! Assuming NPOL=1\n", argv[ii+2]); status = 0; } // Read the number of channels and polarizations fits_read_key(infile, TINT, "NCHAN", &nchan2, comment, &status); \ if (status) { printf(" Warning! Cannot find NCHAN in '%s'!\n", argv[ii+2]); status = 0; } else if (nchan != nchan2) { printf(" Error! The number of channels in '%s'\n", argv[1]); printf(" and in '%s' do not match!\n", argv[ii+2]); exit(1); } fits_read_key(infile, TINT, "NPOL", &npol, comment, &status); \ if (status) { printf(" Warning! Cannot find NPOL in '%s'! Assuming NPOL=1\n", argv[ii+2]); npol = 1; status = 0; } // How many rows are there? fits_get_num_rows(infile, &nrows, &status); if (status) { printf(" Error! Cannot read the number of rows in '%s'!\n", argv[ii+2]); exit(1); } // Get the column numbers for the weights fits_get_colnum(infile, 0, "DAT_WTS", &wgts_col, &status); if (status==COL_NOT_FOUND) { printf(" Warning!: Can't find the channel weights!\n"); status = 0; } else { // update the weights, row by row for (jj = 1 ; jj < nrows+1 ; jj++) fits_write_col(infile, TFLOAT, wgts_col, jj, 1L, nchan, weights, &status); } // Get the column numbers for the offsets if (0) { fits_get_colnum(infile, 0, "DAT_OFFS", &offs_col, &status); if (status==COL_NOT_FOUND) { printf(" Warning!: Can't find the channel offsets!\n"); status = 0; } else { // update the offsets, row by row for (jj = 1 ; jj < nrows+1 ; jj++) for (kk = 0 ; kk < npol ; kk++) fits_write_col(infile, TFLOAT, offs_col, jj, kk*nchan+1L, nchan, offsets, &status); } } // Close the file fits_close_file(infile, &status); if (status) { printf(" Warning!: Cannot properly close '%s' (status=%d)!\n", argv[ii+2], status); status = 0; } } free(weights); free(offsets); printf("Finished.\n"); exit(0); }
bool PLANCKIDEFSource::initFile( ) { bool bRetVal = true; int iResult = 0; _numFrames = 0; if( !_filename.isNull( ) && !_filename.isEmpty( ) ) { QString str; fitsfile* ffits; int iStatus = 0; iResult = fits_open_file( &ffits, _filename.ascii( ), READONLY, &iStatus ); if( iResult == 0 ) { int iNumHeaderDataUnits; if( fits_get_num_hdus( ffits, &iNumHeaderDataUnits, &iStatus ) == 0 ) { long lNumRows; int iHDUType; int i; // // determine the number of frames... // if( iNumHeaderDataUnits > 1 ) { if( fits_movabs_hdu( ffits, 2, &iHDUType, &iStatus ) == 0 ) { if( fits_get_hdu_type( ffits, &iHDUType, &iStatus ) == 0 ) { if( iHDUType == BINARY_TBL ) { iResult = fits_get_num_rows( ffits, &lNumRows, &iStatus ); if( iResult == 0 ) { _numFrames = lNumRows; } } } } } if( _numFrames > 0 ) { fits_movabs_hdu( ffits, 1, &iHDUType, &iStatus ); field *fld = new field; fld->table = 0; fld->column = 0; _fields.insert( "INDEX", fld ); _fieldList.append( "INDEX" ); // // add the fields and metadata... // for( i=0; i<iNumHeaderDataUnits-1; i++ ) { if( iStatus == 0 ) { addToMetadata( ffits, iStatus ); // // the first table never contains data... // if( i > 0 ) { // // create the time entries if necessary... // if( _fields.find( "TIME_ABSOLUTE" ) == 0L && _fields.find( "TIME_RELATIVE" ) == 0L ) { char comment[FLEN_COMMENT]; int iStatusDelta = 0; int iStatusZero = 0; fits_read_key( ffits, TDOUBLE, "DELTA_T", &_dTimeDelta, comment, &iStatusDelta ); fits_read_key( ffits, TDOUBLE, "TIMEZERO", &_dTimeZero, comment, &iStatusZero ); if( iStatusDelta == 0 ) { if( iStatusZero == 0 ) { field *fld = new field; fld->table = 0; fld->column = 0; _fields.insert( "TIME_ABSOLUTE", fld ); _fieldList.append( "TIME_ABSOLUTE" ); } else { field *fld = new field; fld->table = 0; fld->column = 0; _fields.insert( "TIME_RELATIVE", fld ); _fieldList.append( "TIME_RELATIVE" ); } } } // // create the field entries... // fits_get_hdu_type( ffits, &iHDUType, &iStatus ); if( iStatus == 0 ) { if( iHDUType == BINARY_TBL || iHDUType == ASCII_TBL ) { int iNumCols; iResult = fits_get_num_cols( ffits, &iNumCols, &iStatus ); if( iResult == 0 ) { iResult = fits_get_num_rows( ffits, &lNumRows, &iStatus ); if( iResult == 0 ) { addToFieldList( ffits, iNumCols, iStatus ); } } } } } fits_movrel_hdu( ffits, 1, &iHDUType, &iStatus); } } } } iStatus = 0; updateNumFramesScalar( ); fits_close_file( ffits, &iStatus ); } } return bRetVal; }
/** * Function: get_ALL_from_next_in_SPC * The function creates and fills a full spectrum structure with * the content of a SPC table extension. This is only done when, * according to the beam ID, this beam should be corrected. * For extensions with higher order beams which are not corrected * an emply structure is returned. * * Parameters: * @param SPCn_ptr - pointer to the opened SPC file * @param aperID - pointer to aperture identification number * @param beamID - pointer to beam identification number * * Returns: * @return SPC - the full spectrum structure */ full_spectr * get_ALL_from_next_in_SPC(fitsfile *SPC_ptr, int *aperID, int *beamID) { int f_status=0, hdutype; long tmp; //long nrows=0; char comment[FLEN_COMMENT]; full_spectr *SPC; fits_movrel_hdu (SPC_ptr, 1, &hdutype, &f_status); if (f_status) { *aperID = -1; *beamID = -1; SPC = NULL; return SPC; } // read the beam ID number fits_read_key_lng (SPC_ptr, "BEAMID", &tmp, comment, &f_status); if (f_status) { ffrprt (stderr, f_status); aXe_message (aXe_M_FATAL, __FILE__, __LINE__, "get_ALL_from_next_in_SPC: Error getting index keyword OBJECTID"); } *beamID = (int)tmp; // check whether this beam should be correct if (*beamID > CORRMAX) { // set it to NULL and return SPC = NULL; // fprintf (stdout, "aXe_PETFF: Skipping beam: %c.\n", BEAM(*beamID)); return SPC; } // the beam shall be corrected and // first must be read in SPC = (full_spectr *) malloc (sizeof (full_spectr )); // transfer the beam ID SPC->beamID = (int)tmp; // read the aperture number fits_read_key_lng (SPC_ptr, "OBJECTID", &tmp, comment, &f_status); if (f_status) { ffrprt (stderr, f_status); aXe_message (aXe_M_FATAL, __FILE__, __LINE__, "get_ALL_from_next_in_SPC: Error getting index keyword OBJECTID"); } // transfer the aperture ID *aperID = (int)tmp; SPC->aperID = (int)tmp; // Get the number of rows fits_get_num_rows (SPC_ptr, &tmp, &f_status); if (f_status) { ffrprt (stderr, f_status); aXe_message (aXe_M_FATAL, __FILE__, __LINE__, "get_ALL_from_next_in_SPC: " "Could not determine the number of rows in" " correction function table!"); } SPC->nelems = (int)tmp; // load the background subtracted object spectrum SPC->obj_spec = get_spectrum_from_SPC(SPC_ptr, "COUNT", "ERROR", SPC->nelems); // load the total object spectrum SPC->fgr_spec = get_spectrum_from_SPC(SPC_ptr, "TCOUNT", "TERROR", SPC->nelems); // load the background spectrum SPC->bck_spec = get_spectrum_from_SPC(SPC_ptr, "BCOUNT", "BERROR", SPC->nelems); // return the filled structure return SPC; }
int main(int argc, char *argv[]) { static struct option long_opts[] = { {"start", 1, NULL, 's'}, {"end", 1, NULL, 'e'}, {0,0,0,0} }; fitsfile *infptr, *outfptr; /* FITS file pointers defined in fitsio.h */ int opt, opti; int i, status = 0, ii = 1, jj=1; /* status must always be initialized = 0 */ int lo_row, hi_row; unsigned char *buffer = 0; long nrows; int ncols; int tfields; long pcount; char extname[FLEN_VALUE]; char *ttype[NFIELDS_I]; char *tform[NFIELDS_I]; char *tunit[NFIELDS_I]; char *tcomm[NFIELDS_I]; float start=0.0, end=1.0; while ((opt=getopt_long(argc,argv,"s:e:h",long_opts,&opti))!=-1) { switch (opt) { case 's': start = atof(optarg); break; case 'e': end = atof(optarg); break; case 'h': default: usage(); exit(0); break; } } if (argc < 3) { usage(); return(0); } //printf("> %s %s\n", argv[1], argv[2]); //printf("> %s %s\n", argv[optind], argv[2]); /* Allocate space for the table parameters and initialize */ for (i=0; i<NFIELDS_I; i++) { ttype[i] = (char *) malloc(FLEN_VALUE*sizeof(char)); tform[i] = (char *) malloc(FLEN_VALUE*sizeof(char)); tunit[i] = (char *) malloc(FLEN_VALUE*sizeof(char)); tcomm[i] = (char *) malloc(FLEN_CARD*sizeof(char)); strcpy(ttype[i], " "); } /* Open the input file */ if ( !fits_open_file(&infptr, argv[optind], READONLY, &status) ) { /* Create the output file */ if ( !fits_create_file(&outfptr, argv[optind+1], &status) ) { /* Copy every HDU until we get an error */ //while( !fits_movabs_hdu(infptr, ii++, NULL, &status) ) /* Copy first HDU */ fits_copy_hdu(infptr, outfptr, 0, &status); fits_movnam_hdu(infptr, BINARY_TBL, "SUBINT", 0, &status); fits_get_num_rows(infptr, &nrows, &status); printf("Number of rows = %ld\n", nrows); fits_get_num_cols(infptr, &ncols, &status); printf("Number of cols = %d\n", ncols); long width; fits_read_key(infptr, TLONG, "NAXIS1", &width, NULL, &status); printf("Width = %ld\n", width); buffer = (unsigned char *) malloc(width); /* Copy the fits header */ fits_copy_header(infptr, outfptr, &status); //#if 0 /* Determine low and high row number ot copy */ lo_row = 1 + start * nrows; hi_row = end * nrows; printf("lo_row=%d hi_row=%d\n", lo_row, hi_row); for (ii=lo_row, jj=1; ii<=hi_row; ii++, jj++) { printf("\rRead %d/%ld", ii, nrows); fits_read_tblbytes( infptr, ii, 1, width, buffer, &status); fits_write_tblbytes(outfptr, jj, 1, width, buffer, &status); } nrows = (hi_row-lo_row)+1; fits_update_key(outfptr, TLONG, "NAXIS2", &nrows, 0, &status); printf("\nDone\n"); //#endif /* Reset status after normal error */ //if (status == END_OF_FILE) status = 0; fits_close_file(outfptr, &status); } fits_close_file(infptr, &status); } /* if error occured, print out error message */ if (status) fits_report_error(stderr, status); return(status); }
int quickfits_read_map_header(const char* filename , fitsinfo_map* fitsi) { /* Read in map header information INPUTS: char* tfilename : c string = name of FITS file to be read OUTPUTS: ra = right ascention dec = declination object = name of source freq = frequency cell = cellsize (degrees) dim = image size bmaj, bmin, bpa = beam information (degrees) */ fitsfile *fptr; int status,i,j; int err; char comment[FLEN_VALUE]; char key_name[FLEN_VALUE]; char key_type[FLEN_VALUE]; char beamhdu[]="AIPS CG "; char cchdu[]="AIPS CC "; char bmajname[]="BMAJ"; char bminname[]="BMIN"; char bpaname[]="BPA"; int colnum; double temp; float floatbuff; float float_null=0; int int_null=0; long longbuff; status = 0; // for error processing err=0; if ( fits_open_file(&fptr,filename, READONLY, &status) ) // open file and make sure it's open { printf("ERROR : quickfits_read_map_header --> Error opening FITS file, error = %d\n",status); return(status); } if (fits_movabs_hdu(fptr,1,&i,&status)) // move to main AIPS image HDU (assuming it's the first one) { printf("ERROR : quickfits_read_map_header --> Error locating AIPS ACSII table extension, error = %d\n",status); printf("ERROR : quickfits_read_map_header --> Did you remember to use the AIPS FITAB task instead of FITTP?\n"); return(status); } // read in some optional keys (these may fail on strange files - but are not that important) fits_read_key(fptr,TSTRING,"OBJECT",fitsi[0].object,comment,&status); fits_read_key(fptr,TSTRING,"OBSERVER",fitsi[0].observer,comment,&status); fits_read_key(fptr,TSTRING,"TELESCOP",fitsi[0].telescope,comment,&status); fits_read_key(fptr,TDOUBLE,"EQUINOX",&fitsi[0].equinox,comment,&status); fits_read_key(fptr,TSTRING,"DATE-OBS",fitsi[0].date_obs,comment,&status); // Now iterate through CTYPE coords to get important information about RA, DEC, cellsize etc. // Most of this data is important - at least notify the user if some is missing i=1; status=0; j=0; while(status!=KEY_NO_EXIST) { if(status != 0) { printf("ERROR : quickfits_read_map_header --> Error reading from %s\n", filename); printf("ERROR : quickfits_read_map_header --> FITSIO error code: %d\n", status); return(1); } sprintf(key_name,"CTYPE%d",i); fits_read_key(fptr,TSTRING,key_name,key_type,comment,&status); if( !strncmp(key_type,"RA---SIN",8) ) { j++; sprintf(key_name,"CRVAL%d",i); fits_read_key(fptr,TDOUBLE,key_name,&fitsi[0].ra,comment,&status); if(status==KEY_NO_EXIST) { printf("WARNING : quickfits_read_map_header --> Missing RA information %s\n",key_name); status= 0; } sprintf(key_name,"CDELT%d",i); fits_read_key(fptr,TDOUBLE,key_name,&temp,comment,&status); if(status==KEY_NO_EXIST) { printf("WARNING : quickfits_read_map_header --> Missing RA information %s\n",key_name); status= 0; } else { fitsi[0].cell_ra=fabs(temp); } sprintf(key_name,"CRPIX%d",i); fits_read_key(fptr,TDOUBLE,key_name,&temp,comment,&status); if(status==KEY_NO_EXIST) { printf("WARNING : quickfits_read_map_header --> Missing RA information %s\n",key_name); status= 0; } else { fitsi[0].centre_shift[0]=temp; } sprintf(key_name,"CROTA%d",i); fits_read_key(fptr,TDOUBLE,key_name,&temp,comment,&status); if(status==KEY_NO_EXIST) { printf("WARNING : quickfits_read_map_header --> Missing RA information %s\n",key_name); status= 0; } else { fitsi[0].rotations[0]=temp; } } if( !strncmp(key_type,"DEC--SIN",8) ) { j++; sprintf(key_name,"CRVAL%d",i); fits_read_key(fptr,TDOUBLE,key_name,&fitsi[0].dec,comment,&status); if(status==KEY_NO_EXIST) { printf("WARNING : quickfits_read_map_header --> Missing DEC information %s\n",key_name); status = 0; } sprintf(key_name,"CDELT%d",i); fits_read_key(fptr,TDOUBLE,key_name,&temp,comment,&status); if(status==KEY_NO_EXIST) { printf("WARNING : quickfits_read_map_header --> Missing RA information %s\n",key_name); status= 0; } else { fitsi[0].cell_dec=fabs(temp); } sprintf(key_name,"CRPIX%d",i); fits_read_key(fptr,TDOUBLE,key_name,&temp,comment,&status); if(status==KEY_NO_EXIST) { printf("WARNING : quickfits_read_map_header --> Missing DEC information %s\n",key_name); status = 0; } else { fitsi[0].centre_shift[1]=temp; } sprintf(key_name,"CROTA%d",i); fits_read_key(fptr,TDOUBLE,key_name,&temp,comment,&status); if(status==KEY_NO_EXIST) { printf("WARNING : quickfits_read_map_header --> Missing DEC information %s\n",key_name); status = 0; } else { fitsi[0].rotations[1]=temp; } } if( !strncmp(key_type,"FREQ",4) ) { j++; sprintf(key_name,"CRVAL%d",i); fits_read_key(fptr,TDOUBLE,key_name,&fitsi[0].freq,comment,&status); if(status==KEY_NO_EXIST) { printf("WARNING : quickfits_read_map_header --> Missing FREQ information %s\n",key_name); status = 0; } sprintf(key_name,"CDELT%d",i); fits_read_key(fptr,TDOUBLE,key_name,&fitsi[0].freq_delta,comment,&status); if(status==KEY_NO_EXIST) { printf("WARNING : quickfits_read_map_header --> Missing FREQ information %s\n",key_name); status = 0; } } if( !strncmp(key_type,"STOKES",6) ) { sprintf(key_name,"CRVAL%d",i); fits_read_key(fptr,TDOUBLE,key_name,&temp,comment,&status); if(status==KEY_NO_EXIST) { printf("WARNING : quickfits_read_map_header --> Missing Stokes information %s\n",key_name); status = 0; } else { fitsi[0].stokes=(int)(temp); } } i++; } status=0; if(j!=3) { printf("WARNING : quickfits_read_map_header --> Error reading RA, DEC, FREQ information\n"); printf("\t Only %d out of 3 read.\n",j); } fits_read_key(fptr,TDOUBLE,"NAXIS1",&temp,comment,&status); fitsi[0].imsize_ra=(int)(temp); // dim is stored as a double in the FITS file fits_read_key(fptr,TDOUBLE,"NAXIS2",&temp,comment,&status); fitsi[0].imsize_dec=(int)(temp); // dim is stored as a double in the FITS file if(status!=0) { printf("ERROR : quickfits_read_map_header --> Error reading image size from NAXIS1, error = %d\n",err); return(err); } fitsi[0].have_beam = true; // assume true until proved otherwise fits_read_key(fptr,TDOUBLE,"BMAJ",&fitsi[0].bmaj,comment,&status); err += status; fits_read_key(fptr,TDOUBLE,"BMIN",&fitsi[0].bmin,comment,&status); err += status; fits_read_key(fptr,TDOUBLE,"BPA",&fitsi[0].bpa,comment,&status); err += status; if(err!=0) // if the beam information isn't in the main header, move to AIPS CG HDU for beam information { status=0; if (fits_movnam_hdu(fptr,BINARY_TBL,beamhdu,0,&status)) // move to beam information hdu { printf("WARNING : quickfits_read_map_header --> No beam information found.\n"); fitsi[0].bmaj = 0.0; fitsi[0].bmin = 0.0; // changed this because model files don't have any beam information. Should check to make sure beam info is valid in other code fitsi[0].bpa = 0.0; fitsi[0].have_beam = false; } else { fits_get_colnum(fptr,CASEINSEN,bmajname,&colnum,&status); if(status!=0) { printf("ERROR : quickfits_read_map_header --> Error locating BMAJ information, error = %d\n",status); return(err); } fits_read_col(fptr,TFLOAT,colnum,1,1,1,&float_null,&floatbuff,&int_null,&status); if(status!=0) { printf("ERROR : quickfits_read_map_header --> Error reading BMAJ information, error = %d\n",status); return(err); } else { fitsi[0].bmaj=(double)(floatbuff); } fits_get_colnum(fptr,CASEINSEN,bminname,&colnum,&status); if(status!=0) { printf("ERROR : quickfits_read_map_header --> Error locating BMIN information, error = %d\n",status); return(err); } fits_read_col(fptr,TFLOAT,colnum,1,1,1,&float_null,&floatbuff,&int_null,&status); if(status!=0) { printf("ERROR : quickfits_read_map_header --> Error reading BMIN information, error = %d\n",status); return(err); } else { fitsi[0].bmin=(double)(floatbuff); } fits_get_colnum(fptr,CASEINSEN,bpaname,&colnum,&status); if(status!=0) { printf("ERROR : quickfits_read_map_header --> Error locating BPA information, error = %d\n",status); return(err); } fits_read_col(fptr,TFLOAT,colnum,1,1,1,&float_null,&floatbuff,&int_null,&status); if(status!=0) { printf("ERROR : quickfits_read_map_header --> Error reading BPA information, error = %d\n",status); return(err); } else { fitsi[0].bpa=(double)(floatbuff); } } } // move to AIPS CC HDU for clean component information if requested. Read, or give error if a failure occurs. Allow for possibility of the outdated "A3DTABLE" table type 6 as well as normal BINARY_TBL if (fitsi[0].cc_table_version >=0 ) { fits_movnam_hdu(fptr,ANY_HDU,cchdu,fitsi[0].cc_table_version,&status); if (status==0) // move to main AIPS UV hdu { fits_get_num_rows(fptr,&longbuff,&status); fitsi[0].ncc=longbuff; if(status!=0) { printf("ERROR : quickfits_read_map_header --> Error reading number of clean components, error = %d\n",status); return(status); } } else { printf("WARNING : quickfits_read_map_header --> No clean component table detected.\n"); fitsi[0].ncc=0; return(status); } } else { fitsi[0].ncc=0; } status=0; if ( fits_close_file(fptr, &status) ) { printf("ERROR : quickfits_read_map_header --> Error closing FITS file, error = %d\n",status); return(status); } return(status); }
/** * Function: load_SED_from_fitsext * The function creates a energy distribution from the data stored * in a fits file extension. The data must be stored in the columns * "wavelength" and "flux". * * Parameters: * @param spectral_models_file - pathname to the spectral models file * @param s_models - pointer to the fits file extension * * Returns: * @return sed - the energy distribution created */ energy_distrib * load_SED_from_fitsext(const char spectral_models_file[], fitsfile *s_models) { int f_status=0; int anynul; long nrows=0; int colnum1; int colnum2; energy_distrib *sed; double *sed_wavs; double *sed_flux; // allocate memory for the energy distribution sed = (energy_distrib *) malloc(sizeof(energy_distrib)); // get number of rows fits_get_num_rows (s_models, &nrows, &f_status); if (f_status) { ffrprt (stderr, f_status); aXe_message (aXe_M_FATAL, __FILE__, __LINE__, "load_SED_from_fitsext: " "Could not determine the number of rows in" " table %s",spectral_models_file); } // allocate memory for the data sed_wavs = (double *) malloc(nrows*sizeof(double)); if (!sed_wavs) { aXe_message (aXe_M_ERROR, __FILE__, __LINE__, "Memory allocation failed"); } sed_flux = (double *) malloc(nrows*sizeof(double)); if (!sed_flux) { aXe_message (aXe_M_ERROR, __FILE__, __LINE__, "Memory allocation failed"); } // get the column number for the wavelength fits_get_colnum (s_models, CASEINSEN, "WAV_NM", &colnum1, &f_status); if (f_status) { ffrprt (stderr, f_status); aXe_message (aXe_M_FATAL, __FILE__, __LINE__, "create_interp_ftable: " "Could not determine column %s in " " table %s", "WAV_NM", spectral_models_file); } // read the wavelength fits_read_col (s_models, TDOUBLE, colnum1, 1, 1, nrows, NULL, sed_wavs, &anynul, &f_status); if (f_status) { ffrprt (stderr, f_status); aXe_message (aXe_M_FATAL, __FILE__, __LINE__, "load_SED_from_fitsext: " "Could not read content of WAVELENGTH column " " from BINARY table %s", spectral_models_file); } // get the column number for the flux fits_get_colnum (s_models, CASEINSEN, "FLUX", &colnum2, &f_status); if (f_status) { ffrprt (stderr, f_status); aXe_message (aXe_M_FATAL, __FILE__, __LINE__, "create_interp_ftable: " "Could not determine column %s in " " table %s", "FLUX", spectral_models_file); } // read the flux column fits_read_col (s_models, TDOUBLE, colnum2, 1, 1, nrows, NULL, sed_flux, &anynul, &f_status); if (f_status) { ffrprt (stderr, f_status); aXe_message (aXe_M_FATAL, __FILE__, __LINE__, "load_SED_from_fitsext: " "Could not read content of FLUX column " " from BINARY table %s", spectral_models_file); } // transfer the vector and length information // to the SED object sed->npoints = nrows; sed->wavelength = sed_wavs ; sed->flux = sed_flux; // allocate some structures for the interpolator sed->interp = gsl_interp_alloc (SMODEL_INTERP_TYPE, (size_t)sed->npoints ); sed->accel = gsl_interp_accel_alloc (); // initialize the iterpolator gsl_interp_init (sed->interp, sed->wavelength, sed->flux, (size_t)sed->npoints); // return the energy distribution return sed; }
str FITSloadTable(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci) { mvc *m = NULL; sql_schema *sch; sql_table *fits_fl, *fits_tbl, *tbl = NULL; sql_column *col; sql_subtype tpe; fitsfile *fptr; str tname = *(str*)getArgReference(stk, pci, 1); str fname; str msg = MAL_SUCCEED; oid rid = oid_nil, frid = oid_nil; int status = 0, cnum = 0, fid, hdu, hdutype, i, j, anynull = 0, mtype; int *tpcode = NULL; long *rep = NULL, *wid = NULL, rows; char keywrd[80], **cname, nm[FLEN_VALUE]; ptr nilptr; msg = getSQLContext(cntxt, mb, &m, NULL); if (msg) return msg; sch = mvc_bind_schema(m, "sys"); fits_tbl = mvc_bind_table(m, sch, "fits_tables"); if (fits_tbl == NULL) { msg = createException(MAL, "fits.loadtable", "FITS catalog is missing.\n"); return msg; } tbl = mvc_bind_table(m, sch, tname); if (tbl) { msg = createException(MAL, "fits.loadtable", "Table %s is already created.\n", tname); return msg; } col = mvc_bind_column(m, fits_tbl, "name"); rid = table_funcs.column_find_row(m->session->tr, col, tname, NULL); if (rid == oid_nil) { msg = createException(MAL, "fits.loadtable", "Table %s is unknown in FITS catalog. Attach first the containing file\n", tname); return msg; } /* Open FITS file and move to the table HDU */ col = mvc_bind_column(m, fits_tbl, "file_id"); fid = *(int*)table_funcs.column_find_value(m->session->tr, col, rid); fits_fl = mvc_bind_table(m, sch, "fits_files"); col = mvc_bind_column(m, fits_fl, "id"); frid = table_funcs.column_find_row(m->session->tr, col, (void *)&fid, NULL); col = mvc_bind_column(m, fits_fl, "name"); fname = (char *)table_funcs.column_find_value(m->session->tr, col, frid); if (fits_open_file(&fptr, fname, READONLY, &status)) { msg = createException(MAL, "fits.loadtable", "Missing FITS file %s.\n", fname); return msg; } col = mvc_bind_column(m, fits_tbl, "hdu"); hdu = *(int*)table_funcs.column_find_value(m->session->tr, col, rid); fits_movabs_hdu(fptr, hdu, &hdutype, &status); if (hdutype != ASCII_TBL && hdutype != BINARY_TBL) { msg = createException(MAL, "fits.loadtable", "HDU %d is not a table.\n", hdu); fits_close_file(fptr, &status); return msg; } /* create a SQL table to hold the FITS table */ /* col = mvc_bind_column(m, fits_tbl, "columns"); cnum = *(int*) table_funcs.column_find_value(m->session->tr, col, rid); */ fits_get_num_cols(fptr, &cnum, &status); tbl = mvc_create_table(m, sch, tname, tt_table, 0, SQL_PERSIST, 0, cnum); tpcode = (int *)GDKzalloc(sizeof(int) * cnum); rep = (long *)GDKzalloc(sizeof(long) * cnum); wid = (long *)GDKzalloc(sizeof(long) * cnum); cname = (char **)GDKzalloc(sizeof(char *) * cnum); for (j = 1; j <= cnum; j++) { /* fits_get_acolparms(fptr, j, cname, &tbcol, tunit, tform, &tscal, &tzero, tnull, tdisp, &status); */ snprintf(keywrd, 80, "TTYPE%d", j); fits_read_key(fptr, TSTRING, keywrd, nm, NULL, &status); if (status) { snprintf(nm, FLEN_VALUE, "column_%d", j); status = 0; } cname[j - 1] = GDKstrdup(toLower(nm)); fits_get_coltype(fptr, j, &tpcode[j - 1], &rep[j - 1], &wid[j - 1], &status); fits2subtype(&tpe, tpcode[j - 1], rep[j - 1], wid[j - 1]); /* mnstr_printf(cntxt->fdout,"#%d %ld %ld - M: %s\n", tpcode[j-1], rep[j-1], wid[j-1], tpe.type->sqlname); */ mvc_create_column(m, tbl, cname[j - 1], &tpe); } /* data load */ fits_get_num_rows(fptr, &rows, &status); mnstr_printf(cntxt->fdout,"#Loading %ld rows in table %s\n", rows, tname); for (j = 1; j <= cnum; j++) { BAT *tmp = NULL; int time0 = GDKms(); mtype = fits2mtype(tpcode[j - 1]); nilptr = ATOMnil(mtype); col = mvc_bind_column(m, tbl, cname[j - 1]); tmp = BATnew(TYPE_void, mtype, rows); if ( tmp == NULL){ GDKfree(tpcode); GDKfree(rep); GDKfree(wid); GDKfree(cname); throw(MAL,"fits.load", MAL_MALLOC_FAIL); } BATseqbase(tmp, 0); if (rows > (long)REMAP_PAGE_MAXSIZE) BATmmap(tmp, STORE_MMAP, STORE_MMAP, STORE_MMAP, STORE_MMAP, 0); if (mtype != TYPE_str) { fits_read_col(fptr, tpcode[j - 1], j, 1, 1, rows, nilptr, (void *)BUNtloc(bat_iterator(tmp), BUNfirst(tmp)), &anynull, &status); BATsetcount(tmp, rows); tmp->tsorted = 0; tmp->trevsorted = 0; } else { /* char *v = GDKzalloc(wid[j-1]);*/ int bsize = 50; int tm0, tloadtm = 0, tattachtm = 0; int batch = bsize, k; char **v = (char **) GDKzalloc(sizeof(char *) * bsize); for(i = 0; i < bsize; i++) v[i] = GDKzalloc(wid[j-1]); for(i = 0; i < rows; i += batch) { batch = rows - i < bsize ? rows - i: bsize; tm0 = GDKms(); fits_read_col(fptr, tpcode[j - 1], j, 1 + i, 1, batch, nilptr, (void *)v, &anynull, &status); tloadtm += GDKms() - tm0; tm0 = GDKms(); for(k = 0; k < batch ; k++) BUNappend(tmp, v[k], TRUE); tattachtm += GDKms() - tm0; } for(i = 0; i < bsize ; i++) GDKfree(v[i]); GDKfree(v); mnstr_printf(cntxt->fdout,"#String column load %d ms, BUNappend %d ms\n", tloadtm, tattachtm); } if (status) { char buf[FLEN_ERRMSG + 1]; fits_read_errmsg(buf); msg = createException(MAL, "fits.loadtable", "Cannot load column %s of %s table: %s.\n", cname[j - 1], tname, buf); break; } mnstr_printf(cntxt->fdout,"#Column %s loaded for %d ms\t", cname[j-1], GDKms() - time0); store_funcs.append_col(m->session->tr, col, tmp, TYPE_bat); mnstr_printf(cntxt->fdout,"#Total %d ms\n", GDKms() - time0); BBPunfix(tmp->batCacheid); } GDKfree(tpcode); GDKfree(rep); GDKfree(wid); GDKfree(cname); fits_close_file(fptr, &status); return msg; }
bool WMAPSource::initFile( ) { bool bRetVal = true; int iResult = 0; _numFrames = 0; if( !_filename.isNull( ) && !_filename.isEmpty( ) ) { QString str; fitsfile* ffits; int iStatus = 0; iResult = fits_open_file( &ffits, _filename.ascii( ), READONLY, &iStatus ); if( iResult == 0 ) { int iNumHeaderDataUnits; if( fits_get_num_hdus( ffits, &iNumHeaderDataUnits, &iStatus ) == 0 ) { long lNumBaseRows = 0; long lNumRows; int iHDUType; int i; // // determine the number of frames... // for( i=0; i<iNumHeaderDataUnits-1; i++ ) { if( iStatus == 0 ) { fits_get_hdu_type( ffits, &iHDUType, &iStatus ); if( iHDUType == BINARY_TBL || iHDUType == ASCII_TBL ) { iResult = fits_get_num_rows( ffits, &lNumRows, &iStatus ); if( iResult == 0 ) { if( lNumBaseRows == 0 ) { lNumBaseRows = lNumRows; } else if( lNumRows != 1 ) { if( lNumRows < lNumBaseRows ) { lNumBaseRows = lNumRows; } } } } fits_movrel_hdu( ffits, 1, &iHDUType, &iStatus ); } } fits_movabs_hdu( ffits, 1, &iHDUType, &iStatus); field *fld = new field; fld->table = 0; fld->column = 0; fld->entry = 0; fld->entries = 0; fld->numSamplesPerFrame = 1; fld->numFrames = lNumBaseRows; _fields.insert( "INDEX", fld ); _fieldList.append( "INDEX" ); // // add the fields and metadata... // for( i=0; i<iNumHeaderDataUnits-1; i++ ) { if( iStatus == 0 ) { addToMetadata( ffits, iStatus ); // // create the field entries... // fits_get_hdu_type( ffits, &iHDUType, &iStatus ); if( iStatus == 0 ) { if( iHDUType == BINARY_TBL || iHDUType == ASCII_TBL ) { int iNumCols; iResult = fits_get_num_cols( ffits, &iNumCols, &iStatus ); if( iResult == 0 ) { iResult = fits_get_num_rows( ffits, &lNumRows, &iStatus ); if( iResult == 0 ) { if( lNumRows > 1 ) { addToFieldList( ffits, iNumCols, lNumRows, lNumBaseRows, iStatus ); } else if( lNumRows == 1 ) { addToMetadata( ffits, iNumCols, iStatus ); } } } } } fits_movrel_hdu( ffits, 1, &iHDUType, &iStatus); } } } iStatus = 0; updateNumFramesScalar( ); fits_close_file( ffits, &iStatus ); } } return bRetVal; }
long table::get_num_rows(){ long nrows; fits_get_num_rows(fptr, &nrows, &status); return nrows; }
long get_num_of_rows(fitsfile * fptr) { long result = 0; fits_get_num_rows(fptr, &result, &fitsio_status); return result; }
KstObject::UpdateType LFIIOSource::update( int u ) { Q_UNUSED( u ) KstObject::UpdateType updateType = KstObject::NO_CHANGE; QString strTemplate; QString strName; fitsfile* ffits; char charTemplate[ FLEN_CARD ]; char charName[ FLEN_CARD ]; long lNumFrames; long lMaxRepeat = 1; long lRepeat; long lWidth; int iColNumber; int iNumCols; int iStatus = 0; int iResult = 0; int iTypeCode; int i; _valid = false; if( !_filename.isNull( ) && !_filename.isEmpty( ) ) { iResult = fits_open_table( &ffits, _filename.ascii( ), READONLY, &iStatus ); if( iResult == 0 ) { // // determine size of data... // iResult = fits_get_num_cols( ffits, &iNumCols, &iStatus ); if( iResult == 0 ) { iResult = fits_get_num_rows( ffits, &lNumFrames, &iStatus ); if( iResult == 0 ) { _strListColNames.clear( ); _valid = true; // // need to multiply lNumFrames by the maximum value of the vector repeat value... // for( i=0; i<iNumCols; i++ ) { iStatus = 0; sprintf( charTemplate, "%d", i+1 ); iResult = fits_get_colname( ffits, CASEINSEN, charTemplate, charName, &iColNumber, &iStatus ); if( iResult == 0 ) { strName = charName; _strListColNames.append( strName ); } else { strName.setNum( i ); _strListColNames.append( strName ); } iStatus = 0; iResult = fits_get_coltype( ffits, i+1, &iTypeCode, &lRepeat, &lWidth, &iStatus ); if( iResult == 0 ) { if( lRepeat > lMaxRepeat ) { lMaxRepeat = lRepeat; } } } if( lNumFrames * lMaxRepeat != _numFrames ) { _numCols = iNumCols; _numFrames = lNumFrames * lMaxRepeat; updateType = KstObject::UPDATE; } } } iStatus = 0; fits_close_file( ffits, &iStatus ); } } return updateType; }
Kst::Object::UpdateType LFIIOSource::update() { Kst::Object::UpdateType updateType = Kst::Object::NO_CHANGE; QString strTemplate; QString strName; fitsfile* ffits; char charTemplate[FLEN_CARD]; char charName[FLEN_CARD]; long lNumFrames; long lMaxRepeat = 1; long lRepeat; long lWidth; int iColNumber; int iNumCols; int iStatus = 0; int iResult = 0; int iTypeCode; int i; int newNF = 0; _valid = false; if(!_filename.isNull() && !_filename.isEmpty()) { iResult = fits_open_table( &ffits, _filename.ascii(), READONLY, &iStatus ); if(iResult == 0) { // determine size of data... iResult = fits_get_num_cols( ffits, &iNumCols, &iStatus ); if(iResult == 0) { iResult = fits_get_num_rows( ffits, &lNumFrames, &iStatus ); if(iResult == 0) { _fieldList.clear(); _fieldList.append("INDEX"); _valid = true; _bHasTime = false; // need to multiply lNumFrames by the maximum value of the vector repeat value... for(i = 0; i<iNumCols; i++) { iStatus = 0; sprintf(charTemplate, "%d", i+1); iResult = fits_get_colname( ffits, CASEINSEN, charTemplate, charName, &iColNumber, &iStatus ); if(iResult == 0) { int iOffset = i; strName = charName; // ensure that we don't add duplicates to the _fieldList... while(_fieldList.findIndex(strName) != -1) { strName = QString("%1[%2]").arg(charName).arg(iOffset); iOffset++; } } else { strName.setNum(i); } _fieldList.append(strName); iStatus = 0; iResult = fits_get_coltype( ffits, i+1, &iTypeCode, &lRepeat, &lWidth, &iStatus ); if(iResult == 0) { if(lRepeat > lMaxRepeat) { lMaxRepeat = lRepeat; } } } // check if we have a time field defined by the header keys TIMEZERO and DELTA_T. // If so then we create a new field called $TIME_FIELD, unless such a field already // exists, in which case we do nothing... char charTimeZero[] = "TIMEZERO"; iStatus = 0; iResult = fits_read_key( ffits, TDOUBLE, charTimeZero, &_dTimeZero, 0L, &iStatus ); if(iResult == 0) { char charTimeDelta[] = "DELTA_T"; iResult = fits_read_key( ffits, TDOUBLE, charTimeDelta, &_dTimeDelta, 0L, &iStatus ); if(iResult == 0) { if(_fieldList.find(QString(TIME_FIELD)) == _fieldList.end()) { _bHasTime = true; _fieldList.append(TIME_FIELD); } } } if(lNumFrames * lMaxRepeat != _numFrames) { _numCols = iNumCols; newNF = lNumFrames * lMaxRepeat; updateType = Kst::Object::UPDATE; } } } iStatus = 0; fits_close_file( ffits, &iStatus ); } } bool isnew = newNF != _numFrames; _numFrames = newNF; return (isnew ? Kst::Object::UPDATE : Kst::Object::NO_CHANGE); }
int countsmalibur(AG_params & params) { int numcol = 0; long nrows = 0; int status = 0; double l = 0, b = 0; double x = 0, y = 0; int i = 0, ii = 0; double the = 0; long mxdim= params.mxdim; // dimension (in pixels) of the map unsigned short A[mxdim][mxdim]; for (i = 0; i < mxdim; i++) { for (ii = 0; ii < mxdim; ii++) { A[i][ii] = 0; } } double baa = params.ba * D2R; double laa = params.la * D2R; int bitpix = USHORT_IMG; /* 16-bit unsigned short pixel values */ long naxis = 2; /* 2-dimensional image */ long naxes[2] = { mxdim, mxdim }; /* image is 300 pixels wide by 200 rows */ fitsfile * evtFits; char tempname[FLEN_FILENAME]; strcpy(tempname, tmpnam(NULL)); if ( fits_create_file(&evtFits, tempname, &status) != 0 ) { printf("Errore in apertura file %s\n",tempname); return status; } char expr[1024]; strcpy(expr,params.evtexpr().c_str()); std::cout << std::endl << "AG_ctsmapgen....................................adding events files"<< std::endl; status = addfile(evtFits, params.evtfile, expr, params.tmin, params.tmax); std::cout << "AG_ctsmapgen....................................addfile exiting STATUS : "<< status<< std::endl << std::endl ; fitsfile * mapFits; if ( fits_create_file(&mapFits, params.outfile, &status) != 0 ) { printf("Errore in apertura file '%s'\n",params.outfile); return status; } fits_movabs_hdu(evtFits, 2, NULL, &status); fits_get_num_rows(evtFits, &nrows, &status); cout << nrows << endl; double ra, dec; double dummy; switch (params.projection) { case AG_params::ARC: for (long k = 0; k<nrows; ++k) { fits_get_colnum(evtFits, 1, "RA", &numcol, &status); fits_read_col(evtFits, TDOUBLE, numcol, k+1, 1, 1, NULL, &ra, NULL, &status); fits_get_colnum(evtFits, 1, "DEC", &numcol, &status); fits_read_col(evtFits, TDOUBLE, numcol, k+1, 1, 1, NULL, &dec, NULL, &status); eulerold(ra, dec, &l, &b, 1); l*=D2R; b*=D2R; the = sin(b)*sin(baa)+cos(b)*cos(baa)*cos(l-laa); if (the < -1.0) { the = PI; } else if (the > 1.0) { the = 0.0; } else { the = acos(the); } x = R2D/Alikesinaa(the) * cos(b)*sin(l-laa); y = R2D/Alikesinaa(the) * (sin(b)*cos(baa) - cos(b)*sin(baa)*cos(l-laa)); i=(int)floor(((-x+(params.mdim/2.))/params.mres)); ii=(int)floor(((y+(params.mdim/2.))/params.mres)); if (params.inmap(i,ii)) { A[ii][i]+=1; } } break; case AG_params::AIT: for (long k = 0; k<nrows; ++k) { fits_get_colnum(evtFits, 1, "RA", &numcol, &status); fits_read_col(evtFits, TDOUBLE, numcol, k+1, 1, 1, NULL, &ra, NULL, &status); fits_get_colnum(evtFits, 1, "DEC", &numcol, &status); fits_read_col(evtFits, TDOUBLE, numcol, k+1, 1, 1, NULL, &dec, NULL, &status); eulerold(ra, dec, &l, &b, 1); l*=D2R; b*=D2R; the = sin(b)*sin(baa)+cos(b)*cos(baa)*cos(l-laa); if (the < -1.0) { the = PI; } else if (the > 1.0) { the = 0.0; } else { the = acos(the); } l=l-laa; if ( l < PI ) { l=-l; } else { l=2*PI -l; } x=R2D*(sqrt(2.0)*2.0*cos(b)*sin(l/2.0))/sqrt(1.0 + cos(b)*cos(l/2.0) ) ; y=R2D*(sqrt(2.0)*sin(b))/sqrt(1.0 + cos(b)*cos(l/2.0) ); i=(int)floor(((x+(params.mdim/2.))/params.mres)); ii=(int)floor(((y+(params.mdim/2.))/params.mres)); if (params.inmap(i,ii)) { A[ii][i]+=1; } } break; } long nelement = naxes[0] * naxes[1]; std::cout<< "creating Counts Map...................................." << std::endl; fits_create_img(mapFits, bitpix, naxis, naxes, &status); std::cout<< "writinig Counts Map...................................." << std::endl; fits_write_img(mapFits, bitpix, 1, nelement, A, &status); std::cout<< "writing header........................................" << std::endl<< std::endl; params.write_fits_header(mapFits, status); fits_delete_file(evtFits, &status); fits_close_file(mapFits, &status); return status; }
int main(int argc, char *argv[]) { fitsfile *infptr = 0, *outfptr = 0; /* FITS file pointers */ int status = 0; /* CFITSIO status value MUST be initialized to zero! */ int icol = 0, incols = 0, outcols = 0, intype = 0, outtype = 0, check = 1; long inrep = 0, outrep = 0, width = 0, inrows = 0, outrows = 0, ii = 0, jj = 0; unsigned char *buffer = 0; int printhelp = (argc == 2 && (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0)); if (printhelp || argc != 3) { fprintf(stderr, "Usage: %s infile1[ext][filter] outfile[ext]\n", argv[0]); fprintf(stderr, "\n"); fprintf(stderr, "Merge 2 tables by copying all the rows from the 1st table\n"); fprintf(stderr, "into the 2nd table. The 2 tables must have identical\n"); fprintf(stderr, "structure, with the same number of columns with the same\n"); fprintf(stderr, "datatypes. This program modifies the output file in place,\n"); fprintf(stderr, "rather than creating a whole new output file.\n"); fprintf(stderr, "\n"); fprintf(stderr, "Examples: \n"); fprintf(stderr, "\n"); fprintf(stderr, "1. %s intab.fit+1 outtab.fit+2\n", argv[0]); fprintf(stderr, "\n"); fprintf(stderr, " merge the table in the 1st extension of intab.fit with\n"); fprintf(stderr, " the table in the 2nd extension of outtab.fit.\n"); fprintf(stderr, "\n"); fprintf(stderr, "2. %s 'intab.fit+1[PI > 45]' outab.fits+2\n", argv[0]); fprintf(stderr, "\n"); fprintf(stderr, " Same as the 1st example, except only rows that have a PI\n"); fprintf(stderr, " column value > 45 will be merged into the output table.\n"); fprintf(stderr, "\n"); return (0); } /* open both input and output files and perform validity checks */ if (fits_open_file(&infptr, argv[1], READONLY, &status) || fits_open_file(&outfptr, argv[2], READWRITE, &status)) { fprintf(stderr, " Couldn't open both files\n"); } else if (fits_get_hdu_type(infptr, &intype, &status) || fits_get_hdu_type(outfptr, &outtype, &status)) { fprintf(stderr, "couldn't get the type of HDU for the files\n"); } else if (intype == IMAGE_HDU) { fprintf(stderr, "The input HDU is an image, not a table\n"); } else if (outtype == IMAGE_HDU) { fprintf(stderr, "The output HDU is an image, not a table\n"); } else if (outtype != intype) { fprintf(stderr, "Input and output HDUs are not the same type of table.\n"); } else if (fits_get_num_cols(infptr, &incols, &status) || fits_get_num_cols(outfptr, &outcols, &status)) { fprintf(stderr, "Couldn't get number of columns in the tables\n"); } else if (incols != outcols) { fprintf(stderr, "Input and output HDUs don't have same # of columns.\n"); } else if (fits_read_key(infptr, TLONG, "NAXIS1", &width, NULL, &status)) { fprintf(stderr, "Couldn't get width of input table\n"); } else if (!(buffer = (unsigned char *) malloc(width))) { fprintf(stderr, "memory allocation error\n"); } else if (fits_get_num_rows(infptr, &inrows, &status) || fits_get_num_rows(outfptr, &outrows, &status)) { fprintf(stderr, "Couldn't get the number of rows in the tables\n"); } else { /* check that the corresponding columns have the same datatypes */ for (icol = 1; icol <= incols; icol++) { fits_get_coltype(infptr, icol, &intype, &inrep, NULL, &status); fits_get_coltype(outfptr, icol, &outtype, &outrep, NULL, &status); if (intype != outtype || inrep != outrep) { fprintf(stderr, "Column %d is not the same in both tables\n", icol); check = 0; } } if (check && !status) { /* insert 'inrows' empty rows at the end of the output table */ fits_insert_rows(outfptr, outrows, inrows, &status); for (ii = 1, jj = outrows +1; ii <= inrows; ii++, jj++) { /* read row from input and write it to the output table */ fits_read_tblbytes(infptr, ii, 1, width, buffer, &status); fits_write_tblbytes(outfptr, jj, 1, width, buffer, &status); if (status) { break; /* jump out of loop if error occurred */ } } /* all done; now free memory and close files */ fits_close_file(outfptr, &status); fits_close_file(infptr, &status); } } if (buffer) { free(buffer); } if (status) { fits_report_error(stderr, status); /* print any error message */ } return (status); }
//int main ( int argc, char *argv[] ) int read_value ( char *name, int subint, double *value, int nphase, int nchan, int npol) { //double *read_arrival_time( char *input, long *nrows ) //int subint = 1; //double profile[8*1024]; fitsfile *fptr; // pointer to the FITS file, defined in fitsio.h int status; int colnum; long int nrows; status = 0; //if ( fits_open_file(&fptr, argv[1], READONLY, &status) ) // open the file if ( fits_open_file(&fptr, name, READONLY, &status) ) // open the file { printf( "error while openning file\n" ); } if ( fits_get_num_rows(fptr, &nrows, &status) ) // get the row number { printf( "error while getting the row number\n" ); } //printf ("%ld\n", nrows); //if ( fits_get_colnum(fptr, CASEINSEN, "TSUBINT", &colnum, &status) ) // get the row number if ( fits_get_colnum(fptr, CASEINSEN, "DATA", &colnum, &status) ) // get the row number { printf( "error while getting the colnum number\n" ); //fits_get_colnum(fptr, CASEINSEN, "DATA", &colnum, &status); } //printf ("%d\n", colnum); /////////////////////////////////////////////////////////////////////////// int nbin; int frow; int felem; int nelem; int null; int anynull; //double *profile; // the array to store the profile nbin = nphase; //profile = ( double *)malloc( (nchan*npol*nbin) * sizeof( double ) ); // allocate space for column value frow = subint; felem = 1; nelem = nbin*nchan*npol; //nelem = 1024; null = 0; anynull = 0; fits_read_col(fptr, TDOUBLE, colnum, frow, felem, nelem, &null, value, &anynull, &status); // read the column //int i; //for (i = 0; i < (nchan*npol*nbin); i++) // print the results // printf("%d %lf \n", i, profile[i]); if ( fits_close_file(fptr, &status) ) { printf( " error while closing the file " ); } return 0; }
void processFile(char *fname,tmplStruct *tmpl,FILE *fout,int logit) { pheader *header; ptime_observation *obs; toaStruct toa; fitsfile *fp; int i; float baselineFrac = 0.1; int baselineType = 1; int toaAlgorithm=1; double dPhi; double *offs_sub; double *datFreq; int nSub = 1; FILE *fout_log; char logFname[128]; long double period; sprintf(logFname,"log.ptime.%s",fname); fout_log = fopen(logFname,"w"); offs_sub = (double *)malloc(sizeof(double)*nSub); obs = (ptime_observation *)malloc(sizeof(ptime_observation)); header = (pheader *)malloc(sizeof(pheader)); fp = openFitsFile(fname); loadPrimaryHeader(fp,header); datFreq= (double *)malloc(sizeof(double)*header->nchan); allocateObsMemory(obs,header); readData(obs,header,fp); // Now get an array of subintegration times readSubintOffs(obs,offs_sub,fp); // Get an array of frequencies readDatFreq(obs,datFreq,fp,header->nchan); printf("offs_sub = %g\n",offs_sub[0]); // Calculate the period { FILE *pred_out; int status=0; long nrows,row; char nval[128]="UNKNOWN"; int anynul=0; long double mjd0; long double frequency; char **line; T2Predictor pred; int ret; line = (char **)malloc(sizeof(char *)); line[0] = (char *)malloc(sizeof(char)*1024); if (!(pred_out = fopen("ptime.pred","w"))){ printf("Unable to open file >%s<\n","ptime.pred"); } fits_movnam_hdu(fp,BINARY_TBL,(char *)"T2PREDICT",1,&status); if (status) { printf("No predictor table in PSRFITS file\n"); status=0; } fits_get_num_rows(fp,&nrows,&status); printf("NROWS = %d\n",nrows); for (row = 1; row <= nrows ; row++){ fits_read_col_str(fp,1,row,1,1,nval,line,&anynul,&status); printf("Have read %s\n",line[0]); fprintf(pred_out,"%s\n",line[0]); } free(line[0]); free(line); fclose(pred_out); T2Predictor_Init(&pred); // prepare the predictor if (ret=T2Predictor_Read(&pred,(char *)"ptime.pred")) { printf("Error: unable to read predictor\n"); exit(1); } mjd0 = header->imjd + (header->smjd + header->stt_offs)/86400.0L; frequency = datFreq[0]; //(freq in MHz) WHAT SHOULD THIS BE SET TO!! period = 1.0/T2Predictor_GetFrequency(&pred,mjd0,frequency); if (period==-1){ printf("Error: period returned from predictor = -1. This cannot be correct.\n"); exit(1); } T2Predictor_Destroy(&pred); printf("Period = %.15Lf %.15Lf %.15Lf\n",period,mjd0,frequency); } closeFitsFile(fp); // Must remove a baseline removeBaseline(obs,header,baselineType,baselineFrac); printf("Here\n"); // Now get the shift if (toaAlgorithm == 1) getTOA_alg1(obs,header,tmpl,&toa,fout_log); strcpy(toa.fname,fname); // Calculate the arrival time calcArrivalTime(obs,header,tmpl,&toa,offs_sub,datFreq,period,fout,fout_log); free(header); free(obs); free(offs_sub); free(datFreq); fclose(fout_log); }
int main(int argc, char *argv[]) { fitsfile *fptr = 0; /* FITS file pointer, defined in fitsio.h */ char keyname[FLEN_KEYWORD], colname[FLEN_VALUE], coltype[FLEN_VALUE]; int status = 0; /* CFITSIO status value MUST be initialized to zero! */ int single = 0, hdupos = 0, hdutype = 0, bitpix = 0, naxis = 0, ncols = 0, ii = 0; long naxes[10], nrows = 0; int printhelp = (argc == 2 && (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0)); if (printhelp || argc != 2) { fprintf(stderr, "Usage: %s filename[ext] \n", argv[0]); fprintf(stderr, "\n"); fprintf(stderr, "List the structure of a single extension, or, if ext is \n"); fprintf(stderr, "not given, list the structure of the entire FITS file. \n"); fprintf(stderr, "\n"); fprintf(stderr, "Note that it may be necessary to enclose the input file\n"); fprintf(stderr, "name in single quote characters on the Unix command line.\n"); return (0); } FILE *fout = popen(PAGER, "w"); if (fout == NULL) { fprintf(stderr, "Could not execute '%s'\n", PAGER); return (1); } if (!fits_open_file(&fptr, argv[1], READONLY, &status)) { fits_get_hdu_num(fptr, &hdupos); /* Get the current HDU position */ /* List only a single structure if a specific extension was given */ if (strchr(argv[1], '[') || strchr(argv[1], '+')) { single++; } for (; !status; hdupos++) { /* Main loop for each HDU */ fits_get_hdu_type(fptr, &hdutype, &status); /* Get the HDU type */ fprintf(fout, "\nHDU #%d ", hdupos); if (hdutype == IMAGE_HDU) { /* primary array or image HDU */ fits_get_img_param(fptr, 10, &bitpix, &naxis, naxes, &status); fprintf(fout, "Array: NAXIS = %d, BITPIX = %d\n", naxis, bitpix); for (ii = 0; ii < naxis; ii++) { fprintf(fout, " NAXIS%d = %ld\n",ii+1, naxes[ii]); } } else { /* a table HDU */ fits_get_num_rows(fptr, &nrows, &status); fits_get_num_cols(fptr, &ncols, &status); if (hdutype == ASCII_TBL) { fprintf(fout, "ASCII Table: "); } else { fprintf(fout, "Binary Table: "); } fprintf(fout, "%d columns x %ld rows\n", ncols, nrows); fprintf(fout, " COL NAME FORMAT\n"); for (ii = 1; ii <= ncols; ii++) { fits_make_keyn("TTYPE", ii, keyname, &status); /* make keyword */ fits_read_key(fptr, TSTRING, keyname, colname, NULL, &status); fits_make_keyn("TFORM", ii, keyname, &status); /* make keyword */ fits_read_key(fptr, TSTRING, keyname, coltype, NULL, &status); fprintf(fout, " %3d %-16s %-16s\n", ii, colname, coltype); } } if (single) { break; /* quit if only listing a single HDU */ } fits_movrel_hdu(fptr, 1, NULL, &status); /* try move to next ext */ } if (status == END_OF_FILE) { status = 0; /* Reset normal error */ } fits_close_file(fptr, &status); } pclose(fout); if (status) { fits_report_error(stderr, status); /* print any error message */ } return (status); }