icedb::refract Namespace Reference

Namespaces
	boost
	implementations
	The raw dielectric providers implementations.

Classes
struct	provider_s
struct	requirement_s

Typedefs
typedef std::shared_ptr< const requirement_s >	requirement_p
typedef std::shared_ptr< provider_s >	provider_mp
typedef std::shared_ptr< const provider_s >	provider_p
typedef std::multimap< int, provider_p >	provider_collection_type
typedef std::shared_ptr< const provider_collection_type >	all_providers_p
typedef std::shared_ptr< provider_collection_type >	all_providers_mp
typedef std::function< void(double, std::complex< double > &)>	refractFunction_freqonly_t
typedef std::function< void(double, double, std::complex< double > &)>	refractFunction_freq_temp_t

Functions
all_providers_p	listAllProviders ()
all_providers_p	listAllProviders (const std::string &subst)
void	enumProvider (provider_p p, std::ostream &out)
void	enumProviders (all_providers_p p, std::ostream &out)
void	enumSubstances (std::ostream &out)
provider_p	findProviderByName (const std::string &providerName)
provider_p	findProvider (const std::string &subst, bool haveFreq, bool haveTemp, const std::string &start)
all_providers_p	findProviders (const std::string &subst, bool haveFreq, bool haveTemp)
void	prepRefract (provider_p prov, const std::string &inFreqUnits, refractFunction_freqonly_t &res)
void	prepRefract (provider_p prov, const std::string &inFreqUnits, const std::string &inTempUnits, refractFunction_freq_temp_t &res)
void	bruggeman (std::complex< double > Ma, std::complex< double > Mb, double fa, std::complex< double > &Mres)
void	debyeDry (std::complex< double > Ma, std::complex< double > Mb, double fa, std::complex< double > &Mres)
void	maxwellGarnettSpheres (std::complex< double > Ma, std::complex< double > Mb, double fa, std::complex< double > &Mres)
void	maxwellGarnettEllipsoids (std::complex< double > Ma, std::complex< double > Mb, double fa, std::complex< double > &Mres)
void	sihvola (std::complex< double > Ma, std::complex< double > Mb, double fa, double nu, std::complex< double > &Mres)
std::complex< double >	mToE (std::complex< double > m)
	m to e converters More...
void	mToE (std::complex< double > m, std::complex< double > &e)
std::complex< double >	eToM (std::complex< double > e)
void	eToM (std::complex< double > e, std::complex< double > &m)
double	guessTemp (double freq, const std::complex< double > &m, std::function< void(double freq, double temp, std::complex< double > &mres)> meth, double TA, double TB)

Typedef Documentation

all_providers_mp

typedef std::shared_ptr<provider_collection_type > icedb::refract::all_providers_mp

Definition at line 57 of file refract.hpp.

all_providers_p

typedef std::shared_ptr<const provider_collection_type > icedb::refract::all_providers_p

Definition at line 56 of file refract.hpp.

provider_collection_type

typedef std::multimap<int, provider_p> icedb::refract::provider_collection_type

Definition at line 55 of file refract.hpp.

provider_mp

typedef std::shared_ptr<provider_s> icedb::refract::provider_mp

Definition at line 27 of file refract.hpp.

provider_p

typedef std::shared_ptr<const provider_s> icedb::refract::provider_p

Definition at line 29 of file refract.hpp.

refractFunction_freq_temp_t

typedef std::function<void(double, double, std::complex<double>&)> icedb::refract::refractFunction_freq_temp_t

Definition at line 60 of file refract.hpp.

refractFunction_freqonly_t

typedef std::function<void(double, std::complex<double>&)> icedb::refract::refractFunction_freqonly_t

Definition at line 59 of file refract.hpp.

requirement_p

typedef std::shared_ptr<const requirement_s> icedb::refract::requirement_p

Definition at line 16 of file refract.hpp.

Function Documentation

bruggeman()

void icedb::refract::bruggeman	(	std::complex< double >	Ma,
		std::complex< double >	Mb,
		double	fa,
		std::complex< double > &	Mres
	)

Definition at line 353 of file refract.cpp.

