From 8c082b576da211ff915222c64e3de2b47c7872d2 Mon Sep 17 00:00:00 2001 From: Tom Schoonjans Date: Fri, 23 Apr 2021 14:08:16 +0100 Subject: [PATCH] Add MSVC C# support --- .vscode/c_cpp_properties.json | 22 + csharp/AssemblyInfo.cpp | 39 + csharp/AssemblyInfo.cs | 36 + csharp/Compound.h | 342 ++++ csharp/Diffraction.h | 701 +++++++ csharp/Element.h | 220 +++ csharp/Errors.h | 155 ++ csharp/Program.cs | 249 +++ csharp/Radionuclides.h | 278 +++ csharp/Stdafx.cpp | 5 + csharp/Stdafx.h | 7 + csharp/XrayLib.NET.cpp | 1225 +++++++++++++ csharp/XrayLib.NET.h | 2413 +++++++++++++++++++++++++ csharp/app.ico | Bin 0 -> 1078 bytes csharp/app.rc | 63 + csharp/meson.build | 40 + csharp/resource.h | 3 + include/xraylib-crystal-diffraction.h | 12 + include/xraylib.h | 5 + meson.build | 8 +- meson_options.txt | 3 +- src/crystal_diffraction.c | 5 - src/refractive_indices.c | 3 - 23 files changed, 5824 insertions(+), 10 deletions(-) create mode 100644 .vscode/c_cpp_properties.json create mode 100644 csharp/AssemblyInfo.cpp create mode 100644 csharp/AssemblyInfo.cs create mode 100644 csharp/Compound.h create mode 100644 csharp/Diffraction.h create mode 100644 csharp/Element.h create mode 100644 csharp/Errors.h create mode 100644 csharp/Program.cs create mode 100644 csharp/Radionuclides.h create mode 100644 csharp/Stdafx.cpp create mode 100644 csharp/Stdafx.h create mode 100644 csharp/XrayLib.NET.cpp create mode 100644 csharp/XrayLib.NET.h create mode 100644 csharp/app.ico create mode 100644 csharp/app.rc create mode 100644 csharp/meson.build create mode 100644 csharp/resource.h diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json new file mode 100644 index 00000000..09356534 --- /dev/null +++ b/.vscode/c_cpp_properties.json @@ -0,0 +1,22 @@ +{ + "configurations": [ + { + "name": "Win32", + "includePath": [ + "${workspaceFolder}/**" + ], + "defines": [ + "_DEBUG", + "UNICODE", + "_UNICODE" + ], + "windowsSdkVersion": "10.0.18362.0", + "compilerPath": "C:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Enterprise\\VC\\Tools\\MSVC\\14.16.27023\\bin\\Hostx64\\x64\\cl.exe", + "cStandard": "c89", + "cppStandard": "c++11", + "intelliSenseMode": "windows-msvc-x64", + "compileCommands": "C:\\Users\\TomSc\\github\\xraylib\\meson-build\\compile_commands.json" + } + ], + "version": 4 +} \ No newline at end of file diff --git a/csharp/AssemblyInfo.cpp b/csharp/AssemblyInfo.cpp new file mode 100644 index 00000000..38ba5058 --- /dev/null +++ b/csharp/AssemblyInfo.cpp @@ -0,0 +1,39 @@ +#include "stdafx.h" + +using namespace System; +using namespace System::Reflection; +using namespace System::Runtime::CompilerServices; +using namespace System::Runtime::InteropServices; +using namespace System::Security::Permissions; + +// +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +// +[assembly:AssemblyTitleAttribute("XrayLibNET")]; +[assembly:AssemblyDescriptionAttribute("")]; +[assembly:AssemblyConfigurationAttribute("")]; +[assembly:AssemblyCompanyAttribute("")]; +[assembly:AssemblyProductAttribute("XrayLibNET")]; +[assembly:AssemblyCopyrightAttribute("Copyright (c) 2010-2019 Matthew Wormington")]; +[assembly:AssemblyTrademarkAttribute("")]; +[assembly:AssemblyCultureAttribute("")]; + +// +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the value or you can default the Revision and Build Numbers +// by using the '*' as shown below: + +[assembly:AssemblyVersionAttribute("4.0.0.0")]; + +[assembly:ComVisible(false)]; + +[assembly:CLSCompliantAttribute(true)]; + diff --git a/csharp/AssemblyInfo.cs b/csharp/AssemblyInfo.cs new file mode 100644 index 00000000..2790f813 --- /dev/null +++ b/csharp/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Test")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Test")] +[assembly: AssemblyCopyright("Copyright © 2010")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("1d2d7b66-e084-42b5-a3fd-8165b0a670bb")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/csharp/Compound.h b/csharp/Compound.h new file mode 100644 index 00000000..c453a7f0 --- /dev/null +++ b/csharp/Compound.h @@ -0,0 +1,342 @@ +/* + XrayLib.NET copyright (c) 2010-2019 Matthew Wormington. All rights reserved. + + File: Compound.h + Author: Matthew Wormington + Language: C++/CLI + Compiler: Microsoft Visual Studio 2017 + Created: September 5, 2010 + $Version:$ + $Revision:$ + $RevDate:$ + + Description: + Contains a managed class around the XrayLib CompoundParser for + use with XrayLib.NET. + + "A library for X-ray�matter interaction cross sections for + X-ray fluorescence applications". + A. Brunetti, M. Sanchez del Rio, B. Golosio, A. Simionovici, A. Somogyi, + Spectrochimica Acta Part B 59 (2004) 1725�1731 + http://ftp.esrf.fr/pub/scisoft/xraylib/ + + Notes: + A singleton pattern has been used so that only one instance of the class is ever + created. The Instance property provides a global point of access to the instance. + The implementation is based on the Static Initialization example in the following + Microsoft article: http://msdn.microsoft.com/en-us/library/ms998558.aspx + + + XrayLib copyright (c) 2009, Bruno Golosio, Antonio Brunetti, Manuel Sanchez del + Rio, Tom Schoonjans and Teemu Ikonen. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, this + list of conditions and the following disclaimer + in the documentation and/or other materials provided with the distribution. + * The names of the contributors may not be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY Bruno Golosio, Antonio Brunetti, Manuel Sanchez del Rio, + Tom Schoonjans, Teemu Ikonen and Matthew Wormington ''AS IS'' AND ANY EXPRESS OR IMPLIED + WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Bruno Golosio, Antonio + Brunetti, Manuel Sanchez del Rio, Tom Schoonjans and Teemu Ikonen BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + OF SUCH DAMAGE. +*/ + + +#include "xraylib.h" + +using namespace System; +using namespace System::Collections::Generic; +using namespace System::Runtime::InteropServices; +using namespace System::Text; + +/// +/// A namespace that contains scientific classes. +/// +namespace Science { + + /// + /// A simple class that gives information on the composition of a compound. + /// + public ref class CompoundData + { + List^ _atomCount; + List^ _atomicNumber; + int _elementCount; + List^ _massFraction; + double _molarMass; + double _totalAtomCount; + + public: + + /// Default constructor. + CompoundData() + { + _atomCount = gcnew List(); + _atomicNumber = gcnew List(); + _massFraction = gcnew List(); + + Clear(); + } + + /// Constructor. + /// The chemical formula of the compound. + CompoundData(String^ compound) + { + _atomCount = gcnew List(); + _atomicNumber = gcnew List(); + _massFraction = gcnew List(); + + Parse(compound); + } + + /// Constructor. + /// Will calculate the composition corresponding to the sum of the + /// compositions of A and B, taking into their weights, with + /// weightA + weightB typically less than 1.0. + /// The chemical formula of compound A. + /// The weight of compound A. + /// The chemical formula of compound B. + /// The weight of compound B. + CompoundData(String^ compoundA, double weightA, String^ compoundB, double weightB) + { + ::compoundData *cdA, *cdB; + ::compoundData *cd; + + _atomCount = gcnew List(); + _atomicNumber = gcnew List(); + _massFraction = gcnew List(); + Clear(); + + if (String::IsNullOrEmpty(compoundA) || String::IsNullOrEmpty(compoundB) || (weightA < 0.0) || (weightB < 0.0)) + return; + + IntPtr p = Marshal::StringToHGlobalAnsi(compoundA); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + cdA = ::CompoundParser(pCompound, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + if (cdA == nullptr) + return; + + p = Marshal::StringToHGlobalAnsi(compoundB); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + cdB = ::CompoundParser(pCompound, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + if (cdB == nullptr) + { + ::FreeCompoundData(cdA); + return; + } + + cd = ::add_compound_data(*cdA, weightA, *cdB, weightB); + if (cd != nullptr) + { + _elementCount = cd->nElements; + if (_elementCount > 0) + { + for (int i = 0; i < _elementCount; i++) + { + _atomCount->Add(cd->nAtoms[i]); + _atomicNumber->Add(cd->Elements[i]); + _massFraction->Add(cd->massFractions[i]); + } + } + _molarMass = cd->molarMass; + _totalAtomCount = cd->nAtomsAll; + + ::FreeCompoundData(cd); + } + + ::FreeCompoundData(cdA); + ::FreeCompoundData(cdB); + } + + /// Parses the chemical formula of the compound into its component elements. + /// The chemical formula of the compound. + void Parse(String^ compound) + { + struct ::compoundData *cd; + + if (String::IsNullOrEmpty(compound)) + return; + + Clear(); + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + cd = ::CompoundParser(pCompound, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + if (cd != nullptr) + { + _elementCount = cd->nElements; + if (_elementCount > 0) + { + for (int i = 0; i < _elementCount; i++) + { + _atomCount->Add(cd->nAtoms[i]); + _atomicNumber->Add(cd->Elements[i]); + _massFraction->Add(cd->massFractions[i]); + } + } + _molarMass = cd->molarMass; + _totalAtomCount = cd->nAtomsAll; + } + + ::FreeCompoundData(cd); + } + + /// Clears this object to its blank/initial state. + void Clear() + { + _elementCount = 0; + _atomCount->Clear(); + _atomicNumber->Clear(); + _massFraction->Clear(); + _totalAtomCount = 0; + } + + /// Gets the total number of atoms. + /// The total number of atoms. + property double TotalAtomCount + { + double get() + { + return _totalAtomCount; + } + } + + /// Gets the number of atoms of the component element with the specified index. + /// The number of atoms[int]. + property double AtomCount[int] + { + double get(int index) + { + return _atomCount[index]; + } + } + + /// Gets the number of elements. + /// The number of elements. + property double ElementCount + { + double get() + { + return _elementCount; + } + } + + /// Gets the atomic number of the component element with the specified index. + /// The atomic number[int]. + property int AtomicNumber[int] + { + int get(int index) + { + return _atomicNumber[index]; + } + } + + /// Gets the mass fraction of the component element with the specified index. + /// The mass fraction[int]. + property double MassFraction[int] + { + double get(int index) + { + return _massFraction[index]; + } + } + + /// Convert this object into a string representation. + /// Null if it fails, else a string representation of this object. + virtual String^ ToString() override + { + StringBuilder^ sb = gcnew StringBuilder(); + sb->AppendLine(String::Format("ElementCount: {0}", _elementCount)); + sb->AppendLine(String::Format("AtomicNumber, AtomCount, MassFraction")); + for (int i=0; i<_elementCount; i++) + sb->AppendLine(String::Format("{0}, {1}, {2}", _atomicNumber[i], _atomCount[i], _massFraction[i])); + sb->AppendLine(String::Format("MolarMass: {0}", _molarMass)); + sb->AppendLine(String::Format("TotalAtomCount: {0}", _totalAtomCount)); + + return sb->ToString(); + } + + /// Returns the atomic symbol for the specified element. + /// Atomic number of the element. + /// Atomic symbol, else null if it fails. + static String^ AtomicNumberToSymbol(int Z) + { + ::xrl_error *error = nullptr; + char* pSymbol = ::AtomicNumberToSymbol(Z, &error); + Errors::HandleError(error); + + String^ symbol = gcnew String(pSymbol); + + ::xrlFree(pSymbol); + + return symbol; + } + + /// Returns the atomic number for the specified element. + /// Atomic symbol of the element. + /// Atomic number, else zero if it fails. + static int SymbolToAtomicNumber(String^ symbol) + { + int result = 0; + + IntPtr p = Marshal::StringToHGlobalAnsi(symbol); + try + { + ::xrl_error *error = nullptr; + char* pSymbol = static_cast(p.ToPointer()); + result = ::SymbolToAtomicNumber(pSymbol, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; + } + + }; +} + + + diff --git a/csharp/Diffraction.h b/csharp/Diffraction.h new file mode 100644 index 00000000..4ede67e4 --- /dev/null +++ b/csharp/Diffraction.h @@ -0,0 +1,701 @@ +/* + XrayLib.NET copyright (c) 2010-2019 Matthew Wormington. All rights reserved. + + File: Diffraction.h + Author: Matthew Wormington + Language: C++/CLI + Compiler: Microsoft Visual Studio 2017 + Created: July 17, 2012 + $Version:$ + $Revision:$ + $RevDate:$ + + Description: + Contains a managed class for basic X-ray diffraction (XRD) calculations + from crystals for use with XrayLib.NET. + + "A library for X-ray�matter interaction cross sections for + X-ray fluorescence applications". + A. Brunetti, M. Sanchez del Rio, B. Golosio, A. Simionovici, A. Somogyi, + Spectrochimica Acta Part B 59 (2004) 1725�1731 + http://ftp.esrf.fr/pub/scisoft/xraylib/ + + Notes: + A singleton pattern has been used so that only one instance of the class is ever + created. The Instance property provides a global point of access to the instance. + The implementation is based on the Static Initialization example in the following + Microsoft article: http://msdn.microsoft.com/en-us/library/ms998558.aspx + + + XrayLib copyright (c) 2009, Bruno Golosio, Antonio Brunetti, Manuel Sanchez del + Rio, Tom Schoonjans and Teemu Ikonen. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, this + list of conditions and the following disclaimer + in the documentation and/or other materials provided with the distribution. + * The names of the contributors may not be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY Bruno Golosio, Antonio Brunetti, Manuel Sanchez del Rio, + Tom Schoonjans, Teemu Ikonen and Matthew Wormington ''AS IS'' AND ANY EXPRESS OR IMPLIED + WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Bruno Golosio, Antonio + Brunetti, Manuel Sanchez del Rio, Tom Schoonjans and Teemu Ikonen BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + OF SUCH DAMAGE. +*/ + +#include "xraylib.h" +#include + +using namespace System; +using namespace System::Collections::Generic; +using namespace System::Numerics; +using namespace System::Runtime::InteropServices; +using namespace System::Text; + +/// +/// A namespace that contains scientific classes. +/// +namespace Science { + + /// A simple class for an atom in a crystal + public value class CrystalAtom + { + public: + /// Atomic number of atom + int Zatom; + /// Fractional contribution. Normally 1.0 + double fraction; + /// Atom position (fraction of the unit cell length) + double x; + /// Atom position (fraction of the unit cell length) + double y; + /// Atom position (fraction of the unit cell length) + double z; + }; + + /// + /// A managed wrapper for XrayLib's X-ray diffraction (XRD) functionality. + /// + public ref class Crystal + { + private: + List^ _atoms; // List of atoms in unit cell. + + double CosD(Double x) + { + return Math::Cos(x * PI / 180.0); + } + + double SinD(Double x) + { + return Math::Sin(x * PI / 180.0); + } + + ::Crystal_Struct* ToCrystal_Struct() + { + ::Crystal_Struct* result = new ::Crystal_Struct; + + result->name = new char[Name->Length]; + + IntPtr p = Marshal::StringToHGlobalAnsi(Name); + try + { + char* str = static_cast(p.ToPointer()); + + ::memcpy(result->name, str, Name->Length); + } + finally + { + Marshal::FreeHGlobal(p); + } + + result->a = A; + result->b = B; + result->c = C; + result->alpha = Alpha; + result->beta = Beta; + result->gamma = Gamma; + result->volume = Volume; + + int atomCount = _atoms->Count; + result->n_atom = atomCount; + + result->atom = new ::Crystal_Atom[atomCount]; + for (int i = 0; i < atomCount; i++) + { + ::Crystal_Atom* ca = &result->atom[i]; + ca->Zatom = _atoms[i].Zatom; + ca->fraction = _atoms[i].fraction; + ca->x = _atoms[i].x; + ca->y = _atoms[i].y; + ca->z = _atoms[i].z; + } + + return result; + } + + void DeleteCrystal_Struct(::Crystal_Struct* cs) + { + if (cs != nullptr) + { + delete cs->name; + delete cs->atom; + delete cs; + cs = nullptr; + } + } + + public: + + /// Name of crystal + property String^ Name; + /// Unit cell dimension (Angstrom) + property double A; + /// Unit cell dimension (Angstrom) + property double B; + /// Unit cell dimension (Angstrom) + property double C; + /// Unit cell angle (deg) + property double Alpha; + /// Unit cell angle (deg) + property double Beta; + /// Unit cell angle (deg) + property double Gamma; + /// Unit cell volume (Angstrom^3) + property double Volume; + /// List of atoms in the unit cell + property List^ Atoms + { + List^ get() + { + return _atoms; + } + } + + /// Default constructor. + Crystal() + { + _atoms = gcnew List(); + Clear(); + } + + /// Clears this object to its blank/initial state. + void Clear() + { + _atoms->Clear(); + + Name = ""; + A = 0.0; + B = 0.0; + C = 0.0; + Alpha = 0.0; + Beta = 0.0; + Gamma = 0.0; + Volume = 0.0; + } + + /// Calculates the Bragg angle for the specified reflection + /// Energy (keV) + /// Miller index, h + /// Miller index, k + /// Miller index, l + /// Bragg angle (rad) + double BraggAngle(double E, int h, int k, int l) + { + double result = 0.0; + + ::Crystal_Struct* cs = ToCrystal_Struct(); + try + { + ::xrl_error *error = nullptr; + result = ::Bragg_angle(cs, E, h, k, l, &error); + Errors::HandleError(error); + } + finally + { + DeleteCrystal_Struct(cs); + } + + return result; + } + + /// Calculates the components of the atomic scattering factor + /// Atomic number + /// Energy (keV) + /// Momentum transfer (1/Angstrom) + /// Debye temperature facotor + /// f0 + /// f' + /// f'' + void AtomicScatteringFactors(int Z, double E, double q, double debyeFactor, double %f0, double %fp, double %fpp) + { + double f0_ = f0; + double fp_ = fp; + double fpp_ = fpp; + + ::xrl_error *error = nullptr; + ::Atomic_Factors(Z, E, q, debyeFactor, &f0_, &fp_, &fpp_, &error); + Errors::HandleError(error); + + f0 = f0_; + fp = fp_; + fpp = fpp_; + } + + /// Calculates the structure factor of the crystal for the specified reflection + /// See also PartialStructureFactor + /// Energy (keV) + /// Miller index, h + /// Miller index, k + /// Miller index, l + /// Debye temperature factor + /// Relative angle, i.e. fraction of Bragg angle + /// Complex structure factor + Numerics::Complex StructureFactor(double E, int h, int k, int l, double debyeFactor, double relativeAngle) + { + Numerics::Complex result = 1.0; + + ::Crystal_Struct* cs = ToCrystal_Struct(); + try + { + //::xrlComplex z = ::Crystal_F_H_StructureFactor(cs, E, h, k, l, debyeFactor, relativeAngle); + + ::xrlComplex z; + ::xrl_error *error = nullptr; + ::Crystal_F_H_StructureFactor2(cs, E, h, k, l, debyeFactor, relativeAngle, &z, &error); + Errors::HandleError(error); + result = Numerics::Complex(z.re, z.im); + } + finally + { + DeleteCrystal_Struct(cs); + } + + return result; + } + + /// Calculates the partial structure factor of the crystal for the specified reflection + /// + /// See also StructureFactor + /// The Atomic structure factor has three terms: F_H = f0 + f' + i*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 + /// + /// Energy (keV) + /// Miller index, h + /// Miller index, k + /// Miller index, l + /// Debye temperature factor + /// Relative angle, i.e. fraction of Bragg angle + /// f0 flag. + /// f' flag. + /// f'' flag. + /// Complex structure factor + Numerics::Complex PartialStructureFactor(double E, int h, int k, int l, double debyeFactor, double relativeAngle, int f0Flag, int fpFlag, int fppFlag) + { + Numerics::Complex result = -1.0; + + ::Crystal_Struct* cs = ToCrystal_Struct(); + try + { + //::xrlComplex z = ::Crystal_F_H_StructureFactor_Partial(cs, E, h, k, l, debyeFactor, relativeAngle, f0Flag, fpFlag, fppFlag); + + ::xrlComplex z; + ::xrl_error *error = nullptr; + ::Crystal_F_H_StructureFactor_Partial2(cs, E, h, k, l, debyeFactor, relativeAngle, f0Flag, fpFlag, fppFlag, &z, &error); + Errors::HandleError(error); + result = Numerics::Complex(z.re, z.im); + } + finally + { + DeleteCrystal_Struct(cs); + } + + return result; + } + + /// Calculates the unit cell volume of the crystal (using XrayLib) + /// Unit cell volume (Angstrom^3) + double UnitCellVolume() + { + double result = -1.0; + + ::Crystal_Struct* cs = ToCrystal_Struct(); + try + { + ::xrl_error *error = nullptr; + result = ::Crystal_UnitCellVolume(cs, &error); + Errors::HandleError(error); + } + finally + { + DeleteCrystal_Struct(cs); + } + + return result; + } + + /// Calculates the inter-planar spacing (d-spacing) specified crystal planes + /// + /// This 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. + /// + /// Miller index, h + /// Miller index, k + /// Miller index, l + /// Inter-planar distance (Angstrom) + double DSpacing(int h, int k, int l) + { + double result = -1.0; + + ::Crystal_Struct* cs = ToCrystal_Struct(); + try + { + ::xrl_error *error = nullptr; + result = ::Crystal_dSpacing(cs, h, k, l, &error); + Errors::HandleError(error); + } + finally + { + DeleteCrystal_Struct(cs); + } + + return result; + } + + /// Calculates the unit cell volume of the crystal + /// + /// Uses the triclinic formulas taken from Crystals And Crystal Structures, R.J.D. Tilley (Wiley, 2006) pp36-37 + /// + /// Unit cell volume (Angstrom^3) + double UnitCellVolume2() + { + double V = 0.0; + + double cosAlpha = CosD(Alpha); + double cosBeta = CosD(Beta); + double cosGamma = CosD(Gamma); + + V = A*B*C*Math::Sqrt(1-cosAlpha*cosAlpha-cosBeta*cosBeta-cosGamma*cosGamma+2*cosAlpha*cosBeta*cosGamma); + + return V; + } + + /// Calculates the inter-planar spacing (d-spacing) specified crystal planes + /// + /// If (i, j, k) = (0, 0, 0) then zero is returned. + /// Uses the triclinic formulas taken from Crystals And Crystal Structures, R.J.D. Tilley (Wiley, 2006) pp36-37 + /// + /// Miller index, h + /// Miller index, k + /// Miller index, l + /// Inter-planar distance (Angstrom) + double InterplanarSpacing(int h, int k, int l) + { + double d = 0.0; + + if (A >= 0 && B > 0 && C > 0) + { + double cosAlpha = CosD(Alpha); + double cosBeta = CosD(Beta); + double cosGamma = CosD(Gamma); + double sinAlpha = SinD(Alpha); + double sinBeta = SinD(Beta); + double sinGamma = SinD(Gamma); + + double S11 = B*B*C*C*sinAlpha*sinAlpha; + double S22 = A*A*C*C*sinBeta*sinBeta; + double S33 = A*A*B*B*sinGamma*sinGamma; + double S12 = A*B*C*C*(cosAlpha*cosBeta-cosGamma); + double S23 = A*A*B*C*(cosBeta*cosGamma-cosAlpha); + double S13 = A*B*B*C*(cosGamma*cosAlpha-cosBeta); + + double V = UnitCellVolume2(); + + d = Math::Sqrt((V*V)/(S11*h*h + S22*k*k + S33*l*l + 2*S12*k*l + 2*S23*k*l + 2*S13*h*l)); + } + + return d; + } + + /// Calculates the inter-planar angle between the two specified crystal planes (h1,k1,l1) and (h2,k2,l2) + /// + /// If (i, j, k) = (0, 0, 0) then zero is returned. + /// Uses the triclinic formulas taken from Crystals And Crystal Structures, R.J.D. Tilley (Wiley, 2006) pp36-37 + /// + /// Miller index, h1 + /// Miller index, k1 + /// Miller index, l1 + /// Miller index, h2 + /// Miller index, k2 + /// Miller index, l2 + /// Inter-planar distance (Angstrom) + double InterplanarAngle(int h1, int k1, int l1, int h2, int k2, int l2) + { + double phi = 0.0; + + if (A >= 0 && B > 0 && C > 0) + { + double d1 = InterplanarSpacing(h1, k1, l1); + double d2 = InterplanarSpacing(h2, k2, l2); + + double cosAlpha = CosD(Alpha); + double cosBeta = CosD(Beta); + double cosGamma = CosD(Gamma); + double sinAlpha = SinD(Alpha); + double sinBeta = SinD(Beta); + double sinGamma = SinD(Gamma); + + double S11 = B*B*C*C*sinAlpha*sinAlpha; + double S22 = A*A*C*C*sinBeta*sinBeta; + double S33 = A*A*B*B*sinGamma*sinGamma; + double S12 = A*B*C*C*(cosAlpha*cosBeta-cosGamma); + double S23 = A*A*B*C*(cosBeta*cosGamma-cosAlpha); + double S13 = A*B*B*C*(cosGamma*cosAlpha-cosBeta); + + double V = UnitCellVolume2(); + + phi = Math::Acos(d1*d2/(V*V)*(S11*h1*h2 + S22*k1*k2 + S33*l1*l2 + + S23*(k1*l2+k2*l1) + S13*(l1*h2+l2*h1) + S12*(h1*k2+h2*k1))); + } + + return phi; + } + + /// Calculates the magnitude of the scattering vector Q relative to the Bragg angle of the specified reflection + /// Q = Sin(ThetaB*relativeAngle) / Wavelength + /// Energy (keV) + /// Miller index, h + /// Miller index, k + /// Miller index, l + /// Relative angle, i.e. fraction of Bragg angle + /// The magnitude of the scattering vector (1/Angstrom) + double ScatteringVectorMagnitide(double E, int h, int k, int l, double relativeAngle) + { + double result = -1.0; + + ::Crystal_Struct* cs = ToCrystal_Struct(); + try + { + ::xrl_error *error = nullptr; + result = ::Q_scattering_amplitude(cs, E, h, k, l, relativeAngle, &error); + Errors::HandleError(error); + } + finally + { + DeleteCrystal_Struct(cs); + } + + return result; + } + + /// Convert this object into a string representation. + /// Null if it fails, else a string representation of this object. + virtual String^ ToString() override + { + StringBuilder^ sb = gcnew StringBuilder(); + sb->AppendLine(String::Format("Name: {0}", Name)); + sb->AppendLine("Unit cell lengths (�):"); + sb->AppendLine(String::Format(" a = {0:F6}\n b = {1:F6}\n c = {2:F6}", A, B, C)); + sb->AppendLine("Unit cell angles (deg):"); + sb->AppendLine(String::Format(" alpha = {0:F6}\n beta = {1:F6}\n gamma = {2:F6}", Alpha, Beta, Gamma)); + sb->AppendLine("Atoms:"); + sb->AppendLine(String::Format(" Count: {0}", Atoms->Count)); + sb->AppendLine(" Z Fraction X Y Z"); + for (int i = 0; i < Atoms->Count; i++) + { + CrystalAtom atom = Atoms[i]; + sb->AppendLine(String::Format(" {0} {1:F6} {2:F6} {3:F6} {4:F6}", atom.Zatom, atom.fraction, atom.x, atom.y, atom.z)); + } + return sb->ToString(); + } + }; + + /// + /// A class containing an array of Crystals. + /// + public ref class CrystalArray + { + private: + ::Crystal_Array* ca; + public: + CrystalArray() + { + ca = nullptr; + } + + ~CrystalArray() + { + if (ca != nullptr) + ::Crystal_ArrayFree(ca); + } + + /// Loads from the crystals from an appropriately formatted text file. + /// + /// #UCOMMENT comment + /// #UCELL a b c alpha beta gamma + /// The unit cell dimensions (A and deg) (*MANDATORY, IT MUST EXIST*) + /// #UTEMP temperature in Kelvin at which UCELL is given + /// #UREF reference + /// #USYSTEM : 7 crystal system, i.e., triclinic monoclinic orthorhombic + /// tetragonal rhombohedral(trigonal) + /// hexagonal cubic + /// #ULATTICE the lattice centering: + /// P: Primitive centering: lattice points on the cell corners only + /// I: Body centered: one additional lattice point at the center of the cell + /// F: Face centered: one additional lattice point at center of each + /// of the faces of the cell + /// A,B,C Centered on a single face (A, B or C centering): one + /// additional lattice point at the center of one of the + /// cell faces. + /// The 14 Bravais lattices are, then: + /// 1 triclinic (P) + /// 2 monoclinic (P,C) + /// 3 orthorhombic (P,C,I,F) + /// 2 tetragonal (P,I) + /// 1 rhombohedral (P) + /// 1 hexagonal (P) + /// 3 cubic (P,I,F) + /// #USTRUCTURE Model for structure (e.g., diamond, fcc) + /// Data columns: + /// 4 or 5: + /// AtomicNumber Fraction X Y Z Biso + /// The Biso one is optional + /// + /// [in,out] If non-null, filename of the file. + /// A value that indicates whether the file was loaded + int LoadFromFile(String^ fileName, int capacity) + { + int result = -1; + + if (ca != nullptr) + ::Crystal_ArrayFree(ca); + + ::xrl_error *error = nullptr; + ca = ::Crystal_ArrayInit(capacity, &error); + Errors::HandleError(error); + + IntPtr p = Marshal::StringToHGlobalAnsi(fileName); + try + { + char* pFileName = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::Crystal_ReadFile(pFileName, ca, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; + } + + /// Gets a Crystal object from the array using the specified name + /// [in,out] If non-null, the crystal name. + /// Null if it fails, else the crystal. + Crystal^ GetCrystal(String^ name) + { + Crystal^ result = gcnew Crystal(); + Crystal_Struct* cs; + + IntPtr p = Marshal::StringToHGlobalAnsi(name); + try + { + char* name = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + cs = ::Crystal_GetCrystal(name, ca, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + if (cs != nullptr) + { + result->Name = gcnew String(cs->name); + + result->A = cs->a; + result->B = cs->b; + result->C = cs->c; + result->Alpha = cs->alpha; + result->Beta = cs->beta; + result->Gamma = cs->gamma; + result->Volume = cs->volume; + + int atomCount = cs->n_atom; + for (int i = 0; i < atomCount; i++) + { + ::Crystal_Atom* ca = &cs->atom[i]; + CrystalAtom item; + + item.Zatom = ca->Zatom; + item.fraction = ca->fraction; + item.x = ca->x; + item.y = ca->y; + item.z = ca->z; + + result->Atoms->Add(item); + } + } + + return result; + } + + /// Gets the names of crystals within within the CrystalArray object. + /// A list of strings containing the names. + List^ GetNames() + { + int i; + List^ result; + + result = gcnew List; + + if (ca != NULL) + { + for (i = 0; i < ca->n_crystal; i++) + { + result->Add(gcnew String(ca->crystal[i].name)); + } + } + + return result; + } + + /// Gets the names of default crystals defined within the XrayLib library. + /// A list of strings containing the names. + static List^ GetDefaultNames() + { + char **names; + int i; + List^ result; + + result = gcnew List; + + ::xrl_error *error = nullptr; + names = ::Crystal_GetCrystalsList(NULL, 0, &error); + Errors::HandleError(error); + for (i = 0; names[i] != NULL; i++) + { + result->Add(gcnew String(names[i])); + ::xrlFree(names[i]); + } + ::xrlFree(names); + + return result; + } + }; +} diff --git a/csharp/Element.h b/csharp/Element.h new file mode 100644 index 00000000..7c186d6b --- /dev/null +++ b/csharp/Element.h @@ -0,0 +1,220 @@ +/* + XrayLib.NET copyright (c) 2010-2019 Matthew Wormington. All rights reserved. + + File: Element.h + Author: Matthew Wormington + Language: C++/CLI + Compiler: Microsoft Visual Studio 2017 + Created: September 4, 2010 + $Version:$ + $Revision:$ + $RevDate:$ + + Description: + Contains a managed class containing element data for use with XrayLib.NET. + + "A library for X-ray–matter interaction cross sections for + X-ray fluorescence applications". + A. Brunetti, M. Sanchez del Rio, B. Golosio, A. Simionovici, A. Somogyi, + Spectrochimica Acta Part B 59 (2004) 1725–1731 + http://ftp.esrf.fr/pub/scisoft/xraylib/ + + Notes: + A singleton pattern has been used so that only one instance of the class is ever + created. The Instance property provides a global point of access to the instance. + The implementation is based on the Static Initialization example in the following + Microsoft article: http://msdn.microsoft.com/en-us/library/ms998558.aspx + + + XrayLib copyright (c) 2009, Bruno Golosio, Antonio Brunetti, Manuel Sanchez del + Rio, Tom Schoonjans and Teemu Ikonen. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, this + list of conditions and the following disclaimer + in the documentation and/or other materials provided with the distribution. + * The names of the contributors may not be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY Bruno Golosio, Antonio Brunetti, Manuel Sanchez del Rio, + Tom Schoonjans, Teemu Ikonen and Matthew Wormington ''AS IS'' AND ANY EXPRESS OR IMPLIED + WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Bruno Golosio, Antonio + Brunetti, Manuel Sanchez del Rio, Tom Schoonjans and Teemu Ikonen BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + OF SUCH DAMAGE. +*/ + +using namespace System; +using namespace System::Collections::Generic; +using namespace System::Text; + +/// +/// A namespace that contains scientific classes. +/// +namespace Science { + + /// A structure that contains data for an element in the Periodic Table. + public value struct ElementData + { + /// Atomic number + int Number; + /// Name + String^ Name; + /// Atomic symbol + String^ Symbol; + /// Atomic weight + double Weight; + /// Group in Periodic Table + int Group; + /// Period in Periodic Table + int Period; + /// Density (g/cm^3) + double Density; + public: + virtual String^ ToString() override + { + return String::Format("{0}, {1}, {2}, {3}, {4}, {5}, {6}", + Number, Name, Symbol, Weight, Group, Period, Density); + } + }; + + private ref class Elements + { + private: + static array ^_elementData = { + {0, "", "", 0.0, 0, 0, 0.0}, + {1, "Hydrogen", "H", 1.00794, 1, 1, 0.00008988}, + {2, "Helium", "He", 4.002602, 1, 18, 0.0001785}, + {3, "Lithium", "Li", 6.941, 2, 1, 0.534}, + {4, "Beryllium", "Be", 9.012182, 2, 2, 1.8477}, + {5, "Boron", "B", 10.811, 2, 13, 2.34}, + {6, "Carbon", "C", 12.0107, 2, 14, 2.26}, + {7, "Nitrogen", "N", 14.0067, 2, 15, 0.0012506}, + {8, "Oxygen", "O", 15.9994, 2, 16, 0.001429}, + {9, "Fluorine", "F", 18.9984032, 2, 17, 0.001696}, + {10, "Neon", "Ne", 20.1797, 2, 18, 0.00089994}, + {11, "Sodium", "Na", 22.98977, 3, 1, 0.971}, + {12, "Magnesium", "Mg", 24.305, 3, 2, 1.738}, + {13, "Aluminum", "Al", 26.981538, 3, 13, 2.698}, + {14, "Silicon", "Si", 28.0855, 3, 14, 2.329}, + {15, "Phosphorus", "P", 30.973761, 3, 15, 1.82}, + {16, "Sulfur", "S", 32.065, 3, 16, 1.957}, + {17, "Chlorine", "Cl", 35.453, 3, 17, 0.003214}, + {18, "Argon", "Ar", 39.948, 3, 18, 0.001784}, + {19, "Potassium", "K", 39.0983, 4, 1, 0.862}, + {20, "Calcium", "Ca", 40.078, 4, 2, 1.55}, + {21, "Scandium", "Sc", 44.95591, 4, 3, 2.989}, + {22, "Titanium", "Ti", 47.867, 4, 4, 4.54}, + {23, "Vanadium", "V", 50.9415, 4, 5, 6.11}, + {24, "Chromium", "Cr", 51.9961, 4, 6, 7.19}, + {25, "Manganese", "Mn", 54.938049, 4, 7, 7.44}, + {26, "Iron", "Fe", 55.845, 4, 8, 7.874}, + {27, "Cobalt", "Co", 58.9332, 4, 9, 8.9}, + {28, "Nickel", "Ni", 58.6934, 4, 10, 8.902}, + {29, "Copper", "Cu", 63.546, 4, 11, 8.96}, + {30, "Zinc", "Zn", 65.39, 4, 12, 7.133}, + {31, "Gallium", "Ga", 69.723, 4, 13, 5.907}, + {32, "Germanium", "Ge", 72.64, 4, 14, 5.323}, + {33, "Arsenic", "As", 74.9216, 4, 15, 5.78}, + {34, "Selenium", "Se", 78.96, 4, 16, 4.79}, + {35, "Bromine", "Br", 79.904, 4, 17, 3.1226}, + {36, "Krypton", "Kr", 83.8, 4, 18, 0.0037493}, + {37, "Rubidium", "Rb", 85.4678, 5, 1, 1.532}, + {38, "Strontium", "Sr", 87.62, 5, 2, 2.54}, + {39, "Yttrium", "Y", 88.90585, 5, 3, 4.469}, + {40, "Zirconium", "Zr", 91.224, 5, 4, 6.506}, + {41, "Niobium", "Nb", 92.90638, 5, 5, 8.57}, + {42, "Molybdenum", "Mo", 95.94, 5, 6, 10.22}, + {43, "Technetium", "Tc", 98, 5, 7, 11.5}, + {44, "Ruthenium", "Ru", 101.07, 5, 8, 12.37}, + {45, "Rhodium", "Rh", 102.9055, 5, 9, 12.41}, + {46, "Palladium", "Pd", 106.42, 5, 10, 12.02}, + {47, "Silver", "Ag", 107.8682, 5, 11, 10.5}, + {48, "Cadmium", "Cd", 112.411, 5, 12, 8.65}, + {49, "Indium", "In", 114.818, 5, 13, 7.31}, + {50, "Tin", "Sn", 118.71, 5, 14, 7.31}, + {51, "Antimony", "Sb", 121.76, 5, 15, 6.691}, + {52, "Tellurium", "Te", 127.6, 5, 16, 6.24}, + {53, "Iodine", "I", 126.90447, 5, 17, 4.93}, + {54, "Xenon", "Xe", 131.293, 5, 18, 0.0058971}, + {55, "Cesium", "Cs", 132.90545, 6, 1, 1.873}, + {56, "Barium", "Ba", 137.327, 6, 2, 3.594}, + {57, "Lanthanum", "La", 138.9055, 6, 3, 6.145}, + {58, "Cerium", "Ce", 140.116, 6, 3, 6.689}, + {59, "Praseodymium", "Pr", 140.90765, 6, 3, 6.773}, + {60, "Neodumium", "Nd", 144.24, 6, 3, 7.007}, + {61, "Promethium", "Pm", 145, 6, 3, 7.22}, + {62, "Samarium", "Sm", 150.36, 6, 3, 7.52}, + {63, "Europium", "Eu", 151.964, 6, 3, 5.243}, + {64, "Gadolinium", "Gd", 157.25, 6, 3, 7.9004}, + {65, "Terbium", "Tb", 158.92534, 6, 3, 8.229}, + {66, "Dysprosium", "Dy", 162.5, 6, 3, 8.55}, + {67, "Holmium", "Ho", 164.93032, 6, 3, 8.795}, + {68, "Erbium", "Er", 167.259, 6, 3, 9.066}, + {69, "Thulium", "Tm", 168.93421, 6, 3, 9.321}, + {70, "Ytterbium", "Yb", 173.04, 6, 3, 6.965}, + {71, "Lutetium", "Lu", 174.967, 6, 3, 9.84}, + {72, "Hafnium", "Hf", 178.49, 6, 4, 13.31}, + {73, "Tantalum", "Ta", 180.9479, 6, 5, 16.654}, + {74, "Tungsten", "W", 183.84, 6, 6, 19.3}, + {75, "Rhenium", "Re", 186.207, 6, 7, 21.02}, + {76, "Osmium", "Os", 190.23, 6, 8, 22.59}, + {77, "Iridium", "Ir", 192.217, 6, 9, 22.42}, + {78, "Platinum", "Pt", 195.078, 6, 10, 21.45}, + {79, "Gold", "Au", 196.96655, 6, 11, 19.32}, + {80, "Mercury", "Hg", 200.59, 6, 12, 13.546}, + {81, "Thallium", "Tl", 204.3833, 6, 13, 11.85}, + {82, "Lead", "Pb", 207.2, 6, 14, 11.35}, + {83, "Bismuth", "Bi", 208.98038, 6, 15, 9.747}, + {84, "Polonium", "Po", 209, 6, 16, 9.32}, + {85, "Astatine", "At", 210, 6, 17, -9999}, + {86, "Radon", "Rn", 222, 6, 18, 0.00973}, + {87, "Francium", "Fr", 223, 7, 1, -9999}, + {88, "Radium", "Ra", 226, 7, 2, 5}, + {89, "Actinium", "Ac", 227, 7, 3, 10.06}, + {90, "Thorium", "Th", 232.0381, 7, 3, 11.72}, + {91, "Protactnium", "Pa", 231.03588, 7, 3, 15.37}, + {92, "Uranium", "U", 238.02891, 7, 3, 18.95}, + {93, "Neptunium", "Np", 237, 7, 3, 20.25}, + {94, "Plutonium", "Pu", 244, 7, 3, 19.84}, + {95, "Americium", "Am", 243, 7, 3, 13.67}, + {96, "Curium", "Cm", 247, 7, 3, 13.3}, + {97, "Berkelium", "Bk", 247, 7, 3, 14.79}, + {98, "Californium", "Cf", 251, 7, 3, -9999}, + {99, "Einsteinium", "Es", 252, 7, 3, -9999}, + {100, "Fermium", "Fm", 257, 7, 3, -9999}, + {101, "Mendelevium", "Md", 258, 7, 3, -9999}, + {102, "Nobelium", "No", 259, 7, 3, -9999}, + {103, "Lawrencium", "Lr", 262, 7, 3, -9999}, + {104, "Rutherfordium", "Rf", 261, 7, 4, -9999}, + {105, "Dubnium", "Db", 262, 7, 5, -9999}, + {106, "Seaborgium", "Sg", 266, 7, 6, -9999}, + {107, "Bohrium", "Bh", 264, 7, 7, -9999}, + {108, "Hassium", "Hs", 277, 7, 8, -9999}, + {109, "Meitnerium", "Mt", 268, 7, 9, -9999}, + {110, "Darmstadtium", "Ds", 271, 7, 10, -9999}, + {111, "Roentgenium", "Rg", 272, 7, 11, -9999}}; + + public: + /// Gets the element data for the specified element. + /// Atomic number. + /// Element data. + static ElementData GetData(int Z) + { + if (Z < 1 || Z > 110) + { + return _elementData[0]; + } + + return _elementData[Z]; + } + }; +} diff --git a/csharp/Errors.h b/csharp/Errors.h new file mode 100644 index 00000000..502341c1 --- /dev/null +++ b/csharp/Errors.h @@ -0,0 +1,155 @@ +/* + XrayLib.NET copyright (c) 2010-2019 Matthew Wormington. All rights reserved. + + File: Errors.h + Author: Matthew Wormington + Language: C++/CLI + Compiler: Microsoft Visual Studio 2017 + Created: January 15, 2019 + $Version:$ + $Revision:$ + $RevDate:$ + + Description: + Contains a managed class containing element data for use with XrayLib.NET. + + "A library for X-ray�matter interaction cross sections for + X-ray fluorescence applications". + A. Brunetti, M. Sanchez del Rio, B. Golosio, A. Simionovici, A. Somogyi, + Spectrochimica Acta Part B 59 (2004) 1725�1731 + http://ftp.esrf.fr/pub/scisoft/xraylib/ + + Notes: + A singleton pattern has been used so that only one instance of the class is ever + created. The Instance property provides a global point of access to the instance. + The implementation is based on the Static Initialization example in the following + Microsoft article: http://msdn.microsoft.com/en-us/library/ms998558.aspx + + + XrayLib copyright (c) 2009, Bruno Golosio, Antonio Brunetti, Manuel Sanchez del + Rio, Tom Schoonjans and Teemu Ikonen. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, this + list of conditions and the following disclaimer + in the documentation and/or other materials provided with the distribution. + * The names of the contributors may not be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY Bruno Golosio, Antonio Brunetti, Manuel Sanchez del Rio, + Tom Schoonjans, Teemu Ikonen and Matthew Wormington ''AS IS'' AND ANY EXPRESS OR IMPLIED + WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Bruno Golosio, Antonio + Brunetti, Manuel Sanchez del Rio, Tom Schoonjans and Teemu Ikonen BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + OF SUCH DAMAGE. +*/ + + +#pragma once + +using namespace System::IO; + +#include "xraylib.h" + +/// +/// A namespace that contains scientific classes. +/// +namespace Science { + + /// + /// A managed wrapper for XrayLib's error functions. + /// + public ref class Errors + { + public: + + /// + /// Handles library errors by raising a .NET exception. + /// + /// The error. + static void HandleError(::xrl_error *error) + { + if (error == nullptr) + { + return; + } + + int code = error->code; + String^ message = gcnew String(error->message); + switch (code) + { + case ::XRL_ERROR_MEMORY : + throw gcnew OutOfMemoryException(message); + case ::XRL_ERROR_INVALID_ARGUMENT: + throw gcnew ArgumentException(message); + case ::XRL_ERROR_IO : + throw gcnew IOException(message); + case ::XRL_ERROR_TYPE: + throw gcnew InvalidCastException(message); + case ::XRL_ERROR_UNSUPPORTED : + throw gcnew NotImplementedException(message); + case ::XRL_ERROR_RUNTIME : + throw gcnew Exception(message); + default: + throw gcnew Exception("Unknown exception type raised!"); + } + + ::xrl_clear_error(&error); + + String^ s = String::Format("Error {0}: {1}", code, message); + throw gcnew Science::XrayLibException(s); + } + + // Error Handling + /// + /// Sets the hard error exit code. + /// + /// Hard exit code + static void SetHardExit(int hard_exit) + { + ::SetHardExit(hard_exit); + } + + /// + /// Sets the exit status code. + /// + /// Exit status code + static void SetExitStatus(int exit_status) + { + ::SetExitStatus(exit_status); + } + + /// + /// Gets the exit status code. + /// + /// Exit status code + static int GetExitStatus() + { + return ::GetExitStatus(); + } + + /// + /// Sets whether, or not, error messages are displayed. + /// + /// status is non-zero to display messages + static void SetErrorMessages(int status) + { + ::SetErrorMessages(status); + } + + /// Gets whether, or now, error messages are displayed. + /// Returns a non-zero if messages are displayed + static int GetErrorMessages(void) + { + return ::GetErrorMessages(); + } + }; +} \ No newline at end of file diff --git a/csharp/Program.cs b/csharp/Program.cs new file mode 100644 index 00000000..e8967c4b --- /dev/null +++ b/csharp/Program.cs @@ -0,0 +1,249 @@ +using System; +using System.Diagnostics; +using System.Numerics; +using Science; +using System.Collections.Generic; + +namespace Test +{ + class Program + { + static void Main(string[] args) + { + try + { + Stopwatch sw = new Stopwatch(); + sw.Start(); + + Console.Title = String.Format("XrayLib.NET v{0}.{1}", + XrayLib.VERSION_MAJOR, XrayLib.VERSION_MINOR); + Console.WriteLine("Example C# program using XrayLib.NET\n"); + Console.WriteLine("Atomic weight of pure Al: {0} g/cm3", + XrayLib.AtomicWeight(13)); + Console.WriteLine("Density of pure Al: {0} g/cm3", + XrayLib.ElementDensity(13)); + Console.WriteLine("Ca K-alpha Fluorescence Line Energy: {0}", + XrayLib.LineEnergy(20, XrayLib.KA_LINE)); + Console.WriteLine("Fe partial photoionization cs of L3 at 6.0 keV: {0}", + XrayLib.CS_Photo_Partial(26, XrayLib.L3_SHELL, 6.0)); + Console.WriteLine("Zr L1 edge energy: {0}", + XrayLib.EdgeEnergy(40, XrayLib.L1_SHELL)); + Console.WriteLine("Pb Lalpha XRF production cs at 20.0 keV (jump approx): {0}", + XrayLib.CS_FluorLine(82, XrayLib.LA_LINE, 20.0)); + Console.WriteLine("Pb Lalpha XRF production cs at 20.0 keV (Kissel): {0}", + XrayLib.CS_FluorLine_Kissel(82, XrayLib.LA_LINE, 20.0)); + Console.WriteLine("Bi M1N2 radiative rate: {0}", + XrayLib.RadRate(83, XrayLib.M1N2_LINE)); + Console.WriteLine("U M3O3 Fluorescence Line Energy: {0}", + XrayLib.LineEnergy(92, XrayLib.M3O3_LINE)); + Console.WriteLine("Pb information: {0}", + XrayLib.GetElementData(82).ToString()); + + // Parser test for Ca(HCO3)2 (calcium bicarbonate) + CompoundData cd = new CompoundData("Ca(HCO3)2"); + Console.WriteLine("Ca(HCO3)2 contains:"); + Console.Write(cd.ToString()); + + // Parser test for SiO2 (quartz) + cd.Parse("SiO2"); + Console.WriteLine("SiO2 contains:"); + Console.Write(cd.ToString()); + + Console.WriteLine("Ca(HCO3)2 Rayleigh cs at 10.0 keV: {0}", + XrayLib.CS_Rayl_CP("Ca(HCO3)2", 10.0)); + Console.WriteLine("CS2 Refractive Index at 10.0 keV : {0} - {1} i", + XrayLib.Refractive_Index_Re("CS2", 10.0, 1.261), XrayLib.Refractive_Index_Im("CS2", 10.0, 1.261)); + Console.WriteLine("C16H14O3 Refractive Index at 1 keV : {0} - {1} i", + XrayLib.Refractive_Index_Re("C16H14O3", 1.0, 1.2), XrayLib.Refractive_Index_Im("C16H14O3", 1.0, 1.2)); + Console.WriteLine("SiO2 Refractive Index at 5 keV : {0} - {1} i", + XrayLib.Refractive_Index_Re("SiO2", 5.0, 2.65), XrayLib.Refractive_Index_Im("SiO2", 5.0, 2.65)); + + Complex n = XrayLib.Refractive_Index("SiO2", 5.0, 2.65); + Console.WriteLine("SiO2 Refractive Index at 5 keV : {0} - {1} i", n.Real, n.Imaginary); + + Console.WriteLine("Compton profile for Fe at pz = 1.1 : {0}", + XrayLib.ComptonProfile(26, 1.1f)); + Console.WriteLine("M5 Compton profile for Fe at pz = 1.1 : {0}", + XrayLib.ComptonProfile_Partial(26, XrayLib.M5_SHELL, 1.1)); + Console.WriteLine("M1->M5 Coster-Kronig transition probability for Au : {0}", + XrayLib.CosKronTransProb(79, XrayLib.FM15_TRANS)); + Console.WriteLine("L1->L3 Coster-Kronig transition probability for Fe : {0}", + XrayLib.CosKronTransProb(26, XrayLib.FL13_TRANS)); + Console.WriteLine("Au Ma1 XRF production cs at 10.0 keV (Kissel): {0}", + XrayLib.CS_FluorLine_Kissel(79, XrayLib.MA1_LINE, 10.0)); + Console.WriteLine("Au Mb XRF production cs at 10.0 keV (Kissel): {0}", + XrayLib.CS_FluorLine_Kissel(79, XrayLib.MB_LINE, 10.0)); + Console.WriteLine("Au Mg XRF production cs at 10.0 keV (Kissel): {0}", + XrayLib.CS_FluorLine_Kissel(79, XrayLib.MG_LINE, 10.0)); + + Console.WriteLine("K atomic level width for Fe: {0}", + XrayLib.AtomicLevelWidth(26, XrayLib.K_SHELL)); + Console.WriteLine("Bi L2-M5M5 Auger non-radiative rate: {0}", + XrayLib.AugerRate(86, XrayLib.L2_M5M5_AUGER)); + + cd = new CompoundData("SiO2", 0.4, "Ca(HCO3)2", 0.6); + Console.WriteLine("Compound contains:"); + Console.Write(cd.ToString()); + + String symbol = CompoundData.AtomicNumberToSymbol(26); + Console.WriteLine("Symbol of element 26 is: {0}", symbol); + Console.WriteLine("Number of element Fe is: {0}", CompoundData.SymbolToAtomicNumber("Fe")); + + Console.WriteLine("Pb Malpha XRF production cs at 20.0 keV with cascade effect: {0}", + XrayLib.CS_FluorLine_Kissel(82, XrayLib.MA1_LINE, 20.0)); + Console.WriteLine("Pb Malpha XRF production cs at 20.0 keV with radiative cascade effect: {0}", + XrayLib.CS_FluorLine_Kissel_Radiative_Cascade(82, XrayLib.MA1_LINE, 20.0)); + Console.WriteLine("Pb Malpha XRF production cs at 20.0 keV with non-radiative cascade effect: {0}", + XrayLib.CS_FluorLine_Kissel_Nonradiative_Cascade(82, XrayLib.MA1_LINE, 20.0)); + Console.WriteLine("Pb Malpha XRF production cs at 20.0 keV without cascade effect: {0}", + XrayLib.CS_FluorLine_Kissel_No_Cascade(82, XrayLib.MA1_LINE, 20.0)); + + Console.WriteLine("Al mass energy-absorption cs at 20.0 keV: {0}", + XrayLib.CS_Energy(13, 20.0)); + Console.WriteLine("Pb mass energy-absorption cs at 40.0 keV: {0}", + XrayLib.CS_Energy(82, 40.0)); + Console.WriteLine("CdTe mass energy-absorption cs at 40.0 keV: {0}", + XrayLib.CS_Energy_CP("CdTe", 40.0)); + + double energy = 8.0; + double debyeFactor = 1.0; + double relativeAngle = 1.0; + + // Si crystal structure + CrystalArray ca = new CrystalArray(); + + Crystal cryst = ca.GetCrystal("Si"); + if (cryst != null) + { + Console.WriteLine(cryst.ToString()); + + // Si diffraction parameters + Console.WriteLine("Si 111 at 8 KeV. Incidence at the Bragg angle:"); + double bragg = cryst.BraggAngle(energy, 1, 1, 1); + Console.WriteLine(" Bragg angle: {0} rad, {1} deg", bragg, bragg * 180.0 / Math.PI); + + double q = cryst.ScatteringVectorMagnitide(energy, 1, 1, 1, relativeAngle); + Console.WriteLine(" Magnitude of scattering vector, Q: {0}", q); + + double f0 = 0.0, fp = 0.0, fpp = 0.0; + cryst.AtomicScatteringFactors(14, energy, q, debyeFactor, ref f0, ref fp, ref fpp); + Console.WriteLine(" Atomic scattering factors (Z = 14) f0, fp, fpp: {0}, {1}, i{2}", f0, fp, fpp); + + Complex FH, F0; + FH = cryst.StructureFactor(energy, 1, 1, 1, debyeFactor, relativeAngle); + Console.WriteLine(" FH(1,1,1) structure factor: ({0}, {1})", FH.Real, FH.Imaginary); + + F0 = cryst.StructureFactor(energy, 0, 0, 0, debyeFactor, relativeAngle); + Console.WriteLine(" F0=FH(0,0,0) structure factor: ({0}, {1})", F0.Real, F0.Imaginary); + Console.WriteLine(); + } + + // Diamond diffraction parameters + cryst = ca.GetCrystal("Diamond"); + if (cryst != null) + { + Console.WriteLine("Diamond 111 at 8 KeV. Incidence at the Bragg angle:"); + double bragg = cryst.BraggAngle(energy, 1, 1, 1); + Console.WriteLine(" Bragg angle: {0} rad, {1} deg", bragg, bragg * 180.0 / Math.PI); + + double q = cryst.ScatteringVectorMagnitide(energy, 1, 1, 1, relativeAngle); + Console.WriteLine(" Magnitude of scattering vector, Q: {0}", q); + + double f0 = 0.0, fp = 0.0, fpp = 0.0; + cryst.AtomicScatteringFactors(6, energy, q, debyeFactor, ref f0, ref fp, ref fpp); + Console.WriteLine(" Atomic scattering factors (Z = 6) f0, fp, fpp: {0}, {1}, i{2}", f0, fp, fpp); + + Complex FH, F0; + FH = cryst.StructureFactor(energy, 1, 1, 1, debyeFactor, relativeAngle); + Console.WriteLine(" FH(1,1,1) structure factor: ({0}, {1})", FH.Real, FH.Imaginary); + + F0 = cryst.StructureFactor(energy, 0, 0, 0, debyeFactor, relativeAngle); + Console.WriteLine(" F0=FH(0,0,0) structure factor: ({0}, {1})", F0.Real, F0.Imaginary); + + Complex FHbar = cryst.StructureFactor(energy, -1, -1, -1, debyeFactor, relativeAngle); + double dw = 1e10 * 2 * (XrayLib.R_E / cryst.Volume) * (XrayLib.KEV2ANGST * XrayLib.KEV2ANGST / (energy * energy)) * + Math.Sqrt(Complex.Abs(FH * FHbar)) / Math.PI / Math.Sin(2 * bragg); + Console.WriteLine(" Darwin width: {0} uRad", 1e6 * dw); + Console.WriteLine(); + } + + // Alpha Quartz diffraction parameters + cryst = ca.GetCrystal("AlphaQuartz"); + if (cryst != null) + { + Console.WriteLine("AlphaQuartz 020 at 8 KeV. Incidence at the Bragg angle:"); + double bragg = cryst.BraggAngle(energy, 0, 2, 0); + Console.WriteLine(" Bragg angle: {0} rad, {1} deg", bragg, bragg * 180.0 / Math.PI); + + double q = cryst.ScatteringVectorMagnitide(energy, 0, 2, 0, relativeAngle); + Console.WriteLine(" Magnitude of scattering vector, Q: {0}", q); + + double f0 = 0.0, fp = 0.0, fpp = 0.0; + cryst.AtomicScatteringFactors(8, energy, q, debyeFactor, ref f0, ref fp, ref fpp); + Console.WriteLine(" Atomic scattering factors (Z = 8) f0, fp, fpp: {0}, {1}, i{2}", f0, fp, fpp); + + Complex FH, F0; + FH = cryst.StructureFactor(energy, 0, 2, 0, debyeFactor, relativeAngle); + Console.WriteLine(" FH(0,2,0) structure factor: ({0}, {1})", FH.Real, FH.Imaginary); + + F0 = cryst.StructureFactor(energy, 0, 0, 0, debyeFactor, relativeAngle); + Console.WriteLine(" F0=FH(0,0,0) structure factor: ({0}, {1})", F0.Real, F0.Imaginary); + Console.WriteLine(); + } + + // Muscovite diffraction parameters + cryst = ca.GetCrystal("Muscovite"); + if (cryst != null) + { + Console.WriteLine("Muskovite 331 at 8 KeV. Incidence at the Bragg angle:"); + double bragg = cryst.BraggAngle(energy, 3, 3, 1); + Console.WriteLine(" Bragg angle: {0} rad, {1} deg", bragg, bragg * 180.0 / Math.PI); + + double q = cryst.ScatteringVectorMagnitide(energy, 3, 3, 1, relativeAngle); + Console.WriteLine(" Magnitude of scattering vector, Q: {0}", q); + + double f0 = 0.0, fp = 0.0, fpp = 0.0; + cryst.AtomicScatteringFactors(19, energy, q, debyeFactor, ref f0, ref fp, ref fpp); + Console.WriteLine(" Atomic scattering factors (Z = 19) f0, fp, fpp: {0}, {1}, i{2}", f0, fp, fpp); + + Complex FH, F0; + FH = cryst.StructureFactor(energy, 3, 3, 1, debyeFactor, relativeAngle); + Console.WriteLine(" FH(3,3,1) structure factor: ({0}, {1})", FH.Real, FH.Imaginary); + + F0 = cryst.StructureFactor(energy, 0, 0, 0, debyeFactor, relativeAngle); + Console.WriteLine(" F0=FH(0,0,0) structure factor: ({0}, {1})", F0.Real, F0.Imaginary); + Console.WriteLine(); + } + + List crystalNames; + crystalNames = CrystalArray.GetDefaultNames(); + foreach (string name in crystalNames) + Console.WriteLine(name); + Console.WriteLine(); + + // RadionuclideData tests + RadionuclideData rd = new RadionuclideData("109Cd"); + Console.WriteLine(rd.ToString()); + Console.WriteLine(); + + rd = new RadionuclideData(XrayLib.RADIONUCLIDE_125I); + Console.WriteLine(rd.ToString()); + Console.WriteLine(); + + rd = new RadionuclideData(); + string namesCsv = string.Join(", ", rd.Names.ToArray()); + Console.WriteLine(namesCsv); + Console.WriteLine(); + + sw.Stop(); + Console.WriteLine("Time: {0} ms", sw.ElapsedMilliseconds); + } + catch (XrayLibException e) + { + Console.WriteLine(e.Message); + } + + } + } +} + diff --git a/csharp/Radionuclides.h b/csharp/Radionuclides.h new file mode 100644 index 00000000..a21ad0f5 --- /dev/null +++ b/csharp/Radionuclides.h @@ -0,0 +1,278 @@ +/* + XrayLib.NET copyright (c) 2010-2019 Matthew Wormington. All rights reserved. + + File: Radionuclides.h + Author: Matthew Wormington + Language: C++/CLI + Compiler: Microsoft Visual Studio 2017 + Created: October 8, 2014 + $Version:$ + $Revision:$ + $RevDate:$ + + Description: + Contains a managed class for radionuclide data for use with XrayLib.NET. + + "A library for X-ray�matter interaction cross sections for + X-ray fluorescence applications". + A. Brunetti, M. Sanchez del Rio, B. Golosio, A. Simionovici, A. Somogyi, + Spectrochimica Acta Part B 59 (2004) 1725�1731 + http://ftp.esrf.fr/pub/scisoft/xraylib/ + + Notes: + A singleton pattern has been used so that only one instance of the class is ever + created. The Instance property provides a global point of access to the instance. + The implementation is based on the Static Initialization example in the following + Microsoft article: http://msdn.microsoft.com/en-us/library/ms998558.aspx + + + XrayLib copyright (c) 2009, Bruno Golosio, Antonio Brunetti, Manuel Sanchez del + Rio, Tom Schoonjans and Teemu Ikonen. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, this + list of conditions and the following disclaimer + in the documentation and/or other materials provided with the distribution. + * The names of the contributors may not be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY Bruno Golosio, Antonio Brunetti, Manuel Sanchez del Rio, + Tom Schoonjans, Teemu Ikonen and Matthew Wormington ''AS IS'' AND ANY EXPRESS OR IMPLIED + WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Bruno Golosio, Antonio + Brunetti, Manuel Sanchez del Rio, Tom Schoonjans and Teemu Ikonen BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + OF SUCH DAMAGE. +*/ + +#include "xraylib.h" +#include + +using namespace System; +using namespace System::Collections::Generic; +using namespace System::Numerics; +using namespace System::Runtime::InteropServices; +using namespace System::Text; + +/// +/// A namespace that contains scientific classes. +/// +namespace Science { + + /// + /// A managed wrapper for XrayLib's radionuclide data. + /// + public ref class RadionuclideData + { + private: + List^ _xrayLines; + List^ _xrayIntensities; + List^ _gammaEnergies; + List^ _gammaIntensities; + List^ _names; + + void GetNames() + { + char **names; + int i; + String^ name; + + _names->Clear(); + + ::xrl_error *error = nullptr; + names = GetRadioNuclideDataList(NULL, &error); + Errors::HandleError(error); + + for (i = 0; names[i] != NULL; i++) + { + name = gcnew String(names[i]); + _names->Add(name); + xrlFree(names[i]); + } + xrlFree(names); + } + + void Initialize(::radioNuclideData* rd) + { + _xrayLines = gcnew List(); + _xrayIntensities = gcnew List(); + _gammaEnergies = gcnew List(); + _gammaIntensities = gcnew List(); + _names = gcnew List(); + Clear(); + + if (rd != nullptr) + { + Name = gcnew String(rd->name); + Z = rd->Z; + A = rd->A; + N = rd->N; + XrayCount = rd->nXrays; + for (int i = 0; i < XrayCount; i++) + { + _xrayLines->Add(rd->XrayLines[i]); + _xrayIntensities->Add(rd->XrayIntensities[i]); + } + GammaCount = rd->nGammas; + for (int i = 0; i < GammaCount; i++) + { + _gammaEnergies->Add(rd->GammaEnergies[i]); + _gammaIntensities->Add(rd->GammaIntensities[i]); + } + + GammaCount = rd->nGammas; + } + } + + public: + /// A string containing the mass number (A), followed by the chemical element (e.g. 55Fe) + property String^ Name; + /// Atomic number of the radionuclide + property int Z; + /// Mass number of the radionuclide + property int A; + /// Number of neutrons of the radionuclide + property int N; + /// Atomic number of the nuclide after decay, and which should be used in calculating the energy of the emitted X-ray lines + property int ZXray; + /// Number of emitted characteristic X-rays + property int XrayCount; + /// Number of emitted gamma-rays + property int GammaCount; + + /// List of *_LINE macros, identifying the emitted X-rays + property List^ XrayLines + { + List^ get() + { + return _xrayLines; + } + } + + /// List of photons per disintegration, one value per emitted X-ray + property List^ XrayIntensities + { + List^ get() + { + return _xrayIntensities; + } + } + + /// List of all available radionuclide names + property List^ Names + { + List^ get() + { + return _names; + } + } + + /// List of emitted gamma-ray energies + property List^ GammaEnergies + { + List^ get() + { + return _gammaEnergies; + } + } + + /// List of emitted gamma-ray photons per disintegration + property List^ GammaIntensities + { + List^ get() + { + return _gammaIntensities; + } + } + + /// Default constructor. + RadionuclideData() + { + Initialize(nullptr); + } + + /// Constructor. + /// Index of the radionuclide in the internal table + RadionuclideData(int index) + { + ::radioNuclideData* rd; + ::xrl_error *error = nullptr; + rd = GetRadioNuclideDataByIndex(index, &error); + Errors::HandleError(error); + Initialize(rd); + if (rd != nullptr) + FreeRadioNuclideData(rd); + } + + /// Constructor. + /// Name of the radionuclide + RadionuclideData(String^ name) + { + ::radioNuclideData* rd; + + char* cName = new char[name->Length]; + IntPtr p = Marshal::StringToHGlobalAnsi(name); + try + { + cName = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + rd = GetRadioNuclideDataByName(cName, &error); + Errors::HandleError(error); + Initialize(rd); + if (rd != nullptr) + FreeRadioNuclideData(rd); + } + finally + { + Marshal::FreeHGlobal(p); + } + } + + /// Clears this object to its blank/initial state. + void Clear() + { + Name = ""; + Z = 0; + A = 0; + N = 0; + ZXray = 0; + XrayCount = 0; + GammaCount = 0; + _xrayLines->Clear(); + _xrayIntensities->Clear(); + _gammaEnergies->Clear(); + _gammaIntensities->Clear(); + + GetNames(); + } + + /// Convert this object into a string representation. + /// Null if it fails, else a string representation of this object. + virtual String^ ToString() override + { + StringBuilder^ sb = gcnew StringBuilder(); + sb->AppendLine(String::Format("Name: {0}", Name)); + sb->AppendLine(String::Format("Z: {0}", Z)); + sb->AppendLine(String::Format("A: {0}", A)); + sb->AppendLine(String::Format("N: {0}", N)); + sb->AppendLine(String::Format("ZXray: {0}", ZXray)); + sb->AppendLine(String::Format("XrayCount: {0}", XrayCount)); + sb->AppendLine(String::Format("XrayLine, XrayIntensity")); + for (int i = 0; i < XrayCount; i++) + sb->AppendLine(String::Format("{0}, {1}", _xrayLines[i], _xrayIntensities[i])); + sb->AppendLine(String::Format("GammaCount: {0}", GammaCount)); + sb->AppendLine(String::Format("GammaEnergy, GammaIntensity")); + for (int i = 0; i < GammaCount; i++) + sb->AppendLine(String::Format("{0}, {1}", _gammaEnergies[i], _gammaIntensities[i])); + + return sb->ToString(); + } + }; +} \ No newline at end of file diff --git a/csharp/Stdafx.cpp b/csharp/Stdafx.cpp new file mode 100644 index 00000000..16913fe9 --- /dev/null +++ b/csharp/Stdafx.cpp @@ -0,0 +1,5 @@ +// stdafx.cpp : source file that includes just the standard includes +// XrayLib.NET.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" diff --git a/csharp/Stdafx.h b/csharp/Stdafx.h new file mode 100644 index 00000000..3cc4c24e --- /dev/null +++ b/csharp/Stdafx.h @@ -0,0 +1,7 @@ +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, +// but are changed infrequently + +#pragma once + + diff --git a/csharp/XrayLib.NET.cpp b/csharp/XrayLib.NET.cpp new file mode 100644 index 00000000..bc7e9397 --- /dev/null +++ b/csharp/XrayLib.NET.cpp @@ -0,0 +1,1225 @@ +/* + XrayLib.NET copyright (c) 2010-2019 Matthew Wormington. All rights reserved. + + File: XrfLibNET.cpp + Author: Matthew Wormington + Language: C++/CLI + Compiler: Microsoft Visual Studio 2017 + Created: September 4, 2010 + $Version:$ + $Revision:$ + $RevDate:$ + + Description: + Contains the implementation of a managed wrapper class around the native + XrayLib API. + + "A library for X-ray�matter interaction cross sections for + X-ray fluorescence applications". + A. Brunetti, M. Sanchez del Rio, B. Golosio, A. Simionovici, A. Somogyi, + Spectrochimica Acta Part B 59 (2004) 1725�1731 + http://ftp.esrf.fr/pub/scisoft/xraylib/ + + Notes: + A singleton pattern has been used so that only one instance of the class is ever + created. The Instance property provides a global point of access to the instance. + The implementation is based on the Static Initialization example in the following + Microsoft article: http://msdn.microsoft.com/en-us/library/ms998558.aspx + + + XrayLib copyright (c) 2009, Bruno Golosio, Antonio Brunetti, Manuel Sanchez del + Rio, Tom Schoonjans and Teemu Ikonen. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, this + list of conditions and the following disclaimer + in the documentation and/or other materials provided with the distribution. + * The names of the contributors may not be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY Bruno Golosio, Antonio Brunetti, Manuel Sanchez del Rio, + Tom Schoonjans, Teemu Ikonen and Matthew Wormington ''AS IS'' AND ANY EXPRESS OR IMPLIED + WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Bruno Golosio, Antonio + Brunetti, Manuel Sanchez del Rio, Tom Schoonjans and Teemu Ikonen BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + OF SUCH DAMAGE. +*/ +#using "System.Numerics.dll" + + +#include "stdafx.h" +#include "Element.h" +#include "XrayLib.NET.h" +#include "xraylib.h" +#include "Errors.h" +#include "Compound.h" +#include "Diffraction.h" +#include "Radionuclides.h" + +using namespace System::Runtime::InteropServices; + +void Science::XrayLib::XrayInit() +{ + ::XRayInit(); +} + +double Science::XrayLib::AtomicWeight( int Z ) +{ + ::xrl_error *error = nullptr; + double result = ::AtomicWeight(Z, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::ElementDensity(int Z) +{ + ::xrl_error *error = nullptr; + double result = ::ElementDensity(Z, &error); + Errors::HandleError(error); + return result; +} + +Science::ElementData Science::XrayLib::GetElementData( int Z ) +{ + return Elements::GetData(Z); +} + +// Cross sections (cm2/g) +double Science::XrayLib::CS_Total(int Z, double E) +{ + ::xrl_error *error = nullptr; + double result = ::CS_Total(Z, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CS_Photo(int Z, double E) +{ + ::xrl_error *error = nullptr; + double result = ::CS_Photo(Z, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CS_Rayl(int Z, double E) +{ + ::xrl_error *error = nullptr; + double result = ::CS_Rayl(Z, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CS_Compt(int Z, double E) +{ + ::xrl_error *error = nullptr; + double result = ::CS_Compt(Z, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CS_Energy(int Z, double E) +{ + ::xrl_error *error = nullptr; + double result = ::CS_Energy(Z, E, &error); + Errors::HandleError(error); + return result; +} + +// barn/atom +double Science::XrayLib::CSb_Total(int Z, double E) +{ + ::xrl_error *error = nullptr; + double result = ::CSb_Total(Z, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CSb_Photo(int Z, double E) +{ + ::xrl_error *error = nullptr; + double result = ::CSb_Photo(Z, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CSb_Rayl(int Z, double E) +{ + ::xrl_error *error = nullptr; + double result = ::CSb_Rayl(Z, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CSb_Compt(int Z, double E) +{ + ::xrl_error *error = nullptr; + double result = ::CSb_Compt(Z, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CS_KN(double E) +{ + ::xrl_error *error = nullptr; + double result = ::CS_KN(E, &error); + Errors::HandleError(error); + return result; +} + +// Unpolarized differential scattering cross sections +double Science::XrayLib::DCS_Thoms(double theta) +{ + ::xrl_error *error = nullptr; + double result = ::DCS_Thoms(theta, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::DCS_KN(double E, double theta) +{ + ::xrl_error *error = nullptr; + double result = ::DCS_KN(E, theta, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::DCS_Rayl(int Z, double E, double theta) +{ + ::xrl_error *error = nullptr; + double result = ::DCS_Rayl(Z, E, theta, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::DCS_Compt(int Z, double E, double theta) +{ + ::xrl_error *error = nullptr; + double result = ::DCS_Compt(Z, E, theta, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::DCSb_Rayl(int Z, double E, double theta) +{ + ::xrl_error *error = nullptr; + double result = ::DCSb_Rayl(Z, E, theta, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::DCSb_Compt(int Z, double E, double theta) +{ + ::xrl_error *error = nullptr; + double result = ::DCSb_Compt(Z, E, theta, &error); + Errors::HandleError(error); + return result; +} + +// Polarized differential scattering cross sections +double Science::XrayLib::DCSP_Thoms(double theta, double phi) +{ + ::xrl_error *error = nullptr; + double result = ::DCSP_Thoms(theta, phi, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::DCSP_KN(double E, double theta, double phi) +{ + ::xrl_error *error = nullptr; + double result = ::DCSP_KN(E, theta, phi, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::DCSP_Rayl(int Z, double E, double theta, double phi) +{ + ::xrl_error *error = nullptr; + double result = ::DCSP_Rayl(Z, E, theta, phi, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::DCSP_Compt(int Z, double E, double theta, double phi) +{ + ::xrl_error *error = nullptr; + double result = ::DCSP_Compt(Z, E, theta, phi, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::DCSPb_Rayl(int Z, double E, double theta, double phi) +{ + ::xrl_error *error = nullptr; + double result = ::DCSPb_Rayl(Z, E, theta, phi, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::DCSPb_Compt(int Z, double E, double theta, double phi) +{ + ::xrl_error *error = nullptr; + double result = ::DCSPb_Compt(Z, E, theta, phi, &error); + Errors::HandleError(error); + return result; +} + +// Scattering factors +double Science::XrayLib::FF_Rayl(int Z, double q) +{ + ::xrl_error *error = nullptr; + double result = ::FF_Rayl(Z, q, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::SF_Compt(int Z, double q) +{ + ::xrl_error *error = nullptr; + double result = ::SF_Compt(Z, q, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::MomentTransf(double E, double theta) +{ + ::xrl_error *error = nullptr; + double result = ::MomentTransf(E, theta, &error); + Errors::HandleError(error); + return result; +} + +// X-ray fluorescent line energy +double Science::XrayLib::LineEnergy(int Z, int line) +{ + ::xrl_error *error = nullptr; + double result = ::LineEnergy(Z, line, &error); + Errors::HandleError(error); + return result; +} + +// Fluorescence yield +double Science::XrayLib::FluorYield(int Z, int shell) +{ + ::xrl_error *error = nullptr; + double result = ::FluorYield(Z, shell, &error); + Errors::HandleError(error); + return result; +} + +// Coster-Kronig transition Probability +double Science::XrayLib::CosKronTransProb(int Z, int trans) +{ + ::xrl_error *error = nullptr; + double result = ::CosKronTransProb(Z, trans, &error); + Errors::HandleError(error); + return result; +} + +// Absorption-edge energies +double Science::XrayLib::EdgeEnergy(int Z, int shell) +{ + ::xrl_error *error = nullptr; + double result = ::EdgeEnergy(Z, shell, &error); + Errors::HandleError(error); + return result; +} + +// Jump ratio +double Science::XrayLib::JumpFactor(int Z, int shell) +{ + ::xrl_error *error = nullptr; + double result = ::JumpFactor(Z, shell, &error); + Errors::HandleError(error); + return result; +} + +// Fluorescent-lines cross sections +double Science::XrayLib::CS_FluorLine(int Z, int line, double E) +{ + ::xrl_error *error = nullptr; + double result = ::CS_FluorLine(Z, line, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CSb_FluorLine(int Z, int line, double E) +{ + ::xrl_error *error = nullptr; + double result = ::CSb_FluorLine(Z, line, E, &error); + Errors::HandleError(error); + return result; +} + +// Fractional radiative rate +double Science::XrayLib::RadRate(int Z, int line) +{ + ::xrl_error *error = nullptr; + double result = ::RadRate(Z, line, &error); + Errors::HandleError(error); + return result; +} + +// Photon energy after Compton scattering +double Science::XrayLib::ComptonEnergy(double E0, double theta) +{ + ::xrl_error *error = nullptr; + double result = ::ComptonEnergy(E0, theta, &error); + Errors::HandleError(error); + return result; +} + +// Anomalous scattering factors +double Science::XrayLib::Fi( int Z, double E ) +{ + ::xrl_error *error = nullptr; + double result = ::Fi(Z, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::Fii( int Z, double E ) +{ + ::xrl_error *error = nullptr; + double result = ::Fii(Z, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CS_Photo_Total( int Z, double E ) +{ + ::xrl_error *error = nullptr; + double result = ::CS_Photo_Total(Z, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CSb_Photo_Total( int Z, double E ) +{ + ::xrl_error *error = nullptr; + double result = ::CSb_Photo_Total(Z, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CS_Photo_Partial( int Z, int shell, double E ) +{ + ::xrl_error *error = nullptr; + double result = ::CS_Photo_Partial(Z, shell, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CSb_Photo_Partial( int Z, int shell, double E ) +{ + ::xrl_error *error = nullptr; + double result = ::CSb_Photo_Partial(Z, shell, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CS_FluorLine_Kissel( int Z, int line, double E ) +{ + ::xrl_error *error = nullptr; + double result = ::CS_FluorLine_Kissel(Z, line, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CSb_FluorLine_Kissel( int Z, int line, double E ) +{ + ::xrl_error *error = nullptr; + double result = ::CSb_FluorLine_Kissel(Z, line, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CS_Total_Kissel( int Z, double E ) +{ + ::xrl_error *error = nullptr; + double result = ::CS_Total_Kissel(Z, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CSb_Total_Kissel( int Z, double E ) +{ + ::xrl_error *error = nullptr; + double result = ::CSb_Total_Kissel(Z, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CS_FluorLine_Kissel_Cascade( int Z, int line, double E ) +{ + ::xrl_error *error = nullptr; + double result = ::CS_FluorLine_Kissel_Cascade(Z, line, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CSb_FluorLine_Kissel_Cascade( int Z, int line, double E ) +{ + ::xrl_error *error = nullptr; + double result = ::CSb_FluorLine_Kissel_Cascade(Z, line, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CS_FluorLine_Kissel_Nonradiative_Cascade( int Z, int line, double E ) +{ + ::xrl_error *error = nullptr; + double result = ::CS_FluorLine_Kissel_Nonradiative_Cascade(Z, line, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CSb_FluorLine_Kissel_Nonradiative_Cascade( int Z, int line, double E ) +{ + ::xrl_error *error = nullptr; + double result = ::CSb_FluorLine_Kissel_Nonradiative_Cascade(Z, line, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CS_FluorLine_Kissel_Radiative_Cascade( int Z, int line, double E ) +{ + ::xrl_error *error = nullptr; + double result = ::CS_FluorLine_Kissel_Radiative_Cascade(Z, line, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CSb_FluorLine_Kissel_Radiative_Cascade( int Z, int line, double E ) +{ + ::xrl_error *error = nullptr; + double result = ::CSb_FluorLine_Kissel_Radiative_Cascade(Z, line, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CS_FluorLine_Kissel_No_Cascade( int Z, int line, double E ) +{ + ::xrl_error *error = nullptr; + double result = ::CS_FluorLine_Kissel_no_Cascade(Z, line, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CSb_FluorLine_Kissel_No_Cascade( int Z, int line, double E ) +{ + ::xrl_error *error = nullptr; + double result = ::CSb_FluorLine_Kissel_no_Cascade(Z, line, E, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::CS_Total_CP( String^ compound, double E ) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::CS_Total_CP(pCompound, E, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + +double Science::XrayLib::CS_Photo_CP( String^ compound, double E ) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::CS_Photo_CP(pCompound, E, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + +double Science::XrayLib::CS_Rayl_CP( String^ compound, double E ) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::CS_Rayl_CP(pCompound, E, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + +double Science::XrayLib::CS_Compt_CP( String^ compound, double E ) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::CS_Compt_CP(pCompound, E, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + +double Science::XrayLib::CSb_Total_CP( String^ compound, double E ) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::CSb_Total_CP(pCompound, E, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + +double Science::XrayLib::CSb_Photo_CP( String^ compound, double E ) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::CSb_Photo_CP(pCompound, E, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + +double Science::XrayLib::CSb_Rayl_CP( String^ compound, double E ) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::CSb_Rayl_CP(pCompound, E, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + +double Science::XrayLib::CSb_Compt_CP( String^ compound, double E ) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::CSb_Compt_CP(pCompound, E, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + +double Science::XrayLib::DCS_Rayl_CP( String^ compound, double E, double theta ) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::DCS_Rayl_CP(pCompound, E, theta, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + +double Science::XrayLib::DCS_Compt_CP( String^ compound, double E, double theta ) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::DCS_Compt_CP(pCompound, E, theta, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + +double Science::XrayLib::DCSb_Rayl_CP( String^ compound, double E, double theta ) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::DCSb_Rayl_CP(pCompound, E, theta, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + +double Science::XrayLib::DCSb_Compt_CP( String^ compound, double E, double theta ) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::DCSb_Compt_CP(pCompound, E, theta, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + +double Science::XrayLib::DCSP_Rayl_CP( String^ compound, double E, double theta, double phi ) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::DCSP_Rayl_CP(pCompound, E, theta, phi, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + +double Science::XrayLib::DCSP_Compt_CP( String^ compound, double E, double theta, double phi ) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::DCSP_Compt_CP(pCompound, E, theta, phi, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + +double Science::XrayLib::DCSPb_Rayl_CP( String^ compound, double E, double theta, double phi ) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::DCSPb_Rayl_CP(pCompound, E, theta, phi, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + +double Science::XrayLib::DCSPb_Compt_CP( String^ compound, double E, double theta, double phi ) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::DCSPb_Compt_CP(pCompound, E, theta, phi, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + +double Science::XrayLib::CS_Photo_Total_CP( String^ compound, double E ) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::CS_Photo_Total_CP(pCompound, E, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + +double Science::XrayLib::CSb_Photo_Total_CP( String^ compound, double E ) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::CSb_Photo_Total_CP(pCompound, E, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + +double Science::XrayLib::CS_Total_Kissel_CP( String^ compound, double E ) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::CS_Total_Kissel_CP(pCompound, E, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + +double Science::XrayLib::CSb_Total_Kissel_CP( String^ compound, double E ) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::CSb_Total_Kissel_CP(pCompound, E, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + +double Science::XrayLib::CS_Energy_CP(String^ compound, double E) +{ + double result = -1.0; + + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + result = ::CS_Energy_CP(pCompound, E, &error); + Errors::HandleError(error); + } + finally + { + Marshal::FreeHGlobal(p); + } + + return result; +} + + +double Science::XrayLib::ElectronConfig( int Z, int shell ) +{ + ::xrl_error *error = nullptr; + double result = ::ElectronConfig(Z, shell, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::ComptonProfile( int Z, double pz ) +{ + ::xrl_error *error = nullptr; + double result = ::ComptonProfile(Z, pz, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::ComptonProfile_Partial( int Z, int shell, double pz ) +{ + ::xrl_error *error = nullptr; + double result = ::ComptonProfile_Partial(Z, shell, pz, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::Refractive_Index_Re( String^ compound, double E, double density ) +{ + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + double result = ::Refractive_Index_Re(pCompound, E, density, &error); + Errors::HandleError(error); + return result; + } + finally + { + Marshal::FreeHGlobal(p); + } +} + +double Science::XrayLib::Refractive_Index_Im( String^ compound, double E, double density ) +{ + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrl_error *error = nullptr; + double result = ::Refractive_Index_Im(pCompound, E, density, &error); + Errors::HandleError(error); + return result; + } + finally + { + Marshal::FreeHGlobal(p); + } +} + + +Numerics::Complex Science::XrayLib::Refractive_Index( String^ compound, double E, double density ) +{ + IntPtr p = Marshal::StringToHGlobalAnsi(compound); + try + { + char* pCompound = static_cast(p.ToPointer()); + ::xrlComplex z; + ::xrl_error *error = nullptr; + ::Refractive_Index2(pCompound, E, density, &z, &error); + Errors::HandleError(error); + + return Numerics::Complex(z.re, z.im); + } + finally + { + Marshal::FreeHGlobal(p); + } +} + +double Science::XrayLib::AtomicLevelWidth( int Z, int shell ) +{ + ::xrl_error *error = nullptr; + double result = ::AtomicLevelWidth(Z, shell, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::AugerRate( int Z, int auger_trans ) +{ + ::xrl_error *error = nullptr; + double result = ::AugerRate(Z, auger_trans, &error); + Errors::HandleError(error); + return result; +} + +double Science::XrayLib::AugerYield(int Z, int shell) +{ + ::xrl_error *error = nullptr; + double result = ::AugerYield(Z, shell, &error); + Errors::HandleError(error); + return result; +} + +System::String ^ Science::XrayLib::IUPACToSiegbahnLineName( System::String ^name ) +{ + System::String ^result = ""; + + for (int i = 0; i < IUPACLineNames->Length; i++) + { + if (String::Compare(name, IUPACLineNames[i], StringComparison::InvariantCultureIgnoreCase) == 0) + { + result = SiegbahnLineNames[i]; + break; + } + } + return result; +} + +System::String ^ Science::XrayLib::SiegbahnToIUPACLineName( System::String ^name ) +{ + System::String ^result = ""; + + for(int i = 0; i < SiegbahnLineNames->Length; i++) + { + if (String::Compare(name, SiegbahnLineNames[i], StringComparison::InvariantCultureIgnoreCase) == 0) + { + result = IUPACLineNames[i]; + break; + } + } + return result; +} + + +void Science::XrayLib::ElementAndLineFromName( System::String ^elementLine, int %Z, int %line ) +{ + System::String ^delimitersStr = " "; + array ^delimiters = delimitersStr->ToCharArray(); + System::String ^symbol; + System::String ^lineName; + ElementData^ ed; + + double result = -1.0; + + // Split the name into a element symbol and line name + array ^tokens = elementLine->Split(delimiters, StringSplitOptions::RemoveEmptyEntries); + if (tokens->Length != 2) + throw gcnew XrayLibException(System::String::Format("Invalid X-ray fluorescence line {0}", elementLine)); + + symbol = tokens[0]->ToLower(); + lineName = tokens[1]->ToLower(); + + // Find the atomic number of the specified symbol or throw an + // exception if the symbol is unknown + Z = -99; + for(int i = 1; i <= 100; i++) + { + ed = GetElementData(i); + if (String::Compare(symbol, ed->Symbol, StringComparison::InvariantCultureIgnoreCase) == 0) + { + Z = i; + break; + } + } + if (Z == -99) + throw gcnew XrayLibException(System::String::Format("Unknown atomic symbol {0}", tokens[0])); + + // Find the line number of the specified symbol or throw an + // exception if the line is unknown + line = -99; + if (lineName == "ka") + line = KA_LINE; + else if (lineName == "kb") + line = KB_LINE; + else if (lineName == "la") + line = LA_LINE; + else if (lineName == "lb") + line = LB_LINE; + else if (lineName == "lg") + line = LG1_LINE; + else + { + for(int i = 0; i < 17; i++) + { + if (String::Compare(lineName, SiegbahnLineNames[i], StringComparison::InvariantCultureIgnoreCase) == 0) + { + line = SiegbahnLines[i]; + break; + } + } + } + if (line == -99) + throw gcnew XrayLibException(System::String::Format("Unknown emission line {0}", tokens[1])); +} + +double Science::XrayLib::LineEnergyFromName( System::String ^lineName ) +{ + int Z; + int line; + + ElementAndLineFromName( lineName, Z, line ); + + // Return the X-ray fluorescence energy (keV) + return LineEnergy(Z, line); +} + +int Science::XrayLib::SiegbahnLineIndex( System::String ^name ) +{ + System::String ^lineName = name->Trim()->ToLower(); + + // Find the identifier of the specified line + int line = -99; + if (lineName == "ka") + line = KA_LINE; + else if (lineName == "kb") + line = KB_LINE; + else if (lineName == "la") + line = LA_LINE; + else if (lineName == "lb") + line = LB_LINE; + else if (lineName == "lg") + line = LG1_LINE; + else + { + for(int i = 0; i < 17; i++) + { + if (String::Compare(lineName, SiegbahnLineNames[i], StringComparison::InvariantCultureIgnoreCase) == 0) + { + line = SiegbahnLines[i]; + break; + } + } + } + + return line; +} + +int Science::XrayLib::AtomicNumber( System::String ^name ) +{ + int Z; + ElementData^ ed; + + System::String ^symbol = name->Trim()->ToLower(); + + // Find the atomic number of the specified symbol + Z = -99; + for (int i = 1; i <= 100; i++) + { + ed = GetElementData(i); + if (String::Compare(symbol, ed->Symbol, StringComparison::InvariantCultureIgnoreCase) == 0) + { + Z = i; + break; + } + } + + return Z; +} + +double Science::XrayLib::SiEscapeEnergy( double energy ) +{ + double result = energy - 1.750; + return result; +} + +double Science::XrayLib::SiEscapeFraction( double energy ) +{ + const double rho = 2.329; + const double omegaK = 0.047; + const double r = 10.8; + int Z; + double muI; + double muK; + + Z = 14; // Si + muI = CS_Total(Z, energy)*rho; + muK = CS_Total(Z, 1.750)*rho; + + double result = 0.5*omegaK*(1-1/r)*(1-muK/muI*Math::Log(1+muI/muK)); + return result; +} \ No newline at end of file diff --git a/csharp/XrayLib.NET.h b/csharp/XrayLib.NET.h new file mode 100644 index 00000000..efad19c8 --- /dev/null +++ b/csharp/XrayLib.NET.h @@ -0,0 +1,2413 @@ +/* + XrayLib.NET copyright (c) 2010-2019 Matthew Wormington. All rights reserved. + + File: XrayLib.NET.h + Author: Matthew Wormington + Language: C++/CLI + Compiler: Microsoft Visual Studio 2017 + Created: September 4, 2010 + $Version:$ + $Revision:$ + $RevDate:$ + + Description: + Contains the definition of a managed wrapper class around the native + XrayLib API. + + "A library for X-ray�matter interaction cross sections for + X-ray fluorescence applications". + A. Brunetti, M. Sanchez del Rio, B. Golosio, A. Simionovici, A. Somogyi, + Spectrochimica Acta Part B 59 (2004) 1725�1731 + http://ftp.esrf.fr/pub/scisoft/xraylib/ + + Notes: + A singleton pattern has been used so that only one instance of the class is ever + created. The Instance property provides a global point of access to the instance. + The implementation is based on the Static Initialization example in the following + Microsoft article: http://msdn.microsoft.com/en-us/library/ms998558.aspx + + + XrayLib copyright (c) 2009, Bruno Golosio, Antonio Brunetti, Manuel Sanchez del + Rio, Tom Schoonjans and Teemu Ikonen. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, this + list of conditions and the following disclaimer + in the documentation and/or other materials provided with the distribution. + * The names of the contributors may not be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY Bruno Golosio, Antonio Brunetti, Manuel Sanchez del Rio, + Tom Schoonjans, Teemu Ikonen and Matthew Wormington ''AS IS'' AND ANY EXPRESS OR IMPLIED + WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Bruno Golosio, Antonio + Brunetti, Manuel Sanchez del Rio, Tom Schoonjans and Teemu Ikonen BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + OF SUCH DAMAGE. +*/ + +#pragma once + +using namespace System; +using namespace System::Numerics; + +/// +/// A namespace that contains scientific classes. +/// +namespace Science { + + /// + /// A custom exception that inherits from Exception and is thrown by the XrayLib class. + /// + public ref class XrayLibException: Exception + { + public: + // Overloading the constructor for passing the message associated with the exception + XrayLibException(System::String ^message) : Exception(message) { } + }; + + /// + /// A managed wrapper around the XrayLib library for X-ray matter interaction cross sections + /// for X-ray fluorescence applications. + /// The XrayLib is a library of X-ray matter interaction data for X-ray fluorescence, + /// and other, applications. + /// Notes: + /// Version 3.4 contains improved error handling for the library functions and exposes the functions + /// as static methods of the XrayLib class. + /// References: + /// 1) A library for X-ray matter interaction cross sections for X-ray fluorescence applications. + /// A. Brunetti, M. Sanchez del Rio, B. Golosio, A. Simionovici, A. Somogyi, + /// Spectrochimica Acta Part B 59 (2004) 1725�1731 + /// 2) The xraylib library for X-ray�matter interactions.Recent developments. + /// T.Schoonjans, A.Brunetti, B.Golosio, M.Sanchez del Rio, V.A.Sol�, C.Ferrero, L.Vincze, + /// Spectrochimica Acta Part B 66 (2011) 776�784 + /// https://github.com/tschoonj/xraylib/ + + /// + public ref class XrayLib + { + private: + // Only the main lines are included in the following arrays + static array ^IUPACLineNames = + {"KL3","KL2","KM3","KN2","KM2","L3M5","L3M4","L2M4","L3N5", + "L1M3","L1M2","L3N1","L2N4","L1N2","L1N3","L2M1","L3M1"}; + + // In the SiegbahnLineName array, the following notation is used: + // a - alpha, b - beta, g - gamma, n - Nu, l - eta + static array ^SiegbahnLineNames = + {"Ka1","Ka2","Kb1","Kb2","Kb3","La1","La2","Lb1","Lb2", + "Lb3","Lb4","Lb6","Lg1","Lg2","Lg3","Ln","Ll"}; + static array ^SiegbahnLines = + {KA1_LINE,KA2_LINE,KB1_LINE,KB2_LINE,KB3_LINE,LA1_LINE,LA2_LINE,LB1_LINE,LB2_LINE, + LB3_LINE,LB4_LINE,LB6_LINE,LG1_LINE,LG2_LINE,LG3_LINE,LN_LINE,LL_LINE}; + + public: + #pragma region Constants + literal int VERSION_MAJOR = 4; + literal int VERSION_MINOR = 0; + literal double PI = 3.14159265359; + + // Values taken from physics.nist.gov + literal double AVOGNUM = 0.602214129; // Avogadro number (mol-1 * barn-1 * cm2) + literal double KEV2ANGST = 12.39841930; // keV to Angstrom-1 conversion factor + literal double MEC2 = 510.998928; // Electron rest mass (keV) + literal double RE2 = 0.079407877; // Square of classical electron radius (barn) + literal double R_E = 2.8179403267e-15; // Classical electron radius (m) + + // IUPAC lines + literal int KL1_LINE = -1; + literal int KL2_LINE = -2; + literal int KL3_LINE = -3; + literal int KM1_LINE = -4; + literal int KM2_LINE = -5; + literal int KM3_LINE = -6; + literal int KM4_LINE = -7; + literal int KM5_LINE = -8; + literal int KN1_LINE = -9; + literal int KN2_LINE = -10; + literal int KN3_LINE = -11; + literal int KN4_LINE = -12; + literal int KN5_LINE = -13; + literal int KN6_LINE = -14; + literal int KN7_LINE = -15; + literal int KO_LINE = -16; + literal int KO1_LINE = -17; + literal int KO2_LINE = -18; + literal int KO3_LINE = -19; + literal int KO4_LINE = -20; + literal int KO5_LINE = -21; + literal int KO6_LINE = -22; + literal int KO7_LINE = -23; + literal int KP_LINE = -24; + literal int KP1_LINE = -25; + literal int KP2_LINE = -26; + literal int KP3_LINE = -27; + literal int KP4_LINE = -28; + literal int KP5_LINE = -29; + literal int L1L2_LINE = -30; + literal int L1L3_LINE = -31; + literal int L1M1_LINE = -32; + literal int L1M2_LINE = -33; + literal int L1M3_LINE = -34; + literal int L1M4_LINE = -35; + literal int L1M5_LINE = -36; + literal int L1N1_LINE = -37; + literal int L1N2_LINE = -38; + literal int L1N3_LINE = -39; + literal int L1N4_LINE = -40; + literal int L1N5_LINE = -41; + literal int L1N6_LINE = -42; + literal int L1N67_LINE = -43; + literal int L1N7_LINE = -44; + literal int L1O1_LINE = -45; + literal int L1O2_LINE = -46; + literal int L1O3_LINE = -47; + literal int L1O4_LINE = -48; + literal int L1O45_LINE = -49; + literal int L1O5_LINE = -50; + literal int L1O6_LINE = -51; + literal int L1O7_LINE = -52; + literal int L1P1_LINE = -53; + literal int L1P2_LINE = -54; + literal int L1P23_LINE = -55; + literal int L1P3_LINE = -56; + literal int L1P4_LINE = -57; + literal int L1P5_LINE = -58; + literal int L2L3_LINE = -59; + literal int L2M1_LINE = -60; + literal int L2M2_LINE = -61; + literal int L2M3_LINE = -62; + literal int L2M4_LINE = -63; + literal int L2M5_LINE = -64; + literal int L2N1_LINE = -65; + literal int L2N2_LINE = -66; + literal int L2N3_LINE = -67; + literal int L2N4_LINE = -68; + literal int L2N5_LINE = -69; + literal int L2N6_LINE = -70; + literal int L2N7_LINE = -71; + literal int L2O1_LINE = -72; + literal int L2O2_LINE = -73; + literal int L2O3_LINE = -74; + literal int L2O4_LINE = -75; + literal int L2O5_LINE = -76; + literal int L2O6_LINE = -77; + literal int L2O7_LINE = -78; + literal int L2P1_LINE = -79; + literal int L2P2_LINE = -80; + literal int L2P23_LINE = -81; + literal int L2P3_LINE = -82; + literal int L2P4_LINE = -83; + literal int L2P5_LINE = -84; + literal int L2Q1_LINE = -85; + literal int L3M1_LINE = -86; + literal int L3M2_LINE = -87; + literal int L3M3_LINE = -88; + literal int L3M4_LINE = -89; + literal int L3M5_LINE = -90; + literal int L3N1_LINE = -91; + literal int L3N2_LINE = -92; + literal int L3N3_LINE = -93; + literal int L3N4_LINE = -94; + literal int L3N5_LINE = -95; + literal int L3N6_LINE = -96; + literal int L3N7_LINE = -97; + literal int L3O1_LINE = -98; + literal int L3O2_LINE = -99; + literal int L3O3_LINE = -100; + literal int L3O4_LINE = -101; + literal int L3O45_LINE = -102; + literal int L3O5_LINE = -103; + literal int L3O6_LINE = -104; + literal int L3O7_LINE = -105; + literal int L3P1_LINE = -106; + literal int L3P2_LINE = -107; + literal int L3P23_LINE = -108; + literal int L3P3_LINE = -109; + literal int L3P4_LINE = -110; + literal int L3P45_LINE = -111; + literal int L3P5_LINE = -112; + literal int L3Q1_LINE = -113; + literal int M1M2_LINE = -114; + literal int M1M3_LINE = -115; + literal int M1M4_LINE = -116; + literal int M1M5_LINE = -117; + literal int M1N1_LINE = -118; + literal int M1N2_LINE = -119; + literal int M1N3_LINE = -120; + literal int M1N4_LINE = -121; + literal int M1N5_LINE = -122; + literal int M1N6_LINE = -123; + literal int M1N7_LINE = -124; + literal int M1O1_LINE = -125; + literal int M1O2_LINE = -126; + literal int M1O3_LINE = -127; + literal int M1O4_LINE = -128; + literal int M1O5_LINE = -129; + literal int M1O6_LINE = -130; + literal int M1O7_LINE = -131; + literal int M1P1_LINE = -132; + literal int M1P2_LINE = -133; + literal int M1P3_LINE = -134; + literal int M1P4_LINE = -135; + literal int M1P5_LINE = -136; + literal int M2M3_LINE = -137; + literal int M2M4_LINE = -138; + literal int M2M5_LINE = -139; + literal int M2N1_LINE = -140; + literal int M2N2_LINE = -141; + literal int M2N3_LINE = -142; + literal int M2N4_LINE = -143; + literal int M2N5_LINE = -144; + literal int M2N6_LINE = -145; + literal int M2N7_LINE = -146; + literal int M2O1_LINE = -147; + literal int M2O2_LINE = -148; + literal int M2O3_LINE = -149; + literal int M2O4_LINE = -150; + literal int M2O5_LINE = -151; + literal int M2O6_LINE = -152; + literal int M2O7_LINE = -153; + literal int M2P1_LINE = -154; + literal int M2P2_LINE = -155; + literal int M2P3_LINE = -156; + literal int M2P4_LINE = -157; + literal int M2P5_LINE = -158; + literal int M3M4_LINE = -159; + literal int M3M5_LINE = -160; + literal int M3N1_LINE = -161; + literal int M3N2_LINE = -162; + literal int M3N3_LINE = -163; + literal int M3N4_LINE = -164; + literal int M3N5_LINE = -165; + literal int M3N6_LINE = -166; + literal int M3N7_LINE = -167; + literal int M3O1_LINE = -168; + literal int M3O2_LINE = -169; + literal int M3O3_LINE = -170; + literal int M3O4_LINE = -171; + literal int M3O5_LINE = -172; + literal int M3O6_LINE = -173; + literal int M3O7_LINE = -174; + literal int M3P1_LINE = -175; + literal int M3P2_LINE = -176; + literal int M3P3_LINE = -177; + literal int M3P4_LINE = -178; + literal int M3P5_LINE = -179; + literal int M3Q1_LINE = -180; + literal int M4M5_LINE = -181; + literal int M4N1_LINE = -182; + literal int M4N2_LINE = -183; + literal int M4N3_LINE = -184; + literal int M4N4_LINE = -185; + literal int M4N5_LINE = -186; + literal int M4N6_LINE = -187; + literal int M4N7_LINE = -188; + literal int M4O1_LINE = -189; + literal int M4O2_LINE = -190; + literal int M4O3_LINE = -191; + literal int M4O4_LINE = -192; + literal int M4O5_LINE = -193; + literal int M4O6_LINE = -194; + literal int M4O7_LINE = -195; + literal int M4P1_LINE = -196; + literal int M4P2_LINE = -197; + literal int M4P3_LINE = -198; + literal int M4P4_LINE = -199; + literal int M4P5_LINE = -200; + literal int M5N1_LINE = -201; + literal int M5N2_LINE = -202; + literal int M5N3_LINE = -203; + literal int M5N4_LINE = -204; + literal int M5N5_LINE = -205; + literal int M5N6_LINE = -206; + literal int M5N7_LINE = -207; + literal int M5O1_LINE = -208; + literal int M5O2_LINE = -209; + literal int M5O3_LINE = -210; + literal int M5O4_LINE = -211; + literal int M5O5_LINE = -212; + literal int M5O6_LINE = -213; + literal int M5O7_LINE = -214; + literal int M5P1_LINE = -215; + literal int M5P2_LINE = -216; + literal int M5P3_LINE = -217; + literal int M5P4_LINE = -218; + literal int M5P5_LINE = -219; + literal int N1N2_LINE = -220; + literal int N1N3_LINE = -221; + literal int N1N4_LINE = -222; + literal int N1N5_LINE = -223; + literal int N1N6_LINE = -224; + literal int N1N7_LINE = -225; + literal int N1O1_LINE = -226; + literal int N1O2_LINE = -227; + literal int N1O3_LINE = -228; + literal int N1O4_LINE = -229; + literal int N1O5_LINE = -230; + literal int N1O6_LINE = -231; + literal int N1O7_LINE = -232; + literal int N1P1_LINE = -233; + literal int N1P2_LINE = -234; + literal int N1P3_LINE = -235; + literal int N1P4_LINE = -236; + literal int N1P5_LINE = -237; + literal int N2N3_LINE = -238; + literal int N2N4_LINE = -239; + literal int N2N5_LINE = -240; + literal int N2N6_LINE = -241; + literal int N2N7_LINE = -242; + literal int N2O1_LINE = -243; + literal int N2O2_LINE = -244; + literal int N2O3_LINE = -245; + literal int N2O4_LINE = -246; + literal int N2O5_LINE = -247; + literal int N2O6_LINE = -248; + literal int N2O7_LINE = -249; + literal int N2P1_LINE = -250; + literal int N2P2_LINE = -251; + literal int N2P3_LINE = -252; + literal int N2P4_LINE = -253; + literal int N2P5_LINE = -254; + literal int N3N4_LINE = -255; + literal int N3N5_LINE = -256; + literal int N3N6_LINE = -257; + literal int N3N7_LINE = -258; + literal int N3O1_LINE = -259; + literal int N3O2_LINE = -260; + literal int N3O3_LINE = -261; + literal int N3O4_LINE = -262; + literal int N3O5_LINE = -263; + literal int N3O6_LINE = -264; + literal int N3O7_LINE = -265; + literal int N3P1_LINE = -266; + literal int N3P2_LINE = -267; + literal int N3P3_LINE = -268; + literal int N3P4_LINE = -269; + literal int N3P5_LINE = -270; + literal int N4N5_LINE = -271; + literal int N4N6_LINE = -272; + literal int N4N7_LINE = -273; + literal int N4O1_LINE = -274; + literal int N4O2_LINE = -275; + literal int N4O3_LINE = -276; + literal int N4O4_LINE = -277; + literal int N4O5_LINE = -278; + literal int N4O6_LINE = -279; + literal int N4O7_LINE = -280; + literal int N4P1_LINE = -281; + literal int N4P2_LINE = -282; + literal int N4P3_LINE = -283; + literal int N4P4_LINE = -284; + literal int N4P5_LINE = -285; + literal int N5N6_LINE = -286; + literal int N5N7_LINE = -287; + literal int N5O1_LINE = -288; + literal int N5O2_LINE = -289; + literal int N5O3_LINE = -290; + literal int N5O4_LINE = -291; + literal int N5O5_LINE = -292; + literal int N5O6_LINE = -293; + literal int N5O7_LINE = -294; + literal int N5P1_LINE = -295; + literal int N5P2_LINE = -296; + literal int N5P3_LINE = -297; + literal int N5P4_LINE = -298; + literal int N5P5_LINE = -299; + literal int N6N7_LINE = -300; + literal int N6O1_LINE = -301; + literal int N6O2_LINE = -302; + literal int N6O3_LINE = -303; + literal int N6O4_LINE = -304; + literal int N6O5_LINE = -305; + literal int N6O6_LINE = -306; + literal int N6O7_LINE = -307; + literal int N6P1_LINE = -308; + literal int N6P2_LINE = -309; + literal int N6P3_LINE = -310; + literal int N6P4_LINE = -311; + literal int N6P5_LINE = -312; + literal int N7O1_LINE = -313; + literal int N7O2_LINE = -314; + literal int N7O3_LINE = -315; + literal int N7O4_LINE = -316; + literal int N7O5_LINE = -317; + literal int N7O6_LINE = -318; + literal int N7O7_LINE = -319; + literal int N7P1_LINE = -320; + literal int N7P2_LINE = -321; + literal int N7P3_LINE = -322; + literal int N7P4_LINE = -323; + literal int N7P5_LINE = -324; + literal int O1O2_LINE = -325; + literal int O1O3_LINE = -326; + literal int O1O4_LINE = -327; + literal int O1O5_LINE = -328; + literal int O1O6_LINE = -329; + literal int O1O7_LINE = -330; + literal int O1P1_LINE = -331; + literal int O1P2_LINE = -332; + literal int O1P3_LINE = -333; + literal int O1P4_LINE = -334; + literal int O1P5_LINE = -335; + literal int O2O3_LINE = -336; + literal int O2O4_LINE = -337; + literal int O2O5_LINE = -338; + literal int O2O6_LINE = -339; + literal int O2O7_LINE = -340; + literal int O2P1_LINE = -341; + literal int O2P2_LINE = -342; + literal int O2P3_LINE = -343; + literal int O2P4_LINE = -344; + literal int O2P5_LINE = -345; + literal int O3O4_LINE = -346; + literal int O3O5_LINE = -347; + literal int O3O6_LINE = -348; + literal int O3O7_LINE = -349; + literal int O3P1_LINE = -350; + literal int O3P2_LINE = -351; + literal int O3P3_LINE = -352; + literal int O3P4_LINE = -353; + literal int O3P5_LINE = -354; + literal int O4O5_LINE = -355; + literal int O4O6_LINE = -356; + literal int O4O7_LINE = -357; + literal int O4P1_LINE = -358; + literal int O4P2_LINE = -359; + literal int O4P3_LINE = -360; + literal int O4P4_LINE = -361; + literal int O4P5_LINE = -362; + literal int O5O6_LINE = -363; + literal int O5O7_LINE = -364; + literal int O5P1_LINE = -365; + literal int O5P2_LINE = -366; + literal int O5P3_LINE = -367; + literal int O5P4_LINE = -368; + literal int O5P5_LINE = -369; + literal int O6O7_LINE = -370; + literal int O6P4_LINE = -371; + literal int O6P5_LINE = -372; + literal int O7P4_LINE = -373; + literal int O7P5_LINE = -374; + literal int P1P2_LINE = -375; + literal int P1P3_LINE = -376; + literal int P1P4_LINE = -377; + literal int P1P5_LINE = -378; + literal int P2P3_LINE = -379; + literal int P2P4_LINE = -380; + literal int P2P5_LINE = -381; + literal int P3P4_LINE = -382; + literal int P3P5_LINE = -383; + + // Siegbahn notation + // according to Table VIII.2 from Nomenclature system for X-ray spectroscopy + // Linegroups -> usage is discouraged + literal int KA_LINE = 0; // Weighted average of KA1 & KA2 + literal int KB_LINE = 1; // Weighted average of KB1 & KB3 + literal int LA_LINE = 2; // LA1 + literal int LB_LINE = 3; // LB1 + + // Single lines + literal int KA1_LINE = KL3_LINE; + literal int KA2_LINE = KL2_LINE; + literal int KA3_LINE = KL1_LINE; + literal int KB1_LINE = KM3_LINE; + literal int KB2_LINE = KN3_LINE; + literal int KB3_LINE = KM2_LINE; + literal int KB4_LINE = KN5_LINE; + literal int KB5_LINE = KM5_LINE; + + literal int LA1_LINE = L3M5_LINE; + literal int LA2_LINE = L3M4_LINE; + literal int LB1_LINE = L2M4_LINE; + literal int LB2_LINE = L3N5_LINE; + literal int LB3_LINE = L1M3_LINE; + literal int LB4_LINE = L1M2_LINE; + literal int LB5_LINE = L3O45_LINE; + literal int LB6_LINE = L3N1_LINE; + literal int LB7_LINE = L3O1_LINE; + literal int LB9_LINE = L1M5_LINE; + literal int LB10_LINE = L1M4_LINE; + literal int LB15_LINE = L3N4_LINE; + literal int LB17_LINE = L2M3_LINE; + literal int LG1_LINE = L2N4_LINE; + literal int LG2_LINE = L1N2_LINE; + literal int LG3_LINE = L1N3_LINE; + literal int LG4_LINE = L1O3_LINE; + literal int LG5_LINE = L2N1_LINE; + literal int LG6_LINE = L2O4_LINE; + literal int LG8_LINE = L2O1_LINE; + literal int LE_LINE = L2M1_LINE; + literal int LH_LINE = L2M1_LINE; + literal int LN_LINE = L2M1_LINE; + literal int LL_LINE = L3M1_LINE; + literal int LS_LINE = L3M3_LINE; + literal int LT_LINE = L3M2_LINE; + literal int LU_LINE = L3N6_LINE; + literal int LV_LINE = L2N6_LINE; + + literal int MA1_LINE = M5N7_LINE; + literal int MA2_LINE = M5N6_LINE; + literal int MB_LINE = M4N6_LINE; + literal int MG_LINE = M3N5_LINE; + + // Shells + literal int K_SHELL = 0; + literal int L1_SHELL = 1; + literal int L2_SHELL = 2; + literal int L3_SHELL = 3; + literal int M1_SHELL = 4; + literal int M2_SHELL = 5; + literal int M3_SHELL = 6; + literal int M4_SHELL = 7; + literal int M5_SHELL = 8; + literal int N1_SHELL = 9; + literal int N2_SHELL = 10; + literal int N3_SHELL = 11; + literal int N4_SHELL = 12; + literal int N5_SHELL = 13; + literal int N6_SHELL = 14; + literal int N7_SHELL = 15; + literal int O1_SHELL = 16; + literal int O2_SHELL = 17; + literal int O3_SHELL = 18; + literal int O4_SHELL = 19; + literal int O5_SHELL = 20; + literal int O6_SHELL = 21; + literal int O7_SHELL = 22; + literal int P1_SHELL = 23; + literal int P2_SHELL = 24; + literal int P3_SHELL = 25; + literal int P4_SHELL = 26; + literal int P5_SHELL = 27; + literal int Q1_SHELL = 28; + literal int Q2_SHELL = 29; + literal int Q3_SHELL = 30; + + // Transitions + literal int F1_TRANS = 0; + literal int F12_TRANS = 1; + literal int F13_TRANS = 2; + literal int FP13_TRANS = 3; + literal int F23_TRANS = 4; + + literal int FL12_TRANS = 1; + literal int FL13_TRANS = 2; + literal int FLP13_TRANS = 3; + literal int FL23_TRANS = 4; + literal int FM12_TRANS = 5; + literal int FM13_TRANS = 6; + literal int FM14_TRANS = 7; + literal int FM15_TRANS = 8; + literal int FM23_TRANS = 9; + literal int FM24_TRANS = 10; + literal int FM25_TRANS = 11; + literal int FM34_TRANS = 12; + literal int FM35_TRANS = 13; + literal int FM45_TRANS = 14; + + // Auger transitions + literal int K_L1L1_AUGER = 0; + literal int K_L1L2_AUGER = 1; + literal int K_L1L3_AUGER = 2; + literal int K_L1M1_AUGER = 3; + literal int K_L1M2_AUGER = 4; + literal int K_L1M3_AUGER = 5; + literal int K_L1M4_AUGER = 6; + literal int K_L1M5_AUGER = 7; + literal int K_L1N1_AUGER = 8; + literal int K_L1N2_AUGER = 9; + literal int K_L1N3_AUGER = 10; + literal int K_L1N4_AUGER = 11; + literal int K_L1N5_AUGER = 12; + literal int K_L1N6_AUGER = 13; + literal int K_L1N7_AUGER = 14; + literal int K_L1O1_AUGER = 15; + literal int K_L1O2_AUGER = 16; + literal int K_L1O3_AUGER = 17; + literal int K_L1O4_AUGER = 18; + literal int K_L1O5_AUGER = 19; + literal int K_L1O6_AUGER = 20; + literal int K_L1O7_AUGER = 21; + literal int K_L1P1_AUGER = 22; + literal int K_L1P2_AUGER = 23; + literal int K_L1P3_AUGER = 24; + literal int K_L1P4_AUGER = 25; + literal int K_L1P5_AUGER = 26; + literal int K_L1Q1_AUGER = 27; + literal int K_L1Q2_AUGER = 28; + literal int K_L1Q3_AUGER = 29; + literal int K_L2L1_AUGER = 30; + literal int K_L2L2_AUGER = 31; + literal int K_L2L3_AUGER = 32; + literal int K_L2M1_AUGER = 33; + literal int K_L2M2_AUGER = 34; + literal int K_L2M3_AUGER = 35; + literal int K_L2M4_AUGER = 36; + literal int K_L2M5_AUGER = 37; + literal int K_L2N1_AUGER = 38; + literal int K_L2N2_AUGER = 39; + literal int K_L2N3_AUGER = 40; + literal int K_L2N4_AUGER = 41; + literal int K_L2N5_AUGER = 42; + literal int K_L2N6_AUGER = 43; + literal int K_L2N7_AUGER = 44; + literal int K_L2O1_AUGER = 45; + literal int K_L2O2_AUGER = 46; + literal int K_L2O3_AUGER = 47; + literal int K_L2O4_AUGER = 48; + literal int K_L2O5_AUGER = 49; + literal int K_L2O6_AUGER = 50; + literal int K_L2O7_AUGER = 51; + literal int K_L2P1_AUGER = 52; + literal int K_L2P2_AUGER = 53; + literal int K_L2P3_AUGER = 54; + literal int K_L2P4_AUGER = 55; + literal int K_L2P5_AUGER = 56; + literal int K_L2Q1_AUGER = 57; + literal int K_L2Q2_AUGER = 58; + literal int K_L2Q3_AUGER = 59; + literal int K_L3L1_AUGER = 60; + literal int K_L3L2_AUGER = 61; + literal int K_L3L3_AUGER = 62; + literal int K_L3M1_AUGER = 63; + literal int K_L3M2_AUGER = 64; + literal int K_L3M3_AUGER = 65; + literal int K_L3M4_AUGER = 66; + literal int K_L3M5_AUGER = 67; + literal int K_L3N1_AUGER = 68; + literal int K_L3N2_AUGER = 69; + literal int K_L3N3_AUGER = 70; + literal int K_L3N4_AUGER = 71; + literal int K_L3N5_AUGER = 72; + literal int K_L3N6_AUGER = 73; + literal int K_L3N7_AUGER = 74; + literal int K_L3O1_AUGER = 75; + literal int K_L3O2_AUGER = 76; + literal int K_L3O3_AUGER = 77; + literal int K_L3O4_AUGER = 78; + literal int K_L3O5_AUGER = 79; + literal int K_L3O6_AUGER = 80; + literal int K_L3O7_AUGER = 81; + literal int K_L3P1_AUGER = 82; + literal int K_L3P2_AUGER = 83; + literal int K_L3P3_AUGER = 84; + literal int K_L3P4_AUGER = 85; + literal int K_L3P5_AUGER = 86; + literal int K_L3Q1_AUGER = 87; + literal int K_L3Q2_AUGER = 88; + literal int K_L3Q3_AUGER = 89; + literal int K_M1L1_AUGER = 90; + literal int K_M1L2_AUGER = 91; + literal int K_M1L3_AUGER = 92; + literal int K_M1M1_AUGER = 93; + literal int K_M1M2_AUGER = 94; + literal int K_M1M3_AUGER = 95; + literal int K_M1M4_AUGER = 96; + literal int K_M1M5_AUGER = 97; + literal int K_M1N1_AUGER = 98; + literal int K_M1N2_AUGER = 99; + literal int K_M1N3_AUGER = 100; + literal int K_M1N4_AUGER = 101; + literal int K_M1N5_AUGER = 102; + literal int K_M1N6_AUGER = 103; + literal int K_M1N7_AUGER = 104; + literal int K_M1O1_AUGER = 105; + literal int K_M1O2_AUGER = 106; + literal int K_M1O3_AUGER = 107; + literal int K_M1O4_AUGER = 108; + literal int K_M1O5_AUGER = 109; + literal int K_M1O6_AUGER = 110; + literal int K_M1O7_AUGER = 111; + literal int K_M1P1_AUGER = 112; + literal int K_M1P2_AUGER = 113; + literal int K_M1P3_AUGER = 114; + literal int K_M1P4_AUGER = 115; + literal int K_M1P5_AUGER = 116; + literal int K_M1Q1_AUGER = 117; + literal int K_M1Q2_AUGER = 118; + literal int K_M1Q3_AUGER = 119; + literal int K_M2L1_AUGER = 120; + literal int K_M2L2_AUGER = 121; + literal int K_M2L3_AUGER = 122; + literal int K_M2M1_AUGER = 123; + literal int K_M2M2_AUGER = 124; + literal int K_M2M3_AUGER = 125; + literal int K_M2M4_AUGER = 126; + literal int K_M2M5_AUGER = 127; + literal int K_M2N1_AUGER = 128; + literal int K_M2N2_AUGER = 129; + literal int K_M2N3_AUGER = 130; + literal int K_M2N4_AUGER = 131; + literal int K_M2N5_AUGER = 132; + literal int K_M2N6_AUGER = 133; + literal int K_M2N7_AUGER = 134; + literal int K_M2O1_AUGER = 135; + literal int K_M2O2_AUGER = 136; + literal int K_M2O3_AUGER = 137; + literal int K_M2O4_AUGER = 138; + literal int K_M2O5_AUGER = 139; + literal int K_M2O6_AUGER = 140; + literal int K_M2O7_AUGER = 141; + literal int K_M2P1_AUGER = 142; + literal int K_M2P2_AUGER = 143; + literal int K_M2P3_AUGER = 144; + literal int K_M2P4_AUGER = 145; + literal int K_M2P5_AUGER = 146; + literal int K_M2Q1_AUGER = 147; + literal int K_M2Q2_AUGER = 148; + literal int K_M2Q3_AUGER = 149; + literal int K_M3L1_AUGER = 150; + literal int K_M3L2_AUGER = 151; + literal int K_M3L3_AUGER = 152; + literal int K_M3M1_AUGER = 153; + literal int K_M3M2_AUGER = 154; + literal int K_M3M3_AUGER = 155; + literal int K_M3M4_AUGER = 156; + literal int K_M3M5_AUGER = 157; + literal int K_M3N1_AUGER = 158; + literal int K_M3N2_AUGER = 159; + literal int K_M3N3_AUGER = 160; + literal int K_M3N4_AUGER = 161; + literal int K_M3N5_AUGER = 162; + literal int K_M3N6_AUGER = 163; + literal int K_M3N7_AUGER = 164; + literal int K_M3O1_AUGER = 165; + literal int K_M3O2_AUGER = 166; + literal int K_M3O3_AUGER = 167; + literal int K_M3O4_AUGER = 168; + literal int K_M3O5_AUGER = 169; + literal int K_M3O6_AUGER = 170; + literal int K_M3O7_AUGER = 171; + literal int K_M3P1_AUGER = 172; + literal int K_M3P2_AUGER = 173; + literal int K_M3P3_AUGER = 174; + literal int K_M3P4_AUGER = 175; + literal int K_M3P5_AUGER = 176; + literal int K_M3Q1_AUGER = 177; + literal int K_M3Q2_AUGER = 178; + literal int K_M3Q3_AUGER = 179; + literal int K_M4L1_AUGER = 180; + literal int K_M4L2_AUGER = 181; + literal int K_M4L3_AUGER = 182; + literal int K_M4M1_AUGER = 183; + literal int K_M4M2_AUGER = 184; + literal int K_M4M3_AUGER = 185; + literal int K_M4M4_AUGER = 186; + literal int K_M4M5_AUGER = 187; + literal int K_M4N1_AUGER = 188; + literal int K_M4N2_AUGER = 189; + literal int K_M4N3_AUGER = 190; + literal int K_M4N4_AUGER = 191; + literal int K_M4N5_AUGER = 192; + literal int K_M4N6_AUGER = 193; + literal int K_M4N7_AUGER = 194; + literal int K_M4O1_AUGER = 195; + literal int K_M4O2_AUGER = 196; + literal int K_M4O3_AUGER = 197; + literal int K_M4O4_AUGER = 198; + literal int K_M4O5_AUGER = 199; + literal int K_M4O6_AUGER = 200; + literal int K_M4O7_AUGER = 201; + literal int K_M4P1_AUGER = 202; + literal int K_M4P2_AUGER = 203; + literal int K_M4P3_AUGER = 204; + literal int K_M4P4_AUGER = 205; + literal int K_M4P5_AUGER = 206; + literal int K_M4Q1_AUGER = 207; + literal int K_M4Q2_AUGER = 208; + literal int K_M4Q3_AUGER = 209; + literal int K_M5L1_AUGER = 210; + literal int K_M5L2_AUGER = 211; + literal int K_M5L3_AUGER = 212; + literal int K_M5M1_AUGER = 213; + literal int K_M5M2_AUGER = 214; + literal int K_M5M3_AUGER = 215; + literal int K_M5M4_AUGER = 216; + literal int K_M5M5_AUGER = 217; + literal int K_M5N1_AUGER = 218; + literal int K_M5N2_AUGER = 219; + literal int K_M5N3_AUGER = 220; + literal int K_M5N4_AUGER = 221; + literal int K_M5N5_AUGER = 222; + literal int K_M5N6_AUGER = 223; + literal int K_M5N7_AUGER = 224; + literal int K_M5O1_AUGER = 225; + literal int K_M5O2_AUGER = 226; + literal int K_M5O3_AUGER = 227; + literal int K_M5O4_AUGER = 228; + literal int K_M5O5_AUGER = 229; + literal int K_M5O6_AUGER = 230; + literal int K_M5O7_AUGER = 231; + literal int K_M5P1_AUGER = 232; + literal int K_M5P2_AUGER = 233; + literal int K_M5P3_AUGER = 234; + literal int K_M5P4_AUGER = 235; + literal int K_M5P5_AUGER = 236; + literal int K_M5Q1_AUGER = 237; + literal int K_M5Q2_AUGER = 238; + literal int K_M5Q3_AUGER = 239; + literal int L1_L2L2_AUGER = 240; + literal int L1_L2L3_AUGER = 241; + literal int L1_L2M1_AUGER = 242; + literal int L1_L2M2_AUGER = 243; + literal int L1_L2M3_AUGER = 244; + literal int L1_L2M4_AUGER = 245; + literal int L1_L2M5_AUGER = 246; + literal int L1_L2N1_AUGER = 247; + literal int L1_L2N2_AUGER = 248; + literal int L1_L2N3_AUGER = 249; + literal int L1_L2N4_AUGER = 250; + literal int L1_L2N5_AUGER = 251; + literal int L1_L2N6_AUGER = 252; + literal int L1_L2N7_AUGER = 253; + literal int L1_L2O1_AUGER = 254; + literal int L1_L2O2_AUGER = 255; + literal int L1_L2O3_AUGER = 256; + literal int L1_L2O4_AUGER = 257; + literal int L1_L2O5_AUGER = 258; + literal int L1_L2O6_AUGER = 259; + literal int L1_L2O7_AUGER = 260; + literal int L1_L2P1_AUGER = 261; + literal int L1_L2P2_AUGER = 262; + literal int L1_L2P3_AUGER = 263; + literal int L1_L2P4_AUGER = 264; + literal int L1_L2P5_AUGER = 265; + literal int L1_L2Q1_AUGER = 266; + literal int L1_L2Q2_AUGER = 267; + literal int L1_L2Q3_AUGER = 268; + literal int L1_L3L2_AUGER = 269; + literal int L1_L3L3_AUGER = 270; + literal int L1_L3M1_AUGER = 271; + literal int L1_L3M2_AUGER = 272; + literal int L1_L3M3_AUGER = 273; + literal int L1_L3M4_AUGER = 274; + literal int L1_L3M5_AUGER = 275; + literal int L1_L3N1_AUGER = 276; + literal int L1_L3N2_AUGER = 277; + literal int L1_L3N3_AUGER = 278; + literal int L1_L3N4_AUGER = 279; + literal int L1_L3N5_AUGER = 280; + literal int L1_L3N6_AUGER = 281; + literal int L1_L3N7_AUGER = 282; + literal int L1_L3O1_AUGER = 283; + literal int L1_L3O2_AUGER = 284; + literal int L1_L3O3_AUGER = 285; + literal int L1_L3O4_AUGER = 286; + literal int L1_L3O5_AUGER = 287; + literal int L1_L3O6_AUGER = 288; + literal int L1_L3O7_AUGER = 289; + literal int L1_L3P1_AUGER = 290; + literal int L1_L3P2_AUGER = 291; + literal int L1_L3P3_AUGER = 292; + literal int L1_L3P4_AUGER = 293; + literal int L1_L3P5_AUGER = 294; + literal int L1_L3Q1_AUGER = 295; + literal int L1_L3Q2_AUGER = 296; + literal int L1_L3Q3_AUGER = 297; + literal int L1_M1L2_AUGER = 298; + literal int L1_M1L3_AUGER = 299; + literal int L1_M1M1_AUGER = 300; + literal int L1_M1M2_AUGER = 301; + literal int L1_M1M3_AUGER = 302; + literal int L1_M1M4_AUGER = 303; + literal int L1_M1M5_AUGER = 304; + literal int L1_M1N1_AUGER = 305; + literal int L1_M1N2_AUGER = 306; + literal int L1_M1N3_AUGER = 307; + literal int L1_M1N4_AUGER = 308; + literal int L1_M1N5_AUGER = 309; + literal int L1_M1N6_AUGER = 310; + literal int L1_M1N7_AUGER = 311; + literal int L1_M1O1_AUGER = 312; + literal int L1_M1O2_AUGER = 313; + literal int L1_M1O3_AUGER = 314; + literal int L1_M1O4_AUGER = 315; + literal int L1_M1O5_AUGER = 316; + literal int L1_M1O6_AUGER = 317; + literal int L1_M1O7_AUGER = 318; + literal int L1_M1P1_AUGER = 319; + literal int L1_M1P2_AUGER = 320; + literal int L1_M1P3_AUGER = 321; + literal int L1_M1P4_AUGER = 322; + literal int L1_M1P5_AUGER = 323; + literal int L1_M1Q1_AUGER = 324; + literal int L1_M1Q2_AUGER = 325; + literal int L1_M1Q3_AUGER = 326; + literal int L1_M2L2_AUGER = 327; + literal int L1_M2L3_AUGER = 328; + literal int L1_M2M1_AUGER = 329; + literal int L1_M2M2_AUGER = 330; + literal int L1_M2M3_AUGER = 331; + literal int L1_M2M4_AUGER = 332; + literal int L1_M2M5_AUGER = 333; + literal int L1_M2N1_AUGER = 334; + literal int L1_M2N2_AUGER = 335; + literal int L1_M2N3_AUGER = 336; + literal int L1_M2N4_AUGER = 337; + literal int L1_M2N5_AUGER = 338; + literal int L1_M2N6_AUGER = 339; + literal int L1_M2N7_AUGER = 340; + literal int L1_M2O1_AUGER = 341; + literal int L1_M2O2_AUGER = 342; + literal int L1_M2O3_AUGER = 343; + literal int L1_M2O4_AUGER = 344; + literal int L1_M2O5_AUGER = 345; + literal int L1_M2O6_AUGER = 346; + literal int L1_M2O7_AUGER = 347; + literal int L1_M2P1_AUGER = 348; + literal int L1_M2P2_AUGER = 349; + literal int L1_M2P3_AUGER = 350; + literal int L1_M2P4_AUGER = 351; + literal int L1_M2P5_AUGER = 352; + literal int L1_M2Q1_AUGER = 353; + literal int L1_M2Q2_AUGER = 354; + literal int L1_M2Q3_AUGER = 355; + literal int L1_M3L2_AUGER = 356; + literal int L1_M3L3_AUGER = 357; + literal int L1_M3M1_AUGER = 358; + literal int L1_M3M2_AUGER = 359; + literal int L1_M3M3_AUGER = 360; + literal int L1_M3M4_AUGER = 361; + literal int L1_M3M5_AUGER = 362; + literal int L1_M3N1_AUGER = 363; + literal int L1_M3N2_AUGER = 364; + literal int L1_M3N3_AUGER = 365; + literal int L1_M3N4_AUGER = 366; + literal int L1_M3N5_AUGER = 367; + literal int L1_M3N6_AUGER = 368; + literal int L1_M3N7_AUGER = 369; + literal int L1_M3O1_AUGER = 370; + literal int L1_M3O2_AUGER = 371; + literal int L1_M3O3_AUGER = 372; + literal int L1_M3O4_AUGER = 373; + literal int L1_M3O5_AUGER = 374; + literal int L1_M3O6_AUGER = 375; + literal int L1_M3O7_AUGER = 376; + literal int L1_M3P1_AUGER = 377; + literal int L1_M3P2_AUGER = 378; + literal int L1_M3P3_AUGER = 379; + literal int L1_M3P4_AUGER = 380; + literal int L1_M3P5_AUGER = 381; + literal int L1_M3Q1_AUGER = 382; + literal int L1_M3Q2_AUGER = 383; + literal int L1_M3Q3_AUGER = 384; + literal int L1_M4L2_AUGER = 385; + literal int L1_M4L3_AUGER = 386; + literal int L1_M4M1_AUGER = 387; + literal int L1_M4M2_AUGER = 388; + literal int L1_M4M3_AUGER = 389; + literal int L1_M4M4_AUGER = 390; + literal int L1_M4M5_AUGER = 391; + literal int L1_M4N1_AUGER = 392; + literal int L1_M4N2_AUGER = 393; + literal int L1_M4N3_AUGER = 394; + literal int L1_M4N4_AUGER = 395; + literal int L1_M4N5_AUGER = 396; + literal int L1_M4N6_AUGER = 397; + literal int L1_M4N7_AUGER = 398; + literal int L1_M4O1_AUGER = 399; + literal int L1_M4O2_AUGER = 400; + literal int L1_M4O3_AUGER = 401; + literal int L1_M4O4_AUGER = 402; + literal int L1_M4O5_AUGER = 403; + literal int L1_M4O6_AUGER = 404; + literal int L1_M4O7_AUGER = 405; + literal int L1_M4P1_AUGER = 406; + literal int L1_M4P2_AUGER = 407; + literal int L1_M4P3_AUGER = 408; + literal int L1_M4P4_AUGER = 409; + literal int L1_M4P5_AUGER = 410; + literal int L1_M4Q1_AUGER = 411; + literal int L1_M4Q2_AUGER = 412; + literal int L1_M4Q3_AUGER = 413; + literal int L1_M5L2_AUGER = 414; + literal int L1_M5L3_AUGER = 415; + literal int L1_M5M1_AUGER = 416; + literal int L1_M5M2_AUGER = 417; + literal int L1_M5M3_AUGER = 418; + literal int L1_M5M4_AUGER = 419; + literal int L1_M5M5_AUGER = 420; + literal int L1_M5N1_AUGER = 421; + literal int L1_M5N2_AUGER = 422; + literal int L1_M5N3_AUGER = 423; + literal int L1_M5N4_AUGER = 424; + literal int L1_M5N5_AUGER = 425; + literal int L1_M5N6_AUGER = 426; + literal int L1_M5N7_AUGER = 427; + literal int L1_M5O1_AUGER = 428; + literal int L1_M5O2_AUGER = 429; + literal int L1_M5O3_AUGER = 430; + literal int L1_M5O4_AUGER = 431; + literal int L1_M5O5_AUGER = 432; + literal int L1_M5O6_AUGER = 433; + literal int L1_M5O7_AUGER = 434; + literal int L1_M5P1_AUGER = 435; + literal int L1_M5P2_AUGER = 436; + literal int L1_M5P3_AUGER = 437; + literal int L1_M5P4_AUGER = 438; + literal int L1_M5P5_AUGER = 439; + literal int L1_M5Q1_AUGER = 440; + literal int L1_M5Q2_AUGER = 441; + literal int L1_M5Q3_AUGER = 442; + literal int L2_L3L3_AUGER = 443; + literal int L2_L3M1_AUGER = 444; + literal int L2_L3M2_AUGER = 445; + literal int L2_L3M3_AUGER = 446; + literal int L2_L3M4_AUGER = 447; + literal int L2_L3M5_AUGER = 448; + literal int L2_L3N1_AUGER = 449; + literal int L2_L3N2_AUGER = 450; + literal int L2_L3N3_AUGER = 451; + literal int L2_L3N4_AUGER = 452; + literal int L2_L3N5_AUGER = 453; + literal int L2_L3N6_AUGER = 454; + literal int L2_L3N7_AUGER = 455; + literal int L2_L3O1_AUGER = 456; + literal int L2_L3O2_AUGER = 457; + literal int L2_L3O3_AUGER = 458; + literal int L2_L3O4_AUGER = 459; + literal int L2_L3O5_AUGER = 460; + literal int L2_L3O6_AUGER = 461; + literal int L2_L3O7_AUGER = 462; + literal int L2_L3P1_AUGER = 463; + literal int L2_L3P2_AUGER = 464; + literal int L2_L3P3_AUGER = 465; + literal int L2_L3P4_AUGER = 466; + literal int L2_L3P5_AUGER = 467; + literal int L2_L3Q1_AUGER = 468; + literal int L2_L3Q2_AUGER = 469; + literal int L2_L3Q3_AUGER = 470; + literal int L2_M1L3_AUGER = 471; + literal int L2_M1M1_AUGER = 472; + literal int L2_M1M2_AUGER = 473; + literal int L2_M1M3_AUGER = 474; + literal int L2_M1M4_AUGER = 475; + literal int L2_M1M5_AUGER = 476; + literal int L2_M1N1_AUGER = 477; + literal int L2_M1N2_AUGER = 478; + literal int L2_M1N3_AUGER = 479; + literal int L2_M1N4_AUGER = 480; + literal int L2_M1N5_AUGER = 481; + literal int L2_M1N6_AUGER = 482; + literal int L2_M1N7_AUGER = 483; + literal int L2_M1O1_AUGER = 484; + literal int L2_M1O2_AUGER = 485; + literal int L2_M1O3_AUGER = 486; + literal int L2_M1O4_AUGER = 487; + literal int L2_M1O5_AUGER = 488; + literal int L2_M1O6_AUGER = 489; + literal int L2_M1O7_AUGER = 490; + literal int L2_M1P1_AUGER = 491; + literal int L2_M1P2_AUGER = 492; + literal int L2_M1P3_AUGER = 493; + literal int L2_M1P4_AUGER = 494; + literal int L2_M1P5_AUGER = 495; + literal int L2_M1Q1_AUGER = 496; + literal int L2_M1Q2_AUGER = 497; + literal int L2_M1Q3_AUGER = 498; + literal int L2_M2L3_AUGER = 499; + literal int L2_M2M1_AUGER = 500; + literal int L2_M2M2_AUGER = 501; + literal int L2_M2M3_AUGER = 502; + literal int L2_M2M4_AUGER = 503; + literal int L2_M2M5_AUGER = 504; + literal int L2_M2N1_AUGER = 505; + literal int L2_M2N2_AUGER = 506; + literal int L2_M2N3_AUGER = 507; + literal int L2_M2N4_AUGER = 508; + literal int L2_M2N5_AUGER = 509; + literal int L2_M2N6_AUGER = 510; + literal int L2_M2N7_AUGER = 511; + literal int L2_M2O1_AUGER = 512; + literal int L2_M2O2_AUGER = 513; + literal int L2_M2O3_AUGER = 514; + literal int L2_M2O4_AUGER = 515; + literal int L2_M2O5_AUGER = 516; + literal int L2_M2O6_AUGER = 517; + literal int L2_M2O7_AUGER = 518; + literal int L2_M2P1_AUGER = 519; + literal int L2_M2P2_AUGER = 520; + literal int L2_M2P3_AUGER = 521; + literal int L2_M2P4_AUGER = 522; + literal int L2_M2P5_AUGER = 523; + literal int L2_M2Q1_AUGER = 524; + literal int L2_M2Q2_AUGER = 525; + literal int L2_M2Q3_AUGER = 526; + literal int L2_M3L3_AUGER = 527; + literal int L2_M3M1_AUGER = 528; + literal int L2_M3M2_AUGER = 529; + literal int L2_M3M3_AUGER = 530; + literal int L2_M3M4_AUGER = 531; + literal int L2_M3M5_AUGER = 532; + literal int L2_M3N1_AUGER = 533; + literal int L2_M3N2_AUGER = 534; + literal int L2_M3N3_AUGER = 535; + literal int L2_M3N4_AUGER = 536; + literal int L2_M3N5_AUGER = 537; + literal int L2_M3N6_AUGER = 538; + literal int L2_M3N7_AUGER = 539; + literal int L2_M3O1_AUGER = 540; + literal int L2_M3O2_AUGER = 541; + literal int L2_M3O3_AUGER = 542; + literal int L2_M3O4_AUGER = 543; + literal int L2_M3O5_AUGER = 544; + literal int L2_M3O6_AUGER = 545; + literal int L2_M3O7_AUGER = 546; + literal int L2_M3P1_AUGER = 547; + literal int L2_M3P2_AUGER = 548; + literal int L2_M3P3_AUGER = 549; + literal int L2_M3P4_AUGER = 550; + literal int L2_M3P5_AUGER = 551; + literal int L2_M3Q1_AUGER = 552; + literal int L2_M3Q2_AUGER = 553; + literal int L2_M3Q3_AUGER = 554; + literal int L2_M4L3_AUGER = 555; + literal int L2_M4M1_AUGER = 556; + literal int L2_M4M2_AUGER = 557; + literal int L2_M4M3_AUGER = 558; + literal int L2_M4M4_AUGER = 559; + literal int L2_M4M5_AUGER = 560; + literal int L2_M4N1_AUGER = 561; + literal int L2_M4N2_AUGER = 562; + literal int L2_M4N3_AUGER = 563; + literal int L2_M4N4_AUGER = 564; + literal int L2_M4N5_AUGER = 565; + literal int L2_M4N6_AUGER = 566; + literal int L2_M4N7_AUGER = 567; + literal int L2_M4O1_AUGER = 568; + literal int L2_M4O2_AUGER = 569; + literal int L2_M4O3_AUGER = 570; + literal int L2_M4O4_AUGER = 571; + literal int L2_M4O5_AUGER = 572; + literal int L2_M4O6_AUGER = 573; + literal int L2_M4O7_AUGER = 574; + literal int L2_M4P1_AUGER = 575; + literal int L2_M4P2_AUGER = 576; + literal int L2_M4P3_AUGER = 577; + literal int L2_M4P4_AUGER = 578; + literal int L2_M4P5_AUGER = 579; + literal int L2_M4Q1_AUGER = 580; + literal int L2_M4Q2_AUGER = 581; + literal int L2_M4Q3_AUGER = 582; + literal int L2_M5L3_AUGER = 583; + literal int L2_M5M1_AUGER = 584; + literal int L2_M5M2_AUGER = 585; + literal int L2_M5M3_AUGER = 586; + literal int L2_M5M4_AUGER = 587; + literal int L2_M5M5_AUGER = 588; + literal int L2_M5N1_AUGER = 589; + literal int L2_M5N2_AUGER = 590; + literal int L2_M5N3_AUGER = 591; + literal int L2_M5N4_AUGER = 592; + literal int L2_M5N5_AUGER = 593; + literal int L2_M5N6_AUGER = 594; + literal int L2_M5N7_AUGER = 595; + literal int L2_M5O1_AUGER = 596; + literal int L2_M5O2_AUGER = 597; + literal int L2_M5O3_AUGER = 598; + literal int L2_M5O4_AUGER = 599; + literal int L2_M5O5_AUGER = 600; + literal int L2_M5O6_AUGER = 601; + literal int L2_M5O7_AUGER = 602; + literal int L2_M5P1_AUGER = 603; + literal int L2_M5P2_AUGER = 604; + literal int L2_M5P3_AUGER = 605; + literal int L2_M5P4_AUGER = 606; + literal int L2_M5P5_AUGER = 607; + literal int L2_M5Q1_AUGER = 608; + literal int L2_M5Q2_AUGER = 609; + literal int L2_M5Q3_AUGER = 610; + literal int L3_M1M1_AUGER = 611; + literal int L3_M1M2_AUGER = 612; + literal int L3_M1M3_AUGER = 613; + literal int L3_M1M4_AUGER = 614; + literal int L3_M1M5_AUGER = 615; + literal int L3_M1N1_AUGER = 616; + literal int L3_M1N2_AUGER = 617; + literal int L3_M1N3_AUGER = 618; + literal int L3_M1N4_AUGER = 619; + literal int L3_M1N5_AUGER = 620; + literal int L3_M1N6_AUGER = 621; + literal int L3_M1N7_AUGER = 622; + literal int L3_M1O1_AUGER = 623; + literal int L3_M1O2_AUGER = 624; + literal int L3_M1O3_AUGER = 625; + literal int L3_M1O4_AUGER = 626; + literal int L3_M1O5_AUGER = 627; + literal int L3_M1O6_AUGER = 628; + literal int L3_M1O7_AUGER = 629; + literal int L3_M1P1_AUGER = 630; + literal int L3_M1P2_AUGER = 631; + literal int L3_M1P3_AUGER = 632; + literal int L3_M1P4_AUGER = 633; + literal int L3_M1P5_AUGER = 634; + literal int L3_M1Q1_AUGER = 635; + literal int L3_M1Q2_AUGER = 636; + literal int L3_M1Q3_AUGER = 637; + literal int L3_M2M1_AUGER = 638; + literal int L3_M2M2_AUGER = 639; + literal int L3_M2M3_AUGER = 640; + literal int L3_M2M4_AUGER = 641; + literal int L3_M2M5_AUGER = 642; + literal int L3_M2N1_AUGER = 643; + literal int L3_M2N2_AUGER = 644; + literal int L3_M2N3_AUGER = 645; + literal int L3_M2N4_AUGER = 646; + literal int L3_M2N5_AUGER = 647; + literal int L3_M2N6_AUGER = 648; + literal int L3_M2N7_AUGER = 649; + literal int L3_M2O1_AUGER = 650; + literal int L3_M2O2_AUGER = 651; + literal int L3_M2O3_AUGER = 652; + literal int L3_M2O4_AUGER = 653; + literal int L3_M2O5_AUGER = 654; + literal int L3_M2O6_AUGER = 655; + literal int L3_M2O7_AUGER = 656; + literal int L3_M2P1_AUGER = 657; + literal int L3_M2P2_AUGER = 658; + literal int L3_M2P3_AUGER = 659; + literal int L3_M2P4_AUGER = 660; + literal int L3_M2P5_AUGER = 661; + literal int L3_M2Q1_AUGER = 662; + literal int L3_M2Q2_AUGER = 663; + literal int L3_M2Q3_AUGER = 664; + literal int L3_M3M1_AUGER = 665; + literal int L3_M3M2_AUGER = 666; + literal int L3_M3M3_AUGER = 667; + literal int L3_M3M4_AUGER = 668; + literal int L3_M3M5_AUGER = 669; + literal int L3_M3N1_AUGER = 670; + literal int L3_M3N2_AUGER = 671; + literal int L3_M3N3_AUGER = 672; + literal int L3_M3N4_AUGER = 673; + literal int L3_M3N5_AUGER = 674; + literal int L3_M3N6_AUGER = 675; + literal int L3_M3N7_AUGER = 676; + literal int L3_M3O1_AUGER = 677; + literal int L3_M3O2_AUGER = 678; + literal int L3_M3O3_AUGER = 679; + literal int L3_M3O4_AUGER = 680; + literal int L3_M3O5_AUGER = 681; + literal int L3_M3O6_AUGER = 682; + literal int L3_M3O7_AUGER = 683; + literal int L3_M3P1_AUGER = 684; + literal int L3_M3P2_AUGER = 685; + literal int L3_M3P3_AUGER = 686; + literal int L3_M3P4_AUGER = 687; + literal int L3_M3P5_AUGER = 688; + literal int L3_M3Q1_AUGER = 689; + literal int L3_M3Q2_AUGER = 690; + literal int L3_M3Q3_AUGER = 691; + literal int L3_M4M1_AUGER = 692; + literal int L3_M4M2_AUGER = 693; + literal int L3_M4M3_AUGER = 694; + literal int L3_M4M4_AUGER = 695; + literal int L3_M4M5_AUGER = 696; + literal int L3_M4N1_AUGER = 697; + literal int L3_M4N2_AUGER = 698; + literal int L3_M4N3_AUGER = 699; + literal int L3_M4N4_AUGER = 700; + literal int L3_M4N5_AUGER = 701; + literal int L3_M4N6_AUGER = 702; + literal int L3_M4N7_AUGER = 703; + literal int L3_M4O1_AUGER = 704; + literal int L3_M4O2_AUGER = 705; + literal int L3_M4O3_AUGER = 706; + literal int L3_M4O4_AUGER = 707; + literal int L3_M4O5_AUGER = 708; + literal int L3_M4O6_AUGER = 709; + literal int L3_M4O7_AUGER = 710; + literal int L3_M4P1_AUGER = 711; + literal int L3_M4P2_AUGER = 712; + literal int L3_M4P3_AUGER = 713; + literal int L3_M4P4_AUGER = 714; + literal int L3_M4P5_AUGER = 715; + literal int L3_M4Q1_AUGER = 716; + literal int L3_M4Q2_AUGER = 717; + literal int L3_M4Q3_AUGER = 718; + literal int L3_M5M1_AUGER = 719; + literal int L3_M5M2_AUGER = 720; + literal int L3_M5M3_AUGER = 721; + literal int L3_M5M4_AUGER = 722; + literal int L3_M5M5_AUGER = 723; + literal int L3_M5N1_AUGER = 724; + literal int L3_M5N2_AUGER = 725; + literal int L3_M5N3_AUGER = 726; + literal int L3_M5N4_AUGER = 727; + literal int L3_M5N5_AUGER = 728; + literal int L3_M5N6_AUGER = 729; + literal int L3_M5N7_AUGER = 730; + literal int L3_M5O1_AUGER = 731; + literal int L3_M5O2_AUGER = 732; + literal int L3_M5O3_AUGER = 733; + literal int L3_M5O4_AUGER = 734; + literal int L3_M5O5_AUGER = 735; + literal int L3_M5O6_AUGER = 736; + literal int L3_M5O7_AUGER = 737; + literal int L3_M5P1_AUGER = 738; + literal int L3_M5P2_AUGER = 739; + literal int L3_M5P3_AUGER = 740; + literal int L3_M5P4_AUGER = 741; + literal int L3_M5P5_AUGER = 742; + literal int L3_M5Q1_AUGER = 743; + literal int L3_M5Q2_AUGER = 744; + literal int L3_M5Q3_AUGER = 745; + literal int M1_M2M2_AUGER = 746; + literal int M1_M2M3_AUGER = 747; + literal int M1_M2M4_AUGER = 748; + literal int M1_M2M5_AUGER = 749; + literal int M1_M2N1_AUGER = 750; + literal int M1_M2N2_AUGER = 751; + literal int M1_M2N3_AUGER = 752; + literal int M1_M2N4_AUGER = 753; + literal int M1_M2N5_AUGER = 754; + literal int M1_M2N6_AUGER = 755; + literal int M1_M2N7_AUGER = 756; + literal int M1_M2O1_AUGER = 757; + literal int M1_M2O2_AUGER = 758; + literal int M1_M2O3_AUGER = 759; + literal int M1_M2O4_AUGER = 760; + literal int M1_M2O5_AUGER = 761; + literal int M1_M2O6_AUGER = 762; + literal int M1_M2O7_AUGER = 763; + literal int M1_M2P1_AUGER = 764; + literal int M1_M2P2_AUGER = 765; + literal int M1_M2P3_AUGER = 766; + literal int M1_M2P4_AUGER = 767; + literal int M1_M2P5_AUGER = 768; + literal int M1_M2Q1_AUGER = 769; + literal int M1_M2Q2_AUGER = 770; + literal int M1_M2Q3_AUGER = 771; + literal int M1_M3M2_AUGER = 772; + literal int M1_M3M3_AUGER = 773; + literal int M1_M3M4_AUGER = 774; + literal int M1_M3M5_AUGER = 775; + literal int M1_M3N1_AUGER = 776; + literal int M1_M3N2_AUGER = 777; + literal int M1_M3N3_AUGER = 778; + literal int M1_M3N4_AUGER = 779; + literal int M1_M3N5_AUGER = 780; + literal int M1_M3N6_AUGER = 781; + literal int M1_M3N7_AUGER = 782; + literal int M1_M3O1_AUGER = 783; + literal int M1_M3O2_AUGER = 784; + literal int M1_M3O3_AUGER = 785; + literal int M1_M3O4_AUGER = 786; + literal int M1_M3O5_AUGER = 787; + literal int M1_M3O6_AUGER = 788; + literal int M1_M3O7_AUGER = 789; + literal int M1_M3P1_AUGER = 790; + literal int M1_M3P2_AUGER = 791; + literal int M1_M3P3_AUGER = 792; + literal int M1_M3P4_AUGER = 793; + literal int M1_M3P5_AUGER = 794; + literal int M1_M3Q1_AUGER = 795; + literal int M1_M3Q2_AUGER = 796; + literal int M1_M3Q3_AUGER = 797; + literal int M1_M4M2_AUGER = 798; + literal int M1_M4M3_AUGER = 799; + literal int M1_M4M4_AUGER = 800; + literal int M1_M4M5_AUGER = 801; + literal int M1_M4N1_AUGER = 802; + literal int M1_M4N2_AUGER = 803; + literal int M1_M4N3_AUGER = 804; + literal int M1_M4N4_AUGER = 805; + literal int M1_M4N5_AUGER = 806; + literal int M1_M4N6_AUGER = 807; + literal int M1_M4N7_AUGER = 808; + literal int M1_M4O1_AUGER = 809; + literal int M1_M4O2_AUGER = 810; + literal int M1_M4O3_AUGER = 811; + literal int M1_M4O4_AUGER = 812; + literal int M1_M4O5_AUGER = 813; + literal int M1_M4O6_AUGER = 814; + literal int M1_M4O7_AUGER = 815; + literal int M1_M4P1_AUGER = 816; + literal int M1_M4P2_AUGER = 817; + literal int M1_M4P3_AUGER = 818; + literal int M1_M4P4_AUGER = 819; + literal int M1_M4P5_AUGER = 820; + literal int M1_M4Q1_AUGER = 821; + literal int M1_M4Q2_AUGER = 822; + literal int M1_M4Q3_AUGER = 823; + literal int M1_M5M2_AUGER = 824; + literal int M1_M5M3_AUGER = 825; + literal int M1_M5M4_AUGER = 826; + literal int M1_M5M5_AUGER = 827; + literal int M1_M5N1_AUGER = 828; + literal int M1_M5N2_AUGER = 829; + literal int M1_M5N3_AUGER = 830; + literal int M1_M5N4_AUGER = 831; + literal int M1_M5N5_AUGER = 832; + literal int M1_M5N6_AUGER = 833; + literal int M1_M5N7_AUGER = 834; + literal int M1_M5O1_AUGER = 835; + literal int M1_M5O2_AUGER = 836; + literal int M1_M5O3_AUGER = 837; + literal int M1_M5O4_AUGER = 838; + literal int M1_M5O5_AUGER = 839; + literal int M1_M5O6_AUGER = 840; + literal int M1_M5O7_AUGER = 841; + literal int M1_M5P1_AUGER = 842; + literal int M1_M5P2_AUGER = 843; + literal int M1_M5P3_AUGER = 844; + literal int M1_M5P4_AUGER = 845; + literal int M1_M5P5_AUGER = 846; + literal int M1_M5Q1_AUGER = 847; + literal int M1_M5Q2_AUGER = 848; + literal int M1_M5Q3_AUGER = 849; + literal int M2_M3M3_AUGER = 850; + literal int M2_M3M4_AUGER = 851; + literal int M2_M3M5_AUGER = 852; + literal int M2_M3N1_AUGER = 853; + literal int M2_M3N2_AUGER = 854; + literal int M2_M3N3_AUGER = 855; + literal int M2_M3N4_AUGER = 856; + literal int M2_M3N5_AUGER = 857; + literal int M2_M3N6_AUGER = 858; + literal int M2_M3N7_AUGER = 859; + literal int M2_M3O1_AUGER = 860; + literal int M2_M3O2_AUGER = 861; + literal int M2_M3O3_AUGER = 862; + literal int M2_M3O4_AUGER = 863; + literal int M2_M3O5_AUGER = 864; + literal int M2_M3O6_AUGER = 865; + literal int M2_M3O7_AUGER = 866; + literal int M2_M3P1_AUGER = 867; + literal int M2_M3P2_AUGER = 868; + literal int M2_M3P3_AUGER = 869; + literal int M2_M3P4_AUGER = 870; + literal int M2_M3P5_AUGER = 871; + literal int M2_M3Q1_AUGER = 872; + literal int M2_M3Q2_AUGER = 873; + literal int M2_M3Q3_AUGER = 874; + literal int M2_M4M3_AUGER = 875; + literal int M2_M4M4_AUGER = 876; + literal int M2_M4M5_AUGER = 877; + literal int M2_M4N1_AUGER = 878; + literal int M2_M4N2_AUGER = 879; + literal int M2_M4N3_AUGER = 880; + literal int M2_M4N4_AUGER = 881; + literal int M2_M4N5_AUGER = 882; + literal int M2_M4N6_AUGER = 883; + literal int M2_M4N7_AUGER = 884; + literal int M2_M4O1_AUGER = 885; + literal int M2_M4O2_AUGER = 886; + literal int M2_M4O3_AUGER = 887; + literal int M2_M4O4_AUGER = 888; + literal int M2_M4O5_AUGER = 889; + literal int M2_M4O6_AUGER = 890; + literal int M2_M4O7_AUGER = 891; + literal int M2_M4P1_AUGER = 892; + literal int M2_M4P2_AUGER = 893; + literal int M2_M4P3_AUGER = 894; + literal int M2_M4P4_AUGER = 895; + literal int M2_M4P5_AUGER = 896; + literal int M2_M4Q1_AUGER = 897; + literal int M2_M4Q2_AUGER = 898; + literal int M2_M4Q3_AUGER = 899; + literal int M2_M5M3_AUGER = 900; + literal int M2_M5M4_AUGER = 901; + literal int M2_M5M5_AUGER = 902; + literal int M2_M5N1_AUGER = 903; + literal int M2_M5N2_AUGER = 904; + literal int M2_M5N3_AUGER = 905; + literal int M2_M5N4_AUGER = 906; + literal int M2_M5N5_AUGER = 907; + literal int M2_M5N6_AUGER = 908; + literal int M2_M5N7_AUGER = 909; + literal int M2_M5O1_AUGER = 910; + literal int M2_M5O2_AUGER = 911; + literal int M2_M5O3_AUGER = 912; + literal int M2_M5O4_AUGER = 913; + literal int M2_M5O5_AUGER = 914; + literal int M2_M5O6_AUGER = 915; + literal int M2_M5O7_AUGER = 916; + literal int M2_M5P1_AUGER = 917; + literal int M2_M5P2_AUGER = 918; + literal int M2_M5P3_AUGER = 919; + literal int M2_M5P4_AUGER = 920; + literal int M2_M5P5_AUGER = 921; + literal int M2_M5Q1_AUGER = 922; + literal int M2_M5Q2_AUGER = 923; + literal int M2_M5Q3_AUGER = 924; + literal int M3_M4M4_AUGER = 925; + literal int M3_M4M5_AUGER = 926; + literal int M3_M4N1_AUGER = 927; + literal int M3_M4N2_AUGER = 928; + literal int M3_M4N3_AUGER = 929; + literal int M3_M4N4_AUGER = 930; + literal int M3_M4N5_AUGER = 931; + literal int M3_M4N6_AUGER = 932; + literal int M3_M4N7_AUGER = 933; + literal int M3_M4O1_AUGER = 934; + literal int M3_M4O2_AUGER = 935; + literal int M3_M4O3_AUGER = 936; + literal int M3_M4O4_AUGER = 937; + literal int M3_M4O5_AUGER = 938; + literal int M3_M4O6_AUGER = 939; + literal int M3_M4O7_AUGER = 940; + literal int M3_M4P1_AUGER = 941; + literal int M3_M4P2_AUGER = 942; + literal int M3_M4P3_AUGER = 943; + literal int M3_M4P4_AUGER = 944; + literal int M3_M4P5_AUGER = 945; + literal int M3_M4Q1_AUGER = 946; + literal int M3_M4Q2_AUGER = 947; + literal int M3_M4Q3_AUGER = 948; + literal int M3_M5M4_AUGER = 949; + literal int M3_M5M5_AUGER = 950; + literal int M3_M5N1_AUGER = 951; + literal int M3_M5N2_AUGER = 952; + literal int M3_M5N3_AUGER = 953; + literal int M3_M5N4_AUGER = 954; + literal int M3_M5N5_AUGER = 955; + literal int M3_M5N6_AUGER = 956; + literal int M3_M5N7_AUGER = 957; + literal int M3_M5O1_AUGER = 958; + literal int M3_M5O2_AUGER = 959; + literal int M3_M5O3_AUGER = 960; + literal int M3_M5O4_AUGER = 961; + literal int M3_M5O5_AUGER = 962; + literal int M3_M5O6_AUGER = 963; + literal int M3_M5O7_AUGER = 964; + literal int M3_M5P1_AUGER = 965; + literal int M3_M5P2_AUGER = 966; + literal int M3_M5P3_AUGER = 967; + literal int M3_M5P4_AUGER = 968; + literal int M3_M5P5_AUGER = 969; + literal int M3_M5Q1_AUGER = 970; + literal int M3_M5Q2_AUGER = 971; + literal int M3_M5Q3_AUGER = 972; + literal int M4_M5M5_AUGER = 973; + literal int M4_M5N1_AUGER = 974; + literal int M4_M5N2_AUGER = 975; + literal int M4_M5N3_AUGER = 976; + literal int M4_M5N4_AUGER = 977; + literal int M4_M5N5_AUGER = 978; + literal int M4_M5N6_AUGER = 979; + literal int M4_M5N7_AUGER = 980; + literal int M4_M5O1_AUGER = 981; + literal int M4_M5O2_AUGER = 982; + literal int M4_M5O3_AUGER = 983; + literal int M4_M5O4_AUGER = 984; + literal int M4_M5O5_AUGER = 985; + literal int M4_M5O6_AUGER = 986; + literal int M4_M5O7_AUGER = 987; + literal int M4_M5P1_AUGER = 988; + literal int M4_M5P2_AUGER = 989; + literal int M4_M5P3_AUGER = 990; + literal int M4_M5P4_AUGER = 991; + literal int M4_M5P5_AUGER = 992; + literal int M4_M5Q1_AUGER = 993; + literal int M4_M5Q2_AUGER = 994; + literal int M4_M5Q3_AUGER = 995; + + // Radionuclides + literal int RADIONUCLIDE_55FE = 0; + literal int RADIONUCLIDE_57CO = 1; + literal int RADIONUCLIDE_109CD = 2; + literal int RADIONUCLIDE_125I = 3; + literal int RADIONUCLIDE_137CS = 4; + literal int RADIONUCLIDE_133BA = 5; + literal int RADIONUCLIDE_153GD = 6; + literal int RADIONUCLIDE_238PU = 7; + literal int RADIONUCLIDE_241AM = 8; + literal int RADIONUCLIDE_244CM = 9; + #pragma endregion + + /// + /// Initialize the library. + /// + static void XrayInit(); + + /// + /// Gets the atomic weight of the element with the specified atomic number. + /// + /// Atomic number + /// Atomic weight + static double AtomicWeight(int Z); + + /// + /// Gets the density of a pure atomic element. + /// + /// Atomic number + /// Density (g/cm3) + static double ElementDensity(int Z); + + /// + /// Gets element information for the specified atomic number. + /// + /// Atomic number + /// Element information + static Science::ElementData GetElementData(int Z); + + // Cross sections + /// + /// Calculates the total cross section. + /// + /// Atomic number of the element + /// Energy (keV) + /// Cross section (cm2/g) + static double CS_Total(int Z, double E); + + /// + /// Calculates the photoelectric absorption cross section. + /// + /// Atomic number of the element + /// Energy (keV) + /// Cross section (cm2/g) + static double CS_Photo(int Z, double E); + + /// + /// Calculates the Rayleigh scattering cross section. + /// + /// Atomic number of the element + /// Energy (keV) + /// Cross section (cm2/g) + static double CS_Rayl(int Z, double E); + + /// + /// Calculates the Compton scattering cross section. + /// + /// Atomic number of the element + /// Energy (keV) + /// Cross section (cm2/g) + static double CS_Compt(int Z, double E); + + /// + /// Calculates the mass energy-absorption coefficient. + /// + /// Atomic number of the element + /// Energy (keV) + /// Cross section (cm2/g) + static double CS_Energy(int Z, double E); + + /// + /// Calculates the total cross section. + /// + /// Atomic number of the element + /// Energy (keV) + /// Cross section (barn) + static double CSb_Total(int Z, double E); + + /// + /// Calculates the photoelectric absorption cross section. + /// + /// Atomic number of the element + /// Energy (keV) + /// Cross section (barn) + static double CSb_Photo(int Z, double E); + + /// + /// Calculates the Rayleigh scattering cross section. + /// + /// Atomic number of the element + /// Energy (keV) + /// Cross section (barn) + static double CSb_Rayl(int Z, double E); + + /// + /// Calculates the Compton scattering cross section. + /// + /// Atomic number of the element + /// Energy (keV) + /// Cross section (barn) + static double CSb_Compt(int Z, double E); + + /// + /// Calculates the total Klein-Nishina cross section. + /// + /// Energy (keV) + /// Cross section (barn) + static double CS_KN(double E); + + // Unpolarized differential scattering cross sections + /// + /// Calculates the Thomson differential scattering cross section. + /// + /// Scattering polar angle (rad) + /// Cross section (barn) + static double DCS_Thoms(double theta); + + /// + /// Calculates the Klein-Nishina differential scattering cross section. + /// + /// Energy (keV) + /// Scattering polar angle (rad) + /// Cross section (barn) + static double DCS_KN(double E, double theta); + + /// + /// Calculates the Rayleigh differential scattering cross section. + /// + /// Atomic number + /// Energy (keV) + /// Scattering polar angle (rad) + /// Cross section (cm2/g/sterad) + static double DCS_Rayl(int Z, double E, double theta); + + /// + /// Calculates the Compton differential scattering cross section. + /// + /// Atomic number + /// Energy (keV) + /// Scattering polar angle (rad) + /// Cross section (cm2/g/sterad) + static double DCS_Compt(int Z, double E, double theta); + + /// + /// Calculates the Rayleigh differential scattering cross section. + /// + /// Atomic number + /// Energy (keV) + /// Scattering polar angle (rad) + /// Cross section (barn) + static double DCSb_Rayl(int Z, double E, double theta); + + /// + /// Calculates the Compton differential scattering cross section. + /// + /// Atomic number + /// Energy (keV) + /// Scattering polar angle (rad) + /// Cross section (barn) + static double DCSb_Compt(int Z, double E, double theta); + + // Polarized differential scattering cross sections + /// + /// Calculates the Thomson differential scattering cross section for polarized beam. + /// + /// Scattering polar angle (rad) + /// Scattering azimuthal angle (rad) + /// Cross section (barn) + static double DCSP_Thoms(double theta, double phi); + + // Polarized differential scattering cross sections + /// + /// Calculates the Klein-Nishina differential scattering cross section for polarized beam. + /// + /// Scattering polar angle (rad) + /// Scattering azimuthal angle (rad) + /// Cross section (barn) + static double DCSP_KN(double E, double theta, double phi); + + /// + /// Calculates the Rayleigh differential scattering cross section for polarized beam. + /// + /// Atomic number + /// Energy (keV) + /// Scattering polar angle (rad) + /// Scattering azimuthal angle (rad) + /// Cross section (cm2/g/sterad) + static double DCSP_Rayl(int Z, double E, double theta, double phi); + + /// + /// Calculates the Compton differential scattering cross section for polarized beam. + /// + /// Atomic number + /// Energy (keV) + /// Scattering polar angle (rad) + /// Scattering azimuthal angle (rad) + /// Cross section (cm2/g/sterad) + static double DCSP_Compt(int Z, double E, double theta, double phi); + + /// + /// Calculates the Rayleigh differential scattering cross section for polarized beam. + /// + /// Atomic number + /// Energy (keV) + /// Scattering polar angle (rad) + /// Scattering azimuthal angle (rad) + /// Cross section (barn) + static double DCSPb_Rayl(int Z, double E, double theta, double phi); + + /// + /// Calculates the Compton differential scattering cross section for polarized beam. + /// + /// Atomic number + /// Energy (keV) + /// Scattering polar angle (rad) + /// Scattering azimuthal angle (rad) + /// Cross section (barn) + static double DCSPb_Compt(int Z, double E, double theta, double phi); + + // Scattering factors + /// + /// Calculates the Atomic form factor for Rayleigh scattering. + /// + /// Atomic number + /// Momentum transfer + /// Form factor + static double FF_Rayl(int Z, double q); + + /// + /// Calculates the Incoherent scattering function for Compton scattering. + /// + /// Atomic number + /// Momentum transfer + /// Form factor + static double SF_Compt(int Z, double q); + + /// + /// Calculates the Momentum transfer for X-ray photon scattering. + /// + /// Energy (keV) + /// Scattering polar angle (rad) + /// Momentum transfer (1/A) + static double MomentTransf(double E, double theta); + + /// + /// Gets X-ray fluorescent line energy. + /// + /// Atomic number + /// Emission line ID + /// X-ray fluorescent line energy (keV) + static double LineEnergy(int Z, int line); + + /// + /// Gets the fluorescence yield + /// + /// Atomic number of the element + /// Atomic shell ID + /// Fluorescence yield + static double FluorYield(int Z, int shell); + + /// + /// Gets the Coster-Kronig transition probability + /// + /// Atomic number + /// Atomic transition ID + /// Transition probability + static double CosKronTransProb(int Z, int trans); + + /// + /// Gets the absorption-edge energy + /// + /// Atomic number + /// Atomic shell ID + /// Edge energy (keV) + static double EdgeEnergy(int Z, int shell); + + /// + /// Gets the jump ratio + /// + /// Atomic number + /// Atomic shell ID + /// Jump ratio + static double JumpFactor(int Z, int shell); + + /// + /// Calculates the fluorescent line cross section + /// + /// Atomic number + /// Atomic line ID + /// Energy (keV) + /// Cross section (cm2/g) + static double CS_FluorLine(int Z, int line, double E); + + /// + /// Calculates the fluorescent line cross section + /// + /// Atomic number + /// Atomic line ID + /// Energy (keV) + /// Cross section (barn) + static double CSb_FluorLine(int Z, int line, double E); + + /// + /// Gets the fractional radiative rate + /// + /// Atomic number + /// Atomic line ID + /// Fractional radiative rate + static double RadRate(int Z, int line); + + /// + /// Calculates the photon energy after Compton scattering + /// + /// Photon energy before scattering (keV) + /// Scattering polar angle (rad) + /// Energy after scattering (keV) + static double ComptonEnergy(double E0, double theta); + + // Anomalous scattering factors + /// + /// Calculates the real-part of the anomalous scattering factor + /// + /// Atomic number + /// Energy (keV) + /// Real-part of anomalous scattering factor + static double Fi(int Z, double E); + + /// + /// Calculates the imaginary-part of the anomalous scattering factor + /// + /// Atomic number + /// Energy (keV) + /// Imaginary-part of anomalous scattering factor + static double Fii(int Z, double E); + + // Kissel Photoelectric cross sections + /// + /// Calculates the total photoelectric absorption cross section using Kissel partial photoelectric cross sections. + /// + /// Atomic number of the element + /// Energy (keV) + /// Cross section (cm2/g) + static double CS_Photo_Total(int Z, double E); + + /// + /// Calculates the total photoelectric absorption cross section using Kissel partial photoelectric cross sections. + /// + /// Atomic number of the element + /// Energy (keV) + /// Cross section (barn) + static double CSb_Photo_Total(int Z, double E); + + /// + /// Calculates the partial photoelectric absorption cross section using Kissel partial photoelectric cross sections. + /// + /// Atomic number of the element + /// Atomic shell ID + /// Energy (keV) + /// Cross section (cm2/g) + static double CS_Photo_Partial(int Z, int shell, double E); + + /// + /// Calculates the partial photoelectric absorption cross section using Kissel partial photoelectric cross sections. + /// + /// Atomic number of the element + /// Atomic shell ID + /// Energy (keV) + /// Cross section (barn) + static double CSb_Photo_Partial(int Z, int shell, double E); + + // XRF cross sections using Kissel partial photoelectric cross sections + /// + /// Calculates the fluorescent line cross section using Kissel partial photoelectric cross sections + /// + /// Atomic number + /// Atomic line ID + /// Energy (keV) + /// Cross section (cm2/g) + static double CS_FluorLine_Kissel(int Z, int line, double E); + + /// + /// Calculates the fluorescent line cross section using Kissel partial photoelectric cross sections + /// + /// Atomic number + /// Atomic line ID + /// Energy (keV) + /// Cross section (barn) + static double CSb_FluorLine_Kissel(int Z, int line, double E); + + // Total cross sections (photoionization + Rayleigh + Compton) using Kissel total photoelectric cross sections + /// + /// Calculates the total cross section using Kissel partial photoelectric cross sections. + /// + /// Atomic number of the element + /// Energy (keV) + /// Cross section (cm2/g) + static double CS_Total_Kissel(int Z, double E); + + // Total cross sections (photoionization + Rayleigh + Compton) using Kissel total photoelectric cross sections + /// + /// Calculates the total cross section using Kissel partial photoelectric cross sections. + /// + /// Atomic number of the element + /// Energy (keV) + /// Cross section (barn) + static double CSb_Total_Kissel(int Z, double E); + + /// + /// Calculates the fluorescent line cross section including cascade effects. + /// + /// Atomic number + /// Atomic line ID + /// Energy (keV) + /// Cross section (cm2/g) + static double CS_FluorLine_Kissel_Cascade(int Z, int line, double E); + + /// + /// Calculates the fluorescent line cross section including cascade effects. + /// + /// Atomic number + /// Atomic line ID + /// Energy (keV) + /// Cross section (barn) + static double CSb_FluorLine_Kissel_Cascade(int Z, int line, double E); + + /// + /// Calculates the fluorescent line cross section with non-radiative cascade effects. + /// + /// Atomic number + /// Atomic line ID + /// Energy (keV) + /// Cross section (cm2/g) + static double CS_FluorLine_Kissel_Nonradiative_Cascade(int Z, int line, double E); + + /// + /// Calculates the fluorescent line cross section with non-radiative cascade effects. + /// + /// Atomic number + /// Atomic line ID + /// Energy (keV) + /// Cross section (barn) + static double CSb_FluorLine_Kissel_Nonradiative_Cascade(int Z, int line, double E); + + /// + /// Calculates the fluorescent line cross section with radiative cascade effects. + /// + /// Atomic number + /// Atomic line ID + /// Energy (keV) + /// Cross section (cm2/g) + static double CS_FluorLine_Kissel_Radiative_Cascade(int Z, int line, double E); + + /// + /// Calculates the fluorescent line cross section with non-radiative cascade effects. + /// + /// Atomic number + /// Atomic line ID + /// Energy (keV) + /// Cross section (barn) + static double CSb_FluorLine_Kissel_Radiative_Cascade(int Z, int line, double E); + + /// + /// Calculates the fluorescent line cross section without cascade effects. + /// + /// Atomic number + /// Atomic line ID + /// Energy (keV) + /// Cross section (cm2/g) + static double CS_FluorLine_Kissel_No_Cascade(int Z, int line, double E); + + /// + /// Calculates the fluorescent line cross section without cascade effects. + /// + /// Atomic number + /// Atomic line ID + /// Energy (keV) + /// Cross section (barn) + static double CSb_FluorLine_Kissel_No_Cascade(int Z, int line, double E); + + //Cross Section functions using the compound parser + /// + /// Calculates the total cross section of a compound. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Cross section (cm2/g) + static double CS_Total_CP(String^ compound, double E); + + /// + /// Calculates the photoelectric absorption cross section of a compound. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Cross section (cm2/g) + static double CS_Photo_CP(String^ compound, double E); + + /// + /// Calculates the Rayleigh scattering cross section of a compound. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Cross section (cm2/g) + static double CS_Rayl_CP(String^ compound, double E); + + /// + /// Calculates the Compton scattering cross section of a compound. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Cross section (cm2/g) + static double CS_Compt_CP(String^ compound, double E); + + /// + /// Calculates the total cross section of a compound. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Cross section (barn) + static double CSb_Total_CP(String^ compound, double E); + + /// + /// Calculates the photoelectric absorption cross section of a compound. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Cross section (barn) + static double CSb_Photo_CP(String^ compound, double E); + + /// + /// Calculates the Rayleigh scattering cross section of a compound. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Cross section (barn) + static double CSb_Rayl_CP(String^ compound, double E); + + /// + /// Calculates the Compton scattering cross section of a compound. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Cross section (barn) + static double CSb_Compt_CP(String^ compound, double E); + + /// + /// Calculates the Rayleigh differential scattering cross section of a compound. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Scattering polar angle (rad) + /// Cross section (cm2/g/sterad) + static double DCS_Rayl_CP(String^ compound, double E, double theta); + + /// + /// Calculates the Compton differential scattering cross section of a compound. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Scattering polar angle (rad) + /// Cross section (cm2/g/sterad) + static double DCS_Compt_CP(String^ compound, double E, double theta); + + /// + /// Calculates the Rayleigh differential scattering cross section of a compound. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Scattering polar angle (rad) + /// Cross section (barn/sterad) + static double DCSb_Rayl_CP(String^ compound, double E, double theta); + + /// + /// Calculates the Compton differential scattering cross section of a compound. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Scattering polar angle (rad) + /// Cross section (barn/sterad) + static double DCSb_Compt_CP(String^ compound, double E, double theta); + + /// + /// Calculates the Rayleigh differential scattering cross section for polarized beam for a compound. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Scattering polar angle (rad) + /// Scattering azimuthal angle (rad) + /// Cross section (cm2/g/sterad) + static double DCSP_Rayl_CP(String^ compound, double E, double theta, double phi); + + /// + /// Calculates the Compton differential scattering cross section for polarized beam for a compound. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Scattering polar angle (rad) + /// Scattering azimuthal angle (rad) + /// Cross section (cm2/g/sterad) + static double DCSP_Compt_CP(String^ compound, double E, double theta, double phi); + + /// + /// Calculates the Rayleigh differential scattering cross section for polarized beam for a compound. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Scattering polar angle (rad) + /// Scattering azimuthal angle (rad) + /// Cross section (barn/sterad) + static double DCSPb_Rayl_CP(String^ compound, double E, double theta, double phi); + + /// + /// Calculates the Compton differential scattering cross section for polarized beam for a compound. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Scattering polar angle (rad) + /// Scattering azimuthal angle (rad) + /// Cross section (barn/sterad) + static double DCSPb_Compt_CP(String^ compound, double E, double theta, double phi); + + /// + /// Calculates the total photoelectric absorption cross section for a compound. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Cross section (cm2/g) + static double CS_Photo_Total_CP(String^ compound, double E); + + /// + /// Calculates the total photoelectric absorption cross section for a compound. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Cross section (barn) + static double CSb_Photo_Total_CP(String^ compound, double E); + + /// + /// Calculates the total photoelectric absorption cross section for a compound + /// using Kissel partial photoelectric cross sections. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Cross section (cm2/g) + static double CS_Total_Kissel_CP(String^ compound, double E); + + /// + /// Calculates the total photoelectric absorption cross section for a compound + /// using Kissel partial photoelectric cross sections. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Cross section (barn) + static double CSb_Total_Kissel_CP(String^ compound, double E); + + /// + /// Calculates the mass energy-absorption coefficient for a compound. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Cross section (barn) + static double CS_Energy_CP(String^ compound, double E); + + //Refractive indices functions + /// + /// Calculates the real part of the refractive index. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Real part of refractive index (electrons) + static double Refractive_Index_Re(String^ compound, double E, double density); + + /// + /// Calculates the imaginary part of the refractive index. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Imaginary part of refractive index (electrons) + static double Refractive_Index_Im(String^ compound, double E, double density); + + /// + /// Calculates the refractive index. + /// + /// Chemical formula of the compound + /// Energy (keV) + /// Refractive index (electrons) + static Numerics::Complex Refractive_Index(String^ compound, double E, double density); + + /// + /// Calculates the electron configuration according to Kissel. + /// + /// Atomic number of the element + /// Atomic shell ID + /// Electron configuration + static double ElectronConfig(int Z, int shell); + + //ComptonProfiles + /// + /// Calculates the total Compton scattering profile. + /// + /// Atomic number of the element + /// Momentum + /// Compton profile + static double ComptonProfile(int Z, double pz); + + /// + /// Calculates the sub-shell Compton scattering profile. + /// + /// Atomic number of the element + /// Atomic shell ID + /// Momentum + /// Compton profile + static double ComptonProfile_Partial(int Z, int shell, double pz); + + /// Calculates the atomic level width. + /// Atomic number of the element. + /// Atomic shell ID. + /// Level width (keV) + static double AtomicLevelWidth(int Z, int shell); + + /// Calculates the Auger non-radiative rate. + /// Atomic number of the element. + /// Value identifying initial ionized shell and two resulting ejected electrons + /// Non-radiative rate + static double AugerRate(int Z, int auger_trans); + + /// Calculates the Auger non-radiative yeild. + /// Atomic number of the element. + /// Atomic shell ID. + /// Non-radiative yeild + static double AugerYield(int Z, int shell); + + /// + /// Returns the Siegbahn line name corresponding to the specified IUPAC name. + /// + /// IUPAC line name + /// Siegbahn line name + static System::String ^IUPACToSiegbahnLineName(System::String ^name); + + /// + /// Returns IUPAC line name corresponding to the specified Siegbahn name. + /// + /// Siegbahn line name + /// IUPAC line name + static System::String ^SiegbahnToIUPACLineName(System::String ^name); + + /// + /// Returns the energy of the specified fluorescent line string. + /// + /// String containing the element and emission line, e.g. Cu Ka1 + /// Fluorescent line energy (keV) + static double LineEnergyFromName(System::String ^lineName); + + /// + /// Returns the atomic number and line ID of the specified fluorescent line string. + /// + /// String containing the element and emission line, e.g. Cu Ka1 + /// Atomic number + /// Emission line ID + static void ElementAndLineFromName(System::String ^elementLine, int %Z, int %line); + + /// + /// Returns the line ID of the specified emission line name. + /// + /// String containing the emission line name, e.g. Ka1 + /// ID of the emission line + static int SiegbahnLineIndex(System::String ^name); + + /// + /// Returns the atomic number from the specified element name. + /// + /// Element name, e.g. Cu + /// Atomic number + static int AtomicNumber(System::String ^name); + + /// + /// Calculates the energy of the escape peak for a Si detector. + /// + /// Energy of the incident X-ray peak (keV) + /// Energy of the escape peak (keV) + static double SiEscapeEnergy(double energy); + + /// + /// Calculates the fraction of photons in the escape peak for a Si detector. + /// + /// Energy of the incident X-ray peak (keV) + /// Fraction of incident photons in the escape peak + static double SiEscapeFraction(double energy); + }; + +} diff --git a/csharp/app.ico b/csharp/app.ico new file mode 100644 index 0000000000000000000000000000000000000000..3a5525fd794f7a7c5c8e6187f470ea3af38cd2b6 GIT binary patch literal 1078 zcmeHHJr05}7=1t!Hp3A*8IHkVf+j?-!eHY14Gtcw1Eb*_9>Bq^zETJ@GKj{_2j4$w zo9}xCh!8{T3=X##Skq>ikMjsvB|y%crWBM2iW(4pI}c%z6%lW!=~4v77#3{z!dmB1 z__&l)-{KUYR+|8|;wB^R|9ET$J@(@=#rd^=)qs85?vAy(PSF5CyNkus435LVkZ$rj zNw|JG-P7^hF<(;#o*Vk}5R#e|^13tBbQkeF?djULtvqyxd3<{9 literal 0 HcmV?d00001 diff --git a/csharp/app.rc b/csharp/app.rc new file mode 100644 index 00000000..807aa896 --- /dev/null +++ b/csharp/app.rc @@ -0,0 +1,63 @@ +// Microsoft Visual C++ generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (U.S.) resources + + +///////////////////////////////////////////////////////////////////////////// +// +// Icon +// + +// Icon placed first or with lowest ID value becomes application icon + +LANGUAGE 9, 1 +#pragma code_page(1252) +1 ICON "app.ico" + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.h\0" + "\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""afxres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE +BEGIN + "\0" +END + +#endif // APSTUDIO_INVOKED + +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/csharp/meson.build b/csharp/meson.build new file mode 100644 index 00000000..ab8f636f --- /dev/null +++ b/csharp/meson.build @@ -0,0 +1,40 @@ +windows = import('windows') + +win_res = windows.compile_resources('app.rc', depend_files: files('app.ico', 'resource.h')) + +libxrl_cs_sources = files( + 'AssemblyInfo.cpp', + 'Compound.h', + 'Diffraction.h', + 'Element.h', + 'Errors.h', + 'Radionuclides.h', + 'Stdafx.cpp', + 'Stdafx.h', + 'XrayLib.NET.cpp', + 'XrayLib.NET.h', +) + +xraylib_cs_lib = shared_library( + 'XrayLib.NET', + win_res, + libxrl_cs_sources, + dependencies: xraylib_lib_dep, + cpp_args: ['/clr', '/Zc:twoPhase-',], + override_options: ['cpp_eh=none'], +) + +xraylib_cs_dep = declare_dependency( + link_with: xraylib_cs_lib, +) + +csharp_source_dir = meson.current_source_dir() +csharp_build_dir = meson.current_build_dir() + +# Note: to avoid the executable not finding the assembly at run-time, +# ensure they are created in the same folder... +_test_exec = executable( + 'Program', ['Program.cs', 'AssemblyInfo.cs'], + dependencies: [xraylib_cs_dep], + cs_args: ['-r:System.Numerics.dll',]) +test('cs-Program', _test_exec,) \ No newline at end of file diff --git a/csharp/resource.h b/csharp/resource.h new file mode 100644 index 00000000..d5ac7c42 --- /dev/null +++ b/csharp/resource.h @@ -0,0 +1,3 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by app.rc diff --git a/include/xraylib-crystal-diffraction.h b/include/xraylib-crystal-diffraction.h index ab4e8df6..86c5a9a0 100644 --- a/include/xraylib-crystal-diffraction.h +++ b/include/xraylib-crystal-diffraction.h @@ -98,6 +98,11 @@ XRL_EXTERN 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, xrl_error **error); +#ifndef SWIG +XRL_EXTERN +void Crystal_F_H_StructureFactor2(Crystal_Struct* crystal, double energy, int i_miller, int j_miller, int k_miller, double debye_factor, double rel_angle, xrlComplex* result, xrl_error **error); +#endif + /*-------------------------------------------------------------------------------------------------- * Compute F_H * See also Crystal_F_H_StructureFactor @@ -113,6 +118,13 @@ xrlComplex Crystal_F_H_StructureFactor_Partial (Crystal_Struct* crystal, double 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, xrl_error **error); +#ifndef SWIG +XRL_EXTERN +void Crystal_F_H_StructureFactor_Partial2(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, xrlComplex* result, xrl_error **error); +#endif + /*-------------------------------------------------------------------------------- * Compute unit cell volume. * Note: Structures obtained from crystal array will have their volume in .volume. diff --git a/include/xraylib.h b/include/xraylib.h index 47bca89f..55f77c7f 100644 --- a/include/xraylib.h +++ b/include/xraylib.h @@ -371,6 +371,11 @@ double Refractive_Index_Im(const char compound[], double E, double density, xrl_ XRL_EXTERN xrlComplex Refractive_Index(const char compound[], double E, double density, xrl_error **error); +#ifndef SWIG +XRL_EXTERN +void Refractive_Index2(const char compound[], double E, double density, xrlComplex* result, xrl_error **error); +#endif + /* ComptonProfiles */ XRL_EXTERN double ComptonProfile(int Z, double pz, xrl_error **error); diff --git a/meson.build b/meson.build index 40d834f2..d2454542 100644 --- a/meson.build +++ b/meson.build @@ -3,7 +3,7 @@ project('xraylib', meson_version: '>= 0.56.0', version: '4.0.0', license: 'BSD', - default_options: ['cpp_std=c++11',] + default_options: ['cpp_std=c++11'] ) @@ -186,4 +186,10 @@ ENDPROGRAM f2003_main endif endif +endif + +if not get_option('csharp-bindings').disabled() and cc.get_id() == 'msvc' + if add_languages('cpp', 'cs', required: get_option('csharp-bindings'), native: false) + subdir('csharp') + endif endif \ No newline at end of file diff --git a/meson_options.txt b/meson_options.txt index f4a74db5..4a7b4b64 100644 --- a/meson_options.txt +++ b/meson_options.txt @@ -1,6 +1,7 @@ option('fortran-bindings', type: 'feature', value: 'auto', description: 'Build Fortran 2003 bindings') option('python-bindings', type: 'feature', value: 'auto', description: 'Build classic Python bindings') option('python-numpy-bindings', type: 'feature', value: 'auto', description: 'Build numpy Python bindings') +option('csharp-bindings', type: 'feature', value: 'disabled', description: 'Build C# bindings (MSVC only)') option('swig', type : 'string', value : 'swig', description: 'Path to swig executable') option('python', type : 'string', value : 'python3', description: 'Python interpreter to compile bindings for') -option('cython', type : 'string', value : 'cython', description: 'Cython to use for generating C glue code') +option('cython', type : 'string', value : 'cython', description: 'Cython to use for generating C glue code') \ No newline at end of file diff --git a/src/crystal_diffraction.c b/src/crystal_diffraction.c index b931e467..29d90f95 100644 --- a/src/crystal_diffraction.c +++ b/src/crystal_diffraction.c @@ -412,11 +412,6 @@ xrlComplex Crystal_F_H_StructureFactor_Partial (Crystal_Struct* crystal, double return F_H; } -XRL_EXTERN -void Crystal_F_H_StructureFactor_Partial2(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, xrlComplex* result, xrl_error **error); - void Crystal_F_H_StructureFactor_Partial2(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, xrlComplex* result, xrl_error **error) { diff --git a/src/refractive_indices.c b/src/refractive_indices.c index 7ff0f7aa..ddab5e49 100644 --- a/src/refractive_indices.c +++ b/src/refractive_indices.c @@ -146,9 +146,6 @@ xrlComplex Refractive_Index(const char compound[], double E, double density, xrl return rv; } -XRL_EXTERN -void Refractive_Index2(const char compound[], double E, double density, xrlComplex* result, xrl_error **error); - void Refractive_Index2(const char compound[], double E, double density, xrlComplex* result, xrl_error **error) { xrlComplex z = Refractive_Index(compound, E, density, error);