def main():

    for expt_id, value in THRESHOLDS_DICT.iteritems():
        threshold = models.Threshold(experiment_id=expt_id,
                                     determination='chosen40_500',
                                     value=value)
        session.add(threshold)
        commit(session)
Пример #2
0
def main():
    # loop over all experiments
    for expt in session.query(models.Experiment):

        print("In experiment '{}'".format(expt.id))

        dt = 1 / expt.sampling_frequency

        for traj in session.query(
                models.Trajectory).filter_by(experiment=expt):

            positions = traj.positions(session)
            velocities = traj.velocities(session)

            # calculate kinematic quantities
            velocities_a = kinematics.norm(velocities)

            accelerations = kinematics.acceleration(velocities, dt)
            accelerations_a = kinematics.norm(accelerations)

            headings = kinematics.heading(velocities)

            angular_velocities = kinematics.angular_velocity(velocities, dt)
            angular_velocities_a = kinematics.norm(angular_velocities)

            angular_accelerations = kinematics.acceleration(
                angular_velocities, dt)
            angular_accelerations_a = kinematics.norm(angular_accelerations)

            distance_from_wall = kinematics.distance_from_wall(
                positions, WALL_BOUNDS)

            # store kinematic quantities in timepoints
            for ctr, tp in enumerate(traj.timepoints(session)):

                tp.velocity_a = velocities_a[ctr]
                tp.acceleration_x, tp.acceleration_y, tp.acceleration_z = accelerations[
                    ctr]
                tp.acceleration_a = accelerations_a[ctr]

                tp.heading_xy, tp.heading_xz, tp.heading_xyz = headings[ctr]

                tp.angular_velocity_x, tp.angular_velocity_y, tp.angular_velocity_z = angular_velocities[
                    ctr]
                tp.angular_velocity_a = angular_velocities_a[ctr]

                tp.angular_acceleration_x, tp.angular_acceleration_y, tp.angular_acceleration_z = angular_accelerations[
                    ctr]
                tp.angular_acceleration_a = angular_accelerations_a[ctr]

                tp.distance_from_wall = distance_from_wall[ctr]

                session.add(tp)

            commit(session)
Пример #3
0
def main():

    for expt in session.query(models.Experiment):
        print('In experiment "{}"...'.format(expt.id))

        for odor_state in ODOR_STATES:
            print('Odor state = "{}"'.format(odor_state))

            trajs = session.query(models.Trajectory).\
                filter_by(experiment=expt, odor_state=odor_state, clean=True)

            for variable_name in QUANTITIES:
                print('{}...'.format(variable_name))

                traj_data = []

                traj_ctr = 0
                for traj in trajs:

                    traj_data.extend(
                        traj.timepoint_field(session, variable_name))

                    traj_ctr += 1

                lb, ub = None, None

                if variable_name.endswith('_a') or 'heading' in variable_name:
                    lb = 0
                    if 'heading' in variable_name:
                        ub = 180

                cts, bins = make_distribution(np.array(traj_data),
                                              N_BINS,
                                              lb=lb,
                                              ub=ub)

                file_name = '{}_{}_{}.pickle'.format(expt.id, odor_state,
                                                     variable_name)

                tp_dstr = models.TimepointDistribution(
                    figure_root_path_env_var=figure_data_env_var,
                    directory_path=DIRECTORY_PATH,
                    file_name=file_name,
                    variable=variable_name,
                    experiment_id=expt.id,
                    odor_state=odor_state,
                    n_data_points=len(traj_data),
                    n_trajectories=traj_ctr,
                    bin_min=bins[0],
                    bin_max=bins[-1],
                    n_bins=N_BINS)
                tp_dstr.data = {'cts': cts, 'bins': bins}
                session.add(tp_dstr)

                commit(session)
