gs2crmod 0.11.20 → 0.11.21

data/VERSION

@@ -1 +1 @@
-0.11.20
+0.11.21

data/ext/gs2crmod_ext.c

@@ -1,4 +1,8 @@
 #include "gs2crmod_ext.h"
+#include <math.h>
+#include <string.h>
+#include <gsl/gsl_spline.h>
+#include <gsl/gsl_spline.h>
 
 VALUE gs2crmod_tensor_complexes_field_gsl_tensor_complex_2(VALUE self, VALUE options)
 {
@@ -345,6 +349,408 @@ 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, amin;
+    int *c_shape, tot_size, ith, ix, iy, it, t_size, first=1;
+    int index, i, 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));
+    }
+
+    //Read from options
+	  if(RTEST(CR_HKS(options, "amin")))
+        amin = NUM2DBL(CR_HKS(options, "amin"));
+    else
+        amin = 1.0;
+
+    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));
+    
+    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)
+        {
+            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));
+                }
+    }
+
+    
+
+    /******************************
+     * 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; 
+    //printf("Start interpolation, %d, %d, %d, %d, %d\n", c_shape[0], c_shape[1], c_shape[2], nt_reg, tot_size);
+    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)
+    {
+        //printf("%d, %d\n", i1, c_shape[0]*c_shape[1]*c_shape[2]*t_size);
+        for (i2 = 0; i2 < t_size; i2++)
+        {
+            y1[i2] = field[i1+i2];
+            //printf ("%d, %lf %lf\n", i2, t[i2], y1[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);
+
+        //printf("Interpolated:\n");
+        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
+    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.                                                     *
+     * ********************************************************************/
+    double lx_pos_min=20;
+    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;
+    }
+
+    //Start main loop for correlation function calculation
+    for(i1=0; i1<tot_size; i1+=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!!!");*/
@@ -368,6 +774,7 @@ 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,15 +2,12 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: gs2crmod 0.11.20 ruby lib
-# stub: ext/extconf.rb
 
 Gem::Specification.new do |s|
   s.name = "gs2crmod"
-  s.version = "0.11.20"
+  s.version = "0.11.21"
 
   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-03-04"
   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."
@@ -85,12 +82,13 @@ 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 = "2.2.1"
+  s.rubygems_version = "1.8.11"
   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 = 4
+    s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<coderunner>, [">= 0.14.10"])

data/include/gs2crmod_ext.h

@@ -7,13 +7,18 @@
 #define RFCALL_10_ON(obj, name) (rb_funcall(obj, rb_intern(name), 0))
 #define RFCALL_11(name, arg1) (rb_funcall(self, rb_intern(name), 1, arg1))
 #define RFCALL_11_ON(obj, name, arg1) (rb_funcall(obj, rb_intern(name), 1, arg1))
+#define RFCALL_12(name, arg1, arg2) (rb_funcall(self, rb_intern(name), 2, arg1, arg2))
+#define RFCALL_12_ON(obj, name, arg1, arg2) (rb_funcall(obj, rb_intern(name), 2, arg1, arg2))
 #define CR_ELEMENT_ACCESS(recvr, key) ( \
 		RFCALL_11_ON(recvr, "[]", key) \
 		)
 #define CR_HKS(hash, cstr) (CR_ELEMENT_ACCESS(hash, ID2SYM(rb_intern(cstr))))
+#define CR_HKS_SET(hash, cstr, value)(rb_funcall(hash, rb_intern("[]="), 2, ID2SYM(rb_intern(cstr)), value))
 #define CR_RANGE_INC(start, end) (rb_funcall(RGET_CLASS_TOP("Range"), rb_intern("new"), 2, INT2FIX(start), INT2FIX(end)))
 #define CR_RANGE_EXC(start, end) (rb_funcall(RGET_CLASS_TOP("Range"), rb_intern("new"), 3, INT2FIX(start), INT2FIX(end), Qtrue))
 
