cCandidate.h

Go to the documentation of this file.

 
#ifndef _CCANDIDATE_H
#define _CCANDIDATE_H
 
#include <vector>
#include <unordered_set>
#include <string>
 
#include "core/cParameters.h"
#include "core/cBricksDatabase.h"
#include "core/cDeNovoGraphNode.h"
#include "core/cSummaryFormula.h"
 
class cCandidateSet;
class cDeNovoGraph;
 
 
using namespace std;
using namespace boost;
 
 
struct TRotationInfo {
 
    int id;
 
 
    vector<int> bricks;
 
    
    int middlebranchstart;
 
 
    int middlebranchend;
 
 
    int startmodifID;
 
 
    int endmodifID;
 
 
    int middlemodifID;
 
 
    string tcomposition;
        
 
    TRotationInfo() {
        clear();
    }
 
 
    void clear() {
        id = 0;
        bricks.clear();
        middlebranchstart = 0;
        middlebranchend = 0;
        startmodifID = 0;
        endmodifID = 0;
        middlemodifID = 0;
        tcomposition = "";
    }
 
 
    bool startsWithBracket() {
        if (tcomposition.size() == 0) {
            return false;
        }
        return tcomposition[0] == '(';
    }
 
    bool endsWithBracket() {
        if (tcomposition.size() == 0) {
            return false;
        }
        return tcomposition.back() == ')';
    }
 
};
 
 
class cCandidate {
 
    int startmodifID;
    int endmodifID;
    int middlemodifID;
    int branchstart;
    int branchend;
    vector<nodeEdge> path;
    eFragmentIonType startiontype;
    string name;
    cSummaryFormula summary;
 
    vector<string> composition;
    string internalcomposition;
    int numberofinternalbricks;
 
    string realpeptidename;
    string acronympeptidename;
    vector<string> acronyms;
    vector<string> backboneacronyms;
    vector<string> branchacronyms;
    string stringpath;
 
    void updateInternalComposition();
 
    void getPermutationsIter(cCandidateSet& permutations, vector<string>& currentcandidate, int position, bool* terminatecomputation);
 
    void attachSubBranchCandidates(cCandidate& candidate, cCandidateSet& result, ePeptideType peptidetype, bool* terminatecomputation);
 
    void attachAllBranches(cCandidate& candidate, cCandidateSet& result, ePeptideType peptidetype, bool* terminatecomputation);
 
    void getPartialRotations(const string& composition, vector<string>& rotations);
 
    void getPartialBranchCyclicRotations(const string& composition, vector<cCandidate>& branchcyclicrotations, int branchstart, int branchend);
 
public:
 
    cCandidate();
    
 
    cCandidate(vector<string>& composition, vector<nodeEdge>& path, eFragmentIonType startiontype, int startmodifID, int endmodifID, int middlemodifID, int middlepos);
 
 
    cCandidate(vector<string>& composition, vector<nodeEdge>& path, eFragmentIonType startiontype, int startmodifID, int endmodifID, int middlemodifID, int branchstart, int branchend);
 
 
    void setCandidate(vector<string>& composition, vector<nodeEdge>& path, eFragmentIonType startiontype, int startmodifID, int endmodifID, int middlemodifID, int middlepos);
 
 
    void setCandidate(vector<string>& composition, vector<nodeEdge>& path, eFragmentIonType startiontype, int startmodifID, int endmodifID, int middlemodifID, int branchstart, int branchend);
    
 
    void clear();
 
 
    string& getComposition();
 
 
    void revertComposition();
 
 
    void prepareBranchedCandidates(cCandidateSet& result, ePeptideType peptidetype, bool* terminatecomputation);
 
 
    string getTComposition();
 
 
    string getRevertedTComposition(bool usebrackets);
 
 
    string getAcronymsTComposition(cBricksDatabase& brickdatabase);
 
 
    string getRealNameTComposition(cBricksDatabase& brickdatabase);
 
 
    int getBranchSize();
 
 
    int getBranchStart();
 
 
    int getBranchEnd();
 
 
    void getPermutationsOfBranches(vector<TRotationInfo>& tpermutations);
 
 
    double calculatePrecursorMassFromBricks(cBricksDatabase& brickdatabasewithcombinations, cParameters* parameters);
 
 
    bool isEqualTo(cCandidate& candidate);
 
 
    void getPermutations(cCandidateSet& permutations, bool* terminatecomputation);
 
 
    int getStartModifID();
 
 
    void setStartModifID(int id);
 
 
    int getEndModifID();
 
 
    void setEndModifID(int id);
 
 
    int getMiddleModifID();
 
 
    void setMiddleModifID(int id);
 
 
    bool compare(cCandidate& candidate);
 
 
    vector<nodeEdge>& getPath();
 
 
    bool hasEqualTPermutations(cCandidate& candidate);
 
 
    bool hasOnlyArtificialBricks(cBricksDatabase& brickdatabasewithcombinations);
 
    
    bool hasFirstBrickArtificial(cBricksDatabase& brickdatabasewithcombinations);
 
 
    bool hasLastBrickArtificial(cBricksDatabase& brickdatabasewithcombinations);
 
 
    bool hasLastBrickInvalid(cBricksDatabase& brickdatabasewithcombinations);
 
 
    void getRotations(vector<string>& rotations, bool includerevertedrotations);
 
 
    void getBranchCyclicRotations(vector<cCandidate>& branchcyclicrotations, bool includerevertedrotations);
 
 
    cSummaryFormula calculateSummaryFormulaFromBricks(cParameters& parameters, ePeptideType peptidetype, double precursormass = 0);
 
 
    cSummaryFormula& getSummaryFormula();
 
 
    void setSummaryFormula(cSummaryFormula& summary);
 
 
    void store(ofstream& os);
 
 
    void load(ifstream& is);
 
 
    void setName(string& name);
 
 
    string& getName();
 
 
    void setAcronyms(cBricksDatabase& bricksdatabase);
 
 
    void setBackboneAcronyms(cBricksDatabase& bricksdatabase);
 
 
    void setBranchAcronyms(cBricksDatabase& bricksdatabase);
 
 
    vector<string>& getAcronyms();
 
 
    vector<string>& getBackboneAcronyms();
 
 
    vector<string>& getBranchAcronyms();
 
 
    void setPath(cDeNovoGraph& graph, cParameters* parameters);
 
 
    string& getPathAsString();
 
 
    void setRealPeptideName(cBricksDatabase& bricksdatabase, ePeptideType peptidetype);
 
 
    void setAcronymPeptideNameWithHTMLReferences(cBricksDatabase& bricksdatabase, ePeptideType peptidetype);
 
 
    string& getRealPeptideName();
 
 
    string& getAcronymPeptideNameWithHTMLReferences();
 
 
    void setStartIonType(eFragmentIonType iontype);
 
 
    eFragmentIonType getStartIonType();
 
 
    bool checkKetideSequence(cBricksDatabase& bricksdatabase, ePeptideType peptidetype, bool regularblocksorder);
 
 
    eResidueLossType getLeftResidueType(cBricksDatabase& bricksdatabase);
 
 
    eResidueLossType getRightResidueType(cBricksDatabase& bricksdatabase);
 
 
    bool checkKetideBlocks(cBricksDatabase& bricksdatabase, ePeptideType peptidetype, bool regularblocksorder);
 
 
};
 
 
struct hash_cCandidate {
 
    size_t operator()(const cCandidate& candidate) const {
        return std::hash<string>()(((cCandidate&)candidate).getComposition());
    }
 
};
 
 
bool operator == (cCandidate const& a, cCandidate const& b);
 
 
#endif