inlib
1.2.0
|
00001 // Copyright (C) 2010, Guy Barrand. All rights reserved. 00002 // See the file inlib.license for terms. 00003 00004 #ifndef inlib_histo_base_histo 00005 #define inlib_histo_base_histo 00006 00007 #ifdef INLIB_MEM 00008 #include "../mem" 00009 #endif 00010 00011 #include "histo_data" 00012 00013 #include <cmath> 00014 00015 namespace inlib { 00016 namespace histo { 00017 00018 //TC is for a coordinate. 00019 //TN is for a number of entries. 00020 //TW is for a weight. 00021 //TH is for a height. 00022 00023 template <class TC,class TN,class TW,class TH> 00024 class base_histo { 00025 static const std::string& s_class() { 00026 static const std::string s_v("inlib::histo::base_histo"); 00027 return s_v; 00028 } 00029 public: 00030 typedef typename axis<TC>::bn_t bn_t; 00031 typedef unsigned int dim_t; 00032 protected: 00033 virtual TH get_bin_height(int) const = 0; //histo/profile 00034 protected: 00035 void base_from_data(const histo_data<TC,TN,TW>& a_from) { 00036 m_title = a_from.m_title; 00037 m_dimension = a_from.m_dimension; 00038 m_bin_number = a_from.m_bin_number; 00039 // Arrays : 00040 m_bin_entries = a_from.m_bin_entries; 00041 m_bin_Sw = a_from.m_bin_Sw; 00042 m_bin_Sw2 = a_from.m_bin_Sw2; 00043 m_bin_Sxw = a_from.m_bin_Sxw; 00044 m_bin_Sx2w = a_from.m_bin_Sx2w; 00045 m_axes = a_from.m_axes; 00046 //m_annotations = a_from.m_annotations; 00047 } 00048 histo_data<TC,TN,TW> base_get_data() const { 00049 histo_data<TC,TN,TW> hd; 00050 hd.m_title = m_title; 00051 hd.m_dimension = m_dimension; 00052 hd.m_bin_number = m_bin_number; 00053 // Arrays : 00054 hd.m_bin_entries = m_bin_entries; 00055 hd.m_bin_Sw = m_bin_Sw; 00056 hd.m_bin_Sw2 = m_bin_Sw2; 00057 hd.m_bin_Sxw = m_bin_Sxw; 00058 hd.m_bin_Sx2w = m_bin_Sx2w; 00059 hd.m_axes = m_axes; 00060 //hd.m_annotations = m_annotations; 00061 return hd; 00062 } 00063 protected: 00064 base_histo() 00065 :m_dimension(0) 00066 ,m_bin_number(0) 00067 { 00068 #ifdef INLIB_MEM 00069 mem::increment(s_class().c_str()); 00070 #endif 00071 } 00072 protected: 00073 virtual ~base_histo(){ 00074 #ifdef INLIB_MEM 00075 mem::decrement(s_class().c_str()); 00076 #endif 00077 } 00078 protected: 00079 base_histo(const base_histo& a_from) 00080 :m_title(a_from.m_title) 00081 ,m_dimension(a_from.m_dimension) 00082 ,m_bin_number(a_from.m_bin_number) 00083 // Arrays : 00084 ,m_bin_entries(a_from.m_bin_entries) 00085 ,m_bin_Sw(a_from.m_bin_Sw) 00086 ,m_bin_Sw2(a_from.m_bin_Sw2) 00087 ,m_bin_Sxw(a_from.m_bin_Sxw) 00088 ,m_bin_Sx2w(a_from.m_bin_Sx2w) 00089 ,m_axes(a_from.m_axes) 00090 //,m_annotations(a_from.m_annotations) 00091 { 00092 #ifdef INLIB_MEM 00093 mem::increment(s_class().c_str()); 00094 #endif 00095 } 00096 00097 base_histo& operator=(const base_histo& a_from) { 00098 m_title = a_from.m_title; 00099 m_dimension = a_from.m_dimension; 00100 m_bin_number = a_from.m_bin_number; 00101 // Arrays : 00102 m_bin_entries = a_from.m_bin_entries; 00103 m_bin_Sw = a_from.m_bin_Sw; 00104 m_bin_Sw2 = a_from.m_bin_Sw2; 00105 m_bin_Sxw = a_from.m_bin_Sxw; 00106 m_bin_Sx2w = a_from.m_bin_Sx2w; 00107 m_axes = a_from.m_axes; 00108 //m_annotations = a_from.m_annotations; 00109 return *this; 00110 } 00111 00112 public: 00113 const std::string& title() const {return m_title;} 00114 std::string title() {return m_title;} 00115 bool set_title(const std::string& a_title){m_title = a_title;return true;} 00116 dim_t dimension() const {return m_dimension;} 00117 00118 TN entries() const { return get_entries();} 00119 TN all_entries() const { 00120 TN number = 0; 00121 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00122 number += m_bin_entries[ibin]; 00123 } 00124 return number; 00125 } 00126 TN extra_entries() const { 00127 TN number = 0; 00128 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00129 if(is_out(ibin)) { 00130 number += m_bin_entries[ibin]; 00131 } 00132 } 00133 return number; 00134 } 00135 TW equivalent_bin_entries() const { 00136 TW sw = 0; 00137 TW sw2 = 0; 00138 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00139 if(!is_out(ibin)) { 00140 sw += m_bin_Sw[ibin]; 00141 sw2 += m_bin_Sw2[ibin]; 00142 } 00143 } 00144 if(sw2==0) return 0; 00145 return (sw * sw)/sw2; 00146 } 00147 00148 TH sum_bin_heights() const { 00149 TH sh = 0; 00150 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00151 if(!is_out(ibin)) { 00152 sh += get_bin_height(ibin); 00153 } 00154 } 00155 return sh; 00156 } 00157 00158 TH sum_all_bin_heights() const { 00159 TH sh = 0; 00160 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00161 sh += get_bin_height(ibin); 00162 } 00163 return sh; 00164 } 00165 00166 TH sum_extra_bin_heights() const { 00167 TH sh = 0; 00168 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00169 if(is_out(ibin)) { 00170 sh += get_bin_height(ibin); 00171 } 00172 } 00173 return sh; 00174 } 00175 00176 TH min_bin_height() const { 00177 TH value = 0; 00178 bool first = true; 00179 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00180 if(!is_out(ibin)) { 00181 TH vbin = get_bin_height(ibin); 00182 if(first) { 00183 first = false; 00184 value = vbin; 00185 } else { 00186 if(vbin<=value) value = vbin; 00187 } 00188 } 00189 } 00190 return value; 00191 } 00192 00193 TH max_bin_height() const { 00194 TH value = 0; 00195 bool first = true; 00196 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00197 if(!is_out(ibin)) { 00198 TH vbin = get_bin_height(ibin); 00199 if(first) { 00200 first = false; 00201 value = vbin; 00202 } else { 00203 if(vbin>=value) value = vbin; 00204 } 00205 } 00206 } 00207 return value; 00208 } 00209 00210 protected: 00211 enum {AxisX=0,AxisY=1,AxisZ=2}; 00212 00213 bool configure(dim_t a_dim,const std::vector<bn_t>& aNumbers,const std::vector<TC>& aMins,const std::vector<TC>& aMaxs) { 00214 // Clear : 00215 m_bin_entries.clear(); 00216 m_bin_Sw.clear(); 00217 m_bin_Sw2.clear(); 00218 m_bin_Sxw.clear(); 00219 m_bin_Sx2w.clear(); 00220 m_axes.clear(); 00221 m_bin_number = 0; 00222 m_dimension = 0; 00223 //m_annotations.clear(); 00224 00225 // Some checks : 00226 if(!a_dim) return false; 00227 m_axes.resize(a_dim); 00228 // Setup axes : 00229 for(dim_t iaxis=0;iaxis<a_dim;iaxis++) { 00230 if(!m_axes[iaxis].configure(aNumbers[iaxis],aMins[iaxis],aMaxs[iaxis])) { 00231 // do not do : 00232 // m_axes.clear() 00233 // so that : 00234 // b1::axis(),b2::axis_[x,y]() 00235 // do not crash in case of a bad booking. 00236 //m_axes.clear(); 00237 return false; 00238 } 00239 } 00240 00241 m_dimension = a_dim; 00242 00243 base_allocate(); //set m_bin_number. 00244 00245 return true; 00246 } 00247 00248 bool configure(dim_t a_dim,const std::vector< std::vector<TC> >& aEdges) { 00249 // Clear : 00250 m_bin_entries.clear(); 00251 m_bin_Sw.clear(); 00252 m_bin_Sw2.clear(); 00253 m_bin_Sxw.clear(); 00254 m_bin_Sx2w.clear(); 00255 m_axes.clear(); 00256 m_bin_number = 0; 00257 m_dimension = 0; 00258 //m_annotations.clear(); 00259 00260 // Some checks : 00261 if(!a_dim) return false; 00262 m_axes.resize(a_dim); 00263 // Setup axes : 00264 for(dim_t iaxis=0;iaxis<a_dim;iaxis++) { 00265 if(!m_axes[iaxis].configure(aEdges[iaxis])) { 00266 //m_axes.clear(); 00267 return false; 00268 } 00269 } 00270 00271 m_dimension = a_dim; 00272 00273 base_allocate(); //set m_bin_number. 00274 00275 return true; 00276 } 00277 00278 void base_reset() { 00279 // Reset content (different of clear that deallocate all internal things). 00280 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00281 m_bin_entries[ibin] = 0; 00282 m_bin_Sw[ibin] = 0; 00283 m_bin_Sw2[ibin] = 0; 00284 for(dim_t iaxis=0;iaxis<m_dimension;iaxis++) { 00285 m_bin_Sxw[ibin][iaxis] = 0; 00286 m_bin_Sx2w[ibin][iaxis] = 0; 00287 } 00288 } 00289 //profile not done here. 00290 } 00291 00292 protected: 00293 void base_allocate() { 00294 dim_t iaxis; 00295 // Add two bins for the [under,out]flow data. 00296 bn_t n_bin = 1; 00297 for(iaxis=0;iaxis<m_dimension;iaxis++) { 00298 n_bin *= (m_axes[iaxis].bins() + 2); 00299 } 00300 00301 m_bin_entries.resize(n_bin,0); 00302 m_bin_Sw.resize(n_bin,0); 00303 m_bin_Sw2.resize(n_bin,0); 00304 00305 std::vector<TC> empty; 00306 empty.resize(m_dimension,0); 00307 m_bin_Sxw.resize(n_bin,empty); 00308 m_bin_Sx2w.resize(n_bin,empty); 00309 00310 m_bin_number = n_bin; // All bins : [in-range, underflow, outflow] bins. 00311 00312 m_axes[0].m_offset = 1; 00313 for(iaxis=1;iaxis<m_dimension;iaxis++) { 00314 m_axes[iaxis].m_offset = 00315 m_axes[iaxis-1].m_offset * (m_axes[iaxis-1].bins()+2); 00316 } 00317 00318 } 00319 00320 public: 00321 // for BatchLab::Rio::TH::streamTH1 : 00322 TN get_entries() const { 00323 TN number = 0; 00324 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00325 if(!is_out(ibin)) { 00326 number += m_bin_entries[ibin]; 00327 } 00328 } 00329 return number; 00330 } 00331 TW get_Sw() const { 00332 TW sw = 0; 00333 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00334 if(!is_out(ibin)) { 00335 sw += m_bin_Sw[ibin]; 00336 } 00337 } 00338 return sw; 00339 } 00340 00341 TW get_Sw2() const { 00342 TW sw2 = 0; 00343 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00344 if(!is_out(ibin)) { 00345 sw2 += m_bin_Sw2[ibin]; 00346 } 00347 } 00348 return sw2; 00349 } 00350 00351 bool get_ith_axis_Sxw(dim_t a_axis,TC& a_value) const { 00352 a_value = 0; 00353 if(a_axis>=m_dimension) return false; 00354 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00355 if(!is_out(ibin)) { 00356 a_value += m_bin_Sxw[ibin][a_axis]; 00357 } 00358 } 00359 return true; 00360 } 00361 00362 bool get_ith_axis_Sx2w(dim_t a_axis,TC& a_value) const { 00363 a_value = 0; 00364 if(a_axis>=m_dimension) return false; 00365 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00366 if(!is_out(ibin)) { 00367 a_value += m_bin_Sx2w[ibin][a_axis]; 00368 } 00369 } 00370 return true; 00371 } 00372 00373 TN get_all_entries() const { 00374 TN number = 0; 00375 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00376 number += m_bin_entries[ibin]; 00377 } 00378 return number; 00379 } 00380 00381 void get_indices(bn_t aOffset,std::vector<int>& aIs) const { 00382 int offset = aOffset; 00383 {for(int iaxis=m_dimension-1;iaxis>=0;iaxis--) { 00384 aIs[iaxis] = offset/m_axes[iaxis].m_offset; 00385 offset -= aIs[iaxis] * m_axes[iaxis].m_offset; 00386 }} 00387 for(unsigned iaxis=0;iaxis<m_dimension;iaxis++) { 00388 if(aIs[iaxis]==0) { 00389 aIs[iaxis] = axis<TC>::UNDERFLOW_BIN; 00390 } else if(aIs[iaxis]==m_axes[iaxis].m_number_of_bins+1) { 00391 aIs[iaxis] = axis<TC>::OVERFLOW_BIN; 00392 } else { 00393 aIs[iaxis]--; 00394 } 00395 } 00396 } 00397 00398 bool is_out(bn_t aOffset) const { 00399 int offset = aOffset; 00400 int index; 00401 for(int iaxis=m_dimension-1;iaxis>=0;iaxis--) { 00402 index = offset/m_axes[iaxis].m_offset; 00403 if(index==0) return true; 00404 if(index==(int(m_axes[iaxis].m_number_of_bins)+1)) return true; 00405 offset -= index * m_axes[iaxis].m_offset; 00406 } 00407 return false; 00408 } 00409 00410 bool get_offset(const std::vector<int>& aIs,bn_t& a_offset) const { 00411 // aIs[iaxis] is given in in-range indexing : 00412 // - [0,n[iaxis]-1] for in-range bins 00413 // - UNDERFLOW_BIN for the iaxis underflow bin 00414 // - OVERFLOW_BIN for the iaxis overflow bin 00415 a_offset = 0; 00416 if(!m_dimension) return false; 00417 bn_t ibin; 00418 for(dim_t iaxis=0;iaxis<m_dimension;iaxis++) { 00419 if(!m_axes[iaxis].in_range_to_absolute_index(aIs[iaxis],ibin)) { 00420 a_offset = 0; 00421 return false; 00422 } 00423 a_offset += ibin * m_axes[iaxis].m_offset; 00424 } 00425 return true; 00426 } 00427 00428 // to access data from methods : 00429 const std::vector<TN>& bins_entries() const {return m_bin_entries;} 00430 const std::vector<TW>& bins_sum_w() const {return m_bin_Sw;} 00431 const std::vector<TW>& bins_sum_w2() const {return m_bin_Sw2;} 00432 const std::vector< std::vector<TC> >& bins_sum_xw() const {return m_bin_Sxw;} 00433 const std::vector< std::vector<TC> >& bins_sum_x2w() const {return m_bin_Sx2w;} 00434 00435 public: 00436 const axis<TC>& get_axis(int aIndex) const {return m_axes[aIndex];} 00437 bn_t get_bins() const {return m_bin_number;} 00438 const std::string& get_title() const {return m_title;} 00439 dim_t get_dimension() const {return m_dimension;} 00440 bool is_valid() const {return (m_dimension?true:false);} 00441 00442 /* 00443 public: //annotations : 00444 typedef std::map<std::string,std::string> annotations_t; 00445 const annotations_t& annotations() const {return m_annotations;} 00446 annotations_t annotations() {return m_annotations;} 00447 void add_annotation(const std::string& a_key,const std::string& a_value) { 00448 m_annotations[a_key] = a_value; //override if a_key already exists. 00449 } 00450 bool annotation(const std::string& a_key,std::string& a_value) const { 00451 annotations_t::const_iterator it = m_annotations.find(a_key); 00452 if(it==m_annotations.end()) {a_value.clear();return false;} 00453 a_value = (*it).second; 00454 return true; 00455 } 00456 */ 00457 protected: 00458 bool is_compatible(const base_histo& a_histo){ 00459 if(m_dimension!=a_histo.m_dimension) return false; 00460 for(dim_t iaxis=0;iaxis<m_dimension;iaxis++) { 00461 if(!m_axes[iaxis].is_compatible(a_histo.m_axes[iaxis])) return false; 00462 } 00463 return true; 00464 } 00465 00466 void base_add(const base_histo& a_histo){ 00467 // The only histogram operation that makes sense. 00468 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00469 m_bin_entries[ibin] += a_histo.m_bin_entries[ibin]; 00470 m_bin_Sw[ibin] += a_histo.m_bin_Sw[ibin]; 00471 m_bin_Sw2[ibin] += a_histo.m_bin_Sw2[ibin]; 00472 for(dim_t iaxis=0;iaxis<m_dimension;iaxis++) { 00473 m_bin_Sxw[ibin][iaxis] += a_histo.m_bin_Sxw[ibin][iaxis]; 00474 m_bin_Sx2w[ibin][iaxis] += a_histo.m_bin_Sx2w[ibin][iaxis]; 00475 } 00476 } 00477 } 00478 00479 void base_subtract(const base_histo& a_histo) { 00480 //ill-defined operation. We keep that because of the "ill-defined past". 00481 // We build a new histo with one entry in each bin. 00482 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00483 m_bin_entries[ibin] = 1; 00484 00485 m_bin_Sw[ibin] -= a_histo.m_bin_Sw[ibin]; 00486 // Yes, it is a += in the below. 00487 m_bin_Sw2[ibin] += a_histo.m_bin_Sw2[ibin]; 00488 for(dim_t iaxis=0;iaxis<m_dimension;iaxis++) { 00489 m_bin_Sxw[ibin][iaxis] -= a_histo.m_bin_Sxw[ibin][iaxis]; 00490 m_bin_Sx2w[ibin][iaxis] -= a_histo.m_bin_Sx2w[ibin][iaxis]; 00491 } 00492 } 00493 } 00494 00495 bool base_multiply(const base_histo& a_histo) { 00496 //ill-defined operation. We keep that because of the "ill-defined past". 00497 00498 // We build a new histo with one entry in each bin of weight : 00499 // this.w * a_histo.w 00500 // The current histo is overriden with this new histo. 00501 // The m_bin_Sw2 computation is consistent with FreeHEP and ROOT. 00502 00503 if(!is_compatible(a_histo)) return false; 00504 00505 std::vector<int> is(m_dimension); 00506 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00507 TW swa = m_bin_Sw[ibin]; 00508 TW sw2a = m_bin_Sw2[ibin]; 00509 TW swb = a_histo.m_bin_Sw[ibin]; 00510 TW sw2b = a_histo.m_bin_Sw2[ibin]; 00511 TW sw = swa * swb; 00512 m_bin_entries[ibin] = 1; 00513 m_bin_Sw[ibin] = sw; 00514 m_bin_Sw2[ibin] = sw2a * swb * swb + sw2b * swa * swa; 00515 get_indices(ibin,is); 00516 for(dim_t iaxis=0;iaxis<m_dimension;iaxis++) { 00517 TC x = m_axes[iaxis].bin_center(is[iaxis]); 00518 m_bin_Sxw[ibin][iaxis] = x * sw; 00519 m_bin_Sx2w[ibin][iaxis] = x * x * sw; 00520 } 00521 } 00522 return true; 00523 } 00524 00525 bool base_divide(const base_histo& a_histo) { 00526 //ill-defined operation. We keep that because of the "ill-defined past". 00527 00528 // We build a new histo with one entry in each bin of weight : 00529 // this.w / a_histo.w 00530 // The current histo is overriden with this new histo. 00531 // The m_bin_Sw2 computation is consistent with FreeHEP and ROOT. 00532 00533 if(!is_compatible(a_histo)) return false; 00534 00535 std::vector<int> is(m_dimension); 00536 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00537 get_indices(ibin,is); 00538 TW swa = m_bin_Sw[ibin]; 00539 TW swb = a_histo.m_bin_Sw[ibin]; 00540 TW sw2a = m_bin_Sw2[ibin]; 00541 TW sw2b = a_histo.m_bin_Sw2[ibin]; 00542 if(swb!=0) { 00543 m_bin_entries[ibin] = 1; 00544 TW sw = swa / swb; 00545 m_bin_Sw[ibin] = sw; 00546 TW swb2 = swb * swb; 00547 m_bin_Sw2[ibin] = sw2a / swb2 + sw2b * swa * swa /(swb2*swb2); 00548 for(dim_t iaxis=0;iaxis<m_dimension;iaxis++) { 00549 TC x = m_axes[iaxis].bin_center(is[iaxis]); 00550 m_bin_Sxw[ibin][iaxis] = x * sw; 00551 m_bin_Sx2w[ibin][iaxis] = x * x * sw; 00552 } 00553 } else { 00554 m_bin_entries[ibin] = 0; 00555 m_bin_Sw[ibin] = 0; 00556 m_bin_Sw2[ibin] = 0; 00557 for(dim_t iaxis=0;iaxis<m_dimension;iaxis++) { 00558 m_bin_Sxw[ibin][iaxis] = 0; 00559 m_bin_Sx2w[ibin][iaxis] = 0; 00560 } 00561 } 00562 } 00563 return true; 00564 } 00565 00566 bool base_multiply(TW aFactor) { 00567 if(aFactor<0) return false; 00568 TW factor2 = aFactor * aFactor; 00569 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00570 m_bin_Sw[ibin] *= aFactor; 00571 m_bin_Sw2[ibin] *= factor2; 00572 for(dim_t iaxis=0;iaxis<m_dimension;iaxis++) { 00573 m_bin_Sxw[ibin][iaxis] *= aFactor; 00574 m_bin_Sx2w[ibin][iaxis] *= aFactor; 00575 } 00576 } 00577 return true; 00578 } 00579 00580 bool get_ith_axis_mean(dim_t a_axis,TC& a_value) const { 00581 a_value = 0; 00582 if(a_axis>=m_dimension) return false; 00583 TW sw = 0; 00584 TC sxw = 0; 00585 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00586 if(!is_out(ibin)) { 00587 sw += m_bin_Sw[ibin]; 00588 sxw += m_bin_Sxw[ibin][a_axis]; 00589 } 00590 } 00591 if(sw==0) return false; 00592 a_value = sxw/sw; 00593 return true; 00594 } 00595 00596 bool get_ith_axis_rms(dim_t a_axis,TC& a_value) const { 00597 a_value = 0; 00598 if(a_axis>=m_dimension) return false; 00599 TW sw = 0; 00600 TC sxw = 0; 00601 TC sx2w = 0; 00602 for(bn_t ibin=0;ibin<m_bin_number;ibin++) { 00603 if(!is_out(ibin)) { 00604 sw += m_bin_Sw[ibin]; 00605 sxw += m_bin_Sxw[ibin][a_axis]; 00606 sx2w += m_bin_Sx2w[ibin][a_axis]; 00607 } 00608 } 00609 if(sw==0) return false; 00610 TC mean = sxw/sw; 00611 a_value = ::sqrt(::fabs((sx2w / sw) - mean * mean)); 00612 return true; 00613 } 00614 00615 TN get_bin_entries(const std::vector<int>& aIs) const { 00616 if(m_bin_number==0) return 0; 00617 bn_t offset; 00618 if(!get_offset(aIs,offset)) return 0; 00619 return m_bin_entries[offset]; 00620 } 00621 00622 protected: 00623 // General : 00624 std::string m_title; 00625 dim_t m_dimension; 00626 // Bins : 00627 bn_t m_bin_number; 00628 std::vector<TN> m_bin_entries; 00629 std::vector<TW> m_bin_Sw; 00630 std::vector<TW> m_bin_Sw2; 00631 std::vector< std::vector<TC> > m_bin_Sxw; 00632 std::vector< std::vector<TC> > m_bin_Sx2w; 00633 // Axes : 00634 std::vector< axis<TC> > m_axes; 00635 // etc : 00636 //annotations_t m_annotations; 00637 }; 00638 00639 }} 00640 00641 #endif