gphys 1.1.1a

data/install.rb

@@ -0,0 +1,130 @@
+require 'rbconfig'
+require 'find'
+include Config
+if CONFIG["MINOR"].to_i > 6 then $rb_18 = true else $rb_18 = false end
+if $rb_18
+  require 'fileutils'
+else
+  require 'ftools'
+end
+
+=begin
+$version = CONFIG["MAJOR"]+"."+CONFIG["MINOR"]
+$libdir = File.join(CONFIG["libdir"], "ruby", $version)
+# $archdir = File.join($libdir, CONFIG["arch"])
+$site_libdir = $:.find {|x| x =~ /site_ruby$/}
+if !$site_libdir
+  $site_libdir = File.join($libdir, "site_ruby")
+elsif Regexp.compile($site_libdir) !~ Regexp.quote($version)
+  $site_libdir = File.join($site_libdir, $version)
+end
+
+default_destdir = $site_libdir
+=end
+default_destdir = CONFIG["sitelibdir"]
+
+default_bindir = CONFIG["bindir"]
+
+def install_rb(srcdir, destdir)
+  libdir = "lib"
+  libdir = File.join(srcdir, libdir) if srcdir
+  path = []
+  dir = []
+  Find.find(libdir) do |f|
+    next unless FileTest.file?(f)
+    next if (f = f[libdir.length+1..-1]) == nil
+    next if (/CVS$/ =~ File.dirname(f))
+    path.push f
+    dir |= [File.dirname(f)]
+  end
+  for f in dir
+    next if f == "."
+    next if f == "CVS"
+    if $rb_18
+      FileUtils.makedirs(File.join(destdir, f))
+    else
+      File::makedirs(File.join(destdir, f))
+    end
+  end
+  for f in path
+    next if (/\~$/ =~ f)
+    next if (/^\./ =~ File.basename(f))
+    if $rb_18
+      FileUtils.install(File.join(libdir, f), File.join(destdir, f), {:mode => 0644, :verbose => true})
+    else
+      File::install(File.join(libdir, f), File.join(destdir, f), 0644, true)
+    end
+  end
+end
+
+def install_bin(srcdir, destbindir)
+  localbindir = "bin"
+  localbindir = File.join(srcdir, localbindir) if srcdir
+  path = []
+  dir = []
+  Find.find(localbindir) do |f|
+    next unless FileTest.file?(f)
+    next if (f = f[localbindir.length+1..-1]) == nil
+    next if (/CVS$/ =~ File.dirname(f))
+    path.push f
+    #dir |= [File.dirname(f)]
+  end
+  #for f in dir
+  #  next if f == "."
+  #  next if f == "CVS"
+  #  File::makedirs(File.join(destbindir, f))
+  #end
+  for f in path
+    next if (/\~$/ =~ f)
+    next if (/^\./ =~ File.basename(f))
+    if $rb_18
+      FileUtils.install(File.join(localbindir, f), File.join(destbindir, f), {:mode => 0755, :verbose => true})
+    else
+      File::install(File.join(localbindir, f), File.join(destbindir, f), 0755, true)
+    end
+  end
+end
+
+def ARGV.switch
+  return nil if self.empty?
+  arg = self.shift
+  return nil if arg == '--'
+  if arg =~ /^-(.)(.*)/
+    return arg if $1 == '-'
+    raise 'unknown switch "-"' if $2.index('-')
+    self.unshift "-#{$2}" if $2.size > 0
+    "-#{$1}"
+  else
+    self.unshift arg
+    nil
+  end
+end
+
+def ARGV.req_arg
+  self.shift || raise('missing argument')
+end
+
+destdir = default_destdir
+bindir = default_bindir
+
+begin
+  while switch = ARGV.switch
+    case switch
+    when '-d', '--destdir'
+      destdir = ARGV.req_arg
+    when '-b', '--bindir'
+      bindir = ARGV.req_arg
+    else
+      raise "unknown switch #{switch.dump}"
+    end
+  end
+rescue
+  STDERR.puts $!.to_s
+  STDERR.puts File.basename($0) + 
+    " -d <destdir> -b <bindir>"
+  exit 1
+end    
+
+install_rb(nil, destdir)
+install_bin(nil, bindir)
+

data/interpo.c

