/**
* Recalculate the B-spline knots
*/
void BSpline::resetKnots()
{
bool isUniform = getAttribute("Uniform").asBool();
std::vector<double> breakPoints;
if ( isUniform )
{
// create uniform knots in the interval [StartX, EndX]
double startX = getAttribute("StartX").asDouble();
double endX = getAttribute("EndX").asDouble();
gsl_bspline_knots_uniform( startX, endX, m_bsplineWorkspace.get() );
getGSLBreakPoints( breakPoints );
storeAttributeValue( "BreakPoints", Attribute(breakPoints) );
}
else
{
// set the break points from BreakPoints vector attribute, update other attributes
breakPoints = getAttribute( "BreakPoints" ).asVector();
// check that points are in ascending order
double prev = breakPoints[0];
for(size_t i = 1; i < breakPoints.size(); ++i)
{
double next = breakPoints[i];
if ( next <= prev )
{
throw std::invalid_argument("BreakPoints must be in ascending order.");
}
prev = next;
}
int nbreaks = getAttribute( "NBreak" ).asInt();
// if number of break points change do necessary updates
if ( static_cast<size_t>(nbreaks) != breakPoints.size() )
{
storeAttributeValue("NBreak", Attribute(static_cast<int>(breakPoints.size())) );
resetGSLObjects();
resetParameters();
}
GSLVector bp = breakPoints;
gsl_bspline_knots( bp.gsl(), m_bsplineWorkspace.get() );
storeAttributeValue( "StartX", Attribute(breakPoints.front()) );
storeAttributeValue( "EndX", Attribute(breakPoints.back()) );
}
}
/** Set an attribute for the function
*
* @param attName :: The name of the attribute to set
* @param att :: The attribute to set
*/
void BSpline::setAttribute(const std::string &attName,
const API::IFunction::Attribute &att) {
bool isUniform = attName == "Uniform" && att.asBool();
storeAttributeValue(attName, att);
if (attName == "BreakPoints" || isUniform || attName == "StartX" ||
attName == "EndX") {
resetKnots();
} else if (attName == "NBreak" || attName == "Order") {
resetGSLObjects();
resetParameters();
resetKnots();
}
}
/**
* Set a value to a named attribute
* @param name :: The name of the attribute
* @param value :: The value of the attribute
*/
void ResolutionConvolvedCrossSection::setAttribute(
const std::string &name, const API::IFunction::Attribute &value) {
storeAttributeValue(name, value);
const std::string fgModelName = getAttribute(FOREGROUND_ATTR).asString();
const std::string convolutionType = getAttribute(RESOLUTION_ATTR).asString();
if (!convolutionType.empty() && !fgModelName.empty()) {
setupResolutionFunction(convolutionType, fgModelName);
}
if (name == SIMULATION_ATTR)
m_simulation = value.asBool();
else if (name != FOREGROUND_ATTR && name != RESOLUTION_ATTR) {
m_convolution->setAttribute(name, value);
}
}
/** Set an attribute for the function
*
* @param attName :: The name of the attribute to set
* @param att :: The attribute to set
*/
void CubicSpline::setAttribute(const std::string& attName, const API::IFunction::Attribute& att)
{
if (attName == "n")
{
//get the new and old number of data points
int n = att.asInt();
int oldN = getAttribute("n").asInt();
//check that the number of data points is in a valid range
if (n > oldN)
{
//get the name of the last x data point
std::string oldXName = "x" + boost::lexical_cast<std::string>(oldN - 1);
double oldX = getAttribute(oldXName).asDouble();
//reallocate gsl object to new size
reallocGSLObjects(n);
//create blank a number of new blank parameters and attributes
for (int i = oldN; i < n; ++i)
{
std::string num = boost::lexical_cast<std::string>(i);
std::string newXName = "x" + num;
std::string newYName = "y" + num;
declareAttribute(newXName, Attribute(oldX + static_cast<double>(i - oldN + 1)));
declareParameter(newYName, 0);
}
//flag that the spline + derivatives will now need to be recalculated
m_recalculateSpline = true;
}
else if (n < oldN)
{
throw std::invalid_argument("Cubic Spline: Can't decrease the number of attributes");
}
}
storeAttributeValue(attName, att);
}
/**
* Store the attribute's value in the default IFunction's cache
* @param name :: The name of the attribute
* @param value :: The value to store
*/
void IFunctionAdapter::storeAttributePythonValue(const std::string &name,
const object &value) {
auto attr = createAttributeFromPythonValue(value);
storeAttributeValue(name, attr);
}
