g4tools  5.4.0
Classes | Enumerations | Functions
tools::histo Namespace Reference

Classes

class  axis
 
class  b1
 
class  b2
 
class  b3
 
class  base_cloud
 
class  base_histo
 
class  c1d
 
class  c2d
 
class  c3d
 
class  data_point
 
class  dps
 
class  h1
 
class  h1d
 
class  h1df
 
class  h2
 
class  h2d
 
class  h2df
 
class  h3
 
class  h3d
 
class  h3df
 
class  histo_data
 
class  hmpi
 
class  measurement
 
class  p1
 
class  p1d
 
class  p2
 
class  p2d
 
class  profile_data
 

Enumerations

enum  { axis_UNDERFLOW_BIN = -2, axis_OVERFLOW_BIN = -1 }
 

Functions

template<class TC , class TO >
bool is_out (const std::vector< axis< TC, TO > > &a_axes, TO a_offset)
 
template<class TC , class TO >
void get_indices (const std::vector< axis< TC, TO > > &a_axes, TO a_offset, std::vector< int > &a_is)
 
template<class TC , class TO >
bool get_offset (const std::vector< axis< TC, TO > > &a_axes, const std::vector< int > &a_is, TO &a_offset)
 
const std::string & key_axis_x_title ()
 
const std::string & key_axis_y_title ()
 
const std::string & key_axis_z_title ()
 
bool axis_dui_pack (impi &a_mpi, const axis< double, unsigned int > &a_axis)
 hist_data to mpi //////////////////////////////////////////////////////// More...
 
bool histo_data_duiuid_pack (impi &a_mpi, const histo_data< double, unsigned int, unsigned int, double > &a_hd)
 
bool axis_dui_unpack (impi &a_mpi, axis< double, unsigned int > &a_axis)
 mpi to hist_data //////////////////////////////////////////////////////// More...
 
bool histo_data_duiuid_unpack (impi &a_mpi, histo_data< double, unsigned int, unsigned int, double > &a_hd)
 
bool profile_data_duiuidd_pack (impi &a_mpi, const profile_data< double, unsigned int, unsigned int, double, double > &a_pd)
 profile_data to C struct //////////////////////////////////////////////// More...
 
bool profile_data_duiuidd_unpack (impi &a_mpi, profile_data< double, unsigned int, unsigned int, double, double > &a_pd)
 mpi to profile_data ///////////////////////////////////////////////////// More...
 
unsigned int dim_planes (unsigned int a_dim)
 
void delete_histos (std::vector< std::pair< std::string, void * > > &a_hists)
 
caxis_dui * caxis_dui_alloc (const axis< double, unsigned int > &a_axis)
 hist_data to C struct /////////////////////////////////////////////////// More...
 
void caxis_dui_free (caxis_dui *&a_cp)
 
void chisto_duiuid_assign (chisto_duiuid &a_c, const histo_data< double, unsigned int, unsigned int, double > &a_hd)
 
chisto_duiuid * chisto_duiuid_alloc (const histo_data< double, unsigned int, unsigned int, double > &a_hd)
 
void chisto_duiuid_clear (chisto_duiuid &a_c)
 
void chisto_duiuid_free (chisto_duiuid *&a_cp)
 
template<class T >
void vec_assign (std::vector< T > &a_v, unsigned int a_number, const T *a_c)
 C struct to hist_data ///////////////////////////////////////////////////. More...
 
void axis_dui_assign (axis< double, unsigned int > &a_axis, const caxis_dui &a_c)
 
void histo_data_duiuid_assign (histo_data< double, unsigned int, unsigned int, double > &a_hd, const chisto_duiuid &a_c)
 
cprofile_duiuidd * cprofile_duiuidd_alloc (const profile_data< double, unsigned int, unsigned int, double, double > &a_pd)
 profile_data to C struct //////////////////////////////////////////////// More...
 
void cprofile_duiuidd_free (cprofile_duiuidd *&a_cp)
 
void profile_data_duiuidd_assign (profile_data< double, unsigned int, unsigned int, double, double > &a_pd, const cprofile_duiuidd &a_c)
 C struct to profile_data ////////////////////////////////////////////////. More...
 
template<class H2 , class H1 >
bool fill_slice_x (const H2 &a_from, int aJbeg, int aJend, H1 &a_to)
 h2 -> h1 //////////////////////////////////////////////////////////////////// More...
 
template<class H2 , class H1 >
H1 * slice_x (const H2 &a_from, int aJbeg, int aJend, const std::string &a_title)
 
template<class H2 , class H1 >
H1 * projection_x (const H2 &a_from, const std::string &a_title)
 
template<class H2 , class H1 >
bool fill_slice_y (const H2 &a_from, int aIbeg, int aIend, H1 &a_to)
 
template<class H2 , class H1 >
H1 * slice_y (const H2 &a_from, int aIbeg, int aIend, const std::string &a_title)
 
template<class H2 , class H1 >
H1 * projection_y (const H2 &a_from, const std::string &a_title)
 
template<class H2 , class P1 >
bool fill_profile_x (const H2 &a_from, int aJbeg, int aJend, P1 &a_to)
 h2 -> p1 //////////////////////////////////////////////////////////////////// More...
 
template<class H2 , class P1 >
bool fill_profile_y (const H2 &a_from, int aIbeg, int aIend, P1 &a_to)
 
template<class H3 , class H2 >
bool fill_slice_yz (const H3 &a_from, int aIbeg, int aIend, H2 &a_to)
 h3 -> h2 //////////////////////////////////////////////////////////////////// More...
 
template<class H3 , class H2 >
bool fill_slice_xy (const H3 &a_from, int aKbeg, int aKend, H2 &a_to)
 
template<class H3 , class H2 >
bool fill_slice_xz (const H3 &a_from, int aJbeg, int aJend, H2 &a_to)
 
template<class H3 , class H2 >
H2 * slice_xy (const H3 &a_from, int aKbeg, int aKend, const std::string &a_title)
 
template<class H3 , class H2 >
H2 * slice_yz (const H3 &a_from, int aIbeg, int aIend, const std::string &a_title)
 
template<class H3 , class H2 >
H2 * slice_xz (const H3 &a_from, int aJbeg, int aJend, const std::string &a_title)
 
h1d * slice_x (const h2d &a_from, int aJbeg, int aJend, const std::string &a_title)
 
h1d * projection_x (const h2d &a_from, const std::string &a_title)
 
h1d * slice_y (const h2d &a_from, int aIbeg, int aIend, const std::string &a_title)
 
h1d * projection_y (const h2d &a_from, const std::string &a_title)
 
p1d * profile_x (const h2d &a_from, int aJbeg, int aJend, const std::string &a_title)
 
p1d * profile_x (const h2d &a_from, const std::string &a_title)
 
p1d * profile_y (const h2d &a_from, int aIbeg, int aIend, const std::string &a_title)
 
p1d * profile_y (const h2d &a_from, const std::string &a_title)
 
h2d * slice_xy (const h3d &a_from, int aKbeg, int aKend, const std::string &a_title)
 
h2d * projection_xy (const h3d &a_from, const std::string &a_title)
 
h2d * slice_yz (const h3d &a_from, int aIbeg, int aIend, const std::string &a_title)
 
h2d * projection_yz (const h3d &a_from, const std::string &a_title)
 
h2d * slice_xz (const h3d &a_from, int aJbeg, int aJend, const std::string &a_title)
 
h2d * projection_xz (const h3d &a_from, const std::string &a_title)
 

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
axis_UNDERFLOW_BIN 
axis_OVERFLOW_BIN 

Definition at line 13 of file axis.

13 { axis_UNDERFLOW_BIN = -2, axis_OVERFLOW_BIN = -1 }; //AIDA casing.

Function Documentation

◆ axis_dui_assign()

void tools::histo::axis_dui_assign ( axis< double, unsigned int > &  a_axis,
const caxis_dui &  a_c 
)
inline

Definition at line 222 of file htoc.

222  {
223  a_axis.m_offset = a_c.m_offset;
224  a_axis.m_number_of_bins = a_c.m_number_of_bins;
225  a_axis.m_minimum_value = a_c.m_minimum_value;
226  a_axis.m_maximum_value = a_c.m_maximum_value;
227  a_axis.m_fixed = a_c.m_fixed==1?true:false;
228  a_axis.m_bin_width = a_c.m_bin_width;
229  vec_assign(a_axis.m_edges,a_c.m_number_of_edges,a_c.m_edges);
230 }

◆ axis_dui_pack()

bool tools::histo::axis_dui_pack ( impi &  a_mpi,
const axis< double, unsigned int > &  a_axis 
)
inline

hist_data to mpi ////////////////////////////////////////////////////////

Definition at line 22 of file hd2mpi.

22  {
23  //typedef double TC;
24  //typedef unsigned int TO;
25  //typedef unsigned int bn_t;
26  if(!a_mpi.pack(a_axis.m_offset)) return false; //TO
27  if(!a_mpi.pack(a_axis.m_number_of_bins)) return false; //bn_t
28  if(!a_mpi.pack(a_axis.m_minimum_value)) return false; //TC
29  if(!a_mpi.pack(a_axis.m_maximum_value)) return false; //TC
30  if(!a_mpi.bpack(a_axis.m_fixed)) return false;
31  if(!a_mpi.pack(a_axis.m_bin_width)) return false; //TC
32  if(!a_mpi.vpack(a_axis.m_edges)) return false; //TC
33  return true;
34 }

◆ axis_dui_unpack()

bool tools::histo::axis_dui_unpack ( impi &  a_mpi,
axis< double, unsigned int > &  a_axis 
)
inline

mpi to hist_data ////////////////////////////////////////////////////////

Definition at line 88 of file hd2mpi.

88  {
89  //typedef double TC;
90  //typedef unsigned int TO;
91  //typedef unsigned int bn_t;
92 
93  if(!a_mpi.unpack(a_axis.m_offset)) return false; //TO
94  if(!a_mpi.unpack(a_axis.m_number_of_bins)) return false; //bn_t
95  if(!a_mpi.unpack(a_axis.m_minimum_value)) return false; //TC
96  if(!a_mpi.unpack(a_axis.m_maximum_value)) return false; //TC
97  if(!a_mpi.bunpack(a_axis.m_fixed)) return false;
98  if(!a_mpi.unpack(a_axis.m_bin_width)) return false; //TC
99  if(!a_mpi.vunpack(a_axis.m_edges)) return false; //TC
100 
101  return true;
102 }

