/// <summary>
/// Initializes a new instance of the <see cref="ChemicalProteoformHashGenerator" /> class.
/// </summary>
/// <param name="proFormaParser">The proForma parser.</param>
/// <param name="proteoformGroupFactory">The proteoform group factory.</param>
/// <param name="proteoformModificationLookup">The proteoform modification lookup.</param>
/// <param name="mapper">The mapper.</param>
public ChemicalProteoformHashGenerator(ProFormaParser proFormaParser, ProteoformGroupFactory proteoformGroupFactory,
IProteoformModificationLookup proteoformModificationLookup, IAccessionMapper mapper)
{
_proFormaParser = proFormaParser;
_proteoformGroupFactory = proteoformGroupFactory;
_proteoformModificationLookup = proteoformModificationLookup;
_mapper = mapper;
}
private void SetupXlMod()
{
var parser = new XlmodOboParser();
XlmodTerm[] modifications = parser.Parse(XlmodOboParserTest.GetFilePath()).ToArray();
_xlmodLookup = XlModModificationLookup.CreateFromModifications(modifications,
_elementProvider);
}
public void Setup()
{
_elementProvider = new MockElementProvider();
_residueProvider = new IupacAminoAcidProvider(_elementProvider);
_factory = new ProteoformGroupFactory(_elementProvider, _residueProvider);
var parser = new ResidXmlParser();
var modifications = parser.Parse(ResidXmlParserTest.GetResidFilePath()).ToArray();
_residLookup = ResidModificationLookup.CreateFromModifications(modifications.Where(x => x.Id == "AA0038" || x.Id == "AA0074"),
_elementProvider);
}
private void SetupResid()
{
var parser = new ResidXmlParser();
ResidModification[] modifications = parser.Parse(ResidXmlParserTest.GetResidFilePath()).ToArray();
_resid38 = modifications.Single(x => x.Id == "AA0038");
//_residLookup = ResidModificationLookup.CreateFromModifications(new[] { _resid38 },
// _elementProvider);
_residLookup = ResidModificationLookup.CreateFromModifications(modifications,
_elementProvider);
}
private void SetupPsiMod()
{
var parser = new PsiModOboParser();
PsiModTerm[] modifications = parser.Parse(PsiModOboParserTest.GetFilePath()).ToArray();
_psiMod38 = modifications.Single(x => x.Id == "MOD:00038");
//_psiModLookup = PsiModModificationLookup.CreateFromModifications(new[] { _psiMod38 },
// _elementProvider);
_psiModLookup = PsiModModificationLookup.CreateFromModifications(modifications,
_elementProvider);
}
private void SetupUniProt()
{
var parser = new UniProtPtmListParser();
UniprotModification[] modifications = parser.Parse(File.ReadAllText(UniProtTests.GetPtmListPath())).ToArray();
_uniProtMod312 = modifications.Single(x => x.Id == "PTM-0312");
//_uniProtModLookup = UniProtModificationLookup.CreateFromModifications(new[] { _uniProtMod312 },
// _elementProvider);
_uniProtModLookup = UniProtModificationLookup.CreateFromModifications(modifications,
_elementProvider);
}
private void SetupUnimod()
{
var atomProvider = new UnimodHardCodedAtomProvider(_elementProvider);
var parser = new UnimodOboParser();
UnimodModification[] modifications = parser.Parse(UnimodTest.GetUnimodFilePath()).ToArray();
_unimod37 = modifications.Single(x => x.Id == "UNIMOD:37");
//_unimodLookup = UnimodModificationLookup.CreateFromModifications(new[] { _unimod37 },
// atomProvider);
_unimodLookup = UnimodModificationLookup.CreateFromModifications(modifications, atomProvider);
}
private void FindById(IProteoformModificationLookup lookup, ProFormaKey key, ProFormaEvidenceType evidenceType,
int correctId, string extraPrefix)
{
Assert.IsNotNull(lookup.GetModification(new ProFormaDescriptor(key, evidenceType, $"{extraPrefix}{correctId}")));
Assert.IsNotNull(lookup.GetModification(new ProFormaDescriptor(key, evidenceType, $"{correctId}")));
Assert.Throws <ProteoformModificationLookupException>(
() => lookup.GetModification(new ProFormaDescriptor(key, evidenceType, "-1")));
Assert.Throws <ProteoformModificationLookupException>(
() => lookup.GetModification(new ProFormaDescriptor(key, evidenceType, $"{extraPrefix}0")));
Assert.Throws <ProteoformModificationLookupException>(
() => lookup.GetModification(new ProFormaDescriptor(key, evidenceType, $"{extraPrefix}2200")));
}
private void FindByName(IProteoformModificationLookup lookup, ProFormaEvidenceType evidenceType,
bool isDefault, string correctName)
{
if (isDefault)
{
Assert.IsNotNull(lookup.GetModification(new ProFormaDescriptor(ProFormaKey.Name, ProFormaEvidenceType.None, correctName)));
}
Assert.IsNotNull(lookup.GetModification(new ProFormaDescriptor(ProFormaKey.Name, evidenceType, correctName)));
Assert.Throws <ProteoformModificationLookupException>(
() => lookup.GetModification(new ProFormaDescriptor(ProFormaKey.Name, ProFormaEvidenceType.None, "Something")));
Assert.Throws <ProteoformModificationLookupException>(
() => lookup.GetModification(new ProFormaDescriptor(ProFormaKey.Name, evidenceType, "Something")));
}
private void DescriptorHandling(IProteoformModificationLookup lookup, ProFormaEvidenceType key, bool isDefault)
{
// If the key is a specific mod type, always handle
Assert.IsTrue(lookup.CanHandleDescriptor(new ProFormaDescriptor(ProFormaKey.Name, key, "Anything")));
Assert.IsTrue(lookup.CanHandleDescriptor(new ProFormaDescriptor(ProFormaKey.Name, key, "")));
Assert.IsTrue(lookup.CanHandleDescriptor(new ProFormaDescriptor(ProFormaKey.Name, key, null)));
// If using modification name, must have no ending or end in proper ending
Assert.IsTrue(lookup.CanHandleDescriptor(new ProFormaDescriptor(ProFormaKey.Name, key, "Something")));
Assert.IsFalse(lookup.CanHandleDescriptor(new ProFormaDescriptor(ProFormaKey.Name, "Something")));
Assert.IsFalse(lookup.CanHandleDescriptor(new ProFormaDescriptor(ProFormaKey.Name, ProFormaEvidenceType.Brno, "Something")));
// This is malformed and must be interpreted as a mod "name" ... will fail when looking up modification
//Assert.AreEqual(lookup.CanHandleDescriptor(new ProFormaDescriptor(ProFormaKey.Name, $"Something [{key}]")), isDefault);
}
private IProteoformMassDelta?GetModification(IProFormaDescriptor?descriptor, IProteoformModificationLookup modificationLookup)
{
IProteoformMassDelta?modification = null;
if (descriptor != null)
{
if (modificationLookup == null)
{
throw new ProteoformGroupCreateException("Cannot lookup tag because lookup wasn't provided.");
}
if (modificationLookup.CanHandleDescriptor(descriptor))
{
return(modificationLookup.GetModification(descriptor));
}
throw new ProteoformGroupCreateException($"Couldn't handle descriptor {descriptor}.");
}
return(modification);
}
public void Setup()
{
var unimodOboParser = new UnimodOboParser();
UnimodModification[] modifications = unimodOboParser.Parse(UnimodTest.GetUnimodFilePath()).ToArray();
NistElementParser nistParser = new NistElementParser();
IElement[] elements = nistParser.ParseFile(Path.Combine(TestContext.CurrentContext.TestDirectory, "TestData", "elements.dat")).ToArray();
_elementProvider = new InMemoryElementProvider(elements);
_residueProvider = new IupacAminoAcidProvider(_elementProvider);
var atomProvider = new UnimodHardCodedAtomProvider(_elementProvider);
_lookup = new CompositeModificationLookup(new IProteoformModificationLookup[]
{
UnimodModificationLookup.CreateFromModifications(modifications, atomProvider),
new FormulaLookup(_elementProvider),
new MassLookup(),
new BrnoModificationLookup(_elementProvider),
new IgnoreKeyModificationLookup(ProFormaKey.Info),
});
ProFormaParser proFormaParser = new ProFormaParser();
ProteoformGroupFactory proteoformGroupFactory = new ProteoformGroupFactory(_elementProvider, _residueProvider);
var mapper = new RelayAccessionMapper(d =>
{
if (d == "B:ac")
{
return(Tuple.Create(ProFormaEvidenceType.PsiMod, "MOD:00394")); // acetylated residue
}
return(Tuple.Create(ProFormaEvidenceType.None, d));
});
var parser = new UniProtPtmListParser();
var entries = parser.Parse(File.ReadAllText(UniProtTests.GetPtmListPath())).ToList();
_chemicalProteoformHashGenerator = new ChemicalProteoformHashGenerator(proFormaParser, proteoformGroupFactory, _lookup, mapper);
}
public void PsiModIsotope()
{
var parser = new PsiModOboParser();
PsiModTerm[] modifications = parser.Parse(PsiModOboParserTest.GetFilePath()).ToArray();
PsiModTerm psiMod402 = modifications.Single(x => x.Id == "MOD:00402");
IProteoformModificationLookup psiModLookup = PsiModModificationLookup.CreateFromModifications(new[] { psiMod402 },
_elementProvider);
this.FindById(psiModLookup, ProFormaKey.Identifier, ProFormaEvidenceType.PsiMod, 402, "MOD:");
var mod = psiModLookup.GetModification(new ProFormaDescriptor(ProFormaKey.Identifier,
ProFormaEvidenceType.PsiMod, "MOD:00402"));
ChemicalFormula chemicalFormula = new ChemicalFormula(
new IEntityCardinality <IElement>[]
{
new EntityCardinality <IElement>(_elementProvider.GetElement("C"), 22),
new EntityCardinality <IElement>(_elementProvider.GetElement("H", 1), 30),
new EntityCardinality <IElement>(_elementProvider.GetElement("H", 2), 8),
new EntityCardinality <IElement>(_elementProvider.GetElement("N"), 4),
new EntityCardinality <IElement>(_elementProvider.GetElement("O"), 6),
new EntityCardinality <IElement>(_elementProvider.GetElement("S"), 1),
});
Assert.IsInstanceOf(typeof(IHasChemicalFormula), mod);
var formulaMod = (IHasChemicalFormula)mod;
Assert.IsTrue(chemicalFormula.Equals(formulaMod.GetChemicalFormula()));
Assert.IsInstanceOf(typeof(IIdentifiable), mod);
var idMod = (IIdentifiable)mod;
Assert.AreEqual("MOD:00402", idMod.Id);
Assert.AreEqual("Gygi ICAT(TM) d8 modified cysteine", idMod.Name);
}
/// <summary>
/// Creates the proteoform group.
/// </summary>
/// <param name="term">The term.</param>
/// <param name="modificationLookup">The modification lookup.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">term</exception>
/// <exception cref="ProteoformGroupCreateException">
/// Cannot lookup tag because lookup wasn't provided.
/// or
/// </exception>
public IProteoformGroup CreateProteoformGroup(ProFormaTerm term, IProteoformModificationLookup modificationLookup)
{
if (term == null)
{
throw new ArgumentNullException(nameof(term));
}
var residues = term.Sequence.Select(x => _residueProvider.GetResidue(x)).ToArray();
List <IProteoformLocalizedModification>? localizedModifications = null;
List <IProteoformUnlocalizedModification>?unlocalizedModifications = null;
List <IProteoformModificationGroup>? modificationGroups = null;
List <IProteoformGlobalModification>? globalModifications = null;
IProteoformMassDelta?nTerminalModification = this.GetModification(term.NTerminalDescriptors, modificationLookup, "Multiple N Terminal Modifications");
IProteoformMassDelta?cTerminalModification = this.GetModification(term.CTerminalDescriptors, modificationLookup, "Multiple C Terminal Modifications");
if (term.Tags?.Count > 0)
{
foreach (var tag in term.Tags)
{
IProteoformMassDelta?delta = this.GetModification(tag.Descriptors, modificationLookup,
$"Multiple modifications at index: {tag.ZeroBasedStartIndex}");
if (delta != null)
{
localizedModifications ??= new List <IProteoformLocalizedModification>();
localizedModifications.Add(new LocalizedModification(delta, tag.ZeroBasedStartIndex, tag.ZeroBasedEndIndex));
}
}
}
if (term.LabileDescriptors?.Count > 0)
{
foreach (var item in term.LabileDescriptors)
{
IProteoformMassDelta?delta = this.GetModification(item, modificationLookup);
if (delta != null)
{
unlocalizedModifications ??= new List <IProteoformUnlocalizedModification>();
unlocalizedModifications.Add(new UnlocalizedModification(delta, 1, true));
}
}
}
if (term.UnlocalizedTags?.Count > 0)
{
foreach (var item in term.UnlocalizedTags)
{
IProteoformMassDelta?delta = this.GetModification(item.Descriptors, modificationLookup,
"Multiple unlocalized descriptors on same tag.");
if (delta != null)
{
unlocalizedModifications ??= new List <IProteoformUnlocalizedModification>();
unlocalizedModifications.Add(new UnlocalizedModification(delta, item.Count, false));
}
}
}
if (term.TagGroups?.Count > 0)
{
foreach (var item in term.TagGroups)
{
IProteoformMassDelta?delta = this.GetModification(item, modificationLookup);
if (delta != null)
{
modificationGroups ??= new List <IProteoformModificationGroup>();
modificationGroups.Add(new TagGroupModification(delta, item.Name,
item.Members.Select(x => new TagGroupModificationMember(x.ZeroBasedStartIndex, x.ZeroBasedEndIndex, x.Weight))));
}
}
}
// Debating about doing this as a decorators around Residues. Starting with just keeping this as another mod type.
if (term.GlobalModifications?.Count > 0)
{
foreach (var item in term.GlobalModifications)
{
IProteoformMassDelta?delta = this.GetModification(item.Descriptors, modificationLookup,
"Multiple global modification descriptors on same tag.");
if (delta != null)
{
globalModifications ??= new List <IProteoformGlobalModification>();
globalModifications.Add(new GlobalModification(delta, item.TargetAminoAcids));
}
}
}
return(new ProteoformGroup(residues, nTerminalModification, cTerminalModification, localizedModifications, unlocalizedModifications,
modificationGroups, globalModifications, _water));
}
private IProteoformMassDelta?GetModification(IList <ProFormaDescriptor>?descriptors, IProteoformModificationLookup modificationLookup,
string multipleModsErrorMessage)
{
IProteoformMassDelta?modification = null;
if (descriptors != null && descriptors.Count > 0)
{
if (modificationLookup == null)
{
throw new ProteoformGroupCreateException("Cannot lookup tag because lookup wasn't provided.");
}
foreach (var descriptor in descriptors)
{
IProteoformMassDelta?mod = null;
if (modificationLookup.CanHandleDescriptor(descriptor))
{
mod = modificationLookup.GetModification(descriptor);
}
else
{
throw new ProteoformGroupCreateException($"Couldn't handle descriptor {descriptor}.");
}
if (modification == null)
{
modification = mod;
}
else if (mod != null)
{
if (mod is IHasChemicalFormula form1 &&
modification is IHasChemicalFormula form2 &&
!form1.GetChemicalFormula().Equals(form2.GetChemicalFormula()))
{
throw new ProteoformGroupCreateException(multipleModsErrorMessage);
}
}
}
}
return(modification);
}
private void SetupFormula()
{
_formulaLookup = new FormulaLookup(_elementProvider);
}
private void InvalidIdHandling(string id, IProteoformModificationLookup lookup, ProFormaKey key,
ProFormaEvidenceType evidenceType = ProFormaEvidenceType.None)
{
Assert.Throws <ProteoformModificationLookupException>(
() => lookup.GetModification(new ProFormaDescriptor(key, evidenceType, id)));
}
