00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #ifdef HAVE_CONFIG_H
00027 #include <config.h>
00028 #endif
00029
00030
00037
00040
00041
00042
00043
00044 #include <math.h>
00045 #include <xsh_drl.h>
00046
00047 #include <xsh_baryvel.h>
00048 #include <xsh_badpixelmap.h>
00049 #include <xsh_data_rec.h>
00050 #include <xsh_data_localization.h>
00051 #include <xsh_data_pre.h>
00052 #include <xsh_data_order.h>
00053 #include <xsh_data_wavesol.h>
00054 #include <xsh_data_spectralformat.h>
00055 #include <xsh_dfs.h>
00056 #include <xsh_pfits.h>
00057 #include <xsh_error.h>
00058 #include <xsh_msg.h>
00059 #include <xsh_fit.h>
00060 #include <xsh_model_io.h>
00061 #include <xsh_model_kernel.h>
00062 #include <xsh_ifu_defs.h>
00063 #include <xsh_data_dispersol.h>
00064 #include <xsh_data_slice_offset.h>
00065 #include <cpl.h>
00066 #include <xsh_utils.h>
00067 #include <xsh_rectify.h>
00068 #include <xsh_model_utils.h>
00069
00070
00071
00072
00073
00074
00075
00076 #define SLIT_FRAC_STEP 50
00077
00078 static cpl_vector * rec_profile = NULL ;
00079
00080 static double compute_shift_with_localization( cpl_frame *loc_frame,
00081 cpl_frame *loc0_frame);
00082
00083 static double compute_shift_with_kw( cpl_propertylist * header,
00084 xsh_rectify_param *rectify_par,
00085 double **ref_ra, double **ref_dec, int flag);
00086
00087 static cpl_frame*
00088 xsh_shift( cpl_frame *rec_frame, xsh_instrument *instrument,
00089 const char *fname, double slit_shift, cpl_frame** res_frame_ext);
00090
00091
00092
00093
00094
00095 static void get_errors( float *err, int ix, int iy, int nx, int ny,
00096 double radius, float *err_val, int* qual_val)
00097 {
00098 int xmin, xmax, ymin, ymax ;
00099 int i, j, x, y, n ;
00100 double sum2 ;
00101 double *err_vect = NULL;
00102 int err_vect_size = 0;
00103
00104 XSH_ASSURE_NOT_NULL( err);
00105 XSH_ASSURE_NOT_NULL( err_val);
00106 XSH_ASSURE_NOT_NULL( qual_val);
00107
00108
00109
00110
00111
00112 n = 0 ;
00113 sum2 = 0 ;
00114 xmin = ix - radius ;
00115 xmax = ix + radius ;
00116 ymin = iy - radius ;
00117 ymax = iy + radius ;
00118
00119
00120 err_vect_size = (2*radius+1)*(2*radius+1);
00121
00122 XSH_CALLOC( err_vect, double, err_vect_size);
00123
00124 for( y = ymin ; y < ymax ; y++ ){
00125 for( x = xmin ; x < xmax ; x++ ) {
00126 if ( y < 0 || y >= ny || x < 0 || x >= nx ) continue;
00127 err_vect[n] = err[x+y*nx];
00128 n++;
00129 }
00130 }
00131
00132 for(i=0; i< n; i++){
00133 for(j=i; j< n; j++){
00134 if (i==j){
00135 sum2 += err_vect[i]*err_vect[j];
00136 }
00137 else{
00138 sum2 += 2*err_vect[i]*err_vect[j];
00139 }
00140 }
00141 }
00142
00143 if (n != 0){
00144 *err_val = sqrt( sum2 )/(double)n ;
00145 }
00146 else{
00147 *err_val = 1;
00148 *qual_val = QFLAG_OUTSIDE_DATA_RANGE;
00149 }
00150 cleanup:
00151 XSH_FREE( err_vect);
00152 }
00153
00154
00155
00156 static void
00157 xsh_rec_list_rectify( xsh_rec_list *rec_list, int iorder, int irec,
00158 xsh_pre *sci_pre, double fx, double fy, double radius, cpl_vector *profile,
00159 double mult, int *good, int *bad, int *out)
00160 {
00161 int nx,ny;
00162 float *rec_flux = NULL;
00163 float *rec_errs = NULL;
00164 int *rec_qual = NULL;
00165 int ix,iy;
00166
00167 XSH_ASSURE_NOT_NULL( rec_list);
00168 XSH_ASSURE_NOT_NULL( sci_pre);
00169 XSH_ASSURE_NOT_NULL( good);
00170 XSH_ASSURE_NOT_NULL( bad);
00171 XSH_ASSURE_NOT_NULL( out);
00172 XSH_ASSURE_NOT_NULL( profile);
00173
00174 check( rec_flux = xsh_rec_list_get_data1( rec_list, iorder));
00175 check( rec_errs = xsh_rec_list_get_errs1( rec_list, iorder));
00176 check( rec_qual = xsh_rec_list_get_qual1( rec_list, iorder));
00177
00178 check( nx = xsh_pre_get_nx( sci_pre));
00179 check( ny = xsh_pre_get_ny( sci_pre));
00180
00181 ix = floor( fx - 0.5) ;
00182 iy = floor( fy - 0.5) ;
00183
00184 if ( ix <0 || ix >= nx || iy < 0 || iy >= ny ) {
00185 xsh_msg_dbg_high( "OUT_OF_RANGE at %d,%d", ix, iy);
00186 *out= *out+1;
00187 rec_flux[irec] = 0;
00188 rec_errs[irec] = 1;
00189 rec_qual[irec] = QFLAG_OUTSIDE_DATA_RANGE;
00190 }
00191 else{
00192 cpl_image *sci_img = NULL;
00193 float *data = NULL;
00194 float *errs = NULL;
00195 int *qual = NULL;
00196 int imqual_val;
00197 float imflux_val, imerr_val;
00198
00199 check( sci_img = xsh_pre_get_data( sci_pre));
00200 check( data = cpl_image_get_data_float( sci_img));
00201 check( qual = cpl_image_get_data_int( xsh_pre_get_qual( sci_pre)));
00202 check( errs = cpl_image_get_data_float( xsh_pre_get_errs( sci_pre)));
00203 imqual_val = qual[ix+iy*nx];
00204 imflux_val = data[ix+iy*nx];
00205 imerr_val = errs[ix+iy*nx];
00206
00207 if ( radius == 0.){
00208 rec_flux[irec] = imflux_val;
00209 rec_errs[irec] = imerr_val;
00210 rec_qual[irec] = imqual_val;
00211 }
00212 else {
00213 double flux_val=0, confidence=0 ;
00214 float err_val=0;
00215 int qual_val = QFLAG_GOOD_PIXEL;
00216
00217 check( flux_val = cpl_image_get_interpolated( sci_img, fx, fy,
00218 profile, radius, profile, radius, &confidence));
00219
00220 check( get_errors( errs, ix, iy, nx, ny, radius, &err_val,
00221 &qual_val));
00222
00223 if (confidence >= 0.5){
00224 rec_flux[irec] = flux_val;
00225 rec_errs[irec] = err_val;
00226 rec_qual[irec] = qual_val;
00227 *good = *good+1;
00228 }
00229 else if (confidence > 0){
00230 if (flux_val == 0){
00231 XSH_REGDEBUG("fx %f fy %f confidence %f", fx,fy,confidence);
00232 }
00233 rec_flux[irec] = flux_val;
00234 rec_errs[irec] = err_val;
00235 rec_qual[irec] = QFLAG_MISSING_DATA;
00236 *bad = *bad+1;
00237 }
00238 else{
00239 rec_flux[irec] = 0;
00240 rec_errs[irec] = 1;
00241 rec_qual[irec] = QFLAG_MISSING_DATA;
00242 *bad = *bad+1;
00243 }
00244 }
00245 }
00246 rec_flux[irec] *= mult;
00247 rec_errs[irec] *= mult;
00248
00249 cleanup:
00250 return;
00251 }
00252
00253
00254
00275
00276 static void
00277 fill_rectified( xsh_pre *pre_sci,
00278 xsh_rec_list *rec_list,
00279 int idx,
00280 xsh_wavesol *wavesol,
00281 xsh_xs_3 *model_config,
00282 xsh_instrument *instrument,
00283 xsh_dispersol_list *disp_list,
00284 float slit_min,
00285 float slit_max,
00286 double lambda_min,
00287 int skip_low,
00288 int skip_up,
00289 xsh_rectify_param *rectify_par,
00290 double slit_shift)
00291 {
00292 int ns, nl;
00293 int nslit, nlambda ;
00294 float * slit = NULL ;
00295 double * lambda = NULL ;
00296 float * flux1 = NULL ;
00297 float * errs1 = NULL ;
00298 int * qual1 = NULL ;
00299 int order, last_slit, last_lambda;
00300 double *x_data = NULL;
00301 double *y_data = NULL;
00302
00303 int good_pixel = 0, out_of_bound = 0, bad_pixel = 0 ;
00304
00305
00306
00307
00308 XSH_ASSURE_NOT_NULL( pre_sci);
00309 XSH_ASSURE_NOT_NULL( rec_list);
00310 check( slit = xsh_rec_list_get_slit( rec_list, idx));
00311 XSH_ASSURE_NOT_NULL( slit);
00312 check( lambda = xsh_rec_list_get_lambda( rec_list, idx));
00313 XSH_ASSURE_NOT_NULL( lambda);
00314 check( flux1 = xsh_rec_list_get_data1( rec_list, idx));
00315 check( errs1 = xsh_rec_list_get_errs1( rec_list, idx));
00316 check( qual1 = xsh_rec_list_get_qual1( rec_list, idx));
00317
00318
00319 if ( rec_profile == NULL && rectify_par->rectif_radius != 0 ) {
00320 check( rec_profile = cpl_vector_new( CPL_KERNEL_DEF_SAMPLES));
00321
00322 check( cpl_vector_fill_kernel_profile( rec_profile,
00323 rectify_par->kernel_type, rectify_par->rectif_radius));
00324 }
00325
00326
00327 check( order = xsh_rec_list_get_order( rec_list, idx));
00328 check( nslit = xsh_rec_list_get_nslit( rec_list, idx));
00329 check( nlambda = xsh_rec_list_get_nlambda( rec_list, idx));
00330
00331 last_slit = nslit-1;
00332 last_lambda = nlambda-1;
00333
00334 XSH_CALLOC( x_data, double, nslit*nlambda);
00335 XSH_CALLOC( y_data, double, nslit*nlambda);
00336
00337
00338 for( ns = 0 ; ns < nslit ; ns++ ) {
00339
00340 rec_list->list[idx].slit[ns] = slit_min +
00341 ((float)ns*rectify_par->rectif_bin_space)+
00342 rectify_par->rectif_bin_space/2.0;
00343 }
00344
00345 for( nl = 0 ; nl < nlambda ; nl++ ) {
00346
00347 rec_list->list[idx].lambda[nl] = lambda_min +
00348 (double)nl*rectify_par->rectif_bin_lambda;
00349 }
00350
00351 xsh_msg_dbg_low( "Order %d slit (%f,%f):%d lambda (%f,%f):%d",
00352 order, rec_list->list[idx].slit[0],
00353 rec_list->list[idx].slit[last_slit], nslit,
00354 rec_list->list[idx].lambda[0],
00355 rec_list->list[idx].lambda[last_lambda], nlambda);
00356
00357
00358 if ( wavesol != NULL){
00359 for( ns = skip_low ; ns < (nslit - skip_up) ; ns++ ) {
00360 double xslit = slit[ns]+slit_shift;
00361
00362 for( nl = 0 ; nl < nlambda ; nl++ ) {
00363 int irec;
00364 double xlambda = lambda[nl];
00365
00366 irec= nl+ns*nlambda;
00367
00368
00369 check( x_data[irec] = xsh_wavesol_eval_polx( wavesol, xlambda, order,
00370 xslit));
00371 check( y_data[irec] = xsh_wavesol_eval_poly( wavesol, xlambda, order,
00372 xslit));
00373 }
00374 }
00375 }
00376 else{
00377 XSH_ASSURE_NOT_NULL( model_config);
00378 for( ns = skip_low ; ns < (nslit - skip_up) ; ns++ ) {
00379 double xslit = slit[ns]+slit_shift;
00380
00381 for( nl = 0 ; nl < nlambda ; nl++ ) {
00382 int irec;
00383 double pm_x=0, pm_y=0;
00384 double xlambda = lambda[nl];
00385
00386 irec= nl+ns*nlambda;
00387 check( xsh_model_get_xy( model_config, instrument, xlambda, order, xslit,
00388 &pm_x, &pm_y));
00389 x_data[irec] = convert_data_to_bin( pm_x, instrument->binx );
00390 y_data[irec] = convert_data_to_bin( pm_y, instrument->biny );
00391 }
00392 }
00393 }
00394
00395
00396 if (disp_list == NULL) {
00397
00398 for( ns = skip_low ; ns < (nslit - skip_up) ; ns++ ) {
00399 for( nl = 0 ; nl < nlambda ; nl++ ) {
00400 double fx=0, fy=0;
00401 int irec=0;
00402
00403 irec= nl+ns*nlambda;
00404 fx = x_data[irec];
00405 fy = y_data[irec];
00406
00407 check( xsh_rec_list_rectify( rec_list, idx, irec, pre_sci,
00408 fx, fy,
00409 rectify_par->rectif_radius, rec_profile,
00410 1, &good_pixel, &bad_pixel,
00411 &out_of_bound));
00412 }
00413
00414 }
00415 }
00416 else{
00417 cpl_polynomial *plambdadx = NULL, *plambdady = NULL;
00418 cpl_polynomial *pslitdx = NULL, *pslitdy = NULL;
00419 cpl_vector *val = NULL;
00420 int abs_order=0;
00421
00422 check( plambdadx = cpl_polynomial_duplicate(
00423 disp_list->list[idx].lambda_poly));
00424 check( plambdady = cpl_polynomial_duplicate(
00425 disp_list->list[idx].lambda_poly));
00426 check( pslitdx = cpl_polynomial_duplicate(
00427 disp_list->list[idx].slit_poly));
00428 check( pslitdy = cpl_polynomial_duplicate(
00429 disp_list->list[idx].slit_poly));
00430
00431 abs_order = disp_list->list[idx].absorder;
00432
00433 check( cpl_polynomial_derivative( plambdadx, 0));
00434 check( cpl_polynomial_derivative( plambdady, 1));
00435 check( cpl_polynomial_derivative( pslitdx, 0));
00436 check( cpl_polynomial_derivative( pslitdy, 1));
00437
00438 check( val = cpl_vector_new(2));
00439
00440 for( ns = skip_low ; ns < (nslit - skip_up) ; ns++ ) {
00441 for( nl = 0 ; nl < nlambda ; nl++ ) {
00442 double fx, fy;
00443 double ldx, ldy, sdx, sdy, abs_determinant;
00444 int irec;
00445
00446 irec= nl+ns*nlambda;
00447 fx = x_data[irec];
00448 fy = y_data[irec];
00449
00450 check( cpl_vector_set( val, 0, fx));
00451 check( cpl_vector_set( val, 1, fy));
00452
00453 check( ldx = cpl_polynomial_eval( plambdadx, val));
00454 check( ldy = cpl_polynomial_eval( plambdady, val));
00455 check( sdx = cpl_polynomial_eval( pslitdx, val));
00456 check( sdy = cpl_polynomial_eval( pslitdy, val));
00457 abs_determinant = 1.0/(fabs(ldx*sdy-sdx*ldy))*
00458 rectify_par->rectif_bin_space*rectify_par->rectif_bin_lambda;
00459
00460 check( xsh_rec_list_rectify( rec_list, idx, irec, pre_sci,
00461 fx, fy,
00462 rectify_par->rectif_radius,
00463 rec_profile, abs_determinant,
00464 &good_pixel, &bad_pixel, &out_of_bound));
00465 }
00466 }
00467 xsh_free_polynomial( &plambdadx);
00468 xsh_free_polynomial( &plambdady);
00469 xsh_free_polynomial( &pslitdx);
00470 xsh_free_polynomial( &pslitdy);
00471 xsh_free_vector( &val);
00472 }
00473 xsh_msg_dbg_low( " Good pixels: %d, Out of bound: %d, Bad pixels: %d",
00474 good_pixel, out_of_bound, bad_pixel ) ;
00475 cleanup:
00476 xsh_free_vector( &rec_profile);
00477 XSH_FREE( x_data);
00478 XSH_FREE( y_data);
00479 return ;
00480 }
00481
00482
00483
00484
00494 void
00495 xsh_get_slit_edges( cpl_frame *slitmap_frame, double *sdown, double *sup,
00496 double *sldown, double *slup, xsh_instrument *instrument)
00497 {
00498 const char *slitmap_name = NULL;
00499 cpl_propertylist *slitmap_header = NULL;
00500
00501 if ( slitmap_frame != NULL) {
00502 XSH_ASSURE_NOT_NULL( sdown);
00503 XSH_ASSURE_NOT_NULL( sup);
00504
00505 check( slitmap_name = cpl_frame_get_filename( slitmap_frame));
00506 check( slitmap_header = cpl_propertylist_load( slitmap_name, 0));
00507
00508 *sdown = xsh_pfits_get_slitmap_median_edglo( slitmap_header);
00509 if ( cpl_error_get_code() != CPL_ERROR_NONE){
00510 xsh_msg_warning(
00511 "Keyword 'MEDIAN EDGLO SLIT' not found in SLIT_MAP %s. Using default value %f",
00512 slitmap_name, MIN_SLIT);
00513 xsh_error_reset();
00514 }
00515
00516 *sup = xsh_pfits_get_slitmap_median_edgup( slitmap_header);
00517 if ( cpl_error_get_code() != CPL_ERROR_NONE){
00518 xsh_msg_warning(
00519 "Keyword 'MEDIAN EDGUP SLIT' not found in SLIT_MAP %s. Using default value %f",
00520 slitmap_name, MAX_SLIT);
00521 xsh_error_reset();
00522 }
00523 if ( xsh_instrument_get_mode(instrument) == XSH_MODE_IFU){
00524 XSH_ASSURE_NOT_NULL( sldown);
00525 XSH_ASSURE_NOT_NULL( slup);
00526 *sldown = xsh_pfits_get_slitmap_median_sliclo( slitmap_header);
00527 if ( cpl_error_get_code() != CPL_ERROR_NONE){
00528 xsh_msg_warning(
00529 "Keyword 'MEDIAN SLICLO SLIT' not found in SLIT_MAP %s. Using default value %f",
00530 slitmap_name, SLITLET_CEN_CENTER-2);
00531 xsh_error_reset();
00532 }
00533 *slup = xsh_pfits_get_slitmap_median_slicup( slitmap_header);
00534 if ( cpl_error_get_code() != CPL_ERROR_NONE){
00535 xsh_msg_warning(
00536 "Keyword 'MEDIAN SLICUP SLIT' not found in SLIT_MAP %s. Using default value %f",
00537 slitmap_name, SLITLET_CEN_CENTER+2);
00538 xsh_error_reset();
00539 }
00540 }
00541 }
00542 else {
00543 xsh_msg_warning( "No provided SLIT_MAP. Using default values: 'MEDIAN EDGLO SLIT' %f - 'MEDIAN EDGUP SLIT' %f",
00544 MIN_SLIT, MAX_SLIT);
00545 *sdown = MIN_SLIT;
00546 *sup = MAX_SLIT;
00547 if ( xsh_instrument_get_mode(instrument) == XSH_MODE_IFU){
00548 xsh_msg_warning( "Using default values: 'MEDIAN SLICLO SLIT' %f - 'MEDIAN SLICUP SLIT' %f",
00549 SLITLET_CEN_CENTER-2, SLITLET_CEN_CENTER+2);
00550 XSH_ASSURE_NOT_NULL( sldown);
00551 XSH_ASSURE_NOT_NULL( slup);
00552 *sldown = SLITLET_CEN_CENTER-2;
00553 *slup = SLITLET_CEN_CENTER+2;
00554 }
00555 }
00556
00557 if ( xsh_instrument_get_mode(instrument) == XSH_MODE_IFU){
00558 xsh_msg( "IFU limits: slitlet DOWN [%f %f], size: %f arcsec",
00559 *sdown, *sldown, *sldown-*sdown);
00560 xsh_msg( "IFU limits: slitlet CEN [%f %f], size: %f arcsec",
00561 *sldown, *slup, *slup-*sldown);
00562 xsh_msg( "IFU limits: slitlet UP [%f %f], size: %f arcsec",
00563 *slup, *sup, *sup-*slup);
00564 }
00565 else{
00566 xsh_msg( "SLIT limits: [%f %f], total size: %f arcsec", *sdown, *sup, *sup-*sdown);
00567 }
00568 cleanup:
00569 xsh_free_propertylist( &slitmap_header);
00570 return ;
00571 }
00572
00573
00581 void xsh_rec_slit_size( xsh_rectify_param *rectify_par,
00582 double *slit_min, int *nslit, XSH_MODE mode)
00583 {
00584 double smin= MIN_SLIT, smax=MAX_SLIT;
00585 double slit_step;
00586
00587 XSH_ASSURE_NOT_NULL( rectify_par);
00588 XSH_ASSURE_NOT_NULL( slit_min);
00589 XSH_ASSURE_NOT_NULL( nslit);
00590
00591 slit_step = rectify_par->rectif_bin_space;
00592
00593 if ( mode == XSH_MODE_SLIT){
00594 if ( rectify_par->rectify_full_slit != 1 ) {
00595 xsh_msg_warning(" Option not READY go to FULL_SLIT");
00596 }
00597 *nslit = (smax - smin)/slit_step;
00598 *slit_min = smin;
00599 smax = smin+(*nslit-1)*slit_step;
00600
00601 xsh_msg( "SLIT : (%.3f,%.3f) used only (%.3f,%.3f) in %d elts",
00602 MIN_SLIT, MAX_SLIT, smin, smax, *nslit);
00603 }
00604
00605 cleanup:
00606 return;
00607 }
00608
00609
00610 static void
00611 adjust_lambdas( xsh_spectralformat_list * spec_list,
00612 xsh_rectify_param * rectify_par )
00613 {
00614 int i ;
00615 double step = rectify_par->rectif_bin_lambda;
00616
00617 xsh_msg_dbg_high( "Adjust Lambdas: %d orders", spec_list->size ) ;
00618
00619
00620 for ( i = 0 ; i<spec_list->size ; i++ ) {
00621 double min, max ;
00622 int imin, imax ;
00623
00624 min = spec_list->list[i].lambda_min ;
00625 max = spec_list->list[i].lambda_max ;
00626 imin = ceil( min/step) ;
00627 min = (double)imin * step;
00628 imax = floor( max / step);
00629 max = (double)imax*step ;
00630 xsh_msg_dbg_high( "--- test lambdamin - %d : %.4lf -> %.4lf, %lf -> %lf", i,
00631 spec_list->list[i].lambda_min, min,
00632 spec_list->list[i].lambda_max, max ) ;
00633 spec_list->list[i].lambda_min = min;
00634 spec_list->list[i].lambda_max = max;
00635 }
00636 }
00637
00638 static float
00639 get_step_slit( float * slit, int nslit )
00640 {
00641 float result = 0. ;
00642 float min, max ;
00643
00644 max = *(slit+nslit-1) ;
00645 min = *slit ;
00646 result = (max-min)/(float)nslit ;
00647
00648 xsh_msg( " Step Slit = %f", result ) ;
00649 return result ;
00650
00651 }
00652
00653
00654
00687
00688 cpl_frame *
00689 xsh_rectify( cpl_frame *sci_frame,
00690 cpl_frame * orderlist_frame,
00691 cpl_frame *wavesol_frame,
00692 cpl_frame * model_frame,
00693 xsh_instrument *instrument,
00694 xsh_rectify_param *rectify_par,
00695 cpl_frame *spectralformat_frame,
00696 cpl_frame *disp_tab_frame,
00697 const char * res_name,
00698 cpl_frame** res_frame_ext,
00699 cpl_frame** res_frame_tab,
00700 const char* rec_prefix)
00701 {
00702 cpl_frame *result = NULL;
00703 xsh_order_list *orderlist = NULL ;
00704 int nslit;
00705 double slit_min;
00706 char tag[80];
00707
00708 XSH_ASSURE_NOT_NULL( orderlist_frame);
00709
00710 check( orderlist = xsh_order_list_load ( orderlist_frame, instrument));
00711
00712 sprintf(tag,"%s_%s",rec_prefix,
00713 XSH_GET_TAG_FROM_ARM( XSH_ORDER2D, instrument));
00714
00715 xsh_rec_slit_size( rectify_par, &slit_min, &nslit, XSH_MODE_SLIT);
00716
00717 check( result = xsh_rectify_orders( sci_frame, orderlist,
00718 wavesol_frame, model_frame, instrument, rectify_par, spectralformat_frame,
00719 disp_tab_frame, res_name, tag,
00720 res_frame_ext, res_frame_tab,
00721 0, 100, slit_min, nslit,0));
00722
00723 cleanup:
00724 xsh_order_list_free( &orderlist);
00725 return result;
00726 }
00727
00728
00750 cpl_frame * xsh_rectify_and_shift( cpl_frame *sci_frame,
00751 cpl_frame * orderlist_frame,
00752 cpl_frame *wavesol_frame,
00753 cpl_frame * model_frame,
00754 xsh_instrument *instrument,
00755 xsh_rectify_param *rectify_par,
00756 cpl_frame *spectralformat_frame,
00757 cpl_frame * loc_frame,
00758 cpl_frame * loc0_frame,
00759 double *throw_shift,
00760 cpl_frame *disp_tab_frame,
00761 const char * res_name,
00762 cpl_frame** res_frame_ext,
00763 cpl_frame** res_frame_tab)
00764 {
00765 cpl_frame *result = NULL, *shift_rec = NULL;
00766 cpl_frame * shift_rec_ext = NULL;
00767 xsh_order_list *orderlist = NULL ;
00768 int nslit;
00769 double slit_min;
00770
00771 const char *tag = NULL;
00772 cpl_propertylist *header = NULL;
00773 double bin_space;
00774 double shift_arcsec=0, shift_pix=0, shift_bin_arcsec=0;
00775 double rectify_shift;
00776 #if 0
00777
00778 cpl_frame * result0 = NULL;
00779 char * res0_name = NULL ;
00780 #endif
00781 xsh_msg( "===> xsh_rectify_and_shift" ) ;
00782
00783 XSH_ASSURE_NOT_NULL( orderlist_frame);
00784 XSH_ASSURE_NOT_NULL( rectify_par);
00785
00786 check( orderlist = xsh_order_list_load ( orderlist_frame, instrument));
00787
00788 tag = XSH_GET_TAG_FROM_ARM( XSH_ORDER2D, instrument);
00789 xsh_rec_slit_size( rectify_par, &slit_min, &nslit, XSH_MODE_SLIT);
00790 bin_space = rectify_par->rectif_bin_space;
00791
00792 if ( throw_shift == NULL) {
00793 if ( loc0_frame != NULL){
00794 XSH_ASSURE_NOT_NULL( loc_frame ) ;
00795 xsh_msg("Compute shift with localization");
00796 shift_arcsec = compute_shift_with_localization( loc0_frame, loc_frame);
00797 }
00798 else{
00799 xsh_msg("Fixed shift with localization to 0");
00800 shift_arcsec = 0;
00801 }
00802 }
00803 else {
00804 shift_arcsec = *throw_shift;
00805 xsh_msg("Use throw shift %f", shift_arcsec);
00806 }
00807
00808 shift_pix = xsh_round_double(shift_arcsec/bin_space);
00809 shift_bin_arcsec = shift_pix*bin_space;
00810 rectify_shift = shift_bin_arcsec-shift_arcsec;
00811
00812 xsh_msg(" Mesured Shift for rectify : %f", rectify_shift);
00813
00814 check( shift_rec = xsh_rectify_orders( sci_frame, orderlist,
00815 wavesol_frame, model_frame, instrument,
00816 rectify_par, spectralformat_frame,
00817 disp_tab_frame, res_name, tag,
00818 &shift_rec_ext, res_frame_tab,
00819 0, 100, slit_min, nslit, rectify_shift));
00820
00821 check( result = xsh_shift( shift_rec, instrument, res_name, shift_bin_arcsec,
00822 res_frame_ext));
00823
00824 cleanup:
00825 xsh_free_frame( &shift_rec);
00826 xsh_free_frame( &shift_rec_ext);
00827 xsh_order_list_free( &orderlist);
00828 xsh_free_propertylist( &header);
00829 return result;
00830 }
00831
00832
00833
00834
00835 cpl_frameset* xsh_rectify_ifu(cpl_frame *sci_frame,
00836 cpl_frame *orderlist_frame, cpl_frameset *wavesol_frameset,
00837 cpl_frame *model_frame, xsh_instrument *instrument,
00838 xsh_rectify_param *rectify_par, cpl_frame *spectralformat_frame,
00839 cpl_frame *slice_offset_frame, cpl_frame * slitmap_frame,
00840 cpl_frameset** rec_frameset_ext,
00841 cpl_frameset** rec_frameset_tab,
00842 const char* rec_prefix )
00843 {
00844 cpl_frameset *result = NULL;
00845 xsh_order_list *orderlist = NULL ;
00846
00847 XSH_ASSURE_NOT_NULL( orderlist_frame);
00848 check( orderlist = xsh_order_list_load ( orderlist_frame, instrument));
00849
00850
00851 XSH_REGDEBUG("TODO : ADD disp_tab frameset, res_frame_ext frameset");
00852
00853 check( result = xsh_rectify_orders_ifu( sci_frame, orderlist,
00854 wavesol_frameset, model_frame, instrument, rectify_par,
00855 spectralformat_frame, slice_offset_frame,
00856 slitmap_frame,rec_frameset_ext,rec_frameset_tab, 0, 100, rec_prefix));
00857
00858 cleanup:
00859 xsh_order_list_free( &orderlist);
00860 return result;
00861 }
00862
00863
00864
00896
00897 cpl_frame*
00898 xsh_rectify_orders( cpl_frame *sci_frame,
00899 xsh_order_list *orderlist,
00900 cpl_frame *wavesol_frame,
00901 cpl_frame *model_frame,
00902 xsh_instrument *instrument,
00903 xsh_rectify_param *rectify_par,
00904 cpl_frame *spectralformat_frame,
00905 cpl_frame *disp_tab_frame,
00906 const char *res_name,
00907 const char* tag,
00908 cpl_frame** res_frame_ext,
00909 cpl_frame** res_frame_tab,
00910 int min_index,
00911 int max_index,
00912 double slit_min,
00913 int nslit,
00914 double slit_shift)
00915 {
00916 xsh_rec_list * rec_list = NULL ;
00917 xsh_xs_3 config_model ;
00918
00919 int solution_type = 0;
00920 xsh_wavesol * wavesol = NULL ;
00921 cpl_frame * res_frame = NULL ;
00922 xsh_pre * pre_sci = NULL ;
00923 int i, nlambda, order ;
00924 float slit_max ;
00925 xsh_spectralformat_list *spec_list = NULL ;
00926 char tag_drl[256];
00927 char res_name_drl[256];;
00928 cpl_mask* qual_mask = NULL;
00929 xsh_dispersol_list* disp_list = NULL;
00930 int rec_min_index, rec_max_index;
00931 const char* solution_type_name[2] = { "POLY", "MODEL"};
00932 int found_line=true;
00933 double barycor=0;
00934 double helicor=0;
00935
00936 XSH_ASSURE_NOT_NULL( sci_frame);
00937 XSH_ASSURE_NOT_NULL( orderlist);
00938 XSH_ASSURE_NOT_NULL( spectralformat_frame);
00939 XSH_ASSURE_NOT_NULL( rectify_par);
00940 XSH_ASSURE_NOT_NULL( instrument);
00941 XSH_ASSURE_NOT_ILLEGAL( min_index <= max_index);
00942
00943 if (rectify_par->conserve_flux){
00944 XSH_ASSURE_NOT_NULL( disp_tab_frame);
00945 check( disp_list = xsh_dispersol_list_load( disp_tab_frame, instrument));
00946 }
00947
00948 check( pre_sci = xsh_pre_load( sci_frame, instrument));
00949 check( rec_list = xsh_rec_list_create( instrument));
00950
00951 check( xsh_baryvel(pre_sci->data_header, &barycor,&helicor));
00952 cpl_propertylist_append_double(pre_sci->data_header,XSH_QC_VRAD_BARYCOR,barycor);
00953 cpl_propertylist_set_comment(pre_sci->data_header,XSH_QC_VRAD_BARYCOR,
00954 XSH_QC_VRAD_BARYCOR_C);
00955 cpl_propertylist_append_double(pre_sci->data_header,XSH_QC_VRAD_HELICOR,helicor);
00956 cpl_propertylist_set_comment(pre_sci->data_header,XSH_QC_VRAD_HELICOR,
00957 XSH_QC_VRAD_HELICOR_C);
00958
00959 if ( model_frame != NULL) {
00960 solution_type = XSH_RECTIFY_TYPE_MODEL;
00961 check(xsh_model_temperature_update_frame(&model_frame,sci_frame,
00962 instrument,&found_line));
00963 check( xsh_model_config_load_best( model_frame, &config_model));
00964 }
00965 else if ( wavesol_frame != NULL ) {
00966 solution_type = XSH_RECTIFY_TYPE_POLY;
00967 check( wavesol = xsh_wavesol_load( wavesol_frame, instrument));
00968 }
00969 else {
00970 xsh_error_msg(
00971 "Undefined solution type (POLY or MODEL). See your input sof");
00972 }
00973
00974 xsh_msg("===== Solution type %s", solution_type_name[solution_type]);
00975
00976 check( spec_list = xsh_spectralformat_list_load( spectralformat_frame,
00977 instrument));
00978
00979
00980 xsh_msg_dbg_high( "Kernel: %s, Radius: %lf", rectify_par->rectif_kernel,
00981 rectify_par->rectif_radius);
00982 xsh_msg_dbg_high( "Slit Binning: %f, Lambda Binning: %f",
00983 rectify_par->rectif_bin_space,
00984 rectify_par->rectif_bin_lambda);
00985
00986
00987 adjust_lambdas( spec_list, rectify_par);
00988
00989
00990 rec_list->nslit = nslit;
00991 rec_list->slit_min = slit_min;
00992 slit_max = slit_min+rectify_par->rectif_bin_space*nslit;
00993 rec_list->slit_max = slit_max;
00994
00995 if (min_index >= 0){
00996 rec_min_index = min_index;
00997 }
00998 else{
00999 rec_min_index = 0;
01000 }
01001 if ( max_index < rec_list->size){
01002 rec_max_index = max_index;
01003 }
01004 else{
01005 rec_max_index = rec_list->size-1;
01006 }
01007
01008 for( i = rec_min_index; i <= rec_max_index; i++ ) {
01009 double lambda_min, lambda_max ;
01010 double n;
01011
01012 order = spec_list->list[i].absorder ;
01013 rec_list->list[i].nslit = nslit ;
01014 lambda_min = spec_list->list[i].lambda_min ;
01015 lambda_max = spec_list->list[i].lambda_max ;
01016
01017
01018 n = (lambda_max-lambda_min)/rectify_par->rectif_bin_lambda+1.0;
01019 nlambda = (int)xsh_round_double(n);
01020 rec_list->list[i].nlambda = nlambda ;
01021
01022
01023 check( xsh_rec_list_set_data_size( rec_list, i, order, nlambda, nslit));
01024
01025
01026
01027
01028
01029 xsh_msg_dbg_medium( "Order %d, Nslit: %d, Nlambda: %d", order, nslit, nlambda ) ;
01030 xsh_msg_dbg_medium( " Lambda (%f,%f) Slit(%f,%f)",
01031 lambda_min, lambda_max , slit_min, slit_max);
01032
01033 check( qual_mask = xsh_pre_get_bpmap( pre_sci));
01034 check( cpl_image_reject_from_mask( pre_sci->data, qual_mask));
01035
01036 check( fill_rectified( pre_sci, rec_list, i, wavesol,
01037 &config_model, instrument, disp_list,
01038 slit_min, slit_max, lambda_min, 0, 0, rectify_par,
01039 slit_shift));
01040
01041
01042 }
01043
01044 rec_list->slit_min = rec_list->list[0].slit[0];
01045 rec_list->slit_max = rec_list->list[0].slit[nslit-1];
01046
01047 xsh_msg_dbg_medium( "Saving Rectified Frame '%s'", res_name);
01048
01049 sprintf( tag_drl ,"%s_DRL", tag);
01050 sprintf( res_name_drl ,"DRL_%s", res_name);
01051
01052
01053 check( xsh_rec_list_update_header( rec_list, pre_sci, rectify_par, tag_drl));
01054
01055 check( res_frame = xsh_rec_list_save( rec_list, res_name_drl, tag_drl, CPL_TRUE));
01056
01057 if ( res_frame_ext != NULL){
01058
01059 check( *res_frame_ext = xsh_rec_list_save2(rec_list,res_name,tag));
01060 sprintf( tag_drl ,"%s_TAB", tag);
01061 sprintf( res_name_drl ,"TAB_%s", res_name);
01062 check( *res_frame_tab = xsh_rec_list_save_table(rec_list,res_name_drl,tag_drl,
01063 CPL_TRUE));
01064
01065 }
01066
01067 cleanup :
01068 xsh_dispersol_list_free( &disp_list);
01069 xsh_rec_list_free( &rec_list);
01070 xsh_wavesol_free( &wavesol);
01071 xsh_spectralformat_list_free( &spec_list);
01072 xsh_pre_free( &pre_sci);
01073 return res_frame;
01074 }
01075
01076
01077
01100
01101 cpl_frameset *
01102 xsh_rectify_orders_ifu(cpl_frame *sci_frame,
01103 xsh_order_list *orderlist,
01104 cpl_frameset *wavesol_frameset,
01105 cpl_frame *model_frame,
01106 xsh_instrument *instrument,
01107 xsh_rectify_param *rectify_par,
01108 cpl_frame *spectralformat_frame,
01109 cpl_frame *sliceoffset_frame,
01110 cpl_frame * slitmap_frame,
01111 cpl_frameset ** res_frameset_ext,
01112 cpl_frameset ** res_frameset_tab,
01113 int min_index,
01114 int max_index,
01115 const char* rec_prefix)
01116 {
01117 cpl_frameset *res_frameset = NULL ;
01118
01119 cpl_frame *wavesolup_frame = NULL;
01120 cpl_frame *wavesolcen_frame = NULL;
01121 cpl_frame *wavesoldown_frame = NULL;
01122 int slitlet=0;
01123 xsh_slice_offset* slice_offset = NULL;
01124 double sdown=0, sldown=0, slup=0, sup=0;
01125 double slitlet_down_l=0;
01126 double slitlet_cen_l=0, slitlet_cen_u=0;
01127 double slitlet_cen_u_bin=0;
01128 double slitlet_up_u=0;
01129 double up_delta=0, up_offset=0.0, down_offset=0.0;
01130 int nslit=0;
01131 XSH_ARM arm ;
01132
01133 xsh_msg( "Entering xsh_rectify_orders_ifu" ) ;
01134
01135 XSH_ASSURE_NOT_NULL( sci_frame);
01136 XSH_ASSURE_NOT_NULL( orderlist);
01137 XSH_ASSURE_NOT_NULL( rectify_par);
01138 XSH_ASSURE_NOT_NULL( instrument);
01139 XSH_ASSURE_NOT_NULL( spectralformat_frame);
01140
01141 arm = xsh_instrument_get_arm( instrument ) ;
01142
01143
01144 if ( sliceoffset_frame != NULL ) {
01145 check( slice_offset = xsh_slice_offset_load( sliceoffset_frame));
01146 xsh_msg( "Slice Offset Frame Loaded" ) ;
01147 up_offset = slice_offset->cen_up;
01148 down_offset = slice_offset->cen_down;
01149 }
01150 else {
01151 xsh_msg( "No Slice Offset Frame");
01152 }
01153
01154 if ( wavesol_frameset != NULL){
01155 check( wavesoldown_frame = cpl_frameset_get_frame( wavesol_frameset, 0));
01156 check( wavesolcen_frame = cpl_frameset_get_frame( wavesol_frameset, 1));
01157 check( wavesolup_frame = cpl_frameset_get_frame( wavesol_frameset, 2));
01158 }
01159
01160 check( res_frameset = cpl_frameset_new());
01161
01162 check( xsh_get_slit_edges( slitmap_frame, &sdown,
01163 &sldown, &slup, &sup, instrument));
01164
01165 slitlet_cen_l = sldown;
01166 slitlet_cen_u = slup;
01167 slitlet_down_l = sdown;
01168 slitlet_up_u = sup;
01169
01170 for ( slitlet = LOWER_IFU_SLITLET ; slitlet <= UPPER_IFU_SLITLET ;
01171 slitlet++ ) {
01172 cpl_frame *wavesol_frame = NULL;
01173 cpl_frame *res_frame = NULL;
01174 cpl_frame *resext_frame = NULL;
01175 cpl_frame *restab_frame = NULL;
01176 double slitlet_slit_min = 0.0;
01177 char tag[80];
01178 char res_name[80];
01179
01180 switch( slitlet ) {
01181 case LOWER_IFU_SLITLET:
01182
01183 nslit = ceil((slitlet_cen_l-down_offset-slitlet_down_l)/
01184 rectify_par->rectif_bin_space);
01185 slitlet_slit_min = slitlet_cen_l-down_offset-
01186 nslit*rectify_par->rectif_bin_space;
01187
01188 xsh_msg( "DOWN [%f %f,%f] in %d of %f",slitlet_slit_min, slitlet_down_l,
01189 slitlet_slit_min+nslit*rectify_par->rectif_bin_space,
01190 nslit, rectify_par->rectif_bin_space);
01191 wavesol_frame = wavesoldown_frame;
01192 sprintf(tag,"%s_%s",rec_prefix,
01193 XSH_GET_TAG_FROM_ARM(XSH_ORDER2D_DOWN_IFU,instrument));
01194 sprintf(res_name,"%s.fits",tag);
01195 break ;
01196
01197 case CENTER_IFU_SLITLET:
01198 slitlet_slit_min = slitlet_cen_l;
01199 nslit = ceil((slitlet_cen_u-slitlet_cen_l)/rectify_par->rectif_bin_space);
01200 slitlet_cen_u_bin = slitlet_slit_min+nslit*rectify_par->rectif_bin_space;
01201 up_delta = slitlet_cen_u_bin-slitlet_cen_u;
01202
01203 xsh_msg( "CEN [%f,%f %f] in %d of %f (delta %f)",slitlet_cen_l,
01204 slitlet_cen_u,
01205 slitlet_cen_u_bin, nslit,
01206 rectify_par->rectif_bin_space, up_delta);
01207
01208 wavesol_frame = wavesolcen_frame;
01209 sprintf(tag,"%s_%s",rec_prefix,
01210 XSH_GET_TAG_FROM_ARM(XSH_ORDER2D_CEN_IFU,instrument));
01211 sprintf(res_name,"%s.fits",tag);
01212 break ;
01213
01214 case UPPER_IFU_SLITLET:
01215 slitlet_slit_min = slitlet_cen_u_bin-2*up_delta-up_offset;
01216 nslit = ceil((slitlet_up_u-slitlet_slit_min)/
01217 rectify_par->rectif_bin_space);
01218 xsh_msg( "UP [%f %f,%f %f] in %d of %f",slitlet_slit_min, slitlet_cen_u,
01219 slitlet_up_u, slitlet_slit_min+nslit*rectify_par->rectif_bin_space,
01220 nslit, rectify_par->rectif_bin_space);
01221 wavesol_frame = wavesolup_frame;
01222
01223 sprintf(tag,"%s_%s",rec_prefix,
01224 XSH_GET_TAG_FROM_ARM(XSH_ORDER2D_UP_IFU,instrument));
01225 sprintf(res_name,"%s.fits",tag);
01226 break ;
01227 }
01228
01229 XSH_CMP_INT( nslit, >, 0, "Check size in slit",);
01230 check( res_frame = xsh_rectify_orders( sci_frame, orderlist,
01231 wavesol_frame, model_frame, instrument, rectify_par,
01232 spectralformat_frame, NULL, res_name, tag, &resext_frame, &restab_frame,
01233 min_index, max_index, slitlet_slit_min, nslit, 0));
01234
01235 check( cpl_frameset_insert( res_frameset, res_frame));
01236
01237 if(res_frameset_ext !=NULL && res_frameset_tab !=NULL) {
01238 check( cpl_frameset_insert(*res_frameset_ext, resext_frame));
01239 check( cpl_frameset_insert(*res_frameset_tab, restab_frame));
01240 }
01241 }
01242
01243 cleanup:
01244 xsh_slice_offset_free( &slice_offset);
01245
01246 return res_frameset ;
01247 }
01248
01249
01250
01251
01259
01260 static double
01261 compute_shift_with_localization( cpl_frame *loc_frame,
01262 cpl_frame *loc0_frame)
01263 {
01264 double shift_a=0, shift_b=0, shift;
01265 xsh_localization *loc = NULL, *loc0 = NULL;
01266
01267 XSH_ASSURE_NOT_NULL( loc_frame);
01268 XSH_ASSURE_NOT_NULL( loc0_frame);
01269
01270 check( loc = xsh_localization_load( loc_frame));
01271 check( loc0 = xsh_localization_load( loc0_frame));
01272
01273
01274 check( shift_a = cpl_polynomial_eval_1d( loc0->cenpoly, 0., NULL));
01275 check( shift_b = cpl_polynomial_eval_1d( loc->cenpoly, 0., NULL));
01276
01277 xsh_msg_dbg_medium("Shift A %f B %f", shift_a, shift_b)
01278 shift = shift_b-shift_a;
01279
01280 xsh_msg( "Shift (localization) = %lf", shift);
01281
01282 cleanup:
01283 xsh_localization_free( &loc);
01284 xsh_localization_free( &loc0);
01285 return shift;
01286 }
01287
01288 static cpl_frame *
01289 shift_with_localization( cpl_frame * rec_frame,
01290 cpl_frame * loc_frame,
01291 cpl_frame * loc0_frame,
01292 xsh_instrument * instrument,
01293 const char * fname,
01294 cpl_frame** res_frame_ext )
01295 {
01296 cpl_frame * result = NULL ;
01298 xsh_rec_list * shifted_rec_list = NULL ;
01299 xsh_rec_list * rec_list = NULL;
01300 xsh_localization *loc_list = NULL;
01301 xsh_localization *loc0_list = NULL;
01302 float step_slit ;
01303 int nb_orders ;
01304 int order ;
01305 int absorder, nlambda, nslit ;
01306 float * flux1 = NULL ;
01307 float * errs1 = NULL ;
01308 int * qual1 = NULL ;
01309 float * shifted_flux1 = NULL ;
01310 float * shifted_errs1 = NULL ;
01311 int * shifted_qual1 = NULL ;
01312 float * slit = NULL ;
01313 double * lambda = NULL ;
01314 float * shifted_slit = NULL ;
01315 double * shifted_lambda = NULL ;
01316 const char* tag=NULL;
01317 const char* tag_drl=NULL;
01318 const char* fname_drl=NULL;
01319
01320 XSH_ASSURE_NOT_NULL( rec_frame ) ;
01321 XSH_ASSURE_NOT_NULL( loc_frame ) ;
01322 XSH_ASSURE_NOT_NULL( loc0_frame ) ;
01323 XSH_ASSURE_NOT_NULL( instrument ) ;
01324
01325 xsh_msg_dbg_low( "Entering shift_with_localization" ) ;
01326
01327
01328 check( rec_list = xsh_rec_list_load( rec_frame, instrument));
01329 check( loc_list = xsh_localization_load( loc_frame));
01330 check( loc0_list = xsh_localization_load( loc0_frame));
01331
01332 check( shifted_rec_list = xsh_rec_list_duplicate( rec_list, instrument ) ) ;
01333 xsh_msg( "Nb of orders in new rec list: %d", shifted_rec_list->size ) ;
01334
01335 check( nb_orders = rec_list->size ) ;
01336
01337
01338 for( order = 0 ; order < nb_orders ; order++ ) {
01339 int ns, nl ;
01340 int nshift, max_size ;
01341
01342 check( absorder = xsh_rec_list_get_order( rec_list, order ) ) ;
01343 check( nslit = xsh_rec_list_get_nslit( rec_list, order ) ) ;
01344 check( nlambda = xsh_rec_list_get_nlambda( rec_list, order ) ) ;
01345 xsh_msg( " Absolute order: %d, Nslit: %d, Nlambda: %d", absorder,
01346 nslit, nlambda ) ;
01347 max_size = nslit*nlambda ;
01348
01349
01350 check( flux1 = xsh_rec_list_get_data1( rec_list, order ) ) ;
01351 check( qual1 = xsh_rec_list_get_qual1( rec_list, order ) ) ;
01352 check( errs1 = xsh_rec_list_get_errs1( rec_list, order ) ) ;
01353 check( slit = xsh_rec_list_get_slit( rec_list, order ) ) ;
01354 check( lambda = xsh_rec_list_get_lambda( rec_list, order ) ) ;
01355
01356 check( shifted_slit = xsh_rec_list_get_slit( shifted_rec_list,
01357 order ) ) ;
01358 check( shifted_lambda = xsh_rec_list_get_lambda( shifted_rec_list,
01359 order ) ) ;
01360 check( shifted_flux1 = xsh_rec_list_get_data1( shifted_rec_list,
01361 order ) ) ;
01362 check( shifted_qual1 = xsh_rec_list_get_qual1( shifted_rec_list,
01363 order ) ) ;
01364 check( shifted_errs1 = xsh_rec_list_get_errs1( shifted_rec_list,
01365 order ) ) ;
01366
01367 for( ns = 0 ; ns<nslit ; ns++ )
01368 *(shifted_slit+ns) = *(slit+ns) ;
01369 for( nl = 0 ; nl<nlambda ; nl++ )
01370 *(shifted_lambda+nl) = *(lambda+nl) ;
01371
01372
01373 step_slit = get_step_slit( slit, nslit ) ;
01374
01375
01376
01377 for( ns = 0 ; ns < nslit ; ns++ )
01378 for( nl = 0 ; nl < nlambda ; nl++ )
01379 *(shifted_qual1+nl+ns*nlambda) = QFLAG_OUT_OF_NOD ;
01380
01381 for( ns = 0 ; ns < nslit ; ns++ ) {
01382 int shifted_idx =0;
01383
01384 for( nl = 0 ; nl<nlambda ; nl++ ) {
01385 double ab_slit, ba_slit ;
01386
01387 ab_slit = cpl_polynomial_eval_1d( loc0_list->cenpoly,
01388 *(lambda+nl), NULL ) ;
01389 ba_slit = cpl_polynomial_eval_1d( loc_list->cenpoly,
01390 *(lambda+nl), NULL ) ;
01391 nshift = (float)(ab_slit-ba_slit)/step_slit ;
01392 xsh_msg_dbg_medium( " nl: %d, ns: %d, nshift: %d, ab: %lf, ba: %lf",
01393 nl, ns, nshift, ab_slit, ba_slit ) ;
01394
01395 shifted_idx = nl+(ns+nshift)*nlambda ;
01396
01397 if ( shifted_idx < 0 || shifted_idx > max_size ) {
01398 xsh_msg_dbg_high( " Out of Bound: nl=%d, ns=%d, shifted=%d, max=%d", nl, ns,
01399 shifted_idx, max_size ) ;
01400 break ;
01401 }
01402 *(shifted_flux1+nl+(ns+nshift)*nlambda) =
01403 *(flux1+nl+ns*nlambda) ;
01404 *(shifted_errs1+nl+(ns+nshift)*nlambda) =
01405 *(errs1+nl+ns*nlambda) ;
01406 *(shifted_qual1+nl+(ns+nshift)*nlambda) =
01407 *(qual1+nl+ns*nlambda) ;
01408 }
01409 if ( shifted_idx > max_size ) break ;
01410 }
01411 }
01412
01413
01414 tag = xsh_stringcat_any( cpl_frame_get_tag( rec_frame ), "", NULL );
01415 tag_drl = xsh_stringcat_any( cpl_frame_get_tag( rec_frame ), "_DRL", NULL ) ;
01416 fname_drl = xsh_stringcat_any( tag_drl, ".fits", NULL ) ;
01417 check(*res_frame_ext=xsh_rec_list_save2(shifted_rec_list,fname,tag)) ;
01418
01419
01420 check( result =xsh_rec_list_save( shifted_rec_list, fname_drl,
01421 tag_drl, CPL_TRUE));
01422
01423
01424 xsh_msg( " Shifted Frame SAVED [%s]", cpl_frame_get_tag( result ) ) ;
01425
01426 cleanup:
01427 xsh_localization_free( &loc_list ) ;
01428 xsh_localization_free( &loc0_list ) ;
01429 xsh_rec_list_free( &rec_list ) ;
01430 xsh_rec_list_free( &shifted_rec_list ) ;
01431
01432 return result ;
01433 }
01434
01435 static double
01436 compute_shift_with_kw( cpl_propertylist *header,
01437 xsh_rectify_param *rectify_par,
01438 double **ref_ra,
01439 double **ref_dec,
01440 int flag)
01441 {
01442 double ref_ra_cumoff, ref_dec_cumoff;
01443 double ra_cumoff, dec_cumoff;
01444 double ra_reloff, dec_reloff, ra_off, dec_off;
01445 double posang=0;
01446
01447 double shift_arcsec=0;
01448
01449
01450
01451 xsh_msg_dbg_high( "==> compute_shift_with_kw" ) ;
01452 XSH_ASSURE_NOT_NULL( header);
01453 XSH_ASSURE_NOT_NULL( rectify_par);
01454
01455 check( posang = xsh_pfits_get_posang( header));
01456 posang = posang/180.0* M_PI;
01457
01458 if ( *ref_ra != NULL){
01459 ref_ra_cumoff = **ref_ra;
01460 }
01461 else{
01462 check( ref_ra_cumoff = xsh_pfits_get_ra_cumoffset( header));
01463 XSH_MALLOC( *ref_ra, double, 1);
01464 **ref_ra = ref_ra_cumoff;
01465 }
01466 if ( *ref_dec != NULL){
01467 ref_dec_cumoff = **ref_dec;
01468 }
01469 else{
01470 check( ref_dec_cumoff = xsh_pfits_get_dec_cumoffset( header));
01471 XSH_MALLOC( *ref_dec, double, 1);
01472 **ref_dec = ref_dec_cumoff;
01473 }
01474
01475 if ( flag == 0){
01476 check( ra_cumoff = xsh_pfits_get_ra_cumoffset( header));
01477 check( dec_cumoff = xsh_pfits_get_dec_cumoffset( header));
01478 }
01479 else{
01480 check( ra_cumoff = xsh_pfits_get_b_ra_cumoffset( header));
01481 check( dec_cumoff = xsh_pfits_get_b_dec_cumoffset( header));
01482 }
01483
01484 check( ra_reloff = xsh_pfits_get_b_ra_reloffset( header));
01485 check( dec_reloff = xsh_pfits_get_b_dec_reloffset( header));
01486
01487
01488 xsh_msg( "POSANG %f (rad) REF CUM_(RA DEC) : %f %f ", posang, ref_ra_cumoff,
01489 ref_dec_cumoff);
01490 xsh_msg( "OBJ CUM_(RA DEC) : %f %f ", ra_cumoff, dec_cumoff);
01491 xsh_msg( "REL_(RA DEC) : %f %f", ra_reloff, dec_reloff);
01492
01493 ra_off = ra_cumoff-ref_ra_cumoff;
01494 dec_off = dec_cumoff-ref_dec_cumoff;
01495
01496 xsh_msg( "COMPUTE OFF_(RA DEC) : %f %f", ra_off, dec_off);
01497
01498 shift_arcsec = cos(-posang)*dec_off+sin(-posang)*ra_off;
01499
01500 xsh_msg( "COMPUTE shift in arcsec %f :", shift_arcsec);
01501
01502 cleanup:
01503 return shift_arcsec;
01504 }
01505
01506
01507
01522 cpl_frame*
01523 shift_with_kw( cpl_frame *rec_frame,
01524 xsh_instrument *instrument,
01525 xsh_rectify_param *rectify_par,
01526 const char *fname,
01527 cpl_frame** res_frame_ext,
01528 double **ref_ra,
01529 double **ref_dec,
01530 int flag)
01531 {
01532 cpl_frame *result = NULL ;
01533 int shift_pix;
01534 double bin_space, shift_arcsec;
01535 const char *filename = NULL;
01536 cpl_propertylist* header = NULL;
01537
01538
01539 XSH_ASSURE_NOT_NULL( rec_frame);
01540 XSH_ASSURE_NOT_NULL( instrument);
01541 XSH_ASSURE_NOT_NULL( fname);
01542 XSH_ASSURE_NOT_NULL( res_frame_ext);
01543 XSH_ASSURE_NOT_NULL( ref_ra);
01544 XSH_ASSURE_NOT_NULL( ref_dec);
01545
01546 check( filename = cpl_frame_get_filename( rec_frame));
01547 check( header = cpl_propertylist_load( filename, 0));
01548
01549 check( bin_space = xsh_pfits_get_rectify_bin_space( header));
01550
01551 check( shift_arcsec = compute_shift_with_kw( header,
01552 rectify_par, ref_ra, ref_dec, flag));
01553
01554
01555 shift_pix = xsh_round_double(shift_arcsec/bin_space);
01556
01557 shift_arcsec = shift_pix*bin_space;
01558
01559 xsh_msg( "SHIFT A-->B : %f in arcsec", shift_arcsec);
01560
01561 check( result = xsh_shift( rec_frame, instrument, fname, shift_arcsec,
01562 res_frame_ext));
01563
01564 cleanup:
01565 if ( cpl_error_get_code() !=CPL_ERROR_NONE){
01566 xsh_free_frame( &result);
01567 }
01568 xsh_free_propertylist( &header);
01569 return result ;
01570 }
01571
01572
01573
01574
01575 static cpl_frame*
01576 xsh_shift( cpl_frame *rec_frame,
01577 xsh_instrument *instrument,
01578 const char *fname,
01579 double slit_shift,
01580 cpl_frame** res_frame_ext)
01581 {
01582 xsh_rec_list *rec_list = NULL ;
01583 cpl_frame *result = NULL ;
01584 int nb_orders, order = 0 ;
01585 float *slit = NULL ;
01586
01587 char* fname_drl=NULL;
01588 char* tag_drl=NULL;
01589 char* tag=NULL;
01590 int nslit=0;
01591
01592 XSH_ASSURE_NOT_NULL( rec_frame);
01593 XSH_ASSURE_NOT_NULL( instrument);
01594 XSH_ASSURE_NOT_NULL( fname);
01595 XSH_ASSURE_NOT_NULL( res_frame_ext);
01596
01597 check( rec_list = xsh_rec_list_load( rec_frame, instrument));
01598
01599 nb_orders = rec_list->size ;
01600 check( nslit = xsh_rec_list_get_nslit( rec_list, 0));
01601
01602
01603 for( order = 0 ; order < nb_orders ; order++ ) {
01604 int ns;
01605
01606 check( slit = xsh_rec_list_get_slit( rec_list, order));
01607 for( ns = 0 ; ns < nslit ; ns++ ) {
01608 slit[ns]+=slit_shift;
01609 }
01610 }
01611 rec_list->slit_min = slit[0];
01612 rec_list->slit_max = slit[nslit-1];
01613
01614 check( xsh_pfits_set_rectify_space_min( rec_list->header,
01615 rec_list->slit_min));
01616 check( xsh_pfits_set_rectify_space_max( rec_list->header,
01617 rec_list->slit_max));
01618
01619
01620 tag= xsh_stringcat_any( cpl_frame_get_tag( rec_frame ), "", NULL ) ;
01621 tag_drl = xsh_stringcat_any( cpl_frame_get_tag( rec_frame ), "_DRL", NULL ) ;
01622 fname_drl = xsh_stringcat_any( "DRL_", fname, NULL);
01623
01624 check( *res_frame_ext=xsh_rec_list_save2( rec_list, fname,tag)) ;
01625 check( result = xsh_rec_list_save( rec_list, fname_drl,
01626 tag_drl, CPL_TRUE));
01627
01628 cleanup:
01629 if ( cpl_error_get_code() !=CPL_ERROR_NONE){
01630 xsh_free_frame( &result);
01631 }
01632 XSH_FREE( fname_drl);
01633 XSH_FREE( tag_drl);
01634 XSH_FREE( tag);
01635 xsh_rec_list_free( &rec_list);
01636 return result ;
01637 }
01638
01655 cpl_frame * xsh_shift_rectified( cpl_frame * rec_frame,
01656 cpl_frame * loc_frame,
01657 cpl_frame * loc0_frame,
01658 const char * file_name,
01659 xsh_combine_nod_param * combine_nod_param,
01660 xsh_rectify_param * rectif_par,
01661 xsh_instrument * instrument,
01662 cpl_frame** res_frame_ext )
01663 {
01664 cpl_frame * result = NULL ;
01665 double *ra = NULL, *dec = NULL;
01666
01667 xsh_msg( "===> xsh_shift_rectified" ) ;
01668
01669 XSH_ASSURE_NOT_NULL( combine_nod_param ) ;
01670 XSH_ASSURE_NOT_NULL( rec_frame ) ;
01671
01672 check( result = shift_with_kw( rec_frame, instrument,
01673 rectif_par, file_name, res_frame_ext, &ra, &dec, 1));
01674
01675 cleanup:
01676 return result ;
01677 }
01678
01679