IonDetector.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>
#include <OpenMS/DATASTRUCTURES/ListUtils.h>
#include <OpenMS/CONCEPT/HashUtils.h>
#include <functional>
 
namespace OpenMS
{
  class OPENMS_DLLAPI IonDetector :
    public MetaInfoInterface
  {
public:
    enum class Type
    {
      TYPENULL,                                  
      ELECTRONMULTIPLIER,                        
      PHOTOMULTIPLIER,                           
      FOCALPLANEARRAY,                           
      FARADAYCUP,                                
      CONVERSIONDYNODEELECTRONMULTIPLIER,        
      CONVERSIONDYNODEPHOTOMULTIPLIER,           
      MULTICOLLECTOR,                            
      CHANNELELECTRONMULTIPLIER,                 
      CHANNELTRON,                               
      DALYDETECTOR,                              
      MICROCHANNELPLATEDETECTOR,                 
      ARRAYDETECTOR,                             
      CONVERSIONDYNODE,                          
      DYNODE,                                    
      FOCALPLANECOLLECTOR,                       
      IONTOPHOTONDETECTOR,                       
      POINTCOLLECTOR,                            
      POSTACCELERATIONDETECTOR,                  
      PHOTODIODEARRAYDETECTOR,                   
      INDUCTIVEDETECTOR,                         
      ELECTRONMULTIPLIERTUBE,                    
      SIZE_OF_TYPE
    };
    static const std::string NamesOfType[static_cast<size_t>(Type::SIZE_OF_TYPE)];
 
    enum class AcquisitionMode
    {
      ACQMODENULL,             
      PULSECOUNTING,           
      ADC,                     
      TDC,                     
      TRANSIENTRECORDER,       
      SIZE_OF_ACQUISITIONMODE
    };
    static const std::string NamesOfAcquisitionMode[static_cast<size_t>(AcquisitionMode::SIZE_OF_ACQUISITIONMODE)];
 
    static StringList getAllNamesOfType();
 
    static StringList getAllNamesOfAcquisitionMode();
 
    static const std::string& typeToString(Type type);
 
    static Type toType(const std::string& name);
 
    static const std::string& acquisitionModeToString(AcquisitionMode mode);
 
    static AcquisitionMode toAcquisitionMode(const std::string& name);
 
    IonDetector();
    IonDetector(const IonDetector &) = default;
    IonDetector(IonDetector&&) = default;
    ~IonDetector();
 
    IonDetector & operator=(const IonDetector &) = default;
    IonDetector& operator=(IonDetector&&) & = default;
 
    bool operator==(const IonDetector & rhs) const;
    bool operator!=(const IonDetector & rhs) const;
 
    Type getType() const;
    void setType(Type type);
 
    AcquisitionMode getAcquisitionMode() const;
    void setAcquisitionMode(AcquisitionMode acquisition_mode);
 
    double getResolution() const;
    void setResolution(double resolution);
 
    double getADCSamplingFrequency() const;
    void setADCSamplingFrequency(double ADC_sampling_frequency);
 
    Int getOrder() const;
    void setOrder(Int order);
 
protected:
    Type type_;
    AcquisitionMode acquisition_mode_;
    double resolution_;
    double ADC_sampling_frequency_;
    Int order_;
 
  };
} // namespace OpenMS
 
namespace std
{
  template<>
  struct hash<OpenMS::IonDetector>
  {
    std::size_t operator()(const OpenMS::IonDetector& d) const noexcept
    {
      std::size_t seed = OpenMS::hash_int(static_cast<int>(d.getType()));
      OpenMS::hash_combine(seed, OpenMS::hash_int(static_cast<int>(d.getAcquisitionMode())));
      OpenMS::hash_combine(seed, OpenMS::hash_float(d.getResolution()));
      OpenMS::hash_combine(seed, OpenMS::hash_float(d.getADCSamplingFrequency()));
      OpenMS::hash_combine(seed, OpenMS::hash_int(d.getOrder()));
      return seed;
    }
  };
} // namespace std