![(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
- Timestamp:
- Apr 13, 2000, 6:04:50 PM (25 years ago)
- Location:
- trunk/SophyaLib/HiStats
- Files:
-
- 6 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/SophyaLib/HiStats/hisprof.cc
r763 r914 6 6 #include "perrors.h" 7 7 8 //++ 9 // Class HProf 10 // Lib Outils++ 11 // include hisprof.h 12 // 13 // Classe de profil d'histogrammes. 14 //-- 15 16 //++ 17 // Titre Constructeurs 18 //-- 19 20 /********* Methode *********/ 21 //++ 8 9 /********* Methode *********/ 10 /*! 11 Constructeur par defaut. 12 */ 22 13 HProf::HProf() 23 //24 // Constructeur par defaut.25 //--26 14 : Histo() 27 15 , SumY(NULL), SumY2(NULL), SumW(NULL), Ok(false), YMin(1.), YMax(-1.), Opt(0) … … 31 19 32 20 /********* Methode *********/ 33 //++ 21 /*! 22 Constructeur. Histogramme de profil de ``nBin'' bins entre ``xMin'' 23 et ``xMax'' avec coupure d'acceptance sur y entre ``yMin'' et ``yMax''. 24 Si yMin>=yMax alors pas de coupure d'acceptance sur y. 25 Par defaut l'erreur du profil represente la dispersion dans le bin, 26 SetErrOpt(1) permet de demander de calculer l'erreur sur la moyenne. 27 */ 34 28 HProf::HProf(float xMin, float xMax, int nBin, float yMin, float yMax) 35 //36 // Constructeur. Histogramme de profil de ``nBin'' bins entre ``xMin''37 // et ``xMax'' avec coupure d'acceptance sur y entre ``yMin'' et ``yMax''.38 // Si yMin>=yMax alors pas de coupure d'acceptance sur y.39 // Par defaut l'erreur du profil represente la dispersion dans le bin,40 // SetErrOpt(1) permet de demander de calculer l'erreur sur la moyenne.41 //--42 29 : Histo(xMin,xMax,nBin) 43 30 , SumY(new double[nBin]), SumY2(new double[nBin]), SumW(new double[nBin]) … … 50 37 51 38 /********* Methode *********/ 52 //++ 39 /*! 40 Constructeur par copie. 41 */ 53 42 HProf::HProf(const HProf& H) 54 //55 // Constructeur par copie.56 //--57 43 : Histo(H) 58 44 , SumY(new double[H.bins]), SumY2(new double[H.bins]), SumW(new double[H.bins]) … … 66 52 67 53 /********* Methode *********/ 54 /*! 55 Des-allocation 56 */ 68 57 void HProf::Delete() 69 58 { … … 75 64 76 65 /********* Methode *********/ 66 /*! 67 Destructeur 68 */ 77 69 HProf::~HProf() 78 70 { … … 80 72 } 81 73 82 //++ 83 // Titre Methodes 84 //-- 85 86 /********* Methode *********/ 87 //++ 74 /********* Methode *********/ 75 /*! 76 Remise a zero 77 */ 88 78 void HProf::Zero() 89 //90 // Remise a zero91 //--92 79 { 93 80 memset(SumY, 0, bins*sizeof(double)); … … 99 86 100 87 /********* Methode *********/ 101 //++ 88 /*! 89 Pour changer l'option de calcul de l'erreur du profile. 90 Si ``spread'' = true alors l'erreur represente la dispersion 91 des donnees dans le bin, si = false elle represente l'erreur 92 sur la moyenne du bin. 93 \verbatim 94 - Pour le bin (j): 95 H(j) = sum(y), E(j) = sum(y^2), L(j) = sum(w) 96 -> s(j) = sqrt(E(j)/L(j) - (H(j)/L(j))^2) dispersion 97 -> e(j) = s(j)/sqrt(L(j)) erreur sur la moyenne 98 spread=true: opt=0 : dispersion des donnees dans le bin = s(j) 99 spread=false: opt=1 : erreur sur la moyenne du bin = e(j) 100 \endverbatim 101 */ 102 102 void HProf::SetErrOpt(bool spread) 103 //104 // Pour changer l'option de calcul de l'erreur du profile.105 // Si ``spread'' = true alors l'erreur represente la dispersion106 // des donnees dans le bin, si = false elle represente l'erreur107 // sur la moyenne du bin.108 //| - Pour le bin (j):109 //| H(j) = sum(y), E(j) = sum(y^2), L(j) = sum(w)110 //| -> s(j) = sqrt(E(j)/L(j) - (H(j)/L(j))^2) dispersion111 //| -> e(j) = s(j)/sqrt(L(j)) erreur sur la moyenne112 //| spread=true: opt=0 : dispersion des donnees dans le bin = s(j)113 //| spread=false: opt=1 : erreur sur la moyenne du bin = e(j)114 //--115 103 { 116 104 int opt = (spread) ? 0 : 1; … … 119 107 120 108 /********* Methode *********/ 121 //++ 109 /*! 110 Pour mettre a jour l'histogramme de profil. 111 Il est important d'appeler cette methode si on veut 112 utiliser les methodes de la classe Histo qui ne sont 113 pas redefinies dans la classe HProf. 114 En effet, pour des raisons de precision la classe 115 HProf travaille avec des tableaux en double precision 116 et seulement au moment ou l'on a besoin de l'histogramme 117 ce dernier est rempli avec les valeurs demandees (moyenne 118 et dispersion/erreur sur la moyenne). 119 */ 122 120 void HProf::UpdateHisto() const 123 //124 // Pour mettre a jour l'histogramme de profil.125 // Il est important d'appeler cette methode si on veut126 // utiliser les methodes de la classe Histo qui ne sont127 // pas redefinies dans la classe HProf.128 // En effet, pour des raisons de precision la classe129 // HProf travaille avec des tableaux en double precision130 // et seulement au moment ou l'on a besoin de l'histogramme131 // ce dernier est rempli avec les valeurs demandees (moyenne132 // et dispersion/erreur sur la moyenne).133 //--134 121 { 135 122 … … 153 140 154 141 /********* Methode *********/ 155 //++ 142 /*! 143 Addition au contenu de l'histo pour abscisse x de la valeur y et poids w 144 */ 156 145 void HProf::Add(float x, float y, float w) 157 //158 // Addition au contenu de l'histo pour abscisse x de la valeur y et poids w159 //--160 146 { 161 147 if(YMax>YMin && (y<YMin || YMax<y)) return; … … 174 160 175 161 /********* Methode *********/ 176 //++ 162 /*! 163 Addition au contenu de l'histo bin numBin de la valeur y poids w 164 */ 177 165 void HProf::AddBin(int numBin, float y, float w) 178 //179 // Addition au contenu de l'histo bin numBin de la valeur y poids w180 //--181 166 { 182 167 if(YMax>YMin && (y<YMin || YMax<y)) return; … … 194 179 195 180 /********* Methode *********/ 196 //++ 181 /*! 182 Operateur H = H1 183 */ 197 184 HProf& HProf::operator = (const HProf& h) 198 //199 //--200 185 { 201 186 if(this == &h) return *this; … … 218 203 219 204 /********* Methode *********/ 220 //++ 205 /*! 206 Operateur H += H1 207 208 Attention dans cette addition il n'y a pas de gestion 209 des YMin et YMax. L'addition est faite meme si les limites 210 en Y de ``a'' sont differentes de celles de ``this''. 211 */ 221 212 HProf& HProf::operator += (const HProf& a) 222 //223 // Attention dans cette addition il n'y a pas de gestion224 // des YMin et YMax. L'addition est faite meme si les limites225 // en Y de ``a'' sont differentes de celles de ``this''.226 //--227 213 { 228 214 if(bins!=a.bins) THROW(sizeMismatchErr); … … 240 226 241 227 /********* Methode *********/ 242 //++ 228 /*! 229 Operateur H = H1 + H2 230 Meme commentaire que pour l'operateur += 231 */ 243 232 HProf operator + (const HProf& a, const HProf& b) 244 //245 // Meme commentaire que pour l'operateur +=246 //--247 233 { 248 234 if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr); … … 250 236 return (c += b); 251 237 } 252 253 // Rappel des inlines functions pour commentaires254 //++255 // inline Histo GetHisto()256 // Retourne l'histogramme de profil.257 //--258 //++259 // inline void GetMean(Vector& v)260 // Retourne le contenu de la moyenne dans le vecteur v261 //--262 //++263 // inline void GetError2(Vector& v)264 // Retourne le contenu au carre de la dispersion/erreur dans le vecteur v265 //--266 //++267 // inline float operator()(int i) const268 // Retourne le contenu du bin i269 //--270 //++271 // inline float Error2(int i) const272 // Retourne le carre de la dispersion/erreur du bin i273 //--274 //++275 // inline float Error(int i) const276 // Retourne la dispersion/erreur du bin i277 //--278 //++279 // inline int Fit(GeneralFit& gfit)280 // Fit du profile par ``gfit''.281 //--282 //++283 // inline Histo* FitResidus(GeneralFit& gfit)284 // Retourne l'Histogramme des residus par ``gfit''.285 //--286 //++287 // inline Histo* FitFunction(GeneralFit& gfit)288 // Retourne l'Histogramme de la fonction fittee par ``gfit''.289 //--290 //++291 // inline void Print(int dyn,float hmin,float hmax,int pflag,int il,int ih)292 // Print, voir detail dans Histo::Print293 //--294 295 238 296 239 /////////////////////////////////////////////////////////// -
trunk/SophyaLib/HiStats/hisprof.h
r763 r914 10 10 namespace SOPHYA { 11 11 12 /*! 13 Classe de profil d'histogrammes. 14 */ 12 15 class HProf : public Histo { 13 16 friend class ObjFileIO<HProf>; … … 28 31 29 32 // Acces a l information 33 //! Retourne l'histogramme de profil. 30 34 inline Histo GetHisto() {if(!Ok) UpdateHisto(); return (Histo) *this;} 35 //! Retourne le contenu de la moyenne dans le vecteur v 31 36 inline void GetMean(Vector& v) {if(!Ok) UpdateHisto(); Histo::GetValue(v);} 37 //! Retourne le contenu au carre de la dispersion/erreur dans le vecteur v 32 38 inline void GetError2(Vector& v) {if(!Ok) UpdateHisto(); Histo::GetError2(v);} 39 //! Retourne le contenu du bin i 33 40 inline float operator()(int i) const {if(!Ok) UpdateHisto(); return data[i];} 41 //! Retourne le carre de la dispersion/erreur du bin i 34 42 inline float Error2(int i) const {if(!Ok) UpdateHisto(); return (float) err2[i];} 43 //! Retourne la dispersion/erreur du bin i 35 44 inline float Error(int i) const 36 45 {if(!Ok) UpdateHisto(); return err2[i]>0. ? (float) sqrt(err2[i]) : 0.f;} … … 42 51 43 52 // Fit 53 //! Fit du profile par ``gfit''. 44 54 inline int Fit(GeneralFit& gfit) 45 55 {if(!Ok) UpdateHisto(); return Histo::Fit(gfit,0);} 56 //! Retourne l'Histogramme des residus par ``gfit''. 46 57 inline Histo FitResidus(GeneralFit& gfit) 47 58 {if(!Ok) UpdateHisto(); return Histo::FitResidus(gfit);} 59 //! Retourne l'Histogramme de la fonction fittee par ``gfit''. 48 60 inline Histo FitFunction(GeneralFit& gfit) 49 61 {if(!Ok) UpdateHisto(); return Histo::FitFunction(gfit);} 50 62 51 63 // Print 64 //! Print, voir detail dans Histo::Print 52 65 inline void Print(int dyn=100,float hmin=1.,float hmax=-1.,int pflag=0,int il=1,int ih=-1) 53 66 {if(!Ok) UpdateHisto(); Histo::Print(dyn,hmin,hmax,pflag,il,ih);} … … 56 69 void Delete(); 57 70 58 double* SumY; 59 double* SumY2; 60 double* SumW; 61 bool Ok; 62 float YMin; 63 float YMax; 64 uint_2 Opt; 71 double* SumY; //!< somme 72 double* SumY2; //!< somme des carres 73 double* SumW; //!< somme des poids 74 bool Ok; //!< true isiupdate fait 75 float YMin; //!< limite minimum Y pour somme 76 float YMax; //!< limite maximum Y pour somme 77 uint_2 Opt; //!< options pour les erreurs 65 78 }; 66 79 -
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 -
trunk/SophyaLib/HiStats/histos.h
r763 r914 1 1 // This may look like C code, but it is really -*- C++ -*- 2 2 // 3 // $Id: histos.h,v 1. 1.1.1 2000-03-02 16:51:32ansari Exp $3 // $Id: histos.h,v 1.2 2000-04-13 16:04:11 ansari Exp $ 4 4 // 5 5 … … 19 19 class GeneralFit; 20 20 21 22 /*! 23 Classe d'histogrammes 1D 24 */ 21 25 class Histo : public AnyDataObj { 22 26 friend class ObjFileIO<Histo>; … … 77 81 78 82 // INLINES 83 //! Retourne l'abscisse minimum 79 84 inline float XMin() const {return min;} 85 //! Retourne l'abscisse maximum 80 86 inline float XMax() const {return max;} 87 //! Retourne le nombre de bins 81 88 inline int_4 NBins() const {return bins;} 89 //! Retourne la largeur du bin 82 90 inline float BinWidth() const {return binWidth;} 91 //! Retourne le pointeur sur le tableaux des contenus 83 92 inline float* Bins() const {return data;} 93 //! Retourne le contenu du bin i 84 94 inline float operator()(int i) const {return data[i];} 95 //! Remplit le contenu du bin i 85 96 inline float& operator()(int i) {return data[i];} 97 //! retourne "true" si il y a des erreurs stoquees 86 98 inline bool HasErrors() { if(err2) return true; else return false;} 99 //! Retourne l'erreur du bin i 87 100 inline float Error(int i) const 88 101 {if(err2) {if(err2[i]>0.) return sqrt(err2[i]); else return 0.;} 89 102 else return 0.;} 103 //! Retourne l'erreur au carre du bin i 90 104 inline double Error2(int i) const 91 105 {if(err2) return err2[i]; else return 0.;} 106 //! Remplit l'erreur au carre du bin i 92 107 inline double& Error2(int i) {return err2[i];} 108 //! Retourne la somme ponderee 93 109 inline float NData() const {return (float) nHist;} 110 //! Retourne le nombre d'entrees 94 111 inline float NEntries() const {return nEntries;} 112 //! Retourne le nombre d'overflow 95 113 inline float NOver() const {return over;} 114 //! Retourne le nombre d'underflow 96 115 inline float NUnder() const {return under;} 97 116 117 //! Retourne l'abscisse du bord inferieur du bin i 98 118 inline float BinLowEdge(int i) const {return min + i*binWidth;} 119 //! Retourne l'abscisse du centre du bin i 99 120 inline float BinCenter(int i) const {return min + (i+0.5)*binWidth;} 121 //! Retourne l'abscisse du bord superieur du bin i 100 122 inline float BinHighEdge(int i) const {return min + (i+1)*binWidth;} 123 //! Retourne le numero du bin contenant l'abscisse x 101 124 inline int_4 FindBin(float x) const 102 125 {return (int_4) floorf((x - min) / binWidth);} … … 146 169 void Delete(); 147 170 148 float* data; 149 double* err2; 150 float under; 151 float over; 152 double nHist; 153 int_4 nEntries; 154 int_4 bins; 155 float min; 156 float max; 157 float binWidth; 171 float* data; //!< donnees 172 double* err2; //!< erreurs carrees 173 float under; //!< underflow 174 float over; //!< overflow 175 double nHist; //!< somme ponderee des entrees 176 int_4 nEntries; //!< nombre d'entrees 177 int_4 bins; //!< nombre de bins 178 float min; //!< abscisse minimum 179 float max; //!< abscisse maximum 180 float binWidth; //!< largeur du bin 158 181 }; 159 182 -
trunk/SophyaLib/HiStats/histos2.cc
r763 r914 16 16 #include "generalfit.h" 17 17 18 //++ 19 // Class Histo2D 20 // Lib Outils++ 21 // include histos2.h 22 // 23 // Classe d'histogrammes 2D 24 //-- 25 26 /////////////////////////////////////////////////////////////////// 27 //++ 28 // Titre Constructeurs 29 //-- 30 31 //++ 18 /////////////////////////////////////////////////////////////////// 19 /*! 20 Createur d'un histogramme 2D ayant nxBin,nyBin bins 21 entre xMin,xMax et yMin,yMax. 22 */ 32 23 Histo2D::Histo2D(float xMin, float xMax, int nxBin 33 24 ,float yMin, float yMax, int nyBin) 34 //35 // Createur d'un histogramme 2D ayant nxBin,nyBin bins36 // entre xMin,xMax et yMin,yMax.37 //--38 25 : data(new float[nxBin*nyBin]), err2(NULL) 39 26 , nHist(0), nEntries(0) … … 50 37 } 51 38 52 //++ 39 /*! 40 Constructeur par copie. 41 */ 53 42 Histo2D::Histo2D(const Histo2D& h) 54 //55 // Constructeur par copie.56 //--57 43 { 58 44 int i,j; … … 118 104 } 119 105 120 //++ 106 /*! 107 Constructeur par defaut. 108 */ 121 109 Histo2D::Histo2D() 122 //123 // Constructeur par defaut.124 //--125 110 : data(NULL), err2(NULL) 126 111 , nHist(0), nEntries(0) … … 136 121 137 122 /////////////////////////////////////////////////////////////////// 138 //++ 123 /*! 124 Desallocation de la place de l'histogramme (fct privee). 125 */ 139 126 void Histo2D::Delete() 140 //141 // Desallocation de la place de l'histogramme (fct privee).142 //--143 127 { 144 128 if( data != NULL ) { delete[] data; data = NULL;} … … 163 147 } 164 148 165 //++ 149 /*! 150 Destructeur. 151 */ 166 152 Histo2D::~Histo2D() 167 //168 // Destructeur.169 //--170 153 { 171 154 Delete(); … … 173 156 174 157 /////////////////////////////////////////////////////////////////// 175 //++ 176 // Titre Methodes generales 177 //-- 178 179 //++ 158 /*! 159 Remise a zero du contenu, des erreurs et des valeurs. 160 */ 180 161 void Histo2D::Zero() 181 //182 // Remise a zero du contenu, des erreurs et des valeurs.183 //--184 162 { 185 163 nHist = nEntries = 0; … … 200 178 201 179 /////////////////////////////////////////////////////////////////// 202 //++ 180 /*! 181 Pour avoir le calcul des erreurs. 182 */ 203 183 void Histo2D::Errors() 204 //205 // Pour avoir le calcul des erreurs.206 //--207 184 { 208 185 if( nxy > 0 ) { … … 213 190 214 191 /////////////////////////////////////////////////////////////////// 215 //++ 192 /*! 193 Operateur H2 = H1 194 */ 216 195 Histo2D& Histo2D::operator = (const Histo2D& h) 217 //218 //--219 196 { 220 197 int i,j,nb; … … 286 263 287 264 /////////////////////////////////////////////////////////////////// 288 //++ 265 /*! 266 Operateur H *= b 267 */ 289 268 Histo2D& Histo2D::operator *= (double b) 290 //291 //--292 269 { 293 270 int i,j; … … 310 287 } 311 288 312 //++ 289 /*! 290 Operateur H /= b 291 */ 313 292 Histo2D& Histo2D::operator /= (double b) 314 //315 //--316 293 { 317 294 int i,j; … … 335 312 } 336 313 337 //++ 314 /*! 315 Operateur H += b 316 */ 338 317 Histo2D& Histo2D::operator += (double b) 339 //340 //--341 318 { 342 319 int i,j; … … 362 339 } 363 340 364 //++ 341 /*! 342 Operateur H -= b 343 */ 365 344 Histo2D& Histo2D::operator -= (double b) 366 //367 //--368 345 { 369 346 int i,j; … … 390 367 391 368 /////////////////////////////////////////////////////////////////// 392 //++ 369 /*! 370 Operateur H2 = H1 * b 371 */ 393 372 Histo2D operator * (const Histo2D& a, double b) 394 //395 //--396 373 { 397 374 Histo2D result(a); … … 399 376 } 400 377 401 //++ 378 /*! 379 Operateur H2 = b * H1 380 */ 402 381 Histo2D operator * (double b, const Histo2D& a) 403 //404 //--405 382 { 406 383 Histo2D result(a); … … 408 385 } 409 386 410 //++ 387 /*! 388 Operateur H2 = H1 / b 389 */ 411 390 Histo2D operator / (const Histo2D& a, double b) 412 //413 //--414 391 { 415 392 Histo2D result(a); … … 417 394 } 418 395 419 //++ 396 /*! 397 Operateur H2 = H1 + b 398 */ 420 399 Histo2D operator + (const Histo2D& a, double b) 421 //422 //--423 400 { 424 401 Histo2D result(a); … … 426 403 } 427 404 428 //++ 405 /*! 406 Operateur H2 = b + H1 407 */ 429 408 Histo2D operator + (double b, const Histo2D& a) 430 //431 //--432 409 { 433 410 Histo2D result(a); … … 435 412 } 436 413 437 //++ 414 /*! 415 Operateur H2 = H1 - b 416 */ 438 417 Histo2D operator - (const Histo2D& a, double b) 439 //440 //--441 418 { 442 419 Histo2D result(a); … … 444 421 } 445 422 446 //++ 423 /*! 424 Operateur H2 = b - H1 425 */ 447 426 Histo2D operator - (double b, const Histo2D& a) 448 //449 //--450 427 { 451 428 Histo2D result(a); … … 455 432 456 433 /////////////////////////////////////////////////////////////////// 457 //++ 434 /*! 435 Operateur H += H1 436 */ 458 437 Histo2D& Histo2D::operator += (const Histo2D& a) 459 //460 //--461 438 { 462 439 int i,j; … … 478 455 } 479 456 480 //++ 457 /*! 458 Operateur H -= H1 459 */ 481 460 Histo2D& Histo2D::operator -= (const Histo2D& a) 482 //483 //--484 461 { 485 462 int i,j; … … 501 478 } 502 479 503 //++ 480 /*! 481 Operateur H *= H1 482 */ 504 483 Histo2D& Histo2D::operator *= (const Histo2D& a) 505 //506 //--507 484 { 508 485 int i,j; … … 526 503 } 527 504 528 //++ 505 /*! 506 Operateur H /= H1 507 */ 529 508 Histo2D& Histo2D::operator /= (const Histo2D& a) 530 //531 //--532 509 { 533 510 int i,j; … … 559 536 560 537 /////////////////////////////////////////////////////////////////// 561 //++ 538 /*! 539 Operateur H = H1 + H2 540 */ 541 562 542 Histo2D operator + (const Histo2D& a, const Histo2D& b) 563 //564 //--565 543 { 566 544 if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr); … … 569 547 } 570 548 571 //++ 549 /*! 550 Operateur H = H1 - H2 551 */ 572 552 Histo2D operator - (const Histo2D& a, const Histo2D& b) 573 //574 //--575 553 { 576 554 if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr); … … 579 557 } 580 558 581 //++ 559 /*! 560 Operateur H = H1 * H2 561 */ 582 562 Histo2D operator * (const Histo2D& a, const Histo2D& b) 583 //584 //--585 563 { 586 564 if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr); … … 589 567 } 590 568 591 //++ 569 /*! 570 Operateur H = H1 / H2 571 */ 592 572 Histo2D operator / (const Histo2D& a, const Histo2D& b) 593 //594 //--595 573 { 596 574 if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr); … … 600 578 601 579 /////////////////////////////////////////////////////////////////// 602 //++ 580 /*! 581 Remplissage d'un tableau avec les valeurs des abscisses. 582 */ 603 583 void Histo2D::GetXCoor(Vector &v) 604 //605 // Remplissage d'un tableau avec les valeurs des abscisses.606 //--607 584 { 608 585 float x,y; … … 612 589 } 613 590 614 //++ 591 /*! 592 Remplissage d'un tableau avec les valeurs des ordonnees. 593 */ 615 594 void Histo2D::GetYCoor(Vector &v) 616 //617 // Remplissage d'un tableau avec les valeurs des ordonnees.618 //--619 595 { 620 596 float x,y; … … 624 600 } 625 601 626 //++ 627 //| Remarque sur les indices: 628 //| H(i,j) -> i = coord x (0<i<nx), j = coord y (0<j<ny) 629 //| v(ii,jj) -> ii = ligne (0<i<NRows()), jj = colonne (0<i<NCol()) 630 //| On fait une correspondance directe i<->ii et j<->jj 631 //| ce qui, en representation classique des histos2D et des matrices 632 //| entraine une inversion x<->y cad une symetrie / diagonale principale 633 //| H(0,...) represente ^ mais v(0,...) represente 634 //| |x....... |xxxxxxxx| 635 //| |x....... |........| 636 //| |x....... |........| 637 //| |x....... |........| 638 //| |x....... |........| 639 //| ---------> 640 //| colonne no 1 ligne no 1 641 //-- 642 643 //++ 602 /*! 603 Remplissage d'un tableau avec les valeurs du contenu. 604 */ 644 605 void Histo2D::GetValue(Matrix &v) 645 //646 // Remplissage d'un tableau avec les valeurs du contenu.647 //--648 606 { 649 607 v.Realloc(nx,ny); … … 653 611 } 654 612 655 //++ 613 /*! 614 Remplissage d'un tableau avec les valeurs du carre des erreurs. 615 */ 656 616 void Histo2D::GetError2(Matrix &v) 657 //658 // Remplissage d'un tableau avec les valeurs du carre des erreurs.659 //--660 617 { 661 618 int i,j; … … 667 624 } 668 625 669 //++ 626 /*! 627 Remplissage d'un tableau avec les valeurs des erreurs. 628 */ 670 629 void Histo2D::GetError(Matrix &v) 671 //672 // Remplissage d'un tableau avec les valeurs des erreurs.673 //--674 630 { 675 631 int i,j; … … 682 638 683 639 /////////////////////////////////////////////////////////////////// 684 //++ 640 /*! 641 Remplissage du contenu de l'histo avec les valeurs d'un tableau. 642 */ 685 643 void Histo2D::PutValue(Matrix &v, int ierr) 686 //687 // Remplissage du contenu de l'histo avec les valeurs d'un tableau.688 //--689 644 { 690 645 int i,j; … … 697 652 } 698 653 699 //++ 654 /*! 655 Addition du contenu de l'histo avec les valeurs d'un tableau. 656 */ 700 657 void Histo2D::PutValueAdd(Matrix &v, int ierr) 701 //702 // Addition du contenu de l'histo avec les valeurs d'un tableau.703 //--704 658 { 705 659 int i,j; … … 712 666 } 713 667 714 //++ 668 /*! 669 Remplissage des erreurs au carre de l'histo 670 avec les valeurs d'un tableau. 671 */ 715 672 void Histo2D::PutError2(Matrix &v) 716 //717 // Remplissage des erreurs au carre de l'histo718 // avec les valeurs d'un tableau.719 //--720 673 { 721 674 int i,j; … … 726 679 } 727 680 728 //++ 681 /*! 682 Addition des erreurs au carre de l'histo 683 avec les valeurs d'un tableau. 684 */ 729 685 void Histo2D::PutError2Add(Matrix &v) 730 //731 // Addition des erreurs au carre de l'histo732 // avec les valeurs d'un tableau.733 //--734 686 { 735 687 int i,j; … … 741 693 } 742 694 743 //++ 695 /*! 696 Remplissage des erreurs de l'histo avec les valeurs d'un tableau. 697 */ 744 698 void Histo2D::PutError(Matrix &v) 745 //746 // Remplissage des erreurs de l'histo avec les valeurs d'un tableau.747 //--748 699 { 749 700 int i,j; … … 757 708 /////////////////////////////////////////////////////////////////// 758 709 /********* Methode *********/ 759 //++ 710 /*! 711 Addition du contenu de l'histo pour x,y poids w. 712 */ 760 713 void Histo2D::Add(float x, float y, float w) 761 //762 // Addition du contenu de l'histo pour x,y poids w.763 //--764 714 { 765 715 list<bande_slice>::iterator it; … … 801 751 802 752 /////////////////////////////////////////////////////////////////// 803 //++ 753 /*! 754 Recherche du bin du maximum dans le pave [il,ih][jl,jh]. 755 */ 804 756 void Histo2D::IJMax(int& imax,int& jmax,int il,int ih,int jl,int jh) 805 //806 // Recherche du bin du maximum dans le pave [il,ih][jl,jh].807 //--808 757 { 809 758 if( il > ih ) { il = 0; ih = nx-1; } … … 823 772 } 824 773 825 //++ 774 /*! 775 Recherche du bin du minimum dans le pave [il,ih][jl,jh]. 776 */ 826 777 void Histo2D::IJMin(int& imax,int& jmax,int il,int ih,int jl,int jh) 827 //828 // Recherche du bin du minimum dans le pave [il,ih][jl,jh].829 //--830 778 { 831 779 if( il > ih ) { il = 0; ih = nx-1; } … … 846 794 847 795 848 //++ 796 /*! 797 Recherche du maximum dans le pave [il,ih][jl,jh]. 798 */ 849 799 float Histo2D::VMax(int il,int ih,int jl,int jh) const 850 //851 // Recherche du maximum dans le pave [il,ih][jl,jh].852 //--853 800 { 854 801 if( il > ih ) { il = 0; ih = nx-1; } … … 867 814 } 868 815 869 //++ 816 /*! 817 Recherche du minimum dans le pave [il,ih][jl,jh]. 818 */ 870 819 float Histo2D::VMin(int il,int ih,int jl,int jh) const 871 //872 // Recherche du minimum dans le pave [il,ih][jl,jh].873 //--874 820 { 875 821 if( il > ih ) { il = 0; ih = nx-1; } … … 889 835 890 836 /////////////////////////////////////////////////////////////////// 891 //++ 837 /*! 838 Renvoie les under.overflow dans les 8 quadrants. 839 \verbatim 840 over[3][3]: 20 | 21 | 22 841 | | 842 -------------- 843 | | 844 10 | 11 | 12 11 = all overflow+underflow 845 | | 846 -------------- 847 | | 848 00 | 01 | 02 849 \endverbatim 850 */ 892 851 float Histo2D::NOver(int i,int j) const 893 //894 // Renvoie les under.overflow dans les 8 quadrants.895 //| over[3][3]: 20 | 21 | 22896 //| | |897 //| --------------898 //| | |899 //| 10 | 11 | 12 11 = all overflow+underflow900 //| | |901 //| --------------902 //| | |903 //| 00 | 01 | 02904 //--905 852 { 906 853 if( i < 0 || i>=3 || j < 0 || j>=3 ) return over[1][1]; … … 910 857 911 858 /////////////////////////////////////////////////////////////////// 912 //++ 859 /*! 860 Retourne le nombre de bins non-nuls. 861 */ 913 862 int Histo2D::BinNonNul() const 914 //915 // Retourne le nombre de bins non-nuls.916 //--917 863 { 918 864 int non=0; … … 921 867 } 922 868 923 //++ 869 /*! 870 Retourne le nombre de bins avec erreurs non-nulles. 871 */ 924 872 int Histo2D::ErrNonNul() const 925 //926 // Retourne le nombre de bins avec erreurs non-nulles.927 //--928 873 { 929 874 if(err2==NULL) return -1; … … 934 879 935 880 /////////////////////////////////////////////////////////////////// 936 //++ 881 /*! 882 Idem EstimeMax(int...) mais retourne x,y. 883 */ 937 884 int Histo2D::EstimeMax(float& xm,float& ym,int SzPav 938 885 ,int il,int ih,int jl,int jh) 939 //940 // Idem EstimeMax(int...) mais retourne x,y.941 //--942 886 { 943 887 int im,jm; … … 946 890 } 947 891 948 //++ 892 /*! 893 Determine les abscisses et ordonnees du maximum donne par im,jm 894 en moyennant dans un pave SzPav x SzPav autour du maximum. 895 \verbatim 896 Return: 897 0 = si fit maximum reussi avec SzPav pixels 898 1 = si fit maximum reussi avec moins que SzPav pixels 899 dans au moins 1 direction 900 2 = si fit maximum echoue et renvoit BinCenter() 901 -1 = si echec: SzPav <= 0 ou im,jm hors limites 902 \endverbatim 903 */ 949 904 int Histo2D::EstimeMax(int im,int jm,float& xm,float& ym,int SzPav) 950 //951 // Determine les abscisses et ordonnees du maximum donne par im,jm952 // en moyennant dans un pave SzPav x SzPav autour du maximum.953 //| Return:954 //| 0 = si fit maximum reussi avec SzPav pixels955 //| 1 = si fit maximum reussi avec moins que SzPav pixels956 //| dans au moins 1 direction957 //| 2 = si fit maximum echoue et renvoit BinCenter()958 //| -1 = si echec: SzPav <= 0 ou im,jm hors limites959 //--960 905 { 961 906 xm = ym = 0; … … 992 937 } 993 938 994 //++ 939 /*! 940 Pour trouver le maximum de l'histogramme en tenant compte 941 des fluctuations. 942 \verbatim 943 Methode: 944 1-/ On recherche le bin maximum MAX de l'histogramme 945 2-/ On considere que tous les pixels compris entre [MAX-Dz,MAX] 946 peuvent etre des pixels maxima. 947 3-/ On identifie le bin maximum en choissisant le pixel du 2-/ 948 tel que la somme des pixels dans un pave SzPav x SzPav soit maximale. 949 INPUT: 950 SzPav = taille du pave pour departager 951 Dz = tolerance pour identifier tous les pixels "maximum" 952 OUTPUT: 953 im,jm = pixel maximum trouve 954 RETURN: 955 <0 = Echec 956 >0 = nombre de pixels possibles pour le maximum 957 \endverbatim 958 */ 995 959 int Histo2D::FindMax(int& im,int& jm,int SzPav,float Dz 996 960 ,int il,int ih,int jl,int jh) 997 //998 // Pour trouver le maximum de l'histogramme en tenant compte999 // des fluctuations.1000 //| Methode:1001 //| 1-/ On recherche le bin maximum MAX de l'histogramme1002 //| 2-/ On considere que tous les pixels compris entre [MAX-Dz,MAX]1003 //| peuvent etre des pixels maxima.1004 //| 3-/ On identifie le bin maximum en choissisant le pixel du 2-/1005 //| tel que la somme des pixels dans un pave SzPav x SzPav soit maximale.1006 //| INPUT:1007 //| SzPav = taille du pave pour departager1008 //| Dz = tolerance pour identifier tous les pixels "maximum"1009 //| OUTPUT:1010 //| im,jm = pixel maximum trouve1011 //| RETURN:1012 //| <0 = Echec1013 //| >0 = nombre de pixels possibles pour le maximum1014 //--1015 961 { 1016 962 if( il > ih ) { il = 0; ih = nx-1; } … … 1046 992 1047 993 ////////////////////////////////////////////////////////// 1048 //++ 994 /*! 995 Fit de l'histogramme par ``gfit''. 996 \verbatim 997 typ_err = 0 : 998 - erreur attachee au bin si elle existe 999 - sinon 1 1000 typ_err = 1 : 1001 - erreur attachee au bin si elle existe 1002 - sinon max( sqrt(abs(bin) ,1 ) 1003 typ_err = 2 : 1004 - erreur forcee a 1 1005 typ_err = 3 : 1006 - erreur forcee a max( sqrt(abs(bin) ,1 ) 1007 typ_err = 4 : 1008 - erreur forcee a 1, nulle si bin a zero. 1009 typ_err = 5 : 1010 - erreur forcee a max( sqrt(abs(bin) ,1 ), 1011 nulle si bin a zero. 1012 \endverbatim 1013 */ 1049 1014 int Histo2D::Fit(GeneralFit& gfit,unsigned short typ_err) 1050 //1051 // Fit de l'histogramme par ``gfit''.1052 //| typ_err = 0 :1053 //| - erreur attachee au bin si elle existe1054 //| - sinon 11055 //| typ_err = 1 :1056 //| - erreur attachee au bin si elle existe1057 //| - sinon max( sqrt(abs(bin) ,1 )1058 //| typ_err = 2 :1059 //| - erreur forcee a 11060 //| typ_err = 3 :1061 //| - erreur forcee a max( sqrt(abs(bin) ,1 )1062 //| typ_err = 4 :1063 //| - erreur forcee a 1, nulle si bin a zero.1064 //| typ_err = 5 :1065 //| - erreur forcee a max( sqrt(abs(bin) ,1 ),1066 //| nulle si bin a zero.1067 //--1068 1015 { 1069 1016 if(NBinX()*NBinY()<=0) return -1000; … … 1092 1039 } 1093 1040 1094 //++ 1041 /*! 1042 Retourne une classe contenant les residus du fit ``gfit''. 1043 */ 1095 1044 Histo2D Histo2D::FitResidus(GeneralFit& gfit) 1096 //1097 // Retourne une classe contenant les residus du fit ``gfit''.1098 //--1099 1045 { 1100 1046 if(NBinX()<=0 || NBinY()<=0) … … 1114 1060 } 1115 1061 1116 //++ 1062 /*! 1063 Retourne une classe contenant la fonction du fit ``gfit''. 1064 */ 1117 1065 Histo2D Histo2D::FitFunction(GeneralFit& gfit) 1118 //1119 // Retourne une classe contenant la fonction du fit ``gfit''.1120 //--1121 1066 { 1122 1067 if(NBinX()<=0 || NBinY()<=0) … … 1137 1082 1138 1083 /////////////////////////////////////////////////////////////////// 1139 //++ 1084 /*! 1085 Impression des informations sur l'histogramme. 1086 */ 1140 1087 void Histo2D::PrintStatus() 1141 //1142 // Impression des informations sur l'histogramme.1143 //--1144 1088 { 1145 1089 printf("~Histo::Print nHist=%g nEntries=%d\n",nHist,nEntries); … … 1153 1097 1154 1098 /////////////////////////////////////////////////////////////////// 1155 //++ 1099 /*! 1100 Impression de l'histogramme sur stdout entre [il,ih] et [jl,jh]. 1101 \verbatim 1102 numero d'index: 00000000001111111111222222222233333 1103 01234567890123456789012345678901234 1104 valeur entiere: 00000000001111111111222222222233333 1105 12345678901234567890123456789012345 1106 \endverbatim 1107 */ 1156 1108 void Histo2D::Print(float min,float max 1157 1109 ,int il,int ih,int jl,int jh) 1158 //1159 // Impression de l'histogramme sur stdout entre [il,ih] et [jl,jh].1160 //--1161 1110 { 1162 1111 int ns = 35; 1163 // numero d'index: 000000000011111111112222222222333331164 // 012345678901234567890123456789012341165 // valeur entiere: 000000000011111111112222222222333331166 // 123456789012345678901234567890123451167 1112 const char *s = "+23456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 1168 1113 … … 1245 1190 } 1246 1191 1247 // Rappel des inline functions pour commentaires 1248 //++ 1249 // inline float XMin() 1250 // Retourne l'abscisse minimum. 1251 //-- 1252 //++ 1253 // inline float XMax() 1254 // Retourne l'abscisse maximum. 1255 //-- 1256 //++ 1257 // inline float YMin() 1258 // Retourne l'ordonnee minimum. 1259 //-- 1260 //++ 1261 // inline float YMax() 1262 // Retourne l'ordonnee maximum. 1263 //-- 1264 //++ 1265 // inline int NBinX() 1266 // Retourne le nombre de bins selon X. 1267 //-- 1268 //++ 1269 // inline int NBinY() 1270 // Retourne le nombre de bins selon Y. 1271 //-- 1272 //++ 1273 // inline float WBinX() 1274 // Retourne la largeur du bin selon X. 1275 //-- 1276 //++ 1277 // inline float WBinY() 1278 // Retourne la largeur du bin selon Y. 1279 //-- 1280 //++ 1281 // inline float* Bins() const 1282 // Retourne le pointeur sur le tableaux des contenus. 1283 //-- 1284 //++ 1285 // inline float operator()(int i,int j) const 1286 // Retourne le contenu du bin i,j. 1287 //-- 1288 //++ 1289 // inline float& operator()(int i,int j) 1290 // Remplit le contenu du bin i,j. 1291 //-- 1292 //++ 1293 // inline float Error(int i,int j) const 1294 // Retourne l'erreur du bin i,j. 1295 //-- 1296 //++ 1297 // inline double Error2(int i,int j) const 1298 // Retourne l'erreur au carre du bin i,j. 1299 //-- 1300 //++ 1301 // inline double& Error2(int i,int j) 1302 // Remplit l'erreur au carre du bin i,j. 1303 //-- 1304 //++ 1305 // inline float NData() const 1306 // Retourne la somme ponderee. 1307 //-- 1308 //++ 1309 // inline int NEntries() const 1310 // Retourne le nombre d'entrees. 1311 //-- 1312 //++ 1313 // inline void BinLowEdge(int i,int j,float& x,float& y) 1314 // Retourne l'abscisse et l'ordonnee du coin inferieur du bin i,j. 1315 //-- 1316 //++ 1317 // inline void BinCenter(int i,int j,float& x,float& y) 1318 // Retourne l'abscisse et l'ordonnee du centre du bin i,j. 1319 //-- 1320 //++ 1321 // inline void BinHighEdge(int i,int j,float& x,float& y) 1322 // Retourne l'abscisse et l'ordonnee du coin superieur du bin i,j. 1323 //-- 1324 //++ 1325 // inline void FindBin(float x,float y,int& i,int& j) 1326 // Retourne les numeros du bin contenant l'abscisse et l'ordonnee x,y. 1327 //-- 1328 1329 /////////////////////////////////////////////////////////////////// 1330 //++ 1192 /////////////////////////////////////////////////////////////////// 1331 1193 // Titre Methodes pour gerer les projections 1332 //-- 1333 1334 //++ 1194 1195 /*! 1196 Pour creer la projection X. 1197 */ 1335 1198 void Histo2D::SetProjX() 1336 //1337 // Pour creer la projection X.1338 //--1339 1199 { 1340 1200 if( hprojx != NULL ) DelProjX(); … … 1343 1203 } 1344 1204 1345 //++ 1205 /*! 1206 Pour creer la projection Y. 1207 */ 1346 1208 void Histo2D::SetProjY() 1347 //1348 // Pour creer la projection Y.1349 //--1350 1209 { 1351 1210 if( hprojy != NULL ) DelProjY(); … … 1354 1213 } 1355 1214 1356 //++ 1215 /*! 1216 Pour creer les projections X et Y. 1217 */ 1357 1218 void Histo2D::SetProj() 1358 //1359 // Pour creer les projections X et Y.1360 //--1361 1219 { 1362 1220 SetProjX(); … … 1364 1222 } 1365 1223 1366 //++ 1224 /*! 1225 Informations sur les projections. 1226 */ 1367 1227 void Histo2D::ShowProj() 1368 //1369 // Informations sur les projections.1370 //--1371 1228 { 1372 1229 if( hprojx != NULL ) cout << ">>>> Projection X set : "<< hprojx <<endl; … … 1376 1233 } 1377 1234 1378 //++ 1235 /*! 1236 Destruction de l'histogramme de la projection selon X. 1237 */ 1379 1238 void Histo2D::DelProjX() 1380 //1381 // Destruction de l'histogramme de la projection selon X.1382 //--1383 1239 { 1384 1240 if( hprojx == NULL ) return; … … 1387 1243 } 1388 1244 1389 //++ 1245 /*! 1246 Destruction de l'histogramme de la projection selon X. 1247 */ 1390 1248 void Histo2D::DelProjY() 1391 //1392 // Destruction de l'histogramme de la projection selon X.1393 //--1394 1249 { 1395 1250 if( hprojy == NULL ) return; … … 1398 1253 } 1399 1254 1400 //++ 1255 /*! 1256 Destruction des histogrammes des projections selon X et Y. 1257 */ 1401 1258 void Histo2D::DelProj() 1402 //1403 // Destruction des histogrammes des projections selon X et Y.1404 //--1405 1259 { 1406 1260 DelProjX(); … … 1408 1262 } 1409 1263 1410 //++ 1264 /*! 1265 Remise a zero de la projection selon X. 1266 */ 1411 1267 void Histo2D::ZeroProjX() 1412 //1413 // Remise a zero de la projection selon X.1414 //--1415 1268 { 1416 1269 if( hprojx == NULL ) return; … … 1418 1271 } 1419 1272 1420 //++ 1273 /*! 1274 Remise a zero de la projection selon Y. 1275 */ 1421 1276 void Histo2D::ZeroProjY() 1422 //1423 // Remise a zero de la projection selon Y.1424 //--1425 1277 { 1426 1278 if( hprojy == NULL ) return; … … 1428 1280 } 1429 1281 1430 //++ 1282 /*! 1283 Remise a zero des projections selon X et Y. 1284 */ 1431 1285 void Histo2D::ZeroProj() 1432 //1433 // Remise a zero des projections selon X et Y.1434 //--1435 1286 { 1436 1287 ZeroProjX(); … … 1438 1289 } 1439 1290 1440 // Rappel des inline functions pour commentaires 1441 //++ 1442 // inline Histo* HProjX() 1443 // Retourne le pointeur sur l'histo 1D de la projection selon X. 1444 //-- 1445 //++ 1446 // inline Histo* HProjY() 1447 // Retourne le pointeur sur l'histo 1D de la projection selon Y. 1448 //-- 1449 1450 /////////////////////////////////////////////////////////////////// 1451 //++ 1291 /////////////////////////////////////////////////////////////////// 1452 1292 // Titre Methodes pour gerer les bandes 1453 //-- 1454 1455 //++ 1293 1294 /*! 1295 Pour creer une bande en X entre ybmin et ybmax. 1296 */ 1456 1297 int Histo2D::SetBandX(float ybmin,float ybmax) 1457 //1458 // Pour creer une bande en X entre ybmin et ybmax.1459 //--1460 1298 { 1461 1299 b_s.num = lbandx.size(); … … 1468 1306 } 1469 1307 1470 //++ 1308 /*! 1309 Pour creer une bande en Y entre xbmin et xbmax. 1310 */ 1471 1311 int Histo2D::SetBandY(float xbmin,float xbmax) 1472 //1473 // Pour creer une bande en Y entre xbmin et xbmax.1474 //--1475 1312 { 1476 1313 b_s.num = lbandy.size(); … … 1483 1320 } 1484 1321 1485 //++ 1322 /*! 1323 Destruction des histogrammes des bandes selon X. 1324 */ 1486 1325 void Histo2D::DelBandX() 1487 //1488 // Destruction des histogrammes des bandes selon X.1489 //--1490 1326 { 1491 1327 if( lbandx.size() <= 0 ) return; … … 1495 1331 } 1496 1332 1497 //++ 1333 /*! 1334 Destruction des histogrammes des bandes selon Y. 1335 */ 1498 1336 void Histo2D::DelBandY() 1499 //1500 // Destruction des histogrammes des bandes selon Y.1501 //--1502 1337 { 1503 1338 if( lbandy.size() <= 0 ) return; … … 1507 1342 } 1508 1343 1509 //++ 1344 /*! 1345 Remise a zero des bandes selon X. 1346 */ 1510 1347 void Histo2D::ZeroBandX() 1511 //1512 // Remise a zero des bandes selon X.1513 //--1514 1348 { 1515 1349 if( lbandx.size() <= 0 ) return; … … 1519 1353 } 1520 1354 1521 //++ 1355 /*! 1356 Remise a zero des bandes selon Y. 1357 */ 1522 1358 void Histo2D::ZeroBandY() 1523 //1524 // Remise a zero des bandes selon Y.1525 //--1526 1359 { 1527 1360 if( lbandy.size() <= 0 ) return; … … 1531 1364 } 1532 1365 1533 //++ 1366 /*! 1367 Retourne un pointeur sur la bande numero `n' selon X. 1368 */ 1534 1369 Histo* Histo2D::HBandX(int n) const 1535 //1536 // Retourne un pointeur sur la bande numero `n' selon X.1537 //--1538 1370 { 1539 1371 if( lbandx.size() <= 0 || n < 0 || n >= (int) lbandx.size() ) return NULL; … … 1543 1375 } 1544 1376 1545 //++ 1377 /*! 1378 Retourne un pointeur sur la bande numero `n' selon Y. 1379 */ 1546 1380 Histo* Histo2D::HBandY(int n) const 1547 //1548 // Retourne un pointeur sur la bande numero `n' selon Y.1549 //--1550 1381 { 1551 1382 if( lbandy.size() <= 0 || n < 0 || n >= (int) lbandy.size() ) return NULL; … … 1555 1386 } 1556 1387 1557 //++ 1388 /*! 1389 Retourne les limites de la bande numero `n' selon X. 1390 */ 1558 1391 void Histo2D::GetBandX(int n,float& ybmin,float& ybmax) const 1559 //1560 // Retourne les limites de la bande numero `n' selon X.1561 //--1562 1392 { 1563 1393 ybmin = 0.; ybmax = 0.; … … 1568 1398 } 1569 1399 1570 //++ 1400 /*! 1401 Retourne les limites de la bande numero `n' selon Y. 1402 */ 1571 1403 void Histo2D::GetBandY(int n,float& xbmin,float& xbmax) const 1572 //1573 // Retourne les limites de la bande numero `n' selon Y.1574 //--1575 1404 { 1576 1405 xbmin = 0.; xbmax = 0.; … … 1581 1410 } 1582 1411 1583 //++ 1412 /*! 1413 Informations sur les bandes. 1414 */ 1584 1415 void Histo2D::ShowBand(int lp) 1585 //1586 // Informations sur les bandes.1587 //--1588 1416 { 1589 1417 cout << ">>>> Nombre de bande X : " << lbandx.size() << endl; … … 1608 1436 } 1609 1437 1610 // Rappel des inline functions pour commentaires 1611 //++ 1612 // inline int NBandX() 1613 // Retourne le nombre de bandes selon X 1614 //-- 1615 //++ 1616 // inline int NBandY() 1617 // Retourne le nombre de bandes selon Y 1618 //-- 1619 1620 /////////////////////////////////////////////////////////////////// 1621 //++ 1622 // Titre Methodes pour gerer les bandes equidistantes 1623 //-- 1624 1625 //++ 1438 /////////////////////////////////////////////////////////////////// 1439 // Titre Methodes pour gerer les bandes equidistantes ou slices 1440 1441 /*! 1442 Pour creer `nsli' bandes equidistantes selon X. 1443 */ 1626 1444 int Histo2D::SetSliX(int nsli) 1627 //1628 // Pour creer `nsli' bandes equidistantes selon X.1629 //--1630 1445 { 1631 1446 if( nsli <= 0 ) return -1; … … 1645 1460 } 1646 1461 1647 //++ 1462 /*! 1463 Pour creer `nsli' bandes equidistantes selon Y. 1464 */ 1648 1465 int Histo2D::SetSliY(int nsli) 1649 //1650 // Pour creer `nsli' bandes equidistantes selon Y.1651 //--1652 1466 { 1653 1467 if( nsli <= 0 ) return -1; … … 1667 1481 } 1668 1482 1669 //++ 1483 /*! 1484 Destruction des bandes equidistantes selon X. 1485 */ 1670 1486 void Histo2D::DelSliX() 1671 //1672 // Destruction des bandes equidistantes selon X.1673 //--1674 1487 { 1675 1488 if( lslix.size() <= 0 ) return; … … 1679 1492 } 1680 1493 1681 //++ 1494 /*! 1495 Destruction des bandes equidistantes selon Y. 1496 */ 1682 1497 void Histo2D::DelSliY() 1683 //1684 // Destruction des bandes equidistantes selon Y.1685 //--1686 1498 { 1687 1499 if( lsliy.size() <= 0 ) return; … … 1691 1503 } 1692 1504 1693 //++ 1505 /*! 1506 Remise a zero des bandes equidistantes selon X. 1507 */ 1694 1508 void Histo2D::ZeroSliX() 1695 //1696 // Remise a zero des bandes equidistantes selon X.1697 //--1698 1509 { 1699 1510 if( lslix.size() <= 0 ) return; … … 1703 1514 } 1704 1515 1705 //++ 1516 /*! 1517 Remise a zero des bandes equidistantes selon Y. 1518 */ 1706 1519 void Histo2D::ZeroSliY() 1707 //1708 // Remise a zero des bandes equidistantes selon Y.1709 //--1710 1520 { 1711 1521 if( lsliy.size() <= 0 ) return; … … 1715 1525 } 1716 1526 1717 //++ 1527 /*! 1528 Retourne un pointeur sur la bande equidistante numero `n' 1529 selon X. 1530 */ 1718 1531 Histo* Histo2D::HSliX(int n) const 1719 //1720 // Retourne un pointeur sur la bande equidistante numero `n'1721 // selon X.1722 //--1723 1532 { 1724 1533 if( lslix.size() <= 0 || n < 0 || n >= (int) lslix.size() ) return NULL; … … 1728 1537 } 1729 1538 1730 //++ 1539 /*! 1540 Retourne un pointeur sur la bande equidistante numero `n' 1541 selon Y. 1542 */ 1731 1543 Histo* Histo2D::HSliY(int n) const 1732 //1733 // Retourne un pointeur sur la bande equidistante numero `n'1734 // selon Y.1735 //--1736 1544 { 1737 1545 if( lsliy.size() <= 0 || n < 0 || n >= (int) lsliy.size() ) return NULL; … … 1741 1549 } 1742 1550 1743 //++ 1551 /*! 1552 Informations sur les bandes equidistantes. 1553 */ 1744 1554 void Histo2D::ShowSli(int lp) 1745 //1746 // Informations sur les bandes equidistantes.1747 //--1748 1555 { 1749 1556 list<bande_slice>::iterator i; … … 1764 1571 } 1765 1572 } 1766 1767 // Rappel des inline functions pour commentaires1768 //++1769 // inline int NSliX()1770 // Retourne le nombre de slices selon X1771 //--1772 //++1773 // inline int NSliY()1774 // Retourne le nombre de slices selon Y1775 //--1776 1777 1573 1778 1574 /////////////////////////////////////////////////////////// -
trunk/SophyaLib/HiStats/histos2.h
r763 r914 22 22 class GeneralFit; 23 23 24 25 /*! 26 Classe d'histogrammes 2D 27 \verbatim 28 Remarque sur les indices: 29 H(i,j) -> i = coord x (0<i<nx), j = coord y (0<j<ny) 30 v(ii,jj) -> ii = ligne (0<i<NRows()), jj = colonne (0<i<NCol()) 31 On fait une correspondance directe i<->ii et j<->jj 32 ce qui, en representation classique des histos2D et des matrices 33 entraine une inversion x<->y cad une symetrie / diagonale principale 34 H(0,...) represente ^ mais v(0,...) represente 35 |x....... |xxxxxxxx| 36 |x....... |........| 37 |x....... |........| 38 |x....... |........| 39 |x....... |........| 40 ---------> 41 colonne no 1 ligne no 1 42 \endverbatim 43 */ 24 44 class Histo2D : public AnyDataObj { 25 45 friend class ObjFileIO<Histo2D>; … … 75 95 76 96 // INLINES 97 //! Retourne l'abscisse minimum. 77 98 inline float XMin() const {return xmin;} 99 //! Retourne l'abscisse maximum. 78 100 inline float XMax() const {return xmax;} 101 //! Retourne l'ordonnee minimum. 79 102 inline float YMin() const {return ymin;} 103 //! Retourne l'ordonnee maximum. 80 104 inline float YMax() const {return ymax;} 105 //! Retourne le nombre de bins selon X. 81 106 inline int_4 NBinX() const {return nx;} 107 //! Retourne le nombre de bins selon Y. 82 108 inline int_4 NBinY() const {return ny;} 109 //! Retourne la largeur du bin selon X. 83 110 inline float WBinX() const {return wbinx;} 111 //! Retourne la largeur du bin selon Y. 84 112 inline float WBinY() const {return wbiny;} 113 //! Retourne le pointeur sur le tableaux des contenus. 85 114 inline float* Bins() const {return data;} 115 //! Retourne le contenu du bin i,j. 86 116 inline float operator()(int i,int j) const {return data[j*nx+i];} 117 //! Remplit le contenu du bin i,j. 87 118 inline float& operator()(int i,int j) {return data[j*nx+i];} 119 //! retourne "true" si il y a des erreurs stoquees 88 120 inline bool HasErrors() { if(err2) return true; else return false;} 121 //! Retourne l'erreur du bin i,j. 89 122 inline float Error(int i,int j) const 90 123 {if(err2) 91 124 {if(err2[j*nx+i]>0.) return sqrt(err2[j*nx+i]); else return 0.;} 92 125 else return 0.;} 126 //! Remplit l'erreur au carre du bin i,j. 93 127 inline double Error2(int i,int j) const 94 128 {if(err2) return err2[j*nx+i]; else return 0.;} 129 //! Remplit l'erreur au carre du bin i,j. 95 130 inline double& Error2(int i,int j) {return err2[j*nx+i];} 131 //! Retourne la somme ponderee. 96 132 inline float NData() const {return (float) nHist;} 133 //! Retourne le nombre d'entrees. 97 134 inline int_4 NEntries() const {return nEntries;} 135 //! Retourne l'abscisse et l'ordonnee du coin inferieur du bin i,j. 98 136 inline void BinLowEdge(int i,int j,float& x,float& y) 99 137 {x = xmin + i*wbinx; y = ymin + j*wbiny;} 138 //! Retourne l'abscisse et l'ordonnee du centre du bin i,j. 100 139 inline void BinCenter(int i,int j,float& x,float& y) 101 140 {x = xmin + (i+0.5)*wbinx; y = ymin + (j+0.5)*wbiny;} 141 //! Retourne l'abscisse et l'ordonnee du coin superieur du bin i,j. 102 142 inline void BinHighEdge(int i,int j,float& x,float& y) 103 143 {x = xmin + (i+1)*wbinx; y = ymin + (j+1)*wbiny;} 144 //! Retourne les numeros du bin contenant l'abscisse et l'ordonnee x,y. 104 145 inline void FindBin(float x,float y,int& i,int& j) 105 146 { i = (int) floorf((x - xmin)/wbinx); j = (int) floorf((y - ymin)/wbiny);} … … 139 180 void ZeroProjY(); 140 181 void ZeroProj(); 182 //! Retourne le pointeur sur l'histo 1D de la projection selon X. 141 183 inline Histo* HProjX() const {return hprojx;} 184 //! Retourne le pointeur sur l'histo 1D de la projection selon Y. 142 185 inline Histo* HProjY() const {return hprojy;} 143 186 void ShowProj(); 144 187 145 188 // BANDES 189 //! Retourne le nombre de bandes selon X 146 190 inline int NBandX() const {return lbandx.size();} 191 //! Retourne le nombre de bandes selon Y 147 192 inline int NBandY() const {return lbandy.size();} 148 193 int SetBandX(float ybmin,float ybmax); … … 159 204 160 205 // SLICES 206 //! Retourne le nombre de slices selon X 161 207 inline int NSliX() const {return lslix.size();} 208 //! Retourne le nombre de slices selon Y 162 209 inline int NSliY() const {return lsliy.size();} 163 210 int SetSliX(int nsli); … … 174 221 protected: 175 222 #endif 223 //! structure de definition des bandes 176 224 struct bande_slice { 177 int num; 178 float min, max; 179 Histo* H; 225 int num; //!< nombre de bandes 226 float min; //!< limite minimum pour remplir la bande 227 float max; //!< limite maximum pour remplir la bande 228 Histo* H; //!< pointer sur l Histo 1D de la bande 180 229 STRUCTCOMP(bande_slice) 181 230 }; … … 186 235 void Delete(); 187 236 188 float* data; 189 double* err2; 190 191 float over[3][3]; 192 double nHist; 193 int_4 nEntries; 194 195 int_4 nx,ny,nxy; 196 float xmin; 197 float xmax; 198 float ymin; 199 float ymax; 200 float wbinx; 201 float wbiny; 237 float* data; //!< donnees 238 double* err2; //!< erreurs carrees 239 240 float over[3][3]; //!< overflow table 241 double nHist; //!< somme ponderee des entrees 242 int_4 nEntries; //!< nombre d'entrees 243 244 int_4 nx; //!< nombre de bins en X 245 int_4 ny; //!< nombre de bins en Y 246 int_4 nxy; //!< nombre de bins total 247 float xmin; //!< abscisse minimum 248 float xmax; //!< abscisse maximum 249 float ymin; //!< ordonnee minimum 250 float ymax; //!< ordonnee maximum 251 float wbinx; //!< largeur du bin en X 252 float wbiny; //!< largeur du bin en Y 202 253 203 254 bande_slice b_s; 204 255 205 Histo* hprojx; 206 Histo* hprojy; 207 208 list<bande_slice> lbandx; 209 list<bande_slice> lbandy; 256 Histo* hprojx; //!< pointer sur Histo des proj X 257 Histo* hprojy; //!< pointer sur Histo des proj Y 258 259 list<bande_slice> lbandx; //!< liste des bandes selon X 260 list<bande_slice> lbandy; //!< liste des bandes selon Y 210 261 211 list<bande_slice> lslix; 212 list<bande_slice> lsliy; 262 list<bande_slice> lslix; //!< liste des slices selon X 263 list<bande_slice> lsliy; //!< liste des slices selon Y 213 264 214 265 };
Note:
See TracChangeset
for help on using the changeset viewer.
