gfdnavi 1.3.0.0

data/lib/tasks/update.rake

@@ -0,0 +1,62 @@
+desc "Update all"
+task :update do
+  while true
+    print "Please select the following item\n"
+    print " 1: rebuild database tables.\n"
+    print " 2: update data tree.\n"
+    print " x: quit.\n"
+    print "select number: "
+    res = $stdin.gets.chomp!
+    unless ["1", "2", "x"].include?(res)
+      print "Not correct\n\n"
+      next
+    end
+    break
+  end
+  case res
+  when "1"
+    Rake::Task["update:tables"].invoke
+  when "2"
+    Rake::Task["update:tree"].invoke
+  when "x"
+    exit
+  end
+end
+
+namespace :update do
+  desc "Update database tables"
+  task :tables => :environment do
+    print "This will clear all the database tables and try to restore database.\n"
+    print "This might fail.\n"
+    print "Are you sure to continue? (no/yes, default:no) "
+    res = $stdin.gets.chomp!
+    unless res == "yes"
+      abort "execution was canceled"
+    end
+
+    command = 'ruby "' + File.join(File.expand_path(RAILS_ROOT), 'db', 'dump_db.rb') + '"'
+    unless system( command )
+      raise "failed to execute #{command}"
+    end
+
+    Rake::Task["setup:database"].invoke
+
+    command = 'ruby "' + File.join(File.expand_path(RAILS_ROOT), 'db', 'restore_db.rb') + '"'
+    unless system( command )
+      raise "failed to execute #{command}"
+    end
+    command = 'ruby "' + File.join(File.expand_path(RAILS_ROOT), 'db', 'register_directory_tree.rb') + '"'
+    unless system( command )
+      raise "failed to execute #{command}"
+    end
+  end
+
+  desc "Update tree of directories and variables"
+  task :tree => :environment do
+    command = 'ruby "' + File.join(File.expand_path(RAILS_ROOT), 'db', 'register_directory_tree.rb') + '" --verbose'
+    unless system( command )
+      raise "failed to execute #{command}"
+    end
+  end
+
+end

data/lib/vizshot_gfdnavi.rb

