dd/dbf/CrystalFieldEnergies_8cpp_source.html

// Mantid Repository : https://github.com/mantidproject/mantid

//

// Copyright &copy; 2018 ISIS Rutherford Appleton Laboratory UKRI,

//   NScD Oak Ridge National Laboratory, European Spallation Source,

//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS

// SPDX - License - Identifier: GPL - 3.0 +

#include "MantidCurveFitting/Algorithms/CrystalFieldEnergies.h"

//#include "MantidKernel/ArrayLengthValidator.h"

#include "MantidKernel/ArrayProperty.h"

#include "MantidKernel/BoundedValidator.h"


#include "MantidCurveFitting/Functions/CrystalElectricField.h"


#include <sstream>


namespace Mantid::CurveFitting {


using Mantid::CurveFitting::ComplexFortranMatrix;

using Mantid::CurveFitting::DoubleFortranMatrix;

using Mantid::CurveFitting::DoubleFortranVector;

using Mantid::CurveFitting::Functions::calculateEigensystem;

using Mantid::Kernel::Direction;


// Register the algorithm into the AlgorithmFactory

DECLARE_ALGORITHM(CrystalFieldEnergies)


//----------------------------------------------------------------------------------------------


const std::string CrystalFieldEnergies::name() const { return "CrystalFieldEnergies"; }


int CrystalFieldEnergies::version() const { return 1; }


const std::string CrystalFieldEnergies::category() const { return "Inelastic"; }


const std::string CrystalFieldEnergies::summary() const {

  return "Calculates crystal field energies and wave functions for rare earth "

         "ions given the field parameters.";

}


//----------------------------------------------------------------------------------------------

void CrystalFieldEnergies::init() {


  // Input

  auto bounds = std::make_shared<Kernel::BoundedValidator<int>>(-99, 13);

  declareProperty("Nre", 1, bounds,

                  "A rare earth ion. Possible values are: "

                  "1=Ce 2=Pr 3=Nd 4=Pm 5=Sm 6=Eu 7=Gd 8=Tb "

                  "9=Dy 10=Ho 11=Er 12=Tm 13=Yb, or "

                  "negative values for arbitrary J with "

                  "J=-nre/2 up to nre=-99 (J=99/2)");


  declareProperty("BmolX", 0.0, "The x-component of the molecular field.");

  declareProperty("BmolY", 0.0, "The y-component of the molecular field.");

  declareProperty("BmolZ", 0.0, "The z-component of the molecular field.");


  declareProperty("BextX", 0.0, "The x-component of the external field.");

  declareProperty("BextY", 0.0, "The y-component of the external field.");

  declareProperty("BextZ", 0.0, "The z-component of the external field.");


  declareProperty("B20", 0.0, "Real part of the B20 field parameter.");

  declareProperty("B21", 0.0, "Real part of the B21 field parameter.");

  declareProperty("B22", 0.0, "Real part of the B22 field parameter.");

  declareProperty("B40", 0.0, "Real part of the B40 field parameter.");

  declareProperty("B41", 0.0, "Real part of the B41 field parameter.");

  declareProperty("B42", 0.0, "Real part of the B42 field parameter.");

  declareProperty("B43", 0.0, "Real part of the B43 field parameter.");

  declareProperty("B44", 0.0, "Real part of the B44 field parameter.");

  declareProperty("B60", 0.0, "Real part of the B60 field parameter.");

  declareProperty("B61", 0.0, "Real part of the B61 field parameter.");

  declareProperty("B62", 0.0, "Real part of the B62 field parameter.");

  declareProperty("B63", 0.0, "Real part of the B63 field parameter.");

  declareProperty("B64", 0.0, "Real part of the B64 field parameter.");

  declareProperty("B65", 0.0, "Real part of the B65 field parameter.");

  declareProperty("B66", 0.0, "Real part of the B66 field parameter.");


  declareProperty("IB20", 0.0, "Imaginary part of the B20 field parameter.");

  declareProperty("IB21", 0.0, "Imaginary part of the B21 field parameter.");

  declareProperty("IB22", 0.0, "Imaginary part of the B22 field parameter.");

  declareProperty("IB40", 0.0, "Imaginary part of the B40 field parameter.");

  declareProperty("IB41", 0.0, "Imaginary part of the B41 field parameter.");

  declareProperty("IB42", 0.0, "Imaginary part of the B42 field parameter.");

  declareProperty("IB43", 0.0, "Imaginary part of the B43 field parameter.");

  declareProperty("IB44", 0.0, "Imaginary part of the B44 field parameter.");

  declareProperty("IB60", 0.0, "Imaginary part of the B60 field parameter.");

  declareProperty("IB61", 0.0, "Imaginary part of the B61 field parameter.");

  declareProperty("IB62", 0.0, "Imaginary part of the B62 field parameter.");

  declareProperty("IB63", 0.0, "Imaginary part of the B63 field parameter.");

  declareProperty("IB64", 0.0, "Imaginary part of the B64 field parameter.");

  declareProperty("IB65", 0.0, "Imaginary part of the B65 field parameter.");

  declareProperty("IB66", 0.0, "Imaginary part of the B66 field parameter.");


  // Output

  declareProperty(std::make_unique<Kernel::ArrayProperty<double>>("Energies", Kernel::Direction::Output),

                  "The energies starting at 0 in ascending order.");

  declareProperty(std::make_unique<Kernel::ArrayProperty<double>>("Eigenvectors", Kernel::Direction::Output),

                  "The eigenvectors.");

  declareProperty(std::make_unique<Kernel::ArrayProperty<double>>("Hamiltonian", Kernel::Direction::Output),

                  "The Hamiltonian.");

}


//----------------------------------------------------------------------------------------------

void CrystalFieldEnergies::exec() {

  int nre = getProperty("Nre");


  double BmolX = getProperty("BmolX");

  double BmolY = getProperty("BmolY");

  double BmolZ = getProperty("BmolZ");

  DoubleFortranVector bmol(1, 3);

  bmol(1) = BmolX;

  bmol(2) = BmolY;

  bmol(3) = BmolZ;


  double BextX = getProperty("BextX");

  double BextY = getProperty("BextY");

  double BextZ = getProperty("BextZ");

  DoubleFortranVector bext(1, 3);

  bext(1) = BextX;

  bext(2) = BextY;

  bext(3) = BextZ;


  double B20 = getProperty("B20");

  double B21 = getProperty("B21");

  double B22 = getProperty("B22");

  double B40 = getProperty("B40");

  double B41 = getProperty("B41");

  double B42 = getProperty("B42");

  double B43 = getProperty("B43");

  double B44 = getProperty("B44");

  double B60 = getProperty("B60");

  double B61 = getProperty("B61");

  double B62 = getProperty("B62");

  double B63 = getProperty("B63");

  double B64 = getProperty("B64");

  double B65 = getProperty("B65");

  double B66 = getProperty("B66");


  double IB20 = getProperty("IB20");

  double IB21 = getProperty("IB21");

  double IB22 = getProperty("IB22");

  double IB40 = getProperty("IB40");

  double IB41 = getProperty("IB41");

  double IB42 = getProperty("IB42");

  double IB43 = getProperty("IB43");

  double IB44 = getProperty("IB44");

  double IB60 = getProperty("IB60");

  double IB61 = getProperty("IB61");

  double IB62 = getProperty("IB62");

  double IB63 = getProperty("IB63");

  double IB64 = getProperty("IB64");

  double IB65 = getProperty("IB65");

  double IB66 = getProperty("IB66");


  ComplexFortranMatrix bkq(0, 6, 0, 6);

  bkq(2, 0) = ComplexType(B20, IB20);

  bkq(2, 1) = ComplexType(B21, IB21);

  bkq(2, 2) = ComplexType(B22, IB22);

  bkq(4, 0) = ComplexType(B40, IB40);

  bkq(4, 1) = ComplexType(B41, IB41);

  bkq(4, 2) = ComplexType(B42, IB42);

  bkq(4, 3) = ComplexType(B43, IB43);

  bkq(4, 4) = ComplexType(B44, IB44);

  bkq(6, 0) = ComplexType(B60, IB60);

  bkq(6, 1) = ComplexType(B61, IB61);

  bkq(6, 2) = ComplexType(B62, IB62);

  bkq(6, 3) = ComplexType(B63, IB63);

  bkq(6, 4) = ComplexType(B64, IB64);

  bkq(6, 5) = ComplexType(B65, IB65);

  bkq(6, 6) = ComplexType(B66, IB66);


  DoubleFortranVector en;

  ComplexFortranMatrix wf;

  ComplexFortranMatrix ham;

  calculateEigensystem(en, wf, ham, nre, bmol, bext, bkq);


  setProperty("Energies", en.toStdVector());

  setProperty("Eigenvectors", wf.packToStdVector());

  setProperty("Hamiltonian", ham.packToStdVector());

}


} // namespace Mantid::CurveFitting

