AtomicWeight
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                            Atomic Weight                         //
//                                                                  //
//          Z : atomic number                                       //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double AtomicWeight(int Z)

ElementDensity
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                       Density of the pure element                //
//                         under standard conditions                //
//                                                                  //
//          Z : atomic number                                       //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double ElementDensity(int Z)

CosKronTransProb
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                    Coster-Kronig transition probability          //
//          Z : atomic number                                       //
//          transition type :                                       //
//            F1_TRANS  0                                           //
//            F12_TRANS 1                                           //
//            F13_TRANS 2                                           //
//            FP13_TRANS 3                                          //
//            F23_TRANS 4                                           //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CosKronTransProb(int Z, int trans)

CS_FluorLine
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                    Fluorescent line cross section (cm2/g)        //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)
//          line :                                                  //
//            KA_LINE 0                                             //
//            KB_LINE 1                                             //
//            LA_LINE 2                                             //
//            LB_LINE 3                                             //
//            LG_LINE 4                                             //
//            LB2_LINE 5                                            //
//            MA_LINE 6                                             //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CS_FluorLine(int Z, int line, double E)

EdgeEnergy
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                    Absorption edge energy (keV)                  //
//                                                                  //
//          Z : atomic number                                       //
//          shell :                                                 //
//            K_SHELL  0                                            //
//            L1_SHELL 1                                            //
//            L2_SHELL 2                                            //
//            L3_SHELL 3                                            //
//            M1_SHELL 4                                            //
//            M2_SHELL 5                                            //
//            M3_SHELL 6                                            //
//            M4_SHELL 7                                            //
//            M5_SHELL 8                                            //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double EdgeEnergy(int Z, int shell)

LineEnergy
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                    Fluorescent line energy (keV)                 //
//                                                                  //
//          Z : atomic number                                       //
//          line :                                                  //
//            KA_LINE 0                                             //
//            KB_LINE 1                                             //
//            LA_LINE 2                                             //
//            LB_LINE 3                                             //
//            LG_LINE 4                                             //
//            LB2_LINE 5                                            //
//            MA_LINE 6                                             //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double LineEnergy(int Z, int line)

FluorYield
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                    Fluorescent Yield                             //
//                                                                  //
//          Z : atomic number                                       //
//          shell :                                                 //
//            K_SHELL  0                                            //
//            L1_SHELL 1                                            //
//            L2_SHELL 2                                            //
//            L3_SHELL 3                                            //
//            M1_SHELL 4                                            //
//            M2_SHELL 5                                            //
//            M3_SHELL 6                                            //
//            M4_SHELL 7                                            //
//            M5_SHELL 8                                            //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double FluorYield(int Z, int shell)

JumpFactor
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                    Jump Ratio                                    //
//                                                                  //
//          Z : atomic number                                       //
//          shell :                                                 //
//            K_SHELL  0                                            //
//            L1_SHELL 1                                            //
//            L2_SHELL 2                                            //
//            L3_SHELL 3                                            //
//            M1_SHELL 4                                            //
//            M2_SHELL 5                                            //
//            M3_SHELL 6                                            //
//            M4_SHELL 7                                            //
//            M5_SHELL 8                                            //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double JumpFactor(int Z, int shell)

DCSP_Rayl
//////////////////////////////////////////////////////////////////////
//                                                                  //
//         Differential Rayleigh scattering cross section           // 
//                for polarized beam (cm2/g/sterad)                 //
//                                                                  //
//          Z : atomic number                                       //
//          E : Energy (keV)                                        //
//          theta : scattering polar angle (rad)                    //
//          phi : scattering azimuthal angle (rad)                  //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double DCSP_Rayl(int Z, double E, double theta, double phi)

DCSP_Compt
//////////////////////////////////////////////////////////////////////
//                                                                  //
//           Differential Compton scattering cross section          //
//                for polarized beam (cm2/g/sterad)                 //
//          Z : atomic number                                       //
//          E : Energy (keV)                                        //
//          theta : scattering polar angle (rad)                    //
//          phi : scattering azimuthal angle (rad)                  //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double DCSP_Compt(int Z, double E, double theta, double phi)

DCSP_KN
//////////////////////////////////////////////////////////////////////
//                                                                  //
//      Klein-Nishina differential scattering cross section         // 
//                for polarized beam (barn/atom/sterad)             //
//                                                                  //
//          E : Energy (keV)                                        //
//          theta : scattering polar angle (rad)                    //
//          phi : scattering azimuthal angle (rad)                  //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double DCSP_KN(double E, double theta, double phi)

DCSP_Thoms
//////////////////////////////////////////////////////////////////////
//                                                                  //
//       Thomson differential scattering cross section              //
//                for polarized beam (barn/atom/sterad)             //
//                                                                  //
//          theta : scattering polar angle (rad)                    //
//          phi : scattering azimuthal angle (rad)                  //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double DCSP_Thoms(double theta, double phi)