def main():

    for expt in session.query(models.Experiment):
        threshold = session.query(models.Threshold).filter_by(experiment=expt,
                                                              determination=DETERMINATION).first()
        for cg in threshold.crossing_groups:
            print(cg.id)
            for crossing in cg.crossings:

                position_x_entry = crossing.timepoint_field(session, 'position_x', 0, 0, 'entry', 'entry')[0]
                position_y_entry = crossing.timepoint_field(session, 'position_y', 0, 0, 'entry', 'entry')[0]
                position_z_entry = crossing.timepoint_field(session, 'position_z', 0, 0, 'entry', 'entry')[0]

                position_x_peak = crossing.timepoint_field(session, 'position_x', 0, 0, 'peak', 'peak')[0]
                position_y_peak = crossing.timepoint_field(session, 'position_y', 0, 0, 'peak', 'peak')[0]
                position_z_peak = crossing.timepoint_field(session, 'position_z', 0, 0, 'peak', 'peak')[0]

                position_x_exit = crossing.timepoint_field(session, 'position_x', 0, 0, 'exit', 'exit')[0]
                position_y_exit = crossing.timepoint_field(session, 'position_y', 0, 0, 'exit', 'exit')[0]
                position_z_exit = crossing.timepoint_field(session, 'position_z', 0, 0, 'exit', 'exit')[0]

                heading_xy_entry = crossing.timepoint_field(session, 'heading_xy', 0, 0, 'entry', 'entry')[0]
                heading_xz_entry = crossing.timepoint_field(session, 'heading_xz', 0, 0, 'entry', 'entry')[0]
                heading_xyz_entry = crossing.timepoint_field(session, 'heading_xyz', 0, 0, 'entry', 'entry')[0]

                heading_xy_peak = crossing.timepoint_field(session, 'heading_xy', 0, 0, 'peak', 'peak')[0]
                heading_xz_peak = crossing.timepoint_field(session, 'heading_xz', 0, 0, 'peak', 'peak')[0]
                heading_xyz_peak = crossing.timepoint_field(session, 'heading_xyz', 0, 0, 'peak', 'peak')[0]

                heading_xy_exit = crossing.timepoint_field(session, 'heading_xy', 0, 0, 'exit', 'exit')[0]
                heading_xz_exit = crossing.timepoint_field(session, 'heading_xz', 0, 0, 'exit', 'exit')[0]
                heading_xyz_exit = crossing.timepoint_field(session, 'heading_xyz', 0, 0, 'exit', 'exit')[0]

                crossing.feature_set_basic = models.CrossingFeatureSetBasic(position_x_entry=position_x_entry,
                                                                            position_y_entry=position_y_entry,
                                                                            position_z_entry=position_z_entry,
                                                                            position_x_peak=position_x_peak,
                                                                            position_y_peak=position_y_peak,
                                                                            position_z_peak=position_z_peak,
                                                                            position_x_exit=position_x_exit,
                                                                            position_y_exit=position_y_exit,
                                                                            position_z_exit=position_z_exit,
                                                                            heading_xy_entry=heading_xy_entry,
                                                                            heading_xz_entry=heading_xz_entry,
                                                                            heading_xyz_entry=heading_xyz_entry,
                                                                            heading_xy_peak=heading_xy_peak,
                                                                            heading_xz_peak=heading_xz_peak,
                                                                            heading_xyz_peak=heading_xyz_peak,
                                                                            heading_xy_exit=heading_xy_exit,
                                                                            heading_xz_exit=heading_xz_exit,
                                                                            heading_xyz_exit=heading_xyz_exit)

                session.add(crossing)
                commit(session)