@@ -0,0 +1,224 @@
+require "numru/vizshot"
+
+module NumRu
+  class VizShot
+
+    def ==(other)
+      return false unless @set == other.instance_variable_get("@set")
+      self.instance_variable_get("@plots") == other.instance_variable_get("@plots")
+    end
+
+    def get_variables
+      unless @variables
+        @variables = Array.new
+        @plots.each{|pl|
+          pl[:variables].each{|path|
+            var =  var_from_path(path)
+            if var
+              @variables.push var unless @variables.include?(var)
+            else
+              raise "[BUG] variable is invalid (#{path})"
+            end
+          }
+        }
+      end
+      return @variables
+    end
+
+    def to_yaml_properties
+      props = instance_variables.sort
+      props.delete("@variables")
+      return props
+    end
+    
+    def get_plots(num=nil)
+      if num
+        @plots[num].dup
+      else
+        @plots.collect{|pl| pl.dup}
+      end
+    end
+
+    def get_size
+      [ @set[:admin][:iwidth], @set[:admin][:iheight] ]
+    end
+
+    def get_itr
+      @set[:fig]['itr']
+    end
+
+    def get_viewport
+      @set[:fig]['viewport'].join(',')
+    end
+
+    # redefined
+    alias :_gen_code :gen_code
+    def gen_code(all_in_one=false, exec_opt=nil)
+      if exec_opt
+        case exec_opt.delete(:for)
+        when :in
+          flag = true
+        when :out
+          flag = false
+          basename = exec_opt.delete(:basename)
+        else
+          raise "BUG"
+        end
+        exec_opts = nil if exec_opt.empty?
+      else
+        raise "BUG"
+      end
+      plots_org = @plots
+      i = 0
+      @plots = @plots.collect do |plot|
+        plot = plot.dup
+        vars = plot.delete(:variables)
+        if flag
+          v =  var_from_path(vars[0])
+          plot[:file] = v.fname
+          plot[:var] = v.vname
+          if vars[1]
+            v =  var_from_path(vars[1])
+            plot[:file2] = v.fname
+            plot[:var2] = v.vname
+          end
+        else
+          plot[:file] = basename + sprintf("_%03d",i) + '.nc'
+          plot[:var] = File.basename(vars[0])
+          if vars[1]
+            plot[:file2] = basename + sprintf("_%03d_2",i) + '.nc'
+            plot[:var2] = File.basename(vars[1])
+          end
+        end
+        plot
+      end
+      code = _gen_code(all_in_one, exec_opt)
+      @plots = plots_org
+      return code
+    end
+
+    # redefined
+    def cut_out_data(basename)
+      newplots = Array.new
+      data_paths = Array.new
+      @plots.each_with_index{|pl, i|
+        gphys, gphys2 = get_gphyses(pl.dup)
+        method = pl[:method]
+        script = pl.delete(:script)
+        cut = pl.delete(:cut)
+        slice = pl.delete(:slice)
+        ndims = self.class.ndims(method)
+        filename = basename + sprintf("_%03d",i) + '.nc'
+        data_paths.push _output_data(gphys,filename,ndims)
+        pl = pl.dup
+        pl[:file] = filename
+        pl[:var] = gphys.name
+        if gphys2
+          cut2 = pl.delete(:cut2) || cut
+          slice2 = pl.delete(:slice2) || slice
+          filename = basename + sprintf("_%03d_2",i) + '.nc'
+          data_paths.push _output_data(gphys2,filename,ndims)
+          pl = pl.dup
+          pl[:file2] = filename
+          pl[:var2] = gphys.name
+        end
+      }
+      return data_paths
+    end
+
+    protected
+
+    # redefined
+    def get_gphyses(arg)
+      vars = arg.delete(:variables)
+      unless Array === vars
+        raise "variables is valid"
+      end
+      gphyses = Array.new
+      slice = [arg.delete(:slice)]
+      slice[1] = arg.delete(:slice2) || slice[0]
+      cut = [arg.delete(:cut)]
+      cut[1] = arg.delete(:cut2) || cut[0]
+      vars.each_with_index{|path,i|
+        v = var_from_path(path)
+        if v
+          gphys = v.gphys
+          if i==0 || i==1
+            gphys = gphys[*(slice[i])] if slice[i]
+            case cut[i]
+            when Hash
+	      c = cut[i].dup
+	      (c.keys - gphys.axnames).each{|k| c.delete(k)}
+              gphys = gphys.cut(c)
+            when Array
+              gphys = gphys.cut(*(cut[i]))
+            end
+          end
+          gphyses.push gphys
+        else
+          raise "variable is invalid (#{path})"
+        end
+      }
+      if src = arg.delete(:script)
+        safe = $SAFE
+        lambda {
+          $SAFE = 3
+          eval src
+        }.call
+        $SAFE = safe
+      end
+      raise "wrong number of gphyses" if gphyses.length > 2
+      return gphyses
+    end
+
+    def _output_data(gphys,filename,ndims)
+      path = @@dumpdir + filename
+      case ndims
+      when 1
+        gphys = gphys.first1D
+      when 2
+        gphys = gphys.first2D
+      when 3
+        gphys = gphys.first3D
+      else
+        raise "Ploting more-than-3D data is not supported"
+      end
+      file = NetCDF.create(path)
+      GPhys::IO.write(file,gphys)
+      file.close
+      return path
+    end
+
+    def var_from_path(path)
+      if /\A(temporary\:.+)\/([^\/]+)\z/ =~ path
+        fname = $1
+        vname = $2
+        v = Variable.new
+        v.file = fname
+        v.path = File.join(fname,vname)
+      else
+        v = Variable.find(:first,:conditions=>["path=?",path],:user=>:all)
+      end
+      return v
+    end
+
+  end
+end
+
+
+#.*ENDOFLIB
+
+if ActiveRecord::Base.connection.tables.include?("nodes")
+  DrawMethod.find(:all, :user=>:all).each{|dm|
+    if dm.name && dm.script && dm.script!="NULL"
+      hash = {
+        :name => dm.name,
+        :ndims => dm.ndims,
+        :nvars => dm.nvars,
+        :script => dm.script
+      }
+      hash[:ggraph] = dm.ggraph if dm.ggraph && dm.ggraph!="NULL"
+      NumRu::VizShot.add_extensions(hash)
+    end
+  }
+end

data/public/crossdomain.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<cross-domain-policy>
+  <allow-access-from domain="*"/>
+</cross-domain-policy>

data/public/flex/NodeTreeDescriptor.as

