Exemplo n.º 1
0
def retrieve_experiment(exp_id, sync_if_missing=True, verbose=False, force_update=False):
    """
    Retrieve an experiment in the local database based on its id.
    Can call a sync if missing if the flag is true.
    :param exp_id: Id of the experiment to retrieve
    :param sync_if_missing: Should we try to sync if not present?
    :return: The experiment found
    """
    if not exp_id: raise Exception("Trying to retrieve an experiment without providing an experiment ID")
    from uuid import UUID
    if isinstance(exp_id,UUID): exp_id = str(exp_id)

    # If we dont force the update -> look first in the DB
    exp = DataStore.get_experiment(exp_id) or DataStore.get_most_recent_experiment(exp_id)
    if exp:
        # If we have an experiment and we want to force the update -> delete it
        if not force_update:
            return exp
        else:
            DataStore.delete_experiment(exp)

    if not sync_if_missing:
        raise Exception('Experiment %s not found in the local database and sync disabled.' % exp_id)

    logger.info('Experiment with id %s not found in local database, trying sync.' % exp_id)
    with SetupParser.TemporarySetup(temporary_block='HPC') as sp:
        endpoint = sp.get('server_endpoint')

    exp = COMPS_experiment_to_local_db(exp_id, endpoint, verbose)

    if exp: return exp
    raise Exception("Experiment '%s' could not be retrieved." % exp_id)
Exemplo n.º 2
0
    def commission_iteration(self, next_params):
        """
        Commission an experiment of simulations constructed from a list of combinations of
        random seeds, calibration sites, and the next sample points.
        Cache the relevant experiment and simulation information to the IterationState.
        """
        if self.simulations:
            logger.info(
                'Reloading simulation data from cached iteration (%s) state.' %
                self.iteration)
            self.exp_manager = ExperimentManagerFactory.from_experiment(
                DataStore.get_experiment(self.experiment_id))
        else:
            self.exp_manager = ExperimentManagerFactory.init()

            # use passed in function to create exp_builder
            exp_builder = self.exp_builder_func(next_params)

            self.exp_manager.run_simulations(
                config_builder=self.config_builder,
                exp_name='%s_iter%d' % (self.calibration_name, self.iteration),
                exp_builder=exp_builder,
                suite_id=self.suite_id)

            self.simulations = self.exp_manager.experiment.toJSON(
            )['simulations']
            self.experiment_id = self.exp_manager.experiment.exp_id
            self.save()
Exemplo n.º 3
0
    def cleanup(self):
        """
        Cleanup the current calibration
        - Delete the result directory
        - If LOCAL -> also delete the simulations
        """
        try:
            calib_data = self.read_calib_data()
        except Exception:
            logger.info('Calib data cannot be read -> skip')
            calib_data = None

        if calib_data:
            with SetupParser.TemporaryBlock(calib_data['selected_block']):
                # Retrieve suite ids and iter_count
                suites = calib_data.get('suites')
                iter_count = calib_data.get('iteration')

                # Kill
                self.kill()

                # Delete the simulations too
                logger.info('Cleaning up calibration %s' % self.name)
                for i in range(0, iter_count + 1):
                    # Get the iteration cache
                    iteration_cache = os.path.join(self.name, 'iter%d' % i,
                                                   'IterationState.json')

                    if not os.path.exists(iteration_cache):
                        break
                    # Retrieve the iteration state
                    it = IterationState.from_file(iteration_cache)

                    # Create the associated experiment manager and ask for deletion
                    try:
                        exp_mgr = ExperimentManagerFactory.from_experiment(
                            DataStore.get_experiment(it.experiment_id))
                        exp_mgr.hard_delete()
                    except:
                        continue

                # Delete all HPC suites (the local suites are only carried by experiments)
                for suite in suites:
                    if suite['type'] == "HPC":
                        logger.info('Delete COMPS suite %s' % suite['id'])
                        COMPS_login(SetupParser.get('server_endpoint'))
                        from simtools.Utilities.COMPSUtilities import delete_suite
                        delete_suite(suite['id'])

        # Then delete the whole directory
        calib_dir = os.path.abspath(self.name)
        if os.path.exists(calib_dir):
            try:
                shutil.rmtree(calib_dir)
            except OSError:
                logger.error("Failed to delete %s" % calib_dir)
                logger.error(
                    "Try deleting the folder manually before retrying the calibration."
                )
Exemplo n.º 4
0
 def done_commissioning(self):
     self.experiment = DataStore.get_experiment(self.experiment.exp_id)
     for sim in self.experiment.simulations:
         if not sim.status or sim.status in [
                 SimulationState.CommissionRequested,
                 SimulationState.Created
         ]:
             return False
     return True