def main():

    for expt in session.query(models.Experiment):
        print('In experiment "{}"...'.format(expt.id))

        for odor_state in ODOR_STATES:
            print('Odor state = "{}"'.format(odor_state))

            trajs = session.query(models.Trajectory).\
                filter_by(experiment=expt, odor_state=odor_state, clean=True)

            for variable_name in QUANTITIES:
                print('{}...'.format(variable_name))

                traj_data = []

                traj_ctr = 0
                for traj in trajs:

                    traj_data.extend(traj.timepoint_field(session, variable_name))

                    traj_ctr += 1

                lb, ub = None, None

                if variable_name.endswith('_a') or 'heading' in variable_name:
                    lb = 0
                    if 'heading' in variable_name:
                        ub = 180

                cts, bins = make_distribution(np.array(traj_data), N_BINS, lb=lb, ub=ub)

                file_name = '{}_{}_{}.pickle'.format(expt.id, odor_state, variable_name)

                tp_dstr = models.TimepointDistribution(figure_root_path_env_var=figure_data_env_var,
                                                       directory_path=DIRECTORY_PATH,
                                                       file_name=file_name,
                                                       variable=variable_name,
                                                       experiment_id=expt.id,
                                                       odor_state=odor_state,
                                                       n_data_points=len(traj_data),
                                                       n_trajectories=traj_ctr,
                                                       bin_min=bins[0],
                                                       bin_max=bins[-1],
                                                       n_bins=N_BINS)
                tp_dstr.data = {'cts': cts, 'bins': bins}
                session.add(tp_dstr)

                commit(session)
def main():
    # loop over all experiments
    for expt in session.query(models.Experiment):

        print("In experiment '{}'".format(expt.id))

        dt = 1 / expt.sampling_frequency

        for traj in session.query(models.Trajectory).filter_by(experiment=expt):

            positions = traj.positions(session)
            velocities = traj.velocities(session)

            # calculate kinematic quantities
            velocities_a = kinematics.norm(velocities)

            accelerations = kinematics.acceleration(velocities, dt)
            accelerations_a = kinematics.norm(accelerations)

            headings = kinematics.heading(velocities)

            angular_velocities = kinematics.angular_velocity(velocities, dt)
            angular_velocities_a = kinematics.norm(angular_velocities)

            angular_accelerations = kinematics.acceleration(angular_velocities, dt)
            angular_accelerations_a = kinematics.norm(angular_accelerations)

            distance_from_wall = kinematics.distance_from_wall(positions, WALL_BOUNDS)

            # store kinematic quantities in timepoints
            for ctr, tp in enumerate(traj.timepoints(session)):

                tp.velocity_a = velocities_a[ctr]
                tp.acceleration_x, tp.acceleration_y, tp.acceleration_z = accelerations[ctr]
                tp.acceleration_a = accelerations_a[ctr]

                tp.heading_xy, tp.heading_xz, tp.heading_xyz = headings[ctr]

                tp.angular_velocity_x, tp.angular_velocity_y, tp.angular_velocity_z = angular_velocities[ctr]
                tp.angular_velocity_a = angular_velocities_a[ctr]

                tp.angular_acceleration_x, tp.angular_acceleration_y, tp.angular_acceleration_z = angular_accelerations[ctr]
                tp.angular_acceleration_a = angular_accelerations_a[ctr]

                tp.distance_from_wall = distance_from_wall[ctr]

                session.add(tp)

            commit(session)
def main():

    for expt in session.query(models.Experiment):
        print('In experiment "{}"...'.format(expt.id))

        for odor_state in ODOR_STATES:
            print('Odor state = "{}"'.format(odor_state))

            trajs = session.query(models.Trajectory).\
                filter_by(experiment=expt, odor_state=odor_state, clean=True)

            for variable in QUANTITIES:
                print('{}...'.format(variable))

                tp_data = [
                    traj.timepoint_field(session, variable) for traj in trajs
                ]
                n_data_points = np.sum([len(d) for d in tp_data])
                window_len = N_LAGS / expt.sampling_frequency

                acor, p_value, conf_lb, conf_ub = \
                    time_series.xcov_multi_with_confidence(tp_data, tp_data, 0, N_LAGS, normed=True)

                time_vector = np.arange(len(acor)) / expt.sampling_frequency

                file_name = '{}_{}_{}.pickle'.format(expt.id, odor_state,
                                                     variable)

                tp_acor = models.TimepointAutocorrelation(
                    figure_root_path_env_var=figure_data_env_var,
                    directory_path=DIRECTORY_PATH,
                    file_name=file_name,
                    variable=variable,
                    experiment_id=expt.id,
                    odor_state=odor_state,
                    n_data_points=n_data_points,
                    n_trajectories=len(tp_data),
                    window_len=window_len)
                tp_acor.data = {
                    'time_vector': time_vector,
                    'autocorrelation': acor,
                    'p_value': p_value,
                    'confidence_lower': conf_lb,
                    'confidence_upper': conf_ub
                }
                session.add(tp_acor)

                commit(session)
