gs2crmod 0.11.78 → 0.11.79

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cc195134cfa0c19392d90285541c55e0c5fc9a74
+  data.tar.gz: 9c53414eb39130503a7f0a44dd3a8a3577153317
+SHA512:
+  metadata.gz: 4fb9ac64fd98cf403982bdbbcb5209fbaf40abfbc6ef89d668fb19752a8643065e28ed35f7ec0167ba225840f043a46d899ac21907dae9b414ad749607d376a5
+  data.tar.gz: 87357dd8be279c0e1330fba046e65b3622e1e23128bc01ad9ec30984376a45fe42e15be695c07007e61f4245643b80d7d7f52dc84873b1a352f299133a4a1d2f

data/VERSION

@@ -1 +1 @@
-0.11.78
+0.11.79

data/ext/gs2crmod_ext.c

@@ -348,404 +348,6 @@ VALUE gs2crmod_tensor_field_gsl_tensor(VALUE self, VALUE options)
 	return field_real_space;
 }
 
-inline int arr_index(int ix, int iy, int ith, int it, int *c_shape, int t_size)
-{
-    return ix*c_shape[0]*c_shape[2]*t_size + iy*c_shape[0]*t_size + ith*t_size + it;
-}
-
-//Calculates normalized correlation function of 2 time series and stores result
-void correlate_norm(double *A, double *B, double *C, int t_size)
-{
-    //printf("%lf, %lf, %d\n", A[0], B[0], size);
-
-    int i, j, jmax;
-    double temp_sum, norm_a=0., norm_b=0.;
-
-    //printf("%lf, %lf, %lf, %d\n", A[0], B[0], C[0], t_size);
-    
-    //Sum over appropriate terms to get vector of correlations as function of time delay
-    //Split into two loops instead of trying to be too smart with the indices.
-    for(i=0; i<=t_size; i++){
-        temp_sum=0;
-        for(j=0; j<=i; j++)
-        {
-            temp_sum += A[j] * B[t_size - i - 1 + j];
-        }
-        C[i] = temp_sum;
-    }
-    //Second half
-    for(i=t_size+1; i<2*t_size-1; i++){
-        jmax = 2*t_size - 2 - i;
-        temp_sum=0;
-        for(j=0; j<=2*t_size-2-i; j++){
-            temp_sum += A[t_size - jmax - 1 + j] * B[j];
-        }
-        C[i] = temp_sum;
-    }
-
-//    for(i=0; i<t_size; i++)
-//       printf("%lf, ", A[i]);
-//    printf("\n\n");
-//    for(i=0; i<2*t_size-1; i++)
-//        printf("%lf, ", C[i]);
-//    printf("\n\ntemp_sum=%lf, Cmax=%lf\n", temp_sum, C[50]);
-
-    //Normalize each array with its zero time delay correlation value
-    for(i=0; i<t_size; i++){
-        norm_a += A[i]*A[i];
-        norm_b += B[i]*B[i];
-    }
-    //Final answer written to C array
-    for(i=0; i<2*t_size-1; i++)
-        C[i] = C[i]/sqrt(norm_a * norm_b);
-}
-
-VALUE gs2crmod_tensor_field_correlation_gsl_tensor(VALUE self, VALUE options)
-{
-    VALUE field_graphkit, shape, datakit, datakit_array;
-    VALUE x_narray, y_narray, z_narray, field_narray;
-    VALUE t_gsl_vector;
-    //Write some as floats to avoid flooring to wrong (lower) number later
-    float *lx_bin, *ly_bin, *lz_bin, *lt_bin;
-    float lxmin, lxmax, lymin, lymax, lzmin, lzmax, ltmin, ltmax, lx, ly, lz, *lt;
-    double *x, *y, *z, *t, *field, *coarray, *corr_norm;
-    int *c_shape, tot_size, ith, ix, iy, it, t_size, first=1;
-    int index, i2, i3, i4, tot_bins, *count;
-    long int i1;
-
-    printf("Starting correlation analysis\n");
-
-    /*Find time steps*/
-    /*self.gsl_vector('t')*/
-    //t_gsl_vector = RFCALL_11("gsl_vector", rb_str_new2("t"));
-    t_gsl_vector = rb_funcall(self, rb_intern("gsl_vector"), 2, rb_str_new2("t"), options);
-    t_size = NUM2INT(RFCALL_10_ON(t_gsl_vector, "size"));
-    t = ALLOC_N(double, t_size);
-    for(it=0; it<t_size; it++)
-    {
-        t[it] = NUM2DBL(CR_TELMT_R1(t_gsl_vector, it));
-    }
-
-    VALUE nbins_array=CR_HKS(options, "nbins_array");
-    int *nbins;
-	  if(RTEST(nbins_array) && RTEST(rb_obj_is_kind_of(nbins_array, RGET_CLASS_TOP("Array")))){
-        CR_INT_ARY_R2C_STACK(nbins_array, nbins);
-    }
-    else
-        rb_raise(RGET_CLASS_TOP("TypeError"), "Please specify nbins_array as a 4D array");
-
-    //correlation_type = options[:correlation_type]
-    //Test which correlation type is to be calculated using ruby string comparison in a proc
-    VALUE test_proc = rb_eval_string("Proc.new {|options| case options[:correlation_type]; when 'perp'; 0; when 'par'; 1; when 'time'; 2; when 'full'; 3 ;else; raise 'Please specify correlation_type as a string (perp/par/time/full)'; end}");
-    int corr_type = FIX2INT(RFCALL_11_ON(test_proc, "call", options));
-    
-    printf("Reading in data\n");
-    for(it=0; it<t_size; it++)
-    {   
-        /*options[:t_index] = it+1*/
-        /*options.send("[]=", :t_index, it+1)*/
-
-        //rb_funcall(options, rb_intern("[]="), ID2SYM(rb_intern("t_index")), Qnil);
-        CR_HKS_SET(options, "t_index", INT2FIX(it));
-
-        field_graphkit = RFCALL_11("field_real_space_graphkit", options);
-
-        /*shape = rb_funcall(field_graphkit, rb_intern("shape"), 0);*/
-        datakit_array = RFCALL_10_ON(field_graphkit, "data");
-        datakit = CR_ELEMENT_ACCESS(datakit_array, INT2FIX(0));
-        
-        /*Access data: datakit.x.data.narray*/ 
-        x_narray = RFCALL_10_ON(RFCALL_10_ON(RFCALL_10_ON(datakit, "x"), "data"), "narray");
-        y_narray = RFCALL_10_ON(RFCALL_10_ON(RFCALL_10_ON(datakit, "y"), "data"), "narray");
-        z_narray = RFCALL_10_ON(RFCALL_10_ON(RFCALL_10_ON(datakit, "z"), "data"), "narray");
-        field_narray = RFCALL_10_ON(RFCALL_10_ON(RFCALL_10_ON(datakit, "f"), "data"), "narray");
-
-        shape = RFCALL_10_ON(x_narray, "shape");
-        CR_INT_ARY_R2C_STACK(shape, c_shape);
-
-        if(first)
-        {
-            //ALLOC_N is used since it works correctly with ruby garbage collector
-            tot_size = c_shape[0]*c_shape[1]*c_shape[2]*t_size; 
-            x = ALLOC_N(double, tot_size);
-            y = ALLOC_N(double, tot_size);
-            z = ALLOC_N(double, tot_size);
-            field = ALLOC_N(double, tot_size);
-            first=0;
-        }
-
-
-        /*Copy NArrays to C arrays*/
-        for(ith=0; ith<c_shape[0]; ith++)
-            for(ix=0; ix<c_shape[1]; ix++)
-                for(iy=0; iy<c_shape[2]; iy++)
-                {
-                    index = arr_index(ix,iy,ith,it,c_shape,t_size);
-                    x[index] = NUM2DBL(CR_TELMT_R3(x_narray, ith, ix, iy));
-                    y[index] = NUM2DBL(CR_TELMT_R3(y_narray, ith, ix, iy));
-                    z[index] = NUM2DBL(CR_TELMT_R3(z_narray, ith, ix, iy));
-                    field[index] = NUM2DBL(CR_TELMT_R3(field_narray, ith, ix, iy));
-                }
-    }
-
-    
-
-    printf("Interpolating\n");
-    /******************************
-     *    GSL Interpolation of    *
-     *       field in time        *
-     *****************************/
-    //Read t interp from options (default is 100)
-    int nt_reg;
-	  if(RTEST(CR_HKS(options, "nt_reg")))
-        nt_reg = NUM2INT(CR_HKS(options, "nt_reg"));
-    else
-        nt_reg = 100;
-    int idx, ti;
-    double *x_reg, *y_reg, *z_reg, *t_reg, *field_reg, delta_t_reg, *y1;
-    tot_size = c_shape[0]*c_shape[1]*c_shape[2]*nt_reg; 
-    delta_t_reg = (t[t_size-1]-t[0])/(nt_reg-1);
-
-    y1 = ALLOC_N(double, t_size);
-    x_reg = ALLOC_N(double, tot_size);
-    y_reg = ALLOC_N(double, tot_size);
-    z_reg = ALLOC_N(double, tot_size);
-    t_reg = ALLOC_N(double, nt_reg);
-    field_reg = ALLOC_N(double, tot_size);
-
-    for(i1=0; i1<c_shape[0]*c_shape[1]*c_shape[2]*t_size; i1+=t_size)
-    {
-        for (i2 = 0; i2 < t_size; i2++)
-        {
-            y1[i2] = field[i1+i2];
-        }
-
-        gsl_interp_accel *acc 
-              = gsl_interp_accel_alloc ();
-        gsl_spline *spline 
-              = gsl_spline_alloc (gsl_interp_cspline, t_size);
-
-        gsl_spline_init (spline, t, y1, t_size);
-
-        for (ti = 0; ti < nt_reg; ti++)
-        {
-            t_reg[ti] = t[0]+ti*delta_t_reg;
-            idx = floor((i1)/t_size)*nt_reg;
-            x_reg[idx+ti] = x[i1];
-            y_reg[idx+ti] = y[i1];
-            z_reg[idx+ti] = z[i1];
-            field_reg[idx+ti] = gsl_spline_eval (spline, t_reg[ti], acc);
-        }
-        gsl_spline_free (spline);
-        gsl_interp_accel_free (acc);
-
-    }
-    
-    //Can now free the original pointers since redefined variables on a regular grid
-    free(x); x=0;
-    free(y); y=0;
-    free(z); z=0;
-    free(t); t=0;
-
-    /*printf("interpolated:\n");
-    for(i1=0; i1<c_shape[1]; i1++){
-        index = arr_index(i1,0,0,0,c_shape,nt_reg);
-        printf("%lf, ", x_reg[index]);
-    }*/
-
-    /**********************************************************************
-     * First need to know max and min lengths and times in each dimension *
-     * in order to define bins. These need to be specified before the loop*
-     * since the binning will be done at each step since there is too much*
-     * info to store.                                                     *
-     * ********************************************************************/
-    i3=0;
-    lxmin=0; lymin=0; lzmin=0;
-    for(i1=0; i1<tot_size; i1+=nt_reg){
-        //printf("%lf, %lf, %lf\n", x_reg[i1], y_reg[i1], z_reg[i1]);
-        for(i2=0; i2<tot_size; i2+=nt_reg)
-        {
-            lx = x_reg[i2] - x_reg[i1];
-            ly = y_reg[i2] - y_reg[i1];
-            lz = z_reg[i2] - z_reg[i1];
-            
-            if(lx < lxmin)
-                lxmin = lx;
-            if(ly < lymin)
-                lymin = ly;
-            if(lz < lzmin)
-                lzmin = lz;
-        }
-    }
-    lxmax = -lxmin;
-    lymax = -lymin;
-    lzmax = -lzmin;
-    ltmin = t_reg[0] - t_reg[nt_reg-1];
-    ltmax = -ltmin;
-    //printf("\nMin/Max = %lf, %lf\n", lxmin, lxmax);
-    //printf("Min/Max = %lf, %lf\n", lymin, lymax);
-    //printf("Min/Max = %lf, %lf\n", lzmin, lzmax);
-
-    //printf("Bins\n");
-    //Initialize the bin arrays
-    tot_bins = nbins[0]*nbins[1]*nbins[2]*nbins[3];
-    lx_bin = ALLOC_N(double, nbins[0]);
-    ly_bin = ALLOC_N(double, nbins[1]);
-    lz_bin = ALLOC_N(double, nbins[2]);
-    lt_bin = ALLOC_N(double, nbins[3]);
-    
-    for(i1=0; i1<nbins[0]; i1++){
-        lx_bin[i1] = lxmin + i1*(lxmax-lxmin)/(nbins[0]-1);
-        //printf("lx_bin = %f\n ", lx_bin[i1]);
-    }
-    for(i1=0; i1<nbins[1]; i1++){
-        ly_bin[i1] = lymin + i1*(lymax-lymin)/(nbins[1]-1);
-        //printf("ly_bin = %f\n", ly_bin[i1]);
-    }
-    for(i1=0; i1<nbins[2]; i1++){
-        lz_bin[i1] = lzmin + i1*(lzmax-lzmin)/(nbins[2]-1);
-        //printf("lz_bin = %f\n", lz_bin[i1]);
-    }
-    for(i1=0; i1<nbins[3]; i1++)
-        lt_bin[i1] = ltmin + i1*(ltmax-ltmin)/(nbins[3]-1);
-
-    //Now define and initialize the coarray and count arrays
-    coarray = ALLOC_N(double, tot_bins);
-    count = ALLOC_N(int, tot_bins);
-    corr_norm = ALLOC_N(double, (2*nt_reg-1));   //store correlate result before adding to coarray
-    lt = ALLOC_N(double, (2*nt_reg-1));   //Can calculate lt before loops
-
-    for(i1=0; i1<tot_bins; i1++){
-        coarray[i1] = 0.;
-        count[i1] = 0;
-    }
-    /******************************************************
-     * Start looping and calculating correlation function *
-     ******************************************************/
-    //Can predefine the time separations
-    for(i1=0; i1<2*nt_reg-1; i1++){
-        if(i1<nt_reg)
-            lt[i1] = t_reg[i1] - t_reg[nt_reg-1];
-        else if(i1>nt_reg-1)
-            lt[i1] = t_reg[i1-nt_reg] - t_reg[0] + delta_t_reg;
-    }
-
-    /* Now test which correlation function is to be calculated since full 4D correlation
-     * is usually intractable. The type was read in at begininning and corr_type corresponds to:
-     *
-     * 0 : perpendicular only (lz = 0)
-     * 1 : parallel only (lx = ly = 0)
-     * 2 : time only (lx = lz = 0)
-     * 3 : full correlation (may take very long) (all separations != 0)
-     */
-    float eps1 = 1e-5, eps2 = 1e5;  //define very small and very large numbers to test against
-    float lx_test, ly_test, lz_test;
-    switch (corr_type){
-      case 0: //perp
-        lx_test = eps2;
-        ly_test = eps2;
-        lz_test = eps1;
-        break;
-      case 1: //par
-        lx_test = eps1;
-        ly_test = eps1;
-        lz_test = eps2;
-        break;
-      case 2: //time
-        lx_test = eps1;
-        ly_test = eps2;
-        lz_test = eps1;
-        break;
-      case 3: //full
-        lx_test = eps2;
-        ly_test = eps2;
-        lz_test = eps2;
-        break;
-    }
-
-    printf("Main calculation loop\n\n");
-    //Start main loop for correlation function calculation
-    for(i1=0; i1<tot_size; i1+=nt_reg){
-        printf("\33[2K\r"); //Clear line in terminal
-        printf("\33[1A");   //Go back one line in terminal
-        printf("Main loop iterator = %ld of %ld\n", i1/nt_reg, tot_size/nt_reg);
-        for(i2=i1; i2<tot_size; i2+=nt_reg)
-        {
-            //Calculate spatial and temporal separation
-            lx = x_reg[i2] - x_reg[i1]; 
-            ly = y_reg[i2] - y_reg[i1]; 
-            lz = z_reg[i2] - z_reg[i1];
-
-            if(lx<lx_test && ly<ly_test && lz<lz_test){
-                //Calculate correlation function:
-                //corr = correlate(field[i1], field[i2], answer, no of t pts)
-                correlate_norm(&field_reg[i1], &field_reg[i2], &corr_norm[0], nt_reg);
-
-                //Calculate appropriate bin (subtracting min ensures +ve idx)
-                ix = floor((lx - lxmin) / (lx_bin[1] - lx_bin[0]));
-                iy = floor((ly - lymin) / (ly_bin[1] - ly_bin[0]));
-                ith = floor((lz - lzmin) / (lz_bin[1] - lz_bin[0]));
-                //printf("(%lf, %lf, %lf, %lf)\n", lz, lzmin, lz_bin[1], lz_bin[0]);
-                //printf("indices: (%d, %d, %d)\n", ix, iy, ith);
-
-                //Loop over time calculate time bin and put into coarray
-                for(i3=0; i3<2*nt_reg-1; i3++){
-                    it = floor((lt[i3] - ltmin) / (lt_bin[1] - lt_bin[0]));
-                    coarray[ix*nbins[1]*nbins[2]*nbins[3] + iy*nbins[2]*nbins[3] + ith*nbins[3] + it] += corr_norm[i3];
-                    count[ix*nbins[1]*nbins[2]*nbins[3] + iy*nbins[2]*nbins[3] + ith*nbins[3] + it] += 1;
-                }
-
-                /**************************
-                 * Repeat for negative    *
-                 * lx, ly, lz, to avoid   *
-                 * recalculating corr_norm*
-                 **************************/
-
-                lx = -lx; ly = -ly; lz = -lz;
-
-                //Calculate appropriate bin (subtracting min ensures +ve idx)
-                ix = floor((lx - lxmin) / (lx_bin[1] - lx_bin[0]));
-                iy = floor((ly - lymin) / (ly_bin[1] - ly_bin[0]));
-                ith = floor((lz - lzmin) / (lz_bin[1] - lz_bin[0]));
-                //printf("- = {%d, %d, %d}\n", ix, iy, ith);
-
-                //Loop over time calculate time bin and put into coarray
-                for(i3=0; i3<2*nt_reg-1; i3++){
-                    it = floor((-lt[i3] - ltmin) / (lt_bin[1] - lt_bin[0]));
-                    coarray[ix*nbins[1]*nbins[2]*nbins[3] + iy*nbins[2]*nbins[3] + ith*nbins[3] + it] += corr_norm[i3];
-                    count[ix*nbins[1]*nbins[2]*nbins[3] + iy*nbins[2]*nbins[3] + ith*nbins[3] + it] += 1;
-                }
-             }
-         }
-    } 
-    //End main loop
-
-    //Finally have to normalize coarray with count when count != 0
-    //printf("Normalization: \n");
-    for(i1=0; i1<tot_bins; i1++){
-       if(count[i1]>0){
-           coarray[i1] = coarray[i1]/count[i1];
-       }
-    }
-    //printf("Finish normalization: \n");
-
-    //Retun output to CR
-	  VALUE cgsl_tensor, output_tensor;
-    cgsl_tensor = RGET_CLASS(cgsl, "Tensor");
-    //output_tensor = GSL::Tensor.alloc(nbins, ...)
-    output_tensor = rb_funcall(cgsl_tensor, rb_intern("alloc"), 4, INT2FIX(nbins[0]), INT2FIX(nbins[1]), INT2FIX(nbins[2]), INT2FIX(nbins[3]));
-
-    for(i1=0; i1<nbins[0]; i1++)
-        for(i2=0; i2<nbins[1]; i2++)
-            for(i3=0; i3<nbins[2]; i3++)
-                for(i4=0; i4<nbins[3]; i4++){
-                    CR_TELMT_R4_SET(output_tensor, i1, i2, i3, i4, rb_float_new(coarray[i1*nbins[1]*nbins[2]*nbins[3] + i2*nbins[2]*nbins[3] + i3*nbins[3] + i4]));
-                }
-
-    printf("Finished correlation analysis\n");
-    return output_tensor; 
-}
-
 void Init_gs2crmod_ext()
 {
 	/*printf("HERE!!!");*/
@@ -769,7 +371,6 @@ void Init_gs2crmod_ext()
 
 	rb_define_method(ccode_runner_gs2_gsl_tensor_complexes, "field_gsl_tensor_complex_2", gs2crmod_tensor_complexes_field_gsl_tensor_complex_2, 1);
 	rb_define_method(ccode_runner_gs2_gsl_tensors, "field_real_space_gsl_tensor", gs2crmod_tensor_field_gsl_tensor, 1);
-	rb_define_method(ccode_runner_gs2_gsl_tensors, "field_correlation_gsl_tensor", gs2crmod_tensor_field_correlation_gsl_tensor, 1);
 
 	/*rb_define_method(ccode_runner_ext, "hello_world", code_runner_ext_hello_world, 0);*/
 }

