Exemplo n.º 1
0
    def write_frame(self):

        """
        This function ...
        :return:
        """

        # Inform the user
        log.info("Saving the result ...")

        # Determine the path
        path = self.output_path_file(self.image_name)

        # Check if already existing
        if fs.is_file(path):

            if self.config.replace:
                if self.config.backup: fs.backup_file(path, suffix=self.config.backup_suffix)
                fs.remove_file(path)
            else:
                #raise ValueError("The image already exists")
                path = self.output_path_file("result.fits")

        # Save
        self.frame.saveto(path, header=self.header)
Exemplo n.º 2
0
Arquivo: restore.py Projeto: SKIRT/PTS
    def has_best_parameters(self):

        """
        This function ...
        :return:
        """

        return fs.is_file(self.restore_best_parameters_path)
Exemplo n.º 3
0
Arquivo: restore.py Projeto: SKIRT/PTS
    def has_configuration(self):

        """
        This function ...
        :return:
        """

        return fs.is_file(self.restore_configuration_path)
Exemplo n.º 4
0
Arquivo: restore.py Projeto: SKIRT/PTS
    def has_weights(self):

        """
        This function ...
        :return:
        """

        return fs.is_file(self.restore_weights_path)
Exemplo n.º 5
0
Arquivo: restore.py Projeto: SKIRT/PTS
    def restore_fluxes_plots(self):

        """
        This function ...
        :return:
        """

        # Inform the user
        log.info("Making a backup of the mock fluxes plots ...")

        # Loop over the generations
        for generation_name in self.generation_names:

            # Has generation?
            if not self.has_generation(generation_name): continue

            # Debugging
            log.debug("Creating backups for generation '" + generation_name + "' ...")

            # Get the generation
            generation = self.generations[generation_name]

            # Get restore path
            generation_path = self.get_generation_restore_path(generation_name)

            # Loop over the simulations
            for simulation_name in generation.simulation_names:

                # Set simulation path
                simulation_path = fs.join(generation_path, simulation_name)

                # Check whether fluxes are present
                filepath = fs.join(simulation_path, "earth_fluxes.pdf")
                if not fs.is_file(filepath):
                    log.warning("No mock SED plot for simulation '" + simulation_name + "' of generation '" + generation_name + "'")
                    continue

                # Debugging
                log.debug("Restoring fluxes plot for simulation '" + simulation_name + "' ...")

                # Copy the plot file
                fs.copy_file(filepath, generation.get_mock_sed_plot_path(simulation_name))
Exemplo n.º 6
0
Arquivo: restore.py Projeto: SKIRT/PTS
    def restore_differences(self):

        """
        This function ...
        :return:
        """

        # Inform the user
        log.info("Making a backup of the flux differences ...")

        # Loop over the generations
        for generation_name in self.generation_names:

            # Has generation?
            if not self.has_generation(generation_name): continue

            # Debugging
            log.debug("Creating backups for generation '" + generation_name + "' ...")

            # Get the generation
            generation = self.generations[generation_name]

            # Get restore path
            generation_path = self.get_generation_restore_path(generation_name)

            # Loop over the simulations
            for simulation_name in generation.simulation_names:

                # Set simulation path
                simulation_path = fs.join(generation_path, simulation_name)

                # Check whether the simulation has differences
                filepath = fs.join(simulation_path, "differences.dat")
                if not fs.is_file(filepath):
                    log.warning("No differences table for simulation '" + simulation_name + "' of generation '" + generation_name + "'")
                    continue

                # Debugging
                log.debug("Restoring differences table for simulation '" + simulation_name + "' ...")

                # Copy the file
                fs.copy_file(filepath, generation.get_simulation_sed_differences_path(simulation_name))