◆ caxis_dui_alloc()

caxis_dui* tools::histo::caxis_dui_alloc ( const axis< double, unsigned int > &  a_axis)
inline

hist_data to C struct ///////////////////////////////////////////////////

Definition at line 81 of file htoc.

81  {
82  caxis_dui* a_cp = cmem_alloc<caxis_dui>(1);
83  if(!a_cp) return NULL;
84 
85  caxis_dui& a_c = *a_cp;
86 
87  typedef double TC;
88 
89  a_c.m_offset = a_axis.m_offset;
90  a_c.m_number_of_bins = a_axis.m_number_of_bins;
91  a_c.m_minimum_value = a_axis.m_minimum_value;
92  a_c.m_maximum_value = a_axis.m_maximum_value;
93  a_c.m_fixed = a_axis.m_fixed?1:0;
94  a_c.m_bin_width = a_axis.m_bin_width;
95  a_c.m_number_of_edges = (unsigned int)a_axis.m_edges.size();
96  a_c.m_edges = cmem_alloc_copy<TC>(vec_data(a_axis.m_edges),a_axis.m_edges.size());
97 
98  return a_cp;
99 }

◆ caxis_dui_free()

void tools::histo::caxis_dui_free ( caxis_dui *&  a_cp)
inline

Definition at line 101 of file htoc.

101  {
102  if(!a_cp) return;
103  caxis_dui& a_c = *a_cp;
104 
105  cmem_free(a_c.m_edges);
106 
107  a_c.m_offset = 0;
108  a_c.m_number_of_bins = 0;
109  a_c.m_minimum_value = 0;
110  a_c.m_maximum_value = 0;
111  a_c.m_fixed = 1;
112  a_c.m_bin_width = 0;
113  a_c.m_number_of_edges = 0;
114 
115  cmem_free(a_cp);
116 }

◆ chisto_duiuid_alloc()

chisto_duiuid* tools::histo::chisto_duiuid_alloc ( const histo_data< double, unsigned int, unsigned int, double > &  a_hd)
inline

Definition at line 166 of file htoc.

166  {
167  chisto_duiuid* a_cp = cmem_alloc<chisto_duiuid>(1);
168  if(!a_cp) return NULL;
169  chisto_duiuid_assign(*a_cp,a_hd);
170  return a_cp;
171 }

◆ chisto_duiuid_assign()

void tools::histo::chisto_duiuid_assign ( chisto_duiuid &  a_c,
const histo_data< double, unsigned int, unsigned int, double > &  a_hd 
)
inline

Definition at line 118 of file htoc.

118  {
119  typedef double TC;
120  typedef unsigned int TN;
121  typedef double TW;
122 
123  a_c.m_title = str_dup(a_hd.m_title.c_str());
124  a_c.m_dimension = a_hd.m_dimension;
125  a_c.m_bin_number = a_hd.m_bin_number;
126  a_c.m_bin_entries = cmem_alloc_copy<TN>(vec_data(a_hd.m_bin_entries),a_hd.m_bin_number);
127  a_c.m_bin_Sw = cmem_alloc_copy<TW>(vec_data(a_hd.m_bin_Sw),a_hd.m_bin_number);
128  a_c.m_bin_Sw2 = cmem_alloc_copy<TW>(vec_data(a_hd.m_bin_Sw2),a_hd.m_bin_number);
129 
130  {a_c.m_bin_Sxw = cmem_alloc<TC*>(a_hd.m_bin_number);
131  for(unsigned int ibin=0;ibin<a_hd.m_bin_number;ibin++) {
132  a_c.m_bin_Sxw[ibin] = cmem_alloc_copy<TC>(vec_data(a_hd.m_bin_Sxw[ibin]),a_hd.m_dimension);
133  }}
134  {a_c.m_bin_Sx2w = cmem_alloc<TC*>(a_hd.m_bin_number);
135  for(unsigned int ibin=0;ibin<a_hd.m_bin_number;ibin++) {
136  a_c.m_bin_Sx2w[ibin] = cmem_alloc_copy<TC>(vec_data(a_hd.m_bin_Sx2w[ibin]),a_hd.m_dimension);
137  }}
138 
139  // Axes :
140  {a_c.m_axes = cmem_alloc<caxis_dui*>(a_hd.m_dimension);
141  for(unsigned int iaxis=0;iaxis<a_hd.m_dimension;iaxis++) {
142  a_c.m_axes[iaxis] = caxis_dui_alloc(a_hd.m_axes[iaxis]);
143  }}
144 
145  // etc :
146  a_c.m_in_range_plane_Sxyw = cmem_alloc_copy<TC>(vec_data(a_hd.m_in_range_plane_Sxyw),dim_planes(a_hd.m_dimension));
147  {a_c.m_number_of_annotations = (unsigned int)a_hd.m_annotations.size();
148  a_c.m_annotations = cmem_alloc<char*>(2*a_hd.m_annotations.size());
149  unsigned int index = 0;
150  tools_mforcit(std::string,std::string,a_hd.m_annotations,it) {
151  a_c.m_annotations[index] = str_dup((*it).first.c_str());index++;
152  a_c.m_annotations[index] = str_dup((*it).second.c_str());index++;
153  }}
154  // fast getters :
155  a_c.m_all_entries = a_hd.m_all_entries;
156  a_c.m_in_range_entries = a_hd.m_in_range_entries;
157  a_c.m_in_range_Sw = a_hd.m_in_range_Sw;
158  a_c.m_in_range_Sw2 = a_hd.m_in_range_Sw2;
159  a_c.m_in_range_Sxw = cmem_alloc_copy<TC>(vec_data(a_hd.m_in_range_Sxw),a_hd.m_dimension);
160  a_c.m_in_range_Sx2w = cmem_alloc_copy<TC>(vec_data(a_hd.m_in_range_Sx2w),a_hd.m_dimension);
161 
162  //FIXME : should check all sub pointers.
163  //if(to_del {cmem_free(a_cp);return NULL;}
164 }

◆ chisto_duiuid_clear()

void tools::histo::chisto_duiuid_clear ( chisto_duiuid &  a_c)
inline

Definition at line 173 of file htoc.

173  {
174  str_del(a_c.m_title);
175 
176  cmem_free(a_c.m_bin_entries);
177  cmem_free(a_c.m_bin_Sw);
178  cmem_free(a_c.m_bin_Sw2);
179 
180  {for(unsigned int ibin=0;ibin<a_c.m_bin_number;ibin++) cmem_free(a_c.m_bin_Sxw[ibin]);
181  cmem_free(a_c.m_bin_Sxw);}
182  {for(unsigned int ibin=0;ibin<a_c.m_bin_number;ibin++) cmem_free(a_c.m_bin_Sx2w[ibin]);
183  cmem_free(a_c.m_bin_Sx2w);}
184 
185  cmem_free(a_c.m_in_range_plane_Sxyw);
186 
187  {for(unsigned int iaxis=0;iaxis<a_c.m_dimension;iaxis++) caxis_dui_free(a_c.m_axes[iaxis]);
188  cmem_free(a_c.m_axes);}
189 
190  {for(unsigned int i=0;i<(2*a_c.m_number_of_annotations);i++) str_del(a_c.m_annotations[i]);
191  cmem_free(a_c.m_annotations);}
192 
193  cmem_free(a_c.m_in_range_Sxw);
194  cmem_free(a_c.m_in_range_Sx2w);
195 
196  a_c.m_dimension = 0;
197  a_c.m_bin_number = 0;
198  a_c.m_number_of_annotations = 0;
199 
200  a_c.m_all_entries = 0;
201  a_c.m_in_range_entries = 0;
202  a_c.m_in_range_Sw = 0;
203  a_c.m_in_range_Sw2 = 0;
204 }

◆ chisto_duiuid_free()

void tools::histo::chisto_duiuid_free ( chisto_duiuid *&  a_cp)
inline

Definition at line 206 of file htoc.

206  {
207  if(!a_cp) return;
208  chisto_duiuid_clear(*a_cp);
209  cmem_free(a_cp);
210 }

◆ cprofile_duiuidd_alloc()

cprofile_duiuidd* tools::histo::cprofile_duiuidd_alloc ( const profile_data< double, unsigned int, unsigned int, double, double > &  a_pd)
inline

profile_data to C struct ////////////////////////////////////////////////

Definition at line 279 of file htoc.

279  {
280  cprofile_duiuidd* a_cp = cmem_alloc<cprofile_duiuidd>(1);
281  if(!a_cp) return NULL;
282 
283  cprofile_duiuidd& a_c = *a_cp;
284 
285  chisto_duiuid_assign(a_c.m_histo,a_pd);
286 
287  typedef double TV;
288 
289  // profile part :
290  a_c.m_is_profile = a_pd.m_is_profile?1:0;
291  a_c.m_bin_Svw = cmem_alloc_copy<TV>(vec_data(a_pd.m_bin_Svw),a_pd.m_bin_number);
292  a_c.m_bin_Sv2w = cmem_alloc_copy<TV>(vec_data(a_pd.m_bin_Sv2w),a_pd.m_bin_number);
293  a_c.m_cut_v = a_pd.m_cut_v?1:0;
294  a_c.m_min_v = a_pd.m_min_v;
295  a_c.m_max_v = a_pd.m_max_v;
296 
297  return a_cp;
298 }

◆ cprofile_duiuidd_free()

void tools::histo::cprofile_duiuidd_free ( cprofile_duiuidd *&  a_cp)
inline

Definition at line 300 of file htoc.

300  {
301  if(!a_cp) return;
302 
303  cprofile_duiuidd& a_c = *a_cp;
304 
305  chisto_duiuid_clear(a_c.m_histo);
306 
307  cmem_free(a_c.m_bin_Svw);
308  cmem_free(a_c.m_bin_Sv2w);
309 
310  a_c.m_is_profile = 1;
311  a_c.m_cut_v = 0;
312  a_c.m_min_v = 0;
313  a_c.m_max_v = 0;
314 
315  cmem_free(a_cp);
316 }

◆ delete_histos()

void tools::histo::delete_histos ( std::vector< std::pair< std::string, void * > > &  a_hists)
inline

Definition at line 18 of file histos.

18  {
19  typedef std::pair<std::string,void*> class_pointer;
20 
21  tools_vforit(class_pointer,a_hists,it) {
22  const std::string& scls = (*it).first;
23  if(scls==h1d::s_class()) {
24  h1d* h = (h1d*)(*it).second;
25  delete h;
26 
27  } else if(scls==h2d::s_class()) {
28  h2d* h = (h2d*)(*it).second;
29  delete h;
30 
31  } else if(scls==h3d::s_class()) {
32  h3d* h = (h3d*)(*it).second;
33  delete h;
34 
35  } else if(scls==p1d::s_class()) {
36  p1d* h = (p1d*)(*it).second;
37  delete h;
38 
39  } else if(scls==p2d::s_class()) {
40  p2d* h = (p2d*)(*it).second;
41  delete h;
42  }
43  }
44  a_hists.clear();
45 }

◆ dim_planes()

unsigned int tools::histo::dim_planes ( unsigned int  a_dim)
inline

Definition at line 17 of file histo_data.

17  {
18  // m_dim = 1 -> 0
19  // m_dim = 2 -> 0+1=1
20  // m_dim = 3 -> 0+1+2=3
21  // m_dim = 4 -> 0+1+2+3=6
22  typedef unsigned int dim_t;
23  dim_t n = 0;
24  for(dim_t i=0;i<a_dim;i++) n += i;
25  return n;
26 }

◆ fill_profile_x()

template<class H2 , class P1 >
bool tools::histo::fill_profile_x ( const H2 &  a_from,
int  aJbeg,
int  aJend,
P1 &  a_to 
)
inline

h2 -> p1 ////////////////////////////////////////////////////////////////////

Definition at line 157 of file slice.

157  {
158  if(!a_from.dimension()) return false;
159 
160  typedef typename H2::bn_t bn_t;
161 
162  bn_t jbeg;
163  if(!a_from.axis_y().in_range_to_absolute_index(aJbeg,jbeg)) return false;
164  bn_t jend;
165  if(!a_from.axis_y().in_range_to_absolute_index(aJend,jend)) return false;
166  if(jbeg>jend) return false;
167 
168  if(a_from.axis_x().bins()!=a_to.axis().bins()) return false;
169 
170  typedef typename P1::pd_t pd_t;
171  pd_t hdata = a_to.get_histo_data();
172 
173  bn_t aoffset,offset,jbin;
174  bn_t yoffset = a_from.axis_y().m_offset;
175 
176  typedef typename H2::num_entries_t TN;
177  typedef typename H2::weight_t TW;
178  typedef typename H2::coordinate_t TC;
179 
180  const std::vector<TN>& af_bin_entries = a_from.bins_entries();
181  const std::vector<TW>& af_bin_Sw = a_from.bins_sum_w();
182  const std::vector<TW>& af_bin_Sw2 = a_from.bins_sum_w2();
183  const std::vector< std::vector<TC> >& af_bin_Sxw = a_from.bins_sum_xw();
184  const std::vector< std::vector<TC> >& af_bin_Sx2w = a_from.bins_sum_x2w();
185 
186  // Fill also the outflow.
187  bn_t abins = hdata.m_axes[0].bins()+2;
188  for(bn_t aibin=0;aibin<abins;aibin++) {
189  //offset1D = ibin
190  aoffset = aibin;
191  for(jbin=jbeg;jbin<=jend;jbin++) {
192  //offset2D = ibin + jbin * yoffset
193  // hdata booked with x then :
194  offset = aibin + jbin * yoffset;
195  // Bin :
196  hdata.m_bin_entries[aoffset] += af_bin_entries[offset];
197  hdata.m_bin_Sw[aoffset] += af_bin_Sw[offset];
198  hdata.m_bin_Sw2[aoffset] += af_bin_Sw2[offset];
199  hdata.m_bin_Sxw[aoffset][0] += af_bin_Sxw[offset][0];
200  hdata.m_bin_Sx2w[aoffset][0] += af_bin_Sx2w[offset][0];
201 
202  hdata.m_bin_Svw[aoffset] += af_bin_Sxw[offset][1];
203  hdata.m_bin_Sv2w[aoffset] += af_bin_Sx2w[offset][1];
204 
205  }
206  }
207 
208  hdata.m_in_range_plane_Sxyw.assign(a_to.number_of_planes(),0); //ill-defined.
209 
210  hdata.update_fast_getters();
211  a_to.copy_from_data(hdata);
212  return true;
213 }

◆ fill_profile_y()

template<class H2 , class P1 >
bool tools::histo::fill_profile_y ( const H2 &  a_from,
int  aIbeg,
int  aIend,
P1 &  a_to 
)
inline

Definition at line 216 of file slice.

216  {
217 
218  if(!a_from.dimension()) return false;
219 
220  typedef typename H2::bn_t bn_t;
221 
222  bn_t ibeg;
223  if(!a_from.axis_x().in_range_to_absolute_index(aIbeg,ibeg)) return false;
224  bn_t iend;
225  if(!a_from.axis_x().in_range_to_absolute_index(aIend,iend)) return false;
226  if(ibeg>iend) return false;
227 
228  if(a_from.axis_y().bins()!=a_to.axis().bins()) return false;
229 
230  typedef typename P1::pd_t pd_t;
231  pd_t hdata = a_to.get_histo_data();
232 
233  bn_t aibin,aoffset,offset,ibin;
234  bn_t yoffset = a_from.axis_y().m_offset;
235 
236  typedef typename H2::num_entries_t TN;
237  typedef typename H2::weight_t TW;
238  typedef typename H2::coordinate_t TC;
239 
240  const std::vector<TN>& af_bin_entries = a_from.bins_entries();
241  const std::vector<TW>& af_bin_Sw = a_from.bins_sum_w();
242  const std::vector<TW>& af_bin_Sw2 = a_from.bins_sum_w2();
243  const std::vector< std::vector<TC> >& af_bin_Sxw = a_from.bins_sum_xw();
244  const std::vector< std::vector<TC> >& af_bin_Sx2w = a_from.bins_sum_x2w();
245 
246  // Fill also the outflow.
247  bn_t abins = hdata.m_axes[0].bins()+2;
248  for(aibin=0;aibin<abins;aibin++) {
249  //offset1D = ibin
250  aoffset = aibin;
251  for(ibin=ibeg;ibin<=iend;ibin++) {
252  //offset2D = ibin + jbin * yoffset
253  // hdata booked with y then :
254  offset = ibin + aibin * yoffset;
255  // Bin :
256  hdata.m_bin_entries[aoffset] += af_bin_entries[offset];
257  hdata.m_bin_Sw[aoffset] += af_bin_Sw[offset];
258  hdata.m_bin_Sw2[aoffset] += af_bin_Sw2[offset];
259  hdata.m_bin_Sxw[aoffset][0] += af_bin_Sxw[offset][1];
260  hdata.m_bin_Sx2w[aoffset][0] += af_bin_Sx2w[offset][1];
261 
262  hdata.m_bin_Svw[aoffset] += af_bin_Sxw[offset][0];
263  hdata.m_bin_Sv2w[aoffset] += af_bin_Sx2w[offset][0];
264  }
265  }
266 
267  hdata.m_in_range_plane_Sxyw.assign(a_to.number_of_planes(),0); //ill-defined.
268 
269  hdata.update_fast_getters();
270  a_to.copy_from_data(hdata);
271  return true;
272 }

◆ fill_slice_x()

template<class H2 , class H1 >
bool tools::histo::fill_slice_x ( const H2 &  a_from,
int  aJbeg,
int  aJend,
H1 &  a_to 
)
inline

h2 -> h1 ////////////////////////////////////////////////////////////////////

Definition at line 17 of file slice.

17  {
18 
19  if(!a_from.dimension()) return false;
20 
21  typedef typename H2::bn_t bn_t;
22 
23  bn_t jbeg;
24  if(!a_from.axis_y().in_range_to_absolute_index(aJbeg,jbeg)) return false;
25  bn_t jend;
26  if(!a_from.axis_y().in_range_to_absolute_index(aJend,jend)) return false;
27  if(jbeg>jend) return false;
28 
29  if(a_from.axis_x().bins()!=a_to.axis().bins()) return false;
30 
31  typedef typename H1::hd_t hd_t;
32  hd_t hdata = a_to.dac();
33 
34  bn_t aoffset,offset,jbin;
35  bn_t yoffset = a_from.axis_y().m_offset;
36 
37  typedef typename H2::num_entries_t TN;
38  typedef typename H2::weight_t TW;
39  typedef typename H2::coordinate_t TC;
40 
41  const std::vector<TN>& af_bin_entries = a_from.bins_entries();
42  const std::vector<TW>& af_bin_Sw = a_from.bins_sum_w();
43  const std::vector<TW>& af_bin_Sw2 = a_from.bins_sum_w2();
44  const std::vector< std::vector<TC> >& af_bin_Sxw = a_from.bins_sum_xw();
45  const std::vector< std::vector<TC> >& af_bin_Sx2w = a_from.bins_sum_x2w();
46 
47  // Fill also the outflow.
48  bn_t abins = hdata.m_axes[0].bins()+2;
49  for(bn_t aibin=0;aibin<abins;aibin++) {
50  //offset1D = ibin
51  aoffset = aibin;
52  for(jbin=jbeg;jbin<=jend;jbin++) {
53  //offset2D = ibin + jbin * yoffset
54  // hdata booked with x then :
55  offset = aibin + jbin * yoffset;
56  // Bin :
57  hdata.m_bin_entries[aoffset] += af_bin_entries[offset];
58  hdata.m_bin_Sw[aoffset] += af_bin_Sw[offset];
59  hdata.m_bin_Sw2[aoffset] += af_bin_Sw2[offset];
60  hdata.m_bin_Sxw[aoffset][0] += af_bin_Sxw[offset][0];
61  hdata.m_bin_Sx2w[aoffset][0] += af_bin_Sx2w[offset][0];
62  }
63  }
64 
65  hdata.m_in_range_plane_Sxyw.assign(a_to.number_of_planes(),0); //ill-defined.
66 
67  hdata.update_fast_getters();
68  a_to.copy_from_data(hdata);
69  return true;
70 }

