public void TestProteoformCommunityRelate_ED()
{
SaveState.lollipop = new Lollipop();
SaveState.lollipop.decoy_databases = 1;
// In empty comminity, relate ed is empty
Assert.AreEqual(0, SaveState.lollipop.ed_relations.Count);
//create a decoy proteoform community
SaveState.lollipop.decoy_proteoform_communities.Add(SaveState.lollipop.decoy_community_name_prefix + "0", new ProteoformCommunity());
TheoreticalProteoform pf2 = ConstructorsForTesting.make_a_theoretical("decoyProteoform1", 0, -1);
SaveState.lollipop.decoy_proteoform_communities[SaveState.lollipop.decoy_community_name_prefix + "0"].theoretical_proteoforms = new TheoreticalProteoform[1] {
pf2
};
SaveState.lollipop.relate_ed();
// Have a single decoy community --> have single ed_relations
Assert.AreEqual(1, SaveState.lollipop.ed_relations.Count);
// But it's empty
Assert.IsEmpty(SaveState.lollipop.ed_relations[SaveState.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");
SaveState.lollipop.decoy_proteoform_communities[SaveState.lollipop.decoy_community_name_prefix + "0"].theoretical_proteoforms.First().ExpandedProteinList = new List <ProteinWithGoTerms> {
p1
};
Assert.IsEmpty(SaveState.lollipop.decoy_proteoform_communities[SaveState.lollipop.decoy_community_name_prefix + "0"].experimental_proteoforms);
SaveState.lollipop.decoy_proteoform_communities[SaveState.lollipop.decoy_community_name_prefix + "0"].experimental_proteoforms = new ExperimentalProteoform[] { pf1 };
SaveState.lollipop.clear_et();
prepare_for_et(new List <double> {
pf1.modified_mass - pf2.modified_mass
});
SaveState.lollipop.relate_ed();
// Make sure there is one relation total, because only a single decoy was provided
Assert.AreEqual(1, SaveState.lollipop.ed_relations.Count);
Assert.IsNotEmpty(SaveState.lollipop.ed_relations);
Assert.AreEqual(1, SaveState.lollipop.ed_relations[SaveState.lollipop.decoy_community_name_prefix + "0"].Count); // Make sure there is one relation for the provided fake_decoy_proteoform1
ProteoformRelation rel = SaveState.lollipop.ed_relations[SaveState.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_components.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_description, StringComparison.CurrentCultureIgnoreCase));
Assert.AreEqual(1, rel.nearby_relations_count);
}
public void TestUnabeledProteoformCommunityRelate_EF()
{
ProteoformCommunity test_community;
List <ProteoformRelation> unequal_relations;
//Two equal, two unequal lysine count. Each should create two unequal relations, so eight relations total
//However, it shouldn't compare to itself, so that would make 4 total relations
test_community = new ProteoformCommunity();
SaveState.lollipop.neucode_labeled = true;
test_community.experimental_proteoforms = new ExperimentalProteoform[] {
ConstructorsForTesting.ExperimentalProteoform("A1", 1000.0, 1, true),
ConstructorsForTesting.ExperimentalProteoform("A2", 1000.0, 5, true),
ConstructorsForTesting.ExperimentalProteoform("A3", 1000.0, 1, true),
ConstructorsForTesting.ExperimentalProteoform("A4", 1000.0, 2, true)
};
SaveState.lollipop.ee_relations = test_community.relate(test_community.experimental_proteoforms, test_community.experimental_proteoforms, ProteoformComparison.ExperimentalExperimental, true, TestContext.CurrentContext.TestDirectory, false);
unequal_relations = test_community.relate_ef(test_community.experimental_proteoforms, test_community.experimental_proteoforms);
Assert.AreNotEqual(test_community.experimental_proteoforms[0], test_community.experimental_proteoforms[2]);
Assert.False(test_community.allowed_relation(test_community.experimental_proteoforms[0], test_community.experimental_proteoforms[0], ProteoformComparison.ExperimentalExperimental));
Assert.AreNotEqual(test_community.experimental_proteoforms[0].lysine_count, test_community.experimental_proteoforms[1].lysine_count);
Assert.False(test_community.allowed_relation(test_community.experimental_proteoforms[0], test_community.experimental_proteoforms[1], ProteoformComparison.ExperimentalExperimental));
Assert.True(test_community.allowed_relation(test_community.experimental_proteoforms[0], test_community.experimental_proteoforms[2], ProteoformComparison.ExperimentalExperimental));
Assert.False(test_community.allowed_relation(test_community.experimental_proteoforms[0], test_community.experimental_proteoforms[3], ProteoformComparison.ExperimentalExperimental));
Assert.AreEqual(2, unequal_relations.Count); //only 2 relations are > 3 lysines apart
//Two equal, two unequal lysine count. But one each has mass_difference > 250, so no relations
test_community = new ProteoformCommunity();
test_community.experimental_proteoforms = new ExperimentalProteoform[] {
ConstructorsForTesting.ExperimentalProteoform("A1", 1000.0, 1, true),
ConstructorsForTesting.ExperimentalProteoform("A2", 2000, 2, true),
ConstructorsForTesting.ExperimentalProteoform("A3", 3000, 1, true),
ConstructorsForTesting.ExperimentalProteoform("A4", 4000, 2, true)
};
SaveState.lollipop.ee_relations = test_community.relate(test_community.experimental_proteoforms, test_community.experimental_proteoforms, ProteoformComparison.ExperimentalExperimental, true, TestContext.CurrentContext.TestDirectory, false);
unequal_relations = test_community.relate_ef(test_community.experimental_proteoforms, test_community.experimental_proteoforms);
Assert.AreEqual(0, unequal_relations.Count);
//None equal lysine count (apart from itself), four unequal lysine count. Each should create no unequal relations, so no relations total
test_community = new ProteoformCommunity();
test_community.experimental_proteoforms = new ExperimentalProteoform[] {
ConstructorsForTesting.ExperimentalProteoform("A1", 1000.0, 1, true),
ConstructorsForTesting.ExperimentalProteoform("A2", 1000.0, 2, true),
ConstructorsForTesting.ExperimentalProteoform("A3", 1000.0, 3, true),
ConstructorsForTesting.ExperimentalProteoform("A4", 1000.0, 4, true)
};
SaveState.lollipop.ee_relations = test_community.relate(test_community.experimental_proteoforms, test_community.experimental_proteoforms, ProteoformComparison.ExperimentalExperimental, true, TestContext.CurrentContext.TestDirectory, false);
unequal_relations = test_community.relate_ef(test_community.experimental_proteoforms, test_community.experimental_proteoforms);
Assert.AreEqual(0, unequal_relations.Count);
//All equal, no unequal lysine count because there's an empty list of unequal lysine-count proteoforms. Each should create no unequal relations, so no relations total
test_community = new ProteoformCommunity();
test_community.experimental_proteoforms = new ExperimentalProteoform[] {
ConstructorsForTesting.ExperimentalProteoform("A1", 1000.0, 1, true),
ConstructorsForTesting.ExperimentalProteoform("A2", 1000.0, 1, true),
ConstructorsForTesting.ExperimentalProteoform("A3", 1000.0, 1, true),
ConstructorsForTesting.ExperimentalProteoform("A4", 1000.0, 1, true)
};
unequal_relations = test_community.relate_ef(test_community.experimental_proteoforms, test_community.experimental_proteoforms);
Assert.AreEqual(0, unequal_relations.Count);
}
public void results_decoy_dataframe_with_something()
{
Sweet.lollipop = new Lollipop();
Sweet.lollipop.input_files.Add(ConstructorsForTesting.InputFile("fake.txt", Labeling.NeuCode, Purpose.Identification, "n", "s", "1", "1", "1")); //0
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.decoy_proteoform_communities.Add("Decoy1", new ProteoformCommunity());
Sweet.lollipop.decoy_proteoform_communities["Decoy1"].families = new List <ProteoformFamily> {
f
};
var time_stamp = Sweet.time_stamp();
var directory = TestContext.CurrentContext.TestDirectory;
ResultsSummaryGenerator.save_all(TestContext.CurrentContext.TestDirectory, time_stamp, Sweet.lollipop.TusherAnalysis1 as IGoAnalysis, Sweet.lollipop.TusherAnalysis1 as TusherAnalysis);
Assert.IsTrue(File.Exists(Path.Combine(directory, "decoy_experimental_results_" + time_stamp + ".tsv")));
var lines = File.ReadAllLines(Path.Combine(directory, "decoy_experimental_results_" + time_stamp + ".tsv"));
Assert.AreEqual(2, lines.Length);
}
public void test_no_mans_land()
{
var e = ConstructorsForTesting.ExperimentalProteoform("");
var ee = ProteoformComparison.ExperimentalExperimental;
// Small masses, tight tolerance
ProteoformRelation r1 = new ProteoformRelation(e, e, ee, 0.015 + SaveState.lollipop.peak_width_base_ee / 2, TestContext.CurrentContext.TestDirectory);
Assert.IsTrue(r1.outside_no_mans_land);
ProteoformRelation r2 = new ProteoformRelation(e, e, ee, 0.016 + SaveState.lollipop.peak_width_base_ee / 2, TestContext.CurrentContext.TestDirectory);
Assert.IsFalse(r2.outside_no_mans_land);
ProteoformRelation r3 = new ProteoformRelation(e, e, ee, -0.967 + SaveState.lollipop.peak_width_base_ee / 2, TestContext.CurrentContext.TestDirectory);
Assert.IsTrue(r3.outside_no_mans_land);
ProteoformRelation r4 = new ProteoformRelation(e, e, ee, -0.966 + SaveState.lollipop.peak_width_base_ee / 2, TestContext.CurrentContext.TestDirectory);
Assert.IsFalse(r4.outside_no_mans_land);
// Larger masses, larger tolerance
ProteoformRelation r5 = new ProteoformRelation(e, e, ee, 200.22 + SaveState.lollipop.peak_width_base_ee / 2, TestContext.CurrentContext.TestDirectory);
Assert.IsTrue(r5.outside_no_mans_land);
ProteoformRelation r6 = new ProteoformRelation(e, e, ee, 200.23 + SaveState.lollipop.peak_width_base_ee / 2, TestContext.CurrentContext.TestDirectory);
Assert.IsFalse(r6.outside_no_mans_land);
ProteoformRelation r7 = new ProteoformRelation(e, e, ee, 200.92 - SaveState.lollipop.peak_width_base_ee / 2, TestContext.CurrentContext.TestDirectory);
Assert.IsTrue(r7.outside_no_mans_land);
ProteoformRelation r8 = new ProteoformRelation(e, e, ee, 200.91 - SaveState.lollipop.peak_width_base_ee / 2, TestContext.CurrentContext.TestDirectory);
Assert.IsFalse(r8.outside_no_mans_land);
}
public void test_bottom_up_PSMs()
{
Sweet.lollipop = new Lollipop();
Sweet.lollipop.et_high_mass_difference = 2;
Sweet.lollipop.et_low_mass_difference = -2;
Sweet.lollipop.neucode_labeled = false;
Sweet.lollipop.carbamidomethylation = false;
Sweet.lollipop.enter_input_files(new string[] { Path.Combine(TestContext.CurrentContext.TestDirectory, "testHits.psmtsv") }, Lollipop.acceptable_extensions[7], Lollipop.file_types[7], Sweet.lollipop.input_files, false);
Sweet.lollipop.enter_input_files(new string[] { Path.Combine(TestContext.CurrentContext.TestDirectory, "uniprot_yeast_test_12entries.xml") }, Lollipop.acceptable_extensions[2], Lollipop.file_types[2], Sweet.lollipop.input_files, false);
Sweet.lollipop.theoretical_database.get_theoretical_proteoforms(TestContext.CurrentContext.TestDirectory);
Assert.AreEqual(10, Sweet.lollipop.theoretical_database.bottom_up_psm_by_accession.Count);
Sweet.lollipop.min_bu_peptides = 0;
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("E1");
e.modified_mass = 1816.0128; //Q3E770 - no bottomup-peptides
var relations = Sweet.lollipop.target_proteoform_community.relate(new ExperimentalProteoform[] { e }, Sweet.lollipop.target_proteoform_community.theoretical_proteoforms, ProteoformComparison.ExperimentalTheoretical, TestContext.CurrentContext.TestDirectory, false);
Assert.AreEqual(1, relations.Count);
Sweet.lollipop.min_bu_peptides = 1;
relations = Sweet.lollipop.target_proteoform_community.relate(new ExperimentalProteoform[] { e }, Sweet.lollipop.target_proteoform_community.theoretical_proteoforms, ProteoformComparison.ExperimentalTheoretical, TestContext.CurrentContext.TestDirectory, false);
Assert.AreEqual(0, relations.Count);
e.modified_mass = 29260.9826; //P0CX35
Sweet.lollipop.min_bu_peptides = 1;
relations = Sweet.lollipop.target_proteoform_community.relate(new ExperimentalProteoform[] { e }, Sweet.lollipop.target_proteoform_community.theoretical_proteoforms, ProteoformComparison.ExperimentalTheoretical, TestContext.CurrentContext.TestDirectory, false);
Assert.AreEqual(0, relations.Count); //modified peptide, no mod theoretical with this accession so returns 0
e.modified_mass = 59841.6191; //P32329
relations = Sweet.lollipop.target_proteoform_community.relate(new ExperimentalProteoform[] { e }, Sweet.lollipop.target_proteoform_community.theoretical_proteoforms, ProteoformComparison.ExperimentalTheoretical, TestContext.CurrentContext.TestDirectory, false);
Assert.AreEqual(1, relations.Count);
Assert.AreEqual(0, Proteoform.get_possible_PSMs("Q3E770", new PtmSet(new List <Ptm>()), 3, 20).Count());
Assert.AreEqual(0, Proteoform.get_possible_PSMs("P0CX35", new PtmSet(new List <Ptm>()), 3, 20).Count());
Assert.AreEqual(1, Proteoform.get_possible_PSMs("P0CX35", Sweet.lollipop.theoretical_database.possible_ptmset_dictionary[80].Where(p => p.ptm_description.Contains("Phospho")).First(), 2, 500).Count());
Assert.AreEqual(0, Proteoform.get_possible_PSMs("P0CX35", Sweet.lollipop.theoretical_database.possible_ptmset_dictionary[80].Where(p => p.ptm_description.Contains("Phospho")).First(), 1, 5).Count());
}
public void choose_next_exp_proteoform()
{
ExperimentalProteoform c = ConstructorsForTesting.ExperimentalProteoform("E");
ExperimentalProteoform d = ConstructorsForTesting.ExperimentalProteoform("E");
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("E");
ExperimentalProteoform f = ConstructorsForTesting.ExperimentalProteoform("E");
c.agg_mass = 100;
d.agg_mass = 119;
e.agg_mass = 121;
f.agg_mass = 122;
c.agg_intensity = 1;
d.agg_intensity = 2;
e.agg_intensity = 3;
f.agg_intensity = 4;
List <ExperimentalProteoform> ordered = new List <ExperimentalProteoform> {
c, d, e, f
}.OrderByDescending(cc => cc.agg_intensity).ToList();
ExperimentalProteoform is_running = ConstructorsForTesting.ExperimentalProteoform("E");
is_running.agg_mass = 100;
is_running.agg_intensity = 100;
List <ExperimentalProteoform> active = new List <ExperimentalProteoform> {
is_running
};
ExperimentalProteoform next = Sweet.lollipop.find_next_root(ordered, active);
Assert.True(Math.Abs(next.agg_mass - is_running.agg_mass) > 2 * (double)Sweet.lollipop.maximum_missed_monos);
Assert.AreEqual(4, next.agg_intensity);
}
public void TestUnabeledProteoformCommunityRelateWithNotches_EE()
{
Sweet.lollipop = new Lollipop();
Sweet.lollipop.neucode_labeled = false;
Sweet.lollipop.ee_use_notch = true;
Sweet.lollipop.ee_max_mass_difference = 200;
// One experimental one theoretical protoeform; mass difference < 500 -- return 1
ExperimentalProteoform pf1 = ConstructorsForTesting.ExperimentalProteoform("A1", 1000.0, -1, true);
ExperimentalProteoform pf2 = ConstructorsForTesting.ExperimentalProteoform("A2", 1010.0, -1, true);
ExperimentalProteoform[] paE = new ExperimentalProteoform[2];
paE[0] = pf1;
paE[1] = pf2;
List <ProteoformRelation> prList = new List <ProteoformRelation>();
prepare_for_et(new List <double> {
pf2.modified_mass - pf1.modified_mass
});
prList = community.relate(paE, paE, ProteoformComparison.ExperimentalExperimental, TestContext.CurrentContext.TestDirectory, true);
Assert.AreEqual(1, prList.Count);
//Da instead of ppm -- return 1
Sweet.lollipop.ee_notch_ppm = false;
prList = community.relate(paE, paE, ProteoformComparison.ExperimentalExperimental, TestContext.CurrentContext.TestDirectory, true);
Assert.AreEqual(1, prList.Count);
//outside ppm tolerance - return 0
pf1.modified_mass = 1000;
pf2.modified_mass = 1010.5;
Sweet.lollipop.ee_notch_ppm = true;
Sweet.lollipop.notch_tolerance_ee = 1;
prepare_for_et(new List <double> {
10
});
prList = community.relate(paE, paE, ProteoformComparison.ExperimentalExperimental, TestContext.CurrentContext.TestDirectory, true);
Assert.AreEqual(0, prList.Count);
//outside Da toelrance - return 0.
pf1.modified_mass = 1000;
pf2.modified_mass = 1010.5;
Sweet.lollipop.ee_notch_ppm = false;
Sweet.lollipop.notch_tolerance_ee = .5;
prepare_for_et(new List <double> {
10
});
prList = community.relate(paE, paE, ProteoformComparison.ExperimentalExperimental, TestContext.CurrentContext.TestDirectory, true);
Assert.AreEqual(0, prList.Count);
// One experimental one theoretical protoeform; mass difference > 500 -- return 0
pf1.modified_mass = 1000;
pf2.modified_mass = 2000;
prepare_for_et(new List <double> {
pf2.modified_mass - pf1.modified_mass
});
prList = community.relate(paE, paE, ProteoformComparison.ExperimentalExperimental, TestContext.CurrentContext.TestDirectory, true);
Assert.AreEqual(0, prList.Count);
}
public void test_write_families_regular_display()
{
TheoreticalProteoform t = ConstructorsForTesting.make_a_theoretical();
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("E1");
ProteoformRelation et = new ProteoformRelation(e, t, ProteoformComparison.ExperimentalTheoretical, 0, TestContext.CurrentContext.TestDirectory);
et.peak = new DeltaMassPeak(et, new HashSet <ProteoformRelation> {
et
});
et.peak.Accepted = true;
e.relationships.Add(et);
t.relationships.Add(et);
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,
TestContext.CurrentContext.TestDirectory, "", "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.True(File.Exists(Path.Combine(TestContext.CurrentContext.TestDirectory, CytoscapeScript.script_file_prefix + "test" + CytoscapeScript.script_file_extension)));
Assert.True(File.Exists(Path.Combine(TestContext.CurrentContext.TestDirectory, CytoscapeScript.style_file_prefix + "test" + CytoscapeScript.style_file_extension)));
Assert.True(File.Exists(Path.Combine(TestContext.CurrentContext.TestDirectory, CytoscapeScript.node_file_prefix + "test" + CytoscapeScript.node_file_extension)));
Assert.True(File.Exists(Path.Combine(TestContext.CurrentContext.TestDirectory, CytoscapeScript.edge_file_prefix + "test" + CytoscapeScript.edge_file_extension)));
//Check that the style xml is all there
List <string> vizProperties = new List <string>();
using (XmlReader xml = XmlReader.Create(Path.Combine(TestContext.CurrentContext.TestDirectory, CytoscapeScript.style_file_prefix + "test" + CytoscapeScript.style_file_extension)))
{
while (xml.Read())
{
switch (xml.NodeType)
{
case XmlNodeType.Element:
if (xml.Name == "visualProperty")
{
vizProperties.Add(xml.GetAttribute("name"));
}
break;
}
}
}
Assert.AreEqual(CytoscapeScript.default_styles.Keys.Where(s => s.StartsWith("NETWORK")).Count(), vizProperties.Where(s => s.StartsWith("NETWORK")).Count());
Assert.AreEqual(CytoscapeScript.default_styles.Keys.Where(s => s.StartsWith("NODE")).Count(), vizProperties.Where(s => s.StartsWith("NODE")).Count());
Assert.AreEqual(CytoscapeScript.default_styles.Keys.Where(s => s.StartsWith("EDGE")).Count(), vizProperties.Where(s => s.StartsWith("EDGE")).Count());
Assert.AreEqual(CytoscapeScript.default_styles.Keys.Where(s => !s.StartsWith("NETWORK") && !s.StartsWith("NODE") && !s.StartsWith("EDGE")).Count(), vizProperties.Where(s => !s.StartsWith("NETWORK") && !s.StartsWith("NODE") && !s.StartsWith("EDGE")).Count());
Assert.AreEqual(CytoscapeScript.default_styles.Keys.Count, vizProperties.Count);
Assert.True(message.StartsWith("Finished"));
}
public void TestUnabeledProteoformCommunityRelate_EE()
{
Sweet.lollipop.neucode_labeled = false;
Sweet.lollipop.ee_max_mass_difference = 250;
// Two proteoforms; 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; mass difference > 250 -- return 0
pf1.modified_mass = 1000;
pf2.modified_mass = 2000;
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; 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; one mass difference < 250 Da -- return 1
pf3.modified_mass = 1000;
pf4.modified_mass = 1010;
pf5.modified_mass = 2000;
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; mass difference > 250 Da -- return 0
pf3.modified_mass = 1000;
pf4.modified_mass = 2000;
pf5.modified_mass = 3000;
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 biorepintensitytableLog2Fold()
{
Sweet.lollipop = new Lollipop();
Dictionary <string, List <string> > conditionsBioReps = new Dictionary <string, List <string> >
{
{ "n", new List <string> {
1.ToString(), 2.ToString(), 3.ToString()
} },
{ "s", new List <string> {
1.ToString(), 2.ToString(), 3.ToString()
} },
};
Sweet.lollipop.Log2FoldChangeAnalysis.conditionBiorepIntensitySums = conditionsBioReps.SelectMany(kv => kv.Value.Select(v => new Tuple <string, string>(kv.Key, v))).ToDictionary(t => t, t => 1d);
List <InputFile> input_files = new List <InputFile>
{
ConstructorsForTesting.InputFile("fake.txt", Labeling.NeuCode, Purpose.Quantification, "n", "s", "1", "1", "1"), //0
ConstructorsForTesting.InputFile("fake.txt", Labeling.NeuCode, Purpose.Quantification, "n", "s", "1", "2", "1"), //1
ConstructorsForTesting.InputFile("fake.txt", Labeling.NeuCode, Purpose.Quantification, "n", "s", "2", "1", "1"), //2
ConstructorsForTesting.InputFile("fake.txt", Labeling.NeuCode, Purpose.Quantification, "n", "s", "2", "2", "1"), //3
ConstructorsForTesting.InputFile("fake.txt", Labeling.NeuCode, Purpose.Quantification, "n", "s", "3", "1", "1"), //4
ConstructorsForTesting.InputFile("fake.txt", Labeling.NeuCode, Purpose.Quantification, "n", "s", "3", "2", "1"), //5
};
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("asdf");
e.quant.Log2FoldChangeValues.allIntensities = new Dictionary <Tuple <string, string>, BiorepIntensity>
{
{ new Tuple <string, string>("n", 1.ToString()), new BiorepIntensity(false, 1.ToString(), "n", 1) },
{ new Tuple <string, string>("n", 2.ToString()), new BiorepIntensity(true, 2.ToString(), "n", 1) },
{ new Tuple <string, string>("n", 3.ToString()), new BiorepIntensity(false, 3.ToString(), "n", 1) },
{ new Tuple <string, string>("s", 1.ToString()), new BiorepIntensity(false, 1.ToString(), "s", 1) },
{ new Tuple <string, string>("s", 2.ToString()), new BiorepIntensity(false, 2.ToString(), "s", 1) },
{ new Tuple <string, string>("s", 3.ToString()), new BiorepIntensity(false, 3.ToString(), "s", 1) },
};
// With imputation uses processed values
Assert.False(ResultsSummaryGenerator.datatable_tostring(ResultsSummaryGenerator.biological_replicate_intensities(Sweet.lollipop.Log2FoldChangeAnalysis, new List <ExperimentalProteoform> {
e
}, input_files, conditionsBioReps, true, true)).Contains("NaN"));
// Without imputation uses raw values
e.biorepIntensityList = e.quant.Log2FoldChangeValues.allIntensities.Values.Where(x => !x.imputed).ToList();
Assert.True(ResultsSummaryGenerator.datatable_tostring(ResultsSummaryGenerator.biological_replicate_intensities(Sweet.lollipop.Log2FoldChangeAnalysis, new List <ExperimentalProteoform> {
e
}, input_files, conditionsBioReps, false, true)).Contains("\t0\t"));
// Headers should be condition_biorep_fraction_techrep
string[] header = ResultsSummaryGenerator.datatable_tostring(ResultsSummaryGenerator.biological_replicate_intensities(Sweet.lollipop.Log2FoldChangeAnalysis, new List <ExperimentalProteoform> {
e
}, input_files, conditionsBioReps, false, true)).Split('\n')[0].Split('\t');
Assert.True(header[1] == "n_1" && header[2] == "n_2" && header[3] == "n_3" && header[4] == "s_1" && header[5] == "s_2" && header[6] == "s_3");
string[] line = ResultsSummaryGenerator.datatable_tostring(ResultsSummaryGenerator.biological_replicate_intensities(Sweet.lollipop.Log2FoldChangeAnalysis, new List <ExperimentalProteoform> {
e
}, input_files, conditionsBioReps, false, true)).Split('\n')[1].Split('\t');
Assert.True(line.First() == e.accession);
Assert.True(line[1] == "1" && line[2] == "0" && line[3] == "1" && line[4] == "1" && line[5] == "1" && line[6] == "1"); // all "n" condition is imputed
}
public void aggregate_just_the_root()
{
List <IAggregatable> components = generate_neucode_components(starter_mass);
components.Remove(components[1]);
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("E1", components[0], components, empty_quant_components_list, true);
Assert.AreEqual(1, e.aggregated.Count);
Assert.AreEqual(components[0], e.aggregated.First());
}
public static void no_relations_doesnt_crash()
{
ExperimentalProteoform e1 = ConstructorsForTesting.ExperimentalProteoform("e1");
ExperimentalProteoform e2 = ConstructorsForTesting.ExperimentalProteoform("e2");
ConstructorsForTesting.make_relation(e1, e2);
DeltaMassPeak p = e1.relationships.First().peak;
Assert.AreEqual(0, p.count_nearby_decoys(new List <ProteoformRelation>()));
}
public static void accept_peaks_doesnt_crash_with_weird_relation()
{
ProteoformCommunity c = new ProteoformCommunity();
ProteoformRelation r = new ProteoformRelation(ConstructorsForTesting.ExperimentalProteoform("E1"), ConstructorsForTesting.ExperimentalProteoform("E1"), ProteoformComparison.ExperimentalFalse, 0, TestContext.CurrentContext.TestDirectory);
r.outside_no_mans_land = true;
r.nearby_relations = new List <ProteoformRelation>();
Assert.Throws <ArgumentException>(() => c.accept_deltaMass_peaks(new List <ProteoformRelation> {
r
}, new List <ProteoformRelation>()));
}
public void test_construct_one_proteform_family_from_ET_with_theoretical_pf_group()
{
ProteoformCommunity test_community = new ProteoformCommunity();
SaveState.lollipop.theoretical_database.uniprotModifications = new Dictionary <string, List <Modification> > {
{ "unmodified", new List <Modification> {
new Modification("unmodified", "unknown")
} }
};
InputFile f = new InputFile("fake.txt", Purpose.ProteinDatabase);
ProteinWithGoTerms p1 = new ProteinWithGoTerms("", "T1", new List <Tuple <string, string> > {
new Tuple <string, string>("", "")
}, new Dictionary <int, List <Modification> >(), new int?[] { 0 }, new int?[] { 0 }, new string[] { "" }, "name", "full_name", true, false, new List <DatabaseReference>(), new List <GoTerm>());
Dictionary <InputFile, Protein[]> dict = new Dictionary <InputFile, Protein[]> {
{ f, new Protein[] { p1 } }
};
TheoreticalProteoform t = ConstructorsForTesting.make_a_theoretical("T1_T1_asdf", p1, dict);
//One accepted ET relation; should give one ProteoformFamily
SaveState.lollipop.min_peak_count_et = 1;
ExperimentalProteoform pf1 = ConstructorsForTesting.ExperimentalProteoform("E1");
TheoreticalProteoformGroup pf2 = new TheoreticalProteoformGroup(new List <TheoreticalProteoform> {
t
});
ProteoformComparison comparison = ProteoformComparison.ExperimentalTheoretical;
ProteoformRelation pr1 = new ProteoformRelation(pf1, pf2, comparison, 0, TestContext.CurrentContext.TestDirectory);
pr1.Accepted = true;
List <ProteoformRelation> prs = new List <ProteoformRelation> {
pr1
};
foreach (ProteoformRelation pr in prs)
{
pr.set_nearby_group(prs, prs.Select(r => r.InstanceId).ToList());
}
DeltaMassPeak peak = new DeltaMassPeak(prs[0], prs);
SaveState.lollipop.et_peaks = new List <DeltaMassPeak> {
peak
};
test_community.experimental_proteoforms = new ExperimentalProteoform[] { pf1 };
test_community.theoretical_proteoforms = new TheoreticalProteoform[] { pf2 };
test_community.construct_families();
Assert.AreEqual(1, test_community.families.Count);
Assert.AreEqual(2, test_community.families[0].proteoforms.Count);
Assert.AreEqual(1, test_community.families.First().experimental_proteoforms.Count);
Assert.AreEqual(1, test_community.families.First().theoretical_proteoforms.Count);
Assert.AreEqual("E1", test_community.families.First().experimentals_list);
Assert.AreEqual(p1.Name, test_community.families.First().name_list);
Assert.AreEqual(pf2.accession, test_community.families.First().accession_list);
}
public void saveall()
{
SaveState.lollipop = new Lollipop();
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("asdf");
SaveState.lollipop.qVals.Add(e.quant);
GoTermNumber g = new GoTermNumber(new GoTerm("id", "desc", Aspect.BiologicalProcess), 0, 0, 0, 0);
g.by = -1;
SaveState.lollipop.goTermNumbers.Add(g);
ResultsSummaryGenerator.save_all(TestContext.CurrentContext.TestDirectory, SaveState.time_stamp());
}
public void test_construct_multi_member_family()
{
//Four experimental proteoforms, three relations (linear), all accepted; should give 1 bundled family
SaveState.lollipop = new Lollipop();
ProteoformCommunity test_community = new ProteoformCommunity();
SaveState.lollipop.target_proteoform_community = test_community;
SaveState.lollipop.theoretical_database.uniprotModifications = new Dictionary <string, List <Modification> > {
{ "unmodified", new List <Modification> {
new Modification("unmodified", "unknown")
} }
};
SaveState.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");
test_community.experimental_proteoforms = new ExperimentalProteoform[] { pf3, pf4, pf5, pf6 };
ProteoformComparison comparison34 = ProteoformComparison.ExperimentalExperimental;
ProteoformComparison comparison45 = ProteoformComparison.ExperimentalExperimental;
ProteoformComparison comparison56 = ProteoformComparison.ExperimentalExperimental;
ConstructorsForTesting.make_relation(pf3, pf4, comparison34, 0);
ConstructorsForTesting.make_relation(pf4, pf5, comparison45, 0);
ConstructorsForTesting.make_relation(pf5, pf6, comparison56, 0);
List <ProteoformRelation> prs2 = new HashSet <ProteoformRelation>(test_community.experimental_proteoforms.SelectMany(p => p.relationships).Concat(test_community.theoretical_proteoforms.SelectMany(p => p.relationships))).OrderBy(r => r.DeltaMass).ToList();
foreach (ProteoformRelation pr in prs2)
{
pr.set_nearby_group(prs2, prs2.Select(r => r.InstanceId).ToList());
}
Assert.AreEqual(3, pf3.relationships.First().nearby_relations_count);
Assert.AreEqual(3, pf5.relationships.First().nearby_relations_count);
Assert.AreEqual(3, pf6.relationships.First().nearby_relations_count);
test_community.accept_deltaMass_peaks(prs2, new List <ProteoformRelation>());
Assert.AreEqual(1, SaveState.lollipop.ee_peaks.Count);
Assert.AreEqual(3, SaveState.lollipop.ee_peaks[0].grouped_relations.Count);
test_community.experimental_proteoforms = new ExperimentalProteoform[] { pf3, pf4, pf5, pf6 };
test_community.construct_families();
Assert.AreEqual(1, test_community.families.Count);
Assert.AreEqual("", test_community.families.First().accession_list);
Assert.AreEqual(4, test_community.families.First().proteoforms.Count);
Assert.AreEqual(4, test_community.families.First().experimental_proteoforms.Count);
Assert.AreEqual(0, test_community.families.First().theoretical_proteoforms.Count);
}
public void aggregate_outside_rt_tolerance()
{
Sweet.lollipop.neucode_labeled = true;
List <IAggregatable> components = generate_neucode_components(starter_mass);
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("E1", components[0], components, empty_quant_components_list, true);
components[1].rt_apex = starter_rt - Sweet.lollipop.retention_time_tolerance - 1;
e = ConstructorsForTesting.ExperimentalProteoform("E1", components[0], components, empty_quant_components_list, true);
Assert.AreEqual(1, e.aggregated.Count);
components[1].rt_apex = starter_rt + Sweet.lollipop.retention_time_tolerance + 1;
e = ConstructorsForTesting.ExperimentalProteoform("E1", components[0], components, empty_quant_components_list, true);
Assert.AreEqual(1, e.aggregated.Count);
}
public void test_community_has_proteoforms()
{
community.experimental_proteoforms = new ExperimentalProteoform[] { };
community.theoretical_proteoforms = new TheoreticalProteoform[] { };
Assert.False(community.has_e_proteoforms);
Assert.False(community.has_e_and_t_proteoforms);
community.experimental_proteoforms = new ExperimentalProteoform[] { ConstructorsForTesting.ExperimentalProteoform("E1") };
Assert.True(community.has_e_proteoforms);
Assert.False(community.has_e_and_t_proteoforms);
community.theoretical_proteoforms = new TheoreticalProteoform[] { ConstructorsForTesting.make_a_theoretical() };
Assert.True(community.has_e_proteoforms);
Assert.True(community.has_e_and_t_proteoforms);
}
public void aggregate_outside_lysine_count_tolerance()
{
SaveState.lollipop.neucode_labeled = true;
List <Component> components = generate_neucode_components(starter_mass);
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("E1", components[0], components, empty_quant_components_list, true);
((NeuCodePair)components[1]).lysine_count = starter_lysine_count + Convert.ToInt32(SaveState.lollipop.missed_lysines) + 1;
e = ConstructorsForTesting.ExperimentalProteoform("E1", components[0], components, empty_quant_components_list, true);
Assert.AreEqual(1, e.aggregated_components.Count);
((NeuCodePair)components[1]).lysine_count = starter_lysine_count - Convert.ToInt32(SaveState.lollipop.missed_lysines) - 1;
e = ConstructorsForTesting.ExperimentalProteoform("E1", components[0], components, empty_quant_components_list, true);
Assert.AreEqual(1, e.aggregated_components.Count);
}
public void aggregate_outside_lysine_count_tolerance()
{
Sweet.lollipop.neucode_labeled = true;
List <IAggregatable> components = generate_neucode_components(starter_mass);
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("E1", components[0], components, empty_quant_components_list, true);
((NeuCodePair)components[1]).lysine_count = starter_lysine_count + Sweet.lollipop.maximum_missed_lysines + 1;
e = ConstructorsForTesting.ExperimentalProteoform("E1", components[0], components, empty_quant_components_list, true);
Assert.AreEqual(1, e.aggregated.Count);
((NeuCodePair)components[1]).lysine_count = starter_lysine_count - Sweet.lollipop.maximum_missed_lysines - 1;
e = ConstructorsForTesting.ExperimentalProteoform("E1", components[0], components, empty_quant_components_list, true);
Assert.AreEqual(1, e.aggregated.Count);
}
public void aggregate_mass_corrects_for_monoisotopic_errors()
{
//Make a monoisotopic error, and test that it removes it before aggregation
List <IAggregatable> components = generate_neucode_components(starter_mass);
components[4].weighted_monoisotopic_mass = starter_mass + missed_monoisotopics * Lollipop.MONOISOTOPIC_UNIT_MASS;
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("E1", components[0], components, empty_quant_components_list, true);
double expected_agg_intensity = components.Count * starter_intensity;
double intensity_normalization_factor = components.Count * starter_intensity / expected_agg_intensity;
double expected_agg_mass = starter_mass * intensity_normalization_factor;
Assert.AreEqual(expected_agg_mass, e.agg_mass);
}
public void artificial_deltaMPeak()
{
Sweet.lollipop.theoretical_database.all_possible_ptmsets = new List <PtmSet>();
ExperimentalProteoform pf3 = ConstructorsForTesting.ExperimentalProteoform("E1");
ExperimentalProteoform pf4 = ConstructorsForTesting.ExperimentalProteoform("E2");
ProteoformComparison comparison = ProteoformComparison.ExperimentalExperimental;
ProteoformRelation pr2 = new ProteoformRelation(pf3, pf4, comparison, 0, TestContext.CurrentContext.TestDirectory);
ProteoformRelation pr3 = new ProteoformRelation(pf3, pf4, comparison, 0, TestContext.CurrentContext.TestDirectory);
HashSet <ProteoformRelation> prs = new HashSet <ProteoformRelation> {
pr2, pr3
};
Assert.AreEqual(prs, new DeltaMassPeak(pr2, prs).grouped_relations);
}
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;
SaveState.lollipop.neucode_labeled = true;
List <Component> 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(SaveState.lollipop.mass_tolerance);
ExperimentalProteoform e = ConstructorsForTesting.ExperimentalProteoform("E1", components[0], components, empty_quant_components_list, true);
Assert.AreEqual(2, e.aggregated_components.Count);
// in bounds highest monoisotopic error
components[1].weighted_monoisotopic_mass = max_monoisotopic_mass + max_monoisotopic_mass / 1000000 * Convert.ToDouble(SaveState.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(e.accepted, f.accepted);
Assert.AreEqual("E1", f.quant.accession);
Assert.AreEqual(e.mass_shifted, f.mass_shifted);
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_components.GetHashCode(), f.aggregated_components.GetHashCode());
Assert.AreEqual(e.aggregated_components.Count, f.aggregated_components.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();
Sweet.lollipop.input_files.Add(ConstructorsForTesting.InputFile("fake.txt", Labeling.NeuCode, Purpose.Identification, "n", "s", "1", "1", "1")); //0
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.target_proteoform_community, 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.target_proteoform_community, 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.AreEqual(lines.Count(), 4);
Assert.True(lines.Any(a => a.Contains("E1")));
Assert.True(lines.Any(a => a.Contains("TD1")));
}
public void test_construct_one_proteform_family_from_ET()
{
SaveState.lollipop = new Lollipop();
ProteoformCommunity test_community = new ProteoformCommunity();
SaveState.lollipop.target_proteoform_community = test_community;
SaveState.lollipop.theoretical_database.uniprotModifications = new Dictionary <string, List <Modification> > {
{ "unmodified", new List <Modification> {
new Modification("unmodified", "unknown")
} }
};
//One accepted ET relation; should give one ProteoformFamily
SaveState.lollipop.min_peak_count_et = 1;
ExperimentalProteoform pf1 = ConstructorsForTesting.ExperimentalProteoform("E1");
pf1.accepted = true;
TheoreticalProteoform pf2 = ConstructorsForTesting.make_a_theoretical();
pf2.name = "T1";
ProteoformComparison comparison = ProteoformComparison.ExperimentalTheoretical;
ProteoformRelation pr1 = new ProteoformRelation(pf1, pf2, comparison, 0, TestContext.CurrentContext.TestDirectory);
pr1.Accepted = true;
List <ProteoformRelation> prs = new List <ProteoformRelation> {
pr1
};
foreach (ProteoformRelation pr in prs)
{
pr.set_nearby_group(prs, prs.Select(r => r.InstanceId).ToList());
}
DeltaMassPeak peak = new DeltaMassPeak(prs[0], prs);
SaveState.lollipop.et_peaks = new List <DeltaMassPeak> {
peak
};
test_community.experimental_proteoforms = new ExperimentalProteoform[] { pf1 };
test_community.theoretical_proteoforms = new TheoreticalProteoform[] { pf2 };
test_community.construct_families();
Assert.AreEqual("T1", test_community.families.First().name_list);
Assert.AreEqual("T1", test_community.families.First().accession_list);
Assert.AreEqual("E1", test_community.families.First().experimentals_list);
Assert.AreEqual(1, test_community.families.Count);
Assert.AreEqual(2, test_community.families[0].proteoforms.Count);
Assert.AreEqual(1, test_community.families.First().experimental_proteoforms.Count);
Assert.AreEqual(1, test_community.families.First().theoretical_proteoforms.Count);
}
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 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);
}