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
00031
00032
00033 #include <xsh_parameters.h>
00034 #include <xsh_msg.h>
00035 #include <xsh_error.h>
00036 #include <xsh_drl.h>
00037 #include <strings.h>
00038
00044
00045
00046
00047
00048 void xsh_parameters_new_int( cpl_parameterlist* list,
00049 const char* recipe_id, const char* name,int value, const char* comment)
00050 {
00051 char paramname[256];
00052 char recipename[256];
00053 cpl_parameter* p =NULL;
00054
00055
00056 sprintf(recipename,"xsh.%s",recipe_id);
00057 sprintf(paramname,"%s.%s",recipename,name);
00058
00059 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00060
00061 check(p = cpl_parameter_new_value(paramname,CPL_TYPE_INT,comment,
00062 recipename,value));
00063 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,name));
00064 check(cpl_parameterlist_append(list,p));
00065
00066 cleanup:
00067 return;
00068 }
00069
00070
00071 void xsh_parameters_new_boolean( cpl_parameterlist* list,
00072 const char* recipe_id, const char* name,int value, const char* comment)
00073 {
00074 char paramname[256];
00075 char recipename[256];
00076 cpl_parameter* p =NULL;
00077
00078
00079 sprintf(recipename,"xsh.%s",recipe_id);
00080 sprintf(paramname,"%s.%s",recipename,name);
00081
00082 XSH_ASSURE_NOT_NULL(list);
00083 check(p = cpl_parameter_new_value(paramname,CPL_TYPE_BOOL,comment,
00084 recipename,value));
00085 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,name));
00086 check(cpl_parameterlist_append(list,p));
00087
00088 cleanup:
00089 return;
00090 }
00091
00092 static void xsh_parameters_new_string( cpl_parameterlist* list,
00093 const char* recipe_id,
00094 const char* name,
00095 const char* value,
00096 const char* comment)
00097 {
00098 char * paramname = NULL ;
00099 char * recipename = NULL ;
00100 cpl_parameter* p =NULL;
00101
00102 recipename = xsh_stringcat_any( "xsh.", recipe_id, NULL );
00103 paramname = xsh_stringcat_any( recipename, ".", name, NULL );
00104
00105 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00106
00107 check(p = cpl_parameter_new_value(paramname,CPL_TYPE_STRING, comment,
00108 recipename, value));
00109 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,name));
00110 check(cpl_parameterlist_append(list,p));
00111
00112 cleanup:
00113 XSH_FREE(recipename);
00114 XSH_FREE(paramname);
00115 return;
00116 }
00117
00118 void xsh_parameters_new_double( cpl_parameterlist* list,
00119 const char* recipe_id,const char* name,double value, const char* comment)
00120 {
00121 char paramname[256];
00122 char recipename[256];
00123 cpl_parameter* p =NULL;
00124
00125
00126 sprintf(recipename,"xsh.%s",recipe_id);
00127 sprintf(paramname,"%s.%s",recipename,name);
00128
00129 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00130
00131 check(p = cpl_parameter_new_value(paramname,CPL_TYPE_DOUBLE,comment,
00132 recipename,value));
00133 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,name));
00134 check(cpl_parameterlist_append(list,p));
00135
00136 cleanup:
00137 return;
00138 }
00139
00140 static void
00141 xsh_parameters_new_bool( cpl_parameterlist* list,
00142 const char* recipe_id,const char* name,bool value, const char* comment)
00143 {
00144 char paramname[256];
00145 char recipename[256];
00146 cpl_parameter* p =NULL;
00147
00148
00149 sprintf(recipename,"xsh.%s",recipe_id);
00150 sprintf(paramname,"%s.%s",recipename,name);
00151
00152 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00153
00154 check(p = cpl_parameter_new_value(paramname,CPL_TYPE_BOOL,comment,
00155 recipename,value));
00156 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,name));
00157 check(cpl_parameterlist_append(list,p));
00158
00159 cleanup:
00160 return;
00161 }
00162
00163 static void
00164 xsh_parameters_new_float( cpl_parameterlist* list,
00165 const char* recipe_id,const char* name,float value, const char* comment)
00166 {
00167 char paramname[256];
00168 char recipename[256];
00169 cpl_parameter* p =NULL;
00170
00171
00172 sprintf(recipename,"xsh.%s",recipe_id);
00173 sprintf(paramname,"%s.%s",recipename,name);
00174
00175 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00176
00177 check(p = cpl_parameter_new_value(paramname,CPL_TYPE_FLOAT,comment,
00178 recipename,value));
00179 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,name));
00180 check(cpl_parameterlist_append(list,p));
00181
00182 cleanup:
00183 return;
00184 }
00185
00186 static void xsh_parameters_new_range_int( cpl_parameterlist* list,
00187 const char* recipe_id,
00188 const char* name,
00189 int def, int min, int max,
00190 const char* comment)
00191 {
00192 char paramname[256];
00193 char recipename[256];
00194 cpl_parameter* p =NULL;
00195
00196
00197 sprintf(recipename,"xsh.%s",recipe_id);
00198 sprintf(paramname,"%s.%s",recipename,name);
00199
00200 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00201
00202 check(p = cpl_parameter_new_range( paramname,CPL_TYPE_INT, comment,
00203 recipename, def, min, max ));
00204 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,name));
00205 check(cpl_parameterlist_append(list,p));
00206
00207 cleanup:
00208 return;
00209 }
00210
00211
00212
00213 static void xsh_parameters_new_range_double( cpl_parameterlist* list,
00214 const char* recipe_id,
00215 const char* name,
00216 double def, double min, double max,
00217 const char* comment)
00218 {
00219 char paramname[256];
00220 char recipename[256];
00221 cpl_parameter* p =NULL;
00222
00223
00224 sprintf(recipename,"xsh.%s",recipe_id);
00225 sprintf(paramname,"%s.%s",recipename,name);
00226
00227 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00228
00229 check(p = cpl_parameter_new_range( paramname,CPL_TYPE_DOUBLE, comment,
00230 recipename, def, min, max ));
00231 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,name));
00232 check(cpl_parameterlist_append(list,p));
00233
00234 cleanup:
00235 return;
00236 }
00237
00238
00239
00240 static char * xsh_parameters_get_string( const cpl_parameterlist* list,
00241 const char* recipe_id, const char* name)
00242 {
00243 char paramname[256];
00244 cpl_parameter * p =NULL;
00245 char * result = NULL ;
00246
00247 sprintf(paramname,"xsh.%s.%s",recipe_id, name);
00248
00249 p = cpl_parameterlist_find( (cpl_parameterlist *)list, paramname);
00250 if ( p == NULL ) goto cleanup ;
00251 result = (char *)cpl_parameter_get_string(p) ;
00252
00253 cleanup:
00254 return result;
00255 }
00256
00257
00258 int xsh_parameters_get_boolean( const cpl_parameterlist * list,
00259 const char* recipe_id, const char* name)
00260 {
00261 char paramname[256];
00262 char recipename[256];
00263 cpl_parameter* p =NULL;
00264 int result = 0;
00265
00266 sprintf(recipename,"xsh.%s",recipe_id);
00267 sprintf(paramname,"%s.%s",recipename,name);
00268
00269 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00270
00271 check(p = cpl_parameterlist_find( (cpl_parameterlist *)list,paramname));
00272 check(result = cpl_parameter_get_bool( p));
00273
00274 cleanup:
00275 return result;
00276 }
00277
00278
00279 int xsh_parameters_get_int( cpl_parameterlist* list,
00280 const char* recipe_id, const char* name)
00281 {
00282 char paramname[256];
00283 char recipename[256];
00284 cpl_parameter* p =NULL;
00285 int result = 0;
00286 sprintf(recipename,"xsh.%s",recipe_id);
00287 sprintf(paramname,"%s.%s",recipename,name);
00288
00289 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00290
00291 check(p = cpl_parameterlist_find( (cpl_parameterlist *)list,paramname));
00292 check(result = cpl_parameter_get_int(p));
00293
00294 cleanup:
00295 return result;
00296 }
00297
00298 double xsh_parameters_get_double( cpl_parameterlist* list,
00299 const char* recipe_id, const char* name)
00300 {
00301 char paramname[256];
00302 char recipename[256];
00303 cpl_parameter* p =NULL;
00304 double result = 0.0;
00305
00306 sprintf(recipename,"xsh.%s",recipe_id);
00307 sprintf(paramname,"%s.%s",recipename,name);
00308
00309 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00310
00311 check(p = cpl_parameterlist_find(list,paramname));
00312 check(result = cpl_parameter_get_double(p));
00313
00314 cleanup:
00315 return result;
00316 }
00317
00321
00330
00331
00332 cpl_parameter* xsh_parameters_find( cpl_parameterlist* list,
00333 const char* recipe_id, const char* name)
00334 {
00335
00336 char paramname[256];
00337 cpl_parameter * result = NULL ;
00338
00339 sprintf(paramname,"xsh.%s.%s",recipe_id, name);
00340 check(result = cpl_parameterlist_find( (cpl_parameterlist *)list, paramname));
00341
00342 cleanup:
00343 return result;
00344
00345 }
00346
00347
00348 void xsh_parameters_pre_overscan( const char *recipe_id,
00349 cpl_parameterlist * plist )
00350 {
00351 cpl_parameter* p=NULL;
00352 char paramname[256];
00353 char recipename[256];
00354
00355 XSH_ASSURE_NOT_NULL( recipe_id ) ;
00356 XSH_ASSURE_NOT_NULL( plist ) ;
00357
00358
00359 sprintf(recipename,"xsh.%s",recipe_id);
00360 sprintf(paramname,"%s.%s",recipename,"pre-overscan-corr");
00361
00362 check(p = cpl_parameter_new_enum(paramname,CPL_TYPE_INT,
00363 "pre-overscan correction."
00364 "0: no correction"
00365 "1: mean overscan correction"
00366 "2: mean prescan correction"
00367 "3: (mean pre+mean overscan)/2 correction"
00368
00369
00370
00371 ,recipename,0,
00372 4,0,1,2,3));
00373
00374 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
00375 "pre-overscan-corr"));
00376 check(cpl_parameterlist_append(plist,p));
00377
00378 cleanup:
00379 return ;
00380 }
00381
00382 void xsh_parameters_generic( const char *recipe_id,
00383 cpl_parameterlist * plist )
00384 {
00385 XSH_ASSURE_NOT_NULL( recipe_id ) ;
00386 XSH_ASSURE_NOT_NULL( plist ) ;
00387
00388 check( xsh_parameters_new_string( plist, recipe_id, "keep-temp", "no",
00389 "If 'no', temporary files are deleted." ) ) ;
00390 check( xsh_parameters_new_string( plist, recipe_id, "debug-level",
00391 "none",
00392 "Additional xshooter debug level. One of 'none', 'low', 'medium', 'high'"));
00393 check( xsh_parameters_new_string( plist, recipe_id, "test",
00394 "none",
00395 "Can be any string, usage depends on recipe. Used during development phases" ) ) ;
00396 check( xsh_parameters_new_boolean(plist,recipe_id, "time-stamp",
00397 FALSE,
00398 "Add timestamp to product file name." )) ;
00399
00400 cleanup:
00401 return ;
00402 }
00403
00404 int xsh_parameters_get_temporary( const char * recipe_id,
00405 const cpl_parameterlist * list )
00406 {
00407 char * result = NULL ;
00408
00409 result = xsh_parameters_get_string( list, recipe_id,
00410 "keep-temp" ) ;
00411 if ( result == NULL ) {
00412 xsh_msg( "Cant get parameter 'keep-temp'" ) ;
00413 return 1 ;
00414 }
00415 else if ( strcasecmp( result, "yes" ) == 0 ) return 1 ;
00416 else return 0 ;
00417
00418 }
00419
00420 int xsh_parameters_debug_level_get( const char * recipe_id,
00421 const cpl_parameterlist * list )
00422 {
00423 char * slevel = NULL ;
00424 int level = XSH_DEBUG_LEVEL_NONE ;
00425
00426 slevel = xsh_parameters_get_string( list, recipe_id,
00427 "debug-level" ) ;
00428 if ( slevel == NULL ) {
00429 xsh_msg( "Cant get parameter 'debug-level'" ) ;
00430 }
00431 else if ( strcmp( slevel, "low" ) == 0 ) level = XSH_DEBUG_LEVEL_LOW ;
00432 else if ( strcmp( slevel, "medium" ) == 0 ) level = XSH_DEBUG_LEVEL_MEDIUM ;
00433 else if ( strcmp( slevel, "high" ) == 0 ) level = XSH_DEBUG_LEVEL_HIGH ;
00434 else level = XSH_DEBUG_LEVEL_NONE ;
00435
00436 xsh_debug_level_set( level ) ;
00437 return level ;
00438 }
00439
00440 char * xsh_parameters_test_mode_get( const char * recipe_id,
00441 const cpl_parameterlist * list )
00442 {
00443 char * stest = NULL ;
00444
00445 stest = xsh_parameters_get_string( list, recipe_id,
00446 "test" ) ;
00447 return stest ;
00448 }
00449
00450 int xsh_parameters_time_stamp_get( const char * recipe_id,
00451 const cpl_parameterlist * list )
00452 {
00453 int ts = FALSE ;
00454
00455 ts = xsh_parameters_get_boolean( list, recipe_id, "time-stamp" ) ;
00456
00457 xsh_time_stamp_set( ts ) ;
00458
00459 return ts ;
00460 }
00461
00462
00470
00471 void xsh_parameters_clipping_crh_create(const char* recipe_id,
00472 cpl_parameterlist* list, xsh_clipping_param p)
00473 {
00474
00475 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00476
00477
00478
00479
00480
00481
00482 check(xsh_parameters_new_double(list,recipe_id,"crh-clip-kappa", p.sigma,
00483 "Kappa value in sigma clipping during CRH rejection using "\
00484 "multiple frames"));
00485
00486 check(xsh_parameters_new_int(list,recipe_id,"crh-clip-niter", p.niter,
00487 "Number of iterations in sigma clipping during CRH rejection "\
00488 "using multiple frames"));
00489
00490 check(xsh_parameters_new_double(list,recipe_id,"crh-clip-frac", p.frac,
00491 "Minimal ratio of points accepted / total in sigma clipping "\
00492 "during CRH rejection using multiple frames"));
00493
00494 cleanup:
00495 return;
00496 }
00497
00498
00499
00500
00508
00509 void xsh_parameters_hot_cold_pix_create(const char* recipe_id,
00510 cpl_parameterlist* list, xsh_hot_cold_pix_param p)
00511 {
00512
00513 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00514
00515
00516 check( xsh_parameters_new_boolean( list, recipe_id,
00517 "hot-cold-pix-search",
00518 p.hot_cold_pix_search,
00519 "If true hot and cold pixels are searched"));
00520
00521 xsh_parameters_new_double(list,recipe_id,"cold-pix-kappa",p.cold_pix_kappa,
00522 "Kappa sigma value to clip low intensity pixels");
00523
00524
00525 check(xsh_parameters_new_range_int( list, recipe_id,"cold-pix-niter",
00526 p.cold_pix_niter, 1, 999,
00527 "Number of kappa-sigma clip iterations (cold pixels search)."));
00528
00529
00530 xsh_parameters_new_double(list,recipe_id,"hot-pix-kappa",p.hot_pix_kappa,
00531 "Kappa sigma value to clip high intensity pixels");
00532
00533 check(xsh_parameters_new_range_int( list, recipe_id,"hot-pix-niter",
00534 p.hot_pix_niter, 1, 999,
00535 "Number of kappa-sigma clip iterations (hot pixels search)."));
00536
00537 cleanup:
00538 return;
00539 }
00540
00541
00549
00550 void xsh_parameters_struct_create(const char* recipe_id,
00551 cpl_parameterlist* list, xsh_struct_param p)
00552 {
00553
00554 xsh_parameters_new_int(list,recipe_id,"struct_refx",p.ref_x,
00555 "Reference X value to compute structure");
00556
00557 xsh_parameters_new_int(list,recipe_id,"struct_refy",p.ref_y,
00558 "Reference Y value to compute structure");
00559 }
00560
00561
00562
00563
00571
00572 void xsh_parameters_ref1_create(const char* recipe_id,
00573 cpl_parameterlist* list, xsh_ref_param p)
00574 {
00575
00576 xsh_parameters_new_int(list,recipe_id,"ref1_llx",p.ref_llx,
00577 "Lower left X of reference region");
00578
00579 xsh_parameters_new_int(list,recipe_id,"ref1_lly",p.ref_lly,
00580 "Lower left Y of reference region");
00581
00582 xsh_parameters_new_int(list,recipe_id,"ref1_urx",p.ref_urx,
00583 "Upper right X of reference region");
00584
00585 xsh_parameters_new_int(list,recipe_id,"ref1_ury",p.ref_ury,
00586 "Upper right Y of reference region");
00587
00588 }
00589
00590
00591
00599
00600 void xsh_parameters_ref2_create(const char* recipe_id,
00601 cpl_parameterlist* list, xsh_ref_param p)
00602 {
00603
00604 xsh_parameters_new_int(list,recipe_id,"ref2_llx",p.ref_llx,
00605 "Lower left X of reference region");
00606
00607 xsh_parameters_new_int(list,recipe_id,"ref2_lly",p.ref_lly,
00608 "Lower left Y of reference region");
00609
00610 xsh_parameters_new_int(list,recipe_id,"ref2_urx",p.ref_urx,
00611 "Upper right X of reference region");
00612
00613 xsh_parameters_new_int(list,recipe_id,"ref2_ury",p.ref_ury,
00614 "Upper right Y of reference region");
00615
00616 }
00617
00618
00619
00627
00628 void xsh_parameters_ron_dark_create(const char* recipe_id,
00629 cpl_parameterlist* list, xsh_ron_dark_param p)
00630 {
00631
00632 xsh_parameters_new_int(list,recipe_id,"ron_llx",p.ron_llx,
00633 "Lower left X of reference region to measure RON");
00634
00635 xsh_parameters_new_int(list,recipe_id,"ron_lly",p.ron_lly,
00636 "Lower left Y of reference region to measure RON");
00637
00638 xsh_parameters_new_int(list,recipe_id,"ron_urx",p.ron_urx,
00639 "Upper right X of reference region to measure RON");
00640
00641 xsh_parameters_new_int(list,recipe_id,"ron_ury",p.ron_ury,
00642 "Upper right Y of reference region to measure RON");
00643
00644 xsh_parameters_new_int(list,recipe_id,"ron_hsize",p.ron_hsize,
00645 "Sampling area size");
00646
00647
00648 xsh_parameters_new_int(list,recipe_id,"ron_nsamples",p.ron_nsamp,
00649 "Number of random samples");
00650
00651
00652
00653 }
00654
00662
00663 void xsh_parameters_ron_create(const char* recipe_id,
00664 cpl_parameterlist* list, xsh_ron_param p)
00665 {
00666
00667
00668 xsh_ref_param ref_params = {p.ron_ref_llx,p.ron_ref_lly,
00669 p.ron_ref_urx,p.ron_ref_ury};
00670
00671
00672 xsh_parameters_new_string(list,recipe_id,"ron_method",p.ron_method,
00673 "RON computation method");
00674
00675 xsh_parameters_new_int(list,recipe_id,"random_sizex",p.ron_random_sizex,
00676 "Region X size for random computation");
00677
00678 xsh_parameters_new_int(list,recipe_id,"random_nsamples",p.ron_random_nsamples,
00679 "Number of random samples");
00680
00681
00682 xsh_parameters_ref1_create(recipe_id,list,ref_params);
00683 xsh_parameters_ref2_create(recipe_id,list,ref_params);
00684
00685
00686 xsh_parameters_new_int(list,recipe_id,"stacking_ks_low",p.stacking_ks_low,
00687 "Lower value of kappa-sigma clip in stacking");
00688
00689 xsh_parameters_new_int(list,recipe_id,"stacking_ks_iter",p.stacking_ks_iter,
00690 "Number of iterations in kappa-sigma clip in stacking");
00691
00692
00693 }
00694
00695
00696
00697
00705
00706 void xsh_parameters_fpn_create(const char* recipe_id,
00707 cpl_parameterlist* list, xsh_fpn_param p)
00708 {
00709
00710 xsh_parameters_new_int(list,recipe_id,"fpn_llx",p.fpn_llx,
00711 "Lower left reference area X coordinate for "
00712 "Fixed Pattern Noise computation");
00713
00714 xsh_parameters_new_int(list,recipe_id,"fpn_lly",p.fpn_lly,
00715 "Lower left reference area Y coordinate for "
00716 "Fixed Pattern Noise computation");
00717
00718 xsh_parameters_new_int(list,recipe_id,"fpn_urx",p.fpn_urx,
00719 "Upper right reference area X coordinate for "
00720 "Fixed Pattern Noise computation");
00721
00722 xsh_parameters_new_int(list,recipe_id,"fpn_ury",p.fpn_ury,
00723 "Upper right reference area Y coordinate for "
00724 "Fixed Pattern Noise computation");
00725
00726 xsh_parameters_new_int(list,recipe_id,"fpn_hsize",p.fpn_hsize,
00727 "Sample size for "
00728 "Fixed Pattern Noise computation");
00729
00730
00731 xsh_parameters_new_int(list,recipe_id,"fpn_nsamples",p.fpn_nsamples,
00732 "Number of sampling points for "
00733 "Fixed Pattern Noise computation");
00734
00735 }
00736
00737
00745
00746 xsh_clipping_param* xsh_parameters_clipping_crh_get(const char* recipe_id,
00747 cpl_parameterlist* list)
00748 {
00749 xsh_clipping_param* result = NULL;
00750
00751
00752 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00753
00754
00755 check(result = (xsh_clipping_param*)(cpl_malloc(sizeof(xsh_clipping_param)))
00756 );
00757 assure (result != NULL, CPL_ERROR_ILLEGAL_OUTPUT,
00758 "Memory allocation failed!");
00759
00760
00761
00762
00763
00764
00765 check(result->sigma = xsh_parameters_get_double(list,recipe_id,
00766 "crh-clip-kappa"));
00767 check(result->niter = xsh_parameters_get_int(list,recipe_id,
00768 "crh-clip-niter"));
00769 check(result->frac = xsh_parameters_get_double(list,recipe_id,
00770 "crh-clip-frac"));
00771
00772 cleanup:
00773 if(cpl_error_get_code() != CPL_ERROR_NONE){
00774 cpl_free(result);
00775 result = NULL;
00776 }
00777 return result;
00778 }
00779
00780
00788
00789 void xsh_parameters_clipping_noise_create(const char* recipe_id,
00790 cpl_parameterlist* list,
00791 xsh_clipping_param noise_param)
00792 {
00793
00794 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00795
00796
00797
00798 check(xsh_parameters_new_double(list,recipe_id,"noise-clip-kappa",
00799 noise_param.sigma,
00800 "Multiple of sigma in sigma clipping"));
00801
00802 check(xsh_parameters_new_int(list,recipe_id,"noise-clip-niter",
00803 noise_param.niter,
00804 "Number of iterations in sigma clipping"));
00805
00806 check(xsh_parameters_new_double(list,recipe_id,"noise-clip-frac",
00807 noise_param.frac,
00808 "Minimal fractions of bad pixel allowed"));
00809
00810 check(xsh_parameters_new_double(list,recipe_id,"noise-clip-diff",
00811 noise_param.diff,
00812 "Minimum relative change in sigma for sigma clipping"));
00813 cleanup:
00814 return;
00815 }
00816
00817
00825
00826 xsh_clipping_param* xsh_parameters_clipping_noise_get(const char* recipe_id,
00827 cpl_parameterlist* list)
00828 {
00829 xsh_clipping_param* result = NULL;
00830
00831
00832 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00833
00834
00835 check(result = (xsh_clipping_param*)(cpl_malloc(sizeof(xsh_clipping_param)))
00836 );
00837 assure (result != NULL, CPL_ERROR_ILLEGAL_OUTPUT,
00838 "Memory allocation failed!");
00839
00840
00841 check(result->sigma = xsh_parameters_get_double(list,recipe_id,
00842 "noise-clip-kappa"));
00843 check(result->niter = xsh_parameters_get_int(list,recipe_id,
00844 "noise-clip-niter"));
00845 check(result->frac = xsh_parameters_get_double(list,recipe_id,
00846 "noise-clip-frac"));
00847 check(result->diff = xsh_parameters_get_double(list,recipe_id,
00848 "noise-clip-diff"));
00849 cleanup:
00850 if(cpl_error_get_code() != CPL_ERROR_NONE){
00851 cpl_free(result);
00852 result = NULL;
00853 }
00854 return result;
00855 }
00856
00857
00867
00868
00869 void xsh_parameters_detect_order_create(const char* recipe_id,
00870 cpl_parameterlist* list)
00871 {
00872
00873 char paramname[256];
00874 char recipename[256];
00875 cpl_parameter* p =NULL;
00876
00877
00878 XSH_ASSURE_NOT_NULL( recipe_id);
00879 XSH_ASSURE_NOT_NULL( list);
00880
00881
00882
00883 check( xsh_parameters_new_int( list, recipe_id,
00884 "detectorder-edges-search-window-half-size",
00885 50,
00886 "Half window size in pixels for the search for order edges"));
00887
00888
00889 check( xsh_parameters_new_double( list, recipe_id,
00890 "detectorder-edges-flux-thresh",
00891 0.05,
00892 "Threshold in relative flux (compared to the central flux) "\
00893 "below which the order edges are defined"));
00894
00895 check( xsh_parameters_new_double( list, recipe_id,
00896 "detectorder-min-sn",
00897 35.,
00898 "Minimum signal-to-noise ratio at the centroid of the orders"));
00899
00900 check( xsh_parameters_new_int( list, recipe_id,
00901 "detectorder-min-order-size-x",
00902 60,
00903 "Minimum order size in pixels along X direction"));
00904 check( xsh_parameters_new_int( list, recipe_id,
00905 "detectorder-chunk-half-size",
00906 1,
00907 "Half size in pixels of the chunks in Y direction"));
00908
00909
00910 check( xsh_parameters_new_double( list, recipe_id,
00911 "detectorder-slitlet-low-factor",
00912 1.0,
00913 "Factor for slitlet on lower edge slitlet (IFU)"));
00914
00915 check( xsh_parameters_new_double( list, recipe_id,
00916 "detectorder-slitlet-up-factor",
00917 1.0,
00918 "Factor for slitlet on upper edge (IFU)"));
00919 check( xsh_parameters_new_boolean( list, recipe_id,
00920 "detectorder-fixed-slice",
00921 CPL_TRUE,
00922 "If true the size of slitlet is fixed (IFU)"));
00923
00924
00925
00926 sprintf(recipename,"xsh.%s",recipe_id);
00927 sprintf(paramname,"%s.%s",recipename,"detectorder-slice-trace-method");
00928
00929 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00930
00931 check(p = cpl_parameter_new_enum(paramname,CPL_TYPE_STRING,
00932 "method adopted for IFU slice tracing:",
00933 recipename,"fixed",
00934 3,"fixed","sobel","scharr"));
00935
00936 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
00937 "detectorder-slice-trace-method"));
00938 check(cpl_parameterlist_append(list,p));
00939
00940 check( xsh_parameters_new_boolean( list, recipe_id,
00941 "detectorder-qc-mode",
00942 CPL_FALSE,
00943 "If true allows to skip edge detection on orders below detectorder-min-sn (oly for QC mode, not to be set by normal users)"));
00944
00945 cleanup:
00946 return;
00947 }
00948
00949
00961
00962
00963 xsh_detect_order_param* xsh_parameters_detect_order_get(const char* recipe_id,
00964 cpl_parameterlist* list)
00965 {
00966 xsh_detect_order_param* result = NULL;
00967
00968
00969 XSH_ASSURE_NOT_NULL( list);
00970
00971
00972 XSH_MALLOC( result, xsh_detect_order_param, 1);
00973
00974
00975 check( result->search_window_hsize = xsh_parameters_get_int( list, recipe_id,
00976 "detectorder-edges-search-window-half-size"));
00977 check( result->flux_thresh = xsh_parameters_get_double( list, recipe_id,
00978 "detectorder-edges-flux-thresh"));
00979 check( result->min_sn = xsh_parameters_get_double( list, recipe_id,
00980 "detectorder-min-sn"));
00981 check( result->min_order_size_x = xsh_parameters_get_int( list, recipe_id,
00982 "detectorder-min-order-size-x"));
00983 check( result->chunk_hsize = xsh_parameters_get_int( list, recipe_id,
00984 "detectorder-chunk-half-size"));
00985 check( result->slitlet_low_factor = xsh_parameters_get_double( list,recipe_id,
00986 "detectorder-slitlet-low-factor"));
00987 check( result->slitlet_up_factor = xsh_parameters_get_double( list,recipe_id,
00988 "detectorder-slitlet-up-factor"));
00989 check( result->fixed_slice = xsh_parameters_get_boolean( list,recipe_id,
00990 "detectorder-fixed-slice"));
00991
00992 check( result->method = xsh_parameters_get_string( list,recipe_id,
00993 "detectorder-slice-trace-method"));
00994 check( result->qc_mode = xsh_parameters_get_boolean( list,recipe_id,
00995 "detectorder-qc-mode"));
00996
00997 cleanup:
00998 if(cpl_error_get_code() != CPL_ERROR_NONE){
00999 XSH_FREE( result);
01000 }
01001 return result;
01002 }
01003
01013
01014
01015 void xsh_parameters_d2_detect_order_create(const char* recipe_id,
01016 cpl_parameterlist* list)
01017 {
01018
01019 XSH_ASSURE_NOT_NULL( recipe_id);
01020 XSH_ASSURE_NOT_NULL( list);
01021
01022
01023
01024
01025 check( xsh_parameters_new_double( list, recipe_id,
01026 "detectorder-d2-min-sn",
01027 10.,
01028 "minimum signal noise ratio in order"));
01029 cleanup:
01030 return;
01031 }
01032
01033
01045
01046
01047 xsh_d2_detect_order_param* xsh_parameters_d2_detect_order_get(
01048 const char* recipe_id, cpl_parameterlist* list)
01049 {
01050 xsh_d2_detect_order_param* result = NULL;
01051
01052
01053 XSH_ASSURE_NOT_NULL( list);
01054
01055
01056 XSH_MALLOC( result, xsh_d2_detect_order_param, 1);
01057
01058
01059 check( result->min_sn = xsh_parameters_get_double( list, recipe_id,
01060 "detectorder-d2-min-sn"));
01061
01062 cleanup:
01063 if(cpl_error_get_code() != CPL_ERROR_NONE){
01064 XSH_FREE( result);
01065 }
01066 return result;
01067 }
01068
01069
01077
01078 void xsh_parameters_background_create( const char* recipe_id,
01079 cpl_parameterlist* list)
01080 {
01081 char paramname[256];
01082 char recipename[256];
01083 cpl_parameter* p =NULL;
01084
01085 XSH_ASSURE_NOT_NULL(list);
01086
01087
01088
01089 check( xsh_parameters_new_int( list, recipe_id,
01090 "background-nb-y",
01091 100,
01092 "number of points of the grid in y direction"));
01093 check( xsh_parameters_new_int( list, recipe_id,
01094 "background-radius-x",
01095 2,
01096 "half size of the subwindow in x direction [pixel units]."));
01097 check( xsh_parameters_new_int( list, recipe_id,
01098 "background-radius-y",
01099 2,
01100 "half size of the subwindow in y direction [pixel units]."));
01101 #if 1
01102 check( xsh_parameters_new_double( list, recipe_id,
01103 "background-min-grid-frac",
01104 0.3333,
01105 "Minimum fraction of points used to calculate median to the grid"));
01106
01107 #endif
01108 check( xsh_parameters_new_double( list, recipe_id,
01109 "background-grid-frac",
01110 0.5,
01111 "maximum fraction of points rejected from the grid"));
01112
01113
01114
01115
01116
01117
01118
01119
01120 sprintf(recipename,"xsh.%s",recipe_id);
01121 sprintf(paramname,"%s.%s",recipename,"background-method");
01122
01123 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
01124
01125 check(p = cpl_parameter_new_enum(paramname,CPL_TYPE_STRING,
01126 "method adopted for background estimation:",
01127 recipename,"median",
01128 4,"median","minimum","poly","no"));
01129
01130 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
01131 "background-method"));
01132 check(cpl_parameterlist_append(list,p));
01133
01134 check( xsh_parameters_new_int( list, recipe_id,
01135 "background-smooth-x",
01136 -1,
01137 "Smoothing radius' half size in x direction [bin units]. "
01138 "If negative no smoothing is performed"));
01139
01140 check( xsh_parameters_new_int( list, recipe_id,
01141 "background-smooth-y",
01142 100,
01143 "Smoothing radius' half size in y direction [bin units]. "
01144 "If negative no smoothing is performed"));
01145
01146
01147 check( xsh_parameters_new_boolean( list, recipe_id,
01148 "background-debug",
01149 CPL_TRUE,
01150 "Generate a table containing the background sampling grid points"));
01151
01152 cleanup:
01153 return;
01154 }
01155
01163
01164
01165 xsh_background_param* xsh_parameters_background_get(const char* recipe_id,
01166 cpl_parameterlist* list)
01167 {
01168 xsh_background_param* result = NULL;
01169
01170
01171 XSH_ASSURE_NOT_NULL( list );
01172
01173
01174 XSH_MALLOC( result, xsh_background_param, 1);
01175
01176
01177 check(result->sampley = xsh_parameters_get_int(list,recipe_id,
01178 "background-nb-y"));
01179 check(result->radius_x = xsh_parameters_get_int(list,recipe_id,
01180 "background-radius-x"));
01181 check(result->radius_y = xsh_parameters_get_int(list,recipe_id,
01182 "background-radius-y"));
01183 #if 1
01184 check(result->min_frac_grid = xsh_parameters_get_double(list,recipe_id,
01185 "background-min-grid-frac"));
01186 #endif
01187 check(result->max_frac_grid = xsh_parameters_get_double(list,recipe_id,
01188 "background-grid-frac"));
01189 check(result->method = xsh_parameters_get_string(list,recipe_id,
01190 "background-method"));
01191 check(result->smooth_x = xsh_parameters_get_int(list,recipe_id,
01192 "background-smooth-x"));
01193 check(result->smooth_y = xsh_parameters_get_int(list,recipe_id,
01194 "background-smooth-y"));
01195 check(result->debug = xsh_parameters_get_boolean(list,recipe_id,
01196 "background-debug"));
01197
01198 cleanup:
01199 if(cpl_error_get_code() != CPL_ERROR_NONE){
01200 XSH_FREE( result);
01201 }
01202 return result;
01203 }
01204
01205
01214
01215
01216 void xsh_parameters_detect_arclines_create(const char* recipe_id,
01217 cpl_parameterlist* list, xsh_detect_arclines_param p)
01218 {
01219 const char *method_string = NULL;
01220
01221 XSH_ASSURE_NOT_NULL(list);
01222
01223
01224 check( xsh_parameters_new_int(list,recipe_id,
01225 "detectarclines-fit-window-half-size",
01226 p.fit_window_hsize,
01227 "Half window size (HWS) in pixels for the line 2D fitting window"\
01228 " (total window size = 2*HWS+1)"));
01229
01230 check( xsh_parameters_new_int(list,recipe_id,
01231 "detectarclines-search-window-half-size",
01232 p.search_window_hsize,
01233 "Half window size (HWS) in pixels for the line search box around "\
01234 "the expected position (total window size = 2*HWS+1) [bin units]"));
01235
01236 check( xsh_parameters_new_int(list,recipe_id,
01237 "detectarclines-running-median-half-size",
01238 p.running_median_hsize,
01239 "Half window size in pixels (HWS) for the running median box"));
01240
01241 check( xsh_parameters_new_int( list, recipe_id,
01242 "detectarclines-wavesol-deg-lambda",
01243 p.wavesol_deg_lambda,
01244 "Degree in lambda in the polynomial solution "\
01245 "X=f(lambda,order,slit) and Y=f(lambda,order,slit) (POLY mode)"));
01246
01247 check( xsh_parameters_new_int( list, recipe_id,
01248 "detectarclines-wavesol-deg-order",
01249 p.wavesol_deg_order,
01250 "Degree in order in the polynomial solution "\
01251 "X=f(lambda,order,slit) and Y=f(lambda,order,slit) (POLY mode)"));
01252
01253 check( xsh_parameters_new_int( list, recipe_id,
01254 "detectarclines-wavesol-deg-slit",
01255 p.wavesol_deg_slit,
01256 "Degree in slit in the polynomial solution "\
01257 "X=f(lambda,order,slit) and Y=f(lambda,order,slit) (POLY mode)"));
01258
01259 check(xsh_parameters_new_int(list, recipe_id,
01260 "detectarclines-ordertab-deg-y",
01261 p.ordertab_deg_y,
01262 "Degree in Y in the polynomial order tracing X=f(Y)")) ;
01263
01264 check( xsh_parameters_new_double( list, recipe_id,
01265 "detectarclines-min-sn",
01266 p.min_sn,
01267 "Minimum signal-to-noise ratio to filter lines"));
01268
01269 if ( p.find_center_method == XSH_GAUSSIAN_METHOD){
01270 method_string= "gaussian";
01271 }
01272 else{
01273 method_string = "barycenter";
01274 }
01275 check( xsh_parameters_new_string( list, recipe_id,
01276 "detectarclines-find-lines-center", method_string,
01277 "Method used to find the center of the lines" ));
01278 check( xsh_parameters_new_boolean( list, recipe_id,
01279 "detectarclines-mode-iterative", p.mode_iterative,
01280 "If TRUE the recipe doesn't crash if it doesn't succceeded "\
01281 "in producing order table."));
01282
01283
01284 cleanup:
01285 return;
01286 }
01287
01295
01296 xsh_detect_arclines_param* xsh_parameters_detect_arclines_get(
01297 const char* recipe_id, cpl_parameterlist* list)
01298 {
01299 xsh_detect_arclines_param* result = NULL;
01300 const char *method_string = NULL;
01301
01302
01303 XSH_ASSURE_NOT_NULL(list);
01304
01305
01306 XSH_MALLOC(result,xsh_detect_arclines_param,1);
01307
01308
01309 check( result->fit_window_hsize = xsh_parameters_get_int( list, recipe_id,
01310 "detectarclines-fit-window-half-size"));
01311 check( result->search_window_hsize = xsh_parameters_get_int( list,
01312 recipe_id, "detectarclines-search-window-half-size"));
01313 check( result->running_median_hsize = xsh_parameters_get_int( list,
01314 recipe_id, "detectarclines-running-median-half-size"));
01315 check( result->wavesol_deg_lambda = xsh_parameters_get_int( list, recipe_id,
01316 "detectarclines-wavesol-deg-lambda"));
01317 check( result->wavesol_deg_slit = xsh_parameters_get_int( list, recipe_id,
01318 "detectarclines-wavesol-deg-slit"));
01319 check( result->wavesol_deg_order = xsh_parameters_get_int( list, recipe_id,
01320 "detectarclines-wavesol-deg-order"));
01321 check( result->ordertab_deg_y = xsh_parameters_get_int( list, recipe_id,
01322 "detectarclines-ordertab-deg-y"));
01323 check( result->min_sn = xsh_parameters_get_double( list, recipe_id,
01324 "detectarclines-min-sn"));
01325 check( method_string = xsh_parameters_get_string( list, recipe_id,
01326 "detectarclines-find-lines-center"));
01327 if ( strcmp( method_string, "gaussian") == 0){
01328 result->find_center_method = XSH_GAUSSIAN_METHOD;
01329 }
01330 else{
01331 result->find_center_method = XSH_BARYCENTER_METHOD;
01332 }
01333 check( result->mode_iterative = xsh_parameters_get_boolean( list, recipe_id,
01334 "detectarclines-mode-iterative"));
01335
01336 cleanup:
01337 if(cpl_error_get_code() != CPL_ERROR_NONE){
01338 XSH_FREE(result);
01339 }
01340 return result;
01341 }
01342
01343
01355
01356 void xsh_parameters_clipping_detect_arclines_create(const char* recipe_id,
01357 cpl_parameterlist* list, xsh_clipping_param p)
01358 {
01359
01360 XSH_ASSURE_NOT_NULL(list);
01361
01362
01363 check(xsh_parameters_new_double( list, recipe_id,
01364 "detectarclines-clip-sigma",
01365 p.sigma,
01366 "Kappa value in sigma clipping during the polynomial solution "\
01367 "fit (POLY mode)"));
01368 check( xsh_parameters_new_int( list, recipe_id,
01369 "detectarclines-clip-niter",
01370 p.niter,
01371 "Number of iterations in sigma clipping during the polynomial "\
01372 "solution fit (POLY mode)"));
01373 check( xsh_parameters_new_double( list, recipe_id,
01374 "detectarclines-clip-frac",
01375 p.frac,
01376 "Minimal fractions of bad pixel allowed in sigma clipping during"\
01377 "the polynomial solution fit (POLY mode)"));
01378 cleanup:
01379 return;
01380 }
01381
01382
01394
01395 xsh_clipping_param* xsh_parameters_clipping_detect_arclines_get(
01396 const char* recipe_id, cpl_parameterlist* list)
01397 {
01398 xsh_clipping_param* result = NULL;
01399
01400
01401 XSH_ASSURE_NOT_NULL(list);
01402
01403
01404 XSH_MALLOC(result, xsh_clipping_param, 1);
01405
01406
01407 check(result->sigma = xsh_parameters_get_double(list,recipe_id,
01408 "detectarclines-clip-sigma"));
01409 check(result->niter = xsh_parameters_get_int(list,recipe_id,
01410 "detectarclines-clip-niter"));
01411 check(result->frac = xsh_parameters_get_double(list,recipe_id,
01412 "detectarclines-clip-frac"));
01413
01414 cleanup:
01415 if(cpl_error_get_code() != CPL_ERROR_NONE){
01416 XSH_FREE(result);
01417 }
01418 return result;
01419 }
01420
01421
01429
01430 void xsh_parameters_clipping_dcn_create(const char* recipe_id,
01431 cpl_parameterlist* list)
01432 {
01433
01434 XSH_ASSURE_NOT_NULL( list);
01435
01436
01437
01438 check( xsh_parameters_new_range_double(list,recipe_id,
01439 "detectcontinuum-clip-res-max", .3, .05, 2.,
01440 "Maximum allowed residual (before kappa-sigma clip)"));
01441
01442
01443 check(xsh_parameters_new_double(list,recipe_id,
01444 "detectcontinuum-clip-sigma", 5,
01445 "Kappa value in sigma clipping during order trace polynomial fit"));
01446
01447 check(xsh_parameters_new_int(list,recipe_id,
01448 "detectcontinuum-clip-niter", 5,
01449 "Number of iterations in sigma clipping during order trace "\
01450 "polynomial fit"));
01451
01452 check(xsh_parameters_new_double(list,recipe_id,
01453 "detectcontinuum-clip-frac", 0.4,
01454 "Minimal fractions of points accepted / total in sigma clipping"\
01455 "during order trace polynomial fit"));
01456
01457 cleanup:
01458 return;
01459 }
01460
01461
01473
01474 xsh_clipping_param* xsh_parameters_clipping_dcn_get(const char* recipe_id,
01475 cpl_parameterlist* list)
01476 {
01477 xsh_clipping_param* result = NULL;
01478
01479
01480 XSH_ASSURE_NOT_NULL(list);
01481
01482
01483 XSH_MALLOC(result, xsh_clipping_param, 1);
01484
01485
01486 check(result->res_max = xsh_parameters_get_double(list,recipe_id,
01487 "detectcontinuum-clip-res-max"));
01488 check(result->sigma = xsh_parameters_get_double(list,recipe_id,
01489 "detectcontinuum-clip-sigma"));
01490 check(result->niter = xsh_parameters_get_int(list,recipe_id,
01491 "detectcontinuum-clip-niter"));
01492 check(result->frac = xsh_parameters_get_double(list,recipe_id,
01493 "detectcontinuum-clip-frac"));
01494
01495 cleanup:
01496 if( cpl_error_get_code() != CPL_ERROR_NONE){
01497 cpl_free(result);
01498 result = NULL;
01499 }
01500 return result;
01501 }
01502
01503
01511 void xsh_parameters_detect_continuum_create( const char* recipe_id,
01512 cpl_parameterlist* list,
01513 xsh_detect_continuum_param par )
01514 {
01515
01516 XSH_ASSURE_NOT_NULL( list);
01517
01518
01519 check( xsh_parameters_new_int( list, recipe_id,
01520 "detectcontinuum-search-window-half-size",
01521 par.search_window,
01522 "Half window size in pixels for the 1D box to search for the "\
01523 "maximum in the cross-dispersion profile"));
01524
01525 check( xsh_parameters_new_int( list, recipe_id,
01526 "detectcontinuum-running-window-half-size",
01527 par.running_window,
01528 "Half window size for the running median box during the "\
01529 "search for the maximum in the cross-dispersion profile"));
01530
01531 check( xsh_parameters_new_int( list, recipe_id,
01532 "detectcontinuum-fit-window-half-size",
01533 par.fit_window,
01534 "Half window size for the fit of the cross-dispersion profile"));
01535
01536 check( xsh_parameters_new_double( list, recipe_id,
01537 "detectcontinuum-center-threshold-factor",
01538 par.fit_threshold,
01539 "Threshold factor applied to check that the flux at the fitted peak is "
01540 "higher than error."));
01541
01542 check( xsh_parameters_new_int( list, recipe_id,
01543 "detectcontinuum-ordertab-step-y",
01544 par.poly_step,
01545 "Step in Y for order centroid detection"));
01546
01547 check( xsh_parameters_new_int( list, recipe_id,
01548 "detectcontinuum-ordertab-deg-y",
01549 par.poly_degree,
01550 "Degree in Y in the polynomial order tracing X=f(Y)")) ;
01551
01552
01553
01554
01555
01556
01557
01558
01559
01560
01561
01562
01563
01564
01565
01566
01567
01568
01569
01570
01571
01572
01573
01574
01575
01576
01577
01578
01579
01580
01581
01582
01583 cleanup:
01584 return ;
01585 }
01586
01598 xsh_detect_continuum_param * xsh_parameters_detect_continuum_get(
01599 const char* recipe_id, cpl_parameterlist* list)
01600 {
01601 xsh_detect_continuum_param* result = NULL;
01602
01603
01604 XSH_ASSURE_NOT_NULL( list);
01605
01606
01607 XSH_MALLOC( result, xsh_detect_continuum_param, 1);
01608
01609
01610 check( result->search_window = xsh_parameters_get_int( list, recipe_id,
01611 "detectcontinuum-search-window-half-size"));
01612 check( result->fit_window = xsh_parameters_get_int( list, recipe_id,
01613 "detectcontinuum-fit-window-half-size"));
01614 check( result->fit_threshold = xsh_parameters_get_double( list, recipe_id,
01615 "detectcontinuum-center-threshold-factor"));
01616 check( result->running_window = xsh_parameters_get_int( list, recipe_id,
01617 "detectcontinuum-running-window-half-size"));
01618 check( result->poly_degree = xsh_parameters_get_int( list, recipe_id,
01619 "detectcontinuum-ordertab-deg-y"));
01620 check( result->poly_step = xsh_parameters_get_int( list, recipe_id,
01621 "detectcontinuum-ordertab-step-y"));
01622
01623
01624
01625
01626
01627
01628
01629
01630
01631
01632
01633
01634 cleanup:
01635 if(cpl_error_get_code() != CPL_ERROR_NONE){
01636 XSH_FREE(result);
01637 }
01638 return result;
01639 }
01640
01649
01650 void xsh_parameters_clipping_tilt_create(const char* recipe_id,
01651 cpl_parameterlist* list)
01652 {
01653
01654 XSH_ASSURE_NOT_NULL( list);
01655
01656
01657 check( xsh_parameters_new_double( list, recipe_id,
01658 "tilt-clip-kappa",
01659 2.5,
01660 "Multiple of sigma in sigma clipping for evaluate tilt"));
01661 check( xsh_parameters_new_int( list, recipe_id,
01662 "tilt-clip-niter",
01663 5,
01664 "Number of iterations in sigma clipping for evaluate tilt"));
01665 check( xsh_parameters_new_double( list, recipe_id,
01666 "tilt-clip-frac",
01667 0.7,
01668 "Minimal fractions of points accepted / total in sigma clipping for evaluate tilt"));
01669
01670 cleanup:
01671 return;
01672 }
01673
01681
01682 xsh_clipping_param * xsh_parameters_clipping_tilt_get(const char* recipe_id,
01683 cpl_parameterlist* list)
01684 {
01685 xsh_clipping_param* result = NULL;
01686
01687
01688 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
01689
01690
01691 check(result = (xsh_clipping_param*)(cpl_malloc(sizeof(xsh_clipping_param)))
01692 );
01693 assure (result != NULL, CPL_ERROR_ILLEGAL_OUTPUT,
01694 "Memory allocation failed!");
01695
01696
01697 check(result->sigma = xsh_parameters_get_double(list,recipe_id,
01698 "tilt-clip-kappa"));
01699 check(result->niter = xsh_parameters_get_int(list,recipe_id,
01700 "tilt-clip-niter"));
01701 check(result->frac = xsh_parameters_get_double(list,recipe_id,
01702 "tilt-clip-frac"));
01703
01704 cleanup:
01705 if(cpl_error_get_code() != CPL_ERROR_NONE){
01706 cpl_free(result);
01707 result = NULL;
01708 }
01709 return result;
01710 }
01711
01720
01721 void xsh_parameters_clipping_specres_create(const char* recipe_id,
01722 cpl_parameterlist* list)
01723 {
01724
01725 XSH_ASSURE_NOT_NULL( list);
01726
01727
01728 check( xsh_parameters_new_double( list, recipe_id,
01729 "specres-clip-kappa",
01730 2.5,
01731 "Multiple of sigma in sigma clipping for evaluate spectral resolution"));
01732 check( xsh_parameters_new_int( list, recipe_id,
01733 "specres-clip-niter",
01734 5,
01735 "Number of iterations in sigma clipping for evaluate spectral resolution"));
01736 check( xsh_parameters_new_double( list, recipe_id,
01737 "specres-clip-frac",
01738 0.7,
01739 "Minimal fractions of points accepted / total in sigma clipping for evaluate spectral resolution"));
01740
01741 cleanup:
01742 return;
01743 }
01744
01752
01753 xsh_clipping_param * xsh_parameters_clipping_specres_get(const char* recipe_id,
01754 cpl_parameterlist* list)
01755 {
01756 xsh_clipping_param* result = NULL;
01757
01758
01759 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
01760
01761
01762 check(result = (xsh_clipping_param*)(cpl_malloc(sizeof(xsh_clipping_param)))
01763 );
01764 assure (result != NULL, CPL_ERROR_ILLEGAL_OUTPUT,
01765 "Memory allocation failed!");
01766
01767
01768 check(result->sigma = xsh_parameters_get_double(list,recipe_id,
01769 "specres-clip-kappa"));
01770 check(result->niter = xsh_parameters_get_int(list,recipe_id,
01771 "specres-clip-niter"));
01772 check(result->frac = xsh_parameters_get_double(list,recipe_id,
01773 "specres-clip-frac"));
01774
01775 cleanup:
01776 if(cpl_error_get_code() != CPL_ERROR_NONE){
01777 cpl_free(result);
01778 result = NULL;
01779 }
01780 return result;
01781 }
01782
01783
01784 void xsh_parameters_wavecal_range_create(const char* recipe_id,
01785 cpl_parameterlist* list)
01786 {
01787
01788 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
01789
01790
01791
01792 check(xsh_parameters_new_range_int( list, recipe_id,
01793 "followarclines-search-window-half-size",
01794 WAVECAL_RANGE_DEFAULT, 1, 4096,
01795 "Half window size (HWS) in pixels (Y axis) of search window for each line."
01796 ));
01797
01798 cleanup:
01799 return;
01800 }
01801
01802 int xsh_parameters_wavecal_range_get( const char* recipe_id,
01803 cpl_parameterlist* list)
01804 {
01805 int result = 0;
01806
01807 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
01808
01809 check( result = xsh_parameters_get_int( list, recipe_id,
01810 "followarclines-search-window-half-size"));
01811
01812 cleanup:
01813 return result ;
01814 }
01815
01816 void xsh_parameters_wavecal_margin_create(const char* recipe_id,
01817 cpl_parameterlist* list)
01818 {
01819
01820 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
01821
01822
01823
01824 check(xsh_parameters_new_range_int( list, recipe_id,
01825 "followarclines-order-edges-mask",
01826 WAVECAL_MARGIN_DEFAULT, 0, 20,
01827 "Nb of pixels suppressed (X) from edges of search window."
01828 "" ));
01829
01830 cleanup:
01831 return;
01832 }
01833
01834 int xsh_parameters_wavecal_margin_get( const char* recipe_id,
01835 cpl_parameterlist* list)
01836 {
01837 int result = 0;
01838
01839 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
01840
01841 check( result = xsh_parameters_get_int( list, recipe_id,
01842 "followarclines-order-edges-mask"));
01843
01844 cleanup:
01845 return result ;
01846 }
01847
01848 void xsh_parameters_wavecal_s_n_create(const char* recipe_id,
01849 cpl_parameterlist* list)
01850 {
01851
01852 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
01853
01854
01855
01856 check(xsh_parameters_new_double( list, recipe_id,
01857 "followarclines-min-sn",
01858 15.,
01859 "Minimum Signal over Noise ratio at center to keep the line."
01860 ));
01861
01862 cleanup:
01863 return;
01864 }
01865
01866 double xsh_parameters_wavecal_s_n_get( const char* recipe_id,
01867 cpl_parameterlist* list)
01868 {
01869 int result = 0;
01870
01871 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
01872
01873 check( result = xsh_parameters_get_double( list, recipe_id,
01874 "followarclines-min-sn"));
01875
01876 cleanup:
01877 return result ;
01878 }
01879
01880
01881
01882 void xsh_parameters_use_model_create( const char * recipe_id,
01883 cpl_parameterlist * plist )
01884 {
01885 XSH_ASSURE_NOT_NULL( recipe_id ) ;
01886 XSH_ASSURE_NOT_NULL( plist ) ;
01887
01888 check( xsh_parameters_new_string( plist, recipe_id, "use-model", "no",
01889 "If 'no', use wavecal solution, otherwise use model. Default is 'no'" ) ) ;
01890 cleanup:
01891 return ;
01892 }
01893
01894
01895
01896 int xsh_parameters_use_model_get( const char * recipe_id,
01897 const cpl_parameterlist * plist )
01898 {
01899 char * yesno = NULL ;
01900
01901 XSH_ASSURE_NOT_NULL( recipe_id ) ;
01902 XSH_ASSURE_NOT_NULL( plist ) ;
01903
01904 yesno = xsh_parameters_get_string( plist, recipe_id, "use-model" ) ;
01905
01906 if ( strcmp( yesno, "yes" ) == 0 ) return 1 ;
01907 else return 0 ;
01908
01909 cleanup:
01910 return 0 ;
01911 }
01912
01913
01914
01915
01916
01917 void xsh_parameters_remove_crh_single_create( const char * recipe_id,
01918 cpl_parameterlist * plist,
01919 xsh_remove_crh_single_param p )
01920 {
01921 XSH_ASSURE_NOT_NULL( recipe_id ) ;
01922 XSH_ASSURE_NOT_NULL( plist ) ;
01923
01924 check(xsh_parameters_new_double(plist,recipe_id,
01925 "removecrhsingle-frac-max",
01926 p.crh_frac_max,
01927 "Max fraction of bad pixels allowed"));
01928 check(xsh_parameters_new_double(plist,recipe_id,
01929 "removecrhsingle-sigmalim",
01930 p.sigma_lim,
01931 "Poisson fluctuation threshold to flag CRHs (see van Dokkum, PASP,113,2001,p1420-27)"));
01932 check(xsh_parameters_new_double(plist,recipe_id,
01933 "removecrhsingle-flim",
01934 p.f_lim,
01935 "Minimum contrast between the Laplacian image and the fine structure image that a point must have to be flagged as CRH. (see van Dokkum, PASP,113,2001,p1420-27)"));
01936 check(xsh_parameters_new_int(plist,recipe_id,
01937 "removecrhsingle-niter",
01938 p.nb_iter,
01939 "Max number of iterations"));
01940
01941 cleanup:
01942 return ;
01943 }
01944
01945 xsh_remove_crh_single_param * xsh_parameters_remove_crh_single_get(
01946 const char* recipe_id,
01947 cpl_parameterlist* list)
01948 {
01949 xsh_remove_crh_single_param * result = NULL ;
01950
01951
01952 XSH_ASSURE_NOT_NULL(list);
01953
01954
01955 XSH_MALLOC( result, xsh_remove_crh_single_param, 1);
01956
01957
01958 check(result->crh_frac_max = xsh_parameters_get_double(list,recipe_id,
01959 "removecrhsingle-frac-max"));
01960 check(result->sigma_lim = xsh_parameters_get_double(list,recipe_id,
01961 "removecrhsingle-sigmalim"));
01962 check(result->f_lim = xsh_parameters_get_double(list,recipe_id,
01963 "removecrhsingle-flim"));
01964 check(result->nb_iter = xsh_parameters_get_int(list,recipe_id,
01965 "removecrhsingle-niter"));
01966
01967 cleanup:
01968 if(cpl_error_get_code() != CPL_ERROR_NONE){
01969 cpl_free(result);
01970 result = NULL;
01971 }
01972 return result;
01973
01974 }
01975
01976
01977
01978
01979
01980 typedef struct {
01981 const char * name ;
01982 int type ;
01983 } XSH_KERNEL_TYPE ;
01984
01985 static const XSH_KERNEL_TYPE xsh_ker_type[] = {
01986 {"tanh", CPL_KERNEL_TANH},
01987 {"sinc", CPL_KERNEL_SINC},
01988 {"sinc2", CPL_KERNEL_SINC2},
01989 {"lanczos", CPL_KERNEL_LANCZOS},
01990 {"hamming", CPL_KERNEL_HAMMING},
01991 {"hann", CPL_KERNEL_HANN},
01992 {NULL, 0}
01993 } ;
01994
01995 static void set_rectify_kernel_type( xsh_rectify_param *recpar )
01996 {
01997 const XSH_KERNEL_TYPE * pk = xsh_ker_type ;
01998
01999 for( ; pk->name != NULL ; pk++ )
02000 if ( strcasecmp( recpar->rectif_kernel, pk->name ) == 0 ) {
02001 recpar->kernel_type = pk->type ;
02002 return ;
02003 }
02004 recpar->kernel_type = CPL_KERNEL_DEFAULT ;
02005
02006 return ;
02007 }
02008
02009 static const char * get_ker_default( void )
02010 {
02011 const XSH_KERNEL_TYPE * pk = xsh_ker_type ;
02012
02013 for( ; pk->name != NULL ; pk++ )
02014 if ( pk->type == CPL_KERNEL_DEFAULT ) {
02015 return pk->name ;
02016 }
02017 return "unknown" ;
02018
02019 }
02020 void xsh_parameters_rectify_create( const char * recipe_id,
02021 cpl_parameterlist * plist,
02022 xsh_rectify_param p )
02023 {
02024 char ker_comment[256];
02025
02026 XSH_ASSURE_NOT_NULL( recipe_id ) ;
02027 XSH_ASSURE_NOT_NULL( plist ) ;
02028
02029 sprintf( ker_comment,
02030 "Name of the Interpolation Kernel Used. Possible values are"\
02031 " %s, tanh, sinc, sinc2, lanczos, hamming, hann\n ",get_ker_default());
02032
02033 check(xsh_parameters_new_string(plist,recipe_id,
02034 "rectify-kernel",
02035 p.rectif_kernel, ker_comment));
02036
02037 check(xsh_parameters_new_double(plist,recipe_id,
02038 "rectify-radius",
02039 p.rectif_radius,
02040 "Rectify Interpolation radius [bin units]"));
02041
02042 check(xsh_parameters_new_double(plist,recipe_id,
02043 "rectify-bin-lambda",
02044 p.rectif_bin_lambda,
02045 "Wavelength step in the output spectrum [nm]"));
02046
02047 check(xsh_parameters_new_double(plist,recipe_id,
02048 "rectify-bin-slit",
02049 p.rectif_bin_space,
02050 "Spatial step along the slit in the output spectrum [arcsec]"));
02051 check( xsh_parameters_new_boolean( plist, recipe_id,
02052 "rectify-full-slit",
02053 p.rectify_full_slit,
02054 "Use full slit if TRUE"));
02055 check( xsh_parameters_new_boolean( plist, recipe_id,
02056 "rectify-conserve-flux", p.conserve_flux,
02057 "Use flux conservation if TRUE"));
02058
02059
02060
02061
02062
02063
02064
02065
02066
02067
02068
02069
02070 cleanup:
02071 return ;
02072 }
02073
02074 int xsh_parameters_rectify_fast_get( const char* recipe_id,
02075 cpl_parameterlist* list)
02076 {
02077 int result = 0 ;
02078
02079
02080 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
02081
02082 check( result = xsh_parameters_get_boolean( list,
02083 recipe_id, "rectify-fast"));
02084
02085 cleanup:
02086 return result ;
02087 }
02088
02089 xsh_rectify_param * xsh_parameters_rectify_get( const char* recipe_id,
02090 cpl_parameterlist* list)
02091 {
02092 xsh_rectify_param * result = NULL ;
02093 char *p ;
02094
02095
02096 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
02097
02098
02099 check(result = (xsh_rectify_param *)(cpl_malloc(
02100 sizeof(xsh_rectify_param))) );
02101 assure (result != NULL, CPL_ERROR_ILLEGAL_OUTPUT,
02102 "Memory allocation failed!");
02103
02104
02105 check(p = xsh_parameters_get_string(list,recipe_id,
02106 "rectify-kernel"));
02107 strcpy( result->rectif_kernel, p ) ;
02108 check(result->rectif_radius = xsh_parameters_get_double(list,recipe_id,
02109 "rectify-radius"));
02110 check(result->rectif_bin_lambda = xsh_parameters_get_double(list,recipe_id,
02111 "rectify-bin-lambda"));
02112 check(result->rectif_bin_space = xsh_parameters_get_double(list,recipe_id,
02113 "rectify-bin-slit"));
02114 check( result->rectify_full_slit = xsh_parameters_get_boolean( list,
02115 recipe_id,
02116 "rectify-full-slit")) ;
02117 check( result->conserve_flux = xsh_parameters_get_boolean( list,
02118 recipe_id, "rectify-conserve-flux"));
02119
02120
02121
02122
02123
02124 set_rectify_kernel_type( result ) ;
02125
02126 cleanup:
02127 if(cpl_error_get_code() != CPL_ERROR_NONE){
02128 cpl_free(result);
02129 result = NULL;
02130 }
02131 return result;
02132 }
02133
02134 void
02135 xsh_parameters_compute_response_create( const char * recipe_id,
02136 cpl_parameterlist * plist,
02137 xsh_compute_response_param p )
02138 {
02139
02140 assure(plist != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
02141
02142 check(xsh_parameters_new_double(plist,recipe_id,
02143 "compute-response-lambda-step",
02144 p.lambda_bin,
02145 "Compute Response Interpolation Lambda Step"));
02146
02147 cleanup:
02148 return ;
02149 }
02150
02151 xsh_compute_response_param *
02152 xsh_parameters_compute_response_get( const char * recipe_id,
02153 cpl_parameterlist * list)
02154 {
02155 xsh_compute_response_param * result = NULL ;
02156
02157 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
02158
02159
02160 check(result = (xsh_compute_response_param *)(cpl_malloc(
02161 sizeof(xsh_compute_response_param))) );
02162 assure (result != NULL, CPL_ERROR_ILLEGAL_OUTPUT,
02163 "Memory allocation failed!");
02164
02165
02166 check(result->lambda_bin =
02167 xsh_parameters_get_double(list,recipe_id,
02168 "compute-response-lambda-step"));
02169
02170 cleanup:
02171 if(cpl_error_get_code() != CPL_ERROR_NONE){
02172 cpl_free(result);
02173 result = NULL;
02174 }
02175 return result;
02176
02177 }
02178
02179
02180
02181
02182 void xsh_parameters_localize_obj_create( const char * recipe_id,
02183 cpl_parameterlist * plist, xsh_localize_obj_param p)
02184 {
02185 XSH_ASSURE_NOT_NULL( recipe_id);
02186 XSH_ASSURE_NOT_NULL( plist);
02187
02188 check( xsh_parameters_new_string( plist, recipe_id,
02189 "localize-method",
02190 LOCALIZE_METHOD_PRINT(p.method),
02191 "Localization method (MANUAL, MAXIMUM, GAUSSIAN) used to detect "\
02192 "the object centroid and height on the slit"));
02193
02194 check( xsh_parameters_new_int( plist, recipe_id,
02195 "localize-chunk-nb",
02196 p.loc_chunk_nb,
02197 "Number of chunks in the full spectrum to localize the object"));
02198 check( xsh_parameters_new_double( plist, recipe_id,
02199 "localize-thresh",
02200 p.loc_thresh,
02201 "Threshold relative to the peak intensity below which the edges "\
02202 "of the object are detected for MAXIMUM localization"));
02203 check( xsh_parameters_new_int( plist, recipe_id,
02204 "localize-deg-lambda",
02205 p.loc_deg_poly,
02206 "Degree in lambda in the localization polynomial expression "\
02207 "slit=f(lambda), used only for MAXIMUM and GAUSSIAN"));
02208
02209 if (strcmp(recipe_id,"xsh_scired_slit_nod")==0){
02210 check( xsh_parameters_new_double( plist, recipe_id,
02211 "localize-slit-position",
02212 p.slit_position,
02213 "Object position on the slit for MANUAL localization [arcsec]. It refers to the object position in the first frame of the nodding sequence"));
02214 }
02215 else {
02216 check( xsh_parameters_new_double( plist, recipe_id,
02217 "localize-slit-position",
02218 p.slit_position,
02219 "Object position on the slit for MANUAL localization [arcsec]"));
02220 }
02221 check( xsh_parameters_new_double( plist, recipe_id,
02222 "localize-slit-hheight",
02223 p.slit_hheight,
02224 "Object half height on the slit for MANUAL localization [arcsec]"));
02225 check( xsh_parameters_new_double( plist, recipe_id,
02226 "localize-kappa",
02227 p.kappa,
02228 "Kappa value for sigma clipping in the localization "\
02229 "polynomial fit"));
02230 check( xsh_parameters_new_int( plist, recipe_id,
02231 "localize-niter",
02232 p.niter,
02233 "Number of iterations for sigma clipping in the localization "\
02234 "polynomial fit"));
02235
02236 check(xsh_parameters_new_boolean( plist, recipe_id,
02237 "localize-use-skymask", p.use_skymask,
02238 "TRUE if we want to mask sky lines using SKY_LINE_LIST file."));
02239
02240 cleanup:
02241 return ;
02242 }
02243
02244 xsh_localize_obj_param* xsh_parameters_localize_obj_get(
02245 const char* recipe_id, cpl_parameterlist* list)
02246 {
02247 xsh_localize_obj_param * result = NULL ;
02248 const char* par_method = NULL;
02249
02250
02251 XSH_ASSURE_NOT_NULL(list);
02252
02253
02254 XSH_MALLOC( result, xsh_localize_obj_param, 1);
02255
02256
02257 check( result->loc_chunk_nb = xsh_parameters_get_int( list,recipe_id,
02258 "localize-chunk-nb"));
02259 check( result->loc_thresh = xsh_parameters_get_double( list,recipe_id,
02260 "localize-thresh"));
02261 check( result->loc_deg_poly = xsh_parameters_get_int( list,recipe_id,
02262 "localize-deg-lambda"));
02263 check( par_method = xsh_parameters_get_string( list, recipe_id,
02264 "localize-method"));
02265 if ( strcmp( LOCALIZE_METHOD_PRINT(LOC_MANUAL_METHOD), par_method) == 0){
02266 result->method = LOC_MANUAL_METHOD;
02267 }
02268 else if (strcmp( LOCALIZE_METHOD_PRINT(LOC_MAXIMUM_METHOD), par_method) == 0){
02269 result->method = LOC_MAXIMUM_METHOD;
02270 }
02271 else if (strcmp( LOCALIZE_METHOD_PRINT(LOC_GAUSSIAN_METHOD), par_method) == 0){
02272 result->method = LOC_GAUSSIAN_METHOD;
02273 }
02274 else {
02275 xsh_error_msg("WRONG parameter localize-method %s",par_method);
02276 }
02277 check( result->slit_position = xsh_parameters_get_double( list, recipe_id,
02278 "localize-slit-position"));
02279 check( result->slit_hheight = xsh_parameters_get_double( list, recipe_id,
02280 "localize-slit-hheight"));
02281 check( result->kappa = xsh_parameters_get_double( list, recipe_id,
02282 "localize-kappa"));
02283 check( result->niter = xsh_parameters_get_int( list, recipe_id,
02284 "localize-niter"));
02285 check( result->use_skymask = xsh_parameters_get_boolean( list, recipe_id,
02286 "localize-use-skymask"));
02287
02288 cleanup:
02289 if(cpl_error_get_code() != CPL_ERROR_NONE){
02290 XSH_FREE( result);
02291 }
02292 return result;
02293
02294 }
02295
02296
02297
02298
02299
02300
02301
02302 void xsh_parameters_extract_create( const char * recipe_id,
02303 cpl_parameterlist * plist,
02304 xsh_extract_param p,
02305 enum extract_method method)
02306 {
02307 XSH_ASSURE_NOT_NULL( recipe_id);
02308 XSH_ASSURE_NOT_NULL( plist);
02309
02310 check( xsh_parameters_new_string( plist, recipe_id,
02311 "extract-method", EXTRACT_METHOD_PRINT(method),
02312 "Method used for extraction (LOCALIZATION, NOD)"));
02313
02314 cleanup:
02315 return ;
02316 }
02317
02318 xsh_extract_param * xsh_parameters_extract_get(
02319 const char* recipe_id, cpl_parameterlist* list)
02320 {
02321 xsh_extract_param *result = NULL ;
02322 const char *par_method = NULL;
02323
02324
02325 XSH_ASSURE_NOT_NULL( recipe_id);
02326 XSH_ASSURE_NOT_NULL( list);
02327
02328
02329 XSH_MALLOC( result, xsh_extract_param, 1);
02330
02331
02332 check( par_method = xsh_parameters_get_string( list, recipe_id,
02333 "extract-method"));
02334 if ( strcmp( EXTRACT_METHOD_PRINT(LOCALIZATION_METHOD), par_method) == 0){
02335 result->method = LOCALIZATION_METHOD;
02336 }
02337 else if (strcmp( EXTRACT_METHOD_PRINT(FULL_METHOD), par_method) == 0){
02338 result->method = FULL_METHOD;
02339 }
02340 else if (strcmp( EXTRACT_METHOD_PRINT(NOD_METHOD), par_method) == 0){
02341 result->method = NOD_METHOD;
02342 }
02343 else {
02344 xsh_error_msg("WRONG parameter extract-method %s",par_method);
02345 }
02346
02347 cleanup:
02348 if(cpl_error_get_code() != CPL_ERROR_NONE){
02349 cpl_free(result);
02350 result = NULL;
02351 }
02352 return result;
02353 }
02354
02355
02356
02357
02358
02359
02360 void xsh_parameters_subtract_sky_single_create( const char * recipe_id,
02361 cpl_parameterlist * plist,
02362 xsh_subtract_sky_single_param p )
02363 {
02364 XSH_ASSURE_NOT_NULL( recipe_id);
02365 XSH_ASSURE_NOT_NULL( plist);
02366
02367 check(xsh_parameters_new_boolean( plist, recipe_id,
02368 "sky-subtract", TRUE,
02369 "TRUE to use subtract sky single."));
02370
02371 check( xsh_parameters_new_int( plist, recipe_id,
02372 "sky-bspline-nbkpts-first",
02373 p.nbkpts1,
02374 "Nb of break points for Bezier curve fitting (without localization)"));
02375 check( xsh_parameters_new_int( plist,recipe_id,
02376 "sky-bspline-nbkpts-second",
02377 p.nbkpts2,
02378 "Nb of break points for Bezier curve fitting (with localization)"));
02379
02380 check( xsh_parameters_new_int( plist, recipe_id,
02381 "sky-bspline-order",
02382 p.bezier_spline_order,
02383 "Bezier spline order"));
02384
02385 check( xsh_parameters_new_int( plist, recipe_id,
02386 "sky-bspline-niter",
02387 p.niter,
02388 "Nb of iterations"));
02389
02390 check( xsh_parameters_new_double( plist, recipe_id,
02391 "sky-bspline-kappa",
02392 p.kappa,
02393 "Kappa value used to kappa-sigma-clip object"));
02394
02395 check( xsh_parameters_new_double( plist, recipe_id,
02396 "sky-bspline-ron",
02397 p.ron,
02398 "Detector RON (if -1 is automatically set)"));
02399
02400
02401 check( xsh_parameters_new_double( plist, recipe_id,
02402 "sky-bspline-gain",
02403 p.gain,
02404 "Detector gain (if -1 is automatically set)"));
02405
02406 check( xsh_parameters_new_string( plist, recipe_id,
02407 "sky-method",
02408 SKY_METHOD_PRINT(p.method), "Sky subtract Method (BSPLINE, MEDIAN)"));
02409
02410 check( xsh_parameters_new_string( plist, recipe_id,
02411 "bspline-sampling",
02412 BSPLINE_SAMPLING_PRINT(p.bspline_sampling), "BSPLINE sampling. UNIFORM-uses the user defined nbkpts value, corrected for binning, for all orders. FINE: multiplies the user defined nbkpts value, corrected for binning, by a hard coded coefficient optimized on each arm-order)"));
02413
02414 check( xsh_parameters_new_int( plist, recipe_id,
02415 "sky-median-hsize",
02416 p.median_hsize , "Half size of the running median. If sky-method=MEDIAN "));
02417
02418 check( xsh_parameters_new_double( plist, recipe_id,
02419 "sky-slit-edges-mask",
02420 p.slit_edges_mask,
02421 "Size of edges mask in arcsec"));
02422
02423 check( xsh_parameters_new_double( plist, recipe_id,
02424 "sky-position1",
02425 p.pos1,
02426 "Central position of the sky window #1 [arcsec]"));
02427
02428 check( xsh_parameters_new_double( plist, recipe_id,
02429 "sky-hheight1",
02430 p.hheight1,
02431 "Half size of sky window #1 [arcsec]"));
02432
02433 check( xsh_parameters_new_double( plist, recipe_id,
02434 "sky-position2",
02435 p.pos2,
02436 "Central position of the sky window #2 [arcsec]"));
02437
02438 check( xsh_parameters_new_double( plist, recipe_id,
02439 "sky-hheight2",
02440 p.hheight2,
02441 "Half size of the sky window #2 [arcsec]"));
02442
02443 cleanup:
02444 return ;
02445 }
02446
02447 xsh_subtract_sky_single_param* xsh_parameters_subtract_sky_single_get(
02448 const char* recipe_id, cpl_parameterlist* list)
02449 {
02450 xsh_subtract_sky_single_param *result = NULL ;
02451 const char* par_method = NULL;
02452 const char* bspline_sampling = NULL;
02453
02454
02455 XSH_ASSURE_NOT_NULL( recipe_id);
02456 XSH_ASSURE_NOT_NULL( list);
02457
02458
02459 XSH_MALLOC( result, xsh_subtract_sky_single_param, 1);
02460
02461
02462 check( result->nbkpts1 = xsh_parameters_get_int( list, recipe_id,
02463 "sky-bspline-nbkpts-first"));
02464 check( result->nbkpts2 = xsh_parameters_get_int( list, recipe_id,
02465 "sky-bspline-nbkpts-second"));
02466 check( result->bezier_spline_order = xsh_parameters_get_int( list, recipe_id,
02467 "sky-bspline-order"));
02468 check( result->niter = xsh_parameters_get_int( list, recipe_id,
02469 "sky-bspline-niter"));
02470 check( result->kappa = xsh_parameters_get_double( list, recipe_id,
02471 "sky-bspline-kappa"));
02472 check( result->ron = xsh_parameters_get_double( list, recipe_id,
02473 "sky-bspline-ron"));
02474 check( result->gain = xsh_parameters_get_double( list, recipe_id,
02475 "sky-bspline-gain"));
02476 check( par_method = xsh_string_toupper(xsh_parameters_get_string(list,
02477 recipe_id,
02478 "sky-method")
02479 ));
02480
02481
02482 if ( strcmp( SKY_METHOD_PRINT(BSPLINE_METHOD), par_method) == 0){
02483 result->method = BSPLINE_METHOD;
02484 }
02485 else if (strcmp( SKY_METHOD_PRINT(MEDIAN_METHOD), par_method) == 0){
02486 result->method = MEDIAN_METHOD;
02487 }
02488 else {
02489 xsh_error_msg("WRONG parameter sky_method %s",par_method);
02490 }
02491
02492 check( bspline_sampling = xsh_parameters_get_string( list, recipe_id,
02493 "bspline-sampling"));
02494 if ( strcmp( BSPLINE_SAMPLING_PRINT(UNIFORM), bspline_sampling) == 0){
02495 result->bspline_sampling = BSPLINE_METHOD;
02496 }
02497 else if (strcmp( BSPLINE_SAMPLING_PRINT(FINE), bspline_sampling) == 0){
02498 result->bspline_sampling = FINE;
02499 }
02500 else {
02501 xsh_error_msg("WRONG parameter bspline-sampling %s",bspline_sampling);
02502 }
02503
02504
02505
02506 check( result->median_hsize = xsh_parameters_get_int( list, recipe_id,
02507 "sky-median-hsize"));
02508 check( result->slit_edges_mask = xsh_parameters_get_double( list,
02509 recipe_id,
02510 "sky-slit-edges-mask"));
02511
02512 check( result->pos1 = xsh_parameters_get_double( list,
02513 recipe_id,
02514 "sky-position1"));
02515 check( result->hheight1 = xsh_parameters_get_double( list,
02516 recipe_id,
02517 "sky-hheight1"));
02518 check( result->pos2 = xsh_parameters_get_double( list,
02519 recipe_id,
02520 "sky-position2"));
02521 check( result->hheight2 = xsh_parameters_get_double( list,
02522 recipe_id,
02523 "sky-hheight2"));
02524
02525 cleanup:
02526 if(cpl_error_get_code() != CPL_ERROR_NONE){
02527 cpl_free(result);
02528 result = NULL;
02529 }
02530 return result;
02531 }
02532
02533 int xsh_parameters_subtract_sky_single_get_true( const char* recipe_id,
02534 cpl_parameterlist* list)
02535 {
02536 bool result = FALSE;
02537
02538 check( result = xsh_parameters_get_boolean( list, recipe_id,
02539 "sky-subtract"));
02540
02541 cleanup:
02542 return result ;
02543 }
02544
02545
02546 void xsh_parameters_dosky_domap_get( const char *recipe_id,
02547 cpl_parameterlist *list,
02548 cpl_frame* wavemap_frame,
02549 cpl_frame* slitmap_frame,
02550 int *dosky, int *domap)
02551 {
02552 bool sub_sky=FALSE;
02553 bool computemap=FALSE;
02554
02555 XSH_ASSURE_NOT_NULL( dosky);
02556 XSH_ASSURE_NOT_NULL( domap);
02557
02558 check( sub_sky = xsh_parameters_subtract_sky_single_get_true( recipe_id,
02559 list));
02560 check( computemap = xsh_parameters_get_boolean( list, recipe_id,
02561 "compute-map"));
02562
02563
02564
02565
02566
02567 if ( (sub_sky && !computemap) &&
02568 (wavemap_frame == NULL || slitmap_frame == NULL)
02569 ){
02570 xsh_msg_warning( "Parameters sky-subtract and compute-map are not compatible, compute-map has been forced to TRUE");
02571 computemap = TRUE;
02572 }
02573
02574 *dosky = sub_sky;
02575 *domap = computemap;
02576
02577 cleanup:
02578 return;
02579 }
02580
02581
02582 int xsh_parameters_subtract_sky_single_get_first( const char* recipe_id,
02583 cpl_parameterlist* list)
02584 {
02585 int result = 0 ;
02586
02587
02588 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
02589
02590
02591 check(result = xsh_parameters_get_int( list, recipe_id,
02592 "sky-bspline-nbkpts-first"));
02593
02594 cleanup:
02595 return result;
02596
02597 }
02598
02599 int xsh_parameters_subtract_sky_single_get_second( const char* recipe_id,
02600 cpl_parameterlist* list)
02601 {
02602 int result = 0 ;
02603
02604
02605 XSH_ASSURE_NOT_NULL( list);
02606
02607
02608 check(result = xsh_parameters_get_int( list, recipe_id,
02609 "sky-bspline-nbkpts-second"));
02610
02611 cleanup:
02612 return result;
02613 }
02614
02615
02616 int xsh_parameters_subtract_sky_single_get_niter( const char* recipe_id,
02617 cpl_parameterlist* list)
02618 {
02619 int result = 0 ;
02620
02621
02622 XSH_ASSURE_NOT_NULL( list);
02623
02624
02625 check(result = xsh_parameters_get_int( list, recipe_id,
02626 "sky-bspline-niter"));
02627
02628 cleanup:
02629 return result;
02630 }
02631
02632
02633
02634 double xsh_parameters_subtract_sky_single_get_kappa( const char* recipe_id,
02635 cpl_parameterlist* list)
02636 {
02637 double result = 0 ;
02638
02639
02640 XSH_ASSURE_NOT_NULL( list);
02641
02642
02643 check(result = xsh_parameters_get_double( list, recipe_id,
02644 "sky-bspline-kappa"));
02645
02646 cleanup:
02647 return result;
02648 }
02649
02650
02651 double xsh_parameters_subtract_sky_single_get_ron( const char* recipe_id,
02652 cpl_parameterlist* list)
02653 {
02654 double result = 0 ;
02655
02656
02657 XSH_ASSURE_NOT_NULL( list);
02658
02659
02660 check(result = xsh_parameters_get_double( list, recipe_id,
02661 "sky-bspline-ron"));
02662
02663 cleanup:
02664 return result;
02665 }
02666
02667 double xsh_parameters_subtract_sky_single_get_gain( const char* recipe_id,
02668 cpl_parameterlist* list)
02669 {
02670 double result = 0 ;
02671
02672
02673 XSH_ASSURE_NOT_NULL( list);
02674
02675
02676 check(result = xsh_parameters_get_double( list, recipe_id,
02677 "sky-bspline-gain"));
02678
02679 cleanup:
02680 return result;
02681 }
02682
02683
02684
02685
02686
02687
02688 void xsh_parameters_merge_ord_create( const char * recipe_id,
02689 cpl_parameterlist * plist,
02690 int p )
02691 {
02692
02693 XSH_ASSURE_NOT_NULL( recipe_id);
02694 XSH_ASSURE_NOT_NULL( plist);
02695
02696 check(xsh_parameters_new_int( plist, recipe_id, "mergeord-method",
02697 p, "Method for combining overlapping orders "\
02698 "(0 = WEIGHTED with the errors, 1 = MEAN)"));
02699
02700 cleanup:
02701 return;
02702 }
02703
02704 xsh_merge_param* xsh_parameters_merge_ord_get( const char* recipe_id,
02705 cpl_parameterlist* list)
02706 {
02707 xsh_merge_param *result = NULL;
02708
02709
02710 XSH_ASSURE_NOT_NULL( recipe_id);
02711 XSH_ASSURE_NOT_NULL( list);
02712
02713
02714 XSH_MALLOC( result, xsh_merge_param, 1);
02715
02716
02717 check( result->method = xsh_parameters_get_int( list, recipe_id,
02718 "mergeord-method"));
02719
02720 cleanup:
02721 if(cpl_error_get_code() != CPL_ERROR_NONE){
02722 XSH_FREE( result);
02723 }
02724 return result;
02725 }
02726
02727
02728
02729
02730
02731 void xsh_parameters_optimal_extract_create( const char * recipe_id,
02732 cpl_parameterlist * plist,
02733 int p )
02734 {
02735 XSH_ASSURE_NOT_NULL( recipe_id ) ;
02736 XSH_ASSURE_NOT_NULL( plist ) ;
02737
02738 check(xsh_parameters_new_double(plist,recipe_id,
02739 "optimal_extract_kappa",
02740 p,
02741 "Pixels with values > kappa*RMS are ignored. If negative no rejection."));
02742
02743 cleanup:
02744 return ;
02745 }
02746
02747 double xsh_parameters_optimal_extract_get_kappa( const char* recipe_id,
02748 cpl_parameterlist* list)
02749 {
02750 double result = 0 ;
02751
02752
02753 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
02754
02755
02756 check(result = xsh_parameters_get_double(list,recipe_id,
02757 "optimal_extract_kappa"));
02758
02759 cleanup:
02760 return result;
02761
02762 }
02763
02764
02775
02776 void xsh_parameters_dispersol_create(const char* recipe_id,
02777 cpl_parameterlist* list, xsh_dispersol_param p)
02778 {
02779
02780 XSH_ASSURE_NOT_NULL(list);
02781
02782
02783
02784 check(xsh_parameters_new_int(list,recipe_id,"dispersol-deg-x",
02785 p.deg_x, "Degree in X in the polynomial dispersion solution "\
02786 "lambda=f(X,Y) and slit=f(X,Y)"));
02787
02788 check(xsh_parameters_new_int(list,recipe_id,"dispersol-deg-y",
02789 p.deg_y, "Degree in Y in the polynomial dispersion solution "\
02790 "lambda=f(X,Y) and slit=f(X,Y)"));
02791
02792 cleanup:
02793 return;
02794 }
02795
02796
02797
02808
02809 xsh_dispersol_param* xsh_parameters_dispersol_get( const char* recipe_id,
02810 cpl_parameterlist* list)
02811 {
02812 xsh_dispersol_param* result = NULL;
02813
02814
02815 XSH_ASSURE_NOT_NULL(list);
02816
02817
02818 XSH_MALLOC(result, xsh_dispersol_param, 1);
02819
02820
02821 check(result->deg_x = xsh_parameters_get_int(list, recipe_id,
02822 "dispersol-deg-x"));
02823 check(result->deg_y = xsh_parameters_get_int(list, recipe_id,
02824 "dispersol-deg-y"));
02825
02826 cleanup:
02827 if(cpl_error_get_code() != CPL_ERROR_NONE){
02828 XSH_FREE(result);
02829 }
02830 return result;
02831 }
02832
02833
02841
02842 void xsh_parameters_combine_nod_create(const char * recipe_id,
02843 cpl_parameterlist * list,
02844 xsh_combine_nod_param p)
02845 {
02846
02847 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
02848
02849
02850 check(xsh_parameters_new_int(list,recipe_id,"combinenod-min", p.nod_min,
02851 "minimum NS size of resulting frame in pixels"));
02852 check(xsh_parameters_new_boolean(list,recipe_id,"combinenod-clip",
02853 p.nod_clip,
02854 "TRUE if do sigma clipping")) ;
02855
02856 check(xsh_parameters_new_double(list,recipe_id,"combinenod-clip-sigma",
02857 p.nod_clip_sigma,
02858 "Kappa value in sigma clipping for combining nodded frames"));
02859
02860 check(xsh_parameters_new_int(list,recipe_id,"combinenod-clip-niter",
02861 p.nod_clip_niter,
02862 "Number of iterations in sigma clipping for combining nodded frames"));
02863
02864 check(xsh_parameters_new_double(list,recipe_id,"combinenod-clip-diff",
02865 p.nod_clip_diff,
02866 "Minimal change in sigma in sigma clipping for combining nodded frames"));
02867
02868 check( xsh_parameters_new_string( list, recipe_id,
02869 "combinenod-throwlist", p.throwname,
02870 "Name of ascii file containing the list of throw shifts with respect to the first exposure"));
02871
02872 check( xsh_parameters_new_string( list, recipe_id,
02873 "combinenod-method", COMBINE_METHOD_PRINT( p.method),
02874 "Combination method for nodded frames (MEDIAN, MEAN)"));
02875
02876 cleanup:
02877 return;
02878 }
02879
02880
02888
02889 xsh_combine_nod_param * xsh_parameters_combine_nod_get(const char* recipe_id,
02890 cpl_parameterlist* list)
02891 {
02892 xsh_combine_nod_param* result = NULL;
02893 const char *par_method = NULL;
02894
02895
02896 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
02897
02898
02899 check(result = (xsh_combine_nod_param *)(cpl_malloc(sizeof(xsh_combine_nod_param)))
02900 );
02901 assure (result != NULL, CPL_ERROR_ILLEGAL_OUTPUT,
02902 "Memory allocation failed!");
02903
02904
02905
02906 check(result->nod_min = xsh_parameters_get_int(list,recipe_id,
02907 "combinenod-min"));
02908 check(result->nod_clip = xsh_parameters_get_boolean(list,recipe_id,
02909 "combinenod-clip"));
02910 check(result->nod_clip_sigma = xsh_parameters_get_double(list,recipe_id,
02911 "combinenod-clip-sigma"));
02912 check(result->nod_clip_niter = xsh_parameters_get_int(list,recipe_id,
02913 "combinenod-clip-niter"));
02914 check(result->nod_clip_diff = xsh_parameters_get_double(list,recipe_id,
02915 "combinenod-clip-diff"));
02916 check(result->throwname = xsh_parameters_get_string(list,recipe_id,
02917 "combinenod-throwlist"));
02918 check( par_method = xsh_parameters_get_string( list, recipe_id,
02919 "combinenod-method"));
02920 if ( strcmp( COMBINE_METHOD_PRINT( COMBINE_MEAN_METHOD), par_method) == 0){
02921 result->method = COMBINE_MEAN_METHOD;
02922 }
02923 else if (strcmp( COMBINE_METHOD_PRINT( COMBINE_MEDIAN_METHOD), par_method) == 0){
02924 result->method = COMBINE_MEDIAN_METHOD;
02925 }
02926 else {
02927 xsh_error_msg("WRONG parameter combinenod-method %s",par_method);
02928 }
02929
02930
02931 cleanup:
02932 if(cpl_error_get_code() != CPL_ERROR_NONE){
02933 cpl_free(result);
02934 result = NULL;
02935 }
02936 return result;
02937 }
02938
02949
02950 void xsh_parameters_opt_extract_create( const char * recipe_id,
02951 cpl_parameterlist* list, xsh_opt_extract_param p)
02952 {
02953
02954 XSH_ASSURE_NOT_NULL( recipe_id);
02955 XSH_ASSURE_NOT_NULL( list);
02956
02957
02958 check( xsh_parameters_new_int( list, recipe_id,
02959 "optextract-oversample", p.oversample,
02960 "Oversample factor for the science image"));
02961 check( xsh_parameters_new_int( list, recipe_id,
02962 "optextract-box-half-size", p.box_hsize,
02963 "Extraction box [pixel]"));
02964 check( xsh_parameters_new_int( list, recipe_id,
02965 "optextract-chunk-size", p.chunk_size,
02966 "Chunk size [bin]"));
02967 check( xsh_parameters_new_double( list, recipe_id,
02968 "optextract-step-lambda", p.lambda_step,
02969 "Lambda step [nm]"));
02970 check( xsh_parameters_new_double( list, recipe_id,
02971 "optextract-clip-kappa", p.clip_kappa,
02972 "Kappa for cosmics ray hits rejection" ) ) ;
02973 check( xsh_parameters_new_double( list, recipe_id,
02974 "optextract-clip-frac", p.clip_frac,
02975 "Maximum bad pixels fraction for cosmics ray hits rejection"));
02976 check( xsh_parameters_new_int( list, recipe_id,
02977 "optextract-clip-niter", p.clip_niter,
02978 "Maximum number of iterations for cosmics ray hits rejection"));
02979 check( xsh_parameters_new_int( list, recipe_id,
02980 "optextract-niter", p.niter,
02981 "Number of iterations" ) ) ;
02982 check( xsh_parameters_new_string( list, recipe_id,
02983 "optextract-method", OPTEXTRACT_METHOD_PRINT(p.method),
02984 "Extraction method GAUSSIAN | GENERAL"));
02985
02986 cleanup:
02987 return;
02988 }
02989
02990
03001
03002 xsh_opt_extract_param* xsh_parameters_opt_extract_get( const char* recipe_id,
03003 cpl_parameterlist* list)
03004 {
03005 xsh_opt_extract_param* result = NULL;
03006 const char *par_method = NULL;
03007
03008
03009
03010 XSH_ASSURE_NOT_NULL( recipe_id);
03011 XSH_ASSURE_NOT_NULL( list);
03012
03013 XSH_MALLOC( result, xsh_opt_extract_param, 1);
03014
03015
03016 check( result->oversample = xsh_parameters_get_int( list,recipe_id,
03017 "optextract-oversample"));
03018 check( result->box_hsize = xsh_parameters_get_int( list,recipe_id,
03019 "optextract-box-half-size"));
03020 check( result->chunk_size = xsh_parameters_get_int( list,recipe_id,
03021 "optextract-chunk-size"));
03022 check( result->lambda_step = xsh_parameters_get_double( list,recipe_id,
03023 "optextract-step-lambda"));
03024 check( result->clip_kappa = xsh_parameters_get_double( list, recipe_id,
03025 "optextract-clip-kappa"));
03026 check( result->clip_frac = xsh_parameters_get_double( list, recipe_id,
03027 "optextract-clip-frac"));
03028 check( result->clip_niter = xsh_parameters_get_int( list, recipe_id,
03029 "optextract-clip-niter"));
03030 check( result->niter = xsh_parameters_get_int( list, recipe_id,
03031 "optextract-niter"));
03032 check( par_method = xsh_parameters_get_string( list, recipe_id,
03033 "optextract-method"));
03034 if ( strcmp( OPTEXTRACT_METHOD_PRINT(GAUSS_METHOD), par_method) == 0){
03035 result->method = GAUSS_METHOD;
03036 }
03037 else if (strcmp( OPTEXTRACT_METHOD_PRINT(GENERAL_METHOD), par_method) == 0){
03038 result->method = GENERAL_METHOD;
03039 }
03040 else {
03041 xsh_error_msg("WRONG parameter optextract-method %s",par_method);
03042 }
03043
03044 cleanup:
03045 if(cpl_error_get_code() != CPL_ERROR_NONE){
03046 XSH_FREE( result);
03047 }
03048 return result;
03049 }
03050
03051 void xsh_parameters_slit_limit_create( const char* recipe_id,
03052 cpl_parameterlist* list,
03053 xsh_slit_limit_param p )
03054 {
03055
03056 XSH_ASSURE_NOT_NULL( recipe_id);
03057 XSH_ASSURE_NOT_NULL( list);
03058
03059
03060 check( xsh_parameters_new_double( list, recipe_id,
03061 "max-slit", p.max_slit,
03062 "Lower Slit Limit (localize and extract"));
03063 check( xsh_parameters_new_double( list, recipe_id,
03064 "min-slit", p.min_slit,
03065 "Upper Slit Limit (localize and extract"));
03066
03067 cleanup:
03068 return ;
03069 }
03070
03071 xsh_slit_limit_param * xsh_parameters_slit_limit_get( const char * recipe_id,
03072 cpl_parameterlist* list )
03073 {
03074 xsh_slit_limit_param * result = NULL ;
03075
03076
03077 XSH_ASSURE_NOT_NULL( recipe_id);
03078 XSH_ASSURE_NOT_NULL( list);
03079
03080 XSH_MALLOC( result, xsh_slit_limit_param, 1);
03081
03082
03083 check( result->min_slit = xsh_parameters_get_double( list,recipe_id,
03084 "min-slit"));
03085 check( result->max_slit = xsh_parameters_get_double( list,recipe_id,
03086 "max-slit"));
03087 cleanup:
03088 if(cpl_error_get_code() != CPL_ERROR_NONE){
03089 XSH_FREE( result);
03090 }
03091 return result;
03092 }
03093
03094 void xsh_parameters_geom_ifu_mode_create( const char* recipe_id,
03095 cpl_parameterlist* list )
03096 {
03097
03098 XSH_ASSURE_NOT_NULL( recipe_id);
03099 XSH_ASSURE_NOT_NULL( list);
03100
03101 check(xsh_parameters_new_boolean(list,recipe_id,
03102 "geom-ifu-localize-single",
03103 TRUE,
03104 "Use a concatenation of rectified to localize."));
03105 cleanup:
03106 return ;
03107 }
03108
03109 int xsh_parameters_geom_ifu_mode_get( const char * recipe_id,
03110 cpl_parameterlist* list)
03111 {
03112 int ts = FALSE ;
03113
03114
03115 XSH_ASSURE_NOT_NULL( recipe_id);
03116 XSH_ASSURE_NOT_NULL( list);
03117 ts = xsh_parameters_get_boolean( list, recipe_id,
03118 "geom-ifu-localize-single" ) ;
03119
03120 cleanup:
03121 return ts ;
03122 }
03123
03124
03125 cpl_parameterlist*
03126 xsh_parameters_create_from_drs_table(const cpl_table* tab,
03127 const char* recipe_id)
03128 {
03129
03130 cpl_parameterlist* result=NULL;
03131 int nrow=0;
03132 int i=0;
03133 const char* svalue=NULL;
03134 int ivalue=0;
03135 float fvalue=0;
03136 double dvalue=0;
03137 bool bvalue=0;
03138
03139 const char* pname=NULL;
03140 const char* ptype=NULL;
03141 const char* phelp=NULL;
03142 int error=0;
03143
03144 XSH_ASSURE_NOT_NULL_MSG(tab,"Null input DRS tab");
03145 nrow=cpl_table_get_nrow(tab);
03146 result=cpl_parameterlist_new();
03147 for(i=0;i<nrow;i++) {
03148 check(pname=cpl_table_get_string(tab,"name",i));
03149 check(ptype=cpl_table_get_string(tab,"type",i));
03150 check(phelp=cpl_table_get_string(tab,"help",i));
03151
03152 if (strcmp(ptype,"int") == 0) {
03153 check(ivalue=cpl_table_get_int(tab,"value",i,&error));
03154 check(xsh_parameters_new_int(result,recipe_id,pname,ivalue,phelp));
03155 }
03156 else if (strcmp(ptype,"float") == 0) {
03157 fvalue=cpl_table_get_float(tab,"value",i,&error);
03158 xsh_parameters_new_float(result,recipe_id,pname,fvalue,phelp);
03159 }
03160 else if (strcmp(ptype,"double") == 0) {
03161 dvalue=cpl_table_get_double(tab,"value",i,&error);
03162 xsh_parameters_new_float(result,recipe_id,pname,dvalue,phelp);
03163 }
03164 else if (strcmp(ptype,"string") == 0) {
03165 svalue=cpl_table_get_string(tab,"value",i);
03166 xsh_parameters_new_string(result,recipe_id,pname,svalue,phelp);
03167 }
03168 else if (strcmp(ptype,"bool") == 0) {
03169 bvalue=cpl_table_get_int(tab,"value",i,&error);
03170 xsh_parameters_new_bool(result,recipe_id,pname,ivalue,phelp);
03171 }
03172 else {
03173 xsh_msg_error("DRS table parameter type %s not supported!",ptype);
03174 return NULL;
03175 }
03176 }
03177
03178 cleanup:
03179 return result;
03180 }