DECLARE_ALGORITHM
#define DECLARE_ALGORITHM(classname)
Definition: Algorithm.h:576

ArrayProperty.h

BoundedValidator.h

CrystalElectricField.h

CrystalFieldEnergies.h

Mantid::API::Algorithm::declareProperty
void declareProperty(std::unique_ptr< Kernel::Property > p, const std::string &doc="") override
Add a property to the list of managed properties.
Definition: Algorithm.cpp:1913

Mantid::API::Algorithm::getProperty
TypedValue getProperty(const std::string &name) const override
Get the value of a property.
Definition: Algorithm.cpp:2076

Mantid::CurveFitting::ComplexMatrix::packToStdVector
std::vector< double > packToStdVector() const
Pack the matrix into a single std vector of doubles (for passing in and out of algorithms)
Definition: EigenComplexMatrix.cpp:280

Mantid::CurveFitting::CrystalFieldEnergies
CrystalFieldEnergies : Calculates crystal field energies and wave functions for rare earth ions given...
Definition: CrystalFieldEnergies.h:17

Mantid::CurveFitting::CrystalFieldEnergies::exec
void exec() override
Execute the algorithm.
Definition: CrystalFieldEnergies.cpp:110

Mantid::CurveFitting::CrystalFieldEnergies::init
void init() override
Initialize the algorithm's properties.
Definition: CrystalFieldEnergies.cpp:47

