Pion 0.0.2

Simple particle physics library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117


#[derive(Debug,Copy,Clone)]
pub enum Lepton{
     Electron(f64),
     Muon(f64), 
     Tau(f64),
     ElectronNeutrino(f64),
     MuNeutrino(f64),
     TauNeutrino(f64),
}
#[derive(Debug,Copy,Clone)]
pub enum AntiLepton{
     Electron(f64),
     Muon(f64), 
     Tau(f64),
     ElectronNeutrino(f64),
     MuNeutrino(f64),
     TauNeutrino(f64),
}

 impl Lepton{
               ///rest mass in MeV
   pub const fn rest_mass(&self)->f64{
   
    match self {
        Lepton::Electron(_) => 0.510998950,
        Lepton::Muon(_)     => 105.6583755,
        Lepton::Tau(_)      => 1776.86,
        Lepton::ElectronNeutrino(_) => 0f64,
        Lepton::MuNeutrino(_)       => 0f64,
        Lepton::TauNeutrino(_)      => 0f64,
        }
    }
    
    
 
  pub  fn rest_mass_kg(&self)->f64{
      self.rest_mass()*1.79E-30
    }
    
  pub const  fn kinetic(&self)->f64{
       match self {
        Lepton::Electron(x) => *x,
        Lepton::Muon(x)     => *x,
        Lepton::Tau(x)      => *x,
        Lepton::ElectronNeutrino(x) => *x,
        Lepton::MuNeutrino(x)       => *x,
        Lepton::TauNeutrino(x)      => *x,
        }
  }
 
    
 
  pub fn momentum(&self)->f64{
       self.rest_mass()*self.kinetic() / (1.0 - (self.kinetic()*self.kinetic())/89875517873681764f64).sqrt()
    }
    
 pub const fn charge(&self)->f64{
        match self {
        Lepton::Electron(_) => -1f64,
        Lepton::Muon(_)     => -1f64,
        Lepton::Tau(_)      => -1f64,
        Lepton::ElectronNeutrino(_) => 0f64,
        Lepton::MuNeutrino(_)       => 0f64,
        Lepton::TauNeutrino(_)      => 0f64,
        }
 }   
 }
 
 
 impl AntiLepton{
        ///rest mass in MeV
   pub const fn rest_mass(&self)->f64{
   
    match self {
        AntiLepton::Electron(_) => 0.510998950,
        AntiLepton::Muon(_)     => 105.6583755,
        AntiLepton::Tau(_)      => 1776.86,
        AntiLepton::ElectronNeutrino(_) => 0f64,
        AntiLepton::MuNeutrino(_)       => 0f64,
        AntiLepton::TauNeutrino(_)      => 0f64,
        }
    }
    
    
 
  pub fn rest_mass_kg(&self)->f64{
      self.rest_mass()*1.79E-30
    }
    
  pub const fn kinetic(&self)->f64{
       match self {
        AntiLepton::Electron(x) => *x,
        AntiLepton::Muon(x)     => *x,
        AntiLepton::Tau(x)      => *x,
        AntiLepton::ElectronNeutrino(x) => *x,
        AntiLepton::MuNeutrino(x)       => *x,
        AntiLepton::TauNeutrino(x)      => *x,
        }
  }
 
 pub const fn charge(&self)->f64{
        match self {
        AntiLepton::Electron(_) => 1f64,
        AntiLepton::Muon(_)     => 1f64,
        AntiLepton::Tau(_)      => 1f64,
        AntiLepton::ElectronNeutrino(_) => 0f64,
        AntiLepton::MuNeutrino(_)       => 0f64,
        AntiLepton::TauNeutrino(_)      => 0f64,
        }
 }   
 
  pub  fn momentum(&self)->f64{
       self.rest_mass()*self.kinetic() / (1.0 - (self.kinetic()*self.kinetic())/89875517873681764f64).sqrt()
    }
 }