@@ -0,0 +1,497 @@
+/* interpo.c : Extention library regarding interpolation of GPhys
+ */
+
+#include<stdio.h>
+#include<string.h>
+#include "ruby.h"
+#include "narray.h"
+
+#ifndef RARRAY_PTR
+#  define RARRAY_PTR(ary) (RARRAY(ary)->ptr)
+#endif
+#ifndef RARRAY_LEN
+#  define RARRAY_LEN(ary) (RARRAY(ary)->len)
+#endif
+
+static VALUE
+interpo_do(obj, shape_to, idxmap, val_from, missval)
+     VALUE obj;
+     VALUE shape_to; // [Array] shape of the new grid
+     VALUE idxmap;   // [Array] index mapping
+     VALUE val_from; // [NArray] values to be interpolated
+     VALUE missval;  // [nil or Float] missing value if Float
+{
+    VALUE val_to;
+    VALUE chk , ary;
+    struct NARRAY *naf;
+    VALUE vm;
+    int natype;
+    int *sht;  // shape to (could be size_t if NArray is changed)
+    int *shf;  // shape from (could be size_t if NArray is changed)
+    size_t cshf;
+    size_t rankf, rankt, lent;
+    double *pt, *pf;
+    int nomiss;
+    double vmiss;
+    size_t i, it, kf, j, k, l;
+    int *mtyp;
+    size_t *dm, *dm2, *dm2f, *dm3, *dm3f, *dm4, *dm4f;
+    int **di, nid, nic;
+    double **df, *f, a;
+    size_t *idf, idfc, *idt;
+
+    // check arguments
+
+    if (TYPE(shape_to) != T_ARRAY){
+        rb_raise(rb_eTypeError, "1st arg must be an array");
+    }
+    if (TYPE(idxmap) != T_ARRAY){
+        rb_raise(rb_eTypeError, "2nd arg must be an array");
+    }
+
+    chk = rb_obj_is_kind_of(val_from, cNArray);
+    if (chk == Qfalse) {
+	rb_raise(rb_eTypeError, "3rd arg must be an NArray");
+    }
+
+    // read argument (shape_to)
+
+    rankt = RARRAY_LEN(shape_to);
+    sht = ALLOCA_N(int, rankt);
+    for(i=0; i<rankt; i++){
+	sht[i] = NUM2INT( RARRAY_PTR(shape_to)[i] );
+    }
+
+    // read argument (val_from)
+
+    natype = NA_TYPE(val_from);  // saved
+    val_from = na_cast_object(val_from, NA_DFLOAT);
+    rankf = NA_RANK(val_from);
+    GetNArray(val_from, naf);
+    shf = naf->shape;
+    pf = NA_PTR_TYPE(val_from, double *);
+
+    // read argument (missval)
+
+    nomiss = (missval == Qnil);
+    if (!nomiss){
+	vmiss = NUM2DBL(missval);
+    }
+
+    // read argument (idxmap) 
+
+    if (RARRAY_LEN(idxmap) != rankf){
+        rb_raise(rb_eArgError, "length of 2nd arg and rank of 3rd arg must agree");
+    }
+
+    mtyp = ALLOCA_N(int,    rankf);
+    dm   = ALLOCA_N(size_t, rankf);
+    dm2  = ALLOCA_N(size_t, rankf);
+    dm2f = ALLOCA_N(size_t, rankf);
+    dm3  = ALLOCA_N(size_t, rankf);
+    dm3f = ALLOCA_N(size_t, rankf);
+    dm4  = ALLOCA_N(size_t, rankf);
+    dm4f = ALLOCA_N(size_t, rankf);
+    di   = ALLOCA_N(int *,    rankf);
+    df   = ALLOCA_N(double *, rankf);
+    nid = 0;
+    for(i=0; i<rankf; i++){
+	vm = RARRAY_PTR(idxmap)[i];
+	if (RARRAY_LEN(vm) == 1) {
+	    mtyp[i] = 0;   // simple copying
+	    dm[i]  = NUM2INT( RARRAY_PTR(vm)[0] ); 
+	} else if ( RARRAY_PTR(vm)[1] == Qnil ) {
+	    mtyp[i] = 1;   // mapping from 1D
+	    dm[i]  = NUM2INT( RARRAY_PTR(vm)[0] ); 
+	    di[i] = NA_PTR_TYPE( RARRAY_PTR(vm)[2], int *);
+	    df[i] = NA_PTR_TYPE( RARRAY_PTR(vm)[3], double *);
+	    nid++;
+	} else {
+	    dm[i]  = NUM2INT( RARRAY_PTR(vm)[0] ); 
+	    ary = RARRAY_PTR(vm)[1];
+	    mtyp[i] = RARRAY_LEN(ary)+1;   // mapping from multi-D
+	    switch( mtyp[i] ){
+	    case 4:  // do not break
+		dm4[i] = NUM2INT( RARRAY_PTR(ary)[2] ); 
+		dm4f[i]= sht[NUM2INT( RARRAY_PTR(ary)[1] )]; 
+	    case 3:  // do not break
+		dm3[i] = NUM2INT( RARRAY_PTR(ary)[1] ); 
+		dm3f[i]= sht[NUM2INT( RARRAY_PTR(ary)[0] )];
+	    case 2:
+		dm2[i] = NUM2INT( RARRAY_PTR(ary)[0] ); 
+		dm2f[i]= sht[dm[i]]; 
+	    }
+	    di[i] = NA_PTR_TYPE( RARRAY_PTR(vm)[2], int *);
+	    df[i] = NA_PTR_TYPE( RARRAY_PTR(vm)[3], double *);
+	    nid++;
+	}
+    }
+
+    f = ALLOCA_N(double, nid);
+    nic = 1 << nid ;   // ==> 2**nid
+
+    // prepare output object
+
+    val_to = na_make_object(NA_DFLOAT, rankt, sht, cNArray);  // double for a momnent
+    lent = NA_TOTAL(val_to);
+    pt = NA_PTR_TYPE(val_to, double *);
+
+
+    // do interpolation
+
+    idt  = ALLOCA_N(size_t, rankt);
+    idf  = ALLOCA_N(size_t, rankf);
+
+    for(it=0; it<lent; it++){
+	l = it;
+	for(j=0; j<rankt; j++){
+	    idt[j] = l % sht[j];
+	    l /= sht[j];
+	}
+	k = 0;
+	for(j=0; j<rankf; j++){
+	    switch(mtyp[j]){
+	    case 0:
+		idf[j] = idt[dm[j]];
+		break;
+	    case 1:
+		idf[j] = di[j][ idt[dm[j]] ];
+		f[k] = df[j][ idt[dm[j]] ];
+		k++;
+		break;
+	    case 2:
+		idf[j] = di[j][ idt[dm[j]] + dm2f[j]*idt[dm2[j]] ];
+		f[k] = df[j][ idt[dm[j]] + dm2f[j]*idt[dm2[j]] ];
+		k++;
+		break;
+	    case 3:
+                idf[j] = di[j][ idt[dm[j]] + 
+			      dm2f[j]*(idt[dm2[j]] + dm3f[j]*idt[dm3[j]]) ];
+		f[k] = df[j][ idt[dm[j]] + 
+			      dm2f[j]*(idt[dm2[j]] + dm3f[j]*idt[dm3[j]]) ];
+		k++;
+		break;
+	    case 4:
+		idf[j] = di[j][ idt[dm[j]] + 
+			      dm2f[j]*(idt[dm2[j]] + dm3f[j]*
+				       (idt[dm3[j]]+dm4f[j]*idt[dm4[j]])) ];
+		f[k] = df[j][ idt[dm[j]] + 
+			      dm2f[j]*(idt[dm2[j]] + dm3f[j]*
+				       (idt[dm3[j]]+dm4f[j]*idt[dm4[j]])) ];
+		k++;
+		break;
+	    }
+	}
+	pt[it] = 0.0;
+	for(l=0; l<nic; l++){   // loop for 2**nid times
+	    a = 1.0;
+	    for(k=0; k<nid; k++){
+		a = ( (l>>k)%2 ? a*f[k] : a*(1.0 - f[k]) );
+	    }
+	    cshf=1;
+	    kf = 0;
+	    k = 0;
+	    for(j=0; j<rankf; j++){
+		idfc = idf[j];
+		if(mtyp[j]>0){
+                    if ( (l>>k)%2 && idfc<shf[j]-1 ){
+                        idfc += 1;
+                    }
+		    k++;
+		}
+		kf += idfc*cshf;
+		cshf *= shf[j];
+	    }
+	    if (nomiss || pf[kf] != vmiss){
+		pt[it] += a*pf[kf];
+	    } else {
+		pt[it] = vmiss;
+		break;
+	    }
+	}
+    }
+
+    // finish
+    val_to = na_cast_object(val_to, natype);
+    return val_to;
+}
+
+static void
+__interpo_find_loc_1D(N, P, n, p, ids, f)
+     double *P, *p;   // INPUT
+     size_t N, n;     // INPUT
+     int *ids;        // OUTPUT
+     double *f;       // OUTPUT
+{
+    size_t i, j, il, ir;
+    int down;
+
+    // first time finding : use a simple looping 
+    j = 0;
+    for(i=0; i<n-1; i++){
+	if ( (p[i]-P[j])*(P[j]-p[i+1]) >= 0 ){
+	    break;
+	}
+    }
+    if (i<n-1){
+	// found
+	ids[j] = i;
+    } else {
+	// not found --> to be extrapolated
+	if ( (P[j]-p[0])*(p[0]-p[n-1]) >= 0 ){
+	    ids[j] = i = 0;
+	} else {
+	    ids[j] = i = n-2;
+	}
+    }
+    f[j] = (p[i]-P[j])/(p[i]-p[i+1]);
+
+    // second or later time finding : start from the previous position
+    for(j=1; j<N; j++){
+	down = 1; // true : move i downward next time
+	il = ir = i;
+	while (1){
+	    if ( (p[i]-P[j])*(P[j]-p[i+1]) >= 0 ) {
+		break;
+	    } else {
+		if ( il>0 && ( down || ir==n-1 )  ){
+		    il--;
+		    i = il;
+		    down = 0; // false
+		} else if ( ir<n-1 && ( !down || il==0 ) ){
+		    ir++;
+		    i = ir;
+		    down = 1; // true
+		} else {
+		    // not found --> to be extrapolated
+		    if ( (P[j]-p[0])*(p[0]-p[n-1]) >= 0 ){
+			i = 0;
+		    } else {
+			i = n-2;
+		    }
+		    break;
+		}
+	    }
+	}
+	ids[j] = i;
+	f[j] = (p[i]-P[j])/(p[i]-p[i+1]);
+    }
+}
+
+static VALUE
+interpo_find_loc_1D(obj, X, x)
+     VALUE obj;
+     VALUE X; // [NArray(1D)] coordinate values onto which interpolation is made
+     VALUE x; // [NArray(1D)] coordinate values of original data
+{
+    VALUE na_ids, na_f;
+    VALUE chk;
+    size_t N, n;
+    struct NARRAY *na;
+    double *P, *p;
+    int *ids;
+    double *f;
+    int shape[1];  // could be size_t if NArray is changed
+
+    // check and unwrap the input arguments
+
+    chk = rb_obj_is_kind_of(X, cNArray);
+    if (chk == Qfalse) {rb_raise(rb_eTypeError, "expect NArray (1st arg)");}
+
+    chk = rb_obj_is_kind_of(x, cNArray);
+    if (chk == Qfalse) {rb_raise(rb_eTypeError, "expect NArray (2nd arg)");}
+
+    X = na_cast_object(X, NA_DFLOAT);
+    GetNArray(X, na);
+    N = na->total;
+    P = (double *)NA_PTR(na, 0);
+
+    x = na_cast_object(x, NA_DFLOAT);
+    GetNArray(x, na);
+    n = na->total;
+    p = (double *)NA_PTR(na, 0);
+
+    // prepare output NArrays
+
+    shape[0] = N;
+    na_ids = na_make_object(NA_LINT, 1, shape, cNArray);
+    GetNArray(na_ids, na);
+    ids = (int *) NA_PTR(na, 0);
+    na_f = na_make_object(NA_DFLOAT, 1, shape, cNArray);
+    GetNArray(na_f, na);
+    f = (double *) NA_PTR(na, 0);
+
+    // Do the job
+
+    __interpo_find_loc_1D(N, P, n, p, ids, f);
+
+    // Return
+
+    return rb_ary_new3(2, na_ids, na_f);
+}
+
+/* To apply interpo_find_loc_1D multi-dimensionally 
+ */
+static VALUE
+interpo_find_loc_1D_MD(obj, X, x, dimc)
+     VALUE obj;
+     VALUE X; // [NArray(1D)] coordinate values onto which interpolation is made
+     VALUE x; // [NArray(multi-D)] coordinate values of original data
+     VALUE dimc; // [Integer] the dimension in x except which mapping has been set
+{
+    VALUE na_ids, na_f;
+    VALUE chk;
+    size_t N, n1;
+    struct NARRAY *na;
+    double *P, *p, *p1;
+    int *ids, *ids1;
+    double *f, *f1;
+    int *shr;  // shape of the result (could be size_t if NArray is changed)
+    int *shl;  // shape of multi-D loop (could be size_t if NArray is changed)
+    int *shx;  // shape of x (could be size_t if NArray is changed)
+    int dmc; // dimc
+    int rank, dl, dc;
+    size_t *cshxl, *cshrl, *cshl; // cumulative shapes for looping
+    size_t fxl;    // same but only for the dimension treated here
+    size_t il, i, j, ix, ir, totl;
+
+    // check and unwrap the input arguments
+
+    chk = rb_obj_is_kind_of(X, cNArray);
+    if (chk == Qfalse) {rb_raise(rb_eTypeError, "expect NArray (1st arg)");}
+
+    chk = rb_obj_is_kind_of(x, cNArray);
+    if (chk == Qfalse) {rb_raise(rb_eTypeError, "expect NArray (2nd arg)");}
+
+    X = na_cast_object(X, NA_DFLOAT);
+    GetNArray(X, na);
+    N = na->total;
+    P = (double *)NA_PTR(na, 0);
+
+    dmc = NUM2INT( dimc ); 
+
+    x = na_cast_object(x, NA_DFLOAT);
+    GetNArray(x, na);
+    p = (double *)NA_PTR(na, 0);
+    shx = na->shape; 
+    n1 = shx[dmc];
+
+    rank = NA_RANK(x);
+
+    if (dmc<0 || dmc>=rank){
+        rb_raise(rb_eArgError, "Specified dimension (4th argument) is outside the dims of the multi-D coordinate variable");
+    }
+
+    // prepare output NArrays
+
+    shl = ALLOCA_N(int, rank-1);
+    shr = ALLOCA_N(int, rank);
+    shr[0] = N;
+    totl = 1;
+    for(dl=0,dc=0; dl<rank-1; dl++,dc++){
+	if(dc==dmc){dc++;}  // to skip shx[dmc]
+	shr[dl+1] = shl[dl] = shx[dc]; 
+	totl *= shl[dl];
+    }
+
+    cshl = ALLOCA_N(size_t, rank-1);
+    cshl[0] = 1;
+    for(dl=1; dl<rank-1; dl++){
+	cshl[dl] = cshl[dl-1]*shl[dl-1];
+    }
+
+    cshxl = ALLOCA_N(size_t, rank-1);
+    if(dmc==0) {
+ 	fxl = 1;
+	cshxl[0] = shx[0];
+    } else {
+ 	fxl = shx[0];
+	cshxl[0] = 1;
+    }
+
+    for(dl=1,dc=1; dl<rank-1; dl++,dc++){
+	if(dc==dmc){
+	    fxl = cshxl[dl-1]*shx[dc-1];
+	    dc++;
+            cshxl[dl] = fxl*shx[dc-1];
+	} else {
+            cshxl[dl] = cshxl[dl-1]*shx[dc-1];
+        }
+    }
+    if (dmc==rank-1){
+	fxl = cshxl[rank-2]*shx[rank-2];
+    }
+
+    cshrl = ALLOCA_N(size_t, rank-1);
+    cshrl[0] = shr[0];
+    for(dl=1; dl<rank-1; dl++){
+	cshrl[dl] = cshrl[dl-1]*shr[dl];
+    }
+
+    na_ids = na_make_object(NA_LINT, rank, shr, cNArray);
+    GetNArray(na_ids, na);
+    ids = (int *) NA_PTR(na, 0);
+    na_f = na_make_object(NA_DFLOAT, rank, shr, cNArray);
+    GetNArray(na_f, na);
+    f = (double *) NA_PTR(na, 0);
+
+    // Do the job
+
+    p1 =  ALLOCA_N(double, n1);
+    ids1 =  ALLOCA_N(int, N);
+    f1 =  ALLOCA_N(double, N);
+    for(il=0; il<totl; il++){
+
+	// put a 1D subset of p into p1 (p1 = p[..., true,...])
+
+	ix = 0;
+	ir = 0;
+	for(dl=0; dl<rank-1; dl++){
+	    i = (il/cshl[dl]) % shl[dl];
+	    ix += cshxl[dl]*i;
+	    ir += cshrl[dl]*i;
+	}
+
+	for(j=0; j<n1; j++){
+	    p1[j] = p[ix+fxl*j];
+	}
+
+	// find loc in 1D
+
+	__interpo_find_loc_1D(N, P, n1, p1, ids1, f1);
+
+	// substitute ids1 and f1 (1D) into ids and f (multi-D)
+ 
+	for(j=0; j<N; j++){
+	    ids[ir+j] = ids1[j];
+	    f[ir+j] = f1[j];
+	    //printf("  %d %f\n",ids1[j],f1[j]);
+	}
+	//printf("\n");
+
+    }
+
+    // Return
+
+    return rb_ary_new3(2, na_ids, na_f);
+}
+
+
+void
+init_gphys_interpo()
+{
+    static VALUE mNumRu;
+    static VALUE cGPhys;
+
+    // rb_require("narray");  // it does not work
+    mNumRu = rb_define_module("NumRu");
+    cGPhys = rb_define_class_under(mNumRu, "GPhys", rb_cObject);
+    rb_define_private_method(cGPhys, "c_interpo_find_loc_1D", interpo_find_loc_1D, 2);
+    rb_define_private_method(cGPhys, "c_interpo_find_loc_1D_MD", interpo_find_loc_1D_MD, 3);
+
+    rb_define_private_method(cGPhys, "c_interpo_do", interpo_do, 4);
+
+    // to make "find loc" methods available outside GPhys as class methods
+    rb_define_singleton_method(cGPhys, "interpo_find_loc_1D", interpo_find_loc_1D, 2);
+    rb_define_singleton_method(cGPhys, "interpo_find_loc_1D_MD", interpo_find_loc_1D_MD, 3);
+}