References eToM(), ICEDB_log, icedb::logging::ICEDB_LOG_DEBUG_2, mToE(), and icedb::zeros::secantMethod().

        {
            using namespace std;
            complex<double> eA, eB, eRes;
            mToE(Ma, eA);
            mToE(Mb, eB);

            // Liu's formula is derived only for mAmbient = 1. I want a more general case to make 
            // dielectric chaining easier.
            auto formula = [&](std::complex<double> x) -> std::complex<double>
            {
                // f (( eA - eE ) / (eA + 2eE) ) + (1-f) (( eB - eE ) / (eB + 2eE) ) = 0
                using namespace std;
                complex<double> res, pa, pb;
                pa = complex<double>(fa, 0) * (eA - x) / (eA + (complex<double>(2., 0)*x));
                pb = complex<double>(1. - fa, 0) * (eB - x) / (eB + (complex<double>(2., 0)*x));
                res = pa + pb;
                return res;
            };

            complex<double> gA(1.0, 1.0), gB(1.55, 1.45);
            eRes = zeros::secantMethod(formula, gA, gB);

            eToM(eRes, Mres);
            ICEDB_log("refract", icedb::logging::ICEDB_LOG_DEBUG_2,
                "bruggeman code called\n\tMa " << Ma << "\n\tMb " << Mb << "\n\tfa " << fa
                << "\n\tMres " << Mres);
        }

Here is the call graph for this function:

debyeDry()

void icedb::refract::debyeDry	(	std::complex< double >	Ma,
		std::complex< double >	Mb,
		double	fa,
		std::complex< double > &	Mres
	)

Definition at line 383 of file refract.cpp.

References eToM(), ICEDB_log, icedb::logging::ICEDB_LOG_DEBUG_2, and mToE().

        {
            using namespace std;
            std::complex<double> eA, eB, eRes;
            mToE(Ma, eA);
            mToE(Mb, eB);

            complex<double> pa = fa * (eA - complex<double>(1., 0)) / (eA + complex<double>(2., 0));
            complex<double> pb = (1. - fa) * (eB - complex<double>(1., 0)) / (eB + complex<double>(2., 0));

            complex<double> fact = pa + pb;
            eRes = (complex<double>(2., 0) * fact + complex<double>(1., 0))
                / (complex<double>(1., 0) - fact);
            eToM(eRes, Mres);
            ICEDB_log("refract", icedb::logging::ICEDB_LOG_DEBUG_2,
                "debyeDry code called\n\tMa " << Ma << "\n\tMb " << Mb << "\n\tfa " << fa
                << "\n\tMres " << Mres);
        }

Here is the call graph for this function:

enumProvider()

void icedb::refract::enumProvider	(	provider_p	p,
		std::ostream &	out
	)

Definition at line 158 of file refract.cpp.

References ICEDB_throw, and icedb::error::xNullPointer.

Referenced by enumProviders(), and main().

                                                         {
            if (!p) ICEDB_throw(error::error_types::xNullPointer)
                .add<std::string>("Reason", "No provider was passed to this function - instead, a NULL was passed!");
            out << "Provider:\t" << p->name << "\n"
                << "\tSubstance:\t" << p->substance << "\n"
                << "\tSource:\t" << p->source << "\n"
                << "\tNotes:\t" << p->notes << "\n";
            if (p->reqs.size()) {
                out << "\tRequirements:\n";
                for (const auto &r : p->reqs) {
                    out << "\t\tParameter:\t" << r.first
                        << "\t\t\tRange:\t" << r.second->validRange.first << " to "
                        << r.second->validRange.second << " "
                        << r.second->parameterUnits << "\n";
                }
            }
        }

Here is the caller graph for this function:

enumProviders()

void icedb::refract::enumProviders	(	all_providers_p	p,
		std::ostream &	out
	)

Definition at line 175 of file refract.cpp.

References enumProvider(), ICEDB_throw, and icedb::error::xNullPointer.

Referenced by main().

                                                               {
            if (!p) ICEDB_throw(error::error_types::xNullPointer)
                .add<std::string>("Reason", "The pointer passed to this function was NULL!");
            if (p->size() == 1) out << "Providers found: 1\n";
            else out << "Providers enumerated: " << p->size() << "\n";
            for (const auto &i : *(p.get())) {
                enumProvider(i.second, out);
            }
        }

Here is the call graph for this function:

Here is the caller graph for this function:

enumSubstances()

void icedb::refract::enumSubstances

