semtools 0.1.8 → 0.1.91

data/lib/semtools/ontology.rb

@@ -8,45 +8,30 @@ class Ontology
     # AUTHOR NOTES
     #########################################################
 
-    # 1 - Store @profiles as @stanzas[:instances]
     # 2 - Items values (not keys) are imported as strings, not as symbols (maybe add a flag which indicates if values are, or not, symbols?) 
 
-
     #############################################
     # FIELDS
     #############################################
-    # Handled class variables
-    # => @@basic_tags :: hash with main OBO structure tags
-    # => @@allowed_calcs :: hash with allowed ICs and similaritites calcs
-    # => @@symbolizable_ids :: tags which can be symbolized
-    # => @@tags_with_trailing_modifiers :: tags which can include extra info after specific text modifiers
-    #
     # Handled object variables
-    # => @header :: file header (if is available)
-    # => @stanzas :: OBO stanzas {:terms,:typedefs,:instances}
+    # => @terms :: OBO terms descriptions
     # => @ancestors_index :: hash of ancestors per each term handled with any structure relationships
     # => @descendants_index :: hash of descendants per each term handled with any structure relationships
     # => @alternatives_index :: has of alternative IDs (include alt_id and obsoletes)
-    # => @obsoletes_index :: hash of obsoletes and it's new ids
-    # => @special_tags :: set of special tags to be expanded (:is_a, :obsolete, :alt_id)
     # => @structureType :: type of ontology structure depending on ancestors relationship. Allowed: {atomic, sparse, circular, hierarchical}
-    # => @ics :: already calculated ICs for handled terms and IC types
-    # => @meta :: meta_information about handled terms like [ancestors, descendants, struct_freq, observed_freq]
-    # => @max_freqs :: maximum freqs found for structural and observed freqs
     # => @dicts :: bidirectional dictionaries with three levels <key|value>: 1º) <tag|hash2>; 2º) <(:byTerm/:byValue)|hash3>; 3º) dictionary <k|v>
-    # => @profiles :: set of terms assigned to an ID
-    # => @profilesDict :: set of profile IDs assigned to a term
-    # => @items :: hash with items relations to terms
     # => @removable_terms :: array of terms to not be considered
+    # => @meta :: meta_information about handled terms like [ancestors, descendants, struct_freq, observed_freq]
+    # => @ics :: already calculated ICs for handled terms and IC types
     # => @term_paths :: metainfo about parental paths of each term
+    # => @max_freqs :: maximum freqs found for structural and observed freqs
+    # => @items :: hash with items relations to terms
+    # => @profiles :: set of terms assigned to an ID
 
-    @@basic_tags = {ancestors: [:is_a], obsolete: :is_obsolete, alternative: [:replaced_by,:consider,:alt_id]}
     @@allowed_calcs = {ics: [:resnik, :resnik_observed, :seco, :zhou, :sanchez], sims: [:resnik, :lin, :jiang_conrath]}
-    @@symbolizable_ids = [:id, :alt_id, :replaced_by, :consider]
-    @@tags_with_trailing_modifiers = [:is_a, :union_of, :disjoint_from, :relationship, :subsetdef, :synonymtypedef, :property_value]
-    @@multivalue_tags = [:alt_id, :is_a, :subset, :synonym, :xref, :intersection_of, :union_of, :disjoint_from, :relationship, :replaced_by, :consider, :subsetdef, :synonymtypedef, :property_value, :remark]
-    @@symbolizable_ids.concat(@@tags_with_trailing_modifiers)
 
+attr_accessor :terms, :ancestors_index, :descendants_index, :alternatives_index, :obsoletes, :structureType, :ics, :max_freqs, :meta, :dicts, :profiles, :items, :term_paths, :reroot
+    
     #############################################
     # CONSTRUCTOR
     #############################################
@@ -58,266 +43,138 @@ class Ontology
     # +removable_terms+: term to be removed from calcs
     # +build+: flag to launch metainfo calculation
     # +file_format+: force format type despite file extension. Can be :obo or :json
-    def initialize(file: nil, load_file: false, removable_terms: [], build: true, file_format: nil)
-        # Initialize object variables
-        @header = nil
-        @stanzas = {terms: {}, typedefs: {}, instances: {}}
+    def initialize(file: nil, load_file: false, removable_terms: [], build: true, file_format: nil, extra_dicts: [])
+        @terms = {}
         @ancestors_index = {}
         @descendants_index = {}
         @alternatives_index = {}
-        @obsoletes_index = {}
+        @obsoletes = {} # id is obsolete but it could or not have an alt id
         @structureType = nil
         @ics = Hash[@@allowed_calcs[:ics].map{|ictype| [ictype, {}]}]
         @meta = {}
-        @special_tags = @@basic_tags.clone
         @max_freqs = {:struct_freq => -1.0, :observed_freq => -1.0, :max_depth => -1.0}
         @dicts = {}
         @profiles = {}
-        @profilesDict = {}
         @items = {}
-        @removable_terms = []
         @term_paths = {}
-        add_removable_terms(removable_terms) if !removable_terms.empty?
+        @reroot = false
         load_file = true unless file.nil? # This should remove load_file argument, keep it for old scripts
         # Load if proceeds
         if load_file
             fformat = file_format
             fformat = File.extname(file) if fformat.nil? && !file.nil?
             if fformat == :obo || fformat == ".obo"
-                load(file, build: build)
+                OboParser.load(self, file, build: build, black_list: removable_terms, extra_dicts: extra_dicts)
             elsif fformat == :json || fformat == ".json"
-                self.read(file, build: build)
+                JsonParser.load(self, file, build: build)
             elsif !fformat.nil?
                 warn 'Format not allowed. Loading process will not be performed'
             end
+            precompute if build
         end
     end
 
-
     #############################################
-    # CLASS METHODS
+    # GENERATE METADATA FOR ALL TERMS
     #############################################
 
-    # Expand a (starting) term using a specific tag and return all extended terms into an array and
-    # the relationship structuture observed (hierarchical or circular). If circular structure is
-    # foumd, extended array will be an unique vector without starting term (no loops).
-    # +Note+: we extremly recomend use get_related_ids_by_tag function instead of it (directly)
-    # ===== Parameters
-    # +start+:: term where start to expand
-    # +terms+:: set to be used to expand
-    # +target_tag+:: tag used to expand
-    # +eexpansion+:: already expanded info
-    # +split_info_char+:: special regex used to split info (if it is necessary)
-    # +split_info_indx+:: special index to take splitted info (if it is necessary)
-    # +alt_ids+:: set of alternative IDs
-    # ===== Returns 
-    # A vector with the observed structure (string) and the array with extended terms.
-    def self.get_related_ids(start_id, terms, target_tag, related_ids = {}, alt_ids = {})
-        # Take start_id term available info and already accumulated info
-        current_associations = related_ids[start_id]
-        current_associations = [] if current_associations.nil? 
-        return [:no_term,[]] if terms[start_id].nil?
-        id_relations = terms[start_id][target_tag]
-        return [:source,[]] if id_relations.nil?
-
-        # Prepare auxiliar variables
-        struct = :hierarchical
-
-        # Study direct extensions
-        id_relations = id_relations.clone
-        while id_relations.length > 0
-            id = id_relations.shift
-            id = alt_ids[id].first if alt_ids.include?(id) # NOTE: if you want to persist current ID instead source ID, re-implement this
-            
-            # Handle
-            if current_associations.include?(id) # Check if already have been included into this expansion
-                struct = :circular 
-            else
-                current_associations << id 
-                if related_ids.include?(id) # Check if current already has been expanded
-                    current_associations = current_associations | related_ids[id]
-                    if current_associations.include?(start_id) # Check circular case
-                        struct = :circular
-                        [id, start_id].each{|repeated| current_associations.delete(repeated)}
-                    end    
-                else # Expand
-                    related_ids[start_id] = current_associations
-                    structExp, current_related_ids = self.get_related_ids(id, terms, target_tag, related_ids, alt_ids) # Expand current
-                    current_associations = current_associations | current_related_ids
-                    struct = :circular if structExp == :circular # Check struct                
-                    if current_associations.include?(start_id) # Check circular case
-                        struct = :circular
-                        current_associations.delete(start_id)
-                    end
-                end
-            end
-        end
-        related_ids[start_id] = current_associations
-
-        return struct, current_associations
-    end
-
-
-    # Expand terms using a specific tag and return all extended terms into an array and
-    # the relationship structuture observed (hierarchical or circular). If circular structure is
-    # foumd, extended array will be an unique vector without starting term (no loops) 
-    # ===== Parameters
-    # +terms+:: set to be used to expand
-    # +target_tag+:: tag used to expand
-    # +split_info_char+:: special regex used to split info (if it is necessary)
-    # +split_info_indx+:: special index to take splitted info (if it is necessary)
-    # +alt_ids+:: set of alternative IDs
-    # +obsoletes+:: integer with the number of obsolete IDs. used to calculate structure type.
-    # ===== Returns 
-    # A vector with the observed structure (string) and the hash with extended terms
-    def self.get_related_ids_by_tag(terms:,target_tag:, alt_ids: {}, obsoletes: 0)
-        # Define structure type
-        structType = :hierarchical
-        related_ids = {}
-        terms.each do |id, tags|
-            # Check if target tag is defined
-            if !tags[target_tag].nil?
-                # Obtain related terms
-                set_structure, _ = self.get_related_ids(id, terms, target_tag, related_ids, alt_ids)
-                # Check structure            
-                structType = :circular if set_structure == :circular
-            end
-        end
-
-        # Check special case
-        structType = :atomic if related_ids.length <= 0
-        structType = :sparse if related_ids.length > 0 && ((terms.length - related_ids.length - obsoletes) >= 2)
-        # Return type and hash with related_ids
-        return structType, related_ids
+    def precompute
+        get_index_frequencies
+        calc_term_levels(calc_paths: true)
     end
 
-
-    # Class method to transform string with <tag : info> into hash structure
-    # ===== Parameters
-    # +attributes+:: array tuples with info to be transformed into hash format
+    # Calculates regular frequencies based on ontology structure (using parentals)
     # ===== Returns 