def main():

    for th_ctr in range(2):
        for expt in session.query(models.Experiment):
            print('Experiment "{}"'.format(expt.id))

            threshold_value = THRESHOLD_VALUES[expt.insect][th_ctr]

            # make threshold
            threshold = models.Threshold(experiment=expt,
                                         determination='arbitrary',
                                         value=threshold_value)
            session.add(threshold)

            # loop over odor states
            for odor_state in ODOR_STATES:
                print('Odor "{}"'.format(odor_state))

                # make crossing group
                cg_id = '{}_{}_th{}'.format(expt.id, odor_state, threshold_value)
                cg = models.CrossingGroup(id=cg_id,
                                          experiment=expt,
                                          odor_state=odor_state,
                                          threshold=threshold)
                session.add(cg)

                # get crossings for each trajectory
                for traj in session.query(models.Trajectory).\
                    filter_by(experiment=expt, odor_state=odor_state, clean=True):

                    segments, peaks = time_series.segment_by_threshold(traj.odors(session),
                                                                       threshold_value,
                                                                       traj.timepoint_ids_extended)

                    # add crossings
                    for s_ctr, (segment, peak) in enumerate(zip(segments, peaks)):
                        crossing = models.Crossing(trajectory=traj,
                                                   crossing_number=s_ctr + 1,
                                                   crossing_group=cg)
                        crossing.start_timepoint_id = segment[0]
                        crossing.entry_timepoint_id = segment[1]
                        crossing.peak_timepoint_id = segment[2]
                        crossing.exit_timepoint_id = segment[3] - 1
                        crossing.end_timepoint_id = segment[4] - 1
                        crossing.max_odor = peak
                        session.add(crossing)

                    commit(session)
Пример #9
0
def main():

    for expt in session.query(models.Experiment):
        if 'mosquito' in expt.id:
            baseline = MOSQUITO_BASELINE_ODOR
        else:
            baseline = 0

        trajs = session.query(models.Trajectory).filter_by(experiment=expt, clean=True)
        for traj in trajs:
            odor = traj.odors(session)
            integrated_odor = (odor - baseline).sum() / 100
            traj.odor_stats = models.TrajectoryOdorStats(integrated_odor=integrated_odor)

            session.add(traj)

        commit(session)
def main():

    for expt in session.query(models.Experiment):
        print('Experiment "{}"'.format(expt.id))

        threshold = session.query(models.Threshold).\
            filter_by(experiment=expt, determination=DETERMINATION).first()

        # loop over odor states

        for odor_state in ODOR_STATES:
            print('Odor "{}"'.format(odor_state))

            # make crossing group
            cg_id = '{}_{}_th{}_{}'.format(expt.id, odor_state,
                                           threshold.value, DETERMINATION)
            cg = models.CrossingGroup(id=cg_id,
                                      experiment=expt,
                                      odor_state=odor_state,
                                      threshold=threshold)
            session.add(cg)

            # get crossings for each trajectory
            for traj in session.query(models.Trajectory).\
                filter_by(experiment=expt, odor_state=odor_state, clean=True):

                segments, peaks = time_series.segment_by_threshold(
                    traj.odors(session), threshold.value,
                    traj.timepoint_ids_extended)

                # add crossings
                for s_ctr, (segment, peak) in enumerate(zip(segments, peaks)):
                    crossing = models.Crossing(trajectory=traj,
                                               crossing_number=s_ctr + 1,
                                               crossing_group=cg)
                    crossing.start_timepoint_id = segment[0]
                    crossing.entry_timepoint_id = segment[1]
                    crossing.peak_timepoint_id = segment[2]
                    crossing.exit_timepoint_id = segment[3] - 1
                    crossing.end_timepoint_id = segment[4] - 1
                    crossing.max_odor = peak
                    session.add(crossing)

                commit(session)
