예제 #1
0
def zest_step_5_make_radmat():
    # fmt: off
    dyemat = npf([
        [
            [2, 1],
            [2, 1],
        ],
        [
            [0, 0],
            [0, 0],
        ],
    ])

    sim_params = SimV1Params.from_aa_list_fixture(
        ["DE", "C"],
        error_model=ErrorModel.no_errors(n_channels=2, beta=7500.0,
                                         sigma=0.16),
        n_pres=1,
        n_mocks=0,
        n_edmans=1,
    )

    radmat = sim_v1_worker._step_5_make_radmat(dyemat, sim_params)

    def it_makes_radmat():
        assert np.all(radmat[0] > 4000.0)

    def it_deals_with_zeros():
        assert np.all(radmat[1] == 0.0)

    # fmt: on
    zest()
예제 #2
0
    def it_computes_p_bright_from_product():
        error_model = ErrorModel.no_errors(n_channels=2)
        error_model.labels[0].p_failure_to_bind_amino_acid = 0.9
        error_model.labels[1].p_failure_to_bind_amino_acid = 0.8
        error_model.labels[0].p_failure_to_attach_to_dye = 0.7
        error_model.labels[1].p_failure_to_attach_to_dye = 0.6
        error_model.dyes[0].p_non_fluorescent = 0.5
        error_model.dyes[1].p_non_fluorescent = 0.4

        sim_params = SimV1Params.from_aa_list_fixture(("A", "C"),
                                                      error_model=error_model,
                                                      n_edmans=3)
        flu, p_bright = sim_v1_worker._step_1_create_flu_and_p_bright(
            pep_seq_df, sim_params)
        assert flu.shape == (2, 4)
        expected = np.array([
            [
                ((1 - 0.9) * (1 - 0.7) * (1 - 0.5)),
                0,
                0,
                0,
            ],
            [
                0,
                0,
                ((1 - 0.8) * (1 - 0.6) * (1 - 0.4)),
                0,
            ],
        ])
        assert np.allclose(p_bright, expected)
예제 #3
0
 def it_labels_in_tail():
     sim_params = SimV1Params.from_aa_list_fixture(
         ("A", "C"),
         error_model=ErrorModel.no_errors(n_channels=2),
         n_edmans=6,
     )
     pep_seq_df = pd.DataFrame(
         [
             (1, "B", 0),
             (1, "B", 1),
             (1, "B", 2),
             (1, "B", 3),
             (1, "A", 4),
             (1, "C", 5),
         ],
         columns=PrepResult.pep_seqs_columns,
     )
     flu, p_bright = sim_v1_worker._step_1_create_flu_and_p_bright(
         pep_seq_df, sim_params)
     assert np.all(flu == [
         [0, 0, 0, 0, 1, 0, 0],
         [0, 0, 0, 0, 0, 1, 0],
     ])
     assert np.all(p_bright == [
         [0, 0, 0, 0, 1, 0, 0],
         [0, 0, 0, 0, 0, 1, 0],
     ])
예제 #4
0
 def _before():
     nonlocal sim_params
     sim_params = SimV1Params.from_aa_list_fixture(
         ["DE", "C"],
         error_model=ErrorModel.no_errors(n_channels=2, beta=7500.0),
         n_pres=0,
         n_mocks=1,
         n_edmans=1,
     )
예제 #5
0
    def start(self):
        sim_params = SimV1Params(include_dfs=True, **self.config.parameters)

        prep_result = PrepResult.load_from_folder(self.inputs.prep)

        sim_result = sim_v1(
            sim_params, prep_result, progress=self.progress, pipeline=self
        )
        sim_result._generate_flu_info(prep_result)
        sim_result.save()
예제 #6
0
 def it_extends_short_peptides():
     sim_params = SimV1Params.from_aa_list_fixture(
         ("A", "C"),
         error_model=ErrorModel.no_errors(n_channels=2),
         n_edmans=6,
     )
     flu, p_bright = sim_v1_worker._step_1_create_flu_and_p_bright(
         pep_seq_df, sim_params)
     assert flu.shape == (2, 7)
     assert np.all(flu[:, 3:] == 0.0)
예제 #7
0
def _stub_sim_params(error_model, n_samples):
    return SimV1Params.from_aa_list_fixture(
        ["A", "C"],
        error_model=error_model,
        n_samples_train=n_samples,
        n_samples_test=n_samples,
        n_pres=1,
        n_mocks=0,
        n_edmans=2,
    )
예제 #8
0
def result_from_prep_fixture(prep_result, labels, n_edmans=5, error_model=None):
    labels = labels.split(",")
    n_labels = len(labels)
    if error_model is None:
        error_model = ErrorModel.from_defaults(n_labels)

    sim_v1_params = SimV1Params.from_aa_list_fixture(
        labels, error_model=error_model, n_pres=1, n_mocks=0, n_edmans=n_edmans,
    )

    return sim_v1_worker.sim_v1(sim_v1_params, prep_result)
