MassAnalyzer.h

Go to the documentation of this file.

// --------------------------------------------------------------------------
//                   OpenMS -- Open-Source Mass Spectrometry
// --------------------------------------------------------------------------
// Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
// ETH Zurich, and Freie Universitaet Berlin 2002-2018.
//
// This software is released under a three-clause BSD license:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of any author or any participating institution
//    may be used to endorse or promote products derived from this software
//    without specific prior written permission.
// For a full list of authors, refer to the file AUTHORS.
// --------------------------------------------------------------------------
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
// INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg $
// $Authors: Marc Sturm $
// --------------------------------------------------------------------------

#pragma once

#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/METADATA/MetaInfoInterface.h>

namespace OpenMS
{
  class OPENMS_DLLAPI MassAnalyzer :
    public MetaInfoInterface
  {
public:
    enum AnalyzerType
    {
      ANALYZERNULL,                                         
      QUADRUPOLE,                                           
      PAULIONTRAP,                                          
      RADIALEJECTIONLINEARIONTRAP,          
      AXIALEJECTIONLINEARIONTRAP,           
      TOF,                                                          
      SECTOR,                                                   
      FOURIERTRANSFORM,                                 
      IONSTORAGE,                                           
      ESA,                                                          
      IT,                                                           
      SWIFT,                                                    
      CYCLOTRON,                                            
      ORBITRAP,                                                 
      LIT,                                                          
      SIZE_OF_ANALYZERTYPE
    };
    static const std::string NamesOfAnalyzerType[SIZE_OF_ANALYZERTYPE];

    enum ResolutionMethod
    {
      RESMETHNULL,                      
      FWHM,                                     
      TENPERCENTVALLEY,             
      BASELINE,                             
      SIZE_OF_RESOLUTIONMETHOD
    };
    static const std::string NamesOfResolutionMethod[SIZE_OF_RESOLUTIONMETHOD];

    enum ResolutionType
    {
      RESTYPENULL,              
      CONSTANT,                     
      PROPORTIONAL,             
      SIZE_OF_RESOLUTIONTYPE
    };
    static const std::string NamesOfResolutionType[SIZE_OF_RESOLUTIONTYPE];

    enum ScanDirection
    {
      SCANDIRNULL,              
      UP,                               
      DOWN,                             
      SIZE_OF_SCANDIRECTION
    };
    static const std::string NamesOfScanDirection[SIZE_OF_SCANDIRECTION];

    enum ScanLaw
    {
      SCANLAWNULL,              
      EXPONENTIAL,              
      LINEAR,                       
      QUADRATIC,                
      SIZE_OF_SCANLAW
    };
    static const std::string NamesOfScanLaw[SIZE_OF_SCANLAW];

    enum ReflectronState
    {
      REFLSTATENULL,            
      ON,                                   
      OFF,                                  
      NONE,                                 
      SIZE_OF_REFLECTRONSTATE
    };
    static const std::string NamesOfReflectronState[SIZE_OF_REFLECTRONSTATE];

    MassAnalyzer();
    MassAnalyzer(const MassAnalyzer & source);
    ~MassAnalyzer();

    MassAnalyzer & operator=(const MassAnalyzer & source);

    bool operator==(const MassAnalyzer & rhs) const;
    bool operator!=(const MassAnalyzer & rhs) const;

    AnalyzerType getType() const;
    void setType(AnalyzerType type);

    ResolutionMethod getResolutionMethod() const;
    void setResolutionMethod(ResolutionMethod resolution_method);

    ResolutionType getResolutionType() const;
    void setResolutionType(ResolutionType resolution_type);

    ScanDirection getScanDirection() const;
    void setScanDirection(ScanDirection scan_direction);

    ScanLaw getScanLaw() const;
    void setScanLaw(ScanLaw scan_law);

    ReflectronState getReflectronState() const;
    void setReflectronState(ReflectronState reflecton_state);

    double getResolution() const;
    void setResolution(double resolution);

    double getAccuracy() const;
    void setAccuracy(double accuracy);

    double getScanRate() const;
    void setScanRate(double scan_rate);

    double getScanTime() const;
    void setScanTime(double scan_time);

    double getTOFTotalPathLength() const;
    void setTOFTotalPathLength(double TOF_total_path_length);

    double getIsolationWidth() const;
    void setIsolationWidth(double isolation_width);

    Int getFinalMSExponent() const;
    void setFinalMSExponent(Int final_MS_exponent);

    double getMagneticFieldStrength() const;
    void setMagneticFieldStrength(double magnetic_field_strength);

    Int getOrder() const;
    void setOrder(Int order);

protected:
    AnalyzerType type_;
    ResolutionMethod resolution_method_;
    ResolutionType resolution_type_;
    ScanDirection scan_direction_;
    ScanLaw scan_law_;
    ReflectronState reflectron_state_;
    double resolution_;
    double accuracy_;
    double scan_rate_;
    double scan_time_;
    double TOF_total_path_length_;
    double isolation_width_;
    Int final_MS_exponent_;
    double magnetic_field_strength_;
    Int order_;
  };
} // namespace OpenMS