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