public void AddResults()
{
var settings = _document.Settings;
if (!settings.HasResults)
{
MessageDlg.Show(MessageParent, Resources.LibraryGridViewDriver_AddResults_The_active_document_must_contain_results_in_order_to_add_optimized_values_);
return;
}
var newOptimizations = new HashSet <DbOptimization>();
foreach (PeptideGroupDocNode seq in _document.MoleculeGroups.Where(seq => seq.TransitionCount > 0 && !seq.IsDecoy))
{
foreach (PeptideDocNode peptide in seq.Children)
{
foreach (TransitionGroupDocNode nodeGroup in peptide.Children)
{
string sequence = _document.Settings.GetSourceTextId(peptide);
int charge = nodeGroup.TransitionGroup.PrecursorCharge;
foreach (TransitionDocNode nodeTran in nodeGroup.Children)
{
OptimizationKey key = null;
double? value = null;
if (Equals(ViewType, ExportOptimize.CE))
{
key = new OptimizationKey(ViewDbType, sequence, charge, nodeTran.GetFragmentIonName(CultureInfo.InvariantCulture), nodeTran.Transition.Charge);
value = OptimizationStep <CollisionEnergyRegression> .FindOptimizedValueFromResults(
settings, peptide, nodeGroup, nodeTran, OptimizedMethodType.Transition, GetCollisionEnergy);
}
else if (Equals(ViewType, ExportOptimize.COV))
{
key = new OptimizationKey(ViewDbType, sequence, charge, null, 0);
double?cov = OptimizationStep <CompensationVoltageRegressionFine> .FindOptimizedValueFromResults(_document.Settings,
peptide, nodeGroup, null, OptimizedMethodType.Precursor, SrmDocument.GetCompensationVoltageFine);
value = cov.HasValue ? cov.Value : 0;
}
if (value.HasValue && value > 0)
{
newOptimizations.Add(new DbOptimization(key, value.Value));
}
}
}
}
}
AddToLibrary(newOptimizations);
}
public override int GetHashCode()
{
unchecked
{
int result = base.GetHashCode();
result = (result * 397) ^ (MassError.HasValue ? MassError.Value.GetHashCode() : 0);
result = (result * 397) ^ RetentionTime.GetHashCode();
result = (result * 397) ^ StartRetentionTime.GetHashCode();
result = (result * 397) ^ EndRetentionTime.GetHashCode();
result = (result * 397) ^ Area.GetHashCode();
result = (result * 397) ^ BackgroundArea.GetHashCode();
result = (result * 397) ^ Height.GetHashCode();
result = (result * 397) ^ Fwhm.GetHashCode();
result = (result * 397) ^ IsFwhmDegenerate.GetHashCode();
result = (result * 397) ^ Identified.GetHashCode();
result = (result * 397) ^ (IsTruncated.HasValue ? IsTruncated.Value.GetHashCode() : 0);
result = (result * 397) ^ Rank;
result = (result * 397) ^ Ratios.GetHashCodeDeep();
result = (result * 397) ^ OptimizationStep.GetHashCode();
result = (result * 397) ^ Annotations.GetHashCode();
result = (result * 397) ^ UserSet.GetHashCode();
return(result);
}
}
/// <summary>
/// Serializes the contents of a single <see cref="TransitionDocNode"/>
/// to XML.
/// </summary>
/// <param name="writer">The XML writer</param>
/// <param name="nodePep">The transition group's parent peptide node</param>
/// <param name="nodeGroup">The transition node's parent group node</param>
/// <param name="nodeTransition">The transition document node</param>
private void WriteTransitionXml(XmlWriter writer, PeptideDocNode nodePep, TransitionGroupDocNode nodeGroup,
TransitionDocNode nodeTransition)
{
Transition transition = nodeTransition.Transition;
writer.WriteAttribute(ATTR.fragment_type, transition.IonType);
writer.WriteAttribute(ATTR.quantitative, nodeTransition.ExplicitQuantitative, true);
if (transition.IsCustom())
{
if (!(transition.CustomIon is SettingsCustomIon))
{
transition.CustomIon.WriteXml(writer, transition.Adduct);
}
else
{
writer.WriteAttributeString(ATTR.measured_ion_name, transition.CustomIon.Name);
}
}
writer.WriteAttributeNullable(ATTR.decoy_mass_shift, transition.DecoyMassShift);
// NOTE: MassIndex is the peak index in the isotopic distribution of the precursor.
// 0 for monoisotopic peaks and for non "precursor" ion types.
if (transition.MassIndex != 0)
{
writer.WriteAttribute(ATTR.mass_index, transition.MassIndex);
}
if (nodeTransition.HasDistInfo)
{
writer.WriteAttribute(ATTR.isotope_dist_rank, nodeTransition.IsotopeDistInfo.Rank);
writer.WriteAttribute(ATTR.isotope_dist_proportion, nodeTransition.IsotopeDistInfo.Proportion);
}
if (!transition.IsPrecursor())
{
if (!transition.IsCustom())
{
writer.WriteAttribute(ATTR.fragment_ordinal, transition.Ordinal);
writer.WriteAttribute(ATTR.calc_neutral_mass, nodeTransition.GetMoleculePersistentNeutralMass());
}
writer.WriteAttribute(ATTR.product_charge, transition.Charge);
if (!transition.IsCustom())
{
writer.WriteAttribute(ATTR.cleavage_aa, transition.AA.ToString(CultureInfo.InvariantCulture));
writer.WriteAttribute(ATTR.loss_neutral_mass, nodeTransition.LostMass); //po
}
}
// Order of elements matters for XSD validation
WriteAnnotations(writer, nodeTransition.Annotations);
writer.WriteElementString(EL.precursor_mz, SequenceMassCalc.PersistentMZ(nodeGroup.PrecursorMz));
writer.WriteElementString(EL.product_mz, SequenceMassCalc.PersistentMZ(nodeTransition.Mz));
TransitionPrediction predict = Settings.TransitionSettings.Prediction;
var optimizationMethod = predict.OptimizedMethodType;
double?ce = null;
double?dp = null;
var lib = predict.OptimizedLibrary;
if (lib != null && !lib.IsNone)
{
var optimization = lib.GetOptimization(OptimizationType.collision_energy,
Settings.GetSourceTarget(nodePep), nodeGroup.PrecursorAdduct,
nodeTransition.FragmentIonName, nodeTransition.Transition.Adduct);
if (optimization != null)
{
ce = optimization.Value;
}
}
double regressionMz = Settings.GetRegressionMz(nodePep, nodeGroup);
var ceRegression = predict.CollisionEnergy;
var dpRegression = predict.DeclusteringPotential;
if (optimizationMethod == OptimizedMethodType.None)
{
if (ceRegression != null && !ce.HasValue)
{
ce = ceRegression.GetCollisionEnergy(nodeGroup.PrecursorAdduct, regressionMz);
}
if (dpRegression != null)
{
dp = dpRegression.GetDeclustringPotential(regressionMz);
}
}
else
{
if (!ce.HasValue)
{
ce = OptimizationStep <CollisionEnergyRegression> .FindOptimizedValue(Settings,
nodePep, nodeGroup, nodeTransition, optimizationMethod, ceRegression,
SrmDocument.GetCollisionEnergy);
}
dp = OptimizationStep <DeclusteringPotentialRegression> .FindOptimizedValue(Settings,
nodePep, nodeGroup, nodeTransition, optimizationMethod, dpRegression,
SrmDocument.GetDeclusteringPotential);
}
if (nodeGroup.ExplicitValues.CollisionEnergy.HasValue)
{
ce = nodeGroup.ExplicitValues.CollisionEnergy; // Explicitly imported, overrides any calculation
}
if (ce.HasValue)
{
writer.WriteElementString(EL.collision_energy, ce.Value);
}
if (dp.HasValue)
{
writer.WriteElementString(EL.declustering_potential, dp.Value);
}
WriteTransitionLosses(writer, nodeTransition.Losses);
if (nodeTransition.HasLibInfo)
{
writer.WriteStartElement(EL.transition_lib_info);
writer.WriteAttribute(ATTR.rank, nodeTransition.LibInfo.Rank);
writer.WriteAttribute(ATTR.intensity, nodeTransition.LibInfo.Intensity);
writer.WriteEndElement();
}
if (nodeTransition.HasResults)
{
if (nodeTransition.HasResults)
{
if (UseCompactFormat())
{
var protoResults = new SkylineDocumentProto.Types.TransitionResults();
protoResults.Peaks.AddRange(nodeTransition.GetTransitionPeakProtos(Settings.MeasuredResults));
byte[] bytes = protoResults.ToByteArray();
writer.WriteStartElement(EL.results_data);
writer.WriteBase64(bytes, 0, bytes.Length);
writer.WriteEndElement();
}
else
{
WriteResults(writer, Settings, nodeTransition.Results,
EL.transition_results, EL.transition_peak, WriteTransitionChromInfo);
}
}
}
if (WroteTransitions != null)
{
WroteTransitions(1);
}
}
