
! PLEASE NOTE:
! the following is just an example -- it is NOT a complete set of options.
! see star/astero_adipls/defaults/astero_search_controls.defaults
! for current set of controls and their default values.


&astero_search_controls ! based on HD49385

   ! the overall chi^2 is a combination of spectroscopic and seismic 
   
      ! chi2 = chi2_seismo*chi2_seismo_fraction
      !      + chi2_spectro*(1 - chi2_seismo_fraction)
      chi2_seismo_fraction = 0.667d0
   
   ! chi2_spectro is an evenly weighted combination of Teff, logg, logT, and FeH
      ! only need to give values for target and sigma if include in chi^2
      
      include_Teff_in_chi2_spectro = .true.
      Teff_target = 6095d0
      Teff_sigma = 65d0

      include_logg_in_chi2_spectro = .false.
      logg_target = 3.97d0
      logg_sigma = 0.02d0
   
      include_logL_in_chi2_spectro = .false.
      logL_target = 0.67d0
      logL_sigma = 0.05d0
      
      include_FeH_in_chi2_spectro = .true. ! [Fe/H]
      FeH_target = 0.09
      FeH_sigma = 0.05
      
         ! we calculate model [Fe/H] as = log10((Z/X)/Z_div_X_solar)
         ! using model surface average values for Z and X.
         Z_div_X_solar = 0.02293d0
      
      ! NOTE: for plotting with pgstar loggTe window -- logg vs. Teff
         ! you need to set the following pgstar controls
         ! loggTe_target_logg
         ! loggTe_target_logg_sigma
         ! loggTe_target_Teff
         ! loggTe_target_Teff_sigma
      ! same if you are plotting HR window -- lg_L vs. lg_Teff
         ! you need to set the following pgstar controls
         ! HR_target_logL
         ! HR_target_logL_sigma
         ! HR_target_Teff
         ! HR_target_Teff_sigma


   ! chi2_seismo is a weighted combination of
         ! frequencies, ratios of frequencies, delta_nu, and nu_max
         
      ! you specify the weighting of the terms in chi2_seismo by setting the following
   
      chi2_seismo_delta_nu_fraction = 0d0  
         ! if > 0 then delta_nu and delta_nu_sigma must be set (see below)
      chi2_seismo_nu_max_fraction = 0d0    
         ! if > 0 then nu_max and nu_max_sigma must be set (see below)
      chi2_seismo_r_010_fraction = 0d0
         ! if > 0, then include r_010 frequency ratios 
      chi2_seismo_r_02_fraction = 0d0
         ! if > 0, then include r_02 frequency ratios 
      ! fraction for frequencies = 1 - (frac_r_010_ratios + frac_r_02_ratios + frac_delta_nu + frac_nu_max)
      
      ! naturally the fractions must all be between 0 and 1, else get error message.
      
      
      trace_chi2_seismo_delta_nu_info = .false. ! if true, output info to terminal
      trace_chi2_seismo_nu_max_info = .false. ! if true, output info to terminal
      trace_chi2_seismo_ratios_info = .false. ! if true, output info to terminal
      trace_chi2_seismo_frequencies_info = .false. ! if true, output info to terminal

      trace_chi2_spectro_info = .false. ! if true, output info to terminal


   ! seismic data (frequencies in microHz)

      delta_nu = 56.28
      delta_nu_sigma = 1.0
         ! only need delta_nu_sigma if chi2_seismo_delta_nu_fraction > 0

      nu_max = 1010
      nu_max_sigma = -1
         ! only need nu_max_sigma if chi2_seismo_nu_max_fraction > 0


      ! observed l=0 modes to match to model
         nl0 = 9
         l0_obs(1) = 799.70d0
         l0_obs(2) = 855.30d0
         l0_obs(3) = 909.92d0
         l0_obs(4) = 965.16d0
         l0_obs(5) = 1021.81d0
         l0_obs(6) = 1078.97d0
         l0_obs(7) = 1135.32d0
         l0_obs(8) = 1192.12d0
         l0_obs(9) = 1250.12d0
         l0_obs_sigma(1) = 0.27d0
         l0_obs_sigma(2) = 0.73d0
         l0_obs_sigma(3) = 0.26d0
         l0_obs_sigma(4) = 0.36d0
         l0_obs_sigma(5) = 0.28d0
         l0_obs_sigma(6) = 0.33d0
         l0_obs_sigma(7) = 0.34d0
         l0_obs_sigma(8) = 0.45d0
         l0_obs_sigma(9) = 0.89d0
   
      ! observed l=1 modes to match to model
         nl1 = 10
         l1_obs(1) = 748.60d0
         l1_obs(2) = 777.91d0
         l1_obs(3) = 828.21d0
         l1_obs(4) = 881.29d0
         l1_obs(5) = 935.90d0
         l1_obs(6) = 991.09d0
         l1_obs(7) = 1047.79d0
         l1_obs(8) = 1104.68d0
         l1_obs(9) = 1161.27d0
         l1_obs(10) = 1216.95d0
         l1_obs_sigma(1) = 0.23d0
         l1_obs_sigma(2) = 0.24d0
         l1_obs_sigma(3) = 0.42d0
         l1_obs_sigma(4) = 0.29d0
         l1_obs_sigma(5) = 0.23d0
         l1_obs_sigma(6) = 0.22d0
         l1_obs_sigma(7) = 0.24d0
         l1_obs_sigma(8) = 0.22d0
         l1_obs_sigma(9) = 0.33d0
         l1_obs_sigma(10) = 0.53d0
   
      ! observed l=2 modes to match to model
         nl2 = 8
         l2_obs(1) = 794.55d0
         l2_obs(2) = 905.31d0
         l2_obs(3) = 961.47d0
         l2_obs(4) = 1017.56d0
         l2_obs(5) = 1075.01d0
         l2_obs(6) = 1130.79d0
         l2_obs(7) = 1187.55d0
         l2_obs(8) = 1246.78d0
         l2_obs_sigma(1) = 0.52d0
         l2_obs_sigma(2) = 0.35d0
         l2_obs_sigma(3) = 0.49d0
         l2_obs_sigma(4) = 0.27d0
         l2_obs_sigma(5) = 0.27d0
         l2_obs_sigma(6) = 0.61d0
         l2_obs_sigma(7) = 0.32d0
         l2_obs_sigma(8) = 0.84d0
   
      ! observed l=3 modes for matching to model
         nl3 = 0
         l3_obs(:) = 0 ! set l3_obs(1), l3_obs(2) .... l3_obs(nl0)   
         l3_obs_sigma(:) = 0
            ! set l3_obs_sigma(1), l3_obs_sigma(2) .... l3_obs_sigma(nl0)  
   
   
   ! search controls
      
      search_type = 'use_first_values'
         ! this option means no search
         ! just do a single run using "first" values for mass, alpha, Y, ...
         
         
      !search_type = 'scan_grid'
         ! eval chi^2 for each parameter combination
         ! that is within min to max with steps given by "delta"
         
         ! for a first rough scan, consider setting chi2_seismo_delta_nu_fraction = 1
         ! that skips the relatively costly calculations of frequencies
         ! and simply uses delta_nu along with spectro information.
         
         ! then you might follow up with medium resolution scans 
         ! in smaller regions around candidates from the rough scan
         ! with chi2_seismo_delta_nu_fraction = 0 to include frequencies

         ! output goes to the following file when search_type = 'scan_grid'
         scan_grid_output_filename = 'scan_grid_results.data'
         
         restart_scan_grid_from_file = .false.
            ! if true, then reads the scan_grid_output file 
            ! and continues from where that stopped.
         
      
      ! once you've generated some good candidates by doing scan_grid,
      ! it is time to use a minimization technique to fine tune the results.
      ! we have three for you to consider.
      
      ! the two methods from Powell use quadratic interpolation,
      ! either unconstrained (NEWUOA) or bounded (BOBYQA).
      ! the Nelder-Mead SIMPLEX method doesn't do interpolation;
      ! instead it simply compares values and moves toward lower chi^2's
      ! and away from higher ones.  in general, you can expect the
      ! Powell methods to be faster to converge than simplex if the chi^2
      ! terrain is not too "bumpy" (bumps confuse the interpolation).
      ! Since the simplex scheme doesn't do interpolation, bumps
      ! don't cause it trouble, so it may be more robust.  
      ! if you are just getting started, go with simplex at first.
      ! try the interpolation methods when you have a very good
      ! candidate and want to look near it for even better results. 
      
      
      !search_type = 'simplex'
         ! search for minimal chi^2 model using Nelder-Mead simplex algorithm 
            ! Nelder, J. A. and Mead, R.
            ! "A Simplex Method for Function Minimization."
            ! Comput. J. 7, 308-313, 1965.
         ! there are versions of this in Numerical Recipes under the name "amoeba",
         ! in Matlab under the name "fminsearch", and in Mathematica as an option for "NMminimize".
         ! our version has lots of bells and whistles and is, of course, superior to the others. ;)
         
         ! termination criteria
         
         ! terminate if reach max allowed iterations or function calls
         simplex_itermax = 1000 ! each iteration revises the simplex
         simplex_fcn_calls_max = 10000 ! may use several function calls per iteration
            ! each "function call" is a stellar evolution to give a chi^2
         
         ! terminate if simplex gets "small" enough
         simplex_x_atol = 1d-10 ! tolerance for absolute differences
         simplex_x_rtol = 1d-10 ! tolerance for relative differences
            ! if you want the details, here's the snippet of code.
            ! simplex(i,j) is value of i'th parameter for point j
            ! l is the index of the best point. there are n parameters and n+1 points.