◆ fill_slice_xy()

template<class H3 , class H2 >
bool tools::histo::fill_slice_xy ( const H3 &  a_from,
int  aKbeg,
int  aKend,
H2 &  a_to 
)
inline

Definition at line 346 of file slice.

346  {
347 
348  if(!a_from.dimension()) return false;
349 
350  typedef typename H3::bn_t bn_t;
351 
352  bn_t kbeg;
353  if(!a_from.axis_z().in_range_to_absolute_index(aKbeg,kbeg)) return false;
354  bn_t kend;
355  if(!a_from.axis_z().in_range_to_absolute_index(aKend,kend)) return false;
356  if(kbeg>kend) return false;
357 
358  if(a_from.axis_x().bins()!=a_to.axis_x().bins()) return false;
359  if(a_from.axis_y().bins()!=a_to.axis_y().bins()) return false;
360 
361  typedef typename H2::hd_t hd_t;
362  hd_t hdata = a_to.dac();
363 
364  bn_t kbin;
365  bn_t aibin,ajbin,aoffset,offset;
366 
367  bn_t ayoffset = hdata.m_axes[1].m_offset;
368  bn_t yoffset = a_from.axis_y().m_offset;
369  bn_t zoffset = a_from.axis_z().m_offset;
370 
371  bn_t axbins = hdata.m_axes[0].bins()+2;
372  bn_t aybins = hdata.m_axes[1].bins()+2;
373 
374  typedef typename H3::num_entries_t TN;
375  typedef typename H3::weight_t TW;
376  typedef typename H3::coordinate_t TC;
377 
378  const std::vector<TN>& af_bin_entries = a_from.bins_entries();
379  const std::vector<TW>& af_bin_Sw = a_from.bins_sum_w();
380  const std::vector<TW>& af_bin_Sw2 = a_from.bins_sum_w2();
381  const std::vector< std::vector<TC> >& af_bin_Sxw = a_from.bins_sum_xw();
382  const std::vector< std::vector<TC> >& af_bin_Sx2w = a_from.bins_sum_x2w();
383 
384  // Fill also the outflow.
385  for(aibin=0;aibin<axbins;aibin++) {
386  for(ajbin=0;ajbin<aybins;ajbin++) {
387  //offset2D = ibin + jbin * m_axes[1].m_offset
388  aoffset = aibin + ajbin * ayoffset;
389  for(kbin=kbeg;kbin<=kend;kbin++) {
390  //offset3D = ibin + jbin * m_axes[1].m_offset + kbin*m_axes[2].m_offset;
391  // hdata booked with x-y then :
392  offset = aibin + ajbin * yoffset + kbin * zoffset;
393 
394  // Bin :
395  hdata.m_bin_entries[aoffset] += af_bin_entries[offset];
396  hdata.m_bin_Sw[aoffset] += af_bin_Sw[offset];
397  hdata.m_bin_Sw2[aoffset] += af_bin_Sw2[offset];
398  hdata.m_bin_Sxw[aoffset][0] += af_bin_Sxw[offset][0];
399  hdata.m_bin_Sxw[aoffset][1] += af_bin_Sxw[offset][1];
400  hdata.m_bin_Sx2w[aoffset][0] += af_bin_Sx2w[offset][0];
401  hdata.m_bin_Sx2w[aoffset][1] += af_bin_Sx2w[offset][1];
402  }
403  }
404  }
405 
406  hdata.m_in_range_plane_Sxyw.assign(a_to.number_of_planes(),0); //ill-defined.
407 
408  hdata.update_fast_getters();
409  a_to.copy_from_data(hdata);
410  return true;
411 }

◆ fill_slice_xz()

template<class H3 , class H2 >
bool tools::histo::fill_slice_xz ( const H3 &  a_from,
int  aJbeg,
int  aJend,
H2 &  a_to 
)
inline

Definition at line 414 of file slice.

414  {
415 
416  if(!a_from.dimension()) return false;
417 
418  typedef typename H3::bn_t bn_t;
419 
420  bn_t jbeg;
421  if(!a_from.axis_y().in_range_to_absolute_index(aJbeg,jbeg)) return false;
422  bn_t jend;
423  if(!a_from.axis_y().in_range_to_absolute_index(aJend,jend)) return false;
424  if(jbeg>jend) return false;
425 
426  if(a_from.axis_x().bins()!=a_to.axis_x().bins()) return false;
427  if(a_from.axis_z().bins()!=a_to.axis_y().bins()) return false;
428 
429  typedef typename H2::hd_t hd_t;
430  hd_t hdata = a_to.dac();
431 
432  bn_t aibin,ajbin,aoffset,offset,jbin;
433 
434  bn_t ayoffset = hdata.m_axes[1].m_offset;
435  bn_t yoffset = a_from.axis_y().m_offset;
436  bn_t zoffset = a_from.axis_z().m_offset;
437 
438  bn_t axbins = hdata.m_axes[0].bins()+2;
439  bn_t aybins = hdata.m_axes[1].bins()+2;
440 
441  typedef typename H3::num_entries_t TN;
442  typedef typename H3::weight_t TW;
443  typedef typename H3::coordinate_t TC;
444 
445  const std::vector<TN>& af_bin_entries = a_from.bins_entries();
446  const std::vector<TW>& af_bin_Sw = a_from.bins_sum_w();
447  const std::vector<TW>& af_bin_Sw2 = a_from.bins_sum_w2();
448  const std::vector< std::vector<TC> >& af_bin_Sxw = a_from.bins_sum_xw();
449  const std::vector< std::vector<TC> >& af_bin_Sx2w = a_from.bins_sum_x2w();
450 
451  // Fill also the outflow.
452  for(aibin=0;aibin<axbins;aibin++) {
453  for(ajbin=0;ajbin<aybins;ajbin++) {
454  //offset2D = ibin + jbin * m_axes[1].m_offset
455  aoffset = aibin + ajbin * ayoffset;
456  for(jbin=jbeg;jbin<=jend;jbin++) {
457  //offset3D = ibin + jbin * m_axes[1].m_offset + kbin*m_axes[2].m_offset;
458  // hdata booked with x-z then :
459  offset = aibin + jbin * yoffset + ajbin * zoffset;
460 
461  // Bin :
462  hdata.m_bin_entries[aoffset] += af_bin_entries[offset];
463  hdata.m_bin_Sw[aoffset] += af_bin_Sw[offset];
464  hdata.m_bin_Sw2[aoffset] += af_bin_Sw2[offset];
465  hdata.m_bin_Sxw[aoffset][0] += af_bin_Sxw[offset][0];
466  hdata.m_bin_Sxw[aoffset][1] += af_bin_Sxw[offset][2];
467  hdata.m_bin_Sx2w[aoffset][0] += af_bin_Sx2w[offset][0];
468  hdata.m_bin_Sx2w[aoffset][1] += af_bin_Sx2w[offset][2];
469  }
470  }
471  }
472 
473  hdata.m_in_range_plane_Sxyw.assign(a_to.number_of_planes(),0); //ill-defined.
474 
475  hdata.update_fast_getters();
476  a_to.copy_from_data(hdata);
477  return true;
478 }

◆ fill_slice_y()

template<class H2 , class H1 >
bool tools::histo::fill_slice_y ( const H2 &  a_from,
int  aIbeg,
int  aIend,
H1 &  a_to 
)
inline

Definition at line 85 of file slice.

85  {
86 
87  if(!a_from.dimension()) return false;
88 
89  typedef typename H2::bn_t bn_t;
90 
91  bn_t ibeg;
92  if(!a_from.axis_x().in_range_to_absolute_index(aIbeg,ibeg)) return false;
93  bn_t iend;
94  if(!a_from.axis_x().in_range_to_absolute_index(aIend,iend)) return false;
95  if(ibeg>iend) return false;
96 
97  if(a_from.axis_y().bins()!=a_to.axis().bins()) return false;
98 
99  typedef typename H1::hd_t hd_t;
100  hd_t hdata = a_to.dac();
101 
102  bn_t aibin,aoffset,offset,ibin;
103  bn_t yoffset = a_from.axis_y().m_offset;
104 
105  typedef typename H2::num_entries_t TN;
106  typedef typename H2::weight_t TW;
107  typedef typename H2::coordinate_t TC;
108 
109  const std::vector<TN>& af_bin_entries = a_from.bins_entries();
110  const std::vector<TW>& af_bin_Sw = a_from.bins_sum_w();
111  const std::vector<TW>& af_bin_Sw2 = a_from.bins_sum_w2();
112  const std::vector< std::vector<TC> >& af_bin_Sxw = a_from.bins_sum_xw();
113  const std::vector< std::vector<TC> >& af_bin_Sx2w = a_from.bins_sum_x2w();
114 
115  // Fill also the outflow.
116  bn_t abins = hdata.m_axes[0].bins()+2;
117  for(aibin=0;aibin<abins;aibin++) {
118  //offset1D = ibin
119  aoffset = aibin;
120  for(ibin=ibeg;ibin<=iend;ibin++) {
121  //offset2D = ibin + jbin * yoffset
122  // hdata booked with y then :
123  offset = ibin + aibin * yoffset;
124  // Bin :
125  hdata.m_bin_entries[aoffset] += af_bin_entries[offset];
126  hdata.m_bin_Sw[aoffset] += af_bin_Sw[offset];
127  hdata.m_bin_Sw2[aoffset] += af_bin_Sw2[offset];
128  hdata.m_bin_Sxw[aoffset][0] += af_bin_Sxw[offset][1];
129  hdata.m_bin_Sx2w[aoffset][0] += af_bin_Sx2w[offset][1];
130  }
131  }
132 
133  hdata.m_in_range_plane_Sxyw.assign(a_to.number_of_planes(),0); //ill-defined.
134 
135  hdata.update_fast_getters();
136  a_to.copy_from_data(hdata);
137  return true;
138 }

◆ fill_slice_yz()