RadRate
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                    Fractional Radiative Rate                     //
//                                                                  //
//          Z : atomic number                                       //
//          line :                                                  //
//            KA_LINE 0                                             //
//            KB_LINE 1                                             //
//            LA_LINE 2                                             //
//            LB_LINE 3                                             //
//            LG_LINE 4                                             //
//            LB2_LINE 5                                            //
//            MA_LINE 6                                             //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double RadRate(int Z, int line)

FF_Rayl
//////////////////////////////////////////////////////////////////////
//                                                                  //
//          Atomic form factor for Rayleigh scattering              //
//                                                                  //
//          Z : atomic number                                       //
//          q : momentum transfer                                   //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double FF_Rayl(int Z, double q)

SF_Compt
//////////////////////////////////////////////////////////////////////
//                                                                  //
//       Incoherent scattering function for Compton scattering      //
//                                                                  //
//          Z : atomic number                                       //
//          q : momentum transfer                                   //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double SF_Compt(int Z, double q)

DCS_Thoms
//////////////////////////////////////////////////////////////////////
//                                                                  //
// Thomson differential scattering cross section (barn/atom/sterad) //
//                                                                  //
//          theta : scattering polar angle (rad)                    //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double DCS_Thoms(double theta)

DCS_KN
//////////////////////////////////////////////////////////////////////
//                                                                  //
// Klein-Nishina differential scatt cross sect (barn/atom/sterad)   //
//                                                                  //
//          E : Energy (keV)                                        //
//          theta : scattering polar angle (rad)                    //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double DCS_KN(double E, double theta)

DCS_Rayl
//////////////////////////////////////////////////////////////////////
//                                                                  //
//  Differential Rayleigh scattering cross section (cm2/g/sterad)   //
//                                                                  //
//          Z : atomic number                                       //
//          E : Energy (keV)                                        //
//          theta : scattering polar angle (rad)                    //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double DCS_Rayl(int Z, double E, double theta)

DCS_Compt
//////////////////////////////////////////////////////////////////////
//                                                                  //
//  Differential Compton scattering cross section (cm2/g/sterad)    //
//                                                                  //
//          Z : atomic number                                       //
//          E : Energy (keV)                                        //
//          theta : scattering polar angle (rad)                    //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double DCS_Compt(int Z, double E, double theta)

MomentTransf
//////////////////////////////////////////////////////////////////////
//                                                                  //
//    Momentum transfer for X-ray photon scattering (angstrom-1)    //
//                                                                  //
//          E : Energy (keV)                                        //
//          theta : scattering polar angle (rad)                    //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double MomentTransf(double E, double theta)

CS_KN
//////////////////////////////////////////////////////////////////////
//                                                                  //
//            Total klein-Nishina cross section (barn/atom)         //
//                                                                  //
//          E : Energy (keV)                                        //   
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CS_KN(double E)

ComptonEnergy
//////////////////////////////////////////////////////////////////////
//                                                                  //
//              Photon energy after Compton scattering (keV)        //
//                                                                  //
//          E0 : Photon Energy before scattering (keV)              //   
//          theta : scattering polar angle (rad)                    //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double ComptonEnergy(double E0, double theta)

CS_Total
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                  Total cross section  (cm2/g)                    //
//               (Photoelectric + Compton + Rayleigh)               //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CS_Total(int Z, double E)

CS_Photo
//////////////////////////////////////////////////////////////////////
//                                                                  //
//         Photoelectric absorption cross section  (cm2/g)          //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CS_Photo(int Z, double E)

CS_Rayl
//////////////////////////////////////////////////////////////////////
//                                                                  //
//            Rayleigh scattering cross section  (cm2/g)            //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CS_Rayl(int Z, double E)

CS_Compt
//////////////////////////////////////////////////////////////////////
//                                                                  //
//            Compton scattering cross section  (cm2/g)             //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CS_Compt(int Z, double E) 

CSb_FluorLine
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                    Fluorescent line cross section (barn/atom)    //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//          line :                                                  //
//            KA_LINE 0                                             //
//            KB_LINE 1                                             //
//            LA_LINE 2                                             //
//            LB_LINE 3                                             //
//            LG_LINE 4                                             //
//            LB2_LINE 5                                            //
//            MA_LINE 6                                             //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CSb_FluorLine(int Z, int line, double E)

CSb_Total
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                  Total cross section  (barn/atom)                //
//               (Photoelectric + Compton + Rayleigh)               //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CSb_Total(int Z, double E)

CSb_Photo
//////////////////////////////////////////////////////////////////////
//                                                                  //
//         Photoelectric absorption cross section  (barn/atom)      //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CSb_Photo(int Z, double E)

CSb_Rayl
//////////////////////////////////////////////////////////////////////
//                                                                  //
//            Rayleigh scattering cross section  (barn/atom)        //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CSb_Rayl(int Z, double E)

CSb_Compt
//////////////////////////////////////////////////////////////////////
//                                                                  //
//            Compton scattering cross section  (barn/atom)         //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CSb_Compt(int Z, double E) 

