public void saveall()
{
Sweet.lollipop = new Lollipop();
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("asdf");
Sweet.lollipop.qVals.Add(e.quant);
GoTermNumber g = new GoTermNumber(new GoTerm("id", "desc", Aspect.BiologicalProcess), 0, 0, 0, 0);
g.by = -1;
Sweet.lollipop.TusherAnalysis1.GoAnalysis.goTermNumbers.Add(g);
Sweet.lollipop.topdown_proteoforms = new List <TopDownProteoform>()
{
ConstructorsForTesting.TopDownProteoform("td1", 1000, 10)
};
ResultsSummaryGenerator.save_all(TestContext.CurrentContext.TestDirectory, Sweet.time_stamp(), Sweet.lollipop.TusherAnalysis1 as IGoAnalysis, Sweet.lollipop.TusherAnalysis1 as TusherAnalysis);
}
public void unlabeled_proteoform_calculate_properties()
{
Sweet.lollipop.neucode_labeled = false;
List <IAggregatable> components = generate_unlabeled_components(starter_mass);
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("E1", components[0], components, empty_quant_components_list, true);
Assert.AreEqual(2, e.aggregated.Count);
double expected_agg_intensity = components.Count * starter_intensity;
Assert.AreEqual(expected_agg_intensity, e.agg_intensity);
double intensity_normalization_factor = components.Count * starter_intensity / expected_agg_intensity;
double expected_agg_mass = starter_mass * intensity_normalization_factor;
Assert.AreEqual(starter_mass * intensity_normalization_factor, e.agg_mass);
Assert.AreEqual(starter_rt * intensity_normalization_factor, e.agg_rt);
}
public void test_aggregate_copy()
{
double max_monoisotopic_mass = starter_mass + missed_monoisotopics * Lollipop.MONOISOTOPIC_UNIT_MASS;
double min_monoisotopic_mass = starter_mass - missed_monoisotopics * Lollipop.MONOISOTOPIC_UNIT_MASS;
Sweet.lollipop.neucode_labeled = true;
List <IAggregatable> components = generate_neucode_components(starter_mass);
// in bounds lowest monoisotopic error
components[1].charge_states.Clear(); // must clear charge states because you can't set the weighted monoisotopic mass if there are charge states.
components[1].weighted_monoisotopic_mass = min_monoisotopic_mass - min_monoisotopic_mass / 1000000 * Convert.ToDouble(Sweet.lollipop.mass_tolerance);
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("E1", components[0], components, empty_quant_components_list, true);
Assert.AreEqual(2, e.aggregated.Count);
// in bounds highest monoisotopic error
components[1].weighted_monoisotopic_mass = max_monoisotopic_mass + max_monoisotopic_mass / 1000000 * Convert.ToDouble(Sweet.lollipop.mass_tolerance);
e = ConstructorsForTesting.ExperimentalProteoform("E1", components[0], components, empty_quant_components_list, true);
e.manual_validation_id = "something";
e.manual_validation_quant = "something";
e.manual_validation_verification = "something";
ExperimentalProteoform f = new ExperimentalProteoform(e);
Assert.AreEqual(e.root, f.root);
Assert.AreEqual(e.agg_intensity, f.agg_intensity);
Assert.AreEqual(e.agg_mass, f.agg_mass);
Assert.AreEqual(e.modified_mass, f.modified_mass);
Assert.AreEqual(e.agg_rt, f.agg_rt);
Assert.AreEqual(e.lysine_count, f.lysine_count);
Assert.AreEqual("E1", f.quant.accession);
Assert.AreEqual(e.is_target, f.is_target);
Assert.AreEqual(e.family, f.family);
Assert.AreEqual(e.manual_validation_id, f.manual_validation_id);
Assert.AreEqual(e.manual_validation_quant, f.manual_validation_quant);
Assert.AreEqual(e.manual_validation_verification, f.manual_validation_verification);
Assert.AreNotEqual(e.aggregated.GetHashCode(), f.aggregated.GetHashCode());
Assert.AreEqual(e.aggregated.Count, f.aggregated.Count);
Assert.AreNotEqual(e.lt_quant_components.GetHashCode(), f.lt_quant_components.GetHashCode());
Assert.AreEqual(e.lt_quant_components.Count, f.lt_quant_components.Count);
Assert.AreNotEqual(e.lt_verification_components.GetHashCode(), f.lt_verification_components.GetHashCode());
Assert.AreEqual(e.lt_verification_components.Count, f.lt_verification_components.Count);
Assert.AreNotEqual(e.hv_quant_components.GetHashCode(), f.hv_quant_components.GetHashCode());
Assert.AreEqual(e.hv_quant_components.Count, f.hv_quant_components.Count);
Assert.AreNotEqual(e.hv_verification_components.GetHashCode(), f.hv_verification_components.GetHashCode());
Assert.AreEqual(e.hv_verification_components.Count, f.hv_verification_components.Count);
Assert.AreNotEqual(e.biorepIntensityList.GetHashCode(), f.biorepIntensityList.GetHashCode());
Assert.AreEqual(e.biorepIntensityList.Count, f.biorepIntensityList.Count);
}
public void results_dataframe_with_something()
{
Sweet.lollipop = new Lollipop();
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("E1");
e.linked_proteoform_references = new List <Proteoform>(new List <Proteoform> {
ConstructorsForTesting.make_a_theoretical()
});
e.ptm_set = e.linked_proteoform_references.Last().ptm_set;
ProteoformFamily f = new ProteoformFamily(e);
f.construct_family();
Sweet.lollipop.target_proteoform_community.families = new List <ProteoformFamily> {
f
};
string[] lines = ResultsSummaryGenerator.datatable_tostring(ResultsSummaryGenerator.experimental_results_dataframe(Sweet.lollipop.TusherAnalysis1)).Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
Assert.True(lines.Count() == 3);
Assert.True(lines.Any(a => a.Contains("E1")));
TopDownProteoform td = ConstructorsForTesting.TopDownProteoform("TD1", 1000, 10);
td.linked_proteoform_references = new List <Proteoform>(new List <Proteoform> {
ConstructorsForTesting.make_a_theoretical()
});
td.ptm_set = e.linked_proteoform_references.Last().ptm_set;
ProteoformFamily f2 = new ProteoformFamily(td);
f2.construct_family();
Sweet.lollipop.target_proteoform_community.families = new List <ProteoformFamily> {
f2
};
Sweet.lollipop.topdown_proteoforms = new List <TopDownProteoform>()
{
td
};
lines = ResultsSummaryGenerator.datatable_tostring(ResultsSummaryGenerator.experimental_results_dataframe(Sweet.lollipop.TusherAnalysis1)).Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
Assert.True(lines.Count() == 3);
lines = ResultsSummaryGenerator.datatable_tostring(ResultsSummaryGenerator.topdown_results_dataframe()).Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
Assert.True(lines.Count() == 3);
Assert.True(lines.Any(a => a.Contains("TD1")));
Sweet.lollipop.target_proteoform_community.families = new List <ProteoformFamily> {
f, f2
};
lines = ResultsSummaryGenerator.datatable_tostring(ResultsSummaryGenerator.experimental_intensities_dataframe()).Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
Assert.True(lines.Count() == 4);
Assert.True(lines.Any(a => a.Contains("TD1")));
Assert.True(lines.Any(a => a.Contains("E1")));
}
public static ExperimentalProteoform ExperimentalProteoform(string accession, IAggregatable root, List <IAggregatable> candidate_observations, List <Component> quantitative_observations, bool is_target)
{
ExperimentalProteoform e = new ExperimentalProteoform(accession, root, is_target);
e.aggregated.AddRange(candidate_observations.Where(p => e.includes(p, e.root)));
e.calculate_properties();
if (quantitative_observations.Count > 0)
{
e.lt_quant_components.AddRange(quantitative_observations.Where(r => e.includes_neucode_component(r, e, true)));
if (Sweet.lollipop.neucode_labeled)
{
e.hv_quant_components.AddRange(quantitative_observations.Where(r => e.includes_neucode_component(r, e, false)));
}
}
e.root = e.aggregated.OrderByDescending(a => a.intensity_sum).FirstOrDefault();
return(e);
}
public void results_dataframe_with_something()
{
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("E1");
e.linked_proteoform_references = new List <Proteoform>(new List <Proteoform> {
ConstructorsForTesting.make_a_theoretical()
});
e.ptm_set = e.linked_proteoform_references.Last().ptm_set;
ProteoformFamily f = new ProteoformFamily(e);
f.construct_family();
SaveState.lollipop.target_proteoform_community.families = new List <ProteoformFamily> {
f
};
string[] lines = ResultsSummaryGenerator.results_dataframe().Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
Assert.True(lines.Count() == 3);
Assert.True(lines.Any(a => a.Contains("E1")));
}
public void choose_next_agg_component()
{
Component c = new Component();
Component d = new Component();
Component e = new Component();
Component f = new Component();
c.weighted_monoisotopic_mass = 100;
d.weighted_monoisotopic_mass = 119;
e.weighted_monoisotopic_mass = 121;
f.weighted_monoisotopic_mass = 122;
c.intensity_sum = 1;
d.intensity_sum = 2;
e.intensity_sum = 3;
f.intensity_sum = 4;
List <IAggregatable> ordered = new List <IAggregatable> {
c, d, e, f
}.OrderByDescending(cc => cc.intensity_sum).ToList();
Component is_running = new Component();
is_running.weighted_monoisotopic_mass = 100;
is_running.intensity_sum = 100;
//Based on components
List <IAggregatable> active = new List <IAggregatable> {
is_running
};
IAggregatable next = Sweet.lollipop.find_next_root(ordered, active);
Assert.True(Math.Abs(next.weighted_monoisotopic_mass - is_running.weighted_monoisotopic_mass) > 2 * (double)Sweet.lollipop.maximum_missed_monos);
Assert.AreEqual(4, next.intensity_sum);
//Based on experimental proteoforms
ExperimentalProteoform exp = ConstructorsForTesting.ExperimentalProteoform("E");
exp.root = is_running;
List <ExperimentalProteoform> active2 = new List <ExperimentalProteoform> {
exp
};
IAggregatable next2 = Sweet.lollipop.find_next_root(ordered, active2);
Assert.True(Math.Abs(next.weighted_monoisotopic_mass - is_running.weighted_monoisotopic_mass) > 2 * (double)Sweet.lollipop.maximum_missed_monos);
Assert.AreEqual(4, next.intensity_sum);
}
public void TestUnabeledProteoformCommunityRelateLargePeakBase_ET()
{
Sweet.lollipop.neucode_labeled = false;
Sweet.lollipop.et_use_notch = false;
Sweet.lollipop.peak_width_base_et = 1;
// One experimental one theoretical protoeform; mass difference < 500 -- return 1
ExperimentalProteoform pf1 = ConstructorsForTesting.ExperimentalProteoform("A1", 1000.0, -1, true);
TheoreticalProteoform pf2 = ConstructorsForTesting.make_a_theoretical();
pf2.modified_mass = 1010.0;
pf2.lysine_count = 1;
pf2.is_target = true;
pf2.ExpandedProteinList = new List <ProteinWithGoTerms> {
p1
};
ExperimentalProteoform[] paE = new ExperimentalProteoform[1];
TheoreticalProteoform[] paT = new TheoreticalProteoform[1];
paE[0] = pf1;
paT[0] = pf2;
List <ProteoformRelation> prList = new List <ProteoformRelation>();
prepare_for_et(new List <double> {
pf1.modified_mass - pf2.modified_mass - .9
});
prList = community.relate(paE, paT, ProteoformComparison.ExperimentalTheoretical, true,
TestContext.CurrentContext.TestDirectory, true);
Assert.AreEqual(1, prList.Count);
prepare_for_et(new List <double> {
pf1.modified_mass - pf2.modified_mass + .9
});
prList = community.relate(paE, paT, ProteoformComparison.ExperimentalTheoretical, true,
TestContext.CurrentContext.TestDirectory, true);
Assert.AreEqual(1, prList.Count);
prepare_for_et(new List <double> {
pf1.modified_mass - pf2.modified_mass + 1
});
prList = community.relate(paE, paT, ProteoformComparison.ExperimentalTheoretical, true,
TestContext.CurrentContext.TestDirectory, true);
Assert.AreEqual(0, prList.Count);
}
public void aggregate_out_of_monoisotpic_tolerance()
{
double max_monoisotopic_mass = starter_mass + missed_monoisotopics * Lollipop.MONOISOTOPIC_UNIT_MASS;
double min_monoisotopic_mass = starter_mass - missed_monoisotopics * Lollipop.MONOISOTOPIC_UNIT_MASS;
SaveState.lollipop.neucode_labeled = true;
List <Component> components = generate_neucode_components(starter_mass);
// below lowest monoisotopic tolerance
components[1].charge_states.Clear(); // must clear charge states because you can't set the weighted monoisotopic mass if there are charge states.
components[1].weighted_monoisotopic_mass = min_monoisotopic_mass - 100;
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("E1", components[0], components, empty_quant_components_list, true);
Assert.AreEqual(1, e.aggregated_components.Count);
// above highest monoisotopic tolerance
components[1].weighted_monoisotopic_mass = (max_monoisotopic_mass + 100);
e = ConstructorsForTesting.ExperimentalProteoform("E1", components[0], components, empty_quant_components_list, true);
Assert.AreEqual(1, e.aggregated_components.Count);
}
public void aggregate_in_bounds_monoisotopic_tolerance()
{
Sweet.lollipop.set_missed_monoisotopic_range();
double max_monoisotopic_mass = starter_mass + missed_monoisotopics * Lollipop.MONOISOTOPIC_UNIT_MASS;
double min_monoisotopic_mass = starter_mass - missed_monoisotopics * Lollipop.MONOISOTOPIC_UNIT_MASS;
Sweet.lollipop.neucode_labeled = true;
List <IAggregatable> components = generate_neucode_components(starter_mass);
// in bounds lowest monoisotopic error
components[1].charge_states.Clear(); // must clear charge states because you can't set the weighted monoisotopic mass if there are charge states.
components[1].weighted_monoisotopic_mass = min_monoisotopic_mass - min_monoisotopic_mass / 1000000 * Convert.ToDouble(Sweet.lollipop.mass_tolerance);
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("E1", components[0], components, empty_quant_components_list, true);
Assert.AreEqual(2, e.aggregated.Count);
// in bounds highest monoisotopic error
components[1].weighted_monoisotopic_mass = max_monoisotopic_mass + max_monoisotopic_mass / 1000000 * Convert.ToDouble(Sweet.lollipop.mass_tolerance);
e = ConstructorsForTesting.ExperimentalProteoform("E1", components[0], components, empty_quant_components_list, true);
Assert.AreEqual(2, e.aggregated.Count);
}
public void nodes_table_gives_meaningful_experimentals()
{
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("E1");
e.agg_intensity = 999.99;
e.agg_mass = 888.88;
e.agg_rt = 777.77;
ProteoformFamily f = new ProteoformFamily(e);
f.construct_family();
string node_table = CytoscapeScript.get_cytoscape_nodes_tsv(new List <ProteoformFamily> {
f
},
null,
CytoscapeScript.color_scheme_names[0], Lollipop.edge_labels[0], Lollipop.node_labels[0], Lollipop.node_positioning[0], 2,
f.theoretical_proteoforms, false, Lollipop.gene_name_labels[1]);
Assert.True(node_table.Contains("E1"));
Assert.True(node_table.Contains("999.99"));
}
public void wrong_relation_shifting()
{
ProteoformCommunity test_community = new ProteoformCommunity();
SaveState.lollipop.target_proteoform_community = test_community;
ExperimentalProteoform pf3 = ConstructorsForTesting.ExperimentalProteoform("E1");
ExperimentalProteoform pf4 = ConstructorsForTesting.ExperimentalProteoform("E2");
ProteoformComparison wrong_comparison = ProteoformComparison.ExperimentalExperimental;
ProteoformRelation pr2 = new ProteoformRelation(pf3, pf4, wrong_comparison, 0, TestContext.CurrentContext.TestDirectory);
ProteoformRelation pr3 = new ProteoformRelation(pf3, pf4, wrong_comparison, 0, TestContext.CurrentContext.TestDirectory);
List <ProteoformRelation> prs = new List <ProteoformRelation> {
pr2, pr3
};
foreach (ProteoformRelation pr in prs)
{
pr.set_nearby_group(prs, prs.Select(r => r.InstanceId).ToList());
}
test_community.accept_deltaMass_peaks(prs, new List <ProteoformRelation>());
Assert.False(SaveState.lollipop.et_peaks[0].shift_experimental_masses(1, true));
}
public void cytoscape_improper_build_folder()
{
TheoreticalProteoform t = ConstructorsForTesting.make_a_theoretical();
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("E1");
ProteoformRelation et = new ProteoformRelation(e, t, ProteoformComparison.ExperimentalTheoretical, 0, TestContext.CurrentContext.TestDirectory);
e.agg_intensity = 999.99;
e.quant.TusherValues1.numeratorIntensitySum = 444.44m;
e.quant.TusherValues1.denominatorIntensitySum = 333.33m;
e.quant.intensitySum = 777.77m;
List <ProteoformFamily> f = new List <ProteoformFamily> {
new ProteoformFamily(e)
};
f.First().construct_family();
string message = CytoscapeScript.write_cytoscape_script(f, f,
"", "", "test",
null, false, false,
CytoscapeScript.color_scheme_names[0], Lollipop.edge_labels[0], Lollipop.node_labels[0], CytoscapeScript.node_label_positions[0], Lollipop.node_positioning[0], 2,
false, Lollipop.gene_name_labels[1]);
Assert.False(message.StartsWith("Finished"));
}
public void unlabeled_agg()
{
double max_monoisotopic_mass = TestExperimentalProteoform.starter_mass + TestExperimentalProteoform.missed_monoisotopics * Lollipop.MONOISOTOPIC_UNIT_MASS;
double min_monoisotopic_mass = TestExperimentalProteoform.starter_mass - TestExperimentalProteoform.missed_monoisotopics * Lollipop.MONOISOTOPIC_UNIT_MASS;
List <IAggregatable> components = TestExperimentalProteoform.generate_unlabeled_components(TestExperimentalProteoform.starter_mass);
Sweet.lollipop.neucode_labeled = false;
Sweet.lollipop.remaining_to_aggregate = new List <IAggregatable>(components);
Sweet.lollipop.remaining_verification_components = new HashSet <Component>(components.OfType <Component>());
Sweet.lollipop.missed_monoisotopics_range = Enumerable.Range(-3, 3 * 2 + 1).ToList();
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("E");
e.root = components[0];
e.aggregate();
e.verify();
Assert.AreEqual(2, e.aggregated.Count);
Assert.AreEqual(2, e.lt_verification_components.Count);
Assert.AreEqual(0, e.hv_verification_components.Count); // everything goes into light with unlabeled
Assert.AreEqual(0, e.lt_quant_components.Count); // no quantitation for unlabeled, yet
Assert.AreEqual(0, e.hv_quant_components.Count);
}
public void unlabeled_agg()
{
SaveState.lollipop.min_num_bioreps = 0;
double max_monoisotopic_mass = TestExperimentalProteoform.starter_mass + TestExperimentalProteoform.missed_monoisotopics * Lollipop.MONOISOTOPIC_UNIT_MASS;
double min_monoisotopic_mass = TestExperimentalProteoform.starter_mass - TestExperimentalProteoform.missed_monoisotopics * Lollipop.MONOISOTOPIC_UNIT_MASS;
List <Component> components = TestExperimentalProteoform.generate_unlabeled_components(TestExperimentalProteoform.starter_mass);
SaveState.lollipop.neucode_labeled = false;
SaveState.lollipop.remaining_components = new List <Component>(components);
SaveState.lollipop.remaining_verification_components = new List <Component>(components);
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("E");
e.root = components[0];
e.aggregate();
e.verify();
Assert.AreEqual(2, e.aggregated_components.Count);
Assert.AreEqual(2, e.lt_verification_components.Count);
Assert.AreEqual(0, e.hv_verification_components.Count); // everything goes into light with unlabeled
Assert.AreEqual(0, e.lt_quant_components.Count); // no quantitation for unlabeled, yet
Assert.AreEqual(0, e.hv_quant_components.Count);
}
public void assign_quant_components_large_tolerance_split_range()
{
Sweet.lollipop = new Lollipop();
Sweet.lollipop.neucode_labeled = true;
Sweet.lollipop.mass_tolerance = 10; //ppm
Sweet.lollipop.missed_monoisotopics_range = Enumerable.Range(-3, 3 * 2 + 1).ToList();
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("", 20000, 2, true); // tolerance is 0.2 Da
double hv_mass = e.agg_mass + e.lysine_count * Lollipop.NEUCODE_LYSINE_MASS_SHIFT; // 20000.0703
Component bb = new Component();
Component cc = new Component();
Component dd = new Component();
Component ee = new Component();
Component ff = new Component();
Component gg = new Component();
Component hh = new Component();
Component ii = new Component();
bb.weighted_monoisotopic_mass = 19999.79;
cc.weighted_monoisotopic_mass = 19999.99;
dd.weighted_monoisotopic_mass = 20000;
ee.weighted_monoisotopic_mass = 20000.03;
//boundary is 20000.036
ff.weighted_monoisotopic_mass = 20000.04;
gg.weighted_monoisotopic_mass = 20000.07;
hh.weighted_monoisotopic_mass = 20000.08;
ii.weighted_monoisotopic_mass = 20000.28;
Sweet.lollipop.remaining_quantification_components = new HashSet <Component> {
bb, cc, dd, ee, ff, gg, hh, ii
};
e.assign_quantitative_components();
Assert.AreEqual(3, e.lt_quant_components.Count);
Assert.AreEqual(3, e.hv_quant_components.Count);
Assert.False(e.lt_quant_components.Any(c => e.hv_quant_components.Contains(c)));
}
public void TestUnabeledProteoformCommunityRelateWithNotches_ET()
{
Sweet.lollipop.neucode_labeled = false;
Sweet.lollipop.et_use_notch = true;
// One experimental one theoretical protoeform; mass difference < 500 -- return 1
ExperimentalProteoform pf1 = ConstructorsForTesting.ExperimentalProteoform("A1", 1000.0, -1, true);
TheoreticalProteoform pf2 = ConstructorsForTesting.make_a_theoretical();
pf2.modified_mass = 1010.0;
pf2.lysine_count = 1;
pf2.is_target = true;
pf2.ExpandedProteinList = new List <ProteinWithGoTerms> {
p1
};
ExperimentalProteoform[] paE = new ExperimentalProteoform[1];
TheoreticalProteoform[] paT = new TheoreticalProteoform[1];
paE[0] = pf1;
paT[0] = pf2;
List <ProteoformRelation> prList = new List <ProteoformRelation>();
prepare_for_et(new List <double> {
pf1.modified_mass - pf2.modified_mass
});
prList = community.relate(paE, paT, ProteoformComparison.ExperimentalTheoretical, true, TestContext.CurrentContext.TestDirectory, true);
Assert.AreEqual(1, prList.Count);
// One experimental one theoretical protoeform; mass difference > 500 -- return 0
pf1.modified_mass = 1000;
pf2.modified_mass = 2000;
paE[0] = pf1;
paT[0] = pf2;
prepare_for_et(new List <double> {
pf1.modified_mass - pf2.modified_mass
});
prList = community.relate(paE, paT, ProteoformComparison.ExperimentalTheoretical, true, TestContext.CurrentContext.TestDirectory, true);
Assert.AreEqual(0, prList.Count);
//Two experimental one theoretical proteoforms; mass difference < 500 Da -- return 2
ExperimentalProteoform pf3 = ConstructorsForTesting.ExperimentalProteoform("A1", 1000.0, -1, true);
ExperimentalProteoform pf4 = ConstructorsForTesting.ExperimentalProteoform("A2", 1010.0, -1, true);
TheoreticalProteoform pf5 = ConstructorsForTesting.make_a_theoretical();
pf5.modified_mass = 1020.0;
pf5.lysine_count = 1;
pf5.is_target = true;
pf5.ExpandedProteinList = new List <ProteinWithGoTerms> {
p1
};
ExperimentalProteoform[] paE2 = new ExperimentalProteoform[2];
paE2[0] = pf3;
paE2[1] = pf4;
paT[0] = pf5;
prepare_for_et(new List <double> {
pf3.modified_mass - pf5.modified_mass,
pf4.modified_mass - pf5.modified_mass,
});
prList = community.relate(paE2, paT, ProteoformComparison.ExperimentalTheoretical, true, TestContext.CurrentContext.TestDirectory, true);
Assert.AreEqual(2, prList.Count);
//Two experimental one theoretical proteoforms; one mass difference >500 Da -- return 0
pf3.modified_mass = 1000;
pf4.modified_mass = 1010;
pf5.modified_mass = 2000;
paE2[0] = pf3;
paE2[1] = pf4;
paT[0] = pf5;
prepare_for_et(new List <double> {
pf3.modified_mass - pf5.modified_mass,
pf4.modified_mass - pf5.modified_mass,
});
prList = community.relate(paE2, paT, ProteoformComparison.ExperimentalTheoretical, true, TestContext.CurrentContext.TestDirectory, true);
Assert.AreEqual(0, prList.Count);
//Two experimental one theoretical proteoforms; mass difference > 500 Da -- return 0
pf3.modified_mass = 1000;
pf4.modified_mass = 2000;
pf5.modified_mass = 3000;
paE2[0] = pf3;
paE2[1] = pf4;
paT[0] = pf5;
prepare_for_et(new List <double> {
pf3.modified_mass - pf5.modified_mass,
pf4.modified_mass - pf5.modified_mass,
});
prList = community.relate(paE2, paT, ProteoformComparison.ExperimentalTheoretical, true, TestContext.CurrentContext.TestDirectory, true);
Assert.AreEqual(0, prList.Count);
//test methionine retention
pf1.modified_mass = 2131.04;
pf1.lysine_count = 1;
pf2.modified_mass = 2000;
pf2.lysine_count = 1;
pf2.begin = 2;
ModificationMotif motif;
ModificationMotif.TryGetMotif("M", out motif);
Modification m = new Modification("Met retention", _modificationType: "AminoAcid", _target: motif, _locationRestriction: "Anywhere.", _monoisotopicMass: 131.04);
Sweet.lollipop.theoretical_database.all_mods_with_mass.Add(m);
Sweet.lollipop.theoretical_database.all_possible_ptmsets.Add(new PtmSet(new List <Ptm> {
new Ptm(-1, m)
}));
Sweet.lollipop.modification_ranks.Add(131.04, 2);
Sweet.lollipop.theoretical_database.possible_ptmset_dictionary = Sweet.lollipop.theoretical_database.make_ptmset_dictionary();
paE[0] = pf1;
paT[0] = pf2;
prList = community.relate(paE, paT, ProteoformComparison.ExperimentalTheoretical, true, TestContext.CurrentContext.TestDirectory, true);
Assert.AreEqual(1, prList.Count);
}
public void get_interesting_goterm_families()
{
Sweet.lollipop = new Lollipop();
Sweet.lollipop.theoretical_database.aaIsotopeMassList = new AminoAcidMasses(Sweet.lollipop.carbamidomethylation, Sweet.lollipop.neucode_labeled).AA_Masses;
Sweet.lollipop.significance_by_permutation = true;
Sweet.lollipop.significance_by_log2FC = false;
DatabaseReference d1 = new DatabaseReference("GO", "GO:1", new List <Tuple <string, string> > {
new Tuple <string, string>("term", "P:1")
});
DatabaseReference d2 = new DatabaseReference("GO", "GO:2", new List <Tuple <string, string> > {
new Tuple <string, string>("term", "P:2")
});
DatabaseReference d3 = new DatabaseReference("GO", "GO:1", new List <Tuple <string, string> > {
new Tuple <string, string>("term", "P:1")
});
GoTerm g1 = new GoTerm(d1);
GoTerm g2 = new GoTerm(d2);
GoTerm g3 = new GoTerm(d3);
ProteinWithGoTerms p1 = new ProteinWithGoTerms("ASDF", "T1", new List <Tuple <string, string> > {
new Tuple <string, string>("", "")
}, new Dictionary <int, List <Modification> >(), new List <ProteolysisProduct> {
new ProteolysisProduct(0, 0, "")
}, "T2", "T3", true, false, new List <DatabaseReference> {
d1
}, new List <GoTerm> {
g1
});
ProteinWithGoTerms p2 = new ProteinWithGoTerms("ASDF", "T2", new List <Tuple <string, string> > {
new Tuple <string, string>("", "")
}, new Dictionary <int, List <Modification> >(), new List <ProteolysisProduct> {
new ProteolysisProduct(0, 0, "")
}, "T2", "T3", true, false, new List <DatabaseReference> {
d2
}, new List <GoTerm> {
g2
});
ProteinWithGoTerms p3 = new ProteinWithGoTerms("ASDF", "T3", new List <Tuple <string, string> > {
new Tuple <string, string>("", "")
}, new Dictionary <int, List <Modification> >(), new List <ProteolysisProduct> {
new ProteolysisProduct(0, 0, "")
}, "T2", "T3", true, false, new List <DatabaseReference> {
d3
}, new List <GoTerm> {
g3
});
Dictionary <InputFile, Protein[]> dict = new Dictionary <InputFile, Protein[]>
{
{ new InputFile("fake.txt", Purpose.ProteinDatabase), new Protein[] { p1 } },
{ new InputFile("fake.txt", Purpose.ProteinDatabase), new Protein[] { p2 } },
{ new InputFile("fake.txt", Purpose.ProteinDatabase), new Protein[] { p3 } },
};
ExperimentalProteoform e1 = ConstructorsForTesting.ExperimentalProteoform("E");
ExperimentalProteoform e2 = ConstructorsForTesting.ExperimentalProteoform("E");
e1.quant.intensitySum = 1;
e1.quant.TusherValues1.significant = true;
e1.quant.tusherlogFoldChange = 1;
e2.quant.intensitySum = 1;
e2.quant.TusherValues1.significant = true;
e2.quant.tusherlogFoldChange = 1;
TheoreticalProteoform t = ConstructorsForTesting.make_a_theoretical("T1_T1_asdf", p1, dict);
TheoreticalProteoform u = ConstructorsForTesting.make_a_theoretical("T2_T1_asdf_asdf", p2, dict);
TheoreticalProteoform v = ConstructorsForTesting.make_a_theoretical("T3_T1_asdf_Asdf_Asdf", p3, dict);
t.ExpandedProteinList = new List <ProteinWithGoTerms> {
p1
};
u.ExpandedProteinList = new List <ProteinWithGoTerms> {
p2
};
v.ExpandedProteinList = new List <ProteinWithGoTerms> {
p3
};
t.begin = 1;
t.end = 1;
u.begin = 1;
u.end = 1;
v.begin = 1;
v.end = 1;
make_relation(e1, t);
//make_relation(e1, v); // we don't allow this to happen anymore... we only allow one ET conntection per E
make_relation(e2, u);
ProteoformFamily f = new ProteoformFamily(e1); // two theoreticals with the same GoTerms... expecting one GoTerm number but two theoretical proteins (now only one)
ProteoformFamily h = new ProteoformFamily(e2);
f.construct_family();
f.identify_experimentals();
h.construct_family();
h.identify_experimentals();
List <ProteoformFamily> families = new List <ProteoformFamily> {
f, h
};
t.family = f;
v.family = f;
e1.family = f;
u.family = h;
e2.family = h;
List <ExperimentalProteoform> fake_significant = new List <ExperimentalProteoform> {
e1
};
List <ProteinWithGoTerms> significant_proteins = Sweet.lollipop.getInducedOrRepressedProteins(fake_significant, Sweet.lollipop.TusherAnalysis1.GoAnalysis);
List <GoTermNumber> gtn = Sweet.lollipop.TusherAnalysis1.GoAnalysis.getGoTermNumbers(significant_proteins, new List <ProteinWithGoTerms> {
p1, p2, p3
});
Assert.AreEqual(1, significant_proteins.Count);
Assert.AreEqual(1, gtn.Count);
Assert.AreEqual("1", gtn.First().Id);
Assert.AreEqual(0 - (decimal)Math.Log(2d / 3d, 2), gtn.First().log_odds_ratio);
List <ProteoformFamily> fams = Sweet.lollipop.getInterestingFamilies(gtn, families);
Assert.AreEqual(1, fams.Count);
Assert.AreEqual(1, fams[0].theoretical_proteoforms.Count);
}
public void test_accept_from_presets()
{
Sweet.lollipop = new Lollipop();
ProteoformCommunity test_community = new ProteoformCommunity();
Sweet.lollipop.target_proteoform_community = test_community;
Sweet.lollipop.theoretical_database.uniprotModifications = new Dictionary <string, List <Modification> >
{
{ "unmodified", new List <Modification>()
{
ConstructorsForTesting.get_modWithMass("unmodified", 0)
} }
};
//Testing the acceptance of peaks. The FDR is tested above, so I'm not going to work with that here.
//Four proteoforms, three relations (linear), middle one isn't accepted; should give 2 families
Sweet.lollipop.min_peak_count_ee = 2;
ExperimentalProteoform pf3 = ConstructorsForTesting.ExperimentalProteoform("E1");
ExperimentalProteoform pf4 = ConstructorsForTesting.ExperimentalProteoform("E2");
ExperimentalProteoform pf5 = ConstructorsForTesting.ExperimentalProteoform("E3");
ExperimentalProteoform pf6 = ConstructorsForTesting.ExperimentalProteoform("E4");
ProteoformComparison comparison34 = ProteoformComparison.ExperimentalExperimental;
ProteoformComparison comparison45 = ProteoformComparison.ExperimentalExperimental;
ProteoformComparison comparison56 = ProteoformComparison.ExperimentalExperimental;
ProteoformRelation pr2 = new ProteoformRelation(pf3, pf4, comparison34, 0, TestContext.CurrentContext.TestDirectory);
ProteoformRelation pr3 = new ProteoformRelation(pf4, pf5, comparison45, 0, TestContext.CurrentContext.TestDirectory);
ProteoformRelation pr4 = new ProteoformRelation(pf5, pf6, comparison56, 0, TestContext.CurrentContext.TestDirectory);
//Test display strings
Assert.AreEqual("E1", pr2.connected_proteoforms[0].accession);
Assert.AreEqual("E2", pr2.connected_proteoforms[1].accession);
List <ProteoformRelation> prs2 = new List <ProteoformRelation> {
pr2, pr3, pr4
};
foreach (ProteoformRelation pr in prs2)
{
pr.set_nearby_group(prs2, prs2.Select(r => r.InstanceId).ToList());
}
Assert.AreEqual(3, pr2.nearby_relations_count);
Assert.AreEqual(3, pr3.nearby_relations_count);
Assert.AreEqual(3, pr4.nearby_relations_count);
Sweet.lollipop.theoretical_database.all_possible_ptmsets = new List <PtmSet> {
new PtmSet(new List <Ptm> {
new Ptm(-1, ConstructorsForTesting.get_modWithMass("unmodified", 0))
})
};
Sweet.lollipop.theoretical_database.possible_ptmset_dictionary = Sweet.lollipop.theoretical_database.make_ptmset_dictionary();
Sweet.unaccept_peak_action(pr2);
using (StreamWriter file = new StreamWriter(Path.Combine(TestContext.CurrentContext.TestDirectory, "method.xml")))
file.WriteLine(Sweet.save_method());
Sweet.open_method(Path.Combine(TestContext.CurrentContext.TestDirectory, "method.xml"), string.Join(Environment.NewLine, File.ReadAllLines(Path.Combine(TestContext.CurrentContext.TestDirectory, "method.xml"))), true, out string warning);
Sweet.lollipop.ee_peaks = test_community.accept_deltaMass_peaks(prs2, new List <ProteoformRelation>());
Assert.AreEqual(1, Sweet.lollipop.ee_peaks.Count);
DeltaMassPeak peak = Sweet.lollipop.ee_peaks[0];
Assert.IsFalse(peak.Accepted); // <-- even though it's above the threshold
Assert.AreEqual(3, peak.grouped_relations.Count);
Assert.AreEqual(3, pr2.peak.peak_relation_group_count);
Assert.AreEqual(0, pr2.peak.DeltaMass);
Assert.AreEqual("[unmodified]", peak.possiblePeakAssignments_string);
//Test that the relations in the peak are added to each of the proteoforms referenced in the peak
Assert.True(pf3.relationships.Contains(pr2));
Assert.True(pf4.relationships.Contains(pr2) && pf4.relationships.Contains(pr3));
Assert.True(pf5.relationships.Contains(pr3) && pf5.relationships.Contains(pr4));
}
public void test_goterm_analysis_with_custom_list()
{
Sweet.lollipop = new Lollipop();
Sweet.lollipop.theoretical_database.aaIsotopeMassList = new AminoAcidMasses(Sweet.lollipop.carbamidomethylation, Sweet.lollipop.neucode_labeled).AA_Masses;
Sweet.lollipop.significance_by_permutation = true;
Sweet.lollipop.significance_by_log2FC = false;
DatabaseReference d1 = new DatabaseReference("GO", "GO:1", new List <Tuple <string, string> > {
new Tuple <string, string>("term", "P:1")
});
DatabaseReference d2 = new DatabaseReference("GO", "GO:2", new List <Tuple <string, string> > {
new Tuple <string, string>("term", "P:2")
});
DatabaseReference d3 = new DatabaseReference("GO", "GO:1", new List <Tuple <string, string> > {
new Tuple <string, string>("term", "P:1")
});
GoTerm g1 = new GoTerm(d1);
GoTerm g2 = new GoTerm(d2);
GoTerm g3 = new GoTerm(d3);
ProteinWithGoTerms p1 = new ProteinWithGoTerms("ASDF", "T1", new List <Tuple <string, string> > {
new Tuple <string, string>("", "")
}, new Dictionary <int, List <Modification> >(), new List <ProteolysisProduct> {
new ProteolysisProduct(0, 0, "")
}, "T2", "T3", true, false, new List <DatabaseReference> {
d1
}, new List <GoTerm> {
g1
});
ProteinWithGoTerms p2 = new ProteinWithGoTerms("ASDF", "T2", new List <Tuple <string, string> > {
new Tuple <string, string>("", "")
}, new Dictionary <int, List <Modification> >(), new List <ProteolysisProduct> {
new ProteolysisProduct(0, 0, "")
}, "T2", "T3", true, false, new List <DatabaseReference> {
d2
}, new List <GoTerm> {
g2
});
ProteinWithGoTerms p3 = new ProteinWithGoTerms("ASDF", "T3", new List <Tuple <string, string> > {
new Tuple <string, string>("", "")
}, new Dictionary <int, List <Modification> >(), new List <ProteolysisProduct> {
new ProteolysisProduct(0, 0, "")
}, "T2", "T3", true, false, new List <DatabaseReference> {
d3
}, new List <GoTerm> {
g3
});
Dictionary <InputFile, Protein[]> dict = new Dictionary <InputFile, Protein[]> {
{ new InputFile("fake.txt", Purpose.ProteinDatabase), new Protein[] { p1 } },
{ new InputFile("fake.txt", Purpose.ProteinDatabase), new Protein[] { p2 } },
{ new InputFile("fake.txt", Purpose.ProteinDatabase), new Protein[] { p3 } },
};
ExperimentalProteoform e1 = ConstructorsForTesting.ExperimentalProteoform("E");
ExperimentalProteoform e2 = ConstructorsForTesting.ExperimentalProteoform("E");
e1.quant.intensitySum = 1;
e1.quant.TusherValues1.significant = true;
e1.quant.tusherlogFoldChange = 1;
e2.quant.intensitySum = 1;
e2.quant.TusherValues1.significant = true;
e2.quant.tusherlogFoldChange = 1;
TheoreticalProteoform t = ConstructorsForTesting.make_a_theoretical("T1_T1_asdf", p1, dict);
TheoreticalProteoform u = ConstructorsForTesting.make_a_theoretical("T2_T1_asdf_asdf", p2, dict);
TheoreticalProteoform v = ConstructorsForTesting.make_a_theoretical("T3_T1_asdf_Asdf_Asdf", p3, dict);
t.ExpandedProteinList = new List <ProteinWithGoTerms> {
p1
};
u.ExpandedProteinList = new List <ProteinWithGoTerms> {
p2
};
v.ExpandedProteinList = new List <ProteinWithGoTerms> {
p3
};
make_relation(e1, t);
make_relation(e1, v);
make_relation(e2, u);
ProteoformFamily f = new ProteoformFamily(e1); // two theoreticals with the same GoTerms... expecting one GoTerm number but two theoretical proteins
ProteoformFamily h = new ProteoformFamily(e2);
f.construct_family();
f.identify_experimentals();
h.construct_family();
h.identify_experimentals();
List <ProteoformFamily> families = new List <ProteoformFamily> {
f, h
};
t.family = f;
v.family = f;
e1.family = f;
u.family = h;
e2.family = h;
Sweet.lollipop.TusherAnalysis1.inducedOrRepressedProteins = Sweet.lollipop.getInducedOrRepressedProteins(new List <ExperimentalProteoform> {
e1
}, Sweet.lollipop.TusherAnalysis1.GoAnalysis);
Sweet.lollipop.TusherAnalysis1.GoAnalysis.allTheoreticalProteins = true;
Sweet.lollipop.theoretical_database.expanded_proteins = new ProteinWithGoTerms[] { p1, p2, p3 };
Sweet.lollipop.TusherAnalysis1.GoAnalysis.backgroundProteinsList = Path.Combine(TestContext.CurrentContext.TestDirectory, "test_protein_list.txt");
Sweet.lollipop.TusherAnalysis1.GoAnalysis.GO_analysis(Sweet.lollipop.TusherAnalysis1.inducedOrRepressedProteins);
Assert.AreEqual(1, Sweet.lollipop.TusherAnalysis1.inducedOrRepressedProteins.Count); // only taking one ET connection by definition in forming ET relations; only one is used in identify theoreticals
Assert.AreEqual(1, Sweet.lollipop.TusherAnalysis1.GoAnalysis.goTermNumbers.Count);
Assert.AreEqual("1", Sweet.lollipop.TusherAnalysis1.GoAnalysis.goTermNumbers.First().Id);
Assert.AreEqual(0 - (decimal)Math.Log(2d / 3d, 2), Sweet.lollipop.TusherAnalysis1.GoAnalysis.goTermNumbers.First().log_odds_ratio);
List <ProteoformFamily> fams = Sweet.lollipop.getInterestingFamilies(Sweet.lollipop.TusherAnalysis1.GoAnalysis.goTermNumbers, families);
Assert.AreEqual(1, fams.Count);
Assert.AreEqual(2, fams[0].theoretical_proteoforms.Count);
}
public DisplayExperimentalProteoform(ExperimentalProteoform e)
: base(e)
{
this.e = e;
}
private void btn_compare_with_td_Click(object sender, RoutedEventArgs e)
{
MessageBox.Show("Please select a top-down results file.");
System.Windows.Forms.OpenFileDialog openFileDialog = new System.Windows.Forms.OpenFileDialog();
openFileDialog.Title = "Top-Down Results";
openFileDialog.Filter = "Excel Files (*.xlsx) | *.xlsx";
openFileDialog.Multiselect = false;
System.Windows.Forms.DialogResult dr = openFileDialog.ShowDialog();
if (dr == System.Windows.Forms.DialogResult.OK)
{
MessageBox.Show("Save comparison results file.");
System.Windows.Forms.SaveFileDialog saveFileDialog = new System.Windows.Forms.SaveFileDialog();
saveFileDialog.Title = "Top-Down Comparison Results";
saveFileDialog.Filter = "Text Files (*.tsv) | *.tsv";
System.Windows.Forms.DialogResult sdr = saveFileDialog.ShowDialog();
if (sdr == System.Windows.Forms.DialogResult.OK)
{
InputFile file = new InputFile(openFileDialog.FileName, Purpose.TopDown);
TopDownReader reader = new TopDownReader();
List <TopDownHit> hits = reader.ReadTDFile(file);
List <TopDownProteoform> td_proteoforms = Sweet.lollipop.aggregate_td_hits(hits, 0, true, true);
List <ExperimentalProteoform> experimentals = Sweet.lollipop.target_proteoform_community.experimental_proteoforms.Where(p => p.linked_proteoform_references != null && (Sweet.lollipop.count_adducts_as_identifications || !p.adduct) && !p.topdown_id).ToList();
experimentals = Sweet.lollipop.add_topdown_proteoforms(experimentals, td_proteoforms);
using (var writer = new System.IO.StreamWriter(saveFileDialog.FileName))
{
writer.WriteLine("Experimental Accession\tExperimental Mass\tExperimental Retention Time\tTheoretical Accession\tTheoretical Description\tTheoretical Begin\tTheoretical End\tTheoretical PTM Description\tTop-Down Accession\tTop-Down Begin\tTop-Down End\tTop-Down PTM Description\tTop-Down Observed Mass\tTop-Down Retention Time\tTop Top-Down C-Score");
foreach (ExperimentalProteoform ep in experimentals)
{
if (ep.topdown_id)
{
TopDownProteoform tdp = ep as TopDownProteoform;
if (tdp.matching_experimental != null)
{
ExperimentalProteoform exp = tdp.matching_experimental;
string exp_ptm = exp.ptm_set.ptm_combination.Count == 0 ? "Unmodified" : String.Join(", ", exp.ptm_set.ptm_combination.Select(ptm => Sweet.lollipop.theoretical_database.unlocalized_lookup.TryGetValue(ptm.modification, out UnlocalizedModification x) ? x.id : ptm.modification.OriginalId).OrderBy(p => p));
string td_ptm = tdp.topdown_ptm_set.ptm_combination.Count == 0 ? "Unmodified" : String.Join(", ", tdp.topdown_ptm_set.ptm_combination.Select(ptm => Sweet.lollipop.theoretical_database.unlocalized_lookup.TryGetValue(ptm.modification, out UnlocalizedModification x) ? x.id : ptm.modification.OriginalId).OrderBy(p => p));
writer.WriteLine(exp.accession + "\t" + exp.agg_mass + "\t" + exp.agg_rt + "\t" + exp.linked_proteoform_references.First().accession.Split('_')[0] + "\t" + (exp.linked_proteoform_references.First() as TheoreticalProteoform).description + "\t" + exp.begin + "\t" + exp.end + "\t" + exp_ptm
+ "\t" + tdp.accession.Split('_')[0] + "\t" + tdp.topdown_begin + "\t" + tdp.topdown_end + "\t" + td_ptm + "\t" + tdp.modified_mass + "\t" + tdp.agg_rt + "\t" + tdp.topdown_hits.Max(h => h.score));
}
}
else
{
string exp_ptm = ep.ptm_set.ptm_combination.Count == 0 ? "Unmodified" : String.Join(", ", ep.ptm_set.ptm_combination.Select(ptm => Sweet.lollipop.theoretical_database.unlocalized_lookup.TryGetValue(ptm.modification, out UnlocalizedModification x) ? x.id : ptm.modification.OriginalId).OrderBy(p => p));
TheoreticalProteoform t = ep.linked_proteoform_references.First() as TheoreticalProteoform;
writer.WriteLine(ep.accession + "\t" + ep.agg_mass + "\t" + ep.agg_rt + "\t" + t.accession.Split('_')[0] + "\t" + t.description + "\t" + t.begin + "\t" + t.end + "\t" + exp_ptm
+ "\t" + "N\\A" + "\t" + "N\\A" + "\t" + "N\\A" + "\t" + "N\\A" + "\t" + "N\\A" + "\t" + "N\\A" + "\t" + "N\\A");
}
}
}
MessageBox.Show("Successfully saved top-down comparison results.");
}
else
{
return;
}
}
else
{
return;
}
}
public void TestDeltaMassPeakConstructor()
{
Sweet.lollipop = new Lollipop();
ConstructorsForTesting.read_mods();
Sweet.lollipop.et_high_mass_difference = 250;
Sweet.lollipop.et_low_mass_difference = -250;
Sweet.lollipop.peak_width_base_ee = 0.015;
Sweet.lollipop.peak_width_base_et = 0.015;
ExperimentalProteoform pf1 = ConstructorsForTesting.ExperimentalProteoform("acession1");
TheoreticalProteoform pf2 = ConstructorsForTesting.make_a_theoretical();
ProteoformComparison relation_type = ProteoformComparison.ExperimentalTheoretical;
double delta_mass = 1 - 1e-7;
ExperimentalProteoform pf3 = ConstructorsForTesting.ExperimentalProteoform("acession3");
TheoreticalProteoform pf4 = ConstructorsForTesting.make_a_theoretical();
ProteoformComparison relation_type2 = ProteoformComparison.ExperimentalTheoretical;
double delta_mass2 = 1;
ExperimentalProteoform pf5 = ConstructorsForTesting.ExperimentalProteoform("acession5");
TheoreticalProteoform pf6 = ConstructorsForTesting.make_a_theoretical();
ProteoformComparison relation_type3 = ProteoformComparison.ExperimentalTheoretical;
double delta_mass3 = 1 + 1e-7;
ExperimentalProteoform pf55 = ConstructorsForTesting.ExperimentalProteoform("acession5");
TheoreticalProteoform pf65 = ConstructorsForTesting.make_a_theoretical();
ProteoformComparison relation_type35 = ProteoformComparison.ExperimentalTheoretical;
double delta_mass35 = 1 + 2e-7;
List <ProteoformRelation> theList = new List <ProteoformRelation>();
theList.Add(new ProteoformRelation(pf1, pf2, relation_type, delta_mass, TestContext.CurrentContext.TestDirectory));
theList.Add(new ProteoformRelation(pf3, pf4, relation_type2, delta_mass2, TestContext.CurrentContext.TestDirectory));
theList.Add(new ProteoformRelation(pf5, pf6, relation_type3, delta_mass3, TestContext.CurrentContext.TestDirectory));
theList.Add(new ProteoformRelation(pf55, pf65, relation_type35, delta_mass35, TestContext.CurrentContext.TestDirectory));
ProteoformRelation base_relation = new ProteoformRelation(pf3, pf4, relation_type2, delta_mass2, TestContext.CurrentContext.TestDirectory);
//base_relation.nearby_relations = base_relation.set_nearby_group(theList, theList.Select(r => r.InstanceId).ToList());
Console.WriteLine("Creating deltaMassPeak");
DeltaMassPeak deltaMassPeak = new DeltaMassPeak(base_relation, new HashSet <ProteoformRelation>(theList));
Console.WriteLine("Created deltaMassPeak");
Assert.AreEqual(0, deltaMassPeak.peak_group_fdr);
Dictionary <string, List <ProteoformRelation> > decoy_relations = new Dictionary <string, List <ProteoformRelation> >();
decoy_relations["decoyDatabase1"] = new List <ProteoformRelation>();
ExperimentalProteoform pf7 = ConstructorsForTesting.ExperimentalProteoform("experimental1");
TheoreticalProteoform pf8 = ConstructorsForTesting.make_a_theoretical();
ProteoformComparison relation_type4 = ProteoformComparison.ExperimentalDecoy;
double delta_mass4 = 1;
ProteoformRelation decoy_relation = new ProteoformRelation(pf7, pf8, relation_type4, delta_mass4, TestContext.CurrentContext.TestDirectory);
decoy_relations["decoyDatabase1"].Add(decoy_relation);
deltaMassPeak.calculate_fdr(decoy_relations);
Assert.AreEqual(0.25, deltaMassPeak.peak_group_fdr); // 1 decoy database, (1 decoy relation, median=1), 4 target relations
decoy_relations["decoyDatabase2"] = new List <ProteoformRelation>();
decoy_relations["decoyDatabase2"].Add(decoy_relation);
decoy_relations["decoyDatabase2"].Add(decoy_relation);
deltaMassPeak.calculate_fdr(decoy_relations);
Assert.AreEqual(0.375, deltaMassPeak.peak_group_fdr); // 2 decoy databases (1 & 2 decoy relations, median=1.5), 4 target relations
}
public void shift_et_peak_unlabeled()
{
Sweet.lollipop = new Lollipop();
ProteoformCommunity test_community = new ProteoformCommunity();
Sweet.lollipop.target_proteoform_community = test_community;
Sweet.lollipop.neucode_labeled = false;
//Make a few experimental proteoforms
List <IAggregatable> n1 = TestExperimentalProteoform.generate_neucode_components(100);
List <IAggregatable> n2 = TestExperimentalProteoform.generate_neucode_components(200);
List <IAggregatable> n3 = TestExperimentalProteoform.generate_neucode_components(200);
List <IAggregatable> n4 = TestExperimentalProteoform.generate_neucode_components(200);
ExperimentalProteoform pf1 = ConstructorsForTesting.ExperimentalProteoform("E1");
pf1.aggregated = n1.Select(n => (n as NeuCodePair).neuCodeLight).ToList <IAggregatable>();
ExperimentalProteoform pf2 = ConstructorsForTesting.ExperimentalProteoform("E2");
pf2.aggregated = n2.Select(n => (n as NeuCodePair).neuCodeLight).ToList <IAggregatable>();
ExperimentalProteoform pf3 = ConstructorsForTesting.ExperimentalProteoform("E3");
pf3.aggregated = n3.Select(n => (n as NeuCodePair).neuCodeLight).ToList <IAggregatable>();
ExperimentalProteoform pf4 = ConstructorsForTesting.ExperimentalProteoform("E4");
pf4.aggregated = n4.Select(n => (n as NeuCodePair).neuCodeLight).ToList <IAggregatable>();
Sweet.lollipop.target_proteoform_community.experimental_proteoforms = new List <ExperimentalProteoform> {
pf1, pf2, pf3, pf4
}.ToArray();
//Connect them to theoreticals to form two peaks
ProteoformComparison comparison14 = ProteoformComparison.ExperimentalTheoretical;
ProteoformComparison comparison25 = ProteoformComparison.ExperimentalTheoretical;
ProteoformComparison comparison36 = ProteoformComparison.ExperimentalTheoretical;
ProteoformComparison comparison47 = ProteoformComparison.ExperimentalTheoretical;
TheoreticalProteoform pf5 = ConstructorsForTesting.make_a_theoretical();
TheoreticalProteoform pf6 = ConstructorsForTesting.make_a_theoretical();
TheoreticalProteoform pf7 = ConstructorsForTesting.make_a_theoretical();
TheoreticalProteoform pf8 = ConstructorsForTesting.make_a_theoretical();
ProteoformRelation pr1 = new ProteoformRelation(pf1, pf5, comparison14, 0, TestContext.CurrentContext.TestDirectory);
ProteoformRelation pr2 = new ProteoformRelation(pf2, pf6, comparison25, 0, TestContext.CurrentContext.TestDirectory);
ProteoformRelation pr3 = new ProteoformRelation(pf3, pf7, comparison36, 1, TestContext.CurrentContext.TestDirectory);
ProteoformRelation pr4 = new ProteoformRelation(pf4, pf8, comparison47, 1, TestContext.CurrentContext.TestDirectory);
List <ProteoformRelation> prs = new List <ProteoformRelation> {
pr1, pr2, pr3, pr4
};
foreach (ProteoformRelation pr in prs)
{
pr.set_nearby_group(prs, prs.Select(r => r.InstanceId).ToList());
}
test_community.accept_deltaMass_peaks(prs, new List <ProteoformRelation>());
Assert.AreEqual(2, Sweet.lollipop.et_peaks.Count);
//Shift the peaks, which shifts all of the proteoforms
DeltaMassPeak d2 = Sweet.lollipop.et_peaks[1];
d2.shift_experimental_masses(-1, false);
foreach (Component c in pf3.aggregated.Concat(pf4.aggregated).OfType <Component>())
{
Assert.AreEqual(-1.0 * Lollipop.MONOISOTOPIC_UNIT_MASS, c.manual_mass_shift);
Assert.AreEqual(200 - 1.0 * Lollipop.MONOISOTOPIC_UNIT_MASS, c.weighted_monoisotopic_mass);
}
Sweet.lollipop.clear_et();
Assert.AreEqual(0, Sweet.lollipop.et_peaks.Count);
//don't double shift E if it's in two peaks...
pr1 = new ProteoformRelation(pf1, pf5, comparison14, 1, TestContext.CurrentContext.TestDirectory);
pr2 = new ProteoformRelation(pf1, pf6, comparison14, 1, TestContext.CurrentContext.TestDirectory);
prs = new List <ProteoformRelation> {
pr1, pr2
};
foreach (ProteoformRelation pr in prs)
{
pr.set_nearby_group(prs, prs.Select(r => r.InstanceId).ToList());
}
test_community.accept_deltaMass_peaks(prs, new List <ProteoformRelation>());
Assert.AreEqual(1, Sweet.lollipop.et_peaks.Count);
//Shift the peaks, which shifts all of the proteoforms
d2 = Sweet.lollipop.et_peaks[0];
d2.shift_experimental_masses(-1, false);
foreach (Component c in pf3.aggregated.Concat(pf4.aggregated).OfType <Component>())
{
Assert.AreEqual(-1.0 * Lollipop.MONOISOTOPIC_UNIT_MASS, c.manual_mass_shift);
Assert.AreEqual(200 - 1.0 * Lollipop.MONOISOTOPIC_UNIT_MASS, c.weighted_monoisotopic_mass);
}
}
public void TestAcceptDeltaMassPeaks()
{
Sweet.lollipop = new Lollipop();
ProteoformCommunity test_community = new ProteoformCommunity();
Sweet.lollipop.target_proteoform_community = test_community;
Sweet.lollipop.theoretical_database.uniprotModifications = new Dictionary <string, List <Modification> >
{
{ "unmodified", new List <Modification>()
{
ConstructorsForTesting.get_modWithMass("unmodified", 0)
} }
};
//Testing the acceptance of peaks. The FDR is tested above, so I'm not going to work with that here.
//Four proteoforms, three relations (linear), middle one isn't accepted; should give 2 families
Sweet.lollipop.min_peak_count_ee = 2;
ExperimentalProteoform pf3 = ConstructorsForTesting.ExperimentalProteoform("E1");
ExperimentalProteoform pf4 = ConstructorsForTesting.ExperimentalProteoform("E2");
ExperimentalProteoform pf5 = ConstructorsForTesting.ExperimentalProteoform("E3");
ExperimentalProteoform pf6 = ConstructorsForTesting.ExperimentalProteoform("E4");
ProteoformComparison comparison34 = ProteoformComparison.ExperimentalExperimental;
ProteoformComparison comparison45 = ProteoformComparison.ExperimentalExperimental;
ProteoformComparison comparison56 = ProteoformComparison.ExperimentalExperimental;
ProteoformRelation pr2 = new ProteoformRelation(pf3, pf4, comparison34, 0, TestContext.CurrentContext.TestDirectory);
ProteoformRelation pr3 = new ProteoformRelation(pf4, pf5, comparison45, 0, TestContext.CurrentContext.TestDirectory);
ProteoformRelation pr4 = new ProteoformRelation(pf5, pf6, comparison56, 0, TestContext.CurrentContext.TestDirectory);
//Test display strings
Assert.AreEqual("E1", pr2.connected_proteoforms[0].accession);
Assert.AreEqual("E2", pr2.connected_proteoforms[1].accession);
pr2.RelationType = ProteoformComparison.ExperimentalExperimental;
pr2.RelationType = ProteoformComparison.ExperimentalTheoretical;
pr2.RelationType = ProteoformComparison.ExperimentalDecoy;
pr2.RelationType = ProteoformComparison.ExperimentalFalse;
pr2.RelationType = comparison34;
List <ProteoformRelation> prs2 = new List <ProteoformRelation> {
pr2, pr3, pr4
};
foreach (ProteoformRelation pr in prs2)
{
pr.set_nearby_group(prs2, prs2.Select(r => r.InstanceId).ToList());
}
Assert.AreEqual(3, pr2.nearby_relations_count);
Assert.AreEqual(3, pr3.nearby_relations_count);
Assert.AreEqual(3, pr4.nearby_relations_count);
Sweet.lollipop.theoretical_database.all_possible_ptmsets = new List <PtmSet> {
new PtmSet(new List <Ptm> {
new Ptm(-1, ConstructorsForTesting.get_modWithMass("unmodified", 0))
})
};
Sweet.lollipop.theoretical_database.possible_ptmset_dictionary = Sweet.lollipop.theoretical_database.make_ptmset_dictionary();
//auto accept set to false
Sweet.lollipop.ee_accept_peaks_based_on_rank = false;
Sweet.lollipop.ee_peaks = test_community.accept_deltaMass_peaks(prs2, new List <ProteoformRelation>());
Assert.AreEqual(1, Sweet.lollipop.ee_peaks.Count);
DeltaMassPeak peak = Sweet.lollipop.ee_peaks[0];
Assert.IsTrue(peak.Accepted);
Assert.AreEqual(3, peak.grouped_relations.Count);
Assert.AreEqual(3, pr2.peak.peak_relation_group_count);
Assert.AreEqual(0, pr2.peak.DeltaMass);
Assert.AreEqual("[unmodified]", peak.possiblePeakAssignments_string);
//Test that the relations in the peak are added to each of the proteoforms referenced in the peak
Assert.True(pf3.relationships.Contains(pr2));
Assert.True(pf4.relationships.Contains(pr2) && pf4.relationships.Contains(pr3));
Assert.True(pf5.relationships.Contains(pr3) && pf5.relationships.Contains(pr4));
//autoaccept set to true, must be less than first quartile rank...
Sweet.lollipop.clear_ee();
Sweet.lollipop.mod_rank_first_quartile = 0;
Sweet.lollipop.ee_accept_peaks_based_on_rank = true;
Sweet.lollipop.ee_peaks = test_community.accept_deltaMass_peaks(prs2, new List <ProteoformRelation>());
peak = Sweet.lollipop.ee_peaks[0];
Assert.IsFalse(peak.Accepted);
Assert.AreEqual(0, peak.possiblePeakAssignments.Min(p => p.ptm_rank_sum));
Sweet.lollipop.clear_ee();
Sweet.lollipop.mod_rank_first_quartile = 1;
Sweet.lollipop.ee_accept_peaks_based_on_rank = true;
Sweet.lollipop.ee_peaks = test_community.accept_deltaMass_peaks(prs2, new List <ProteoformRelation>());
peak = Sweet.lollipop.ee_peaks[0];
Assert.IsTrue(peak.Accepted);
Assert.AreEqual(0, peak.possiblePeakAssignments.Min(p => p.ptm_rank_sum));
}
public void TestProteoformCommunityRelateWithNotches_ED()
{
Sweet.lollipop = new Lollipop();
Sweet.lollipop.neucode_labeled = true;
Sweet.lollipop.et_use_notch = true;
Sweet.lollipop.decoy_databases = 1;
// In empty comminity, relate ed is empty
Assert.AreEqual(0, Sweet.lollipop.ed_relations.Count);
//create a decoy proteoform community
Sweet.lollipop.decoy_proteoform_communities.Add(Sweet.lollipop.decoy_community_name_prefix + "0", new ProteoformCommunity());
TheoreticalProteoform pf2 = ConstructorsForTesting.make_a_theoretical("decoyProteoform1", 0, -1);
Sweet.lollipop.decoy_proteoform_communities[Sweet.lollipop.decoy_community_name_prefix + "0"].theoretical_proteoforms = new TheoreticalProteoform[1] {
pf2
};
Sweet.lollipop.relate_ed();
// Have a single decoy community --> have single ed_relations
Assert.AreEqual(1, Sweet.lollipop.ed_relations.Count);
// But it's empty
Assert.IsEmpty(Sweet.lollipop.ed_relations[Sweet.lollipop.decoy_community_name_prefix + "0"]);
// In order to make it not empty, we must have relate_et method output a non-empty List
// it must take as arguments non-empty pfs1 and pfs2
// So testProteoformCommunity.experimental_proteoforms must be non-empty
// And decoy_proteoforms["fake_decoy_proteoform1"] must be non-empty
ExperimentalProteoform pf1 = ConstructorsForTesting.ExperimentalProteoform("experimentalProteoform1");
Sweet.lollipop.decoy_proteoform_communities[Sweet.lollipop.decoy_community_name_prefix + "0"].theoretical_proteoforms.First().ExpandedProteinList = new List <ProteinWithGoTerms> {
p1
};
Assert.IsEmpty(Sweet.lollipop.decoy_proteoform_communities[Sweet.lollipop.decoy_community_name_prefix + "0"].experimental_proteoforms);
Sweet.lollipop.decoy_proteoform_communities[Sweet.lollipop.decoy_community_name_prefix + "0"].experimental_proteoforms = new ExperimentalProteoform[] { pf1 };
pf1.modified_mass = 1000;
pf2.modified_mass = 1000;
Sweet.lollipop.clear_et();
prepare_for_et(new List <double> {
pf1.modified_mass - pf2.modified_mass
});
Sweet.lollipop.relate_ed();
// Make sure there is one relation total, because only a single decoy was provided
Assert.AreEqual(1, Sweet.lollipop.ed_relations.Count);
Assert.IsNotEmpty(Sweet.lollipop.ed_relations);
Assert.AreEqual(1, Sweet.lollipop.ed_relations[Sweet.lollipop.decoy_community_name_prefix + "0"].Count); // Make sure there is one relation for the provided fake_decoy_proteoform1
ProteoformRelation rel = Sweet.lollipop.ed_relations[Sweet.lollipop.decoy_community_name_prefix + "0"][0];
Assert.IsFalse(rel.Accepted);
Assert.AreEqual("decoyProteoform1", rel.connected_proteoforms[1].accession);
Assert.AreEqual(0, rel.DeltaMass);
Assert.IsEmpty(((TheoreticalProteoform)rel.connected_proteoforms[1]).fragment);
Assert.AreEqual(1, rel.nearby_relations_count); //shows that calculate_unadjusted_group_count works
//Assert.AreEqual(1, rel.mass_difference_group.Count); //I don't think we need this test anymore w/ way peaks are made -LVS
Assert.AreEqual(-1, rel.lysine_count);
Assert.AreEqual("T2", ((TheoreticalProteoform)rel.connected_proteoforms[1]).name);
Assert.AreEqual(0, ((ExperimentalProteoform)rel.connected_proteoforms[0]).aggregated.Count); //nothing aggregated with the basic constructor
Assert.IsTrue(rel.outside_no_mans_land);
Assert.IsNull(rel.peak);
Assert.True(string.Equals("unmodified", ((TheoreticalProteoform)rel.connected_proteoforms[1]).ptm_set.ptm_description, StringComparison.CurrentCultureIgnoreCase));
Assert.AreEqual(1, rel.nearby_relations_count);
}
public void shift_et_peak_neucode_from_actions()
{
Sweet.lollipop = new Lollipop();
ProteoformCommunity test_community = new ProteoformCommunity();
Sweet.lollipop.target_proteoform_community = test_community;
//Make a few experimental proteoforms
List <IAggregatable> n1 = TestExperimentalProteoform.generate_neucode_components(100);
List <IAggregatable> n2 = TestExperimentalProteoform.generate_neucode_components(100);
List <IAggregatable> n3 = TestExperimentalProteoform.generate_neucode_components(200);
List <IAggregatable> n4 = TestExperimentalProteoform.generate_neucode_components(200);
ExperimentalProteoform pf1 = ConstructorsForTesting.ExperimentalProteoform("E1");
pf1.aggregated = n1;
ExperimentalProteoform pf2 = ConstructorsForTesting.ExperimentalProteoform("E2");
pf2.aggregated = n2;
ExperimentalProteoform pf3 = ConstructorsForTesting.ExperimentalProteoform("E3");
pf3.aggregated = n3;
ExperimentalProteoform pf4 = ConstructorsForTesting.ExperimentalProteoform("E4");
pf4.aggregated = n4;
Sweet.lollipop.target_proteoform_community.experimental_proteoforms = new List <ExperimentalProteoform> {
pf1, pf2, pf3, pf4
}.ToArray();
//Connect them to theoreticals to form two peaks
ProteoformComparison comparison14 = ProteoformComparison.ExperimentalTheoretical;
ProteoformComparison comparison25 = ProteoformComparison.ExperimentalTheoretical;
ProteoformComparison comparison36 = ProteoformComparison.ExperimentalTheoretical;
ProteoformComparison comparison47 = ProteoformComparison.ExperimentalTheoretical;
TheoreticalProteoform pf5 = ConstructorsForTesting.make_a_theoretical();
TheoreticalProteoform pf6 = ConstructorsForTesting.make_a_theoretical();
TheoreticalProteoform pf7 = ConstructorsForTesting.make_a_theoretical();
TheoreticalProteoform pf8 = ConstructorsForTesting.make_a_theoretical();
ProteoformRelation pr1 = new ProteoformRelation(pf1, pf5, comparison14, 0, TestContext.CurrentContext.TestDirectory);
ProteoformRelation pr2 = new ProteoformRelation(pf2, pf6, comparison25, 0, TestContext.CurrentContext.TestDirectory);
ProteoformRelation pr3 = new ProteoformRelation(pf3, pf7, comparison36, 1, TestContext.CurrentContext.TestDirectory);
ProteoformRelation pr4 = new ProteoformRelation(pf4, pf8, comparison47, 1, TestContext.CurrentContext.TestDirectory);
List <ProteoformRelation> prs = new List <ProteoformRelation> {
pr1, pr2, pr3, pr4
};
foreach (ProteoformRelation pr in prs)
{
pr.set_nearby_group(prs, prs.Select(r => r.InstanceId).ToList());
}
test_community.accept_deltaMass_peaks(prs, new List <ProteoformRelation>());
Assert.AreEqual(2, Sweet.lollipop.et_peaks.Count);
//Shift the peaks, which shifts all of the proteoforms
DeltaMassPeak d2 = Sweet.lollipop.et_peaks[1];
d2.mass_shifter = "-1";
Sweet.shift_peak_action(d2);
d2.mass_shifter = null;
using (StreamWriter file = new StreamWriter(Path.Combine(TestContext.CurrentContext.TestDirectory, "method.xml")))
file.WriteLine(Sweet.save_method());
Sweet.open_method(Path.Combine(TestContext.CurrentContext.TestDirectory, "method.xml"), string.Join(Environment.NewLine, File.ReadAllLines(Path.Combine(TestContext.CurrentContext.TestDirectory, "method.xml"))), true, out string warning);
Sweet.mass_shifts_from_presets();
d2.shift_experimental_masses(Convert.ToInt32(d2.mass_shifter), true);
foreach (Component c in
n3.OfType <NeuCodePair>().Select(n => n.neuCodeLight).
Concat(n4.OfType <NeuCodePair>().Select(n => n.neuCodeLight)))
{
Assert.AreEqual(-1.0 * Lollipop.MONOISOTOPIC_UNIT_MASS, c.manual_mass_shift);
Assert.AreEqual(200 - 1.0 * Lollipop.MONOISOTOPIC_UNIT_MASS, c.weighted_monoisotopic_mass);
}
foreach (Component c in
n3.OfType <NeuCodePair>().Select(n => n.neuCodeHeavy).
Concat(n4.OfType <NeuCodePair>().Select(n => n.neuCodeHeavy)))
{
Assert.AreEqual(-1.0 * Lollipop.MONOISOTOPIC_UNIT_MASS, c.manual_mass_shift);
Assert.AreEqual(200 + TestExperimentalProteoform.starter_lysine_count * Lollipop.NEUCODE_LYSINE_MASS_SHIFT - 1.0 * Lollipop.MONOISOTOPIC_UNIT_MASS, c.weighted_monoisotopic_mass);
}
}
public void TestNeuCodeLabeledProteoformCommunityRelate_EE()
{
SaveState.lollipop.neucode_labeled = true;
// Two proteoforms; lysine count equal; mass difference < 250 -- return 1
ExperimentalProteoform pf1 = ConstructorsForTesting.ExperimentalProteoform("A1", 1000.0, 1, true);
ExperimentalProteoform pf2 = ConstructorsForTesting.ExperimentalProteoform("A2", 1010.0, 1, true);
ExperimentalProteoform[] pa1 = new ExperimentalProteoform[2];
pa1[0] = pf1;
pa1[1] = pf2;
List <ProteoformRelation> prList = new List <ProteoformRelation>();
prList = community.relate(pa1, pa1, ProteoformComparison.ExperimentalExperimental, true, TestContext.CurrentContext.TestDirectory, false);
Assert.AreEqual(1, prList.Count);
// Two proteoforms; lysine count equal; mass difference > 250 -- return 0
pf1.modified_mass = 1000;
pf1.lysine_count = 1;
pf2.modified_mass = 2000;
pf2.lysine_count = 1;
pa1[0] = pf1;
pa1[1] = pf2;
prList = community.relate(pa1, pa1, ProteoformComparison.ExperimentalExperimental, true, TestContext.CurrentContext.TestDirectory, false);
Assert.AreEqual(0, prList.Count);
// Two proteoforms; lysine count NOT equal; mass difference < 250 -- return 0
pf1.modified_mass = 1000;
pf1.lysine_count = 1;
pf2.modified_mass = 1100;
pf2.lysine_count = 2;
pa1[0] = pf1;
pa1[1] = pf2;
prList = community.relate(pa1, pa1, ProteoformComparison.ExperimentalExperimental, true, TestContext.CurrentContext.TestDirectory, false);
Assert.AreEqual(0, prList.Count);
//Three proteoforms; lysine count equal; mass difference < 250 Da -- return 3
ExperimentalProteoform pf3 = ConstructorsForTesting.ExperimentalProteoform("A1", 1000.0, 1, true);
ExperimentalProteoform pf4 = ConstructorsForTesting.ExperimentalProteoform("A2", 1010.0, 1, true);
ExperimentalProteoform pf5 = ConstructorsForTesting.ExperimentalProteoform("A3", 1020.0, 1, true);
ExperimentalProteoform[] pa2 = new ExperimentalProteoform[3];
pa2[0] = pf3;
pa2[1] = pf4;
pa2[2] = pf5;
prList = community.relate(pa2, pa2, ProteoformComparison.ExperimentalExperimental, true, TestContext.CurrentContext.TestDirectory, false);
Assert.AreEqual(3, prList.Count);
//Three proteoforms; lysine count equal; one mass difference < 250 Da; one mass difference > 500 -- return 1
pf3.modified_mass = 1000;
pf3.lysine_count = 1;
pf4.modified_mass = 1010;
pf4.lysine_count = 1;
pf5.modified_mass = 2020;
pf5.lysine_count = 1;
pa2[0] = pf3;
pa2[1] = pf4;
pa2[2] = pf5;
prList = community.relate(pa2, pa2, ProteoformComparison.ExperimentalExperimental, true, TestContext.CurrentContext.TestDirectory, false);
Assert.AreEqual(1, prList.Count);
//Three proteoforms; lysine count NOT equal; mass difference < 250 Da -- return 0
pf3.modified_mass = 1000;
pf3.lysine_count = 1;
pf4.modified_mass = 1010;
pf4.lysine_count = 2;
pf5.modified_mass = 1020;
pf5.lysine_count = 3;
pa2[0] = pf3;
pa2[1] = pf4;
pa2[2] = pf5;
prList = community.relate(pa2, pa2, ProteoformComparison.ExperimentalExperimental, true, TestContext.CurrentContext.TestDirectory, false);
Assert.AreEqual(0, prList.Count);
//Three proteoforms; lysine count equal; mass difference > 250 Da -- return 0
pf3.lysine_count = 1;
pf3.modified_mass = 1000;
pf4.lysine_count = 1;
pf4.modified_mass = 1600;
pf5.lysine_count = 1;
pf5.modified_mass = 2500;
pa2[0] = pf3;
pa2[1] = pf4;
pa2[2] = pf5;
prList = community.relate(pa2, pa2, ProteoformComparison.ExperimentalExperimental, true, TestContext.CurrentContext.TestDirectory, false);
Assert.AreEqual(0, prList.Count);
}
public void TestDeltaMassPeakConstructorWithNotches()
{
Sweet.lollipop = new Lollipop();
Sweet.lollipop.et_use_notch = true;
Sweet.lollipop.enter_input_files(new string[] { Path.Combine(TestContext.CurrentContext.TestDirectory, "ptmlist.txt") }, Lollipop.acceptable_extensions[2], Lollipop.file_types[2], Sweet.lollipop.input_files, false);
ConstructorsForTesting.read_mods();
Sweet.lollipop.et_high_mass_difference = 250;
Sweet.lollipop.et_low_mass_difference = -250;
ExperimentalProteoform pf1 = ConstructorsForTesting.ExperimentalProteoform("acession1");
TheoreticalProteoform pf2 = ConstructorsForTesting.make_a_theoretical();
pf1.modified_mass = 1000;
ProteoformComparison relation_type = ProteoformComparison.ExperimentalTheoretical;
double delta_mass = 1 - 1e-7;
ExperimentalProteoform pf3 = ConstructorsForTesting.ExperimentalProteoform("acession3");
TheoreticalProteoform pf4 = ConstructorsForTesting.make_a_theoretical();
pf3.modified_mass = 1000;
ProteoformComparison relation_type2 = ProteoformComparison.ExperimentalTheoretical;
double delta_mass2 = 1;
ExperimentalProteoform pf5 = ConstructorsForTesting.ExperimentalProteoform("acession5");
TheoreticalProteoform pf6 = ConstructorsForTesting.make_a_theoretical();
pf5.modified_mass = 1000;
ProteoformComparison relation_type3 = ProteoformComparison.ExperimentalTheoretical;
double delta_mass3 = 1 + 1e-7;
ExperimentalProteoform pf55 = ConstructorsForTesting.ExperimentalProteoform("acession5");
TheoreticalProteoform pf65 = ConstructorsForTesting.make_a_theoretical();
pf55.modified_mass = 1000;
ProteoformComparison relation_type35 = ProteoformComparison.ExperimentalTheoretical;
double delta_mass35 = 1 + 2e-7;
TestProteoformCommunityRelate.prepare_for_et(new List <double>()
{
1
});
List <ProteoformRelation> theList = new List <ProteoformRelation>();
theList.Add(new ProteoformRelation(pf1, pf2, relation_type, delta_mass, TestContext.CurrentContext.TestDirectory));
theList.Add(new ProteoformRelation(pf3, pf4, relation_type2, delta_mass2, TestContext.CurrentContext.TestDirectory));
theList.Add(new ProteoformRelation(pf5, pf6, relation_type3, delta_mass3, TestContext.CurrentContext.TestDirectory));
theList.Add(new ProteoformRelation(pf55, pf65, relation_type35, delta_mass35, TestContext.CurrentContext.TestDirectory));
ProteoformRelation base_relation = new ProteoformRelation(pf3, pf4, relation_type2, delta_mass2, TestContext.CurrentContext.TestDirectory);
//base_relation.nearby_relations = base_relation.set_nearby_group(theList, theList.Select(r => r.InstanceId).ToList());
Console.WriteLine("Creating deltaMassPeak");
DeltaMassPeak deltaMassPeak = new DeltaMassPeak(base_relation, new HashSet <ProteoformRelation>(theList));
Console.WriteLine("Created deltaMassPeak");
Assert.AreEqual(0, deltaMassPeak.peak_group_fdr);
Assert.AreEqual(4, deltaMassPeak.grouped_relations.Count);
Assert.AreEqual("[fake1]", deltaMassPeak.possiblePeakAssignments_string);
Assert.AreEqual(1.0, deltaMassPeak.DeltaMass);
Dictionary <string, List <ProteoformRelation> > decoy_relations = new Dictionary <string, List <ProteoformRelation> >();
decoy_relations["decoyDatabase1"] = new List <ProteoformRelation>();
ExperimentalProteoform pf7 = ConstructorsForTesting.ExperimentalProteoform("experimental1");
TheoreticalProteoform pf8 = ConstructorsForTesting.make_a_theoretical();
pf7.modified_mass = 1000;
ProteoformComparison relation_type4 = ProteoformComparison.ExperimentalDecoy;
double delta_mass4 = 1;
ProteoformRelation decoy_relation = new ProteoformRelation(pf7, pf8, relation_type4, delta_mass4, TestContext.CurrentContext.TestDirectory);
decoy_relations["decoyDatabase1"].Add(decoy_relation);
deltaMassPeak.calculate_fdr(decoy_relations);
Assert.AreEqual(0.25, deltaMassPeak.peak_group_fdr); // 1 decoy database, (1 decoy relation, median=1), 4 target relations
decoy_relations["decoyDatabase2"] = new List <ProteoformRelation>();
decoy_relations["decoyDatabase2"].Add(decoy_relation);
decoy_relations["decoyDatabase2"].Add(decoy_relation);
deltaMassPeak.calculate_fdr(decoy_relations);
Assert.AreEqual(0.375, deltaMassPeak.peak_group_fdr); // 2 decoy databases (1 & 2 decoy relations, median=1.5), 4 target relations
}
public void TestUnabeledProteoformCommunityRelate_ET()
{
SaveState.lollipop.neucode_labeled = false;
// One experimental one theoretical protoeform; mass difference < 500 -- return 1
ExperimentalProteoform pf1 = ConstructorsForTesting.ExperimentalProteoform("A1", 1000.0, -1, true);
TheoreticalProteoform pf2 = ConstructorsForTesting.make_a_theoretical();
pf2.modified_mass = 1010.0;
pf2.lysine_count = 1;
pf2.is_target = true;
pf2.ExpandedProteinList = new List <ProteinWithGoTerms> {
p1
};
ExperimentalProteoform[] paE = new ExperimentalProteoform[1];
TheoreticalProteoform[] paT = new TheoreticalProteoform[1];
paE[0] = pf1;
paT[0] = pf2;
List <ProteoformRelation> prList = new List <ProteoformRelation>();
prepare_for_et(new List <double> {
pf1.modified_mass - pf2.modified_mass
});
prList = community.relate(paE, paT, ProteoformComparison.ExperimentalTheoretical, true, TestContext.CurrentContext.TestDirectory, true);
Assert.AreEqual(1, prList.Count);
// One experimental one theoretical protoeform; mass difference > 500 -- return 0
pf1.modified_mass = 1000;
pf2.modified_mass = 2000;
paE[0] = pf1;
paT[0] = pf2;
prepare_for_et(new List <double> {
pf1.modified_mass - pf2.modified_mass
});
prList = community.relate(paE, paT, ProteoformComparison.ExperimentalTheoretical, true, TestContext.CurrentContext.TestDirectory, true);
Assert.AreEqual(0, prList.Count);
//Two experimental one theoretical proteoforms; mass difference < 500 Da -- return 2
ExperimentalProteoform pf3 = ConstructorsForTesting.ExperimentalProteoform("A1", 1000.0, -1, true);
ExperimentalProteoform pf4 = ConstructorsForTesting.ExperimentalProteoform("A2", 1010.0, -1, true);
TheoreticalProteoform pf5 = ConstructorsForTesting.make_a_theoretical();
pf5.modified_mass = 1020.0;
pf5.lysine_count = 1;
pf5.is_target = true;
pf5.ExpandedProteinList = new List <ProteinWithGoTerms> {
p1
};
ExperimentalProteoform[] paE2 = new ExperimentalProteoform[2];
paE2[0] = pf3;
paE2[1] = pf4;
paT[0] = pf5;
prepare_for_et(new List <double> {
pf3.modified_mass - pf5.modified_mass,
pf4.modified_mass - pf5.modified_mass,
});
prList = community.relate(paE2, paT, ProteoformComparison.ExperimentalTheoretical, true, TestContext.CurrentContext.TestDirectory, true);
Assert.AreEqual(2, prList.Count);
//Two experimental one theoretical proteoforms; one mass difference >500 Da -- return 0
pf3.modified_mass = 1000;
pf4.modified_mass = 1010;
pf5.modified_mass = 2000;
paE2[0] = pf3;
paE2[1] = pf4;
paT[0] = pf5;
prepare_for_et(new List <double> {
pf3.modified_mass - pf5.modified_mass,
pf4.modified_mass - pf5.modified_mass,
});
prList = community.relate(paE2, paT, ProteoformComparison.ExperimentalTheoretical, true, TestContext.CurrentContext.TestDirectory, true);
Assert.AreEqual(0, prList.Count);
//Two experimental one theoretical proteoforms; mass difference > 500 Da -- return 0
pf3.modified_mass = 1000;
pf4.modified_mass = 2000;
pf5.modified_mass = 3000;
paE2[0] = pf3;
paE2[1] = pf4;
paT[0] = pf5;
prepare_for_et(new List <double> {
pf3.modified_mass - pf5.modified_mass,
pf4.modified_mass - pf5.modified_mass,
});
prList = community.relate(paE2, paT, ProteoformComparison.ExperimentalTheoretical, true, TestContext.CurrentContext.TestDirectory, true);
Assert.AreEqual(0, prList.Count);
}
