# ** 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.basics.plot import normal_colormaps
from pts.magic.plot.imagegrid import default_cmap, light_theme, themes
# ------------------------------------------------------------------------------
# Create definition
definition = ConfigurationDefinition(write_config=False)
# From directory
definition.add_optional("from_directory", "directory_path", "load images from directory")
# Colormap
definition.add_optional("cmap", "string", "colormap", default_cmap, choices=normal_colormaps)
# Options
definition.add_optional("axes_label_size", "positive_integer", "axes label size", 14)
definition.add_optional("ticks_label_size", "positive_integer", "ticks label size", 8)
definition.add_optional("legend_fontsize", "positive_integer", "legend fontsize", 14)
definition.add_optional("legend_markers_cale", "positive_integer", "legend marker scale", 0)
definition.add_optional("lines_marker_size", "positive_real", "lines marker size", 2.5)
definition.add_optional("linewidth", "positive_integer", "linewidth", 1)
# Dark or light theme?
definition.add_optional("theme", "string", "theme for the plot", light_theme, choices=themes)
default_models_loc = "upper right"
# Locations
locations = sequences.get_lists_combinations(["upper", "center", "lower"], ["left", "center", "right"], combine=lambda x: " ".join(x) if x[0] != x[1] else x[0])
# -----------------------------------------------------------------
# Create configuration definition
definition = ConfigurationDefinition()
#definition.add_flag("old", "old plotting methods", False)
# SEDs from file
definition.add_positional_optional("seds", "filepath_list_or_string_filepath_dictionary", "SED files to be plotted")
definition.add_flag("multi", "look for multiple SEDs per file", False)
definition.add_optional("wavelength_unit_file", "length_unit", "wavelength unit in SED file")
definition.add_optional("unit_file", "photometric_unit", "photometric unit in SED file")
definition.add_optional("distance", "length_quantity", "object distance (for flux <> luminosity unit conversion")
# Add plotting options
definition.import_section("plot", "plotting options", plot_definition)
# Add optional
definition.add_optional("output", "string", "output directory")
definition.add_optional("format", "string", "plotting format", default=default_format, choices=formats)
# -----------------------------------------------------------------
# The unit in which to plot
definition.add_optional("wavelength_unit", "length_unit", "unit of wavelength", "micron", convert_default=True)
definition.add_optional("unit", "photometric_unit", "photometric unit", "Jy", 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
# -----------------------------------------------------------------
# Create the configuration
definition = ConfigurationDefinition()
# Add optional arguments
definition.add_section("wavelengths")
definition.sections["wavelengths"].add_optional("unit", str, "the unit of the wavelengths", "micron")
definition.sections["wavelengths"].add_optional("min", float, "the minimum wavelength", 0.09)
definition.sections["wavelengths"].add_optional("max", float, "the maximum wavelength", 2000)
definition.sections["wavelengths"].add_optional("npoints", int, "the number of wavelength points", 100)
definition.sections["wavelengths"].add_optional("min_zoom", float, "the minimum wavelength of the zoomed-in grid", 1)
definition.sections["wavelengths"].add_optional("max_zoom", float, "the maximum wavelength of the zoomed-in grid", 30)
definition.sections["wavelengths"].add_optional("npoints_zoom", int, "the number of wavelength points in the zoomed-in grid", 100)
definition.add_optional("packages", float, "the number of photon packages per wavelength", 2e5)
definition.add_flag("selfabsorption", "enable dust self-absorption")
definition.add_optional("dust_grid", str, "the type of dust grid to use (bintree, octtree or cartesian)", "bintree")
# -----------------------------------------------------------------
#!/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 configuration definition
definition = ConfigurationDefinition()
# Add optional
definition.add_positional_optional("ski", "file_path", "ski file to be used (if not specified, all ski files in the current directory will be used)")
# Add flag
definition.add_flag("recursive", "look for ski files recursively")
# Add optional
definition.add_optional("remote", "string", "the remote host (no schedulers) on which to launch the simulations", choices=find_host_ids(schedulers=False))
# Add optional
definition.add_optional("nprocesses", "integer", "number of processes to use", 1)
definition.add_flag("data_parallel", "use data parallelization mode")
# -----------------------------------------------------------------
# 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)
# -----------------------------------------------------------------
show_normalizations(ski, flux_unit=config.flux)
from pts.core.basics.configuration import ConfigurationDefinition
from pts.magic.core.cutout import interpolation_methods
# -----------------------------------------------------------------
default_method = "pts"
default_interpolation_method = "pts"
# -----------------------------------------------------------------
# Create the configuration
definition = ConfigurationDefinition()
definition.add_required("image", "string", "name of the input image")
definition.add_required("regions", "string", "name of the regions file over which to interpolate")
definition.add_flag("write_mask", "write out the mask")
definition.add_optional("color", "string", "only interpolate over the shapes with this color")
definition.add_optional("ignore_color", "string", "ignore shapes with this particular color")
definition.add_optional("shapes", "string_list", "only interpolate over these kinds of shapes")
definition.add_optional("input", "string", "name of the input directory", letter="i")
definition.add_optional("output", "string", "name of the output directory", letter="o")
definition.add_optional("method", "string", "interpolation method to use", default=default_method)
definition.add_optional("interpolation_method", "string", "interpolation method", default_interpolation_method, choices=interpolation_methods)
definition.add_flag("sigma_clip", "apply sigma clipping before interpolation", True)
definition.add_optional("source_outer_factor", "real", "outer factor", 1.4)
definition.add_flag("plot", "plot after interpolation", False)
definition.add_flag("replace", "allow the original image to be replaced", False)
definition.add_flag("backup", "backup if replaced", True)
definition.add_optional("backup_suffix", "string", "backup suffix", "backup")
# -----------------------------------------------------------------
# -----------------------------------------------------------------
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.magic.core.list import NamedFrameList
from pts.core.tools import filesystem as fs
from pts.magic.basics.coordinatesystem import CoordinateSystem
# -----------------------------------------------------------------
# Create the definition
definition = ConfigurationDefinition()
# Select files
definition.add_optional("contains", "string_list",
"only files whose name contain one of these strings")
# Options
definition.add_optional("name", "string", "rebin to this name")
definition.add_optional("wcs", "file_path",
"path to the file from which to take the WCS")
# Flags
definition.add_flag("backup", "make backups", True)
# Parse the command line arguments
config = parse_arguments("rebin", definition)
# -----------------------------------------------------------------
# Load frame list
# *****************************************************************
# ** 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()
# Commands to be run
definition.add_positional_optional("commands", "string_list", "commands to be run in interactive mode")
# Interactive mode
definition.add_flag("interactive", "use interactive mode", True)
# -----------------------------------------------------------------
# Caching
definition.add_optional("cache_volume", "string", "name of the volume to be used for caching")
# -----------------------------------------------------------------
# Set plotting backend
definition.add_optional("mpl_backend", "string", "set the matplotlib backend")
# -----------------------------------------------------------------
#!/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)
# -----------------------------------------------------------------
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)
definition.add_flag("only_skirt", "only SKIRT", False)
definition.add_flag("only_pts", "only PTS", False)
definition.add_flag("only_sampled", "only sampled", False)
# Output path
definition.add_optional("output", "directory_path", "output path")
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.modeling.preparation.initialization import PreparationInitializer
from pts.core.tools import logging, time, tables
from pts.core.tools import filesystem as fs
from pts.magic.core.frame import Frame
from pts.core.basics.configuration import ConfigurationDefinition, ConfigurationReader
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
# Add optional arguments
definition.add_optional(
"image", str, "the name of the image for which to run the initialization")
definition.add_flag("visualise", "make visualisations")
# Get configuration
reader = ConfigurationReader("initialize_preparation")
config = reader.read(definition)
# -----------------------------------------------------------------
# Determine the log file path
logfile_path = fs.join(fs.cwd(), "log",
time.unique_name("log") +
".txt") if config.report else None
# Determine the log level
level = "DEBUG" if config.debug else "INFO"
# Ensure Python 3 compatibility
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.basics.log import log
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.core.remote.remote import Remote
from pts.core.remote.host import find_host_ids
# -----------------------------------------------------------------
definition = ConfigurationDefinition()
definition.add_optional("remotes",
"string_list",
"remote host ID",
choices=find_host_ids(),
default=find_host_ids())
config = parse_arguments("sessions", definition)
# -----------------------------------------------------------------
# Loop over the remote host
for host_id in config.remotes:
# Create and setup the remote
remote = Remote()
if not remote.setup(host_id):
raise RuntimeError("The remote host '" + host_id +
"' is not available at the moment")
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")
# -----------------------------------------------------------------
# Check quantity
if is_photometric_quantity(config.quantity):
#physical_types = possible_physical_types(config.quantity)
# 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.services.attenuation import GalacticAttenuation
from pts.core.basics.plot import MPLFigure
from pts.core.filter.broad import categorize_filters, categorized_filters_sorted_labels, get_filters_for_regimes
from pts.magic.basics.coordinatesystem import CoordinateSystem
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
definition.add_positional_optional("galaxy_name", "string", "galaxy name")
definition.add_optional("image", "file_path", "image path")
# Get the configuration
config = parse_arguments("attenuation", definition)
# -----------------------------------------------------------------
# Create attenuation object
if config.image is not None:
wcs = CoordinateSystem.from_file(config.image)
attenuation = GalacticAttenuation(wcs.bounding_box.center)
# or attenuation = GalacticAttenuation(wcs.center_sky)
else:
attenuation = GalacticAttenuation(config.galaxy_name)
# -----------------------------------------------------------------
# ** © 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("ski", "file_path", "path to the ski file")
# Add optional
definition.add_optional("input", "directory_path", "path to the input directory")
# Add optional
definition.add_optional("nwavelengths", "integer", "the number of wavelengths (useful for when a file wavelength grid is used and the file is not present)")
definition.add_optional("ncells", "integer", "number of dust cells (useful only when the ski file includes a tree dust grid)")
# Add flag
definition.add_flag("probe", "probe the number of cells (or memory usage) by launching a dry-run of the simulation, if necessary (tree dust grid and ncells not specified)", True)
# Add optional
definition.add_optional("nprocesses", "integer_list", "number of processes", [1, 2, 4, 8, 12, 20])
# Add flag
#definition.add_flag("data_parallel", "with data parallelization mode")
# Flags
from pts.magic.view.html import scales, colormaps, zooms
# -----------------------------------------------------------------
default_scale = "log"
default_colormap = "viridis"
default_zoom = "toFit"
# -----------------------------------------------------------------
# Create the configuration
definition = ConfigurationDefinition(log_path="log", config_path="config")
definition.add_flag("show", "show the page", False)
# Filters
definition.add_optional("filters", "filter_list", "filters")
# Preload
definition.add_flag("preload_all", "preload all images", False)
definition.add_optional("preload", "filter_list",
"filters for which to preload the image")
# View settings
definition.add_optional("scale",
"string",
"scale",
default_scale,
choices=scales)
definition.add_optional("colormap",
"string",
"color map",
from pts.core.tools import filesystem as fs
from pts.dustpedia.core.database import DustPediaDatabase, get_account
from pts.dustpedia.core.sample import DustPediaSample
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.magic.services.s4g import get_galaxy_names, has_galaxy
from pts.core.basics.map import Map
from pts.core.basics.log import log
from pts.core.basics.table import SmartTable
# -----------------------------------------------------------------
# Create the configuration
definition = ConfigurationDefinition()
#
definition.add_optional("ngalaxies", "positive_integer", "max number of galaxies")
# Get configuration
config = parse_arguments("plot_galaxies", definition)
# -----------------------------------------------------------------
# Create the database instance
database = DustPediaDatabase()
#username, password = get_account()
#database.login(username, password)
# -----------------------------------------------------------------
sample = DustPediaSample()
galaxy_names = sample.get_names()
# *****************************************************************
# ** 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 definition
definition = ConfigurationDefinition(write_config=False)
definition.add_flag("plot", "do plotting", False)
definition.add_optional("fwhm", "positive_real", "FWHM in pixels", 5.)
definition.add_optional("shape", "integer_tuple", "shape", (300, 500))
definition.add_optional("nsources", "positive_integer", "number of sources",
100)
definition.add_optional("flux_range",
"real_range",
"range of flux of sources",
"500>1000",
convert_default=True)
definition.add_optional("noise_stddev", "real", "stddev of noise", 2.)
definition.add_optional("constant_sky", "real", "constant sky value", 5.)
definition.add_flag("rotate", "rotate", 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()
# Optional
definition.add_optional("default_fwhm",
"quantity",
"default FWHM",
"2.0 arcsec",
convert_default=True)
definition.add_optional("sigma_level", "real", "sigma level", 4.0)
# -----------------------------------------------------------------
origins = ["model", "fitting_run"]
dust_grid_types = ["cartesian", "bintree", "octtree"]
default_dust_grid_type = "bintree"
# -----------------------------------------------------------------
definition.add_required("origin",
"string",
"origin of the analysis model",
choices=origins)
# -----------------------------------------------------------------
# Give the analysis run a custom name
definition.add_optional("name",
"string",
"name for the analysis run",
forbidden=run_names)
# -----------------------------------------------------------------
# Settings for the wavelength grid generation
definition.add_section("wg", "settings for the wavelength grids")
definition.sections["wg"].add_optional("npoints", "positive_integer",
"range of the wavelength grid size",
450)
definition.sections["wg"].add_flag(
"add_emission_lines", "add emission lines to the wavelength grids", True)
definition.sections["wg"].add_optional("range",
"quantity_range",
"range of wavelengths",
"0.1 micron > 2000 micron",
# *****************************************************************
# ** 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 definition
definition = ConfigurationDefinition(write_config=False)
# Number of frames
definition.add_optional("nframes", "positive_integer", "number of frames", 2)
# Size of frames
definition.add_optional("npixels", "positive_integer",
"number of pixels of the frames", 500)
# Number of sources
definition.add_optional("nrandom_sources", "positive_integer",
"number of point sources", 100)
# Flags
definition.add_flag("vary_fwhm", "vary the FWHM", False)
# PSF model
definition.add_fixed("psf_model", "psf model", "gaussian")
# 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")
# -----------------------------------------------------------------
# Spacing of the maps
definition.add_optional("spacing", "string", "method of determining the grid cell spacing", default_spacing_measure, choices=spacing_measures)
definition.add_optional("spacing_factor", "positive_real", "factor by which to multiply the grid cells spacing measure to become the actual map spacing", default_spacing_factor)
# -----------------------------------------------------------------
# Do interpolation on the maps
definition.add_flag("interpolate", "do interpolation", False)
from pts.core.prep.update import PTSUpdater
# -----------------------------------------------------------------
# Configuration definition
definition = ConfigurationDefinition()
# Required parameters
definition.add_required("message", "string", "the commit message")
# Optional parameters
definition.add_positional_optional("git_remotes",
"string_list",
"the remote(s) to commit to",
default="origin")
definition.add_optional("remote", "string",
"the remote on which to pull the changes")
# -----------------------------------------------------------------
# Get the configuration
config = parse_arguments(
"push_pts",
definition,
description=
"Add all, commit and push to remote repositories, and pull again on remote systems"
)
# -----------------------------------------------------------------
# Get the path to the PTS repository
pts_repo_path = introspection.pts_package_dir
# *****************************************************************
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition
from pts.core.remote.host import find_host_ids
# -----------------------------------------------------------------
# Create definition
definition = ConfigurationDefinition(write_config=False)
definition.add_flag("plot", "do plotting", False)
definition.add_flag("rotate", "rotation", True)
definition.add_optional("nrandom_sources", "positive_integer", "number of random sources", 100)
definition.add_flag("vary_fwhm", "vary the FWHM slightly for each star", True)
definition.add_flag("add_catalogued_sources", "add catalogued sources", False)
definition.add_optional("point_source_catalogs", "string_list", "point source catalogs", ["II/246"])
definition.add_optional("nfilters_stars", "positive_integer", "number of filters to use where stars are visible", 4)
definition.add_optional("nfilters_extra", "positive_integer", "number of filters to use where stars are not visible", 2)
definition.add_optional("psf_model", "string", "model to use for the PSF", "airydisk", choices=["gaussian", "airydisk"])
definition.add_optional("noise_stddev", "real", "stddev of noise", 5.)
definition.add_flag("only_local", "only evaluate PSFs locally", 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()
# Optional
definition.add_optional("default_fwhm", "quantity", "default FWHM", "2.0 arcsec", convert_default=True)
definition.add_optional("sigma_level", "real", "sigma level", 4.0)
# -----------------------------------------------------------------
from pts.core.config.analyse_simulation import definition as analysis_definition
# -----------------------------------------------------------------
host_ids = find_host_ids()
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
# Assignment file
definition.add_positional_optional("assignment", "file_path", "path of assignment file")
# Status file
definition.add_optional("status", "file_path", "path of status file")
# Remotes for which to find corresponding simulations
definition.add_optional("remotes", "string_list", "remote hosts for which to look for matching simulations (not necessary when assignment is specified)", default=host_ids, choices=host_ids)
# To specify the simulations
definition.add_optional("simulation_names", "string_list", "names of the simulations to look for")
definition.add_optional("simulation_ids", "integer_list", "IDs of the simulations (only if one remote host is specified)")
definition.add_flag("from_directories", "use directory names as simulation names")
# Timing and memory table
definition.add_optional("timing", "file_path", "timing table path")
definition.add_optional("memory", "file_path", "memory table path")
# Commands to be run
definition.add_optional("commands", "string_list", "commands to be run in interactive mode")
from pts.core.basics.animation import Animation
from pts.core.basics.apng import APNG
from pts.core.basics.numpngw import write_apng
# -----------------------------------------------------------------
formats = ["avi", "gif", "apng"]
default_format = "gif"
# -----------------------------------------------------------------
# Create the definition
definition = ConfigurationDefinition()
# File format
definition.add_optional("format", "string", "output format", default_format, choices=formats)
definition.add_optional("fps", "positive_integer", "frames per second", 10)
# Parse the command line arguments
config = parse_arguments("animate", definition)
# -----------------------------------------------------------------
# Add the frames
paths = fs.files_in_cwd(extension="png", sort=int)
# Determine path
path = "animation." + config.format
# APNG
if config.format == "apng":
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)
# -----------------------------------------------------------------
# Save
# -----------------------------------------------------------------
formats = ["pdf", "png"]
default_format = "pdf"
normalizations = ["max", "sum"]
# -----------------------------------------------------------------
# Create configuration definition
definition = ConfigurationDefinition()
# Distributions
definition.add_positional_optional("distributions", "filepath_list", "distribution files to be plotted")
definition.add_flag("panels", "plot the distributions in separate panels")
definition.add_flag("recursive", "search distribution files recursively in the working directory")
definition.add_optional("normalize", "string", "normalize all distributions by a certain method", choices=normalizations)
definition.add_optional("normalization_value", "real", "value for normalization", 1.)
# Add plotting options
definition.import_section("plot", "plotting options", plot_definition)
definition.sections["plot"].optional["xsize"].default = 8
definition.sections["plot"].optional["ysize"].default = 4
definition.add_flag("logscale", "use value log scale")
definition.add_flag("logfrequency", "use log scale for frequency")
definition.add_optional("bar_width", "positive_real", "relative width of the bars (1 means edges touch)", 1.)
definition.add_flag("use_name_xlabel", "use the distribution name(s) for the x labels of the panels")
definition.add_flag("colours_per_panel", "reuse the same colours for each panel")
# Add features
definition.add_flag("smooth", "add smooth curves to plot")
definition.add_flag("statistics", "add statistics to plot")
environment = load_modeling_environment_cwd()
suite = environment.static_model_suite
# -----------------------------------------------------------------
dust_grid_types = ["cartesian", "bintree", "octtree"]
default_dust_grid_type = "bintree"
# -----------------------------------------------------------------
# Create the configuration
definition = ConfigurationDefinition(log_path="log", config_path="config")
# Name of the representation
if suite.has_representations: definition.add_required("name", "string", "name for the representation", forbidden=suite.representation_names)
else: definition.add_optional("name", "string", "name for the representation", default="highres")
# 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)
# Dust grid properties
definition.add_section("dg", "settings for the dust grid")
definition.sections["dg"].add_optional("grid_type", "string", "type of dust grid", default_dust_grid_type, choices=dust_grid_types)
definition.sections["dg"].add_optional("scale", "real", "number of image pixels to take as the minimum scale in the model (can also be a certain fraction of a pixel)", 0.5)
definition.sections["dg"].add_optional("bintree_min_level", "integer", "minimum depth level for binary trees", 9)
definition.sections["dg"].add_optional("octtree_min_level", "integer", "minimum depth level for octrees", 3)
definition.sections["dg"].add_optional("max_mass_fraction", "real", "maximum mass fraction in each cell", 0.5e-6)
definition.sections["dg"].add_optional("scale_heights", "real", "number of times to take the dust scale height as the vertical radius of the dust grid", 10.)
# Create the configuration
definition = ConfigurationDefinition()
# Add flags
definition.add_flag("check_hosts",
"check the availability of the remote hosts", True)
definition.add_flag("deploy", "deploy SKIRT and PTS where necessary", False)
definition.add_flag("check_versions",
"check versions of SKIRT and PTS where necessary", True)
definition.add_flag("update_dependencies", "update PTS dependencies", False)
# Advanced settings
definition.add_flag("local", "keep computationaly heavy computations local")
definition.add_optional(
"remotes",
"string_list",
"remote hosts for computationally heavy computations (overrule the modeling configuration)",
choices=find_host_ids())
definition.add_flag(
"fitting_local",
"launch the simulations as part of the fitting locally (overrule the modeling configuration"
)
definition.add_optional(
"fitting_remotes",
"string_list",
"remote hosts for the fitting (overrule the modeling configuration)",
choices=find_host_ids())
definition.add_flag("attached", "run remote computations in attached mode")
definition.add_flag("fitting_attached",
"run the simulations remotely in attached mode")
# -*- 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.evolve.solve.extremizer import genetic_definition
# -----------------------------------------------------------------
# Create definition
definition = ConfigurationDefinition(write_config=False)
# Settings
#definition.add_optional("nruns", "positive_integer", "number of runs", 2)
definition.add_optional("ngenerations", "positive_integer",
"number of generations", 10)
definition.add_optional("nindividuals", "even_integer",
"number of individuals per generation", 100)
# Genetic settings
definition.import_section("genetic", "genetic algorithm settings",
genetic_definition)
# Flags
definition.add_flag("plot", "plot", True)
# -----------------------------------------------------------------
# *****************************************************************
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition
from pts.core.remote.host import find_host_ids
# -----------------------------------------------------------------
# Create definition
definition = ConfigurationDefinition(write_config=False)
definition.add_flag("plot", "do plotting", False)
definition.add_flag("rotate", "rotation", True)
definition.add_optional("nrandom_sources", "positive_integer",
"number of random sources", 100)
definition.add_flag("vary_fwhm", "vary the FWHM slightly for each star", True)
definition.add_flag("add_catalogued_sources", "add catalogued sources", False)
definition.add_optional("point_source_catalogs", "string_list",
"point source catalogs", ["II/246"])
definition.add_optional("nfilters_stars", "positive_integer",
"number of filters to use where stars are visible", 4)
definition.add_optional(
"nfilters_extra", "positive_integer",
"number of filters to use where stars are not visible", 2)
definition.add_optional("psf_model",
#!/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")
# Flags
definition.add_flag("write", "write the components and properties", False)
definition.add_flag("show", "show the parameters", True)
# The output directory
definition.add_optional("output", "directory_path", "output directory", letter="o")
# -----------------------------------------------------------------
definition.add_required(
"ski_path", "file_path",
"the name of the ski file to be used for the scaling test")
definition.add_required("remote", "string", "the name of the remote host")
definition.add_required("mode",
"string",
"the parallelization mode for the scaling test",
choices=["mpi", "hybrid", "threads"])
# Optional arguments
definition.add_positional_optional("maxnodes", "real",
"the maximum number of nodes", 1)
definition.add_positional_optional(
"minnodes", "real",
"the minimum number of nodes. In hybrid mode, this also defines the number of threads per process",
0)
definition.add_optional("cluster", "string", "the name of the cluster", None)
definition.add_optional("wavelengths", "real",
"boost the number of wavelengths by a certain factor",
None)
definition.add_optional(
"packages", "real",
"boost the number of photon packages by a certain factor", None)
# Flags
definition.add_flag("manual", "launch and inspect job scripts manually")
definition.add_flag(
"keep", "keep the output generated by the different SKIRT simulations")
# -----------------------------------------------------------------
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition, parse_arguments
from pts.magic.tools.segments import segments_to_regions
from pts.magic.core.segmentationmap import SegmentationMap
# -----------------------------------------------------------------
# Initialize definition
definition = ConfigurationDefinition()
# Add options
definition.add_required("segments", "file_path", "segmentation map")
definition.add_required("regions", "string", "path of the output regions file")
# Add optional
definition.add_optional("mask", "string", "path to an output mask file")
definition.add_optional(
"offset", "real",
"offset to make the regions larger or smaller, in pixels")
#definition.add_optional("", )
# parser.add_argument("--xc", nargs='?', const=1, help="Optional: If you don't want to mask the galaxy with the given x-coordinate of the center",type=str, default=None)
# parser.add_argument("--yc", nargs='?', const=1, help="Optional: If you don't want to mask the galaxy with the given y-coordinate of the center",type=str, default=None)
# parser.add_argument("--fits_slice", nargs='?', const=1, help="Optional: Fits slice in the segmentation map to be used. Default 0.",type=str, default='0')
# Get the configuration
config = parse_arguments("pix_to_sky", definition)
# -----------------------------------------------------------------
# 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.environment import find_modeling_environment_up_cwd
from pts.magic.plot.imagegrid import ResidualImageGridPlotter
from pts.core.tools import filesystem as fs
from pts.magic.core.frame import Frame
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
definition.add_optional("not_filters", "lazy_broad_band_filter_list", "don't show these filters")
definition.add_flag("downsample", "perform downsampling")
definition.add_optional("max_npixels", "positive_integer", "maximum number of pixels to enabled downsampling", 400)
definition.add_flag("truncate", "truncate the images", True)
definition.add_flag("distributions", "show residual distributions", False)
# Extra
definition.add_flag("normalize", "normalize the images")
definition.add_optional("share_scale_with", "string", "share the scale of all other images with this image")
definition.add_optional("colormap", "string", "colormap", "viridis")
# Extra
definition.add_flag("write_data", "write data")
# 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)
# Backup existing wavelength grids
definition.add_flag("backup", "backup existing wavelength grids", True)
# Create the configuration
config = parse_arguments("make_wavelength_grids", definition, "(Re)make the wavelength grids for a fitting run")
# -----------------------------------------------------------------
# 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
simulation = get_simulation_for_host(config.remote, config.id)
# Check whether retrieved (specific to remote simulations)
if not simulation.retrieved: raise ValueError("The simulation has not been retrieved yet")
# ** © Astronomical Observatory, Ghent University **
# *****************************************************************
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition
# -----------------------------------------------------------------
# Create the configuration
definition = ConfigurationDefinition()
# Add prequired
definition.add_required("ski", "file_path", "name or path of the ski file")
# Add optional argument
definition.add_optional("input", "directory_path",
"path to the input directory")
# Add required
definition.add_required("nnodes", "integer", "number of nodes")
definition.add_required("nsockets", "integer", "number of sockets per node")
definition.add_required("ncores", "integer", "number of cores per socket")
definition.add_required("memory", "real", "available virtual memory per node")
# Add flags
definition.add_flag("mpi", "mpi available", True)
definition.add_flag("hyperthreading", "use hyperthreading", False)
definition.add_optional("threads_per_core", "integer",
"number of hyperthreads per core")
# Add optional
definition.add_optional(
# -----------------------------------------------------------------
# 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")
definition.add_optional("plot_path", "string", "plot output path")
definition.add_optional("plotting", "dictionary", "plotting options", dict())
# Formatting of the values
definition.add_flag("round", "round the table values")
definition.add_optional("ndecimal_places", "positive_integer", "number of decimal places when rounding")
# Additional options
definition.add_flag("unique", "show only the unique in each column")
definition.add_flag("sorted_unique", "sort the unique values")
# *****************************************************************
# ** 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.modeling.tests.NGC4013.test import fitting_filter_names, free_parameters, free_parameter_labels
# -----------------------------------------------------------------
# Create definition
definition = ConfigurationDefinition(write_config=False)
# Simulation
definition.add_optional("npackages", "positive_integer",
"number of photon packages", int(1e4))
# Free parameters
definition.add_optional("free_parameters",
"string_list",
"list of free parameters",
free_parameter_labels,
choices=free_parameters)
# Fitting filters
definition.add_optional("fitting_filters",
"filter_list",
"filters for the fitting",
fitting_filter_names,
convert_default=True)
# ** © 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
from pts.modeling.tests.base import default_free_parameters, possible_free_parameters
from pts.evolve.solve.extremizer import genetic_definition
# -----------------------------------------------------------------
# Create definition
definition = ConfigurationDefinition(write_config=False)
# Optional settings
definition.add_optional("nwavelengths", "positive_integer", "number of wavelengths for the reference simulation", 50)
definition.add_optional("npackages", "positive_integer", "number of photon packages per wavelength for the reference simulation", int(1e5))
definition.add_optional("dust_grid_relative_scale", "real", "smallest scale of the dust grid relative to the pixelscale of the input maps", 2.)
definition.add_optional("dust_grid_min_level", "positive_integer", "level for the dust grid", 2)
definition.add_optional("dust_grid_max_mass_fraction", "positive_real", "max mass fraction for the dust grid", 1e-6)
# Flags
definition.add_flag("transient_heating", "enable transient heating", False)
definition.add_flag("selfabsorption", "enable dust selfabsorption", False)
# For remote execution
definition.add_optional("host_ids", "string_list", "remote hosts to use for heavy computations and simulations", choices=find_host_ids())
definition.add_flag("attached", "launch remote executions in attached mode", False)
# Fitting
definition.add_optional("ngenerations", "positive_integer", "number of generations", 5)
# *****************************************************************
# Import the relevant PTS classes and modules
from pts.core.basics.configuration import ConfigurationDefinition
from pts.magic.tools.catalogs import stellar_catalog_descriptions
# -----------------------------------------------------------------
# Create the configuration definition
definition = ConfigurationDefinition()
definition.add_flag(
"use_frame_fwhm",
"If possible, avoid the fitting procedure and use the FWHM defined by the frame",
True)
definition.add_optional("input_path", "directory_path",
"path to the input directory")
definition.add_optional("output_path", "directory_path",
"path to the output directory")
definition.add_flag("track_record", "track record", False)
definition.add_flag("plot_track_record_if_exception", True)
definition.add_optional("manual_region", "file_path", "manual star region")
definition.add_flag("remove", "remove stars from the frame", True)
definition.add_flag("find_saturation", "find saturated stars", True)
# -----------------------------------------------------------------
# Settings for fetching the catalogs
definition.add_section("fetching", "fetching")
# THE CATALOGS
default_catalogs = ["2MASS"]
from pts.core.basics.configuration import ConfigurationDefinition
from pts.magic.config.extract import definition as extraction_definition
from pts.magic.config.subtract_sky import definition as subtraction_definition
from pts.core.tools.parallelization import ncores
# -----------------------------------------------------------------
# Create the configuration
definition = ConfigurationDefinition()
# The dataset or image
definition.add_positional_optional("dataset", "file_path",
"name of the dataset file or image file")
# The maximum FWHM (minimum resolution that has to be retained in the convolved frames)
definition.add_optional("max_fwhm", "quantity", "maximum FWHM for convolution")
# The minimum pixel size (minimum resolution that has to be retained in the rebinned frames)
definition.add_optional("max_pixelscale", "quantity",
"maximum pixelscale for rebinning")
# Add input section
#definition.add_section("input", "the names of the input files")
#definition.sections["input"].add_required("image", "image_path", "name of the input image")
#definition.sections["input"].add_optional("galaxy_region", "file_path", "file with galaxy regions", "galaxies.reg")
#definition.sections["input"].add_optional("star_region", "file_path", "file with star regions", "stars.reg")
#definition.sections["input"].add_optional("saturation_region", "file_path", "file with regions for saturated stars", "saturation.reg")
#definition.sections["input"].add_optional("other_region", "file_path", "file with regions for other contaminating sources", "other_sources.reg")
#definition.sections["input"].add_optional("segments", "file_path", "image with segmentation maps (as planes 'galaxies', 'stars' and 'other_sources')", "segments.fits")
# Number of parallel processes
from __future__ import absolute_import, division, print_function
# Import the relevant PTS classes and modules
from pts.core.tools import introspection
from pts.core.tools import filesystem as fs
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 time
# -----------------------------------------------------------------
# Create definition
definition = ConfigurationDefinition()
definition.add_positional_optional("remote", "string", "remote host on which to clear the temporary directory", choices=find_host_ids())
definition.add_optional("names", "string_list", "remove temporary directories matching these names (e.g. 'installation' matches 'installation_2017-05-03--08-45-44-410', 'installation_2017-05-03--13-52-28-371', etc. and also exact matches")
# Create setter
config = parse_arguments("clear_temp", definition)
# -----------------------------------------------------------------
# Remote
if config.remote is not None:
# Create the remote
remote = Remote(host_id=config.remote)
# Check whether names are given
if config.names is not None:
#!/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)
# -----------------------------------------------------------------
definition.add_positional_optional("ids", "string_integer_list_dictionary", "simulation IDs for the different remote hosts")
# Add flag
definition.add_flag("show_progress", "show the progress of the simulation that is still running (only if there is just one)", False)
definition.add_flag("debug_output", "show all simulation output in debug mode")
# -----------------------------------------------------------------
definition.add_flag("retrieve", "retrieve finished simulations", True)
definition.add_flag("analyse", "analyse retrieved simulations", True)
# -----------------------------------------------------------------
# Crashed
definition.add_flag("check_crashed", "check whether crashed simulations have the necessary output, if so, retrieve them")
definition.add_optional("retrieve_crashed", "string_integer_list_dictionary", "retrieve crashed simulations for these hosts and simulation IDs")
definition.add_flag("check_data", "for crashed simulations, check whether the simulation data is valid")
# -----------------------------------------------------------------
definition.add_flag("ignore_missing_data", "ignore missing data when analysing the simulations", False)
definition.add_flag("batch_replace", "replace timing and memory information when a simulation is ")
# -----------------------------------------------------------------
definition.add_flag("offline", "run in offline mode: only analyse already retrieved simulations and tasks, don't try to connect to remotes")
# -----------------------------------------------------------------
# ADVANCED
definition.add_optional("nopen_files", "positive_integer", "number of allowed open files", 2000)
# -*- 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
definition = ConfigurationDefinition()
# Commands to be run
definition.add_optional("commands", "string_list", "commands to be run in interactive mode")
# Interactive mode
definition.add_flag("interactive", "use interactive mode", default=None)
# -----------------------------------------------------------------
# Showing
definition.add_flag("show", "show stuff", True)
definition.add_flag("show_components", "show the model components", False)
# Plotting
definition.add_flag("plot", "do plotting", True)
# Writing
definition.add_flag("write", "do writing", True)
# *****************************************************************
# ** 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 optional arguments
definition.add_positional_optional("host_id", "string", "install SKIRT/PTS remotely")
definition.add_optional("repository", "string", "repository name from which to clone (only possible when installing remotely and SKIRT/PTS is already installed locally)")
# Add flags
definition.add_flag("private", "use the private SKIRT/PTS repository")
# Advanced
definition.add_flag("force", "force re-installation when already present", letter="f")
definition.add_flag("force_conda", "force installation of conda and creation of a conda environment even when it is already present")
definition.add_flag("finish", "finish previously initiated installation")
# Add flag
#definition.add_flag("all_remotes", "update on all remote hosts")
# For PTS:
definition.add_optional("python_name", "string_no_spaces", "name for the python environment for PTS (also the alias for the python executable)", "python_pts")
# *****************************************************************
# 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_positional_optional("remote", "string", "name of the remote host", choices=find_host_ids())
definition.add_positional_optional("matching", "string", "only adapt settings with a name matching this string")
definition.add_positional_optional("ids", "integer_list", "simulation IDs (if none specified, all simulation IDs will be used)")
definition.add_optional("names", "string_list", "simulation names")
definition.add_flag("from_directories", "use directory names as simulation names")
# -----------------------------------------------------------------
# Select certain properties
definition.add_optional("contains", "string", "only adapt properties containing this string in their name")
definition.add_optional("not_contains", "string", "don't adapt properties containing this string in their name")
definition.add_optional("exact_name", "string", "only adapt properties with this exact string as their name")
definition.add_optional("exact_not_name", "string", "don't adapt properties with this exact string as their name")
definition.add_optional("startswith", "string", "only adapt properties whose name starts with this string")
definition.add_optional("endswith", "string", "only adapt properties whose name starts with this string")
# -----------------------------------------------------------------
definition.add_optional("types", "string_list", "only adapt properties of these types")
# ** 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()
definition.add_positional_optional("host_ids",
"string_list",
"remote host(s)",
choices=find_host_ids(),
default=find_host_ids())
# Add optional
definition.add_optional("not_remotes",
"string_list",
"skip these remote hosts",
choices=find_host_ids())
# Add flag
definition.add_flag("show", "show the versions on the terminal", True)
definition.add_flag("one_attempt",
"only perform one attempt at connecting to a remote")
# -----------------------------------------------------------------
