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_model_arm_constants.h>
00035 #include <xsh_badpixelmap.h>
00036 #include <xsh_msg.h>
00037 #include <xsh_error.h>
00038 #include <xsh_drl.h>
00039 #include <strings.h>
00040
00046
00047
00048
00049
00050 void xsh_parameters_new_int( cpl_parameterlist* list,
00051 const char* recipe_id, const char* name,int value, const char* comment)
00052 {
00053 char paramname[256];
00054 char recipename[256];
00055 cpl_parameter* p =NULL;
00056
00057
00058 sprintf(recipename,"xsh.%s",recipe_id);
00059 sprintf(paramname,"%s.%s",recipename,name);
00060
00061 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00062
00063 check(p = cpl_parameter_new_value(paramname,CPL_TYPE_INT,comment,
00064 recipename,value));
00065 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,name));
00066 check(cpl_parameterlist_append(list,p));
00067
00068 cleanup:
00069 return;
00070 }
00071
00072
00073 void xsh_parameters_new_boolean( cpl_parameterlist* list,
00074 const char* recipe_id, const char* name,int value, const char* comment)
00075 {
00076 char paramname[256];
00077 char recipename[256];
00078 cpl_parameter* p =NULL;
00079
00080
00081 sprintf(recipename,"xsh.%s",recipe_id);
00082 sprintf(paramname,"%s.%s",recipename,name);
00083
00084 XSH_ASSURE_NOT_NULL(list);
00085 check(p = cpl_parameter_new_value(paramname,CPL_TYPE_BOOL,comment,
00086 recipename,value));
00087 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,name));
00088 check(cpl_parameterlist_append(list,p));
00089
00090 cleanup:
00091 return;
00092 }
00093
00094 static void xsh_parameters_new_string( cpl_parameterlist* list,
00095 const char* recipe_id,
00096 const char* name,
00097 const char* value,
00098 const char* comment)
00099 {
00100 char * paramname = NULL ;
00101 char * recipename = NULL ;
00102 cpl_parameter* p =NULL;
00103
00104 recipename = xsh_stringcat_any( "xsh.", recipe_id, NULL );
00105 paramname = xsh_stringcat_any( recipename, ".", name, NULL );
00106
00107 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00108
00109 check(p = cpl_parameter_new_value(paramname,CPL_TYPE_STRING, comment,
00110 recipename, value));
00111 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,name));
00112 check(cpl_parameterlist_append(list,p));
00113
00114 cleanup:
00115 XSH_FREE(recipename);
00116 XSH_FREE(paramname);
00117 return;
00118 }
00119
00120 void xsh_parameters_new_double( cpl_parameterlist* list,
00121 const char* recipe_id,const char* name,double value, const char* comment)
00122 {
00123 char paramname[256];
00124 char recipename[256];
00125 cpl_parameter* p =NULL;
00126
00127
00128 sprintf(recipename,"xsh.%s",recipe_id);
00129 sprintf(paramname,"%s.%s",recipename,name);
00130
00131 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00132
00133 check(p = cpl_parameter_new_value(paramname,CPL_TYPE_DOUBLE,comment,
00134 recipename,value));
00135 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,name));
00136 check(cpl_parameterlist_append(list,p));
00137
00138 cleanup:
00139 return;
00140 }
00141
00142 static void
00143 xsh_parameters_new_bool( cpl_parameterlist* list,
00144 const char* recipe_id,const char* name,bool value, const char* comment)
00145 {
00146 char paramname[256];
00147 char recipename[256];
00148 cpl_parameter* p =NULL;
00149
00150
00151 sprintf(recipename,"xsh.%s",recipe_id);
00152 sprintf(paramname,"%s.%s",recipename,name);
00153
00154 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00155
00156 check(p = cpl_parameter_new_value(paramname,CPL_TYPE_BOOL,comment,
00157 recipename,value));
00158 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,name));
00159 check(cpl_parameterlist_append(list,p));
00160
00161 cleanup:
00162 return;
00163 }
00164
00165 static void
00166 xsh_parameters_new_float( cpl_parameterlist* list,
00167 const char* recipe_id,const char* name,float value, const char* comment)
00168 {
00169 char paramname[256];
00170 char recipename[256];
00171 cpl_parameter* p =NULL;
00172
00173
00174 sprintf(recipename,"xsh.%s",recipe_id);
00175 sprintf(paramname,"%s.%s",recipename,name);
00176
00177 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00178
00179 check(p = cpl_parameter_new_value(paramname,CPL_TYPE_FLOAT,comment,
00180 recipename,value));
00181 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,name));
00182 check(cpl_parameterlist_append(list,p));
00183
00184 cleanup:
00185 return;
00186 }
00187
00188 static void xsh_parameters_new_range_int( cpl_parameterlist* list,
00189 const char* recipe_id,
00190 const char* name,
00191 int def, int min, int max,
00192 const char* comment)
00193 {
00194 char paramname[256];
00195 char recipename[256];
00196 cpl_parameter* p =NULL;
00197
00198
00199 sprintf(recipename,"xsh.%s",recipe_id);
00200 sprintf(paramname,"%s.%s",recipename,name);
00201
00202 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00203
00204 check(p = cpl_parameter_new_range( paramname,CPL_TYPE_INT, comment,
00205 recipename, def, min, max ));
00206 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,name));
00207 check(cpl_parameterlist_append(list,p));
00208
00209 cleanup:
00210 return;
00211 }
00212
00213
00214
00215 static void xsh_parameters_new_range_double( cpl_parameterlist* list,
00216 const char* recipe_id,
00217 const char* name,
00218 double def, double min, double max,
00219 const char* comment)
00220 {
00221 char paramname[256];
00222 char recipename[256];
00223 cpl_parameter* p =NULL;
00224
00225
00226 sprintf(recipename,"xsh.%s",recipe_id);
00227 sprintf(paramname,"%s.%s",recipename,name);
00228
00229 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00230
00231 check(p = cpl_parameter_new_range( paramname,CPL_TYPE_DOUBLE, comment,
00232 recipename, def, min, max ));
00233 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,name));
00234 check(cpl_parameterlist_append(list,p));
00235
00236 cleanup:
00237 return;
00238 }
00239
00240
00241
00242 char * xsh_parameters_get_string( const cpl_parameterlist* list,
00243 const char* recipe_id, const char* name)
00244 {
00245 char paramname[256];
00246 cpl_parameter * p =NULL;
00247 char * result = NULL ;
00248
00249 sprintf(paramname,"xsh.%s.%s",recipe_id, name);
00250
00251 p = cpl_parameterlist_find( (cpl_parameterlist *)list, paramname);
00252 if ( p == NULL ) goto cleanup ;
00253 result = (char *)cpl_parameter_get_string(p) ;
00254
00255 cleanup:
00256 return result;
00257 }
00258
00259
00260 int xsh_parameters_get_boolean( const cpl_parameterlist * list,
00261 const char* recipe_id, const char* name)
00262 {
00263 char paramname[256];
00264 char recipename[256];
00265 cpl_parameter* p =NULL;
00266 int result = 0;
00267
00268 sprintf(recipename,"xsh.%s",recipe_id);
00269 sprintf(paramname,"%s.%s",recipename,name);
00270
00271 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00272
00273 check(p = cpl_parameterlist_find( (cpl_parameterlist *)list,paramname));
00274 check(result = cpl_parameter_get_bool( p));
00275
00276 cleanup:
00277 return result;
00278 }
00279
00280
00281 int xsh_parameters_get_int( cpl_parameterlist* list,
00282 const char* recipe_id, const char* name)
00283 {
00284 char paramname[256];
00285 char recipename[256];
00286 cpl_parameter* p =NULL;
00287 int result = 0;
00288 sprintf(recipename,"xsh.%s",recipe_id);
00289 sprintf(paramname,"%s.%s",recipename,name);
00290
00291 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00292 check(p = cpl_parameterlist_find( (cpl_parameterlist *)list,paramname));
00293 check(result = cpl_parameter_get_int(p));
00294
00295 cleanup:
00296 return result;
00297 }
00298
00299 double xsh_parameters_get_double( cpl_parameterlist* list,
00300 const char* recipe_id, const char* name)
00301 {
00302 char paramname[256];
00303 char recipename[256];
00304 cpl_parameter* p =NULL;
00305 double result = 0.0;
00306
00307 sprintf(recipename,"xsh.%s",recipe_id);
00308 sprintf(paramname,"%s.%s",recipename,name);
00309
00310 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00311
00312 check(p = cpl_parameterlist_find(list,paramname));
00313 check(result = cpl_parameter_get_double(p));
00314
00315 cleanup:
00316 return result;
00317 }
00318
00322
00331
00332
00333 cpl_parameter* xsh_parameters_find( cpl_parameterlist* list,
00334 const char* recipe_id, const char* name)
00335 {
00336
00337 char paramname[256];
00338 cpl_parameter * result = NULL ;
00339
00340 sprintf(paramname,"xsh.%s.%s",recipe_id, name);
00341 check(result = cpl_parameterlist_find( (cpl_parameterlist *)list, paramname));
00342
00343 cleanup:
00344 return result;
00345
00346 }
00347
00348
00349 void xsh_parameters_pre_overscan( const char *recipe_id,
00350 cpl_parameterlist * plist )
00351 {
00352 cpl_parameter* p=NULL;
00353 char paramname[256];
00354 char recipename[256];
00355
00356 XSH_ASSURE_NOT_NULL( recipe_id ) ;
00357 XSH_ASSURE_NOT_NULL( plist ) ;
00358
00359
00360 sprintf(recipename,"xsh.%s",recipe_id);
00361 sprintf(paramname,"%s.%s",recipename,"pre-overscan-corr");
00362
00363 check(p = cpl_parameter_new_enum(paramname,CPL_TYPE_INT,
00364 "pre-overscan correction."
00365 "0: no correction"
00366 "1: mean overscan correction"
00367 "2: mean prescan correction"
00368 "3: (mean pre+mean overscan)/2 correction"
00369
00370
00371
00372 ,recipename,0,
00373 4,0,1,2,3));
00374
00375 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
00376 "pre-overscan-corr"));
00377 check(cpl_parameterlist_append(plist,p));
00378
00379 cleanup:
00380 return ;
00381 }
00382
00383 void xsh_parameters_generic( const char *recipe_id,
00384 cpl_parameterlist * plist )
00385 {
00386 XSH_ASSURE_NOT_NULL( recipe_id ) ;
00387 XSH_ASSURE_NOT_NULL( plist ) ;
00388 int mval=2*QFLAG_OUTSIDE_DATA_RANGE-1;
00389 int ival=2*QFLAG_OUTSIDE_DATA_RANGE-1;
00390 check( xsh_parameters_new_string( plist, recipe_id, "keep-temp", "no",
00391 "If 'no', temporary files are deleted." ) ) ;
00392 check( xsh_parameters_new_string( plist, recipe_id, "debug-level",
00393 "none",
00394 "Additional xshooter debug level. One of 'none', 'low', 'medium', 'high'"));
00395
00396
00397
00398
00399
00400 check( xsh_parameters_new_boolean(plist,recipe_id, "time-stamp",
00401 FALSE,
00402 "Add timestamp to product file name." )) ;
00403
00404 if(strcmp(recipe_id,"xsh_mdark")==0) {
00405 ival=4;
00406 }
00407 check(xsh_parameters_new_range_int( plist, recipe_id,"decode-bp",
00408 ival, 0,mval,
00409 "Integer representation of the bits to be considered bad when decoding the bad pixel mask pixel values."));
00410 cleanup:
00411 return ;
00412 }
00413
00414 int xsh_parameters_get_temporary( const char * recipe_id,
00415 const cpl_parameterlist * list )
00416 {
00417 char * result = NULL ;
00418
00419 result = xsh_parameters_get_string( list, recipe_id,
00420 "keep-temp" ) ;
00421 if ( result == NULL ) {
00422 xsh_msg( "Cant get parameter 'keep-temp'" ) ;
00423 return 1 ;
00424 }
00425 else if ( strcasecmp( result, "yes" ) == 0 ) return 1 ;
00426 else return 0 ;
00427
00428 }
00429
00430 int xsh_parameters_debug_level_get( const char * recipe_id,
00431 const cpl_parameterlist * list )
00432 {
00433 char * slevel = NULL ;
00434 int level = XSH_DEBUG_LEVEL_NONE ;
00435
00436 slevel = xsh_parameters_get_string( list, recipe_id,
00437 "debug-level" ) ;
00438 if ( slevel == NULL ) {
00439 xsh_msg( "Cant get parameter 'debug-level'" ) ;
00440 }
00441 else if ( strcmp( slevel, "low" ) == 0 ) level = XSH_DEBUG_LEVEL_LOW ;
00442 else if ( strcmp( slevel, "medium" ) == 0 ) level = XSH_DEBUG_LEVEL_MEDIUM ;
00443 else if ( strcmp( slevel, "high" ) == 0 ) level = XSH_DEBUG_LEVEL_HIGH ;
00444 else level = XSH_DEBUG_LEVEL_NONE ;
00445
00446 xsh_debug_level_set( level ) ;
00447 return level ;
00448 }
00449
00450 char * xsh_parameters_test_mode_get( const char * recipe_id,
00451 const cpl_parameterlist * list )
00452 {
00453 char * stest = NULL ;
00454
00455 stest = xsh_parameters_get_string( list, recipe_id,
00456 "test" ) ;
00457 return stest ;
00458 }
00459
00460 int xsh_parameters_time_stamp_get( const char * recipe_id,
00461 const cpl_parameterlist * list )
00462 {
00463 int ts = FALSE ;
00464
00465 ts = xsh_parameters_get_boolean( list, recipe_id, "time-stamp" ) ;
00466
00467 xsh_time_stamp_set( ts ) ;
00468
00469 return ts ;
00470 }
00471
00472
00480
00481 void xsh_parameters_clipping_crh_create(const char* recipe_id,
00482 cpl_parameterlist* list, xsh_clipping_param p)
00483 {
00484
00485 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00486
00487
00488
00489
00490
00491
00492 check(xsh_parameters_new_double(list,recipe_id,"crh-clip-kappa", p.sigma,
00493 "Kappa value in sigma clipping during CRH rejection using "\
00494 "multiple frames"));
00495
00496 check(xsh_parameters_new_int(list,recipe_id,"crh-clip-niter", p.niter,
00497 "Number of iterations in sigma clipping during CRH rejection "\
00498 "using multiple frames"));
00499
00500 check(xsh_parameters_new_double(list,recipe_id,"crh-clip-frac", p.frac,
00501 "Minimal ratio of points accepted / total in sigma clipping "\
00502 "during CRH rejection using multiple frames"));
00503
00504 cleanup:
00505 return;
00506 }
00507
00508
00509
00510
00518
00519 void xsh_parameters_hot_cold_pix_create(const char* recipe_id,
00520 cpl_parameterlist* list, xsh_hot_cold_pix_param p)
00521 {
00522
00523 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00524
00525
00526 check( xsh_parameters_new_boolean( list, recipe_id,
00527 "hot-cold-pix-search",
00528 p.hot_cold_pix_search,
00529 "If true hot and cold pixels are searched"));
00530
00531 xsh_parameters_new_double(list,recipe_id,"cold-pix-kappa",p.cold_pix_kappa,
00532 "Kappa sigma value to clip low intensity pixels");
00533
00534
00535 check(xsh_parameters_new_range_int( list, recipe_id,"cold-pix-niter",
00536 p.cold_pix_niter, 1, 999,
00537 "Number of kappa-sigma clip iterations (cold pixels search)."));
00538
00539
00540 xsh_parameters_new_double(list,recipe_id,"hot-pix-kappa",p.hot_pix_kappa,
00541 "Kappa sigma value to clip high intensity pixels");
00542
00543 check(xsh_parameters_new_range_int( list, recipe_id,"hot-pix-niter",
00544 p.hot_pix_niter, 1, 999,
00545 "Number of kappa-sigma clip iterations (hot pixels search)."));
00546
00547 cleanup:
00548 return;
00549 }
00550
00551
00559
00560 void xsh_parameters_struct_create(const char* recipe_id,
00561 cpl_parameterlist* list, xsh_struct_param p)
00562 {
00563
00564 xsh_parameters_new_int(list,recipe_id,"struct_refx",p.ref_x,
00565 "Reference X value to compute structure");
00566
00567 xsh_parameters_new_int(list,recipe_id,"struct_refy",p.ref_y,
00568 "Reference Y value to compute structure");
00569 }
00570
00571
00572
00573
00581
00582 void xsh_parameters_ref1_create(const char* recipe_id,
00583 cpl_parameterlist* list, xsh_ref_param p)
00584 {
00585
00586 xsh_parameters_new_int(list,recipe_id,"ref1_llx",p.ref_llx,
00587 "Lower left X of reference region");
00588
00589 xsh_parameters_new_int(list,recipe_id,"ref1_lly",p.ref_lly,
00590 "Lower left Y of reference region");
00591
00592 xsh_parameters_new_int(list,recipe_id,"ref1_urx",p.ref_urx,
00593 "Upper right X of reference region");
00594
00595 xsh_parameters_new_int(list,recipe_id,"ref1_ury",p.ref_ury,
00596 "Upper right Y of reference region");
00597
00598 }
00599
00600
00601
00609
00610 void xsh_parameters_ref2_create(const char* recipe_id,
00611 cpl_parameterlist* list, xsh_ref_param p)
00612 {
00613
00614 xsh_parameters_new_int(list,recipe_id,"ref2_llx",p.ref_llx,
00615 "Lower left X of reference region");
00616
00617 xsh_parameters_new_int(list,recipe_id,"ref2_lly",p.ref_lly,
00618 "Lower left Y of reference region");
00619
00620 xsh_parameters_new_int(list,recipe_id,"ref2_urx",p.ref_urx,
00621 "Upper right X of reference region");
00622
00623 xsh_parameters_new_int(list,recipe_id,"ref2_ury",p.ref_ury,
00624 "Upper right Y of reference region");
00625
00626 }
00627
00628
00629
00637
00638 void xsh_parameters_ron_dark_create(const char* recipe_id,
00639 cpl_parameterlist* list, xsh_ron_dark_param p)
00640 {
00641
00642 xsh_parameters_new_int(list,recipe_id,"ron_llx",p.ron_llx,
00643 "Lower left X of reference region to measure RON");
00644
00645 xsh_parameters_new_int(list,recipe_id,"ron_lly",p.ron_lly,
00646 "Lower left Y of reference region to measure RON");
00647
00648 xsh_parameters_new_int(list,recipe_id,"ron_urx",p.ron_urx,
00649 "Upper right X of reference region to measure RON");
00650
00651 xsh_parameters_new_int(list,recipe_id,"ron_ury",p.ron_ury,
00652 "Upper right Y of reference region to measure RON");
00653
00654 xsh_parameters_new_int(list,recipe_id,"ron_hsize",p.ron_hsize,
00655 "Sampling area size");
00656
00657
00658 xsh_parameters_new_int(list,recipe_id,"ron_nsamples",p.ron_nsamp,
00659 "Number of random samples");
00660
00661
00662
00663 }
00664
00665
00666
00674
00675 void
00676 xsh_parameters_stack_create(const char* recipe_id,
00677 cpl_parameterlist* list, xsh_stack_param sp)
00678 {
00679
00680 char * paramname = NULL ;
00681 char * recipename = NULL ;
00682 const char* aliasname="stack-method";
00683 cpl_parameter* p =NULL;
00684
00685 recipename = xsh_stringcat_any( "xsh.", recipe_id, NULL );
00686 paramname = xsh_stringcat_any( recipename, ".", aliasname, NULL );
00687
00688 p = cpl_parameter_new_enum(paramname,CPL_TYPE_STRING,
00689 "Method used to build master frame.",
00690 recipe_id,"median",
00691 2,"median","mean");
00692
00693 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
00694 aliasname);
00695 cpl_parameterlist_append(list,p);
00696
00697 xsh_parameters_new_double(list,recipe_id,"klow",sp.klow,
00698 "Kappa used to clip low level values, when method is set to 'mean'");
00699
00700 xsh_parameters_new_double(list,recipe_id,"khigh",sp.khigh,
00701 "Kappa used to clip high level values, when method is set to 'mean'");
00702
00703 xsh_parameters_new_int(list,recipe_id,"niter",sp.niter,
00704 "Number of kappa sigma iterations, when method is set to 'mean'");
00705
00706 XSH_FREE(recipename);
00707 XSH_FREE(paramname);
00708
00709 }
00710
00718
00719 void xsh_parameters_ron_create(const char* recipe_id,
00720 cpl_parameterlist* list, xsh_ron_param p)
00721 {
00722
00723
00724 xsh_ref_param ref_params = {p.ron_ref_llx,p.ron_ref_lly,
00725 p.ron_ref_urx,p.ron_ref_ury};
00726
00727
00728 xsh_parameters_new_string(list,recipe_id,"ron_method",p.ron_method,
00729 "RON computation method");
00730
00731 xsh_parameters_new_int(list,recipe_id,"random_sizex",p.ron_random_sizex,
00732 "Region X size for random computation");
00733
00734 xsh_parameters_new_int(list,recipe_id,"random_nsamples",p.ron_random_nsamples,
00735 "Number of random samples");
00736
00737
00738 xsh_parameters_ref1_create(recipe_id,list,ref_params);
00739 xsh_parameters_ref2_create(recipe_id,list,ref_params);
00740
00741
00742 xsh_parameters_new_int(list,recipe_id,"stacking_ks_low",p.stacking_ks_low,
00743 "Lower value of kappa-sigma clip in stacking");
00744
00745 xsh_parameters_new_int(list,recipe_id,"stacking_ks_iter",p.stacking_ks_iter,
00746 "Number of iterations in kappa-sigma clip in stacking");
00747
00748
00749 }
00750
00751
00752
00753
00761
00762 void xsh_parameters_fpn_create(const char* recipe_id,
00763 cpl_parameterlist* list, xsh_fpn_param p)
00764 {
00765
00766 xsh_parameters_new_int(list,recipe_id,"fpn_llx",p.fpn_llx,
00767 "Lower left reference area X coordinate for "
00768 "Fixed Pattern Noise computation");
00769
00770 xsh_parameters_new_int(list,recipe_id,"fpn_lly",p.fpn_lly,
00771 "Lower left reference area Y coordinate for "
00772 "Fixed Pattern Noise computation");
00773
00774 xsh_parameters_new_int(list,recipe_id,"fpn_urx",p.fpn_urx,
00775 "Upper right reference area X coordinate for "
00776 "Fixed Pattern Noise computation");
00777
00778 xsh_parameters_new_int(list,recipe_id,"fpn_ury",p.fpn_ury,
00779 "Upper right reference area Y coordinate for "
00780 "Fixed Pattern Noise computation");
00781
00782 xsh_parameters_new_int(list,recipe_id,"fpn_hsize",p.fpn_hsize,
00783 "Sample size for "
00784 "Fixed Pattern Noise computation");
00785
00786
00787 xsh_parameters_new_int(list,recipe_id,"fpn_nsamples",p.fpn_nsamples,
00788 "Number of sampling points for "
00789 "Fixed Pattern Noise computation");
00790
00791 }
00792
00793
00801
00802 xsh_clipping_param* xsh_parameters_clipping_crh_get(const char* recipe_id,
00803 cpl_parameterlist* list)
00804 {
00805 xsh_clipping_param* result = NULL;
00806
00807
00808 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00809
00810
00811 check(result = (xsh_clipping_param*)(cpl_malloc(sizeof(xsh_clipping_param)))
00812 );
00813 assure (result != NULL, CPL_ERROR_ILLEGAL_OUTPUT,
00814 "Memory allocation failed!");
00815
00816
00817
00818
00819
00820
00821 check(result->sigma = xsh_parameters_get_double(list,recipe_id,
00822 "crh-clip-kappa"));
00823 check(result->niter = xsh_parameters_get_int(list,recipe_id,
00824 "crh-clip-niter"));
00825 check(result->frac = xsh_parameters_get_double(list,recipe_id,
00826 "crh-clip-frac"));
00827
00828 cleanup:
00829 if(cpl_error_get_code() != CPL_ERROR_NONE){
00830 cpl_free(result);
00831 result = NULL;
00832 }
00833 return result;
00834 }
00835
00836
00844
00845 void xsh_parameters_clipping_noise_create(const char* recipe_id,
00846 cpl_parameterlist* list,
00847 xsh_clipping_param noise_param)
00848 {
00849
00850 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00851
00852
00853
00854 check(xsh_parameters_new_double(list,recipe_id,"noise-clip-kappa",
00855 noise_param.sigma,
00856 "Multiple of sigma in sigma clipping"));
00857
00858 check(xsh_parameters_new_int(list,recipe_id,"noise-clip-niter",
00859 noise_param.niter,
00860 "Number of iterations in sigma clipping"));
00861
00862 check(xsh_parameters_new_double(list,recipe_id,"noise-clip-frac",
00863 noise_param.frac,
00864 "Minimal fractions of bad pixel allowed"));
00865
00866 check(xsh_parameters_new_double(list,recipe_id,"noise-clip-diff",
00867 noise_param.diff,
00868 "Minimum relative change in sigma for sigma clipping"));
00869 cleanup:
00870 return;
00871 }
00872
00873
00881
00882 xsh_clipping_param* xsh_parameters_clipping_noise_get(const char* recipe_id,
00883 cpl_parameterlist* list)
00884 {
00885 xsh_clipping_param* result = NULL;
00886
00887
00888 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00889
00890
00891 check(result = (xsh_clipping_param*)(cpl_malloc(sizeof(xsh_clipping_param)))
00892 );
00893 assure (result != NULL, CPL_ERROR_ILLEGAL_OUTPUT,
00894 "Memory allocation failed!");
00895
00896
00897 check(result->sigma = xsh_parameters_get_double(list,recipe_id,
00898 "noise-clip-kappa"));
00899 check(result->niter = xsh_parameters_get_int(list,recipe_id,
00900 "noise-clip-niter"));
00901 check(result->frac = xsh_parameters_get_double(list,recipe_id,
00902 "noise-clip-frac"));
00903 check(result->diff = xsh_parameters_get_double(list,recipe_id,
00904 "noise-clip-diff"));
00905 cleanup:
00906 if(cpl_error_get_code() != CPL_ERROR_NONE){
00907 cpl_free(result);
00908 result = NULL;
00909 }
00910 return result;
00911 }
00912
00913
00923
00924
00925 void xsh_parameters_detect_order_create(const char* recipe_id,
00926 cpl_parameterlist* list)
00927 {
00928
00929 char paramname[256];
00930 char recipename[256];
00931 cpl_parameter* p =NULL;
00932
00933
00934 XSH_ASSURE_NOT_NULL( recipe_id);
00935 XSH_ASSURE_NOT_NULL( list);
00936
00937
00938
00939 check( xsh_parameters_new_int( list, recipe_id,
00940 "detectorder-edges-search-window-half-size",
00941 50,
00942 "Half window size in pixels for the search for order edges"));
00943
00944
00945 check( xsh_parameters_new_double( list, recipe_id,
00946 "detectorder-edges-flux-thresh",
00947 0.05,
00948 "Threshold in relative flux (compared to the central flux) "\
00949 "below which the order edges are defined"));
00950
00951 check( xsh_parameters_new_double( list, recipe_id,
00952 "detectorder-min-sn",
00953 -1,
00954 "Minimum signal-to-noise ratio at the centroid of the orders (35 for SLIT-UVB,VIS, 20 for IFU-UVB,VIS, 25 for SLIT-NIR, 4 for IFU-NIR"));
00955
00956 check( xsh_parameters_new_int( list, recipe_id,
00957 "detectorder-min-order-size-x",
00958 -1,
00959 "Minimum order size in pixels along X direction [60 for UVB,VIS, 40 for NIR]"));
00960 check( xsh_parameters_new_int( list, recipe_id,
00961 "detectorder-chunk-half-size",
00962 1,
00963 "Half size in pixels of the chunks in Y direction"));
00964
00965
00966 check( xsh_parameters_new_double( list, recipe_id,
00967 "detectorder-slitlet-low-factor",
00968 1.0,
00969 "Factor for slitlet on lower edge slitlet (IFU)"));
00970
00971 check( xsh_parameters_new_double( list, recipe_id,
00972 "detectorder-slitlet-up-factor",
00973 1.0,
00974 "Factor for slitlet on upper edge (IFU)"));
00975 check( xsh_parameters_new_boolean( list, recipe_id,
00976 "detectorder-fixed-slice",
00977 CPL_TRUE,
00978 "If true the size of slitlet is fixed (IFU)"));
00979
00980
00981
00982 sprintf(recipename,"xsh.%s",recipe_id);
00983 sprintf(paramname,"%s.%s",recipename,"detectorder-slice-trace-method");
00984
00985 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
00986
00987 check(p = cpl_parameter_new_enum(paramname,CPL_TYPE_STRING,
00988 "method adopted for IFU slice tracing ('fixed' for SLIT and 'sobel' for IFU):",
00989 recipename,"auto",
00990 4,"auto","fixed","sobel","scharr"));
00991
00992 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
00993 "detectorder-slice-trace-method"));
00994 check(cpl_parameterlist_append(list,p));
00995
00996 check( xsh_parameters_new_boolean( list, recipe_id,
00997 "detectorder-qc-mode",
00998 CPL_FALSE,
00999 "If true allows to skip edge detection on orders below detectorder-min-sn (oly for QC mode, not to be set by normal users)"));
01000
01001 cleanup:
01002 return;
01003 }
01004
01005
01017
01018
01019 xsh_detect_order_param* xsh_parameters_detect_order_get(const char* recipe_id,
01020 cpl_parameterlist* list,cpl_parameterlist* drs)
01021 {
01022 xsh_detect_order_param* result = NULL;
01023
01024
01025 XSH_ASSURE_NOT_NULL( list);
01026
01027
01028 XSH_MALLOC( result, xsh_detect_order_param, 1);
01029
01030
01031 check( result->search_window_hsize = xsh_parameters_get_int( list, recipe_id,
01032 "detectorder-edges-search-window-half-size"));
01033 check( result->flux_thresh = xsh_parameters_get_double( list, recipe_id,
01034 "detectorder-edges-flux-thresh"));
01035 check( result->min_sn = xsh_parameters_get_double( list, recipe_id,
01036 "detectorder-min-sn"));
01037 check( result->min_order_size_x = xsh_parameters_get_int( list, recipe_id,
01038 "detectorder-min-order-size-x"));
01039 check( result->chunk_hsize = xsh_parameters_get_int( list, recipe_id,
01040 "detectorder-chunk-half-size"));
01041 check( result->slitlet_low_factor = xsh_parameters_get_double( list,recipe_id,
01042 "detectorder-slitlet-low-factor"));
01043 check( result->slitlet_up_factor = xsh_parameters_get_double( list,recipe_id,
01044 "detectorder-slitlet-up-factor"));
01045 check( result->fixed_slice = xsh_parameters_get_boolean( list,recipe_id,
01046 "detectorder-fixed-slice"));
01047
01048 check( result->method = xsh_parameters_get_string( list,recipe_id,
01049 "detectorder-slice-trace-method"));
01050 if(drs==NULL) {
01051 result->qc_mode= false;
01052 } else {
01053 check( result->qc_mode = xsh_parameters_get_boolean( drs,recipe_id,
01054 "detectorder-qc-mode"));
01055 }
01056 cleanup:
01057 if(cpl_error_get_code() != CPL_ERROR_NONE){
01058 XSH_FREE( result);
01059 }
01060 return result;
01061 }
01062
01072
01073
01074 void xsh_parameters_d2_detect_order_create(const char* recipe_id,
01075 cpl_parameterlist* list)
01076 {
01077
01078 XSH_ASSURE_NOT_NULL( recipe_id);
01079 XSH_ASSURE_NOT_NULL( list);
01080
01081
01082
01083
01084 check( xsh_parameters_new_double( list, recipe_id,
01085 "detectorder-d2-min-sn",
01086 10.,
01087 "minimum signal noise ratio in order"));
01088 cleanup:
01089 return;
01090 }
01091
01092
01104
01105
01106 xsh_d2_detect_order_param* xsh_parameters_d2_detect_order_get(
01107 const char* recipe_id, cpl_parameterlist* list)
01108 {
01109 xsh_d2_detect_order_param* result = NULL;
01110
01111
01112 XSH_ASSURE_NOT_NULL( list);
01113
01114
01115 XSH_MALLOC( result, xsh_d2_detect_order_param, 1);
01116
01117
01118 check( result->min_sn = xsh_parameters_get_double( list, recipe_id,
01119 "detectorder-d2-min-sn"));
01120
01121 cleanup:
01122 if(cpl_error_get_code() != CPL_ERROR_NONE){
01123 XSH_FREE( result);
01124 }
01125 return result;
01126 }
01127
01128
01136
01137 void xsh_parameters_background_create( const char* recipe_id,
01138 cpl_parameterlist* list)
01139 {
01140 char paramname[256];
01141 char recipename[256];
01142 cpl_parameter* p =NULL;
01143
01144 XSH_ASSURE_NOT_NULL(list);
01145
01146
01147
01148 check( xsh_parameters_new_int( list, recipe_id,
01149 "background-nb-y",
01150 100,
01151 "number of points of the grid in y direction"));
01152 check( xsh_parameters_new_int( list, recipe_id,
01153 "background-radius-x",
01154 -1,
01155 "half size of the subwindow in x direction (2 for UVB,VIS, 1 for NIR) [pixel units]."));
01156 check( xsh_parameters_new_int( list, recipe_id,
01157 "background-radius-y",
01158 2,
01159 "half size of the subwindow in y direction [pixel units]."));
01160 #if 1
01161 check( xsh_parameters_new_double( list, recipe_id,
01162 "background-min-grid-frac",
01163 0.3333,
01164 "Minimum fraction of points used to calculate median to the grid"));
01165
01166 #endif
01167 check( xsh_parameters_new_double( list, recipe_id,
01168 "background-grid-frac",
01169 0.5,
01170 "maximum fraction of points rejected from the grid"));
01171
01172
01173
01174
01175
01176
01177
01178
01179 sprintf(recipename,"xsh.%s",recipe_id);
01180 sprintf(paramname,"%s.%s",recipename,"background-method");
01181
01182 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
01183
01184 check(p = cpl_parameter_new_enum(paramname,CPL_TYPE_STRING,
01185 "method adopted for background estimation:",
01186 recipename,"median",
01187 4,"median","minimum","poly","no"));
01188
01189 check(cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
01190 "background-method"));
01191 check(cpl_parameterlist_append(list,p));
01192
01193 check( xsh_parameters_new_int( list, recipe_id,
01194 "background-smooth-x",
01195 -1,
01196 "Smoothing radius' half size in x direction [bin units]. "
01197 "If negative no smoothing is performed"));
01198
01199 check( xsh_parameters_new_int( list, recipe_id,
01200 "background-smooth-y",
01201 100,
01202 "Smoothing radius' half size in y direction [bin units]. "
01203 "If negative no smoothing is performed"));
01204
01205
01206
01207 check( xsh_parameters_new_int( list, recipe_id,
01208 "background-poly-deg-y",
01209 2,
01210 "Poly mode fit deg along Y."));
01211
01212 check( xsh_parameters_new_int( list, recipe_id,
01213 "background-poly-deg-x",
01214 2,
01215 "Poly mode fit deg along X."));
01216
01217 check( xsh_parameters_new_double( list, recipe_id,
01218 "background-poly-kappa",
01219 4.0,
01220 "Poly mode kappa value of kappa-sigma-clip outliers removal."));
01221
01222
01223
01224
01225
01226
01227
01228 cleanup:
01229 return;
01230 }
01231
01239
01240
01241 xsh_background_param* xsh_parameters_background_get(const char* recipe_id,
01242 cpl_parameterlist* list)
01243 {
01244 xsh_background_param* result = NULL;
01245
01246
01247 XSH_ASSURE_NOT_NULL( list );
01248
01249
01250 XSH_MALLOC( result, xsh_background_param, 1);
01251
01252
01253 check(result->sampley = xsh_parameters_get_int(list,recipe_id,
01254 "background-nb-y"));
01255 check(result->radius_x = xsh_parameters_get_int(list,recipe_id,
01256 "background-radius-x"));
01257 check(result->radius_y = xsh_parameters_get_int(list,recipe_id,
01258 "background-radius-y"));
01259 #if 1
01260 check(result->min_frac_grid = xsh_parameters_get_double(list,recipe_id,
01261 "background-min-grid-frac"));
01262 #endif
01263 check(result->max_frac_grid = xsh_parameters_get_double(list,recipe_id,
01264 "background-grid-frac"));
01265 check(result->method = xsh_parameters_get_string(list,recipe_id,
01266 "background-method"));
01267 check(result->smooth_x = xsh_parameters_get_int(list,recipe_id,
01268 "background-smooth-x"));
01269 check(result->smooth_y = xsh_parameters_get_int(list,recipe_id,
01270 "background-smooth-y"));
01271
01272 check(result->poly_deg_x = xsh_parameters_get_int(list,recipe_id,
01273 "background-poly-deg-x"));
01274
01275 check(result->poly_deg_y = xsh_parameters_get_int(list,recipe_id,
01276 "background-poly-deg-y"));
01277
01278 check(result->poly_kappa = xsh_parameters_get_double(list,recipe_id,
01279 "background-poly-kappa"));
01280
01281
01282
01283
01284 result->debug=true;
01285
01286 cleanup:
01287 if(cpl_error_get_code() != CPL_ERROR_NONE){
01288 XSH_FREE( result);
01289 }
01290 return result;
01291 }
01292
01293
01302
01303
01304 void xsh_parameters_detect_arclines_create(const char* recipe_id,
01305 cpl_parameterlist* list, xsh_detect_arclines_param p)
01306 {
01307 const char *method_string = NULL;
01308
01309 XSH_ASSURE_NOT_NULL(list);
01310
01311
01312 check( xsh_parameters_new_int(list,recipe_id,
01313 "detectarclines-fit-window-half-size",
01314 p.fit_window_hsize,
01315 "Half window size (HWS) in pixels for the line 2D fitting window"\
01316 " (total window size = 2*HWS+1)"));
01317
01318 check( xsh_parameters_new_int(list,recipe_id,
01319 "detectarclines-search-window-half-size",
01320 p.search_window_hsize,
01321 "Half window size (HWS) in pixels for the line search box around "\
01322 "the expected position (total window size = 2*HWS+1) [bin units]"));
01323
01324 check( xsh_parameters_new_int(list,recipe_id,
01325 "detectarclines-running-median-half-size",
01326 p.running_median_hsize,
01327 "Half window size in pixels (HWS) for the running median box"));
01328
01329 check( xsh_parameters_new_int( list, recipe_id,
01330 "detectarclines-wavesol-deg-lambda",
01331 p.wavesol_deg_lambda,
01332 "Degree in lambda in the polynomial solution "\
01333 "X=f(lambda,order,slit) and Y=f(lambda,order,slit) (POLY mode)"));
01334
01335 check( xsh_parameters_new_int( list, recipe_id,
01336 "detectarclines-wavesol-deg-order",
01337 p.wavesol_deg_order,
01338 "Degree in order in the polynomial solution "\
01339 "X=f(lambda,order,slit) and Y=f(lambda,order,slit) (POLY mode)"));
01340 if( strcmp("xsh_2dmap",recipe_id) == 0 ) {
01341
01342 check( xsh_parameters_new_int( list, recipe_id,
01343 "detectarclines-wavesol-deg-slit",
01344 p.wavesol_deg_slit,
01345 "Degree in slit in the polynomial solution "\
01346 "X=f(lambda,order,slit) and Y=f(lambda,order,slit) (POLY mode)"));
01347
01348 }
01349
01350 check(xsh_parameters_new_int(list, recipe_id,
01351 "detectarclines-ordertab-deg-y",
01352 p.ordertab_deg_y,
01353 "Degree in Y in the polynomial order tracing X=f(Y)")) ;
01354
01355 check( xsh_parameters_new_double( list, recipe_id,
01356 "detectarclines-min-sn",
01357 p.min_sn,
01358 "Minimum signal-to-noise ratio to filter lines [xsh_predict: UVB,VIS=5,NIR=4; xsh_2dmap: UVB=3, VIS=6, NIR=10]"));
01359
01360 if ( p.find_center_method == XSH_GAUSSIAN_METHOD){
01361 method_string= "gaussian";
01362 }
01363 else{
01364 method_string = "barycenter";
01365 }
01366 check( xsh_parameters_new_string( list, recipe_id,
01367 "detectarclines-find-lines-center", method_string,
01368 "Method used to find the center of the lines: gaussian, barycenter. Gaussian method applies a Gaussian fit to the line. Barycenter method computes the line centroid." ));
01369
01370
01371
01372
01373
01374
01375
01376 cleanup:
01377 return;
01378 }
01379
01380
01381
01389
01390 xsh_stack_param* xsh_stack_frames_get(
01391 const char* recipe_id, cpl_parameterlist* list)
01392 {
01393 xsh_stack_param* result = NULL;
01394
01395
01396
01397 XSH_ASSURE_NOT_NULL(list);
01398
01399
01400 XSH_MALLOC(result,xsh_stack_param,1);
01401
01402
01403 check( result->stack_method = xsh_parameters_get_string( list, recipe_id,
01404 "stack-method"));
01405
01406 check( result->klow = xsh_parameters_get_double( list, recipe_id,"klow"));
01407
01408 check( result->khigh = xsh_parameters_get_double( list, recipe_id,"khigh"));
01409
01410 check( result->niter = xsh_parameters_get_int( list, recipe_id,"niter"));
01411
01412
01413 cleanup:
01414 return result;
01415
01416 }
01417
01418
01426
01427 xsh_detect_arclines_param* xsh_parameters_detect_arclines_get(
01428 const char* recipe_id, cpl_parameterlist* list)
01429 {
01430 xsh_detect_arclines_param* result = NULL;
01431 const char *method_string = NULL;
01432
01433
01434 XSH_ASSURE_NOT_NULL(list);
01435
01436
01437 XSH_MALLOC(result,xsh_detect_arclines_param,1);
01438
01439
01440 check( result->fit_window_hsize = xsh_parameters_get_int( list, recipe_id,
01441 "detectarclines-fit-window-half-size"));
01442 check( result->search_window_hsize = xsh_parameters_get_int( list,
01443 recipe_id, "detectarclines-search-window-half-size"));
01444 check( result->running_median_hsize = xsh_parameters_get_int( list,
01445 recipe_id, "detectarclines-running-median-half-size"));
01446 check( result->wavesol_deg_lambda = xsh_parameters_get_int( list, recipe_id,
01447 "detectarclines-wavesol-deg-lambda"));
01448 if (strcmp("xsh_2dmap", recipe_id) == 0) {
01449 check(
01450 result->wavesol_deg_slit = xsh_parameters_get_int( list, recipe_id, "detectarclines-wavesol-deg-slit"));
01451 } else {
01452
01453 result->wavesol_deg_slit=0;
01454 }
01455 check( result->wavesol_deg_order = xsh_parameters_get_int( list, recipe_id,
01456 "detectarclines-wavesol-deg-order"));
01457 check( result->ordertab_deg_y = xsh_parameters_get_int( list, recipe_id,
01458 "detectarclines-ordertab-deg-y"));
01459 check( result->min_sn = xsh_parameters_get_double( list, recipe_id,
01460 "detectarclines-min-sn"));
01461 check( method_string = xsh_parameters_get_string( list, recipe_id,
01462 "detectarclines-find-lines-center"));
01463 if ( strcmp( method_string, "gaussian") == 0){
01464 result->find_center_method = XSH_GAUSSIAN_METHOD;
01465 }
01466 else{
01467 result->find_center_method = XSH_BARYCENTER_METHOD;
01468 }
01469
01470
01471
01472
01473 result->mode_iterative=false;
01474 cleanup:
01475 if(cpl_error_get_code() != CPL_ERROR_NONE){
01476 XSH_FREE(result);
01477 }
01478 return result;
01479 }
01480
01481
01493
01494 void xsh_parameters_clipping_detect_arclines_create(const char* recipe_id,
01495 cpl_parameterlist* list, xsh_clipping_param p)
01496 {
01497
01498 XSH_ASSURE_NOT_NULL(list);
01499
01500
01501 check(xsh_parameters_new_double( list, recipe_id,
01502 "detectarclines-clip-sigma",
01503 p.sigma,
01504 "Kappa value in sigma clipping during the polynomial solution "\
01505 "fit (POLY mode)"));
01506 check( xsh_parameters_new_int( list, recipe_id,
01507 "detectarclines-clip-niter",
01508 p.niter,
01509 "Number of iterations in sigma clipping during the polynomial "\
01510 "solution fit (POLY mode)"));
01511 check( xsh_parameters_new_double( list, recipe_id,
01512 "detectarclines-clip-frac",
01513 p.frac,
01514 "Minimal fractions of bad pixel allowed in sigma clipping during"\
01515 "the polynomial solution fit (POLY mode)"));
01516 cleanup:
01517 return;
01518 }
01519
01520
01532
01533 xsh_clipping_param* xsh_parameters_clipping_detect_arclines_get(
01534 const char* recipe_id, cpl_parameterlist* list)
01535 {
01536 xsh_clipping_param* result = NULL;
01537
01538
01539 XSH_ASSURE_NOT_NULL(list);
01540
01541
01542 XSH_MALLOC(result, xsh_clipping_param, 1);
01543
01544
01545 check(result->sigma = xsh_parameters_get_double(list,recipe_id,
01546 "detectarclines-clip-sigma"));
01547 check(result->niter = xsh_parameters_get_int(list,recipe_id,
01548 "detectarclines-clip-niter"));
01549 check(result->frac = xsh_parameters_get_double(list,recipe_id,
01550 "detectarclines-clip-frac"));
01551
01552 cleanup:
01553 if(cpl_error_get_code() != CPL_ERROR_NONE){
01554 XSH_FREE(result);
01555 }
01556 return result;
01557 }
01558
01559
01567
01568 void xsh_parameters_clipping_dcn_create(const char* recipe_id,
01569 cpl_parameterlist* list)
01570 {
01571
01572 XSH_ASSURE_NOT_NULL( list);
01573
01574
01575
01576 check( xsh_parameters_new_range_double(list,recipe_id,
01577 "detectcontinuum-clip-res-max", -1., -1., 2.,
01578 "Maximum allowed residual (before kappa-sigma clip)"));
01579
01580
01581 check(xsh_parameters_new_double(list,recipe_id,
01582 "detectcontinuum-clip-sigma", 5,
01583 "Kappa value in sigma clipping during order trace polynomial fit"));
01584
01585 check(xsh_parameters_new_int(list,recipe_id,
01586 "detectcontinuum-clip-niter", 5,
01587 "Number of iterations in sigma clipping during order trace "\
01588 "polynomial fit"));
01589
01590 check(xsh_parameters_new_double(list,recipe_id,
01591 "detectcontinuum-clip-frac", 0.4,
01592 "Minimal fractions of points accepted / total in sigma clipping"\
01593 "during order trace polynomial fit"));
01594
01595 cleanup:
01596 return;
01597 }
01598
01599
01611
01612 xsh_clipping_param* xsh_parameters_clipping_dcn_get(const char* recipe_id,
01613 cpl_parameterlist* list)
01614 {
01615 xsh_clipping_param* result = NULL;
01616
01617
01618 XSH_ASSURE_NOT_NULL(list);
01619
01620
01621 XSH_MALLOC(result, xsh_clipping_param, 1);
01622
01623
01624 check(result->res_max = xsh_parameters_get_double(list,recipe_id,
01625 "detectcontinuum-clip-res-max"));
01626 check(result->sigma = xsh_parameters_get_double(list,recipe_id,
01627 "detectcontinuum-clip-sigma"));
01628 check(result->niter = xsh_parameters_get_int(list,recipe_id,
01629 "detectcontinuum-clip-niter"));
01630 check(result->frac = xsh_parameters_get_double(list,recipe_id,
01631 "detectcontinuum-clip-frac"));
01632
01633 cleanup:
01634 if( cpl_error_get_code() != CPL_ERROR_NONE){
01635 cpl_free(result);
01636 result = NULL;
01637 }
01638 return result;
01639 }
01640
01641
01649 void xsh_parameters_detect_continuum_create( const char* recipe_id,
01650 cpl_parameterlist* list,
01651 xsh_detect_continuum_param par )
01652 {
01653
01654 XSH_ASSURE_NOT_NULL( list);
01655
01656
01657 check( xsh_parameters_new_int( list, recipe_id,
01658 "detectcontinuum-search-window-half-size",
01659 par.search_window,
01660 "Half window size in pixels for the 1D box to search for the "\
01661 "maximum in the cross-dispersion profile"));
01662
01663 check( xsh_parameters_new_int( list, recipe_id,
01664 "detectcontinuum-running-window-half-size",
01665 par.running_window,
01666 "Half window size for the running median box during the "\
01667 "search for the maximum in the cross-dispersion profile"));
01668
01669 check( xsh_parameters_new_int( list, recipe_id,
01670 "detectcontinuum-fit-window-half-size",
01671 par.fit_window,
01672 "Half window size for the fit of the cross-dispersion profile"));
01673
01674 check( xsh_parameters_new_double( list, recipe_id,
01675 "detectcontinuum-center-threshold-factor",
01676 par.fit_threshold,
01677 "Threshold factor applied to check that the flux at the fitted peak is "
01678 "higher than error."));
01679
01680 check( xsh_parameters_new_int( list, recipe_id,
01681 "detectcontinuum-ordertab-step-y",
01682 par.poly_step,
01683 "Step in Y for order centroid detection"));
01684
01685 check( xsh_parameters_new_int( list, recipe_id,
01686 "detectcontinuum-ordertab-deg-y",
01687 par.poly_degree,
01688 "Degree in Y in the polynomial order tracing X=f(Y)")) ;
01689
01690
01691
01692
01693
01694
01695
01696
01697
01698
01699
01700
01701
01702
01703
01704
01705
01706
01707
01708
01709
01710
01711
01712
01713
01714
01715
01716
01717
01718
01719
01720
01721 cleanup:
01722 return ;
01723 }
01724
01736 xsh_detect_continuum_param * xsh_parameters_detect_continuum_get(
01737 const char* recipe_id, cpl_parameterlist* list)
01738 {
01739 xsh_detect_continuum_param* result = NULL;
01740
01741
01742 XSH_ASSURE_NOT_NULL( list);
01743
01744
01745 XSH_MALLOC( result, xsh_detect_continuum_param, 1);
01746
01747
01748 check( result->search_window = xsh_parameters_get_int( list, recipe_id,
01749 "detectcontinuum-search-window-half-size"));
01750 check( result->fit_window = xsh_parameters_get_int( list, recipe_id,
01751 "detectcontinuum-fit-window-half-size"));
01752 check( result->fit_threshold = xsh_parameters_get_double( list, recipe_id,
01753 "detectcontinuum-center-threshold-factor"));
01754 check( result->running_window = xsh_parameters_get_int( list, recipe_id,
01755 "detectcontinuum-running-window-half-size"));
01756 check( result->poly_degree = xsh_parameters_get_int( list, recipe_id,
01757 "detectcontinuum-ordertab-deg-y"));
01758 check( result->poly_step = xsh_parameters_get_int( list, recipe_id,
01759 "detectcontinuum-ordertab-step-y"));
01760
01761
01762
01763
01764
01765
01766
01767
01768
01769
01770
01771
01772 cleanup:
01773 if(cpl_error_get_code() != CPL_ERROR_NONE){
01774 XSH_FREE(result);
01775 }
01776 return result;
01777 }
01778
01787
01788 void xsh_parameters_clipping_tilt_create(const char* recipe_id,
01789 cpl_parameterlist* list)
01790 {
01791
01792 XSH_ASSURE_NOT_NULL( list);
01793
01794
01795 check( xsh_parameters_new_double( list, recipe_id,
01796 "tilt-clip-kappa",
01797 2.5,
01798 "Multiple of sigma in sigma clipping for evaluate tilt"));
01799 check( xsh_parameters_new_int( list, recipe_id,
01800 "tilt-clip-niter",
01801 5,
01802 "Number of iterations in sigma clipping for evaluate tilt"));
01803 check( xsh_parameters_new_double( list, recipe_id,
01804 "tilt-clip-frac",
01805 0.7,
01806 "Minimal fractions of points accepted / total in sigma clipping for evaluate tilt"));
01807
01808 cleanup:
01809 return;
01810 }
01811
01819
01820 xsh_clipping_param * xsh_parameters_clipping_tilt_get(const char* recipe_id,
01821 cpl_parameterlist* list)
01822 {
01823 xsh_clipping_param* result = NULL;
01824
01825
01826 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
01827
01828
01829 check(result = (xsh_clipping_param*)(cpl_malloc(sizeof(xsh_clipping_param)))
01830 );
01831 assure (result != NULL, CPL_ERROR_ILLEGAL_OUTPUT,
01832 "Memory allocation failed!");
01833
01834
01835 check(result->sigma = xsh_parameters_get_double(list,recipe_id,
01836 "tilt-clip-kappa"));
01837 check(result->niter = xsh_parameters_get_int(list,recipe_id,
01838 "tilt-clip-niter"));
01839 check(result->frac = xsh_parameters_get_double(list,recipe_id,
01840 "tilt-clip-frac"));
01841
01842 cleanup:
01843 if(cpl_error_get_code() != CPL_ERROR_NONE){
01844 cpl_free(result);
01845 result = NULL;
01846 }
01847 return result;
01848 }
01849
01858
01859 void xsh_parameters_clipping_specres_create(const char* recipe_id,
01860 cpl_parameterlist* list)
01861 {
01862
01863 XSH_ASSURE_NOT_NULL( list);
01864
01865
01866 check( xsh_parameters_new_double( list, recipe_id,
01867 "specres-clip-kappa",
01868 2.5,
01869 "Multiple of sigma in sigma clipping for evaluate spectral resolution"));
01870 check( xsh_parameters_new_int( list, recipe_id,
01871 "specres-clip-niter",
01872 5,
01873 "Number of iterations in sigma clipping for evaluate spectral resolution"));
01874 check( xsh_parameters_new_double( list, recipe_id,
01875 "specres-clip-frac",
01876 0.7,
01877 "Minimal fractions of points accepted / total in sigma clipping for evaluate spectral resolution"));
01878
01879 cleanup:
01880 return;
01881 }
01882
01890
01891 xsh_clipping_param * xsh_parameters_clipping_specres_get(const char* recipe_id,
01892 cpl_parameterlist* list)
01893 {
01894 xsh_clipping_param* result = NULL;
01895
01896
01897 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
01898
01899
01900 check(result = (xsh_clipping_param*)(cpl_malloc(sizeof(xsh_clipping_param)))
01901 );
01902 assure (result != NULL, CPL_ERROR_ILLEGAL_OUTPUT,
01903 "Memory allocation failed!");
01904
01905
01906 check(result->sigma = xsh_parameters_get_double(list,recipe_id,
01907 "specres-clip-kappa"));
01908 check(result->niter = xsh_parameters_get_int(list,recipe_id,
01909 "specres-clip-niter"));
01910 check(result->frac = xsh_parameters_get_double(list,recipe_id,
01911 "specres-clip-frac"));
01912
01913 cleanup:
01914 if(cpl_error_get_code() != CPL_ERROR_NONE){
01915 cpl_free(result);
01916 result = NULL;
01917 }
01918 return result;
01919 }
01920
01921
01922 void xsh_parameters_wavecal_range_create(const char* recipe_id,
01923 cpl_parameterlist* list)
01924 {
01925
01926 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
01927
01928
01929
01930 check(xsh_parameters_new_range_int( list, recipe_id,
01931 "followarclines-search-window-half-size",
01932 WAVECAL_RANGE_DEFAULT, 1, 4096,
01933 "Half window size (HWS) in pixels (Y axis) of search window for each line."
01934 ));
01935
01936 cleanup:
01937 return;
01938 }
01939
01940 int xsh_parameters_wavecal_range_get( const char* recipe_id,
01941 cpl_parameterlist* list)
01942 {
01943 int result = 0;
01944
01945 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
01946
01947 check( result = xsh_parameters_get_int( list, recipe_id,
01948 "followarclines-search-window-half-size"));
01949
01950 cleanup:
01951 return result ;
01952 }
01953
01954 void xsh_parameters_wavecal_margin_create(const char* recipe_id,
01955 cpl_parameterlist* list)
01956 {
01957
01958 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
01959
01960
01961
01962 check(xsh_parameters_new_range_int( list, recipe_id,
01963 "followarclines-order-edges-mask",
01964 WAVECAL_MARGIN_DEFAULT, 0, 20,
01965 "Nb of pixels suppressed (X) from edges of search window."
01966 "" ));
01967
01968 cleanup:
01969 return;
01970 }
01971
01972 int xsh_parameters_wavecal_margin_get( const char* recipe_id,
01973 cpl_parameterlist* list)
01974 {
01975 int result = 0;
01976
01977 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
01978
01979 check( result = xsh_parameters_get_int( list, recipe_id,
01980 "followarclines-order-edges-mask"));
01981
01982 cleanup:
01983 return result ;
01984 }
01985
01986 void xsh_parameters_wavecal_s_n_create(const char* recipe_id,
01987 cpl_parameterlist* list)
01988 {
01989
01990 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
01991
01992
01993
01994 check(xsh_parameters_new_double( list, recipe_id,
01995 "followarclines-min-sn",
01996 -1.,
01997 "Minimum Signal over Noise ratio at center to keep the line (6 for IFU, 15 for SLIT)."
01998 ));
01999
02000 cleanup:
02001 return;
02002 }
02003
02004 double xsh_parameters_wavecal_s_n_get( const char* recipe_id,
02005 cpl_parameterlist* list)
02006 {
02007 int result = 0;
02008
02009 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
02010
02011 check( result = xsh_parameters_get_double( list, recipe_id,
02012 "followarclines-min-sn"));
02013
02014 cleanup:
02015 return result ;
02016 }
02017
02018
02019
02020 void xsh_parameters_use_model_create( const char * recipe_id,
02021 cpl_parameterlist * plist )
02022 {
02023 XSH_ASSURE_NOT_NULL( recipe_id ) ;
02024 XSH_ASSURE_NOT_NULL( plist ) ;
02025
02026 check( xsh_parameters_new_string( plist, recipe_id, "use-model", "no",
02027 "If 'no', use wavecal solution, otherwise use model. Default is 'no'" ) ) ;
02028 cleanup:
02029 return ;
02030 }
02031
02032
02033
02034 int xsh_parameters_use_model_get( const char * recipe_id,
02035 const cpl_parameterlist * plist )
02036 {
02037 char * yesno = NULL ;
02038
02039 XSH_ASSURE_NOT_NULL( recipe_id ) ;
02040 XSH_ASSURE_NOT_NULL( plist ) ;
02041
02042 yesno = xsh_parameters_get_string( plist, recipe_id, "use-model" ) ;
02043
02044 if ( strcmp( yesno, "yes" ) == 0 ) return 1 ;
02045 else return 0 ;
02046
02047 cleanup:
02048 return 0 ;
02049 }
02050
02051
02052
02053
02054
02055 void xsh_parameters_remove_crh_single_create( const char * recipe_id,
02056 cpl_parameterlist * plist,
02057 xsh_remove_crh_single_param p )
02058 {
02059 XSH_ASSURE_NOT_NULL( recipe_id ) ;
02060 XSH_ASSURE_NOT_NULL( plist ) ;
02061
02062 check(xsh_parameters_new_double(plist,recipe_id,
02063 "removecrhsingle-frac-max",
02064 p.crh_frac_max,
02065 "Max fraction of bad pixels allowed"));
02066 check(xsh_parameters_new_double(plist,recipe_id,
02067 "removecrhsingle-sigmalim",
02068 p.sigma_lim,
02069 "Poisson fluctuation threshold to flag CRHs (see van Dokkum, PASP,113,2001,p1420-27)"));
02070 check(xsh_parameters_new_double(plist,recipe_id,
02071 "removecrhsingle-flim",
02072 p.f_lim,
02073 "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)"));
02074 check(xsh_parameters_new_int(plist,recipe_id,
02075 "removecrhsingle-niter",
02076 p.nb_iter,
02077 "Max number of iterations"));
02078
02079 cleanup:
02080 return ;
02081 }
02082
02083 xsh_remove_crh_single_param * xsh_parameters_remove_crh_single_get(
02084 const char* recipe_id,
02085 cpl_parameterlist* list)
02086 {
02087 xsh_remove_crh_single_param * result = NULL ;
02088
02089
02090 XSH_ASSURE_NOT_NULL(list);
02091
02092
02093 XSH_MALLOC( result, xsh_remove_crh_single_param, 1);
02094
02095
02096 check(result->crh_frac_max = xsh_parameters_get_double(list,recipe_id,
02097 "removecrhsingle-frac-max"));
02098 check(result->sigma_lim = xsh_parameters_get_double(list,recipe_id,
02099 "removecrhsingle-sigmalim"));
02100 check(result->f_lim = xsh_parameters_get_double(list,recipe_id,
02101 "removecrhsingle-flim"));
02102 check(result->nb_iter = xsh_parameters_get_int(list,recipe_id,
02103 "removecrhsingle-niter"));
02104
02105 cleanup:
02106 if(cpl_error_get_code() != CPL_ERROR_NONE){
02107 cpl_free(result);
02108 result = NULL;
02109 }
02110 return result;
02111
02112 }
02113
02114
02115
02116
02117
02118 typedef struct {
02119 const char * name ;
02120 int type ;
02121 } XSH_KERNEL_TYPE ;
02122
02123 static const XSH_KERNEL_TYPE xsh_ker_type[] = {
02124 {"tanh", CPL_KERNEL_TANH},
02125 {"sinc", CPL_KERNEL_SINC},
02126 {"sinc2", CPL_KERNEL_SINC2},
02127 {"lanczos", CPL_KERNEL_LANCZOS},
02128 {"hamming", CPL_KERNEL_HAMMING},
02129 {"hann", CPL_KERNEL_HANN},
02130 {NULL, 0}
02131 } ;
02132
02133 static void set_rectify_kernel_type( xsh_rectify_param *recpar )
02134 {
02135 const XSH_KERNEL_TYPE * pk = xsh_ker_type ;
02136
02137 for( ; pk->name != NULL ; pk++ )
02138 if ( strcasecmp( recpar->rectif_kernel, pk->name ) == 0 ) {
02139 recpar->kernel_type = pk->type ;
02140 return ;
02141 }
02142 recpar->kernel_type = CPL_KERNEL_DEFAULT ;
02143
02144 return ;
02145 }
02146
02147 static const char * get_ker_default( void )
02148 {
02149 const XSH_KERNEL_TYPE * pk = xsh_ker_type ;
02150
02151 for( ; pk->name != NULL ; pk++ )
02152 if ( pk->type == CPL_KERNEL_DEFAULT ) {
02153 return pk->name ;
02154 }
02155 return "unknown" ;
02156
02157 }
02158 void xsh_parameters_rectify_create( const char * recipe_id,
02159 cpl_parameterlist * plist,
02160 xsh_rectify_param p )
02161 {
02162 char ker_comment[256];
02163
02164 XSH_ASSURE_NOT_NULL( recipe_id ) ;
02165 XSH_ASSURE_NOT_NULL( plist ) ;
02166
02167 sprintf( ker_comment,
02168 "Name of the Interpolation Kernel Used. Possible values are"\
02169 " %s, tanh, sinc, sinc2, lanczos, hamming, hann\n ",get_ker_default());
02170
02171 check(xsh_parameters_new_string(plist,recipe_id,
02172 "rectify-kernel",
02173 p.rectif_kernel, ker_comment));
02174
02175 check(xsh_parameters_new_double(plist,recipe_id,
02176 "rectify-radius",
02177 p.rectif_radius,
02178 "Rectify Interpolation radius [bin units]"));
02179
02180 check(xsh_parameters_new_double(plist,recipe_id,
02181 "rectify-bin-lambda",
02182 p.rectif_bin_lambda,
02183 "Wavelength step in the output spectrum [nm]"));
02184
02185 check(xsh_parameters_new_double(plist,recipe_id,
02186 "rectify-bin-slit",
02187 p.rectif_bin_space,
02188 "Spatial step along the slit in the output spectrum [arcsec]"));
02189
02190
02191
02192
02193
02194
02195 check( xsh_parameters_new_boolean( plist, recipe_id,
02196 "rectify-conserve-flux", p.conserve_flux,
02197 "Use flux conservation if TRUE"));
02198
02199
02200
02201
02202
02203
02204
02205
02206
02207
02208
02209
02210
02211
02212
02213
02214 cleanup:
02215 return ;
02216 }
02217
02218 int xsh_parameters_rectify_fast_get( const char* recipe_id,
02219 cpl_parameterlist* list)
02220 {
02221 int result = 0 ;
02222
02223
02224 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
02225
02226 check( result = xsh_parameters_get_boolean( list,
02227 recipe_id, "rectify-fast"));
02228
02229 cleanup:
02230 return result ;
02231 }
02232
02233 xsh_rectify_param * xsh_parameters_rectify_get( const char* recipe_id,
02234 cpl_parameterlist* list)
02235 {
02236 xsh_rectify_param * result = NULL ;
02237 char *p ;
02238
02239
02240 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
02241
02242
02243 check(result = (xsh_rectify_param *)(cpl_malloc(
02244 sizeof(xsh_rectify_param))) );
02245 assure (result != NULL, CPL_ERROR_ILLEGAL_OUTPUT,
02246 "Memory allocation failed!");
02247
02248
02249 check(p = xsh_parameters_get_string(list,recipe_id,
02250 "rectify-kernel"));
02251 strcpy( result->rectif_kernel, p ) ;
02252 check(result->rectif_radius = xsh_parameters_get_double(list,recipe_id,
02253 "rectify-radius"));
02254 check(result->rectif_bin_lambda = xsh_parameters_get_double(list,recipe_id,
02255 "rectify-bin-lambda"));
02256 check(result->rectif_bin_space = xsh_parameters_get_double(list,recipe_id,
02257 "rectify-bin-slit"));
02258
02259
02260
02261
02262
02263 result->rectify_full_slit=true;
02264 check( result->conserve_flux = xsh_parameters_get_boolean( list,
02265 recipe_id, "rectify-conserve-flux"));
02266
02267
02268
02269
02270
02271
02272
02273
02274 set_rectify_kernel_type( result ) ;
02275
02276 cleanup:
02277 if(cpl_error_get_code() != CPL_ERROR_NONE){
02278 cpl_free(result);
02279 result = NULL;
02280 }
02281 return result;
02282 }
02283
02284 void
02285 xsh_parameters_compute_response_create( const char * recipe_id,
02286 cpl_parameterlist * plist,
02287 xsh_compute_response_param p )
02288 {
02289
02290 assure(plist != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
02291
02292 check(xsh_parameters_new_double(plist,recipe_id,
02293 "compute-response-lambda-step",
02294 p.lambda_bin,
02295 "Compute Response Interpolation Lambda Step"));
02296
02297 cleanup:
02298 return ;
02299 }
02300
02301 xsh_compute_response_param *
02302 xsh_parameters_compute_response_get( const char * recipe_id,
02303 cpl_parameterlist * list)
02304 {
02305 xsh_compute_response_param * result = NULL ;
02306
02307 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
02308
02309
02310 check(result = (xsh_compute_response_param *)(cpl_malloc(
02311 sizeof(xsh_compute_response_param))) );
02312 assure (result != NULL, CPL_ERROR_ILLEGAL_OUTPUT,
02313 "Memory allocation failed!");
02314
02315
02316 check(result->lambda_bin =
02317 xsh_parameters_get_double(list,recipe_id,
02318 "compute-response-lambda-step"));
02319
02320 cleanup:
02321 if(cpl_error_get_code() != CPL_ERROR_NONE){
02322 cpl_free(result);
02323 result = NULL;
02324 }
02325 return result;
02326
02327 }
02328
02329
02330
02331
02332 void xsh_parameters_localize_obj_create( const char * recipe_id,
02333 cpl_parameterlist * plist, xsh_localize_obj_param p)
02334 {
02335 XSH_ASSURE_NOT_NULL( recipe_id);
02336 XSH_ASSURE_NOT_NULL( plist);
02337
02338 check( xsh_parameters_new_string( plist, recipe_id,
02339 "localize-method",
02340 LOCALIZE_METHOD_PRINT(p.method),
02341 "Localization method (MANUAL, MAXIMUM, GAUSSIAN) used to detect "\
02342 "the object centroid and height on the slit"));
02343
02344 check( xsh_parameters_new_int( plist, recipe_id,
02345 "localize-chunk-nb",
02346 p.loc_chunk_nb,
02347 "Number of chunks in the full spectrum to localize the object"));
02348 check( xsh_parameters_new_double( plist, recipe_id,
02349 "localize-thresh",
02350 p.loc_thresh,
02351 "Threshold relative to the peak intensity below which the edges "\
02352 "of the object are detected for MAXIMUM localization"));
02353 check( xsh_parameters_new_int( plist, recipe_id,
02354 "localize-deg-lambda",
02355 p.loc_deg_poly,
02356 "Degree in lambda in the localization polynomial expression "\
02357 "slit=f(lambda), used only for MAXIMUM and GAUSSIAN"));
02358
02359 if (strcmp(recipe_id,"xsh_scired_slit_nod")==0){
02360 check( xsh_parameters_new_double( plist, recipe_id,
02361 "localize-slit-position",
02362 p.slit_position,
02363 "Object position on the slit for MANUAL localization [arcsec]. It refers to the object position in the first frame of the nodding sequence"));
02364 }
02365 else {
02366 check( xsh_parameters_new_double( plist, recipe_id,
02367 "localize-slit-position",
02368 p.slit_position,
02369 "Object position on the slit for MANUAL localization [arcsec]"));
02370 }
02371 check( xsh_parameters_new_double( plist, recipe_id,
02372 "localize-slit-hheight",
02373 p.slit_hheight,
02374 "Object half height on the slit for MANUAL localization [arcsec]"));
02375 check( xsh_parameters_new_double( plist, recipe_id,
02376 "localize-kappa",
02377 p.kappa,
02378 "Kappa value for sigma clipping in the localization "\
02379 "polynomial fit"));
02380 check( xsh_parameters_new_int( plist, recipe_id,
02381 "localize-niter",
02382 p.niter,
02383 "Number of iterations for sigma clipping in the localization "\
02384 "polynomial fit"));
02385
02386 check(xsh_parameters_new_boolean( plist, recipe_id,
02387 "localize-use-skymask", p.use_skymask,
02388 "TRUE if we want to mask sky lines using SKY_LINE_LIST file."));
02389
02390 cleanup:
02391 return ;
02392 }
02393
02394 xsh_localize_obj_param* xsh_parameters_localize_obj_get(
02395 const char* recipe_id, cpl_parameterlist* list)
02396 {
02397 xsh_localize_obj_param * result = NULL ;
02398 const char* par_method = NULL;
02399
02400
02401 XSH_ASSURE_NOT_NULL(list);
02402
02403
02404 XSH_MALLOC( result, xsh_localize_obj_param, 1);
02405
02406
02407 check( result->loc_chunk_nb = xsh_parameters_get_int( list,recipe_id,
02408 "localize-chunk-nb"));
02409 check( result->loc_thresh = xsh_parameters_get_double( list,recipe_id,
02410 "localize-thresh"));
02411 check( result->loc_deg_poly = xsh_parameters_get_int( list,recipe_id,
02412 "localize-deg-lambda"));
02413 check( par_method = xsh_parameters_get_string( list, recipe_id,
02414 "localize-method"));
02415 if ( strcmp( LOCALIZE_METHOD_PRINT(LOC_MANUAL_METHOD), par_method) == 0){
02416 result->method = LOC_MANUAL_METHOD;
02417 }
02418 else if (strcmp( LOCALIZE_METHOD_PRINT(LOC_MAXIMUM_METHOD), par_method) == 0){
02419 result->method = LOC_MAXIMUM_METHOD;
02420 }
02421 else if (strcmp( LOCALIZE_METHOD_PRINT(LOC_GAUSSIAN_METHOD), par_method) == 0){
02422 result->method = LOC_GAUSSIAN_METHOD;
02423 }
02424 else {
02425 xsh_error_msg("WRONG parameter localize-method %s",par_method);
02426 }
02427 check( result->slit_position = xsh_parameters_get_double( list, recipe_id,
02428 "localize-slit-position"));
02429 check( result->slit_hheight = xsh_parameters_get_double( list, recipe_id,
02430 "localize-slit-hheight"));
02431 check( result->kappa = xsh_parameters_get_double( list, recipe_id,
02432 "localize-kappa"));
02433 check( result->niter = xsh_parameters_get_int( list, recipe_id,
02434 "localize-niter"));
02435 check( result->use_skymask = xsh_parameters_get_boolean( list, recipe_id,
02436 "localize-use-skymask"));
02437
02438 cleanup:
02439 if(cpl_error_get_code() != CPL_ERROR_NONE){
02440 XSH_FREE( result);
02441 }
02442 return result;
02443
02444 }
02445
02446
02447
02448
02449
02450 void xsh_parameters_localize_ifu_create( const char * recipe_id,
02451 cpl_parameterlist * plist, xsh_localize_ifu_param p)
02452 {
02453 XSH_ASSURE_NOT_NULL( recipe_id);
02454 XSH_ASSURE_NOT_NULL( plist);
02455
02456 check( xsh_parameters_new_int( plist, recipe_id,
02457 "localizeifu-bckg-deg",
02458 p.bckg_deg,
02459 "Degree (<=2) of the polynomial component in the cross-dispersion profile fit"));
02460
02461 check( xsh_parameters_new_int( plist, recipe_id,
02462 "localizeifu-smooth-hsize",
02463 p.smooth_hsize,
02464 "Half-size of the median filter for smoothing the cross-dispersion profile prior to localization"));
02465
02466 check( xsh_parameters_new_int( plist, recipe_id,
02467 "localizeifu-wavelet-nscales",
02468 p.nscales,
02469 "Number of scales used for wavelet a trous algorithm"));
02470
02471 check( xsh_parameters_new_int( plist, recipe_id,
02472 "localizeifu-wavelet-hf-skip",
02473 p.HF_skip,
02474 "Number of high frequency scales skipped from the wavelet decomposition"));
02475
02476 check( xsh_parameters_new_double( plist, recipe_id,
02477 "localizeifu-sigma-low",
02478 p.cut_sigma_low,
02479 "Gaussian fits of the cross-dispersion profile whose FWHM is lower than this value are rejected"));
02480
02481 check( xsh_parameters_new_double( plist, recipe_id,
02482 "localizeifu-sigma-up",
02483 p.cut_sigma_up,
02484 "Gaussian fits of the cross-dispersion profile whose FWHM is larger than this value are rejected"));
02485
02486 check( xsh_parameters_new_double( plist, recipe_id,
02487 "localizeifu-snr-low",
02488 p.cut_snr_low,
02489 "Gaussian fits of the cross-dispersion profile whose SNR is lower than this value are rejected"));
02490
02491 check( xsh_parameters_new_double( plist, recipe_id,
02492 "localizeifu-snr-up",
02493 p.cut_snr_up,
02494 "Gaussian fits of the cross-dispersion profile whose SNR is larger than this value are rejected"));
02495
02496 check( xsh_parameters_new_double( plist, recipe_id,
02497 "localizeifu-slitlow-edges-mask",
02498 p.slitlow_edges_mask,
02499 "in arsec"));
02500
02501 check( xsh_parameters_new_double( plist, recipe_id,
02502 "localizeifu-slitup-edges-mask",
02503 p.slitup_edges_mask,
02504 "in arsec"));
02505
02506 check(xsh_parameters_new_boolean( plist, recipe_id,
02507 "localizeifu-use-skymask", p.use_skymask,
02508 "TRUE if we want to mask sky lines using SKY_LINE_LIST file."));
02509
02510 check(xsh_parameters_new_int( plist, recipe_id,
02511 "localizeifu-chunk-hsize", p.box_hsize,
02512 "Half size of chunk [bin]"));
02513
02514 cleanup:
02515 return;
02516 }
02517 xsh_localize_ifu_param * xsh_parameters_localize_ifu_get(
02518 const char* recipe_id, cpl_parameterlist* list)
02519 {
02520 xsh_localize_ifu_param *result = NULL ;
02521
02522
02523 XSH_ASSURE_NOT_NULL(list);
02524
02525
02526 XSH_MALLOC( result, xsh_localize_ifu_param, 1);
02527
02528 check( result->bckg_deg = xsh_parameters_get_int( list, recipe_id,
02529 "localizeifu-bckg-deg"));
02530 check( result->smooth_hsize = xsh_parameters_get_int( list, recipe_id,
02531 "localizeifu-smooth-hsize"));
02532
02533 check( result->nscales = xsh_parameters_get_int( list, recipe_id,
02534 "localizeifu-wavelet-nscales"));
02535
02536 check( result->HF_skip = xsh_parameters_get_int( list, recipe_id,
02537 "localizeifu-wavelet-hf-skip"));
02538
02539 check( result->cut_sigma_low = xsh_parameters_get_double( list, recipe_id,
02540 "localizeifu-sigma-low"));
02541 check( result->cut_sigma_up = xsh_parameters_get_double( list, recipe_id,
02542 "localizeifu-sigma-up"));
02543
02544 check( result->cut_snr_low = xsh_parameters_get_double( list, recipe_id,
02545 "localizeifu-snr-low"));
02546 check( result->cut_snr_up = xsh_parameters_get_double( list, recipe_id,
02547 "localizeifu-snr-up"));
02548
02549 check( result->slitlow_edges_mask = xsh_parameters_get_double( list, recipe_id,
02550 "localizeifu-slitlow-edges-mask"));
02551 check( result->slitup_edges_mask = xsh_parameters_get_double( list, recipe_id,
02552 "localizeifu-slitup-edges-mask"));
02553
02554 check( result->use_skymask = xsh_parameters_get_boolean( list, recipe_id,
02555 "localizeifu-use-skymask"));
02556
02557 check( result->box_hsize = xsh_parameters_get_int( list, recipe_id,
02558 "localizeifu-chunk-hsize"));
02559
02560 cleanup:
02561 if(cpl_error_get_code() != CPL_ERROR_NONE){
02562 XSH_FREE( result);
02563 }
02564 return result;
02565 }
02566
02567
02568
02569
02570
02571
02572
02573 void xsh_parameters_extract_create( const char * recipe_id,
02574 cpl_parameterlist * plist,
02575 xsh_extract_param p,
02576 enum extract_method method)
02577 {
02578 XSH_ASSURE_NOT_NULL( recipe_id);
02579 XSH_ASSURE_NOT_NULL( plist);
02580
02581 check( xsh_parameters_new_string( plist, recipe_id,
02582 "extract-method", EXTRACT_METHOD_PRINT(method),
02583 "Method used for extraction (LOCALIZATION, NOD)"));
02584
02585 cleanup:
02586 return ;
02587 }
02588
02589 xsh_extract_param * xsh_parameters_extract_get(
02590 const char* recipe_id, cpl_parameterlist* list)
02591 {
02592 xsh_extract_param *result = NULL ;
02593 const char *par_method = NULL;
02594
02595
02596 XSH_ASSURE_NOT_NULL( recipe_id);
02597 XSH_ASSURE_NOT_NULL( list);
02598
02599
02600 XSH_MALLOC( result, xsh_extract_param, 1);
02601
02602
02603 check( par_method = xsh_parameters_get_string( list, recipe_id,
02604 "extract-method"));
02605 if ( strcmp( EXTRACT_METHOD_PRINT(LOCALIZATION_METHOD), par_method) == 0){
02606 result->method = LOCALIZATION_METHOD;
02607 }
02608 else if (strcmp( EXTRACT_METHOD_PRINT(FULL_METHOD), par_method) == 0){
02609 result->method = FULL_METHOD;
02610 }
02611 else if (strcmp( EXTRACT_METHOD_PRINT(NOD_METHOD), par_method) == 0){
02612 result->method = NOD_METHOD;
02613 }
02614 else {
02615 xsh_error_msg("WRONG parameter extract-method %s",par_method);
02616 }
02617
02618 cleanup:
02619 if(cpl_error_get_code() != CPL_ERROR_NONE){
02620 cpl_free(result);
02621 result = NULL;
02622 }
02623 return result;
02624 }
02625
02626
02627
02628
02629
02630
02631 void xsh_parameters_subtract_sky_single_create( const char * recipe_id,
02632 cpl_parameterlist * plist,
02633 xsh_subtract_sky_single_param p )
02634 {
02635 XSH_ASSURE_NOT_NULL( recipe_id);
02636 XSH_ASSURE_NOT_NULL( plist);
02637
02638 check(xsh_parameters_new_boolean( plist, recipe_id,
02639 "sky-subtract", TRUE,
02640 "TRUE to use subtract sky single."));
02641
02642 check( xsh_parameters_new_int( plist, recipe_id,
02643 "sky-bspline-nbkpts-first",
02644 p.nbkpts1,
02645 "Nb of break points for Bezier curve fitting (without localization)"));
02646 check( xsh_parameters_new_int( plist,recipe_id,
02647 "sky-bspline-nbkpts-second",
02648 p.nbkpts2,
02649 "Nb of break points for Bezier curve fitting (with localization)"));
02650
02651 check( xsh_parameters_new_int( plist, recipe_id,
02652 "sky-bspline-order",
02653 p.bezier_spline_order,
02654 "Bezier spline order"));
02655
02656 check( xsh_parameters_new_int( plist, recipe_id,
02657 "sky-bspline-niter",
02658 p.niter,
02659 "Nb of iterations"));
02660
02661 check( xsh_parameters_new_double( plist, recipe_id,
02662 "sky-bspline-kappa",
02663 p.kappa,
02664 "Kappa value used to kappa-sigma-clip object"));
02665
02666 check( xsh_parameters_new_double( plist, recipe_id,
02667 "sky-bspline-ron",
02668 p.ron,
02669 "Detector RON (if -1 is automatically set)"));
02670
02671
02672 check( xsh_parameters_new_double( plist, recipe_id,
02673 "sky-bspline-gain",
02674 p.gain,
02675 "Detector gain (if -1 is automatically set)"));
02676
02677 check( xsh_parameters_new_string( plist, recipe_id,
02678 "sky-method",
02679 SKY_METHOD_PRINT(p.method), "Sky subtract Method (BSPLINE, MEDIAN)"));
02680
02681 check( xsh_parameters_new_string( plist, recipe_id,
02682 "bspline-sampling",
02683 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)"));
02684
02685 check( xsh_parameters_new_int( plist, recipe_id,
02686 "sky-median-hsize",
02687 p.median_hsize , "Half size of the running median. If sky-method=MEDIAN "));
02688
02689 check( xsh_parameters_new_double( plist, recipe_id,
02690 "sky-slit-edges-mask",
02691 p.slit_edges_mask,
02692 "Size of edges mask in arcsec"));
02693
02694 check( xsh_parameters_new_double( plist, recipe_id,
02695 "sky-position1",
02696 p.pos1,
02697 "Central position of the sky window #1 [arcsec]"));
02698
02699 check( xsh_parameters_new_double( plist, recipe_id,
02700 "sky-hheight1",
02701 p.hheight1,
02702 "Half size of sky window #1 [arcsec]"));
02703
02704 check( xsh_parameters_new_double( plist, recipe_id,
02705 "sky-position2",
02706 p.pos2,
02707 "Central position of the sky window #2 [arcsec]"));
02708
02709 check( xsh_parameters_new_double( plist, recipe_id,
02710 "sky-hheight2",
02711 p.hheight2,
02712 "Half size of the sky window #2 [arcsec]"));
02713
02714 cleanup:
02715 return ;
02716 }
02717
02718 xsh_subtract_sky_single_param* xsh_parameters_subtract_sky_single_get(
02719 const char* recipe_id, cpl_parameterlist* list)
02720 {
02721 xsh_subtract_sky_single_param *result = NULL ;
02722 const char* par_method = NULL;
02723 const char* bspline_sampling = NULL;
02724
02725
02726 XSH_ASSURE_NOT_NULL( recipe_id);
02727 XSH_ASSURE_NOT_NULL( list);
02728
02729
02730 XSH_MALLOC( result, xsh_subtract_sky_single_param, 1);
02731
02732
02733 check( result->nbkpts1 = xsh_parameters_get_int( list, recipe_id,
02734 "sky-bspline-nbkpts-first"));
02735 check( result->nbkpts2 = xsh_parameters_get_int( list, recipe_id,
02736 "sky-bspline-nbkpts-second"));
02737 check( result->bezier_spline_order = xsh_parameters_get_int( list, recipe_id,
02738 "sky-bspline-order"));
02739 check( result->niter = xsh_parameters_get_int( list, recipe_id,
02740 "sky-bspline-niter"));
02741 check( result->kappa = xsh_parameters_get_double( list, recipe_id,
02742 "sky-bspline-kappa"));
02743 check( result->ron = xsh_parameters_get_double( list, recipe_id,
02744 "sky-bspline-ron"));
02745 check( result->gain = xsh_parameters_get_double( list, recipe_id,
02746 "sky-bspline-gain"));
02747 check( par_method = xsh_string_toupper(xsh_parameters_get_string(list,
02748 recipe_id,
02749 "sky-method")
02750 ));
02751
02752
02753 if ( strcmp( SKY_METHOD_PRINT(BSPLINE_METHOD), par_method) == 0){
02754 result->method = BSPLINE_METHOD;
02755 }
02756 else if (strcmp( SKY_METHOD_PRINT(MEDIAN_METHOD), par_method) == 0){
02757 result->method = MEDIAN_METHOD;
02758 }
02759 else {
02760 xsh_error_msg("WRONG parameter sky_method %s",par_method);
02761 }
02762
02763 check( bspline_sampling = xsh_parameters_get_string( list, recipe_id,
02764 "bspline-sampling"));
02765 if ( strcmp( BSPLINE_SAMPLING_PRINT(UNIFORM), bspline_sampling) == 0){
02766 result->bspline_sampling = BSPLINE_METHOD;
02767 }
02768 else if (strcmp( BSPLINE_SAMPLING_PRINT(FINE), bspline_sampling) == 0){
02769 result->bspline_sampling = FINE;
02770 }
02771 else {
02772 xsh_error_msg("WRONG parameter bspline-sampling %s",bspline_sampling);
02773 }
02774
02775
02776
02777 check( result->median_hsize = xsh_parameters_get_int( list, recipe_id,
02778 "sky-median-hsize"));
02779 check( result->slit_edges_mask = xsh_parameters_get_double( list,
02780 recipe_id,
02781 "sky-slit-edges-mask"));
02782
02783 check( result->pos1 = xsh_parameters_get_double( list,
02784 recipe_id,
02785 "sky-position1"));
02786 check( result->hheight1 = xsh_parameters_get_double( list,
02787 recipe_id,
02788 "sky-hheight1"));
02789 check( result->pos2 = xsh_parameters_get_double( list,
02790 recipe_id,
02791 "sky-position2"));
02792 check( result->hheight2 = xsh_parameters_get_double( list,
02793 recipe_id,
02794 "sky-hheight2"));
02795
02796 cleanup:
02797 if(cpl_error_get_code() != CPL_ERROR_NONE){
02798 cpl_free(result);
02799 result = NULL;
02800 }
02801 return result;
02802 }
02803
02804 int xsh_parameters_subtract_sky_single_get_true( const char* recipe_id,
02805 cpl_parameterlist* list)
02806 {
02807 bool result = FALSE;
02808
02809 check( result = xsh_parameters_get_boolean( list, recipe_id,
02810 "sky-subtract"));
02811
02812 cleanup:
02813 return result ;
02814 }
02815
02816
02817 void xsh_parameters_dosky_domap_get( const char *recipe_id,
02818 cpl_parameterlist *list,
02819 cpl_frame* wavemap_frame,
02820 cpl_frame* slitmap_frame,
02821 int *dosky, int *domap)
02822 {
02823 bool sub_sky=FALSE;
02824 bool computemap=FALSE;
02825
02826 XSH_ASSURE_NOT_NULL( dosky);
02827 XSH_ASSURE_NOT_NULL( domap);
02828
02829 check( sub_sky = xsh_parameters_subtract_sky_single_get_true( recipe_id,
02830 list));
02831 check( computemap = xsh_parameters_get_boolean( list, recipe_id,
02832 "compute-map"));
02833
02834
02835
02836
02837
02838 if ( (sub_sky && !computemap) &&
02839 (wavemap_frame == NULL || slitmap_frame == NULL)
02840 ){
02841 xsh_msg_warning( "Parameters sky-subtract and compute-map are not compatible, compute-map has been forced to TRUE");
02842 computemap = TRUE;
02843 }
02844
02845 *dosky = sub_sky;
02846 *domap = computemap;
02847
02848 cleanup:
02849 return;
02850 }
02851
02852
02853 int xsh_parameters_subtract_sky_single_get_first( const char* recipe_id,
02854 cpl_parameterlist* list)
02855 {
02856 int result = 0 ;
02857
02858
02859 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
02860
02861
02862 check(result = xsh_parameters_get_int( list, recipe_id,
02863 "sky-bspline-nbkpts-first"));
02864
02865 cleanup:
02866 return result;
02867
02868 }
02869
02870 int xsh_parameters_subtract_sky_single_get_second( const char* recipe_id,
02871 cpl_parameterlist* list)
02872 {
02873 int result = 0 ;
02874
02875
02876 XSH_ASSURE_NOT_NULL( list);
02877
02878
02879 check(result = xsh_parameters_get_int( list, recipe_id,
02880 "sky-bspline-nbkpts-second"));
02881
02882 cleanup:
02883 return result;
02884 }
02885
02886
02887 int xsh_parameters_subtract_sky_single_get_niter( const char* recipe_id,
02888 cpl_parameterlist* list)
02889 {
02890 int result = 0 ;
02891
02892
02893 XSH_ASSURE_NOT_NULL( list);
02894
02895
02896 check(result = xsh_parameters_get_int( list, recipe_id,
02897 "sky-bspline-niter"));
02898
02899 cleanup:
02900 return result;
02901 }
02902
02903
02904
02905 double xsh_parameters_subtract_sky_single_get_kappa( const char* recipe_id,
02906 cpl_parameterlist* list)
02907 {
02908 double result = 0 ;
02909
02910
02911 XSH_ASSURE_NOT_NULL( list);
02912
02913
02914 check(result = xsh_parameters_get_double( list, recipe_id,
02915 "sky-bspline-kappa"));
02916
02917 cleanup:
02918 return result;
02919 }
02920
02921
02922 double xsh_parameters_subtract_sky_single_get_ron( const char* recipe_id,
02923 cpl_parameterlist* list)
02924 {
02925 double result = 0 ;
02926
02927
02928 XSH_ASSURE_NOT_NULL( list);
02929
02930
02931 check(result = xsh_parameters_get_double( list, recipe_id,
02932 "sky-bspline-ron"));
02933
02934 cleanup:
02935 return result;
02936 }
02937
02938 double xsh_parameters_subtract_sky_single_get_gain( const char* recipe_id,
02939 cpl_parameterlist* list)
02940 {
02941 double result = 0 ;
02942
02943
02944 XSH_ASSURE_NOT_NULL( list);
02945
02946
02947 check(result = xsh_parameters_get_double( list, recipe_id,
02948 "sky-bspline-gain"));
02949
02950 cleanup:
02951 return result;
02952 }
02953
02954
02955
02956
02957
02958
02959 void xsh_parameters_merge_ord_create( const char * recipe_id,
02960 cpl_parameterlist * plist,
02961 int p )
02962 {
02963
02964 XSH_ASSURE_NOT_NULL( recipe_id);
02965 XSH_ASSURE_NOT_NULL( plist);
02966
02967 check(xsh_parameters_new_int( plist, recipe_id, "mergeord-method",
02968 p, "Method for combining overlapping orders "\
02969 "(0 = WEIGHTED with the errors, 1 = MEAN)"));
02970
02971 cleanup:
02972 return;
02973 }
02974
02975 xsh_merge_param* xsh_parameters_merge_ord_get( const char* recipe_id,
02976 cpl_parameterlist* list)
02977 {
02978 xsh_merge_param *result = NULL;
02979
02980
02981 XSH_ASSURE_NOT_NULL( recipe_id);
02982 XSH_ASSURE_NOT_NULL( list);
02983
02984
02985 XSH_MALLOC( result, xsh_merge_param, 1);
02986
02987
02988 check( result->method = xsh_parameters_get_int( list, recipe_id,
02989 "mergeord-method"));
02990
02991 cleanup:
02992 if(cpl_error_get_code() != CPL_ERROR_NONE){
02993 XSH_FREE( result);
02994 }
02995 return result;
02996 }
02997
02998
02999
03000
03001
03002 void xsh_parameters_optimal_extract_create( const char * recipe_id,
03003 cpl_parameterlist * plist,
03004 int p )
03005 {
03006 XSH_ASSURE_NOT_NULL( recipe_id ) ;
03007 XSH_ASSURE_NOT_NULL( plist ) ;
03008
03009 check(xsh_parameters_new_double(plist,recipe_id,
03010 "optimal_extract_kappa",
03011 p,
03012 "Pixels with values > kappa*RMS are ignored. If negative no rejection."));
03013
03014 cleanup:
03015 return ;
03016 }
03017
03018 double xsh_parameters_optimal_extract_get_kappa( const char* recipe_id,
03019 cpl_parameterlist* list)
03020 {
03021 double result = 0 ;
03022
03023
03024 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
03025
03026
03027 check(result = xsh_parameters_get_double(list,recipe_id,
03028 "optimal_extract_kappa"));
03029
03030 cleanup:
03031 return result;
03032
03033 }
03034
03035
03046
03047 void xsh_parameters_dispersol_create(const char* recipe_id,
03048 cpl_parameterlist* list, xsh_dispersol_param p)
03049 {
03050
03051 XSH_ASSURE_NOT_NULL(list);
03052
03053
03054
03055 check(xsh_parameters_new_int(list,recipe_id,"dispersol-deg-x",
03056 p.deg_x, "Degree in X in the polynomial dispersion solution "\
03057 "lambda=f(X,Y) and slit=f(X,Y)"));
03058
03059 check(xsh_parameters_new_int(list,recipe_id,"dispersol-deg-y",
03060 p.deg_y, "Degree in Y in the polynomial dispersion solution "\
03061 "lambda=f(X,Y) and slit=f(X,Y)"));
03062
03063 cleanup:
03064 return;
03065 }
03066
03067
03068
03079
03080 xsh_dispersol_param* xsh_parameters_dispersol_get( const char* recipe_id,
03081 cpl_parameterlist* list)
03082 {
03083 xsh_dispersol_param* result = NULL;
03084
03085
03086 XSH_ASSURE_NOT_NULL(list);
03087
03088
03089 XSH_MALLOC(result, xsh_dispersol_param, 1);
03090
03091
03092 check(result->deg_x = xsh_parameters_get_int(list, recipe_id,
03093 "dispersol-deg-x"));
03094 check(result->deg_y = xsh_parameters_get_int(list, recipe_id,
03095 "dispersol-deg-y"));
03096
03097 cleanup:
03098 if(cpl_error_get_code() != CPL_ERROR_NONE){
03099 XSH_FREE(result);
03100 }
03101 return result;
03102 }
03103
03104
03112
03113 void xsh_parameters_combine_nod_create(const char * recipe_id,
03114 cpl_parameterlist * list,
03115 xsh_combine_nod_param p)
03116 {
03117
03118 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
03119
03120
03121 check(xsh_parameters_new_int(list,recipe_id,"combinenod-min", p.nod_min,
03122 "minimum NS size of resulting frame in pixels"));
03123 check(xsh_parameters_new_boolean(list,recipe_id,"combinenod-clip",
03124 p.nod_clip,
03125 "TRUE if do sigma clipping")) ;
03126
03127 check(xsh_parameters_new_double(list,recipe_id,"combinenod-clip-sigma",
03128 p.nod_clip_sigma,
03129 "Kappa value in sigma clipping for combining nodded frames"));
03130
03131 check(xsh_parameters_new_int(list,recipe_id,"combinenod-clip-niter",
03132 p.nod_clip_niter,
03133 "Number of iterations in sigma clipping for combining nodded frames"));
03134
03135 check(xsh_parameters_new_double(list,recipe_id,"combinenod-clip-diff",
03136 p.nod_clip_diff,
03137 "Minimal change in sigma in sigma clipping for combining nodded frames"));
03138
03139 check( xsh_parameters_new_string( list, recipe_id,
03140 "combinenod-throwlist", p.throwname,
03141 "Name of ascii file containing the list of throw shifts with respect to the first exposure"));
03142
03143 check( xsh_parameters_new_string( list, recipe_id,
03144 "combinenod-method", COMBINE_METHOD_PRINT( p.method),
03145 "Combination method for nodded frames (MEDIAN, MEAN)"));
03146
03147 cleanup:
03148 return;
03149 }
03150
03151
03159
03160 xsh_combine_nod_param * xsh_parameters_combine_nod_get(const char* recipe_id,
03161 cpl_parameterlist* list)
03162 {
03163 xsh_combine_nod_param* result = NULL;
03164 const char *par_method = NULL;
03165
03166
03167 assure(list != NULL,CPL_ERROR_NULL_INPUT,"parameters list is NULL");
03168
03169
03170 check(result = (xsh_combine_nod_param *)(cpl_malloc(sizeof(xsh_combine_nod_param)))
03171 );
03172 assure (result != NULL, CPL_ERROR_ILLEGAL_OUTPUT,
03173 "Memory allocation failed!");
03174
03175
03176
03177 check(result->nod_min = xsh_parameters_get_int(list,recipe_id,
03178 "combinenod-min"));
03179 check(result->nod_clip = xsh_parameters_get_boolean(list,recipe_id,
03180 "combinenod-clip"));
03181 check(result->nod_clip_sigma = xsh_parameters_get_double(list,recipe_id,
03182 "combinenod-clip-sigma"));
03183 check(result->nod_clip_niter = xsh_parameters_get_int(list,recipe_id,
03184 "combinenod-clip-niter"));
03185 check(result->nod_clip_diff = xsh_parameters_get_double(list,recipe_id,
03186 "combinenod-clip-diff"));
03187 check(result->throwname = xsh_parameters_get_string(list,recipe_id,
03188 "combinenod-throwlist"));
03189 check( par_method = xsh_parameters_get_string( list, recipe_id,
03190 "combinenod-method"));
03191 if ( strcmp( COMBINE_METHOD_PRINT( COMBINE_MEAN_METHOD), par_method) == 0){
03192 result->method = COMBINE_MEAN_METHOD;
03193 }
03194 else if (strcmp( COMBINE_METHOD_PRINT( COMBINE_MEDIAN_METHOD), par_method) == 0){
03195 result->method = COMBINE_MEDIAN_METHOD;
03196 }
03197 else {
03198 xsh_error_msg("WRONG parameter combinenod-method %s",par_method);
03199 }
03200
03201
03202 cleanup:
03203 if(cpl_error_get_code() != CPL_ERROR_NONE){
03204 cpl_free(result);
03205 result = NULL;
03206 }
03207 return result;
03208 }
03209
03220
03221 void xsh_parameters_opt_extract_create( const char * recipe_id,
03222 cpl_parameterlist* list, xsh_opt_extract_param p)
03223 {
03224
03225 XSH_ASSURE_NOT_NULL( recipe_id);
03226 XSH_ASSURE_NOT_NULL( list);
03227
03228
03229 check( xsh_parameters_new_int( list, recipe_id,
03230 "optextract-oversample", p.oversample,
03231 "Oversample factor for the science image"));
03232 check( xsh_parameters_new_int( list, recipe_id,
03233 "optextract-box-half-size", p.box_hsize,
03234 "Extraction box [pixel]"));
03235 check( xsh_parameters_new_int( list, recipe_id,
03236 "optextract-chunk-size", p.chunk_size,
03237 "Chunk size [bin]"));
03238 check( xsh_parameters_new_double( list, recipe_id,
03239 "optextract-step-lambda", p.lambda_step,
03240 "Lambda step [nm]"));
03241 check( xsh_parameters_new_double( list, recipe_id,
03242 "optextract-clip-kappa", p.clip_kappa,
03243 "Kappa for cosmics ray hits rejection" ) ) ;
03244 check( xsh_parameters_new_double( list, recipe_id,
03245 "optextract-clip-frac", p.clip_frac,
03246 "Maximum bad pixels fraction for cosmics ray hits rejection"));
03247 check( xsh_parameters_new_int( list, recipe_id,
03248 "optextract-clip-niter", p.clip_niter,
03249 "Maximum number of iterations for cosmics ray hits rejection"));
03250 check( xsh_parameters_new_int( list, recipe_id,
03251 "optextract-niter", p.niter,
03252 "Number of iterations" ) ) ;
03253 check( xsh_parameters_new_string( list, recipe_id,
03254 "optextract-method", OPTEXTRACT_METHOD_PRINT(p.method),
03255 "Extraction method GAUSSIAN | GENERAL"));
03256
03257 cleanup:
03258 return;
03259 }
03260
03261
03272
03273 xsh_opt_extract_param* xsh_parameters_opt_extract_get( const char* recipe_id,
03274 cpl_parameterlist* list)
03275 {
03276 xsh_opt_extract_param* result = NULL;
03277 const char *par_method = NULL;
03278
03279
03280
03281 XSH_ASSURE_NOT_NULL( recipe_id);
03282 XSH_ASSURE_NOT_NULL( list);
03283
03284 XSH_MALLOC( result, xsh_opt_extract_param, 1);
03285
03286
03287 check( result->oversample = xsh_parameters_get_int( list,recipe_id,
03288 "optextract-oversample"));
03289 check( result->box_hsize = xsh_parameters_get_int( list,recipe_id,
03290 "optextract-box-half-size"));
03291 check( result->chunk_size = xsh_parameters_get_int( list,recipe_id,
03292 "optextract-chunk-size"));
03293 check( result->lambda_step = xsh_parameters_get_double( list,recipe_id,
03294 "optextract-step-lambda"));
03295 check( result->clip_kappa = xsh_parameters_get_double( list, recipe_id,
03296 "optextract-clip-kappa"));
03297 check( result->clip_frac = xsh_parameters_get_double( list, recipe_id,
03298 "optextract-clip-frac"));
03299 check( result->clip_niter = xsh_parameters_get_int( list, recipe_id,
03300 "optextract-clip-niter"));
03301 check( result->niter = xsh_parameters_get_int( list, recipe_id,
03302 "optextract-niter"));
03303 check( par_method = xsh_parameters_get_string( list, recipe_id,
03304 "optextract-method"));
03305 if ( strcmp( OPTEXTRACT_METHOD_PRINT(GAUSS_METHOD), par_method) == 0){
03306 result->method = GAUSS_METHOD;
03307 }
03308 else if (strcmp( OPTEXTRACT_METHOD_PRINT(GENERAL_METHOD), par_method) == 0){
03309 result->method = GENERAL_METHOD;
03310 }
03311 else {
03312 xsh_error_msg("WRONG parameter optextract-method %s",par_method);
03313 }
03314
03315 cleanup:
03316 if(cpl_error_get_code() != CPL_ERROR_NONE){
03317 XSH_FREE( result);
03318 }
03319 return result;
03320 }
03321
03322 void xsh_parameters_slit_limit_create( const char* recipe_id,
03323 cpl_parameterlist* list,
03324 xsh_slit_limit_param p )
03325 {
03326
03327 XSH_ASSURE_NOT_NULL( recipe_id);
03328 XSH_ASSURE_NOT_NULL( list);
03329
03330
03331 check( xsh_parameters_new_double( list, recipe_id,
03332 "max-slit", p.max_slit,
03333 "Lower Slit Limit (localize and extract"));
03334 check( xsh_parameters_new_double( list, recipe_id,
03335 "min-slit", p.min_slit,
03336 "Upper Slit Limit (localize and extract"));
03337
03338 cleanup:
03339 return ;
03340 }
03341
03342 xsh_slit_limit_param * xsh_parameters_slit_limit_get( const char * recipe_id,
03343 cpl_parameterlist* list )
03344 {
03345 xsh_slit_limit_param * result = NULL ;
03346
03347
03348 XSH_ASSURE_NOT_NULL( recipe_id);
03349 XSH_ASSURE_NOT_NULL( list);
03350
03351 XSH_MALLOC( result, xsh_slit_limit_param, 1);
03352
03353
03354 check( result->min_slit = xsh_parameters_get_double( list,recipe_id,
03355 "min-slit"));
03356 check( result->max_slit = xsh_parameters_get_double( list,recipe_id,
03357 "max-slit"));
03358 cleanup:
03359 if(cpl_error_get_code() != CPL_ERROR_NONE){
03360 XSH_FREE( result);
03361 }
03362 return result;
03363 }
03364
03365 void xsh_parameters_geom_ifu_mode_create( const char* recipe_id,
03366 cpl_parameterlist* list )
03367 {
03368
03369 XSH_ASSURE_NOT_NULL( recipe_id);
03370 XSH_ASSURE_NOT_NULL( list);
03371
03372 check(xsh_parameters_new_boolean(list,recipe_id,
03373 "geom-ifu-localize-single",
03374 TRUE,
03375 "Use a concatenation of rectified to localize."));
03376 cleanup:
03377 return ;
03378 }
03379
03380 int xsh_parameters_geom_ifu_mode_get( const char * recipe_id,
03381 cpl_parameterlist* list)
03382 {
03383 int ts = FALSE ;
03384
03385
03386 XSH_ASSURE_NOT_NULL( recipe_id);
03387 XSH_ASSURE_NOT_NULL( list);
03388 ts = xsh_parameters_get_boolean( list, recipe_id,
03389 "geom-ifu-localize-single" ) ;
03390
03391 cleanup:
03392 return ts ;
03393 }
03394
03395
03396 cpl_parameterlist*
03397 xsh_parameters_create_from_drs_table(const cpl_table* tab)
03398 {
03399
03400 cpl_parameterlist* result=NULL;
03401 int nrow=0;
03402 int i=0;
03403 const char* svalue=NULL;
03404 int ivalue=0;
03405 float fvalue=0;
03406 double dvalue=0;
03407 bool bvalue=0;
03408
03409 const char* rec_id=NULL;
03410 const char* pname=NULL;
03411 const char* ptype=NULL;
03412 const char* phelp=NULL;
03413
03414
03415 XSH_ASSURE_NOT_NULL_MSG(tab,"Null input DRS tab");
03416 nrow=cpl_table_get_nrow(tab);
03417 result=cpl_parameterlist_new();
03418 for(i=0;i<nrow;i++) {
03419 check(rec_id=cpl_table_get_string(tab,"recipe",i));
03420 check(pname=cpl_table_get_string(tab,"param_name",i));
03421 check(ptype=cpl_table_get_string(tab,"param_type",i));
03422 check(phelp=cpl_table_get_string(tab,"param_help",i));
03423
03424 if (strcmp(ptype,"int") == 0) {
03425 check(ivalue=atoi(cpl_table_get_string(tab,"param_value",i)));
03426 check(xsh_parameters_new_int(result,rec_id,pname,ivalue,phelp));
03427 }
03428 else if (strcmp(ptype,"float") == 0) {
03429 fvalue=atof(cpl_table_get_string(tab,"param_value",i));
03430 xsh_parameters_new_float(result,rec_id,pname,fvalue,phelp);
03431 }
03432 else if (strcmp(ptype,"double") == 0) {
03433 dvalue=atof(cpl_table_get_string(tab,"param_value",i));
03434 xsh_parameters_new_double(result,rec_id,pname,dvalue,phelp);
03435 }
03436 else if (strcmp(ptype,"string") == 0) {
03437 svalue=cpl_table_get_string(tab,"param_value",i);
03438 xsh_parameters_new_string(result,rec_id,pname,svalue,phelp);
03439 }
03440 else if (strcmp(ptype,"bool") == 0) {
03441 bvalue=atoi(cpl_table_get_string(tab,"param_value",i));
03442 xsh_parameters_new_bool(result,rec_id,pname,bvalue,phelp);
03443 }
03444 else {
03445 xsh_msg_error("DRS table parameter type %s not supported!",ptype);
03446 return NULL;
03447 }
03448 }
03449
03450 cleanup:
03451 return result;
03452 }
03453
03454
03455
03456 static cpl_error_code
03457 xsh_params_overscan_nir_check(cpl_parameterlist * parameters,const char* rec_id)
03458 {
03459
03460 cpl_parameter* p=NULL;
03461 const char* pname=NULL;
03462 pname="pre-overscan-corr";
03463 p=xsh_parameters_find(parameters,rec_id,pname);
03464 cpl_parameter_set_int(p,0);
03465
03466 return cpl_error_get_code();
03467
03468 }
03469
03470
03471
03472 static cpl_error_code
03473 xsh_parameter_check_int(cpl_parameterlist* parameters,const char* rec_id,const char* pname,const int min,const int max,const int skip_val, const char* spec)
03474 {
03475 int ival=0;
03476 int uval=0;
03477 cpl_parameter* p=NULL;
03478
03479
03480 check(uval=xsh_parameters_get_int(parameters,rec_id,pname));
03481 if(skip_val == -1) {
03482 if( (uval != skip_val && uval < min ) || uval > max ) {
03483 xsh_msg_warning("%s (%d) < %d or > %s (%d). Switch to defaults",
03484 pname,uval,min,spec,max);
03485 check(p=xsh_parameters_find(parameters,rec_id,pname));
03486 ival=cpl_parameter_get_default_int(p);
03487 cpl_parameter_set_int(p,ival);
03488 }
03489 } else {
03490 if( uval < min || uval > max ) {
03491 xsh_msg_warning("%s (%d) < %d or > %s (%d). Switch to defaults",
03492 pname,uval,min,spec,max);
03493 check(p=xsh_parameters_find(parameters,rec_id,pname));
03494 ival=cpl_parameter_get_default_int(p);
03495 cpl_parameter_set_int(p,ival);
03496 }
03497 }
03498
03499 cleanup:
03500 return cpl_error_get_code();
03501
03502 }
03503
03504 static cpl_error_code
03505 xsh_parameter_check_double(cpl_parameterlist* parameters,const char* rec_id,const char* pname,const double min,const double max,const double skip_val, const char* spec)
03506 {
03507 double dval=0;
03508 double uval=0;
03509 cpl_parameter* p=NULL;
03510
03511 check(uval=xsh_parameters_get_double(parameters,rec_id,pname));
03512 if(skip_val == -1) {
03513 if( (uval != skip_val && uval < min ) || uval > max ) {
03514 xsh_msg_warning("%s (%g) < %g or > %s (%g). Switch to defaults",
03515 pname,uval,min,spec,max);
03516 check(p=xsh_parameters_find(parameters,rec_id,pname));
03517 dval=cpl_parameter_get_default_double(p);
03518 cpl_parameter_set_double(p,dval);
03519 }
03520 } else {
03521 if( uval < min || uval > max ) {
03522 xsh_msg_warning("%s (%g) < %g or > %s (%g). Switch to defaults",
03523 pname,uval,min,spec,max);
03524 check(p=xsh_parameters_find(parameters,rec_id,pname));
03525 dval=cpl_parameter_get_default_double(p);
03526 cpl_parameter_set_double(p,dval);
03527 }
03528 }
03529
03530 cleanup:
03531 return cpl_error_get_code();
03532 }
03533
03534
03535 static cpl_error_code
03536 xsh_params_crhclip_check(cpl_parameterlist * parameters, const char* rec_id)
03537 {
03538
03539 const char* pname=NULL;
03540
03541 pname="crh-clip-frac";
03542 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
03543
03544 pname="crh-clip-kappa";
03545 xsh_parameter_check_double(parameters,rec_id,pname,0,20,-9,"");
03546
03547 pname="crh-clip-niter";
03548 xsh_parameter_check_int(parameters,rec_id,pname,0,100,-9,"");
03549
03550 return cpl_error_get_code();
03551
03552 }
03553
03554 static cpl_error_code
03555 xsh_params_noise_clip_check(cpl_parameterlist * parameters, const char* rec_id)
03556 {
03557
03558 const char* pname=NULL;
03559
03560 pname="noise-clip-kappa";
03561 xsh_parameter_check_double(parameters,rec_id,pname,0,20,-9,"");
03562
03563 pname="noise-clip-niter";
03564 xsh_parameter_check_int(parameters,rec_id,pname,1,100,-9,"");
03565
03566 pname="noise-clip-frac";
03567 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
03568
03569 pname="noise-clip-diff";
03570 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
03571
03572 pname="noise-lower-rejection";
03573 xsh_parameter_check_double(parameters,rec_id,pname,0,100,-9,"");
03574
03575 pname="noise-higher-rejection";
03576 xsh_parameter_check_double(parameters,rec_id,pname,0,100,-9,"");
03577
03578 return cpl_error_get_code();
03579
03580 }
03581
03582
03583
03584 static cpl_error_code
03585 xsh_params_crhsingle_check(cpl_parameterlist * parameters, const char* rec_id)
03586 {
03587
03588 const char* pname=NULL;
03589
03590 pname="removecrhsingle-frac-max";
03591 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
03592
03593 pname="removecrhsingle-sigmalim";
03594 xsh_parameter_check_double(parameters,rec_id,pname,0,20,-9,"");
03595
03596 pname="removecrhsingle-flim";
03597 xsh_parameter_check_double(parameters,rec_id,pname,0,20,-9,"");
03598
03599 pname="removecrhsingle-niter";
03600 xsh_parameter_check_int(parameters,rec_id,pname,0,1000,-9,"");
03601
03602 return cpl_error_get_code();
03603
03604
03605 }
03606
03607 static cpl_error_code
03608 xsh_params_combinenod_check(cpl_parameterlist * parameters,const char* rec_id)
03609 {
03610
03611 const char* pname=NULL;
03612
03613 pname="combinenod-min";
03614 xsh_parameter_check_int(parameters,rec_id,pname,0,100,-9,"");
03615
03616 pname="combinenod-clip-sigma";
03617 xsh_parameter_check_double(parameters,rec_id,pname,0,100,-9,"");
03618
03619 pname="combinenod-clip-niter";
03620 xsh_parameter_check_int(parameters,rec_id,pname,1,100,-9,"");
03621
03622 pname="combinenod-clip-diff";
03623 xsh_parameter_check_double(parameters,rec_id,pname,1,100,-9,"");
03624
03625 return cpl_error_get_code();
03626
03627 }
03628
03629 static cpl_error_code
03630 xsh_params_optextract_check(cpl_parameterlist * parameters,const char* rec_id,
03631 const int sizey)
03632 {
03633
03634 const char* pname=NULL;
03635
03636 pname="optextract-oversample";
03637 xsh_parameter_check_int(parameters,rec_id,pname,1,100,-9,"");
03638
03639 pname="optextract-box-half-size";
03640 xsh_parameter_check_int(parameters,rec_id,pname,1,100,-9,"");
03641
03642 pname="optextract-chunk-size";
03643 xsh_parameter_check_int(parameters,rec_id,pname,1,sizey,-9,"");
03644
03645 pname="optextract-step-lambda";
03646 xsh_parameter_check_double(parameters,rec_id,pname,0,210,-9,"nm");
03647
03648 pname="optextract-clip-kappa";
03649 xsh_parameter_check_double(parameters,rec_id,pname,0,100,-9,"");
03650
03651 pname="optextract-clip-frac";
03652 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
03653
03654 pname="optextract-clip-niter";
03655 xsh_parameter_check_int(parameters,rec_id,pname,1,200,-9,"");
03656
03657 pname="optextract-niter";
03658 xsh_parameter_check_int(parameters,rec_id,pname,1,200,-9,"");
03659
03660 return cpl_error_get_code();
03661
03662 }
03663
03664 static cpl_error_code
03665 xsh_params_follow_arclines_check(cpl_parameterlist * parameters,const char* rec_id)
03666 {
03667
03668 const char* pname=NULL;
03669
03670 pname="followarclines-search-window-half-size";
03671 xsh_parameter_check_int(parameters,rec_id,pname,1,60,-9,"");
03672
03673 pname="followarclines-order-edges-mask";
03674 xsh_parameter_check_int(parameters,rec_id,pname,0,10,-9,"");
03675
03676 pname="followarclines-min-sn";
03677 xsh_parameter_check_double(parameters,rec_id,pname,0,200,-9,"");
03678
03679 return cpl_error_get_code();
03680
03681 }
03682
03683
03684
03685 static cpl_error_code
03686 xsh_params_tilt_clip_check(cpl_parameterlist * parameters,const char* rec_id)
03687 {
03688
03689 const char* pname=NULL;
03690
03691 pname="tilt-clip-kappa";
03692 xsh_parameter_check_double(parameters,rec_id,pname,0,100,-9,"");
03693
03694 pname="tilt-clip-niter";
03695 xsh_parameter_check_int(parameters,rec_id,pname,0,100,-9,"");
03696
03697 pname="tilt-clip-frac";
03698 xsh_parameter_check_double(parameters,rec_id,pname,0,200,-9,"");
03699
03700 return cpl_error_get_code();
03701
03702 }
03703
03704
03705 static cpl_error_code
03706 xsh_params_spec_res_check(cpl_parameterlist * parameters,const char* rec_id)
03707 {
03708
03709 const char* pname=NULL;
03710
03711 pname="specres-clip-kappa";
03712 xsh_parameter_check_double(parameters,rec_id,pname,0,100,-9,"");
03713
03714 pname="specres-clip-niter";
03715 xsh_parameter_check_int(parameters,rec_id,pname,0,100,-9,"");
03716
03717 pname="specres-clip-frac";
03718 xsh_parameter_check_double(parameters,rec_id,pname,0,200,-9,"");
03719
03720 return cpl_error_get_code();
03721
03722 }
03723
03724
03725 static cpl_error_code
03726 xsh_params_background_check(cpl_parameterlist * parameters,const char* rec_id,
03727 const int sizex,const int sizey, const int norder)
03728 {
03729 int nb_y_max=0;
03730 int radius_y=0;
03731
03732 const char* pname=NULL;
03733
03734 pname="background-radius-x";
03735 xsh_parameter_check_int(parameters,rec_id,pname,1,sizex/(norder+1)/2,-1,"");
03736
03737 pname="background-radius-y";
03738 check(radius_y=xsh_parameters_get_int(parameters,rec_id,pname));
03739 xsh_parameter_check_int(parameters,rec_id,pname,1,sizey,-9,"");
03740
03741 if(radius_y != 0) {
03742 nb_y_max=sizey/radius_y;
03743 } else {
03744 nb_y_max=sizey;
03745 }
03746
03747 pname="background-nb-y";
03748 xsh_parameter_check_int(parameters,rec_id,pname,1,nb_y_max,-9,"");
03749
03750
03751 pname="background-min-grid-frac";
03752 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
03753
03754 pname="background-smooth-x";
03755 xsh_parameter_check_int(parameters,rec_id,pname,0,sizex,-1,"");
03756
03757 pname="background-smooth-y";
03758 xsh_parameter_check_int(parameters,rec_id,pname,0,sizey,-9,"");
03759
03760 cleanup:
03761 return cpl_error_get_code();
03762
03763 }
03764
03765 static cpl_error_code
03766 xsh_params_rectify_check(cpl_parameterlist * parameters, const char* rec_id)
03767 {
03768
03769 const char* pname=NULL;
03770
03771 pname="rectify-radius";
03772 xsh_parameter_check_double(parameters,rec_id,pname,1,100,-9,"");
03773
03774 pname="rectify-bin-slit";
03775 xsh_parameter_check_double(parameters,rec_id,pname,0,6,-1,"arcsec");
03776
03777 pname="rectify-bin-lambda";
03778 xsh_parameter_check_double(parameters,rec_id,pname,0,210,-1,"nm");
03779
03780 return cpl_error_get_code();
03781
03782 }
03783
03784 static cpl_error_code
03785 xsh_params_localize_check(cpl_parameterlist * parameters,const char* rec_id)
03786 {
03787
03788 const char* pname=NULL;
03789
03790 pname="localize-chunk-nb";
03791 xsh_parameter_check_int(parameters,rec_id,pname,1,1000,-9,"");
03792
03793 pname="localize-thresh";
03794 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
03795
03796 pname="localize-deg-lambda";
03797 xsh_parameter_check_int(parameters,rec_id,pname,0,10,-9,"");
03798
03799 pname="localize-slit-position";
03800 xsh_parameter_check_double(parameters,rec_id,pname,-7,7,-9,"");
03801
03802 pname="localize-slit-hheight";
03803 xsh_parameter_check_double(parameters,rec_id,pname,0,7,-9,"");
03804
03805
03806 pname="localize-kappa";
03807 xsh_parameter_check_double(parameters,rec_id,pname,0,20,-9,"");
03808
03809 pname="localize-niter";
03810 xsh_parameter_check_int(parameters,rec_id,pname,0,100,-9,"");
03811
03812 return cpl_error_get_code();
03813
03814
03815 }
03816
03817
03818 static cpl_error_code
03819 xsh_params_sky_bspline_check(cpl_parameterlist * parameters,const char* rec_id,
03820 const int biny)
03821 {
03822
03823 int nbkpts_max=20000/(0.75 *biny);
03824 int niter_max=100;
03825 const char* pname=NULL;
03826
03827 pname="sky-bspline-nbkpts-first";
03828 xsh_parameter_check_int(parameters,rec_id,pname,1,nbkpts_max,-1,"");
03829
03830 pname="sky-bspline-nbkpts-second";
03831 xsh_parameter_check_int(parameters,rec_id,pname,1,nbkpts_max,-1,"");
03832
03833 pname="sky-bspline-order";
03834 xsh_parameter_check_int(parameters,rec_id,pname,7,7,-9,"");
03835
03836 pname="sky-bspline-niter";
03837 xsh_parameter_check_int(parameters,rec_id,pname,1,niter_max,-9,"");
03838
03839 pname="sky-bspline-kappa";
03840 xsh_parameter_check_double(parameters,rec_id,pname,1,10,-9,"");
03841
03842 pname="sky-bspline-ron";
03843 xsh_parameter_check_double(parameters,rec_id,pname,1,10,-1,"");
03844
03845 pname="sky-bspline-gain";
03846 xsh_parameter_check_double(parameters,rec_id,pname,1,10,-1,"");
03847
03848 pname="sky-slit-edges-mask";
03849 xsh_parameter_check_double(parameters,rec_id,pname,0,7,-9,"");
03850
03851 pname="sky-hheight1";
03852 xsh_parameter_check_double(parameters,rec_id,pname,0,7,-9,"");
03853
03854 pname="sky-hheight2";
03855 xsh_parameter_check_double(parameters,rec_id,pname,0,7,-9,"");
03856
03857 return cpl_error_get_code();
03858
03859 }
03860
03861
03862
03863 static cpl_error_code
03864 xsh_params_model_anneal_check(cpl_parameterlist * parameters,const char* rec_id)
03865 {
03866
03867 const char* pname=NULL;
03868
03869 pname="model-anneal-factor";
03870 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
03871
03872 pname="model-scenario";
03873 xsh_parameter_check_int(parameters,rec_id,pname,0,8,-9,"");
03874
03875 pname="model-maxit";
03876 xsh_parameter_check_int(parameters,rec_id,pname,0,100000,-9,"");
03877
03878 return cpl_error_get_code();
03879
03880 }
03881
03882 static cpl_error_code
03883 xsh_params_overscan_check(cpl_parameterlist * parameters,const char* rec_id)
03884 {
03885
03886 const char* pname=NULL;
03887
03888 pname="pre-overscan-corr";
03889 xsh_parameter_check_int(parameters,rec_id,pname,0,6,-1,"");
03890
03891 return cpl_error_get_code();
03892
03893
03894
03895 }
03896
03897 static cpl_error_code
03898 xsh_params_detect_arclines_check(cpl_parameterlist * parameters,const char* rec_id)
03899 {
03900
03901 const char* pname=NULL;
03902 int deg_slit_min=0;
03903 int deg_slit_max=0;
03904
03905 pname="detectarclines-fit-window-half-size";
03906 xsh_parameter_check_int(parameters,rec_id,pname,0,60,-1,"");
03907
03908 pname="detectarclines-search-window-half-size";
03909 xsh_parameter_check_int(parameters,rec_id,pname,0,60,-9,"");
03910
03911 pname="detectarclines-running-median-half-size";
03912 xsh_parameter_check_int(parameters,rec_id,pname,1,60,-9,"");
03913
03914 pname="detectarclines-wavesol-deg-lambda";
03915 xsh_parameter_check_int(parameters,rec_id,pname,0,10,-9,"");
03916
03917 pname="detectarclines-wavesol-deg-order";
03918 xsh_parameter_check_int(parameters,rec_id,pname,0,10,-9,"");
03919
03920 if(strcmp(rec_id,"xsh_predict") == 0) {
03921 deg_slit_max=0;
03922 deg_slit_min=0;
03923 } else {
03924 deg_slit_max=0;
03925 deg_slit_min=10;
03926 }
03927
03928 if (strcmp("xsh_2dmap", rec_id) == 0) {
03929 pname = "detectarclines-wavesol-deg-slit";
03930 xsh_parameter_check_int(parameters,rec_id,pname,deg_slit_min,deg_slit_max,-9,"");
03931
03932 }
03933
03934
03935 pname="detectarclines-ordertab-deg-y";
03936 xsh_parameter_check_int(parameters,rec_id,pname,0,10,-9,"");
03937
03938 pname="detectarclines-min-sn";
03939 xsh_parameter_check_double(parameters,rec_id,pname,0,200,-1,"");
03940
03941 pname="detectarclines-clip-sigma";
03942 xsh_parameter_check_double(parameters,rec_id,pname,0,20,-9,"");
03943
03944 pname="detectarclines-clip-niter";
03945 xsh_parameter_check_int(parameters,rec_id,pname,0,200,-9,"");
03946
03947 pname="detectarclines-clip-frac";
03948 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
03949
03950 return cpl_error_get_code();
03951
03952 }
03953
03954 static cpl_error_code
03955 xsh_params_detect_continuum_check(cpl_parameterlist * parameters,const char* rec_id)
03956 {
03957
03958 const char* pname=NULL;
03959
03960 pname="detectcontinuum-search-window-half-size";
03961 xsh_parameter_check_int(parameters,rec_id,pname,1,100,-1,"");
03962
03963 pname="detectcontinuum-running-window-half-size";
03964 xsh_parameter_check_int(parameters,rec_id,pname,1,100,-1,"");
03965
03966 pname="detectcontinuum-fit-window-half-size";
03967 xsh_parameter_check_int(parameters,rec_id,pname,0,100,-9,"");
03968
03969 pname="detectcontinuum-center-threshold-factor";
03970 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
03971
03972 pname="detectcontinuum-ordertab-step-y";
03973 xsh_parameter_check_int(parameters,rec_id,pname,1,20,-9,"");
03974
03975 pname="detectcontinuum-ordertab-deg-y";
03976 xsh_parameter_check_int(parameters,rec_id,pname,0,10,-9,"");
03977
03978 pname="detectcontinuum-clip-sigma";
03979 xsh_parameter_check_double(parameters,rec_id,pname,0,20,-9,"");
03980
03981 pname="detectcontinuum-clip-frac";
03982 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
03983
03984 pname="detectcontinuum-clip-res-max";
03985 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
03986
03987 pname="detectcontinuum-clip-niter";
03988 xsh_parameter_check_int(parameters,rec_id,pname,0,100,-9,"");
03989
03990 return cpl_error_get_code();
03991
03992 }
03993
03994 static cpl_error_code
03995 xsh_params_detectorder_check(cpl_parameterlist * parameters,
03996 const char* rec_id,const int sizex,
03997 const int sizey,const int norders)
03998 {
03999
04000 const char* pname=NULL;
04001
04002 pname="detectorder-edges-flux-thresh";
04003 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
04004
04005 pname="detectorder-edges-search-window-half-size";
04006 xsh_parameter_check_int(parameters,rec_id,pname,sizex/norders/4,sizex/norders,-1,"");
04007
04008 pname="detectorder-min-order-size-x";
04009 xsh_parameter_check_int(parameters,rec_id,pname,1,sizex/norders,-1,"");
04010
04011 pname="detectorder-chunk-half-size";
04012 xsh_parameter_check_int(parameters,rec_id,pname,1,sizey,-9,"");
04013
04014 pname="detectorder-slitlet-low-factor";
04015 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
04016
04017 pname="detectorder-slitlet-up-factor";
04018 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
04019
04020 pname="detectorder-chunk-half-size";
04021 xsh_parameter_check_int(parameters,rec_id,pname,1,sizey,-9,"");
04022
04023 pname="detectorder-min-sn";
04024 xsh_parameter_check_double(parameters,rec_id,pname,0,100,-9,"");
04025
04026 pname="detectorder-d2-min-sn";
04027 xsh_parameter_check_double(parameters,rec_id,pname,0,100,-9,"");
04028
04029 return cpl_error_get_code();
04030
04031 }
04032
04033 static cpl_error_code
04034 xsh_params_dispersol_check(cpl_parameterlist * parameters,const char* rec_id)
04035 {
04036
04037 const char* pname=NULL;
04038
04039 pname="dispersol-deg-x";
04040 xsh_parameter_check_int(parameters,rec_id,pname,0,10,-9,"");
04041
04042 pname="dispersol-deg-y";
04043 xsh_parameter_check_int(parameters,rec_id,pname,0,10,-9,"");
04044
04045 return cpl_error_get_code();
04046
04047 }
04048
04049 static cpl_error_code
04050 xsh_params_compute_fpn_check(cpl_parameterlist * parameters,const char* rec_id, const int sizex, const int sizey)
04051 {
04052
04053 int hsize=0;
04054 int nsamples=0;
04055
04056 cpl_parameter* p=NULL;
04057 const char* pname=NULL;
04058 int ival=0;
04059
04060 pname="fpn_llx";
04061 xsh_parameter_check_int(parameters,rec_id,pname,1,sizex,-1,"detector X size");
04062
04063 pname="fpn_urx";
04064 xsh_parameter_check_int(parameters,rec_id,pname,1,sizex,-1,"detector X size");
04065
04066 pname="fpn_lly";
04067 xsh_parameter_check_int(parameters,rec_id,pname,1,sizey,-1,"detector Y size");
04068
04069 pname="fpn_ury";
04070 xsh_parameter_check_int(parameters,rec_id,pname,1,sizey,-1,"detector Y size");
04071
04072 pname="fpn_nsamples";
04073 check(nsamples=xsh_parameters_get_int(parameters,rec_id,pname));
04074
04075
04076 if( nsamples<1 || nsamples > sizex || nsamples > sizey ) {
04077 xsh_msg_warning("%s (%d) < 1 or > detector X size (%d) or > detector Y size. Switch to defaults",pname,nsamples,sizex);
04078 check(p=xsh_parameters_find(parameters,rec_id,pname));
04079 ival=cpl_parameter_get_default_int(p);
04080 cpl_parameter_set_int(p,ival);
04081 }
04082
04083 pname="fpn_hsize";
04084 check(hsize=xsh_parameters_get_int(parameters,rec_id,pname));
04085 if( hsize<1 || hsize > sizex || hsize > sizey ) {
04086 xsh_msg_warning("%s (%d) < 1 or > detector X size (%d) or > detector Y size (%d). Switch to defaults",pname,hsize,sizex,sizey);
04087 check(p=xsh_parameters_find(parameters,rec_id,pname));
04088 ival=cpl_parameter_get_default_int(p);
04089 cpl_parameter_set_int(p,ival);
04090 }
04091
04092 cleanup:
04093 return cpl_error_get_code();
04094
04095 }
04096
04097 static cpl_error_code
04098 xsh_params_stacking_check(cpl_parameterlist * parameters,
04099 const char* rec_id)
04100 {
04101
04102 const char* pname=NULL;
04103
04104 pname="stacking_ks_low";
04105 xsh_parameter_check_int(parameters,rec_id,pname,0,20,-9,"");
04106
04107 pname="stacking_ks_iter";
04108 xsh_parameter_check_int(parameters,rec_id,pname,0,200,-9,"");
04109
04110 return cpl_error_get_code();
04111 }
04112
04113
04114
04115 static cpl_error_code
04116 xsh_params_stack_check(cpl_parameterlist * parameters,
04117 const char* rec_id)
04118 {
04119
04120 const char* pname=NULL;
04121
04122 pname="klow";
04123 xsh_parameter_check_double(parameters,rec_id,pname,0,100,-9,"");
04124
04125 pname="khigh";
04126 xsh_parameter_check_double(parameters,rec_id,pname,0,100,-9,"");
04127
04128 pname="niter";
04129 xsh_parameter_check_int(parameters,rec_id,pname,0,100,-9,"");
04130
04131 return cpl_error_get_code();
04132 }
04133
04134
04135 static cpl_error_code
04136 xsh_params_compute_ron_region1_check(cpl_parameterlist * parameters,
04137 const char* rec_id,
04138 const int sizex,const int sizey)
04139
04140 {
04141
04142 const char* pname=NULL;
04143
04144 pname="ref1_llx";
04145 xsh_parameter_check_int(parameters,rec_id,pname,1,sizex,-1,"detector X size");
04146
04147 pname="ref1_urx";
04148 xsh_parameter_check_int(parameters,rec_id,pname,1,sizex,-1,"detector X size");
04149
04150 pname="ref1_lly";
04151 xsh_parameter_check_int(parameters,rec_id,pname,1,sizey,-1,"detector Y size");
04152
04153 pname="ref1_ury";
04154 xsh_parameter_check_int(parameters,rec_id,pname,1,sizey,-1,"detector Y size");
04155
04156 return cpl_error_get_code();
04157
04158 }
04159
04160 static cpl_error_code
04161 xsh_params_compute_ron_region2_check(cpl_parameterlist * parameters,
04162 const char* rec_id,
04163 const int sizex,const int sizey)
04164
04165 {
04166 const char* pname=NULL;
04167
04168 pname="ref2_llx";
04169 xsh_parameter_check_int(parameters,rec_id,pname,1,sizex,-1,"detector X size");
04170
04171 pname="ref2_urx";
04172 xsh_parameter_check_int(parameters,rec_id,pname,1,sizex,-1,"detector X size");
04173
04174 pname="ref2_lly";
04175 xsh_parameter_check_int(parameters,rec_id,pname,1,sizey,-1,"detector Y size");
04176
04177 pname="ref2_ury";
04178 xsh_parameter_check_int(parameters,rec_id,pname,1,sizey,-1,"detector Y size");
04179
04180 return cpl_error_get_code();
04181
04182
04183 }
04184
04185 static cpl_error_code
04186 xsh_params_compute_ron_mbias_set3_check(cpl_parameterlist * parameters,
04187 const char* rec_id,
04188 const int sizex,const int sizey)
04189
04190 {
04191
04192 const char* pname=NULL;
04193 cpl_parameter* p=NULL;
04194 int nsamples=0;
04195 int hsize=0;
04196 int ival=0;
04197
04198 pname="random_nsamples";
04199 check(nsamples=xsh_parameters_get_int(parameters,rec_id,pname));
04200
04201
04202 if( nsamples<1 || nsamples > sizex || nsamples > sizey ) {
04203 xsh_msg_warning("%s (%d) < 1 or > detector X size (%d) or > detector Y size. Switch to defaults",pname,nsamples,sizex);
04204 check(p=xsh_parameters_find(parameters,rec_id,pname));
04205 ival=cpl_parameter_get_default_int(p);
04206 cpl_parameter_set_int(p,ival);
04207 }
04208
04209 pname="random_sizex";
04210 check(hsize=xsh_parameters_get_int(parameters,rec_id,pname));
04211 if( hsize<1 || hsize > sizex || hsize > sizey ) {
04212 xsh_msg_warning("%s (%d) < 1 or > detector X size (%d) or > detector Y size (%d). Switch to defaults",pname,hsize,sizex,sizey);
04213 check(p=xsh_parameters_find(parameters,rec_id,pname));
04214 ival=cpl_parameter_get_default_int(p);
04215 cpl_parameter_set_int(p,ival);
04216 }
04217
04218 cleanup:
04219 return cpl_error_get_code();
04220
04221
04222 }
04223
04224 static cpl_error_code
04225 xsh_params_compute_ron_mdark_check(cpl_parameterlist * parameters,
04226 const char* rec_id,
04227 const int sizex,const int sizey)
04228
04229 {
04230 int hsize=0;
04231 int nsamples=0;
04232
04233 cpl_parameter* p=NULL;
04234 const char* pname=NULL;
04235 int ival=0;
04236
04237 pname="ron_llx";
04238 xsh_parameter_check_int(parameters,rec_id,pname,1,sizex,-1,"detector X size");
04239
04240 pname="ron_urx";
04241 xsh_parameter_check_int(parameters,rec_id,pname,1,sizex,-1,"detector X size");
04242
04243 pname="ron_lly";
04244 xsh_parameter_check_int(parameters,rec_id,pname,1,sizey,-1,"detector Y size");
04245
04246 pname="ron_ury";
04247 xsh_parameter_check_int(parameters,rec_id,pname,1,sizey,-1,"detector Y size");
04248
04249 pname="ron_nsamples";
04250 check(nsamples=xsh_parameters_get_int(parameters,rec_id,pname));
04251
04252 if( nsamples<1 || nsamples > sizex || nsamples > sizey ) {
04253 xsh_msg_warning("%s (%d) < 1 or > detector X size (%d) or > detector Y size. Switch to defaults",pname,nsamples,sizex);
04254 check(p=xsh_parameters_find(parameters,rec_id,pname));
04255 ival=cpl_parameter_get_default_int(p);
04256 cpl_parameter_set_int(p,ival);
04257 }
04258
04259 pname="ron_hsize";
04260 check(hsize=xsh_parameters_get_int(parameters,rec_id,pname));
04261 if( hsize<1 || hsize > sizex || hsize > sizey ) {
04262 xsh_msg_warning("%s (%d) < 1 or > detector X size (%d) or > detector Y size (%d). Switch to defaults",pname,hsize,sizex,sizey);
04263 check(p=xsh_parameters_find(parameters,rec_id,pname));
04264 ival=cpl_parameter_get_default_int(p);
04265 cpl_parameter_set_int(p,ival);
04266 }
04267
04268 cleanup:
04269 return cpl_error_get_code();
04270
04271
04272 }
04273
04274
04275 static cpl_error_code
04276 xsh_params_compute_ron_check(cpl_parameterlist * parameters,
04277 const char* rec_id,
04278 const int sizex,const int sizey)
04279 {
04280
04281 if(strcmp(rec_id,"xsh_mbias") ==0 ) {
04282 check(xsh_params_compute_ron_region1_check(parameters,rec_id,sizex,sizey));
04283 xsh_params_compute_ron_region2_check(parameters,rec_id,sizex,sizey);
04284 xsh_params_compute_ron_mbias_set3_check(parameters,rec_id,sizex,sizey);
04285 } else if(strcmp(rec_id,"xsh_mdark") ==0 ) {
04286 xsh_params_compute_ron_region1_check(parameters,rec_id,sizex,sizey);
04287 xsh_params_compute_ron_mdark_check(parameters,rec_id,sizex,sizey);
04288 }
04289
04290 cleanup:
04291 return cpl_error_get_code();
04292
04293 }
04294
04295
04296 static cpl_error_code
04297 xsh_params_localizeifu_check(cpl_parameterlist* parameters, const char* rec_id){
04298
04299 int use_skymask=0;
04300 cpl_parameter* p=NULL;
04301 const char* pname=NULL;
04302 int ival=0;
04303
04304 pname="localizeifu-bckg-deg";
04305 xsh_parameter_check_int(parameters,rec_id,pname,0,100,-9,"");
04306
04307 pname="localizeifu-smooth-hsize";
04308 xsh_parameter_check_int(parameters,rec_id,pname,0,10,-9,"");
04309
04310 pname="localizeifu-wavelet-nscales";
04311 xsh_parameter_check_int(parameters,rec_id,pname,0,10,-9,"");
04312
04313 pname="localizeifu-wavelet-hf-skip";
04314 xsh_parameter_check_int(parameters,rec_id,pname,0,10,-9,"");
04315
04316 pname="localizeifu-sigma-low";
04317 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
04318
04319 pname="localizeifu-sigma-up";
04320 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
04321
04322 pname="localizeifu-snr-low";
04323 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
04324
04325 pname="localizeifu-snr-up";
04326 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
04327
04328 pname="localizeifu-slitlow-edges-mask";
04329 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
04330
04331 pname="localizeifu-slitup-edges-mask";
04332 xsh_parameter_check_double(parameters,rec_id,pname,0,1,-9,"");
04333
04334 pname="localizeifu-use-skymask";
04335 check(use_skymask=xsh_parameters_get_boolean(parameters,rec_id,pname));
04336 if( (use_skymask < 0) || use_skymask > 10 ) {
04337 xsh_msg_warning("%s (%d) < 0 or > 10. Switch to defaults",
04338 pname,use_skymask);
04339 check(p=xsh_parameters_find(parameters,rec_id,pname));
04340 ival=cpl_parameter_get_default_bool(p);
04341 cpl_parameter_set_bool(p,ival);
04342 }
04343
04344
04345 pname="localizeifu-chunk-hsize";
04346 xsh_parameter_check_int(parameters,rec_id,pname,0,10,-9,"");
04347
04348 cleanup:
04349 return cpl_error_get_code();
04350
04351 }
04352
04353 static cpl_error_code
04354 xsh_params_correctifu_check(cpl_parameterlist* parameters, const char* rec_id){
04355
04356
04357 const char* pname=NULL;
04358
04359 pname="correctifu-niter";
04360 xsh_parameter_check_int(parameters,rec_id,pname,0,10,-9,"");
04361
04362 pname="correctifu-lambdaref";
04363 xsh_parameter_check_double(parameters,rec_id,pname,300,1500,-1,"");
04364
04365 pname="correctifu-lambdaref-hsize";
04366 xsh_parameter_check_double(parameters,rec_id,pname,0,10,-9,"");
04367
04368 return cpl_error_get_code();
04369
04370 }
04371
04372 cpl_error_code
04373 xsh_recipe_params_check(cpl_parameterlist * parameters,xsh_instrument* instrument,const char* rec_id)
04374 {
04375 XSH_ARM arm;
04376 int binx=1;
04377 int biny=1;
04378 int sizex=0;
04379 int sizey=0;
04380 int norders=0;
04381
04382 check(arm =xsh_instrument_get_arm(instrument));
04383
04384 if ( arm == XSH_ARM_UVB ) {
04385 binx=xsh_instrument_get_binx( instrument ) ;
04386 biny=xsh_instrument_get_biny( instrument ) ;
04387
04388 sizex=UVB_ASIZE;
04389 sizex/=binx;
04390 sizey=UVB_BSIZE;
04391 sizey/=biny;
04392 norders=UVB_morder;
04393
04394 } else if ( arm == XSH_ARM_VIS ) {
04395 binx=xsh_instrument_get_binx( instrument ) ;
04396 biny=xsh_instrument_get_biny( instrument ) ;
04397
04398 sizex=VIS_ASIZE;
04399 sizex/=binx;
04400 sizey=VIS_BSIZE;
04401 sizey/=biny;
04402 norders=VIS_morder;
04403
04404 } else if ( arm == XSH_ARM_NIR ) {
04405
04406 sizex=NIR_ASIZE;
04407 sizey=NIR_BSIZE;
04408 norders=NIR_morder;
04409
04410 } else {
04411 xsh_msg_error("arm not supported");
04412 return CPL_ERROR_ILLEGAL_INPUT;
04413 }
04414
04415 if (strcmp(rec_id, "xsh_cfg_recover") == 0) {
04416
04417 } else if (strcmp(rec_id, "xsh_mbias") == 0) {
04418 xsh_params_compute_fpn_check(parameters,rec_id,sizex,sizey);
04419 xsh_params_compute_ron_check(parameters,rec_id,sizex,sizey);
04420 xsh_params_stack_check(parameters, rec_id);
04421 } else if (strcmp(rec_id, "xsh_mdark") == 0) {
04422 xsh_params_overscan_check(parameters, rec_id);
04423 xsh_params_stack_check(parameters, rec_id);
04424 xsh_params_crhclip_check(parameters, rec_id);
04425 xsh_params_noise_clip_check(parameters,rec_id);
04426 xsh_params_compute_ron_check(parameters,rec_id,sizex,sizey);
04427 check(xsh_params_compute_fpn_check(parameters,rec_id,sizex,sizey));
04428
04429 } else if (strcmp(rec_id, "xsh_mflat") == 0) {
04430 xsh_params_crhclip_check(parameters, rec_id);
04431 xsh_params_detectorder_check(parameters, rec_id, sizex, sizey, norders);
04432 xsh_params_background_check(parameters, rec_id, sizex, sizey, norders);
04433 } else if (strcmp(rec_id, "xsh_predict") == 0) {
04434 xsh_params_detect_arclines_check(parameters, rec_id);
04435 xsh_params_model_anneal_check(parameters, rec_id);
04436 } else if (strcmp(rec_id, "xsh_orderpos") == 0) {
04437 xsh_params_detect_continuum_check(parameters, rec_id);
04438 } else if (strcmp(rec_id, "xsh_2dmap") == 0) {
04439 xsh_params_detect_arclines_check(parameters, rec_id);
04440 xsh_params_dispersol_check(parameters, rec_id);
04441 xsh_params_model_anneal_check(parameters, rec_id);
04442 } else if (strcmp(rec_id, "xsh_flexcomp") == 0) {
04443 xsh_params_detect_arclines_check(parameters, rec_id);
04444 xsh_params_dispersol_check(parameters, rec_id);
04445 } else if (strcmp(rec_id, "xsh_wavecal") == 0) {
04446 xsh_params_follow_arclines_check(parameters, rec_id);
04447 xsh_params_tilt_clip_check(parameters, rec_id);
04448 xsh_params_spec_res_check(parameters, rec_id);
04449 } else if (strcmp(rec_id, "xsh_respon_slit_stare") == 0) {
04450 xsh_params_overscan_check(parameters, rec_id);
04451 check(xsh_params_sky_bspline_check(parameters, rec_id, biny));
04452 xsh_params_rectify_check(parameters, rec_id);
04453 xsh_params_localize_check(parameters, rec_id);
04454 xsh_params_background_check(parameters, rec_id, sizex, sizey, norders);
04455 xsh_params_crhclip_check(parameters, rec_id);
04456 xsh_params_crhsingle_check(parameters, rec_id);
04457 xsh_params_optextract_check(parameters, rec_id, sizey);
04458 } else if (strcmp(rec_id, "xsh_respon_slit_offset") == 0) {
04459 xsh_params_overscan_check(parameters, rec_id);
04460 xsh_params_rectify_check(parameters, rec_id);
04461 xsh_params_localize_check(parameters, rec_id);
04462 xsh_params_background_check(parameters, rec_id, sizex, sizey, norders);
04463 xsh_params_crhclip_check(parameters, rec_id);
04464 xsh_params_crhsingle_check(parameters, rec_id);
04465 xsh_params_combinenod_check(parameters, rec_id);
04466 } else if (strcmp(rec_id, "xsh_respon_slit_nod") == 0) {
04467 xsh_params_rectify_check(parameters, rec_id);
04468 xsh_params_localize_check(parameters, rec_id);
04469 xsh_params_background_check(parameters, rec_id, sizex, sizey, norders);
04470
04471 } else if (strcmp(rec_id, "xsh_scired_slit_stare") == 0) {
04472 xsh_params_overscan_check(parameters, rec_id);
04473 xsh_params_sky_bspline_check(parameters, rec_id, biny);
04474 xsh_params_rectify_check(parameters, rec_id);
04475 xsh_params_localize_check(parameters, rec_id);
04476 xsh_params_background_check(parameters, rec_id, sizex, sizey, norders);
04477 xsh_params_crhclip_check(parameters, rec_id);
04478 xsh_params_crhsingle_check(parameters, rec_id);
04479 xsh_params_optextract_check(parameters, rec_id, sizey);
04480 } else if (strcmp(rec_id, "xsh_scired_slit_offset") == 0) {
04481 xsh_params_overscan_check(parameters, rec_id);
04482 xsh_params_rectify_check(parameters, rec_id);
04483 xsh_params_localize_check(parameters, rec_id);
04484 xsh_params_background_check(parameters, rec_id, sizex, sizey, norders);
04485 xsh_params_crhclip_check(parameters, rec_id);
04486 xsh_params_crhsingle_check(parameters, rec_id);
04487 xsh_params_combinenod_check(parameters, rec_id);
04488 } else if (strcmp(rec_id, "xsh_scired_slit_nod") == 0) {
04489 xsh_params_rectify_check(parameters, rec_id);
04490 xsh_params_localize_check(parameters, rec_id);
04491 xsh_params_background_check(parameters, rec_id, sizex, sizey, norders);
04492 } else if (strcmp(rec_id, "xsh_scired_ifu_offset") == 0) {
04493 xsh_params_rectify_check(parameters, rec_id);
04494 xsh_params_localize_check(parameters, rec_id);
04495 xsh_params_background_check(parameters, rec_id, sizex, sizey, norders);
04496 xsh_params_crhclip_check(parameters, rec_id);
04497 xsh_params_crhsingle_check(parameters, rec_id);
04498 } else if (strcmp(rec_id, "xsh_scired_ifu_stare") == 0) {
04499 xsh_params_overscan_check(parameters,rec_id);
04500 xsh_params_crhclip_check(parameters, rec_id);
04501 xsh_params_rectify_check(parameters, rec_id);
04502 xsh_params_background_check(parameters, rec_id, sizex, sizey, norders);
04503 } else if (strcmp(rec_id, "xsh_absorp") == 0) {
04504 xsh_params_overscan_check(parameters, rec_id);
04505 xsh_params_stack_check(parameters, rec_id);
04506 xsh_params_crhclip_check(parameters, rec_id);
04507 xsh_params_background_check(parameters, rec_id, sizex, sizey, norders);
04508 xsh_params_crhsingle_check(parameters, rec_id);
04509 xsh_params_rectify_check(parameters, rec_id);
04510 xsh_params_localize_check(parameters, rec_id);
04511
04512 xsh_params_sky_bspline_check(parameters, rec_id, biny);
04513 xsh_params_optextract_check(parameters, rec_id, sizey);
04514 } else if (strcmp(rec_id, "xsh_geom_ifu") == 0) {
04515 xsh_params_crhclip_check(parameters, rec_id);
04516 xsh_params_background_check(parameters, rec_id, sizex, sizey, norders);
04517 xsh_params_crhsingle_check(parameters, rec_id);
04518 xsh_params_rectify_check(parameters, rec_id);
04519 xsh_params_localizeifu_check(parameters, rec_id);
04520 check(xsh_params_correctifu_check(parameters, rec_id));
04521 } else if (strcmp(rec_id, "xsh_scired_ifu_stare_drl") == 0) {
04522 xsh_params_crhclip_check(parameters, rec_id);
04523 xsh_params_background_check(parameters, rec_id, sizex, sizey, norders);
04524 xsh_params_crhsingle_check(parameters, rec_id);
04525 xsh_params_rectify_check(parameters, rec_id);
04526 xsh_params_localize_check(parameters, rec_id);
04527 } else if (strcmp(rec_id, "xsh_scired_ifu_offset_drl") == 0) {
04528 xsh_params_crhclip_check(parameters, rec_id);
04529 xsh_params_background_check(parameters, rec_id, sizex, sizey, norders);
04530 xsh_params_crhsingle_check(parameters, rec_id);
04531 xsh_params_rectify_check(parameters, rec_id);
04532 xsh_params_localize_check(parameters, rec_id);
04533 } else {
04534
04535 xsh_msg_error("Parameter checking for recipe %s not supported", rec_id);
04536
04537 }
04538
04539 if ( arm == XSH_ARM_NIR ) {
04540 xsh_params_overscan_nir_check(parameters, rec_id);
04541 }
04542
04543 cleanup:
04544 return cpl_error_get_code();
04545
04546 }
04547
04548
04549 cpl_error_code
04550 xsh_recipe_params_drs_check(cpl_parameterlist * parameters,xsh_instrument* instrument,const char* rec_id)
04551 {
04552 XSH_ARM arm;
04553 int binx=1;
04554 int biny=1;
04555 int sizex=0;
04556 int sizey=0;
04557 int norders=0;
04558
04559 check(arm =xsh_instrument_get_arm(instrument));
04560
04561 if ( arm == XSH_ARM_UVB ) {
04562 binx=xsh_instrument_get_binx( instrument ) ;
04563 biny=xsh_instrument_get_biny( instrument ) ;
04564
04565 sizex=UVB_ASIZE;
04566 sizex/=binx;
04567 sizey=UVB_BSIZE;
04568 sizey/=biny;
04569 norders=UVB_morder;
04570
04571 } else if ( arm == XSH_ARM_VIS ) {
04572 binx=xsh_instrument_get_binx( instrument ) ;
04573 biny=xsh_instrument_get_biny( instrument ) ;
04574
04575 sizex=VIS_ASIZE;
04576 sizex/=binx;
04577 sizey=VIS_BSIZE;
04578 sizey/=biny;
04579 norders=VIS_morder;
04580
04581 } else if ( arm == XSH_ARM_NIR ) {
04582
04583 sizex=NIR_ASIZE;
04584 sizey=NIR_BSIZE;
04585 norders=NIR_morder;
04586
04587 } else {
04588 xsh_msg_error("arm not supported");
04589 return CPL_ERROR_ILLEGAL_INPUT;
04590 }
04591
04592 if (strcmp(rec_id, "xsh_cfg_recover") == 0) {
04593
04594 } else if (strcmp(rec_id, "xsh_mbias") == 0) {
04595 xsh_params_stacking_check(parameters, rec_id);
04596 xsh_params_compute_ron_check(parameters, rec_id, sizex, sizey);
04597 } else if (strcmp(rec_id, "xsh_mdark") == 0) {
04598 check(xsh_params_crhclip_check(parameters, rec_id));
04599 check(xsh_params_noise_clip_check(parameters, rec_id));
04600 check(xsh_params_compute_ron_check(parameters, rec_id, sizex, sizey));
04601 xsh_params_compute_fpn_check(parameters, rec_id, sizex, sizey);
04602 } else if (strcmp(rec_id, "xsh_mflat") == 0) {
04603 } else if (strcmp(rec_id, "xsh_predict") == 0) {
04604 } else if (strcmp(rec_id, "xsh_orderpos") == 0) {
04605 } else if (strcmp(rec_id, "xsh_2dmap") == 0) {
04606 } else if (strcmp(rec_id, "xsh_geom_ifu") == 0) {
04607 } else if (strcmp(rec_id, "xsh_flexcomp") == 0) {
04608 } else if (strcmp(rec_id, "xsh_wavecal") == 0) {
04609 } else if (strcmp(rec_id, "xsh_respon_slit_stare") == 0) {
04610 } else if (strcmp(rec_id, "xsh_respon_slit_offset") == 0) {
04611 } else if (strcmp(rec_id, "xsh_respon_slit_nod") == 0) {
04612 } else if (strcmp(rec_id, "xsh_scired_slit_stare") == 0) {
04613 } else if (strcmp(rec_id, "xsh_scired_slit_offset") == 0) {
04614 } else if (strcmp(rec_id, "xsh_scired_slit_nod") == 0) {
04615 } else if (strcmp(rec_id, "xsh_scired_ifu_offset") == 0) {
04616 } else if (strcmp(rec_id, "xsh_scired_ifu_stare") == 0) {
04617 } else {
04618
04619 xsh_msg_error("Parameter checking for recipe %s not supported", rec_id);
04620
04621 }
04622
04623 cleanup:
04624 return cpl_error_get_code();
04625
04626 }
04627
04628