Пример #11
0
def main():

    for expt in session.query(models.Experiment):
        if 'mosquito' in expt.id:
            baseline = MOSQUITO_BASELINE_ODOR
        else:
            baseline = 0

        trajs = session.query(models.Trajectory).filter_by(experiment=expt,
                                                           clean=True)
        for traj in trajs:
            odor = traj.odors(session)
            integrated_odor = (odor - baseline).sum() / 100
            traj.odor_stats = models.TrajectoryOdorStats(
                integrated_odor=integrated_odor)

            session.add(traj)

        commit(session)
def main():

    for expt in session.query(models.Experiment):
        print('In experiment "{}"...'.format(expt.id))

        for odor_state in ODOR_STATES:
            print('Odor state = "{}"'.format(odor_state))

            trajs = session.query(models.Trajectory).\
                filter_by(experiment=expt, odor_state=odor_state, clean=True)

            for variable in QUANTITIES:
                print('{}...'.format(variable))

                tp_data = [traj.timepoint_field(session, variable) for traj in trajs]
                n_data_points = np.sum([len(d) for d in tp_data])
                window_len = N_LAGS / expt.sampling_frequency

                acor, p_value, conf_lb, conf_ub = \
                    time_series.xcov_multi_with_confidence(tp_data, tp_data, 0, N_LAGS, normed=True)

                time_vector = np.arange(len(acor)) / expt.sampling_frequency

                file_name = '{}_{}_{}.pickle'.format(expt.id, odor_state, variable)

                tp_acor = models.TimepointAutocorrelation(figure_root_path_env_var=figure_data_env_var,
                                                          directory_path=DIRECTORY_PATH,
                                                          file_name=file_name,
                                                          variable=variable,
                                                          experiment_id=expt.id,
                                                          odor_state=odor_state,
                                                          n_data_points=n_data_points,
                                                          n_trajectories=len(tp_data),
                                                          window_len=window_len)
                tp_acor.data = {'time_vector': time_vector,
                                'autocorrelation': acor,
                                'p_value': p_value,
                                'confidence_lower': conf_lb,
                                'confidence_upper': conf_ub}
                session.add(tp_acor)

                commit(session)
Пример #13
0
def main():

    for insect in INSECTS:
        cleaning_params_list = session.query(models.TrajectoryCleaningParameter.param,
                                             models.TrajectoryCleaningParameter.value).\
                                             filter_by(insect=insect).all()
        cleaning_params = dict(cleaning_params_list)

        for expt in session.query(models.Experiment).filter_by(insect=insect):
            for traj in expt.trajectories:

                clean_portions = clean_traj(traj, cleaning_params)

                for ctr, clean_portion in enumerate(clean_portions):

                    if clean_portion[
                            0] == traj.start_timepoint_id and clean_portion[
                                1] == traj.end_timepoint_id:
                        traj.clean = True
                        portion_traj = traj

                    else:
                        stp_id, etp_id = clean_portion
                        # make new trajectory
                        id = traj.id + '_c{}'.format(ctr)
                        portion_traj = models.Trajectory(
                            id=id,
                            start_timepoint_id=stp_id,
                            end_timepoint_id=etp_id,
                            experiment=expt,
                            raw=False,
                            clean=True,
                            odor_state=traj.odor_state)
                    session.add(portion_traj)
                    portion_traj.basic_info = make_trajectory_basic_info(
                        portion_traj)
                    session.add(portion_traj)

                commit(session)
