ROOT  6.06/08
Reference Guide
TSpectrum3.cxx
Go to the documentation of this file.
1 // @(#)root/spectrum:$Id$
2 // Author: Miroslav Morhac 25/09/2006
3 
4 /////////////////////////////////////////////////////////////////////////////
5 // THIS CLASS CONTAINS ADVANCED SPECTRA PROCESSING FUNCTIONS. //
6 // //
7 // THREE-DIMENSIONAL BACKGROUND ESTIMATION FUNCTIONS //
8 // THREE-DIMENSIONAL SMOOTHING FUNCTIONS //
9 // THREE-DIMENSIONAL DECONVOLUTION FUNCTIONS //
10 // THREE-DIMENSIONAL PEAK SEARCH FUNCTIONS //
11 // //
12 // These functions were written by: //
13 // Miroslav Morhac //
14 // Institute of Physics //
15 // Slovak Academy of Sciences //
16 // Dubravska cesta 9, 842 28 BRATISLAVA //
17 // SLOVAKIA //
18 // //
19 // email:fyzimiro@savba.sk, fax:+421 7 54772479 //
20 // //
21 // The original code in C has been repackaged as a C++ class by R.Brun //
22 // //
23 // The algorithms in this class have been published in the following //
24 // references: //
25 // [1] M.Morhac et al.: Background elimination methods for //
26 // multidimensional coincidence gamma-ray spectra. Nuclear //
27 // Instruments and Methods in Physics Research A 401 (1997) 113- //
28 // 132. //
29 // //
30 // [2] M.Morhac et al.: Efficient one- and two-dimensional Gold //
31 // deconvolution and its application to gamma-ray spectra //
32 // decomposition. Nuclear Instruments and Methods in Physics //
33 // Research A 401 (1997) 385-408. //
34 // //
35 // [3] M. Morhac et al.: Efficient algorithm of multidimensional //
36 // deconvolution and its application to nuclear data processing. Digital //
37 // Signal Processing, Vol. 13, No. 1, (2003), 144-171. //
38 // //
39 // [4] M.Morhac et al.: Identification of peaks in multidimensional //
40 // coincidence gamma-ray spectra. Nuclear Instruments and Methods in //
41 // Research Physics A 443(2000), 108-125. //
42 // //
43 // These NIM papers are also available as Postscript files from: //
44 //
45 //
46 // ftp://root.cern.ch/root/SpectrumDec.ps.gz
47 // ftp://root.cern.ch/root/SpectrumSrc.ps.gz
48 // ftp://root.cern.ch/root/SpectrumBck.ps.gz
49 //
50 //
51 /////////////////////////////////////////////////////////////////////////////
52 
53 /** \class TSpectrum3
54  \ingroup Hist
55  \brief Advanced 3-dimentional spectra processing functions
56  \author Miroslav Morhac
57 
58 */
59 
60 #include "TSpectrum3.h"
61 #include "TH1.h"
62 #include "TMath.h"
63 #define PEAK_WINDOW 1024
64 
66 
67 ////////////////////////////////////////////////////////////////////////////////
68 /// Constructor.
69 
70 TSpectrum3::TSpectrum3() :TNamed("Spectrum", "Miroslav Morhac peak finder")
71 {
72  Int_t n = 100;
73  fMaxPeaks = n;
74  fPosition = new Double_t[n];
75  fPositionX = new Double_t[n];
76  fPositionY = new Double_t[n];
77  fPositionZ = new Double_t[n];
78  fResolution = 1;
79  fHistogram = 0;
80  fNPeaks = 0;
81 }
82 
83 
84 ////////////////////////////////////////////////////////////////////////////////
85 /// maxpositions: maximum number of peaks
86 /// resolution: determines resolution of the neighboring peaks
87 /// default value is 1 correspond to 3 sigma distance
88 /// between peaks. Higher values allow higher resolution
89 /// (smaller distance between peaks.
90 /// May be set later through SetResolution.
91 
92 TSpectrum3::TSpectrum3(Int_t maxpositions, Double_t resolution) :TNamed("Spectrum", "Miroslav Morhac peak finder")
93 {
94  Int_t n = TMath::Max(maxpositions, 100);
95  fMaxPeaks = n;
96  fPosition = new Double_t[n];
97  fPositionX = new Double_t[n];
98  fPositionY = new Double_t[n];
99  fPositionZ = new Double_t[n];
100  fHistogram = 0;
101  fNPeaks = 0;
102  SetResolution(resolution);
103 }
104 
105 
106 ////////////////////////////////////////////////////////////////////////////////
107 /// Destructor.
108 
110 {
111  delete [] fPosition;
112  delete [] fPositionX;
113  delete [] fPositionY;
114  delete [] fPositionZ;
115  delete fHistogram;
116 }
117 
118 ////////////////////////////////////////////////////////////////////////////////
119 //////////////////////////////////////////////////////////////////////////////
120 /// ONE-DIMENSIONAL BACKGROUND ESTIMATION FUNCTION //
121 /// This function calculates background spectrum from source in h. //
122 /// The result is placed in the vector pointed by spectrum pointer. //
123 /// //
124 /// Function parameters: //
125 /// spectrum: pointer to the vector of source spectrum //
126 /// size: length of spectrum and working space vectors //
127 /// number_of_iterations, for details we refer to manual //
128 /// //
129 //////////////////////////////////////////////////////////////////////////////
130 
131 const char *TSpectrum3::Background(const TH1 * h, Int_t number_of_iterations,
132  Option_t * option)
133 {
134  Error("Background","function not yet implemented: h=%s, iter=%d, option=%sn"
135  , h->GetName(), number_of_iterations, option);
136  return 0;
137 }
138 
139 ////////////////////////////////////////////////////////////////////////////////
140 /// Print the array of positions
141 
143 {
144  printf("\nNumber of positions = %d\n",fNPeaks);
145  for (Int_t i=0;i<fNPeaks;i++) {
146  printf(" x[%d] = %g, y[%d] = %g, z[%d] = %g\n",i,fPositionX[i],i,fPositionY[i],i,fPositionZ[i]);
147  }
148 }
149 
150 
151 
152 ////////////////////////////////////////////////////////////////////////////////
153 //////////////////////////////////////////////////////////////////////////////
154 /// ONE-DIMENSIONAL PEAK SEARCH FUNCTION //
155 /// This function searches for peaks in source spectrum in hin //
156 /// The number of found peaks and their positions are written into //
157 /// the members fNpeaks and fPositionX. //
158 /// //
159 /// Function parameters: //
160 /// hin: pointer to the histogram of source spectrum //
161 /// sigma: sigma of searched peaks, for details we refer to manual //
162 /// Note that sigma is in number of bins //
163 /// threshold: (default=0.05) peaks with amplitude less than //
164 /// threshold*highest_peak are discarded. //
165 /// //
166 /// if option is not equal to "goff" (goff is the default), then //
167 /// a polymarker object is created and added to the list of functions of //
168 /// the histogram. The histogram is drawn with the specified option and //
169 /// the polymarker object drawn on top of the histogram. //
170 /// The polymarker coordinates correspond to the npeaks peaks found in //
171 /// the histogram. //
172 /// A pointer to the polymarker object can be retrieved later via: //
173 /// TList *functions = hin->GetListOfFunctions(); //
174 /// TPolyMarker *pm = (TPolyMarker*)functions->FindObject("TPolyMarker") //
175 /// //
176 //////////////////////////////////////////////////////////////////////////////
177 
179  Option_t * option, Double_t threshold)
180 {
181  if (hin == 0)
182  return 0;
183  Int_t dimension = hin->GetDimension();
184  if (dimension != 3) {
185  Error("Search", "Must be a 3-d histogram");
186  return 0;
187  }
188 
189  Int_t sizex = hin->GetXaxis()->GetNbins();
190  Int_t sizey = hin->GetYaxis()->GetNbins();
191  Int_t sizez = hin->GetZaxis()->GetNbins();
192  Int_t i, j, k, binx,biny,binz, npeaks;
193  Double_t*** source = new Double_t**[sizex];
194  Double_t*** dest = new Double_t**[sizex];
195  for (i = 0; i < sizex; i++) {
196  source[i] = new Double_t*[sizey];
197  dest[i] = new Double_t*[sizey];
198  for (j = 0; j < sizey; j++) {
199  source[i][j] = new Double_t[sizez];
200  dest[i][j] = new Double_t[sizez];
201  for (k = 0; k < sizez; k++)
202  source[i][j][k] = (Double_t) hin->GetBinContent(i + 1, j + 1, k + 1);
203  }
204  }
205  //the smoothing option is used for 1-d but not for 2-d histograms
206  npeaks = SearchHighRes((const Double_t***)source, dest, sizex, sizey, sizez, sigma, 100*threshold, kTRUE, 3, kFALSE, 3);
207 
208  //The logic in the loop should be improved to use the fact
209  //that fPositionX,Y give a precise position inside a bin.
210  //The current algorithm takes the center of the bin only.
211  for (i = 0; i < npeaks; i++) {
212  binx = 1 + Int_t(fPositionX[i] + 0.5);
213  biny = 1 + Int_t(fPositionY[i] + 0.5);
214  binz = 1 + Int_t(fPositionZ[i] + 0.5);
215  fPositionX[i] = hin->GetXaxis()->GetBinCenter(binx);
216  fPositionY[i] = hin->GetYaxis()->GetBinCenter(biny);
217  fPositionZ[i] = hin->GetZaxis()->GetBinCenter(binz);
218  }
219  for (i = 0; i < sizex; i++) {
220  for (j = 0; j < sizey; j++){
221  delete [] source[i][j];
222  delete [] dest[i][j];
223  }
224  delete [] source[i];
225  delete [] dest[i];
226  }
227  delete [] source;
228  delete [] dest;
229 
230  if (strstr(option, "goff"))
231  return npeaks;
232  if (!npeaks) return 0;
233  return npeaks;
234 }
235 
236 
237 ////////////////////////////////////////////////////////////////////////////////
238 /// resolution: determines resolution of the neighboring peaks
239 /// default value is 1 correspond to 3 sigma distance
240 /// between peaks. Higher values allow higher resolution
241 /// (smaller distance between peaks.
242 /// May be set later through SetResolution.
243 
245 {
246  if (resolution > 1)
247  fResolution = resolution;
248  else
249  fResolution = 1;
250 }
251 
252 ////////////////////////////////////////////////////////////////////////////////
253 ////////////////////////////////////////////////////////////////////////////////
254 /// THREE-DIMENSIONAL BACKGROUND ESTIMATION FUNCTIONS //
255 /// This function calculates background spectrum from source spectrum. //
256 /// The result is placed to the array pointed by spectrum pointer. //
257 /// //
258 /// Function parameters: //
259 /// spectrum-pointer to the array of source spectrum //
260 /// ssizex-x length of spectrum //
261 /// ssizey-y length of spectrum //
262 /// ssizez-z length of spectrum //
263 /// numberIterationsX-maximal x width of clipping window //
264 /// numberIterationsY-maximal y width of clipping window //
265 /// numberIterationsZ-maximal z width of clipping window //
266 /// for details we refer to manual //
267 /// direction- direction of change of clipping window //
268 /// - possible values=kBackIncreasingWindow //
269 /// kBackDecreasingWindow //
270 /// filterType-determines the algorithm of the filtering //
271 /// -possible values=kBackSuccessiveFiltering //
272 /// kBackOneStepFiltering //
273 /// //
274 /// //
275 ////////////////////////////////////////////////////////////////////////////////
276 
277 const char *TSpectrum3::Background(Double_t***spectrum,
278  Int_t ssizex, Int_t ssizey, Int_t ssizez,
279  Int_t numberIterationsX,
280  Int_t numberIterationsY,
281  Int_t numberIterationsZ,
282  Int_t direction,
283  Int_t filterType)
284 {
285 /*
286 <div class=Section1>
287 
288 <p class=MsoNormal style='text-align:justify'><b><span style='font-size:14.0pt'>Background
289 estimation</span></b></p>
290 
291 <p class=MsoNormal style='text-align:justify'><i>&nbsp;</i></p>
292 
293 <p class=MsoNormal style='text-align:justify'><i>Goal: Separation of useful
294 information (peaks) from useless information (background)</i> </p>
295 
296 <p class=MsoNormal style='margin-left:36.0pt;text-align:justify;text-indent:
297 -18.0pt'>•<span style='font:7.0pt "Times New Roman"'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
298 </span>method is based on Sensitive Nonlinear Iterative Peak (SNIP) clipping
299 algorithm [1]</p>
300 
301 <p class=MsoNormal style='margin-left:36.0pt;text-align:justify;text-indent:
302 -18.0pt'>•<span style='font:7.0pt "Times New Roman"'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
303 </span>there exist two algorithms for the estimation of new value in the
304 channel “<sub><img width=43 height=24 src="gif/spectrum3_background_image001.gif"></sub>”</p>
305 
306 <p class=MsoNormal style='margin-left:18.0pt;text-align:justify'>&nbsp;</p>
307 
308 <p class=MsoNormal style='text-align:justify'><i>Algorithm based on Successive
309 Comparisons</i></p>
310 
311 <p class=MsoNormal style='text-align:justify'>It is an extension of
312 one-dimensional SNIP algorithm to another dimension. For details we refer to
313 [2].</p>
314 
315 <p class=MsoNormal style='text-align:justify'>&nbsp;</p>
316 
317 <p class=MsoNormal style='text-align:justify'><i>Algorithm based on One Step
318 Filtering</i></p>
319 
320 <p class=MsoNormal style='text-align:justify'>The algorithm is analogous to
321 that for 2-dimensional data. For details we refer to TSpectrum2. New value in
322 the estimated channel is calculated as</p>
323 
324 <p class=MsoNormal style='text-align:justify'>&nbsp;</p>
325 
326 <p class=MsoNormal style='text-align:justify'><sub><img width=103 height=26
327 src="gif/spectrum3_background_image002.gif"></sub></p>
328 
329 <p class=MsoNormal style='text-align:justify'><sub><img width=621 height=408
330 src="gif/spectrum3_background_image003.gif"></sub><sub><img width=148 height=27
331 src="gif/spectrum3_background_image004.gif"></sub></p>
332 
333 <p class=MsoNormal>&nbsp;</p>
334 
335 <p class=MsoNormal style='text-align:justify'>where p = 1, 2, …,
336 number_of_iterations. </p>
337 
338 <p class=MsoNormal><i>&nbsp;</i></p>
339 
340 <p class=MsoNormal><i>Function:</i></p>
341 
342 <p class=MsoNormal style='text-align:justify'><b>const <a
343 href="http://root.cern.ch/root/html/ListOfTypes.html#char" target="_parent">char</a>*
344 </b><a href="http://root.cern.ch/root/html/TSpectrum.html#TSpectrum:Fit1Awmi"><b>TSpectrum3::Background</b></a><b>
345 (<a href="http://root.cern.ch/root/html/ListOfTypes.html#double" target="_parent">double</a>
346 ***fSpectrum, <a href="http://root.cern.ch/root/html/ListOfTypes.html#int"
347 target="_parent">int</a> fSizex, <a
348 href="http://root.cern.ch/root/html/ListOfTypes.html#int" target="_parent">int</a>
349 fSizey, int fSizez, <a href="http://root.cern.ch/root/html/ListOfTypes.html#int"
350 target="_parent">int</a> fNumberIterationsX, <a
351 href="http://root.cern.ch/root/html/ListOfTypes.html#int" target="_parent">int</a>
352 fNumberIterationsY, <a href="http://root.cern.ch/root/html/ListOfTypes.html#int"
353 target="_parent">int</a> fNumberIterationsZ,  <a
354 href="http://root.cern.ch/root/html/ListOfTypes.html#int" target="_parent">int</a>
355 fDirection, <a href="http://root.cern.ch/root/html/ListOfTypes.html#int"
356 target="_parent">int</a> fFilterType)  </b></p>
357 
358 <p class=MsoNormal>&nbsp;</p>
359 
360 <p class=MsoNormal style='text-align:justify'>This function calculates
361 background spectrum from the source spectrum.  The result is placed in the matrix
362 pointed by fSpectrum pointer.  One can also switch the direction of the change
363 of the clipping window and to select one of the two above given algorithms. On
364 successful completion it returns 0. On error it returns pointer to the string
365 describing error.</p>
366 
367 <p class=MsoNormal>&nbsp;</p>
368 
369 <p class=MsoNormal><i><span style='color:red'>Parameters:</span></i></p>
370 
371 <p class=MsoNormal>        <b>fSpectrum</b>-pointer to the matrix of source
372 spectrum                  </p>
373 
374 <p class=MsoNormal>        <b>fSizex, fSizey, fSizez </b>-lengths of the
375 spectrum matrix                                 </p>
376 
377 <p class=MsoNormal style='text-align:justify'>        <b>fNumberIterationsX,
378 fNumberIterationsY, fNumberIterationsZ </b>maximal</p>
379 
380 <p class=MsoNormal style='text-align:justify'>        widths of clipping window,                                
381 </p>
382 
383 <p class=MsoNormal>        <b>fDirection</b>- direction of change of clipping
384 window                  </p>
385 
386 <p class=MsoNormal>               - possible
387 values=kBackIncreasingWindow                      </p>
388 
389 <p class=MsoNormal>                                           
390 kBackDecreasingWindow                      </p>
391 
392 <p class=MsoNormal>        <b>fFilterType</b>-type of the clipping algorithm,          
393                    </p>
394 
395 <p class=MsoNormal>                  -possible values=kBack SuccessiveFiltering</p>
396 
397 <p class=MsoNormal>                                             
398 kBackOneStepFiltering                              </p>
399 
400 <p class=MsoNormal>&nbsp;</p>
401 
402 <p class=MsoNormal><b><i>References:</i></b></p>
403 
404 <p class=MsoNormal style='text-align:justify'>[1]  C. G Ryan et al.: SNIP, a
405 statistics-sensitive background treatment for the quantitative analysis of PIXE
406 spectra in geoscience applications. NIM, B34 (1988), 396-402.</p>
407 
408 <p class=MsoNormal style='text-align:justify'>[2] <span lang=SK> M.
409 Morhá&#269;, J. Kliman, V. Matoušek, M. Veselský, I. Turzo</span>.: Background
410 elimination methods for multidimensional gamma-ray spectra. NIM, A401 (1997)
411 113-132.</p>
412 
413 <p class=MsoNormal style='text-align:justify'><span style='font-size:16.0pt'>&nbsp;</span></p>
414 
415 <p class=MsoNormal><i>Example 1– script Back3.c :</i></p>
416 
417 <p class=MsoNormal><i><span style='font-size:18.0pt'><img border=0 width=601
418 height=368 src="gif/spectrum3_background_image005.jpg"></span></i></p>
419 
420 <p class=MsoNormal>&nbsp;</p>
421 
422 <p class=MsoNormal style='text-align:justify'><b>Fig. 1 Original three-dimensional
423 gamma-gamma-gamma-ray spectrum</b></p>
424 
425 <p class=MsoNormal style='text-align:justify'><b><span style='font-size:16.0pt'><img
426 border=0 width=601 height=368 src="gif/spectrum3_background_image006.jpg"></span></b></p>
427 
428 <p class=MsoNormal style='text-align:justify'><b>Fig. 2 Background estimated
429 from data from Fig. 1 using decreasing clipping window with widths 5, 5, 5 and
430 algorithm based on successive comparisons. The estimate includes not only
431 continuously changing background but also one- and two-dimensional ridges.</b></p>
432 
433 <p class=MsoNormal><b><span style='font-size:14.0pt;color:green'>&nbsp;</span></b></p>
434 
435 <p class=MsoNormal><b><span style='font-size:14.0pt;color:green'><img border=0
436 width=601 height=368 src="gif/spectrum3_background_image007.jpg"></span></b></p>
437 
438 <p class=MsoNormal style='text-align:justify'><b>Fig. 3 Resulting peaks after
439 subtraction of the estimated background (Fig. 2) from original three-dimensional
440 gamma-gamma-gamma-ray spectrum (Fig. 1).</b></p>
441 
442 <p class=MsoNormal><b><span style='color:green'>&nbsp;</span></b></p>
443 
444 <p class=MsoNormal><b><span style='color:green'>&nbsp;</span></b></p>
445 
446 <p class=MsoNormal><b><span style='color:green'>Script:</span></b></p>
447 
448 <p class=MsoNormal><span style='font-size:10.0pt'>// Example to illustrate the
449 background estimator (class TSpectrum3).</span></p>
450 
451 <p class=MsoNormal><span style='font-size:10.0pt'>// To execute this example,
452 do</span></p>
453 
454 <p class=MsoNormal><span style='font-size:10.0pt'>// root &gt; .x Back3.C</span></p>
455 
456 <p class=MsoNormal><span style='font-size:10.0pt'>&nbsp;</span></p>
457 
458 <p class=MsoNormal><span style='font-size:10.0pt'>void Back3() {</span></p>
459 
460 <p class=MsoNormal><span style='font-size:10.0pt'>   Int_t i, j, k;</span></p>
461 
462 <p class=MsoNormal><span style='font-size:10.0pt'>   </span><span lang=FR
463 style='font-size:10.0pt'>Int_t nbinsx = 64;</span></p>
464 
465 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t nbinsy = 64;</span></p>
466 
467 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t nbinsz =
468 64;   </span></p>
469 
470 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t xmin  = 0;</span></p>
471 
472 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t xmax  =
473 nbinsx;</span></p>
474 
475 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t ymin  = 0;</span></p>
476 
477 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t ymax  =
478 nbinsy;   </span></p>
479 
480 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t zmin  = 0;</span></p>
481 
482 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   </span><span
483 style='font-size:10.0pt'>Int_t zmax  = nbinsz;      </span></p>
484 
485 <p class=MsoNormal><span style='font-size:10.0pt'>   Double_t*** source = new
486 Double_t**[nbinsx];</span></p>
487 
488 <p class=MsoNormal><span style='font-size:10.0pt'>   Double_t*** dest = new Double_t
489 **[nbinsx];      </span></p>
490 
491 <p class=MsoNormal><span style='font-size:10.0pt'>   for(i=0;i&lt;nbinsx;i++){</span></p>
492 
493 <p class=MsoNormal><span style='font-size:10.0pt'>      source[i]=new Double_t*
494 [nbinsy];</span></p>
495 
496 <p class=MsoNormal><span style='font-size:10.0pt'>     
497 for(j=0;j&lt;nbinsy;j++)</span></p>
498 
499 <p class=MsoNormal><span style='font-size:10.0pt'>         source[i][j]=new
500 Double_t[nbinsz];</span></p>
501 
502 <p class=MsoNormal><span style='font-size:10.0pt'>   }           </span></p>
503 
504 <p class=MsoNormal><span style='font-size:10.0pt'>   for(i=0;i&lt;nbinsx;i++){</span></p>
505 
506 <p class=MsoNormal><span style='font-size:10.0pt'>      dest[i]=new Double_t*
507 [nbinsy];</span></p>
508 
509 <p class=MsoNormal><span style='font-size:10.0pt'>     
510 for(j=0;j&lt;nbinsy;j++)</span></p>
511 
512 <p class=MsoNormal><span style='font-size:10.0pt'>         dest[i][j]=new Double_t
513 [nbinsz];</span></p>
514 
515 <p class=MsoNormal><span style='font-size:10.0pt'>   }              </span></p>
516 
517 <p class=MsoNormal><span style='font-size:10.0pt'>   TH3F *back = new
518 TH3F(&quot;back&quot;,&quot;Background
519 estimation&quot;,nbinsx,xmin,xmax,nbinsy,ymin,ymax,nbinsz,zmin,zmax);</span></p>
520 
521 <p class=MsoNormal><span style='font-size:10.0pt'>   TFile *f = new
522 TFile(&quot;TSpectrum3.root&quot;);</span></p>
523 
524 <p class=MsoNormal><span style='font-size:10.0pt'>   back=(TH3F*)
525 f-&gt;Get(&quot;back;1&quot;);</span></p>
526 
527 <p class=MsoNormal><span style='font-size:10.0pt'>   TCanvas *Background = new
528 TCanvas(&quot;Background&quot;,&quot;Estimation of background with decreasing
529 window&quot;,10,10,1000,700);</span></p>
530 
531 <p class=MsoNormal><span style='font-size:10.0pt'>   TSpectrum3 *s = new
532 TSpectrum3();</span></p>
533 
534 <p class=MsoNormal><span style='font-size:10.0pt'>   for (i = 0; i &lt; nbinsx;
535 i++){</span></p>
536 
537 <p class=MsoNormal><span style='font-size:10.0pt'>     for (j = 0; j &lt;
538 nbinsy; j++){</span></p>
539 
540 <p class=MsoNormal><span style='font-size:10.0pt'>                  for (k = 0;
541 k &lt; nbinsz; k++){</span></p>
542 
543 <p class=MsoNormal><span style='font-size:10.0pt'>                       source[i][j][k]
544 = back-&gt;GetBinContent(i + 1,j + 1,k + 1);</span></p>
545 
546 <p class=MsoNormal><span style='font-size:10.0pt'>                       dest[i][j][k]
547 = back-&gt;GetBinContent(i + 1,j + 1,k + 1);                     </span></p>
548 
549 <p class=MsoNormal><span style='font-size:10.0pt'>                    } </span></p>
550 
551 <p class=MsoNormal><span style='font-size:10.0pt'>                 }</span></p>
552 
553 <p class=MsoNormal><span style='font-size:10.0pt'>   }</span></p>
554 
555 <p class=MsoNormal><span style='font-size:10.0pt'>  
556 s-&gt;Background(dest,nbinsx,nbinsy,nbinsz,5,5,5,s-&gt;kBackDecreasingWindow,s-&gt;kBackSuccessiveFiltering);</span></p>
557 
558 <p class=MsoNormal><span style='font-size:10.0pt'>   for (i = 0; i &lt; nbinsx;
559 i++){</span></p>
560 
561 <p class=MsoNormal><span style='font-size:10.0pt'>     for (j = 0; j &lt;
562 nbinsy; j++){</span></p>
563 
564 <p class=MsoNormal><span style='font-size:10.0pt'>        for (k = 0; k &lt;
565 nbinsz; k++){</span></p>
566 
567 <p class=MsoNormal><span style='font-size:10.0pt'>          
568 back-&gt;SetBinContent(i + 1,j + 1,k + 1, dest[i][j][k]);</span></p>
569 
570 <p class=MsoNormal><span style='font-size:10.0pt'>        }    </span></p>
571 
572 <p class=MsoNormal><span style='font-size:10.0pt'>     }</span></p>
573 
574 <p class=MsoNormal><span style='font-size:10.0pt'>   }</span></p>
575 
576 <p class=MsoNormal><span style='font-size:10.0pt'>&nbsp;</span></p>
577 
578 <p class=MsoNormal><span style='font-size:10.0pt'>   FILE *out;</span></p>
579 
580 <p class=MsoNormal><span style='font-size:10.0pt'>   char PATH[80];   </span></p>
581 
582 <p class=MsoNormal><span style='font-size:10.0pt'>  
583 strcpy(PATH,&quot;spectra3\\back_output_5ds.spe&quot;);   </span></p>
584 
585 <p class=MsoNormal><span style='font-size:10.0pt'>   out=fopen(PATH,&quot;wb&quot;);</span></p>
586 
587 <p class=MsoNormal><span style='font-size:10.0pt'>   for(i=0;i&lt;nbinsx;i++){</span></p>
588 
589 <p class=MsoNormal><span style='font-size:10.0pt'>     
590 for(j=0;j&lt;nbinsy;j++){                   </span></p>
591 
592 <p class=MsoNormal><span style='font-size:10.0pt'>         fwrite(dest[i][j],
593 sizeof(dest[0][0][0]),nbinsz,out);</span></p>
594 
595 <p class=MsoNormal><span style='font-size:10.0pt'>      }</span></p>
596 
597 <p class=MsoNormal><span style='font-size:10.0pt'>   }   </span></p>
598 
599 <p class=MsoNormal><span style='font-size:10.0pt'>   fclose(out);   </span></p>
600 
601 <p class=MsoNormal><span style='font-size:10.0pt'>   </span></p>
602 
603 <p class=MsoNormal><span style='font-size:10.0pt'>   for (i = 0; i &lt; nbinsx;
604 i++){</span></p>
605 
606 <p class=MsoNormal><span style='font-size:10.0pt'>     for (j = 0; j &lt;
607 nbinsy; j++){</span></p>
608 
609 <p class=MsoNormal><span style='font-size:10.0pt'>        for (k = 0; k &lt;
610 nbinsz; k++){</span></p>
611 
612 <p class=MsoNormal><span style='font-size:10.0pt'>           source[i][j][k] =
613 source[i][j][k] - dest[i][j][k];</span></p>
614 
615 <p class=MsoNormal><span style='font-size:10.0pt'>        }    </span></p>
616 
617 <p class=MsoNormal><span style='font-size:10.0pt'>     }</span></p>
618 
619 <p class=MsoNormal><span style='font-size:10.0pt'>   }</span></p>
620 
621 <p class=MsoNormal><span style='font-size:10.0pt'>   </span></p>
622 
623 <p class=MsoNormal><span style='font-size:10.0pt'>   for (i = 0; i &lt; nbinsx;
624 i++){</span></p>
625 
626 <p class=MsoNormal><span style='font-size:10.0pt'>     for (j = 0; j &lt;
627 nbinsy; j++){</span></p>
628 
629 <p class=MsoNormal><span style='font-size:10.0pt'>        for (k = 0; k &lt;
630 nbinsz; k++){</span></p>
631 
632 <p class=MsoNormal><span style='font-size:10.0pt'>          
633 back-&gt;SetBinContent(i + 1,j + 1,k + 1, source[i][j][k]);</span></p>
634 
635 <p class=MsoNormal><span style='font-size:10.0pt'>        }    </span></p>
636 
637 <p class=MsoNormal><span style='font-size:10.0pt'>     }</span></p>
638 
639 <p class=MsoNormal><span style='font-size:10.0pt'>   }   </span></p>
640 
641 <p class=MsoNormal><span style='font-size:10.0pt'>   </span></p>
642 
643 <p class=MsoNormal><span style='font-size:10.0pt'>  
644 strcpy(PATH,&quot;spectra3\\back_peaks_5ds.spe&quot;);   </span></p>
645 
646 <p class=MsoNormal><span style='font-size:10.0pt'>  
647 out=fopen(PATH,&quot;wb&quot;);</span></p>
648 
649 <p class=MsoNormal><span style='font-size:10.0pt'>   for(i=0;i&lt;nbinsx;i++){</span></p>
650 
651 <p class=MsoNormal><span style='font-size:10.0pt'>     
652 for(j=0;j&lt;nbinsy;j++){                   </span></p>
653 
654 <p class=MsoNormal><span style='font-size:10.0pt'>         fwrite(source[i][j],
655 sizeof(source[0][0][0]),nbinsz,out);</span></p>
656 
657 <p class=MsoNormal><span style='font-size:10.0pt'>      }</span></p>
658 
659 <p class=MsoNormal><span style='font-size:10.0pt'>   }   </span></p>
660 
661 <p class=MsoNormal><span style='font-size:10.0pt'>   fclose(out);      </span></p>
662 
663 <p class=MsoNormal><span style='font-size:10.0pt'>   </span></p>
664 
665 <p class=MsoNormal><span style='font-size:10.0pt'>  
666 back-&gt;Draw(&quot;&quot;);  </span></p>
667 
668 <p class=MsoNormal><span style='font-size:10.0pt'>}</span></p>
669 
670 <p class=MsoNormal>&nbsp;</p>
671 
672 <p class=MsoNormal style='text-align:justify'><span style='font-size:16.0pt'>&nbsp;</span></p>
673 
674 </div>
675 
676  */
677  Int_t i, j, x, y, z, sampling, q1, q2, q3;
678  Double_t a, b, c, d, p1, p2, p3, p4, p5, p6, p7, p8, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, r1, r2, r3, r4, r5, r6;
679  if (ssizex <= 0 || ssizey <= 0 || ssizez <= 0)
680  return "Wrong parameters";
681  if (numberIterationsX < 1 || numberIterationsY < 1 || numberIterationsZ < 1)
682  return "Width of Clipping Window Must Be Positive";
683  if (ssizex < 2 * numberIterationsX + 1 || ssizey < 2 * numberIterationsY + 1 || ssizey < 2 * numberIterationsZ + 1)
684  return ("Too Large Clipping Window");
685  Double_t*** working_space=new Double_t**[ssizex];
686  for(i=0;i<ssizex;i++){
687  working_space[i] =new Double_t*[ssizey];
688  for(j=0;j<ssizey;j++)
689  working_space[i][j]=new Double_t[ssizez];
690  }
691  sampling =(Int_t) TMath::Max(numberIterationsX, numberIterationsY);
692  sampling =(Int_t) TMath::Max(sampling, numberIterationsZ);
693  if (direction == kBackIncreasingWindow) {
694  if (filterType == kBackSuccessiveFiltering) {
695  for (i = 1; i <= sampling; i++) {
696  q1 = (Int_t) TMath::Min(i, numberIterationsX), q2 =(Int_t) TMath::Min(i, numberIterationsY), q3 =(Int_t) TMath::Min(i, numberIterationsZ);
697  for (z = q3; z < ssizez - q3; z++) {
698  for (y = q2; y < ssizey - q2; y++) {
699  for (x = q1; x < ssizex - q1; x++) {
700  a = spectrum[x][y][z];
701  p1 = spectrum[x + q1][y + q2][z - q3];
702  p2 = spectrum[x - q1][y + q2][z - q3];
703  p3 = spectrum[x + q1][y - q2][z - q3];
704  p4 = spectrum[x - q1][y - q2][z - q3];
705  p5 = spectrum[x + q1][y + q2][z + q3];
706  p6 = spectrum[x - q1][y + q2][z + q3];
707  p7 = spectrum[x + q1][y - q2][z + q3];
708  p8 = spectrum[x - q1][y - q2][z + q3];
709  s1 = spectrum[x + q1][y ][z - q3];
710  s2 = spectrum[x ][y + q2][z - q3];
711  s3 = spectrum[x - q1][y ][z - q3];
712  s4 = spectrum[x ][y - q2][z - q3];
713  s5 = spectrum[x + q1][y ][z + q3];
714  s6 = spectrum[x ][y + q2][z + q3];
715  s7 = spectrum[x - q1][y ][z + q3];
716  s8 = spectrum[x ][y - q2][z + q3];
717  s9 = spectrum[x - q1][y + q2][z ];
718  s10 = spectrum[x - q1][y - q2][z ];
719  s11 = spectrum[x + q1][y + q2][z ];
720  s12 = spectrum[x + q1][y - q2][z ];
721  r1 = spectrum[x ][y ][z - q3];
722  r2 = spectrum[x ][y ][z + q3];
723  r3 = spectrum[x - q1][y ][z ];
724  r4 = spectrum[x + q1][y ][z ];
725  r5 = spectrum[x ][y + q2][z ];
726  r6 = spectrum[x ][y - q2][z ];
727  b = (p1 + p3) / 2.0;
728  if(b > s1)
729  s1 = b;
730  b = (p1 + p2) / 2.0;
731  if(b > s2)
732  s2 = b;
733  b = (p2 + p4) / 2.0;
734  if(b > s3)
735  s3 = b;
736  b = (p3 + p4) / 2.0;
737  if(b > s4)
738  s4 = b;
739  b = (p5 + p7) / 2.0;
740  if(b > s5)
741  s5 = b;
742  b = (p5 + p6) / 2.0;
743  if(b > s6)
744  s6 = b;
745  b = (p6 + p8) / 2.0;
746  if(b > s7)
747  s7 = b;
748  b = (p7 + p8) / 2.0;
749  if(b > s8)
750  s8 = b;
751  b = (p2 + p6) / 2.0;
752  if(b > s9)
753  s9 = b;
754  b = (p4 + p8) / 2.0;
755  if(b > s10)
756  s10 = b;
757  b = (p1 + p5) / 2.0;
758  if(b > s11)
759  s11 = b;
760  b = (p3 + p7) / 2.0;
761  if(b > s12)
762  s12 = b;
763  s1 = s1 - (p1 + p3) / 2.0;
764  s2 = s2 - (p1 + p2) / 2.0;
765  s3 = s3 - (p2 + p4) / 2.0;
766  s4 = s4 - (p3 + p4) / 2.0;
767  s5 = s5 - (p5 + p7) / 2.0;
768  s6 = s6 - (p5 + p6) / 2.0;
769  s7 = s7 - (p6 + p8) / 2.0;
770  s8 = s8 - (p7 + p8) / 2.0;
771  s9 = s9 - (p2 + p6) / 2.0;
772  s10 = s10 - (p4 + p8) / 2.0;
773  s11 = s11 - (p1 + p5) / 2.0;
774  s12 = s12 - (p3 + p7) / 2.0;
775  b = (s1 + s3) / 2.0 + (s2 + s4) / 2.0 + (p1 + p2 + p3 + p4) / 4.0;
776  if(b > r1)
777  r1 = b;
778  b = (s5 + s7) / 2.0 + (s6 + s8) / 2.0 + (p5 + p6 + p7 + p8) / 4.0;
779  if(b > r2)
780  r2 = b;
781  b = (s3 + s7) / 2.0 + (s9 + s10) / 2.0 + (p2 + p4 + p6 + p8) / 4.0;
782  if(b > r3)
783  r3 = b;
784  b = (s1 + s5) / 2.0 + (s11 + s12) / 2.0 + (p1 + p3 + p5 + p7) / 4.0;
785  if(b > r4)
786  r4 = b;
787  b = (s9 + s11) / 2.0 + (s2 + s6) / 2.0 + (p1 + p2 + p5 + p6) / 4.0;
788  if(b > r5)
789  r5 = b;
790  b = (s4 + s8) / 2.0 + (s10 + s12) / 2.0 + (p3 + p4 + p7 + p8) / 4.0;
791  if(b > r6)
792  r6 = b;
793  r1 = r1 - ((s1 + s3) / 2.0 + (s2 + s4) / 2.0 + (p1 + p2 + p3 + p4) / 4.0);
794  r2 = r2 - ((s5 + s7) / 2.0 + (s6 + s8) / 2.0 + (p5 + p6 + p7 + p8) / 4.0);
795  r3 = r3 - ((s3 + s7) / 2.0 + (s9 + s10) / 2.0 + (p2 + p4 + p6 + p8) / 4.0);
796  r4 = r4 - ((s1 + s5) / 2.0 + (s11 + s12) / 2.0 + (p1 + p3 + p5 + p7) / 4.0);
797  r5 = r5 - ((s9 + s11) / 2.0 + (s2 + s6) / 2.0 + (p1 + p2 + p5 + p6) / 4.0);
798  r6 = r6 - ((s4 + s8) / 2.0 + (s10 + s12) / 2.0 + (p3 + p4 + p7 + p8) / 4.0);
799  b = (r1 + r2) / 2.0 + (r3 + r4) / 2.0 + (r5 + r6) / 2.0 + (s1 + s3 + s5 + s7) / 4.0 + (s2 + s4 + s6 + s8) / 4.0 + (s9 + s10 + s11 + s12) / 4.0 + (p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8) / 8.0;
800  if(b < a)
801  a = b;
802  working_space[x][y][z] = a;
803  }
804  }
805  }
806  for (z = q3; z < ssizez - q3; z++) {
807  for (y = q2; y < ssizey - q2; y++) {
808  for (x = q1; x < ssizex - q1; x++) {
809  spectrum[x][y][z] = working_space[x][y][z];
810  }
811  }
812  }
813  }
814  }
815 
816  else if (filterType == kBackOneStepFiltering) {
817  for (i = 1; i <= sampling; i++) {
818  q1 = (Int_t) TMath::Min(i, numberIterationsX), q2 =(Int_t) TMath::Min(i, numberIterationsY), q3 =(Int_t) TMath::Min(i, numberIterationsZ);
819  for (z = q3; z < ssizez - q3; z++) {
820  for (y = q2; y < ssizey - q2; y++) {
821  for (x = q1; x < ssizex - q1; x++) {
822  a = spectrum[x][y][z];
823  p1 = spectrum[x + q1][y + q2][z - q3];
824  p2 = spectrum[x - q1][y + q2][z - q3];
825  p3 = spectrum[x + q1][y - q2][z - q3];
826  p4 = spectrum[x - q1][y - q2][z - q3];
827  p5 = spectrum[x + q1][y + q2][z + q3];
828  p6 = spectrum[x - q1][y + q2][z + q3];
829  p7 = spectrum[x + q1][y - q2][z + q3];
830  p8 = spectrum[x - q1][y - q2][z + q3];
831  s1 = spectrum[x + q1][y ][z - q3];
832  s2 = spectrum[x ][y + q2][z - q3];
833  s3 = spectrum[x - q1][y ][z - q3];
834  s4 = spectrum[x ][y - q2][z - q3];
835  s5 = spectrum[x + q1][y ][z + q3];
836  s6 = spectrum[x ][y + q2][z + q3];
837  s7 = spectrum[x - q1][y ][z + q3];
838  s8 = spectrum[x ][y - q2][z + q3];
839  s9 = spectrum[x - q1][y + q2][z ];
840  s10 = spectrum[x - q1][y - q2][z ];
841  s11 = spectrum[x + q1][y + q2][z ];
842  s12 = spectrum[x + q1][y - q2][z ];
843  r1 = spectrum[x ][y ][z - q3];
844  r2 = spectrum[x ][y ][z + q3];
845  r3 = spectrum[x - q1][y ][z ];
846  r4 = spectrum[x + q1][y ][z ];
847  r5 = spectrum[x ][y + q2][z ];
848  r6 = spectrum[x ][y - q2][z ];
849  b=(p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8) / 8 - (s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10 + s11 + s12) / 4 + (r1 + r2 + r3 + r4 + r5 + r6) / 2;
850  c = -(s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10 + s11 + s12) / 4 + (r1 + r2 + r3 + r4 + r5 + r6) / 2;
851  d = -(p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8) / 8 + (s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10 + s11 + s12) / 12;
852  if(b < a && b >= 0 && c >=0 && d >= 0)
853  a = b;
854  working_space[x][y][z] = a;
855  }
856  }
857  }
858  for (z = q3; z < ssizez - q3; z++) {
859  for (y = q2; y < ssizey - q2; y++) {
860  for (x = q1; x < ssizex - q1; x++) {
861  spectrum[x][y][z] = working_space[x][y][z];
862  }
863  }
864  }
865  }
866  }
867  }
868 
869  else if (direction == kBackDecreasingWindow) {
870  if (filterType == kBackSuccessiveFiltering) {
871  for (i = sampling; i >= 1; i--) {
872  q1 = (Int_t) TMath::Min(i, numberIterationsX), q2 =(Int_t) TMath::Min(i, numberIterationsY), q3 =(Int_t) TMath::Min(i, numberIterationsZ);
873  for (z = q3; z < ssizez - q3; z++) {
874  for (y = q2; y < ssizey - q2; y++) {
875  for (x = q1; x < ssizex - q1; x++) {
876  a = spectrum[x][y][z];
877  p1 = spectrum[x + q1][y + q2][z - q3];
878  p2 = spectrum[x - q1][y + q2][z - q3];
879  p3 = spectrum[x + q1][y - q2][z - q3];
880  p4 = spectrum[x - q1][y - q2][z - q3];
881  p5 = spectrum[x + q1][y + q2][z + q3];
882  p6 = spectrum[x - q1][y + q2][z + q3];
883  p7 = spectrum[x + q1][y - q2][z + q3];
884  p8 = spectrum[x - q1][y - q2][z + q3];
885  s1 = spectrum[x + q1][y ][z - q3];
886  s2 = spectrum[x ][y + q2][z - q3];
887  s3 = spectrum[x - q1][y ][z - q3];
888  s4 = spectrum[x ][y - q2][z - q3];
889  s5 = spectrum[x + q1][y ][z + q3];
890  s6 = spectrum[x ][y + q2][z + q3];
891  s7 = spectrum[x - q1][y ][z + q3];
892  s8 = spectrum[x ][y - q2][z + q3];
893  s9 = spectrum[x - q1][y + q2][z ];
894  s10 = spectrum[x - q1][y - q2][z ];
895  s11 = spectrum[x + q1][y + q2][z ];
896  s12 = spectrum[x + q1][y - q2][z ];
897  r1 = spectrum[x ][y ][z - q3];
898  r2 = spectrum[x ][y ][z + q3];
899  r3 = spectrum[x - q1][y ][z ];
900  r4 = spectrum[x + q1][y ][z ];
901  r5 = spectrum[x ][y + q2][z ];
902  r6 = spectrum[x ][y - q2][z ];
903  b = (p1 + p3) / 2.0;
904  if(b > s1)
905  s1 = b;
906  b = (p1 + p2) / 2.0;
907  if(b > s2)
908  s2 = b;
909  b = (p2 + p4) / 2.0;
910  if(b > s3)
911  s3 = b;
912  b = (p3 + p4) / 2.0;
913  if(b > s4)
914  s4 = b;
915  b = (p5 + p7) / 2.0;
916  if(b > s5)
917  s5 = b;
918  b = (p5 + p6) / 2.0;
919  if(b > s6)
920  s6 = b;
921  b = (p6 + p8) / 2.0;
922  if(b > s7)
923  s7 = b;
924  b = (p7 + p8) / 2.0;
925  if(b > s8)
926  s8 = b;
927  b = (p2 + p6) / 2.0;
928  if(b > s9)
929  s9 = b;
930  b = (p4 + p8) / 2.0;
931  if(b > s10)
932  s10 = b;
933  b = (p1 + p5) / 2.0;
934  if(b > s11)
935  s11 = b;
936  b = (p3 + p7) / 2.0;
937  if(b > s12)
938  s12 = b;
939  s1 = s1 - (p1 + p3) / 2.0;
940  s2 = s2 - (p1 + p2) / 2.0;
941  s3 = s3 - (p2 + p4) / 2.0;
942  s4 = s4 - (p3 + p4) / 2.0;
943  s5 = s5 - (p5 + p7) / 2.0;
944  s6 = s6 - (p5 + p6) / 2.0;
945  s7 = s7 - (p6 + p8) / 2.0;
946  s8 = s8 - (p7 + p8) / 2.0;
947  s9 = s9 - (p2 + p6) / 2.0;
948  s10 = s10 - (p4 + p8) / 2.0;
949  s11 = s11 - (p1 + p5) / 2.0;
950  s12 = s12 - (p3 + p7) / 2.0;
951  b = (s1 + s3) / 2.0 + (s2 + s4) / 2.0 + (p1 + p2 + p3 + p4) / 4.0;
952  if(b > r1)
953  r1 = b;
954  b = (s5 + s7) / 2.0 + (s6 + s8) / 2.0 + (p5 + p6 + p7 + p8) / 4.0;
955  if(b > r2)
956  r2 = b;
957  b = (s3 + s7) / 2.0 + (s9 + s10) / 2.0 + (p2 + p4 + p6 + p8) / 4.0;
958  if(b > r3)
959  r3 = b;
960  b = (s1 + s5) / 2.0 + (s11 + s12) / 2.0 + (p1 + p3 + p5 + p7) / 4.0;
961  if(b > r4)
962  r4 = b;
963  b = (s9 + s11) / 2.0 + (s2 + s6) / 2.0 + (p1 + p2 + p5 + p6) / 4.0;
964  if(b > r5)
965  r5 = b;
966  b = (s4 + s8) / 2.0 + (s10 + s12) / 2.0 + (p3 + p4 + p7 + p8) / 4.0;
967  if(b > r6)
968  r6 = b;
969  r1 = r1 - ((s1 + s3) / 2.0 + (s2 + s4) / 2.0 + (p1 + p2 + p3 + p4) / 4.0);
970  r2 = r2 - ((s5 + s7) / 2.0 + (s6 + s8) / 2.0 + (p5 + p6 + p7 + p8) / 4.0);
971  r3 = r3 - ((s3 + s7) / 2.0 + (s9 + s10) / 2.0 + (p2 + p4 + p6 + p8) / 4.0);
972  r4 = r4 - ((s1 + s5) / 2.0 + (s11 + s12) / 2.0 + (p1 + p3 + p5 + p7) / 4.0);
973  r5 = r5 - ((s9 + s11) / 2.0 + (s2 + s6) / 2.0 + (p1 + p2 + p5 + p6) / 4.0);
974  r6 = r6 - ((s4 + s8) / 2.0 + (s10 + s12) / 2.0 + (p3 + p4 + p7 + p8) / 4.0);
975  b = (r1 + r2) / 2.0 + (r3 + r4) / 2.0 + (r5 + r6) / 2.0 + (s1 + s3 + s5 + s7) / 4.0 + (s2 + s4 + s6 + s8) / 4.0 + (s9 + s10 + s11 + s12) / 4.0 + (p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8) / 8.0;
976  if(b < a)
977  a = b;
978  working_space[x][y][z] = a;
979  }
980  }
981  }
982  for (z = q3; z < ssizez - q3; z++) {
983  for (y = q2; y < ssizey - q2; y++) {
984  for (x = q1; x < ssizex - q1; x++) {
985  spectrum[x][y][z] = working_space[x][y][z];
986  }
987  }
988  }
989  }
990  }
991 
992  else if (filterType == kBackOneStepFiltering) {
993  for (i = sampling; i >= 1; i--) {
994  q1 = (Int_t) TMath::Min(i, numberIterationsX), q2 =(Int_t) TMath::Min(i, numberIterationsY), q3 =(Int_t) TMath::Min(i, numberIterationsZ);
995  for (z = q3; z < ssizez - q3; z++) {
996  for (y = q2; y < ssizey - q2; y++) {
997  for (x = q1; x < ssizex - q1; x++) {
998  a = spectrum[x][y][z];
999  p1 = spectrum[x + q1][y + q2][z - q3];
1000  p2 = spectrum[x - q1][y + q2][z - q3];
1001  p3 = spectrum[x + q1][y - q2][z - q3];
1002  p4 = spectrum[x - q1][y - q2][z - q3];
1003  p5 = spectrum[x + q1][y + q2][z + q3];
1004  p6 = spectrum[x - q1][y + q2][z + q3];
1005  p7 = spectrum[x + q1][y - q2][z + q3];
1006  p8 = spectrum[x - q1][y - q2][z + q3];
1007  s1 = spectrum[x + q1][y ][z - q3];
1008  s2 = spectrum[x ][y + q2][z - q3];
1009  s3 = spectrum[x - q1][y ][z - q3];
1010  s4 = spectrum[x ][y - q2][z - q3];
1011  s5 = spectrum[x + q1][y ][z + q3];
1012  s6 = spectrum[x ][y + q2][z + q3];
1013  s7 = spectrum[x - q1][y ][z + q3];
1014  s8 = spectrum[x ][y - q2][z + q3];
1015  s9 = spectrum[x - q1][y + q2][z ];
1016  s10 = spectrum[x - q1][y - q2][z ];
1017  s11 = spectrum[x + q1][y + q2][z ];
1018  s12 = spectrum[x + q1][y - q2][z ];
1019  r1 = spectrum[x ][y ][z - q3];
1020  r2 = spectrum[x ][y ][z + q3];
1021  r3 = spectrum[x - q1][y ][z ];
1022  r4 = spectrum[x + q1][y ][z ];
1023  r5 = spectrum[x ][y + q2][z ];
1024  r6 = spectrum[x ][y - q2][z ];
1025  b = (p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8) / 8 - (s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10 + s11 + s12) / 4 + (r1 + r2 + r3 + r4 + r5 + r6) / 2;
1026  c = -(s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10 + s11 + s12) / 4+(r1 + r2 + r3 + r4 + r5 + r6) / 2;
1027  d = -(p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8)/8 + (s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10 + s11 + s12) / 12;
1028  if(b < a && b >= 0 && c >=0 && d >= 0)
1029  a = b;
1030  working_space[x][y][z] = a;
1031  }
1032  }
1033  }
1034  for (z = q3; z < ssizez - q3; z++) {
1035  for (y = q2; y < ssizey - q2; y++) {
1036  for (x = q1; x < ssizex - q1; x++) {
1037  spectrum[x][y][z] = working_space[x][y][z];
1038  }
1039  }
1040  }
1041  }
1042  }
1043  }
1044  for(i = 0;i < ssizex; i++){
1045  for(j = 0;j < ssizey; j++)
1046  delete[] working_space[i][j];
1047  delete[] working_space[i];
1048  }
1049  delete[] working_space;
1050  return 0;
1051 }
1052 
1053 ////////////////////////////////////////////////////////////////////////////////
1054 //////////////////////////////////////////////////////////////////////////////
1055 /// THREE-DIMENSIONAL MARKOV SPECTRUM SMOOTHING FUNCTION //
1056 /// //
1057 /// This function calculates smoothed spectrum from source spectrum //
1058 /// based on Markov chain method. //
1059 /// The result is placed in the array pointed by spectrum pointer. //
1060 /// //
1061 /// Function parameters: //
1062 /// source-pointer to the array of source spectrum //
1063 /// working_space-pointer to the working array //
1064 /// ssizex-x length of spectrum and working space arrays //
1065 /// ssizey-y length of spectrum and working space arrays //
1066 /// ssizey-z length of spectrum and working space arrays //
1067 /// averWindow-width of averaging smoothing window //
1068 /// //
1069 //////////////////////////////////////////////////////////////////////////////
1070 
1071 const char* TSpectrum3::SmoothMarkov(Double_t***source, Int_t ssizex, Int_t ssizey, Int_t ssizez, Int_t averWindow)
1072 {
1073 /*
1074 
1075 <div class=Section2>
1076 
1077 <p class=MsoNormal style='text-align:justify'><b><span style='font-size:14.0pt'>Smoothing</span></b></p>
1078 
1079 <p class=MsoNormal style='text-align:justify'><i>&nbsp;</i></p>
1080 
1081 <p class=MsoNormal><i>Goal: Suppression of statistical fluctuations</i></p>
1082 
1083 <p class=MsoNormal style='margin-left:36.0pt;text-align:justify;text-indent:
1084 -18.0pt'>•<span style='font:7.0pt "Times New Roman"'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
1085 </span>the algorithm is based on discrete Markov chain, which has very simple
1086 invariant distribution</p>
1087 
1088 <p class=MsoNormal>&nbsp;</p>
1089 
1090 <p class=MsoNormal>            <sub><img width=404 height=42
1091 src="Smoothing_files/image001.gif"></sub><span style='font-family:Arial'>     </span></p>
1092 
1093 <p class=MsoNormal style='text-align:justify'><span style='font-family:Arial'>       
1094 </span><sub><img width=22 height=28 src="Smoothing_files/image002.gif"></sub><span
1095 style='font-family:Arial'>  </span>being defined from the normalization
1096 condition <sub><img width=50 height=37 src="Smoothing_files/image003.gif"></sub></p>
1097 
1098 <p class=MsoNormal>         n is the length of the smoothed spectrum and </p>
1099 
1100 <p class=MsoNormal>
1101 
1102 <table cellpadding=0 cellspacing=0 align=left>
1103  <tr>
1104  <td width=65 height=9></td>
1105  </tr>
1106  <tr>
1107  <td></td>
1108  <td><img width=205 height=48 src="Smoothing_files/image004.gif"></td>
1109  </tr>
1110 </table>
1111 
1112  &nbsp;</p>
1113 
1114 <p class=MsoNormal>&nbsp;</p>
1115 
1116 <p class=MsoNormal style='text-align:justify'>&nbsp;</p>
1117 
1118 <br clear=ALL>
1119 
1120 <p class=MsoNormal style='margin-left:34.2pt;text-align:justify'>is the
1121 probability of the change of the peak position from channel i to the channel
1122 i+1.  <sub><img width=24 height=31 src="Smoothing_files/image005.gif"></sub>is
1123 the normalization constant so that <sub><img width=99 height=25
1124 src="Smoothing_files/image006.gif"></sub> and m is a width of smoothing window.
1125 We have extended this algorithm to three dimensions. </p>
1126 
1127 <p class=MsoNormal><i>&nbsp;</i></p>
1128 
1129 <p class=MsoNormal><i>Function:</i></p>
1130 
1131 <p class=MsoNormal><b>const <a
1132 href="http://root.cern.ch/root/html/ListOfTypes.html#char" target="_parent">char</a>*
1133 </b><a href="http://root.cern.ch/root/html/TSpectrum.html#TSpectrum:Fit1Awmi"><b>TSpectrum3::SmoothMarkov</b></a><b>(<a
1134 href="http://root.cern.ch/root/html/ListOfTypes.html#double" target="_parent">double</a>
1135 ***fSpectrum, <a href="http://root.cern.ch/root/html/ListOfTypes.html#int"
1136 target="_parent">int</a> fSizex, <a
1137 href="http://root.cern.ch/root/html/ListOfTypes.html#int" target="_parent">int</a>
1138 fSizey, <a href="http://root.cern.ch/root/html/ListOfTypes.html#int"
1139 target="_parent">int</a> fSizey,  <a
1140 href="http://root.cern.ch/root/html/ListOfTypes.html#int" target="_parent">int</a>
1141 fAverWindow)  </b></p>
1142 
1143 <p class=MsoNormal>&nbsp;</p>
1144 
1145 <p class=MsoNormal style='text-align:justify'>This function calculates smoothed
1146 spectrum from the source spectrum based on Markov chain method. The result is
1147 placed in the field pointed by source pointer. On successful completion it
1148 returns 0. On error it returns pointer to the string describing error.</p>
1149 
1150 <p class=MsoNormal>&nbsp;</p>
1151 
1152 <p class=MsoNormal><i><span style='color:red'>Parameters:</span></i></p>
1153 
1154 <p class=MsoNormal>        <b>fSpectrum</b>-pointer to the matrix of source
1155 spectrum                  </p>
1156 
1157 <p class=MsoNormal>        <b>fSizex, fSizey, fSizez</b> -lengths of the
1158 spectrum matrix                                 </p>
1159 
1160 <p class=MsoNormal>        <b>fAverWindow</b>-width of averaging smoothing
1161 window </p>
1162 
1163 <p class=MsoNormal>&nbsp;</p>
1164 
1165 <p class=MsoNormal><b><i>Reference:</i></b></p>
1166 
1167 <p class=MsoNormal style='text-align:justify'>[1] Z.K. Silagadze, A new
1168 algorithm for automatic photopeak searches. NIM A 376 (1996), 451<b>.</b>  </p>
1169 
1170 <p class=MsoNormal style='text-align:justify'>&nbsp;</p>
1171 
1172 <p class=MsoNormal><i>Example 1 – script SmootMarkov3.c :</i></p>
1173 
1174 <p class=MsoNormal><i><img border=0 width=601 height=368
1175 src="Smoothing_files/image007.jpg"></i><b>Fig. 1 Original noisy spectrum.    </b></p>
1176 
1177 <p class=MsoNormal><b><img border=0 width=601 height=368
1178 src="Smoothing_files/image008.jpg"></b></p>
1179 
1180 <p class=MsoNormal><b>Fig. 2 Smoothed spectrum with averaging window m=3.</b></p>
1181 
1182 <p class=MsoNormal><b><span style='color:#339966'>&nbsp;</span></b></p>
1183 
1184 <p class=MsoNormal><b><span style='color:#339966'>Script:</span></b></p>
1185 
1186 <p class=MsoNormal><span style='font-size:10.0pt'>// Example to illustrate the
1187 Markov smoothing (class TSpectrum3).</span></p>
1188 
1189 <p class=MsoNormal><span style='font-size:10.0pt'>// To execute this example,
1190 do</span></p>
1191 
1192 <p class=MsoNormal><span style='font-size:10.0pt'>// root &gt; .x
1193 SmoothMarkov3.C</span></p>
1194 
1195 <p class=MsoNormal><span style='font-size:10.0pt'>&nbsp;</span></p>
1196 
1197 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>void SmoothMarkov3()
1198 {</span></p>
1199 
1200 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t i, j, k;</span></p>
1201 
1202 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t nbinsx = 64;</span></p>
1203 
1204 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t nbinsy = 64;</span></p>
1205 
1206 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t nbinsz =
1207 64;   </span></p>
1208 
1209 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t xmin  = 0;</span></p>
1210 
1211 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t xmax  =
1212 nbinsx;</span></p>
1213 
1214 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t ymin  = 0;</span></p>
1215 
1216 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t ymax  =
1217 nbinsy;   </span></p>
1218 
1219 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t zmin  = 0;</span></p>
1220 
1221 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   </span><span
1222 style='font-size:10.0pt'>Int_t zmax  = nbinsz;      </span></p>
1223 
1224 <p class=MsoNormal><span style='font-size:10.0pt'>   Double_t*** source = new
1225 Double_t**[nbinsx];</span></p>
1226 
1227 <p class=MsoNormal><span style='font-size:10.0pt'>   for(i=0;i&lt;nbinsx;i++){</span></p>
1228 
1229 <p class=MsoNormal><span style='font-size:10.0pt'>      source[i]=new Double_t*
1230 [nbinsy];</span></p>
1231 
1232 <p class=MsoNormal><span style='font-size:10.0pt'>     
1233 for(j=0;j&lt;nbinsy;j++)</span></p>
1234 
1235 <p class=MsoNormal><span style='font-size:10.0pt'>         source[i][j]=new
1236 Double_t[nbinsz];</span></p>
1237 
1238 <p class=MsoNormal><span style='font-size:10.0pt'>   }           </span></p>
1239 
1240 <p class=MsoNormal><span style='font-size:10.0pt'>   TH3F *sm = new
1241 TH3F(&quot;Smoothing&quot;,&quot;Markov
1242 smoothing&quot;,nbinsx,xmin,xmax,nbinsy,ymin,ymax,nbinsz,zmin,zmax);</span></p>
1243 
1244 <p class=MsoNormal><span style='font-size:10.0pt'>   TFile *f = new
1245 TFile(&quot;TSpectrum3.root&quot;);</span></p>
1246 
1247 <p class=MsoNormal><span style='font-size:10.0pt'>   sm=(TH3F*)
1248 f-&gt;Get(&quot;back;1&quot;);</span></p>
1249 
1250 <p class=MsoNormal><span style='font-size:10.0pt'>   TCanvas *Background = new
1251 TCanvas(&quot;Smoothing&quot;,&quot;Markov smoothing&quot;,10,10,1000,700);</span></p>
1252 
1253 <p class=MsoNormal><span style='font-size:10.0pt'>   TSpectrum3 *s = new
1254 TSpectrum3();</span></p>
1255 
1256 <p class=MsoNormal><span style='font-size:10.0pt'>   for (i = 0; i &lt; nbinsx;
1257 i++){</span></p>
1258 
1259 <p class=MsoNormal><span style='font-size:10.0pt'>     for (j = 0; j &lt;
1260 nbinsy; j++){</span></p>
1261 
1262 <p class=MsoNormal><span style='font-size:10.0pt'>                  for (k = 0;
1263 k &lt; nbinsz; k++){</span></p>
1264 
1265 <p class=MsoNormal><span style='font-size:10.0pt'>                       source[i][j][k]
1266 = sm-&gt;GetBinContent(i + 1,j + 1,k + 1);</span></p>
1267 
1268 <p class=MsoNormal><span style='font-size:10.0pt'>                    } </span></p>
1269 
1270 <p class=MsoNormal><span style='font-size:10.0pt'>                 }</span></p>
1271 
1272 <p class=MsoNormal><span style='font-size:10.0pt'>   }</span></p>
1273 
1274 <p class=MsoNormal><span style='font-size:10.0pt'>  
1275 s-&gt;SmoothMarkov(source,nbinsx,nbinsy,nbinsz,3);</span></p>
1276 
1277 <p class=MsoNormal><span style='font-size:10.0pt'>   for (i = 0; i &lt; nbinsx;
1278 i++){</span></p>
1279 
1280 <p class=MsoNormal><span style='font-size:10.0pt'>     for (j = 0; j &lt;
1281 nbinsy; j++){</span></p>
1282 
1283 <p class=MsoNormal><span style='font-size:10.0pt'>        for (k = 0; k &lt;
1284 nbinsz; k++){</span></p>
1285 
1286 <p class=MsoNormal><span style='font-size:10.0pt'>          
1287 sm-&gt;SetBinContent(i + 1,j + 1,k + 1, source[i][j][k]);</span></p>
1288 
1289 <p class=MsoNormal><span style='font-size:10.0pt'>        }    </span></p>
1290 
1291 <p class=MsoNormal><span style='font-size:10.0pt'>     }</span></p>
1292 
1293 <p class=MsoNormal><span style='font-size:10.0pt'>   }</span></p>
1294 
1295 <p class=MsoNormal><span style='font-size:10.0pt'>  
1296 sm-&gt;Draw(&quot;&quot;);  </span></p>
1297 
1298 <p class=MsoNormal><span style='font-size:10.0pt'>}</span></p>
1299 
1300 </div>
1301 
1302  */
1303 
1304  Int_t xmin,xmax,ymin,ymax,zmin,zmax,i,j,k,l;
1305  Double_t a,b,maxch;
1306  Double_t nom,nip,nim,sp,sm,spx,smx,spy,smy,spz,smz,plocha=0;
1307  if(averWindow<=0)
1308  return "Averaging Window must be positive";
1309  Double_t***working_space = new Double_t**[ssizex];
1310  for(i = 0;i < ssizex; i++){
1311  working_space[i] = new Double_t*[ssizey];
1312  for(j = 0;j < ssizey; j++)
1313  working_space[i][j] = new Double_t[ssizez];
1314  }
1315  xmin = 0;
1316  xmax = ssizex - 1;
1317  ymin = 0;
1318  ymax = ssizey - 1;
1319  zmin = 0;
1320  zmax = ssizez - 1;
1321  for(i = 0,maxch = 0;i < ssizex; i++){
1322  for(j = 0;j < ssizey; j++){
1323  for(k = 0;k < ssizez; k++){
1324  working_space[i][j][k] = 0;
1325  if(maxch < source[i][j][k])
1326  maxch = source[i][j][k];
1327  plocha += source[i][j][k];
1328  }
1329  }
1330  }
1331  if(maxch == 0) {
1332  delete [] working_space;
1333  return 0;
1334  }
1335 
1336  nom = 0;
1337  working_space[xmin][ymin][zmin] = 1;
1338  for(i = xmin;i < xmax; i++){
1339  nip = source[i][ymin][zmin] / maxch;
1340  nim = source[i + 1][ymin][zmin] / maxch;
1341  sp = 0,sm = 0;
1342  for(l = 1;l <= averWindow; l++){
1343  if((i + l) > xmax)
1344  a = source[xmax][ymin][zmin] / maxch;
1345 
1346  else
1347  a = source[i + l][ymin][zmin] / maxch;
1348 
1349  b = a - nip;
1350  if(a + nip <= 0)
1351  a = 1;
1352 
1353  else
1354  a = TMath::Sqrt(a + nip);
1355 
1356  b = b / a;
1357  b = TMath::Exp(b);
1358  sp = sp + b;
1359  if(i - l + 1 < xmin)
1360  a = source[xmin][ymin][zmin] / maxch;
1361 
1362  else
1363  a = source[i - l + 1][ymin][zmin] / maxch;
1364 
1365  b = a - nim;
1366  if(a + nim <= 0)
1367  a = 1;
1368 
1369  else
1370  a = TMath::Sqrt(a + nim);
1371 
1372  b = b / a;
1373  b = TMath::Exp(b);
1374  sm = sm + b;
1375  }
1376  a = sp / sm;
1377  a = working_space[i + 1][ymin][zmin] = a * working_space[i][ymin][zmin];
1378  nom = nom + a;
1379  }
1380  for(i = ymin;i < ymax; i++){
1381  nip = source[xmin][i][zmin] / maxch;
1382  nim = source[xmin][i + 1][zmin] / maxch;
1383  sp = 0,sm = 0;
1384  for(l = 1;l <= averWindow; l++){
1385  if((i + l) > ymax)
1386  a = source[xmin][ymax][zmin] / maxch;
1387 
1388  else
1389  a = source[xmin][i + l][zmin] / maxch;
1390 
1391  b = a - nip;
1392  if(a + nip <= 0)
1393  a = 1;
1394 
1395  else
1396  a = TMath::Sqrt(a + nip);
1397 
1398  b = b / a;
1399  b = TMath::Exp(b);
1400  sp = sp + b;
1401  if(i - l + 1 < ymin)
1402  a = source[xmin][ymin][zmin] / maxch;
1403 
1404  else
1405  a = source[xmin][i - l + 1][zmin] / maxch;
1406 
1407  b = a - nim;
1408  if(a + nim <= 0)
1409  a = 1;
1410 
1411  else
1412  a = TMath::Sqrt(a + nim);
1413 
1414  b = b / a;
1415  b = TMath::Exp(b);
1416  sm = sm + b;
1417  }
1418  a = sp / sm;
1419  a = working_space[xmin][i + 1][zmin] = a * working_space[xmin][i][zmin];
1420  nom = nom + a;
1421  }
1422  for(i = zmin;i < zmax; i++){
1423  nip = source[xmin][ymin][i] / maxch;
1424  nim = source[xmin][ymin][i + 1] / maxch;
1425  sp = 0,sm = 0;
1426  for(l = 1;l <= averWindow; l++){
1427  if((i + l) > zmax)
1428  a = source[xmin][ymin][zmax] / maxch;
1429 
1430  else
1431  a = source[xmin][ymin][i + l] / maxch;
1432 
1433  b = a - nip;
1434  if(a + nip <= 0)
1435  a = 1;
1436 
1437  else
1438  a = TMath::Sqrt(a + nip);
1439 
1440  b = b / a;
1441  b = TMath::Exp(b);
1442  sp = sp + b;
1443  if(i - l + 1 < zmin)
1444  a = source[xmin][ymin][zmin] / maxch;
1445 
1446  else
1447  a = source[xmin][ymin][i - l + 1] / maxch;
1448 
1449  b = a - nim;
1450  if(a + nim <= 0)
1451  a = 1;
1452 
1453  else
1454  a = TMath::Sqrt(a + nim);
1455  b = b / a;
1456  b = TMath::Exp(b);
1457  sm = sm + b;
1458  }
1459  a = sp / sm;
1460  a = working_space[xmin][ymin][i + 1] = a * working_space[xmin][ymin][i];
1461  nom = nom + a;
1462  }
1463  for(i = xmin;i < xmax; i++){
1464  for(j = ymin;j < ymax; j++){
1465  nip = source[i][j + 1][zmin] / maxch;
1466  nim = source[i + 1][j + 1][zmin] / maxch;
1467  spx = 0,smx = 0;
1468  for(l = 1;l <= averWindow; l++){
1469  if(i + l > xmax)
1470  a = source[xmax][j][zmin] / maxch;
1471 
1472  else
1473  a = source[i + l][j][zmin] / maxch;
1474 
1475  b = a - nip;
1476  if(a + nip <= 0)
1477  a = 1;
1478 
1479  else
1480  a = TMath::Sqrt(a + nip);
1481 
1482  b = b / a;
1483  b = TMath::Exp(b);
1484  spx = spx + b;
1485  if(i - l + 1 < xmin)
1486  a = source[xmin][j][zmin] / maxch;
1487 
1488  else
1489  a = source[i - l + 1][j][zmin] / maxch;
1490 
1491  b = a - nim;
1492  if(a + nim <= 0)
1493  a = 1;
1494 
1495  else
1496  a = TMath::Sqrt(a + nim);
1497 
1498  b = b / a;
1499  b = TMath::Exp(b);
1500  smx = smx + b;
1501  }
1502  spy = 0,smy = 0;
1503  nip = source[i + 1][j][zmin] / maxch;
1504  nim = source[i + 1][j + 1][zmin] / maxch;
1505  for(l = 1;l <= averWindow; l++){
1506  if(j + l > ymax)
1507  a = source[i][ymax][zmin] / maxch;
1508 
1509  else
1510  a = source[i][j + l][zmin] / maxch;
1511 
1512  b = a - nip;
1513  if(a + nip <= 0)
1514  a = 1;
1515 
1516  else
1517  a = TMath::Sqrt(a + nip);
1518 
1519  b = b / a;
1520  b = TMath::Exp(b);
1521  spy = spy + b;
1522  if(j - l + 1 < ymin)
1523  a = source[i][ymin][zmin] / maxch;
1524 
1525  else
1526  a = source[i][j - l + 1][zmin] / maxch;
1527 
1528  b = a - nim;
1529  if(a + nim <= 0)
1530  a = 1;
1531 
1532  else
1533  a = TMath::Sqrt(a + nim);
1534 
1535  b = b / a;
1536  b = TMath::Exp(b);
1537  smy = smy + b;
1538  }
1539  a = (spx * working_space[i][j + 1][zmin] + spy * working_space[i + 1][j][zmin]) / (smx + smy);
1540  working_space[i + 1][j + 1][zmin] = a;
1541  nom = nom + a;
1542  }
1543  }
1544  for(i = xmin;i < xmax; i++){
1545  for(j = zmin;j < zmax; j++){
1546  nip = source[i][ymin][j + 1] / maxch;
1547  nim = source[i + 1][ymin][j + 1] / maxch;
1548  spx = 0,smx = 0;
1549  for(l = 1;l <= averWindow; l++){
1550  if(i + l > xmax)
1551  a = source[xmax][ymin][j] / maxch;
1552 
1553  else
1554  a = source[i + l][ymin][j] / maxch;
1555 
1556  b = a - nip;
1557  if(a + nip <= 0)
1558  a = 1;
1559 
1560  else
1561  a = TMath::Sqrt(a + nip);
1562 
1563  b = b / a;
1564  b = TMath::Exp(b);
1565  spx = spx + b;
1566  if(i - l + 1 < xmin)
1567  a = source[xmin][ymin][j] / maxch;
1568 
1569  else
1570  a = source[i - l + 1][ymin][j] / maxch;
1571 
1572  b = a - nim;
1573  if(a + nim <= 0)
1574  a = 1;
1575 
1576  else
1577  a = TMath::Sqrt(a + nim);
1578 
1579  b = b / a;
1580  b = TMath::Exp(b);
1581  smx = smx + b;
1582  }
1583  spz = 0,smz = 0;
1584  nip = source[i + 1][ymin][j] / maxch;
1585  nim = source[i + 1][ymin][j + 1] / maxch;
1586  for(l = 1;l <= averWindow; l++){
1587  if(j + l > zmax)
1588  a = source[i][ymin][zmax] / maxch;
1589 
1590  else
1591  a = source[i][ymin][j + l] / maxch;
1592 
1593  b = a - nip;
1594  if(a + nip <= 0)
1595  a = 1;
1596 
1597  else
1598  a = TMath::Sqrt(a + nip);
1599 
1600  b = b / a;
1601  b = TMath::Exp(b);
1602  spz = spz + b;
1603  if(j - l + 1 < zmin)
1604  a = source[i][ymin][zmin] / maxch;
1605 
1606  else
1607  a = source[i][ymin][j - l + 1] / maxch;
1608 
1609  b = a - nim;
1610  if(a + nim <= 0)
1611  a = 1;
1612 
1613  else
1614  a = TMath::Sqrt(a + nim);
1615 
1616  b = b / a;
1617  b = TMath::Exp(b);
1618  smz = smz + b;
1619  }
1620  a = (spx * working_space[i][ymin][j + 1] + spz * working_space[i + 1][ymin][j]) / (smx + smz);
1621  working_space[i + 1][ymin][j + 1] = a;
1622  nom = nom + a;
1623  }
1624  }
1625  for(i = ymin;i < ymax; i++){
1626  for(j = zmin;j < zmax; j++){
1627  nip = source[xmin][i][j + 1] / maxch;
1628  nim = source[xmin][i + 1][j + 1] / maxch;
1629  spy = 0,smy = 0;
1630  for(l = 1;l <= averWindow; l++){
1631  if(i + l > ymax)
1632  a = source[xmin][ymax][j] / maxch;
1633 
1634  else
1635  a = source[xmin][i + l][j] / maxch;
1636 
1637  b = a - nip;
1638  if(a + nip <= 0)
1639  a = 1;
1640 
1641  else
1642  a = TMath::Sqrt(a + nip);
1643 
1644  b = b / a;
1645  b = TMath::Exp(b);
1646  spy = spy + b;
1647  if(i - l + 1 < ymin)
1648  a = source[xmin][ymin][j] / maxch;
1649 
1650  else
1651  a = source[xmin][i - l + 1][j] / maxch;
1652 
1653  b = a - nim;
1654  if(a + nim <= 0)
1655  a = 1;
1656 
1657  else
1658  a = TMath::Sqrt(a + nim);
1659 
1660  b = b / a;
1661  b = TMath::Exp(b);
1662  smy = smy + b;
1663  }
1664  spz = 0,smz = 0;
1665  nip = source[xmin][i + 1][j] / maxch;
1666  nim = source[xmin][i + 1][j + 1] / maxch;
1667  for(l = 1;l <= averWindow; l++){
1668  if(j + l > zmax)
1669  a = source[xmin][i][zmax] / maxch;
1670 
1671  else
1672  a = source[xmin][i][j + l] / maxch;
1673 
1674  b = a - nip;
1675  if(a + nip <= 0)
1676  a = 1;
1677 
1678  else
1679  a = TMath::Sqrt(a + nip);
1680 
1681  b = b / a;
1682  b = TMath::Exp(b);
1683  spz = spz + b;
1684  if(j - l + 1 < zmin)
1685  a = source[xmin][i][zmin] / maxch;
1686 
1687  else
1688  a = source[xmin][i][j - l + 1] / maxch;
1689 
1690  b = a - nim;
1691  if(a + nim <= 0)
1692  a = 1;
1693 
1694  else
1695  a = TMath::Sqrt(a + nim);
1696 
1697  b = b / a;
1698  b = TMath::Exp(b);
1699  smz = smz + b;
1700  }
1701  a = (spy * working_space[xmin][i][j + 1] + spz * working_space[xmin][i + 1][j]) / (smy + smz);
1702  working_space[xmin][i + 1][j + 1] = a;
1703  nom = nom + a;
1704  }
1705  }
1706  for(i = xmin;i < xmax; i++){
1707  for(j = ymin;j < ymax; j++){
1708  for(k = zmin;k < zmax; k++){
1709  nip = source[i][j + 1][k + 1] / maxch;
1710  nim = source[i + 1][j + 1][k + 1] / maxch;
1711  spx = 0,smx = 0;
1712  for(l = 1;l <= averWindow; l++){
1713  if(i + l > xmax)
1714  a = source[xmax][j][k] / maxch;
1715 
1716  else
1717  a = source[i + l][j][k] / maxch;
1718 
1719  b = a - nip;
1720  if(a + nip <= 0)
1721  a = 1;
1722 
1723  else
1724  a = TMath::Sqrt(a + nip);
1725 
1726  b = b / a;
1727  b = TMath::Exp(b);
1728  spx = spx + b;
1729  if(i - l + 1 < xmin)
1730  a = source[xmin][j][k] / maxch;
1731 
1732  else
1733  a = source[i - l + 1][j][k] / maxch;
1734 
1735  b = a - nim;
1736  if(a + nim <= 0)
1737  a = 1;
1738 
1739  else
1740  a = TMath::Sqrt(a + nim);
1741 
1742  b = b / a;
1743  b = TMath::Exp(b);
1744  smx = smx + b;
1745  }
1746  spy = 0,smy = 0;
1747  nip = source[i + 1][j][k + 1] / maxch;
1748  nim = source[i + 1][j + 1][k + 1] / maxch;
1749  for(l = 1;l <= averWindow; l++){
1750  if(j + l > ymax)
1751  a = source[i][ymax][k] / maxch;
1752 
1753  else
1754  a = source[i][j + l][k] / maxch;
1755 
1756  b = a - nip;
1757  if(a + nip <= 0)
1758  a = 1;
1759 
1760  else
1761  a = TMath::Sqrt(a + nip);
1762 
1763  b = b / a;
1764  b = TMath::Exp(b);
1765  spy = spy + b;
1766  if(j - l + 1 < ymin)
1767  a = source[i][ymin][k] / maxch;
1768 
1769  else
1770  a = source[i][j - l + 1][k] / maxch;
1771 
1772  b = a - nim;
1773  if(a + nim <= 0)
1774  a = 1;
1775 
1776  else
1777  a = TMath::Sqrt(a + nim);
1778 
1779  b = b / a;
1780  b = TMath::Exp(b);
1781  smy = smy + b;
1782  }
1783  spz = 0,smz = 0;
1784  nip = source[i + 1][j + 1][k] / maxch;
1785  nim = source[i + 1][j + 1][k + 1] / maxch;
1786  for(l = 1;l <= averWindow; l++){
1787  if(j + l > zmax)
1788  a = source[i][j][zmax] / maxch;
1789 
1790  else
1791  a = source[i][j][k + l] / maxch;
1792 
1793  b = a - nip;
1794  if(a + nip <= 0)
1795  a = 1;
1796 
1797  else
1798  a = TMath::Sqrt(a + nip);
1799 
1800  b = b / a;
1801  b = TMath::Exp(b);
1802  spz = spz + b;
1803  if(j - l + 1 < ymin)
1804  a = source[i][j][zmin] / maxch;
1805 
1806  else
1807  a = source[i][j][k - l + 1] / maxch;
1808 
1809  b = a - nim;
1810  if(a + nim <= 0)
1811  a = 1;
1812 
1813  else
1814  a = TMath::Sqrt(a + nim);
1815 
1816  b = b / a;
1817  b = TMath::Exp(b);
1818  smz = smz+b;
1819  }
1820  a = (spx * working_space[i][j + 1][k + 1] + spy * working_space[i + 1][j][k + 1] + spz * working_space[i + 1][j + 1][k]) / (smx + smy + smz);
1821  working_space[i + 1][j + 1][k + 1] = a;
1822  nom = nom + a;
1823  }
1824  }
1825  }
1826  for(i = xmin;i <= xmax; i++){
1827  for(j = ymin;j <= ymax; j++){
1828  for(k = zmin;k <= zmax; k++){
1829  working_space[i][j][k] = working_space[i][j][k] / nom;
1830  }
1831  }
1832  }
1833  for(i = 0;i < ssizex; i++){
1834  for(j = 0;j < ssizey; j++){
1835  for(k = 0;k < ssizez; k++){
1836  source[i][j][k] = plocha * working_space[i][j][k];
1837  }
1838  }
1839  }
1840  for(i = 0;i < ssizex; i++){
1841  for(j = 0;j < ssizey; j++)
1842  delete[] working_space[i][j];
1843  delete[] working_space[i];
1844  }
1845  delete[] working_space;
1846  return 0;
1847 }
1848 
1849 ////////////////////////////////////////////////////////////////////////////////
1850 //////////////////////////////////////////////////////////////////////////////
1851 /// THREE-DIMENSIONAL DECONVOLUTION FUNCTION //
1852 /// This function calculates deconvolution from source spectrum //
1853 /// according to response spectrum //
1854 /// The result is placed in the cube pointed by source pointer. //
1855 /// //
1856 /// Function parameters: //
1857 /// source-pointer to the cube of source spectrum //
1858 /// resp-pointer to the cube of response spectrum //
1859 /// ssizex-x length of source and response spectra //
1860 /// ssizey-y length of source and response spectra //
1861 /// ssizey-y length of source and response spectra //
1862 /// numberIterations, for details we refer to manual //
1863 /// numberRepetitions, for details we refer to manual //
1864 /// boost, boosting factor, for details we refer to manual //
1865 /// //
1866 //////////////////////////////////////////////////////////////////////////////
1867 
1868 const char *TSpectrum3::Deconvolution(Double_t***source, const Double_t***resp,
1869  Int_t ssizex, Int_t ssizey, Int_t ssizez,
1870  Int_t numberIterations,
1871  Int_t numberRepetitions,
1872  Double_t boost)
1873 {
1874 /*
1875 
1876 <div class=Section3>
1877 
1878 <p class=MsoNormal style='text-align:justify'><b><span style='font-size:14.0pt'>Deconvolution</span></b></p>
1879 
1880 <p class=MsoNormal style='text-align:justify'><i>&nbsp;</i></p>
1881 
1882 <p class=MsoNormal style='text-align:justify'><i>Goal: Improvement of the
1883 resolution in spectra, decomposition of multiplets</i></p>
1884 
1885 <p class=MsoNormal>&nbsp;</p>
1886 
1887 <p class=MsoNormal>Mathematical formulation of the 3-dimensional convolution
1888 system is</p>
1889 
1890 <p class=MsoNormal style='margin-left:18.0pt'>
1891 
1892 <table cellpadding=0 cellspacing=0 align=left>
1893  <tr>
1894  <td width=69 height=1></td>
1895  </tr>
1896  <tr>
1897  <td></td>
1898  <td><img width=334 height=67 src="gif/spectrum3_deconvolution_image001.gif"></td>
1899  </tr>
1900 </table>
1901 
1902 <span style='font-size:16.0pt'>&nbsp;</span></p>
1903 
1904 <p class=MsoNormal><span style='font-size:16.0pt'>&nbsp;</span></p>
1905 
1906 <p class=MsoNormal>&nbsp;</p>
1907 
1908 <p class=MsoNormal>&nbsp;</p>
1909 
1910 <br clear=ALL>
1911 
1912 <p class=MsoNormal>where h(i,j,k) is the impulse response function, x, y are
1913 input and output fields, respectively, <sub><img width=69 height=24
1914 src="gif/spectrum3_deconvolution_image002.gif"></sub>, are the lengths of x and h fields<i>
1915 </i></p>
1916 
1917 <p class=MsoNormal style='margin-left:36.0pt;text-align:justify;text-indent:
1918 -18.0pt'>•<span style='font:7.0pt "Times New Roman"'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
1919 </span>let us assume that we know the response and the output fields (spectra)
1920 of the above given system. </p>
1921 
1922 <p class=MsoNormal style='margin-left:36.0pt;text-align:justify;text-indent:
1923 -18.0pt'>•<span style='font:7.0pt "Times New Roman"'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
1924 </span>the deconvolution represents solution of the overdetermined system of
1925 linear equations, i.e.,  the calculation of the field <b>x.</b></p>
1926 
1927 <p class=MsoNormal style='margin-left:36.0pt;text-align:justify;text-indent:
1928 -18.0pt'>•<span style='font:7.0pt "Times New Roman"'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
1929 </span>from numerical stability point of view the operation of deconvolution is
1930 extremely critical (ill-posed  problem) as well as time consuming operation. </p>
1931 
1932 <p class=MsoNormal style='margin-left:36.0pt;text-align:justify;text-indent:
1933 -18.0pt'>•<span style='font:7.0pt "Times New Roman"'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
1934 </span>the Gold deconvolution algorithm proves to work very well even for
1935 2-dimensional systems. Generalization of the algorithm for 2-dimensional
1936 systems was presented in [1], and for multidimensional systems in [2].</p>
1937 
1938 <p class=MsoNormal style='margin-left:36.0pt;text-align:justify;text-indent:
1939 -18.0pt'>•<span style='font:7.0pt "Times New Roman"'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
1940 </span>for Gold deconvolution algorithm as well as for boosted deconvolution
1941 algorithm we refer also to TSpectrum and TSpectrum2 </p>
1942 
1943 <p class=MsoNormal><i>&nbsp;</i></p>
1944 
1945 <p class=MsoNormal><i>Function:</i></p>
1946 
1947 <p class=MsoNormal style='text-align:justify'><b>const <a
1948 href="http://root.cern.ch/root/html/ListOfTypes.html#char">char</a>* </b><a
1949 name="TSpectrum:Deconvolution1"></a><a
1950 href="http://root.cern.ch/root/html/TSpectrum.html#TSpectrum:Fit1Awmi"><b>TSpectrum3::Deconvolution</b></a><b>(<a
1951 href="http://root.cern.ch/root/html/ListOfTypes.html#double">double</a> ***fSource,
1952 const <a href="http://root.cern.ch/root/html/ListOfTypes.html#double">double</a>
1953 ***fResp, <a href="http://root.cern.ch/root/html/ListOfTypes.html#int">int</a>
1954 fSizex, <a href="http://root.cern.ch/root/html/ListOfTypes.html#int">int</a>
1955 fSizey, <a href="http://root.cern.ch/root/html/ListOfTypes.html#int">int</a>
1956 fSizez, <a href="http://root.cern.ch/root/html/ListOfTypes.html#int">int</a>
1957 fNumberIterations, <a href="http://root.cern.ch/root/html/ListOfTypes.html#int">int</a>
1958 fNumberRepetitions, <a
1959 href="http://root.cern.ch/root/html/ListOfTypes.html#double">double</a> fBoost)</b></p>
1960 
1961 <p class=MsoNormal>&nbsp;</p>
1962 
1963 <p class=MsoNormal style='text-align:justify'>This function calculates
1964 deconvolution from source spectrum according to response spectrum using Gold
1965 deconvolution algorithm. The result is placed in the field pointed by source
1966 pointer. On successful completion it returns 0. On error it returns pointer to
1967 the string describing error. If desired after every fNumberIterations one can apply
1968 boosting operation (exponential function with exponent given by fBoost
1969 coefficient) and repeat it fNumberRepetitions times.</p>
1970 
1971 <p class=MsoNormal>&nbsp;</p>
1972 
1973 <p class=MsoNormal><i><span style='color:red'>Parameters:</span></i></p>
1974 
1975 <p class=MsoNormal>        <b>fSource</b>-pointer to the matrix of source
1976 spectrum                  </p>
1977 
1978 <p class=MsoNormal>        <b>fResp</b>-pointer to the matrix of response
1979 spectrum                  </p>
1980 
1981 <p class=MsoNormal>        <b>fSizex, fSizey, fSizez</b> -lengths of the
1982 spectrum matrix                                 </p>
1983 
1984 <p class=MsoNormal style='text-align:justify'>        <b>fNumberIterations</b>-number
1985 of iterations </p>
1986 
1987 <p class=MsoNormal style='text-align:justify'>        <b>fNumberRepetitions</b>-number
1988 of repetitions for boosted deconvolution. It must be </p>
1989 
1990 <p class=MsoNormal style='text-align:justify'>        greater or equal to one.</p>
1991 
1992 <p class=MsoNormal style='text-align:justify'>        <b>fBoost</b>-boosting
1993 coefficient, applies only if fNumberRepetitions is greater than one.  </p>
1994 
1995 <p class=MsoNormal style='text-align:justify'>        <span style='color:fuchsia'>Recommended
1996 range &lt;1,2&gt;.</span></p>
1997 
1998 <p class=MsoNormal>&nbsp;</p>
1999 
2000 <p class=MsoNormal><b><i>References:</i></b></p>
2001 
2002 <p class=MsoNormal style='text-align:justify'> [1] <span lang=SK>M.
2003 Morhá&#269;, J. Kliman, V. Matoušek, M. Veselský, I. Turzo</span>.: Efficient
2004 one- and two-dimensional Gold deconvolution and its application to gamma-ray
2005 spectra decomposition. NIM, A401 (1997) 385-408.</p>
2006 
2007 <p class=MsoNormal style='text-align:justify'>[2] Morhá&#269; M., Matoušek V.,
2008 Kliman J., Efficient algorithm of multidimensional deconvolution and its
2009 application to nuclear data processing, Digital Signal Processing 13 (2003)
2010 144. </p>
2011 
2012 <p class=MsoNormal style='text-align:justify'>&nbsp;</p>
2013 
2014 <p class=MsoNormal><i>Example 1 – script Decon.c :</i></p>
2015 
2016 <p class=MsoNormal style='margin-left:36.0pt;text-align:justify;text-indent:
2017 -18.0pt'>•<span style='font:7.0pt "Times New Roman"'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
2018 </span>response function (usually peak) should be shifted to the beginning of
2019 the coordinate system (see Fig. 1)</p>
2020 
2021 <p class=MsoNormal style='text-align:justify'><b><span style='font-size:16.0pt'><img
2022 border=0 width=601 height=368 src="gif/spectrum3_deconvolution_image003.jpg"></span></b></p>
2023 
2024 <p class=MsoNormal style='text-align:justify'><b>Fig. 1 Three-dimensional
2025 response spectrum</b></p>
2026 
2027 <p class=MsoNormal>&nbsp;</p>
2028 
2029 <p class=MsoNormal><img border=0 width=601 height=368
2030 src="gif/spectrum3_deconvolution_image004.jpg"></p>
2031 
2032 <p class=MsoNormal>&nbsp;</p>
2033 
2034 <p class=MsoNormal style='text-align:justify'><b>Fig. 2 Three-dimensional input
2035 spectrum (before deconvolution)</b></p>
2036 
2037 <p class=MsoNormal>&nbsp;</p>
2038 
2039 <p class=MsoNormal><img border=0 width=601 height=368
2040 src="gif/spectrum3_deconvolution_image005.jpg"></p>
2041 
2042 <p class=MsoNormal style='text-align:justify'><b>Fig. 3 Spectrum from Fig. 2
2043 after deconvolution (100 iterations)</b></p>
2044 
2045 <p class=MsoNormal>&nbsp;</p>
2046 
2047 <p class=MsoNormal><b><span style='color:#339966'>Script:</span></b></p>
2048 
2049 <p class=MsoNormal><span style='font-size:10.0pt'>// Example to illustrate the
2050 Gold deconvolution (class TSpectrum3).</span></p>
2051 
2052 <p class=MsoNormal><span style='font-size:10.0pt'>// To execute this example,
2053 do</span></p>
2054 
2055 <p class=MsoNormal><span style='font-size:10.0pt'>// root &gt; .x Decon3.C</span></p>
2056 
2057 <p class=MsoNormal><span style='font-size:10.0pt'>&nbsp;</span></p>
2058 
2059 <p class=MsoNormal><span style='font-size:10.0pt'>#include &lt;TSpectrum3&gt;</span></p>
2060 
2061 <p class=MsoNormal><span style='font-size:10.0pt'>&nbsp;</span></p>
2062 
2063 <p class=MsoNormal><span style='font-size:10.0pt'>void Decon3() {</span></p>
2064 
2065 <p class=MsoNormal><span style='font-size:10.0pt'>   Int_t i, j, k;</span></p>
2066 
2067 <p class=MsoNormal><span style='font-size:10.0pt'>   </span><span lang=FR
2068 style='font-size:10.0pt'>Int_t nbinsx = 32;</span></p>
2069 
2070 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t nbinsy = 32;</span></p>
2071 
2072 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t nbinsz =
2073 32;   </span></p>
2074 
2075 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t xmin  = 0;</span></p>
2076 
2077 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t xmax  =
2078 nbinsx;</span></p>
2079 
2080 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t ymin  = 0;</span></p>
2081 
2082 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t ymax  =
2083 nbinsy;   </span></p>
2084 
2085 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t zmin  = 0;</span></p>
2086 
2087 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   </span><span
2088 style='font-size:10.0pt'>Int_t zmax  = nbinsz;      </span></p>
2089 
2090 <p class=MsoNormal><span style='font-size:10.0pt'>   Double_t*** source = new
2091 Double_t**[nbinsx];</span></p>
2092 
2093 <p class=MsoNormal><span style='font-size:10.0pt'>   Double_t*** resp = new Double_t
2094 **[nbinsx];      </span></p>
2095 
2096 <p class=MsoNormal><span style='font-size:10.0pt'>   for(i=0;i&lt;nbinsx;i++){</span></p>
2097 
2098 <p class=MsoNormal><span style='font-size:10.0pt'>      source[i]=new Double_t*
2099 [nbinsy];</span></p>
2100 
2101 <p class=MsoNormal><span style='font-size:10.0pt'>     
2102 for(j=0;j&lt;nbinsy;j++)</span></p>
2103 
2104 <p class=MsoNormal><span style='font-size:10.0pt'>         source[i][j]=new
2105 Double_t[nbinsz];</span></p>
2106 
2107 <p class=MsoNormal><span style='font-size:10.0pt'>   }           </span></p>
2108 
2109 <p class=MsoNormal><span style='font-size:10.0pt'>   for(i=0;i&lt;nbinsx;i++){</span></p>
2110 
2111 <p class=MsoNormal><span style='font-size:10.0pt'>      resp[i]=new Double_t*
2112 [nbinsy];</span></p>
2113 
2114 <p class=MsoNormal><span style='font-size:10.0pt'>     
2115 for(j=0;j&lt;nbinsy;j++)</span></p>
2116 
2117 <p class=MsoNormal><span style='font-size:10.0pt'>         resp[i][j]=new Double_t
2118 [nbinsz];</span></p>
2119 
2120 <p class=MsoNormal><span style='font-size:10.0pt'>   }              </span></p>
2121 
2122 <p class=MsoNormal><span style='font-size:10.0pt'>   TH3F *decon_in = new
2123 TH3F(&quot;decon_in&quot;,&quot;Deconvolution&quot;,nbinsx,xmin,xmax,nbinsy,ymin,ymax,nbinsz,zmin,zmax);</span></p>
2124 
2125 <p class=MsoNormal><span style='font-size:10.0pt'>   TH3F *decon_resp = new
2126 TH3F(&quot;decon_resp&quot;,&quot;Deconvolution&quot;,nbinsx,xmin,xmax,nbinsy,ymin,ymax,nbinsz,zmin,zmax);  
2127 </span></p>
2128 
2129 <p class=MsoNormal><span style='font-size:10.0pt'>   TFile *f = new
2130 TFile(&quot;TSpectrum3.root&quot;);</span></p>
2131 
2132 <p class=MsoNormal><span style='font-size:10.0pt'>   decon_in=(TH3F*)
2133 f-&gt;Get(&quot;decon_in;1&quot;);</span></p>
2134 
2135 <p class=MsoNormal><span style='font-size:10.0pt'>   decon_resp=(TH3F*)
2136 f-&gt;Get(&quot;decon_resp;1&quot;);   </span></p>
2137 
2138 <p class=MsoNormal><span style='font-size:10.0pt'>   TCanvas *Deconvolution =
2139 new TCanvas(&quot;Deconvolution&quot;,&quot;Deconvolution of 3-dimensional
2140 spectra&quot;,10,10,1000,700);</span></p>
2141 
2142 <p class=MsoNormal><span style='font-size:10.0pt'>   TSpectrum3 *s = new
2143 TSpectrum3();</span></p>
2144 
2145 <p class=MsoNormal><span style='font-size:10.0pt'>   for (i = 0; i &lt; nbinsx;
2146 i++){</span></p>
2147 
2148 <p class=MsoNormal><span style='font-size:10.0pt'>     for (j = 0; j &lt;
2149 nbinsy; j++){</span></p>
2150 
2151 <p class=MsoNormal><span style='font-size:10.0pt'>                  for (k = 0;
2152 k &lt; nbinsz; k++){</span></p>
2153 
2154 <p class=MsoNormal><span style='font-size:10.0pt'>                       source[i][j][k]
2155 = decon_in-&gt;GetBinContent(i + 1,j + 1,k + 1);</span></p>
2156 
2157 <p class=MsoNormal><span style='font-size:10.0pt'>                       resp[i][j][k]
2158 = decon_resp-&gt;GetBinContent(i + 1,j + 1,k + 1);                        </span></p>
2159 
2160 <p class=MsoNormal><span style='font-size:10.0pt'>                    } </span></p>
2161 
2162 <p class=MsoNormal><span style='font-size:10.0pt'>                 }</span></p>
2163 
2164 <p class=MsoNormal><span style='font-size:10.0pt'>   }</span></p>
2165 
2166 <p class=MsoNormal><span style='font-size:10.0pt'>  
2167 s-&gt;Deconvolution(source,resp,nbinsx,nbinsy,nbinsz,100,1,1);</span></p>
2168 
2169 <p class=MsoNormal><span style='font-size:10.0pt'>   for (i = 0; i &lt; nbinsx;
2170 i++){</span></p>
2171 
2172 <p class=MsoNormal><span style='font-size:10.0pt'>     for (j = 0; j &lt;
2173 nbinsy; j++){</span></p>
2174 
2175 <p class=MsoNormal><span style='font-size:10.0pt'>        for (k = 0; k &lt;
2176 nbinsz; k++){</span></p>
2177 
2178 <p class=MsoNormal><span style='font-size:10.0pt'>          
2179 decon_in-&gt;SetBinContent(i + 1,j + 1,k + 1, source[i][j][k]);</span></p>
2180 
2181 <p class=MsoNormal><span style='font-size:10.0pt'>        }    </span></p>
2182 
2183 <p class=MsoNormal><span style='font-size:10.0pt'>     }</span></p>
2184 
2185 <p class=MsoNormal><span style='font-size:10.0pt'>   }</span></p>
2186 
2187 <p class=MsoNormal>   decon_in-&gt;Draw(&quot;&quot;);  </p>
2188 
2189 <p class=MsoNormal>}</p>
2190 
2191 <p class=MsoNormal>&nbsp;</p>
2192 
2193 <p class=MsoNormal><i>Example 2 – script Decon_hr.c :</i></p>
2194 
2195 <p class=MsoNormal style='text-align:justify'>This example illustrates repeated
2196 Gold deconvolution with boosting. After every 10 iterations we apply power
2197 function with exponent = 2 to the spectrum given in Fig. 2.</p>
2198 
2199 <p class=MsoNormal style='text-align:justify'>&nbsp;</p>
2200 
2201 <p class=MsoNormal style='text-align:justify'><img border=0 width=601
2202 height=368 src="gif/spectrum3_deconvolution_image006.jpg"></p>
2203 
2204 <p class=MsoNormal style='text-align:justify'><b>Fig. 4 Spectrum from Fig. 2
2205 after boosted deconvolution (10 iterations repeated 10 times). It decomposes
2206 completely cluster of peaks from Fig 2.</b></p>
2207 
2208 <p class=MsoNormal style='text-align:justify'>&nbsp;</p>
2209 
2210 <p class=MsoNormal><b><span style='color:#339966'>Script:</span></b></p>
2211 
2212 <p class=MsoNormal><span style='font-size:10.0pt'>// Example to illustrate the
2213 Gold deconvolution (class TSpectrum3).</span></p>
2214 
2215 <p class=MsoNormal><span style='font-size:10.0pt'>// To execute this example,
2216 do</span></p>
2217 
2218 <p class=MsoNormal><span style='font-size:10.0pt'>// root &gt; .x Decon3_hr.C</span></p>
2219 
2220 <p class=MsoNormal><span style='font-size:10.0pt'>void Decon3_hr() {</span></p>
2221 
2222 <p class=MsoNormal><span style='font-size:10.0pt'>   Int_t i, j, k;</span></p>
2223 
2224 <p class=MsoNormal><span style='font-size:10.0pt'>   </span><span lang=FR
2225 style='font-size:10.0pt'>Int_t nbinsx = 32;</span></p>
2226 
2227 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t nbinsy = 32;</span></p>
2228 
2229 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t nbinsz =
2230 32;   </span></p>
2231 
2232 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t xmin  = 0;</span></p>
2233 
2234 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t xmax  =
2235 nbinsx;</span></p>
2236 
2237 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t ymin  = 0;</span></p>
2238 
2239 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t ymax  =
2240 nbinsy;   </span></p>
2241 
2242 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t zmin  = 0;</span></p>
2243 
2244 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   </span><span
2245 style='font-size:10.0pt'>Int_t zmax  = nbinsz;      </span></p>
2246 
2247 <p class=MsoNormal><span style='font-size:10.0pt'>   Double_t*** source = new
2248 Double_t**[nbinsx];</span></p>
2249 
2250 <p class=MsoNormal><span style='font-size:10.0pt'>   Double_t*** resp = new Double_t
2251 **[nbinsx];      </span></p>
2252 
2253 <p class=MsoNormal><span style='font-size:10.0pt'>   for(i=0;i&lt;nbinsx;i++){</span></p>
2254 
2255 <p class=MsoNormal><span style='font-size:10.0pt'>      source[i]=new Double_t*
2256 [nbinsy];</span></p>
2257 
2258 <p class=MsoNormal><span style='font-size:10.0pt'>     
2259 for(j=0;j&lt;nbinsy;j++)</span></p>
2260 
2261 <p class=MsoNormal><span style='font-size:10.0pt'>         source[i][j]=new
2262 Double_t[nbinsz];</span></p>
2263 
2264 <p class=MsoNormal><span style='font-size:10.0pt'>   }           </span></p>
2265 
2266 <p class=MsoNormal><span style='font-size:10.0pt'>   for(i=0;i&lt;nbinsx;i++){</span></p>
2267 
2268 <p class=MsoNormal><span style='font-size:10.0pt'>      resp[i]=new Double_t*
2269 [nbinsy];</span></p>
2270 
2271 <p class=MsoNormal><span style='font-size:10.0pt'>     
2272 for(j=0;j&lt;nbinsy;j++)</span></p>
2273 
2274 <p class=MsoNormal><span style='font-size:10.0pt'>         resp[i][j]=new Double_t
2275 [nbinsz];</span></p>
2276 
2277 <p class=MsoNormal><span style='font-size:10.0pt'>   }              </span></p>
2278 
2279 <p class=MsoNormal><span style='font-size:10.0pt'>   TH3F *decon_in = new
2280 TH3F(&quot;decon_in&quot;,&quot;Deconvolution&quot;,nbinsx,xmin,xmax,nbinsy,ymin,ymax,nbinsz,zmin,zmax);</span></p>
2281 
2282 <p class=MsoNormal><span style='font-size:10.0pt'>   TH3F *decon_resp = new
2283 TH3F(&quot;decon_resp&quot;,&quot;Deconvolution&quot;,nbinsx,xmin,xmax,nbinsy,ymin,ymax,nbinsz,zmin,zmax);  
2284 </span></p>
2285 
2286 <p class=MsoNormal><span style='font-size:10.0pt'>   TFile *f = new
2287 TFile(&quot;TSpectrum3.root&quot;);</span></p>
2288 
2289 <p class=MsoNormal><span style='font-size:10.0pt'>   decon_in=(TH3F*)
2290 f-&gt;Get(&quot;decon_in;1&quot;);</span></p>
2291 
2292 <p class=MsoNormal><span style='font-size:10.0pt'>   decon_resp=(TH3F*)
2293 f-&gt;Get(&quot;decon_resp;1&quot;);   </span></p>
2294 
2295 <p class=MsoNormal><span style='font-size:10.0pt'>   TCanvas *Deconvolution =
2296 new TCanvas(&quot;Deconvolution&quot;,&quot;High resolution deconvolution of
2297 3-dimensional spectra&quot;,10,10,1000,700);</span></p>
2298 
2299 <p class=MsoNormal><span style='font-size:10.0pt'>   TSpectrum3 *s = new
2300 TSpectrum3();</span></p>
2301 
2302 <p class=MsoNormal><span style='font-size:10.0pt'>   for (i = 0; i &lt; nbinsx;
2303 i++){</span></p>
2304 
2305 <p class=MsoNormal><span style='font-size:10.0pt'>     for (j = 0; j &lt;
2306 nbinsy; j++){</span></p>
2307 
2308 <p class=MsoNormal><span style='font-size:10.0pt'>                  for (k = 0;
2309 k &lt; nbinsz; k++){</span></p>
2310 
2311 <p class=MsoNormal><span style='font-size:10.0pt'>                       source[i][j][k]
2312 = decon_in-&gt;GetBinContent(i + 1,j + 1,k + 1);</span></p>
2313 
2314 <p class=MsoNormal><span style='font-size:10.0pt'>                       resp[i][j][k]
2315 = decon_resp-&gt;GetBinContent(i + 1,j + 1,k + 1);                        </span></p>
2316 
2317 <p class=MsoNormal><span style='font-size:10.0pt'>                    } </span></p>
2318 
2319 <p class=MsoNormal><span style='font-size:10.0pt'>                 }</span></p>
2320 
2321 <p class=MsoNormal><span style='font-size:10.0pt'>   }</span></p>
2322 
2323 <p class=MsoNormal><span style='font-size:10.0pt'>  
2324 s-&gt;Deconvolution(source,resp,nbinsx,nbinsy,nbinsz,10,10,2);</span></p>
2325 
2326 <p class=MsoNormal><span style='font-size:10.0pt'>   for (i = 0; i &lt; nbinsx;
2327 i++){</span></p>
2328 
2329 <p class=MsoNormal><span style='font-size:10.0pt'>     for (j = 0; j &lt;
2330 nbinsy; j++){</span></p>
2331 
2332 <p class=MsoNormal><span style='font-size:10.0pt'>        for (k = 0; k &lt;
2333 nbinsz; k++){</span></p>
2334 
2335 <p class=MsoNormal><span style='font-size:10.0pt'>          
2336 decon_in-&gt;SetBinContent(i + 1,j + 1,k + 1, source[i][j][k]);</span></p>
2337 
2338 <p class=MsoNormal><span style='font-size:10.0pt'>        }    </span></p>
2339 
2340 <p class=MsoNormal><span style='font-size:10.0pt'>     }</span></p>
2341 
2342 <p class=MsoNormal><span style='font-size:10.0pt'>   }</span></p>
2343 
2344 <p class=MsoNormal><span style='font-size:10.0pt'>  
2345 decon_in-&gt;Draw(&quot;&quot;);  </span></p>
2346 
2347 <p class=MsoNormal><span style='font-size:10.0pt'>}</span></p>
2348 
2349 <p class=MsoNormal style='text-align:justify'><span style='font-size:16.0pt'>&nbsp;</span></p>
2350 
2351 <p class=MsoNormal style='text-align:justify'><span style='font-size:16.0pt'>&nbsp;</span></p>
2352 
2353 </div>
2354 
2355  */
2356 
2357  Int_t i, j, k, lhx, lhy, lhz, i1, i2, i3, j1, j2, j3, k1, k2, k3, lindex, i1min, i1max, i2min, i2max, i3min, i3max, j1min, j1max, j2min, j2max, j3min, j3max, positx = 0, posity = 0, positz = 0, repet;
2358  Double_t lda, ldb, ldc, area, maximum = 0;
2359  if (ssizex <= 0 || ssizey <= 0 || ssizez <= 0)
2360  return "Wrong parameters";
2361  if (numberIterations <= 0)
2362  return "Number of iterations must be positive";
2363  if (numberRepetitions <= 0)
2364  return "Number of repetitions must be positive";
2365  Double_t ***working_space=new Double_t** [ssizex];
2366  for(i=0;i<ssizex;i++){
2367  working_space[i]=new Double_t* [ssizey];
2368  for(j=0;j<ssizey;j++)
2369  working_space[i][j]=new Double_t [5*ssizez];
2370  }
2371  area = 0;
2372  lhx = -1, lhy = -1, lhz = -1;
2373  for (i = 0; i < ssizex; i++) {
2374  for (j = 0; j < ssizey; j++) {
2375  for (k = 0; k < ssizez; k++) {
2376  lda = resp[i][j][k];
2377  if (lda != 0) {
2378  if ((i + 1) > lhx)
2379  lhx = i + 1;
2380  if ((j + 1) > lhy)
2381  lhy = j + 1;
2382  if ((k + 1) > lhz)
2383  lhz = k + 1;
2384  }
2385  working_space[i][j][k] = lda;
2386  area = area + lda;
2387  if (lda > maximum) {
2388  maximum = lda;
2389  positx = i, posity = j, positz = k;
2390  }
2391  }
2392  }
2393  }
2394  if (lhx == -1 || lhy == -1 || lhz == -1) {
2395  delete [] working_space;
2396  return ("Zero response data");
2397  }
2398 
2399 //calculate ht*y and write into p
2400  for (i3 = 0; i3 < ssizez; i3++) {
2401  for (i2 = 0; i2 < ssizey; i2++) {
2402  for (i1 = 0; i1 < ssizex; i1++) {
2403  ldc = 0;
2404  for (j3 = 0; j3 <= (lhz - 1); j3++) {
2405  for (j2 = 0; j2 <= (lhy - 1); j2++) {
2406  for (j1 = 0; j1 <= (lhx - 1); j1++) {
2407  k3 = i3 + j3, k2 = i2 + j2, k1 = i1 + j1;
2408  if (k3 >= 0 && k3 < ssizez && k2 >= 0 && k2 < ssizey && k1 >= 0 && k1 < ssizex) {
2409  lda = working_space[j1][j2][j3];
2410  ldb = source[k1][k2][k3];
2411  ldc = ldc + lda * ldb;
2412  }
2413  }
2414  }
2415  }
2416  working_space[i1][i2][i3 + ssizez] = ldc;
2417  }
2418  }
2419  }
2420 
2421 //calculate matrix b=ht*h
2422  i1min = -(lhx - 1), i1max = lhx - 1;
2423  i2min = -(lhy - 1), i2max = lhy - 1;
2424  i3min = -(lhz - 1), i3max = lhz - 1;
2425  for (i3 = i3min; i3 <= i3max; i3++) {
2426  for (i2 = i2min; i2 <= i2max; i2++) {
2427  for (i1 = i1min; i1 <= i1max; i1++) {
2428  ldc = 0;
2429  j3min = -i3;
2430  if (j3min < 0)
2431  j3min = 0;
2432  j3max = lhz - 1 - i3;
2433  if (j3max > lhz - 1)
2434  j3max = lhz - 1;
2435  for (j3 = j3min; j3 <= j3max; j3++) {
2436  j2min = -i2;
2437  if (j2min < 0)
2438  j2min = 0;
2439  j2max = lhy - 1 - i2;
2440  if (j2max > lhy - 1)
2441  j2max = lhy - 1;
2442  for (j2 = j2min; j2 <= j2max; j2++) {
2443  j1min = -i1;
2444  if (j1min < 0)
2445  j1min = 0;
2446  j1max = lhx - 1 - i1;
2447  if (j1max > lhx - 1)
2448  j1max = lhx - 1;
2449  for (j1 = j1min; j1 <= j1max; j1++) {
2450  lda = working_space[j1][j2][j3];
2451  if (i1 + j1 < ssizex && i2 + j2 < ssizey)
2452  ldb = working_space[i1 + j1][i2 + j2][i3 + j3];
2453  else
2454  ldb = 0;
2455  ldc = ldc + lda * ldb;
2456  }
2457  }
2458  }
2459  working_space[i1 - i1min][i2 - i2min][i3 - i3min + 2 * ssizez ] = ldc;
2460  }
2461  }
2462  }
2463 
2464 //initialization in x1 matrix
2465  for (i3 = 0; i3 < ssizez; i3++) {
2466  for (i2 = 0; i2 < ssizey; i2++) {
2467  for (i1 = 0; i1 < ssizex; i1++) {
2468  working_space[i1][i2][i3 + 3 * ssizez] = 1;
2469  working_space[i1][i2][i3 + 4 * ssizez] = 0;
2470  }
2471  }
2472  }
2473 
2474  //START OF ITERATIONS
2475  for (repet = 0; repet < numberRepetitions; repet++) {
2476  if (repet != 0) {
2477  for (i = 0; i < ssizex; i++) {
2478  for (j = 0; j < ssizey; j++) {
2479  for (k = 0; k < ssizez; k++) {
2480  working_space[i][j][k + 3 * ssizez] = TMath::Power(working_space[i][j][k + 3 * ssizez],boost);
2481  }
2482  }
2483  }
2484  }
2485  for (lindex = 0; lindex < numberIterations; lindex++) {
2486  for (i3 = 0; i3 < ssizez; i3++) {
2487  for (i2 = 0; i2 < ssizey; i2++) {
2488  for (i1 = 0; i1 < ssizex; i1++) {
2489  ldb = 0;
2490  j3min = i3;
2491  if (j3min > lhz - 1)
2492  j3min = lhz - 1;
2493  j3min = -j3min;
2494  j3max = ssizez - i3 - 1;
2495  if (j3max > lhz - 1)
2496  j3max = lhz - 1;
2497  j2min = i2;
2498  if (j2min > lhy - 1)
2499  j2min = lhy - 1;
2500  j2min = -j2min;
2501  j2max = ssizey - i2 - 1;
2502  if (j2max > lhy - 1)
2503  j2max = lhy - 1;
2504  j1min = i1;
2505  if (j1min > lhx - 1)
2506  j1min = lhx - 1;
2507  j1min = -j1min;
2508  j1max = ssizex - i1 - 1;
2509  if (j1max > lhx - 1)
2510  j1max = lhx - 1;
2511  for (j3 = j3min; j3 <= j3max; j3++) {
2512  for (j2 = j2min; j2 <= j2max; j2++) {
2513  for (j1 = j1min; j1 <= j1max; j1++) {
2514  ldc = working_space[j1 - i1min][j2 - i2min][j3 - i3min + 2 * ssizez];
2515  lda = working_space[i1 + j1][i2 + j2][i3 + j3 + 3 * ssizez];
2516  ldb = ldb + lda * ldc;
2517  }
2518  }
2519  }
2520  lda = working_space[i1][i2][i3 + 3 * ssizez];
2521  ldc = working_space[i1][i2][i3 + 1 * ssizez];
2522  if (ldc * lda != 0 && ldb != 0) {
2523  lda = lda * ldc / ldb;
2524  }
2525 
2526  else
2527  lda = 0;
2528  working_space[i1][i2][i3 + 4 * ssizez] = lda;
2529  }
2530  }
2531  }
2532  for (i3 = 0; i3 < ssizez; i3++) {
2533  for (i2 = 0; i2 < ssizey; i2++) {
2534  for (i1 = 0; i1 < ssizex; i1++)
2535  working_space[i1][i2][i3 + 3 * ssizez] = working_space[i1][i2][i3 + 4 * ssizez];
2536  }
2537  }
2538  }
2539  }
2540  for (i = 0; i < ssizex; i++) {
2541  for (j = 0; j < ssizey; j++){
2542  for (k = 0; k < ssizez; k++)
2543  source[(i + positx) % ssizex][(j + posity) % ssizey][(k + positz) % ssizez] = area * working_space[i][j][k + 3 * ssizez];
2544  }
2545  }
2546  delete [] working_space;
2547  return 0;
2548 }
2549 
2550 ////////////////////////////////////////////////////////////////////////////////
2551 
2552 Int_t TSpectrum3::SearchHighRes(const Double_t***source,Double_t***dest, Int_t ssizex, Int_t ssizey, Int_t ssizez,
2553  Double_t sigma, Double_t threshold,
2554  Bool_t backgroundRemove,Int_t deconIterations,
2555  Bool_t markov, Int_t averWindow)
2556 
2557 {
2558 /////////////////////////////////////////////////////////////////////////////
2559 // THREE-DIMENSIONAL HIGH-RESOLUTION PEAK SEARCH FUNCTION //
2560 // This function searches for peaks in source spectrum //
2561 // It is based on deconvolution method. First the background is //
2562 // removed (if desired), then Markov spectrum is calculated //
2563 // (if desired), then the response function is generated //
2564 // according to given sigma and deconvolution is carried out. //
2565 // It returns number of found peaks. //
2566 // //
2567 // Function parameters: //
2568 // source-pointer to the matrix of source spectrum //
2569 // dest-pointer to the matrix of resulting deconvolved spectrum //
2570 // ssizex-x length of source spectrum //
2571 // ssizey-y length of source spectrum //
2572 // ssizez-z length of source spectrum //
2573 // sigma-sigma of searched peaks, for details we refer to manual //
2574 // threshold-threshold value in % for selected peaks, peaks with //
2575 // amplitude less than threshold*highest_peak/100 //
2576 // are ignored, see manual //
2577 // backgroundRemove-logical variable, set if the removal of //
2578 // background before deconvolution is desired //
2579 // deconIterations-number of iterations in deconvolution operation //
2580 // markov-logical variable, if it is true, first the source spectrum //
2581 // is replaced by new spectrum calculated using Markov //
2582 // chains method. //
2583 // averWindow-averanging window of searched peaks, for details //
2584 // we refer to manual (applies only for Markov method) //
2585 // //
2586 /////////////////////////////////////////////////////////////////////////////
2587 /*
2588 
2589 <div class=Section4>
2590 
2591 <p class=MsoNormal><b><span style='font-size:14.0pt'>Peaks searching</span></b></p>
2592 
2593 <p class=MsoNormal style='text-align:justify'><i>&nbsp;</i></p>
2594 
2595 <p class=MsoNormal style='text-align:justify'><i>Goal: to identify
2596 automatically the peaks in spectrum with the presence of the continuous
2597 background, one- and two-fold coincidences (ridges) and statistical
2598 fluctuations - noise.</i> </p>
2599 
2600 <p class=MsoNormal><span style='font-family:Arial'>&nbsp;</span></p>
2601 
2602 <p class=MsoNormal style='text-align:justify'>The common problems connected
2603 with correct peak identification in three-dimensional coincidence spectra are</p>
2604 
2605 <ul style='margin-top:0mm' type=disc>
2606  <li class=MsoNormal style='text-align:justify'>non-sensitivity to noise, i.e.,
2607  only statistically relevant peaks should be identified</li>
2608  <li class=MsoNormal style='text-align:justify'>non-sensitivity of the
2609  algorithm to continuous background</li>
2610  <li class=MsoNormal style='text-align:justify'>non-sensitivity to one-fold coincidences
2611  (coincidences peak – peak – background in all dimensions) and their
2612  crossings</li>
2613  <li class=MsoNormal style='text-align:justify'>non-sensitivity to two-fold
2614  coincidences (coincidences peak – background – background in all
2615  dimensions) and their crossings</li>
2616  <li class=MsoNormal style='text-align:justify'>ability to identify peaks close
2617  to the edges of the spectrum region</li>
2618  <li class=MsoNormal style='text-align:justify'>resolution, decomposition of
2619  doublets and multiplets. The algorithm should be able to recognize close
2620  positioned peaks. </li>
2621 </ul>
2622 
2623 <p class=MsoNormal><i>&nbsp;</i></p>
2624 
2625 <p class=MsoNormal><i>Function:</i></p>
2626 
2627 <p class=MsoNormal style='text-align:justify'><b><a
2628 href="http://root.cern.ch/root/html/ListOfTypes.html#Int_t">Int_t</a> </b><a
2629 name="TSpectrum:Search1HighRes"></a><a
2630 href="http://root.cern.ch/root/html/TSpectrum.html#TSpectrum:Fit1Awmi"><b>TSpectrum3::SearchHighRes</b></a><b>
2631 (const <a href="http://root.cern.ch/root/html/ListOfTypes.html#double">double</a>
2632 ***fSource,<a href="http://root.cern.ch/root/html/ListOfTypes.html#double">double</a>
2633 ***fDest, <a href="http://root.cern.ch/root/html/ListOfTypes.html#int">int</a>
2634 fSizex, <a href="http://root.cern.ch/root/html/ListOfTypes.html#int">int</a>
2635 fSizey, <a href="http://root.cern.ch/root/html/ListOfTypes.html#int">int</a>
2636 fSizez, <a href="http://root.cern.ch/root/html/ListOfTypes.html#double">double</a>
2637 fSigma, <a href="http://root.cern.ch/root/html/ListOfTypes.html#double">double</a>
2638 fThreshold, <a href="http://root.cern.ch/root/html/ListOfTypes.html#bool">bool</a>
2639 fBackgroundRemove,<a href="http://root.cern.ch/root/html/ListOfTypes.html#int">int</a>
2640 fDeconIterations, <a href="http://root.cern.ch/root/html/ListOfTypes.html#bool">bool</a>
2641 fMarkov, <a href="http://root.cern.ch/root/html/ListOfTypes.html#int">int</a>
2642 fAverWindow)   </b></p>
2643 
2644 <p class=MsoNormal>&nbsp;</p>
2645 
2646 <p class=MsoNormal style='text-align:justify'>This function searches for peaks
2647 in source spectrum. It is based on deconvolution method. First the background
2648 is removed (if desired), then Markov smoothed spectrum is calculated (if
2649 desired), then the response function is generated according to given sigma and
2650 deconvolution is carried out. On success it returns number of found peaks.</p>
2651 
2652 <p class=MsoNormal>&nbsp;</p>
2653 
2654 <p class=MsoNormal><i><span style='color:red'>Parameters:</span></i></p>
2655 
2656 <p class=MsoNormal style='text-align:justify'>        <b>fSource</b>-pointer to
2657 the matrix of source spectrum                  </p>
2658 
2659 <p class=MsoNormal style='text-align:justify'>        <b>fDest</b>-resulting
2660 spectrum after deconvolution</p>
2661 
2662 <p class=MsoNormal style='text-align:justify'>        <b>fSizex, fSizey, fSizez</b>
2663 -lengths of the source and destination spectra                </p>
2664 
2665 <p class=MsoNormal style='text-align:justify'>        <b>fSigma</b>-sigma of
2666 searched peaks</p>
2667 
2668 <p class=MsoNormal style='margin-left:22.8pt;text-align:justify'><b>fThreshold</b>-
2669 threshold value in % for selected peaks, peaks with amplitude less than
2670 threshold*highest_peak/100 are ignored</p>
2671 
2672 <p class=MsoNormal style='margin-left:22.8pt;text-align:justify'><b>fBackgroundRemove</b>-
2673 background_remove-logical variable, true if the removal of background before
2674 deconvolution is desired  </p>
2675 
2676 <p class=MsoNormal style='margin-left:22.8pt;text-align:justify'><b>fDeconIterations</b>-number
2677 of iterations in deconvolution operation</p>
2678 
2679 <p class=MsoNormal style='margin-left:22.8pt;text-align:justify'><b>fMarkov</b>-logical
2680 variable, if it is true, first the source spectrum is replaced by new spectrum
2681 calculated using Markov chains method </p>
2682 
2683 <p class=MsoNormal style='margin-left:19.95pt;text-align:justify;text-indent:
2684 2.85pt'><b>fAverWindow</b>-width of averaging smoothing window </p>
2685 
2686 <p class=MsoNormal>&nbsp;</p>
2687 
2688 <p class=MsoNormal><b><i>References:</i></b></p>
2689 
2690 <p class=MsoNormal style='text-align:justify'>[1] M.A. Mariscotti: A method for
2691 identification of peaks in the presence of background and its application to
2692 spectrum analysis. NIM 50 (1967), 309-320.</p>
2693 
2694 <p class=MsoNormal style='text-align:justify'>[2] <span lang=SK> M.
2695 Morhá&#269;, J. Kliman, V. Matoušek, M. Veselský, I. Turzo</span>.:Identification
2696 of peaks in multidimensional coincidence gamma-ray spectra. NIM, A443 (2000)
2697 108-125.</p>
2698 
2699 <p class=MsoNormal style='text-align:justify'>[3] Z.K. Silagadze, A new
2700 algorithm for automatic photopeak searches. NIM A 376 (1996), 451.</p>
2701 
2702 <p class=MsoNormal style='text-align:justify'>&nbsp;</p>
2703 
2704 <p class=MsoNormal><b>Example of peak searching method</b></p>
2705 
2706 <p class=MsoNormal>&nbsp;</p>
2707 
2708 <p class=MsoNormal style='text-align:justify'><a
2709 href="http://root.cern.ch/root/html/src/TSpectrum.cxx.html#TSpectrum:Search1HighRes"
2710 target="_parent">SearchHighRes</a> function provides users with the possibility
2711 to vary the input parameters and with the access to the output deconvolved data
2712 in the destination spectrum. Based on the output data one can tune the
2713 parameters. </p>
2714 
2715 <p class=MsoNormal><i>Example 1 – script Search3.c:</i></p>
2716 
2717 <p class=MsoNormal>&nbsp;</p>
2718 
2719 <p class=MsoNormal><img border=0 width=601 height=368
2720 src="gif/spectrum3_searching_image001.jpg"></p>
2721 
2722 <p class=MsoNormal style='text-align:justify'><b>Fig. 1 Three-dimensional
2723 spectrum with 5 peaks (<sub><img border=0 width=40 height=19
2724 src="gif/spectrum3_searching_image002.gif"></sub>, threshold=5%, 3 iterations steps in
2725 the deconvolution)</b></p>
2726 
2727 <p class=MsoNormal style='text-align:justify'><b>&nbsp;</b></p>
2728 
2729 <p class=MsoNormal style='text-align:justify'><b><img border=0 width=601
2730 height=368 src="gif/spectrum3_searching_image003.jpg"></b></p>
2731 
2732 <p class=MsoNormal style='text-align:justify'><b>Fig. 2 Spectrum from Fig. 1
2733 after background elimination and deconvolution</b></p>
2734 
2735 <p class=MsoNormal><b><span style='color:#339966'>&nbsp;</span></b></p>
2736 
2737 <p class=MsoNormal><b><span style='color:#339966'>Script:</span></b></p>
2738 
2739 <p class=MsoNormal><span style='font-size:10.0pt'>// Example to illustrate high
2740 resolution peak searching function (class TSpectrum3).</span></p>
2741 
2742 <p class=MsoNormal><span style='font-size:10.0pt'>// To execute this example,
2743 do</span></p>
2744 
2745 <p class=MsoNormal><span style='font-size:10.0pt'>// root &gt; .x Search3.C</span></p>
2746 
2747 <p class=MsoNormal><span style='font-size:10.0pt'>void Search3() {</span></p>
2748 
2749 <p class=MsoNormal><span style='font-size:10.0pt'>   Int_t i, j, k, nfound;</span></p>
2750 
2751 <p class=MsoNormal><span style='font-size:10.0pt'>   </span><span lang=FR
2752 style='font-size:10.0pt'>Int_t nbinsx = 32;</span></p>
2753 
2754 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t nbinsy = 32;</span></p>
2755 
2756 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t nbinsz =
2757 32;   </span></p>
2758 
2759 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t xmin  = 0;</span></p>
2760 
2761 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t xmax  =
2762 nbinsx;</span></p>
2763 
2764 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t ymin  = 0;</span></p>
2765 
2766 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t ymax  =
2767 nbinsy;   </span></p>
2768 
2769 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   Int_t zmin  = 0;</span></p>
2770 
2771 <p class=MsoNormal><span lang=FR style='font-size:10.0pt'>   </span><span
2772 style='font-size:10.0pt'>Int_t zmax  = nbinsz;      </span></p>
2773 
2774 <p class=MsoNormal><span style='font-size:10.0pt'>   Double_t*** source = new
2775 Double_t**[nbinsx];</span></p>
2776 
2777 <p class=MsoNormal><span style='font-size:10.0pt'>   Double_t*** dest = new Double_t
2778 **[nbinsx];      </span></p>
2779 
2780 <p class=MsoNormal><span style='font-size:10.0pt'>   for(i=0;i&lt;nbinsx;i++){</span></p>
2781 
2782 <p class=MsoNormal><span style='font-size:10.0pt'>      source[i]=new Double_t*
2783 [nbinsy];</span></p>
2784 
2785 <p class=MsoNormal><span style='font-size:10.0pt'>     
2786 for(j=0;j&lt;nbinsy;j++)</span></p>
2787 
2788 <p class=MsoNormal><span style='font-size:10.0pt'>         source[i][j]=new
2789 Double_t[nbinsz];</span></p>
2790 
2791 <p class=MsoNormal><span style='font-size:10.0pt'>   }           </span></p>
2792 
2793 <p class=MsoNormal><span style='font-size:10.0pt'>   for(i=0;i&lt;nbinsx;i++){</span></p>
2794 
2795 <p class=MsoNormal><span style='font-size:10.0pt'>      dest[i]=new Double_t*
2796 [nbinsy];</span></p>
2797 
2798 <p class=MsoNormal><span style='font-size:10.0pt'>     
2799 for(j=0;j&lt;nbinsy;j++)</span></p>
2800 
2801 <p class=MsoNormal><span style='font-size:10.0pt'>         dest[i][j]=new Double_t
2802 [nbinsz];</span></p>
2803 
2804 <p class=MsoNormal><span style='font-size:10.0pt'>   }              </span></p>
2805 
2806 <p class=MsoNormal><span style='font-size:10.0pt'>   TH3F *search = new
2807 TH3F(&quot;Search&quot;,&quot;Peak
2808 searching&quot;,nbinsx,xmin,xmax,nbinsy,ymin,ymax,nbinsz,zmin,zmax);</span></p>
2809 
2810 <p class=MsoNormal><span style='font-size:10.0pt'>   TFile *f = new
2811 TFile(&quot;TSpectrum3.root&quot;);</span></p>
2812 
2813 <p class=MsoNormal><span style='font-size:10.0pt'>   search=(TH3F*)
2814 f-&gt;Get(&quot;search2;1&quot;);   </span></p>
2815 
2816 <p class=MsoNormal><span style='font-size:10.0pt'>   TCanvas *Search = new
2817 TCanvas(&quot;Search&quot;,&quot;Peak searching&quot;,10,10,1000,700);</span></p>
2818 
2819 <p class=MsoNormal><span style='font-size:10.0pt'>   TSpectrum3 *s = new
2820 TSpectrum3();</span></p>
2821 
2822 <p class=MsoNormal><span style='font-size:10.0pt'>   for (i = 0; i &lt; nbinsx;
2823 i++){</span></p>
2824 
2825 <p class=MsoNormal><span style='font-size:10.0pt'>     for (j = 0; j &lt;
2826 nbinsy; j++){</span></p>
2827 
2828 <p class=MsoNormal><span style='font-size:10.0pt'>                  for (k = 0;
2829 k &lt; nbinsz; k++){</span></p>
2830 
2831 <p class=MsoNormal><span style='font-size:10.0pt'>                       source[i][j][k]
2832 = search-&gt;GetBinContent(i + 1,j + 1,k + 1);</span></p>
2833 
2834 <p class=MsoNormal><span style='font-size:10.0pt'>                    } </span></p>
2835 
2836 <p class=MsoNormal><span style='font-size:10.0pt'>                 }</span></p>
2837 
2838 <p class=MsoNormal><span style='font-size:10.0pt'>   }</span></p>
2839 
2840 <p class=MsoNormal><span style='font-size:10.0pt'>   nfound =
2841 s-&gt;SearchHighRes(source, dest, nbinsx, nbinsy, nbinsz, 2, 5, kTRUE, 3,
2842 kFALSE, 3);   </span></p>
2843 
2844 <p class=MsoNormal><span style='font-size:10.0pt'>   printf(&quot;Found %d
2845 candidate peaks\n&quot;,nfound);   </span></p>
2846 
2847 <p class=MsoNormal><span style='font-size:10.0pt'>   for (i = 0; i &lt; nbinsx;
2848 i++){</span></p>
2849 
2850 <p class=MsoNormal><span style='font-size:10.0pt'>     for (j = 0; j &lt;
2851 nbinsy; j++){</span></p>
2852 
2853 <p class=MsoNormal><span style='font-size:10.0pt'>        for (k = 0; k &lt;
2854 nbinsz; k++){</span></p>
2855 
2856 <p class=MsoNormal><span style='font-size:10.0pt'>          
2857 search-&gt;SetBinContent(i + 1,j + 1,k + 1, dest[i][j][k]);</span></p>
2858 
2859 <p class=MsoNormal><span style='font-size:10.0pt'>        }    </span></p>
2860 
2861 <p class=MsoNormal><span style='font-size:10.0pt'>     }</span></p>
2862 
2863 <p class=MsoNormal><span style='font-size:10.0pt'>   }</span></p>
2864 
2865 <p class=MsoNormal><span style='font-size:10.0pt'>   Double_t *PosX = new
2866 Double_t[nfound];         </span></p>
2867 
2868 <p class=MsoNormal><span style='font-size:10.0pt'>   Double_t *PosY = new
2869 Double_t[nfound];</span></p>
2870 
2871 <p class=MsoNormal><span style='font-size:10.0pt'>   Double_t *PosZ = new
2872 Double_t[nfound];      </span></p>
2873 
2874 <p class=MsoNormal><span style='font-size:10.0pt'>   PosX =
2875 s-&gt;GetPositionX();</span></p>
2876 
2877 <p class=MsoNormal><span style='font-size:10.0pt'>   PosY =
2878 s-&gt;GetPositionY();         </span></p>
2879 
2880 <p class=MsoNormal><span style='font-size:10.0pt'>   PosZ =
2881 s-&gt;GetPositionZ();            </span></p>
2882 
2883 <p class=MsoNormal><span style='font-size:10.0pt'>   for(i=0;i&lt;nfound;i++)</span></p>
2884 
2885 <p class=MsoNormal><span style='font-size:10.0pt'>                    </span><span
2886 lang=PL style='font-size:10.0pt'>printf(&quot;posx= %d, posy= %d, posz=
2887 %d\n&quot;,(Int_t)(PosX[i]+0.5), (Int_t)(PosY[i]+0.5),
2888 (Int_t)(PosZ[i]+0.5));           </span></p>
2889 
2890 <p class=MsoNormal><span lang=PL style='font-size:10.0pt'>   </span><span
2891 style='font-size:10.0pt'>search-&gt;Draw(&quot;&quot;);  </span></p>
2892 
2893 <p class=MsoNormal><span style='font-size:10.0pt'>}</span></p>
2894 
2895 </div>
2896 
2897  */
2898 
2899  Int_t number_of_iterations = (Int_t)(4 * sigma + 0.5);
2900  Int_t k,lindex;
2901  Double_t lda,ldb,ldc,area,maximum;
2902  Int_t xmin,xmax,l,peak_index = 0,sizex_ext=ssizex + 4 * number_of_iterations,sizey_ext = ssizey + 4 * number_of_iterations,sizez_ext = ssizez + 4 * number_of_iterations,shift = 2 * number_of_iterations;
2903  Int_t ymin,ymax,zmin,zmax,i,j;
2904  Double_t a,b,maxch,plocha = 0,plocha_markov = 0;
2905  Double_t nom,nip,nim,sp,sm,spx,spy,smx,smy,spz,smz;
2906  Double_t p1,p2,p3,p4,p5,p6,p7,p8,s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11,s12,r1,r2,r3,r4,r5,r6;
2907  Int_t x,y,z;
2908  Double_t pocet_sigma = 5;
2909  Int_t lhx,lhy,lhz,i1,i2,i3,j1,j2,j3,k1,k2,k3,i1min,i1max,i2min,i2max,i3min,i3max,j1min,j1max,j2min,j2max,j3min,j3max,positx,posity,positz;
2910  if(sigma < 1){
2911  Error("SearchHighRes", "Invalid sigma, must be greater than or equal to 1");
2912  return 0;
2913  }
2914 
2915  if(threshold<=0||threshold>=100){
2916  Error("SearchHighRes", "Invalid threshold, must be positive and less than 100");
2917  return 0;
2918  }
2919 
2920  j = (Int_t)(pocet_sigma*sigma+0.5);
2921  if (j >= PEAK_WINDOW / 2) {
2922  Error("SearchHighRes", "Too large sigma");
2923  return 0;
2924  }
2925 
2926  if (markov == true) {
2927  if (averWindow <= 0) {
2928  Error("SearchHighRes", "Averanging window must be positive");
2929  return 0;
2930  }
2931  }
2932 
2933  if(backgroundRemove == true){
2934  if(sizex_ext < 2 * number_of_iterations + 1 || sizey_ext < 2 * number_of_iterations + 1 || sizez_ext < 2 * number_of_iterations + 1){
2935  Error("SearchHighRes", "Too large clipping window");
2936  return 0;
2937  }
2938  }
2939 
2940  i = (Int_t)(4 * sigma + 0.5);
2941  i = 4 * i;
2942  Double_t ***working_space = new Double_t** [ssizex + i];
2943  for(j = 0;j < ssizex + i; j++){
2944  working_space[j] = new Double_t* [ssizey + i];
2945  for(k = 0;k < ssizey + i; k++)
2946  working_space[j][k] = new Double_t [5 * (ssizez + i)];
2947  }
2948  for(k = 0;k < sizez_ext; k++){
2949  for(j = 0;j < sizey_ext; j++){
2950  for(i = 0;i < sizex_ext; i++){
2951  if(i < shift){
2952  if(j < shift){
2953  if(k < shift)
2954  working_space[i][j][k + sizez_ext] = source[0][0][0];
2955 
2956  else if(k >= ssizez + shift)
2957  working_space[i][j][k + sizez_ext] = source[0][0][ssizez - 1];
2958 
2959  else
2960  working_space[i][j][k + sizez_ext] = source[0][0][k - shift];
2961  }
2962 
2963  else if(j >= ssizey + shift){
2964  if(k < shift)
2965  working_space[i][j][k + sizez_ext] = source[0][ssizey - 1][0];
2966 
2967  else if(k >= ssizez + shift)
2968  working_space[i][j][k + sizez_ext] = source[0][ssizey - 1][ssizez - 1];
2969 
2970  else
2971  working_space[i][j][k + sizez_ext] = source[0][ssizey - 1][k - shift];
2972  }
2973 
2974  else{
2975  if(k < shift)
2976  working_space[i][j][k + sizez_ext] = source[0][j - shift][0];
2977 
2978  else if(k >= ssizez + shift)
2979  working_space[i][j][k + sizez_ext] = source[0][j - shift][ssizez - 1];
2980 
2981  else
2982  working_space[i][j][k + sizez_ext] = source[0][j - shift][k - shift];
2983  }
2984  }
2985 
2986  else if(i >= ssizex + shift){
2987  if(j < shift){
2988  if(k < shift)
2989  working_space[i][j][k + sizez_ext] = source[ssizex - 1][0][0];
2990 
2991  else if(k >= ssizez + shift)
2992  working_space[i][j][k + sizez_ext] = source[ssizex - 1][0][ssizez - 1];
2993 
2994  else
2995  working_space[i][j][k + sizez_ext] = source[ssizex - 1][0][k - shift];
2996  }
2997 
2998  else if(j >= ssizey + shift){
2999  if(k < shift)
3000  working_space[i][j][k + sizez_ext] = source[ssizex - 1][ssizey - 1][0];
3001 
3002  else if(k >= ssizez + shift)
3003  working_space[i][j][k + sizez_ext] = source[ssizex - 1][ssizey - 1][ssizez - 1];
3004 
3005  else
3006  working_space[i][j][k + sizez_ext] = source[ssizex - 1][ssizey - 1][k - shift];
3007  }
3008 
3009  else{
3010  if(k < shift)
3011  working_space[i][j][k + sizez_ext] = source[ssizex - 1][j - shift][0];
3012 
3013  else if(k >= ssizez + shift)
3014  working_space[i][j][k + sizez_ext] = source[ssizex - 1][j - shift][ssizez - 1];
3015 
3016  else
3017  working_space[i][j][k + sizez_ext] = source[ssizex - 1][j - shift][k - shift];
3018  }
3019  }
3020 
3021  else{
3022  if(j < shift){
3023  if(k < shift)
3024  working_space[i][j][k + sizez_ext] = source[i - shift][0][0];
3025 
3026  else if(k >= ssizez + shift)
3027  working_space[i][j][k + sizez_ext] = source[i - shift][0][ssizez - 1];
3028 
3029  else
3030  working_space[i][j][k + sizez_ext] = source[i - shift][0][k - shift];
3031  }
3032 
3033  else if(j >= ssizey + shift){
3034  if(k < shift)
3035  working_space[i][j][k + sizez_ext] = source[i - shift][ssizey - 1][0];
3036 
3037  else if(k >= ssizez + shift)
3038  working_space[i][j][k + sizez_ext] = source[i - shift][ssizey - 1][ssizez - 1];
3039 
3040  else
3041  working_space[i][j][k + sizez_ext] = source[i - shift][ssizey - 1][k - shift];
3042  }
3043 
3044  else{
3045  if(k < shift)
3046  working_space[i][j][k + sizez_ext] = source[i - shift][j - shift][0];
3047 
3048  else if(k >= ssizez + shift)
3049  working_space[i][j][k + sizez_ext] = source[i - shift][j - shift][ssizez - 1];
3050 
3051  else
3052  working_space[i][j][k + sizez_ext] = source[i - shift][j - shift][k - shift];
3053  }
3054  }
3055  }
3056  }
3057  }
3058  if(backgroundRemove == true){
3059  for(i = 1;i <= number_of_iterations; i++){
3060  for(z = i;z < sizez_ext - i; z++){
3061  for(y = i;y < sizey_ext - i; y++){
3062  for(x = i;x < sizex_ext - i; x++){
3063  a = working_space[x][y][z + sizez_ext];
3064  p1 = working_space[x + i][y + i][z - i + sizez_ext];
3065  p2 = working_space[x - i][y + i][z - i + sizez_ext];
3066  p3 = working_space[x + i][y - i][z - i + sizez_ext];
3067  p4 = working_space[x - i][y - i][z - i + sizez_ext];
3068  p5 = working_space[x + i][y + i][z + i + sizez_ext];
3069  p6 = working_space[x - i][y + i][z + i + sizez_ext];
3070  p7 = working_space[x + i][y - i][z + i + sizez_ext];
3071  p8 = working_space[x - i][y - i][z + i + sizez_ext];
3072  s1 = working_space[x + i][y ][z - i + sizez_ext];
3073  s2 = working_space[x ][y + i][z - i + sizez_ext];
3074  s3 = working_space[x - i][y ][z - i + sizez_ext];
3075  s4 = working_space[x ][y - i][z - i + sizez_ext];
3076  s5 = working_space[x + i][y ][z + i + sizez_ext];
3077  s6 = working_space[x ][y + i][z + i + sizez_ext];
3078  s7 = working_space[x - i][y ][z + i + sizez_ext];
3079  s8 = working_space[x ][y - i][z + i + sizez_ext];
3080  s9 = working_space[x - i][y + i][z + sizez_ext];
3081  s10 = working_space[x - i][y - i][z +sizez_ext];
3082  s11 = working_space[x + i][y + i][z +sizez_ext];
3083  s12 = working_space[x + i][y - i][z +sizez_ext];
3084  r1 = working_space[x ][y ][z - i + sizez_ext];
3085  r2 = working_space[x ][y ][z + i + sizez_ext];
3086  r3 = working_space[x - i][y ][z + sizez_ext];
3087  r4 = working_space[x + i][y ][z + sizez_ext];
3088  r5 = working_space[x ][y + i][z + sizez_ext];
3089  r6 = working_space[x ][y - i][z + sizez_ext];
3090  b = (p1 + p3) / 2.0;
3091  if(b > s1)
3092  s1 = b;
3093 
3094  b = (p1 + p2) / 2.0;
3095  if(b > s2)
3096  s2 = b;
3097 
3098  b = (p2 + p4) / 2.0;
3099  if(b > s3)
3100  s3 = b;
3101 
3102  b = (p3 + p4) / 2.0;
3103  if(b > s4)
3104  s4 = b;
3105 
3106  b = (p5 + p7) / 2.0;
3107  if(b > s5)
3108  s5 = b;
3109 
3110  b = (p5 + p6) / 2.0;
3111  if(b > s6)
3112  s6 = b;
3113 
3114  b = (p6 + p8) / 2.0;
3115  if(b > s7)
3116  s7 = b;
3117 
3118  b = (p7 + p8) / 2.0;
3119  if(b > s8)
3120  s8 = b;
3121 
3122  b = (p2 + p6) / 2.0;
3123  if(b > s9)
3124  s9 = b;
3125 
3126  b = (p4 + p8) / 2.0;
3127  if(b > s10)
3128  s10 = b;
3129 
3130  b = (p1 + p5) / 2.0;
3131  if(b > s11)
3132  s11 = b;
3133 
3134  b = (p3 + p7) / 2.0;
3135  if(b > s12)
3136  s12 = b;
3137 
3138  s1 = s1 - (p1 + p3) / 2.0;
3139  s2 = s2 - (p1 + p2) / 2.0;
3140  s3 = s3 - (p2 + p4) / 2.0;
3141  s4 = s4 - (p3 + p4) / 2.0;
3142  s5 = s5 - (p5 + p7) / 2.0;
3143  s6 = s6 - (p5 + p6) / 2.0;
3144  s7 = s7 - (p6 + p8) / 2.0;
3145  s8 = s8 - (p7 + p8) / 2.0;
3146  s9 = s9 - (p2 + p6) / 2.0;
3147  s10 = s10 - (p4 + p8) / 2.0;
3148  s11 = s11 - (p1 + p5) / 2.0;
3149  s12 = s12 - (p3 + p7) / 2.0;
3150  b = (s1 + s3) / 2.0 + (s2 + s4) / 2.0 + (p1 + p2 + p3 + p4) / 4.0;
3151  if(b > r1)
3152  r1 = b;
3153 
3154  b = (s5 + s7) / 2.0 + (s6 + s8) / 2.0 + (p5 + p6 + p7 + p8) / 4.0;
3155  if(b > r2)
3156  r2 = b;
3157 
3158  b = (s3 + s7) / 2.0 + (s9 + s10) / 2.0 + (p2 + p4 + p6 + p8) / 4.0;
3159  if(b > r3)
3160  r3 = b;
3161 
3162  b = (s1 + s5) / 2.0 + (s11 + s12) / 2.0 + (p1 + p3 + p5 + p7) / 4.0;
3163  if(b > r4)
3164  r4 = b;
3165 
3166  b = (s9 + s11) / 2.0 + (s2 + s6) / 2.0 + (p1 + p2 + p5 + p6) / 4.0;
3167  if(b > r5)
3168  r5 = b;
3169 
3170  b = (s4 + s8) / 2.0 + (s10 + s12) / 2.0 + (p3 + p4 + p7 + p8) / 4.0;
3171  if(b > r6)
3172  r6 = b;
3173 
3174  r1 = r1 - ((s1 + s3) / 2.0 + (s2 + s4) / 2.0 + (p1 + p2 + p3 + p4) / 4.0);
3175  r2 = r2 - ((s5 + s7) / 2.0 + (s6 + s8) / 2.0 + (p5 + p6 + p7 + p8) / 4.0);
3176  r3 = r3 - ((s3 + s7) / 2.0 + (s9 + s10) / 2.0 + (p2 + p4 + p6 + p8) / 4.0);
3177  r4 = r4 - ((s1 + s5) / 2.0 + (s11 + s12) / 2.0 + (p1 + p3 + p5 + p7) / 4.0);
3178  r5 = r5 - ((s9 + s11) / 2.0 + (s2 + s6) / 2.0 + (p1 + p2 + p5 + p6) / 4.0);
3179  r6 = r6 - ((s4 + s8) / 2.0 + (s10 + s12) / 2.0 + (p3 + p4 + p7 + p8) / 4.0);
3180  b = (r1 + r2) / 2.0 + (r3 + r4) / 2.0 + (r5 + r6) / 2.0 + (s1 + s3 + s5 + s7) / 4.0 + (s2 + s4 + s6 + s8) / 4.0 + (s9 + s10 + s11 + s12) / 4.0 + (p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8) / 8.0;
3181  if(b < a)
3182  a = b;
3183 
3184  working_space[x][y][z] = a;
3185  }
3186  }
3187  }
3188  for(z = i;z < sizez_ext - i; z++){
3189  for(y = i;y < sizey_ext - i; y++){
3190  for(x = i;x < sizex_ext - i; x++){
3191  working_space[x][y][z + sizez_ext] = working_space[x][y][z];
3192  }
3193  }
3194  }
3195  }
3196  for(k = 0;k < sizez_ext; k++){
3197  for(j = 0;j < sizey_ext; j++){
3198  for(i = 0;i < sizex_ext; i++){
3199  if(i < shift){
3200  if(j < shift){
3201  if(k < shift)
3202  working_space[i][j][k + sizez_ext] = source[0][0][0] - working_space[i][j][k + sizez_ext];
3203 
3204  else if(k >= ssizez + shift)
3205  working_space[i][j][k + sizez_ext] = source[0][0][ssizez - 1] - working_space[i][j][k + sizez_ext];
3206 
3207  else
3208  working_space[i][j][k + sizez_ext] = source[0][0][k - shift] - working_space[i][j][k + sizez_ext];
3209  }
3210 
3211  else if(j >= ssizey + shift){
3212  if(k < shift)
3213  working_space[i][j][k + sizez_ext] = source[0][ssizey - 1][0] - working_space[i][j][k + sizez_ext];
3214 
3215  else if(k >= ssizez + shift)
3216  working_space[i][j][k + sizez_ext] = source[0][ssizey - 1][ssizez - 1] - working_space[i][j][k + sizez_ext];
3217 
3218  else
3219  working_space[i][j][k + sizez_ext] = source[0][ssizey - 1][k - shift] - working_space[i][j][k + sizez_ext];
3220  }
3221 
3222  else{
3223  if(k < shift)
3224  working_space[i][j][k + sizez_ext] = source[0][j - shift][0] - working_space[i][j][k + sizez_ext];
3225 
3226  else if(k >= ssizez + shift)
3227  working_space[i][j][k + sizez_ext] = source[0][j - shift][ssizez - 1] - working_space[i][j][k + sizez_ext];
3228 
3229  else
3230  working_space[i][j][k + sizez_ext] = source[0][j - shift][k - shift] - working_space[i][j][k + sizez_ext];
3231  }
3232  }
3233 
3234  else if(i >= ssizex + shift){
3235  if(j < shift){
3236  if(k < shift)
3237  working_space[i][j][k + sizez_ext] = source[ssizex - 1][0][0] - working_space[i][j][k + sizez_ext];
3238 
3239  else if(k >= ssizez + shift)
3240  working_space[i][j][k + sizez_ext] = source[ssizex - 1][0][ssizez - 1] - working_space[i][j][k + sizez_ext];
3241 
3242  else
3243  working_space[i][j][k + sizez_ext] = source[ssizex - 1][0][k - shift] - working_space[i][j][k + sizez_ext];
3244  }
3245 
3246  else if(j >= ssizey + shift){
3247  if(k < shift)
3248  working_space[i][j][k + sizez_ext] = source[ssizex - 1][ssizey - 1][0] - working_space[i][j][k + sizez_ext];
3249 
3250  else if(k >= ssizez + shift)
3251  working_space[i][j][k + sizez_ext] = source[ssizex - 1][ssizey - 1][ssizez - 1] - working_space[i][j][k + sizez_ext];
3252 
3253  else
3254  working_space[i][j][k + sizez_ext] = source[ssizex - 1][ssizey - 1][k - shift] - working_space[i][j][k + sizez_ext];
3255  }
3256 
3257  else{
3258  if(k < shift)
3259  working_space[i][j][k + sizez_ext] = source[ssizex - 1][j - shift][0] - working_space[i][j][k + sizez_ext];
3260 
3261  else if(k >= ssizez + shift)
3262  working_space[i][j][k + sizez_ext] = source[ssizex - 1][j - shift][ssizez - 1] - working_space[i][j][k + sizez_ext];
3263 
3264  else
3265  working_space[i][j][k + sizez_ext] = source[ssizex - 1][j - shift][k - shift] - working_space[i][j][k + sizez_ext];
3266  }
3267  }
3268 
3269  else{
3270  if(j < shift){
3271  if(k < shift)
3272  working_space[i][j][k + sizez_ext] = source[i - shift][0][0] - working_space[i][j][k + sizez_ext];
3273 
3274  else if(k >= ssizez + shift)
3275  working_space[i][j][k + sizez_ext] = source[i - shift][0][ssizez - 1] - working_space[i][j][k + sizez_ext];
3276 
3277  else
3278  working_space[i][j][k + sizez_ext] = source[i - shift][0][k - shift] - working_space[i][j][k + sizez_ext];
3279  }
3280 
3281  else if(j >= ssizey + shift){
3282  if(k < shift)
3283  working_space[i][j][k + sizez_ext] = source[i - shift][ssizey - 1][0] - working_space[i][j][k + sizez_ext];
3284 
3285  else if(k >= ssizez + shift)
3286  working_space[i][j][k + sizez_ext] = source[i - shift][ssizey - 1][ssizez - 1] - working_space[i][j][k + sizez_ext];
3287 
3288  else
3289  working_space[i][j][k + sizez_ext] = source[i - shift][ssizey - 1][k - shift] - working_space[i][j][k + sizez_ext];
3290  }
3291 
3292  else{
3293  if(k < shift)
3294  working_space[i][j][k + sizez_ext] = source[i - shift][j - shift][0] - working_space[i][j][k + sizez_ext];
3295 
3296  else if(k >= ssizez + shift)
3297  working_space[i][j][k + sizez_ext] = source[i - shift][j - shift][ssizez - 1] - working_space[i][j][k + sizez_ext];
3298 
3299  else
3300  working_space[i][j][k + sizez_ext] = source[i - shift][j - shift][k - shift] - working_space[i][j][k + sizez_ext];
3301  }
3302  }
3303  }
3304  }
3305  }
3306  }
3307 
3308  if(markov == true){
3309  for(i = 0;i < sizex_ext; i++){
3310  for(j = 0;j < sizey_ext; j++){
3311  for(k = 0;k < sizez_ext; k++){
3312  working_space[i][j][k + 2 * sizez_ext] = working_space[i][j][sizez_ext + k];
3313  plocha_markov = plocha_markov + working_space[i][j][sizez_ext + k];
3314  }
3315  }
3316  }
3317  xmin = 0;
3318  xmax = sizex_ext - 1;
3319  ymin = 0;
3320  ymax = sizey_ext - 1;
3321  zmin = 0;
3322  zmax = sizez_ext - 1;
3323  for(i = 0,maxch = 0;i < sizex_ext; i++){
3324  for(j = 0;j < sizey_ext;j++){
3325  for(k = 0;k < sizez_ext;k++){
3326  working_space[i][j][k] = 0;
3327  if(maxch < working_space[i][j][k + 2 * sizez_ext])
3328  maxch = working_space[i][j][k + 2 * sizez_ext];
3329 
3330  plocha += working_space[i][j][k + 2 * sizez_ext];
3331  }
3332  }
3333  }
3334  if(maxch == 0) {
3335  delete [] working_space;
3336  return 0;
3337  }
3338  nom = 0;
3339  working_space[xmin][ymin][zmin] = 1;
3340  for(i = xmin;i < xmax; i++){
3341  nip = working_space[i][ymin][zmin + 2 * sizez_ext] / maxch;
3342  nim = working_space[i + 1][ymin][zmin + 2 * sizez_ext] / maxch;
3343  sp = 0,sm = 0;
3344  for(l = 1;l <= averWindow; l++){
3345  if((i + l) > xmax)
3346  a = working_space[xmax][ymin][zmin + 2 * sizez_ext] / maxch;
3347 
3348  else
3349  a = working_space[i + l][ymin][zmin + 2 * sizez_ext] / maxch;
3350 
3351  b = a - nip;
3352  if(a + nip <= 0)
3353  a = 1;
3354 
3355  else
3356  a = TMath::Sqrt(a + nip);
3357 
3358  b = b / a;
3359  b = TMath::Exp(b);
3360  sp = sp + b;
3361  if(i - l + 1 < xmin)
3362  a = working_space[xmin][ymin][zmin + 2 * sizez_ext] / maxch;
3363 
3364  else
3365  a = working_space[i - l + 1][ymin][zmin + 2 * sizez_ext] / maxch;
3366 
3367  b = a - nim;
3368  if(a + nim <= 0)
3369  a = 1;
3370 
3371  else
3372  a = TMath::Sqrt(a + nim);
3373 
3374  b = b / a;
3375  b = TMath::Exp(b);
3376  sm = sm + b;
3377  }
3378  a = sp / sm;
3379  a = working_space[i + 1][ymin][zmin] = a * working_space[i][ymin][zmin];
3380  nom = nom + a;
3381  }
3382  for(i = ymin;i < ymax; i++){
3383  nip = working_space[xmin][i][zmin + 2 * sizez_ext] / maxch;
3384  nim = working_space[xmin][i + 1][zmin + 2 * sizez_ext] / maxch;
3385  sp = 0,sm = 0;
3386  for(l = 1;l <= averWindow; l++){
3387  if((i + l) > ymax)
3388  a = working_space[xmin][ymax][zmin + 2 * sizez_ext] / maxch;
3389 
3390  else
3391  a = working_space[xmin][i + l][zmin + 2 * sizez_ext] / maxch;
3392 
3393  b = a - nip;
3394  if(a + nip <= 0)
3395  a = 1;
3396 
3397  else
3398  a = TMath::Sqrt(a + nip);
3399 
3400  b = b / a;
3401  b = TMath::Exp(b);
3402  sp = sp + b;
3403  if(i - l + 1 < ymin)
3404  a = working_space[xmin][ymin][zmin + 2 * sizez_ext] / maxch;
3405 
3406  else
3407  a = working_space[xmin][i - l + 1][zmin + 2 * sizez_ext] / maxch;
3408 
3409  b = a - nim;
3410  if(a + nim <= 0)
3411  a = 1;
3412 
3413  else
3414  a = TMath::Sqrt(a + nim);
3415 
3416  b = b / a;
3417  b = TMath::Exp(b);
3418  sm = sm + b;
3419  }
3420  a = sp / sm;
3421  a = working_space[xmin][i + 1][zmin] = a * working_space[xmin][i][zmin];
3422  nom = nom + a;
3423  }
3424  for(i = zmin;i < zmax;i++){
3425  nip = working_space[xmin][ymin][i + 2 * sizez_ext] / maxch;
3426  nim = working_space[xmin][ymin][i + 1 + 2 * sizez_ext] / maxch;
3427  sp = 0,sm = 0;
3428  for(l = 1;l <= averWindow;l++){
3429  if((i + l) > zmax)
3430  a = working_space[xmin][ymin][zmax + 2 * sizez_ext] / maxch;
3431 
3432  else
3433  a = working_space[xmin][ymin][i + l + 2 * sizez_ext] / maxch;
3434 
3435  b = a - nip;
3436  if(a + nip <= 0)
3437  a = 1;
3438 
3439  else
3440  a = TMath::Sqrt(a + nip);
3441 
3442  b = b / a;
3443  b = TMath::Exp(b);
3444  sp = sp + b;
3445  if(i - l + 1 < zmin)
3446  a = working_space[xmin][ymin][zmin + 2 * sizez_ext] / maxch;
3447 
3448  else
3449  a = working_space[xmin][ymin][i - l + 1 + 2 * sizez_ext] / maxch;
3450 
3451  b = a - nim;
3452  if(a + nim <= 0)
3453  a = 1;
3454 
3455  else
3456  a = TMath::Sqrt(a + nim);
3457 
3458  b = b / a;
3459  b = TMath::Exp(b);
3460  sm = sm + b;
3461  }
3462  a = sp / sm;
3463  a = working_space[xmin][ymin][i + 1] = a * working_space[xmin][ymin][i];
3464  nom = nom + a;
3465  }
3466  for(i = xmin;i < xmax; i++){
3467  for(j = ymin;j < ymax; j++){
3468  nip = working_space[i][j + 1][zmin + 2 * sizez_ext] / maxch;
3469  nim = working_space[i + 1][j + 1][zmin + 2 * sizez_ext] / maxch;
3470  spx = 0,smx = 0;
3471  for(l = 1;l <= averWindow; l++){
3472  if(i + l > xmax)
3473  a = working_space[xmax][j][zmin + 2 * sizez_ext] / maxch;
3474 
3475  else
3476  a = working_space[i + l][j][zmin + 2 * sizez_ext] / maxch;
3477 
3478  b = a - nip;
3479  if(a + nip <= 0)
3480  a = 1;
3481 
3482  else
3483  a = TMath::Sqrt(a + nip);
3484 
3485  b = b / a;
3486  b = TMath::Exp(b);
3487  spx = spx + b;
3488  if(i - l + 1 < xmin)
3489  a = working_space[xmin][j][zmin + 2 * sizez_ext] / maxch;
3490 
3491  else
3492  a = working_space[i - l + 1][j][zmin + 2 * sizez_ext] / maxch;
3493 
3494  b = a - nim;
3495  if(a + nim <= 0)
3496  a = 1;
3497 
3498  else
3499  a = TMath::Sqrt(a + nim);
3500 
3501  b = b / a;
3502  b = TMath::Exp(b);
3503  smx = smx + b;
3504  }
3505  spy = 0,smy = 0;
3506  nip = working_space[i + 1][j][zmin + 2 * sizez_ext] / maxch;
3507  nim = working_space[i + 1][j + 1][zmin + 2 * sizez_ext] / maxch;
3508  for(l = 1;l <= averWindow; l++){
3509  if(j + l > ymax)
3510  a = working_space[i][ymax][zmin + 2 * sizez_ext] / maxch;
3511 
3512  else
3513  a = working_space[i][j + l][zmin + 2 * sizez_ext] / maxch;
3514 
3515  b = a - nip;
3516  if(a + nip <= 0)
3517  a = 1;
3518 
3519  else
3520  a = TMath::Sqrt(a + nip);
3521 
3522  b = b / a;
3523  b = TMath::Exp(b);
3524  spy = spy + b;
3525  if(j - l + 1 < ymin)
3526  a = working_space[i][ymin][zmin + 2 * sizez_ext] / maxch;
3527 
3528  else
3529  a = working_space[i][j - l + 1][zmin + 2 * sizez_ext] / maxch;
3530 
3531  b = a - nim;
3532  if(a + nim <= 0)
3533  a = 1;
3534 
3535  else
3536  a = TMath::Sqrt(a + nim);
3537 
3538  b = b / a;
3539  b = TMath::Exp(b);
3540  smy = smy + b;
3541  }
3542  a = (spx * working_space[i][j + 1][zmin] + spy * working_space[i + 1][j][zmin]) / (smx + smy);
3543  working_space[i + 1][j + 1][zmin] = a;
3544  nom = nom + a;
3545  }
3546  }
3547  for(i = xmin;i < xmax;i++){
3548  for(j = zmin;j < zmax;j++){
3549  nip = working_space[i][ymin][j + 1 + 2 * sizez_ext] / maxch;
3550  nim = working_space[i + 1][ymin][j + 1 + 2 * sizez_ext] / maxch;
3551  spx = 0,smx = 0;
3552  for(l = 1;l <= averWindow; l++){
3553  if(i + l > xmax)
3554  a = working_space[xmax][ymin][j + 2 * sizez_ext] / maxch;
3555 
3556  else
3557  a = working_space[i + l][ymin][j + 2 * sizez_ext] / maxch;
3558 
3559  b = a - nip;
3560  if(a + nip <= 0)
3561  a = 1;
3562 
3563  else
3564  a = TMath::Sqrt(a + nip);
3565 
3566  b = b / a;
3567  b = TMath::Exp(b);
3568  spx = spx + b;
3569  if(i - l + 1 < xmin)
3570  a = working_space[xmin][ymin][j + 2 * sizez_ext] / maxch;
3571 
3572  else
3573  a = working_space[i - l + 1][ymin][j + 2 * sizez_ext] / maxch;
3574 
3575  b = a - nim;
3576  if(a + nim <= 0)
3577  a = 1;
3578 
3579  else
3580  a = TMath::Sqrt(a + nim);
3581 
3582  b = b / a;
3583  b = TMath::Exp(b);
3584  smx = smx + b;
3585  }
3586  spz = 0,smz = 0;
3587  nip = working_space[i + 1][ymin][j + 2 * sizez_ext] / maxch;
3588  nim = working_space[i + 1][ymin][j + 1 + 2 * sizez_ext] / maxch;
3589  for(l = 1;l <= averWindow; l++){
3590  if(j + l > zmax)
3591  a = working_space[i][ymin][zmax + 2 * sizez_ext] / maxch;
3592 
3593  else
3594  a = working_space[i][ymin][j + l + 2 * sizez_ext] / maxch;
3595 
3596  b = a - nip;
3597  if(a + nip <= 0)
3598  a = 1;
3599 
3600  else
3601  a = TMath::Sqrt(a + nip);
3602 
3603  b = b / a;
3604  b = TMath::Exp(b);
3605  spz = spz + b;
3606  if(j - l + 1 < zmin)
3607  a = working_space[i][ymin][zmin + 2 * sizez_ext] / maxch;
3608 
3609  else
3610  a = working_space[i][ymin][j - l + 1 + 2 * sizez_ext] / maxch;
3611 
3612  b = a - nim;
3613  if(a + nim <= 0)
3614  a = 1;
3615 
3616  else
3617  a = TMath::Sqrt(a + nim);
3618 
3619  b = b / a;
3620  b = TMath::Exp(b);
3621  smz = smz + b;
3622  }
3623  a = (spx * working_space[i][ymin][j + 1] + spz * working_space[i + 1][ymin][j]) / (smx + smz);
3624  working_space[i + 1][ymin][j + 1] = a;
3625  nom = nom + a;
3626  }
3627  }
3628  for(i = ymin;i < ymax;i++){
3629  for(j = zmin;j < zmax;j++){
3630  nip = working_space[xmin][i][j + 1 + 2 * sizez_ext] / maxch;
3631  nim = working_space[xmin][i + 1][j + 1 + 2 * sizez_ext] / maxch;
3632  spy = 0,smy = 0;
3633  for(l = 1;l <= averWindow; l++){
3634  if(i + l > ymax)
3635  a = working_space[xmin][ymax][j + 2 * sizez_ext] / maxch;
3636 
3637  else
3638  a = working_space[xmin][i + l][j + 2 * sizez_ext] / maxch;
3639 
3640  b = a - nip;
3641  if(a + nip <= 0)
3642  a = 1;
3643 
3644  else
3645  a = TMath::Sqrt(a + nip);
3646 
3647  b = b / a;
3648  b = TMath::Exp(b);
3649  spy = spy + b;
3650  if(i - l + 1 < ymin)
3651  a = working_space[xmin][ymin][j + 2 * sizez_ext] / maxch;
3652 
3653  else
3654  a = working_space[xmin][i - l + 1][j + 2 * sizez_ext] / maxch;
3655 
3656  b = a - nim;
3657  if(a + nim <= 0)
3658  a = 1;
3659 
3660  else
3661  a = TMath::Sqrt(a + nim);
3662 
3663  b = b / a;
3664  b = TMath::Exp(b);
3665  smy = smy + b;
3666  }
3667  spz = 0,smz = 0;
3668  nip = working_space[xmin][i + 1][j + 2 * sizez_ext] / maxch;
3669  nim = working_space[xmin][i + 1][j + 1 + 2 * sizez_ext] / maxch;
3670  for(l = 1;l <= averWindow; l++){
3671  if(j + l > zmax)
3672  a = working_space[xmin][i][zmax + 2 * sizez_ext] / maxch;
3673 
3674  else
3675  a = working_space[xmin][i][j + l + 2 * sizez_ext] / maxch;
3676 
3677  b = a - nip;
3678  if(a + nip <= 0)
3679  a = 1;
3680 
3681  else
3682  a = TMath::Sqrt(a + nip);
3683 
3684  b = b / a;
3685  b = TMath::Exp(b);
3686  spz = spz + b;
3687  if(j - l + 1 < zmin)
3688  a = working_space[xmin][i][zmin + 2 * sizez_ext] / maxch;
3689 
3690  else
3691  a = working_space[xmin][i][j - l + 1 + 2 * sizez_ext] / maxch;
3692 
3693  b = a - nim;
3694  if(a + nim <= 0)
3695  a = 1;
3696 
3697  else
3698  a = TMath::Sqrt(a + nim);
3699 
3700  b = b / a;
3701  b = TMath::Exp(b);
3702  smz = smz + b;
3703  }
3704  a = (spy * working_space[xmin][i][j + 1] + spz * working_space[xmin][i + 1][j]) / (smy + smz);
3705  working_space[xmin][i + 1][j + 1] = a;
3706  nom = nom + a;
3707  }
3708  }
3709  for(i = xmin;i < xmax; i++){
3710  for(j = ymin;j < ymax; j++){
3711  for(k = zmin;k < zmax; k++){
3712  nip = working_space[i][j + 1][k + 1 + 2 * sizez_ext] / maxch;
3713  nim = working_space[i + 1][j + 1][k + 1 + 2 * sizez_ext] / maxch;
3714  spx = 0,smx = 0;
3715  for(l = 1;l <= averWindow; l++){
3716  if(i + l > xmax)
3717  a = working_space[xmax][j][k + 2 * sizez_ext] / maxch;
3718 
3719  else
3720  a = working_space[i + l][j][k + 2 * sizez_ext] / maxch;
3721 
3722  b = a - nip;
3723  if(a + nip <= 0)
3724  a = 1;
3725 
3726  else
3727  a = TMath::Sqrt(a + nip);
3728 
3729  b = b / a;
3730  b = TMath::Exp(b);
3731  spx = spx + b;
3732  if(i - l + 1 < xmin)
3733  a = working_space[xmin][j][k + 2 * sizez_ext] / maxch;
3734 
3735  else
3736  a = working_space[i - l + 1][j][k + 2 * sizez_ext] / maxch;
3737 
3738  b = a - nim;
3739  if(a + nim <= 0)
3740  a = 1;
3741 
3742  else
3743  a = TMath::Sqrt(a + nim);
3744 
3745  b = b / a;
3746  b = TMath::Exp(b);
3747  smx = smx + b;
3748  }
3749  spy = 0,smy = 0;
3750  nip = working_space[i + 1][j][k + 1 + 2 * sizez_ext] / maxch;
3751  nim = working_space[i + 1][j + 1][k + 1 + 2 * sizez_ext] / maxch;
3752  for(l = 1;l <= averWindow; l++){
3753  if(j + l > ymax)
3754  a = working_space[i][ymax][k + 2 * sizez_ext] / maxch;
3755 
3756  else
3757  a = working_space[i][j + l][k + 2 * sizez_ext] / maxch;
3758 
3759  b = a - nip;
3760  if(a + nip <= 0)
3761  a = 1;
3762 
3763  else
3764  a = TMath::Sqrt(a + nip);
3765 
3766  b = b / a;
3767  b = TMath::Exp(b);
3768  spy = spy + b;
3769  if(j - l + 1 < ymin)
3770  a = working_space[i][ymin][k + 2 * sizez_ext] / maxch;
3771 
3772  else
3773  a = working_space[i][j - l + 1][k + 2 * sizez_ext] / maxch;
3774 
3775  b = a - nim;
3776  if(a + nim <= 0)
3777  a = 1;
3778 
3779  else
3780  a = TMath::Sqrt(a + nim);
3781 
3782  b = b / a;
3783  b = TMath::Exp(b);
3784  smy = smy + b;
3785  }
3786  spz = 0,smz = 0;
3787  nip = working_space[i + 1][j + 1][k + 2 * sizez_ext] / maxch;
3788  nim = working_space[i + 1][j + 1][k + 1 + 2 * sizez_ext] / maxch;
3789  for(l = 1;l <= averWindow; l++ ){
3790  if(j + l > zmax)
3791  a = working_space[i][j][zmax + 2 * sizez_ext] / maxch;
3792 
3793  else
3794  a = working_space[i][j][k + l + 2 * sizez_ext] / maxch;
3795 
3796  b = a - nip;
3797  if(a + nip <= 0)
3798  a = 1;
3799 
3800  else
3801  a = TMath::Sqrt(a + nip);
3802 
3803  b = b / a;
3804  b = TMath::Exp(b);
3805  spz = spz + b;
3806  if(j - l + 1 < ymin)
3807  a = working_space[i][j][zmin + 2 * sizez_ext] / maxch;
3808 
3809  else
3810  a = working_space[i][j][k - l + 1 + 2 * sizez_ext] / maxch;
3811 
3812  b = a - nim;
3813  if(a + nim <= 0)
3814  a = 1;
3815 
3816  else
3817  a = TMath::Sqrt(a + nim);
3818 
3819  b = b / a;
3820  b = TMath::Exp(b);
3821  smz = smz + b;
3822  }
3823  a = (spx * working_space[i][j + 1][k + 1] + spy * working_space[i + 1][j][k + 1] + spz * working_space[i + 1][j + 1][k]) / (smx + smy + smz);
3824  working_space[i + 1][j + 1][k + 1] = a;
3825  nom = nom + a;
3826  }
3827  }
3828  }
3829  a = 0;
3830  for(i = xmin;i <= xmax; i++){
3831  for(j = ymin;j <= ymax; j++){
3832  for(k = zmin;k <= zmax; k++){
3833  working_space[i][j][k] = working_space[i][j][k] / nom;
3834  a+=working_space[i][j][k];
3835  }
3836  }
3837  }
3838  for(i = 0;i < sizex_ext; i++){
3839  for(j = 0;j < sizey_ext; j++){
3840  for(k = 0;k < sizez_ext; k++){
3841  working_space[i][j][k + sizez_ext] = working_space[i][j][k] * plocha_markov / a;
3842  }
3843  }
3844  }
3845  }
3846  //deconvolution starts
3847  area = 0;
3848  lhx = -1,lhy = -1,lhz = -1;
3849  positx = 0,posity = 0,positz = 0;
3850  maximum = 0;
3851  //generate response cube
3852  for(i = 0;i < sizex_ext; i++){
3853  for(j = 0;j < sizey_ext; j++){
3854  for(k = 0;k < sizez_ext; k++){
3855  lda = (Double_t)i - 3 * sigma;
3856  ldb = (Double_t)j - 3 * sigma;
3857  ldc = (Double_t)k - 3 * sigma;
3858  lda = (lda * lda + ldb * ldb + ldc * ldc) / (2 * sigma * sigma);
3859  l = (Int_t)(1000 * exp(-lda));
3860  lda = l;
3861  if(lda!=0){
3862  if((i + 1) > lhx)
3863  lhx = i + 1;
3864 
3865  if((j + 1) > lhy)
3866  lhy = j + 1;
3867 
3868  if((k + 1) > lhz)
3869  lhz = k + 1;
3870  }
3871  working_space[i][j][k] = lda;
3872  area = area + lda;
3873  if(lda > maximum){
3874  maximum = lda;
3875  positx = i,posity = j,positz = k;
3876  }
3877  }
3878  }
3879  }
3880  //read source cube
3881  for(i = 0;i < sizex_ext; i++){
3882  for(j = 0;j < sizey_ext; j++){
3883  for(k = 0;k < sizez_ext; k++){
3884  working_space[i][j][k + 2 * sizez_ext] = TMath::Abs(working_space[i][j][k + sizez_ext]);
3885  }
3886  }
3887  }
3888  //calculate ht*y and write into p
3889  for (i3 = 0; i3 < sizez_ext; i3++) {
3890  for (i2 = 0; i2 < sizey_ext; i2++) {
3891  for (i1 = 0; i1 < sizex_ext; i1++) {
3892  ldc = 0;
3893  for (j3 = 0; j3 <= (lhz - 1); j3++) {
3894  for (j2 = 0; j2 <= (lhy - 1); j2++) {
3895  for (j1 = 0; j1 <= (lhx - 1); j1++) {
3896  k3 = i3 + j3, k2 = i2 + j2, k1 = i1 + j1;
3897  if (k3 >= 0 && k3 < sizez_ext && k2 >= 0 && k2 < sizey_ext && k1 >= 0 && k1 < sizex_ext) {
3898  lda = working_space[j1][j2][j3];
3899  ldb = working_space[k1][k2][k3+2*sizez_ext];
3900  ldc = ldc + lda * ldb;
3901  }
3902  }
3903  }
3904  }
3905  working_space[i1][i2][i3 + sizez_ext] = ldc;
3906  }
3907  }
3908  }
3909 //calculate b=ht*h
3910  i1min = -(lhx - 1), i1max = lhx - 1;
3911  i2min = -(lhy - 1), i2max = lhy - 1;
3912  i3min = -(lhz - 1), i3max = lhz - 1;
3913  for (i3 = i3min; i3 <= i3max; i3++) {
3914  for (i2 = i2min; i2 <= i2max; i2++) {
3915  for (i1 = i1min; i1 <= i1max; i1++) {
3916  ldc = 0;
3917  j3min = -i3;
3918  if (j3min < 0)
3919  j3min = 0;
3920 
3921  j3max = lhz - 1 - i3;
3922  if (j3max > lhz - 1)
3923  j3max = lhz - 1;
3924 
3925  for (j3 = j3min; j3 <= j3max; j3++) {
3926  j2min = -i2;
3927  if (j2min < 0)
3928  j2min = 0;
3929 
3930  j2max = lhy - 1 - i2;
3931  if (j2max > lhy - 1)
3932  j2max = lhy - 1;
3933 
3934  for (j2 = j2min; j2 <= j2max; j2++) {
3935  j1min = -i1;
3936  if (j1min < 0)
3937  j1min = 0;
3938 
3939  j1max = lhx - 1 - i1;
3940  if (j1max > lhx - 1)
3941  j1max = lhx - 1;
3942 
3943  for (j1 = j1min; j1 <= j1max; j1++) {
3944  lda = working_space[j1][j2][j3];
3945  if (i1 + j1 < sizex_ext && i2 + j2 < sizey_ext)
3946  ldb = working_space[i1 + j1][i2 + j2][i3 + j3];
3947 
3948  else
3949  ldb = 0;
3950 
3951  ldc = ldc + lda * ldb;
3952  }
3953  }
3954  }
3955  working_space[i1 - i1min][i2 - i2min][i3 - i3min + 2 * sizez_ext ] = ldc;
3956  }
3957  }
3958  }
3959 //initialization in x1 cube
3960  for (i3 = 0; i3 < sizez_ext; i3++) {
3961  for (i2 = 0; i2 < sizey_ext; i2++) {
3962  for (i1 = 0; i1 < sizex_ext; i1++) {
3963  working_space[i1][i2][i3 + 3 * sizez_ext] = 1;
3964  working_space[i1][i2][i3 + 4 * sizez_ext] = 0;
3965  }
3966  }
3967  }
3968 
3969 //START OF ITERATIONS
3970  for (lindex=0;lindex<deconIterations;lindex++){
3971  for (i3 = 0; i3 < sizez_ext; i3++) {
3972  for (i2 = 0; i2 < sizey_ext; i2++) {
3973  for (i1 = 0; i1 < sizex_ext; i1++) {
3974  if (TMath::Abs(working_space[i1][i2][i3 + 3 * sizez_ext])>1e-6 && TMath::Abs(working_space[i1][i2][i3 + 1 * sizez_ext])>1e-6){
3975  ldb = 0;
3976  j3min = i3;
3977  if (j3min > lhz - 1)
3978  j3min = lhz - 1;
3979 
3980  j3min = -j3min;
3981  j3max = sizez_ext - i3 - 1;
3982  if (j3max > lhz - 1)
3983  j3max = lhz - 1;
3984 
3985  j2min = i2;
3986  if (j2min > lhy - 1)
3987  j2min = lhy - 1;
3988 
3989  j2min = -j2min;
3990  j2max = sizey_ext - i2 - 1;
3991  if (j2max > lhy - 1)
3992  j2max = lhy - 1;
3993 
3994  j1min = i1;
3995  if (j1min > lhx - 1)
3996  j1min = lhx - 1;
3997 
3998  j1min = -j1min;
3999  j1max = sizex_ext - i1 - 1;
4000  if (j1max > lhx - 1)
4001  j1max = lhx - 1;
4002 
4003  for (j3 = j3min; j3 <= j3max; j3++) {
4004  for (j2 = j2min; j2 <= j2max; j2++) {
4005  for (j1 = j1min; j1 <= j1max; j1++) {
4006  ldc = working_space[j1 - i1min][j2 - i2min][j3 - i3min + 2 * sizez_ext];
4007  lda = working_space[i1 + j1][i2 + j2][i3 + j3 + 3 * sizez_ext];
4008  ldb = ldb + lda * ldc;
4009  }
4010  }
4011  }
4012  lda = working_space[i1][i2][i3 + 3 * sizez_ext];
4013  ldc = working_space[i1][i2][i3 + 1 * sizez_ext];
4014  if (ldc * lda != 0 && ldb != 0) {
4015  lda = lda * ldc / ldb;
4016  }
4017 
4018  else
4019  lda = 0;
4020  working_space[i1][i2][i3 + 4 * sizez_ext] = lda;
4021  }
4022  }
4023  }
4024  }
4025  for (i3 = 0; i3 < sizez_ext; i3++) {
4026  for (i2 = 0; i2 < sizey_ext; i2++) {
4027  for (i1 = 0; i1 < sizex_ext; i1++)
4028  working_space[i1][i2][i3 + 3 * sizez_ext] = working_space[i1][i2][i3 + 4 * sizez_ext];
4029  }
4030  }
4031  }
4032 //write back resulting spectrum
4033  maximum=0;
4034  for(i = 0;i < sizex_ext; i++){
4035  for(j = 0;j < sizey_ext; j++){
4036  for(k = 0;k < sizez_ext; k++){
4037  working_space[(i + positx) % sizex_ext][(j + posity) % sizey_ext][(k + positz) % sizez_ext] = area * working_space[i][j][k + 3 * sizez_ext];
4038  if(maximum < working_space[(i + positx) % sizex_ext][(j + posity) % sizey_ext][(k + positz) % sizez_ext])
4039  maximum = working_space[(i + positx) % sizex_ext][(j + posity) % sizey_ext][(k + positz) % sizez_ext];
4040  }
4041  }
4042  }
4043 //searching for peaks in deconvolved spectrum
4044  for(i = 1;i < sizex_ext - 1; i++){
4045  for(j = 1;j < sizey_ext - 1; j++){
4046  for(l = 1;l < sizez_ext - 1; l++){
4047  a = working_space[i][j][l];
4048  if(a > working_space[i][j][l - 1] && a > working_space[i - 1][j][l - 1] && a > working_space[i - 1][j - 1][l - 1] && a > working_space[i][j - 1][l - 1] && a > working_space[i + 1][j - 1][l - 1] && a > working_space[i + 1][j][l - 1] && a > working_space[i + 1][j + 1][l - 1] && a > working_space[i][j + 1][l - 1] && a > working_space[i - 1][j + 1][l - 1] && a > working_space[i - 1][j][l] && a > working_space[i - 1][j - 1][l] && a > working_space[i][j - 1][l] && a > working_space[i + 1][j - 1][l] && a > working_space[i + 1][j][l] && a > working_space[i + 1][j + 1][l] && a > working_space[i][j + 1][l] && a > working_space[i - 1][j + 1][l] && a > working_space[i][j][l + 1] && a > working_space[i - 1][j][l + 1] && a > working_space[i - 1][j - 1][l + 1] && a > working_space[i][j - 1][l + 1] && a > working_space[i + 1][j - 1][l + 1] && a > working_space[i + 1][j][l + 1] && a > working_space[i + 1][j + 1][l + 1] && a > working_space[i][j + 1][l + 1] && a > working_space[i - 1][j + 1][l + 1]){
4049  if(i >= shift && i < ssizex + shift && j >= shift && j < ssizey + shift && l >= shift && l < ssizez + shift){
4050  if(working_space[i][j][l] > threshold * maximum / 100.0){
4051  if(peak_index < fMaxPeaks){
4052  for(k = i - 1,a = 0,b = 0;k <= i + 1; k++){
4053  a += (Double_t)(k - shift) * working_space[k][j][l];
4054  b += working_space[k][j][l];
4055  }
4056  fPositionX[peak_index] = a / b;
4057  for(k = j - 1,a = 0,b = 0;k <= j + 1; k++){
4058  a += (Double_t)(k - shift) * working_space[i][k][l];
4059  b += working_space[i][k][l];
4060  }
4061  fPositionY[peak_index] = a / b;
4062  for(k = l - 1,a = 0,b = 0;k <= l + 1; k++){
4063  a += (Double_t)(k - shift) * working_space[i][j][k];
4064  b += working_space[i][j][k];
4065  }
4066  fPositionZ[peak_index] = a / b;
4067  peak_index += 1;
4068  }
4069  }
4070  }
4071  }
4072  }
4073  }
4074  }
4075  for(i = 0;i < ssizex; i++){
4076  for(j = 0;j < ssizey; j++){
4077  for(k = 0;k < ssizez; k++){
4078  dest[i][j][k] = working_space[i + shift][j + shift][k + shift];
4079  }
4080  }
4081  }
4082  k = (Int_t)(4 * sigma + 0.5);
4083  k = 4 * k;
4084  for(i = 0;i < ssizex + k; i++){
4085  for(j = 0;j < ssizey + k; j++)
4086  delete[] working_space[i][j];
4087  delete[] working_space[i];
4088  }
4089  delete[] working_space;
4090  fNPeaks = peak_index;
4091  return fNPeaks;
4092 }
4093 
4094 ////////////////////////////////////////////////////////////////////////////////
4095 
4096 Int_t TSpectrum3::SearchFast(const Double_t***source, Double_t***dest, Int_t ssizex, Int_t ssizey, Int_t ssizez,
4097  Double_t sigma, Double_t threshold,
4098  Bool_t markov, Int_t averWindow)
4099 
4100 {
4101 
4102 /////////////////////////////////////////////////////////////////////////////
4103 // THREE-DIMENSIONAL CLASSICAL PEAK SEARCH FUNCTION //
4104 // This function searches for peaks in source spectrum using //
4105 // the algorithm based on smoothed second differences. //
4106 // //
4107 // Function parameters: //
4108 // source-pointer to the matrix of source spectrum //
4109 // ssizex-x length of source spectrum //
4110 // ssizey-y length of source spectrum //
4111 // ssizez-z length of source spectrum //
4112 // sigma-sigma of searched peaks, for details we refer to manual //
4113 // threshold-threshold value in % for selected peaks, peaks with //
4114 // amplitude less than threshold*highest_peak/100 //
4115 // are ignored, see manual //
4116 // markov-logical variable, if it is true, first the source spectrum //
4117 // is replaced by new spectrum calculated using Markov //
4118 // chains method. //
4119 // averWindow-averanging window of searched peaks, for details //
4120 // we refer to manual (applies only for Markov method) //
4121 /////////////////////////////////////////////////////////////////////////////
4122 
4123  Int_t i,j,k,l,li,lj,lk,lmin,lmax,xmin,xmax,ymin,ymax,zmin,zmax;
4124  Double_t maxch,plocha = 0,plocha_markov = 0;
4125  Double_t nom,nip,nim,sp,sm,spx,spy,smx,smy,spz,smz;
4126  Double_t norma,val,val1,val2,val3,val4,val5,val6,val7,val8,val9,val10,val11,val12,val13,val14,val15,val16,val17,val18,val19,val20,val21,val22,val23,val24,val25,val26;
4127  Double_t a,b,s,f,maximum;
4128  Int_t x,y,z,peak_index=0;
4129  Double_t p1,p2,p3,p4,p5,p6,p7,p8,s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11,s12,r1,r2,r3,r4,r5,r6;
4130  Double_t pocet_sigma = 5;
4131  Int_t number_of_iterations=(Int_t)(4 * sigma + 0.5);
4132  Int_t sizex_ext=ssizex + 4 * number_of_iterations,sizey_ext = ssizey + 4 * number_of_iterations,sizez_ext = ssizez + 4 * number_of_iterations,shift = 2 * number_of_iterations;
4133  Double_t c[PEAK_WINDOW],s_f_ratio_peaks = 5;
4134  if(sigma < 1){
4135  Error("SearchFast", "Invalid sigma, must be greater than or equal to 1");
4136  return 0;
4137  }
4138 
4139  if(threshold<=0||threshold>=100){
4140  Error("SearchFast", "Invalid threshold, must be positive and less than 100");
4141  return 0;
4142  }
4143 
4144  j = (Int_t)(pocet_sigma*sigma+0.5);
4145  if (j >= PEAK_WINDOW / 2) {
4146  Error("SearchFast", "Too large sigma");
4147  return 0;
4148  }
4149 
4150  if (markov == true) {
4151  if (averWindow <= 0) {
4152  Error("SearchFast", "Averanging window must be positive");
4153  return 0;
4154  }
4155  }
4156 
4157  if(sizex_ext < 2 * number_of_iterations + 1 || sizey_ext < 2 * number_of_iterations + 1 || sizez_ext < 2 * number_of_iterations + 1){
4158  Error("SearchFast", "Too large clipping window");
4159  return 0;
4160  }
4161 
4162  i = (Int_t)(4 * sigma + 0.5);
4163  i = 4 * i;
4164  Double_t ***working_space = new Double_t** [ssizex + i];
4165  for(j = 0;j < ssizex + i; j++){
4166  working_space[j] = new Double_t* [ssizey + i];
4167  for(k = 0;k < ssizey + i; k++)
4168  working_space[j][k] = new Double_t [4 * (ssizez + i)];
4169  }
4170 
4171  for(k = 0;k < sizez_ext; k++){
4172  for(j = 0;j < sizey_ext; j++){
4173  for(i = 0;i < sizex_ext; i++){
4174  if(i < shift){
4175  if(j < shift){
4176  if(k < shift)
4177  working_space[i][j][k + sizez_ext] = source[0][0][0];
4178 
4179  else if(k >= ssizez + shift)
4180  working_space[i][j][k + sizez_ext] = source[0][0][ssizez - 1];
4181 
4182  else
4183  working_space[i][j][k + sizez_ext] = source[0][0][k - shift];
4184  }
4185 
4186  else if(j >= ssizey + shift){
4187  if(k < shift)
4188  working_space[i][j][k + sizez_ext] = source[0][ssizey - 1][0];
4189 
4190  else if(k >= ssizez + shift)
4191  working_space[i][j][k + sizez_ext] = source[0][ssizey - 1][ssizez - 1];
4192 
4193  else
4194  working_space[i][j][k + sizez_ext] = source[0][ssizey - 1][k - shift];
4195  }
4196 
4197  else{
4198  if(k < shift)
4199  working_space[i][j][k + sizez_ext] = source[0][j - shift][0];
4200 
4201  else if(k >= ssizez + shift)
4202  working_space[i][j][k + sizez_ext] = source[0][j - shift][ssizez - 1];
4203 
4204  else
4205  working_space[i][j][k + sizez_ext] = source[0][j - shift][k - shift];
4206  }
4207  }
4208 
4209  else if(i >= ssizex + shift){
4210  if(j < shift){
4211  if(k < shift)
4212  working_space[i][j][k + sizez_ext] = source[ssizex - 1][0][0];
4213 
4214  else if(k >= ssizez + shift)
4215  working_space[i][j][k + sizez_ext] = source[ssizex - 1][0][ssizez - 1];
4216 
4217  else
4218  working_space[i][j][k + sizez_ext] = source[ssizex - 1][0][k - shift];
4219  }
4220 
4221  else if(j >= ssizey + shift){
4222  if(k < shift)
4223  working_space[i][j][k + sizez_ext] = source[ssizex - 1][ssizey - 1][0];
4224 
4225  else if(k >= ssizez + shift)
4226  working_space[i][j][k + sizez_ext] = source[ssizex - 1][ssizey - 1][ssizez - 1];
4227 
4228  else
4229  working_space[i][j][k + sizez_ext] = source[ssizex - 1][ssizey - 1][k - shift];
4230  }
4231 
4232  else{
4233  if(k < shift)
4234  working_space[i][j][k + sizez_ext] = source[ssizex - 1][j - shift][0];
4235 
4236  else if(k >= ssizez + shift)
4237  working_space[i][j][k + sizez_ext] = source[ssizex - 1][j - shift][ssizez - 1];
4238 
4239  else
4240  working_space[i][j][k + sizez_ext] = source[ssizex - 1][j - shift][k - shift];
4241  }
4242  }
4243 
4244  else{
4245  if(j < shift){
4246  if(k < shift)
4247  working_space[i][j][k + sizez_ext] = source[i - shift][0][0];
4248 
4249  else if(k >= ssizez + shift)
4250  working_space[i][j][k + sizez_ext] = source[i - shift][0][ssizez - 1];
4251 
4252  else
4253  working_space[i][j][k + sizez_ext] = source[i - shift][0][k - shift];
4254  }
4255 
4256  else if(j >= ssizey + shift){
4257  if(k < shift)
4258  working_space[i][j][k + sizez_ext] = source[i - shift][ssizey - 1][0];
4259 
4260  else if(k >= ssizez + shift)
4261  working_space[i][j][k + sizez_ext] = source[i - shift][ssizey - 1][ssizez - 1];
4262 
4263  else
4264  working_space[i][j][k + sizez_ext] = source[i - shift][ssizey - 1][k - shift];
4265  }
4266 
4267  else{
4268  if(k < shift)
4269  working_space[i][j][k + sizez_ext] = source[i - shift][j - shift][0];
4270 
4271  else if(k >= ssizez + shift)
4272  working_space[i][j][k + sizez_ext] = source[i - shift][j - shift][ssizez - 1];
4273 
4274  else
4275  working_space[i][j][k + sizez_ext] = source[i - shift][j - shift][k - shift];
4276  }
4277  }
4278  }
4279  }
4280  }
4281  for(i = 1;i <= number_of_iterations; i++){
4282  for(z = i;z < sizez_ext - i; z++){
4283  for(y = i;y < sizey_ext - i; y++){
4284  for(x = i;x < sizex_ext - i; x++){
4285  a = working_space[x][y][z + sizez_ext];
4286  p1 = working_space[x + i][y + i][z - i + sizez_ext];
4287  p2 = working_space[x - i][y + i][z - i + sizez_ext];
4288  p3 = working_space[x + i][y - i][z - i + sizez_ext];
4289  p4 = working_space[x - i][y - i][z - i + sizez_ext];
4290  p5 = working_space[x + i][y + i][z + i + sizez_ext];
4291  p6 = working_space[x - i][y + i][z + i + sizez_ext];
4292  p7 = working_space[x + i][y - i][z + i + sizez_ext];
4293  p8 = working_space[x - i][y - i][z + i + sizez_ext];
4294  s1 = working_space[x + i][y ][z - i + sizez_ext];
4295  s2 = working_space[x ][y + i][z - i + sizez_ext];
4296  s3 = working_space[x - i][y ][z - i + sizez_ext];
4297  s4 = working_space[x ][y - i][z - i + sizez_ext];
4298  s5 = working_space[x + i][y ][z + i + sizez_ext];
4299  s6 = working_space[x ][y + i][z + i + sizez_ext];
4300  s7 = working_space[x - i][y ][z + i + sizez_ext];
4301  s8 = working_space[x ][y - i][z + i + sizez_ext];
4302  s9 = working_space[x - i][y + i][z + sizez_ext];
4303  s10 = working_space[x - i][y - i][z +sizez_ext];
4304  s11 = working_space[x + i][y + i][z +sizez_ext];
4305  s12 = working_space[x + i][y - i][z +sizez_ext];
4306  r1 = working_space[x ][y ][z - i + sizez_ext];
4307  r2 = working_space[x ][y ][z + i + sizez_ext];
4308  r3 = working_space[x - i][y ][z + sizez_ext];
4309  r4 = working_space[x + i][y ][z + sizez_ext];
4310  r5 = working_space[x ][y + i][z + sizez_ext];
4311  r6 = working_space[x ][y - i][z + sizez_ext];
4312  b = (p1 + p3) / 2.0;
4313  if(b > s1)
4314  s1 = b;
4315 
4316  b = (p1 + p2) / 2.0;
4317  if(b > s2)
4318  s2 = b;
4319 
4320  b = (p2 + p4) / 2.0;
4321  if(b > s3)
4322  s3 = b;
4323 
4324  b = (p3 + p4) / 2.0;
4325  if(b > s4)
4326  s4 = b;
4327 
4328  b = (p5 + p7) / 2.0;
4329  if(b > s5)
4330  s5 = b;
4331 
4332  b = (p5 + p6) / 2.0;
4333  if(b > s6)
4334  s6 = b;
4335 
4336  b = (p6 + p8) / 2.0;
4337  if(b > s7)
4338  s7 = b;
4339 
4340  b = (p7 + p8) / 2.0;
4341  if(b > s8)
4342  s8 = b;
4343 
4344  b = (p2 + p6) / 2.0;
4345  if(b > s9)
4346  s9 = b;
4347 
4348  b = (p4 + p8) / 2.0;
4349  if(b > s10)
4350  s10 = b;
4351 
4352  b = (p1 + p5) / 2.0;
4353  if(b > s11)
4354  s11 = b;
4355 
4356  b = (p3 + p7) / 2.0;
4357  if(b > s12)
4358  s12 = b;
4359 
4360  s1 = s1 - (p1 + p3) / 2.0;
4361  s2 = s2 - (p1 + p2) / 2.0;
4362  s3 = s3 - (p2 + p4) / 2.0;
4363  s4 = s4 - (p3 + p4) / 2.0;
4364  s5 = s5 - (p5 + p7) / 2.0;
4365  s6 = s6 - (p5 + p6) / 2.0;
4366  s7 = s7 - (p6 + p8) / 2.0;
4367  s8 = s8 - (p7 + p8) / 2.0;
4368  s9 = s9 - (p2 + p6) / 2.0;
4369  s10 = s10 - (p4 + p8) / 2.0;
4370  s11 = s11 - (p1 + p5) / 2.0;
4371  s12 = s12 - (p3 + p7) / 2.0;
4372  b = (s1 + s3) / 2.0 + (s2 + s4) / 2.0 + (p1 + p2 + p3 + p4) / 4.0;
4373  if(b > r1)
4374  r1 = b;
4375 
4376  b = (s5 + s7) / 2.0 + (s6 + s8) / 2.0 + (p5 + p6 + p7 + p8) / 4.0;
4377  if(b > r2)
4378  r2 = b;
4379 
4380  b = (s3 + s7) / 2.0 + (s9 + s10) / 2.0 + (p2 + p4 + p6 + p8) / 4.0;
4381  if(b > r3)
4382  r3 = b;
4383 
4384  b = (s1 + s5) / 2.0 + (s11 + s12) / 2.0 + (p1 + p3 + p5 + p7) / 4.0;
4385  if(b > r4)
4386  r4 = b;
4387 
4388  b = (s9 + s11) / 2.0 + (s2 + s6) / 2.0 + (p1 + p2 + p5 + p6) / 4.0;
4389  if(b > r5)
4390  r5 = b;
4391 
4392  b = (s4 + s8) / 2.0 + (s10 + s12) / 2.0 + (p3 + p4 + p7 + p8) / 4.0;
4393  if(b > r6)
4394  r6 = b;
4395 
4396  r1 = r1 - ((s1 + s3) / 2.0 + (s2 + s4) / 2.0 + (p1 + p2 + p3 + p4) / 4.0);
4397  r2 = r2 - ((s5 + s7) / 2.0 + (s6 + s8) / 2.0 + (p5 + p6 + p7 + p8) / 4.0);
4398  r3 = r3 - ((s3 + s7) / 2.0 + (s9 + s10) / 2.0 + (p2 + p4 + p6 + p8) / 4.0);
4399  r4 = r4 - ((s1 + s5) / 2.0 + (s11 + s12) / 2.0 + (p1 + p3 + p5 + p7) / 4.0);
4400  r5 = r5 - ((s9 + s11) / 2.0 + (s2 + s6) / 2.0 + (p1 + p2 + p5 + p6) / 4.0);
4401  r6 = r6 - ((s4 + s8) / 2.0 + (s10 + s12) / 2.0 + (p3 + p4 + p7 + p8) / 4.0);
4402  b = (r1 + r2) / 2.0 + (r3 + r4) / 2.0 + (r5 + r6) / 2.0 + (s1 + s3 + s5 + s7) / 4.0 + (s2 + s4 + s6 + s8) / 4.0 + (s9 + s10 + s11 + s12) / 4.0 + (p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8) / 8.0;
4403  if(b < a)
4404  a = b;
4405 
4406  working_space[x][y][z] = a;
4407  }
4408  }
4409  }
4410  for(z = i;z < sizez_ext - i; z++){
4411  for(y = i;y < sizey_ext - i; y++){
4412  for(x = i;x < sizex_ext - i; x++){
4413  working_space[x][y][z + sizez_ext] = working_space[x][y][z];
4414  }
4415  }
4416  }
4417  }
4418  for(k = 0;k < sizez_ext; k++){
4419  for(j = 0;j < sizey_ext; j++){
4420  for(i = 0;i < sizex_ext; i++){
4421  if(i < shift){
4422  if(j < shift){
4423  if(k < shift)
4424  working_space[i][j][k + 3 * sizez_ext] = source[0][0][0] - working_space[i][j][k + sizez_ext];
4425 
4426  else if(k >= ssizez + shift)
4427  working_space[i][j][k + 3 * sizez_ext] = source[0][0][ssizez - 1] - working_space[i][j][k + sizez_ext];
4428 
4429  else
4430  working_space[i][j][k + 3 * sizez_ext] = source[0][0][k - shift] - working_space[i][j][k + sizez_ext];
4431  }
4432 
4433  else if(j >= ssizey + shift){
4434  if(k < shift)
4435  working_space[i][j][k + 3 * sizez_ext] = source[0][ssizey - 1][0] - working_space[i][j][k + sizez_ext];
4436 
4437  else if(k >= ssizez + shift)
4438  working_space[i][j][k + 3 * sizez_ext] = source[0][ssizey - 1][ssizez - 1] - working_space[i][j][k + sizez_ext];
4439 
4440  else
4441  working_space[i][j][k + 3 * sizez_ext] = source[0][ssizey - 1][k - shift] - working_space[i][j][k + sizez_ext];
4442  }
4443 
4444  else{
4445  if(k < shift)
4446  working_space[i][j][k + 3 * sizez_ext] = source[0][j - shift][0] - working_space[i][j][k + sizez_ext];
4447 
4448  else if(k >= ssizez + shift)
4449  working_space[i][j][k + 3 * sizez_ext] = source[0][j - shift][ssizez - 1] - working_space[i][j][k + sizez_ext];
4450 
4451  else
4452  working_space[i][j][k + 3 * sizez_ext] = source[0][j - shift][k - shift] - working_space[i][j][k + sizez_ext];
4453  }
4454  }
4455 
4456  else if(i >= ssizex + shift){
4457  if(j < shift){
4458  if(k < shift)
4459  working_space[i][j][k + 3 * sizez_ext] = source[ssizex - 1][0][0] - working_space[i][j][k + sizez_ext];
4460 
4461  else if(k >= ssizez + shift)
4462  working_space[i][j][k + 3 * sizez_ext] = source[ssizex - 1][0][ssizez - 1] - working_space[i][j][k + sizez_ext];
4463 
4464  else
4465  working_space[i][j][k + 3 * sizez_ext] = source[ssizex - 1][0][k - shift] - working_space[i][j][k + sizez_ext];
4466  }
4467 
4468  else if(j >= ssizey + shift){
4469  if(k < shift)
4470  working_space[i][j][k + 3 * sizez_ext] = source[ssizex - 1][ssizey - 1][0] - working_space[i][j][k + sizez_ext];
4471 
4472  else if(k >= ssizez + shift)
4473  working_space[i][j][k + 3 * sizez_ext] = source[ssizex - 1][ssizey - 1][ssizez - 1] - working_space[i][j][k + sizez_ext];
4474 
4475  else
4476  working_space[i][j][k + 3 * sizez_ext] = source[ssizex - 1][ssizey - 1][k - shift] - working_space[i][j][k + sizez_ext];
4477  }
4478 
4479  else{
4480  if(k < shift)
4481  working_space[i][j][k + 3 * sizez_ext] = source[ssizex - 1][j - shift][0] - working_space[i][j][k + sizez_ext];
4482 
4483  else if(k >= ssizez + shift)
4484  working_space[i][j][k + 3 * sizez_ext] = source[ssizex - 1][j - shift][ssizez - 1] - working_space[i][j][k + sizez_ext];
4485 
4486  else
4487  working_space[i][j][k + 3 * sizez_ext] = source[ssizex - 1][j - shift][k - shift] - working_space[i][j][k + sizez_ext];
4488  }
4489  }
4490 
4491  else{
4492  if(j < shift){
4493  if(k < shift)
4494  working_space[i][j][k + 3 * sizez_ext] = source[i - shift][0][0] - working_space[i][j][k + sizez_ext];
4495 
4496  else if(k >= ssizez + shift)
4497  working_space[i][j][k + 3 * sizez_ext] = source[i - shift][0][ssizez - 1] - working_space[i][j][k + sizez_ext];
4498 
4499  else
4500  working_space[i][j][k + 3 * sizez_ext] = source[i - shift][0][k - shift] - working_space[i][j][k + sizez_ext];
4501  }
4502 
4503  else if(j >= ssizey + shift){
4504  if(k < shift)
4505  working_space[i][j][k + 3 * sizez_ext] = source[i - shift][ssizey - 1][0] - working_space[i][j][k + sizez_ext];
4506 
4507  else if(k >= ssizez + shift)
4508  working_space[i][j][k + 3 * sizez_ext] = source[i - shift][ssizey - 1][ssizez - 1] - working_space[i][j][k + sizez_ext];
4509 
4510  else
4511  working_space[i][j][k + 3 * sizez_ext] = source[i - shift][ssizey - 1][k - shift] - working_space[i][j][k + sizez_ext];
4512  }
4513 
4514  else{
4515  if(k < shift)
4516  working_space[i][j][k + 3 * sizez_ext] = source[i - shift][j - shift][0] - working_space[i][j][k + sizez_ext];
4517 
4518  else if(k >= ssizez + shift)
4519  working_space[i][j][k + 3 * sizez_ext] = source[i - shift][j - shift][ssizez - 1] - working_space[i][j][k + sizez_ext];
4520 
4521  else
4522  working_space[i][j][k + 3 * sizez_ext] = source[i - shift][j - shift][k - shift] - working_space[i][j][k + sizez_ext];
4523  }
4524  }
4525  }
4526  }
4527  }
4528 
4529  for(i = 0;i < sizex_ext; i++){
4530  for(j = 0;j < sizey_ext; j++){
4531  for(k = 0;k < sizez_ext; k++){
4532  if(i >= shift && i < ssizex + shift && j >= shift && j < ssizey + shift && k >= shift && k < ssizez + shift){
4533  working_space[i][j][k + 2 * sizez_ext] = source[i - shift][j - shift][k - shift];
4534  plocha_markov = plocha_markov + source[i - shift][j - shift][k - shift];
4535  }
4536  else
4537  working_space[i][j][k + 2 * sizez_ext] = 0;
4538  }
4539  }
4540  }
4541 
4542  if(markov == true){
4543  xmin = 0;
4544  xmax = sizex_ext - 1;
4545  ymin = 0;
4546  ymax = sizey_ext - 1;
4547  zmin = 0;
4548  zmax = sizez_ext - 1;
4549  for(i = 0,maxch = 0;i < sizex_ext; i++){
4550  for(j = 0;j < sizey_ext;j++){
4551  for(k = 0;k < sizez_ext;k++){
4552  working_space[i][j][k] = 0;
4553  if(maxch < working_space[i][j][k + 2 * sizez_ext])
4554  maxch = working_space[i][j][k + 2 * sizez_ext];
4555 
4556  plocha += working_space[i][j][k + 2 * sizez_ext];
4557  }
4558  }
4559  }
4560  if(maxch == 0) {
4561  delete [] working_space;
4562  return 0;
4563  }
4564 
4565  nom = 0;
4566  working_space[xmin][ymin][zmin] = 1;
4567  for(i = xmin;i < xmax; i++){
4568  nip = working_space[i][ymin][zmin + 2 * sizez_ext] / maxch;
4569  nim = working_space[i + 1][ymin][zmin + 2 * sizez_ext] / maxch;
4570  sp = 0,sm = 0;
4571  for(l = 1;l <= averWindow; l++){
4572  if((i + l) > xmax)
4573  a = working_space[xmax][ymin][zmin + 2 * sizez_ext] / maxch;
4574 
4575  else
4576  a = working_space[i + l][ymin][zmin + 2 * sizez_ext] / maxch;
4577 
4578  b = a - nip;
4579  if(a + nip <= 0)
4580  a = 1;
4581 
4582  else
4583  a = TMath::Sqrt(a + nip);
4584 
4585  b = b / a;
4586  b = TMath::Exp(b);
4587  sp = sp + b;
4588  if(i - l + 1 < xmin)
4589  a = working_space[xmin][ymin][zmin + 2 * sizez_ext] / maxch;
4590 
4591  else
4592  a = working_space[i - l + 1][ymin][zmin + 2 * sizez_ext] / maxch;
4593 
4594  b = a - nim;
4595  if(a + nim <= 0)
4596  a = 1;
4597 
4598  else
4599  a = TMath::Sqrt(a + nim);
4600 
4601  b = b / a;
4602  b = TMath::Exp(b);
4603  sm = sm + b;
4604  }
4605  a = sp / sm;
4606  a = working_space[i + 1][ymin][zmin] = a * working_space[i][ymin][zmin];
4607  nom = nom + a;
4608  }
4609  for(i = ymin;i < ymax; i++){
4610  nip = working_space[xmin][i][zmin + 2 * sizez_ext] / maxch;
4611  nim = working_space[xmin][i + 1][zmin + 2 * sizez_ext] / maxch;
4612  sp = 0,sm = 0;
4613  for(l = 1;l <= averWindow; l++){
4614  if((i + l) > ymax)
4615  a = working_space[xmin][ymax][zmin + 2 * sizez_ext] / maxch;
4616 
4617  else
4618  a = working_space[xmin][i + l][zmin + 2 * sizez_ext] / maxch;
4619 
4620  b = a - nip;
4621  if(a + nip <= 0)
4622  a = 1;
4623 
4624  else
4625  a = TMath::Sqrt(a + nip);
4626 
4627  b = b / a;
4628  b = TMath::Exp(b);
4629  sp = sp + b;
4630  if(i - l + 1 < ymin)
4631  a = working_space[xmin][ymin][zmin + 2 * sizez_ext] / maxch;
4632 
4633  else
4634  a = working_space[xmin][i - l + 1][zmin + 2 * sizez_ext] / maxch;
4635 
4636  b = a - nim;
4637  if(a + nim <= 0)
4638  a = 1;
4639 
4640  else
4641  a = TMath::Sqrt(a + nim);
4642 
4643  b = b / a;
4644  b = TMath::Exp(b);
4645  sm = sm + b;
4646  }
4647  a = sp / sm;
4648  a = working_space[xmin][i + 1][zmin] = a * working_space[xmin][i][zmin];
4649  nom = nom + a;
4650  }
4651  for(i = zmin;i < zmax;i++){
4652  nip = working_space[xmin][ymin][i + 2 * sizez_ext] / maxch;
4653  nim = working_space[xmin][ymin][i + 1 + 2 * sizez_ext] / maxch;
4654  sp = 0,sm = 0;
4655  for(l = 1;l <= averWindow;l++){
4656  if((i + l) > zmax)
4657  a = working_space[xmin][ymin][zmax + 2 * sizez_ext] / maxch;
4658 
4659  else
4660  a = working_space[xmin][ymin][i + l + 2 * sizez_ext] / maxch;
4661 
4662  b = a - nip;
4663  if(a + nip <= 0)
4664  a = 1;
4665 
4666  else
4667  a = TMath::Sqrt(a + nip);
4668 
4669  b = b / a;
4670  b = TMath::Exp(b);
4671  sp = sp + b;
4672  if(i - l + 1 < zmin)
4673  a = working_space[xmin][ymin][zmin + 2 * sizez_ext] / maxch;
4674 
4675  else
4676  a = working_space[xmin][ymin][i - l + 1 + 2 * sizez_ext] / maxch;
4677 
4678  b = a - nim;
4679  if(a + nim <= 0)
4680  a = 1;
4681 
4682  else
4683  a = TMath::Sqrt(a + nim);
4684 
4685  b = b / a;
4686  b = TMath::Exp(b);
4687  sm = sm + b;
4688  }
4689  a = sp / sm;
4690  a = working_space[xmin][ymin][i + 1] = a * working_space[xmin][ymin][i];
4691  nom = nom + a;
4692  }
4693  for(i = xmin;i < xmax; i++){
4694  for(j = ymin;j < ymax; j++){
4695  nip = working_space[i][j + 1][zmin + 2 * sizez_ext] / maxch;
4696  nim = working_space[i + 1][j + 1][zmin + 2 * sizez_ext] / maxch;
4697  spx = 0,smx = 0;
4698  for(l = 1;l <= averWindow; l++){
4699  if(i + l > xmax)
4700  a = working_space[xmax][j][zmin + 2 * sizez_ext] / maxch;
4701 
4702  else
4703  a = working_space[i + l][j][zmin + 2 * sizez_ext] / maxch;
4704 
4705  b = a - nip;
4706  if(a + nip <= 0)
4707  a = 1;
4708 
4709  else
4710  a = TMath::Sqrt(a + nip);
4711 
4712  b = b / a;
4713  b = TMath::Exp(b);
4714  spx = spx + b;
4715  if(i - l + 1 < xmin)
4716  a = working_space[xmin][j][zmin + 2 * sizez_ext] / maxch;
4717 
4718  else
4719  a = working_space[i - l + 1][j][zmin + 2 * sizez_ext] / maxch;
4720 
4721  b = a - nim;
4722  if(a + nim <= 0)
4723  a = 1;
4724 
4725  else
4726  a = TMath::Sqrt(a + nim);
4727 
4728  b = b / a;
4729  b = TMath::Exp(b);
4730  smx = smx + b;
4731  }
4732  spy = 0,smy = 0;
4733  nip = working_space[i + 1][j][zmin + 2 * sizez_ext] / maxch;
4734  nim = working_space[i + 1][j + 1][zmin + 2 * sizez_ext] / maxch;
4735  for(l = 1;l <= averWindow; l++){
4736  if(j + l > ymax)
4737  a = working_space[i][ymax][zmin + 2 * sizez_ext] / maxch;
4738 
4739  else
4740  a = working_space[i][j + l][zmin + 2 * sizez_ext] / maxch;
4741 
4742  b = a - nip;
4743  if(a + nip <= 0)
4744  a = 1;
4745 
4746  else
4747  a = TMath::Sqrt(a + nip);
4748 
4749  b = b / a;
4750  b = TMath::Exp(b);
4751  spy = spy + b;
4752  if(j - l + 1 < ymin)
4753  a = working_space[i][ymin][zmin + 2 * sizez_ext] / maxch;
4754 
4755  else
4756  a = working_space[i][j - l + 1][zmin + 2 * sizez_ext] / maxch;
4757 
4758  b = a - nim;
4759  if(a + nim <= 0)
4760  a = 1;
4761 
4762  else
4763  a = TMath::Sqrt(a + nim);
4764 
4765  b = b / a;
4766  b = TMath::Exp(b);
4767  smy = smy + b;
4768  }
4769  a = (spx * working_space[i][j + 1][zmin] + spy * working_space[i + 1][j][zmin]) / (smx + smy);
4770  working_space[i + 1][j + 1][zmin] = a;
4771  nom = nom + a;
4772  }
4773  }
4774  for(i = xmin;i < xmax;i++){
4775  for(j = zmin;j < zmax;j++){
4776  nip = working_space[i][ymin][j + 1 + 2 * sizez_ext] / maxch;
4777  nim = working_space[i + 1][ymin][j + 1 + 2 * sizez_ext] / maxch;
4778  spx = 0,smx = 0;
4779  for(l = 1;l <= averWindow; l++){
4780  if(i + l > xmax)
4781  a = working_space[xmax][ymin][j + 2 * sizez_ext] / maxch;
4782 
4783  else
4784  a = working_space[i + l][ymin][j + 2 * sizez_ext] / maxch;
4785 
4786  b = a - nip;
4787  if(a + nip <= 0)
4788  a = 1;
4789 
4790  else
4791  a = TMath::Sqrt(a + nip);
4792 
4793  b = b / a;
4794  b = TMath::Exp(b);
4795  spx = spx + b;
4796  if(i - l + 1 < xmin)
4797  a = working_space[xmin][ymin][j + 2 * sizez_ext] / maxch;
4798 
4799  else
4800  a = working_space[i - l + 1][ymin][j + 2 * sizez_ext] / maxch;
4801 
4802  b = a - nim;
4803  if(a + nim <= 0)
4804  a = 1;
4805 
4806  else
4807  a = TMath::Sqrt(a + nim);
4808 
4809  b = b / a;
4810  b = TMath::Exp(b);
4811  smx = smx + b;
4812  }
4813  spz = 0,smz = 0;
4814  nip = working_space[i + 1][ymin][j + 2 * sizez_ext] / maxch;
4815  nim = working_space[i + 1][ymin][j + 1 + 2 * sizez_ext] / maxch;
4816  for(l = 1;l <= averWindow; l++){
4817  if(j + l > zmax)
4818  a = working_space[i][ymin][zmax + 2 * sizez_ext] / maxch;
4819 
4820  else
4821  a = working_space[i][ymin][j + l + 2 * sizez_ext] / maxch;
4822 
4823  b = a - nip;
4824  if(a + nip <= 0)
4825  a = 1;
4826 
4827  else
4828  a = TMath::Sqrt(a + nip);
4829 
4830  b = b / a;
4831  b = TMath::Exp(b);
4832  spz = spz + b;
4833  if(j - l + 1 < zmin)
4834  a = working_space[i][ymin][zmin + 2 * sizez_ext] / maxch;
4835 
4836  else
4837  a = working_space[i][ymin][j - l + 1 + 2 * sizez_ext] / maxch;
4838 
4839  b = a - nim;
4840  if(a + nim <= 0)
4841  a = 1;
4842 
4843  else
4844  a = TMath::Sqrt(a + nim);
4845 
4846  b = b / a;
4847  b = TMath::Exp(b);
4848  smz = smz + b;
4849  }
4850  a = (spx * working_space[i][ymin][j + 1] + spz * working_space[i + 1][ymin][j]) / (smx + smz);
4851  working_space[i + 1][ymin][j + 1] = a;
4852  nom = nom + a;
4853  }
4854  }
4855  for(i = ymin;i < ymax;i++){
4856  for(j = zmin;j < zmax;j++){
4857  nip = working_space[xmin][i][j + 1 + 2 * sizez_ext] / maxch;
4858  nim = working_space[xmin][i + 1][j + 1 + 2 * sizez_ext] / maxch;
4859  spy = 0,smy = 0;
4860  for(l = 1;l <= averWindow; l++){
4861  if(i + l > ymax)
4862  a = working_space[xmin][ymax][j + 2 * sizez_ext] / maxch;
4863 
4864  else
4865  a = working_space[xmin][i + l][j + 2 * sizez_ext] / maxch;
4866 
4867  b = a - nip;
4868  if(a + nip <= 0)
4869  a = 1;
4870 
4871  else
4872  a = TMath::Sqrt(a + nip);
4873 
4874  b = b / a;
4875  b = TMath::Exp(b);
4876  spy = spy + b;
4877  if(i - l + 1 < ymin)
4878  a = working_space[xmin][ymin][j + 2 * sizez_ext] / maxch;
4879 
4880  else
4881  a = working_space[xmin][i - l + 1][j + 2 * sizez_ext] / maxch;
4882 
4883  b = a - nim;
4884  if(a + nim <= 0)
4885  a = 1;
4886 
4887  else
4888  a = TMath::Sqrt(a + nim);
4889 
4890  b = b / a;
4891  b = TMath::Exp(b);
4892  smy = smy + b;
4893  }
4894  spz = 0,smz = 0;
4895  nip = working_space[xmin][i + 1][j + 2 * sizez_ext] / maxch;
4896  nim = working_space[xmin][i + 1][j + 1 + 2 * sizez_ext] / maxch;
4897  for(l = 1;l <= averWindow; l++){
4898  if(j + l > zmax)
4899  a = working_space[xmin][i][zmax + 2 * sizez_ext] / maxch;
4900 
4901  else
4902  a = working_space[xmin][i][j + l + 2 * sizez_ext] / maxch;
4903 
4904  b = a - nip;
4905  if(a + nip <= 0)
4906  a = 1;
4907 
4908  else
4909  a = TMath::Sqrt(a + nip);
4910 
4911  b = b / a;
4912  b = TMath::Exp(b);
4913  spz = spz + b;
4914  if(j - l + 1 < zmin)
4915  a = working_space[xmin][i][zmin + 2 * sizez_ext] / maxch;
4916 
4917  else
4918  a = working_space[xmin][i][j - l + 1 + 2 * sizez_ext] / maxch;
4919 
4920  b = a - nim;
4921  if(a + nim <= 0)
4922  a = 1;
4923 
4924  else
4925  a = TMath::Sqrt(a + nim);
4926 
4927  b = b / a;
4928  b = TMath::Exp(b);
4929  smz = smz + b;
4930  }
4931  a = (spy * working_space[xmin][i][j + 1] + spz * working_space[xmin][i + 1][j]) / (smy + smz);
4932  working_space[xmin][i + 1][j + 1] = a;
4933  nom = nom + a;
4934  }
4935  }
4936  for(i = xmin;i < xmax; i++){
4937  for(j = ymin;j < ymax; j++){
4938  for(k = zmin;k < zmax; k++){
4939  nip = working_space[i][j + 1][k + 1 + 2 * sizez_ext] / maxch;
4940  nim = working_space[i + 1][j + 1][k + 1 + 2 * sizez_ext] / maxch;
4941  spx = 0,smx = 0;
4942  for(l = 1;l <= averWindow; l++){
4943  if(i + l > xmax)
4944  a = working_space[xmax][j][k + 2 * sizez_ext] / maxch;
4945 
4946  else
4947  a = working_space[i + l][j][k + 2 * sizez_ext] / maxch;
4948 
4949  b = a - nip;
4950  if(a + nip <= 0)
4951  a = 1;
4952 
4953  else
4954  a = TMath::Sqrt(a + nip);
4955 
4956  b = b / a;
4957  b = TMath::Exp(b);
4958  spx = spx + b;
4959  if(i - l + 1 < xmin)
4960  a = working_space[xmin][j][k + 2 * sizez_ext] / maxch;
4961 
4962  else
4963  a = working_space[i - l + 1][j][k + 2 * sizez_ext] / maxch;
4964 
4965  b = a - nim;
4966  if(a + nim <= 0)
4967  a = 1;
4968 
4969  else
4970  a = TMath::Sqrt(a + nim);
4971 
4972  b = b / a;
4973  b = TMath::Exp(b);
4974  smx = smx + b;
4975  }
4976  spy = 0,smy = 0;
4977  nip = working_space[i + 1][j][k + 1 + 2 * sizez_ext] / maxch;
4978  nim = working_space[i + 1][j + 1][k + 1 + 2 * sizez_ext] / maxch;
4979  for(l = 1;l <= averWindow; l++){
4980  if(j + l > ymax)
4981  a = working_space[i][ymax][k + 2 * sizez_ext] / maxch;
4982 
4983  else
4984  a = working_space[i][j + l][k + 2 * sizez_ext] / maxch;
4985 
4986  b = a - nip;
4987  if(a + nip <= 0)
4988  a = 1;
4989 
4990  else
4991  a = TMath::Sqrt(a + nip);
4992 
4993  b = b / a;
4994  b = TMath::Exp(b);
4995  spy = spy + b;
4996  if(j - l + 1 < ymin)
4997  a = working_space[i][ymin][k + 2 * sizez_ext] / maxch;
4998 
4999  else
5000  a = working_space[i][j - l + 1][k + 2 * sizez_ext] / maxch;
5001 
5002  b = a - nim;
5003  if(a + nim <= 0)
5004  a = 1;
5005 
5006  else
5007  a = TMath::Sqrt(a + nim);
5008 
5009  b = b / a;
5010  b = TMath::Exp(b);
5011  smy = smy + b;
5012  }
5013  spz = 0,smz = 0;
5014  nip = working_space[i + 1][j + 1][k + 2 * sizez_ext] / maxch;
5015  nim = working_space[i + 1][j + 1][k + 1 + 2 * sizez_ext] / maxch;
5016  for(l = 1;l <= averWindow; l++ ){
5017  if(j + l > zmax)
5018  a = working_space[i][j][zmax + 2 * sizez_ext] / maxch;
5019 
5020  else
5021  a = working_space[i][j][k + l + 2 * sizez_ext] / maxch;
5022 
5023  b = a - nip;
5024  if(a + nip <= 0)
5025  a = 1;
5026 
5027  else
5028  a = TMath::Sqrt(a + nip);
5029 
5030  b = b / a;
5031  b = TMath::Exp(b);
5032  spz = spz + b;
5033  if(j - l + 1 < ymin)
5034  a = working_space[i][j][zmin + 2 * sizez_ext] / maxch;
5035 
5036  else
5037  a = working_space[i][j][k - l + 1 + 2 * sizez_ext] / maxch;
5038 
5039  b = a - nim;
5040  if(a + nim <= 0)
5041  a = 1;
5042 
5043  else
5044  a = TMath::Sqrt(a + nim);
5045 
5046  b = b / a;
5047  b = TMath::Exp(b);
5048  smz = smz + b;
5049  }
5050  a = (spx * working_space[i][j + 1][k + 1] + spy * working_space[i + 1][j][k + 1] + spz * working_space[i + 1][j + 1][k]) / (smx + smy + smz);
5051  working_space[i + 1][j + 1][k + 1] = a;
5052  nom = nom + a;
5053  }
5054  }
5055  }
5056  a = 0;
5057  for(i = xmin;i <= xmax; i++){
5058  for(j = ymin;j <= ymax; j++){
5059  for(k = zmin;k <= zmax; k++){
5060  working_space[i][j][k] = working_space[i][j][k] / nom;
5061  a+=working_space[i][j][k];
5062  }
5063  }
5064  }
5065  for(i = 0;i < sizex_ext; i++){
5066  for(j = 0;j < sizey_ext; j++){
5067  for(k = 0;k < sizez_ext; k++){
5068  working_space[i][j][k + 2 * sizez_ext] = working_space[i][j][k] * plocha_markov / a;
5069  }
5070  }
5071  }
5072  }
5073 
5074  maximum = 0;
5075  for(k = 0;k < ssizez; k++){
5076  for(j = 0;j < ssizey; j++){
5077  for(i = 0;i < ssizex; i++){
5078  working_space[i][j][k] = 0;
5079  working_space[i][j][sizez_ext + k] = 0;
5080  if(working_space[i][j][k + 3 * sizez_ext] > maximum)
5081  maximum=working_space[i][j][k+3*sizez_ext];
5082  }
5083  }
5084  }
5085  for(i = 0;i < PEAK_WINDOW; i++){
5086  c[i] = 0;
5087  }
5088  j = (Int_t)(pocet_sigma * sigma + 0.5);
5089  for(i = -j;i <= j; i++){
5090  a=i;
5091  a = -a * a;
5092  b = 2.0 * sigma * sigma;
5093  a = a / b;
5094  a = TMath::Exp(a);
5095  s = i;
5096  s = s * s;
5097  s = s - sigma * sigma;
5098  s = s / (sigma * sigma * sigma * sigma);
5099  s = s * a;
5100  c[PEAK_WINDOW / 2 + i] = s;
5101  }
5102  norma = 0;
5103  for(i = 0;i < PEAK_WINDOW; i++){
5104  norma = norma + TMath::Abs(c[i]);
5105  }
5106  for(i = 0;i < PEAK_WINDOW; i++){
5107  c[i] = c[i] / norma;
5108  }
5109  a = pocet_sigma * sigma + 0.5;
5110  i = (Int_t)a;
5111  zmin = i;
5112  zmax = sizez_ext - i - 1;
5113  ymin = i;
5114  ymax = sizey_ext - i - 1;
5115  xmin = i;
5116  xmax = sizex_ext - i - 1;
5117  lmin = PEAK_WINDOW / 2 - i;
5118  lmax = PEAK_WINDOW / 2 + i;
5119  for(i = xmin;i <= xmax; i++){
5120  for(j = ymin;j <= ymax; j++){
5121  for(k = zmin;k <= zmax; k++){
5122  s = 0,f = 0;
5123  for(li = lmin;li <= lmax; li++){
5124  for(lj = lmin;lj <= lmax; lj++){
5125  for(lk = lmin;lk <= lmax; lk++){
5126  a = working_space[i + li - PEAK_WINDOW / 2][j + lj - PEAK_WINDOW / 2][k + lk - PEAK_WINDOW / 2 + 2 * sizez_ext];
5127  b = c[li] * c[lj] * c[lk];
5128  s += a * b;
5129  f += a * b * b;
5130  }
5131  }
5132  }
5133  working_space[i][j][k] = s;
5134  working_space[i][j][k + sizez_ext] = TMath::Sqrt(f);
5135  }
5136  }
5137  }
5138  for(x = xmin;x <= xmax; x++){
5139  for(y = ymin + 1;y < ymax; y++){
5140  for(z = zmin + 1;z < zmax; z++){
5141  val = working_space[x][y][z];
5142  val1 = working_space[x - 1][y - 1][z - 1];
5143  val2 = working_space[x ][y - 1][z - 1];
5144  val3 = working_space[x + 1][y - 1][z - 1];
5145  val4 = working_space[x - 1][y ][z - 1];
5146  val5 = working_space[x ][y ][z - 1];
5147  val6 = working_space[x + 1][y ][z - 1];
5148  val7 = working_space[x - 1][y + 1][z - 1];
5149  val8 = working_space[x ][y + 1][z - 1];
5150  val9 = working_space[x + 1][y + 1][z - 1];
5151  val10 = working_space[x - 1][y - 1][z ];
5152  val11 = working_space[x ][y - 1][z ];
5153  val12 = working_space[x + 1][y - 1][z ];
5154  val13 = working_space[x - 1][y ][z ];
5155  val14 = working_space[x + 1][y ][z ];
5156  val15 = working_space[x - 1][y + 1][z ];
5157  val16 = working_space[x ][y + 1][z ];
5158  val17 = working_space[x + 1][y + 1][z ];
5159  val18 = working_space[x - 1][y - 1][z + 1];
5160  val19 = working_space[x ][y - 1][z + 1];
5161  val20 = working_space[x + 1][y - 1][z + 1];
5162  val21 = working_space[x - 1][y ][z + 1];
5163  val22 = working_space[x ][y ][z + 1];
5164  val23 = working_space[x + 1][y ][z + 1];
5165  val24 = working_space[x - 1][y + 1][z + 1];
5166  val25 = working_space[x ][y + 1][z + 1];
5167  val26 = working_space[x + 1][y + 1][z + 1];
5168  f = -s_f_ratio_peaks * working_space[x][y][z + sizez_ext];
5169  if(val < f && val < val1 && val < val2 && val < val3 && val < val4 && val < val5 && val < val6 && val < val7 && val < val8 && val < val9 && val < val10 && val < val11 && val < val12 && val < val13 && val < val14 && val < val15 && val < val16 && val < val17 && val < val18 && val < val19 && val < val20 && val < val21 && val < val22 && val < val23 && val < val24 && val < val25 && val < val26){
5170  s=0,f=0;
5171  for(li = lmin;li <= lmax; li++){
5172  a = working_space[x + li - PEAK_WINDOW / 2][y][z + 2 * sizez_ext];
5173  s += a * c[li];
5174  f += a * c[li] * c[li];
5175  }
5176  f = -s_f_ratio_peaks * sqrt(f);
5177  if(s < f){
5178  s = 0,f = 0;
5179  for(li = lmin;li <= lmax; li++){
5180  a = working_space[x][y + li - PEAK_WINDOW / 2][z + 2 * sizez_ext];
5181  s += a * c[li];
5182  f += a * c[li] * c[li];
5183  }
5184  f = -s_f_ratio_peaks * sqrt(f);
5185  if(s < f){
5186  s = 0,f = 0;
5187  for(li = lmin;li <= lmax; li++){
5188  a = working_space[x][y][z + li - PEAK_WINDOW / 2 + 2 * sizez_ext];
5189  s += a * c[li];
5190  f += a * c[li] * c[li];
5191  }
5192  f = -s_f_ratio_peaks * sqrt(f);
5193  if(s < f){
5194  s = 0,f = 0;
5195  for(li = lmin;li <= lmax; li++){
5196  for(lj = lmin;lj <= lmax; lj++){
5197  a = working_space[x + li - PEAK_WINDOW / 2][y + lj - PEAK_WINDOW / 2][z + 2 * sizez_ext];
5198  s += a * c[li] * c[lj];
5199  f += a * c[li] * c[li] * c[lj] * c[lj];
5200  }
5201  }
5202  f = s_f_ratio_peaks * sqrt(f);
5203  if(s > f){
5204  s = 0,f = 0;
5205  for(li = lmin;li <= lmax; li++){
5206  for(lj = lmin;lj <= lmax; lj++){
5207  a = working_space[x + li - PEAK_WINDOW / 2][y][z + lj - PEAK_WINDOW / 2 + 2 * sizez_ext];
5208  s += a * c[li] * c[lj];
5209  f += a * c[li] * c[li] * c[lj] * c[lj];
5210  }
5211  }
5212  f = s_f_ratio_peaks * sqrt(f);
5213  if(s > f){
5214  s = 0,f = 0;
5215  for(li = lmin;li <= lmax; li++){
5216  for(lj=lmin;lj<=lmax;lj++){
5217  a = working_space[x][y + li - PEAK_WINDOW / 2][z + lj - PEAK_WINDOW / 2 + 2 * sizez_ext];
5218  s += a * c[li] * c[lj];
5219  f += a * c[li] * c[li] * c[lj] * c[lj];
5220  }
5221  }
5222  f = s_f_ratio_peaks * sqrt(f);
5223  if(s > f){
5224  if(x >= shift && x < ssizex + shift && y >= shift && y < ssizey + shift && z >= shift && z < ssizez + shift){
5225  if(working_space[x][y][z + 3 * sizez_ext] > threshold * maximum / 100.0){
5226  if(peak_index<fMaxPeaks){
5227  for(k = x - 1,a = 0,b = 0;k <= x + 1; k++){
5228  a += (Double_t)(k - shift) * working_space[k][y][z];
5229  b += working_space[k][y][z];
5230  }
5231  fPositionX[peak_index] = a / b;
5232  for(k = y - 1,a = 0,b = 0;k <= y + 1; k++){
5233  a += (Double_t)(k - shift) * working_space[x][k][z];
5234  b += working_space[x][k][z];
5235  }
5236  fPositionY[peak_index] = a / b;
5237  for(k = z - 1,a = 0,b = 0;k <= z + 1; k++){
5238  a += (Double_t)(k - shift) * working_space[x][y][k];
5239  b += working_space[x][y][k];
5240  }
5241  fPositionZ[peak_index] = a / b;
5242  peak_index += 1;
5243  }
5244  }
5245  }
5246  }
5247  }
5248  }
5249  }
5250  }
5251  }
5252  }
5253  }
5254  }
5255  }
5256  for(i = 0;i < ssizex; i++){
5257  for(j = 0;j < ssizey; j++){
5258  for(k = 0;k < ssizez; k++){
5259  val = -working_space[i + shift][j + shift][k + shift];
5260  if( val < 0)
5261  val = 0;
5262  dest[i][j][k] = val;
5263  }
5264  }
5265  }
5266  k = (Int_t)(4 * sigma + 0.5);
5267  k = 4 * k;
5268  for(i = 0;i < ssizex + k; i++){
5269  for(j = 0;j < ssizey + k; j++)
5270  delete[] working_space[i][j];
5271  delete[] working_space[i];
5272  }
5273  delete[] working_space;
5274  fNPeaks = peak_index;
5275  return fNPeaks;
5276 }
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:51
void SetResolution(Double_t resolution=1)
resolution: determines resolution of the neighboring peaks default value is 1 correspond to 3 sigma d...
Definition: TSpectrum3.cxx:244
Double_t * fPosition
Definition: TSpectrum3.h:24
float xmin
Definition: THbookFile.cxx:93
static double p3(double t, double a, double b, double c, double d)
Int_t fNPeaks
Definition: TSpectrum3.h:23
const char Option_t
Definition: RtypesCore.h:62
float ymin
Definition: THbookFile.cxx:93
Int_t SearchFast(const Double_t ***source, Double_t ***dest, Int_t ssizex, Int_t ssizey, Int_t ssizez, Double_t sigma, Double_t threshold, Bool_t markov, Int_t averWindow)
TH1 * h
Definition: legend2.C:5
const char * SmoothMarkov(Double_t ***source, Int_t ssizex, Int_t ssizey, Int_t ssizez, Int_t averWindow)
THREE-DIMENSIONAL MARKOV SPECTRUM SMOOTHING FUNCTION // // This function calculates smoothed spectrum...
virtual Double_t GetBinContent(Int_t bin) const
Return content of bin number bin.
Definition: TH1.cxx:4635
const char * Deconvolution(Double_t ***source, const Double_t ***resp, Int_t ssizex, Int_t ssizey, Int_t ssizez, Int_t numberIterations, Int_t numberRepetitions, Double_t boost)
THREE-DIMENSIONAL DECONVOLUTION FUNCTION // This function calculates deconvolution from source spectr...
Short_t Min(Short_t a, Short_t b)
Definition: TMathBase.h:170
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
TArc * a
Definition: textangle.C:12
const Bool_t kFALSE
Definition: Rtypes.h:92
Short_t Abs(Short_t d)
Definition: TMathBase.h:110
LongDouble_t Power(LongDouble_t x, LongDouble_t y)
Definition: TMath.h:501
virtual Int_t GetDimension() const
Definition: TH1.h:283
double sqrt(double)
Double_t x[n]
Definition: legend1.C:17
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:33
unsigned int r3[N_CITIES]
Definition: simanTSP.cxx:323
static double p2(double t, double a, double b, double c)
virtual Double_t GetBinCenter(Int_t bin) const
Return center of bin.
Definition: TAxis.cxx:449
Double_t * fPositionZ
Definition: TSpectrum3.h:27
virtual const char * Background(const TH1 *hist, Int_t niter, Option_t *option="goff")
ONE-DIMENSIONAL BACKGROUND ESTIMATION FUNCTION // This function calculates background spectrum from s...
Definition: TSpectrum3.cxx:131
Double_t * fPositionY
Definition: TSpectrum3.h:26
float ymax
Definition: THbookFile.cxx:93
Double_t fResolution
Definition: TSpectrum3.h:28
unsigned int r1[N_CITIES]
Definition: simanTSP.cxx:321
LVector boost(const LVector &v, const BoostVector &b)
Boost a generic Lorentz Vector class using a generic 3D Vector class describing the boost The only re...
Definition: VectorUtil.h:329
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:918
TLine * l
Definition: textangle.C:4
TAxis * GetYaxis()
Definition: TH1.h:320
Advanced 3-dimentional spectra processing functions.
Definition: TSpectrum3.h:20
float xmax
Definition: THbookFile.cxx:93
static double p1(double t, double a, double b)
Int_t fMaxPeaks
Definition: TSpectrum3.h:22
Double_t Exp(Double_t x)
Definition: TMath.h:495
Int_t SearchHighRes(const Double_t ***source, Double_t ***dest, Int_t ssizex, Int_t ssizey, Int_t ssizez, Double_t sigma, Double_t threshold, Bool_t backgroundRemove, Int_t deconIterations, Bool_t markov, Int_t averWindow)
#define ClassImp(name)
Definition: Rtypes.h:279
double f(double x)
double Double_t
Definition: RtypesCore.h:55
Double_t y[n]
Definition: legend1.C:17
The TH1 histogram class.
Definition: TH1.h:80
TH1 * fHistogram
Definition: TSpectrum3.h:29
#define PEAK_WINDOW
Definition: TSpectrum3.cxx:63
Double_t * fPositionX
Definition: TSpectrum3.h:25
TAxis * GetZaxis()
Definition: TH1.h:321
#define dest(otri, vertexptr)
Definition: triangle.c:1040
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:202
Double_t Sqrt(Double_t x)
Definition: TMath.h:464
Int_t GetNbins() const
Definition: TAxis.h:125
double exp(double)
const Bool_t kTRUE
Definition: Rtypes.h:91
virtual Int_t Search(const TH1 *hist, Double_t sigma=2, Option_t *option="goff", Double_t threshold=0.05)
ONE-DIMENSIONAL PEAK SEARCH FUNCTION // This function searches for peaks in source spectrum in hin //...
Definition: TSpectrum3.cxx:178
const Int_t n
Definition: legend1.C:16
virtual void Print(Option_t *option="") const
Print the array of positions.
Definition: TSpectrum3.cxx:142
TSpectrum3()
Constructor.
Definition: TSpectrum3.cxx:70
unsigned int r2[N_CITIES]
Definition: simanTSP.cxx:322
TAxis * GetXaxis()
Definition: TH1.h:319
virtual ~TSpectrum3()
Destructor.
Definition: TSpectrum3.cxx:109