docs: def augment(self, session, parent, addendum):
          '''
          Augments a DATASET with some calcs
          NB: this is the PUBLIC method
          @returns error
          '''
          parent_calc = session.query(model.Calculation).get(parent)
          if not parent_calc or not parent_calc.siblings_count:
              return 'Dataset is erroneously selected!'
  
          existing_children, filtered_addendum = [child.checksum for child in parent_calc.children], []
  
          for child in addendum:
              if not child in existing_children:
                  filtered_addendum.append(child)
  
          if not filtered_addendum:
              return 'All these data are already present in this dataset.'
          if parent_calc.checksum in filtered_addendum:
              return 'A dataset cannot be added into itself.'
  
          higher_lookup = {}
          more = parent_calc.parent
          distance = 0
          while True:
              distance += 1
              higher, more = more, []
              if not higher:
                  break
              for item in higher:
                  try:
                      higher_lookup[distance].add(item)
                  except KeyError:
                      higher_lookup[distance] = set([item])
                  if item.parent:
                      more += item.parent
  
          for members in list(higher_lookup.values()):
              for member in members:
                  if member.checksum in filtered_addendum:
                      return 'A parent dataset cannot be added to its children dataset.'
  
          parent_meta = session.query(model.Metadata).get(parent)
          parent_grid = session.query(model.Grid).get(parent)
          info_obj = json.loads(parent_grid.info)
  
          for nested_depth, grid_item, download_size in session.query(model.Calculation.nested_depth, model.Grid.info, model.Metadata.download_size).filter(model.Calculation.checksum == model.Grid.checksum, model.Grid.checksum == model.Metadata.checksum, model.Calculation.checksum.in_(filtered_addendum)).all():
  
              if nested_depth >= parent_calc.nested_depth:
                  parent_calc.nested_depth = nested_depth + 1
  
              grid_item = json.loads(grid_item)
  
              for entity in self.hierarchy:
  
                  topic = grid_item.get(entity['source'])
                  if not topic:
                      continue
  
                  if entity['source'] == 'standard':
                      topic = []
  
                  if not isinstance(topic, list):
                      topic = [ topic ]
  
                  existing_term = info_obj.get(entity['source'], [])
                  if not isinstance(existing_term, list):
                      existing_term = [ existing_term ] # TODO
  
                  info_obj[ entity['source'] ] = list(set( existing_term + topic ))
  
              parent_meta.download_size += download_size
  
          info_obj['standard'] = info_obj['standard'][0] # TODO
          parent_grid.info = json.dumps(info_obj)
  
          # tags ORM
          for entity in self.hierarchy:
  
              if not entity['creates_topic']:
                  continue
  
              for item in info_obj.get( entity['source'], [] ):
                  parent_calc.uitopics.append( model.Topic.as_unique(session, cid=entity['cid'], topic="%s" % item) )
  
          for child in session.query(model.Calculation).filter(model.Calculation.checksum.in_(filtered_addendum)).all():
              parent_calc.children.append(child)
  
          parent_calc.siblings_count = len(parent_calc.children)
  
          for distance, members in higher_lookup.items():
              for member in members:
                  d = parent_calc.nested_depth - member.nested_depth + distance
                  if d > 0:
                      member.nested_depth += d
  
                  member.meta_data.download_size += parent_meta.download_size # FIXME
                  session.add(member)
  
          session.add_all([parent_calc, parent_meta, parent_grid])
          session.commit()
          return False