예제 #9
0
 def it_copies():
     error_model = ErrorModel.from_defaults(n_channels=2)
     src_params = SimV1Params.from_aa_list_fixture(
         ["DE", "Y"], error_model=error_model
     )
     src_params.dfs()
     src_bleach = src_params.error_model.dyes[0].p_bleach
     dst_params = src_params.copy()
     dst_params.error_model.set_dye_param("p_bleach", 1.0)
     _src_bleach = src_params.error_model.dyes[0].p_bleach
     _dst_bleach = dst_params.error_model.dyes[0].p_bleach
     assert _src_bleach == src_bleach
     assert _dst_bleach == 1.0
예제 #10
0
 def _make_sim_params(aa_list,
                      n_edmans,
                      n_train_samples=4,
                      n_test_samples=4):
     params = SimV1Params.from_aa_list_fixture(
         aa_list,
         error_model=ErrorModel.no_errors(n_channels=len(aa_list)),
         n_samples_train=n_train_samples,
         n_samples_test=n_test_samples,
         n_pres=1,
         n_mocks=0,
         n_edmans=n_edmans,
     )
     return params
예제 #11
0
def zest_step_1_create_flu():
    sim_params = SimV1Params.from_aa_list_fixture(
        ("A", "C"),
        error_model=ErrorModel.no_errors(n_channels=2),
    )

    pep_seq_df = pd.DataFrame([
        (1, "A", 0),
        (1, "B", 1),
        (1, "C", 2),
    ],
                              columns=PrepResult.pep_seqs_columns)

    def it_return_flu_and_p_bright():
        flu, p_bright = sim_v1_worker._step_1_create_flu_and_p_bright(
            pep_seq_df, sim_params)
        assert np.all(flu == [
            [
                1,
                0,
                0,
            ],
            [
                0,
                0,
                1,
            ],
        ])
        assert np.all(p_bright == [
            [
                1,
                0,
                0,
            ],
            [
                0,
                0,
                1,
            ],
        ])

    def it_extends_short_peptides():
        sim_params = SimV1Params.from_aa_list_fixture(
            ("A", "C"),
            error_model=ErrorModel.no_errors(n_channels=2),
            n_edmans=6,
        )
        flu, p_bright = sim_v1_worker._step_1_create_flu_and_p_bright(
            pep_seq_df, sim_params)
        assert flu.shape == (2, 7)
        assert np.all(flu[:, 3:] == 0.0)

    def it_computes_p_bright_from_product():
        error_model = ErrorModel.no_errors(n_channels=2)
        error_model.labels[0].p_failure_to_bind_amino_acid = 0.9
        error_model.labels[1].p_failure_to_bind_amino_acid = 0.8
        error_model.labels[0].p_failure_to_attach_to_dye = 0.7
        error_model.labels[1].p_failure_to_attach_to_dye = 0.6
        error_model.dyes[0].p_non_fluorescent = 0.5
        error_model.dyes[1].p_non_fluorescent = 0.4

        sim_params = SimV1Params.from_aa_list_fixture(("A", "C"),
                                                      error_model=error_model,
                                                      n_edmans=3)
        flu, p_bright = sim_v1_worker._step_1_create_flu_and_p_bright(
            pep_seq_df, sim_params)
        assert flu.shape == (2, 4)
        expected = np.array([
            [
                ((1 - 0.9) * (1 - 0.7) * (1 - 0.5)),
                0,
                0,
                0,
            ],
            [
                0,
                0,
                ((1 - 0.8) * (1 - 0.6) * (1 - 0.4)),
                0,
            ],
        ])
        assert np.allclose(p_bright, expected)

    def it_labels_in_tail():
        sim_params = SimV1Params.from_aa_list_fixture(
            ("A", "C"),
            error_model=ErrorModel.no_errors(n_channels=2),
            n_edmans=6,
        )
        pep_seq_df = pd.DataFrame(
            [
                (1, "B", 0),
                (1, "B", 1),
                (1, "B", 2),
                (1, "B", 3),
                (1, "A", 4),
                (1, "C", 5),
            ],
            columns=PrepResult.pep_seqs_columns,
        )
        flu, p_bright = sim_v1_worker._step_1_create_flu_and_p_bright(
            pep_seq_df, sim_params)
        assert np.all(flu == [
            [0, 0, 0, 0, 1, 0, 0],
            [0, 0, 0, 0, 0, 1, 0],
        ])
        assert np.all(p_bright == [
            [0, 0, 0, 0, 1, 0, 0],
            [0, 0, 0, 0, 0, 1, 0],
        ])

    zest()