Takin can load S(q,w) plugins via native shared libraries (SO or DLL files). C++ examples to build upon are given in the subdirectory "examples/sqw_module".
The minimal example using the native interface to Takin is given in the following.
Header file "sqwmod.h":
/**
* S(q,w) module example
* @author Tobias Weber
/**
* S(q,w) module example
* @author Tobias Weber
* @date 2016
* @license GPLv2
*
* compile with:
* g++ -std=c++11 -I. -shared -fPIC -o plugins/sqwmod.so sqwmod.cpp tools/monteconvo/sqwbase.cpp tlibs/log/log.cpp
*/
#include "sqwmod.h"
#include "libs/version.h"
#include "tlibs/string/string.h"
#include "tlibs/math/math.h"
#include "tlibs/phys/neutrons.h"
#include
using t_real = typename SqwMod::t_real;
// ----------------------------------------------------------------------------
// constructors
SqwMod::SqwMod() : m_vecG(tl::make_vec({1,0,0}))
{
SqwBase::m_bOk = 1;
}
SqwMod::SqwMod(const std::string& strCfgFile) : SqwMod()
{
tl::log_info("Config file: \"", strCfgFile, "\".");
SqwBase::m_bOk = 1;
}
SqwMod::~SqwMod()
{
}
// ----------------------------------------------------------------------------
// dispersion, spectral weight and structure factor
std::tuple, std::vector>
SqwMod::disp(t_real dh, t_real dk, t_real dl) const
{
t_real dEp = 0; // energy (boson creation)
t_real dwp = 1; // spectral weight (boson creation)
t_real dEm = -dEp; // energy (boson annihilation)
t_real dwm = dwp; // spectral weight (boson annihilation)
// TODO: calculate dispersion relation
return std::make_tuple(std::vector({dEp, dEm}),
std::vector({dwp, dwm}));
}
t_real SqwMod::operator()(t_real dh, t_real dk, t_real dl, t_real dE) const
{
t_real dcut = t_real(0.02);
std::vector vecE, vecW;
std::tie(vecE, vecW) = disp(dh, dk, dl);
t_real dInc=0, dS_p=0, dS_m=0;
if(!tl::float_equal(m_dIncAmp, t_real(0)))
dInc = tl::gauss_model(dE, t_real(0), m_dIncSigma, m_dIncAmp, t_real(0));
t_real dS = 0;
for(std::size_t iE=0; iE SqwMod::GetVars() const
{
std::vector vecVars;
vecVars.push_back(SqwBase::t_var{"T", "real", tl::var_to_str(m_dT)});
vecVars.push_back(SqwBase::t_var{"sigma_create", "real", tl::var_to_str(m_dSigma[0])});
vecVars.push_back(SqwBase::t_var{"sigma_annihilate", "real", tl::var_to_str(m_dSigma[1])});
vecVars.push_back(SqwBase::t_var{"single_sigma", "bool", tl::var_to_str(m_bUseSingleSigma)});
vecVars.push_back(SqwBase::t_var{"inc_amp", "real", tl::var_to_str(m_dIncAmp)});
vecVars.push_back(SqwBase::t_var{"inc_sigma", "real", tl::var_to_str(m_dIncSigma)});
vecVars.push_back(SqwBase::t_var{"S0", "real", tl::var_to_str(m_dS0)});
vecVars.push_back(SqwBase::t_var{"G", "vector", vec_to_str(m_vecG)});
return vecVars;
}
void SqwMod::SetVars(const std::vector& vecVars)
{
if(!vecVars.size()) return;
for(const SqwBase::t_var& var : vecVars)
{
const std::string& strVar = std::get<0>(var);
const std::string& strVal = std::get<2>(var);
if(strVar == "T") m_dT = tl::str_to_var(strVal);
else if(strVar == "sigma_create") m_dSigma[0] = tl::str_to_var(strVal);
else if(strVar == "sigma_annihilate") m_dSigma[1] = tl::str_to_var(strVal);
else if(strVar == "single_sigma") m_bUseSingleSigma = tl::str_to_var(strVal);
else if(strVar == "inc_amp") m_dIncAmp = tl::str_to_var(strVal);
else if(strVar == "inc_sigma") m_dIncSigma = tl::str_to_var(strVal);
else if(strVar == "S0") m_dS0 = tl::str_to_var(strVal);
else if(strVar == "G") m_vecG = str_to_vec(strVal);
}
}
bool SqwMod::SetVarIfAvail(const std::string& strKey, const std::string& strNewVal)
{
return SqwBase::SetVarIfAvail(strKey, strNewVal);
}
// ----------------------------------------------------------------------------
// copy
SqwBase* SqwMod::shallow_copy() const
{
SqwMod *pMod = new SqwMod();
pMod->m_dT = this->m_dT;
pMod->m_dSigma[0] = this->m_dSigma[0];
pMod->m_dSigma[1] = this->m_dSigma[1];
pMod->m_bUseSingleSigma = this->m_bUseSingleSigma;
pMod->m_dIncAmp = this->m_dIncAmp;
pMod->m_dIncSigma = this->m_dIncSigma;
pMod->m_vecG = this->m_vecG;
pMod->m_dS0 = this->m_dS0;
return pMod;
}
// ----------------------------------------------------------------------------
// SO interface
static const char* pcModIdent = "tstmod";
static const char* pcModName = "Test Module";
std::tuple sqw_info()
{
tl::log_info("In ", __func__, ".");
return std::make_tuple(TAKIN_VER, pcModIdent, pcModName);
}
std::shared_ptr sqw_construct(const std::string& strCfgFile)
{
tl::log_info("In ", __func__, ".");
return std::make_shared(strCfgFile);
}
// exports from so file
BOOST_DLL_ALIAS(sqw_info, takin_sqw_info);
BOOST_DLL_ALIAS(sqw_construct, takin_sqw);