(

std::ostream &

out

)

Definition at line 184 of file refract.cpp.

References listAllProviders(), and icedb::refract::implementations::substs.

Referenced by main().

                                             {
            listAllProviders();
            out << "Substances:" << std::endl;
            for (const auto &i : implementations::substs)
                out << "\t" << i << std::endl;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

eToM() [1/2]

std::complex< double > icedb::refract::eToM

(

std::complex< double >

e

)

Definition at line 485 of file refract.cpp.

Referenced by bruggeman(), debyeDry(), eToM(), maxwellGarnettEllipsoids(), maxwellGarnettSpheres(), and sihvola().

        {
            return sqrt(e);
        }

Here is the caller graph for this function:

eToM() [2/2]

void icedb::refract::eToM	(	std::complex< double >	e,
		std::complex< double > &	m
	)

Definition at line 489 of file refract.cpp.

References eToM().

        {
            m = eToM(e);
        }

Here is the call graph for this function:

findProvider()

provider_p icedb::refract::findProvider	(	const std::string &	subst,
		bool	haveFreq,
		bool	haveTemp,
		const std::string &	start
	)

Definition at line 202 of file refract.cpp.

References icedb::refract::implementations::_init(), icedb::refract::implementations::allProvidersSet, ICEDB_throw, icedb::refract::implementations::providersByName, icedb::refract::implementations::providersSet, and icedb::error::xBadFunctionMap.

                                                                   {
            provider_p emptyres;
            if (!implementations::allProvidersSet) implementations::_init();
            if (implementations::allProvidersSet->size() == 0) implementations::_init();

            if (implementations::providersByName.count(subst)) {
                provider_p cres = implementations::providersByName.at(subst);
                if ((cres->reqs.count("spec") && !haveFreq) || (cres->reqs.count("temp") && !haveTemp)) {
                    ICEDB_throw(icedb::error::error_types::xBadFunctionMap)
                        .add<std::string>("Reason", "Attempting to find the provider for a manually-"
                            "specified refractive index formula, but the retrieved formula's "
                            "requirements do not match what whas passed.")
                        .add<std::string>("Provider", subst);
                }
                return cres;
            }

            if (!implementations::providersSet.count(subst)) return emptyres;
            all_providers_mp pss = implementations::providersSet.at(subst);
            bool startSearch = false;
            if (start == "") startSearch = true;
            for (const auto &p : *(pss.get())) {
                if (!startSearch) {
                    if (p.second->name == start) startSearch = true;
                    continue;
                } else {
                    if (p.second->reqs.count("spec") && !haveFreq) continue;
                    if (p.second->reqs.count("temp") && !haveTemp) continue;
                }
                return p.second;
            }
            return emptyres;
        }

Here is the call graph for this function:

findProviderByName()

provider_p icedb::refract::findProviderByName

(

const std::string &

providerName

)

Definition at line 191 of file refract.cpp.

References icedb::refract::implementations::_init(), icedb::refract::implementations::allProvidersSet, and icedb::refract::implementations::providersByName.

Referenced by main().

                                                                     {
            provider_p emptyres;
            if (!implementations::allProvidersSet) implementations::_init();
            if (implementations::allProvidersSet->size() == 0) implementations::_init();
            if (implementations::providersByName.count(providerName)) {
                provider_p cres = implementations::providersByName.at(providerName);
                return cres;
            }
            return emptyres;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

findProviders()

all_providers_p icedb::refract::findProviders	(	const std::string &	subst,
		bool	haveFreq,
		bool	haveTemp
	)

Definition at line 236 of file refract.cpp.

References icedb::refract::implementations::_init(), icedb::refract::implementations::allProvidersSet, ICEDB_throw, icedb::refract::implementations::providersByName, icedb::refract::implementations::providersSet, and icedb::error::xBadFunctionMap.

Referenced by main().

                                          {
            all_providers_mp res(new provider_collection_type);
            if (!implementations::allProvidersSet) implementations::_init();
            if (implementations::allProvidersSet->size() == 0) implementations::_init();
            
            if (implementations::providersByName.count(subst)) {
                provider_p cres = implementations::providersByName.at(subst);
                if ((cres->reqs.count("spec") && !haveFreq) || (cres->reqs.count("temp") && !haveTemp)) {
                    ICEDB_throw(icedb::error::error_types::xBadFunctionMap)
                        .add<std::string>("Reason", "Attempting to find the provider for a manually-"
                            "specified refractive index formula, but the retrieved formula's "
                            "requirements do not match what was passed.")
                        .add<bool>("Have-Freq", haveFreq)
                        .add<bool>("Need-Freq", (bool) cres->reqs.count("spec"))
                        .add<bool>("Have-Temp", haveTemp)
                        .add<bool>("Need-Temp", (bool)cres->reqs.count("temp"))
                        .add<std::string>("Provider", subst);
                }
                res->insert(std::pair<int, provider_p>(0, cres));
                return res;
            }
            
            if (!implementations::providersSet.count(subst)) return res;
            all_providers_p pss = implementations::providersSet.at(subst);
            for (const auto &p : *(pss.get())) {
                if (p.second->reqs.count("spec") && !haveFreq) continue;
                if (p.second->reqs.count("temp") && !haveTemp) continue;
                res->insert(p);
            }
            return res;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

guessTemp()

double icedb::refract::guessTemp	(	double	freq,
		const std::complex< double > &	m,
		std::function< void(double freq, double temp, std::complex< double > &mres)>	meth,
		double	TA,
		double	TB
	)

Definition at line 494 of file refract.cpp.

References icedb::zeros::secantMethod().

        {
            using namespace std;
            // Attempt to guess the formula using the secant method.
            auto formulaTemp = [&](double T) -> double
            {
                // 0 = mRes(f,T) - m_known
                using namespace std;
                complex<double> mRes;
                meth(freq, T, mRes);

                double mNorm = mRes.real() - m.real(); //norm(mRes- ms.at(0));

                return mNorm;
            };

            double temp = 0;
            //complex<double> gA, gB;
            //refract::mIce(freq, TA, gA);
            //refract::mIce(freq, TB, gB);
            temp = zeros::secantMethod(formulaTemp, TA, TB, 0.00001);
            return temp;
        }

Here is the call graph for this function:

listAllProviders() [1/2]

all_providers_p icedb::refract::listAllProviders

(

)

Definition at line 145 of file refract.cpp.

References icedb::refract::implementations::_init(), and icedb::refract::implementations::allProvidersSet.

Referenced by enumSubstances(), and main().

                                           {
            if (!implementations::allProvidersSet) implementations::_init();
            if (implementations::allProvidersSet->size() == 0) implementations::_init();
            return implementations::allProvidersSet;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

listAllProviders() [2/2]

all_providers_p icedb::refract::listAllProviders

(

const std::string &

subst

)

Definition at line 150 of file refract.cpp.

References icedb::refract::implementations::_init(), icedb::refract::implementations::allProvidersSet, and icedb::refract::implementations::providersSet.

                                                                 {
            all_providers_p emptyres;
            if (!implementations::allProvidersSet) implementations::_init();
            if (implementations::allProvidersSet->size() == 0) implementations::_init();
            if (!implementations::providersSet.count(subst)) return emptyres;
            all_providers_p pss = implementations::providersSet.at(subst);
            return pss;
        }

Here is the call graph for this function:

maxwellGarnettEllipsoids()

void icedb::refract::maxwellGarnettEllipsoids	(	std::complex< double >	Ma,
		std::complex< double >	Mb,
		double	fa,
		std::complex< double > &	Mres
	)

Definition at line 422 of file refract.cpp.

References eToM(), ICEDB_log, icedb::logging::ICEDB_LOG_DEBUG_2, and mToE().

        {
            using namespace std;
            std::complex<double> eA, eB, eRes;
            mToE(Ma, eA);
            mToE(Mb, eB);

            complex<double> betaA = complex<double>(2., 0)*eA / (eB - eA);
            complex<double> betaB = ((eB / (eB - eA)) * log(eB / eA)) - complex<double>(1., 0);
            complex<double> beta = betaA * betaB;

            complex<double> cf(fa, 0), cfc(1. - fa, 0);

            eRes = ((cfc*beta) + (cf*eA)) / (cf + (cfc*beta));
            eToM(eRes, Mres);
            ICEDB_log("refract", icedb::logging::ICEDB_LOG_DEBUG_2, 
                "maxwellGarnettEllipsoids code called\n\tMa " << Ma << "\n\tMb " << Mb << "\n\tfa " << fa
                << "\n\tMres " << Mres);
        }

Here is the call graph for this function:

maxwellGarnettSpheres()

void icedb::refract::maxwellGarnettSpheres	(	std::complex< double >	Ma,
		std::complex< double >	Mb,
		double	fa,
		std::complex< double > &	Mres
	)

Definition at line 403 of file refract.cpp.

References eToM(), ICEDB_log, icedb::logging::ICEDB_LOG_DEBUG_2, and mToE().

        {
            using namespace std;
            std::complex<double> eA, eB, eRes;
            mToE(Ma, eA);
            mToE(Mb, eB);

            // Formula is:
            // (e_eff - eb)/(e_eff+2eb) = fa * (ea - eb) / (ea + 2 eb)
            complex<double> a = complex<double>(fa, 0) * (eA - eB) / (eA + (complex<double>(2, 0) * eB));
            eRes = eB * (complex<double>(2, 0) * a + complex<double>(1, 0))
                / (complex<double>(1, 0) - a);
            eToM(eRes, Mres);
            ICEDB_log("refract", icedb::logging::ICEDB_LOG_DEBUG_2,
                "maxwellGarnettSpheres code called\n\tMa " << Ma << "\n\tMb " << Mb << "\n\tfa " << fa
                << "\n\tMres " << Mres);
        }

Here is the call graph for this function:

mToE() [1/2]

std::complex< double > icedb::refract::mToE

(

std::complex< double >

m

)

m to e converters

Definition at line 476 of file refract.cpp.

Referenced by bruggeman(), debyeDry(), maxwellGarnettEllipsoids(), maxwellGarnettSpheres(), mToE(), and sihvola().

        {
            return m * m;
        }

Here is the caller graph for this function:

mToE() [2/2]

void icedb::refract::mToE	(	std::complex< double >	m,
		std::complex< double > &	e
	)

Definition at line 480 of file refract.cpp.

References mToE().

        {
            e = mToE(m);
        }

Here is the call graph for this function:

prepRefract() [1/2]

void icedb::refract::prepRefract	(	provider_p	prov,
		const std::string &	inFreqUnits,
		refractFunction_freqonly_t &	res
	)

Translation function exists to ensure that the units are passed as expected.

Definition at line 268 of file refract.cpp.

References icedb::refract::provider_s::FREQ, icedb::units::conv_spec::generate(), ICEDB_throw, icedb::error::xBadFunctionMap, and icedb::error::xBadInput.

Referenced by main().

                                             {
            auto compatFunc = [](
                units::converter_p converterFreq,
                void* innerFunc,
                double inSpec,
                std::complex<double> &m) -> void {
                // It's an ugly cast...
                void(*transFunc)(double, std::complex<double>&) = (void(*)(double,std::complex<double>&))innerFunc;
                if (!converterFreq)
                    transFunc(inSpec, m);
                else {
                    transFunc(converterFreq->convert(inSpec), m);
                }
            };
            units::converter_p converter;
            if (prov->speciality_function_type != provider_s::spt::FREQ)
                ICEDB_throw(icedb::error::error_types::xBadInput)
                .add<std::string>("Reason", "You called the wrong prepRefract.");
            if (!prov->reqs.count("spec"))
                ICEDB_throw(icedb::error::error_types::xBadFunctionMap)
                .add<std::string>("Reason", "Attempting to prepare a refractive index formula that does not "
                    "require a frequency / wavelength / wavenumber, but one was provided.");
            std::string reqUnits = prov->reqs.at("spec")->parameterUnits;
            if (reqUnits != inFreqUnits)
                converter = units::conv_spec::generate(inFreqUnits, reqUnits);

            res = std::bind(compatFunc,
                converter,
                prov->specialty_pointer,
                std::placeholders::_1,
                std::placeholders::_2);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

prepRefract() [2/2]

void icedb::refract::prepRefract	(	provider_p	prov,
		const std::string &	inFreqUnits,
		const std::string &	inTempUnits,
		refractFunction_freq_temp_t &	res
	)

Translation function exists to ensure that the units are passed as expected.

Definition at line 302 of file refract.cpp.

References icedb::refract::provider_s::FREQTEMP, icedb::units::converter::generate(), icedb::units::conv_spec::generate(), ICEDB_throw, icedb::error::xBadFunctionMap, and icedb::error::xBadInput.

                                              {
            auto compatFunc = [](
                units::converter_p converterFreq,
                units::converter_p converterTemp,
                void* innerFunc,
                double inSpec,
                double inTemp,
                std::complex<double> &m) -> void {
                // It's an ugly cast...
                void(*transFunc)(double, double, std::complex<double>&) = (void(*)(double, double, std::complex<double>&))innerFunc;
                if (!converterFreq && !converterTemp)
                    transFunc(inSpec, inTemp, m);
                else if (converterFreq && !converterTemp)
                    transFunc(converterFreq->convert(inSpec), inTemp, m);
                else if (!converterFreq && converterTemp)
                    transFunc(inSpec, converterTemp->convert(inTemp), m);
                else transFunc(converterFreq->convert(inSpec), converterTemp->convert(inTemp), m);
            };
            units::converter_p converterFreq, converterTemp;
            if (prov->speciality_function_type != provider_s::spt::FREQTEMP)
                ICEDB_throw(icedb::error::error_types::xBadInput)
                .add<std::string>("Reason", "You called the wrong prepRefract.");
            if (!prov->reqs.count("spec"))
                ICEDB_throw(icedb::error::error_types::xBadFunctionMap)
                .add<std::string>("Reason", "Attempting to prepare a refractive index formula that does not "
                    "require a frequency / wavelength / wavenumber, but one was provided.");
            std::string reqFreqUnits = prov->reqs.at("spec")->parameterUnits;
            if (reqFreqUnits != inFreqUnits)
                converterFreq = units::conv_spec::generate(inFreqUnits, reqFreqUnits);

            if (!prov->reqs.count("temp"))
                ICEDB_throw(icedb::error::error_types::xBadFunctionMap)
                .add<std::string>("Reason", "Attempting to prepare a refractive index formula that does not "
                    "require a temperature, but one was provided.");
            std::string reqTempUnits = prov->reqs.at("temp")->parameterUnits;
            if (reqTempUnits != inTempUnits)
                converterTemp = units::converter::generate(inTempUnits, reqTempUnits);

            res = std::bind(compatFunc,
                converterFreq,
                converterTemp,
                prov->specialty_pointer,
                std::placeholders::_1,
                std::placeholders::_2,
                std::placeholders::_3);
        }

Here is the call graph for this function:

sihvola()

void icedb::refract::sihvola	(	std::complex< double >	Ma,
		std::complex< double >	Mb,
		double	fa,
		double	nu,
		std::complex< double > &	Mres
	)

Formula is: (e_eff - eb) / (e_eff + 2eb + v(e_eff - eb)) - fa (ea-eb)/(ea+2eb+v(e_eff-eb) = 0 This formula has no analytic solution. It is also complex-valued. Its derivative is hard to calculate. Because of this, I will be using the complex secant method to find the zeros. This is also why the other mixing formulas do not call this code.

Definition at line 443 of file refract.cpp.

References eToM(), ICEDB_log, icedb::logging::ICEDB_LOG_DEBUG_2, mToE(), and icedb::zeros::secantMethod().

        {
            using namespace std;
            std::complex<double> eA, eB, eRes;
            mToE(Ma, eA);
            mToE(Mb, eB);

            auto formulaSihvola = [&](std::complex<double> x) -> std::complex<double>
            {
                using namespace std;
                complex<double> res, pa, pb;
                pa = (x - eB) / (x + (complex<double>(2.0, 0)*eB) + (complex<double>(nu, 0)*(x - eB)));
                pb = complex<double>(fa, 0) *
                    (eA - eB) / (eA + (complex<double>(2.0, 0)*eB) + (complex<double>(nu, 0)*(x - eB)));
                res = pa - pb;
                return res;
            };

            complex<double> gA(1.0, 1.0), gB(1.55, 1.45);
            eRes = zeros::secantMethod(formulaSihvola, gA, gB);
            eToM(eRes, Mres);
            ICEDB_log("refract", icedb::logging::ICEDB_LOG_DEBUG_2, "sihvola code called\n\tMa " << Ma << "\n\tMb " << Mb << "\n\tfa " << fa
                << "\n\tnu " << nu << "\n\tMres " << Mres);
        }

Here is the call graph for this function: