def METHOD_NAME(self, evaluated_obj, root_obj, fill_defaults=True, multiplier=1):
    if isinstance(evaluated_obj, dict) and evaluated_obj.keys() == [root_obj]:
        evaluated_obj = evaluated_obj.get(root_obj)
    if not self.ref_obj:
        self.ref_obj = load_yaml_to_obj(self.yaml_path)
        # self.load_reference()
    ref_item = self.ref_obj.get(root_obj)
    if ref_item is not None:
        try:
            typed_obj = [False, None]   # first item stores validity (multiple object "shapes"), second stored type
            if "type" in evaluated_obj:
                ref_item = ref_item[evaluated_obj.get("type")]
                # print "lower resolution with typed object"
                typed_obj = [True, evaluated_obj.get("type")]
            if isinstance(ref_item, dict) and "type" not in ref_item:   # this is not a terminal
                result_obj = {}
                if typed_obj[0]:
                    result_obj["type"] = typed_obj[1]
                # print "processing dictionary non-terminal value"
                for k, v in ref_item.items():
                    # print "processing element '{0}' with value '{1}'".format(k,v)
                    if k in evaluated_obj:
                        # validate with ref obj
                        # print "found in evaluated object!"
                        tmp_type = v.get('type')
                        # print tmp_type
                        # print evaluated_obj
                        if tmp_type == "object":
                            # go deeper into nesting hierarchy
                            # print "This is an object type, recursion!"
                            result_obj[k] = self.METHOD_NAME(evaluated_obj.get(k), k, fill_defaults, multiplier)
                        else:
                            # validation on terminal type
                            # print "Validating terminal type %s" % k
                            res_ok, data = self.check_term_param_type(evaluated_obj.get(k), k, v, multiplier)
                            if res_ok:
                                # data field contains the value to save
                                result_obj[k] = data
                            else:
                                # data var contains the exception to throw
                                raise data
                    elif fill_defaults:
                        # complete missing values with default value, if exists
                        sub_obj = typed_obj[1] if typed_obj[0] else None
                        res_ok, data = self.get_reference_default(root_obj, sub_obj, k)
                        if res_ok:
                            # data field contains the value to save
                            result_obj[k] = data
                        else:
                            # data var contains the exception to throw
                            raise data
                return result_obj
            elif isinstance(ref_item, list):
                # currently not handling list objects
                return NotImplementedError("List object are currently unsupported")
            else:
                raise TypeError("Unknown parse tree object type.")
        except KeyError as e:
            raise
    else:
        raise KeyError("The given root_key '{key}' does not exists on reference object".format(key=root_obj))