Changeset eba9885 in sasview for sansmodels/src/sans/models/c_models

Timestamp:

Aug 5, 2009 5:39:03 PM (16 years ago)

Author:

Gervaise Alina <gervyh@…>

Branches:

master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload

Children:

f88624d

Parents:

8344c50

Message:

code for evalDistribution

Location:

sansmodels/src/sans/models/c_models

Files:

• c_models.cpp (modified) (5 diffs)
• dispersion_visitor.cpp (modified) (2 diffs)
• dispersion_visitor.hh (modified) (1 diff)
• parameters.cpp (modified) (1 diff)
• parameters.hh (modified) (1 diff)

sansmodels/src/sans/models/c_models/c_models.cpp

@@ -48 +48 @@
         void addCGaussian(PyObject *module);
         void addCLorentzian(PyObject *module);
+        void addCLogNormal(PyObject *module);
+        void addCSchulz(PyObject *module);
 }
 
@@ -69 +71 @@
 
 /**
+ * Delete a lognormal dispersion model object
+ */
+void del_lognormal_dispersion(void *ptr){
+        LogNormalDispersion * disp = static_cast<LogNormalDispersion *>(ptr);
+        delete disp;
+        return;
+}
+
+/**
+ * Create a lognormal dispersion model as a python object
+ */
+PyObject * new_lognormal_dispersion(PyObject *, PyObject *args) {
+        LogNormalDispersion *disp = new LogNormalDispersion();
+        return PyCObject_FromVoidPtr(disp, del_lognormal_dispersion);
+}
+
+/**
  * Delete a gaussian dispersion model object
  */
@@ -84 +103 @@
         return PyCObject_FromVoidPtr(disp, del_gaussian_dispersion);
 }