Mantid::CurveFitting::CrystalFieldEnergies::version
int version() const override
Algorithm's version for identification.
Definition: CrystalFieldEnergies.cpp:33

Mantid::CurveFitting::CrystalFieldEnergies::category
const std::string category() const override
Algorithm's category for identification.
Definition: CrystalFieldEnergies.cpp:36

Mantid::CurveFitting::CrystalFieldEnergies::summary
const std::string summary() const override
Algorithm's summary for use in the GUI and help.
Definition: CrystalFieldEnergies.cpp:39

Mantid::CurveFitting::EigenVector::toStdVector
std::vector< double > toStdVector() const
Copy the values to an std vector of doubles.
Definition: EigenVector.cpp:276

Mantid::CurveFitting::FortranMatrix< ComplexMatrix >

Mantid::CurveFitting::FortranVector< EigenVector >

Mantid::Kernel::ArrayProperty
Support for a property that holds an array of values.
Definition: ArrayProperty.h:28

Mantid::Kernel::IPropertyManager::setProperty
IPropertyManager * setProperty(const std::string &name, const T &value)
Templated method to set the value of a PropertyWithValue.
Definition: IPropertyManager.h:266

Mantid::CurveFitting::Functions::calculateEigensystem
void MANTID_CURVEFITTING_DLL calculateEigensystem(DoubleFortranVector &eigenvalues, ComplexFortranMatrix &eigenvectors, ComplexFortranMatrix &hamiltonian, ComplexFortranMatrix &hzeeman, int nre, const DoubleFortranVector &bmol, const DoubleFortranVector &bext, const ComplexFortranMatrix &bkq, double alpha_euler=0.0, double beta_euler=0.0, double gamma_euler=0.0)
Calculate eigenvalues and eigenvectors of the crystal field hamiltonian.
Definition: CrystalElectricField.cpp:630

Mantid::CurveFitting
Definition: IFunction1D.h:19

Mantid::CurveFitting::ComplexType
std::complex< double > ComplexType
Definition: EigenComplexVector.h:19

std
STL namespace.

Mantid::Kernel::Direction
Describes the direction (within an algorithm) of a Property.
Definition: Property.h:50

Mantid::Kernel::Direction::Output
@ Output
An output workspace.
Definition: Property.h:54