template<class H3 , class H2 >
bool tools::histo::fill_slice_yz ( const H3 &  a_from,
int  aIbeg,
int  aIend,
H2 &  a_to 
)
inline

h3 -> h2 ////////////////////////////////////////////////////////////////////

Definition at line 279 of file slice.

279  {
280 
281  if(!a_from.dimension()) return false;
282 
283  typedef typename H3::bn_t bn_t;
284 
285  bn_t ibeg;
286  if(!a_from.axis_x().in_range_to_absolute_index(aIbeg,ibeg)) return false;
287  bn_t iend;
288  if(!a_from.axis_x().in_range_to_absolute_index(aIend,iend)) return false;
289  if(ibeg>iend) return false;
290 
291  if(a_from.axis_y().bins()!=a_to.axis_x().bins()) return false;
292  if(a_from.axis_z().bins()!=a_to.axis_y().bins()) return false;
293 
294  typedef typename H2::hd_t hd_t;
295  hd_t hdata = a_to.dac();
296 
297  bn_t aibin,ajbin,aoffset,offset,ibin;
298 
299  bn_t ayoffset = hdata.m_axes[1].m_offset;
300  bn_t yoffset = a_from.axis_y().m_offset;
301  bn_t zoffset = a_from.axis_z().m_offset;
302 
303  bn_t axbins = hdata.m_axes[0].bins()+2;
304  bn_t aybins = hdata.m_axes[1].bins()+2;
305 
306  typedef typename H3::num_entries_t TN;
307  typedef typename H3::weight_t TW;
308  typedef typename H3::coordinate_t TC;
309 
310  const std::vector<TN>& af_bin_entries = a_from.bins_entries();
311  const std::vector<TW>& af_bin_Sw = a_from.bins_sum_w();
312  const std::vector<TW>& af_bin_Sw2 = a_from.bins_sum_w2();
313  const std::vector< std::vector<TC> >& af_bin_Sxw = a_from.bins_sum_xw();
314  const std::vector< std::vector<TC> >& af_bin_Sx2w = a_from.bins_sum_x2w();
315 
316  // Fill also the outflow.
317  for(aibin=0;aibin<axbins;aibin++) {
318  for(ajbin=0;ajbin<aybins;ajbin++) {
319  //offset2D = ibin + jbin * m_axes[1].m_offset
320  aoffset = aibin + ajbin * ayoffset;
321  for(ibin=ibeg;ibin<=iend;ibin++) {
322  //offset3D = ibin + jbin * m_axes[1].m_offset + kbin*m_axes[2].m_offset;
323  // hdata booked with y-z then :
324  offset = ibin + aibin * yoffset + ajbin * zoffset;
325 
326  // Bin :
327  hdata.m_bin_entries[aoffset] += af_bin_entries[offset];
328  hdata.m_bin_Sw[aoffset] += af_bin_Sw[offset];
329  hdata.m_bin_Sw2[aoffset] += af_bin_Sw2[offset];
330  hdata.m_bin_Sxw[aoffset][0] += af_bin_Sxw[offset][1];
331  hdata.m_bin_Sxw[aoffset][1] += af_bin_Sxw[offset][2];
332  hdata.m_bin_Sx2w[aoffset][0] += af_bin_Sx2w[offset][1];
333  hdata.m_bin_Sx2w[aoffset][1] += af_bin_Sx2w[offset][2];
334  }
335  }
336  }
337 
338  hdata.m_in_range_plane_Sxyw.assign(a_to.number_of_planes(),0); //ill-defined.
339 
340  hdata.update_fast_getters();
341  a_to.copy_from_data(hdata);
342  return true;
343 }

◆ get_indices()

template<class TC , class TO >
void tools::histo::get_indices ( const std::vector< axis< TC, TO > > &  a_axes,
TO  a_offset,
std::vector< int > &  a_is 
)
inline

Definition at line 30 of file axes.

30  {
31  TO offset = a_offset;
32  typename std::vector< axis<TC,TO> >::size_type dimension = a_axes.size();
33  {for(int iaxis=int(dimension)-1;iaxis>=0;iaxis--) {
34  a_is[iaxis] = int(offset/a_axes[iaxis].m_offset);
35  offset -= a_is[iaxis] * a_axes[iaxis].m_offset;
36  }}
37  typedef unsigned int dim_t;
38  for(dim_t iaxis=0;iaxis<dimension;iaxis++) {
39  if(a_is[iaxis]==0) {
40  a_is[iaxis] = axis_UNDERFLOW_BIN;
41  } else if(a_is[iaxis]==int(a_axes[iaxis].m_number_of_bins)+1) {
42  a_is[iaxis] = axis_OVERFLOW_BIN;
43  } else {
44  a_is[iaxis]--;
45  }
46  }
47 }

◆ get_offset()

template<class TC , class TO >
bool tools::histo::get_offset ( const std::vector< axis< TC, TO > > &  a_axes,
const std::vector< int > &  a_is,
TO &  a_offset 
)
inline

Definition at line 50 of file axes.

50  {
51  // a_is[iaxis] is given in in-range indexing :
52  // - [0,n[iaxis]-1] for in-range bins
53  // - UNDERFLOW_BIN for the iaxis underflow bin
54  // - OVERFLOW_BIN for the iaxis overflow bin
55  a_offset = 0;
56  if(a_axes.empty()) return false;
57  typename std::vector< axis<TC,TO> >::size_type dimension = a_axes.size();
58  typename axis<TC,TO>::bn_t ibin;
59  typedef unsigned int dim_t;
60  for(dim_t iaxis=0;iaxis<dimension;iaxis++) {
61  if(!a_axes[iaxis].in_range_to_absolute_index(a_is[iaxis],ibin)) {
62  a_offset = 0;
63  return false;
64  }
65  a_offset += ibin * a_axes[iaxis].m_offset;
66  }
67  return true;
68 }

◆ histo_data_duiuid_assign()

void tools::histo::histo_data_duiuid_assign ( histo_data< double, unsigned int, unsigned int, double > &  a_hd,
const chisto_duiuid &  a_c 
)
inline

Definition at line 232 of file htoc.

232  {
233  a_hd.m_title = std::string(a_c.m_title);
234  a_hd.m_dimension = a_c.m_dimension;
235  a_hd.m_bin_number = a_c.m_bin_number;
236  vec_assign(a_hd.m_bin_entries,a_c.m_bin_number,a_c.m_bin_entries);
237  vec_assign(a_hd.m_bin_Sw,a_c.m_bin_number,a_c.m_bin_Sw);
238  vec_assign(a_hd.m_bin_Sw2,a_c.m_bin_number,a_c.m_bin_Sw2);
239 
240  {a_hd.m_bin_Sxw.resize(a_c.m_bin_number);
241  for(unsigned int ibin=0;ibin<a_c.m_bin_number;ibin++) {
242  vec_assign(a_hd.m_bin_Sxw[ibin],a_c.m_dimension,a_c.m_bin_Sxw[ibin]);
243  }}
244  {a_hd.m_bin_Sx2w.resize(a_c.m_bin_number);
245  for(unsigned int ibin=0;ibin<a_c.m_bin_number;ibin++) {
246  vec_assign(a_hd.m_bin_Sx2w[ibin],a_c.m_dimension,a_c.m_bin_Sx2w[ibin]);
247  }}
248 
249  {a_hd.m_axes.resize(a_c.m_dimension);
250  for(unsigned int iaxis=0;iaxis<a_c.m_dimension;iaxis++) {
251  axis_dui_assign(a_hd.m_axes[iaxis],*(a_c.m_axes[iaxis]));
252  }}
253  vec_assign(a_hd.m_in_range_plane_Sxyw,dim_planes(a_c.m_dimension),a_c.m_in_range_plane_Sxyw);
254 
255  {a_hd.m_annotations.clear();
256  for(unsigned int i=0;i<a_c.m_number_of_annotations;i++) {
257  a_hd.m_annotations[a_c.m_annotations[2*i+0]] = a_c.m_annotations[2*i+1];
258  }}
259 
260  a_hd.m_all_entries = a_c.m_all_entries;
261  a_hd.m_in_range_entries = a_c.m_in_range_entries;
262  a_hd.m_in_range_Sw = a_c.m_in_range_Sw;
263  a_hd.m_in_range_Sw2 = a_c.m_in_range_Sw2;
264  vec_assign(a_hd.m_in_range_Sxw,a_c.m_dimension,a_c.m_in_range_Sxw);
265  vec_assign(a_hd.m_in_range_Sx2w,a_c.m_dimension,a_c.m_in_range_Sx2w);
266 }

◆ histo_data_duiuid_pack()

bool tools::histo::histo_data_duiuid_pack ( impi &  a_mpi,
const histo_data< double, unsigned int, unsigned int, double > &  a_hd 
)
inline

Definition at line 36 of file hd2mpi.

36  {
37  //typedef double TC;
38  //typedef unsigned int TO;
39  //typedef unsigned int TN;
40  //typedef double TW;
41  //typedef unsigned int dim_t;
42  typedef unsigned int num_t;
43 
44  if(!a_mpi.spack(a_hd.m_title)) return false;
45  if(!a_mpi.pack(a_hd.m_dimension)) return false; //dim_t
46  if(!a_mpi.pack(a_hd.m_bin_number)) return false; //TO
47  if(!a_mpi.vpack(a_hd.m_bin_entries)) return false; //TN
48  if(!a_mpi.vpack(a_hd.m_bin_Sw)) return false; //TW
49  if(!a_mpi.vpack(a_hd.m_bin_Sw2)) return false; //TW
50 
51  {for(unsigned int ibin=0;ibin<a_hd.m_bin_number;ibin++) {
52  if(!a_mpi.vpack(a_hd.m_bin_Sxw[ibin])) return false;
53  }}
54  {for(unsigned int ibin=0;ibin<a_hd.m_bin_number;ibin++) {
55  if(!a_mpi.vpack(a_hd.m_bin_Sx2w[ibin])) return false;
56  }}
57 
58  // Axes :
59  {for(unsigned int iaxis=0;iaxis<a_hd.m_dimension;iaxis++) {
60  if(!axis_dui_pack(a_mpi,a_hd.m_axes[iaxis])) return false;
61  }}
62 
63  // etc :
64  if(!a_mpi.vpack(a_hd.m_in_range_plane_Sxyw)) return false; //TC
65 
66  // Annotations :
67  {if(!a_mpi.pack((num_t)a_hd.m_annotations.size())) return false; //num_t
68  tools_mforcit(std::string,std::string,a_hd.m_annotations,it) {
69  if(!a_mpi.spack((*it).first)) return false;
70  if(!a_mpi.spack((*it).second)) return false;
71  }}
72 
73  // fast getters :
74  if(!a_mpi.pack(a_hd.m_all_entries)) return false; //TN
75  if(!a_mpi.pack(a_hd.m_in_range_entries)) return false; //TN
76  if(!a_mpi.pack(a_hd.m_in_range_Sw)) return false; //TW
77  if(!a_mpi.pack(a_hd.m_in_range_Sw2)) return false; //TW
78  if(!a_mpi.vpack(a_hd.m_in_range_Sxw)) return false; //TC
79  if(!a_mpi.vpack(a_hd.m_in_range_Sx2w)) return false; //TC
80 
81  return true;
82 }