DCSb_Rayl
//////////////////////////////////////////////////////////////////////
//                                                                  //
//  Differential Rayleigh scattering cross sect (barn/atom/sterad)  //
//                                                                  //
//          Z : atomic number                                       //
//          E : Energy (keV)                                        //
//          theta : scattering polar angle (rad)                    //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double DCSb_Rayl(int Z, double E, double theta)

DCSb_Compt
//////////////////////////////////////////////////////////////////////
//                                                                  //
//  Differential Compton scatt cross section (barn/atom/sterad)     //
//                                                                  //
//          Z : atomic number                                       //
//          E : Energy (keV)                                        //
//          theta : scattering polar angle (rad)                    //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double DCSb_Compt(int Z, double E, double theta)

DCSPb_Rayl
//////////////////////////////////////////////////////////////////////
//                                                                  //
//         Differential Rayleigh scattering cross section           // 
//                for polarized beam (barn/atom/sterad)             //
//                                                                  //
//          Z : atomic number                                       //
//          E : Energy (keV)                                        //
//          theta : scattering polar angle (rad)                    //
//          phi : scattering azimuthal angle (rad)                  //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double DCSPb_Rayl(int Z, double E, double theta, double phi)

DCSPb_Compt
//////////////////////////////////////////////////////////////////////
//                                                                  //
//           Differential Compton scattering cross section          //
//                for polarized beam (barn/atom/sterad)             //
//          Z : atomic number                                       //
//          E : Energy (keV)                                        //
//          theta : scattering polar angle (rad)                    //
//          phi : scattering azimuthal angle (rad)                  //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double DCSPb_Compt(int Z, double E, double theta, double phi)

Fi
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                  Anomalous Scattering Factor Fi                  //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double Fi(int Z, double E)

Fii
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                  Anomalous Scattering Factor Fii                  //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double Fii(int Z, double E)

CSb_Photo_Total
///////////////////////////////////////////////////////////
//                                                       //
//        Photoelectric cross section  (barns/atom)      //
//                  Using the Kissel data                //
//                                                       //
//    Z : atomic number                                  //
//    E : energy (keV)                                   //
//                                                       //
///////////////////////////////////////////////////////////
>>> double CSb_Photo_Total(int Z, double E)

CS_Photo_Total
///////////////////////////////////////////////////////////
//                                                       //
//        Photoelectric cross section  (cm2/g)           //
//                  Using the Kissel data                //
//                                                       //
//    Z : atomic number                                  //
//    E : energy (keV)                                   //
//                                                       //
///////////////////////////////////////////////////////////
>>> double CS_Photo_Total(int Z, double E)

CSb_Photo_Partial
///////////////////////////////////////////////////////////
//                                                       //
//   Partial Photoelectric cross section  (barns/elec)   //
//                  Using the Kissel data                //
//                                                       //
//    Z : atomic number                                  //
//    shell : shell                                      //
//    E : energy (keV)                                   //
//                                                       //
///////////////////////////////////////////////////////////
>>> double CSb_Photo_Partial(int Z, int shell, double E)

CS_Photo_Partial
///////////////////////////////////////////////////////////
//                                                       //
//   Partial Photoelectric cross section  (cm2/g)        //
//                  Using the Kissel data                //
//                                                       //
//    Z : atomic number                                  //
//    shell : shell                                      //
//    E : energy (keV)                                   //
//                                                       //
///////////////////////////////////////////////////////////
>>> double CS_Photo_Partial(int Z, int shell, double E)

CS_FluorLine_Kissel
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                    Fluorescent line cross section (cm2/g)        //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//          line :                                                  //
//            KA_LINE 0                                             //
//            KB_LINE 1                                             //
//            LA_LINE 2                                             //
//            LB_LINE 3                                             //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CS_FluorLine_Kissel(int Z, int line, double E)

CSb_FluorLine_Kissel
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                    Fluorescent line cross section (barns/atom)   //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//          line :                                                  //
//            KA_LINE 0                                             //
//            KB_LINE 1                                             //
//            LA_LINE 2                                             //
//            LB_LINE 3                                             //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CSb_FluorLine_Kissel(int Z, int line, double E)

CS_Total_Kissel
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                  Total cross section  (cm2/g)                    //
//         (Photoelectric (Kissel) + Compton + Rayleigh)            //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CS_Total_Kissel(int Z, double E) 

CSb_Total_Kissel
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                  Total cross section  (barn/atom)                //
//         (Photoelectric (Kissel) + Compton + Rayleigh)            //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CSb_Total_Kissel(int Z, double E)

CS_Total_CP
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                  Total cross section  (cm2/g)                    //
//               (Photoelectric + Compton + Rayleigh)               //
//                                                                  //
//          compound : chemical formula                             //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CS_Total_CP(const char compound[], double E);


CS_Photo_CP
//////////////////////////////////////////////////////////////////////
//                                                                  //
//         Photoelectric absorption cross section  (cm2/g)          //
//                                                                  //
//          compound : chemical formula                             //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CS_Photo_CP(const char compound[], double E);