-    # Attributes stored into hash structure
-    def self.info2hash(attributes, split_char = " ! ", selected_field = 0)
-        # Load info
-        info_hash = {}
-        # Only TERMS multivalue tags (future add Typedefs and Instance)
-        # multivalue_tags = [:alt_id, :is_a, :subset, :synonym, :xref, :intersection_of, :union_of, :disjoint_from, :relationship, :replaced_by, :consider]
-        attributes.each do |tag, value|
-            value.gsub!(/{source=[\\\":A-Za-z0-9\/\.\-, =]+} /, '') if tag == 'is_a' # To delete "source" attributes in is_a tag of MONDO ontology
-            # Check
-            raise EncodingError, 'Info element incorrect format' if (tag.nil?) || (value.nil?)
-            # Prepare
-            tag = tag.lstrip.to_sym
-            value.lstrip!
-            value = value.split(split_char)[selected_field].to_sym if @@tags_with_trailing_modifiers.include?(tag)
-            
-            # Store
-            query = info_hash[tag]
-            if !query.nil? # Tag already exists
-                if !query.kind_of?(Array) # Check that tag is multivalue
-                    raise('Attempt to concatenate plain text with another. The tag is not declared as multivalue. [' + tag.to_s + '](' + query + ')')
-                else
-                    query << value    # Add new value to tag
-                end
-            else # New entry
-                if @@multivalue_tags.include?(tag)
-                    info_hash[tag] = [value]
-                else
-                    info_hash[tag] = value
+    # true if everything end without errors and false in other cases
+    def get_index_frequencies() # Per each term, add frequencies
+        if @ancestors_index.empty?
+            warn('ancestors_index object is empty')
+        else
+            each(att = true) do |id, tags|
+                query = @meta[id]
+                if query.nil?
+                    query = {ancestors: 0.0, descendants: 0.0, struct_freq: 0.0, observed_freq: 0.0}
+                    @meta[id] = query 
                 end
+                query[:ancestors] = @ancestors_index.include?(id) ? @ancestors_index[id].length.to_f : 0.0
+                query[:descendants] = @descendants_index.include?(id) ? @descendants_index[id].length.to_f : 0.0
+                query[:struct_freq] = query[:descendants] + 1.0
+                # Update maximums
+                @max_freqs[:struct_freq] = query[:struct_freq] if @max_freqs[:struct_freq] < query[:struct_freq]  
+                @max_freqs[:max_depth] = query[:descendants] if @max_freqs[:max_depth] < query[:descendants]  
             end
         end
-        self.symbolize_ids(info_hash)
-        return info_hash
     end
 
-
-    # Class method to load an OBO format file (based on OBO 1.4 format). Specially focused on load
-    # the Header, the Terms, the Typedefs and the Instances.
+    # Calculates ontology structural levels for all ontology terms
     # ===== Parameters
-    # +file+:: OBO file to be loaded
-    # ===== Returns 
-    # Hash with FILE, HEADER and STANZAS info
-    def self.load_obo(file) #TODO: Send to obo_parser class
-        raise("File is not defined") if file.nil?
-        # Data variables
-        header = ''
-        stanzas = {terms: {}, typedefs: {}, instances: {}}
-        # Auxiliar variables
-        infoType = 'Header'
-        currInfo = []
-        stanzas_flags = %w[[Term] [Typedef] [Instance]]
-        # Read file
-        File.open(file).each do |line|
-            line.chomp!
-            next if line.empty?
-            fields = line.split(':', 2)
-            # Check if new instance is found
-            if stanzas_flags.include?(line)
-                header = self.process_entity(header, infoType, stanzas, currInfo)
-                # Update info variables
-                currInfo = []
-                infoType = line.gsub!(/[\[\]]/, '')
-                next
+    # +calc_paths+:: calculates term paths if it's not already calculated
+    # +shortest_path+:: if true, level is calculated with shortest path, largest path will be used in other cases
+    def calc_term_levels(calc_paths: false, shortest_path: true) 
+        self.calc_term_paths if @term_paths.empty? && calc_paths
+        if !@term_paths.empty?
+            byTerm = {}
+            byValue = {}
+            @term_paths.each do |term, info|
+                level = shortest_path ? info[:shortest_path] : info[:largest_path]
+                level = level.nil? ? -1 : level.round(0)
+                byTerm[term] = level
+                add2hash(byValue, level, term)
             end
-            # Concat info
-            currInfo << fields  
+            @dicts[:level] = {byTerm: byValue, byValue: byTerm} # Note: in this case, value has multiplicity and term is unique value
+            @max_freqs[:max_depth] = byValue.keys.max # Update maximum depth
         end
-        # Store last loaded info
-        header = self.process_entity(header, infoType, stanzas, currInfo) if !currInfo.empty?
-
-        # Prepare to return
-        finfo = {:file => file, :name => File.basename(file, File.extname(file))}
-        return finfo, header, stanzas
     end
 
-
-    # Handle OBO loaded info and stores it into correct container and format
-    # ===== Parameters
-    # +header+:: container
-    # +infoType+:: current ontology item type detected
-    # +stanzas+:: container
-    # +currInfo+:: info to be stored
-    # ===== Returns 
-    # header newly/already stored
-    def self.process_entity(header, infoType, stanzas, currInfo)
-        info = self.info2hash(currInfo)
-        # Store current info
-        if infoType.eql?('Header')
-            header = info
-        else
-            id = info[:id]
-            case infoType
-                when 'Term'
-                    stanzas[:terms][id] = info
-                when 'Typedef'
-                    stanzas[:typedefs][id] = info
-                when 'Instance'
-                    stanzas[:instances][id] = info
+    # Find paths of a term following it ancestors and stores all possible paths for it and it's parentals.
+    # Also calculates paths metadata and stores into @term_paths
+    def calc_term_paths 
+        @term_paths = {}
+        if [:hierarchical, :sparse].include? @structureType
+            each do |term|
+                expand_path(term)                    
+                path_attr = @term_paths[term]
+                # expand_path is arecursive function so these pat attributes must be calculated once the recursion is finished
+                path_attr[:total_paths] = path_attr[:paths].length
+                paths_sizes = path_attr[:paths].map{|path| path.length}
+                path_attr[:largest_path] = paths_sizes.max
+                path_attr[:shortest_path] = paths_sizes.min
             end
+        else
+            warn('Ontology structure must be hierarchical or sparse to calculate term levels. Aborting paths calculation')
         end
-        return header
     end
 
-
-    # Symboliza all values into hashs using symbolizable tags as keys
+    # Recursive function whic finds paths of a term following it ancestors and stores all possible paths for it and it's parentals
     # ===== Parameters
-    # +item_hash+:: hash to be checked
-    def self.symbolize_ids(item_hash)
-        @@symbolizable_ids.each do |tag|
-            query = item_hash[tag] 
-            if !query.nil?
-                if query.kind_of?(Array)
-                    query.map!{|item| item.to_sym}
-                else
-                    item_hash[tag] = query.to_sym if !query.nil?
+    # +curr_term+:: current visited term
+    # +visited_terms+:: already expanded terms
+    def expand_path(curr_term) 
+        if !@term_paths.include?(curr_term)
+            path_attr = {total_paths: 0, largest_path: 0, shortest_path: 0, paths: []}
+            @term_paths[curr_term] = path_attr
+            direct_parentals = @dicts[:is_a][:byTerm][curr_term]
+            if direct_parentals.nil? # No parents :: End of recurrence
+                path_attr[:paths] << [curr_term]
+            else # Expand and concat
+                direct_parentals.each do |ancestor|
+                    path_attr_parental = @term_paths[ancestor]
+                    if path_attr_parental.nil? # Calculate new paths
+                        self.expand_path(ancestor) 
+                        new_paths = @term_paths[ancestor][:paths]
+                    else # Use direct_parental paths already calculated 
+                        new_paths = path_attr_parental[:paths] 
+                    end
+                    path_attr[:paths].concat(new_paths.map{|path| path.clone.unshift(curr_term)})
                 end
             end
         end
     end
 
+    #############################################
+    # CLASS METHODS (TODO: TO BE TRANFORMED IN INSTANCE METHODS)
+    #############################################
 
-    #
     # ===== Parameters
     # +root+:: main term to expand
     # +ontology+:: to be cutted
@@ -325,18 +182,32 @@ class Ontology
     # +remove_up+:: if true, stores only the root term given an it descendants. If false, only root ancestors will be stored
     # ===== Returns
     # An Ontology object with terms after cut the ontology.
-    def self.mutate(root, ontology, clone: true, remove_up: true)
+    def self.mutate(root, ontology, clone: true, remove_up: true) #TODO, pending to fix and pass to instance method
         ontology = ontology.clone if clone
         # Obtain affected IDs
         descendants = ontology.descendants_index[root]
         descendants << root # Store itself to do not remove it
         # Remove unnecesary terms
-        ontology.stanzas[:terms] = ontology.stanzas[:terms].select{|id,v| remove_up ? descendants.include?(id) : !descendants.include?(id)}
+        terms = ontology.terms.select{|id,v| remove_up ? descendants.include?(id) : !descendants.include?(id)}
+        ids = terms.keys
+        terms.each do |id, term|
+            term[:is_a] = term[:is_a] & ids # Clean parental relations to keep only whose that exist between selected terms
+        end
+        ontology.terms = terms
         ontology.ics = Hash[@@allowed_calcs[:ics].map{|ictype| [ictype, {}]}]
         ontology.max_freqs = {:struct_freq => -1.0, :observed_freq => -1.0, :max_depth => -1.0}
         ontology.dicts = {}
-        ontology.removable_terms = []
         ontology.term_paths = {}
+        ontology.reroot = true
+
+        ontology.ancestors_index = {}
+        ontology.descendants_index = {}
+        ontology.alternatives_index = {}
+        ontology.meta = {}
+        ontology.profiles = {}
+        ontology.items = {}
+
+
         # Recalculate metadata
         ontology.build_index
         ontology.add_observed_terms_from_profiles
@@ -344,33 +215,13 @@ class Ontology
         return ontology
     end
 
-
-
     #############################################
-    # GENERAL METHODS
+    # TERM METHODS
     #############################################
 
-    # Include removable terms to current removable terms list
-    # ===== Parameters
-    # +terms+:: terms array to be concatenated
-    def add_removable_terms(terms)
-        terms = terms.map{|term| term.to_sym}
-        @removable_terms.concat(terms)
-    end
-
-
-    # Include removable terms to current removable terms list loading new
-    # terms from a one column plain text file
-    # ===== Parameters
-    # +file+:: to be loaded 
-    def add_removable_terms_from_file(file)
-        File.open(excluded_codes_file).each do |line|
-            line.chomp!
-            @removable_terms << line.to_sym
-        end
-    end
+    # I/O observed term from data
+    ####################################
 
-    
     # Increase observed frequency for a specific term
     # ===== Parameters
     # +term+:: term which frequency is going to be increased
@@ -378,15 +229,7 @@ class Ontology
     # ===== Return
     # true if process ends without errors, false in other cases
     def add_observed_term(term:,increase: 1.0)
-        # Check
-        raise ArgumentError, "Term given is NIL" if term.nil?
-        return false unless @stanzas[:terms].include?(term)
-        return false if @removable_terms.include?(term)
-        if @alternatives_index.include?(term)
-            alt_id = @alternatives_index[term]
-            @meta[alt_id] = {:ancestors => -1.0,:descendants => -1.0,:struct_freq => 0.0,:observed_freq => 0.0} if @meta[alt_id].nil?
-            @meta[term] = @meta[alt_id]             
-        end
+        return false unless term_exist?(term)
         # Check if exists
         @meta[term] = {:ancestors => -1.0,:descendants => -1.0,:struct_freq => 0.0,:observed_freq => 0.0} if @meta[term].nil?
         # Add frequency
@@ -397,345 +240,199 @@ class Ontology
         return true
     end
 
+    # Obtain level and term relations
+    ####################################
 
-    # Increase the arbitrary frequency of a given term set 
     # ===== Parameters
-    # +terms+:: set of terms to be updated
-    # +increase+:: amount to be increased
-    # +transform_to_sym+:: if true, transform observed terms to symbols. Default: false
-    # ===== Return
-    # true if process ends without errors and false in other cases
-    def add_observed_terms(terms:, increase: 1.0, transform_to_sym: false)
-        # Check
-        raise ArgumentError, 'Terms array given is NIL' if terms.nil?
-        raise ArgumentError, 'Terms given is not an array' if !terms.is_a? Array
-        # Add observations
-        if transform_to_sym
-            checks = terms.map{|id| self.add_observed_term(term: id.to_sym,increase: increase)}
-        else
-            checks = terms.map{|id| self.add_observed_term(term: id,increase: increase)}
+    # +term+:: which are requested
+    # +relation+:: can be :ancestor or :descendant 
+    # ===== Returns
+    # Direct ancestors/descendants of given term or nil if any error occurs
+    def get_direct_related(term, relation)
+        target = nil
+        case relation
+            when :ancestor
+                target = :byTerm
+            when :descendant
+                target = :byValue
+            else
+                warn('Relation type not allowed. Returning nil')
         end
-        return checks
+        query = @dicts.dig(:is_a, target, term)
+        return query
     end
 
-
-    # Compare to terms sets 
+    # Return direct ancestors/descendants of a given term
+    # Return direct ancestors of a given term
     # ===== Parameters
-    # +termsA+:: set to be compared
-    # +termsB+:: set to be compared
-    # +sim_type+:: similitude method to be used. Default: resnik
-    # +ic_type+:: ic type to be used. Default: resnik
-    # +bidirectional+:: calculate bidirectional similitude. Default: false
-    # ===== Return
-    # similitude calculated
-    def compare(termsA, termsB, sim_type: :resnik, ic_type: :resnik, bidirectional: true, store_mica: false)
-        # Check
-        raise ArgumentError, "Terms sets given are NIL" if termsA.nil? | termsB.nil?
-        raise ArgumentError, "Set given is empty. Aborting similarity calc" if termsA.empty? | termsB.empty?
-        micasA = []
-        # Compare A -> B
-        termsA.each do |tA|
-            micas = []
-            termsB.each do |tB|
-                if store_mica
-                    value = @mica_index.dig(tA, tB)
-                else
-                    value = nil
-                end
-                if value.nil?
-                    value = self.get_similarity(tA, tB, type: sim_type, ic_type: ic_type)
-                    if store_mica
-                        value = true if value.nil? # We use true to save that the operation was made but there is not mica value
-                        add2nestHash(@mica_index, tA, tB, value)
-                    end
-                end
-                micas << value if value.class == Float 
-            end
-            if !micas.empty?
-                micasA << micas.max # Obtain maximum value
-            else
-                micasA << 0 
-            end
-        end
-        means_sim = micasA.inject{ |sum, el| sum + el }.fdiv(micasA.size)
-        # Compare B -> A
-        if bidirectional
-            means_simA = means_sim * micasA.size
-            means_simB = self.compare(termsB, termsA, sim_type: sim_type, ic_type: ic_type, bidirectional: false, store_mica: store_mica) * termsB.size
-            means_sim = (means_simA + means_simB).fdiv(termsA.size + termsB.size)
-        end
-        # Return
-        return means_sim
+    # +term+:: which ancestors are requested
+    # ===== Returns
+    # Direct ancestors of given term or nil if any error occurs
+    def get_direct_ancentors(term)
+        return self.get_direct_related(term, :ancestor)
     end
 
-    def add2nestHash(h, key1, key2, val)
-        query1 = h[key1]
-        if query1.nil?
-            h[key1] = {key2 => val} 
-        else
-            query1[key2] = val
-        end
+    # Return direct descendants of a given term
+    # ===== Parameters
+    # +term+:: which descendants are requested
+    # ===== Returns
+    # Direct descendants of given term or nil if any error occurs
+    def get_direct_descendants(term)
+        return self.get_direct_related(term, :descendant)        
     end
 
-    # Compare internal stored profiles against another set of profiles. If an external set is not provided, internal profiles will be compared with itself 
+    # Find ancestors/descendants of a given term
     # ===== Parameters
-    # +external_profiles+:: set of external profiles. If nil, internal profiles will be compared with itself
-    # +sim_type+:: similitude method to be used. Default: resnik
-    # +ic_type+:: ic type to be used. Default: resnik
-    # +bidirectional+:: calculate bidirectional similitude. Default: false
-    # ===== Return
-    # Similitudes calculated
-    def compare_profiles(external_profiles: nil, sim_type: :resnik, ic_type: :resnik, bidirectional: true)
-        profiles_similarity = {} #calculate similarity between patients profile
-        profiles_ids = @profiles.keys
-        if external_profiles.nil?
-            comp_ids = profiles_ids
-            comp_profiles = @profiles
-            main_ids = comp_ids
-            main_profiles = comp_profiles
+    # +term+:: to be checked
+    # +return_ancestors+:: return ancestors if true or descendants if false
+    # ===== Returns 
+    # an array with all ancestors/descendants of given term or nil if parents are not available yet
+    def get_familiar(term, return_ancestors = true) 
+        familiars = return_ancestors ? @ancestors_index[term] : @descendants_index[term]    
+        if !familiars.nil?
+            familiars = familiars.clone
         else
-            comp_ids = external_profiles.keys
-            comp_profiles = external_profiles
-            main_ids = profiles_ids
-            main_profiles = @profiles
-        end
-        # Compare
-        @mica_index = {}
-        while !main_ids.empty?
-            curr_id = main_ids.shift
-            current_profile = main_profiles[curr_id]
-            comp_ids.each do |id|
-                profile = comp_profiles[id]
-                value = compare(current_profile, profile, sim_type: sim_type, ic_type: ic_type, bidirectional: bidirectional, store_mica: true)
-                query = profiles_similarity[curr_id]
-                if query.nil?
-                  profiles_similarity[curr_id] = {id => value}
-                else
-                  query[id] = value
-                end
-            end    
+            familiars = []
         end
-        return profiles_similarity
+        return familiars
     end
 
+    # Find ancestors of a given term
+    # ===== Parameters
+    # +term+:: to be checked
+    # ===== Returns 
+    # an array with all ancestors of given term or false if parents are not available yet
+    def get_ancestors(term)
+        return self.get_familiar(term, true)        
+    end
 
-    # Expand alternative IDs arround all already stored terms
+    # Find descendants of a given term
     # ===== Parameters
-    # +alt_tag+:: tag used to expand alternative IDs
+    # +term+:: to be checked
     # ===== Returns 
-    # true if process ends without errors and false in other cases
-    def get_index_alternatives(alt_tag: @@basic_tags[:alternative].last)
-        # Check input
-        raise('stanzas terms empty')  if @stanzas[:terms].empty?
-        # Take all alternative IDs
-        alt_ids2add = {}
-        @stanzas[:terms].each do |id, tags|
-            if id == tags[:id] # Avoid simulated alternative terms
-                # id = tags[:id] # Take always real ID in case of alternative terms simulted
-                alt_ids = tags[alt_tag]
-                if !alt_ids.nil?
-                    alt_ids = alt_ids - @removable_terms - [id]
-                    # Update info
-                    alt_ids.each do |alt_term|
-                        @alternatives_index[alt_term] = id
-                        alt_ids2add[alt_term] = @stanzas[:terms][id] if !@stanzas[:terms].include?(alt_term)
-                        @ancestors_index[alt_term] = @ancestors_index[id] if !@ancestors_index[id].nil?
-                    end
+    # an array with all descendants of given term or false if parents are not available yet
+    def get_descendants(term)
+        return self.get_familiar(term, false)        
+    end
+
+    # Gets ontology level of a specific term
+    # ===== Returns 
+    # Term level
+    def get_term_level(term)
+        return @dicts[:level][:byValue][term]
+    end
+
+    # nil, term not found, [] term exists but not has parents
+    def get_parental_path(term, which_path = :shortest_path, level = 0) 
+        path = nil
+        path_attr = @term_paths[term]
+        if !path_attr.nil?
+            path_length = path_attr[which_path]
+            all_paths = path_attr[:paths]
+            if all_paths.empty?
+                path = []
+            else
+                path = all_paths.select{|pt| pt.length == path_length}.first.clone
+                if level > 0 # we want the term and his ascendants until a specific level
+                    n_parents = path_length - level 
+                    path = path[0..n_parents]
                 end
+                path.shift # Discard the term itself
             end
         end
-        @stanzas[:terms].merge!(alt_ids2add)
+        return path
     end
 
+    # ID Handlers
+    ####################################
 
-    # Executes basic expansions of tags (alternatives, obsoletes and parentals) with default values
     # ===== Returns 
-    # true if eprocess ends without errors and false in other cases
-    def build_index()
-        self.get_index_obsoletes
-        self.get_index_alternatives
-        self.get_index_child_parent_relations
-            @alternatives_index.each{|k,v| @alternatives_index[k] = self.extract_id(v)}
-            ## @alternatives_index.map {|k,v| @alternatives_index[k] = self.stanzas[:terms][v][:id] if k == v} unless self.stanzas[:terms].empty?
-            @alternatives_index.compact!
-            @obsoletes_index.each{|k,v| @obsoletes_index[k] = self.extract_id(v)}
-            @obsoletes_index.compact!
-            @ancestors_index.each{|k,v| @ancestors_index[k] = v.map{|t| self.extract_id(t)}.compact}
-            @ancestors_index.compact!
-            @descendants_index.each{|k,v| @descendants_index[k] = v.map{|t| self.extract_id(t)}.compact}
-            @descendants_index.compact!
-        self.get_index_frequencies
-        self.calc_dictionary(:name)
-        self.calc_dictionary(:synonym, select_regex: /\"(.*)\"/)
-        self.calc_term_levels(calc_paths: true)
+    # the main ID assigned to a given ID. If it's a non alternative/obsolete ID itself will be returned
+    # ===== Parameters
+    # +id+:: to be translated
+    # ===== Return
+    # main ID related to a given ID. Returns nil if given ID is not an allowed ID
+    def get_main_id(id) 
+        mainID = @alternatives_index[id]
+        return nil if !term_exist?(id) && mainID.nil?
+        if !mainID.nil? # Recursive code to get the definitive final term id if there are several alt_id in chain
+            new_id = get_main_id(mainID)
+            if new_id != mainID
+                new_id = get_main_id(new_id)
+            end
+            id = new_id    
+        end
+        return id
     end
 
-
-    # Calculates regular frequencies based on ontology structure (using parentals)
-    # ===== Returns 
-    # true if everything end without errors and false in other cases
-    def get_index_frequencies()
-        # Check
-        if @ancestors_index.empty?
-            warn('ancestors_index object is empty') 
-        else
-            # Per each term, add frequencies
-            @stanzas[:terms].each do |id, tags|            
-                if @alternatives_index.include?(id)
-                    alt_id = @alternatives_index[id]
-                    query = @meta[alt_id] # Check if exist
-                    if query.nil?
-                        query = {ancestors: 0.0, descendants: 0.0, struct_freq: 0.0, observed_freq: 0.0}
-                        @meta[alt_id] = query 
-                    end 
-                    @meta[id] = query
-                    # Note: alternative terms do not increase structural frequencies
-                else # Official term
-                    query = @meta[id] # Check if exist
-                    if query.nil?
-                        query = {ancestors: 0.0, descendants: 0.0, struct_freq: 0.0, observed_freq: 0.0}
-                        @meta[id] = query 
-                    end
-                    # Store metadata
-                    query[:ancestors] = @ancestors_index.include?(id) ? @ancestors_index[id].count{|anc| !@alternatives_index.include?(anc)}.to_f : 0.0
-                    query[:descendants] = @descendants_index.include?(id) ? @descendants_index[id].count{|desc| !@alternatives_index.include?(desc)}.to_f : 0.0
-                    query[:struct_freq] = query[:descendants] + 1.0
-                    # Update maximums
-                    @max_freqs[:struct_freq] = query[:struct_freq] if @max_freqs[:struct_freq] < query[:struct_freq]  
-                    @max_freqs[:max_depth] = query[:descendants] if @max_freqs[:max_depth] < query[:descendants]  
-                end
-            end
-        end
+    # Translate a given value using an already calcualted dictionary
+    # ===== Parameters
+    # +toTranslate+:: value to be translated using dictiontionary
+    # +tag+:: used to generate the dictionary
+    # +byValue+:: boolean flag to indicate if dictionary must be used values as keys or terms as keys. Default: values as keys = true
+    # ===== Return
+    # translation
+    def translate(toTranslate, tag, byValue: true)
+        dict = byValue ? @dicts[tag][:byValue] : @dicts[tag][:byTerm]    
+        toTranslate =  get_main_id(toTranslate) if !byValue
+        return dict[toTranslate]
     end
 
-
-    # Expand obsoletes set and link info to their alternative IDs
+    # Translate a name given
     # ===== Parameters
-    # +obs_tags+:: tags to be used to find obsoletes
-    # +alt_tags+:: tags to find alternative IDs (if are available)
-    # +reset_obsoletes+:: flag to indicate if obsoletes set must be reset. Default: true
-    # ===== Returns 
-    # true if process ends without errors and false in other cases
-    def get_index_obsoletes(obs_tag: @@basic_tags[:obsolete], alt_tags: @@basic_tags[:alternative])
-        if @stanzas[:terms].empty?
-            warn('stanzas terms empty')
-        else
-            # Check obsoletes
-            @stanzas[:terms].each do |id, term_tags|
-                next if term_tags.nil?
-                next if self.is_alternative?(id)
-                query = term_tags[obs_tag]
-                if !query.nil? && query == 'true' # Obsolete tag presence 
-                    next if !@obsoletes_index[id].nil? # Already stored
-                    # Check if alternative value is available
-                    alt_ids = alt_tags.map{|alt| term_tags[alt]}.compact
-                    if !alt_ids.empty?
-                        alt_id = alt_ids.first.first #FIRST tag, FIRST id 
-                        # Store
-                        @alternatives_index[id] = alt_id
-                        @obsoletes_index[id] = alt_id
-                    end
-                end
-            end
-        end
+    # +name+:: to be translated
+    # ===== Return
+    # translated name or nil if it's not stored into this ontology
+    def translate_name(name)
+        term = self.translate(name, :name)
+        term = self.translate(name, :synonym) if term.nil?
+        return term            
     end
 
-
-    # Expand parentals set and link all info to their alternative IDs. Also launch frequencies process
+    # Translates a given ID to it assigned name
     # ===== Parameters
-    # +tag+:: tag used to expand parentals
-    # +split_info_char+:: special regex used to split info (if it is necessary)
-    # +split_info_indx+:: special index to take splitted info (if it is necessary)
-    # ===== Returns 
-    # true if process ends without errors and false in other cases
-    def get_index_child_parent_relations(tag: @@basic_tags[:ancestors][0])
-        # Check
-        if @stanzas[:terms].nil?
-            warn('stanzas terms empty')
-        else
-            # Expand
-            structType, parentals = self.class.get_related_ids_by_tag(terms: @stanzas[:terms],
-                                                            target_tag: tag,
-                                                            alt_ids: @alternatives_index,
-                                                            obsoletes: @obsoletes_index.length)
-            # Check
-            raise('Error expanding parentals')  if (structType.nil?) || parentals.nil?
-            # Prepare ancestors structure
-            anc = {}
-            des = {}
-            parentals.each do |id, parents|
-                parents = parents - @removable_terms
-                anc[id] = parents
-                parents.each do |anc_id| # Add descendants
-                    if !des.include?(anc_id)
-                        des[anc_id] = [id]
-                    else 
-                        des[anc_id] << id
-                    end
-                end
-            end
-            # Store alternatives
-            # @alternatives_index.each do |id,alt|
-            #     anc[id] = anc[alt] if anc.include?(alt)
-            #     des[id] = des[alt] if des.include?(alt)
-            # end
-            # Check structure
-            if ![:atomic,:sparse].include? structType
-                structType = structType == :circular ? :circular : :hierarchical
-            end
-            # Store
-            @ancestors_index = anc
-            @descendants_index = des
-            @structureType = structType
-        end
-        # Finish        
+    # +id+:: to be translated
+    # ===== Return
+    # main name or nil if it's not included into this ontology
+    def translate_id(id)
+        name = self.translate(id, :name, byValue: false)
+        return name.nil? ? nil : name.first
     end
 
+    # Get term frequency and information
+    ####################################
 
-    # Find ancestors of a given term
+    # One single term #
+
+    # Get a term frequency
     # ===== Parameters
-    # +term+:: to be checked
-    # +filter_alternatives+:: if true, remove alternatives from final results
+    # +term+:: term to be checked
+    # +type+:: type of frequency to be returned. Allowed: [:struct_freq, :observed_freq]
     # ===== Returns 
-    # an array with all ancestors of given term or false if parents are not available yet
-    def get_ancestors(term, filter_alternatives = false)
-        return self.get_familiar(term, true, filter_alternatives)        
+    # frequency of term given or nil if term is not allowed
+    def get_frequency(term, type: :struct_freq)
+        queryFreq = @meta[term]
+        return queryFreq.nil? ? nil : queryFreq[type]        
     end
 
-
-    # Find descendants of a given term
+    # Geys structural frequency of a term given
     # ===== Parameters
     # +term+:: to be checked
-    # +filter_alternatives+:: if true, remove alternatives from final results
     # ===== Returns 
-    # an array with all descendants of given term or false if parents are not available yet
-    def get_descendants(term, filter_alternatives = false)
-        return self.get_familiar(term, false, filter_alternatives)        
+    # structural frequency of given term or nil if term is not allowed
+    def get_structural_frequency(term)
+        return self.get_frequency(term, type: :struct_freq)
     end
 
-
-    # Find ancestors/descendants of a given term
+    # Gets observed frequency of a term given
     # ===== Parameters
     # +term+:: to be checked
-    # +return_ancestors+:: return ancestors if true or descendants if false
-    # +filter_alternatives+:: if true, remove alternatives from final results
     # ===== Returns 
-    # an array with all ancestors/descendants of given term or nil if parents are not available yet
-    def get_familiar(term, return_ancestors = true, filter_alternatives = false)
-        # Find into parentals
-        familiars = return_ancestors ? @ancestors_index[term] : @descendants_index[term]    
-        if !familiars.nil?
-            familiars = familiars.clone
-            if filter_alternatives
-                familiars.reject!{|fm| @alternatives_index.include?(fm)}
-            end
-        else
-            familiars = []
-        end
-        return familiars
+    # observed frequency of given term or nil if term is not allowed
+    def get_observed_frequency(term)
+        return self.get_frequency(term, type: :observed_freq)
     end
 
-
     # Obtain IC of an specific term
     # ===== Parameters
     # +term+:: which IC will be calculated
@@ -789,7 +486,7 @@ class Ontology
             ###########################################
             when :seco, :zhou # SECO:: An intrinsic information content metric for semantic similarity in WordNet
                 #  1 - ( log(hypo(x) + 1) / log(max_nodes) )
-                ic = 1 - Math.log10(term_meta[:struct_freq]).fdiv(Math.log10(@stanzas[:terms].length - @alternatives_index.length))
+                ic = 1 - Math.log10(term_meta[:struct_freq]).fdiv(Math.log10(@terms.length))
                 if :zhou # New Model of Semantic Similarity Measuring in Wordnet                
                     # k*(IC_Seco(x)) + (1-k)*(log(depth(x))/log(max_depth))
                     @ics[:seco][term] = ic # Special store
@@ -803,40 +500,25 @@ class Ontology
         return ic
     end
 
+    # Term vs Term #
 
-    # Calculates and return resnik ICs (by ontology and observed frequency) for observed terms
-    # ===== Returns 
-    # two hashes with resnik and resnik_observed ICs for observed terms
-    def get_observed_ics_by_onto_and_freq
-        # Chech there are observed terms
-        if @profiles.empty?
-            resnik = {}
-            resnik_observed = {}
-        else
-            # Calc ICs for all terms
-            observed_terms = @profiles.values.flatten.uniq
-            observed_terms.each{ |term| get_IC(term)}
-            observed_terms.each{ |term| get_IC(term, type: :resnik_observed)}
-            resnik = @ics[:resnik].select{|k,v| observed_terms.include?(k)}
-            resnik_observed = @ics[:resnik_observed].select{|k,v| observed_terms.include?(k)}
+    def get_LCA(termA, termB, lca_index: false)
+        lca = []
+        if lca_index
+            res = @lca_index.dig(termA, termB)
+            lca = [res] if !res.nil?
+        else  # Obtain ancestors (include itselfs too)       
+            anc_A = self.get_ancestors(termA) 
+            anc_B = self.get_ancestors(termB)
+            if !(anc_A.empty? && anc_B.empty?)
+                anc_A << termA
+                anc_B << termB
+                lca = anc_A & anc_B
+            end
         end
-        return resnik.clone, resnik_observed.clone
-    end
-
-
-    # Find the IC of the Most Index Content shared Ancestor (MICA) of two given terms
-    # ===== Parameters
-    # +termA+:: term to be cheked
-    # +termB+:: term to be checked
-    # +ic_type+:: IC formula to be used
-    # ===== Returns 
-    # the IC of the MICA(termA,termB)
-    def get_ICMICA(termA, termB, ic_type = :resnik)
-        term, ic = self.get_MICA(termA, termB, ic_type)
-        return term.nil? ? nil : ic
+        return lca
     end
 
-
     # Find the Most Index Content shared Ancestor (MICA) of two given terms
     # ===== Parameters
     # +termA+:: term to be cheked
@@ -844,30 +526,31 @@ class Ontology
     # +ic_type+:: IC formula to be used
     # ===== Returns 
     # the MICA(termA,termB) and it's IC
-    def get_MICA(termA, termB, ic_type = :resnik)
-        termA = @alternatives_index[termA] if @alternatives_index.include?(termA)
-        termB = @alternatives_index[termB] if @alternatives_index.include?(termB)
+    def get_MICA(termA, termB, ic_type = :resnik, lca_index = false)
         mica = [nil,-1.0]
-        # Special case
-        if termA.eql?(termB)
+        if termA.eql?(termB) # Special case
             ic = self.get_IC(termA, type: ic_type)
             mica = [termA, ic]
-        else    
-            # Obtain ancestors (include itselfs too)
-            anc_A = self.get_ancestors(termA) 
-            anc_B = self.get_ancestors(termB)
-            if !(anc_A.empty? && anc_B.empty?)
-                anc_A << termA
-                anc_B << termB
-                (anc_A & anc_B).each do |anc| # Find MICA in shared ancestors
-                    ic = self.get_IC(anc, type: ic_type)
-                    mica = [anc,ic] if ic > mica[1]
-                end
+        else
+            get_LCA(termA, termB, lca_index: lca_index).each do |lca| # Find MICA in shared ancestors
+                ic = self.get_IC(lca, type: ic_type)
+                mica = [lca, ic] if ic > mica[1]
             end
         end
         return mica
     end
 
+    # Find the IC of the Most Index Content shared Ancestor (MICA) of two given terms
+    # ===== Parameters
+    # +termA+:: term to be cheked
+    # +termB+:: term to be checked
+    # +ic_type+:: IC formula to be used
+    # ===== Returns 
+    # the IC of the MICA(termA,termB)
+    def get_ICMICA(termA, termB, ic_type = :resnik)
+        term, ic = self.get_MICA(termA, termB, ic_type)
+        return term.nil? ? nil : ic
+    end
 
     # Calculate similarity between two given terms
     # ===== Parameters
@@ -877,11 +560,10 @@ class Ontology
     # +ic_type+:: IC formula to be used
     # ===== Returns 
     # the similarity between both sets or false if frequencies are not available yet
-    def get_similarity(termA, termB, type: :resnik, ic_type: :resnik)
-        # Check
+    def get_similarity(termA, termB, type: :resnik, ic_type: :resnik, lca_index: false)
         raise ArgumentError, "SIM type specified (#{type}) is not allowed" if !@@allowed_calcs[:sims].include?(type)
         sim = nil
-        mica, sim_res = get_MICA(termA, termB, ic_type)
+        mica, sim_res = get_MICA(termA, termB, ic_type, lca_index)
         if !mica.nil?
             case type
                 when :resnik
@@ -895,1631 +577,1027 @@ class Ontology
         return sim
     end
 
+    # Checking valid terms
+    ####################################
 
-    # Method used to load information stored into an OBO file and store it into this object.
-    # If a file is specified by input parameter, current @file value is updated
-    # ===== Parameters
-    # +file+:: optional file to update object stored file
-    def load(file, build: true)
-        _, header, stanzas = self.class.load_obo(file)
-        @header = header
-        @stanzas = stanzas
-        self.remove_removable()
-        # @removable_terms.each{|removableID| @stanzas[:terms].delete(removableID)} if !@removable_terms.empty? # Remove if proceed
-        self.build_index() if build
+    def term_exist?(id)
+        return @terms.include?(id)
     end
 
-    # 
-    def remove_removable()
-        @removable_terms.each{|removableID| @stanzas[:terms].delete(removableID)} if !@removable_terms.empty? # Remove if proceed
+    # Check if a term given is marked as obsolete
+    def is_obsolete?(term)
+        return @obsoletes.include?(term)
     end
 
+    #############################################
+    # ITEMS METHODS
+    #############################################
+
+    # I/O Items
+    ####################################
 
-    # Exports an OBO_Handler object in json format
+    # Store specific relations hash given into ITEMS structure
     # ===== Parameters
-    # +file+:: where info will be stored
-    def write(file)
-        # Take object stored info
-        obj_info = {header: @header,
-                    stanzas: @stanzas,
-                    ancestors_index: @ancestors_index,
-                    descendants_index: @descendants_index,
-                    alternatives_index: @alternatives_index,
-                    obsoletes_index: @obsoletes_index,
-                    structureType: @structureType,
-                    ics: @ics,
-                    meta: @meta,
-                    special_tags: @special_tags,
-                    max_freqs: @max_freqs,
-                    dicts: @dicts,
-                    profiles: @profiles,
-                    profilesDict: @profilesDict,
-                    items: @items,
-                    removable_terms: @removable_terms,
-                    term_paths: @term_paths}
-        # Convert to JSON format & write
-        File.open(file, "w") { |f| f.write obj_info.to_json }
-    end
+    # +relations+:: hash to be stored
+    # +remove_old_relations+:: substitute ITEMS structure instead of merge new relations
+    # +expand+:: if true, already stored keys will be updated with the unique union of both sets
+    def load_item_relations_to_terms(relations, remove_old_relations = false, expand = false)
+        @items = {} if remove_old_relations        
+        relations.each do |term, items| 
+            if !term_exist?(term)
+                warn('Some terms specified are not stored into this ontology. These not correct terms will be stored too')
+                break
+            end
+        end
+        if expand
+            @items = self.concatItems(@items, relations)
+        else
+            @items.merge!(relations)
+        end
+    end 
 
+    # Defining Items from instance variables
+    ########################################
 
-    def is_number? string
-          true if Float(string) rescue false
+    # Assign a dictionary already calculated as a items set.
+    # ===== Parameters
+    # +dictID+:: dictionary ID to be stored (:byTerm will be used)
+    def set_items_from_dict(dictID, remove_old_relations = false)
+        @items = {} if remove_old_relations
+        query = @dicts[dictID]
+        if !query.nil?
+            @items.merge!(query[:byTerm])
+        else
+            warn('Specified ID is not calculated. Dict will not be added as a items set')
+        end
     end
 
-
-    # Read a JSON file with an OBO_Handler object stored
+    # Get related profiles to a given term
     # ===== Parameters
-    # +file+:: with object info
-    # +file+:: if true, calculate indexes. Default: true
-    # ===== Return
-    # OBO_Handler internal fields 
-    def read(file, build: true)
-        # Read file
-        jsonFile = File.open(file)
-        jsonInfo = JSON.parse(jsonFile.read, :symbolize_names => true)
-        # Pre-process (Symbolize some hashs values)
-        if !jsonInfo[:header].nil?
-            aux = jsonInfo[:header].map do |entry,info|
-                if info.kind_of?(Array) && @@symbolizable_ids.include?(entry) 
-                    [entry,info.map{|item| item.to_sym}]
-                else
-                    [entry,info]
-                end
-            end
-            jsonInfo[:header] = aux.to_h
-        end
-        jsonInfo[:stanzas][:terms].map{|id,info| self.class.symbolize_ids(info)} # STANZAS
-        jsonInfo[:stanzas][:typedefs].map{|id,info| self.class.symbolize_ids(info)}
-        jsonInfo[:stanzas][:instances].map{|id,info| self.class.symbolize_ids(info)}
-        # Optional
-        jsonInfo[:alternatives_index] = jsonInfo[:alternatives_index].map{|id,value| [id, value.to_sym]}.to_h unless jsonInfo[:alternatives_index].nil?
-        jsonInfo[:ancestors_index].map {|id,family_arr| family_arr.map!{|item| item.to_sym}} unless jsonInfo[:ancestors_index].nil?
-        jsonInfo[:descendants_index].map {|id,family_arr| family_arr.map!{|item| item.to_sym}} unless jsonInfo[:descendants_index].nil?
-        jsonInfo[:obsoletes_index] = jsonInfo[:obsoletes_index].map{|id,value| [id, value.to_sym]}.to_h unless jsonInfo[:obsoletes_index].nil?
-        jsonInfo[:dicts] = jsonInfo[:dicts].each do |flag, dictionaries|
-            next if dictionaries.nil?
-            # Special case: byTerm
-            dictionaries[:byTerm] = dictionaries[:byTerm].map do |term, value| 
-                if !term.to_s.scan(/\A[-+]?[0-9]*\.?[0-9]+\Z/).empty?  # Numeric dictionary
-                    [term.to_s.to_i, value.map{|term| term.to_sym}]
-                elsif value.is_a? Numeric # Numeric dictionary
-                    [term.to_sym, value]
-                elsif value.kind_of?(Array) && flag == :is_a
-                    [term.to_sym, value.map{|v| v.to_sym}]
-                else
-                    [term.to_sym, value]
-                end
-            end
-            dictionaries[:byTerm] = dictionaries[:byTerm].to_h
-            # By value
-            dictionaries[:byValue] = dictionaries[:byValue].map do |value, term| 
-                if value.is_a? Numeric # Numeric dictionary
-                    [value, term.to_sym]
-                elsif term.is_a? Numeric # Numeric dictionary
-                    [value.to_s.to_sym, term]
-                elsif flag == :is_a
-                    [value.to_sym, term.map{|v| v.to_sym}]
-                elsif term.kind_of?(Array)
-                    [value.to_sym, term.map{|t| t.to_sym}]
-                else
-                    [value.to_s, term.to_sym]
-                end
-            end
-            dictionaries[:byValue] = dictionaries[:byValue].to_h
-        end 
-        if !jsonInfo[:profiles].nil?
-            jsonInfo[:profiles].map{|id,terms| terms.map!{|term| term.to_sym}}
-            jsonInfo[:profiles].keys.map{|id| jsonInfo[:profiles][id.to_s.to_i] = jsonInfo[:profiles].delete(id) if self.is_number?(id.to_s)}
-        end
-        jsonInfo[:profilesDict].map{|term,ids| ids.map!{|id| id.to_sym if !id.is_a?(Numeric)}} unless jsonInfo[:profilesDict].nil?
-        jsonInfo[:removable_terms] = jsonInfo[:removable_terms].map{|term| term.to_sym} unless jsonInfo[:removable_terms].nil?
-        jsonInfo[:special_tags] = jsonInfo[:special_tags].each do |k, v|
-            next if v.nil?
-            if v.kind_of?(Array)
-                jsonInfo[:special_tags][k] = v.map{|tag| tag.to_sym}
-            else
-                jsonInfo[:special_tags][k] = v.to_sym
-            end
+    # +term+:: to be checked
+    # ===== Returns 
+    # profiles which contains given term
+    def get_items_from_term(term)
+        return @items[term]
+    end
+
+    # For each term in profiles add the ids in the items term-id dictionary 
+    def get_items_from_profiles
+        @profiles.each do |id, terms|
+            terms.each {|term| add2hash(@items, term, id) }
         end
-        jsonInfo[:items].each{|k,v| jsonInfo[:items][k] = v.map{|item| item.to_sym}} unless jsonInfo[:items].nil?
-        jsonInfo[:term_paths].each{|term,info| jsonInfo[:term_paths][term][:paths] = info[:paths].map{|path| path.map{|t| t.to_sym}}} unless jsonInfo[:term_paths].nil?
-        
-        # Store info
-        @header = jsonInfo[:header]
-        @stanzas = jsonInfo[:stanzas]
-        @ancestors_index = jsonInfo[:ancestors_index]
-        @descendants_index = jsonInfo[:descendants_index]
-        @alternatives_index = jsonInfo[:alternatives_index]
-        @obsoletes_index = jsonInfo[:obsoletes_index]
-        jsonInfo[:structureType] = jsonInfo[:structureType].to_sym unless jsonInfo[:structureType].nil?
-        @structureType = jsonInfo[:structureType]
-        @ics = jsonInfo[:ics]
-        @meta = jsonInfo[:meta]
-        @special_tags = jsonInfo[:special_tags]
-        @max_freqs = jsonInfo[:max_freqs]
-        @dicts = jsonInfo[:dicts]
-        @profiles = jsonInfo[:profiles]
-        @profilesDict = jsonInfo[:profilesDict]
-        @items = jsonInfo[:items]
-        @removable_terms = jsonInfo[:removable_terms]
-        @term_paths = jsonInfo[:term_paths]
-
-        self.build_index() if build
-    end
-
-
-    # Check if a given ID is stored as term into this object
-    # ===== Parameters
-    # +id+:: to be checked 
-    # ===== Return
-    # True if term is allowed or false in other cases
-    def exists? id
-        return stanzas[:terms].include?(id)
     end
 
+    # Defining instance variables from items
+    ########################################
 
-    # This method assumes that a text given contains an allowed ID. And will try to obtain it splitting it
-    # ===== Parameters
-    # +text+:: to be checked 
-    # ===== Return
-    # The correct ID if it can be found or nil in other cases
-    def extract_id(text, splitBy: ' ')
-        if self.exists?(text)
-            return text
-        else
-            splittedText = text.to_s.split(splitBy).first.to_sym
-            return self.exists?(splittedText) ? splittedText : nil
+    def get_profiles_from_items
+        new_profiles = {}
+        @items.each do |term, ids|
+            ids.each{|id| add2hash(new_profiles, id, term) }
         end
+        @profiles = new_profiles        
     end
 
+    # Expanding items
+    ####################################
 
-    # Generate a bidirectinal dictionary set using a specific tag and terms stanzas set
-    # This functions stores calculated dictionary into @dicts field.
-    # This functions stores first value for multivalue tags
-    # This function does not handle synonyms for byValue dictionaries
+    # This method computes childs similarity and impute items to it parentals. To do that Item keys must be this ontology allowed terms.
+    # Similarity will be calculated by text extact similarity unless an ontology object will be provided. In this case, MICAs will be used
     # ===== Parameters
-    # +tag+:: to be used to calculate dictionary
-    # +select_regex+:: gives a regfex that can be used to modify value to be stored
-    # +substitute_alternatives+:: flag used to indicate if alternatives must, or not, be replaced by it official ID
-    # +store_tag+:: flag used to store dictionary. If nil, mandatory tag given will be used
-    # +multiterm+:: if true, byValue will allows multi-term linkage (array)
-    # +self_type_references+:: if true, program assumes that refrences will be between Ontology terms, and it term IDs will be checked
-    # ===== Return
-    # void. And stores calcualted bidirectional dictonary into dictionaries main container
-    def calc_dictionary(tag, select_regex: nil, substitute_alternatives: true, store_tag: nil, multiterm: false, self_type_references: false)
-        tag = tag.to_sym
-        store_tag = tag if store_tag.nil?
-        if @stanzas[:terms].empty?
-            warn('Terms are not already loaded. Aborting dictionary calc') 
-        else
-            byTerm = {}
-            byValue = {}
-            # Calc per term
-            @stanzas[:terms].each do |term, tags|
-                referenceTerm = term
-                if @alternatives_index.include?(term) && substitute_alternatives # Special case
-                    referenceTerm = @alternatives_index[term] if !@obsoletes_index.include?(@alternatives_index[term])
-                end
-                queryTag = tags[tag]
-                if !queryTag.nil?
-                    # Pre-process
-                    if !select_regex.nil?
-                        if queryTag.kind_of?(Array)
-                            queryTag = queryTag.map{|value| value.scan(select_regex).first}
-                            queryTag.flatten!
-                        else
-                            queryTag = queryTag.scan(select_regex).first
-                        end
-                        queryTag.compact!
-                    end
-                    if queryTag.kind_of?(Array) # Store
-                        if !queryTag.empty?
-                            if byTerm.include?(referenceTerm)
-                                byTerm[referenceTerm] = (byTerm[referenceTerm] + queryTag).uniq
-                            else
-                                byTerm[referenceTerm] = queryTag
+    # +ontology+:: (Optional) ontology object which items given belongs
+    # +minimum_childs+:: minimum of childs needed to infer relations to parental. Default: 2
+    # +clean_profiles+:: if true, clena_profiles ontology method will be used over inferred profiles. Only if an ontology object is provided
+    # ===== Returns
+    # void and update items object
+    def expand_items_to_parentals(ontology: nil, minimum_childs: 2, clean_profiles: true)
+        targetKeys = expand_profile_with_parents(@items.keys)
+        terms_per_level = list_terms_per_level(targetKeys)        
+        terms_per_level = terms_per_level.to_a.sort{|l1, l2| l1.first <=> l2.first} # Obtain sorted levels 
+        terms_per_level.pop # Leaves are not expandable # FRED: Thats comment could be not true
+
+        terms_per_level.reverse_each do |lvl, terms| # Expand from leaves to roots
+            terms.each do |term|
+                childs = self.get_descendants(term).select{|t| @items.include?(t)} # Get child with items
+                next if childs.length < minimum_childs
+                propagated_item_count = Hash.new(0)                
+                if ontology.nil? # Count how many times is presented an item in childs
+                    childs.each do |child| 
+                        @items[child].each{|i| propagated_item_count[i] += 1}
+                    end 
+                else # Count take into account similarity between terms in other ontology. Not pretty clear the full logic
+                    while childs.length > 1 
+                        curr_term = childs.shift
+                        childs.each do |child|
+                            maxmica_counts = Hash.new(0)
+                            curr_items = @items[curr_term]
+                            child_items = @items[child]
+                            curr_items.each do |item|
+                                maxmica = ontology.get_maxmica_term2profile(item, child_items)
+                                maxmica_counts[maxmica.first] += 1
                             end
-                            if multiterm
-                                queryTag.each do |value|
-                                    byValue[value] = [] if byValue[value].nil? 
-                                    byValue[value] << referenceTerm
-                                end                                
-                            else
-                                queryTag.each{|value| byValue[value] = referenceTerm}
+                            child_items.each do |item|
+                                maxmica = ontology.get_maxmica_term2profile(item, curr_items)
+                                maxmica_counts[maxmica.first] += 1
                             end
-                        end
-                    else
-                        if byTerm.include?(referenceTerm)
-                            byTerm[referenceTerm] = (byTerm[referenceTerm] + [queryTag]).uniq
-                        else
-                            byTerm[referenceTerm] = [queryTag]
-                        end
-                        if multiterm
-                            byValue[queryTag] = [] if byValue[queryTag].nil?
-                            byValue[queryTag] << referenceTerm
-                        else
-                            byValue[queryTag] = referenceTerm
-                        end
-                    end
-                end
-            end
-            
-            # Check self-references
-            if self_type_references
-                byTerm.map do |term, references|
-                    corrected_references = references.map do |t|
-                        checked = self.extract_id(t)
-                        if checked.nil?
-                            t
-                        else
-                            byValue[checked] = byValue.delete(t) if checked != t && byValue[checked].nil? # Update in byValue
-                            checked
+                            maxmica_counts.each{|t,freq| propagated_item_count[t] += freq if freq >= 2} #TODO: Maybe need Division by 2 due to the calculation of mica two times  but test fails. 
+                            # FRED: Maybe for the childs.shift there is uniqueness
                         end
                     end
-                    byTerm[term] = corrected_references.uniq
                 end
-            end
-
-            # Check order
-            byTerm.map do |term,values|
-                if self.exists?(term)
-                    referenceValue = @stanzas[:terms][term][tag]
-                    if !referenceValue.nil?
-                        if !select_regex.nil?
-                            if referenceValue.kind_of?(Array)
-                                referenceValue = referenceValue.map{|value| value.scan(select_regex).first}
-                                referenceValue.flatten!
-                            else
-                                referenceValue = referenceValue.scan(select_regex).first
-                            end
-                            referenceValue.compact!
-                        end
-                        if self_type_references
-                            if referenceValue.kind_of?(Array)
-                                aux = referenceValue.map{|t| self.extract_id(t)}
-                            else
-                                aux = self.extract_id(referenceValue)
-                            end
-                            aux.compact! unless aux.nil?
-                            referenceValue = aux unless aux.nil?
-                        end
-                        referenceValue = [referenceValue] if !referenceValue.kind_of?(Array)
-                        byTerm[term] = referenceValue + (values - referenceValue)
+                propagated_items = propagated_item_count.select{|k,v| v >= minimum_childs}.keys
+                if propagated_items.length > 0
+                    query = @items[term]
+                    if query.nil?
+                        @items[term] = propagated_items
+                    else 
+                        terms = @items[term] | propagated_items
+                        terms = ontology.clean_profile(terms) if clean_profiles && !ontology.nil?
+                        @items[term] = terms
                     end
                 end
             end
-
-            # Store
-            @dicts[store_tag] = {byTerm: byTerm, byValue: byValue}
         end
     end
 
+    # Compute modified fisher between terms and items based on topgo methodology. Refactor to use all the possible methods of this class
+    #-------------------------------------------------------------------------------------------------------------------------------------
 
-    # Calculates :is_a dictionary without alternatives substitution
-    def calc_ancestors_dictionary
-        self.calc_dictionary(:is_a, substitute_alternatives: false, self_type_references: true, multiterm: true)
+    def compute_relations_to_items(external_item_list, total_items, mode, thresold) # NEED TEST, check with PSZ how to maintain these methods
+        terms_levels = list_terms_per_level_from_items 
+        connect_familiars!(terms_levels)
+        item_list_with_transf_parental = get_item_list_parental(terms_levels)
+        results = []
+        if mode == :elim 
+            results = compute_relations_elim(terms_levels, external_item_list, total_items, thresold, item_list_with_transf_parental)
+        elsif mode == :weight
+            results = compute_relations_weight(terms_levels, external_item_list, total_items, item_list_with_transf_parental)
+        end
+        return results
     end
 
+    def list_terms_per_level_from_items
+        return list_terms_per_level(@items.keys)
+    end
 
-    # Translate a given value using an already calcualted dictionary
-    # ===== Parameters
-    # +toTranslate+:: value to be translated using dictiontionary
-    # +tag+:: used to generate the dictionary
-    # +byValue+:: boolean flag to indicate if dictionary must be used values as keys or terms as keys. Default: values as keys = true
-    # ===== Return
-    # translation
-    def translate(toTranslate, tag, byValue: true)
-        dict = byValue ? @dicts[tag][:byValue] : @dicts[tag][:byTerm]    
-        toTranslate =  get_main_id(toTranslate) if !byValue
-        return dict[toTranslate]
-    end
-
-
-    # Translate a name given
-    # ===== Parameters
-    # +name+:: to be translated
-    # ===== Return
-    # translated name or nil if it's not stored into this ontology
-    def translate_name(name)
-        term = self.translate(name, :name)
-        term = self.translate(name, :synonym) if term.nil?
-        return term            
-    end
-
-
-    # Translate several names and return translations and a list of names which couldn't be translated
-    # ===== Parameters
-    # +names+:: array to be translated
-    # ===== Return
-    # two arrays with translations and names which couldn't be translated respectively
-    def translate_names(names)
-        translated = []
-        rejected = []
-        names.each do |name|
-            tr = self.translate_name(name)
-            if tr.nil?
-                rejected << name
-            else
-                translated << tr
-            end
-        end
-        return translated, rejected
-    end
-
-
-    # Translates a given ID to it assigned name
-    # ===== Parameters
-    # +id+:: to be translated
-    # ===== Return
-    # main name or nil if it's not included into this ontology
-    def translate_id(id)
-        name = self.translate(id, :name, byValue: false)
-        return name.nil? ? nil : name.first
-    end
-
-
-    # Translates several IDs and returns translations and not allowed IDs list
-    # ===== Parameters
-    # +ids+:: to be translated
-    # ===== Return
-    # two arrays with translations and names which couldn't be translated respectively
-    def translate_ids(ids)
-        translated = []
-        rejected = []
-        ids.each do |term_id|
-            tr = self.translate_id(term_id.to_sym)
-            if !tr.nil?
-                translated << tr
-            else
-                rejected << tr
-            end
-        end
-        return translated, rejected
-    end
-
-
-    # ===== Returns 
-    # the main ID assigned to a given ID. If it's a non alternative/obsolete ID itself will be returned
-    # ===== Parameters
-    # +id+:: to be translated
-    # ===== Return
-    # main ID related to a given ID. Returns nil if given ID is not an allowed ID
-    def get_main_id(id)
-        return nil if !@stanzas[:terms].include? id
-        new_id = id
-        mainID = @alternatives_index[id]
-        new_id = mainID if !mainID.nil? & !@obsoletes_index.include?(mainID)
-        return new_id
-    end
-
-
-    # Check a pull of IDs and return allowed IDs removing which are not official terms on this ontology
-    # ===== Parameters
-    # +ids+:: to be checked
-    # ===== Return
-    # two arrays whit allowed and rejected IDs respectively
-    def check_ids(ids, substitute: true)
-        checked_codes = []
-        rejected_codes = []
-        ids.each do |id|
-            if @stanzas[:terms].include? id
-                if substitute
-                    checked_codes << self.get_main_id(id)
-                else
-                    checked_codes << id
-                end
-            else
-                rejected_codes << id
-            end
-        end
-        return checked_codes, rejected_codes
-    end
-
-
-    # Stores a given profile with an specific ID. If ID is already assigend to a profile, it will be replaced
-    # ===== Parameters
-    # +id+:: assigned to profile
-    # +terms+:: array of terms
-    # +substitute+:: subsstitute flag from check_ids
-    def add_profile(id, terms, substitute: true)
-        warn("Profile assigned to ID (#{id}) is going to be replaced") if @profiles.include? id
-        correct_terms, rejected_terms = self.check_ids(terms, substitute: substitute)
-        if !rejected_terms.empty?
-            warn('Given terms contains erroneus IDs. These IDs will be removed')
-        end
-        if id.is_a? Numeric
-            @profiles[id] = correct_terms              
-        else
-            @profiles[id.to_sym] = correct_terms  
-        end
-    end    
-
-
-    # Method used to store a pull of profiles
-    # ===== Parameters
-    # +profiles+:: array/hash of profiles to be stored. If it's an array, numerical IDs will be assigned starting at 1 
-    # +calc_metadata+:: if true, launch calc_profiles_dictionary process
-    # +reset_stored+:: if true, remove already stored profiles
-    # +substitute+:: subsstitute flag from check_ids
-    def load_profiles(profiles, calc_metadata: true, reset_stored: false, substitute: false)
-        self.reset_profiles if reset_stored
-        # Check
-        if profiles.kind_of?(Array)
-            profiles.each_with_index do |items, i|
-                self.add_profile(i, items.map {|item| item.to_sym}, substitute: substitute)
-            end
-        else # Hash
-            if !profiles.keys.select{|id| @profiles.include?(id)}.empty?
-                warn('Some profiles given are already stored. Stored version will be replaced')
-            end
-            profiles.each{|id, prof| self.add_profile(id, prof, substitute: substitute)}
-        end
-
-        self.add_observed_terms_from_profiles(reset: true)
-
-        if calc_metadata
-            self.calc_profiles_dictionary
-        end
-    end
-
-
-    # Internal method used to remove already stored profiles and restore observed frequencies
-    def reset_profiles
-        # Clean profiles storage
-        @profiles = {}
-        # Reset frequency observed
-        @meta.each{|term,info| info[:observed_freq] = 0}
-        @max_freqs[:observed_freq] = 0
-    end
-
-
-    # ===== Returns 
-    # profiles assigned to a given ID
-    # ===== Parameters
-    # +id+:: profile ID
-    # ===== Return
-    # specific profile or nil if it's not stored
-    def get_profile(id)
-        return @profiles[id]
-    end    
-
-
-    # ===== Returns 
-    # an array of sizes for all stored profiles
-    # ===== Return
-    # array of profile sizes
-    def get_profiles_sizes()
-        return @profiles.map{|id,terms| terms.length}
-    end
-
-
-    # ===== Returns 
-    # mean size of stored profiles
-    # ===== Parameters
-    # +round_digits+:: number of digits to round result. Default: 4
-    # ===== Returns 
-    # mean size of stored profiles
-    def get_profiles_mean_size(round_digits: 4)
-        sizes = self.get_profiles_sizes
-        return sizes.inject(0){|sum, n| sum + n}.fdiv(@profiles.length).round(round_digits)
-    end
-
-
-    # Calculates profiles sizes and returns size assigned to percentile given
-    # ===== Parameters
-    # +perc+:: percentile to be returned
-    # +increasing_sort+:: flag to indicate if sizes order must be increasing. Default: false
-    # ===== Returns 
-    # values assigned to percentile asked
-    def get_profile_length_at_percentile(perc=50, increasing_sort: false)
-        prof_lengths = self.get_profiles_sizes.sort
-        prof_lengths.reverse! if !increasing_sort
-        n_profiles = prof_lengths.length 
-        percentile_index = ((perc * (n_profiles - 1)).fdiv(100) - 0.5).round # Take length which not overpass percentile selected
-        percentile_index = 0 if percentile_index < 0 # Special case (caused by literal calc)
-        return prof_lengths[percentile_index]
-    end
-
-
-    # Translate a given profile to terms names
-    # ===== Parameters
-    # +prof+:: array of terms to be translated
-    # ===== Returns 
-    # array of translated terms. Can include nils if some IDs are not allowed
-    def profile_names(prof)
-        return prof.map{|term| self.translate_id(term)}
-    end
-
-
-    # Trnaslates a bunch of profiles to it sets of term names
-    # ===== Parameters
-    # +profs+:: array of profiles
-    # +asArray+:: flag to indicate if results must be returned as: true => an array of tuples [ProfID, ArrayOdNames] or ; false => hashs of translations
-    # ===== Returns 
-    # translated profiles
-    def translate_profiles_ids(profs = [], asArray: true)
-        profs = @profiles if profs.empty?
-        profs = profs.each_with_index.map{|terms, index| [index, terms]}.to_h if profs.kind_of?(Array)
-        profs_names = profs.map{|id, terms| [id, self.profile_names(terms)]}.to_h
-        return asArray ? profs_names.values : profs_names
-    end
-
-
-    # Includes as "observed_terms" all terms included into stored profiles
-    # ===== Parameters
-    # +reset+:: if true, reset observed freqs alreeady stored befor re-calculate
-    def add_observed_terms_from_profiles(reset: false)
-        @meta.each{|term, freqs| freqs[:observed_freq] = -1} if reset
-        @profiles.each{|id, terms| self.add_observed_terms(terms: terms)}
-    end
-
-
-    # Get a term frequency
-    # ===== Parameters
-    # +term+:: term to be checked
-    # +type+:: type of frequency to be returned. Allowed: [:struct_freq, :observed_freq]
-    # ===== Returns 
-    # frequency of term given or nil if term is not allowed
-    def get_frequency(term, type: :struct_freq)
-        queryFreq = @meta[term]
-        return queryFreq.nil? ? nil : queryFreq[type]        
-    end
-
-
-    # Geys structural frequency of a term given
-    # ===== Parameters
-    # +term+:: to be checked
-    # ===== Returns 
-    # structural frequency of given term or nil if term is not allowed
-    def get_structural_frequency(term)
-        return self.get_frequency(term, type: :struct_freq)
-    end
-
-
-    # Gets observed frequency of a term given
-    # ===== Parameters
-    # +term+:: to be checked
-    # ===== Returns 
-    # observed frequency of given term or nil if term is not allowed
-    def get_observed_frequency(term)
-        return self.get_frequency(term, type: :observed_freq)
-    end
-
-
-    # Calculates frequencies of stored profiles terms
-    # ===== Parameters
-    # +ratio+:: if true, frequencies will be returned as ratios between 0 and 1.
-    # +literal+:: if true, literal terms will be used to calculate frequencies instead translate alternative terms
-    # +asArray+:: used to transform returned structure format from hash of Term-Frequency to an array of tuples [Term, Frequency]
-    # +translate+:: if true, term IDs will be translated to 
-    # ===== Returns 
-    # stored profiles terms frequencies
-    def get_profiles_terms_frequency(ratio: true, literal: true, asArray: true, translate: true)
-        n_profiles = @profiles.length
-        if literal
-            freqs = {}
-            @profiles.each do |id, terms|
-                terms.each do |literalTerm|
-                    if freqs.include?(literalTerm)
-                        freqs[literalTerm] += 1
-                    else
-                        freqs[literalTerm] = 1
-                    end
-                end
-            end
-            if (ratio || translate)
-                aux_keys = freqs.keys
-                aux_keys.each do |term| 
-                    freqs[term] = freqs[term].fdiv(n_profiles) if ratio
-                    if translate
-                        tr = self.translate_id(term)
-                        freqs[tr] = freqs.delete(term) if !tr.nil?
-                    end
-                end
-            end
-            if asArray
-                freqs = freqs.map{|term, freq| [term, freq]}
-                freqs.sort!{|h1, h2| h2[1] <=> h1[1]}
-            end
-        else # Freqs translating alternatives
-            freqs = @meta.select{|id, freqs| freqs[:observed_freq] > 0}.map{|id, freqs| [id, ratio ? freqs[:observed_freq].fdiv(n_profiles) : freqs[:observed_freq]]}
-            freqs = freqs.to_h if !asArray
-            if translate
-                freqs = freqs.map do |term, freq|
-                    tr = self.translate_id(term)
-                    tr.nil? ? [term, freq] : [tr, freq]
-                end
-            end
-            if asArray
-                freqs = freqs.map{|term, freq| [term, freq]}
-                freqs.sort!{|h1, h2| h2[1] <=> h1[1]}
-            else
-                freqs = freqs.to_h
-            end
-        end
-        return freqs
-    end    
-
-
-    # Clean a given profile returning cleaned set of terms and removed ancestors term.
-    # ===== Parameters
-    # +prof+:: array of terms to be checked
-    # ===== Returns 
-    # two arrays, first is the cleaned profile and second is the removed elements array
-    def remove_ancestors_from_profile(prof)
-        ancestors = prof.map{|term| self.get_ancestors(term)}.flatten.uniq
-        redundant = prof.select{|term| ancestors.include?(term)}
-        return prof - redundant, redundant
-    end
-
-
-    # Remove alternative IDs if official ID is present. DOES NOT REMOVE synonyms or alternative IDs of the same official ID
-    # ===== Parameters
-    # +prof+:: array of terms to be checked
-    # ===== Returns 
-    # two arrays, first is the cleaned profile and second is the removed elements array
-    def remove_alternatives_from_profile(prof)
-        alternatives = prof.select{|term| @alternatives_index.include?(term)}
-        redundant = alternatives.select{|alt_id| prof.include?(@alternatives_index[alt_id])}
-        return prof - redundant, redundant
-    end
-
-
-    # Remove alternatives (if official term is present) and ancestors terms of a given profile 
-    # ===== Parameters
-    # +profile+:: profile to be cleaned
-    # +remove_alternatives+:: if true, clenaed profiles will replace already stored profiles
-    # ===== Returns 
-    # cleaned profile
-    def clean_profile(profile, remove_alternatives: true)
-        warn('Estructure is circular, behaviour could not be which is expected') if @structureType == :circular
-        terms_without_ancestors, _ = self.remove_ancestors_from_profile(profile)
-        if remove_alternatives
-            terms_without_ancestors_and_alternatices, _ = self.remove_alternatives_from_profile(terms_without_ancestors)
-        else
-            terms_without_ancestors_and_alternatices = terms_without_ancestors
+    def list_terms_per_level(terms)
+        terms_levels = {}
+        terms.each do |term| 
+          level = self.get_term_level(term)
+          add2hash(terms_levels, level, term)
         end
-        return terms_without_ancestors_and_alternatices
-    end
-
-    def clean_profile_hard(profile, options = {})
-        profile, _ = check_ids(profile)
-        profile = profile.select{|t| !is_obsolete?(t)}
-        if !options[:term_filter].nil?
-            profile.select! {|term| get_ancestors(term).include?(options[:term_filter])}
-        end 
-        profile = clean_profile(profile.uniq)
-        return profile
+        return terms_levels
     end
 
-    # Remove terms from a given profile using hierarchical info and scores set given  
-    # ===== Parameters
-    # +profile+:: profile to be cleaned
-    # +scores+:: hash with terms by keys and numerical values (scores)
-    # +byMax+:: if true, maximum scored term will be keeped, if false, minimum will be keeped
-    # +remove_without_score+:: if true, terms without score will be removed. Default: true
-    # ===== Returns 
-    # cleaned profile
-    def clean_profile_by_score(profile, scores, byMax: true, remove_without_score: true)
-        scores = scores.sort_by{|term,score| score}.to_h
-        keep = profile.map do |term|
-            if scores.include?(term)
-                parentals = [self.get_ancestors(term), self.get_descendants(term)].flatten
-                targetable = parentals.select{|parent| profile.include?(parent)}
-                if targetable.empty? 
-                    term
-                else
-                    targetable << term
-                    targets = scores.select{|term,score| targetable.include?(term)}.to_h
-                    byMax ? targets.keys.last : targets.keys.first
-                end
-            elsif remove_without_score
-                nil
-            else
-                term
+    def connect_familiars!(terms_levels)
+        levels = terms_levels.keys.sort
+        while levels.length > 1 # Process when current level has a parental level
+            level = levels.pop
+            parental_level = level - 1
+            parental_terms = terms_levels[parental_level]
+            if parental_terms.nil? # The queried parent level not exists but there is a parental level above of the non existant
+                parental_terms = [] # Initialize required parental level
+                terms_levels[parental_level] = parental_terms
+                levels << parental_level
             end
-        end
-        return keep.compact.uniq
-    end
-
-
-    # Remove alternatives (if official term is present) and ancestors terms of stored profiles 
-    # ===== Parameters
-    # +store+:: if true, clenaed profiles will replace already stored profiles
-    # +remove_alternatives+:: if true, clenaed profiles will replace already stored profiles
-    # ===== Returns 
-    # a hash with cleaned profiles
-    def clean_profiles(store: false, remove_alternatives: true)
-        cleaned_profiles = {}
-        @profiles.each{ |id, terms| cleaned_profiles[id] = self.clean_profile(terms, remove_alternatives: remove_alternatives)}
-        @profiles = cleaned_profiles if store
-        return cleaned_profiles
-    end
-
-
-    # Calculates number of ancestors present (redundant) in each profile stored
-    # ===== Returns 
-    # array of parentals for each profile
-    def parentals_per_profile
-        cleaned_profiles = self.clean_profiles(remove_alternatives: false)
-        parentals = @profiles.map{ |id, terms| terms.length - cleaned_profiles[id].length}
-        return parentals
-    end
-
-
-    def get_profile_redundancy()
-      profile_sizes = self.get_profiles_sizes
-      parental_terms_per_profile = self.parentals_per_profile# clean_profiles
-      parental_terms_per_profile = parental_terms_per_profile.map{|item| item[0]}
-      profile_sizes, parental_terms_per_profile = profile_sizes.zip(parental_terms_per_profile).sort_by{|i| i.first}.reverse.transpose
-      return profile_sizes, parental_terms_per_profile
-    end
-
-    def compute_term_list_and_childs()
-      suggested_childs = {}
-      total_terms = 0
-      terms_with_more_specific_childs = 0
-      @profiles.each do |id, terms|
-        total_terms += terms.length
-        more_specific_childs = self.get_childs_table(terms, true)
-        terms_with_more_specific_childs += more_specific_childs.select{|hpo_record| !hpo_record.last.empty?}.length #Exclude phenotypes with no childs
-        suggested_childs[id] = more_specific_childs  
-      end
-      return suggested_childs, terms_with_more_specific_childs.fdiv(total_terms)
-    end
-
-    #  Calculates mean IC of a given profile
-    # ===== Parameters
-    # +prof+:: profile to be checked
-    # +ic_type+:: ic_type to be used
-    # +zhou_k+:: special coeficient for Zhou IC method
-    # ===== Returns 
-    # mean IC for a given profile
-    def get_profile_mean_IC(prof, ic_type: :resnik, zhou_k: 0.5)
-        return prof.map{|term| self.get_IC(term, type: ic_type, zhou_k: zhou_k)}.inject(0){|sum,x| sum + x}.fdiv(prof.length)
-    end    
-
-
-    # Calculates resnik ontology, and resnik observed mean ICs for all profiles stored
-    # ===== Returns 
-    # two hashes with Profiles and IC calculated for resnik and observed resnik respectively
-    def get_profiles_resnik_dual_ICs
-        struct_ics = {}
-        observ_ics = {}
-        @profiles.each do |id, terms|
-            struct_ics[id] = self.get_profile_mean_IC(terms, ic_type: :resnik)
-            observ_ics[id] = self.get_profile_mean_IC(terms, ic_type: :resnik_observed)
-        end
-        return struct_ics.clone, observ_ics.clone
-    end    
-
-
-    # Calculates ontology structural levels for all ontology terms
-    # ===== Parameters
-    # +calc_paths+:: calculates term paths if it's not already calculated
-    # +shortest_path+:: if true, level is calculated with shortest path, largest path will be used in other cases
-    def calc_term_levels(calc_paths: false, shortest_path: true)
-        if @term_paths.empty?
-            if calc_paths
-                self.calc_term_paths
-            else
-                warn('Term paths are not already loaded. Aborting dictionary calc') 
+            terms_levels[level].each do |term|
+                path_info = @term_paths[term]
+                shortest_path_length = path_info[:shortest_path] 
+                path = path_info[:paths].select{|p| p.length == shortest_path_length}.first
+                parental = path[1] # the first elements is the term itself
+                parental_terms << parental if !parental_terms.include?(parental)
             end
         end
-        if !@term_paths.empty?
-            byTerm = {}
-            byValue = {}
-            # Calc per term
-            @term_paths.each do |term, info|
-                level = shortest_path ? info[:shortest_path] : info[:largest_path]
-                if level.nil?
-                    level = -1
-                else
-                    level = level.round(0)
-                end
-                byTerm[term] = level
-                queryLevels = byValue[level]
-                if queryLevels.nil?
-                    byValue[level] = [term]
+    end
+
+    def get_item_list_parental(terms_levels)
+        transfered_list = {}
+        parent_dict = @dicts[:is_a][:byTerm]
+        levels = terms_levels.keys.sort
+        while levels.length > 1
+            level = levels.pop
+            terms_levels[level].each do |term|
+                parents = parent_dict[term]
+                if parents.nil?
+                    next
+                elsif parents.length == 1
+                    parent = parents.first
                 else
-                    byValue[level] << term
+                    parent = (parents | terms_levels[level - 1]).first
                 end
+                term_it = @items[term]
+                parent_it = @items[parent]
+                curr_it = transfered_list[term]
+                parent_all_items = merge_groups([term_it, parent_it, curr_it])
+                transfered_list[parent] = parent_all_items if !parent_all_items.empty?
+                term_all_items = merge_groups([term_it, curr_it])
+                transfered_list[term] = term_all_items if !term_all_items.empty?
             end
-            @dicts[:level] = {byTerm: byValue, byValue: byTerm} # Note: in this case, value has multiplicity and term is unique value
-            # Update maximum depth
-            @max_freqs[:max_depth] = byValue.keys.max
         end
+        terms_levels[levels.first].each do |term| # Rescue lower level terms that not have children so they cannot receive items
+            transfered_list[term] = @items[term] if transfered_list[term].nil?
+        end
+        return transfered_list
     end
 
-
-    # Check if a term given is marked as obsolete
-    def is_obsolete? term
-        return @obsoletes_index.include?(term)
+    def merge_groups(groups)
+        return groups.compact.inject([ ]){|it, a| it | a}
     end
 
-    # Check if a term given is marked as alternative
-    def is_alternative? term
-        return @alternatives_index.include?(term)
+    def compute_relations_elim(terms_levels, external_item_list, total_items, thresold, item_list)
+        results = []
+        penalized_terms = {}
+        levels = terms_levels.keys.sort
+        levels.reverse_each do |level|
+            terms_levels[level].each do |term|
+                associated_items = item_list[term]
+                items_to_remove = penalized_terms[term]
+                items_to_remove = [] if items_to_remove.nil?
+                pval = get_fisher_exact_test(
+                    external_item_list - items_to_remove, 
+                    associated_items - items_to_remove, 
+                    #((associated_items | external_item_list) - items_to_remove).length
+                    total_items
+                    )
+                if pval <= thresold
+                    parents = get_ancestors(term) # Save the items for each parent term to remove them later in the fisher test
+                    parents.each do |prnt|
+                        query = penalized_terms[prnt]
+                        if query.nil?
+                            penalized_terms[prnt] = item_list[term].clone # We need a new array to store the following iterations
+                        else
+                            query.concat(item_list[term])
+                        end
+                    end
+                end
+                results << [term, pval]
+            end
+        end
+        return results
     end
 
-    # Find paths of a term following it ancestors and stores all possible paths for it and it's parentals.
-    # Also calculates paths metadata and stores into @term_paths
-    def calc_term_paths(only_main_terms=false)
-        self.calc_ancestors_dictionary if @dicts[:is_a].nil? # Calculate direct parentals dictionary if it's not already calculated
-        visited_terms = {} # PEDRO: To keep track of visited data, hash accesions are fast than array includes. I don't understant why use this variable instead of check @term_paths to see if the data is calculated
-        @term_paths = {}
-        if [:hierarchical, :sparse].include? @structureType
-            @stanzas[:terms].each do |term, t_attributes|
-                if !only_main_terms && (self.is_obsolete?(term) || self.is_alternative?(term))  # Special case (obsoletes)
-                    special_term = term
-                    term = self.is_obsolete?(term) ? @obsoletes_index[term] : @alternatives_index[term]
-                    @term_paths[term] = {total_paths: 0, largest_path: 0, shortest_path: 0, paths: []} if !@term_paths.include?(term)
-                    @term_paths[special_term] = @term_paths[term]
-                    visited_terms[special_term] = true
-                end
-                if !visited_terms.include?(term)
-                    # PEDRO: This code is very similar to expand_path method, but cannot be replaced by it (test fail). We must work to use this method here
-                    path_attr = @term_paths[term]
-                    if path_attr.nil?
-                        path_attr = {total_paths: 0, largest_path: 0, shortest_path: 0, paths: []} # create new path data
-                        @term_paths[term] = path_attr #save path data container
-                    end
-                    parentals = @dicts[:is_a][:byTerm][term]
-                    if parentals.nil?
-                        path_attr[:paths] << [term]
-                    else
-                        parentals.each do |direct_parental|
-                            self.expand_path(direct_parental)
-                            new_paths = @term_paths[direct_parental][:paths]
-                            path_attr[:paths].concat(new_paths.map{|path| path.clone.unshift(term)})
-                        end
-                    end                    
-                    anc = @ancestors_index[term].each{|anc| visited_terms[anc] = true} if @ancestors_index.include?(term)
-                    visited_terms[term] = true
+    def compute_relations_weight(terms_levels, external_item_list, total_items, item_list)
+        pvals = {}
+        item_weigths_per_term = Hash.new { |hash, key|  Hash.new(1) } #https://mensfeld.pl/2016/09/ruby-hash-default-value-be-cautious-when-you-use-it/
+        levels = terms_levels.keys.sort
+        levels.reverse_each do |level|
+            terms_levels[level].each do |term|
+                associated_items = item_list[term]
+                #initialize observed items in item_weigths_per_term list
+                add_items_to_weigthed_list(term, associated_items, item_weigths_per_term) if !associated_items.nil?
+                children = @dicts[:is_a][:byValue][term]
+                if children.nil?
+                    children = []
+                else
+                    children = children.select{|ch| item_weigths_per_term[ch].length > 0} # Only use children with items associated to them OR transfered to them
                 end
-                # Update metadata
-                path_attr = @term_paths[term]
-                path_attr[:total_paths] = path_attr[:paths].length
-                paths_sizes = path_attr[:paths].map{|path| path.length}
-                path_attr[:largest_path] = paths_sizes.max
-                path_attr[:shortest_path] = paths_sizes.min
+                computeTermSig(term, children, external_item_list, total_items, pvals, item_weigths_per_term)
             end
-        else
-            warn('Ontology structure must be hierarchical or sparse to calculate term levels. Aborting paths calculation')
         end
+        return pvals.to_a     
     end
 
+    def add_items_to_weigthed_list(term, associated_items, weigthed_list)
+        term_weigthing = weigthed_list[term]
+        associated_items.each{|ai| term_weigthing[ai] = 1}
+        weigthed_list[term] = term_weigthing
+    end
 
-    # Recursive function whic finds paths of a term following it ancestors and stores all possible paths for it and it's parentals
-    # ===== Parameters
-    # +curr_term+:: current visited term
-    # +visited_terms+:: already expanded terms
-    def expand_path(curr_term)
-        if !@term_paths.include?(curr_term)
-            path_attr = {total_paths: 0, largest_path: 0, shortest_path: 0, paths: []}
-            @term_paths[curr_term] = path_attr
-            direct_parentals = @dicts[:is_a][:byTerm][curr_term]
-            if direct_parentals.nil? # No parents :: End of recurrence
-                path_attr[:paths] << [curr_term]
-            else # Expand and concat
-                direct_parentals.each do |ancestor|
-                    path_attr_parental = @term_paths[ancestor]
-                    if path_attr_parental.nil? # Calculate new paths
-                        self.expand_path(ancestor) 
-                        new_paths = @term_paths[ancestor][:paths]
-                    else # Use direct_parental paths already calculated 
-                        new_paths = path_attr_parental[:paths] 
+    def computeTermSig(term, children, external_item_list, total_items, pvals, item_weigths_per_term)
+        #puts term.to_s.red
+        #puts @term_paths[term].inspect
+        #puts @dicts[:is_a][:byValue][term].inspect.light_blue
+        associated_items = item_weigths_per_term[term].keys
+        pval = get_fisher_exact_test(external_item_list, associated_items, total_items, 
+                                    'two_sided', item_weigths_per_term[term], true)
+        pvals[term] = pval
+        if children.length > 0
+            rates = {}
+            sig_child = 0
+            children.each do |child|
+                ratio = sigRatio(pvals[child], pval)
+                rates[child] = ratio 
+                sig_child += 1 if ratio >= 1
+            end
+            if sig_child == 0 # CASE 1
+                children.each do |child|
+                    current_ratio = rates[child]
+                    query_child = item_weigths_per_term[child]
+                    query_child.transform_values!{|weight| weight * current_ratio}
+                    pvals[child] = get_fisher_exact_test(external_item_list, item_weigths_per_term[child].keys, total_items, 
+                                      'two_sided', item_weigths_per_term[child], true)
+                end
+            else
+                ancs = get_ancestors(term)
+                ancs << term
+                rates.each do |ch, ratio|# CASE 2
+                    if ratio >= 1 # The child is better than parent
+                        ancs.each do |anc|
+                            query_anc = item_weigths_per_term[anc]
+                            associated_items.each do |item|
+                                query_anc[item] /= ratio # /= --> query_anc[item]/ratio
+                            end
+                        end
                     end
-                    path_attr[:paths].concat(new_paths.map{|path| path.clone.unshift(curr_term)})
                 end
+                computeTermSig(term, children - rates.keys, external_item_list, total_items, pvals, item_weigths_per_term)
             end
         end
     end
 
-
-    # Gets ontology levels calculated
-    # ===== Returns 
-    # ontology levels calculated
-    def get_ontology_levels
-        return @dicts[:level][:byTerm].clone # By term, in this case, is Key::Level, Value::Terms
+    def sigRatio(pvalA, pvalB)
+        return Math.log(pvalA)/Math.log(pvalB)
     end
 
+    # END of methods involved with compute_relations_to_items
+    #-----------------------------------------------------------------------------------
+    
+    #############################################
+    # PROFILE EXTERNAL METHODS
+    #############################################
 
-    # Gets ontology level of a specific term
-    # ===== Returns 
-    # Term level
-    def get_term_level(term)
-        return @dicts[:level][:byValue][term]
+    # I/O profile
+    ####################################
+
+    # Increase the arbitrary frequency of a given term set 
+    # ===== Parameters
+    # +terms+:: set of terms to be updated
+    # +increase+:: amount to be increased
+    # +transform_to_sym+:: if true, transform observed terms to symbols. Default: false
+    # ===== Return
+    # true if process ends without errors and false in other cases
+    def add_observed_terms(terms:, increase: 1.0, transform_to_sym: false, expand2parentals: true)
+        terms = terms.map{|term| [term] + get_ancestors(term.to_sym)}.flatten if expand2parentals
+        return terms.map{|id| self.add_observed_term(
+            term: transform_to_sym ? id.to_sym : id, 
+            increase: increase)} # FRED: It is necessary the return?
     end
 
-    # nil, term not found, [] term exists but not has parents
-    def get_parental_path(term, which_path = :shortest_path, level = 0)
-        path = nil
-        path_attr = @term_paths[term]
-        if !path_attr.nil?
-            path_length = path_attr[which_path]
-            all_paths = path_attr[:paths]
-            if all_paths.empty?
-                path = []
-            else
-                path = all_paths.select{|pt| pt.length == path_length}.first.clone
-                if level > 0 # we want the term and his ascendants until a specific level
-                    n_parents = path_length - level 
-                    path = path[0..n_parents]
-                end
-                path.shift # Discard the term itself
-            end
+    # Modifying Profile
+    ####################################
+
+    def expand_profile_with_parents(profile)
+        new_terms = []
+        profile.each do |term|
+            new_terms = new_terms | get_ancestors(term)
         end
-        return path
-    end
+        return new_terms | profile
+    end     
 
-    # Return ontology levels from profile terms
+    # Clean a given profile returning cleaned set of terms and removed ancestors term.
+    # ===== Parameters
+    # +prof+:: array of terms to be checked
     # ===== Returns 
-    # hash of term levels (Key: level; Value: array of term IDs)
-    def get_ontology_levels_from_profiles(uniq = true) # TODO: remove uniq and check dependencies
-        profiles_terms = @profiles.values.flatten
-        profiles_terms.uniq! if uniq
-        term_freqs_byProfile = {}
-        profiles_terms.each do |term|
-            query = term_freqs_byProfile[term]
-            if query.nil?
-                term_freqs_byProfile[term] = 1
-            else
-                term_freqs_byProfile[term] += 1
-            end
-        end
-        levels_filtered = @dicts[:level][:byTerm].map{|level, terms| [level,terms.map{|t| profiles_terms.include?(t) ? Array.new(term_freqs_byProfile[t], t) : nil}.flatten.compact]}.select{|level, filteredTerms| !filteredTerms.empty?}.to_h
-        return levels_filtered
+    # two arrays, first is the cleaned profile and second is the removed elements array
+    def remove_ancestors_from_profile(prof) 
+        ancestors = prof.map{|term| self.get_ancestors(term)}.flatten.uniq
+        redundant = prof & ancestors
+        return prof - redundant, redundant
     end
 
-    def get_profile_ontology_distribution_tables
-      cohort_ontology_levels = get_ontology_levels_from_profiles(uniq=false)
-      uniq_cohort_ontology_levels = get_ontology_levels_from_profiles
-      hpo_ontology_levels = get_ontology_levels
-      total_ontology_terms = hpo_ontology_levels.values.flatten.length
-      total_cohort_terms = cohort_ontology_levels.values.flatten.length
-      total_uniq_cohort_terms = uniq_cohort_ontology_levels.values.flatten.length
+    # Remove alternative IDs if official ID is present. DOES NOT REMOVE synonyms or alternative IDs of the same official ID
+    # ===== Parameters
+    # +prof+:: array of terms to be checked
+    # ===== Returns 
+    # two arrays, first is the cleaned profile and second is the removed elements array
+    def remove_alternatives_from_profile(prof) 
+        alternatives = prof.select{|term| @alternatives_index.include?(term)}
+        redundant = alternatives.select{|alt_id| prof.include?(@alternatives_index[alt_id])}
+        return prof - redundant, redundant
+    end
 
-      ontology_levels = []
-      distribution_percentage = []
-      hpo_ontology_levels.each do |level, terms|
-        cohort_terms = cohort_ontology_levels[level]
-        uniq_cohort_terms = uniq_cohort_ontology_levels[level]
-        if cohort_terms.nil? || uniq_cohort_terms.nil?
-          num = 0
-          u_num = 0
-        else
-          num = cohort_terms.length
-          u_num = uniq_cohort_terms.length
-        end
-        ontology_levels << [level, terms.length, num]
-        distribution_percentage << [
-          level,
-          (terms.length.fdiv(total_ontology_terms)*100).round(3),
-          (num.fdiv(total_cohort_terms)*100).round(3),
-          (u_num.fdiv(total_uniq_cohort_terms)*100).round(3)
-        ]
-      end
-      ontology_levels.sort! { |x,y| x.first <=> y.first }
-      distribution_percentage.sort! { |x,y| x.first <=> y.first }
-      return ontology_levels, distribution_percentage
+    # Remove alternatives (if official term is present) and ancestors terms of a given profile 
+    # ===== Parameters
+    # +profile+:: profile to be cleaned
+    # +remove_alternatives+:: if true, clenaed profiles will replace already stored profiles
+    # ===== Returns 
+    # cleaned profile
+    def clean_profile(profile, remove_alternatives: true) 
+        warn('Estructure is circular, behaviour could not be which is expected') if @structureType == :circular
+        terms_without_ancestors, _ = remove_ancestors_from_profile(profile)    
+        terms_without_ancestors, _ = remove_alternatives_from_profile(terms_without_ancestors) if remove_alternatives
+        return terms_without_ancestors
     end
 
-    def get_dataset_specifity_index(mode)
-        ontology_levels, distribution_percentage = get_profile_ontology_distribution_tables
-        if mode == 'uniq'
-            observed_distribution = 3
-        elsif mode == 'weigthed'
-            observed_distribution = 2
-        end
-        max_terms = distribution_percentage.map{|row| row[1]}.max
-        maxL = nil 
-        distribution_percentage.each do |level_info|
-            maxL = level_info.first if level_info[1] == max_terms
-        end
-        diffL = distribution_percentage.map{|l| [l[0], l[observed_distribution] - l[1]]}
-        diffL.select!{|dL| dL.last > 0}
-        lowSection = diffL.select{|dL| dL.first <= maxL}
-        highSection = diffL.select{|dL| dL.first > maxL}
-        dsi = nil
-        if highSection.empty?
-            dsi = 0
-        else
-            accumulated_weigth = 0
-            accumulated_weigthed_diffL = 0
-            hss = get_weigthed_level_contribution(highSection, maxL, ontology_levels.length - maxL)
-            lss = get_weigthed_level_contribution(lowSection, maxL, maxL)
-            dsi = hss.fdiv(lss)
-        end
-        return dsi
+    def clean_profile_hard(profile, options = {})
+        profile, _ = check_ids(profile)
+        profile = profile.select{|t| !is_obsolete?(t)} 
+        if !options[:term_filter].nil?
+            profile.select! {|term| get_ancestors(term).include?(options[:term_filter])}
+        end 
+        profile = clean_profile(profile.uniq)
+        return profile
     end
 
-    def get_weigthed_level_contribution(section, maxL, nLevels)
-        accumulated_weigthed_diffL = 0
-        section.each do |level, diff|
-            weightL = maxL - level 
-            if weightL >= 0
-                weightL += 1
+    # Remove terms from a given profile using hierarchical info and scores set given  
+    # ===== Parameters
+    # +profile+:: profile to be cleaned
+    # +scores+:: hash with terms by keys and numerical values (scores)
+    # +byMax+:: if true, maximum scored term will be keeped, if false, minimum will be keeped
+    # +remove_without_score+:: if true, terms without score will be removed. Default: true
+    # ===== Returns 
+    # cleaned profile
+    def clean_profile_by_score(profile, scores, byMax: true, remove_without_score: true) 
+        scores = scores.sort_by{|term,score| score}.to_h
+        keep = profile.map do |term|
+            if scores.include?(term)
+                parentals = [self.get_ancestors(term), self.get_descendants(term)].flatten
+                targetable = parentals.select{|parent| profile.include?(parent)}
+                if targetable.empty? 
+                    term
+                else
+                    targetable << term
+                    targets = scores.select{|term,score| targetable.include?(term)}.to_h
+                    byMax ? targets.keys.last : targets.keys.first
+                end
+            elsif remove_without_score
+                nil
             else
-                weightL = weightL.abs
+                term
             end
-            accumulated_weigthed_diffL += diff * weightL
         end
-        weigthed_contribution = accumulated_weigthed_diffL.fdiv(nLevels)
-        return weigthed_contribution
+        return keep.compact.uniq
     end
 
+    # ID Handlers
+    #################################### 
 
-    # Calculate profiles dictionary with Key= Term; Value = Profiles
-    def calc_profiles_dictionary
-        if @profiles.empty?
-            warn('Profiles are not already loaded. Aborting dictionary calc')
-        else
-            byTerm = {} # Key: Terms
-            # byValue -- Key: Profile == @profiles
-            @profiles.each do |id, terms|
-                terms.each do |term|
-                    if byTerm.include?(term)
-                        byTerm[term] << id
-                    else
-                        byTerm[term] = [id]
-                    end
+    # Check a set of IDs and return allowed IDs removing which are not official terms on this ontology
+    # ===== Parameters
+    # +ids+:: to be checked
+    # ===== Return
+    # two arrays whit allowed and rejected IDs respectively
+    def check_ids(ids, substitute: true) 
+        checked_codes = []
+        rejected_codes = []
+        ids.each do |id|
+            new_id = get_main_id(id)
+            if new_id.nil?
+                rejected_codes << id
+            else
+                if substitute
+                    checked_codes << new_id
+                else
+                    checked_codes << id
                 end
             end
-            @profilesDict = byTerm
         end
+        return checked_codes, rejected_codes
     end
 
 
-    # Gets profiles dictionary calculated
+    # Translates several IDs and returns translations and not allowed IDs list
+    # ===== Parameters
+    # +ids+:: to be translated
     # ===== Return
-    # profiles dictionary (clone)
-    def get_terms_linked_profiles
-        return @profilesDict.clone
-    end    
-
+    # two arrays with translations and ids which couldn't be translated respectively
+    def translate_ids(ids)
+        translated = []
+        rejected = []
+        ids.each do |term_id|
+            tr = self.translate_id(term_id.to_sym)
+            if !tr.nil?
+                translated << tr # FRED: Why have this a different behaviour from ...->
+            else
+                rejected << tr
+            end
+        end
+        return translated, rejected
+    end
 
-    # Get related profiles to a given term
+    # Translate several names and return translations and a list of names which couldn't be translated
     # ===== Parameters
-    # +term+:: to be checked
-    # ===== Returns 
-    # profiles which contains given term
-    def get_term_linked_profiles(term)
-        return @profilesDict[term]
+    # +names+:: array to be translated
+    # ===== Return
+    # two arrays with translations and names which couldn't be translated respectively
+    def translate_names(names) 
+        translated = []
+        rejected = []
+        names.each do |name|
+            tr = self.translate_name(name)
+            if tr.nil?
+                rejected << name # FRED: <-... this?
+            else
+                translated << tr
+            end
+        end
+        return translated, rejected
     end
 
+    # Description of profile's terms
+    ####################################
 
     # Gets metainfo table from a set of terms
     # ===== Parameters
     # +terms+:: IDs to be expanded
-    # +filter_alternatives+:: flag to be used in get_descendants method
     # ===== Returns 
     # an array with triplets [TermID, TermName, DescendantsNames]
-    def get_childs_table(terms, filter_alternatives = false)
-        expanded_terms = []
-        terms.each do |t|
-            expanded_terms << [[t, self.translate_id(t)], self.get_descendants(t, filter_alternatives).map{|child| [child, self.translate_id(child)]}]
+    def get_childs_table(profile)
+        expanded_profile = []
+        profile.each do |t|
+            expanded_profile << [[t, translate_id(t)], get_descendants(t).map{|child| [child, translate_id(child)]}]
         end
-        return expanded_terms
+        return expanded_profile
     end
 
+    def get_terms_levels(profile)
+        termsAndLevels = []
+        profile.each do |term|
+            termsAndLevels << [term, get_term_level(term)]
+        end
+        return termsAndLevels
+    end      
 
-    # Store specific relations hash given into ITEMS structure
+    # IC data
+    ####################################
+
+    # Get information coefficient from profiles #
+    
+    #  Calculates mean IC of a given profile
     # ===== Parameters
-    # +relations+:: hash to be stored
-    # +remove_old_relations+:: substitute ITEMS structure instead of merge new relations
-    # +expand+:: if true, already stored keys will be updated with the unique union of both sets
-    def load_item_relations_to_terms(relations, remove_old_relations = false, expand = false)
-        @items = {} if remove_old_relations
-        if !relations.select{|term, items| !@stanzas[:terms].include?(term)}.empty?
-            warn('Some terms specified are not stored into this ontology. These not correct terms will be stored too')
-        end
-        if !remove_old_relations
-            if !relations.select{|term, items| @items.include?(term)}.empty? && !expand
-                warn('Some terms given are already stored. Stored version will be replaced')
+    # +prof+:: profile to be checked
+    # +ic_type+:: ic_type to be used
+    # +zhou_k+:: special coeficient for Zhou IC method
+    # ===== Returns 
+    # mean IC for a given profile
+    def get_profile_mean_IC(prof, ic_type: :resnik, zhou_k: 0.5)
+        return prof.map{|term| self.get_IC(term, type: ic_type, zhou_k: zhou_k)}.sum.fdiv(prof.length)
+    end
+
+    # Term ref vs profile #
+
+    def get_maxmica_term2profile(ref_term, profile)
+        micas = profile.map{|term| get_MICA(ref_term, term)}
+        maxmica = micas.first
+        micas.each{|mica| maxmica = mica if mica.last > maxmica.last}
+        return maxmica
+    end
+
+    # Profile vs Profile #
+
+    # Get semantic similarity from two term sets 
+    # ===== Parameters
+    # +termsA+:: set to be compared
+    # +termsB+:: set to be compared
+    # +sim_type+:: similitude method to be used. Default: resnik
+    # +ic_type+:: ic type to be used. Default: resnik
+    # +bidirectional+:: calculate bidirectional similitude. Default: false
+    # ===== Return
+    # similitude calculated
+    def compare(termsA, termsB, sim_type: :resnik, ic_type: :resnik, bidirectional: true, store_mica: false)
+        # Check
+        raise ArgumentError, "Terms sets given are NIL" if termsA.nil? | termsB.nil?
+        raise ArgumentError, "Set given is empty. Aborting similarity calc" if termsA.empty? | termsB.empty?
+        micasA = []
+        # Compare A -> B
+        termsA.each do |tA|
+            micas = []
+            termsB.each do |tB|
+                if store_mica
+                    value = @mica_index[tA][tB]
+                else
+                    value = self.get_similarity(tA, tB, type: sim_type, ic_type: ic_type)
+                end
+                micas << value if value.class == Float 
             end
+            !micas.empty? ? micasA << micas.max : micasA << 0 
         end
-        if expand
-            @items = self.concatItems(@items,relations)
-            # relations.each do |k,v| # MUST UPDATE THIS USING A CONCAT SPECIFIC FUNCTION
-            #     if @items.keys.include?(k)
-            #         if v.kind_of?(Array)
-            #             @items[k] = (@items[k] + v).uniq
-            #         elsif v.kind_of?(Hash)
-            #             @items.merge!(relations) do |k, oldV, newV| 
-            #                if oldV.kind_of?(Array)
-            #                  return (oldV + newV).uniq
-            #                else
-            #                  oldV = [oldV,newV]
-            #                end  
-            #             end
-            #         elsif @items[k].kind_of?(Array) # We suppose a single value/object from here
-            #             @items[k] = (@items[k] + [v]).uniq
-            #         else
-            #             @items[k] = [@items[k],v]
-            #         end 
-            #     else
-            #         @items[k] = v
-            #     end
-            # end
-        else
-            @items.merge!(relations)
+        means_sim = micasA.sum.fdiv(micasA.size)
+        # Compare B -> A
+        if bidirectional
+            means_simA = means_sim * micasA.size
+            means_simB = self.compare(termsB, termsA, sim_type: sim_type, ic_type: ic_type, bidirectional: false, store_mica: store_mica) * termsB.size
+            means_sim = (means_simA + means_simB).fdiv(termsA.size + termsB.size)
         end
-    end 
+        # Return
+        return means_sim
+    end
 
-    # Internal function to concat two elements.
+
+    #############################################
+    # PROFILE INTERNAL METHODS 
+    #############################################
+
+    # I/O profiles
+    ####################################
+
+    # Method used to store a pool of profiles
     # ===== Parameters
-    # +itemA+:: item to be concatenated
-    # +itemB+:: item to be concatenated
-    # ===== Returns
-    # Concatenated objects
-    def concatItems(itemA,itemB)
-        # A is Array :: RETURN ARRAY
-            # A_array : B_array
-            # A_array : B_hash => NOT ALLOWED
-            # A_array : B_single => NOT ALLOWED
-        # A is Hash :: RETURN HASH
-            # A_hash : B_array => NOT ALLOWED
-            # A_hash : B_hash
-            # A_hash : B_single => NOT ALLOWED
-        # A is single element => RETURN ARRAY
-            # A_single : B_array
-            # A_single : B_hash => NOT ALLOWED
-            # A_single : B_single
-        concatenated = nil
-        if itemA.kind_of?(Array) && itemB.kind_of?(Array)
-            concatenated = (itemA + itemB).uniq
-        elsif itemA.kind_of?(Hash) && itemB.kind_of?(Hash)
-            concatenated = itemA.merge(itemB) do |k, oldV, newV| 
-                self.concatItems(oldV,newV)
+    # +profiles+:: array/hash of profiles to be stored. If it's an array, numerical IDs will be assigned starting at 1 
+    # +calc_metadata+:: if true, launch get_items_from_profiles process
+    # +reset_stored+:: if true, remove already stored profiles
+    # +substitute+:: subsstitute flag from check_ids
+    def load_profiles(profiles, calc_metadata: true, reset_stored: false, substitute: false)
+        self.reset_profiles if reset_stored
+        # Check
+        if profiles.kind_of?(Array)
+            profiles.each_with_index do |items, i|
+                self.add_profile(i, items.map {|item| item.to_sym}, substitute: substitute)
             end
-        elsif itemB.kind_of?(Array)
-            concatenated = ([itemA] + itemB).uniq
-        elsif ![Array, Hash].include?(itemB.class)
-            concatenated = [itemA,itemB].uniq
+        else # Hash
+            if !profiles.keys.select{|id| @profiles.include?(id)}.empty?
+                warn('Some profiles given are already stored. Stored version will be replaced')
+            end
+            profiles.each{|id, prof| self.add_profile(id, prof, substitute: substitute)}
         end
-        return concatenated
-    end      
 
+        self.add_observed_terms_from_profiles(reset: true)
 
-    # Assign a dictionary already calculated as a items set.
-    # ===== Parameters
-    # +dictID+:: dictionary ID to be stored (:byTerm will be used)
-    def set_items_from_dict(dictID, remove_old_relations = false)
-        @items = {} if remove_old_relations
-        if !@dicts[dictID].nil?
-            @items.merge(@dicts[dictID][:byTerm])
-        else
-            warn('Specified ID is not calculated. Dict will not be added as a items set')
+        if calc_metadata
+            self.get_items_from_profiles
         end
     end
 
-
-    # This method computes childs similarity and impute items to it parentals. To do that Item keys must be this ontology allowed terms.
-    # Similarity will be calculated by text extact similarity unless an ontology object will be provided. In this case, MICAs will be used
+    # Stores a given profile with an specific ID. If ID is already assigend to a profile, it will be replaced
     # ===== Parameters
-    # +ontology+:: (Optional) ontology object which items given belongs
-    # +minimum_childs+:: minimum of childs needed to infer relations to parental. Default: 2
-    # +clean_profiles+:: if true, clena_profiles ontology method will be used over inferred profiles. Only if an ontology object is provided
-    # ===== Returns
-    # void and update items object
-    def expand_items_to_parentals(ontology: nil, minimum_childs: 2, clean_profiles: true)
-        # Check item keys
-        if @items.empty?
-            warn('Items have been not provided yet')
-            return nil
-        end
-        targetKeys = @items.keys.select{|k| self.exists?(k)}
-        if targetKeys.length == 0
-            warn('Any item key is allowed')
-            return nil
-        elsif targetKeys.length < @items.keys.length
-            warn('Some item keys are not allowed')
-        end
-
-        # Expand to parentals
-        targetKeys << targetKeys.map{|t| self.get_ancestors(t, true)}
-        targetKeys.flatten!
-        targetKeys.uniq!
-
-        # Obtain levels (go from leaves to roots)
-        levels = targetKeys.map{|term| self.get_term_level(term)}
-        levels.compact!
-        levels.uniq!
-        levels.sort!
-        levels.reverse!
-        levels.shift # Leaves are not expandable
-
-        # Expand from leaves to roots
-        levels.map do |lvl|
-            curr_keys = targetKeys.select{|k| self.get_term_level(k) == lvl}
-            curr_keys.map do |term_expand|
-                to_infer = []
-                # Obtain childs
-                childs = self.get_descendants(term_expand,true).select{|t| !@items[t].nil?}
-                # Expand
-                if childs.length > 0 && minimum_childs == 1 # Special case
-                    to_infer = childs.map{|c| @items[c]}.flatten.compact.uniq
-                elsif childs.length >= minimum_childs
-                    to_infer = Hash.new(0)
-                    # Compare
-                    while childs.length > 1
-                        curr_term = childs.shift
-                        childs.each do |compare_term|
-                            pivot_items = @items[curr_term]
-                            compare_items = @items[compare_term]
-                            if ontology.nil? # Exact match
-                                pivot_items.map do |pitem|
-                                    if compare_items.include?(pitem)
-                                        to_infer[pitem] += 2
-                                    end
-                                end
-                            else # Find MICAs
-                                local_infer = Hash.new(0)
-                                pivot_items.map do |pitem|
-                                    micas = compare_items.map{|citem| ontology.get_MICA(pitem, citem)}
-                                    maxmica = micas[0]
-                                    micas.each{|mica| maxmica = mica if mica.last > maxmica.last}
-                                    local_infer[maxmica.first] += 1
-                                end
-                                compare_items.map do |citem|
-                                    micas = pivot_items.map{|pitem| ontology.get_MICA(pitem, citem)}
-                                    maxmica = micas[0]
-                                    micas.each{|mica| maxmica = mica if mica.last > maxmica.last}
-                                    local_infer[maxmica.first] += 1
-                                end
-                                local_infer.each{|t,freq| to_infer[t] += freq if freq >= 2}
-                            end
-                        end
-                    end
-                    # Filter infer
-                    to_infer = to_infer.select{|k,v| v >= minimum_childs}
-                end
-                # Infer
-                if to_infer.length > 0
-                    @items[term_expand] = [] if @items[term_expand].nil?
-                    if to_infer.kind_of?(Array)
-                        @items[term_expand] = (@items[term_expand] + to_infer).uniq
-                    else
-                        @items[term_expand] = (@items[term_expand] + to_infer.keys).uniq
-                    end
-                    @items[term_expand] = ontology.clean_profile(@items[term_expand]) if clean_profiles && !ontology.nil?
-                elsif !@items.include?(term_expand)
-                    targetKeys.delete(term_expand)
-                end
-            end
+    # +id+:: assigned to profile
+    # +terms+:: array of terms
+    # +substitute+:: subsstitute flag from check_ids
+    def add_profile(id, terms, substitute: true) # FRED: Talk with PSZ about the uniqness of IDs translated
+        warn("Profile assigned to ID (#{id}) is going to be replaced") if @profiles.include? id
+        correct_terms, rejected_terms = self.check_ids(terms, substitute: substitute)
+        if !rejected_terms.empty?
+            warn("Given terms contains erroneus IDs: #{rejected_terms.join(",")}. These IDs will be removed")
         end
-    end
+        if id.is_a? Numeric
+            @profiles[id] = correct_terms              
+        else
+            @profiles[id.to_sym] = correct_terms  
+        end
+    end   
 
 
-    # Return direct ancestors/descendants of a given term
+    # Includes as "observed_terms" all terms included into stored profiles
     # ===== Parameters
-    # +term+:: which are requested
-    # +relation+:: can be :ancestor or :descendant 
-    # +remove_alternatives+:: if true, alternatives will be removed
-    # ===== Returns
-    # Direct ancestors/descendants of given term or nil if any error occurs
-    def get_direct_related(term, relation, remove_alternatives: false)
-        if @dicts[:is_a].nil?
-            warn("Hierarchy dictionary is not already calculated. Returning nil")
-            return nil
-        end 
-        target = nil
-        case relation
-            when :ancestor
-                target = :byTerm
-            when :descendant
-                target = :byValue
-            else
-                warn('Relation type not allowed. Returning nil')
-        end
-        return nil if target.nil? 
-        query = @dicts[:is_a][target][term]
-        return query if query.nil?
-        query, _ = remove_alternatives_from_profile(query) if remove_alternatives
-        return query
+    # +reset+:: if true, reset observed freqs alreeady stored befor re-calculate
+    def add_observed_terms_from_profiles(reset: false)
+        @meta.each{|term, freqs| freqs[:observed_freq] = -1} if reset
+        @profiles.each{|id, terms| self.add_observed_terms(terms: terms)}
     end
 
-
-    # Return direct ancestors of a given term
+    # ===== Returns 
+    # profiles assigned to a given ID
     # ===== Parameters
-    # +term+:: which ancestors are requested
-    # +remove_alternatives+:: if true, alternatives will be removed
-    # ===== Returns
-    # Direct ancestors of given term or nil if any error occurs
-    def get_direct_ancentors(term, remove_alternatives: false)
-        return self.get_direct_related(term, :ancestor, remove_alternatives: remove_alternatives)
+    # +id+:: profile ID
+    # ===== Return
+    # specific profile or nil if it's not stored
+    def get_profile(id)
+        return @profiles[id]
     end
 
-    # Return direct descendants of a given term
-    # ===== Parameters
-    # +term+:: which descendants are requested
-    # +remove_alternatives+:: if true, alternatives will be removed
-    # ===== Returns
-    # Direct descendants of given term or nil if any error occurs
-    def get_direct_descendants(term, remove_alternatives: false)
-        return self.get_direct_related(term, :descendant, remove_alternatives: remove_alternatives)        
+    # Modifying profiles
+    ####################################
+
+    def reset_profiles # Internal method used to remove already stored profiles and restore observed frequencies #TODO FRED: Modify test for this method.
+        @profiles = {} # Clean profiles storage
+        # Reset frequency observed
+        @meta.each{|term,info| info[:observed_freq] = 0}
+        @max_freqs[:observed_freq] = 0
+        @items = {}
     end
 
-    def each(att = false)
-        @stanzas[:terms].each do |id, tags|            
-            next if @alternatives_index.include?(id)
-            if att
-               yield(id, tags)
-            else
-               yield(id)
+    def expand_profiles(meth, unwanted_terms: [], calc_metadata: true, ontology: nil, minimum_childs: 1, clean_profiles: true)
+        if meth == 'parental'
+            @profiles.each do |id, terms|
+                @profiles[id] = expand_profile_with_parents(terms) - unwanted_terms
             end
+            get_items_from_profiles if calc_metadata
+        elsif meth == 'propagate'
+            get_items_from_profiles
+            expand_items_to_parentals(ontology: ontology, minimum_childs: minimum_childs, clean_profiles: clean_profiles)
+            get_profiles_from_items
         end
+        add_observed_terms_from_profiles(reset: true)        
     end
 
-    def list_term_attributes
-        terms = []
-        each do |code|
-            terms << [code, translate_id(code), get_term_level(code)]
-        end
-        return terms
+    # Remove alternatives (if official term is present) and ancestors terms of stored profiles 
+    # ===== Parameters
+    # +store+:: if true, clenaed profiles will replace already stored profiles
+    # +remove_alternatives+:: if true, clenaed profiles will replace already stored profiles
+    # ===== Returns 
+    # a hash with cleaned profiles
+    def clean_profiles(store: false, remove_alternatives: true)
+        cleaned_profiles = {}
+        @profiles.each{ |id, terms| cleaned_profiles[id] = self.clean_profile(terms, remove_alternatives: remove_alternatives)}
+        @profiles = cleaned_profiles if store
+        return cleaned_profiles
     end
 
-#============================================================================
-#============================================================================
+    # ID Handlers
+    ####################################
 
-    # NO IDEA WHAT THIS DOES. DON'T USE THIS METHODS IS NOT CHECKED
+    # Trnaslates a bunch of profiles to it sets of term names
     # ===== Parameters
-    # ++::
-    # ===== Returns
-    # ...
-     def compute_relations_to_items(external_item_list, total_items, mode, thresold)
-        terms_levels = list_terms_per_level_from_items 
-        #puts terms_levels.inspect.yellow
-        connect_familiars!(terms_levels)
-        #puts terms_levels.inspect.blue
-        item_list_with_transf_parental = get_item_list_parental(terms_levels)
-        results = []
-        if mode == :elim 
-            results = compute_relations_elim(terms_levels, external_item_list, total_items, thresold, item_list_with_transf_parental)
-        elsif mode == :weight
-            results = compute_relations_weight(terms_levels, external_item_list, total_items, item_list_with_transf_parental)
-        end
-        return results
-    end
-
-    def get_item_list_parental(terms_levels)
-        transfered_list = {}
-        parent_dict = @dicts[:is_a][:byTerm]
-        levels = terms_levels.keys.sort
-        while levels.length > 1
-            level = levels.pop
-            terms_levels[level].each do |term|
-                parents = parent_dict[term]
-                if parents.nil?
-                    next
-                elsif parents.length == 1
-                    parent = parents.first
-                else
-                    parent = (parents | terms_levels[level - 1]).first
-                end
-                term_it = @items[term]
-                parent_it = @items[parent]
-                curr_it = transfered_list[term]
-                parent_all_items = merge_groups([term_it, parent_it, curr_it])
-                transfered_list[parent] = parent_all_items if !parent_all_items.empty?
-                term_all_items = merge_groups([term_it, curr_it])
-                transfered_list[term] = term_all_items if !term_all_items.empty?
-            end
+    # +profs+:: array of profiles
+    # +asArray+:: flag to indicate if results must be returned as: true => an array of tuples [ProfID, ArrayOdNames] or ; false => hashs of translations
+    # ===== Returns 
+    # translated profiles
+    def translate_profiles_ids(profs = [], asArray: true)
+        profs2proc = {}
+        if profs.empty?
+            profs2proc = @profiles 
+        else
+            profs.each_with_index{|terms, index| profs2proc[index] = terms} if profs.kind_of?(Array)
         end
-        terms_levels[levels.first].each do |term| # Rescue lower level terms that not have children so they cannot receive items
-            transfered_list[term] = @items[term] if transfered_list[term].nil?
+        profs_names = {}
+        profs2proc.each do |id, terms|
+            names, _ = translate_ids(terms)
+            profs_names[id] = names
         end
-        return transfered_list
+        return asArray ? profs_names.values : profs_names
     end
 
-    def merge_groups(groups)
-        return groups.compact.inject([]){|it, a| it | a}
+    # Description of profile size
+    ####################################
+
+    def profile_stats 
+      stats = Hash.new(0)
+      data = get_profiles_sizes
+      stats[:average] = data.sum().fdiv(data.size)
+      sum_devs = data.sum{|element| (element - stats[:average]) ** 2}
+      stats[:variance] = sum_devs.fdiv(data.size)
+      stats[:standardDeviation] = stats[:variance] ** 0.5
+      stats[:max] = data.max
+      stats[:min] = data.min
+
+      stats[:count] = data.size
+      data.each do |value|
+        stats[:countNonZero] += 1 if value != 0
+      end
+
+      stats[:q1] = data.get_quantiles(0.25)
+      stats[:median] = data.get_quantiles(0.5)
+      stats[:q3] = data.get_quantiles(0.75)
+      return stats
+
     end
 
-    def list_terms_per_level_from_items
-        terms_levels = {}
-        @items.each do |term, items| 
-          level = self.get_term_level(term)
-          query = terms_levels[level]
-          if query.nil?
-            terms_levels[level] = [term]
-          else
-            query << term
-          end
-        end
-        return terms_levels
+    # ===== Returns 
+    # mean size of stored profiles
+    # ===== Parameters
+    # +round_digits+:: number of digits to round result. Default: 4
+    # ===== Returns 
+    # mean size of stored profiles
+    def get_profiles_mean_size(round_digits: 4)
+        sizes = self.get_profiles_sizes
+        return sizes.sum.fdiv(@profiles.length).round(round_digits)
     end
 
-    def connect_familiars!(terms_levels)
-        levels = terms_levels.keys.sort
-        while levels.length > 1 # Process when current level has a parental level
-            level = levels.pop
-            parental_level = level - 1
-            parental_terms = terms_levels[parental_level]
-            if parental_terms.nil? # The queried parent level not exists but there is a parental level above of the non existant
-                parental_terms = [] # Initialize required parental level
-                terms_levels[parental_level] = parental_terms
-                levels << parental_level
-            end
-            terms_levels[level].each do |term|
-                path_info = @term_paths[term]
-                shortest_path_length = path_info[:shortest_path] 
-                path = path_info[:paths].select{|p| p.length == shortest_path_length}.first
-                parental = path[1] # the first elements is the term itself
-                parental_terms << parental if !parental_terms.include?(parental)
-            end
-        end
+    # ===== Returns 
+    # an array of sizes for all stored profiles
+    # ===== Return
+    # array of profile sizes
+    def get_profiles_sizes()
+        return @profiles.map{|id,terms| terms.length}
     end
 
-    def compute_relations_elim(terms_levels, external_item_list, total_items, thresold, item_list)
-        results = []
-        penalized_terms = {}
-        levels = terms_levels.keys.sort
-        levels.reverse_each do |level|
-            terms_levels[level].each do |term|
-                associated_items = item_list[term]
-                items_to_remove = penalized_terms[term]
-                items_to_remove = [] if items_to_remove.nil?
-                pval = get_fisher_exact_test(
-                    external_item_list - items_to_remove, 
-                    associated_items - items_to_remove, 
-                    #((associated_items | external_item_list) - items_to_remove).length
-                    total_items
-                    )
-                if pval <= thresold
-                    parents = get_ancestors(term) # Save the items for each parent term to remove them later in the fisher test
-                    parents.each do |prnt|
-                        query = penalized_terms[prnt]
-                        if query.nil?
-                            penalized_terms[prnt] = item_list[term].clone # We need a new array to store the following iterations
-                        else
-                            query.concat(item_list[term])
-                        end
-                    end
-                end
-                results << [term, pval]
-            end
-        end
-        return results
+    # Calculates profiles sizes and returns size assigned to percentile given
+    # ===== Parameters
+    # +perc+:: percentile to be returned
+    # +increasing_sort+:: flag to indicate if sizes order must be increasing. Default: false
+    # ===== Returns 
+    # values assigned to percentile asked
+    def get_profile_length_at_percentile(perc=50, increasing_sort: false) 
+        prof_lengths = self.get_profiles_sizes
+        percentile_profile = prof_lengths.get_quantiles(perc.fdiv(100), decreasing_sort = !increasing_sort)
+        return percentile_profile
     end
 
-    def compute_relations_weight(terms_levels, external_item_list, total_items, item_list)
-        pvals = {}
-        item_weigths_per_term = Hash.new { |hash, key|  Hash.new(1) } #https://mensfeld.pl/2016/09/ruby-hash-default-value-be-cautious-when-you-use-it/
-        levels = terms_levels.keys.sort
-        levels.reverse_each do |level|
-            terms_levels[level].each do |term|
-                associated_items = item_list[term]
-                #initialize observed items in item_weigths_per_term list
-                add_items_to_weigthed_list(term, associated_items, item_weigths_per_term) if !associated_items.nil?
-                children = @dicts[:is_a][:byValue][term]
-                if children.nil?
-                    children = []
-                else
-                    children = children.select{|ch| item_weigths_per_term[ch].length > 0} # Only use children with items associated to them OR transfered to them
-                end
-                computeTermSig(term, children, external_item_list, total_items, pvals, item_weigths_per_term)
+    # IC data
+    ####################################
+
+    # Get frequency terms and information coefficient from profiles #
+
+    # Calculates frequencies of stored profiles terms
+    # ===== Parameters
+    # +ratio+:: if true, frequencies will be returned as ratios between 0 and 1.
+    # +asArray+:: used to transform returned structure format from hash of Term-Frequency to an array of tuples [Term, Frequency]
+    # +translate+:: if true, term IDs will be translated to 
+    # ===== Returns 
+    # stored profiles terms frequencies
+    def get_profiles_terms_frequency(ratio: true, asArray: true, translate: true)
+        freqs = Hash.new(0)
+        @profiles.each do |id, terms|
+            terms.each{|term| freqs[term] += 1}
+        end
+        if translate
+            translated_freqs = {}
+            freqs.each do |term, freq| 
+                tr = self.translate_id(term)
+                translated_freqs[tr] = freq if !tr.nil?
             end
+            freqs = translated_freqs
         end
-        return pvals.to_a     
+        n_profiles = @profiles.length
+        freqs.transform_values!{|freq| freq.fdiv(n_profiles)} if ratio
+        if asArray
+            freqs = freqs.to_a
+            freqs.sort!{|h1, h2| h2[1] <=> h1[1]}
+        end
+        return freqs
     end
 
-    def add_items_to_weigthed_list(term, associated_items, weigthed_list)
-        term_weigthing = weigthed_list[term]
-        associated_items.each{|ai| term_weigthing[ai] = 1}
-        weigthed_list[term] = term_weigthing
+    # Calculates resnik ontology, and resnik observed mean ICs for all profiles stored
+    # ===== Returns 
+    # two hashes with Profiles and IC calculated for resnik and observed resnik respectively
+    def get_profiles_resnik_dual_ICs(struct: :resnik, observ: :resnik_observed) # Maybe change name during migration to get_profiles_dual_ICs
+        struct_ics = {}
+        observ_ics = {}
+        @profiles.each do |id, terms|
+            struct_ics[id] = self.get_profile_mean_IC(terms, ic_type: struct)
+            observ_ics[id] = self.get_profile_mean_IC(terms, ic_type: observ)
+        end
+        return struct_ics, observ_ics
     end
 
-    def computeTermSig(term, children, external_item_list, total_items, pvals, item_weigths_per_term)
-        #puts term.to_s.red
-        #puts @term_paths[term].inspect
-        #puts @dicts[:is_a][:byValue][term].inspect.light_blue
-        associated_items = item_weigths_per_term[term].keys
-        pval = get_fisher_exact_test(external_item_list, associated_items, total_items, 
-                                    'two_sided', item_weigths_per_term[term], true)
-        pvals[term] = pval
-        if children.length > 0
-            rates = {}
-            sig_child = 0
-            children.each do |child|
-                ratio = sigRatio(pvals[child], pval)
-                rates[child] = ratio 
-                sig_child += 1 if ratio >= 1
-            end
-            if sig_child == 0 # CASE 1
-                children.each do |child|
-                    current_ratio = rates[child]
-                    query_child = item_weigths_per_term[child]
-                    query_child.transform_values!{|weight| weight * current_ratio}
-                    pvals[child] = get_fisher_exact_test(external_item_list, item_weigths_per_term[child].keys, total_items, 
-                                      'two_sided', item_weigths_per_term[child], true)
-                end
-            else
-                ancs = get_ancestors(term, filter_alternatives = true)
-                ancs << term
-                rates.each do |ch, ratio|# CASE 2
-                    if ratio >= 1 # The child is better than parent
-                        ancs.each do |anc|
-                            query_anc = item_weigths_per_term[anc]
-                            associated_items.each do |item|
-                                query_anc[item] /= ratio # /= --> query_anc[item]/ratio
-                            end
-                        end
+
+    # Calculates and return resnik ICs (by ontology and observed frequency) for observed terms
+    # ===== Returns 
+    # two hashes with resnik and resnik_observed ICs for observed terms
+    def get_observed_ics_by_onto_and_freq() 
+        ic_ont = {}
+        resnik_observed = {}
+        observed_terms = @profiles.values.flatten.uniq
+        observed_terms.each do |term| 
+            ic_ont[term] = get_IC(term)
+            resnik_observed[term] = get_IC(term, type: :resnik_observed)
+        end
+        return ic_ont, resnik_observed
+    end
+
+    # Profiles vs Profiles #
+
+    def get_pair_index(profiles_A, profiles_B)
+        pair_index = {}
+        profiles_A.each do |curr_id, profile_A|
+            profiles_B.each do |id, profile_B|
+                profile_A.each do |term_A|
+                    profile_B.each do |term_B|
+                        pair_index[[term_A, term_B].sort] = true 
                     end
                 end
-                computeTermSig(term, children - rates.keys, external_item_list, total_items, pvals, item_weigths_per_term)
-            end
+            end    
         end
+        return pair_index
     end
 
-    def sigRatio(pvalA, pvalB)
-        return Math.log(pvalA)/Math.log(pvalB)
+    def get_mica_index_from_profiles(pair_index, sim_type: :resnik, ic_type: :resnik, lca_index: true)
+        pair_index.each do |pair, val|
+            tA, tB = pair
+            value = self.get_similarity(tA, tB, type: sim_type, ic_type: ic_type, lca_index: lca_index)
+            value = true if value.nil? # We use true to save that the operation was made but there is not mica value
+            add2nestHash(@mica_index, tA, tB, value)
+            add2nestHash(@mica_index, tB, tA, value)
+        end
     end
 
-    def profile_stats
-      stats = Hash.new(0)
-      data = @profiles.values.map{|ont_ids| ont_ids.size}
-      stats[:average] = data.sum().fdiv(data.size)
-      sum_devs = data.sum{|element| (element - stats[:avg]) ** 2}
-      stats[:variance] = sum_devs.fdiv(data.size)
-      stats[:standardDeviation] = stats[:variance] ** 0.5
-      stats[:max] = data.max
-      stats[:min] = data.min
-
-      stats[:count] = data.size
-      data.each do |value|
-        stats[:countNonZero] += 1 if value != 0
-      end
+    # Compare internal stored profiles against another set of profiles. If an external set is not provided, internal profiles will be compared with itself 
+    # ===== Parameters
+    # +external_profiles+:: set of external profiles. If nil, internal profiles will be compared with itself
+    # +sim_type+:: similitude method to be used. Default: resnik
+    # +ic_type+:: ic type to be used. Default: resnik
+    # +bidirectional+:: calculate bidirectional similitude. Default: false
+    # ===== Return
+    # Similitudes calculated
+    def compare_profiles(external_profiles: nil, sim_type: :resnik, ic_type: :resnik, bidirectional: true)
+        profiles_similarity = {} #calculate similarity between patients profile
+        if external_profiles.nil?
+            comp_profiles = @profiles
+            main_profiles = comp_profiles
+        else
+            comp_profiles = external_profiles
+            main_profiles = @profiles
+        end
+        # Compare
+        pair_index = get_pair_index(main_profiles, comp_profiles)
+        @mica_index = {}
+        get_mica_index_from_profiles(pair_index, sim_type: sim_type, ic_type: ic_type, lca_index: false)
+        main_profiles.each do |curr_id, current_profile|
+            comp_profiles.each do |id, profile|
+                value = compare(current_profile, profile, sim_type: sim_type, ic_type: ic_type, bidirectional: bidirectional, store_mica: true)
+                add2nestHash(profiles_similarity, curr_id, id, value)
+            end    
+        end
+        return profiles_similarity
+    end
 
-      stats[:q1] = data.get_quantiles(0.25)
-      stats[:median] = data.get_quantiles(0.5)
-      stats[:q3] = data.get_quantiles(0.75)
-      return stats
+    # specifity_index related methods
+    ####################################
 
+    # Return ontology levels from profile terms
+    # ===== Returns 
+    # hash of term levels (Key: level; Value: array of term IDs)
+    def get_ontology_levels_from_profiles(uniq = true)
+        profiles_terms = @profiles.values.flatten
+        profiles_terms.uniq! if uniq
+        term_freqs_byProfile = Hash.new(0)
+        profiles_terms.each do |term|
+            term_freqs_byProfile[term] += 1 
+        end
+        levels_filtered = {}
+        terms_levels = @dicts[:level][:byValue]
+        term_freqs_byProfile.each do |term, count|
+            level = terms_levels[term]
+            term_repeat = Array.new(count, term)
+            query = levels_filtered[level]
+            if query.nil?
+                levels_filtered[level] = term_repeat
+            else
+                query.concat(term_repeat)
+            end
+        end
+        return levels_filtered
     end
 
-#============================================================================
-#============================================================================
+    def get_profile_ontology_distribution_tables
+      cohort_ontology_levels = get_ontology_levels_from_profiles(uniq=false)
+      uniq_cohort_ontology_levels = get_ontology_levels_from_profiles
+      ontology_levels = get_ontology_levels
+      total_ontology_terms = ontology_levels.values.flatten.length
+      total_cohort_terms = cohort_ontology_levels.values.flatten.length
+      total_uniq_cohort_terms = uniq_cohort_ontology_levels.values.flatten.length
 
-    # Check if a given ID is a removable (blacklist) term.
-    # +DEPRECATED+ use is_removable? instead
-    # ===== Parameters
-    # +id+:: to be checked
-    # ===== Returns 
-    # true if given term is a removable (blacklist) term or false in other cases
-    def is_removable(id)
-        warn "[DEPRECATION] `is_removable` is deprecated.  Please use `is_removable?` instead."
-        return @removable_terms.include?(id.to_sym)
+      distribution_ontology_levels = []
+      distribution_percentage = []
+      ontology_levels.each do |level, terms|
+        cohort_terms = cohort_ontology_levels[level]
+        uniq_cohort_terms = uniq_cohort_ontology_levels[level]
+        if cohort_terms.nil? || uniq_cohort_terms.nil?
+          num = 0
+          u_num = 0
+        else
+          num = cohort_terms.length
+          u_num = uniq_cohort_terms.length
+        end
+        distribution_ontology_levels << [level, terms.length, num]
+        distribution_percentage << [
+          level,
+          (terms.length.fdiv(total_ontology_terms)*100).round(3),
+          (num.fdiv(total_cohort_terms)*100).round(3),
+          (u_num.fdiv(total_uniq_cohort_terms)*100).round(3)
+        ]
+      end
+      distribution_ontology_levels.sort! { |x,y| x.first <=> y.first }
+      distribution_percentage.sort! { |x,y| x.first <=> y.first }
+      return distribution_ontology_levels, distribution_percentage
     end
 
-    # Check if a given ID is a removable (blacklist) term
-    # ===== Parameters
-    # +id+:: to be checked
-    # ===== Returns 
-    # true if given term is a removable (blacklist) term or false in other cases
-    def is_removable? id
-        return @removable_terms.include?(id.to_sym)
+    def get_dataset_specifity_index(mode)
+        ontology_levels, distribution_percentage = get_profile_ontology_distribution_tables
+        if mode == 'uniq'
+            observed_distribution = 3
+        elsif mode == 'weigthed'
+            observed_distribution = 2
+        end
+        max_terms = distribution_percentage.map{|row| row[1]}.max
+        maxL = nil 
+        distribution_percentage.each do |level_info|
+            maxL = level_info.first if level_info[1] == max_terms
+        end
+        diffL = distribution_percentage.map{|l| [l[0], l[observed_distribution] - l[1]]}
+        diffL.select!{|dL| dL.last > 0}
+        highSection = diffL.select{|dL| dL.first > maxL}
+        lowSection = diffL.select{|dL| dL.first <= maxL}
+        dsi = nil
+        if highSection.empty?
+            dsi = 0
+        else
+            hss = get_weigthed_level_contribution(highSection, maxL, ontology_levels.length - maxL)
+            lss = get_weigthed_level_contribution(lowSection, maxL, maxL)
+            dsi = hss.fdiv(lss)
+        end
+        return dsi
     end
 
-    ############################################
-    # SPECIAL METHODS
-    #############################################
+    def get_weigthed_level_contribution(section, maxL, nLevels)
+        accumulated_weigthed_diffL = 0
+        section.each do |level, diff|
+            weightL = maxL - level 
+            if weightL >= 0
+                weightL += 1
+            else
+                weightL = weightL.abs
+            end
+            accumulated_weigthed_diffL += diff * weightL
+        end
+        weigthed_contribution = accumulated_weigthed_diffL.fdiv(nLevels)
+        return weigthed_contribution
+    end
+
+    ########################################
+    ## GENERAL ONTOLOGY METHODS
+    ########################################
+
     def ==(other)
-        self.header == other.header &&
-        self.stanzas == other.stanzas &&
+        self.terms == other.terms &&
         self.ancestors_index == other.ancestors_index &&
         self.alternatives_index == other.alternatives_index &&
-        self.obsoletes_index == other.obsoletes_index &&
         self.structureType == other.structureType &&
         self.ics == other.ics &&
         self.meta == other.meta &&
         self.dicts == other.dicts &&
         self.profiles == other.profiles &&
-        self.profilesDict == other.profilesDict &&
         (self.items.keys - other.items.keys).empty? &&
-        self.removable_terms == other.removable_terms &&
-        self.special_tags == other.special_tags &&
         self.items == other.items &&
         self.term_paths == other.term_paths &&
         self.max_freqs == other.max_freqs
@@ -2528,32 +1606,128 @@ class Ontology
 
     def clone
         copy = Ontology.new
-        copy.header = self.header.clone
-        copy.stanzas[:terms] = self.stanzas[:terms].clone
-        copy.stanzas[:typedefs] = self.stanzas[:typedefs].clone
-        copy.stanzas[:instances] = self.stanzas[:instances].clone
+        copy.terms = self.terms.clone
         copy.ancestors_index = self.ancestors_index.clone
         copy.descendants_index = self.descendants_index.clone
         copy.alternatives_index = self.alternatives_index.clone
-        copy.obsoletes_index = self.obsoletes_index.clone
         copy.structureType = self.structureType.clone
         copy.ics = self.ics.clone
         copy.meta = self.meta.clone
         copy.dicts = self.dicts.clone
         copy.profiles = self.profiles.clone
-        copy.profilesDict = self.profilesDict.clone
         copy.items = self.items.clone
-        copy.removable_terms = self.removable_terms.clone
         copy.term_paths = self.term_paths.clone
         copy.max_freqs = self.max_freqs.clone
         return copy
     end
 
+    # Exports an OBO_Handler object in json format
+    # ===== Parameters
+    # +file+:: where info will be stored
+    def write(file)
+        # Take object stored info
+        obj_info = {terms: @terms,
+                    ancestors_index: @ancestors_index,
+                    descendants_index: @descendants_index,
+                    alternatives_index: @alternatives_index,
+                    structureType: @structureType,
+                    ics: @ics,
+                    meta: @meta,
+                    max_freqs: @max_freqs,
+                    dicts: @dicts,
+                    profiles: @profiles,
+                    items: @items,
+                    term_paths: @term_paths}
+        # Convert to JSON format & write
+        File.open(file, "w") { |f| f.write obj_info.to_json }
+    end
+
+
+    def each(att = false)
+        warn('terms empty') if @terms.empty?
+        @terms.each do |id, tags|            
+            if att
+               yield(id, tags)
+            else
+               yield(id)
+            end
+        end
+    end
+
+    def get_root 
+        roots = []
+        each do |term|
+            roots << term if @ancestors_index[term].nil? 
+        end
+        return roots
+    end
+
+    def list_term_attributes
+        terms = []
+        each do |code|
+            terms << [code, translate_id(code), get_term_level(code)]
+        end
+        return terms
+    end
+
+    # Gets ontology levels calculated
+    # ===== Returns 
+    # ontology levels calculated
+    def get_ontology_levels
+        return @dicts[:level][:byTerm].clone # By term, in this case, is Key::Level, Value::Terms
+    end
     
-    #############################################
-    # ACCESS CONTROL
-    #############################################
+    private
+
+    def add2hash(hash, key, val)
+        query = hash[key]
+        if query.nil?
+            hash[key] = [val]
+        else
+            query << val
+        end
+    end    
+
+    def add2nestHash(h, key1, key2, val)
+        query1 = h[key1]
+        if query1.nil?
+            h[key1] = {key2 => val} 
+        else
+            query1[key2] = val
+        end
+    end
 
-    attr_reader :file, :header, :stanzas, :ancestors_index, :descendants_index, :special_tags, :alternatives_index, :obsoletes_index, :structureType, :ics, :max_freqs, :meta, :dicts, :profiles, :profilesDict, :items, :removable_terms, :term_paths
-    attr_writer :file, :header, :stanzas, :ancestors_index, :descendants_index, :special_tags, :alternatives_index, :obsoletes_index, :structureType, :ics, :max_freqs, :meta, :dicts, :profiles, :profilesDict, :items, :removable_terms, :term_paths
+    # Internal function to concat two elements.
+    # ===== Parameters
+    # +itemA+:: item to be concatenated
+    # +itemB+:: item to be concatenated
+    # ===== Returns
+    # Concatenated objects
+    def concatItems(itemA,itemB) # NEED TEST, CHECK WITH PSZ THIS METHOD
+        # A is Array :: RETURN ARRAY
+            # A_array : B_array
+            # A_array : B_hash => NOT ALLOWED
+            # A_array : B_single => NOT ALLOWED
+        # A is Hash :: RETURN HASH
+            # A_hash : B_array => NOT ALLOWED
+            # A_hash : B_hash
+            # A_hash : B_single => NOT ALLOWED
+        # A is single element => RETURN ARRAY
+            # A_single : B_array
+            # A_single : B_hash => NOT ALLOWED
+            # A_single : B_single
+        concatenated = nil
+        if itemA.kind_of?(Array) && itemB.kind_of?(Array)
+            concatenated = itemA | itemB
+        elsif itemA.kind_of?(Hash) && itemB.kind_of?(Hash)
+            concatenated = itemA.merge(itemB) do |k, oldV, newV| 
+                self.concatItems(oldV,newV)
+            end
+        elsif itemB.kind_of?(Array)
+            concatenated = ([itemA] + itemB).uniq
+        elsif ![Array, Hash].include?(itemB.class)
+            concatenated = [itemA,itemB].uniq
+        end
+        return concatenated
+    end
 end