def main(n_trials, n_train_max, n_test_max, root_dir_env_var):

    # make basis functions
    basis_ins, basis_outs, max_filter_length = igfh.make_exponential_basis_functions(
        INPUT_TAUS, OUTPUT_TAUS, DOMAIN_FACTOR
    )

    for expt_id in EXPERIMENT_IDS:
        for odor_state in ODOR_STATES:

            trajs = igfh.get_trajs_with_integrated_odor_above_threshold(
                expt_id, odor_state, INTEGRATED_ODOR_THRESHOLD
            )

            train_test_ratio = (n_train_max / (n_train_max + n_test_max))
            test_train_ratio = (n_test_max / (n_train_max + n_test_max))
            n_train = min(n_train_max, np.floor(len(trajs) * train_test_ratio))
            n_test = min(n_test_max, np.floor(len(trajs) * test_train_ratio))

            trajs_trains = []
            trajs_tests = []
            glmss = []
            residualss = []

            for trial_ctr in range(n_trials):
                print('{}: odor {} (trial number: {})'.format(expt_id, odor_state, trial_ctr))

                # get random set of training and test trajectories
                perm = np.random.permutation(len(trajs))
                train_idxs = perm[:n_train]
                test_idxs = perm[-n_test:]

                trajs_train = list(np.array(trajs)[train_idxs])
                trajs_test = list(np.array(trajs)[test_idxs])

                # do some more stuff
                glms = []
                residuals = []
                for input_set, output, basis_in, basis_out in zip(INPUT_SETS, OUTPUTS, basis_ins, basis_outs):

                    # get relevant time-series data from each trajectory set
                    data_train = igfh.time_series_from_trajs(
                        trajs_train,
                        inputs=input_set,
                        output=output
                    )
                    data_test = igfh.time_series_from_trajs(
                        trajs_test,
                        inputs=input_set,
                        output=output
                    )

                    glm = fitting.GLMFitter(link=LINK, family=FAMILY)
                    glm.set_params(DELAY, basis_in=basis_in, basis_out=False)

                    glm.input_set = input_set
                    glm.output = output

                    # fit to training data
                    glm.fit(data=data_train, start=START_TIMEPOINT)

                    # predict test data
                    prediction = glm.predict(data=data_test, start=START_TIMEPOINT)
                    _, ground_truth = glm.make_feature_matrix_and_response_vector(data_test, START_TIMEPOINT)

                    # calculate residual
                    residual = np.sqrt(((prediction - ground_truth)**2).mean())

                    # clear out feature matrix and response from glm for efficient storage
                    glm.feature_matrix = None
                    glm.response_vector = None
                    glm.results.remove_data()
                    # store things
                    glms.append(glm)
                    residuals.append(residual)

                trajs_train_ids = [traj.id for traj in trajs_train]
                trajs_test_ids = [traj.id for traj in trajs_test]
                trajs_trains.append(trajs_train_ids)
                trajs_tests.append(trajs_test_ids)
                glmss.append(glms)
                residualss.append(residuals)

            # save a glm fit set
            glm_fit_set = models.GlmFitSet()

            # add data to it
            glm_fit_set.root_dir_env_var = root_dir_env_var
            glm_fit_set.path_relative = 'glm_fit'
            glm_fit_set.file_name = '{}_{}_odor_{}.pickle'.format(FIT_NAME, expt_id, odor_state)
            glm_fit_set.experiment = session.query(models.Experiment).get(expt_id)
            glm_fit_set.odor_state = odor_state
            glm_fit_set.name = FIT_NAME
            glm_fit_set.link = LINK
            glm_fit_set.family = FAMILY
            glm_fit_set.integrated_odor_threshold = INTEGRATED_ODOR_THRESHOLD
            glm_fit_set.predicted = PREDICTED
            glm_fit_set.delay = DELAY
            glm_fit_set.start_time_point = START_TIMEPOINT
            glm_fit_set.n_glms = len(glms)
            glm_fit_set.n_train = n_train
            glm_fit_set.n_test = n_test
            glm_fit_set.n_trials = n_trials

            # save data file
            glm_fit_set.save_to_file(
                input_sets=INPUT_SETS,
                outputs=OUTPUTS,
                basis_in=basis_ins,
                basis_out=basis_outs,
                trajs_train=trajs_trains,
                trajs_test=trajs_tests,
                glms=glmss,
                residuals=residualss
            )

            # save everything else (+ link to data file) in database
            session.add(glm_fit_set)

            commit(session)
