& _pv, mspectrumcondition& _p, mscore& _m);
~SAXMzxmlHandler();
// -----------------------------------------------------------------------
// Overrides of SAXHandler functions
// -----------------------------------------------------------------------
/**
* Receive notification of the start of an element.
*
* By default, do nothing. Application writers may override this
* method in a subclass to take specific actions at the start of
* each element (such as allocating a new tree node or writing
* output to a file).
*/
void startElement(const XML_Char *el, const XML_Char **attr);
/**
* Receive notification of the end of an element.
*
* By default, do nothing. Application writers may override this
* method in a subclass to take specific actions at the end of
* each element (such as finalising a tree node or writing
* output to a file).
*/
void endElement(const XML_Char *el);
/**
* Receive notification of character data inside an element.
*
* By default, do nothing. Application writers may override this
* method to take specific actions for each chunk of character data
* (such as adding the data to a node or buffer, or printing it to
* a file).
*/
void characters(const XML_Char *s, int len);
private:
/**
* Handle data collected in the characters() function.
*/
void processData();
set m_sId;
private:
// Flags indicating parser is inside a particular tag.
bool m_bInMsLevel2;
bool m_bInPrecursorMz;
bool m_bInPeaks;
};
#endif //SAXMzxmlHandler_H
tandem-linux-13-09-01-1/src/mcleave.h 0000664 0001750 0001750 00000033014 11405712543 017207 0 ustar langella langella /*
Copyright (C) 2003 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
#ifndef MCLEAVE_H
#define MCLEAVE_H
// File version: 2006-03-10
/*
* mcleave is a specialty class meant to store information about protein cleavage specificity
* and rapidly test a peptide sequence to see if it is cleavable.
* NOTE: mcleave.h does not have a corresponding .cpp file
*/
class mcleave_single
{
public:
mcleave_single(void) {
strcpy(m_pNCleave,"KR");
strcpy(m_pCCleave,"P");
m_bN = true;
m_bC = false;
m_bNX = false;
m_bCX = false;
m_lType = 0;
}
virtual ~mcleave_single(void) { }
char m_pNCleave[32]; // residues that are valid cleavage sites (or invalid if m_bN = false)
char m_pCCleave[32]; // residues that are valid cleavage sites (or invalid if m_bC = false)
bool m_bN; // if true, all residues in m_pNCleave can be N-temrinal to a cleavable bond
bool m_bC; // if true, all residues in m_pNCleave can be C-temrinal to a cleavable bond
bool m_bCX;
bool m_bNX;
unsigned long m_lType;
string m_strCleave;
mcleave_single& operator=(const mcleave_single &rhs) {
strcpy(m_pNCleave,rhs.m_pNCleave);
strcpy(m_pCCleave,rhs.m_pCCleave);
m_bN = rhs.m_bN;
m_bC = rhs.m_bC;
m_bNX = rhs.m_bNX;
m_bCX = rhs.m_bCX;
m_lType = rhs.m_lType;
return *this;
}
/*
* load takes a string containing cleavage information and parses it
* these strings take the format:
* A|B, where A or B are expressions of the form [xyz] or {xyz}. if square brackets, only the single letter
* abbreviations in the brackets are valid at that position for a cleavage, and if french brackets, those
* single letter abbreviations are the only non-valid residues at that position. For example, trypsin
* can be represented by [KR]|{P}, i.e. cleave C-terminal to a K or R residue, except when followed by
* a P. The expression [X]|[X] means cleave at all residues.
* NOTE: use of upper case characters is required for amino acid abbreviations
*/
bool load(string &_s) {
m_strCleave = _s;
if(_s == "[X]|[X]") {
m_lType = 0x01;
return true;
}
else if(_s == "[KR]|{P}" || _s == "[RK]|{P}") {
m_lType = 0x02;
return true;
}
m_lType = 0x04;
size_t a = 0;
size_t b = 0;
if(_s[a] == '[') {
m_bN = true;
a++;
b = 0;
while(a < _s.size() && _s[a] != ']') {
m_pNCleave[b] = _s[a];
a++;
b++;
}
m_pNCleave[b] = '\0';
a = _s.find('|');
if(a == _s.npos)
return false;
a++;
if(_s[a] == '{') {
m_bC = false;
a++;
b = 0;
while(a < _s.size() && _s[a] != '}') {
m_pCCleave[b] = _s[a];
a++;
b++;
}
m_pCCleave[b] = '\0';
}
else if(_s[a] == '[') {
m_bC = true;
a++;
b = 0;
while(a < _s.size() && _s[a] != ']') {
m_pCCleave[b] = _s[a];
a++;
b++;
}
m_pCCleave[b] = '\0';
}
}
else if(_s[a] == '{') {
m_bN = false;
a++;
b = 0;
while(a < _s.size() && _s[a] != '}') {
m_pNCleave[b] = _s[a];
a++;
b++;
}
m_pNCleave[b] = '\0';
a = _s.find('|');
if(a == _s.npos)
return false;
a++;
if(_s[a] == '{') {
m_bC = false;
a++;
b = 0;
while(a < _s.size() && _s[a] != '}') {
m_pCCleave[b] = _s[a];
a++;
b++;
}
m_pCCleave[b] = '\0';
}
else if(_s[a] == '[') {
m_bC = true;
a++;
b = 0;
while(a < _s.size() && _s[a] != ']') {
m_pCCleave[b] = _s[a];
a++;
b++;
}
m_pCCleave[b] = '\0';
}
}
if(m_pNCleave[0] == 'X') {
m_bNX = true;
}
if(m_pCCleave[0] == 'X') {
m_bCX = true;
}
return true;
}
/*
* test takes the abbreviations for the residue N-terminal to a potentially cleaved bond
* and the residue C-terminal to the bond and checks to see if the bond can be cleaved
* according to the rules stored in the load method. load must always be called at least once
* prior to using test, or the results may be unpredictable
*/
bool test(const char _n,const char _c) {
if(m_lType & 0x01)
return true;
if(m_lType & 0x02) {
if(_n == 'K' || _n == 'R') {
if(_c != 'P') {
return true;
}
}
return false;
}
bool bReturn = false;
bool bN = false;
bool bC = false;
if(m_bNX) {
bN = true;
}
else {
if(strchr(m_pNCleave,_n))
bN = true;
}
if(m_bN) {
bReturn = bN;
}
else {
bReturn = !bN;
}
if(!bReturn)
return false;
if(m_bCX) {
bC = true;
}
else {
if(strchr(m_pCCleave,_c))
bC = true;
}
if(m_bC && bC) {
return true;
}
else if(!m_bC && !bC) {
return true;
}
return false;
}
};
class mcleave
{
public:
mcleave(void) {
m_lType = 0;
m_vCleaves.clear();
m_itStart = m_vCleaves.begin();
m_itEnd = m_vCleaves.end();
}
virtual ~mcleave(void) { }
vector m_vCleaves;
vector::iterator m_itStart;
vector::iterator m_itEnd;
vector::iterator m_itValue;
string m_strCleave;
unsigned long m_lType;
/*
* load takes a string containing cleavage information and parses it
* these strings take the format:
* A|B, where A or B are expressions of the form [xyz] or {xyz}. if square brackets, only the single letter
* abbreviations in the brackets are valid at that position for a cleavage, and if french brackets, those
* single letter abbreviations are the only non-valid residues at that position. For example, trypsin
* can be represented by [KR]|{P}, i.e. cleave C-terminal to a K or R residue, except when followed by
* a P. The expression [X]|[X] means cleave at all residues.
* NOTE: use of upper case characters is required for amino acid abbreviations
*/
bool load(string &_s) {
m_strCleave = _s;
m_lType = 0x04;
size_t a = 0;
size_t tEnd = _s.size();
string strTemp;
mcleave_single clvTemp;
m_vCleaves.clear();
while(a < tEnd) {
if(_s[a] == ',') {
if(clvTemp.load(strTemp)) {
m_vCleaves.push_back(clvTemp);
}
strTemp.erase(0,strTemp.size());
}
else if(strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZ[]{}|",_s[a])) {
strTemp += _s[a];
}
else if(_s[a] >= 'a' && _s[a] <= 'z') {
strTemp += (char)(_s[a]-32);
}
a++;
}
if(!strTemp.empty()) {
if(clvTemp.load(strTemp)) {
m_vCleaves.push_back(clvTemp);
}
}
m_itStart = m_vCleaves.begin();
m_itEnd = m_vCleaves.end();
if(m_vCleaves.size() == 1) {
m_lType = m_vCleaves[0].m_lType;
}
return !m_vCleaves.empty();
}
/*
* test takes the abbreviations for the residue N-terminal to a potentially cleaved bond
* and the residue C-terminal to the bond and checks to see if the bond can be cleaved
* according to the rules stored in the load method. load must always be called at least once
* prior to using test, or the results may be unpredictable
*/
bool test(const char _n,const char _c) {
if(m_lType & 0x01)
return true;
if(m_lType & 0x02) {
if(_n == 'K' || _n == 'R') {
if(_c != 'P') {
return true;
}
}
return false;
}
m_itValue = m_itStart;
while(m_itValue != m_itEnd) {
if(m_itValue->test(_n,_c)) {
return true;
}
m_itValue++;
}
return false;
}
};
#endif //ifdef MCLEAVE_H
tandem-linux-13-09-01-1/src/p3msequenceserver.h 0000664 0001750 0001750 00000016346 10406350530 021255 0 ustar langella langella /*
Copyright (C) 2003 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
#ifndef P3MSEQUENCESERVER_H
#define P3MSEQUENCESERVER_H
// File version: 2003-07-01
/*
* p3msequenceserver takes a sequence list file (in FASTA format) and uses it to load an
* msequencecontainer object with a set of amino acid sequences and descriptions. the container
* can be loaded repeatedly until the end-of-file is reached. the next list file path in a
* deque of file names is then extracted and the process continues until the last
* sequence from the last file in the deque is read into the msequencecontainer.
*/
typedef map DESMAP;
class p3msequenceServer : public msequenceServer
{
public:
p3msequenceServer(void);
virtual ~p3msequenceServer(void);
long load_file(const string &_p,const string &_t);
long u_load_file(const string &_p,const string &_t);
unsigned long u_maps(DESMAP &_desc,vector &_v);
};
#endif
tandem-linux-13-09-01-1/src/saxmzmlhandler.cpp 0000664 0001750 0001750 00000014374 12144722506 021170 0 ustar langella langella /************************************************************
* SAXMzmlHandler.cpp
* Adapted from SAXMzdataHandler.cpp
* August 2008
* Ronald Beavis
*
* April 2009 - Support for referenceable param groups and mzML 1.1.0
* Fredrik Levander
*
* Premiere version janvier 2005
* Patrick Lacasse
* placasse@mat.ulaval.ca
*
* 3/11/2005 (Brendan MacLean): Use eXpat SAX parser, and create SAXSpectraHandler
*
* November 2005
* Fredrik Levander
* A few changes to handle MzData 1.05.
*
* Updated to handle version 1.04 and 1.05. (Rob Craig)
*
*
* See http://psidev.sourceforge.net/ms/#mzdata for
* mzData schema information.
*
* Inspired by DtaSAX2Handler.cpp
* copyright : (C) 2002 by Pedrioli Patrick, ISB, Proteomics
* email : ppatrick@systemsbiology.org
* Artistic License granted 3/11/2005
*******************************************************/
#include "stdafx.h"
#include "saxmzmlhandler.h"
SAXMzmlHandler::SAXMzmlHandler( vector& _vS, mspectrumcondition& _sC, mscore& _m)
: SAXSpectraHandler(_vS, _sC, _m)
{
m_bInmzArrayBinary = false;
m_bInintenArrayBinary = false;
m_bInRefGroup = false;
m_bInData = false;
m_bInMsLevel2 = false;
m_bNetworkData = true;
m_bLowPrecision = false;
m_bGaml = false;
}
SAXMzmlHandler::~SAXMzmlHandler()
{
}
void SAXMzmlHandler::startElement(const XML_Char *el, const XML_Char **attr)
{
// Let's see what element just started
// We use:
// spectrum for the id number
// acqInstrument for the msLevel
// cvParam for the polarity and the mz of the parent ion
// data for the values of the spectrum
if (isElement("spectrum", el))
{
reset(); // Clean up for the next scan
m_scanNum = atoi(getAttrValue("index", attr));
m_strDesc = string(getAttrValue("id", attr));
m_tId = m_scanNum;
while(m_sId.find(m_tId) != m_sId.end()) {
m_tId++;
}
m_sId.insert(m_tId);
int iLevel = atoi(getAttrValue("msLevel", attr));
if(iLevel == 2) {
m_bInMsLevel2 = true;
}
m_peaksCount = atoi(getAttrValue("defaultArrayLength", attr));
}
else if (isElement("softwareParam", el)) {
const char* name = getAttrValue("name", attr);
const char* accession = getAttrValue("accession", attr);
const char* version = getAttrValue("version", attr);
}
else if (isElement("referenceableParamGroup", el))
{
const char* groupName = getAttrValue("id", attr);
m_ccurrentRefGroupName = string(groupName);
m_bInRefGroup = true;
cout.flush();
}
else if (isElement("cvParam", el))
{
const char* name = getAttrValue("name", attr);
cout.flush();
const char* accession = getAttrValue("accession", attr);
const char* value = getAttrValue("value", attr);
if (m_bInRefGroup)
{
cvParam m_cvParam;
m_cvParam.refGroupName = string(m_ccurrentRefGroupName);
m_cvParam.name = string(name);
m_cvParam.accession = string(accession);
m_cvParam.value = string(value);
m_refGroupCvParams.push_back(m_cvParam);
}
else
{
processCVParam(name,accession,value);
}
}
else if (isElement("referenceableParamGroupRef", el))
{
const char* groupName = getAttrValue("ref", attr);
for (unsigned int i=0;i 0) {
m_peaksCount = atoi(getAttrValue("arrayLength", attr));
}
m_bInData = true;
}
}
void SAXMzmlHandler::endElement(const XML_Char *el)
{
if(isElement("binary", el)) {
processData();
m_bInintenArrayBinary = false;
m_bInmzArrayBinary = false;
m_bInData = false;
}
else if(isElement("spectrum", el) && m_bInMsLevel2)
{
pushSpectrum();
m_bInMsLevel2 = false;
}
else if (isElement("referenceableParamGroup", el))
{
m_bInRefGroup = false;
}
}
void SAXMzmlHandler::characters(const XML_Char *s, int len)
{
if(m_bInmzArrayBinary && m_bInMsLevel2 && m_bInData){
m_strData.append(s, len);
}
if(m_bInintenArrayBinary && m_bInMsLevel2 && m_bInData){
m_strData.append(s, len);
}
}
void SAXMzmlHandler::processCVParam(const char* name, const char* accession, const char* value)
{
if ((!strcmp(name, "ms level") || !strcmp(accession,"MS:1000511")) && !strcmp(value,"2")){
m_bInMsLevel2 = true;
}
else if(!strcmp(name, "charge state") || !strcmp(accession,"MS:1000041")) {
m_precursorCharge = atoi(value);
}
else if(!strcmp(name, "filter string") || !strcmp(accession,"MS:1000512")) {
m_strDesc = value;
}
else if(!strcmp(name, "scan start time") || !strcmp(accession,"MS:1000016")) {
if(atof(value) > 0.0) {
char pLine[256];
sprintf(pLine,"PT%.3lfS",60.0*atof(value));
m_strRt = pLine;
}
else {
m_strRt = value;
}
}
else if(!strcmp(name, "selected ion m/z") || !strcmp(accession,"MS:1000744")) {
m_precursorMz = atof(value);
}
else if(!strcmp(name, "64-bit float") || !strcmp(accession,"MS:1000523")) {
m_bLowPrecision = false;
}
else if(!strcmp(name, "32-bit float") || !strcmp(accession,"MS:1000521")) {
m_bLowPrecision = true;
}
else if(!strcmp(name, "m/z array") || !strcmp(accession,"MS:1000514")) {
m_bInData = true;
m_bInmzArrayBinary = true;
m_bInintenArrayBinary = false;
}
else if(!strcmp(name, "intensity array") || !strcmp(accession,"MS:1000515")) {
m_bInData = true;
m_bInintenArrayBinary = true;
m_bInmzArrayBinary = false;
}
else if(!strcmp(name, "zlib compression") || !strcmp(accession,"MS:1000574")) {
cout << "
Fatal error: non-standard CODEC used for mzML peak data (CODEC type=" << name << ").
File cannot be interpreted.
\n";
exit(-10);
}
}
void SAXMzmlHandler::processData()
{
if(m_bInmzArrayBinary && m_bInMsLevel2 && m_bInData)
{
pushPeaks(m_bInmzArrayBinary, m_bInintenArrayBinary);
}
else if(m_bInintenArrayBinary && m_bInMsLevel2 && m_bInData)
{
pushPeaks(m_bInmzArrayBinary, m_bInintenArrayBinary);
}
m_strData.clear();
}
tandem-linux-13-09-01-1/src/saxbiomlhandler.cpp 0000664 0001750 0001750 00000020673 11202354267 021311 0 ustar langella langella /*
Copyright (C) 2006 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
// File version: 2006-02-17
/*
* saxBIOMLhandler.cpp contains the override methods necessary for compatibility with
* BIOML file formats.
*/
#include "stdafx.h"
#include "msequence.h"
#include "saxbiomlhandler.h"
SAXBiomlHandler::SAXBiomlHandler( )
: SAXHandler()
{
m_bProtein = false;
m_bPeptide = false;
m_vseqBest.clear();
m_setSeq.clear();
}
SAXBiomlHandler::~SAXBiomlHandler()
{
}
void SAXBiomlHandler::startElement(const XML_Char *el, const XML_Char **attr)
{
if(isElement("protein", el)){
m_bProtein = true;
string strValue;
strValue = getAttrValue("label", attr);
m_seqCurrent.m_strSeq.erase(0,m_seqCurrent.m_strSeq.size());
m_seqCurrent.m_strDes = strValue;
m_seqCurrent.m_bForward = true;
if(strValue.find(":reversed") != strValue.npos) {
m_seqCurrent.m_bForward = false;
}
strValue = getAttrValue("uid",attr);
m_seqCurrent.m_tUid = (size_t)atoi(strValue.c_str());
}
else if(isElement("file", el) && m_bProtein){
string strValue;
strValue = getAttrValue("URL", attr);
short int iPath = 0;
if(m_setPaths.find(strValue) == m_setPaths.end()) {
m_setPaths.insert(strValue);
iPath = (short int) m_vstrPaths.size();
m_vstrPaths.push_back(strValue);
}
else {
size_t a = 0;
while(a < m_vstrPaths.size()) {
if(m_vstrPaths[a] == strValue) {
iPath = (short int) a;
break;
}
a++;
}
}
m_seqCurrent.m_siPath = iPath;
}
else if(isElement("peptide", el)){
m_bPeptide = true;
}
}
void SAXBiomlHandler::endElement(const XML_Char *el)
{
if(isElement("protein", el)){
m_bProtein = false;
if(m_setSeq.find(m_seqCurrent.m_tUid) == m_setSeq.end()) {
m_vseqBest.push_back(m_seqCurrent);
m_setSeq.insert(m_seqCurrent.m_tUid);
}
}
else if(isElement("peptide", el)){
m_bPeptide = false;
}
}
void SAXBiomlHandler::characters(const XML_Char *s, int len)
{
if(m_bPeptide && m_bProtein) {
int a = 0;
while(a < len) {
if((s[a] >= 'A' && s[a] <= 'Z') || s[a] == '*') {
m_seqCurrent.m_strSeq += s[a];
}
a++;
}
}
}
tandem-linux-13-09-01-1/src/msequencecollection.cpp 0000664 0001750 0001750 00000016636 10030624574 022201 0 ustar langella langella /*
Copyright (C) 2003 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
// File version: 2003-07-01
/*
* msequenceCollection objects are used to store lists of msequences, mainly serving as a
* wrapper class for the m_vASequences member
*/
#include "stdafx.h"
#include "msequence.h"
#include "msequencecollection.h"
msequenceCollection::msequenceCollection(void)
{
m_tMax = 1000;
}
msequenceCollection::~msequenceCollection(void)
{
}
bool msequenceCollection::initialize(const size_t _t)
{
m_tMax = _t;
size_t a = 0;
msequence seqTemp;
seqTemp.m_strDes = " ";
seqTemp.m_strSeq = " ";
m_vASequences.clear();
while(a < m_tMax) {
m_vASequences.push_back(seqTemp);
a++;
}
m_tLength = 0;
return true;
}
/*
* removes all msequence objects
*/
bool msequenceCollection::clear(void)
{
m_tLength = 0;
return true;
}
/*
* returns the number of msequence objects currently stored
*/
size_t msequenceCollection::size(void)
{
return m_tLength;
}
/*
* reuturns true if the collection object is full
*/
bool msequenceCollection::full(void)
{
return m_tLength >= m_tMax;
}
tandem-linux-13-09-01-1/src/mplugin.cpp 0000664 0001750 0001750 00000016514 10204373376 017612 0 ustar langella langella /*
Copyright (C) 2003-2004 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
// File version: 2004-02-06
#include "stdafx.h"
#include "mplugin.h"
mpluginmanager* mpluginmanager::m_pManager = NULL;
mpluginmanager& mpluginmanager::get()
{
if (m_pManager == NULL)
m_pManager = new mpluginmanager;
return *m_pManager;
}
mpluginmanager::mpluginmanager()
{
}
string mpluginmanager::get_key(const char* _type, const char* _spec)
{
string key = _type;
key.append(", ");
key.append(_spec);
return key;
}
mplugin* mpluginmanager::create_plugin(const char* _type, const char* _spec)
{
string key = get_key(_type, _spec);
map::iterator it = m_mapFactories.find(key);
if (it == m_mapFactories.end())
{
cout << "Error: The plug-in '" << key << "' is not registered.";
return NULL;
}
return it->second->create_plugin();
}
void mpluginmanager::register_factory(const char* _type, const char* _spec, mpluginfactory* _f)
{
m_mapFactories.insert(make_pair(get_key(_type, _spec), _f));
}
tandem-linux-13-09-01-1/src/mmotif.h 0000664 0001750 0001750 00000026676 10575320112 017100 0 ustar langella langella /*
Copyright (C) 2003 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
#ifndef MMOTIF_H
#define MMOTIF_H
// File version: 2004-06-01
// File version: 2005-01-01
/*
* mmotif is a specialty class meant to store information about protein sequence motifs.
* NOTE: mmotif.h does not have a corresponding .cpp file
*/
class mmotifres
{
public:
mmotifres(void)
{
m_bRes = false;
m_bPos = true;
m_bIsX = false;
strcpy(m_pMotif,"");
}
virtual ~mmotifres(void)
{
}
char m_pMotif[32];
bool m_bRes;
bool m_bPos;
bool m_bIsX;
bool set(const char *_p) {
if(_p == NULL) {
return false;
}
if(strlen(_p) == 0) {
return false;
}
strcpy(m_pMotif,"");
m_bIsX = false;
m_bRes = true;
m_bPos = true;
if(strchr(_p,'!') == NULL) {
m_bRes = false;
}
if(strchr(_p,'X') != NULL) {
m_bIsX = true;
m_bPos = true;
strcpy(m_pMotif,"X");
return true;
}
char *pValue = new char[strlen(_p)+1];
strcpy(pValue,_p);
char *pStart = pValue;
char *pEnd = pStart;
size_t a = 0;
if(strchr(pValue,'[') != NULL) {
pStart = strchr(pValue,'[');
pStart++;
while(*pStart != ']' && *pStart != '\0') {
if(isalpha(*pStart)) {
m_pMotif[a] = *pStart;
}
pStart++;
a++;
}
m_pMotif[a] = '0';
m_bPos = true;
return true;
}
else if(strchr(pValue,'{') != NULL) {
pStart = strchr(pValue,'{');
pStart++;
while(*pStart != ']' && *pStart != '\0') {
if(isalpha(*pStart)) {
m_pMotif[a] = *pStart;
}
pStart++;
a++;
}
m_pMotif[a] = '0';
m_bPos = false;
return true;
}
else {
pStart = pValue;
while(*pStart != '0') {
if(isalpha(*pStart)) {
m_pMotif[a] = *pStart;
a++;
break;
}
pStart++;
}
m_pMotif[a] = '\0';
m_bPos = true;
}
return false;
}
bool check(const char _c) {
if(m_bIsX) {
return true;
}
if(m_bPos) {
if(strchr(m_pMotif,_c) != NULL) {
return true;
}
return false;
}
if(strchr(m_pMotif,_c) == NULL) {
return true;
}
return false;
}
mmotifres& operator=(const mmotifres &rhs) {
strcpy(m_pMotif,rhs.m_pMotif);
m_bRes = rhs.m_bRes;
m_bPos = rhs.m_bPos;
m_bIsX = rhs.m_bIsX;
return *this;
}
};
class mmotif
{
public:
mmotif(void)
{
m_fMass = 0.0;
m_fMassPrompt = 0;
m_tPos = 0;
}
virtual ~mmotif(void)
{
}
vector m_vresMotifs;
float m_fMass;
float m_fMassPrompt;
size_t m_tPos;
bool set(const char *_p) {
if(_p == NULL) {
return false;
}
if(strlen(_p) == 0) {
return false;
}
const char *pStart = (char *)strchr(_p,'@');
const char *pColon = (char *)strchr(_p,':');
if(pStart == NULL) {
return false;
}
m_fMassPrompt = 0.0;
if(pColon != NULL && pColon < pStart) {
m_fMassPrompt = (float)atof(pColon+1);
}
m_fMass = (float)(atof(_p));
pStart++;
size_t a = 0;
size_t b = 0;
size_t tEnd = strlen(pStart);
char *pOut = new char[256];
mmotifres motRes;
m_vresMotifs.clear();
while(a < tEnd) {
if(pStart[a] == '[') {
a++;
b = 0;
pOut[b] = '[';
b++;
while(pStart[a] != '\0' && pStart[a] != ']') {
pOut[b] = pStart[a];
b++;
a++;
}
pOut[b] = ']';
b++;
pOut[b] = '\0';
motRes.set(pOut);
if(motRes.m_bRes) {
m_tPos = m_vresMotifs.size();
}
m_vresMotifs.push_back(motRes);
}
else if(pStart[a] == '{') {
a++;
b = 0;
pOut[b] = '{';
b++;
while(pStart[a] != '\0' && pStart[a] != '}') {
pOut[b] = pStart[a];
b++;
a++;
}
pOut[b] = '}';
b++;
pOut[b] = '\0';
motRes.set(pOut);
if(motRes.m_bRes) {
m_tPos = m_vresMotifs.size();
}
m_vresMotifs.push_back(motRes);
}
else if(pStart[a] == '(') {
a++;
unsigned long c = (unsigned long)atoi(pStart+a);
if(c > 0)
c--;
while(pStart[a] != '\0' && pStart[a] != ')') {
a++;
}
if(!m_vresMotifs.empty()) {
b = 0;
while(b < c) {
m_vresMotifs.push_back(motRes);
b++;
}
}
}
else if(isalpha(pStart[a])) {
b = 0;
pOut[b] = pStart[a];
b++;
if(pStart[a+1] == '!') {
pOut[b] = pStart[a+1];
b++;
}
pOut[b] = '\0';
motRes.set(pOut);
if(motRes.m_bRes) {
m_tPos = m_vresMotifs.size();
}
m_vresMotifs.push_back(motRes);
}
a++;
}
delete pOut;
return true;
}
bool check(const char *_p,size_t &_o) {
size_t a = 0;
const size_t tSize = m_vresMotifs.size();
while(*(_p+a) != '\0' && a < tSize) {
if(!m_vresMotifs[a].check(*(_p+a))) {
return false;
}
a++;
}
if(a != tSize) {
return false;
}
_o = m_tPos;
return true;
}
bool initialize() {
m_vresMotifs.clear();
m_fMass = 0.0;
m_tPos = 0;
return true;
}
mmotif& operator=(const mmotif &rhs) {
m_fMass = rhs.m_fMass;
m_tPos = rhs.m_tPos;
m_vresMotifs.clear();
size_t a = 0;
while(a < rhs.m_vresMotifs.size()) {
m_vresMotifs.push_back(rhs.m_vresMotifs[a]);
a++;
}
return *this;
}
};
#endif
tandem-linux-13-09-01-1/src/mbiomlreport.h 0000664 0001750 0001750 00000017706 11202352520 020306 0 ustar langella langella /*
Copyright (C) 2006 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
// File version: 2006-02-17
/*
* mbiomlreport outputs a bioml file containing the refinement sequences.
*/
#if !defined(MBIOMLREPORT_H)
#define MBIOMLREPORT_H
/**
* Uses eXpat SAX parser to parse Bioml data to obtain protein information.
*/
class mbiomlreport
{
public:
mbiomlreport();
~mbiomlreport();
// -----------------------------------------------------------------------
// Overrides of SAXHandler functions
// -----------------------------------------------------------------------
/**
* Receive notification of the start of an element.
*
* By default, do nothing. Application writers may override this
* method in a subclass to take specific actions at the start of
* each element (such as allocating a new tree node or writing
* output to a file).
*/
void setpath(string &_s);
/**
* Receive notification of the end of an element.
*
* By default, do nothing. Application writers may override this
* method in a subclass to take specific actions at the end of
* each element (such as finalising a tree node or writing
* output to a file).
*/
bool write(vector &_v,vector &_p);
/**
* Receive notification of character data inside an element.
*
* By default, do nothing. Application writers may override this
* method to take specific actions for each chunk of character data
* (such as adding the data to a node or buffer, or printing it to
* a file).
*/
private:
// Flags indicating parser is inside a particular tag.
string m_strPath;
};
#endif //MBIOMLREPORT_H
tandem-linux-13-09-01-1/src/base64.cpp 0000664 0001750 0001750 00000007510 11720520101 017177 0 ustar langella langella /* downloaded from web */
//#include
//#include
//#include
#include "stdafx.h"
#include "base64.h"
inline int getPosition( char buf );
static const unsigned char *b64_tbl = (const unsigned char*) "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
static const unsigned char b64_pad = '=';
/* base64 encode a group of between 1 and 3 input chars into a group of 4 output chars */
static void encode_group (unsigned char output[],
const unsigned char input[],
int n)
{
unsigned char ingrp[3];
ingrp[0] = n > 0 ? input[0] : 0;
ingrp[1] = n > 1 ? input[1] : 0;
ingrp[2] = n > 2 ? input[2] : 0;
/* upper 6 bits of ingrp[0] */
output[0] = n > 0 ? b64_tbl[ingrp[0] >> 2] : b64_pad;
/* lower 2 bits of ingrp[0] | upper 4 bits of ingrp[1] */
output[1] = n > 0 ? b64_tbl[((ingrp[0] & 0x3) << 4) | (ingrp[1] >> 4)] : b64_pad;
/* lower 4 bits of ingrp[1] | upper 2 bits of ingrp[2] */
output[2] = n > 1 ? b64_tbl[((ingrp[1] & 0xf) << 2) | (ingrp[2] >> 6)] : b64_pad;
/* lower 6 bits of ingrp[2] */
output[3] = n > 2 ? b64_tbl[ingrp[2] & 0x3f] : b64_pad;
}
/* base64 decode a group of 4 input chars into a group of between 0 and
* 3 output chars */
static void decode_group (unsigned char output[],
const unsigned char input[],
int *n)
{
unsigned char *t1, *t2;
*n = 0;
if (input[0] == '=')
return;
t1 = (unsigned char*) strchr ((const char*)b64_tbl, input[0]);
t2 = (unsigned char*) strchr ((const char*)b64_tbl, input[1]);
output[(*n)++] = (unsigned char)(((t1 - b64_tbl) << 2) | ((t2 - b64_tbl) >> 4));
if (input[2] == '=')
return;
t1 = (unsigned char*) strchr ((const char*)b64_tbl, input[2]);
output[(*n)++] = (unsigned char)(((t2 - b64_tbl) << 4) | ((t1 - b64_tbl) >> 2));
if (input[3] == '=')
return;
t2 = (unsigned char*) strchr ((const char*)b64_tbl, input[3]);
output[(*n)++] = (unsigned char)(((t1 - b64_tbl) << 6) | (t2 - b64_tbl));
return;
}
inline int getPosition( char buf )
{
if( buf > 96 ) // [a-z]
return (buf - 71);
else if( buf > 64 ) // [A-Z]
return (buf - 65);
else if( buf > 47 ) // [0-9]
return (buf + 4);
else if( buf == 43 )
return 63;
else // buf == '/'
return 64;
}
// Returns the total number of bytes decoded
int b64_decode_mio ( char *dest, char *src, size_t size )
{
char *temp = dest;
char *end = dest + size;
for (;;)
{
int register a;
int register b;
int t1,t2,t3,t4;
if (!(t1 = *src++) || !(t2 = *src++) || !(t3 = *src++) || !(t4 = *src++))
return (int)(temp-dest);
if (t1 == 61 || temp >= end) // if == '='
return(int)(temp-dest);
if( t1 > 96 ) // [a-z]
a = (t1 - 71);
else if( t1 > 64 ) // [A-Z]
a = (t1 - 65);
else if( t1 > 47 ) // [0-9]
a = (t1 + 4);
else if( t1 == 43 )
a = 62;
else // src[0] == '/'
a = 63;
if( t2 > 96 ) // [a-z]
b = (t2 - 71);
else if( t2 > 64 ) // [A-Z]
b = (t2 - 65);
else if( t2 > 47 ) // [0-9]
b = (t2 + 4);
else if( t2 == 43 )
b = 62;
else // src[0] == '/'
b = 63;
*temp++ = ( a << 2) | ( b >> 4);
if (t3 == 61 || temp >= end)
return (int)(temp-dest);;
if( t3 > 96 ) // [a-z]
a = (t3 - 71);
else if( t3 > 64 ) // [A-Z]
a = (t3 - 65);
else if( t3 > 47 ) // [0-9]
a = (t3 + 4);
else if( t3 == 43 )
a = 62;
else // src[0] == '/'
a = 63;
*temp++ = ( b << 4) | ( a >> 2);
if (t4 == 61 || temp >= end)
return (int)(temp-dest);;
if( t4 > 96 ) // [a-z]
b = (t4 - 71);
else if( t4 > 64 ) // [A-Z]
b = (t4 - 65);
else if( t4 > 47 ) // [0-9]
b = (t4 + 4);
else if( t4 == 43 )
b = 62;
else // src[0] == '/'
b = 63;
*temp++ = ( a << 6) | ( b );
}
}
tandem-linux-13-09-01-1/src/mxxcleavage.h 0000664 0001750 0001750 00000016541 10311635154 020102 0 ustar langella langella /*
Copyright (C) 2005 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
// File version: 2005-09-01
#ifndef MXXCLEAVAGE_H
#define MXXCLEAVAGE_H
#include "mrefine.h"
class mpeptide;
class msequence;
class mprocess;
class mxxcleavage : public mrefine
{
public:
mxxcleavage();
~mxxcleavage(void);
bool refine(); //entry point for unanticipated cleavage processing
bool set_mprocess(mprocess *_p); //set the m_pProcess object
mprocess *m_pProcess; //pointer to the parent mprocess class
};
/*
* mxxcleavagemanager is used to organize and facilitate the creation of mxxcleavage objects
*/
class mxxcleavagemanager
{
public:
static const char* TYPE;
static mxxcleavage* create_mxxcleavage(XmlParameter &_x);
static void register_factory(const char* _spec, mpluginfactory* _f);
};
/*
* mxxcleavagefactory_tandem implements a factory for creating mxxcleavage
* instances.
*/
class mxxcleavagefactory_tandem : public mpluginfactory
{
public:
mxxcleavagefactory_tandem();
virtual mplugin* create_plugin();
};
#endif
tandem-linux-13-09-01-1/src/xmltaxonomy.h 0000664 0001750 0001750 00000020670 10630552014 020170 0 ustar langella langella /*
Copyright (C) 2003 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
#ifndef XMLTAXONOMY_H
#define XMLTAXONOMY_H
// File version: 2003-07-01
/*
* the XmlTaxonomy object is used to create a list of sequnece list files, based on
* an XML file that can be used to create lists of sequence list files to be
* modelled. The format for this file is as follows:
* A list of file nodes, containing the path to a sequence list file, is associated with
* a "taxon" label by being contained within the taxon object tags. The XmlTaxonomy object
* checks for the availability of these files and stores the paths for later use.
*/
class XmlTaxonomy
{
public:
XmlTaxonomy(void);
virtual ~XmlTaxonomy(void);
vector m_vstrPaths; // the path names associated with a taxon
string m_strTaxonPath; // the path to the taxonomy file
string m_strTaxon; // the name of the desired taxon
enum tax_type {
SEQUENCE = 1,
SPECTRUM = 2
} TAX_TYPE;
bool load(const string &_p,const string &_t,const string &_y);
};
#endif
tandem-linux-13-09-01-1/src/mhistogram.h 0000664 0001750 0001750 00000042537 12211621737 017757 0 ustar langella langella /*
Copyright (C) 2003-2013 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
#ifndef MHISTOGRAM_H
#define MHISTOGRAM_H
// File version: 2003-07-01
/*
* The mhistogram class is used for storing information about scoring in the mspectrum class.
* Two types of histogram classes are used: the mhistogram which stores information about
* convolution and hyper scores and the count_mhistogram class which is used to store the number
* of specific ion types (e.g. y or b ions). The mhistgram class converts the scores into base-10 logs
* to make the histogram more compact and to linearize the extreme value distribution, which
* governs the scoring distribution. In order to calculate expectation values from these distributions,
* they are first converted to survival functions (by the survival methdod), the outlying non-random
* scores are removed from the distribution and the high scoring tail of the distribution is fitted
* to a log-log linear distribution using least-squares in the model method.
* mhistogram is included in the mspectrum.h file only
*/
#include
class mhistogram {
public:
mhistogram(void) {
init();
}
mhistogram(const mhistogram& rhs) {
init();
(*this) = rhs;
}
int* m_pList; // doubling buffer
int m_lLength; // the length of the histogram
int m_ulCount;
int m_ulMax;
void init() {
m_ulCount = 0;
m_lLength = 0;
m_pList = NULL;
m_fA0 = (float)4.8;
m_fA1 = (float)-0.28;
m_dProteinFactor = 1.0;
m_lSum = 0;
m_dLimit = 1.0e-15;
m_lHigh = 0;
m_ulMax = INT_MAX;
}
virtual ~mhistogram(void) {
delete [] m_pList;
}
protected:
double m_dProteinFactor; // a weighting factor
float m_fA0; // the intercept of the least-squares fit performed in model
float m_fA1; // the slope of the least-squares fit performed in model
private:
vector m_vlSurvive; // the survival function array, reduced to [96] from [256]
int m_lSum;
double m_dLimit;
int m_lHigh;
public:
bool dump(void)
{
int a = 0;
while(a < m_lLength) {
cout << m_pList[a] << ",";
a++;
}
cout << "
" << m_ulCount << "
";
cout.flush();
return true;
}
/*
* expect uses the equation derived in model to convert scores into expectation values
* survival and model must be called before expect will return reasonable values
*/
float expect(const float _f) {
double dR = pow(10.0,(double)(m_fA0 + m_fA1*_f));
if(dR < m_dLimit) {
dR = m_dLimit;
}
return (float)dR;
}
/*
* list returns a specified value from the stochastic distribution of the histogram
*/
int list(const int _l) {
if (_l >= m_lLength)
return 0;
return m_pList[_l];
}
/*
* survive returns a specified value from the stochastic distribution of the survival function
*/
int survive(const int _l) {
return m_vlSurvive[_l];
}
int sum() {
return m_lSum;
}
/*
* length returns the maximum length of the histogram
*/
int length(void) {
return m_lLength;
}
/*
* a0 returns the first parameter in the linear fit to the survival function
*/
float a0(void) {
return m_fA0;
}
/*
* a1 returns the first parameter in the linear fit to the survival function
*/
float a1(void) {
return m_fA1;
}
/*
* expect_protein allows for a modified expectation value to be used for proteins
*/
float expect_protein(const float _f) {
double dR = pow(10.0,(double)(m_fA0 + m_fA1*_f))*m_dProteinFactor;
if(dR < m_dLimit) {
dR = m_dLimit;
}
return (float)dR;
}
/*
* set_protein_factor simply sets the value for m_dProteinFactor
*/
bool set_protein_factor(const double _d) {
if(_d <= 0.0)
return false;
m_dProteinFactor = _d;
return true;
}
/*
* reset zeros the histogram array m_pList
*/
virtual bool clear() {
int a = 0;
while(a < m_lLength) {
m_pList[a] = 0;
a++;
}
m_ulCount = 0;
m_lHigh = 0;
return true;
}
/*
* add increments the appropriate value in m_pList for a score value
*/
virtual int add(const float _f) {
int lValue = (int)(_f + 0.5);
// If buffer too small, double its size.
// Buffer must have empty bucket at end to output
// histogram correctly for reports.
if(lValue > m_lLength - 2) {
int lLengthNew = lValue + 2;
int* pListNew = new int[lLengthNew];
memset(pListNew, 0, lLengthNew * sizeof(int));
if (m_pList != NULL) {
memcpy(pListNew, m_pList, m_lLength * sizeof(int));
delete [] m_pList;
}
m_pList = pListNew;
m_lLength = lLengthNew;
if(m_pList[lValue] < INT_MAX) {
m_pList[lValue]++;
}
m_lHigh = lValue;
return lValue;
}
if(m_ulCount > m_ulMax) {
if(lValue >= m_lHigh) {
if(m_pList[lValue] < INT_MAX) {
m_pList[lValue]++;
}
m_lHigh = lValue;
}
}
else {
if(m_pList[lValue] < INT_MAX) {
m_pList[lValue]++;
}
if(lValue > m_lHigh) {
m_lHigh = lValue;
}
if(lValue < m_lHigh) {
m_ulCount++;
}
}
return lValue;
}
/*
* survival converts the scoring histogram in m_pList into a survival function
*/
bool survival()
{
if (m_lLength == 0)
return false;
int a = 0;
int lSum = 0;
int *plValues = new int[m_lLength];
/*
* first calculate the raw survival function
*/
int *pTempList = new int[m_lLength];
int lZeros = 0;
while(a < m_lLength) {
if(a < 6) {
pTempList[a] = m_pList[a];
}
else
{
if(m_pList[a] == 0) {
lZeros++;
}
if(lZeros == 1 && m_pList[a-1] > 1) {
pTempList[a-1] = 1;
}
if(lZeros > 0 && lZeros <= 1 && m_pList[a] > 1) {
pTempList[a] = 1;
}
else if(lZeros > 1) {
pTempList[a] = 0;
}
else {
pTempList[a] = m_pList[a];
}
}
a++;
}
a = m_lLength - 1;
while(a > -1) {
lSum += pTempList[a];
plValues[a] = lSum;
a--;
}
a = 0;
/*
* replace the scoring distribution with the survival function
*/
m_vlSurvive.clear();
plValues[m_lHigh] = 1;
while(a < m_lLength) {
m_vlSurvive.push_back(plValues[a]);
a++;
}
delete plValues;
delete pTempList;
m_lSum = m_vlSurvive[0];
return true;
}
bool clear_survive()
{
m_vlSurvive.clear();
return true;
}
/*
* model performs a least-squares fit to the log score vs log survival function.
* survival must be called prior to using model
*/
bool model()
{
survival();
m_fA0 = (float)3.5;
m_fA1 = (float)-0.25;
/*
* use default values if the statistics in the survival function is too meager
*/
if(m_lLength == 0) {
return false;
}
float *pfX = new float[m_lLength];
float *pfT = new float[m_lLength];
int a = 1;
const int lMaxLimit = (int)(0.5 + m_vlSurvive[0]*0.6);
const int lMinLimit = 1;
/*
* find non zero points to use for the fit
*/
a = 0;
while(a < m_lLength && m_vlSurvive[a] > lMaxLimit) {
a++;
}
int b = 0;
while(a < m_lLength-1 && m_vlSurvive[a] > lMinLimit) {
pfX[b] = (float)a;
pfT[b] = (float)log10((double)m_vlSurvive[a]);
b++;
a++;
}
/*
* calculate the fit
*/
double dSumX = 0.0;
double dSumT = 0.0;
double dSumXX = 0.0;
double dSumXT = 0.0;
int iMaxValue = 0;
double dMaxT = 0.0;
double dZero = (double)(a - 1);
int lZeros = m_lHigh - a - 1;
double dDefaultA1 = -0.25;
double dDefaultA0 = -1.0*((dZero+2.5)*dDefaultA1);
int iValues = b-1;
a = 0;
while(a < iValues) {
if(pfT[a] > dMaxT) {
dMaxT = pfT[a];
iMaxValue = a;
}
a++;
}
a = iMaxValue;
while(a < iValues) {
dSumX += pfX[a];
dSumXX += pfX[a]*pfX[a];
dSumXT += pfX[a]*pfT[a];
dSumT += pfT[a];
a++;
}
iValues -= iMaxValue;
double dDelta = (double)iValues*dSumXX - dSumX*dSumX;
if(dDelta == 0.0) {
delete pfX;
delete pfT;
return false;
}
m_fA0 = (float)((dSumXX*dSumT -dSumX*dSumXT)/dDelta);
m_fA1 = (float)(((double)iValues*dSumXT - dSumX*dSumT)/dDelta);
m_fA0 = (float)(-1.0*((dZero+2.5)*m_fA1));
double dScore = m_fA0 + m_fA1*(double)m_lHigh;
if(dScore > 0.0) {
dScore = 0.0;
}
if(dScore > 2.5 + dDefaultA0 + dDefaultA1*(double)m_lHigh || m_vlSurvive[0] < 200) {
// cout << "
" << lZeros << ", " << m_fA0 << ":" << m_fA1<< ", " << dDefaultA0 << ":" << dDefaultA1 << " | ";
m_fA0 = (float)dDefaultA0;
m_fA1 = (float)dDefaultA1;
// cout << dScore << ":" << m_fA0 + m_fA1*(double)m_lHigh << "
";
}
delete pfX;
delete pfT;
m_vlSurvive.clear();
return true;
}
/*
* simple copy method using the = operator
*/
mhistogram& operator=(const mhistogram &rhs) {
m_ulCount = rhs.m_ulCount;
m_lLength = rhs.m_lLength;
m_lHigh = rhs.m_lHigh;
delete [] m_pList;
if (rhs.m_pList == NULL)
m_pList = NULL;
else {
size_t size = m_lLength * sizeof(int);
m_pList = new int[size];
memcpy(m_pList, rhs.m_pList, size);
}
m_fA0 = rhs.m_fA0;
m_fA1 = rhs.m_fA1;
m_dProteinFactor = rhs.m_dProteinFactor;
m_lSum = rhs.m_lSum;
return *this;
}
mhistogram& operator+=(const mhistogram &rhs) {
m_ulCount += rhs.m_ulCount;
m_lLength = rhs.m_lLength;
int a = 0;
m_fA0 = rhs.m_fA0;
m_fA1 = rhs.m_fA1;
m_dProteinFactor = rhs.m_dProteinFactor;
while(a < m_lLength) {
m_pList[a] += rhs.m_pList[a];
if(m_pList[a] > 0) {
m_lHigh = a;
}
a++;
}
m_lSum += rhs.m_lSum;
return *this;
}
};
/*
* count_mhistogram stores information about the number of specific ion-types
* discovered while modeling mspectrum object against a sequence collection.
* model and survival are not used
* starting in version 2004.04.01, this class is no longer a public mhistogram
* this change was made to reduce memory usage, by eliminating the
* m_pSurvive array & reducing the size of the m_pList array
*/
class count_mhistogram
{
public:
count_mhistogram(void) {m_lLength = 8;}
virtual ~count_mhistogram(void) { }
int m_lLength;
virtual float convert(const float _f) {
return _f;
}
virtual int add(const int _c) {
if(_c < m_lLength && _c > -1) {
m_pList[_c]++;
}
else if(_c > -1) {
m_pList[m_lLength-1]++;
}
else if(_c < 0) {
m_pList[0]++;
}
return _c;
}
/*
* reset zeros the histogram array m_pList
*/
virtual bool clear() {
int a = 0;
while(a < m_lLength) {
m_pList[a] = 0;
a++;
}
return true;
}
/*
* simple copy method using the = operator
*/
count_mhistogram& operator=(const count_mhistogram &rhs) {
m_lLength = rhs.m_lLength;
int a = 0;
while(a < m_lLength) {
m_pList[a] = rhs.m_pList[a];
a++;
}
return *this;
}
count_mhistogram& operator+=(const count_mhistogram &rhs) {
m_lLength = rhs.m_lLength;
int a = 0;
while(a < m_lLength) {
m_pList[a] += rhs.m_pList[a];
a++;
}
return *this;
}
/*
* list returns a specified value from the stochastic distribution of the histogram
*/
int list(const int _l) {
return m_pList[_l];
}
/*
* length returns the maximum length of the histogram
*/
int length(void) {
return m_lLength;
}
private:
int m_pList[8]; // the histogram array
};
#endif //ifdef MHISTOGRAM_H
tandem-linux-13-09-01-1/src/mspectrum.h 0000664 0001750 0001750 00000034366 11662510050 017617 0 ustar langella langella /*
Copyright (C) 2003-2004 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
#ifndef MSPECTRUM_H
#define MSPECTRUM_H
// File version: 2004-01-07
/*
* mspectrum objects store all information about individual tandem mass spectra. The parent ion
* information and all m/z - intensity pairs are stored, along with msequence and mhistogram
* objects that contain the information discovered while modeling a list of sequences.
*/
#include "mhistogram.h"
#include "msequence.h"
/*
* mi objects contain the m/z - intensity information about a single peak in a spectrum
*/
class mi
{
public:
mi(void) {
m_fM = 0.0;
m_fI = 1.0;
}
virtual ~mi(void) { }
float m_fM; // the m/z value
float m_fI; // the intensity value
/*
* a simple copy operation, using the = operator
*/
mi& operator=(const mi &rhs) {
m_fM = rhs.m_fM;
m_fI = rhs.m_fI;
return *this;
}
};
class mspectrum {
public:
mspectrum(void) {
m_dRatio = 0.0;
m_dMH = 0.0;
m_fI = 1.0;
m_fZ = 1.0;
m_tId = 0;
m_fScore = m_fScoreNext = 0.0;
m_fHyper = m_fHyperNext = 100.0;
m_dExpect = 1000.0;
m_dProteinExpect = 1000.0;
m_bRepeat = false;
m_bActive = true;
m_uiType = 0;
if(sizeof(size_t) == 8) {
m_tCurrentSequence = (size_t)0xAFFFFFFF;
}
else {
m_tCurrentSequence = (size_t)0xAFFF;
}
m_vseqBest.clear();
m_vMI.clear();
m_vMINeutral.clear();
m_hHyper.clear(); // the histogram of hyper scores
m_hConvolute.clear(); // the histogram of convolution scores
m_chBCount.clear(); // the histogram of b-ion counts
m_chYCount.clear(); // the histogram of y-ion counts
m_mapScore.clear();
m_mapCount.clear();
}
~mspectrum(void) { }
size_t m_tId; // an identification number
size_t m_tCurrentSequence; // an identifier for the current sequence (used in mprocess)
unsigned int m_uiType;
float m_fScore; // the convolution score
float m_fHyper; // the hyper score
float m_fScoreNext; // next best convolution score
float m_fHyperNext; // next best hyper score
double m_dRatio;
double m_dExpect; // the expectation value
double m_dProteinExpect; // the expectation value for the associated protein
double m_dMH; // the parent ion mass + a proton
float m_fI; // the parent ion intensity (if available)
float m_fZ; // the parent ion charge
bool m_bRepeat; // a flag indicating that a better match for an individual peptide has already been found
bool m_bActive; // a flag indicating that a spectrum is available for scoring
vector m_vMI; // a vector containing the m/z - intensity information for fragment ions
vector m_vMINeutral; // a vector containing the m/z - intensity information for fragment ions
vector m_vseqBest; // a vector containing the highest scoring msequence objects
vector m_vdStats;
string m_strDescription;
string m_strRt;
mhistogram m_hHyper; // the histogram of hyper scores
mhistogram m_hConvolute; // the histogram of convolution scores
count_mhistogram m_chBCount; // the histogram of b-ion counts
count_mhistogram m_chYCount; // the histogram of y-ion counts
map m_mapCount; // a map of the number of ions detected for each ion type
map m_mapScore; // a map of the convolution scores for each ion type
/*
* a simple copy operator using the = operator
*/
mspectrum& operator=(const mspectrum &rhs) {
m_vdStats = rhs.m_vdStats;
m_uiType = rhs.m_uiType;
m_dRatio = rhs.m_dRatio;
m_hHyper = rhs.m_hHyper;
m_hConvolute = rhs.m_hConvolute;
m_chBCount = rhs.m_chBCount;
m_chYCount = rhs.m_chYCount;
m_mapCount = rhs.m_mapCount;
m_mapScore = rhs.m_mapScore;
m_vMI.clear();
m_vMINeutral.clear();
size_t a = 0;
size_t tLength = rhs.m_vMI.size();
while(a < tLength) {
m_vMI.push_back(rhs.m_vMI[a]);
a++;
}
tLength = rhs.m_vMINeutral.size();
a = 0;
while(a < tLength) {
m_vMINeutral.push_back(rhs.m_vMINeutral[a]);
a++;
}
m_dMH = rhs.m_dMH;
m_fI = rhs.m_fI;
m_fZ = rhs.m_fZ;
m_tId = rhs.m_tId;
m_fScore = rhs.m_fScore;
m_fHyper = rhs.m_fHyper;
m_fScoreNext = rhs.m_fScoreNext;
m_fHyperNext = rhs.m_fHyperNext;
m_dExpect = rhs.m_dExpect;
m_dProteinExpect = rhs.m_dProteinExpect;
m_bRepeat = rhs.m_bRepeat;
m_vseqBest.clear();
m_vseqBest = rhs.m_vseqBest;
m_tCurrentSequence = rhs.m_tCurrentSequence;
m_strDescription = rhs.m_strDescription;
m_strRt = rhs.m_strRt;
m_bActive = rhs.m_bActive;
return *this;
}
mspectrum& operator*=(const mspectrum &rhs) {
m_hHyper = rhs.m_hHyper;
m_hConvolute = rhs.m_hConvolute;
m_chBCount = rhs.m_chBCount;
m_chYCount = rhs.m_chYCount;
m_mapCount = rhs.m_mapCount;
m_mapScore = rhs.m_mapScore;
m_bActive = rhs.m_bActive;
m_dMH = rhs.m_dMH;
m_fI = rhs.m_fI;
m_fZ = rhs.m_fZ;
m_tId = rhs.m_tId;
m_uiType = rhs.m_uiType;
m_fScore = rhs.m_fScore;
m_dRatio = rhs.m_dRatio;
m_fHyper = rhs.m_fHyper;
m_fScoreNext = rhs.m_fScoreNext;
m_fHyperNext = rhs.m_fHyperNext;
m_dExpect = rhs.m_dExpect;
m_dProteinExpect = rhs.m_dProteinExpect;
m_bRepeat = rhs.m_bRepeat;
m_vseqBest.clear();
m_vseqBest = rhs.m_vseqBest;
m_tCurrentSequence = rhs.m_tCurrentSequence;
return *this;
}
mspectrum& operator+=(const mspectrum &rhs) {
m_vdStats = rhs.m_vdStats;
m_hHyper += rhs.m_hHyper;
m_hConvolute += rhs.m_hConvolute;
m_chBCount += rhs.m_chBCount;
m_chYCount += rhs.m_chYCount;
m_mapCount = rhs.m_mapCount;
m_mapScore = rhs.m_mapScore;
m_uiType = rhs.m_uiType;
size_t a = 0;
size_t tLength = 0;
m_bRepeat = false;
if(rhs.m_fHyper == m_fHyper) {
m_dMH = rhs.m_dMH;
m_fI = rhs.m_fI;
m_fZ = rhs.m_fZ;
m_tId = rhs.m_tId;
m_fScore = rhs.m_fScore;
m_fHyper = rhs.m_fHyper;
m_dRatio = rhs.m_dRatio;
m_fScoreNext = rhs.m_fScoreNext;
m_fHyperNext = rhs.m_fHyperNext;
a = 0;
tLength = rhs.m_vseqBest.size();
while(a < tLength) {
m_vseqBest.push_back(rhs.m_vseqBest[a]);
a++;
}
m_tCurrentSequence = rhs.m_tCurrentSequence;
}
else if(rhs.m_fHyper > m_fHyper) {
m_dMH = rhs.m_dMH;
m_fI = rhs.m_fI;
m_fZ = rhs.m_fZ;
m_tId = rhs.m_tId;
m_fScore = rhs.m_fScore;
m_fHyper = rhs.m_fHyper;
m_dRatio = rhs.m_dRatio;
m_fScoreNext = rhs.m_fScoreNext;
m_fHyperNext = rhs.m_fHyperNext;
m_vseqBest.clear();
m_vseqBest = rhs.m_vseqBest;
m_tCurrentSequence = rhs.m_tCurrentSequence;
}
m_dExpect = rhs.m_dExpect;
m_dProteinExpect = rhs.m_dProteinExpect;
return *this;
}
bool format() {
size_t tStart = m_strDescription.find('&');
while(tStart != m_strDescription.npos) {
m_strDescription.replace(tStart,1,"&");
tStart = m_strDescription.find('&',tStart+1);
}
tStart = m_strDescription.find('<');
while(tStart != m_strDescription.npos) {
m_strDescription.replace(tStart,1,"<");
tStart = m_strDescription.find('<',tStart+1);
}
tStart = m_strDescription.find('>');
while(tStart != m_strDescription.npos) {
m_strDescription.replace(tStart,1,">");
tStart = m_strDescription.find('<',tStart+1);
}
tStart = m_strDescription.find('\"');
while(tStart != m_strDescription.npos) {
m_strDescription.replace(tStart,1,""");
tStart = m_strDescription.find('\"',tStart+1);
}
return true;
}
// contributed by Brian Pratt to correct a problem associated with not
// clearing the m_vdStats vector when spectrum, use conditioning=no
void clear_intensity_values() { // clear intensities and associated stats
m_vMI.clear();
m_vdStats.clear();
}
bool reset() {
m_fScore = 0.0;
m_fHyper = 100.0;
m_dExpect = 1000.0;
m_dProteinExpect = 1000.0;
m_mapCount.clear();
m_mapScore.clear();
if(sizeof(size_t) == 8) {
m_tCurrentSequence = (size_t)0xAFFFFFFF;
}
else {
m_tCurrentSequence = (size_t)0xAFFF;
}
m_vseqBest.clear();
return true;
}
};
#endif
tandem-linux-13-09-01-1/src/saxmodhandler.h 0000664 0001750 0001750 00000020217 10743470712 020430 0 ustar langella langella /*
Copyright (C) 2008 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
// File version: 2006-02-17
/*
* saxBIOMLhandler.h contains the override methods necessary for compatibility with
* BIOML file formats.
*/
#if !defined(SAXMODHANDLER_H)
#define SAXMODHANDLER_H
#include "saxhandler.h"
#include
/**
* Uses eXpat SAX parser to parse Bioml data to obtain protein information.
*/
class SAXModHandler : public SAXHandler
{
public:
SAXModHandler();
~SAXModHandler();
// -----------------------------------------------------------------------
// Overrides of SAXHandler functions
// -----------------------------------------------------------------------
/**
* Receive notification of the start of an element.
*
* By default, do nothing. Application writers may override this
* method in a subclass to take specific actions at the start of
* each element (such as allocating a new tree node or writing
* output to a file).
*/
void startElement(const XML_Char *el, const XML_Char **attr);
/**
* Receive notification of the end of an element.
*
* By default, do nothing. Application writers may override this
* method in a subclass to take specific actions at the end of
* each element (such as finalising a tree node or writing
* output to a file).
*/
void endElement(const XML_Char *el);
/**
* Receive notification of character data inside an element.
*
* By default, do nothing. Application writers may override this
* method to take specific actions for each chunk of character data
* (such as adding the data to a node or buffer, or printing it to
* a file).
*/
map m_mapMod;
private:
// Flags indicating parser is inside a particular tag.
bool m_bProtein;
bool m_bAa;
string m_strId;
string m_strMods;
};
#endif //SAXMODHANDLER_H
tandem-linux-13-09-01-1/src/mrefine.h 0000664 0001750 0001750 00000017653 10311635160 017225 0 ustar langella langella /*
Copyright (C) 2005 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
#ifndef MREFINE_H
#define MREFINE_H
// File version: 2005-09-01
#include "mplugin.h"
class mprocess;
class XmlParameter;
//forward class declarations for refinement classes
class mpmods;
class mxxcleavage;
class mtermmods;
class mpam;
class mrefine : public mplugin
{
public:
mrefine();
~mrefine(void);
bool set_mprocess(mprocess *_p); //overridden by each plugin refinement object
virtual bool refine(); //overridden by each plugin refinement object
double m_dMaxExpect;
private:
bool initialize(); //perform start up initialization
mprocess *m_pProcess; //initialized with the current mprocess object and used to set the mprocess object for each plugin refinement object
// refinement objects
mpmods *m_pPMods; // the object that is used to process potential modifications
mxxcleavage *m_pXXCleavage; // the object that is used to process unanticipated cleavages
mtermmods *m_pTermMods; // the object that is used to process terminal modifications
mpam *m_pPam; // the object that is used to process point mutations
};
/*
* mrefinemanager is used to organize and facilitate the creation of mrefine objects
*/
class mrefinemanager
{
public:
static const char* TYPE;
static mrefine* create_mrefine(XmlParameter &_x);
static void register_factory(const char* _spec, mpluginfactory* _f);
};
/*
* mrefinefactory_tandem implements a factory for creating mrefine
* instances.
*/
class mrefinefactory_tandem : public mpluginfactory
{
public:
mrefinefactory_tandem();
virtual mplugin* create_plugin();
};
#endif
tandem-linux-13-09-01-1/src/xmlparameter.h 0000664 0001750 0001750 00000016676 10307572736 020323 0 ustar langella langella /*
Copyright (C) 2003 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
#ifndef XMLPARAMETER_H
#define XMLPARAMETER_H
// File version: 2003-07-01
/*
* XmlParameter stores a string-to-string map that corresponds to note nodes in the input
* file that have the type="input" value. An input file is loaded, the appropriate nodes
* recorded and the map accessed through get and set functions. The map is single values, so
* the previous value associated with a key string are overwriten by subsequent calls to
* the set method. The use of keys in a map is recorded.
*/
class XmlParameter
{
public:
XmlParameter(void);
virtual ~XmlParameter(void);
bool get(string &_k,string &_v); // retreive a string associated with a key
bool getpath(string &_p); // retrieve the current path to the input file
bool load(string &_p); // load the maps from an input XML file
bool set(string &_k,string &_v); // set a string associated with a key
xMap m_mapParam; // a string-string map type, defined in stdafx.h
bMap m_mapUsed; // a string-bool map type, defined in stdafx.h
protected:
string m_strXmlPath; // the path to the input file
};
#endif
tandem-linux-13-09-01-1/src/saxbiomlhandler.h 0000664 0001750 0001750 00000020524 11202354211 020736 0 ustar langella langella /*
Copyright (C) 2006 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
// File version: 2006-02-17
/*
* saxBIOMLhandler.h contains the override methods necessary for compatibility with
* BIOML file formats.
*/
#if !defined(SAXBIOMLHANDLER_H)
#define SAXBIOMLHANDLER_H
#include "saxhandler.h"
#include
/**
* Uses eXpat SAX parser to parse Bioml data to obtain protein information.
*/
class SAXBiomlHandler : public SAXHandler
{
public:
SAXBiomlHandler();
~SAXBiomlHandler();
// -----------------------------------------------------------------------
// Overrides of SAXHandler functions
// -----------------------------------------------------------------------
/**
* Receive notification of the start of an element.
*
* By default, do nothing. Application writers may override this
* method in a subclass to take specific actions at the start of
* each element (such as allocating a new tree node or writing
* output to a file).
*/
void startElement(const XML_Char *el, const XML_Char **attr);
/**
* Receive notification of the end of an element.
*
* By default, do nothing. Application writers may override this
* method in a subclass to take specific actions at the end of
* each element (such as finalising a tree node or writing
* output to a file).
*/
void endElement(const XML_Char *el);
/**
* Receive notification of character data inside an element.
*
* By default, do nothing. Application writers may override this
* method to take specific actions for each chunk of character data
* (such as adding the data to a node or buffer, or printing it to
* a file).
*/
void characters(const XML_Char *s, int len);
vector m_vseqBest; // a vector of msequences used in the model refinement process
set m_setSeq;
set m_setPaths;
vector m_vstrPaths;
private:
// Flags indicating parser is inside a particular tag.
bool m_bProtein;
bool m_bPeptide;
msequence m_seqCurrent;
};
#endif //SAXBIOMLHANDLER_H
tandem-linux-13-09-01-1/src/mprocess.h 0000664 0001750 0001750 00000047666 12205422433 017443 0 ustar langella langella /*
Copyright (C) 2003 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
#ifndef MPROCESS_H
#define MPROCESS_H
// File version: 2003-08-01
// File version: 2004-03-01
// File version: 2004-11-01
typedef map SEQMAP;
#include
#include
#include "mcleave.h"
#include "mspectrumcondition.h"
#include "mreport.h"
#include "msequenceserver.h"
#include "mplugin.h"
#include "msemistate.h"
#include "mrefine.h"
#include
typedef map > MSEQMAP;
/*
* the process object coordinates the function of tandem. it contains the information
* loaded from the input XML file in the m_xmlValues object and performance
* information in the m_xmlPerformance object. The mass spectra to be analyzed are
* in the m_vSpectra vector container. A set of input parameters are used to
* initialize constants that are used in processing the mass spectra.
*/
class merrors
{
public:
merrors(void) {
m_bPpm = true;
m_bIsotope = false;
m_dPlus = 20.0;
m_dMinus = 20.0;
}
virtual ~merrors(void) { }
bool m_bPpm;
bool m_bIsotope;
double m_dPlus;
double m_dMinus;
bool check(double _s,double _m) {
double dDelta = _s - _m;
double dPlus = m_dPlus;
double dMinus = m_dMinus;
if(m_bPpm) {
dPlus *= _m*1.0e-6;
dMinus*= _m*1.0e-6;
}
if(dDelta < 0.0) {
if(dDelta >= dMinus) {
return true;
}
}
else {
if(dDelta <= dPlus) {
return true;
}
}
if(!m_bIsotope) {
return false;
}
if(_s > 1000.0) {
dDelta -= 1.008664916;
if(dDelta < 0.0) {
if(dDelta >= dMinus) {
return true;
}
}
else {
if(dDelta <= dPlus) {
return true;
}
}
}
if(_s > 1500.0) {
dDelta -= 1.008664916;
if(dDelta < 0.0) {
if(dDelta >= dMinus) {
return true;
}
}
else {
if(dDelta <= dPlus) {
return true;
}
}
}
return false;
}
};
class mprocesslog
{
public:
mprocesslog() { }
virtual ~mprocesslog() { }
bool open(string &_s) {
m_ofLog.open(_s.c_str());
if(m_ofLog.fail()) {
return false;
}
return true;
}
bool log(string &_m) {
if(!m_ofLog.is_open()) {
return false;
}
time_t tValue;
time(&tValue);
struct tm *tmValue = localtime(&tValue);
char pLine[256];
strftime(pLine, 255,"%Y-%m-%d %H:%M:%S",tmValue);
m_ofLog << pLine << "\t" << _m.c_str() << "\n";
m_ofLog.flush();
return true;
}
bool log(const char *_m) {
if(!m_ofLog.is_open()) {
return false;
}
string strValue = _m;
return log(strValue);
}
bool close() {
if(!m_ofLog.is_open()) {
return false;
}
m_ofLog.close();
return true;
}
private:
ofstream m_ofLog;
};
class mprocess
{
public:
mprocess(void);
virtual ~mprocess(void);
bool serialize(void); //serializes the m_vMI data elements in m_vSpectra onto the disk to save space during calculation
bool restore(void); //restores the m_vMI data elements from disk
bool removeMI(void);
vector m_vstrPaths;
mprocesslog m_prcLog;
bool add_spectra(vector &_v); // adds the spectra contained in _v to m_vSpectra
bool clear(); // clears a selection of vectors in the mprocess object
unsigned long get_thread(); // retrieves the number of the current thread (0 - 15)
unsigned long get_threads(); // retrieves the total number of threads running (1 - 16)
size_t get_protein_count(); // gets the total number of proteins read
size_t get_peptide_count(); // gets the total number of peptides used
size_t get_total_residues(); // gets the total number of residues read
size_t get_valid(); // gets the number of valid peptide models
double get_error_estimate() {return m_dEsum;}
size_t get_unique(); // gets the number of valid peptide models
long get_reversed(); // gets the number of reversed peptide models
double get_threshold(); // gets the number of valid peptide models
bool load(const char *_f,mprocess *_p = NULL); // loads input parameters
bool load_saps(mprocess *_p); // loads sap information, if it exists
bool load_annotation(mprocess *_p); // loads sequence annotation information, if it exists
virtual bool merge_spectra(); // adds externally generated mspectrum vector to m_vSpectra
virtual bool merge_spectra(vector &_s); // adds externally generated mspectrum vector to m_vSpectra
bool merge_map(SEQMAP &_s); // adds externally generated mspectrum vector to m_vSpectra
bool merge_statistics(const mprocess *_p); // adds externally generated spectra to this object
bool process(void); // performs identifications based on the input parameters
bool refine(void); // controls the protein model refinement process
bool report(void); // produces the XML output report, using an mreport class
bool pyro_check(const char _c);
bool pyro_reset(void);
bool score_each_sequence(); // generates a score for all sequences in the m_svrSequences object
bool set_threads(const unsigned long _t); // sets the object's thread number
bool set_thread(const unsigned long _t); // sets the object's thread number
int set_round(const int _r) { m_iCurrentRound = _r; return m_iCurrentRound;}
virtual bool load_sequences();
XmlParameter m_xmlPerformance; // stores process performance parameters
XmlParameter m_xmlValues; // store process input parameters
vector m_vSpectra; // store spectra to be analyzed
SEQMAP m_mapSequences; // a map containing all of the protein sequences discovered, indexed by their m_tUid value
vector m_vseqBest; // a vector of msequences used in the model refinement process
vector m_vstrModifications; //a vector containing the strings defining fixed modifications for a protein
size_t m_tRefineModels; // total number of models generated by refinement
size_t m_tRefineInput; // total number of sequences included in a refinement session
size_t m_tRefinePartial; // the number of models discovered to have partial cleavage
size_t m_tRefineUnanticipated; // the number of models discovered to have unanticpated cleavage
size_t m_tRefineNterminal; // the number of models discovered to have modified N-terminii
size_t m_tRefineCterminal; // the number of models discovered to have modified C-terminii
size_t m_tRefinePam; // the number of models discovered to have point mutations
double m_dRefineTime; // the time required to perform a refinement
size_t m_tActive; // total number of models remaining after each refinement step
bool m_bRefineCterm; //true if processing 'refine, potential C-terminus modifications'. Set in mrefine::refine and
//checked in score(), so the start position can be set to the length of the protein sequence
// minus the value for 'refine, potential N-terminus modification position limit' before performing cleavage
vector m_viQuality; // contains the data quality scoring vector
map m_mapCrc;
size_t m_tTemp;
bool m_bReversedOnly;
bool m_bSaps;
bool m_bAnnotation;
bool m_bMinimalAnnotation;
bool m_bSerialize;
bool m_bCheckNg;
bool m_bSkyline;
bool m_bUseCrc;
string m_strSkyline;
double m_dNt;
double m_dNtAve;
double m_dNg;
double m_dNgAve;
float m_fMaxMass;
float m_fMaxZ;
enum {
I_Y = 0x01,
I_B = 0x02,
I_X = 0x04,
I_A = 0x08,
I_C = 0x10,
I_Z = 0x20,
} ion_type; // enum for referencing information about specific ion types.
protected:
/*
* refinement classes are declared friend classes so they can access private member variables and functions.
* If a new refinement class is added to the project, include a declaration here
*/
friend class mrefine;
friend class mpmods;
friend class mxxcleavage;
friend class mtermmods;
friend class mpam;
protected:
string m_strLastMods;
int m_iCurrentRound;
bool m_bPermute;
bool m_bPermuteHigh;
bool m_bCrcCheck;
bool m_bQuickAcetyl;
bool m_bQuickPyro;
double m_dEsum;
set m_setRound;
vector m_vstrSaps;
vector m_vstrMods;
map m_mapAnnotation;
msemistate m_semiState; // maintains the state of the semi-enzymatic cleavage state machine
mpyrostate m_pyroState; // maintains the state of the pyrolidone carboxylic acid detection state machine
merrors m_errValues;
double m_dSearchTime; // total time elapsed during a protein modeling session process
long m_lIonCount; // minimum sum of detected ions that are significant enough to store a sequence
unsigned long m_lThread; // thread number of this object
unsigned long m_lThreads; // the total number of threads current active
long m_lReversed; // the total number of peptides found where the reversed sequence was better than the forward sequence
double m_dThreshold; // the current expectation value threshold
double m_tContrasted; // the number of spectra subtracted using contrast angle redundancy detection
long m_lStartMax; // set the maximum distance from N-terminus for a peptide
// normally set at an impossibly large value = 100,000,000
// for ragged N-terminii with potential modifications, set at a low but plausible value = 50
long m_lCStartMax;
char *m_pSeq; // a character pointer, used for temporary sequence information
bool m_bUn; // if true, cleave at all residues. if false, use cleavage specification in data input.
bool m_bUseHomologManagement; // set to true to use homologue management
size_t m_tMinResidues; // the minimum peptide length that will be scored
size_t m_tMissedCleaves; // the maximum number of cleavage sites that can be missed
size_t m_tPeptideCount; // the total number of peptide sequences generated during a process
size_t m_tPeptideScoredCount; // the total number of peptide sequences scored during a process
size_t m_tProteinCount; // the total number of protein sequences considered during a process
size_t m_tSpectra; // the total number of spectra being modeled
size_t m_tSpectraTotal; // the total number of spectra in the input file
size_t m_tValid; // the number of valid peptide models
size_t m_tTotalResidues; // the number of residues read
size_t m_tSeqSize; // current length of the m_pSeq character array
size_t m_tUnique; // the number of unique peptides found in a result
string m_strOutputPath; // the path name of the XML output file
mcleave m_Cleave; // the specification for a cleavage peptide bond
msequence m_seqCurrent; // the msequence object that is currently being scored
#ifdef X_P3
p3msequenceServer m_svrSequences; // the msequenceServer object that provides msequences to msequenceCollection
#else
msequenceServer m_svrSequences; // the msequenceServer object that provides msequences to msequenceCollection
#endif
mspectrumcondition m_specCondition; // the mspectrumcondition object that cleans up and normalized
// spectra for further processing
mscore* m_pScore; // the object that is used to score sequences and spectra
mrefine* m_pRefine; // the object that is used to refine models
bool charge(void); // adds additional charge states to the list of spectra, resulting in +1, +2 and +3 all being represented
virtual bool clean_sequences(void); // remove sequences no longer required from m_mapSequences
double dot(const size_t _f,const size_t _s,const float _r,const bool _t); // calculated inner product between two spectrum vectors
bool create_rollback(vector &_v); // create a temporary rollback vector
virtual bool create_score(const msequence &_s,const size_t _v,
const size_t _w, const long _m,const bool _p); // generates scores for a sequence
double expect_protein(const unsigned long _c,const unsigned long _t,
const unsigned long _n,const double _d); // assigns an expectation value for a protein
bool load_best_vector(void); // creates a new m_vseqBest vector and marks assigned spectra inactive
bool mark_repeats(void); // checks for repeated assignments of the same peptide sequence
bool modify(void); // sets the initial residue modification parameters in the m_seqUtil object
bool refine_model(void); // the method that refines protein models
bool report_all(); // create a report that contains all peptide models, regardless of expectation value
bool report_valid(const double _d); // create a report that only contains valid peptide models (expect < m_dThreshold)
bool report_stochastic(const double _d); // create a report that contains only stochastic peptide models (expect > m_dThreshold)
bool report_expect(const double _m); // calculates expectation values for the report
bool report_sort(void); // sorts peptide models for use in the report
bool residues(); // estimates the minimum number of residues that can possibly be contained in a peptide
bool rollback(vector &_v,const double _m,const double _f);
bool score(const msequence &_s); // generates scores of an msequence object
bool score_single(const msequence &_s); // generates scores of an msequence object
bool score_terminus(const string &_s); // attempts to find N or C terminal modified peptides
bool score_terminus_single(const string &_s); // attempts to find N or C terminal modified peptides
bool spectra(void); // loads the m_vSpectra object using the m_specCondition object
bool spectra_force(string &_t,string &_v); // forces the spectrum loader to use a specified file type
bool subtract(void); // remove redundant mass spectra
uint64_t crc(const string &_s);
uint64_t *m_pCrcTable;
bool initialize_crc(void);
MSEQMAP m_mapDups;
// SEQMAP m_mapTest; used to test the utility of the crc function, see commented code in mprocess::score
size_t m_tDuplicates;
size_t m_tDuplicateIds;
bool insert_dups(void);
virtual bool taxonomy(void); // loads the taxonomy setting into the m_svrSequences object
};
#include "p3mprocess.h"
#endif
tandem-linux-13-09-01-1/src/Makefile 0000664 0001750 0001750 00000002674 12211626235 017070 0 ustar langella langella #makefile for c++ programs
#change the name of the executable to use for "any" project
EXECUTABLE = ../bin/tandem.exe
#EXECUTABLE = ../bin/p3.exe
LINKCC = $(CXX)
#CXXFLAGS denotes flags for the C++ compiler
CXX = g++
#uncomment this line if you are using gcc 4.x
CXXFLAGS = -O2 -DGCC4_3
#CXXFLAGS = -O2 -DGCC4_3 -DX_P3
#CXXFLAGS = -O2 -DGCC4_3 -DPLUGGABLE_SCORING -DX_P3
#LDFLAGS = -lpthread -L/usr/lib -lm /usr/local/lib/libexpat.a -static-libstdc++
#LDFLAGS = -lpthread -L/usr/lib -lm /usr/local/lib/libexpat.a
LDFLAGS = -lpthread -L/usr/lib -lm -lexpat
SRCS := $(wildcard *.cpp)
OBJS := $(patsubst %.cpp,%.o,$(wildcard *.cpp))
DEPS := $(patsubst %.o,%.d,$(OBJS))
all: $(EXECUTABLE)
#define the components of the program, and how to link them
#these components are defined as dependencies; that is they must be up-to-date before the code is linked
$(EXECUTABLE): $(DEPS) $(OBJS)
$(LINKCC) $(CXXFLAGS) -o $(EXECUTABLE) $(OBJS) $(LDFLAGS)
#specify the dep files depend on the cpp files
%.d: %.cpp
$(CXX) -M $(CXXFLAGS) $< > $@
$(CXX) -M $(CXXFLAGS) $< | sed s/\\.o/.d/ > $@
clean:
-rm $(OBJS) $(EXECUTABLE) $(DEPS) *~
explain:
@echo "The following info represents the program:"
@echo "Final exec name: $(EXECUTABLE)"
@echo "Source files: $(SRCS)"
@echo "Object files: $(OBJS)"
@echo "Dep files: $(DEPS)"
depend: $(DEPS)
@echo "Deps are now up-to-date."
-include $(DEPS)
tandem-linux-13-09-01-1/src/p3mprocess.cpp 0000664 0001750 0001750 00000060367 12156671045 020244 0 ustar langella langella /*
Copyright (C) 2003-2004 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
// File version: 2004-02-01
// File version: 2004-03-01
// File version: 2004-03-01
// File version: 2004-07-12
// File version: 2004-10-05
// File version: 2004-11-01
// File version: 2005-01-01
/*
* the process object coordinates the function of tandem. it contains the information
* loaded from the input XML file in the m_xmlValues object and performance
* information in the m_xmlPerformance object. The mass spectra to be analyzed are
* in the m_vSpectra vector container. A set of input parameters are used to
* initialize constants that are used in processing the mass spectra.
* NOTE: see tandem.cpp for an example of how to use an mprocess class
* NOTE: mprocess uses cout to report errors. This may not be appropriate for
* many applications. Feel free to change this to a more appropriate mechanism
*/
#include "stdafx.h"
#include
#include
#include "msequence.h"
#include "msequencecollection.h"
#include "msequenceserver.h"
#include "msequtilities.h"
#include "mspectrum.h"
#include "loadmspectrum.h"
#include "xmlparameter.h"
#include "xmltaxonomy.h"
#include "mscore.h"
#include "mprocess.h"
#include "saxbiomlhandler.h"
#include "saxsaphandler.h"
#include "mbiomlreport.h"
#include "mrefine.h"
// #define TANDEM_EXACT 1
/*
* global less than operators to be used in sort operations
*/
p3mprocess::p3mprocess(void)
{
string strKey = "process, version";
string strValue = "X! P3 ";
strValue += VERSION;
m_xmlPerformance.set(strKey,strValue);
}
p3mprocess::~p3mprocess(void)
{
}
/*
* taxonomy uses the taxonomy information in the input XML file to load
* the msequenceServer member object with file path names to the required
* sequence list files (FASTA format only in the initial release). If these
*/
bool p3mprocess::taxonomy()
{
#ifdef X_P3
string strValue;
string strKey = "list path, taxonomy information";
m_xmlValues.get(strKey,strValue);
string strTaxonPath = strValue;
strKey = "protein, taxon";
m_xmlValues.get(strKey,strValue);
long lReturn = m_svrSequences.u_load_file(strTaxonPath,strValue);
/*
* return false if the load_file method fails
*/
if(lReturn == 2) {
cout << "\nThe taxonomy parameter file \"" << strTaxonPath.c_str();
cout << "\" did not contain the value \"" << strValue.c_str() << "\".\nCheck your settings and try again.\n";
return false;
}
if(lReturn == 1) {
cout << "\nThe taxonomy parameter file \"" << strTaxonPath.c_str();
cout << "\" could not be found.\nCheck your settings and try again.\n";
return false;
}
return true;
#endif
return true;
}
/*
* merge_spectra takes an mspectrum vector from an external source and merges it
* with the m_vSpectra vector. this method is used to combine information obtained
* from other threads with this mprocess object
*/
bool p3mprocess::merge_spectra()
{
string strKey = "refine, maximum valid expectation value";
string strValue;
m_xmlValues.get(strKey,strValue);
double dMaxExpect = 0.01;
if(strValue.size() > 0) {
dMaxExpect = atof(strValue.c_str());
}
size_t a = 0;
size_t b = 0;
size_t c = 0;
{
while(a < m_vSpectra.size()) {
m_vSpectra[a].m_hHyper.model();
m_vSpectra[a].m_hHyper.set_protein_factor(1.0);
a++;
}
a = 0;
double dExpect = 1.0;
SEQMAP::iterator itValue;
while(a < m_vSpectra.size()) {
b = 0;
dExpect = (double)m_vSpectra[a].m_hHyper.expect_protein(m_pScore->hconvert(m_vSpectra[a].m_fHyper));
if(dExpect <= dMaxExpect) {
m_vSpectra[a].m_bActive = false;
while(b < m_vSpectra[a].m_vseqBest.size()) {
c = 0;
while(c < m_vseqBest.size()) {
if(m_vSpectra[a].m_vseqBest[b].m_tUid == m_vseqBest[c].m_tUid) {
break;
}
c++;
}
if(c == m_vseqBest.size()) {
m_vseqBest.push_back(m_vSpectra[a].m_vseqBest[b]);
itValue = m_mapSequences.find(m_vseqBest[c].m_tUid);
m_vseqBest[c].m_strSeq = ((*itValue).second.c_str());
m_vseqBest[c].m_vDomains.clear();
}
b++;
if(m_bUseHomologManagement && b >= 5) {
break;
}
}
}
m_vSpectra[a].reset();
a++;
}
}
return true;
}
bool p3mprocess::merge_spectra(vector &_s)
{
string strKey = "refine, maximum valid expectation value";
string strValue;
m_xmlValues.get(strKey,strValue);
double dMaxExpect = 0.01;
if(strValue.size() > 0) {
dMaxExpect = atof(strValue.c_str());
}
size_t a = 0;
size_t b = 0;
size_t c = 0;
{
while(a < _s.size()) {
_s[a].m_hHyper.model();
_s[a].m_hHyper.set_protein_factor(1.0);
a++;
if(m_bUseHomologManagement && _s[a].m_vseqBest.size() > 5) {
_s[a].m_vseqBest.erase(_s[a].m_vseqBest.begin()+5,_s[a].m_vseqBest.end());
}
}
a = 0;
double dExpect = 1.0;
SEQMAP::iterator itValue;
while(a < _s.size()) {
b = 0;
dExpect = (double)_s[a].m_hHyper.expect_protein(_s[a].m_fHyper);
if(dExpect <= dMaxExpect) {
while(b < _s[a].m_vseqBest.size()) {
c = 0;
while(c < m_vseqBest.size()) {
if(_s[a].m_vseqBest[b].m_tUid == m_vseqBest[c].m_tUid) {
break;
}
c++;
}
if(c == m_vseqBest.size()) {
m_vseqBest.push_back(_s[a].m_vseqBest[b]);
itValue = m_mapSequences.find(m_vseqBest[c].m_tUid);
m_vseqBest[c].m_strSeq = ((*itValue).second.c_str());
m_vseqBest[c].m_vDomains.clear();
}
b++;
}
}
_s[a].reset();
a++;
}
}
return true;
}
/*
* merge_map adds new values to the existing m_mapSequences map.
*/
bool p3mprocess::merge_map(SEQMAP &_s,DESMAP &_d)
{
SEQMAP::iterator itValue = _s.begin();
SEQMAP::iterator itEnd = _s.end();
while(itValue != itEnd) {
if(m_mapSequences.find(itValue->first) == m_mapSequences.end()) {
m_mapSequences.insert(*itValue);
}
itValue++;
}
DESMAP::iterator itV = _d.begin();
DESMAP::iterator itE = _d.end();
while(itV != itE) {
if(m_mapDesc.find(itV->first) == m_mapDesc.end()) {
m_mapDesc.insert(*itV);
}
itV++;
}
return true;
}
/*
* merge_map adds new values to the existing m_mapSequences map.
*/
bool p3mprocess::merge_map(SEQMAP &_s)
{
return mprocess::merge_map(_s);
}
bool p3mprocess::load_sequences()
{
#ifdef X_P3
vector vSeq;
string strValue;
string strKey = "list path, taxonomy information";
m_xmlValues.get(strKey,strValue);
string strTaxonPath = strValue;
strKey = "protein, taxon";
m_xmlValues.get(strKey,strValue);
long lReturn = m_svrSequences.load_file(strTaxonPath,strValue);
/*
* return false if the load_file method fails
*/
if(lReturn == 2) {
cout << "\nThe taxonomy parameter file \"" << strTaxonPath.c_str();
cout << "\" did not contain the value \"" << strValue.c_str() << "\".\nCheck your settings and try again.\n";
return false;
}
if(lReturn == 1) {
cout << "\nThe taxonomy parameter file \"" << strTaxonPath.c_str();
cout << "\" could not be found.\nCheck your settings and try again.\n";
return false;
}
m_svrSequences.u_maps(m_mapDesc,vSeq);
size_t a = 0;
DESMAP mapDes;
m_mapSequences.clear();
while(a < vSeq.size()) {
mapDes[vSeq[a].m_strDes] = a;
m_mapSequences[vSeq[a].m_tUid] = vSeq[a].m_strSeq;
a++;
}
m_vstrPaths = m_svrSequences.m_vstrPaths;
a = 0;
while(a < m_vseqBest.size()) {
m_vseqBest[a] = vSeq[mapDes[m_vseqBest[a].m_strDes]];
a++;
}
strKey = "refine, sequence path";
// Check for input sequences for refinement to be loaded from a bioml file
// Loading done for each thread
m_xmlValues.get(strKey,strValue);
if(strValue.size() > 0) {
SAXBiomlHandler saxFile;
saxFile.setFileName(strValue.c_str());
saxFile.parse();
a = 0;
while(a < saxFile.m_vseqBest.size()) {
if(m_mapSequences.find(saxFile.m_vseqBest[a].m_tUid) == m_mapSequences.end()) {
short int iPath = saxFile.m_vseqBest[a].m_siPath;
string strPath = saxFile.m_vstrPaths[iPath];
size_t b = 0;
while(b < m_vstrPaths.size()) {
if(strPath == m_vstrPaths[b]) {
saxFile.m_vseqBest[a].m_siPath = (short int)b;
break;
}
b++;
}
if(b == m_vstrPaths.size()) {
m_vstrPaths.push_back(strPath);
saxFile.m_vseqBest[a].m_siPath = (short int)(m_vstrPaths.size() - 1);
}
m_vseqBest.push_back(saxFile.m_vseqBest[a]);
m_mapSequences.insert(SEQMAP::value_type(saxFile.m_vseqBest[a].m_tUid,saxFile.m_vseqBest[a].m_strSeq));
}
a++;
}
}
#endif
return true;
}
bool p3mprocess::clean_sequences(void)
{
map mapValue;
map::iterator itMap;
size_t a = 0;
size_t b = 0;
size_t tLength = m_vSpectra.size();
size_t tBest = 0;
while(a < tLength) {
b = 0;
tBest = m_vSpectra[a].m_vseqBest.size();
while(b < tBest) {
mapValue[m_vSpectra[a].m_vseqBest[b].m_tUid] = 1;
b++;
}
a++;
}
SEQMAP::iterator itValue = m_mapSequences.begin();
while(itValue != m_mapSequences.end()) {
itMap = mapValue.find((*itValue).first);
if(itMap == mapValue.end()) {
m_mapSequences.erase(itValue);
itValue = m_mapSequences.begin();
}
else {
itValue++;
}
}
DESMAP::iterator itV = m_mapDesc.begin();
while(itV != m_mapDesc.end()) {
itMap = mapValue.find((*itV).second);
if(itMap == mapValue.end()) {
m_mapDesc.erase(itV);
itV = m_mapDesc.begin();
}
else {
itV++;
}
}
return true;
}
/*
* create_score takes an msequence object and a start and an end sequence position
* and saves that msequence, its mdomain and scoring in the spectrum that has just
* been scored. equivalent msequence objects (based on their hyper score)
* are stored sequentially in a vector in the mspectrum object
*/
bool p3mprocess::create_score(const msequence &_s,const size_t _v,const size_t _w,const long _m,bool _p)
{
long lIonCount = 0;
float fScore = -1.0;
float fHyper = -1.0;
size_t a = 0;
size_t b = 0;
size_t c = 0;
bool bOk = false;
bool bDom = false;
long lCount = 0;
bool bIonCheck = false;
bool bMassCheck = false;
/*
* score each mspectrum identified as a candidate in the m_pScore->m_State object
*/
while(lCount < m_pScore->m_State.m_lEqualsS) {
a = m_pScore->m_State.m_plEqualsS[lCount];
lCount++;
lIonCount = 0;
fScore = 1.0;
fHyper = 1.0;
m_pScore->m_lMaxCharge = (long)(m_vSpectra[a].m_fZ+0.1);
/*
* in versions prior to 2004.03.01, spectra with m_bActive == false were
* rejected at this point, to save time & because of a problem with
* multiple recording of the same sequence. starting with 2004.03.01,
* the later problem has been corrected, and because of point mutation
* analysis, it has become important to reexamine all sequences.
*/
fScore = m_pScore->score(a);
fHyper = m_pScore->m_fHyper;
/*
* If the convolution score is greater than 2.0, record information in the ion-type histograms
*/
if(fScore > 2.0) {
m_tPeptideScoredCount++;
lIonCount = m_pScore->m_plCount[mscore::S_B] + m_pScore->m_plCount[mscore::S_Y];
lIonCount += m_pScore->m_plCount[mscore::S_C] + m_pScore->m_plCount[mscore::S_Z];
lIonCount += m_pScore->m_plCount[mscore::S_A] + m_pScore->m_plCount[mscore::S_X];
m_vSpectra[a].m_hHyper.add(m_pScore->hconvert(fHyper));
m_vSpectra[a].m_hConvolute.add(m_pScore->hconvert(fScore));
m_vSpectra[a].m_chBCount.add(m_pScore->m_plCount[mscore::S_A] +
m_pScore->m_plCount[mscore::S_B] +
m_pScore->m_plCount[mscore::S_C]);
m_vSpectra[a].m_chYCount.add(m_pScore->m_plCount[mscore::S_X] +
m_pScore->m_plCount[mscore::S_Y] +
m_pScore->m_plCount[mscore::S_Z]);
if(m_bCrcCheck && _p && m_vSpectra[a].m_hHyper.m_ulCount < 400) {
m_bPermute = true;
}
else if(m_vSpectra[a].m_dMH > 3000.0 && m_vSpectra[a].m_hHyper.m_ulCount < 400) {
m_bPermuteHigh = true;
}
}
bIonCheck = false;
if(lIonCount > m_lIonCount) {
if( (m_pScore->m_plCount[mscore::S_A] || m_pScore->m_plCount[mscore::S_B] || m_pScore->m_plCount[mscore::S_C]) &&
(m_pScore->m_plCount[mscore::S_X] || m_pScore->m_plCount[mscore::S_Y] || m_pScore->m_plCount[mscore::S_Z])) {
bIonCheck = true;
}
}
bMassCheck = m_errValues.check(m_vSpectra[a].m_dMH,m_pScore->seq_mh());
if(!_p) {
bMassCheck = false;
}
/*
* if the same score has been recorded for another peptide in the same msequence object,
* add a domain to that object, but do not update the entire object
*/
unsigned char ucM = 0;
if(_m < 0) {
ucM = 0;
}
else {
ucM = (unsigned char)_m;
}
if(bMassCheck && bIonCheck && fHyper == m_vSpectra[a].m_fHyper && m_vSpectra[a].m_tCurrentSequence == _s.m_tUid) {
vector vAa;
mdomain domValue;
domValue.m_vAa.clear();
double dDelta = 0.0;
if(m_pScore->get_aa(vAa,_v,dDelta)) {
b = 0;
while(b < vAa.size()) {
domValue.m_vAa.push_back(vAa[b]);
b++;
}
}
if(fabs(dDelta) > 2.5) {
domValue.m_fScore = fScore;
domValue.m_fHyper = fHyper;
domValue.m_dMH = m_pScore->seq_mh();
// m_fDelta was changed to m_dDelta in 2006.02.01
domValue.m_dDelta = m_vSpectra[a].m_dMH - m_pScore->seq_mh();
domValue.m_lE = (int)_w;
domValue.m_lS = (int)_v;
domValue.m_lMissedCleaves = ucM;
domValue.m_bUn = m_bUn;
unsigned char lType = 1;
unsigned long sType = 1;
while(lType < m_pScore->m_lType+1) {
m_vSpectra[a].m_mapScore[lType] = m_pScore->m_pfScore[sType];
m_vSpectra[a].m_mapCount[lType] = (m_pScore->m_plCount[sType]);
lType *= 2;
sType++;
}
b = 0;
bOk = true;
while(bOk && b < m_vSpectra[a].m_vseqBest.back().m_vDomains.size()) {
if(domValue == m_vSpectra[a].m_vseqBest.back().m_vDomains[b]){
bOk = false;
}
b++;
}
if(bOk) {
m_vSpectra[a].m_vseqBest.back().m_vDomains.push_back(domValue);
}
}
}
/*
* if the same hyper score has been recorded for a different msequence object, retain that
* object and add the new msequence to the back of the m_vseqBest vector
*/
else if(bMassCheck && bIonCheck && fHyper == m_vSpectra[a].m_fHyper) {
vector vAa;
msequence seqValue;
mdomain domValue;
domValue.m_vAa.clear();
double dDelta = 0.0;
if(m_pScore->get_aa(vAa,_v,dDelta)) {
b = 0;
while(b < vAa.size()) {
domValue.m_vAa.push_back(vAa[b]);
b++;
}
}
if(fabs(dDelta) > 2.5) {
domValue.m_fScore = fScore;
domValue.m_fHyper = fHyper;
domValue.m_dMH = m_pScore->seq_mh();
// m_fDelta was changed to m_dDelta in 2006.02.01
domValue.m_dDelta = m_vSpectra[a].m_dMH - m_pScore->seq_mh();
domValue.m_lE = (int)_w;
domValue.m_lS = (int)_v;
domValue.m_lMissedCleaves = ucM;
domValue.m_bUn = m_bUn;
unsigned char lType = 1;
unsigned long sType = 1;
while(lType < m_pScore->m_lType+1) {
m_vSpectra[a].m_mapScore[lType] = m_pScore->m_pfScore[sType];
m_vSpectra[a].m_mapCount[lType] = (m_pScore->m_plCount[sType]);
lType *= 2;
sType++;
}
seqValue = _s;
seqValue.m_strSeq = " ";
m_mapSequences.insert(SEQMAP::value_type(_s.m_tUid,_s.m_strSeq));
m_mapDesc.insert(DESMAP::value_type(_s.m_strDes,_s.m_tUid));
seqValue.m_vDomains.clear();
seqValue.m_vDomains.push_back(domValue);
bOk = true;
b = 0;
while(bOk && b < m_vSpectra[a].m_vseqBest.size()) {
if(m_vSpectra[a].m_vseqBest[b].m_tUid == _s.m_tUid) {
c = 0;
bDom = true;
while(bDom && c < m_vSpectra[a].m_vseqBest[b].m_vDomains.size()) {
if(m_vSpectra[a].m_vseqBest[b].m_vDomains[c] == domValue) {
bDom = false;
bOk = false;
}
c++;
}
if(bDom) {
m_vSpectra[a].m_vseqBest[b].m_vDomains.push_back(domValue);
bOk = false;
}
}
b++;
}
if(bOk) {
m_vSpectra[a].m_tCurrentSequence = _s.m_tUid;
seqValue.m_iRound = m_iCurrentRound;
m_vSpectra[a].m_vseqBest.push_back(seqValue);
}
}
}
/*
* if the hyper score is the best found so far for the mspectrum, delete the old msequence
* objects and record this one.
*/
else if(bMassCheck && bIonCheck && fHyper > m_vSpectra[a].m_fHyper && lIonCount > m_lIonCount) {
vector vAa;
msequence seqValue;
mdomain domValue;
domValue.m_vAa.clear();
double dDelta = 0.0;
if(m_pScore->get_aa(vAa,_v,dDelta)) {
b = 0;
while(b < vAa.size()) {
domValue.m_vAa.push_back(vAa[b]);
b++;
}
}
if(fabs(dDelta) > 2.5) {
if(m_vSpectra[a].m_fHyper > m_vSpectra[a].m_fScoreNext) {
m_vSpectra[a].m_fScoreNext = m_vSpectra[a].m_fScore;
m_vSpectra[a].m_fHyperNext = m_vSpectra[a].m_fHyper;
}
m_vSpectra[a].m_fScore = fScore;
m_vSpectra[a].m_fHyper = fHyper;
domValue.m_fScore = fScore;
domValue.m_fHyper = fHyper;
domValue.m_lE = (int)_w;
domValue.m_lS = (int)_v;
domValue.m_lMissedCleaves = ucM;
domValue.m_dMH = m_pScore->seq_mh();
// m_fDelta was changed to m_dDelta in 2006.02.01
domValue.m_dDelta = m_vSpectra[a].m_dMH - m_pScore->seq_mh();
domValue.m_bUn = m_bUn;
unsigned char lType = 1;
unsigned long sType = 1;
while(lType < m_pScore->m_lType+1) {
m_vSpectra[a].m_mapScore[lType] = m_pScore->m_pfScore[sType];
m_vSpectra[a].m_mapCount[lType] = m_pScore->m_plCount[sType];
lType *= 2;
sType++;
}
seqValue = _s;
seqValue.m_strSeq = " ";
m_mapSequences.insert(SEQMAP::value_type(_s.m_tUid,_s.m_strSeq));
m_mapDesc.insert(DESMAP::value_type(_s.m_strDes,_s.m_tUid));
seqValue.m_vDomains.clear();
seqValue.m_vDomains.push_back(domValue);
m_vSpectra[a].m_tCurrentSequence = _s.m_tUid;
seqValue.m_iRound = m_iCurrentRound;
m_vSpectra[a].m_vseqBest.clear();
m_vSpectra[a].m_vseqBest.push_back(seqValue);
}
}
else if(_p && bMassCheck && bIonCheck && fHyper > m_vSpectra[a].m_fHyperNext) {
m_vSpectra[a].m_fScoreNext = fScore;
m_vSpectra[a].m_fHyperNext = fHyper;
}
}
return true;
}
tandem-linux-13-09-01-1/src/mspectrumcondition.cpp 0000664 0001750 0001750 00000065074 12136510115 022060 0 ustar langella langella /*
Copyright (C) 2003 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
// File version: 2003-07-01
// File version: 2005-01-01
/*
* the mspectrumcondition object analyzes tandem mass spectra and alters them to
* be suitable for searching. it loads a set of parameters from an XmlParameters
* object and uses those values for the spectrum analysis. this object contains
* more "get" and "set" type methods than most of the other objects in this
* project: there was considerable experimentation necessary to refine the spectrum
* analysis methods and these additional methods were used for these experiments.
*
* mspectrumcondition performs a series of operations on a spectrum list to make
* compatible with the scoring methods. the spectrum can be normalized, adjacent
* peaks removed, parent ion masses excluded, low mass parents excluded, highly
* charged parents excluded, low mass fragments excluded, and low intensity
* fragment ions excluded.
*/
#include "stdafx.h"
#include
#include "msequence.h"
#include "msequencecollection.h"
#include "msequenceserver.h"
#include "msequtilities.h"
#include "mspectrum.h"
#include "xmlparameter.h"
#include "saxsaphandler.h"
#include "mspectrumcondition.h"
#include "mscore.h"
bool lessThanMImz(const mi &_l,const mi &_r);
/*
* global less than operator for mi classes: to be used in sort operations to achieve
* list ordered from lowest to highest m/z
*/
bool lessThanMImz(const mi &_l,const mi &_r)
{
return _l.m_fM < _r.m_fM;
}
/*
* mspectrumcondition performs a series of operations on a spectrum list to make
* compatible with the scoring methods. the spectrum can be normalized, adjacent
* peaks removed, parent ion masses excluded, low mass parents excluded, highly
* charged parents excluded, low mass fragments excluded, and low intensity
* fragment ions excluded.
*/
mspectrumcondition::mspectrumcondition(void)
{
m_bUseMaxPeaks = true;
m_bUseDynamicRange = true;
m_bUseMinMass = true;
m_bUseParent = true;
m_bUseLowestMass = true;
m_bUseMinSize = true;
m_bUseNoiseSuppression = true;
m_bUseChargeSuppression = true;
m_bCondition = true;
m_bUseNeutralLoss = false;
m_bUsePhosphoDetection = false;
m_tMaxPeaks = 50;
m_fDynamicRange = 100.0;
m_fMinMass = 500.0;
m_fLowestMass = 150.0;
m_fParentLower = 2.0;
m_fParentUpper = 2.0;
m_lMinSize = 5;
m_lMaxCharge = 3;
m_fNeutralLoss = 0.0;
m_fNeutralLossWidth = 0.0;
m_fFactor = 1.0;
m_fMaxZ = 4.0;
}
mspectrumcondition::~mspectrumcondition(void)
{
}
/*
* condition is the method called by mprocess to condition a particular mspectrum object.
* by checking the appropriate flags, the various properties of a spectrum can be altered,
* and the spectrum rejected if it does not pass the appropriate tests.
* NOTE: the order of operations is important here: do not change it unless you feel you
* fully understand why things were done in this order.
*/
bool mspectrumcondition::condition(mspectrum &_s, mscore &_score)
{
/*
* bail out if conditioning has been turned off
*/
if(m_bUsePhosphoDetection) {
if(!find_loss(_s,98.0,3.0)) {
return false;
}
}
if(m_bUseAllowedNeutralLosses) {
size_t m = 0;
size_t tSize = m_vdNeutralLosses.size();
bool bOK = false;
while(m < tSize && !bOK) {
bOK = find_loss(_s,(float)m_vdNeutralLosses[m],(float)0.5,(float)0.05);
m++;
}
if(!bOK) {
return false;
}
}
_s.m_vMINeutral.clear();
sort(_s.m_vMI.begin(),_s.m_vMI.end(),lessThanMImz);
if(_s.m_vdStats.size() == 0) {
vector::iterator itMI = _s.m_vMI.begin();
vector::iterator itEnd = _s.m_vMI.end();
double dSum = 0.0;
double dMax = 0.0;
while(itMI != itEnd) {
if(dMax < itMI->m_fI) {
dMax = itMI->m_fI;
}
dSum += itMI->m_fI;
itMI++;
}
_s.m_vdStats.push_back(dSum);
_s.m_vdStats.push_back(dMax);
_s.m_vdStats.push_back(m_fFactor);
}
if(_s.m_fZ > m_fMaxZ) {
return false;
}
if(!m_bCondition) {
return true;
}
/*
* give the score object a chance to perform score specific modifications
* or veto this spectrum.
*/
if(!_score.precondition(_s)) {
return false;
}
/*
* check the parent ion charge and return false if it is too large
*/
if(m_bUseNoiseSuppression) {
/*
* check the parent ion mass against the minimum mass allowed (about 600.0 is usually safe)
*/
if(m_bUseMinMass) {
if(_s.m_dMH < m_fMinMass)
return false;
}
if(m_bUseChargeSuppression) {
if((long)(_s.m_fZ+0.5) > m_lMaxCharge) {
return false;
}
}
}
size_t tSize = _s.m_vMI.size();
size_t a = 0;
float fMaxI = 0;
/*
* this method doesn't really remove isotopes: it cleans up multiple intensities within one Dalton
* of each other.
*/
// sort(_s.m_vMI.begin(),_s.m_vMI.end(),lessThanMImz);
remove_isotopes(_s);
/*
* remove ions near the parent ion m/z
*/
if(m_bUseParent) {
remove_parent(_s);
}
/*
* remove low mass immonium ions prior to normalization
*/
if(m_bUseLowestMass) {
remove_low_masses(_s);
}
/*
* normalize the spectrum
*/
vector::iterator itMI = _s.m_vMI.begin();
vector::iterator itEnd = _s.m_vMI.end();
double dSum = 0.0;
double dMax = 0.0;
while(itMI != itEnd) {
if(dMax < itMI->m_fI) {
dMax = itMI->m_fI;
}
dSum += itMI->m_fI;
itMI++;
}
_s.m_vdStats.clear();
_s.m_vdStats.push_back(dSum);
_s.m_vdStats.push_back(dMax);
_s.m_vdStats.push_back(m_fFactor);
if(m_bUseDynamicRange) {
dynamic_range(_s);
}
if(m_bUseNeutralLoss) {
remove_neutral(_s);
}
/*
* reject the spectrum if there aren't enough peaks
*/
if(m_bUseMinSize) {
if((long)_s.m_vMI.size() < m_lMinSize)
return false;
}
/*
* check to see if the spectrum has the characteristics of noise
*/
if(m_bUseNoiseSuppression) {
if(is_noise(_s)) {
return false;
}
}
/*
* retrieve the N most intense peaks
*/
clean_isotopes(_s);
if(m_bUseMaxPeaks) {
sort(_s.m_vMI.begin(),_s.m_vMI.end(),lessThanMI);
remove_small(_s);
}
sort(_s.m_vMI.begin(),_s.m_vMI.end(),lessThanMImz);
itMI = _s.m_vMI.begin();
itEnd = _s.m_vMI.end();
dSum = 0.0;
dMax = 0.0;
while(itMI != itEnd) {
if(dMax < itMI->m_fI) {
dMax = itMI->m_fI;
}
dSum += itMI->m_fI;
itMI++;
}
_s.m_vdStats[0] = dSum*m_fFactor;
_s.m_vdStats[1] = dMax*m_fFactor;
_s.m_vdStats[2] = m_fFactor;
return true;
}
/*
* check_neutral looks for the loss of water or ammonia in a spectrum. this
* method is not used in this implementation: it is for further experimentation
*/
bool mspectrumcondition::find_loss(mspectrum &_s,const float _d,const float _t,const float _p)
{
sort(_s.m_vMI.begin(),_s.m_vMI.end(),lessThanMI);
vector::iterator itMI = _s.m_vMI.begin();
vector::iterator itEnd = _s.m_vMI.end();
float fMax = itMI->m_fI;
while(itMI != itEnd) {
if(itMI->m_fI > fMax) {
fMax = itMI->m_fI;
}
itMI++;
}
fMax *= _p;
itMI = _s.m_vMI.begin();
float fD = (float)(1.007276 + ((_s.m_dMH - 1.007276 - _d)/_s.m_fZ));
while(itMI != itEnd) {
if(fabs(itMI->m_fM - fD) <= _t && itMI->m_fI >= fMax) {
return true;
}
itMI++;
}
return false;
}
/*
* check_neutral looks for the loss of water or ammonia in a spectrum. this
* method is not used in this implementation: it is for further experimentation
*/
bool mspectrumcondition::check_neutral(mspectrum &_s)
{
sort(_s.m_vMI.begin(),_s.m_vMI.end(),lessThanMI);
vector::iterator itMI = _s.m_vMI.begin();
vector::iterator itEnd = _s.m_vMI.end();
vector::iterator itLast = itMI;
unsigned long a = 0;
unsigned long lCount = 0;
float fM = 0.0;
while(a < 10) {
itMI = itLast;
while(itMI != itEnd && itMI->m_fM < 300.0) {
itMI++;
}
if(itMI == itEnd)
break;
fM = (float)(itMI->m_fM - 18.0);
itMI++;
itLast = itMI;
while(itMI < itEnd) {
if(fabs(fM - itMI->m_fM) < 2.5) {
lCount++;
break;
}
itMI++;
}
a++;
}
if(lCount < 1)
return false;
return true;
}
/*
* remove isotopes removes multiple entries within 0.95 Da of each other, retaining
* the highest value. this is necessary because of the behavior of some peak
* finding routines in commercial software
*/
bool mspectrumcondition::remove_isotopes(mspectrum &_s)
{
if(_s.m_vMI.size() < 2)
return true;
vector::iterator itMI_ecriture = _s.m_vMI.begin();
vector::iterator itMI_lecture = _s.m_vMI.begin() + 1;
vector::const_iterator itMI_fin = _s.m_vMI.end();
vector miTemp;
float fEcriture = itMI_ecriture->m_fM;
while( itMI_lecture != itMI_fin )
{
if( ( itMI_lecture->m_fM - fEcriture) >= 0.95 || itMI_lecture->m_fM < 200.0)
{
miTemp.push_back(*itMI_ecriture);
itMI_ecriture = itMI_lecture;
fEcriture = itMI_ecriture->m_fM;
}
else if( itMI_lecture->m_fI > itMI_ecriture->m_fI )
{
*itMI_ecriture = *itMI_lecture;
}
itMI_lecture++;
}
miTemp.push_back(*itMI_ecriture);
_s.m_vMI = miTemp;
return true;
}
/*
* clean_isotopes removes peaks that are probably C13 isotopes
*/
bool mspectrumcondition::clean_isotopes(mspectrum &_s)
{
if( _s.m_vMI.size() < 2 )
return true;
vector::iterator itMI_ecriture = _s.m_vMI.begin();
vector::iterator itMI_lecture = _s.m_vMI.begin() + 1;
vector::const_iterator itMI_fin = _s.m_vMI.end();
vector miTemp;
float fEcriture = itMI_ecriture->m_fM;
while( itMI_lecture != itMI_fin )
{
if( ( itMI_lecture->m_fM - fEcriture) >= 1.5 || itMI_lecture->m_fM < 200.0)
{
miTemp.push_back(*itMI_ecriture);
itMI_ecriture = itMI_lecture;
fEcriture = itMI_ecriture->m_fM;
}
else if( itMI_lecture->m_fI > itMI_ecriture->m_fI )
{
*itMI_ecriture = *itMI_lecture;
}
itMI_lecture++;
}
miTemp.push_back(*itMI_ecriture);
_s.m_vMI = miTemp;
return true;
}
/*
* is_noise attempts to determine if the spectrum is simply noise. if the spectrum
* does not have any peaks within a window near the parent ion mass, it is considered
* noise.
*/
bool mspectrumcondition::is_noise(mspectrum &_s)
{
if(!m_bUseNoiseSuppression)
return false;
size_t a = 0;
size_t tSize = _s.m_vMI.size();
float fZ = _s.m_fZ;
float fMax = (float)(_s.m_dMH/fZ);
if(fZ == 1) {
fMax = (float)(_s.m_dMH - 600.0);
}
if(fZ == 2) {
fMax = (float)(_s.m_dMH - 600.0);
}
while(a < tSize) {
if(_s.m_vMI[a].m_fM > fMax)
return false;
a++;
}
return true;
}
/*
* load makes internal copies of the relavent parameters found in the XmlParameter object
*/
bool mspectrumcondition::load(XmlParameter &_x)
{
string strKey;
string strValue;
strKey = "spectrum, dynamic range";
m_bUseDynamicRange = _x.get(strKey,strValue);
if(m_bUseDynamicRange) {
m_fDynamicRange = (float)atof(strValue.c_str());
}
strKey = "spectrum, total peaks";
m_bUseMaxPeaks = _x.get(strKey,strValue);
if(m_bUseMaxPeaks) {
m_tMaxPeaks = atoi(strValue.c_str());
}
strKey = "spectrum, minimum peaks";
m_bUseMinSize = _x.get(strKey,strValue);
if(m_bUseMinSize) {
m_lMinSize = atoi(strValue.c_str());
}
strKey = "spectrum, minimum parent m+h";
m_bUseMinMass = _x.get(strKey,strValue);
if(m_bUseMinMass) {
m_fMinMass = (float)atof(strValue.c_str());
}
strKey = "spectrum, minimum fragment mz";
m_bUseLowestMass = _x.get(strKey,strValue);
if(m_bUseLowestMass) {
m_fLowestMass = (float)atof(strValue.c_str());
}
strKey = "spectrum, use conditioning";
bool bCondition = _x.get(strKey,strValue);
if(bCondition) {
if(strValue == "yes") {
m_bCondition = true;
}
else if(strValue == "no") {
m_bCondition = false;
}
else {
m_bCondition = true;
}
}
strKey = "spectrum, use noise suppression";
bool bUseNoiseSuppression = _x.get(strKey,strValue);
if(bUseNoiseSuppression) {
if(strValue == "yes") {
m_bUseNoiseSuppression = true;
}
else if(strValue == "no") {
m_bUseNoiseSuppression = false;
}
else {
m_bUseNoiseSuppression = true;
}
}
strKey = "spectrum, use neutral loss window";
bool bUseNeutralLoss = _x.get(strKey,strValue);
if(bUseNeutralLoss) {
if(strValue == "yes") {
m_bUseNeutralLoss = true;
}
else if(strValue == "no") {
m_bUseNeutralLoss = false;
}
else {
m_bUseNeutralLoss = false;
}
}
if(m_bUseNeutralLoss) {
strKey = "spectrum, neutral loss window";
if(_x.get(strKey,strValue)) {
m_fNeutralLossWidth = (float)atof(strValue.c_str());
}
strKey = "spectrum, neutral loss mass";
if(_x.get(strKey,strValue)) {
m_fNeutralLoss = (float)atof(strValue.c_str());
}
}
strKey = "spectrum, allowed neutral losses";
m_bUseAllowedNeutralLosses = _x.get(strKey,strValue);
if(m_bUseAllowedNeutralLosses) {
m_vdNeutralLosses.clear();
string strV;
size_t tLength = strValue.size();
size_t a = 0;
while(a < tLength) {
if(!isspace(strValue[a])) {
strV += strValue[a];
}
a++;
}
tLength = strV.size();
if(tLength > 0) {
a = 0;
size_t b = strV.find(',',a);
double dValue = 0.0;
while(b != strV.npos) {
dValue = atof(strV.substr(a,b-a).c_str());
if(dValue != 0.0) {
m_vdNeutralLosses.push_back(dValue);
}
a = b + 1;
b = strV.find(',',a);
}
dValue = atof(strV.substr(a,tLength-a).c_str());
if(dValue != 0.0) {
m_vdNeutralLosses.push_back(dValue);
}
if(m_vdNeutralLosses.empty()) {
m_bUseAllowedNeutralLosses = false;
}
}
else {
m_bUseAllowedNeutralLosses = false;
}
}
strKey = "spectrum, maximum parent charge";
if(_x.get(strKey,strValue)) {
m_fMaxZ = (float)atof(strValue.c_str());
if(m_fMaxZ < 1.0) {
m_fMaxZ = 4.0;
}
}
return true;
}
/*
* use the dynamic range parameter to set the maximum intensity value for the spectrum.
* then remove all peaks with a normalized intensity < 1
*/
bool mspectrumcondition::dynamic_range(mspectrum &_s)
{
if (!m_bUseDynamicRange) {
return false;
}
size_t tSize = _s.m_vMI.size();
float fI = 1.0;
if(tSize > 0) {
fI = _s.m_vMI[0].m_fI;
}
size_t a = 0;
while(a < tSize) {
if(_s.m_vMI[a].m_fI > fI) {
fI = _s.m_vMI[a].m_fI;
}
a++;
}
m_fFactor = fI/m_fDynamicRange;
vector::iterator itMI = _s.m_vMI.begin();
while(itMI != _s.m_vMI.end()) {
itMI->m_fI /= m_fFactor;
if(itMI->m_fI < 1.0) {
itMI = _s.m_vMI.erase(itMI);
}
else {
itMI++;
}
}
return true;
}
/*
* limit the total number of peaks used
*/
bool mspectrumcondition::remove_small(mspectrum &_s)
{
if(!m_bUseMaxPeaks) {
return false;
}
vector::iterator itMI = _s.m_vMI.begin();
// The test line was changed in 2006.09.01 to correct a problem
// created by VC++ 2005. This new version uses a strict bounds checking
// style for STL iterators, that cause a run time error if an iterator
// longer than .end() is produced by incrementing the iterator. The previous
// test was
//
// if(itMI+m_tMaxPeaks < _s.m_vMI.end())
//
// which caused the error when the statement was false.
if(m_tMaxPeaks < _s.m_vMI.size()) {
_s.m_vMI.erase(itMI+m_tMaxPeaks,_s.m_vMI.end());
}
return true;
}
/*
* set up m/z regions to ignore: those immediately below the m/z of the parent ion
* which will contain uninformative neutral loss ions, and those immediately above
* the parent ion m/z, which will contain the parent ion and its isotope pattern
*/
bool mspectrumcondition::remove_parent(mspectrum &_s)
{
if(!m_bUseParent)
return false;
vector::iterator itMI = _s.m_vMI.begin();
float fParentMz = (float)(1.00727+(_s.m_dMH - 1.00727)/_s.m_fZ);
while(itMI != _s.m_vMI.end()) {
if(fParentMz - itMI->m_fM >= 0.0 && fParentMz - itMI->m_fM < m_fParentLower/_s.m_fZ) {
itMI = _s.m_vMI.erase(itMI);
}
else if(itMI->m_fM - fParentMz > 0.0 && itMI->m_fM - fParentMz < m_fParentUpper/_s.m_fZ) {
itMI = _s.m_vMI.erase(itMI);
}
else {
itMI++;
}
}
return true;
}
/*
* remove_low_masses deletes peaks with m/z values below the m_fLowestMass member value
*/
bool mspectrumcondition::remove_low_masses(mspectrum &_s)
{
if(!m_bUseLowestMass)
return false;
vector::iterator itMI = _s.m_vMI.begin();
while(itMI != _s.m_vMI.end()) {
if(itMI->m_fM > m_fLowestMass) {
break;
}
itMI++;
}
_s.m_vMI.erase(_s.m_vMI.begin(),itMI);
return true;
}
/*
* remove_neutral
*/
bool mspectrumcondition::remove_neutral(mspectrum &_s)
{
if(!m_bUseNeutralLoss)
return false;
vector::iterator itMI = _s.m_vMI.begin();
while(itMI != _s.m_vMI.end()) {
if(fabs((_s.m_dMH - itMI->m_fM) - m_fNeutralLoss) <= m_fNeutralLossWidth) {
_s.m_vMINeutral.push_back(*itMI);
itMI = _s.m_vMI.erase(itMI);
}
else {
itMI++;
}
}
return true;
}
/*
* get_noise_suppression gets the current value of the m_bUseNoiseSuppression member
*/
bool mspectrumcondition::get_noise_suppression(void)
{
return m_bUseNoiseSuppression;
}
/*
* set_max_peaks sets the current value of the m_tMaxPeaks member
*/
bool mspectrumcondition::set_max_peaks(const long _p)
{
m_tMaxPeaks = _p;
return true;
}
/*
* set_min_size sets the current value of the m_lMinSize member
*/
bool mspectrumcondition::set_min_size(const long _p)
{
m_lMinSize = _p;
return true;
}
/*
* set_dynamic_range sets the current value of the m_fDynamicRange member
*/
bool mspectrumcondition::set_dynamic_range(const float _p)
{
m_fDynamicRange = _p;
return true;
}
/*
* set_parent_exclusion sets the current value of the m_fParentLower & m_fParentUpper members
*/
bool mspectrumcondition::set_parent_exclusion(const float _l,const float _u)
{
m_fParentLower = _l;
m_fParentUpper = _u;
return true;
}
/*
* set_min_mass sets the current value of the m_fMinMass member
*/
bool mspectrumcondition::set_min_mass(const float _m)
{
m_fMinMass = _m;
return true;
}
/*
* set_max_charge sets the current value of the m_lMaxCharge member
*/
bool mspectrumcondition::set_max_charge(const long _m)
{
m_lMaxCharge = _m;
return true;
}
/*
* set_lowest_mass sets the current value of the m_fLowestMass member
*/
bool mspectrumcondition::set_lowest_mass(const float _m)
{
m_fLowestMass = _m;
return true;
}
/*
* use_condition sets the current value of the m_bCondition member
*/
bool mspectrumcondition::use_condition(const bool _f)
{
m_bCondition = _f;
return m_bCondition;
}
/*
* use_min_size sets the current value of the m_bUseMinSize member
*/
bool mspectrumcondition::use_min_size(const bool _f)
{
m_bUseMinSize = _f;
return m_bUseMinSize;
}
/*
* use_max_peaks sets the current value of the m_bUseMaxPeaks member
*/
bool mspectrumcondition::use_max_peaks(const bool _f)
{
m_bUseMaxPeaks = _f;
return m_bUseMaxPeaks;
}
/*
* use_charge_suppression sets the current value of the m_bUseChargeSuppression member
*/
bool mspectrumcondition::use_charge_suppression(const bool _f)
{
m_bUseChargeSuppression = _f;
return m_bUseChargeSuppression;
}
/*
* use_dynamic_range sets the current value of the m_bUseDynamicRange member
*/
bool mspectrumcondition::use_dynamic_range(const bool _f)
{
m_bUseDynamicRange = _f;
return m_bUseDynamicRange;
}
/*
* use_noise_suppression sets the current value of the m_bUseNoiseSuppression member
*/
bool mspectrumcondition::use_noise_suppression(const bool _f)
{
m_bUseNoiseSuppression = _f;
return m_bUseNoiseSuppression;
}
/*
* use_lowest_mass sets the current value of the m_bUseLowestMass member
*/
bool mspectrumcondition::use_lowest_mass(const bool _f)
{
m_bUseLowestMass = _f;
return m_bUseLowestMass;
}
/*
* use_min_mass sets the current value of the m_bUseMinMass member
*/
bool mspectrumcondition::use_min_mass(const bool _f)
{
m_bUseMinMass = _f;
return m_bUseMinMass;
}
/*
* use_parent_exclusion sets the current value of the m_bUseParent member
*/
bool mspectrumcondition::use_parent_exclusion(const bool _f)
{
m_bUseParent = _f;
return m_bUseParent;
}
tandem-linux-13-09-01-1/src/loadmspectrum.cpp 0000664 0001750 0001750 00000076742 12124577160 021027 0 ustar langella langella /*
Copyright (C) 2003-2004 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
// File version: 2004-01-07
// File version: 2005-11-15
/*
* loadspectrum.cpp contains the override methods necessary for compatibility with
* various mass spectrum file formats. See loadspectrum.h for additional details.
*/
#include "stdafx.h"
#include
#include "msequence.h"
#include "mspectrum.h"
#include "loadmspectrum.h"
#include
#include "base64.h"
loadgaml::loadgaml( vector& _vS, mspectrumcondition& _sC, mscore& _m)
: handler(_vS, _sC, _m)
{
}
loadgaml::~loadgaml(void)
{
}
bool loadgaml::get()
{
handler.parse();
return true;
}
bool loadgaml::open(string &_s)
{
/*
* copy the file pathname into m_strPath
*/
m_strPath = _s;
/*
* try to open the file and bail out if it isn't available
*/
/*
* test for the file extension .bioml
*/
/*
* check the open file to see if it is a BIOML file
* Verification tres tres sommaire
* scoop up the first 100000 characters and then test for
* & _vS, mspectrumcondition& _sC, mscore& _m)
: handler(_vS, _sC, _m)
{
}
loadmzdata::~loadmzdata(void)
{
}
/*
*
* loadmzdata::get
* loadmzdata::open doit avoir ete lancee avant.
* parser est SAX2XMLparser* instantie par le constraucteur
* get met tous les spectres du fichier dans _vSpec
*
*/
bool loadmzdata::get()
{
handler.parse();
return true;
}
// loadmzdata::open
// La machine xml est ouverte ici en meme temps que le fichier d'entree.
// Elle sera refermee lorsque loadmzdata::get atteindra la fin de m_ifIn
bool loadmzdata::open(string &_s)
{
//Il faut trouver une fonction propre pour tester qu'un fichier est un mzXML
m_tId = 1;
/*
* copy the file pathname into m_strPath
*/
m_strPath = _s;
/*
* try to open the file and bail out if it isn't available
*/
/*
* check the open file to see if it is an mzData file
* Verification tres tres sommaire
* scoop up the first 100000 characters and then test for
* & _vS, mspectrumcondition& _sC, mscore& _m)
: handler(_vS, _sC, _m)
{
}
loadmzxml::~loadmzxml(void)
{
}
/*
*
* loadmzxml::get
* loadmzxml::open doit avoir ete lancee avant.
* parser est SAX2XMLparser* instantie par le constraucteur
* get met tous les spectres du fichier dans _vSpec
*
*/
bool loadmzxml::get()
{
return handler.parse();
}
// loadmzxml::open
// La machine xml est ouverte ici en meme temps que le fichier d'entree.
// Elle sera refermee lorsque loadmzxml::get atteindra la fin de m_ifIn
bool loadmzxml::open(string &_s)
{
//Il faut trouver une fonction propre pour tester qu'un fichier est un mzXML
m_tId = 1;
/*
* copy the file pathname into m_strPath
*/
m_strPath = _s;
/*
* try to open the file and bail out if it isn't available
*/
int iReturn = load_test(".mzxml");
if(iReturn == 0) {
return false;
}
else if(iReturn == 2) {
handler.setFileName( m_strPath.c_str() );
return true;
}
size_t tXml = m_strTest.find(" 0.0) {
miCurrent.m_fM = (float)atof(pLine);
pValue = pLine;
while(*pValue != '\0' && isspace(*pValue)) {
pValue++;
}
while(*pValue != '\0' && !isspace(*pValue)) {
pValue++;
}
miCurrent.m_fI = (float)atof(pValue);
specCurrent.m_vMI.push_back(miCurrent);
}
else if(strTemp.find("END IONS") != strTemp.npos) {
break;
}
}
delete pLine;
double dProton = 1.007276;
/*
* adjust the parent ion mass to be M+H (mspectrum expects an M+H)
*/
specCurrent.m_dMH = (specCurrent.m_dMH - dProton)*specCurrent.m_fZ + dProton;
specCurrent.m_tId = m_tId;
/*
* copy the temporary mspectrum into the input reference
*/
_m = specCurrent;
m_tId++;
/*
* if the file is finished, return false, otherwise return true
*/
if(m_ifIn.eof() || !m_ifIn.good()) {
m_ifIn.close();
return false;
}
return true;
}
bool loadmatrix::open(string &_s)
{
m_tId = 1;
/*
* copy the file pathname into m_strPath
*/
m_strPath = _s;
/*
* try to open the file and bail out if it isn't available
*/
m_ifIn.open(m_strPath.c_str());
if(m_ifIn.fail()) {
return false;
}
/*
* check the open file to see if it is a matrix science file
*/
char *pLine = new char[m_tSize];
m_ifIn.getline(pLine,256,m_cEol);
pLine[255] = '\0';
if(strlen(pLine) == 255) {
m_cEol = 0x0D;
}
m_ifIn.close();
m_ifIn.clear();
m_ifIn.open(m_strPath.c_str());
m_ifIn.getline(pLine,m_tSize-1,m_cEol);
pLine[m_tSize-1] = '\0';
bool bOk = false;
long lCount = 0;
string strTemp;
while(!bOk && !m_ifIn.eof() && lCount < 4096) {
strTemp = pLine;
if(strTemp.find("BEGIN IONS") != strTemp.npos) {
bOk = true;
}
lCount++;
m_ifIn.getline(pLine,m_tSize-1,m_cEol);
pLine[m_tSize-1] = '\0';
}
m_ifIn.close();
/*
* return false if there were no matrix science spectrum tags
*/
if(!bOk) {
delete pLine;
return false;
}
/*
* if it is a matrix science file, clear the stream and reopen it for calls from get
*/
m_ifIn.clear();
m_ifIn.open(m_strPath.c_str());
delete pLine;
return true;
}
// loadmatrix::open_force
// forces the opening of a Matrix Science Generic format file
bool loadmatrix::open_force(string &_s)
{
m_tId = 1;
/*
* copy the file pathname into m_strPath
*/
m_strPath = _s;
/*
* try to open the file and bail out if it isn't available
*/
m_ifIn.open(m_strPath.c_str());
if(m_ifIn.fail()) {
return false;
}
m_ifIn.close();
/*
* return false if there were no matrix science spectrum tags
*/
m_ifIn.clear();
m_ifIn.open(m_strPath.c_str());
return true;
}
loadpkl::loadpkl(void)
{
}
loadpkl::~loadpkl(void)
{
}
bool loadpkl::get(mspectrum &_m)
{
char *pLine = new char[m_tSize];
char *pValue;
bool bFirst = true;
long lId = 0;
mi miCurrent;
bool bNext = true;
/*
* create a temporary mspectrum object
*/
mspectrum specCurrent;
specCurrent.m_strDescription = "no description";
double dProton = 1.007276;
specCurrent.m_fZ = 2.0;
while(bNext && m_ifIn.good() && !m_ifIn.eof()) {
m_ifIn.getline(pLine,m_tSize-1,m_cEol);
/*
* find the next spectrum in the file - the stream should still be connected
*/
if(atof(pLine) != 0.0) {
if(bFirst) {
specCurrent.clear_intensity_values();
/*
* load the parent m/z value
*/
specCurrent.m_dMH = atof(pLine);
pValue = pLine;
while(*pValue != '\0' && isspace(*pValue)) {
pValue++;
}
while(*pValue != '\0' && !isspace(*pValue)) {
pValue++;
}
/*
* find and skip the parent ion intensity
*/
while(*pValue != '\0' && isspace(*pValue)) {
pValue++;
}
while(*pValue != '\0' && !isspace(*pValue)) {
pValue++;
}
/*
* load the parent charge value
*/
if(*pValue != '\0') {
specCurrent.m_fZ = (float)atof(pValue);
}
/*
* convert the parent m/z value into M+H, as required by mspectrum definition
*/
specCurrent.m_dMH = (specCurrent.m_dMH - dProton)*specCurrent.m_fZ + dProton;
bFirst = false;
}
else {
/*
* load fragment ion m/z values and intensities
*/
miCurrent.m_fM = (float)atof(pLine);
pValue = pLine;
while(*pValue != '\0' && isspace(*pValue)) {
pValue++;
}
while(*pValue != '\0' && !isspace(*pValue)) {
pValue++;
}
miCurrent.m_fI = (float)atof(pValue);
while(*pValue != '\0' && isspace(*pValue)) {
pValue++;
}
while(*pValue != '\0' && !isspace(*pValue)) {
pValue++;
}
if(pValue != '\0' && strlen(pValue) > 2) {
specCurrent.m_strDescription = pValue;
}
specCurrent.m_vMI.push_back(miCurrent);
}
}
else {
if(specCurrent.m_vMI.size() > 0) {
bNext = false;
}
bFirst = true;
}
}
delete pLine;
specCurrent.m_tId = m_tId;
/*
* copy the temporary mspectrum into the input reference
*/
_m = specCurrent;
m_tId++;
/*
* if the file is finished, return false, otherwise return true
*/
if(m_ifIn.eof()) {
m_ifIn.close();
return false;
}
return true;
}
bool loadpkl::open(string &_s)
{
m_tId = 1;
/*
* copy the file pathname into m_strPath
*/
m_strPath = _s;
/*
* try to open the file and bail out if it isn't available
*/
m_ifIn.open(m_strPath.c_str());
if(m_ifIn.fail()) {
return false;
}
/*
* check the open file to test for the value of the end-of-line character
*/
long lCount = 0;
char *pLine = new char[m_tSize];
m_ifIn.getline(pLine,256,m_cEol);
pLine[255] = '\0';
if(strlen(pLine) == 255) {
m_cEol = 0x0D;
}
m_ifIn.close();
m_ifIn.clear();
/*
* close, clear and reopen the stream to test to see if it is a PKL file
* the test is to see if the first non-blank line has three ASCII numbers separated
* by whitespace
*/
m_ifIn.open(m_strPath.c_str());
m_ifIn.getline(pLine,m_tSize-1,m_cEol);
while(!m_ifIn.eof() && atof(pLine) == 0.0 && lCount < 4096) {
m_ifIn.getline(pLine,m_tSize-1,m_cEol);
lCount++;
}
if(m_ifIn.eof()) {
m_ifIn.close();
delete pLine;
return false;
}
char *pValue = pLine;
while(*pValue != '\0' && isspace(*pValue)) {
pValue++;
}
while(*pValue != '\0' && !isspace(*pValue)) {
pValue++;
}
if(atof(pValue) == 0.0) {
m_ifIn.close();
delete pLine;
return false;
}
while(*pValue != '\0' && isspace(*pValue)) {
pValue++;
}
while(*pValue != '\0' && !isspace(*pValue)) {
pValue++;
}
if(atof(pValue) == 0.0) {
m_ifIn.close();
delete pLine;
return false;
}
m_ifIn.close();
m_ifIn.clear();
/*
* if the file format is ok, clear, close and reopen the stream, returning true
*/
m_ifIn.open(m_strPath.c_str());
delete pLine;
return true;
}
// loadpkl::open_force
// forces the opening of a PKL format file
bool loadpkl::open_force(string &_s)
{
m_tId = 1;
/*
* copy the file pathname into m_strPath
*/
m_strPath = _s;
/*
* try to open the file and bail out if it isn't available
*/
m_ifIn.open(m_strPath.c_str());
if(m_ifIn.fail()) {
return false;
}
/*
* check the open file to test for the value of the end-of-line character
*/
char *pLine = new char[m_tSize];
m_ifIn.getline(pLine,256,m_cEol);
pLine[255] = '\0';
if(strlen(pLine) == 255) {
m_cEol = 0x0D;
}
m_ifIn.close();
m_ifIn.clear();
/*
* if the file format is ok, clear, close and reopen the stream, returning true
*/
m_ifIn.open(m_strPath.c_str());
delete pLine;
return true;
}
loaddta::loaddta(void)
{
}
loaddta::~loaddta(void)
{
}
bool loaddta::get(mspectrum &_m)
{
char *pLine = new char[m_tSize];
char *pValue;
bool bFirst = true;
long lId = 0;
mi miCurrent;
bool bNext = true;
/*
* create a temporary mspectrum object
*/
mspectrum specCurrent;
specCurrent.m_strDescription = "no description";
while(bNext && m_ifIn.good() && !m_ifIn.eof()) {
m_ifIn.getline(pLine,m_tSize-1,m_cEol);
/*
* find the next spectrum
*/
if(atof(pLine) != 0.0) {
if(bFirst) {
specCurrent.clear_intensity_values();
/*
* load the parent M+H value
*/
specCurrent.m_dMH = atof(pLine);
pValue = pLine;
while(*pValue != '\0' && isspace(*pValue)) {
pValue++;
}
while(*pValue != '\0' && !isspace(*pValue)) {
pValue++;
}
/*
* load the parent charge value
*/
if(*pValue != '\0') {
specCurrent.m_fZ = (float)atof(pValue);
}
while(*pValue != '\0' && isspace(*pValue)) {
pValue++;
}
while(*pValue != '\0' && !isspace(*pValue)) {
pValue++;
}
if(pValue != '\0' && strlen(pValue) > 2) {
specCurrent.m_strDescription = pValue;
}
bFirst = false;
}
else {
/*
* load the m/z and intensity values
*/
miCurrent.m_fM = (float)atof(pLine);
pValue = pLine;
while(*pValue != '\0' && isspace(*pValue)) {
pValue++;
}
while(*pValue != '\0' && !isspace(*pValue)) {
pValue++;
}
miCurrent.m_fI = (float)atof(pValue);
specCurrent.m_vMI.push_back(miCurrent);
}
}
else {
if(specCurrent.m_vMI.size() > 0) {
bNext = false;
}
bFirst = true;
}
}
delete pLine;
specCurrent.m_tId = m_tId;
/*
* copy the temporary mspectrum into the input reference
*/
_m = specCurrent;
m_tId++;
/*
* if the file is finished, return false, otherwise return true
*/
if(m_ifIn.eof() || !m_ifIn.good() || specCurrent.m_vMI.empty()) {
m_ifIn.close();
return false;
}
return true;
}
bool loaddta::open(string &_s)
{
m_tId = 1;
/*
* copy the file pathname into m_strPath
*/
m_strPath = _s;
/*
* try to open the file and bail out if it isn't available
*/
m_ifIn.open(m_strPath.c_str());
if(m_ifIn.fail()) {
return false;
}
/*
* check the open file to test for the value of the end-of-line character
*/
char *pLine = new char[m_tSize];
m_ifIn.getline(pLine,256,m_cEol);
pLine[255] = '\0';
if(strlen(pLine) == 255) {
m_cEol = 0x0D;
}
m_ifIn.close();
m_ifIn.clear();
/*
* close, clear and reopen the stream to test to see if it is a DTA file
* the test is to see if the first non-blank line has two ASCII numbers separated
* by whitespace
* note: PKL files also pass this test, so test for PKL files before testing for DTA files
*/
m_ifIn.open(m_strPath.c_str());
m_ifIn.getline(pLine,m_tSize-1,m_cEol);
while(!m_ifIn.eof() && atof(pLine) == 0.0) {
m_ifIn.getline(pLine,m_tSize-1,m_cEol);
}
if(m_ifIn.eof()) {
m_ifIn.close();
delete pLine;
return false;
}
char *pValue = pLine;
while(*pValue != '\0' && isspace(*pValue)) {
pValue++;
}
while(*pValue != '\0' && !isspace(*pValue)) {
pValue++;
}
double dZ = atof(pValue);
if(dZ == 0.0 || ((double)(int)dZ != dZ)) {
m_ifIn.close();
delete pLine;
return false;
}
m_ifIn.close();
/*
* if the file format is ok, clear, close and reopen the stream, returning true
*/
m_ifIn.clear();
m_ifIn.open(m_strPath.c_str());
delete pLine;
return true;
}
// loaddta::open_force
// forces the opening of a DTA format file
bool loaddta::open_force(string &_s)
{
m_tId = 1;
/*
* copy the file pathname into m_strPath
*/
m_strPath = _s;
/*
* try to open the file and bail out if it isn't available
*/
m_ifIn.open(m_strPath.c_str());
if(m_ifIn.fail()) {
return false;
}
/*
* check the open file to test for the value of the end-of-line character
*/
char *pLine = new char[m_tSize];
m_ifIn.getline(pLine,256,m_cEol);
pLine[255] = '\0';
if(strlen(pLine) == 255) {
m_cEol = 0x0D;
}
m_ifIn.close();
m_ifIn.clear();
m_ifIn.open(m_strPath.c_str());
delete pLine;
return true;
}
loadcmn::loadcmn(void)
{
}
loadcmn::~loadcmn(void)
{
}
bool loadcmn::get(mspectrum &_m)
{
if(m_pFile == NULL || feof(m_pFile)) {
return false;
}
char *pLine = new char[256];
size_t tLength = 255;
long lId = 0;
mi miCurrent;
bool bNext = true;
/*
* create a temporary mspectrum object
*/
mspectrum specCurrent;
specCurrent.m_strDescription = "no description";
unsigned short sValue = 0;
unsigned char cValue = 0;
unsigned int iValue = 0;
float fValue = 0.0;
double dValue = 0.0;
size_t tS = 0;
tS = fread((void *)&iValue,sizeof(unsigned int),1,m_pFile);
m_tId = iValue;
tS = fread((void *)&dValue,sizeof(double),1,m_pFile);
specCurrent.m_dMH = dValue;
tS = fread((void *)&cValue,1,1,m_pFile);
specCurrent.m_fZ = (float)cValue;
if(m_iVersion == 2) {
unsigned int iValue = 0;
tS = fread((void *)&iValue,4,1,m_pFile);
if(iValue > tLength) {
tLength = iValue + 255;
delete pLine;
pLine = new char[tLength];
}
tS = fread((void *)pLine,1,iValue,m_pFile);
pLine[iValue] = '\0';
}
else {
tS = fread((void *)&cValue,1,1,m_pFile);
tS = fread((void *)pLine,1,(int)cValue,m_pFile);
pLine[cValue] = '\0';
}
specCurrent.m_strDescription = pLine;
if(strstr(pLine,":ETD")) {
specCurrent.m_uiType = I_C|I_Z;
}
else if(strstr(pLine,":CID") || strstr(pLine,":HCD")) {
specCurrent.m_uiType = I_B|I_Y;
}
fValue = 0.0;
tS = fread((void *)&fValue,sizeof(float),1,m_pFile);
float fIntensity = fValue;
cValue = 0;
tS = fread((void *)&cValue,1,1,m_pFile);
size_t tSize = (size_t)cValue;
fValue = 0.0;
tS = fread((void *)&fValue,sizeof(float),1,m_pFile);
tS = fread((void *)&cValue,1,1,m_pFile);
float fScale = fValue;
size_t a = 0;
tS = fread((void *)&sValue,2,1,m_pFile);
iValue = (unsigned int)sValue;
miCurrent.m_fM = (float)iValue/fScale;
specCurrent.m_vMI.push_back(miCurrent);
a++;
while(a < tSize) {
tS = fread((void *)&sValue,2,1,m_pFile);
iValue += (unsigned int)sValue;
miCurrent.m_fM = (float)iValue/fScale;
specCurrent.m_vMI.push_back(miCurrent);
a++;
}
a = 0;
double dSum = 0.0;
char cMax = 0;
while(a < tSize) {
tS = fread((void *)&cValue,1,1,m_pFile);
specCurrent.m_vMI[a].m_fI = (float)cValue;
if(cMax < cValue) {
cMax = cValue;
}
dSum += (double)cValue;
a++;
}
delete pLine;
specCurrent.m_vdStats.push_back(dSum*fIntensity);
specCurrent.m_vdStats.push_back((double)cMax*fIntensity);
specCurrent.m_vdStats.push_back((double)fIntensity);
specCurrent.m_tId = m_tId;
/*
* copy the temporary mspectrum into the input reference
*/
/*
* if the file is finished, return false, otherwise return true
*/
if(feof(m_pFile)) {
fclose(m_pFile);
return false;
}
_m = specCurrent;
return true;
}
bool loadcmn::open(string &_s)
{
m_iVersion = 1;
m_tId = 1;
/*
* copy the file pathname into m_strPath
*/
m_strPath = _s;
/*
* try to open the file and bail out if it isn't available
*/
m_pFile = fopen(m_strPath.c_str(),"rb");
if(m_pFile == NULL) {
return false;
}
/*
* check the open file to test for the value of the end-of-line character
*/
char *pLine = new char[m_tSize];
size_t tS = fread((void *)pLine,1,256,m_pFile);
pLine[255] = '\0';
string strTemp = pLine;
if(strTemp.find("CMN ") != 0) {
fclose(m_pFile);
return false;
}
if(pLine[64] != 0) {
m_iVersion = 2;
}
else {
m_iVersion = 1;
}
delete pLine;
return true;
}
// loaddta::open_force
// forces the opening of a DTA format file
bool loadcmn::open_force(string &_s)
{
return open(_s);
}
/*
loadmzml was added by Ron Beavis in August, 2008
*/
loadmzml::loadmzml( vector& _vS, mspectrumcondition& _sC, mscore& _m)
: handler(_vS, _sC, _m)
{
}
loadmzml::~loadmzml(void)
{
}
bool loadmzml::get()
{
handler.parse();
return true;
}
bool loadmzml::open(string &_s)
{
//Il faut trouver une fonction propre pour tester qu'un fichier est un mzXML
m_tId = 1;
/*
* copy the file pathname into m_strPath
*/
m_strPath = _s;
/*
* try to open the file and bail out if it isn't available
*/
int iReturn = load_test(".mzml");
if(iReturn == 0) {
return false;
}
else if(iReturn == 2) {
handler.setFileName( m_strPath.c_str() );
return true;
}
size_t tXml = m_strTest.find("
#include
#include "saxsaphandler.h"
#include "msequence.h"
#include "msequencecollection.h"
#include "msequenceserver.h"
#include "msequtilities.h"
#include "mspectrum.h"
#include "xmlparameter.h"
#include "mscore.h"
#include "mprocess.h"
mreport::mreport(mscore& score)
: m_Score(score)
{
m_lHistogramColumns = 30;
m_bCompress = false;
}
mreport::~mreport(void)
{
}
/*
* Sets the value for the number of values in a GAML value list before a return
*/
bool mreport::set_columns(const long _v)
{
if(_v < 1)
return false;
m_lHistogramColumns = _v;
return true;
}
/*
* Sets the value for the m_bCompress flag. When set, only one copy of a protein's
* sequence is stored in the output XML file.
*/
bool mreport::set_compression(const bool _b)
{
m_bCompress = _b;
return m_bCompress;
}
/*
* Checks a protein uid to see if it has already been used, storing the uid in m_vtProteins if it has not
* been stored. This function is used to reduce the number of protein sequences stored in an XML file
*/
bool mreport::check_proteins(const size_t _t)
{
if(!m_bCompress)
return true;
if(m_setProteins.find(_t) == m_setProteins.end()) {
m_setProteins.insert(_t);
return true;
}
return false;
}
/*
* end finishes the XML document
*/
bool mreport::end(void)
{
if(m_ofOut.fail()) {
return false;
}
m_ofOut << "\n";
m_ofOut.close();
return true;
}
/*
* endgroup finishes the group object associated with a particular mspectrum object
*/
bool mreport::endgroup()
{
if(m_ofOut.fail() || !m_ofOut.good()) {
return false;
}
m_ofOut << "\n";
return true;
}
/*
* group starts the group associated with outputing the information from a particular
* mspectrum object
*/
bool mreport::group(const mspectrum &_s)
{
if(m_ofOut.fail() || !m_ofOut.good()) {
return false;
}
char *pLine = new char[256];
string strTemp;
size_t tId = _s.m_tId;
while(tId > 100000000) {
tId -= 100000000;
}
if(_s.m_vseqBest.size() == 0) {
m_ofOut << "\n";
}
else {
m_ofOut << "\n";
}
delete pLine;
return true;
}
bool mreport::get_short_label(const string &_s,char *_p,const unsigned long _l,const unsigned long _t)
{
size_t lLength = _s.size();
size_t a = 0;
size_t tMax = _t - 5;
while(a < lLength && a < _l && strchr("\r\n",_s[a]) == NULL) {
_p[a] = _s[a];
a++;
}
if(strchr("\r\n",_s[a])) {
_p[a] = '\0';
return true;
}
while(a < lLength && !isspace(_s[a]) && a < tMax) {
_p[a] = _s[a];
a++;
}
if(a != lLength) {
// cout << _s.c_str() << "||";
// cout.flush();
_p[a] = '.';
a++;
_p[a] = '.';
a++;
_p[a] = '.';
a++;
}
_p[a] = '\0';
return true;
}
/*
* histogram outputs all of the histrograms contained in an mspectrum object. GAML
* notation is used to output the histograms
*/
bool mreport::histogram(mspectrum &_s)
{
if(m_ofOut.fail() || !m_ofOut.good()) {
return false;
}
__int64_t tId = _s.m_tId;
while(tId > 100000000) {
tId -= 100000000;
}
m_ofOut << "\n";
m_ofOut << "\n";
m_ofOut << "" << _s.m_hHyper.a0() << "\n";
m_ofOut << "" << _s.m_hHyper.a1() << "\n";
m_ofOut << "\n";
long a = _s.m_hHyper.length()-1;
_s.m_hHyper.survival();
while(a >= 0 && _s.m_hHyper.survive(a) < 1) {
a--;
}
if(a == _s.m_hHyper.length()-1)
a = _s.m_hHyper.length()-2;
long lLength = a+2;
long lCount = 0;
m_ofOut << "\n";
a = 0;
while(a < lLength) {
m_ofOut << a;
lCount++;
if(lCount == m_lHistogramColumns) {
m_ofOut << "\n";
lCount = 0;
}
else {
m_ofOut << " ";
}
a++;
}
m_ofOut << "\n\n\n";
m_ofOut << "\n";
m_ofOut << "\n";
a = 0;
lCount = 0;
while(a < lLength) {
m_ofOut << _s.m_hHyper.survive(a);
lCount++;
if(lCount == m_lHistogramColumns) {
m_ofOut << "\n";
lCount = 0;
}
else {
m_ofOut << " ";
}
a++;
}
_s.m_hHyper.clear_survive();
m_ofOut << "\n\n\n\n";
m_ofOut << "\n";
m_ofOut << "\n";
a = _s.m_hConvolute.length()-1;
_s.m_hConvolute.survival();
while(a >= 0 && _s.m_hConvolute.survive(a) < 1) {
a--;
}
if(a == _s.m_hConvolute.length()-1)
a = _s.m_hConvolute.length()-2;
lLength = a+2;
m_ofOut << "\n";
a = 0;
lCount = 0;
while(a < lLength) {
m_ofOut << a;
lCount++;
if(lCount == m_lHistogramColumns) {
m_ofOut << "\n";
lCount = 0;
}
else {
m_ofOut << " ";
}
a++;
}
m_ofOut << "\n\n\n";
m_ofOut << "\n";
m_ofOut << "\n";
a = 0;
lCount = 0;
while(a < lLength) {
m_ofOut << _s.m_hConvolute.survive(a);
lCount++;
if(lCount == m_lHistogramColumns) {
m_ofOut << "\n";
lCount = 0;
}
else {
m_ofOut << " ";
}
a++;
}
_s.m_hConvolute.clear_survive();
m_ofOut << "\n\n\n\n";
m_ofOut << "\n";
m_ofOut << "\n";
a = _s.m_chBCount.length()-1;
while(a >= 0 && _s.m_chBCount.list(a) < 1) {
a--;
}
if(a == _s.m_chBCount.length()-1)
a = _s.m_chBCount.length()-2;
lLength = a+2;
m_ofOut << "\n";
a = 0;
lCount = 0;
while(a < lLength) {
m_ofOut << a;
lCount++;
if(lCount == m_lHistogramColumns) {
m_ofOut << "\n";
lCount = 0;
}
else {
m_ofOut << " ";
}
a++;
}
m_ofOut << "\n\n\n";
m_ofOut << "\n";
m_ofOut << "\n";
a = 0;
lCount = 0;
while(a < lLength) {
m_ofOut << _s.m_chBCount.list(a);
lCount++;
if(lCount == m_lHistogramColumns) {
m_ofOut << "\n";
lCount = 0;
}
else {
m_ofOut << " ";
}
a++;
}
m_ofOut << "\n\n\n\n";
m_ofOut << "\n";
m_ofOut << "\n";
a = _s.m_chYCount.length()-1;
while(a >= 0 && _s.m_chYCount.list(a) < 1) {
a--;
}
if(a == _s.m_chYCount.length()-1)
a = _s.m_chYCount.length()-2;
lLength = a+2;
m_ofOut << "\n";
a = 0;
lCount = 0;
while(a < lLength) {
m_ofOut << a;
lCount++;
if(lCount == m_lHistogramColumns) {
m_ofOut << "\n";
lCount = 0;
}
else {
m_ofOut << " ";
}
a++;
}
m_ofOut << "\n\n\n";
m_ofOut << "\n";
m_ofOut << "\n";
a = 0;
lCount = 0;
while(a < lLength) {
m_ofOut << _s.m_chYCount.list(a);
lCount++;
if(lCount == m_lHistogramColumns) {
m_ofOut << "\n";
lCount = 0;
}
else {
m_ofOut << " ";
}
a++;
}
m_ofOut << "\n\n\n\n";
m_ofOut << "\n\n";
return true;
}
/*
* info outputs the input parameters derived from the input file and the default input file
* (if used). This record should be sufficient to repeat this protein modeling session exactly, without reference to
* the original input files.
* Two group nodes are used to record this information. The "input parameters" group contains all
* of the input nodes that were used to create this output file. The "unused input parameters" group
* contains all of the input parameters that were either unsupported, mis-entered or otherwise
* ignored.
*/
bool mreport::info(XmlParameter &_x)
{
if(m_ofOut.fail() || !m_ofOut.good()) {
return false;
}
pair pairValue;
xMap::iterator itStart = _x.m_mapParam.begin();
xMap::iterator itEnd = _x.m_mapParam.end();
size_t a = 0;
string strValue;
m_ofOut << "\n";
size_t tUnused = 0;
while(itStart != itEnd) {
pairValue = *itStart;
if(_x.m_mapUsed[pairValue.first]) {
strValue = pairValue.second;
m_ofOut << "\t";
a = 0;
while(a < strValue.size()) {
if(strValue[a] == '<') {
m_ofOut << "<";
}
else if(strValue[a] == '>') {
m_ofOut << ">";
}
else if(strValue[a] == '\"') {
m_ofOut << """;
}
else {
m_ofOut << strValue[a];
}
a++;
}
m_ofOut << "\n";
}
else {
tUnused++;
}
itStart++;
}
m_ofOut << "\n";
if(tUnused == 0)
return true;
itStart = _x.m_mapParam.begin();
itEnd = _x.m_mapParam.end();
a = 0;
m_ofOut << "\n";
while(itStart != itEnd) {
pairValue = *itStart;
if(!_x.m_mapUsed[pairValue.first]) {
strValue = pairValue.second;
m_ofOut << "\t";
a = 0;
while(a < strValue.size()) {
if(strValue[a] == '<') {
m_ofOut << "<";
}
else if(strValue[a] == '>') {
m_ofOut << ">";
}
else if(strValue[a] == '\"') {
m_ofOut << """;
}
else {
m_ofOut << strValue[a];
}
a++;
}
m_ofOut << "\n";
}
itStart++;
}
m_ofOut << "\n";
return true;
}
/*
* performance is called to output a group node that contains any
* performance parameters from the protein modeling session that might be of interest
* after the protein modeling session. Any number of additional output parameters can
* be included here. An XmlParameter object is used to supply the information
* required to create a series of note objects that contain the informtion.
*/
bool mreport::performance(XmlParameter &_x)
{
if(m_ofOut.fail() || !m_ofOut.good()) {
return false;
}
pair pairValue;
xMap::iterator itStart = _x.m_mapParam.begin();
xMap::iterator itEnd = _x.m_mapParam.end();
size_t a = 0;
/*
* create the group object
*/
string strValue;
m_ofOut << "\n";
while(itStart != itEnd) {
pairValue = *itStart;
strValue = pairValue.second;
/*
* create the individual notes
*/
m_ofOut << "\t";
a = 0;
while(a < strValue.size()) {
if(strValue[a] == '<') {
m_ofOut << "<";
}
else if(strValue[a] == '>') {
m_ofOut << ">";
}
else if(strValue[a] == '\"') {
m_ofOut << """;
}
else {
m_ofOut << strValue[a];
}
a++;
}
m_ofOut << "\n";
itStart++;
}
/*
* finish the group
*/
m_ofOut << "\n";
return true;
}
/*
* write masses to the results file if residue masses are not default values
*/
bool mreport::masses(msequtilities &_p)
{
if(!_p.is_modified()) {
return false;
}
size_t a = 0;
char cAa = 'A';
/*
* create the group object
*/
string strValue;
char *pLine = new char[256];
m_ofOut << "\n";
while(cAa <= 'Z') {
sprintf(pLine,"\t\n",cAa,_p.m_pdAaMass[cAa]);
m_ofOut << pLine;
cAa++;
}
sprintf(pLine,"\t\n",_p.m_dAmmonia);
m_ofOut << pLine;
sprintf(pLine,"\t\n",_p.m_dWater);
m_ofOut << pLine;
/*
* finish the group
*/
m_ofOut << "\n";
delete pLine;
return true;
}
/*
* spectrum is used to output a complete spectrum, using GAML notation.
*/
bool mreport::spectrum(mspectrum &_s,string &_f)
{
if(m_ofOut.fail() || !m_ofOut.good()) {
return false;
}
__int64_t tId = _s.m_tId;
while(tId > 100000000) {
tId -= 100000000;
}
m_ofOut << "\n";
if(!_f.empty()) {
m_ofOut << "\n";
}
if(!_s.m_strDescription.empty()) {
_s.format();
m_ofOut << "" << _s.m_strDescription.c_str() << "\n";
}
m_ofOut << "\n";
m_ofOut << "" << _s.m_dMH << "\n";
m_ofOut << "" << _s.m_fZ << "\n";
m_ofOut << "\n";
m_ofOut << "\n";
size_t a = 0;
const size_t tLength = _s.m_vMI.size();
long lCount = 0;
while(a < tLength) {
m_ofOut << _s.m_vMI[a].m_fM;
lCount++;
if(lCount == m_lHistogramColumns) {
m_ofOut << "\n";
lCount = 0;
}
else {
m_ofOut << " ";
}
a++;
}
m_ofOut << "\n\n\n";
m_ofOut << "\n";
m_ofOut << "\n";
a = 0;
lCount = 0;
char *pLine = new char[256];
while(a < tLength) {
sprintf(pLine,"%.0f",_s.m_vMI[a].m_fI);
m_ofOut << pLine;
lCount++;
if(lCount == m_lHistogramColumns) {
m_ofOut << "\n";
lCount = 0;
}
else {
m_ofOut << " ";
}
a++;
}
m_ofOut << "\n\n\n\n";
delete pLine;
return true;
}
/*
* sequence outputs the information about an identified protein sequence, using
* bioml notation
*/
bool mreport::sequence(mspectrum &_s,const bool _b,vector &_p,map &_ann)
{
if(m_ofOut.fail() || !m_ofOut.good()) {
return false;
}
size_t a = 0;
size_t b = 0;
size_t c = 0;
size_t tRow = 0;
size_t tSpace = 0;
char *pLine = new char[256];
__int64_t tId = _s.m_tId;
while(tId > 100000000) {
tId -= 100000000;
}
string strTemp;
map::iterator itMod;
while(a < _s.m_vseqBest.size()) {
m_ofOut << "second).c_str());
m_ofOut << pLine;
}
m_ofOut << ">\n";
m_ofOut << "";
m_ofOut << strV.c_str() << "\n";
m_ofOut << "\n";
m_ofOut << "\n";
c = 0;
tRow = 0;
tSpace = 0;
m_ofOut << "\t";
if(m_maptUids.find(_s.m_vseqBest[a].m_tUid) == m_maptUids.end()) {
m_maptUids[_s.m_vseqBest[a].m_tUid] = true;
}
if(check_proteins(_s.m_vseqBest[a].m_tUid)) {
while(_b && c < _s.m_vseqBest[a].m_strSeq.size()) {
m_ofOut << _s.m_vseqBest[a].m_strSeq[c];
tRow++;
tSpace++;
if(tRow == 50) {
tSpace = 0;
tRow = 0;
m_ofOut << "\n\t";
}
else if(tSpace == 10) {
tSpace = 0;
m_ofOut << " ";
}
c++;
}
m_ofOut << "\n";
}
b = 0;
double dDelta;
while(b < _s.m_vseqBest[a].m_vDomains.size()) {
m_ofOut << " 0.01) {
sprintf(pLine,"%.3lf",_s.m_vseqBest[a].m_vDomains[b].m_dMH);
}
else {
sprintf(pLine,"%.4lf",_s.m_vseqBest[a].m_vDomains[b].m_dMH);
}
m_ofOut << "mh=\"" << pLine << "\" ";
if(fabs(dDelta) > 0.01) {
sprintf(pLine,"%.3lf",dDelta);
}
else {
sprintf(pLine,"%.4lf",dDelta);
}
m_ofOut << "delta=\"" << pLine << "\" ";
m_Score.report_score(pLine, _s.m_vseqBest[a].m_vDomains[b].m_fHyper);
m_ofOut << "hyperscore=\"" << pLine << "\" ";
m_Score.report_score(pLine, _s.m_fHyperNext);
m_ofOut << "nextscore=\"" << pLine << "\" ";
m_Score.report_score(pLine, _s.m_mapScore[mscore::T_Y]+_s.m_mapScore[mscore::T_Z]);
m_ofOut << "y_score=\"" << pLine << "\" ";
m_ofOut << "y_ions=\"" << _s.m_mapCount[mscore::T_Y]+_s.m_mapCount[mscore::T_Z] << "\" ";
m_Score.report_score(pLine, _s.m_mapScore[mscore::T_B]+_s.m_mapScore[mscore::T_C]);
m_ofOut << "b_score=\"" << pLine << "\" ";
m_ofOut << "b_ions=\"" << _s.m_mapCount[mscore::T_B] + _s.m_mapCount[mscore::T_C] << "\" ";
get_pre(_s.m_vseqBest[a].m_strSeq,strTemp,_s.m_vseqBest[a].m_vDomains[b].m_lS,_s.m_vseqBest[a].m_vDomains[b].m_lE);
m_ofOut << "pre=\"" << strTemp.c_str() << "\" ";
get_post(_s.m_vseqBest[a].m_strSeq,strTemp,_s.m_vseqBest[a].m_vDomains[b].m_lS,_s.m_vseqBest[a].m_vDomains[b].m_lE);
m_ofOut << "post=\"" << strTemp.c_str() << "\" ";
m_ofOut << "seq=\"" << _s.m_vseqBest[a].m_strSeq.substr(_s.m_vseqBest[a].m_vDomains[b].m_lS,
_s.m_vseqBest[a].m_vDomains[b].m_lE-_s.m_vseqBest[a].m_vDomains[b].m_lS+1).c_str() << "\" ";
m_ofOut << "missed_cleavages=\"" << (int)_s.m_vseqBest[a].m_vDomains[b].m_lMissedCleaves
<< "\">\n";
c = 0;
while(c < _s.m_vseqBest[a].m_vDomains[b].m_vAa.size()) {
m_ofOut << " 0.1) {
sprintf(pLine,"%.5lf",_s.m_vseqBest[a].m_vDomains[b].m_vAa[c].m_dPrompt);
m_ofOut << "prompt=\"" << pLine << "\" ";
}
m_ofOut << "/>\n";
c++;
}
m_ofOut << "\n";
b++;
}
m_ofOut << "\n\n";
a++;
}
delete pLine;
return true;
}
bool mreport::get_pre(const string &_s,string &_p,const size_t _b,const size_t _e)
{
long lStart = (long)_b;
lStart -= 4;
_p.erase(_p.begin(),_p.end());
if(lStart < 0) {
lStart = 0;
_p = '[';
}
while(lStart < (long)_b) {
_p += _s[lStart];
lStart++;
}
return true;
}
bool mreport::get_post(const string &_s,string &_p,const size_t _b,const size_t _e)
{
size_t tEnd = (long)_e;
tEnd += 5;
_p.erase(_p.begin(),_p.end());
if(tEnd >= _s.size()) {
tEnd = _s.size();
}
size_t a = _e + 1;
while(a < tEnd) {
_p += _s[a];
a++;;
}
if(a == _s.size()) {
_p += ']';
}
return true;
}
/*
* start is called first to set up the XML header
*/
bool mreport::start(XmlParameter &_x)
{
string strKey = "output, path";
string strValue;
_x.get(strKey,strValue);
if(strValue.size() == 0)
return false;
string strPath = strValue;
strKey = "output, path hashing";
_x.get(strKey,strValue);
if(strValue == "yes") {
size_t tStart = strPath.rfind('.');
if(tStart != strPath.npos) {
tStart++;
time_t tValue;
time(&tValue);
char pLine[256];
struct tm *ptmValue = localtime(&tValue);
if(ptmValue == NULL) {
ptmValue = gmtime(&tValue);
}
if(ptmValue != NULL) {
strftime(pLine, 255,"%Y_%m_%d_%H_%M_%S.t.",ptmValue);
}
else {
srand((unsigned)time(NULL));
sprintf(pLine,"%i.t",rand());
}
strPath.insert(tStart,pLine);
}
}
m_ofOut.open(strPath.c_str());
if(m_ofOut.fail()) {
return false;
}
m_ofOut << "\n";
strKey = "output, xsl path";
_x.get(strKey,strValue);
if(strValue.size() > 0) {
m_ofOut << "\n";
}
strKey = "output, title";
_x.get(strKey,strValue);
if(strValue.size() > 0) {
m_ofOut << "\n";
}
else {
strKey = "spectrum, path";
_x.get(strKey,strValue);
m_ofOut << "\n";
}
return true;
}
tandem-linux-13-09-01-1/src/tandem.cpp 0000664 0001750 0001750 00000052363 12156735037 017415 0 ustar langella langella /*
Copyright (C) 2003-2013 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
// File version: 2013-04-01
/*
tandem.cpp provides a command line interface to the main processing class, mprocess.
A single command line parameter is accepted, which is the file name for an XML class
containing the parameters for performing the protein modelling session. The input file
also contains the name of an output file, which will contain the output from the session.
*/
#include "stdafx.h"
#include
#include
#include
#include "msequence.h"
#include "msequencecollection.h"
#include "msequenceserver.h"
#include "msequtilities.h"
#include "mspectrum.h"
#include "xmlparameter.h"
#include "mscore.h"
#include "mprocess.h"
#ifndef X_P3
/*
* windows.h and the definition of ProcessThread are necessary for multithreading
* in the Windows 32 environment. UNIX platforms that use POSIX threads use an
* alternate version of this file.
*/
#ifdef MSVC
#include "windows.h"
DWORD WINAPI ProcessThread(LPVOID);
DWORD WINAPI RefineThread(LPVOID);
#else
#include
void* ProcessThread(void *pParam);
void* RefineThread(void *pParam);
#endif
bool lessThanSpec(const mspectrum &_l,const mspectrum &_r);
bool lessThanSpec(const mspectrum &_l,const mspectrum &_r)
{
return _l.m_dMH < _r.m_dMH;
}
int main(int argc, char* argv[])
{
/*
* Check the argv array for at least one parameter.
* mprocess checks the validity of the file.
*/
if(argc < 2 || argc > 1 && strstr(argv[1],"-L") == argv[1] || argc > 1 && strstr(argv[1],"-h") == argv[1]) {
cout << "\n\nUSAGE: tandem filename\n\nwhere filename is any valid path to an XML input file.\n\n+-+-+-+-+-+-+\n";
cout << "\nX! TANDEM " << VERSION << "\n";
cout << "\nCopyright (C) 2003-2013 Ronald C Beavis, all rights reserved\n";
cout << "This software is a component of the GPM project.\n";
cout << "Use of this software governed by the Artistic license.\n";
cout << "If you do not have this license, you can get a copy at\n";
cout << "http://www.perl.com/pub/a/language/misc/Artistic.html\n";
cout << "\n+-+-+-+-+-+-+\n\npress to continue ...";
char *pValue = new char[128];
cin.getline(pValue,127);
delete pValue;
return -1;
}
cout << "\nX! TANDEM " << VERSION << "\n\n";
/*
* Create an mprocess object array
*/
unsigned long lMaxThreads = 256;
mprocess **pProcess = new mprocess*[lMaxThreads];
if(pProcess == NULL) {
cout << "An error was detected creating the processing objects.\nPlease contact a GPM administrator.\n";
return -2;
}
#ifdef MSVC
DWORD *pId = new DWORD[lMaxThreads];
HANDLE *pHandle = new HANDLE[lMaxThreads];
#else
int *pId = new int[lMaxThreads];
int *pHandle = new int[lMaxThreads];
pthread_t pThreads[lMaxThreads];
#endif
unsigned long a = 0;
while(a < lMaxThreads) {
pProcess[a] = NULL;
pHandle[a] = NULL;
pId[a] = NULL;
a++;
}
pProcess[0] = new mprocess;
cout << "Loading spectra";
cout.flush();
/*
* Initialize the first mprocess object with the input file name.
*/
char *pS = new char[1024];
strcpy(pS,argv[1]);
if(!pProcess[0]->load(pS)) {
cout << "\n\nAn error was detected while loading the input parameters.\nPlease follow the advice above or contact a GPM administrator to help you.";
delete pProcess[0];
delete pProcess;
return -4;
}
cout << " loaded.\n";
if(pProcess[0]->m_vSpectra.size() == 0) {
cout << "No input spectra met the acceptance criteria.\n";
cout.flush();
delete pProcess[0];
delete pProcess;
return 1;
}
pProcess[0]->serialize();
cout << "Spectra matching criteria = " << (unsigned long)pProcess[0]->m_vSpectra.size() << "\n";
cout.flush();
#ifdef PLUGGABLE_SCORING
cout << "Pluggable scoring enabled.\n";
#endif
/*
* Start the mprocess object and wait for it to return.
*/
unsigned long lThread = pProcess[0]->get_thread();
unsigned long lThreads = pProcess[0]->get_threads();
if(lThreads > lMaxThreads) {
lThreads = lMaxThreads;
}
if(pProcess[0]->m_vSpectra.size() < lThreads) {
lThreads = (unsigned long)pProcess[0]->m_vSpectra.size();
if(lThreads < 1) {
lThreads = 1;
}
pProcess[0]->set_threads(lThreads);
}
#ifdef MSVC
DWORD dCount = lThreads - 1;
#else
int dCount = lThreads - 1;
#endif
long lSpectra = lThreads + (long)pProcess[0]->m_vSpectra.size()/lThreads;
bool bSpectra = true;
cout << "Starting threads .";
cout.flush();
size_t tCount = pProcess[0]->m_vSpectra.size();
sort(pProcess[0]->m_vSpectra.begin(),pProcess[0]->m_vSpectra.end(),lessThanSpec);
float fMax = (float)pProcess[0]->m_vSpectra.back().m_dMH;
float fZ = pProcess[0]->m_vSpectra.back().m_fZ;
pProcess[0]->m_fMaxMass = fMax;
pProcess[0]->m_fMaxZ = fZ;
if(lThread != 0xFFFFFFFF) {
while(dCount > 0) {
pProcess[dCount] = new mprocess;
pProcess[dCount]->set_thread(dCount);
pProcess[dCount]->m_vSpectra.reserve(lSpectra);
pProcess[dCount]->m_fMaxMass = fMax;
pProcess[dCount]->m_fMaxZ = fZ;
dCount--;
}
size_t tProcesses = lThreads;
size_t tRing = 0;
vector vZero;
vZero.reserve(lSpectra);
do {
if(tRing == 0) {
vZero.push_back(pProcess[0]->m_vSpectra.back());
}
else {
pProcess[tRing]->m_vSpectra.push_back(pProcess[0]->m_vSpectra.back());
}
tRing++;
pProcess[0]->m_vSpectra.pop_back();
if(tRing == tProcesses) {
tRing = 0;
}
} while(pProcess[0]->m_vSpectra.size() != 0);
pProcess[0]->m_vSpectra.reserve(vZero.size());
do {
pProcess[0]->m_vSpectra.push_back(vZero.back());
vZero.pop_back();
} while(vZero.size() != 0);
dCount = lThreads - 1;
while(dCount > 0) {
if(!pProcess[dCount]->load(pS,pProcess[0])) {
cout << "error pProcess->LoadParameters returned error (main)\r\n";
delete pProcess;
return -4;
}
dCount--;
cout << ".";
cout.flush();
}
}
/* if(lThread != 0xFFFFFFFF) {
while(dCount > 0) {
pProcess[dCount] = new mprocess;
pProcess[dCount]->set_thread(dCount);
// initialize the new mprocess objects with the spectra already loaded into the first mprocess
pProcess[dCount]->m_vSpectra.reserve(lSpectra);
pProcess[dCount]->m_fMaxMass = fMax;
pProcess[dCount]->m_fMaxZ = fZ;
dCount--;
}
size_t tProcesses = lThreads;
size_t tTotal = pProcess[0]->m_vSpectra.size();
size_t tMaxSlice = tTotal/(2*lThreads);
if(tMaxSlice == 0) {
tMaxSlice = 1;
}
size_t tRing = 0;
double dSliceMH = pProcess[0]->m_vSpectra.back().m_dMH;
double dSliceWidth = 0.20;
size_t tSlice = 0;
vector vZero;
vZero.reserve(lSpectra);
size_t tI = 0;
do {
dSliceMH = pProcess[0]->m_vSpectra.back().m_dMH;
tSlice = 0;
while(!pProcess[0]->m_vSpectra.empty() && tSlice < tMaxSlice && dSliceMH - pProcess[0]->m_vSpectra.back().m_dMH < dSliceWidth) {
if(tRing == 0) {
vZero.push_back(pProcess[0]->m_vSpectra.back());
}
else {
pProcess[tRing]->m_vSpectra.push_back(pProcess[0]->m_vSpectra.back());
}
pProcess[0]->m_vSpectra.pop_back();
tSlice++;
tI++;
}
tRing++;
if(tRing == tProcesses) {
tRing = 0;
}
} while(!pProcess[0]->m_vSpectra.empty() != 0);
pProcess[0]->m_vSpectra.reserve(vZero.size());
do {
pProcess[0]->m_vSpectra.push_back(vZero.back());
vZero.pop_back();
} while(!vZero.empty());
dCount = lThreads - 1;
tSlice = 0;
while(dCount > 0) {
if(!pProcess[dCount]->load(pS,pProcess[0])) {
cout << "error pProcess->LoadParameters returned error (main)\r\n";
delete pProcess;
return -4;
}
cout << pProcess[dCount]->m_vSpectra.size();
tSlice += pProcess[dCount]->m_vSpectra.size();
cout.flush();
dCount--;
}
cout << "|" << pProcess[dCount]->m_vSpectra.size();
cout.flush();
tSlice += pProcess[dCount]->m_vSpectra.size();
if((int)tSlice - (int)tTotal != 0) {
cout << "|" << (int)tSlice - (int)tTotal;
}
}*/
delete pS;
dCount = 0;
#ifdef MSVC
pHandle[dCount] = CreateThread(NULL,0,ProcessThread,(void *)pProcess[dCount],0,&pId[dCount]);
#else
pthread_create(&pThreads[dCount],NULL,ProcessThread,(void*)pProcess[dCount]);
#endif
dCount++;
/*
* Initialize more mprocess objects, if lThread is not 0xFFFFFFFF, which signifies default single
* threaded operation.
*/
if(lThread != 0xFFFFFFFF && bSpectra) {
while(dCount < lThreads) {
#ifdef MSVC
pHandle[dCount] = CreateThread(NULL,0,ProcessThread,(void *)pProcess[dCount],0,&pId[dCount]);
#else
pthread_create(&pThreads[dCount],NULL,ProcessThread,(void*)pProcess[dCount]);
#endif
dCount++;
}
}
cout << " started.\n";
cout.flush();
cout << "Computing models:\n";
cout.flush();
/*
* wait until all of the mprocess objects return.
*/
#ifdef MSVC
// DWORD wait = WaitForMultipleObjects(dCount,pHandle,true,INFINITE);
a = 0;
DWORD dwTime = 100000;
DWORD wait = WAIT_TIMEOUT;
int iTics = 0;
while(a < dCount) {
wait = WaitForSingleObject(pHandle[a],100);
if(a > 0 && wait == WAIT_TIMEOUT) {
if(a == 1) {
cout << "waiting for " << a+1;
}
else {
cout << a+1;
}
while(wait == WAIT_TIMEOUT) {
wait = WaitForSingleObject(pHandle[a],dwTime);
if(wait == WAIT_TIMEOUT) {
cout << ".";
cout.flush();
iTics++;
if(iTics > 50) {
cout << "|\n\t\t";
cout.flush();
iTics = 0;
}
}
}
}
else {
while(wait == WAIT_TIMEOUT) {
wait = WaitForSingleObject(pHandle[a],dwTime);
if(wait == WAIT_TIMEOUT) {
cout << ":";
cout.flush();
}
}
if(a == 1) {
cout << "waiting for " << a+1;
}
else if(a == 0) {
cout << "\n\t";
cout.flush();
}
else {
cout << a+1;
}
}
a++;
}
if(dCount > 1) {
cout << " done.\n\n";
cout.flush();
}
else {
cout << "\n";
cout.flush();
}
#else
//2003-03-01:note - the declaration below was changed from void **vp;
void *vp;
int x=0;
int wait;
for(x=0;xmerge_spectra();
a = 1;
/*
* merge the results into the first object
*/
while(a < dCount) {
pProcess[0]->merge_map(pProcess[a]->m_mapSequences);
pProcess[0]->merge_spectra(pProcess[a]->m_vSpectra);
a++;
}
a = 1;
pProcess[0]->load_sequences();
while(a < dCount) {
pProcess[a]->merge_map(pProcess[0]->m_mapSequences);
pProcess[a]->m_vseqBest = pProcess[0]->m_vseqBest;
pProcess[a]->m_mapCrc.clear();
a++;
}
/*
* Report the contents of the mprocess objects into an XML file as described
* in the input file.
*/
cout << "Model refinement:\n";
cout.flush();
dCount = 0;
#ifdef MSVC
pHandle[dCount] = CreateThread(NULL,0,RefineThread,(void *)pProcess[dCount],0,&pId[dCount]);
#else
pthread_create(&pThreads[dCount],NULL,RefineThread,(void*)pProcess[dCount]);
#endif
dCount++;
/*
* Initialize more mprocess objects, if lThread is not 0xFFFFFFFF, which signifies default single
* threaded operation.
*/
if(lThread != 0xFFFFFFFF) {
while(dCount < lThreads) {
#ifdef MSVC
pHandle[dCount] = CreateThread(NULL,0,RefineThread,(void *)pProcess[dCount],0,&pId[dCount]);
#else
pthread_create(&pThreads[dCount],NULL,RefineThread,(void*)pProcess[dCount]);
#endif
dCount++;
}
}
/*
* wait until all of the mprocess objects return.
*/
#ifdef MSVC
// wait = WaitForMultipleObjects(dCount,pHandle,true,INFINITE);
a = 0;
iTics = 0;
while(a < dCount) {
wait = WaitForSingleObject(pHandle[a],10000);
if(a > 0 && wait == WAIT_TIMEOUT) {
if(a == 1) {
cout << "waiting for " << a+1;
}
else {
cout << a+1;
}
cout.flush();
while(wait == WAIT_TIMEOUT) {
wait = WaitForSingleObject(pHandle[a],dwTime);
if(wait == WAIT_TIMEOUT) {
cout << ".";
cout.flush();
iTics++;
if(iTics > 50) {
cout << "|\n\t\t";
cout.flush();
iTics = 0;
}
}
}
}
else {
while(wait == WAIT_TIMEOUT) {
wait = WaitForSingleObject(pHandle[a],dwTime);
if(wait == WAIT_TIMEOUT) {
cout << ":";
cout.flush();
}
}
if(a == 1) {
cout << "waiting for " << a+1;
}
else if(a == 0) {
cout << "\n\t";
cout.flush();
}
else {
cout << a+1;
}
}
a++;
}
if(dCount > 1) {
cout << " done.\n\n";
cout.flush();
}
else {
cout << "\n";
cout.flush();
}
#else
//2003-03-01:note - the declaration below was changed from void **vp;
x=0;
for(x=0;x 1) {
cout << "Merging results:\n";
cout.flush();
}
while(a < dCount) {
if(a == 1) {
cout << "\tfrom " << a+1;
}
else {
cout << a+1;
}
cout.flush();
if(!pProcess[0]->add_spectra(pProcess[a]->m_vSpectra)) {
cout << "adding spectra failed.\n";
}
pProcess[0]->merge_statistics(pProcess[a]);
pProcess[a]->clear();
pProcess[a]->m_mapSequences.clear();
delete pProcess[a];
pProcess[a] = NULL;
a++;
}
if(dCount > 1) {
cout << "\n\n";
cout.flush();
}
cout.flush();
cout << "Creating report:\n";
cout.flush();
pProcess[0]->report();
size_t tValid = pProcess[0]->get_valid();
size_t tUnique = pProcess[0]->get_unique();
double dE = pProcess[0]->get_error_estimate();
unsigned long lE = (unsigned long)(0.5+dE);
unsigned long lEe = (unsigned long)(0.5 + sqrt(dE));
if(lEe == 0) {
lEe = 1;
}
if(dE <= 0.0) {
dE = 1.0;
}
cout << "\nValid models = " << (unsigned long)tValid << "\n";
if(tUnique > 0) {
cout << "Unique models = " << (unsigned long)tUnique << "\n";
cout << "Estimated false positives = " << lE << " ± ";
cout << lEe << "\n";
}
lE = pProcess[0]->get_reversed();
if(lE != -1) {
cout << "False positive rate (reversed sequences) = " << lE << "\n";
}
cout << "\n\n";
/*
* Delete the mprocess objects and exit
*/
a = 0;
while(a < 16) {
if(pProcess[a] != NULL) {
#ifdef MSVC
CloseHandle(pHandle[a]);
#endif
delete pProcess[a];
}
a++;
}
delete pProcess;
delete pId;
delete pHandle;
return 0;
}
/*
* Process thread is used to create the worker threads for each mprocess object
*/
#ifdef MSVC
DWORD WINAPI ProcessThread(LPVOID _p)
{
((mprocess *)_p)->process();
return 0;
}
DWORD WINAPI RefineThread(LPVOID _p)
{
((mprocess *)_p)->refine();
return 0;
}
#else
void* ProcessThread(void *_p){
((mprocess *)_p)->process();
return (void*)0;
}
void* RefineThread(void *_p){
((mprocess *)_p)->refine();
return (void*)0;
}
#endif
#endif
tandem-linux-13-09-01-1/src/expat.h 0000664 0001750 0001750 00000120556 10354016526 016724 0 ustar langella langella /* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
See the file COPYING for copying permission.
*/
#ifndef Expat_INCLUDED
#define Expat_INCLUDED 1
#ifdef __VMS
/* 0 1 2 3 0 1 2 3
1234567890123456789012345678901 1234567890123456789012345678901 */
#define XML_SetProcessingInstructionHandler XML_SetProcessingInstrHandler
#define XML_SetUnparsedEntityDeclHandler XML_SetUnparsedEntDeclHandler
#define XML_SetStartNamespaceDeclHandler XML_SetStartNamespcDeclHandler
#define XML_SetExternalEntityRefHandlerArg XML_SetExternalEntRefHandlerArg
#endif
#include
#include "expat_external.h"
#ifdef __cplusplus
extern "C" {
#endif
struct XML_ParserStruct;
typedef struct XML_ParserStruct *XML_Parser;
/* Should this be defined using stdbool.h when C99 is available? */
typedef unsigned char XML_Bool;
#define XML_TRUE ((XML_Bool) 1)
#define XML_FALSE ((XML_Bool) 0)
/* The XML_Status enum gives the possible return values for several
API functions. The preprocessor #defines are included so this
stanza can be added to code that still needs to support older
versions of Expat 1.95.x:
#ifndef XML_STATUS_OK
#define XML_STATUS_OK 1
#define XML_STATUS_ERROR 0
#endif
Otherwise, the #define hackery is quite ugly and would have been
dropped.
*/
enum XML_Status {
XML_STATUS_ERROR = 0,
#define XML_STATUS_ERROR XML_STATUS_ERROR
XML_STATUS_OK = 1,
#define XML_STATUS_OK XML_STATUS_OK
XML_STATUS_SUSPENDED = 2
#define XML_STATUS_SUSPENDED XML_STATUS_SUSPENDED
};
enum XML_Error {
XML_ERROR_NONE,
XML_ERROR_NO_MEMORY,
XML_ERROR_SYNTAX,
XML_ERROR_NO_ELEMENTS,
XML_ERROR_INVALID_TOKEN,
XML_ERROR_UNCLOSED_TOKEN,
XML_ERROR_PARTIAL_CHAR,
XML_ERROR_TAG_MISMATCH,
XML_ERROR_DUPLICATE_ATTRIBUTE,
XML_ERROR_JUNK_AFTER_DOC_ELEMENT,
XML_ERROR_PARAM_ENTITY_REF,
XML_ERROR_UNDEFINED_ENTITY,
XML_ERROR_RECURSIVE_ENTITY_REF,
XML_ERROR_ASYNC_ENTITY,
XML_ERROR_BAD_CHAR_REF,
XML_ERROR_BINARY_ENTITY_REF,
XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
XML_ERROR_MISPLACED_XML_PI,
XML_ERROR_UNKNOWN_ENCODING,
XML_ERROR_INCORRECT_ENCODING,
XML_ERROR_UNCLOSED_CDATA_SECTION,
XML_ERROR_EXTERNAL_ENTITY_HANDLING,
XML_ERROR_NOT_STANDALONE,
XML_ERROR_UNEXPECTED_STATE,
XML_ERROR_ENTITY_DECLARED_IN_PE,
XML_ERROR_FEATURE_REQUIRES_XML_DTD,
XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING,
/* Added in 1.95.7. */
XML_ERROR_UNBOUND_PREFIX,
/* Added in 1.95.8. */
XML_ERROR_UNDECLARING_PREFIX,
XML_ERROR_INCOMPLETE_PE,
XML_ERROR_XML_DECL,
XML_ERROR_TEXT_DECL,
XML_ERROR_PUBLICID,
XML_ERROR_SUSPENDED,
XML_ERROR_NOT_SUSPENDED,
XML_ERROR_ABORTED,
XML_ERROR_FINISHED,
XML_ERROR_SUSPEND_PE,
/* Added in 2.0. */
XML_ERROR_RESERVED_PREFIX_XML,
XML_ERROR_RESERVED_PREFIX_XMLNS,
XML_ERROR_RESERVED_NAMESPACE_URI
};
enum XML_Content_Type {
XML_CTYPE_EMPTY = 1,
XML_CTYPE_ANY,
XML_CTYPE_MIXED,
XML_CTYPE_NAME,
XML_CTYPE_CHOICE,
XML_CTYPE_SEQ
};
enum XML_Content_Quant {
XML_CQUANT_NONE,
XML_CQUANT_OPT,
XML_CQUANT_REP,
XML_CQUANT_PLUS
};
/* If type == XML_CTYPE_EMPTY or XML_CTYPE_ANY, then quant will be
XML_CQUANT_NONE, and the other fields will be zero or NULL.
If type == XML_CTYPE_MIXED, then quant will be NONE or REP and
numchildren will contain number of elements that may be mixed in
and children point to an array of XML_Content cells that will be
all of XML_CTYPE_NAME type with no quantification.
If type == XML_CTYPE_NAME, then the name points to the name, and
the numchildren field will be zero and children will be NULL. The
quant fields indicates any quantifiers placed on the name.
CHOICE and SEQ will have name NULL, the number of children in
numchildren and children will point, recursively, to an array
of XML_Content cells.
The EMPTY, ANY, and MIXED types will only occur at top level.
*/
typedef struct XML_cp XML_Content;
struct XML_cp {
enum XML_Content_Type type;
enum XML_Content_Quant quant;
XML_Char * name;
unsigned int numchildren;
XML_Content * children;
};
/* This is called for an element declaration. See above for
description of the model argument. It's the caller's responsibility
to free model when finished with it.
*/
typedef void (XMLCALL *XML_ElementDeclHandler) (void *userData,
const XML_Char *name,
XML_Content *model);
XMLPARSEAPI(void)
XML_SetElementDeclHandler(XML_Parser parser,
XML_ElementDeclHandler eldecl);
/* The Attlist declaration handler is called for *each* attribute. So
a single Attlist declaration with multiple attributes declared will
generate multiple calls to this handler. The "default" parameter
may be NULL in the case of the "#IMPLIED" or "#REQUIRED"
keyword. The "isrequired" parameter will be true and the default
value will be NULL in the case of "#REQUIRED". If "isrequired" is
true and default is non-NULL, then this is a "#FIXED" default.
*/
typedef void (XMLCALL *XML_AttlistDeclHandler) (
void *userData,
const XML_Char *elname,
const XML_Char *attname,
const XML_Char *att_type,
const XML_Char *dflt,
int isrequired);
XMLPARSEAPI(void)
XML_SetAttlistDeclHandler(XML_Parser parser,
XML_AttlistDeclHandler attdecl);
/* The XML declaration handler is called for *both* XML declarations
and text declarations. The way to distinguish is that the version
parameter will be NULL for text declarations. The encoding
parameter may be NULL for XML declarations. The standalone
parameter will be -1, 0, or 1 indicating respectively that there
was no standalone parameter in the declaration, that it was given
as no, or that it was given as yes.
*/
typedef void (XMLCALL *XML_XmlDeclHandler) (void *userData,
const XML_Char *version,
const XML_Char *encoding,
int standalone);
XMLPARSEAPI(void)
XML_SetXmlDeclHandler(XML_Parser parser,
XML_XmlDeclHandler xmldecl);
typedef struct {
void *(*malloc_fcn)(size_t size);
void *(*realloc_fcn)(void *ptr, size_t size);
void (*free_fcn)(void *ptr);
} XML_Memory_Handling_Suite;
/* Constructs a new parser; encoding is the encoding specified by the
external protocol or NULL if there is none specified.
*/
XMLPARSEAPI(XML_Parser)
XML_ParserCreate(const XML_Char *encoding);
/* Constructs a new parser and namespace processor. Element type
names and attribute names that belong to a namespace will be
expanded; unprefixed attribute names are never expanded; unprefixed
element type names are expanded only if there is a default
namespace. The expanded name is the concatenation of the namespace
URI, the namespace separator character, and the local part of the
name. If the namespace separator is '\0' then the namespace URI
and the local part will be concatenated without any separator.
It is a programming error to use the separator '\0' with namespace
triplets (see XML_SetReturnNSTriplet).
*/
XMLPARSEAPI(XML_Parser)
XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);
/* Constructs a new parser using the memory management suite referred to
by memsuite. If memsuite is NULL, then use the standard library memory
suite. If namespaceSeparator is non-NULL it creates a parser with
namespace processing as described above. The character pointed at
will serve as the namespace separator.
All further memory operations used for the created parser will come from
the given suite.
*/
XMLPARSEAPI(XML_Parser)
XML_ParserCreate_MM(const XML_Char *encoding,
const XML_Memory_Handling_Suite *memsuite,
const XML_Char *namespaceSeparator);
/* Prepare a parser object to be re-used. This is particularly
valuable when memory allocation overhead is disproportionatly high,
such as when a large number of small documnents need to be parsed.
All handlers are cleared from the parser, except for the
unknownEncodingHandler. The parser's external state is re-initialized
except for the values of ns and ns_triplets.
Added in Expat 1.95.3.
*/
XMLPARSEAPI(XML_Bool)
XML_ParserReset(XML_Parser parser, const XML_Char *encoding);
/* atts is array of name/value pairs, terminated by 0;
names and values are 0 terminated.
*/
typedef void (XMLCALL *XML_StartElementHandler) (void *userData,
const XML_Char *name,
const XML_Char **atts);
typedef void (XMLCALL *XML_EndElementHandler) (void *userData,
const XML_Char *name);
/* s is not 0 terminated. */
typedef void (XMLCALL *XML_CharacterDataHandler) (void *userData,
const XML_Char *s,
int len);
/* target and data are 0 terminated */
typedef void (XMLCALL *XML_ProcessingInstructionHandler) (
void *userData,
const XML_Char *target,
const XML_Char *data);
/* data is 0 terminated */
typedef void (XMLCALL *XML_CommentHandler) (void *userData,
const XML_Char *data);
typedef void (XMLCALL *XML_StartCdataSectionHandler) (void *userData);
typedef void (XMLCALL *XML_EndCdataSectionHandler) (void *userData);
/* This is called for any characters in the XML document for which
there is no applicable handler. This includes both characters that
are part of markup which is of a kind that is not reported
(comments, markup declarations), or characters that are part of a
construct which could be reported but for which no handler has been
supplied. The characters are passed exactly as they were in the XML
document except that they will be encoded in UTF-8 or UTF-16.
Line boundaries are not normalized. Note that a byte order mark
character is not passed to the default handler. There are no
guarantees about how characters are divided between calls to the
default handler: for example, a comment might be split between
multiple calls.
*/
typedef void (XMLCALL *XML_DefaultHandler) (void *userData,
const XML_Char *s,
int len);
/* This is called for the start of the DOCTYPE declaration, before
any DTD or internal subset is parsed.
*/
typedef void (XMLCALL *XML_StartDoctypeDeclHandler) (
void *userData,
const XML_Char *doctypeName,
const XML_Char *sysid,
const XML_Char *pubid,
int has_internal_subset);
/* This is called for the start of the DOCTYPE declaration when the
closing > is encountered, but after processing any external
subset.
*/
typedef void (XMLCALL *XML_EndDoctypeDeclHandler)(void *userData);
/* This is called for entity declarations. The is_parameter_entity
argument will be non-zero if the entity is a parameter entity, zero
otherwise.
For internal entities (), value will
be non-NULL and systemId, publicID, and notationName will be NULL.
The value string is NOT nul-terminated; the length is provided in
the value_length argument. Since it is legal to have zero-length
values, do not use this argument to test for internal entities.
For external entities, value will be NULL and systemId will be
non-NULL. The publicId argument will be NULL unless a public
identifier was provided. The notationName argument will have a
non-NULL value only for unparsed entity declarations.
Note that is_parameter_entity can't be changed to XML_Bool, since
that would break binary compatibility.
*/
typedef void (XMLCALL *XML_EntityDeclHandler) (
void *userData,
const XML_Char *entityName,
int is_parameter_entity,
const XML_Char *value,
int value_length,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId,
const XML_Char *notationName);
XMLPARSEAPI(void)
XML_SetEntityDeclHandler(XML_Parser parser,
XML_EntityDeclHandler handler);
/* OBSOLETE -- OBSOLETE -- OBSOLETE
This handler has been superceded by the EntityDeclHandler above.
It is provided here for backward compatibility.
This is called for a declaration of an unparsed (NDATA) entity.
The base argument is whatever was set by XML_SetBase. The
entityName, systemId and notationName arguments will never be
NULL. The other arguments may be.
*/
typedef void (XMLCALL *XML_UnparsedEntityDeclHandler) (
void *userData,
const XML_Char *entityName,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId,
const XML_Char *notationName);
/* This is called for a declaration of notation. The base argument is
whatever was set by XML_SetBase. The notationName will never be
NULL. The other arguments can be.
*/
typedef void (XMLCALL *XML_NotationDeclHandler) (
void *userData,
const XML_Char *notationName,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId);
/* When namespace processing is enabled, these are called once for
each namespace declaration. The call to the start and end element
handlers occur between the calls to the start and end namespace
declaration handlers. For an xmlns attribute, prefix will be
NULL. For an xmlns="" attribute, uri will be NULL.
*/
typedef void (XMLCALL *XML_StartNamespaceDeclHandler) (
void *userData,
const XML_Char *prefix,
const XML_Char *uri);
typedef void (XMLCALL *XML_EndNamespaceDeclHandler) (
void *userData,
const XML_Char *prefix);
/* This is called if the document is not standalone, that is, it has an
external subset or a reference to a parameter entity, but does not
have standalone="yes". If this handler returns XML_STATUS_ERROR,
then processing will not continue, and the parser will return a
XML_ERROR_NOT_STANDALONE error.
If parameter entity parsing is enabled, then in addition to the
conditions above this handler will only be called if the referenced
entity was actually read.
*/
typedef int (XMLCALL *XML_NotStandaloneHandler) (void *userData);
/* This is called for a reference to an external parsed general
entity. The referenced entity is not automatically parsed. The
application can parse it immediately or later using
XML_ExternalEntityParserCreate.
The parser argument is the parser parsing the entity containing the
reference; it can be passed as the parser argument to
XML_ExternalEntityParserCreate. The systemId argument is the
system identifier as specified in the entity declaration; it will
not be NULL.
The base argument is the system identifier that should be used as
the base for resolving systemId if systemId was relative; this is
set by XML_SetBase; it may be NULL.
The publicId argument is the public identifier as specified in the
entity declaration, or NULL if none was specified; the whitespace
in the public identifier will have been normalized as required by
the XML spec.
The context argument specifies the parsing context in the format
expected by the context argument to XML_ExternalEntityParserCreate;
context is valid only until the handler returns, so if the
referenced entity is to be parsed later, it must be copied.
context is NULL only when the entity is a parameter entity.
The handler should return XML_STATUS_ERROR if processing should not
continue because of a fatal error in the handling of the external
entity. In this case the calling parser will return an
XML_ERROR_EXTERNAL_ENTITY_HANDLING error.
Note that unlike other handlers the first argument is the parser,
not userData.
*/
typedef int (XMLCALL *XML_ExternalEntityRefHandler) (
XML_Parser parser,
const XML_Char *context,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId);
/* This is called in two situations:
1) An entity reference is encountered for which no declaration
has been read *and* this is not an error.
2) An internal entity reference is read, but not expanded, because
XML_SetDefaultHandler has been called.
Note: skipped parameter entities in declarations and skipped general
entities in attribute values cannot be reported, because
the event would be out of sync with the reporting of the
declarations or attribute values
*/
typedef void (XMLCALL *XML_SkippedEntityHandler) (
void *userData,
const XML_Char *entityName,
int is_parameter_entity);
/* This structure is filled in by the XML_UnknownEncodingHandler to
provide information to the parser about encodings that are unknown
to the parser.
The map[b] member gives information about byte sequences whose
first byte is b.
If map[b] is c where c is >= 0, then b by itself encodes the
Unicode scalar value c.
If map[b] is -1, then the byte sequence is malformed.
If map[b] is -n, where n >= 2, then b is the first byte of an
n-byte sequence that encodes a single Unicode scalar value.
The data member will be passed as the first argument to the convert
function.
The convert function is used to convert multibyte sequences; s will
point to a n-byte sequence where map[(unsigned char)*s] == -n. The
convert function must return the Unicode scalar value represented
by this byte sequence or -1 if the byte sequence is malformed.
The convert function may be NULL if the encoding is a single-byte
encoding, that is if map[b] >= -1 for all bytes b.
When the parser is finished with the encoding, then if release is
not NULL, it will call release passing it the data member; once
release has been called, the convert function will not be called
again.
Expat places certain restrictions on the encodings that are supported
using this mechanism.
1. Every ASCII character that can appear in a well-formed XML document,
other than the characters
$@\^`{}~
must be represented by a single byte, and that byte must be the
same byte that represents that character in ASCII.
2. No character may require more than 4 bytes to encode.
3. All characters encoded must have Unicode scalar values <=
0xFFFF, (i.e., characters that would be encoded by surrogates in
UTF-16 are not allowed). Note that this restriction doesn't
apply to the built-in support for UTF-8 and UTF-16.
4. No Unicode character may be encoded by more than one distinct
sequence of bytes.
*/
typedef struct {
int map[256];
void *data;
int (XMLCALL *convert)(void *data, const char *s);
void (XMLCALL *release)(void *data);
} XML_Encoding;
/* This is called for an encoding that is unknown to the parser.
The encodingHandlerData argument is that which was passed as the
second argument to XML_SetUnknownEncodingHandler.
The name argument gives the name of the encoding as specified in
the encoding declaration.
If the callback can provide information about the encoding, it must
fill in the XML_Encoding structure, and return XML_STATUS_OK.
Otherwise it must return XML_STATUS_ERROR.
If info does not describe a suitable encoding, then the parser will
return an XML_UNKNOWN_ENCODING error.
*/
typedef int (XMLCALL *XML_UnknownEncodingHandler) (
void *encodingHandlerData,
const XML_Char *name,
XML_Encoding *info);
XMLPARSEAPI(void)
XML_SetElementHandler(XML_Parser parser,
XML_StartElementHandler start,
XML_EndElementHandler end);
XMLPARSEAPI(void)
XML_SetStartElementHandler(XML_Parser parser,
XML_StartElementHandler handler);
XMLPARSEAPI(void)
XML_SetEndElementHandler(XML_Parser parser,
XML_EndElementHandler handler);
XMLPARSEAPI(void)
XML_SetCharacterDataHandler(XML_Parser parser,
XML_CharacterDataHandler handler);
XMLPARSEAPI(void)
XML_SetProcessingInstructionHandler(XML_Parser parser,
XML_ProcessingInstructionHandler handler);
XMLPARSEAPI(void)
XML_SetCommentHandler(XML_Parser parser,
XML_CommentHandler handler);
XMLPARSEAPI(void)
XML_SetCdataSectionHandler(XML_Parser parser,
XML_StartCdataSectionHandler start,
XML_EndCdataSectionHandler end);
XMLPARSEAPI(void)
XML_SetStartCdataSectionHandler(XML_Parser parser,
XML_StartCdataSectionHandler start);
XMLPARSEAPI(void)
XML_SetEndCdataSectionHandler(XML_Parser parser,
XML_EndCdataSectionHandler end);
/* This sets the default handler and also inhibits expansion of
internal entities. These entity references will be passed to the
default handler, or to the skipped entity handler, if one is set.
*/
XMLPARSEAPI(void)
XML_SetDefaultHandler(XML_Parser parser,
XML_DefaultHandler handler);
/* This sets the default handler but does not inhibit expansion of
internal entities. The entity reference will not be passed to the
default handler.
*/
XMLPARSEAPI(void)
XML_SetDefaultHandlerExpand(XML_Parser parser,
XML_DefaultHandler handler);
XMLPARSEAPI(void)
XML_SetDoctypeDeclHandler(XML_Parser parser,
XML_StartDoctypeDeclHandler start,
XML_EndDoctypeDeclHandler end);
XMLPARSEAPI(void)
XML_SetStartDoctypeDeclHandler(XML_Parser parser,
XML_StartDoctypeDeclHandler start);
XMLPARSEAPI(void)
XML_SetEndDoctypeDeclHandler(XML_Parser parser,
XML_EndDoctypeDeclHandler end);
XMLPARSEAPI(void)
XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
XML_UnparsedEntityDeclHandler handler);
XMLPARSEAPI(void)
XML_SetNotationDeclHandler(XML_Parser parser,
XML_NotationDeclHandler handler);
XMLPARSEAPI(void)
XML_SetNamespaceDeclHandler(XML_Parser parser,
XML_StartNamespaceDeclHandler start,
XML_EndNamespaceDeclHandler end);
XMLPARSEAPI(void)
XML_SetStartNamespaceDeclHandler(XML_Parser parser,
XML_StartNamespaceDeclHandler start);
XMLPARSEAPI(void)
XML_SetEndNamespaceDeclHandler(XML_Parser parser,
XML_EndNamespaceDeclHandler end);
XMLPARSEAPI(void)
XML_SetNotStandaloneHandler(XML_Parser parser,
XML_NotStandaloneHandler handler);
XMLPARSEAPI(void)
XML_SetExternalEntityRefHandler(XML_Parser parser,
XML_ExternalEntityRefHandler handler);
/* If a non-NULL value for arg is specified here, then it will be
passed as the first argument to the external entity ref handler
instead of the parser object.
*/
XMLPARSEAPI(void)
XML_SetExternalEntityRefHandlerArg(XML_Parser parser,
void *arg);
XMLPARSEAPI(void)
XML_SetSkippedEntityHandler(XML_Parser parser,
XML_SkippedEntityHandler handler);
XMLPARSEAPI(void)
XML_SetUnknownEncodingHandler(XML_Parser parser,
XML_UnknownEncodingHandler handler,
void *encodingHandlerData);
/* This can be called within a handler for a start element, end
element, processing instruction or character data. It causes the
corresponding markup to be passed to the default handler.
*/
XMLPARSEAPI(void)
XML_DefaultCurrent(XML_Parser parser);
/* If do_nst is non-zero, and namespace processing is in effect, and
a name has a prefix (i.e. an explicit namespace qualifier) then
that name is returned as a triplet in a single string separated by
the separator character specified when the parser was created: URI
+ sep + local_name + sep + prefix.
If do_nst is zero, then namespace information is returned in the
default manner (URI + sep + local_name) whether or not the name
has a prefix.
Note: Calling XML_SetReturnNSTriplet after XML_Parse or
XML_ParseBuffer has no effect.
*/
XMLPARSEAPI(void)
XML_SetReturnNSTriplet(XML_Parser parser, int do_nst);
/* This value is passed as the userData argument to callbacks. */
XMLPARSEAPI(void)
XML_SetUserData(XML_Parser parser, void *userData);
/* Returns the last value set by XML_SetUserData or NULL. */
#define XML_GetUserData(parser) (*(void **)(parser))
/* This is equivalent to supplying an encoding argument to
XML_ParserCreate. On success XML_SetEncoding returns non-zero,
zero otherwise.
Note: Calling XML_SetEncoding after XML_Parse or XML_ParseBuffer
has no effect and returns XML_STATUS_ERROR.
*/
XMLPARSEAPI(enum XML_Status)
XML_SetEncoding(XML_Parser parser, const XML_Char *encoding);
/* If this function is called, then the parser will be passed as the
first argument to callbacks instead of userData. The userData will
still be accessible using XML_GetUserData.
*/
XMLPARSEAPI(void)
XML_UseParserAsHandlerArg(XML_Parser parser);
/* If useDTD == XML_TRUE is passed to this function, then the parser
will assume that there is an external subset, even if none is
specified in the document. In such a case the parser will call the
externalEntityRefHandler with a value of NULL for the systemId
argument (the publicId and context arguments will be NULL as well).
Note: For the purpose of checking WFC: Entity Declared, passing
useDTD == XML_TRUE will make the parser behave as if the document
had a DTD with an external subset.
Note: If this function is called, then this must be done before
the first call to XML_Parse or XML_ParseBuffer, since it will
have no effect after that. Returns
XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING.
Note: If the document does not have a DOCTYPE declaration at all,
then startDoctypeDeclHandler and endDoctypeDeclHandler will not
be called, despite an external subset being parsed.
Note: If XML_DTD is not defined when Expat is compiled, returns
XML_ERROR_FEATURE_REQUIRES_XML_DTD.
*/
XMLPARSEAPI(enum XML_Error)
XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD);
/* Sets the base to be used for resolving relative URIs in system
identifiers in declarations. Resolving relative identifiers is
left to the application: this value will be passed through as the
base argument to the XML_ExternalEntityRefHandler,
XML_NotationDeclHandler and XML_UnparsedEntityDeclHandler. The base
argument will be copied. Returns XML_STATUS_ERROR if out of memory,
XML_STATUS_OK otherwise.
*/
XMLPARSEAPI(enum XML_Status)
XML_SetBase(XML_Parser parser, const XML_Char *base);
XMLPARSEAPI(const XML_Char *)
XML_GetBase(XML_Parser parser);
/* Returns the number of the attribute/value pairs passed in last call
to the XML_StartElementHandler that were specified in the start-tag
rather than defaulted. Each attribute/value pair counts as 2; thus
this correspondds to an index into the atts array passed to the
XML_StartElementHandler.
*/
XMLPARSEAPI(int)
XML_GetSpecifiedAttributeCount(XML_Parser parser);
/* Returns the index of the ID attribute passed in the last call to
XML_StartElementHandler, or -1 if there is no ID attribute. Each
attribute/value pair counts as 2; thus this correspondds to an
index into the atts array passed to the XML_StartElementHandler.
*/
XMLPARSEAPI(int)
XML_GetIdAttributeIndex(XML_Parser parser);
/* Parses some input. Returns XML_STATUS_ERROR if a fatal error is
detected. The last call to XML_Parse must have isFinal true; len
may be zero for this call (or any other).
Though the return values for these functions has always been
described as a Boolean value, the implementation, at least for the
1.95.x series, has always returned exactly one of the XML_Status
values.
*/
XMLPARSEAPI(enum XML_Status)
XML_Parse(XML_Parser parser, const char *s, int len, int isFinal);
XMLPARSEAPI(void *)
XML_GetBuffer(XML_Parser parser, int len);
XMLPARSEAPI(enum XML_Status)
XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
/* Stops parsing, causing XML_Parse() or XML_ParseBuffer() to return.
Must be called from within a call-back handler, except when aborting
(resumable = 0) an already suspended parser. Some call-backs may
still follow because they would otherwise get lost. Examples:
- endElementHandler() for empty elements when stopped in
startElementHandler(),
- endNameSpaceDeclHandler() when stopped in endElementHandler(),
and possibly others.
Can be called from most handlers, including DTD related call-backs,
except when parsing an external parameter entity and resumable != 0.
Returns XML_STATUS_OK when successful, XML_STATUS_ERROR otherwise.
Possible error codes:
- XML_ERROR_SUSPENDED: when suspending an already suspended parser.
- XML_ERROR_FINISHED: when the parser has already finished.
- XML_ERROR_SUSPEND_PE: when suspending while parsing an external PE.
When resumable != 0 (true) then parsing is suspended, that is,
XML_Parse() and XML_ParseBuffer() return XML_STATUS_SUSPENDED.
Otherwise, parsing is aborted, that is, XML_Parse() and XML_ParseBuffer()
return XML_STATUS_ERROR with error code XML_ERROR_ABORTED.
*Note*:
This will be applied to the current parser instance only, that is, if
there is a parent parser then it will continue parsing when the
externalEntityRefHandler() returns. It is up to the implementation of
the externalEntityRefHandler() to call XML_StopParser() on the parent
parser (recursively), if one wants to stop parsing altogether.
When suspended, parsing can be resumed by calling XML_ResumeParser().
*/
XMLPARSEAPI(enum XML_Status)
XML_StopParser(XML_Parser parser, XML_Bool resumable);
/* Resumes parsing after it has been suspended with XML_StopParser().
Must not be called from within a handler call-back. Returns same
status codes as XML_Parse() or XML_ParseBuffer().
Additional error code XML_ERROR_NOT_SUSPENDED possible.
*Note*:
This must be called on the most deeply nested child parser instance
first, and on its parent parser only after the child parser has finished,
to be applied recursively until the document entity's parser is restarted.
That is, the parent parser will not resume by itself and it is up to the
application to call XML_ResumeParser() on it at the appropriate moment.
*/
XMLPARSEAPI(enum XML_Status)
XML_ResumeParser(XML_Parser parser);
enum XML_Parsing {
XML_INITIALIZED,
XML_PARSING,
XML_FINISHED,
XML_SUSPENDED
};
typedef struct {
enum XML_Parsing parsing;
XML_Bool finalBuffer;
} XML_ParsingStatus;
/* Returns status of parser with respect to being initialized, parsing,
finished, or suspended and processing the final buffer.
XXX XML_Parse() and XML_ParseBuffer() should return XML_ParsingStatus,
XXX with XML_FINISHED_OK or XML_FINISHED_ERROR replacing XML_FINISHED
*/
XMLPARSEAPI(void)
XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status);
/* Creates an XML_Parser object that can parse an external general
entity; context is a '\0'-terminated string specifying the parse
context; encoding is a '\0'-terminated string giving the name of
the externally specified encoding, or NULL if there is no
externally specified encoding. The context string consists of a
sequence of tokens separated by formfeeds (\f); a token consisting
of a name specifies that the general entity of the name is open; a
token of the form prefix=uri specifies the namespace for a
particular prefix; a token of the form =uri specifies the default
namespace. This can be called at any point after the first call to
an ExternalEntityRefHandler so longer as the parser has not yet
been freed. The new parser is completely independent and may
safely be used in a separate thread. The handlers and userData are
initialized from the parser argument. Returns NULL if out of memory.
Otherwise returns a new XML_Parser object.
*/
XMLPARSEAPI(XML_Parser)
XML_ExternalEntityParserCreate(XML_Parser parser,
const XML_Char *context,
const XML_Char *encoding);
enum XML_ParamEntityParsing {
XML_PARAM_ENTITY_PARSING_NEVER,
XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE,
XML_PARAM_ENTITY_PARSING_ALWAYS
};
/* Controls parsing of parameter entities (including the external DTD
subset). If parsing of parameter entities is enabled, then
references to external parameter entities (including the external
DTD subset) will be passed to the handler set with
XML_SetExternalEntityRefHandler. The context passed will be 0.
Unlike external general entities, external parameter entities can
only be parsed synchronously. If the external parameter entity is
to be parsed, it must be parsed during the call to the external
entity ref handler: the complete sequence of
XML_ExternalEntityParserCreate, XML_Parse/XML_ParseBuffer and
XML_ParserFree calls must be made during this call. After
XML_ExternalEntityParserCreate has been called to create the parser
for the external parameter entity (context must be 0 for this
call), it is illegal to make any calls on the old parser until
XML_ParserFree has been called on the newly created parser.
If the library has been compiled without support for parameter
entity parsing (ie without XML_DTD being defined), then
XML_SetParamEntityParsing will return 0 if parsing of parameter
entities is requested; otherwise it will return non-zero.
Note: If XML_SetParamEntityParsing is called after XML_Parse or
XML_ParseBuffer, then it has no effect and will always return 0.
*/
XMLPARSEAPI(int)
XML_SetParamEntityParsing(XML_Parser parser,
enum XML_ParamEntityParsing parsing);
/* If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then
XML_GetErrorCode returns information about the error.
*/
XMLPARSEAPI(enum XML_Error)
XML_GetErrorCode(XML_Parser parser);
/* These functions return information about the current parse
location. They may be called from any callback called to report
some parse event; in this case the location is the location of the
first of the sequence of characters that generated the event. When
called from callbacks generated by declarations in the document
prologue, the location identified isn't as neatly defined, but will
be within the relevant markup. When called outside of the callback
functions, the position indicated will be just past the last parse
event (regardless of whether there was an associated callback).
They may also be called after returning from a call to XML_Parse
or XML_ParseBuffer. If the return value is XML_STATUS_ERROR then
the location is the location of the character at which the error
was detected; otherwise the location is the location of the last
parse event, as described above.
*/
XMLPARSEAPI(XML_Size) XML_GetCurrentLineNumber(XML_Parser parser);
XMLPARSEAPI(XML_Size) XML_GetCurrentColumnNumber(XML_Parser parser);
XMLPARSEAPI(XML_Index) XML_GetCurrentByteIndex(XML_Parser parser);
/* Return the number of bytes in the current event.
Returns 0 if the event is in an internal entity.
*/
XMLPARSEAPI(int)
XML_GetCurrentByteCount(XML_Parser parser);
/* If XML_CONTEXT_BYTES is defined, returns the input buffer, sets
the integer pointed to by offset to the offset within this buffer
of the current parse position, and sets the integer pointed to by size
to the size of this buffer (the number of input bytes). Otherwise
returns a NULL pointer. Also returns a NULL pointer if a parse isn't
active.
NOTE: The character pointer returned should not be used outside
the handler that makes the call.
*/
XMLPARSEAPI(const char *)
XML_GetInputContext(XML_Parser parser,
int *offset,
int *size);
/* For backwards compatibility with previous versions. */
#define XML_GetErrorLineNumber XML_GetCurrentLineNumber
#define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber
#define XML_GetErrorByteIndex XML_GetCurrentByteIndex
/* Frees the content model passed to the element declaration handler */
XMLPARSEAPI(void)
XML_FreeContentModel(XML_Parser parser, XML_Content *model);
/* Exposing the memory handling functions used in Expat */
XMLPARSEAPI(void *)
XML_MemMalloc(XML_Parser parser, size_t size);
XMLPARSEAPI(void *)
XML_MemRealloc(XML_Parser parser, void *ptr, size_t size);
XMLPARSEAPI(void)
XML_MemFree(XML_Parser parser, void *ptr);
/* Frees memory used by the parser. */
XMLPARSEAPI(void)
XML_ParserFree(XML_Parser parser);
/* Returns a string describing the error. */
XMLPARSEAPI(const XML_LChar *)
XML_ErrorString(enum XML_Error code);
/* Return a string containing the version number of this expat */
XMLPARSEAPI(const XML_LChar *)
XML_ExpatVersion(void);
typedef struct {
int major;
int minor;
int micro;
} XML_Expat_Version;
/* Return an XML_Expat_Version structure containing numeric version
number information for this version of expat.
*/
XMLPARSEAPI(XML_Expat_Version)
XML_ExpatVersionInfo(void);
/* Added in Expat 1.95.5. */
enum XML_FeatureEnum {
XML_FEATURE_END = 0,
XML_FEATURE_UNICODE,
XML_FEATURE_UNICODE_WCHAR_T,
XML_FEATURE_DTD,
XML_FEATURE_CONTEXT_BYTES,
XML_FEATURE_MIN_SIZE,
XML_FEATURE_SIZEOF_XML_CHAR,
XML_FEATURE_SIZEOF_XML_LCHAR,
XML_FEATURE_NS
/* Additional features must be added to the end of this enum. */
};
typedef struct {
enum XML_FeatureEnum feature;
const XML_LChar *name;
long int value;
} XML_Feature;
XMLPARSEAPI(const XML_Feature *)
XML_GetFeatureList(void);
/* Expat follows the GNU/Linux convention of odd number minor version for
beta/development releases and even number minor version for stable
releases. Micro is bumped with each release, and set to 0 with each
change to major or minor version.
*/
#define XML_MAJOR_VERSION 2
#define XML_MINOR_VERSION 0
#define XML_MICRO_VERSION 0
#ifdef __cplusplus
}
#endif
#endif /* not Expat_INCLUDED */
tandem-linux-13-09-01-1/src/Makefile_ubuntu 0000664 0001750 0001750 00000003200 12211622371 020451 0 ustar langella langella #makefile for c++ programs
#change the name of the executable to use for "any" project
EXECUTABLE = ../bin/tandem.exe
#EXECUTABLE = ../bin/p3.exe
LINKCC = $(CXX)
#CXXFLAGS denotes flags for the C++ compiler
CXX = g++
#uncomment this line if you are using gcc 4.x
CXXFLAGS = -w -O2 -DGCC4_3
#CXXFLAGS = -w -O2 -DGCC4_3 -DX_P3
#ubuntu 64 bit version
#LDFLAGS = -lpthread -L/usr/lib -lm /usr/local/lib/libexpat.a -static-libstdc++
#LDFLAGS = -lpthread -L/usr/lib -lm /usr/local/lib/libexpat.a
#LDFLAGS = -lpthread -L/usr/lib -lm -lexpat
#LDFLAGS = -lpthread -lm -L/usr/lib /usr/lib/x86_64-linux-gnu/libexpat.a -static-libstdc++
#LDFLAGS = -lpthread -lm -L/usr/lib /usr/lib/x86_64-linux-gnu/libexpat.a
LDFLAGS = -lpthread -lm -lexpat
SRCS := $(wildcard *.cpp)
OBJS := $(patsubst %.cpp,%.o,$(wildcard *.cpp))
DEPS := $(patsubst %.o,%.d,$(OBJS))
all: $(EXECUTABLE)
#define the components of the program, and how to link them
#these components are defined as dependencies; that is they must be up-to-date before the code is linked
$(EXECUTABLE): $(DEPS) $(OBJS)
$(LINKCC) $(CXXFLAGS) -o $(EXECUTABLE) $(OBJS) $(LDFLAGS)
#specify the dep files depend on the cpp files
%.d: %.cpp
$(CXX) -M $(CXXFLAGS) $< > $@
$(CXX) -M $(CXXFLAGS) $< | sed s/\\.o/.d/ > $@
clean:
-rm $(OBJS) $(EXECUTABLE) $(DEPS) *~
explain:
@echo "The following info represents the program:"
@echo "Final exec name: $(EXECUTABLE)"
@echo "Source files: $(SRCS)"
@echo "Object files: $(OBJS)"
@echo "Dep files: $(DEPS)"
depend: $(DEPS)
@echo "Deps are now up-to-date."
-include $(DEPS)
tandem-linux-13-09-01-1/src/mscore_tandem.cpp 0000664 0001750 0001750 00000046312 12173254450 020754 0 ustar langella langella /*
Copyright (C) 2003-2004 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
// File version: 2005-01-23
#include "stdafx.h"
#include "msequence.h"
#include "mspectrum.h"
#include "msequtilities.h"
#include "mscore_tandem.h"
// Factory instance, registers itself with the mscoremanager.
static mscorefactory_tandem factory;
mscorefactory_tandem::mscorefactory_tandem()
{
mscoremanager::register_factory("tandem", this);
}
mplugin* mscorefactory_tandem::create_plugin()
{
return new mscore_tandem();
}
mscore_tandem::mscore_tandem(void)
{
m_fScale = 4.0;
m_pFactorial = new double[64];
double dFac = 1.0;
m_pFactorial[0] = 1.0;
long a = 1;
while(a < 64) {
dFac *= (double)a;
m_pFactorial[a] = dFac;
a++;
}
m_uiSimd = 0;
m_pfLogs = new float[101];
float fV = (float)0.01;
a = 1;
m_pfLogs[0] = 0;
while(a < 101) {
m_pfLogs[a] = log(fV);
fV += (float)0.01;
a++;
}
m_fLog2 = (float)log(2.0);
m_fLog10 = (float)(1.0/log(10.0));
#ifdef MSVC
m_uiSimd = check_simd();
if(m_uiSimd == 1) {
cout << "|";
cout.flush();
}
#endif
}
mscore_tandem::~mscore_tandem(void)
{
if(m_pplType) {
size_t a = 0;
while(a < m_vmiType.size()) {
if(m_pplType[a]) {
delete m_pplType[a];
}
a++;
}
delete m_pplType;
}
if(m_pfLogs != NULL) {
delete m_pfLogs;
}
if(m_pFactorial != NULL)
delete m_pFactorial;
}
/*
* add_mi does the work necessary to set up an mspectrum object for modeling.
* - an entry in the m_State object is made for the parent ion M+H
* once an mspectrum has been added, the original mspectrum is no longer
* needed for modeling, as all of the work associated with a spectrum
* is only done once, prior to modeling sequences.
*/
bool mscore_tandem::add_mi(mspectrum &_s)
{
if (!mscore::add_mi(_s))
return false;
if (m_vmiType.size() == 0) {
m_vmiType.reserve((long)m_vSpec.size());
m_pplType = new unsigned long *[m_vSpec.size()+1];
size_t a = 0;
while(a < m_vSpec.size()+1) {
m_pplType[a] = NULL;
a++;
}
}
/*
* use blur to improve accuracy at the edges of the fragment ion m/z error range
*/
blur(_s.m_vMI);
return true;
}
/*
* blur takes an SMap object and adds values to it adjacent to the
* values in the existing map. this process makes the conversion from
* floating point m/z values to integer SMap index values more accurate.
* the half-width of the distribution around each initial value is set
* by the m_dWidth value. For example,
*
* if there is an intensity value I at index value N,
* then with a width of 2, the following new values are created,
* I(N-2),I(N-1),I(N+1),I(N+2)
*
* the value for the width has an impact on the performance of the
* protein modeling session: the wider the width, the more memory that is required to hold
* the SMaps for the spectra. as that memory expands, the ability of
* the various processor caches to hold the SMaps will change. keeping
* the SMaps in the fastest cache speeds up the calculation considerably.
*/
__inline__ bool mscore_tandem::blur(vector &_s)
{
vmiType vType;
MIType uType;
uType.m_fI = 0.0;
uType.m_lM = 0;
long lValue = 0;
long a = 0;
long w = (long)(0.1+m_dWidth);
/*
* fConvert and fFactor are only used if the m_lErrorType uses ppm for fragment ion mass errors
* if ppm is used, the width at m/z = 200.0 is taken as the base width for blurring & the
* width is scaled by the measured m/z.
* NOTE: the m_fErr value used in the ppm case is: (the error in ppm) x 200
*/
double dConvert = m_dErr/m_dWidth;
const double dFactor = 200.0/dConvert;
const size_t tSize = _s.size();
long u = w;
size_t tCount = 0;
vType.reserve(tSize*3);
/*
* add additional values based on the m_dWidth setting
*/
while(tCount < tSize) {
if(_s[tCount].m_fI > 0.5) {
lValue = (long)((double)_s[tCount].m_fM/dConvert);
a = -1*w;
if(m_lErrorType & T_FRAGMENT_PPM) {
a = (long)((double)a * (double)lValue/dFactor - 0.5);
if(a > -1*w)
a = -1*w;
}
// u was added to correct an error: previously w was used as the upper limit for this calculation
// resulting in unbalanced ppm windows
u = -1*a;
while(a <= u) {
if(uType.m_lM == lValue + a) {
if(uType.m_fI < _s[tCount].m_fI) {
vType.back().m_fI = _s[tCount].m_fI;
}
}
else {
uType.m_lM = lValue + a;
uType.m_fI = _s[tCount].m_fI;
vType.push_back(uType);
}
a++;
}
}
tCount++;
}
m_vmiType.push_back(vType);
return true;
}
/*
* hfactor returns a factor applied to the score to produce the
* hyper score, given a number of ions matched.
*/
double mscore_tandem::hfactor(long _l) {
if(_l > 63) {
return m_pFactorial[63];
}
return m_pFactorial[_l];
}
/*
* hconvert is use to convert a hyper score to the value used in a score
* histogram, since the actual scoring distribution may not lend itself
* to statistical analysis through use of a histogram.
*/
float mscore_tandem::hconvert(float _f) {
if(_f <= 0.0)
return 0.0;
return m_fScale*(float)log10(_f);
}
__inline__ float mscore_tandem::log_10(float _f) {
int iV;
double man = frexp(_f,&iV);
int iM = (int)(man*100.0 + 0.5);
return (iV*m_fLog2 + m_pfLogs[iM])*m_fLog10;
}
bool mscore_tandem::clear()
{
m_vmiType.clear();
return true;
}
/*
* dot is the fundamental logic for scoring a peptide with a mass spectrum.
* the mass spectrum is determined by the value of m_lId, which is its index
* number in the m_vsmapMI vector. the sequence is represented by the values
* that are currently held in m_plSeq (integer masses) and m_pfSeq (scoring
* weight factors).
* convolution scores are the sum of the products of the spectrum intensities
* and the scoring weight factors for a spectrum.
* hyper scores are the product of the products of the spectrum intensities
* and the scoring weight factors for a spectrum.
* the number of predicted ions that correspond to non-zero intensities in
* the spectrum are tallied and returned.
*/
double mscore_tandem::dot(unsigned long *_v)
{
float fScore = 0.0;
float fValue0 = 0.0;
unsigned long a = 0;
unsigned long lCount = 0;
long lType = 0;
size_t b = 0;
vector::iterator itType = m_vmiType[m_lId].begin();
// tType and tTypeSize were added in 2006.09.01 to correct a problem
// created by VC++ 2005. This new version uses a strict bounds checking
// style for STL iterators, that cause a run time error if an iterator
// longer than .end() is produced by incrementing the iterator.
size_t tType = 0;
const size_t tTypeSize = m_vmiType[m_lId].size();
unsigned long *pType = NULL;
if(!m_pplType[m_lId]) {
m_pplType[m_lId] = new unsigned long[tTypeSize];
pType = m_pplType[m_lId];
while(tType < tTypeSize) {
pType[tType] = itType->m_lM;
++itType;
tType++;
}
}
else {
pType = m_pplType[m_lId];
}
itType = m_vmiType[m_lId].begin();
tType = 0;
size_t tStep = (size_t)(0.5 + (double)tTypeSize/(double)m_lCount);
if(tStep < 1) {
tStep = 1;
}
unsigned long lSeq = m_plSeq[a];
while(lSeq != 0 && tType != tTypeSize) {
lType = 0;
if(*pType < lSeq) {
lType = 1;
// Generally lots more spectrum peaks than sequence peaks. Trying
// large steps first helps reduce performance hit for this operation.
// This is were the iterator bounds checking failed in VC++ 2005.
// By checking the size first, the iterator is not evaluated and
// does not produce the failure.
while (tType+tStep < tTypeSize && *(pType+tStep) < lSeq) {
tType += tStep;
pType += tStep;
}
do {
tType++;
pType++;
} while(tType < tTypeSize && *(pType) < lSeq);
}
else if(*pType > lSeq) {
do {
a++;
lSeq = m_plSeq[a];
} while(*pType > lSeq && lSeq != 0);
}
if(lSeq == 0 || tType == tTypeSize) {
break;
}
if(*pType == lSeq) {
// if((itType+tType)->m_fI > 0.0 && m_pfSeq[a] > 0.0) {
m_pafI[lCount] = (itType+tType)->m_fI;
m_pafSeq[lCount] = m_pfSeq[a];
lCount++;
// }
}
if(lType) {
a++;
lSeq = m_plSeq[a];
}
else {
tType++;
pType++;
}
}
*_v = lCount;
if(lCount == 0) {
return fScore;
}
#ifdef MSVC
if(!m_uiSimd) {
for(a = 0; a < lCount; a++) {
fScore += m_pafI[a] * m_pafSeq[a];
}
return fScore;
}
if(lCount < 5) {
for(a = 0; a < lCount; a++) {
fScore += m_pafI[a] * m_pafSeq[a];
}
return fScore;
}
// align the arrays to 4 float boundary
for(a = 0; lCount % 4 != 0; a++) {
m_pafI[lCount] = 0.0;
m_pafSeq[lCount] = 0.0;
lCount++;
}
// create compatible pointers
__m128* pSum = (__m128*) m_pafSum;
__m128* pI = (__m128*) m_pafI;
__m128* pS = (__m128*) m_pafSeq;
__m128 Sum = _mm_set1_ps(0.0);
__m128 S1 = _mm_set1_ps(0.0);
unsigned int n = lCount/4;
// perform intrinsic calls for SIMD registers
for(a = 0; a < n; a++) {
S1 = _mm_mul_ps(*pI,*pS);
Sum = _mm_add_ps(Sum,S1);
pI++;
pS++;
}
m_um128.m = Sum;
fScore = m_um128.f[0] + m_um128.f[1] + m_um128.f[2] + m_um128.f[3];
#else
for(a = 0; a < lCount; a++) {
fScore += m_pafI[a] * m_pafSeq[a];
}
#endif
return (fScore);
}
#ifdef MSVC
unsigned int mscore_tandem::check_simd(void)
{
unsigned int iSimd = 0;
int CPUInfo[4] = {-1};
__cpuid(CPUInfo, 0);
unsigned int nIds = CPUInfo[0];
for (unsigned int i=0; i<=nIds; ++i) {
__cpuid(CPUInfo, i);
// Interpret CPU feature information
if (i == 1) {
if(((CPUInfo[3] >> 26) & 0x01) && sizeof(int *) == 8) {
return 1;
}
}
}
return iSimd;
}
#endif
/*
double mscore_tandem::dot(unsigned long *_v)
{
float fScore = 0.0;
float fValue0 = 0.0;
unsigned long a = 0;
unsigned long lCount = 0;
long lType = 0;
size_t b = 0;
vector::iterator itType = m_vmiType[m_lId].begin();
// tType and tTypeSize were added in 2006.09.01 to correct a problem
// created by VC++ 2005. This new version uses a strict bounds checking
// style for STL iterators, that cause a run time error if an iterator
// longer than .end() is produced by incrementing the iterator.
register size_t tType = 0;
size_t tTypeSize = m_vmiType[m_lId].size();
register unsigned long *pType = NULL;
if(!m_pplType[m_lId]) {
m_pplType[m_lId] = new unsigned long[tTypeSize];
pType = m_pplType[m_lId];
while(tType < tTypeSize) {
pType[tType] = itType->m_lM;
++itType;
tType++;
}
}
else {
pType = m_pplType[m_lId];
}
tType = 0;
size_t tStep = (size_t)(0.5+(float)tTypeSize/(float)m_lCount);
if(tStep == 0) {
tStep = 1;
}
register unsigned long lSeq = m_plSeq[a];
while(lSeq != 0 && tType != tTypeSize) {
lType = 0;
if(pType[tType] < lSeq) {
lType = 1;
// Generally lots more spectrum peaks than sequence peaks. Trying
// large steps first helps reduce performance hit for this operation.
// This is were the iterator bounds checking failed in VC++ 2005.
// By checking the size first, the iterator is not evaluated and
// does not produce the failure.
while (tType+tStep < tTypeSize && *(pType+tType+tStep) < lSeq) {
tType += tStep;
}
do {
tType++;
} while(tType < tTypeSize && *(pType+tType) < lSeq);
}
else if(pType[tType] > lSeq) {
do {
a++;
lSeq = m_plSeq[a];
} while(pType[tType] > lSeq && lSeq != 0);
}
if(lSeq == 0 || tType == tTypeSize) {
break;
}
if(pType[tType] == lSeq) {
fValue0 = m_vmiType[m_lId][tType].m_fI * m_pfSeq[a];
if(fValue0 > 0.0) {
lCount++;
fScore += fValue0;
}
}
if(lType) {
a++;
lSeq = m_plSeq[a];
}
else {
tType++;
}
}
*_v = lCount;
return (fScore);
}
*/
float mscore_tandem::ion_check(const unsigned long _v,const size_t _s)
{
unsigned long a = 0;
unsigned long lCount = 0;
long lType = 0;
size_t b = 0;
vector::iterator itType = m_vmiType[_s].begin();
vector::const_iterator itStart = m_vmiType[_s].begin();
vector::const_iterator itEnd = m_vmiType[_s].end();
// tType and tTypeSize were added in 2006.09.01 to correct a problem
// created by VC++ 2005. This new version uses a strict bounds checking
// style for STL iterators, that cause a run time error if an iterator
// longer than .end() is produced by incrementing the iterator.
size_t tTypeSize = m_vmiType[_s].size();
size_t tType = tTypeSize/2;
float fV = (float)1.0;
itType += tType;
if(itType->m_lM == _v) {
fV = itType->m_fI;
return fV;
}
else if(_v > itType->m_lM) {
itType++;
while(itType != itEnd) {
if(itType->m_lM == _v) {
fV = itType->m_fI;
return fV;
}
if(_v < itType->m_lM) {
return fV;
}
itType++;
}
return fV;
}
else {
itType--;
while(itType != itStart) {
if(itType->m_lM == _v) {
fV = itType->m_fI;
return fV;
}
if(_v > itType->m_lM) {
return fV;
}
itType--;
}
return fV;
}
return fV;
}
tandem-linux-13-09-01-1/src/saxmzmlhandler.h 0000664 0001750 0001750 00000004462 11437174002 020626 0 ustar langella langella #if !defined(SAXMZMLHANDLER_H)
#define SAXMZMLHANDLER_H
#include "saxhandler.h"
#include
#include
/**
* Uses eXpat SAX parser to parse mzData XML.
*/
class SAXMzmlHandler : public SAXSpectraHandler
{
public:
SAXMzmlHandler( vector& _pv, mspectrumcondition& _p, mscore& _m);
~SAXMzmlHandler();
// -----------------------------------------------------------------------
// Overrides of SAXHandler functions
// -----------------------------------------------------------------------
/**
* Receive notification of the start of an element.
*
* By default, do nothing. Application writers may override this
* method in a subclass to take specific actions at the start of
* each element (such as allocating a new tree node or writing
* output to a file).
*/
void startElement(const XML_Char *el, const XML_Char **attr);
/**
* Receive notification of the end of an element.
*
* By default, do nothing. Application writers may override this
* method in a subclass to take specific actions at the end of
* each element (such as finalising a tree node or writing
* output to a file).
*/
void endElement(const XML_Char *el);
/**
* Receive notification of character data inside an element.
*
* By default, do nothing. Application writers may override this
* method to take specific actions for each chunk of character data
* (such as adding the data to a node or buffer, or printing it to
* a file).
*/
void characters(const XML_Char *s, int len);
private:
/**
* Handle attributes for a peaksListBinaryType element.
*/
void startPeakListBinary(const XML_Char **attr);
set m_sId;
/**
* Handle data collected in the characters() function.
*/
void processData();
/**
* Process cv params
*/
void processCVParam(const char* name, const char* accession, const char* value);
private:
// Flags indicating parser is inside a particular tag.
bool m_bInRefGroup;
bool m_bInMsLevel2;
bool m_bInmzArrayBinary;
bool m_bInintenArrayBinary;
bool m_bInData;
string m_ccurrentRefGroupName;
class cvParam
{
public:
string refGroupName;
string name;
string accession;
string value;
};
vector m_refGroupCvParams;
};
#endif //SAXMZMLHANDLER_H
tandem-linux-13-09-01-1/src/msequenceserver.h 0000664 0001750 0001750 00000021653 11423336103 021007 0 ustar langella langella /*
Copyright (C) 2003 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
#ifndef MSEQUENCESERVER_H
#define MSEQUENCESERVER_H
// File version: 2003-07-01
/*
* msequenceserver takes a sequence list file (in FASTA format) and uses it to load an
* msequencecontainer object with a set of amino acid sequences and descriptions. the container
* can be loaded repeatedly until the end-of-file is reached. the next list file path in a
* deque of file names is then extracted and the process continues until the last
* sequence from the last file in the deque is read into the msequencecontainer.
*/
typedef map DESMAP;
class msequenceCollection;
class msequenceServer
{
public:
msequenceServer(void);
virtual ~msequenceServer(void);
size_t m_tColMax; // Maximum size of a sequence collection
size_t m_tStartAt; // Ordinal number of the first sequence retreived
string m_strPath; // Full path name to the current FASTA file
string m_strStatus; // Status string for debugging
string m_strFirst;
string m_strTaxonPath; // Path to the taxonomy translation file
string m_strTaxon; // Taxon to model
msequenceCollection *m_pCol; // Sequence collection ring
deque m_dstrFasta; // List of FASTA files
vector m_vstrFasta;
vector m_vstrDesc;
vector m_vstrPaths;
enum {
FASTA = 0,
XBANG = 1,
UNKNOWN = 0xFFFFFFFF,
} mfiletypes;
bool clear(void);
bool done(void); // true if all sequences retrieved
bool error(void); // true if object in any error state
double get_time(void); // returns the elapsed time
virtual long load_file(const string &_p,const string &_t);
bool initialize(const size_t _t);
unsigned long next(const bool _b); // Method to retrieve ASequenceCollection object
unsigned long next_pro(const bool _b); // Method to retrieve ASequenceCollection object
bool started(void); // true if object was correctly started
bool working(void); // true if retrieving sequence
protected:
// Status indicators
bool m_bStarted; // true if the server is processing files
bool m_bDone; // true if the last sequence has been read
bool m_bError; // true if the server is in an error condition
double m_dTime; // the elapsed time taken to read sequences
FILE *m_pInput; // a pointer to an input file
unsigned long m_lFileType;
// Initializing/termination method
char *m_pLine;
unsigned long m_lSize;
bool finish(void);
unsigned long mac_rev(const unsigned long _l);
unsigned long next_l(void); // Method to retrieve ASequenceCollection object
bool start(void);
bool bz(char *_p);
};
#include "p3msequenceserver.h"
#endif
tandem-linux-13-09-01-1/src/saxtaxhandler.h 0000664 0001750 0001750 00000020064 10510310074 020427 0 ustar langella langella /*
Copyright (C) 2003-2005 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
// File version: 2005-07-29
/*
* saxtaxhandler.h contains the override methods necessary for compatibility with
* gaml mass spectrum file formats.
*/
#if !defined(SAXTAXHANDLER_H)
#define SAXTAXHANDLER_H
#include "saxhandler.h"
#include
/**
* Uses eXpat SAX parser to parse taxonomy data.
*/
class SAXTaxHandler : public SAXHandler
{
public:
SAXTaxHandler(const string& _p, const string& _t, vector& _vP);
~SAXTaxHandler();
bool load(const string &_y);
protected:
// -----------------------------------------------------------------------
// Overrides of SAXHandler functions
// -----------------------------------------------------------------------
/**
* Receive notification of the start of an element.
*
* By default, do nothing. Application writers may override this
* method in a subclass to take specific actions at the start of
* each element (such as allocating a new tree node or writing
* output to a file).
*/
void startElement(const XML_Char *el, const XML_Char **attr);
/**
* Receive notification of the end of an element.
*
* By default, do nothing. Application writers may override this
* method in a subclass to take specific actions at the end of
* each element (such as finalising a tree node or writing
* output to a file).
*/
void endElement(const XML_Char *el);
vector* m_vstrPaths; //the vector of paths
string m_strPath; // the path to the taxonomy.xml
string m_strTax; //the current taxonomy
set m_setTax;
set m_setPaths;
string m_strType;
bool m_bTax; //true if current tax matches that from taxonomy.xml.
};
#endif //SAXTAXHANDLER_H
tandem-linux-13-09-01-1/src/msequencecollection.h 0000664 0001750 0001750 00000016206 10260254412 021632 0 ustar langella langella /*
Copyright (C) 2003 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
#ifndef MSEQUENCECOLLECTION_H
#define MSEQUENCECOLLECTION_H
// File version: 2003-07-01
/*
* msequenceCollection objects are used to store lists of msequences, mainly serving as a
* wrapper class for the m_vASequences member
*/
class msequenceCollection
{
public:
msequenceCollection(void);
virtual ~msequenceCollection(void);
size_t m_tLength;
size_t m_tMax; // maximum number of sequences to be stored in the m_vASequences vector
vector m_vASequences; // a vector of msequence objects
bool clear(void); // removes all msequences from the container
bool full(void); // returns true if m_vASequences congtains >= m_tMax sequences
size_t size(void); // returns the current size of m_vASequences
bool initialize(const size_t _t);
};
#endif
tandem-linux-13-09-01-1/src/saxmzdatahandler.h 0000664 0001750 0001750 00000003750 10713662524 021135 0 ustar langella langella #if !defined(SAXMZDATAHANDLER_H)
#define SAXMZDATAHANDLER_H
#include "saxhandler.h"
#include
/**
* Uses eXpat SAX parser to parse mzData XML.
*/
class SAXMzdataHandler : public SAXSpectraHandler
{
public:
SAXMzdataHandler( vector& _pv, mspectrumcondition& _p, mscore& _m );
~SAXMzdataHandler();
// -----------------------------------------------------------------------
// Overrides of SAXHandler functions
// -----------------------------------------------------------------------
/**
* Receive notification of the start of an element.
*
* By default, do nothing. Application writers may override this
* method in a subclass to take specific actions at the start of
* each element (such as allocating a new tree node or writing
* output to a file).
*/
void startElement(const XML_Char *el, const XML_Char **attr);
/**
* Receive notification of the end of an element.
*
* By default, do nothing. Application writers may override this
* method in a subclass to take specific actions at the end of
* each element (such as finalising a tree node or writing
* output to a file).
*/
void endElement(const XML_Char *el);
/**
* Receive notification of character data inside an element.
*
* By default, do nothing. Application writers may override this
* method to take specific actions for each chunk of character data
* (such as adding the data to a node or buffer, or printing it to
* a file).
*/
void characters(const XML_Char *s, int len);
private:
/**
* Handle attributes for a peaksListBinaryType element.
*/
void startPeakListBinary(const XML_Char **attr);
set m_sId;
/**
* Handle data collected in the characters() function.
*/
void processData();
private:
// Flags indicating parser is inside a particular tag.
bool m_bInMsLevel2;
bool m_bInmzArrayBinary;
bool m_bInintenArrayBinary;
bool m_bInData;
};
#endif //SAXMZDATAHANDLER_H
tandem-linux-13-09-01-1/src/mtermmods.h 0000664 0001750 0001750 00000016502 10311635156 017604 0 ustar langella langella /*
Copyright (C) 2005 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
// File version: 2005-09-01
#ifndef MTERMMODS_H
#define MTERMMODS_H
#include "mrefine.h"
class mpeptide;
class msequence;
class mprocess;
class mtermmods : public mrefine
{
public:
mtermmods();
~mtermmods(void);
bool refine(); //entry point for terminal modification processing
bool set_mprocess(mprocess *_p); //set the m_pProcess object
mprocess *m_pProcess; //pointer to the parent mprocess class
};
/*
* mtermmodsmanager is used to organize and facilitate the creation of mtermmods objects
*/
class mtermmodsmanager
{
public:
static const char* TYPE;
static mtermmods* create_mtermmods(XmlParameter &_x);
static void register_factory(const char* _spec, mpluginfactory* _f);
};
/*
* mrefinefactory_tandem implements a factory for creating mtermmods
* instances.
*/
class mtermmodsfactory_tandem : public mpluginfactory
{
public:
mtermmodsfactory_tandem();
virtual mplugin* create_plugin();
};
#endif
tandem-linux-13-09-01-1/src/saxtandeminputhandler.cpp 0000664 0001750 0001750 00000017456 10477572166 022561 0 ustar langella langella /*
Copyright (C) 2003-2005 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
// File version: 2005-07-29
/*
* saxtandeminputhandler.cpp parses Tandem Input data (input.xml and default_input.xml)
* and populates the reference to XmlParameter::m_mapParam[strKey] = strValue;
*/
#include "stdafx.h"
#include "saxtandeminputhandler.h"
SAXTandemInputHandler::SAXTandemInputHandler(const string& _p, xMap& _map)
{
m_strXmlPath = _p;
m_mapParam = &_map;
m_bInput=false;
}
SAXTandemInputHandler::~SAXTandemInputHandler()
{
}
void SAXTandemInputHandler::startElement(const XML_Char *el, const XML_Char **attr)
{
if(isElement("note", el) && !(strcmp("input", getAttrValue("type", attr)))){
m_strKey = getAttrValue("label", attr);
(*(m_mapParam))[m_strKey] = "";
m_bInput = true;
}
}
void SAXTandemInputHandler::endElement(const XML_Char *el)
{
if(isElement("note", el) && m_bInput){
m_bInput=false;
}
}
// changed in 2006.09.15 to improve handling of characters
// suggested by Brendan Maclean
void SAXTandemInputHandler::characters(const XML_Char *s, int len)
{
if(m_bInput){
(*(m_mapParam))[m_strKey].append(s, len);
}
}
bool SAXTandemInputHandler::load(){
ifstream ifXml;
/*
* open an input stream, return false if it can't be opened
*/
ifXml.open(m_strXmlPath.c_str());
if(ifXml.fail()){
cout << "\nFailed to open: \"" << m_strXmlPath.c_str() << "\"\n";
return false;
}
setFileName( m_strXmlPath.data() );
parse();
return true;
}
tandem-linux-13-09-01-1/src/saxsaphandler.cpp 0000664 0001750 0001750 00000022227 12136531110 020756 0 ustar langella langella /*
Copyright (C) 2006 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
// File version: 2006-02-17
/*
* SAXSapHandler.cpp contains the override methods necessary for compatibility with
* BIOML file formats.
*/
#include "stdafx.h"
#include "msequence.h"
#include "saxsaphandler.h"
SAXSapHandler::SAXSapHandler( )
: SAXHandler()
{
m_bProtein = false;
m_bAa = false;
m_mapSap.clear();
}
SAXSapHandler::~SAXSapHandler()
{
}
void SAXSapHandler::startElement(const XML_Char *el, const XML_Char **attr)
{
if(isElement("protein", el)){
m_bProtein = true;
m_mapItem.clear();
m_strId = getAttrValue("id", attr);
}
else if(isElement("aa", el)){
char res = '\0';
char mut = '\0';
m_bAa = true;
string strValue;
strValue = getAttrValue("at",attr);
m_pairItem.first = atoi(strValue.c_str());
strValue = getAttrValue("mut",attr);
mut = strValue[0];
m_pairItem.second.m_strId = getAttrValue("id",attr);
strValue = getAttrValue("type",attr);
res = strValue[0];
double dMod = atof(getAttrValue("mod",attr));
if(mut != '\0' && res != '\0' && checkMut(res,mut) && m_pairItem.first > 0) {
m_pairItem.second.m_dMod = 0.0;
m_pairItem.second.m_cRes = res;
m_pairItem.second.m_cMut = mut;
m_pairItem.second.m_iPos = m_pairItem.first;
m_mapItem.insert(m_pairItem);
}
else if (dMod != 0.0 && mut == '\0' && res != '\0' && m_pairItem.first > 0){
m_pairItem.second.m_dMod = dMod;
m_pairItem.second.m_cRes = res;
m_pairItem.second.m_cMut = res;
m_pairItem.second.m_iPos = m_pairItem.first;
m_mapItem.insert(m_pairItem);
}
}
}
void SAXSapHandler::endElement(const XML_Char *el)
{
if(isElement("protein", el)){
m_bProtein = false;
pair > pairValue;
pairValue.first = m_strId;
pairValue.second.clear();
map >::iterator itValue;
itValue = m_mapSap.find(pairValue.first);
if(itValue == m_mapSap.end()) {
m_mapSap.insert(pairValue);
itValue = m_mapSap.find(pairValue.first);
}
itValue = m_mapSap.find(pairValue.first);
multimap::iterator itMap = m_mapItem.begin();
while(itMap != m_mapItem.end()) {
itValue->second.insert(*itMap);
itMap++;
}
}
else if(isElement("aa", el)){
m_bAa = false;
}
}
bool SAXSapHandler::checkMut(char _r,char _m)
{
if(_r == 'K' && (_m == 'Q' || _m == 'E')) {
return false;
}
if(_r == 'Q' && (_m == 'K' || _m == 'E')) {
return false;
}
if(_r == 'E' && (_m == 'K' || _m == 'Q')) {
return false;
}
if(_r == 'N' && _m == 'D') {
return false;
}
if(_r == 'D' && _m == 'N') {
return false;
}
if(_r == 'I' && _m == 'L') {
return false;
}
if(_r == 'L' && _m == 'I') {
return false;
}
if(_r == 'F' && _m == 'M') {
return false;
}
if(_r == 'M' && _m == 'F') {
return false;
}
return true;
}
tandem-linux-13-09-01-1/src/saxtaxhandler.cpp 0000664 0001750 0001750 00000020467 12040310371 020771 0 ustar langella langella /*
Copyright (C) 2003-2005 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
// File version: 2005-07-29
/*
* saxtaxhandler.cpp parses xml taxonomy files
*/
#include "stdafx.h"
#include "saxtaxhandler.h"
SAXTaxHandler::SAXTaxHandler(const string& _p, const string& _t, vector& _vP)
{
m_strPath = _p;
m_strTax = _t;
m_vstrPaths = &_vP;
string strTemp;
size_t tStart = 0;
size_t tEnd = 0;
size_t tValue = 0;
do {
while(tStart < m_strTax.size() && isspace(m_strTax[tStart])) {
tStart++;
}
if(tStart >= m_strTax.size()) {
break;
}
else {
tEnd = m_strTax.find(",",tStart);
tValue = tEnd;
if(tValue == m_strTax.npos) {
tValue = m_strTax.size() - 1;
}
while(tValue > tStart && isspace(m_strTax[tValue])) {
tValue--;
}
if(tValue != tEnd) {
tValue++;
}
strTemp = m_strTax.substr(tStart,tValue-tStart);
if(!strTemp.empty()) {
m_setTax.insert(strTemp);
}
tStart = tEnd + 1;
}
} while(tStart < m_strTax.size() && tEnd != m_strTax.npos);
m_bTax=false;
}
SAXTaxHandler::~SAXTaxHandler()
{
}
bool SAXTaxHandler::load(const string &_y)
{
/*
* try to open the file and bail out if it isn't available
*/
m_strType = _y;
//check the open file to see if it is a taxonomy file
setFileName( m_strPath.data() );
parse();
return true;
}
void SAXTaxHandler::startElement(const XML_Char *el, const XML_Char **attr)
{
int i=1;
const char* label = getAttrValue("label", attr);
if(isElement("taxon", el) && m_setTax.find(label) != m_setTax.end()){
m_bTax = true;
}
else if(isElement("file", el) && m_bTax){
string strType = getAttrValue("format",attr);
if(m_strType == strType) {
string strPath = getAttrValue("URL",attr);
if(m_setPaths.find(strPath) == m_setPaths.end()) {
m_vstrPaths->push_back(strPath);
m_setPaths.insert(strPath);
}
}
}
}
void SAXTaxHandler::endElement(const XML_Char *el)
{
size_t a=0;
if(isElement("taxon",el) && m_bTax){
m_bTax=false;
}
}
tandem-linux-13-09-01-1/src/mscore.cpp 0000664 0001750 0001750 00000177544 12205422257 017436 0 ustar langella langella /*
Copyright (C) 2003-2004 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
// File version: 2003-08-01
// File version: 2004-02-01
// File version: 2004-03-01
// File version: 2004-09-01
// File version: 2004-09-30
// File version: 2005-01-01
/*
* mscore is the class that contains most of the logic for comparing one sequence with
* many tandem mass spectra. mprocess contains a comprehensive example of how to use an mscore
* class. mscore has been optimized for speed, without any specific modifications to take
* advantage of processor architectures.
*/
#include "stdafx.h"
#include
#include
#include
#include "msequence.h"
#include "msequencecollection.h"
#include "msequenceserver.h"
#include "msequtilities.h"
#include "mspectrum.h"
#include "xmlparameter.h"
#include "saxsaphandler.h"
#include "mscore.h"
/*
* global less than operator for mspectrumdetails classes: to be used in sort operations
*/
bool lessThanDetails(const mspectrumdetails &_l,const mspectrumdetails &_r)
{
return _l.m_dL < _r.m_dL;
}
/*
* global less than operator for mi classes: to be used in sort operations to achieve
* list ordered from most intense to least intense
*/
bool lessThanMI(const mi &_l,const mi &_r)
{
return _l.m_fI > _r.m_fI;
}
mscore::mscore(void) :
m_seqUtil(masscalc::monoisotopic),
m_seqUtilAvg(masscalc::average)
{
m_pSeqUtilFrag = &m_seqUtil; // default to monoisotopic masses for fragment ions
m_bIsC = false;
m_bIsN = false;
m_pSeq = NULL;
m_lType = T_Y|T_B;
m_lErrorType = T_PARENT_DALTONS|T_FRAGMENT_DALTONS;
m_dParentErrPlus = 2.0;
m_dParentErrMinus = 2.0;
m_dErr = (float)0.45;
m_dWidth = 1.0;
m_lMaxCharge = 100;
m_dSeqMH = -1.0;
m_lSize = 256;
m_pfSeq = new float[m_lSize];
m_plSeq = new unsigned long[m_lSize];
m_pSeq = new char[m_lSize];
m_bIsotopeError = false;
long a = 0;
while(a < 20) {
m_plCount[a] = 0;
m_pfScore[a] = 0;
a++;
}
m_dMinMass = 0.0;
m_dMaxMass = 1.0;
m_bUsePam = false;
m_dHomoError = 4.5;
m_dScale = 1.0;
m_bMini = false;
m_iCharge = 1;
m_bPhosphoBias = true;
m_plAA = new unsigned long[256];
memset((void *)m_plAA,0,256*sizeof(unsigned long));
m_lCount = 0;
}
mscore::~mscore(void)
{
if(m_pfSeq != NULL)
delete m_pfSeq;
if(m_plSeq != NULL)
delete m_plSeq;
if(m_pSeq != NULL)
delete m_pSeq;
if(m_plAA != NULL)
delete m_plAA;
}
bool mscore::set_mini(const bool _b)
{
m_bMini = _b;
return m_bMini;
}
/*
* allows score object to issue warnings, or set variable based on xml.
* default implementation does nothing.
*/
bool mscore::load_param(XmlParameter &_x)
{
string strKey = "spectrum, fragment mass type";
string strValue;
_x.get(strKey,strValue);
if (strValue == "average") {
set_fragment_masstype(masscalc::average);
}
return true;
}
/*
* called before spectrum conditioning to allow the score object to
* modify the spectrum in ways specific to the scoring algorithm.
* default implementation does nothing.
*/
bool mscore::precondition(mspectrum &_s)
{
return true;
}
/*
* called before scoring inside the score() function to allow any
* necessary resetting of member variables.
*/
__inline__ void mscore::prescore(const size_t _i)
{
m_lId = _i;
m_fHyper = (float)0.0;
}
bool mscore::clear()
{
m_vSpec.clear(); // vector of all spectra being considered
// for all spectra being considered
m_vDetails.clear(); // vector of mspectrumdetails objects, for looking up parent ion M+H
// values of mass spectra
return true;
}
/*
* create list of non-zero predicted intensity values for a-ions and their
* integer converted m/z values
*/
bool mscore::add_A(const unsigned long _t,const long _c)
{
unsigned long a = 0;
/*
* get the conversion factor between a straight sequence mass and an a-ion
*/
double dValue = m_pSeqUtilFrag->m_dA;
/*
* deal with protein N-terminus
*/
if(m_bIsN) {
dValue += m_pSeqUtilFrag->m_fNT;
}
/*
* deal with non-hydrolytic cleavage
*/
dValue += (m_pSeqUtilFrag->m_dCleaveN - m_pSeqUtilFrag->m_dCleaveNdefault);
if(m_Term.m_lN) {
dValue += m_pSeqUtilFrag->m_pdAaMod['['];
}
dValue += m_pSeqUtilFrag->m_pdAaFullMod['['];
unsigned long lValue = 0;
/*
* calculate the conversion factor between an m/z value and its integer value
* as referenced in m_vsmapMI
*/
size_t tC = 0;
float *pfScore = m_pSeqUtilFrag->m_pfAScore;
unsigned long lCount = 0;
/*
* from N- to C-terminus, calcuate fragment ion m/z values and store the results
* look up appropriate scores from m_pSeqUtilFrag->m_pfAScore
*/
const unsigned long tPos = (unsigned long) m_tSeqPos;
m_dWE = m_dWidth/m_dErr;
const double dZ = (double)_c;
while(a < m_lSeqLength) {
tC = m_pSeq[a];
#ifdef PLUGGABLE_SCORING
dValue += m_pSeqUtilFrag->getAaMass((char)tC, tPos+a);
lValue = mconvert(dValue, _c);
#else
dValue +=m_pSeqUtilFrag-> m_pdAaMass[tC];
dValue += m_pSeqUtilFrag->m_pdAaMod[tC];
dValue += m_pSeqUtilFrag->m_pdAaFullMod[tC];
if(m_pSeqUtilFrag->m_bPrompt) {
dValue += m_pSeqUtilFrag->m_pdAaPrompt[tC];
}
if (m_pSeqUtilFrag->m_bSequenceMods) {
SMap::iterator itSeq = m_pSeqUtilFrag->m_mapMods.find(tPos+a);
if(itSeq != m_pSeqUtilFrag->m_mapMods.end())
dValue += itSeq->second;
}
lValue = mconvert(dValue, dZ);
#endif
m_plSeq[lCount] = lValue;
m_pfSeq[lCount] = pfScore[tC];
lCount++;
a++;
}
/*
* set the next integer mass value to 0: this marks the end of the array
*/
m_lCount = lCount;
m_plSeq[lCount] = 0;
return true;
}
/*
* create list of non-zero predicted intensity values for b-ions and their
* integer converted m/z values
*/
bool mscore::add_B(const unsigned long _t,const long _c)
{
unsigned long a = 0;
/*
* get the conversion factor between a straight sequence mass and a b-ion
*/
double dValue = m_pSeqUtilFrag->m_dB;
/*
* deal with protein N-terminus
*/
if(m_bIsN) {
dValue += m_pSeqUtilFrag->m_fNT;
}
/*
* deal with non-hydrolytic cleavage
*/
dValue += (m_pSeqUtilFrag->m_dCleaveN - m_pSeqUtilFrag->m_dCleaveNdefault);
if(m_Term.m_lN) {
dValue += m_pSeqUtilFrag->m_pdAaMod['['];
}
dValue += m_pSeqUtilFrag->m_pdAaFullMod['['];
unsigned long lValue = 0;
/*
* calculate the conversion factor between an m/z value and its integer value
* as referenced in m_vsmapMI
*/
long lCount = 0;
float *pfScore = m_pSeqUtilFrag->m_pfBScore;
float *pfScorePlus = m_pSeqUtilFrag->m_pfYScore;
/*
* from N- to C-terminus, calcuate fragment ion m/z values and store the results
* look up appropriate scores from m_pSeqUtilFrag->m_pfBScore
*/
const unsigned long tPos = (unsigned long) m_tSeqPos;
size_t tC = 0;
m_dWE = m_dWidth/m_dErr;
const double dZ = (double)_c;
while(a < m_lSeqLength-1) {
tC = m_pSeq[a];
#ifdef PLUGGABLE_SCORING
dValue += m_pSeqUtilFrag->getAaMass((char)tC, tPos+a);
lValue = mconvert(dValue, _c);
#else
dValue +=m_pSeqUtilFrag-> m_pdAaMass[tC];
dValue += m_pSeqUtilFrag->m_pdAaMod[tC];
dValue += m_pSeqUtilFrag->m_pdAaFullMod[tC];
if(m_pSeqUtilFrag->m_bPrompt) {
dValue += m_pSeqUtilFrag->m_pdAaPrompt[tC];
}
if (m_pSeqUtilFrag->m_bSequenceMods) {
SMap::iterator itSeq = m_pSeqUtilFrag->m_mapMods.find(tPos+a);
if(itSeq != m_pSeqUtilFrag->m_mapMods.end())
dValue += itSeq->second;
}
lValue = mconvert(dValue, dZ);
#endif
m_plSeq[lCount] = lValue;
m_pfSeq[lCount] = pfScore[tC]*pfScorePlus[m_pSeq[a+1]];
if(a == 1) {
if(m_pSeq[1] == 'P') {
m_pfSeq[lCount] *= 10;
}
else {
m_pfSeq[lCount] *= 3;
}
}
lCount++;
a++;
}
m_lCount = lCount;
m_plSeq[lCount] = 0;
return true;
}
/*
* create list of non-zero predicted intensity values for c-ions and their
* integer converted m/z values
*/
bool mscore::add_C(const unsigned long _t,const long _c)
{
unsigned long a = 0;
/*
* get the conversion factor between a straight sequence mass and a b-ion
*/
double dValue = m_pSeqUtilFrag->m_dC;
/*
* deal with protein N-terminus
*/
if(m_bIsN) {
dValue += m_pSeqUtilFrag->m_fNT;
}
/*
* deal with non-hydrolytic cleavage
*/
dValue += (m_pSeqUtilFrag->m_dCleaveN - m_pSeqUtilFrag->m_dCleaveNdefault);
if(m_Term.m_lN) {
dValue += m_pSeqUtilFrag->m_pdAaMod['['];
}
dValue += m_pSeqUtilFrag->m_pdAaFullMod['['];
unsigned long lValue = 0;
/*
* calculate the conversion factor between an m/z value and its integer value
* as referenced in m_vsmapMI
*/
size_t tC = 0;
long lCount = 0;
float *pfScore = m_pSeqUtilFrag->m_pfBScore;
float *pfScorePlus = m_pSeqUtilFrag->m_pfYScore;
/*
* from N- to C-terminus, calcuate fragment ion m/z values and store the results
* look up appropriate scores from m_pSeqUtilFrag->m_pfBScore
*/
m_dWE = m_dWidth/m_dErr;
double dZ = (double)_c;
const unsigned long tPos = (unsigned long) m_tSeqPos;
while(a < m_lSeqLength-2) {
tC = m_pSeq[a];
#ifdef PLUGGABLE_SCORING
dValue += m_pSeqUtilFrag->getAaMass((char)tC, tPos+a);
lValue = mconvert(dValue, _c);
#else
dValue +=m_pSeqUtilFrag-> m_pdAaMass[tC];
dValue += m_pSeqUtilFrag->m_pdAaMod[tC];
dValue += m_pSeqUtilFrag->m_pdAaFullMod[tC];
if(m_pSeqUtilFrag->m_bPrompt) {
dValue += m_pSeqUtilFrag->m_pdAaPrompt[tC];
}
if (m_pSeqUtilFrag->m_bSequenceMods) {
SMap::iterator itSeq = m_pSeqUtilFrag->m_mapMods.find(tPos+a);
if(itSeq != m_pSeqUtilFrag->m_mapMods.end())
dValue += itSeq->second;
}
lValue = mconvert(dValue, dZ);
#endif
m_plSeq[lCount] = lValue;
m_pfSeq[lCount] = pfScore[tC]*pfScorePlus[m_pSeq[a+1]];
lCount++;
a++;
}
m_lCount = lCount;
m_plSeq[lCount] = 0;
return true;
}
/*
* create list of non-zero predicted intensity values for x-ions and their
* integer converted m/z values
*/
bool mscore::add_X(const unsigned long _t,const long _c)
{
long a = m_lSeqLength - 1;
/*
* get the conversion factor between a straight sequence mass and an x-ion
*/
double dValue = m_pSeqUtilFrag->m_dX;
/*
* deal with non-hydrolytic cleavage
*/
dValue += (m_pSeqUtilFrag->m_dCleaveC - m_pSeqUtilFrag->m_dCleaveCdefault);
if(m_Term.m_lC) {
dValue += m_pSeqUtilFrag->m_pdAaMod[']'];
}
dValue += m_pSeqUtilFrag->m_pdAaFullMod[']'];
/*
* deal with protein C-teminus
*/
if(m_bIsC) {
dValue += m_pSeqUtilFrag->m_fCT;
}
unsigned long lValue = 0;
/*
* calculate the conversion factor between an m/z value and its integer value
* as referenced in m_vsmapMI
*/
size_t tC = 0;
unsigned long lCount = 0;
float fSub = 0.0;
float *pfScore = m_pSeqUtilFrag->m_pfXScore;
/*
* from C- to N-terminus, calcuate fragment ion m/z values and store the results
* look up appropriate scores from m_pSeqUtilFrag->m_pfAScore
*/
m_dWE = m_dWidth/m_dErr;
double dZ = (double)_c;
const unsigned long tPos = (unsigned long) m_tSeqPos;
while(a > 0) {
tC = m_pSeq[a];
#ifdef PLUGGABLE_SCORING
dValue += m_pSeqUtilFrag->getAaMass((char)tC, tPos+a);
lValue = mconvert(dValue, _c);
#else
dValue +=m_pSeqUtilFrag-> m_pdAaMass[tC];
dValue += m_pSeqUtilFrag->m_pdAaMod[tC];
dValue += m_pSeqUtilFrag->m_pdAaFullMod[tC];
if(m_pSeqUtilFrag->m_bPrompt) {
dValue += m_pSeqUtilFrag->m_pdAaPrompt[tC];
}
if (m_pSeqUtilFrag->m_bSequenceMods) {
SMap::iterator itSeq = m_pSeqUtilFrag->m_mapMods.find(tPos+a);
if(itSeq != m_pSeqUtilFrag->m_mapMods.end())
dValue += itSeq->second;
}
lValue = mconvert(dValue, dZ);
#endif
m_plSeq[lCount] = lValue;
m_pfSeq[lCount] = pfScore[tC];
lCount++;
a--;
}
/*
* set the next integer mass value to 0: this marks the end of the array
*/
m_lCount = lCount;
m_plSeq[lCount] = 0;
return true;
}
/*
* create list of non-zero predicted intensity values for y-ions and their
* integer converted m/z values
*/
bool mscore::add_Y(const unsigned long _t,const long _c)
{
long a = m_lSeqLength - 1;
/*
* get the conversion factor between a straight sequence mass and a y-ion
*/
double dValue = m_pSeqUtilFrag->m_dY;
unsigned long lValue = 0;
/*
* deal with non-hydrolytic cleavage
*/
dValue += (m_pSeqUtilFrag->m_dCleaveC - m_pSeqUtilFrag->m_dCleaveCdefault);
if(m_Term.m_lC) {
dValue += m_pSeqUtilFrag->m_pdAaMod[']'];
}
dValue += m_pSeqUtilFrag->m_pdAaFullMod[']'];
/*
/*
* deal with protein C-teminus
*/
if(m_bIsC) {
dValue += m_pSeqUtilFrag->m_fCT;
}
unsigned long lCount = 0;
float fSub = 0.0;
float *pfScore = m_pSeqUtilFrag->m_pfYScore;
float *pfScoreMinus = m_pSeqUtilFrag->m_pfBScore;
/*
* from C- to N-terminus, calcuate fragment ion m/z values and store the results
* look up appropriate scores from m_pSeqUtilFrag->m_pfAScore
*/
long tPos = (unsigned long) m_tSeqPos;
size_t tC = 0;
m_dWE = m_dWidth/m_dErr;
double dZ = (double)_c;
bool bZero = false;
if(_t == 0) {
bZero = true;
}
while(a > 0) {
tC = m_pSeq[a];
#ifdef PLUGGABLE_SCORING
dValue += m_pSeqUtilFrag->getAaMass((char)tC, tPos+a);
lValue = mconvert(dValue, _c);
#else
dValue +=m_pSeqUtilFrag-> m_pdAaMass[tC];
dValue += m_pSeqUtilFrag->m_pdAaMod[tC];
dValue += m_pSeqUtilFrag->m_pdAaFullMod[tC];
if(m_pSeqUtilFrag->m_bPrompt) {
dValue += m_pSeqUtilFrag->m_pdAaPrompt[tC];
}
if (m_pSeqUtilFrag->m_bSequenceMods) {
SMap::iterator itSeq = m_pSeqUtilFrag->m_mapMods.find(tPos+a);
if(itSeq != m_pSeqUtilFrag->m_mapMods.end())
dValue += itSeq->second;
}
lValue = mconvert(dValue, dZ);
#endif
if(bZero) {
if(a < 5) {
m_plSeq[lCount] = lValue;
m_pfSeq[lCount] = pfScore[tC]*pfScoreMinus[m_pSeq[a-1]];
lCount++;
}
}
else {
m_plSeq[lCount] = lValue;
m_pfSeq[lCount] = pfScore[tC]*pfScoreMinus[m_pSeq[a-1]];
if(a == 2) {
if(m_pSeq[1] == 'P') {
m_pfSeq[lCount] *= 10;
}
else {
m_pfSeq[lCount] *= 3;
}
}
lCount++;
}
a--;
}
/*
* set the next integer mass value to 0: this marks the end of the array
*/
m_lCount = lCount;
m_plSeq[lCount] = 0;
return true;
}
/*
* create list of non-zero predicted intensity values for y-ions and their
* integer converted m/z values
*/
bool mscore::add_Z(const unsigned long _t,const long _c)
{
long a = m_lSeqLength - 1;
/*
* get the conversion factor between a straight sequence mass and a y-ion
*/
double dValue = m_pSeqUtilFrag->m_dZ;
unsigned long lValue = 0;
/*
* deal with non-hydrolytic cleavage
*/
dValue += (m_pSeqUtilFrag->m_dCleaveC - m_pSeqUtilFrag->m_dCleaveCdefault);
if(m_Term.m_lC) {
dValue += m_pSeqUtilFrag->m_pdAaMod[']'];
}
dValue += m_pSeqUtilFrag->m_pdAaFullMod[']'];
/*
/*
* deal with protein C-teminus
*/
if(m_bIsC) {
dValue += m_pSeqUtilFrag->m_fCT;
}
size_t tC = 0;
unsigned long lCount = 0;
float fSub = 0.0;
float *pfScore = m_pSeqUtilFrag->m_pfYScore;
float *pfScoreMinus = m_pSeqUtilFrag->m_pfBScore;
/*
* from C- to N-terminus, calcuate fragment ion m/z values and store the results
* look up appropriate scores from m_pSeqUtilFrag->m_pfAScore
*/
m_dWE = m_dWidth/m_dErr;
double dZ = (double)_c;
const unsigned long tPos = (unsigned long) m_tSeqPos;
while(a > 0) {
tC = m_pSeq[a];
#ifdef PLUGGABLE_SCORING
dValue += m_pSeqUtilFrag->getAaMass((char)tC, tPos+a);
lValue = mconvert(dValue, _c);
#else
dValue +=m_pSeqUtilFrag-> m_pdAaMass[tC];
dValue += m_pSeqUtilFrag->m_pdAaMod[tC];
dValue += m_pSeqUtilFrag->m_pdAaFullMod[tC];
if(m_pSeqUtilFrag->m_bPrompt) {
dValue += m_pSeqUtilFrag->m_pdAaPrompt[tC];
}
if (m_pSeqUtilFrag->m_bSequenceMods) {
SMap::iterator itSeq = m_pSeqUtilFrag->m_mapMods.find(tPos+a);
if(itSeq != m_pSeqUtilFrag->m_mapMods.end())
dValue += itSeq->second;
}
lValue = mconvert(dValue, dZ);
#endif
m_plSeq[lCount] = lValue;
m_pfSeq[lCount] = pfScore[tC]*pfScoreMinus[m_pSeq[a-1]];
lCount++;
m_plSeq[lCount] = mconvert(dValue+m_pSeqUtilFrag->m_dHydrogen, dZ);
m_pfSeq[lCount] = pfScore[tC]*pfScoreMinus[m_pSeq[a-1]];
lCount++;
a--;
}
/*
* set the next integer mass value to 0: this marks the end of the array
*/
m_lCount = lCount;
m_plSeq[lCount] = 0;
return true;
}
bool mscore::sort_details()
{
/*
* update the mstate object
*/
m_State.create_equals((long)m_vSpec.size());
/*
* sort the m_vDetails vector to improve efficiency at modeling the vector
*/
sort(m_vDetails.begin(),m_vDetails.end(),lessThanDetails);
/*
* store the mspectrumdetails object for the mspectrum
*/
m_lDetails = (long)m_vDetails.size();
size_t tLimit = m_vDetails.size();
size_t a = 0;
m_sIndex.clear();
mspectrumindex indTemp;
double dLast = 0.0;
while(a < tLimit) {
indTemp.m_dM = m_vDetails[a].m_dU;
indTemp.m_tA = (unsigned long)a;
if(indTemp.m_dM != dLast) {
m_sIndex.insert(indTemp);
}
dLast = indTemp.m_dM;
a++;
}
return true;
}
/*
* add_mi does the work necessary to set up an mspectrum object for modeling.
* default implementation simply checks for errors, and sets spectrum count.
* override in an mscore derived class implementation to do algorithm specific
* processing.
*/
bool mscore::add_mi(mspectrum &_s)
{
/*
* the fragment ion error cannot be zero
*/
if(m_dErr == 0.0)
return false;
m_lSpectra = (long)m_vSpec.size();
return true;
}
/*
* add_mi does the work necessary to set up an mspectrum object for modeling.
* - a copy of the mspectrum object is added to m_vSpec
* - an entry in the m_State object is made for the parent ion M+H
* once an mspectrum has been added, the original mspectrum is no longer
* needed for modeling, as all of the work associated with a spectrum
* is only done once, prior to modeling sequences.
*/
bool mscore::add_details(mspectrum &_s)
{
/*
* if there is a limit on the number of peaks, sort the temporary mspectrum.m_vMI member
* using lessThanMI (see top of this file). the sort results in m_vMI having the most
* intense peaks first in the vector. then, simply erase all but the top m_lMaxPeaks values
* from that vector and continue.
/*
* the fragment ion error cannot be zero
*/
if(m_dErr == 0.0)
return false;
/*
* create a temporary mspec object
*/
mspec spCurrent;
spCurrent = _s;
/*
* store the mspec object
*/
m_vSpec.push_back(spCurrent);
mspectrumdetails detTemp;
double dErrPlus = m_dParentErrPlus;
double dErrMinus = m_dParentErrMinus;
if(m_lErrorType & T_PARENT_PPM) {
detTemp.m_dL = _s.m_dMH - (_s.m_dMH*dErrPlus/1e6);
detTemp.m_dU = _s.m_dMH + (_s.m_dMH*dErrMinus/1e6);
}
else {
detTemp.m_dL = _s.m_dMH - dErrPlus;
detTemp.m_dU = _s.m_dMH + dErrMinus;
}
if(detTemp.m_dU > (double)m_dMaxMass) {
m_dMaxMass = detTemp.m_dU;
}
detTemp.m_tA = (unsigned long)m_vSpec.size() - 1;
m_vDetails.push_back(detTemp);
if(m_bIsotopeError) {
if(spCurrent.m_fMH > 1000.0) {
detTemp.m_dL -= 1.008664916;
detTemp.m_dU -= 1.008664916;
m_vDetails.push_back(detTemp);
}
if(spCurrent.m_fMH > 1500.0) {
detTemp.m_dL -= 1.008664916;
detTemp.m_dU -= 1.008664916;
m_vDetails.push_back(detTemp);
}
}
return true;
}
/*
* add_seq stores a sequence, if the current value of m_pSeq contains the N-terminal portion
* of the new sequence. this method is part of optimizing the scoring process: all references
* to it could be replaced by set_seq. set_seq must be called before add_seq is called.
*/
unsigned long mscore::add_seq(const char *_s,const bool _n,const bool _c,const unsigned long _l,const int _f)
{
m_tSeqPos = _f;
if(_s == NULL)
return 0;
unsigned long lOldLength = m_lSeqLength;
m_lSeqLength = _l;
/*
* if the sequence is too long, use set_seq to adjust the arrays and store the sequence
*/
if(m_lSeqLength >= m_lSize-1) {
return set_seq(_s,_n,_c,_l,_f);
}
/*
* copy the new part of the sequence into m_pSeq
*/
strcpy(m_pSeq + lOldLength,_s + lOldLength);
unsigned long a = lOldLength;
m_bIsC = _c;
m_State.initialize(m_pSeq,m_lSize);
m_Term.initialize(m_seqUtil.m_pdAaMod['['],m_seqUtil.m_pdAaMod[']']);
/*
* update the parent ion M+H value
*/
map::iterator itValue;
map::iterator itEnd = m_seqUtil.m_mapMotifs.end();
SMap::iterator itSeq;
SMap::iterator itSeqEnd = m_seqUtil.m_mapMods.end();
if(m_seqUtil.m_bPotentialMotif) {
m_seqUtil.clear_motifs(false);
}
while(a < m_lSeqLength) {
m_dSeqMH += m_seqUtil.m_pdAaMass[m_pSeq[a]] + m_seqUtil.m_pdAaMod[m_pSeq[a]] + m_seqUtil.m_pdAaFullMod[m_pSeq[a]];
if(m_seqUtil.m_bSequenceMods) {
itSeq = m_seqUtil.m_mapMods.find((unsigned long)(m_tSeqPos+a));
if(itSeq != itSeqEnd) {
m_dSeqMH += itSeq->second;
}
}
if(m_seqUtil.m_pdAaMod[m_pSeq[a]+32] != 0.0) {
m_State.add_mod(m_pSeq+a);
}
if(m_seqUtil.m_bPotentialMotif) {
itValue = m_seqUtil.m_mapMotifs.find(m_tSeqPos+a);
if(itValue != itEnd){
m_State.add_mod(m_pSeq+a);
m_seqUtil.add_mod(m_pSeq[a],itValue->second);
}
}
a++;
}
if(m_seqUtil.m_bPotentialMotif) {
m_seqUtil.set_motifs();
}
/*
* deal with protein terminii
*/
if(m_bIsC)
m_dSeqMH += m_seqUtil.m_fCT;
/*
* update the mstate object
*/
m_State.m_dSeqMHS = m_dSeqMH;
m_dMinMass = m_dSeqMH;
if(m_bUsePam) {
m_Pam.initialize(m_pSeq,(size_t)m_lSize,(float)m_dSeqMH);
}
if(m_bUseSaps) {
m_Sap.m_bMods = m_pSeqUtilFrag->m_bSequenceMods;
m_Sap.m_smapOld = m_pSeqUtilFrag->m_mapMods;
m_Sap.initialize(m_pSeq,(size_t)m_lSize,(float)m_dSeqMH);
}
return m_lSeqLength;
}
/*
* check_parents is used by the state machine for dealing with potentially
* modified sequences. it determines how many parent ions are eligible
* to be generated by the current modified sequence and stores the
* vector indices of those eligible spectra in the m_State object.
* this test is done to improve performance. inlining is not necessary,
* but this method is called very often in a normal protein modeling session, so removing
* the method calling overhead can improve overall performance
*/
__inline__ bool mscore::check_parents(void) {
/*
* this check improves performance because of the way the state machine assigns modifications
* if the state machine sequence order is modified, this mechanism should be reviewed
*/
if(m_State.m_dSeqMHFailedS == m_dSeqMH) {
m_State.m_lEqualsS = 0;
return false;
}
if(m_dSeqMH < m_vDetails[0].m_dL) {
return false;
}
if(m_dSeqMH > m_vDetails.back().m_dU) {
return false;
}
vector::iterator itDetails = m_vDetails.begin();
vector::iterator itEnd = m_vDetails.end();
set::iterator itIndex;
mspectrumindex indTemp;
indTemp.m_dM = m_dSeqMH - 4.0;
if(!m_sIndex.empty()) {
itIndex = m_sIndex.lower_bound(indTemp);
if(itIndex != m_sIndex.begin()) {
itIndex--;
}
itDetails = itDetails + (*itIndex).m_tA;
}
m_State.m_lEqualsS = 0;
while(itDetails != itEnd && itDetails->m_dL < m_dSeqMH + 4.0) {
if(*itDetails == m_dSeqMH) {
m_State.m_plEqualsS[m_State.m_lEqualsS] = itDetails->m_tA;
m_State.m_lEqualsS++;
}
itDetails++;
}
if(m_State.m_lEqualsS > 0) {
return true;
}
/*
* this check improves performance because of the way the state machine assigns modifications
* if the state machine sequence order is modified, this mechanism should be reviewed
*/
m_State.m_dSeqMHFailedS = m_dSeqMH;
m_State.m_lEqualsS = 0;
return false;
}
/*
* get_aa is used to check the current sequence and determine how many of
* the residues correspond to modification sites. this method is not used
* by mscore: check mprocess to see an example of how it is used to create
* a list of modified residues in a domain
*/
bool mscore::get_aa(vector &_m,const size_t _a,double &_d)
{
_d = 1000000.0;
_m.clear();
size_t a = 0;
char cRes = '\0';
char *pValue = NULL;
maa aaValue;
double dDelta = 0.0;
while(a < 128) {
if(a == '[' && m_seqUtil.m_pdAaFullMod['['] != 0.0) {
cRes = m_pSeq[0];
aaValue.m_cRes = cRes;
aaValue.m_dMod = (float)m_seqUtil.m_pdAaFullMod['['];
aaValue.m_lPos = (unsigned int)_a;
_m.push_back(aaValue);
}
if(a == ']' && m_seqUtil.m_pdAaFullMod[']'] != 0.0) {
cRes = m_pSeq[strlen(m_pSeq) - 1];
aaValue.m_cRes = cRes;
aaValue.m_dMod = (float)m_seqUtil.m_pdAaFullMod[']'];
aaValue.m_lPos = (unsigned int)(_a + strlen(m_pSeq) - 1);
_m.push_back(aaValue);
}
if(m_seqUtil.m_pdAaMod[a] != 0.0) {
cRes = (char)a;
pValue = strchr(m_pSeq,cRes);
while(pValue != NULL) {
aaValue.m_cRes = cRes;
aaValue.m_dMod = (float)m_seqUtil.m_pdAaMod[a];
aaValue.m_dPrompt = (float)m_seqUtil.m_pdAaPrompt[a];
aaValue.m_lPos = (unsigned int)(_a + (pValue - m_pSeq));
dDelta += aaValue.m_dMod;
_m.push_back(aaValue);
pValue++;
pValue = strchr(pValue,cRes);
}
}
if(m_seqUtil.m_pdAaFullMod[a] != 0.0) {
cRes = (char)a;
pValue = strchr(m_pSeq,cRes);
while(pValue != NULL) {
aaValue.m_cRes = cRes;
aaValue.m_dMod = (float)m_seqUtil.m_pdAaFullMod[a];
aaValue.m_lPos = (unsigned int)(_a + (pValue - m_pSeq));
aaValue.m_dPrompt = 0.0;
_m.push_back(aaValue);
pValue++;
pValue = strchr(pValue,cRes);
}
}
a++;
}
if(m_seqUtil.m_bSequenceMods) {
SMap::iterator itValue = m_seqUtil.m_mapMods.begin();
SMap::const_iterator itEnd = m_seqUtil.m_mapMods.end();
size_t tValue = 0;
size_t tEnd = m_tSeqPos + m_lSeqLength;
while(itValue != itEnd) {
tValue = itValue->first;
if(tValue >= m_tSeqPos || tValue < tEnd) {
tValue = tValue - m_tSeqPos-1;
cRes = m_pSeq[tValue];
aaValue.m_cRes = cRes;
aaValue.m_dMod = (float)itValue->second;
aaValue.m_lPos = (unsigned int)(_a+tValue);
if(cRes <= 'Z') {
cRes += 32;
}
dDelta += aaValue.m_dMod;
aaValue.m_dPrompt = (float)m_seqUtil.m_pdAaPrompt[cRes];
_m.push_back(aaValue);
}
itValue++;
}
}
if(m_Term.m_lN) {
aaValue.m_dMod = (float)m_seqUtil.m_pdAaMod['['];
aaValue.m_dPrompt = 0.0;
aaValue.m_lPos = (unsigned int)_a;
aaValue.m_cRes = m_pSeq[0];
dDelta += aaValue.m_dMod;
_m.push_back(aaValue);
}
if(m_Term.m_lC) {
aaValue.m_dMod = (float)m_seqUtil.m_pdAaMod[']'];
aaValue.m_dPrompt = 0.0;
aaValue.m_lPos = (unsigned int)(_a+ m_lSeqLength - 1);
aaValue.m_cRes = m_pSeq[m_lSeqLength - 1];
dDelta += aaValue.m_dMod;
_m.push_back(aaValue);
}
if(m_Pam.m_tCount > 0) {
aaValue.m_dMod = (float)(m_seqUtil.m_pdAaMass[m_pSeq[m_Pam.m_tPos]] - m_seqUtil.m_pdAaMass[m_Pam.m_pSeqTrue[m_Pam.m_tPos]]);
aaValue.m_dPrompt = (float)(m_seqUtil.m_pdAaPrompt[m_pSeq[m_Pam.m_tPos]] - m_seqUtil.m_pdAaPrompt[m_Pam.m_pSeqTrue[m_Pam.m_tPos]]);
aaValue.m_lPos = (unsigned int)(_a+ m_Pam.m_tPos);
aaValue.m_cRes = m_Pam.m_pSeqTrue[m_Pam.m_tPos];
aaValue.m_cMut = m_pSeq[m_Pam.m_tPos];
aaValue.m_strId.clear();
dDelta += aaValue.m_dMod;
_d = dDelta;
_m.push_back(aaValue);
}
if(m_Sap.m_tCount > 0 && m_Sap.m_dMod == 0.0) {
aaValue.m_dMod = (float)(m_seqUtil.m_pdAaMass[m_pSeq[m_Sap.m_tPos]] - m_seqUtil.m_pdAaMass[m_Sap.m_pSeqTrue[m_Sap.m_tPos]]);
aaValue.m_dPrompt = (float)(m_seqUtil.m_pdAaPrompt[m_pSeq[m_Sap.m_tPos]] - m_seqUtil.m_pdAaPrompt[m_Sap.m_pSeqTrue[m_Sap.m_tPos]]);
aaValue.m_lPos = (unsigned int)(_a+ m_Sap.m_tPos);
aaValue.m_cRes = m_Sap.m_pSeqTrue[m_Sap.m_tPos];
aaValue.m_cMut = m_pSeq[m_Sap.m_tPos];
aaValue.m_strId = m_Sap.m_strId;
dDelta += aaValue.m_dMod;
_d = dDelta;
_m.push_back(aaValue);
}
size_t b = 0;
while(b < _m.size()) {
if(_m[b].m_cRes >= 'a' && _m[b].m_cRes <= 'z') {
_m[b].m_cRes -= 32;
}
if(_m[b].m_cMut >= 'a' && _m[b].m_cMut <= 'z') {
_m[b].m_cMut -= 32;
}
b++;
}
return true;
}
/*
* mconvert converts from mass and charge to integer ion value
* for mi vector.
*/
__inline__ unsigned long mscore::mconvert(double _m, const long _c)
{
/*
* calculate the conversion factor between an m/z value and its integer value
* as referenced in m_vsmapMI
*/
const double dZ = (double)_c;
return (unsigned long)((m_pSeqUtilFrag->m_dProton + _m/dZ)*m_dWidth/m_dErr);
}
#ifndef PLUGGABLE_SCORING
__inline__ unsigned long mscore::mconvert(double _m, const double _z)
{
/*
* calculate the conversion factor between an m/z value and its integer value
* as referenced in m_vsmapMI
*/
return (unsigned long)((m_pSeqUtilFrag->m_dProton + _m/_z)*m_dWE);
}
#endif
/*
* hfactor returns a factor applied to the score to produce the
* hyper score, given a number of ions matched.
*/
double mscore::hfactor(long _l)
{
return 1.0;
}
/*
* sfactor returns a factor applied to the final convolution score.
*/
double mscore::sfactor()
{
return 1.0;
}
/*
* hconvert is use to convert a hyper score to the value used in a score
* histogram, since the actual scoring distribution may not lend itself
* to statistical analysis through use of a histogram.
*/
float mscore::hconvert(float _f)
{
if(_f <= 0.0)
return 0.0;
return (float)(m_dScale*_f);
}
/*
* report_score formats a hyper score for output.
*/
void mscore::report_score(char* buffer, float hyper)
{
sprintf(buffer,"%.1f",hconvert(hyper));
}
/*
* load_next is used access the potential sequence modification state machine.
* it runs the state machine until either:
* - a modified sequence that has a mass that is within error of
* one of the mspectrum objects has been found, or
* - the last of the modified sequences has been returned
* it returns true if there are more sequences to consider.
* NOTE: the last sequence generated by the state machine is the one without any
* of the potential modifications in place. maintaining this order is important
* to the correct functioning of the logic using in mprocess.
*/
bool mscore::load_next(void)
{
bool bReturn = false;
if(!(m_bUsePam || m_bUseSaps)) {
bReturn = load_state();
if(bReturn) {
return bReturn;
}
bReturn = load_next_term();
return bReturn;
}
else if(m_bUsePam) {
// Shift mutation to be checked
if(m_Pam.m_tCount != 0) {
bReturn = load_state();
if(bReturn) {
return bReturn;
}
bReturn = load_next_term();
if(bReturn) {
return bReturn;
}
}
bReturn = load_next_pam();
return bReturn;
}
else if(m_bUseSaps) {
bReturn = load_state();
if(bReturn) {
return bReturn;
}
bReturn = load_next_term();
if(bReturn) {
return bReturn;
}
if(m_Sap.m_bOk) {
bReturn = load_next_sap();
}
return bReturn;
}
return bReturn;
}
/*
* as of version 2004.03.01, a new state machine has been added that allows for testing
* for N- and C- terminal modifications as partial modifications. Previous versions
* tested for these modifications as complete modifications only. This state machine
* relies on the mscoreterm class, m_Term, to maintain information about the current modification
* state of the N- and C- terminus of the peptide. See the source for that class (in mscorestate.h)
* for an explanation of how the state is stored and referenced.
*/
bool mscore::load_next_term(void)
{
if(!m_Term.m_bC && !m_Term.m_bN) {
return false;
}
// reset the state machine, as there are no further states
if(m_Term.m_lState == 3) {
m_Term.initialize(m_seqUtil.m_pdAaMod['['],m_seqUtil.m_pdAaMod[']']);
m_dSeqMH -= m_pSeqUtilFrag->m_pdAaMod['['];
m_dSeqMH -= m_pSeqUtilFrag->m_pdAaMod[']'];
m_State.initialize(m_pSeq,m_lSeqLength);
m_State.m_dSeqMHS = m_dSeqMH;
m_dMinMass = m_dSeqMH;
m_State.m_lEqualsS = 0;
check_parents();
return false;
}
bool bReturn = false;
if(m_Term.m_lState == 0) {
// deal with modification at N-terminus, if possible
if(m_Term.m_bN) {
m_Term.m_lState = 1;
m_dSeqMH += m_pSeqUtilFrag->m_pdAaMod['['];
m_Term.m_lN = 1;
m_Term.m_lC = 0;
m_State.initialize(m_pSeq,m_lSeqLength);
m_State.m_dSeqMHS = m_dSeqMH;
m_dMinMass = m_dSeqMH;
m_State.m_lEqualsS = 0;
check_parents();
return true;
}
// deal with modification at C-terminus, if possible
if(m_Term.m_bC) {
m_Term.m_lState = 2;
m_dSeqMH += m_pSeqUtilFrag->m_pdAaMod[']'];
m_Term.m_lN = 0;
m_Term.m_lC = 1;
m_State.initialize(m_pSeq,m_lSeqLength);
m_State.m_dSeqMHS = m_dSeqMH;
m_dMinMass = m_dSeqMH;
m_State.m_lEqualsS = 0;
check_parents();
return true;
}
return false;
}
// deal with modification at C-terminus, if the N-terminus is in the modified state
else if(m_Term.m_lState == 1) {
if(!m_Term.m_bC) {
m_dSeqMH -= m_pSeqUtilFrag->m_pdAaMod['['];
m_Term.initialize(m_seqUtil.m_pdAaMod['['],m_seqUtil.m_pdAaMod[']']);
return false;
}
m_Term.m_lN = 0;
m_Term.m_lC = 1;
m_dSeqMH -= m_pSeqUtilFrag->m_pdAaMod['['];
m_dSeqMH += m_pSeqUtilFrag->m_pdAaMod[']'];
m_Term.m_lState = 2;
m_State.initialize(m_pSeq,m_lSeqLength);
m_State.m_dSeqMHS = m_dSeqMH;
m_dMinMass = m_dSeqMH;
m_State.m_lEqualsS = 0;
check_parents();
return true;
}
// deal with modification at both N- and C- terminus, if possible
else if(m_Term.m_lState == 2) {
if(!m_Term.m_bN) {
m_dSeqMH -= m_pSeqUtilFrag->m_pdAaMod[']'];
m_Term.initialize(m_pSeqUtilFrag->m_pdAaMod['['],m_pSeqUtilFrag->m_pdAaMod[']']);
return false;
}
m_dSeqMH += m_pSeqUtilFrag->m_pdAaMod['['];
m_Term.m_lN = 1;
m_Term.m_lC = 1;
m_State.initialize(m_pSeq,m_lSeqLength);
m_State.m_dSeqMHS = m_dSeqMH;
m_dMinMass = m_dSeqMH;
m_Term.m_lState = 3;
m_State.m_lEqualsS = 0;
check_parents();
}
return bReturn;
}
/*
* load_next_pam alters the current peptide sequence by iterating through all possible
* single amino acid polymorphisms. Polymorphisms that are difficult to distinguish by
* mass spectrometry are skipped to avoid reporting spurious assignments.
*/
bool mscore::load_next_pam(void)
{
bool bReturn = false;
if(m_Pam.m_tCount != 0) {
m_Pam.m_tAa++;
}
m_Pam.m_tCount++;
// Shift to next residue if all possibilities have been checked
if(m_Pam.m_tAa >= m_Pam.m_tAaTotal) {
m_pSeq[m_Pam.m_tPos] = m_Pam.m_pSeqTrue[m_Pam.m_tPos];
m_Pam.m_tPos++;
m_Pam.m_tAa = 0;
}
// Skip mutations indistinguishable from the sequence
while(m_Pam.m_tPos < m_Pam.m_tLength && check_pam_mass()) {
if(m_Pam.m_tAa == m_Pam.m_tAaTotal - 1) {
m_pSeq[m_Pam.m_tPos] = m_Pam.m_pSeqTrue[m_Pam.m_tPos];
m_Pam.m_tPos++;
m_Pam.m_tAa = 0;
}
else {
m_Pam.m_tAa++;
}
}
// Return false if all residues have been checked
if(m_Pam.m_tPos >= m_Pam.m_tLength) {
strcpy(m_pSeq,m_Pam.m_pSeqTrue);
m_dSeqMH = m_Pam.m_fSeqTrue;
m_State.m_dSeqMHS = m_dSeqMH;
m_dMinMass = m_dSeqMH;
m_State.m_lEqualsS = 0;
check_parents();
m_Pam.m_tCount = 0;
return false;
}
else {
strcpy(m_pSeq,m_Pam.m_pSeqTrue);
m_dSeqMH = m_Pam.m_fSeqTrue;
m_dSeqMH += m_pSeqUtilFrag->m_pdAaMass[m_Pam.m_pAa[m_Pam.m_tAa]];
m_dSeqMH -= m_pSeqUtilFrag->m_pdAaMass[m_Pam.m_pSeqTrue[m_Pam.m_tPos]];
m_dSeqMH += m_pSeqUtilFrag->m_pdAaFullMod[m_Pam.m_pAa[m_Pam.m_tAa]];
m_dSeqMH -= m_pSeqUtilFrag->m_pdAaFullMod[m_Pam.m_pSeqTrue[m_Pam.m_tPos]];
m_pSeq[m_Pam.m_tPos] = m_Pam.m_pAa[m_Pam.m_tAa];
m_State.initialize(m_pSeq,m_lSeqLength);
m_State.m_dSeqMHS = m_dSeqMH;
m_dMinMass = m_dSeqMH;
m_State.m_lEqualsS = 0;
check_parents();
return true;
}
return bReturn;
}
/*
* this method checks for modifications that result from trivial changes in mass assignment, e.g.
* M->F (+16), even though M+16 is being checked a potential modification. getting this function
* right is critical to the point mutation assignment working properly.
*/
__inline__ bool mscore::check_pam_mass()
{
const char cTrue = m_Pam.m_pSeqTrue[m_Pam.m_tPos];
const char cNew = m_Pam.m_pAa[m_Pam.m_tAa];
const float fTrue = m_pSeqUtilFrag->m_pfAaMass[cTrue] + (float)m_pSeqUtilFrag->m_pdAaFullMod[cTrue];
const float fNew = m_pSeqUtilFrag->m_pfAaMass[cNew] + (float)m_pSeqUtilFrag->m_pdAaFullMod[cNew];
if(fabs(fTrue - fNew) < m_dHomoError) {
return true;
}
if(fabs(fTrue + m_pSeqUtilFrag->m_pdAaMod[cTrue+32] - fNew) < m_dHomoError) {
return true;
}
if(fabs(fNew + m_pSeqUtilFrag->m_pdAaMod[cNew+32] - fTrue) < m_dHomoError) {
return true;
}
if(fabs(fTrue + m_pSeqUtilFrag->m_pdAaMod[cTrue+32] - fNew) < m_dHomoError) {
return true;
}
if(fabs(fNew + m_pSeqUtilFrag->m_pdAaMod[cNew+32] - fTrue - m_pSeqUtilFrag->m_pdAaMod[cTrue+32]) < m_dHomoError) {
return true;
}
return false;
}
/*
* load_next_sap alters the current peptide sequence by adding single amino acid
* polymorphisms that have been annotated in the SAP files specified in the taxonomy
* file settings.
*/
bool mscore::load_next_sap(void)
{
bool bReturn = false;
if(!m_Sap.m_bOk) {
return bReturn;
}
// Return false if all residues have been checked
if(!m_Sap.next()) {
memcpy(m_pSeq,m_Sap.m_pSeqTrue,m_lSeqLength);
m_pSeqUtilFrag->m_bSequenceMods = m_Sap.m_bMods;
m_pSeqUtilFrag->m_mapMods = m_Sap.m_smapOld;
m_dSeqMH = m_Sap.m_fSeqTrue;
m_State.m_dSeqMHS = m_dSeqMH;
m_dMinMass = m_dSeqMH;
m_State.m_lEqualsS = 0;
check_parents();
m_Sap.m_tCount = 0;
return false;
}
else {
memcpy(m_pSeq,m_Sap.m_pSeqTrue,m_lSeqLength);
m_pSeqUtilFrag->m_bSequenceMods = m_Sap.m_bMods;
m_pSeqUtilFrag->m_mapMods = m_Sap.m_smapOld;
m_dSeqMH = m_Sap.m_fSeqTrue;
m_dSeqMH += m_pSeqUtilFrag->m_pdAaMass[m_Sap.m_cCurrent] + m_Sap.m_dMod;
m_dSeqMH -= m_pSeqUtilFrag->m_pdAaMass[m_Sap.m_pSeqTrue[m_Sap.m_tPos]];
m_dSeqMH += m_pSeqUtilFrag->m_pdAaFullMod[m_Sap.m_cCurrent];
m_dSeqMH -= m_pSeqUtilFrag->m_pdAaFullMod[m_Sap.m_pSeqTrue[m_Sap.m_tPos]];
m_pSeq[m_Sap.m_tPos] = m_Sap.m_cCurrent;
if(m_Sap.m_dMod != 0.0) {
m_pSeqUtilFrag->m_bSequenceMods = true;
m_pSeqUtilFrag->m_mapMods[m_Sap.m_tPos+m_Sap.m_iStart] = m_Sap.m_dMod;
}
m_State.initialize(m_pSeq,m_lSeqLength);
m_State.m_dSeqMHS = m_dSeqMH;
m_dMinMass = m_dSeqMH;
m_State.m_lEqualsS = 0;
check_parents();
return true;
}
return bReturn;
}
/*
* load_state is used access the potential sequence modification state machine.
* it runs the state machine until either:
* - a modified sequence that has a mass that is within error of
* one of the mspectrum objects has been found, or
* - the last of the modified sequences has been returned
* it returns true if there are more sequences to consider.
* NOTE: the last sequence generated by the state machine is the one without any
* of the potential modifications in place. maintaining this order is important
* to the correct functioning of the logic using in mprocess.
*/
bool mscore::load_state(void)
{
bool bReturn = run_state_machine();
if(m_dSeqMH < m_dMinMass) {
m_dMinMass = m_dSeqMH;
}
while(bReturn) {
if(m_State.m_bIsPossible && check_parents()) {
return bReturn;
}
bReturn = run_state_machine();
if(m_dSeqMH < m_dMinMass) {
m_dMinMass = m_dSeqMH;
}
}
return bReturn;
}
/*
* load_seq is used to call the appropriate add_? method to create the
* ion type specific scoring array. These arrays are padded to mod(4), so
* that an optimizing compiler can utilize MMX arrays in the dot method.
*/
bool mscore::load_seq(const unsigned long _t,const long _c)
{
bool bReturn = true;
if(T_Y & _t) {
bReturn = add_Y(_t,_c);
}
else if(T_X & _t) {
bReturn = add_X(_t,_c);
}
else if(T_A & _t) {
bReturn = add_A(_t,_c);
}
else if(T_B & _t) {
bReturn = add_B(_t,_c);
}
else if(T_C & _t) {
bReturn = add_C(_t,_c);
}
else if(T_Z & _t) {
bReturn = add_Z(_t,_c);
}
return bReturn;
}
/*
* modifications have exponential impact on number of sequences that require scoring,
* so a limit is imposed to keep things like a modification on M, and a sequence with
* 30 M's from costing too much.
*/
unsigned long mscorestate::M_lMaxModStates = 1 << 12;
/*
* the state machine for determining all potentially modified residues in a peptide sequence
* and then generating and scoring them efficiently relies upon run_state_machine.
*
* this version calculates the various combinations in order of the number of actual
* modifications present. for example, if there are 10 possible modification sites,
* then all combinations with 1 modification are checked first, then all combinations
* with 2 modifications, with 3, with 4, etc.
*
* this makes it possible to impose a maximum number of states checked, while still
* checking the most likely combinations first. i.e. checking all possible combinations
* of 1-10 modifications on 30 sites is probably better than all combinations of the
* first 10 sites, as with FIX1.
*/
bool mscore::run_state_machine(void)
{
/*
* return false if there are no more states
*/
m_State.m_bIsPossible = true;
if(!m_State.m_bStateS)
{
memcpy(m_pSeq,m_State.m_pSeqS,m_lSeqLength);
m_dSeqMH = m_State.m_dSeqMHS;
return false;
}
else if (m_State.m_lStates >= mscorestate::M_lMaxModStates)
{
memcpy(m_pSeq,m_State.m_pSeqS,m_lSeqLength);
m_dSeqMH = m_State.m_dSeqMHS;
m_State.m_bStateS = false;
m_State.m_lStates++;
return true;
}
m_State.m_lStates++;
bool bReturn = m_State.m_bStateS;
/*
* deal efficiently with protein modeling sessions that do not require potential modifications
*/
if(!m_seqUtil.m_bPotential) {
m_State.m_bStateS = false;
return bReturn;
}
if(m_State.m_lLastS == 0) {
m_State.m_bStateS = false;
return bReturn;
}
/*
* adjust the states of the modification positions
*/
if(m_State.m_lFilledS > 0 &&
m_State.m_piMods[m_State.m_lCursorS] < m_State.m_lLastS - m_State.m_lFilledS + m_State.m_lCursorS) {
/*
* shift current mod through all valid positions.
*/
m_State.m_piMods[m_State.m_lCursorS]++;
}
else if (m_State.m_lCursorS > 0) {
/*
* shift the mod to the left of the current mod.
*/
m_State.m_lCursorS--;
m_State.m_piMods[m_State.m_lCursorS]++;
/*
* if there it is not at its largest possible position, shift all mods to the
* right back, and start over with them.
*/
if (m_State.m_piMods[m_State.m_lCursorS] < m_State.m_lLastS - m_State.m_lFilledS + m_State.m_lCursorS)
{
for (unsigned long i = 1; i < m_State.m_lFilledS - m_State.m_lCursorS; i++)
m_State.m_piMods[m_State.m_lCursorS + i] = m_State.m_piMods[m_State.m_lCursorS] + i;
m_State.m_lCursorS = m_State.m_lFilledS - 1;
}
}
else if (m_State.m_lFilledS < m_State.m_lLastS) {
/*
* introduce more possible modifications, and start over calculating all
* possible combinations.
*/
m_State.m_lFilledS++;
if (m_State.m_lFilledS < m_State.m_lLastS)
m_State.m_lCursorS = m_State.m_lFilledS - 1;
for (unsigned long i = 0; i < m_State.m_lFilledS; i++)
m_State.m_piMods[i] = i;
}
else {
/*
* last state is no modifications.
*/
m_State.m_lFilledS = 0;
}
/*
* reset the sequence string and initial mass
*/
memcpy(m_pSeq,m_State.m_pSeqS,m_lSeqLength);
m_dSeqMH = m_State.m_dSeqMHS;
/*
* unmodified is the last state
*/
if (m_State.m_lFilledS == 0)
m_State.m_bStateS = false;
/*
* otherwise, use the modification state indices to correctly set the modifications
* in the sequence string, and add to the parent mass.
*/
else
{
/* for (unsigned long i = 0; i < m_State.m_lFilledS; i++)
{
unsigned long pos = m_State.m_piMods[i];
*(m_State.m_ppModsS[pos]) += 32;
m_dSeqMH += m_seqUtil.m_pdAaMod[*(m_State.m_ppModsS[pos])];
} */
m_plAA['s'] = 0;
m_plAA['t'] = 0;
m_plAA['n'] = 0;
m_plAA['q'] = 0;
m_plAA['y'] = 0;
unsigned long pos = 0;
size_t tPos = 0;
double *pAaMod = m_seqUtil.m_pdAaMod;
for (unsigned long i = 0; i < m_State.m_lFilledS; i++) {
pos = m_State.m_piMods[i];
*(m_State.m_ppModsS[pos]) += 32;
tPos = (size_t) *(m_State.m_ppModsS[pos]);
m_plAA[tPos]++;
m_dSeqMH += pAaMod[tPos];
}
m_State.m_bIsPossible = !(m_plAA['s'] + m_plAA['t'] + m_plAA['y'] > 3 || m_plAA['n'] + m_plAA['q'] > 3);
}
return true;
}
/*
* the score method is called externally to score a loaded peptide against one of the
* loaded mass spectra. the mass spectrum is refered to by its index number in the
* m_vSpec mspectrum vector. the sequence has already been loaded via set_seq and/or
* add_seq.
*/
float mscore::score(const size_t _i)
{
m_fScore = -1.0;
m_fHyper = -1.0;
double dFactor = 1.0;
/*
* return -1000.0 if there is no sequence available
*/
if(m_pSeq == NULL)
return -1000.0;
/*
* initialize values for the protein modeling session
*/
prescore(_i);
double dScore = (float)0.0;
double dValue = (float)0.0;
unsigned int lType = T_Y;
unsigned long lValue = 0;
unsigned long lValueTotal = 0;
unsigned long lS = S_Y;
long lChargeLimit = (long)m_vSpec[m_lId].m_fZ;
unsigned int uiType = m_vSpec[m_lId].m_uiType;
//if uiType has not been set, then use m_lType value
if(uiType == 0) {
uiType = (unsigned int)m_lType;
m_vSpec[m_lId].m_uiType = uiType;
}
// 2006.12.01: to reduce problems with high charge states, the hyperscore is
// calculated on the 2 best fragment ion charge states. in the
// previous versions the hyperscore used all available charge states, giving
// a considerable advantage to highly charged parent ions
vector vFactor;
long a = 0;
while(a < lChargeLimit+1) {
vFactor.push_back(1.0);
a++;
}
if(lChargeLimit == 1) {
lChargeLimit = 2;
}
if((uiType & T_C) || (uiType & T_Z)) {
if(lChargeLimit > 2) {
lChargeLimit--;
}
}
/*
* iterate through all of the possible values of the mscore_type enum
* comparing them against uiType
*/
while(lType < uiType+1) {
lValueTotal = 0;
dValue = 0.0;
if(lType & uiType) {
a = 1;
while(a < lChargeLimit) {
/*
* load the sequence arrays for each possible charge states for the selected spectrum
*/
load_seq(lType,a);
lValue = 0;
/*
* perform a dot product on each charge state
*/
dValue += dot(&lValue);
if(a == 1 && (T_Y & lType) && (long)m_vSpec[m_lId].m_fZ == 2) {
unsigned long lTemp = 0;
add_Y(0,2);
dValue += dot(&lTemp);
lValue += lTemp;
}
lValueTotal += lValue;
vFactor[a] *= hfactor(lValue);
a++;
}
dScore += dValue;
}
m_pfScore[lS] = (float) dValue;
m_plCount[lS] = lValueTotal;
/*
* move on to next value in the mstate_type enum
*/
lS++;
lType *= 2;
}
dScore *= sfactor();
m_fScore = (float)dScore;
// only use the 2 best component hyperscores
sort(vFactor.begin(),vFactor.end());
a = (long)vFactor.size()-1;
if(a > 1) {
dFactor = vFactor[a] * vFactor[a-1];
}
else {
dFactor = vFactor[a];
}
dFactor *= dScore;
if(dFactor > FLT_MAX) {
m_fHyper = FLT_MAX;
}
else {
m_fHyper = (float)dFactor;
}
/*
* returning 1.0 for a zero score makes the logic in mprocess easier. see mprocess:create_score
* to see why.
*/
if(dScore == 0.0) {
dScore = 1.0;
}
char *pS = strchr(m_pSeq,'s');
char *pT = strchr(m_pSeq,'t');
if(m_bPhosphoBias && m_fHyper < FLT_MAX && (pS || pT)) {
int iST = 0;
char *pV = strstr(m_pSeq,"sP");
while(pV) {
iST++;
pV++;
pV = strstr(pV,"sP");
}
pV = strstr(m_pSeq,"tP");
while(pV) {
iST++;
pV++;
pV = strstr(pV,"tP");
}
double dV = (double)m_fHyper*(1.0 + 0.001*iST);
if(dV < FLT_MAX) {
m_fHyper = (float)dV;
}
double dNeutral = 0.0;
unsigned long lNeutral = 0;
m_dWE = (double)(m_dWidth/m_dErr);
if((pS && m_pSeqUtilFrag->m_bPhosphoSerine) || (pT && m_pSeqUtilFrag->m_bPhosphoThreonine)) {
nMap::iterator itMap = m_seqUtil.m_mapNeutralLoss.find(m_lId);
if(itMap != m_seqUtil.m_mapNeutralLoss.end()) {
double dHyper = (double)m_fHyper * (double)itMap->second;
if(dHyper < FLT_MAX) {
m_fHyper = (float)dHyper;
}
}
else {
dNeutral = m_dSeqMH - (79.966331 + m_seqUtil.m_dWater) - m_seqUtil.m_dProton;
#ifdef PLUGGABLE_SCORING
lNeutral = mconvert(dNeutral,(long)m_vSpec[m_lId].m_fZ);
#else
lNeutral = mconvert(dNeutral,(double)m_vSpec[m_lId].m_fZ);
#endif
float fV = ion_check(lNeutral,m_lId);
if(fV >= 20.0) {
double dHyper = (double)m_fHyper * (double)1.001;
if(dHyper < FLT_MAX) {
m_fHyper = (float)dHyper;
}
m_seqUtil.m_mapNeutralLoss.insert(nMap::value_type(m_lId,(float)1.001));
}
else {
m_seqUtil.m_mapNeutralLoss.insert(nMap::value_type(m_lId,(float)1.0));
}
}
}
}
return (float) dScore;
}
/*
* get the current value of the m_fSeqMH member variable
*/
double mscore::seq_mh()
{
return m_dSeqMH;
}
/*
* set true if sequence is to be checked for all possible point mutations
*/
bool mscore::set_pam(const bool _b)
{
m_bUsePam = _b;
m_Pam.m_tCount = 0;
return m_bUsePam;
}
/*
* set true if corrections to phosphorylation assignments are to be made
*/
bool mscore::set_phospho_bias(const bool _b)
{
m_bPhosphoBias = _b;
return m_bPhosphoBias;
}
/*
* set true if sequence is to be checked for known single amino acid polymorphisms
*/
bool mscore::set_saps(const bool _b,string &_s)
{
m_bUseSaps = _b;
m_Sap.reset_value(_s,_b);
return m_bUseSaps;
}
bool mscore::set_allowed_saps(string &_s)
{
m_Sap.allowed(_s);
return m_bUseSaps;
}
/*
* set the absolute, zero-based start position of the peptide in the full
* protein sequence
*/
bool mscore::set_pos(const size_t _t)
{
m_tSeqPos = _t;
return true;
}
/*
* set a new peptide sequence for consideration
*/
unsigned long mscore::set_seq(const char *_s,const bool _n,const bool _c,const unsigned long _l,const int _f)
{
m_tSeqPos = _f;
if(_s == NULL)
return 0;
/*
* adjust arrays if the sequence is longer that m_lSize
*/
m_lSeqLength = _l;
if(m_lSeqLength >= m_lSize-1) {
if(m_pfSeq != NULL)
delete m_pfSeq;
if(m_plSeq != NULL)
delete m_plSeq;
if(m_pSeq != NULL)
delete m_pSeq;
m_lSize = m_lSeqLength + 16;
m_pfSeq = new float[m_lSize];
m_pSeq = new char[m_lSize];
m_plSeq = new unsigned long[m_lSize];
}
/*
* make a copy of the sequence
*/
strcpy(m_pSeq,_s);
m_dSeqMH = 0.0;
unsigned long a = 0;
m_bIsC = _c;
m_bIsN = _n;
m_State.initialize(m_pSeq,m_lSize);
m_Term.initialize(m_seqUtil.m_pdAaMod['['],m_seqUtil.m_pdAaMod[']']);
m_State.m_lLastS = 0;
map::iterator itValue;
map::iterator itEnd = m_seqUtil.m_mapMotifs.end();
SMap::iterator itSeq;
SMap::iterator itSeqEnd = m_seqUtil.m_mapMods.end();
a = 0;
if(m_seqUtil.m_bPotentialMotif) {
m_seqUtil.clear_motifs(true);
}
/*
* calculate the M+H of the sequence
*/
m_iCharge = 1;
while(a < m_lSeqLength) {
m_dSeqMH += m_seqUtil.m_pdAaMass[m_pSeq[a]] + m_seqUtil.m_pdAaMod[m_pSeq[a]] + m_seqUtil.m_pdAaFullMod[m_pSeq[a]];
if(m_seqUtil.m_bSequenceMods) {
itSeq = m_seqUtil.m_mapMods.find((unsigned long)(m_tSeqPos+a));
if(itSeq != itSeqEnd) {
m_dSeqMH += itSeq->second;
}
}
if(m_seqUtil.m_pdAaMod[m_pSeq[a]+32] != 0.0)
m_State.add_mod(m_pSeq+a);
itValue = m_seqUtil.m_mapMotifs.find(m_tSeqPos+a);
if(m_seqUtil.m_bPotentialMotif) {
itValue = m_seqUtil.m_mapMotifs.find(m_tSeqPos+a);
if(itValue != itEnd){
m_State.add_mod(m_pSeq+a);
m_seqUtil.add_mod(m_pSeq[a],itValue->second);
}
}
a++;
}
if(m_seqUtil.m_bPotentialMotif) {
m_seqUtil.set_motifs();
}
m_dSeqMH += m_seqUtil.m_dProton + m_seqUtil.m_dCleaveN + m_seqUtil.m_dCleaveC;
if(m_Term.m_lN) {
m_dSeqMH += m_seqUtil.m_pdAaMod['['];
}
if(m_Term.m_lC) {
m_dSeqMH += m_seqUtil.m_pdAaMod[']'];
}
/*
* deal with protein terminii
*/
if(m_bIsC)
m_dSeqMH += m_seqUtil.m_fCT;
if(m_bIsN)
m_dSeqMH += m_seqUtil.m_fNT;
m_dSeqMH += m_seqUtil.m_pdAaFullMod['['];
m_dSeqMH += m_seqUtil.m_pdAaFullMod[']'];
/*
* record the M+H value in the mstate object
*/
m_State.m_dSeqMHS = m_dSeqMH;
m_dMinMass = m_dSeqMH;
if(m_bUsePam) {
m_Pam.initialize(m_pSeq,m_lSize,(float)m_dSeqMH);
}
if(m_bUseSaps) {
m_Sap.m_bMods = m_pSeqUtilFrag->m_bSequenceMods;
m_Sap.m_smapOld = m_pSeqUtilFrag->m_mapMods;
m_Sap.initialize(m_pSeq,(size_t)m_lSize,(float)m_dSeqMH,_f);
}
return m_lSeqLength;
}
/*
* sets the types of ions (Biemann notation) to be used in scoring a peptide sequence
*/
unsigned long mscore::set_type(const unsigned long _t)
{
m_lType = _t;
return m_lType;
}
/*
* sets the interpretation of the parent ion and fragment ion errors to be either absolute
* in Daltons, or relative, in parts-per-million. the allowed values are constructed
* from the values in the enum mscore_error.
*/
unsigned long mscore::set_error(const unsigned long _t)
{
m_lErrorType = _t;
return m_lErrorType;
}
/*
* sets the interpretation of the parent ion and fragment ion errors to be either absolute
* in Daltons, or relative, in parts-per-million. the allowed values are constructed
* from the values in the enum mscore_error.
*/
double mscore::set_homo_error(const double _f)
{
m_dHomoError = _f;
return m_dHomoError;
}
/*
* sets the value for the fragment error member value m_fErr. this value is interpreted in two ways:
* CASE 1: m_lErrorType & T_FRAGMENT_DALTONS is true
* in this case, the error is the error in Daltons
* CASE 2: m_lErrorType & T_FRAGMENT_PPM is true
* in this case, the error in Daltons is calculated at m/z = 200.0
* this value is used in the blur() method and the width of the
* blurred distribution is scaled from the value at m/z = 200.0
*/
double mscore::set_fragment_error(const double _f)
{
if(_f <= 0.0)
return 0.0;
m_dErr = _f;
if(m_lErrorType & T_FRAGMENT_PPM) {
m_dErr = (200.0*m_dErr/1e6);
}
/*
* NOTE: the m_fErr value used in the ppm case is: 200 x (the error in ppm)/1000000
*/
return m_dErr;
}
/*
* sets the value for the parent error member values m_dParentErrPlus and m_dParentErrMinus.
*/
double mscore::set_parent_error(const double _f,const bool _b)
{
if(_b) {
if(_f < 0.0)
m_dParentErrPlus = 0.0;
else
m_dParentErrPlus = _f;
}
else {
if(_f < 0.0)
m_dParentErrPlus = 0.0;
else
m_dParentErrMinus = _f;
}
return _f;
}
/*
* sets the value for the m_bIsotopeError member, which checks for isotope peak assignment errors
*/
bool mscore::set_isotope_error(const bool _b)
{
m_bIsotopeError = _b;
return m_bIsotopeError;
}
/*
* sets the mass type for fragment ions
*/
void mscore::set_fragment_masstype(masscalc::massType _t)
{
if (_t == masscalc::average) {
m_seqUtilAvg.set_modified(true);
m_pSeqUtilFrag = &m_seqUtilAvg;
}
else {
m_pSeqUtilFrag = &m_seqUtil;
}
}
/*
* return true if any parent ion is within error of the current peptide's modified M+H
* and return the number of spectra that have M+H values greater than or within error
* of the current peptide's modified M+H
*/
bool mscore::test_parents(size_t &_t) {
size_t a = 0;
const float fSeqMH = (float)m_dSeqMH;
if(m_lSpectra > 100) {
size_t h = m_lSpectra/10;
while(!(m_vDetails[a] < fSeqMH) && a < 9*h) {
a += h;
}
}
const size_t tLimit = (size_t)m_lSpectra;
while(a < tLimit) {
if(m_vDetails[a] == fSeqMH) {
_t = tLimit - a;
return true;
}
a++;
}
return false;
}
bool mscore::reset_permute()
{
m_psPermute.m_tPos = 0;
m_psPermute.m_tEnd = m_lSeqLength-2;
if(m_lSeqLength > m_psPermute.m_lSize) {
delete m_psPermute.m_pPerm;
delete m_psPermute.m_pSeq;
m_psPermute.m_lSize = m_lSeqLength + 16;
m_psPermute.m_pPerm = new char[m_psPermute.m_lSize+1];
m_psPermute.m_pSeq = new char[m_psPermute.m_lSize+1];
}
strcpy(m_psPermute.m_pSeq,m_pSeq);
m_psPermute.m_bRev = true;
return true;
}
bool mscore::permute()
{
if(m_psPermute.m_tPos == m_psPermute.m_tEnd && m_psPermute.m_bRev) {
strcpy(m_pSeq,m_psPermute.m_pSeq);
string strTemp;
string strSeq = m_pSeq;
string::reverse_iterator itS = strSeq.rbegin();
string::reverse_iterator itE = strSeq.rend();
while(itS != itE) {
strTemp += *itS;
itS++;
}
strcpy(m_pSeq,strTemp.c_str());
m_psPermute.m_bRev = false;
m_psPermute.m_tPos = 0;
}
if(m_psPermute.m_tPos == m_psPermute.m_tEnd) {
strcpy(m_pSeq,m_psPermute.m_pSeq);
return false;
}
memcpy(m_psPermute.m_pPerm + 1,m_pSeq,m_lSeqLength);
m_psPermute.m_pPerm[0] = m_psPermute.m_pPerm[m_lSeqLength];
m_psPermute.m_pPerm[m_lSeqLength] = '\0';
memcpy(m_pSeq,m_psPermute.m_pPerm,m_lSeqLength);
m_psPermute.m_tPos++;
return true;
}
/*
* mscoremanager contains static short-cuts for dealing with mscore
* plug-ins.
*/
const char* mscoremanager::TYPE = "scoring, algorithm";
/*
* create_mscore creates the correct mscore for the given set of XML
* parameters.
*/
mscore* mscoremanager::create_mscore(XmlParameter &_x)
{
string strValue;
string strKey = TYPE;
if (!_x.get(strKey,strValue))
strValue = "tandem";
return (mscore*) mpluginmanager::get().create_plugin(TYPE, strValue.data());
}
/*
* register_factory registers a factory with the mpluginmanager for
* creating mscore derived objects.
*/
void mscoremanager::register_factory(const char* _spec, mpluginfactory* _f)
{
mpluginmanager::get().register_factory(TYPE, _spec, _f);
}
tandem-linux-13-09-01-1/src/mprocess.cpp 0000664 0001750 0001750 00000422122 12205500073 017753 0 ustar langella langella /*
Copyright (C) 2003-2013 Ronald C Beavis, all rights reserved
X! tandem
This software is a component of the X! proteomics software
development project
Use of this software governed by the Artistic license, as reproduced here:
The Artistic License for all X! software, binaries and documentation
Preamble
The intent of this document is to state the conditions under which a
Package may be copied, such that the Copyright Holder maintains some
semblance of artistic control over the development of the package,
while giving the users of the package the right to use and distribute
the Package in a more-or-less customary fashion, plus the right to
make reasonable modifications.
Definitions
"Package" refers to the collection of files distributed by the Copyright
Holder, and derivatives of that collection of files created through
textual modification.
"Standard Version" refers to such a Package if it has not been modified,
or has been modified in accordance with the wishes of the Copyright
Holder as specified below.
"Copyright Holder" is whoever is named in the copyright or copyrights
for the package.
"You" is you, if you're thinking about copying or distributing this Package.
"Reasonable copying fee" is whatever you can justify on the basis of
media cost, duplication charges, time of people involved, and so on.
(You will not be required to justify it to the Copyright Holder, but
only to the computing community at large as a market that must bear
the fee.)
"Freely Available" means that no fee is charged for the item itself,
though there may be fees involved in handling the item. It also means
that recipients of the item may redistribute it under the same
conditions they received it.
1. You may make and give away verbatim copies of the source form of the
Standard Version of this Package without restriction, provided that
you duplicate all of the original copyright notices and associated
disclaimers.
2. You may apply bug fixes, portability fixes and other modifications
derived from the Public Domain or from the Copyright Holder. A
Package modified in such a way shall still be considered the Standard
Version.
3. You may otherwise modify your copy of this Package in any way, provided
that you insert a prominent notice in each changed file stating how and
when you changed that file, and provided that you do at least ONE of the
following:
a. place your modifications in the Public Domain or otherwise make them
Freely Available, such as by posting said modifications to Usenet
or an equivalent medium, or placing the modifications on a major
archive site such as uunet.uu.net, or by allowing the Copyright Holder
to include your modifications in the Standard Version of the Package.
b. use the modified Package only within your corporation or organization.
c. rename any non-standard executables so the names do not conflict
with standard executables, which must also be provided, and provide
a separate manual page for each non-standard executable that clearly
documents how it differs from the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
4. You may distribute the programs of this Package in object code or
executable form, provided that you do at least ONE of the following:
a. distribute a Standard Version of the executables and library files,
together with instructions (in the manual page or equivalent) on
where to get the Standard Version.
b. accompany the distribution with the machine-readable source of the
Package with your modifications.
c. give non-standard executables non-standard names, and clearly
document the differences in manual pages (or equivalent), together
with instructions on where to get the Standard Version.
d. make other distribution arrangements with the Copyright Holder.
5. You may charge a reasonable copying fee for any distribution of
this Package. You may charge any fee you choose for support of
this Package. You may not charge a fee for this Package itself.
However, you may distribute this Package in aggregate with other
(possibly commercial) programs as part of a larger (possibly
commercial) software distribution provided that you do not a
dvertise this Package as a product of your own. You may embed this
Package's interpreter within an executable of yours (by linking);
this shall be construed as a mere form of aggregation, provided that
the complete Standard Version of the interpreter is so embedded.
6. The scripts and library files supplied as input to or produced as
output from the programs of this Package do not automatically fall
under the copyright of this Package, but belong to whomever generated
them, and may be sold commercially, and may be aggregated with this
Package. If such scripts or library files are aggregated with this
Package via the so-called "undump" or "unexec" methods of producing
a binary executable image, then distribution of such an image shall
neither be construed as a distribution of this Package nor shall it
fall under the restrictions of Paragraphs 3 and 4, provided that you
do not represent such an executable image as a Standard Version of
this Package.
7. C subroutines (or comparably compiled subroutines in other languages)
supplied by you and linked into this Package in order to emulate
subroutines and variables of the language defined by this Package
shall not be considered part of this Package, but are the equivalent
of input as in Paragraph 6, provided these subroutines do not change
the language in any way that would cause it to fail the regression
tests for the language.
8. Aggregation of this Package with a commercial distribution is always
permitted provided that the use of this Package is embedded; that is,
when no overt attempt is made to make this Package's interfaces visible
to the end user of the commercial distribution. Such use shall not be
construed as a distribution of this Package.
9. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
*/
// File version: 2004-02-01
// File version: 2004-03-01
// File version: 2004-03-01
// File version: 2004-07-12
// File version: 2004-10-05
// File version: 2004-11-01
// File version: 2005-01-01
/*
* the process object coordinates the function of tandem. it contains the information
* loaded from the input XML file in the m_xmlValues object and performance
* information in the m_xmlPerformance object. The mass spectra to be analyzed are
* in the m_vSpectra vector container. A set of input parameters are used to
* initialize constants that are used in processing the mass spectra.
* NOTE: see tandem.cpp for an example of how to use an mprocess class
* NOTE: mprocess uses cout to report errors. This may not be appropriate for
* many applications. Feel free to change this to a more appropriate mechanism
*/
#include "stdafx.h"
#include
#include
#include "msequence.h"
#include "msequencecollection.h"
#include "msequenceserver.h"
#include "msequtilities.h"
#include "mspectrum.h"
#include "loadmspectrum.h"
#include "xmlparameter.h"
#include "mscore.h"
#include "mprocess.h"
#include "saxbiomlhandler.h"
#include "saxsaphandler.h"
#include "saxmodhandler.h"
#include "xmltaxonomy.h"
#include "mbiomlreport.h"
#include "mrefine.h"
// #define TANDEM_EXACT 1
/*
* global less than operators to be used in sort operations
*/
bool lessThanSequence(const msequence &_l,const msequence &_r);
bool lessThanSequenceId(const msequence &_l,const msequence &_r);
bool lessThanSequenceDes(const msequence &_l,const msequence &_r);
bool lessThanSpectrum(const mspectrum &_l,const mspectrum &_r);
bool lessThanSpectrumUid(const mspectrum &_l,const mspectrum &_r);
bool lessThanOrder(const mspectrum &l,const mspectrum &r);
bool lessThanMass(const mi &_l,const mi &_r);
bool lessThanSequence(const msequence &_l,const msequence &_r)
{
return _l.m_dExpect < _r.m_dExpect;
}
bool lessThanSequenceUid(const msequence &_l,const msequence &_r)
{
return _l.m_tUid < _r.m_tUid;
}
bool lessThanSequenceDes(const msequence &_l,const msequence &_r)
{
return _l.m_strDes.size() < _r.m_strDes.size();
}
bool lessThanSpectrum(const mspectrum &_l,const mspectrum &_r)
{
return _l.m_dProteinExpect < _r.m_dProteinExpect;
}
bool lessThanSpectrumId(const mspectrum &_l,const mspectrum &_r)
{
return _l.m_tId < _r.m_tId;
}
bool lessThanSpectrumSequence(const mspectrum &_l,const mspectrum &_r)
{
if(_l.m_vseqBest.empty())
return false;
if(_r.m_vseqBest.empty())
return true;
return _l.m_dExpect < _r.m_dExpect;
}
bool lessThanOrder(const mspectrum &_l,const mspectrum &_r)
{
if(_l.m_vseqBest.empty())
return false;
if(_r.m_vseqBest.empty())
return true;
return _l.m_vseqBest[0].m_vDomains[0].m_lS < _r.m_vseqBest[0].m_vDomains[0].m_lS;
}
bool lessThanMass(const mi &_l,const mi &_r)
{
return _l.m_fM < _r.m_fM;
}
mprocess::mprocess(void)
{
m_iCurrentRound = 1;
m_lReversed = -1;
m_tMissedCleaves = 1;
/*
* record the process start time
*/
time_t tValue;
time(&tValue);
struct tm *tmValue = localtime(&tValue);
char pLine[256];
strftime(pLine, 255,"%Y:%m:%d:%H:%M:%S",tmValue);
string strKey;
string strValue;
strKey = "process, start time";
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
/*
* record the version of the software
*/
strKey = "process, version";
#ifdef X_P3
strValue = "X! P3 ";
#else
strValue = "X! Tandem ";
#endif
strValue += VERSION;
m_xmlPerformance.set(strKey,strValue);
m_tProteinCount = 0;
m_tPeptideCount = 0;
m_tTotalResidues = 0;
m_tPeptideScoredCount = 0;
m_tMinResidues = 0;
m_lThread = 0;
m_lThreads = 1;
m_tValid = 0;
m_tUnique = 0;
m_tSpectraTotal = 0;
m_bUn = false;
m_tSeqSize = 4096*4;
m_pSeq = new char[m_tSeqSize];
m_lStartMax = 100000000;
m_dThreshold = 1000.0;
m_tRefineInput = 0;
m_tRefinePartial = 0;
m_tRefineUnanticipated = 0;
m_tRefineNterminal = 0;
m_tRefineCterminal = 0;
m_tRefinePam = 0;
m_tRefineModels = 0;
m_tContrasted = 0;
m_bUseHomologManagement = false;
m_pScore = NULL;
m_lCStartMax = 50;
m_bCrcCheck = false;
m_bRefineCterm = false;
m_semiState.activate(false);
m_tActive = 0;
m_bReversedOnly = false;
m_bSaps = false;
m_bAnnotation = false;
m_bMinimalAnnotation = false;
m_bSerialize = false;
m_bQuickAcetyl = true;
m_bQuickPyro = true;
m_bCheckNg = false;
m_dNt = 0.0;
m_dNtAve = 0.0;
m_dNg = 0.0;
m_dNgAve = 0.0;
m_tDuplicates = 0;
m_tDuplicateIds = 0;
m_tTemp = 0;
m_bSkyline = false;
m_pCrcTable = NULL;
m_fMaxMass = 5000;
m_fMaxZ = 2;
#ifdef X_P3
m_bUseCrc = false;
#else
m_bUseCrc = true;
#endif
}
mprocess::~mprocess(void)
{
if(m_pSeq != NULL)
delete m_pSeq;
if(m_pScore != NULL)
delete m_pScore;
if(m_lThread == 0 || m_lThread == 0xFFFFFFFF) {
m_prcLog.log("X! Tandem exiting");
m_prcLog.close();
}
if(m_pCrcTable != NULL) {
delete m_pCrcTable;
}
}
/*
* add spectra is used to load spectra into the m_vSpectra vector
*/
bool mprocess::add_spectra(vector &_v)
{
size_t a = 0;
// changed from m_vSpectra.resize(m_vSpectra.size() + _v.size()+1) in 2006.02.01
m_vSpectra.reserve(m_vSpectra.size() + _v.size()+1);
size_t c = 0;
while(a < _v.size()) {
m_vSpectra.push_back(_v[a]);
if(c == 1000) {
cout << ".";
cout.flush();
c = 0;
}
c++;
a++;
}
return true;
}
/*
* clean_sequences is used to maintain the m_mapSequences container. If a sequence
* has been removed from the m_vSpectra list of sequences, then that sequence is
* subsequently deleted from the m_mapSequences collection
*/
bool mprocess::clean_sequences(void)
{
map mapValue;
map::iterator itMap;
size_t a = 0;
size_t b = 0;
size_t tLength = m_vSpectra.size();
size_t tBest = 0;
while(a < tLength) {
b = 0;
tBest = m_vSpectra[a].m_vseqBest.size();
while(b < tBest) {
mapValue[m_vSpectra[a].m_vseqBest[b].m_tUid] = 1;
b++;
}
a++;
}
SEQMAP::iterator itValue = m_mapSequences.begin();
while(itValue != m_mapSequences.end()) {
itMap = mapValue.find((*itValue).first);
if(itMap == mapValue.end()) {
m_mapSequences.erase(itValue);
itValue = m_mapSequences.begin();
}
else {
itValue++;
}
}
return true;
}
/*
* clear is used to reset any vector or map object necessary to reset the mprocess object
*/
bool mprocess::clear(void)
{
m_vSpectra.clear();
if (m_pScore != NULL)
m_pScore->clear();
return true;
}
/*
* create_rollback is used to create a vector of mspectrum objects that serves as
* the record of values to be used by the rollback method.
*/
bool mprocess::create_rollback(vector& _v)
{
_v.clear();
size_t a = 0;
const size_t tSize = m_vSpectra.size();
mspectrum spTemp;
double dExpect = 0;
_v.reserve(tSize);
while(a < tSize) {
_v.push_back(spTemp);
_v.back() *= m_vSpectra[a];
m_vSpectra[a].m_hHyper.model();
m_vSpectra[a].m_hHyper.set_protein_factor(1.0);
dExpect = (double)m_vSpectra[a].m_hHyper.expect_protein(m_pScore->hconvert(m_vSpectra[a].m_fHyper));
_v.back().m_dExpect = dExpect;
a++;
}
return true;
}
/*
* create_score takes an msequence object and a start and an end sequence position
* and saves that msequence, its mdomain and scoring in the spectrum that has just
* been scored. equivalent msequence objects (based on their hyper score)
* are stored sequentially in a vector in the mspectrum object
*/
bool mprocess::create_score(const msequence &_s,const size_t _v,const size_t _w,const long _m,bool _p)
{
long lIonCount = 0;
float fScore = -1.0;
float fHyper = -1.0;
size_t a = 0;
size_t b = 0;
size_t c = 0;
bool bOk = false;
bool bDom = false;
long lCount = 0;
bool bIonCheck = false;
bool bMassCheck = false;
bool bC = false;
// if(_s.m_strDes == "ENSRNOP00000027073" && _v == 11 && _w == 26) {
// bC = true;
// }
/*
* score each mspectrum identified as a candidate in the m_pScore->m_State object
*/
set setDone;
while(lCount < m_pScore->m_State.m_lEqualsS) {
bIonCheck = false;
bMassCheck = false;
a = m_pScore->m_State.m_plEqualsS[lCount];
lCount++;
lIonCount = 0;
/*
* this check is needed to keep tandem consistent whether running on
* single-threaded, multi-threaded or on a cluster. otherwise, when
* there are multiple spectra matching a sequence (which is more common
* the fewer mprocess objects there are) one can cause others to score
* more permutation sequences.
*/
if (!_p && m_vSpectra[a].m_hHyper.m_ulCount >= 400)
continue;
fScore = 1.0;
fHyper = 1.0;
m_pScore->m_lMaxCharge = (long)(m_vSpectra[a].m_fZ+0.1);
/*
* in versions prior to 2004.03.01, spectra with m_bActive == false were
* rejected at this point, to save time & because of a problem with
* multiple recording of the same sequence. starting with 2004.03.01,
* the later problem has been corrected, and because of point mutation
* analysis, it has become important to reexamine all sequences.
*/
fScore = m_pScore->score(a);
fHyper = m_pScore->m_fHyper;
/*
* If the convolution score is greater than 2.0, record information in the ion-type histograms
*/
if(fScore > 2.0) {
m_tPeptideScoredCount++;
lIonCount = m_pScore->m_plCount[mscore::S_B] + m_pScore->m_plCount[mscore::S_Y];
lIonCount += m_pScore->m_plCount[mscore::S_C] + m_pScore->m_plCount[mscore::S_Z];
lIonCount += m_pScore->m_plCount[mscore::S_A] + m_pScore->m_plCount[mscore::S_X];
m_vSpectra[a].m_hHyper.add(m_pScore->hconvert(fHyper));
m_vSpectra[a].m_hConvolute.add(m_pScore->hconvert(fScore));
m_vSpectra[a].m_chBCount.add(m_pScore->m_plCount[mscore::S_A] +
m_pScore->m_plCount[mscore::S_B] +
m_pScore->m_plCount[mscore::S_C]);
m_vSpectra[a].m_chYCount.add(m_pScore->m_plCount[mscore::S_X] +
m_pScore->m_plCount[mscore::S_Y] +
m_pScore->m_plCount[mscore::S_Z]);
}
/*
* this check is must be outside the above conditional to keep tandem
* consistent whether running on single-threaded, multi-threaded or on
* a cluster. otherwise, when there are multiple spectra matching a
* sequence (which is more common the fewer mprocess objects there are)
* one can cause others to score differently from how they would score
* alone.
*/
if (m_vSpectra[a].m_hHyper.m_ulCount < 400 && m_iCurrentRound < 3) {
if(m_bCrcCheck && _p) {
m_bPermute = true;
}
else if(m_vSpectra[a].m_dMH > 3000.0) {
m_bPermuteHigh = true;
}
}
double dRatio = (double)lIonCount/(double)(_w - _v + 1);
if(m_vSpectra[a].m_fZ < 1.1 && dRatio > 0.2 && lIonCount > m_lIonCount) {
bIonCheck = true;
}
if(m_vSpectra[a].m_fZ > 1.0 && dRatio > 0.5 && lIonCount > m_lIonCount) {
bIonCheck = true;
}
if(lIonCount > m_lIonCount) {
bIonCheck = true;
}
if(m_vSpectra[a].m_fZ > 1.0 && dRatio > 0.5 && lIonCount > m_lIonCount) {
bIonCheck = true;
}
bMassCheck = m_errValues.check(m_vSpectra[a].m_dMH,m_pScore->seq_mh());
if(!_p) {
bMassCheck = false;
}
/*
* if the same score has been recorded for another peptide in the same msequence object,
* add a domain to that object, but do not update the entire object
*/
unsigned char ucM = 0;
if(_m < 0) {
ucM = 0;
}
else {
ucM = (unsigned char)_m;
}
if(bMassCheck && bIonCheck && fHyper == m_vSpectra[a].m_fHyper && m_vSpectra[a].m_tCurrentSequence == _s.m_tUid) {
vector vAa;
mdomain domValue;
domValue.m_vAa.clear();
double dDelta = 0.0;
if(m_pScore->get_aa(vAa,_v,dDelta)) {
b = 0;
while(b < vAa.size()) {
domValue.m_vAa.push_back(vAa[b]);
b++;
}
}
if(fabs(dDelta) > 2.5) {
domValue.m_fScore = fScore;
domValue.m_fHyper = fHyper;
domValue.m_dMH = m_pScore->seq_mh();
// m_fDelta was changed to m_dDelta in 2006.02.01
domValue.m_dDelta = m_vSpectra[a].m_dMH - m_pScore->seq_mh();
domValue.m_lE = (int)_w;
domValue.m_lS = (int)_v;
domValue.m_lMissedCleaves = ucM;
domValue.m_bUn = m_bUn;
unsigned char lType = 1;
unsigned long sType = 1;
while(lType < m_pScore->m_lType+1) {
m_vSpectra[a].m_mapScore[lType] = m_pScore->m_pfScore[sType];
m_vSpectra[a].m_mapCount[lType] = (unsigned int)m_pScore->m_plCount[sType];
lType *= 2;
sType++;
}
b = 0;
bOk = true;
while(bOk && b < m_vSpectra[a].m_vseqBest.back().m_vDomains.size()) {
if(domValue == m_vSpectra[a].m_vseqBest.back().m_vDomains[b]){
bOk = false;
}
b++;
}
if(bOk) {
m_vSpectra[a].m_vseqBest.back().m_vDomains.push_back(domValue);
}
}
}
/*
* if the same hyper score has been recorded for a different msequence object, retain that
* object and add the new msequence to the back of the m_vseqBest vector
*/
else if(bMassCheck && bIonCheck && fHyper == m_vSpectra[a].m_fHyper) {
vector vAa;
msequence seqValue;
mdomain domValue;
domValue.m_vAa.clear();
double dDelta = 0.0;
if(m_pScore->get_aa(vAa,_v,dDelta)) {
b = 0;
while(b < vAa.size()) {
domValue.m_vAa.push_back(vAa[b]);
b++;
}
}
if(fabs(dDelta) > 2.5) {
domValue.m_fScore = fScore;
domValue.m_fHyper = fHyper;
domValue.m_dMH = m_pScore->seq_mh();
// m_fDelta was changed to m_dDelta in 2006.02.01
domValue.m_dDelta = m_vSpectra[a].m_dMH - m_pScore->seq_mh();
domValue.m_lE = (int)_w;
domValue.m_lS = (int)_v;
domValue.m_lMissedCleaves = ucM;
domValue.m_bUn = m_bUn;
unsigned char lType = 1;
unsigned long sType = 1;
while(lType < m_pScore->m_lType+1) {
m_vSpectra[a].m_mapScore[lType] = m_pScore->m_pfScore[sType];
m_vSpectra[a].m_mapCount[lType] = (unsigned int)m_pScore->m_plCount[sType];
lType *= 2;
sType++;
}
seqValue = _s;
seqValue.m_strSeq = " ";
m_mapSequences.insert(SEQMAP::value_type(_s.m_tUid,_s.m_strSeq));
seqValue.m_vDomains.clear();
seqValue.m_vDomains.push_back(domValue);
bOk = true;
b = 0;
while(bOk && b < m_vSpectra[a].m_vseqBest.size()) {
if(m_vSpectra[a].m_vseqBest[b].m_tUid == _s.m_tUid) {
c = 0;
bDom = true;
while(bDom && c < m_vSpectra[a].m_vseqBest[b].m_vDomains.size()) {
if(m_vSpectra[a].m_vseqBest[b].m_vDomains[c] == domValue) {
bDom = false;
bOk = false;
}
c++;
}
if(bDom) {
m_vSpectra[a].m_vseqBest[b].m_vDomains.push_back(domValue);
bOk = false;
}
}
b++;
}
if(bOk) {
m_vSpectra[a].m_dRatio = dRatio;
m_vSpectra[a].m_tCurrentSequence = _s.m_tUid;
seqValue.m_iRound = m_iCurrentRound;
m_vSpectra[a].m_vseqBest.push_back(seqValue);
}
}
}
/*
* if the hyper score is the best found so far for the mspectrum, delete the old msequence
* objects and record this one.
*/
else if(bMassCheck && bIonCheck && fHyper > m_vSpectra[a].m_fHyper && lIonCount > m_lIonCount) {
vector vAa;
msequence seqValue;
mdomain domValue;
domValue.m_vAa.clear();
double dDelta = 0.0;
if(m_pScore->get_aa(vAa,_v,dDelta)) {
b = 0;
while(b < vAa.size()) {
domValue.m_vAa.push_back(vAa[b]);
b++;
}
}
if(fabs(dDelta) > 2.5) {
if(m_vSpectra[a].m_fHyper > m_vSpectra[a].m_fScoreNext) {
m_vSpectra[a].m_fScoreNext = m_vSpectra[a].m_fScore;
m_vSpectra[a].m_fHyperNext = m_vSpectra[a].m_fHyper;
}
m_vSpectra[a].m_fScore = fScore;
m_vSpectra[a].m_fHyper = fHyper;
domValue.m_fScore = fScore;
domValue.m_fHyper = fHyper;
domValue.m_lE = (int)_w;
domValue.m_lS = (int)_v;
domValue.m_lMissedCleaves = ucM;
domValue.m_dMH = m_pScore->seq_mh();
// m_fDelta was changed to m_dDelta in 2006.02.01
domValue.m_dDelta = m_vSpectra[a].m_dMH - m_pScore->seq_mh();
domValue.m_bUn = m_bUn;
unsigned char lType = 1;
unsigned long sType = 1;
while(lType < m_pScore->m_lType+1) {
m_vSpectra[a].m_mapScore[lType] = m_pScore->m_pfScore[sType];
m_vSpectra[a].m_mapCount[lType] = (unsigned int)m_pScore->m_plCount[sType];
lType *= 2;
sType++;
}
seqValue = _s;
seqValue.m_strSeq = " ";
m_mapSequences.insert(SEQMAP::value_type(_s.m_tUid,_s.m_strSeq));
seqValue.m_vDomains.clear();
seqValue.m_vDomains.push_back(domValue);
m_vSpectra[a].m_tCurrentSequence = _s.m_tUid;
m_vSpectra[a].m_vseqBest.clear();
seqValue.m_iRound = m_iCurrentRound;
m_vSpectra[a].m_dRatio = dRatio;
m_vSpectra[a].m_vseqBest.push_back(seqValue);
}
}
else if(_p && bMassCheck && bIonCheck && fHyper > m_vSpectra[a].m_fHyperNext) {
m_vSpectra[a].m_fScoreNext = fScore;
m_vSpectra[a].m_fHyperNext = fHyper;
}
}
return true;
}
//
// This method is used to perform an inner product between two mass spectra. The fragment
// ion mass accuracy is used to set the binning for the two vectors
//
__inline__ double mprocess::dot(const size_t _f,const size_t _s,const float _r,const bool _t)
{
float fValue = 0.0;
vector::iterator itA = m_vSpectra[_f].m_vMI.begin();
vector::iterator itB = m_vSpectra[_s].m_vMI.begin();
vector::const_iterator itAEnd = m_vSpectra[_f].m_vMI.end();
vector::const_iterator itBEnd = m_vSpectra[_s].m_vMI.end();
// if _t == true, then the mass error, _r, is given in Daltons
if(_t) {
while(itA != itAEnd) {
while(itB != itBEnd) {
if(fabs(itB->m_fM - itA->m_fM) <= _r) {
fValue += itB->m_fI*itA->m_fI;
}
if(itB->m_fM > itA->m_fM) {
break;
}
itB++;
}
itA++;
}
}
// deal with the case where _r is in ppm
else {
const float fRes = (float)(_r/1.0e6);
float fW = fRes;
while(itA != itAEnd) {
fW = itA->m_fM * fRes;
while(itB != itBEnd) {
if(fabs(itB->m_fM - itA->m_fM) <= fW) {
fValue += itB->m_fI*itA->m_fI;
}
if(itB->m_fM > itA->m_fM) {
break;
}
itB++;
}
itA++;
}
}
return (double)fValue;
}
/*
* expect_protein is used to assign the expectation value for a protein, if more
* than one peptide has been found for that protein. the expectation values for
* the peptides are combined with a simple Bayesian model for the probability of
* having two peptides from the same protein having the best score in different
* spectra.
*/
double mprocess::expect_protein(const unsigned long _c,const unsigned long _t,
const unsigned long _n,const double _d)
{
double dValue = _d+log10((double)m_tProteinCount);
if(_c == 1 && _d < 0.0) {
return _d;
}
else if(_c == 1) {
return 1.0;
}
if(_c == 0) {
return 1.0;
}
double dN = _n;
double dK = _c;
double dV = _t;
unsigned long a = 0;
while(a < _c) {
dValue += log10((dV - a)/(dK - a));
a++;
}
dValue -= log10(dV);
dValue -= (dK-1.0)*log10(dN);
double dP = dN/(double)m_tPeptideCount;
if(dP >= 1.0)
dP = 0.9999999;
double dLog = dK*log10(dP)+(dV-dK)*log10(1.0-dP);
dValue += dLog;
char *pLine = new char[256];
sprintf(pLine,"%.1lf",dValue);
if(strstr(pLine,"-1.$")) {
dValue = -5999.0;
}
if(dValue < -5999.0) {
dValue = -5999.0;
}
delete pLine;
return dValue;
}
/*
* get_peptide_count returns the total number of peptides that have been scored
*/
size_t mprocess::get_peptide_count()
{
return m_tPeptideCount;
}
/*
* get_protein_count returns the total number of proteins that have been scored
*/
size_t mprocess::get_protein_count()
{
return m_tProteinCount;
}
/*
* get_reversed returns the number of significant reverse peptide sequences
*/
long mprocess::get_reversed()
{
return m_lReversed;
}
/*
* get_thread returns the thread number for the object
*/
unsigned long mprocess::get_thread()
{
return m_lThread;
}
/*
* get_threads returns the total number of threads currently in use
*/
unsigned long mprocess::get_threads()
{
return m_lThreads;
}
/*
* get_threshold returns the current value of the expectation value threshold
*/
double mprocess::get_threshold()
{
return m_dThreshold;
}
/*
* get_total_residues returns the total number of residues that have been processed
*/
size_t mprocess::get_total_residues()
{
return m_tTotalResidues;
}
/*
* get_valid returns the number of unique models
*/
size_t mprocess::get_unique()
{
return m_tUnique;
}
/*
* get_valid returns the number of valid models
*/
size_t mprocess::get_valid()
{
return m_tValid;
}
/*
* load takes a path name to the input XML parameter file and uses that file name
* to initialize an XmlParameters object
*/
bool mprocess::load(const char *_f,mprocess *_p)
{
/*
* check the string
*/
if(_f == NULL)
return false;
string strFile = _f;
/*
* load the m_xmlValues object
*/
bool bReturn = m_xmlValues.load(strFile);
if(!bReturn) {
cout << "The input parameter file \"" << strFile.c_str() << "\" could not be located.\nCheck the file path name and try again.\n";
return false;
}
/*
* check for the specification of a default parameter list
*/
string strValue;
string strKey = "list path, default parameters";
if(m_xmlValues.get(strKey,strValue)) {
/*
* if there is a default parameter list, load it and then reload the input list
* the input list will over ride all settings in the default list
*/
m_xmlValues.load(strValue);
m_xmlValues.load(strFile);
strKey = "list path, default parameters";
m_xmlValues.get(strKey,strValue);
}
/*
* if a parameter list was found, load the msequenceServer object with the taxonomy information
*/
if(bReturn) {
bReturn = taxonomy();
}
/*
* if the msequenceServer object was loaded, create the scoring object
*/
if (bReturn) {
m_pScore = mscoremanager::create_mscore(m_xmlValues);
if (m_pScore != NULL) {
bReturn = m_pScore->load_param(m_xmlValues);
}
else {
bReturn = false;
}
}
/*
* if the scoring object was loaded, load parameters
*/
if (bReturn) {
bReturn = (m_specCondition.load(m_xmlValues));
}
/*
* if the msequenceServer object was loaded, obtain the tandem MS spectra to analyze
*/
if(bReturn) {
bReturn = spectra();
strKey = "spectrum, check all charges";
m_xmlValues.get(strKey,strValue);
if(bReturn && strValue == "yes" && (m_lThread == 0 || m_lThread == 0xFFFFFFFF)) {
charge();
cout << "#";
}
}
if(bReturn) {
bReturn = load_saps(_p);
}
if(bReturn) {
bReturn = load_annotation(_p);
}
/*
* load the msequenceutilities object in the m_pScore member class with the amino acid
* modification information
*/
if(bReturn) {
bReturn = modify();
}
return bReturn;
}
/*
* charge adds additional charge states to the vector of spectra, generating
* +1, +2 and +3 charge states
*/
bool mprocess::charge(void)
{
size_t a = 0;
size_t tLength = m_vSpectra.size();
while(a < tLength) {
if(m_vSpectra[a].m_tId > 100000000) {
return true;
}
a++;
}
a = 0;
size_t tTest = 0;
int iZ = 1;
double dProton = 1.007276;
double dMH = 0.0;
while(a < tLength) {
tTest = m_vSpectra[a].m_tId + 100000000;
iZ = (int)(m_vSpectra[a].m_fZ+0.5);
if(iZ == 2) {
m_vSpectra.push_back(m_vSpectra[a]);
m_vSpectra.back().m_fZ = 3.0;
dMH = dProton + ((m_vSpectra[a].m_dMH - dProton)/m_vSpectra[a].m_fZ);
m_vSpectra.back().m_dMH = dProton + ((dMH - dProton)*m_vSpectra.back().m_fZ);
m_vSpectra.back().m_tId = tTest;
if(m_vSpectra.back().m_dMH > 4500.0) {
m_vSpectra.pop_back();
}
m_vSpectra.push_back(m_vSpectra[a]);
m_vSpectra.back().m_fZ = 1.0;
dMH = dProton + ((m_vSpectra[a].m_dMH - dProton)/m_vSpectra[a].m_fZ);
m_vSpectra.back().m_dMH = dProton + ((dMH - dProton)*m_vSpectra.back().m_fZ);
m_vSpectra.back().m_tId = tTest + 100000000;
if(m_vSpectra.back().m_dMH > 4500.0) {
m_vSpectra.pop_back();
}
}
else if(iZ == 3) {
m_vSpectra.push_back(m_vSpectra[a]);
m_vSpectra.back().m_fZ = 2.0;
dMH = dProton + ((m_vSpectra[a].m_dMH - dProton)/m_vSpectra[a].m_fZ);
m_vSpectra.back().m_dMH = dProton + ((dMH - dProton)*m_vSpectra.back().m_fZ);
m_vSpectra.back().m_tId = tTest;
if(m_vSpectra.back().m_dMH > 4500.0) {
m_vSpectra.pop_back();
}
m_vSpectra.push_back(m_vSpectra[a]);
m_vSpectra.back().m_fZ = 1.0;
dMH = dProton + ((m_vSpectra[a].m_dMH - dProton)/m_vSpectra[a].m_fZ);
m_vSpectra.back().m_dMH = dProton + ((dMH - dProton)*m_vSpectra.back().m_fZ);
m_vSpectra.back().m_tId = tTest + 100000000;
if(m_vSpectra.back().m_dMH > 4500.0) {
m_vSpectra.pop_back();
}
}
else if(iZ == 1) {
m_vSpectra.push_back(m_vSpectra[a]);
m_vSpectra.back().m_fZ = 2.0;
dMH = dProton + ((m_vSpectra[a].m_dMH - dProton)/m_vSpectra[a].m_fZ);
m_vSpectra.back().m_dMH = dProton + ((dMH - dProton)*m_vSpectra.back().m_fZ);
m_vSpectra.back().m_tId = tTest;
if(m_vSpectra.back().m_dMH > 4500.0) {
m_vSpectra.pop_back();
}
m_vSpectra.push_back(m_vSpectra[a]);
m_vSpectra.back().m_fZ = 3.0;
dMH = dProton + ((m_vSpectra[a].m_dMH - dProton)/m_vSpectra[a].m_fZ);
m_vSpectra.back().m_dMH = dProton + ((dMH - dProton)*m_vSpectra.back().m_fZ);
m_vSpectra.back().m_tId = tTest + 100000000;
if(m_vSpectra.back().m_dMH > 4500.0) {
m_vSpectra.pop_back();
}
}
a++;
}
if(m_fMaxZ < 3) {
dMH = (double)m_fMaxMass;
dMH = dProton + ((dMH - dProton)/m_fMaxZ);
m_fMaxMass = (float)(dProton + ((dMH - dProton)*3.0));
}
return true;
}
/*
* load_best_vector loads the m_vseqBest vector with a list of sequences
* that correspond to assigned, valid peptide models. spectra that have
* produced valid models are marked as inactive, so that they are
* not reassigned the same peptides again.
*/
bool mprocess::load_best_vector(void)
{
string strKey = "refine, maximum valid expectation value";
string strValue;
m_xmlValues.get(strKey,strValue);
double dMaxExpect = 0.01;
if(strValue.size() > 0) {
dMaxExpect = atof(strValue.c_str());
}
size_t a = 0;
while(a < m_vSpectra.size()) {
m_vSpectra[a].m_hHyper.model();
m_vSpectra[a].m_hHyper.set_protein_factor(1.0);
a++;
}
a = 0;
double dExpect = 1.0;
while(a < m_vSpectra.size()) {
dExpect = (double)m_vSpectra[a].m_hHyper.expect_protein(m_pScore->hconvert(m_vSpectra[a].m_fHyper));
if(dExpect <= dMaxExpect) {
m_vSpectra[a].m_bActive = false;
}
a++;
}
return !m_vseqBest.empty();
}
/*
* mark_repeats is used to determine which models are simply repeats of each other. finding
* the same model more than once does not help with confirming the model: a stochastic match
* to the same pattern twice is actually quite likely if the pattern is repeated in
* subsequent spectra.
*/
bool mprocess::mark_repeats()
{
size_t a = 0;
size_t b = 0;
string strValue;
string strCurrent;
float fMH = 0.0;
size_t tStart = 0;
size_t tEnd = 0;
size_t tUid = 0;
size_t tUidB = 0;
size_t tStartB = 0;
size_t tEndB = 0;
size_t tLength = m_vSpectra.size();
double dBestExpect = 0.0;
SEQMAP::iterator itValue;
size_t tTics = 0;
size_t tTicLength = (size_t)((double) tLength/5.0);
while(a < tLength) {
dBestExpect = 1.0e32;
tTics++;
if(tTics >= tTicLength) {
cout << ".";
cout.flush();
tTics = 0;
}
if(!m_vSpectra[a].m_bRepeat && !m_vSpectra[a].m_vseqBest.empty()) {
tStart = m_vSpectra[a].m_vseqBest[0].m_vDomains[0].m_lS;
tEnd = m_vSpectra[a].m_vseqBest[0].m_vDomains[0].m_lE;
tUid = m_vSpectra[a].m_vseqBest[0].m_tUid;
dBestExpect = m_vSpectra[a].m_dExpect;
}
if(!m_vSpectra[a].m_bRepeat && !m_vSpectra[a].m_vseqBest.empty()) {
b = a + 1;
while(b < tLength) {
if(!m_vSpectra[b].m_bRepeat && !m_vSpectra[b].m_vseqBest.empty()) {
tStartB = m_vSpectra[b].m_vseqBest[0].m_vDomains[0].m_lS;
tEndB = m_vSpectra[b].m_vseqBest[0].m_vDomains[0].m_lE;
tUidB = m_vSpectra[b].m_vseqBest[0].m_tUid;
if(tEndB == tEnd && tStartB == tStart && tUidB == tUid) {
if(dBestExpect <= m_vSpectra[b].m_dExpect) {
m_vSpectra[b].m_bRepeat = true;
}
else {
dBestExpect = m_vSpectra[b].m_dExpect;
}
}
}
b++;
}
if(dBestExpect < m_vSpectra[a].m_dExpect) {
m_vSpectra[a].m_bRepeat = true;
}
}
a++;
}
return true;
}
/*
* merge_map adds new values to the existing m_mapSequences map.
*/
bool mprocess::merge_map(SEQMAP &_s)
{
SEQMAP::iterator itValue = _s.begin();
SEQMAP::iterator itEnd = _s.end();
while(itValue != itEnd) {
if(m_mapSequences.find(itValue->first) == m_mapSequences.end()) {
m_mapSequences.insert(*itValue);
}
itValue++;
}
return true;
}
/*
* merge_spectra takes an mspectrum vector from an external source and merges it
* with the m_vSpectra vector. this method is used to combine information obtained
* from other threads with this mprocess object
*/
bool mprocess::merge_spectra()
{
string strKey = "refine, maximum valid expectation value";
string strValue;
m_xmlValues.get(strKey,strValue);
double dMaxExpect = 0.01;
if(strValue.size() > 0) {
dMaxExpect = atof(strValue.c_str());
}
size_t a = 0;
size_t b = 0;
size_t c = 0;
{
while(a < m_vSpectra.size()) {
m_vSpectra[a].m_hHyper.model();
m_vSpectra[a].m_hHyper.set_protein_factor(1.0);
if(m_bUseHomologManagement && m_vSpectra[a].m_vseqBest.size() > 5) {
m_vSpectra[a].m_vseqBest.erase(m_vSpectra[a].m_vseqBest.begin()+5,m_vSpectra[a].m_vseqBest.end());
}
a++;
}
a = 0;
double dExpect = 1.0;
SEQMAP::iterator itValue;
while(a < m_vSpectra.size()) {
b = 0;
dExpect = (double)m_vSpectra[a].m_hHyper.expect_protein(m_pScore->hconvert(m_vSpectra[a].m_fHyper));
if(dExpect <= dMaxExpect) {
m_vSpectra[a].m_bActive = false;
while(b < m_vSpectra[a].m_vseqBest.size()) {
c = 0;
while(c < m_vseqBest.size()) {
if(m_vSpectra[a].m_vseqBest[b].m_tUid == m_vseqBest[c].m_tUid) {
break;
}
c++;
}
if(c == m_vseqBest.size()) {
m_vseqBest.push_back(m_vSpectra[a].m_vseqBest[b]);
itValue = m_mapSequences.find(m_vseqBest[c].m_tUid);
m_vseqBest[c].m_strSeq = ((*itValue).second.c_str());
m_vseqBest[c].m_vDomains.clear();
}
b++;
if(m_bUseHomologManagement && b >= 5) {
break;
}
}
}
a++;
}
}
return true;
}
bool mprocess::merge_spectra(vector &_s)
{
string strKey = "refine, maximum valid expectation value";
string strValue;
m_xmlValues.get(strKey,strValue);
double dMaxExpect = 0.01;
if(strValue.size() > 0) {
dMaxExpect = atof(strValue.c_str());
}
size_t a = 0;
size_t b = 0;
size_t c = 0;
{
while(a < _s.size()) {
_s[a].m_hHyper.model();
_s[a].m_hHyper.set_protein_factor(1.0);
if(m_bUseHomologManagement && _s[a].m_vseqBest.size() > 5) {
_s[a].m_vseqBest.erase(_s[a].m_vseqBest.begin()+5,_s[a].m_vseqBest.end());
}
a++;
}
a = 0;
double dExpect = 1.0;
SEQMAP::iterator itValue;
while(a < _s.size()) {
b = 0;
dExpect = (double)_s[a].m_hHyper.expect_protein(m_pScore->hconvert(_s[a].m_fHyper));
if(dExpect <= dMaxExpect) {
while(b < _s[a].m_vseqBest.size()) {
c = 0;
while(c < m_vseqBest.size()) {
if(_s[a].m_vseqBest[b].m_tUid == m_vseqBest[c].m_tUid) {
break;
}
c++;
}
if(c == m_vseqBest.size()) {
m_vseqBest.push_back(_s[a].m_vseqBest[b]);
itValue = m_mapSequences.find(m_vseqBest[c].m_tUid);
m_vseqBest[c].m_strSeq = ((*itValue).second.c_str());
m_vseqBest[c].m_vDomains.clear();
}
if(m_bUseHomologManagement && b >= 5) {
break;
}
b++;
}
}
a++;
}
}
return true;
}
/*
* merge_statistics updates the processing statistics with external statistics.
* this method is used to combine information obtained from other threads with
* this mprocess object
*/
bool mprocess::merge_statistics(const mprocess *_p)
{
m_tPeptideCount += _p->m_tPeptideCount;
m_tRefineInput += _p->m_tRefineInput;
m_tRefinePartial += _p->m_tRefinePartial;
m_tRefineUnanticipated += _p->m_tRefineUnanticipated;
m_tRefineNterminal += _p->m_tRefineNterminal;
m_tRefineCterminal += _p->m_tRefineCterminal;
m_tRefinePam += _p->m_tRefinePam;
return true;
}
/*
* modify checks the input parameters for known parameters that are use to modify
* a protein sequence. these parameters are stored in the m_pScore member object's
* msequenceutilities member object
*/
bool mprocess::modify()
{
string strKey = "residue, modification mass";
string strValue;
m_vstrModifications.clear();
if(m_xmlValues.get(strKey,strValue) && strValue.size() > 0) {
m_vstrModifications.push_back(strValue);
}
else {
strValue = "";
m_vstrModifications.push_back(strValue);
};
int a = 1;
char *pLine = new char[256];
sprintf(pLine,"residue, modification mass %i",(int)a);
strKey = pLine;
while(m_xmlValues.get(strKey,strValue) && strValue.size() > 0) {
m_vstrModifications.push_back(strValue);
a++;
sprintf(pLine,"residue, modification mass %i",(int)a);
strKey = pLine;
}
delete pLine;
strKey = "residue, potential modification mass";
if(m_xmlValues.get(strKey,strValue)) {
m_pScore->m_seqUtil.modify_maybe(strValue);
m_pScore->m_seqUtilAvg.modify_maybe(strValue);
}
strKey = "residue, potential modification motif";
if(m_xmlValues.get(strKey,strValue)) {
m_pScore->m_seqUtil.modify_motif(strValue);
m_pScore->m_seqUtilAvg.modify_motif(strValue);
}
strKey = "protein, N-terminal residue modification mass";
if(m_xmlValues.get(strKey,strValue)) {
m_pScore->m_seqUtil.modify_n((float)atof(strValue.c_str()));
m_pScore->m_seqUtilAvg.modify_n((float)atof(strValue.c_str()));
}
strKey = "protein, C-terminal residue modification mass";
if(m_xmlValues.get(strKey,strValue)) {
m_pScore->m_seqUtil.modify_c((float)atof(strValue.c_str()));
m_pScore->m_seqUtilAvg.modify_c((float)atof(strValue.c_str()));
}
strKey = "protein, cleavage N-terminal mass change";
if(m_xmlValues.get(strKey,strValue)) {
m_pScore->m_seqUtil.m_dCleaveN = atof(strValue.c_str());
m_pScore->m_seqUtilAvg.m_dCleaveN = atof(strValue.c_str());
}
strKey = "protein, cleavage C-terminal mass change";
if(m_xmlValues.get(strKey,strValue)) {
m_pScore->m_seqUtil.m_dCleaveC = atof(strValue.c_str());
m_pScore->m_seqUtilAvg.m_dCleaveC = atof(strValue.c_str());
}
strKey = "residue, NG deamidation";
m_xmlValues.get(strKey,strValue);
if(strValue == "yes") {
m_bCheckNg = true;
}
return true;
}
/*
* process carries out the protein identification
*/
bool mprocess::process(void)
{
if(m_vSpectra.size() < 1)
return false;
string strKey;
string strValue;
// m_pScore->set_mini(true);
#ifdef PLUGGABLE_SCORING
strKey = "scoring, pluggable scoring";
strValue = "yes";
m_xmlValues.set(strKey,strValue);
#else
strKey = "scoring, pluggable scoring";
strValue = "no";
m_xmlValues.set(strKey,strValue);
#endif
strKey = "output, path";
m_xmlValues.get(strKey,strValue);
strKey = "output path: ";
strKey += strValue;
m_prcLog.log(strKey);
strKey = "spectrum, path";
m_xmlValues.get(strKey,strValue);
strKey = "input path: ";
strKey += strValue;
m_prcLog.log(strKey);
strKey = "spectrum, skyline path";
m_xmlValues.get(strKey,strValue);
if(strValue.length() != 0) {
m_strSkyline = strValue;
m_bSkyline = true;
}
else {
m_bSkyline = false;
}
#ifndef X_P3
strKey = "protein, saps";
m_bSaps = false;
m_xmlValues.get(strKey,strValue);
if(strValue == "yes") {
m_bSaps = true;
}
#endif
strKey = "protein, homolog management";
m_xmlValues.get(strKey,strValue);
m_bUseHomologManagement = false;
if(strValue == "yes") {
m_bUseHomologManagement = true;
}
strKey = "scoring, cyclic permutation";
m_xmlValues.get(strKey,strValue);
m_bCrcCheck = false;
if(strValue == "yes") {
m_bCrcCheck = true;
}
/*
* Detect the presence of ion type parameters: default is b + y ions
*/
unsigned long lType = 0;
strKey = "scoring, include reverse";
m_xmlValues.get(strKey,strValue);
m_lReversed = -1;
m_bReversedOnly = false;
if(strValue == "yes") {
m_lReversed = 0;
}
else if(strValue == "only") {
m_bReversedOnly = true;
m_lReversed = 0;
}
strKey = "scoring, a ions";
m_xmlValues.get(strKey,strValue);
if(strValue == "yes") {
lType |= mscore::T_A;
}
strKey = "scoring, a ions";
m_xmlValues.get(strKey,strValue);
if(strValue == "yes") {
lType |= mscore::T_A;
}
strKey = "scoring, b ions";
m_xmlValues.get(strKey,strValue);
if(strValue == "yes") {
lType |= mscore::T_B;
}
strKey = "scoring, c ions";
m_xmlValues.get(strKey,strValue);
if(strValue == "yes") {
lType |= mscore::T_C;
}
strKey = "scoring, x ions";
m_xmlValues.get(strKey,strValue);
if(strValue == "yes") {
lType |= mscore::T_X;
}
strKey = "scoring, z ions";
m_xmlValues.get(strKey,strValue);
if(strValue == "yes") {
lType |= mscore::T_Z;
}
strKey = "scoring, y ions";
m_xmlValues.get(strKey,strValue);
if(strValue == "yes") {
lType |= mscore::T_Y;
}
if(lType == 0) {
lType = mscore::T_B | mscore::T_Y;
}
m_pScore->set_type(lType);
strKey = "refine, spectrum synthesis";
m_xmlValues.get(strKey,strValue);
if(strValue == "yes") {
m_pScore->m_seqUtil.synthesis(true);
}
else {
m_pScore->m_seqUtil.synthesis(false);
}
/*
* Determine how to process the parent and fragment error numbers:
* 1. absolute errors in Daltons; or
* 2. relative errors in ppm.
*/
strKey = "spectrum, parent monoisotopic mass error units";
m_xmlValues.get(strKey,strValue);
lType = 0;
m_errValues.m_bPpm = false;
if(strValue == "Daltons") {
lType |= mscore::T_PARENT_DALTONS;
m_errValues.m_bPpm = false;
}
else if(strValue == "ppm") {
lType |= mscore::T_PARENT_PPM;
m_errValues.m_bPpm = true;
}
strKey = "spectrum, fragment mass error units";
m_xmlValues.get(strKey,strValue);
if (strValue.empty()) {
// try old parameter name
strKey = "spectrum, fragment monoisotopic mass error units";
m_xmlValues.get(strKey,strValue);
}
if(strValue == "Daltons") {
lType |= mscore::T_FRAGMENT_DALTONS;
}
else if(strValue == "ppm") {
lType |= mscore::T_FRAGMENT_PPM;
}
if(lType == 0) {
lType = mscore::T_PARENT_DALTONS | mscore::T_FRAGMENT_DALTONS;
}
m_pScore->set_error(lType);
/*
* check the m_xmlValues parameters for a set of known input parameters, and
* substitute default values if they are not found
*/
strKey = "spectrum, fragment mass error";
m_xmlValues.get(strKey,strValue);
if (strValue.empty()) {
// try old parameter name
strKey = "spectrum, fragment monoisotopic mass error";
m_xmlValues.get(strKey,strValue);
}
double dErrorValue = atof(strValue.c_str());
if(dErrorValue <= 0.0)
dErrorValue = (float)0.45;
m_pScore->set_fragment_error(dErrorValue);
strKey = "spectrum, parent monoisotopic mass error plus";
m_xmlValues.get(strKey,strValue);
dErrorValue = atof(strValue.c_str());
dErrorValue = fabs(atof(strValue.c_str()));
m_errValues.m_dPlus = dErrorValue;
if(m_errValues.m_bPpm) {
if(dErrorValue < 95.0) {
m_bCrcCheck = true;
}
if(dErrorValue < 20.0) {
dErrorValue = 20.0;
}
}
else {
if(dErrorValue < 0.095) {
m_bCrcCheck = true;
}
if(dErrorValue < 0.01) {
dErrorValue = (float)0.01;
}
}
m_pScore->set_parent_error(dErrorValue,true);
strKey = "spectrum, homology error";
m_xmlValues.get(strKey,strValue);
dErrorValue = atof(strValue.c_str());
if(dErrorValue <= 0.0)
dErrorValue = 4.5;
m_pScore->set_homo_error(dErrorValue);
strKey = "spectrum, parent monoisotopic mass error minus";
m_xmlValues.get(strKey,strValue);
dErrorValue = fabs(atof(strValue.c_str()));
m_errValues.m_dMinus = -1.0*dErrorValue;
if(m_errValues.m_bPpm) {
if(dErrorValue < 95.0) {
m_bCrcCheck = true;
}
if(dErrorValue < 20.0) {
dErrorValue = 20.0;
}
}
else {
if(dErrorValue < 0.095) {
m_bCrcCheck = true;
}
if(dErrorValue < 0.01) {
dErrorValue = 0.01;
}
}
m_pScore->set_parent_error(dErrorValue,false);
strKey = "spectrum, parent monoisotopic mass isotope error";
m_xmlValues.get(strKey,strValue);
if(strValue == "yes") {
m_errValues.m_bIsotope = true;
m_pScore->set_isotope_error(true);
}
else {
m_pScore->set_isotope_error(false);
m_errValues.m_bIsotope = false;
}
strKey = "protein, cleavage N-terminal limit";
if(m_xmlValues.get(strKey,strValue)) {
if(atoi(strValue.c_str()) > 0) {
m_lStartMax = atoi(strValue.c_str());
}
}
strKey = "protein, quick acetyl";
if(m_xmlValues.get(strKey,strValue)) {
if(strValue == "no") {
m_bQuickAcetyl = false;
}
}
strKey = "protein, quick pyrolidone";
if(m_xmlValues.get(strKey,strValue)) {
if(strValue == "no") {
m_bQuickPyro = false;
}
}
strKey = "protein, stP bias";
bool bA = true;
if(m_xmlValues.get(strKey,strValue)) {
if(strValue == "no") {
bA = false;
}
}
m_pScore->set_phospho_bias(bA);
strKey = "protein, modified residue mass file";
if(m_xmlValues.get(strKey,strValue)) {
m_pScore->m_seqUtil.set_aa_file(strValue);
m_pScore->m_seqUtilAvg.set_aa_file(strValue);
}
strKey = "protein, cleavage site";
m_xmlValues.get(strKey,strValue);
m_Cleave.load(strValue);
strKey = "protein, cleavage semi";
m_xmlValues.get(strKey,strValue);
if(strValue == "yes") {
m_semiState.activate(true);
m_semiState.type(0);
}
else if(strValue == "amino") {
m_semiState.activate(true);
m_semiState.type(2);
}
else if(strValue == "carboxy") {
m_semiState.activate(true);
m_semiState.type(1);
}
strKey = "scoring, minimum ion count";
m_xmlValues.get(strKey,strValue);
m_lIonCount = (unsigned long)atoi(strValue.c_str()) - 1;
strKey = "scoring, maximum missed cleavage sites";
m_xmlValues.get(strKey,strValue);
m_tMissedCleaves = atoi(strValue.c_str());
if(m_Cleave.m_lType == 0x01 && m_tMissedCleaves < 6) {
m_tMissedCleaves = 50;
}
strKey = "spectrum, sequence batch size";
m_xmlValues.get(strKey,strValue);
size_t tBatch = atoi(strValue.c_str());
if(tBatch < 1) {
tBatch = 1000;
}
m_svrSequences.initialize(tBatch);
strKey = "protein, use annotations";
m_xmlValues.get(strKey,strValue);
m_bAnnotation = false;
m_strLastMods.clear();
m_bMinimalAnnotation = false;
if(strValue == "yes") {
m_bAnnotation = true;
}
else {
strKey = "protein, use minimal annotations";
m_xmlValues.get(strKey,strValue);
if(strValue == "no") {
m_bMinimalAnnotation = false;
m_xmlValues.set(strKey,strValue);
}
else {
m_bMinimalAnnotation = true;
strValue = "yes";
m_xmlValues.set(strKey,strValue);
}
}
size_t tLength = 0;
size_t a = 0;
m_tProteinCount = 0;
m_tPeptideCount = 0;
m_tPeptideScoredCount = 0;
strKey = "output, http";
m_xmlValues.get(strKey,strValue);
a = 0;
long lTics = 0;
/*
* record the spectrum m/z - intensity pairs into the mscore object. This
* is done here to speed up processing many spectra, as they are only
* loaded and processed once.
*/
m_tSpectra = m_vSpectra.size();
while(a < m_tSpectra) {
m_pScore->add_details(m_vSpectra[a]);
a++;
}
m_pScore->sort_details();
a =0;
while(a < m_tSpectra) {
m_pScore->add_mi(m_vSpectra[a]);
a++;
}
removeMI();
a = 0;
long b = 0;
bool bForward = true;
char pLine[32];
pLine[0] = '\0';
char cBs = 0x08;
/*
* estimate the smallest number of residues that could possibily correspond to the
* smallest parent ion in the m_vSpectra vector
*/
residues();
/*
* record the start time for the identification process.
*/
m_dSearchTime = clock();
unsigned long lServerCount = 0;
unsigned long lWaste = 0;
long lReadTime = 0;
long lTempTime = 0;
char *pOut = new char[256];
sprintf(pOut,"Spectrum-to-sequence matching process in progress");
strKey = "output, message";
m_xmlValues.get(strKey,strValue);
if(strValue.size() > 0) {
if(strValue.size() > 255) {
delete pOut;
pOut = new char[strValue.size()+1];
}
sprintf(pOut,"%s",strValue.c_str());
}
long lOut = 0;
long lOutLimit = (long)strlen(pOut);
/*
* use the msequenceServer to get a list of proteins to analyze
*/
while(!m_svrSequences.done()) {
m_svrSequences.next(true);
lServerCount++;
score_each_sequence();
/*
* this section produces the "still alive" messages that are displayed so
* that a user doesn't get anxious. this implementaion only throws messages
* from the 0th thread, and uses a character string
* to generate characters that get flushed to the console.
*/
if(m_lThread == 0 || m_lThread == 0xFFFFFFFF) {
lTics++;
if(lTics == 50) {
cout << " | " << (unsigned long)m_tProteinCount/1000 << " ks \n";
cout.flush();
m_prcLog.log(".");
lTics = 0;
}
else {
if(lTics == 1) {
cout << "\t";
}
cout << pOut[lOut];
cout.flush();
m_prcLog.log(".");
lOut++;
if(lOut >= lOutLimit) {
lOut = 0;
}
}
}
clean_sequences();
}
delete pOut;
/*
* record the total protein modelling session time
*/
m_dSearchTime = (clock() - m_dSearchTime)/(double)CLOCKS_PER_SEC;
m_vstrPaths = m_svrSequences.m_vstrPaths;
m_svrSequences.clear();
/*
* process the scoring histograms in each spectrum, so that expectation values
* can be calculated. first a survival function is calculated, replacing the
* original scoring histogram. then, the high scoring tail of the survival function
* is modeled.
* NOTE: only the hyper score histogram is used in the modelling process.
* NOTE: the protein factor is not used to weigth scores - it is present for future use
*/
return true;
}
/*
* refine controls the sequence refinement process.
*/
bool mprocess::refine(void)
{
size_t tTime = clock();
m_pScore->set_mini(false);
// Check for output path for sequences to be loaded to a bioml file
// Writing only done on the base thread
string strKey = "output, sequence path";
string strValue;
m_xmlValues.get(strKey,strValue);
if(!strValue.empty() && (m_lThread == 0 || m_lThread == 0xFFFFFFFF)) {
mbiomlreport rptCurrent;
rptCurrent.setpath(strValue);
rptCurrent.write(m_vseqBest,m_vstrPaths);
}
strKey = "refine";
m_xmlValues.get(strKey,strValue);
bool bReturn = false;
m_lStartMax = 100000000;
sort(m_vseqBest.begin(),m_vseqBest.end(),lessThanSequenceUid);
if(strValue == "yes") {
bReturn = refine_model();
tTime = clock() - tTime;
m_dRefineTime = (double)tTime/(double)(CLOCKS_PER_SEC);
}
return bReturn;
}
/*
* refine_models takes the model peptides that have been found and tries to
* find other spectra that can be described by the proteins that these models
* come from. several layers of modelling are available in the current implementation:
* 1. comparison with multiple potential modificiation
* 2. full [X]|[X] cleavage
* 3. N-terminal modifications
* 4. C-terminal modifications
*/
bool mprocess::refine_model()
{
m_pRefine = mrefinemanager::create_mrefine(m_xmlValues);
if (m_pRefine == NULL) {
cout << "Failed to create mrefine\n";
return false;
}
m_pRefine->set_mprocess(this);
m_pRefine->refine();
return true;
}
/*
* report outputs the information obtained during the process method, using
* an mreport object and the reporting parameter settings obtained from the
* input parameter list. many applications may need to customize this method.
* two customized output types are given: one which emphasizes protein sequences
* and one which emphasizes spectra.
*/
bool mprocess::insert_dups(void)
{
vector::iterator itS = m_vSpectra.begin();
SEQMAP::iterator itSeq;
MSEQMAP::iterator itDup = m_mapDups.begin();
m_tDuplicates = 0;
while(itDup != m_mapDups.end()) {
m_tDuplicates += (*itDup).second.size();
itDup++;
}
uint64_t uiCrc = 0;
size_t a = 0;
size_t tLength = 0;
map mapCrc;
map::iterator itCrc;
m_tDuplicateIds = 0;
while(itS != m_vSpectra.end()) {
if(!itS->m_vseqBest.empty()) {
tLength = itS->m_vseqBest.size();
a = 0;
while(a < tLength) {
itCrc = mapCrc.find(itS->m_vseqBest[a].m_tUid);
if(itCrc == mapCrc.end()) {
itSeq = m_mapSequences.find(itS->m_vseqBest[a].m_tUid);
uiCrc = crc((*itSeq).second);
itDup = m_mapDups.find(uiCrc);
mapCrc[itS->m_vseqBest[a].m_tUid] = uiCrc;
}
else {
itDup = m_mapDups.find((*itCrc).second);
}
if(itDup != m_mapDups.end()) {
msequence seqTemp = itS->m_vseqBest[a];
size_t b = 0;
itSeq = m_mapSequences.find(itS->m_vseqBest[a].m_tUid);
while(b < (*itDup).second.size()) {
seqTemp.m_siPath = (*itDup).second[b].m_siPath;
seqTemp.m_strDes = (*itDup).second[b].m_strDes;
seqTemp.m_tUid = (*itDup).second[b].m_tUid;
if(m_mapSequences.find(seqTemp.m_tUid) == m_mapSequences.end()) {
m_mapSequences[seqTemp.m_tUid] = (*itSeq).second;
}
seqTemp.m_bForward = (*itDup).second[b].m_bForward;
itS->m_vseqBest.push_back(seqTemp);
m_tDuplicateIds++;
b++;
}
}
a++;
}
}
itS++;
}
m_mapDups.clear();
m_mapCrc.clear();
return true;
}
bool mprocess::report(void)
{
m_prcLog.log("creating report");
vector::iterator itS = m_vSpectra.begin();
m_pScore->clear();
sort(m_vSpectra.begin(),m_vSpectra.end(),lessThanSpectrumId);
while(itS != m_vSpectra.end()) {
// if(itS->m_tId == 8313) {
// itS->m_hHyper.dump();
// itS->m_hHyper.model_dump();
// itS->m_hHyper.dump();
// }
// else
// {
itS->m_hHyper.model();
// }
itS->m_hHyper.set_protein_factor(1.0);
sort(itS->m_vseqBest.begin(),itS->m_vseqBest.end(),lessThanSequenceUid);
itS++;
}
if(m_bUseCrc) {
insert_dups();
}
size_t a = 0;
map mapSpec;
pair prSpec;
map::iterator itMap;
while(a < m_vSpectra.size()) {
prSpec.first = m_vSpectra[a].m_tId;
prSpec.second = a;
mapSpec.insert(prSpec);
if(!m_vSpectra[a].m_vseqBest.empty() && !m_vSpectra[a].m_vseqBest[0].m_vDomains.empty()) {
m_vSpectra[a].m_dExpect = m_vSpectra[a].m_hHyper.expect(m_pScore->hconvert(m_vSpectra[a].m_vseqBest[0].m_vDomains[0].m_fHyper));
// if(m_vSpectra[a].m_tId == 8313) {
// cout << "
" << m_pScore->hconvert(m_vSpectra[a].m_vseqBest[0].m_vDomains[0].m_fHyper) << ":" << m_vSpectra[a].m_hHyper.m_ulCount << ":" << m_vSpectra[a].m_dExpect << "
";
// }
}
a++;
}
size_t tTest = 0;
itS = m_vSpectra.begin();
while(itS != m_vSpectra.end()) {
if(itS->m_tId < 100000000) {
tTest = itS->m_tId + 100000000;
itMap = mapSpec.find(tTest);
if(itMap != mapSpec.end()) {
a = itMap->second;
if(itS->m_dExpect <= m_vSpectra[a].m_dExpect) {
m_vSpectra[a].m_dExpect = 1000;
m_vSpectra[a].m_fScore = 0.0;
mapSpec.erase(tTest);
tTest = tTest + 100000000;
itMap = mapSpec.find(tTest);
if(itMap != mapSpec.end()) {
a = itMap->second;
if(itS->m_dExpect <= m_vSpectra[a].m_dExpect) {
m_vSpectra[a].m_dExpect = 1000;
m_vSpectra[a].m_fScore = 0.0;
mapSpec.erase(tTest);
}
else {
itS->m_dExpect = 1000;
itS->m_fScore = 0.0;
mapSpec.erase(tTest);
}
}
}
else {
itS->m_dExpect = 1000;
itS->m_fScore = 0.0;
mapSpec.erase(tTest);
tTest = tTest + 100000000;
itMap = mapSpec.find(tTest);
if(itMap != mapSpec.end()) {
size_t b = itMap->second;
if(m_vSpectra[a].m_dExpect <= m_vSpectra[b].m_dExpect) {
m_vSpectra[b].m_dExpect = 1000;
m_vSpectra[b].m_fScore = 0.0;
mapSpec.erase(tTest);
}
else {
m_vSpectra[a].m_dExpect = 1000;
m_vSpectra[a].m_fScore = 0.0;
mapSpec.erase(tTest);
}
}
}
}
}
itS++;
}
mapSpec.clear();
a = 0;
itS = m_vSpectra.begin();
m_viQuality.clear();
while(a < 255) {
m_viQuality.push_back(0);
a++;
}
a = 0;
int iIndex;
int iQ = 0;
vector vRoundCount;
a = 0;
size_t tMaxRounds = 128;
while(a < tMaxRounds) {
vRoundCount.push_back(0);
a++;
}
a = 0;
size_t r = 0;
while(itS != m_vSpectra.end()) {
a = 0;
if(itS->m_fScore > 0.0 && itS->m_dExpect < 1.0) {
iIndex = int(-1.0*log(itS->m_dExpect));
if(iIndex >= 0 && iIndex < 255) {
m_viQuality[iIndex]++;
iQ++;
}
}
while(a < itS->m_vMINeutral.size()) {
itS->m_vMI.push_back(itS->m_vMINeutral[a]);
a++;
}
if(a > 0) {
sort(itS->m_vMI.begin(),itS->m_vMI.end(),lessThanMass);
}
a = 0;
while(a < itS->m_vseqBest.size()) {
r = itS->m_vseqBest[a].m_iRound;
if(r < tMaxRounds) {
vRoundCount[r] = vRoundCount[r] + 1;
}
a++;
}
itS++;
}
m_tRefinePartial = vRoundCount[2];
m_tRefineUnanticipated = vRoundCount[3];
m_tRefineNterminal = vRoundCount[4];
m_tRefineCterminal = vRoundCount[5];
m_tRefinePam = vRoundCount[6];
char *pLine = new char[256];
string strKey = "quality values";
string strValue;
a = 0;
while(a < 20) {
if(a != 0) {
strValue += " ";
}
sprintf(pLine,"%i",(int)m_viQuality[a]);
strValue += pLine;
a++;
}
m_xmlPerformance.set(strKey,strValue);
/*
* store information in the m_smlPerformance object for reporting
*/
strKey = "timing, initial modelling total (sec)";
sprintf(pLine,"%.2lf",m_dSearchTime);
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
strKey = "timing, initial modelling/spectrum (sec)";
sprintf(pLine,"%.4lf",m_dSearchTime/(double)m_tSpectraTotal);
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
strKey = "timing, load sequence models (sec)";
sprintf(pLine,"%.2lf",m_svrSequences.get_time());
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
strKey = "modelling, total spectra used";
sprintf(pLine,"%lu",(unsigned long)m_tSpectraTotal);
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
strKey = "modelling, total proteins used";
sprintf(pLine,"%lu",(unsigned long)m_tProteinCount);
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
if(m_bUseCrc) {
strKey = "modelling, duplicate proteins";
sprintf(pLine,"%lu",(unsigned long)m_tDuplicates);
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
strKey = "modelling, duplicate peptide ids";
sprintf(pLine,"%lu",(unsigned long)m_tDuplicateIds);
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
}
strKey = "modelling, total peptides used";
sprintf(pLine,"%lu",(unsigned long)m_tPeptideCount);
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
if(m_specCondition.get_noise_suppression()) {
strKey = "modelling, spectrum noise suppression ratio";
sprintf(pLine,"%.2lf",(double)(m_tSpectraTotal - m_vSpectra.size())/(double)m_tSpectraTotal);
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
}
size_t tSeq = 0;
while(tSeq < m_svrSequences.m_vstrFasta.size()) {
sprintf(pLine,"list path, sequence source #%i",(int)(tSeq+1));
strKey = pLine;
strValue = m_svrSequences.m_vstrFasta[tSeq];
m_xmlPerformance.set(strKey,strValue);
if(tSeq < m_svrSequences.m_vstrDesc.size()) {
sprintf(pLine,"list path, sequence source description #%i",(int)(tSeq+1));
strKey = pLine;
strValue = m_svrSequences.m_vstrDesc[tSeq];
m_xmlPerformance.set(strKey,strValue);
}
tSeq++;
}
tSeq = 0;
while(tSeq < m_vstrSaps.size()) {
sprintf(pLine,"list path, saps source #%i",(int)(tSeq+1));
strKey = pLine;
strValue = m_vstrSaps[tSeq];
m_xmlPerformance.set(strKey,strValue);
tSeq++;
}
tSeq = 0;
while(tSeq < m_vstrMods.size()) {
sprintf(pLine,"list path, mods source #%i",(int)(tSeq+1));
strKey = pLine;
strValue = m_vstrMods[tSeq];
m_xmlPerformance.set(strKey,strValue);
tSeq++;
}
strKey = "output, maximum valid expectation value";
m_xmlValues.get(strKey,strValue);
double dMaxExpect = 0.01;
if(strValue.size() > 0) {
dMaxExpect = atof(strValue.c_str());
}
m_dThreshold = dMaxExpect;
strKey = "refining, # input models";
sprintf(pLine,"%u",(unsigned int)m_tRefineModels);
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
strKey = "refining, # input spectra";
sprintf(pLine,"%u",(unsigned int)(m_tRefineInput));
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
strKey = "refining, # partial cleavage";
sprintf(pLine,"%u",(unsigned int)(m_tRefinePartial));
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
strKey = "refining, # unanticipated cleavage";
sprintf(pLine,"%u",(unsigned int)(m_tRefineUnanticipated));
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
strKey = "refining, # potential N-terminii";
sprintf(pLine,"%u",(unsigned int)(m_tRefineNterminal));
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
strKey = "refining, # potential C-terminii";
sprintf(pLine,"%u",(unsigned int)(m_tRefineCterminal));
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
strKey = "refining, # point mutations";
sprintf(pLine,"%u",(unsigned int)(m_tRefinePam));
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
strKey = "timing, refinement/spectrum (sec)";
sprintf(pLine,"%.4lf",m_dRefineTime/(double)m_vSpectra.size());
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
strKey = "spectrum, use contrast angle";
m_xmlValues.get(strKey,strValue);
if(strValue == "yes") {
strKey = "modelling, contrast angle rejection ratio";
sprintf(pLine,"%.2lf",(double)m_tContrasted/((double)m_vSpectra.size()+(double)m_tContrasted));
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
}
/*
* calculate the expectation values for the proteins
*/
m_prcLog.log("calculating expectation values");
report_expect(dMaxExpect);
/*
* now, using the expectation values for the proteins, sort the results into proteins or spectra
*/
m_prcLog.log("sorting peptides");
report_sort();
/*
* using the retrieved values, create an mreport and use it to create the output
*/
dMaxExpect = log10(dMaxExpect);
strKey = "output, results";
m_xmlValues.get(strKey,strValue);
string strResults = strValue;
cout << "\twriting results ";
cout.flush();
m_prcLog.log("writing results");
restore();
m_dEsum = 0.0;
if(strResults != "all" && strResults != "valid" && strResults != "stochastic")
strResults = "valid";
if(strResults == "all") {
report_all();
}
else if(strResults == "valid") {
report_valid(dMaxExpect);
}
else if(strResults == "stochastic") {
report_stochastic(dMaxExpect);
}
cout << "..... done.\n";
cout.flush();
m_prcLog.log("report complete");
delete pLine;
return false;
}
bool mprocess::report_all()
{
/*
* check the input parameters for known output information
*/
string strKey = "output, histogram column width";
string strValue;
m_xmlValues.get(strKey,strValue);
long lHistogramColumns = 30;
if(atoi(strValue.c_str()) > 0)
lHistogramColumns = atoi(strValue.c_str());
strKey = "output, spectra";
m_xmlValues.get(strKey,strValue);
bool bSpectra = false;
if(strValue == "yes")
bSpectra = true;
strKey = "output, histograms";
m_xmlValues.get(strKey,strValue);
bool bHistograms = false;
if(strValue == "yes")
bHistograms = true;
strKey = "output, sequences";
m_xmlValues.get(strKey,strValue);
bool bSequences = false;
if(strValue == "yes")
bSequences = true;
strKey = "output, proteins";
m_xmlValues.get(strKey,strValue);
bool bProteins = false;
if(strValue == "yes")
bProteins = true;
strKey = "output, parameters";
m_xmlValues.get(strKey,strValue);
bool bInput = false;
if(strValue == "yes")
bInput = true;
strKey = "output, performance";
m_xmlValues.get(strKey,strValue);
bool bPerf = false;
if(strValue == "yes")
bPerf = true;
strKey = "output, one sequence copy";
m_xmlValues.get(strKey,strValue);
bool bCompress = false;
if(strValue == "yes")
bCompress = true;
mreport rptValue(*m_pScore);
rptValue.set_compression(bCompress);
rptValue.set_columns(lHistogramColumns);
rptValue.start(m_xmlValues);
size_t a = 0;
size_t tLength = m_vSpectra.size();
size_t b = 0;
SEQMAP::iterator itValue;
map ::iterator itMod;
string strMods;
strKey = "spectrum, path";
m_xmlValues.get(strKey,strValue);
string strPath = strValue;
string strSky = "";
size_t tPos = 0;
size_t tEnd = 0;
while(a < tLength) {
b = 0;
if(!m_vSpectra[a].m_vseqBest.empty() && !m_vSpectra[a].m_vseqBest[0].m_vDomains.empty()) {
m_dEsum += m_vSpectra[a].m_hHyper.expect(m_pScore->hconvert(m_vSpectra[a].m_vseqBest[0].m_vDomains[0].m_fHyper));
while(b < m_vSpectra[a].m_vseqBest.size()) {
itValue = m_mapSequences.find(m_vSpectra[a].m_vseqBest[b].m_tUid);
m_vSpectra[a].m_vseqBest[b].m_strSeq = (*itValue).second;
b++;
}
if(!m_bSkyline) {
strSky = "";
}
else {
if(m_strSkyline == "1") {
tPos = m_vSpectra[a].m_strDescription.find("|source=");
if(tPos != m_vSpectra[a].m_strDescription.npos) {
tPos += strlen("|source=");
tEnd = m_vSpectra[a].m_strDescription.find("|",tPos);
if(tEnd != m_vSpectra[a].m_strDescription.npos) {
strSky = m_vSpectra[a].m_strDescription.substr(tPos,tEnd-tPos);
}
else {
strSky = strPath;
}
}
else {
strSky = strPath;
}
}
else {
strSky = m_strSkyline;
}
}
if(bSpectra || bHistograms || bProteins)
rptValue.group(m_vSpectra[a]);
if(bProteins) {
rptValue.sequence(m_vSpectra[a],bSequences,m_vstrPaths,m_mapAnnotation);
}
if(bHistograms)
rptValue.histogram(m_vSpectra[a]);
if(bSpectra)
rptValue.spectrum(m_vSpectra[a],strSky);
if(bSpectra || bHistograms || bProteins)
rptValue.endgroup();
}
m_vSpectra[a].m_vseqBest.clear();
a++;
}
if(bInput)
rptValue.info(m_xmlValues);
if(bPerf)
rptValue.performance(m_xmlPerformance);
//CONSIDER(bmaclean): Report average masses too, if using average for fragments?
if(m_pScore->m_pSeqUtilFrag->is_modified()) {
rptValue.masses(*(m_pScore->m_pSeqUtilFrag));
}
return rptValue.end();
}
bool mprocess::report_valid(const double _d)
{
/*
* check the input parameters for known output information
*/
string strKey = "output, histogram column width";
string strValue;
m_xmlValues.get(strKey,strValue);
long lHistogramColumns = 30;
if(atoi(strValue.c_str()) > 0)
lHistogramColumns = atoi(strValue.c_str());
strKey = "output, spectra";
m_xmlValues.get(strKey,strValue);
bool bSpectra = false;
if(strValue == "yes")
bSpectra = true;
strKey = "output, histograms";
m_xmlValues.get(strKey,strValue);
bool bHistograms = false;
if(strValue == "yes")
bHistograms = true;
strKey = "output, sequences";
m_xmlValues.get(strKey,strValue);
bool bSequences = false;
if(strValue == "yes")
bSequences = true;
strKey = "output, proteins";
m_xmlValues.get(strKey,strValue);
bool bProteins = false;
if(strValue == "yes")
bProteins = true;
strKey = "output, parameters";
m_xmlValues.get(strKey,strValue);
bool bInput = false;
if(strValue == "yes")
bInput = true;
strKey = "output, performance";
m_xmlValues.get(strKey,strValue);
bool bPerf = false;
if(strValue == "yes")
bPerf = true;
strKey = "output, one sequence copy";
m_xmlValues.get(strKey,strValue);
bool bCompress = false;
if(strValue == "yes")
bCompress = true;
mreport rptValue(*m_pScore);
rptValue.set_compression(bCompress);
rptValue.set_columns(lHistogramColumns);
rptValue.start(m_xmlValues);
size_t a = 0;
size_t tLength = m_vSpectra.size();
size_t tActive = 0;
double dValue = 0.0;
size_t b = 0;
size_t c = 0;
SEQMAP::iterator itValue;
m_tValid = 0;
m_tUnique = 1;
size_t tLast = 0;
double dProteinMax = pow(10,_d);
strKey = "output, maximum valid protein expectation value";
m_xmlValues.get(strKey,strValue);
if(strValue.size() > 0) {
dProteinMax = atof(strValue.c_str());
}
dProteinMax = log10(dProteinMax);
double dProtein = 0.0;
strKey = "spectrum, path";
m_xmlValues.get(strKey,strValue);
string strPath = strValue;
string strSky = "";
size_t tPos = 0;
size_t tEnd = 0;
set setUnique;
string strPeptide;
while(a < tLength) {
dValue = 3.0;
size_t c = 0;
if(m_vSpectra[a].m_fScore > 0.0 && !m_vSpectra[a].m_vseqBest.empty() && !m_vSpectra[a].m_vseqBest[0].m_vDomains.empty()) {
dValue = m_vSpectra[a].m_hHyper.expect(m_pScore->hconvert(m_vSpectra[a].m_vseqBest[0].m_vDomains[0].m_fHyper));
dProtein = m_vSpectra[a].m_dProteinExpect;
if(log10(dValue) <= _d && dProtein <= dProteinMax) {
m_dEsum += dValue;
}
dValue = log10(dValue);
}
if(!m_vSpectra[a].m_vseqBest.empty() && !m_vSpectra[a].m_vseqBest[0].m_vDomains.empty() && dValue <= _d && dProtein <= dProteinMax) {
b = 0;
while(b < m_vSpectra[a].m_vseqBest.size()) {
itValue = m_mapSequences.find(m_vSpectra[a].m_vseqBest[b].m_tUid);
m_vSpectra[a].m_vseqBest[b].m_strSeq = (*itValue).second;
b++;
}
if(m_lReversed != -1 && !m_vSpectra[a].m_vseqBest[0].m_bForward) {
m_lReversed++;
}
b = 0;
while(b < m_vSpectra[a].m_vseqBest.size()) {
c = 0;
while(c < m_vSpectra[a].m_vseqBest[b].m_vDomains.size()) {
tPos = m_vSpectra[a].m_vseqBest[b].m_vDomains[c].m_lS;
tEnd = m_vSpectra[a].m_vseqBest[b].m_vDomains[c].m_lE;
strPeptide = m_vSpectra[a].m_vseqBest[b].m_strSeq.substr(tPos,tEnd-tPos+1);
if(setUnique.find(strPeptide) == setUnique.end()) {
setUnique.insert(strPeptide);
}
c++;
}
b++;
}
if(!m_bSkyline) {
strSky = "";
}
else {
if(m_strSkyline == "1") {
tPos = m_vSpectra[a].m_strDescription.find("|source=");
if(tPos != m_vSpectra[a].m_strDescription.npos) {
tPos += strlen("|source=");
tEnd = m_vSpectra[a].m_strDescription.find("|",tPos);
if(tEnd != m_vSpectra[a].m_strDescription.npos) {
strSky = m_vSpectra[a].m_strDescription.substr(tPos,tEnd-tPos);
}
else {
strSky = strPath;
}
}
else {
strSky = strPath;
}
}
else {
strSky = m_strSkyline;
}
}
m_tValid++;
tActive++;
if(bSpectra || bHistograms || bProteins)
rptValue.group(m_vSpectra[a]);
if(bProteins)
rptValue.sequence(m_vSpectra[a],bSequences,m_vstrPaths,m_mapAnnotation);
if(bHistograms)
rptValue.histogram(m_vSpectra[a]);
if(bSpectra)
rptValue.spectrum(m_vSpectra[a],strSky);
if(bSpectra || bHistograms || bProteins)
rptValue.endgroup();
}
a++;
}
m_tUnique = setUnique.size();
if(m_tValid == 0) {
m_tUnique = 0;
}
strKey = "modelling, total spectra assigned";
char *pLine = new char[256];
sprintf(pLine,"%u",(unsigned int)m_tValid);
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
strKey = "modelling, total unique assigned";
sprintf(pLine,"%u",(unsigned int)m_tUnique);
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
if(m_lReversed != -1) {
strKey = "modelling, reversed sequence false positives";
sprintf(pLine,"%i",(int)m_lReversed);
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
}
unsigned long lE = (unsigned long)(0.5+m_dEsum);
unsigned long lEe = (unsigned long)(0.5 + sqrt(m_dEsum));
if(lEe == 0) {
lEe = 1;
}
strKey = "modelling, estimated false positives";
sprintf(pLine,"%u",(unsigned int)lE);
strValue = pLine;
m_xmlPerformance.set(strKey,strValue);
if(bInput)
rptValue.info(m_xmlValues);
if(bPerf)
rptValue.performance(m_xmlPerformance);
//TODO(bmaclean): Report average masses too, if using average for fragments?
if(m_pScore->m_pSeqUtilFrag->is_modified()) {
rptValue.masses(*(m_pScore->m_pSeqUtilFrag));
}
delete pLine;
return rptValue.end();
}
bool mprocess::report_stochastic(const double _d)
{
/*
* check the input parameters for known output information
*/
string strKey = "output, histogram column width";
string strValue;
m_xmlValues.get(strKey,strValue);
long lHistogramColumns = 30;
if(atoi(strValue.c_str()) > 0)
lHistogramColumns = atoi(strValue.c_str());
strKey = "output, spectra";
m_xmlValues.get(strKey,strValue);
bool bSpectra = false;
if(strValue == "yes")
bSpectra = true;
strKey = "output, histograms";
m_xmlValues.get(strKey,strValue);
bool bHistograms = false;
if(strValue == "yes")
bHistograms = true;
strKey = "output, sequences";
m_xmlValues.get(strKey,strValue);
bool bSequences = false;
if(strValue == "yes")
bSequences = true;
strKey = "output, proteins";
m_xmlValues.get(strKey,strValue);
bool bProteins = false;
if(strValue == "yes")
bProteins = true;
strKey = "output, parameters";
m_xmlValues.get(strKey,strValue);
bool bInput = false;
if(strValue == "yes")
bInput = true;
strKey = "output, performance";
m_xmlValues.get(strKey,strValue);
bool bPerf = false;
if(strValue == "yes")
bPerf = true;
strKey = "output, one sequence copy";
m_xmlValues.get(strKey,strValue);
bool bCompress = false;
if(strValue == "yes")
bCompress = true;
mreport rptValue(*m_pScore);
rptValue.set_compression(bCompress);
rptValue.set_columns(lHistogramColumns);
rptValue.start(m_xmlValues);
size_t a = 0;
size_t b = 0;
SEQMAP::iterator itValue;
size_t tLength = m_vSpectra.size();
double dValue = 0.0;
strKey = "spectrum, path";
m_xmlValues.get(strKey,strValue);
string strPath = strValue;
string strSky = "";
size_t tPos = 0;
size_t tEnd = 0;
while(a < tLength) {
dValue = 3.0;
if(!m_vSpectra[a].m_vseqBest.empty() && !m_vSpectra[a].m_vseqBest[0].m_vDomains.empty()) {
dValue = m_vSpectra[a].m_hHyper.expect(m_pScore->hconvert(m_vSpectra[a].m_vseqBest[0].m_vDomains[0].m_fHyper));
if(log10(dValue) > _d) {
m_dEsum += dValue;
}
dValue = log10(dValue);
}
if(m_vSpectra[a].m_vseqBest.empty() || dValue > _d) {
b = 0;
if(!m_bSkyline) {
strSky = "";
}
else {
if(m_strSkyline == "1") {
tPos = m_vSpectra[a].m_strDescription.find("|source=");
if(tPos != m_vSpectra[a].m_strDescription.npos) {
tPos += strlen("|source=");
tEnd = m_vSpectra[a].m_strDescription.find("|",tPos);
if(tEnd != m_vSpectra[a].m_strDescription.npos) {
strSky = m_vSpectra[a].m_strDescription.substr(tPos,tEnd-tPos);
}
else {
strSky = strPath;
}
}
else {
strSky = strPath;
}
}
else {
strSky = m_strSkyline;
}
}
while(b < m_vSpectra[a].m_vseqBest.size()) {
itValue = m_mapSequences.find(m_vSpectra[a].m_vseqBest[b].m_tUid);
m_vSpectra[a].m_vseqBest[b].m_strSeq = (*itValue).second;
b++;
}
if(bSpectra || bHistograms || bProteins)
rptValue.group(m_vSpectra[a]);
if(bProteins)
rptValue.sequence(m_vSpectra[a],bSequences,m_vstrPaths,m_mapAnnotation);
if(bHistograms)
rptValue.histogram(m_vSpectra[a]);
if(bSpectra)
rptValue.spectrum(m_vSpectra[a],strSky);
if(bSpectra || bHistograms || bProteins)
rptValue.endgroup();
}
m_vSpectra[a].m_vseqBest.clear();
a++;
}
if(bInput)
rptValue.info(m_xmlValues);
if(bPerf)
rptValue.performance(m_xmlPerformance);
//TODO(bmaclean): Report average masses too, if using average for fragments?
if(m_pScore->m_pSeqUtilFrag->is_modified() ) {
rptValue.masses(*(m_pScore->m_pSeqUtilFrag));
}
return rptValue.end();
}
/*
* report_expect calculates the expectation value for proteins
*/
bool mprocess::report_expect(const double _m)
{
cout << "\tinitial calculations ";
cout.flush();
size_t tLength = m_vSpectra.size();
unsigned long a = 0;
m_tValid = 0;
unsigned long b = 0;
size_t tMaxUid = 0;
SEQMAP::iterator itMap = m_mapSequences.begin();
while(itMap != m_mapSequences.end()) {
if(itMap->first > tMaxUid) {
tMaxUid = itMap->first;
}
itMap++;
}
tMaxUid += 10;
double *pdExpect = new double[tMaxUid];
unsigned long *plCount = new unsigned long[tMaxUid];
const double dConstant = 2.0e32;
while(a < tMaxUid) {
pdExpect[a] = dConstant;
plCount[a] = 0;
a++;
}
double dExpect = 0.0;
double dSum = 0;
a = 0;
while(a < tLength) {
dExpect = (double)m_vSpectra[a].m_hHyper.expect_protein(m_pScore->hconvert(m_vSpectra[a].m_fHyper));
dSum += m_vSpectra[a].m_hHyper.sum();
if(dExpect <= _m) {
m_tValid++;
}
m_vSpectra[a].m_dExpect = dExpect;
m_vSpectra[a].m_dProteinExpect = log10(dExpect);
a++;
}
vector::iterator itStart = m_vSpectra.begin();
cout << " ..... done.\n\tsorting ";
cout.flush();
string strKey = "output, results";
string strValue;
m_xmlValues.get(strKey,strValue);
if(strValue == "valid") {
sort(m_vSpectra.begin(),m_vSpectra.end(),lessThanSpectrum);
while(itStart != m_vSpectra.end() && itStart->m_dExpect <= 0.95*_m) {
itStart++;
}
if(itStart != m_vSpectra.end()) {
m_vSpectra.erase(itStart,m_vSpectra.end());
}
}
strKey = "output, sort best scores by";
m_xmlValues.get(strKey,strValue);
bool bSortScores = (strValue != "sequence");
unsigned long lSum = (unsigned long)(0.5+dSum/(double)tLength);
cout << " ..... done.\n\tfinding repeats ";
cout.flush();
mark_repeats();
cout << " done.\n\tevaluating results ";
cout.flush();
a = 0;
tLength = m_vSpectra.size();
size_t tUid;
size_t tBest;
size_t tTicLength = (size_t)((double)tLength/5.0);
size_t tTics = 0;
vector::iterator itDom;
vector::iterator itDomEnd;
bool bRound = false;
while(a < tLength) {
tTics++;
if(tTics >= tTicLength) {
cout << ".";
cout.flush();
tTics = 0;
}
dExpect = log10(m_vSpectra[a].m_dExpect);
b = 0;
tBest = m_vSpectra[a].m_vseqBest.size();
while(b < tBest) {
tUid = m_vSpectra[a].m_vseqBest[b].m_tUid;
bRound = false;
if(m_vSpectra[a].m_vseqBest[b].m_iRound < 10 || m_lReversed != -1) {
bRound = true;
m_setRound.insert(tUid);
}
if(!m_vSpectra[a].m_bRepeat && dExpect <= -1.0) {
if(pdExpect[tUid] != dConstant) {
if(bRound) {
plCount[tUid]++;
}
pdExpect[tUid] += dExpect;
}
else if(bRound) {
plCount[tUid] = 1;
if(dExpect <= -1.0) {
pdExpect[tUid] = dExpect;
}
else {
pdExpect[tUid] = 0.0;
}
}
}
b++;
}
a++;
}
a = 0;
vector::iterator itSeq;
double dBias = (double)m_tPeptideCount/(double)m_tProteinCount;
dBias /= (double)m_tTotalResidues/(double)m_tProteinCount;
SEQMAP::iterator itValue;
cout << " done.\n\tcalculating expectations ";
cout.flush();
tTics = 0;
map mapExpect;
pair pairExpect;
set::iterator itRound = m_setRound.end();
while(a < tLength) {
b = 0;
tTics++;
if(tTics >= tTicLength) {
cout << ".";
cout.flush();
tTics = 0;
}
itSeq = m_vSpectra[a].m_vseqBest.begin();
while(itSeq != m_vSpectra[a].m_vseqBest.end()) {
tUid = itSeq->m_tUid;
if(m_setRound.find(tUid) != itRound) {
if(pdExpect[tUid] != dConstant) {
if(mapExpect.find(tUid) == mapExpect.end()) {
itSeq->m_dExpect = expect_protein(plCount[tUid],
(unsigned long)tLength,lSum,
pdExpect[tUid]);
pairExpect.first = tUid;
pairExpect.second = itSeq->m_dExpect;
mapExpect.insert(pairExpect);
}
else {
itSeq->m_dExpect = mapExpect.find(tUid)->second;
}
}
else {
itSeq->m_dExpect = 0.0;
}
if(plCount[tUid] > 1) {
itValue= m_mapSequences.find(tUid);
if((*itValue).second.size()*dBias < 1.0) {
itSeq->m_dExpect += plCount[tUid]*log10((*itValue).second.size()*dBias);
}
}
itSeq++;
}
else {
itSeq = m_vSpectra[a].m_vseqBest.erase(itSeq);
}
}
if(!m_vSpectra[a].m_vseqBest.empty()) {
if(bSortScores) {
sort(m_vSpectra[a].m_vseqBest.begin(),m_vSpectra[a].m_vseqBest.end(),lessThanSequence);
}
vector::iterator itA = m_vSpectra[a].m_vseqBest.begin();
vector::iterator itB = m_vSpectra[a].m_vseqBest.begin();
while(itA != m_vSpectra[a].m_vseqBest.end()) {
itB++;
if(itB == m_vSpectra[a].m_vseqBest.end() || itB->m_dExpect != itA->m_dExpect) {
sort(itA,itB,lessThanSequenceUid);
itA = itB;
}
}
m_vSpectra[a].m_dProteinExpect = m_vSpectra[a].m_vseqBest[0].m_dExpect;
}
a++;
}
a = 0;
b = 0;
while(a < tMaxUid) {
pdExpect[a] = dConstant;
a++;
}
a = 0;
while(a < tLength) {
b = 0;
tBest = m_vSpectra[a].m_vseqBest.size();
while(b < tBest) {
tUid = m_vSpectra[a].m_vseqBest[b].m_tUid;
if(pdExpect[tUid] == dConstant) {
pdExpect[tUid] = m_vSpectra[a].m_vdStats[0];
}
else {
pdExpect[tUid] += m_vSpectra[a].m_vdStats[0];
}
b++;
}
a++;
}
a = 0;
b = 0;
while(a < tLength) {
b = 0;
tBest = m_vSpectra[a].m_vseqBest.size();
while(b < tBest) {
m_vSpectra[a].m_vseqBest[b].m_fIntensity = (float)(pdExpect[m_vSpectra[a].m_vseqBest[b].m_tUid]);
b++;
}
a++;
}
a = 0;
cout << " done.\n";
cout.flush();
delete plCount;
delete pdExpect;
return true;
}
/*
* report_sort contains the logic for sorting the output results, if sorting
* is desired.
*/
bool mprocess::report_sort()
{
string strKey = "output, sort results by";
string strValue;
m_xmlValues.get(strKey,strValue);
vector::iterator itSeq;
vector::iterator itSort;
if(strValue == "protein") {
sort(m_vSpectra.begin(),m_vSpectra.end(),lessThanSpectrum);
vector::iterator itStart = m_vSpectra.begin();
vector::iterator itEnd = itStart;
while(itStart != m_vSpectra.end() && itEnd != m_vSpectra.end()) {
while(itStart != m_vSpectra.end() && itStart->m_vseqBest.empty())
itStart++;
if(itStart == m_vSpectra.end())
break;
itEnd = itStart + 1;
while(itEnd != m_vSpectra.end()) {
if(!itEnd->m_vseqBest.empty()) {
if(itStart->m_vseqBest[0].m_tUid == itEnd->m_vseqBest[0].m_tUid) {
itEnd++;
}
else {
break;
}
}
else {
break;
}
}
if(itEnd != itStart + 1) {
sort(itStart,itEnd,lessThanOrder);
}
itStart = itEnd;
}
}
else
{
sort(m_vSpectra.begin(),m_vSpectra.end(),lessThanSpectrumId);
vector::iterator itStart = m_vSpectra.begin();
vector::iterator itEnd = itStart;
while(itStart != m_vSpectra.end() && itEnd != m_vSpectra.end()) {
while(itStart != m_vSpectra.end() && itStart->m_vseqBest.empty())
itStart++;
if(itStart == m_vSpectra.end())
break;
itEnd = itStart + 1;
while(itEnd != m_vSpectra.end()) {
if(!itEnd->m_vseqBest.empty()) {
if(itStart->m_vseqBest[0].m_tUid == itEnd->m_vseqBest[0].m_tUid) {
itEnd++;
}
else {
break;
}
}
else {
break;
}
}
if(itEnd != itStart + 1) {
sort(itStart,itEnd,lessThanOrder);
}
itStart = itEnd;
}
}
return true;
}
/*
* residues is used to estimate the minimum number of residues that are required for a peptide
* to match the lowest mass spectrum in the m_Spectra vector. this estimate is made to
* improve performance, by simply rejecting very small sequences from consideration by the
* calculationally intensive scoring routines.
*/
bool mprocess::residues()
{
/*
* make a very conservative estimate of the minimum number of residues
* As of version 2004.03.01, the more complex version of this function has been
* altered to return simply a constant value. The older method of estimating
* the minimum number of residues was found to fail badly when there were
* large moeities added as modifications to the peptide sequences.
*/
m_tMinResidues = 5;
return true;
}
/*
* rollback is a method that is used to reverse changes that have been made to the
* m_vSpectra vector during the refinement process. If a new result, discovered during
* the refinement process, is not sufficiently significant (as determined by _f), then
* the m_vSpectra entry is "rolled back" to the value it had after the initial
* survey round.
*/
bool mprocess::rollback(vector& _v,const double _m,const double _f)
{
if(_v.empty()) {
return false;
}
size_t a = 0;
const size_t tSize = m_vSpectra.size();
double dExpect = 1.0;
double dExpectLast = 1.0;
bool bDone = false;
while(a < tSize) {
if(!m_vSpectra[a].m_vseqBest.empty() && !_v[a].m_vseqBest.empty()) {
bDone = false;
m_vSpectra[a].m_hHyper.model();
m_vSpectra[a].m_hHyper.set_protein_factor(1.0);
dExpect = (double)m_vSpectra[a].m_hHyper.expect_protein(m_pScore->hconvert(m_vSpectra[a].m_fHyper));
dExpectLast = (double)m_vSpectra[a].m_hHyper.expect_protein(m_pScore->hconvert(_v[a].m_fHyper));
if(dExpect > _m) {
m_vSpectra[a] *= _v[a];
bDone = true;
}
else if(dExpect <= _m && dExpect/dExpectLast > _f) {
m_vSpectra[a] *= _v[a];
bDone = true;
}
else if(!bDone && m_vSpectra[a].m_fHyper == _v[a].m_fHyper) {
m_vSpectra[a] *= _v[a];
}
}
a++;
}
_v.clear();
return true;
}
/*
* score takes an msequence object and sequentially creates all possible cleavage peptides
* from that msequence. each peptide is then tested and scored.
*/
bool mprocess::score(const msequence &_s)
{
/* Use CRC mechanism to remove identical protein sequences
* - this can be surprisingly effective at improving performance
* - uncomment the items in this segment to test CRC function for accuracy with
* specific protein sequences.
*/
if(m_bUseCrc && m_iCurrentRound == 1) {
// m_mapTest[_s.m_tUid] = _s.m_strSeq;
uint64_t uiCRC = crc(_s.m_strSeq);
if(m_mapCrc.find(uiCRC) == m_mapCrc.end()) {
m_mapCrc[uiCRC] = _s.m_tUid;
}
else {
if(m_lThread == 0 || m_lThread == 0xFFFFFFFF) {
// SEQMAP::iterator itSeq = m_mapTest.find(m_mapCrc[uiCRC]);
// if(_s.m_strSeq != itSeq->second) {
// cout << "crc test failed\n";
// }
msequence mSeq = _s;
mSeq.m_strSeq.clear();
m_mapDups[uiCRC].push_back(mSeq);
}
return true;
}
}
size_t m = 0;
string strValue;
if(!m_vstrModifications.empty()) {
strValue = m_vstrModifications[m];
m_pScore->m_seqUtil.modify_all(strValue);
m_pScore->m_seqUtilAvg.modify_all(strValue);
}
bool bReturn = score_single(_s);
m++;
while(m < m_vstrModifications.size()) {
strValue = m_vstrModifications[m];
m_pScore->m_seqUtil.modify_all(strValue);
m_pScore->m_seqUtilAvg.modify_all(strValue);
bReturn = score_single(_s);
m++;
}
return bReturn;
}
bool mprocess::score_terminus(const string &_s)
{
size_t m = 0;
string strValue;
if(!m_vstrModifications.empty()) {
strValue = m_vstrModifications[m];
m_pScore->m_seqUtil.modify_all(strValue);
m_pScore->m_seqUtilAvg.modify_all(strValue);
}
bool bReturn = score_terminus_single(_s);
m++;
while(m < m_vstrModifications.size()) {
strValue = m_vstrModifications[m];
m_pScore->m_seqUtil.modify_all(strValue);
m_pScore->m_seqUtilAvg.modify_all(strValue);
bReturn = score_terminus_single(_s);
m++;
}
return bReturn;
}
bool mprocess::score_single(const msequence &_s)
{
m_pScore->m_seqUtil.motif_set(_s);
// if(_s.m_strDes == "ENSRNOP00000027073") {
// cout << "
" << _s.m_strDes << "
";
// cout.flush();
// }
if((m_bAnnotation || m_bMinimalAnnotation) && !m_mapAnnotation.empty()) {
map ::iterator itMod;
if(_s.m_strDes.find("IPI") != _s.m_strDes.npos) {
size_t tFind = _s.m_strDes.find("IPI");
size_t tEnd = _s.m_strDes.find(".",tFind);
itMod = m_mapAnnotation.find(_s.m_strDes.substr(tFind,tEnd-tFind));
}
else {
itMod = m_mapAnnotation.find(_s.m_strDes);
}
string strMods;
if(itMod != m_mapAnnotation.end()) {
strMods = itMod->second;
}
else {
strMods.clear();
}
if(m_strLastMods != strMods) {
if(!m_bAnnotation && m_bMinimalAnnotation) {
if(strMods.find("-1@B") != strMods.npos) {
m_pScore->m_seqUtil.modify_annotation(strMods);
}
else {
strMods.clear();
m_pScore->m_seqUtil.modify_annotation(strMods);
}
}
else {
m_pScore->m_seqUtil.modify_annotation(strMods);
}
}
m_strLastMods = strMods;
}
string strDesc = _s.m_strDes;
m_pScore->set_saps(m_bSaps,strDesc);
long lLength = (long)_s.m_strSeq.size();
if(m_tSeqSize < (size_t)(lLength+1)) {
delete m_pSeq;
m_tSeqSize = 4096*(size_t)(ceil((double)lLength/4096.0)+1);
m_pSeq = new char[m_tSeqSize];
}
strcpy(m_pSeq,_s.m_strSeq.c_str());
char cValue;
m_tTotalResidues += lLength;
long lStart = 0;
if(m_bRefineCterm) {
lStart = lLength - m_lCStartMax;
if(lStart < 0) {
lStart = 0;
}
}
long lEnd = 0;
bool bBreak = false;
const long lSpectra = (long) m_tSpectra;
bool bIsFirst = true;
bool bNg = false;
long lMissedCleaves = 0;
long lNextStart = 0;
/*
* set up variables and make some const local copies of frequently used member variables
*/
const long lMissedMax = (long)m_tMissedCleaves;
const long lMinAa = (long)m_tMinResidues;
long lLastCleave = -1;
double dMinMax = 0;
m_semiState.limit(lMinAa);
if(m_Cleave.m_lType & 0x01) {
m_semiState.activate(false);
}
const char cAster = '*';
const char cX = 'X';
m_dNt = m_pScore->m_seqUtil.m_pdAaMod['['];
m_dNtAve = m_pScore->m_seqUtilAvg.m_pdAaMod['['];
m_dNg = m_pScore->m_seqUtil.m_pdAaMod['n'];
m_dNgAve = m_pScore->m_seqUtilAvg.m_pdAaMod['n'];
bool bModsUtil = m_pScore->m_seqUtil.m_bPotential;
bool bModsUtilAvg = m_pScore->m_seqUtilAvg.m_bPotential;
const double dAcetyl = 42.010565;
const double dAcetylAve = 42.0367;
const double dDeamidate = 0.984016;
const double dDeamidateAve = 0.9848;
bool bFirstAcetyl = false;
unsigned long lRagged = 1;
bool bMiss = true;
/*
* continue operations until the start cursor (the beginning of the new peptide) reaches
* the end of the sequence
*/
while(lStart < lLength && lStart < m_lStartMax) {
bBreak = false;
while((m_pSeq[lStart] == cAster || m_pSeq[lStart] == cX) && lStart < m_lStartMax) {
lStart++;
}
lEnd = lStart;
if(lEnd >= lLength)
lEnd = lLength - 1;
bIsFirst = true;
lMissedCleaves = 0;
lLastCleave = -1;
/*
* with a given lStart, vary the end cursor (lEnd), using the cleavage rules, until
* none of the spectra have a parent ion as large as the peptide (tEligible == 0),
* or the number of missed cleavages is larger than the maximum allowed
*/
while(lEnd < lLength) {
/*
* get the next allowed lEnd
*/
bMiss = true;
while(lEnd < lLength) {
if(m_pSeq[lEnd] == cAster || m_pSeq[lEnd] == cX) {
if(lMissedCleaves == 0)
lNextStart = lEnd+1;
lMissedCleaves = lMissedMax;
lEnd--;
break;
}
if(m_pSeq[lEnd] == 'D' && m_pSeq[lEnd+1] == 'P') {
bMiss = false;
if(lMissedCleaves == 0)
lNextStart = lEnd+1;
break;
}
else if(m_Cleave.m_lType & 0x02) {
if(m_pSeq[lEnd+1] != 'P') {
if(m_pSeq[lEnd] == 'K' || m_pSeq[lEnd] == 'R') {
if(lMissedCleaves == 0)
lNextStart = lEnd+1;
break;
}
}
}
else if(m_Cleave.m_lType & 0x01) {
if(lMissedCleaves == 0)
lNextStart = lEnd+1;
break;
}
else if(m_Cleave.test(m_pSeq[lEnd],m_pSeq[lEnd+1])) {
if(lMissedCleaves == 0)
lNextStart = lEnd+1;
break;
}
lEnd++;
}
if(lEnd == lLength && lMissedCleaves == 0) {
lNextStart = lEnd+1;
}
if(bMiss) {
lMissedCleaves++;
}
/*
* update the peptide sequence in m_pScore
*/
if(lEnd >= lLength)
lEnd = lLength - 1;
if(lEnd - lStart >= lMinAa && lEnd < lLength) {
m_semiState.reset(lStart,lEnd,lLastCleave);
dMinMax = 0.0;
if(lStart == 0 && m_pSeq[0] == 'M' && (m_dNt == 0.0 || (int)m_dNt == 42) && m_iCurrentRound < 4) {
if(m_bQuickAcetyl) {
m_pScore->m_seqUtil.m_pdAaMod['['] = dAcetyl;
m_pScore->m_seqUtilAvg.m_pdAaMod['['] = dAcetylAve;
}
bFirstAcetyl = true;
}
do {
cValue = m_pSeq[lEnd+1];
m_pSeq[lEnd+1] = '\0';
if(lStart <= 2 && m_pSeq[0] == 'M' && (m_dNt == 0.0 || (int)m_dNt == 42) && m_iCurrentRound < 4) {
if(m_bQuickAcetyl) {
m_pScore->m_seqUtil.m_pdAaMod['['] = dAcetyl;
m_pScore->m_seqUtilAvg.m_pdAaMod['['] = dAcetylAve;
}
m_pScore->m_seqUtil.m_bPotential = true;
m_pScore->m_seqUtilAvg.m_bPotential = true;
bFirstAcetyl = true;
}
else if(bFirstAcetyl) {
m_pScore->m_seqUtil.m_pdAaMod['['] = m_dNt;
m_pScore->m_seqUtilAvg.m_pdAaMod['['] = m_dNtAve;
m_pScore->m_seqUtil.m_bPotential = bModsUtil;
m_pScore->m_seqUtilAvg.m_bPotential = bModsUtilAvg;
}
if(m_bCheckNg && m_dNg == 0.0 && strstr(m_pSeq+lStart,"NG")) {
m_pScore->m_seqUtil.m_pdAaMod['n'] = dDeamidate;
m_pScore->m_seqUtilAvg.m_pdAaMod['n'] = dDeamidateAve;
bNg = true;
}
pyro_check(*(m_pSeq+lStart)); // must be done before call to set_seq !!!!
if(bIsFirst || m_semiState.m_bActive) {
m_pScore->set_seq(m_pSeq+lStart,lStart == 0,lEnd == lLength-1,lEnd-lStart+1,lStart);
}
else {
m_pScore->add_seq(m_pSeq+lStart,lStart == 0,lEnd == lLength-1,lEnd-lStart+1,lStart);
}
m_pSeq[lEnd+1] = cValue;
bIsFirst = false;
/*
* use the m_pScore state machine to obtain allowed modified peptides that have
* the same sequence. then use create_score to score relavent spectra
*/
while(m_pScore->load_next()) {
m_tPeptideCount += m_pScore->m_State.m_lEqualsS;
m_bPermute = false;
m_bPermuteHigh = false;
if(m_semiState.ok()) {
create_score(_s,lStart,lEnd,lMissedCleaves - 1,true);
}
if(m_iCurrentRound == 1 && (m_bPermute && m_bCrcCheck || m_bPermuteHigh)) {
m_pScore->reset_permute();
while(m_pScore->permute()) {
if(m_semiState.ok()) {
create_score(_s,lStart,lEnd,lMissedCleaves - 1,false);
}
}
}
}
if(m_pyroState.m_bPyro) {
pyro_reset();
}
if(bNg) {
m_pScore->m_seqUtil.m_pdAaMod['n'] = m_dNg;
m_pScore->m_seqUtilAvg.m_pdAaMod['n'] = m_dNgAve;
m_pScore->m_seqUtil.m_bPotential = bModsUtil;
m_pScore->m_seqUtilAvg.m_bPotential = bModsUtilAvg;
bNg = false;
}
/*
* as of version 2004.03.01, the test for the number of missed cleavage sites (see the next note)
* was moved outside of this test.
*/
} while(m_semiState.next(lStart,lEnd));
if(bFirstAcetyl) {
m_pScore->m_seqUtil.m_pdAaMod['['] = m_dNt;
m_pScore->m_seqUtilAvg.m_pdAaMod['['] = m_dNtAve;
m_pScore->m_seqUtil.m_bPotential = bModsUtil;
m_pScore->m_seqUtilAvg.m_bPotential = bModsUtilAvg;
bFirstAcetyl = false;
}
if(!m_semiState.m_bActive && lStart == 0 && m_pSeq[0] == 'M' && (m_dNt == 0.0 || (int)m_dNt == 42) && m_iCurrentRound < 4) {
lRagged = 1;
while(lRagged <= 2) {
lStart = lRagged;
if(*(m_pSeq+lStart) != 'Q') {
if(m_bQuickAcetyl) {
m_pScore->m_seqUtil.m_pdAaMod['['] = dAcetyl;
m_pScore->m_seqUtilAvg.m_pdAaMod['['] = dAcetylAve;
}
m_pScore->m_seqUtil.m_bPotential = true;
m_pScore->m_seqUtilAvg.m_bPotential = true;
}
cValue = m_pSeq[lEnd+1];
m_pSeq[lEnd+1] = '\0';
if(m_bCheckNg && m_dNg == 0.0 && strstr(m_pSeq+lStart,"NG")) {
m_pScore->m_seqUtil.m_pdAaMod['n'] = dDeamidate;
m_pScore->m_seqUtilAvg.m_pdAaMod['n'] = dDeamidateAve;
m_pScore->m_seqUtil.m_bPotential = true;
m_pScore->m_seqUtilAvg.m_bPotential = true;
}
pyro_check(*(m_pSeq+lStart)); // must be done prior to call to set_seq !!!!!
m_pScore->set_seq(m_pSeq+lStart,lStart == 0,lEnd == lLength-1,lEnd-lStart+1,lStart);
m_pSeq[lEnd+1] = cValue;
bIsFirst = true;
/*
* use the m_pScore state machine to obtain allowed modified peptides that have
* the same sequence. then use create_score to score relavent spectra
*/
while(m_pScore->load_next()) {
m_tPeptideCount += m_pScore->m_State.m_lEqualsS;
m_bPermute = false;
m_bPermuteHigh = false;
create_score(_s,lStart,lEnd,lMissedCleaves - 1,true);
}
if(m_pyroState.m_bPyro) {
pyro_reset();
}
lStart = 0;
m_pScore->m_seqUtil.m_pdAaMod['['] = m_dNt;
m_pScore->m_seqUtilAvg.m_pdAaMod['['] = m_dNtAve;
if(bNg) {
m_pScore->m_seqUtil.m_pdAaMod['n'] = m_dNg;
m_pScore->m_seqUtilAvg.m_pdAaMod['n'] = m_dNgAve;
bNg = false;
}
m_pScore->m_seqUtil.m_bPotential = bModsUtil;
m_pScore->m_seqUtilAvg.m_bPotential = bModsUtilAvg;
lRagged++;
}
}
if(m_pScore->m_dMinMass > dMinMax) {
dMinMax = m_pScore->m_dMinMass;
}
if(dMinMax - m_fMaxMass > 100.0) {
break;
}
}
lLastCleave = lEnd;
/*
* as of version 2004.03.01, the test for the number of missed cleavage sites was moved to
* out of the previous if structure, because it could occasionally result in peptides being
* considered that contained too many missed cleavage sites.
*/
if(lMissedCleaves > lMissedMax) {
break;
}
lEnd++;
}
/*
* get the next allowed value for the start peptide cursor
*/
if(m_pSeq[lStart] == 'D' && m_pSeq[lStart+1] == 'P') {
lStart++;
}
else if(m_Cleave.m_lType & 0x02) {
if(m_pSeq[lStart+1] != 'P') {
if(m_pSeq[lStart] == 'K' || m_pSeq[lStart] == 'R') {
lStart++;
}
else {
lStart = lNextStart;
}
}
else {
lStart = lNextStart;
}
}
else if(m_Cleave.test(m_pSeq[lStart],m_pSeq[lStart+1])) {
lStart++;
}
else {
lStart = lNextStart;
}
}
return true;
}
__inline__ bool mprocess::pyro_check(const char _c)
{
if(m_pScore->m_seqUtil.m_pdAaMod['['] != 0.0 || !m_bQuickPyro) {
m_pyroState.m_bPyro = false;
return false;
}
if(_c == 'Q') {
m_pyroState.m_dModMass = -1.0*m_pScore->m_seqUtil.m_dAmmonia;
m_pScore->m_seqUtil.m_pdAaMod['['] = m_pyroState.m_dModMass;
m_pScore->m_seqUtilAvg.m_pdAaMod['['] = -1.0*m_pScore->m_seqUtilAvg.m_dAmmonia;
m_pyroState.m_bPotential = m_pScore->m_seqUtil.m_bPotential;
m_pScore->m_seqUtil.m_bPotential = true;
m_pScore->m_seqUtilAvg.m_bPotential = true;
m_pyroState.m_bPyro = true;
m_pyroState.m_cRes = 'Q';
return true;
}
else if(_c == 'E') {
m_pyroState.m_dModMass = -1.0*m_pScore->m_seqUtil.m_dWater;
m_pScore->m_seqUtil.m_pdAaMod['['] = m_pyroState.m_dModMass;
m_pScore->m_seqUtilAvg.m_pdAaMod['['] = -1.0*m_pScore->m_seqUtilAvg.m_dWater;
m_pyroState.m_bPotential = m_pScore->m_seqUtil.m_bPotential;
m_pScore->m_seqUtil.m_bPotential = true;
m_pScore->m_seqUtilAvg.m_bPotential = true;
m_pyroState.m_bPyro = true;
m_pyroState.m_cRes = 'E';
return true;
}
else if(_c == 'C' && (long)(m_pScore->m_seqUtil.m_pdAaFullMod['C']) == 57) {
m_pyroState.m_dModMass = -1.0*m_pScore->m_seqUtil.m_dAmmonia;
m_pScore->m_seqUtil.m_pdAaMod['['] = m_pyroState.m_dModMass;
m_pScore->m_seqUtilAvg.m_pdAaMod['['] = -1.0*m_pScore->m_seqUtilAvg.m_dAmmonia;
m_pyroState.m_bPotential = m_pScore->m_seqUtil.m_bPotential;
m_pScore->m_seqUtil.m_bPotential = true;
m_pScore->m_seqUtilAvg.m_bPotential = true;
m_pyroState.m_bPyro = true;
m_pyroState.m_cRes = 'C';
return true;
}
m_pyroState.m_bPyro = false;
return false;
}
__inline__ bool mprocess::pyro_reset()
{
m_pScore->m_seqUtil.m_bPotential = m_pyroState.m_bPotential;
m_pScore->m_seqUtilAvg.m_bPotential = m_pyroState.m_bPotential;
m_pyroState.m_bPyro = false;
m_pyroState.m_cRes = '\0';
m_pScore->m_seqUtil.m_pdAaMod['['] = m_dNt;
m_pScore->m_seqUtilAvg.m_pdAaMod['['] = m_dNtAve;
m_pyroState.m_dModMass = 0.0;
return true;
}
/*
* score_each_sequence runs through the list of sequences in m_svrSequences and
* generates scores for the peptides in those sequences.
*/
bool mprocess::score_each_sequence()
{
size_t tLength = m_svrSequences.m_pCol->size();
size_t a = 0;
// map ::iterator itMod;
// string strMods;
string strValue;
/*
* go through the msequenceCollection object and score each msequence
*/
while(a < tLength) {
if(!m_bReversedOnly) {
m_svrSequences.m_pCol->m_vASequences[a].m_tUid = m_tProteinCount+1;
m_svrSequences.m_pCol->m_vASequences[a].m_bForward = true;
score(m_svrSequences.m_pCol->m_vASequences[a]);
m_tProteinCount++;
}
if(m_lReversed != -1) {
m_svrSequences.m_pCol->m_vASequences[a].m_tUid = m_tProteinCount+1;
m_svrSequences.m_pCol->m_vASequences[a].m_bForward = false;
string strTemp;
string::reverse_iterator itS = m_svrSequences.m_pCol->m_vASequences[a].m_strSeq.rbegin();
string::reverse_iterator itE = m_svrSequences.m_pCol->m_vASequences[a].m_strSeq.rend();
while(itS != itE) {
strTemp += *itS;
itS++;
}
m_svrSequences.m_pCol->m_vASequences[a].m_strSeq = strTemp;
m_svrSequences.m_pCol->m_vASequences[a].m_strDes += ":reversed";
score(m_svrSequences.m_pCol->m_vASequences[a]);
m_tProteinCount++;
}
a++;
}
return true;
}
/*
* score_terminus is used to attempt to find modified terminii. the modifications
* are entered as a string, e.g.
* _s = "42@[,27@["
* means that the N-terminus may be modified by 42 or 27 daltons. Similarly:
* _s = -1@]"
* means that the C-terminus may be modified by -1 dalton. each potential modification
* is used separately. the protein sequence is cleaved using [X]|[X].
*/
bool mprocess::score_terminus_single(const string &_s)
{
if(_s.size() == 0) {
return false;
}
size_t tStart = 0;
size_t tAt = 0;
string strValue = _s.substr(tStart,_s.size()-tStart);
double dValue = atof(strValue.c_str());
string strKey = "refine, tic percent";
m_xmlValues.get(strKey,strValue);
double dTicPercent = atof(strValue.c_str());
if(dTicPercent == 0) {
dTicPercent = 20.0;
}
size_t tTicMax = (size_t)((double)m_vseqBest.size()*dTicPercent/100.0);
if(tTicMax < 1) {
tTicMax = 1;
}
size_t a = 0;
size_t tPips = 0;
bool bPotential = m_pScore->m_seqUtil.m_bPotential;
while(fabs(dValue) > 0.001) {
tAt = _s.find('@',tStart);
if(tAt == _s.npos)
break;
tAt++;
m_pScore->m_seqUtil.m_bPotential = true;
m_pScore->m_seqUtilAvg.m_bPotential = true;
m_pScore->m_seqUtil.m_pdAaMod[_s[tAt]] = dValue;
m_pScore->m_seqUtilAvg.m_pdAaMod[_s[tAt]] = dValue;
a = 0;
tPips = 0;
while(a < m_vseqBest.size()) {
score(m_vseqBest[a]);
tPips++;
if(tPips == tTicMax) {
if(m_lThread == 0 || m_lThread == 0xFFFFFFFF) {
cout << ".";
cout.flush();
m_prcLog.log(".");
}
tPips = 0;
}
a++;
}
tStart = _s.find(',',tAt);
if(tStart == _s.npos)
break;
cout << ". ";
cout.flush();
tStart++;
strValue = _s.substr(tStart,_s.size()-tStart);
dValue = atof(strValue.c_str());
}
m_pScore->m_seqUtil.m_bPotential = bPotential;
m_pScore->m_seqUtilAvg.m_bPotential = bPotential;
return true;
}
/*
* set_thread tells the mprocess it's assigned thread number. this number
* is used to determine which parts of the sequence list are to be
* processed by this mprocess object
*/
bool mprocess::set_thread(const unsigned long _t)
{
m_lThread = _t;
return true;
}
bool mprocess::set_threads(const unsigned long _t)
{
m_lThreads = _t;
if(m_lThreads == 1) {
m_lThread = 0xFFFFFFFF;
}
return true;
}
/*
* using the input parameters from the input XML file, retrieve the tandem MS spectra
*/
bool mprocess::spectra()
{
string strValue;
string strKey;
strKey = "spectrum, threads";
m_xmlValues.get(strKey,strValue);
unsigned long lThreads = atoi(strValue.c_str());
if(lThreads > 1) {
m_lThreads = lThreads;
}
else {
m_lThread = 0xFFFFFFFF;
}
strKey = "output, log path";
strValue = "no";
m_xmlValues.get(strKey,strValue);
if(m_lThread == 0 || m_lThread == 0xFFFFFFFF) {
if(strValue.size() > 0) {
m_prcLog.open(strValue);
strKey = "output, path";
m_xmlValues.get(strKey,strValue);
m_prcLog.log("X! Tandem starting");
}
}
if(m_vSpectra.size() > 0) {
m_tSpectraTotal = m_vSpectra.size();
return true;
}
m_vSpectra.clear();
mspectrum spCurrent;
bool bContinue = true;
m_tSpectraTotal = 0;
strKey = "spectrum, path";
m_xmlValues.get(strKey,strValue);
FILE *pStream;
bool bCommon = false;
pStream = fopen(strValue.c_str(),"r");
char *pValue = new char[1028];
memset(pValue,0,1028);
size_t tRead = 256;
if(pStream) {
tRead = fread(pValue,1,256,pStream);
}
if(pStream) {
fclose(pStream);
if(pValue[0] == 1 && pValue[1] == -95 || (pValue[3] == 'F' && pValue[5] == 'i' && pValue[7] == 'n') ) {
cout << "\nFailed to read spectrum file: " << strValue.c_str() << "\n";
cout << "Most likely cause: using a Finnigan raw spectrum.\nUse dta, pkl, mgf, mzdata (v.1.05) or mzxml (v.2.0) files ONLY! (1)\n\n";
cout.flush();
m_prcLog.log("error reading spectrum file 1");
delete pValue;
return false;
}
else if(strstr(pValue,"CMN ") == pValue) {
bCommon = true;
}
else {
size_t d = 0;
while(d < tRead) {
if(pValue[d] == '\0') {
cout << "\nFailed to read spectrum file: " << strValue.c_str() << "\n";
cout << "Most likely cause: using a binary spectrum file.\nUse dta, pkl, mgf, mzdata (v.1.05) or mzxml (v.2.0) files ONLY! (2)\n\n";
cout.flush();
m_prcLog.log("error reading spectrum file 2");
delete pValue;
return false;
}
d++;
}
}
if(strstr(pValue," 0) {
return spectra_force(strType,strValue);
}
}
/*
* if the input file did not contain GAML spectra, test the spectrum path parameter
* for aGAML spectrum information
* the ability to use a GAML formated spectrum file was added in v 2004-04-01
*/
if(bContinue) {
bool bState = m_specCondition.m_bCondition;
m_specCondition.use_condition(false);
loadgaml ldGaml(m_vSpectra, m_specCondition, *m_pScore);
if(ldGaml.open(strValue)) {
cout << " (gaml).";
ldGaml.get();
m_tSpectraTotal = m_vSpectra.size();
bContinue = false;
}
m_specCondition.use_condition(bState);
}
/*
* if the spectrum file did not contain GAML spectra, test the spectrum path parameter
* for a Matrix Science format file
*/
if(bContinue) {
loadmatrix ldMatrix;
if(ldMatrix.open(strValue)) {
cout << " (mgf).";
while(ldMatrix.get(spCurrent)) {
m_tSpectraTotal++;
lLoaded++;
if(lLoaded == lLimit) {
cout << ".";
cout.flush();
lLoaded = 0;
m_prcLog.log(".\n");
}
if(m_specCondition.condition(spCurrent, *m_pScore)) {
m_vSpectra.push_back(spCurrent);
}
spCurrent.m_vMI.clear();
}
if(!spCurrent.m_vMI.empty()) {
m_tSpectraTotal++;
if(m_specCondition.condition(spCurrent, *m_pScore))
m_vSpectra.push_back(spCurrent);
}
bContinue = false;
}
}
/*
* if no Matrix Science format data was found, test for PKL format information
*/
if(bContinue) {
loadpkl ldPkl;
if(ldPkl.open(strValue)) {
cout << " (pkl).";
while(ldPkl.get(spCurrent)) {
m_tSpectraTotal++;
lLoaded++;
if(lLoaded == lLimit) {
cout << ".";
cout.flush();
lLoaded = 0;
m_prcLog.log(".\n");
}
if(m_specCondition.condition(spCurrent, *m_pScore)) {
m_vSpectra.push_back(spCurrent);
}
spCurrent.m_vMI.clear();
}
if(!spCurrent.m_vMI.empty()) {
m_tSpectraTotal++;
if(m_specCondition.condition(spCurrent, *m_pScore)) {
m_vSpectra.push_back(spCurrent);
}
}
bContinue = false;
}
}
#ifdef XMLCLASS
/*
* if no PKl format data was found, test for mzxml format information
* Celui ci sera different des autres.
* La boucle while(ldPkl.get(spCurrent))
* est remplacee par le travail de la machine xml provenant de mzxml2other
* ldMzxml.open instantie la machine
* tandis que ldMzxml.get l'enclenche
*/
if(bContinue) {
loadmzxml ldMzxml( m_vSpectra, m_specCondition, *m_pScore);
if(ldMzxml.open(strValue)) {
//Ce .get est different, il va chercher tous les spectres du fichier.
cout << " (mzXML).";
ldMzxml.get();
m_tSpectraTotal = m_vSpectra.size();
bContinue = false;
}
}
/*
* if no MzXML format data was found, test for MzData format information
* Comme pour mzxml
*/
if(bContinue) {
loadmzml ldMzml( m_vSpectra, m_specCondition, *m_pScore);
if(ldMzml.open(strValue)) {
//Ce .get est different, il va chercher tous les spectres du fichier.
cout << " (mzML).";
ldMzml.get();
m_tSpectraTotal = m_vSpectra.size();
bContinue = false;
}
}
if(bContinue) {
loadmzdata ldMzdata( m_vSpectra, m_specCondition, *m_pScore);
if(ldMzdata.open(strValue)) {
//Ce .get est different, il va chercher tous les spectres du fichier.
cout << " (mzData).";
ldMzdata.get();
m_tSpectraTotal = m_vSpectra.size();
bContinue = false;
}
}
#endif
/*
* if no mzxml format data was found, test for dta format information
*/
if(bContinue) {
loaddta ldSpec;
if(!ldSpec.open(strValue)) {
/*
* report an error if no DTA information was found: there are no more default file types to check
*/
cout << "\nFailed to read spectrum file: " << strValue.c_str() << "\n";
cout << "Most likely: an unsupported data file type:\nUse cmn, dta, pkl, mgf, mzData (v.1.05) oe mzXML (v.2.0) files only! (4)\n\n";
cout.flush();
m_prcLog.log("error loading spectrum file 4");
return false;
}
else {
cout << " (dta).";
while(ldSpec.get(spCurrent)) {
m_tSpectraTotal++;
lLoaded++;
if(lLoaded == lLimit) {
cout << ".";
cout.flush();
lLoaded = 0;
m_prcLog.log(".\n");
}
if(m_specCondition.condition(spCurrent, *m_pScore)) {
m_vSpectra.push_back(spCurrent);
}
spCurrent.m_vMI.clear();
}
if(!spCurrent.m_vMI.empty()) {
m_tSpectraTotal++;
if(m_specCondition.condition(spCurrent, *m_pScore)) {
m_vSpectra.push_back(spCurrent);
}
}
}
}
strKey = "spectrum, use contrast angle";
m_xmlValues.get(strKey,strValue);
if(strValue == "yes") {
// remove spectra that are redundant
subtract();
}
m_prcLog.log("spectra loaded");
size_t a = 0;
while(a < m_vSpectra.size()) {
if(m_vSpectra[a].m_strDescription.find(":ETD") != m_vSpectra[a].m_strDescription.npos) {
m_vSpectra[a].m_uiType = I_C|I_Z;
}
else if(m_vSpectra[a].m_strDescription.find(":CID") != m_vSpectra[a].m_strDescription.npos) {
m_vSpectra[a].m_uiType = I_B|I_Y;
}
else if(m_vSpectra[a].m_strDescription.find(":HCD") != m_vSpectra[a].m_strDescription.npos) {
m_vSpectra[a].m_uiType = I_B|I_Y;
}
a++;
}
return true;
}
/*
* This method loads sequences from a bioml sequence data file.
* It was first introduced in version 2006.04.01
*/
bool mprocess::load_sequences(void)
{
string strKey = "refine, sequence path";
string strValue;
size_t a = 0;
// Check for input sequences for refinement to be loaded from a bioml file
// Loading done for each thread
m_xmlValues.get(strKey,strValue);
FILE *pFile = fopen(strValue.c_str(),"r");
if(pFile == NULL) {
return true;
}
else {
fclose(pFile);
}
set setUids;
while(a < m_vseqBest.size()) {
setUids.insert(m_vseqBest[a].m_tUid);
a++;
}
if(strValue.size() > 0) {
SAXBiomlHandler saxFile;
saxFile.setFileName(strValue.c_str());
saxFile.parse();
a = 0;
while(a < saxFile.m_vseqBest.size()) {
if(setUids.find(saxFile.m_vseqBest[a].m_tUid) == setUids.end()) {
short int iPath = saxFile.m_vseqBest[a].m_siPath;
string strPath = saxFile.m_vstrPaths[iPath];
size_t b = 0;
while(b < m_vstrPaths.size()) {
if(strPath == m_vstrPaths[b]) {
saxFile.m_vseqBest[a].m_siPath = (short int)b;
break;
}
b++;
}
if(b == m_vstrPaths.size()) {
m_vstrPaths.push_back(strPath);
saxFile.m_vseqBest[a].m_siPath = (short int)(m_vstrPaths.size() - 1);
}
m_vseqBest.push_back(saxFile.m_vseqBest[a]);
m_mapSequences.insert(SEQMAP::value_type(saxFile.m_vseqBest[a].m_tUid,saxFile.m_vseqBest[a].m_strSeq));
}
a++;
}
}
return true;
}
/*
* This method forces the use of a particular file format, based on the value of the
* input parameter "spectrum, path type" parameter. This can be useful if
* for some reason the file type detection routines do not correctly identify your
* file type. It may cause bad behavior if your file does not match the file type
* specified by this parameter.
* Currently supported values for the "spectrum, path type parameter" are as follows:
* "dta", "pkl", "mgf", "gaml", "mzdata", "mzxml"
*/
bool mprocess::spectra_force(string &_t,string &_v)
{
string strValue = _v;
string strKey;
mspectrum spCurrent;
long lLoaded = 0;
long lLimit = 2000;
cout << " (" << _t.c_str() << ").";
if(_t == "gaml") {
bool bState = m_specCondition.m_bCondition;
m_specCondition.use_condition(false);
loadgaml ldGaml(m_vSpectra, m_specCondition, *m_pScore);
if(ldGaml.open_force(strValue)) {
ldGaml.get();
m_tSpectraTotal = m_vSpectra.size();
}
m_specCondition.use_condition(bState);
}
else if(_t == "cmn") {
loadcmn ldCmn;
if(ldCmn.open(strValue)) {
while(ldCmn.get(spCurrent)) {
m_tSpectraTotal++;
lLoaded++;
if(lLoaded == lLimit) {
cout << ".";
cout.flush();
lLoaded = 0;
m_prcLog.log(".\n");
}
m_vSpectra.push_back(spCurrent);
}
}
}
/*
* if the spectrum file did not contain GAML spectra, test the spectrum path parameter
* for a Matrix Science format file
*/
else if(_t == "mgf") {
loadmatrix ldMatrix;
if(ldMatrix.open_force(strValue)) {
while(ldMatrix.get(spCurrent)) {
m_tSpectraTotal++;
lLoaded++;
if(lLoaded == lLimit) {
cout << ".";
cout.flush();
lLoaded = 0;
m_prcLog.log(".");
}
if(m_specCondition.condition(spCurrent, *m_pScore))
m_vSpectra.push_back(spCurrent);
}
if(spCurrent.m_vMI.size() > 0) {
m_tSpectraTotal++;
if(m_specCondition.condition(spCurrent, *m_pScore))
m_vSpectra.push_back(spCurrent);
}
}
}
/*
* if no Matrix Science format data was found, test for PKL format information
*/
else if(_t == "pkl") {
loadpkl ldPkl;
if(ldPkl.open_force(strValue)) {
while(ldPkl.get(spCurrent)) {
m_tSpectraTotal++;
lLoaded++;
if(lLoaded == lLimit) {
cout << ".";
cout.flush();
lLoaded = 0;
m_prcLog.log(".");
}
if(m_specCondition.condition(spCurrent, *m_pScore))
m_vSpectra.push_back(spCurrent);
}
if(spCurrent.m_vMI.size() > 0) {
m_tSpectraTotal++;
if(m_specCondition.condition(spCurrent, *m_pScore))
m_vSpectra.push_back(spCurrent);
}
}
}
#ifdef XMLCLASS
else if(_t == "mzxml") {
loadmzxml ldMzxml( m_vSpectra, m_specCondition, *m_pScore);
if(ldMzxml.open_force(strValue)) {
//Ce .get est different, il va chercher tous les spectres du fichier.
ldMzxml.get();
m_tSpectraTotal = m_vSpectra.size();
}
}
else if(_t == "mzml") {
loadmzxml ldMzml( m_vSpectra, m_specCondition, *m_pScore);
if(ldMzml.open_force(strValue)) {
//Ce .get est different, il va chercher tous les spectres du fichier.
ldMzml.get();
m_tSpectraTotal = m_vSpectra.size();
}
}
else if(_t == "mzdata") {
loadmzdata ldMzdata( m_vSpectra, m_specCondition, *m_pScore);
if(ldMzdata.open_force(strValue)) {
//Ce .get est different, il va chercher tous les spectres du fichier.
ldMzdata.get();
m_tSpectraTotal = m_vSpectra.size();
}
}
#endif
else if(_t == "dta") {
loaddta ldSpec;
if(ldSpec.open_force(strValue)) {
while(ldSpec.get(spCurrent)) {
m_tSpectraTotal++;
lLoaded++;
if(lLoaded == lLimit) {
cout << ".";
cout.flush();
m_prcLog.log(".");
lLoaded = 0;
}
if(m_specCondition.condition(spCurrent, *m_pScore))
m_vSpectra.push_back(spCurrent);
}
if(spCurrent.m_vMI.size() > 0) {
m_tSpectraTotal++;
if(m_specCondition.condition(spCurrent, *m_pScore))
m_vSpectra.push_back(spCurrent);
}
}
}
else {
cout << "\n" << "The file type \"" << _t.c_str() << " is not supported.\n";
cout << "Supported values: pkl, dta, mgf, gaml, mzxml, mzdata\n";
cout.flush();
m_prcLog.log("error loading forced spectrum file 5");
return false;
}
strKey = "spectrum, use contrast angle";
m_xmlValues.get(strKey,strValue);
if(strValue == "yes") {
// remove spectra that are redundant
subtract();
}
m_prcLog.log("spectra loaded");
return true;
}
//
// This method is an experiment to decrease the number of redundant spectra that
// enter the calculation. It calculates the inner product (using ::dot) between
// two spectrum vectors and then calculates the cosine of the opening
// angle between the vectors. If the arccos is greater than the parameter
// "spectrum, contrast angle", then the spectrum is considered to be non-redundant and kept.
//
// The inner product is calculated for parent ion masses within 1000 ppm of each
// other. If the arccos between two spectrum vectors is below the contrast angle parameter,
// then the two spectra's summed intensities are compared. The spectrum with the lowest
// summed intensity is placed in a list of rejected spectra and the process is repeated.
// Once all of the spectra to be rejected have been marked, a new mspectrum vector is created
// and copied into m_vSpectra.
//
bool mprocess::subtract(void)
{
if(m_vSpectra.size() == 0)
return false;
cout << "+";
cout.flush();
string strValue;
string strKey = "spectrum, fragment mass error";
m_xmlValues.get(strKey,strValue);
if (strValue.empty()) {
// try old parameter name
strKey = "spectrum, fragment monoisotopic mass error";
m_xmlValues.get(strKey,strValue);
}
float fRes = (float)atof(strValue.c_str());
if(fRes <= 0.0) {
fRes = 0.5;
}
bool bType = true;
strKey = "spectrum, fragment mass error units";
m_xmlValues.get(strKey,strValue);
if (strValue.empty()) {
// try old parameter name
strKey = "spectrum, fragment monoisotopic mass error units";
m_xmlValues.get(strKey,strValue);
}
if(strValue != "Daltons") {
bType = false;
}
// retrieve contrast angle
strKey = "spectrum, contrast angle";
m_xmlValues.get(strKey,strValue);
double dLimit = atof(strValue.c_str());
// apply limits to the value of the angle
if(dLimit < 0.0) {
dLimit = 0.0;
}
if(dLimit > 90.0) {
dLimit = 90.0;
}
dLimit = cos(dLimit * 3.1415/180.0);
const size_t tSpectra = m_vSpectra.size();
size_t a = 0;
size_t b = 0;
double dValue = 0.0;
long lCount = 0;
double dDot1 = 0.0;
double dDot2 = 0.0;
vector vdDot1;
// calculate the length of all of the spectrum vectors
vector::iterator itM = m_vSpectra[b].m_vMI.begin();
vector::iterator itMEnd = m_vSpectra[b].m_vMI.end();
while(b < m_vSpectra.size()) {
dDot1 = 0.0;
itM = m_vSpectra[b].m_vMI.begin();
itMEnd = m_vSpectra[b].m_vMI.end();
while(itM != itMEnd) {
dDot1 += itM->m_fI*itM->m_fI;
itM++;
}
vdDot1.push_back(sqrt(dDot1));
b++;
}
a = 0;
long c = 0;
double dTotal = 0.;
long lMax = 0;
set vDelete;
double dMax = 0.0;
size_t tLastMax;
double dLastSum;
size_t tLastA;
float fMH = 0.0;
const double dFactor = 0.001;
double dDelta = 1.0;
vector::iterator itA = m_vSpectra.begin();
vector::iterator itB = itA;
// calculated the dot products between the spectrum vector pairs
while(a < tSpectra) {
// calculate only the pairs below the diagonal on the pairs matrix
// the values on the diagonal are all 1.0
// the values above the diagonal repeat the below diagonal elements, d(i,j) = d(j,i)
b = a+1;
itB = itA;
itB++;
lCount = 0;
dMax = itA->m_vdStats[0];
tLastMax = itA->m_tId;
fMH = (float)itA->m_dMH;
dDelta = dFactor*fMH;
dLastSum = itA->m_vdStats[0];
tLastA = 0;
while(b < tSpectra) {
// only calculate dValue if the parent ion mass is appropriate
// and if the spectrum has not already been rejected
if(fabs(fMH - (float)itB->m_dMH) < dDelta && vDelete.find(itB->m_tId) == vDelete.end()) {
dValue = dot(a,b,fRes,bType)/(vdDot1[a]*vdDot1[b]);
if(dValue > dLimit) {
if(dMax < itB->m_vdStats[0]) {
dMax = itB->m_vdStats[0];
tLastA = b;
vDelete.insert(tLastMax);
tLastMax = itB->m_tId;
}
else {
vDelete.insert(itB->m_tId);
dLastSum += itB->m_vdStats[0];
tLastA = a;
}
lCount++;
}
}
b++;
itB++;
}
if(tLastA != 0) {
m_vSpectra[tLastA].m_vdStats[0] += dLastSum;
}
if(lCount > lMax) {
lMax = lCount;
}
if(c > 1000) {
if(m_lThread == 0 || m_lThread == 0xFFFFFFFF) {
cout << "+";
cout.flush();
}
c = 0;
}
c++;
a++;
itA++;
while(a < tSpectra && vDelete.find(itA->m_tId) != vDelete.end()) {
a++;
itA++;
if(c > 1000) {
cout << "+";
cout.flush();
c = 0;
}
c++;
}
}
vector::iterator itStart = m_vSpectra.begin();
vector vTemp;
vTemp.reserve(m_vSpectra.size() - vDelete.size()+1);
m_tContrasted = 0;
// create a new list of spectra, vTemp and replace m_vSpectra with
// those spectra. This is much faster than deleting the spectra
// from the intact m_vSpectra list
while(itStart != m_vSpectra.end()) {
if(vDelete.find(itStart->m_tId) == vDelete.end()) {
vTemp.push_back(*itStart);
}
itStart++;
}
m_tContrasted = (double)(m_vSpectra.size() - vTemp.size());
m_vSpectra.clear();
m_vSpectra.reserve(vTemp.size() + 1);
m_vSpectra = vTemp;
return true;
}
/*
* taxonomy uses the taxonomy information in the input XML file to load
* the msequenceServer member object with file path names to the required
* sequence list files (FASTA format only in the initial release). If these
*/
bool mprocess::taxonomy()
{
string strValue;
string strKey = "list path, taxonomy information";
m_xmlValues.get(strKey,strValue);
string strTaxonPath = strValue;
strKey = "protein, taxon";
m_xmlValues.get(strKey,strValue);
long lReturn = m_svrSequences.load_file(strTaxonPath,strValue);
/*
* return false if the load_file method fails
*/
if(lReturn == 1) {
cout << "\nThe taxonomy parameter file \"" << strTaxonPath.c_str();
cout << "\" could not be found.\nCheck your settings and try again.\n";
return false;
}
else if(lReturn == 2) {
cout << "\nThe taxonomy parameter file \"" << strTaxonPath.c_str();
cout << "\" did not contain the value \"" << strValue.c_str() << "\".\nCheck your settings and try again.\n";
return false;
}
else if(lReturn == 3) {
cout << "\nThe taxonomy parameter file \"" << strTaxonPath.c_str();
cout << "\" contained incorrect entries\nfor the protein sequence files associated with the name: \"" << strValue.c_str() << "\".\nCheck the file names in the taxonomy file and try again.\n";
return false;
}
return true;
}
//
// new code, version 2007/04/01, Ron Beavis
// this section finds the file names associated with the taxonomy specification
// associated with Single Amino acid Polymorphisms (SAPs). The information
// is parsed using SAXSapHandler and stored in the m_mapSap object of mscore.
// This object will be used to control the state machine that generates the
// peptides associated with these polymorphisms
// When the mprocess pointer is NULL, the SAP object is loaded from the object
// in the original file. If the pointer is not NULL, it is assumed that the mprocess
// object contains the necessary SAP information, which is simply copied from memory.
//
bool mprocess::load_saps(mprocess *_p)
{
string strValue;
string strKey = "list path, taxonomy information";
m_xmlValues.get(strKey,strValue);
string strTaxonPath = strValue;
strKey = "protein, taxon";
m_xmlValues.get(strKey,strValue);
XmlTaxonomy xmlTax;
string strType = "saps"; //this is the format attribute for the objects in the tax file
if(!xmlTax.load(strTaxonPath,strValue,strType))
return true;
// bail out without error if there aren't any SAP files specified.
size_t a = 0;
map >::iterator itMap;
map >::iterator itValue;
pair > pairMap;
multimap::iterator itMulti;
// copy from _p if it exists
if(_p != NULL) {
itMap = _p->m_pScore->m_Sap.m_mapSap.begin();
// load the mscore m_Sap object with the new values
while(itMap != _p->m_pScore->m_Sap.m_mapSap.end()) {
pairMap.first = itMap->first;
pairMap.second.clear();
itValue = m_pScore->m_Sap.m_mapSap.find(pairMap.first);
if(itValue == m_pScore->m_Sap.m_mapSap.end()) {
m_pScore->m_Sap.m_mapSap.insert(pairMap);
itValue = m_pScore->m_Sap.m_mapSap.find(pairMap.first);
}
itMulti = itMap->second.begin();
while(itMulti != itMap->second.end()) {
itValue->second.insert(*itMulti);
itMulti++;
}
itMap++;
}
return true;
}
m_vstrSaps.clear();
// obtain the lists from files, if no valid mprocess value was passed through _p
while(a < xmlTax.m_vstrPaths.size()) {
ifstream ifTest;
ifTest.open(xmlTax.m_vstrPaths[a].c_str());
if(!ifTest.fail()) {
m_vstrSaps.push_back(xmlTax.m_vstrPaths[a]);
ifTest.close();
}
ifTest.clear();
a++;
}
if(!m_vstrSaps.empty()) {
cout << " loaded.\nLoading SAPs ";
cout.flush();
}
a = 0;
while(a < m_vstrSaps.size()) {
SAXSapHandler sapXml;
sapXml.setFileName(xmlTax.m_vstrPaths[a].data());
sapXml.parse();
itMap = sapXml.m_mapSap.begin();
// load the mscore m_Sap object with the new values
while(itMap != sapXml.m_mapSap.end()) {
pairMap.first = itMap->first;
pairMap.second.clear();
itValue = m_pScore->m_Sap.m_mapSap.find(pairMap.first);
if(itValue == m_pScore->m_Sap.m_mapSap.end()) {
m_pScore->m_Sap.m_mapSap.insert(pairMap);
itValue = m_pScore->m_Sap.m_mapSap.find(pairMap.first);
}
itMulti = itMap->second.begin();
while(itMulti != itMap->second.end()) {
itValue->second.insert(*itMulti);
itMulti++;
}
itMap++;
}
cout << ".";
cout.flush();
a++;
}
return true;
}
//
// new code, version 2007/04/01, Ron Beavis
// this section finds the file names associated with the taxonomy specification
// associated with Single Amino acid Polymorphisms (SAPs). The information
// is parsed using SAXModHandler and stored in the m_mapMod object of mscore.
// This object will be used to control the state machine that generates the
// peptides associated with these modifications
// When the mprocess pointer is NULL, the MOD object is loaded from the object
// in the original file. If the pointer is not NULL, it is assumed that the mprocess
// object contains the necessary MOD information, which is simply copied from memory.
//
bool mprocess::load_annotation(mprocess *_p)
{
string strValue;
string strKey = "list path, taxonomy information";
m_xmlValues.get(strKey,strValue);
string strTaxonPath = strValue;
strKey = "protein, taxon";
m_xmlValues.get(strKey,strValue);
XmlTaxonomy xmlTax;
string strType = "mods"; //this is the format attribute for the objects in the tax file
if(!xmlTax.load(strTaxonPath,strValue,strType))
return true;
// bail out without error if there aren't any mods files specified.
size_t a = 0;
map::iterator itMods;
if(_p != NULL) {
itMods = _p->m_mapAnnotation.begin();
// load the m_mapAnnotation object with the new values
while(itMods != _p->m_mapAnnotation.end()) {
m_mapAnnotation[itMods->first] = itMods->second;
itMods++;
}
return true;
}
m_vstrMods.clear();
// obtain the lists from files, if no valid mprocess value was passed through _p
while(a < xmlTax.m_vstrPaths.size()) {
ifstream ifTest;
ifTest.open(xmlTax.m_vstrPaths[a].c_str());
if(!ifTest.fail()) {
m_vstrMods.push_back(xmlTax.m_vstrPaths[a]);
ifTest.close();
}
ifTest.clear();
a++;
}
if(!m_vstrMods.empty()) {
cout << " loaded.\nLoading annotation ";
cout.flush();
}
a = 0;
while(a < m_vstrMods.size()) {
SAXModHandler modXml;
modXml.setFileName(xmlTax.m_vstrPaths[a].data());
modXml.parse();
itMods = modXml.m_mapMod.begin();
// load the mscore m_Sap object with the new values
while(itMods != modXml.m_mapMod.end()) {
m_mapAnnotation[itMods->first] = itMods->second;
itMods++;
}
cout << ".";
cout.flush();
a++;
}
return true;
}
bool mprocess::serialize(void)
{
if(!m_bSerialize) {
return true;
}
string strKey = "output, path";
string strValue;
if(!m_xmlValues.get(strKey,strValue)) {
return false;
}
FILE *pFile = fopen(strValue.c_str(),"wb");
if(!pFile) {
cout << "Warning: serialization did not occur.\n";
cout.flush();
return false;
}
vector::iterator itS = m_vSpectra.begin();
vector::iterator itE = m_vSpectra.end();
vector::iterator itMI;
vector::iterator itMIE;
size_t tLength = m_vSpectra.size();
fwrite((const void*)&tLength,sizeof(size_t),1,pFile);
float fV = 0.0;
while(itS != itE) {
tLength = itS->m_vMI.size();
fwrite((const void*)&(itS->m_tId),sizeof(size_t),1,pFile);
fwrite((const void*)&tLength,sizeof(size_t),1,pFile);
itMI = itS->m_vMI.begin();
itMIE = itS->m_vMI.end();
while(itMI != itMIE) {
fwrite((const void*)&(itMI->m_fM),sizeof(float),1,pFile);
fwrite((const void*)&(itMI->m_fI),sizeof(float),1,pFile);
itMI++;
}
itS++;
}
fclose(pFile);
return true;
}
bool mprocess::restore(void)
{
if(!m_bSerialize) {
return true;
}
string strKey = "output, path";
string strValue;
if(!m_xmlValues.get(strKey,strValue)) {
return false;
}
FILE *pFile = fopen(strValue.c_str(),"rb");
if(!pFile || feof(pFile)) {
cout << "Warning: could not find serialization file \"" << strValue.c_str() << "\", spectrum restoration not performed.\n";
cout.flush();
return false;
}
vector