CS_Rayl_CP
//////////////////////////////////////////////////////////////////////
//                                                                  //
//            Rayleigh scattering cross section  (cm2/g)            //
//                                                                  //
//          compound : chemical formula                             //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CS_Rayl_CP(const char compound[], double E);

CS_Compt_CP
//////////////////////////////////////////////////////////////////////
//                                                                  //
//            Compton scattering cross section  (cm2/g)             //
//                                                                  //
//          compound : chemical formula                             //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CS_Compt_CP(const char compound[], double E); 


CSb_Total_CP
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                  Total cross section  (barn/atom)                //
//               (Photoelectric + Compton + Rayleigh)               //
//                                                                  //
//          compound : chemical formula                             //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CSb_Total_CP(const char compound[], double E);

CSb_Photo_CP
//////////////////////////////////////////////////////////////////////
//                                                                  //
//         Photoelectric absorption cross section  (barn/atom)      //
//                                                                  //
//          compound : chemical formula                             //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CSb_Photo_CP(const char compound[], double E);

CSb_Rayl_CP
//////////////////////////////////////////////////////////////////////
//                                                                  //
//            Rayleigh scattering cross section  (barn/atom)        //
//                                                                  //
//          compound : chemical formula                             //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CSb_Rayl_CP(const char compound[], double E);

CSb_Compt_CP
//////////////////////////////////////////////////////////////////////
//                                                                  //
//            Compton scattering cross section  (barn/atom)         //
//                                                                  //
//          compound : chemical formula                             //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CSb_Compt_CP(const char compound[], double E); 

DCS_Rayl_CP
//////////////////////////////////////////////////////////////////////
//                                                                  //
//  Differential Rayleigh scattering cross section (cm2/g/sterad)   //
//                                                                  //
//          compound : chemical formula                             //
//          E : Energy (keV)                                        //
//          theta : scattering polar angle (rad)                    //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double DCS_Rayl_CP(const char compound[], double E, double theta);

DCS_Compt_CP
//////////////////////////////////////////////////////////////////////
//                                                                  //
//  Differential Compton scattering cross section (cm2/g/sterad)    //
//                                                                  //
//          compound : chemical formula                             //
//          E : Energy (keV)                                        //
//          theta : scattering polar angle (rad)                    //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double DCS_Compt_CP(const char compound[], double E, double theta);

DCSb_Rayl_CP
//////////////////////////////////////////////////////////////////////
//                                                                  //
//  Differential Rayleigh scattering cross sect (barn/atom/sterad)  //
//                                                                  //
//          compound : chemical formula                             //
//          E : Energy (keV)                                        //
//          theta : scattering polar angle (rad)                    //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double DCSb_Rayl_CP(const char compound[], double E, double theta);

DCSb_Compt_CP
//////////////////////////////////////////////////////////////////////
//                                                                  //
//  Differential Compton scatt cross section (barn/atom/sterad)     //
//                                                                  //
//          compound : chemical formula                             //
//          E : Energy (keV)                                        //
//          theta : scattering polar angle (rad)                    //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double DCSb_Compt_CP(const char compound[], double E, double theta);

DCSP_Rayl_CP
//////////////////////////////////////////////////////////////////////
//                                                                  //
//         Differential Rayleigh scattering cross section           // 
//                for polarized beam (cm2/g/sterad)                 //
//                                                                  //
//          compound : chemical formula                             //
//          E : Energy (keV)                                        //
//          theta : scattering polar angle (rad)                    //
//          phi : scattering azimuthal angle (rad)                  //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double DCSP_Rayl_CP(const char compound[], double E, double theta, double phi);

DCSP_Compt_CP
//////////////////////////////////////////////////////////////////////
//                                                                  //
//           Differential Compton scattering cross section          //
//                for polarized beam (cm2/g/sterad)                 //
//                                                                  //
//          compound : chemical formula                             //
//          E : Energy (keV)                                        //
//          theta : scattering polar angle (rad)                    //
//          phi : scattering azimuthal angle (rad)                  //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double DCSP_Compt_CP(const char compound[], double E, double theta, double phi);

DCSPb_Rayl_CP
//////////////////////////////////////////////////////////////////////
//                                                                  //
//         Differential Rayleigh scattering cross section           // 
//                for polarized beam (barn/atom/sterad)             //
//                                                                  //
//          compound : chemical formula                             //
//          E : Energy (keV)                                        //
//          theta : scattering polar angle (rad)                    //
//          phi : scattering azimuthal angle (rad)                  //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double DCSPb_Rayl_CP(const char compound[], double E, double theta, double phi);


DCSPb_Compt_CP
//////////////////////////////////////////////////////////////////////
//                                                                  //
//           Differential Compton scattering cross section          //
//                for polarized beam (barn/atom/sterad)             //
//                                                                  //
//          compound : chemical formula                             //
//          E : Energy (keV)                                        //
//          theta : scattering polar angle (rad)                    //
//          phi : scattering azimuthal angle (rad)                  //
//                                                                  //
//////////////////////////////////////////////////// /////////////////
>>> double DCSPb_Compt_CP(const char compound[], double E, double theta, double phi);