data/gs2crmod.gemspec

@@ -2,14 +2,17 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
+# stub: gs2crmod 0.11.79 ruby lib
+# stub: ext/extconf.rb
 
 Gem::Specification.new do |s|
   s.name = "gs2crmod"
-  s.version = "0.11.78"
+  s.version = "0.11.79"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
   s.authors = ["Edmund Highcock", "Ferdinand van Wyk"]
-  s.date = "2014-10-08"
+  s.date = "2014-10-17"
   s.description = "GS2 is a gyrokinetic flux tube initial value turbulence code which can be used for fusion or astrophysical plasmas. CodeRunner is a framework for the automated running and analysis of large simulations. This module allows GS2 (and its sister code AstroGK) to harness the power of the CodeRunner framework."
   s.email = "edmundhighcock@sourceforge.net"
   s.extensions = ["ext/extconf.rb"]
@@ -75,13 +78,12 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "http://gs2crmod.sourceforge.net"
   s.licenses = ["GSLv3"]
-  s.require_paths = ["lib"]
   s.required_ruby_version = Gem::Requirement.new(">= 1.9.1")
-  s.rubygems_version = "1.8.23"
+  s.rubygems_version = "2.2.2"
   s.summary = "Module to allow CodeRunner to run and analyse the GS2 and AstroGK codes."
 
   if s.respond_to? :specification_version then