Exemplo n.º 7
0
    def write_frame(self):
        """
        This function ...
        :return:
        """

        # Inform the user
        log.info("Saving the result ...")

        # Determine the path
        path = fs.join(output_path, config.image)
        if fs.is_file(path):
            if config.replace:
                if config.backup:
                    fs.backup_file(path, suffix=config.backup_suffix)
                    fs.remove_file(path)
                else:
                    fs.remove_file(path)
            else:
                raise ValueError("The image already exists")

        # Save
        frame.saveto(path, header=header)
Exemplo n.º 8
0
# Determine the full path to the bad region file
bad_region_path = fs.join(input_path, arguments.bad) if arguments.bad is not None else None

# Import the image
importer = ImageImporter()
importer.run(image_path, bad_region_path=bad_region_path)

# Get the image
image = importer.image

# -----------------------------------------------------------------

# Load the galaxy region
galaxy_region_path = fs.join(input_path, "galaxies.reg")
galaxy_region = Region.from_file(galaxy_region_path) if fs.is_file(galaxy_region_path) else None

# Load the star region
star_region_path = fs.join(input_path, "stars.reg")
star_region = Region.from_file(star_region_path) if fs.is_file(star_region_path) else None

# Load the saturation region
saturation_region_path = fs.join(input_path, "saturation.reg")
saturation_region = Region.from_file(saturation_region_path) if fs.is_file(saturation_region_path) else None

# Load the region of other sources
other_region_path = fs.join(input_path, "other_sources.reg")
other_region = Region.from_file(other_region_path) if fs.is_file(other_region_path) else None

# Load the image with segmentation maps
segments_path = fs.join(input_path, "segments.fits")
Exemplo n.º 9
0
def show_possible_matches(matches, table_matches=None, tables=None):
    """
    This function ...
    :param matches:
    :param table_matches:
    :param tables:
    :return:
    """

    # The list that will contain the info about all the scripts / table commands
    info = []

    ## Combine script and table matches

    # Scripts
    for script in matches:

        subproject = script[0]
        command = script[1]

        # Determine the path to the script
        path = fs.join(introspection.pts_package_dir, "do", subproject,
                       command)

        # Get the description
        description = get_description(path, subproject, command[:-3])

        # Add entry to the info
        title = None
        configuration_module_path = None
        info.append((subproject, command[:-3], description, "arguments", title,
                     configuration_module_path))

    # Tables
    for subproject, index in table_matches:

        command = tables[subproject]["Command"][index]
        hidden = False
        if command.startswith("*"):
            hidden = True
            command = command[1:]
        if hidden: continue  # skip if hidden
        description = tables[subproject]["Description"][index]
        configuration_method = tables[subproject]["Configuration method"][
            index]

        configuration_name = tables[subproject]["Configuration"][index]
        if configuration_name == "--": configuration_name = command
        configuration_module_path = "pts." + subproject + ".config." + configuration_name
        real_configuration_module_path = introspection.pts_root_dir + "/" + configuration_module_path.replace(
            ".", "/") + ".py"
        if not fs.is_file(real_configuration_module_path):
            real_configuration_module_path = None

        title = tables[subproject]["Title"][index]
        info.append((subproject, command, description, configuration_method,
                     title, real_configuration_module_path))

    # Sort on the 'do' subfolder name
    info = sorted(info, key=itemgetter(0))

    # Print in columns
    with fmt.print_in_columns(6) as print_row:

        previous_subproject = None
        previous_title = None

        for script in info:

            configuration_method = script[3]
            description = script[2]

            # Get the title
            title = script[4]

            # Transform title
            if title is None: title = ""

            # Get the configuration module path
            has_configuration = script[5] is not None
            if has_configuration:
                has_configuration_string = fmt.green + "C" + fmt.reset
            else:
                has_configuration_string = fmt.red + "NC" + fmt.reset

            coloured_subproject = fmt.green + script[0] + fmt.reset
            coloured_name = fmt.bold + fmt.underlined + fmt.red + script[
                1] + fmt.reset
            coloured_config_method = fmt.yellow + "[" + configuration_method + "]" + fmt.reset

            coloured_title = fmt.blue + fmt.bold + title + fmt.reset

            if previous_subproject is None or previous_subproject != script[0]:
                previous_subproject = script[0]
                print_row(coloured_subproject, "/")

            if previous_title is None or previous_title != title:

                previous_title = title

                if title != "":
                    print_row()
                    print_row("", "", coloured_title)

            # Print command
            print_row("", "/", coloured_name, coloured_config_method,
                      description, has_configuration_string)
