# File lib/numru/nusdas.rb, line 1163
    def get(*index)
      if @meta[:projection] == "RG  "
        parm = @meta[:subc]["RGAU"]
        raise("parameters RGAU in SUBC do not exist") unless parm
        nx = parm[:i_n].max
        ny = parm[:j_n]
      else
        nx, ny = @meta[:size]
      end
      np = @meta[:nplane]
      nt = @meta[:nvalidtime]
      ne = @meta[:nmember]
      nb = @meta[:nbasetime]
      case index.length
      when 0
        x = nx==1 ? [[(ix=0)], 1, true] : [(ix=true), nx, false]
        y = ny==1 ? [[(iy=0)], 1, true] : [(iy=true), ny, false]
        p = np==1 ? [[0], 1, true] : [0...np, np, false]
        t = nt==1 ? [[0], 1, true] : [0...nt, nt, false]
        e = ne==1 ? [[0], 1, true] : [0...ne, ne, false]
        b = nb==1 ? [[0], 1, true] : [0...nb, nb, false]
      when rank
        x = nx==1 ? [[(ix=0)], 1, true] : parse_index((ix=index.shift), nx, true)
        y = ny==1 ? [[(iy=0)], 1, true] : parse_index((iy=index.shift), ny, true)
        p = np==1 ? [[0], 1, true] : parse_index(index.shift, np)
        t = nt==1 ? [[0], 1, true] : parse_index(index.shift, nt)
        e = ne==1 ? [[0], 1, true] : parse_index(index.shift, ne)
        b = nb==1 ? [[0], 1, true] : parse_index(index.shift, nb)
      else
        raise "number of index is invalid"
      end

      if @meta[:projection] == "RG  "
        lon = dim("x")
        ind = NArray.int(nx,ny)
        if NArrayMiss === lon
          mask = lon.mask
          ind[mask] = NArray.int(mask.count_true).indgen
          mask = mask[ix,iy]
        else
          ind.indgen
          mask = nil
        end
        xorg = x
        yorg = y
        ind = ind[ix,iy]
        x = [ind[0], ind[-1]-ind[0]+1]
        y = [[0], 1]
        nx, ny = @meta[:size]
      end
      ary = NArray.byte(x[1], y[1], p[1], t[1], e[1], b[1])

      b[0].each_with_index{|l,ll|
        basetime = @meta[:basetimes][l]
        e[0].each_with_index{|m,mm|
          member = @meta[:members][m]
          t[0].each_with_index{|n,nn|
            validtime = @meta[:validtimes][n]
            p[0].each_with_index{|k,kk|
              plane = @meta[:planes][k]
              fn = @meta[:fnumber][k,n,m,l]
              if fn > @@fnumber_max
                ary = NArrayMiss.to_nam_no_dup(ary) unless NArrayMiss===ary
                ary.set_invalid(true,true,kk,nn,mm,ll)
                next
              end
              h = @meta[:files][fn]
              file = h[:file]
              kkk = h[:planes]==true ? k : h[:planes].index(k)
              nnn = h[:validtimes]==true ? n : h[:validtimes].to_a.index(n)
              mmm = h[:members]==true ? m : h[:members].index(m)
              pos = h[:record_pos][kkk,nnn,mmm]
              file.pos = pos
              name, mtime, str = get_record(file)
              data = parse_data(str)
              data[:validtime] = time_from_basetime(data[:validtime], basetime, @meta[:validtime_unit])
#              p( [member, validtime, plane, [nx,ny]], [data[:member], data[:validtime], data[:plane], data[:size]])
              unless [member, validtime, plane, [nx,ny]] == [data[:member], data[:validtime], data[:plane], data[:size]]
                raise "data is not consistent"
              end
              sub = unpack_data(data[:data], x[0], x[1], y[0], y[1], data[:packing], data[:missing], data[:size])
              ary = ary.to_type(sub.typecode) if sub.typecode > ary.typecode
              if NArrayMiss===sub && !(NArrayMiss===ary)
                ary = NArrayMiss.to_nam_no_dup(ary)
              end
              ary[true,true,kk,nn,mm,ll] = sub
            }
          }
        }
      }

      if @meta[:projection] == "RG  "
        shape = [ind[0], ind[1]] + ary.shape[2..-1]
        ary2 = ary.class.new(ary.typecode, *shape)
        if mask
          if NArray === ary
            mask2 = NArray.byte(*shape)
            mask2[true,true,true,true,true,true] = mask.reshape!(shape[0],shape[1],1,1,1,1)
            ary2[mask2] = ary
            ary = NArrayMiss.to_nam(ary2, mask2)
          else
            mask2 = ary2.get_mask!
            mask2[true,true,true,true,true,true] = mask.reshape!(shape[0],shape[1],1,1,1,1)
            ary2[mask2] = ary
            ary = ary2
          end
        end
        x = xorg
        y = yorg
      end


      shape = []
      shape.push x[1] unless x[2]
      shape.push y[1] unless y[2]
      shape.push p[1] unless p[2]
      shape.push t[1] unless t[2]
      shape.push e[1] unless e[2]
      shape.push b[1] unless b[2]
      ary.reshape!(*shape)

      return ary
    end