Пример #1
0
    def test_load_missing(self):
        """
        """
        path = paths.project('does_not_exist.fake')
        mm_end = mock.MagicMock(name='end')
        system.end = mm_end

        configs.load('trial', path)
        mm_end.assert_called_once_with(1)
Пример #2
0
    def test_load_invalid(self):
        """
        """
        path = paths.project('tests', 'resources', 'invalid.json')
        mm_end = mock.MagicMock(name='end')
        system.end = mm_end

        configs.load('trial', path)
        mm_end.assert_called_once_with(1)
Пример #3
0
def run(
        settings: typing.Union[str, dict],
        **kwargs
) -> dict:
    """
    Executes a grouped collection of simulation trials and returns the compiled
    results for the individual trials, as well as results calculated for the
    group of trials

    :param settings:
        Settings for running the group of trials. Each trial configuration
        will inherit values from these settings.
    :param kwargs:
        Optional setting overrides to be included in the group configuration
    """

    settings = configs.load('group', settings, **kwargs)
    trials = []

    system.log('[{}]: STARTING'.format(settings['id']))

    for source in fetch_trial_list(settings):
        if isinstance(source, str):
            original = source
            source = os.path.abspath(os.path.join(settings['path'], source))
            if not os.path.exists(source):
                source = '{}.json'.format(source)
            if not os.path.exists(source):
                system.log(
                    """
                    [ERROR]: Unable to locate simulation trial file "{}"
                    """.format(original)
                )
                raise FileNotFoundError('No such file {}'.format(source))

        trial_settings = configs.load('trial', source, inherits=settings)
        simulate_trial.run(trial_settings)
        trials.append(dict(
            settings=trial_settings,
            index=len(trials) + 1,
            id=trial_settings['id'],
        ))

    system.log('[{}]: ANALYZING'.format(settings['id']))

    url = analyze.create(settings, trials)

    system.log('[{}]: COMPLETE'.format(settings['id']))

    return url
Пример #4
0
def execute_command():
    """

    :return:
    """

    parser = ArgumentParser()

    parser.description = cli.reformat(DESCRIPTION)

    parser.add_argument(
        'generate_command',
        type=str,
        help='The generate command itself'
    )

    parser.add_argument(
        'trial_or_group',
        type=str,
        help='Path to a trial or group file where the data source is specified'
    )

    parser.add_argument(
        'output_filename',
        type=str,
        help='Name of the csv file to be created'
    )

    args = parser.parse_args()
    cli_configs = system.load_configs()

    path = get_path(args.trial_or_group, cli_configs)
    if path is None:
        system.log('ERROR: Invalid or missing trial/group path')
        sys.exit(1)

    settings = configs.load(None, path)
    out_path = os.path.join(settings['directory'], args.output_filename)

    simulate.load_trackway_positions(
        settings,
        save_as=out_path
    )
Пример #5
0
def run(
        settings: typing.Union[str, dict],
        trackway_positions: trackway.TrackPosition = None,
        **kwargs
) -> dict:
    """
    Runs and analyzes a simulation of the trackway under the conditions
    specified by the arguments and returns a dictionary of results for the
    trial

    :param settings:
        Either a dictionary containing the configuration values for the trial
        or an absolute path to a json format file that contains the
        configuration values for the trial
    :param trackway_positions:
        A TrackwayDefinition instance populated with phase and position values
    """

    settings = configs.load('trial', settings, **kwargs)

    if 'steps_per_cycle' not in settings:
        settings['steps_per_cycle'] = 20
    if 'moving_ambiguity' not in settings:
        # The coefficient of uncertainty while the foot is moving
        settings['moving_ambiguity'] = 0.1
    if 'duty_cycle' not in settings:
        settings['duty_cycle'] = 0.6

    system.log('[{}]: STARTING'.format(settings['id']))

    activity_phases = load_activity_phases(settings)
    trackway_positions = load_trackway_positions(settings, trackway_positions)

    trackway_definition = trackway.TrackwayDefinition(
        trackway_positions,
        activity_phases
    )
    trackway_definition.reorient_positions()

    foot_positions = limb.Property()

    time_steps = list(generate.time_steps_from_data(
        settings['steps_per_cycle'],
        trackway_definition
    ))

    for key in limb.KEYS:
        out = compute.positions_over_time(
            time_steps=time_steps,
            limb_positions=trackway_definition.limb_positions.get(key),
            activity_phase=trackway_definition.activity_phases.get(key),
            settings=settings
        )
        foot_positions.set(key, out)

    prune.invalid_positions(
        settings,
        time_steps,
        foot_positions
    )

    if len(time_steps) < 1:
        system.log(
            """
            [{}]: INVALID RESULTS
                There are no simulated results to analyze. Either the
                simulation is not valid, or you have set a start and end time
                that is not within the range of valid values. Please check your
                settings file.
            """.format(settings['id']))
        raise ValueError('Invalid Results')

    system.log('[{}]: ANALYZING'.format(settings['id']))

    reorientation_needed = prune.unused_foot_prints(
        trackway_definition.limb_positions,
        foot_positions
    )

    if reorientation_needed:
        # Reorient positions again now that the trackway has been pruned
        trackway_definition.reorient_positions(
            *foot_positions.left_pes,
            *foot_positions.right_pes,
            *foot_positions.left_manus,
            *foot_positions.right_manus
        )

    url = analyze.create(
        track_definition=trackway_definition,
        settings=settings,
        time_steps=time_steps,
        foot_positions=foot_positions
    )

    system.log('[{}]: COMPLETED'.format(settings['id']))

    return url