gphys 1.1.1a

data/lib/numru/gphys/coordmapping.rb

@@ -0,0 +1,286 @@
+require "narray"
+
+=begin
+= class CoordMapping
+
+== Overview
+Mapping of a coordinate to another. It supports analytic and 
+grid-point-based mapping in subclasses. Here in this root
+CoordMapping class only the invariant unity mapping (or no mapping)
+is defined.
+
+== Class methods
+---CoordMapping.new
+     Constructor. One or more arguments can be needed in subclasses
+
+== Methods
+---map(x,y,z,...)
+     Maps data point(s)
+
+     ARGUMENTS
+     * x,y,z,... (one or more Numeric or NArray) : data points. 
+       Mapping is made of [x,y,z,..] (if Numeric) or 
+       [x[0],y[0],z[0],..], [x[1],y[1],z[1],..], ..(if NArray).
+       Thus, the number of arguments must be equal to the rank of 
+       the mapping. Also, their lengths must agree with each other.
+
+     RETURN VALUE
+     * Array of p,q,r,... (Numeric or NArray) : mapping result
+
+---map_grid(x,y,z,...)
+     Same as ((<map>)) but for a regular grid.
+     
+     ARGUMENTS
+     * x,y,z,... (one or more 1D NArray) : coordinate values of
+       a regular grid [x_i, y_j, z_k,..].  The shape of the grid is thus 
+       [x.length, y.length, z.length,..]. This method needs no redefinition,
+       since it calls ((<map>)) inside.
+
+---inverse_map(p,q,r,...)
+     Inversely maps data point(s).
+
+     ARGUMENTS
+     * p,q,r,... (one or more Numeric or NArray) : data points. 
+       Inverse mapping is made of [p,q,r,..] (if Numeric) or 
+       [p[0],q[0],r[0],..], [p[1],q[1],r[1],..], ..(if NArray).
+       Thus, the number of arguments must be equal to the rank of 
+       the mapping. Also, if NArray, their lengths must agree with each other.
+
+     RETURN VALUE
+     * Array of x,y,z,... (Numeric or NArray) : inverse mapping result
+
+---inverse
+     Returns the inverse mapping.
+
+     RETURN VALUE
+     * a CoordMapping
+
+---inversion_rigorous?
+     Whether the inversion is rigorous (analytical)
+
+     RETURN VALUE
+     * true or false
+
+= class LinearCoordMapping < CoordMapping
+
+== Overview
+Linear coordinate mapping expressed as offset + factor*x,
+where offset is a vector (NVect) and factor is a matrix (NMatrix).
+
+Methods listed below are only those newly defined or those whose 
+arguments are changed.
+
+== Class methods
+---LinearCoordMapping.new(offset=nil, factor=nil)
+     Constructor. If one of offset and factor is not 
+     specified (nil), a zero vector / a unit matrix is used (at least 
+     one of them must be given).
+
+     ARGUMENTS
+     * offset (NVector or nil) : the offset. Its length represents the rank
+       of mapping. (if nil a zero vector is assumed)
+     * factor (NMatrix or nil) : the factor. For consistency, 
+       ( offset.length == factor.shape[0] == factor.shape[1] ) is required.
+
+== Methods
+---offset
+     Returns the internally stored offset.
+
+---factor
+     Returns the internally stored factor.
+
+=end
+
+module NumRu
+
+   class CoordMapping
+      def initialize
+	 @rank = nil   # nil means any (set a positive integer to specify)
+         @inversion_rigorous = true
+      end
+
+      attr_reader :rank
+
+      def inversion_rigorous?
+	 @inversion_rigorous
+      end
+
+      def map(*args)
+	 __check_args_m(*args)
+	 args.collect{|v| v.dup}
+      end
+      def inverse_map
+	 __check_args_m(*args)
+	 args.collect{|v| v.dup}
+      end
+
+      def map_grid(*args)
+	 args.each{|v| raise ArgumentError,"all args must be 1D" if v.rank!=1}
+	 shape = args.collect{|v| v.length}
+	 rank = shape.length
+	 expanded=Array.new
+	 (0...args.length).each{|i|
+	    to_insert = (0...i).collect{|j| 0} + ((i+1)...rank).collect{|j| 1}
+	    x = args[i]
+	    if to_insert.length > 0
+	       x = x.newdim(*to_insert) 
+	       x += NArray.float(*shape)
+	    end
+	    expanded.push(x)
+	 }
+	 map(*expanded)
+      end
+
+      def inverse
+	 self.clone
+      end
+
+      private
+      def __check_args_m(*args)
+	 if @rank
+	    if args.length != @rank
+	       raise ArgementError,
+		  "# of the arguments must agree with the rank #{@rank}"
+	    end
+	 else
+	    if args.length == 0
+	       raise ArgementError,"# of the arguments must be 1 or greater"
+	    end
+	 end
+	 if args[0].is_a?(Numeric)
+	    for i in 1...args.length
+	       if !args[i].is_a?(Numeric)
+		  raise ArgumentError,
+		     "If the first arg is a numeric, the remaing must be so."
+	       end
+	    end
+	 else
+	    for i in 1...args.length
+	       if args[i-1].length != args[i].length
+		  raise ArgumentError,"lengths of the args must be the same"
+	       end
+	    end
+	 end
+      end
+   end
+
+   ############################
+
+   class LinearCoordMapping < CoordMapping
+
+      def initialize(offset=nil, factor=nil)
+
+	 #< argument check & set rank, offset, factor >
+
+	 if !offset && !factor
+	    raise ArgumentError,"One of offset and factor must be specified"
+	 elsif !factor
+	    raise ArgumentError,"offset is not a NVector" if !offset.is_a?(NVector)
+	    @rank = offset.length
+	    @factor = NMatrix.float(@rank,@rank)
+	    @factor.diagonal!(1)
+	 else
+	    raise ArgumentError,"factor is not a NMAtrix" if !factor.is_a?(NMatrix)
+	    nx,ny = factor.shape
+	    raise ArgumentError,"factor must be a square matrix" if nx != ny
+	    @rank = nx
+	    if offset
+	       raise ArgumentError,"offset is not a NVector" if !offset.is_a?(NVector)
+	       if offset.length != @rank
+		  raise ArgumentError,"inconsistent dimensionarity between "+
+		     "offset #{offset.length} and factor #{factor.shape}"
+	       end
+	       @offset = offset
+	    else
+	       @offset = NVector.float(@rank)
+	    end
+	    @factor = factor
+	 end
+
+	 #< other parameters >
+
+	 @inversion_rigorous = true
+	 @inv_factor = nil   # deferred until needed (might not be invertible)
+
+      end
+
+      attr_reader :factor, :offset
+
+      def map(*args)
+	 __check_args_m(*args)
+	 x = __to_NVector(*args)
+	 p = @offset + @factor*x
+	 (0...@rank).collect{|i| p[i,false]}
+      end
+
+      def inverse_map(*args)
+	 __check_args_m(*args)
+	 p = __to_NVector(*args)
+	 __set_inv_factor if !@inv_factor
+	 x = @inv_factor * ( p - @offset )
+	 (0...@rank).collect{|i| x[i,false]}
+      end
+
+      def inverse
+	 __set_inv_factor if !@inv_factor
+	 LinearCoordMapping.new( -@inv_factor*@offset, @inv_factor )
+	 # Here, LinearCoordMapping.new is better than class.new,
+         # since the constructor may change in subclasses.
+      end
+
+      private 
+      def __to_NVector(*args)
+	 if args[0].is_a?(Numeric)
+	    NVector[*args]
+	 else
+	    v = NVector.float(@rank,*args[0].shape)
+	    for i in 0...@rank
+	       v[i,false] = args[i]
+	    end
+	    v
+	 end
+      end
+
+      def __set_inv_factor
+	 begin
+	    @inv_factor = @factor.inverse
+	 rescue
+	    raise $!,"mapping factor (which is a Matrix) is not invertible"
+	 end
+      end
+
+   end
+
+end
+
+################################################################
+if $0 == __FILE__
+   include NumRu
+
+   puts "\n** The default unity mapping class CoordMapping **\n\n"
+
+   mp = CoordMapping.new
+   x = y = z = NArray.float(10).indgen!
+   p,q,r = mp.map(x,y,z)
+   p p,q,r
+
+   puts "\n** LinearCoordMapping **\n\n"
+   include Math
+
+   offset = NVector[ 100.0, 0.0, 100.0 ]
+   theta = PI/6
+   factor = NMatrix[ [cos(theta), -sin(theta), 0],
+                     [sin(theta), cos(theta) , 0],
+                     [0         , 0          , 1] ]
+   mp = LinearCoordMapping.new(offset, factor)
+   y = z = NArray.float(10)
+   p,q,r = mp.map(x,y,z)
+   puts "<<forward>>"
+   p p,q,r
+   puts "<<inverse>>"
+   p *mp.inverse_map(p,q,r)
+   puts "<<map grid>>"
+   x = y = NArray[0.0, 1.0]
+   z = NArray[0.0,1.0,2.0]
+   p *mp.map_grid(x,y,z)
+end