Exemplo n.º 5
0
    def get_experiment_from_iteration(self, iteration=None, force_metadata=False):
        """
        Retrieve experiment for a given iteration
        """
        exp = None

        # Only check iteration for resume cases
        if force_metadata:
            iteration = self.adjust_iteration(iteration)
            it = self.read_iteration_data(iteration)
            exp = DataStore.get_experiment(it.experiment_id)

        return exp
Exemplo n.º 6
0
    def query(self):
        logger.debug("Query the DB Monitor for Experiment %s" % self.exp_id)
        states, msgs = {}, {}
        experiment = DataStore.get_experiment(self.exp_id)

        if not experiment or not experiment.simulations:
            return states, msgs

        for sim in experiment.simulations:
            states[
                sim.
                id] = sim.status if sim.status else SimulationState.CommissionRequested
            msgs[sim.id] = sim.message if sim.message else ""
        logger.debug("States returned")
        logger.debug(Counter(states.values()))
        return states, msgs
Exemplo n.º 7
0
def retrieve_object(obj_id, obj_type, sync_if_missing=True, verbose=False, force_update=False):
    """
        Retrieve an object (Experiment, Simulation) in the local database based on its id.
        Can call a sync if missing if the flag is true
        :param obj_id: Id of the object to retrieve
        :param obj_type: Type of the object to retrieve
        :param sync_if_missing: Should we try to sync if not present?
        :return: The experiment found

        #TODO: SHould also support suites
        """
    typename = obj_type.__name__
    if not obj_id: raise ValueError("Trying to retrieve an object (%s) without providing an ID" % typename)

    # Try a hit in the DB
    if obj_type == Experiment:
        obj = DataStore.get_experiment(obj_id)
    elif obj_type == Simulation:
        obj = DataStore.get_simulation(obj_id)

    if obj:
        # If we have an experiment and we want to force the update -> delete it
        if not force_update:
            return obj
        else:
            if obj_type == Experiment:
                DataStore.delete_experiment(obj_id)
            elif obj_type == Simulation:
                DataStore.delete_simulation(obj_id)

    if not sync_if_missing:
        raise Exception('%s %s not found in the local database and sync disabled.' % (typename, obj_id))

    logger.info('%s with id %s not found in local database, trying sync.' % (typename, obj_id))
    with SetupParser.TemporarySetup(temporary_block='HPC') as sp:
        endpoint = sp.get('server_endpoint')

    if obj_type == Experiment:
        obj = COMPS_experiment_to_local_db(obj_id, endpoint, verbose)
    elif obj_type == Simulation:
        obj =None

    if obj: return obj
    raise Exception("%s '%s' could not be retrieved." % (typename, obj_id))
Exemplo n.º 8
0
    def test_run(self):
        input_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
                                  'input')
        model_file = os.path.join(input_path, 'dummy_model.py')
        local_manager = ExperimentManagerFactory.from_model(
            model_file, 'LOCAL')
        local_manager.run_simulations(
            config_builder=PythonConfigBuilder.from_defaults('sleep'),
            exp_builder=RunNumberSweepBuilder(self.nsims))
        self.assertEqual(local_manager.experiment.exp_name, 'test')
        experiment = local_manager.experiment

        local_manager = ExperimentManagerFactory.from_experiment(
            experiment=DataStore.get_experiment(experiment.exp_id))
        states, msgs = local_manager.get_simulation_status()
        self.assertListEqual(states.values(),
                             [SimulationState.Created] * self.nsims)

        local_manager.hard_delete()
        import time
        time.sleep(3)
Exemplo n.º 9
0
    def load_experiment_from_iteration(self, iteration=None):
        """
        Load experiment for a given or the latest iteration
        """
        if iteration is None:
            # restore the existing calibration data
            calib_data = self.read_calib_data()

            # Get the last iteration
            latest_iteration = calib_data.get('iteration', None)
        else:
            latest_iteration = iteration

        try:
            # Restore IterationState
            it = IterationState.from_file(os.path.join(self.name, 'iter%d' % latest_iteration, 'IterationState.json'))

            # Get experiment by id
            return DataStore.get_experiment(it.experiment_id)
        except:
            return None
Exemplo n.º 10
0
 def refresh_experiment(self):
     self.check_overseer()
     # Refresh the experiment
     self.experiment = DataStore.get_experiment(self.experiment.exp_id)