-    s.specification_version = 3
+    s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<coderunner>, [">= 0.14.15"])

data/lib/gs2crmod/calculations.rb

@@ -668,42 +668,11 @@ alias :ctehfa :calculate_transient_es_heat_flux_amplifications
 
 
 def calculate_transient_amplification(vector, options={})
-  t = gsl_vector(:t)
-
-  #Implement data smoothing through a moving average procedure of 5 surrounding points.
-  #This is needed since we need to know the turning points and need calculate gradients
-  #to find the points where they change sign. In order to get the actual transient amplification
-  #use the original data at the points where the gradient of smoothed data changes sign.
-
-  vec_smooth = GSL::Vector.alloc(vector.size-2);
-  vec_smooth[0] = vector[0]
-  vec_smooth[1] = (vector[0] + vector[1] + vector[2])/3
-  for i in 2...vector.size-2
-    vec_smooth[i] = (vector[i-2] + vector[i-1] + vector[i] + vector[i+1] + vector[i+2])/5
-  end
-
-  #Calculate the gradient of the smoothed function
-  grad = GSL::Vector.alloc(vec_smooth.size-1);
-  for i in 0...vec_smooth.size-1
-    grad[i] = (vec_smooth[i+1] - vec_smooth[i])/(t[i+1]-t[i]) 
-  end
-
-  #Now find the first two points where the gradient changes sign
-  #If your data still oscillates too much this method will not work.
-  #You will have to change the order of the data smoothing scheme.
-  turning_points = Array.new
-  for i in 1...grad.size
-    if GSL::sign(grad[i]) != GSL::sign(grad[i-1])
-      turning_points.push(i+1)
-    end
-  end
-
-  #Now calculate amplification factor using original vector (assuming turning point is roughly the same)
-  #by dividing value at max by the value at the min
-  if turning_points.empty? or turning_points.size < 2
-    return 0
+  if @g_exb_start_timestep
+    return GSL::Sf::log(vector[@g_exb_start_timestep...-1].max / vector[@g_exb_start_timestep])/2
   else
-    return vector[turning_points[1]]/vector[turning_points[0]]
+		eputs "Warning: could not calculate transient amplification since g_exb_start_timestep was not used. Returning 0."
+    return 0
   end
 end
 

data/lib/gs2crmod/graphs.rb

@@ -317,7 +317,7 @@ module GraphKits
 		when :options
 			return	[:mag, :norm, :z, :flip, :range, :kx_index, :ky_index, :kx, :ky, :strongest_non_zonal_mode]
 		when :plot, nil
-				eputs "Starting efn, this can take a while..."
+				#eputs "Starting efn, this can take a while..."
 				options[:imrc] ||= :real
 				ep options
 				options.convert_to_index(self, :ky)