Index: sansmodels/src/sans/models/c_models/c_models.cpp
===================================================================
--- sansmodels/src/sans/models/c_models/c_models.cpp	(revision 812b901e8b8451f555bc0649e5ee190827ff9130)
+++ sansmodels/src/sans/models/c_models/c_models.cpp	(revision eba988511d86410985b5a1c35ce70dd3968132a8)
@@ -48,4 +48,6 @@
 	void addCGaussian(PyObject *module);
 	void addCLorentzian(PyObject *module);
+	void addCLogNormal(PyObject *module);
+	void addCSchulz(PyObject *module);
 }
 
@@ -69,4 +71,21 @@
 
 /**
+ * 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,4 +103,21 @@
 	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,4 +183,8 @@
 	{"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,7 +234,8 @@
 	addDisperser(m);
 	addCGaussian(m);
+	addCSchulz(m);
+	addCLogNormal(m);
 	addCLorentzian(m);
 	addCVesicleModel(m);
 
-
-}
+}
Index: sansmodels/src/sans/models/c_models/dispersion_visitor.cpp
===================================================================
--- sansmodels/src/sans/models/c_models/dispersion_visitor.cpp	(revision fca6936ab3704433fa2327bcd55367e8ea28de72)
+++ sansmodels/src/sans/models/c_models/dispersion_visitor.cpp	(revision eba988511d86410985b5a1c35ce70dd3968132a8)
@@ -25,4 +25,29 @@
 
 	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,3 +86,24 @@
 }
 
+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) {}
Index: sansmodels/src/sans/models/c_models/dispersion_visitor.hh
===================================================================
--- sansmodels/src/sans/models/c_models/dispersion_visitor.hh	(revision fca6936ab3704433fa2327bcd55367e8ea28de72)
+++ sansmodels/src/sans/models/c_models/dispersion_visitor.hh	(revision eba988511d86410985b5a1c35ce70dd3968132a8)
@@ -19,8 +19,12 @@
 	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 *);
 
Index: sansmodels/src/sans/models/c_models/parameters.cpp
===================================================================
--- sansmodels/src/sans/models/c_models/parameters.cpp	(revision 07da7493b3fac0bc4aa288a1fd12e1d6d4d6b215)
+++ sansmodels/src/sans/models/c_models/parameters.cpp	(revision eba988511d86410985b5a1c35ce70dd3968132a8)
@@ -136,4 +136,127 @@
 	}
 }
+
+
+/**
+ * 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));
+			}
+		}
+	}
+}
+
+
+
 
 /**
Index: sansmodels/src/sans/models/c_models/parameters.hh
===================================================================
--- sansmodels/src/sans/models/c_models/parameters.hh	(revision fca6936ab3704433fa2327bcd55367e8ea28de72)
+++ sansmodels/src/sans/models/c_models/parameters.hh	(revision eba988511d86410985b5a1c35ce70dd3968132a8)
@@ -77,4 +77,33 @@
 
 /**
+ * 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
  */