Exemplo n.º 10
0
definition.add_required("simulation_id", "integer", "ID of the simulation")
definition.add_required("job_id", "integer", "job ID")

# Create config
config = parse_arguments("set_postponed_job_id", definition, add_cwd=False)

# -----------------------------------------------------------------

# Determine the path to the run directory for the specified remote host
host_run_path = fs.join(introspection.skirt_run_dir, config.remote)

# -----------------------------------------------------------------

# Determine the path to the simulation file
simulation_file_path = fs.join(host_run_path, config.simulation_id + ".sim")
if not fs.is_file(simulation_file_path): raise ValueError("Simulation file '" + simulation_file_path + "' does not exist")

# -----------------------------------------------------------------

# Open the simulation file
simulation = RemoteSimulation.from_file(simulation_file_path)

# Create execution handle
handle = ExecutionHandle.job(config.job_id, config.host_id)

# Set the handle
simulation.handle = handle

# Save the simulation
simulation.save()
Exemplo n.º 11
0
    elif config.page == "fitting": page_path = fs.join(environment.html_path, fitting_page_filename)
    elif config.page == "seds": page_path = fs.join(environment.html_path, seds_page_filename)
    elif config.page == "datacubes": page_path = fs.join(environment.html_path, datacubes_page_filename)
    elif config.page == "fluxes": page_path = fs.join(environment.html_path, fluxes_page_filename)
    elif config.page == "images": page_path = fs.join(environment.html_path, images_page_filename)
    elif config.page == "attenuation": page_path = fs.join(environment.html_path, attenuation_page_filename)
    elif config.page == "colours": page_path = fs.join(environment.html_path, colours_page_filename)
    elif config.page == "heating": page_path = fs.join(environment.html_path, heating_page_filename)
    else: raise ValueError("Invalid page name")

    directory = None

# -----------------------------------------------------------------

# Check whether page exists
if not fs.is_file(page_path): raise ValueError("The page is not present")

# -----------------------------------------------------------------

# # Setup localhost server
# with browser.serve_local_host():
#     # Open
#     # SHOULD BE AN OPEN AND WAIT FOR CLOSING FUNCTION?
#     browser.open_path(page_path)

if directory is not None: fs.change_cwd(directory)

import subprocess
from pts.core.tools import introspection

python_path = introspection.python_executable_path()
Exemplo n.º 12
0
    elif a_is_colour and b_is_lum:

        a_part1, a_part2 = column_a.split("_")
        #a_filters = get_filters_for_colour(column_a)
        a_filter_names = filternames_for_colours[a_part1] + filternames_for_colours[a_part2]
        if column_b in a_filter_names: continue

    #print(column_a, column_b)

    # Set filename
    filename = column_a + "__" + column_b
    output_path = fs.join(config.output_path(), filename + "." + config.format)

    # Check
    if fs.is_file(output_path):
        if config.replot is not None and (column_a in config.replot or column_b in config.replot): fs.remove_file(output_path)
        else: continue

    # Logscales
    if a_is_colour or column_a in linear_scales: xlog = False
    else: xlog = True
    if b_is_colour or column_b in linear_scales: ylog = False
    else: ylog = True

    # Plot
    plotting.plot_table(filepath, column_a, column_b, output_path, x_log=xlog, y_log=ylog)

    ncombinations += 1

print(ncombinations)
Exemplo n.º 13
0
# Create the configuration definition
definition = ConfigurationDefinition()

# Add flags
definition.add_flag("table", "save the extracted progress table")

# Get configuration
reader = ConfigurationReader("plotprogress")
config = reader.read(definition)

# -----------------------------------------------------------------

