![(please configure the [header_logo] section in trac.ini)](/PI/chrome/site/your_project_logo.png){kind=logo}
Changeset 914 in Sophya for trunk/SophyaLib/HiStats/histos.cc
- Timestamp:
- Apr 13, 2000, 6:04:50 PM (25 years ago)
- File:
-
- 1 edited
-
trunk/SophyaLib/HiStats/histos.cc (modified) (77 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/SophyaLib/HiStats/histos.cc
r763 r914 1 1 // 2 // $Id: histos.cc,v 1. 1.1.1 2000-03-02 16:51:32ansari Exp $2 // $Id: histos.cc,v 1.2 2000-04-13 16:04:11 ansari Exp $ 3 3 // 4 4 … … 13 13 #include "generalfit.h" 14 14 15 //++ 16 // Class Histo 17 // Lib Outils++ 18 // include histos.h 19 // 20 // Classe d'histogrammes 1D 21 //-- 22 23 //++ 24 // Titre Constructeurs 25 //-- 26 27 /********* Methode *********/ 28 //++ 15 /********* Methode *********/ 16 /*! Constructeur par defaut */ 29 17 Histo::Histo() 30 //31 //--32 18 : data(NULL), err2(NULL), 33 19 under(0), over(0), nHist(0), nEntries(0), … … 39 25 40 26 /********* Methode *********/ 41 / /++27 /*! Constructeur d'un histo de nBin bins allant de xMin a xMax */ 42 28 Histo::Histo(float xMin, float xMax, int nBin) 43 //44 //--45 29 : data(new float[nBin]), err2(NULL), 46 30 under(0), over(0), nHist(0), nEntries(0), … … 53 37 54 38 /********* Methode *********/ 55 / /++39 /*! Constructeur par copie */ 56 40 Histo::Histo(const Histo& H) 57 //58 //--59 41 : data(new float[H.bins]), err2(NULL), 60 42 under(H.under), over(H.over), nHist(H.nHist), nEntries(H.nEntries), … … 71 53 72 54 /********* Methode *********/ 55 /*! Gestion de la des-allocation */ 73 56 void Histo::Delete() 74 57 { … … 81 64 82 65 /********* Methode *********/ 66 /*! Destructeur */ 83 67 Histo::~Histo() 84 68 { … … 86 70 } 87 71 88 //++ 89 // Titre Methodes 90 //-- 91 92 /********* Methode *********/ 93 //++ 72 /********* Methode *********/ 73 /*! 74 Remise a zero 75 */ 94 76 void Histo::Zero() 95 //96 // Remise a zero97 //--98 77 { 99 78 memset(data, 0, bins*sizeof(float)); … … 105 84 106 85 /********* Methode *********/ 107 //++ 86 /*! 87 Pour avoir le calcul des erreurs 88 */ 108 89 void Histo::Errors() 109 //110 // Pour avoir le calcul des erreurs111 //--112 90 { 113 91 if( bins > 0 ) { … … 118 96 119 97 /********* Methode *********/ 120 //++ 98 /*! 99 Operateur egal 100 */ 121 101 Histo& Histo::operator = (const Histo& h) 122 //123 //--124 102 { 125 103 if(this == &h) return *this; … … 145 123 146 124 /********* Methode *********/ 147 //++ 125 /*! 126 Operateur de multiplication par une constante 127 */ 148 128 Histo& Histo::operator *= (double b) 149 //150 //--151 129 { 152 130 double b2 = b*b; … … 162 140 } 163 141 164 //++ 142 /*! 143 Operateur de division par une constante 144 */ 165 145 Histo& Histo::operator /= (double b) 166 //167 //--168 146 { 169 147 if (b==0.) THROW(inconsistentErr); … … 180 158 } 181 159 182 //++ 160 /*! 161 Operateur d'addition d'une constante 162 */ 183 163 Histo& Histo::operator += (double b) 184 //185 //--186 164 { 187 165 for(int i=0;i<bins;i++) data[i] += b; … … 193 171 } 194 172 195 //++ 173 /*! 174 Operateur de soustraction d'une constante 175 */ 196 176 Histo& Histo::operator -= (double b) 197 //198 //--199 177 { 200 178 for(int i=0;i<bins;i++) data[i] -= b; … … 207 185 208 186 /********* Methode *********/ 209 //++ 187 /*! 188 Operateur H2 = H1 * b 189 */ 210 190 Histo operator * (const Histo& a, double b) 211 //212 //--213 191 { 214 192 Histo result(a); … … 216 194 } 217 195 218 //++ 196 /*! 197 Operateur H2 = b * H1 198 */ 219 199 Histo operator * (double b, const Histo& a) 220 //221 //--222 200 { 223 201 Histo result(a); … … 225 203 } 226 204 227 //++ 205 /*! 206 Operateur H2 = H1 / b 207 */ 228 208 Histo operator / (const Histo& a, double b) 229 //230 //--231 209 { 232 210 Histo result(a); … … 234 212 } 235 213 236 //++ 214 /*! 215 Operateur H2 = H1 + b 216 */ 237 217 Histo operator + (const Histo& a, double b) 238 //239 //--240 218 { 241 219 Histo result(a); … … 243 221 } 244 222 245 //++ 223 /*! 224 Operateur H2 = b + H1 225 */ 246 226 Histo operator + (double b, const Histo& a) 247 //248 //--249 227 { 250 228 Histo result(a); … … 252 230 } 253 231 254 //++ 232 /*! 233 Operateur H2 = H1 - b 234 */ 255 235 Histo operator - (const Histo& a, double b) 256 //257 //--258 236 { 259 237 Histo result(a); … … 261 239 } 262 240 263 //++ 241 /*! 242 Operateur H2 = b - H1 243 */ 264 244 Histo operator - (double b, const Histo& a) 265 //266 //--267 245 { 268 246 Histo result(a); … … 272 250 273 251 /********* Methode *********/ 274 //++ 252 /*! 253 Operateur H += H1 254 */ 275 255 Histo& Histo::operator += (const Histo& a) 276 //277 //--278 256 { 279 257 if(bins!=a.bins) THROW(sizeMismatchErr); … … 291 269 } 292 270 293 //++ 271 /*! 272 Operateur H -= H1 273 */ 294 274 Histo& Histo::operator -= (const Histo& a) 295 //296 //--297 275 { 298 276 if(bins!=a.bins) THROW(sizeMismatchErr); … … 310 288 } 311 289 312 //++ 290 /*! 291 Operateur H *= H1 292 */ 313 293 Histo& Histo::operator *= (const Histo& a) 314 //315 //--316 294 { 317 295 if(bins!=a.bins) THROW(sizeMismatchErr); … … 331 309 } 332 310 333 //++ 311 /*! 312 Operateur H /= H1 313 */ 334 314 Histo& Histo::operator /= (const Histo& a) 335 //336 //--337 315 { 338 316 if(bins!=a.bins) THROW(sizeMismatchErr); … … 359 337 360 338 /********* Methode *********/ 361 //++ 339 /*! 340 Operateur H = H1 + H2 341 */ 362 342 Histo operator + (const Histo& a, const Histo& b) 363 //364 //--365 343 { 366 344 if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr); … … 369 347 } 370 348 371 //++ 349 /*! 350 Operateur H = H1 - H2 351 */ 372 352 Histo operator - (const Histo& a, const Histo& b) 373 //374 //--375 353 { 376 354 if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr); … … 379 357 } 380 358 381 //++ 359 /*! 360 Operateur H = H1 * H2 361 */ 382 362 Histo operator * (const Histo& a, const Histo& b) 383 //384 //--385 363 { 386 364 if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr); … … 389 367 } 390 368 391 //++ 369 /*! 370 Operateur H = H1 / H2 371 */ 392 372 Histo operator / (const Histo& a, const Histo& b) 393 //394 //--395 373 { 396 374 if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr); … … 400 378 401 379 /********* Methode *********/ 402 //++ 380 /*! 381 Remplissage d'un tableau avec la valeur des abscisses 382 */ 403 383 void Histo::GetAbsc(Vector &v) 404 //405 // Remplissage d'un tableau avec la valeur des abscisses406 //--407 384 { 408 385 v.Realloc(bins); … … 411 388 } 412 389 413 //++ 390 /*! 391 Remplissage d'un tableau avec la valeur du contenu 392 */ 414 393 void Histo::GetValue(Vector &v) 415 //416 // Remplissage d'un tableau avec la valeur du contenu417 //--418 394 { 419 395 v.Realloc(bins); … … 422 398 } 423 399 424 //++ 400 /*! 401 Remplissage d'un tableau avec la valeur des erreurs au carre 402 */ 425 403 void Histo::GetError2(Vector &v) 426 //427 // Remplissage d'un tableau avec la valeur des erreurs au carre428 //--429 404 { 430 405 v.Realloc(bins); … … 434 409 } 435 410 436 //++ 411 /*! 412 Remplissage d'un tableau avec la valeur des erreurs 413 */ 437 414 void Histo::GetError(Vector &v) 438 //439 // Remplissage d'un tableau avec la valeur des erreurs440 //--441 415 { 442 416 v.Realloc(bins); … … 447 421 448 422 /********* Methode *********/ 449 //++ 423 /*! 424 Remplissage du contenu de l'histo avec les valeurs d'un vecteur 425 */ 450 426 void Histo::PutValue(Vector &v, int ierr) 451 //452 // Remplissage du contenu de l'histo avec les valeurs d'un vecteur453 //--454 427 { 455 428 if(v.NElts()<bins) THROW(sizeMismatchErr); … … 461 434 } 462 435 463 //++ 436 /*! 437 Addition du contenu de l'histo avec les valeurs d'un vecteur 438 */ 464 439 void Histo::PutValueAdd(Vector &v, int ierr) 465 //466 // Addition du contenu de l'histo avec les valeurs d'un vecteur467 //--468 440 { 469 441 if(v.NElts()<bins) THROW(sizeMismatchErr); … … 475 447 } 476 448 477 //++ 449 /*! 450 Remplissage des erreurs au carre de l'histo avec les valeurs d'un vecteur 451 */ 478 452 void Histo::PutError2(Vector &v) 479 //480 // Remplissage des erreurs au carre de l'histo avec les valeurs d'un vecteur481 //--482 453 { 483 454 if(v.NElts()<bins) THROW(sizeMismatchErr); … … 487 458 } 488 459 489 //++ 460 /*! 461 Addition des erreurs au carre de l'histo avec les valeurs d'un vecteur 462 */ 490 463 void Histo::PutError2Add(Vector &v) 491 //492 // Addition des erreurs au carre de l'histo avec les valeurs d'un vecteur493 //--494 464 { 495 465 if(v.NElts()<bins) THROW(sizeMismatchErr); … … 499 469 } 500 470 501 //++ 471 /*! 472 Remplissage des erreurs de l'histo avec les valeurs d'un vecteur 473 */ 502 474 void Histo::PutError(Vector &v) 503 //504 // Remplissage des erreurs de l'histo avec les valeurs d'un vecteur505 //--506 475 { 507 476 if(v.NElts()<bins) THROW(sizeMismatchErr); … … 513 482 514 483 /********* Methode *********/ 515 //++ 484 /*! 485 Addition du contenu de l'histo pour abscisse x poids w 486 */ 516 487 void Histo::Add(float x, float w) 517 //518 // Addition du contenu de l'histo pour abscisse x poids w519 //--520 488 { 521 489 int numBin = FindBin(x); … … 531 499 532 500 /********* Methode *********/ 533 //++ 501 /*! 502 Addition du contenu de l'histo bin numBin poids w 503 */ 534 504 void Histo::AddBin(int numBin, float w) 535 //536 // Addition du contenu de l'histo bin numBin poids w537 //--538 505 { 539 506 if (numBin<0) under += w; … … 548 515 549 516 /********* Methode *********/ 550 //++ 517 /*! 518 Remplissage du contenu de l'histo pour abscisse x poids w 519 */ 551 520 void Histo::SetBin(float x, float w) 552 //553 // Remplissage du contenu de l'histo pour abscisse x poids w554 //--555 521 { 556 522 int numBin = FindBin(x); … … 559 525 560 526 /********* Methode *********/ 561 //++ 527 /*! 528 Remplissage du contenu de l'histo pour numBin poids w 529 */ 562 530 void Histo::SetBin(int numBin, float w) 563 //564 // Remplissage du contenu de l'histo pour numBin poids w565 //--566 531 { 567 532 if (numBin<0) under = w; … … 575 540 576 541 /********* Methode *********/ 577 //++ 542 /*! 543 Remplissage des erreurs au carre pour abscisse x 544 */ 578 545 void Histo::SetErr2(float x, double e2) 579 //580 // Remplissage des erreurs au carre pour abscisse x581 //--582 546 { 583 547 int numBin = FindBin(x); … … 586 550 587 551 /********* Methode *********/ 588 //++ 552 /*! 553 Remplissage des erreurs au carre pour numBin poids 554 */ 589 555 void Histo::SetErr2(int numBin, double e2) 590 //591 // Remplissage des erreurs au carre pour numBin poids592 //--593 556 { 594 557 if( err2==NULL) return; … … 598 561 599 562 /********* Methode *********/ 600 //++ 563 /*! 564 Remplissage des erreurs pour abscisse x 565 */ 601 566 void Histo::SetErr(float x, float e) 602 //603 // Remplissage des erreurs pour abscisse x604 //--605 567 { 606 568 SetErr2(x, (double) e*e); … … 608 570 609 571 /********* Methode *********/ 610 //++ 572 /*! 573 Remplissage des erreurs pour numBin 574 */ 611 575 void Histo::SetErr(int numBin, float e) 612 //613 // Remplissage des erreurs pour numBin614 //--615 576 { 616 577 SetErr2(numBin, (double) e*e); … … 618 579 619 580 /********* Methode *********/ 620 //++ 581 /*! 582 Numero du bin ayant le contenu maximum 583 */ 621 584 int Histo::IMax() const 622 //623 // Numero du bin ayant le contenu maximum624 //--625 585 { 626 586 int imx=0; … … 633 593 634 594 /********* Methode *********/ 635 //++ 595 /*! 596 Numero du bin ayant le contenu minimum 597 */ 636 598 int Histo::IMin() const 637 //638 // Numero du bin ayant le contenu minimum639 //--640 599 { 641 600 int imx=0; … … 648 607 649 608 /********* Methode *********/ 650 //++ 609 /*! 610 Valeur le contenu maximum 611 */ 651 612 float Histo::VMax() const 652 //653 // Valeur le contenu maximum654 //--655 613 { 656 614 float mx=data[0]; … … 661 619 662 620 /********* Methode *********/ 663 //++ 621 /*! 622 Valeur le contenu minimum 623 */ 664 624 float Histo::VMin() const 665 //666 // Valeur le contenu minimum667 //--668 625 { 669 626 float mx=data[0]; … … 674 631 675 632 /********* Methode *********/ 676 //++ 633 /*! 634 Valeur moyenne 635 */ 677 636 float Histo::Mean() const 678 //679 // Valeur moyenne680 //--681 637 { 682 638 double n = 0; … … 691 647 692 648 /********* Methode *********/ 693 //++ 649 /*! 650 Valeur du sigma 651 */ 694 652 float Histo::Sigma() const 695 //696 // Valeur du sigma697 //--698 653 { 699 654 double n = 0; … … 714 669 715 670 /********* Methode *********/ 716 //++ 671 /*! 672 Valeur de la moyenne calculee entre les bin il et ih 673 */ 717 674 float Histo::MeanLH(int il,int ih) const 718 //719 // Valeur de la moyenne calculee entre les bin il et ih720 //--721 675 { 722 676 if( ih < il ) { il = 0; ih = bins-1; } … … 734 688 735 689 /********* Methode *********/ 736 //++ 690 /*! 691 Valeur de la moyenne calculee entre les bin il et ih 692 */ 737 693 float Histo::SigmaLH(int il,int ih) const 738 //739 // Valeur de la moyenne calculee entre les bin il et ih740 //--741 694 { 742 695 if( ih < il ) { il = 0; ih = bins - 1; } … … 759 712 760 713 /********* Methode *********/ 761 //++ 714 /*! 715 Valeur de la moyenne calculee entre x0-dx et x0+dx 716 */ 762 717 float Histo::Mean(float x0, float dx) const 763 //764 // Valeur de la moyenne calculee entre x0-dx et x0+dx765 //--766 718 { 767 719 double sdata = 0; … … 780 732 781 733 /********* Methode *********/ 782 //++ 734 /*! 735 Valeur du sigma calcule entre x0-dx et x0+dx 736 */ 783 737 float Histo::Sigma(float x0, float dx) const 784 //785 // Valeur du sigma calcule entre x0-dx et x0+dx786 //--787 738 { 788 739 double sx = 0; … … 804 755 805 756 /********* Methode *********/ 806 //++ 757 /*! 758 Valeur de la moyenne et du sigma nettoyes 759 */ 807 760 float Histo::CleanedMean(float& sigma) const 808 //809 // Valeur de la moyenne et du sigma nettoyes810 //--811 761 { 812 762 if (!nHist) return 0; … … 825 775 826 776 /********* Methode *********/ 827 //++ 777 /*! 778 Valeur de la moyenne nettoyee 779 */ 828 780 float Histo::CleanedMean() const 829 //830 // Valeur de la moyenne nettoyee831 //--832 781 { 833 782 if (!nHist) return 0; … … 837 786 838 787 /********* Methode *********/ 839 //++ 788 /*! 789 Retourne le nombre de bins non-nul 790 */ 840 791 int Histo::BinNonNul() const 841 //842 // Retourne le nombre de bins non-nul843 //--844 792 { 845 793 int non=0; … … 849 797 850 798 /********* Methode *********/ 851 //++ 799 /*! 800 Retourne le nombre de bins ayant une erreur non-nulle 801 */ 852 802 int Histo::ErrNonNul() const 853 //854 // Retourne le nombre de bins ayant une erreur non-nulle855 //--856 803 { 857 804 if(err2==NULL) return -1; … … 862 809 863 810 /********* Methode *********/ 864 //++ 811 /*! 812 Renvoie le numero de bin tel que il y ait "per" pourcent entrees 813 entre le bin 0 et ce bin (y compris le contenu de ce bin). 814 */ 865 815 int Histo::BinPercent(float per) const 866 //867 // Renvoie le numero de bin tel que il y ait "per" pourcent entrees868 // entre le bin 0 et ce bin (y compris le contenu de ce bin).869 //--870 816 { 871 817 double n = nHist*per; … … 881 827 882 828 /********* Methode *********/ 883 //++ 829 /*! 830 Renvoie les numeros de bins imin,imax (0=<i<bins) tels que: 831 \verbatim 832 notons I = bin contenant l'abscisse x 833 N1 = nombre d'entrees entre bin 0 et I compris 834 N2 = nombre d'entrees entre bin I et bins-1 compris 835 imin = bin tel que nombre d'entrees entre imin et I = N1 * per 836 imax = bin tel que nombre d'entrees entre I et imax = N2 * per 837 Return: <0 si echec 838 min(I-imin,imax-I) si ok 839 \endverbatim 840 */ 884 841 int Histo::BinPercent(float x,float per,int& imin,int& imax) 885 //886 // Renvoie les numeros de bins imin,imax (0=<i<bins) tels que:887 //| notons I = bin contenant l'abscisse x888 //| N1 = nombre d'entrees entre bin 0 et I compris889 //| N2 = nombre d'entrees entre bin I et bins-1 compris890 //| imin = bin tel que nombre d'entrees entre imin et I = N1 * per891 //| imax = bin tel que nombre d'entrees entre I et imax = N2 * per892 //| Return: <0 si echec893 //| min(I-imin,imax-I) si ok894 //--895 842 { 896 843 imin = imax = -1; … … 917 864 918 865 /********* Methode *********/ 919 //++ 866 /*! 867 Idem precedent mais renvoie xmin et xmax 868 */ 920 869 int Histo::BinPercent(float x,float per,float& xmin,float& xmax) 921 //922 // Idem precedent mais renvoie xmin et xmax923 //--924 870 { 925 871 xmin = xmax = 0.; … … 931 877 932 878 /********* Methode *********/ 933 //++ 879 /*! 880 Remplace l'histogramme par son integrale normalise a norm: 881 si norm <= 0 : pas de normalisation, integration seule 882 */ 934 883 void Histo::HInteg(float norm) 935 //936 // Remplace l'histogramme par son integrale normalise a norm:937 // si norm <= 0 : pas de normalisation, integration seule938 //--939 884 { 940 885 if(bins>1) … … 952 897 953 898 /********* Methode *********/ 954 //++ 899 /*! 900 Remplace l'histogramme par sa derivee 901 */ 955 902 void Histo::HDeriv() 956 //957 // Remplace l'histogramme par sa derivee958 //--959 903 { 960 904 if( bins <= 1 ) return; … … 970 914 971 915 /********* Methode *********/ 972 //++ 916 /*! 917 Pour rebinner l'histogramme sur nbinew bins 918 */ 973 919 void Histo::HRebin(int nbinew) 974 //975 // Pour rebinner l'histogramme sur nbinew bins976 //--977 920 { 978 921 if( nbinew <= 0 ) return; … … 1023 966 1024 967 /********* Methode *********/ 1025 //++ 968 /*! 969 Retourne le nombre de maxima locaux, la valeur du maximum (maxi) 970 et sa position (imax), ainsi que la valeur du second maximum 971 local (maxn) et sa position (imaxn). 972 Attention: si un maximum a la meme valeur sur plusieurs bins 973 consecutifs, le bin le plus a droite est pris. 974 */ 1026 975 int Histo::MaxiLocal(float& maxi,int& imax,float& maxn,int& imaxn) 1027 //1028 // Retourne le nombre de maxima locaux, la valeur du maximum (maxi)1029 // et sa position (imax), ainsi que la valeur du second maximum1030 // local (maxn) et sa position (imaxn).1031 // Attention: si un maximum a la meme valeur sur plusieurs bins1032 // consecutifs, le bin le plus a droite est pris.1033 //--1034 976 { 1035 977 int nml = 0; … … 1064 1006 1065 1007 /********* Methode *********/ 1066 //++ 1008 /*! 1009 Fit de la position du maximum de l'histo par un polynome 1010 de degre `degree' a `frac' pourcent du maximum. 1011 L'histo est suppose etre remplit de valeurs positives 1012 */ 1067 1013 float Histo::FitMax(int degree, float frac, int debug) const 1068 //1069 // Fit de la position du maximum de l'histo par un polynome1070 // de degre `degree' a `frac' pourcent du maximum.1071 // L'histo est suppose etre remplit de valeurs positives1072 //--1073 1014 { 1074 1015 if (degree < 2 || degree > 3) degree = 3; … … 1200 1141 1201 1142 /********* Methode *********/ 1202 //++ 1143 /*! 1144 Calcul de la largeur a frac pourcent du maximum 1145 autour du bin du maximum. 1146 L'histo est suppose etre remplit de valeurs positives 1147 */ 1203 1148 float Histo::FindWidth(float frac, int debug) const 1204 //1205 // Calcul de la largeur a frac pourcent du maximum1206 // autour du bin du maximum.1207 // L'histo est suppose etre remplit de valeurs positives1208 //--1209 1149 { 1210 1150 float xmax = BinCenter( IMax() ); … … 1213 1153 1214 1154 /********* Methode *********/ 1215 //++ 1155 /*! 1156 Calcul de la largeur a frac pourcent de la valeur du bin xmax. 1157 L'histo est suppose etre remplit de valeurs positives 1158 */ 1216 1159 float Histo::FindWidth(float xmax,float frac, int debug) const 1217 //1218 // Calcul de la largeur a frac pourcent de la valeur du bin xmax.1219 // L'histo est suppose etre remplit de valeurs positives1220 //--1221 1160 { 1222 1161 if (frac <= 0 || frac >= 1.) frac = 0.5; … … 1292 1231 1293 1232 /********* Methode *********/ 1294 //++ 1233 /*! 1234 Cf suivant mais im est le bin du maximum de l'histo 1235 */ 1295 1236 int Histo::EstimeMax(float& xm,int SzPav) 1296 //1297 // Cf suivant mais im est le bin du maximum de l'histo1298 //--1299 1237 { 1300 1238 int im = IMax(); … … 1303 1241 1304 1242 /********* Methode *********/ 1305 //++ 1243 /*! 1244 Determine l'abscisses du maximum donne par im 1245 en moyennant dans un pave SzPav autour du maximum 1246 \verbatim 1247 Return: 1248 0 = si fit maximum reussi avec SzPav pixels 1249 1 = si fit maximum reussi avec moins que SzPav pixels 1250 2 = si fit maximum echoue et renvoit BinCenter() 1251 -1 = si echec: SzPav <= 0 ou im hors limites 1252 \endverbatim 1253 */ 1306 1254 int Histo::EstimeMax(int& im,float& xm,int SzPav) 1307 //1308 // Determine l'abscisses du maximum donne par im1309 // en moyennant dans un pave SzPav autour du maximum1310 //| Return:1311 //| 0 = si fit maximum reussi avec SzPav pixels1312 //| 1 = si fit maximum reussi avec moins que SzPav pixels1313 //| 2 = si fit maximum echoue et renvoit BinCenter()1314 //| -1 = si echec: SzPav <= 0 ou im hors limites1315 //--1316 1255 { 1317 1256 xm = 0; … … 1341 1280 1342 1281 /********* Methode *********/ 1343 //++ 1282 /*! 1283 Determine la largeur a frac% du maximum a gauche (widthG) 1284 et a droite (widthD) 1285 */ 1344 1286 void Histo::EstimeWidthS(float frac,float& widthG,float& widthD) 1345 //1346 // Determine la largeur a frac% du maximum a gauche (widthG)1347 // et a droite (widthD)1348 //--1349 1287 { 1350 1288 int i; … … 1385 1323 1386 1324 ////////////////////////////////////////////////////////// 1387 //++ 1325 /*! 1326 Fit de l'histogramme par ``gfit''. 1327 \verbatim 1328 typ_err = 0 : 1329 - erreur attachee au bin si elle existe 1330 - sinon 1 1331 typ_err = 1 : 1332 - erreur attachee au bin si elle existe 1333 - sinon max( sqrt(abs(bin) ,1 ) 1334 typ_err = 2 : 1335 - erreur forcee a 1 1336 typ_err = 3 : 1337 - erreur forcee a max( sqrt(abs(bin) ,1 ) 1338 typ_err = 4 : 1339 - erreur forcee a 1, nulle si bin a zero. 1340 typ_err = 5 : 1341 - erreur forcee a max( sqrt(abs(bin) ,1 ), 1342 nulle si bin a zero. 1343 \endverbatim 1344 */ 1388 1345 int Histo::Fit(GeneralFit& gfit,unsigned short typ_err) 1389 //1390 // Fit de l'histogramme par ``gfit''.1391 //| typ_err = 0 :1392 //| - erreur attachee au bin si elle existe1393 //| - sinon 11394 //| typ_err = 1 :1395 //| - erreur attachee au bin si elle existe1396 //| - sinon max( sqrt(abs(bin) ,1 )1397 //| typ_err = 2 :1398 //| - erreur forcee a 11399 //| typ_err = 3 :1400 //| - erreur forcee a max( sqrt(abs(bin) ,1 )1401 //| typ_err = 4 :1402 //| - erreur forcee a 1, nulle si bin a zero.1403 //| typ_err = 5 :1404 //| - erreur forcee a max( sqrt(abs(bin) ,1 ),1405 //| nulle si bin a zero.1406 //--1407 1346 { 1408 1347 if(NBins()<=0) return -1000; … … 1430 1369 } 1431 1370 1432 //++ 1371 /*! 1372 Retourne une classe contenant les residus du fit ``gfit''. 1373 */ 1433 1374 Histo Histo::FitResidus(GeneralFit& gfit) 1434 //1435 // Retourne une classe contenant les residus du fit ``gfit''.1436 //--1437 1375 { 1438 1376 if(NBins()<=0) … … 1450 1388 } 1451 1389 1452 //++ 1390 /*! 1391 Retourne une classe contenant la fonction du fit ``gfit''. 1392 */ 1453 1393 Histo Histo::FitFunction(GeneralFit& gfit) 1454 //1455 // Retourne une classe contenant la fonction du fit ``gfit''.1456 //--1457 1394 { 1458 1395 if(NBins()<=0) … … 1471 1408 1472 1409 /********* Methode *********/ 1473 //++ 1410 /*! 1411 Impression de l'histogramme dans le fichier fp 1412 \verbatim 1413 hdyn = nombre de colonnes pour imprimer les etoiles 1414 si =0 alors defaut(100), 1415 si <0 pas de print histo seulement infos 1416 hmin = minimum de la dynamique 1417 hmax = maximum de la dynamique 1418 si hmax<=hmin : hmin=VMin() hmax=VMax() 1419 si hmax<=hmin et hmin=0 : hmin=0 hmax=VMax() 1420 sinon : hmin hmax 1421 pflag < 0 : on imprime les informations (nbin,min,...) sans l'histogramme 1422 = 0 : on imprime "BinCenter(i) data[i]" (note "... ...") 1423 bit 0 on : (v=1): numero_bin "... ..." 1424 bit 1 on : (v=2): "... ..." erreur 1425 \endverbatim 1426 */ 1474 1427 void Histo::PrintF(FILE * fp, int hdyn,float hmin, float hmax,int pflag, 1475 1428 int il, int ih) 1476 //1477 // Impression de l'histogramme dans le fichier fp1478 //| hdyn = nombre de colonnes pour imprimer les etoiles1479 //| si =0 alors defaut(100),1480 //| si <0 pas de print histo seulement infos1481 //| hmin = minimum de la dynamique1482 //| hmax = maximum de la dynamique1483 //| si hmax<=hmin : hmin=VMin() hmax=VMax()1484 //| si hmax<=hmin et hmin=0 : hmin=0 hmax=VMax()1485 //| sinon : hmin hmax1486 //| pflag < 0 : on imprime les informations (nbin,min,...) sans l'histogramme1487 //| = 0 : on imprime "BinCenter(i) data[i]" (note "... ...")1488 //| bit 0 on : (v=1): numero_bin "... ..."1489 //| bit 1 on : (v=2): "... ..." erreur1490 //--1491 1429 { 1492 1430 … … 1642 1580 1643 1581 /********* Methode *********/ 1644 //++ 1582 /*! 1583 Impression de l'histogramme sur stdout 1584 */ 1645 1585 void Histo::Print(int hdyn,float hmin, float hmax,int pflag, 1646 1586 int il, int ih) 1647 //1648 // Impression de l'histogramme sur stdout1649 //--1650 1587 { 1651 1588 Histo::PrintF(stdout, hdyn, hmin, hmax, pflag, il, ih); 1652 1589 } 1653 1654 1655 // Rappel des inlines functions pour commentaires1656 //++1657 // inline float XMin() const1658 // Retourne l'abscisse minimum1659 //--1660 //++1661 // inline float XMax() const1662 // Retourne l'abscisse maximum1663 //--1664 //++1665 // inline int NBins() const1666 // Retourne le nombre de bins1667 //--1668 //++1669 // inline float BinWidth() const1670 // Retourne la largeur du bin1671 //--1672 //++1673 // inline float* Bins() const1674 // Retourne le pointeur sur le tableaux des contenus1675 //--1676 //++1677 // inline float operator()(int i) const1678 // Retourne le contenu du bin i1679 //--1680 //++1681 // inline float& operator()(int i)1682 // Remplit le contenu du bin i1683 //--1684 //++1685 // inline float Error(int i) const1686 // Retourne l'erreur du bin i1687 //--1688 //++1689 // inline double Error2(int i) const1690 // Retourne l'erreur au carre du bin i1691 //--1692 //++1693 // inline double& Error2(int i)1694 // Remplit l'erreur au carre du bin i1695 //--1696 //++1697 // inline float NData() const1698 // Retourne la somme ponderee1699 //--1700 //++1701 // inline float NEntries()1702 // Retourne le nombre d'entrees1703 //--1704 //++1705 // inline float NOver() const1706 // Retourne le nombre d'overflow1707 //--1708 //++1709 // inline float NUnder() const1710 // Retourne le nombre d'underflow1711 //--1712 //++1713 // inline float BinLowEdge(int i) const1714 // Retourne l'abscisse du bord inferieur du bin i1715 //--1716 //++1717 // inline float BinCenter(int i) const1718 // Retourne l'abscisse du centre du bin i1719 //--1720 //++1721 // inline float BinHighEdge(int i) const1722 // Retourne l'abscisse du bord superieur du bin i1723 //--1724 //++1725 // inline int FindBin(float x) const1726 // Retourne le numero du bin contenant l'abscisse x1727 //--1728 1590 1729 1591
Note:
See TracChangeset
for help on using the changeset viewer.
