IonSource.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/METADATA/MetaInfoInterface.h>
 
namespace OpenMS
{
 
  class OPENMS_DLLAPI IonSource :
    public MetaInfoInterface
  {
public:
    enum InletType
    {
      INLETNULL,                           
      DIRECT,                              
      BATCH,                               
      CHROMATOGRAPHY,                      
      PARTICLEBEAM,                        
      MEMBRANESEPARATOR,                   
      OPENSPLIT,                           
      JETSEPARATOR,                        
      SEPTUM,                              
      RESERVOIR,                           
      MOVINGBELT,                          
      MOVINGWIRE,                          
      FLOWINJECTIONANALYSIS,               
      ELECTROSPRAYINLET,                   
      THERMOSPRAYINLET,                    
      INFUSION,                            
      CONTINUOUSFLOWFASTATOMBOMBARDMENT,   
      INDUCTIVELYCOUPLEDPLASMA,            
      MEMBRANE,                            
      NANOSPRAY,                           
      SIZE_OF_INLETTYPE
    };
    static const std::string NamesOfInletType[SIZE_OF_INLETTYPE];
 
    enum IonizationMethod
    {
      IONMETHODNULL,           
      ESI,                     
      EI,                      
      CI,                      
      FAB,                     
      TSP,                     
      LD,                      
      FD,                      
      FI,                      
      PD,                      
      SI,                      
      TI,                      
      API,                     
      ISI,                     
      CID,                     
      CAD,                     
      HN,                      
      APCI,                    
      APPI,                    
      ICP,                     
      NESI,                    
      MESI,                    
      SELDI,                   
      SEND,                    
      FIB,                     
      MALDI,                   
      MPI,                     
      DI,                      
      FA,                      
      FII,                     
      GD_MS,                   
      NICI,                    
      NRMS,                    
      PI,                      
      PYMS,                    
      REMPI,                   
      AI,                      
      ASI,                     
      AD,                      
      AUI,                     
      CEI,                     
      CHEMI,                   
      DISSI,                   
      LSI,                     
      PEI,                     
      SOI,                     
      SPI,                     
      SUI,                     
      VI,                      
      AP_MALDI,                
      SILI,                    
      SALDI,                   
      SIZE_OF_IONIZATIONMETHOD
    };
    static const std::string NamesOfIonizationMethod[SIZE_OF_IONIZATIONMETHOD];
 
    enum Polarity
    {
      POLNULL,          
      POSITIVE,         
      NEGATIVE,         
      SIZE_OF_POLARITY
    };
    static const std::string NamesOfPolarity[SIZE_OF_POLARITY];
 
    IonSource();
    IonSource(const IonSource &) = default;
    IonSource(IonSource&&) = default;
    ~IonSource();
 
    IonSource & operator=(const IonSource &) = default;
    IonSource& operator=(IonSource&&) & = default;
 
    bool operator==(const IonSource & rhs) const;
    bool operator!=(const IonSource & rhs) const;
 
    InletType getInletType() const;
    void setInletType(InletType inlet_type);
 
    IonizationMethod getIonizationMethod() const;
    void setIonizationMethod(IonizationMethod ionization_type);
 
    Polarity getPolarity() const;
    void setPolarity(Polarity polarity);
 
    Int getOrder() const;
    void setOrder(Int order);
 
protected:
    InletType inlet_type_;
    IonizationMethod ionization_method_;
    Polarity polarity_;
    Int order_;
 
  };
 
} // namespace OpenMS