StRoot: StEvent/StEventClusteringHints.cxx Source File

00001 /***************************************************************************
00002  *
00003  * $Id: StEventClusteringHints.cxx,v 2.31 2012/04/16 20:28:37 ullrich Exp $
00004  *
00005  * Author: Thomas Ullrich, Apr 2001
00006  ***************************************************************************
00007  *
00008  * Description:
00009  *
00010  ***************************************************************************
00011  *
00012  * $Log: StEventClusteringHints.cxx,v $
00013  * Revision 2.31  2012/04/16 20:28:37  ullrich
00014  * Added StFgtCollection.
00015  *
00016  * Revision 2.30  2012/01/24 03:03:13  perev
00017  * Open for new detectors
00018  *
00019  * Revision 2.29  2011/11/04 19:19:33  ullrich
00020  * Added StTriggerData2012.
00021  *
00022  * Revision 2.28  2011/10/13 17:52:52  perev
00023  * Fgt added
00024  *
00025  * Revision 2.27  2011/04/27 22:28:46  ullrich
00026  * Add MTD.
00027  *
00028  * Revision 2.26  2011/02/01 19:47:36  ullrich
00029  * Added HLT branch and hooks.
00030  *
00031  * Revision 2.25  2010/08/31 19:55:38  fisyak
00032  * Remove SoftwareMonitors
00033  *
00034  * Revision 2.24  2010/04/07 14:40:27  ullrich
00035  * Added StTriggerData2009.
00036  *
00037  * Revision 2.23  2010/01/08 22:43:44  ullrich
00038  * Updates needed to add StFmsCollection and related classes.
00039  *
00040  * Revision 2.22  2009/11/23 22:22:25  ullrich
00041  * Minor cleanup performed and hooks for RPS added.
00042  *
00043  * Revision 2.21  2008/12/22 20:36:54  ullrich
00044  * Added hooks for new ToF (BTof)
00045  *
00046  * Revision 2.20  2007/11/19 19:31:42  ullrich
00047  *  Added class StTriggerData2008.
00048  *
00049  * Revision 2.19  2007/02/24 03:03:02  ullrich
00050  * Added StTriggerData2007.
00051  *
00052  * Revision 2.18  2006/01/19 21:51:51  ullrich
00053  * Added RnD collection.
00054  *
00055  * Revision 2.17  2004/11/02 21:19:25  ullrich
00056  * Added StTriggerData2005 class.
00057  *
00058  * Revision 2.16  2003/12/23 21:58:28  ullrich
00059  * Modifications to handle StTruggerData2004.
00060  *
00061  * Revision 2.15  2003/10/02 16:39:25  jeromel
00062  * Unitialized data member mNameMap
00063  *
00064  * Revision 2.14  2003/07/25 19:47:37  ullrich
00065  * Added StSPtrVecCalibrationVertex to I/O list.
00066  *
00067  * Revision 2.13  2003/04/16 17:48:32  ullrich
00068  * Added StTriggerData and inherited classe(s).
00069  *
00070  * Revision 2.12  2003/01/30 18:37:55  ullrich
00071  * Added Phmd and TriggerId stuff.
00072  *
00073  * Revision 2.11  2002/12/20 22:41:30  ullrich
00074  * Added PMD.
00075  *
00076  * Revision 2.10  2002/02/19 16:42:05  ullrich
00077  * Fixed bug: StDetectorState now StSPtrVecDetectorState.
00078  *
00079  * Revision 2.9  2002/01/03 20:59:33  ullrich
00080  * Added BBC and FPD.
00081  *
00082  * Revision 2.8  2001/12/01 15:41:55  ullrich
00083  * Added StDetectorState container hints.
00084  *
00085  * Revision 2.7  2001/11/07 21:19:43  ullrich
00086  * Added L1 trigger.
00087  *
00088  * Revision 2.6  2001/10/15 23:15:50  ullrich
00089  * Added StRunInfo.
00090  *
00091  * Revision 2.5  2001/05/30 17:45:54  perev
00092  * StEvent branching
00093  *
00094  * Revision 2.4  2001/05/01 03:48:28  ullrich
00095  * Added branch IDs.
00096  *
00097  * Revision 2.3  2001/04/23 19:28:53  ullrich
00098  * Inherit from StObject. Not a singleton anymore.
00099  *
00100  * Revision 2.2  2001/04/20 00:50:48  ullrich
00101  * Added new query methods.
00102  *
00103  * Revision 2.1  2001/04/06 17:47:20  ullrich
00104  * Initial Revision
00105  *
00106  **************************************************************************/
00107 #include "StEventClusteringHints.h"
00108 #include <algorithm>
00109 
00110 static const char rcsid[] = "$Id: StEventClusteringHints.cxx,v 2.31 2012/04/16 20:28:37 ullrich Exp $";
00111 
00112 ClassImp(StEventClusteringHints)
00113 
00114 StEventClusteringHints::~StEventClusteringHints() {/*noop*/}
00115 
00116 StEventClusteringHints::StEventClusteringHints()
00117 {
00118     fParent = 0;
00119     mNameMap= 0;
00120 
00121     setMiniDstMode();
00122     setBranch("StRunInfo",                   "evt_header",   2);
00123     setBranch("StEventInfo",                 "evt_header",   2);
00124     setBranch("StEventSummary",              "evt_header",   2);
00125     setBranch("StSPtrVecDetectorState",      "evt_header",   2);
00126     setBranch("StEventClusteringHints",      "evt_header",   2);
00127     setBranch("StL0Trigger",                 "evt_trigger",  3);
00128     setBranch("StL1Trigger",                 "evt_trigger",  3);
00129     setBranch("StL3Trigger",                 "evt_trigger",  3);
00130     setBranch("StTriggerDetectorCollection", "evt_trigger",  3);
00131     setBranch("StTriggerIdCollection",       "evt_trigger",  3);
00132     setBranch("StTriggerData",               "evt_trigger",  3);
00133     setBranch("StTriggerData2003",           "evt_trigger",  3);
00134     setBranch("StTriggerData2004",           "evt_trigger",  3);
00135     setBranch("StTriggerData2005",           "evt_trigger",  3);
00136     setBranch("StTriggerData2007",           "evt_trigger",  3);
00137     setBranch("StTriggerData2008",           "evt_trigger",  3);
00138     setBranch("StTriggerData2009",           "evt_trigger",  3);
00139     setBranch("StTriggerData2012",           "evt_trigger",  3);
00140     setBranch("StSPtrVecTrackDetectorInfo",  "evt_tracks",   4);
00141     setBranch("StSPtrVecPrimaryVertex",      "evt_tracks",   4);
00142     setBranch("StSPtrVecTrackNode",          "evt_tracks",   4);
00143     setBranch("StSPtrVecKinkVertex",         "evt_vertices", 5);
00144     setBranch("StSPtrVecV0Vertex",           "evt_vertices", 5);
00145     setBranch("StSPtrVecXiVertex",           "evt_vertices", 5);
00146     setBranch("StSPtrVecCalibrationVertex",  "evt_vertices", 5);
00147     setBranch("StEmcCollection",             "evt_emc",      6);
00148     setBranch("StFmsCollection",             "evt_emc",      6);
00149     setBranch("StRichCollection",            "evt_aux",      7);
00150     setBranch("StTofCollection",             "evt_aux",      7);
00151     setBranch("StBTofCollection",            "evt_aux",      7);
00152     setBranch("StMtdCollection",             "evt_aux",      7);
00153     setBranch("StFpdCollection",             "evt_aux",      7);
00154     setBranch("StPhmdCollection",            "evt_aux",      7);
00155     setBranch("StRpsCollection",             "evt_aux",      7);
00156     setBranch("StSsdHitCollection",          "evt_hits",     8);
00157     setBranch("StSvtHitCollection",          "evt_hits",     8);
00158     setBranch("StTpcHitCollection",          "evt_hits",     8);
00159     setBranch("StFtpcHitCollection",         "evt_hits",     8);
00160     setBranch("StRnDHitCollection",          "evt_hits",     8);
00161     setBranch("StHltEvent",                  "evt_hlt",      9);
00162     setBranch("StFgtCollection",             "evt_fgt",      9);
00163     
00164     setDstMode();
00165     setBranch("StRunInfo",                   "event", 1);
00166     setBranch("StEventInfo",                 "event", 1);
00167     setBranch("StEventSummary",              "event", 1);
00168     setBranch("StSPtrVecDetectorState",      "event", 1);
00169     setBranch("StEventClusteringHints",      "event", 1);
00170     setBranch("StEmcCollection",             "event", 1);
00171     setBranch("StFmsCollection",             "event", 1);
00172     setBranch("StRichCollection",            "event", 1);
00173     setBranch("StTofCollection",             "event", 1);
00174     setBranch("StBTofCollection",            "event", 1);
00175     setBranch("StMtdCollection",             "event", 1);
00176     setBranch("StFpdCollection",             "event", 1);
00177     setBranch("StRpsCollection",             "event", 1);
00178     setBranch("StSsdHitCollection",          "event", 1);
00179     setBranch("StSvtHitCollection",          "event", 1);
00180     setBranch("StTpcHitCollection",          "event", 1);
00181     setBranch("StFtpcHitCollection",         "event", 1);
00182     setBranch("StL0Trigger",                 "event", 1);
00183     setBranch("StL1Trigger",                 "event", 1);
00184     setBranch("StL3Trigger",                 "event", 1);
00185     setBranch("StTriggerDetectorCollection", "event", 1);
00186     setBranch("StTriggerIdCollection",       "event", 1);
00187     setBranch("StTriggerData",               "event", 1);
00188     setBranch("StTriggerData2003",           "event", 1);
00189     setBranch("StTriggerData2004",           "event", 1);
00190     setBranch("StTriggerData2005",           "event", 1);
00191     setBranch("StTriggerData2007",           "event", 1);
00192     setBranch("StTriggerData2008",           "event", 1);
00193     setBranch("StTriggerData2009",           "event", 1);
00194     setBranch("StTriggerData2012",           "event", 1);
00195     setBranch("StSPtrVecKinkVertex",         "event", 1);
00196     setBranch("StSPtrVecV0Vertex",           "event", 1);
00197     setBranch("StSPtrVecXiVertex",           "event", 1);
00198     setBranch("StSPtrVecTrackDetectorInfo",  "event", 1);
00199     setBranch("StSPtrVecCalibrationVertex",  "event", 1);
00200     setBranch("StSPtrVecPrimaryVertex",      "event", 1);
00201     setBranch("StSPtrVecTrackNode",          "event", 1);
00202     setBranch("StPhmdCollection",            "event", 1);
00203     setBranch("StRnDHitCollection",          "event", 1);
00204     setBranch("StHltEvent",                  "event", 1);
00205     setBranch("StFgtCollection",             "event", 1);
00206 } 
00207 
00208 void
00209 StEventClusteringHints::setDstMode()
00210 { 
00211   if (mNameMap == &mDstMap) return;
00212   mNameMap = &mDstMap;
00213   if (fParent) fParent->Notify();
00214 }
00215 
00216 void
00217 StEventClusteringHints::setMiniDstMode()
00218 {
00219   if (mNameMap == &mMiniDstMap) return;
00220   mNameMap = &mMiniDstMap;
00221   if (fParent) fParent->Notify();
00222 }
00223 const char*
00224 StEventClusteringHints::branchName(const char* classname) const
00225 {
00226     if (strstr(classname,"Hit")) return "evt_hits";
00227     map<string,string>::const_iterator i = mNameMap->find(string(classname));
00228     return i != mNameMap->end() ? i->second.c_str() : "event";
00229 }
00230 
00231 void
00232 StEventClusteringHints::setBranch(const char* classname, const char* branchname, int id)
00233 {
00234     (*mNameMap)[string(classname)] = string(branchname);
00235     mBranchIds[string(branchname)] = id;
00236     if (fParent) fParent->Notify();
00237     
00238 }
00239 
00240 int
00241 StEventClusteringHints::branchId(const char* branchname) const
00242 {
00243     map<string,int>::const_iterator i = mBranchIds.find(string(branchname));
00244     return i != mBranchIds.end() ? i->second : 1;  
00245 }
00246 
00247 vector<string>
00248 StEventClusteringHints::listOfBranches() const
00249 {
00250     vector<string> result, tmp;
00251     map<string,string>::iterator i;
00252     for (i = mNameMap->begin(); i != mNameMap->end(); i++)
00253         tmp.push_back(i->second);
00254     sort(tmp.begin(), tmp.end());
00255     insert_iterator<vector<string> > ins(result, result.begin());
00256     unique_copy(tmp.begin(), tmp.end(), ins);
00257     return result;
00258 }
00259 
00260 vector<string>
00261 StEventClusteringHints::listOfClasses() const
00262 {
00263     vector<string> result;
00264     map<string,string>::iterator i;
00265     for (i = mNameMap->begin(); i != mNameMap->end(); i++)
00266         result.push_back(i->first);
00267     sort(result.begin(), result.end());    
00268     return result;
00269 }
00270 
00271 vector<string>
00272 StEventClusteringHints::listOfClasses(const char* branchname) const
00273 {
00274     vector<string> result;
00275     map<string,string>::iterator i;
00276     for (i = mNameMap->begin(); i != mNameMap->end(); i++)
00277         if (string(branchname) == i->second) result.push_back(i->first);
00278     sort(result.begin(), result.end());    
00279     return result;
00280 }
00281 
00282 void
00283 StEventClusteringHints::print(ostream& os)
00284 {
00285     vector<string> branches = listOfBranches();
00286     for (unsigned int j=0; j<branches.size(); j++) {
00287         vector<string> classes = listOfClasses(branches[j].c_str());
00288         cout << branches[j] << "[id=" << branchId(branches[j].c_str()) << "]" << endl;
00289         for (unsigned int k=0; k<classes.size(); k++)
00290             cout << '\t' << classes[k] << endl;
00291     }
00292 }
00293 
00294 static TBuffer&  operator<<(TBuffer& buf, const map<string,string> &s)
00295 {
00296   TString ts1,ts2;
00297   map<string,string>::const_iterator i;
00298   buf << s.size();
00299   for (i = s.begin(); i != s.end(); i++){
00300     ts1 = i->first. c_str(); ts1.Streamer(buf);
00301     ts2 = i->second.c_str(); ts2.Streamer(buf);}
00302   return buf;
00303 }
00304 
00305 static TBuffer&  operator>>(TBuffer& buf,      map<string,string> & s)
00306 {
00307   TString ts1,ts2; int i,size;
00308   buf >> size;
00309   for (i = 0;i<size;i++){
00310     ts1.Streamer(buf); ts2.Streamer(buf);
00311     s[string(ts1.Data())] = string(ts2.Data());}  
00312   return buf;
00313 }
00314    
00315 static TBuffer&  operator<<(TBuffer& buf, const map<string,int> &s)
00316 {
00317   TString ts1;
00318   map<string,int>::const_iterator i;
00319   int size = s.size();buf << size;
00320   for (i = s.begin(); i != s.end(); i++){
00321     ts1 = i->first.c_str(); ts1.Streamer(buf);
00322     buf << i->second;}
00323   return buf;
00324 }
00325 
00326 static TBuffer&  operator>>(TBuffer& buf,      map<string,int> & s)
00327 {
00328   TString ts1;
00329   int i,size,ii;
00330   buf >> size;
00331   for (i = 0;i<size;i++){
00332     ts1.Streamer(buf); buf>>ii;
00333     s[string(ts1.Data())] = ii;}
00334   return buf;
00335 }
00336 
00337 
00338 
00339 void StEventClusteringHints::Streamer(TBuffer &R__b)
00340 {
00341 // Stream an object of class StEventClusteringHints
00342 
00343    UChar_t mode;
00344    UInt_t R__s, R__c;
00345    if (R__b.IsReading()) {
00346       Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
00347       R__b >> mode; mNameMap=(mode)? &mMiniDstMap:&mDstMap;
00348       R__b >>  mDstMap;     
00349       R__b >>  mMiniDstMap;     
00350       R__b >>  mBranchIds;
00351       R__b.CheckByteCount(R__s, R__c, Class());  
00352       
00353    } else { /*writing*/   
00354       R__c = R__b.WriteVersion(Class(), kTRUE);
00355       mode = (mNameMap == &mMiniDstMap);
00356       R__b <<  mode;     
00357       R__b <<  mDstMap;     
00358       R__b <<  mMiniDstMap;     
00359       R__b <<  mBranchIds;
00360       R__b.SetByteCount(R__c, kTRUE);
00361    }
00362 }