+
+/**
+ * Delete a schulz dispersion model object
+ */
+void del_schulz_dispersion(void *ptr){
+        SchulzDispersion * disp = static_cast<SchulzDispersion *>(ptr);
+        delete disp;
+        return;
+}
+/**
+ * Create a schulz dispersion model as a python object
+ */
+PyObject * new_schulz_dispersion(PyObject *, PyObject *args) {
+        SchulzDispersion *disp = new SchulzDispersion();
+        return PyCObject_FromVoidPtr(disp, del_schulz_dispersion);
+}
+
 
 /**
@@ -147 +183 @@
         {"new_gaussian_model",   (PyCFunction)new_gaussian_dispersion, METH_VARARGS,
                   "Create a new GaussianDispersion object"},
+    {"new_lognormal_model",   (PyCFunction)new_lognormal_dispersion, METH_VARARGS,
+                  "Create a new LogNormalDispersion object"},
+    {"new_schulz_model",   (PyCFunction)new_schulz_dispersion, METH_VARARGS,
+                  "Create a new SchulzDispersion object"},
         {"new_array_model",      (PyCFunction)new_array_dispersion  , METH_VARARGS,
                   "Create a new ArrayDispersion object"},
@@ -194 +234 @@
         addDisperser(m);
         addCGaussian(m);
+        addCSchulz(m);
+        addCLogNormal(m);
         addCLorentzian(m);
         addCVesicleModel(m);
 
-
-}
+}

sansmodels/src/sans/models/c_models/dispersion_visitor.cpp

@@ -25 +25 @@
 
         PyDict_SetItemString(dict, "type",  Py_BuildValue("s", "gaussian"));
+    PyDict_SetItemString(dict, "npts",  Py_BuildValue("i", disp->npts));
+    PyDict_SetItemString(dict, "width", Py_BuildValue("d", disp->width));
+    PyDict_SetItemString(dict, "nsigmas", Py_BuildValue("i", disp->nsigmas));
+#endif
+}
+
+void DispersionVisitor:: lognormal_to_dict(void* dispersion, void* dictionary) {
+#ifndef __MODELS_STANDALONE__
+        LogNormalDispersion * disp = (LogNormalDispersion*)dispersion;
+        PyObject * dict = (PyObject*)dictionary;
+
+        PyDict_SetItemString(dict, "type",  Py_BuildValue("s", "lognormal"));
+    PyDict_SetItemString(dict, "npts",  Py_BuildValue("i", disp->npts));
+    PyDict_SetItemString(dict, "width", Py_BuildValue("d", disp->width));
+    PyDict_SetItemString(dict, "nsigmas", Py_BuildValue("i", disp->nsigmas));
+#endif
+}
+
+
+void DispersionVisitor:: schulz_to_dict(void* dispersion, void* dictionary) {
+#ifndef __MODELS_STANDALONE__
+        SchulzDispersion * disp = (SchulzDispersion*)dispersion;
+        PyObject * dict = (PyObject*)dictionary;
+
+        PyDict_SetItemString(dict, "type",  Py_BuildValue("s", "schulz"));
     PyDict_SetItemString(dict, "npts",  Py_BuildValue("i", disp->npts));
     PyDict_SetItemString(dict, "width", Py_BuildValue("d", disp->width));
@@ -61 +86 @@
 }
 
+void DispersionVisitor:: lognormal_from_dict(void* dispersion, void* dictionary) {
+#ifndef __MODELS_STANDALONE__
+        LogNormalDispersion * disp = (LogNormalDispersion*)dispersion;
+        PyObject * dict = (PyObject*)dictionary;
+
+        disp->npts    = PyInt_AsLong( PyDict_GetItemString(dict, "npts") );
+        disp->width   = PyFloat_AsDouble( PyDict_GetItemString(dict, "width") );
+        disp->nsigmas = PyFloat_AsDouble( PyDict_GetItemString(dict, "nsigmas") );
+#endif
+}
+void DispersionVisitor:: schulz_from_dict(void* dispersion, void* dictionary) {
+#ifndef __MODELS_STANDALONE__
+        SchulzDispersion * disp = (SchulzDispersion*)dispersion;
+        PyObject * dict = (PyObject*)dictionary;
+
+        disp->npts    = PyInt_AsLong( PyDict_GetItemString(dict, "npts") );
+        disp->width   = PyFloat_AsDouble( PyDict_GetItemString(dict, "width") );
+        disp->nsigmas = PyFloat_AsDouble( PyDict_GetItemString(dict, "nsigmas") );
+#endif
+}
+
 void DispersionVisitor:: array_from_dict(void* dispersion, void* dictionary) {}

sansmodels/src/sans/models/c_models/dispersion_visitor.hh

@@ -19 +19 @@
         void dispersion_to_dict(void *, void *);
         void gaussian_to_dict(void *, void *);
+        void lognormal_to_dict(void *, void *);
+        void schulz_to_dict(void*, void *);
         void array_to_dict(void *, void *);
 
         void dispersion_from_dict(void*, void *);
         void gaussian_from_dict(void*, void *);
+        void lognormal_from_dict(void*, void *);
+        void schulz_from_dict(void*, void *);
         void array_from_dict(void*, void *);
 

sansmodels/src/sans/models/c_models/parameters.cpp

@@ -136 +136 @@
         }
 }
+
+
+/**
+ * LogNormal dispersion
+ */
+
+LogNormalDispersion :: LogNormalDispersion() {
+        npts  = 1;
+        width = 0.0;
+        nsigmas = 2;
+};
+
+void LogNormalDispersion :: accept_as_source(DispersionVisitor* visitor, void* from, void* to) {
+        visitor->lognormal_to_dict(from, to);
+}
+void LogNormalDispersion :: accept_as_destination(DispersionVisitor* visitor, void* from, void* to) {
+        visitor->lognormal_from_dict(from, to);
+}
+
+double lognormal_weight(double mean, double sigma, double x) {
+        
+        double sigma2 = pow(sigma, 2);  
+        return 1/(x*sigma2) * exp( -pow((log(x) -mean), 2) / (2*sigma2));
+ 
+}
+
+/**
+ * Lognormal dispersion
+ * @param mean: mean value of the LogNormal
+ * @param sigma: standard deviation of the LogNormal
+ * @param x: value at which the LogNormal is evaluated
+ * @return: value of the LogNormal
+ */
+void LogNormalDispersion :: operator() (void *param, vector<WeightPoint> &weights){
+        // Check against zero width
+        if (width<=0) {
+                width = 0.0;
+                npts  = 1;
+                nsigmas = 3;
+        }
+
+        Parameter* par = (Parameter*)param;
+        double value = (*par)();
+
+        if (npts<2) {
+                weights.insert(weights.end(), WeightPoint(value, 1.0));
+        } else {
+                for(int i=0; i<npts; i++) {
+                        // We cover n(nsigmas) times sigmas on each side of the mean
+                        double val = value + width * (2.0*nsigmas*i/float(npts-1) - nsigmas);
+
+                        if ( ((*par).has_min==false || val>(*par).min)
+                          && ((*par).has_max==false || val<(*par).max)  ) {
+                                double _w = lognormal_weight(value, width, val);
+                                weights.insert(weights.end(), WeightPoint(val, _w));
+                        }
+                }
+        }
+}
+
+
+
+/**
+ * Schulz dispersion
+ */
+
+SchulzDispersion :: SchulzDispersion() {
+        npts  = 1;
+        width = 0.0;
+        nsigmas = 2;
+};
+
+void SchulzDispersion :: accept_as_source(DispersionVisitor* visitor, void* from, void* to) {
+        visitor->schulz_to_dict(from, to);
+}
+void SchulzDispersion :: accept_as_destination(DispersionVisitor* visitor, void* from, void* to) {
+        visitor->schulz_from_dict(from, to);
+}
+
+double schulz_weight(double mean, double sigma, double x) {
+        double vary, expo_value;
+    double z = pow(mean/ sigma, 2)-1;   
+        double R= x/mean;
+        double zz= z+1;
+        return  pow(zz,zz) * pow(R,z) * exp(-1*R*zz)/((mean) * tgamma(zz)) ;
+}
+
+/**
+ * Schulz dispersion
+ * @param mean: mean value of the Schulz
+ * @param sigma: standard deviation of the Schulz
+ * @param x: value at which the Schulz is evaluated
+ * @return: value of the Schulz
+ */
+void SchulzDispersion :: operator() (void *param, vector<WeightPoint> &weights){
+        // Check against zero width
+        if (width<=0) {
+                width = 0.0;
+                npts  = 1;
+                nsigmas = 3;
+        }
+
+        Parameter* par = (Parameter*)param;
+        double value = (*par)();
+
+        if (npts<2) {
+                weights.insert(weights.end(), WeightPoint(value, 1.0));
+        } else {
+                for(int i=0; i<npts; i++) {
+                        // We cover n(nsigmas) times sigmas on each side of the mean
+                        double val = value + width * (2.0*nsigmas*i/float(npts-1) - nsigmas);
+
+                        if ( ((*par).has_min==false || val>(*par).min)
+                          && ((*par).has_max==false || val<(*par).max)  ) {
+                                double _w = schulz_weight(value, width, val);
+                                weights.insert(weights.end(), WeightPoint(val, _w));
+                        }
+                }
+        }
+}
+
+
+
 
 /**

sansmodels/src/sans/models/c_models/parameters.hh

@@ -77 +77 @@
 
 /**
+ * Schulz dispersion model
+ */
+class SchulzDispersion: public DispersionModel {
+public:
+        /// Number of sigmas on each side of the mean
+        int nsigmas;
+
+        SchulzDispersion();
+        void operator()(void *, vector<WeightPoint>&);
+        void accept_as_source(DispersionVisitor*, void*, void*);
+        void accept_as_destination(DispersionVisitor*, void*, void*);
+};
+
+/**
+ * LogNormal dispersion model
+ */
+class LogNormalDispersion: public DispersionModel {
+public:
+        /// Number of sigmas on each side of the mean
+        int nsigmas;
+
+        LogNormalDispersion();
+        void operator()(void *, vector<WeightPoint>&);
+        void accept_as_source(DispersionVisitor*, void*, void*);
+        void accept_as_destination(DispersionVisitor*, void*, void*);
+};
+
+
+/**
  * Dispersion model based on arrays provided by the user
  */