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
00036
00039
00040
00041
00042
00043 #include <tests.h>
00044
00045 #include <xsh_data_pre.h>
00046 #include <xsh_error.h>
00047 #include <xsh_msg.h>
00048 #include <xsh_data_instrument.h>
00049 #include <xsh_data_the_map.h>
00050 #include <xsh_data_localization.h>
00051 #include <xsh_data_spectralformat.h>
00052 #include <xsh_utils_table.h>
00053
00054 #include <xsh_drl.h>
00055 #include <xsh_pfits.h>
00056
00057 #include <xsh_badpixelmap.h>
00058
00059 #include <cpl.h>
00060 #include <math.h>
00061
00062 #include <getopt.h>
00063
00064
00065
00066
00067
00068 #define MODULE_ID "XSH_DATA_CUBE"
00069
00070
00071
00072
00073 enum {
00074 KERNEL_OPT, RADIUS_OPT, BIN_LAMBDA_OPT, BIN_SPACE_OPT, HELP_OPT,
00075 MIN_ORDER_OPT, MAX_ORDER_OPT, SLIT_MIN_OPT, NSLIT_OPT, MERGE_METHOD_OPT,
00076 LAMBDA_REF_OPT
00077 } ;
00078
00079 static const char * Options = "" ;
00080
00081 static struct option long_options[] = {
00082 {"kernel", required_argument, 0, KERNEL_OPT},
00083 {"radius", required_argument, 0, RADIUS_OPT},
00084 {"bin-lambda", required_argument, 0, BIN_LAMBDA_OPT},
00085 {"bin-space", required_argument, 0, BIN_SPACE_OPT},
00086 {"order-min", required_argument, 0, MIN_ORDER_OPT},
00087 {"order-max", required_argument, 0, MAX_ORDER_OPT},
00088 {"slit-min",required_argument, 0, SLIT_MIN_OPT},
00089 {"slit-n",required_argument, 0, NSLIT_OPT},
00090 {"merge-method", required_argument, 0, MERGE_METHOD_OPT},
00091 {"lambda-ref", required_argument, 0, LAMBDA_REF_OPT},
00092 {"help", 0, 0, HELP_OPT},
00093 {0, 0, 0, 0}
00094 };
00095
00096 static void Help( void )
00097 {
00098 puts( "Unitary test of xsh_data_cube" ) ;
00099 puts( "Usage: test_xsh_data_cube [options] <input_files>" ) ;
00100 puts( "Options" ) ;
00101 puts( " --kernel=<name> : TANH, SINC, SINC2, LANCZOS, HAMMING, HANN [TANH]");
00102 puts( " --radius=<nn> : Radius [4]" ) ;
00103 puts( " --bin-lambda=<n> : Bin in Lambda [0.1]" ) ;
00104 puts( " --bin-space=<n> : Bin in Slit [0.1]" ) ;
00105 puts( " --order-min=<n> : Minimum abs order" );
00106 puts( " --order-max=<n> : Maximum abs order" );
00107 puts( " --slit-min=<n> : Minimum slit to rectify" );
00108 puts( " --slit-n=<n> : Number of pixels in slit rectified frame" );
00109 puts( " --merge-method : WEIGHT or MEAN [MEAN]");
00110 puts( " --lambda-ref=<n> : Lambda reference for SLICE OFFSET");
00111 puts( " --help : What you see" ) ;
00112 puts( "\nInput Files" ) ;
00113 puts( "The input files argument MUST be in this order:" ) ;
00114 puts( " 1. Science frame in PRE format" ) ;
00115 puts( " 2. SOF\n" ) ;
00116 TEST_END();
00117 }
00118
00119 static void HandleOptions( int argc, char **argv,
00120 xsh_rectify_param *rectify_par, xsh_merge_param *merge_par,
00121 int *order_min, int *order_max,
00122 double *slit_min, int *nslit, double *lambda_ref)
00123 {
00124 int opt ;
00125 int option_index = 0;
00126
00127 while (( opt = getopt_long (argc, argv, Options,
00128 long_options, &option_index)) != EOF )
00129 switch ( opt ) {
00130 case KERNEL_OPT:
00131 strcpy( rectify_par->rectif_kernel, optarg);
00132 if ( strcmp( optarg, RECTIFY_KERNEL_PRINT( CPL_KERNEL_TANH)) == 0){
00133 rectify_par->kernel_type = CPL_KERNEL_TANH;
00134 }
00135 else if ( strcmp( optarg, RECTIFY_KERNEL_PRINT( CPL_KERNEL_TANH)) == 0){
00136 rectify_par->kernel_type = CPL_KERNEL_TANH;
00137 }
00138 else if ( strcmp( optarg, RECTIFY_KERNEL_PRINT( CPL_KERNEL_SINC)) == 0){
00139 rectify_par->kernel_type = CPL_KERNEL_SINC;
00140 }
00141 else if ( strcmp( optarg, RECTIFY_KERNEL_PRINT( CPL_KERNEL_SINC2)) == 0){
00142 rectify_par->kernel_type = CPL_KERNEL_SINC2;
00143 }
00144 else if ( strcmp( optarg, RECTIFY_KERNEL_PRINT( CPL_KERNEL_LANCZOS)) == 0){
00145 rectify_par->kernel_type = CPL_KERNEL_LANCZOS;
00146 }
00147 else if ( strcmp( optarg, RECTIFY_KERNEL_PRINT( CPL_KERNEL_HAMMING)) == 0){
00148 rectify_par->kernel_type = CPL_KERNEL_HAMMING;
00149 }
00150 else if ( strcmp( optarg, RECTIFY_KERNEL_PRINT( CPL_KERNEL_HANN)) == 0){
00151 rectify_par->kernel_type = CPL_KERNEL_HANN;
00152 }
00153 else{
00154 xsh_msg("Invalid kernel option %s", optarg);
00155 Help();
00156 exit(0);
00157 }
00158 break;
00159 case RADIUS_OPT:
00160 rectify_par->rectif_radius = atof( optarg);
00161 break ;
00162 case BIN_LAMBDA_OPT:
00163 sscanf( optarg, "%lf", &rectify_par->rectif_bin_lambda ) ;
00164 break ;
00165 case BIN_SPACE_OPT:
00166 sscanf( optarg, "%lf", &rectify_par->rectif_bin_space ) ;
00167 break ;
00168 case MIN_ORDER_OPT:
00169 sscanf( optarg, "%d", order_min);
00170 break;
00171 case MAX_ORDER_OPT:
00172 sscanf( optarg, "%d", order_max);
00173 break;
00174 case SLIT_MIN_OPT:
00175 sscanf( optarg, "%lf", slit_min) ;
00176 break ;
00177 case LAMBDA_REF_OPT:
00178 sscanf( optarg, "%lf", lambda_ref);
00179 break ;
00180 case NSLIT_OPT:
00181 sscanf( optarg, "%d", nslit);
00182 break ;
00183 case MERGE_METHOD_OPT:
00184 if ( strcmp(optarg, MERGE_METHOD_PRINT( MEAN_MERGE_METHOD)) == 0){
00185 merge_par->method = MEAN_MERGE_METHOD;
00186 }
00187 else if ( strcmp(optarg, MERGE_METHOD_PRINT( WEIGHTED_MERGE_METHOD)) == 0){
00188 merge_par->method = WEIGHTED_MERGE_METHOD;
00189 }
00190 else{
00191 xsh_msg("WRONG method %s", optarg);
00192 exit(-1);
00193 }
00194 break;
00195 default: Help() ; exit( 0 ) ;
00196 }
00197 }
00198
00207 int main( int argc, char **argv)
00208 {
00209
00210 int ret = 0 ;
00211
00212 xsh_instrument* instrument = NULL;
00213
00214 const char *sof_name = NULL;
00215 cpl_frameset *set = NULL;
00216 cpl_frame *sliceoffset_frame = NULL;
00217
00218 const char * sci_name = NULL ;
00219 xsh_merge_param merge_par = { MEAN_MERGE_METHOD} ;
00220
00221 cpl_frameset *wavesol_frameset = NULL;
00222 cpl_frameset *rect_frameset = NULL;
00223 cpl_frameset *res_2D_frameset = NULL;
00224 cpl_frame *sci_frame = NULL;
00225 cpl_frame *orderlist_frame = NULL;
00226 cpl_frame *slitmap_frame = NULL;
00227 cpl_frame *wavesol_frame = NULL;
00228 cpl_frame *model_frame = NULL;
00229 cpl_frame *spectralformat_frame = NULL;
00230 cpl_frame *recorder_frame = NULL ;
00231 cpl_frame *recordereso_frame = NULL ;
00232 cpl_frame *recordertab_frame = NULL ;
00233 cpl_frame *cube = NULL;
00234 int order_min = -1, order_max = -1;
00235 int rec_min_index=-1, rec_max_index=-1;
00236 int slitlet;
00237 double lambda_ref = -1;
00238 xsh_order_list* order_list = NULL;
00239 xsh_slice_offset *sliceoffset = NULL;
00240 xsh_rectify_param rectify_par;
00241 int nslit_c, nslit=-100;
00242 double slit_min_c, slit_min=-100;
00243 XSH_MODE mode;
00244
00245
00246 TESTS_INIT(MODULE_ID);
00247 cpl_msg_set_level(CPL_MSG_DEBUG);
00248 xsh_debug_level_set(XSH_DEBUG_LEVEL_MEDIUM);
00249
00250
00251 strcpy( rectify_par.rectif_kernel, "default");
00252 rectify_par.kernel_type = CPL_KERNEL_TANH;
00253 rectify_par.rectif_radius = 4 ;
00254 rectify_par.rectif_bin_lambda = 0.1 ;
00255 rectify_par.rectif_bin_space = 0.1 ;
00256 rectify_par.conserve_flux = FALSE;
00257
00258 HandleOptions( argc, argv, &rectify_par, &merge_par, &order_min, &order_max,
00259 &slit_min, &nslit, &lambda_ref);
00260
00261 if ( (argc - optind) >=2 ) {
00262 sci_name = argv[optind];
00263 sof_name = argv[optind+1];
00264 }
00265 else {
00266 Help();
00267 exit(0);
00268 }
00269
00270 check( set = sof_to_frameset( sof_name));
00271
00272 check( instrument = xsh_dfs_set_groups( set));
00273
00274 check( spectralformat_frame = xsh_find_spectral_format( set, instrument));
00275 check( orderlist_frame = xsh_find_order_tab_edges( set, instrument));
00276 check( slitmap_frame = xsh_find_slitmap( set, instrument));
00277
00278 TESTS_XSH_FRAME_CREATE( sci_frame, "SLIT_STARE_DIVIDED_arm", sci_name);
00279 check( mode = xsh_instrument_get_mode( instrument));
00280
00281 xsh_msg("SCI : %s",
00282 cpl_frame_get_filename( sci_frame));
00283 xsh_msg("ORDERLIST : %s",
00284 cpl_frame_get_filename( orderlist_frame));
00285 xsh_msg("SPECTRALFORMAT : %s",
00286 cpl_frame_get_filename( spectralformat_frame));
00287 if ( slitmap_frame != NULL){
00288 xsh_msg("SLITMAP : %s",
00289 cpl_frame_get_filename( slitmap_frame));
00290 }
00291
00292 wavesol_frameset = xsh_find_wave_tab_ifu( set, instrument);
00293 cpl_error_reset();
00294 if ( wavesol_frameset == NULL){
00295 model_frame = xsh_find_model_config_tab( set, instrument);
00296 xsh_msg("MODEL : %s",
00297 cpl_frame_get_filename( model_frame));
00298 }
00299 else{
00300 int iframe;
00301 int size;
00302
00303 size = cpl_frameset_get_size( wavesol_frameset);
00304 for(iframe=0; iframe < size; iframe++){
00305 cpl_frame *frame = cpl_frameset_get_frame(wavesol_frameset, iframe);
00306 xsh_msg("WAVESOL : %s",
00307 cpl_frame_get_filename( frame));
00308 }
00309 }
00310 sliceoffset_frame = xsh_find_frame_with_tag( set, XSH_SLICE_OFFSET,
00311 instrument);
00312 if ( sliceoffset_frame !=NULL){
00313 xsh_msg("SLICEOFFSET : %s",
00314 cpl_frame_get_filename( sliceoffset_frame));
00315 }
00316
00317 xsh_msg(" Parameters ");
00318 xsh_msg(" kernel %s", RECTIFY_KERNEL_PRINT( rectify_par.kernel_type));
00319 xsh_msg(" radius %f", rectify_par.rectif_radius);
00320 xsh_msg(" bin-space %f", rectify_par.rectif_bin_space);
00321 xsh_msg(" bin-lambda %f", rectify_par.rectif_bin_lambda);
00322
00323
00324 check( order_list = xsh_order_list_load ( orderlist_frame, instrument));
00325
00326 if ( order_min != -1) {
00327 check( rec_min_index = xsh_order_list_get_index_by_absorder( order_list,
00328 order_min));
00329 xsh_msg("Order min %d => index %d", order_min, rec_min_index);
00330 }
00331 else{
00332 rec_min_index = 0;
00333 }
00334
00335 if ( order_max != -1) {
00336 check( rec_max_index = xsh_order_list_get_index_by_absorder( order_list,
00337 order_max));
00338 xsh_msg("Order max %d => index %d", order_max, rec_max_index);
00339 }
00340 else{
00341 rec_max_index = order_list->size;
00342 }
00343
00344
00345
00346
00347 check( xsh_rec_slit_size( &rectify_par,
00348 &slit_min_c, &nslit_c, mode));
00349
00350 if (slit_min == -100){
00351 slit_min = slit_min_c;
00352 }
00353 if ( nslit == -100){
00354 nslit = nslit_c;
00355 }
00356
00357 xsh_msg("SLIT min = %f and has size %d", slit_min, nslit);
00358 xsh_msg("Lambda ref %f", lambda_ref);
00359 if (lambda_ref < 0.0){
00360 check( rect_frameset = xsh_rectify_orders_ifu( sci_frame, order_list,
00361 wavesol_frameset, model_frame, instrument, &rectify_par,
00362 spectralformat_frame, sliceoffset_frame, slitmap_frame,NULL,NULL,rec_min_index,
00363 rec_max_index, "test"));
00364 }
00365 else{
00366 double lambda_ref_min;
00367 double lambda_ref_max;
00368 const char * tablename = NULL;
00369 cpl_table *table = NULL;
00370 cpl_frame *spectralformat2_frame = NULL;
00371 xsh_spectralformat_list* list = NULL;
00372 cpl_vector* orders = NULL;
00373 int size, absorder, iorder;
00374
00375 lambda_ref_min = lambda_ref-rectify_par.rectif_bin_lambda*10;
00376 lambda_ref_max = lambda_ref+rectify_par.rectif_bin_lambda*10;
00377
00378 xsh_msg( "Do cube for reference %f ==> %f", lambda_ref_min, lambda_ref_max);
00379 check( list = xsh_spectralformat_list_load( spectralformat_frame,
00380 instrument));
00381 check( orders = xsh_spectralformat_list_get_orders( list, lambda_ref));
00382 size = cpl_vector_get_size( orders);
00383
00384 tablename = cpl_frame_get_filename( spectralformat_frame);
00385 XSH_TABLE_LOAD( table, tablename);
00386
00387 for( iorder=0; iorder < size; iorder++){
00388 absorder = cpl_vector_get( orders, iorder);
00389 xsh_msg("In Order %d", absorder);
00390 cpl_table_set_int(table, XSH_SPECTRALFORMAT_TABLE_COLNAME_ORDER, iorder, absorder);
00391 cpl_table_set_float(table, XSH_SPECTRALFORMAT_TABLE_COLNAME_WLMIN, iorder, lambda_ref_min);
00392 cpl_table_set_float(table, XSH_SPECTRALFORMAT_TABLE_COLNAME_WLMAX, iorder, lambda_ref_max);
00393 }
00394 cpl_table_save( table, NULL,NULL,"LAMBDA_REF_FORMAT.fits",CPL_IO_DEFAULT);
00395 TESTS_XSH_FRAME_CREATE( spectralformat2_frame, "SPEC_arm", "LAMBDA_REF_FORMAT.fits");
00396
00397 check( rect_frameset = xsh_rectify_orders_ifu( sci_frame, order_list,
00398 wavesol_frameset, model_frame, instrument, &rectify_par,
00399 spectralformat2_frame, sliceoffset_frame, slitmap_frame,NULL,NULL, 0,
00400 size-1, "test"));
00401 }
00402 check( res_2D_frameset = xsh_merge_ord_ifu( rect_frameset,instrument,
00403 &merge_par, "test"));
00404
00405
00406 check( cube = xsh_format( res_2D_frameset, "CUBE.fits",instrument,
00407 "test") ) ;
00408 cleanup:
00409 if (cpl_error_get_code() != CPL_ERROR_NONE) {
00410 xsh_error_dump(CPL_MSG_ERROR);
00411 ret = 1;
00412 }
00413 xsh_order_list_free( &order_list);
00414 xsh_free_frame( &sci_frame);
00415 xsh_free_frameset( &rect_frameset);
00416 xsh_free_frameset( &res_2D_frameset);
00417 xsh_free_frameset( &wavesol_frameset);
00418 xsh_free_frameset( &set);
00419 xsh_instrument_free( &instrument);
00420 xsh_free_frame( &recorder_frame);
00421 xsh_free_frame( &recordereso_frame);
00422 xsh_free_frame( &recordertab_frame);
00423 xsh_free_frame( &cube);
00424 TEST_END();
00425 return ret;
00426 }