CS_Photo_Total_CP
///////////////////////////////////////////////////////////
//                                                       //
//        Photoelectric cross section  (cm2/g)           //
//                  Using the Kissel data                //
//                                                       //
//          compound : chemical formula                  //
//    	    E : energy (keV)                             //
//                                                       //
///////////////////////////////////////////////////////////
>>> double CS_Photo_Total_CP(const char compound[], double E);

CSb_Photo_Total_CP
///////////////////////////////////////////////////////////
//                                                       //
//        Photoelectric cross section  (barns/atom)      //
//                  Using the Kissel data                //
//                                                       //
//          compound : chemical formula                  //
//    	    E : energy (keV)                             //
//                                                       //
///////////////////////////////////////////////////////////
>>> double CSb_Photo_Total_CP(const char compound[], double E);

CS_Total_Kissel_CP
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                  Total cross section  (cm2/g)                    //
//         (Photoelectric (Kissel) + Compton + Rayleigh)            //
//                                                                  //
//          compound : chemical formula                             //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CS_Total_Kissel_CP(const char compound[], double E); 

CSb_Total_Kissel_CP
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                  Total cross section  (barn/atom)                //
//         (Photoelectric (Kissel) + Compton + Rayleigh)            //
//                                                                  //
//          compound : chemical formula                             //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CSb_Total_Kissel_CP(const char compound[], double E); 

Refractive_Index_Re
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                Refractive Index real part (1-alpha)              //
//                                                                  //
//          compound : chemical formula                             //
//          E : energy (keV)                                        //
//          density : compound density (g/cm3)                      //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double Refractive_Index_Re(const char compound[], double E, double density);

Refractive_Index_Im
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                Refractive Index imaginary part (beta)            //
//                                                                  //
//          compound : chemical formula                             //
//          E : energy (keV)                                        //
//          density : compound density (g/cm3)                      //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double Refractive_Index_Im(const char compound[], double E, double density);

Refractive_Index
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                Refractive Index (as complex number)              //
//                                                                  //
//          compound : chemical formula                             //
//          E : energy (keV)                                        //
//          density : compound density (g/cm3)                      //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> xrlComplex Refractive_Index(const char compound[], double E, double density);

ComptonProfile
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                Compton scattering profile                        //
//                                                                  //
//          Z : atomic number                                       //
//          pz : momentum                                           //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double ComptonProfile(int Z, double pz);

ComptonProfile_Partial
//////////////////////////////////////////////////////////////////////
//                                                                  //
//              subshell Compton scattering profile                 //
//                                                                  //
//          Z : atomic number                                       //
//          shell : shell macro                                     // 
//          pz : momentum                                           //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double ComptonProfile_Partial(int Z, int shell, double pz);

AugerRate
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                Fractional Auger Rate                             //
//                                                                  //
//          Z : atomic number                                       //
//          auger_trans: macro identifying initial                  //
//		ionized shell and the origin of the two             //
//              ejected electrons                                   //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double AugerRate(int Z, int auger_trans);

AugerYield
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                Auger Yield                                       //
//                                                                  //
//          Z : atomic number                                       //
//          shell : shell macro                                     // 
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double AugerRate(int Z, int auger_trans);

AtomicLevelWidth
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                    Atomic level width (keV)                      //
//                                                                  //
//          Z : atomic number                                       //
//          shell :                                                 //
//            K_SHELL  0                                            //
//            L1_SHELL 1                                            //
//            L2_SHELL 2                                            //
//            L3_SHELL 3                                            //
//            M1_SHELL 4                                            //
//            M2_SHELL 5                                            //
//            M3_SHELL 6                                            //
//            M4_SHELL 7                                            //
//            M5_SHELL 8                                            //
//             .......                                              //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double AtomicLevelWidth(int Z, int shell);

ElectronConfig
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                  Electronic configuration                        //
//                      According to Lynn Kissel                    //
//                                                                  //
//          Z : atomic number                                       //
//          shell : shell macro                                     //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double ElectronConfig(int Z, int shell);

CS_FluorLine_Kissel_Cascade
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                    Fluorescent line cross section (cm2/g)        //
//                       with cascade effects                       //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//          line :                                                  //
//            KA_LINE 0                                             //
//            KB_LINE 1                                             //
//            LA_LINE 2                                             //
//            LB_LINE 3                                             //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CS_FluorLine_Kissel_Cascade(int Z, int line, double E)

CSb_FluorLine_Kissel_Cascade
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                    Fluorescent line cross section (barns/atom)   //
//                       with cascade effects                       //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//          line :                                                  //
//            KA_LINE 0                                             //
//            KB_LINE 1                                             //
//            LA_LINE 2                                             //
//            LB_LINE 3                                             //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CSb_FluorLine_Kissel_Cascade(int Z, int line, double E)

