Index: /tags/getstar-1-0/Ohana/src/getstar/Makefile =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/Makefile (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/Makefile (revision 2513) @@ -0,0 +1,60 @@ +include ../../Configure +HOME = $(ROOT)/src/getstar +PROGRAM = getstar + +BIN = $(HOME)/bin +INC = $(HOME)/include +SRC = $(HOME)/src +MAN = $(HOME)/doc +DESTBIN = $(LBIN) +DESTLIB = $(LLIB) +DESTINC = $(LINC) +DESTMAN = $(LMAN) + +# +INCS = -I$(INC) -I$(LINC) -I$(XINC) +LIBS = -L$(LLIB) -lFITS -lohana -lm +CFLAGS = -o $*.$(ARCH).o $(INCS) +CCFLAGS = $(INCS) $(LIBS) + +GETSTAR = \ +$(SRC)/getstar.$(ARCH).o $(SRC)/gcatalog.$(ARCH).o \ +$(SRC)/gregions.$(ARCH).o $(SRC)/gimages.$(ARCH).o \ +$(SRC)/wstars.$(ARCH).o $(SRC)/find_matches.$(ARCH).o \ +$(SRC)/sort_lists.$(ARCH).o $(SRC)/ConfigInit.$(ARCH).o \ +$(SRC)/aregion.$(ARCH).o $(SRC)/clean_stars.$(ARCH).o \ +$(SRC)/args.$(ARCH).o + +OBJ = $(GETSTAR) + +default: $(PROGRAM) + +$(GETSTAR): $(INC)/getstar.h + +# dependancy rules for binary code ########################## +$(PROGRAM): $(BIN)/$(PROGRAM).$(ARCH) + +$(BIN)/$(PROGRAM).$(ARCH): $(OBJ) + @if [ ! -d $(BIN) ]; then mkdir -p $(BIN); fi + $(CC) $(OBJ) -o $(BIN)/$(PROGRAM).$(ARCH) $(CCFLAGS) + +install: $(DESTBIN)/$(PROGRAM) + +$(DESTBIN)/$(PROGRAM): $(BIN)/$(PROGRAM).$(ARCH) + @if [ ! -d $(DESTBIN) ]; then mkdir -p $(DESTBIN); fi + rm -f $(DESTBIN)/$(PROGRAM) + cp $(BIN)/$(PROGRAM).$(ARCH) $(DESTBIN)/$(PROGRAM) + +# utilities ################################################# +clean: + rm -f $(BIN)/*.$(ARCH) + rm -f `find . -name "*.o"` + rm -f `find . -name "*~"` + rm -f `find . -name "#*"` + +.SUFFIXES: .$(ARCH).o + +.c.$(ARCH).o: + $(CC) $(CFLAGS) -c $< + + Index: /tags/getstar-1-0/Ohana/src/getstar/doc/database.txt =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/doc/database.txt (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/doc/database.txt (revision 2513) @@ -0,0 +1,91 @@ + +\begin{verbatim} + +typedef struct { + float R; /* RA in decimal degrees */ + float D; /* DEC in decimal degrees */ + short int M; /* thousandths of mag (-32.000 to 32.000 valid range) */ + unsigned short int Nm; /* number of measurements */ + unsigned short int Xp, Xm; /* chisq values in tenths */ + unsigned int offset; /* offset to first Measure-ment */ +} Average; /* = 20 bytes / average */ + +typedef struct { + char dR, dD; /* tenths of arcsec (-12.7 to +12.7 valid range) */ + short int M; /* thousandths of mag (-32.000 to 32.000 valid range) */ + unsigned char dM; /* thousandths of mag (0.000 -- 0.255 valid range) */ + float t; /* time in seconds (what is reference?) */ + unsigned int average; /* reference to corresponding Average entry, + upper byte of value contains flags. + limit of 16,777,215 stars (Naverage) + in a file (=0xFFFFFF). + flags = average & 0x1000000 */ +} Measure; /* = 13 bytes / measure */ + +# define BLEND_IMAGE 0X01000000 +# define BLEND_CATALOG 0X02000000 +# define UPPER_LIMIT 0X04000000 +# define CALIBRATED 0X08000000 + +\end{verbatim} + +The above two structures define the entries in the photometry +database. The database consists of a large number of files +representing a small patch on the sky (roughly 1.5 degree$^2$ in most +places). These files are organized into directories representing +bands of Declination. A reference file determines the coordinate +boundaries for each of the files so that a given point on the sky can +unambiguously be associated with a specific file in a specific +directory. The sky coordinates for each file is the same as those +used by the HST Guide Star catalog, except for the region around the +North celestial pole, for which all stars are included in a single +file. + +Within a given file, the data are stored in a binary format, with an +ASCII FITS-like header. The header is examply in the format of a +normal FITS header, but with the exception that all files have a fixed +number of header blocks (for now 3 blocks = 8640 bytes). This is done +to speed loading the header and finding the beginning of the binary +data. The number of 3 blocks seems quite generous, as currently only +a few FITS keywords have been defined for each file, basically +keywords to define the number of stars and the total number of +measurements stored in the file, as well as values to define the RA +and DEC range of the file. + +The first section of data following the header blocks consists of +average measurements for each uniquely observed star. Each star +occupies 20 bytes, the size of the Average structure defined above. +The Average structure contains the average Ra, Dec, and Magnitude for +the star, as well as the number of measurements, and \chisq\ values +for the magnitude and position. Finally, there is a 32 bit integer +which defines the offset to the first measurement for this star. This +offset is defined as the number of Measure records from the start of +the Measure structure. + +The second section of data, following the Average data contains all +measurements for each star listed in Average. Each measurement +occupies 13 bytes, the size of the Measure structure. This structure +contains the difference of this position from the average RA and DEC, +and the instrumental magnitude of this measurement (in the units +defined by the fstat program, which give m = -2.5*log(cts) + Mo, where +Mo is currently 24.5 [10/15]). There is also the magnitude error for +this measurement, the time of the measurement (in seconds relative to +a to-be-determined zero point), and a reference to the entry in the +Average structure so we can relate a given measurement with a given star. +This last entry also includes a byte of flags, of which only 4 have +currently been defined. This means the Average offset can only be as +large as 16,777,215 (0xffffff), limiting the possible number of stars +allowed in a given file. This does not seem like a long term problem, +though: aside from the fact that this number is very large and we +only expect in the vicinity of 20,000 stars per file, the file can +easily be divided into pieces at a later date if needed. this last +step is trivial, consisting of splitting the data up into smaller +RA,DEC regions, and updating the reference catalog. With the above +definitions for the Average and Measure structures, we will typically +expect 20,000 * 15 measurements per year and 20,000 average entries in +a given file. This implies a file size of about 4.3 MB at the end of +a year. It is also possible that we will choose to split the files up +in the future if the number of measurements makes their size +unweildy. 4.3 MB is sufficiently small that this is not a problem, +but after only 5 years, the files will be over 21 MB each, getting to +be fairly significant. Index: /tags/getstar-1-0/Ohana/src/getstar/doc/description.txt =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/doc/description.txt (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/doc/description.txt (revision 2513) @@ -0,0 +1,94 @@ + +ADDSTAR: + +This program takes a photometry file, with astrometry, provided by +earlier routines and incorporates the stellar measurements into the +photometry database. This routine does NOT try to calibrate or check +the photometry, nor does it try to improve the coordinate +determinations or calculate chisquares for position or photometry - +those tasks are performed by other routines. + +Addstar starts by loading in the photometry file and converting the +pixel coordinates to sky coordinates using the astrometry information +in the header of the file. It also gets the detection limits and +stores the image astrometry information. + +Next, addstar determines which of all the previous images overlaps +with this image and also which of the catalog regions overlaps with +this image. + +Addstar considers each catalog region in turn, and compares the +positions of stars in the catalog with stars in the image. If a +catalog star is detected, a new measurement is added to the catalog. +If a catalog star is not detected, but is in the field of view of this +image, the detection limit for this image is added to the list of +measurements as an upper limit. If the image contains a star which is +not already included in the catalog, the star is added to the catalog, +and all previous images are checked to see if they included this +location. If so, upper limits are added to the list of measurements. + +To deal with blended images, we have taken the philosophy that all +measurements compatible with the coordinates of a given star should be +included in the list of measurements. This assumes that programs or people +downstream will figure out which is the "correct" measurement. To +this end, if a catalog star is consistent with multiple measurements, +they are all added to the catalog measurement and the measurements are +given a flag to say that there was blending in the catalog (ie, it is +probably the catalog star which is a blend). If multiple catalog +stars are consistent with the same image star, that measurement is +added to each catalog star, and given a flag to say that there was +blending on the image. + +After all catalogs have been checked, updated, and written to disk, +the image is added to the database of images. + +The format for a catalog region file is as follows: + +-- +Header +-- +Averages +-- +Measurements +-- + +The Header follows the format of a FITS header but always stored with +3 blocks to speed up read time: 2880 x 3 bytes. Two important +keywords in the header: NSTARS & NMEAS + +All average values are stored consecutively in a single block. They +are written as an array with NSTARS elements of the Average structure +defined below. The individual measurements follow the averages as a +block. To find a measurement for a given star, you need to get the +value of the offset for the star. this is the element number for the +first measurement of this star, and are followed by next measurements +for this star, until the value Nm is reached. + +Here are the structures being used for the average and measurement +values: + +typedef struct { + float R; /* RA in decimal degrees */ + float D; /* DEC in decimal degrees */ + short int M; /* thousandths of mag (-32.000 to 32.000 valid range) */ + unsigned short int Nm; /* number of measurements */ + unsigned short int Xp, Xm; /* chisq values in tenths */ + unsigned int offset; /* offset to first measurement */ +} Average; /* = 20 bytes / average */ + +typedef struct { + char dR, dD; /* tenths of arcsec (-12.7 to +12.7 valid range) */ + short int M; /* thousandths of mag (-32.000 to 32.000 valid range) */ + unsigned char dM; /* thousandths of mag (0.000 -- 0.255 valid range) */ + float t; /* time in seconds (what is reference?) */ + unsigned int average; + /* reference to corresponding average entry, upper byte stores flags: + limit of 16,777,215 stars (Naverage) in a file (=0xFFFFFF) + flags: average & 0x1000000 */ +} Measure; /* = 13 bytes / measure */ + +/* flags for measurements: */ +# define BLEND_IMAGE 0X01000000 +# define BLEND_CATALOG 0X02000000 +# define UPPER_LIMIT 0X04000000 +# define CALIBRATED 0X08000000 Index: /tags/getstar-1-0/Ohana/src/getstar/etc/phottemp.cat =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/etc/phottemp.cat (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/etc/phottemp.cat (revision 2513) @@ -0,0 +1,296 @@ +SIMPLE = F / ASTROCAM PHOTOMETRY FILE \ +BITPIX = 16 / \ +NAXIS = 2 / NUMBER OF AXES \ +NAXIS1 = 1106 / NUMBER OF COLUMNS \ +NAXIS2 = 1024 / NUMBER OF ROWS \ +BSCALE = 1.000000 / \ +BZERO = 0.000000 / \ +DATE = '19/12/94' / UT Date of file creation (DD/MM/YY) \ +ORIGIN = 'MDM Observatory' / Michigan-Dartmouth-MIT \ +LATITUDE= 31.9500 / Latitude (degrees N) \ +LONGITUD= -111.6150 / Longitude (degrees E) \ +OBSERVER= 'Metzger ' / Name of observer \ +TELESCOP= '1.3m McGraw-Hill' / Telescope used for observation \ +INSTRUME= 'Charlotte Direct' / Instrument used for observation \ +DETECTOR= 'Charlotte/Tek 1024^2 CCD' / Detector used for observation \ +FRAME = 32 / Frame number of observation \ +CCDPICNO= 32 / Frame number of observation \ +OBJECT = 'ocl0327 ' / Name of object \ +IMAGETYP= 'OBJECT ' / Type of observation \ +EXPTIME = 250.000 / Integration time (seconds) \ +DARKTIME= 250.067 / Dark current time (seconds) \ +DATE-OBS= '19/12/94' / UT Date of observation (DD/MM/YY) \ +UT = ' 05:25:44.00' / Universal time (UTC) at exposure start \ +JD = 2449705.726204 \ +RA = 50.700 / Right Ascension \ +DEC = 89.000 / Declination \ +DIRECTN = -1 / Moving South \ +EQUINOX = 1950.000 / Equinox of RA and DEC \ +HA = ' 02:14:06.72' / Hour angle at start \ +ST = ' 03:49:36.85' / Sidereal time at start \ +ZD = ' 36:26:07.17' / Zenith distance (degrees) \ +AIRMASS = 1.243 / Airmass at start \ +FILTER = 'I KP ' / Filter description \ +GAIN = 3.350 / Nominal gain (e-/ADU) \ +SECPIX1 = 0.508 / Arcseconds per pixel in fast dir \ +SECPIX2 = 0.508 / Arcseconds per pixel in slow dir \ +CCDBIN1 = 1 / On-chip column binning (fast dir) \ +CCDBIN2 = 1 / On-chip row binning (slow dir) \ +GPROBE = ' 5000.00 7000.00' / Guide probe X Y \ +DATASEC = '[51:1074,1:1024]' / Image area of frame \ +CCDSEC = '[1:1074,1:1024]' / Image area relative to full chip \ +BIASSEC = '[1080:1106,1:1023]' / Overscan area of frame \ +UNSIGN = T / \ +NSTARS = 0 / NUMBER OF stars \ +CTYPE1 = 'RA---SIN ' / +CTYPE2 = 'DEC--SIN ' / +CDELT1 = 0.000733 / +CDELT2 = 0.000733 / +CRVAL1 = 50.191418 / +CRVAL2 = 88.998663 / +CRPIX1 = 1028.644173 / +CRPIX2 = 503.129830 / +PC001001= 0.999906 / +PC001002= 0.012081 / +PC002001= -0.011936 / +PC002002= 0.999950 / +END \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + 246.5 352.1 13.000 020 1 3.2 + 246.5 352.1 14.100 020 1 3.2 + 279.4 328.9 13.800 020 1 3.2 + 187.3 238.8 9.800 020 1 3.2 + 187.3 238.8 9.800 020 1 3.2 + 436.6 413.5 14.300 020 1 3.2 + 9.3 856.5 13.000 020 1 3.2 + 9.3 856.2 13.600 020 1 3.2 + 319.7 697.9 12.000 020 1 3.2 + 319.7 697.7 12.100 020 1 3.2 + 244.3 9.5 14.100 020 1 3.2 + 284.7 334.4 14.000 020 1 3.2 + 127.1 122.8 14.200 020 1 3.2 + 140.2 791.1 13.700 020 1 3.2 + 140.2 790.8 14.400 020 1 3.2 + 131.7 636.3 13.800 020 1 3.2 + 423.8 700.6 13.800 020 1 3.2 + 423.7 700.7 12.500 020 1 3.2 + 266.2 290.7 13.800 020 1 3.2 + 266.0 290.7 13.100 020 1 3.2 + 570.7 721.6 13.600 020 1 3.2 + 570.7 721.6 13.100 020 1 3.2 + 548.7 673.0 13.700 020 1 3.2 + 264.2 219.7 12.800 020 1 3.2 + 264.0 219.7 12.100 020 1 3.2 + 161.9 797.4 11.900 020 1 3.2 + 162.0 797.2 12.200 020 1 3.2 + 505.8 851.8 13.700 020 1 3.2 + 88.2 419.0 11.400 020 1 3.2 + 88.2 419.0 11.800 020 1 3.2 + 426.9 613.2 9.400 020 1 3.2 + 427.4 613.5 7.600 020 1 3.2 + 326.1 595.2 12.100 020 1 3.2 + 326.2 595.1 12.600 020 1 3.2 + 444.4 845.2 14.200 020 1 3.2 + 254.1 916.8 14.500 020 1 3.2 + 502.6 882.4 14.200 020 1 3.2 + 128.3 275.7 12.300 020 1 3.2 + 128.3 275.7 12.900 020 1 3.2 + 230.9 554.8 13.300 020 1 3.2 + 230.9 554.7 14.200 020 1 3.2 + 47.5 685.2 13.500 020 1 3.2 + 47.5 684.9 14.200 020 1 3.2 + 382.6 658.7 14.000 020 1 3.2 + 182.2 330.3 14.200 020 1 3.2 + 245.1 548.3 12.600 020 1 3.2 + 245.3 548.0 13.200 020 1 3.2 + 50.3 849.0 13.700 020 1 3.2 + 50.5 848.8 14.300 020 1 3.2 + 17.9 772.7 14.200 020 1 3.2 + 499.8 712.8 13.500 020 1 3.2 + 499.8 712.6 14.400 020 1 3.2 + 294.5 349.4 14.000 020 1 3.2 + 497.7 747.8 11.000 020 1 3.2 + 497.5 747.8 10.900 020 1 3.2 + 109.7 323.5 14.000 020 1 3.2 + 59.5 917.6 14.300 020 1 3.2 + 59.4 917.8 13.700 020 1 3.2 + 82.2 880.5 13.800 020 1 3.2 + 145.1 341.2 14.500 020 1 3.2 + 452.7 592.4 14.400 020 1 3.2 + 623.4 820.0 13.700 020 1 3.2 + 609.7 829.3 13.500 020 1 3.2 + 481.8 938.3 14.400 020 1 3.2 + 617.0 792.7 13.500 020 1 3.2 + 183.2 539.7 14.400 020 1 3.2 + 133.9 679.6 14.400 020 1 3.2 + 423.7 667.8 6.500 020 1 3.2 + 434.7 111.9 13.200 020 1 3.2 + 434.5 111.9 13.200 020 1 3.2 + 434.6 111.9 14.200 020 1 3.2 +1222.3 684.2 13.900 020 1 3.2 +1077.6 282.5 14.000 020 1 3.2 +1077.8 282.5 13.400 020 1 3.2 + 720.8 562.1 14.100 020 1 3.2 + 721.1 561.9 14.400 020 1 3.2 +1182.1 944.4 12.100 020 1 3.2 +1181.9 944.4 11.800 020 1 3.2 +1181.9 944.4 12.300 020 1 3.2 + 761.2 423.1 14.300 020 1 3.2 + 761.0 423.1 14.100 020 1 3.2 + 926.7 436.8 13.400 020 1 3.2 + 926.6 436.8 14.200 020 1 3.2 +1209.1 45.0 13.200 020 1 3.2 +1209.2 43.6 12.800 020 1 3.2 +1135.2 653.1 8.100 020 1 3.2 +1135.6 653.4 8.200 020 1 3.2 +1123.5 735.8 12.000 020 1 3.2 +1123.6 735.8 11.800 020 1 3.2 +1123.7 735.7 11.600 020 1 3.2 + 730.7 28.6 12.100 020 1 3.2 + 730.7 28.6 12.200 020 1 3.2 + 783.1 267.5 14.200 020 1 3.2 + 783.2 267.5 13.400 020 1 3.2 + 876.2 462.7 13.800 020 1 3.2 + 876.4 462.7 14.200 020 1 3.2 + 917.2 399.9 13.700 020 1 3.2 + 917.3 399.9 13.200 020 1 3.2 +1227.5 218.4 10.400 020 1 3.2 +1227.7 218.4 10.500 020 1 3.2 +1022.7 146.0 13.300 020 1 3.2 +1022.5 146.0 14.100 020 1 3.2 +1324.7 72.3 12.900 020 1 3.2 +1324.6 72.3 13.200 020 1 3.2 + 743.2 379.4 14.300 020 1 3.2 + 742.9 379.4 13.900 020 1 3.2 +1255.9 544.0 12.600 020 1 3.2 +1256.0 543.9 12.300 020 1 3.2 + 848.9 251.1 13.200 020 1 3.2 + 849.0 251.1 12.700 020 1 3.2 + 495.6 147.4 11.400 020 1 3.2 + 495.6 147.4 11.300 020 1 3.2 + 495.5 147.4 11.000 020 1 3.2 +1016.4 735.5 14.200 020 1 3.2 +1016.3 735.7 13.900 020 1 3.2 + 795.2 675.9 14.400 020 1 3.2 + 887.2 968.8 10.800 020 1 3.2 + 626.8 726.9 14.400 020 1 3.2 + 718.6 800.1 9.700 020 1 3.2 + 675.4 301.6 14.400 020 1 3.2 + 801.6 436.8 14.200 020 1 3.2 +1066.4 870.0 13.700 020 1 3.2 +1066.5 869.9 13.800 020 1 3.2 + 644.5 662.9 9.900 020 1 3.2 + 639.1 760.4 13.000 020 1 3.2 + 822.7 663.1 12.800 020 1 3.2 + 822.7 663.1 13.100 020 1 3.2 + 677.2 716.2 12.900 020 1 3.2 + 765.6 641.5 13.200 020 1 3.2 + 765.7 641.4 13.500 020 1 3.2 + 998.3 425.8 14.400 020 1 3.2 + 713.7 716.2 13.800 020 1 3.2 + 814.7 887.6 2.000 020 1 3.2 + 808.7 884.1 8.200 020 1 3.2 +1812.3 259.3 14.500 020 1 3.2 +1655.9 655.4 12.200 020 1 3.2 +1655.9 655.4 12.100 020 1 3.2 +1577.2 839.6 11.500 020 1 3.2 +1577.2 839.6 11.400 020 1 3.2 +1643.7 597.0 14.100 020 1 3.2 +1552.8 251.1 10.100 020 1 3.2 +1552.8 251.1 10.300 020 1 3.2 +1410.0 999.9 13.900 020 1 3.2 +1335.6 687.0 13.000 020 1 3.2 +1335.8 686.8 12.700 020 1 3.2 +1471.4 262.0 14.200 020 1 3.2 +1479.6 608.3 14.200 020 1 3.2 +1478.1 211.5 12.000 020 1 3.2 +1478.3 211.5 12.000 020 1 3.2 +1552.5 46.4 14.500 020 1 3.2 +2042.4 548.3 10.800 020 1 3.2 +2042.6 548.3 11.000 020 1 3.2 +1448.0 915.7 14.100 020 1 3.2 +1462.3 989.2 13.000 020 1 3.2 +1462.3 989.0 12.700 020 1 3.2 +1316.9 787.3 14.100 020 1 3.2 +1787.6 883.5 12.200 020 1 3.2 +1787.6 883.5 12.200 020 1 3.2 +1979.1 300.3 12.900 020 1 3.2 +1979.1 300.3 12.900 020 1 3.2 +1677.2 106.4 13.100 020 1 3.2 +1677.0 106.4 13.300 020 1 3.2 +1324.2 429.9 9.200 020 1 3.2 +1324.2 429.9 9.000 020 1 3.2 +1462.8 214.3 13.700 020 1 3.2 +1462.8 214.3 14.200 020 1 3.2 +1405.4 95.5 11.700 020 1 3.2 +1405.2 95.5 11.600 020 1 3.2 +1604.8 90.0 11.200 020 1 3.2 +1604.8 90.0 11.300 020 1 3.2 +1921.5 738.1 13.500 020 1 3.2 +1921.5 738.1 13.500 020 1 3.2 +1459.8 473.6 13.400 020 1 3.2 +1459.7 473.6 13.800 020 1 3.2 +1438.7 77.8 12.200 020 1 3.2 +1438.6 77.8 12.200 020 1 3.2 +1355.0 114.6 13.000 020 1 3.2 +1354.9 114.6 13.200 020 1 3.2 +1941.4 940.7 13.000 020 1 3.2 +1941.6 940.7 12.900 020 1 3.2 +1994.0 800.8 13.900 020 1 3.2 +1993.8 800.8 14.000 020 1 3.2 +2024.4 907.0 13.700 020 1 3.2 +2024.4 907.0 13.800 020 1 3.2 +2035.7 881.6 13.900 020 1 3.2 +2035.9 881.6 13.800 020 1 3.2 +1994.0 924.2 12.100 020 1 3.2 +1994.0 924.2 12.000 020 1 3.2 Index: /tags/getstar-1-0/Ohana/src/getstar/etc/template.cat =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/etc/template.cat (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/etc/template.cat (revision 2513) @@ -0,0 +1,296 @@ +SIMPLE = F / ASTROCAM PHOTOMETRY FILE \ +BITPIX = 16 / \ +NAXIS = 2 / NUMBER OF AXES \ +NAXIS1 = 1106 / NUMBER OF COLUMNS \ +NAXIS2 = 1024 / NUMBER OF ROWS \ +BSCALE = 1.000000 / \ +BZERO = 0.000000 / \ +DATE = '19/12/94' / UT Date of file creation (DD/MM/YY) \ +ORIGIN = 'MDM Observatory' / Michigan-Dartmouth-MIT \ +LATITUDE= 31.9500 / Latitude (degrees N) \ +LONGITUD= -111.6150 / Longitude (degrees E) \ +OBSERVER= 'Metzger ' / Name of observer \ +TELESCOP= '1.3m McGraw-Hill' / Telescope used for observation \ +INSTRUME= 'Charlotte Direct' / Instrument used for observation \ +DETECTOR= 'Charlotte/Tek 1024^2 CCD' / Detector used for observation \ +FRAME = 32 / Frame number of observation \ +CCDPICNO= 32 / Frame number of observation \ +OBJECT = 'ocl0327 ' / Name of object \ +IMAGETYP= 'OBJECT ' / Type of observation \ +EXPTIME = 250.000 / Integration time (seconds) \ +DARKTIME= 250.067 / Dark current time (seconds) \ +DATE-OBS= '19/12/94' / UT Date of observation (DD/MM/YY) \ +UT = ' 05:25:44.00' / Universal time (UTC) at exposure start \ +JD = 2449705.726204 \ +RA = 50.700 / Right Ascension \ +DEC = 89.000 / Declination \ +DIRECTN = -1 / Moving South \ +EQUINOX = 1950.000 / Equinox of RA and DEC \ +HA = ' 02:14:06.72' / Hour angle at start \ +ST = ' 03:49:36.85' / Sidereal time at start \ +ZD = ' 36:26:07.17' / Zenith distance (degrees) \ +AIRMASS = 1.243 / Airmass at start \ +FILTER = 'I KP ' / Filter description \ +GAIN = 3.350 / Nominal gain (e-/ADU) \ +SECPIX1 = 0.508 / Arcseconds per pixel in fast dir \ +SECPIX2 = 0.508 / Arcseconds per pixel in slow dir \ +CCDBIN1 = 1 / On-chip column binning (fast dir) \ +CCDBIN2 = 1 / On-chip row binning (slow dir) \ +GPROBE = ' 5000.00 7000.00' / Guide probe X Y \ +DATASEC = '[51:1074,1:1024]' / Image area of frame \ +CCDSEC = '[1:1074,1:1024]' / Image area relative to full chip \ +BIASSEC = '[1080:1106,1:1023]' / Overscan area of frame \ +UNSIGN = T / \ +NSTARS = 0 / NUMBER OF stars \ +CTYPE1 = 'RA---SIN ' / +CTYPE2 = 'DEC--SIN ' / +CDELT1 = 0.000733 / +CDELT2 = 0.000733 / +CRVAL1 = 50.191418 / +CRVAL2 = 88.998663 / +CRPIX1 = 1028.644173 / +CRPIX2 = 503.129830 / +PC001001= 0.999906 / +PC001002= 0.012081 / +PC002001= -0.011936 / +PC002002= 0.999950 / +END \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + \ + 246.5 352.1 13.000 020 1 3.2 + 246.5 352.1 14.100 020 1 3.2 + 279.4 328.9 13.800 020 1 3.2 + 187.3 238.8 9.800 020 1 3.2 + 187.3 238.8 9.800 020 1 3.2 + 436.6 413.5 14.300 020 1 3.2 + 9.3 856.5 13.000 020 1 3.2 + 9.3 856.2 13.600 020 1 3.2 + 319.7 697.9 12.000 020 1 3.2 + 319.7 697.7 12.100 020 1 3.2 + 244.3 9.5 14.100 020 1 3.2 + 284.7 334.4 14.000 020 1 3.2 + 127.1 122.8 14.200 020 1 3.2 + 140.2 791.1 13.700 020 1 3.2 + 140.2 790.8 14.400 020 1 3.2 + 131.7 636.3 13.800 020 1 3.2 + 423.8 700.6 13.800 020 1 3.2 + 423.7 700.7 12.500 020 1 3.2 + 266.2 290.7 13.800 020 1 3.2 + 266.0 290.7 13.100 020 1 3.2 + 570.7 721.6 13.600 020 1 3.2 + 570.7 721.6 13.100 020 1 3.2 + 548.7 673.0 13.700 020 1 3.2 + 264.2 219.7 12.800 020 1 3.2 + 264.0 219.7 12.100 020 1 3.2 + 161.9 797.4 11.900 020 1 3.2 + 162.0 797.2 12.200 020 1 3.2 + 505.8 851.8 13.700 020 1 3.2 + 88.2 419.0 11.400 020 1 3.2 + 88.2 419.0 11.800 020 1 3.2 + 426.9 613.2 9.400 020 1 3.2 + 427.4 613.5 7.600 020 1 3.2 + 326.1 595.2 12.100 020 1 3.2 + 326.2 595.1 12.600 020 1 3.2 + 444.4 845.2 14.200 020 1 3.2 + 254.1 916.8 14.500 020 1 3.2 + 502.6 882.4 14.200 020 1 3.2 + 128.3 275.7 12.300 020 1 3.2 + 128.3 275.7 12.900 020 1 3.2 + 230.9 554.8 13.300 020 1 3.2 + 230.9 554.7 14.200 020 1 3.2 + 47.5 685.2 13.500 020 1 3.2 + 47.5 684.9 14.200 020 1 3.2 + 382.6 658.7 14.000 020 1 3.2 + 182.2 330.3 14.200 020 1 3.2 + 245.1 548.3 12.600 020 1 3.2 + 245.3 548.0 13.200 020 1 3.2 + 50.3 849.0 13.700 020 1 3.2 + 50.5 848.8 14.300 020 1 3.2 + 17.9 772.7 14.200 020 1 3.2 + 499.8 712.8 13.500 020 1 3.2 + 499.8 712.6 14.400 020 1 3.2 + 294.5 349.4 14.000 020 1 3.2 + 497.7 747.8 11.000 020 1 3.2 + 497.5 747.8 10.900 020 1 3.2 + 109.7 323.5 14.000 020 1 3.2 + 59.5 917.6 14.300 020 1 3.2 + 59.4 917.8 13.700 020 1 3.2 + 82.2 880.5 13.800 020 1 3.2 + 145.1 341.2 14.500 020 1 3.2 + 452.7 592.4 14.400 020 1 3.2 + 623.4 820.0 13.700 020 1 3.2 + 609.7 829.3 13.500 020 1 3.2 + 481.8 938.3 14.400 020 1 3.2 + 617.0 792.7 13.500 020 1 3.2 + 183.2 539.7 14.400 020 1 3.2 + 133.9 679.6 14.400 020 1 3.2 + 423.7 667.8 6.500 020 1 3.2 + 434.7 111.9 13.200 020 1 3.2 + 434.5 111.9 13.200 020 1 3.2 + 434.6 111.9 14.200 020 1 3.2 +1222.3 684.2 13.900 020 1 3.2 +1077.6 282.5 14.000 020 1 3.2 +1077.8 282.5 13.400 020 1 3.2 + 720.8 562.1 14.100 020 1 3.2 + 721.1 561.9 14.400 020 1 3.2 +1182.1 944.4 12.100 020 1 3.2 +1181.9 944.4 11.800 020 1 3.2 +1181.9 944.4 12.300 020 1 3.2 + 761.2 423.1 14.300 020 1 3.2 + 761.0 423.1 14.100 020 1 3.2 + 926.7 436.8 13.400 020 1 3.2 + 926.6 436.8 14.200 020 1 3.2 +1209.1 45.0 13.200 020 1 3.2 +1209.2 43.6 12.800 020 1 3.2 +1135.2 653.1 8.100 020 1 3.2 +1135.6 653.4 8.200 020 1 3.2 +1123.5 735.8 12.000 020 1 3.2 +1123.6 735.8 11.800 020 1 3.2 +1123.7 735.7 11.600 020 1 3.2 + 730.7 28.6 12.100 020 1 3.2 + 730.7 28.6 12.200 020 1 3.2 + 783.1 267.5 14.200 020 1 3.2 + 783.2 267.5 13.400 020 1 3.2 + 876.2 462.7 13.800 020 1 3.2 + 876.4 462.7 14.200 020 1 3.2 + 917.2 399.9 13.700 020 1 3.2 + 917.3 399.9 13.200 020 1 3.2 +1227.5 218.4 10.400 020 1 3.2 +1227.7 218.4 10.500 020 1 3.2 +1022.7 146.0 13.300 020 1 3.2 +1022.5 146.0 14.100 020 1 3.2 +1324.7 72.3 12.900 020 1 3.2 +1324.6 72.3 13.200 020 1 3.2 + 743.2 379.4 14.300 020 1 3.2 + 742.9 379.4 13.900 020 1 3.2 +1255.9 544.0 12.600 020 1 3.2 +1256.0 543.9 12.300 020 1 3.2 + 848.9 251.1 13.200 020 1 3.2 + 849.0 251.1 12.700 020 1 3.2 + 495.6 147.4 11.400 020 1 3.2 + 495.6 147.4 11.300 020 1 3.2 + 495.5 147.4 11.000 020 1 3.2 +1016.4 735.5 14.200 020 1 3.2 +1016.3 735.7 13.900 020 1 3.2 + 795.2 675.9 14.400 020 1 3.2 + 887.2 968.8 10.800 020 1 3.2 + 626.8 726.9 14.400 020 1 3.2 + 718.6 800.1 9.700 020 1 3.2 + 675.4 301.6 14.400 020 1 3.2 + 801.6 436.8 14.200 020 1 3.2 +1066.4 870.0 13.700 020 1 3.2 +1066.5 869.9 13.800 020 1 3.2 + 644.5 662.9 9.900 020 1 3.2 + 639.1 760.4 13.000 020 1 3.2 + 822.7 663.1 12.800 020 1 3.2 + 822.7 663.1 13.100 020 1 3.2 + 677.2 716.2 12.900 020 1 3.2 + 765.6 641.5 13.200 020 1 3.2 + 765.7 641.4 13.500 020 1 3.2 + 998.3 425.8 14.400 020 1 3.2 + 713.7 716.2 13.800 020 1 3.2 + 814.7 887.6 2.000 020 1 3.2 + 808.7 884.1 8.200 020 1 3.2 +1812.3 259.3 14.500 020 1 3.2 +1655.9 655.4 12.200 020 1 3.2 +1655.9 655.4 12.100 020 1 3.2 +1577.2 839.6 11.500 020 1 3.2 +1577.2 839.6 11.400 020 1 3.2 +1643.7 597.0 14.100 020 1 3.2 +1552.8 251.1 10.100 020 1 3.2 +1552.8 251.1 10.300 020 1 3.2 +1410.0 999.9 13.900 020 1 3.2 +1335.6 687.0 13.000 020 1 3.2 +1335.8 686.8 12.700 020 1 3.2 +1471.4 262.0 14.200 020 1 3.2 +1479.6 608.3 14.200 020 1 3.2 +1478.1 211.5 12.000 020 1 3.2 +1478.3 211.5 12.000 020 1 3.2 +1552.5 46.4 14.500 020 1 3.2 +2042.4 548.3 10.800 020 1 3.2 +2042.6 548.3 11.000 020 1 3.2 +1448.0 915.7 14.100 020 1 3.2 +1462.3 989.2 13.000 020 1 3.2 +1462.3 989.0 12.700 020 1 3.2 +1316.9 787.3 14.100 020 1 3.2 +1787.6 883.5 12.200 020 1 3.2 +1787.6 883.5 12.200 020 1 3.2 +1979.1 300.3 12.900 020 1 3.2 +1979.1 300.3 12.900 020 1 3.2 +1677.2 106.4 13.100 020 1 3.2 +1677.0 106.4 13.300 020 1 3.2 +1324.2 429.9 9.200 020 1 3.2 +1324.2 429.9 9.000 020 1 3.2 +1462.8 214.3 13.700 020 1 3.2 +1462.8 214.3 14.200 020 1 3.2 +1405.4 95.5 11.700 020 1 3.2 +1405.2 95.5 11.600 020 1 3.2 +1604.8 90.0 11.200 020 1 3.2 +1604.8 90.0 11.300 020 1 3.2 +1921.5 738.1 13.500 020 1 3.2 +1921.5 738.1 13.500 020 1 3.2 +1459.8 473.6 13.400 020 1 3.2 +1459.7 473.6 13.800 020 1 3.2 +1438.7 77.8 12.200 020 1 3.2 +1438.6 77.8 12.200 020 1 3.2 +1355.0 114.6 13.000 020 1 3.2 +1354.9 114.6 13.200 020 1 3.2 +1941.4 940.7 13.000 020 1 3.2 +1941.6 940.7 12.900 020 1 3.2 +1994.0 800.8 13.900 020 1 3.2 +1993.8 800.8 14.000 020 1 3.2 +2024.4 907.0 13.700 020 1 3.2 +2024.4 907.0 13.800 020 1 3.2 +2035.7 881.6 13.900 020 1 3.2 +2035.9 881.6 13.800 020 1 3.2 +1994.0 924.2 12.100 020 1 3.2 +1994.0 924.2 12.000 020 1 3.2 Index: /tags/getstar-1-0/Ohana/src/getstar/include/addstar.h =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/include/addstar.h (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/include/addstar.h (revision 2513) @@ -0,0 +1,47 @@ +# include +# include +# include + +typedef struct { + double X; + double Y; + double R; + double D; + double M, dM; + char dophot; + double sky; + double fx, fy, df; + double Mgal, Map; + int found; +} Stars; + +/* global variables set in parameter file */ +char ImageCat[256]; +char ImageTemplate[256]; +char CatTemplate[256]; +char GSCFILE[256]; +char CATDIR[256]; +double DEFAULT_RADIUS, NSIGMA, SNLIMIT; +double ZeroPt; +int VERBOSE; +int SKIP_MISSED; +int XOVERSCAN, YOVERSCAN; +int XMIN, XMAX, YMIN, YMAX; +int ACCEPT_ASTROM; + +PhotCode *thiscode; + +char DateKeyword[64]; +char DateMode[64]; +char UTKeyword[64]; +char MJDKeyword[64]; +char JDKeyword[64]; +char ExptimeKeyword[64]; +char AirmassKeyword[64]; +char CCDNumKeyword[64]; + +int CalReference; +int CalColor; +int CALIBRATE; +int DUMP_MATCHES; +int ONLY_IMAGES; Index: /tags/getstar-1-0/Ohana/src/getstar/include/getstar.h =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/include/getstar.h (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/include/getstar.h (revision 2513) @@ -0,0 +1,47 @@ +# include +# include +# include + +typedef struct { + double X; + double Y; + double R; + double D; + double M, dM; + char dophot; + double sky; + double fx, fy, df; + double Mgal, Map; + int found; +} Stars; + +/* global variables set in parameter file */ +char ImageCat[256]; +char ImageTemplate[256]; +char CatTemplate[256]; +char GSCFILE[256]; +char CATDIR[256]; +double DEFAULT_RADIUS, NSIGMA, SNLIMIT; +double ZeroPt; +int VERBOSE; +int SKIP_MISSED; +int XOVERSCAN, YOVERSCAN; +int XMIN, XMAX, YMIN, YMAX; +int ACCEPT_ASTROM; + +PhotCode *thiscode; + +char DateKeyword[64]; +char DateMode[64]; +char UTKeyword[64]; +char MJDKeyword[64]; +char JDKeyword[64]; +char ExptimeKeyword[64]; +char AirmassKeyword[64]; +char CCDNumKeyword[64]; + +int CalReference; +int CalColor; +int CALIBRATE; +int DUMP_MATCHES; +int ONLY_IMAGES; Index: /tags/getstar-1-0/Ohana/src/getstar/src/ConfigInit.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/ConfigInit.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/ConfigInit.c (revision 2513) @@ -0,0 +1,63 @@ +# include "getstar.h" + +ConfigInit (int *argc, char **argv) { + + char *config, *file; + char RadiusWord[80]; + char PhotCodeFile[256]; + + /*** load configuration info ***/ + file = SelectConfigFile (argc, argv, "ptolemy"); + config = LoadConfigFile (file); + if (config == (char *) NULL) { + fprintf (stderr, "ERROR: can't find configuration file %s\n", file); + if (file != (char *) NULL) free (file); + exit (1); + } + if (VERBOSE) fprintf (stderr, "loaded config file: %s\n", file); + + ScanConfig (config, "RADIUS", "%s", 0, RadiusWord); + if (!strcasecmp (RadiusWord, "header")) { + DEFAULT_RADIUS = 0; + } else { + DEFAULT_RADIUS = atof (RadiusWord); + } + + XMIN = XMAX = YMIN = YMAX = 0; + ScanConfig (config, "NSIGMA", "%lf", 0, &NSIGMA); + ScanConfig (config, "XOVERSCAN", "%d", 0, &XOVERSCAN); + ScanConfig (config, "YOVERSCAN", "%d", 0, &YOVERSCAN); + ScanConfig (config, "ZERO_PT", "%lf", 0, &ZeroPt); + + ScanConfig (config, "ADDSTAR_XMIN", "%d", 0, &XMIN); + ScanConfig (config, "ADDSTAR_XMAX", "%d", 0, &XMAX); + ScanConfig (config, "ADDSTAR_YMIN", "%d", 0, &YMIN); + ScanConfig (config, "ADDSTAR_YMAX", "%d", 0, &YMAX); + + ScanConfig (config, "IMAGE_CATALOG", "%s", 0, ImageCat); + ScanConfig (config, "IMAGE_CATALOG_TEMPLATE", "%s", 0, ImageTemplate); + ScanConfig (config, "CATALOG_TEMPLATE", "%s", 0, CatTemplate); + ScanConfig (config, "GSCFILE", "%s", 0, GSCFILE); + ScanConfig (config, "CATDIR", "%s", 0, CATDIR); + ScanConfig (config, "MIN_SN_FSTAT", "%lf", 0, &SNLIMIT); + ScanConfig (config, "PHOTCODE_FILE", "%s", 0, PhotCodeFile); + + ScanConfig (config, "DATE-KEYWORD", "%s", 0, DateKeyword); + ScanConfig (config, "DATE-MODE", "%s", 0, DateMode); + ScanConfig (config, "UT-KEYWORD", "%s", 0, UTKeyword); + ScanConfig (config, "MJD-KEYWORD", "%s", 0, MJDKeyword); + ScanConfig (config, "JD-KEYWORD", "%s", 0, JDKeyword); + + ScanConfig (config, "EXPTIME-KEYWORD", "%s", 0, ExptimeKeyword); + ScanConfig (config, "AIRMASS-KEYWORD", "%s", 0, AirmassKeyword); + ScanConfig (config, "CCDNUM-KEYWORD", "%s", 0, CCDNumKeyword); + + if (!LoadPhotcodes (PhotCodeFile)) { + fprintf (stderr, "error loading photcodes\n"); + exit (1); + } + + free (config); + free (file); + +} Index: /tags/getstar-1-0/Ohana/src/getstar/src/addstar.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/addstar.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/addstar.c (revision 2513) @@ -0,0 +1,223 @@ +# include "addstar.h" + +/* these variables are needed by Shutdown */ +static FILE *f = (FILE *) NULL; +static int Protect = FALSE; +static int Trapped = FALSE; + +/* clean up open / locked ImageCat before shutting down */ +int Shutdown () { + int dbstate; + + Protect = TRUE; + fclearlockfile (ImageCat, f, LCK_HARD, &dbstate); + fprintf (stderr, "ERROR: addstar halted\n"); + exit (1); +} + +void TrapSignal (int sig) { + fprintf (stderr, "trapped signal %d, exiting gracefully\n", sig); + if (sig == 11) { + fprintf (stderr, "seg fault\n"); + exit (1); + } + if (Protect) { + Trapped = TRUE; + fprintf (stderr, "blocking until protected sections are clear\n"); + return; + } + Shutdown (); +} + +main (int argc, char **argv) { + + int i, N, mode, dbstate; + int Nstars, Nimage, Nregions, Nmissed; + Stars *stars, *gstars(); + Image image, *pimage, *gimages(); + GSCRegion *region, *gregions(); + Catalog catalog; + struct timeval now, then; + + SetSignals (); + args (argc, argv); + + /* load the input datafile */ + stars = gstars (argv[1], &Nstars, &image); + if (Nstars == 0) { + if (VERBOSE) fprintf (stderr, "no stars in data file, skipping\n"); + fprintf (stderr, "SUCCESS\n"); + exit (0); + } + + /* lock the image catalog */ + check_permissions (ImageCat); + f = fsetlockfile (ImageCat, 3600.0, LCK_HARD, &dbstate); + if ((f == (FILE *) NULL) && (dbstate != LCK_EMPTY)) { + fprintf (stderr, "ERROR: can't lock image catalog\n"); + exit (1); + } + fseek (f, 0, SEEK_SET); + + /* load images */ + if (dbstate == LCK_EMPTY) { + Nimage = 0; + } else { + pimage = gimages (f, &image, &Nimage); + } + region = gregions (&image, &Nregions); + fprintf (stderr, "region %f %f %f %f\n", region[0].RA[0], region[0].RA[1], region[0].DEC[0], region[0].DEC[1]); + + for (i = 0; i < Nregions; i++) { + check_permissions (region[i].filename); + } + + if (CALIBRATE) { InitCalibration (); } + + for (i = 0; i < Nregions; i++) { + catalog.filename = region[i].filename; /* don't free region before catalog! */ + fprintf (stderr, "adding to %s\n", region[i].filename); + + switch (lock_catalog (&catalog, LCK_XCLD)) { + case 0: + /* this is a serious error because ImageCat was NOT locked */ + fprintf (stderr, "ERROR: can't lock file %s\n", catalog.filename); + exit (1); + case 1: + gcatalog (&catalog); /* load from disk */ + break; + case 2: + mkcatalog (®ion[i], &catalog); /* fills in new header info */ + break; + } + find_matches (®ion[i], stars, Nstars, &catalog, &image, pimage, Nimage); + + /* protect wcatalog from interrupt signals */ + Protect = TRUE; + if (!DUMP_MATCHES && !ONLY_IMAGES) wcatalog (&catalog); + if (Trapped) Shutdown (); + Protect = FALSE; + unlock_catalog (&catalog); + } + + if (CALIBRATE) { FindCalibration (&image); } + if (DUMP_MATCHES) Shutdown (); + + for (Nmissed = i = 0; i < Nstars; i++) { + if (stars[i].found == -1) { + fprintf (stderr, "%d %f %f %f %f\n", i, stars[i].R, stars[i].D, stars[i].M, stars[i].dM); + Nmissed ++; + } + } + if (Nmissed) fprintf (stderr, "WARNING: %d stars in image were missed!\n", Nmissed); + + /* protect wimage from interrupt signals */ + Protect = TRUE; + wimage (f, dbstate, &image, Nstars); + if (Trapped) Shutdown (); + Protect = FALSE; + + fclearlockfile (ImageCat, f, LCK_HARD, &dbstate); + + mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH; + chmod (ImageCat, mode); + + fprintf (stderr, "SUCCESS\n"); + exit (0); + +} + +int SetSignals () { + + int i; + + /* disable almost all signal interrupts */ + for (i = 0; i < 36; i++) { + switch (i) { + /* can't redirect this signals */ + case SIGKILL: /* kill -9: cannot be caught or ignored */ + case SIGSTOP: /* SIGSTOP: cannot be caught or ignored */ + /* ignore these signals */ + case SIGCHLD: /* child halted: ignore */ + case SIGPWR: /* power failure - why ignore this? */ + case SIGWINCH: /* window resized */ + case SIGCONT: /* continue - maintain this action */ + case SIGTSTP: /* stop signal sent from tty - why ignore? */ + case SIGURG: /* socket signal, ignore this */ + break; + + default: + signal (i, TrapSignal); + } + } + +} +/* + + Signal Value Action Comment + ------------------------------------------------------------------------- + SIGHUP 1 A Hangup detected on controlling terminal + or death of controlling process + SIGINT 2 A Interrupt from keyboard + SIGQUIT 3 A Quit from keyboard + SIGILL 4 A Illegal Instruction + SIGABRT 6 C Abort signal from abort(3) + SIGFPE 8 C Floating point exception + SIGKILL 9 AEF Kill signal + SIGSEGV 11 C Invalid memory reference + SIGPIPE 13 A Broken pipe: write to pipe with no readers + SIGALRM 14 A Timer signal from alarm(2) + SIGTERM 15 A Termination signal + SIGUSR1 30,10,16 A User-defined signal 1 + SIGUSR2 31,12,17 A User-defined signal 2 + SIGCHLD 20,17,18 B Child stopped or terminated + SIGCONT 19,18,25 Continue if stopped + SIGSTOP 17,19,23 DEF Stop process + SIGTSTP 18,20,24 D Stop typed at tty + SIGTTIN 21,21,26 D tty input for background process + SIGTTOU 22,22,27 D tty output for background process + + Next various other signals. + + Signal Value Action Comment + --------------------------------------------------------------------- + SIGTRAP 5 CG Trace/breakpoint trap + SIGIOT 6 CG IOT trap. A synonym for SIGABRT + SIGEMT 7,-,7 G + SIGBUS 10,7,10 AG Bus error + SIGSYS 12,-,12 G Bad argument to routine (SVID) + SIGSTKFLT -,16,- AG Stack fault on coprocessor + SIGURG 16,23,21 BG Urgent condition on socket (4.2 BSD) + SIGIO 23,29,22 AG I/O now possible (4.2 BSD) + SIGPOLL AG A synonym for SIGIO (System V) + SIGCLD -,-,18 G A synonym for SIGCHLD + SIGXCPU 24,24,30 AG CPU time limit exceeded (4.2 BSD) + SIGXFSZ 25,25,31 AG File size limit exceeded (4.2 BSD) + SIGVTALRM 26,26,28 AG Virtual alarm clock (4.2 BSD) + SIGPROF 27,27,29 AG Profile alarm clock + SIGPWR 29,30,19 AG Power failure (System V) + SIGINFO 29,-,- G A synonym for SIGPWR + SIGLOST -,-,- AG File lock lost + SIGWINCH 28,28,20 BG Window resize signal (4.3 BSD, Sun) + SIGUNUSED -,31,- AG Unused signal + (Here - denotes that a signal is absent; there where three values are given, the first one is usually valid for alpha and + sparc, the middle one for i386 and ppc, the last one for mips. Signal 29 is SIGINFO / SIGPWR on an alpha but SIGLOST on a + sparc.) + + The letters in the "Action" column have the following meanings: + + A Default action is to terminate the process. + + B Default action is to ignore the signal. + + C Default action is to dump core. + + D Default action is to stop the process. + + E Signal cannot be caught. + + F Signal cannot be ignored. + + G Not a POSIX.1 conformant signal. + +*/ Index: /tags/getstar-1-0/Ohana/src/getstar/src/aregion.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/aregion.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/aregion.c (revision 2513) @@ -0,0 +1,180 @@ +# include "getstar.h" + +double BigDecBounds[] = {0.0, 7.5, 15.0, 22.5, 30.0, 37.5, 45.0, + 52.5, 60.0, 67.5, 75.0, 82.5, 90.0, + 0.0, -7.5, -15.0, -22.5, -30.0, -37.5, -45.0, + -52.5, -60.0, -67.5, -75.0, -82.5, -90.0}; +char *DecSections[] = {"N0000", "N0730", "N1500", "N2230", "N3000", "N3730", "N4500", + "N5230", "N6000", "N6730", "N7500", "N8230", "weirdness", + "S0000", "S0730", "S1500", "S2230", "S3000", "S3730", "S4500", + "S5230", "S6000", "S6730", "S7500", "S8230", "weirdness"}; + +char *Dec2Sections[] = {"n0000", "n0730", "n1500", "n2230", "n3000", "n3730", "n4500", + "n5230", "n6000", "n6730", "n7500", "n8230", "weirdness", + "s0000", "s0730", "s1500", "s2230", "s3000", "s3730", "s4500", + "s5230", "s6000", "s6730", "s7500", "s8230", "weirdness"}; + +char *disk[] = {"disk 1", "disk 1", "disk 1", "disk 1", "disk 1", "disk 1", "disk 1", + "disk 1", "disk 1", "disk 1", "disk 1", "disk 1", "weirdness", + "disk 1", "disk 2", "disk 2", "disk 2", "disk 2", "disk 2", "disk 2", + "disk 2", "disk 2", "disk 2", "disk 2", "disk 2", "weirdness"}; + +int NBigRASections [] = {48, 47, 45, 43, 40, 36, 32, 28, 21, 15, 9, 3, 3, 48, 47, 45, 43, 40, 36, 32, 28, 21, 15, 9, 3, 3}; + +int NDecLines[] = {593, 584, 551, 530, 522, 465, 406, 362, 280, 198, 123, 24, + 0, 597, 578, 574, 577, 534, 499, 442, 376, 294, 212, 144, 48}; + +# define DEBUG 1 + +/* find region file which contains ra, dec */ +aregion (region, f, ra, dec) +GSCRegion region[]; +FILE *f; +double ra, dec; +{ + + + char buffer[28800], temp[50], file[256]; + double dr, dd; + double RA0, RA1, DEC0, DEC1; + int i, NBigDec, NLINES, done, nregion; + + while (ra < 0) { ra += 360.0; } + while (ra >= 360.0) { ra -= 360.0; } + + if (dec >= 86.25) { + sprintf (file, "%s/n8230/pole.cpt\0", CATDIR); + region[0].DEC[0] = 86.25; + region[0].DEC[1] = 93.75; + region[0].RA[0] = 0.0; + region[0].RA[1] = 360.0; + strcpy (region[0].filename, file); + return; + } + + NBigDec = -1; + for (i = 0; i < 12; i++) { + if ((dec >= BigDecBounds[i]) && (dec < BigDecBounds[i+1])) { + NBigDec = i; + break; + } + } + if (NBigDec < 0) { + for (i = 13; i < 24; i++) { + if ((dec < BigDecBounds[i]) && (dec >= BigDecBounds[i+1])) { + NBigDec = i; + break; + } + } + } + if (NBigDec < 0) { + fprintf (stderr, "dec out of range: %f\n", dec); + } + + NLINES = 0; + for (i = 0; i < NBigDec; i++) { + NLINES += NDecLines[i]; + } + fseek (f, 5*2880 + 48*NLINES, SEEK_SET); + + done = FALSE; + Fread (buffer, 1, 48*NDecLines[NBigDec], f, "char"); + for (i = 0; !done && (i < NDecLines[NBigDec]); i++) { + strncpy (temp, &buffer[i*48], 48); + temp[49] = 0; + hms_to_deg (&RA0, &RA1, &DEC0, &DEC1, &temp[7]); + if (RA1 < RA0) RA1 += 360.0; + if ((dec >= 0) && (dec >= DEC0) && (dec < DEC1) && (ra >= RA0) && (ra < RA1)) { + done = TRUE; + } + if ((dec < 0) && (dec < DEC0) && (dec >= DEC1) && (ra >= RA0) && (ra < RA1)) { + done = TRUE; + } + } + + if (!done) { + fprintf (stderr, "error in search: %f %f\n", ra, dec); + exit (1); + } + temp[5] = 0; + sprintf (file, "%s/%s/%s.cpt\0", CATDIR, Dec2Sections[NBigDec], &temp[1]); + if (DEC0 < DEC1) { + region[0].DEC[0] = DEC0; + region[0].DEC[1] = DEC1; + } else { + region[0].DEC[0] = DEC1; + region[0].DEC[1] = DEC0; + } + region[0].RA[0] = RA0; + region[0].RA[1] = RA1; + strcpy (region[0].filename, file); + return; +} + + +/**********/ +int hms_to_deg (h0, h1, d0, d1, string) + char *string; + double *h0, *h1, *d0, *d1; +{ + + int flag_d0, flag_d1, flag_h0, flag_h1; + double tmp; + + *d0 = *h0 = *d1 = *h1 = 0; + + flag_h0 = dparse (h0, 1, string); + flag_h1 = dparse (h1, 4, string); + flag_d0 = dparse (d0, 7, string); + flag_d1 = dparse (d1, 9, string); + *h0 *= flag_h0; + *h1 *= flag_h1; + *d0 *= flag_d0; + *d1 *= flag_d1; + + dparse (&tmp, 2, string); + *h0 += tmp/60.0; + dparse (&tmp, 3, string); + *h0 += tmp/3600.0; + + dparse (&tmp, 5, string); + *h1 += tmp/60.0; + dparse (&tmp, 6, string); + *h1 += tmp/3600.0; + + dparse (&tmp, 8, string); + *d0 += tmp/60.0; + + dparse (&tmp, 10, string); + *d1 += tmp/60.0; + + *h0 *= 15*flag_h0; + *h1 *= 15*flag_h1; + *d0 *= flag_d0; + *d1 *= flag_d1; + + return (TRUE); +} + + +/* + if (buffer[i*48 + 19] == ' ') continue; + strncpy (temp, &buffer[i*48 + 19], 20); temp[20] = 0; + hms_to_deg (&RA, &DEC, temp, ' ', 3); + + + dBigRA = 360.0 / (int)(0.5 + 48*cos(3.1415927*0.5*(BigDecBounds[NBigDec] + BigDecBounds[NBigDec + 1])/180.0)); + + NBigRA = ra / dBigRA; + + NBig = NBigRA; + for (i = 0; (i < 12) && (i < NBigDec); i++) { + NBig += NBigRASections[i]; + } + for (i = 13; (i < 24) && (i < NBigDec); i++) { + NBig += NBigRASections[i]; + } + + + fprintf (stderr, "%d %d %d %d %f %f -> %f %f %f\n", NBigDec, NBigRA, NBigRASections[NBigDec], NBig, ra, dec, BigDecBounds[NBigDec], BigDecBounds[NBigDec + 1], dBigRA); +*/ Index: /tags/getstar-1-0/Ohana/src/getstar/src/args.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/args.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/args.c (revision 2513) @@ -0,0 +1,31 @@ +# include "getstar.h" + +void help () { + fprintf (stderr, "USAGE: getstar (file) (output)\n"); + exit (2); +} + +int args (int argc, char **argv) { + + int N; + + /* check for help request */ + if (get_argument (argc, argv, "-help") || + get_argument (argc, argv, "-h")) { + help (); + } + + /* configuration info */ + ConfigInit (&argc, argv); + + /* check for command line options */ + VERBOSE = FALSE; + if ((N = get_argument (argc, argv, "-v"))) { + VERBOSE = TRUE; + remove_argument (N, &argc, argv); + } + + if (argc != 3) help (); + +} + Index: /tags/getstar-1-0/Ohana/src/getstar/src/calibrate.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/calibrate.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/calibrate.c (revision 2513) @@ -0,0 +1,143 @@ +# include "addstar.h" + +static int Ncal, NCAL; +static float *Mobs, *dMobs, *Mref, *Cref, *Airm; +static float *RA, *DEC, *X, *Y; +int *Nstar; + +InitCalibration () { + + fprintf (stderr, "calibrating the image... %d\n", CalReference); + Ncal = 0; + NCAL = 1000; + ALLOCATE (Mobs, float, NCAL); + ALLOCATE (dMobs, float, NCAL); + ALLOCATE (Mref, float, NCAL); + ALLOCATE (Cref, float, NCAL); + ALLOCATE (Airm, float, NCAL); + ALLOCATE (Nstar, int, NCAL); + ALLOCATE (RA, float, NCAL); + ALLOCATE (DEC, float, NCAL); + ALLOCATE (X, float, NCAL); + ALLOCATE (Y, float, NCAL); +} + +SaveCalibration (float M, float dM, float Mr, float Mc, float A, int N, float ra, float dec, float x, float y) { + + Mobs[Ncal] = M; + dMobs[Ncal] = dM; + Mref[Ncal] = Mr; + Cref[Ncal] = Mc; + Airm[Ncal] = A; + Nstar[Ncal] = N; + + RA[Ncal] = ra; + DEC[Ncal] = dec; + X[Ncal] = x; + Y[Ncal] = y; + Ncal ++; + + if (Ncal == NCAL) { + NCAL += 1000; + REALLOCATE (dMobs, float, NCAL); + REALLOCATE (Mobs, float, NCAL); + REALLOCATE (Mref, float, NCAL); + REALLOCATE (Cref, float, NCAL); + REALLOCATE (Airm, float, NCAL); + REALLOCATE (Nstar, int, NCAL); + REALLOCATE (RA, float, NCAL); + REALLOCATE (DEC, float, NCAL); + REALLOCATE (X, float, NCAL); + REALLOCATE (Y, float, NCAL); + } +} + +FindCalibration (Image *image) { + + int i, MaxN, *Nlist, Nkeep; + float N, M1, M2, Klam, Clam, Xlam, Mabs, dM, dm, *Dmag; + float dAs, dMs, dYs; + + /* reject multiple matched-stars */ + /* find maximum value of Nstar[] */ + MaxN = -1; + for (i = 0; i < Ncal; i++) { + MaxN = MAX (Nstar[i], MaxN); + } + if (MaxN == -1) { + fprintf (stderr, "no clean stars\n"); + image[0].Mcal = 10000; + image[0].dMcal = 10000; + return; + } + /* create a hash array from Nstar[] entries */ + ALLOCATE (Nlist, int, MAX (1, MaxN + 1)); + bzero (Nlist, MAX (0, MaxN*sizeof(int))); + for (i = 0; i < Ncal; i++) { + Nlist[Nstar[i]] ++; + } + + /* accumulate delta mags */ + ALLOCATE (Dmag, float, Ncal); + Nkeep = 0; + Klam = thiscode[0].K; + Clam = thiscode[0].C; + Xlam = thiscode[0].X; + for (i = 0; i < Ncal; i++) { + /* if this entry has too many (or two few?) matches, skip it */ + if (Nlist[Nstar[i]] != 1) continue; + Mabs = 0.001*(Mobs[i] + Klam*(Airm[i] - 1000) + Clam + Xlam*(Mref[i] - Cref[i])) - ZeroPt; + + /* subpix correction : make parameters global! */ + dAs = 0; + if (Y[i] < 400) dAs = 0.06 - 0.00015*Y[i]; + dYs = Y[i] - (int) (Y[i]) + 0.55; + dMs = dAs * sin (6.28*dYs); + /* Mabs -= dMs; */ + + if (DUMP_MATCHES) + fprintf (stdout, "%d %6.3f %6.3f %6.3f %10.6f %10.6f %7.2f %7.2f\n", + i, Mabs, 0.001*Mref[i], 0.001*Cref[i], RA[i], DEC[i], X[i], Y[i]); + + /* skip stars brighter than 8.0 */ + /* if (Mabs < 8.0) continue; */ + + Dmag[Nkeep] = (Mabs - 0.001*Mref[i]); + Nkeep ++; + } + + if (Nkeep < 3) { + fprintf (stderr, "too few stars\n"); + image[0].Mcal = 10000; + image[0].dMcal = 10000; + return; + } + fsort (Dmag, Nkeep); + + /* accumulate delta mags (25% - 75% of list) */ + M1 = 0.0; + M2 = 0.0; + N = 0.0; + for (i = 0.25*Nkeep; i <= 0.75*Nkeep; i++) { + + /* a straight mean works better, given the bad photometry of skyprobe */ + M1 += Dmag[i]; + M2 += SQ (Dmag[i]); + N += 1.0; + + } + + if (N > 1) { + M1 = M1 / N; + M2 = sqrt (fabs(M2/N - M1*M1)); + fprintf (stderr, "N: %.0f, mean: %f, stdev: %f, precision: %f\n", N, M1, M2, M2 / sqrt (N)); + image[0].Mcal = 1000 * M1; + image[0].dMcal = 1000 * M2 / sqrt (N); + } else { + fprintf (stderr, "too few stars\n"); + image[0].Mcal = 10000; + image[0].dMcal = 10000; + } +} + + Index: /tags/getstar-1-0/Ohana/src/getstar/src/check_permissions.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/check_permissions.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/check_permissions.c (revision 2513) @@ -0,0 +1,91 @@ +# include "addstar.h" + +check_permissions (char *basefile) { + + FILE *f; + char *c, dir[256], filename[256]; + struct stat filestat; + uid_t fuid, uid; + gid_t fgid, gid; + int status, cmode; + + uid = getuid(); + gid = getgid(); + + /* check permission to write to directory */ + sprintf (filename, "%s\0", basefile); + c = strrchr (filename, '/'); + if (c == (char *) NULL) { + strcpy (dir, "."); + } else { + *c = 0; + strcpy (dir, filename); + } + status = stat (dir, &filestat); + if (status == -1) { + fprintf (stderr, "directory %s does not exist, creating...\n", dir); + cmode = S_IRWXU | S_IRWXG | S_IRWXO; + status = mkdir (dir, cmode); + if (status == -1) { + fprintf (stderr, "ERROR: can't create %s\n", dir); + exit (1); + } + } + status = stat (dir, &filestat); + if (((uid == filestat.st_uid) && (filestat.st_mode & S_IRWXU)) || + ((gid == filestat.st_gid) && (filestat.st_mode & S_IRWXG)) || + (filestat.st_mode & S_IRWXO)) { + } else { + fprintf (stderr, "ERROR: can't write to %s\n", dir); + exit (1); + } + + /* check permission to write to file */ + sprintf (filename, "%s\0", basefile); + status = stat (filename, &filestat); + if (status == 0) { /* file exists, are permissions OK? */ + if (((uid == filestat.st_uid) && (filestat.st_mode & S_IRUSR) && (filestat.st_mode & S_IWUSR)) || + ((gid == filestat.st_gid) && (filestat.st_mode & S_IRGRP) && (filestat.st_mode & S_IWGRP)) || + ((filestat.st_mode & S_IROTH) && (filestat.st_mode & S_IWOTH))) { + } else { + fprintf (stderr, "ERROR: can't write to %s\n", filename); + exit (1); + } + } + + /* check permission to write to backup file */ + sprintf (filename, "%s~\0", basefile); + status = stat (filename, &filestat); + if (status == 0) { /* file exists, are permissions OK? */ + if (((uid == filestat.st_uid) && (filestat.st_mode & S_IRUSR) && (filestat.st_mode & S_IWUSR)) || + ((gid == filestat.st_gid) && (filestat.st_mode & S_IRGRP) && (filestat.st_mode & S_IWGRP)) || + ((filestat.st_mode & S_IROTH) && (filestat.st_mode & S_IWOTH))) { + } else { + fprintf (stderr, "ERROR: can't write to %s\n", filename); + exit (1); + } + } + +} + +/* uses cp only */ +make_backup (char *filename) { + + int status, cmode; + struct stat filestat; + char line [256]; + + status = stat (filename, &filestat); + if (status == 0) { /* file exists, make backup copy */ + sprintf (line, "cp %s %s~\0", filename, filename); + status = system (line); + if (status) { + fprintf (stderr, "ERROR: unable to create %s~, exiting\n", filename); + exit (1); + } + cmode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH; + sprintf (line, "%s~\0", filename); + chmod (line, cmode); + } + +} Index: /tags/getstar-1-0/Ohana/src/getstar/src/clean_stars.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/clean_stars.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/clean_stars.c (revision 2513) @@ -0,0 +1,63 @@ +# include "getstar.h" + +int clean_stars (Stars *stars, int *nstars, Image *image) { + + int i, j, Nsubset, *subset, *skip, *found, Nstars, check, Nskip; + double Xo, Yo, Xt, Yt, radius; + double Mo, Mt, dM; + + Nstars = *nstars; + ALLOCATE (found, int, Nstars); + ALLOCATE (subset, int, Nstars); + ALLOCATE (skip, int, Nstars); + bzero (skip, Nstars*sizeof(int)); + + Nskip = 0; + Nsubset = 0; + for (i = 0; i < Nstars; i++) { + RD_to_XY (&stars[i].X, &stars[i].Y, stars[i].R, stars[i].D, &image[0].coords); + check = (stars[i].found & BLEND_IMAGE) || (stars[i].found & BLEND_IMAGE_NEIGHBOR) || (stars[i].found & BLEND_CATALOG); + if (check) { + subset[Nsubset] = i; + found[Nsubset] = FALSE; + Nsubset ++; + } + } + + if (Nsubset > 1) { + for (i = 0; i < Nsubset; i++) { + if (found[i]) continue; + Xo = stars[subset[i]].X; + Yo = stars[subset[i]].Y; + Mo = stars[subset[i]].M; + for (j = 0; j < Nsubset; j++) { + if (j == i) continue; + if (found[j]) continue; + Xt = stars[subset[j]].X; + Yt = stars[subset[j]].Y; + Mt = stars[subset[j]].M; + radius = hypot ((Xo-Xt), (Yo-Yt)); + dM = fabs (Mo-Mt); + if ((radius < 5.0) && (dM < 0.005)) { + skip[subset[j]] = TRUE; + found[j] = TRUE; + Nskip ++; + } + } + found[i] = TRUE; + } + + for (i = j = 0; i < Nstars; i++) { + if (skip[i]) continue; + if (i == j) { + j++; + continue; + } + stars[j] = stars[i]; + j++; + } + *nstars = j; + } + fprintf (stderr, "%d skipped\n", Nskip); +} + Index: /tags/getstar-1-0/Ohana/src/getstar/src/coordops.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/coordops.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/coordops.c (revision 2513) @@ -0,0 +1,342 @@ +# include "addstar.h" + +XY_to_RD (ra, dec, x, y, coords) +double *ra, *dec; +double x, y; +Coords coords[]; +{ + + double L, M, X, Y, T; + double R, sphi, cphi, stht, ctht; + double alpha, delta, salp, calp, sdel, sdp, cdp; + + *ra = 0; + *dec = 0; + +# if 1 + if (!strcmp(&coords[0].ctype[4], "-PLY")) { + X = coords[0].cdelt1*(x - coords[0].crpix1 + x*x*coords[0].polyterms[0][0] + x*y*coords[0].polyterms[1][0] + y*y*coords[0].polyterms[2][0] + + x*x*x*coords[0].polyterms[3][0] + x*x*y*coords[0].polyterms[4][0] + x*y*y*coords[0].polyterms[5][0] + y*y*y*coords[0].polyterms[6][0]); + Y = coords[0].cdelt2*(y - coords[0].crpix2 + x*x*coords[0].polyterms[0][1] + x*y*coords[0].polyterms[1][1] + y*y*coords[0].polyterms[2][1] + + x*x*x*coords[0].polyterms[3][1] + x*x*y*coords[0].polyterms[4][1] + x*y*y*coords[0].polyterms[5][1] + y*y*y*coords[0].polyterms[6][1]); + } else { +# else + { +# endif + X = coords[0].cdelt1*(x - coords[0].crpix1); + Y = coords[0].cdelt2*(y - coords[0].crpix2); + } + + L = (X*coords[0].pc1_1 + Y*coords[0].pc1_2); + M = (X*coords[0].pc2_1 + Y*coords[0].pc2_2); + + if (!strcmp(&coords[0].ctype[4], "-PLY") || !strcmp(&coords[0].ctype[4], "-TAN") || !strcmp(&coords[0].ctype[4], "-SIN") || !strcmp(&coords[0].ctype[0], "MM")) { + R = hypot (L,M); + if ((L == 0) && (M == 0)) { + sphi = 0; + cphi = 1; + } + else { + sphi = L / R; + cphi = -M / R; + } + + if (!strcmp(&coords[0].ctype[4], "-PLY") || !strcmp(&coords[0].ctype[4], "-TAN")) { + if (R == 0) { + stht = 1.0; + ctht = 0.0; + } + else { + T = DEG_RAD / R; + stht = T / sqrt ( 1.0 + T*T); + ctht = 1.0 / sqrt ( 1.0 + T*T); + } + } + if (!strcmp(&coords[0].ctype[4], "-SIN") || !strcmp(&coords[0].ctype[0], "MM")) { + ctht = RAD_DEG * R; + stht = sqrt (1 - ctht*ctht); + } + + sdp = sin(RAD_DEG*coords[0].crval2); + cdp = cos(RAD_DEG*coords[0].crval2); + + sdel = stht*sdp - ctht*cphi*cdp; + salp = ctht*sphi; + calp = stht*cdp + ctht*cphi*sdp; + alpha = atan2 (salp, calp); + delta = asin (sdel); + + *ra = DEG_RAD*alpha + coords[0].crval1; + *dec = DEG_RAD*delta; + } + if (!strcmp(&coords[0].ctype[4], "-LIN") || !strcmp(&coords[0].ctype[0], "GENE")) { + *ra = L + coords[0].crval1; + *dec = M + coords[0].crval2; + } + +} + + +fXY_to_RD (ra, dec, x, y, coords) +float *ra, *dec; +double x, y; +Coords coords[]; +{ + + double L, M, X, Y, T; + double R, sphi, cphi, stht, ctht; + double alpha, delta, salp, calp, sdel, sdp, cdp; + + *ra = 0; + *dec = 0; + + if (!strcmp(&coords[0].ctype[4], "-PLY")) { + X = coords[0].cdelt1*(x - coords[0].crpix1 + x*x*coords[0].polyterms[0][0] + x*y*coords[0].polyterms[1][0] + y*y*coords[0].polyterms[2][0] + + x*x*x*coords[0].polyterms[3][0] + x*x*y*coords[0].polyterms[4][0] + x*y*y*coords[0].polyterms[5][0] + y*y*y*coords[0].polyterms[6][0]); + Y = coords[0].cdelt2*(y - coords[0].crpix2 + x*x*coords[0].polyterms[0][1] + x*y*coords[0].polyterms[1][1] + y*y*coords[0].polyterms[2][1] + + x*x*x*coords[0].polyterms[3][1] + x*x*y*coords[0].polyterms[4][1] + x*y*y*coords[0].polyterms[5][1] + y*y*y*coords[0].polyterms[6][1]); + } else { + X = coords[0].cdelt1*(x - coords[0].crpix1); + Y = coords[0].cdelt2*(y - coords[0].crpix2); + } + L = (X*coords[0].pc1_1 + Y*coords[0].pc1_2); + M = (X*coords[0].pc2_1 + Y*coords[0].pc2_2); + + if (!strcmp(&coords[0].ctype[4], "-PLY") || !strcmp(&coords[0].ctype[4], "-TAN") || !strcmp(&coords[0].ctype[4], "-SIN") || !strcmp(&coords[0].ctype[0], "MM")) { + R = hypot (L,M); + if ((L == 0) && (M == 0)) { + sphi = 0; + cphi = 1; + } + else { + sphi = L / R; + cphi = -M / R; + } + + if (!strcmp(&coords[0].ctype[4], "-PLY") || !strcmp(&coords[0].ctype[4], "-TAN") ) { + if (R == 0) { + stht = 1.0; + ctht = 0.0; + } + else { + T = DEG_RAD / R; + stht = T / sqrt ( 1.0 + T*T); + ctht = 1.0 / sqrt ( 1.0 + T*T); + } + } + if (!strcmp(&coords[0].ctype[4], "-SIN") || !strcmp(&coords[0].ctype[0], "MM")) { + ctht = RAD_DEG * R; + stht = sqrt (1 - ctht*ctht); + } + + sdp = sin(RAD_DEG*coords[0].crval2); + cdp = cos(RAD_DEG*coords[0].crval2); + + sdel = stht*sdp - ctht*cphi*cdp; + salp = ctht*sphi; + calp = stht*cdp + ctht*cphi*sdp; + alpha = atan2 (salp, calp); + delta = asin (sdel); + + *ra = DEG_RAD*alpha + coords[0].crval1; + *dec = DEG_RAD*delta; + } + if (!strcmp(&coords[0].ctype[4], "-LIN") || !strcmp(&coords[0].ctype[0], "GENE")) { + *ra = L + coords[0].crval1; + *dec = M + coords[0].crval2; + } + +} + + +RD_to_XY (x, y, ra, dec, coords) +double *x, *y; +double ra, dec; +Coords coords[]; +{ + + double tmp_d; + double X, Y, sphi, cphi, stht; + double salp, calp, sdel, cdel, sdp, cdp; + + if (!strcmp(&coords[0].ctype[4], "-PLY")) { + /* fprintf (stderr, "approximate to polynomial TAN plane fit\n"); */ + } + + *x = 0; + *y = 0; + if (!strcmp(&coords[0].ctype[0], "GENE") || !strcmp(&coords[0].ctype[4], "-LIN")) { + X = (ra - coords[0].crval1); + Y = (dec - coords[0].crval2); + } + + if (!strcmp(&coords[0].ctype[4], "-PLY") || !strcmp(&coords[0].ctype[4], "-TAN") || !strcmp(&coords[0].ctype[4], "-SIN") || !strcmp(&coords[0].ctype[0], "MM")) { + sdp = sin(RAD_DEG*coords[0].crval2); + cdp = cos(RAD_DEG*coords[0].crval2); + salp = sin(RAD_DEG*(ra - coords[0].crval1)); + calp = cos(RAD_DEG*(ra - coords[0].crval1)); + sdel = sin(RAD_DEG*dec); + cdel = cos(RAD_DEG*dec); + + stht = sdel*sdp + cdel*cdp*calp; /* sin(theta) */ + sphi = cdel*salp; /* = cos(theta)*sin(phi) */ + cphi = cdel*sdp*calp - sdel*cdp; /* = cos(theta)*cos(phi) */ + + if (!strcmp(&coords[0].ctype[4], "-PLY") || !strcmp(&coords[0].ctype[4], "-TAN") ) { + X = DEG_RAD * sphi / stht; + Y = -DEG_RAD * cphi / stht; + } + if (!strcmp(&coords[0].ctype[4], "-SIN") || !strcmp(&coords[0].ctype[0], "MM")) { + X = DEG_RAD * sphi; + Y = -DEG_RAD * cphi; + } + X = X; + Y = Y; + } + + tmp_d = 1.0 / (coords[0].pc1_1*coords[0].pc2_2 - coords[0].pc1_2*coords[0].pc2_1); + *x = tmp_d * (coords[0].pc2_2*X - coords[0].pc1_2*Y) / coords[0].cdelt1 + coords[0].crpix1; + *y = tmp_d * (coords[0].pc1_1*Y - coords[0].pc2_1*X) / coords[0].cdelt2 + coords[0].crpix2; + +} + + +fRD_to_XY (x, y, ra, dec, coords) +float *x, *y; +double ra, dec; +Coords coords[]; +{ + + double tmp_d; + double X, Y, sphi, cphi, stht; + double salp, calp, sdel, cdel, sdp, cdp; + + *x = 0; + *y = 0; + if (!strcmp(&coords[0].ctype[0], "GENE") || !strcmp(&coords[0].ctype[4], "-LIN")) { + X = (ra - coords[0].crval1); + Y = (dec - coords[0].crval2); + } + + if (!strcmp(&coords[0].ctype[4], "-PLY") || !strcmp(&coords[0].ctype[4], "-TAN") || !strcmp(&coords[0].ctype[4], "-SIN") || !strcmp(&coords[0].ctype[0], "MM")) { + sdp = sin(RAD_DEG*coords[0].crval2); + cdp = cos(RAD_DEG*coords[0].crval2); + salp = sin(RAD_DEG*(ra - coords[0].crval1)); + calp = cos(RAD_DEG*(ra - coords[0].crval1)); + sdel = sin(RAD_DEG*dec); + cdel = cos(RAD_DEG*dec); + + stht = sdel*sdp + cdel*cdp*calp; /* sin(theta) */ + sphi = cdel*salp; /* = cos(theta)*sin(phi) */ + cphi = cdel*sdp*calp - sdel*cdp; /* = cos(theta)*cos(phi) */ + + if (!strcmp(&coords[0].ctype[4], "-PLY") || !strcmp(&coords[0].ctype[4], "-TAN") ) { + X = DEG_RAD * sphi / stht; + Y = -DEG_RAD * cphi / stht; + } + if (!strcmp(&coords[0].ctype[4], "-SIN") || !strcmp(&coords[0].ctype[0], "MM")) { + X = DEG_RAD * sphi; + Y = -DEG_RAD * cphi; + } + X = X; + Y = Y; + } + + tmp_d = 1.0 / (coords[0].pc1_1*coords[0].pc2_2 - coords[0].pc1_2*coords[0].pc2_1); + *x = tmp_d * (coords[0].pc2_2*X - coords[0].pc1_2*Y) / coords[0].cdelt1 + coords[0].crpix1; + *y = tmp_d * (coords[0].pc1_1*Y - coords[0].pc2_1*X) / coords[0].cdelt2 + coords[0].crpix2; + +} + + + +GetCoords (coords, header) +Coords coords[]; +Header header[]; +{ + + int status; + double rotate; + + rotate = 0.0; + coords[0].crval1 = coords[0].crpix1 = coords[0].cdelt1 = 0.0; + coords[0].crval2 = coords[0].crpix2 = coords[0].cdelt2 = 0.0; + coords[0].pc1_1 = coords[0].pc2_2 = 1.0; + coords[0].pc2_1 = coords[0].pc1_2 = 0.0; + strcpy (coords[0].ctype, "NONE"); + + status = TRUE; + if (fits_scan (header, "CTYPE2", "%s", 1, coords[0].ctype)) { + status = fits_scan (header, "CRVAL1", "%lf", 1, &coords[0].crval1); + status &= fits_scan (header, "CRPIX1", "%lf", 1, &coords[0].crpix1); + status &= fits_scan (header, "CRVAL2", "%lf", 1, &coords[0].crval2); + status &= fits_scan (header, "CRPIX2", "%lf", 1, &coords[0].crpix2); + if (fits_scan (header, "CDELT1", "%lf", 1, &coords[0].cdelt1)) { + status &= fits_scan (header, "CDELT2", "%lf", 1, &coords[0].cdelt2); + if (fits_scan (header, "CROTA2", "%lf", 1, &rotate)) { + coords[0].pc1_1 = cos(rotate*RAD_DEG); + coords[0].pc1_2 = -sin(rotate*RAD_DEG); + coords[0].pc2_1 = sin(rotate*RAD_DEG); + coords[0].pc2_2 = cos(rotate*RAD_DEG); + } + if (fits_scan (header, "PC001001", "%lf", 1, &coords[0].pc1_1)) { + status &= fits_scan (header, "PC001002", "%lf", 1, &coords[0].pc1_2); + status &= fits_scan (header, "PC002001", "%lf", 1, &coords[0].pc2_1); + status &= fits_scan (header, "PC002002", "%lf", 1, &coords[0].pc2_2); + } + } + else { + if (fits_scan (header, "CD1_1", "%lf", 1, &coords[0].pc1_1)) { + status &= fits_scan (header, "CD1_2", "%lf", 1, &coords[0].pc1_2); + status &= fits_scan (header, "CD2_1", "%lf", 1, &coords[0].pc2_1); + status &= fits_scan (header, "CD2_2", "%lf", 1, &coords[0].pc2_2); + coords[0].cdelt1 = coords[0].cdelt2 = 1.0; + } + else { + status = FALSE; + } + } + } + else { + if (fits_scan (header, "RA_O", "%lf", 1, &coords[0].crval1)) { + status = fits_scan (header, "RA_X", "%lf", 1, &coords[0].pc1_1); + status &= fits_scan (header, "RA_Y", "%lf", 1, &coords[0].pc1_2); + status &= fits_scan (header, "DEC_O", "%lf", 1, &coords[0].crval2); + status &= fits_scan (header, "DEC_X", "%lf", 1, &coords[0].pc2_1); + status &= fits_scan (header, "DEC_Y", "%lf", 1, &coords[0].pc2_2); + coords[0].crpix1 = coords[0].crpix2 = 0.0; + coords[0].cdelt1 = coords[0].cdelt2 = 1.0; + strcpy (coords[0].ctype, "GENE"); + } + } + if (!status) { + fprintf (stderr, "error getting all elements for coordinate mode %d\n", coords[0].ctype); + coords[0].crval1 = coords[0].crpix1 = coords[0].cdelt1 = 0.0; + coords[0].crval2 = coords[0].crpix2 = coords[0].cdelt2 = 0.0; + coords[0].pc1_1 = coords[0].pc2_2 = 1.0; + coords[0].pc2_1 = coords[0].pc1_2 = 0.0; + strcpy (coords[0].ctype, "NONE"); + } +} + + + /* -PLY projection is an extrapolation of the -TAN projection. + In addition to the usual linear terms of CRPIXi, PC00i00j, there are + higher order polynomial terms (up to 3rd order): + Axis 1 terms: + PCA1X2Y0 = coords.polyterm[0][0] = x^2 + PCA1X1Y1 = coords.polyterm[1][0] = xy + PCA1X0Y2 = coords.polyterm[2][0] = y^2 + PCA1X3Y0 = coords.polyterm[3][0] = x^3 + PCA1X2Y1 = coords.polyterm[4][0] = x^2 y + PCA1X1Y2 = coords.polyterm[5][0] = x y^2 + PCA1X0Y3 = coords.polyterm[6][0] = y^2 + Axis 2 terms: + PCA2X2Y0 = coords.polyterm[0][1] = x^2 + PCA2X1Y1 = coords.polyterm[1][1] = xy + PCA2X0Y2 = coords.polyterm[2][1] = y^2 + PCA2X3Y0 = coords.polyterm[3][1] = x^3 + PCA2X2Y1 = coords.polyterm[4][1] = x^2 y + PCA2X1Y2 = coords.polyterm[5][1] = x y^2 + PCA2X0Y3 = coords.polyterm[6][1] = y^2 + */ Index: /tags/getstar-1-0/Ohana/src/getstar/src/find_matches.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/find_matches.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/find_matches.c (revision 2513) @@ -0,0 +1,57 @@ +# include "getstar.h" + +Stars *find_matches (Catalog *catalog, Image *image, int start, int end, Stars *stars, int *Nstar) { + + int i, n, N, NSTARS; + int photcode; + + if (stars == (Stars *) NULL) { + N = 0; + NSTARS = 1000; + ALLOCATE (stars, Stars, NSTARS); + } else { + N = *Nstar; + NSTARS = N + 1000; + REALLOCATE (stars, Stars, NSTARS); + } + + /* identify selection criteria */ + photcode = -1; + if ((start == 0) && (end == 0)) { + start = image[0].tzero; + end = image[0].tzero + 1e-4*image[0].NY*image[0].trate; /* trate is in 0.1 msec / row */ + photcode = image[0].source; + } + if (VERBOSE) fprintf (stderr, "extracting for range %d to %d (photcode %s)\n", start, end, photcode); + + for (i = 0; (i < catalog[0].Nmeasure); i++) { + if ((i % 10000) == 0) fprintf (stderr, ". "); + if ((catalog[0].measure[i].t >= start) && (catalog[0].measure[i].t <= end) && (photcode == catalog[0].measure[i].source)) { + n = catalog[0].measure[i].averef; + stars[N].R = catalog[0].average[n].R - catalog[0].measure[i].dR / 360000.0; + stars[N].D = catalog[0].average[n].D - catalog[0].measure[i].dD / 360000.0; + + stars[N].M = 0.001*(catalog[0].measure[i].M - catalog[0].measure[i].dt); + stars[N].dM = catalog[0].measure[i].dM; + stars[N].dophot = catalog[0].measure[i].dophot; + + stars[N].Mgal = 0.001*(catalog[0].measure[i].Mgal - catalog[0].measure[i].dt); + + stars[N].fx = 0.01*catalog[0].measure[i].FWx; + stars[N].fy = stars[N].fx * 0.01*catalog[0].measure[i].fwy; + stars[N].df = (360.0/255.0)*catalog[0].measure[i].theta; + stars[N].found = catalog[0].measure[i].flags; + + N ++; + if (N == NSTARS) { + NSTARS += 1000; + REALLOCATE (stars, Stars, NSTARS); + } + + } + } + fprintf (stderr, "found %d meas\n", N); + *Nstar = N; + return (stars); +} + Index: /tags/getstar-1-0/Ohana/src/getstar/src/gcatalog.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/gcatalog.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/gcatalog.c (revision 2513) @@ -0,0 +1,45 @@ +# include "getstar.h" + +int gcatalog (Catalog *catalog) { + + int Nsecfilt; + char mode; + + /* read catalog header */ + mode = LOAD_AVES | LOAD_MEAS | LOAD_MISS | LOAD_SECF; + if (!load_catalog (catalog, mode, VERBOSE)) { + fprintf (stderr, "ERROR: failure loading catalog\n"); + exit (1); + } + + /* check Nsecfile value, update if needed */ + Nsecfilt = GetPhotcodeNsecfilt (); + if (catalog[0].Nsecfilt < Nsecfilt) { + + int i, j, Nextra, in, out; + SecFilt *insec, *outsec; + + Nextra = Nsecfilt - catalog[0].Nsecfilt; + insec = catalog[0].secfilt; + ALLOCATE (outsec, SecFilt, catalog[0].Naverage * Nsecfilt); + for (in = out = i = 0; i < catalog[0].Naverage; i++) { + for (j = 0; j < catalog[0].Nsecfilt; j++, in++, out++) { + outsec[out].M = insec[in].M; + outsec[out].Xm = insec[in].Xm; + } + for (j = 0; j < Nextra; j++, out++) { + outsec[out].M = NO_MAG; + outsec[out].Xm = NO_MAG; + } + } + free (catalog[0].secfilt); + catalog[0].secfilt = outsec; + catalog[0].Nsecfilt = Nsecfilt; + } + + if (catalog[0].Nsecfilt > Nsecfilt) { + fprintf (stderr, "ERROR: can't reduce number of secondary filters\n"); + exit (1); + } + return (TRUE); +} Index: /tags/getstar-1-0/Ohana/src/getstar/src/getstar.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/getstar.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/getstar.c (revision 2513) @@ -0,0 +1,49 @@ +# include "getstar.h" + +main (int argc, char **argv) { + + int i, Nstars, Nregions; + Image *image, *gimages(), *gtimes(), *find_images(); + Catalog catalog; + GSCRegion *region, *tregion, *gregions(); + Stars *stars; + + args (argc, argv); + + image = gimages (argv[1]); + + region = gregions (&image[0], &Nregions); + + stars = (Stars *) NULL; + Nstars = 0; + + for (i = 0; i < Nregions; i++) { + if (VERBOSE) fprintf (stderr, "extracting from %s\n", region[i].filename); + catalog.filename = region[i].filename; /* don't free region before catalog! */ + switch (lock_catalog (&catalog, LCK_SOFT)) { + case 0: + fprintf (stderr, "ERROR: can't lock file\n"); + exit (1); + case 1: + gcatalog (&catalog); + break; + case 2: + fprintf (stderr, "no data in %s, skipping\n", catalog.filename); + catalog.Naverage = 0; + catalog.Nmeasure = 0; + break; + default: + fprintf (stderr, "weird lock_catalog exit state\n"); + exit (1); + } + unlock_catalog (&catalog); + stars = find_matches (&catalog, &image[0], 0, 0, stars, &Nstars); + } + + /* write out the selected stars */ + clean_stars (stars, &Nstars, image); + wstars (argv[2], stars, Nstars, image); + fprintf (stderr, "SUCCESS\n"); + exit (0); + +} Index: /tags/getstar-1-0/Ohana/src/getstar/src/gimages.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/gimages.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/gimages.c (revision 2513) @@ -0,0 +1,63 @@ +# include "getstar.h" + +Image *gimages (char *filename) { + + int i, size, Nimage, nimage; + double zeropt; + struct stat filestatus; + FILE *f; + Image *timage, *image; + Header header; + + f = fopen (ImageCat, "r"); + if (f == (FILE *) NULL) { + fprintf (stderr, "error opening image cat %s\n", ImageCat); + exit (1); + } + + /* read header */ + if (!fits_load_header (f, &header)) { + if (VERBOSE) fprintf (stderr, "ERROR: can't read image catalog %s\n", ImageCat); + exit (1); + } + + fits_scan (&header, "ZERO_PT", "%lf", 1, &zeropt); + if (fabs (ZeroPt - zeropt) > 1e-4) { + fprintf (stderr, "ERROR: zero point in image table (%f:%s) inconsistent with zero point in image header (%f:%s)\n", + zeropt, ImageCat, ZeroPt, filename); + exit (1); + } + + /* advance to data segment */ + fseek (f, header.size, SEEK_SET); + + Nimage = 0; + fits_scan (&header, "NIMAGES", "%d", 1, &Nimage); + /* check that file size makes sense */ + if (stat (ImageCat, &filestatus) == -1) { + fprintf (stderr, "ERROR: failed to get status of image catalog\n"); + exit (1); + } + size = Nimage*sizeof(Image) + header.size; + if (size != filestatus.st_size) { + fprintf (stderr, "ERROR: image catalog has inconsistent size\n"); + exit (1); + } + + ALLOCATE (timage, Image, Nimage); + nimage = Fread (timage, sizeof(Image), Nimage, f, "image"); + if (nimage != Nimage) { + fprintf (stderr, "error reading images from table\n"); + exit (1); + } + + ALLOCATE (image, Image, 1); + for (i = 0; i < Nimage; i++) { + if (strcmp (timage[i].name, filename)) continue; + memcpy (image, &timage[i], sizeof(Image)); + return (image); + } + + fprintf (stderr, "error: failed to find desired image\n"); + exit (1); +} Index: /tags/getstar-1-0/Ohana/src/getstar/src/gregions.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/gregions.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/gregions.c (revision 2513) @@ -0,0 +1,56 @@ +# include "getstar.h" + +GSCRegion *gregions (image, Nregions) +Image *image; +int *Nregions; +{ + + GSCRegion *region; + FILE *f; + double x, y; + double dr, dd, dec, ra; + int i, j, done, nregion, NREGION; + + f = fopen (GSCFILE, "r"); + if (f == NULL) { + fprintf (stderr, "ERROR: can't find GSC region file %s\n", GSCFILE); + exit (1); + } + + /* find regions at image corners */ + NREGION = 10; + ALLOCATE (region, GSCRegion, NREGION); + nregion = 0; + + /* look for new regions on grid across image */ + for (x = 0.0; x <= 1.0; x+=0.25) { + for (y = 0.0; y <= 1.0; y+=0.25) { + XY_to_RD (&ra, &dec, image[0].NX*(1.1*x - 0.05), image[0].NY*(1.1*y - 0.05), &image[0].coords); + aregion (®ion[nregion], f, ra, dec); + done = FALSE; + for (j = 0; (j < nregion) && !done; j++) { + if (!strcmp (region[nregion].filename, region[j].filename)) { + nregion --; + done = TRUE; + } + } + nregion ++; + if (nregion == NREGION) { + NREGION += 10; + REALLOCATE (region, GSCRegion, NREGION); + } + } + } + + if (VERBOSE) { + fprintf (stderr, "found %d region files:\n", nregion); + for (i = 0; i < nregion; i++) { + fprintf (stderr, " %d %s\n", i, region[i].filename); + } + } + *Nregions = nregion; + + fclose (f); + return (region); + +} Index: /tags/getstar-1-0/Ohana/src/getstar/src/gstars.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/gstars.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/gstars.c (revision 2513) @@ -0,0 +1,276 @@ +# include "addstar.h" +# define D_NSTARS 1000 +# define BYTES_STAR 66 +# define BLOCK 1000 +#include +#include + +Stars *gstars (file, NSTARS, image) +char file[]; +int *NSTARS; +Image *image; +{ + + FILE *f; + Header header; + int j, N, Ninstar; + int nbytes, Nbytes; + Stars *stars; + char *buffer, *c, *c2, photcode[64]; + double tmp; + int done, doneread, Nskip, Nextra, itmp; + unsigned short int Nc; + + if (!fits_read_header (file, &header)) { + fprintf (stderr, "ERROR: can't read header for %s\n", file); + exit (1); + } + + /* open file */ + f = fopen (file, "r"); + if (f == NULL) { + fprintf (stderr, "ERROR: can't read data from %s\n", file); + exit (1); + } + fseek (f, header.size, SEEK_SET); + + /* find image rootname */ + c = strrchr (file, 0x2f); + if (c == (char *) NULL) { + strcpy (image[0].name, file); + } else { + strcpy (image[0].name, (c+1)); + } + + /* get astrometry information */ + if (!GetCoords (&image[0].coords, &header)) { + fprintf (stderr, "ERROR: no astrometric solution in header\n"); + exit (1); + } + while (image[0].coords.crval1 < 0) image[0].coords.crval1 += 360.0; + while (image[0].coords.crval1 > 360.0) image[0].coords.crval1 -= 360.0; + itmp = 0; + fits_scan (&header, "NASTRO", "%d", 1, &itmp); + if ((itmp == 0) && !ACCEPT_ASTROM) { + fprintf (stderr, "ERROR: bad astrometric solution in header\n"); + exit (1); + } + + /* CERROR in data file is in arcsec */ + if (!fits_scan (&header, "CERROR", "%lf", 1, &tmp)) tmp = 1.0; + image[0].cerror = tmp * 50.0; + fits_scan (&header, "NAXIS1", "%hd", 1, &image[0].NX); + fits_scan (&header, "NAXIS2", "%hd", 1, &image[0].NY); + + /* get photcode from header */ + if (thiscode == NULL) { + fits_scan (&header, "PHOTCODE", "%s", 1, photcode); + thiscode = GetPhotcodebyName (photcode); + } + if (thiscode == NULL) { + fprintf (stderr, "ERROR: photcode %s not found in photcode table\n", photcode); + exit (1); + } + image[0].source = thiscode[0].code; + + image[0].NX -= XOVERSCAN; + image[0].NY -= YOVERSCAN; + fits_scan (&header, ExptimeKeyword, "%lf", 1, &tmp); + image[0].exptime = tmp; + + tmp = 0; + /* fits_scan (&header, "APMIFIT", "%lf", 1, &tmp); */ + image[0].apmifit = tmp * 1000.0; + + tmp = 0; + /* fits_scan (&header, "dAPMIFIT", "%lf", 1, &tmp); */ + image[0].dapmifit = tmp * 1000.0; + + tmp = 0; + fits_scan (&header, "FLIMIT", "%lf", 1, &tmp); + image[0].detection_limit = tmp * 10.0; + + tmp = 0; + fits_scan (&header, "FSATUR", "%lf", 1, &tmp); + image[0].saturation_limit = tmp * 10.0; + + tmp = 0; + fits_scan (&header, "FWHM_X", "%lf", 1, &tmp); + image[0].fwhm_x = tmp * 25.0 * image[0].coords.cdelt1 * 3600.0; + + tmp = 0; + fits_scan (&header, "FWHM_Y", "%lf", 1, &tmp); + image[0].fwhm_y = tmp * 25.0 * image[0].coords.cdelt1 * 3600.0; + + if (!fits_scan (&header, "TZERO", "%d", 1, &image[0].tzero)) { + image[0].tzero = parse_time (&header); + } + + tmp = 0; + fits_scan (&header, "TRATE", "%lf", 1, &tmp); + image[0].trate = 10000 * tmp; + + tmp = 0; + fits_scan (&header, AirmassKeyword, "%lf", 1, &tmp); + image[0].secz = MIN (NO_MAG, 1000*tmp); + + if (!fits_scan (&header, CCDNumKeyword, "%d", 1, &itmp)) { + image[0].ccdnum = 0xff; + } else { + image[0].ccdnum = itmp; + } + + fits_scan (&header, "ZERO_PT", "%lf", 1, &ZeroPt); + + /* secz is in units milli-airmass */ + image[0].Mcal = 0.0; + image[0].code = 0; + image[0].Xm = NO_MAG; + bzero (image[0].dummy, sizeof(image[0].dummy)); + + /* find expected number of stars */ + fits_scan (&header, "NSTARS", "%d", 1, &image[0].nstar); + if (image[0].nstar == 0) { + fprintf (stderr, "ERROR: can't get NSTARS from header\n"); + exit (1); + } + ALLOCATE (stars, Stars, image[0].nstar); + + /* load in stars by blocks of 1000 */ + N = 0; + ALLOCATE (buffer, char, (BLOCK*BYTES_STAR) + 1); + buffer[BLOCK*BYTES_STAR] = 0; + Nextra = 0; + doneread = FALSE; + while (!doneread) { + Nbytes = BYTES_STAR * BLOCK - Nextra; + nbytes = Fread (&buffer[Nextra], 1, Nbytes, f, "char"); + if (nbytes == 0) { + doneread = TRUE; + continue; + } + nbytes += Nextra; + /* check line-by-line integrity */ + c = buffer; + done = FALSE; + while ((c < buffer + nbytes) && (!done)) { + for (c2 = c; *c2 == '\n'; c2++); + if (c2 > c) { /* extra return chars */ + memmove (c, c2, (int)(buffer + nbytes - c2)); + Nskip = c2 - c; + nbytes -= Nskip; + bzero (buffer + nbytes, Nskip); + if (VERBOSE) fprintf (stderr, "deleted %d extra return chars\n", Nskip); + } + c2 = strchr (c, '\n'); + if (c2 == (char *) NULL) { + done = TRUE; + continue; + } + c2++; + if ((c2 - c) != BYTES_STAR) { /* bad line, delete it */ + memmove (c, c2, (int)(buffer + nbytes - c2)); + Nskip = c2 - c; + nbytes -= Nskip; + bzero (buffer + nbytes, Nskip); + if (VERBOSE) fprintf (stderr, "deleted line, %d extra chars\n", Nskip); + } else { + c = c2; + } + } + Ninstar = nbytes / BYTES_STAR; + Nextra = nbytes % BYTES_STAR; + for (j = 0; j < Ninstar; j++, N++) { + dparse (&stars[N].X, 1, &buffer[j*BYTES_STAR]); + dparse (&stars[N].Y, 2, &buffer[j*BYTES_STAR]); + dparse (&stars[N].M, 3, &buffer[j*BYTES_STAR]); + dparse (&stars[N].dM, 4, &buffer[j*BYTES_STAR]); + /* allow for some dynamic filtering of star list */ + if (stars[N].dM > 1000.0 / SNLIMIT) { N--; continue; } + if (XMAX && (stars[N].X > XMAX)) { N--; continue; } + if (XMIN && (stars[N].X < XMIN)) { N--; continue; } + if (YMAX && (stars[N].Y > YMAX)) { N--; continue; } + if (YMIN && (stars[N].Y < YMIN)) { N--; continue; } + + dparse (&tmp, 5, &buffer[j*BYTES_STAR]); + stars[N].dophot = tmp; + dparse (&stars[N].Mgal, 7, &buffer[j*BYTES_STAR]); + dparse (&stars[N].Map, 8, &buffer[j*BYTES_STAR]); + dparse (&stars[N].fx, 9, &buffer[j*BYTES_STAR]); + dparse (&stars[N].fy, 10, &buffer[j*BYTES_STAR]); + dparse (&stars[N].df, 11, &buffer[j*BYTES_STAR]); + + XY_to_RD (&stars[N].R, &stars[N].D, stars[N].X, stars[N].Y, &image[0].coords); + while (stars[N].R < 0.0) stars[N].R += 360.0; + while (stars[N].R >= 360.0) stars[N].R -= 360.0; + stars[N].found = -1; + } + } + + image[0].nstar = N; + REALLOCATE (stars, Stars, image[0].nstar); + if (VERBOSE) fprintf (stderr, "read %d stars from target file\n", image[0].nstar); + *NSTARS = image[0].nstar; + + return (stars); +} + + + + +# if (0) + /* left over fraction of a block */ + nbytes = Fread (buffer, 1, (Nbytes % (BLOCK*BYTES_STAR)), f, "char"); + if (nbytes != (Nbytes % (BLOCK*BYTES_STAR))) { + fprintf (stderr, "ERROR: failed to read in stars (2)\n"); + exit (1); + } + /* check line-by-line integrity */ + Nnew = 0; + c = buffer; + done = FALSE; + while ((c < buffer + nbytes) && (!done)) { + for (c2 = c; *c2 == '\n'; c2++); + if (c2 > c) { /* extra return chars */ + memmove (c, c2, (int)(buffer + nbytes - c2)); + Nnew += c2 - c; + fprintf (stderr, "deleting %d extra return chars\n", (int)(c2-c)); + } + c2 = strchr (c, '\n'); + if (c2 == (char *) NULL) { + if (Nnew > 0) { + nnew = Fread (&buffer[nbytes-Nnew], 1, Nnew, f, "char"); + if (nnew != Nnew) { + fprintf (stderr, "ERROR: failed to read in stars (1)\n"); + exit (1); + } + } else { + done = TRUE; + } + continue; + } + c2++; + if ((c2 - c) != BYTES_STAR) { + /* this is a bad line, delete it, adjust data in buffer, + and be ready to read the rest of the last line */ + memmove (c, c2, (int)(buffer + nbytes - c2)); + Nnew += c2 - c; + fprintf (stderr, "deleting bad line with %d chars\n", (int)(c2-c)); + } else { + c = c2; + } + } + for (j = 0; j < nbytes / BYTES_STAR; j++, nstar++, N++) { + dparse (&stars[N].X, 1, &buffer[j*BYTES_STAR]); + dparse (&stars[N].Y, 2, &buffer[j*BYTES_STAR]); + dparse (&stars[N].M, 3, &buffer[j*BYTES_STAR]); + dparse (&stars[N].dM, 4, &buffer[j*BYTES_STAR]); + XY_to_RD (&stars[N].R, &stars[N].D, stars[N].X, stars[N].Y, &image[0].coords); + while (stars[N].R < 0.0) stars[N].R += 360.0; + while (stars[N].R >= 360.0) stars[N].R -= 360.0; + dparse (&tmp, 5, &buffer[j*BYTES_STAR]); + stars[N].dophot = tmp; + stars[N].found = -1; + } + +# endif Index: /tags/getstar-1-0/Ohana/src/getstar/src/misc.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/misc.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/misc.c (revision 2513) @@ -0,0 +1,398 @@ +# include "getstar.h" + +/***** convert [-]00:00:00 to 0.0000 ****/ +int dms_to_ddd (double *Value, char *string) { + + int valid, neg, status; + double tmp, value; + char *p1, *p2, *px; + + valid = FALSE; + neg = FALSE; + stripwhite (string); + p1 = string; + px = string + strlen(string); + + if (string[0] == '-') { + valid = TRUE; + neg = TRUE; + p1 = &string[1]; + } + if (string[0] == '+') { + valid = TRUE; + neg = FALSE; + p1 = &string[1]; + } + if (isdigit(string[0])) { + valid = TRUE; + p1 = &string[0]; + } + if (!valid) { return (FALSE); } + + status = 1; + tmp = strtod (p1, &p2); + if (p2 == p1) return (FALSE); /* entry not a number: +fred */ + value = tmp; + if (p2 == px) goto escape; /* entry only number: +1.0 */ + p1 = p2 + 1; + + tmp = strtod (p1, &p2); + if (p2 == p1) goto escape; /* entry not a number: +1:fred */ + status = 2; + value += tmp / 60.0; + if (p2 == px) goto escape; /* entry only number: +1:1 */ + p1 = p2 + 1; + + tmp = strtod (p1, &p2); + if (p2 == p1) goto escape; /* entry not a number: +1:1:fred */ + value += tmp / 3600.0; + + escape: + if (neg) { + value *= -1; + } + *Value = value; + + return (status); +} + +/**********/ +int str_to_radec (double *ra, double *dec, char *str1, char *str2) { + + double Ra, Dec; + + *ra = *dec = 0; + switch (dms_to_ddd (&Ra, str1)) { + case 0: + fprintf (stderr, "syntax error in RA\n"); + return (FALSE); + case 1: + break; + case 2: + Ra = Ra * 15; + break; + } + switch (dms_to_ddd (&Dec, str2)) { + case 0: + fprintf (stderr, "syntax error in DEC\n"); + return (FALSE); + case 1: + case 2: + break; + } + *ra = Ra; + *dec = Dec; + return (TRUE); +} + +# define FORMAT_DAYS 1 +# define FORMAT_HOURS 2 +# define FORMAT_MINUTES 3 +# define FORMAT_SECONDS 4 +# define FORMAT_JD 5 +# define FORMAT_DATE 6 + +/**********/ +int chk_time (char *line) { + + char *p1, *p2; + double tmp; + int mode; + + p1 = line; + tmp = strtod (p1, &p2); + if (p2 == p1 + strlen (p1) - 1) { + if (*p2 == 'd') { + mode = FORMAT_DAYS; + } + if (*p2 == 'h') { + mode = FORMAT_HOURS; + } + if (*p2 == 'm') { + mode = FORMAT_MINUTES; + } + if (*p2 == 's') { + mode = FORMAT_SECONDS; + } + if (*p2 == 'j') { + mode = FORMAT_JD; + } + } else { + mode = FORMAT_DATE; + } + return (mode); +} + +/**********/ +int str_to_time (char *line, unsigned int *second) { + + char *tmpline; + struct tm *gmt; + struct timeval now; + double jd; + unsigned long tsec; + + if (!strcasecmp (line, "NOW")) { + gettimeofday (&now, (struct timezone *) NULL); + *second = now.tv_sec; + return (TRUE); + } + + if (!strncasecmp (line, "TODAY", 5)) { + gettimeofday (&now, (struct timezone *) NULL); + if (line[5]) { /* line has extra data (ie, hh:mm:ss) */ + tsec = now.tv_sec; + ALLOCATE (tmpline, char, 64); + gmt = gmtime (&tsec); + sprintf (tmpline, "%04d/%02d/%02d,%s", + 1900 + gmt[0].tm_year, gmt[0].tm_mon+1, gmt[0].tm_mday, &line[6]); + *second = date_to_sec (tmpline); + free (tmpline); + return (TRUE); + } else { + *second = 86400 * ((int)(now.tv_sec / 86400)); + return (TRUE); + } + } + + switch (chk_time (line)) { + case 0: + return (FALSE); + case FORMAT_DAYS: + *second = strtod (line, 0) * 86400.0; + return (TRUE); + case FORMAT_HOURS: + *second = strtod (line, 0) * 3600.0; + return (TRUE); + case FORMAT_MINUTES: + *second = strtod (line, 0) * 60.0; + return (TRUE); + case FORMAT_SECONDS: + *second = strtod (line, 0); + return (TRUE); + case FORMAT_JD: + jd = strtod (line, 0); + *second = jd_to_sec (jd); + return (TRUE); + case FORMAT_DATE: + *second = date_to_sec (line); + return (TRUE); + } + return (FALSE); +} + + +/**********/ +int str_to_dtime (char *line, double *second) { + + switch (chk_time (line)) { + case 0: + case FORMAT_JD: + case FORMAT_DATE: + return (FALSE); + case FORMAT_DAYS: + *second = strtod (line, 0) * 86400.0; + return (TRUE); + case FORMAT_HOURS: + *second = strtod (line, 0) * 3600.0; + return (TRUE); + case FORMAT_MINUTES: + *second = strtod (line, 0) * 60.0; + return (TRUE); + case FORMAT_SECONDS: + *second = strtod (line, 0); + return (TRUE); + } + return (FALSE); +} + +/**********/ +double sec_to_jd (unsigned long second) { + + double jd; + + jd = second/86400.0 + 2440587.5; + return (jd); +} + +/**********/ +unsigned long int jd_to_sec (double jd) { + + unsigned long int second; + + second = (jd - 2440587.5)*86400; + return (second); +} + +/**********/ +char *sec_to_date (unsigned long second) { + + struct tm *gmt; + char *line; + + ALLOCATE (line, char, 64); + gmt = gmtime (&second); + sprintf (line, "%04d/%02d/%02d,%02d:%02d:%02d", + 1900 + gmt[0].tm_year, gmt[0].tm_mon+1, gmt[0].tm_mday, + gmt[0].tm_hour, gmt[0].tm_min, gmt[0].tm_sec); + return (line); + +} + +/***** date in format yyyy/mm/dd,hh:mm:ss *****/ +unsigned long date_to_sec (char *date) { + + unsigned long second; + double tmp, jd; + struct tm now; + char *p1, *p2, *px; + + p1 = date; + px = date + strlen(date); + bzero (&now, sizeof(now)); + + tmp = strtod (p1, &p2); + if (p2 == p1) goto escape; + now.tm_year = tmp; + if (now.tm_year > 1000) now.tm_year -= 1900; + if (now.tm_year < 50) now.tm_year += 100; + if (p2 == px) goto escape; + p1 = p2 + 1; + + tmp = strtod (p1, &p2); + if (p2 == p1) goto escape; + now.tm_mon = tmp - 1; /* mon runs from 0 - 11 */ + if (p2 == px) goto escape; + p1 = p2 + 1; + + tmp = strtod (p1, &p2); + if (p2 == p1) goto escape; + now.tm_mday = tmp; + if (p2 == px) goto escape; + p1 = p2 + 1; + + tmp = strtod (p1, &p2); + if (p2 == p1) goto escape; + p1 = p2 + 1; + now.tm_hour = tmp; + if (p2 == px) goto escape; + + tmp = strtod (p1, &p2); + if (p2 == p1) goto escape; + now.tm_min = tmp; + if (p2 == px) goto escape; + p1 = p2 + 1; + + tmp = strtod (p1, &p2); + if (p2 == p1) goto escape; + now.tm_sec = tmp; + if (p2 == px) goto escape; + p1 = p2 + 1; + + escape: + jd = now.tm_mday - 32075 + (int)(1461*(1900 + now.tm_year + 4800 + (int)(((now.tm_mon+1)-14)/12))/4) + + (int)(367*((now.tm_mon+1) - 2 - (int)(((now.tm_mon+1) - 14)/12)*12)/12) + - (int)(3*(int)((1900 + now.tm_year + 4900 + (int)(((now.tm_mon+1) - 14)/12))/100)/4) - 0.5; + + second = (jd - 2440587.5)*86400 + 3600.0*now.tm_hour + now.tm_min*60.0 + now.tm_sec; + + return (second); +} + + + +/* times may be in forms as: + 20040200450s (N seconds since 1970.0) + 2440900.232j (julian date) + 99/02/23,03:22:18 (date string) + (separators may be anything except space, +, -) + 99:02:15:12:23:30 + 99:02:15:12h23m30s + */ + + +int GetTimeFormat (unsigned int *TimeReference, int *TimeFormat) { + + char *p; + + *TimeReference = 0; + if ((p = get_variable ("TIMEREF")) != (char *) NULL) { + if (!str_to_time (p, TimeReference)) { + fprintf (stderr, "error in TIME_REF format\n"); + return (FALSE); + } + free (p); + } + *TimeFormat = FALSE; + if ((p = get_variable ("TIMEFORMAT")) != (char *) NULL) { + if (!strcasecmp (p, "date")) *TimeFormat = TIME_DATE; + if (!strcasecmp (p, "hours")) *TimeFormat = TIME_HOURS; + if (!strcasecmp (p, "days")) *TimeFormat = TIME_DAYS; + if (!strcasecmp (p, "JD")) *TimeFormat = TIME_JD; + if (!strcasecmp (p, "MJD")) *TimeFormat = TIME_MJD; + if (!strcasecmp (p, "sec")) *TimeFormat = TIME_SEC; + if (!*TimeFormat) fprintf (stderr, "unknown TIME_FORMAT\n"); + free (p); + return (FALSE); + } + if (!*TimeFormat) *TimeFormat = TIME_SEC; + return (TRUE); +} + +/* convert UNIX time to a value referenced to the TimeReference in the given unit */ +double TimeValue (unsigned int time, unsigned int TimeReference, int TimeFormat) { + + double value, dt; + + dt = (time > TimeReference) ? (time - TimeReference) : -1 * (double)(TimeReference - time); + switch (TimeFormat) { + case TIME_HOURS: + value = dt / 3600.0; + break; + case TIME_DAYS: + value = dt / 86400.0; + break; + case TIME_JD: + value = time / 86400.0 + 2440587.5; + break; + case TIME_MJD: + value = time / 86400.0 + 40587.0; + break; + case TIME_SEC: + default: + value = dt; + break; + } + return (value); +} + +/* convert time value referenced to the TimeReference in the given unit to UNIX time */ +unsigned int TimeRef (double value, unsigned int TimeReference, int TimeFormat) { + + int dt; + unsigned int time; + + switch (TimeFormat) { + case TIME_HOURS: + dt = value * 3600.0; + break; + case TIME_DAYS: + dt = value * 86400.0; + break; + case TIME_JD: + time = (value - 2440587.5) * 86400.0; + return (time); + break; + case TIME_MJD: + time = (value - 40587.0) * 86400.0; + return (time); + break; + case TIME_SEC: + default: + dt = value; + break; + } + + time = TimeReference + dt; + return (time); +} Index: /tags/getstar-1-0/Ohana/src/getstar/src/mkcatalog.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/mkcatalog.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/mkcatalog.c (revision 2513) @@ -0,0 +1,42 @@ +# include "addstar.h" +# include + +mkcatalog (GSCRegion *region, Catalog *catalog) { + + char filename[64], line[64]; + int i, Nmeas, Nmiss; + struct tm *local; + struct timeval now; + char mode; + int status, Nextra, in, out, j; + SecFilt *insec, *outsec; + + if (VERBOSE) fprintf (stderr, "new catalog file: %s\n", region[0].filename); + if (!fits_read_header (CatTemplate, &catalog[0].header)) { + fprintf (stderr, "ERROR: can't find template header %s\n", CatTemplate); + exit (1); + } + + /* assign header values for RA, DEC, DATE, etc */ + fits_modify (&catalog[0].header, "RA0", "%lf", 1, region[0].RA[0]); + fits_modify (&catalog[0].header, "DEC0", "%lf", 1, region[0].DEC[0]); + fits_modify (&catalog[0].header, "RA1", "%lf", 1, region[0].RA[1]); + fits_modify (&catalog[0].header, "DEC1", "%lf", 1, region[0].DEC[1]); + gettimeofday (&now, NULL); + local = localtime (&now.tv_sec); + sprintf (line, "%02d/%02d/%02d\0", local[0].tm_year, local[0].tm_mon + 1, local[0].tm_mday); + fits_modify (&catalog[0].header, "DATE", "%s", 1, line); + strcpy (filename, CatTemplate); + ALLOCATE (catalog[0].average, Average, 1); + ALLOCATE (catalog[0].measure, Measure, 1); + ALLOCATE (catalog[0].missing, Missing, 1); + catalog[0].Naverage = catalog[0].Nmeasure = catalog[0].Nmissing = 0; + + /* setup secondary filters to match photcodes */ + ALLOCATE (catalog[0].secfilt, SecFilt, 1); + catalog[0].Nsecfilt = GetPhotcodeNsecfilt (); + + /* Nsecfilt is number of filters. Number of entries in array is + Nsecfilt * Naverage. At this point, N entries == 0 */ + +} Index: /tags/getstar-1-0/Ohana/src/getstar/src/old/ForkToServer.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/old/ForkToServer.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/old/ForkToServer.c (revision 2513) @@ -0,0 +1,77 @@ +# include + +int ForkToServer (int argc, char **argv, char *database, char *server) { + + int i, fd, N, pid, status; + char **arglist, *p; + char hostname[1025]; + struct timeval now, then; + double dtime; + + /* get local hostname */ + if (gethostname (hostname, 1024)) { + fprintf (stderr, "ERROR: can't get hostname\n"); + exit (1); + } + + /* lock database file */ + fd = setlockfile (database, 60.0, TRUE); + if (fd == -1) { + fprintf (stderr, "ERROR: can't set lock on %s\n", database); + exit (1); + } + + if ((p = strchr (server, '.')) != (char *) NULL) *p = 0; + if ((p = strchr (hostname, '.')) != (char *) NULL) *p = 0; + + if (!strcasecmp (hostname, server)) return (fd); + + if (!strlen (server)) { + fprintf (stderr, "ERROR: no Database Server defined\n"); + clearlockfile (database, fd, TRUE); + exit (1); + } + + /* get start of fork time */ + gettimeofday (&then, (void *) NULL); + pid = fork (); + if (!pid) { + /* must be child process, fork to remote machine */ + + /* create argument list */ + N = argc + 4; + ALLOCATE (arglist, char *, N); + + arglist[0] = strcreate ("rsh"); + arglist[1] = strcreate (server); + arglist[2] = strcreate (argv[0]); + arglist[3] = strcreate ("-remote"); + for (i = 4; i < N; i++) { + arglist[i] = strcreate (argv[i-3]); + } + fprintf (stderr, "starting remote process on %s\n", server); + status = execvp ("rsh", arglist); + fprintf (stderr, "ERROR: can't start remote shell process\n"); + exit (1); + } + /* it would be good to put rsh in the config file */ + + /* block until child exits */ + wait (0); + + /***** + inetd has a maximum connection rate of 40 / 60 seconds it will + block for 10 min if this rate is exceeded. this is here because + we have to hold the lock long enough that the connection rate does + not get exceeded. We actually use 3.0 seconds to avoid stealing + too many rsh slots. + *****/ + + gettimeofday (&now, (void *) NULL); + dtime = 1e6*(3.0 - DTIME(now,then)); + if (dtime > 0) usleep (dtime); + + clearlockfile (database, fd, TRUE); + exit (0); + +} Index: /tags/getstar-1-0/Ohana/src/getstar/src/old/add_unfound.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/old/add_unfound.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/old/add_unfound.c (revision 2513) @@ -0,0 +1,35 @@ + /* incorporate unmatched image stars -- after all catalogs searched... */ + for (i = 0; i < Nstars; i++) { + if (!found[i]) { + catalog[0].average[Nave].R = stars[N1[i]].R; + catalog[0].average[Nave].D = stars[N1[i]].D; + catalog[0].average[Nave].M = 1000.0*stars[N1[i]].M; + catalog[0].average[Nave].Nm = 1; + catalog[0].average[Nave].Xp = catalog[0].average[Nave].Xm = 0.0; + catalog[0].average[Nave].offset = Nmeas; + catalog[0].measure[Nmeas].dR = 0.0; + catalog[0].measure[Nmeas].dD = 0.0; + catalog[0].measure[Nmeas].M = 1000.0*stars[N1[i]].M; + catalog[0].measure[Nmeas].dM = stars[N1[i]].dM; + catalog[0].measure[Nmeas].t = 3600.0 + stars[N1[i]].Y*0.1; + catalog[0].measure[Nmeas].average = (0x00ffffff & Nave); + /* time of star = time of image + offset + Y*rate */ + Nave ++; + if (Nave == 0x1000000) { + fprintf (stderr, "too many stars in catalog\n"); + clear_lockfile (); + exit (0); + } + if (Nave == NAVE) { + NAVE = Nave + 1000; + REALLOCATE (next, int, NAVE); + REALLOCATE (catalog[0].average, Average, NAVE); + } + Nmeas ++; + if (Nmeas == NMEAS) { + NMEAS = Nmeas + 1000; + REALLOCATE (next, int, NMEAS); + REALLOCATE (catalog[0].measure, Measure, NMEAS); + } + } + } Index: /tags/getstar-1-0/Ohana/src/getstar/src/old/check_lockfile.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/old/check_lockfile.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/old/check_lockfile.c (revision 2513) @@ -0,0 +1,46 @@ +# include "addstar.h" + +check_lockfile () +{ + + FILE *f; + char filename[128]; + struct stat filestat; + + sprintf (filename, "%s/lock\0", CATDIR); + if (stat (filename, &filestat) != -1) { + fprintf (stderr, "ERROR: catalog %s is locked, try again later\n", CATDIR); + sprintf (filename, "%s/kill\0", CATDIR); + f = fopen (filename, "w"); + if (f == (FILE *) NULL) { + fprintf (stderr, "ERROR: can't set kill file %s\n", filename); + exit (0); + } + fclose (f); + exit (0); + } + + f = fopen (filename, "w"); + if (f == (FILE *) NULL) { + fprintf (stderr, "ERROR: can't set lock file %s\n", filename); + exit (0); + } + fclose (f); + +} + +clear_lockfile () +{ + + char filename[128], line[256]; + struct stat filestat; + + sprintf (filename, "%s/lock\0", CATDIR); + if (stat (filename, &filestat) != -1) { + sprintf (line, "rm %s\0", filename); + system (line); + } else { + fprintf (stderr, "can't remove lockfile, why not?\n"); + } + +} Index: /tags/getstar-1-0/Ohana/src/getstar/src/old/config.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/old/config.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/old/config.c (revision 2513) @@ -0,0 +1,110 @@ +# include +# define D_NBYTES 4096 + +char *LoadConfigFile (filename) +char *filename; +{ + + FILE *f; + int i, done, Nbytes, NBYTES, size; + char *config; + + f = fopen (filename, "r"); + if (f == NULL) { + fprintf (stderr, "couldn't find %s\n", filename); + return ((char *) NULL); + } + + NBYTES = D_NBYTES; + ALLOCATE (config, char, NBYTES); + + size = 0; + done = FALSE; + for (i = 0; !done; i++) { + Nbytes = Fread (&config[i*D_NBYTES], sizeof(char), D_NBYTES, f, "char"); + size += Nbytes; + if (Nbytes < D_NBYTES) + done = TRUE; + else { + NBYTES += D_NBYTES; + REALLOCATE (config, char, NBYTES); + } + } + + config[size] = '\n'; + config[size+1] = 0; + REALLOCATE (config, char, size + 2); + + fclose (f); + + return (config); +} + +int ScanConfig /* we expect one more field: the pointer to the value requested */ +# ifndef ANSI +(config, field, mode, va_alist) + char *config; char *field, *mode; va_dcl +# else +(char config[], + char field[], + char mode[],...) +# endif +{ + + int i, j; + char *p, *p2, tmp[256]; + va_list argp; + double value; + +# ifndef ANSI + va_start (argp); +# else + va_start (argp, N); +# endif + + /* find the correct line with field */ + p2 = config; + for (i = 0; ; i++) { + if (!strncmp (field, p2, strlen(field))) { + p = p2 + strlen (field); + break; + } + else { + p2 = strchr (p2, '\n'); + if (p2 == (char *) NULL) { + fprintf (stderr, "entry %s not found in config file\n", field); + return (FALSE); + } + else p2++; + } + } + if (!strcmp (mode, "%s")) { + p2 = strchr (p, '\n'); + if (p2 == (char *) NULL) + p2 = config + strlen(config); + bcopy (p, tmp, (p2-p)); + tmp[(p2-p)] = 0; + stripwhite (tmp); + p2 = va_arg (argp, char *); + strcpy (p2, tmp); + } + else { + + /* try to get a numerical value from the field */ + value = strtod (p, &p2); + if ((*p2 == 'd') || (*p2 == 'D')) + value *= pow (10.0, atof (p2 + 1)); + + if (!strcmp (mode, "%d")) *va_arg (argp, int *) = value; + if (!strcmp (mode, "%u")) *va_arg (argp, unsigned *) = value; + if (!strcmp (mode, "%ld")) *va_arg (argp, long *) = value; + if (!strcmp (mode, "%hd")) *va_arg (argp, short *) = value; + if (!strcmp (mode, "%f")) *va_arg (argp, float *) = value; + if (!strcmp (mode, "%lf")) *va_arg (argp, double *) = value; + + } + + va_end (argp); + return (TRUE); + +} Index: /tags/getstar-1-0/Ohana/src/getstar/src/old/dumpcat.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/old/dumpcat.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/old/dumpcat.c (revision 2513) @@ -0,0 +1,61 @@ +# include "addstar.h" + +main (argc, argv) +int argc; +char **argv; +{ + + int i, j, Nstars, Nimage, Nregions; + Average *average; + Measure *measure; + Missing *missing; + Catalog catalog; + GSCRegion region; + FILE *f; + + if (argc < 4) { + fprintf (stderr, "USAGE: dumpcat catalog output mode(0,1,2,3)\n"); + clear_lockfile (); + exit (0); + } + + strcpy (region.filename, argv[1]); + + gcatalog (®ion, &catalog); + + f = fopen (argv[2], "w"); + if (f == (FILE *) NULL) { + fprintf (stderr, "failed to open file %s for write\n", argv[2]); + clear_lockfile (); + exit (0); + } + + average = catalog.average; + for (i = 0; i < catalog.Naverage; i++) { + fprintf (f, "%10.6f %10.6f %7.3f %3d %3d %8d %d\n", average[i].R, average[i].D, + 0.001*average[i].M, average[i].Nm, average[i].Nn, average[i].offset, catalog.measure[average[i].offset].t); + if ((atof(argv[3]) == 1) || (atof(argv[3]) == 3)) { + measure = &catalog.measure[average[i].offset]; + for (j = 0; j < average[i].Nm; j++) { + fprintf (f, " %d %d %f %f %d\n", measure[j].dR, measure[j].dD, 0.001*measure[j].M, + measure[j].t, measure[j].average); + } + } + if ((atof(argv[3]) == 2) || (atof(argv[3]) == 3)) { + if (average[i].Nn > 0) { + missing = &catalog.missing[average[i].missing]; + for (j = 0; j < average[i].Nn; j++) { + fprintf (f, " %f\n", missing[j].t); + } + } else { + fprintf (f, "no missing obs\n"); + } + } + } + + + + fclose (f); + + +} Index: /tags/getstar-1-0/Ohana/src/getstar/src/old/gstars1.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/old/gstars1.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/old/gstars1.c (revision 2513) @@ -0,0 +1,273 @@ +# include "addstar.h" +# define D_NSTARS 1000 +# define BYTES_STAR 31 +# define BLOCK 1000 +#include +#include + +Stars *gstars (file, NSTARS, image) +char file[]; +int *NSTARS; +Image *image; +{ + + FILE *f; + Header header; + int j, N, Ninstar; + int nbytes, Nbytes; + Stars *stars; + char *buffer; + double tmp; + int done, doneread, Nskip, Nextra, itmp; + char *c, *c2; + unsigned short int Nc; + + if (!fits_read_header (file, &header)) { + fprintf (stderr, "ERROR: can't read header for %s\n", file); + clearlockfile (ImageCat, -1); + exit(0); + } + + /* open file */ + f = fopen (file, "r"); + if (f == NULL) { + fprintf (stderr, "ERROR: can't read data from %s\n", file); + clearlockfile (ImageCat, -1); + exit(0); + } + fseek (f, header.size, SEEK_SET); + + /* find image rootname */ + c = strrchr (file, 0x2f); + if (c == (char *) NULL) { + strcpy (image[0].name, file); + } else { + strcpy (image[0].name, (c+1)); + } + + /* get astrometry information */ + if (!GetCoords (&image[0].coords, &header)) { + fprintf (stderr, "ERROR: no astrometric solution in header\n"); + clearlockfile (ImageCat, -1); + exit (0); + } + while (image[0].coords.crval1 < 0) image[0].coords.crval1 += 360.0; + while (image[0].coords.crval1 > 360.0) image[0].coords.crval1 -= 360.0; + itmp = 0; + fits_scan (&header, "NASTRO", "%d", 1, &itmp); + if (itmp == 0) { + fprintf (stderr, "ERROR: bad astrometric solution in header\n"); + clearlockfile (ImageCat, -1); + exit (0); + } + + /* CERROR in data file is in arcsec */ + fits_scan (&header, "CERROR", "%lf", 1, &tmp); + image[0].cerror = tmp * 50.0; + fits_scan (&header, "NAXIS1", "%hd", 1, &image[0].NX); + fits_scan (&header, "NAXIS2", "%hd", 1, &image[0].NY); + fits_scan (&header, "PHOTCODE", "%hd", 1, &image[0].source); + if (NEWPHOTCODE) { + image[0].source = PHOTCODE; + } + if ((image[0].source < 0) || (image[0].source > 0xffff)) { + fprintf (stderr, "error: invalid photcode\n"); + exit (0); + } + Nc = photcodes.hashcode[image[0].source]; + if (Nc < 0) { + fprintf (stderr, "ERROR: image has invalid photcode value\n"); + exit (0); + } + thiscode = &photcodes.code[Nc]; + + image[0].NX -= XOVERSCAN; + image[0].NY -= YOVERSCAN; + fits_scan (&header, "EXPTIME", "%lf", 1, &tmp); + image[0].exptime = tmp; + + tmp = 0; + fits_scan (&header, "APMIFIT", "%lf", 1, &tmp); + image[0].apmifit = tmp * 1000.0; + + tmp = 0; + fits_scan (&header, "dAPMIFIT", "%lf", 1, &tmp); + image[0].dapmifit = tmp * 1000.0; + + tmp = 0; + fits_scan (&header, "FLIMIT", "%lf", 1, &tmp); + image[0].detection_limit = tmp * 10.0; + + tmp = 0; + fits_scan (&header, "FSATUR", "%lf", 1, &tmp); + image[0].saturation_limit = tmp * 10.0; + + tmp = 0; + fits_scan (&header, "FWHM_X", "%lf", 1, &tmp); + image[0].fwhm_x = tmp * 25.0 * image[0].coords.cdelt1 * 3600.0; + + tmp = 0; + fits_scan (&header, "FWHM_Y", "%lf", 1, &tmp); + image[0].fwhm_y = tmp * 25.0 * image[0].coords.cdelt1 * 3600.0; + + if (!fits_scan (&header, "TZERO", "%d", 1, &image[0].tzero)) { + image[0].tzero = parse_time (&header); + } + + tmp = 0; + fits_scan (&header, "TRATE", "%lf", 1, &tmp); + image[0].trate = 10000 * tmp; + + tmp = 0; + fits_scan (&header, "AIRMASS", "%lf", 1, &tmp); + image[0].secz = 1000*tmp; + + if (!fits_scan (&header, "IMAGEID", "%d", 1, &itmp)) { + image[0].ccdnum = 0xff; + } else { + image[0].ccdnum = itmp; + } + + fits_scan (&header, "ZERO_PT", "%lf", 1, &ZeroPt); + + /* secz is in units milli-airmass */ + image[0].Mcal = ALPHA*(image[0].secz - 1000); + image[0].Xm = 30.0; + image[0].code = 0; + bzero (image[0].dummy, sizeof(image[0].dummy)); + + /* find expected number of stars */ + fits_scan (&header, "NSTARS", "%d", 1, &image[0].nstar); + if (image[0].nstar == 0) { + fprintf (stderr, "ERROR: can't get NSTARS from header\n"); + clearlockfile (ImageCat, -1); + exit (0); + } + ALLOCATE (stars, Stars, image[0].nstar); + + /* load in stars by blocks of 1000 */ + N = 0; + ALLOCATE (buffer, char, (BLOCK*BYTES_STAR) + 1); + buffer[BLOCK*BYTES_STAR] = 0; + Nextra = 0; + doneread = FALSE; + while (!doneread) { + Nbytes = BYTES_STAR * BLOCK - Nextra; + nbytes = Fread (&buffer[Nextra], 1, Nbytes, f, "char"); + if (nbytes == 0) { + doneread = TRUE; + continue; + } + nbytes += Nextra; + /* check line-by-line integrity */ + c = buffer; + done = FALSE; + while ((c < buffer + nbytes) && (!done)) { + for (c2 = c; *c2 == '\n'; c2++); + if (c2 > c) { /* extra return chars */ + memmove (c, c2, (int)(buffer + nbytes - c2)); + Nskip = c2 - c; + nbytes -= Nskip; + bzero (buffer + nbytes, Nskip); + if (VERBOSE) fprintf (stderr, "deleted %d extra return chars\n", Nskip); + } + c2 = strchr (c, '\n'); + if (c2 == (char *) NULL) { + done = TRUE; + continue; + } + c2++; + if ((c2 - c) != BYTES_STAR) { /* bad line, delete it */ + memmove (c, c2, (int)(buffer + nbytes - c2)); + Nskip = c2 - c; + nbytes -= Nskip; + bzero (buffer + nbytes, Nskip); + if (VERBOSE) fprintf (stderr, "deleted line, %d extra chars\n", Nskip); + } else { + c = c2; + } + } + Ninstar = nbytes / BYTES_STAR; + Nextra = nbytes % BYTES_STAR; + for (j = 0; j < Ninstar; j++, N++) { + dparse (&stars[N].X, 1, &buffer[j*BYTES_STAR]); + dparse (&stars[N].Y, 2, &buffer[j*BYTES_STAR]); + dparse (&stars[N].M, 3, &buffer[j*BYTES_STAR]); + dparse (&stars[N].dM, 4, &buffer[j*BYTES_STAR]); + XY_to_RD (&stars[N].R, &stars[N].D, stars[N].X, stars[N].Y, &image[0].coords); + while (stars[N].R < 0.0) stars[N].R += 360.0; + while (stars[N].R >= 360.0) stars[N].R -= 360.0; + dparse (&tmp, 5, &buffer[j*BYTES_STAR]); + stars[N].dophot = tmp; + stars[N].found = -1; + } + } + + image[0].nstar = N; + REALLOCATE (stars, Stars, image[0].nstar); + if (VERBOSE) fprintf (stderr, "read %d stars from target file\n", image[0].nstar); + *NSTARS = image[0].nstar; + + return (stars); +} + + + + +# if (0) + /* left over fraction of a block */ + nbytes = Fread (buffer, 1, (Nbytes % (BLOCK*BYTES_STAR)), f, "char"); + if (nbytes != (Nbytes % (BLOCK*BYTES_STAR))) { + fprintf (stderr, "ERROR: failed to read in stars (2)\n"); + clearlockfile (ImageCat, -1); + exit (0); + } + /* check line-by-line integrity */ + Nnew = 0; + c = buffer; + done = FALSE; + while ((c < buffer + nbytes) && (!done)) { + for (c2 = c; *c2 == '\n'; c2++); + if (c2 > c) { /* extra return chars */ + memmove (c, c2, (int)(buffer + nbytes - c2)); + Nnew += c2 - c; + fprintf (stderr, "deleting %d extra return chars\n", (int)(c2-c)); + } + c2 = strchr (c, '\n'); + if (c2 == (char *) NULL) { + if (Nnew > 0) { + nnew = Fread (&buffer[nbytes-Nnew], 1, Nnew, f, "char"); + if (nnew != Nnew) { + fprintf (stderr, "ERROR: failed to read in stars (1)\n"); + exit (0); + } + } else { + done = TRUE; + } + continue; + } + c2++; + if ((c2 - c) != BYTES_STAR) { + /* this is a bad line, delete it, adjust data in buffer, + and be ready to read the rest of the last line */ + memmove (c, c2, (int)(buffer + nbytes - c2)); + Nnew += c2 - c; + fprintf (stderr, "deleting bad line with %d chars\n", (int)(c2-c)); + } else { + c = c2; + } + } + for (j = 0; j < nbytes / BYTES_STAR; j++, nstar++, N++) { + dparse (&stars[N].X, 1, &buffer[j*BYTES_STAR]); + dparse (&stars[N].Y, 2, &buffer[j*BYTES_STAR]); + dparse (&stars[N].M, 3, &buffer[j*BYTES_STAR]); + dparse (&stars[N].dM, 4, &buffer[j*BYTES_STAR]); + XY_to_RD (&stars[N].R, &stars[N].D, stars[N].X, stars[N].Y, &image[0].coords); + while (stars[N].R < 0.0) stars[N].R += 360.0; + while (stars[N].R >= 360.0) stars[N].R -= 360.0; + dparse (&tmp, 5, &buffer[j*BYTES_STAR]); + stars[N].dophot = tmp; + stars[N].found = -1; + } + +# endif Index: /tags/getstar-1-0/Ohana/src/getstar/src/old/sort_stars.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/old/sort_stars.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/old/sort_stars.c (revision 2513) @@ -0,0 +1,61 @@ +# include "relphot.h" + +void sort_stars (radec, stars, Nstars) +int **radec; +Star *stars; +int Nstars; +{ + + int i; + double *RAs; + + ALLOCATE (radec[0], int, Nstars); + ALLOCATE (RAs, double, Nstars); + for (i = 0; i < Nstars; i++) { + radec[0][i] = i; + RAs[i] = stars[i].RA; + } + + sort_seq (radec[0], RAs, Nstars); + free (RAs); + +} + + +void sort_seq (seq, value, N) +int *seq; +double *value; +int N; +{ + int l,j,ir,i; + int temp; + + l = N >> 1; + ir = N - 1; + for (;;) { + if (l > 0) { + temp = seq[--l]; + } + else { + temp = seq[ir]; + seq[ir] = seq[0]; + if (--ir == 0) { + seq[0] = temp; + return; + } + } + i = l; + j = (l << 1) + 1; + while (j <= ir) { + if (j < ir && value[seq[j]] < value[seq[j+1]]) ++j; + if (value[temp] < value[seq[j]]) { + seq[i]=seq[j]; + j += (i=j) + 1; + } + else j = ir + 1; + } + seq[i] = temp; + } +} + + Index: /tags/getstar-1-0/Ohana/src/getstar/src/old/string.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/old/string.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/old/string.c (revision 2513) @@ -0,0 +1,64 @@ +# include +# include +# define TRUE 1 +# define FALSE 0 + +int scan_line (f, line) +FILE *f; +char line[]; +{ + + int i, status; + char c; + + status = EOF + 1; + + for (i = 0, c = 0; (c != '\n') && (status != EOF); i++) { + status = fscanf (f, "%c", &c); + line[i] = c; + } + line[i - 1] = 0; /* this could make things crash! */ + + if (i > 1) { + status = EOF + 1; + } + + return (status); + +} + +char *_parse_nextword(string) +char *string; +{ + if (string == (char *) NULL) return ((char *) NULL); + + for (; isspace (*string); string++); + for (; (*string != 0) && !isspace (*string); string++); + for (; isspace (*string); string++); + return (string); +} + +int dparse (X, NX, line) +double *X; +int NX; +char *line; +{ + + int i; + char *word; + char *ptr; + + word = line; + for (i = 0; i < NX - 1; i++) + word = _parse_nextword (word); + + *X = strtod (word, &ptr); + if (ptr == word) + return (FALSE); + else { + if (word[0] == '-') + return (-1); + else + return (1); + } +} Index: /tags/getstar-1-0/Ohana/src/getstar/src/parse_time.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/parse_time.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/parse_time.c (revision 2513) @@ -0,0 +1,126 @@ +# include "addstar.h" + +parse_time (Header *header) { + + double jd; + int Ny, Nf, mode; + int Nsec, hour, min, sec, year, month, day; + char *py, *pm, *pd, *c; + char line[256]; + + /* we want to find JD or MJD to get Nsec (seconds since 01/01/1970) */ + + /* try JD first */ + if (strcasecmp (JDKeyword, "NONE")) { + uppercase (JDKeyword); + fits_scan (header, JDKeyword, "%lf", 1, &jd); + Nsec = (jd - 2440587.5)*86400; + return (Nsec); + } + + /* try MJD next */ + if (strcasecmp (MJDKeyword, "NONE")) { + uppercase (MJDKeyword); + fits_scan (header, MJDKeyword, "%lf", 1, &jd); + Nsec = (jd - 40587.0)*86400; + return (Nsec); + } + + /* get UT and DATE */ + uppercase (UTKeyword); + fits_scan (header, UTKeyword, "%s", 1, line); + /* remove ':' characters */ + for (c = strchr (line, 0x3a); c != (char *) NULL; c = strchr (line, 0x3a)) { *c = ' '; } + sscanf (line, "%d %d %d", &hour, &min, &sec); + + /* parse mode line */ + uppercase (DateMode); + for (Ny = 0, c = strchr (DateMode, 'Y'); c != (char ) NULL; c = strchr (c + 1, 'Y'), Ny++); + if ((Ny != 2) && (Ny != 4)) { + fprintf (stderr, "error in DATE-MODE format: %s\n", DateMode); + exit (1); + } + py = strchr (DateMode, 'Y'); + pm = strchr (DateMode, 'M'); + pd = strchr (DateMode, 'D'); + if ((py == (char *) NULL) || (pm == (char *) NULL) || (pd == (char *) NULL)) { + fprintf (stderr, "error in DATE-MODE format: %s\n", DateMode); + exit (1); + } + if ((py > pm) && (py < pd)) { + fprintf (stderr, "error in DATE-MODE format: %s\n", DateMode); + exit (1); + } + if ((py > pd) && (py < pm)) { + fprintf (stderr, "error in DATE-MODE format: %s\n", DateMode); + exit (1); + } + mode = 0; + if ((py < pm) && (pm < pd)) { mode = 1; } /* yyyy-mm-dd */ + if ((py < pm) && (pm > pd)) { mode = 2; } /* yyyy-dd-mm */ + if ((py > pm) && (pm < pd)) { mode = 3; } /* mm-dd-yyyy */ + if ((py > pm) && (pm > pd)) { mode = 4; } /* dd-mm-yyyy */ + if (!mode) { + fprintf (stderr, "error in DATE-MODE format: %s\n", DateMode); + exit (1); + } + + /* parse date entry */ + uppercase (DateKeyword); + fits_scan (header, DateKeyword, "%s", 1, line); + /* remove possible separators: ':', '/' '.', '-' */ + for (c = strchr (line, 0x3a); c != (char *) NULL; c = strchr (line, 0x3a)) { *c = ' '; } + for (c = strchr (line, 0x2f); c != (char *) NULL; c = strchr (line, 0x2f)) { *c = ' '; } + for (c = strchr (line, 0x2e); c != (char *) NULL; c = strchr (line, 0x2e)) { *c = ' '; } + for (c = strchr (line, 0x2d); c != (char *) NULL; c = strchr (line, 0x2d)) { *c = ' '; } + + switch (mode) { + case 1: + Nf = sscanf (line, "%d %d %d", &year, &month, &day); + break; + case 2: + Nf = sscanf (line, "%d %d %d", &year, &day, &month); + break; + case 3: + Nf = sscanf (line, "%d %d %d", &month, &day, &year); + break; + case 4: + Nf = sscanf (line, "%d %d %d", &day, &month, &year); + break; + } + if (Nf != 3) { + fprintf (stderr, "error in date entry (%s) or DATE-MODE format (%s)\n", line, DateMode); + exit (1); + } + + if (year > 1000) { + if (Ny == 2) { + fprintf (stderr, "warning: mode line claims 2 digit year, but 4 digit year found\n"); + } + } else { + if (Ny == 4) { + fprintf (stderr, "warning: mode line claims 4 digit year, but 2 digit year found\n"); + } + if (year < 50) year += 100; + year += 1900; + } + + /* convert yy.mm.dd hh.mm.ss to Nsec since 1970 (jd = 2440587.5) */ + /* note that in this section, tm_mon has range 1-12, unlike for gmtime () */ + jd = day - 32075 + (int)(1461*(year + 4800 + (int)(((month)-14)/12))/4) + + (int)(367*((month) - 2 - (int)(((month) - 14)/12)*12)/12) + - (int)(3*(int)((year + 4900 + (int)(((month) - 14)/12))/100)/4) - 0.5; + /* jd is the julian day of the whole day only not the time */ + Nsec = (jd - 2440587.5)*86400 + 3600.0*hour + min*60.0 + sec; + + return (Nsec); + +} + +uppercase (char *string) { + + int i; + + for (i = 0; i < strlen (string); i++) string[i] = toupper (string[i]); + +} Index: /tags/getstar-1-0/Ohana/src/getstar/src/sort_lists.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/sort_lists.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/sort_lists.c (revision 2513) @@ -0,0 +1,82 @@ + +sort_lists (X, Y, S, N) +float *X, *Y; +int *S, N; +{ + int l,j,ir,i; + double tX, tY, tS; + + l = N >> 1; + ir = N - 1; + for (;;) { + if (l > 0) { + l--; + tX = X[l]; + tY = Y[l]; + tS = S[l]; + } + else { + tX = X[ir]; + X[ir] = X[0]; + tY = Y[ir]; + Y[ir] = Y[0]; + tS = S[ir]; + S[ir] = S[0]; + if (--ir == 0) { + X[0] = tX; + Y[0] = tY; + S[0] = tS; + return; + } + } + i = l; + j = (l << 1) + 1; + while (j <= ir) { + if (j < ir && X[j] < X[j+1]) j++; + if (tX < X[j]) { + X[i] = X[j]; + Y[i] = Y[j]; + S[i] = S[j]; + j += (i=j) + 1; + } + else j = ir + 1; + } + X[i] = tX; + Y[i] = tY; + S[i] = tS; + } +} + +fsort (float *X, int N) { + + int l,j,ir,i; + float tX; + + l = N >> 1; + ir = N - 1; + for (;;) { + if (l > 0) { + l--; + tX = X[l]; + } + else { + tX = X[ir]; + X[ir] = X[0]; + if (--ir == 0) { + X[0] = tX; + return; + } + } + i = l; + j = (l << 1) + 1; + while (j <= ir) { + if (j < ir && X[j] < X[j+1]) j++; + if (tX < X[j]) { + X[i] = X[j]; + j += (i=j) + 1; + } + else j = ir + 1; + } + X[i] = tX; + } +} Index: /tags/getstar-1-0/Ohana/src/getstar/src/wcatalog.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/wcatalog.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/wcatalog.c (revision 2513) @@ -0,0 +1,37 @@ +# include "addstar.h" + +wcatalog (Catalog *catalog) { + + int status; + + /* we'll leave these for now, but they are LONEOS specific */ + fits_modify (&catalog[0].header, "MARKSTAR", "%t", 1, FALSE); + fits_modify (&catalog[0].header, "ADDUSNO", "%t", 1, FALSE); + fits_modify (&catalog[0].header, "MARKROCK", "%t", 1, FALSE); + + if (!save_catalog (catalog, VERBOSE)) { + fprintf (stderr, "ERROR: failure saving catalog\n"); + exit (1); + } + + /* free, initialize data structures */ + + if (catalog[0].Naverage) { + free (catalog[0].average); + catalog[0].Naverage = 0; + } + if (catalog[0].Nmeasure) { + free (catalog[0].measure); + catalog[0].Nmeasure = 0; + } + if (catalog[0].Nmissing) { + free (catalog[0].missing); + catalog[0].Nmissing = 0; + } + if (catalog[0].Nsecfilt) { + free (catalog[0].secfilt); + catalog[0].Nsecfilt = 0; + } + fits_free_header (&catalog[0].header); +} + Index: /tags/getstar-1-0/Ohana/src/getstar/src/wimage.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/wimage.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/wimage.c (revision 2513) @@ -0,0 +1,52 @@ +# include "getstar.h" + +wimage (FILE *f, int dbstate, Image *image, int Nstars) { + + int Nimages, status, mode; + Header header; + + /* place file pointer at beginning of file */ + fseek (f, 0, SEEK_SET); + + if (dbstate == LCK_EMPTY) { + if (VERBOSE) fprintf (stderr, "can't find %s, creating a new one\n", ImageCat); + if (!fits_read_header (ImageTemplate, &header)) { + fprintf (stderr, "ERROR: can't find template header %s\n", ImageTemplate); + exit (1); + } + /* assign Zero Point provided by first image in dB */ + fits_modify (&header, "ZERO_PT", "%lf", 1, ZeroPt); + } else { + if (!fits_load_header (f, &header)) { + fprintf (stderr, "ERROR: can't read image header %s\n", ImageCat); + exit (1); + } + } + + Nimages = 0; + fits_scan (&header, "NIMAGES", "%d", 1, &Nimages); + Nimages ++; + fits_modify (&header, "NIMAGES", "%d", 1, Nimages); + + /* position to begining of file to write header */ + fseek (f, 0, SEEK_SET); + status = Fwrite (header.buffer, 1, header.size, f, "char"); + if (status != header.size) { + fprintf (stderr, "ERROR: failed writing data to image header\n"); + exit (1); + } + + /* position to end of file for new image data */ + fseek (f, 0, SEEK_END); + status = Fwrite (image, sizeof(Image), 1, f, "image"); + if (status != 1) { + fprintf (stderr, "ERROR: failed writing data to image catalog\n"); + exit (1); + } +} + +/* the image we add in this routine is always a new image. + We only need to do two things: + 1) append the data for the image to the end of the file + 2) update the NIMAGES field in the header (which means, read in header, re-write) + */ Index: /tags/getstar-1-0/Ohana/src/getstar/src/wstars.c =================================================================== --- /tags/getstar-1-0/Ohana/src/getstar/src/wstars.c (revision 2513) +++ /tags/getstar-1-0/Ohana/src/getstar/src/wstars.c (revision 2513) @@ -0,0 +1,146 @@ +# include "getstar.h" +# define NCHAR 66 /* 65 char EXCLUDING return */ + +int wstars (char *filename, Stars *stars, int Nstars, Image *image) { + + /* construct a header from the image structure */ + /* write out header */ + /* write out data lines */ + + int i, Nchar, Ny, mode; + double scale; + char *photcode, *c, *py, *pm, *pd, datestr[64], timestr[64]; + struct tm *gmt; + Header header; + FILE *f; + char line[NCHAR]; + + fits_init_header (&header); + header.Naxis[0] = image[0].NX + XOVERSCAN; + header.Naxis[1] = image[0].NY + YOVERSCAN; + header.bitpix = 16; + header.Naxes = 2; + fits_create_header (&header); + + /* astrometric data */ + fits_print (&header, "CTYPE1", "%s", 1, "RA---SIN"); + fits_print (&header, "CTYPE2", "%s", 1, "DEC--SIN"); + + fits_print (&header, "CRVAL1", "%f", 1, image[0].coords.crval1); + fits_print (&header, "CRVAL2", "%f", 1, image[0].coords.crval2); + + fits_print (&header, "CRPIX1", "%f", 1, image[0].coords.crpix1); + fits_print (&header, "CRPIX2", "%f", 1, image[0].coords.crpix2); + + fits_print (&header, "PC001001", "%f", 1, image[0].coords.pc1_1); + fits_print (&header, "PC001002", "%f", 1, image[0].coords.pc1_2); + fits_print (&header, "PC002001", "%f", 1, image[0].coords.pc2_1); + fits_print (&header, "PC002002", "%f", 1, image[0].coords.pc2_2); + + fits_print (&header, "CDELT1", "%f", 1, image[0].coords.cdelt1); + fits_print (&header, "CDELT2", "%f", 1, image[0].coords.cdelt2); + + fits_print (&header, "NASTRO", "%d", 1, 1); /* TBD */ + fits_print (&header, "EQUINOX", "%f", 1, 2000.0); /* TBD */ + + fits_print (&header, "CERROR", "%f", 1, 0.02*image[0].cerror); + + photcode = GetPhotcodeNamebyCode (image[0].source); + fits_print (&header, "PHOTCODE", "%s", 1, photcode); + + fits_print (&header, ExptimeKeyword, "%f", 1, image[0].exptime); + + fits_print (&header, "FLIMIT", "%lf", 1, 0.1*image[0].detection_limit); + fits_print (&header, "FSATUR", "%lf", 1, 0.1*image[0].saturation_limit); + + scale = image[0].coords.cdelt1*25.0*3600.0; + fits_print (&header, "FWHM_X", "%lf", 1, image[0].fwhm_x / scale); + fits_print (&header, "FWHM_Y", "%lf", 1, image[0].fwhm_y / scale); + + fits_print (&header, "TRATE", "%lf", 1, image[0].trate/10000.0); + fits_print (&header, AirmassKeyword, "%lf", 1, 0.001*image[0].secz); + + if (image[0].ccdnum != 0xff) { + fits_print (&header, CCDNumKeyword, "%d", 1, image[0].ccdnum); + } + + /* parse date-mode line */ + uppercase (DateMode); + for (Ny = 0, c = strchr (DateMode, 'Y'); c != (char ) NULL; c = strchr (c + 1, 'Y'), Ny++); + if ((Ny != 2) && (Ny != 4)) { + fprintf (stderr, "error in DATE-MODE format: %s\n", DateMode); + exit (1); + } + py = strchr (DateMode, 'Y'); + pm = strchr (DateMode, 'M'); + pd = strchr (DateMode, 'D'); + if ((py == (char *) NULL) || (pm == (char *) NULL) || (pd == (char *) NULL)) { + fprintf (stderr, "error in DATE-MODE format: %s\n", DateMode); + exit (1); + } + if ((py > pm) && (py < pd)) { + fprintf (stderr, "error in DATE-MODE format: %s\n", DateMode); + exit (1); + } + if ((py > pd) && (py < pm)) { + fprintf (stderr, "error in DATE-MODE format: %s\n", DateMode); + exit (1); + } + mode = 0; + if ((py < pm) && (pm < pd)) { mode = 1; } /* yyyy-mm-dd */ + if ((py < pm) && (pm > pd)) { mode = 2; } /* yyyy-dd-mm */ + if ((py > pm) && (pm < pd)) { mode = 3; } /* mm-dd-yyyy */ + if ((py > pm) && (pm > pd)) { mode = 4; } /* dd-mm-yyyy */ + if (!mode) { + fprintf (stderr, "error in DATE-MODE format: %s\n", DateMode); + exit (1); + } + + gmt = gmtime ((unsigned long *)&image[0].tzero); + + switch (mode) { + case 1: + sprintf (datestr, "%04d/%02d/%02d", 1900 + gmt[0].tm_year, gmt[0].tm_mon+1, gmt[0].tm_mday); + break; + case 2: + sprintf (datestr, "%04d/%02d/%02d", 1900 + gmt[0].tm_year, gmt[0].tm_mday, gmt[0].tm_mon+1); + break; + case 3: + sprintf (datestr, "%02d/%02d/%04d", gmt[0].tm_mon+1, gmt[0].tm_mday, 1900 + gmt[0].tm_year); + break; + case 4: + sprintf (datestr, "%02d/%02d/%04d", gmt[0].tm_mday, gmt[0].tm_mon+1, 1900 + gmt[0].tm_year); + break; + } + sprintf (timestr, "%02d:%02d:%02d", gmt[0].tm_hour, gmt[0].tm_min, gmt[0].tm_sec); + fits_print (&header, UTKeyword, "%s", 1, timestr); + fits_print (&header, DateKeyword, "%s", 1, datestr); + + fits_print (&header, "ZERO_PT", "%lf", 1, ZeroPt); + fits_print (&header, "NSTARS", "%d", 1, Nstars); + + f = fopen (filename, "w"); + if (f == (FILE *) NULL) { + fprintf (stderr, "ERROR: can't create output file %s\n", filename); + exit (1); + } + + fwrite (header.buffer, 1, header.size, f); + + for (i = 0; i < Nstars; i++) { + Nchar = snprintf (line, NCHAR, "%6.1f %6.1f %6.3f %03d %2d %3.1f %6.3f %6.3f %6.2f %6.2f %5.1f", + stars[i].X, stars[i].Y, stars[i].M, + (int)(stars[i].dM), stars[i].dophot, stars[i].sky, + stars[i].Mgal, stars[i].Map, stars[i].fx, stars[i].fy, stars[i].df); + fprintf (f, "%s\n", line); + } + fclose (f); +} + +uppercase (char *string) { + + int i; + + for (i = 0; i < strlen (string); i++) string[i] = toupper (string[i]); + +}