Пример #15
0
def main():

    for expt in session.query(models.Experiment):
        threshold = session.query(models.Threshold).filter_by(
            experiment=expt, determination=DETERMINATION).first()
        for cg in threshold.crossing_groups:
            print(cg.id)
            for crossing in cg.crossings:

                position_x_entry = crossing.timepoint_field(
                    session, 'position_x', 0, 0, 'entry', 'entry')[0]
                position_y_entry = crossing.timepoint_field(
                    session, 'position_y', 0, 0, 'entry', 'entry')[0]
                position_z_entry = crossing.timepoint_field(
                    session, 'position_z', 0, 0, 'entry', 'entry')[0]

                position_x_peak = crossing.timepoint_field(
                    session, 'position_x', 0, 0, 'peak', 'peak')[0]
                position_y_peak = crossing.timepoint_field(
                    session, 'position_y', 0, 0, 'peak', 'peak')[0]
                position_z_peak = crossing.timepoint_field(
                    session, 'position_z', 0, 0, 'peak', 'peak')[0]

                position_x_exit = crossing.timepoint_field(
                    session, 'position_x', 0, 0, 'exit', 'exit')[0]
                position_y_exit = crossing.timepoint_field(
                    session, 'position_y', 0, 0, 'exit', 'exit')[0]
                position_z_exit = crossing.timepoint_field(
                    session, 'position_z', 0, 0, 'exit', 'exit')[0]

                heading_xy_entry = crossing.timepoint_field(
                    session, 'heading_xy', 0, 0, 'entry', 'entry')[0]
                heading_xz_entry = crossing.timepoint_field(
                    session, 'heading_xz', 0, 0, 'entry', 'entry')[0]
                heading_xyz_entry = crossing.timepoint_field(
                    session, 'heading_xyz', 0, 0, 'entry', 'entry')[0]

                heading_xy_peak = crossing.timepoint_field(
                    session, 'heading_xy', 0, 0, 'peak', 'peak')[0]
                heading_xz_peak = crossing.timepoint_field(
                    session, 'heading_xz', 0, 0, 'peak', 'peak')[0]
                heading_xyz_peak = crossing.timepoint_field(
                    session, 'heading_xyz', 0, 0, 'peak', 'peak')[0]

                heading_xy_exit = crossing.timepoint_field(
                    session, 'heading_xy', 0, 0, 'exit', 'exit')[0]
                heading_xz_exit = crossing.timepoint_field(
                    session, 'heading_xz', 0, 0, 'exit', 'exit')[0]
                heading_xyz_exit = crossing.timepoint_field(
                    session, 'heading_xyz', 0, 0, 'exit', 'exit')[0]

                crossing.feature_set_basic = models.CrossingFeatureSetBasic(
                    position_x_entry=position_x_entry,
                    position_y_entry=position_y_entry,
                    position_z_entry=position_z_entry,
                    position_x_peak=position_x_peak,
                    position_y_peak=position_y_peak,
                    position_z_peak=position_z_peak,
                    position_x_exit=position_x_exit,
                    position_y_exit=position_y_exit,
                    position_z_exit=position_z_exit,
                    heading_xy_entry=heading_xy_entry,
                    heading_xz_entry=heading_xz_entry,
                    heading_xyz_entry=heading_xyz_entry,
                    heading_xy_peak=heading_xy_peak,
                    heading_xz_peak=heading_xz_peak,
                    heading_xyz_peak=heading_xyz_peak,
                    heading_xy_exit=heading_xy_exit,
                    heading_xz_exit=heading_xz_exit,
                    heading_xyz_exit=heading_xyz_exit)

                session.add(crossing)
                commit(session)
