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