PTE.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: PTE.h,v 1.30.16.1 2007/03/25 21:23:42 oliver Exp $
//

#ifndef BALL_KERNEL_PTE_H
#define BALL_KERNEL_PTE_H

#ifndef BALL_COMMON_CREATE_H
# include <BALL/COMMON/create.h>
#endif

#ifndef BALL_DATATYPE_STRING_H
# include <BALL/DATATYPE/string.h>
#endif

#ifndef BALL_CONCEPT_PROCESSOR_H
# include <BALL/CONCEPT/processor.h>
#endif

#define BALL_ELEMENT_NAME_DEFAULT                "Unknown"
#define BALL_ELEMENT_SYMBOL_DEFAULT              "?"
#define BALL_ELEMENT_GROUP_DEFAULT               0
#define BALL_ELEMENT_PERIOD_DEFAULT              0
#define BALL_ELEMENT_ATOMICNUMBER_DEFAULT        0
#define BALL_ELEMENT_ATOMICWEIGHT_DEFAULT        0
#define BALL_ELEMENT_ATOMICRADIUS_DEFAULT        0
#define BALL_ELEMENT_COVALENTRADIUS_DEFAULT      0
#define BALL_ELEMENT_VANDERWAALSRADIUS_DEFAULT   0
#define BALL_ELEMENT_ELECTRONEGATIVITY_DEFAULT   0
#define BALL_ELEMENT_IS_METAL_DEFAULT            false


namespace BALL 
{

  class BALL_EXPORT Element
  {
    public:

      BALL_CREATE(Element)

      
      typedef short Group;

      typedef short Period;

      typedef short AtomicNumber;

      enum Name
      {
        ACTINIUM = 0,
        ALUMINUM,
        AMERICIUM,
        ANTIMONY, STIBIUM = ANTIMONY,
        ARGON,
        ARSENIC,
        ASTATINE,
        BARIUM,
        BERKELIUM,
        BERYLLIUM,
        BISMUTH, WISMUT = BISMUTH,
        BOHRIUM,
        BORON,
        BROMINE,
        CADMIUM,
        CAESIUM,
        CALCIUM,
        CALIFORNIUM,
        CARBON, CARBONEUM = CARBON,
        CERIUM,
        CHLORINE,
        CHROMIUM,
        COBALT,
        COPPER, CUPRUM = COPPER,
        CURIUM,
        DUBNIUM,
        DYSPROSIUM,
        EINSTEINIUM,
        ERBIUM,
        EUROPIUM,
        FERMIUM,
        FLUORINE,
        FRANCIUM,
        GADOLINIUM,
        GALLIUM,
        GERMANIUM,
        GOLD, AURUM = GOLD,
        HAFNIUM,
        HAHNIUM,
        HELIUM,
        HOLMIUM,
        HYDROGEN, HYDROGENIUM = HYDROGEN,
        INDIUM,
        IODINE, JOD = IODINE,
        IRIDIUM,
        IRON, FERRUM = IRON,
        JOLIOTIUM,
        KRYPTON,
        LANTHANUM,
        LAWRENCIUM,
        LEAD, PLUMBUM = LEAD,
        LITHIUM,
        LUTETIUM,
        MAGNESIUM,
        MANGANESE, MANGAN = MANGANESE,
        MEITNERIUM,
        MENDELEVIUM,
        MERCURY, HYDRARGYRUM = MERCURY, MERCURIUM = MERCURY,
        MOLYBDENUM,
        NEODYMIUM,
        NEON,
        NEPTUNIUM,
        NICKEL,
        NIOBIUM,
        NITROGEN, NITROGENIUM = NITROGEN,
        NOBELIUM,
        OSMIUM,
        OXYGEN, OXYGENIUM = OXYGEN,
        PALLADIUM,
        PHOSPHORUS,
        PLATINUM,
        PLUTONIUM,
        POLONIUM,
        POTASSIUM, KALIUM = POTASSIUM,
        PRASEODYMIUM,
        PROMETHIUM,
        PROTACTINIUM,
        RADIUM,
        RADON,
        RHENIUM,
        RHODIUM,
        RUBIDIUM,
        RUTHENIUM,
        RUTHERFORDIUM,
        SAMARIUM,
        SCANDIUM,
        SELENIUM,
        SILICON, SILICIUM = SILICON,
        SILVER, ARGENTUM = SILVER,
        SODIUM, NATRIUM = SODIUM,
        STRONTIUM,
        SULPHUR, SULFUR = SULPHUR,
        TANTALUM,
        TECHNETIUM,
        TELLURIUM,
        TERBIUM,
        THALLIUM,
        THORIUM,
        THULIUM,
        TIN, STANNUM = TIN,
        TITANIUM,
        TUNGSTEN, WOLFRAM = TUNGSTEN,
        UNUNBIUM,
        UNUNNILIUM,
        UNUNNINIUM,
        URANIUM,
        VANADIUM,
        XENON,
        YTTERBIUM,
        YTTRIUM,
        ZINC, ZINCUM = ZINC,
        ZIRCONIUM,
        
