/// 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); }