Exemplo n.º 11
0
def link(args, unknownArgs):
    """
    Open browser to the COMPS Experiment/Simulation with ID or name provided
    :param args:
    :param unknownArgs:
    :return:
    """

    # get input from commands line
    input_id = args.Id

    # default: consider the latest experiment
    if input_id is None:
        latest = DataStore.get_most_recent_experiment()
        input_id = latest.exp_id

    try:
        comps_item = retrieve_item(input_id)
    except:
        print('Nothing was found for {}'.format(input_id))
        exit()

    # check item type
    id_type = ''
    location = 'LOCAL'
    if isinstance(comps_item, Experiment):
        item_id = comps_item.exp_id
        id_type = 'exp'
        location = comps_item.location
    elif isinstance(comps_item, Simulation):
        item_id = comps_item.id
        exp_id = comps_item.experiment_id
        id_type = 'sim'
        # retrieve location
        exp = DataStore.get_experiment(exp_id)
        location = exp.location
    else:
        print('No Experiment or Simulation was found on COMPS for {}'.format(
            input_id))
        exit()

    # make sure it exists on COMPS
    if location == 'LOCAL':
        print('Item is on LOCAL not on COMPS.')
        exit()

    # open browser to COMPS Experiment/Simulation
    import webbrowser
    with SetupParser.TemporarySetup(temporary_block='HPC') as sp:
        endpoint = sp.get('server_endpoint')

    url = ''
    if id_type == 'exp':
        url = '%s/#explore/Experiments?filters=Id=%s&offset=0&selectedId=%s' % (
            endpoint, item_id, item_id)
    elif id_type == 'sim':
        url = '%s/#explore/Simulations?filters=Id=%s&mode=list&orderby=DateCreated+desc&count=50&offset=0&layout=512C56&selectedId=%s' % (
            endpoint, item_id, item_id)

    # Open URL in new browser window
    webbrowser.open_new(url)  # opens in default browser
Exemplo n.º 12
0
def COMPS_experiment_to_local_db(exp_id, endpoint, verbose=False, save_new_experiment=True):
    """
    Return a DB object representing an experiment coming from COMPS.
    This function saves the newly retrieved experiment in the DB by default but this behavior can be changed by switching
    the save_new_experiment parameter allowing to return an experiment object and save later with a batch for example.
    :param exp_id:
    :param endpoint:
    :param verbose:
    :param save_new_experiment:
    :return:
    """
    # Make sure we are logged in
    COMPS_login(endpoint)

    #Ensure exp_id is a string
    exp_id = str(exp_id)

    # IF the experiment already exists and
    experiment = DataStore.get_experiment(exp_id)
    if experiment and experiment.is_done():
        if verbose:
            print("Experiment ('%s') already exists in local db." % exp_id)
        # Do not bother with finished experiments
        return None

    from COMPS.Data import QueryCriteria
    try:
        query_criteria = QueryCriteria().select_children('tags')
        exp_comps = get_experiment_by_id(exp_id, query_criteria) or get_experiments_by_name(exp_id, query_criteria)[-1]
    except:
        if verbose:
            print("The experiment ('%s') doesn't exist in COMPS." % exp_id)
        return None

    # Case: experiment doesn't exist in local db
    if not experiment:
        # Cast the creation_date
        experiment = DataStore.create_experiment(exp_id=str(exp_comps.id),
                                                 suite_id=str(exp_comps.suite_id) if exp_comps.suite_id else None,
                                                 exp_name=exp_comps.name,
                                                 tags=exp_comps.tags,
                                                 date_created=utc_to_local(exp_comps.date_created).replace(tzinfo=None),
                                                 location='HPC',
                                                 selected_block='HPC',
                                                 endpoint=endpoint)

    # Note: experiment may be new or comes from local db
    # Get associated simulations of the experiment
    sims = exp_comps.get_simulations(QueryCriteria().select(['id', 'state', 'date_created']).select_children('tags'))

    # Skip empty experiments or experiments that have the same number of sims
    if len(sims) == 0 or len(sims) == len(experiment.simulations):
        if verbose:
            if len(sims) == 0:
                print("Skip empty experiment ('%s')." % exp_id)
            elif len(sims) == len(experiment.simulations):
                print("Skip experiment ('%s') since local one has the same number of simulations." % exp_id)
        return None

    # Go through the sims and create them
    for sim in sims:
        # Cast the simulation tags

        # Create the simulation
        simulation = DataStore.create_simulation(id=str(sim.id),
                                                 status=sim.state, # this is already a SimulationState object
                                                 tags={tag:cast_number(val) for tag,val in sim.tags.items()},
                                                 date_created=utc_to_local(sim.date_created).replace(tzinfo=None))
        # Add to the experiment
        experiment.simulations.append(simulation)

    # Save it to the DB
    if save_new_experiment: DataStore.save_experiment(experiment, verbose=verbose)

    return experiment