libXpertMass Developer Documentation
  • libXpertMass
  • CalcOptions

    • Contents

    CalcOptions Class

    class MsXpS::libXpertMass::CalcOptions

    The CalcOptions class provides the specifications that configure the way masses are calculated for Oligomers, Polymers and product ions. More...

    Header: #include <CalcOptions.hpp>

    Public Functions

    CalcOptions()
    CalcOptions(bool deepCalculation, int massType = MassType::MASS_BOTH, int capping = CAP_BOTH, int monomerEntities = MONOMER_CHEMENT_NONE, int polymerEntities = POLYMER_CHEMENT_NONE)
    CalcOptions(const CalcOptions &other)
    ~CalcOptions()
    int capping() const
    const CoordinateList &coordinateList() const
    void debugPutStdErr() const
    bool isDeepCalculation() const
    int massType() const
    int monomerEntities() const
    int polymerEntities() const
    SelectionType selectionType() const
    void setCapping(int cap_type)
    void setCoordinateList(const Coordinates &coordinates = Coordinates())
    void setCoordinateList(const CoordinateList &list)
    void setDeepCalculation(bool deep)
    void setMassType(int mass_type)
    void setMonomerEntities(int entities)
    void setPolymerEntities(int entities)
    void setSelectionType(SelectionType type)
    CalcOptions &operator=(const CalcOptions &other)

    Protected Variables

    int m_capping
    CoordinateList m_coordinateList
    bool m_deepCalculation
    int m_massType
    int m_monomerEntities
    int m_polymerEntities
    SelectionType m_selectionType

    Detailed Description

    Member Function Documentation

    CalcOptions::CalcOptions()

    Constructs a CalcOptions instance.

    CalcOptions::CalcOptions(bool deepCalculation, int massType = MassType::MASS_BOTH, int capping = CAP_BOTH, int monomerEntities = MONOMER_CHEMENT_NONE, int polymerEntities = POLYMER_CHEMENT_NONE)

    Constructs a CalcOptions instance.

    All the members are initialized using the parameters:

    deepCalculation: m_deepCalculation

    massType: m_massType

    capping: m_capping

    monomerEntities: m_monomerEntities

    polymerEntities: m_polymerEntities

    CalcOptions::CalcOptions(const CalcOptions &other)

    Construct a CalcOptions instance as a copy of other.

    [noexcept] CalcOptions::~CalcOptions()

    Destructs this CalcOptions object.

    All the Coordinates in the member CoordinateList are deleted.

    int CalcOptions::capping() const

    Returns the cap type .

    See also setCapping() and m_capping.

    const CoordinateList &CalcOptions::coordinateList() const

    Returns the CoordinateList member.

    See also setCoordinateList().

    void CalcOptions::debugPutStdErr() const

    Outputs a string describing this CalcOptions instance using qDebug().

    bool CalcOptions::isDeepCalculation() const

    Returns if the calculation should be deep.

    See also m_deepCalculation.

    int CalcOptions::massType() const

    Returns the mass type.

    See also setMassType() and m_massType.

    int CalcOptions::monomerEntities() const

    Returns the monomer entities.

    See also setMonomerEntities() and m_monomerEntities.

    int CalcOptions::polymerEntities() const

    Returns the polymer entities.

    See also setPolymerEntities() and m_polymerEntities.

    SelectionType CalcOptions::selectionType() const

    Returns the selection type.

    See also setSelectionType() and m_selectionType.

    void CalcOptions::setCapping(int cap_type)

    Set the cap type to cap_type.

    See also m_capping.

    void CalcOptions::setCoordinateList(const Coordinates &coordinates = Coordinates())

    Adds a copy of coordinates to the CoordinateList.

    Note: The CoordinateList' is first emptied, essentially replacing its contents with a copy of coordinates.

    See also coordinateList().

    void CalcOptions::setCoordinateList(const CoordinateList &list)

    Allocates a copy of each Coordinates instance in list and adds it to the CoordinateList.

    Note: The CoordinateList is first emptied, essentially replacing its contents with a copy of those in list.

    void CalcOptions::setDeepCalculation(bool deep)

    Sets to deep the configuration defining if the mass calculations must involve the recalculation of the masses of all the monomers.

    See also isDeepCalculation() and m_deepCalculation.

    void CalcOptions::setMassType(int mass_type)

    Sets the mass type to mass_type.

    See also m_massType.

    void CalcOptions::setMonomerEntities(int entities)

    Sets the monomer entities to entities.

    See also m_monomerEntities.

    void CalcOptions::setPolymerEntities(int entities)

    Sets the polymer entities to entities.

    See also m_polymerEntities.

    void CalcOptions::setSelectionType(SelectionType type)

    Set the selection type to type.

    See also m_selectionType.

    CalcOptions &CalcOptions::operator=(const CalcOptions &other)

    Assigns other to this CalcOptions instance.

    The copy is deep, with all the Coordinates in the other's CoordinateList being copied to this CalcOptions instance.

    Returns a reference to this CalcOptions object.

    Member Variable Documentation

    int CalcOptions::m_capping

    This variable holds the cap type, left or right to account for in the calculations.

    See also CapType.

    CoordinateList CalcOptions::m_coordinateList

    This variable holds the list of Coordinates.

    bool CalcOptions::m_deepCalculation

    Tells if the calculations must involve the recalculation of all the masses of the Monomers in the sequence.

    int CalcOptions::m_massType

    This variable holds the mass type, monoisotopic or average to compute.

    See also MassType.

    int CalcOptions::m_monomerEntities

    This variable holds the Monomer entities to account for in the calculations.

    See also MonomerChemEnt.

    int CalcOptions::m_polymerEntities

    This variable holds the Polymer entities to account for in the calculations.

    See also PolymerChemEnt.

    SelectionType CalcOptions::m_selectionType

    This variable holds the manner the monomers need to be accounted for: as residual chains or as finished-polymerization state Oligomers.

    The calculations might consider only the residual chain. In that case, only the mass of the monomers is considered and then the polymer is not in its finished polymerization state. If that latter state is required, then, the residual chain must be capped with the left end cap and the right end cap.

    See also MsXpS::libXpertMass::SelectionType.

    Filippo Rusconi