!               term_val_x = 0
!               do j=1,n+1 ! check each point
!                  if (j == l) cycle ! l is the best point; so skip it
!                  do i=1,n ! check each coordinate of point j vs point l
!                     term1 = abs(simplex(i,j)-simplex(i,l)) / &
!                        (x_atol + x_rtol*max(abs(simplex(i,j)), abs(simplex(i,l))))
!                     if (term1 > term_val_x) term_val_x = term1
!                  end do
!               end do
!               if (term_val_x <= 1d0) exit ! converged
         
         ! options
         simplex_centroid_weight_power = 1d0
            ! each iteration starts by doing a reflection
            ! of the worst point through the centroid of the others.
            ! centroid points are weighted by (1/chi^2)**power
            ! power = 0 gives the standard unweighted centroid.
            ! power = 1 shifts the reflection toward the better points.
            ! in some (many? most?) cases, this shift improves convergence rate.
         simplex_enforce_bounds = .false.
            ! if true, then points outside the bounds will be rejected without evaluation.
            ! if false, then bounds will only be used in creating the initial simplex
            !                 and for adaptive random search.
         simplex_adaptive_random_search = .false.
            ! this flag controls what is done if the standard options of reflect or contract
            ! fail to produce a improvement in the simplex.
            ! if true, test uniform random samples within the bounds until find a better point.
            ! if false, "shrink" the simplex toward the best point.

         simplex_output_filename = 'simplex_results.data'
         
         restart_simplex_from_file = .false.
            ! if true, then reads the output file (simplex_output_filename)
            ! and continues from where that stopped
            ! using the best n+1 results as the initial simplex
            ! (where n is the number of parameters)
         
         simplex_seed = 1074698122 ! seed for random number generation
         
         
      !search_type = 'newuoa'
            
         ! search for minimal chi^2 model using Powell's NEWUOA algorithm
         ! unconstrained minimization without derivatives
         ! by quadratic polynomial approximation.
         ! results are written to newuoa_output_filename

         ! output goes to the following file when search_type = 'newuoa'
         newuoa_output_filename = 'newuoa_results.data'
   
         ! search controls for bobyqa
            ! see mesa/num/public/num_newuoa for details
            newuoa_rhoend = 1d-6 
               ! this is the tolerance that determines relative accuracy of final values
               ! i.e., stops search when results are changing by less than this
         
         
      !search_type = 'bobyqa'
         ! search for minimal chi^2 model using Powell's BOBYQA algorithm
         ! "BOBYQA" = Bounded Optimization BY Quadratic Approximation
         ! any location within the bounds is available for consideration.
         ! results are written to bobyqa_output_filename

         ! output goes to the following file when search_type = 'bobyqa'
         bobyqa_output_filename = 'bobyqa_results.data'
   
         ! search controls for bobyqa
            ! see mesa/num/public/num_bobyqa for details
            bobyqa_rhoend = 1d-6 
               ! this is the tolerance that determines relative accuracy of final values
               ! i.e., stops search when results are changing by less than this

      
      !search_type = 'from_file'
         ! this uses a file to provide a series of parameter combinations.
         
         ! the input file for the parameters is the following:
         filename_for_parameters = 'undefined'
         
         max_num_from_file = -1 ! if > 0, then stop after doing this many lines from file.
         
         ! for each line in the file after the 1st (which holds column names)
         ! for each parameter with vary_<Param> = .true.,
         !     set value of first_<Parama> to value from file.
         ! then run that set of parameters as if search_type = 'use_first_values'
         ! save the best chi^2 info for that set of parameters,
         ! then go to the next line in the file.
         ! stops when finishes the file or reaches "max_num_from_file"
         
         ! you need to say which columns in the file hold the various parameters.
         ! for example, if you file starts like the following:
         !       chi2         mass        alpha        init_Y      init_FeH    init_f_ov
         ! 654   0.81543178   1.35000000  1.76000000   0.27000000  0.21000000  0.01000000
         ! then set the column numbers like this
         file_column_for_mass = 3
         file_column_for_alpha = 4
         file_column_for_Y = 5
         file_column_for_FeH = 6
         file_column_for_f_ov = 7
         ! note that if you are not varying one of the parameters, f_ov e.g.,
         ! then you don't need to set the file_col for that parameter.

         ! output goes to the following when search_type = 'from_file'
         from_file_output_filename = 'from_file_results.data'
         
         
      ! set these flags to specify which parameters will vary during searches
         vary_FeH = .true. ! FeH = [Fe/H] = log10((Z/X)/Z_div_X_solar)
            ! Z and X are the initial uniform values
         vary_Y = .true. ! Y the initial uniform value
         vary_mass = .true. ! initial mass
         vary_alpha = .true.
         vary_f_ov = .false.

      ! >>>> NOTE: if "vary" is false, the "first" value is used for all runs.
         ! so you must set the first value even when you have vary = .false.
   
      ! use the following as the first values in searches
      
         first_FeH = -0.0118938
         first_Y = 0.23765625
         first_mass = 1.31093750
         first_alpha = 1.5875
         first_f_ov = 0.015
         
         min_FeH = -0.012012738
         min_Y = 0.2352796875
         min_mass = 1.297828125
         min_alpha = 1.571625
         
         max_FeH = -0.011774862
         max_Y = 0.2400328125
         max_mass = 1.324046875
         max_alpha = 1.603375
      
         
   
      ! search_type = 'scan_grid' uses this grid spacing
         ! note: grid spacing does not apply to other searches
         delta_FeH = 0.03
         delta_Y = 0.01
         delta_mass = 0.01
         delta_alpha = 0.1
         delta_f_ov = 0
         
      ! calculating mode frequencies is a relatively costly process,
      ! so we don't want to do it for models that are not good candidates.
      ! i.e., we want to filter out the bad candidates using the following
      ! less expensive tests whenever possible.

         ! NOTE: if none of the models in a run pass these tests,
         ! then you will not get any total chi2 result for that run.
         ! in some situations that might not matter,
         ! but if you are eliminating too many candidates in this way,
         ! the search routines might not be getting enough valid results to work properly.
         ! So watch what you are doing!  If your search or scan is getting lots of
         ! runs that fail to give chi^2 results, you'll need to adjust the limits.
      
         ! don't consider models that aren't old enough
            min_age_limit = 1d6
         
         ! don't consider models with L_nuc/L less than this limit
            Lnuc_div_L_limit = 0.95 ! this rules out pre-zams models

         ! don't consider models with chi2_spectroscopic above this limit 
            chi2_spectroscopic_limit = 20

         ! don't consider models with chi2_delta_nu above this limit 
            chi2_delta_nu_limit = 20

         ! we calculate radial modes only if pass the previous checks
      
         ! calculating nonradial modes is much more expensive than radial ones.
         ! so we skip the nonradial calculation if the radial results are poor.

         ! don't consider models with chi2_radial above this limit 
            chi2_radial_limit = 30
         
      
      ! adjust max timestep depending on how close to target
      
         ! NOTE: if you set the timestep limits too large you run the risk of missing good chi^2 cases.
         ! but if they are very small, you will spend a lot of runtime calculating lots of frequencies
         ! for lots of models.  There is no standard set of best values for this.
         ! The choice will depend on the stage of evolution and how fast things are changing
         ! in the general region of the models with good chi2 values.  
         ! There is no alternative to trying things and tuning the controls for your problem.
      
         ! these are just default values -- you will probably need to adjust them for your problem.
         max_yrs_dt_when_cold = 1d7 ! when fail Lnuc/L, chi2_spectro, or ch2_delta_nu
         max_yrs_dt_when_warm = 1d6 ! when pass previous but fail chi2_radial; < max_yrs_dt_when_cold
         max_yrs_dt_when_hot = 1d5 ! when pass chi2_radial; < max_yrs_dt_when_warm
         
         max_yrs_dt_chi2_small_limit = 5d4 ! < max_yrs_dt_when_hot
         chi2_limit_for_small_timesteps = 30
         
         max_yrs_dt_chi2_smaller_limit = 5d4 ! < max_yrs_dt_chi2_small_limit
         chi2_limit_for_smaller_timesteps = -1d99 ! < chi2_limit_for_small_timesteps
         
         max_yrs_dt_chi2_smallest_limit = 3d4 ! < max_yrs_dt_chi2_smaller_limit
         chi2_limit_for_smallest_timesteps = -1d99 ! < chi2_limit_for_smaller_timesteps
      
      
      ! only calculate chi^2 if pass all the checks
   

      ! we need a way to decide when to stop an evolution run.
      ! the following limits are used for this.
      ! NOTE: we don't want to stop too soon, so these limits
         ! are only tested for models that are okay for the Lnuc_div_L_limit.
      
         ! logg_limit = logg_target + logg_sigma*sigmas_coeff_for_logg_limit
         ! logL_limit = logL_target + logL_sigma*sigmas_coeff_for_logL_limit
         ! Teff_limit = Teff_target + Teff_sigma*sigmas_coeff_for_Teff_limit
         ! delta_nu_limit = delta_nu + delta_nu_sigma*sigmas_coeff_for_delta_nu_limit
         
         ! only use limits with sigma_coeff /= 0
         ! if the sigma_coeff is > 0, then stop when value is > limit
         ! if the sigma_coeff is < 0, then stop when value is < limit
         ! so use positive sigma_coeff for values that are increasing (such as logL)
         ! and negative ones for values that are decreasing (logg, Teff, delta_nu)
         
         sigmas_coeff_for_logg_limit = -5 ! disable by setting to 0
         sigmas_coeff_for_logL_limit = 5 ! disable by setting to 0
         sigmas_coeff_for_Teff_limit = -5 ! disable by setting to 0
         sigmas_coeff_for_delta_nu_limit = 0 ! -5 ! disable by setting to 0
      
      
      ! you can stop the run if chi^2 is rising.
         
         ! here is a relative limit
         chi2_relative_increase_limit = 2.0
         limit_num_chi2_too_big = 3
         ! if limit_num_chi2_too_big consequtive chi2s
         ! are > chi2_relative_increase_limit times the best chi2 for the run,
         ! then stop the run.
         
         ! and this is an absolute limit
         chi2_search_limit1 = 3.0
         chi2_search_limit2 = 4.0
         ! if best chi2 for the run is <= chi2_search_limit1,
         ! then stop the run if chi2 >= chi2_search_limit2.
         
         
      ! if you are doing a search or scanning a grid, you can use previous results
      !    as a guide for when to stop a run
      
         min_num_samples_for_avg = 2 ! want at least this many samples to form averages
         max_num_samples_for_avg = 10 ! use this many of the best chi^2 samples for averages
         
         ! these use results for the best chi^2 model of the previous best samples
         avg_age_sigma_limit = 5 ! stop if age > avg age + this limit times sigma of avg age
         avg_model_number_sigma_limit = 5 ! ditto for model number
   
   
   ! surface corrections (see K08 -- ApJ 683, pg 175)
      correction_factor = 1 
         ! use this fraction of the correction; set to 0 to skip doing corrections.
      l0_n_obs(:) = -1 ! the observed radial orders (ignored if < 0)
         ! the observed radial orders are used in calculating surface corrections
         ! if <= 0, use default calculation for radial orders
      correction_b = 4.25d0
            
      
   ! output controls
   
      write_best_model_data_for_each_sample = .true.
      num_digits = 4 ! number of digits in sample number (with leading 0's)
      sample_results_prefix = 'outputs/sample_' 
         ! note that you can include a directory in the prefix if desired
      sample_results_postfix = '.data'
      
      write_fgong_for_each_model = .false.
      model_num_digits = 4 ! number of digits in model number (with leading 0's)
      fgong_prefix = 'fgong_' 
         ! note that you can include a directory in the prefix if desired
      fgong_postfix = '.data'
      
      write_fgong_for_best_model = .false.
      best_model_fgong_filename = 'best.fgong'
      
      write_profile_for_best_model = .false.
      best_model_profile_filename = 'best.profile'
      
      save_model_for_best_model = .false.
      best_model_save_model_filename = 'best.mod'
      
      save_info_for_last_model = .false.
      last_model_save_info_filename = 'last_model.info'
      
   
   ! miscellaneous
   
      ! save all control settings to file
         save_controls = .true. ! dumps &astero_search_controls controls to file
         save_controls_filename = '' ! if empty, uses a default name
      
      
      ! composition control
         Y_frac_he3 = 1d-4 ! = xhe3/(xhe3 + xhe4); Y = xhe3 + xhe4

   
      ! save an eigenfunction
         save_mode_model_number = 0
         save_mode_filename = ''
         el_to_save = 0
         order_to_save = 0


      ! options for input model to pulsation codes
         add_atmosphere = .false. 
            ! if true, then star adds atmosphere before passing model to adipls
            ! the atmosphere model is determined by the mesa/star control which_atm_option
            ! it should either be one of the T(tau) integration options or Paczynski_grey,
               ! scheme inspired by B. Paczynski, 1969, Acta Astr., vol. 19, 1.
               ! which takes into account radiation dilution when tau < 2/3,
         keep_surface_point = .false.
            ! if true, keep k=1 point of model.
         add_center_point = .true. 
            ! if true, add point at r=0

      
      ! oscillation analysis

         oscillation_code = 'adipls' ! or 'gyre'   <<< lowercase
         
      ! gyre controls
      
         gyre_l0_input_file = 'gyre.l0.in'
         gyre_l1_input_file = 'gyre.l1.in'
         gyre_l2_input_file = 'gyre.l2.in'
         gyre_l3_input_file = 'gyre.l3.in'

      ! adipls controls
      
         add_atmosphere = .false.
         
         do_redistribute_mesh = .false.
         
            ! note: number of zones for redistribute is set in redistrb.c.pruned.in
            ! if you set this false, then the mesh from star is used directly.
            ! if you set this true, then astero calls adipls redistb before doing
            ! the frequency analysis.
            
            
         ! iscan for adipls = the following factor times the given number of observed modes
         iscan_factor_l0 = 15
         iscan_factor_l1 = 15
         iscan_factor_l2 = 15
         iscan_factor_l3 = 15
         ! frequency range is set from observed frequencies times these factors
         nu_lower_factor = 0.8
         nu_upper_factor = 1.2


   ! include other inlists
   
         read_extra_astero_search_inlist1 = .false.
         extra_astero_search_inlist1_name = 'undefined'
            ! if read_extra_astero_search_inlist1 is true, then read this namelist file
   
         read_extra_astero_search_inlist2 = .false.
         extra_astero_search_inlist2_name = 'undefined'
            ! if read_extra_astero_search_inlist2 is true, then read this namelist file
   
         read_extra_astero_search_inlist3 = .false.
         extra_astero_search_inlist3_name = 'undefined'
            ! if read_extra_astero_search_inlist3 is true, then read this namelist file
   
         read_extra_astero_search_inlist4 = .false.
         extra_astero_search_inlist4_name = 'undefined'
            ! if read_extra_astero_search_inlist4 is true, then read this namelist file
   
         read_extra_astero_search_inlist5 = .false.
         extra_astero_search_inlist5_name = 'undefined'
            ! if read_extra_astero_search_inlist5 is true, then read this namelist file


/ ! end astero_search_controls


! PLEASE NOTE:
! the following is just an example -- it is NOT a complete set of options.
! see star/astero_adipls/defaults/astero_pgstar_controls.defaults
! for current set of controls and their default values.

&astero_pgstar_controls

   ! PGSTAR Eschelle plot
   
         !echelle_win_flag = .true.

         echelle_win_width = 6
         echelle_win_aspect_ratio = 0.62 ! aspect_ratio = height/width
         
         show_echelle_annotation1 = .true.
         
         ! file output
         !echelle_file_flag = .true.
         echelle_file_dir = 'png'
         echelle_file_prefix = 'echelle'
         echelle_best_model_file_prefix = 'best_echelle' ! if non-empty save best chi^2 model file
            ! e.g. 'best_echelle'
            ! note: this is enabled even if echelle_file_flag = .false.
         echelle_file_cnt = 1 ! output when mod(model_number,echelle_file_cnt)==0
         echelle_file_width = -1 ! negative means use same value as for window
         echelle_file_aspect_ratio = -1 ! negative means use same value as for window


   ! PGSTAR ratios plot
   
         !ratios_win_flag = .true.

         ratios_win_width = 3.5
         ratios_win_aspect_ratio = 1.2 ! aspect_ratio = height/width

         show_ratios_annotation1 = .true.
         
         ! file output
         !ratios_file_flag = .true.
         ratios_file_dir = 'png'
         ratios_file_prefix = 'ratios'
         ratios_best_model_file_prefix = '' ! if non-empty save best chi^2 model file
            ! e.g., 'best_ratios'
            ! note: this is enabled even if ratios_file_flag = .false.
         ratios_file_cnt = 5 ! output when mod(model_number,ratios_file_cnt)==0
         ratios_file_width = -1 ! negative means use same value as for window
         ratios_file_aspect_ratio = -1 ! negative means use same value as for window


/ ! end astero_pgstar_controls

