def check_derived_fields(self, fields_to_check=None):
deps = {}
unavailable = []
fields_to_check = fields_to_check or list(self.keys())
for field in fields_to_check:
if field not in self:
raise YTFieldNotFound(str(field))
fi = self[field]
try:
fd = fi.get_dependencies(ds=self.ds)
except Exception as e:
if field in self._show_field_errors:
raise
if type(e) != YTFieldNotFound:
# if we're doing field tests, raise an error
# see yt.fields.tests.test_fields
if hasattr(self.ds, '_field_test_dataset'):
raise
mylog.debug("Raises %s during field %s detection.",
str(type(e)), field)
self.pop(field)
continue
# This next bit checks that we can't somehow generate everything.
# We also manually update the 'requested' attribute
missing = not all(f in self.field_list for f in fd.requested)
if missing:
self.pop(field)
unavailable.append(field)
continue
fd.requested = set(fd.requested)
deps[field] = fd
mylog.debug("Succeeded with %s (needs %s)", field, fd.requested)
dfl = set(self.ds.derived_field_list).union(deps.keys())
self.ds.derived_field_list = list(sorted(dfl, key=tupleize))
return deps, unavailable
def _split_fields(self, fields):
# This will split fields into either generated or read fields
fields_to_read, fields_to_generate = [], []
for ftype, fname in fields:
if fname in self.field_list or (ftype, fname) in self.field_list:
fields_to_read.append((ftype, fname))
elif fname in self.ds.derived_field_list or (ftype, fname) in self.ds.derived_field_list:
fields_to_generate.append((ftype, fname))
else:
raise YTFieldNotFound((ftype,fname), self.ds)
return fields_to_read, fields_to_generate
def NullFunc(field, data):
raise YTFieldNotFound(field.name)
