def show(self):
"""
This function ...
:return:
"""
print("")
print("Best parameter values:")
print("")
for label in self.best_parameter_values:
print(" - " + label + ": " +
stringify.stringify(self.best_parameter_values[label])[1])
print("")
print("Best luminosities:")
print("")
for filter_name in self.best_luminosities:
print(" " + filter_name + ":")
print("")
for index in range(len(self.best_luminosities)):
print(" - component #" + str(index) + ": " +
stringify.stringify(self.best_luminosities[filter_name]
[index])[1])
print("")
def set_fwhms(self):
"""
This function ...
:return:
"""
# Inform the user
log.info("Setting the FWHMs ...")
# Loop over the filters
for fltr in self.frames:
# Get the fwhm
if has_variable_fwhm(fltr): fwhm = fwhms[str(fltr)]
else: fwhm = get_fwhm(fltr)
# Debugging
log.debug("The FWHM of the '" + str(fltr) + "' image is " + stringify.stringify(fwhm)[1])
# Set
self.real_fwhms[fltr] = fwhm
def make_rotation_masks(self):
"""
This function ...
:return:
"""
# Inform the user
log.info("Making rotation masks ...")
# Loop over the filters
for fltr in self.frames:
# Debugging
log.info("Making rotation mask for the '" + str(fltr) +
"' image ...")
# Get the frame
frame = self.frames[fltr]
# Rotate
if self.config.rotate:
# Choose a random rotation angle
angle = Angle(np.random.uniform(-90, 90), "deg")
# Debugging
log.debug("The random rotation angle is '" +
stringify.stringify(angle)[1] + "'")
# Create mask
mask = frame.rotation_mask(angle)
# Don't rotate
else:
mask = Mask.empty_like(frame)
# Set the mask
self.rotation_masks[fltr] = mask
def make_rotation_masks(self):
"""
This function ...
:return:
"""
# Inform the user
log.info("Making rotation masks ...")
# Loop over the filters
for fltr in self.frames:
# Debugging
log.info("Making rotation mask for the '" + str(fltr) + "' image ...")
# Get the frame
frame = self.frames[fltr]
# Rotate
if self.config.rotate:
# Choose a random rotation angle
angle = Angle(np.random.uniform(-90, 90), "deg")
# Debugging
log.debug("The random rotation angle is '" + stringify.stringify(angle)[1] + "'")
# Create mask
mask = frame.rotation_mask(angle)
# Don't rotate
else: mask = Mask.empty_like(frame)
# Set the mask
self.rotation_masks[fltr] = mask
# Show the properties
for prop_name in properties:
description = properties[prop_name].description
ptype = properties[prop_name].ptype
min_value = properties[prop_name].min
max_value = properties[prop_name].max
default = properties[prop_name].default
choices = properties[prop_name].choices
item = properties[prop_name].item
string = fmt.blue + prop_name + fmt.reset
string += " [type: " + ptype + "]"
if min_value is not None: string += " [min: " + stringify.stringify_not_list(min_value)[1] + "]"
if max_value is not None: string += " [max: " + stringify.stringify_not_list(max_value)[1] + "]"
if default is not None: string += " [default: " + stringify.stringify_not_list(default)[1] + "]"
if choices is not None: string += " [choices: " + stringify.stringify(choices.keys())[1] + "]"
string += " " + fmt.darkgray + stringify.stringify_string_fancy(description, lines_prefix=" ")[1] + fmt.reset
if item: string += fmt.red + " [SIMULATION ITEM] " + fmt.reset
print(" - " + string)
print("")
#print("")
# -----------------------------------------------------------------
def make_point_sources_fixed_fwhm(self, masks=None):
"""
This function ...
:param masks:
:return:
"""
# Inform the user
log.info("Making point sources with a fixed FWHM in each band ...")
# Loop over the 'star' filters
for fltr in self.star_filters:
# Debugging
log.debug("Making point sources for the '" + str(fltr) + "' image ...")
# Get pixelscale
pixelscale = self.frames[fltr].average_pixelscale
# Debugging
log.debug("The pixelscale of the image is " + stringify.stringify(pixelscale)[1])
# Determine the FWHM in pixel coordinates
fwhm_pix = self.real_fwhms[fltr].to("arcsec").value / pixelscale.to("arcsec").value
# Determine sigma
sigma = statistics.fwhm_to_sigma * fwhm_pix
# Only 'render' the Gaussian locally
origin = PixelCoordinate(0.0, 0.0)
amplitude = 1.
min_x, max_x, min_y, max_y, rel_center = determine_patch_for_psf(origin, amplitude, sigma, keep_in_frame=False)
# Make the model
model = create_model(self.config.psf_model, amplitude, rel_center, sigma)
# Evalute the model
y, x = np.indices((max_y - min_y, max_x - min_x))
data = model(x, y)
# Keep track of the number of sources
counter = 0
# Loop over the coordinates in the point sources catalog
for coordinate in self.point_source_catalog.coordinates():
counter += 1
# Debugging
log.debug("Adding source " + str(counter) + " of " + str(len(self.point_source_catalog)) + " ...")
# Check whether it falls in the frame
if not self.frames[fltr].contains(coordinate): continue
# Convert into pixel coordinate
pixel_coordinate = coordinate.to_pixel(self.frames[fltr].wcs)
# Get the corresponding pixel
pixel = Pixel.for_coordinate(pixel_coordinate)
# Check whether not masked
if masks is not None and fltr in masks and masks[fltr][pixel.y, pixel.x]: continue
# Generate a random amplitude (from 100 till 100 000)
amplitude_exponent = np.random.uniform(2., 5.)
amplitude = 10 ** amplitude_exponent
# Calculate absolute minima and maxima
source_min_x = min_x + pixel.x
source_max_x = max_x + pixel.x
source_min_y = min_y + pixel.y
source_max_y = max_y + pixel.y
source_xsize = source_max_x - source_min_x
source_ysize = source_max_y - source_min_y
# Correct
if source_min_x < 0:
cut_x_min = - source_min_x
source_min_x = 0
else: cut_x_min = 0
if source_max_x >= self.frames[fltr].xsize:
cut_x_max = source_xsize - (source_max_x - self.frames[fltr].xsize)
source_max_x = self.frames[fltr].xsize
else: cut_x_max = source_xsize
if source_min_y < 0:
cut_y_min = - source_min_y
source_min_y = 0
else: cut_y_min = 0
if source_max_y >= self.frames[fltr].ysize:
cut_y_max = source_ysize - (source_max_y - self.frames[fltr].ysize)
source_max_y = self.frames[fltr].ysize
else: cut_y_max = source_ysize
# Create the final data for this source
source_data = data[cut_y_min:cut_y_max, cut_x_min:cut_x_max] * amplitude
# Add the data
self.frames[fltr][source_min_y:source_max_y, source_min_x:source_max_x] += source_data
def make_point_sources_variable_fwhm(self, masks=None):
"""
THis function ...
:param masks:
:return:
"""
# Inform the user
log.info("Making point sources with a variable FWHM in each band ...")
# Loop over the 'star' filters
for fltr in self.star_filters:
# Debugging
log.debug("Making point sources for the '" + str(fltr) + "' image ...")
# Get y and x
if not self.config.only_local:
y, x = np.indices(self.frames[fltr].shape)
else: y = x = None
# Get pixelscale
pixelscale = self.frames[fltr].average_pixelscale
# Debugging
log.debug("The pixelscale of the image is " + stringify.stringify(pixelscale)[1])
# Determine the FWHM in pixel coordinates
fwhm_pix = self.real_fwhms[fltr].to("arcsec").value / pixelscale.to("arcsec").value
counter = 0
# Loop over the coordinates in the point sources catalog
for coordinate in self.point_source_catalog.coordinates():
counter += 1
# Debugging
log.debug("Adding point source " + str(counter) + " of " + str(len(self.point_source_catalog)) + " ...")
# Check whether it falls in the frame
if not self.frames[fltr].contains(coordinate): continue
# Convert into pixel coordinate
pixel_coordinate = coordinate.to_pixel(self.frames[fltr].wcs)
# Get the corresponding pixel
pixel = Pixel.for_coordinate(pixel_coordinate)
# Check whether not masked
if masks is not None and fltr in masks and masks[fltr][pixel.y, pixel.x]: continue
# Generate random deviation
x_deviation = np.random.normal(0.0, 1.)
y_deviation = np.random.normal(0.0, 1.)
# Debugging
log.debug("Random pixel position deviation is (" + str(x_deviation) + ", " + str(y_deviation) + ")")
# Alter pixel coordinate
pixel_coordinate.x += x_deviation
pixel_coordinate.y += y_deviation
# Generate random deviation from FWHM
fwhm_deviation = np.random.normal(0.0, 0.05 * fwhm_pix)
# Debugging
log.debug("Random FWHM deviation (on a FWHM of " + str(fwhm_pix) + ") is " + str(fwhm_deviation))
# Add the deviation
fwhm_pix += fwhm_deviation
# Generate a random amplitude (from 100 till 100 000)
amplitude_exponent = np.random.uniform(2., 5.)
amplitude = 10**amplitude_exponent
# Determine sigma
sigma = statistics.fwhm_to_sigma * fwhm_pix
# Only 'render' the Gaussian locally
if self.config.only_local: min_x, max_x, min_y, max_y, rel_center = determine_patch_for_psf(pixel_coordinate, amplitude, sigma, max_x_pixel=self.frames[fltr].xsize-1, max_y_pixel=self.frames[fltr].ysize-1, keep_in_frame=True)
# Render each Gaussian over the entire frame
else:
min_x = max_x = min_y = max_y = None
rel_center = pixel_coordinate
# Make the model
model = create_model(self.config.psf_model, amplitude, rel_center, sigma)
# Evaluate the model
if self.config.only_local: y, x = np.indices((max_y - min_y, max_x - min_x))
data = model(x, y)
# Add the data
if self.config.only_local: self.frames[fltr][min_y:max_y, min_x:max_x] += data
else: self.frames[fltr] += data
def load_dictionary(self, dictionary_name, dictionary, local_temp_path, remote_temp_path=None):
"""
This function ...
:param dictionary_name:
:param dictionary:
:param local_temp_path:
:param remote_temp_path:
:return:
"""
# Set temp paths
temp_path = local_temp_path
# Check if remote temp path is defined
if remote_temp_path is None: remote_temp_path = self.session_temp_directory
# Import the parsing module remotely
self.import_package("parsing", from_name="pts.core.tools", show_output=log.is_debug)
# Paths to input files that have to be uploaded
local_input_filepaths = []
# Depending paths
depending_filepaths = dict()
# Strings
input_strings = dict()
# E.G.
# dictionary = {"a": OBJECT_A, "b": OBJECT_B}
# Loop over the names of the input objects
for name in dictionary:
# name = "a"
# Get the value
value = dictionary[name]
# value = OBJECT_A
# Check whether extension is defined
if hasattr(value, "default_extension"):
# Determine filepath
path = fs.join(temp_path, name + "." + value.default_extension)
# path = .../a.ext
# Save
dictionary[name].saveto(path)
# Add the filepath
local_input_filepaths.append(path)
# Check whether this object has depending paths
if hasattr(value, "get_depending_paths"):
# Get the local depending filepaths
local_depending_filepaths = value.get_depending_paths() # = dictionary
# Set the depending filepaths for this input object
depending_filepaths[name] = local_depending_filepaths
# Extension is not defined
else:
# Try to convert the object to a string
ptype, string = stringify(value)
# Add to dictinoary
input_strings[name] = (ptype, string)
#### UPLOAD THE INPUT :
# Upload the input files
self.remote.upload_retry(local_input_filepaths, remote_temp_path, show_output=log.is_debug)
# UPLOAD DEPENDING FILEPATHS
remote_depending_filepaths = dict()
for name in depending_filepaths:
# name = "a"
# Create remote directory for this input object
dirname = name + "_depending"
dirpath = fs.join(remote_temp_path, dirname)
self.create_directory(dirpath)
# Initialize
remote_depending_filepaths[name] = dict()
# Upload all depending
index = 0
for label in depending_filepaths[name]:
# Get the local filepath
local_depending_filepath = depending_filepaths[name][label]
# Determine new name for the file
extension = fs.get_extension(local_depending_filepath)
new_name = str(index) + "." + extension
# Upload the file, giving it a new name
remote_depending_filepath = self.remote.upload_file_to(local_depending_filepath, dirpath, new_name=new_name, show_output=log.is_debug)
# Set the remote path
remote_depending_filepaths[name][label] = remote_depending_filepath
# Increment the counter
index += 1
### LOAD THE INPUT DICT REMOTELY
# Initialize the remote input dictionary
self.send_line(dictionary_name + " = dict()", show_output=log.is_debug)
# Add the stuff
for name in dictionary:
# Get the value
value = dictionary[name]
# Check whether extension is defined
if hasattr(value, "default_extension"):
# Determine the remote filepath
remote_filepath = fs.join(remote_temp_path, name + "." + value.default_extension)
# Import the class of the filetype remotely
classpath = str(type(value)).split("'")[1].split("'")[0]
modulepath, classname = classpath.rsplit(".", 1)
self.send_line("input_module = importlib.import_module('" + modulepath + "')", show_output=log.is_debug) # get the module of the class
self.send_line("input_cls = getattr(input_module, '" + classname + "')", show_output=log.is_debug) # get the class
# Open the input file
if name in depending_filepaths: self.send_line("input_dict['" + name + "'] = input_cls.from_file('" + remote_filepath + "', check=False)", show_output=True)
else: self.send_line("input_dict['" + name + "'] = input_cls.from_file('" + remote_filepath + "')", show_output=True)
# Check whether depending paths have to be adjusted
if name in depending_filepaths:
# Loop over each label
for label in depending_filepaths[name]:
# Get the remote filepath
depending_filepath = remote_depending_filepaths[name][label]
# Set the depending path
self.send_line("input_dict['" + name + "'].set_depending_path('" + label + "', '" + depending_filepath + "')", show_output=True)
# Extension is not defined
else:
# Get the parsing type and the string
ptype, string = input_strings[name]
# Get the parsing function remotely
self.send_line("parsing_function = getattr(parsing, '" + ptype + "')")
# Parse the input object
self.send_line("input_dict['" + name + "'] = parsing_function('" + string + "')")
print(" - position: " + str(sample.get_position(name)))
print(" - D25: " + str(sample.get_d25(name)))
print(" - R25: " + str(sample.get_r25(name)))
print("")
print(" - stage: " + str(info["Hubble Stage"][0]))
print(" - V: " + str(info["V"][0]))
print(" - inclination: " + str(info["Inclination"][0]))
print("")
print(fmt.red + fmt.underlined + "Images:" + fmt.reset)
print("")
#for name in image_names: print(" - " + name)
#print("")
print(" " + "\n ".join(wrap(stringify.stringify(image_filters)[1], 100)))
print("")
#urls = database.get_image_urls(name, error_maps=False)
#print(urls)
#database.reset(username, password)
# Open the cutouts file
fs.open_file(path)
# Create the photometry
photometry = DustPediaPhotometry()
# Get the aperture
aperture = photometry.get_aperture(name)
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
# -----------------------------------------------------------------
# Create the configuration
definition = ConfigurationDefinition()
definition.add_positional_optional(
"match", "string",
"only show quantities with names that contain this string")
# Parse
config = parse_arguments("skirt_quantities", definition)
# -----------------------------------------------------------------
# Create the SKIRT smile schema
smile = SKIRTSmileSchema()
print("")
for quantity in smile.quantities:
units = smile.units_for_quantity(quantity)
print(fmt.green + fmt.underlined + quantity + fmt.reset + ": " +
stringify.stringify(units)[1].replace(" ", "").replace(",", ", ") +
" [PTS: " + skirt_quantities_to_pts_quantities[quantity] + "]")
print("")
#print("")
# -----------------------------------------------------------------
print(" - position: " + str(sample.get_position(name)))
print(" - D25: " + str(sample.get_d25(name)))
print(" - R25: " + str(sample.get_r25(name)))
print("")
print(" - stage: " + str(info["Hubble Stage"][0]))
print(" - V: " + str(info["V"][0]))
print(" - inclination: " + str(info["Inclination"][0]))
print("")
print(fmt.red + fmt.underlined + "Images:" + fmt.reset)
print("")
#for name in image_names: print(" - " + name)
#print("")
print(" " + "\n ".join(wrap(stringify.stringify(image_filters)[1], 100)))
print("")
#urls = database.get_image_urls(name, error_maps=False)
#print(urls)
#database.reset(username, password)
# Open the cutouts file
fs.open_file(path)
# Create the photometry
photometry = DustPediaPhotometry()
# Get the aperture
aperture = photometry.get_aperture(name)