◆ histo_data_duiuid_unpack()

bool tools::histo::histo_data_duiuid_unpack ( impi &  a_mpi,
histo_data< double, unsigned int, unsigned int, double > &  a_hd 
)
inline

Definition at line 104 of file hd2mpi.

104  {
105  //typedef double TC;
106  //typedef unsigned int TO;
107  //typedef unsigned int TN;
108  //typedef double TW;
109  //typedef unsigned int dim_t;
110  typedef unsigned int num_t;
111 
112  if(!a_mpi.sunpack(a_hd.m_title)) return false;
113  if(!a_mpi.unpack(a_hd.m_dimension)) return false; //dim_t
114  if(!a_mpi.unpack(a_hd.m_bin_number)) return false; //TO
115  if(!a_mpi.vunpack(a_hd.m_bin_entries)) return false; //TN
116  if(!a_mpi.vunpack(a_hd.m_bin_Sw)) return false; //TW
117  if(!a_mpi.vunpack(a_hd.m_bin_Sw2)) return false; //TW
118 
119  {a_hd.m_bin_Sxw.resize(a_hd.m_bin_number);
120  for(unsigned int ibin=0;ibin<a_hd.m_bin_number;ibin++) {
121  if(!a_mpi.vunpack(a_hd.m_bin_Sxw[ibin])) return false;
122  }}
123  {a_hd.m_bin_Sx2w.resize(a_hd.m_bin_number);
124  for(unsigned int ibin=0;ibin<a_hd.m_bin_number;ibin++) {
125  if(!a_mpi.vunpack(a_hd.m_bin_Sx2w[ibin])) return false;
126  }}
127 
128  // Axes :
129  {a_hd.m_axes.resize(a_hd.m_dimension);
130  for(unsigned int iaxis=0;iaxis<a_hd.m_dimension;iaxis++) {
131  if(!axis_dui_unpack(a_mpi,a_hd.m_axes[iaxis])) return false;
132  }}
133 
134  // etc :
135  if(!a_mpi.vunpack(a_hd.m_in_range_plane_Sxyw)) return false; //TC
136 
137  // Annotations :
138  {a_hd.m_annotations.clear();
139  num_t num;
140  if(!a_mpi.unpack(num)) return false;
141  for(unsigned int index=0;index<num;index++) {
142  std::string k,v;
143  if(!a_mpi.sunpack(k)) return false;
144  if(!a_mpi.sunpack(v)) return false;
145  a_hd.m_annotations[k] = v;
146  }}
147 
148  // fast getters :
149  if(!a_mpi.unpack(a_hd.m_all_entries)) return false; //TN
150  if(!a_mpi.unpack(a_hd.m_in_range_entries)) return false; //TN
151  if(!a_mpi.unpack(a_hd.m_in_range_Sw)) return false; //TW
152  if(!a_mpi.unpack(a_hd.m_in_range_Sw2)) return false; //TW
153  if(!a_mpi.vunpack(a_hd.m_in_range_Sxw)) return false; //TC
154  if(!a_mpi.vunpack(a_hd.m_in_range_Sx2w)) return false; //TC
155 
156  return true;
157 }

◆ is_out()

template<class TC , class TO >
bool tools::histo::is_out ( const std::vector< axis< TC, TO > > &  a_axes,
TO  a_offset 
)
inline

Definition at line 16 of file axes.

16  {
17  TO offset = a_offset;
18  int index;
19  typename std::vector< axis<TC,TO> >::size_type dimension = a_axes.size();
20  for(int iaxis=int(dimension)-1;iaxis>=0;iaxis--) {
21  index = int(offset/a_axes[iaxis].m_offset);
22  if(index==0) return true;
23  if(index==(int(a_axes[iaxis].m_number_of_bins)+1)) return true;
24  offset -= index * a_axes[iaxis].m_offset;
25  }
26  return false;
27 }

◆ key_axis_x_title()

const std::string& tools::histo::key_axis_x_title ( )
inline

Definition at line 653 of file base_histo.

653  {
654  static const std::string s_v("axis_x.title");
655  return s_v;
656 }

◆ key_axis_y_title()

const std::string& tools::histo::key_axis_y_title ( )
inline

Definition at line 657 of file base_histo.

657  {
658  static const std::string s_v("axis_y.title");
659  return s_v;
660 }

◆ key_axis_z_title()

const std::string& tools::histo::key_axis_z_title ( )
inline

Definition at line 661 of file base_histo.

661  {
662  static const std::string s_v("axis_z.title");
663  return s_v;
664 }

◆ profile_data_duiuidd_assign()

void tools::histo::profile_data_duiuidd_assign ( profile_data< double, unsigned int, unsigned int, double, double > &  a_pd,
const cprofile_duiuidd &  a_c 
)
inline

C struct to profile_data ////////////////////////////////////////////////.

Definition at line 322 of file htoc.

322  {
323  histo_data_duiuid_assign(a_pd,a_c.m_histo);
324  a_pd.m_is_profile = a_c.m_is_profile==1?true:false;
325  vec_assign(a_pd.m_bin_Svw,a_c.m_histo.m_bin_number,a_c.m_bin_Svw);
326  vec_assign(a_pd.m_bin_Sv2w,a_c.m_histo.m_bin_number,a_c.m_bin_Sv2w);
327  a_pd.m_cut_v = a_c.m_cut_v==1?true:false;
328  a_pd.m_min_v = a_c.m_min_v;
329  a_pd.m_max_v = a_c.m_max_v;
330 }

◆ profile_data_duiuidd_pack()

bool tools::histo::profile_data_duiuidd_pack ( impi &  a_mpi,
const profile_data< double, unsigned int, unsigned int, double, double > &  a_pd 
)
inline

profile_data to C struct ////////////////////////////////////////////////

Definition at line 170 of file hd2mpi.

170  {
171 
172  if(!histo_data_duiuid_pack(a_mpi,a_pd)) return false;
173 
174  //typedef double TV;
175 
176  if(!a_mpi.bpack(a_pd.m_is_profile)) return false;
177  if(!a_mpi.vpack(a_pd.m_bin_Svw)) return false; //TV
178  if(!a_mpi.vpack(a_pd.m_bin_Sv2w)) return false; //TV
179  if(!a_mpi.bpack(a_pd.m_cut_v)) return false;
180  if(!a_mpi.pack(a_pd.m_min_v)) return false; //TV
181  if(!a_mpi.pack(a_pd.m_max_v)) return false; //TV
182 
183  return true;
184 }

◆ profile_data_duiuidd_unpack()

bool tools::histo::profile_data_duiuidd_unpack ( impi &  a_mpi,
profile_data< double, unsigned int, unsigned int, double, double > &  a_pd 
)
inline

mpi to profile_data /////////////////////////////////////////////////////

Definition at line 190 of file hd2mpi.

190  {
191 
192  if(!histo_data_duiuid_unpack(a_mpi,a_pd)) return false;
193 
194  //typedef double TV;
195 
196  if(!a_mpi.bunpack(a_pd.m_is_profile)) return false;
197  if(!a_mpi.vunpack(a_pd.m_bin_Svw)) return false; //TV
198  if(!a_mpi.vunpack(a_pd.m_bin_Sv2w)) return false; //TV
199  if(!a_mpi.bunpack(a_pd.m_cut_v)) return false;
200  if(!a_mpi.unpack(a_pd.m_min_v)) return false; //TV
201  if(!a_mpi.unpack(a_pd.m_max_v)) return false; //TV
202 
203  return true;
204 }

◆ profile_x() [1/2]

p1d* tools::histo::profile_x ( const h2d &  a_from,
const std::string &  a_title 
)
inline

Definition at line 57 of file sliced.

57  {
58  return profile_x(a_from,axis_UNDERFLOW_BIN,axis_OVERFLOW_BIN,a_title);
59 }

◆ profile_x() [2/2]

p1d* tools::histo::profile_x ( const h2d &  a_from,
int  aJbeg,
int  aJend,
const std::string &  a_title 
)
inline

Definition at line 50 of file sliced.

50  {
51  p1d* slice_x = new p1d(a_title,
52  a_from.axis_x().bins(),a_from.axis_x().lower_edge(),a_from.axis_x().upper_edge());
53  if(!fill_profile_x(a_from,aJbeg,aJend,*slice_x)) {delete slice_x;return 0;}
54  return slice_x;
55 }

◆ profile_y() [1/2]

p1d* tools::histo::profile_y ( const h2d &  a_from,
const std::string &  a_title 
)
inline

Definition at line 68 of file sliced.

68  {
69  return profile_y(a_from,axis_UNDERFLOW_BIN,axis_OVERFLOW_BIN,a_title);
70 }

◆ profile_y() [2/2]

p1d* tools::histo::profile_y ( const h2d &  a_from,
int  aIbeg,
int  aIend,
const std::string &  a_title 
)
inline

Definition at line 61 of file sliced.

61  {
62  p1d* slice_y = new p1d(a_title,
63  a_from.axis_y().bins(),a_from.axis_y().lower_edge(),a_from.axis_y().upper_edge());
64  if(!fill_profile_y(a_from,aIbeg,aIend,*slice_y)) {delete slice_y;return 0;}
65  return slice_y;
66 }