# Look for a file in the current working directory that contains extracted progress information
progress_table_path = fs.join(fs.cwd(), "progress.dat")
if fs.is_file(progress_table_path):
    table = ProgressTable.from_file(progress_table_path)

    # If extracted progress information is not present, first perform the extraction
else:

    # Create a SkirtSimulation object based on a log file present in the current working directory
    simulation = createsimulations(single=True)

    # Create a new ProgressExtractor instance
    extractor = ProgressExtractor()

    # Run the extractor and get the table
    table = extractor.run(simulation)

# -----------------------------------------------------------------
Exemplo n.º 14
0
    generation_path = fs.join(fs.cwd(), "Generation " + str(last_generation))
    print("Current generation: " + str(last_generation))

# -----------------------------------------------------------------

# Path to the current GA object
path = fs.join(generation_path, "ga.pickle")

# Path to the parameters table
parameters_path = fs.join(generation_path, "parameters.dat")

# Path to the chi squared table
chi_squared_path = fs.join(generation_path, "chi_squared.dat")

# Check whether the generation is scored
if not fs.is_file(chi_squared_path): raise RuntimeError("The last generation has not been scored yet!")

# Path to the random state
random_path = fs.join(generation_path, "rndstate.pickle")

# -----------------------------------------------------------------

# Load the random state
load_state(random_path)

# -----------------------------------------------------------------

# Load the parameters table
parameters = tables.from_file(parameters_path, format="ascii.ecsv")

# Load the chi squared table
Exemplo n.º 15
0
def show_possible_matches(matches, table_matches=None, tables=None):

    """
    This function ...
    :param matches:
    :param table_matches:
    :param tables:
    :return:
    """

    # The list that will contain the info about all the scripts / table commands
    info = []

    ## Combine script and table matches

    # Scripts
    for script in matches:

        subproject = script[0]
        command = script[1]

        # Determine the path to the script
        path = fs.join(introspection.pts_package_dir, "do", subproject, command)

        # Get the description
        description = get_description(path, subproject, command[:-3])

        # Add entry to the info
        title = None
        configuration_module_path = None
        info.append((subproject, command[:-3], description, "arguments", title, configuration_module_path))

    # Tables
    for subproject, index in table_matches:

        command = tables[subproject]["Command"][index]
        hidden = False
        if command.startswith("*"):
            hidden = True
            command = command[1:]
        if hidden: continue # skip if hidden
        description = tables[subproject]["Description"][index]
        configuration_method = tables[subproject]["Configuration method"][index]

        configuration_name = tables[subproject]["Configuration"][index]
        if configuration_name == "--": configuration_name = command
        configuration_module_path = "pts." + subproject + ".config." + configuration_name
        real_configuration_module_path = introspection.pts_root_dir + "/" + configuration_module_path.replace(".", "/") + ".py"
        if not fs.is_file(real_configuration_module_path): real_configuration_module_path = None

        title = tables[subproject]["Title"][index]
        info.append((subproject, command, description, configuration_method, title, real_configuration_module_path))

    # Sort on the 'do' subfolder name
    info = sorted(info, key=itemgetter(0))

    # Print in columns
    with fmt.print_in_columns(6) as print_row:

        previous_subproject = None
        previous_title = None

        for script in info:

            configuration_method = script[3]
            description = script[2]

            # Get the title
            title = script[4]

            # Transform title
            if title is None: title = ""

            # Get the configuration module path
            has_configuration = script[5] is not None
            if has_configuration: has_configuration_string = fmt.green + "C" + fmt.reset
            else: has_configuration_string = fmt.red + "NC" + fmt.reset

            coloured_subproject = fmt.green + script[0] + fmt.reset
            coloured_name = fmt.bold + fmt.underlined + fmt.red + script[1] + fmt.reset
            coloured_config_method = fmt.yellow + "[" + configuration_method + "]" + fmt.reset

            coloured_title = fmt.blue + fmt.bold + title + fmt.reset

            if previous_subproject is None or previous_subproject != script[0]:
                previous_subproject = script[0]
                print_row(coloured_subproject, "/")

            if previous_title is None or previous_title != title:

                previous_title = title

                if title != "":
                    print_row()
                    print_row("", "", coloured_title)

            # Print command
            print_row("", "/", coloured_name, coloured_config_method, description, has_configuration_string)