CS_FluorLine_Kissel_Radiative_Cascade
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                    Fluorescent line cross section (cm2/g)        //
//                       with radiative cascade effects             //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//          line :                                                  //
//            KA_LINE 0                                             //
//            KB_LINE 1                                             //
//            LA_LINE 2                                             //
//            LB_LINE 3                                             //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CS_FluorLine_Kissel_Radiative_Cascade(int Z, int line, double E)

CSb_FluorLine_Kissel_Radiative_Cascade
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                    Fluorescent line cross section (barns/atom)   //
//                       with radiative cascade effects             //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//          line :                                                  //
//            KA_LINE 0                                             //
//            KB_LINE 1                                             //
//            LA_LINE 2                                             //
//            LB_LINE 3                                             //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CSb_FluorLine_Kissel_Radiative_Cascade(int Z, int line, double E)

CS_FluorLine_Kissel_Nonradiative_Cascade
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                    Fluorescent line cross section (cm2/g)        //
//                       with non-radiative cascade effects         //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//          line :                                                  //
//            KA_LINE 0                                             //
//            KB_LINE 1                                             //
//            LA_LINE 2                                             //
//            LB_LINE 3                                             //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CS_FluorLine_Kissel_Nonradiative_Cascade(int Z, int line, double E)

CSb_FluorLine_Kissel_Nonradiative_Cascade
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                    Fluorescent line cross section (barns/atom)   //
//                       with non-radiative cascade effects         //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//          line :                                                  //
//            KA_LINE 0                                             //
//            KB_LINE 1                                             //
//            LA_LINE 2                                             //
//            LB_LINE 3                                             //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CSb_FluorLine_Kissel_Nonradiative_Cascade(int Z, int line, double E)

CS_FluorLine_Kissel_no_Cascade
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                    Fluorescent line cross section (cm2/g)        //
//                       without cascade effects                    //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//          line :                                                  //
//            KA_LINE 0                                             //
//            KB_LINE 1                                             //
//            LA_LINE 2                                             //
//            LB_LINE 3                                             //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CS_FluorLine_Kissel_no_Cascade(int Z, int line, double E)

CSb_FluorLine_Kissel_no_Cascade
//////////////////////////////////////////////////////////////////////
//                                                                  //
//                    Fluorescent line cross section (barns/atom)   //
//                       with non-radiative cascade effects         //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//          line :                                                  //
//            KA_LINE 0                                             //
//            KB_LINE 1                                             //
//            LA_LINE 2                                             //
//            LB_LINE 3                                             //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CSb_FluorLine_Kissel_no_Cascade(int Z, int line, double E)

Crystal_ArrayInit
//////////////////////////////////////////////////////////////////////
//								    //
//			Initialize a new crystal array		    //
//								    //
//		c_array : pointer to a Crystal_Array variable	    //
//		n_crystal : number of crystals c_array can hold	    //
//								    //
//////////////////////////////////////////////////////////////////////
>>> void Crystal_ArrayInit (Crystal_Array* c_array, int n_crystal_alloc)

Crystal_ArrayFree
//////////////////////////////////////////////////////////////////////
//								    //
//			Free memory from a crystal array	    //
//								    //
//		c_array : pointer to a Crystal_Array variable	    //
//								    //
//////////////////////////////////////////////////////////////////////
>>> void Crystal_ArrayFree (Crystal_Array* c_array)

Crystal_MakeCopy
//////////////////////////////////////////////////////////////////////
//								    //
//			Copy a Crystal_Struct			    //
//								    //
//		crystal : Crystal_Struct to be copied		    //
//								    //
//////////////////////////////////////////////////////////////////////
>>> Crystal_Struct* Crystal_MakeCopy (Crystal_Struct* crystal)

Crystal_Free
//////////////////////////////////////////////////////////////////////
//								    //
//			Free malloc'd memory in a CrystalStruct.    //
//								    //
//		crystal : Crystal_Struct to be freed		    //
//								    //
//////////////////////////////////////////////////////////////////////
>>> void Crystal_Free (Crystal_Struct* crystal)

Crystal_GetCrystal
//////////////////////////////////////////////////////////////////////
//								    //
//		Get a pointer to a Crystal_Struct of a given        //
//		material from a Crystal_Array c_array		    //
//		IF c_array is NULL then the official array	    //
//		is searched					    //
//		IF not found, NULL is returned			    //
//								    //
//////////////////////////////////////////////////////////////////////
>>> Crystal_Struct* Crystal_GetCrystal(const char* material, Crystal_Array* c_array)

Bragg_angle
//////////////////////////////////////////////////////////////////////
//								    //
//		Computes the Bragg angle in radians of a crystal    //
//		at a given energy and Miller indices		    //
//								    //
//		crystal : Crystal_Struct			    //
//		energy : incidence energy			    //
//		x_miller : Miller indices			    //
//								    //
//////////////////////////////////////////////////////////////////////
>>> double Bragg_angle (Crystal_Struct* crystal, double energy, int i_miller, int j_miller, int k_miller)