Пример #16
0
from db_api.connect import session, commit
from db_api import models

FRUIT_FLY_PARAMS = {
                    'speed_threshold': 0.03,  # m/s
                    'dist_from_wall_threshold': 0.01,  # m
                    'min_pause_length': 10,  # hundredths of a second
                    'min_trajectory_length': 50,  # hundredths of a second
                    }

MOSQUITO_PARAMS = {
                   'speed_threshold': 0.03,  # m/s
                   'dist_from_wall_threshold': 0.01,  # m
                   'min_pause_length': 10,  # hundredths of a second
                   'min_trajectory_length': 50,  # hundredths of a second
                   }

for param, value in FRUIT_FLY_PARAMS.items():
    tcp = models.TrajectoryCleaningParameter(insect='fruit_fly',
                                             param=param,
                                             value=value)
    session.add(tcp)

for param, value in MOSQUITO_PARAMS.items():
    tcp = models.TrajectoryCleaningParameter(insect='mosquito',
                                             param=param,
                                             value=value)
    session.add(tcp)

commit(session)
Пример #17
0
def main():

    n_timesteps = TIME_AVG_END - TIME_AVG_START

    for expt in session.query(models.Experiment):
        for cg in session.query(models.CrossingGroup).\
            filter(models.CrossingGroup.experiment == expt).\
            filter(models.CrossingGroup.odor_state == 'on').\
            filter(models.Threshold.determination == 'arbitrary'):
            print('Crossings group: "{}"'.format(cg.id))

            for th_val in DISCRIMINATION_THRESHOLD_VALUES[expt.insect]:

                crossings_below = session.query(models.Crossing).\
                    filter(models.Crossing.crossing_group == cg).\
                    filter(models.Crossing.max_odor < th_val).all()
                crossings_above = session.query(models.Crossing).\
                    filter(models.Crossing.crossing_group == cg).\
                    filter(models.Crossing.max_odor >= th_val).all()

                responses_below = np.nan * np.ones((len(crossings_below), n_timesteps), dtype=float)
                responses_above = np.nan * np.ones((len(crossings_above), n_timesteps), dtype=float)

                # fill in values
                for crossing, response in zip(crossings_below, responses_below):
                    response_var = crossing.timepoint_field(session, RESPONSE_VAR,
                                                            first=TIME_AVG_START,
                                                            last=TIME_AVG_END - 1,
                                                            first_rel_to=TIME_AVG_REL_TO,
                                                            last_rel_to=TIME_AVG_REL_TO)
                    response[:len(response_var)] = response_var

                for crossing, response in zip(crossings_above, responses_above):
                    response_var = crossing.timepoint_field(session, RESPONSE_VAR,
                                                            first=TIME_AVG_START,
                                                            last=TIME_AVG_END - 1,
                                                            first_rel_to=TIME_AVG_REL_TO,
                                                            last_rel_to=TIME_AVG_REL_TO)
                    response[:len(response_var)] = response_var

                diff, lb, ub = get_time_avg_response_diff_and_bounds(responses_below,
                                                                     responses_above)

                if len(crossings_below) == 0 or len(crossings_above) == 0:
                    diff = None
                    lb = None
                    ub = None

                disc_th = models.DiscriminationThreshold(crossing_group=cg,
                                                         odor_threshold=th_val,
                                                         n_crossings_below=len(crossings_below),
                                                         n_crossings_above=len(crossings_above),
                                                         time_avg_start=TIME_AVG_START,
                                                         time_avg_end=TIME_AVG_END,
                                                         time_avg_rel_to=TIME_AVG_REL_TO,
                                                         variable=RESPONSE_VAR,
                                                         time_avg_difference=diff,
                                                         lower_bound=lb,
                                                         upper_bound=ub)

                session.add(disc_th)
                commit(session)