◆ projection_x() [1/2]

template<class H2 , class H1 >
H1* tools::histo::projection_x ( const H2 &  a_from,
const std::string &  a_title 
)
inline

Definition at line 80 of file slice.

80  {
81  return slice_x(a_from,axis_UNDERFLOW_BIN,axis_OVERFLOW_BIN,a_title);
82 }

◆ projection_x() [2/2]

h1d* tools::histo::projection_x ( const h2d &  a_from,
const std::string &  a_title 
)
inline

Definition at line 25 of file sliced.

25  {
26  return slice_x(a_from,axis_UNDERFLOW_BIN,axis_OVERFLOW_BIN,a_title);
27 }

◆ projection_xy()

h2d* tools::histo::projection_xy ( const h3d &  a_from,
const std::string &  a_title 
)
inline

Definition at line 91 of file sliced.

91  {
92  return slice_xy(a_from,axis_UNDERFLOW_BIN,axis_OVERFLOW_BIN,a_title);
93 }

◆ projection_xz()

h2d* tools::histo::projection_xz ( const h3d &  a_from,
const std::string &  a_title 
)
inline

Definition at line 115 of file sliced.

115  {
116  return slice_xz(a_from,axis_UNDERFLOW_BIN,axis_OVERFLOW_BIN,a_title);
117 }

◆ projection_y() [1/2]

template<class H2 , class H1 >
H1* tools::histo::projection_y ( const H2 &  a_from,
const std::string &  a_title 
)
inline

Definition at line 148 of file slice.

148  {
149  return slice_y(a_from,axis_UNDERFLOW_BIN,axis_OVERFLOW_BIN,a_title);
150 }

◆ projection_y() [2/2]

h1d* tools::histo::projection_y ( const h2d &  a_from,
const std::string &  a_title 
)
inline

Definition at line 36 of file sliced.

36  {
37  return slice_y(a_from,axis_UNDERFLOW_BIN,axis_OVERFLOW_BIN,a_title);
38 }

◆ projection_yz()

h2d* tools::histo::projection_yz ( const h3d &  a_from,
const std::string &  a_title 
)
inline

Definition at line 103 of file sliced.

103  {
104  return slice_yz(a_from,axis_UNDERFLOW_BIN,axis_OVERFLOW_BIN,a_title);
105 }

◆ slice_x() [1/2]

template<class H2 , class H1 >
H1* tools::histo::slice_x ( const H2 &  a_from,
int  aJbeg,
int  aJend,
const std::string &  a_title 
)
inline

Definition at line 73 of file slice.

73  {
74  H1* slice = new H1(a_title,a_from.axis_x().bins(),a_from.axis_x().lower_edge(),a_from.axis_x().upper_edge());
75  if(!fill_slice_x(a_from,aJbeg,aJend,*slice)) {delete slice;return 0;}
76  return slice;
77 }

◆ slice_x() [2/2]

h1d* tools::histo::slice_x ( const h2d &  a_from,
int  aJbeg,
int  aJend,
const std::string &  a_title 
)
inline

Definition at line 18 of file sliced.

18  {
19  h1d* slice_x = new h1d(a_title,
20  a_from.axis_x().bins(),a_from.axis_x().lower_edge(),a_from.axis_x().upper_edge());
21  if(!fill_slice_x(a_from,aJbeg,aJend,*slice_x)) {delete slice_x;return 0;}
22  return slice_x;
23 }

◆ slice_xy() [1/2]

template<class H3 , class H2 >
H2* tools::histo::slice_xy ( const H3 &  a_from,
int  aKbeg,
int  aKend,
const std::string &  a_title 
)
inline

Definition at line 481 of file slice.

481  {
482  H2* slice = new H2(a_title,
483  a_from.axis_x().bins(),a_from.axis_x().lower_edge(),a_from.axis_x().upper_edge(),
484  a_from.axis_y().bins(),a_from.axis_y().lower_edge(),a_from.axis_y().upper_edge());
485  if(!fill_slice_xy(a_from,aKbeg,aKend,*slice)) {delete slice;return 0;}
486  return slice;
487 }

◆ slice_xy() [2/2]

h2d* tools::histo::slice_xy ( const h3d &  a_from,
int  aKbeg,
int  aKend,
const std::string &  a_title 
)
inline

Definition at line 83 of file sliced.

83  {
84  h2d* slice = new h2d(a_title,
85  a_from.axis_x().bins(),a_from.axis_x().lower_edge(),a_from.axis_x().upper_edge(),
86  a_from.axis_y().bins(),a_from.axis_y().lower_edge(),a_from.axis_y().upper_edge());
87  if(!fill_slice_xy(a_from,aKbeg,aKend,*slice)) {delete slice;return 0;}
88  return slice;
89 }

◆ slice_xz() [1/2]

template<class H3 , class H2 >
H2* tools::histo::slice_xz ( const H3 &  a_from,
int  aJbeg,
int  aJend,
const std::string &  a_title 
)
inline

Definition at line 499 of file slice.

499  {
500  H2* slice = new H2(a_title,
501  a_from.axis_x().bins(),a_from.axis_x().lower_edge(),a_from.axis_x().upper_edge(),
502  a_from.axis_z().bins(),a_from.axis_z().lower_edge(),a_from.axis_z().upper_edge());
503  if(!fill_slice_xz(a_from,aJbeg,aJend,*slice)) {delete slice;return 0;}
504  return slice;
505 }

◆ slice_xz() [2/2]

h2d* tools::histo::slice_xz ( const h3d &  a_from,
int  aJbeg,
int  aJend,
const std::string &  a_title 
)
inline

Definition at line 107 of file sliced.

107  {
108  h2d* slice = new h2d(a_title,
109  a_from.axis_x().bins(),a_from.axis_x().lower_edge(),a_from.axis_x().upper_edge(),
110  a_from.axis_z().bins(),a_from.axis_z().lower_edge(),a_from.axis_z().upper_edge());
111  if(!fill_slice_xz(a_from,aJbeg,aJend,*slice)) {delete slice;return 0;}
112  return slice;
113 }

◆ slice_y() [1/2]

template<class H2 , class H1 >
H1* tools::histo::slice_y ( const H2 &  a_from,
int  aIbeg,
int  aIend,
const std::string &  a_title 
)
inline

Definition at line 141 of file slice.

141  {
142  H1* slice = new H1(a_title,a_from.axis_y().bins(),a_from.axis_y().lower_edge(),a_from.axis_y().upper_edge());
143  if(!fill_slice_y(a_from,aIbeg,aIend,*slice)) {delete slice;return 0;}
144  return slice;
145 }

◆ slice_y() [2/2]

h1d* tools::histo::slice_y ( const h2d &  a_from,
int  aIbeg,
int  aIend,
const std::string &  a_title 
)
inline

Definition at line 29 of file sliced.

29  {
30  h1d* slice_y = new h1d(a_title,
31  a_from.axis_y().bins(),a_from.axis_y().lower_edge(),a_from.axis_y().upper_edge());
32  if(!fill_slice_y(a_from,aIbeg,aIend,*slice_y)) {delete slice_y;return 0;}
33  return slice_y;
34 }

◆ slice_yz() [1/2]

template<class H3 , class H2 >
H2* tools::histo::slice_yz ( const H3 &  a_from,
int  aIbeg,
int  aIend,
const std::string &  a_title 
)
inline

Definition at line 490 of file slice.

490  {
491  H2* slice = new H2(a_title,
492  a_from.axis_y().bins(),a_from.axis_y().lower_edge(),a_from.axis_y().upper_edge(),
493  a_from.axis_z().bins(),a_from.axis_z().lower_edge(),a_from.axis_z().upper_edge());
494  if(!fill_slice_yz(a_from,aIbeg,aIend,*slice)) {delete slice;return 0;}
495  return slice;
496 }

◆ slice_yz() [2/2]

h2d* tools::histo::slice_yz ( const h3d &  a_from,
int  aIbeg,
int  aIend,
const std::string &  a_title 
)
inline

Definition at line 95 of file sliced.

95  {
96  h2d* slice = new h2d(a_title,
97  a_from.axis_y().bins(),a_from.axis_y().lower_edge(),a_from.axis_y().upper_edge(),
98  a_from.axis_z().bins(),a_from.axis_z().lower_edge(),a_from.axis_z().upper_edge());
99  if(!fill_slice_yz(a_from,aIbeg,aIend,*slice)) {delete slice;return 0;}
100  return slice;
101 }

◆ vec_assign()

template<class T >
void tools::histo::vec_assign ( std::vector< T > &  a_v,
unsigned int  a_number,
const T *  a_c 
)
inline

C struct to hist_data ///////////////////////////////////////////////////.

Definition at line 217 of file htoc.

