MassAnalyzer.h

Go to the documentation of this file.

// Copyright (c) 2002-present, OpenMS Inc. -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg $
// $Authors: Marc Sturm $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/CONCEPT/HashUtils.h>
#include <OpenMS/METADATA/MetaInfoInterface.h>
#include <OpenMS/DATASTRUCTURES/ListUtils.h>
 
#include <functional>
 
namespace OpenMS
{
  class OPENMS_DLLAPI MassAnalyzer :
    public MetaInfoInterface
  {
public:
    enum class AnalyzerType
    {
      ANALYZERNULL,                 
      QUADRUPOLE,                   
      PAULIONTRAP,                  
      RADIALEJECTIONLINEARIONTRAP,  
      AXIALEJECTIONLINEARIONTRAP,   
      TOF,                          
      SECTOR,                       
      FOURIERTRANSFORM,             
      IONSTORAGE,                   
      ESA,                          
      IT,                           
      SWIFT,                        
      CYCLOTRON,                    
      ORBITRAP,                     
      LIT,                          
      SIZE_OF_ANALYZERTYPE
    };
    static const std::string NamesOfAnalyzerType[static_cast<size_t>(AnalyzerType::SIZE_OF_ANALYZERTYPE)];
 
    enum class ResolutionMethod
    {
      RESMETHNULL,                  
      FWHM,                         
      TENPERCENTVALLEY,             
      BASELINE,                     
      SIZE_OF_RESOLUTIONMETHOD
    };
    static const std::string NamesOfResolutionMethod[static_cast<size_t>(ResolutionMethod::SIZE_OF_RESOLUTIONMETHOD)];
 
    enum class ResolutionType
    {
      RESTYPENULL,              
      CONSTANT,                 
      PROPORTIONAL,             
      SIZE_OF_RESOLUTIONTYPE
    };
    static const std::string NamesOfResolutionType[static_cast<size_t>(ResolutionType::SIZE_OF_RESOLUTIONTYPE)];
 
    enum class ScanDirection
    {
      SCANDIRNULL,              
      UP,                       
      DOWN,                     
      SIZE_OF_SCANDIRECTION
    };
    static const std::string NamesOfScanDirection[static_cast<size_t>(ScanDirection::SIZE_OF_SCANDIRECTION)];
 
    enum class ScanLaw
    {
      SCANLAWNULL,              
      EXPONENTIAL,              
      LINEAR,                   
      QUADRATIC,                
      SIZE_OF_SCANLAW
    };
    static const std::string NamesOfScanLaw[static_cast<size_t>(ScanLaw::SIZE_OF_SCANLAW)];
 
    enum class ReflectronState
    {
      REFLSTATENULL,            
      ON,                       
      OFF,                      
      NONE,                     
      SIZE_OF_REFLECTRONSTATE
    };
    static const std::string NamesOfReflectronState[static_cast<size_t>(ReflectronState::SIZE_OF_REFLECTRONSTATE)];
 
    static StringList getAllNamesOfAnalyzerType();
 
    static StringList getAllNamesOfResolutionMethod();
 
    static StringList getAllNamesOfResolutionType();
 
    static StringList getAllNamesOfScanDirection();
 
    static StringList getAllNamesOfScanLaw();
 
    static StringList getAllNamesOfReflectronState();
 
    static const std::string& analyzerTypeToString(AnalyzerType type);
 
    static AnalyzerType toAnalyzerType(const std::string& name);
 
    static const std::string& resolutionMethodToString(ResolutionMethod method);
 
    static ResolutionMethod toResolutionMethod(const std::string& name);
 
    static const std::string& resolutionTypeToString(ResolutionType type);
 
    static ResolutionType toResolutionType(const std::string& name);
 
    static const std::string& scanDirectionToString(ScanDirection direction);
 
    static ScanDirection toScanDirection(const std::string& name);
 
    static const std::string& scanLawToString(ScanLaw law);
 
    static ScanLaw toScanLaw(const std::string& name);
 
    static const std::string& reflectronStateToString(ReflectronState state);
 
    static ReflectronState toReflectronState(const std::string& name);
 
    MassAnalyzer();
    MassAnalyzer(const MassAnalyzer &) = default;
    MassAnalyzer(MassAnalyzer&&) = default;
    ~MassAnalyzer();
 
    MassAnalyzer & operator=(const MassAnalyzer&) = default;
    MassAnalyzer& operator=(MassAnalyzer&&) & = default;
 
    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
 
namespace std
{
  template<>
  struct hash<OpenMS::MassAnalyzer>
  {
    std::size_t operator()(const OpenMS::MassAnalyzer& ma) const noexcept
    {
      std::size_t seed = 0;
 
      // Hash enum fields (cast to underlying integer type)
      OpenMS::hash_combine(seed, OpenMS::hash_int(static_cast<int>(ma.getType())));
      OpenMS::hash_combine(seed, OpenMS::hash_int(static_cast<int>(ma.getResolutionMethod())));
      OpenMS::hash_combine(seed, OpenMS::hash_int(static_cast<int>(ma.getResolutionType())));
      OpenMS::hash_combine(seed, OpenMS::hash_int(static_cast<int>(ma.getScanDirection())));
      OpenMS::hash_combine(seed, OpenMS::hash_int(static_cast<int>(ma.getScanLaw())));
      OpenMS::hash_combine(seed, OpenMS::hash_int(static_cast<int>(ma.getReflectronState())));
 
      // Hash double fields
      OpenMS::hash_combine(seed, OpenMS::hash_float(ma.getResolution()));
      OpenMS::hash_combine(seed, OpenMS::hash_float(ma.getAccuracy()));
      OpenMS::hash_combine(seed, OpenMS::hash_float(ma.getScanRate()));
      OpenMS::hash_combine(seed, OpenMS::hash_float(ma.getScanTime()));
      OpenMS::hash_combine(seed, OpenMS::hash_float(ma.getTOFTotalPathLength()));
      OpenMS::hash_combine(seed, OpenMS::hash_float(ma.getIsolationWidth()));
      OpenMS::hash_combine(seed, OpenMS::hash_float(ma.getMagneticFieldStrength()));
 
      // Hash integer fields
      OpenMS::hash_combine(seed, OpenMS::hash_int(ma.getFinalMSExponent()));
      OpenMS::hash_combine(seed, OpenMS::hash_int(ma.getOrder()));
 
      return seed;
    }
  };
} // namespace std