Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/externals/g4tools/include/tools/wroot/tree

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

  1 // Copyright (C) 2010, Guy Barrand. All rights reserved.
  2 // See the file tools.license for terms.
  3 
  4 #ifndef tools_wroot_tree
  5 #define tools_wroot_tree
  6 
  7 #include "itree"
  8 #include "iobject"
  9 #include "idir"
 10 
 11 #include "branch_element"
 12 #include "branch_object"
 13 
 14 namespace tools {
 15 namespace wroot {
 16 
 17 class tree : public virtual iobject, public virtual itree {
 18 #ifdef TOOLS_MEM
 19   static const std::string& s_class() {
 20     static const std::string s_v("tools::wroot::tree");
 21     return s_v;
 22   }
 23 #endif
 24 public: //iobject
 25   virtual const std::string& name() const {return m_name;}
 26   virtual const std::string& title() const {return m_title;}
 27   virtual const std::string& store_class_name() const {
 28     static const std::string s_v("TTree");
 29     return s_v;
 30   }
 31   virtual bool stream(buffer& a_buffer) const {
 32     unsigned int c;
 33     if(!a_buffer.write_version(5,c)) return false;
 34 
 35     if(!Named_stream(a_buffer,m_name,m_title)) return false;
 36 
 37     // Beurk.
 38     if(!AttLine_stream(a_buffer)) return false;
 39     if(!AttFill_stream(a_buffer)) return false;
 40     if(!AttMarker_stream(a_buffer)) return false;
 41 
 42     double fEntries = (double)m_entries;
 43     if(!a_buffer.write(fEntries)) return false;
 44 
 45     double fTotBytes = (double)m_tot_bytes;
 46     double fZipBytes = (double)m_zip_bytes;
 47     if(!a_buffer.write(fTotBytes)) return false;
 48     if(!a_buffer.write(fZipBytes)) return false;
 49     if(!a_buffer.write((double)0)) return false; //fSavedBytes
 50     if(!a_buffer.write((int)0)) return false;    //fTimerInterval
 51     if(!a_buffer.write((int)25)) return false;   //fScanField (25)
 52     if(!a_buffer.write((int)0)) return false;    //fUpdate
 53     if(!a_buffer.write((int)1000000000)) return false; //fMaxEntryLoop
 54     int fMaxVirtualSize = 0;
 55     int fAutoSave = 100000000;
 56     if(!a_buffer.write(fMaxVirtualSize)) return false;
 57     if(!a_buffer.write(fAutoSave)) return false;
 58     if(!a_buffer.write((int)1000000)) return false;    //fEstimate;
 59 
 60     if(!m_branches.stream(a_buffer)) return false;
 61 
 62    {obj_array<base_leaf> m_leaves;
 63     tools_vforcit(branch*,m_branches,itb) {
 64       const std::vector<base_leaf*>& leaves = (*itb)->leaves();
 65       tools_vforcit(base_leaf*,leaves,itl) {
 66         m_leaves.push_back(*itl); //WARNING : ownership touchy.
 67       }
 68     }
 69     if(!m_leaves.stream(a_buffer)) return false;
 70     m_leaves.clear();} //WARNING : important.
 71 
 72     // fIndexValues (TArrayD).
 73     if(!a_buffer.write_array(std::vector<double>())) return false; //TArrayD
 74     // fIndex (TArrayI).
 75     if(!a_buffer.write_array(std::vector<int>())) return false; //TArrayI
 76 
 77     if(!a_buffer.set_byte_count(c)) return false;
 78     return true;
 79   }
 80 public: //itree
 81   //virtual void add_tot_bytes(uint32 a_n) {m_tot_bytes += a_n;}
 82   //virtual void add_zip_bytes(uint32 a_n) {m_zip_bytes += a_n;}
 83   virtual idir& dir() {return m_dir;}
 84   virtual const idir& dir() const {return m_dir;}
 85 public:
 86   tree(idir& a_dir,const std::string& a_name,const std::string& a_title,bool a_managed = true)
 87   :m_dir(a_dir)
 88   ,m_out(a_dir.file().out())
 89   ,m_name(a_name)
 90   ,m_title(a_title)
 91   ,m_entries(0)
 92   ,m_tot_bytes(0)
 93   ,m_zip_bytes(0)
 94   {
 95 #ifdef TOOLS_MEM
 96     mem::increment(s_class().c_str());
 97 #endif
 98     if(a_managed) a_dir.append_object(this); //a_dir takes ownership of tree.
 99   }
100   virtual ~tree(){
101 #ifdef TOOLS_MEM
102     mem::decrement(s_class().c_str());
103 #endif
104   }
105 protected:
106   tree(const tree& a_from)
107   :iobject(a_from),itree(a_from)
108   ,m_dir(a_from.m_dir)
109   ,m_out(a_from.m_out)
110   {}
111   tree& operator=(const tree&){return *this;}
112 public:
113   std::ostream& out() const {return m_out;}
114   const std::vector<branch*>& branches() const {return m_branches;}
115   //uint64 tot_bytes() const {return m_tot_bytes;}
116   //uint64 zip_bytes() const {return m_zip_bytes;}
117   uint64 entries() const {return m_entries;}
118 
119   branch* create_branch(const std::string& a_name){
120     const ifile& _file = m_dir.file();
121     branch* br = new branch(m_out,_file.byte_swap(),_file.compression(),
122                             m_dir.seek_directory(),a_name,m_name,_file.verbose());
123     if(!br) return 0;
124     m_branches.push_back(br);
125     return br;
126   }
127 
128   ////////////////////////////////////////////////
129   /// ref : //////////////////////////////////////
130   ////////////////////////////////////////////////
131   template <class TYPE>
132   leaf_ref<TYPE>* create_leaf_ref(const std::string& a_name,const TYPE& a_ref){
133     branch* br = create_branch(a_name);
134     if(!br) return 0;
135     return br->create_leaf_ref<TYPE>(a_name,a_ref);
136   }
137 
138   leaf_string_ref* create_leaf_string_ref(const std::string& a_name,const std::string& a_ref){
139     branch* br = create_branch(a_name);
140     if(!br) return 0;
141     return br->create_leaf_string_ref(a_name,a_ref);
142   }
143 
144   template <class T>
145   leaf_element* create_std_vector_leaf_ref(const std::string& a_name,const std::vector<T>& a_ref){
146     const ifile& _file = m_dir.file();
147     std_vector_be_ref<T>* br = new std_vector_be_ref<T>(m_out,_file.byte_swap(),_file.compression(),
148                                                         m_dir.seek_directory(),a_name,m_name,a_ref,_file.verbose());
149     leaf_element* le = br->create_leaf_element(a_name);
150     m_branches.push_back(br);
151     return le;
152   }
153   ////////////////////////////////////////////////
154   ////////////////////////////////////////////////
155   ////////////////////////////////////////////////
156   template <class T>
157   std_vector_be_ref<T>* create_std_vector_be_ref(const std::string& a_name,const std::vector<T>& a_ref){
158     const ifile& _file = m_dir.file();
159     std_vector_be_ref<T>* br = new std_vector_be_ref<T>(m_out,_file.byte_swap(),_file.compression(),
160                                                         m_dir.seek_directory(),a_name,m_name,a_ref,_file.verbose());
161     m_branches.push_back(br);
162     return br;
163   }
164 
165   template <class T>
166   std_vector_be<T>* create_std_vector_be(const std::string& a_name,const std::vector<T>& a_def = std::vector<T>()){
167     const ifile& _file = m_dir.file();
168     std_vector_be<T>* br = new std_vector_be<T>(m_out,_file.byte_swap(),_file.compression(),
169                                                 m_dir.seek_directory(),a_name,m_name,a_def,_file.verbose());
170     m_branches.push_back(br);
171     return br;
172   }
173 
174   template <class T>
175   std_vector_be_pointer<T>* create_std_vector_be_pointer(const std::string& a_name,std::vector<T>* a_pointer){
176     const ifile& _file = m_dir.file();
177     std_vector_be_pointer<T>* br = new std_vector_be_pointer<T>(m_out,_file.byte_swap(),_file.compression(),
178                                                                 m_dir.seek_directory(),a_name,m_name,a_pointer,_file.verbose());
179     m_branches.push_back(br);
180     return br;
181   }
182 
183   template <class TYPE>
184   leaf<TYPE>* create_leaf(const std::string& a_name){
185     branch* br = create_branch(a_name);
186     if(!br) return 0;
187     return br->create_leaf<TYPE>(a_name);
188   }
189 
190   leaf_object* create_leaf(const std::string& a_name,const iobject& a_obj){
191     const ifile& _file = m_dir.file();
192     branch_object* br = new branch_object(m_out,_file.byte_swap(),_file.compression(),
193                                           m_dir.seek_directory(),a_name,m_name,_file.verbose());
194     m_branches.push_back(br);
195     return br->create_leaf(a_name,a_obj);
196   }
197 
198   bool fill(uint32& a_nbytes) {
199     // Fill all branches of a Tree :
200     //   This function loops on all the branches of this tree.
201     //   For each branch, it copies to the branch buffer (basket) the current
202     //   values of the leaves data types.
203     //   If a leaf is a simple data type, a simple conversion to a machine
204     //   independent format has to be done.
205     a_nbytes = 0;
206     tools_vforcit(branch*,m_branches,it) {
207       //FIXME if ((*it)->testBit(kDoNotProcess)) continue;
208       uint32 n,add_bytes,nout;
209       if(!(*it)->fill(m_dir.file(),n,add_bytes,nout)) {a_nbytes = 0;return false;}
210       a_nbytes += n;
211       m_tot_bytes += add_bytes;
212       m_zip_bytes += nout;
213     }
214 
215     m_entries++;
216 
217     //if (fTotBytes - fSavedBytes > fAutoSave) {
218     //  if(!autoSave()) return false;
219     //}
220 
221     return true;
222   }
223 
224   void reset() {
225     // Reset buffers and entries count in all branches/leaves
226     m_entries       = 0;
227     m_tot_bytes     = 0;
228     m_zip_bytes     = 0;
229   //fSavedBytes     = 0;
230   //fTotalBuffers   = 0;
231   //fChainOffset    = 0;
232    {tools_vforcit(branch*,m_branches,it) (*it)->reset();}
233   }
234 protected:
235   idir& m_dir;
236   std::ostream& m_out;
237   //Named
238   std::string m_name;
239   std::string m_title;
240 
241   obj_array<branch> m_branches;
242   uint64 m_entries;   // Number of entries
243   uint64 m_tot_bytes; // Total number of bytes in branches before compression
244   uint64 m_zip_bytes; // Total number of bytes in branches after compression
245 };
246 
247 }}
248 
249 #endif