Exemplo n.º 16
0
    raise RuntimeError(
        "The galactic catalog is invalid: principal galaxy not defined")

# Determine the path to the user catalogs directory
catalogs_user_path = fs.join(introspection.pts_user_dir, "magic", "catalogs")

# Determint the path to the directory to contain the catalogs for this galaxy
galaxy_user_path = fs.join(catalogs_user_path, galaxy_name)

# Cache the galaxy and stellar catalog
if fs.is_directory(galaxy_user_path):

    old_galactic_catalog_path = fs.join(galaxy_user_path, "galaxies.dat")
    old_stellar_catalog_path = fs.join(galaxy_user_path, "stars.dat")

    if fs.is_file(old_galactic_catalog_path):

        # Open the 'old' galaxy catalog
        old_galaxy_catalog = tables.from_file(old_galactic_catalog_path)

        # Create merged galaxy catalog
        galaxy_catalog = catalogs.merge_galactic_catalogs(
            galactic_catalog, old_galaxy_catalog)

        # Save the merged catalog
        path = fs.join(galaxy_user_path, "galaxies.dat")
        tables.write(galaxy_catalog, path)

    # If a galactic catalog file does not exist yet
    else:
        fs.copy_file(galactic_catalog_path, galaxy_user_path, "galaxies.dat")
Exemplo n.º 17
0
# 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.core.tools.serialization import load_dict
from pts.core.tools import sequences
from pts.core.tools import formatting as fmt

# -----------------------------------------------------------------

# Find methods file
methods_path = fs.join(fs.cwd(), "methods.txt")
if not fs.is_file(methods_path): raise IOError("Methods file not found")
methods = load_dict(methods_path)

# Find origins file
origins_path = fs.join(fs.cwd(), "origins.txt")
if not fs.is_file(origins_path): raise IOError("Origins file not found")
origins = load_dict(origins_path)

# -----------------------------------------------------------------

filenames = fs.files_in_path(fs.cwd(), returns="name", extension="fits")

# -----------------------------------------------------------------

map_names = sequences.union(methods.keys(), origins.keys(), filenames)
Exemplo n.º 18
0
    log.debug("The correction factor for the " + prep_name + " image is " +
              str(factor))
    correction_factors[prep_name] = factor

    #print(paths)
    #continue

    # Loop over the images
    for step in paths:

        # Get the path
        path = paths[step]

        # Check whether the correction has already been performed
        backup_filepath = fs.appended_filepath(path, "_backup")
        if fs.is_file(path):  # local

            if fs.is_file(backup_filepath):  # already corrected

                # Check
                corrected = Frame.from_file(path)
                backup = Frame.from_file(backup_filepath)

                ratio = corrected / backup
                ratios = ratio[np.isfinite(ratio)]
                if not np.all(np.isclose(ratios, factor)):
                    raise RuntimeError("Correction was not OK for " +
                                       prep_name + " after the " + step +
                                       " step: mean ratio of " +
                                       str(np.mean(ratios)))
Exemplo n.º 19
0
# If the galaxy name is still None, something is wrong with the galaxy catalog (principal not defined)
if galaxy_name is None: raise RuntimeError("The galactic catalog is invalid: principal galaxy not defined")

# Determine the path to the user catalogs directory
catalogs_user_path = fs.join(introspection.pts_user_dir, "magic", "catalogs")

# Determint the path to the directory to contain the catalogs for this galaxy
galaxy_user_path = fs.join(catalogs_user_path, galaxy_name)