data/lib/numru/dcl_mouse.rb

@@ -0,0 +1,71 @@
+require "numru/dcl"
+
+module NumRu
+
+  class DCLMousePt
+    @@t_thres = 0.05  # threshold of time delay [in sec] to judge interaction
+    def initialize
+      ta = Time.now
+      wx = wy = nil
+      while(true)
+        wx, wy, mb = DCL.swqpnt
+        tb = Time.now
+        if (tb-ta > @@t_thres)   # OK if it takes a short time 
+          break 
+        else     # Too fast. It must be due to previous clicks. Take one again.
+          ta = tb
+        end
+      end
+      @rx, @ry = NumRu::DCL.stiwtr(wx, wy)
+      @vx, @vy = NumRu::DCL.stipr2(rx, ry) 
+      @ux, @uy = NumRu::DCL.stitrf(vx, vy)
+      @wx = wx
+      @wy = wy
+    end
+
+    attr_accessor :ux, :uy, :vx, :vy, :rx, :ry, :wx, :wy
+
+    def uxy
+      [@ux, @uy]
+    end
+
+    def vxy
+      [@vx, @vy]
+    end
+
+    def rxy
+      [@rx, @ry]
+    end
+
+    def mark(type=2,index=1,size=0.02)
+      DCL.uumrkz([@ux], [@uy], type, index, size)
+    end
+  end
+
+  class DCLMouseLine
+    def initialize(num=2)
+      raise("Number of points must be 2 or greater") if num<2
+      @p = Array.new
+      num.times{@p.push(DCLMousePt.new)}
+      @ux = @p.collect{|p| p.ux}
+      @uy = @p.collect{|p| p.uy}
+      @vx = @p.collect{|p| p.vx}
+      @vy = @p.collect{|p| p.vy}
+      @rx = @p.collect{|p| p.rx}
+      @ry = @p.collect{|p| p.ry}
+      @wx = @p.collect{|p| p.wx}
+      @wy = @p.collect{|p| p.wy}
+    end
+
+    attr_accessor :ux, :uy, :vx, :vy, :rx, :ry, :wx, :wy
+      
+    # Drawn in the V coordinate so that it will be a straight line
+    # on the display
+    def draw(type=1,index=1)
+      DCL.sgplzv(vx,vy,type,index)
+    end
+
+  end
+
+end
+