@@ -0,0 +1,55 @@
+package
+{
+  import mx.controls.treeClasses.DefaultDataDescriptor;
+  import mx.collections.ICollectionView;
+  import mx.collections.ArrayCollection;
+  import mx.controls.Alert;
+  import mx.rpc.AsyncResponder;
+  import mx.rpc.AsyncToken;
+  import mx.rpc.http.mxml.HTTPService;
+
+
+  public class NodeTreeDescriptor extends DefaultDataDescriptor
+  {
+    public function NodeTreeDescriptor():void
+    {
+      super();
+    }
+
+    public function toString():String { return "[Object NodeTreeDescriptor]"};
+
+    public override function getChildren(node:Object, model:Object=null):ICollectionView {
+      if (node.directories) {
+         return node.directories;
+      } else {
+         return node.children;
+      }
+    }
+
+    public override function isBranch(node:Object, model:Object=null):Boolean {
+       if (node.numDirs > 0) {
+          return true;
+       } else {
+          return false;
+       }
+
+    }
+
+    public override function hasChildren(node:Object, model:Object=null):Boolean {
+       var children:ArrayCollection;
+
+       if (node.directories) {
+          children = node.directories;
+       } else {
+          children = node.children;
+       }
+       if (children.length > 0) {
+          return true;
+       } else {
+          return false
+       }
+    }
+
+  }
+}
+

data/public/flex/TreeNode.as