        NUMBER_OF_ELEMENTS //  111
      };

      enum Symbol
      {
        Ac = 0,
        Al,
        Am,
        Sb,
        Ar,
        As,
        At,
        Ba,
        Bk,
        Be,
        Bi,
        Bh,
        B,
        Br,
        Cd,
        Cs,
        Ca,
        Cf,
        C,
        Ce,
        Cl,
        Cr,
        Co,
        Cu,
        Cm,
        Db,
        Dy,
        Es,
        Er,
        Eu,
        Fm,
        F,
        Fr,
        Gd,
        Ga,
        Ge,
        Au,
        Hf,
        Hn,
        He,
        Ho,
        H,
        In,
        I,
        Ir,
        Fe,
        Jl,
        Kr,
        La,
        Lr,
        Pb,
        Li,
        Lu,
        Mg,
        Mn,
        Mt,
        Md,
        Hg,
        Mo,
        Nd,
        Ne,
        Np,
        Ni,
        Nb,
        N,
        No,
        Os,
        O,
        Pd,
        P,
        Pt,
        Pu,
        Po,
        K,
        Pr,
        Pm,
        Pa,
        Ra,
        Rn,
        Re,
        Rh,
        Rb,
        Ru,
        Rf,
        Sm,
        Sc,
        Se,
        Si,
        Ag,
        Na,
        Sr,
        S,
        Ta,
        Tc,
        Te,
        Tb,
        Tl,
        Th,
        Tm,
        Sn,
        Ti,
        W,
        Uub,
        Uun,
        Uuu,
        U,
        V,
        Xe,
        Yb,
        Y,
        Zn,
        Zr
      };

      
      Element();

      Element(const Element& element);

      Element
        (const String& name,
         const String& symbol,
         Group group,
         Period period,
         AtomicNumber atomic_umber,
         float atomic_weight,
         float atomic_radius,
         float covalent_radius,
         float van_der_waals_radius,
         bool is_metal,
         float electronegativity);

      virtual ~Element();

      virtual void clear();
      


      Element& operator = (const Element& element);


    
      void setName(const String& name);

      const String& getName() const;

      void setSymbol(const String& symbol);

      const String& getSymbol() const;

      void setGroup(Group group);

      Group getGroup() const;

      void setPeriod(Period period);

      Period getPeriod() const;

      void setAtomicNumber(AtomicNumber atomic_number);

      AtomicNumber getAtomicNumber() const;

      void setAtomicWeight(float atomic_weight);

      float getAtomicWeight() const;

      void setAtomicRadius(float atomic_radius);

      float getAtomicRadius() const;

      void setCovalentRadius(float covalent_radius);

      float getCovalentRadius() const;

      void setVanDerWaalsRadius(float van_der_waals_radius);

      float getVanDerWaalsRadius() const;

      void setElectronegativity(float electronegativity);

      float getElectronegativity() const;



      bool operator == (const Element& element) const;

      bool operator != (const Element& element) const;

      bool operator < (const Element& element) const;

      bool operator <= (const Element& element) const;

      bool operator >= (const Element& element) const;

      bool operator >(const Element& element) const;

      BALL_EXPORT
      friend std::ostream& operator << (std::ostream& s, const Element& element);



      bool isUnknown() const;

      bool isMetal() const;


      static Element UNKNOWN;


    private:

      String name_;

      String symbol_;

      Group   group_;

      Period  period_;

      AtomicNumber atomic_number_;

      float atomic_weight_;
    
      float atomic_radius_;

      float  covalent_radius_;

      float van_der_waals_radius_;

      bool is_metal_;

      float electronegativity_;
  };


  BALL_EXPORT
  std::ostream& operator << (std::ostream& s, const Element& element);


  class BALL_EXPORT PTE_
  {
    public:

      BALL_CREATE(PTE_)

      

      PTE_();

      PTE_(const PTE_& pse);

      virtual ~PTE_();

      virtual void clear();


    
      PTE_& operator = (const PTE_& /*pte*/);
      


      static Element& getElement(Position atomic_number);
    
      static Element& getElement(const String& symbol);


    
      bool operator == (const PTE_& pte) const;

      Element& operator [] (const String& symbol);

      const Element& operator [] (const String& symbol) const;

      Element& operator [] (Element::Name name);

      const Element& operator [] (Element::Name name) const;

      Element& operator [] (Element::Symbol symbol);

      const Element& operator [] (Element::Symbol symbol) const;

      Element& operator [] (Position position);

      const Element& operator [] (Position position) const;


    
      static bool apply(UnaryProcessor<Element>& applicator);


      struct SymbolToElement
      {
        const char* symbol;

        Element*    element;
      };

    private:

      static Element element_[];

      static SymbolToElement symbol_to_element_[];

      static Element* atomic_number_to_element_[];
  };


  BALL_EXPORT extern PTE_ PTE;



# ifndef BALL_NO_INLINE_FUNCTIONS
#   include <BALL/KERNEL/PTE.iC>
# endif
} //namespace BALL 


#endif // BALL_KERNEL_PTE_H