/// Declares attributes and generates parameters based on the defaults.
void PawleyParameterFunction::init() {
declareAttribute("LatticeSystem", IFunction::Attribute("Triclinic"));
declareAttribute("ProfileFunction", IFunction::Attribute("Gaussian"));
setLatticeSystem("Triclinic");
setProfileFunction("Gaussian");
}
// DiffRotDiscreteCircle::DiffRotDiscreteCircle()
void DiffRotDiscreteCircle::init() {
m_elastic = boost::dynamic_pointer_cast<ElasticDiffRotDiscreteCircle>(
API::FunctionFactory::Instance().createFunction(
"ElasticDiffRotDiscreteCircle"));
addFunction(m_elastic);
m_inelastic = boost::dynamic_pointer_cast<InelasticDiffRotDiscreteCircle>(
API::FunctionFactory::Instance().createFunction(
"InelasticDiffRotDiscreteCircle"));
addFunction(m_inelastic);
setAttributeValue("NumDeriv", true);
declareAttribute("Q", API::IFunction::Attribute(0.5));
declareAttribute("N", API::IFunction::Attribute(3));
// Set the aliases
setAlias("f1.Intensity", "Intensity");
setAlias("f1.Radius", "Radius");
setAlias("f1.Decay", "Decay");
setAlias("f1.Shift", "Shift");
// Set the ties between Elastic and Inelastic parameters
addDefaultTies("f0.Height=f1.Intensity,f0.Radius=f1.Radius");
applyTies();
}
/**
* Constructor.
*/
ChFun::ChFun(size_t n, const double& startX,const double& endX):
chebfun(n,startX,endX),IFunction1D()
{
m_errors.resize(n + 1);
m_isFixed.resize( n + 1 );
m_explicitlySet.resize( n + 1 );
declareAttribute("n", Attribute(3));
declareAttribute("StartX", Attribute(-1.0));
declareAttribute("EndX", Attribute(1.0));
}
/// Constructor
CrystalFieldPeaksBase::CrystalFieldPeaksBase()
: API::IFunctionGeneral(), API::ParamFunction(), m_defaultDomainSize(0) {
declareAttribute("Ion", Attribute("Ce"));
declareAttribute("Symmetry", Attribute("Ci"));
declareAttribute("ToleranceEnergy", Attribute(1.0e-10));
declareAttribute("ToleranceIntensity", Attribute(1.0e-1));
declareAttribute("MaxPeakCount", Attribute(0));
declareParameter("BmolX", 0.0, "The x-component of the molecular field.");
declareParameter("BmolY", 0.0, "The y-component of the molecular field.");
declareParameter("BmolZ", 0.0, "The z-component of the molecular field.");
declareParameter("BextX", 0.0, "The x-component of the external field.");
declareParameter("BextY", 0.0, "The y-component of the external field.");
declareParameter("BextZ", 0.0, "The z-component of the external field.");
declareParameter("B20", 0.0, "Real part of the B20 field parameter.");
declareParameter("B21", 0.0, "Real part of the B21 field parameter.");
declareParameter("B22", 0.0, "Real part of the B22 field parameter.");
declareParameter("B40", 0.0, "Real part of the B40 field parameter.");
declareParameter("B41", 0.0, "Real part of the B41 field parameter.");
declareParameter("B42", 0.0, "Real part of the B42 field parameter.");
declareParameter("B43", 0.0, "Real part of the B43 field parameter.");
declareParameter("B44", 0.0, "Real part of the B44 field parameter.");
declareParameter("B60", 0.0, "Real part of the B60 field parameter.");
declareParameter("B61", 0.0, "Real part of the B61 field parameter.");
declareParameter("B62", 0.0, "Real part of the B62 field parameter.");
declareParameter("B63", 0.0, "Real part of the B63 field parameter.");
declareParameter("B64", 0.0, "Real part of the B64 field parameter.");
declareParameter("B65", 0.0, "Real part of the B65 field parameter.");
declareParameter("B66", 0.0, "Real part of the B66 field parameter.");
declareParameter("IB21", 0.0, "Imaginary part of the B21 field parameter.");
declareParameter("IB22", 0.0, "Imaginary part of the B22 field parameter.");
declareParameter("IB41", 0.0, "Imaginary part of the B41 field parameter.");
declareParameter("IB42", 0.0, "Imaginary part of the B42 field parameter.");
declareParameter("IB43", 0.0, "Imaginary part of the B43 field parameter.");
declareParameter("IB44", 0.0, "Imaginary part of the B44 field parameter.");
declareParameter("IB61", 0.0, "Imaginary part of the B61 field parameter.");
declareParameter("IB62", 0.0, "Imaginary part of the B62 field parameter.");
declareParameter("IB63", 0.0, "Imaginary part of the B63 field parameter.");
declareParameter("IB64", 0.0, "Imaginary part of the B64 field parameter.");
declareParameter("IB65", 0.0, "Imaginary part of the B65 field parameter.");
declareParameter("IB66", 0.0, "Imaginary part of the B66 field parameter.");
setSymmetryC1(*this);
}
/*
* genxDeclareAttribute - see genx.h for details
*/
genxAttribute genxDeclareAttribute(genxWriter w,
genxNamespace ns, constUtf8 name,
genxStatus * statusP)
{
if ((w->status = checkNCName(w, name)) != GENX_SUCCESS)
{
*statusP = w->status;
return NULL;
}
return declareAttribute(w, ns, name, NULL, statusP);
}
/** 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);
}
void VesuvioResolution::declareAttributes() {
declareAttribute(MASS_NAME, IFunction::Attribute(m_mass));
}
/*
* DeclareNamespace - by far the most complex routine in Genx
*/
genxNamespace genxDeclareNamespace(genxWriter w, constUtf8 uri,
constUtf8 defaultPref,
genxStatus * statusP)
{
genxNamespace ns;
genxAttribute defaultDecl;
UTFTYPE newPrefix[100];
if (uri == NULL || uri[0] == 0)
{
w->status = GENX_BAD_NAMESPACE_NAME;
goto busted;
}
if ((w->status = genxCheckText(w, uri)) != GENX_SUCCESS)
goto busted;
/* if a prefix is provided, it has to be an NCname */
if (defaultPref != NULL && defaultPref[0] != 0 &&
(w->status = checkNCName(w, defaultPref)) != GENX_SUCCESS)
goto busted;
/* previously declared? */
if ((ns = findNamespace(&w->namespaces, uri)))
{
/* just a lookup, really */
if ((defaultPref == NULL) ||
(defaultPref[0] == 0 && ns->defaultDecl == w->xmlnsEquals) ||
(strcmp((const char *) ns->defaultDecl->name + STRLEN_XMLNS_COLON,
(const char *) defaultPref) == 0))
{
w->status = *statusP = GENX_SUCCESS;
return ns;
}
}
/* wasn't already declared */
else
{
/* make a default prefix if none provided */
if (defaultPref == NULL)
{
sprintf((char *) newPrefix, "g%d", w->nextPrefix++);
defaultPref = newPrefix;
}
ns = (genxNamespace) allocate(w, sizeof(struct genxNamespace_rec));
if (ns == NULL)
{
w->status = GENX_ALLOC_FAILED;
goto busted;
}
ns->writer = w;
ns->baroque = False;
if ((ns->name = copy(w, uri)) == NULL)
{
w->status = GENX_ALLOC_FAILED;
goto busted;
}
if ((w->status = listAppend(&w->namespaces, ns)) != GENX_SUCCESS)
goto busted;
ns->defaultDecl = ns->declaration = NULL;
ns->declCount = 0;
}
if (defaultPref[0] == 0)
{
if (w->defaultNsDeclared)
{
w->status = GENX_DUPLICATE_PREFIX;
goto busted;
}
defaultDecl = w->xmlnsEquals;
w->defaultNsDeclared = True;
}
else
{
/* this catches dupes too */
if ((defaultPref = storePrefix(w, defaultPref, False)) == NULL)
goto busted;
defaultDecl = declareAttribute(w, NULL, defaultPref, ns->name, statusP);
if (defaultDecl == NULL || *statusP != GENX_SUCCESS)
{
w->status = *statusP;
return NULL;
}
}
if (ns->defaultDecl != NULL && defaultDecl != ns->defaultDecl)
ns->baroque = True;
ns->defaultDecl = defaultDecl;
*statusP = GENX_SUCCESS;
return ns;
busted:
*statusP = w->status;
return NULL;
}
/*
* Construct a new genxWriter
*/
genxWriter genxNew(void * (* alloc)(void * userData, int bytes),
void (* dealloc)(void * userData, void * data),
void * userData)
{
genxWriter w;
genxNamespace xml;
if (alloc)
w = (genxWriter) (*alloc)(userData, sizeof(struct genxWriter_rec));
else
w = (genxWriter) malloc(sizeof(struct genxWriter_rec));
if (w == NULL)
return NULL;
w->status = GENX_SUCCESS;
w->alloc = alloc;
w->dealloc = dealloc;
w->userData = userData;
w->sequence = SEQUENCE_NO_DOC;
if (initPlist(w, &w->namespaces) != GENX_SUCCESS ||
initPlist(w, &w->elements) != GENX_SUCCESS ||
initPlist(w, &w->attributes) != GENX_SUCCESS ||
initPlist(w, &w->prefixes) != GENX_SUCCESS ||
initPlist(w, &w->stack) != GENX_SUCCESS)
return NULL;
if ((w->status = initCollector(w, &w->arec.value)) != GENX_SUCCESS)
return NULL;
if ((w->empty = copy(w, (utf8) "")) == NULL)
{
w->status = GENX_ALLOC_FAILED;
return NULL;
}
w->xmlnsEquals = declareAttribute(w, NULL, (utf8) "xmlns", NULL, &w->status);
if (w->xmlnsEquals == NULL || w->status != GENX_SUCCESS)
return NULL;
w->defaultNsDeclared = False;
w->nextPrefix = 1;
genxSetCharProps(w->xmlChars);
w->etext[GENX_SUCCESS] = "Success";
w->etext[GENX_BAD_UTF8] = "Bad UTF8";
w->etext[GENX_NON_XML_CHARACTER] = "Non XML Character";
w->etext[GENX_BAD_NAME] = "Bad NAME";
w->etext[GENX_ALLOC_FAILED] = "Memory allocation failed";
w->etext[GENX_BAD_NAMESPACE_NAME] = "Bad namespace name";
w->etext[GENX_INTERNAL_ERROR] = "Internal error";
w->etext[GENX_DUPLICATE_PREFIX] = "Duplicate prefix";
w->etext[GENX_SEQUENCE_ERROR] = "Call out of sequence";
w->etext[GENX_NO_START_TAG] = "No Start-tag for EndElement call";
w->etext[GENX_IO_ERROR] = "I/O error";
w->etext[GENX_MISSING_VALUE] = "Missing attribute value";
w->etext[GENX_MALFORMED_COMMENT] = "Malformed comment body";
w->etext[GENX_MALFORMED_PI] = "?> in PI";
w->etext[GENX_XML_PI_TARGET] = "Target of PI matches [xX][mM][lL]";
w->etext[GENX_DUPLICATE_ATTRIBUTE] =
"Same attribute specified more than once";
w->etext[GENX_ATTRIBUTE_IN_DEFAULT_NAMESPACE] =
"Attribute cannot be in default namespace";
w->etext[GENX_DUPLICATE_NAMESPACE] =
"Declared namespace twice with different prefixes on one element.";
w->etext[GENX_BAD_DEFAULT_DECLARATION] =
"Declared a default namespace on an element which is in no namespace";
/* the xml: namespace is pre-wired */
xml = genxDeclareNamespace(w, (utf8) "http://www.w3.org/XML/1998/namespace",
(utf8) "xml", &w->status);
if (xml == NULL)
return NULL;
xml->declCount = 1;
xml->declaration = xml->defaultDecl;
return w;
}
/*
* internal namespace adder; no sequence checking
*/
static genxStatus addNamespace(genxNamespace ns, utf8 prefix)
{
genxWriter w = ns->writer;
genxAttribute decl;
int i;
genxElement e;
/*
* first, we'll find the declaring attribute
*/
if (prefix == NULL)
decl = ns->defaultDecl;
else
{
if (prefix[0] == 0)
decl = w->xmlnsEquals;
else
{
if ((prefix = storePrefix(w, prefix, True)) == NULL)
return w->status;
decl = declareAttribute(w, NULL, prefix, ns->name, &w->status);
if (decl == NULL || w->status != GENX_SUCCESS)
return w->status;
}
}
if (decl != ns->defaultDecl)
ns->baroque = True;
/*
* avoid doing anything if this namespace is already declared. If
* they've shown good taste we can do this cheaply
*/
if (!ns->baroque)
{
if (ns->declCount > 0)
return w->status = GENX_SUCCESS;
}
else
{
/*
* First, we'll run all the way up the stack to see if there is
* another declaration for this namespace/prefix in scope, in which
* case it's a no-op; or, if there's another declaration for this
* prefix on another namespace, in which case we have to over-ride
*/
i = w->stack.count - 1;
while (i > 0)
{
while (w->stack.pointers[i] != NULL)
{
genxAttribute otherDecl = (genxAttribute) w->stack.pointers[i--];
genxNamespace otherNs = (genxNamespace) w->stack.pointers[i--];
if (ns == otherNs)
{
if (decl == otherDecl)
return w->status = GENX_SUCCESS;
else
{
i = 0;
break;
}
}
else
{
/* different namespace, same prefix? */
if (decl == otherDecl)
{
i = 0;
break;
}
}
}
i -= 2;
}
}
/*
* If this namespace is already declared on
* this element (with different prefix/decl) which is an error.
*/
i = w->stack.count - 1;
while (w->stack.pointers[i] != NULL)
{
genxNamespace otherNs;
i--; /* don't need declaration */
otherNs = (genxNamespace) w->stack.pointers[i--];
if (ns == otherNs)
return w->status = GENX_DUPLICATE_NAMESPACE;
}
/* move pointer from NULL to element */
--i;
/*
* It's also an error if this is a default-namespace declaration and the
* element is in no namespace.
*/
e = (genxElement) w->stack.pointers[i];
if (e->ns == NULL && decl == w->xmlnsEquals)
return w->status = GENX_BAD_DEFAULT_DECLARATION;
if ((w->status = listAppend(&w->stack, ns)) != GENX_SUCCESS)
return w->status;
if ((w->status = listAppend(&w->stack, decl)) != GENX_SUCCESS)
return w->status;
ns->declaration = decl;
ns->declCount++;
return addAttribute(decl, ns->name);
}