@@ -0,0 +1,253 @@
+package {
+
+  import mx.controls.treeClasses.DefaultDataDescriptor;
+  import mx.collections.ICollectionView;
+  import mx.collections.ArrayCollection;
+  import mx.controls.Alert;
+  import mx.rpc.AsyncResponder;
+  import mx.rpc.AsyncToken;
+  import mx.rpc.http.mxml.HTTPService;
+  import mx.controls.Tree;
+  import flash.events.Event;
+  import mx.events.CollectionEvent;
+  import mx.events.PropertyChangeEvent;
+
+  public class TreeNode {
+
+      public function TreeNode(host:String):void {
+	  super();
+          this.host = host;
+      }
+
+      [Embed(source='../images/tree/folder.png')]
+      [Bindable]
+      public var closedFolderIcon:Class;
+
+      [Embed(source='../images/tree/binary.png')]
+      [Bindable]
+      public var binaryIcon:Class;
+
+      [Embed(source='../images/tree/image2.png')]
+      [Bindable]
+      public var imageIcon:Class;
+
+      [Embed(source='../images/tree/knowledge_icon.png')]
+      [Bindable]
+      public var knowledgeIcon:Class;
+
+      [Embed(source='../images/tree/anal_viz.png')]
+      [Bindable]
+      public var analysisIcon:Class;
+
+      [Embed(source='../images/tree/show.png')]
+      [Bindable]
+      public var showIcon:Class;
+
+
+      public static var hs:HTTPService;
+      public static var tree:Tree;
+      public static var changeHandler:Function;
+
+
+      public var host:String;
+      public var has_variable:Boolean;
+      public var has_image:Boolean;
+
+      public var has_children:Boolean;
+      private var childrenUri:String;
+
+      private var _chld:ArrayCollection;
+      private var _dirs:ArrayCollection;
+      private var _vars:ArrayCollection;
+      private var _imgs:ArrayCollection;
+
+      private var _kas:ArrayCollection;
+
+      public var name:String;
+      public var path:String;
+      public var size:int;
+      public var node_type:String;
+      public var mtime:String;
+      public var title:String;
+      public var description:String;
+      public var parent:Object;
+      public var numDirs:int;
+      public var imgSrc:String;
+
+      public var dlUri:String;
+
+
+      public function toString():String { return "[Object TreeNode]"};
+
+      public function get directories():ArrayCollection {
+	  getChildren();
+	  return _dirs;
+      }
+      public function set directories(dirs:ArrayCollection):void {
+	  _dirs = dirs;
+      }
+      public function get variables():ArrayCollection {
+	  getChildren();
+	  return _vars;
+      }
+      public function set variables(vars:ArrayCollection):void {
+	  _vars = vars;
+      }
+      public function get images():ArrayCollection {
+	  getChildren();
+	  return _imgs;
+      }
+      public function set images(imgs:ArrayCollection):void {
+	  _imgs = imgs;
+      }
+      public function get children():ArrayCollection {
+	  getChildren();
+	  return _chld;
+      }
+      public function set children(chld:ArrayCollection):void {
+	  _chld = chld;
+      }
+
+      public function get keywordAttributes():ArrayCollection {
+	  var ary:ArrayCollection;
+          if (!_kas) {
+	      _kas = (ary = new ArrayCollection());
+	      hs.url = host + "/data" + this.path + "/keyword_attributes.xml";
+	      hs.method = "GET";
+	      var call:AsyncToken = hs.send();
+
+	      call.addResponder(new AsyncResponder(
+                function (result:Object, token:Object = null):void {
+                   trace(result.toString(), "succeded to get Node Keyword Attributes");
+                   var obj:Object;
+	           var kas:Object;
+	           if ( result.result.hasOwnProperty("keyword-attributes") ) {
+                     kas = result.result["keyword-attributes"];
+		     if (kas) {
+			 kas = kas["keyword-attribute"];
+			 if (!kas.length) kas = new Array(kas);
+			 var ka:Object;
+			 for (var i:int=0; i < kas.length; i++) {
+			     ka = kas[i];
+			     obj = new Object();
+			     obj.name = ka.name;
+			     obj.value = ka.value;
+			     obj.lang = ka.lang;
+			     ary.addItem(obj);
+			 }
+		     }
+		   }
+		},
+		function (error:Object, token:Object = null):void {
+                    trace(error.toString());
+                    Alert.show("failed to get Node Keyword Attributes","Error");
+		},
+		call
+            ));
+	  }
+	  return _kas;
+      }
+
+      private function getChildren():void {
+	  if (!this.has_children) {
+	      this.has_children = true;
+	      getNodes(this.childrenUri, this);
+	  }
+      }
+
+      public function getNodeTypeIcon():Class {
+	  if (this.node_type == "directory") {
+	      return closedFolderIcon;
+	  } else if (this.node_type == "variable") {
+	      return binaryIcon;
+	  } else if (this.node_type == "image") {
+	      return imageIcon;
+	  } else if (this.node_type == "knowledge") {
+	      return knowledgeIcon;
+	  }
+	  return closedFolderIcon;
+      }
+
+      public function getNodeActionIcon():Class {
+	  if (this.node_type == "directory") {
+	    if (this.variables.length > 0 )
+	          return analysisIcon;
+	  } else if (this.node_type == "variable") {
+	      return analysisIcon;
+	  } else if (this.node_type == "image") {
+	      return showIcon;
+	  }
+          return null;
+      }
+
+      public static function getNodes(uri:String, parent:Object):ArrayCollection {
+	  var dis:ArrayCollection;
+	  var vas:ArrayCollection;
+	  var ims:ArrayCollection;
+	  var chd:ArrayCollection;
+	  var host:String = parent.host;
+
+	  dis = new ArrayCollection();
+	  if (parent is TreeNode) {
+	      chd = new ArrayCollection();
+              vas = new ArrayCollection();
+              ims = new ArrayCollection();
+	      parent.directories = dis;
+	      parent.variables = vas;
+	      parent.images = ims;
+	      parent.children = chd;
+	  }
+
+	  hs.url = uri + "?num_dirs=true";
+	  hs.method = "GET";
+	  var call:AsyncToken = hs.send();
+
+	  call.addResponder(new AsyncResponder(
+              function (result:Object, token:Object = null):void {
+                 trace(result.toString(), "succeded to get Nodes");
+                 var obj:TreeNode;
+		 var nodes:Object = result.result.nodes.node;
+		 if (!nodes.length)  nodes = new Array(nodes);
+		 var node:Object;
+		 for (var i:int=0; i < nodes.length; i++) {
+		     node = nodes[i];
+		     obj = new TreeNode(host);
+		     obj.name = node.name;
+		     obj.numDirs = node.num_dirs;
+		     obj.path = node.path;
+		     obj.size = node.size;
+		     obj.node_type = node.node_type;
+		     obj.mtime = node.mtime;
+                     obj.childrenUri = node.children.uri;
+		     if (node.title is String) if (node.title!="NULL") obj.title = node.title;
+		     if (node.description is String ) if (node.description!="NULL") obj.description = node.description;
+                     obj.imgSrc = node.img_src;
+                     obj.dlUri = node.dl_uri;
+		     if (parent is TreeNode) obj.parent = parent;
+		     if (node.node_type == "directory") {
+		       dis.addItem(obj);
+      		     } else if (node.node_type == "variable") {
+                       if (vas) vas.addItem(obj);
+		     } else if (node.node_type == "image") {
+                       if (ims) ims.addItem(obj);
+                     }
+		     if (chd) chd.addItem(obj);
+		 }
+
+		 changeHandler(parent);
+
+	      },
+	      function (error:Object, token:Object = null):void {
+                  Alert.show("faild to list Nodes","error");
+                  trace(error.toString());
+		  parent.has_children = false;
+	      },
+	      call
+          ));
+	  return dis;
+      }
+
+
+  }
+}
+