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
00027 #ifdef HAVE_CONFIG_H
00028 #include <config.h>
00029 #endif
00030
00031
00036
00037
00038
00042
00043
00044
00045
00046 #include <math.h>
00047
00048 #include <xsh_data_dispersol.h>
00049 #include <xsh_utils.h>
00050 #include <xsh_error.h>
00051 #include <xsh_msg.h>
00052 #include <xsh_pfits.h>
00053 #include <xsh_dfs.h>
00054 #include <cpl.h>
00055 #include <xsh_utils_table.h>
00056 #include <xsh_data_spectralformat.h>
00057 #include <xsh_data_order.h>
00058
00059
00060
00061
00062
00063
00064
00076
00077 xsh_dispersol_list* xsh_dispersol_list_new( int size, int degx, int degy,
00078 xsh_instrument *instrument)
00079 {
00080 xsh_dispersol_list *result = NULL;
00081
00082
00083 XSH_ASSURE_NOT_ILLEGAL( size > 0);
00084 XSH_ASSURE_NOT_NULL( instrument);
00085
00086 XSH_CALLOC( result, xsh_dispersol_list, 1);
00087 result->size = size;
00088 result->degx = degx;
00089 result->degy = degy;
00090 check( result->binx = xsh_instrument_get_binx( instrument));
00091 check( result->biny = xsh_instrument_get_biny( instrument));
00092 XSH_CALLOC( result->list, xsh_dispersol, result->size);
00093 XSH_NEW_PROPERTYLIST( result->header);
00094
00095 cleanup:
00096 if ( cpl_error_get_code() != CPL_ERROR_NONE) {
00097 xsh_dispersol_list_free( &result);
00098 }
00099 return result;
00100 }
00101
00102
00103
00104
00113
00114 xsh_dispersol_list* xsh_dispersol_list_load( cpl_frame *frame,
00115 xsh_instrument *instrument)
00116 {
00117 xsh_dispersol_list *result = NULL;
00118 const char* tablename = NULL;
00119 cpl_table* table = NULL;
00120 int rows, cols ;
00121 int degx, degy;
00122 char coefname[20];
00123 int i;
00124
00125
00126 XSH_ASSURE_NOT_ILLEGAL( frame);
00127
00128
00129 check( tablename = cpl_frame_get_filename(frame));
00130
00131 XSH_TABLE_LOAD( table, tablename);
00132 check( rows = cpl_table_get_nrow( table));
00133 check( cols = cpl_table_get_ncol( table));
00134
00135
00136 check( xsh_get_table_value( table, XSH_DISPERSOL_TABLE_COLNAME_DEGX,
00137 CPL_TYPE_INT, 0, °x));
00138
00139 check( xsh_get_table_value( table, XSH_DISPERSOL_TABLE_COLNAME_DEGY,
00140 CPL_TYPE_INT, 0, °y));
00141
00142 check( result = xsh_dispersol_list_new( rows/2, degx, degy, instrument));
00143
00144 for(i=0; i< rows/2; i++){
00145 cpl_polynomial *lambda_poly = NULL;
00146 cpl_polynomial *slit_poly = NULL;
00147 int pows[2];
00148 int k,l, absorder = 0;
00149 int j = 2*i;
00150
00151 check( xsh_get_table_value( table, XSH_DISPERSOL_TABLE_COLNAME_ORDER,
00152 CPL_TYPE_INT, j, &absorder));
00153 check( lambda_poly = cpl_polynomial_new( 2));
00154 check( slit_poly = cpl_polynomial_new( 2));
00155 for( k=0; k<= degx; k++){
00156 for( l=0; l<= degy; l++){
00157 double coef_lambda = 0.0, coef_slit = 0.0;
00158 sprintf(coefname,"C%d%d",k,l);
00159 check( xsh_get_table_value( table, coefname,CPL_TYPE_DOUBLE, j,
00160 &coef_lambda));
00161 check( xsh_get_table_value( table, coefname,CPL_TYPE_DOUBLE, j+1,
00162 &coef_slit));
00163 pows[0] =k;
00164 pows[1] = l;
00165 check( cpl_polynomial_set_coeff( lambda_poly, pows, coef_lambda));
00166 check( cpl_polynomial_set_coeff( slit_poly, pows, coef_slit));
00167 }
00168 }
00169 check( xsh_dispersol_list_add( result, i, absorder, lambda_poly, slit_poly));
00170 }
00171
00172 cleanup:
00173 xsh_free_table( &table);
00174 if ( cpl_error_get_code() != CPL_ERROR_NONE) {
00175 xsh_dispersol_list_free( &result);
00176 }
00177 return result;
00178 }
00179
00180
00181
00196
00197 void xsh_dispersol_list_add( xsh_dispersol_list *list, int idx,
00198 int absorder, cpl_polynomial *lambda_poly,
00199 cpl_polynomial *slit_poly)
00200 {
00201
00202 XSH_ASSURE_NOT_NULL( list);
00203 XSH_ASSURE_NOT_NULL( lambda_poly);
00204 XSH_ASSURE_NOT_NULL( slit_poly);
00205 XSH_ASSURE_NOT_ILLEGAL( idx >=0 && idx < list->size);
00206
00207 list->list[idx].absorder = absorder;
00208 list->list[idx].lambda_poly = lambda_poly;
00209 list->list[idx].slit_poly = slit_poly;
00210
00211 cleanup:
00212 return;
00213 }
00214
00215
00216
00223
00224 void xsh_dispersol_list_free( xsh_dispersol_list **list)
00225 {
00226 int i = 0;
00227
00228 if ( list && *list){
00229
00230 for( i = 0; i < (*list)->size; i++){
00231 xsh_free_polynomial( &(*list)->list[i].lambda_poly);
00232 xsh_free_polynomial( &(*list)->list[i].slit_poly);
00233 }
00234 if ((*list)->list){
00235 cpl_free( (*list)->list);
00236 }
00237 xsh_free_propertylist( &((*list)->header));
00238 cpl_free( *list);
00239 *list = NULL;
00240 }
00241 }
00242
00243
00244
00245
00260
00261 cpl_frame* xsh_dispersol_list_to_wavemap( xsh_dispersol_list *list,
00262 cpl_frame *order_frame,
00263 xsh_pre *pre,
00264 xsh_instrument *instr,
00265 const char* tag)
00266
00267 {
00268 cpl_frame *result = NULL;
00269 cpl_image *image = NULL;
00270 xsh_order_list *order_list = NULL;
00271 int nx, ny;
00272 cpl_vector* pos = NULL;
00273 double *data = NULL;
00274 int i, y;
00275 char filename[80];
00276 cpl_propertylist *wavemap_header = NULL;
00277
00278
00279 XSH_ASSURE_NOT_NULL( list);
00280 XSH_ASSURE_NOT_NULL( order_frame);
00281 XSH_ASSURE_NOT_NULL( pre);
00282 XSH_ASSURE_NOT_NULL( instr);
00283
00284
00285 check( order_list = xsh_order_list_load( order_frame, instr));
00286 nx = pre->nx;
00287 ny = pre->ny;
00288 pos = cpl_vector_new(2);
00289
00290
00291 check( image = cpl_image_new( nx, ny, CPL_TYPE_DOUBLE));
00292 check( data = cpl_image_get_data_double( image));
00293 check( wavemap_header = cpl_propertylist_new());
00294
00295
00296 for( i=0; i < list->size; i++) {
00297 int starty, endy;
00298 double lambda_min, lambda_max;
00299 double lambda_starty_lo, lambda_starty_up, lambda_endy_lo, lambda_endy_up;
00300 double dxmin, dxmax ;
00301 int xmin, xmax;
00302 int absorder;
00303
00304
00305 absorder = order_list->list[i].absorder;
00306 check( starty = xsh_order_list_get_starty( order_list, i));
00307
00308 check( endy = xsh_order_list_get_endy( order_list, i));
00309
00310
00311 for ( y=starty ; y<=endy && y<ny; y++){
00312 int x;
00313
00314
00315 check( dxmin = xsh_order_list_eval( order_list,
00316 order_list->list[i].edglopoly,
00317 (double)y ) ) ;
00318 check( dxmax = xsh_order_list_eval( order_list,
00319 order_list->list[i].edguppoly,
00320 (double)y ) ) ;
00321 xmin = ceil( dxmin);
00322 xmax = floor( dxmax);
00323 for ( x=xmin ; x<=xmax && x<nx; x++){
00324 double lambda;
00325
00326 cpl_vector_set(pos, 0, (double)x);
00327 cpl_vector_set(pos, 1, (double)y);
00328
00329
00330 check( lambda = xsh_dispersol_list_eval(
00331 list, list->list[i].lambda_poly, pos));
00332
00333 data[x-1+(y-1)*nx] = (float)lambda;
00334
00335 }
00336
00337 }
00338
00339
00340 check( dxmin = xsh_order_list_eval( order_list,
00341 order_list->list[i].edglopoly,
00342 (double)starty));
00343 check( dxmax = xsh_order_list_eval( order_list,
00344 order_list->list[i].edguppoly,
00345 (double)starty));
00346 xmin = ceil( dxmin);
00347 xmax = floor( dxmax);
00348
00349 cpl_vector_set(pos, 0, (double)xmin);
00350 cpl_vector_set(pos, 1, (double)starty);
00351 check( lambda_starty_lo = xsh_dispersol_list_eval(
00352 list, list->list[i].lambda_poly, pos));
00353
00354 cpl_vector_set(pos, 0, (double)xmax);
00355 check( lambda_starty_up = xsh_dispersol_list_eval(
00356 list, list->list[i].lambda_poly, pos));
00357
00358 check( dxmin = xsh_order_list_eval( order_list,
00359 order_list->list[i].edglopoly,
00360 (double)endy));
00361 check( dxmax = xsh_order_list_eval( order_list,
00362 order_list->list[i].edguppoly,
00363 (double)endy));
00364 xmin = ceil( dxmin);
00365 xmax = floor( dxmax);
00366
00367 cpl_vector_set(pos, 0, (double)xmin);
00368 cpl_vector_set(pos, 1, (double)endy);
00369 check( lambda_endy_lo = xsh_dispersol_list_eval(
00370 list, list->list[i].lambda_poly, pos));
00371
00372 cpl_vector_set(pos, 0, (double)xmax);
00373 check( lambda_endy_up = xsh_dispersol_list_eval(
00374 list, list->list[i].lambda_poly, pos));
00375
00376 if ( lambda_starty_lo < lambda_endy_lo
00377 && lambda_starty_up < lambda_endy_up){
00378 if ( lambda_starty_lo > lambda_starty_up){
00379 lambda_min = lambda_starty_lo;
00380 }
00381 else{
00382 lambda_min = lambda_starty_up;
00383 }
00384 if ( lambda_endy_lo > lambda_endy_up){
00385 lambda_max = lambda_endy_up;
00386 }
00387 else{
00388 lambda_max = lambda_endy_lo;
00389 }
00390 }
00391 else if ( lambda_starty_lo > lambda_endy_lo
00392 && lambda_starty_up > lambda_endy_up){
00393 if ( lambda_starty_lo > lambda_starty_up){
00394 lambda_max = lambda_starty_up;
00395 }
00396 else{
00397 lambda_max = lambda_starty_lo;
00398 }
00399 if ( lambda_endy_lo > lambda_endy_up){
00400 lambda_min = lambda_endy_lo;
00401 }
00402 else{
00403 lambda_min = lambda_endy_up;
00404 }
00405 }
00406 else{
00407 xsh_msg_warning(
00408 "wavelength variation differs between upper(%f %f) and lower edges( %f %f)",
00409 lambda_starty_up, lambda_endy_up, lambda_endy_up, lambda_endy_lo);
00410 lambda_min = 0.0;
00411 lambda_max = 0.0;
00412 }
00413
00414
00415 check( xsh_pfits_set_wavemap_order_lambda_min(
00416 wavemap_header, absorder, lambda_min));
00417 check( xsh_pfits_set_wavemap_order_lambda_max(
00418 wavemap_header, absorder, lambda_max));
00419 }
00420
00421 sprintf(filename,"%s.fits",tag);
00422 check( xsh_pfits_set_pcatg( wavemap_header, tag));
00423
00424 check( cpl_image_save( image, filename, CPL_BPP_IEEE_FLOAT,
00425 wavemap_header, CPL_IO_DEFAULT));
00426
00427 check( result = xsh_frame_product(filename, tag,
00428 CPL_FRAME_TYPE_IMAGE, CPL_FRAME_GROUP_PRODUCT,
00429 CPL_FRAME_LEVEL_TEMPORARY));
00430
00431 cleanup:
00432 if (cpl_error_get_code() != CPL_ERROR_NONE){
00433 xsh_free_frame( &result);
00434 }
00435 xsh_free_image ( &image);
00436 xsh_free_propertylist( &wavemap_header);
00437 xsh_order_list_free( &order_list);
00438 xsh_free_vector( &pos);
00439
00440
00441 return result;
00442 }
00443
00444
00445
00446
00461
00462 cpl_frame* xsh_dispersol_list_to_slitmap( xsh_dispersol_list *list,
00463 cpl_frame *order_frame,
00464 xsh_pre *pre,
00465 xsh_instrument *instr,
00466 const char* tag)
00467 {
00468 cpl_frame *result = NULL;
00469 cpl_image *image = NULL;
00470 xsh_order_list *order_list = NULL;
00471 int nx, ny;
00472 cpl_vector* pos = NULL;
00473 double *data = NULL;
00474 int i, y;
00475 char filename[80];
00476 cpl_vector *med_low_vect = NULL, *med_up_vect = NULL, *med_cen_vect = NULL;
00477 cpl_vector *med_sliclo_vect = NULL, *med_slicup_vect = NULL;
00478 int nb_orders;
00479 double slit_up, slit_low, slit_cen;
00480 cpl_propertylist *slitmap_header = NULL;
00481
00482
00483 XSH_ASSURE_NOT_NULL( list);
00484 XSH_ASSURE_NOT_NULL( order_frame);
00485 XSH_ASSURE_NOT_NULL( pre);
00486 XSH_ASSURE_NOT_NULL( instr);
00487
00488
00489 check( order_list = xsh_order_list_load( order_frame, instr));
00490 nx = pre->nx;
00491 ny = pre->ny;
00492
00493
00494 XSH_ASSURE_NOT_ILLEGAL( order_list->bin_x == pre->binx);
00495 XSH_ASSURE_NOT_ILLEGAL( order_list->bin_x == list->binx);
00496
00497 pos = cpl_vector_new(2);
00498
00499 check( image = cpl_image_new( nx, ny, CPL_TYPE_DOUBLE));
00500 check( data = cpl_image_get_data_double( image));
00501 check( slitmap_header = cpl_propertylist_new());
00502
00503 nb_orders = list->size;
00504
00505 med_low_vect = cpl_vector_new( nb_orders);
00506 med_cen_vect = cpl_vector_new( nb_orders);
00507 med_up_vect = cpl_vector_new( nb_orders);
00508 if ( xsh_instrument_get_mode( instr) == XSH_MODE_IFU){
00509 med_sliclo_vect = cpl_vector_new( nb_orders);
00510 med_slicup_vect = cpl_vector_new( nb_orders);
00511 }
00512
00513
00514 for( i=0; i < nb_orders; i++) {
00515 int starty, endy, vect_size;
00516 int absorder;
00517 cpl_vector *low_vect = NULL, *up_vect = NULL, *cen_vect = NULL;
00518 cpl_vector *sliclo_vect = NULL, *slicup_vect = NULL;
00519
00520 check( starty = xsh_order_list_get_starty( order_list, i));
00521 check( endy = xsh_order_list_get_endy( order_list, i));
00522 absorder = order_list->list[i].absorder;
00523
00524 vect_size = endy-starty+1;
00525
00526 low_vect = cpl_vector_new( vect_size);
00527 cen_vect = cpl_vector_new( vect_size);
00528 up_vect = cpl_vector_new( vect_size);
00529
00530 if ( xsh_instrument_get_mode( instr) == XSH_MODE_IFU){
00531 sliclo_vect = cpl_vector_new( vect_size);
00532 slicup_vect = cpl_vector_new( vect_size);
00533 }
00534
00535 for ( y=starty ; y<=endy && y<ny; y++){
00536 double dxmin, dxmax, xcen;
00537 int xmin, xmax, x;
00538 double slit;
00539 double ypos;
00540
00541
00542 check( dxmin = xsh_order_list_eval( order_list,
00543 order_list->list[i].edglopoly,
00544 (double)y ) ) ;
00545 check( dxmax = xsh_order_list_eval( order_list,
00546 order_list->list[i].edguppoly,
00547 (double)y ) ) ;
00548 check( xcen = xsh_order_list_eval( order_list,
00549 order_list->list[i].cenpoly,
00550 (double)y ) ) ;
00551
00552 xmin = ceil( dxmin);
00553 xmax = floor( dxmax);
00554
00555 ypos = (double)y;
00556 cpl_vector_set(pos, 1, ypos);
00557
00558 for ( x=xmin ; x<=xmax && x<nx; x++){
00559 double xpos;
00560
00561 xpos = (double)x;
00562 cpl_vector_set(pos, 0, xpos);
00563 cpl_vector_set(pos, 1, ypos);
00564
00565 check( slit = xsh_dispersol_list_eval( list, list->list[i].slit_poly, pos));
00566
00567
00568 data[x-1+(y-1)*nx] = (float)slit;
00569 }
00570
00571 cpl_vector_set(pos, 0, xmin);
00572 cpl_vector_set(pos, 1, ypos);
00573 check( slit = xsh_dispersol_list_eval( list, list->list[i].slit_poly, pos));
00574 cpl_vector_set( low_vect, y-starty, slit);
00575
00576 cpl_vector_set(pos, 0, xmax);
00577 cpl_vector_set(pos, 1, ypos);
00578 check( slit = xsh_dispersol_list_eval( list, list->list[i].slit_poly, pos));
00579 cpl_vector_set( up_vect, y-starty, slit);
00580
00581 cpl_vector_set(pos, 0, xcen);
00582 cpl_vector_set(pos, 1, ypos);
00583 check( slit = xsh_dispersol_list_eval( list, list->list[i].slit_poly, pos));
00584 cpl_vector_set( cen_vect, y-starty, slit);
00585
00586 if ( xsh_instrument_get_mode( instr) == XSH_MODE_IFU){
00587 xmin = xsh_order_list_eval( order_list,
00588 order_list->list[i].sliclopoly,
00589 (double)y );
00590 xmax = xsh_order_list_eval( order_list,
00591 order_list->list[i].slicuppoly,
00592 (double)y );
00593 cpl_vector_set(pos, 0, xmin);
00594 cpl_vector_set(pos, 1, ypos);
00595 check( slit = xsh_dispersol_list_eval( list, list->list[i].slit_poly, pos));
00596 cpl_vector_set( sliclo_vect, y-starty, slit);
00597
00598 cpl_vector_set(pos, 0, xmax);
00599 cpl_vector_set(pos, 1, ypos);
00600 check( slit = xsh_dispersol_list_eval( list, list->list[i].slit_poly, pos));
00601 cpl_vector_set( slicup_vect, y-starty, slit);
00602 }
00603
00604 }
00605
00606 check( slit_up = cpl_vector_get_median( up_vect));
00607 check( slit_low = cpl_vector_get_median( low_vect));
00608 check( slit_cen = cpl_vector_get_median( cen_vect));
00609
00610
00611 check( xsh_pfits_set_slitmap_order_cen( slitmap_header, absorder, slit_cen));
00612 check( cpl_vector_set( med_cen_vect, i, slit_cen));
00613
00614 if ( slit_up > slit_low){
00615 check( xsh_pfits_set_slitmap_order_edgup( slitmap_header, absorder, slit_up));
00616 check( xsh_pfits_set_slitmap_order_edglo( slitmap_header, absorder, slit_low));
00617 check( cpl_vector_set( med_low_vect, i, slit_low));
00618 check( cpl_vector_set( med_up_vect, i, slit_up));
00619 }
00620 else{
00621 check( xsh_pfits_set_slitmap_order_edgup( slitmap_header, absorder, slit_low));
00622 check( xsh_pfits_set_slitmap_order_edglo( slitmap_header, absorder, slit_up));
00623 check( cpl_vector_set( med_low_vect, i, slit_up));
00624 check( cpl_vector_set( med_up_vect, i, slit_low));
00625 }
00626
00627 if ( xsh_instrument_get_mode( instr) == XSH_MODE_IFU){
00628 check( slit_up = cpl_vector_get_median( slicup_vect));
00629 check( slit_low = cpl_vector_get_median( sliclo_vect));
00630 if ( slit_up > slit_low){
00631 check( xsh_pfits_set_slitmap_order_slicup( slitmap_header, absorder, slit_up));
00632 check( xsh_pfits_set_slitmap_order_sliclo( slitmap_header, absorder, slit_low));
00633 check( cpl_vector_set( med_sliclo_vect, i, slit_low));
00634 check( cpl_vector_set( med_slicup_vect, i, slit_up));
00635 }
00636 else{
00637 check( xsh_pfits_set_slitmap_order_slicup( slitmap_header, absorder, slit_low));
00638 check( xsh_pfits_set_slitmap_order_sliclo( slitmap_header, absorder, slit_up));
00639 check( cpl_vector_set( med_sliclo_vect, i, slit_up));
00640 check( cpl_vector_set( med_slicup_vect, i, slit_low));
00641 }
00642 xsh_free_vector( &slicup_vect);
00643 xsh_free_vector( &sliclo_vect);
00644 }
00645 xsh_free_vector( &up_vect);
00646 xsh_free_vector( &low_vect);
00647 xsh_free_vector( &cen_vect);
00648 }
00649
00650 check( slit_cen = cpl_vector_get_median( med_cen_vect));
00651 check( slit_up = cpl_vector_get_median( med_up_vect));
00652 check( slit_low = cpl_vector_get_median( med_low_vect));
00653
00654 check( xsh_pfits_set_slitmap_median_cen( slitmap_header, slit_cen));
00655 check( xsh_pfits_set_slitmap_median_edgup( slitmap_header, slit_up));
00656 check( xsh_pfits_set_slitmap_median_edglo( slitmap_header, slit_low));
00657
00658 if ( xsh_instrument_get_mode( instr) == XSH_MODE_IFU){
00659 check( slit_up = cpl_vector_get_median( med_slicup_vect));
00660 check( slit_low = cpl_vector_get_median( med_sliclo_vect));
00661 check( xsh_pfits_set_slitmap_median_slicup( slitmap_header, slit_up));
00662 check( xsh_pfits_set_slitmap_median_sliclo( slitmap_header, slit_low));
00663 }
00664
00665 sprintf(filename,"%s.fits",tag);
00666 xsh_pfits_set_pcatg( slitmap_header, tag);
00667 check( cpl_image_save( image, filename, CPL_BPP_IEEE_FLOAT,
00668 slitmap_header, CPL_IO_DEFAULT));
00669 check( result = xsh_frame_product(filename,tag,
00670 CPL_FRAME_TYPE_IMAGE, CPL_FRAME_GROUP_PRODUCT,
00671 CPL_FRAME_LEVEL_TEMPORARY));
00672
00673 cleanup:
00674 if (cpl_error_get_code() != CPL_ERROR_NONE){
00675 xsh_free_frame( &result);
00676 }
00677
00678 xsh_free_image ( &image);
00679 xsh_free_propertylist( &slitmap_header);
00680 xsh_order_list_free( &order_list);
00681 xsh_free_vector( &pos);
00682 xsh_free_vector( &med_up_vect);
00683 xsh_free_vector( &med_low_vect);
00684 xsh_free_vector( &med_cen_vect);
00685 xsh_free_vector( &med_slicup_vect);
00686 xsh_free_vector( &med_sliclo_vect);
00687
00688 return result;
00689 }
00690
00691
00692
00705
00706 double
00707 xsh_dispersol_list_eval( xsh_dispersol_list *list,
00708 cpl_polynomial *poly,
00709 cpl_vector *pos)
00710 {
00711 double result=0;
00712 double y_bin, y_no_bin;
00713 double x_bin, x_no_bin;
00714
00715 XSH_ASSURE_NOT_NULL( list);
00716 XSH_ASSURE_NOT_NULL( pos);
00717 XSH_ASSURE_NOT_NULL( poly);
00718
00719 check( x_bin = cpl_vector_get(pos, 0));
00720 check( y_bin = cpl_vector_get(pos, 1));
00721
00722 x_no_bin = convert_bin_to_data( x_bin, list->binx);
00723 y_no_bin = convert_bin_to_data( y_bin, list->biny);
00724
00725 check( cpl_vector_set(pos, 0, x_no_bin));
00726 check( cpl_vector_set(pos, 1, y_no_bin));
00727
00728 check( result = cpl_polynomial_eval( poly, pos));
00729
00730 cleanup:
00731 return result;
00732 }
00733
00734
00735
00743
00744 cpl_frame*
00745 xsh_dispersol_list_save( xsh_dispersol_list *list, xsh_instrument* instrument)
00746 {
00747 cpl_frame *result = NULL;
00748 cpl_table *table = NULL;
00749 char coefname[20];
00750 int i,j,k;
00751 int nbcoefs =0;
00752 int pows[2];
00753 const char* tag=NULL;
00754 char filename[80];
00755
00756
00757 XSH_ASSURE_NOT_NULL( list);
00758
00759 nbcoefs = (list->degx+1)*(list->degy+1);
00760
00761 check( table = cpl_table_new( XSH_DISPERSOL_TABLE_NBCOL+nbcoefs));
00762 check(cpl_table_set_size(table, list->size*2));
00763
00764 check(
00765 cpl_table_new_column( table, XSH_DISPERSOL_TABLE_COLNAME_AXIS,
00766 CPL_TYPE_STRING));
00767 check(
00768 cpl_table_new_column( table, XSH_DISPERSOL_TABLE_COLNAME_ORDER,
00769 CPL_TYPE_INT));
00770 check(
00771 cpl_table_new_column( table, XSH_DISPERSOL_TABLE_COLNAME_DEGX,
00772 CPL_TYPE_INT));
00773 check(
00774 cpl_table_new_column( table, XSH_DISPERSOL_TABLE_COLNAME_DEGY,
00775 CPL_TYPE_INT));
00776
00777 for(i=0; i<= list->degx; i++){
00778 for(j = 0; j<= list->degy; j++){
00779 sprintf(coefname,"C%d%d",i,j);
00780 check( cpl_table_new_column( table, coefname, CPL_TYPE_DOUBLE));
00781 }
00782 }
00783
00784 for(i=0; i< list->size; i++){
00785 int i2 = i*2;
00786 check(cpl_table_set_string(table,XSH_DISPERSOL_TABLE_COLNAME_AXIS,
00787 i2, XSH_DISPERSOL_AXIS_LAMBDA));
00788 check(cpl_table_set_string(table,XSH_DISPERSOL_TABLE_COLNAME_AXIS,
00789 i2+1, XSH_DISPERSOL_AXIS_SLIT));
00790 check(cpl_table_set_int(table,XSH_DISPERSOL_TABLE_COLNAME_ORDER,
00791 i2, list->list[i].absorder));
00792 check(cpl_table_set_int(table,XSH_DISPERSOL_TABLE_COLNAME_ORDER,
00793 i2+1, list->list[i].absorder));
00794 check(cpl_table_set_int(table,XSH_DISPERSOL_TABLE_COLNAME_DEGX,
00795 i2, list->degx));
00796 check(cpl_table_set_int(table,XSH_DISPERSOL_TABLE_COLNAME_DEGX,
00797 i2+1, list->degx));
00798 check(cpl_table_set_int(table,XSH_DISPERSOL_TABLE_COLNAME_DEGY,
00799 i2, list->degy));
00800 check(cpl_table_set_int(table,XSH_DISPERSOL_TABLE_COLNAME_DEGY,
00801 i2+1, list->degy));
00802 for( j=0; j<= list->degx; j++){
00803 for( k=0; k<= list->degy; k++){
00804 double coef_lambda = 0.0, coef_slit = 0.0;
00805 sprintf(coefname,"C%d%d",j,k);
00806 pows[0] = j;
00807 pows[1] = k;
00808 check(coef_lambda =
00809 cpl_polynomial_get_coeff( list->list[i].lambda_poly, pows));
00810 check(cpl_table_set_double( table, coefname, i2, coef_lambda));
00811 check(coef_slit =
00812 cpl_polynomial_get_coeff( list->list[i].slit_poly, pows));
00813 check(cpl_table_set_double( table, coefname, i2+1, coef_slit));
00814 }
00815 }
00816 }
00817
00818 tag = XSH_GET_TAG_FROM_ARM( XSH_DISP_TAB,instrument);
00819 sprintf(filename, "%s.fits",tag);
00820 check( xsh_pfits_set_pcatg(list->header,tag));
00821 check(cpl_table_save(table, list->header, NULL,
00822 filename, CPL_IO_DEFAULT));
00823
00824 check( result= xsh_frame_product( filename, tag,
00825 CPL_FRAME_TYPE_TABLE,
00826 CPL_FRAME_GROUP_PRODUCT,
00827 CPL_FRAME_LEVEL_TEMPORARY));
00828
00829 cleanup:
00830 xsh_free_table( &table);
00831 if ( cpl_error_get_code() != CPL_ERROR_NONE) {
00832 }
00833 return result;
00834 }
00835
00836