nera 0.0.1

data/lib/nera/nera_job_layer_controller.rb

@@ -0,0 +1,237 @@
+require 'date'
+require 'fileutils'
+require 'yaml'
+require 'nera_db_folders'
+require 'nera_simulator_records'
+require 'nera_parameter_records'
+require 'nera_run_records'
+require 'nera_job_records'
+require 'nera_job_script'
+
+module NERA
+
+  class JobLayerController
+
+    # instance of NERA::DbFolders
+    @db_folders
+    # instance of NERA::JobRecords
+    @job_records
+    
+    def initialize( path_db_folder)
+      raise ArgumentError unless path_db_folder.is_a?(String)
+      
+      @db_folders = NERA::DbFolders.new( path_db_folder)
+      @job_records = NERA::JobRecords.new( @db_folders.path_to_jobs_table)
+    end
+
+    public
+    def path_to_job_layer
+      return @db_folders.path_to_job_layer
+    end
+
+    def not_finished_list_in_csv
+      list = @job_records.list_all
+      header = @job_records.keys.dup
+      header_ab = "id, state, simulator, param_id, run_id, num_runs, created_at, updated_at, host_name"
+
+      csv_list = []
+      list.each do |r_hash|
+        strings = []
+        header.each do |key|
+          if r_hash[key].is_a?(DateTime)
+            strings << r_hash[key].to_s.split('T')[0]
+          else
+            strings << r_hash[key].to_s
+          end
+        end
+        csv_list << strings.join(", ")
+      end
+      return header_ab, csv_list
+    end
+
+    def cancel_jobs( job_ids)
+      unless job_ids.is_a?(Array)
+        raise ArgumentError, "job_ids must be an Array."
+      end
+      job_ids.each do |x|
+        raise ArgumentError, "each element of job_ids must be an Integer" unless x.is_a?(Integer)
+      end
+
+      flag = nil
+      @job_records.transaction {
+        job_ids.each do |jid|
+          d = @job_records.destroy( jid)
+          next unless d
+          sim_recs = NERA::SimulatorRecords.new( @db_folders.path_to_simulators_table)
+          klass = eval( d[:simulator])
+          raise RuntimeError, "must not happen" unless klass
+          run_records = NERA::RunRecords.new( @db_folders.path_to_runs_table( klass, d[:parameter_id]) )
+          run_records.transaction {
+            a = run_records.destroy_job_id( jid)
+            raise RuntimeError, "must not happen" unless a
+            FileUtils.rm( @db_folders.path_to_job_script(jid) )
+          }
+          File.open( @db_folders.path_to_runs_yaml( klass, d[:parameter_id]), 'w') do |io|
+            YAML.dump( run_records.list_all, io)
+            io.flush
+          end
+          flag = true
+        end
+      }
+      dump_in_yaml
+      return flag
+    end
+
+    def include_list
+      list = @db_folders.search_include_files
+      list.map! do |path|
+        path.sub( @db_folders.path_to_include_layer, '')
+      end
+      return list
+    end
+
+    def include( filename)
+      @job_records.transaction {
+        fpath = @db_folders.path_to_include_layer + filename
+        return nil unless File.exist?(fpath)
+        jinfo, rinfo = expand_and_parse( fpath)
+        run_layer_path, run_recs, run_yaml_path = check_consistency( jinfo, rinfo)
+        run_recs.transaction {
+          folder_path = fpath.sub(/.tar.bz2$/,'/')
+          file_move( folder_path, run_layer_path, jinfo[:run_ids])
+          update_tables( run_recs, jinfo, rinfo)
+        }
+        remove_files( fpath)
+        File.open( run_yaml_path, 'w') do |io|
+          YAML.dump( run_recs.list_all, io)
+          io.flush
+        end
+      }
+      dump_in_yaml
+      return true
+    end
+
+    private
+    def expand_and_parse( fpath)
+      bz2_path = fpath.sub( /^#{@db_folders.path_to_include_layer}/, '')
+      Dir.chdir( @db_folders.path_to_include_layer) {
+        cmd = "bunzip2 #{bz2_path}"
+        system(cmd)
+        raise "command : #{cmd} failed" unless $? == 0
+        tarpath = bz2_path.sub(/.bz2$/,'')
+        cmd = "tar xvf #{tarpath}"
+        system(cmd)
+        raise "command : #{cmd} failed" unless $? == 0
+        stat_path = tarpath.sub(/.tar$/,'/nera_status.rb')
+        js = NERA::JobScript.new(@db_folders)
+        jinfo, rinfo = js.parse_status( stat_path)
+        return jinfo, rinfo
+      }
+    end
+    
+    private
+    def check_consistency( jinfo, rinfo)
+      # record exists?
+      found = @job_records.find_by_id( jinfo[:job_id] )
+      return nil unless found
+
+      # check consistency of the simulator
+      conflicting unless jinfo[:simulator] == found[:simulator]
+      sim_records = NERA::SimulatorRecords.new( @db_folders.path_to_simulators_table)
+      sim_class = eval( jinfo[:simulator])
+      conflicting unless jinfo[:simulator] == sim_class.to_s
+      
+      # check consistency of the parameter
+      conflicting unless jinfo[:param_id] == found[:parameter_id]
+      param_records = NERA::ParameterRecords.new( @db_folders.path_to_parameters_table( sim_class) , sim_class)
+      param = param_records.find_by_id( jinfo[:param_id])
+      jinfo[:parameters].each_pair do |key, value|
+        conflicting unless param[key] == value
+      end
+      
+      # check consistency of the runs
+      conflicting unless jinfo[:run_ids][0] == found[:run_id]
+      conflicting unless jinfo[:run_ids].size == found[:number_of_runs]
+      run_recs = NERA::RunRecords.new( @db_folders.path_to_runs_table( sim_class, jinfo[:param_id]) )
+      run_yaml_path = @db_folders.path_to_runs_yaml( sim_class, jinfo[:param_id])
+      found_runs = run_recs.list_all_not_finished.find_all do |rec|
+        rec[:job_id] == jinfo[:job_id] and jinfo[:run_ids].include?(rec[:id])
+      end
+      conflicting unless jinfo[:run_ids].size == found_runs.size
+
+      # check consistency of run_info
+      raise "Run info is not consistent with job info!" unless jinfo[:run_ids] == rinfo.keys.sort
+      
+      run_layer_path = @db_folders.path_to_run_layer( sim_class, jinfo[:param_id])
+      return run_layer_path, run_recs, run_yaml_path
+    end
+
+    def conflicting
+      raise RuntimeError, "This information is conflicting with the table."
+    end
+    
+    def file_move( folder_path, run_layer_path, run_ids)
+      run_ids.each do |rid|
+        data_folder = folder_path + rid.to_s
+        raise "must not happen" unless FileTest.directory?(data_folder)
+        data_files = Dir.glob(data_folder + '/*')
+        data_files.each do |data_file|
+          dest = run_layer_path + sprintf("%06d_",rid) + File.basename( data_file)
+          raise "file already exists." if File.exists?(dest)
+          FileUtils.mv( data_file, dest, {:verbose => true} )
+        end
+      end
+    end
+    
+    def update_tables( run_recs, jinfo, rinfos)
+      d = DateTime.now
+      rinfos.each_pair do |rid, info|
+        f = run_recs.update_state_to_finished( rid, info[:start_at], info[:finish_at], d,
+                                               info[:real_time], info[:user_time], jinfo[:host_name] )
+        raise "must not happen" unless f
+      end
+      destroyed = @job_records.destroy( jinfo[:job_id])
+      destroyed[:simulator] = jinfo[:simulator]
+      destroyed[:parameters] = jinfo[:parameters]
+      destroyed[:start_at] = jinfo[:start_at]
+      destroyed[:host_name] = jinfo[:host_name]
+      destroyed[:finish_at] = jinfo[:finish_at]
+      File.open( @db_folders.path_to_finished_jobs_file, "a") do |io|
+        YAML.dump( destroyed, io)
+        io.flush
+      end
+    end
+
+    def remove_files( fpath)
+      tar_path = fpath.sub(/.bz2$/,'')
+      FileUtils.rm( tar_path)
+      fold_path = tar_path.sub(/.tar$/,'/')
+      FileUtils.rm_r( fold_path)
+      sh_path = @db_folders.path_to_job_layer + File.basename( tar_path.sub(/.tar$/,'.sh'))
+      if FileTest.exist?(sh_path)
+        ff = @db_folders.path_to_job_layer + 'finished_jobs/'
+        FileUtils.mkdir_p( ff)
+        FileUtils.mv(sh_path, ff )
+      end
+    end
+    
+    public
+    def include_all
+      flag = true
+      include_list.each do |fname|
+        f = include(fname)
+        flag = nil unless f
+      end
+      dump_in_yaml
+      return flag
+    end
+
+    def dump_in_yaml
+      File.open( @db_folders.path_to_jobs_yaml, 'w') do |io|
+        YAML.dump( @job_records.list_all, io)
+        io.flush
+      end
+    end
+
+  end
+end

data/lib/nera/nera_job_records.rb

@@ -0,0 +1,111 @@
+require 'nera_database'
+
+module NERA
+
+  # This class access the simulator table.
+  class JobRecords
+
+    # keys of the simulator table
+    ATTRIBUTES = [ [:id, Integer],
+                   [:state, Symbol],
+                   [:simulator, String],
+                   [:parameter_id, Integer],
+                   [:run_id, Integer],
+                   [:number_of_runs, Integer],
+                   [:created_at, DateTime],
+                   [:updated_at, DateTime],
+                   [:host_name, String]
+                 ]
+    
+    # NERA::Database object
+    @db
+
+    # db_file is the path to database file
+    def initialize( db_file)
+      @db = NERA::Database.new( db_file)
+    end
+
+    # if file already exists, returns false
+    def self.create_table( db_file)
+      NERA::Database.create_table( db_file)
+    end
+
+    # return keys of the simulator table
+    def keys
+      keys = ATTRIBUTES.map do |x|
+        x[0]
+      end
+      return keys
+    end
+
+    # sim_class must be a subclass of NERA::Simulator
+    def add( sim_class, param_id, r_id, num_runs)
+      unless sim_class.is_a?(Class) and sim_class.superclass == NERA::Simulator and param_id.is_a?(Integer) and r_id.is_a?(Integer) and num_runs.is_a?(Integer)
+        raise ArgumentError, "Each argument must be an Integer"
+      end
+      if param_id <= 0 or r_id <= 0 or num_runs <= 0
+        raise ArgumentError, "Each argument must be a positive integer."
+      end
+      d = DateTime.now
+      h = { :state => :created, :simulator => sim_class.to_s, :parameter_id => param_id, :run_id => r_id,
+        :number_of_runs => num_runs, :created_at => d, :updated_at => d, :host_name => nil}
+      id = @db.add( h)
+      return id
+    end
+
+    def list_all
+      l = @db.find_all do |r| true end
+      return l.to_a
+    end
+
+    def list_created
+      l = @db.find_all do |r|
+        r[:state] == :created
+      end
+      return l.to_a
+    end
+
+    def find_by_id( i)
+      @db.find_by_id( i)
+    end
+
+    def update_to_state_copied( id, hostname)
+      unless id.is_a?(Integer) and hostname.is_a?(String)
+        raise ArgumentError, "Type of the argument is invalid."
+      end
+      
+      found = @db.find_by_id( id)
+      return nil  if found == nil
+
+      found[:state] = :copied
+      found[:updated_at] = DateTime.now
+      found[:host_name] = hostname
+      @db.update(found)
+    end
+
+    def update_to_state_submitted( id, hostname)
+      unless id.is_a?(Integer) and hostname.is_a?(String)
+        raise ArgumentError, "Type of the argument is invalid."
+      end
+      
+      found = @db.find_by_id( id)
+      return nil  if found == nil
+
+      found[:state] = :submitted
+      found[:updated_at] = DateTime.now
+      found[:host_name] = hostname
+      @db.update(found)
+    end
+    
+    def destroy( id)
+      raise ArgumentError unless id.is_a?(Integer)
+      @db.destroy(id)
+    end
+    
+    def transaction
+      @db.transaction{
+        yield
+      }
+    end
+  end
+end

data/lib/nera/nera_job_script.rb

@@ -0,0 +1,202 @@
+require 'fileutils'
+require 'date'
+require 'nera_db_folders'
+require 'nera_simulator'
+
+
+module NERA
+
+  # This class create & parse job scripts
+  class JobScript
+    
+    # NERA::DbFolders object
+    @db_folder
+    
+    #--------------------------------------
+    #-class methods -----------------------
+    #--------------------------------------
+
+    # db_folder is the instance of DbFolders
+    def initialize( db_folder)
+      unless db_folder.instance_of?(NERA::DbFolders) then
+        raise ArgumentError, "Argument must be an instance of NERA::DbFolders."
+      end
+      @db_folder = db_folder
+    end
+    
+    # job script
+    def job_script_body(job_info)
+ ############## job_script ###################
+job_script =<<"BODY"
+#!/bin/bash
+LANG=C
+mkdir -p #{job_info[:job_script_id]}
+cd #{job_info[:job_script_id]}
+echo \"#---------- header of #{job_info[:job_id]} ----------\" > nera_status.rb
+echo \"header = {\" >> nera_status.rb
+echo \"    :database => '#{job_info[:database]}',\" >> nera_status.rb
+echo \"    :job_id => #{job_info[:job_id]},\" >> nera_status.rb
+echo \"    :simulator => '#{job_info[:simulator]}',\" >> nera_status.rb
+echo \"    :simulator_id => #{job_info[:sim_id]},\" >> nera_status.rb
+echo \"    :param_id => #{job_info[:param_id]},\" >> nera_status.rb
+echo \"    :run_ids => #{job_info[:run_ids].inspect},\" >> nera_status.rb
+echo \"    :parameters => {\" >> nera_status.rb
+BODY
+
+job_info[:params].each_pair do |key, value|
+job_script += "echo \"        :#{key} => #{value},\" >> nera_status.rb\n"
+end
+
+job_script +=<<"BODY"
+echo \"    },\" >> nera_status.rb
+echo \"    :start_at => DateTime.parse( <<'NERA_DATE'.chomp )\" >> nera_status.rb
+date >> nera_status.rb
+echo \"NERA_DATE\" >> nera_status.rb
+echo \"}\" >> nera_status.rb
+echo \"body = {\" >> nera_status.rb
+BODY
+
+job_info[:run_ids].each_with_index do |run_id, i|
+job_script +=<<"BODY"
+echo \"    #---------- #{run_id} start ----------\" >> nera_status.rb
+echo \"    #{run_id} => {\" >> nera_status.rb
+echo \"        :seed => #{job_info[:seeds][i]}, :start_at => DateTime.parse( <<'NERA_START_AT'.chomp), :output => <<'NERA_OUTPUT', :finish_at => DateTime.parse( <<'NERA_FINISH_AT'.chomp)\" >> nera_status.rb
+date >> nera_status.rb
+echo \"NERA_START_AT\" >> nera_status.rb
+echo \"#{job_info[:execs][i]}\"
+mkdir -p #{run_id}
+cd #{run_id}
+{ time -p #{job_info[:execs][i]}; } >> ../nera_status.rb 2>&1
+if test $? -ne 0; then { echo \"Exit abnormally!\" >> ../nera_status.rb; exit; } fi
+cd ..
+echo \"NERA_OUTPUT\" >> nera_status.rb
+date >> nera_status.rb
+echo \"NERA_FINISH_AT\" >> nera_status.rb
+BODY
+if i == job_info[:run_ids].length-1 then job_script += "echo \"    }\" >> nera_status.rb\n"
+else job_script += "echo \"    },\" >> nera_status.rb\n" end
+job_script += "echo \"    #---------- #{run_id} end ----------\" >> nera_status.rb\n"
+end
+
+job_script +=<<"BODY"
+echo \"}\" >> nera_status.rb
+echo \"footer = {\" >> nera_status.rb
+echo \"    :host_name => <<'NERA_HOST'.chomp, :finish_at => DateTime.parse( <<'NERA_DATE'.chomp )\" >> nera_status.rb
+hostname >> nera_status.rb
+echo \"NERA_HOST\" >> nera_status.rb
+date >> nera_status.rb
+echo \"NERA_DATE\" >> nera_status.rb
+echo "}" >> nera_status.rb
+cd ..
+tar cf #{job_info[:job_script_id]}.tar #{job_info[:job_script_id]}/
+if test $? -ne 0; then { echo \"#Exit abnormally!\" >> ./nera_status.rb; exit; } fi
+bzip2 #{job_info[:job_script_id]}.tar
+if test $? -ne 0; then { echo \"Exit abnormally!\"; exit; } fi
+rm -rf #{job_info[:job_script_id]}
+BODY
+############## job script ###################
+
+      return job_script
+    end
+    private :job_script_body
+    
+    #--------------------------------------
+    #-public instance methods--------------
+    #--------------------------------------
+    public
+    # create job script --------------------
+    def  create_script(job_id, sim_id, param_id, sim_inst, run_stat)
+      unless job_id.is_a?(Integer) and sim_id.is_a?(Integer) and param_id.is_a?(Integer) 
+        raise ArgumentError, "Each ID of Job, Simulation and Parameter  must be an Integer."
+      end
+      unless sim_inst.kind_of?(NERA::Simulator)
+        raise ArgumentError, "Simulation_Instance must be a subclass of NERA::Simulator."
+      else
+        if sim_inst.param == {}
+          raise ArgumentError, "@param in Simulation_Instance must be set a parameter."
+        end
+      end
+      unless run_stat.is_a?(Array)
+        raise ArgumentError, "Run_Status must be an Array."
+      else 
+        run_stat.each do | stat |
+          unless stat.has_key?(:id) and stat.has_key?(:seed)
+            raise ArgumentError, "Run Status must have keys, :id and :seed."
+          end
+        end
+      end
+      
+      
+      run_ids =[]
+      seeds = []
+      run_stat.each do |run_info|
+        run_ids << run_info[:id]
+        seeds << run_info[:seed]
+      end
+
+      job_info ={
+        :job_id => job_id,
+        :job_script_id => sprintf("j%06d",job_id),
+        :database => File.basename( @db_folder.path_to_simulator_layer),
+        :simulator => sim_inst.class.to_s,
+        :sim_id => sim_id,
+        :param_id => param_id,
+        :params => sim_inst.param,
+        # {:L => 256, :K => 0.22325, :tmax => 512},
+        :run_ids => run_ids,
+        :seeds => seeds,
+        :execs => seeds.map do |sed| sim_inst.simulate_command( sed) end
+      }
+
+      path_job_script = @db_folder.path_to_job_script( job_id)
+      unless FileTest.directory?(@db_folder.path_to_job_layer)
+        raise "must not happen"
+      end
+      if FileTest.exist?(path_job_script)
+        raise "must not happen"
+      end
+
+      File.open(path_job_script,"w") do |io|
+        io.puts job_script_body(job_info)
+        io.flush
+      end
+
+      return path_job_script
+    end
+    
+    # parse status file --------------------
+    def parse_status(path_stat)
+      unless path_stat.is_a?(String) and FileTest.exists?(path_stat)
+        raise ArgumentError, "#{path_stat} is not valid status file."
+      end
+      
+      str = ""
+      File.open(path_stat).each do |line|
+        str += line
+      end
+      header = {}
+      body = {}
+      footer = {}
+      begin
+        eval(str)
+      rescue 
+        raise RuntimeError, "This nera_status.rb is not valid."
+      end
+      job_info = header.merge( footer)
+
+      body.each_pair do |run_id, info|
+        info[:real_time] = 0.0
+        info[:user_time] = 0.0
+        info[:output].each_line do |line|
+          if line =~ /^real [-+]?(?:[0-9]+(\.[0-9]*)?|(\.[0-9]+))([eE][-+]?[0-9]+)?/
+            info[:real_time] = line.sub(/^real /,'').to_f
+          elsif line =~ /^user [-+]?(?:[0-9]+(\.[0-9]*)?|(\.[0-9]+))([eE][-+]?[0-9]+)?/
+            info[:user_time] += line.sub(/^user /,'').to_f
+          end
+        end
+      end
+      return job_info, body
+    end
+
+  end
+end

data/lib/nera/nera_parameter_layer_controller.rb

@@ -0,0 +1,157 @@
+require 'date'
+require 'nera_db_folders'
+require 'nera_simulator_records'
+require 'nera_parameter_records'
+require 'nera_run_records'
+require 'nera_job_records'
+
+module NERA
+
+  class ParameterLayerController
+
+    # instance of NERA::DbFolders
+    @db_folders
+    # simulator class
+    @sim_class
+    # instance of NERA::ParameterRecords
+    @param_records
+
+    def initialize( path_db_folder, sim_class)
+      raise ArgumentError unless path_db_folder.is_a?(String)
+      unless sim_class.is_a?(Class) and sim_class.superclass == NERA::Simulator
+        raise ArgumentError, "#{sim_class} is not a subclass of NERA::Simulator"
+      end
+      
+      @db_folders = NERA::DbFolders.new( path_db_folder)
+      sim_records = NERA::SimulatorRecords.new( @db_folders.path_to_simulators_table)
+      @sim_class = sim_class
+      p_tab_path = @db_folders.path_to_parameters_table( @sim_class)
+      @param_records = NERA::ParameterRecords.new( p_tab_path, @sim_class)
+    end
+
+    def parameters_list_in_csv
+      l_active = @param_records.list_active
+      header = @param_records.keys.dup
+      header.delete( :in_trashbox?)
+      csv_list = []
+      l_active.each do |p_hash|
+        strings = []
+        header.each do |key|
+          if p_hash[key].is_a?(DateTime)
+            strings << p_hash[key].to_s.split('T')[0]
+          elsif p_hash[key]
+            strings << p_hash[key].to_s
+          elsif p_hash[key] == nil
+            found = @sim_class::Parameters.find do |p| p[0] == key end
+            strings << found[2].to_s
+          end
+        end
+        csv_list << strings.join(", ")
+      end
+      return header.join(", "), csv_list
+    end
+
+    def get_id_from_csv_string( pstr)
+      return pstr.split(',').first.to_i
+    end
+
+    def list_of_parameters
+      return  @sim_class::Parameters.dup
+    end
+
+    def path_to_param_layer
+      return  @db_folders.path_to_parameter_layer( @sim_class)
+    end
+
+    def create_a_new_parameter_set( p_hash)
+      pid = nil
+      @param_records.transaction {
+        pid = @param_records.add( p_hash)
+        return nil unless pid
+        b = @db_folders.create_new_parameter_folder( @sim_class, pid)
+        raise "Creation of a new folder for #{kalss}, #{pid} failed." unless b
+        path = @db_folders.path_to_runs_table( @sim_class, pid)
+        c = NERA::RunRecords.create_table( path)
+        raise "File #{path} already exists." unless c
+      }
+      dump_in_yaml
+      return pid
+    end
+
+    def move_a_parameter_set_into_trashbox( id)
+      return nil unless @param_records.find_by_id(id)
+      run_records = NERA::RunRecords.new( @db_folders.path_to_runs_table( @sim_class, id) )
+      return nil if run_records.list_all_not_finished.size > 0
+
+      job_records = NERA::JobRecords.new( @db_folders.path_to_jobs_table)
+      job_records.transaction {
+        @param_records.transaction {
+          flag = @param_records.update_to_state_trashbox(id)
+          return nil unless flag
+          r_path = @db_folders.path_to_run_layer( @sim_class, id).sub(/\/$/,'')
+          cmd = "tar cvjf #{r_path}.tar.bz2 #{r_path}"
+          system(cmd)
+          raise "Command #{cmd} failed" unless $? == 0
+          FileUtils.rm_r(r_path)
+        }
+      }
+      dump_in_yaml
+      return true
+    end
+
+    def trashbox_parameter_list_in_csv
+      lt = @param_records.list_trashbox
+      header = @param_records.keys.dup
+      header.delete( :in_trashbox?)
+      csv_list = []
+      lt.each do |p_hash|
+        strings = []
+        header.each do |key|
+          if p_hash[key].is_a?(DateTime)
+            strings << p_hash[key].to_s.split('T')[0]
+          elsif p_hash[key]
+            strings << p_hash[key].to_s
+          elsif p_hash[key] == nil
+            found = @sim_class::Parameters.find do |p| p[0] == key end
+            strings << found[2].to_s
+          end
+        end
+        csv_list << strings.join(", ")
+      end
+      return header.join(", "), csv_list
+    end
+
+    def revert_a_parameter_set_in_trashbox( id)
+      @param_records.transaction {
+        flag = @param_records.update_to_state_active(id)
+        return nil unless flag
+        r_path = @db_folders.path_to_run_layer( @sim_class, id).sub(/\/$/,'')
+        cmd = "tar xvjf #{r_path}.tar.bz2"
+        system(cmd)
+        raise "Command #{cmd} failed" unless $? == 0
+        FileUtils.rm(r_path+".tar.bz2")
+      }
+      dump_in_yaml
+      return true
+    end
+
+    def delete_a_parameter_set( id)
+      @param_records.transaction {
+        flag = @param_records.destroy(id)
+        return nil unless flag
+        r_path = @db_folders.path_to_run_layer( @sim_class, id).sub(/\/$/,'')
+        FileUtils.rm("#{r_path}.tar.bz2")
+      }
+      dump_in_yaml
+      return true
+    end
+
+    def dump_in_yaml
+      File.open( @db_folders.path_to_parameters_yaml( @sim_class), 'w') do |io|
+        YAML.dump( @param_records.list_all, io)
+        io.flush
+      end
+    end
+
+  end
+end