Q_scattering_amplitude
//////////////////////////////////////////////////////////////////////
//								    //
//		Computes the Q scattering factor = 		    //
//		sin(theta)/lambda of a crystal    		    //
//		at a given energy and Miller indices		    //
//								    //
//		crystal : Crystal_Struct			    //
//		energy : incidence energy			    //
//		x_miller : Miller indices			    //
//								    //
//////////////////////////////////////////////////////////////////////
>>> double Q_scattering_amplitude(Crystal_Struct* crystal, double energy, int i_miller, int j_miller, int k_miller, double rel_angle)

Atomic_factors
//////////////////////////////////////////////////////////////////////
//								    //
//		Computes the atomic factors f0, f' and f''	    //
//		for a given element Z, incidence energy		    //
//		and Debye factor				    //
//								    //
//		f0, f_primep and f_prime2 : pointers to doubles in C //
//		fortran and IDL BUT return values in Perl, Python   //
//		and Lua!!!					    //
//								    //
//////////////////////////////////////////////////////////////////////
>>> Atomic_Factors (int Z, double energy, double q, double debye_factor, double* f0, double* f_primep, double* f_prime2)

Crystal_F_H_StructureFactor
//////////////////////////////////////////////////////////////////////
//								    //
//		Computes the F_H Structure factor for a given	    //
//		crystal and parameters				    //
//		The return value is a complex number		    //
//								    //
//////////////////////////////////////////////////////////////////////
>>> xrlComplex Crystal_F_H_StructureFactor (Crystal_Struct* crystal, double energy, int i_miller, int j_miller, int k_miller, double debye_factor, double rel_angle)

Crystal_F_H_StructureFactor_Partial
//////////////////////////////////////////////////////////////////////
//								    //
//		See also Crystal_F_H_StructureFactor		    //
//		The Atomic structure factor has three terms: 	    //
//			F = f0 + f' + f''			    //
//		For each of these three terms, there is		    //
//		a corresponding *_flag argument which controls	    //
//		the numerical value used in computing F_H:	    //
//		*_flag = 0 --> Set this term to 0.		    //
//		*_flag = 1 --> Set this term to 1. Only used for f0.//
//		*_flag = 2 --> Set this term to the value given	    //
//								    //
//////////////////////////////////////////////////////////////////////
>>> xrlComplex Crystal_F_H_StructureFactor_Partial (Crystal_Struct* crystal, double energy, int i_miller, int j_miller, int k_miller, double debye_factor, double rel_angle, int f0_flag, int f_prime_flag, int f_prime2_flag)

Crystal_UnitCellVolume
//////////////////////////////////////////////////////////////////////
//								    //
//		Computes the unit cell volume for a given	    //
//		crystal. Structures obtained from the		    //
//		official array will have their volume in .volume    //
//								    //
//////////////////////////////////////////////////////////////////////
>>> double Crystal_UnitCellVolume (Crystal_Struct* crystal)

Crystal_dSpacing
//////////////////////////////////////////////////////////////////////
//								    //
//		Computes the d-spacing for a given		    //
//		crystal and Miller indices. 			    //
//		The routine assumes that if crystal.volume is 	    //
//		nonzero then it holds a valid value.		    //
//		If (i,j,k) = (0,0,0) then zero is returned	    //
//								    //
//////////////////////////////////////////////////////////////////////
>>> double Crystal_dSpacing (Crystal_Struct* crystal, int i_miller, int j_miller, int k_miller)

Crystal_AddCrystal
//////////////////////////////////////////////////////////////////////
//								    //
//		Add a new CrystalStruct to crystal_array.	    //
//		The data is copied to crystal_array.		    //
//		If the material already exists in the array then    //
//		the existing material data is overwitten.	    //
//		If crystal_array is NULL then the crystals are 	    //
//		added to the official array of crystals.	    //
//		Return: 1 on success and 0 on error.		    //
//								    //
//////////////////////////////////////////////////////////////////////
>>> int Crystal_AddCrystal (Crystal_Struct* crystal, Crystal_Array* c_array)

Crystal_ReadFile
//////////////////////////////////////////////////////////////////////
//								    //
//		Read in a set of crystal structs to crystal_array.  //
//		If a material already exists in the array then 	    //
//		the existing material data is overwitten.	    //
//		If crystal_array is NULL then the crystals are      //
//		added to the official array of crystals.	    //
//		Return: 1 on success and 0 on error.		    //
//								    //
//////////////////////////////////////////////////////////////////////
>>> int Crystal_ReadFile (const char* file_name, Crystal_Array* c_array)

//////////////////////////////////////////////////////////////////////
//								    //
//              Returns a NULL-terminated array of strings          //
//              containing the names of the crystals in c_array.    //
//              If c_array is NULL, then the builtin array of       //
//              crystals will be used instead. If nCrystals is      //
//              not NULL, it shall receive the number of            //
//              crystalnames in the array.                          //
//              The returned array should be freed firstly          //
//              by using xrlFree to deallocate all individual       //
//              strings, and subsequently by using xrlFree to       //
//              deallocate the array                                //
//								    //
//////////////////////////////////////////////////////////////////////
>>> char **Crystal_GetCrystalsList(Crystal_Array *c_array, int *nCrystals)