# Cache the galaxy and stellar catalog
if fs.is_directory(galaxy_user_path):

    old_galactic_catalog_path = fs.join(galaxy_user_path, "galaxies.dat")
    old_stellar_catalog_path = fs.join(galaxy_user_path, "stars.dat")

    if fs.is_file(old_galactic_catalog_path):

        # Open the 'old' galaxy catalog
        old_galaxy_catalog = tables.from_file(old_galactic_catalog_path)

        # Create merged galaxy catalog
        galaxy_catalog = catalogs.merge_galactic_catalogs(galactic_catalog, old_galaxy_catalog)

        # Save the merged catalog
        path = fs.join(galaxy_user_path, "galaxies.dat")
        tables.write(galaxy_catalog, path)

    # If a galactic catalog file does not exist yet
    else: fs.copy_file(galactic_catalog_path, galaxy_user_path, "galaxies.dat")

    # Check whether there is a stellar catalog file in the galaxy's directory
Exemplo n.º 20
0
definition = ConfigurationDefinition()
definition.add_flag("generate", "first (re)generate the HTML", False)
config = parse_arguments("show_status", definition)

# -----------------------------------------------------------------

modeling_path = verify_modeling_cwd()

# -----------------------------------------------------------------

# Load the modeling environment
environment = GalaxyModelingEnvironment(modeling_path)

# -----------------------------------------------------------------

# Generate the HTML
if config.generate:

    # Generate the HTML
    generator = StatusPageGenerator()
    generator.config.path = modeling_path
    generator.run()

# -----------------------------------------------------------------

# Check whether the status page is present
if not fs.is_file(environment.html_status_path): raise ValueError("The status page is not present")
else: browser.open_path(environment.html_status_path)

# -----------------------------------------------------------------
Exemplo n.º 21
0
                                           returns=["name", "path"]):

        # Determine origin
        origin = instrument_to_origin(name.split("_")[1])

        # Determine local directory for this image
        origin_path = fs.join(environment.data_images_path, origin)
        if not fs.is_directory(origin_path): fs.create_directory(origin_path)

        # Determine local path
        local_path = fs.join(origin_path, name)

        #print("local_path")

        # Check whether the image is not present
        if fs.is_file(local_path):
            log.warning(
                "The '" + name +
                "' remotely cached image is still present locally. Keeping this file and throwing the remote file away."
            )
            continue
        else:
            # Infomr
            log.info("Downloading the '" + name + "' file to [" + origin_path +
                     "] ...")

            # Download
            remote.download_file_to(path, origin_path, remove=True)

            # Success
            log.success("Succesfully retrieved the '" + name + "' image ...")
Exemplo n.º 22
0
    generation_path = fs.join(fs.cwd(), "Generation " + str(last_generation))
    print("Current generation: " + str(last_generation))

# -----------------------------------------------------------------

# Path to the current GA object
path = fs.join(generation_path, "ga.pickle")

# Path to the parameters table
parameters_path = fs.join(generation_path, "parameters.dat")

# Path to the chi squared table
chi_squared_path = fs.join(generation_path, "chi_squared.dat")

# Check whether the generation is scored
if not fs.is_file(chi_squared_path):
    raise RuntimeError("The last generation has not been scored yet!")

# Path to the random state
random_path = fs.join(generation_path, "rndstate.pickle")

# -----------------------------------------------------------------

# Load the random state
load_state(random_path)

# -----------------------------------------------------------------

# Load the parameters table
parameters = tables.from_file(parameters_path, format="ascii.ecsv")
Exemplo n.º 23
0
# Create the configuration definition
definition = ConfigurationDefinition()

# Add flags
definition.add_flag("table", "save the extracted memory table")

# Get the configuration
reader = ConfigurationReader("plotmemory")
config = reader.read(definition)

# -----------------------------------------------------------------

# Look for a file in the current working directory that contains extracted memory information
memory_table_path = fs.join(fs.getcwd(), "memory.dat")
if fs.is_file(memory_table_path): table = MemoryUsageTable.from_file(memory_table_path)

