Hall-D Software  alpha
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
DDANAEVIO_factory.cc
Go to the documentation of this file.
1 // $Id$
2 //
3 // File: DDANAEVIO_factory.cc
4 // Created: Mon Mar 15 09:08:37 EDT 2010
5 // Creator: wolin (on Linux stan.jlab.org 2.6.18-164.el5 x86_64)
6 //
7 //
8 //
9 // JANA factory plugin creates EVIO DOM tree from DANA objects
10 //
11 //
12 // Implements the following JANA command-line parameters:
13 //
14 // EVIO:DANAEVIO specify which objects to add to DOM tree, see below for defaults
15 // EVIO:DANADICT use custom XML tag/num dictionary instead of built-in version
16 // EVIO:WRITEOUT default file writeout is true, to turn off use -PEVIO::WRITEOUT=0
17 //
18 //
19 // To specify which objects to add to EVIO tree:
20 //
21 // Use comma-separated, case-insensitive list (best not to included embedded whitespace)
22 // Accepts "all", "none", "truth" and "hits", as well as individual DANA object names
23 // Use prefix "-" to invert selection, "+" also accepted
24 //
25 //
26 // Built-in dictionary can be found in dana_evio_dict.xml
27 //
28 //
29 //
30 // Elliott Wolin, 19-Jul-2010
31 //
32 //
33 //
34 // n.b. to get factory pointer in event processor
35 //
36 // DDANAEVIO_factory *f = dynamic_cast<DDANAEVIO_factory*>(eventLoop->GetFactory("DDANAEVIODOMTree"));
37 // if(f!=NULL) { ... }
38 //
39 //
40 //
41 // still to do:
42 // enable associated objects in DTOFRawHit when JANA fixed
43 // Add new objects when Paul M. is done
44 // optimize multi-threading
45 // add evio to external packages
46 // lock when changing map
47 
48 
49 #include <iostream>
50 #include <iomanip>
51 #include <map>
52 #include <set>
53 using namespace std;
54 
55 
56 
57 // DANA objects processed by DANAEVIO
58 static string danaObjs[] = {
59  "dmctrackhit",
60  "dbeamphoton",
61  "dmcthrown",
62  "dfcaltruthshower",
63  "dbcaltruthshower",
64  "dtoftruth",
65  "dsctruthhit",
66  "dmctrajectorypoint",
67  "dcdchit",
68  "dfdchit",
69  "dfcalhit",
70  "dtofrawhit",
71  "dschit",
72  "dtagmhit",
73  "dtaghhit",
74  "dtrackwirebased",
75  "dtracktimebased",
76  "dchargedtrack",
77  "dphoton",
78  "dcdctrackhit",
79  "dfdcpseudo",
80  "dvertex",
81  "dtrackcandidate",
82  "dbcalphoton",
83  "dfcalphoton",
84  "dchargedtruthmatch",
85  "dtofrawhitmc",
86  "dtofhit",
87  "dtofpoint",
88  "dbcalhit",
89  "dbcalshower",
90  "dfcalcluster",
91  "dfdccathodecluster",
92  "dfdcsegment",
93 };
94 
95 
96 
97 #include <expat.h>
98 
99 #include <JANA/JEventProcessor.h>
100 #include <JANA/JFactory_base.h>
101 #include <JANA/JApplication.h>
102 #include <JANA/JEventLoop.h>
103 using namespace jana;
104 
105 
106 #include "DANA/DApplication.h"
107 
108 #include "TRACKING/DMCThrown.h"
109 #include "TRACKING/DMCTrackHit.h"
110 #include "TRACKING/DTrackWireBased.h"
111 #include "TRACKING/DTrackTimeBased.h"
112 #include "TRACKING/DMCTrajectoryPoint.h"
113 #include "TRACKING/DTrackCandidate.h"
114 
115 #include "FCAL/DFCALTruthShower.h"
116 #include "FCAL/DFCALHit.h"
117 #include "FCAL/DFCALPhoton.h"
118 #include "FCAL/DFCALCluster.h"
119 
120 #include "BCAL/DBCALTruthShower.h"
121 #include "BCAL/DBCALPhoton.h"
122 #include "BCAL/DBCALGeometry.h"
123 #include "BCAL/DBCALHit.h"
124 #include "BCAL/DBCALShower.h"
125 
126 #include "TOF/DTOFTruth.h"
127 #include "TOF/DTOFRawHit.h"
128 #include "TOF/DTOFRawHitMC.h"
129 #include "TOF/DTOFHit.h"
130 #include "TOF/DTOFPoint.h"
131 
132 #include "CDC/DCDCHit.h"
133 
134 #include "FDC/DFDCHit.h"
135 #include "FDC/DFDCCathodeCluster.h"
136 #include "FDC/DFDCSegment.h"
137 
138 #include "PID/DBeamPhoton.h"
139 #include "PID/DPhoton.h"
140 #include "PID/DChargedTrack.h"
141 #include "PID/DChargedTruthMatch.h"
142 
143 #include "START_COUNTER/DSCHit.h"
144 #include "START_COUNTER/DSCTruthHit.h"
145 
146 #include "PID/DVertex.h"
147 
148 #include "TAGGER/DTAGMHit.h"
149 #include "TAGGER/DTAGHHit.h"
150 
151 #include "SplitString.h"
152 
153 
154 #include "evioFileChannel.hxx"
155 #include "evioUtil.hxx"
156 using namespace evio;
157 
158 
159 // for DANAEVIO
160 #include "danaevio/dana_evio_dict.h"
161 #include "danaevio/DDANAEVIO_factory.h"
162 
163 
164 // holds tag/num pairs for all DANA objects
165 static map< string, pair<uint16_t,uint8_t> > tagMap;
166 
167 
168 // for one-time initialization
169 static pthread_mutex_t initMutex = PTHREAD_MUTEX_INITIALIZER;
170 
171 
172 
173 //--------------------------------------------------------------------------------------
174 
175 
176 DDANAEVIO_factory::DDANAEVIO_factory() {
177 
178  static bool done_once_only = false;
179  static string danaevio = "";
180 
181 
182  // initialize evio hash map (insert empty set<string> into map for each danaObj)
183  for(unsigned int i=0; i<sizeof(danaObjs)/sizeof(danaObjs[0]); i++) {
184  evioMap[danaObjs[i]]=set<string>();
185  }
186 
187 
188  // get mutex and initialize, some stuff done once-only
189  pthread_mutex_lock(&initMutex);
190  if(!done_once_only) {
191  done_once_only=true;
192 
193  // get danaevio command line parameter
194  gPARMS->SetDefaultParameter("EVIO:DANAEVIO",danaevio);
195 
196  // parse tag/num file (using EVIO:DANADICT parameter) our use default string to get tag/num pairs
197  get_tagNum_dictionary();
198 
199  // fill evioMap based on EVIO:DANAEVIO parameter
200  setEVIOMap(danaevio);
201 
202 
203  // print factory/tag selection flags
204  map<string, set<string> >::iterator iter1;
205  set<string>::iterator iter2;
206  jout << endl << endl << endl << " DANA object output flags:" << endl << endl;
207  for(iter1=evioMap.begin(); iter1!=evioMap.end(); iter1++) {
208  jout << " " << setiosflags(ios::left) << setw(20) << iter1->first+":";
209  if(iter1->second.size()>0) {
210  for(iter2=iter1->second.begin(); iter2!=iter1->second.end(); iter2++) {
211  jout << setw(20) << string(((*iter2).size()>0)?(*iter2):("untagged")) << string(" ");
212  }
213  } else {
214  jout << setw(20) << "(not selected)";
215  }
216  jout << endl;
217  }
218  jout << endl << endl<< endl;
219 
220  } else {
221 
222  // just fill evioMap based on EVIO:DANAEVIO parameter
223  setEVIOMap(danaevio);
224 
225  }
226  pthread_mutex_unlock(&initMutex);
227 
228 }
229 
230 
231 //----------------------------------------------------------------------------
232 
233 
234 void DDANAEVIO_factory::setEVIOMap(string danaevio) {
235 
236 
237  // decodes danaevio string and fills map
238 
239  // parameters are comma-separated and case-insensitive
240  // "-" means invert
241  // "+" is ignored
242  // also supported: "all", "none", "truth" "hits", "tracks"
243  // otherwise parameter must be the name/tag of a DANA object that is processed by this program
244 
245  // append factory tag to object with ":" to specify tagged factory, e.g. "DBCALShower:myTag"
246 
247  // NOTE: factory tag names are case sensitive
248 
249 
250  if(danaevio==NULL)return;
251  if(danaevio.size()<=0)return;
252 
253 
254  map< string, set<string> >::iterator iter;
255  vector<string> params;
256  SplitString<string>(danaevio,params,",");
257  for(unsigned int i=0; i<params.size(); i++) {
258 
259  vector<string> paramsCS(params); // factory tags are Case Sensitive
260  std::transform(params[i].begin(), params[i].end(), params[i].begin(), (int(*)(int)) tolower);
261  bool plus=(params[i][0]=='+');
262  bool minus=(params[i][0]=='-');
263 
264  string value = params[i].substr((plus||minus)?1:0);
265  string valueCS = paramsCS[i].substr((plus||minus)?1:0);
266 
267 
268  if(value=="all") {
269  for(iter=evioMap.begin(); iter!=evioMap.end(); iter++) if(!minus) iter->second.insert(""); else iter->second.erase("");
270 
271  } else if(value=="none") {
272  for(iter=evioMap.begin(); iter!=evioMap.end(); iter++) if(minus) iter->second.insert(""); else iter->second.erase("");
273  } else if(value=="truth") {
274  if(!minus) evioMap["dbeamphoton"].insert(""); else evioMap["dbeamphoton"].erase("");
275  if(!minus) evioMap["dmcthrown"].insert(""); else evioMap["dmcthrown"].erase("");
276  if(!minus) evioMap["dmctrackhit"].insert(""); else evioMap["dmctrackhit"].erase("");
277  if(!minus) evioMap["dfcaltruthshower"].insert(""); else evioMap["dfcaltruthshower"].erase("");
278  if(!minus) evioMap["dbcaltruthshower"].insert(""); else evioMap["dbcaltruthshower"].erase("");
279  if(!minus) evioMap["dtoftruth"].insert(""); else evioMap["dtoftruth"].erase("");
280  if(!minus) evioMap["dsctruth"].insert(""); else evioMap["dsctruth"].erase("");
281  if(!minus) evioMap["dtofrawhitmc"].insert(""); else evioMap["dtofrawhitmc"].erase("");
282 
283 
284  } else if(value=="hits") {
285  if(!minus) evioMap["dcdchit"].insert(""); else evioMap["dcdchit"].erase("");
286  if(!minus) evioMap["dfdchit"].insert(""); else evioMap["dfdchit"].erase("");
287  if(!minus) evioMap["dfcalhit"].insert(""); else evioMap["dfcalhit"].erase("");
288  if(!minus) evioMap["dbcalhit"].insert(""); else evioMap["dbcalhit"].erase("");
289  if(!minus) evioMap["dschit"].insert(""); else evioMap["dschit"].erase("");
290  if(!minus) evioMap["dtofrawhit"].insert(""); else evioMap["dtofrawhit"].erase("");
291 
292  } else if(value=="tracks") {
293  if(!minus) evioMap["dtrackwirebased"].insert(""); else evioMap["dtrackwirebased"].erase("");
294  if(!minus) evioMap["dtracktimebased"].insert(""); else evioMap["dtracktimebased"].erase("");
295  if(!minus) evioMap["dchargedtrack"].insert(""); else evioMap["dchargedtrack"].erase("");
296  if(!minus) evioMap["dphoton"].insert(""); else evioMap["dphoton"].erase("");
297  if(!minus) evioMap["dcdctrackhit"].insert(""); else evioMap["dcdctrackhit"].erase("");
298  if(!minus) evioMap["dfdcpseudo"].insert(""); else evioMap["dfdcpseudo"].erase("");
299 
300  } else {
301 
302  string::size_type colon = value.find(":");
303  string name = value;
304  string tag = "";
305  if(colon!=string::npos) {
306  name = value.substr(0,colon);
307  tag = valueCS.substr(colon+1);
308  }
309 
310  map< string, set<string> >::iterator found = evioMap.find(name);
311  if(found!=evioMap.end()) {
312  if(!minus)found->second.insert(tag); else found->second.erase(tag);
313  } else {
314  jerr << endl << " ?unknown DANAEVIO parameter: " << params[i] << endl;
315  }
316 
317  }
318  }
319 }
320 
321 
322 //----------------------------------------------------------------------------
323 
324 
325 void DDANAEVIO_factory::get_tagNum_dictionary(void) {
326 
327 
328  // init string parser
329  XML_Parser xmlParser = XML_ParserCreate(NULL);
330  XML_SetElementHandler(xmlParser,startElement,NULL);
331 
332 
333  // set defaults by parsing internal string
334  if(XML_Parse(xmlParser,dana_evio_dict_String.c_str(),dana_evio_dict_String.size(),true)!=0) {
335  jout << endl << endl << " Successfully loaded default tag/num dictionary" << endl << endl << endl;
336  } else {
337  jerr << endl << endl << endl << " ?get_tagNum_dictionary...parse error for default string"
338  << endl << endl << " " << XML_ErrorString(XML_GetErrorCode(xmlParser))
339  << endl << endl << endl;
340  }
341  XML_ParserFree(xmlParser);
342 
343 
344  // parse user-supplied dictionary file if specified
345  string danadict = "";
346  gPARMS->SetDefaultParameter("EVIO:DANADICT",danadict);
347  if(danadict!="") {
348 
349  const int bufSize = 10000;
350  char buf[bufSize];
351 
352  // init file parser
353  XML_Parser xmlParser2 = XML_ParserCreate(NULL);
354  XML_SetElementHandler(xmlParser2,startElement,NULL);
355 
356  // open dictionary file
357  FILE *f = fopen(danadict.c_str(),"r");
358  if(f!=NULL) {
359 
360  int status,len;
361  bool done;
362  do {
363  len = fread(buf,1,bufSize,f);
364  done = len!=bufSize;
365  status=XML_Parse(xmlParser2,buf,len,done);
366  if((!done)&&(status==0)) {
367  jerr << endl << endl << endl << " ?read_custom_dictionary...parseXMLFile parse error for " << danadict
368  << endl << endl << XML_ErrorString(XML_GetErrorCode(xmlParser2))
369  << endl << endl << endl;
370  fclose(f);
371  XML_ParserFree(xmlParser2);
372  return;
373  }
374  } while (!done);
375  fclose(f);
376 
377  } else {
378  jerr << endl << endl << endl << " ?Unable to read custom tag/num dictionary: " << danadict
379  << endl << endl << endl;
380  XML_ParserFree(xmlParser2);
381  return;
382  }
383 
384  // successfully parsed dictionary file
385  jout << endl << endl << " Using custom tag/num dictionary: " << danadict << endl << endl << endl;
386  XML_ParserFree(xmlParser2);
387 
388  }
389 
390 }
391 
392 
393 //----------------------------------------------------------------------------
394 
395 
396 void DDANAEVIO_factory::startElement(void *userData, const char *xmlname, const char **atts) {
397 
398 
399  // only process dictionary entries
400  if( (strcasecmp(xmlname,"xmldumpDictEntry")!=0) &&
401  (strcasecmp(xmlname,"evioDictEntry")!=0) &&
402  (strcasecmp(xmlname,"danaevioDictEntry")!=0)
403  ) return;
404 
405 
406  string name = "";
407  int tag = 0;
408  int num = 0;
409  for (int i=0; atts[i]; i+=2) {
410  if(strcasecmp(atts[i],"name")==0) {
411  name = string(atts[i+1]);
412  } else if(strcasecmp(atts[i],"tag")==0) {
413  tag = atoi(atts[i+1]);
414  } else if(strcasecmp(atts[i],"num")==0) {
415  num = atoi(atts[i+1]);
416  }
417  }
418 
419  // add pair to dictionary
420  tagMap[name]=pair<uint16_t,uint8_t>(tag,num);
421 }
422 
423 
424 //--------------------------------------------------------------------------
425 
426 
427 const map< string, pair<uint16_t,uint8_t> > *DDANAEVIO_factory::getTagMapPointer() {
428  return(&tagMap);
429 }
430 
431 
432 //--------------------------------------------------------------------------
433 
434 
435 jerror_t DDANAEVIO_factory::evnt(JEventLoop *loop, uint64_t eventnumber) {
436 
437 
438 
439  // clear global object id map
440  objIdMap.clear();
441 
442 
443  // create single evio tree object and add to factory vector (may create more than one tree in the future)
444  pair<uint16_t,uint8_t> p = tagMap["DanaEvent"];
445  DDANAEVIODOMTree *myDDANAEVIODOMTree = new DDANAEVIODOMTree(p.first,p.second);
446  _data.push_back(myDDANAEVIODOMTree);
447 
448 
449  // add selected DANA banks to event tree
450  if(evioMap["dmctrackhit" ].size()>0) addDMCTrackHit( eventLoop, myDDANAEVIODOMTree->tree);
451  if(evioMap["dbeamphoton" ].size()>0) addDBeamPhoton( eventLoop, myDDANAEVIODOMTree->tree);
452  if(evioMap["dmcthrown" ].size()>0) addDMCThrown( eventLoop, myDDANAEVIODOMTree->tree);
453  if(evioMap["dfcaltruthshower" ].size()>0) addDFCALTruthShower( eventLoop, myDDANAEVIODOMTree->tree);
454  if(evioMap["dbcaltruthshower" ].size()>0) addDBCALTruthShower( eventLoop, myDDANAEVIODOMTree->tree);
455  if(evioMap["dtoftruth" ].size()>0) addDTOFTruth( eventLoop, myDDANAEVIODOMTree->tree);
456  if(evioMap["dsctruthhit" ].size()>0) addDSCTruthHit( eventLoop, myDDANAEVIODOMTree->tree);
457  if(evioMap["dmctrajectorypoint" ].size()>0) addDMCTrajectoryPoint( eventLoop, myDDANAEVIODOMTree->tree);
458 
459  if(evioMap["dcdchit" ].size()>0) addDCDCHit( eventLoop, myDDANAEVIODOMTree->tree);
460  if(evioMap["dfdchit" ].size()>0) addDFDCHit( eventLoop, myDDANAEVIODOMTree->tree);
461  if(evioMap["dbcalhit" ].size()>0) addDBCALHit( eventLoop, myDDANAEVIODOMTree->tree);
462  if(evioMap["dfcalhit" ].size()>0) addDFCALHit( eventLoop, myDDANAEVIODOMTree->tree);
463  if(evioMap["dtofrawhitmc" ].size()>0) addDTOFRawHitMC( eventLoop, myDDANAEVIODOMTree->tree);
464  if(evioMap["dschit" ].size()>0) addDSCHit( eventLoop, myDDANAEVIODOMTree->tree);
465  if(evioMap["dtagmhit" ].size()>0) addDTAGMHit( eventLoop, myDDANAEVIODOMTree->tree);
466  if(evioMap["dtaghhit" ].size()>0) addDTAGHHit( eventLoop, myDDANAEVIODOMTree->tree);
467 
468  if(evioMap["dcdctrackhit" ].size()>0) addDCDCTrackHit( eventLoop, myDDANAEVIODOMTree->tree);
469  if(evioMap["dfdcpseudo" ].size()>0) addDFDCPseudo( eventLoop, myDDANAEVIODOMTree->tree);
470  if(evioMap["dtrackwirebased" ].size()>0) addDTrackWireBased( eventLoop, myDDANAEVIODOMTree->tree);
471  if(evioMap["dtracktimebased" ].size()>0) addDTrackTimeBased( eventLoop, myDDANAEVIODOMTree->tree);
472  if(evioMap["dchargedtrack" ].size()>0) addDChargedTrack( eventLoop, myDDANAEVIODOMTree->tree);
473  if(evioMap["dphoton" ].size()>0) addDPhoton( eventLoop, myDDANAEVIODOMTree->tree);
474  if(evioMap["dvertex" ].size()>0) addDVertex( eventLoop, myDDANAEVIODOMTree->tree);
475  if(evioMap["dtrackcandidate" ].size()>0) addDTrackCandidate( eventLoop, myDDANAEVIODOMTree->tree);
476  if(evioMap["dbcalphoton" ].size()>0) addDBCALPhoton( eventLoop, myDDANAEVIODOMTree->tree);
477  if(evioMap["dfcalphoton" ].size()>0) addDFCALPhoton( eventLoop, myDDANAEVIODOMTree->tree);
478  if(evioMap["dchargedtruthmatch" ].size()>0) addDChargedTruthMatch( eventLoop, myDDANAEVIODOMTree->tree);
479  if(evioMap["dtofrawhit" ].size()>0) addDTOFRawHit( eventLoop, myDDANAEVIODOMTree->tree);
480  if(evioMap["dtofhit" ].size()>0) addDTOFHit( eventLoop, myDDANAEVIODOMTree->tree);
481  if(evioMap["dtofpoint" ].size()>0) addDTOFPoint( eventLoop, myDDANAEVIODOMTree->tree);
482  if(evioMap["dbcalshower" ].size()>0) addDBCALShower( eventLoop, myDDANAEVIODOMTree->tree);
483  if(evioMap["dfcalcluster" ].size()>0) addDFCALCluster( eventLoop, myDDANAEVIODOMTree->tree);
484  if(evioMap["dfdccathodecluster" ].size()>0) addDFDCCathodeCluster( eventLoop, myDDANAEVIODOMTree->tree);
485  if(evioMap["dfdcsegment" ].size()>0) addDFDCSegment( eventLoop, myDDANAEVIODOMTree->tree);
486  // if(evioMap["dtwogammafit" ].size()>0) addDTwoGammaFit( eventLoop, myDDANAEVIODOMTree->tree);
487 
488 
489  // add global object id bank
490  addObjIdBank(myDDANAEVIODOMTree->tree);
491 
492 
493  return NOERROR;
494 }
495 
496 
497 //--------------------------------------------------------------------------------------
498 
499 
500  template<typename T> evioDOMNodeP DDANAEVIO_factory::createLeafNode(string nameId) {
501  pair<uint16_t,uint8_t> p = tagMap[nameId];;
502  return(evioDOMNode::createEvioDOMNode<T>(p.first,p.second));
503  }
504 
505 
506 //--------------------------------------------------------------------------------------
507 
508 
509  // might as well put this here...
510  evioDOMNodeP DDANAEVIO_factory::createContainerNode(string nameId) {
511  pair<uint16_t,uint8_t> p = tagMap[nameId];;
512  return(evioDOMNode::createEvioDOMNode(p.first,p.second));
513  }
514 
515 
516 //--------------------------------------------------------------------------------------
517 
518 
519 void DDANAEVIO_factory::addObjIdBank(evioDOMTree &tree) {
520 
521 
522  // create objIdBank and add to event tree
523  evioDOMNodeP objIdBank = createContainerNode("objIdBank");
524  tree << objIdBank;
525 
526 
527  // create data banks and add to objIdBank
528  evioDOMNodeP idBank = createLeafNode<uint64_t> ("objIdBank.id");
529  evioDOMNodeP nameTagBank = createLeafNode<string> ("objIdBank.nameTag");
530  *objIdBank << idBank << nameTagBank;
531 
532 
533  // add collected id's and name/tags to data banks
534  map<int,string>::iterator iter;
535  for(iter=objIdMap.begin(); iter!=objIdMap.end(); iter++) {
536  *idBank << iter->first;
537  *nameTagBank << iter->second;
538  }
539 
540 }
541 
542 
543 //------------------------------------------------------------------------------
544 
545 
546 void DDANAEVIO_factory::addDMCThrown(JEventLoop *eventLoop, evioDOMTree &tree) {
547 
548 
549  // create mcthrown bank and add to event tree
550  evioDOMNodeP mcthrown = createContainerNode("DMCThrown");
551  tree << mcthrown;
552 
553 
554  // create data banks and add to mcthrown
555  evioDOMNodeP objIdBank = createLeafNode<uint64_t> ("DMCThrown.objId");
556  evioDOMNodeP typeBank = createLeafNode<int> ("DMCThrown.type");
557  evioDOMNodeP pdgtypeBank = createLeafNode<int> ("DMCThrown.pdgtype");
558  evioDOMNodeP myidBank = createLeafNode<int> ("DMCThrown.myid");
559  evioDOMNodeP parentidBank = createLeafNode<int> ("DMCThrown.parentid");
560  evioDOMNodeP mechBank = createLeafNode<int> ("DMCThrown.mech");
561  evioDOMNodeP xBank = createLeafNode<float> ("DMCThrown.x");
562  evioDOMNodeP yBank = createLeafNode<float> ("DMCThrown.y");
563  evioDOMNodeP zBank = createLeafNode<float> ("DMCThrown.z");
564  evioDOMNodeP pxBank = createLeafNode<float> ("DMCThrown.px");
565  evioDOMNodeP pyBank = createLeafNode<float> ("DMCThrown.py");
566  evioDOMNodeP pzBank = createLeafNode<float> ("DMCThrown.pz");
567  evioDOMNodeP energyBank = createLeafNode<float> ("DMCThrown.energy");
568  *mcthrown << objIdBank << typeBank << pdgtypeBank << myidBank << parentidBank << mechBank
569  << xBank << yBank << zBank << pxBank << pyBank << pzBank << energyBank;
570 
571 
572  // create associated object bank and add to main bank
573  evioDOMNodeP assocBank = createContainerNode("DMCThrown.assocObjectBanks");
574  *mcthrown << assocBank;
575 
576 
577  // loop over each requested factory, add data to banks
578  int assocCount = 0;
579  set<string>::iterator iter;
580  for(iter=evioMap["dmcthrown"].begin(); iter!=evioMap["dmcthrown"].end(); iter++) {
581 
582  vector<const DMCThrown*> mcthrowns;
583  eventLoop->Get(mcthrowns,(*iter).c_str());
584  if(mcthrowns.size()<=0)continue;
585 
586 
587  // add track data to banks
588  for(unsigned int i=0; i<mcthrowns.size(); i++) {
589  *objIdBank << mcthrowns[i]->id;
590  *typeBank << mcthrowns[i]->type;
591  *pdgtypeBank << mcthrowns[i]->pdgtype;
592  *myidBank << mcthrowns[i]->myid;
593  *parentidBank << mcthrowns[i]->parentid;
594  *mechBank << mcthrowns[i]->mech;
595 
596  DVector3 pos = mcthrowns[i]->position();
597  *xBank << pos.X();
598  *yBank << pos.Y();
599  *zBank << pos.Z();
600 
601  DVector3 mom = mcthrowns[i]->momentum();
602  *pxBank << mom.X();
603  *pyBank << mom.Y();
604  *pzBank << mom.Z();
605 
606  *energyBank << mcthrowns[i]->energy();
607 
608  objIdMap[mcthrowns[i]->id]=mcthrowns[i]->GetNameTag();
609 
610 
611  // get associated object id bank and add to associated object bank
612  evioDOMNodeP assocObjs = createLeafNode<uint64_t> ("DMCThrown.assocObjects");
613  *assocBank << assocObjs;
614 
615  // get id's, add to id bank and to global object id map
616  vector<const JObject*> objs;
617  mcthrowns[i]->GetT(objs);
618  for(unsigned int j=0; j<objs.size(); j++) {
619  assocCount++;
620  *assocObjs << objs[j]->id;
621  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
622  }
623  }
624  }
625  if(assocCount==0)assocBank->cutAndDelete();
626 
627 }
628 
629 
630 //------------------------------------------------------------------------------
631 
632 
633 void DDANAEVIO_factory::addDMCTrackHit(JEventLoop *eventLoop, evioDOMTree &tree) {
634 
635 
636  // create mctrackhit bank and add to event tree
637  evioDOMNodeP mctrackhit = createContainerNode("DMCTrackHit");
638  tree << mctrackhit;
639 
640 
641  // create data banks and add to mctrackhit bank
642  evioDOMNodeP objIdBank = createLeafNode<uint64_t> ("DMCTrackHit.objId");
643  evioDOMNodeP rBank = createLeafNode<float> ("DMCTrackHit.r");
644  evioDOMNodeP phiBank = createLeafNode<float> ("DMCTrackHit.phi");
645  evioDOMNodeP zBank = createLeafNode<float> ("DMCTrackHit.z");
646  evioDOMNodeP trackBank = createLeafNode<int> ("DMCTrackHit.track");
647  evioDOMNodeP primaryBank = createLeafNode<int> ("DMCTrackHit.primary");
648  evioDOMNodeP ptypeBank = createLeafNode<int> ("DMCTrackHit.ptype");
649  evioDOMNodeP systemBank = createLeafNode<int> ("DMCTrackHit.system");
650  *mctrackhit << objIdBank << rBank << phiBank << zBank << trackBank << primaryBank
651  << ptypeBank << systemBank;
652 
653 
654  // create associated object bank and add to main bank
655  evioDOMNodeP assocBank = createContainerNode("DMCTrackHit.assocObjectBanks");
656  *mctrackhit << assocBank;
657 
658 
659  // loop over each requested factory
660  int assocCount = 0;
661  set<string>::iterator iter;
662  for(iter=evioMap["dmctrackhit"].begin(); iter!=evioMap["dmctrackhit"].end(); iter++) {
663 
664  // is there any data
665  vector<const DMCTrackHit*> mctrackhits;
666  eventLoop->Get(mctrackhits,(*iter).c_str());
667  if(mctrackhits.size()<=0)continue;
668 
669 
670  // add track data to banks
671  for(unsigned int i=0; i<mctrackhits.size(); i++) {
672  *objIdBank << mctrackhits[i]->id;
673  *rBank << mctrackhits[i]->r;
674  *phiBank << mctrackhits[i]->phi;
675  *zBank << mctrackhits[i]->z;
676  *trackBank << mctrackhits[i]->track;
677  *primaryBank << mctrackhits[i]->primary;
678  *ptypeBank << mctrackhits[i]->ptype;
679  *systemBank << mctrackhits[i]->system;
680 
681  objIdMap[mctrackhits[i]->id]=mctrackhits[i]->GetNameTag();
682 
683 
684  // get associated object id bank and add to associated object bank
685  evioDOMNodeP assocObjs = createLeafNode<uint64_t> ("DMCTrackHit.assocObjects");
686  *assocBank << assocObjs;
687 
688  // get id's, add to id bank and to global object id map
689  vector<const JObject*> objs;
690  mctrackhits[i]->GetT(objs);
691  for(unsigned int j=0; j<objs.size(); j++) {
692  assocCount++;
693  *assocObjs << objs[j]->id;
694  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
695  }
696  }
697  }
698  if(assocCount==0)assocBank->cutAndDelete();
699 
700 }
701 
702 
703 //------------------------------------------------------------------------------
704 
705 
706 void DDANAEVIO_factory::addDTOFTruth(JEventLoop *eventLoop, evioDOMTree &tree) {
707 
708 
709  // create toftruth bank and add to event tree
710  evioDOMNodeP toftruth = createContainerNode("DTOFTruth");
711  tree << toftruth;
712 
713 
714  // create data banks and add to toftruth bank
715  evioDOMNodeP objIdBank = createLeafNode<uint64_t> ("DTOFTruth.objId");
716  evioDOMNodeP trackBank = createLeafNode<int> ("DTOFTruth.track");
717  evioDOMNodeP primaryBank = createLeafNode<int> ("DTOFTruth.primary");
718  evioDOMNodeP xBank = createLeafNode<float> ("DTOFTruth.x");
719  evioDOMNodeP yBank = createLeafNode<float> ("DTOFTruth.y");
720  evioDOMNodeP zBank = createLeafNode<float> ("DTOFTruth.z");
721  evioDOMNodeP pxBank = createLeafNode<float> ("DTOFTruth.px");
722  evioDOMNodeP pyBank = createLeafNode<float> ("DTOFTruth.py");
723  evioDOMNodeP pzBank = createLeafNode<float> ("DTOFTruth.pz");
724  evioDOMNodeP tBank = createLeafNode<float> ("DTOFTruth.t");
725  evioDOMNodeP EBank = createLeafNode<float> ("DTOFTruth.E");
726  evioDOMNodeP ptypeBank = createLeafNode<int> ("DTOFTruth.ptype");
727  *toftruth << objIdBank << trackBank << primaryBank << xBank << yBank << zBank
728  << pxBank << pyBank << pzBank << tBank << EBank << ptypeBank;
729 
730 
731  // create associated object bank and add to main bank
732  evioDOMNodeP assocBank = createContainerNode("DTOFTruth.assocObjectBanks");
733  *toftruth << assocBank;
734 
735 
736  // loop over each requested factory
737  int assocCount = 0;
738  set<string>::iterator iter;
739  for(iter=evioMap["dtoftruth"].begin(); iter!=evioMap["dtoftruth"].end(); iter++) {
740 
741  // is there any data
742  vector<const DTOFTruth*> toftruths;
743  eventLoop->Get(toftruths,(*iter).c_str());
744  if(toftruths.size()<=0)continue;
745 
746 
747  // add track data to banks
748  for(unsigned int i=0; i<toftruths.size(); i++) {
749  *objIdBank << toftruths[i]->id;
750  *trackBank << toftruths[i]->track;
751  *primaryBank << toftruths[i]->primary;
752  *xBank << toftruths[i]->x;
753  *yBank << toftruths[i]->y;
754  *zBank << toftruths[i]->z;
755  *pxBank << toftruths[i]->px;
756  *pyBank << toftruths[i]->py;
757  *pzBank << toftruths[i]->pz;
758  *tBank << toftruths[i]->t;
759  *EBank << toftruths[i]->E;
760  *ptypeBank << toftruths[i]->ptype;
761 
762  objIdMap[toftruths[i]->id]=toftruths[i]->GetNameTag();
763 
764 
765  // get associated object id bank and add to associated object bank
766  evioDOMNodeP assocObjs = createLeafNode<uint64_t> ("DTOFTruth.assocObjects");
767  *assocBank << assocObjs;
768 
769  // get id's, add to id bank and to global object id map
770  vector<const JObject*> objs;
771  toftruths[i]->GetT(objs);
772  for(unsigned int j=0; j<objs.size(); j++) {
773  assocCount++;
774  *assocObjs << objs[j]->id;
775  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
776  }
777  }
778  }
779  if(assocCount==0)assocBank->cutAndDelete();
780 
781 }
782 
783 
784 //------------------------------------------------------------------------------
785 
786 
787 
788 void DDANAEVIO_factory::addDFCALTruthShower(JEventLoop *eventLoop, evioDOMTree &tree) {
789 
790 
791  // create fcaltruthshower bank and add to event tree
792  evioDOMNodeP fcaltruthshower = createContainerNode("DFCALTruthShower");
793  tree << fcaltruthshower;
794 
795 
796  // create data banks and add to fcaltruthshower
797  evioDOMNodeP objIdBank = createLeafNode<uint64_t> ("DFCALTruthShower.objId");
798  evioDOMNodeP xBank = createLeafNode<float> ("DFCALTruthShower.x");
799  evioDOMNodeP yBank = createLeafNode<float> ("DFCALTruthShower.y");
800  evioDOMNodeP zBank = createLeafNode<float> ("DFCALTruthShower.z");
801  evioDOMNodeP tBank = createLeafNode<float> ("DFCALTruthShower.t");
802  evioDOMNodeP pxBank = createLeafNode<float> ("DFCALTruthShower.px");
803  evioDOMNodeP pyBank = createLeafNode<float> ("DFCALTruthShower.py");
804  evioDOMNodeP pzBank = createLeafNode<float> ("DFCALTruthShower.pz");
805  evioDOMNodeP EBank = createLeafNode<float> ("DFCALTruthShower.E");
806  evioDOMNodeP primaryBank = createLeafNode<float> ("DFCALTruthShower.primary");
807  evioDOMNodeP trackBank = createLeafNode<float> ("DFCALTruthShower.track");
808  evioDOMNodeP typeBank = createLeafNode<float> ("DFCALTruthShower.type");
809  *fcaltruthshower << objIdBank << xBank << yBank << zBank << tBank << pxBank << pyBank<< pzBank
810  << EBank << primaryBank<< trackBank<< typeBank;
811 
812 
813  // create associated object bank and add to main bank
814  evioDOMNodeP assocBank = createContainerNode("DFCALTruthShower.assocObjectBanks");
815  *fcaltruthshower<< assocBank;
816 
817 
818  // loop over each requested factory
819  int assocCount = 0;
820  set<string>::iterator iter;
821  for(iter=evioMap["dfcaltruthshower"].begin(); iter!=evioMap["dfcaltruthshower"].end(); iter++) {
822 
823  // is there any data
824  vector<const DFCALTruthShower*> fcaltruthshowers;
825  eventLoop->Get(fcaltruthshowers,(*iter).c_str());
826  if(fcaltruthshowers.size()<=0)continue;
827 
828 
829  // add track data to banks
830  for(unsigned int i=0; i<fcaltruthshowers.size(); i++) {
831  *objIdBank << fcaltruthshowers[i]->id;
832  *xBank << fcaltruthshowers[i]->x();
833  *yBank << fcaltruthshowers[i]->y();
834  *zBank << fcaltruthshowers[i]->z();
835  *tBank << fcaltruthshowers[i]->t();
836  *pxBank << fcaltruthshowers[i]->px();
837  *pyBank << fcaltruthshowers[i]->py();
838  *pzBank << fcaltruthshowers[i]->pz();
839  *EBank << fcaltruthshowers[i]->E();
840  *primaryBank << fcaltruthshowers[i]->primary();
841  *trackBank << fcaltruthshowers[i]->track();
842  *typeBank << fcaltruthshowers[i]->type();
843 
844  objIdMap[fcaltruthshowers[i]->id]=fcaltruthshowers[i]->GetNameTag();
845 
846 
847  // associated object id bank and add to associated object bank
848  evioDOMNodeP assocObjs = createLeafNode<uint64_t> ("DFCALTruthShower.assocObjects");
849  *assocBank << assocObjs;
850 
851  // get id's, add to id bank and to global object id map
852  vector<const JObject*> objs;
853  fcaltruthshowers[i]->GetT(objs);
854  for(unsigned int j=0; j<objs.size(); j++) {
855  assocCount++;
856  *assocObjs << objs[j]->id;
857  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
858  }
859  }
860  }
861  if(assocCount==0)assocBank->cutAndDelete();
862 
863 }
864 
865 
866 //------------------------------------------------------------------------------
867 
868 
869 void DDANAEVIO_factory::addDBCALTruthShower(JEventLoop *eventLoop, evioDOMTree &tree) {
870 
871 
872  // create bcaltruthshower bank and add to event tree
873  evioDOMNodeP bcaltruthshower = createContainerNode("DBCALTruthShower");
874  tree << bcaltruthshower;
875 
876 
877  // create data banks and add to bcaltruthshower
878  evioDOMNodeP objIdBank = createLeafNode<uint64_t> ("DBCALTruthShower.objId");
879  evioDOMNodeP trackBank = createLeafNode<int> ("DBCALTruthShower.track");
880  evioDOMNodeP primaryBank = createLeafNode<int> ("DBCALTruthShower.primary");
881  evioDOMNodeP phiBank = createLeafNode<float> ("DBCALTruthShower.phi");
882  evioDOMNodeP rBank = createLeafNode<float> ("DBCALTruthShower.r");
883  evioDOMNodeP zBank = createLeafNode<float> ("DBCALTruthShower.z");
884  evioDOMNodeP tBank = createLeafNode<float> ("DBCALTruthShower.t");
885  evioDOMNodeP EBank = createLeafNode<float> ("DBCALTruthShower.E");
886  *bcaltruthshower << objIdBank << trackBank << primaryBank << phiBank << rBank
887  << zBank << tBank << EBank;
888 
889 
890  // create associated object bank and add to main bank
891  evioDOMNodeP assocBank = createContainerNode("DBCALTruthShower.assocObjectBanks");
892  *bcaltruthshower<< assocBank;
893 
894 
895  // loop over each requested factory
896  int assocCount = 0;
897  set<string>::iterator iter;
898  for(iter=evioMap["dbcaltruthshower"].begin(); iter!=evioMap["dbcaltruthshower"].end(); iter++) {
899 
900  // is there any data
901  vector<const DBCALTruthShower*> bcaltruthshowers;
902  eventLoop->Get(bcaltruthshowers,(*iter).c_str());
903  if(bcaltruthshowers.size()<=0)continue;
904 
905 
906  // add track data to banks
907  for(unsigned int i=0; i<bcaltruthshowers.size(); i++) {
908  *objIdBank << bcaltruthshowers[i]->id;
909  *trackBank << bcaltruthshowers[i]->track;
910  *primaryBank << bcaltruthshowers[i]->primary;
911  *phiBank << bcaltruthshowers[i]->phi;
912  *rBank << bcaltruthshowers[i]->r;
913  *zBank << bcaltruthshowers[i]->z;
914  *tBank << bcaltruthshowers[i]->t;
915  *EBank << bcaltruthshowers[i]->E;
916 
917  objIdMap[bcaltruthshowers[i]->id]=bcaltruthshowers[i]->GetNameTag();
918 
919 
920  // get associated object id bank and add to associated object bank
921  evioDOMNodeP assocObjs = createLeafNode<uint64_t> ("DBCALTruthShower.assocObjects");
922  *assocBank << assocObjs;
923 
924  // get id's, add to id bank and to global object id map
925  vector<const JObject*> objs;
926  bcaltruthshowers[i]->GetT(objs);
927  for(unsigned int j=0; j<objs.size(); j++) {
928  assocCount++;
929  *assocObjs << objs[j]->id;
930  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
931  }
932  }
933  }
934  if(assocCount==0)assocBank->cutAndDelete();
935 
936 }
937 
938 
939 //------------------------------------------------------------------------------
940 
941 
942 void DDANAEVIO_factory::addDCDCHit(JEventLoop *eventLoop, evioDOMTree &tree) {
943 
944 
945  // create cdchit bank and add to event tree
946  evioDOMNodeP cdchit = createContainerNode("DCDCHit");
947  tree << cdchit;
948 
949 
950  // create data banks and add to cdchit bank
951  evioDOMNodeP objIdBank = createLeafNode<uint64_t> ("DCDCHit.objId");
952  evioDOMNodeP ringBank = createLeafNode<int> ("DCDCHit.ring");
953  evioDOMNodeP strawBank = createLeafNode<int> ("DCDCHit.straw");
954  evioDOMNodeP dEBank = createLeafNode<float> ("DCDCHit.dE");
955  evioDOMNodeP tBank = createLeafNode<float> ("DCDCHit.t");
956  *cdchit << objIdBank << ringBank << strawBank << dEBank << tBank;
957 
958 
959  // create associated object bank and add to main bank
960  evioDOMNodeP assocBank = createContainerNode("DCDCHit.assocObjectBanks");
961  *cdchit << assocBank;
962 
963 
964  // loop over each requested factory
965  int assocCount = 0;
966  set<string>::iterator iter;
967  for(iter=evioMap["dcdchit"].begin(); iter!=evioMap["dcdchit"].end(); iter++) {
968 
969  // is there any data
970  vector<const DCDCHit*> cdchits;
971  eventLoop->Get(cdchits,(*iter).c_str());
972  if(cdchits.size()<=0)continue;
973 
974 
975  // add track data to banks
976  for(unsigned int i=0; i<cdchits.size(); i++) {
977  *objIdBank << cdchits[i]->id;
978  *ringBank << cdchits[i]->ring;
979  *strawBank << cdchits[i]->straw;
980  *dEBank << cdchits[i]->dE;
981  *tBank << cdchits[i]->t;
982 
983  objIdMap[cdchits[i]->id]=cdchits[i]->GetNameTag();
984 
985 
986  // get associated object id bank and add to associated object bank
987  evioDOMNodeP assocObjs = createLeafNode<uint64_t> ("DCDCHit.assocObjects");
988  *assocBank << assocObjs;
989 
990  // get id's, add to id bank and to global object id map
991  vector<const JObject*> objs;
992  cdchits[i]->GetT(objs);
993  for(unsigned int j=0; j<objs.size(); j++) {
994  assocCount++;
995  *assocObjs << objs[j]->id;
996  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
997  }
998  }
999  }
1000  if(assocCount==0)assocBank->cutAndDelete();
1001 
1002 }
1003 
1004 
1005 //------------------------------------------------------------------------------
1006 
1007 
1008 void DDANAEVIO_factory::addDMCTrajectoryPoint(JEventLoop *eventLoop, evioDOMTree &tree) {
1009 
1010 
1011  // create bank and add to event tree
1012  evioDOMNodeP mctrajectorypoint = createContainerNode("DMCTrajectoryPoint");
1013  tree << mctrajectorypoint;
1014 
1015 
1016  // create data banks and add to bank
1017  evioDOMNodeP objIdBank = createLeafNode<uint64_t> ("DMCTrajectoryPoint.objId");
1018  evioDOMNodeP xBank = createLeafNode<float> ("DMCTrajectoryPoint.x");
1019  evioDOMNodeP yBank = createLeafNode<float> ("DMCTrajectoryPoint.y");
1020  evioDOMNodeP zBank = createLeafNode<float> ("DMCTrajectoryPoint.z");
1021  evioDOMNodeP pxBank = createLeafNode<float> ("DMCTrajectoryPoint.px");
1022  evioDOMNodeP pyBank = createLeafNode<float> ("DMCTrajectoryPoint.py");
1023  evioDOMNodeP pzBank = createLeafNode<float> ("DMCTrajectoryPoint.pz");
1024  evioDOMNodeP EBank = createLeafNode<float> ("DMCTrajectoryPoint.E");
1025  evioDOMNodeP dEBank = createLeafNode<float> ("DMCTrajectoryPoint.dE");
1026  evioDOMNodeP primary_trackBank = createLeafNode<int> ("DMCTrajectoryPoint.primary_track");
1027  evioDOMNodeP trackBank = createLeafNode<int> ("DMCTrajectoryPoint.track");
1028  evioDOMNodeP partBank = createLeafNode<int> ("DMCTrajectoryPoint.part");
1029  evioDOMNodeP radlenBank = createLeafNode<float> ("DMCTrajectoryPoint.radlen");
1030  evioDOMNodeP stepBank = createLeafNode<float> ("DMCTrajectoryPoint.step");
1031  evioDOMNodeP mechBank = createLeafNode<int> ("DMCTrajectoryPoint.mech");
1032  *mctrajectorypoint << objIdBank << xBank << yBank << zBank << pxBank << pyBank << pzBank << EBank << dEBank
1033  << primary_trackBank << trackBank << partBank << radlenBank << stepBank << mechBank;
1034 
1035 
1036  // create associated object bank and add to main bank
1037  evioDOMNodeP assocBank = createContainerNode("DMCTrajectoryPoint.assocObjectBanks");
1038  *mctrajectorypoint << assocBank;
1039 
1040 
1041  // loop over each requested factory
1042  int assocCount = 0;
1043  set<string>::iterator iter;
1044  for(iter=evioMap["dmctrajectorypoint"].begin(); iter!=evioMap["dmctrajectorypoint"].end(); iter++) {
1045 
1046  // is there any data
1047  vector<const DMCTrajectoryPoint*> mctrajectorypoints;
1048  eventLoop->Get(mctrajectorypoints,(*iter).c_str());
1049  if(mctrajectorypoints.size()<=0)continue;
1050 
1051 
1052  // add track data to banks
1053  for(unsigned int i=0; i<mctrajectorypoints.size(); i++) {
1054  *objIdBank << mctrajectorypoints[i]->id;
1055  *xBank << mctrajectorypoints[i]->x;
1056  *yBank << mctrajectorypoints[i]->y;
1057  *zBank << mctrajectorypoints[i]->z;
1058  *pxBank << mctrajectorypoints[i]->px;
1059  *pyBank << mctrajectorypoints[i]->py;
1060  *pzBank << mctrajectorypoints[i]->pz;
1061  *EBank << mctrajectorypoints[i]->E;
1062  *dEBank << mctrajectorypoints[i]->dE;
1063  *primary_trackBank << mctrajectorypoints[i]->primary_track;
1064  *trackBank << mctrajectorypoints[i]->track;
1065  *partBank << mctrajectorypoints[i]->part;
1066  *radlenBank << mctrajectorypoints[i]->radlen;
1067  *stepBank << mctrajectorypoints[i]->step;
1068  *mechBank << mctrajectorypoints[i]->mech;
1069 
1070  objIdMap[mctrajectorypoints[i]->id]=mctrajectorypoints[i]->GetNameTag();
1071 
1072 
1073  // get associated object id bank and add to associated object bank
1074  evioDOMNodeP assocObjs = createLeafNode<uint64_t> ("DMCTrajectoryPoint.assocObjects");
1075  *assocBank << assocObjs;
1076 
1077  // get id's, add to id bank and to global object id map
1078  vector<const JObject*> objs;
1079  mctrajectorypoints[i]->GetT(objs);
1080  for(unsigned int j=0; j<objs.size(); j++) {
1081  assocCount++;
1082  *assocObjs << objs[j]->id;
1083  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
1084  }
1085  }
1086  }
1087  if(assocCount==0)assocBank->cutAndDelete();
1088 
1089 }
1090 
1091 
1092 //------------------------------------------------------------------------------
1093 
1094 
1095 void DDANAEVIO_factory::addDFDCHit(JEventLoop *eventLoop, evioDOMTree &tree) {
1096 
1097 
1098  // create fdchit bank and add to event tree
1099  evioDOMNodeP fdchit = createContainerNode("DFDCHit");
1100  tree << fdchit;
1101 
1102 
1103  // create data banks and add to fdchit bank
1104  evioDOMNodeP objIdBank = createLeafNode<uint64_t> ("DFDCHit.objId");
1105  evioDOMNodeP layerBank = createLeafNode<int> ("DFDCHit.layer");
1106  evioDOMNodeP moduleBank = createLeafNode<int> ("DFDCHit.module");
1107  evioDOMNodeP elementBank = createLeafNode<int> ("DFDCHit.element");
1108  evioDOMNodeP planeBank = createLeafNode<int> ("DFDCHit.plane");
1109  evioDOMNodeP gPlaneBank = createLeafNode<int> ("DFDCHit.gPlane");
1110  evioDOMNodeP gLayerBank = createLeafNode<int> ("DFDCHit.gLayer");
1111  evioDOMNodeP qBank = createLeafNode<float> ("DFDCHit.q");
1112  evioDOMNodeP tBank = createLeafNode<float> ("DFDCHit.t");
1113  evioDOMNodeP rBank = createLeafNode<float> ("DFDCHit.r");
1114  evioDOMNodeP typeBank = createLeafNode<int> ("DFDCHit.type");
1115  *fdchit << objIdBank << layerBank << moduleBank << elementBank << planeBank
1116  << gPlaneBank << gLayerBank << qBank << tBank << rBank << typeBank;
1117 
1118 
1119  // create associated object bank and add to main bank
1120  evioDOMNodeP assocBank = createContainerNode("DFDCHits.assocObjectBanks");
1121  *fdchit << assocBank;
1122 
1123 
1124  // loop over each requested factory
1125  int assocCount = 0;
1126  set<string>::iterator iter;
1127  for(iter=evioMap["dfdchit"].begin(); iter!=evioMap["dfdchit"].end(); iter++) {
1128 
1129  // is there any data
1130  vector<const DFDCHit*> fdchits;
1131  eventLoop->Get(fdchits,(*iter).c_str());
1132  if(fdchits.size()<=0)continue;
1133 
1134 
1135  // add track data to banks
1136  for(unsigned int i=0; i<fdchits.size(); i++) {
1137  *objIdBank << fdchits[i]->id;
1138  *layerBank << fdchits[i]->layer;
1139  *moduleBank << fdchits[i]->module;
1140  *elementBank << fdchits[i]->element;
1141  *planeBank << fdchits[i]->plane;
1142  *gPlaneBank << fdchits[i]->gPlane;
1143  *gLayerBank << fdchits[i]->gLayer;
1144  *qBank << fdchits[i]->q;
1145  *tBank << fdchits[i]->t;
1146  *rBank << fdchits[i]->r;
1147  *typeBank << fdchits[i]->type;
1148 
1149  objIdMap[fdchits[i]->id]=fdchits[i]->GetNameTag();
1150 
1151 
1152  // get associated object id bank and add to associated object bank
1153  evioDOMNodeP assocObjs = createLeafNode<uint64_t> ("DFDCHits.assocObjects");
1154  *assocBank << assocObjs;
1155 
1156  // get id's, add to id bank and to global object id map
1157  vector<const JObject*> objs;
1158  fdchits[i]->GetT(objs);
1159  for(unsigned int j=0; j<objs.size(); j++) {
1160  assocCount++;
1161  *assocObjs << objs[j]->id;
1162  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
1163  }
1164  }
1165  }
1166  if(assocCount==0)assocBank->cutAndDelete();
1167 
1168 }
1169 
1170 
1171 //----------------------------------------------------------------------------
1172 
1173 
1174 void DDANAEVIO_factory::addDBeamPhoton(JEventLoop *eventLoop, evioDOMTree &tree) {
1175 
1176 
1177  // create bank and add to event tree
1178  evioDOMNodeP beamphoton = createContainerNode("DBeamPhoton");
1179  tree << beamphoton;
1180 
1181 
1182  // create data banks and add to bank
1183  evioDOMNodeP objIdBank = createLeafNode<uint64_t> ("DBeamPhoton.objId");
1184  evioDOMNodeP xBank = createLeafNode<float> ("DBeamPhoton.x");
1185  evioDOMNodeP yBank = createLeafNode<float> ("DBeamPhoton.y");
1186  evioDOMNodeP zBank = createLeafNode<float> ("DBeamPhoton.z");
1187  evioDOMNodeP pxBank = createLeafNode<float> ("DBeamPhoton.px");
1188  evioDOMNodeP pyBank = createLeafNode<float> ("DBeamPhoton.py");
1189  evioDOMNodeP pzBank = createLeafNode<float> ("DBeamPhoton.pz");
1190  evioDOMNodeP tBank = createLeafNode<int> ("DBeamPhoton.t");
1191  *beamphoton << objIdBank << xBank<< yBank<< zBank<< pxBank<< pyBank<< pzBank << tBank;
1192 
1193 
1194  // create associated object bank and add to main bank
1195  evioDOMNodeP assocBank = createContainerNode("DBeamPhoton.assocObjectBanks");
1196  *beamphoton << assocBank;
1197 
1198 
1199  // loop over each requested factory
1200  int assocCount = 0;
1201  set<string>::iterator iter;
1202  for(iter=evioMap["dbeamphoton"].begin(); iter!=evioMap["dbeamphoton"].end(); iter++) {
1203 
1204  // is there any data
1205  vector<const DBeamPhoton*> beamphotons;
1206  eventLoop->Get(beamphotons,(*iter).c_str());
1207  if(beamphotons.size()<=0)continue;
1208 
1209 
1210  // add track data to banks
1211  for(unsigned int i=0; i<beamphotons.size(); i++) {
1212  *objIdBank << beamphotons[i]->id;
1213 
1214 
1215  DVector3 pos = beamphotons[i]->position();
1216  *xBank << pos.X();
1217  *yBank << pos.Y();
1218  *zBank << pos.Z();
1219 
1220  DVector3 mom = beamphotons[i]->momentum();
1221  *pxBank << mom.X();
1222  *pyBank << mom.Y();
1223  *pzBank << mom.Z();
1224 
1225  *tBank << beamphotons[i]->t;
1226 
1227  objIdMap[beamphotons[i]->id]=beamphotons[i]->GetNameTag();
1228 
1229 
1230  // get associated object id bank and add to associated object bank
1231  evioDOMNodeP assocObjs = createLeafNode<uint64_t> ("DBeamPhoton.assocObjects");
1232  *assocBank << assocObjs;
1233 
1234  // get id's, add to id bank and to global object id map
1235  vector<const JObject*> objs;
1236  beamphotons[i]->GetT(objs);
1237  for(unsigned int j=0; j<objs.size(); j++) {
1238  assocCount++;
1239  *assocObjs << objs[j]->id;
1240  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
1241  }
1242  }
1243  }
1244  if(assocCount==0)assocBank->cutAndDelete();
1245 
1246 }
1247 
1248 
1249 //------------------------------------------------------------------------------
1250 
1251 
1252 void DDANAEVIO_factory::addDSCTruthHit(JEventLoop *eventLoop, evioDOMTree &tree) {
1253 
1254 
1255  // create bank and add to event tree
1256  evioDOMNodeP sctruthhit = createContainerNode("DSCTruthHit");
1257  tree << sctruthhit;
1258 
1259 
1260  // create data banks and add to bank
1261  evioDOMNodeP objIdBank = createLeafNode<uint64_t> ("DSCTruthHit.objId");
1262  evioDOMNodeP dEdxBank = createLeafNode<float> ("DSCTruthHit.dEdx");
1263  evioDOMNodeP primaryBank = createLeafNode<int8_t> ("DSCTruthHit.primary");
1264  evioDOMNodeP trackBank = createLeafNode<int> ("DSCTruthHit.track");
1265  evioDOMNodeP ptypeBank = createLeafNode<int> ("DSCTruthHit.ptype");
1266  evioDOMNodeP rBank = createLeafNode<float> ("DSCTruthHit.r");
1267  evioDOMNodeP phiBank = createLeafNode<float> ("DSCTruthHit.phi");
1268  evioDOMNodeP zBank = createLeafNode<float> ("DSCTruthHit.z");
1269  evioDOMNodeP tBank = createLeafNode<float> ("DSCTruthHit.t");
1270  evioDOMNodeP sectorBank = createLeafNode<int> ("DSCTruthHit.sector");
1271  *sctruthhit << objIdBank << dEdxBank << primaryBank << trackBank << ptypeBank << rBank << phiBank
1272  << zBank << tBank << sectorBank;
1273 
1274 
1275  // create associated object bank and add to main bank
1276  evioDOMNodeP assocBank = createContainerNode("DSCTruthHit.assocObjectBanks");
1277  *sctruthhit << assocBank;
1278 
1279 
1280  // loop over each requested factory
1281  int assocCount = 0;
1282  set<string>::iterator iter;
1283  for(iter=evioMap["dsctruthhit"].begin(); iter!=evioMap["dsctruthhit"].end(); iter++) {
1284 
1285  // is there any data
1286  vector<const DSCTruthHit*> sctruthhits;
1287  eventLoop->Get(sctruthhits,(*iter).c_str());
1288  if(sctruthhits.size()<=0)continue;
1289 
1290 
1291  // add track data to banks
1292  for(unsigned int i=0; i<sctruthhits.size(); i++) {
1293  *objIdBank << sctruthhits[i]->id;
1294  *dEdxBank << sctruthhits[i]->dEdx;
1295  *primaryBank << (int8_t)sctruthhits[i]->primary;
1296  *trackBank << sctruthhits[i]->track;
1297  *ptypeBank << sctruthhits[i]->ptype;
1298  *rBank << sctruthhits[i]->r;
1299  *phiBank << sctruthhits[i]->phi;
1300  *zBank << sctruthhits[i]->z;
1301  *tBank << sctruthhits[i]->t;
1302  *sectorBank << sctruthhits[i]->sector;
1303 
1304  objIdMap[sctruthhits[i]->id]=sctruthhits[i]->GetNameTag();
1305 
1306 
1307  // get associated object id bank and add to associated object bank
1308  evioDOMNodeP assocObjs = createLeafNode<uint64_t> ("DSCTruthHit.assocObjects");
1309  *assocBank << assocObjs;
1310 
1311  // get id's, add to id bank and to global object id map
1312  vector<const JObject*> objs;
1313  sctruthhits[i]->GetT(objs);
1314  for(unsigned int j=0; j<objs.size(); j++) {
1315  assocCount++;
1316  *assocObjs << objs[j]->id;
1317  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
1318  }
1319  }
1320  }
1321  if(assocCount==0)assocBank->cutAndDelete();
1322 
1323 }
1324 
1325 
1326 //------------------------------------------------------------------------------
1327 
1328 
1329 void DDANAEVIO_factory::addDFCALHit(JEventLoop *eventLoop, evioDOMTree &tree) {
1330 
1331 
1332  // create bank and add to event tree
1333  evioDOMNodeP fcalhit = createContainerNode("DFCALHit");
1334  tree << fcalhit;
1335 
1336 
1337  // create data banks and add to bank
1338  evioDOMNodeP objIdBank = createLeafNode<uint64_t> ("DFCALHit.objId");
1339  evioDOMNodeP rowBank = createLeafNode<int> ("DFCALHit.row");
1340  evioDOMNodeP columnBank = createLeafNode<int> ("DFCALHit.column");
1341  evioDOMNodeP xBank = createLeafNode<float> ("DFCALHit.x");
1342  evioDOMNodeP yBank = createLeafNode<float> ("DFCALHit.y");
1343  evioDOMNodeP EBank = createLeafNode<float> ("DFCALHit.E");
1344  evioDOMNodeP tBank = createLeafNode<float> ("DFCALHit.t");
1345  *fcalhit << objIdBank << rowBank << columnBank << xBank << yBank << EBank << tBank;
1346 
1347 
1348  // create associated object bank and add to main bank
1349  evioDOMNodeP assocBank = createContainerNode("DFCALHit.assocObjectBanks");
1350  *fcalhit << assocBank;
1351 
1352 
1353  // loop over each requested factory
1354  int assocCount = 0;
1355  set<string>::iterator iter;
1356  for(iter=evioMap["dfcalhit"].begin(); iter!=evioMap["dfcalhit"].end(); iter++) {
1357 
1358  // is there any data
1359  vector<const DFCALHit*> fcalhits;
1360  eventLoop->Get(fcalhits,(*iter).c_str());
1361  if(fcalhits.size()<=0)continue;
1362 
1363 
1364  // add track data to banks
1365  for(unsigned int i=0; i<fcalhits.size(); i++) {
1366  *objIdBank << fcalhits[i]->id;
1367  *rowBank << fcalhits[i]->row;
1368  *columnBank << fcalhits[i]->column;
1369  *xBank << fcalhits[i]->x;
1370  *yBank << fcalhits[i]->y;
1371  *EBank << fcalhits[i]->E;
1372  *tBank << fcalhits[i]->t;
1373 
1374  objIdMap[fcalhits[i]->id]=fcalhits[i]->GetNameTag();
1375 
1376 
1377  // get associated object id bank and add to associated object bank
1378  evioDOMNodeP assocObjs = createLeafNode<uint64_t> ("DFCALHit.assocObjects");
1379  *assocBank << assocObjs;
1380 
1381  // get id's, add to id bank and to global object id map
1382  vector<const JObject*> objs;
1383  fcalhits[i]->GetT(objs);
1384  for(unsigned int j=0; j<objs.size(); j++) {
1385  assocCount++;
1386  *assocObjs << objs[j]->id;
1387  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
1388  }
1389  }
1390  }
1391  if(assocCount==0)assocBank->cutAndDelete();
1392 
1393 }
1394 
1395 
1396 //------------------------------------------------------------------------------
1397 
1398 
1399 void DDANAEVIO_factory::addDSCHit(JEventLoop *eventLoop, evioDOMTree &tree) {
1400 
1401 
1402  // create bank and add to event tree
1403  evioDOMNodeP schit = createContainerNode("DSCHit");
1404  tree << schit;
1405 
1406 
1407  // create data banks and add to bank
1408  evioDOMNodeP objIdBank = createLeafNode<uint64_t> ("DSCHit.objId");
1409  evioDOMNodeP dEBank = createLeafNode<float> ("DSCHit.dE");
1410  evioDOMNodeP tBank = createLeafNode<float> ("DSCHit.t");
1411  evioDOMNodeP sectorBank = createLeafNode<int> ("DSCHit.sector");
1412  *schit << objIdBank << dEBank << tBank << sectorBank;
1413 
1414 
1415  // create associated object bank and add to main bank
1416  evioDOMNodeP assocBank = createContainerNode("DSCHit.assocObjectBanks");
1417  *schit << assocBank;
1418 
1419 
1420  // loop over each requested factory
1421  int assocCount = 0;
1422  set<string>::iterator iter;
1423  for(iter=evioMap["dschit"].begin(); iter!=evioMap["dschit"].end(); iter++) {
1424 
1425  // is there any data
1426  vector<const DSCHit*> schits;
1427  eventLoop->Get(schits,(*iter).c_str());
1428  if(schits.size()<=0)continue;
1429 
1430 
1431  // add track data to banks
1432  for(unsigned int i=0; i<schits.size(); i++) {
1433  *objIdBank << schits[i]->id;
1434  *dEBank << schits[i]->dE;
1435  *tBank << schits[i]->t;
1436  *sectorBank << schits[i]->sector;
1437 
1438  objIdMap[schits[i]->id]=schits[i]->GetNameTag();
1439 
1440 
1441  // get associated object id bank and add to associated object bank
1442  evioDOMNodeP assocObjs = createLeafNode<uint64_t> ("DSCHit.assocObjects");
1443  *assocBank << assocObjs;
1444 
1445  // get id's, add to id bank and to global object id map
1446  vector<const JObject*> objs;
1447  schits[i]->GetT(objs);
1448  for(unsigned int j=0; j<objs.size(); j++) {
1449  assocCount++;
1450  *assocObjs << objs[j]->id;
1451  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
1452  }
1453  }
1454  }
1455  if(assocCount==0)assocBank->cutAndDelete();
1456 
1457 }
1458 
1459 
1460 //------------------------------------------------------------------------------
1461 
1462 
1463 void DDANAEVIO_factory::addDTrackWireBased(JEventLoop *eventLoop, evioDOMTree &tree) {
1464 
1465 
1466  // create wirebasedtrack bank and add to event tree
1467  evioDOMNodeP wirebasedtrack = createContainerNode("DTrackWireBased");
1468  tree << wirebasedtrack;
1469 
1470 
1471  // create data banks and add to bank (n.b. time based track has FOM, wire based doesn't)
1472  evioDOMNodeP objIdBank = createLeafNode<uint64_t> ("DTrackWireBased.objId");
1473  evioDOMNodeP chisqBank = createLeafNode<float> ("DTrackWireBased.chisq");
1474  evioDOMNodeP NdofBank = createLeafNode<int> ("DTrackWireBased.Ndof");
1475  evioDOMNodeP xBank = createLeafNode<float> ("DTrackWireBased.x");
1476  evioDOMNodeP yBank = createLeafNode<float> ("DTrackWireBased.y");
1477  evioDOMNodeP zBank = createLeafNode<float> ("DTrackWireBased.z");
1478  evioDOMNodeP pxBank = createLeafNode<float> ("DTrackWireBased.px");
1479  evioDOMNodeP pyBank = createLeafNode<float> ("DTrackWireBased.py");
1480  evioDOMNodeP pzBank = createLeafNode<float> ("DTrackWireBased.pz");
1481  evioDOMNodeP qBank = createLeafNode<float> ("DTrackWireBased.q");
1482  evioDOMNodeP EBank = createLeafNode<float> ("DTrackWireBased.E");
1483  evioDOMNodeP massBank = createLeafNode<float> ("DTrackWireBased.mass");
1484  *wirebasedtrack << objIdBank << chisqBank << NdofBank << xBank << yBank << zBank << pxBank << pyBank << pzBank
1485  << qBank << EBank << massBank;
1486 
1487 
1488  // create associated object bank and add to main bank
1489  evioDOMNodeP assocBank = createContainerNode("DTrackWireBased.assocObjectBanks");
1490  *wirebasedtrack<< assocBank;
1491 
1492 
1493  // loop over each requested factory
1494  int assocCount = 0;
1495  set<string>::iterator iter;
1496  for(iter=evioMap["dtrackwirebased"].begin(); iter!=evioMap["dtrackwirebased"].end(); iter++) {
1497 
1498  // is there any data
1499  vector<const DTrackWireBased*> wirebasedtracks;
1500  eventLoop->Get(wirebasedtracks,(*iter).c_str());
1501  if(wirebasedtracks.size()<=0)continue;
1502 
1503 
1504  // add track data to banks
1505  for(unsigned int i=0; i<wirebasedtracks.size(); i++) {
1506  *objIdBank << wirebasedtracks[i]->id;
1507  *chisqBank << wirebasedtracks[i]->chisq;
1508  *NdofBank << wirebasedtracks[i]->Ndof;
1509  *xBank << wirebasedtracks[i]->x();
1510  *yBank << wirebasedtracks[i]->y();
1511  *zBank << wirebasedtracks[i]->z();
1512  *pxBank << wirebasedtracks[i]->px();
1513  *pyBank << wirebasedtracks[i]->py();
1514  *pzBank << wirebasedtracks[i]->pz();
1515  *qBank << wirebasedtracks[i]->charge();
1516  *EBank << wirebasedtracks[i]->energy();
1517  *massBank << wirebasedtracks[i]->mass();
1518 
1519  objIdMap[wirebasedtracks[i]->id]=wirebasedtracks[i]->GetNameTag();
1520 
1521 
1522  // get associated object id bank and add to associated object bank
1523  evioDOMNodeP assocObjs = createLeafNode<uint64_t> ("DTrackWireBased.assocObjects");
1524  *assocBank << assocObjs;
1525 
1526  // get id's, add to id bank and to global object id map
1527  vector<const JObject*> objs;
1528  wirebasedtracks[i]->GetT(objs);
1529  for(unsigned int j=0; j<objs.size(); j++) {
1530  assocCount++;
1531  *assocObjs << objs[j]->id;
1532  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
1533  }
1534  }
1535  }
1536  if(assocCount==0)assocBank->cutAndDelete();
1537 
1538 }
1539 
1540 
1541 //------------------------------------------------------------------------------
1542 
1543 
1544 void DDANAEVIO_factory::addDTrackTimeBased(JEventLoop *eventLoop, evioDOMTree &tree) {
1545 
1546 
1547  // create timebasedtrack bank and add to event tree
1548  evioDOMNodeP timebasedtrack = createContainerNode("DTrackTimeBased");
1549  tree << timebasedtrack;
1550 
1551 
1552  // create data banks and add to bank
1553  evioDOMNodeP objIdBank = createLeafNode<uint64_t> ("DTrackTimeBased.objId");
1554  evioDOMNodeP chisqBank = createLeafNode<float> ("DTrackTimeBased.chisq");
1555  evioDOMNodeP NdofBank = createLeafNode<int> ("DTrackTimeBased.Ndof");
1556  evioDOMNodeP FOMBank = createLeafNode<float> ("DTrackTimeBased.FOM");
1557  evioDOMNodeP xBank = createLeafNode<float> ("DTrackTimeBased.x");
1558  evioDOMNodeP yBank = createLeafNode<float> ("DTrackTimeBased.y");
1559  evioDOMNodeP zBank = createLeafNode<float> ("DTrackTimeBased.z");
1560  evioDOMNodeP pxBank = createLeafNode<float> ("DTrackTimeBased.px");
1561  evioDOMNodeP pyBank = createLeafNode<float> ("DTrackTimeBased.py");
1562  evioDOMNodeP pzBank = createLeafNode<float> ("DTrackTimeBased.pz");
1563  evioDOMNodeP qBank = createLeafNode<float> ("DTrackTimeBased.q");
1564  evioDOMNodeP EBank = createLeafNode<float> ("DTrackTimeBased.E");
1565  evioDOMNodeP massBank = createLeafNode<float> ("DTrackTimeBased.mass");
1566  evioDOMNodeP t0Bank = createLeafNode<float> ("DTrackTimeBased.t0");
1567  *timebasedtrack << objIdBank << chisqBank << NdofBank << FOMBank << xBank << yBank << zBank
1568  << pxBank << pyBank << pzBank << qBank << EBank << massBank << t0Bank;
1569 
1570 
1571  // create associated object bank and add to main bank
1572  evioDOMNodeP assocBank = createContainerNode("DTrackTimeBased.assocObjectBanks");
1573  *timebasedtrack << assocBank;
1574 
1575 
1576  // loop over each requested factory
1577  int assocCount = 0;
1578  set<string>::iterator iter;
1579  for(iter=evioMap["dtracktimebased"].begin(); iter!=evioMap["dtracktimebased"].end(); iter++) {
1580 
1581  // is there any data
1582  vector<const DTrackTimeBased*> timebasedtracks;
1583  eventLoop->Get(timebasedtracks,(*iter).c_str());
1584  if(timebasedtracks.size()<=0)continue;
1585 
1586 
1587  // add track data to banks
1588  for(unsigned int i=0; i<timebasedtracks.size(); i++) {
1589  *objIdBank << timebasedtracks[i]->id;
1590  *chisqBank << timebasedtracks[i]->chisq;
1591  *NdofBank << timebasedtracks[i]->Ndof;
1592  *FOMBank << timebasedtracks[i]->FOM;
1593  *xBank << timebasedtracks[i]->x();
1594  *yBank << timebasedtracks[i]->y();
1595  *zBank << timebasedtracks[i]->z();
1596  *pxBank << timebasedtracks[i]->px();
1597  *pyBank << timebasedtracks[i]->py();
1598  *pzBank << timebasedtracks[i]->pz();
1599  *qBank << timebasedtracks[i]->charge();
1600  *EBank << timebasedtracks[i]->energy();
1601  *massBank << timebasedtracks[i]->mass();
1602  *t0Bank << timebasedtracks[i]->t0();
1603 
1604  objIdMap[timebasedtracks[i]->id]=timebasedtracks[i]->GetNameTag();
1605 
1606 
1607  // get associated object id bank and add to associated object bank
1608  evioDOMNodeP assocObjs = createLeafNode<uint64_t> ("DTrackTimeBased.assocObjects");
1609  *assocBank << assocObjs;
1610 
1611  // get id's, add to id bank and to global object id map
1612  vector<const JObject*> objs;
1613  timebasedtracks[i]->GetT(objs);
1614  for(unsigned int j=0; j<objs.size(); j++) {
1615  assocCount++;
1616  *assocObjs << objs[j]->id;
1617  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
1618  }
1619  }
1620  }
1621  if(assocCount==0)assocBank->cutAndDelete();
1622 
1623 }
1624 
1625 
1626 //------------------------------------------------------------------------------
1627 
1628 
1629 void DDANAEVIO_factory::addDChargedTrack(JEventLoop *eventLoop, evioDOMTree &tree) {
1630 
1631 
1632  // create chargedtrack bank and add to event tree
1633  evioDOMNodeP chargedtrack = createContainerNode("DChargedTrack");
1634  tree << chargedtrack;
1635 
1636 
1637  // create data banks and add to chargedtrack bank
1638  evioDOMNodeP objIdBank = createLeafNode<uint64_t> ("DChargedTrack.objId");
1639  evioDOMNodeP hypothesisBank = createContainerNode ("DChargedTrack.hypothesisBanks");
1640  *chargedtrack << objIdBank << hypothesisBank;
1641 
1642 
1643  // create associated object bank and add to main bank
1644  evioDOMNodeP assocBank = createContainerNode("DChargedTrack.assocObjectBanks");
1645  *chargedtrack << assocBank;
1646 
1647 
1648  // loop over each requested factory
1649  int assocCount = 0;
1650  set<string>::iterator iter;
1651  for(iter=evioMap["dchargedtrack"].begin(); iter!=evioMap["dchargedtrack"].end(); iter++) {
1652 
1653  // is there any data
1654  vector<const DChargedTrack*> chargedtracks;
1655  eventLoop->Get(chargedtracks,(*iter).c_str());
1656  if(chargedtracks.size()<=0)continue;
1657 
1658 
1659  // add track data to banks
1660  for(unsigned int i=0; i<chargedtracks.size(); i++) {
1661  *objIdBank << chargedtracks[i]->id;
1662 
1663  // create id bank for each charged track and add to hypotheses bank
1664  evioDOMNodeP hypotheses = createLeafNode<uint64_t> ("DChargedTrack.hypotheses");
1665  *hypothesisBank << hypotheses;
1666  for(unsigned int j=0; j<chargedtracks[i]->hypotheses.size(); j++) {
1667  *hypotheses << chargedtracks[i]->hypotheses[j]->id;
1668  }
1669 
1670  objIdMap[chargedtracks[i]->id]=chargedtracks[i]->GetNameTag();
1671 
1672 
1673  // get associated object id bank and add to associated object bank
1674  evioDOMNodeP assocObjs = createLeafNode<uint64_t> ("DChargedTrack.assocObjects");
1675  *assocBank << assocObjs;
1676 
1677  // get id's, add to id bank and to global object id map
1678  vector<const JObject*> objs;
1679  chargedtracks[i]->GetT(objs);
1680  for(unsigned int j=0; j<objs.size(); j++) {
1681  assocCount++;
1682  *assocObjs << objs[j]->id;
1683  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
1684  }
1685  }
1686  }
1687  if(assocCount==0)assocBank->cutAndDelete();
1688 
1689 }
1690 
1691 
1692 //------------------------------------------------------------------------------
1693 
1694 
1695 void DDANAEVIO_factory::addDPhoton(JEventLoop *eventLoop, evioDOMTree &tree) {
1696 
1697 
1698  // create photon bank and add to event tree
1699  evioDOMNodeP photon = createContainerNode("DPhoton");
1700  tree << photon;
1701 
1702 
1703  // create data banks and add to photon bank
1704  evioDOMNodeP objIdBank = createLeafNode<uint64_t> ("DPhoton.objId");
1705  evioDOMNodeP EBank = createLeafNode<float> ("DPhoton.E");
1706  evioDOMNodeP pxBank = createLeafNode<float> ("DPhoton.px");
1707  evioDOMNodeP pyBank = createLeafNode<float> ("DPhoton.py");
1708  evioDOMNodeP pzBank = createLeafNode<float> ("DPhoton.pz");
1709  evioDOMNodeP xBank = createLeafNode<float> ("DPhoton.x");
1710  evioDOMNodeP yBank = createLeafNode<float> ("DPhoton.y");
1711  evioDOMNodeP zBank = createLeafNode<float> ("DPhoton.z");
1712  evioDOMNodeP tBank = createLeafNode<float> ("DPhoton.t");
1713  evioDOMNodeP TagBank = createLeafNode<int> ("DPhoton.Tag");
1714  *photon << objIdBank << EBank << pxBank << pyBank << pzBank << xBank << yBank << zBank
1715  << tBank << TagBank;
1716 
1717 
1718  // create associated object bank and add to main bank
1719  evioDOMNodeP assocBank = createContainerNode("DPhoton.assocObjectBanks");
1720  *photon << assocBank;
1721 
1722 
1723  // loop over each requested factory
1724  int assocCount = 0;
1725  set<string>::iterator iter;
1726  for(iter=evioMap["dphoton"].begin(); iter!=evioMap["dphoton"].end(); iter++) {
1727 
1728  // is there any data
1729  vector<const DPhoton*> photons;
1730  eventLoop->Get(photons),(*iter).c_str();
1731  if(photons.size()<=0)continue;
1732 
1733 
1734  // add track data to banks
1735  for(unsigned int i=0; i<photons.size(); i++) {
1736  *objIdBank << photons[i]->id;
1737  *EBank << photons[i]->energy();
1738  *pxBank << photons[i]->px();
1739  *pyBank << photons[i]->py();
1740  *pzBank << photons[i]->pz();
1741  *xBank << photons[i]->x();
1742  *yBank << photons[i]->y();
1743  *zBank << photons[i]->z();
1744  *tBank << photons[i]->getTime();
1745  *TagBank << photons[i]->getTag();
1746 
1747  objIdMap[photons[i]->id]=photons[i]->GetNameTag();
1748 
1749 
1750  // get associated object id bank and add to associated object bank
1751  evioDOMNodeP assocObjs = createLeafNode<uint64_t> ("DPhoton.assocObjects");
1752  *assocBank << assocObjs;
1753 
1754  // get id's, add to id bank and to global object id map
1755  vector<const JObject*> objs;
1756  photons[i]->GetT(objs);
1757  for(unsigned int j=0; j<objs.size(); j++) {
1758  assocCount++;
1759  *assocObjs << objs[j]->id;
1760  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
1761  }
1762  }
1763  }
1764  if(assocCount==0)assocBank->cutAndDelete();
1765 
1766 }
1767 
1768 
1769 //------------------------------------------------------------------------------
1770 
1771 
1772 void DDANAEVIO_factory::addDCDCTrackHit(JEventLoop *eventLoop, evioDOMTree &tree) {
1773 
1774 
1775  // create cdctrackhit bank and add to event tree
1776  evioDOMNodeP cdctrackhit = createContainerNode("DCDCTrackHit");
1777  tree << cdctrackhit;
1778 
1779 
1780  // create data banks and add to cdctrackhit bank
1781  evioDOMNodeP objIdBank = createLeafNode<uint64_t> ("DCDCTrackHit.objId");
1782  evioDOMNodeP ringBank = createLeafNode<int> ("DCDCTrackHit.ring");
1783  evioDOMNodeP strawBank = createLeafNode<int> ("DCDCTrackHit.straw");
1784  evioDOMNodeP xBank = createLeafNode<float> ("DCDCTrackHit.x");
1785  evioDOMNodeP yBank = createLeafNode<float> ("DCDCTrackHit.y");
1786  evioDOMNodeP stereoBank = createLeafNode<float> ("DCDCTrackHit.stereo");
1787  evioDOMNodeP tdriftBank = createLeafNode<float> ("DCDCTrackHit.tdrift");
1788  evioDOMNodeP distBank = createLeafNode<float> ("DCDCTrackHit.dist");
1789  evioDOMNodeP dEBank = createLeafNode<float> ("DCDCTrackHit.dE");
1790  *cdctrackhit << objIdBank << ringBank << strawBank << xBank << yBank << stereoBank
1791  << tdriftBank << distBank << dEBank;
1792 
1793 
1794  // create associated object bank and add to main bank
1795  evioDOMNodeP assocBank = createContainerNode("DCDCTrackHit.assocObjectBanks");
1796  *cdctrackhit << assocBank;
1797 
1798 
1799  // loop over each requested factory
1800  int assocCount = 0;
1801  set<string>::iterator iter;
1802  for(iter=evioMap["dcdctrackhit"].begin(); iter!=evioMap["dcdctrackhit"].end(); iter++) {
1803 
1804  // is there any data
1805  vector<const DCDCTrackHit*> cdctrackhits;
1806  eventLoop->Get(cdctrackhits,(*iter).c_str());
1807  if(cdctrackhits.size()<=0)continue;
1808 
1809 
1810  // add track data to banks
1811  for(unsigned int i=0; i<cdctrackhits.size(); i++) {
1812  *objIdBank << cdctrackhits[i]->id;
1813  *ringBank << cdctrackhits[i]->wire->ring;
1814  *strawBank << cdctrackhits[i]->wire->straw;
1815  *xBank << cdctrackhits[i]->wire->origin.x();
1816  *yBank << cdctrackhits[i]->wire->origin.y();
1817  *stereoBank << cdctrackhits[i]->wire->stereo;
1818  *tdriftBank << cdctrackhits[i]->tdrift;
1819  *distBank << cdctrackhits[i]->dist;
1820  *dEBank << cdctrackhits[i]->dE;
1821 
1822  objIdMap[cdctrackhits[i]->id]=cdctrackhits[i]->GetNameTag();
1823 
1824 
1825  // get associated object id bank and add to associated object bank
1826  evioDOMNodeP assocObjs = createLeafNode<uint64_t> ("DCDCTrackHit.assocObjects");
1827  *assocBank << assocObjs;
1828 
1829  // get id's, add to id bank and to global object id map
1830  vector<const JObject*> objs;
1831  cdctrackhits[i]->GetT(objs);
1832  for(unsigned int j=0; j<objs.size(); j++) {
1833  assocCount++;
1834  *assocObjs << objs[j]->id;
1835  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
1836  }
1837  }
1838  }
1839  if(assocCount==0)assocBank->cutAndDelete();
1840 
1841 }
1842 
1843 
1844 //------------------------------------------------------------------------------
1845 
1846 
1847 void DDANAEVIO_factory::addDFDCPseudo(JEventLoop *eventLoop, evioDOMTree &tree) {
1848 
1849 
1850  // create fdcpseudo bank and add to event tree
1851  evioDOMNodeP fdcpseudo = createContainerNode("DFDCPseudo");
1852  tree << fdcpseudo;
1853 
1854 
1855  // create data banks and add to fdcpseudo bank
1856  evioDOMNodeP objIdBank = createLeafNode<uint64_t> ("DFDCPseudo.objId");
1857  evioDOMNodeP uBank = createLeafNode<float> ("DFDCPseudo.u");
1858  evioDOMNodeP vBank = createLeafNode<float> ("DFDCPseudo.v");
1859  evioDOMNodeP wBank = createLeafNode<float> ("DFDCPseudo.w");
1860  evioDOMNodeP sBank = createLeafNode<float> ("DFDCPseudo.s");
1861  evioDOMNodeP layerBank = createLeafNode<int> ("DFDCPseudo.layer");
1862  evioDOMNodeP wireBank = createLeafNode<int> ("DFDCPseudo.wire");
1863  evioDOMNodeP timeBank = createLeafNode<float> ("DFDCPseudo.time");
1864  evioDOMNodeP statusBank = createLeafNode<int> ("DFDCPseudo.status");
1865  evioDOMNodeP xBank = createLeafNode<float> ("DFDCPseudo.x");
1866  evioDOMNodeP yBank = createLeafNode<float> ("DFDCPseudo.y");
1867  evioDOMNodeP dEBank = createLeafNode<float> ("DFDCPseudo.dE");
1868  *fdcpseudo << objIdBank << uBank<< vBank << wBank << sBank << layerBank << wireBank << timeBank
1869  << statusBank << xBank << yBank << dEBank;
1870 
1871 
1872  // create associated object bank and add to main bank
1873  evioDOMNodeP assocBank = createContainerNode("DFDCPseudo.assocObjectBanks");
1874  *fdcpseudo << assocBank;
1875 
1876 
1877  // loop over each requested factory
1878  int assocCount = 0;
1879  set<string>::iterator iter;
1880  for(iter=evioMap["dfdcpseudo"].begin(); iter!=evioMap["dfdcpseudo"].end(); iter++) {
1881 
1882  // is there any data
1883  vector<const DFDCPseudo*> fdcpseudos;
1884  eventLoop->Get(fdcpseudos,(*iter).c_str());
1885  if(fdcpseudos.size()<=0)continue;
1886 
1887 
1888  // add track data to banks
1889  for(unsigned int i=0; i<fdcpseudos.size(); i++) {
1890  *objIdBank << fdcpseudos[i]->id;
1891  *uBank << fdcpseudos[i]->u;
1892  *vBank << fdcpseudos[i]->v;
1893  *wBank << fdcpseudos[i]->w;
1894  *sBank << fdcpseudos[i]->s;
1895  *layerBank << fdcpseudos[i]->wire->layer;
1896  *wireBank << fdcpseudos[i]->wire->wire;
1897  *timeBank << fdcpseudos[i]->time;
1898  *statusBank << fdcpseudos[i]->status;
1899  *xBank << fdcpseudos[i]->xy.X();
1900  *yBank << fdcpseudos[i]->xy.Y();
1901  *dEBank << fdcpseudos[i]->dE;
1902 
1903  objIdMap[fdcpseudos[i]->id]=fdcpseudos[i]->GetNameTag();
1904 
1905 
1906  // get associated object id bank and add to associated object bank
1907  evioDOMNodeP assocObjs = createLeafNode<uint64_t> ("DFDCPseudo.assocObjects");
1908  *assocBank << assocObjs;
1909 
1910  // get id's, add to id bank and to global object id map
1911  vector<const JObject*> objs;
1912  fdcpseudos[i]->GetT(objs);
1913  for(unsigned int j=0; j<objs.size(); j++) {
1914  assocCount++;
1915  *assocObjs << objs[j]->id;
1916  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
1917  }
1918  }
1919  }
1920  if(assocCount==0)assocBank->cutAndDelete();
1921 
1922 }
1923 
1924 
1925 //----------------------------------------------------------------------------
1926 
1927 
1928 void DDANAEVIO_factory::addDVertex(JEventLoop *eventLoop, evioDOMTree &tree) {
1929 
1930  string objName = "DVertex";
1931  string objNameLC(objName);
1932  std::transform(objNameLC.begin(), objNameLC.end(), objNameLC.begin(), (int(*)(int)) tolower);
1933 
1934 
1935  // create main bank and add to event tree
1936  evioDOMNodeP mainBank = createContainerNode(objName);
1937  tree << mainBank;
1938 
1939 
1940  // create data banks and add to bank
1941  evioDOMNodeP objIdBank = createLeafNode<uint64_t> (objName+".objId");
1942  evioDOMNodeP var1Bank = createLeafNode<float> (objName+".x");
1943  evioDOMNodeP var2Bank = createLeafNode<float> (objName+".y");
1944  evioDOMNodeP var3Bank = createLeafNode<float> (objName+".z");
1945  evioDOMNodeP var4Bank = createLeafNode<float> (objName+".t");
1946  evioDOMNodeP var5Bank = createLeafNode<int> (objName+".beamline_used");
1947  evioDOMNodeP var6Bank = createLeafNode<int> (objName+".Ntracks");
1948  evioDOMNodeP var7Bank = createLeafNode<int> (objName+".Nphotons");
1949  *mainBank << objIdBank << var1Bank << var2Bank << var3Bank << var4Bank << var5Bank << var6Bank << var7Bank;
1950 
1951 
1952  // create associated object bank and add to main bank
1953  evioDOMNodeP assocBank = createContainerNode(objName+".assocObjectBanks");
1954  *mainBank << assocBank;
1955 
1956 
1957  // loop over each requested factory, indexed by object name in lower case
1958  int assocCount = 0;
1959  set<string>::iterator iter;
1960  for(iter=evioMap[objNameLC].begin(); iter!=evioMap[objNameLC].end(); iter++) {
1961 
1962 
1963  // is there any data
1964  vector<const DVertex*> dataObjects;
1965  eventLoop->Get(dataObjects,(*iter).c_str());
1966  if(dataObjects.size()<=0)continue;
1967 
1968 
1969  // add track data to banks
1970  for(unsigned int i=0; i<dataObjects.size(); i++) {
1971  *objIdBank << dataObjects[i]->id;
1972  *var1Bank << dataObjects[i]->x.X();
1973  *var2Bank << dataObjects[i]->x.Y();
1974  *var3Bank << dataObjects[i]->x.Z();
1975  *var4Bank << dataObjects[i]->x.T();
1976  *var5Bank << dataObjects[i]->beamline_used;
1977 
1978  vector<const DTrackTimeBased*> trks;
1979  dataObjects[i]->Get(trks);
1980  *var6Bank << trks.size();
1981 
1982  vector<const DFCALShower*> showers;
1983  dataObjects[i]->Get(showers);
1984  *var7Bank << showers.size();
1985 
1986 
1987  objIdMap[dataObjects[i]->id]=dataObjects[i]->GetNameTag();
1988 
1989 
1990  // get associated object id bank and add to associated object bank
1991  evioDOMNodeP assocObjs = createLeafNode<uint64_t> (objName+".assocObjects");
1992  *assocBank << assocObjs;
1993 
1994  // get id's, add to id bank and to global object id map
1995  vector<const JObject*> objs;
1996  dataObjects[i]->GetT(objs);
1997  for(unsigned int j=0; j<objs.size(); j++) {
1998  assocCount++;
1999  *assocObjs << objs[j]->id;
2000  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
2001  }
2002  }
2003  }
2004  if(assocCount==0)assocBank->cutAndDelete();
2005 
2006 }
2007 
2008 
2009 //------------------------------------------------------------------------------
2010 
2011 
2012 void DDANAEVIO_factory::addDTrackCandidate(JEventLoop *eventLoop, evioDOMTree &tree) {
2013 
2014  string objName = "DTrackCandidate";
2015  string objNameLC(objName);
2016  std::transform(objNameLC.begin(), objNameLC.end(), objNameLC.begin(), (int(*)(int)) tolower);
2017 
2018 
2019  // create main bank and add to event tree
2020  evioDOMNodeP mainBank = createContainerNode(objName);
2021  tree << mainBank;
2022 
2023 
2024  // create data banks and add to bank
2025  evioDOMNodeP objIdBank = createLeafNode<uint64_t> (objName+".objId");
2026  evioDOMNodeP var1Bank = createLeafNode<float> (objName+".chisq");
2027  evioDOMNodeP var2Bank = createLeafNode<int> (objName+".Ndof");
2028  *mainBank << objIdBank << var1Bank << var2Bank;
2029 
2030 
2031  // create associated object bank and add to main bank
2032  evioDOMNodeP assocBank = createContainerNode(objName+".assocObjectBanks");
2033  *mainBank << assocBank;
2034 
2035 
2036  // loop over each requested factory, indexed by object name in lower case
2037  int assocCount = 0;
2038  set<string>::iterator iter;
2039  for(iter=evioMap[objNameLC].begin(); iter!=evioMap[objNameLC].end(); iter++) {
2040 
2041 
2042  // is there any data
2043  // vector<const DBankName*> dataObjects;
2044  vector<const DTrackCandidate*> dataObjects;
2045  eventLoop->Get(dataObjects,(*iter).c_str());
2046  if(dataObjects.size()<=0)continue;
2047 
2048 
2049  // add track data to banks
2050  for(unsigned int i=0; i<dataObjects.size(); i++) {
2051  *objIdBank << dataObjects[i]->id;
2052  *var1Bank << dataObjects[i]->chisq;
2053  *var2Bank << dataObjects[i]->Ndof ;
2054 
2055  objIdMap[dataObjects[i]->id]=dataObjects[i]->GetNameTag();
2056 
2057 
2058  // get associated object id bank and add to associated object bank
2059  evioDOMNodeP assocObjs = createLeafNode<uint64_t> (objName+".assocObjects");
2060  *assocBank << assocObjs;
2061 
2062  // get id's, add to id bank and to global object id map
2063  vector<const JObject*> objs;
2064  dataObjects[i]->GetT(objs);
2065  for(unsigned int j=0; j<objs.size(); j++) {
2066  assocCount++;
2067  *assocObjs << objs[j]->id;
2068  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
2069  }
2070  }
2071  }
2072  if(assocCount==0)assocBank->cutAndDelete();
2073 
2074 }
2075 
2076 
2077 //------------------------------------------------------------------------------
2078 
2079 
2080 void DDANAEVIO_factory::addDBCALPhoton(JEventLoop *eventLoop, evioDOMTree &tree) {
2081 
2082  string objName = "DBCALPhoton";
2083  string objNameLC(objName);
2084  std::transform(objNameLC.begin(), objNameLC.end(), objNameLC.begin(), (int(*)(int)) tolower);
2085 
2086 
2087  // create main bank and add to event tree
2088  evioDOMNodeP mainBank = createContainerNode(objName);
2089  tree << mainBank;
2090 
2091 
2092  // create data banks and add to bank
2093  evioDOMNodeP objIdBank = createLeafNode<uint64_t> (objName+".objId");
2094  evioDOMNodeP var1Bank = createLeafNode<float> (objName+".x");
2095  evioDOMNodeP var2Bank = createLeafNode<float> (objName+".y");
2096  evioDOMNodeP var3Bank = createLeafNode<float> (objName+".z");
2097  evioDOMNodeP var4Bank = createLeafNode<float> (objName+".px");
2098  evioDOMNodeP var5Bank = createLeafNode<float> (objName+".py");
2099  evioDOMNodeP var6Bank = createLeafNode<float> (objName+".pz");
2100  evioDOMNodeP var7Bank = createLeafNode<float> (objName+".E");
2101  evioDOMNodeP var8Bank = createLeafNode<float> (objName+".t");
2102  *mainBank << objIdBank << var1Bank << var2Bank << var3Bank << var4Bank << var5Bank
2103  << var6Bank << var7Bank << var8Bank;
2104 
2105 
2106  // create associated object bank and add to main bank
2107  evioDOMNodeP assocBank = createContainerNode(objName+".assocObjectBanks");
2108  *mainBank << assocBank;
2109 
2110 
2111  // loop over each requested factory, indexed by object name in lower case
2112  int assocCount = 0;
2113  set<string>::iterator iter;
2114  for(iter=evioMap[objNameLC].begin(); iter!=evioMap[objNameLC].end(); iter++) {
2115 
2116 
2117  // is there any data
2118  vector<const DBCALPhoton*> dataObjects;
2119  eventLoop->Get(dataObjects,(*iter).c_str());
2120  if(dataObjects.size()<=0)continue;
2121 
2122 
2123  // add track data to banks
2124  for(unsigned int i=0; i<dataObjects.size(); i++) {
2125  *objIdBank << dataObjects[i]->id;
2126  *var1Bank << dataObjects[i]->showerPosition().X();
2127  *var2Bank << dataObjects[i]->showerPosition().Y();
2128  *var3Bank << dataObjects[i]->showerPosition().Z();
2129  *var4Bank << dataObjects[i]->lorentzMomentum().Px();
2130  *var5Bank << dataObjects[i]->lorentzMomentum().Py();
2131  *var6Bank << dataObjects[i]->lorentzMomentum().Pz();
2132  *var7Bank << dataObjects[i]->lorentzMomentum().E();
2133  *var8Bank << dataObjects[i]->showerTime();
2134 
2135  objIdMap[dataObjects[i]->id]=dataObjects[i]->GetNameTag();
2136 
2137 
2138  // get associated object id bank and add to associated object bank
2139  evioDOMNodeP assocObjs = createLeafNode<uint64_t> (objName+".assocObjects");
2140  *assocBank << assocObjs;
2141 
2142  // get id's, add to id bank and to global object id map
2143  vector<const JObject*> objs;
2144  dataObjects[i]->GetT(objs);
2145  for(unsigned int j=0; j<objs.size(); j++) {
2146  assocCount++;
2147  *assocObjs << objs[j]->id;
2148  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
2149  }
2150  }
2151  }
2152  if(assocCount==0)assocBank->cutAndDelete();
2153 
2154 }
2155 
2156 
2157 //------------------------------------------------------------------------------
2158 
2159 
2160 void DDANAEVIO_factory::addDFCALPhoton(JEventLoop *eventLoop, evioDOMTree &tree) {
2161 
2162  string objName = "DFCALPhoton";
2163  string objNameLC(objName);
2164  std::transform(objNameLC.begin(), objNameLC.end(), objNameLC.begin(), (int(*)(int)) tolower);
2165 
2166 
2167  // create main bank and add to event tree
2168  evioDOMNodeP mainBank = createContainerNode(objName);
2169  tree << mainBank;
2170 
2171 
2172  // create data banks and add to bank
2173  evioDOMNodeP objIdBank = createLeafNode<uint64_t> (objName+".objId");
2174  evioDOMNodeP var1Bank = createLeafNode<float> (objName+".x");
2175  evioDOMNodeP var2Bank = createLeafNode<float> (objName+".y");
2176  evioDOMNodeP var3Bank = createLeafNode<float> (objName+".z");
2177  evioDOMNodeP var4Bank = createLeafNode<float> (objName+".px");
2178  evioDOMNodeP var5Bank = createLeafNode<float> (objName+".py");
2179  evioDOMNodeP var6Bank = createLeafNode<float> (objName+".pz");
2180  evioDOMNodeP var7Bank = createLeafNode<float> (objName+".E");
2181  evioDOMNodeP var8Bank = createLeafNode<float> (objName+".t");
2182  *mainBank << objIdBank << var1Bank << var2Bank << var3Bank << var4Bank << var5Bank
2183  << var6Bank << var7Bank << var8Bank;
2184 
2185 
2186  // create associated object bank and add to main bank
2187  evioDOMNodeP assocBank = createContainerNode(objName+".assocObjectBanks");
2188  *mainBank << assocBank;
2189 
2190 
2191  // loop over each requested factory, indexed by object name in lower case
2192  int assocCount = 0;
2193  set<string>::iterator iter;
2194  for(iter=evioMap[objNameLC].begin(); iter!=evioMap[objNameLC].end(); iter++) {
2195 
2196 
2197  // is there any data
2198  vector<const DFCALPhoton*> dataObjects;
2199  eventLoop->Get(dataObjects,(*iter).c_str());
2200  if(dataObjects.size()<=0)continue;
2201 
2202 
2203  // add track data to banks
2204  for(unsigned int i=0; i<dataObjects.size(); i++) {
2205  *objIdBank << dataObjects[i]->id;
2206  *var1Bank << dataObjects[i]->lorentzMomentum().X();
2207  *var2Bank << dataObjects[i]->lorentzMomentum().Y();
2208  *var3Bank << dataObjects[i]->lorentzMomentum().Z();
2209  *var4Bank << dataObjects[i]->lorentzMomentum().Px();
2210  *var5Bank << dataObjects[i]->lorentzMomentum().Py();
2211  *var6Bank << dataObjects[i]->lorentzMomentum().Pz();
2212  *var7Bank << dataObjects[i]->lorentzMomentum().E();
2213  *var8Bank << dataObjects[i]->showerTime();
2214 
2215  objIdMap[dataObjects[i]->id]=dataObjects[i]->GetNameTag();
2216 
2217 
2218  // get associated object id bank and add to associated object bank
2219  evioDOMNodeP assocObjs = createLeafNode<uint64_t> (objName+".assocObjects");
2220  *assocBank << assocObjs;
2221 
2222  // get id's, add to id bank and to global object id map
2223  vector<const JObject*> objs;
2224  dataObjects[i]->GetT(objs);
2225  for(unsigned int j=0; j<objs.size(); j++) {
2226  assocCount++;
2227  *assocObjs << objs[j]->id;
2228  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
2229  }
2230  }
2231  }
2232  if(assocCount==0)assocBank->cutAndDelete();
2233 
2234 }
2235 
2236 
2237 //------------------------------------------------------------------------------
2238 
2239 
2240 void DDANAEVIO_factory::addDChargedTruthMatch(JEventLoop *eventLoop, evioDOMTree &tree) {
2241 
2242  string objName = "DChargedTruthMatch";
2243  string objNameLC(objName);
2244  std::transform(objNameLC.begin(), objNameLC.end(), objNameLC.begin(), (int(*)(int)) tolower);
2245 
2246 
2247  // create main bank and add to event tree
2248  evioDOMNodeP mainBank = createContainerNode(objName);
2249  tree << mainBank;
2250 
2251 
2252  // create data banks and add to bank
2253  evioDOMNodeP objIdBank = createLeafNode<uint64_t> (objName+".objId");
2254  evioDOMNodeP var1Bank = createLeafNode<int> (objName+".Nhits_thrown");
2255  evioDOMNodeP var2Bank = createLeafNode<int> (objName+".Nhits_thrown_selector");
2256  evioDOMNodeP var3Bank = createLeafNode<int> (objName+".Nhits_recon");
2257  evioDOMNodeP var4Bank = createLeafNode<int> (objName+".Nhits_both");
2258  evioDOMNodeP var5Bank = createLeafNode<float> (objName+".fom");
2259  *mainBank << objIdBank << var1Bank << var2Bank << var3Bank << var4Bank << var5Bank;
2260 
2261 
2262  // create associated object bank and add to main bank
2263  evioDOMNodeP assocBank = createContainerNode(objName+".assocObjectBanks");
2264  *mainBank << assocBank;
2265 
2266 
2267  // loop over each requested factory, indexed by object name in lower case
2268  int assocCount = 0;
2269  set<string>::iterator iter;
2270  for(iter=evioMap[objNameLC].begin(); iter!=evioMap[objNameLC].end(); iter++) {
2271 
2272 
2273  // is there any data
2274  vector<const DChargedTruthMatch*> dataObjects;
2275  eventLoop->Get(dataObjects,(*iter).c_str());
2276  if(dataObjects.size()<=0)continue;
2277 
2278 
2279  // add track data to banks
2280  for(unsigned int i=0; i<dataObjects.size(); i++) {
2281  *objIdBank << dataObjects[i]->id;
2282  *var1Bank << dataObjects[i]->Nhits_thrown;
2283  *var2Bank << dataObjects[i]->Nhits_thrown_selector;
2284  *var3Bank << dataObjects[i]->Nhits_recon;
2285  *var4Bank << dataObjects[i]->Nhits_both;
2286  *var5Bank << dataObjects[i]->fom;
2287 
2288  objIdMap[dataObjects[i]->id]=dataObjects[i]->GetNameTag();
2289 
2290 
2291  // get associated object id bank and add to associated object bank
2292  evioDOMNodeP assocObjs = createLeafNode<uint64_t> (objName+".assocObjects");
2293  *assocBank << assocObjs;
2294 
2295  // get id's, add to id bank and to global object id map
2296  vector<const JObject*> objs;
2297  dataObjects[i]->GetT(objs);
2298  for(unsigned int j=0; j<objs.size(); j++) {
2299  assocCount++;
2300  *assocObjs << objs[j]->id;
2301  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
2302  }
2303  }
2304  }
2305  if(assocCount==0)assocBank->cutAndDelete();
2306 
2307 }
2308 
2309 
2310 //------------------------------------------------------------------------------
2311 
2312 
2313 void DDANAEVIO_factory::addDTOFRawHit(JEventLoop *eventLoop, evioDOMTree &tree) {
2314 
2315 
2316  string objName = "DTOFRawHit";
2317  string objNameLC(objName);
2318  std::transform(objNameLC.begin(), objNameLC.end(), objNameLC.begin(), (int(*)(int)) tolower);
2319 
2320 
2321  // create main bank and add to event tree
2322  evioDOMNodeP mainBank = createContainerNode(objName);
2323  tree << mainBank;
2324 
2325 
2326  // create data banks and add to bank
2327  evioDOMNodeP objIdBank = createLeafNode<uint64_t> (objName+".objId");
2328  evioDOMNodeP var1Bank = createLeafNode<int> (objName+".bar");
2329  evioDOMNodeP var2Bank = createLeafNode<int> (objName+".plane");
2330  evioDOMNodeP var3Bank = createLeafNode<int> (objName+".lr");
2331  evioDOMNodeP var4Bank = createLeafNode<float> (objName+".dE");
2332  evioDOMNodeP var5Bank = createLeafNode<float> (objName+".t");
2333  *mainBank << objIdBank << var1Bank << var2Bank << var3Bank << var4Bank << var5Bank;
2334 
2335 
2336  // create associated object bank and add to main bank
2337  evioDOMNodeP assocBank = createContainerNode(objName+".assocObjectBanks");
2338  *mainBank << assocBank;
2339 
2340 
2341  // loop over each requested factory, indexed by object name in lower case
2342  int assocCount = 0;
2343  set<string>::iterator iter;
2344  for(iter=evioMap[objNameLC].begin(); iter!=evioMap[objNameLC].end(); iter++) {
2345 
2346 
2347  // is there any data
2348  vector<const DTOFRawHit*> dataObjects;
2349  eventLoop->Get(dataObjects,(*iter).c_str());
2350  if(dataObjects.size()<=0)continue;
2351 
2352 
2353  // add track data to banks
2354  for(unsigned int i=0; i<dataObjects.size(); i++) {
2355  *objIdBank << dataObjects[i]->id;
2356  *var1Bank << dataObjects[i]->bar;
2357  *var2Bank << dataObjects[i]->plane;
2358  *var3Bank << dataObjects[i]->lr;
2359  *var4Bank << dataObjects[i]->dE;
2360  *var5Bank << dataObjects[i]->t;
2361 
2362  objIdMap[dataObjects[i]->id]=dataObjects[i]->GetNameTag();
2363 
2364 
2365  // get associated object id bank and add to associated object bank
2366  evioDOMNodeP assocObjs = createLeafNode<uint64_t> (objName+".assocObjects");
2367  *assocBank << assocObjs;
2368 
2369  // get id's, add to id bank and to global object id map
2370  vector<const JObject*> objs;
2371  dataObjects[i]->GetT(objs);
2372  for(unsigned int j=0; j<objs.size(); j++) {
2373  assocCount++;
2374  *assocObjs << objs[j]->id;
2375  // objIdMap[objs[j]->id]=objs[j]->GetNameTag();
2376  }
2377  }
2378  }
2379  if(assocCount==0)assocBank->cutAndDelete();
2380 
2381 }
2382 
2383 
2384 //------------------------------------------------------------------------------
2385 
2386 
2387 void DDANAEVIO_factory::addDTOFRawHitMC(JEventLoop *eventLoop, evioDOMTree &tree) {
2388 
2389 
2390  string objName = "DTOFRawHitMC";
2391  string objNameLC(objName);
2392  std::transform(objNameLC.begin(), objNameLC.end(), objNameLC.begin(), (int(*)(int)) tolower);
2393 
2394 
2395  // create main bank and add to event tree
2396  evioDOMNodeP mainBank = createContainerNode(objName);
2397  tree << mainBank;
2398 
2399 
2400  // create data banks and add to bank
2401  evioDOMNodeP objIdBank = createLeafNode<uint64_t> (objName+".objId");
2402  evioDOMNodeP var1Bank = createLeafNode<int> (objName+".bar");
2403  evioDOMNodeP var2Bank = createLeafNode<int> (objName+".plane");
2404  evioDOMNodeP var3Bank = createLeafNode<int> (objName+".lr");
2405  evioDOMNodeP var4Bank = createLeafNode<float> (objName+".dist");
2406  evioDOMNodeP var5Bank = createLeafNode<float> (objName+".x");
2407  evioDOMNodeP var6Bank = createLeafNode<float> (objName+".y");
2408  evioDOMNodeP var7Bank = createLeafNode<float> (objName+".z");
2409  evioDOMNodeP var8Bank = createLeafNode<float> (objName+".px");
2410  evioDOMNodeP var9Bank = createLeafNode<float> (objName+".py");
2411  evioDOMNodeP var10Bank = createLeafNode<float> (objName+".pz");
2412  evioDOMNodeP var11Bank = createLeafNode<float> (objName+".E");
2413  evioDOMNodeP var12Bank = createLeafNode<int> (objName+".ptype");
2414  evioDOMNodeP var13Bank = createLeafNode<int> (objName+".itrack");
2415  *mainBank << objIdBank << var1Bank << var2Bank << var3Bank << var4Bank << var5Bank
2416  << var6Bank << var7Bank << var8Bank << var9Bank << var10Bank << var11Bank
2417  << var12Bank << var13Bank;
2418 
2419 
2420  // create associated object bank and add to main bank
2421  evioDOMNodeP assocBank = createContainerNode(objName+".assocObjectBanks");
2422  *mainBank << assocBank;
2423 
2424 
2425  // loop over each requested factory, indexed by object name in lower case
2426  int assocCount = 0;
2427  set<string>::iterator iter;
2428  for(iter=evioMap[objNameLC].begin(); iter!=evioMap[objNameLC].end(); iter++) {
2429 
2430 
2431  // is there any data
2432  vector<const DTOFRawHitMC*> dataObjects;
2433  eventLoop->Get(dataObjects,(*iter).c_str());
2434  if(dataObjects.size()<=0)continue;
2435 
2436 
2437  // add track data to banks
2438  for(unsigned int i=0; i<dataObjects.size(); i++) {
2439  *objIdBank << dataObjects[i]->id;
2440  *var1Bank << dataObjects[i]->bar;
2441  *var2Bank << dataObjects[i]->plane;
2442  *var3Bank << dataObjects[i]->lr;
2443  *var4Bank << dataObjects[i]->dist;
2444  *var5Bank << dataObjects[i]->x;
2445  *var6Bank << dataObjects[i]->y;
2446  *var7Bank << dataObjects[i]->z;
2447  *var8Bank << dataObjects[i]->px;
2448  *var9Bank << dataObjects[i]->py;
2449  *var10Bank << dataObjects[i]->pz;
2450  *var11Bank << dataObjects[i]->E;
2451  *var12Bank << dataObjects[i]->ptype;
2452  *var13Bank << dataObjects[i]->itrack;
2453 
2454  objIdMap[dataObjects[i]->id]=dataObjects[i]->GetNameTag();
2455 
2456 
2457  // get associated object id bank and add to associated object bank
2458  evioDOMNodeP assocObjs = createLeafNode<uint64_t> (objName+".assocObjects");
2459  *assocBank << assocObjs;
2460 
2461  // get id's, add to id bank and to global object id map
2462  vector<const JObject*> objs;
2463  dataObjects[i]->GetT(objs);
2464  for(unsigned int j=0; j<objs.size(); j++) {
2465  assocCount++;
2466  *assocObjs << objs[j]->id;
2467  // objIdMap[objs[j]->id]=objs[j]->GetNameTag();
2468  }
2469  }
2470  }
2471  if(assocCount==0)assocBank->cutAndDelete();
2472 
2473 }
2474 
2475 
2476 //------------------------------------------------------------------------------
2477 
2478 
2479 void DDANAEVIO_factory::addDTOFHit(JEventLoop *eventLoop, evioDOMTree &tree) {
2480 
2481  string objName = "DTOFHit";
2482  string objNameLC(objName);
2483  std::transform(objNameLC.begin(), objNameLC.end(), objNameLC.begin(), (int(*)(int)) tolower);
2484 
2485 
2486  // create main bank and add to event tree
2487  evioDOMNodeP mainBank = createContainerNode(objName);
2488  tree << mainBank;
2489 
2490 
2491  // create data banks and add to bank
2492  evioDOMNodeP objIdBank = createLeafNode<uint64_t> (objName+".objId");
2493  evioDOMNodeP var1Bank = createLeafNode<int> (objName+".orientation");
2494  evioDOMNodeP var2Bank = createLeafNode<int> (objName+".bar");
2495  evioDOMNodeP var3Bank = createLeafNode<float> (objName+".t_north");
2496  evioDOMNodeP var4Bank = createLeafNode<float> (objName+".E_north");
2497  evioDOMNodeP var5Bank = createLeafNode<float> (objName+".t_south");
2498  evioDOMNodeP var6Bank = createLeafNode<float> (objName+".E_south");
2499  evioDOMNodeP var7Bank = createLeafNode<float> (objName+".meantime");
2500  evioDOMNodeP var8Bank = createLeafNode<float> (objName+".timediff");
2501  evioDOMNodeP var9Bank = createLeafNode<float> (objName+".pos");
2502  evioDOMNodeP var10Bank = createLeafNode<float> (objName+".dpos");
2503  evioDOMNodeP var11Bank = createLeafNode<float> (objName+".dE");
2504  *mainBank << objIdBank << var1Bank << var2Bank << var3Bank << var4Bank << var5Bank
2505  << var6Bank << var7Bank << var8Bank << var9Bank << var10Bank << var11Bank;
2506 
2507 
2508  // create associated object bank and add to main bank
2509  evioDOMNodeP assocBank = createContainerNode(objName+".assocObjectBanks");
2510  *mainBank << assocBank;
2511 
2512 
2513  // loop over each requested factory, indexed by object name in lower case
2514  int assocCount = 0;
2515  set<string>::iterator iter;
2516  for(iter=evioMap[objNameLC].begin(); iter!=evioMap[objNameLC].end(); iter++) {
2517 
2518 
2519  // is there any data
2520  vector<const DTOFHit*> dataObjects;
2521  eventLoop->Get(dataObjects,(*iter).c_str());
2522  if(dataObjects.size()<=0)continue;
2523 
2524 
2525  // add track data to banks
2526  for(unsigned int i=0; i<dataObjects.size(); i++) {
2527  *objIdBank << dataObjects[i]->id;
2528  *var1Bank << dataObjects[i]->orientation;
2529  *var2Bank << dataObjects[i]->bar;
2530  *var3Bank << dataObjects[i]->t_north;
2531  *var4Bank << dataObjects[i]->E_north;
2532  *var5Bank << dataObjects[i]->t_south;
2533  *var6Bank << dataObjects[i]->E_south;
2534  *var7Bank << dataObjects[i]->meantime;
2535  *var8Bank << dataObjects[i]->timediff;
2536  *var9Bank << dataObjects[i]->pos;
2537  *var10Bank << dataObjects[i]->dpos;
2538  *var11Bank << dataObjects[i]->dE;
2539 
2540  objIdMap[dataObjects[i]->id]=dataObjects[i]->GetNameTag();
2541 
2542 
2543  // get associated object id bank and add to associated object bank
2544  evioDOMNodeP assocObjs = createLeafNode<uint64_t> (objName+".assocObjects");
2545  *assocBank << assocObjs;
2546 
2547  // get id's, add to id bank and to global object id map
2548  vector<const JObject*> objs;
2549  dataObjects[i]->GetT(objs);
2550  for(unsigned int j=0; j<objs.size(); j++) {
2551  assocCount++;
2552  *assocObjs << objs[j]->id;
2553  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
2554  }
2555  }
2556  }
2557  if(assocCount==0)assocBank->cutAndDelete();
2558 
2559 }
2560 
2561 
2562 //------------------------------------------------------------------------------
2563 
2564 
2565 void DDANAEVIO_factory::addDTOFPoint(JEventLoop *eventLoop, evioDOMTree &tree) {
2566 
2567  string objName = "DTOFPoint";
2568  string objNameLC(objName);
2569  std::transform(objNameLC.begin(), objNameLC.end(), objNameLC.begin(), (int(*)(int)) tolower);
2570 
2571 
2572  // create main bank and add to event tree
2573  evioDOMNodeP mainBank = createContainerNode(objName);
2574  tree << mainBank;
2575 
2576 
2577  // create data banks and add to bank
2578  evioDOMNodeP objIdBank = createLeafNode<uint64_t> (objName+".objId");
2579  evioDOMNodeP var1Bank = createLeafNode<float> (objName+".x");
2580  evioDOMNodeP var2Bank = createLeafNode<float> (objName+".y");
2581  evioDOMNodeP var3Bank = createLeafNode<float> (objName+".z");
2582  evioDOMNodeP var4Bank = createLeafNode<float> (objName+".t");
2583  evioDOMNodeP var5Bank = createLeafNode<float> (objName+".dedx");
2584  evioDOMNodeP var6Bank = createLeafNode<float> (objName+".chisq");
2585  *mainBank << objIdBank << var1Bank << var2Bank << var3Bank << var4Bank << var5Bank << var6Bank;
2586 
2587 
2588  // create associated object bank and add to main bank
2589  evioDOMNodeP assocBank = createContainerNode(objName+".assocObjectBanks");
2590  *mainBank << assocBank;
2591 
2592 
2593  // loop over each requested factory, indexed by object name in lower case
2594  int assocCount = 0;
2595  set<string>::iterator iter;
2596  for(iter=evioMap[objNameLC].begin(); iter!=evioMap[objNameLC].end(); iter++) {
2597 
2598 
2599  // is there any data
2600  vector<const DTOFPoint*> dataObjects;
2601  eventLoop->Get(dataObjects,(*iter).c_str());
2602  if(dataObjects.size()<=0)continue;
2603 
2604 
2605  // add track data to banks
2606  for(unsigned int i=0; i<dataObjects.size(); i++) {
2607  *objIdBank << dataObjects[i]->id;
2608  *var1Bank << dataObjects[i]->pos.x();
2609  *var2Bank << dataObjects[i]->pos.y();
2610  *var3Bank << dataObjects[i]->pos.z();
2611  *var4Bank << dataObjects[i]->t;
2612  *var5Bank << dataObjects[i]->dedx;
2613  *var6Bank << dataObjects[i]->chisq;
2614 
2615  objIdMap[dataObjects[i]->id]=dataObjects[i]->GetNameTag();
2616 
2617 
2618  // get associated object id bank and add to associated object bank
2619  evioDOMNodeP assocObjs = createLeafNode<uint64_t> (objName+".assocObjects");
2620  *assocBank << assocObjs;
2621 
2622  // get id's, add to id bank and to global object id map
2623  vector<const JObject*> objs;
2624  dataObjects[i]->GetT(objs);
2625  for(unsigned int j=0; j<objs.size(); j++) {
2626  assocCount++;
2627  *assocObjs << objs[j]->id;
2628  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
2629  }
2630  }
2631  }
2632  if(assocCount==0)assocBank->cutAndDelete();
2633 
2634 }
2635 
2636 
2637 //------------------------------------------------------------------------------
2638 
2639 
2640 void DDANAEVIO_factory::addDBCALHit(JEventLoop *eventLoop, evioDOMTree &tree) {
2641 
2642  string objName = "DBCALHit";
2643  string objNameLC(objName);
2644  std::transform(objNameLC.begin(), objNameLC.end(), objNameLC.begin(), (int(*)(int)) tolower);
2645 
2646 
2647  // create main bank and add to event tree
2648  evioDOMNodeP mainBank = createContainerNode(objName);
2649  tree << mainBank;
2650 
2651 
2652  // create data banks and add to bank
2653  evioDOMNodeP objIdBank = createLeafNode<uint64_t> (objName+".objId");
2654  evioDOMNodeP var1Bank = createLeafNode<int> (objName+".module");
2655  evioDOMNodeP var2Bank = createLeafNode<int> (objName+".layer");
2656  evioDOMNodeP var3Bank = createLeafNode<int> (objName+".sector");
2657  evioDOMNodeP var4Bank = createLeafNode<string> (objName+".end");
2658  evioDOMNodeP var5Bank = createLeafNode<float> (objName+".E");
2659  evioDOMNodeP var6Bank = createLeafNode<float> (objName+".t");
2660  *mainBank << objIdBank << var1Bank << var2Bank << var3Bank << var4Bank << var5Bank << var6Bank;
2661 
2662 
2663  // create associated object bank and add to main bank
2664  evioDOMNodeP assocBank = createContainerNode(objName+".assocObjectBanks");
2665  *mainBank << assocBank;
2666 
2667 
2668  // loop over each requested factory, indexed by object name in lower case
2669  int assocCount = 0;
2670  set<string>::iterator iter;
2671  for(iter=evioMap[objNameLC].begin(); iter!=evioMap[objNameLC].end(); iter++) {
2672 
2673 
2674  // is there any data
2675  vector<const DBCALHit*> dataObjects;
2676  eventLoop->Get(dataObjects,(*iter).c_str());
2677  if(dataObjects.size()<=0)continue;
2678 
2679 
2680  // add track data to banks
2681  string s;
2682  for(unsigned int i=0; i<dataObjects.size(); i++) {
2683  *objIdBank << dataObjects[i]->id;
2684  *var1Bank << dataObjects[i]->module;
2685  *var2Bank << dataObjects[i]->layer;
2686  *var3Bank << dataObjects[i]->sector;
2687  *var4Bank << string((dataObjects[i]->end==DBCALGeometry::kUpstream) ? "upstream" : "downstream");
2688  *var5Bank << dataObjects[i]->E;
2689  *var6Bank << dataObjects[i]->t;
2690 
2691  objIdMap[dataObjects[i]->id]=dataObjects[i]->GetNameTag();
2692 
2693 
2694  // get associated object id bank and add to associated object bank
2695  evioDOMNodeP assocObjs = createLeafNode<uint64_t> (objName+".assocObjects");
2696  *assocBank << assocObjs;
2697 
2698  // get id's, add to id bank and to global object id map
2699  vector<const JObject*> objs;
2700  dataObjects[i]->GetT(objs);
2701  for(unsigned int j=0; j<objs.size(); j++) {
2702  assocCount++;
2703  *assocObjs << objs[j]->id;
2704  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
2705  }
2706  }
2707  }
2708  if(assocCount==0)assocBank->cutAndDelete();
2709 
2710 }
2711 
2712 
2713 //------------------------------------------------------------------------------
2714 
2715 
2716 void DDANAEVIO_factory::addDBCALShower(JEventLoop *eventLoop, evioDOMTree &tree) {
2717 
2718  string objName = "DBCALShower";
2719  string objNameLC(objName);
2720  std::transform(objNameLC.begin(), objNameLC.end(), objNameLC.begin(), (int(*)(int)) tolower);
2721 
2722 
2723  // create main bank and add to event tree
2724  evioDOMNodeP mainBank = createContainerNode(objName);
2725  tree << mainBank;
2726 
2727 
2728  // create data banks and add to bank
2729  evioDOMNodeP objIdBank = createLeafNode<uint64_t> (objName+".objId");
2730  evioDOMNodeP var1Bank = createLeafNode<float> (objName+".x");
2731  evioDOMNodeP var2Bank = createLeafNode<float> (objName+".y");
2732  evioDOMNodeP var3Bank = createLeafNode<float> (objName+".z");
2733  evioDOMNodeP var4Bank = createLeafNode<float> (objName+".t");
2734  evioDOMNodeP var5Bank = createLeafNode<float> (objName+".E");
2735  *mainBank << objIdBank << var1Bank << var2Bank << var3Bank << var4Bank << var5Bank;
2736 
2737 
2738  // create associated object bank and add to main bank
2739  evioDOMNodeP assocBank = createContainerNode(objName+".assocObjectBanks");
2740  *mainBank << assocBank;
2741 
2742 
2743  // loop over each requested factory, indexed by object name in lower case
2744  int assocCount = 0;
2745  set<string>::iterator iter;
2746  for(iter=evioMap[objNameLC].begin(); iter!=evioMap[objNameLC].end(); iter++) {
2747 
2748 
2749  // is there any data
2750  vector<const DBCALShower*> dataObjects;
2751  eventLoop->Get(dataObjects,(*iter).c_str());
2752  if(dataObjects.size()<=0)continue;
2753 
2754 
2755  // add track data to banks
2756  for(unsigned int i=0; i<dataObjects.size(); i++) {
2757  *objIdBank << dataObjects[i]->id;
2758  *var1Bank << dataObjects[i]->x;
2759  *var2Bank << dataObjects[i]->y;
2760  *var3Bank << dataObjects[i]->z;
2761  *var4Bank << dataObjects[i]->t;
2762  *var5Bank << dataObjects[i]->E;
2763 
2764  objIdMap[dataObjects[i]->id]=dataObjects[i]->GetNameTag();
2765 
2766 
2767  // get associated object id bank and add to associated object bank
2768  evioDOMNodeP assocObjs = createLeafNode<uint64_t> (objName+".assocObjects");
2769  *assocBank << assocObjs;
2770 
2771  // get id's, add to id bank and to global object id map
2772  vector<const JObject*> objs;
2773  dataObjects[i]->GetT(objs);
2774  for(unsigned int j=0; j<objs.size(); j++) {
2775  assocCount++;
2776  *assocObjs << objs[j]->id;
2777  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
2778  }
2779  }
2780  }
2781  if(assocCount==0)assocBank->cutAndDelete();
2782 
2783 }
2784 
2785 
2786 //------------------------------------------------------------------------------
2787 
2788 
2789 void DDANAEVIO_factory::addDFCALCluster(JEventLoop *eventLoop, evioDOMTree &tree) {
2790 
2791  string objName = "DFCALCluster";
2792  string objNameLC(objName);
2793  std::transform(objNameLC.begin(), objNameLC.end(), objNameLC.begin(), (int(*)(int)) tolower);
2794 
2795 
2796  // create main bank and add to event tree
2797  evioDOMNodeP mainBank = createContainerNode(objName);
2798  tree << mainBank;
2799 
2800 
2801  // create data banks and add to bank
2802  evioDOMNodeP objIdBank = createLeafNode<uint64_t> (objName+".objId");
2803  evioDOMNodeP var1Bank = createLeafNode<float> (objName+".x");
2804  evioDOMNodeP var2Bank = createLeafNode<float> (objName+".y");
2805  evioDOMNodeP var3Bank = createLeafNode<float> (objName+".E");
2806  evioDOMNodeP var4Bank = createLeafNode<float> (objName+".t");
2807  *mainBank << objIdBank << var1Bank << var2Bank << var3Bank << var4Bank;
2808 
2809 
2810  // create associated object bank and add to main bank
2811  evioDOMNodeP assocBank = createContainerNode(objName+".assocObjectBanks");
2812  *mainBank << assocBank;
2813 
2814 
2815  // loop over each requested factory, indexed by object name in lower case
2816  int assocCount = 0;
2817  set<string>::iterator iter;
2818  for(iter=evioMap[objNameLC].begin(); iter!=evioMap[objNameLC].end(); iter++) {
2819 
2820 
2821  // is there any data
2822  vector<const DFCALCluster*> dataObjects;
2823  eventLoop->Get(dataObjects,(*iter).c_str());
2824  if(dataObjects.size()<=0)continue;
2825 
2826 
2827  // add track data to banks
2828  for(unsigned int i=0; i<dataObjects.size(); i++) {
2829  *objIdBank << dataObjects[i]->id;
2830  *var1Bank << dataObjects[i]->getCentroid().x();
2831  *var2Bank << dataObjects[i]->getCentroid().y();
2832  *var3Bank << dataObjects[i]->getEnergy();
2833  *var4Bank << dataObjects[i]->getTime();
2834 
2835  objIdMap[dataObjects[i]->id]=dataObjects[i]->GetNameTag();
2836 
2837 
2838  // get associated object id bank and add to associated object bank
2839  evioDOMNodeP assocObjs = createLeafNode<uint64_t> (objName+".assocObjects");
2840  *assocBank << assocObjs;
2841 
2842  // get id's, add to id bank and to global object id map
2843  vector<const JObject*> objs;
2844  dataObjects[i]->GetT(objs);
2845  for(unsigned int j=0; j<objs.size(); j++) {
2846  assocCount++;
2847  *assocObjs << objs[j]->id;
2848  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
2849  }
2850  }
2851  }
2852  if(assocCount==0)assocBank->cutAndDelete();
2853 
2854 }
2855 
2856 
2857 //------------------------------------------------------------------------------
2858 
2859 
2860 void DDANAEVIO_factory::addDFDCCathodeCluster(JEventLoop *eventLoop, evioDOMTree &tree) {
2861 
2862  string objName = "DFDCCathodeCluster";
2863  string objNameLC(objName);
2864  std::transform(objNameLC.begin(), objNameLC.end(), objNameLC.begin(), (int(*)(int)) tolower);
2865 
2866 
2867  // create main bank and add to event tree
2868  evioDOMNodeP mainBank = createContainerNode(objName);
2869  tree << mainBank;
2870 
2871 
2872  // create data banks and add to bank
2873  evioDOMNodeP objIdBank = createLeafNode<uint64_t> (objName+".objId");
2874  evioDOMNodeP var1Bank = createLeafNode<int> (objName+".Nmembers");
2875  evioDOMNodeP var2Bank = createLeafNode<int> (objName+".plane");
2876  evioDOMNodeP var3Bank = createLeafNode<int> (objName+".gLayer");
2877  evioDOMNodeP var4Bank = createLeafNode<int> (objName+".gPlane");
2878  evioDOMNodeP var5Bank = createLeafNode<float> (objName+".q_tot");
2879  *mainBank << objIdBank << var1Bank << var2Bank << var3Bank << var4Bank << var5Bank;
2880 
2881 
2882  // create associated object bank and add to main bank
2883  evioDOMNodeP assocBank = createContainerNode(objName+".assocObjectBanks");
2884  *mainBank << assocBank;
2885 
2886 
2887  // loop over each requested factory, indexed by object name in lower case
2888  int assocCount = 0;
2889  set<string>::iterator iter;
2890  for(iter=evioMap[objNameLC].begin(); iter!=evioMap[objNameLC].end(); iter++) {
2891 
2892 
2893  // is there any data
2894  vector<const DFDCCathodeCluster*> dataObjects;
2895  eventLoop->Get(dataObjects,(*iter).c_str());
2896  if(dataObjects.size()<=0)continue;
2897 
2898 
2899  // add track data to banks
2900  for(unsigned int i=0; i<dataObjects.size(); i++) {
2901  *objIdBank << dataObjects[i]->id;
2902  *var1Bank << dataObjects[i]->members.size();
2903  *var2Bank << dataObjects[i]->plane;
2904  *var3Bank << dataObjects[i]->gLayer;
2905  *var4Bank << dataObjects[i]->gPlane;
2906  *var5Bank << dataObjects[i]->q_tot;
2907 
2908  objIdMap[dataObjects[i]->id]=dataObjects[i]->GetNameTag();
2909 
2910 
2911  // get associated object id bank and add to associated object bank
2912  evioDOMNodeP assocObjs = createLeafNode<uint64_t> (objName+".assocObjects");
2913  *assocBank << assocObjs;
2914 
2915  // get id's, add to id bank and to global object id map
2916  vector<const JObject*> objs;
2917  dataObjects[i]->GetT(objs);
2918  for(unsigned int j=0; j<objs.size(); j++) {
2919  assocCount++;
2920  *assocObjs << objs[j]->id;
2921  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
2922  }
2923  }
2924  }
2925  if(assocCount==0)assocBank->cutAndDelete();
2926 
2927 }
2928 
2929 
2930 //------------------------------------------------------------------------------
2931 
2932 
2933 void DDANAEVIO_factory::addDFDCSegment(JEventLoop *eventLoop, evioDOMTree &tree) {
2934 
2935  string objName = "DFDCSegment";
2936  string objNameLC(objName);
2937  std::transform(objNameLC.begin(), objNameLC.end(), objNameLC.begin(), (int(*)(int)) tolower);
2938 
2939 
2940  // create main bank and add to event tree
2941  evioDOMNodeP mainBank = createContainerNode(objName);
2942  tree << mainBank;
2943 
2944 
2945  // create data banks and add to bank
2946  evioDOMNodeP objIdBank = createLeafNode<uint64_t> (objName+".objId");
2947  evioDOMNodeP var1Bank = createLeafNode<float> (objName+".xc");
2948  evioDOMNodeP var2Bank = createLeafNode<float> (objName+".yc");
2949  evioDOMNodeP var3Bank = createLeafNode<float> (objName+".rc");
2950  evioDOMNodeP var4Bank = createLeafNode<float> (objName+".Phi1");
2951  evioDOMNodeP var5Bank = createLeafNode<int> (objName+".Nhits");
2952  *mainBank << objIdBank << var1Bank << var2Bank << var3Bank << var4Bank << var5Bank;
2953 
2954 
2955  // create associated object bank and add to main bank
2956  evioDOMNodeP assocBank = createContainerNode(objName+".assocObjectBanks");
2957  *mainBank << assocBank;
2958 
2959 
2960  // loop over each requested factory, indexed by object name in lower case
2961  int assocCount = 0;
2962  set<string>::iterator iter;
2963  for(iter=evioMap[objNameLC].begin(); iter!=evioMap[objNameLC].end(); iter++) {
2964 
2965 
2966  // is there any data
2967  vector<const DFDCSegment*> dataObjects;
2968  eventLoop->Get(dataObjects,(*iter).c_str());
2969  if(dataObjects.size()<=0)continue;
2970 
2971 
2972  // add track data to banks
2973  for(unsigned int i=0; i<dataObjects.size(); i++) {
2974  *objIdBank << dataObjects[i]->id;
2975  *var1Bank << dataObjects[i]->xc;
2976  *var2Bank << dataObjects[i]->yc;
2977  *var3Bank << dataObjects[i]->rc;
2978  *var4Bank << dataObjects[i]->Phi1;
2979  *var5Bank << dataObjects[i]->hits.size();
2980 
2981  objIdMap[dataObjects[i]->id]=dataObjects[i]->GetNameTag();
2982 
2983 
2984  // get associated object id bank and add to associated object bank
2985  evioDOMNodeP assocObjs = createLeafNode<uint64_t> (objName+".assocObjects");
2986  *assocBank << assocObjs;
2987 
2988  // get id's, add to id bank and to global object id map
2989  vector<const JObject*> objs;
2990  dataObjects[i]->GetT(objs);
2991  for(unsigned int j=0; j<objs.size(); j++) {
2992  assocCount++;
2993  *assocObjs << objs[j]->id;
2994  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
2995  }
2996  }
2997  }
2998  if(assocCount==0)assocBank->cutAndDelete();
2999 
3000 }
3001 
3002 
3003 //------------------------------------------------------------------------------
3004 
3005 
3006 void DDANAEVIO_factory::addDTAGMHit(JEventLoop *eventLoop, evioDOMTree &tree) {
3007 
3008  string objName = "DTAGMHit";
3009  string objNameLC(objName);
3010  std::transform(objNameLC.begin(), objNameLC.end(), objNameLC.begin(), (int(*)(int)) tolower);
3011 
3012 
3013  // create main bank and add to event tree
3014  evioDOMNodeP mainBank = createContainerNode(objName);
3015  tree << mainBank;
3016 
3017 
3018  // create data banks and add to bank
3019  evioDOMNodeP objIdBank = createLeafNode<uint64_t> (objName+".objId");
3020  evioDOMNodeP var1Bank = createLeafNode<int> (objName+".row");
3021  evioDOMNodeP var2Bank = createLeafNode<int> (objName+".column");
3022  evioDOMNodeP var3Bank = createLeafNode<float> (objName+".E");
3023  evioDOMNodeP var4Bank = createLeafNode<float> (objName+".t");
3024  *mainBank << objIdBank << var1Bank << var2Bank << var3Bank << var4Bank;
3025 
3026 
3027  // create associated object bank and add to main bank
3028  evioDOMNodeP assocBank = createContainerNode(objName+".assocObjectBanks");
3029  *mainBank << assocBank;
3030 
3031 
3032  // loop over each requested factory, indexed by object name in lower case
3033  int assocCount = 0;
3034  set<string>::iterator iter;
3035  for(iter=evioMap[objNameLC].begin(); iter!=evioMap[objNameLC].end(); iter++) {
3036 
3037 
3038  // is there any data
3039  vector<const DTAGMHit*> dataObjects;
3040  eventLoop->Get(dataObjects,(*iter).c_str());
3041  if(dataObjects.size()<=0)continue;
3042 
3043 
3044  // add track data to banks
3045  for(unsigned int i=0; i<dataObjects.size(); i++) {
3046  *objIdBank << dataObjects[i]->id;
3047  *var1Bank << dataObjects[i]->row;
3048  *var2Bank << dataObjects[i]->column;
3049  *var3Bank << dataObjects[i]->E;
3050  *var3Bank << dataObjects[i]->t;
3051 
3052 
3053  objIdMap[dataObjects[i]->id]=dataObjects[i]->GetNameTag();
3054 
3055 
3056  // get associated object id bank and add to associated object bank
3057  evioDOMNodeP assocObjs = createLeafNode<uint64_t> (objName+".assocObjects");
3058  *assocBank << assocObjs;
3059 
3060  // get id's, add to id bank and to global object id map
3061  vector<const JObject*> objs;
3062  dataObjects[i]->GetT(objs);
3063  for(unsigned int j=0; j<objs.size(); j++) {
3064  assocCount++;
3065  *assocObjs << objs[j]->id;
3066  objIdMap[objs[j]->id]=objs[j]->GetNameTag();
3067  }
3068  }
3069  }
3070  if(assocCount==0)assocBank->cutAndDelete();
3071 
3072 }
3073 
3074 
3075 //------------------------------------------------------------------------------
3076 
3077 
3078 
3079 
DDANAEVIO_factory::addDBCALPhoton
void addDBCALPhoton(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:2080
DTrackCandidate.h
danaObjs
static string danaObjs[]
Definition: DDANAEVIO_factory.cc:58
DTOFPoint.h
photon
Definition: photon.h:15
DTOFHit.h
DTAGMHit.h
DDANAEVIO_factory::setEVIOMap
void setEVIOMap(string danaevio)
Definition: DDANAEVIO_factory.cc:234
DDANAEVIO_factory::addDCDCHit
void addDCDCHit(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:942
DBCALShower.h
DDANAEVIO_factory::addDTOFRawHit
void addDTOFRawHit(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:2313
DFDCHit.h
DDANAEVIO_factory::addDFDCCathodeCluster
void addDFDCCathodeCluster(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:2860
DDANAEVIO_factory::addDVertex
void addDVertex(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:1928
DTrackTimeBased.h
DVector3
TVector3 DVector3
Definition: DVector3.h:14
DDANAEVIO_factory::addDCDCTrackHit
void addDCDCTrackHit(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:1772
DDANAEVIO_factory::get_tagNum_dictionary
void get_tagNum_dictionary(void)
Definition: DDANAEVIO_factory.cc:325
string
char string[256]
Definition: plot_epics_dump.C:24
DDANAEVIO_factory::addDChargedTruthMatch
void addDChargedTruthMatch(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:2240
DDANAEVIO_factory::addDMCThrown
void addDMCThrown(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:546
DDANAEVIO_factory::addDFCALTruthShower
void addDFCALTruthShower(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:788
DDANAEVIO_factory::getTagMapPointer
static const map< string, pair< uint16_t, uint8_t > > * getTagMapPointer()
Definition: DDANAEVIO_factory.cc:427
DApplication.h
DDANAEVIO_factory::addDBCALHit
void addDBCALHit(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:2640
DFDCSegment.h
DDANAEVIO_factory.h
size
Definition: DFDCPseudo.h:53
startElement
void startElement(void *data, const char *el, const char **attr)
Definition: hddm2root.cc:221
DDANAEVIO_factory::addDTOFHit
void addDTOFHit(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:2479
DFDCCathodeCluster.h
DBCALTruthShower.h
DDANAEVIO_factory::addDBCALShower
void addDBCALShower(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:2716
DDANAEVIO_factory::addDFDCPseudo
void addDFDCPseudo(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:1847
f
TF1 * f
Definition: FitGains.C:21
DFCALHit.h
DTrackWireBased.h
DDANAEVIO_factory::addDSCHit
void addDSCHit(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:1399
DDANAEVIO_factory::addDTOFTruth
void addDTOFTruth(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:706
DDANAEVIO_factory::addDFCALHit
void addDFCALHit(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:1329
DDANAEVIO_factory::addObjIdBank
void addObjIdBank(evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:519
DDANAEVIO_factory::createContainerNode
evioDOMNodeP createContainerNode(string nameId)
Definition: DDANAEVIO_factory.cc:510
DDANAEVIO_factory::addDMCTrackHit
void addDMCTrackHit(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:633
DDANAEVIO_factory::addDFCALCluster
void addDFCALCluster(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:2789
DDANAEVIO_factory::addDBCALTruthShower
void addDBCALTruthShower(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:869
DDANAEVIO_factory::addDPhoton
void addDPhoton(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:1695
DMCTrajectoryPoint.h
DSCHit.h
DTAGHHit.h
DDANAEVIO_factory::addDChargedTrack
void addDChargedTrack(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:1629
DDANAEVIO_factory::addDFDCSegment
void addDFDCSegment(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:2933
DBCALHit.h
DDANAEVIO_factory::addDTOFRawHitMC
void addDTOFRawHitMC(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:2387
DBCALGeometry.h
DDANAEVIO_factory::startElement
static void startElement(void *userData, const char *xmlname, const char **atts)
Definition: DDANAEVIO_factory.cc:396
DBeamPhoton.h
DMCTrackHit.h
DDANAEVIO_factory::addDSCTruthHit
void addDSCTruthHit(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:1252
DDANAEVIO_factory::DDANAEVIO_factory
DDANAEVIO_factory()
Definition: DDANAEVIO_factory.cc:176
DDANAEVIO_factory::addDFDCHit
void addDFDCHit(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:1095
DDANAEVIO_factory::addDTrackWireBased
void addDTrackWireBased(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:1463
DFCALTruthShower.h
DSCTruthHit.h
DDANAEVIO_factory::evnt
jerror_t evnt(JEventLoop *eventLoop, uint64_t eventnumber)
Definition: DDANAEVIO_factory.cc:435
DDANAEVIO_factory::addDBeamPhoton
void addDBeamPhoton(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:1174
initMutex
static pthread_mutex_t initMutex
Definition: DDANAEVIO_factory.cc:169
SplitString.h
DFCALCluster.h
DDANAEVIO_factory::addDTrackCandidate
void addDTrackCandidate(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:2012
DVertex.h
tagMap
static map< string, pair< uint16_t, uint8_t > > tagMap
Definition: DDANAEVIO_factory.cc:165
DDANAEVIO_factory::addDTOFPoint
void addDTOFPoint(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:2565
DDANAEVIO_factory::createLeafNode
evioDOMNodeP createLeafNode(string nameId)
Definition: DDANAEVIO_factory.cc:500
DDANAEVIO_factory::addDTrackTimeBased
void addDTrackTimeBased(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:1544
DMCThrown.h
DChargedTrack.h
DDANAEVIO_factory::addDMCTrajectoryPoint
void addDMCTrajectoryPoint(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:1008
DCDCHit.h
DDANAEVIO_factory::addDTAGMHit
void addDTAGMHit(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:3006
DTOFTruth.h
DDANAEVIO_factory::addDFCALPhoton
void addDFCALPhoton(JEventLoop *eventLoop, evioDOMTree &tree)
Definition: DDANAEVIO_factory.cc:2160