KVNucleus.h

/***************************************************************************
$Id: KVNucleus.h,v 1.40 2009/04/02 09:32:55 ebonnet Exp $
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef KVNUCLEUS_H
#define KVNUCLEUS_H
 
#include <optional>
#include "TVector3.h"
#include "KVParticle.h"
#include "KVNumberList.h"
#include "tknucleus.h"
 
class KVNucleus: public KVParticle {
 
 
private:
    UChar_t fA;
    UChar_t fZ;
    UChar_t fMassFormula;
    mutable TString fSymbolName;
 
   enum {
      kIsHeavy = BIT(17)        //flag when mass of nucleus is > 255
   };
 
public:
   enum {                       //determines how to calculate mass from Z
      kBetaMass,
      kVedaMass,
      kEALMass,
      kEALResMass,
      kEPAXMass
   };
   enum {                       //determines how to calculate radius from Mass
      kLDModel,
      kEMPFunc,
      kELTON
   };
 
   enum {
      kDefaultFormula,
      kItkis1998,
      kHinde1987,
      kViola1985,
      kViola1966
   };
 
   enum {
      kNN,
      knn,
      kpp,
      knp
   };
 
    static Double_t kAMU;
    static Double_t kMe;
   static Double_t u(void);
    static Double_t hbar;
    static Double_t e2;
 
   inline void SetMassFormula(UChar_t mt);
   inline Int_t GetMassFormula() const
   {
      return (Int_t)fMassFormula;
   }
 
   void init();
   KVNucleus();
   KVNucleus(const KVNucleus&);
   void Clear(Option_t* opt = "") override;
   KVNucleus(Int_t z, Int_t a = 0, Double_t ekin = 0);
   KVNucleus(Int_t z, Double_t t, const TVector3& p);
   KVNucleus(Int_t z, Int_t a, const TVector3& p);
   KVNucleus(const Char_t*, Double_t EperA = 0);
 
   void Copy(TObject&) const override;
   Bool_t IsSortable() const override
   {
      return kTRUE;
   }
   Int_t Compare(const TObject* obj) const override;
   Bool_t IsDefined() const
   {
      return !(fZ == 0 && fA == 0);
   }
 
   virtual ~ KVNucleus();
   static Int_t GetAFromZ(Double_t, Char_t mt);
   static Int_t GetNFromZ(Double_t, Char_t mt);
   static Double_t GetRealAFromZ(Double_t, Char_t mt);
   static Double_t GetRealNFromZ(Double_t, Char_t mt);
   const Char_t* GetSymbol(Option_t* opt = "") const;
   const Char_t* GetLatexSymbol(Option_t* opt = "") const;
 
   static Int_t GetZFromSymbol(const Char_t*);
   int SetZFromSymbol(const Char_t*);
   void Set(const Char_t*);
   static Int_t IsMassGiven(const Char_t*);
 
   void SetZ(Int_t z, Char_t mt = -1);
   void SetA(Int_t a);
   void SetN(Int_t n);
   void SetZandA(Int_t z, Int_t a);
   void SetZandN(Int_t z, Int_t n);
   void SetZAandE(Int_t z, Int_t a, Double_t ekin);
 
   void Print(Option_t* t = "") const override;
   Int_t GetZ() const;
   Int_t GetA() const;
   Int_t GetN() const;
 
   Int_t GetNpairs(Int_t type = kNN) const;
 
   Double_t GetAsurZ() const
   {
      return Double_t(GetA()) / GetZ();
   }
   Double_t GetNsurZ() const
   {
      return Double_t(GetN()) / GetZ();
   }
   Double_t GetChargeAsymmetry() const
   {
      return Double_t(GetN() - GetZ()) / GetA();
   }
   Double_t GetEnergyPerNucleon() const;
   Double_t GetAMeV() const;
 
   void CheckZAndA(std::optional<Int_t>& z, std::optional<Int_t>& a) const;
 
   Double_t GetMassExcess(std::optional<int> z = {}, std::optional<int> a = {}) const;
   Double_t GetExtraMassExcess(std::optional<int> z = {}, std::optional<int> a = {}) const;
   Double_t GetAtomicMass(std::optional<int> z = {}, std::optional<int> a = {}) const ;
   Double_t GetNaturalA(std::optional<int> z = {}) const ;
 
   Double_t GetBindingEnergy(std::optional<int> z = {}, std::optional<int> a = {}) const;
   Double_t GetLiquidDropBindingEnergy(std::optional<int> z = {}, std::optional<int> a = {}) const;
   Double_t GetBindingEnergyPerNucleon(std::optional<int> z = {}, std::optional<int> a = {}) const;
 
   Double_t LiquidDrop_Weizsacker();
 
   KVNumberList GetKnownARange(std::optional<int> z = {}, std::optional<double> tmin = {}) const;
   KVNumberList GetMeasuredARange(std::optional<int> z = {}) const;
   const Char_t* GetIsotopesList(Int_t zmin, Int_t zmax, std::optional<double> tmin = {}) const;
   Int_t GetAWithMaxBindingEnergy(std::optional<int> z = {});
 
   static Double_t LiquidDrop_BrackGuet(UInt_t A, UInt_t Z);
 
   Bool_t IsKnown(std::optional<int> z = {}, std::optional<int> a = {}) const;
   Bool_t IsStable(Double_t min_lifetime = 1.0e+15/*seconds*/) const;
   Bool_t IsResonance(std::optional<int> z = {}, std::optional<int> a = {}) const;
   std::optional<double> GetWidth(std::optional<int> z = {}, std::optional<int> a = {}) const;
 
   void SetExcitEnergy(Double_t e);
 
   Double_t GetExcitEnergy() const
   {
      return GetMass() - GetMassGS();
   }
   Double_t GetMassGS() const
   {
      return (kAMU * GetA() + GetMassExcess());
   }
 
   tkn::tknucleus GetTkNucleus(std::optional<int> z = {}, std::optional<int> a = {}) const;
 
   std::optional<double> GetLifeTime(std::optional<int> z = {}, std::optional<int> a = {}) const;
   std::optional<double> GetSpin(std::optional<int> z = {}, std::optional<int> a = {}) const;
   std::optional<int> GetParity(std::optional<int> z = {}, std::optional<int> a = {}) const;
   std::optional<double> GetAbundance(std::optional<int> z = {}, std::optional<int> a = {}) const;
   std::optional<int> GetMostAbundantA(std::optional<int> z = {}) const;
   Double_t GetChargeRadius(std::optional<int> z = {}, std::optional<int> a = {}) const;
   Double_t GetExtraChargeRadius(std::optional<int> a = {}, Int_t rct = 2) const;
 
   KVNucleus& operator=(const KVNucleus& rhs);
   KVNucleus operator+(const KVNucleus& rhs);
   KVNucleus operator-(const KVNucleus& rhs);
   KVNucleus& operator+=(const KVNucleus& rhs);
   KVNucleus& operator-=(const KVNucleus& rhs);
 
   Double_t DeduceEincFromBrho(Double_t Brho, Int_t ChargeState = 0);
   Double_t GetRelativeVelocity(KVNucleus* nuc);
   Double_t GetFissionTKE(const KVNucleus* nuc = 0, Int_t formula = kDefaultFormula) const;
   Double_t GetQFasymTKE(KVNucleus* target);
   Double_t GetFissionVelocity(KVNucleus* nuc = 0, Int_t formula = kDefaultFormula);
 
   static Double_t TKE_Hinde1987(Double_t z1, Double_t a1, Double_t z2, Double_t a2);
   static Double_t TKE_Viola1985(Double_t z, Double_t a);
   static Double_t TKE_Viola1966(Double_t z, Double_t a);
   static Double_t TKE_Itkis1998(Double_t z, Double_t a);
   static Double_t TKE_Kozulin2014(Double_t zp, Double_t zt, Double_t ap, Double_t at);
 
   Bool_t IsElement(Int_t Z) const
   {
      return GetZ() == Z;
   }
   Bool_t IsIsotope(Int_t Z, Int_t A) const
   {
      return (GetZ() == Z && GetA() == A);
   }
 
   Double_t ShimaChargeState(Int_t) const;
   Double_t ShimaChargeStatePrecision() const;
 
   ClassDefOverride(KVNucleus, 7)      //Class describing atomic nuclei
};
 
inline void KVNucleus::SetMassFormula(UChar_t mt)
{
   fMassFormula = mt;
   SetA(GetAFromZ(GetZ(), fMassFormula));       //recalculate A and mass
}
 
#endif