class Experiment(MRExperiment):
"""
An Experiment is a container for multiple experimental runs - some of which may contain the same precursors.
"""
def __init__(self):
super(Experiment, self).__init__()
self.transformation_collection = TransformationCollection()
def estimate_real_fdr(self, multipeptides, fraction_needed_selected):
class DecoyStats():
def __init__(self):
self.est_real_fdr = 0.0
self.nr_decoys = 0
self.nr_targets = 0
self.decoy_pcnt = 0.0
self.est_real_fdr = 0.0
d = DecoyStats()
precursors_to_be_used = [
m for m in multipeptides
if m.more_than_fraction_selected(fraction_needed_selected)
]
# count the decoys
d.nr_decoys = sum([
len(prec.get_selected_peakgroups())
for prec in precursors_to_be_used
if prec.find_best_peptide_pg().peptide.get_decoy()
])
d.nr_targets = sum([
len(prec.get_selected_peakgroups())
for prec in precursors_to_be_used
if not prec.find_best_peptide_pg().peptide.get_decoy()
])
# estimate the real fdr by calculating the decoy ratio and dividing it
# by the decoy ration obtained at @fdr_cutoff => which gives us the
# decoy in/decrease realtive to fdr_cutoff. To calculate the absolute
# value, we multiply by fdr_cutoff again (which was used to obtain the
# original estimated decoy percentage).
if self.estimated_decoy_pcnt is None: return d
if (d.nr_targets + d.nr_decoys) == 0: return d
d.decoy_pcnt = (d.nr_decoys * 100.0 / (d.nr_targets + d.nr_decoys))
d.est_real_fdr = d.decoy_pcnt / self.estimated_decoy_pcnt * self.initial_fdr_cutoff
return d
def print_stats(self, multipeptides, fdr_cutoff, fraction_present,
min_nrruns):
alignment = AlignmentStatistics()
alignment.count(multipeptides, fdr_cutoff)
# Count presence in all runs (before alignment)
precursors_in_all_runs_wo_align = len([
1 for m in multipeptides
if m.all_above_cutoff(fdr_cutoff) and not m.get_decoy()
])
proteins_in_all_runs_wo_align_target = len(
set([
m.find_best_peptide_pg().peptide.protein_name
for m in multipeptides if m.all_above_cutoff(fdr_cutoff)
and not m.find_best_peptide_pg().peptide.get_decoy()
]))
peptides_in_all_runs_wo_align_target = len(
set([
m.find_best_peptide_pg().peptide.sequence
for m in multipeptides if m.all_above_cutoff(fdr_cutoff)
and not m.find_best_peptide_pg().peptide.get_decoy()
]))
# Count presence in all runs (before alignment)
precursors_in_all_runs = [m for m in multipeptides if m.all_selected()]
nr_peptides_target = len(
set([
prec.find_best_peptide_pg().peptide.sequence
for prec in precursors_in_all_runs
if not prec.find_best_peptide_pg().peptide.get_decoy()
]))
nr_proteins_target = len(
set([
prec.find_best_peptide_pg().peptide.protein_name
for prec in precursors_in_all_runs
if not prec.find_best_peptide_pg().peptide.get_decoy()
]))
nr_precursors_in_all = len([
1 for m in multipeptides if m.all_selected() and not m.get_decoy()
])
max_pg = alignment.nr_good_precursors * len(self.runs)
dstats = self.estimate_real_fdr(multipeptides, fraction_present)
dstats_all = self.estimate_real_fdr(multipeptides, 1.0)
# Get single/multiple hits stats
from itertools import groupby
precursors_quantified = [
m for m in multipeptides if len(m.get_selected_peakgroups()) > 0
]
target_quant_protein_list = [
prec.find_best_peptide_pg().peptide.protein_name
for prec in precursors_quantified
if not prec.find_best_peptide_pg().peptide.get_decoy()
]
target_quant_protein_list.sort()
nr_sh_target_proteins = sum([
len(list(group)) == 1
for key, group in groupby(target_quant_protein_list)
])
nr_mh_target_proteins = sum([
len(list(group)) > 1
for key, group in groupby(target_quant_protein_list)
])
#
###########################################################################
#
print "=" * 75
print "=" * 75
print "Total we have", len(self.runs), "runs with", alignment.nr_good_precursors, \
"peakgroups quantified in at least %s run(s) below m_score (q-value) %0.4f %%" % (min_nrruns, fdr_cutoff*100) + ", " + \
"giving maximally nr peakgroups", max_pg
print "We were able to quantify", alignment.nr_quantified, "/", max_pg, "peakgroups of which we aligned", \
alignment.nr_aligned
print " The order of", alignment.nr_changed, "peakgroups was changed,", max_pg - alignment.nr_quantified, \
"could not be aligned and %s were removed. Ambigous cases: %s, multiple suitable peakgroups: %s" % (
alignment.nr_removed, self.nr_ambiguous, self.nr_multiple_align)
print "We were able to quantify %s / %s precursors in %s runs, and %s in all runs (up from %s before alignment)" % (
alignment.nr_quant_precursors, alignment.nr_good_precursors,
min_nrruns, nr_precursors_in_all, precursors_in_all_runs_wo_align)
print "We were able to quantify %s / %s peptides in %s runs, and %s in all runs (up from %s before alignment)" % (
len(alignment.quant_peptides), len(
alignment.good_peptides), min_nrruns, nr_peptides_target,
peptides_in_all_runs_wo_align_target)
print "We were able to quantify %s / %s proteins in %s runs, and %s in all runs (up from %s before alignment)" % (
len(alignment.quant_proteins), len(
alignment.good_proteins), min_nrruns, nr_proteins_target,
proteins_in_all_runs_wo_align_target)
print " Of these %s proteins, %s were multiple hits and %s were single hits." % (
len(alignment.quant_proteins), nr_mh_target_proteins,
nr_sh_target_proteins)
# Get decoy estimates
decoy_precursors = len([
1 for m in multipeptides if len(m.get_selected_peakgroups()) > 0
and m.find_best_peptide_pg().peptide.get_decoy()
])
if len(precursors_in_all_runs) > 0:
print "Decoy percentage of peakgroups that are fully aligned %0.4f %% (%s out of %s) which roughly corresponds to a peakgroup FDR of %s %%" % (
dstats_all.decoy_pcnt, dstats_all.nr_decoys,
dstats_all.nr_decoys + dstats_all.nr_targets,
dstats_all.est_real_fdr * 100)
print "Decoy percentage of peakgroups that are partially aligned %0.4f %% (%s out of %s) which roughly corresponds to a peakgroup FDR of %s %%" % (
dstats.decoy_pcnt, dstats.nr_decoys, dstats.nr_decoys +
dstats.nr_targets, dstats.est_real_fdr * 100)
print "There were", decoy_precursors, "decoy precursors identified out of", \
alignment.nr_quant_precursors + decoy_precursors, "precursors which is %0.4f %%" % (
decoy_precursors *100.0 / (alignment.nr_quant_precursors + decoy_precursors))
def _getTrafoFilename(self, current_run, ref_id):
current_id = current_run.get_id()
input_basename = os.path.basename(current_run.orig_filename)
fn = os.path.splitext(input_basename)[0]
dirname = os.path.dirname(current_run.orig_filename)
filename = os.path.join(dirname,
"%s-%s-%s.tr" % (fn, current_id, ref_id))
return filename
def _write_trafo_files(self):
# Print out trafo data
trafo_fnames = []
for current_run in self.runs:
current_id = current_run.get_id()
ref_id = self.transformation_collection.getReferenceRunID()
filename = self._getTrafoFilename(current_run, ref_id)
trafo_fnames.append(filename)
self.transformation_collection.writeTransformationData(
filename, current_id, ref_id)
self.transformation_collection.readTransformationData(filename)
def write_to_file(self, multipeptides, options, writeTrafoFiles=True):
infiles = options.infiles
outfile = options.outfile
matrix_outfile = options.matrix_outfile
yaml_outfile = options.yaml_outfile
ids_outfile = options.ids_outfile
fraction_needed_selected = options.min_frac_selected
file_format = options.file_format
# 1. Collect ids of selected features
selected_pgs = []
for m in multipeptides:
selected_peakgroups = m.get_selected_peakgroups()
if (len(selected_peakgroups) * 1.0 /
len(self.runs)) < fraction_needed_selected:
continue
for p in m.getAllPeptides():
selected_pg = p.get_selected_peakgroup()
clustered_pg = p.getClusteredPeakgroups()
for pg in clustered_pg:
selected_pgs.append(pg)
selected_ids_dict = dict([(pg.get_feature_id(), pg)
for pg in selected_pgs])
# 2. Write out the (selected) ids
if len(ids_outfile) > 0:
fh = open(ids_outfile, "w")
id_writer = csv.writer(fh, delimiter="\t")
for pg in selected_pgs:
id_writer.writerow([pg.get_feature_id()])
fh.close()
del id_writer
# 3. Write out the matrix outfile
if len(matrix_outfile) > 0:
write_out_matrix_file(matrix_outfile,
self.runs,
multipeptides,
fraction_needed_selected,
style=options.matrix_output_method,
aligner_mscore_treshold=options.fdr_cutoff)
# 4. Write out the full outfile
if len(outfile) > 0 and options.readmethod == "full":
# write out the complete original files
writer = csv.writer(open(outfile, "w"), delimiter="\t")
header_first = self.runs[0].header
for run in self.runs:
assert header_first == run.header
header_first += ["align_runid", "align_origfilename"]
writer.writerow(header_first)
for m in multipeptides:
selected_peakgroups = m.get_selected_peakgroups()
if (len(selected_peakgroups) * 1.0 /
len(self.runs)) < fraction_needed_selected:
continue
for p in m.get_peptides():
selected_pg = p.get_selected_peakgroup()
if selected_pg is None:
continue
row_to_write = selected_pg.row
row_to_write += [
selected_pg.run.get_id(), selected_pg.run.orig_filename
]
# Replace run_id with the aligned id (align_runid) ->
# otherwise the run_id is not guaranteed to be unique
row_to_write[header_dict["run_id"]] = selected_ids_dict[
f_id].peptide.run.get_id()
writer.writerow(row_to_write)
elif len(outfile) > 0 and file_format in [
"openswath", "peakview_preprocess"
]:
name_of_id_col_map = {
"openswath": "id",
"peakview_preprocess": "preprocess_id"
}
name_of_trgr_col_map = {
"openswath": "transition_group_id",
"peakview_preprocess": "Pep Index"
}
name_of_id_col = name_of_id_col_map[file_format]
name_of_trgr_col = name_of_trgr_col_map[file_format]
# Only in openswath we have the ID and can go back to the original file.
# We can write out the complete original files.
writer = csv.writer(open(outfile, "w"), delimiter="\t")
header_first = self.runs[0].header
for run in self.runs:
assert header_first == run.header
header_first += [
"align_runid", "align_origfilename", "align_clusterid"
]
writer.writerow(header_first)
for file_nr, f in enumerate(infiles):
header_dict = {}
if f.endswith('.gz'):
import gzip
filehandler = gzip.open(f, 'rb')
else:
filehandler = open(f)
reader = csv.reader(filehandler, delimiter="\t")
header = reader.next()
for i, n in enumerate(header):
header_dict[n] = i
for row in reader:
f_id = row[header_dict[name_of_id_col]]
if selected_ids_dict.has_key(f_id):
# Check the "id" and "transition_group_id" field.
# Unfortunately the id can be non-unique, there we check both.
trgroup_id = selected_ids_dict[f_id].peptide.get_id()
unique_peptide_id = row[header_dict[name_of_trgr_col]]
if unique_peptide_id == trgroup_id:
row_to_write = row
row_to_write += [
selected_ids_dict[f_id].peptide.run.get_id(),
f, selected_ids_dict[f_id].get_cluster_id()
]
# Replace run_id with the aligned id (align_runid) ->
# otherwise the run_id is not guaranteed to be unique
if file_format == "openswath":
row_to_write[
header_dict["run_id"]] = selected_ids_dict[
f_id].peptide.run.get_id()
writer.writerow(row_to_write)
# 5. Write out the .tr transformation files
if writeTrafoFiles:
self._write_trafo_files()
# 6. Write out the YAML file
if len(yaml_outfile) > 0:
import yaml
myYaml = {
"Commandline": sys.argv,
"RawData": [],
"PeakGroupData": [outfile],
"ReferenceRun":
self.transformation_collection.getReferenceRunID(),
"FeatureAlignment": {
"RawInputParameters": options.__dict__,
"Parameters": {}
},
"Parameters": {}
}
myYaml["Parameters"]["m_score_cutoff"] = float(
options.fdr_cutoff) # deprecated
myYaml["FeatureAlignment"]["Parameters"]["m_score_cutoff"] = float(
options.fdr_cutoff)
myYaml["FeatureAlignment"]["Parameters"]["fdr_cutoff"] = float(
options.fdr_cutoff)
myYaml["FeatureAlignment"]["Parameters"][
"aligned_fdr_cutoff"] = float(options.aligned_fdr_cutoff)
for current_run in self.runs:
current_id = current_run.get_id()
ref_id = self.transformation_collection.getReferenceRunID()
filename = self._getTrafoFilename(current_run, ref_id)
dirpath = os.path.dirname(current_run.orig_filename)
### Use real path (not very useful when moving data from one computer to another)
### filename = os.path.realpath(filename)
### dirpath = os.path.realpath(dirpath)
this = {
"id": current_id,
"directory": dirpath,
"trafo_file": filename
}
myYaml["RawData"].append(this)
open(yaml_outfile,
'w').write(yaml.dump({"AlignedSwathRuns": myYaml}))
def _read_trafo(self, trafo_filenames):
# Read the transformations
transformation_collection_ = TransformationCollection()
for filename in [d["trafo_file"] for d in trafo_filenames]:
transformation_collection_.readTransformationData(filename)
transformation_collection_.initialize_from_data(reverse=True)
class Experiment(MRExperiment):
"""
An Experiment is a container for multiple experimental runs - some of which may contain the same precursors.
"""
def __init__(self):
super(Experiment, self).__init__()
self.transformation_collection = TransformationCollection()
def estimate_real_fdr(self, multipeptides, fraction_needed_selected):
class DecoyStats(object):
def __init__(self):
self.est_real_fdr = 0.0
self.nr_decoys = 0
self.nr_targets = 0
self.decoy_pcnt = 0.0
self.est_real_fdr = 0.0
d = DecoyStats()
precursors_to_be_used = [m for m in multipeptides if m.more_than_fraction_selected(fraction_needed_selected)]
# count the decoys
d.nr_decoys = sum([len(prec.get_selected_peakgroups()) for prec in precursors_to_be_used
if prec.find_best_peptide_pg().peptide.get_decoy()])
d.nr_targets = sum([len(prec.get_selected_peakgroups()) for prec in precursors_to_be_used
if not prec.find_best_peptide_pg().peptide.get_decoy()])
# estimate the real fdr by calculating the decoy ratio and dividing it
# by the decoy ration obtained at @fdr_cutoff => which gives us the
# decoy in/decrease realtive to fdr_cutoff. To calculate the absolute
# value, we multiply by fdr_cutoff again (which was used to obtain the
# original estimated decoy percentage).
if self.estimated_decoy_pcnt is None: return d
if (d.nr_targets + d.nr_decoys) == 0: return d
d.decoy_pcnt = (d.nr_decoys * 100.0 / (d.nr_targets + d.nr_decoys) )
d.est_real_fdr = d.decoy_pcnt / self.estimated_decoy_pcnt * self.initial_fdr_cutoff
return d
def print_stats(self, multipeptides, fdr_cutoff, fraction_present, min_nrruns):
alignment = AlignmentStatistics()
alignment.count(multipeptides, fdr_cutoff, self.runs)
# Count presence in all runs (before alignment)
precursors_in_all_runs_wo_align = len([1 for m in multipeptides if m.all_above_cutoff(fdr_cutoff) and not m.get_decoy()])
proteins_in_all_runs_wo_align_target = len(set([m.find_best_peptide_pg().peptide.protein_name for m in multipeptides
if m.all_above_cutoff(fdr_cutoff) and
not m.find_best_peptide_pg().peptide.get_decoy()]))
peptides_in_all_runs_wo_align_target = len(set([m.find_best_peptide_pg().peptide.sequence for m in multipeptides
if m.all_above_cutoff(fdr_cutoff) and
not m.find_best_peptide_pg().peptide.get_decoy()]))
# Count presence in all runs (before alignment)
precursors_in_all_runs = [m for m in multipeptides if m.all_selected()]
nr_peptides_target = len(set([prec.find_best_peptide_pg().peptide.sequence for prec in precursors_in_all_runs
if not prec.find_best_peptide_pg().peptide.get_decoy()]))
nr_proteins_target = len(set([prec.find_best_peptide_pg().peptide.protein_name for prec in precursors_in_all_runs
if not prec.find_best_peptide_pg().peptide.get_decoy()]))
nr_precursors_in_all = len([1 for m in multipeptides if m.all_selected() and not m.get_decoy()])
max_pg = alignment.nr_good_precursors * len(self.runs)
dstats = self.estimate_real_fdr(multipeptides, fraction_present)
dstats_all = self.estimate_real_fdr(multipeptides, 1.0)
# Get single/multiple hits stats
from itertools import groupby
precursors_quantified = [m for m in multipeptides if len(m.get_selected_peakgroups()) > 0]
target_quant_protein_list = [ prec.find_best_peptide_pg().peptide.protein_name for prec in precursors_quantified
if not prec.find_best_peptide_pg().peptide.get_decoy()]
target_quant_protein_list.sort()
nr_sh_target_proteins = sum( [len(list(group)) == 1 for key, group in groupby(target_quant_protein_list)] )
nr_mh_target_proteins = sum( [len(list(group)) > 1 for key, group in groupby(target_quant_protein_list)] )
### Store for later (yaml output)
alignment.nr_ambiguous = self.nr_ambiguous
alignment.nr_multiple_align = self.nr_multiple_align
alignment.precursors_in_all_runs_wo_align = precursors_in_all_runs_wo_align
alignment.peptides_in_all_runs_wo_align_target = peptides_in_all_runs_wo_align_target
alignment.proteins_in_all_runs_wo_align_target = proteins_in_all_runs_wo_align_target
alignment.nr_precursors_in_all = nr_precursors_in_all
alignment.nr_peptides_target = nr_peptides_target
alignment.nr_proteins_target = nr_proteins_target
#
###########################################################################
#
print("="*75)
print("="*75)
print("Total we have", len(self.runs), "runs with", alignment.nr_good_precursors,
"peakgroups quantified in at least %s run(s) below m_score (q-value) %0.4f %%" % (min_nrruns, fdr_cutoff*100) + ", " +
"giving maximally nr peakgroups", max_pg)
print("We were able to quantify", alignment.nr_quantified, "/", max_pg, "peakgroups of which we aligned",
alignment.nr_aligned)
print(" The order of", alignment.nr_changed, "peakgroups was changed,", max_pg - alignment.nr_quantified,
"could not be aligned and %s were removed. Ambigous cases: %s, multiple suitable peakgroups: %s" % (
alignment.nr_removed, self.nr_ambiguous, self.nr_multiple_align))
print("We were able to quantify %s / %s precursors in %s runs, and %s in all runs (up from %s before alignment)" % (
alignment.nr_quant_precursors, alignment.nr_good_precursors, min_nrruns, nr_precursors_in_all, precursors_in_all_runs_wo_align))
print("We were able to quantify %s / %s peptides in %s runs, and %s in all runs (up from %s before alignment)" % (
len(alignment.quant_peptides), len(alignment.good_peptides), min_nrruns, nr_peptides_target, peptides_in_all_runs_wo_align_target))
print("We were able to quantify %s / %s proteins in %s runs, and %s in all runs (up from %s before alignment)" % (
len(alignment.quant_proteins), len(alignment.good_proteins), min_nrruns, nr_proteins_target, proteins_in_all_runs_wo_align_target))
print("Of these %s proteins, %s were multiple hits and %s were single hits." % (len(alignment.quant_proteins), nr_mh_target_proteins, nr_sh_target_proteins))
# Get decoy estimates
decoy_precursors = len([1 for m in multipeptides if len(m.get_selected_peakgroups()) > 0 and m.find_best_peptide_pg().peptide.get_decoy()])
if len(precursors_in_all_runs) > 0:
print("Decoy percentage of peakgroups that are fully aligned %0.4f %% (%s out of %s) which roughly corresponds to a peakgroup FDR of %s %%" % (
dstats_all.decoy_pcnt, dstats_all.nr_decoys, dstats_all.nr_decoys + dstats_all.nr_targets, dstats_all.est_real_fdr*100))
print("Decoy percentage of peakgroups that are partially aligned %0.4f %% (%s out of %s) which roughly corresponds to a peakgroup FDR of %s %%" % (
dstats.decoy_pcnt, dstats.nr_decoys, dstats.nr_decoys + dstats.nr_targets, dstats.est_real_fdr*100))
print("There were", decoy_precursors, "decoy precursors identified out of", \
alignment.nr_quant_precursors + decoy_precursors, "precursors which is %0.4f %%" % (
decoy_precursors * 100.0 / (alignment.nr_quant_precursors + decoy_precursors)))
return alignment
def _getTrafoFilename(self, current_run, ref_id):
current_id = current_run.get_id()
input_basename = os.path.basename(current_run.orig_filename)
fn = os.path.splitext(input_basename)[0]
dirname = os.path.dirname(current_run.orig_filename)
filename = os.path.join(dirname, "%s-%s-%s.tr" % (fn, current_id, ref_id) )
return filename
def _write_trafo_files(self):
# Print out trafo data
trafo_fnames = []
for current_run in self.runs:
current_id = current_run.get_id()
ref_id = self.transformation_collection.getReferenceRunID()
filename = self._getTrafoFilename(current_run, ref_id)
trafo_fnames.append(filename)
self.transformation_collection.writeTransformationData(filename, current_id, ref_id)
self.transformation_collection.readTransformationData(filename)
def write_to_file(self, multipeptides, options, alignment, tree=None, writeTrafoFiles=True):
infiles = options.infiles
outfile = options.outfile
matrix_outfile = options.matrix_outfile
yaml_outfile = options.yaml_outfile
ids_outfile = options.ids_outfile
fraction_needed_selected = options.min_frac_selected
file_format = options.file_format
# 1. Collect ids of selected features
selected_pgs = []
for m in multipeptides:
selected_peakgroups = m.get_selected_peakgroups()
if (len(selected_peakgroups)*1.0 / len(self.runs)) < fraction_needed_selected:
continue
for p in m.getAllPeptides():
selected_pg = p.get_selected_peakgroup()
clustered_pg = p.getClusteredPeakgroups()
for pg in clustered_pg:
selected_pgs.append(pg)
selected_ids_dict = dict( [ (pg.get_feature_id(), pg) for pg in selected_pgs] )
# 2. Write out the (selected) ids
if len(ids_outfile) > 0:
fh = open(ids_outfile, "w")
id_writer = csv.writer(fh, delimiter="\t")
for pg in sorted(selected_pgs):
id_writer.writerow([pg.get_feature_id()])
fh.close()
del id_writer
# 3. Write out the matrix outfile
if len(matrix_outfile) > 0:
write_out_matrix_file(matrix_outfile, self.runs, multipeptides,
fraction_needed_selected,
style=options.matrix_output_method,
aligner_mscore_treshold=options.fdr_cutoff)
# 4. Write out the full outfile
if len(outfile) > 0 and options.readmethod == "full":
# write out the complete original files
writer = csv.writer(open(outfile, "w"), delimiter="\t")
header_first = self.runs[0].header
for run in self.runs:
assert header_first == run.header
header_first += ["align_runid", "align_origfilename"]
writer.writerow(header_first)
for m in multipeptides:
selected_peakgroups = m.get_selected_peakgroups()
if (len(selected_peakgroups)*1.0 / len(self.runs)) < fraction_needed_selected:
continue
for p in m.get_peptides():
selected_pg = p.get_selected_peakgroup()
if selected_pg is None:
continue
row_to_write = selected_pg.row
row_to_write += [selected_pg.run.get_id(), selected_pg.run.orig_filename]
# Replace run_id with the aligned id (align_runid) ->
# otherwise the run_id is not guaranteed to be unique
row_to_write[ header_dict["run_id"]] = selected_ids_dict[f_id].peptide.run.get_id()
writer.writerow(row_to_write)
elif len(outfile) > 0 and file_format in ["openswath", "peakview_preprocess"]:
name_of_id_col_map = { "openswath" : "id" , "peakview_preprocess" : "preprocess_id"}
name_of_trgr_col_map = { "openswath" : "transition_group_id" , "peakview_preprocess" : "Pep Index"}
name_of_id_col = name_of_id_col_map[file_format]
name_of_trgr_col = name_of_trgr_col_map[file_format]
# Only in openswath we have the ID and can go back to the original file.
# We can write out the complete original files.
writer = csv.writer(open(outfile, "w"), delimiter="\t")
header_first = self.runs[0].header
for run in self.runs:
assert header_first == run.header
header_first += ["align_runid", "align_origfilename", "align_clusterid"]
writer.writerow(header_first)
for file_nr, f in enumerate(infiles):
header_dict = {}
if f.endswith('.gz'):
import gzip
filehandler = gzip.open(f,'rb')
else:
filehandler = open(f)
reader = csv.reader(filehandler, delimiter="\t")
header = next(reader)
for i,n in enumerate(header):
header_dict[n] = i
for row in reader:
f_id = row[ header_dict[name_of_id_col]]
if f_id in selected_ids_dict:
# Check the "id" and "transition_group_id" field.
# Unfortunately the id can be non-unique, there we check both.
trgroup_id = selected_ids_dict[f_id].peptide.get_id()
unique_peptide_id = row[ header_dict[name_of_trgr_col]]
if unique_peptide_id == trgroup_id:
row_to_write = row
row_to_write += [selected_ids_dict[f_id].peptide.run.get_id(), f, selected_ids_dict[f_id].get_cluster_id()]
# Replace run_id with the aligned id (align_runid) ->
# otherwise the run_id is not guaranteed to be unique
if file_format == "openswath" :
row_to_write[ header_dict["run_id"]] = selected_ids_dict[f_id].peptide.run.get_id()
writer.writerow(row_to_write)
# 5. Write out the .tr transformation files
if writeTrafoFiles:
self._write_trafo_files()
# 6. Write out the YAML file
if len(yaml_outfile) > 0:
import yaml
myYaml = {"Commandline" : sys.argv,
"RawData" : [], "PeakGroupData" : [ outfile ],
"ReferenceRun" : self.transformation_collection.getReferenceRunID(),
"FeatureAlignment" :
{
"RawInputParameters" : options.__dict__,
"Parameters" : {}
},
"Parameters" : {}
}
myYaml["Output"] = {}
myYaml["Output"]["Tree"] = {}
if tree is not None:
myYaml["Output"]["Tree"]["Raw"] = [list(t) for t in tree]
tree_mapped = [ [self.runs[a].get_id(), self.runs[b].get_id()] for a,b in tree]
myYaml["Output"]["Tree"]["Mapped"] = tree_mapped
tree_mapped = [ [self.runs[a].get_openswath_filename(), self.runs[b].get_openswath_filename()] for a,b in tree]
myYaml["Output"]["Tree"]["MappedFile"] = tree_mapped
tree_mapped = [ [self.runs[a].get_openswath_filename(), self.runs[b].get_openswath_filename()] for a,b in tree]
myYaml["Output"]["Tree"]["MappedFile"] = tree_mapped
tree_mapped = [ [self.runs[a].get_original_filename(), self.runs[b].get_original_filename()] for a,b in tree]
myYaml["Output"]["Tree"]["MappedFileInput"] = tree_mapped
myYaml["Output"]["Quantification"] = alignment.to_yaml()
myYaml["Parameters"]["m_score_cutoff"] = float(options.fdr_cutoff) # deprecated
myYaml["FeatureAlignment"]["Parameters"]["m_score_cutoff"] = float(options.fdr_cutoff)
myYaml["FeatureAlignment"]["Parameters"]["fdr_cutoff"] = float(options.fdr_cutoff)
myYaml["FeatureAlignment"]["Parameters"]["aligned_fdr_cutoff"] = float(options.aligned_fdr_cutoff)
for current_run in self.runs:
current_id = current_run.get_id()
ref_id = self.transformation_collection.getReferenceRunID()
filename = self._getTrafoFilename(current_run, ref_id)
dirpath = os.path.dirname(current_run.orig_filename)
### Use real path (not very useful when moving data from one computer to another)
### filename = os.path.realpath(filename)
### dirpath = os.path.realpath(dirpath)
this = {"id" : current_id, "directory" : dirpath, "trafo_file" : filename}
myYaml["RawData"].append(this)
open(yaml_outfile, 'w').write(yaml.dump({"AlignedSwathRuns" : myYaml}))
def _read_trafo(self, trafo_filenames):
# Read the transformations
transformation_collection_ = TransformationCollection()
for filename in [d["trafo_file"] for d in trafo_filenames]:
transformation_collection_.readTransformationData(filename)
transformation_collection_.initialize_from_data(reverse=True)
class Experiment(MRExperiment):
"""
An Experiment is a container for multiple experimental runs - some of which may contain the same precursors.
"""
def __init__(self):
super(Experiment, self).__init__()
self.transformation_collection = TransformationCollection()
def get_max_pg(self):
return len(self.runs)*len(self.union_transition_groups_set)
def estimate_real_fdr(self, multipeptides, fraction_needed_selected):
class DecoyStats(object):
def __init__(self):
self.est_real_fdr = 0.0
self.nr_decoys = 0
self.nr_targets = 0
self.decoy_pcnt = 0.0
self.est_real_fdr = 0.0
d = DecoyStats()
precursors_to_be_used = [m for m in multipeptides if m.more_than_fraction_selected(fraction_needed_selected)]
# count the decoys
d.nr_decoys = sum([len(prec.get_selected_peakgroups()) for prec in precursors_to_be_used
if prec.find_best_peptide_pg().peptide.get_decoy()])
d.nr_targets = sum([len(prec.get_selected_peakgroups()) for prec in precursors_to_be_used
if not prec.find_best_peptide_pg().peptide.get_decoy()])
# estimate the real fdr by calculating the decoy ratio and dividing it
# by the decoy ration obtained at @fdr_cutoff => which gives us the
# decoy in/decrease realtive to fdr_cutoff. To calculate the absolute
# value, we multiply by fdr_cutoff again (which was used to obtain the
# original estimated decoy percentage).
if self.estimated_decoy_pcnt is None: return d
if (d.nr_targets + d.nr_decoys) == 0: return d
d.decoy_pcnt = (d.nr_decoys * 100.0 / (d.nr_targets + d.nr_decoys) )
d.est_real_fdr = d.decoy_pcnt / self.estimated_decoy_pcnt * self.initial_fdr_cutoff
return d
def print_stats(self, multipeptides, alignment, outlier_detection, fdr_cutoff, fraction_present, min_nrruns):
nr_precursors_total = len(self.union_transition_groups_set)
# Do statistics and print out
in_all_runs_wo_align = len([1 for m in multipeptides if m.all_above_cutoff(fdr_cutoff) and not m.get_decoy()])
proteins_in_all_runs_wo_align = len(set([m.find_best_peptide_pg().peptide.protein_name for m in multipeptides if m.all_above_cutoff(fdr_cutoff)]))
proteins_in_all_runs_wo_align_target = len(set([m.find_best_peptide_pg().peptide.protein_name for m in multipeptides if m.all_above_cutoff(fdr_cutoff) and not m.find_best_peptide_pg().peptide.get_decoy()]))
nr_all_proteins = len(set([m.find_best_peptide_pg().peptide.protein_name for m in multipeptides if not m.find_best_peptide_pg().peptide.get_decoy()]))
nr_all_peptides = len(set([m.find_best_peptide_pg().peptide.sequence for m in multipeptides if not m.find_best_peptide_pg().peptide.get_decoy()]))
peptides_in_all_runs_wo_align_target = len(set([m.find_best_peptide_pg().peptide.sequence for m in multipeptides if m.all_above_cutoff(fdr_cutoff) and not m.find_best_peptide_pg().peptide.get_decoy()]))
print("Present targets in all runs", in_all_runs_wo_align)
precursors_in_all_runs = [m for m in multipeptides if m.all_selected()]
precursors_quantified = [m for m in multipeptides if len(m.get_selected_peakgroups()) > 0]
# precursors_in_all_runs = [m for m in multipeptides if m.all_selected()]
# precursors_in_all_runs = [m for m in multipeptides if m.all_selected()]
nr_decoys = len([1 for prec in precursors_in_all_runs if prec.find_best_peptide_pg().peptide.get_decoy()])
decoy_precursors = len([1 for m in multipeptides if len(m.get_selected_peakgroups()) > 0 and m.find_best_peptide_pg().peptide.get_decoy()])
nr_peptides = len(set([prec.find_best_peptide_pg().peptide.sequence for prec in precursors_in_all_runs]))
nr_proteins = len(set([prec.find_best_peptide_pg().peptide.protein_name for prec in precursors_in_all_runs]))
nr_peptides_target = len(set([prec.find_best_peptide_pg().peptide.sequence for prec in precursors_in_all_runs if not prec.find_best_peptide_pg().peptide.get_decoy()]))
nr_proteins_target = len(set([prec.find_best_peptide_pg().peptide.protein_name for prec in precursors_in_all_runs if not prec.find_best_peptide_pg().peptide.get_decoy()]))
nr_precursors_to_quant = len(set([ prec for prec in precursors_quantified if not prec.find_best_peptide_pg().peptide.get_decoy()]))
nr_proteins_to_quant = len(set([ prec.find_best_peptide_pg().peptide.protein_name for prec in precursors_quantified if not prec.find_best_peptide_pg().peptide.get_decoy()]))
nr_peptides_to_quant = len(set([ prec.find_best_peptide_pg().peptide.sequence for prec in precursors_quantified if not prec.find_best_peptide_pg().peptide.get_decoy()]))
nr_precursors_in_all = len([1 for m in multipeptides if m.all_selected() and not m.get_decoy()])
max_pg = self.get_max_pg()
dstats = self.estimate_real_fdr(multipeptides, fraction_present)
dstats_all = self.estimate_real_fdr(multipeptides, 1.0)
print("="*75)
print("="*75)
print("Total we have", len(self.runs), "runs with", len(self.union_transition_groups_set),\
"peakgroups quantified in at least %s run(s) above FDR %0.4f %%" % (min_nrruns, fdr_cutoff*100) + ", " + \
"giving maximally nr peakgroups", max_pg)
print("We were able to quantify", alignment.nr_quantified, "/", max_pg, "peakgroups of which we aligned", \
alignment.nr_aligned, "and changed order of", alignment.nr_changed, "and could not align", alignment.could_not_align)
print("We were able to quantify %s / %s precursors in %s runs, and %s in all runs (up from %s before alignment)" % (
nr_precursors_to_quant, nr_precursors_total, min_nrruns, nr_precursors_in_all, in_all_runs_wo_align))
print("We were able to quantify %s / %s peptides in %s runs, and %s in all runs (up from %s before alignment)" % (
nr_peptides_to_quant, nr_all_peptides, min_nrruns, nr_peptides_target, peptides_in_all_runs_wo_align_target))
print("We were able to quantify %s / %s proteins in %s runs, and %s in all runs (up from %s before alignment)" % (
nr_proteins_to_quant, nr_all_proteins, min_nrruns, nr_proteins_target, proteins_in_all_runs_wo_align_target))
# print "quant proteins", nr_proteins_to_quant
# Get decoy estimates
if len(precursors_in_all_runs) > 0:
print("Decoy percentage of peakgroups that are fully aligned %0.4f %% (%s out of %s) which roughly corresponds to a peakgroup FDR of %s %%" % (
dstats_all.decoy_pcnt, dstats_all.nr_decoys, dstats_all.nr_decoys + dstats_all.nr_targets, dstats_all.est_real_fdr*100))
print("Decoy percentage of peakgroups that are partially aligned %1.4f %% (%s out of %s) which roughly corresponds to a peakgroup FDR of %s %%" % (
dstats.decoy_pcnt, dstats.nr_decoys, dstats.nr_decoys + dstats.nr_targets, dstats.est_real_fdr*100))
print("There were", decoy_precursors, "decoy precursors identified out of", nr_precursors_to_quant + decoy_precursors, "precursors which is %0.4f %%" % (decoy_precursors *100.0 / (nr_precursors_to_quant + decoy_precursors)))
if outlier_detection is not None:
print("Outliers:", outlier_detection.nr_outliers, "outliers in", len(multipeptides), "peptides or", outlier_detection.outlier_pg, "peakgroups out of", alignment.nr_quantified, "changed", outlier_detection.outliers_changed)
def write_to_file(self, multipeptides, options):
infiles = options.infiles
outfile = options.outfile
matrix_outfile = options.matrix_outfile
matrix_excelfile = options.matix_excel
yaml_outfile = options.yaml_outfile
ids_outfile = options.ids_outfile
fraction_needed_selected = options.min_frac_selected
file_format = options.file_format
selected_pgs = []
for m in multipeptides:
selected_peakgroups = m.get_selected_peakgroups()
if (len(selected_peakgroups)*1.0 / len(self.runs) < fraction_needed_selected) : continue
for p in m.get_peptides():
selected_pg = p.get_selected_peakgroup()
if selected_pg is None: continue
selected_pgs.append(selected_pg)
selected_ids_dict = dict( [ (pg.get_feature_id(), pg) for pg in selected_pgs] )
if len(ids_outfile) > 0:
fh = open(ids_outfile, "w")
id_writer = csv.writer(fh, delimiter="\t")
for pg in selected_pgs:
id_writer.writerow([pg.get_feature_id()])
fh.close()
del id_writer
if len(matrix_outfile) > 0:
write_out_matrix_file(matrix_outfile, self.runs, multipeptides, fraction_needed_selected)
if len(outfile) > 0 and options.readmethod == "full":
# write out the complete original files
writer = csv.writer(open(outfile, "w"), delimiter="\t")
header_first = self.runs[0].header
for run in self.runs:
assert header_first == run.header
header_first += ["align_runid", "align_origfilename"]
writer.writerow(header_first)
for m in multipeptides:
selected_peakgroups = m.get_selected_peakgroups()
if (len(selected_peakgroups)*1.0 / len(self.runs) < fraction_needed_selected) : continue
for p in m.get_peptides():
selected_pg = p.get_selected_peakgroup()
if selected_pg is None: continue
row_to_write = selected_pg.row
row_to_write += [selected_pg.run.get_id(), selected_pg.run.orig_filename]
writer.writerow(row_to_write)
elif len(outfile) > 0 and file_format == "openswath":
# only in openswath we have the ID and can go back to the original file ...
# write out the complete original files
writer = csv.writer(open(outfile, "w"), delimiter="\t")
header_first = self.runs[0].header
for run in self.runs:
assert header_first == run.header
header_first += ["align_runid", "align_origfilename"]
writer.writerow(header_first)
for file_nr, f in enumerate(infiles):
header_dict = {}
reader = csv.reader(open(f), delimiter="\t")
header = next(reader)
for i,n in enumerate(header):
header_dict[n] = i
for row in reader:
f_id = row[ header_dict["id"]]
if f_id in selected_ids_dict:
# Check the "id" and "transition_group_id" field.
# Unfortunately the id can be non-unique, there we check both.
trgroup_id = selected_ids_dict[f_id].peptide.get_id()
unique_peptide_id = row[ header_dict["transition_group_id"]]
if unique_peptide_id == trgroup_id:
row_to_write = row
row_to_write += [selected_ids_dict[f_id].peptide.run.get_id(), f]
writer.writerow(row_to_write)
# Print out trafo data
trafo_fnames = []
for current_run in self.runs:
current_id = current_run.get_id()
ref_id = self.transformation_collection.getReferenceRunID()
filename = os.path.join(os.path.dirname(current_run.orig_filename), "transformation-%s-%s.tr" % (current_id, ref_id) )
trafo_fnames.append(filename)
self.transformation_collection.writeTransformationData(filename, current_id, ref_id)
self.transformation_collection.readTransformationData(filename)
if len(yaml_outfile) > 0:
import yaml
myYaml = {"RawData" : [], "PeakGroupData" : [ outfile ],
"ReferenceRun" : self.transformation_collection.getReferenceRunID() }
for current_run in self.runs:
current_id = current_run.get_id()
ref_id = self.transformation_collection.getReferenceRunID()
filename = os.path.join(os.path.dirname(current_run.orig_filename), "transformation-%s-%s.tr" % (current_id, ref_id) )
dirpath = os.path.realpath(os.path.dirname(current_run.orig_filename))
this = {"id" : current_id, "directory" : dirpath, "trafo_file" : os.path.realpath(filename)}
myYaml["RawData"].append(this)
open(yaml_outfile, 'w').write(yaml.dump({"AlignedSwathRuns" : myYaml}))
return trafo_fnames
class Experiment(MRExperiment):
"""
An Experiment is a container for multiple experimental runs - some of which may contain the same precursors.
"""
def __init__(self):
super(Experiment, self).__init__()
self.transformation_collection = TransformationCollection()
def get_max_pg(self):
return len(self.runs) * len(self.union_transition_groups_set)
def estimate_real_fdr(self, multipeptides, fraction_needed_selected):
class DecoyStats(object):
def __init__(self):
self.est_real_fdr = 0.0
self.nr_decoys = 0
self.nr_targets = 0
self.decoy_pcnt = 0.0
self.est_real_fdr = 0.0
d = DecoyStats()
precursors_to_be_used = [
m for m in multipeptides
if m.more_than_fraction_selected(fraction_needed_selected)
]
# count the decoys
d.nr_decoys = sum([
len(prec.get_selected_peakgroups())
for prec in precursors_to_be_used
if prec.find_best_peptide_pg().peptide.get_decoy()
])
d.nr_targets = sum([
len(prec.get_selected_peakgroups())
for prec in precursors_to_be_used
if not prec.find_best_peptide_pg().peptide.get_decoy()
])
# estimate the real fdr by calculating the decoy ratio and dividing it
# by the decoy ration obtained at @fdr_cutoff => which gives us the
# decoy in/decrease realtive to fdr_cutoff. To calculate the absolute
# value, we multiply by fdr_cutoff again (which was used to obtain the
# original estimated decoy percentage).
if self.estimated_decoy_pcnt is None: return d
if (d.nr_targets + d.nr_decoys) == 0: return d
d.decoy_pcnt = (d.nr_decoys * 100.0 / (d.nr_targets + d.nr_decoys))
d.est_real_fdr = d.decoy_pcnt / self.estimated_decoy_pcnt * self.initial_fdr_cutoff
return d
def print_stats(self, multipeptides, alignment, outlier_detection,
fdr_cutoff, fraction_present, min_nrruns):
nr_precursors_total = len(self.union_transition_groups_set)
# Do statistics and print out
in_all_runs_wo_align = len([
1 for m in multipeptides
if m.all_above_cutoff(fdr_cutoff) and not m.get_decoy()
])
proteins_in_all_runs_wo_align = len(
set([
m.find_best_peptide_pg().peptide.protein_name
for m in multipeptides if m.all_above_cutoff(fdr_cutoff)
]))
proteins_in_all_runs_wo_align_target = len(
set([
m.find_best_peptide_pg().peptide.protein_name
for m in multipeptides if m.all_above_cutoff(fdr_cutoff)
and not m.find_best_peptide_pg().peptide.get_decoy()
]))
nr_all_proteins = len(
set([
m.find_best_peptide_pg().peptide.protein_name
for m in multipeptides
if not m.find_best_peptide_pg().peptide.get_decoy()
]))
nr_all_peptides = len(
set([
m.find_best_peptide_pg().peptide.sequence
for m in multipeptides
if not m.find_best_peptide_pg().peptide.get_decoy()
]))
peptides_in_all_runs_wo_align_target = len(
set([
m.find_best_peptide_pg().peptide.sequence
for m in multipeptides if m.all_above_cutoff(fdr_cutoff)
and not m.find_best_peptide_pg().peptide.get_decoy()
]))
print("Present targets in all runs", in_all_runs_wo_align)
precursors_in_all_runs = [m for m in multipeptides if m.all_selected()]
precursors_quantified = [
m for m in multipeptides if len(m.get_selected_peakgroups()) > 0
]
# precursors_in_all_runs = [m for m in multipeptides if m.all_selected()]
# precursors_in_all_runs = [m for m in multipeptides if m.all_selected()]
nr_decoys = len([
1 for prec in precursors_in_all_runs
if prec.find_best_peptide_pg().peptide.get_decoy()
])
decoy_precursors = len([
1 for m in multipeptides if len(m.get_selected_peakgroups()) > 0
and m.find_best_peptide_pg().peptide.get_decoy()
])
nr_peptides = len(
set([
prec.find_best_peptide_pg().peptide.sequence
for prec in precursors_in_all_runs
]))
nr_proteins = len(
set([
prec.find_best_peptide_pg().peptide.protein_name
for prec in precursors_in_all_runs
]))
nr_peptides_target = len(
set([
prec.find_best_peptide_pg().peptide.sequence
for prec in precursors_in_all_runs
if not prec.find_best_peptide_pg().peptide.get_decoy()
]))
nr_proteins_target = len(
set([
prec.find_best_peptide_pg().peptide.protein_name
for prec in precursors_in_all_runs
if not prec.find_best_peptide_pg().peptide.get_decoy()
]))
nr_precursors_to_quant = len(
set([
prec for prec in precursors_quantified
if not prec.find_best_peptide_pg().peptide.get_decoy()
]))
nr_proteins_to_quant = len(
set([
prec.find_best_peptide_pg().peptide.protein_name
for prec in precursors_quantified
if not prec.find_best_peptide_pg().peptide.get_decoy()
]))
nr_peptides_to_quant = len(
set([
prec.find_best_peptide_pg().peptide.sequence
for prec in precursors_quantified
if not prec.find_best_peptide_pg().peptide.get_decoy()
]))
nr_precursors_in_all = len([
1 for m in multipeptides if m.all_selected() and not m.get_decoy()
])
max_pg = self.get_max_pg()
dstats = self.estimate_real_fdr(multipeptides, fraction_present)
dstats_all = self.estimate_real_fdr(multipeptides, 1.0)
print("=" * 75)
print("=" * 75)
print("Total we have", len(self.runs), "runs with", len(self.union_transition_groups_set),\
"peakgroups quantified in at least %s run(s) above FDR %0.4f %%" % (min_nrruns, fdr_cutoff*100) + ", " + \
"giving maximally nr peakgroups", max_pg)
print("We were able to quantify", alignment.nr_quantified, "/", max_pg, "peakgroups of which we aligned", \
alignment.nr_aligned, "and changed order of", alignment.nr_changed, "and could not align", alignment.could_not_align)
print(
"We were able to quantify %s / %s precursors in %s runs, and %s in all runs (up from %s before alignment)"
% (nr_precursors_to_quant, nr_precursors_total, min_nrruns,
nr_precursors_in_all, in_all_runs_wo_align))
print(
"We were able to quantify %s / %s peptides in %s runs, and %s in all runs (up from %s before alignment)"
% (nr_peptides_to_quant, nr_all_peptides, min_nrruns,
nr_peptides_target, peptides_in_all_runs_wo_align_target))
print(
"We were able to quantify %s / %s proteins in %s runs, and %s in all runs (up from %s before alignment)"
% (nr_proteins_to_quant, nr_all_proteins, min_nrruns,
nr_proteins_target, proteins_in_all_runs_wo_align_target))
# print "quant proteins", nr_proteins_to_quant
# Get decoy estimates
if len(precursors_in_all_runs) > 0:
print(
"Decoy percentage of peakgroups that are fully aligned %0.4f %% (%s out of %s) which roughly corresponds to a peakgroup FDR of %s %%"
% (dstats_all.decoy_pcnt, dstats_all.nr_decoys,
dstats_all.nr_decoys + dstats_all.nr_targets,
dstats_all.est_real_fdr * 100))
print(
"Decoy percentage of peakgroups that are partially aligned %1.4f %% (%s out of %s) which roughly corresponds to a peakgroup FDR of %s %%"
% (dstats.decoy_pcnt, dstats.nr_decoys, dstats.nr_decoys +
dstats.nr_targets, dstats.est_real_fdr * 100))
print(
"There were", decoy_precursors,
"decoy precursors identified out of",
nr_precursors_to_quant + decoy_precursors,
"precursors which is %0.4f %%" %
(decoy_precursors * 100.0 /
(nr_precursors_to_quant + decoy_precursors)))
if outlier_detection is not None:
print("Outliers:", outlier_detection.nr_outliers, "outliers in",
len(multipeptides), "peptides or",
outlier_detection.outlier_pg, "peakgroups out of",
alignment.nr_quantified, "changed",
outlier_detection.outliers_changed)
def write_to_file(self, multipeptides, options):
infiles = options.infiles
outfile = options.outfile
matrix_outfile = options.matrix_outfile
matrix_excelfile = options.matix_excel
yaml_outfile = options.yaml_outfile
ids_outfile = options.ids_outfile
fraction_needed_selected = options.min_frac_selected
file_format = options.file_format
selected_pgs = []
for m in multipeptides:
selected_peakgroups = m.get_selected_peakgroups()
if (len(selected_peakgroups) * 1.0 / len(self.runs) <
fraction_needed_selected):
continue
for p in m.get_peptides():
selected_pg = p.get_selected_peakgroup()
if selected_pg is None: continue
selected_pgs.append(selected_pg)
selected_ids_dict = dict([(pg.get_feature_id(), pg)
for pg in selected_pgs])
if len(ids_outfile) > 0:
fh = open(ids_outfile, "w")
id_writer = csv.writer(fh, delimiter="\t")
for pg in selected_pgs:
id_writer.writerow([pg.get_feature_id()])
fh.close()
del id_writer
if len(matrix_outfile) > 0:
write_out_matrix_file(matrix_outfile, self.runs, multipeptides,
fraction_needed_selected)
if len(outfile) > 0 and options.readmethod == "full":
# write out the complete original files
writer = csv.writer(open(outfile, "w"), delimiter="\t")
header_first = self.runs[0].header
for run in self.runs:
assert header_first == run.header
header_first += ["align_runid", "align_origfilename"]
writer.writerow(header_first)
for m in multipeptides:
selected_peakgroups = m.get_selected_peakgroups()
if (len(selected_peakgroups) * 1.0 / len(self.runs) <
fraction_needed_selected):
continue
for p in m.get_peptides():
selected_pg = p.get_selected_peakgroup()
if selected_pg is None: continue
row_to_write = selected_pg.row
row_to_write += [
selected_pg.run.get_id(), selected_pg.run.orig_filename
]
writer.writerow(row_to_write)
elif len(outfile) > 0 and file_format == "openswath":
# only in openswath we have the ID and can go back to the original file ...
# write out the complete original files
writer = csv.writer(open(outfile, "w"), delimiter="\t")
header_first = self.runs[0].header
for run in self.runs:
assert header_first == run.header
header_first += ["align_runid", "align_origfilename"]
writer.writerow(header_first)
for file_nr, f in enumerate(infiles):
header_dict = {}
reader = csv.reader(open(f), delimiter="\t")
header = next(reader)
for i, n in enumerate(header):
header_dict[n] = i
for row in reader:
f_id = row[header_dict["id"]]
if f_id in selected_ids_dict:
# Check the "id" and "transition_group_id" field.
# Unfortunately the id can be non-unique, there we check both.
trgroup_id = selected_ids_dict[f_id].peptide.get_id()
unique_peptide_id = row[
header_dict["transition_group_id"]]
if unique_peptide_id == trgroup_id:
row_to_write = row
row_to_write += [
selected_ids_dict[f_id].peptide.run.get_id(), f
]
writer.writerow(row_to_write)
# Print out trafo data
trafo_fnames = []
for current_run in self.runs:
current_id = current_run.get_id()
ref_id = self.transformation_collection.getReferenceRunID()
filename = os.path.join(
os.path.dirname(current_run.orig_filename),
"transformation-%s-%s.tr" % (current_id, ref_id))
trafo_fnames.append(filename)
self.transformation_collection.writeTransformationData(
filename, current_id, ref_id)
self.transformation_collection.readTransformationData(filename)
if len(yaml_outfile) > 0:
import yaml
myYaml = {
"RawData": [],
"PeakGroupData": [outfile],
"ReferenceRun":
self.transformation_collection.getReferenceRunID()
}
for current_run in self.runs:
current_id = current_run.get_id()
ref_id = self.transformation_collection.getReferenceRunID()
filename = os.path.join(
os.path.dirname(current_run.orig_filename),
"transformation-%s-%s.tr" % (current_id, ref_id))
dirpath = os.path.realpath(
os.path.dirname(current_run.orig_filename))
this = {
"id": current_id,
"directory": dirpath,
"trafo_file": os.path.realpath(filename)
}
myYaml["RawData"].append(this)
open(yaml_outfile,
'w').write(yaml.dump({"AlignedSwathRuns": myYaml}))
return trafo_fnames