def run(self):
try:
self.func(self.settings)
except Exception as e:
self._exited_with_errors = True
message.error(e.message)
message.finish()
raise
def calculateframe(self, filepath, frame, resolution, cutoff_radii=None, domains=False, surface=False, center=False,
atoms=None, gyration_tensor_parameters=False, recalculate=False, last_frame=True):
"""
Get results for the given parameters. They are either loaded from the
cache or calculated.
**Parameters:**
`filepath` :
absolute path of the input file
`frame` :
the frame number
`resolution` :
resolution of the used discretization
`domains` :
calculate cavitiy domains
`cutoff_radii` :
dict that maps element symbols to cutoff radii
`surface` :
calculate surface-based cavities
`center` :
calculate center-based cavities
`gyration_tensor_parameters` :
gyration tensor parameters will be calculated for cavities (they are always calculated for
cavity domains)
`recalculate` :
results will be calculated even if cached results exists
**Returns:**
A :class:`core.data.Results` object.
"""
# always recalculate if gyration tensor parameters shall be computed for center or surface based cavities
recalculate = recalculate or (gyration_tensor_parameters and (center or surface))
message.progress(0)
inputfile = File.open(filepath)
# TODO: error handling
if isinstance(inputfile, core.file.ResultFile):
resultfile = inputfile
else:
resultfile = self.cache[filepath]
try:
results = resultfile.getresults(frame, resolution)
except Exception as e:
logger.debug("error in resultfile.getresults: {}".format(e))
results = None
if atoms is None:
atoms = inputfile.getatoms(frame)
atoms.radii = cutoff_radii
volume = atoms.volume
if results is None:
results = data.Results(filepath, frame, resolution, atoms, None, None, None)
if recalculate:
results.domains = None
results.surface_cavities = None
results.center_cavities = None
if not ((domains and results.domains is None)
or (surface and results.surface_cavities is None)
or (center and results.center_cavities is None)):
message.print_message("Reusing results")
else:
cachepath = os.path.join(self.cachedir, 'discretization_cache.hdf5')
discretization_cache = DiscretizationCache(cachepath)
discretization = discretization_cache.get_discretization(volume, resolution)
atom_discretization = AtomDiscretization(atoms, discretization)
message.progress(10)
if (domains and results.domains is None) \
or (surface and results.surface_cavities is None):
# CavityCalculation depends on DomainCalculation
message.print_message("Calculating domains")
domain_calculation = DomainCalculation(discretization, atom_discretization)
if domain_calculation.critical_domains:
logger.warn('Found {:d} critical domains in file {}, frame {:d}. Domain indices: {}'.format(
len(domain_calculation.critical_domains), os.path.basename(filepath), frame,
domain_calculation.critical_domains
))
message.log('Found {:d} critical domains in file {}, frame {:d}'.format(
len(domain_calculation.critical_domains), os.path.basename(filepath), frame + 1,
))
if results.domains is None:
results.domains = data.Domains(domain_calculation)
message.progress(40)
if surface and results.surface_cavities is None:
message.print_message("Calculating surface-based cavities")
cavity_calculation = CavityCalculation(domain_calculation, use_surface_points=True,
gyration_tensor_parameters=gyration_tensor_parameters)
results.surface_cavities = data.Cavities(cavity_calculation)
message.progress(70)
if center and results.center_cavities is None:
message.print_message("Calculating center-based cavities")
domain_calculation = FakeDomainCalculation(discretization, atom_discretization, results)
cavity_calculation = CavityCalculation(domain_calculation, use_surface_points=False,
gyration_tensor_parameters=gyration_tensor_parameters)
results.center_cavities = data.Cavities(cavity_calculation)
resultfile.addresults(results, overwrite=recalculate)
message.progress(100)
message.print_message("Calculation finished")
if last_frame:
message.finish()
return results
def calculateframe(self,
filepath,
frame,
resolution,
cutoff_radii=None,
domains=False,
surface=False,
center=False,
atoms=None,
gyration_tensor_parameters=False,
recalculate=False,
last_frame=True):
"""
Get results for the given parameters. They are either loaded from the
cache or calculated.
**Parameters:**
`filepath` :
absolute path of the input file
`frame` :
the frame number
`resolution` :
resolution of the used discretization
`domains` :
calculate cavitiy domains
`cutoff_radii` :
dict that maps element symbols to cutoff radii
`surface` :
calculate surface-based cavities
`center` :
calculate center-based cavities
`gyration_tensor_parameters` :
gyration tensor parameters will be calculated for cavities (they are always calculated for
cavity domains)
`recalculate` :
results will be calculated even if cached results exists
**Returns:**
A :class:`core.data.Results` object.
"""
# always recalculate if gyration tensor parameters shall be computed for center or surface based cavities
recalculate = recalculate or (gyration_tensor_parameters and
(center or surface))
message.progress(0)
inputfile = File.open(filepath)
# TODO: error handling
if isinstance(inputfile, core.file.ResultFile):
resultfile = inputfile
else:
resultfile = self.cache[filepath]
try:
results = resultfile.getresults(frame, resolution)
except Exception as e:
logger.debug("error in resultfile.getresults: {}".format(e))
results = None
if atoms is None:
atoms = inputfile.getatoms(frame)
atoms.radii = cutoff_radii
volume = atoms.volume
if results is None:
results = data.Results(filepath, frame, resolution, atoms, None,
None, None)
if recalculate:
results.domains = None
results.surface_cavities = None
results.center_cavities = None
if not ((domains and results.domains is None) or
(surface and results.surface_cavities is None) or
(center and results.center_cavities is None)):
message.print_message("Reusing results")
else:
cachepath = os.path.join(self.cachedir,
'discretization_cache.hdf5')
discretization_cache = DiscretizationCache(cachepath)
with DiscretizationCache(cachepath) as discretization_cache:
discretization = discretization_cache.get_discretization(
volume, resolution)
atom_discretization = AtomDiscretization(atoms, discretization)
message.progress(10)
if (domains and results.domains is None) \
or (surface and results.surface_cavities is None):
# CavityCalculation depends on DomainCalculation
message.print_message("Calculating domains")
domain_calculation = DomainCalculation(discretization,
atom_discretization)
if domain_calculation.critical_domains:
logger.warn(
'Found {:d} critical domains in file {}, frame {:d}. Domain indices: {}'
.format(len(domain_calculation.critical_domains),
os.path.basename(filepath), frame,
domain_calculation.critical_domains))
message.log(
'Found {:d} critical domains in file {}, frame {:d}'.
format(
len(domain_calculation.critical_domains),
os.path.basename(filepath),
frame + 1,
))
if results.domains is None:
results.domains = data.Domains(domain_calculation)
message.progress(40)
if surface and results.surface_cavities is None:
message.print_message("Calculating surface-based cavities")
cavity_calculation = CavityCalculation(
domain_calculation,
use_surface_points=True,
gyration_tensor_parameters=gyration_tensor_parameters)
results.surface_cavities = data.Cavities(cavity_calculation)
message.progress(70)
if center and results.center_cavities is None:
message.print_message("Calculating center-based cavities")
domain_calculation = FakeDomainCalculation(
discretization, atom_discretization, results)
cavity_calculation = CavityCalculation(
domain_calculation,
use_surface_points=False,
gyration_tensor_parameters=gyration_tensor_parameters)
results.center_cavities = data.Cavities(cavity_calculation)
resultfile.addresults(results, overwrite=recalculate)
message.progress(100)
message.print_message("Calculation finished")
if last_frame:
message.finish()
return results
