diff --git a/core/base/inc/Rtypes.h b/core/base/inc/Rtypes.h index 47e0219f8d3dd..345e82a30f1ee 100644 --- a/core/base/inc/Rtypes.h +++ b/core/base/inc/Rtypes.h @@ -76,6 +76,7 @@ typedef float Float_t; //Float 4 bytes (float) typedef float Float16_t; //Float 4 bytes written with a truncated mantissa typedef double Double_t; //Double 8 bytes typedef double Double32_t; //Double 8 bytes in memory, written as a 4 bytes float +typedef long double LongDouble_t;//Long Double typedef char Text_t; //General string (char) typedef bool Bool_t; //Boolean (0=false, 1=true) (bool) typedef unsigned char Byte_t; //Byte (8 bits) (unsigned char) diff --git a/io/io/inc/TStreamerInfo.h b/io/io/inc/TStreamerInfo.h index d0955971cee65..044538ba77ffc 100644 --- a/io/io/inc/TStreamerInfo.h +++ b/io/io/inc/TStreamerInfo.h @@ -113,7 +113,7 @@ class TStreamerInfo : public TVirtualStreamerInfo { static Int_t fgCount; //Number of TStreamerInfo instances static TStreamerElement *fgElement; //Pointer to current TStreamerElement - static Double_t GetValueAux(Int_t type, void *ladd, int k, Int_t len); + template static T GetTypedValueAux(Int_t type, void *ladd, int k, Int_t len); static void PrintValueAux(char *ladd, Int_t atype, TStreamerElement * aElement, Int_t aleng, Int_t *count); UInt_t GenerateIncludes(FILE *fp, char *inclist, const TList *extrainfos); @@ -220,10 +220,14 @@ class TStreamerInfo : public TVirtualStreamerInfo { TStreamerElement *GetStreamerElement(const char*datamember, Int_t& offset) const; TStreamerElement *GetStreamerElementReal(Int_t i, Int_t j) const; Int_t *GetTypes() const {return fType;} - Double_t GetValue(char *pointer, Int_t i, Int_t j, Int_t len) const; - Double_t GetValueClones(TClonesArray *clones, Int_t i, Int_t j, Int_t k, Int_t eoffset) const; - Double_t GetValueSTL(TVirtualCollectionProxy *cont, Int_t i, Int_t j, Int_t k, Int_t eoffset) const; - Double_t GetValueSTLP(TVirtualCollectionProxy *cont, Int_t i, Int_t j, Int_t k, Int_t eoffset) const; + template T GetTypedValue(char *pointer, Int_t i, Int_t j, Int_t len) const; + template T GetTypedValueClones(TClonesArray *clones, Int_t i, Int_t j, Int_t k, Int_t eoffset) const; + template T GetTypedValueSTL(TVirtualCollectionProxy *cont, Int_t i, Int_t j, Int_t k, Int_t eoffset) const; + template T GetTypedValueSTLP(TVirtualCollectionProxy *cont, Int_t i, Int_t j, Int_t k, Int_t eoffset) const; + Double_t GetValue(char *pointer, Int_t i, Int_t j, Int_t len) const { return GetTypedValue(pointer, i, j, len); } + Double_t GetValueClones(TClonesArray *clones, Int_t i, Int_t j, Int_t k, Int_t eoffset) const { return GetTypedValueClones(clones, i, j, k, eoffset); } + Double_t GetValueSTL(TVirtualCollectionProxy *cont, Int_t i, Int_t j, Int_t k, Int_t eoffset) const { return GetTypedValueSTL(cont, i, j, k, eoffset); } + Double_t GetValueSTLP(TVirtualCollectionProxy *cont, Int_t i, Int_t j, Int_t k, Int_t eoffset) const { return GetTypedValueSTLP(cont, i, j, k, eoffset); } void ls(Option_t *option="") const; TVirtualStreamerInfo *NewInfo(TClass *cl) {return new TStreamerInfo(cl);} void *New(void *obj = 0); diff --git a/io/io/src/TStreamerInfo.cxx b/io/io/src/TStreamerInfo.cxx index 8b6c9a9d6c921..fe97b65839c6d 100644 --- a/io/io/src/TStreamerInfo.cxx +++ b/io/io/src/TStreamerInfo.cxx @@ -3485,7 +3485,8 @@ TStreamerElement* TStreamerInfo::GetStreamerElementReal(Int_t i, Int_t j) const } //______________________________________________________________________________ -Double_t TStreamerInfo::GetValueAux(Int_t type, void *ladd, Int_t k, Int_t len) +template +T TStreamerInfo::GetTypedValueAux(Int_t type, void *ladd, Int_t k, Int_t len) { // Get the value from inside a collection. @@ -3494,46 +3495,46 @@ Double_t TStreamerInfo::GetValueAux(Int_t type, void *ladd, Int_t k, Int_t len) } switch (type) { // basic types - case kBool: {Bool_t *val = (Bool_t*)ladd; return Double_t(*val);} - case kChar: {Char_t *val = (Char_t*)ladd; return Double_t(*val);} - case kShort: {Short_t *val = (Short_t*)ladd; return Double_t(*val);} - case kInt: {Int_t *val = (Int_t*)ladd; return Double_t(*val);} - case kLong: {Long_t *val = (Long_t*)ladd; return Double_t(*val);} - case kLong64: {Long64_t *val = (Long64_t*)ladd; return Double_t(*val);} - case kFloat: {Float_t *val = (Float_t*)ladd; return Double_t(*val);} - case kFloat16: {Float_t *val = (Float_t*)ladd; return Double_t(*val);} - case kDouble: {Double_t *val = (Double_t*)ladd; return Double_t(*val);} - case kDouble32: {Double_t *val = (Double_t*)ladd; return Double_t(*val);} - case kUChar: {UChar_t *val = (UChar_t*)ladd; return Double_t(*val);} - case kUShort: {UShort_t *val = (UShort_t*)ladd; return Double_t(*val);} - case kUInt: {UInt_t *val = (UInt_t*)ladd; return Double_t(*val);} - case kULong: {ULong_t *val = (ULong_t*)ladd; return Double_t(*val);} + case kBool: {Bool_t *val = (Bool_t*)ladd; return T(*val);} + case kChar: {Char_t *val = (Char_t*)ladd; return T(*val);} + case kShort: {Short_t *val = (Short_t*)ladd; return T(*val);} + case kInt: {Int_t *val = (Int_t*)ladd; return T(*val);} + case kLong: {Long_t *val = (Long_t*)ladd; return T(*val);} + case kLong64: {Long64_t *val = (Long64_t*)ladd; return T(*val);} + case kFloat: {Float_t *val = (Float_t*)ladd; return T(*val);} + case kFloat16: {Float_t *val = (Float_t*)ladd; return T(*val);} + case kDouble: {Double_t *val = (Double_t*)ladd; return T(*val);} + case kDouble32: {Double_t *val = (Double_t*)ladd; return T(*val);} + case kUChar: {UChar_t *val = (UChar_t*)ladd; return T(*val);} + case kUShort: {UShort_t *val = (UShort_t*)ladd; return T(*val);} + case kUInt: {UInt_t *val = (UInt_t*)ladd; return T(*val);} + case kULong: {ULong_t *val = (ULong_t*)ladd; return T(*val);} #if defined(_MSC_VER) && (_MSC_VER <= 1200) - case kULong64: {Long64_t *val = (Long64_t*)ladd; return Double_t(*val);} + case kULong64: {Long64_t *val = (Long64_t*)ladd; return T(*val);} #else - case kULong64: {ULong64_t *val= (ULong64_t*)ladd; return Double_t(*val);} + case kULong64: {ULong64_t *val= (ULong64_t*)ladd; return T(*val);} #endif - case kBits: {UInt_t *val = (UInt_t*)ladd; return Double_t(*val);} + case kBits: {UInt_t *val = (UInt_t*)ladd; return T(*val);} // array of basic types array[8] - case kOffsetL + kBool: {Bool_t *val = (Bool_t*)ladd; return Double_t(val[k]);} - case kOffsetL + kChar: {Char_t *val = (Char_t*)ladd; return Double_t(val[k]);} - case kOffsetL + kShort: {Short_t *val = (Short_t*)ladd; return Double_t(val[k]);} - case kOffsetL + kInt: {Int_t *val = (Int_t*)ladd; return Double_t(val[k]);} - case kOffsetL + kLong: {Long_t *val = (Long_t*)ladd; return Double_t(val[k]);} - case kOffsetL + kLong64: {Long64_t *val = (Long64_t*)ladd; return Double_t(val[k]);} - case kOffsetL + kFloat: {Float_t *val = (Float_t*)ladd; return Double_t(val[k]);} - case kOffsetL + kFloat16: {Float_t *val = (Float_t*)ladd; return Double_t(val[k]);} - case kOffsetL + kDouble: {Double_t *val = (Double_t*)ladd; return Double_t(val[k]);} - case kOffsetL + kDouble32:{Double_t *val = (Double_t*)ladd; return Double_t(val[k]);} - case kOffsetL + kUChar: {UChar_t *val = (UChar_t*)ladd; return Double_t(val[k]);} - case kOffsetL + kUShort: {UShort_t *val = (UShort_t*)ladd; return Double_t(val[k]);} - case kOffsetL + kUInt: {UInt_t *val = (UInt_t*)ladd; return Double_t(val[k]);} - case kOffsetL + kULong: {ULong_t *val = (ULong_t*)ladd; return Double_t(val[k]);} + case kOffsetL + kBool: {Bool_t *val = (Bool_t*)ladd; return T(val[k]);} + case kOffsetL + kChar: {Char_t *val = (Char_t*)ladd; return T(val[k]);} + case kOffsetL + kShort: {Short_t *val = (Short_t*)ladd; return T(val[k]);} + case kOffsetL + kInt: {Int_t *val = (Int_t*)ladd; return T(val[k]);} + case kOffsetL + kLong: {Long_t *val = (Long_t*)ladd; return T(val[k]);} + case kOffsetL + kLong64: {Long64_t *val = (Long64_t*)ladd; return T(val[k]);} + case kOffsetL + kFloat: {Float_t *val = (Float_t*)ladd; return T(val[k]);} + case kOffsetL + kFloat16: {Float_t *val = (Float_t*)ladd; return T(val[k]);} + case kOffsetL + kDouble: {Double_t *val = (Double_t*)ladd; return T(val[k]);} + case kOffsetL + kDouble32:{Double_t *val = (Double_t*)ladd; return T(val[k]);} + case kOffsetL + kUChar: {UChar_t *val = (UChar_t*)ladd; return T(val[k]);} + case kOffsetL + kUShort: {UShort_t *val = (UShort_t*)ladd; return T(val[k]);} + case kOffsetL + kUInt: {UInt_t *val = (UInt_t*)ladd; return T(val[k]);} + case kOffsetL + kULong: {ULong_t *val = (ULong_t*)ladd; return T(val[k]);} #if defined(_MSC_VER) && (_MSC_VER <= 1200) - case kOffsetL + kULong64: {Long64_t *val = (Long64_t*)ladd; return Double_t(val[k]);} + case kOffsetL + kULong64: {Long64_t *val = (Long64_t*)ladd; return T(val[k]);} #else - case kOffsetL + kULong64:{ULong64_t *val= (ULong64_t*)ladd; return Double_t(val[k]);} + case kOffsetL + kULong64:{ULong64_t *val= (ULong64_t*)ladd; return T(val[k]);} #endif #define READ_ARRAY(TYPE_t) \ @@ -3548,7 +3549,7 @@ Double_t TStreamerInfo::GetValueAux(Int_t type, void *ladd, Int_t k, Int_t len) sub_instance = 0; \ } \ TYPE_t **val =(TYPE_t**)(ladd); \ - return Double_t((val[sub_instance])[index]); \ + return T((val[sub_instance])[index]); \ } // pointer to an array of basic types array[n] @@ -3573,13 +3574,18 @@ Double_t TStreamerInfo::GetValueAux(Int_t type, void *ladd, Int_t k, Int_t len) #endif // array counter //[n] - case kCounter: {Int_t *val = (Int_t*)ladd; return Double_t(*val);} + case kCounter: {Int_t *val = (Int_t*)ladd; return T(*val);} } return 0; } //______________________________________________________________________________ -Double_t TStreamerInfo::GetValue(char *pointer, Int_t i, Int_t j, Int_t len) const +template Double_t TStreamerInfo::GetTypedValue(char *pointer, Int_t i, Int_t j, Int_t len) const; +template Long64_t TStreamerInfo::GetTypedValue(char *pointer, Int_t i, Int_t j, Int_t len) const; +template LongDouble_t TStreamerInfo::GetTypedValue(char *pointer, Int_t i, Int_t j, Int_t len) const; + +template +T TStreamerInfo::GetTypedValue(char *pointer, Int_t i, Int_t j, Int_t len) const { // return value of element i in object at pointer. // The function may be called in two ways: @@ -3615,15 +3621,20 @@ Double_t TStreamerInfo::GetValue(char *pointer, Int_t i, Int_t j, Int_t len) con Int_t nc = proxy->Size(); if (j >= nc) return 0; char *element_ptr = (char*)proxy->At(j); - return GetValueAux(atype,element_ptr,0,1); + return GetTypedValueAux(atype,element_ptr,0,1); } } } - return GetValueAux(atype,ladd,j,len); + return GetTypedValueAux(atype,ladd,j,len); } //______________________________________________________________________________ -Double_t TStreamerInfo::GetValueClones(TClonesArray *clones, Int_t i, Int_t j, int k, Int_t eoffset) const +template Double_t TStreamerInfo::GetTypedValueClones(TClonesArray *clones, Int_t i, Int_t j, int k, Int_t eoffset) const; +template Long64_t TStreamerInfo::GetTypedValueClones(TClonesArray *clones, Int_t i, Int_t j, int k, Int_t eoffset) const; +template LongDouble_t TStreamerInfo::GetTypedValueClones(TClonesArray *clones, Int_t i, Int_t j, int k, Int_t eoffset) const; + +template +T TStreamerInfo::GetTypedValueClones(TClonesArray *clones, Int_t i, Int_t j, int k, Int_t eoffset) const { // return value of element i in object number j in a TClonesArray and eventually // element k in a sub-array. @@ -3633,11 +3644,16 @@ Double_t TStreamerInfo::GetValueClones(TClonesArray *clones, Int_t i, Int_t j, i char *pointer = (char*)clones->UncheckedAt(j); char *ladd = pointer + eoffset + fOffset[i]; - return GetValueAux(fType[i],ladd,k,((TStreamerElement*)fElem[i])->GetArrayLength()); + return GetTypedValueAux(fType[i],ladd,k,((TStreamerElement*)fElem[i])->GetArrayLength()); } //______________________________________________________________________________ -Double_t TStreamerInfo::GetValueSTL(TVirtualCollectionProxy *cont, Int_t i, Int_t j, int k, Int_t eoffset) const +template Double_t TStreamerInfo::GetTypedValueSTL(TVirtualCollectionProxy *cont, Int_t i, Int_t j, int k, Int_t eoffset) const; +template Long64_t TStreamerInfo::GetTypedValueSTL(TVirtualCollectionProxy *cont, Int_t i, Int_t j, int k, Int_t eoffset) const; +template LongDouble_t TStreamerInfo::GetTypedValueSTL(TVirtualCollectionProxy *cont, Int_t i, Int_t j, int k, Int_t eoffset) const; + +template +T TStreamerInfo::GetTypedValueSTL(TVirtualCollectionProxy *cont, Int_t i, Int_t j, int k, Int_t eoffset) const { // return value of element i in object number j in a TClonesArray and eventually // element k in a sub-array. @@ -3647,11 +3663,16 @@ Double_t TStreamerInfo::GetValueSTL(TVirtualCollectionProxy *cont, Int_t i, Int_ char *pointer = (char*)cont->At(j); char *ladd = pointer + eoffset + fOffset[i]; - return GetValueAux(fType[i],ladd,k,((TStreamerElement*)fElem[i])->GetArrayLength()); + return GetTypedValueAux(fType[i],ladd,k,((TStreamerElement*)fElem[i])->GetArrayLength()); } //______________________________________________________________________________ -Double_t TStreamerInfo::GetValueSTLP(TVirtualCollectionProxy *cont, Int_t i, Int_t j, int k, Int_t eoffset) const +template Double_t TStreamerInfo::GetTypedValueSTLP(TVirtualCollectionProxy *cont, Int_t i, Int_t j, int k, Int_t eoffset) const; +template Long64_t TStreamerInfo::GetTypedValueSTLP(TVirtualCollectionProxy *cont, Int_t i, Int_t j, int k, Int_t eoffset) const; +template LongDouble_t TStreamerInfo::GetTypedValueSTLP(TVirtualCollectionProxy *cont, Int_t i, Int_t j, int k, Int_t eoffset) const; + +template +T TStreamerInfo::GetTypedValueSTLP(TVirtualCollectionProxy *cont, Int_t i, Int_t j, int k, Int_t eoffset) const { // return value of element i in object number j in a TClonesArray and eventually // element k in a sub-array. @@ -3663,7 +3684,7 @@ Double_t TStreamerInfo::GetValueSTLP(TVirtualCollectionProxy *cont, Int_t i, Int char *pointer = *ptr; char *ladd = pointer + eoffset + fOffset[i]; - return GetValueAux(fType[i],ladd,k,((TStreamerElement*)fElem[i])->GetArrayLength()); + return GetTypedValueAux(fType[i],ladd,k,((TStreamerElement*)fElem[i])->GetArrayLength()); } //______________________________________________________________________________ diff --git a/tree/tree/inc/TBranchElement.h b/tree/tree/inc/TBranchElement.h index 40b6a135fc257..cc2f56652a556 100644 --- a/tree/tree/inc/TBranchElement.h +++ b/tree/tree/inc/TBranchElement.h @@ -195,7 +195,8 @@ class TBranchElement : public TBranch { Int_t GetStreamerType() const { return fStreamerType; } virtual TClass *GetTargetClass() { return fTargetClass; } virtual const char *GetTypeName() const; - Double_t GetValue(Int_t i, Int_t len, Bool_t subarr = kFALSE) const; + Double_t GetValue(Int_t i, Int_t len, Bool_t subarr = kFALSE) const { return GetTypedValue(i, len, subarr); } + template T GetTypedValue(Int_t i, Int_t len, Bool_t subarr = kFALSE) const; virtual void *GetValuePointer() const; Int_t GetClassVersion() { return fClassVersion; } Bool_t IsBranchFolder() const { return TestBit(kBranchFolder); } diff --git a/tree/tree/inc/TLeaf.h b/tree/tree/inc/TLeaf.h index b0fc975a2bc8a..41738c1045941 100644 --- a/tree/tree/inc/TLeaf.h +++ b/tree/tree/inc/TLeaf.h @@ -50,6 +50,10 @@ class TLeaf : public TNamed { TLeaf(const TLeaf&); TLeaf& operator=(const TLeaf&); + template struct GetValueHelper { + static T Exec(const TLeaf *leaf, Int_t i = 0) { return leaf->GetValue(i); } + }; + public: enum { kIndirectAddress = BIT(11), // Data member is a pointer to an array of basic types. @@ -75,7 +79,12 @@ class TLeaf : public TNamed { virtual Int_t GetOffset() const { return fOffset; } virtual void *GetValuePointer() const { return 0; } virtual const char *GetTypeName() const { return ""; } + virtual Double_t GetValue(Int_t i = 0) const; + virtual Long64_t GetValueLong64(Int_t i = 0) const { return GetValue(i); } //overload only when it matters. + virtual LongDouble_t GetValueLongDouble(Int_t i = 0) const { return GetValue(i); } // overload only when it matters. + template T GetTypedValue(Int_t i = 0) const { return GetValueHelper::Exec(this, i); } + virtual void Import(TClonesArray*, Int_t) {} virtual Bool_t IsOnTerminalBranch() const { return kTRUE; } virtual Bool_t IsRange() const { return fIsRange; } @@ -98,6 +107,19 @@ class TLeaf : public TNamed { ClassDef(TLeaf,2); //Leaf: description of a Branch data type }; + +template <> struct TLeaf::GetValueHelper { + static Long64_t Exec(const TLeaf *leaf, Int_t i = 0) { return leaf->GetValueLong64(i); } +}; +template <> struct TLeaf::GetValueHelper { + static ULong64_t Exec(const TLeaf *leaf, Int_t i = 0) { return (ULong64_t)leaf->GetValueLong64(i); } +}; +template <> struct TLeaf::GetValueHelper { + static LongDouble_t Exec(const TLeaf *leaf, Int_t i = 0) { return leaf->GetValueLongDouble(i); } +}; + + + inline Double_t TLeaf::GetValue(Int_t /*i = 0*/) const { return 0.0; } inline void TLeaf::PrintValue(Int_t /* i = 0*/) const {} inline void TLeaf::SetAddress(void* /* add = 0 */) {} diff --git a/tree/tree/inc/TLeafElement.h b/tree/tree/inc/TLeafElement.h index 2f43e7217099a..dcc289feddf3d 100644 --- a/tree/tree/inc/TLeafElement.h +++ b/tree/tree/inc/TLeafElement.h @@ -48,8 +48,12 @@ class TLeafElement : public TLeaf { virtual Int_t GetMaximum() const {return ((TBranchElement*)fBranch)->GetMaximum();} virtual Int_t GetNdata() const {return ((TBranchElement*)fBranch)->GetNdata()*fLen;} virtual const char *GetTypeName() const {return ((TBranchElement*)fBranch)->GetTypeName();} - virtual Double_t GetValue(Int_t i=0) const {return ((TBranchElement*)fBranch)->GetValue(i, fLen, kFALSE);} - virtual Double_t GetValueSubArray(Int_t i=0, Int_t j=0) const {return ((TBranchElement*)fBranch)->GetValue(i, j, kTRUE);} + + virtual Double_t GetValue(Int_t i=0) const { return ((TBranchElement*)fBranch)->GetValue(i, fLen, kFALSE);} + virtual Long64_t GetValueLong64(Int_t i = 0) const { return ((TBranchElement*)fBranch)->GetTypedValue(i, fLen, kFALSE); } + virtual LongDouble_t GetValueLongDouble(Int_t i = 0) const { return ((TBranchElement*)fBranch)->GetTypedValue(i, fLen, kFALSE); } + template T GetTypedValueSubArray(Int_t i=0, Int_t j=0) const {return ((TBranchElement*)fBranch)->GetTypedValue(i, j, kTRUE);} + virtual void *GetValuePointer() const { return ((TBranchElement*)fBranch)->GetValuePointer(); } virtual Bool_t IsOnTerminalBranch() const; virtual void PrintValue(Int_t i=0) const {((TBranchElement*)fBranch)->PrintValue(i);} diff --git a/tree/tree/inc/TLeafL.h b/tree/tree/inc/TLeafL.h index 8933dc6d36b94..e38b5dfc09922 100644 --- a/tree/tree/inc/TLeafL.h +++ b/tree/tree/inc/TLeafL.h @@ -44,7 +44,9 @@ class TLeafL : public TLeaf { const char *GetTypeName() const; virtual Int_t GetMaximum() const {return (Int_t)fMaximum;} virtual Int_t GetMinimum() const {return (Int_t)fMinimum;} - Double_t GetValue(Int_t i=0) const; + virtual Double_t GetValue(Int_t i=0) const; + virtual Long64_t GetValueLong64(Int_t i = 0) const ; + virtual LongDouble_t GetValueLongDouble(Int_t i = 0) const; virtual void *GetValuePointer() const {return fValue;} virtual void Import(TClonesArray *list, Int_t n); virtual void PrintValue(Int_t i=0) const; @@ -58,4 +60,8 @@ class TLeafL : public TLeaf { ClassDef(TLeafL,1); //A TLeaf for a 64 bit Integer data type. }; +// if leaf is a simple type, i must be set to 0 +// if leaf is an array, i is the array element number to be returned +inline Long64_t TLeafL::GetValueLong64(Int_t i) const { return fValue[i]; } + #endif diff --git a/tree/tree/inc/TTree.h b/tree/tree/inc/TTree.h index 42b44d53d6211..c033bff62b65c 100644 --- a/tree/tree/inc/TTree.h +++ b/tree/tree/inc/TTree.h @@ -375,8 +375,8 @@ class TTree : public TNamed, public TAttLine, public TAttFill, public TAttMarker virtual Int_t GetEntry(Long64_t entry = 0, Int_t getall = 0); Int_t GetEvent(Long64_t entry = 0, Int_t getall = 0) { return GetEntry(entry, getall); } virtual Int_t GetEntryWithIndex(Int_t major, Int_t minor = 0); - virtual Long64_t GetEntryNumberWithBestIndex(Int_t major, Int_t minor = 0) const; - virtual Long64_t GetEntryNumberWithIndex(Int_t major, Int_t minor = 0) const; + virtual Long64_t GetEntryNumberWithBestIndex(Long64_t major, Long64_t minor = 0) const; + virtual Long64_t GetEntryNumberWithIndex(Long64_t major, Long64_t minor = 0) const; TEventList *GetEventList() const { return fEventList; } virtual TEntryList *GetEntryList(); virtual Long64_t GetEntryNumber(Long64_t entry) const; diff --git a/tree/tree/inc/TVirtualIndex.h b/tree/tree/inc/TVirtualIndex.h index 513372fb01693..f2a2a29b9ef4d 100644 --- a/tree/tree/inc/TVirtualIndex.h +++ b/tree/tree/inc/TVirtualIndex.h @@ -38,8 +38,8 @@ class TVirtualIndex : public TNamed { virtual ~TVirtualIndex(); virtual void Append(const TVirtualIndex *,Bool_t delaySort = kFALSE) = 0; virtual Long64_t GetEntryNumberFriend(const TTree * /*parent*/) = 0; - virtual Long64_t GetEntryNumberWithIndex(Int_t major, Int_t minor) const = 0; - virtual Long64_t GetEntryNumberWithBestIndex(Int_t major, Int_t minor) const = 0; + virtual Long64_t GetEntryNumberWithIndex(Long64_t major, Long64_t minor) const = 0; + virtual Long64_t GetEntryNumberWithBestIndex(Long64_t major, Long64_t minor) const = 0; virtual const char *GetMajorName() const = 0; virtual const char *GetMinorName() const = 0; virtual Long64_t GetN() const = 0; diff --git a/tree/tree/src/TBranchElement.cxx b/tree/tree/src/TBranchElement.cxx index 73d4f16a0a3b5..fc6562ec07281 100644 --- a/tree/tree/src/TBranchElement.cxx +++ b/tree/tree/src/TBranchElement.cxx @@ -2428,7 +2428,12 @@ const char* TBranchElement::GetTypeName() const } //______________________________________________________________________________ -Double_t TBranchElement::GetValue(Int_t j, Int_t len, Bool_t subarr) const +template Double_t TBranchElement::GetTypedValue(Int_t j, Int_t len, Bool_t subarr) const; +template Long64_t TBranchElement::GetTypedValue(Int_t j, Int_t len, Bool_t subarr) const; +template LongDouble_t TBranchElement::GetTypedValue(Int_t j, Int_t len, Bool_t subarr) const; + +template +T TBranchElement::GetTypedValue(Int_t j, Int_t len, Bool_t subarr) const { // -- Returns the branch value. // @@ -2470,22 +2475,22 @@ Double_t TBranchElement::GetValue(Int_t j, Int_t len, Bool_t subarr) const } if ((fType == 3) || (fType == 4)) { // Top-level branch of a TClonesArray. - return (Double_t) fNdata; + return fNdata; } else if ((fType == 31) || (fType == 41)) { // sub branch of a TClonesArray Int_t atype = fStreamerType; if (atype < 20) { atype += 20; } - return GetInfoImp()->GetValue(fAddress, atype, j, 1); + return GetInfoImp()->GetTypedValue(fAddress, atype, j, 1); } else if (fType <= 2) { // branch in split mode // FIXME: This should probably be < 60 instead! if ((fStreamerType > 40) && (fStreamerType < 55)) { Int_t atype = fStreamerType - 20; - return GetInfoImp()->GetValue(fAddress, atype, j, 1); + return GetInfoImp()->GetTypedValue(fAddress, atype, j, 1); } else { - return GetInfoImp()->GetValue(object, prID, j, -1); + return GetInfoImp()->GetTypedValue(object, prID, j, -1); } } } @@ -2500,27 +2505,27 @@ Double_t TBranchElement::GetValue(Int_t j, Int_t len, Bool_t subarr) const if (fType == 31) { TClonesArray* clones = (TClonesArray*) object; if (subarr) { - return GetInfoImp()->GetValueClones(clones, prID, j, len, fOffset); + return GetInfoImp()->GetTypedValueClones(clones, prID, j, len, fOffset); } - return GetInfoImp()->GetValueClones(clones, prID, j/len, j%len, fOffset); + return GetInfoImp()->GetTypedValueClones(clones, prID, j/len, j%len, fOffset); } else if (fType == 41) { TVirtualCollectionProxy::TPushPop helper(((TBranchElement*) this)->GetCollectionProxy(), object); if( fSplitLevel < TTree::kSplitCollectionOfPointers ) { if (subarr) - return GetInfoImp()->GetValueSTL(((TBranchElement*) this)->GetCollectionProxy(), prID, j, len, fOffset); + return GetInfoImp()->GetTypedValueSTL(((TBranchElement*) this)->GetCollectionProxy(), prID, j, len, fOffset); - return GetInfoImp()->GetValueSTL(((TBranchElement*) this)->GetCollectionProxy(), prID, j/len, j%len, fOffset); + return GetInfoImp()->GetTypedValueSTL(((TBranchElement*) this)->GetCollectionProxy(), prID, j/len, j%len, fOffset); } else { if (subarr) - return GetInfoImp()->GetValueSTLP(((TBranchElement*) this)->GetCollectionProxy(), prID, j, len, fOffset); - return GetInfoImp()->GetValueSTLP(((TBranchElement*) this)->GetCollectionProxy(), prID, j/len, j%len, fOffset); + return GetInfoImp()->GetTypedValueSTLP(((TBranchElement*) this)->GetCollectionProxy(), prID, j, len, fOffset); + return GetInfoImp()->GetTypedValueSTLP(((TBranchElement*) this)->GetCollectionProxy(), prID, j/len, j%len, fOffset); } } else { if (GetInfoImp()) { - return GetInfoImp()->GetValue(object, prID, j, -1); + return GetInfoImp()->GetTypedValue(object, prID, j, -1); } return 0; } diff --git a/tree/tree/src/TLeafL.cxx b/tree/tree/src/TLeafL.cxx index 4bbce00d2248e..dba80218550e0 100644 --- a/tree/tree/src/TLeafL.cxx +++ b/tree/tree/src/TLeafL.cxx @@ -118,6 +118,18 @@ Double_t TLeafL::GetValue(Int_t i) const } +//______________________________________________________________________________ +LongDouble_t TLeafL::GetValueLongDouble(Int_t i) const +{ +// Returns current value of leaf +// if leaf is a simple type, i must be set to 0 +// if leaf is an array, i is the array element number to be returned + + if (fIsUnsigned) return (LongDouble_t)((ULong64_t)fValue[i]); + return fValue[i]; +} + + //______________________________________________________________________________ void TLeafL::Import(TClonesArray *list, Int_t n) diff --git a/tree/tree/src/TTree.cxx b/tree/tree/src/TTree.cxx index 9783cda01b4be..837bede02fae5 100644 --- a/tree/tree/src/TTree.cxx +++ b/tree/tree/src/TTree.cxx @@ -4969,7 +4969,7 @@ Long64_t TTree::GetEntryNumber(Long64_t entry) const } //______________________________________________________________________________ -Long64_t TTree::GetEntryNumberWithBestIndex(Int_t major, Int_t minor) const +Long64_t TTree::GetEntryNumberWithBestIndex(Long64_t major, Long64_t minor) const { // Return entry number corresponding to major and minor number. // Note that this function returns only the entry number, not the data @@ -4993,7 +4993,7 @@ Long64_t TTree::GetEntryNumberWithBestIndex(Int_t major, Int_t minor) const } //______________________________________________________________________________ -Long64_t TTree::GetEntryNumberWithIndex(Int_t major, Int_t minor) const +Long64_t TTree::GetEntryNumberWithIndex(Long64_t major, Long64_t minor) const { // Return entry number corresponding to major and minor number. // Note that this function returns only the entry number, not the data diff --git a/tree/treeplayer/inc/TChainIndex.h b/tree/treeplayer/inc/TChainIndex.h index e9fb65b144050..c35ab648fea23 100644 --- a/tree/treeplayer/inc/TChainIndex.h +++ b/tree/treeplayer/inc/TChainIndex.h @@ -35,6 +35,7 @@ #include class TTreeFormula; +class TTreeIndex; class TChain; class TChainIndex : public TVirtualIndex { @@ -43,10 +44,20 @@ class TChainIndex : public TVirtualIndex { class TChainIndexEntry { // holds a description of indices of trees in the chain. public: - TChainIndexEntry() : fMinIndexValue(0), fMaxIndexValue(0), fTreeIndex(0) {} + TChainIndexEntry() : fMinIndexValue(0), fMinIndexValMinor(0), + fMaxIndexValue(0), fMaxIndexValMinor(0), + fTreeIndex(0) {} - Long64_t fMinIndexValue; // the minimum value of the index - Long64_t fMaxIndexValue; // the maximum value of the index + typedef std::pair IndexValPair_t; + + IndexValPair_t GetMinIndexValPair() const { return IndexValPair_t(fMinIndexValue, fMinIndexValMinor); } + IndexValPair_t GetMaxIndexValPair() const { return IndexValPair_t(fMaxIndexValue, fMaxIndexValMinor); } + void SetMinMaxFrom(const TTreeIndex *index ); + + Long64_t fMinIndexValue; // the minimum value of the index (upper bits) + Long64_t fMinIndexValMinor; // the minimum value of the index (lower bits) + Long64_t fMaxIndexValue; // the maximum value of the index (upper bits) + Long64_t fMaxIndexValMinor; // the maximum value of the index (lower bits) TVirtualIndex* fTreeIndex; // the tree index in case it was created in the constructor, // otherwise 0 }; @@ -58,7 +69,7 @@ class TChainIndex : public TVirtualIndex { TTreeFormula *fMinorFormulaParent; //! Pointer to minor TreeFormula in Parent tree (if any) std::vector fEntries; // descriptions of indices of trees in the chain. - std::pair GetSubTreeIndex(Int_t major, Int_t minor) const; + std::pair GetSubTreeIndex(Long64_t major, Long64_t minor) const; void ReleaseSubTreeIndex(TVirtualIndex* index, Int_t treeNo) const; void DeleteIndices(); @@ -68,8 +79,8 @@ class TChainIndex : public TVirtualIndex { virtual ~TChainIndex(); virtual void Append(const TVirtualIndex *, Bool_t delaySort = kFALSE); virtual Long64_t GetEntryNumberFriend(const TTree *parent); - virtual Long64_t GetEntryNumberWithIndex(Int_t major, Int_t minor) const; - virtual Long64_t GetEntryNumberWithBestIndex(Int_t major, Int_t minor) const; + virtual Long64_t GetEntryNumberWithIndex(Long64_t major, Long64_t minor) const; + virtual Long64_t GetEntryNumberWithBestIndex(Long64_t major, Long64_t minor) const; const char *GetMajorName() const {return fMajorName.Data();} const char *GetMinorName() const {return fMinorName.Data();} virtual Long64_t GetN() const {return fEntries.size();} diff --git a/tree/treeplayer/inc/TFormLeafInfo.h b/tree/treeplayer/inc/TFormLeafInfo.h index a7738205135ba..18d12eb94faf9 100644 --- a/tree/treeplayer/inc/TFormLeafInfo.h +++ b/tree/treeplayer/inc/TFormLeafInfo.h @@ -26,6 +26,30 @@ #include "TStreamerElement.h" +// declare the extra versions of GetValue() plus templated implementation +#define DECLARE_GETVAL \ + virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0) \ + { return GetValueImpl(leaf, instance); } \ + virtual Long64_t GetValueLong64(TLeaf *leaf, Int_t instance = 0) \ + { return GetValueImpl(leaf, instance); } \ + virtual LongDouble_t GetValueLongDouble(TLeaf *leaf, Int_t instance = 0) \ + { return GetValueImpl(leaf, instance); } \ + template T GetValueImpl(TLeaf *leaf, Int_t instance = 0) // no semicolon + + +// declare the extra versions of ReadValue() plus templated implementation +#define DECLARE_READVAL \ + virtual Double_t ReadValue(char *where, Int_t instance = 0) \ + { return ReadValueImpl(where, instance); } \ + virtual Long64_t ReadValueLong64(char *where, Int_t instance = 0) \ + { return ReadValueImpl(where, instance); } \ + virtual LongDouble_t ReadValueLongDouble(char *where, Int_t instance = 0) \ + { return ReadValueImpl(where, instance); } \ + template T ReadValueImpl(char *where, Int_t instance = 0) // no semicolon + + + + class TFormLeafInfo : public TObject { public: // Constructors @@ -69,8 +93,6 @@ class TFormLeafInfo : public TObject { Int_t GetNdata(TLeaf* leaf); virtual Int_t GetNdata(); - virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0); - virtual void *GetValuePointer(TLeaf *leaf, Int_t instance = 0); virtual void *GetValuePointer(char *from, Int_t instance = 0); virtual void *GetLocalValuePointer(TLeaf *leaf, Int_t instance = 0); @@ -94,12 +116,50 @@ class TFormLeafInfo : public TObject { virtual void SetSize(Int_t index, Int_t val); virtual void SetBranch(TBranch* br) { if ( fNext ) fNext->SetBranch(br); } virtual void UpdateSizes(TArrayI *garr); + + virtual Bool_t Update(); + + DECLARE_GETVAL; + DECLARE_READVAL; + + template struct ReadValueHelper { + static T Exec(TFormLeafInfo *leaf, char *where, Int_t instance) + { return leaf->ReadValue(where, instance); } + }; + template T ReadTypedValue(char *where, Int_t instance = 0) + { return ReadValueHelper::Exec(this, where, instance); } + + template struct GetValueHelper { + static T Exec(TFormLeafInfo *linfo, TLeaf *leaf, Int_t instance) + { return linfo->GetValue(leaf, instance); } + }; + template T GetTypedValue(TLeaf *leaf, Int_t instance = 0) + { return GetValueHelper::Exec(this, leaf, instance); } +}; - virtual Double_t ReadValue(char *where, Int_t instance = 0); - virtual Bool_t Update(); +template <> struct TFormLeafInfo::ReadValueHelper { + static Long64_t Exec(TFormLeafInfo *leaf, char *where, Int_t instance) { return leaf->ReadValueLong64(where, instance); } +}; +template <> struct TFormLeafInfo::ReadValueHelper { + static ULong64_t Exec(TFormLeafInfo *leaf, char *where, Int_t instance) { return (ULong64_t)leaf->ReadValueLong64(where, instance); } +}; +template <> struct TFormLeafInfo::ReadValueHelper { + static LongDouble_t Exec(TFormLeafInfo *leaf, char *where, Int_t instance) { return leaf->ReadValueLongDouble(where, instance); } +}; + + +template <> struct TFormLeafInfo::GetValueHelper { + static Long64_t Exec(TFormLeafInfo *linfo, TLeaf *leaf, Int_t instance) { return linfo->GetValueLong64(leaf, instance); } +}; +template <> struct TFormLeafInfo::GetValueHelper { + static ULong64_t Exec(TFormLeafInfo *linfo, TLeaf *leaf, Int_t instance) { return (ULong64_t)linfo->GetValueLong64(leaf, instance); } +}; +template <> struct TFormLeafInfo::GetValueHelper { + static LongDouble_t Exec(TFormLeafInfo *linfo, TLeaf *leaf, Int_t instance) { return linfo->GetValueLongDouble(leaf, instance); } +}; + -}; //______________________________________________________________________________ // @@ -113,10 +173,14 @@ class TFormLeafInfoDirect : public TFormLeafInfo { virtual TFormLeafInfo* DeepCopy() const; - virtual Double_t ReadValue(char * /*where*/, Int_t /*instance*/= 0); - virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0); + DECLARE_GETVAL; virtual void *GetLocalValuePointer(TLeaf *leaf, Int_t instance = 0); virtual void *GetLocalValuePointer(char *thisobj, Int_t instance = 0); + + virtual Double_t ReadValue(char * /*where*/, Int_t /*instance*/= 0); + virtual Long64_t ReadValueLong64(char *where, Int_t i= 0) { return ReadValue(where, i); } + virtual LongDouble_t ReadValueLongDouble(char *where, Int_t i= 0) { return ReadValue(where, i); } + }; @@ -162,9 +226,11 @@ class TFormLeafInfoCollectionObject : public TFormLeafInfo { return new TFormLeafInfoCollectionObject(*this); } + DECLARE_GETVAL; virtual Int_t GetCounterValue(TLeaf* leaf); virtual Double_t ReadValue(char *where, Int_t instance = 0); - virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0); + virtual Long64_t ReadValueLong64(char *where, Int_t i= 0) { return ReadValue(where, i); } + virtual LongDouble_t ReadValueLongDouble(char *where, Int_t i= 0) { return ReadValue(where, i); } virtual void *GetValuePointer(TLeaf *leaf, Int_t instance = 0); virtual void *GetValuePointer(char *thisobj, Int_t instance = 0); virtual void *GetLocalValuePointer(TLeaf *leaf, Int_t instance = 0); @@ -193,10 +259,10 @@ class TFormLeafInfoClones : public TFormLeafInfo { return new TFormLeafInfoClones(*this); } + DECLARE_GETVAL; + DECLARE_READVAL; virtual Int_t GetCounterValue(TLeaf* leaf); virtual Int_t ReadCounterValue(char *where); - virtual Double_t ReadValue(char *where, Int_t instance = 0); - virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0); virtual void *GetValuePointer(TLeaf *leaf, Int_t instance = 0); virtual void *GetValuePointer(char *thisobj, Int_t instance = 0); virtual void *GetLocalValuePointer(TLeaf *leaf, Int_t instance = 0); @@ -240,12 +306,12 @@ class TFormLeafInfoCollection : public TFormLeafInfo { virtual Bool_t Update(); + DECLARE_GETVAL; + DECLARE_READVAL; virtual Int_t GetCounterValue(TLeaf* leaf); virtual Int_t ReadCounterValue(char* where); virtual Int_t GetCounterValue(TLeaf* leaf, Int_t instance); virtual Bool_t HasCounter() const; - virtual Double_t ReadValue(char *where, Int_t instance = 0); - virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0); virtual void *GetValuePointer(TLeaf *leaf, Int_t instance = 0); virtual void *GetValuePointer(char *thisobj, Int_t instance = 0); virtual void *GetLocalValuePointer(TLeaf *leaf, Int_t instance = 0); @@ -280,6 +346,8 @@ class TFormLeafInfoCollectionSize : public TFormLeafInfo { virtual void *GetLocalValuePointer(TLeaf *leaf, Int_t instance = 0); virtual void *GetLocalValuePointer( char *from, Int_t instance = 0); virtual Double_t ReadValue(char *where, Int_t instance = 0); + virtual Long64_t ReadValueLong64(char *where, Int_t i= 0) { return ReadValue(where, i); } + virtual LongDouble_t ReadValueLongDouble(char *where, Int_t i= 0) { return ReadValue(where, i); } }; //______________________________________________________________________________ @@ -295,8 +363,8 @@ class TFormLeafInfoPointer : public TFormLeafInfo { virtual TFormLeafInfo* DeepCopy() const; - virtual Double_t ReadValue(char *where, Int_t instance = 0); - virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0); + DECLARE_GETVAL; + DECLARE_READVAL; }; //______________________________________________________________________________ @@ -326,12 +394,12 @@ class TFormLeafInfoMethod : public TFormLeafInfo { virtual TFormLeafInfo* DeepCopy() const; + DECLARE_READVAL; virtual TClass* GetClass() const; virtual void *GetLocalValuePointer( TLeaf *from, Int_t instance = 0); virtual void *GetLocalValuePointer(char *from, Int_t instance = 0); virtual Bool_t IsInteger() const; virtual Bool_t IsString() const; - virtual Double_t ReadValue(char *where, Int_t instance = 0); virtual Bool_t Update(); }; @@ -382,6 +450,8 @@ class TFormLeafInfoMultiVarDim : public TFormLeafInfo { virtual Int_t GetSize(Int_t index); virtual Int_t GetSumOfSizes(); virtual Double_t GetValue(TLeaf * /*leaf*/, Int_t /*instance*/ = 0); + virtual Long64_t GetValueLong64(TLeaf *leaf, Int_t i= 0) { return GetValue(leaf, i); } + virtual LongDouble_t GetValueLongDouble(TLeaf *leaf, Int_t i= 0) { return GetValue(leaf, i); } virtual Int_t GetVarDim(); virtual Int_t GetVirtVarDim(); virtual Bool_t Update(); @@ -400,8 +470,10 @@ class TFormLeafInfoMultiVarDimDirect : public TFormLeafInfoMultiVarDim { virtual TFormLeafInfo* DeepCopy() const; - virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0); + DECLARE_GETVAL; virtual Double_t ReadValue(char * /*where*/, Int_t /*instance*/ = 0); + virtual Long64_t ReadValueLong64(char *where, Int_t i= 0) { return ReadValue(where, i); } + virtual LongDouble_t ReadValueLongDouble(char *where, Int_t i= 0) { return ReadValue(where, i); } }; //______________________________________________________________________________ @@ -423,7 +495,9 @@ class TFormLeafInfoMultiVarDimCollection : public TFormLeafInfoMultiVarDim { virtual Int_t GetArrayLength() { return 0; } virtual void LoadSizes(TBranch* branch); virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0); - virtual Double_t ReadValue(char * /*where*/, Int_t /*instance*/ = 0); + virtual Long64_t GetValueLong64(TLeaf *leaf, Int_t i= 0) { return GetValue(leaf, i); } + virtual LongDouble_t GetValueLongDouble(TLeaf *leaf, Int_t i= 0) { return GetValue(leaf, i); } + DECLARE_READVAL; }; //______________________________________________________________________________ @@ -445,7 +519,9 @@ class TFormLeafInfoMultiVarDimClones : public TFormLeafInfoMultiVarDim { virtual Int_t GetArrayLength() { return 0; } virtual void LoadSizes(TBranch* branch); virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0); - virtual Double_t ReadValue(char * /*where*/, Int_t /*instance*/ = 0); + virtual Long64_t GetValueLong64(TLeaf *leaf, Int_t i= 0) { return GetValue(leaf, i); } + virtual LongDouble_t GetValueLongDouble(TLeaf *leaf, Int_t i= 0) { return GetValue(leaf, i); } + DECLARE_READVAL; }; //______________________________________________________________________________ @@ -469,9 +545,9 @@ class TFormLeafInfoCast : public TFormLeafInfo { virtual TFormLeafInfo* DeepCopy() const; + DECLARE_READVAL; // Currently only implemented in TFormLeafInfoCast virtual Int_t GetNdata(); - virtual Double_t ReadValue(char *where, Int_t instance = 0); virtual Bool_t Update(); }; @@ -497,9 +573,9 @@ class TFormLeafInfoTTree : public TFormLeafInfo { using TFormLeafInfo::GetLocalValuePointer; using TFormLeafInfo::GetValue; + DECLARE_GETVAL; + DECLARE_READVAL; virtual void *GetLocalValuePointer(TLeaf *leaf, Int_t instance = 0); - virtual Double_t GetValue(TLeaf *leaf, Int_t instance = 0); - virtual Double_t ReadValue(char *thisobj, Int_t instance); virtual Bool_t Update(); }; diff --git a/tree/treeplayer/inc/TFormLeafInfoReference.h b/tree/treeplayer/inc/TFormLeafInfoReference.h index e0b9c60decf13..aa8d586e3e98d 100644 --- a/tree/treeplayer/inc/TFormLeafInfoReference.h +++ b/tree/treeplayer/inc/TFormLeafInfoReference.h @@ -80,10 +80,10 @@ class TFormLeafInfoReference : public TFormLeafInfo { // Return the current size of the array container virtual Int_t GetCounterValue(TLeaf* leaf); - // Access value of referenced object - virtual Double_t GetValue(TLeaf *leaf, Int_t instance); + // Access value of referenced object (macro from TFormLeafInfo.g) + DECLARE_GETVAL; // Read value of referenced object - virtual Double_t ReadValue(char *where, Int_t instance = 0); + DECLARE_READVAL; // TFormLeafInfo overload: Update (and propagate) cached information virtual Bool_t Update(); }; diff --git a/tree/treeplayer/inc/TTreeFormula.h b/tree/treeplayer/inc/TTreeFormula.h index 855c11477c0a7..1759a0ac9bcc2 100644 --- a/tree/treeplayer/inc/TTreeFormula.h +++ b/tree/treeplayer/inc/TTreeFormula.h @@ -124,6 +124,8 @@ friend class TTreeFormulaManager; TList *fDimensionSetup; //! list of dimension setups, for delayed creation of the dimension information. std::vector fAliasesUsed; //! List of aliases used during the parsing of the expression. + LongDouble_t* fConstLD; // local version of fConsts able to store bigger numbers + TTreeFormula(const char *name, const char *formula, TTree *tree, const std::vector& aliases); void Init(const char *name, const char *formula); Bool_t BranchHasMethod(TLeaf* leaf, TBranch* branch, const char* method,const char* params, Long64_t readentry) const; @@ -159,6 +161,8 @@ friend class TTreeFormulaManager; // Not implemented yet TTreeFormula(const TTreeFormula&); TTreeFormula& operator=(const TTreeFormula&); + + template T GetConstant(Int_t k) ; public: TTreeFormula(); @@ -167,7 +171,12 @@ friend class TTreeFormulaManager; virtual Int_t DefinedVariable(TString &variable, Int_t &action); virtual TClass* EvalClass() const; - virtual Double_t EvalInstance(Int_t i=0, const char *stringStack[]=0); + + template T EvalInstance(Int_t i=0, const char *stringStack[]=0); + virtual Double_t EvalInstance(Int_t i=0, const char *stringStack[]=0) {return EvalInstance(i, stringStack); } + virtual Long64_t EvalInstance64(Int_t i=0, const char *stringStack[]=0) {return EvalInstance(i, stringStack); } + virtual LongDouble_t EvalInstanceLD(Int_t i=0, const char *stringStack[]=0) {return EvalInstance(i, stringStack); } + virtual const char *EvalStringInstance(Int_t i=0); virtual void* EvalObject(Int_t i=0); // EvalInstance should be const. See comment on GetNdata() diff --git a/tree/treeplayer/inc/TTreeIndex.h b/tree/treeplayer/inc/TTreeIndex.h index 677f0516ca7ed..24cc63a763f2c 100644 --- a/tree/treeplayer/inc/TTreeIndex.h +++ b/tree/treeplayer/inc/TTreeIndex.h @@ -35,7 +35,8 @@ class TTreeIndex : public TVirtualIndex { TString fMajorName; // Index major name TString fMinorName; // Index minor name Long64_t fN; // Number of entries - Long64_t *fIndexValues; //[fN] Sorted index values + Long64_t *fIndexValues; //[fN] Sorted index values, higher 64bits + Long64_t *fIndexValuesMinor; //[fN] Sorted index values, lower 64bits Long64_t *fIndex; //[fN] Index of sorted values TTreeFormula *fMajorFormula; //! Pointer to major TreeFormula TTreeFormula *fMinorFormula; //! Pointer to minor TreeFormula @@ -51,11 +52,14 @@ class TTreeIndex : public TVirtualIndex { TTreeIndex(const TTree *T, const char *majorname, const char *minorname); virtual ~TTreeIndex(); virtual void Append(const TVirtualIndex *,Bool_t delaySort = kFALSE); + bool ConvertOldToNew(); + Long64_t FindValues(Long64_t major, Long64_t minor) const; virtual Long64_t GetEntryNumberFriend(const TTree *parent); - virtual Long64_t GetEntryNumberWithIndex(Int_t major, Int_t minor) const; - virtual Long64_t GetEntryNumberWithBestIndex(Int_t major, Int_t minor) const; - virtual Long64_t *GetIndexValues() const {return fIndexValues;} + virtual Long64_t GetEntryNumberWithIndex(Long64_t major, Long64_t minor) const; + virtual Long64_t GetEntryNumberWithBestIndex(Long64_t major, Long64_t minor) const; virtual Long64_t *GetIndex() const {return fIndex;} + virtual Long64_t *GetIndexValues() const {return fIndexValues;} + virtual Long64_t *GetIndexValuesMinor() const; const char *GetMajorName() const {return fMajorName.Data();} const char *GetMinorName() const {return fMinorName.Data();} virtual Long64_t GetN() const {return fN;} @@ -67,7 +71,7 @@ class TTreeIndex : public TVirtualIndex { virtual void UpdateFormulaLeaves(const TTree *parent); virtual void SetTree(const TTree *T); - ClassDef(TTreeIndex,1); //A Tree Index with majorname and minorname. + ClassDef(TTreeIndex,2); //A Tree Index with majorname and minorname. }; #endif diff --git a/tree/treeplayer/src/TChainIndex.cxx b/tree/treeplayer/src/TChainIndex.cxx index 4966930a73960..7ad9bf940110b 100644 --- a/tree/treeplayer/src/TChainIndex.cxx +++ b/tree/treeplayer/src/TChainIndex.cxx @@ -22,6 +22,19 @@ #include "TFile.h" #include "TError.h" + + +//______________________________________________________________________________ +void TChainIndex::TChainIndexEntry::SetMinMaxFrom(const TTreeIndex *index ) +{ + fMinIndexValue = index->GetIndexValues()[0]; + fMinIndexValMinor = index->GetIndexValuesMinor()[0]; + fMaxIndexValue = index->GetIndexValues()[index->GetN() - 1]; + fMaxIndexValMinor = index->GetIndexValuesMinor()[index->GetN() - 1]; +} + + + ClassImp(TChainIndex) //______________________________________________________________________________ @@ -99,14 +112,13 @@ TChainIndex::TChainIndex(const TTree *T, const char *majorname, const char *mino return; } - entry.fMinIndexValue = ti_index->GetIndexValues()[0]; - entry.fMaxIndexValue = ti_index->GetIndexValues()[index->GetN() - 1]; + entry.SetMinMaxFrom(ti_index); fEntries.push_back(entry); } // Check if the indices of different trees are in order. If not then return an error. for (i = 0; i < Int_t(fEntries.size() - 1); i++) { - if (fEntries[i].fMaxIndexValue > fEntries[i+1].fMinIndexValue) { + if( fEntries[i].GetMaxIndexValPair() > fEntries[i+1].GetMinIndexValPair() ) { DeleteIndices(); MakeZombie(); Error("TChainIndex", "The indices in files of this chain aren't sorted."); @@ -115,6 +127,7 @@ TChainIndex::TChainIndex(const TTree *T, const char *majorname, const char *mino } + //______________________________________________________________________________ void TChainIndex::Append(const TVirtualIndex *index, Bool_t delaySort ) { @@ -129,15 +142,14 @@ void TChainIndex::Append(const TVirtualIndex *index, Bool_t delaySort ) TChainIndexEntry entry; entry.fTreeIndex = 0; - entry.fMinIndexValue = ti_index->GetIndexValues()[0]; - entry.fMaxIndexValue = ti_index->GetIndexValues()[index->GetN() - 1]; + entry.SetMinMaxFrom(ti_index); fEntries.push_back(entry); } if (!delaySort) { // Check if the indices of different trees are in order. If not then return an error. for (Int_t i = 0; i < Int_t(fEntries.size() - 1); i++) { - if (fEntries[i].fMaxIndexValue > fEntries[i+1].fMinIndexValue) { + if( fEntries[i].GetMaxIndexValPair() > fEntries[i+1].GetMinIndexValPair() ) { DeleteIndices(); MakeZombie(); Error("Append", "The indices in files of this chain aren't sorted."); @@ -171,7 +183,7 @@ TChainIndex::~TChainIndex() } //______________________________________________________________________________ -std::pair TChainIndex::GetSubTreeIndex(Int_t major, Int_t minor) const +std::pair TChainIndex::GetSubTreeIndex(Long64_t major, Long64_t minor) const { // Returns a TVirtualIndex for a tree which holds the entry with the specified // major and minor values and the number of that tree. @@ -184,22 +196,22 @@ std::pair TChainIndex::GetSubTreeIndex(Int_t major, Int_t return make_pair(static_cast(0), 0); } - Long64_t indexValue = (Long64_t(major) << 31) + minor; - - if (indexValue < fEntries[0].fMinIndexValue) { + const TChainIndexEntry::IndexValPair_t indexValue(major, minor); + + if( indexValue < fEntries[0].GetMinIndexValPair() ) { Warning("GetSubTreeIndex", "The index value is less than the smallest index values in subtrees"); return make_pair(static_cast(0), 0); } Int_t treeNo = fEntries.size() - 1; for (unsigned int i = 0; i < fEntries.size() - 1; i++) { - if (indexValue < fEntries[i+1].fMinIndexValue) { + if( indexValue < fEntries[i+1].GetMinIndexValPair() ) { treeNo = i; break; } } // Double check we found the right range. - if (indexValue > fEntries[treeNo].fMaxIndexValue) { + if( indexValue > fEntries[treeNo].GetMaxIndexValPair() ) { return make_pair(static_cast(0), 0); } TChain* chain = dynamic_cast (fTree); @@ -268,7 +280,7 @@ Long64_t TChainIndex::GetEntryNumberFriend(const TTree *parent) } //______________________________________________________________________________ -Long64_t TChainIndex::GetEntryNumberWithBestIndex(Int_t major, Int_t minor) const +Long64_t TChainIndex::GetEntryNumberWithBestIndex(Long64_t major, Long64_t minor) const { // See TTreeIndex::GetEntryNumberWithBestIndex for details. @@ -287,7 +299,7 @@ Long64_t TChainIndex::GetEntryNumberWithBestIndex(Int_t major, Int_t minor) cons } //______________________________________________________________________________ -Long64_t TChainIndex::GetEntryNumberWithIndex(Int_t major, Int_t minor) const +Long64_t TChainIndex::GetEntryNumberWithIndex(Long64_t major, Long64_t minor) const { // Returns the entry number with given index values. // See TTreeIndex::GetEntryNumberWithIndex for details. diff --git a/tree/treeplayer/src/TFormLeafInfo.cxx b/tree/treeplayer/src/TFormLeafInfo.cxx index 4cc90ebd18950..beff3c6279470 100644 --- a/tree/treeplayer/src/TFormLeafInfo.cxx +++ b/tree/treeplayer/src/TFormLeafInfo.cxx @@ -55,6 +55,17 @@ #include "TVirtualCollectionProxy.h" +#define INSTANTIATE_READVAL(CLASS) \ + template Double_t CLASS::ReadValueImpl(char*, Int_t); \ + template Long64_t CLASS::ReadValueImpl(char*, Int_t); \ + template LongDouble_t CLASS::ReadValueImpl(char*, Int_t) // no semicolon + + +#define INSTANTIATE_GETVAL(CLASS) \ + template Double_t CLASS::GetValueImpl(TLeaf*, Int_t); \ + template Long64_t CLASS::GetValueImpl(TLeaf*, Int_t); \ + template LongDouble_t CLASS::GetValueImpl(TLeaf*, Int_t) // no semicolon + //______________________________________________________________________________ // // This class is a small helper class to implement reading a data member @@ -761,10 +772,11 @@ void* TFormLeafInfo::GetLocalValuePointer(char *thisobj, Int_t instance) } } - + //______________________________________________________________________________ -Double_t TFormLeafInfo::GetValue(TLeaf *leaf, Int_t instance) +template +T TFormLeafInfo::GetValueImpl(TLeaf *leaf, Int_t instance) { // Return result of a leafobject method. @@ -775,11 +787,15 @@ Double_t TFormLeafInfo::GetValue(TLeaf *leaf, Int_t instance) thisobj = GetObjectAddress((TLeafElement*)leaf, instance); // instance might be modified } if (thisobj==0) return 0; - return ReadValue(thisobj,instance); + return ReadTypedValue(thisobj,instance); } +INSTANTIATE_GETVAL(TFormLeafInfo); +INSTANTIATE_READVAL(TFormLeafInfo); + //______________________________________________________________________________ -Double_t TFormLeafInfo::ReadValue(char *thisobj, Int_t instance) +template +T TFormLeafInfo::ReadValueImpl(char *thisobj, Int_t instance) { // Read the value at the given memory location if ( !thisobj ) { @@ -804,65 +820,64 @@ Double_t TFormLeafInfo::ReadValue(char *thisobj, Int_t instance) } nextobj += index*fElement->GetClassPointer()->Size(); } - return fNext->ReadValue(nextobj,sub_instance); + return fNext->ReadTypedValue(nextobj,sub_instance); } // return fInfo->ReadValue(thisobj+fOffset,fElement->GetNewType(),instance,1); switch (fElement->GetNewType()) { // basic types - case TStreamerInfo::kBool: return (Double_t)(*(Bool_t*)(thisobj+fOffset)); - case TStreamerInfo::kChar: return (Double_t)(*(Char_t*)(thisobj+fOffset)); - case TStreamerInfo::kUChar: return (Double_t)(*(UChar_t*)(thisobj+fOffset)); - case TStreamerInfo::kShort: return (Double_t)(*(Short_t*)(thisobj+fOffset)); - case TStreamerInfo::kUShort: return (Double_t)(*(UShort_t*)(thisobj+fOffset)); - case TStreamerInfo::kInt: return (Double_t)(*(Int_t*)(thisobj+fOffset)); - case TStreamerInfo::kUInt: return (Double_t)(*(UInt_t*)(thisobj+fOffset)); - case TStreamerInfo::kLong: return (Double_t)(*(Long_t*)(thisobj+fOffset)); - case TStreamerInfo::kULong: return (Double_t)(*(ULong_t*)(thisobj+fOffset)); - case TStreamerInfo::kLong64: return (Double_t)(*(Long64_t*)(thisobj+fOffset)); - case TStreamerInfo::kULong64: return (Double_t)(*(Long64_t*)(thisobj+fOffset)); //cannot cast to ULong64_t with VC++6 - case TStreamerInfo::kFloat: return (Double_t)(*(Float_t*)(thisobj+fOffset)); - case TStreamerInfo::kFloat16: return (Double_t)(*(Float_t*)(thisobj+fOffset)); - case TStreamerInfo::kDouble: return (Double_t)(*(Double_t*)(thisobj+fOffset)); - case TStreamerInfo::kDouble32: return (Double_t)(*(Double_t*)(thisobj+fOffset)); - case TStreamerInfo::kLegacyChar: return (Double_t)(*(char*)(thisobj+fOffset)); - case TStreamerInfo::kCounter: - return (Double_t)(*(Int_t*)(thisobj+fOffset)); + case TStreamerInfo::kBool: return (T)(*(Bool_t*)(thisobj+fOffset)); + case TStreamerInfo::kChar: return (T)(*(Char_t*)(thisobj+fOffset)); + case TStreamerInfo::kUChar: return (T)(*(UChar_t*)(thisobj+fOffset)); + case TStreamerInfo::kShort: return (T)(*(Short_t*)(thisobj+fOffset)); + case TStreamerInfo::kUShort: return (T)(*(UShort_t*)(thisobj+fOffset)); + case TStreamerInfo::kInt: return (T)(*(Int_t*)(thisobj+fOffset)); + case TStreamerInfo::kUInt: return (T)(*(UInt_t*)(thisobj+fOffset)); + case TStreamerInfo::kLong: return (T)(*(Long_t*)(thisobj+fOffset)); + case TStreamerInfo::kULong: return (T)(*(ULong_t*)(thisobj+fOffset)); + case TStreamerInfo::kLong64: return (T)(*(Long64_t*)(thisobj+fOffset)); + case TStreamerInfo::kULong64: return (T)(*(Long64_t*)(thisobj+fOffset)); //cannot cast to ULong64_t with VC++6 + case TStreamerInfo::kFloat: return (T)(*(Float_t*)(thisobj+fOffset)); + case TStreamerInfo::kFloat16: return (T)(*(Float_t*)(thisobj+fOffset)); + case TStreamerInfo::kDouble: return (T)(*(Double_t*)(thisobj+fOffset)); + case TStreamerInfo::kDouble32: return (T)(*(Double_t*)(thisobj+fOffset)); + case TStreamerInfo::kLegacyChar: return (T)(*(char*)(thisobj+fOffset)); + case TStreamerInfo::kCounter: return (T)(*(Int_t*)(thisobj+fOffset)); // array of basic types array[8] case TStreamerInfo::kOffsetL + TStreamerInfo::kBool: - {Bool_t *val = (Bool_t*)(thisobj+fOffset); return Double_t(val[instance]);} + {Bool_t *val = (Bool_t*)(thisobj+fOffset); return T(val[instance]);} case TStreamerInfo::kOffsetL + TStreamerInfo::kChar: - {Char_t *val = (Char_t*)(thisobj+fOffset); return Double_t(val[instance]);} + {Char_t *val = (Char_t*)(thisobj+fOffset); return T(val[instance]);} case TStreamerInfo::kOffsetL + TStreamerInfo::kShort: - {Short_t *val = (Short_t*)(thisobj+fOffset); return Double_t(val[instance]);} + {Short_t *val = (Short_t*)(thisobj+fOffset); return T(val[instance]);} case TStreamerInfo::kOffsetL + TStreamerInfo::kInt: - {Int_t *val = (Int_t*)(thisobj+fOffset); return Double_t(val[instance]);} + {Int_t *val = (Int_t*)(thisobj+fOffset); return T(val[instance]);} case TStreamerInfo::kOffsetL + TStreamerInfo::kLong: - {Long_t *val = (Long_t*)(thisobj+fOffset); return Double_t(val[instance]);} + {Long_t *val = (Long_t*)(thisobj+fOffset); return T(val[instance]);} case TStreamerInfo::kOffsetL + TStreamerInfo::kLong64: - {Long64_t *val = (Long64_t*)(thisobj+fOffset); return Double_t(val[instance]);} + {Long64_t *val = (Long64_t*)(thisobj+fOffset); return T(val[instance]);} case TStreamerInfo::kOffsetL + TStreamerInfo::kFloat16: - {Float_t *val = (Float_t*)(thisobj+fOffset); return Double_t(val[instance]);} + {Float_t *val = (Float_t*)(thisobj+fOffset); return T(val[instance]);} case TStreamerInfo::kOffsetL + TStreamerInfo::kFloat: - {Float_t *val = (Float_t*)(thisobj+fOffset); return Double_t(val[instance]);} + {Float_t *val = (Float_t*)(thisobj+fOffset); return T(val[instance]);} case TStreamerInfo::kOffsetL + TStreamerInfo::kDouble: - {Double_t *val = (Double_t*)(thisobj+fOffset); return Double_t(val[instance]);} + {Double_t *val = (Double_t*)(thisobj+fOffset); return T(val[instance]);} case TStreamerInfo::kOffsetL + TStreamerInfo::kDouble32: - {Double_t *val = (Double_t*)(thisobj+fOffset); return Double_t(val[instance]);} + {Double_t *val = (Double_t*)(thisobj+fOffset); return T(val[instance]);} case TStreamerInfo::kOffsetL + TStreamerInfo::kUChar: - {UChar_t *val = (UChar_t*)(thisobj+fOffset); return Double_t(val[instance]);} + {UChar_t *val = (UChar_t*)(thisobj+fOffset); return T(val[instance]);} case TStreamerInfo::kOffsetL + TStreamerInfo::kUShort: - {UShort_t *val = (UShort_t*)(thisobj+fOffset); return Double_t(val[instance]);} + {UShort_t *val = (UShort_t*)(thisobj+fOffset); return T(val[instance]);} case TStreamerInfo::kOffsetL + TStreamerInfo::kUInt: - {UInt_t *val = (UInt_t*)(thisobj+fOffset); return Double_t(val[instance]);} + {UInt_t *val = (UInt_t*)(thisobj+fOffset); return T(val[instance]);} case TStreamerInfo::kOffsetL + TStreamerInfo::kULong: - {ULong_t *val = (ULong_t*)(thisobj+fOffset); return Double_t(val[instance]);} + {ULong_t *val = (ULong_t*)(thisobj+fOffset); return T(val[instance]);} #if defined(_MSC_VER) && (_MSC_VER <= 1200) case TStreamerInfo::kOffsetL + TStreamerInfo::kULong64: - {Long64_t *val = (Long64_t*)(thisobj+fOffset); return Double_t(val[instance]);} + {Long64_t *val = (Long64_t*)(thisobj+fOffset); return T(val[instance]);} #else case TStreamerInfo::kOffsetL + kULong64_t: - {ULong64_t *val = (ULong64_t*)(thisobj+fOffset); return Double_t(val[instance]);} + {ULong64_t *val = (ULong64_t*)(thisobj+fOffset); return T(val[instance]);} #endif #define READ_ARRAY(TYPE_t) \ @@ -877,7 +892,7 @@ Double_t TFormLeafInfo::ReadValue(char *thisobj, Int_t instance) sub_instance = 0; \ } \ TYPE_t **val =(TYPE_t**)(thisobj+fOffset); \ - return Double_t((val[sub_instance])[index]); \ + return T((val[sub_instance])[index]); \ } // pointer to an array of basic types array[n] @@ -935,12 +950,16 @@ Double_t TFormLeafInfoDirect::ReadValue(char * /*where*/, Int_t /*instance*/) } //______________________________________________________________________________ -Double_t TFormLeafInfoDirect:: GetValue(TLeaf *leaf, Int_t instance) +template +T TFormLeafInfoDirect::GetValueImpl(TLeaf *leaf, Int_t instance) { // Return the underlying value. - return leaf->GetValue(instance); + return leaf->GetTypedValue(instance); } +INSTANTIATE_GETVAL(TFormLeafInfoDirect); + + //______________________________________________________________________________ void* TFormLeafInfoDirect::GetLocalValuePointer(TLeaf *leaf, Int_t instance) { @@ -1148,7 +1167,8 @@ Int_t TFormLeafInfoClones::ReadCounterValue(char* where) } //______________________________________________________________________________ -Double_t TFormLeafInfoClones::ReadValue(char *where, Int_t instance) +template +T TFormLeafInfoClones::ReadValueImpl(char *where, Int_t instance) { // Return the value of the underlying data member inside the // clones array. @@ -1168,9 +1188,12 @@ Double_t TFormLeafInfoClones::ReadValue(char *where, Int_t instance) // Note we take advantage of having only one physically variable // dimension: char * obj = (char*)clones->UncheckedAt(index); - return fNext->ReadValue(obj,sub_instance); + return fNext->ReadTypedValue(obj,sub_instance); } +INSTANTIATE_GETVAL(TFormLeafInfoClones); +INSTANTIATE_READVAL(TFormLeafInfoClones); + //______________________________________________________________________________ void* TFormLeafInfoClones::GetLocalValuePointer(TLeaf *leaf, Int_t /*instance*/) { @@ -1197,7 +1220,8 @@ void* TFormLeafInfoClones::GetLocalValuePointer(char *where, Int_t instance) } //______________________________________________________________________________ -Double_t TFormLeafInfoClones::GetValue(TLeaf *leaf, Int_t instance) +template +T TFormLeafInfoClones::GetValueImpl(TLeaf *leaf, Int_t instance) { // Return the value of the underlying data member inside the // clones array. @@ -1222,7 +1246,7 @@ Double_t TFormLeafInfoClones::GetValue(TLeaf *leaf, Int_t instance) // Note we take advantage of having only one physically variable // dimension: char * obj = (char*)clones->UncheckedAt(index); - return fNext->ReadValue(obj,sub_instance); + return fNext->ReadTypedValue(obj,sub_instance); } //______________________________________________________________________________ @@ -1351,7 +1375,8 @@ void* TFormLeafInfoCollectionObject::GetLocalValuePointer(char *where, Int_t ins } //______________________________________________________________________________ -Double_t TFormLeafInfoCollectionObject::GetValue(TLeaf *leaf, Int_t instance) +template +T TFormLeafInfoCollectionObject::GetValueImpl(TLeaf *leaf, Int_t instance) { // Return the value of the underlying data member inside the // clones array. @@ -1359,9 +1384,12 @@ Double_t TFormLeafInfoCollectionObject::GetValue(TLeaf *leaf, Int_t instance) char * obj = (char*)GetLocalValuePointer(leaf); if (fNext==0) return 0; - return fNext->ReadValue(obj,instance); + return fNext->ReadTypedValue(obj,instance); } +INSTANTIATE_GETVAL(TFormLeafInfoCollectionObject); + + //______________________________________________________________________________ void * TFormLeafInfoCollectionObject::GetValuePointer(TLeaf *leaf, Int_t instance) { @@ -1583,7 +1611,8 @@ Int_t TFormLeafInfoCollection::GetCounterValue(TLeaf* leaf, Int_t instance) } //______________________________________________________________________________ -Double_t TFormLeafInfoCollection::ReadValue(char *where, Int_t instance) +template +T TFormLeafInfoCollection::ReadValueImpl(char *where, Int_t instance) { // Return the value of the underlying data member inside the // clones array. @@ -1612,9 +1641,13 @@ Double_t TFormLeafInfoCollection::ReadValue(char *where, Int_t instance) char * obj = (char*)fCollProxy->At(index); if (fCollProxy->HasPointers()) obj = *(char**)obj; - return fNext->ReadValue(obj,sub_instance); + return fNext->ReadTypedValue(obj,sub_instance); } +INSTANTIATE_GETVAL(TFormLeafInfoCollection); +INSTANTIATE_READVAL(TFormLeafInfoCollection); + + //______________________________________________________________________________ void* TFormLeafInfoCollection::GetLocalValuePointer(TLeaf *leaf, Int_t /*instance*/) { @@ -1641,7 +1674,8 @@ void* TFormLeafInfoCollection::GetLocalValuePointer(char *where, Int_t instance) } //______________________________________________________________________________ -Double_t TFormLeafInfoCollection::GetValue(TLeaf *leaf, Int_t instance) +template +T TFormLeafInfoCollection::GetValueImpl(TLeaf *leaf, Int_t instance) { // Return the value of the underlying data member inside the // clones array. @@ -1671,7 +1705,7 @@ Double_t TFormLeafInfoCollection::GetValue(TLeaf *leaf, Int_t instance) if (obj==0) return 0; if (fCollProxy->HasPointers()) obj = *(char**)obj; if (obj==0) return 0; - return fNext->ReadValue(obj,sub_instance); + return fNext->ReadTypedValue(obj,sub_instance); } //______________________________________________________________________________ @@ -1913,7 +1947,8 @@ TFormLeafInfo* TFormLeafInfoPointer::DeepCopy() const //______________________________________________________________________________ -Double_t TFormLeafInfoPointer::ReadValue(char *where, Int_t instance) +template +T TFormLeafInfoPointer::ReadValueImpl(char *where, Int_t instance) { // Return the value of the underlying pointer data member @@ -1927,7 +1962,7 @@ Double_t TFormLeafInfoPointer::ReadValue(char *where, Int_t instance) case TStreamerInfo::kAnyP: case TStreamerInfo::kSTLp: {TObject **obj = (TObject**)(whereoffset); - return obj && *obj ? fNext->ReadValue((char*)*obj,instance) : 0; } + return obj && *obj ? fNext->ReadTypedValue((char*)*obj,instance) : 0; } case TStreamerInfo::kObject: case TStreamerInfo::kTString: @@ -1938,7 +1973,7 @@ Double_t TFormLeafInfoPointer::ReadValue(char *where, Int_t instance) case TStreamerInfo::kSTL: { TObject *obj = (TObject*)(whereoffset); - return fNext->ReadValue((char*)obj,instance); + return fNext->ReadTypedValue((char*)obj,instance); } case TStreamerInfo::kOffsetL + TStreamerInfo::kTObject: @@ -1960,7 +1995,7 @@ Double_t TFormLeafInfoPointer::ReadValue(char *where, Int_t instance) whereoffset += index*fElement->GetClassPointer()->Size(); TObject *obj = (TObject*)(whereoffset); - return fNext->ReadValue((char*)obj,sub_instance); + return fNext->ReadTypedValue((char*)obj,sub_instance); } case TStreamerInfo::kOffsetL + TStreamerInfo::kObjectp: @@ -1970,7 +2005,7 @@ Double_t TFormLeafInfoPointer::ReadValue(char *where, Int_t instance) case TStreamerInfo::kOffsetL + TStreamerInfo::kSTLp: { TObject *obj = (TObject*)(whereoffset); - return fNext->ReadValue((char*)obj,instance); + return fNext->ReadTypedValue((char*)obj,instance); } case kOther_t: @@ -1980,16 +2015,22 @@ Double_t TFormLeafInfoPointer::ReadValue(char *where, Int_t instance) } //______________________________________________________________________________ -Double_t TFormLeafInfoPointer::GetValue(TLeaf *leaf, Int_t instance) +template +T TFormLeafInfoPointer::GetValueImpl(TLeaf *leaf, Int_t instance) { // Return the value of the underlying pointer data member if (!fNext) return 0; char * where = (char*)GetLocalValuePointer(leaf,instance); if (where==0) return 0; - return fNext->ReadValue(where,instance); + return fNext->ReadTypedValue(where,instance); } +INSTANTIATE_GETVAL(TFormLeafInfoPointer); +INSTANTIATE_READVAL(TFormLeafInfoPointer); + + + //______________________________________________________________________________ // // TFormLeafInfoMethod is a small helper class to implement executing a method @@ -2203,7 +2244,8 @@ void *TFormLeafInfoMethod::GetLocalValuePointer(char *from, } //______________________________________________________________________________ -Double_t TFormLeafInfoMethod::ReadValue(char *where, Int_t instance) +template +T TFormLeafInfoMethod::ReadValueImpl(char *where, Int_t instance) { // Execute the method on the given address @@ -2211,27 +2253,27 @@ Double_t TFormLeafInfoMethod::ReadValue(char *where, Int_t instance) if (!thisobj) return 0; TMethodCall::EReturnType r = fMethod->ReturnType(); - Double_t result = 0; + T result = 0; if (r == TMethodCall::kLong) { Long_t l = 0; fMethod->Execute(thisobj, l); - result = (Double_t) l; + result = (T) l; } else if (r == TMethodCall::kDouble) { Double_t d = 0; fMethod->Execute(thisobj, d); - result = (Double_t) d; + result = (T) d; } else if (r == TMethodCall::kString) { char *returntext = 0; fMethod->Execute(thisobj,&returntext); - result = (Long_t) returntext; + result = T((Long_t) returntext); } else if (fNext) { char * char_result = 0; fMethod->Execute(thisobj, &char_result); - result = fNext->ReadValue(char_result,instance); + result = fNext->ReadTypedValue(char_result,instance); } else fMethod->Execute(thisobj); @@ -2240,6 +2282,9 @@ Double_t TFormLeafInfoMethod::ReadValue(char *where, Int_t instance) return result; } +INSTANTIATE_READVAL(TFormLeafInfoMethod); + + //______________________________________________________________________________ // // TFormLeafInfoMultiVarDim is a helper class to implement reading a @@ -2483,12 +2528,16 @@ TFormLeafInfo* TFormLeafInfoMultiVarDimDirect::DeepCopy() const } //______________________________________________________________________________ -Double_t TFormLeafInfoMultiVarDimDirect::GetValue(TLeaf *leaf, Int_t instance) +template +T TFormLeafInfoMultiVarDimDirect::GetValueImpl(TLeaf *leaf, Int_t instance) { // Return the undersying value. - return ((TLeafElement*)leaf)->GetValueSubArray(fPrimaryIndex,instance); + return ((TLeafElement*)leaf)->GetTypedValueSubArray(fPrimaryIndex,instance); } +INSTANTIATE_GETVAL(TFormLeafInfoMultiVarDimDirect); + + //______________________________________________________________________________ Double_t TFormLeafInfoMultiVarDimDirect::ReadValue(char * /*where*/, Int_t /*instance*/) { @@ -2585,7 +2634,8 @@ void TFormLeafInfoMultiVarDimCollection::LoadSizes(TBranch* branch) } //______________________________________________________________________________ -Double_t TFormLeafInfoMultiVarDimCollection::ReadValue(char *where, Int_t instance) +template +T TFormLeafInfoMultiVarDimCollection::ReadValueImpl(char *where, Int_t instance) { // Return the value of the underlying data. if (fSecondaryIndex>=0) { @@ -2596,9 +2646,12 @@ Double_t TFormLeafInfoMultiVarDimCollection::ReadValue(char *where, Int_t instan instance = fSecondaryIndex; } } - return fNext->ReadValue(where,instance); + return fNext->ReadTypedValue(where,instance); } +INSTANTIATE_READVAL(TFormLeafInfoMultiVarDimCollection); + + //______________________________________________________________________________ // // TFormLeafInfoMultiVarDimClones is a small helper class to implement reading @@ -2691,7 +2744,8 @@ void TFormLeafInfoMultiVarDimClones::LoadSizes(TBranch* branch) } //______________________________________________________________________________ -Double_t TFormLeafInfoMultiVarDimClones::ReadValue(char *where, Int_t instance) +template +T TFormLeafInfoMultiVarDimClones::ReadValueImpl(char *where, Int_t instance) { // Return the value of the underlying data. @@ -2703,9 +2757,12 @@ Double_t TFormLeafInfoMultiVarDimClones::ReadValue(char *where, Int_t instance) instance = fSecondaryIndex; } } - return fNext->ReadValue(where,instance); + return fNext->ReadTypedValue(where,instance); } +INSTANTIATE_READVAL(TFormLeafInfoMultiVarDimClones); + + //______________________________________________________________________________ // // TFormLeafInfoCast is a small helper class to implement casting an object to @@ -2780,7 +2837,8 @@ Int_t TFormLeafInfoCast::GetNdata() } //______________________________________________________________________________ -Double_t TFormLeafInfoCast::ReadValue(char *where, Int_t instance) +template +T TFormLeafInfoCast::ReadValueImpl(char *where, Int_t instance) { // Read the value at the given memory location @@ -2797,9 +2855,12 @@ Double_t TFormLeafInfoCast::ReadValue(char *where, Int_t instance) // real class name. } fGoodCast = kTRUE; - return fNext->ReadValue(where,instance); + return fNext->ReadTypedValue(where,instance); } +INSTANTIATE_READVAL(TFormLeafInfoCast); + + //______________________________________________________________________________ Bool_t TFormLeafInfoCast::Update() { @@ -2856,23 +2917,28 @@ void* TFormLeafInfoTTree::GetLocalValuePointer(TLeaf *, Int_t instance) } //______________________________________________________________________________ -Double_t TFormLeafInfoTTree::GetValue(TLeaf *, Int_t instance) +template +T TFormLeafInfoTTree::GetValueImpl(TLeaf *, Int_t instance) { // Return result of a leafobject method. - return ReadValue((char*)fCurrent,instance); + return ReadTypedValue((char*)fCurrent,instance); } //______________________________________________________________________________ -Double_t TFormLeafInfoTTree::ReadValue(char *thisobj, Int_t instance) +template +T TFormLeafInfoTTree::ReadValueImpl(char *thisobj, Int_t instance) { // Return result of a leafobject method. - if (fElement) return TFormLeafInfo::ReadValue(thisobj,instance); - else if (fNext) return fNext->ReadValue(thisobj,instance); + if (fElement) return TFormLeafInfo::ReadTypedValue(thisobj,instance); + else if (fNext) return fNext->ReadTypedValue(thisobj,instance); else return 0; } +INSTANTIATE_GETVAL(TFormLeafInfoTTree); +INSTANTIATE_READVAL(TFormLeafInfoTTree); + //______________________________________________________________________________ Bool_t TFormLeafInfoTTree::Update() { diff --git a/tree/treeplayer/src/TFormLeafInfoReference.cxx b/tree/treeplayer/src/TFormLeafInfoReference.cxx index ea7d83b902c5e..7c7665f8c72ec 100644 --- a/tree/treeplayer/src/TFormLeafInfoReference.cxx +++ b/tree/treeplayer/src/TFormLeafInfoReference.cxx @@ -160,13 +160,17 @@ Bool_t TFormLeafInfoReference::Update() } //______________________________________________________________________________ -Double_t TFormLeafInfoReference::GetValue(TLeaf *leaf, Int_t instance) +template +T TFormLeafInfoReference::GetValueImpl(TLeaf *leaf, Int_t instance) { // Return result of a leafobject method - fBranch = leaf->GetBranch(); - return TFormLeafInfo::GetValue(leaf, instance); + return TFormLeafInfo::GetValueImpl(leaf, instance); } +template Double_t TFormLeafInfoReference::GetValueImpl(TLeaf*, Int_t); +template Long64_t TFormLeafInfoReference::GetValueImpl(TLeaf*, Int_t); +template LongDouble_t TFormLeafInfoReference::GetValueImpl(TLeaf*, Int_t); + //______________________________________________________________________________ void *TFormLeafInfoReference::GetLocalValuePointer( TLeaf *from, Int_t instance) @@ -196,17 +200,18 @@ void *TFormLeafInfoReference::GetLocalValuePointer(char *where, Int_t instance) } //______________________________________________________________________________ -Double_t TFormLeafInfoReference::ReadValue(char *where, Int_t instance) +template +T TFormLeafInfoReference::ReadValueImpl(char *where, Int_t instance) { // Execute the method on the given address - Double_t result = 0; + T result = 0; if ( where ) { where = (char*)fProxy->GetPreparedReference(where); if ( where ) { void* res = fProxy->GetObject(this, where, instance); if ( res ) { - result = (fNext) ? fNext->ReadValue((char*)res,instance) : *(Double_t*)res; + result = (fNext) ? fNext->ReadTypedValue((char*)res,instance) : *(Double_t*)res; } } } @@ -214,3 +219,8 @@ Double_t TFormLeafInfoReference::ReadValue(char *where, Int_t instance) // Get rid of temporary return object. return result; } + +template Double_t TFormLeafInfoReference::ReadValueImpl(char*, Int_t); +template Long64_t TFormLeafInfoReference::ReadValueImpl(char*, Int_t); +template LongDouble_t TFormLeafInfoReference::ReadValueImpl(char*, Int_t); + diff --git a/tree/treeplayer/src/TTreeFormula.cxx b/tree/treeplayer/src/TTreeFormula.cxx index b01483c24c6a9..afafe3d2a1358 100644 --- a/tree/treeplayer/src/TTreeFormula.cxx +++ b/tree/treeplayer/src/TTreeFormula.cxx @@ -57,7 +57,6 @@ const Int_t kMaxLen = 1024; R__EXTERN TTree *gTree; - ClassImp(TTreeFormula) //______________________________________________________________________________ @@ -141,6 +140,7 @@ TTreeFormula::TTreeFormula(): TFormula(), fQuickLoad(kFALSE), fNeedLoading(kTRUE fHasCast = 0; fManager = 0; fMultiplicity = 0; + fConstLD = 0; Int_t j,k; for (j=0; jAdd(this); @@ -350,6 +351,7 @@ TTreeFormula::~TTreeFormula() fDimensionSetup->Delete(); delete fDimensionSetup; } + delete[] fConstLD; } //______________________________________________________________________________ @@ -3762,107 +3764,144 @@ const char* TTreeFormula::EvalStringInstance(Int_t instance) \ if (real_instance>=fNdata[code]) return 0; -namespace { - Double_t Summing(TTreeFormula *sum) { - Int_t len = sum->GetNdata(); - Double_t res = 0; - for (int i=0; iEvalInstance(i); - return res; + +template T Summing(TTreeFormula *sum) { + Int_t len = sum->GetNdata(); + T res = 0; + for (int i=0; iEvalInstance(i); + return res; +} + +template T FindMin(TTreeFormula *arr) { + Int_t len = arr->GetNdata(); + T res = 0; + if (len) { + res = arr->EvalInstance(0); + for (int i=1; iEvalInstance(i); + if (val < res) { + res = val; + } + } } - Double_t FindMin(TTreeFormula *arr) { - Int_t len = arr->GetNdata(); - Double_t res = 0; - if (len) { - res = arr->EvalInstance(0); - for (int i=1; iEvalInstance(i); - if (val < res) { - res = val; - } + return res; +} + +template T FindMax(TTreeFormula *arr) { + Int_t len = arr->GetNdata(); + T res = 0; + if (len) { + res = arr->EvalInstance(0); + for (int i=1; iEvalInstance(i); + if (val > res) { + res = val; } } - return res; } - Double_t FindMax(TTreeFormula *arr) { - Int_t len = arr->GetNdata(); - Double_t res = 0; - if (len) { - res = arr->EvalInstance(0); - for (int i=1; iEvalInstance(i); - if (val > res) { + return res; +} + +template T FindMin(TTreeFormula *arr, TTreeFormula *condition) { + Int_t len = arr->GetNdata(); + T res = 0; + if (len) { + int i = 0; + T condval; + do { + condval = condition->EvalInstance(i); + ++i; + } while (!condval && iEvalInstance(0); + } + // Now we know that i>0 && iEvalInstance(i-1); + for (; iEvalInstance(i); + if (condval) { + T val = arr->EvalInstance(i); + if (val < res) { res = val; } } } - return res; } - Double_t FindMin(TTreeFormula *arr, TTreeFormula *condition) { - Int_t len = arr->GetNdata(); - Double_t res = 0; - if (len) { - int i = 0; - Double_t condval; - do { - condval = condition->EvalInstance(i); - ++i; - } while (!condval && iEvalInstance(0); - } - // Now we know that i>0 && iEvalInstance(i-1); - for (; iEvalInstance(i); - if (condval) { - Double_t val = arr->EvalInstance(i); - if (val < res) { - res = val; - } + return res; +} + +template T FindMax(TTreeFormula *arr, TTreeFormula *condition) { + Int_t len = arr->GetNdata(); + T res = 0; + if (len) { + int i = 0; + T condval; + do { + condval = condition->EvalInstance(i); + ++i; + } while (!condval && iEvalInstance(0); + } + // Now we know that i>0 && iEvalInstance(i-1); + for (; iEvalInstance(i); + if (condval) { + T val = arr->EvalInstance(i); + if (val > res) { + res = val; } } } - return res; } - Double_t FindMax(TTreeFormula *arr, TTreeFormula *condition) { - Int_t len = arr->GetNdata(); - Double_t res = 0; - if (len) { - int i = 0; - Double_t condval; - do { - condval = condition->EvalInstance(i); - ++i; - } while (!condval && iEvalInstance(0); - } - // Now we know that i>0 && iEvalInstance(i-1); - for (; iEvalInstance(i); - if (condval) { - Double_t val = arr->EvalInstance(i); - if (val > res) { - res = val; - } + return res; +} + + + +template inline T POWER(T x, T y) { return TMath::Power(x, y); } +template<> Long64_t POWER(Long64_t x, Long64_t y) { return TMath::Power(x, (Int_t)y); } +template<> LongDouble_t POWER(LongDouble_t x, LongDouble_t y) { return TMath::Power(x, (Double_t)y); } + +template inline void SetMethodParam(TMethodCall *method, T p) { method->SetParam(p); } +template<> void SetMethodParam(TMethodCall *method, LongDouble_t p) { method->SetParam((Double_t)p); } + + +template inline T TTreeFormula::GetConstant(Int_t k) { return fConst[k]; } +template<> inline LongDouble_t TTreeFormula::GetConstant(Int_t k) { + if( !fConstLD ) { + // create LD version of the constants list by rescanning all literals used in the expression + fConstLD = new LongDouble_t[fNconst]; + for (Int_t op=0; op> kTFOperShift) == kConstant ) { + int i = (oper & kTFOperMask); + if( !strncmp(fExpr[op], "0x", 2) || !strncmp(fExpr[op], "0X", 2) ) { + ULong64_t val; + sscanf( fExpr[op], "%llx", &val ); + fConstLD[i] = (LongDouble_t)val; + } else { + sscanf( fExpr[op], "%Lg", &fConstLD[i] ); } } } - return res; } + return fConstLD[k]; } +template<> inline Long64_t TTreeFormula::GetConstant(Int_t k) { return (Long64_t)GetConstant(k); } //______________________________________________________________________________ -Double_t TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[]) +template +T TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[]) { //*-*-*-*-*-*-*-*-*-*-*Evaluate this treeformula*-*-*-*-*-*-*-*-*-*-*-*-*-*-* //*-* ========================= @@ -3870,15 +3909,13 @@ Double_t TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[] // Note that the redundance and structure in this code is tailored to improve // efficiencies. - if (TestBit(kMissingLeaf)) return 0; if (fNoper == 1 && fNcodes > 0) { - + switch (fLookupType[0]) { case kDirect: { TT_EVAL_INIT; - Double_t result = leaf->GetValue(real_instance); - return result; + return leaf->GetTypedValue(real_instance); } case kMethod: { TT_EVAL_INIT; @@ -3888,21 +3925,21 @@ Double_t TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[] case kDataMember: { TT_EVAL_INIT; ((TFormLeafInfo*)fDataMembers.UncheckedAt(0))->SetBranch(leaf->GetBranch()); - return ((TFormLeafInfo*)fDataMembers.UncheckedAt(0))->GetValue(leaf,real_instance); + return ((TFormLeafInfo*)fDataMembers.UncheckedAt(0))->GetTypedValue(leaf,real_instance); } case kTreeMember: { TREE_EVAL_INIT; - return ((TFormLeafInfo*)fDataMembers.UncheckedAt(0))->GetValue((TLeaf*)0x0,real_instance); + return ((TFormLeafInfo*)fDataMembers.UncheckedAt(0))->GetTypedValue((TLeaf*)0x0,real_instance); } - case kIndexOfEntry: return (Double_t)fTree->GetReadEntry(); - case kIndexOfLocalEntry: return (Double_t)fTree->GetTree()->GetReadEntry(); - case kEntries: return (Double_t)fTree->GetEntries(); + case kIndexOfEntry: return (T)fTree->GetReadEntry(); + case kIndexOfLocalEntry: return (T)fTree->GetTree()->GetReadEntry(); + case kEntries: return (T)fTree->GetEntries(); case kLength: return fManager->fNdata; case kLengthFunc: return ((TTreeFormula*)fAliases.UncheckedAt(0))->GetNdata(); case kIteration: return instance; - case kSum: return Summing((TTreeFormula*)fAliases.UncheckedAt(0)); - case kMin: return FindMin((TTreeFormula*)fAliases.UncheckedAt(0)); - case kMax: return FindMax((TTreeFormula*)fAliases.UncheckedAt(0)); + case kSum: return Summing((TTreeFormula*)fAliases.UncheckedAt(0)); + case kMin: return FindMin((TTreeFormula*)fAliases.UncheckedAt(0)); + case kMax: return FindMax((TTreeFormula*)fAliases.UncheckedAt(0)); case kEntryList: { TEntryList *elist = (TEntryList*)fExternalCuts.At(0); return elist->Contains(fTree->GetTree()->GetReadEntry()); @@ -3914,20 +3951,20 @@ Double_t TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[] TCutG *gcut = (TCutG*)fExternalCuts.At(0); TTreeFormula *fx = (TTreeFormula *)gcut->GetObjectX(); TTreeFormula *fy = (TTreeFormula *)gcut->GetObjectY(); - Double_t xcut = fx->EvalInstance(instance); - Double_t ycut = fy->EvalInstance(instance); + T xcut = fx->EvalInstance(instance); + T ycut = fy->EvalInstance(instance); return gcut->IsInside(xcut,ycut); } case -1: { TCutG *gcut = (TCutG*)fExternalCuts.At(0); TTreeFormula *fx = (TTreeFormula *)gcut->GetObjectX(); - return fx->EvalInstance(instance); + return fx->EvalInstance(instance); } default: return 0; } } - Double_t tab[kMAXFOUND]; + T tab[kMAXFOUND]; const Int_t kMAXSTRINGFOUND = 10; const char *stringStackLocal[kMAXSTRINGFOUND]; const char **stringStack = stringStackArg?stringStackArg:stringStackLocal; @@ -3946,7 +3983,7 @@ Double_t TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[] // TFormula operands. // one of the most used cases - if (newaction==kConstant) { pos++; tab[pos-1] = fConst[(oper & kTFOperMask)]; continue; } + if (newaction==kConstant) { pos++; tab[pos-1] = GetConstant(oper & kTFOperMask); continue; } switch(newaction) { @@ -3960,7 +3997,7 @@ Double_t TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[] case kModulo : {pos--; Long64_t int1((Long64_t)tab[pos-1]); Long64_t int2((Long64_t)tab[pos]); - tab[pos-1] = Double_t(int1%int2); + tab[pos-1] = T(int1 % int2); continue;} case kcos : tab[pos-1] = TMath::Cos(tab[pos-1]); continue; @@ -3968,10 +4005,10 @@ Double_t TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[] case ktan : if (TMath::Cos(tab[pos-1]) == 0) {tab[pos-1] = 0;} // { tangente indeterminee } else tab[pos-1] = TMath::Tan(tab[pos-1]); continue; - case kacos : if (TMath::Abs(tab[pos-1]) > 1) {tab[pos-1] = 0;} // indetermination + case kacos : if (std::abs(tab[pos-1]) > 1) {tab[pos-1] = 0;} // indetermination else tab[pos-1] = TMath::ACos(tab[pos-1]); continue; - case kasin : if (TMath::Abs(tab[pos-1]) > 1) {tab[pos-1] = 0;} // indetermination + case kasin : if (std::abs(tab[pos-1]) > 1) {tab[pos-1] = 0;} // indetermination else tab[pos-1] = TMath::ASin(tab[pos-1]); continue; case katan : tab[pos-1] = TMath::ATan(tab[pos-1]); continue; @@ -3984,20 +4021,20 @@ Double_t TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[] else tab[pos-1] = TMath::ACosH(tab[pos-1]); continue; case kasinh: tab[pos-1] = TMath::ASinH(tab[pos-1]); continue; - case katanh: if (TMath::Abs(tab[pos-1]) > 1) {tab[pos-1] = 0;} // indetermination + case katanh: if (std::abs(tab[pos-1]) > 1) {tab[pos-1] = 0;} // indetermination else tab[pos-1] = TMath::ATanH(tab[pos-1]); continue; case katan2: pos--; tab[pos-1] = TMath::ATan2(tab[pos-1],tab[pos]); continue; case kfmod : pos--; tab[pos-1] = fmod(tab[pos-1],tab[pos]); continue; - case kpow : pos--; tab[pos-1] = TMath::Power(tab[pos-1],tab[pos]); continue; + case kpow : pos--; tab[pos-1] = POWER(tab[pos-1],tab[pos]); continue; case ksq : tab[pos-1] = tab[pos-1]*tab[pos-1]; continue; - case ksqrt : tab[pos-1] = TMath::Sqrt(TMath::Abs(tab[pos-1])); continue; + case ksqrt : tab[pos-1] = TMath::Sqrt(std::abs(tab[pos-1])); continue; case kstrstr : pos2 -= 2; pos++;if (strstr(stringStack[pos2],stringStack[pos2+1])) tab[pos-1]=1; else tab[pos-1]=0; continue; - case kmin : pos--; tab[pos-1] = TMath::Min(tab[pos-1],tab[pos]); continue; - case kmax : pos--; tab[pos-1] = TMath::Max(tab[pos-1],tab[pos]); continue; + case kmin : pos--; tab[pos-1] = std::min(tab[pos-1],tab[pos]); continue; + case kmax : pos--; tab[pos-1] = std::max(tab[pos-1],tab[pos]); continue; case klog : if (tab[pos-1] > 0) tab[pos-1] = TMath::Log(tab[pos-1]); else {tab[pos-1] = 0;} //{indetermination } @@ -4013,9 +4050,9 @@ Double_t TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[] case kpi : pos++; tab[pos-1] = TMath::ACos(-1); continue; - case kabs : tab[pos-1] = TMath::Abs(tab[pos-1]); continue; + case kabs : tab[pos-1] = std::abs(tab[pos-1]); continue; case ksign : if (tab[pos-1] < 0) tab[pos-1] = -1; else tab[pos-1] = 1; continue; - case kint : tab[pos-1] = Double_t(Int_t(tab[pos-1])); continue; + case kint : tab[pos-1] = T(Long64_t(tab[pos-1])); continue; case kSignInv: tab[pos-1] = -1 * tab[pos-1]; continue; case krndm : pos++; tab[pos-1] = gRandom->Rndm(1); continue; @@ -4037,10 +4074,10 @@ Double_t TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[] case kStringNotEqual: pos2 -= 2; pos++;if (strcmp(stringStack[pos2+1],stringStack[pos2])) tab[pos-1]=1; else tab[pos-1]=0; continue; - case kBitAnd : pos--; tab[pos-1]= ((Long64_t) tab[pos-1]) & ((Long64_t) tab[pos]); continue; - case kBitOr : pos--; tab[pos-1]= ((Long64_t) tab[pos-1]) | ((Long64_t) tab[pos]); continue; - case kLeftShift : pos--; tab[pos-1]= ((Long64_t) tab[pos-1]) <<((Long64_t) tab[pos]); continue; - case kRightShift: pos--; tab[pos-1]= ((Long64_t) tab[pos-1]) >>((Long64_t) tab[pos]); continue; + case kBitAnd : pos--; tab[pos-1]= ((ULong64_t) tab[pos-1]) & ((ULong64_t) tab[pos]); continue; + case kBitOr : pos--; tab[pos-1]= ((ULong64_t) tab[pos-1]) | ((ULong64_t) tab[pos]); continue; + case kLeftShift : pos--; tab[pos-1]= ((ULong64_t) tab[pos-1]) <<((ULong64_t) tab[pos]); continue; + case kRightShift: pos--; tab[pos-1]= ((ULong64_t) tab[pos-1]) >>((ULong64_t) tab[pos]); continue; case kJump : i = (oper & kTFOperMask); continue; case kJumpIf : { @@ -4061,7 +4098,7 @@ Double_t TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[] pos2++; stringStack[pos2-1] = (char*)fExpr[i].Data(); if (fAxis) { // See TT_EVAL_INIT - Int_t bin = fAxis->FindBin(stringStack[pos2-1]); \ + Int_t bin = fAxis->FindBin(stringStack[pos2-1]); return bin; } continue; @@ -4116,7 +4153,7 @@ Double_t TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[] if (nargs) { UInt_t argloc = pos-nargs; for(Int_t j=0;jSetParam( tab[argloc] ); + SetMethodParam(method, tab[argloc]); } } pos++; @@ -4140,22 +4177,22 @@ Double_t TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[] const Int_t code = (oper & kTFOperMask); const Int_t lookupType = fLookupType[code]; switch (lookupType) { - case kIndexOfEntry: tab[pos++] = (Double_t)fTree->GetReadEntry(); continue; - case kIndexOfLocalEntry: tab[pos++] = (Double_t)fTree->GetTree()->GetReadEntry(); continue; - case kEntries: tab[pos++] = (Double_t)fTree->GetEntries(); continue; + case kIndexOfEntry: tab[pos++] = (T)fTree->GetReadEntry(); continue; + case kIndexOfLocalEntry: tab[pos++] = (T)fTree->GetTree()->GetReadEntry(); continue; + case kEntries: tab[pos++] = (T)fTree->GetEntries(); continue; case kLength: tab[pos++] = fManager->fNdata; continue; case kLengthFunc: tab[pos++] = ((TTreeFormula*)fAliases.UncheckedAt(i))->GetNdata(); continue; case kIteration: tab[pos++] = instance; continue; - case kSum: tab[pos++] = Summing((TTreeFormula*)fAliases.UncheckedAt(i)); continue; - case kMin: tab[pos++] = FindMin((TTreeFormula*)fAliases.UncheckedAt(i)); continue; - case kMax: tab[pos++] = FindMax((TTreeFormula*)fAliases.UncheckedAt(i)); continue; + case kSum: tab[pos++] = Summing((TTreeFormula*)fAliases.UncheckedAt(i)); continue; + case kMin: tab[pos++] = FindMin((TTreeFormula*)fAliases.UncheckedAt(i)); continue; + case kMax: tab[pos++] = FindMax((TTreeFormula*)fAliases.UncheckedAt(i)); continue; - case kDirect: { TT_EVAL_INIT_LOOP; tab[pos++] = leaf->GetValue(real_instance); continue; } + case kDirect: { TT_EVAL_INIT_LOOP; tab[pos++] = leaf->GetTypedValue(real_instance); continue; } case kMethod: { TT_EVAL_INIT_LOOP; tab[pos++] = GetValueFromMethod(code,leaf); continue; } case kDataMember: { TT_EVAL_INIT_LOOP; tab[pos++] = ((TFormLeafInfo*)fDataMembers.UncheckedAt(code))-> - GetValue(leaf,real_instance); continue; } + GetTypedValue(leaf,real_instance); continue; } case kTreeMember: { TREE_EVAL_INIT_LOOP; tab[pos++] = ((TFormLeafInfo*)fDataMembers.UncheckedAt(code))-> - GetValue((TLeaf*)0x0,real_instance); continue; } + GetTypedValue((TLeaf*)0x0,real_instance); continue; } case kEntryList: { TEntryList *elist = (TEntryList*)fExternalCuts.At(code); tab[pos++] = elist->Contains(fTree->GetReadEntry()); continue;} @@ -4167,15 +4204,15 @@ Double_t TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[] TCutG *gcut = (TCutG*)fExternalCuts.At(code); TTreeFormula *fx = (TTreeFormula *)gcut->GetObjectX(); TTreeFormula *fy = (TTreeFormula *)gcut->GetObjectY(); - Double_t xcut = fx->EvalInstance(instance); - Double_t ycut = fy->EvalInstance(instance); + T xcut = fx->EvalInstance(instance); + T ycut = fy->EvalInstance(instance); tab[pos++] = gcut->IsInside(xcut,ycut); continue; } case -1: { TCutG *gcut = (TCutG*)fExternalCuts.At(code); TTreeFormula *fx = (TTreeFormula *)gcut->GetObjectX(); - tab[pos++] = fx->EvalInstance(instance); + tab[pos++] = fx->EvalInstance(instance); continue; } default: { @@ -4193,7 +4230,7 @@ Double_t TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[] R__ASSERT(subform); subform->fDidBooleanOptimization = fDidBooleanOptimization; - Double_t param = subform->EvalInstance(instance); + T param = subform->EvalInstance(instance); tab[pos] = param; pos++; continue; @@ -4213,7 +4250,7 @@ Double_t TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[] int alternateN = i; TTreeFormula *primary = static_cast(fAliases.UncheckedAt(alternateN)); TTreeFormula *condition = static_cast(fAliases.UncheckedAt(alternateN+1)); - Double_t param = FindMin(primary,condition); + T param = FindMin(primary,condition); ++i; // skip the place holder for the condition tab[pos] = param; pos++; continue; @@ -4222,7 +4259,7 @@ Double_t TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[] int alternateN = i; TTreeFormula *primary = static_cast(fAliases.UncheckedAt(alternateN)); TTreeFormula *condition = static_cast(fAliases.UncheckedAt(alternateN+1)); - Double_t param = FindMax(primary,condition); + T param = FindMax(primary,condition); ++i; // skip the place holder for the condition tab[pos] = param; pos++; continue; @@ -4236,7 +4273,7 @@ Double_t TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[] // First check whether we are in range for the primary formula if (instance < primary->GetNdata()) { - Double_t param = primary->EvalInstance(instance); + T param = primary->EvalInstance(instance); ++i; // skip the alternate value. @@ -4309,8 +4346,8 @@ Double_t TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[] R__ASSERT(iGetTypeName(),"Bool_t")) return kTRUE; if (!strcmp(leaf->GetTypeName(),"Char_t")) return kTRUE; if (!strcmp(leaf->GetTypeName(),"UChar_t")) return kTRUE; + if (!strcmp(leaf->GetTypeName(),"Long64_t")) return kTRUE; + if (!strcmp(leaf->GetTypeName(),"ULong64_t")) return kTRUE; if (!strcmp(leaf->GetTypeName(),"string")) return kTRUE; return kFALSE; } @@ -4777,7 +4816,7 @@ char *TTreeFormula::PrintValue(Int_t mode, Int_t instance, const char *decform) switch (outputSizeLevel) { case 0: snprintf(value,kMAXLENGTH,Form("%%%s",decform),(Short_t)((TTreeFormula*)this)->EvalInstance(instance)); break; case 2: snprintf(value,kMAXLENGTH,Form("%%%s",decform),(Long_t)((TTreeFormula*)this)->EvalInstance(instance)); break; - case 3: snprintf(value,kMAXLENGTH,Form("%%%s",decform),(Long64_t)((TTreeFormula*)this)->EvalInstance(instance)); break; + case 3: snprintf(value,kMAXLENGTH,Form("%%%s",decform),(Long64_t)((TTreeFormula*)this)->EvalInstance(instance)); break; case 1: default: snprintf(value,kMAXLENGTH,Form("%%%s",decform),(Int_t)((TTreeFormula*)this)->EvalInstance(instance)); break; } @@ -4791,7 +4830,7 @@ char *TTreeFormula::PrintValue(Int_t mode, Int_t instance, const char *decform) switch (outputSizeLevel) { case 0: snprintf(value,kMAXLENGTH,Form("%%%s",decform),(UShort_t)((TTreeFormula*)this)->EvalInstance(instance)); break; case 2: snprintf(value,kMAXLENGTH,Form("%%%s",decform),(ULong_t)((TTreeFormula*)this)->EvalInstance(instance)); break; - case 3: snprintf(value,kMAXLENGTH,Form("%%%s",decform),(ULong64_t)((TTreeFormula*)this)->EvalInstance(instance)); break; + case 3: snprintf(value,kMAXLENGTH,Form("%%%s",decform),(ULong64_t)((TTreeFormula*)this)->EvalInstance(instance)); break; case 1: default: snprintf(value,kMAXLENGTH,Form("%%%s",decform),(UInt_t)((TTreeFormula*)this)->EvalInstance(instance)); break; } @@ -4804,7 +4843,7 @@ char *TTreeFormula::PrintValue(Int_t mode, Int_t instance, const char *decform) case 'G': { switch (outputSizeLevel) { - case 2: snprintf(value,kMAXLENGTH,Form("%%%s",decform),(long double)((TTreeFormula*)this)->EvalInstance(instance)); break; + case 2: snprintf(value,kMAXLENGTH,Form("%%%s",decform),(LongDouble_t)((TTreeFormula*)this)->EvalInstance(instance)); break; case 1: default: snprintf(value,kMAXLENGTH,Form("%%%s",decform),((TTreeFormula*)this)->EvalInstance(instance)); break; } diff --git a/tree/treeplayer/src/TTreeIndex.cxx b/tree/treeplayer/src/TTreeIndex.cxx index 0eff1ac1ee538..f750ce028da5d 100644 --- a/tree/treeplayer/src/TTreeIndex.cxx +++ b/tree/treeplayer/src/TTreeIndex.cxx @@ -21,14 +21,35 @@ ClassImp(TTreeIndex) + +struct IndexSortComparator { + + IndexSortComparator(Long64_t *major, Long64_t *minor) + : fValMajor(major), fValMinor(minor) + {} + + template + bool operator()(Index i1, Index i2) { + if( *(fValMajor + i1) == *(fValMajor + i2) ) + return *(fValMinor + i1) < *(fValMinor + i2); + else + return *(fValMajor + i1) < *(fValMajor + i2); + } + + // pointers to the start of index values tables keeping uppder 64bit and lower 64bit + // of combined indexed 128bit value + Long64_t *fValMajor, *fValMinor; +}; + + //______________________________________________________________________________ TTreeIndex::TTreeIndex(): TVirtualIndex() { // Default constructor for TTreeIndex - fTree = 0; fN = 0; fIndexValues = 0; + fIndexValuesMinor = 0; fIndex = 0; fMajorFormula = 0; fMinorFormula = 0; @@ -100,6 +121,7 @@ TTreeIndex::TTreeIndex(const TTree *T, const char *majorname, const char *minorn fTree = (TTree*)T; fN = 0; fIndexValues = 0; + fIndexValuesMinor = 0; fIndex = 0; fMajorFormula = 0; fMinorFormula = 0; @@ -134,7 +156,8 @@ TTreeIndex::TTreeIndex(const TTree *T, const char *majorname, const char *minorn // return; //} - Long64_t *w = new Long64_t[fN]; + Long64_t *tmp_major = new Long64_t[fN]; + Long64_t *tmp_minor = new Long64_t[fN]; Long64_t i; Long64_t oldEntry = fTree->GetReadEntry(); Int_t current = -1; @@ -146,21 +169,22 @@ TTreeIndex::TTreeIndex(const TTree *T, const char *majorname, const char *minorn fMajorFormula->UpdateFormulaLeaves(); fMinorFormula->UpdateFormulaLeaves(); } - Double_t majord = fMajorFormula->EvalInstance(); - Double_t minord = fMinorFormula->EvalInstance(); - Long64_t majorv = (Long64_t)majord; - Long64_t minorv = (Long64_t)minord; - w[i] = majorv<<31; - w[i] += minorv; + tmp_major[i] = (Long64_t) fMajorFormula->EvalInstance(); + tmp_minor[i] = (Long64_t) fMinorFormula->EvalInstance(); } - fIndex = new Long64_t[fN]; - TMath::Sort(fN,w,fIndex,0); + fIndex = new Long64_t[fN]; + for(i = 0; i < fN; i++) { fIndex[i] = i; } + std::sort(fIndex, fIndex + fN, IndexSortComparator(tmp_major, tmp_minor) ); + //TMath::Sort(fN,w,fIndex,0); fIndexValues = new Long64_t[fN]; + fIndexValuesMinor = new Long64_t[fN]; for (i=0;iLoadTree(oldEntry); } @@ -171,6 +195,7 @@ TTreeIndex::~TTreeIndex() if (fTree && fTree->GetTreeIndex() == this) fTree->SetTreeIndex(0); delete [] fIndexValues; fIndexValues = 0; + delete [] fIndexValuesMinor; fIndexValuesMinor = 0; delete [] fIndex; fIndex = 0; delete fMajorFormula; fMajorFormula = 0; delete fMinorFormula; fMinorFormula = 0; @@ -199,53 +224,85 @@ void TTreeIndex::Append(const TVirtualIndex *add, Bool_t delaySort ) fN += add->GetN(); Long64_t *oldIndex = fIndex; - Long64_t *oldValues = fIndexValues; + Long64_t *oldValues = GetIndexValues(); + Long64_t *oldValues2 = GetIndexValuesMinor(); fIndex = new Long64_t[fN]; fIndexValues = new Long64_t[fN]; + fIndexValuesMinor = new Long64_t[fN]; // Copy data - Long_t size = sizeof(Long64_t) * oldn; Long_t add_size = sizeof(Long64_t) * add->GetN(); memcpy(fIndex,oldIndex, size); memcpy(fIndexValues,oldValues, size); + memcpy(fIndexValuesMinor,oldValues2, size); Long64_t *addIndex = ti_add->GetIndex(); Long64_t *addValues = ti_add->GetIndexValues(); + Long64_t *addValues2 = ti_add->GetIndexValuesMinor(); memcpy(fIndex + oldn, addIndex, add_size); memcpy(fIndexValues + oldn, addValues, add_size); + memcpy(fIndexValuesMinor + oldn, addValues2, add_size); for(Int_t i = 0; i < add->GetN(); i++) { fIndex[oldn + i] += oldn; } delete [] oldIndex; delete [] oldValues; + delete [] oldValues2; } // Sort. if (!delaySort) { - Long64_t *w = fIndexValues; + Long64_t *addValues = GetIndexValues(); + Long64_t *addValues2 = GetIndexValuesMinor(); Long64_t *ind = fIndex; Long64_t *conv = new Long64_t[fN]; - TMath::Sort(fN,w,conv,0); + for(Long64_t i = 0; i < fN; i++) { conv[i] = i; } + std::sort(conv, conv+fN, IndexSortComparator(addValues, addValues2) ); + //Long64_t *w = fIndexValues; + //TMath::Sort(fN,w,conv,0); fIndex = new Long64_t[fN]; fIndexValues = new Long64_t[fN]; + fIndexValuesMinor = new Long64_t[fN]; for (Int_t i=0;i>= 31; + } + return true; + } + return false; +} + + + //______________________________________________________________________________ Long64_t TTreeIndex::GetEntryNumberFriend(const TTree *parent) { @@ -282,8 +339,33 @@ Long64_t TTreeIndex::GetEntryNumberFriend(const TTree *parent) return fTree->GetEntryNumberWithIndex(majorv,minorv); } + +//______________________________________________________________________________ +Long64_t TTreeIndex::FindValues(Long64_t major, Long64_t minor) const +{ + // find position where major|minor values are in the IndexValues tables + // this is the index in IndexValues table, not entry# ! + // use lower_bound STD algorithm + + Long64_t mid, step, pos = 0, count = fN; + // find lower bound using bisection + while( count > 0 ) { + step = count / 2; + mid = pos + step; + // check if *mid < major|minor + if( fIndexValues[mid] < major + || ( fIndexValues[mid] == major && fIndexValuesMinor[mid] < minor ) ) { + pos = mid+1; + count -= step + 1; + } else + count = step; + } + return pos; +} + + //______________________________________________________________________________ -Long64_t TTreeIndex::GetEntryNumberWithBestIndex(Int_t major, Int_t minor) const +Long64_t TTreeIndex::GetEntryNumberWithBestIndex(Long64_t major, Long64_t minor) const { // Return entry number corresponding to major and minor number. // Note that this function returns only the entry number, not the data @@ -301,16 +383,18 @@ Long64_t TTreeIndex::GetEntryNumberWithBestIndex(Int_t major, Int_t minor) const // See also GetEntryNumberWithIndex if (fN == 0) return -1; - Long64_t value = Long64_t(major)<<31; - value += minor; - Int_t i = TMath::BinarySearch(fN, fIndexValues, value); - if (i < 0) return -1; - return fIndex[i]; + + Long64_t pos = FindValues(major, minor); + if( pos < fN && fIndexValues[pos] == major && fIndexValuesMinor[pos] == minor ) + return fIndex[pos]; + if( --pos < 0 ) + return -1; + return fIndex[pos]; } //______________________________________________________________________________ -Long64_t TTreeIndex::GetEntryNumberWithIndex(Int_t major, Int_t minor) const +Long64_t TTreeIndex::GetEntryNumberWithIndex(Long64_t major, Long64_t minor) const { // Return entry number corresponding to major and minor number. // Note that this function returns only the entry number, not the data @@ -324,14 +408,22 @@ Long64_t TTreeIndex::GetEntryNumberWithIndex(Int_t major, Int_t minor) const // See also GetEntryNumberWithBestIndex if (fN == 0) return -1; - Long64_t value = Long64_t(major)<<31; - value += minor; - Int_t i = TMath::BinarySearch(fN, fIndexValues, value); - if (i < 0) return -1; - if (fIndexValues[i] != value) return -1; - return fIndex[i]; + + Long64_t pos = FindValues(major, minor); + if( pos < fN && fIndexValues[pos] == major && fIndexValuesMinor[pos] == minor ) + return fIndex[pos]; + return -1; +} + + +//______________________________________________________________________________ +Long64_t* TTreeIndex::GetIndexValuesMinor() const +{ + return fIndexValuesMinor; } + + //______________________________________________________________________________ TTreeFormula *TTreeIndex::GetMajorFormula() { @@ -394,6 +486,7 @@ TTreeFormula *TTreeIndex::GetMinorFormulaParent(const TTree *parent) return fMinorFormulaParent; } + //______________________________________________________________________________ void TTreeIndex::Print(Option_t * option) const { @@ -413,30 +506,26 @@ void TTreeIndex::Print(Option_t * option) const } if (printEntry) { - Printf("\n*****************************************************************"); Printf("* Index of Tree: %s/%s",fTree->GetName(),fTree->GetTitle()); Printf("*****************************************************************"); Printf("%8s : %16s : %16s : %16s","serial",fMajorName.Data(),fMinorName.Data(),"entry number"); Printf("*****************************************************************"); for (Long64_t i=0;i>31; - Printf("%8lld : %8lld : %8lld : %8lld",i,major,minor,fIndex[i]); + Printf("%8lld : %8lld : %8lld : %8lld", + i, fIndexValues[i], GetIndexValuesMinor()[i], fIndex[i]); } } else { - Printf("\n**********************************************"); Printf("* Index of Tree: %s/%s",fTree->GetName(),fTree->GetTitle()); Printf("**********************************************"); Printf("%8s : %16s : %16s","serial",fMajorName.Data(),fMinorName.Data()); Printf("**********************************************"); for (Long64_t i=0;i>31; - Printf("%8lld : %8lld : %8lld",i,major,minor); - } + Printf("%8lld : %8lld : %8lld", + i, fIndexValues[i],GetIndexValuesMinor()[i]); + } } } @@ -456,6 +545,12 @@ void TTreeIndex::Streamer(TBuffer &R__b) R__b >> fN; fIndexValues = new Long64_t[fN]; R__b.ReadFastArray(fIndexValues,fN); + if( R__v > 1 ) { + fIndexValuesMinor = new Long64_t[fN]; + R__b.ReadFastArray(fIndexValuesMinor,fN); + } else { + ConvertOldToNew(); + } fIndex = new Long64_t[fN]; R__b.ReadFastArray(fIndex,fN); R__b.CheckByteCount(R__s, R__c, TTreeIndex::IsA()); @@ -466,6 +561,7 @@ void TTreeIndex::Streamer(TBuffer &R__b) fMinorName.Streamer(R__b); R__b << fN; R__b.WriteFastArray(fIndexValues, fN); + R__b.WriteFastArray(fIndexValuesMinor, fN); R__b.WriteFastArray(fIndex, fN); R__b.SetByteCount(R__c, kTRUE); }