source: sasview/sansmodels/src/sans/models/c_models/parameters.cpp @ fcd8a80e

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since fcd8a80e was fcd8a80e, checked in by Jae Cho <jhjcho@…>, 16 years ago

comment on nsigmas is changed.

  • Property mode set to 100644
File size: 5.5 KB
Line 
1/**
2        This software was developed by the University of Tennessee as part of the
3        Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
4        project funded by the US National Science Foundation.
5
6        If you use DANSE applications to do scientific research that leads to
7        publication, we ask that you acknowledge the use of the software with the
8        following sentence:
9
10        "This work benefited from DANSE software developed under NSF award DMR-0520547."
11
12        copyright 2008, University of Tennessee
13 */
14#include "parameters.hh"
15#include <stdio.h>
16#include <math.h>
17using namespace std;
18
19/**
20 * TODO: normalize all dispersion weight lists
21 */
22
23
24/**
25 * Weight points
26 */
27WeightPoint :: WeightPoint() {
28        value = 0.0;
29        weight = 0.0;
30}
31
32WeightPoint :: WeightPoint(double v, double w) {
33        value = v;
34        weight = w;
35}
36
37/**
38 * Dispersion models
39 */
40DispersionModel :: DispersionModel() {
41        npts  = 1;
42        width = 0.0;
43};
44
45void DispersionModel :: accept_as_source(DispersionVisitor* visitor, void* from, void* to) {
46        visitor->dispersion_to_dict(from, to);
47}
48void DispersionModel :: accept_as_destination(DispersionVisitor* visitor, void* from, void* to) {
49        visitor->dispersion_from_dict(from, to);
50}
51void DispersionModel :: operator() (void *param, vector<WeightPoint> &weights){
52        // Check against zero width
53        if (width<=0) {
54                width = 0.0;
55                npts  = 1;
56        }
57
58        Parameter* par = (Parameter*)param;
59        double value = (*par)();
60
61        if (npts<2) {
62                weights.insert(weights.end(), WeightPoint(value, 1.0));
63        } else {
64                for(int i=0; i<npts; i++) {
65                        double val = value + width * (1.0*i/float(npts-1) - 0.5);
66
67                        if ( ((*par).has_min==false || val>(*par).min)
68                          && ((*par).has_max==false || val<(*par).max)  )
69                                weights.insert(weights.end(), WeightPoint(val, 1.0));
70                }
71        }
72}
73
74/**
75 * Method to set the weights
76 * Not implemented for this class
77 */
78void DispersionModel :: set_weights(int npoints, double* values, double* weights){}
79
80/**
81 * Gaussian dispersion
82 */
83
84GaussianDispersion :: GaussianDispersion() {
85        npts  = 1;
86        width = 0.0;
87        nsigmas = 2;
88};
89
90void GaussianDispersion :: accept_as_source(DispersionVisitor* visitor, void* from, void* to) {
91        visitor->gaussian_to_dict(from, to);
92}
93void GaussianDispersion :: accept_as_destination(DispersionVisitor* visitor, void* from, void* to) {
94        visitor->gaussian_from_dict(from, to);
95}
96
97double gaussian_weight(double mean, double sigma, double x) {
98        double vary, expo_value;
99    vary = x-mean;
100    expo_value = -vary*vary/(2*sigma*sigma);
101    //return 1.0;
102    return exp(expo_value);
103}
104
105/**
106 * Gaussian dispersion
107 * @param mean: mean value of the Gaussian
108 * @param sigma: standard deviation of the Gaussian
109 * @param x: value at which the Gaussian is evaluated
110 * @return: value of the Gaussian
111 */
112void GaussianDispersion :: operator() (void *param, vector<WeightPoint> &weights){
113        // Check against zero width
114        if (width<=0) {
115                width = 0.0;
116                npts  = 1;
117                nsigmas = 3;
118        }
119
120        Parameter* par = (Parameter*)param;
121        double value = (*par)();
122
123        if (npts<2) {
124                weights.insert(weights.end(), WeightPoint(value, 1.0));
125        } else {
126                for(int i=0; i<npts; i++) {
127                        // We cover n(nsigmas) times sigmas on each side of the mean
128                        double val = value + width * (2.0*nsigmas*i/float(npts-1) - nsigmas);
129
130                        if ( ((*par).has_min==false || val>(*par).min)
131                          && ((*par).has_max==false || val<(*par).max)  ) {
132                                double _w = gaussian_weight(value, width, val);
133                                weights.insert(weights.end(), WeightPoint(val, _w));
134                        }
135                }
136        }
137}
138
139/**
140 * Array dispersion based on input arrays
141 */
142
143void ArrayDispersion :: accept_as_source(DispersionVisitor* visitor, void* from, void* to) {
144        visitor->array_to_dict(from, to);
145}
146void ArrayDispersion :: accept_as_destination(DispersionVisitor* visitor, void* from, void* to) {
147        visitor->array_from_dict(from, to);
148}
149
150/**
151 * Method to get the weights
152 */
153void ArrayDispersion :: operator() (void *param, vector<WeightPoint> &weights) {
154        Parameter* par = (Parameter*)param;
155        double value = (*par)();
156
157        if (npts<2) {
158                weights.insert(weights.end(), WeightPoint(value, 1.0));
159        } else {
160                for(int i=0; i<npts; i++) {
161                        if ( ((*par).has_min==false || _values[i]>(*par).min)
162                          && ((*par).has_max==false || _values[i]<(*par).max)  )
163                                weights.insert(weights.end(), WeightPoint(_values[i], _weights[i]));
164                }
165        }
166}
167
168
169/**
170 * Method to set the weights
171 */
172void ArrayDispersion :: set_weights(int npoints, double* values, double* weights){
173        npts = npoints;
174        _values = values;
175        _weights = weights;
176}
177
178
179/**
180 * Parameters
181 */
182Parameter :: Parameter() {
183        value = 0;
184        min   = 0.0;
185        max   = 0.0;
186        has_min = false;
187        has_max = false;
188        has_dispersion = false;
189        dispersion = new GaussianDispersion();
190}
191
192Parameter :: Parameter(double _value) {
193        value = _value;
194        min   = 0.0;
195        max   = 0.0;
196        has_min = false;
197        has_max = false;
198        has_dispersion = false;
199        dispersion = new GaussianDispersion();
200}
201
202Parameter :: Parameter(double _value, bool disp) {
203        value = _value;
204        min   = 0.0;
205        max   = 0.0;
206        has_min = false;
207        has_max = false;
208        has_dispersion = disp;
209        dispersion = new GaussianDispersion();
210}
211
212void Parameter :: get_weights(vector<WeightPoint> &weights) {
213        (*dispersion)((void*)this, weights);
214}
215
216void Parameter :: set_min(double value) {
217        has_min = true;
218        min = value;
219}
220
221void Parameter :: set_max(double value) {
222        has_max = true;
223        max = value;
224}
225
226double Parameter :: operator()() {
227        return value;
228}
229
230double Parameter :: operator=(double _value){
231        value = _value;
232}
Note: See TracBrowser for help on using the repository browser.