CS_Energy
//////////////////////////////////////////////////////////////////////
//                                                                  //
//            Mass energy-absorption coefficient (cm2/g)            //
//                                                                  //
//          Z : atomic number                                       //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CS_Energy(int Z, double E)

CS_Energy_CP
//////////////////////////////////////////////////////////////////////
//                                                                  //
//         Photoelectric absorption cross section  (cm2/g)          //
//                                                                  //
//          compound : chemical formula                             //
//          E : energy (keV)                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> double CS_Energy_CP(const char compound[], double E);

CompoundParser
//////////////////////////////////////////////////////////////////////
//                                                                  //
//         Compound parser: returns pointer to struct compoundData  //
//                                                                  //
//          compound : chemical formula                             //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> struct compoundData *CompoundParser(const char compoundString[]);

FreeCompoundData
//////////////////////////////////////////////////////////////////////
//                                                                  //
//         Compound parser: frees struct compoundData               //
//                                                                  //
//          parsedCompound : pointer to struct compoundData         //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> void FreeCompoundData(struct compoundData *parsedCompound);

xrlFree
//////////////////////////////////////////////////////////////////////
//                                                                  //
//         Use to free memory allocated by xraylib if               //
//           no dedicated function is available                     //
//                                                                  //
//          memPtr: pointer to xraylib allocated memory             //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> void xrlFree(void *memPtr);

AtomicNumberToSymbol
//////////////////////////////////////////////////////////////////////
//                                                                  //
//         Returns string with chemical symbol for                  //
//           a given atomic number                                  //
//                                                                  //
//          Z: atomic number                                        //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> char * AtomicNumberToSymbol(int Z);

SymbolToAtomicNumber
//////////////////////////////////////////////////////////////////////
//                                                                  //
//         Returns atomic number corresponding to                   //
//           a given chemical element                               //
//                                                                  //
//          symbol: chemical symbol                                 //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> int SymbolToAtomicNumber(const char *symbol);

GetCompoundDataNISTByName
//////////////////////////////////////////////////////////////////////
//                                                                  //
//         Allocates a structure containing the composition         //
//           and density of a compound from the NIST database       //
//                                                                  //
//          compoundString: Full name of the compound               //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> struct compoundDataNIST *GetCompoundDataNISTByName(const char compoundString[]);

GetCompoundDataNISTByIndex
//////////////////////////////////////////////////////////////////////
//                                                                  //
//         Allocates a structure containing the composition         //
//           and density of a compound from the NIST database       //
//                                                                  //
//          i: the index of the compound in the NIST database,      //
//           usually obtained using a NIST_COMPOUND_* macro         //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> struct compoundDataNIST *GetCompoundDataNISTByIndex(int i);

GetCompoundDataNISTList
//////////////////////////////////////////////////////////////////////
//                                                                  //
//        Returns a NULL-terminated array of strings of all         //
//		the compounds in the database. If nCompounds        //
//		is not NULL, it shall receive the number of 	    //
//		of compounds.					    //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> char **GetCompoundDataNISTList(int *nCompounds);

FreeCompoundDataNIST
//////////////////////////////////////////////////////////////////////
//                                                                  //
//        Deallocates a pointer to a struct compoundDataNIST        //
//         	and its components                                  //
//                                                                  //
//         compoundData: pointer to struct compoundDataNIST         //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> void FreeCompoundDataNIST(struct compoundDataNIST *compoundData);

GetRadioNuclideDataByName
//////////////////////////////////////////////////////////////////////
//                                                                  //
//         Allocates a structure containing the radionuclide        //
//         	X-ray and Gamma profile.			    //
//                                                                  //
//          radioNuclideString: Full name of the radionuclide       //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> struct radioNuclideData *GetRadioNuclideDataByName(const char radioNuclideString[]);

GetRadioNuclideDataByIndex
//////////////////////////////////////////////////////////////////////
//                                                                  //
//         Allocates a structure containing the radionuclide        //
//         	X-ray and Gamma profile.			    //
//                                                                  //
//          i: the index of the radionuclide in the database,       //
//           usually obtained using a RADIO_NUCLIDE_* macro         //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> struct radioNuclideData *GetRadioNuclideDataByIndex(int i);

GetRadioNuclideDataList
//////////////////////////////////////////////////////////////////////
//                                                                  //
//        Returns a NULL-terminated array of strings of all         //
//		the radionuclides in the database. If 		    //
//		nRadioNuclides is not NULL, it shall receive the    //
//		number of radionuclides.			    //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> char **GetRadioNuclideDataList(int *nRadioNuclides);

FreeRadioNuclideData
//////////////////////////////////////////////////////////////////////
//                                                                  //
//        Deallocates a pointer to a struct radioNuclideData        //
//         	and its components                                  //
//                                                                  //
//         compoundData: pointer to struct radioNuclideData         //
//                                                                  //
//////////////////////////////////////////////////////////////////////
>>> void FreeRadioNuclideData(struct radioNuclideData *radioNuclideData);