+#define CR_SYM(cstr)(ID2SYM(rb_intern(cstr)))
+
 /*Allocates an integer array on the heap
  with values of array. int_ptr should be
  an unallocated int*. array should not
@@ -30,6 +35,14 @@
 			FIX2INT(RARRAY_PTR(array)[cr_internal_xaa11]);\
 		}
 
+/* Get element of  a rank 1,2 or 3 tensor respectively */
+#define CR_TELMT_R1(tensor, i)(rb_funcall(tensor, rb_intern("[]"), 1, INT2FIX(i)))
+#define CR_TELMT_R2(tensor, i, j)(rb_funcall(tensor, rb_intern("[]"), 2, INT2FIX(i), INT2FIX(j)))
+#define CR_TELMT_R3(tensor, i, j, k)(rb_funcall(tensor, rb_intern("[]"), 3, INT2FIX(i), INT2FIX(j), INT2FIX(k)))
+
+// Set the value of a 4D tensor
+#define CR_TELMT_R4_SET(tensor, i, j, k, l, value)(rb_funcall(tensor, rb_intern("[]="), 5, INT2FIX(i), INT2FIX(j), INT2FIX(k), INT2FIX(l), value))
+ 
 
 /*Allocates an integer array on the heap
  with values of array. int_ptr should be

data/lib/gs2crmod/gs2.rb

@@ -1159,6 +1159,90 @@ end
 		end
 	end
 
+  #This function will handle running the correlation analysis and writing the results to a NetCDF file.
+  #Cases need to be handled differently since perp, par and full are just subsets of the full correlation function
+  #but the time correlation calculation needs to deal with each radial location separately. Time correlation
+  #uses the zonal flows in the toroidal direction to calculate the correlation time.
+  #
+  #This function takes in the same options as field_real_space_standard_representation, along with the following
+  #new options dealing with interpolation and binning:
+  #
+  # correlation_type: determines which subset of correlation function should be calculated (perp/par/full/time)
+  # nbins_array: array giving number of bins to use in the binning procedure. Index order (x, y, z ,t)
+  # nt_reg: Most of the time you have many more time points than you need for spatial correlations. This sets
+  #         number of new interpolation points in time.
+  #
+  # Using this function: Since this can only be single threaded, this can be a very expensive calculation when
+  # trying to do the full correlation function, so this is not recommended for highly resolved nonlinear runs. This is
+  # why the perp/par/full splitting is implemented, allowing one dimension to be taken out essentially.
+  def correlation_analysis(options={})
+
+    #Sanity checks: 
+    #Cannot only have one bin since require difference between bins for index calculation 
+    if options[:nbins_array].include?1
+      raise('Cannot have only one bin in nbins_array. Minuimum is two.')
+    end
+    #Thetamin shouldn't be equal to thetamax to avoid possibili
+    #
+    
+    case options[:correlation_type]
+    when 'perp', 'par', 'full'
+      gsl_tensor = field_correlation_gsl_tensor(options)
+      shape = gsl_tensor.shape
+
+      #Set up dimensions
+      file = NumRu::NetCDF.create(@run_name + "_correlation_analysis_#{options[:correlation_type]}.nc")
+      ydim = file.def_dim('x',shape[0])
+      xdim = file.def_dim('y',shape[1])
+      zdim = file.def_dim('z',shape[2])
+      tdim = file.def_dim('t',shape[3])
+      correlation_var = file.def_var("correlation", 'sfloat', [xdim, ydim, zdim, tdim])
+      file.enddef
+      #Write out array
+      correlation_var.put(NArray.to_na(gsl_tensor.to_a))
+      file.close
+    when 'time'
+        nakx_actual = NumRu::NetCDF.open(@run_name + ".out.nc").var('kx').get
+        kx_len = nakx_actual.length
+      if options[:nakx] == nil
+        radial_pts = kx_len
+      elsif options[:nakx] <= kx_len
+        radial_pts = options[:nakx]
+      else
+        raise('nakx exceeds the total number of kx\'s in simulation')
+      end
+
+      #Check whether t_index_window is specified, if not, set to entire t range
+      if options[:t_index_window] == nil
+        options[:t_index_window] = [1, -1]
+      end
+
+
+      #Now loop through the radial locations and calculate the correlation function in y and t.
+      for x in 0...radial_pts
+        options[:xmin] = x
+        options[:xmax] = x
+        gsl_tensor = field_correlation_gsl_tensor(options)
+        shape = gsl_tensor.shape
+
+        if x == 0 #Write dimensions to NetCDF file
+          file = NumRu::NetCDF.create(@run_name + "_correlation_analysis_#{options[:correlation_type]}.nc")
+          ydim = file.def_dim('x',shape[0])
+          xdim = file.def_dim('y',shape[1])
+          zdim = file.def_dim('z',shape[2])    
+          tdim = file.def_dim('t',shape[3])
+        end
+        file.redef
+        correlation_var = file.def_var("correlation_x_#{x}", 'sfloat', [xdim, ydim, zdim, tdim])
+        file.enddef
+        #Write out array
+        correlation_var.put(NArray.to_na(gsl_tensor.to_a))
+      end
+        file.close #only close after loop over radial points
+    else
+      raise 'Please specify correlation_type as perp/par/time/full'
+    end
+  end
 	end # class GS2
 	# For backwards compatibility
 

data/lib/gs2crmod/gsl_data_3d.rb

@@ -171,7 +171,7 @@ class CodeRunner::Gs2
 			case options[:field_name].to_s
 			when /density/
 				options.convert_to_index(self, :species)
-				ep 'options', options
+				#ep 'options', options
 				options[:species_index] - 1
 			else
 				nil
@@ -179,7 +179,7 @@ class CodeRunner::Gs2
 		end
 		def field_gsl_tensor(options)
 			species_element = field_species_element(options)
-			ep 'species_element', species_element
+			#ep 'species_element', species_element
 			if options[:t_index]
 				#ep options; gets
                 #raise CRFatal.new("write_phi_over_time is not enabled so this function won't work") unless @write_phi_over_time

data/test/test_gs2crmod.rb

@@ -59,6 +59,12 @@ class TestAnalysis < Test::Unit::TestCase
 		assert_equal(6.6036e-01, @run.frequency_at_ky_at_kx[0.5][2.5133])
 		#p @run.gsl_vector('kx'); STDIN.gets
 		assert_equal(6.6036e-01, @run.frequency_at_ky_at_kx[0.5][@run.gsl_vector('kx')[3]])
+
+    #Correlation analysis testing
+    CodeRunner.run_command('correlation_analysis(correlation_type:"full", field_name:"density", gs2_coordinate_factor:1.0, species_index: 1, nbins_array:[4,4,4,25], nt_reg:25, Rgeo:3, n0:1)', {j:1, Y:tfolder})
+    corr_file = NumRu::NetCDF.open("#{tfolder}/v/id_1/v_write_moments_.true._write_line_.true._id_1_correlation_analysis_full.nc")
+    corr_function = corr_file.var('correlation').get
+    assert_equal([4,4,4,25], corr_function.shape)
 	end
 	def test_interpolation
 		assert_equal(5, @run.gsl_vector('kx').size)

metadata

@@ -1,7 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: gs2crmod
 version: !ruby/object:Gem::Version
-  version: 0.11.20
+  version: 0.11.21
+  prerelease: 
 platform: ruby
 authors:
 - Edmund Highcock
@@ -13,102 +14,81 @@ date: 2014-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coderunner
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &23277780 !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.14.10
   type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.14.10
+  version_requirements: *23277780
 - !ruby/object:Gem::Dependency
   name: rubyhacks
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &23277220 !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.1.2
   type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.2
+  version_requirements: *23277220
 - !ruby/object:Gem::Dependency
   name: ruby-netcdf-updated
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &23273380 !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.6.6.1
   type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.6.6.1
+  version_requirements: *23273380
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &23443080 !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *23443080
 - !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &23442460 !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '3.12'
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.12'
+  version_requirements: *23442460
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &23441920 !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - ">"
+    - - ! '>'
       - !ruby/object:Gem::Version
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">"
-      - !ruby/object:Gem::Version
-        version: 1.0.0
+  version_requirements: *23441920
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &23441400 !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.8.4
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.8.4
+  version_requirements: *23441400
 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
@@ -122,7 +102,7 @@ extra_rdoc_files:
 - README.md
 - README.rdoc
 files:
-- ".document"
+- .document
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -185,25 +165,26 @@ files:
 homepage: http://gs2crmod.sourceforge.net
 licenses:
 - GSLv3
-metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - ">="
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: 1.9.1
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - ">="
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 1.8.11
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: Module to allow CodeRunner to run and analyse the GS2 and AstroGK codes.
 test_files: []

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: 6573d709227e4e6a3ef38b5e91a2a798051bbe94
-  data.tar.gz: 34e87dca9ffb31bb3700be59cf829adb3c8a0bf7
-SHA512:
-  metadata.gz: b059c57412e1c7cf3dfd78d4c2d2cf8dfc588ce9d4336b39608861351210605501656b1c512997e99afdf4771d582858ccd2e051322cee777bcc4f28f198e405
-  data.tar.gz: 2df0e3c66ed093b41fc620775a7b8b01622fe3d7188ee5a7e7b1622ef94c7c73038e68bcd175af0f7ec727b6f3ceb57025ae6f4e7740fda93ebb6cb5a2bfe9bb