217  {
218  a_v.resize(a_number);
219  for(unsigned int i=0;i<a_number;i++) a_v[i] = a_c[i];
220 }
cprofile_duiuidd::m_bin_Sv2w
TV * m_bin_Sv2w
Definition: htoc:61
tools::histo::fill_slice_xz
bool fill_slice_xz(const H3 &a_from, int aJbeg, int aJend, H2 &a_to)
Definition: slice:414
cprofile_duiuidd::m_cut_v
unsigned char m_cut_v
Definition: htoc:62
tools::histo::axis::m_edges
std::vector< TC > m_edges
Definition: axis:272
tools::histo::slice_xy
h2d * slice_xy(const h3d &a_from, int aKbeg, int aKend, const std::string &a_title)
Definition: sliced:83
cprofile_duiuidd::m_min_v
TV m_min_v
Definition: htoc:63
tools::histo::histo_data::m_in_range_Sw2
TW m_in_range_Sw2
Definition: histo_data:189
chisto_duiuid::m_in_range_plane_Sxyw
TC * m_in_range_plane_Sxyw
Definition: htoc:42
cprofile_duiuidd
Definition: htoc:54
tools::histo::histo_data::m_annotations
std::map< std::string, std::string > m_annotations
Definition: histo_data:184
chisto_duiuid::m_number_of_annotations
unsigned int m_number_of_annotations
Definition: htoc:43
tools::histo::axis_dui_assign
void axis_dui_assign(axis< double, unsigned int > &a_axis, const caxis_dui &a_c)
Definition: htoc:222
tools::histo::axis::m_maximum_value
TC m_maximum_value
Definition: axis:267
tools::histo::axis::m_offset
TO m_offset
Definition: axis:264
tools::histo::slice_x
h1d * slice_x(const h2d &a_from, int aJbeg, int aJend, const std::string &a_title)
Definition: sliced:18
tools::histo::axis_UNDERFLOW_BIN
@ axis_UNDERFLOW_BIN
Definition: axis:13
tools::histo::histo_data::m_bin_Sx2w
std::vector< std::vector< TC > > m_bin_Sx2w
Definition: histo_data:179
chisto_duiuid::m_annotations
char ** m_annotations
Definition: htoc:44
tools::histo::histo_data::m_in_range_Sxw
std::vector< TC > m_in_range_Sxw
Definition: histo_data:190
tools::histo::vec_assign
void vec_assign(std::vector< T > &a_v, unsigned int a_number, const T *a_c)
C struct to hist_data ///////////////////////////////////////////////////.
Definition: htoc:217
chisto_duiuid::m_bin_Sw
TW * m_bin_Sw
Definition: htoc:35
chisto_duiuid::m_title
char * m_title
Definition: htoc:30
tools::vec_data
const T * vec_data(const std::vector< T > &a_vec)
Definition: vdata:18
chisto_duiuid::m_all_entries
TN m_all_entries
Definition: htoc:46
tools::histo::histo_data_duiuid_unpack
bool histo_data_duiuid_unpack(impi &a_mpi, histo_data< double, unsigned int, unsigned int, double > &a_hd)
Definition: hd2mpi:104
tools::cmem_free
void cmem_free(T *&a_p)
Definition: cmemT:16
tools::histo::histo_data::m_bin_entries
std::vector< TN > m_bin_entries
Definition: histo_data:175
tools::histo::chisto_duiuid_assign
void chisto_duiuid_assign(chisto_duiuid &a_c, const histo_data< double, unsigned int, unsigned int, double > &a_hd)
Definition: htoc:118
caxis_dui::m_minimum_value
TC m_minimum_value
Definition: htoc:14
chisto_duiuid::m_bin_Sw2
TW * m_bin_Sw2
Definition: htoc:36
caxis_dui::m_bin_width
TC m_bin_width
Definition: htoc:17
tools::histo::fill_profile_y
bool fill_profile_y(const H2 &a_from, int aIbeg, int aIend, P1 &a_to)
Definition: slice:216
tools::histo::fill_slice_yz
bool fill_slice_yz(const H3 &a_from, int aIbeg, int aIend, H2 &a_to)
h3 -> h2 ////////////////////////////////////////////////////////////////////
Definition: slice:279
tools::histo::histo_data::m_bin_Sw
std::vector< TW > m_bin_Sw
Definition: histo_data:176
chisto_duiuid::m_bin_Sxw
TC ** m_bin_Sxw
Definition: htoc:37
chisto_duiuid
Definition: htoc:22
tools::histo::histo_data_duiuid_pack
bool histo_data_duiuid_pack(impi &a_mpi, const histo_data< double, unsigned int, unsigned int, double > &a_hd)
Definition: hd2mpi:36
tools::histo::fill_slice_x
bool fill_slice_x(const H2 &a_from, int aJbeg, int aJend, H1 &a_to)
h2 -> h1 ////////////////////////////////////////////////////////////////////
Definition: slice:17
tools::histo::slice_y
h1d * slice_y(const h2d &a_from, int aIbeg, int aIend, const std::string &a_title)
Definition: sliced:29
chisto_duiuid::m_in_range_Sxw
TC * m_in_range_Sxw
Definition: htoc:50
tools::histo::fill_slice_xy
bool fill_slice_xy(const H3 &a_from, int aKbeg, int aKend, H2 &a_to)
Definition: slice:346
tools::histo::histo_data::m_in_range_entries
TN m_in_range_entries
Definition: histo_data:187
tools::histo::axis_OVERFLOW_BIN
@ axis_OVERFLOW_BIN
Definition: axis:13
tools::histo::axis::m_bin_width
TC m_bin_width
Definition: axis:270
tools::histo::histo_data::m_in_range_Sx2w
std::vector< TC > m_in_range_Sx2w
Definition: histo_data:191
tools::histo::histo_data::m_title
std::string m_title
Definition: histo_data:171
tools::histo::axis_dui_unpack
bool axis_dui_unpack(impi &a_mpi, axis< double, unsigned int > &a_axis)
mpi to hist_data ////////////////////////////////////////////////////////
Definition: hd2mpi:88
caxis_dui::m_offset
TO m_offset
Definition: htoc:12
tools::histo::dim_planes
unsigned int dim_planes(unsigned int a_dim)
Definition: histo_data:17
chisto_duiuid::m_axes
caxis_dui ** m_axes
Definition: htoc:40
caxis_dui::m_maximum_value
TC m_maximum_value
Definition: htoc:15
cprofile_duiuidd::m_max_v
TV m_max_v
Definition: htoc:64
tools::histo::fill_slice_y
bool fill_slice_y(const H2 &a_from, int aIbeg, int aIend, H1 &a_to)
Definition: slice:85
tools::histo::histo_data::m_bin_Sxw
std::vector< std::vector< TC > > m_bin_Sxw
Definition: histo_data:178
cprofile_duiuidd::m_bin_Svw
TV * m_bin_Svw
Definition: htoc:60
tools::histo::slice_y
H1 * slice_y(const H2 &a_from, int aIbeg, int aIend, const std::string &a_title)
Definition: slice:141
tools_vforit
#define tools_vforit(a__T, a__v, a__it)
Definition: forit:13
tools::histo::histo_data::m_axes
std::vector< axis_t > m_axes
Definition: histo_data:181
tools::histo::axis::m_minimum_value
TC m_minimum_value
Definition: axis:266
tools::histo::caxis_dui_free
void caxis_dui_free(caxis_dui *&a_cp)
Definition: htoc:101
chisto_duiuid::m_in_range_Sx2w
TC * m_in_range_Sx2w
Definition: htoc:51
tools_mforcit
#define tools_mforcit(a__K, a__V, a__m, a__it)
Definition: forit:49
tools::histo::axis::m_number_of_bins
bn_t m_number_of_bins
Definition: axis:265
tools::histo::histo_data::m_bin_Sw2
std::vector< TW > m_bin_Sw2
Definition: histo_data:177
tools::str_del
void str_del(char *&a_cstr)
Definition: cstr:66
tools::histo::histo_data::m_all_entries
TN m_all_entries
Definition: histo_data:186
tools::histo::histo_data::m_in_range_Sw
TW m_in_range_Sw
Definition: histo_data:188
tools::histo::chisto_duiuid_clear
void chisto_duiuid_clear(chisto_duiuid &a_c)
Definition: htoc:173
tools::str_dup
char * str_dup(const char *a_cstr)
Definition: cstr:30
chisto_duiuid::m_in_range_Sw2
TW m_in_range_Sw2
Definition: htoc:49
caxis_dui::m_number_of_edges
unsigned int m_number_of_edges
Definition: htoc:18
tools::histo::slice_xz
h2d * slice_xz(const h3d &a_from, int aJbeg, int aJend, const std::string &a_title)
Definition: sliced:107
caxis_dui::m_number_of_bins
bn_t m_number_of_bins
Definition: htoc:13
tools::histo::histo_data_duiuid_assign
void histo_data_duiuid_assign(histo_data< double, unsigned int, unsigned int, double > &a_hd, const chisto_duiuid &a_c)
Definition: htoc:232
chisto_duiuid::m_bin_entries
TN * m_bin_entries
Definition: htoc:34
cprofile_duiuidd::m_histo
chisto_duiuid m_histo
Definition: htoc:57
caxis_dui::m_edges
TC * m_edges
Definition: htoc:19
tools::histo::slice_yz
h2d * slice_yz(const h3d &a_from, int aIbeg, int aIend, const std::string &a_title)
Definition: sliced:95
tools::histo::slice_x
H1 * slice_x(const H2 &a_from, int aJbeg, int aJend, const std::string &a_title)
Definition: slice:73
tools::histo::histo_data::m_bin_number
TO m_bin_number
Definition: histo_data:174
tools::histo::axis_dui_pack
bool axis_dui_pack(impi &a_mpi, const axis< double, unsigned int > &a_axis)
hist_data to mpi ////////////////////////////////////////////////////////
Definition: hd2mpi:22
caxis_dui::m_fixed
unsigned char m_fixed
Definition: htoc:16
chisto_duiuid::m_in_range_entries
TN m_in_range_entries
Definition: htoc:47
cprofile_duiuidd::m_is_profile
unsigned char m_is_profile
Definition: htoc:59
tools::histo::axis::m_fixed
bool m_fixed
Definition: axis:268
tools::histo::histo_data::m_in_range_plane_Sxyw
std::vector< TC > m_in_range_plane_Sxyw
Definition: histo_data:183
tools::histo::histo_data::m_dimension
dim_t m_dimension
Definition: histo_data:172
tools::histo::profile_y
p1d * profile_y(const h2d &a_from, const std::string &a_title)
Definition: sliced:68
tools::histo::profile_x
p1d * profile_x(const h2d &a_from, const std::string &a_title)
Definition: sliced:57
chisto_duiuid::m_dimension
dim_t m_dimension
Definition: htoc:31
tools::histo::caxis_dui_alloc
caxis_dui * caxis_dui_alloc(const axis< double, unsigned int > &a_axis)
hist_data to C struct ///////////////////////////////////////////////////
Definition: htoc:81
chisto_duiuid::m_bin_Sx2w
TC ** m_bin_Sx2w
Definition: htoc:38
chisto_duiuid::m_bin_number
TO m_bin_number
Definition: htoc:33
tools::histo::fill_profile_x
bool fill_profile_x(const H2 &a_from, int aJbeg, int aJend, P1 &a_to)
h2 -> p1 ////////////////////////////////////////////////////////////////////
Definition: slice:157
caxis_dui
Definition: htoc:7
chisto_duiuid::m_in_range_Sw
TW m_in_range_Sw
Definition: htoc:48
Generated by doxygen 1.8.20