# If extracted memory information is not present, first perform the extraction
else:

    # Create a SkirtSimulation object based on a log file present in the current working directory
    simulation = createsimulations(single=True)

    # Create a new MemoryExtractor instance
    extractor = MemoryExtractor()

    # Run the extractor and get the memory table
    table = extractor.run(simulation)

# -----------------------------------------------------------------
Exemplo n.º 24
0
# -----------------------------------------------------------------

# Create the configuration definition
definition = ConfigurationDefinition()

# Add flags
definition.add_flag("table", "save the extracted progress table")

# Get configuration
config = parse_arguments("plotprogress", definition)

# -----------------------------------------------------------------

# Look for a file in the current working directory that contains extracted progress information
progress_table_path = fs.join(fs.cwd(), "progress.dat")
if fs.is_file(progress_table_path): table = ProgressTable.from_file(progress_table_path)

# If extracted progress information is not present, first perform the extraction
else: table = extract_progress_cwd()

# -----------------------------------------------------------------

if config.table and not fs.is_file(progress_table_path): table.saveto(progress_table_path)

# -----------------------------------------------------------------

# Determine the path to the plotting directory
plot_path = fs.join(fs.cwd())

# Create a ProgressPlotter instance
plotter = ProgressPlotter()
Exemplo n.º 25
0
# -----------------------------------------------------------------

# Create the configuration definition
definition = ConfigurationDefinition()

# Add flags
definition.add_flag("table", "save the extracted memory table")

# Get the configuration
config = parse_arguments("plotmemory", definition)

# -----------------------------------------------------------------

# Look for a file in the current working directory that contains extracted memory information
memory_table_path = fs.join(fs.cwd(), "memory.dat")
if fs.is_file(memory_table_path):
    table = MemoryUsageTable.from_file(memory_table_path)

    # If extracted memory information is not present, first perform the extraction
else:

    # Create a SkirtSimulation object based on a log file present in the current working directory
    simulation = createsimulations(single=True)

    # Create a new MemoryExtractor instance
    extractor = MemoryExtractor()

    # Run the extractor and get the memory table
    table = extractor.run(simulation)

# -----------------------------------------------------------------
Exemplo n.º 26
0
# Create the configuration
definition = ConfigurationDefinition()

# Add flags
definition.add_flag("table", "save the extracted timeline table")

# Get configuration
reader = ConfigurationReader("plottimeline")
config = reader.read(definition)

# -----------------------------------------------------------------

# Look for a file in the current working directory that contains extracted timeline information
timeline_table_path = fs.join(fs.cwd(), "timeline.dat")
if fs.is_file(timeline_table_path):
    table = TimeLineTable.from_file(timeline_table_path)

    # If extracted timeline information is not present, first perform the extraction
else:

    # Create a SkirtSimulation object based on a log file present in the current working directory
    simulation = createsimulations(single=True)

    # Create a new TimeLineExtractor instance
    extractor = TimeLineExtractor()

    # Run the extractor and get the timeline table
    table = extractor.run(simulation)

# -----------------------------------------------------------------
Exemplo n.º 27
0
definition.add_required("simulation_id", "integer", "ID of the simulation")
definition.add_required("job_id", "integer", "job ID")

# Create config
config = parse_arguments("set_postponed_job_id", definition, add_cwd=False)

# -----------------------------------------------------------------

# Determine the path to the run directory for the specified remote host
host_run_path = fs.join(introspection.skirt_run_dir, config.remote)

# -----------------------------------------------------------------

# Determine the path to the simulation file
simulation_file_path = fs.join(host_run_path, config.simulation_id + ".sim")
if not fs.is_file(simulation_file_path):
    raise ValueError("Simulation file '" + simulation_file_path +
                     "' does not exist")

# -----------------------------------------------------------------

# Open the simulation file
simulation = RemoteSimulation.from_file(simulation_file_path)

# Create execution handle
handle = ExecutionHandle.job(config.job_id, config.host_id)

# Set the handle
simulation.handle = handle

# Save the simulation