/**
* Function: free_full_spectr
* The function frees the memory allocated in a full
* spectrum structure.
*
* Parameters:
* @param SPC - the full spectrum structure
*
* Returns:
* @return -
*/
void
free_full_spectr(full_spectr *SPC)
{
// free the three spectra in the
// full spectrum structure
free_spectrum(SPC->obj_spec);
free_spectrum(SPC->fgr_spec);
free_spectrum(SPC->bck_spec);
// free the full spectrum
free(SPC);
// set the structure to NULL
SPC = NULL;
}
int
main (int argc, char *argv[])
{
char *opt;
char grism_file[MAXCHAR];
char grism_file_path[MAXCHAR];
char aper_file[MAXCHAR];
char aper_file_path[MAXCHAR];
char obj_PET_file[MAXCHAR];
char obj_PET_file_path[MAXCHAR];
char bck_PET_file[MAXCHAR];
char bck_PET_file_path[MAXCHAR];
char conf_file[MAXCHAR];
char conf_file_path[MAXCHAR];
char SPC_file[MAXCHAR];
char SPC_file_path[MAXCHAR];
char SPC_opt_file[MAXCHAR];
char SPC_opt_file_path[MAXCHAR];
char WHT_file[MAXCHAR];
char WHT_file_path[MAXCHAR];
char label[MAXCHAR];
int i, index, dobck = 0, noflux = 1;
object **oblist;
FITScards *cards;
ap_pixel *obj_PET = NULL, *bck_PET = NULL;
observation *obs;
//tracestruct *trace;
aperture_conf *conf;
spectrum *obj_spec = NULL, *bck_spec = NULL, *sobj_spec = NULL;
spectrum *resp;
response_function *resp_func;
calib_function *wl_calibration;
fitsfile *OPET_ptr, *BPET_ptr;
int f_status = 0;
fitsfile *SPC_ptr, *SPC_opt_ptr, *WHT_ptr;
gsl_matrix *weights;
drzstamp *modvar;
int obj_aperID, obj_beamID, objindex;
int bck_aperID, bck_beamID;
char table[MAXCHAR], table_path[MAXCHAR];
//char comment[FLEN_COMMENT];
int empty;
int drizzle;
int quant_cont=0;
int opt_weights=0;
int for_grism=0;
int smooth_conv=0;
d_point smooth_params;
double exptime;
double sky_cps;
drzstamp_dim dimension;
gsl_matrix *coverage;
if (((argc < 3))
|| (opt = get_online_option ("help", argc, argv)))
{
fprintf (stdout,
"ST-ECF European Coordinating Facility\n"
"Copyright (C) 2002 Martin Kuemmel\n"
"aXe_PET2SPC Version %s:\n"
" aXe task that produces 1-D, binned spectra using information\n"
" contained in a OPET and a BPET. A 1-D spectrum is generated\n"
" for each beam in each of both the OPET and the BPET files\n"
" The binned background spectra of each beam (order) is then\n"
" subtraced from the corresponding spectra form the OPET. Th\ne"
" background subtraction (and reading a BPET altogether can be\n"
" avoided by using the -noBPET option\n"
" An SPC file, a multi-extension FITS file containing binned\n"
" spectra is produced. Each extension (named after the beam ID,\n"
" e.g. 11B for aperture (object) 11,beam (order) B) contains the\n"
" following columns:\n"
"\n"
" LAMBDA ; the wavelength (in A)\n"
" TCOUNT ; the total number of counts (in DN)\n"
" TERROR ; the error in TERRORS (in DN)\n"
" BCOUNT ; the estimated number of counts from the\n"
" background (in DN)\n"
" BERROR ; the error in BCOUNTS (in DN)\n"
" COUNT ; the estimated number of counts from the\n"
" object (in DN)\n"
" ERROR ; the error in COUNTS (in DN)\n"
" FLUX ; the estimated flux (in erg/s/cm^2/A)\n"
" FERROR ; the error in FLUX (in erg/s/cm^s/A)\n"
" WEIGHT ; weight (in pixels)\n"
"\n"
" Input FITS mages are looked for in $AXE_IMAGE_PATH\n"
" aXe config file is looked for in $AXE_CONFIG_PATH\n"
" All outputs are writen to $AXE_OUTPUT_PATH\n"
"\n"
"Usage:\n"
" aXe_PET2SPC [g/prism image filename] [aXe config file name] [options]\n"
"\n"
"Options:\n"
" -noBPET - to disable the use of a BPET file\n"
" -noflux - to disable the flux calibration\n"
" -drz - use $AXE_DRIZZLE_PATH to locate the grism-, OAF-\n"
" - and PET-files instead of $AXE_IMAGE/OUTPUT_PATH\n"
" -in_AF=[string] - overwrite the default input Aperture File name\n"
" -OPET=[string] - overwrite the default input Object PET file name\n"
" -BPET=[string] - overwrite the default input Background PET\n"
" file name\n"
" -out_SPC=[string] - overwrite the default output SPC file name\n"
"\n"
"Example:\n"
" ./aXe_PET2SPC slim_grism.fits SLIM.conf.A.0\n"
"\n",RELEASE);
exit (1);
}
// make a general opening statement
fprintf (stdout, "aXe_PET2SPC: Starting...\n");
// get the name of the flt-file
index = 0;
strcpy (grism_file, argv[++index]);
if ((opt = get_online_option ("drz", argc, argv)))
{
build_path (AXE_DRIZZLE_PATH, grism_file, grism_file_path);
drizzle=1;
}
else
{
build_path (AXE_IMAGE_PATH, grism_file, grism_file_path);
drizzle=0;
}
// get the name of the configuration file
strcpy (conf_file, argv[++index]);
build_path (AXE_CONFIG_PATH, conf_file, conf_file_path);
// load the configuration file
conf = get_aperture_descriptor (conf_file_path);
// Determine where the various extensions are in the FITS file
get_extension_numbers(grism_file_path, conf,conf->optkey1,conf->optval1);
// Build aperture file name
replace_file_extension (grism_file, aper_file, ".fits",
".OAF", conf->science_numext);
if (drizzle)
build_path (AXE_DRIZZLE_PATH, aper_file, aper_file_path);
else
build_path (AXE_OUTPUT_PATH, aper_file, aper_file_path);
// Build object PET file name
replace_file_extension (grism_file, obj_PET_file, ".fits",
".PET.fits", conf->science_numext);
// make the total filename
if (drizzle)
build_path (AXE_DRIZZLE_PATH, obj_PET_file, obj_PET_file_path);
else
build_path (AXE_OUTPUT_PATH, obj_PET_file, obj_PET_file_path);
// Build background PET file name
replace_file_extension (grism_file, bck_PET_file, ".fits",
".BCK.PET.fits", conf->science_numext);
// make the total filename
if (drizzle)
build_path (AXE_DRIZZLE_PATH, bck_PET_file, bck_PET_file_path);
else
build_path (AXE_OUTPUT_PATH, bck_PET_file, bck_PET_file_path);
// make a non-standard AF name if necessary
if ((opt = get_online_option ("in_AF", argc, argv)))
{
strcpy(aper_file,opt);
strcpy(aper_file_path,opt);
}
// make a non-standard PET name if necessary
if ((opt = get_online_option ("OPET", argc, argv)))
{
strcpy(obj_PET_file,opt);
strcpy(obj_PET_file_path,opt);
}
// make a non-standard BPET name if necessary
if ((opt = get_online_option ("BPET", argc, argv)))
{
strcpy(bck_PET_file,opt);
strcpy(bck_PET_file_path,opt);
}
// set the flagg for no background subtraction
if ((opt = get_online_option ("noBPET",argc,argv)))
{
dobck = 0;
strcpy(bck_PET_file,"None");
strcpy(bck_PET_file_path, "None");
}
else
{
dobck = 1;
}
// set the flagg for flux
if ((opt = get_online_option ("noflux",argc,argv)))
noflux = 1;
else
noflux = 0;
// check for the weights flagg,
// set the file name if the flagg is set
if ((opt = get_online_option ("opt_weights",argc,argv)))
opt_weights = 1;
else
opt_weights = 0;
// read the trigger for smoothing the sensitivity
if ((opt = get_online_option ("smooth_conv",argc,argv)))
smooth_conv = 1;
else
smooth_conv = 0;
if ((opt = get_online_option ("out_SPC", argc, argv)))
{
strcpy (SPC_file, opt);
strcpy (SPC_file_path, opt);
if (opt_weights)
{
replace_file_extension (SPC_file, SPC_opt_file, ".fits",
"_opt.SPC.fits", -1);
replace_file_extension (SPC_file_path, SPC_opt_file_path, ".fits",
"_opt.SPC.fits", -1);
replace_file_extension (SPC_opt_file, WHT_file, ".SPC.fits",
".WHT.fits", -1);
replace_file_extension (SPC_opt_file_path, WHT_file_path, ".SPC.fits",
".WHT.fits", -1);
}
}
else
{
replace_file_extension (obj_PET_file, SPC_file, ".PET.fits",
".SPC.fits", -1);
if (drizzle)
build_path (AXE_DRIZZLE_PATH, SPC_file, SPC_file_path);
else
build_path (AXE_OUTPUT_PATH, SPC_file, SPC_file_path);
if (opt_weights)
{
replace_file_extension (obj_PET_file, SPC_opt_file, ".PET.fits",
"_opt.SPC.fits", -1);
replace_file_extension (SPC_opt_file, WHT_file, ".SPC.fits",
".WHT.fits", -1);
if (drizzle)
{
build_path (AXE_DRIZZLE_PATH, SPC_opt_file, SPC_opt_file_path);
build_path (AXE_DRIZZLE_PATH, WHT_file, WHT_file_path);
}
else
{
build_path (AXE_OUTPUT_PATH, SPC_opt_file, SPC_opt_file_path);
build_path (AXE_OUTPUT_PATH, WHT_file, WHT_file_path);
}
}
}
// check the configuration file for the smoothin keywords
if (!check_conf_for_smoothing(conf, smooth_conv))
aXe_message(aXe_M_FATAL, __FILE__, __LINE__,
"aXe_PET2SP: Either the configuration file %s does not contain\n"
"the necessary keywords for the smoothing (POBJSIZE, SMFACTOR),\n"
"or one of these keywords has an unreasonable value < 0.0!\n",
conf_file_path);
// give feedback onto the screen:
// report on input and output
// and also on specific parameter
fprintf (stdout, "aXe_PET2SPC: Input configuration file name: %s\n",
conf_file_path);
fprintf (stdout, "aXe_PET2SPC: Input Object Aperture file name: %s\n",
aper_file_path);
fprintf (stdout, "aXe_PET2SPC: Input Object PET file name: %s\n",
obj_PET_file_path);
if (dobck)
fprintf (stdout, "aXe_PET2SPC: Input Background PET file name: %s\n",
bck_PET_file_path);
fprintf (stdout, "aXe_PET2SPC: Output SPC file name: %s\n",
SPC_file_path);
if (opt_weights)
{
fprintf (stdout, "aXe_PET2SPC: Computing optimal weights.\n");
fprintf (stdout, "aXe_PET2SPC: Optimized SPC file name: %s\n",
SPC_opt_file_path);
fprintf (stdout, "aXe_PET2SPC: Output WHT file name: %s\n",
WHT_file_path);
}
if (!noflux)
{
fprintf (stdout, "aXe_PET2SPC: Performing flux calibration.\n");
if (smooth_conv)
fprintf (stdout, "aXe_PET2SPC: Using smoothed sensitivity curves.\n");
}
fprintf (stdout, "\n\n");
//
// try to get the descriptor 'exptime' from the 'sci'-extension
//
exptime = (double)get_float_from_keyword(grism_file_path, conf->science_numext, conf->exptimekey);
if (isnan(exptime))
exptime = (double)get_float_from_keyword(grism_file_path, 1, conf->exptimekey);
if (isnan(exptime))
exptime = 1.0;
//
// try to get the descriptor 'SKY_CPS' from the 'sci'-extension
//
sky_cps = (double)get_float_from_keyword(grism_file_path, conf->science_numext, "SKY_CPS");
if (isnan(sky_cps))
sky_cps = 0.0;
// Open the OPET file for reading
fits_open_file (&OPET_ptr, obj_PET_file_path, READONLY, &f_status);
if (f_status)
{
ffrprt (stderr, f_status);
aXe_message (aXe_M_FATAL, __FILE__, __LINE__,
"aXe_PET2SPC: Could not open file: %s\n",
obj_PET_file_path);
}
// check whether the contamination is quantitative
quant_cont = check_quantitative_contamination(OPET_ptr);
if (opt_weights && !quant_cont)
aXe_message (aXe_M_FATAL, __FILE__, __LINE__,
"aXe_PET2SPC: The optimal extractions needs quantitative contamination! "
" Please re-run aXe with Gauss or Fluxcube contamination!");
obs = load_dummy_observation ();
/* Loading the object list */
fprintf (stdout, "aXe_PET2SPC: Loading object aperture list...");
oblist = file_to_object_list_seq (aper_file_path, obs);
fprintf (stdout,"%d objects loaded.\n",object_list_size(oblist));
if (dobck)
{
// Open the file for reading
fits_open_file (&BPET_ptr, bck_PET_file_path, READONLY, &f_status);
if (f_status)
{
ffrprt (stderr, f_status);
aXe_message (aXe_M_FATAL, __FILE__, __LINE__,
"aXe_PET2SP: Could not open file: %s\n",
bck_PET_file_path);
}
}
/* Copy the header info from the grism image */
SPC_ptr = create_SPC_opened (SPC_file_path,1);
cards = get_FITS_cards_opened(OPET_ptr);
put_FITS_cards_opened(SPC_ptr, cards);
free_FITScards(cards);
if (opt_weights)
{
cards = get_FITS_cards_opened(OPET_ptr);
// open the WHT file and add the header keywords
WHT_ptr = create_FITSimage_opened (WHT_file_path, 1);
put_FITS_cards_opened(WHT_ptr, cards);
// open the opt_SPC and add the header keywords
SPC_opt_ptr = create_SPC_opened (SPC_opt_file_path,1);
put_FITS_cards_opened(SPC_opt_ptr, cards);
// delete the header keywords
free_FITScards(cards);
}
// do something only if there
// exist valid objects
i = 0;
if (oblist!=NULL)
{
// turn until the end of the PET is reached
while (1)
{
empty=0;
// Get the PET for this object
obj_PET = get_ALL_from_next_in_PET(OPET_ptr, &obj_aperID, &obj_beamID);
// load the background PET if requested
if (dobck)
{
bck_PET = get_ALL_from_next_in_PET(BPET_ptr, &bck_aperID, &bck_beamID);
if ((bck_aperID!=obj_aperID)||(bck_beamID!=obj_beamID))
aXe_message (aXe_M_FATAL, __FILE__, __LINE__,
"Background PET and Object PET extensions are not"
" in the same order and cannot be combined.\n");
}
// end of PET reached: the break condition
if ((obj_aperID==-1) && (obj_beamID==-1))
break;
// signal an empty PET
if (obj_PET==NULL)
empty=1;
// give feedback to the screen
fprintf (stdout, "aXe_PET2SPC: BEAM %d; %d%c\n", i, obj_aperID, BEAM(obj_beamID));fflush(stdout);
// identify the object which matches the PET
objindex = find_object_in_object_list(oblist,obj_aperID);
// look whether we are for grisms or prisms
for_grism = check_for_grism (conf_file_path, obj_beamID);
wl_calibration = get_calfunc_for_beam(oblist[objindex]->beams[obj_beamID], for_grism, conf_file_path, conf);
// compute the object spectrum
obj_spec = bin_naive (obj_PET, oblist[objindex]->beams[obj_beamID].width,
oblist[objindex]->beams[obj_beamID].orient, quant_cont);
// check for the existence of a background PET
if (dobck)
{
// compute the background spectrum
bck_spec = bin_naive (bck_PET,
oblist[objindex]->beams[bck_beamID].width,
oblist[objindex]->beams[bck_beamID].orient, quant_cont);
}
else
{
// create a dummy background spectrum
bck_spec = empty_counts_spectrum_copy(obj_spec);
}
// subtract the background spectrum from the
// object (or forground) spectrum
sobj_spec = subtract_spectra (obj_spec, bck_spec);
if(!noflux)
{
get_troughput_table_name(conf_file_path,
oblist[objindex]->beams[obj_beamID].ID,
table);
if (strcmp(table,"None"))
{
build_path (AXE_CONFIG_PATH, table, table_path);
resp=get_response_function_from_FITS(table_path,2);
resp_func = create_response_function(table_path);
if (resp->spec_len <2)
{
aXe_message (aXe_M_WARN1, __FILE__, __LINE__,
"Throughput table %s contains only %d"
" values. No sensitivity curve was applied.\n",
table_path,resp->spec_len);
}
else
{
fprintf(stdout,"aXe_PET2SPC: Applying sensitivity contained in %s\n",table_path);
smooth_params = get_smooth_pars_for_beam(conf, smooth_conv, oblist[objindex]->beams[obj_beamID]);
if (smooth_params.x > 0.0)
{
// apply a smoothed flux conversion
apply_smoothed_response(wl_calibration, for_grism, quant_cont, resp_func, smooth_params, sobj_spec);
}
else
{
// apply a normal flux conversion
apply_response_function(sobj_spec,resp, quant_cont);
}
}
// free the memory of the
// response functions
free_spectrum(resp);
free_response_function(resp_func);
}
}
if (empty!=1)
{
add_spectra_to_SPC_opened (SPC_ptr, obj_spec, bck_spec,
sobj_spec, oblist[objindex]->ID, oblist[objindex]->beams[obj_beamID].ID);
/* Copy header from OPET extension into this SPC extension */
cards = get_FITS_cards_opened(OPET_ptr);
put_FITS_cards_opened(SPC_ptr,cards);
free_FITScards(cards);
}
free_spectrum (bck_spec);
free_spectrum (sobj_spec);
free_spectrum (obj_spec);
if (opt_weights)
{
// get the dimension in trace length
// and crossdispersion
dimension = get_all_dims(obj_PET, bck_PET,
oblist[objindex]->beams[obj_beamID], dobck);
// check for empty PET
if (!dimension.resolution)
{
// create dummies in case of empty PET's
weights = get_default_weight();
modvar = get_default_modvar();
}
else
{
// prepare the PET's by computing the inverse variance.
// Also the trace distances are shifted by 0.5
// to get a sampling comparable to the unweighted
// extraction
prepare_inv_variance(obj_PET, bck_PET, dobck, conf, exptime, sky_cps, 0.0);
// compute the inverse variance and the profile
// image in the trace distance - crossdispersion plane
modvar = compute_modvar(obj_PET, oblist[objindex]->beams[obj_beamID], dimension);
// compute the optimal weights
weights = comp_allweight(modvar);
}
if (dimension.resolution && empty != 1)
{
sprintf (label, "WHT_%d%c", obj_aperID, BEAM (obj_beamID));
gsl_to_FITSimage_opened (weights, WHT_ptr ,0,label);
// make and store the default header
cards = beam_to_FITScards(oblist[objindex],obj_beamID);
put_FITS_cards_opened(WHT_ptr,cards);
free_FITScards(cards);
}
// create the optimal weighted
// foreground spectrum
obj_spec = bin_optimal (obj_PET,oblist[objindex]->beams[obj_beamID],
quant_cont, weights, dimension, coverage);
// check for the presence of a background PET
if (dobck)
{
// create the optimal weighted
// background spectrum
bck_spec = bin_optimal (bck_PET,oblist[objindex]->beams[obj_beamID],
quant_cont, weights, dimension, coverage);
}
else
{
// make a dummy background spectrum
bck_spec = empty_counts_spectrum_copy(obj_spec);
}
// release memory
gsl_matrix_free(weights);
free_drzstamp(modvar);
// subtract the background spectrum from the
// object (or forground) spectrum
sobj_spec = subtract_spectra (obj_spec, bck_spec);
if(!noflux)
{
get_troughput_table_name(conf_file_path,
oblist[objindex]->beams[obj_beamID].ID,
table);
if (strcmp(table,"None"))
{
build_path (AXE_CONFIG_PATH, table, table_path);
resp=get_response_function_from_FITS(table_path,2);
resp_func = create_response_function(table_path);
if (resp->spec_len <2)
{
aXe_message (aXe_M_WARN1, __FILE__, __LINE__,
"Throughput table %s contains only %d"
" values. No sensitivity curve was applied.\n",
table_path,resp->spec_len);
}
else
{
fprintf(stdout,"aXe_PET2SPC: Applying sensitivity contained in %s\n",table_path);
smooth_params = get_smooth_pars_for_beam(conf, smooth_conv, oblist[objindex]->beams[obj_beamID]);
if (smooth_params.x > 0.0)
{
apply_smoothed_response(wl_calibration, for_grism, quant_cont, resp_func, smooth_params, sobj_spec);
}
else
{
apply_response_function(sobj_spec,resp, quant_cont);
}
}
// free the memory
free_spectrum(resp);
free_response_function(resp_func);
}
}
if (empty!=1)
{
add_spectra_to_SPC_opened (SPC_opt_ptr, obj_spec, bck_spec,
sobj_spec, oblist[objindex]->ID, oblist[objindex]->beams[obj_beamID].ID);
/* Copy header from OPET extension into this SPC extension */
cards = get_FITS_cards_opened(OPET_ptr);
put_FITS_cards_opened(SPC_opt_ptr,cards);
free_FITScards(cards);
}
free_spectrum (bck_spec);
free_spectrum (sobj_spec);
free_spectrum (obj_spec);
}
// free memory
free_calib (wl_calibration);
if (bck_PET!=NULL)
free (bck_PET);
if (obj_PET!=NULL)
free (obj_PET);
i++;
}
}
fits_close_file (SPC_ptr, &f_status);
if (f_status)
{
ffrprt (stderr, f_status);
aXe_message (aXe_M_FATAL, __FILE__, __LINE__,
"aXe_PET2SPC: " "Error closing SPC: %s\n",
SPC_file_path);
}
if (opt_weights)
{
fits_close_file (WHT_ptr, &f_status);
if (f_status)
{
ffrprt (stderr, f_status);
aXe_message (aXe_M_FATAL, __FILE__, __LINE__,
"aXe_PET2SPC: " "Error closing WHT: %s\n",
WHT_file_path);
}
fits_close_file (SPC_opt_ptr, &f_status);
if (f_status)
{
ffrprt (stderr, f_status);
aXe_message (aXe_M_FATAL, __FILE__, __LINE__,
"aXe_PET2SPC: " "Error closing PSC: %s\n",
SPC_opt_file_path);
}
}
if (oblist!=NULL)
free_oblist (oblist);
fprintf (stdout, "aXe_PET2SPC: Done...\n");
exit (0);
}
/**
* Function: bin_optimal
* computes a spectrum from a table of aperture pixels generated from
* spc_extract. This is adds up the pixel values, distributing them
* over the trace, taking into account the fracton of the pixel that
* projects onto the given [xi,xi+1] interval.
* Return NULL if ap_p is NULL
*
* Parameters:
* @param ap_p the table of aperture pixels
* @param px_width width of a pixel (=1 if not subsampled)
* @param ob_width the width of the object that has generated the spectrum
* @param ob_orientation the orientation of the object that has
* generated the spectrum
* @param flags problems that were accumulated in generating ap_p;
* possible flags are defined for the warning member of the spectrum struct
*
* Returns:
* @return spec - the 1D spectrum
*/
spectrum *
bin_optimal (const ap_pixel * const ap_p, const beam curbeam,
const int quant_cont, const gsl_matrix *weights,
const drzstamp_dim dimension,gsl_matrix *coverage)
{
const ap_pixel *cur_p;
ap_pixel *tmp_p;
spectrum *spec;
spectrum *tspec;
spc_entry *spec_table;
quadrangle quad;
// drzstamp_dim dimension;
double jacob, arr;
double frac, totweight;
int jcen, icen;
int jupp, iupp;
int jlow, ilow;
int ii, jj;
int stpi, stpj;
// return NULL if
// empty PET
if (ap_p==NULL)
return NULL;
// allocate memory
tmp_p = (ap_pixel *) malloc(sizeof(ap_pixel));
// allocate memory for the spectrum
spec = allocate_spectrum (weights->size1);
spec_table = spec->spec;
// go over each PET pixel
cur_p = ap_p;
for (cur_p = ap_p; cur_p->p_x != -1; cur_p++)
{
// continue if the pixel is outside
// of the extraction region
if (fabs (cur_p->dist) > curbeam.width + .5)
continue;
// determine which fraction
// of the pixel is inside of the extraction area
if ((fabs (cur_p->dist) >= curbeam.width - .5) && (fabs (cur_p->dist) <= curbeam.width + .5))
frac = fabs (curbeam.width - (fabs (cur_p->dist) - 0.5));
else
frac = 1.;
// transfer values to the temporary pixel
tmp_p->lambda = cur_p->xi;
tmp_p->dist = cur_p->dist;
tmp_p->dxs = cur_p->dxs;
tmp_p->dlambda = 1.0;
// create the quadrangle for the current pixel
quad = get_quad_from_pixel(tmp_p, curbeam.orient, dimension);
// get the jacobian (well, easy here)
// the term "cos(cur_p->dxs)" must be there
// to correct the enlargement necessary
// to cover the whole lambda-crossdispersion area!
// NOT COMPLETELY understood
jacob = cos(cur_p->dxs);
// get the central pixel (icen, jcen) of the current PET-pixel
icen = (int) floor(cur_p->xi - dimension.xstart+.5);
jcen = (int) floor(cur_p->dist - dimension.ystart+.5);
// get the uper and lower extend of the quadrangle in x
iupp = (int)floor(quad.xmax - (double)icen + 0.5)+1;
ilow = (int)floor(quad.xmin - (double)icen + 0.5);
// get the uper and lower extend of the quadrangle in x
jupp = (int)floor(quad.ymax - (double)jcen + 0.5)+1;
jlow = (int)floor(quad.ymin - (double)jcen + 0.5);
// go over the extend in x
for (ii=ilow;ii<iupp;ii++)
{
// go over the extend in x
for (jj=jlow;jj<jupp;jj++)
{
// get the coordinates of the current output pixel
stpi = icen+ii;
stpj = jcen+jj;
// check whether the current output pixel is within
// the stamp image; continue if not
if ( (stpi>=dimension.xsize)||(stpi<0)||(stpj>=dimension.ysize)||(stpj<0) )
continue;
// get the area which falls onto the current output pixel
arr = boxer(stpi,stpj,quad.x,quad.y);
// compute the pixel weight from
// the various inputs
totweight = arr*frac*jacob*gsl_matrix_get(weights, stpi, stpj);
//totweight = arr*frac*jacob;//*gsl_matrix_get(weights, stpi, stpj);
//gsl_matrix_set(coverage, stpi, stpj, gsl_matrix_get(coverage, stpi, stpj) + arr*frac*jacob);
// add the pixel to the spectrum
if (totweight > 0.0)
add_to_spec_table (spec, stpi, cur_p, quant_cont,totweight);
// gsl_matrix_set(coverage, stpi, stpj, sqrt (SQR (gsl_matrix_get(coverage, stpi, stpj)) + SQR (fabs(cur_p->error) * totweight)));
}
}
}
/* Trimming the INDEF beginning and ending values in spectrum */
tspec = trim_spectrum (spec);
free_spectrum (spec);
spec = NULL;
free(tmp_p);
// return the spectrum
return tspec;
}
int main(int argc, char **argv)
{
pthread_t rtl_thread;
pthread_t fm_thread;
char cert_path[1024];
char key_path[1024];
int n = 0;
int use_ssl = 0;
struct libwebsocket_context *context;
int opts = 0;
char interface_name[128] = "";
const char *iface = NULL;
int syslog_options = LOG_PID | LOG_PERROR;
unsigned int oldus = 0;
struct lws_context_creation_info info;
int debug_level = 7;
memset(&info, 0, sizeof info);
info.port = PORT;
rtl_init(DEV_INDEX);
transfer.buf = NULL;
transfer.block_id = 0;
spectrum = init_spectrum(FFT_POINTS);
spectrum_temp_buffer = malloc(FFT_POINTS*2*4);
send_buffer = malloc(LWS_SEND_BUFFER_PRE_PADDING + SEND_BUFFER_SIZE + LWS_SEND_BUFFER_POST_PADDING);
while (n >= 0) {
n = getopt_long(argc, argv, "i:hsp:d:Dr:", options, NULL);
if (n < 0)
continue;
switch (n) {
case 'd':
debug_level = atoi(optarg);
break;
case 's':
use_ssl = 1;
break;
case 'p':
info.port = atoi(optarg);
break;
case 'i':
strncpy(interface_name, optarg, sizeof interface_name);
interface_name[(sizeof interface_name) - 1] = '\0';
iface = interface_name;
break;
case 'r':
resource_path = optarg;
printf("Setting resource path to \"%s\"\n", resource_path);
break;
case 'h':
fprintf(stderr, "Usage: rtl-ws-server "
"[--port=<p>] [--ssl] "
"[-d <log bitfield>] "
"[--resource_path <path>]\n");
exit(1);
}
}
signal(SIGINT, sighandler);
/* we will only try to log things according to our debug_level */
setlogmask(LOG_UPTO (LOG_DEBUG));
openlog("lwsts", syslog_options, LOG_DAEMON);
/* tell the library what debug level to emit and to send it to syslog */
lws_set_log_level(debug_level, lwsl_emit_syslog);
info.iface = iface;
info.protocols = protocols;
info.extensions = libwebsocket_get_internal_extensions();
if (!use_ssl) {
info.ssl_cert_filepath = NULL;
info.ssl_private_key_filepath = NULL;
} else {
if (strlen(resource_path) > sizeof(cert_path) - 32) {
lwsl_err("resource path too long\n");
return -1;
}
sprintf(cert_path, "%s/libwebsockets-test-server.pem",
resource_path);
if (strlen(resource_path) > sizeof(key_path) - 32) {
lwsl_err("resource path too long\n");
return -1;
}
sprintf(key_path, "%s/libwebsockets-test-server.key.pem",
resource_path);
info.ssl_cert_filepath = cert_path;
info.ssl_private_key_filepath = key_path;
}
info.gid = -1;
info.uid = -1;
info.options = opts;
context = libwebsocket_create_context(&info);
if (context == NULL) {
lwsl_err("libwebsocket init failed\n");
return -1;
}
n = 0;
pthread_mutex_init(&data_mutex, NULL);
pthread_create(&rtl_thread, NULL, rtl_worker, NULL);
pthread_create(&fm_thread, NULL, fm_worker, NULL);
while (n >= 0 && !force_exit) {
n = libwebsocket_service(context, 50);
}
force_exit = 1;
usleep(100);
libwebsocket_context_destroy(context);
lwsl_notice("rtl-ws-server exited\n");
closelog();
rtl_close();
pthread_mutex_destroy(&data_mutex);
pthread_exit(NULL);
if (transfer.buf != NULL) {
free(transfer.buf);
transfer.buf = NULL;
transfer.block_id = 0;
}
free(send_buffer);
free_spectrum(spectrum);
free(spectrum_temp_buffer);
return 0;
}
/**
* Function: bin_naive
* computes a spectrum from a table of aperture pixels generated from
* spc_extract. This is adds up the pixel values, distributing them
* over the trace, taking into account the fracton of the pixel that
* projects onto the given [xi,xi+1] interval.
* Return NULL if ap_p is NULL
*
* Parameters:
* @param ap_p the table of aperture pixels
* @param px_width width of a pixel (=1 if not subsampled)
* @param ob_width the width of the object that has generated the spectrum
* @param ob_orientation the orientation of the object that has
* generated the spectrum
* @param flags problems that were accumulated in generating ap_p;
* possible flags are defined for the warning member of the spectrum struct
*
* Returns:
* @return spec - the 1D spectrum
*/
spectrum *
bin_naive (const ap_pixel * const ap_p, const double ob_width,
const double ob_orient, const int quant_cont)
{
const ap_pixel *cur_p;
int upper, lower;
int bin;
spectrum *spec, *tspec;
double phi_trace;
spc_entry *spec_table;
double d, frac;
// immediately return empty PET's
if (ap_p==NULL)
return NULL;
// go through the PET,
// find the minimum and
// maximum in trace distance
cur_p = ap_p;
upper = NAIVE_VAL_TO_BININD (cur_p->xi);
lower = NAIVE_VAL_TO_BININD (cur_p->xi);
while (cur_p->p_x != -1)
{
bin = NAIVE_VAL_TO_BININD (cur_p->xi);
upper = MAX (bin, upper);
lower = MIN (bin, lower);
cur_p++;
}
// check whether the spectrum
// will ahve a finite length,
// exit if not
if (upper == lower)
{
aXe_message (aXe_M_WARN4, __FILE__, __LINE__,
"Pixel table empty.\n");
return NULL;
}
// Thresh in some headway so we don't need to worry too much about
// accessing invalid elements now and then
lower -= 10;
upper += 10;
spec = allocate_spectrum (upper - lower);
spec_table = spec->spec;
cur_p = ap_p;
while (cur_p->p_x != -1)
{
// Compute any fractional pixel that might fall within the
//desired extraction width
d = ob_width;
frac = 1.;
// continue if the pixel is outside
// of the extraction region
if (fabs (cur_p->dist) > d + .5)
{
cur_p++;
continue;
}
if ((fabs (cur_p->dist) >= d - .5) && (fabs (cur_p->dist) <= d + .5))
{
frac = fabs (d - (fabs (cur_p->dist) - 0.5));
}
// store the local trace angle
phi_trace = cur_p->dxs;
if (1)
{
double xi;
w_pixel pix;
double sinp = sin (phi_trace);
double cosp = cos (phi_trace);
double xc, yc;
double w;
double sum = 0;
fill_w_pixel (&pix, cur_p->x, cur_p->y, ob_orient);
xc = cur_p->xs;
yc = cur_p->ys;
// at cur_p->xi, there has to be some contribution. We go back
// collecting, until w is zero
for (xi = cur_p->xi;; xi -= 1)
{
bin = NAIVE_VAL_TO_BININD (xi);
w = PIXWEIGHT (xc + (bin - cur_p->xi) * cosp,
yc + (bin - cur_p->xi) * sinp,
xc + (bin + 1 - cur_p->xi) * cosp,
yc + (bin + 1 - cur_p->xi) * sinp,
&pix);
if (w < 1e-10)
break;
add_to_spec_table (spec, bin - lower, cur_p, quant_cont,
w * frac * cur_p->weight);
// if (cur_p->weight > 10.0){
// fprintf(stdout,"weight: %f, distance: %f, ewidth: %f\n",
// cur_p->weight, cur_p->dist, d+0.5);
// }
sum += w;
}
/* Now collect contributions upward of cur_p->xi */
for (xi = cur_p->xi + 1;; xi += 1)
{
bin = NAIVE_VAL_TO_BININD (xi);
w = PIXWEIGHT (xc + (bin - cur_p->xi) * cosp,
yc + (bin - cur_p->xi) * sinp,
xc + (bin + 1 - cur_p->xi) * cosp,
yc + (bin + 1 - cur_p->xi) * sinp,
&pix);
if (w < 1e-10)
break;
add_to_spec_table (spec, bin - lower, cur_p, quant_cont,
w * frac * cur_p->weight);
sum += w;
}
if (fabs (sum - 1) > 1e-6)
{
fprintf(stdout,
"Weights added up to only %f for pixel from %4d,%4d\n",
sum, cur_p->p_x, cur_p->p_y);
}
}
cur_p++;
}
/* Trimming the INDEF beginning and ending values in spectrum */
tspec = trim_spectrum (spec);
free_spectrum (spec);
spec = NULL;
// return the spectrum
return tspec;
}
