From 2a315950b3f3bed952a6d15ed3d193b924036b91 Mon Sep 17 00:00:00 2001 From: Ishan Goel Date: Fri, 5 Jun 2026 13:36:53 -0400 Subject: [PATCH 01/11] Another try! --- offline/packages/trackbase/Makefile.am | 3 + offline/packages/trackbase/TrkrCluster.h | 24 ++ offline/packages/trackbase/TrkrClusterv6.cc | 141 +++++++++ offline/packages/trackbase/TrkrClusterv6.h | 276 ++++++++++++++++++ .../packages/trackbase/TrkrClusterv6LinkDef.h | 5 + 5 files changed, 449 insertions(+) create mode 100644 offline/packages/trackbase/TrkrClusterv6.cc create mode 100644 offline/packages/trackbase/TrkrClusterv6.h create mode 100644 offline/packages/trackbase/TrkrClusterv6LinkDef.h diff --git a/offline/packages/trackbase/Makefile.am b/offline/packages/trackbase/Makefile.am index bcb0b81d96..3e10b1f173 100644 --- a/offline/packages/trackbase/Makefile.am +++ b/offline/packages/trackbase/Makefile.am @@ -115,6 +115,7 @@ pkginclude_HEADERS = \ TrkrClusterv3.h \ TrkrClusterv4.h \ TrkrClusterv5.h \ + TrkrClusterv6.h \ TrkrDefs.h \ TrkrHit.h \ TrkrHitSet.h \ @@ -187,6 +188,7 @@ ROOTDICTS = \ TrkrClusterv3_Dict.cc \ TrkrClusterv4_Dict.cc \ TrkrClusterv5_Dict.cc \ + TrkrClusterv6_Dict.cc \ TrkrHitSetContMvtxHelper_Dict.cc \ TrkrHitSetContMvtxHelperv1_Dict.cc \ TrkrHitSetContainer_Dict.cc \ @@ -273,6 +275,7 @@ libtrack_io_la_SOURCES = \ TrkrClusterv3.cc \ TrkrClusterv4.cc \ TrkrClusterv5.cc \ + TrkrClusterv6.cc \ TrkrDefs.cc \ TrkrHitSet.cc \ TrkrHitSetContMvtxHelper.cc \ diff --git a/offline/packages/trackbase/TrkrCluster.h b/offline/packages/trackbase/TrkrCluster.h index 7fd091a527..0fdb36b6eb 100644 --- a/offline/packages/trackbase/TrkrCluster.h +++ b/offline/packages/trackbase/TrkrCluster.h @@ -79,6 +79,30 @@ class TrkrCluster : public PHObject virtual float getPhiError() const { return NAN; } virtual float getRPhiError() const { return NAN; } virtual float getZError() const { return NAN; } + virtual unsigned int getCenAdc() const { return UINT_MAX; } + virtual float getPadCen() const { return NAN; } + virtual float getTBinCen() const { return NAN; } + virtual float getPadMax() const { return NAN; } + virtual float getTBinMax() const { return NAN; } + virtual char getSLEdge() const { return std::numeric_limits::max(); } + virtual char getSREdge() const { return std::numeric_limits::max(); } + virtual char getTLEdge() const { return std::numeric_limits::max(); } + virtual char getTREdge() const { return std::numeric_limits::max(); } + virtual char getDLEdge() const { return std::numeric_limits::max(); } + virtual char getDREdge() const { return std::numeric_limits::max(); } + virtual char getHLEdge() const { return std::numeric_limits::max(); } + virtual char getHREdge() const { return std::numeric_limits::max(); } + virtual int getSLMix() const { return std::numeric_limits::max(); } + virtual int getSRMix() const { return std::numeric_limits::max(); } + virtual int getTLMix() const { return std::numeric_limits::max(); } + virtual int getTRMix() const { return std::numeric_limits::max(); } + virtual float getPhiBinLo() const { return NAN; } + virtual float getPhiBinHi() const { return NAN; } + virtual float getTBinLo() const { return NAN; } + virtual float getTBinHi() const { return NAN; } + virtual float getPadPhase() const { return NAN; } + virtual float getTBinPhase() const { return NAN; } + virtual float getRSize() const { return NAN; } /// Acts functions, for Acts modules use only virtual void setActsLocalError(unsigned int /*i*/, unsigned int /*j*/, float /*value*/) {} diff --git a/offline/packages/trackbase/TrkrClusterv6.cc b/offline/packages/trackbase/TrkrClusterv6.cc new file mode 100644 index 0000000000..bb2c1716d7 --- /dev/null +++ b/offline/packages/trackbase/TrkrClusterv6.cc @@ -0,0 +1,141 @@ +/** + * @file trackbase/TrkrClusterv6.cc + * @author Ishan Goel + * @date May 2026 + * @brief Implementation of TrkrClusterv6 + */ +#include "TrkrClusterv6.h" + +#include +#include // for swap + +namespace +{ + // square convenience function + template + inline constexpr T square(const T& x) + { + return x * x; + } +} // namespace + +TrkrClusterv6::TrkrClusterv6() + : m_subsurfkey(TrkrDefs::SUBSURFKEYMAX) + , m_phierr(0) + , m_zerr(0) + , m_adc(0) + , m_maxadc(0) + , m_cenadc(0) + , m_padcen(0) + , m_tbincen(0) + , m_padmax(0) + , m_tbinmax(0) + , m_rsize(0) + , m_phisize(0) + , m_zsize(0) + , m_overlap(0) + , m_edge(0) + , m_sledge(0) + , m_sredge(0) + , m_tledge(0) + , m_tredge(0) + , m_dledge(0) + , m_dredge(0) + , m_hledge(0) + , m_hredge(0) + , m_slmix(0) + , m_srmix(0) + , m_tlmix(0) + , m_trmix(0) + , m_phibinlo(0) + , m_phibinhi(0) + , m_tbinlo(0) + , m_tbinhi(0) + , m_padphase(0) + , m_tbinphase(0) +{ + for (float& i : m_local) + { + i = NAN; + } +} + +void TrkrClusterv6::identify(std::ostream& os) const +{ + os << "---TrkrClusterv6--------------------" << std::endl; + + os << " (rphi,z) = (" << getLocalX(); + os << ", " << getLocalY() << ") cm "; + + os << " valid = " << isValid() << std::endl; + + os << std::endl; + os << "-----------------------------------------------" << std::endl; + + return; +} + +int TrkrClusterv6::isValid() const +{ + for (int i = 0; i < 2; ++i) + { + if (std::isnan(getPosition(i))) + { + return 0; + } + } + if (m_adc == 0xFFFF) + { + return 0; + } + + return 1; +} + +void TrkrClusterv6::CopyFrom(const TrkrCluster& source) +{ + // do nothing if copying onto oneself + if (this == &source) + { + return; + } + + // parent class method + TrkrCluster::CopyFrom(source); + + setLocalX(source.getLocalX()); + setLocalY(source.getLocalY()); + setSubSurfKey(source.getSubSurfKey()); + setAdc(source.getAdc()); + setMaxAdc(source.getMaxAdc()); + setCenAdc(source.getCenAdc()); + setPadCen(source.getPadCen()); + setTBinCen(source.getTBinCen()); + setPadMax(source.getPadMax()); + setTBinMax(source.getTBinMax()); + setPhiError(source.getRPhiError()); + setZError(source.getZError()); + setRSize(source.getRSize()); + setPhiSize(source.getPhiSize()); + setZSize(source.getZSize()); + setOverlap(source.getOverlap()); + setEdge(source.getEdge()); + setSLEdge(source.getSLEdge()); + setSREdge(source.getSREdge()); + setTLEdge(source.getTLEdge()); + setTREdge(source.getTREdge()); + setDLEdge(source.getDLEdge()); + setDREdge(source.getDREdge()); + setHLEdge(source.getHLEdge()); + setHREdge(source.getHREdge()); + setSLMix(source.getSLMix()); + setSRMix(source.getSRMix()); + setTLMix(source.getTLMix()); + setTRMix(source.getTRMix()); + setPhiBinLo(source.getPhiBinLo()); + setPhiBinHi(source.getPhiBinHi()); + setTBinLo(source.getTBinLo()); + setTBinHi(source.getTBinHi()); + setPadPhase(source.getPadPhase()); + setTBinPhase(source.getTBinPhase()); +} diff --git a/offline/packages/trackbase/TrkrClusterv6.h b/offline/packages/trackbase/TrkrClusterv6.h new file mode 100644 index 0000000000..c36d1d84ee --- /dev/null +++ b/offline/packages/trackbase/TrkrClusterv6.h @@ -0,0 +1,276 @@ +/** + * @file trackbase/TrkrClusterv6.h + * @author Ishan Goel + * @date May 2026 + * @brief Version 6 of TrkrCluster + */ +#ifndef TRACKBASE_TRKRCLUSTERV6_H +#define TRACKBASE_TRKRCLUSTERV6_H + +#include +#include +#include "TrkrCluster.h" +#include "TrkrDefs.h" + +class PHObject; + +/** + * @brief Version 6 of TrkrCluster + * + * This version of TrkrCluster is blown up to contain a maximum of information + */ + +class TrkrClusterv6 : public TrkrCluster +{ + public: + //! ctor + TrkrClusterv6(); + + //! dtor + ~TrkrClusterv6() override = default; + + // PHObject virtual overloads + + void identify(std::ostream& os = std::cout) const override; + void Reset() override {} + int isValid() const override; + PHObject* CloneMe() const override { return new TrkrClusterv6(*this); } + + //! import PHObject CopyFrom, in order to avoid clang warning + using PHObject::CopyFrom; + + //! copy content from base class + void CopyFrom(const TrkrCluster&) override; + + //! copy content from base class + void CopyFrom(TrkrCluster* source) override + { + if (!source) + { + return; + } + CopyFrom(*source); + } + + // + // cluster position + // + float getPosition(int coor) const override + { + return (coor >= 0 && coor < 2) m_local[coor] : NAN; + } + void setPosition(int coor, float xi) override + { + if (coor >= 0 && coor < 2) + { + m_local[coor] = xi; + } + } + float getLocalX() const override { return m_local[0]; } + void setLocalX(float loc0) override { m_local[0] = loc0; } + float getLocalY() const override { return m_local[1]; } + void setLocalY(float loc1) override { m_local[1] = loc1; } + + TrkrDefs::subsurfkey getSubSurfKey() const override { return m_subsurfkey; } + void setSubSurfKey(TrkrDefs::subsurfkey id) override { m_subsurfkey = id; } + + // + // cluster info + // + unsigned int getAdc() const override { return m_adc; } + void setAdc(unsigned int adc) override { m_adc = adc; } + + unsigned int getMaxAdc() const override { return m_maxadc; } + void setMaxAdc(uint16_t maxadc) override { m_maxadc = maxadc; } + + unsigned int getCenAdc() const override { return m_cenadc; } + void setCenAdc(uint16_t cenadc) { m_cenadc = cenadc; } + + float getPadCen() const override { return m_padcen; } + void setPadCen(float padcen) { m_padcen = padcen; } + + float getTBinCen() const override { return m_tbincen; } + void setTBinCen(float tbincen) { m_tbincen = tbincen; } + + float getPadMax() const override { return m_padmax; } + void setPadMax(float padmax) { m_padmax = padmax; } + + float getTBinMax() const override { return m_tbinmax; } + void setTBinMax(float tbinmax) { m_tbinmax = tbinmax; } + + // + // convenience interface + // + float getRPhiError() const override { return m_phierr; } + float getZError() const override { return m_zerr; } + + void setPhiError(float phierror) { m_phierr = phierror; } + void setZError(float zerror) { m_zerr = zerror; } + + /// deprecated global funtions with a warning + float getX() const override + { + std::cout << "Deprecated getx trkrcluster function!" << std::endl; + return NAN; + } + float getY() const override + { + std::cout << "Deprecated gety trkrcluster function!" << std::endl; + return NAN; + } + float getZ() const override + { + std::cout << "Deprecated getz trkrcluster function!" << std::endl; + return NAN; + } + void setX(float) override + { + std::cout << "Deprecated setx trkrcluster function!" << std::endl; + } + void setY(float) override + { + std::cout << "Deprecated sety trkrcluster function!" << std::endl; + } + void setZ(float) override + { + std::cout << "Deprecated setz trkrcluster function!" << std::endl; + } + float getSize(unsigned int, unsigned int) const override + { + std::cout << "Deprecated getsize trkrcluster function!" << std::endl; + return NAN; + } + void setSize(unsigned int, unsigned int, float) override + { + std::cout << "Deprecated setsize trkrcluster function!" << std::endl; + } + float getError(unsigned int, unsigned int) const override + { + std::cout << "Deprecated geterr trkrcluster function!" << std::endl; + return NAN; + } + void setError(unsigned int, unsigned int, float) override + { + std::cout << "Deprecated seterr trkrcluster function!" << std::endl; + } + + char getSize() const override { return m_phisize * m_zsize; } + // void setSize(char size) { m_size = size; } + + float getRSize() const override { return (float) m_rsize; } + void setRSize(unsigned char rsize) { m_rsize = rsize; } + + float getPhiSize() const override { return (float) m_phisize; } + void setPhiSize(char phisize) { m_phisize = phisize; } + + float getZSize() const override { return (float) m_zsize; } + void setZSize(char zsize) { m_zsize = zsize; } + + char getOverlap() const override { return m_overlap; } + void setOverlap(char overlap) override { m_overlap = overlap; } + + char getEdge() const override { return m_edge; } + void setEdge(char edge) override { m_edge = edge; } + + char getSLEdge() const override { return m_sledge; } + void setSLEdge(char sledge) { m_sledge = sledge; } + + char getSREdge() const override { return m_sredge; } + void setSREdge(char sredge) { m_sredge = sredge; } + + char getTLEdge() const override { return m_tledge; } + void setTLEdge(char tledge) { m_tledge = tledge; } + + char getTREdge() const override { return m_tredge; } + void setTREdge(char tredge) { m_tredge = tredge; } + + char getDLEdge() const override { return m_dledge; } + void setDLEdge(char dledge) { m_dledge = dledge; } + + char getDREdge() const override { return m_dredge; } + void setDREdge(char dredge) { m_dredge = dredge; } + + char getHLEdge() const override { return m_hledge; } + void setHLEdge(char hledge) { m_hledge = hledge; } + + char getHREdge() const override { return m_hredge; } + void setHREdge(char hredge) { m_hredge = hredge; } + + int getSLMix() const override { return m_slmix; } + void setSLMix(char slmix) { m_slmix = slmix; } + + int getSRMix() const override { return m_srmix; } + void setSRMix(char srmix) { m_srmix = srmix; } + + int getTLMix() const override { return m_tlmix; } + void setTLMix(char tlmix) { m_tlmix = tlmix; } + + int getTRMix() const override { return m_trmix; } + void setTRMix(char trmix) { m_trmix = trmix; } + + float getPhiBinLo() const override { return m_phibinlo; } + void setPhiBinLo(float phibinlo) { m_phibinlo = phibinlo; } + + float getPhiBinHi() const override { return m_phibinhi; } + void setPhiBinHi(float phibinhi) { m_phibinhi = phibinhi; } + + float getTBinLo() const override { return m_tbinlo; } + void setTBinLo(float tbinlo) { m_tbinlo = tbinlo; } + + float getTBinHi() const override { return m_tbinhi; } + void setTBinHi(float tbinhi) { m_tbinhi = tbinhi; } + + float getPadPhase() const override { return m_padphase; } + void setPadPhase(float padphase) { m_padphase = padphase; } + + float getTBinPhase() const override { return m_tbinphase; } + void setTBinPhase(float tbinphase){ m_tbinphase = tbinphase; } + + // float getPhiSize() const override + //{ std::cout << "Deprecated size function"<< std::endl; return NAN;} + // float getZSize() const override + //{std::cout << "Deprecated size function" << std::endl; return NAN;} + // float getPhiError() const override + //{ std::cout << "Deprecated getPhiError function"<< std::endl; return NAN;} + + private: + float m_local[2]{std::numeric_limits::quiet_NaN(), std::numeric_limits::quiet_NaN()}; + //< 2D local position [cm] 2 * 32 64bit - cumul 1*64 + TrkrDefs::subsurfkey m_subsurfkey; //< unique identifier for hitsetkey-surface maps 16 bit + float m_phierr; + float m_zerr; + unsigned short int m_adc; //< cluster sum adc 16 + unsigned short int m_maxadc; //< cluster max adc 16 + unsigned short int m_cenadc; //< cluster centroid adc 16 + float m_padcen; + float m_tbincen; + float m_padmax; + float m_tbinmax; + unsigned char m_rsize; // 8bit + char m_phisize; // 8bit + char m_zsize; // 8bit + char m_overlap; // 8bit + char m_edge; // 8bit - cumul 2*64 + char m_sledge; // 8bit + char m_sredge; // 8bit + char m_tledge; // 8bit + char m_tredge; // 8bit + char m_dledge; // 8bit + char m_dredge; // 8bit + char m_hledge; // 8bit + char m_hredge; // 8bit + char m_slmix; // 8bit + char m_srmix; // 8bit + char m_tlmix; // 8bit + char m_trmix; // 8bit + float m_phibinlo; + float m_phibinhi; + float m_tbinlo; + float m_tbinhi; + float m_padphase; + float m_tbinphase; + + ClassDefOverride(TrkrClusterv6, 1) +}; + +#endif // TRACKBASE_TRKRCLUSTERV6_H diff --git a/offline/packages/trackbase/TrkrClusterv6LinkDef.h b/offline/packages/trackbase/TrkrClusterv6LinkDef.h new file mode 100644 index 0000000000..936ec262cc --- /dev/null +++ b/offline/packages/trackbase/TrkrClusterv6LinkDef.h @@ -0,0 +1,5 @@ +#ifdef __CINT__ + +#pragma link C++ class TrkrClusterv6 + ; + +#endif From d3cc64e4a62a22c75030327679d55c6237c7cefb Mon Sep 17 00:00:00 2001 From: Ishan Goel Date: Fri, 5 Jun 2026 13:40:48 -0400 Subject: [PATCH 02/11] Something --- offline/packages/trackbase/TrkrClusterv6.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/offline/packages/trackbase/TrkrClusterv6.cc b/offline/packages/trackbase/TrkrClusterv6.cc index bb2c1716d7..4481a9828a 100644 --- a/offline/packages/trackbase/TrkrClusterv6.cc +++ b/offline/packages/trackbase/TrkrClusterv6.cc @@ -13,7 +13,7 @@ namespace { // square convenience function template - inline constexpr T square(const T& x) + constexpr T square(const T& x) { return x * x; } From 50caed7b44fe0936ab8c7fa38a10107e542c5d27 Mon Sep 17 00:00:00 2001 From: Ishan Goel Date: Fri, 5 Jun 2026 14:18:34 -0400 Subject: [PATCH 03/11] Bug --- offline/packages/trackbase/TrkrClusterv6.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/offline/packages/trackbase/TrkrClusterv6.h b/offline/packages/trackbase/TrkrClusterv6.h index c36d1d84ee..a021cadd91 100644 --- a/offline/packages/trackbase/TrkrClusterv6.h +++ b/offline/packages/trackbase/TrkrClusterv6.h @@ -32,7 +32,7 @@ class TrkrClusterv6 : public TrkrCluster // PHObject virtual overloads void identify(std::ostream& os = std::cout) const override; - void Reset() override {} + void Reset() override { *this = TrkrClusterv6();} int isValid() const override; PHObject* CloneMe() const override { return new TrkrClusterv6(*this); } @@ -57,7 +57,7 @@ class TrkrClusterv6 : public TrkrCluster // float getPosition(int coor) const override { - return (coor >= 0 && coor < 2) m_local[coor] : NAN; + return (coor >= 0 && coor < 2) ? m_local[coor] : NAN; } void setPosition(int coor, float xi) override { From 771f1964b313956f323e3de2671edaf8a94569f6 Mon Sep 17 00:00:00 2001 From: Ishan Goel Date: Fri, 5 Jun 2026 14:21:05 -0400 Subject: [PATCH 04/11] Bug2 --- offline/packages/trackbase/.TrkrClusterv6.h.swo | Bin 0 -> 16384 bytes offline/packages/trackbase/TrkrClusterv6.h | 2 +- 2 files changed, 1 insertion(+), 1 deletion(-) create mode 100644 offline/packages/trackbase/.TrkrClusterv6.h.swo diff --git a/offline/packages/trackbase/.TrkrClusterv6.h.swo b/offline/packages/trackbase/.TrkrClusterv6.h.swo new file mode 100644 index 0000000000000000000000000000000000000000..a59af2385190e0e2639f0aecb637538d2133fdf2 GIT binary patch literal 16384 zcmeI3U2Ggz6~`xp0D-ze^CpI!`V|&-zu&vfkTE|J+G>v09ZqznJ%k0cu?@eZB zw)5fmLv0?gpcE;Thf*X!NC;3>Di9!{@>HZsyj5yM5enh+fsZFDfe;i0%KyxrnVp^8 zY&L*|RLx4ic=q0VKJK}9@7!}|QZJo3evMLQvRpqsX$w&|1-OT;Vwl z|Dx`SqSI(t(iX+GZd}mUgje)kT-9|?6j$8~?xGcVzHrwoGtI22{CggOJOVut7}4%5 z&z87&Y;-@p?~aFhTI2Z7mupF9G21o8;v5y&HuM<9tE26c88zw}D;Y=Od5*rd5!?gzfL-9qyEW|<@NMuMxD1{IJKzB@ z0)Dbr)4l+n0ms1K-=%4P1Ahj;0oTCSKohKi0{HzqHSKrco1g_OZ~*-49h&w}@G|%e zcoHmw4}uSXU+>YhZ-B3ZuYw(L2^;~pgAs7$?V9!#@MU0uCGY^)4gP{dnb*M;@Cx`8 zSO+dx1y9+Z6aFKGhUMt~1Uc)%b)_j# z_c$Q(e6w0LoWQ5~c^W+;+O9BkUxZQ{Dc>6xoIdTY}1;9nzX5h zZ)nODe&E`)w6Mf715B?8f9qCEhkYYRJzAI`!?8WTx1YCSeDgmt{>cBv_$>uJ>G{L` zj2DYVGCL!>W;u1;;&J3*^ys4Wo1_!o{jsIJh6N&-E{`5{UB^`eNn4mPjyply)T;3{ z9gK?R!YLF_vE`;rOSPLaC8xeYGA?FW7)<<+EM|ufMx%jKww1|5Y9%o`NKn~SqQxSt zA}p9C>v$PT*oGi!tR4Y>>T?sB8Xv!RHEtp0jz(~(lYCb_TY$}WD8Wz=s>SADf za?Qpn2nk+TA_apCcf?bMF_2w`F_xj>co`0VRH_gjsEhs{M4AS9&=F605SmZ-rq@17 zU>yJUx6B#_nN0+f-&SutvctkY3YSjzs9ttmrO_FBk zCKW~}Rd*1z%E!K<7^jr>K`wW6vbt2X9&`-dif)!=Tk2=F_Xdz&JC)heIVGv?{OVuAs;+7c$8p)hhE%s_ zzNr(*1{Ju54jrTtjgMpH#Fu$0PoO$|-(Pk-$@i54|75t)RJ6Kp$WCt{qs&ID`VCam zJsGd6@vea_Ch_hunTdJbhFzGj?H=$-I&mrlZ(Jg8A=wMev`zr!FTU4hO(@+QIaJS}( zIUdJQ23ue3ej1yFaR2IfzAN~AJ%6_F(P z=Hd59P9xn0VWqm|T(l`@^HB2a(=oO>-+g2&XmNX9x!sn|KWC_8jrZ1FDH?Pp(pkx9 z)rymoTI6ROB}8ou_kJrd1&wk~d99ymj%G@u*UGyp<_$}>r0*T-w4ImHU>$;5gcC2S z)9T8?;)%lxr;pZFS5B-fKKRh-)uStCDz*C|*09lNK#M3+H|rO7-9$b_C-qG#m&%ne z7<%A0u?imdnz~K*@oW3st|2Xf%;84w%yWo1|L2_bTgYWO|DTQ$y%&+wKMfYZy`TbK zMUMVOPz43>e(+o5=FbBgd>kAHcYzOs>&VGp122Fba0+|`yop?!^Yrh4PlFn`3+w}b zK#u(qcosO|EVvJR42*$&;2-ey4e%Pc0$v5||MMXK<4|jyDokB5x293Yv&EA&l^%- z(-r2L=y9;ezos=@J99{V=8*c3CJyDFKcqfyNPXUr`ucho&Rrf~nkFM?1s0VjD+fA* z9cHh3I~(<$pl^9{t9NYphtWNGFz@=c?6gZxRioL4{4}Mw(=I*Tk(GAMcXjlQPNW;* z>^0LUDoHGQ$k%YBfMbPLEk3D559V>!68^7dKK=Dwep<$-p|eQysIP2%#@Z!|!kdVN zXQYHr+N6hMJFymbho7)?^(B0c!XB%`xN>l~Gl+}>HH$^o8A$y}OMb1C*) zogtRbZHK2QcF+>8G-@i1pAQ=ys#YHhr0{D?`ch$HN*%Y{ydkf!ZC9=%39qVinC;F< zP4=NBj)3DwLdo;W(XOYJ@$)2p3dyHJn02ZPDbb!Ir?8#sS>H#cn8qD*-A_lm?fn}D C68PKz literal 0 HcmV?d00001 diff --git a/offline/packages/trackbase/TrkrClusterv6.h b/offline/packages/trackbase/TrkrClusterv6.h index a021cadd91..e1b61a9820 100644 --- a/offline/packages/trackbase/TrkrClusterv6.h +++ b/offline/packages/trackbase/TrkrClusterv6.h @@ -32,7 +32,7 @@ class TrkrClusterv6 : public TrkrCluster // PHObject virtual overloads void identify(std::ostream& os = std::cout) const override; - void Reset() override { *this = TrkrClusterv6();} + void Reset() override { *this = TrkrClusterv6(); } int isValid() const override; PHObject* CloneMe() const override { return new TrkrClusterv6(*this); } From d46ad78f9da617e1ee67c9e70f964c8bbe2430e5 Mon Sep 17 00:00:00 2001 From: Ishan Goel Date: Sat, 6 Jun 2026 09:15:48 -0400 Subject: [PATCH 05/11] Filling new variables. --- offline/packages/tpc/TpcClusterizer.cc | 308 +++++++++++++++++++++---- 1 file changed, 261 insertions(+), 47 deletions(-) diff --git a/offline/packages/tpc/TpcClusterizer.cc b/offline/packages/tpc/TpcClusterizer.cc index 687d5b58f9..7ccd9ba40f 100644 --- a/offline/packages/tpc/TpcClusterizer.cc +++ b/offline/packages/tpc/TpcClusterizer.cc @@ -16,6 +16,7 @@ #include #include #include +#include #include // for hitkey, getLayer #include #include @@ -84,6 +85,36 @@ namespace unsigned short edge = 0; }; + struct ClusterCounters + { + int overlap = 0; + + int nedge = 0; // Total No. of Edges + + int sledge = 0; // Touching Left Sector Edge + int sredge = 0; // Touching Right Sector Edge + + int tledge = 0; // Touching Left Time Edge + int tredge = 0; // Touching Right Time Edge + + int dledge = 0; // Touching Left Dead Edge + int dredge = 0; // Touching Right Dead Edge + + int hledge = 0; // Touching Left Hot Edge + int hredge = 0; // Touching Right Hot Edge + + int slmix = 0; // Touching Cluster at Left in Phibin + int srmix = 0; // Touching Cluster at Right in Phibin + + int tlmix = 0; // Touching Cluster at Left in Timebin + int trmix = 0; // Touching Cluster at Right in Timebin + + void clear() + { + *this = ClusterCounters{}; + } + }; + using vec_dVerbose = std::vector>>; // Neural network parameters and modules @@ -176,13 +207,14 @@ namespace } } - void find_t_range(int phibin, int tbin, const thread_data &my_data, const std::vector> &adcval, int &tdown, int &tup, int &touch, int &edge) + void find_t_range(int phibin, int tbin, const thread_data &my_data, const std::vector> &adcval, int &tdown, int &tup, ClusterCounters &counts, bool &ttop_edge, bool &tbottom_edge) { const int FitRangeT = (int) my_data.maxHalfSizeT; const int NTBinsMax = (int) my_data.tbins; - const int FixedWindow = (int) my_data.FixedWindow; + // const int FixedWindow = (int) my_data.FixedWindow; tup = 0; tdown = 0; + /* if (FixedWindow != 0) { tup = FixedWindow; @@ -190,15 +222,16 @@ namespace if (tbin + tup >= NTBinsMax) { tup = NTBinsMax - tbin - 1; - edge++; + counts.nedge++; } if ((tbin - tdown) <= 0) { tdown = tbin; - edge++; + counts.edge++; } return; } + */ for (int it = 0; it < FitRangeT; it++) { int ct = tbin + it; @@ -206,7 +239,12 @@ namespace if (ct <= 0 || ct >= NTBinsMax) { // tup = it; - edge++; + if (!ttop_edge) + { + counts.nedge++; + counts.tredge = 1; + ttop_edge = true; + } break; // truncate edge } @@ -216,7 +254,7 @@ namespace } if (adcval[phibin][ct] == USHRT_MAX) { - touch++; + counts.overlap++; break; } if (my_data.do_split) @@ -228,7 +266,7 @@ namespace adcval[phibin][ct + 2] + adcval[phibin][ct + 3]) { // rising again tup = it + 1; - touch++; + counts.overlap++; break; } } @@ -241,7 +279,12 @@ namespace if (ct <= 0 || ct >= NTBinsMax) { // tdown = it; - edge++; + if (!tbottom_edge) + { + counts.nedge++; + counts.tledge = 1; + tbottom_edge = true; + } break; // truncate edge } if (adcval[phibin][ct] <= 0) @@ -250,7 +293,7 @@ namespace } if (adcval[phibin][ct] == USHRT_MAX) { - touch++; + counts.overlap++; break; } if (my_data.do_split) @@ -261,7 +304,7 @@ namespace adcval[phibin][ct - 2] + adcval[phibin][ct - 3]) { // rising again tdown = it + 1; - touch++; + counts.overlap++; break; } } @@ -271,13 +314,14 @@ namespace return; } - void find_phi_range(int phibin, int tbin, const thread_data &my_data, const std::vector> &adcval, int &phidown, int &phiup, int &touch, int &edge) + void find_phi_range(int phibin, int tbin, const thread_data &my_data, const std::vector> &adcval, int &phidown, int &phiup, ClusterCounters &counts, bool &phitop_edge, bool &phibottom_edge) { int FitRangePHI = (int) my_data.maxHalfSizePhi; int NPhiBinsMax = (int) my_data.phibins; - const int FixedWindow = (int) my_data.FixedWindow; + // const int FixedWindow = (int) my_data.FixedWindow; phidown = 0; phiup = 0; + /* if (FixedWindow != 0) { phiup = FixedWindow; @@ -294,13 +338,19 @@ namespace } return; } + */ for (int iphi = 0; iphi < FitRangePHI; iphi++) { int cphi = phibin + iphi; if (cphi < 0 || cphi >= NPhiBinsMax) { // phiup = iphi; - edge++; + if (!phitop_edge) + { + counts.nedge++; + counts.sredge = 1; + phitop_edge = true; + } break; // truncate edge } @@ -312,7 +362,7 @@ namespace } if (adcval[cphi][tbin] == USHRT_MAX) { - touch++; + counts.overlap++; break; } if (my_data.do_split) @@ -323,7 +373,7 @@ namespace adcval[cphi + 2][tbin] + adcval[cphi + 3][tbin]) { // rising again phiup = iphi + 1; - touch++; + counts.overlap++; break; } } @@ -337,7 +387,12 @@ namespace if (cphi < 0 || cphi >= NPhiBinsMax) { // phidown = iphi; - edge++; + if (!phibottom_edge) + { + counts.nedge++; + counts.sledge = 1; + phibottom_edge = true; + } break; // truncate edge } @@ -348,7 +403,7 @@ namespace } if (adcval[cphi][tbin] == USHRT_MAX) { - touch++; + counts.overlap++; break; } if (my_data.do_split) @@ -359,7 +414,7 @@ namespace adcval[cphi - 2][tbin] + adcval[cphi - 3][tbin]) { // rising again phidown = iphi + 1; - touch++; + counts.overlap++; break; } } @@ -369,6 +424,60 @@ namespace return; } + void check_cluster_touching(const std::vector& ihit_list, const std::vector>& adcval, int phibins, int tbins, ClusterCounters &counts) + { + // Encode (iphi, it) into single integer for fast lookup + std::unordered_set cluster_hits; + cluster_hits.reserve(ihit_list.size()); + + auto encode = [tbins](int phi, int t) + { + return phi * tbins + t; + }; + + for (const auto &hit : ihit_list) + { + cluster_hits.insert(encode(hit.iphi, hit.it)); + } + + for (auto &hit : ihit_list) + { + int iphi = hit.iphi; + int it = hit.it; + + for (int dphi = -1; dphi <= 1; ++dphi) + { + for (int dt = -1; dt <= 1; ++dt) + { + if (dphi == 0 && dt == 0) continue; + + int nphi = iphi + dphi; + int nt = it + dt; + + if (nphi < 0 || nphi >= phibins || + nt < 0 || nt >= tbins) + continue; + + // skip same cluster + if (cluster_hits.count(encode(nphi, nt))) continue; + + // neighbor has signal → touching + if (adcval[nphi][nt] > 0 && + adcval[nphi][nt] != USHRT_MAX) + { + // Check Phi + if (dphi == -1) counts.slmix = 1; + if (dphi == 1) counts.srmix = 1; + + // Check Time + if (dt == -1) counts.tlmix = 1; + if (dt == 1) counts.trmix = 1; + } + } + } + } + } + int is_hit_isolated(int iphi, int it, int NPhiBinsMax, int NTBinsMax, const std::vector> &adcval) { // check isolated hits @@ -426,20 +535,25 @@ namespace return isiso; } - void get_cluster(int phibin, int tbin, const thread_data &my_data, const std::vector> &adcval, std::vector &ihit_list, int &touch, int &edge) + void get_cluster(int phibin, int tbin, const thread_data &my_data, const std::vector> &adcval, std::vector &ihit_list, ClusterCounters &counts) { + bool ttop_edge = false; + bool tbottom_edge = false; + bool phitop_edge = false; + bool phibottom_edge = false; + // search along phi at the peak in t // const int NPhiBinsMax = (int) my_data.phibins; // const int NTBinsMax = (int) my_data.tbins; int tup = 0; int tdown = 0; - find_t_range(phibin, tbin, my_data, adcval, tdown, tup, touch, edge); + find_t_range(phibin, tbin, my_data, adcval, tdown, tup, counts, ttop_edge, tbottom_edge); // now we have the t extent of the cluster, go find the phi edges for (int it = tbin - tdown; it <= (tbin + tup); it++) { int phiup = 0; int phidown = 0; - find_phi_range(phibin, it, my_data, adcval, phidown, phiup, touch, edge); + find_phi_range(phibin, it, my_data, adcval, phidown, phiup, counts, phitop_edge, phibottom_edge); for (int iphi = (phibin - phidown); iphi <= (phibin + phiup); iphi++) { if (adcval[iphi][it] > 0 && adcval[iphi][it] != USHRT_MAX) @@ -456,7 +570,7 @@ namespace hit.it = it; hit.adc = adcval[iphi][it]; - if (touch > 0) + if (counts.overlap > 0) { if ((iphi == (phibin - phidown)) || (iphi == (phibin + phiup))) @@ -472,7 +586,7 @@ namespace } void calc_cluster_parameter(const int iphi_center, const int it_center, - const std::vector &ihit_list, thread_data &my_data, int ntouch, int nedge) + const std::vector &ihit_list, thread_data &my_data, ClusterCounters counts) { // // get z range from layer geometry @@ -488,6 +602,8 @@ namespace double iphi_sum = 0.0; double iphi2_sum = 0.0; + double it_sum = 0.0; + double radius = my_data.layergeom->get_radius(); // returns center of layer int phibinhi = -1; @@ -497,6 +613,12 @@ namespace int clus_size = ihit_list.size(); int max_adc = 0; + int phibinmax = -1; + int tbinmax = -1; + double cen_adc = 0; + + int size = 0; + if (clus_size <= my_data.min_clus_size) { return; @@ -521,14 +643,16 @@ namespace training_hits->phistep = my_data.layergeom->get_phistep(); training_hits->zstep = my_data.layergeom->get_zstep() * my_data.tGeometry->get_drift_velocity(); training_hits->layer = my_data.layer; - training_hits->ntouch = ntouch; - training_hits->nedge = nedge; + training_hits->ntouch = counts.overlap; + training_hits->nedge = counts.nedge; training_hits->v_adc.fill(0); } // std::cout << "process list" << std::endl; std::vector hitkeyvec; + std::map, double> adc_map; + // keep track of the hit locations in a given cluster std::map m_phi{}; std::map m_z{}; @@ -544,7 +668,18 @@ namespace continue; } - max_adc = std::max(max_adc, static_cast(std::round(adc))); // preserves rounding (0.5 -> 1) + size++; + + int adc_int = static_cast(std::round(adc)); + + if (adc_int > max_adc) + { + max_adc = adc_int; + phibinmax = iphi; + tbinmax = it; + } + + // max_adc = std::max(max_adc, static_cast(std::round(adc))); // preserves rounding (0.5 -> 1) phibinhi = std::max(iphi, phibinhi); phibinlo = std::min(iphi, phibinlo); tbinhi = std::max(it, tbinhi); @@ -565,8 +700,12 @@ namespace t_sum += t * adc; t2_sum += square(t) * adc; + it_sum += it * adc; + adc_sum += adc; + adc_map[{iphi, it}] += adc; + if (my_data.fillClusHitsVerbose) { auto pnew = m_phi.try_emplace(iphi, adc); @@ -623,13 +762,15 @@ namespace left_pad >= my_data.phioffset && deadset.contains(TpcDefs::genHitKey(left_pad, 0))) { - nedge++; + counts.nedge++; + counts.dledge = 1; } if (right_pad < (my_data.phibins + my_data.phioffset) && deadset.contains(TpcDefs::genHitKey(right_pad, 0))) { - nedge++; + counts.nedge++; + counts.dredge = 1; } } } @@ -646,24 +787,62 @@ namespace left_pad >= my_data.phioffset && hotset.contains(TpcDefs::genHitKey(left_pad, 0))) { - nedge++; + counts.nedge++; + counts.hledge = 1; } if (right_pad < (my_data.phibins + my_data.phioffset) && hotset.contains(TpcDefs::genHitKey(right_pad, 0))) { - nedge++; + counts.nedge++; + counts.hredge = 1; } } } - // This is the global position + // This is local position double clusiphi = iphi_sum / adc_sum; + double clusit = it_sum / adc_sum; + + // This is the global position double clusphi = my_data.layergeom->get_phi(clusiphi, my_data.side); + double clust = t_sum / adc_sum; + + // ADC of centroid bin + int iphi_centroid = static_cast(std::floor(clusiphi)); + int it_centroid = static_cast(std::floor(clusit)); + + auto it_cent = adc_map.find({iphi_centroid, it_centroid}); + if (it_cent != adc_map.end()) + { + cen_adc = it_cent->second; + } + else + { + cen_adc = 0.0; // centroid may not land on a real hit + } + + // Max ADC position in global coordinates + double maxphi = my_data.layergeom->get_phi(phibinmax, my_data.side); + double maxt = my_data.layergeom->get_zcenter(tbinmax); + + // Phase relative to max ADC position + double padphase = 0.0; + double tbinphase = 0.0; + + if (my_data.layergeom->get_phistep() > 0) + { + padphase = (clusphi - maxphi) / my_data.layergeom->get_phistep(); + } + + if (my_data.layergeom->get_zstep() > 0) + { + tbinphase = (clust - maxt) / my_data.layergeom->get_zstep(); + } double clusx = radius * cos(clusphi); double clusy = radius * sin(clusphi); - double clust = t_sum / adc_sum; + // needed for surface identification double zdriftlength = clust * my_data.tGeometry->get_drift_velocity(); // convert z drift length to z position in the TPC @@ -702,6 +881,7 @@ namespace char tsize = tbinhi - tbinlo + 1; char phisize = phibinhi - phibinlo + 1; + char rsize = size; // std::cout << "phisize: " << (int) phisize << " phibinhi " << phibinhi << " phibinlo " << phibinlo << std::endl; // phi_cov = (weighted mean of dphi^2) - (weighted mean of dphi)^2, which is essentially the weighted mean of dphi^2. The error is then: // e_phi = sigma_dphi/sqrt(N) = sqrt( sigma_dphi^2 / N ) -- where N is the number of samples of the distribution with standard deviation sigma_dphi @@ -714,7 +894,7 @@ namespace /// convert to Acts units global *= Acts::UnitConstants::cm; // std::cout << "transform" << std::endl; - Acts::Vector3 local = surface->localToGlobalTransform(my_data.tGeometry->geometry().getGeoContext()).inverse() * global; + Acts::Vector3 local = surface->localtoGlobalTransform(my_data.tGeometry->geometry().getGeoContext()).inverse() * global; local /= Acts::UnitConstants::cm; // std::cout << "done transform" << std::endl; // we need the cluster key and all associated hit keys (note: the cluster key includes the hitset key) @@ -726,20 +906,45 @@ namespace // std::cout << "clus num" << my_data.cluster_vector.size() << " X " << local(0) << " Y " << clust << std::endl; if (sqrt(phi_err_square) > my_data.min_err_squared) { - auto *clus = new TrkrClusterv5; + auto *clus = new TrkrClusterv6; + // auto *clus = new TrkrClusterv5; // auto clus = std::make_unique(); clus_base = clus; - clus->setAdc(adc_sum); - clus->setMaxAdc(max_adc); - clus->setEdge(nedge); - clus->setPhiSize(phisize); - clus->setZSize(tsize); - clus->setSubSurfKey(subsurfkey); - clus->setOverlap(ntouch); clus->setLocalX(local(0)); clus->setLocalY(clust); + clus->setSubSurfKey(subsurfkey); + clus->setAdc(adc_sum); + clus->setMaxAdc(max_adc); + clus->setCenAdc(cen_adc); + clus->setPadCen(clusiphi); + clus->setTBinCen(clusit); + clus->setPadMax(phibinmax); + clus->setTBinMax(tbinmax); clus->setPhiError(sqrt(phi_err_square)); clus->setZError(sqrt(t_err_square * pow(my_data.tGeometry->get_drift_velocity(), 2))); + clus->setRSize(rsize); + clus->setPhiSize(phisize); + clus->setZSize(tsize); + clus->setOverlap(counts.overlap); + clus->setEdge(counts.nedge); + clus->setSLEdge(counts.sledge); + clus->setSREdge(counts.sredge); + clus->setTLEdge(counts.tledge); + clus->setTREdge(counts.tredge); + clus->setDLEdge(counts.dledge); + clus->setDREdge(counts.dredge); + clus->setHLEdge(counts.hledge); + clus->setHREdge(counts.hredge); + clus->setSLMix(counts.slmix); + clus->setSRMix(counts.srmix); + clus->setTLMix(counts.tlmix); + clus->setTRMix(counts.trmix); + clus->setPhiBinLo(phibinlo); + clus->setPhiBinHi(phibinhi); + clus->setTBinLo(tbinlo); + clus->setTBinHi(tbinhi); + clus->setPadPhase(padphase); + clus->setTBinPhase(tbinphase); my_data.cluster_vector.push_back(clus); b_made_cluster = true; } @@ -763,7 +968,7 @@ namespace double nn_y = radius * std::sin(nn_phi); Acts::Vector3 nn_global(nn_x, nn_y, nn_z); nn_global *= Acts::UnitConstants::cm; - Acts::Vector3 nn_local = surface->localToGlobalTransform(my_data.tGeometry->geometry().geoContext).inverse() * nn_global; + Acts::Vector3 nn_local = surface->localtoGlobalTransform(my_data.tGeometry->geometry().geoContext).inverse() * nn_global; nn_local /= Acts::UnitConstants::cm; double nn_t = my_data.m_tdriftmax - std::fabs(nn_z) / my_data.tGeometry->get_drift_velocity(); clus_base->setLocalX(nn_local(0)); @@ -1037,6 +1242,9 @@ namespace } } */ + + std::vector> adcval_orig = adcval; + // std::cout << "done filling " << std::endl; while (!all_hit_map.empty()) { @@ -1064,9 +1272,10 @@ namespace // start with highest adc hit // -> cluster around it and get vector of hits std::vector ihit_list; - int ntouch = 0; - int nedge = 0; - get_cluster(iphi, it, *my_data, adcval, ihit_list, ntouch, nedge); + // Setting all the counters + ClusterCounters counts; + + get_cluster(iphi, it, *my_data, adcval, ihit_list, counts); if (my_data->FixedWindow > 0) { @@ -1102,11 +1311,16 @@ namespace my_data->FixedWindow = 0; // reset hit list and try again without fixed window ihit_list.clear(); - get_cluster(iphi, it, *my_data, adcval, ihit_list, ntouch, nedge); + // resetting all the counters + counts.clear(); + get_cluster(iphi, it, *my_data, adcval, ihit_list, counts); // std::cout << " stepdown size after " << ihit_list.size() << std::endl; my_data->FixedWindow = window_cache; } } + + check_cluster_touching(ihit_list, adcval_orig, my_data->phibins, my_data->tbins, counts); + if (ihit_list.size() <= 1) { remove_hits(ihit_list, all_hit_map, adcval); @@ -1117,7 +1331,7 @@ namespace // -> add hits to truth association // remove hits from all_hit_map // repeat untill all_hit_map empty - calc_cluster_parameter(iphi, it, ihit_list, *my_data, ntouch, nedge); + calc_cluster_parameter(iphi, it, ihit_list, *my_data, counts); remove_hits(ihit_list, all_hit_map, adcval); ihit_list.clear(); } From 48077c82b74b69cb4dc32d46291f1d4e1df012f1 Mon Sep 17 00:00:00 2001 From: Ishan Goel Date: Sat, 6 Jun 2026 09:44:53 -0400 Subject: [PATCH 06/11] Adding new information. --- .../.TrackResiduals.cc.swo | Bin 0 -> 16384 bytes .../TrackingDiagnostics/.TrackResiduals.h.swo | Bin 0 -> 4096 bytes .../TrackingDiagnostics/.TrkrNtuplizer.h.swo | Bin 0 -> 4096 bytes .../TrackingDiagnostics/TrackResiduals.cc | 195 +++++++++++++++++- .../TrackingDiagnostics/TrackResiduals.h | 53 ++++- .../TrackingDiagnostics/TrkrNtuplizer.cc | 60 +++++- 6 files changed, 287 insertions(+), 21 deletions(-) create mode 100644 offline/packages/TrackingDiagnostics/.TrackResiduals.cc.swo create mode 100644 offline/packages/TrackingDiagnostics/.TrackResiduals.h.swo create mode 100644 offline/packages/TrackingDiagnostics/.TrkrNtuplizer.h.swo diff --git a/offline/packages/TrackingDiagnostics/.TrackResiduals.cc.swo b/offline/packages/TrackingDiagnostics/.TrackResiduals.cc.swo new file mode 100644 index 0000000000000000000000000000000000000000..17a9840a5d3f88eff089ea62bbc3c54fe421f537 GIT binary patch literal 16384 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 literal 0 HcmV?d00001 diff --git a/offline/packages/TrackingDiagnostics/TrackResiduals.cc b/offline/packages/TrackingDiagnostics/TrackResiduals.cc index 1a5a69fae0..fe41ab9af1 100644 --- a/offline/packages/TrackingDiagnostics/TrackResiduals.cc +++ b/offline/packages/TrackingDiagnostics/TrackResiduals.cc @@ -46,6 +46,8 @@ #include #include +#include + #include #include #include @@ -57,6 +59,7 @@ #include #include #include +#include #include @@ -126,6 +129,7 @@ int TrackResiduals::InitRun(PHCompositeNode* topNode) void TrackResiduals::clearClusterStateVectors() { m_cluskeys.clear(); + m_clussize.clear(); m_clusphisize.clear(); m_cluszsize.clear(); m_idealsurfcenterx.clear(); @@ -183,7 +187,23 @@ void TrackResiduals::clearClusterStateVectors() m_statelzlocderivqop.clear(); m_clusedge.clear(); + m_clussledge.clear(); + m_clussredge.clear(); + m_clustledge.clear(); + m_clustredge.clear(); + m_clusdledge.clear(); + m_clusdredge.clear(); + m_clushledge.clear(); + m_clushredge.clear(); + m_clusslmix.clear(); + m_clussrmix.clear(); + m_clustlmix.clear(); + m_clustrmix.clear(); m_clusoverlap.clear(); + m_clusPadCen.clear(); + m_clusTBinCen.clear(); + m_clusPadMax.clear(); + m_clusTBinMax.clear(); m_cluslx.clear(); m_cluslz.clear(); m_cluselx.clear(); @@ -197,7 +217,14 @@ void TrackResiduals::clearClusterStateVectors() m_clusgzunmoved.clear(); m_clusAdc.clear(); m_clusMaxAdc.clear(); + m_clusCenAdc.clear(); m_cluslayer.clear(); + m_clusphibinlo.clear(); + m_clusphibinhi.clear(); + m_clustbinlo.clear(); + m_clustbinhi.clear(); + m_cluspadphase.clear(); + m_clustbinphase.clear(); m_statelx.clear(); m_statelz.clear(); @@ -301,6 +328,21 @@ int TrackResiduals::process_event(PHCompositeNode* topNode) } } + EventHeader* eventheader = findNode::getClass(topNode, "EventHeader"); + + if(eventheader) + { + m_evt_id = eventheader->get_EvtSequence(); + } + else + { + m_evt_id = -1; + } + + auto *rcs = recoConsts::instance(); + m_runnumber = rcs->get_IntFlag("RUNNUMBER"); + m_segment = rcs->get_IntFlag("RUNSEGMENT"); + m_ntpcclus = 0; if (Verbosity() > 1) { @@ -662,11 +704,37 @@ void TrackResiduals::fillClusterTree(TrkrClusterContainer* clusters, m_scluseta = acos(glob.z() / std::sqrt(square(glob.x()) + square(glob.y()) + square(glob.z()))); m_adc = cluster->getAdc(); m_clusmaxadc = cluster->getMaxAdc(); + m_cluscenadc = cluster->getCenAdc(); + m_padcen = cluster->getPadCen(); + m_tbincen = cluster->getTBinCen(); + m_padmax = cluster->getPadMax(); + m_tbinmax = cluster->getTBinMax(); m_scluslx = cluster->getLocalX(); m_scluslz = cluster->getLocalY(); + m_phibinlo = cluster->getPhiBinLo(); + m_phibinhi = cluster->getPhiBinHi(); + m_tbinlo = cluster->getTBinLo(); + m_tbinhi = cluster->getTBinHi(); + m_padphase = cluster->getPadPhase(); + m_tbinphase = cluster->getTBinPhase(); auto para_errors = ClusterErrorPara::get_clusterv5_modified_error(cluster, m_sclusgr, key); + m_size = cluster->getSize(); m_phisize = cluster->getPhiSize(); m_zsize = cluster->getZSize(); + m_overlap = cluster->getOverlap(); + m_nedge = cluster->getEdge(); + m_sledge = cluster->getSLEdge(); + m_sredge = cluster->getSREdge(); + m_tledge = cluster->getTLEdge(); + m_tredge = cluster->getTREdge(); + m_dledge = cluster->getDLEdge(); + m_dredge = cluster->getDREdge(); + m_hledge = cluster->getHLEdge(); + m_hredge = cluster->getHREdge(); + m_slmix = cluster->getSLMix(); + m_srmix = cluster->getSRMix(); + m_tlmix = cluster->getTLMix(); + m_trmix = cluster->getTRMix(); m_scluselx = std::sqrt(para_errors.first); m_scluselz = std::sqrt(para_errors.second); @@ -1087,7 +1155,19 @@ void TrackResiduals::fillClusterBranchesKF(TrkrDefs::cluskey ckey, SvtxTrack* tr //! have cluster and state, fill vectors m_clusedge.push_back(cluster->getEdge()); + m_clussledge.push_back(cluster->getSLEdge()); + m_clussredge.push_back(cluster->getSREdge()); + m_clustledge.push_back(cluster->getTLEdge()); + m_clustredge.push_back(cluster->getTREdge()); + m_clusdledge.push_back(cluster->getDLEdge()); + m_clusdredge.push_back(cluster->getDREdge()); + m_clushledge.push_back(cluster->getHLEdge()); + m_clushredge.push_back(cluster->getHREdge()); m_clusoverlap.push_back(cluster->getOverlap()); + m_clusslmix.push_back(cluster->getSLMix()); + m_clussrmix.push_back(cluster->getSRMix()); + m_clustlmix.push_back(cluster->getTLMix()); + m_clustrmix.push_back(cluster->getTRMix()); // get new local coords from moved cluster Surface surf = geometry->maps().getSurface(ckey, cluster); @@ -1128,7 +1208,7 @@ void TrackResiduals::fillClusterBranchesKF(TrkrDefs::cluskey ckey, SvtxTrack* tr { // otherwise take the manual calculation for the TPC // doing it this way just avoids the bounds check that occurs in the surface class method - Acts::Vector3 loct = surf->localToGlobalTransform(geometry->geometry().getGeoContext()).inverse() * clusglob_moved; // global is in mm + Acts::Vector3 loct = surf->localtoGlobalTransform(geometry->geometry().getGeoContext()).inverse() * clusglob_moved; // global is in mm loct /= Acts::UnitConstants::cm; loc(0) = loct(0); @@ -1160,13 +1240,25 @@ void TrackResiduals::fillClusterBranchesKF(TrkrDefs::cluskey ckey, SvtxTrack* tr m_clusgzunmoved.push_back(clusglob.z()); m_clusAdc.push_back(cluster->getAdc()); m_clusMaxAdc.push_back(cluster->getMaxAdc()); + m_clusCenAdc.push_back(cluster->getCenAdc()); + m_clusPadCen.push_back(cluster->getPadCen()); + m_clusTBinCen.push_back(cluster->getTBinCen()); + m_clusPadMax.push_back(cluster->getPadMax()); + m_clusTBinMax.push_back(cluster->getTBinMax()); m_cluslayer.push_back(TrkrDefs::getLayer(ckey)); + m_clussize.push_back(cluster->getSize()); m_clusphisize.push_back(cluster->getPhiSize()); m_cluszsize.push_back(cluster->getZSize()); + m_clusphibinlo.push_back(cluster->getPhiBinLo()); + m_clusphibinhi.push_back(cluster->getPhiBinHi()); + m_clustbinlo.push_back(cluster->getTBinLo()); + m_clustbinhi.push_back(cluster->getTBinHi()); + m_cluspadphase.push_back(cluster->getPadPhase()); + m_clustbinphase.push_back(cluster->getTBinPhase()); auto misaligncenter = surf->center(geometry->geometry().getGeoContext()); auto misalignnorm = -1 * surf->normal(geometry->geometry().getGeoContext(), Acts::Vector3(1, 1, 1), Acts::Vector3(1, 1, 1)); - auto misrot = surf->localToGlobalTransform(geometry->geometry().getGeoContext()).rotation(); + auto misrot = surf->localtoGlobalTransform(geometry->geometry().getGeoContext()).rotation(); float mgamma = atan2(-misrot(1, 0), misrot(0, 0)); float mbeta = -asin(misrot(0, 1)); @@ -1183,11 +1275,11 @@ void TrackResiduals::fillClusterBranchesKF(TrkrDefs::cluskey ckey, SvtxTrack* tr std::cout << "resids: layer " << layer << " ideal center z " << idealcenter.z() << " mm " << std::endl; std::cout << " surface bounds " << surfbounds[0] << " " << surfbounds[1] << " mm " << std::endl; alignmentTransformationContainer::use_alignment = false; - Acts::Transform3 transform = surf_ideal->localToGlobalTransform(geometry->geometry().getGeoContext()); + Acts::Transform3 transform = surf_ideal->localtoGlobalTransform(geometry->geometry().getGeoContext()); std::cout << "Ideal transform is:" << std::endl; std::cout << transform.matrix() << std::endl; alignmentTransformationContainer::use_alignment = true; - Acts::Transform3 transform1 = surf_ideal->localToGlobalTransform(geometry->geometry().getGeoContext()); + Acts::Transform3 transform1 = surf_ideal->localtoGlobalTransform(geometry->geometry().getGeoContext()); std::cout << "Alignment transform is:" << std::endl; std::cout << transform1.matrix() << std::endl; @@ -1199,8 +1291,8 @@ void TrackResiduals::fillClusterBranchesKF(TrkrDefs::cluskey ckey, SvtxTrack* tr // Acts::Vector3 ideal_local(loc.x(), loc.y(), 0.0); auto nominal_loc = geometry->getLocalCoords(ckey, cluster); Acts::Vector3 ideal_local(nominal_loc.x(), nominal_loc.y(), 0.0); - Acts::Vector3 ideal_glob = surf_ideal->localToGlobalTransform(geometry->geometry().getGeoContext()) * (ideal_local * Acts::UnitConstants::cm); - auto idealrot = surf_ideal->localToGlobalTransform(geometry->geometry().getGeoContext()).rotation(); + Acts::Vector3 ideal_glob = surf_ideal->localtoGlobalTransform(geometry->geometry().getGeoContext()) * (ideal_local * Acts::UnitConstants::cm); + auto idealrot = surf_ideal->localtoGlobalTransform(geometry->geometry().getGeoContext()).rotation(); //! These calculations are taken from the wikipedia page for Euler angles, //! under the Tait-Bryan angle explanation. Formulas for the angles @@ -1416,6 +1508,18 @@ void TrackResiduals::fillClusterBranchesSeeds(TrkrDefs::cluskey ckey, // SvtxTr //! have cluster and state, fill vectors m_clusedge.push_back(cluster->getEdge()); + m_clussledge.push_back(cluster->getSLEdge()); + m_clussredge.push_back(cluster->getSREdge()); + m_clustledge.push_back(cluster->getTLEdge()); + m_clustredge.push_back(cluster->getTREdge()); + m_clusdledge.push_back(cluster->getDLEdge()); + m_clusdredge.push_back(cluster->getDREdge()); + m_clushledge.push_back(cluster->getHLEdge()); + m_clushredge.push_back(cluster->getHREdge()); + m_clusslmix.push_back(cluster->getSLMix()); + m_clussrmix.push_back(cluster->getSRMix()); + m_clustlmix.push_back(cluster->getTLMix()); + m_clustrmix.push_back(cluster->getTRMix()); m_clusoverlap.push_back(cluster->getOverlap()); // This is the nominal position of the cluster in local coords, completely uncorrected - is that what we want? @@ -1438,9 +1542,21 @@ void TrackResiduals::fillClusterBranchesSeeds(TrkrDefs::cluskey ckey, // SvtxTr m_clusgzunmoved.push_back(clusglob.z()); m_clusAdc.push_back(cluster->getAdc()); m_clusMaxAdc.push_back(cluster->getMaxAdc()); + m_clusCenAdc.push_back(cluster->getCenAdc()); + m_clusPadCen.push_back(cluster->getPadCen()); + m_clusTBinCen.push_back(cluster->getTBinCen()); + m_clusPadMax.push_back(cluster->getPadMax()); + m_clusTBinMax.push_back(cluster->getTBinMax()); m_cluslayer.push_back(TrkrDefs::getLayer(ckey)); + m_clussize.push_back(cluster->getSize()); m_clusphisize.push_back(cluster->getPhiSize()); m_cluszsize.push_back(cluster->getZSize()); + m_clusphibinlo.push_back(cluster->getPhiBinLo()); + m_clusphibinhi.push_back(cluster->getPhiBinHi()); + m_clustbinlo.push_back(cluster->getTBinLo()); + m_clustbinhi.push_back(cluster->getTBinHi()); + m_cluspadphase.push_back(cluster->getPadPhase()); + m_clustbinphase.push_back(cluster->getTBinPhase()); if (Verbosity() > 1) { @@ -1453,7 +1569,7 @@ void TrackResiduals::fillClusterBranchesSeeds(TrkrDefs::cluskey ckey, // SvtxTr auto misaligncenter = surf->center(geometry->geometry().getGeoContext()); auto misalignnorm = -1 * surf->normal(geometry->geometry().getGeoContext(), Acts::Vector3(1, 1, 1), Acts::Vector3(1, 1, 1)); - auto misrot = surf->localToGlobalTransform(geometry->geometry().getGeoContext()).rotation(); + auto misrot = surf->localtoGlobalTransform(geometry->geometry().getGeoContext()).rotation(); float mgamma = atan2(-misrot(1, 0), misrot(0, 0)); float mbeta = -asin(misrot(0, 1)); @@ -1464,8 +1580,8 @@ void TrackResiduals::fillClusterBranchesSeeds(TrkrDefs::cluskey ckey, // SvtxTr auto idealcenter = surf->center(geometry->geometry().getGeoContext()); auto idealnorm = -1 * surf->normal(geometry->geometry().getGeoContext(), Acts::Vector3(1, 1, 1), Acts::Vector3(1, 1, 1)); Acts::Vector3 ideal_local(loc.x(), loc.y(), 0.0); - Acts::Vector3 ideal_glob = surf->localToGlobalTransform(geometry->geometry().getGeoContext()) * (ideal_local * Acts::UnitConstants::cm); - auto idealrot = surf->localToGlobalTransform(geometry->geometry().getGeoContext()).rotation(); + Acts::Vector3 ideal_glob = surf->localtoGlobalTransform(geometry->geometry().getGeoContext()) * (ideal_local * Acts::UnitConstants::cm); + auto idealrot = surf->localtoGlobalTransform(geometry->geometry().getGeoContext()).rotation(); //! These calculations are taken from the wikipedia page for Euler angles, //! under the Tait-Bryan angle explanation. Formulas for the angles @@ -1552,7 +1668,7 @@ void TrackResiduals::fillStatesWithCircleFit(const TrkrDefs::cluskey& key, } else { - auto local = (surf->localToGlobalTransform(geometry->geometry().getGeoContext())).inverse() * (intersection * Acts::UnitConstants::cm); + auto local = (surf->localtoGlobalTransform(geometry->geometry().getGeoContext())).inverse() * (intersection * Acts::UnitConstants::cm); local /= Acts::UnitConstants::cm; m_statelx.push_back(local.x()); m_statelz.push_back(local.y()); @@ -1579,7 +1695,7 @@ void TrackResiduals::fillStatesWithLineFit(const TrkrDefs::cluskey& key, } else { - Acts::Vector3 loct = surf->localToGlobalTransform(geometry->geometry().getGeoContext()).inverse() * (intersection * Acts::UnitConstants::cm); + Acts::Vector3 loct = surf->localtoGlobalTransform(geometry->geometry().getGeoContext()).inverse() * (intersection * Acts::UnitConstants::cm); loct /= Acts::UnitConstants::cm; m_statelx.push_back(loct(0)); m_statelz.push_back(loct(1)); @@ -1607,6 +1723,7 @@ void TrackResiduals::createBranches() m_eventtree->Branch("run", &m_runnumber, "m_runnumber/I"); m_eventtree->Branch("segment", &m_segment, "m_segment/I"); m_eventtree->Branch("event", &m_event, "m_event/I"); + m_eventtree->Branch("evt_id", &m_evt_id, "m_evt_id/I"); m_eventtree->Branch("gl1bco", &m_bco, "m_bco/I"); m_eventtree->Branch("nmvtx", &m_nmvtx_all, "m_nmvtx_all/I"); m_eventtree->Branch("nintt", &m_nintt_all, "m_nintt_all/I"); @@ -1627,6 +1744,7 @@ void TrackResiduals::createBranches() m_failedfits->Branch("segment", &m_segment, "m_segment/I"); m_failedfits->Branch("trackid", &m_trackid, "m_trackid/I"); m_failedfits->Branch("event", &m_event, "m_event/I"); + m_failedfits->Branch("evt_id", &m_evt_id, "m_evt_id/I"); m_failedfits->Branch("silseedx", &m_silseedx, "m_silseedx/F"); m_failedfits->Branch("silseedy", &m_silseedy, "m_silseedy/F"); m_failedfits->Branch("silseedz", &m_silseedz, "m_silseedz/F"); @@ -1653,6 +1771,7 @@ void TrackResiduals::createBranches() m_vertextree->Branch("run", &m_runnumber, "m_runnumber/I"); m_vertextree->Branch("segment", &m_segment, "m_segment/I"); m_vertextree->Branch("event", &m_event, "m_event/I"); + m_vertextree->Branch("evt_id", &m_evt_id, "m_evt_id/I"); m_vertextree->Branch("firedTriggers", &m_firedTriggers); m_vertextree->Branch("gl1BunchCrossing", &m_gl1BunchCrossing, "m_gl1BunchCrossing/l"); m_vertextree->Branch("gl1bco", &m_bco, "m_bco/l"); @@ -1675,6 +1794,7 @@ void TrackResiduals::createBranches() m_hittree->Branch("run", &m_runnumber, "m_runnumber/I"); m_hittree->Branch("segment", &m_segment, "m_segment/I"); m_hittree->Branch("event", &m_event, "m_event/I"); + m_hittree->Branch("evt_id", &m_evt_id, "m_evt_id/I"); m_hittree->Branch("gl1bco", &m_bco, "m_bco/l"); m_hittree->Branch("hitsetkey", &m_hitsetkey, "m_hitsetkey/i"); m_hittree->Branch("gx", &m_hitgx, "m_hitgx/F"); @@ -1704,6 +1824,7 @@ void TrackResiduals::createBranches() m_clustree->Branch("run", &m_runnumber, "m_runnumber/I"); m_clustree->Branch("segment", &m_segment, "m_segment/I"); m_clustree->Branch("event", &m_event, "m_event/I"); + m_clustree->Branch("evt_id", &m_evt_id, "m_evt_id/I"); m_clustree->Branch("gl1bco", &m_bco, "m_bco/l"); m_clustree->Branch("lx", &m_scluslx, "m_scluslx/F"); m_clustree->Branch("lz", &m_scluslz, "m_scluslz/F"); @@ -1713,11 +1834,37 @@ void TrackResiduals::createBranches() m_clustree->Branch("phi", &m_sclusphi, "m_sclusphi/F"); m_clustree->Branch("eta", &m_scluseta, "m_scluseta/F"); m_clustree->Branch("adc", &m_adc, "m_adc/F"); + m_clustree->Branch("size", &m_size, "m_size/I"); m_clustree->Branch("phisize", &m_phisize, "m_phisize/I"); m_clustree->Branch("zsize", &m_zsize, "m_zsize/I"); + m_clustree->Branch("phibinlo", &m_phibinlo, "m_phibinlo/F"); + m_clustree->Branch("phibinhi", &m_phibinhi, "m_phibinhi/F"); + m_clustree->Branch("tbinlo", &m_tbinlo, "m_tbinlo/F"); + m_clustree->Branch("tbinhi", &m_tbinhi, "m_tbinhi/F"); + m_clustree->Branch("padphase", &m_padphase, "m_padphase/F"); + m_clustree->Branch("tbinphase", &m_tbinphase, "m_tbinphase/F"); + m_clustree->Branch("overlap", &m_overlap, "m_overlap/I"); + m_clustree->Branch("nedge", &m_nedge, "m_nedge/I"); + m_clustree->Branch("sledge", &m_sledge, "m_sledge/I"); + m_clustree->Branch("sredge", &m_sredge, "m_sredge/I"); + m_clustree->Branch("tledge", &m_tledge, "m_tledge/I"); + m_clustree->Branch("tredge", &m_tredge, "m_tredge/I"); + m_clustree->Branch("dledge", &m_dledge, "m_dledge/I"); + m_clustree->Branch("dredge", &m_dredge, "m_dredge/I"); + m_clustree->Branch("hledge", &m_hledge, "m_hledge/I"); + m_clustree->Branch("hredge", &m_hredge, "m_hredge/I"); + m_clustree->Branch("slmix", &m_slmix, "m_slmix/I"); + m_clustree->Branch("srmix", &m_srmix, "m_srmix/I"); + m_clustree->Branch("tlmix", &m_tlmix, "m_tlmix/I"); + m_clustree->Branch("trmix", &m_trmix, "m_trmix/I"); m_clustree->Branch("erphi", &m_scluselx, "m_scluselx/F"); m_clustree->Branch("ez", &m_scluselz, "m_scluselz/F"); m_clustree->Branch("maxadc", &m_clusmaxadc, "m_clusmaxadc/F"); + m_clustree->Branch("cenadc", &m_cluscenadc, "m_cluscenadc/F"); + m_clustree->Branch("padcen", &m_padcen, "m_padcen/F"); + m_clustree->Branch("tbincen", &m_tbincen, "m_tbincen/F"); + m_clustree->Branch("padmax", &m_padmax, "m_padmax/F"); + m_clustree->Branch("tbinmax", &m_tbinmax, "m_tbinmax/F"); m_clustree->Branch("sector", &m_clussector, "m_clussector/I"); m_clustree->Branch("side", &m_side, "m_side/I"); m_clustree->Branch("stave", &m_staveid, "m_staveid/I"); @@ -1734,6 +1881,7 @@ void TrackResiduals::createBranches() m_tree->Branch("run", &m_runnumber, "m_runnumber/I"); m_tree->Branch("segment", &m_segment, "m_segment/I"); m_tree->Branch("event", &m_event, "m_event/I"); + m_tree->Branch("evt_id", &m_evt_id, "m_evt_id/I"); m_tree->Branch("mbdcharge",&m_totalmbd, "m_totalmbd/F"); m_tree->Branch("mbdzvtx", &m_mbdvtxz, "m_mbdvtxz/F"); m_tree->Branch("firedTriggers", &m_firedTriggers); @@ -1815,7 +1963,27 @@ void TrackResiduals::createBranches() m_tree->Branch("clusside", &m_clside); m_tree->Branch("cluskeys", &m_cluskeys); m_tree->Branch("clusedge", &m_clusedge); + m_tree->Branch("clussledge", &m_clussledge); + m_tree->Branch("clussredge", &m_clussredge); + m_tree->Branch("clustledge", &m_clustledge); + m_tree->Branch("clustredge", &m_clustredge); + m_tree->Branch("clusdledge", &m_clusdledge); + m_tree->Branch("clusdredge", &m_clusdredge); + m_tree->Branch("clushledge", &m_clushledge); + m_tree->Branch("clushredge", &m_clushredge); + m_tree->Branch("clusslmix", &m_clusslmix); + m_tree->Branch("clussrmix", &m_clussrmix); + m_tree->Branch("clustlmix", &m_clustlmix); + m_tree->Branch("clustrmix", &m_clustrmix); m_tree->Branch("clusoverlap", &m_clusoverlap); + m_tree->Branch("clusphibinlo", &m_clusphibinlo); + m_tree->Branch("clusphibinhi", &m_clusphibinhi); + m_tree->Branch("clustbinlo", &m_clustbinlo); + m_tree->Branch("clustbinhi", &m_clustbinhi); + m_tree->Branch("clusPadCen", &m_clusPadCen); + m_tree->Branch("clusTBinCen", &m_clusTBinCen); + m_tree->Branch("clusPadMax", &m_clusPadMax); + m_tree->Branch("clusTBinMax", &m_clusTBinMax); m_tree->Branch("cluslx", &m_cluslx); m_tree->Branch("cluslz", &m_cluslz); m_tree->Branch("cluselx", &m_cluselx); @@ -1824,6 +1992,8 @@ void TrackResiduals::createBranches() m_tree->Branch("clusgy", &m_clusgy); m_tree->Branch("clusgz", &m_clusgz); m_tree->Branch("clusgr", &m_clusgr); + m_tree->Branch("cluspadphase", &m_cluspadphase); + m_tree->Branch("clustbinphase", &m_clustbinphase); if (m_doAlignment) { m_tree->Branch("clusgxunmoved", &m_clusgxunmoved); @@ -1832,6 +2002,8 @@ void TrackResiduals::createBranches() } m_tree->Branch("clusAdc", &m_clusAdc); m_tree->Branch("clusMaxAdc", &m_clusMaxAdc); + m_tree->Branch("clusCenAdc", &m_clusCenAdc); + m_tree->Branch("clussize", &m_clussize); m_tree->Branch("clusphisize", &m_clusphisize); m_tree->Branch("cluszsize", &m_cluszsize); @@ -2235,6 +2407,7 @@ void TrackResiduals::fillEventTree(PHCompositeNode* topNode) if (Verbosity() > 1) { std::cout << " m_event:" << m_event << std::endl; + std::cout << " m_evt_id:" << m_evt_id << std::endl; std::cout << " m_ntpc_clus0:" << m_ntpc_clus0 << std::endl; std::cout << " m_ntpc_clus1: " << m_ntpc_clus1 << std::endl; std::cout << " m_nmvtx_all:" << m_nmvtx_all << std::endl; diff --git a/offline/packages/TrackingDiagnostics/TrackResiduals.h b/offline/packages/TrackingDiagnostics/TrackResiduals.h index 7e789faba5..6601fc47c9 100644 --- a/offline/packages/TrackingDiagnostics/TrackResiduals.h +++ b/offline/packages/TrackingDiagnostics/TrackResiduals.h @@ -128,6 +128,7 @@ class TrackResiduals : public SubsysReco bool m_doMicromegasOnly = false; int m_event = 0; + int m_evt_id = -1; int m_segment = std::numeric_limits::quiet_NaN(); int m_runnumber = std::numeric_limits::quiet_NaN(); int m_ntpcclus = std::numeric_limits::quiet_NaN(); @@ -246,8 +247,34 @@ class TrackResiduals : public SubsysReco float m_scluseta = std::numeric_limits::quiet_NaN(); float m_adc = std::numeric_limits::quiet_NaN(); float m_clusmaxadc = std::numeric_limits::quiet_NaN(); + float m_cluscenadc = std::numeric_limits::quiet_NaN(); + int m_size = std::numeric_limits::quiet_NaN(); int m_phisize = std::numeric_limits::quiet_NaN(); int m_zsize = std::numeric_limits::quiet_NaN(); + int m_overlap = std::numeric_limits::quiet_NaN(); + int m_nedge = std::numeric_limits::quiet_NaN(); + int m_sledge = std::numeric_limits::quiet_NaN(); + int m_sredge = std::numeric_limits::quiet_NaN(); + int m_tledge = std::numeric_limits::quiet_NaN(); + int m_tredge = std::numeric_limits::quiet_NaN(); + int m_dledge = std::numeric_limits::quiet_NaN(); + int m_dredge = std::numeric_limits::quiet_NaN(); + int m_hledge = std::numeric_limits::quiet_NaN(); + int m_hredge = std::numeric_limits::quiet_NaN(); + int m_slmix = std::numeric_limits::quiet_NaN(); + int m_srmix = std::numeric_limits::quiet_NaN(); + int m_tlmix = std::numeric_limits::quiet_NaN(); + int m_trmix = std::numeric_limits::quiet_NaN(); + float m_phibinlo = std::numeric_limits::quiet_NaN(); + float m_phibinhi = std::numeric_limits::quiet_NaN(); + float m_tbinlo = std::numeric_limits::quiet_NaN(); + float m_tbinhi = std::numeric_limits::quiet_NaN(); + float m_padphase = std::numeric_limits::quiet_NaN(); + float m_tbinphase = std::numeric_limits::quiet_NaN(); + float m_padcen = std::numeric_limits::quiet_NaN(); + float m_tbincen = std::numeric_limits::quiet_NaN(); + float m_padmax = std::numeric_limits::quiet_NaN(); + float m_tbinmax = std::numeric_limits::quiet_NaN(); float m_scluslx = std::numeric_limits::quiet_NaN(); float m_scluslz = std::numeric_limits::quiet_NaN(); float m_sclusgx = std::numeric_limits::quiet_NaN(); @@ -270,6 +297,11 @@ class TrackResiduals : public SubsysReco //! clusters on track information std::vector m_clusAdc; std::vector m_clusMaxAdc; + std::vector m_clusCenAdc; + std::vector m_clusPadCen; + std::vector m_clusTBinCen; + std::vector m_clusPadMax; + std::vector m_clusTBinMax; std::vector m_cluslx; std::vector m_cluslz; std::vector m_cluselx; @@ -288,10 +320,29 @@ class TrackResiduals : public SubsysReco std::vector m_clsector; std::vector m_clside; std::vector m_cluslayer; + std::vector m_clussize; std::vector m_clusphisize; std::vector m_cluszsize; - std::vector m_clusedge; std::vector m_clusoverlap; + std::vector m_clusedge; + std::vector m_clussledge; + std::vector m_clussredge; + std::vector m_clustledge; + std::vector m_clustredge; + std::vector m_clusdledge; + std::vector m_clusdredge; + std::vector m_clushledge; + std::vector m_clushredge; + std::vector m_clusslmix; + std::vector m_clussrmix; + std::vector m_clustlmix; + std::vector m_clustrmix; + std::vector m_clusphibinlo; + std::vector m_clusphibinhi; + std::vector m_clustbinlo; + std::vector m_clustbinhi; + std::vector m_cluspadphase; + std::vector m_clustbinphase; std::vector m_cluskeys; std::vector m_idealsurfcenterx; std::vector m_idealsurfcentery; diff --git a/offline/packages/TrackingDiagnostics/TrkrNtuplizer.cc b/offline/packages/TrackingDiagnostics/TrkrNtuplizer.cc index d5fddf6538..1c90c4688c 100644 --- a/offline/packages/TrackingDiagnostics/TrkrNtuplizer.cc +++ b/offline/packages/TrackingDiagnostics/TrkrNtuplizer.cc @@ -289,6 +289,11 @@ enum n_cluster // NOLINT(readability-enum-initial-value, performance-enum-size) nclue, ncluadc, nclumaxadc, + nclucenadc, + nclupadcen, + nclutbincen, + nclupadmax, + nclutbinmax, ncluthick, ncluafac, nclubfac, @@ -301,7 +306,25 @@ enum n_cluster // NOLINT(readability-enum-initial-value, performance-enum-size) ncluzsize, nclupedge, ncluredge, + nclusledge, + nclusredge, + nclutledge, + nclutredge, + ncludledge, + ncludredge, + ncluhledge, + ncluhredge, + ncluslmix, + nclusrmix, + nclutlmix, + nclutrmix, ncluovlp, + ncluphibinlo, + ncluphibinhi, + nclutbinlo, + nclutbinhi, + nclupadphase, + nclutbinphase, nclutrackID, ncluniter, clusize = ncluniter + 1 @@ -337,7 +360,7 @@ int TrkrNtuplizer::Init(PHCompositeNode* /*unused*/) std::string str_vertex = {"vertexID:vx:vy:vz:ntracks:chi2:ndof"}; std::string str_event = {"event:seed:run:seg:job"}; std::string str_hit = {"hitID:e:adc:layer:phielem:zelem:cellID:ecell:phibin:zbin:tbin:phi:r:x:y:z"}; - std::string str_cluster = {"locx:locy:x:y:z:r:phi:eta:theta:phibin:tbin:fee:chan:sampa:ex:ey:ez:ephi:pez:pephi:e:adc:maxadc:thick:afac:bfac:dcal:layer:phielem:zelem:size:phisize:zsize:pedge:redge:ovlp:trackID:niter"}; + std::string str_cluster = {"locx:locy:x:y:z:r:phi:eta:theta:phibin:tbin:fee:chan:sampa:ex:ey:ez:ephi:pez:pephi:e:adc:maxadc:cenadc:padcen:tbincen:padmax:tbinmax:thick:afac:bfac:dcal:layer:phielem:zelem:size:phisize:zsize:pedge:redge:sledge:sredge:tledge:tredge:dledge:dredge:hledge:hredge:slmix:srmix:tlmix:trmix:ovlp:phibinlo:phibinhi:tbinlo:tbinhi:padphase:tbinphase:trackID:niter"}; std::string str_seed = {"seedID:siter:spt:sptot:seta:sphi:syxint:srzint:sxyslope:srzslope:sX0:sY0:sdZ0:sR0:scharge:sdedx:spidedx:skdedx:sprdedx:sn1pix:snsil:sntpc:snhits"}; std::string str_residual = {"alpha:beta:resphio:resphi:resz"}; std::string str_track = {"trackID:crossing:px:py:pz:pt:eta:phi:deltapt:deltaeta:deltaphi:charge:quality:chisq:ndf:nhits:nmaps:nintt:ntpc:nmms:ntpc1:ntpc11:ntpc2:ntpc3:dedx:pidedx:kdedx:prdedx:vertexID:vx:vy:vz:dca2d:dca2dsigma:dca3dxy:dca3dxysigma:dca3dz:dca3dzsigma:pcax:pcay:pcaz:hlxpt:hlxeta:hlxphi:hlxX0:hlxY0:hlxZ0:hlxcharge"}; @@ -1386,7 +1409,7 @@ void TrkrNtuplizer::fillOutputNtuples(PHCompositeNode* topNode) } //----------------------- - // fill the Vertex NTuple and fixed NaN placeholders + // fill the Vertex NTuple and fixed NaN placeholders //----------------------- bool doit = true; if (_ntp_vertex && doit) @@ -1409,8 +1432,7 @@ void TrkrNtuplizer::fillOutputNtuples(PHCompositeNode* topNode) for (auto & iter : *vertexmap) { SvtxVertex* vertex = iter.second; - if (!vertex) { continue; -} + if (!vertex) { continue; } float fx_vertex[n_vertex::vtxsize]; for (float& i : fx_vertex) @@ -1453,8 +1475,6 @@ void TrkrNtuplizer::fillOutputNtuples(PHCompositeNode* topNode) _timer->stop(); std::cout << "vertex time: " << _timer->get_accumulated_time() / 1000. << " sec" << std::endl; } - - //-------------------- // fill the Hit NTuple //-------------------- @@ -2284,6 +2304,11 @@ void TrkrNtuplizer::FillCluster(float fXcluster[n_cluster::clusize], TrkrDefs::c fXcluster[n_cluster::nclue] = cluster->getAdc(); fXcluster[n_cluster::ncluadc] = cluster->getAdc(); fXcluster[n_cluster::nclumaxadc] = cluster->getMaxAdc(); + fXcluster[n_cluster::nclucenadc] = cluster->getCenAdc(); + fXcluster[n_cluster::nclupadcen] = cluster->getPadCen(); + fXcluster[n_cluster::nclutbincen] = cluster->getTBinCen(); + fXcluster[n_cluster::nclupadmax] = cluster->getPadMax(); + fXcluster[n_cluster::nclutbinmax] = cluster->getTBinMax(); fXcluster[n_cluster::nclulayer] = layer_local; if (layer_local < 3) @@ -2311,7 +2336,7 @@ void TrkrNtuplizer::FillCluster(float fXcluster[n_cluster::clusize], TrkrDefs::c } } */ - fXcluster[n_cluster::nclusize] = cluster->getSize(); + fXcluster[n_cluster::nclusize] = cluster->getRSize(); fXcluster[n_cluster::ncluphisize] = cluster->getPhiSize(); fXcluster[n_cluster::ncluzsize] = cluster->getZSize(); fXcluster[n_cluster::nclupedge] = cluster->getEdge(); @@ -2321,8 +2346,25 @@ void TrkrNtuplizer::FillCluster(float fXcluster[n_cluster::clusize], TrkrDefs::c { fXcluster[n_cluster::ncluredge] = 1; } - - fXcluster[n_cluster::ncluovlp] = 3; // cluster->getOvlp(); + fXcluster[n_cluster::nclusledge] = cluster->getSLEdge(); + fXcluster[n_cluster::nclusredge] = cluster->getSREdge(); + fXcluster[n_cluster::nclutledge] = cluster->getTLEdge(); + fXcluster[n_cluster::nclutredge] = cluster->getTREdge(); + fXcluster[n_cluster::ncludledge] = cluster->getDLEdge(); + fXcluster[n_cluster::ncludredge] = cluster->getDREdge(); + fXcluster[n_cluster::ncluhledge] = cluster->getHLEdge(); + fXcluster[n_cluster::ncluhredge] = cluster->getHREdge(); + fXcluster[n_cluster::ncluslmix] = cluster->getSLMix(); + fXcluster[n_cluster::nclusrmix] = cluster->getSRMix(); + fXcluster[n_cluster::nclutlmix] = cluster->getTLMix(); + fXcluster[n_cluster::nclutrmix] = cluster->getTRMix(); + fXcluster[n_cluster::ncluovlp] = cluster->getOverlap(); + fXcluster[n_cluster::ncluphibinlo] = cluster->getPhiBinLo(); + fXcluster[n_cluster::ncluphibinhi] = cluster->getPhiBinHi(); + fXcluster[n_cluster::nclutbinlo] = cluster->getTBinLo(); + fXcluster[n_cluster::nclutbinhi] = cluster->getTBinHi(); + fXcluster[n_cluster::nclupadphase] = cluster->getPadPhase(); + fXcluster[n_cluster::nclutbinphase] = cluster->getTBinPhase(); fXcluster[n_cluster::nclutrackID] = std::numeric_limits::quiet_NaN(); fXcluster[n_cluster::ncluniter] = 0; From 6772d6f441f707b3ddcbd305892d7d17cb11ec09 Mon Sep 17 00:00:00 2001 From: Ishan Goel Date: Sat, 6 Jun 2026 17:00:25 -0400 Subject: [PATCH 07/11] Requested changes. --- offline/packages/tpc/.TpcClusterizer.cc.swo | Bin 0 -> 16384 bytes offline/packages/trackbase/TrkrCluster.h | 83 +++++----- offline/packages/trackbase/TrkrClusterv6.cc | 41 +---- offline/packages/trackbase/TrkrClusterv6.h | 172 ++++++++++---------- 4 files changed, 132 insertions(+), 164 deletions(-) create mode 100644 offline/packages/tpc/.TpcClusterizer.cc.swo diff --git a/offline/packages/tpc/.TpcClusterizer.cc.swo b/offline/packages/tpc/.TpcClusterizer.cc.swo new file mode 100644 index 0000000000000000000000000000000000000000..407cf8f4e3e8e5a8d9fc3820b7f6d3c23fdf5a38 GIT binary patch literal 16384 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 literal 0 HcmV?d00001 diff --git a/offline/packages/trackbase/TrkrCluster.h b/offline/packages/trackbase/TrkrCluster.h index 0fdb36b6eb..01c66e02f4 100644 --- a/offline/packages/trackbase/TrkrCluster.h +++ b/offline/packages/trackbase/TrkrCluster.h @@ -13,6 +13,7 @@ #include #include +#include #include #include @@ -51,81 +52,81 @@ class TrkrCluster : public PHObject // // cluster position // - virtual float getLocalX() const { return NAN; } + virtual float getLocalX() const { return std::numeric_limits::quiet_NaN(); } virtual void setLocalX(float) {} - virtual float getLocalY() const { return NAN; } + virtual float getLocalY() const { return std::numeric_limits::quiet_NaN(); } virtual void setLocalY(float) {} // // cluster info // - virtual void setAdc(unsigned int) {} - virtual unsigned int getAdc() const { return UINT_MAX; } + virtual void setAdc(uint16_t) {} + virtual uint16_t getAdc() const { return UINT16_MAX; } virtual void setMaxAdc(uint16_t) {} - virtual unsigned int getMaxAdc() const { return UINT_MAX; } - virtual char getOverlap() const { return std::numeric_limits::max(); } + virtual uint16_t getMaxAdc() const { return UINT16_MAX; } + virtual uint8_t getOverlap() const { return std::numeric_limits::max(); } virtual void setOverlap(char) {} - virtual char getEdge() const { return std::numeric_limits::max(); } + virtual uint8_t getEdge() const { return std::numeric_limits::max(); } virtual void setEdge(char) {} virtual void setTime(const float) {} - virtual float getTime() const { return NAN; } - virtual char getSize() const { return std::numeric_limits::max(); } + virtual float getTime() const { return std::numeric_limits::quiet_NaN(); } + virtual uint8_t getSize() const { return std::numeric_limits::max(); } // // convenience interface // - virtual float getPhiSize() const { return NAN; } - virtual float getZSize() const { return NAN; } - virtual float getPhiError() const { return NAN; } - virtual float getRPhiError() const { return NAN; } - virtual float getZError() const { return NAN; } - virtual unsigned int getCenAdc() const { return UINT_MAX; } - virtual float getPadCen() const { return NAN; } - virtual float getTBinCen() const { return NAN; } - virtual float getPadMax() const { return NAN; } - virtual float getTBinMax() const { return NAN; } - virtual char getSLEdge() const { return std::numeric_limits::max(); } - virtual char getSREdge() const { return std::numeric_limits::max(); } - virtual char getTLEdge() const { return std::numeric_limits::max(); } - virtual char getTREdge() const { return std::numeric_limits::max(); } - virtual char getDLEdge() const { return std::numeric_limits::max(); } - virtual char getDREdge() const { return std::numeric_limits::max(); } - virtual char getHLEdge() const { return std::numeric_limits::max(); } - virtual char getHREdge() const { return std::numeric_limits::max(); } + virtual float getPhiSize() const { return std::numeric_limits::quiet_NaN(); } + virtual float getZSize() const { return std::numeric_limits::quiet_NaN(); } + virtual float getPhiError() const { return std::numeric_limits::quiet_NaN(); } + virtual float getRPhiError() const { return std::numeric_limits::quiet_NaN(); } + virtual float getZError() const { return std::numeric_limits::quiet_NaN(); } + virtual uint16_t getCenAdc() const { return UINT16_MAX; } + virtual float getPadCen() const { return std::numeric_limits::quiet_NaN(); } + virtual float getTBinCen() const { return std::numeric_limits::quiet_NaN(); } + virtual float getPadMax() const { return std::numeric_limits::quiet_NaN(); } + virtual float getTBinMax() const { return std::numeric_limits::quiet_NaN(); } + virtual uint8_t getSLEdge() const { return std::numeric_limits::max(); } + virtual uint8_t getSREdge() const { return std::numeric_limits::max(); } + virtual uint8_t getTLEdge() const { return std::numeric_limits::max(); } + virtual uint8_t getTREdge() const { return std::numeric_limits::max(); } + virtual uint8_t getDLEdge() const { return std::numeric_limits::max(); } + virtual uint8_t getDREdge() const { return std::numeric_limits::max(); } + virtual uint8_t getHLEdge() const { return std::numeric_limits::max(); } + virtual uint8_t getHREdge() const { return std::numeric_limits::max(); } virtual int getSLMix() const { return std::numeric_limits::max(); } virtual int getSRMix() const { return std::numeric_limits::max(); } virtual int getTLMix() const { return std::numeric_limits::max(); } virtual int getTRMix() const { return std::numeric_limits::max(); } - virtual float getPhiBinLo() const { return NAN; } - virtual float getPhiBinHi() const { return NAN; } - virtual float getTBinLo() const { return NAN; } - virtual float getTBinHi() const { return NAN; } - virtual float getPadPhase() const { return NAN; } - virtual float getTBinPhase() const { return NAN; } - virtual float getRSize() const { return NAN; } + virtual int getPhiBinLo() const { return std::numeric_limits::quiet_NaN(); } + virtual int getPhiBinHi() const { return std::numeric_limits::quiet_NaN(); } + virtual int getTBinLo() const { return std::numeric_limits::quiet_NaN(); } + virtual int getTBinHi() const { return std::numeric_limits::quiet_NaN(); } + virtual float getPadPhase() const { return std::numeric_limits::quiet_NaN(); } + virtual float getTBinPhase() const { return std::numeric_limits::quiet_NaN(); } + virtual float getRSize() const { return std::numeric_limits::quiet_NaN(); } /// Acts functions, for Acts modules use only virtual void setActsLocalError(unsigned int /*i*/, unsigned int /*j*/, float /*value*/) {} - virtual float getActsLocalError(unsigned int /*i*/, unsigned int /*j*/) const { return NAN; } + virtual float getActsLocalError(unsigned int /*i*/, unsigned int /*j*/) const { return std::numeric_limits::quiet_NaN(); } virtual TrkrDefs::subsurfkey getSubSurfKey() const { return TrkrDefs::SUBSURFKEYMAX; } virtual void setSubSurfKey(TrkrDefs::subsurfkey /*id*/) {} // Global coordinate functions are deprecated, use local // coordinate functions only - virtual float getX() const { return NAN; } + virtual float getX() const { return std::numeric_limits::quiet_NaN(); } virtual void setX(float) {} - virtual float getY() const { return NAN; } + virtual float getY() const { return std::numeric_limits::quiet_NaN(); } virtual void setY(float) {} - virtual float getZ() const { return NAN; } + virtual float getZ() const { return std::numeric_limits::quiet_NaN(); } virtual void setZ(float) {} - virtual float getPosition(int /*coor*/) const { return NAN; } + virtual float getPosition(int /*coor*/) const { return std::numeric_limits::quiet_NaN(); } virtual void setPosition(int /*coor*/, float /*xi*/) {} virtual void setGlobal() {} virtual void setLocal() {} virtual bool isGlobal() const { return true; } - virtual float getError(unsigned int /*i*/, unsigned int /*j*/) const { return NAN; } + virtual float getError(unsigned int /*i*/, unsigned int /*j*/) const { return std::numeric_limits::quiet_NaN(); } virtual void setError(unsigned int /*i*/, unsigned int /*j*/, float /*value*/) {} - virtual float getSize(unsigned int /*i*/, unsigned int /*j*/) const { return NAN; } + virtual float getSize(unsigned int /*i*/, unsigned int /*j*/) const { return std::numeric_limits::quiet_NaN(); } virtual void setSize(unsigned int /*i*/, unsigned int /*j*/, float /*value*/) {} protected: diff --git a/offline/packages/trackbase/TrkrClusterv6.cc b/offline/packages/trackbase/TrkrClusterv6.cc index 4481a9828a..9d5654fde7 100644 --- a/offline/packages/trackbase/TrkrClusterv6.cc +++ b/offline/packages/trackbase/TrkrClusterv6.cc @@ -6,7 +6,9 @@ */ #include "TrkrClusterv6.h" +#include #include +#include #include // for swap namespace @@ -20,44 +22,7 @@ namespace } // namespace TrkrClusterv6::TrkrClusterv6() - : m_subsurfkey(TrkrDefs::SUBSURFKEYMAX) - , m_phierr(0) - , m_zerr(0) - , m_adc(0) - , m_maxadc(0) - , m_cenadc(0) - , m_padcen(0) - , m_tbincen(0) - , m_padmax(0) - , m_tbinmax(0) - , m_rsize(0) - , m_phisize(0) - , m_zsize(0) - , m_overlap(0) - , m_edge(0) - , m_sledge(0) - , m_sredge(0) - , m_tledge(0) - , m_tredge(0) - , m_dledge(0) - , m_dredge(0) - , m_hledge(0) - , m_hredge(0) - , m_slmix(0) - , m_srmix(0) - , m_tlmix(0) - , m_trmix(0) - , m_phibinlo(0) - , m_phibinhi(0) - , m_tbinlo(0) - , m_tbinhi(0) - , m_padphase(0) - , m_tbinphase(0) { - for (float& i : m_local) - { - i = NAN; - } } void TrkrClusterv6::identify(std::ostream& os) const @@ -84,7 +49,7 @@ int TrkrClusterv6::isValid() const return 0; } } - if (m_adc == 0xFFFF) + if (m_adc == std::numeric_limits::max()) { return 0; } diff --git a/offline/packages/trackbase/TrkrClusterv6.h b/offline/packages/trackbase/TrkrClusterv6.h index e1b61a9820..1657bd127d 100644 --- a/offline/packages/trackbase/TrkrClusterv6.h +++ b/offline/packages/trackbase/TrkrClusterv6.h @@ -7,11 +7,13 @@ #ifndef TRACKBASE_TRKRCLUSTERV6_H #define TRACKBASE_TRKRCLUSTERV6_H -#include -#include #include "TrkrCluster.h" #include "TrkrDefs.h" +#include +#include +#include + class PHObject; /** @@ -24,7 +26,7 @@ class TrkrClusterv6 : public TrkrCluster { public: //! ctor - TrkrClusterv6(); + TrkrClusterv6() = default; //! dtor ~TrkrClusterv6() override = default; @@ -57,7 +59,7 @@ class TrkrClusterv6 : public TrkrCluster // float getPosition(int coor) const override { - return (coor >= 0 && coor < 2) ? m_local[coor] : NAN; + return (coor >= 0 && coor < 2) ? m_local[coor] : std::numeric_limits::quiet_NaN(); } void setPosition(int coor, float xi) override { @@ -77,13 +79,13 @@ class TrkrClusterv6 : public TrkrCluster // // cluster info // - unsigned int getAdc() const override { return m_adc; } - void setAdc(unsigned int adc) override { m_adc = adc; } + uint16_t getAdc() const override { return m_adc; } + void setAdc(uint16_t adc) override { m_adc = adc; } - unsigned int getMaxAdc() const override { return m_maxadc; } + uint16_t getMaxAdc() const override { return m_maxadc; } void setMaxAdc(uint16_t maxadc) override { m_maxadc = maxadc; } - unsigned int getCenAdc() const override { return m_cenadc; } + uint16_t getCenAdc() const override { return m_cenadc; } void setCenAdc(uint16_t cenadc) { m_cenadc = cenadc; } float getPadCen() const override { return m_padcen; } @@ -111,17 +113,17 @@ class TrkrClusterv6 : public TrkrCluster float getX() const override { std::cout << "Deprecated getx trkrcluster function!" << std::endl; - return NAN; + return std::numeric_limits::quiet_NaN(); } float getY() const override { std::cout << "Deprecated gety trkrcluster function!" << std::endl; - return NAN; + return std::numeric_limits::quiet_NaN(); } float getZ() const override { std::cout << "Deprecated getz trkrcluster function!" << std::endl; - return NAN; + return std::numeric_limits::quiet_NaN(); } void setX(float) override { @@ -138,7 +140,7 @@ class TrkrClusterv6 : public TrkrCluster float getSize(unsigned int, unsigned int) const override { std::cout << "Deprecated getsize trkrcluster function!" << std::endl; - return NAN; + return std::numeric_limits::quiet_NaN(); } void setSize(unsigned int, unsigned int, float) override { @@ -147,7 +149,7 @@ class TrkrClusterv6 : public TrkrCluster float getError(unsigned int, unsigned int) const override { std::cout << "Deprecated geterr trkrcluster function!" << std::endl; - return NAN; + return std::numeric_limits::quiet_NaN(); } void setError(unsigned int, unsigned int, float) override { @@ -155,70 +157,70 @@ class TrkrClusterv6 : public TrkrCluster } char getSize() const override { return m_phisize * m_zsize; } - // void setSize(char size) { m_size = size; } + // void setSize(uint8_t size) { m_size = size; } float getRSize() const override { return (float) m_rsize; } - void setRSize(unsigned char rsize) { m_rsize = rsize; } + void setRSize(uint8_t rsize) { m_rsize = rsize; } float getPhiSize() const override { return (float) m_phisize; } - void setPhiSize(char phisize) { m_phisize = phisize; } + void setPhiSize(uint8_t phisize) { m_phisize = phisize; } float getZSize() const override { return (float) m_zsize; } - void setZSize(char zsize) { m_zsize = zsize; } + void setZSize(uint8_t zsize) { m_zsize = zsize; } - char getOverlap() const override { return m_overlap; } - void setOverlap(char overlap) override { m_overlap = overlap; } + uint8_t getOverlap() const override { return m_overlap; } + void setOverlap(uint8_t overlap) override { m_overlap = overlap; } - char getEdge() const override { return m_edge; } - void setEdge(char edge) override { m_edge = edge; } + uint8_t getEdge() const override { return m_edge; } + void setEdge(uint8_t edge) override { m_edge = edge; } - char getSLEdge() const override { return m_sledge; } - void setSLEdge(char sledge) { m_sledge = sledge; } + uint8_t getSLEdge() const override { return m_sledge; } + void setSLEdge(uint8_t sledge) { m_sledge = sledge; } - char getSREdge() const override { return m_sredge; } - void setSREdge(char sredge) { m_sredge = sredge; } + uint8_t getSREdge() const override { return m_sredge; } + void setSREdge(uint8_t sredge) { m_sredge = sredge; } - char getTLEdge() const override { return m_tledge; } - void setTLEdge(char tledge) { m_tledge = tledge; } + uint8_t getTLEdge() const override { return m_tledge; } + void setTLEdge(uint8_t tledge) { m_tledge = tledge; } - char getTREdge() const override { return m_tredge; } - void setTREdge(char tredge) { m_tredge = tredge; } + uint8_t getTREdge() const override { return m_tredge; } + void setTREdge(uint8_t tredge) { m_tredge = tredge; } - char getDLEdge() const override { return m_dledge; } - void setDLEdge(char dledge) { m_dledge = dledge; } + uint8_t getDLEdge() const override { return m_dledge; } + void setDLEdge(uint8_t dledge) { m_dledge = dledge; } - char getDREdge() const override { return m_dredge; } - void setDREdge(char dredge) { m_dredge = dredge; } + uint8_t getDREdge() const override { return m_dredge; } + void setDREdge(uint8_t dredge) { m_dredge = dredge; } - char getHLEdge() const override { return m_hledge; } - void setHLEdge(char hledge) { m_hledge = hledge; } + uint8_t getHLEdge() const override { return m_hledge; } + void setHLEdge(uint8_t hledge) { m_hledge = hledge; } - char getHREdge() const override { return m_hredge; } - void setHREdge(char hredge) { m_hredge = hredge; } + uint8_t getHREdge() const override { return m_hredge; } + void setHREdge(uint8_t hredge) { m_hredge = hredge; } int getSLMix() const override { return m_slmix; } - void setSLMix(char slmix) { m_slmix = slmix; } + void setSLMix(uint8_t slmix) { m_slmix = slmix; } int getSRMix() const override { return m_srmix; } - void setSRMix(char srmix) { m_srmix = srmix; } + void setSRMix(uint8_t srmix) { m_srmix = srmix; } int getTLMix() const override { return m_tlmix; } - void setTLMix(char tlmix) { m_tlmix = tlmix; } + void setTLMix(uint8_t tlmix) { m_tlmix = tlmix; } int getTRMix() const override { return m_trmix; } - void setTRMix(char trmix) { m_trmix = trmix; } + void setTRMix(uint8_t trmix) { m_trmix = trmix; } - float getPhiBinLo() const override { return m_phibinlo; } - void setPhiBinLo(float phibinlo) { m_phibinlo = phibinlo; } + int getPhiBinLo() const override { return m_phibinlo; } + void setPhiBinLo(int phibinlo) { m_phibinlo = phibinlo; } - float getPhiBinHi() const override { return m_phibinhi; } - void setPhiBinHi(float phibinhi) { m_phibinhi = phibinhi; } + int getPhiBinHi() const override { return m_phibinhi; } + void setPhiBinHi(int phibinhi) { m_phibinhi = phibinhi; } - float getTBinLo() const override { return m_tbinlo; } - void setTBinLo(float tbinlo) { m_tbinlo = tbinlo; } + int getTBinLo() const override { return m_tbinlo; } + void setTBinLo(int tbinlo) { m_tbinlo = tbinlo; } - float getTBinHi() const override { return m_tbinhi; } - void setTBinHi(float tbinhi) { m_tbinhi = tbinhi; } + int getTBinHi() const override { return m_tbinhi; } + void setTBinHi(int tbinhi) { m_tbinhi = tbinhi; } float getPadPhase() const override { return m_padphase; } void setPadPhase(float padphase) { m_padphase = padphase; } @@ -227,48 +229,48 @@ class TrkrClusterv6 : public TrkrCluster void setTBinPhase(float tbinphase){ m_tbinphase = tbinphase; } // float getPhiSize() const override - //{ std::cout << "Deprecated size function"<< std::endl; return NAN;} + //{ std::cout << "Deprecated size function"<< std::endl; return std::numeric_limits::quiet_NaN();} // float getZSize() const override - //{std::cout << "Deprecated size function" << std::endl; return NAN;} + //{std::cout << "Deprecated size function" << std::endl; return std::numeric_limits::quiet_NaN();} // float getPhiError() const override - //{ std::cout << "Deprecated getPhiError function"<< std::endl; return NAN;} + //{ std::cout << "Deprecated getPhiError function"<< std::endl; return std::numeric_limits::quiet_NaN();} private: float m_local[2]{std::numeric_limits::quiet_NaN(), std::numeric_limits::quiet_NaN()}; //< 2D local position [cm] 2 * 32 64bit - cumul 1*64 - TrkrDefs::subsurfkey m_subsurfkey; //< unique identifier for hitsetkey-surface maps 16 bit - float m_phierr; - float m_zerr; - unsigned short int m_adc; //< cluster sum adc 16 - unsigned short int m_maxadc; //< cluster max adc 16 - unsigned short int m_cenadc; //< cluster centroid adc 16 - float m_padcen; - float m_tbincen; - float m_padmax; - float m_tbinmax; - unsigned char m_rsize; // 8bit - char m_phisize; // 8bit - char m_zsize; // 8bit - char m_overlap; // 8bit - char m_edge; // 8bit - cumul 2*64 - char m_sledge; // 8bit - char m_sredge; // 8bit - char m_tledge; // 8bit - char m_tredge; // 8bit - char m_dledge; // 8bit - char m_dredge; // 8bit - char m_hledge; // 8bit - char m_hredge; // 8bit - char m_slmix; // 8bit - char m_srmix; // 8bit - char m_tlmix; // 8bit - char m_trmix; // 8bit - float m_phibinlo; - float m_phibinhi; - float m_tbinlo; - float m_tbinhi; - float m_padphase; - float m_tbinphase; + TrkrDefs::subsurfkey m_subsurfkey{TrkrDefs::SUBSURFKEYMAX}; //< unique identifier for hitsetkey-surface maps 16 bit + float m_phierr{0}; + float m_zerr{0}; + uint16_t m_adc{0}; //< cluster sum adc 16 + uint16_t m_maxadc{0}; //< cluster max adc 16 + uint16_t m_cenadc{0}; //< cluster centroid adc 16 + float m_padcen{0}; + float m_tbincen{0}; + float m_padmax{0}; + float m_tbinmax{0}; + uint8_t m_rsize{0}; // 8bit + uint8_t m_phisize{0}; // 8bit + uint8_t m_zsize{0}; // 8bit + uint8_t m_overlap{0}; // 8bit + uint8_t m_edge{0}; // 8bit - cumul 2*64 + uint8_t m_sledge{0}; // 8bit + uint8_t m_sredge{0}; // 8bit + uint8_t m_tledge{0}; // 8bit + uint8_t m_tredge{0}; // 8bit + uint8_t m_dledge{0}; // 8bit + uint8_t m_dredge{0}; // 8bit + uint8_t m_hledge{0}; // 8bit + uint8_t m_hredge{0}; // 8bit + uint8_t m_slmix{0}; // 8bit + uint8_t m_srmix{0}; // 8bit + uint8_t m_tlmix{0}; // 8bit + uint8_t m_trmix{0}; // 8bit + int m_phibinlo{0}; + int m_phibinhi{0}; + int m_tbinlo{0}; + int m_tbinhi{0}; + float m_padphase{0}; + float m_tbinphase{0}; ClassDefOverride(TrkrClusterv6, 1) }; From 5332e22b56a4d70295b1b9f7ca7117582283b27b Mon Sep 17 00:00:00 2001 From: Ishan Goel Date: Sat, 6 Jun 2026 17:19:30 -0400 Subject: [PATCH 08/11] More fixes --- offline/packages/trackbase/TrkrCluster.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/offline/packages/trackbase/TrkrCluster.h b/offline/packages/trackbase/TrkrCluster.h index 01c66e02f4..e676b7ea62 100644 --- a/offline/packages/trackbase/TrkrCluster.h +++ b/offline/packages/trackbase/TrkrCluster.h @@ -65,9 +65,9 @@ class TrkrCluster : public PHObject virtual void setMaxAdc(uint16_t) {} virtual uint16_t getMaxAdc() const { return UINT16_MAX; } virtual uint8_t getOverlap() const { return std::numeric_limits::max(); } - virtual void setOverlap(char) {} + virtual void setOverlap(uint8_t) {} virtual uint8_t getEdge() const { return std::numeric_limits::max(); } - virtual void setEdge(char) {} + virtual void setEdge(uint8_t) {} virtual void setTime(const float) {} virtual float getTime() const { return std::numeric_limits::quiet_NaN(); } virtual uint8_t getSize() const { return std::numeric_limits::max(); } @@ -97,10 +97,10 @@ class TrkrCluster : public PHObject virtual int getSRMix() const { return std::numeric_limits::max(); } virtual int getTLMix() const { return std::numeric_limits::max(); } virtual int getTRMix() const { return std::numeric_limits::max(); } - virtual int getPhiBinLo() const { return std::numeric_limits::quiet_NaN(); } - virtual int getPhiBinHi() const { return std::numeric_limits::quiet_NaN(); } - virtual int getTBinLo() const { return std::numeric_limits::quiet_NaN(); } - virtual int getTBinHi() const { return std::numeric_limits::quiet_NaN(); } + virtual int getPhiBinLo() const { return std::numeric_limits::max(); } + virtual int getPhiBinHi() const { return std::numeric_limits::max(); } + virtual int getTBinLo() const { return std::numeric_limits::max(); } + virtual int getTBinHi() const { return std::numeric_limits::max(); } virtual float getPadPhase() const { return std::numeric_limits::quiet_NaN(); } virtual float getTBinPhase() const { return std::numeric_limits::quiet_NaN(); } virtual float getRSize() const { return std::numeric_limits::quiet_NaN(); } From 91199aa25e65f59aa194b73ce37115815b1d91f1 Mon Sep 17 00:00:00 2001 From: Ishan Goel Date: Sat, 6 Jun 2026 23:11:15 -0400 Subject: [PATCH 09/11] Even more fixes! Sigh! --- .../TrackingDiagnostics/TrackResiduals.cc | 195 +---------- .../TrackingDiagnostics/TrackResiduals.h | 53 +-- .../TrackingDiagnostics/TrkrNtuplizer.cc | 60 +--- offline/packages/tpc/TpcClusterizer.cc | 308 +++--------------- .../packages/trackbase/.TrkrClusterv6.h.swn | Bin 0 -> 16384 bytes offline/packages/trackbase/TrkrClusterv1.h | 6 +- offline/packages/trackbase/TrkrClusterv2.h | 6 +- offline/packages/trackbase/TrkrClusterv3.h | 6 +- offline/packages/trackbase/TrkrClusterv4.h | 38 +-- offline/packages/trackbase/TrkrClusterv5.h | 34 +- offline/packages/trackbase/TrkrClusterv6.cc | 4 - offline/packages/trackbase/TrkrClusterv6.h | 2 +- 12 files changed, 114 insertions(+), 598 deletions(-) create mode 100644 offline/packages/trackbase/.TrkrClusterv6.h.swn diff --git a/offline/packages/TrackingDiagnostics/TrackResiduals.cc b/offline/packages/TrackingDiagnostics/TrackResiduals.cc index fe41ab9af1..1a5a69fae0 100644 --- a/offline/packages/TrackingDiagnostics/TrackResiduals.cc +++ b/offline/packages/TrackingDiagnostics/TrackResiduals.cc @@ -46,8 +46,6 @@ #include #include -#include - #include #include #include @@ -59,7 +57,6 @@ #include #include #include -#include #include @@ -129,7 +126,6 @@ int TrackResiduals::InitRun(PHCompositeNode* topNode) void TrackResiduals::clearClusterStateVectors() { m_cluskeys.clear(); - m_clussize.clear(); m_clusphisize.clear(); m_cluszsize.clear(); m_idealsurfcenterx.clear(); @@ -187,23 +183,7 @@ void TrackResiduals::clearClusterStateVectors() m_statelzlocderivqop.clear(); m_clusedge.clear(); - m_clussledge.clear(); - m_clussredge.clear(); - m_clustledge.clear(); - m_clustredge.clear(); - m_clusdledge.clear(); - m_clusdredge.clear(); - m_clushledge.clear(); - m_clushredge.clear(); - m_clusslmix.clear(); - m_clussrmix.clear(); - m_clustlmix.clear(); - m_clustrmix.clear(); m_clusoverlap.clear(); - m_clusPadCen.clear(); - m_clusTBinCen.clear(); - m_clusPadMax.clear(); - m_clusTBinMax.clear(); m_cluslx.clear(); m_cluslz.clear(); m_cluselx.clear(); @@ -217,14 +197,7 @@ void TrackResiduals::clearClusterStateVectors() m_clusgzunmoved.clear(); m_clusAdc.clear(); m_clusMaxAdc.clear(); - m_clusCenAdc.clear(); m_cluslayer.clear(); - m_clusphibinlo.clear(); - m_clusphibinhi.clear(); - m_clustbinlo.clear(); - m_clustbinhi.clear(); - m_cluspadphase.clear(); - m_clustbinphase.clear(); m_statelx.clear(); m_statelz.clear(); @@ -328,21 +301,6 @@ int TrackResiduals::process_event(PHCompositeNode* topNode) } } - EventHeader* eventheader = findNode::getClass(topNode, "EventHeader"); - - if(eventheader) - { - m_evt_id = eventheader->get_EvtSequence(); - } - else - { - m_evt_id = -1; - } - - auto *rcs = recoConsts::instance(); - m_runnumber = rcs->get_IntFlag("RUNNUMBER"); - m_segment = rcs->get_IntFlag("RUNSEGMENT"); - m_ntpcclus = 0; if (Verbosity() > 1) { @@ -704,37 +662,11 @@ void TrackResiduals::fillClusterTree(TrkrClusterContainer* clusters, m_scluseta = acos(glob.z() / std::sqrt(square(glob.x()) + square(glob.y()) + square(glob.z()))); m_adc = cluster->getAdc(); m_clusmaxadc = cluster->getMaxAdc(); - m_cluscenadc = cluster->getCenAdc(); - m_padcen = cluster->getPadCen(); - m_tbincen = cluster->getTBinCen(); - m_padmax = cluster->getPadMax(); - m_tbinmax = cluster->getTBinMax(); m_scluslx = cluster->getLocalX(); m_scluslz = cluster->getLocalY(); - m_phibinlo = cluster->getPhiBinLo(); - m_phibinhi = cluster->getPhiBinHi(); - m_tbinlo = cluster->getTBinLo(); - m_tbinhi = cluster->getTBinHi(); - m_padphase = cluster->getPadPhase(); - m_tbinphase = cluster->getTBinPhase(); auto para_errors = ClusterErrorPara::get_clusterv5_modified_error(cluster, m_sclusgr, key); - m_size = cluster->getSize(); m_phisize = cluster->getPhiSize(); m_zsize = cluster->getZSize(); - m_overlap = cluster->getOverlap(); - m_nedge = cluster->getEdge(); - m_sledge = cluster->getSLEdge(); - m_sredge = cluster->getSREdge(); - m_tledge = cluster->getTLEdge(); - m_tredge = cluster->getTREdge(); - m_dledge = cluster->getDLEdge(); - m_dredge = cluster->getDREdge(); - m_hledge = cluster->getHLEdge(); - m_hredge = cluster->getHREdge(); - m_slmix = cluster->getSLMix(); - m_srmix = cluster->getSRMix(); - m_tlmix = cluster->getTLMix(); - m_trmix = cluster->getTRMix(); m_scluselx = std::sqrt(para_errors.first); m_scluselz = std::sqrt(para_errors.second); @@ -1155,19 +1087,7 @@ void TrackResiduals::fillClusterBranchesKF(TrkrDefs::cluskey ckey, SvtxTrack* tr //! have cluster and state, fill vectors m_clusedge.push_back(cluster->getEdge()); - m_clussledge.push_back(cluster->getSLEdge()); - m_clussredge.push_back(cluster->getSREdge()); - m_clustledge.push_back(cluster->getTLEdge()); - m_clustredge.push_back(cluster->getTREdge()); - m_clusdledge.push_back(cluster->getDLEdge()); - m_clusdredge.push_back(cluster->getDREdge()); - m_clushledge.push_back(cluster->getHLEdge()); - m_clushredge.push_back(cluster->getHREdge()); m_clusoverlap.push_back(cluster->getOverlap()); - m_clusslmix.push_back(cluster->getSLMix()); - m_clussrmix.push_back(cluster->getSRMix()); - m_clustlmix.push_back(cluster->getTLMix()); - m_clustrmix.push_back(cluster->getTRMix()); // get new local coords from moved cluster Surface surf = geometry->maps().getSurface(ckey, cluster); @@ -1208,7 +1128,7 @@ void TrackResiduals::fillClusterBranchesKF(TrkrDefs::cluskey ckey, SvtxTrack* tr { // otherwise take the manual calculation for the TPC // doing it this way just avoids the bounds check that occurs in the surface class method - Acts::Vector3 loct = surf->localtoGlobalTransform(geometry->geometry().getGeoContext()).inverse() * clusglob_moved; // global is in mm + Acts::Vector3 loct = surf->localToGlobalTransform(geometry->geometry().getGeoContext()).inverse() * clusglob_moved; // global is in mm loct /= Acts::UnitConstants::cm; loc(0) = loct(0); @@ -1240,25 +1160,13 @@ void TrackResiduals::fillClusterBranchesKF(TrkrDefs::cluskey ckey, SvtxTrack* tr m_clusgzunmoved.push_back(clusglob.z()); m_clusAdc.push_back(cluster->getAdc()); m_clusMaxAdc.push_back(cluster->getMaxAdc()); - m_clusCenAdc.push_back(cluster->getCenAdc()); - m_clusPadCen.push_back(cluster->getPadCen()); - m_clusTBinCen.push_back(cluster->getTBinCen()); - m_clusPadMax.push_back(cluster->getPadMax()); - m_clusTBinMax.push_back(cluster->getTBinMax()); m_cluslayer.push_back(TrkrDefs::getLayer(ckey)); - m_clussize.push_back(cluster->getSize()); m_clusphisize.push_back(cluster->getPhiSize()); m_cluszsize.push_back(cluster->getZSize()); - m_clusphibinlo.push_back(cluster->getPhiBinLo()); - m_clusphibinhi.push_back(cluster->getPhiBinHi()); - m_clustbinlo.push_back(cluster->getTBinLo()); - m_clustbinhi.push_back(cluster->getTBinHi()); - m_cluspadphase.push_back(cluster->getPadPhase()); - m_clustbinphase.push_back(cluster->getTBinPhase()); auto misaligncenter = surf->center(geometry->geometry().getGeoContext()); auto misalignnorm = -1 * surf->normal(geometry->geometry().getGeoContext(), Acts::Vector3(1, 1, 1), Acts::Vector3(1, 1, 1)); - auto misrot = surf->localtoGlobalTransform(geometry->geometry().getGeoContext()).rotation(); + auto misrot = surf->localToGlobalTransform(geometry->geometry().getGeoContext()).rotation(); float mgamma = atan2(-misrot(1, 0), misrot(0, 0)); float mbeta = -asin(misrot(0, 1)); @@ -1275,11 +1183,11 @@ void TrackResiduals::fillClusterBranchesKF(TrkrDefs::cluskey ckey, SvtxTrack* tr std::cout << "resids: layer " << layer << " ideal center z " << idealcenter.z() << " mm " << std::endl; std::cout << " surface bounds " << surfbounds[0] << " " << surfbounds[1] << " mm " << std::endl; alignmentTransformationContainer::use_alignment = false; - Acts::Transform3 transform = surf_ideal->localtoGlobalTransform(geometry->geometry().getGeoContext()); + Acts::Transform3 transform = surf_ideal->localToGlobalTransform(geometry->geometry().getGeoContext()); std::cout << "Ideal transform is:" << std::endl; std::cout << transform.matrix() << std::endl; alignmentTransformationContainer::use_alignment = true; - Acts::Transform3 transform1 = surf_ideal->localtoGlobalTransform(geometry->geometry().getGeoContext()); + Acts::Transform3 transform1 = surf_ideal->localToGlobalTransform(geometry->geometry().getGeoContext()); std::cout << "Alignment transform is:" << std::endl; std::cout << transform1.matrix() << std::endl; @@ -1291,8 +1199,8 @@ void TrackResiduals::fillClusterBranchesKF(TrkrDefs::cluskey ckey, SvtxTrack* tr // Acts::Vector3 ideal_local(loc.x(), loc.y(), 0.0); auto nominal_loc = geometry->getLocalCoords(ckey, cluster); Acts::Vector3 ideal_local(nominal_loc.x(), nominal_loc.y(), 0.0); - Acts::Vector3 ideal_glob = surf_ideal->localtoGlobalTransform(geometry->geometry().getGeoContext()) * (ideal_local * Acts::UnitConstants::cm); - auto idealrot = surf_ideal->localtoGlobalTransform(geometry->geometry().getGeoContext()).rotation(); + Acts::Vector3 ideal_glob = surf_ideal->localToGlobalTransform(geometry->geometry().getGeoContext()) * (ideal_local * Acts::UnitConstants::cm); + auto idealrot = surf_ideal->localToGlobalTransform(geometry->geometry().getGeoContext()).rotation(); //! These calculations are taken from the wikipedia page for Euler angles, //! under the Tait-Bryan angle explanation. Formulas for the angles @@ -1508,18 +1416,6 @@ void TrackResiduals::fillClusterBranchesSeeds(TrkrDefs::cluskey ckey, // SvtxTr //! have cluster and state, fill vectors m_clusedge.push_back(cluster->getEdge()); - m_clussledge.push_back(cluster->getSLEdge()); - m_clussredge.push_back(cluster->getSREdge()); - m_clustledge.push_back(cluster->getTLEdge()); - m_clustredge.push_back(cluster->getTREdge()); - m_clusdledge.push_back(cluster->getDLEdge()); - m_clusdredge.push_back(cluster->getDREdge()); - m_clushledge.push_back(cluster->getHLEdge()); - m_clushredge.push_back(cluster->getHREdge()); - m_clusslmix.push_back(cluster->getSLMix()); - m_clussrmix.push_back(cluster->getSRMix()); - m_clustlmix.push_back(cluster->getTLMix()); - m_clustrmix.push_back(cluster->getTRMix()); m_clusoverlap.push_back(cluster->getOverlap()); // This is the nominal position of the cluster in local coords, completely uncorrected - is that what we want? @@ -1542,21 +1438,9 @@ void TrackResiduals::fillClusterBranchesSeeds(TrkrDefs::cluskey ckey, // SvtxTr m_clusgzunmoved.push_back(clusglob.z()); m_clusAdc.push_back(cluster->getAdc()); m_clusMaxAdc.push_back(cluster->getMaxAdc()); - m_clusCenAdc.push_back(cluster->getCenAdc()); - m_clusPadCen.push_back(cluster->getPadCen()); - m_clusTBinCen.push_back(cluster->getTBinCen()); - m_clusPadMax.push_back(cluster->getPadMax()); - m_clusTBinMax.push_back(cluster->getTBinMax()); m_cluslayer.push_back(TrkrDefs::getLayer(ckey)); - m_clussize.push_back(cluster->getSize()); m_clusphisize.push_back(cluster->getPhiSize()); m_cluszsize.push_back(cluster->getZSize()); - m_clusphibinlo.push_back(cluster->getPhiBinLo()); - m_clusphibinhi.push_back(cluster->getPhiBinHi()); - m_clustbinlo.push_back(cluster->getTBinLo()); - m_clustbinhi.push_back(cluster->getTBinHi()); - m_cluspadphase.push_back(cluster->getPadPhase()); - m_clustbinphase.push_back(cluster->getTBinPhase()); if (Verbosity() > 1) { @@ -1569,7 +1453,7 @@ void TrackResiduals::fillClusterBranchesSeeds(TrkrDefs::cluskey ckey, // SvtxTr auto misaligncenter = surf->center(geometry->geometry().getGeoContext()); auto misalignnorm = -1 * surf->normal(geometry->geometry().getGeoContext(), Acts::Vector3(1, 1, 1), Acts::Vector3(1, 1, 1)); - auto misrot = surf->localtoGlobalTransform(geometry->geometry().getGeoContext()).rotation(); + auto misrot = surf->localToGlobalTransform(geometry->geometry().getGeoContext()).rotation(); float mgamma = atan2(-misrot(1, 0), misrot(0, 0)); float mbeta = -asin(misrot(0, 1)); @@ -1580,8 +1464,8 @@ void TrackResiduals::fillClusterBranchesSeeds(TrkrDefs::cluskey ckey, // SvtxTr auto idealcenter = surf->center(geometry->geometry().getGeoContext()); auto idealnorm = -1 * surf->normal(geometry->geometry().getGeoContext(), Acts::Vector3(1, 1, 1), Acts::Vector3(1, 1, 1)); Acts::Vector3 ideal_local(loc.x(), loc.y(), 0.0); - Acts::Vector3 ideal_glob = surf->localtoGlobalTransform(geometry->geometry().getGeoContext()) * (ideal_local * Acts::UnitConstants::cm); - auto idealrot = surf->localtoGlobalTransform(geometry->geometry().getGeoContext()).rotation(); + Acts::Vector3 ideal_glob = surf->localToGlobalTransform(geometry->geometry().getGeoContext()) * (ideal_local * Acts::UnitConstants::cm); + auto idealrot = surf->localToGlobalTransform(geometry->geometry().getGeoContext()).rotation(); //! These calculations are taken from the wikipedia page for Euler angles, //! under the Tait-Bryan angle explanation. Formulas for the angles @@ -1668,7 +1552,7 @@ void TrackResiduals::fillStatesWithCircleFit(const TrkrDefs::cluskey& key, } else { - auto local = (surf->localtoGlobalTransform(geometry->geometry().getGeoContext())).inverse() * (intersection * Acts::UnitConstants::cm); + auto local = (surf->localToGlobalTransform(geometry->geometry().getGeoContext())).inverse() * (intersection * Acts::UnitConstants::cm); local /= Acts::UnitConstants::cm; m_statelx.push_back(local.x()); m_statelz.push_back(local.y()); @@ -1695,7 +1579,7 @@ void TrackResiduals::fillStatesWithLineFit(const TrkrDefs::cluskey& key, } else { - Acts::Vector3 loct = surf->localtoGlobalTransform(geometry->geometry().getGeoContext()).inverse() * (intersection * Acts::UnitConstants::cm); + Acts::Vector3 loct = surf->localToGlobalTransform(geometry->geometry().getGeoContext()).inverse() * (intersection * Acts::UnitConstants::cm); loct /= Acts::UnitConstants::cm; m_statelx.push_back(loct(0)); m_statelz.push_back(loct(1)); @@ -1723,7 +1607,6 @@ void TrackResiduals::createBranches() m_eventtree->Branch("run", &m_runnumber, "m_runnumber/I"); m_eventtree->Branch("segment", &m_segment, "m_segment/I"); m_eventtree->Branch("event", &m_event, "m_event/I"); - m_eventtree->Branch("evt_id", &m_evt_id, "m_evt_id/I"); m_eventtree->Branch("gl1bco", &m_bco, "m_bco/I"); m_eventtree->Branch("nmvtx", &m_nmvtx_all, "m_nmvtx_all/I"); m_eventtree->Branch("nintt", &m_nintt_all, "m_nintt_all/I"); @@ -1744,7 +1627,6 @@ void TrackResiduals::createBranches() m_failedfits->Branch("segment", &m_segment, "m_segment/I"); m_failedfits->Branch("trackid", &m_trackid, "m_trackid/I"); m_failedfits->Branch("event", &m_event, "m_event/I"); - m_failedfits->Branch("evt_id", &m_evt_id, "m_evt_id/I"); m_failedfits->Branch("silseedx", &m_silseedx, "m_silseedx/F"); m_failedfits->Branch("silseedy", &m_silseedy, "m_silseedy/F"); m_failedfits->Branch("silseedz", &m_silseedz, "m_silseedz/F"); @@ -1771,7 +1653,6 @@ void TrackResiduals::createBranches() m_vertextree->Branch("run", &m_runnumber, "m_runnumber/I"); m_vertextree->Branch("segment", &m_segment, "m_segment/I"); m_vertextree->Branch("event", &m_event, "m_event/I"); - m_vertextree->Branch("evt_id", &m_evt_id, "m_evt_id/I"); m_vertextree->Branch("firedTriggers", &m_firedTriggers); m_vertextree->Branch("gl1BunchCrossing", &m_gl1BunchCrossing, "m_gl1BunchCrossing/l"); m_vertextree->Branch("gl1bco", &m_bco, "m_bco/l"); @@ -1794,7 +1675,6 @@ void TrackResiduals::createBranches() m_hittree->Branch("run", &m_runnumber, "m_runnumber/I"); m_hittree->Branch("segment", &m_segment, "m_segment/I"); m_hittree->Branch("event", &m_event, "m_event/I"); - m_hittree->Branch("evt_id", &m_evt_id, "m_evt_id/I"); m_hittree->Branch("gl1bco", &m_bco, "m_bco/l"); m_hittree->Branch("hitsetkey", &m_hitsetkey, "m_hitsetkey/i"); m_hittree->Branch("gx", &m_hitgx, "m_hitgx/F"); @@ -1824,7 +1704,6 @@ void TrackResiduals::createBranches() m_clustree->Branch("run", &m_runnumber, "m_runnumber/I"); m_clustree->Branch("segment", &m_segment, "m_segment/I"); m_clustree->Branch("event", &m_event, "m_event/I"); - m_clustree->Branch("evt_id", &m_evt_id, "m_evt_id/I"); m_clustree->Branch("gl1bco", &m_bco, "m_bco/l"); m_clustree->Branch("lx", &m_scluslx, "m_scluslx/F"); m_clustree->Branch("lz", &m_scluslz, "m_scluslz/F"); @@ -1834,37 +1713,11 @@ void TrackResiduals::createBranches() m_clustree->Branch("phi", &m_sclusphi, "m_sclusphi/F"); m_clustree->Branch("eta", &m_scluseta, "m_scluseta/F"); m_clustree->Branch("adc", &m_adc, "m_adc/F"); - m_clustree->Branch("size", &m_size, "m_size/I"); m_clustree->Branch("phisize", &m_phisize, "m_phisize/I"); m_clustree->Branch("zsize", &m_zsize, "m_zsize/I"); - m_clustree->Branch("phibinlo", &m_phibinlo, "m_phibinlo/F"); - m_clustree->Branch("phibinhi", &m_phibinhi, "m_phibinhi/F"); - m_clustree->Branch("tbinlo", &m_tbinlo, "m_tbinlo/F"); - m_clustree->Branch("tbinhi", &m_tbinhi, "m_tbinhi/F"); - m_clustree->Branch("padphase", &m_padphase, "m_padphase/F"); - m_clustree->Branch("tbinphase", &m_tbinphase, "m_tbinphase/F"); - m_clustree->Branch("overlap", &m_overlap, "m_overlap/I"); - m_clustree->Branch("nedge", &m_nedge, "m_nedge/I"); - m_clustree->Branch("sledge", &m_sledge, "m_sledge/I"); - m_clustree->Branch("sredge", &m_sredge, "m_sredge/I"); - m_clustree->Branch("tledge", &m_tledge, "m_tledge/I"); - m_clustree->Branch("tredge", &m_tredge, "m_tredge/I"); - m_clustree->Branch("dledge", &m_dledge, "m_dledge/I"); - m_clustree->Branch("dredge", &m_dredge, "m_dredge/I"); - m_clustree->Branch("hledge", &m_hledge, "m_hledge/I"); - m_clustree->Branch("hredge", &m_hredge, "m_hredge/I"); - m_clustree->Branch("slmix", &m_slmix, "m_slmix/I"); - m_clustree->Branch("srmix", &m_srmix, "m_srmix/I"); - m_clustree->Branch("tlmix", &m_tlmix, "m_tlmix/I"); - m_clustree->Branch("trmix", &m_trmix, "m_trmix/I"); m_clustree->Branch("erphi", &m_scluselx, "m_scluselx/F"); m_clustree->Branch("ez", &m_scluselz, "m_scluselz/F"); m_clustree->Branch("maxadc", &m_clusmaxadc, "m_clusmaxadc/F"); - m_clustree->Branch("cenadc", &m_cluscenadc, "m_cluscenadc/F"); - m_clustree->Branch("padcen", &m_padcen, "m_padcen/F"); - m_clustree->Branch("tbincen", &m_tbincen, "m_tbincen/F"); - m_clustree->Branch("padmax", &m_padmax, "m_padmax/F"); - m_clustree->Branch("tbinmax", &m_tbinmax, "m_tbinmax/F"); m_clustree->Branch("sector", &m_clussector, "m_clussector/I"); m_clustree->Branch("side", &m_side, "m_side/I"); m_clustree->Branch("stave", &m_staveid, "m_staveid/I"); @@ -1881,7 +1734,6 @@ void TrackResiduals::createBranches() m_tree->Branch("run", &m_runnumber, "m_runnumber/I"); m_tree->Branch("segment", &m_segment, "m_segment/I"); m_tree->Branch("event", &m_event, "m_event/I"); - m_tree->Branch("evt_id", &m_evt_id, "m_evt_id/I"); m_tree->Branch("mbdcharge",&m_totalmbd, "m_totalmbd/F"); m_tree->Branch("mbdzvtx", &m_mbdvtxz, "m_mbdvtxz/F"); m_tree->Branch("firedTriggers", &m_firedTriggers); @@ -1963,27 +1815,7 @@ void TrackResiduals::createBranches() m_tree->Branch("clusside", &m_clside); m_tree->Branch("cluskeys", &m_cluskeys); m_tree->Branch("clusedge", &m_clusedge); - m_tree->Branch("clussledge", &m_clussledge); - m_tree->Branch("clussredge", &m_clussredge); - m_tree->Branch("clustledge", &m_clustledge); - m_tree->Branch("clustredge", &m_clustredge); - m_tree->Branch("clusdledge", &m_clusdledge); - m_tree->Branch("clusdredge", &m_clusdredge); - m_tree->Branch("clushledge", &m_clushledge); - m_tree->Branch("clushredge", &m_clushredge); - m_tree->Branch("clusslmix", &m_clusslmix); - m_tree->Branch("clussrmix", &m_clussrmix); - m_tree->Branch("clustlmix", &m_clustlmix); - m_tree->Branch("clustrmix", &m_clustrmix); m_tree->Branch("clusoverlap", &m_clusoverlap); - m_tree->Branch("clusphibinlo", &m_clusphibinlo); - m_tree->Branch("clusphibinhi", &m_clusphibinhi); - m_tree->Branch("clustbinlo", &m_clustbinlo); - m_tree->Branch("clustbinhi", &m_clustbinhi); - m_tree->Branch("clusPadCen", &m_clusPadCen); - m_tree->Branch("clusTBinCen", &m_clusTBinCen); - m_tree->Branch("clusPadMax", &m_clusPadMax); - m_tree->Branch("clusTBinMax", &m_clusTBinMax); m_tree->Branch("cluslx", &m_cluslx); m_tree->Branch("cluslz", &m_cluslz); m_tree->Branch("cluselx", &m_cluselx); @@ -1992,8 +1824,6 @@ void TrackResiduals::createBranches() m_tree->Branch("clusgy", &m_clusgy); m_tree->Branch("clusgz", &m_clusgz); m_tree->Branch("clusgr", &m_clusgr); - m_tree->Branch("cluspadphase", &m_cluspadphase); - m_tree->Branch("clustbinphase", &m_clustbinphase); if (m_doAlignment) { m_tree->Branch("clusgxunmoved", &m_clusgxunmoved); @@ -2002,8 +1832,6 @@ void TrackResiduals::createBranches() } m_tree->Branch("clusAdc", &m_clusAdc); m_tree->Branch("clusMaxAdc", &m_clusMaxAdc); - m_tree->Branch("clusCenAdc", &m_clusCenAdc); - m_tree->Branch("clussize", &m_clussize); m_tree->Branch("clusphisize", &m_clusphisize); m_tree->Branch("cluszsize", &m_cluszsize); @@ -2407,7 +2235,6 @@ void TrackResiduals::fillEventTree(PHCompositeNode* topNode) if (Verbosity() > 1) { std::cout << " m_event:" << m_event << std::endl; - std::cout << " m_evt_id:" << m_evt_id << std::endl; std::cout << " m_ntpc_clus0:" << m_ntpc_clus0 << std::endl; std::cout << " m_ntpc_clus1: " << m_ntpc_clus1 << std::endl; std::cout << " m_nmvtx_all:" << m_nmvtx_all << std::endl; diff --git a/offline/packages/TrackingDiagnostics/TrackResiduals.h b/offline/packages/TrackingDiagnostics/TrackResiduals.h index 6601fc47c9..7e789faba5 100644 --- a/offline/packages/TrackingDiagnostics/TrackResiduals.h +++ b/offline/packages/TrackingDiagnostics/TrackResiduals.h @@ -128,7 +128,6 @@ class TrackResiduals : public SubsysReco bool m_doMicromegasOnly = false; int m_event = 0; - int m_evt_id = -1; int m_segment = std::numeric_limits::quiet_NaN(); int m_runnumber = std::numeric_limits::quiet_NaN(); int m_ntpcclus = std::numeric_limits::quiet_NaN(); @@ -247,34 +246,8 @@ class TrackResiduals : public SubsysReco float m_scluseta = std::numeric_limits::quiet_NaN(); float m_adc = std::numeric_limits::quiet_NaN(); float m_clusmaxadc = std::numeric_limits::quiet_NaN(); - float m_cluscenadc = std::numeric_limits::quiet_NaN(); - int m_size = std::numeric_limits::quiet_NaN(); int m_phisize = std::numeric_limits::quiet_NaN(); int m_zsize = std::numeric_limits::quiet_NaN(); - int m_overlap = std::numeric_limits::quiet_NaN(); - int m_nedge = std::numeric_limits::quiet_NaN(); - int m_sledge = std::numeric_limits::quiet_NaN(); - int m_sredge = std::numeric_limits::quiet_NaN(); - int m_tledge = std::numeric_limits::quiet_NaN(); - int m_tredge = std::numeric_limits::quiet_NaN(); - int m_dledge = std::numeric_limits::quiet_NaN(); - int m_dredge = std::numeric_limits::quiet_NaN(); - int m_hledge = std::numeric_limits::quiet_NaN(); - int m_hredge = std::numeric_limits::quiet_NaN(); - int m_slmix = std::numeric_limits::quiet_NaN(); - int m_srmix = std::numeric_limits::quiet_NaN(); - int m_tlmix = std::numeric_limits::quiet_NaN(); - int m_trmix = std::numeric_limits::quiet_NaN(); - float m_phibinlo = std::numeric_limits::quiet_NaN(); - float m_phibinhi = std::numeric_limits::quiet_NaN(); - float m_tbinlo = std::numeric_limits::quiet_NaN(); - float m_tbinhi = std::numeric_limits::quiet_NaN(); - float m_padphase = std::numeric_limits::quiet_NaN(); - float m_tbinphase = std::numeric_limits::quiet_NaN(); - float m_padcen = std::numeric_limits::quiet_NaN(); - float m_tbincen = std::numeric_limits::quiet_NaN(); - float m_padmax = std::numeric_limits::quiet_NaN(); - float m_tbinmax = std::numeric_limits::quiet_NaN(); float m_scluslx = std::numeric_limits::quiet_NaN(); float m_scluslz = std::numeric_limits::quiet_NaN(); float m_sclusgx = std::numeric_limits::quiet_NaN(); @@ -297,11 +270,6 @@ class TrackResiduals : public SubsysReco //! clusters on track information std::vector m_clusAdc; std::vector m_clusMaxAdc; - std::vector m_clusCenAdc; - std::vector m_clusPadCen; - std::vector m_clusTBinCen; - std::vector m_clusPadMax; - std::vector m_clusTBinMax; std::vector m_cluslx; std::vector m_cluslz; std::vector m_cluselx; @@ -320,29 +288,10 @@ class TrackResiduals : public SubsysReco std::vector m_clsector; std::vector m_clside; std::vector m_cluslayer; - std::vector m_clussize; std::vector m_clusphisize; std::vector m_cluszsize; - std::vector m_clusoverlap; std::vector m_clusedge; - std::vector m_clussledge; - std::vector m_clussredge; - std::vector m_clustledge; - std::vector m_clustredge; - std::vector m_clusdledge; - std::vector m_clusdredge; - std::vector m_clushledge; - std::vector m_clushredge; - std::vector m_clusslmix; - std::vector m_clussrmix; - std::vector m_clustlmix; - std::vector m_clustrmix; - std::vector m_clusphibinlo; - std::vector m_clusphibinhi; - std::vector m_clustbinlo; - std::vector m_clustbinhi; - std::vector m_cluspadphase; - std::vector m_clustbinphase; + std::vector m_clusoverlap; std::vector m_cluskeys; std::vector m_idealsurfcenterx; std::vector m_idealsurfcentery; diff --git a/offline/packages/TrackingDiagnostics/TrkrNtuplizer.cc b/offline/packages/TrackingDiagnostics/TrkrNtuplizer.cc index 1c90c4688c..d5fddf6538 100644 --- a/offline/packages/TrackingDiagnostics/TrkrNtuplizer.cc +++ b/offline/packages/TrackingDiagnostics/TrkrNtuplizer.cc @@ -289,11 +289,6 @@ enum n_cluster // NOLINT(readability-enum-initial-value, performance-enum-size) nclue, ncluadc, nclumaxadc, - nclucenadc, - nclupadcen, - nclutbincen, - nclupadmax, - nclutbinmax, ncluthick, ncluafac, nclubfac, @@ -306,25 +301,7 @@ enum n_cluster // NOLINT(readability-enum-initial-value, performance-enum-size) ncluzsize, nclupedge, ncluredge, - nclusledge, - nclusredge, - nclutledge, - nclutredge, - ncludledge, - ncludredge, - ncluhledge, - ncluhredge, - ncluslmix, - nclusrmix, - nclutlmix, - nclutrmix, ncluovlp, - ncluphibinlo, - ncluphibinhi, - nclutbinlo, - nclutbinhi, - nclupadphase, - nclutbinphase, nclutrackID, ncluniter, clusize = ncluniter + 1 @@ -360,7 +337,7 @@ int TrkrNtuplizer::Init(PHCompositeNode* /*unused*/) std::string str_vertex = {"vertexID:vx:vy:vz:ntracks:chi2:ndof"}; std::string str_event = {"event:seed:run:seg:job"}; std::string str_hit = {"hitID:e:adc:layer:phielem:zelem:cellID:ecell:phibin:zbin:tbin:phi:r:x:y:z"}; - std::string str_cluster = {"locx:locy:x:y:z:r:phi:eta:theta:phibin:tbin:fee:chan:sampa:ex:ey:ez:ephi:pez:pephi:e:adc:maxadc:cenadc:padcen:tbincen:padmax:tbinmax:thick:afac:bfac:dcal:layer:phielem:zelem:size:phisize:zsize:pedge:redge:sledge:sredge:tledge:tredge:dledge:dredge:hledge:hredge:slmix:srmix:tlmix:trmix:ovlp:phibinlo:phibinhi:tbinlo:tbinhi:padphase:tbinphase:trackID:niter"}; + std::string str_cluster = {"locx:locy:x:y:z:r:phi:eta:theta:phibin:tbin:fee:chan:sampa:ex:ey:ez:ephi:pez:pephi:e:adc:maxadc:thick:afac:bfac:dcal:layer:phielem:zelem:size:phisize:zsize:pedge:redge:ovlp:trackID:niter"}; std::string str_seed = {"seedID:siter:spt:sptot:seta:sphi:syxint:srzint:sxyslope:srzslope:sX0:sY0:sdZ0:sR0:scharge:sdedx:spidedx:skdedx:sprdedx:sn1pix:snsil:sntpc:snhits"}; std::string str_residual = {"alpha:beta:resphio:resphi:resz"}; std::string str_track = {"trackID:crossing:px:py:pz:pt:eta:phi:deltapt:deltaeta:deltaphi:charge:quality:chisq:ndf:nhits:nmaps:nintt:ntpc:nmms:ntpc1:ntpc11:ntpc2:ntpc3:dedx:pidedx:kdedx:prdedx:vertexID:vx:vy:vz:dca2d:dca2dsigma:dca3dxy:dca3dxysigma:dca3dz:dca3dzsigma:pcax:pcay:pcaz:hlxpt:hlxeta:hlxphi:hlxX0:hlxY0:hlxZ0:hlxcharge"}; @@ -1409,7 +1386,7 @@ void TrkrNtuplizer::fillOutputNtuples(PHCompositeNode* topNode) } //----------------------- - // fill the Vertex NTuple and fixed NaN placeholders + // fill the Vertex NTuple and fixed NaN placeholders //----------------------- bool doit = true; if (_ntp_vertex && doit) @@ -1432,7 +1409,8 @@ void TrkrNtuplizer::fillOutputNtuples(PHCompositeNode* topNode) for (auto & iter : *vertexmap) { SvtxVertex* vertex = iter.second; - if (!vertex) { continue; } + if (!vertex) { continue; +} float fx_vertex[n_vertex::vtxsize]; for (float& i : fx_vertex) @@ -1475,6 +1453,8 @@ void TrkrNtuplizer::fillOutputNtuples(PHCompositeNode* topNode) _timer->stop(); std::cout << "vertex time: " << _timer->get_accumulated_time() / 1000. << " sec" << std::endl; } + + //-------------------- // fill the Hit NTuple //-------------------- @@ -2304,11 +2284,6 @@ void TrkrNtuplizer::FillCluster(float fXcluster[n_cluster::clusize], TrkrDefs::c fXcluster[n_cluster::nclue] = cluster->getAdc(); fXcluster[n_cluster::ncluadc] = cluster->getAdc(); fXcluster[n_cluster::nclumaxadc] = cluster->getMaxAdc(); - fXcluster[n_cluster::nclucenadc] = cluster->getCenAdc(); - fXcluster[n_cluster::nclupadcen] = cluster->getPadCen(); - fXcluster[n_cluster::nclutbincen] = cluster->getTBinCen(); - fXcluster[n_cluster::nclupadmax] = cluster->getPadMax(); - fXcluster[n_cluster::nclutbinmax] = cluster->getTBinMax(); fXcluster[n_cluster::nclulayer] = layer_local; if (layer_local < 3) @@ -2336,7 +2311,7 @@ void TrkrNtuplizer::FillCluster(float fXcluster[n_cluster::clusize], TrkrDefs::c } } */ - fXcluster[n_cluster::nclusize] = cluster->getRSize(); + fXcluster[n_cluster::nclusize] = cluster->getSize(); fXcluster[n_cluster::ncluphisize] = cluster->getPhiSize(); fXcluster[n_cluster::ncluzsize] = cluster->getZSize(); fXcluster[n_cluster::nclupedge] = cluster->getEdge(); @@ -2346,25 +2321,8 @@ void TrkrNtuplizer::FillCluster(float fXcluster[n_cluster::clusize], TrkrDefs::c { fXcluster[n_cluster::ncluredge] = 1; } - fXcluster[n_cluster::nclusledge] = cluster->getSLEdge(); - fXcluster[n_cluster::nclusredge] = cluster->getSREdge(); - fXcluster[n_cluster::nclutledge] = cluster->getTLEdge(); - fXcluster[n_cluster::nclutredge] = cluster->getTREdge(); - fXcluster[n_cluster::ncludledge] = cluster->getDLEdge(); - fXcluster[n_cluster::ncludredge] = cluster->getDREdge(); - fXcluster[n_cluster::ncluhledge] = cluster->getHLEdge(); - fXcluster[n_cluster::ncluhredge] = cluster->getHREdge(); - fXcluster[n_cluster::ncluslmix] = cluster->getSLMix(); - fXcluster[n_cluster::nclusrmix] = cluster->getSRMix(); - fXcluster[n_cluster::nclutlmix] = cluster->getTLMix(); - fXcluster[n_cluster::nclutrmix] = cluster->getTRMix(); - fXcluster[n_cluster::ncluovlp] = cluster->getOverlap(); - fXcluster[n_cluster::ncluphibinlo] = cluster->getPhiBinLo(); - fXcluster[n_cluster::ncluphibinhi] = cluster->getPhiBinHi(); - fXcluster[n_cluster::nclutbinlo] = cluster->getTBinLo(); - fXcluster[n_cluster::nclutbinhi] = cluster->getTBinHi(); - fXcluster[n_cluster::nclupadphase] = cluster->getPadPhase(); - fXcluster[n_cluster::nclutbinphase] = cluster->getTBinPhase(); + + fXcluster[n_cluster::ncluovlp] = 3; // cluster->getOvlp(); fXcluster[n_cluster::nclutrackID] = std::numeric_limits::quiet_NaN(); fXcluster[n_cluster::ncluniter] = 0; diff --git a/offline/packages/tpc/TpcClusterizer.cc b/offline/packages/tpc/TpcClusterizer.cc index 7ccd9ba40f..687d5b58f9 100644 --- a/offline/packages/tpc/TpcClusterizer.cc +++ b/offline/packages/tpc/TpcClusterizer.cc @@ -16,7 +16,6 @@ #include #include #include -#include #include // for hitkey, getLayer #include #include @@ -85,36 +84,6 @@ namespace unsigned short edge = 0; }; - struct ClusterCounters - { - int overlap = 0; - - int nedge = 0; // Total No. of Edges - - int sledge = 0; // Touching Left Sector Edge - int sredge = 0; // Touching Right Sector Edge - - int tledge = 0; // Touching Left Time Edge - int tredge = 0; // Touching Right Time Edge - - int dledge = 0; // Touching Left Dead Edge - int dredge = 0; // Touching Right Dead Edge - - int hledge = 0; // Touching Left Hot Edge - int hredge = 0; // Touching Right Hot Edge - - int slmix = 0; // Touching Cluster at Left in Phibin - int srmix = 0; // Touching Cluster at Right in Phibin - - int tlmix = 0; // Touching Cluster at Left in Timebin - int trmix = 0; // Touching Cluster at Right in Timebin - - void clear() - { - *this = ClusterCounters{}; - } - }; - using vec_dVerbose = std::vector>>; // Neural network parameters and modules @@ -207,14 +176,13 @@ namespace } } - void find_t_range(int phibin, int tbin, const thread_data &my_data, const std::vector> &adcval, int &tdown, int &tup, ClusterCounters &counts, bool &ttop_edge, bool &tbottom_edge) + void find_t_range(int phibin, int tbin, const thread_data &my_data, const std::vector> &adcval, int &tdown, int &tup, int &touch, int &edge) { const int FitRangeT = (int) my_data.maxHalfSizeT; const int NTBinsMax = (int) my_data.tbins; - // const int FixedWindow = (int) my_data.FixedWindow; + const int FixedWindow = (int) my_data.FixedWindow; tup = 0; tdown = 0; - /* if (FixedWindow != 0) { tup = FixedWindow; @@ -222,16 +190,15 @@ namespace if (tbin + tup >= NTBinsMax) { tup = NTBinsMax - tbin - 1; - counts.nedge++; + edge++; } if ((tbin - tdown) <= 0) { tdown = tbin; - counts.edge++; + edge++; } return; } - */ for (int it = 0; it < FitRangeT; it++) { int ct = tbin + it; @@ -239,12 +206,7 @@ namespace if (ct <= 0 || ct >= NTBinsMax) { // tup = it; - if (!ttop_edge) - { - counts.nedge++; - counts.tredge = 1; - ttop_edge = true; - } + edge++; break; // truncate edge } @@ -254,7 +216,7 @@ namespace } if (adcval[phibin][ct] == USHRT_MAX) { - counts.overlap++; + touch++; break; } if (my_data.do_split) @@ -266,7 +228,7 @@ namespace adcval[phibin][ct + 2] + adcval[phibin][ct + 3]) { // rising again tup = it + 1; - counts.overlap++; + touch++; break; } } @@ -279,12 +241,7 @@ namespace if (ct <= 0 || ct >= NTBinsMax) { // tdown = it; - if (!tbottom_edge) - { - counts.nedge++; - counts.tledge = 1; - tbottom_edge = true; - } + edge++; break; // truncate edge } if (adcval[phibin][ct] <= 0) @@ -293,7 +250,7 @@ namespace } if (adcval[phibin][ct] == USHRT_MAX) { - counts.overlap++; + touch++; break; } if (my_data.do_split) @@ -304,7 +261,7 @@ namespace adcval[phibin][ct - 2] + adcval[phibin][ct - 3]) { // rising again tdown = it + 1; - counts.overlap++; + touch++; break; } } @@ -314,14 +271,13 @@ namespace return; } - void find_phi_range(int phibin, int tbin, const thread_data &my_data, const std::vector> &adcval, int &phidown, int &phiup, ClusterCounters &counts, bool &phitop_edge, bool &phibottom_edge) + void find_phi_range(int phibin, int tbin, const thread_data &my_data, const std::vector> &adcval, int &phidown, int &phiup, int &touch, int &edge) { int FitRangePHI = (int) my_data.maxHalfSizePhi; int NPhiBinsMax = (int) my_data.phibins; - // const int FixedWindow = (int) my_data.FixedWindow; + const int FixedWindow = (int) my_data.FixedWindow; phidown = 0; phiup = 0; - /* if (FixedWindow != 0) { phiup = FixedWindow; @@ -338,19 +294,13 @@ namespace } return; } - */ for (int iphi = 0; iphi < FitRangePHI; iphi++) { int cphi = phibin + iphi; if (cphi < 0 || cphi >= NPhiBinsMax) { // phiup = iphi; - if (!phitop_edge) - { - counts.nedge++; - counts.sredge = 1; - phitop_edge = true; - } + edge++; break; // truncate edge } @@ -362,7 +312,7 @@ namespace } if (adcval[cphi][tbin] == USHRT_MAX) { - counts.overlap++; + touch++; break; } if (my_data.do_split) @@ -373,7 +323,7 @@ namespace adcval[cphi + 2][tbin] + adcval[cphi + 3][tbin]) { // rising again phiup = iphi + 1; - counts.overlap++; + touch++; break; } } @@ -387,12 +337,7 @@ namespace if (cphi < 0 || cphi >= NPhiBinsMax) { // phidown = iphi; - if (!phibottom_edge) - { - counts.nedge++; - counts.sledge = 1; - phibottom_edge = true; - } + edge++; break; // truncate edge } @@ -403,7 +348,7 @@ namespace } if (adcval[cphi][tbin] == USHRT_MAX) { - counts.overlap++; + touch++; break; } if (my_data.do_split) @@ -414,7 +359,7 @@ namespace adcval[cphi - 2][tbin] + adcval[cphi - 3][tbin]) { // rising again phidown = iphi + 1; - counts.overlap++; + touch++; break; } } @@ -424,60 +369,6 @@ namespace return; } - void check_cluster_touching(const std::vector& ihit_list, const std::vector>& adcval, int phibins, int tbins, ClusterCounters &counts) - { - // Encode (iphi, it) into single integer for fast lookup - std::unordered_set cluster_hits; - cluster_hits.reserve(ihit_list.size()); - - auto encode = [tbins](int phi, int t) - { - return phi * tbins + t; - }; - - for (const auto &hit : ihit_list) - { - cluster_hits.insert(encode(hit.iphi, hit.it)); - } - - for (auto &hit : ihit_list) - { - int iphi = hit.iphi; - int it = hit.it; - - for (int dphi = -1; dphi <= 1; ++dphi) - { - for (int dt = -1; dt <= 1; ++dt) - { - if (dphi == 0 && dt == 0) continue; - - int nphi = iphi + dphi; - int nt = it + dt; - - if (nphi < 0 || nphi >= phibins || - nt < 0 || nt >= tbins) - continue; - - // skip same cluster - if (cluster_hits.count(encode(nphi, nt))) continue; - - // neighbor has signal → touching - if (adcval[nphi][nt] > 0 && - adcval[nphi][nt] != USHRT_MAX) - { - // Check Phi - if (dphi == -1) counts.slmix = 1; - if (dphi == 1) counts.srmix = 1; - - // Check Time - if (dt == -1) counts.tlmix = 1; - if (dt == 1) counts.trmix = 1; - } - } - } - } - } - int is_hit_isolated(int iphi, int it, int NPhiBinsMax, int NTBinsMax, const std::vector> &adcval) { // check isolated hits @@ -535,25 +426,20 @@ namespace return isiso; } - void get_cluster(int phibin, int tbin, const thread_data &my_data, const std::vector> &adcval, std::vector &ihit_list, ClusterCounters &counts) + void get_cluster(int phibin, int tbin, const thread_data &my_data, const std::vector> &adcval, std::vector &ihit_list, int &touch, int &edge) { - bool ttop_edge = false; - bool tbottom_edge = false; - bool phitop_edge = false; - bool phibottom_edge = false; - // search along phi at the peak in t // const int NPhiBinsMax = (int) my_data.phibins; // const int NTBinsMax = (int) my_data.tbins; int tup = 0; int tdown = 0; - find_t_range(phibin, tbin, my_data, adcval, tdown, tup, counts, ttop_edge, tbottom_edge); + find_t_range(phibin, tbin, my_data, adcval, tdown, tup, touch, edge); // now we have the t extent of the cluster, go find the phi edges for (int it = tbin - tdown; it <= (tbin + tup); it++) { int phiup = 0; int phidown = 0; - find_phi_range(phibin, it, my_data, adcval, phidown, phiup, counts, phitop_edge, phibottom_edge); + find_phi_range(phibin, it, my_data, adcval, phidown, phiup, touch, edge); for (int iphi = (phibin - phidown); iphi <= (phibin + phiup); iphi++) { if (adcval[iphi][it] > 0 && adcval[iphi][it] != USHRT_MAX) @@ -570,7 +456,7 @@ namespace hit.it = it; hit.adc = adcval[iphi][it]; - if (counts.overlap > 0) + if (touch > 0) { if ((iphi == (phibin - phidown)) || (iphi == (phibin + phiup))) @@ -586,7 +472,7 @@ namespace } void calc_cluster_parameter(const int iphi_center, const int it_center, - const std::vector &ihit_list, thread_data &my_data, ClusterCounters counts) + const std::vector &ihit_list, thread_data &my_data, int ntouch, int nedge) { // // get z range from layer geometry @@ -602,8 +488,6 @@ namespace double iphi_sum = 0.0; double iphi2_sum = 0.0; - double it_sum = 0.0; - double radius = my_data.layergeom->get_radius(); // returns center of layer int phibinhi = -1; @@ -613,12 +497,6 @@ namespace int clus_size = ihit_list.size(); int max_adc = 0; - int phibinmax = -1; - int tbinmax = -1; - double cen_adc = 0; - - int size = 0; - if (clus_size <= my_data.min_clus_size) { return; @@ -643,16 +521,14 @@ namespace training_hits->phistep = my_data.layergeom->get_phistep(); training_hits->zstep = my_data.layergeom->get_zstep() * my_data.tGeometry->get_drift_velocity(); training_hits->layer = my_data.layer; - training_hits->ntouch = counts.overlap; - training_hits->nedge = counts.nedge; + training_hits->ntouch = ntouch; + training_hits->nedge = nedge; training_hits->v_adc.fill(0); } // std::cout << "process list" << std::endl; std::vector hitkeyvec; - std::map, double> adc_map; - // keep track of the hit locations in a given cluster std::map m_phi{}; std::map m_z{}; @@ -668,18 +544,7 @@ namespace continue; } - size++; - - int adc_int = static_cast(std::round(adc)); - - if (adc_int > max_adc) - { - max_adc = adc_int; - phibinmax = iphi; - tbinmax = it; - } - - // max_adc = std::max(max_adc, static_cast(std::round(adc))); // preserves rounding (0.5 -> 1) + max_adc = std::max(max_adc, static_cast(std::round(adc))); // preserves rounding (0.5 -> 1) phibinhi = std::max(iphi, phibinhi); phibinlo = std::min(iphi, phibinlo); tbinhi = std::max(it, tbinhi); @@ -700,12 +565,8 @@ namespace t_sum += t * adc; t2_sum += square(t) * adc; - it_sum += it * adc; - adc_sum += adc; - adc_map[{iphi, it}] += adc; - if (my_data.fillClusHitsVerbose) { auto pnew = m_phi.try_emplace(iphi, adc); @@ -762,15 +623,13 @@ namespace left_pad >= my_data.phioffset && deadset.contains(TpcDefs::genHitKey(left_pad, 0))) { - counts.nedge++; - counts.dledge = 1; + nedge++; } if (right_pad < (my_data.phibins + my_data.phioffset) && deadset.contains(TpcDefs::genHitKey(right_pad, 0))) { - counts.nedge++; - counts.dredge = 1; + nedge++; } } } @@ -787,62 +646,24 @@ namespace left_pad >= my_data.phioffset && hotset.contains(TpcDefs::genHitKey(left_pad, 0))) { - counts.nedge++; - counts.hledge = 1; + nedge++; } if (right_pad < (my_data.phibins + my_data.phioffset) && hotset.contains(TpcDefs::genHitKey(right_pad, 0))) { - counts.nedge++; - counts.hredge = 1; + nedge++; } } } - // This is local position - double clusiphi = iphi_sum / adc_sum; - double clusit = it_sum / adc_sum; - // This is the global position + double clusiphi = iphi_sum / adc_sum; double clusphi = my_data.layergeom->get_phi(clusiphi, my_data.side); - double clust = t_sum / adc_sum; - - // ADC of centroid bin - int iphi_centroid = static_cast(std::floor(clusiphi)); - int it_centroid = static_cast(std::floor(clusit)); - - auto it_cent = adc_map.find({iphi_centroid, it_centroid}); - if (it_cent != adc_map.end()) - { - cen_adc = it_cent->second; - } - else - { - cen_adc = 0.0; // centroid may not land on a real hit - } - - // Max ADC position in global coordinates - double maxphi = my_data.layergeom->get_phi(phibinmax, my_data.side); - double maxt = my_data.layergeom->get_zcenter(tbinmax); - - // Phase relative to max ADC position - double padphase = 0.0; - double tbinphase = 0.0; - - if (my_data.layergeom->get_phistep() > 0) - { - padphase = (clusphi - maxphi) / my_data.layergeom->get_phistep(); - } - - if (my_data.layergeom->get_zstep() > 0) - { - tbinphase = (clust - maxt) / my_data.layergeom->get_zstep(); - } double clusx = radius * cos(clusphi); double clusy = radius * sin(clusphi); - + double clust = t_sum / adc_sum; // needed for surface identification double zdriftlength = clust * my_data.tGeometry->get_drift_velocity(); // convert z drift length to z position in the TPC @@ -881,7 +702,6 @@ namespace char tsize = tbinhi - tbinlo + 1; char phisize = phibinhi - phibinlo + 1; - char rsize = size; // std::cout << "phisize: " << (int) phisize << " phibinhi " << phibinhi << " phibinlo " << phibinlo << std::endl; // phi_cov = (weighted mean of dphi^2) - (weighted mean of dphi)^2, which is essentially the weighted mean of dphi^2. The error is then: // e_phi = sigma_dphi/sqrt(N) = sqrt( sigma_dphi^2 / N ) -- where N is the number of samples of the distribution with standard deviation sigma_dphi @@ -894,7 +714,7 @@ namespace /// convert to Acts units global *= Acts::UnitConstants::cm; // std::cout << "transform" << std::endl; - Acts::Vector3 local = surface->localtoGlobalTransform(my_data.tGeometry->geometry().getGeoContext()).inverse() * global; + Acts::Vector3 local = surface->localToGlobalTransform(my_data.tGeometry->geometry().getGeoContext()).inverse() * global; local /= Acts::UnitConstants::cm; // std::cout << "done transform" << std::endl; // we need the cluster key and all associated hit keys (note: the cluster key includes the hitset key) @@ -906,45 +726,20 @@ namespace // std::cout << "clus num" << my_data.cluster_vector.size() << " X " << local(0) << " Y " << clust << std::endl; if (sqrt(phi_err_square) > my_data.min_err_squared) { - auto *clus = new TrkrClusterv6; - // auto *clus = new TrkrClusterv5; + auto *clus = new TrkrClusterv5; // auto clus = std::make_unique(); clus_base = clus; - clus->setLocalX(local(0)); - clus->setLocalY(clust); - clus->setSubSurfKey(subsurfkey); clus->setAdc(adc_sum); clus->setMaxAdc(max_adc); - clus->setCenAdc(cen_adc); - clus->setPadCen(clusiphi); - clus->setTBinCen(clusit); - clus->setPadMax(phibinmax); - clus->setTBinMax(tbinmax); - clus->setPhiError(sqrt(phi_err_square)); - clus->setZError(sqrt(t_err_square * pow(my_data.tGeometry->get_drift_velocity(), 2))); - clus->setRSize(rsize); + clus->setEdge(nedge); clus->setPhiSize(phisize); clus->setZSize(tsize); - clus->setOverlap(counts.overlap); - clus->setEdge(counts.nedge); - clus->setSLEdge(counts.sledge); - clus->setSREdge(counts.sredge); - clus->setTLEdge(counts.tledge); - clus->setTREdge(counts.tredge); - clus->setDLEdge(counts.dledge); - clus->setDREdge(counts.dredge); - clus->setHLEdge(counts.hledge); - clus->setHREdge(counts.hredge); - clus->setSLMix(counts.slmix); - clus->setSRMix(counts.srmix); - clus->setTLMix(counts.tlmix); - clus->setTRMix(counts.trmix); - clus->setPhiBinLo(phibinlo); - clus->setPhiBinHi(phibinhi); - clus->setTBinLo(tbinlo); - clus->setTBinHi(tbinhi); - clus->setPadPhase(padphase); - clus->setTBinPhase(tbinphase); + clus->setSubSurfKey(subsurfkey); + clus->setOverlap(ntouch); + clus->setLocalX(local(0)); + clus->setLocalY(clust); + clus->setPhiError(sqrt(phi_err_square)); + clus->setZError(sqrt(t_err_square * pow(my_data.tGeometry->get_drift_velocity(), 2))); my_data.cluster_vector.push_back(clus); b_made_cluster = true; } @@ -968,7 +763,7 @@ namespace double nn_y = radius * std::sin(nn_phi); Acts::Vector3 nn_global(nn_x, nn_y, nn_z); nn_global *= Acts::UnitConstants::cm; - Acts::Vector3 nn_local = surface->localtoGlobalTransform(my_data.tGeometry->geometry().geoContext).inverse() * nn_global; + Acts::Vector3 nn_local = surface->localToGlobalTransform(my_data.tGeometry->geometry().geoContext).inverse() * nn_global; nn_local /= Acts::UnitConstants::cm; double nn_t = my_data.m_tdriftmax - std::fabs(nn_z) / my_data.tGeometry->get_drift_velocity(); clus_base->setLocalX(nn_local(0)); @@ -1242,9 +1037,6 @@ namespace } } */ - - std::vector> adcval_orig = adcval; - // std::cout << "done filling " << std::endl; while (!all_hit_map.empty()) { @@ -1272,10 +1064,9 @@ namespace // start with highest adc hit // -> cluster around it and get vector of hits std::vector ihit_list; - // Setting all the counters - ClusterCounters counts; - - get_cluster(iphi, it, *my_data, adcval, ihit_list, counts); + int ntouch = 0; + int nedge = 0; + get_cluster(iphi, it, *my_data, adcval, ihit_list, ntouch, nedge); if (my_data->FixedWindow > 0) { @@ -1311,16 +1102,11 @@ namespace my_data->FixedWindow = 0; // reset hit list and try again without fixed window ihit_list.clear(); - // resetting all the counters - counts.clear(); - get_cluster(iphi, it, *my_data, adcval, ihit_list, counts); + get_cluster(iphi, it, *my_data, adcval, ihit_list, ntouch, nedge); // std::cout << " stepdown size after " << ihit_list.size() << std::endl; my_data->FixedWindow = window_cache; } } - - check_cluster_touching(ihit_list, adcval_orig, my_data->phibins, my_data->tbins, counts); - if (ihit_list.size() <= 1) { remove_hits(ihit_list, all_hit_map, adcval); @@ -1331,7 +1117,7 @@ namespace // -> add hits to truth association // remove hits from all_hit_map // repeat untill all_hit_map empty - calc_cluster_parameter(iphi, it, ihit_list, *my_data, counts); + calc_cluster_parameter(iphi, it, ihit_list, *my_data, ntouch, nedge); remove_hits(ihit_list, all_hit_map, adcval); ihit_list.clear(); } diff --git a/offline/packages/trackbase/.TrkrClusterv6.h.swn b/offline/packages/trackbase/.TrkrClusterv6.h.swn new file mode 100644 index 0000000000000000000000000000000000000000..f5452fabf6ab5429dd927ee0510b624086444169 GIT binary patch literal 16384 zcmeI3ON<;x8OJ+zhp?|BXP<+N*sM-P@zO_$l>$ zOXmA^^)XfXr!)0?)$b^efaBk0>ebKuD~~`Pfjk0v1o8;v5y&HuM<9)`v~MQ{~71{&Z5mo8UR{74QY{dC&$PxCCsl4juvb0tUYKR!w^eTm_GTi-3a#Fb`(I zK5*?Vn)WzY0n1=7`1+eQ?Q7tx;A!v#Fu@@(0bbpQI`9JUK?OVjZUH~N4LZT&U>&T1 zyTR|@q-nnc&jSx!0ycOAoCfa%uiT1wgD-;%K!69p`@mh`XGqLE1)c!gpbd2JSDf$H zz;*C*a21>b>!1Q?JbVcB|1h?rG1hj4#e5!|Db#J(2*#M(=AI`kj=C#=F^>nK=P*C8 zDitSea!;65TQo)B&qN|eE0s&3;6e2v z0PlU6^1TmM4;?cQt}`-9O(Qw(ST?C4_aX}=^R&vQLFXxKJ}jO&fD9oDSU zF*~A)rlTQdHMr z6=A_>Yvau(?wFhj2k$7=4U?`4)TiRGdQ3Qr#-<8HP!mqm*p!h_KhPz0lyNN<9pqR_ zGG%nhusSwdhLxC<#}veBt)Cl!#RDRZzjYng=*XL_n!4Hz`TrnD%JVNo8)E+#E; zb5g>CjCMp*MsX6mjN&{-M&o;MbV12NSeFOA)|Hk));ppp>s_XM?V)So2YMk#8|!b)HI5L{fD}P%HiG zD~fZI(mu%Lj!sgSiqdJ z5msae58_UVA2X~phH7dO_hHHP1wBU!xTvB=6Y6=sDLTDD`>uJ$E~?pwGhS8xnHfpf zRHDbN?Ad`!*@4?qU6ECZ&vR~T>xAbv3*){UdL~!XpE!>4!IX{Nh-wQhNwgA0sdr+> znQEAx^62^qLfP7)$5X%&*E-BIdYzV;w&DB9&`mVTSyM{y!A|hWwP7@dJ|6#U>A{C< z7q}TzDzWldUNl>-7bFc>Tt9&)Cv!cEdn|C75e*Eu30(ntssVoZtZTZL$b z>iU7ljpjk-`jAQ{yV-FxO(z30iMWHTExaJa{EAFtwrxdc>k}EP9mkGfYF0NwJBY(< z1+GUrvl2ZGO=`$mVa*n1McdJ$q0ueIDylwR4CUjP{*1F#1eL){AD1t4>*+R#Fss?_ zWru|=I;%7g4V-3!9#EngHmN<`=)I;vS3lH|#*frI!Ru^Y=`3foYWny%R$DZLlXxM1 z2QW3TLyNN+p@M!iRc0deIOknOa%pljB|1vsqNmDaW3(e2m8!STsX{w|VB?tUnv|G)8!2!jT0 zq^JCb;jokR+CH_b3!7uUzuPvRvi zj&=Co!JolZunvBWwf8mf4R8g_fm^{1tgEksAAlFYXTTY72BO$gn|arkyNIT2e~oFmf-@={3bB$+NBxI(oP!0(hEg zY7gDiA6~0Jyw--tt&J#BH}$n)58c!nUaK{{RxDeF^)(n?t3SL}e|W8ZJ&guCjRAIu znPD@uS!uj{f7gJB7FR|qJ9_$!oo!!i_ntYro_dBEhHAgY{hDIYG+1kVIjQ8Xx=!L! zTx3{CWeQb}G*c=wnW`{JNH(i7*+}K-A*t&#$Pq;UZcCZWz@x1n%JNNN{SjSJQRcH* zmD$2U;%L!V656t2@E~p2$NDg_8F!iX3{)@TBAJm_h4BKeD=pZpc5-$*ofa!=$5z&s zPb|!zU7S5b0U+z4BQAwVucJEFK`mc!*Ms$nIkW+wu_(CT}t%SvpSH zH>}y?3=n(NY@TN&EY0pKvGV;i6qB(yCC6gi2bn}Go!^Nv1UKJ1n;15wMK|S^C)!v- zR%DK0r;~-~v*os=HeQn5w$ZM=ws-?&NH?b`y@i1 0xff) @@ -79,10 +79,10 @@ class TrkrClusterv4 : public TrkrCluster m_adc |= tmp; } - unsigned int getMaxAdc() const override + uint16_t getMaxAdc() const override { - uint8_t tmp = (m_adc >> 8); - unsigned int out = 0; + uint16_t tmp = (m_adc >> 8); + uint16_t out = 0; out |= tmp; return out; } @@ -155,20 +155,20 @@ class TrkrClusterv4 : public TrkrCluster std::cout << "Deprecated seterr trkrcluster function!" << std::endl; } - char getSize() const override { return m_phisize * m_zsize; } - // void setSize(char size) { m_size = size; } + uint8_t getSize() const override { return m_phisize * m_zsize; } + // void setSize(uint8_t size) { m_size = size; } float getPhiSize() const override { return (float) m_phisize; } - void setPhiSize(char phisize) { m_phisize = phisize; } + void setPhiSize(uint8_t phisize) { m_phisize = phisize; } float getZSize() const override { return (float) m_zsize; } - void setZSize(char zsize) { m_zsize = zsize; } + void setZSize(uint8_t zsize) { m_zsize = zsize; } - char getOverlap() const override { return m_overlap; } - void setOverlap(char overlap) override { m_overlap = overlap; } + uint8_t getOverlap() const override { return m_overlap; } + void setOverlap(uint8_t overlap) override { m_overlap = overlap; } - char getEdge() const override { return m_edge; } - void setEdge(char edge) override { m_edge = edge; } + uint8_t getEdge() const override { return m_edge; } + void setEdge(uint8_t edge) override { m_edge = edge; } // float getPhiSize() const override //{ std::cout << "Deprecated size function"<< std::endl; return NAN;} @@ -180,11 +180,11 @@ class TrkrClusterv4 : public TrkrCluster protected: float m_local[2]{}; //< 2D local position [cm] 2 * 32 64bit - cumul 1*64 TrkrDefs::subsurfkey m_subsurfkey; //< unique identifier for hitsetkey-surface maps 16 bit - unsigned short int m_adc; //< cluster sum adc 16 - char m_phisize; // 8bit - char m_zsize; // 8bit - char m_overlap; // 8bit - char m_edge; // 8bit - cumul 2*64 + uint16_t m_adc; //< cluster sum adc 16 + uint8_t m_phisize; // 8bit + uint8_t m_zsize; // 8bit + uint8_t m_overlap; // 8bit + uint8_t m_edge; // 8bit - cumul 2*64 ClassDefOverride(TrkrClusterv4, 2) }; diff --git a/offline/packages/trackbase/TrkrClusterv5.h b/offline/packages/trackbase/TrkrClusterv5.h index 9e5e0fe7ff..54f29193fa 100644 --- a/offline/packages/trackbase/TrkrClusterv5.h +++ b/offline/packages/trackbase/TrkrClusterv5.h @@ -63,17 +63,17 @@ class TrkrClusterv5 : public TrkrCluster // // cluster info // - unsigned int getAdc() const override + uint16_t getAdc() const override { return m_adc; } - void setAdc(unsigned int adc) override + void setAdc(uint16_t adc) override { m_adc = adc; } - unsigned int getMaxAdc() const override + uint16_t getMaxAdc() const override { return m_maxadc; } @@ -151,20 +151,20 @@ class TrkrClusterv5 : public TrkrCluster std::cout << "Deprecated seterr trkrcluster function!" << std::endl; } - char getSize() const override { return m_phisize * m_zsize; } - // void setSize(char size) { m_size = size; } + uint8_t getSize() const override { return m_phisize * m_zsize; } + // void setSize(uint8_t size) { m_size = size; } float getPhiSize() const override { return (float) m_phisize; } - void setPhiSize(char phisize) { m_phisize = phisize; } + void setPhiSize(uint8_t phisize) { m_phisize = phisize; } float getZSize() const override { return (float) m_zsize; } - void setZSize(char zsize) { m_zsize = zsize; } + void setZSize(uint8_t zsize) { m_zsize = zsize; } - char getOverlap() const override { return m_overlap; } - void setOverlap(char overlap) override { m_overlap = overlap; } + uint8_t getOverlap() const override { return m_overlap; } + void setOverlap(uint8_t overlap) override { m_overlap = overlap; } - char getEdge() const override { return m_edge; } - void setEdge(char edge) override { m_edge = edge; } + uint8_t getEdge() const override { return m_edge; } + void setEdge(uint8_t edge) override { m_edge = edge; } // float getPhiSize() const override //{ std::cout << "Deprecated size function"<< std::endl; return NAN;} @@ -178,12 +178,12 @@ class TrkrClusterv5 : public TrkrCluster TrkrDefs::subsurfkey m_subsurfkey; //< unique identifier for hitsetkey-surface maps 16 bit float m_phierr; float m_zerr; - unsigned short int m_adc; //< cluster sum adc 16 - unsigned short int m_maxadc; //< cluster sum adc 16 - char m_phisize; // 8bit - char m_zsize; // 8bit - char m_overlap; // 8bit - char m_edge; // 8bit - cumul 2*64 + uint16_t m_adc; //< cluster sum adc 16 + uint16_t m_maxadc; //< cluster sum adc 16 + uint8_t m_phisize; // 8bit + uint8_t m_zsize; // 8bit + uint8_t m_overlap; // 8bit + uint8_t m_edge; // 8bit - cumul 2*64 ClassDefOverride(TrkrClusterv5, 2) }; diff --git a/offline/packages/trackbase/TrkrClusterv6.cc b/offline/packages/trackbase/TrkrClusterv6.cc index 9d5654fde7..0bdcf47d39 100644 --- a/offline/packages/trackbase/TrkrClusterv6.cc +++ b/offline/packages/trackbase/TrkrClusterv6.cc @@ -21,10 +21,6 @@ namespace } } // namespace -TrkrClusterv6::TrkrClusterv6() -{ -} - void TrkrClusterv6::identify(std::ostream& os) const { os << "---TrkrClusterv6--------------------" << std::endl; diff --git a/offline/packages/trackbase/TrkrClusterv6.h b/offline/packages/trackbase/TrkrClusterv6.h index 1657bd127d..d74f98e664 100644 --- a/offline/packages/trackbase/TrkrClusterv6.h +++ b/offline/packages/trackbase/TrkrClusterv6.h @@ -156,7 +156,7 @@ class TrkrClusterv6 : public TrkrCluster std::cout << "Deprecated seterr trkrcluster function!" << std::endl; } - char getSize() const override { return m_phisize * m_zsize; } + uint8_t getSize() const override { return m_phisize * m_zsize; } // void setSize(uint8_t size) { m_size = size; } float getRSize() const override { return (float) m_rsize; } From 7fd08733ce3f160238b505a793f174b8118ff695 Mon Sep 17 00:00:00 2001 From: Ishan Goel Date: Sun, 7 Jun 2026 00:02:45 -0400 Subject: [PATCH 10/11] More!! --- offline/packages/trackbase/.TrkrClusterv6.h.swm | Bin 0 -> 16384 bytes offline/packages/trackbase/TrkrClusterv1.cc | 4 +++- offline/packages/trackbase/TrkrClusterv1.h | 2 +- offline/packages/trackbase/TrkrClusterv2.cc | 6 ++++-- offline/packages/trackbase/TrkrClusterv2.h | 2 +- offline/packages/trackbase/TrkrClusterv3.cc | 6 ++++-- offline/packages/trackbase/TrkrClusterv3.h | 2 +- offline/packages/trackbase/TrkrClusterv4.h | 2 +- offline/packages/trackbase/TrkrClusterv5.h | 2 +- 9 files changed, 16 insertions(+), 10 deletions(-) create mode 100644 offline/packages/trackbase/.TrkrClusterv6.h.swm diff --git a/offline/packages/trackbase/.TrkrClusterv6.h.swm b/offline/packages/trackbase/.TrkrClusterv6.h.swm new file mode 100644 index 0000000000000000000000000000000000000000..bfca8a7aa1525f5c77d8aa1de0cbc38edc6198c5 GIT binary patch literal 16384 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 #include +#include #include // for swap namespace @@ -130,7 +132,7 @@ int TrkrClusterv1::isValid() const return 0; } } - if (m_adc == 0xFFFFFFFF) + if (m_adc == std::numeric_limits::max()) { return 0; } diff --git a/offline/packages/trackbase/TrkrClusterv1.h b/offline/packages/trackbase/TrkrClusterv1.h index e99367784d..062ee26ed5 100644 --- a/offline/packages/trackbase/TrkrClusterv1.h +++ b/offline/packages/trackbase/TrkrClusterv1.h @@ -88,7 +88,7 @@ class TrkrClusterv1 : public TrkrCluster float m_size[6]{}; //< size covariance matrix (packed storage) (+/- cm^2) float m_err[6]{}; //< covariance matrix: rad, arc and z - ClassDefOverride(TrkrClusterv1, 1) + ClassDefOverride(TrkrClusterv1, 2) }; #endif // TRACKBASE_TRKRCLUSTERV1_H diff --git a/offline/packages/trackbase/TrkrClusterv2.cc b/offline/packages/trackbase/TrkrClusterv2.cc index c6e9bd7862..32b7c2c9af 100644 --- a/offline/packages/trackbase/TrkrClusterv2.cc +++ b/offline/packages/trackbase/TrkrClusterv2.cc @@ -6,7 +6,9 @@ */ #include "TrkrClusterv2.h" +#include #include +#include #include // for swap namespace @@ -48,7 +50,7 @@ TrkrClusterv2::TrkrClusterv2() : m_cluskey(TrkrDefs::CLUSKEYMAX) , m_subsurfkey(TrkrDefs::SUBSURFKEYMAX) , m_isGlobal(true) - , m_adc(0xFFFFFFFF) + , m_adc(std::numeric_limits::max()) { for (float& m_po : m_pos) { @@ -136,7 +138,7 @@ int TrkrClusterv2::isValid() const return 0; } } - if (m_adc == 0xFFFFFFFF) + if (m_adc == std::numeric_limits::max()) { return 0; } diff --git a/offline/packages/trackbase/TrkrClusterv2.h b/offline/packages/trackbase/TrkrClusterv2.h index 901634f6b5..33608109b7 100644 --- a/offline/packages/trackbase/TrkrClusterv2.h +++ b/offline/packages/trackbase/TrkrClusterv2.h @@ -102,7 +102,7 @@ class TrkrClusterv2 : public TrkrCluster float m_local[2]{}; //< 2D local position [cm] float m_actsLocalErr[2][2]{}; //< 2D local error for Acts [cm] - ClassDefOverride(TrkrClusterv2, 2) + ClassDefOverride(TrkrClusterv2, 3) }; #endif // TRACKBASE_TRKRCLUSTERV2_H diff --git a/offline/packages/trackbase/TrkrClusterv3.cc b/offline/packages/trackbase/TrkrClusterv3.cc index de1fc2753a..de25382af5 100644 --- a/offline/packages/trackbase/TrkrClusterv3.cc +++ b/offline/packages/trackbase/TrkrClusterv3.cc @@ -6,7 +6,9 @@ */ #include "TrkrClusterv3.h" +#include #include +#include #include // for swap namespace @@ -22,7 +24,7 @@ namespace TrkrClusterv3::TrkrClusterv3() : m_cluskey(TrkrDefs::CLUSKEYMAX) , m_subsurfkey(TrkrDefs::SUBSURFKEYMAX) - , m_adc(0xFFFFFFFF) + , m_adc(std::numeric_limits::max()) { for (int i = 0; i < 2; i++) { @@ -77,7 +79,7 @@ int TrkrClusterv3::isValid() const } } } - if (m_adc == 0xFFFFFFFF) + if (m_adc == std::numeric_limits::max()) { return 0; } diff --git a/offline/packages/trackbase/TrkrClusterv3.h b/offline/packages/trackbase/TrkrClusterv3.h index a47e152f92..12c4e73ad1 100644 --- a/offline/packages/trackbase/TrkrClusterv3.h +++ b/offline/packages/trackbase/TrkrClusterv3.h @@ -142,7 +142,7 @@ class TrkrClusterv3 : public TrkrCluster float m_local[2]{}; //< 2D local position [cm] float m_actsLocalErr[2][2]{}; //< 2D local error for Acts [cm] - ClassDefOverride(TrkrClusterv3, 2) + ClassDefOverride(TrkrClusterv3, 3) }; #endif // TRACKBASE_TRKRCLUSTERV3_H diff --git a/offline/packages/trackbase/TrkrClusterv4.h b/offline/packages/trackbase/TrkrClusterv4.h index 2657c2bfca..9c8d7743cf 100644 --- a/offline/packages/trackbase/TrkrClusterv4.h +++ b/offline/packages/trackbase/TrkrClusterv4.h @@ -186,7 +186,7 @@ class TrkrClusterv4 : public TrkrCluster uint8_t m_overlap; // 8bit uint8_t m_edge; // 8bit - cumul 2*64 - ClassDefOverride(TrkrClusterv4, 2) + ClassDefOverride(TrkrClusterv4, 3) }; #endif // TRACKBASE_TRKRCLUSTERV4_H diff --git a/offline/packages/trackbase/TrkrClusterv5.h b/offline/packages/trackbase/TrkrClusterv5.h index 54f29193fa..a1c9c0886c 100644 --- a/offline/packages/trackbase/TrkrClusterv5.h +++ b/offline/packages/trackbase/TrkrClusterv5.h @@ -185,7 +185,7 @@ class TrkrClusterv5 : public TrkrCluster uint8_t m_overlap; // 8bit uint8_t m_edge; // 8bit - cumul 2*64 - ClassDefOverride(TrkrClusterv5, 2) + ClassDefOverride(TrkrClusterv5, 3) }; #endif // TRACKBASE_TRKRCLUSTERV5_H From 5f6ac3ba02dbfec1107750fb59ec8b9e19fb66fa Mon Sep 17 00:00:00 2001 From: Ishan Goel Date: Sun, 7 Jun 2026 00:16:54 -0400 Subject: [PATCH 11/11] Few --- offline/packages/trackbase/TrkrClusterv1.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/offline/packages/trackbase/TrkrClusterv1.cc b/offline/packages/trackbase/TrkrClusterv1.cc index e817cacec0..46835c3abe 100644 --- a/offline/packages/trackbase/TrkrClusterv1.cc +++ b/offline/packages/trackbase/TrkrClusterv1.cc @@ -49,7 +49,7 @@ namespace TrkrClusterv1::TrkrClusterv1() : m_cluskey(TrkrDefs::CLUSKEYMAX) , m_isGlobal(true) - , m_adc(0xFFFFFFFF) + , m_adc(std::numeric_limits::max()) { for (float& m_po : m_pos) {