data/lib/numru/gphys/coordtransform.rb

@@ -0,0 +1,209 @@
+require "numru/gphys/coordmapping"
+require "numru/gphys/gphys"
+begin
+  require "numru/ssl2"
+  HAVE_NUMRU_SSL2 = true
+rescue LoadError
+  HAVE_NUMRU_SSL2 = false
+end
+
+=begin
+=class NumRu::GPhys
+
+Additional methods regarding coordinate transformation.
+
+== Methods
+
+---coordtransform( coordmapping, axes_to, *dims )
+
+     Coordinate transformation with ((|coordmapping|)) into ((|axes_to|)).
+
+     ARGUMENTS
+     * ((|coordmapping|)) (CoordMapping) : relation between the new and
+       original coordinate systems. Mapping is defined from the new one to
+       the orinal one. If the rank of the mapping is smaller than 
+       the rank of self, ((|dims|)) must be used to specify the
+       correspondence. e.g., if the rank of the mapping is 2 and that 
+       of self is 3 and the mapping is regarding the first 2 dimensions
+       of the three, ((|dims|)) must be [0,1].
+     * ((|axes_to|)) (Array of Axis) : grid in the new coordinate system.
+       Its length must be the same as the rank of ((|coordmapping|))
+     * ((|dims|)) (integers) : Specifies the dimensions to which 
+       ((|coordmapping|)) is applied. Needed if 
+       (({self.rank!=coordmapping.rank})) (neglected otherwise). 
+       The number of integers must agree with the rank of the mapping.
+
+=end
+
+module NumRu
+  class GPhys
+
+    def coordtransform( coordmapping, axes_to, *dims )
+
+      rankmp = coordmapping.rank
+
+      #< check arguments >
+      if axes_to.length != rankmp
+        raise ArgumentError,
+          "length of axes_to must be equal to the rank of coordmapping"
+      end
+      if self.rank == rankmp
+        dims = (0...rankmp).collect{|i| i}
+      elsif self.rank < rankmp
+        raise ArgumentError,"rank of coordmapping is greater than self.rank"
+      elsif dims.length != rankmp
+        raise ArguemntError,
+          "# of dimensions speficied is not equal to the rank of coordmapping"
+      elsif dims != dims.sort
+        raise ArguementErroor,"dims must be in the increasing order"
+      end
+
+      #< get grid points >
+      vt = coordmapping.map_grid( *dims.collect{|d| axes_to[d].pos.val} )
+      x = dims.collect{|d| self.grid.axis(d).pos.val}
+      #< prepare the output object >
+      axes = (0...self.rank).collect{|i| grid.axis(i)}
+      dims.each_with_index{|d,j| axes[d]=axes_to[j]}
+      grid_to = Grid.new( *axes )
+      vnew = VArray.new( NArray.new( self.data.ntype, *grid_to.shape ),
+                        self.data, self.name )
+
+      #< do interpolation (so far only 2D is supported) >
+      case dims.length
+      when 2
+        if !HAVE_NUMRU_SSL2
+
+          p "interpolation without SSL2"
+#         raise "Sorry, so far I need SSL2 (ruby-ssl2)"
+          self.each_subary_at_dims_with_index( *dims ){ |fxy,idx|
+
+            wgts = Array.new
+            idxs = Array.new
+
+            for d in 0..dims.length-1
+              wgt = vt[d].dup.fill!(-1.0)
+              idx0 = vt[d].dup.to_i.fill!(-1)
+              idx1 = idx0.dup.fill!(x[d].length)
+
+              xsort = x[d].sort
+              xsortindex = x[d].sort_index
+              for i in 0..x[d].length-1
+                idx0[ xsort[i] <= vt[d] ] = xsortindex[i]
+                idx1[ xsort[-1-i] >= vt[d] ] = xsortindex[-1-i]
+              end
+
+              # where idx0=idx1
+              wgt[ idx0.eq(idx1) ] = 1.0
+
+              # where vt[d] < x[d].min
+              wgt[ idx0 <= -1 ] = 1.0
+              idx0[ idx0 <= -1 ] = 0
+
+              # where vt[d] > x[d].max
+              wgt[ idx1 >= x[d].length ] = 0.0
+              idx1[ idx1 >= x[d].length ] = x[d].length-1
+
+              # normal points
+              mask = wgt.eq(-1.0)
+              wgt[mask] = (vt[d][mask]-x[d][idx0[mask]])/(x[d][idx1[mask]]-x[d][idx0[mask]])
+
+              wgts.push(wgt)
+              idxs[d*2] = idx0
+              idxs[d*2+1] = idx1
+
+            end
+
+            case dims.length
+#            when 1
+#              f =   fxy.data.val[idxs[0]]*(1-wgts[0]) + 
+#                    fxy.data.val[idxs[1]]*wgts[0]
+#              f = f.to_na if( f.class.to_s == "NArrayMiss" )
+            when 2
+              lx = fxy.shape[0]
+              f =   ( fxy.data.val[idxs[0]+idxs[2]*lx]*(1-wgts[0]) + 
+                      fxy.data.val[idxs[1]+idxs[2]*lx]*wgts[0]
+                    ) * (1-wgts[1]) + 
+                    ( fxy.data.val[idxs[0]+idxs[3]*lx]*(1-wgts[0]) + 
+                      fxy.data.val[idxs[1]+idxs[3]*lx]*wgts[0] 
+                    ) * wgts[1]
+              f = f.to_na if( f.class.to_s == "NArrayMiss" )
+            else
+              raise "Sorry, #{v.length}D interpolation is yet to be supported"
+            end
+
+            if(idx==false)
+              vnew[] = f
+            else
+              vnew[*idx] = f
+            end
+          }
+
+        else
+          ix=iy=0
+          m=3
+          self.each_subary_at_dims_with_index( *dims ){ |fxy,idx|
+            c,xt = SSL2.bicd3(x[0],x[1],fxy.val,m)
+            begin
+              ix,iy,f = SSL2.bifd3(x[0],x[1],m,c,xt,0,vt[0],ix,0,vt[1],iy)
+            rescue
+              $stderr.print "Interpolation into", vt[0].inspect, vt[1].inspect
+              raise $!
+            end
+            vnew[*idx] = f
+          }
+        end
+      else
+        raise "Sorry, #{v.length}D interpolation is yet to be supported"
+      end
+
+      #< finish >
+      GPhys.new( grid_to, vnew )
+    end
+
+  end
+end
+
+########################################
+
+if __FILE__ == $0
+  include NumRu
+  include NMath
+
+  #< make a GPhys >
+
+  puts "** preparation **"
+
+  nx=ny=10
+  nz=3
+  xv = VArray.new( xx=NArray.sfloat(nx).indgen!.mul!(4*PI/(nx-1)) ).rename("x")
+  yv = VArray.new( yy=NArray.sfloat(ny).indgen!.mul!(4*PI/(ny-1)) ).rename("y")
+  zv = VArray.new( NArray.sfloat(nz).indgen! ).rename("z")
+  xax = Axis.new.set_pos(xv)
+  yax = Axis.new.set_pos(yv)
+  zax = Axis.new.set_pos(zv)
+  grid = Grid.new(xax,yax,zax)
+  fxy = sin(yy).newdim(0,1) + NArray.sfloat(nx).newdim(1,1) +
+                              NArray.sfloat(nz).indgen!.newdim(0,0)
+  p fxy.shape, fxy
+  z = VArray.new( fxy )
+  gp = GPhys.new( grid, z )
+
+
+  #< make the new coordinate  >
+
+  puts "** transformation **"
+
+  theta = PI/6
+  factor = NMatrix[ [cos(theta), -sin(theta)],
+                    [sin(theta), cos(theta) ] ]
+  offset = NVector[ 0.0, 0.0 ]
+  coordmapping = LinearCoordMapping.new(offset, factor)
+
+  axes_to = [ Axis.new.set_pos( xv[0..(nx/2)] + 1.5*PI ), 
+              Axis.new.set_pos( yv[0..(ny/2)] ) ]
+
+  gprot = gp.coordtransform( coordmapping, axes_to, 0, 1 )
+  p gprot.val
+
+end
+