from __future__ import absolute_import, division, print_function
# Import standard modules
import numpy as np
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.magic.core.image import Image
from pts.core.tools import filesystem as fs
from pts.core.basics.log import log
# -----------------------------------------------------------------
# Create the configuration
definition = ConfigurationDefinition()
definition.add_required("filepath", "file_path", "path of the image")
definition.add_required("factor", "real", "multiplication factor")
definition.add_flag("backup", "make a backup of each image that is multiplied",
False)
config = parse_arguments("multiply", definition)
# -----------------------------------------------------------------
# BACKUP FIRST
if config.backup:
# Inform the user
log.info("Making a backup of the original image ...")
# Determine new filepath and copy
new_filepath = fs.appended_filepath(config.filepath, "_backup")
from pts.core.tools import time
from pts.core.tools import formatting as fmt
# -----------------------------------------------------------------
# Get the modeling commands
modeling_path = verify_modeling_cwd()
filepaths = get_log_file_paths(modeling_path)
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
# Add settings
definition.add_required("match", "string", "(partial) command name")
# Get configuration
config = parse_arguments("previous_config", definition)
# -----------------------------------------------------------------
matches = defaultdict(list)
# -----------------------------------------------------------------
# Loop over the filepaths
for filepath in filepaths:
# Get the modeling command
filename = fs.name(filepath)
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.simulation.skifile import SkiFile
from pts.core.simulation.skifile import show_normalizations
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
# Ski path
definition.add_required("ski", "file_path", "path of the ski file")
# Optional
definition.add_optional("flux", "photometric_unit", "also show flux in a particular unit")
# -----------------------------------------------------------------
# Parse the arguments into a configuration
config = parse_arguments("normalizations", definition, "Show the normalizations of stellar components in a ski file")
# -----------------------------------------------------------------
# Load the ski file
ski = SkiFile(config.ski)
# -----------------------------------------------------------------
# -----------------------------------------------------------------
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.basics.table import SmartTable
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.tools import filesystem as fs
from pts.core.tools import sequences
# -----------------------------------------------------------------
# Create configuration
definition = ConfigurationDefinition(write_config=False)
definition.add_required("filename", "file_path", "table file")
definition.add_required("old_name", "string", "original column name")
definition.add_required("new_name", "string", "new column name")
definition.add_optional("method", "string", "table reading method", "lines")
config = parse_arguments("remove_columns", definition)
# -----------------------------------------------------------------
# Load the table
table = SmartTable.from_file(config.filename, method=config.method)
# -----------------------------------------------------------------
# Rename
table.rename_column(config.old_name, config.new_name)
# -----------------------------------------------------------------
modeling_path = verify_modeling_cwd()
runs = FittingRuns(modeling_path)
# -----------------------------------------------------------------
# Create configuration definition
definition = ConfigurationDefinition()
# -----------------------------------------------------------------
# FITTING RUN
if runs.empty: raise RuntimeError("No fitting runs are present (yet)")
elif runs.has_single: definition.add_fixed("fitting_run", "name of the fitting run", runs.single_name)
else: definition.add_required("fitting_run", "string", "name of the fitting run", choices=runs.names)
# Create the configuration
config = parse_arguments("check_populations", definition)
# -----------------------------------------------------------------
# Load populations table
populations = get_populations(modeling_path)
populations_run = populations[config.fitting_run]
# Load generation table
generations = get_generations_table(modeling_path, config.fitting_run)
# -----------------------------------------------------------------
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments, prompt_yn
from pts.core.tools.stringify import tostr
from pts.core.units.parsing import is_photometric_unit, is_photometric_quantity, parse_unit, parse_quantity
from pts.core.units.parsing import possible_physical_types, possible_density_flags, possible_brightness_flags
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition(write_config=False)
# Quantity to convert and unit to convert to
definition.add_required("quantity", "string", "quantity to convert to another unit")
definition.add_required("unit", "string", "unit to convert the quantity to")
# Extra information
definition.add_optional("distance", "length_quantity", "distance")
definition.add_optional("wavelength", "length_quantity", "wavelength")
definition.add_optional("frequency", "frequency_quantity", "frequency")
definition.add_optional("pixelscale", "pixelscale", "pixelscale")
definition.add_optional("solid_angle", "solid_angle", "solid angle")
definition.add_optional("filter", "filter", "filter")
# Create the configuration
config = parse_arguments("convert", definition, "Convert a quantity from one unit to another")
# -----------------------------------------------------------------
#!/usr/bin/env python
# -*- coding: utf8 -*-
# *****************************************************************
# ** PTS -- Python Toolkit for working with SKIRT **
# ** © Astronomical Observatory, Ghent University **
# *****************************************************************
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition
from pts.dustpedia.data.images import instruments
# -----------------------------------------------------------------
# Configuration
definition = ConfigurationDefinition()
# Galaxy name
definition.add_required("galaxy_name", "string", "the name of the galaxy")
# Database
definition.add_section("database", "DustPedia database credentials")
definition.add_optional("username", "string", "username")
definition.add_optional("password", "string", "password")
# Other options
definition.add_positional_optional("instruments", "string_list", "instruments for which to download the images", choices=instruments, default=instruments)
# -----------------------------------------------------------------
# Import standard modules
import subprocess
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.remote.host import find_host_ids, load_host
from pts.core.tools import filesystem as fs
from pts.core.tools import introspection
from pts.core.tools import time
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
definition.add_required("remote",
"string",
"remote host to mount",
choices=find_host_ids())
# Read the command line arguments
config = parse_arguments(
"login",
definition,
description="Login to a remote host configured in PTS")
# -----------------------------------------------------------------
# Check platform
if not introspection.is_macos():
raise RuntimeError("This command only works on MacOS")
# -----------------------------------------------------------------
#!/usr/bin/env python
# -*- coding: utf8 -*-
# *****************************************************************
# ** PTS -- Python Toolkit for working with SKIRT **
# ** © Astronomical Observatory, Ghent University **
# *****************************************************************
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
# Required settings
#definition.add_required("galaxy_name", "string", "galaxy name")
definition.add_required("wcs", "file_path", "FITS file with the desired WCS")
definition.add_required("parameters", "directory_path",
"path parameters directory")
# The output directory
definition.add_optional("output",
"directory_path",
"output directory",
letter="o")
# -----------------------------------------------------------------
default_generation_method = "genetic"
generation_methods = ["genetic", "grid"]
# -----------------------------------------------------------------
# Create the configuration
definition = ConfigurationDefinition(log_path="log", config_path="config")
# The fitting run for which to explore the parameter space
# FITTING RUN
if runs.empty: raise RuntimeError("No fitting runs are present")
elif runs.has_single:
definition.add_fixed("name", "name of the fitting run", runs.single_name)
else:
definition.add_required("name",
"string",
"name of the fitting run",
choices=runs.names)
# Positional optional parameter
definition.add_positional_optional("generation_method",
"string",
"model generation method",
default_generation_method,
choices=generation_methods)
# Optional parameters
if len(find_host_ids()) > 0:
definition.add_optional(
"remotes",
"string_list",
"the remote hosts on which to run the parameter exploration",
# -----------------------------------------------------------------
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.remote.host import find_host_ids
from pts.core.remote.remote import Remote
from pts.core.tools import filesystem as fs
# -----------------------------------------------------------------
definition = ConfigurationDefinition()
definition.add_required("local_path", "string",
"path or name of the file or directory to send")
definition.add_required("remote",
"string",
"the remote host to send to",
choices=find_host_ids())
definition.add_optional("remote_path", "string",
"path of the remote directory to send to")
config = parse_arguments("send", definition)
# -----------------------------------------------------------------
# Create remote
remote = Remote(host_id=config.remote)
# -----------------------------------------------------------------
# -----------------------------------------------------------------
# Import standard modules
import imageio
# Import the relevant PTS classes and modules
from pts.core.basics.rgbimage import invert_colors
from pts.core.tools import filesystem as fs
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
# -----------------------------------------------------------------
# Create the definition
definition = ConfigurationDefinition()
definition.add_required("filename", "file_path",
"name of the input image file")
# Parse the command line arguments
config = parse_arguments("invert", definition)
# -----------------------------------------------------------------
# Open the original image
image = imageio.imread(config.filename)
# Invert the colours
invert_colors(image)
# Determine output name
name = fs.strip_extension(fs.name(config.filename))
extension = fs.get_extension(config.filename)
units = dict()
units["distance"] = "Mpc"
units["ionizing_scaleheight"] = "pc"
units["sfr_compactness"] = None
units["fuv_young"] = "W/micron"
units["old_scaleheight"] = "pc"
units["position_angle"] = "deg"
units["dust_mass"] = "Msun"
units["fuv_ionizing"] = "W/micron"
units["metallicity"] = None
units["young_scaleheight"] = "pc"
units["sfr_covering"] = None
units["dust_scaleheight"] = "pc"
units["i1_old"] = "W/micron"
units["sfr_pressure"] = "K/m3"
units["inclination"] = "deg"
# -----------------------------------------------------------------
# Create the configuration
definition = ConfigurationDefinition(write_config=False)
# Add the required setting of the list of free parameters
definition.add_required(
"free_parameters",
"string_list",
"parameters to be used as free parameters during the fitting",
choices=parameter_descriptions)
# -----------------------------------------------------------------
from pts.modeling.core.environment import GalaxyModelingEnvironment
from pts.core.remote.remote import Remote
from pts.core.tools.parsing import real
from pts.core.tools.introspection import pts_temp_dir
from pts.magic.core.frame import Frame
from pts.magic.tools import plotting
from pts.modeling.core.steps import cached_directory_name_for_single_command
from pts.modeling.core.environment import verify_modeling_cwd
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
# The galaxy name
definition.add_required("filter", "filter",
"filter for which to show the truncated image")
definition.add_required("factor", "real",
"truncation ellipse factor for which to plot")
# Get configuration
config = parse_arguments("plot_truncated", definition)
# -----------------------------------------------------------------
modeling_path = verify_modeling_cwd()
# -----------------------------------------------------------------
# Load the modeling environment
environment = GalaxyModelingEnvironment(modeling_path)
#!/usr/bin/env python
# -*- coding: utf8 -*-
# *****************************************************************
# ** PTS -- Python Toolkit for working with SKIRT **
# ** © Astronomical Observatory, Ghent University **
# *****************************************************************
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition
from pts.core.tools import filesystem as fs
# -----------------------------------------------------------------
# Create the configuration
definition = ConfigurationDefinition()
# Add required settings
definition.add_required("runs", )
# -----------------------------------------------------------------
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.basics.remote import Remote
from pts.core.basics.configuration import ConfigurationDefinition, ConfigurationReader
from pts.core.tools import introspection
from pts.core.tools.logging import log
# -----------------------------------------------------------------
# Create configuration definition
definition = ConfigurationDefinition()
# Add required
definition.add_required("remote", str, "the remote host ID")
# Add flags
definition.add_flag("versions", "compare versions", "v")
# Get configuration
reader = ConfigurationReader("compare_python_packages")
config = reader.read(definition)
# -----------------------------------------------------------------
# Create the remote execution environment
remote = Remote()
# Log in
remote.setup(config.remote)
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.remote.remote import Remote
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.tools import introspection
from pts.core.basics.log import log
# -----------------------------------------------------------------
# Create configuration definition
definition = ConfigurationDefinition()
# Add required
definition.add_required("remote", "string", "the remote host ID")
# Add flags
definition.add_flag("versions", "compare versions", "v")
# Get configuration
config = parse_arguments("compare_python_packages", definition)
# -----------------------------------------------------------------
# Create the remote execution environment
remote = Remote()
# Log in
remote.setup(config.remote)
# -----------------------------------------------------------------
# Load environment and model suite
environment = load_modeling_environment_cwd()
suite = environment.static_model_suite
# -----------------------------------------------------------------
# Create the configuration
definition = ConfigurationDefinition(log_path="log", config_path="config")
# Add settings
if suite.has_models:
definition.add_required("name",
"string",
"name for the model",
forbidden=suite.model_names)
else:
definition.add_positional_optional("name",
"string",
"name for the model",
default="standard")
# Description
definition.add_positional_optional("description", "string",
"description of the model")
# Settings for stellar and dust components
definition.add_optional("sfr", "real", "average star formation rate",
default_sfr)
definition.add_optional("dust_mass", "quantity",
## \package pts.do.developer.execute Execute a line on a remote host and check the output.
# -----------------------------------------------------------------
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.remote.remote import Remote
# -----------------------------------------------------------------
definition = ConfigurationDefinition()
definition.add_required("remote", "string", "remote host ID")
definition.add_required("line", "string", "line to be executed on the remote host")
config = parse_arguments("sessions", definition)
# -----------------------------------------------------------------
# Initialize the remote
remote = Remote()
if not remote.setup(config.remote): raise RuntimeError("The remote host '" + config.remote + "' is not available at the moment")
# -----------------------------------------------------------------
print("")
#print("-----------------------------------------------------------------")
print("OUTPUT")
print("-----------------------------------------------------------------")
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.tools import time
from pts.core.tools import filesystem as fs
from pts.modeling.analysis.run import AnalysisRunInfo
from pts.core.tools.serialization import load_dict, write_dict
# -----------------------------------------------------------------
environment = load_modeling_environment_cwd()
analysis_runs = environment.analysis_runs
# -----------------------------------------------------------------
definition = ConfigurationDefinition()
definition.add_required("analysis_run",
"string",
"analysis run to clone",
choices=analysis_runs.names)
definition.add_optional("name",
"string",
"name for the new analysis run",
forbidden=analysis_runs.names)
config = parse_arguments("clone_analysis_run", definition)
# -----------------------------------------------------------------
# Get analysis run path
path = analysis_runs.get_path(config.analysis_run)
# -----------------------------------------------------------------
# Generate new analysis run name
# -----------------------------------------------------------------
default_spacing_measure = "mean"
spacing_measures = ["min", "max", "mean", "median"]
default_spacing_factor = 10.
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
# -----------------------------------------------------------------
# 3D data file
definition.add_required("filename", "file_path", "path of the 3D data file")
# Orientations
definition.add_required("orientations", "string_list", "orientations from which to project the data", choices=orientations)
# -----------------------------------------------------------------
# Width/height
definition.add_optional("height", "length_quantity", "maximum height above/below midplane for the faceon projection")
definition.add_optional("width", "length_quantity", "maximum width before/behind center vertical plane for the edgeon projection")
# Output directory
definition.add_optional("output", "directory_path", "output directory")
# -----------------------------------------------------------------
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import standard modules
import collections
# Import the relevant PTS classes and modules
from pts.core.basics.log import log
from pts.core.tools import parsing
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
# -----------------------------------------------------------------
definition = ConfigurationDefinition()
definition.add_required("parsing_type", "string", "parsing type")
definition.add_required("string", "string", "string to be parsed")
# -----------------------------------------------------------------
# Get config
config = parse_arguments("parse", definition)
# -----------------------------------------------------------------
# Get parsing function
parsing_function = getattr(parsing, config.parsing_type)
# Parse
try:
# -----------------------------------------------------------------
# Set the modeling path
environment = load_modeling_environment_cwd()
runs = environment.fitting_runs
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
# The fitting run name
if runs.empty: raise ValueError("No analysis runs present (yet)")
elif runs.has_single: definition.add_fixed("run", "name of the fitting run", runs.single_name)
else: definition.add_required("run", "string", "name of the fitting run for which to (re)make the wavelength grids", choices=runs.names)
# Options
definition.add_flag("basic", "make basic wavelength grids", True)
definition.add_flag("refined", "make refined wavelength grids", True)
definition.add_flag("highres", "make high-resolution wavelength grids", True)
# Settings for the wavelength grid generation
definition.add_optional("npoints_range_basic", "integer_range", "range of the basic wavelength grid size", default_npoints_range_basic, convert_default=True)
definition.add_optional("npoints_range_refined", "integer_range", "range of the refined wavelength grid size", default_npoints_range_refined, convert_default=True)
definition.add_optional("npoints_range_highres", "integer_range", "range of the high-resolution wavelength grid size", default_npoints_range_highres, convert_default=True)
definition.add_optional("ngrids_basic", "integer", "number of basic wavelength grids to generate", default_ngrids_basic)
definition.add_optional("ngrids_refined", "integer", "number of refined wavelength grids to generate", default_ngrids_refined)
definition.add_optional("ngrids_highres", "integer", "number of high-resolution wavelength grids to generate", default_ngrids_highres)
definition.add_flag("add_emission_lines", "add emission lines to the wavelength grids", True)
definition.add_optional("range", "quantity_range", "range of wavelengths", default_wavelength_range, convert_default=True)
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, ConfigurationReader
from pts.dustpedia.core.dataprocessing import DustPediaDataProcessing
from pts.core.basics.remote import Remote
from pts.core.tools import filesystem as fs
from pts.core.tools import logging
from pts.core.tools import time
# -----------------------------------------------------------------
# Configuration
definition = ConfigurationDefinition()
# Galaxy name
definition.add_required("galaxy_name", str, "the name of the galaxy")
definition.add_required("band", str, "the band (GALEX or SDSS u/g/r/i/z)")
# Optional
definition.add_optional("remote", str, "the remote host name", None)
# Get configuration
reader = ConfigurationReader(
"get_poisson_errors",
"Calculate poisson error maps for DustPedia UV and optical images")
config = reader.read(definition)
arguments = reader.get_arguments()
# -----------------------------------------------------------------
# Determine the log file path
from pts.core.tools import filesystem as fs
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.dustpedia.core.sample import DustPediaSample
from pts.dustpedia.core.database import DustPediaDatabase, get_account
from pts.core.tools import formatting as fmt
from pts.core.tools import introspection
from pts.dustpedia.core.photometry import DustPediaPhotometry
from pts.core.tools import stringify
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
# The galaxy name
definition.add_required("galaxy", "string", "galaxy name")
# Get configuration
config = parse_arguments("strategy", definition)
# -----------------------------------------------------------------
sample = DustPediaSample()
# Database
username, password = get_account()
database = DustPediaDatabase()
database.login(username, password)
# Get the DustPedia name
name = sample.get_name(config.galaxy)
# *****************************************************************
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition
# -----------------------------------------------------------------
# Create the configuration
definition = ConfigurationDefinition()
# Add input section
definition.add_section("input", "the names of the input files")
definition.sections["input"].add_required("cutout", "file_path", "name of the cutout FITS file on which the photometry is performed")
definition.sections["input"].add_required("psf", "file_path", "the name of the FITS file with the PSF of the image on which the photometry is performed")
# Add required settings
definition.add_required("pix_arcsec", "real", "The width, in arscec, of the pixels in the map photometry is being performed upon (this is needed in case there is a pixel size mismatch with PSF)")
definition.add_required("semimaj_pix", "real", "Semi-major axis of photometric aperture, in pixels")
definition.add_required("axial_ratio", "real", "Axial ratio of photometric aperture")
definition.add_required("angle", "real", "Position angle of photometric aperture, in degrees")
definition.add_required("centre_i", "real", "Zero-indexed, 0th-axis coordinate (equivalent to y-axis one-indexed coordinates in FITS terms) of centre position of photometric aperture")
definition.add_required("centre_j", "real", "Zero-indexed, 1st-axis coordinate (equivalent to x-axis one-indexed coordinates in FITS terms) of centre position of photometric aperture")
definition.add_required("semimaj_pix_annulus_outer", "real", "Semi-major axis length of the outer annulus ellipse")
definition.add_required("semimaj_pix_annulus_inner", "real", "Semi-major axis length of the inner annulus ellipse")
definition.add_required("axial_ratio_annulus", "real", "Axial ratio of annulus ellipses")
definition.add_required("annulus_angle", "real", "Position angle of annulus, in degrees")
definition.add_required("annulus_centre_i", "real", "0th-axis coordinate (y) of centre position of annulus ellipses")
definition.add_required("annulus_centre_j", "real", "1th-axis coordinate (x) of centre position of annulus ellipses")
# -----------------------------------------------------------------
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.plot.sed import plot_sed
from pts.core.plot.distribution import plot_distribution
from pts.core.tools import formatting as fmt
from pts.core.tools import sequences
from pts.core.tools.stringify import tostr
from pts.core.basics.structure import load_structure, filetypes, composite, table, dictionary, sed, distribution, regions
# -----------------------------------------------------------------
# Create configuration definition
definition = ConfigurationDefinition(write_config=False)
definition.add_required("filetype", "string", "type of file", choices=filetypes)
definition.add_required("filename", "file_path", "path of the dictionary file")
# As table?
definition.add_flag("table", "show as table")
# Displaying and formatting
definition.add_flag("interactive", "display tables interactively", False)
definition.add_flag("latex", "print as latex")
# Modyfying the table
definition.add_optional("columns", "string_list", "only show these columns")
definition.add_optional("sort", "string", "sort the entries on this column")
# Extra options
definition.add_flag("plot", "make a plot")
#!/usr/bin/env python
# -*- coding: utf8 -*-
# *****************************************************************
# ** PTS -- Python Toolkit for working with SKIRT **
# ** © Astronomical Observatory, Ghent University **
# *****************************************************************
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition
# -----------------------------------------------------------------
# Create the configuration
definition = ConfigurationDefinition()
# Add required arguments
definition.add_required("image", str, "the name of the image for which to run the preparation")
# Add optional arguments
definition.add_optional("reference_image", str, "the name of the reference image")
definition.add_flag("steps", "write the results of intermediate steps")
definition.add_flag("visualise", "make visualisations")
#config.add_section("importation")
#config.add_section("preparation")
# -----------------------------------------------------------------
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.tools import logging
from pts.magic.tools import catalogs
from pts.core.tools import filesystem as fs
from pts.core.basics.configuration import ConfigurationDefinition, ConfigurationReader
# -----------------------------------------------------------------
# Create the configuration
definition = ConfigurationDefinition()
# Add required settings
definition.add_required("name", str, "the name of the galaxy")
# Get configuration
reader = ConfigurationReader("setup")
config = reader.read(definition)
# -----------------------------------------------------------------
# Determine the log level
level = "DEBUG" if config.debug else "INFO"
# Initialize the logger
log = logging.setup_log(level=level)
log.start("Starting setup ...")
# -----------------------------------------------------------------
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.remote.host import find_host_ids
from pts.core.tools import filesystem as fs
from pts.core.remote.remote import Remote
from pts.core.tools import introspection
from pts.core.simulation.simulation import RemoteSimulation
from pts.core.simulation.remote import get_simulation_for_host
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
# Add required
definition.add_required("remote",
"string",
"name of the remote host",
choices=find_host_ids())
definition.add_required("id", "positive_integer", "simulation ID")
# -----------------------------------------------------------------
# Parse the arguments into a configuration
config = parse_arguments(
"show_simulation_log",
definition,
description="Show the log output of a remote SKIRT simulation")
# -----------------------------------------------------------------
# Create and setup the remote
remote = Remote()
## \package pts.do.magic.scale_regions Scale regions with a certain factor.
# -----------------------------------------------------------------
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.tools import filesystem as fs
from pts.magic.region.list import load_region_list
# -----------------------------------------------------------------
definition = ConfigurationDefinition()
definition.add_required("path", "file_path", "region path list")
definition.add_required("factor", "positive_real", "scale factor")
config = parse_arguments("scale_regions", definition)
# -----------------------------------------------------------------
regions = load_region_list(config.path)
# -----------------------------------------------------------------
regions *= config.factor
# -----------------------------------------------------------------
# Remove the original file
fs.remove_file(config.path)
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.remote.mounter import RemoteMounter
from pts.core.remote.host import find_host_ids
from pts.core.tools import filesystem as fs
from pts.core.remote.remote import Remote
from pts.core.basics.log import log
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
definition.add_required("remote", "string", "remote host", choices=find_host_ids())
definition.add_required("filename", "string", "file name (or path)")
# Read the command line arguments
config = parse_arguments("open", definition, description="Open a file on a remote host")
# -----------------------------------------------------------------
# Connect to remote
remote = Remote()
remote.setup(config.remote)
# Determine the absolute file path
filepath = remote.absolute_path(config.filename)
# Determine the file path relative to the home directory
#!/usr/bin/env python
# -*- coding: utf8 -*-
# *****************************************************************
# ** PTS -- Python Toolkit for working with SKIRT **
# ** © Astronomical Observatory, Ghent University **
# *****************************************************************
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
# Add required
definition.add_required("ski_path", "file_path", "ski file")
# -----------------------------------------------------------------
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.tools import filesystem as fs
from pts.magic.core.frame import Frame
from pts.core.basics.log import log
from pts.magic.core.rgba import alpha_methods
# -----------------------------------------------------------------
default_alpha_method = "absolute"
scales = ["log", "sqrt"]
# -----------------------------------------------------------------
definition = ConfigurationDefinition()
definition.add_required("filename", "file_path", "path of the FITS file")
definition.add_optional("scale", "string", "scaling", "log", scales)
definition.add_optional("interval", "string", "interval", "pts")
definition.add_optional("colours", "string", "colour or colour scale", "red")
definition.add_optional("alpha", "string", "alpha method", default_alpha_method, suggestions=alpha_methods)
definition.add_optional("output", "string", "output filepath", letter="o")
definition.add_optional("peak_alpha", "real", "alpha of peak value", 1.)
definition.add_optional("max_npixels", "positive_integer", "maximum number of pixels")
definition.add_optional("downsample", "positive_real", "downsample with this factor")
definition.add_flag("show", "show after creating", False)
config = parse_arguments("fits_to_png", definition)
# -----------------------------------------------------------------
# Inform the user
log.info("Loading the FITS file ...")
environment = load_modeling_environment_cwd()
runs = environment.fitting_runs
# -----------------------------------------------------------------
all_steps = steps + [batch]
# -----------------------------------------------------------------
# Create definition
definition = ConfigurationDefinition()
# The fitting run for which to explore the parameter space
if runs.empty: raise RuntimeError("No fitting runs are present")
elif runs.has_single: definition.add_fixed("name", "name of the fitting run", runs.single_name)
else: definition.add_required("name", "string", "name of the fitting run", choices=runs.names)
# Generations to remove
definition.add_required("generation", "string", "generation name")
# Simulations to reanalyse
definition.add_optional("simulations", "string_list", "simulation names")
# Reanalyse which steps?
definition.add_positional_optional("steps", "string_list", "re-analyse only certain steps", choices=all_steps, default=all_steps)
definition.add_positional_optional("features", "string_list", "re-analyse only certain features (if a single step is defined)")
definition.add_optional("not_steps", "string_list", "don't analyse these steps", choices=all_steps)
definition.add_optional("not_features", "string_list", "don't analyse these features (if a single not_step is defined)")
# Add section for analysis options
definition.import_section("analysis", "analyser options", analysis_definition)
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
# Name of the model for which to create the representation
if suite.no_models:
raise RuntimeError(
"No models found: first run build_model to create a new model")
elif suite.has_single_model:
definition.add_fixed("model_name", "name of the model",
suite.single_model_name)
else:
definition.add_required("model_name",
"string",
"name of the model",
choices=suite.model_names)
# Get configuration
config = parse_arguments("show_model", definition)
# -----------------------------------------------------------------
# Load the model definition
model = suite.get_model_definition(config.model_name)
# -----------------------------------------------------------------
print("")
print(fmt.green + fmt.underlined + "STELLAR COMPONENTS" + fmt.reset)
print("")
from pts.core.tools.stringify import tostr
from pts.modeling.misc.playground import MappingsPlayground
from pts.core.plot.sed import SEDPlotter
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.data.sun import Sun
from pts.core.tools import filesystem as fs
from pts.core.data.sed import SED
from pts.core.simulation.wavelengthgrid import WavelengthGrid
# -----------------------------------------------------------------
# Create definition
definition = ConfigurationDefinition()
# Filter
definition.add_required("filter", "filter", "filter in which to calculate the luminosity")
# SFR
definition.add_positional_optional("sfr", "quantity", "star formation rate", "1. Msun/yr", convert_default=True)
# MAPPINGS parameters
definition.add_optional("metallicity", "positive_real", "metallicity", 0.02)
definition.add_optional("compactness", "positive_real", "compactness", 6)
definition.add_optional("pressure", "quantity", "pressure", 1e12 * u("K/m3"))
definition.add_optional("covering_factor", "positive_real", "covering factor", 0.2) # fPDR
# Flags
definition.add_flag("plot", "plot the SEDs", False)
definition.add_flag("skirt", "use SKIRT", True)
definition.add_flag("pts", "use PTS", True)
definition.add_flag("sampled", "use SKIRT luminosities already sampled on a wavelength grid", True)
#!/usr/bin/env python
# -*- coding: utf8 -*-
# *****************************************************************
# ** PTS -- Python Toolkit for working with SKIRT **
# ** © Astronomical Observatory, Ghent University **
# *****************************************************************
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
# The galaxy name
definition.add_required("galaxy_name", "string", "galaxy name")
# Flag
definition.add_flag("show", "show the parameters", True)
# The output directory
definition.add_optional("output",
"directory_path",
"output directory",
letter="o")
# -----------------------------------------------------------------
#!/usr/bin/env python
# -*- coding: utf8 -*-
# *****************************************************************
# ** PTS -- Python Toolkit for working with SKIRT **
# ** © Astronomical Observatory, Ghent University **
# *****************************************************************
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition
# -----------------------------------------------------------------
# Create configuration definition
definition = ConfigurationDefinition()
# Add required
definition.add_required("host_id", "string", "remote host ID")
# -----------------------------------------------------------------
# *****************************************************************
## \package pts.do.magic.sky_to_pix Convert a sky coordinate to a pixel coordinate for a specific WCS.
# -----------------------------------------------------------------
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.magic.basics.coordinatesystem import CoordinateSystem
# -----------------------------------------------------------------
definition = ConfigurationDefinition()
definition.add_required("coordinate", "skycoordinate", "the sky coordinate")
definition.add_required("wcs_path", "file_path",
"the path to the file holding the WCS info")
# Get the configuration
config = parse_arguments("pix_to_sky", definition)
# -----------------------------------------------------------------
# Print the pixel coordinate
print(config.coordinate.to_pixel(CoordinateSystem.from_file(config.wcs_path)))
# -----------------------------------------------------------------
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import standard modules
import numpy as np
# Import the relevant PTS classes and modules
from pts.core.tools import formatting as fmt
from pts.core.tools import tables
from pts.core.tools import filesystem as fs
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
# -----------------------------------------------------------------
definition = ConfigurationDefinition(write_config=False)
definition.add_required("path_a", "file_path", "path of the first table")
definition.add_required("path_b", "file_path", "path of the second table")
config = parse_arguments("compare_tables", definition, add_logging=False, add_cwd=False)
# -----------------------------------------------------------------
format_a = "ascii." + fs.get_extension(config.path_a)
format_b = "ascii." + fs.get_extension(config.path_b)
table_a = tables.from_file(config.path_a, format=format_a)
table_b = tables.from_file(config.path_b, format=format_b)
# -----------------------------------------------------------------
print("")
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.remote.host import find_host_ids
from pts.core.simulation.remote import get_simulation_for_host
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
# Add required
definition.add_required("remote",
"string",
"ID of the remote host",
choices=find_host_ids())
definition.add_required("id", "integer", "ID of the simulation")
# -----------------------------------------------------------------
# Parse the arguments into a configuration
config = parse_arguments(
"show_analysis_options",
definition,
description="Show information about a certain remote simulation")
# -----------------------------------------------------------------
# Load the simulation
simulation = get_simulation_for_host(config.remote, config.id)
# ** © Astronomical Observatory, Ghent University **
# *****************************************************************
## \package pts.do.magic.sky_to_pix Convert a sky coordinate to a pixel coordinate for a specific WCS.
# -----------------------------------------------------------------
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.magic.basics.coordinatesystem import CoordinateSystem
# -----------------------------------------------------------------
definition = ConfigurationDefinition()
definition.add_required("coordinate", "skycoordinate", "the sky coordinate")
definition.add_required("wcs_path", "file_path", "the path to the file holding the WCS info")
# Get the configuration
config = parse_arguments("pix_to_sky", definition)
# -----------------------------------------------------------------
# Print the pixel coordinate
print(config.coordinate.to_pixel(CoordinateSystem.from_file(config.wcs_path)))
# -----------------------------------------------------------------
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.remote.host import find_host_ids
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
# Add required
definition.add_required("remote",
"string",
"ID of the remote host",
choices=find_host_ids())
definition.add_required("task_id", "integer", "ID of the PTS task")
# -----------------------------------------------------------------
# Parse the arguments into a configuration
config = parse_arguments(
"task_info",
definition,
description="Show information about a certain remote PTS task")
# -----------------------------------------------------------------
print("Not implemented yet")
# -----------------------------------------------------------------
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.modeling.core.data import load_data
from pts.core.basics.log import log
# -----------------------------------------------------------------
# Create configuration
definition = ConfigurationDefinition()
definition.add_required("filename", "file_path", "path of the data file")
definition.add_required("new_filename", "string", "path for the completed data file")
config = parse_arguments("upload_status", definition)
# -----------------------------------------------------------------
# Inform the user
log.info("Loading the data file ...")
# Load
data = load_data(config.filename)
# -----------------------------------------------------------------
# Dereference
data.dereference()
from pts.core.launch.analyser import SimulationAnalyser
# -----------------------------------------------------------------
batch = "batch"
scaling = "scaling"
# -----------------------------------------------------------------
all_steps = steps + [batch, scaling]
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
definition.add_required("remote", "string", "remote host to mount", choices=all_host_ids())
definition.add_required("id", "positive_integer", "simulation ID")
definition.add_positional_optional("steps", "string_list", "re-analyse only certain steps", choices=all_steps, default=all_steps)
# Read the command line arguments
config = parse_arguments("reanalyse", definition, description="Re-analyse a certain simulation")
# -----------------------------------------------------------------
# Load the simulation
simulation = get_simulation_for_host(config.remote, config.id)
# Check whether retrieved
if not simulation.retrieved: raise ValueError("The simulation has not been retrieved yet")
# -----------------------------------------------------------------
## \package pts.do.core.task_info Show information about a certain remote PTS task.
# -----------------------------------------------------------------
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.remote.host import find_host_ids
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
# Add required
definition.add_required("remote", "string", "ID of the remote host", choices=find_host_ids())
definition.add_required("task_id", "integer", "ID of the PTS task")
# -----------------------------------------------------------------
# Parse the arguments into a configuration
config = parse_arguments("task_info", definition, description="Show information about a certain remote PTS task")
# -----------------------------------------------------------------
print("Not implemented yet")
# -----------------------------------------------------------------
suite = ModelSuite.from_modeling_path(modeling_path)
# -----------------------------------------------------------------
# Create the configuration
definition = ConfigurationDefinition(log_path="log", config_path="config")
# Name of the representation
representation_names = suite.representation_names
if len(representation_names) == 0:
definition.add_optional("name",
"string",
"name for the representation",
default="highres")
else:
definition.add_required("name", "string", "name for the representation")
# Name of the model for which to create the representation
model_names = suite.model_names
if len(model_names) == 0:
raise RuntimeError(
"No models found: first run build_model to create a new model")
elif len(model_names) == 1:
definition.add_fixed("model_name", "name of the model", model_names[0])
else:
definition.add_required("model_name",
"string",
"name of the model",
choices=model_names)
# Whether quality has to be calculated
from __future__ import absolute_import, division, print_function
# Import standard modules
import numpy as np
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.magic.core.image import Image
from pts.core.tools import filesystem as fs
from pts.core.basics.log import log
# -----------------------------------------------------------------
# Create the configuration
definition = ConfigurationDefinition()
definition.add_required("file_path", "file_path", "path of the image")
definition.add_required("factor", "real", "multiplication factor")
definition.add_flag("backup", "make a backup of each image that is multiplied", False)
config = parse_arguments("multiply", definition)
# -----------------------------------------------------------------
# BACKUP FIRST
if config.backup:
# Inform the user
log.info("Making a backup of the original image ...")
# Determine new filepath and copy
new_filepath = fs.appended_filepath(config.filepath, "_backup")
fs.copy_file(config.filepath, new_filepath)
# -----------------------------------------------------------------
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.remote.host import find_host_ids
from pts.core.remote.remote import Remote
from pts.core.tools import filesystem as fs
# -----------------------------------------------------------------
definition = ConfigurationDefinition()
definition.add_required("remote_path", "string", "remote path of the file or directory to retrieve")
definition.add_required("remote", "string", "remote host to retrieve from", choices=find_host_ids())
definition.add_optional("local_path", "string", "path of the local directory to store the file/directory")
config = parse_arguments("retrieve", definition)
# -----------------------------------------------------------------
# Create remote
remote = Remote(host_id=config.remote)
# -----------------------------------------------------------------
# Set full path of origin
origin = remote.absolute_path(config.remote_path)
# *****************************************************************
## \package pts.do.core.mount Mount a remote configured in PTS into a local directory.
# -----------------------------------------------------------------
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.remote.mounter import mount_and_open
from pts.core.remote.host import all_host_ids
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
definition.add_required("remote", "string", "remote host to mount", choices=all_host_ids())
definition.add_positional_optional("path", "directory_path", "path of directory in which to create the mount point")
# Read the command line arguments
config = parse_arguments("mount", definition, description="Mount a remote configured in PTS into the local filesystem")
# -----------------------------------------------------------------
# Mount and open
mount_and_open(config.remote, path=config.path)
# -----------------------------------------------------------------
mosenkov_ratio = 9.06
# -----------------------------------------------------------------
scalelength_scaleheight_ratios = dict()
scalelength_scaleheight_ratios[degeyter_ratio] = "De Geyter et al. (2014)"
scalelength_scaleheight_ratios[kregel_ratio] = "Kregel et al. (2002)"
scalelength_scaleheight_ratios[mosenkov_ratio] = "Mosenkov et al. (2015)"
# -----------------------------------------------------------------
# Create the configuration
definition = ConfigurationDefinition(log_path="log", config_path="config")
# The name
definition.add_required("name", "string", "name of the model")
# Stellar maps
definition.add_required("old_stars_map",
"string",
"choice of old stars map",
choices=selection.old_map_names)
definition.add_required("young_stars_map",
"string",
"choice of young stars map",
choices=selection.young_map_names)
definition.add_required("ionizing_stars_map",
"string",
"choice of ionizing stars map",
choices=selection.ionizing_map_names)
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.remote.host import all_host_ids
from pts.core.simulation.remote import get_simulation_for_host
from pts.core.launch.analyser import reanalyse_simulation, all_steps
from pts.core.basics.log import log
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
definition.add_required("remote", "string", "remote host to mount", choices=all_host_ids())
definition.add_required("ids", "integer_list", "simulation IDs")
definition.add_positional_optional("steps", "string_list", "re-analyse only certain steps", choices=all_steps, default=all_steps)
definition.add_positional_optional("features", "string_list", "re-analyse only certain features (if a single step is defined)")
definition.add_optional("not_steps", "string_list", "don't analyse these steps", choices=all_steps)
definition.add_optional("not_features", "string_list", "don't analyse these features (if a single not_step is defined)")
# Read the command line arguments
config = parse_arguments("reanalyse", definition, description="Re-analyse a certain simulation")
# -----------------------------------------------------------------
# Loop over the simulations
for simulation_id in config.ids:
# Load the simulation
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.simulation.jobscript import SKIRTJobScript
from pts.core.launch.options import LoggingOptions
from pts.core.simulation.arguments import SkirtArguments
from pts.core.simulation.definition import SingleSimulationDefinition
from pts.core.remote.host import load_host
from pts.core.simulation.parallelization import Parallelization
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
# Add required arguments
definition.add_required("remote",
"string",
"remote host ID",
choices=find_host_ids())
definition.add_required("ski", "string", "the name/path of the ski file")
# Input and output
definition.add_optional("input",
"string",
"input directory for the simulation(s)",
letter="i")
definition.add_optional("output",
"string",
"output directory for the simulation(s)",
"~/SKIRT/run",
letter="o",
convert_default=True)
#!/usr/bin/env python
# -*- coding: utf8 -*-
# *****************************************************************
# ** PTS -- Python Toolkit for working with SKIRT **
# ** © Astronomical Observatory, Ghent University **
# *****************************************************************
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition
from pts.core.remote.host import find_host_ids
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
# Add required
definition.add_required("remote", "string", "name of the remote host", choices=find_host_ids())
definition.add_positional_optional("id", "positive_integer", "simulation ID")
definition.add_optional("name", "string", "simulation name")
# Additional relative error
definition.add_optional("additional_error", "percentage", "additional percentual error for the observed flux points")
# Flags
definition.add_flag("write", "write the results", True)
# -----------------------------------------------------------------
# -----------------------------------------------------------------
modeling_path = verify_modeling_cwd()
runs = FittingRuns(modeling_path)
# -----------------------------------------------------------------
# Create configuration definition
definition = ConfigurationDefinition()
# -----------------------------------------------------------------
# THE FITTING RUN
if runs.empty: raise RuntimeError("No fitting runs are present (yet)")
elif runs.has_single: definition.add_fixed("fitting_run", "name of the fitting run", runs.single_name)
else: definition.add_required("fitting_run", "string", "name of the fitting run", choices=runs.names)
# -----------------------------------------------------------------
# Generation
definition.add_positional_optional("generations", "string_list", "name of the generations for which to show the reproductions")
# Create the configuration
config = parse_arguments("show_reproductions", definition)
# -----------------------------------------------------------------
# Load the modeling environment
environment = GalaxyModelingEnvironment(modeling_path)
# -----------------------------------------------------------------
# -----------------------------------------------------------------
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.tools import filesystem as fs
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.basics.log import log
from pts.magic.core.image import Image
# -----------------------------------------------------------------
# Create the configuration
definition = ConfigurationDefinition()
definition.add_required("add_to", "file_path", "add to this FITS file")
definition.add_required("add_from", "file_path", "add from this FITS file")
definition.add_flag("frames", "add frames", True)
definition.add_flag("masks", "add masks", True)
definition.add_flag("segments", "add segmentation maps", True)
definition.add_flag("replace", "replace planes", False)
definition.add_flag("replace_frames", "replace frames", False)
definition.add_flag("replace_masks", "replace masks", False)
definition.add_flag("replace_segments", "replace segmentation maps", False)
definition.add_flag("backup", "make backup", False)
config = parse_arguments("interpolate", definition)
# -----------------------------------------------------------------
if config.replace: config.replace_frames = config.replace_masks = config.replace_segments = True
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import standard modules
import collections
# Import the relevant PTS classes and modules
from pts.core.basics.log import log
from pts.core.tools import parsing
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
# -----------------------------------------------------------------
definition = ConfigurationDefinition()
definition.add_required("parsing_type", "string", "parsing type")
definition.add_required("string", "string", "string to be parsed")
# -----------------------------------------------------------------
# Get config
config = parse_arguments("parse", definition)
# -----------------------------------------------------------------
# Get parsing function
parsing_function = getattr(parsing, config.parsing_type)
# Parse
try:
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.tools import logging, time
from pts.core.tools import filesystem as fs
from pts.core.basics.configuration import ConfigurationDefinition, ConfigurationReader
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
# Add setting
definition.add_required("step", str, "the modeling step for which to clear the output")
# Get the configuration
reader = ConfigurationReader("clear")
config = reader.read(definition)
# -----------------------------------------------------------------
# Determine the log file path
logfile_path = fs.join(fs.cwd(), "log", time.unique_name("log") + ".txt") if config.arguments.report else None
# Determine the log level
level = "DEBUG" if config.arguments.debug else "INFO"
# Initialize the logger
log = logging.setup_log(level=level, path=logfile_path)
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import standard modules
import numpy as np
# Import the relevant PTS classes and modules
from pts.core.tools import formatting as fmt
from pts.core.tools import tables
from pts.core.tools import filesystem as fs
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
# -----------------------------------------------------------------
definition = ConfigurationDefinition(write_config=False)
definition.add_required("path_a", "file_path", "path of the first table")
definition.add_required("path_b", "file_path", "path of the second table")
config = parse_arguments("compare_tables",
definition,
add_logging=False,
add_cwd=False)
# -----------------------------------------------------------------
format_a = "ascii." + fs.get_extension(config.path_a)
format_b = "ascii." + fs.get_extension(config.path_b)
table_a = tables.from_file(config.path_a, format=format_a)
table_b = tables.from_file(config.path_b, format=format_b)
