EVE/Reve/PODs.h

   1 // $Header$
   2
   3 #ifndef REVE_PODs_H
   4 #define REVE_PODs_H
   5
   6 #include <TObject.h>
   7 #include <TMath.h>
   8
   9 #include <TParticle.h>
  10
  11 namespace Reve {
  12
  13 /**************************************************************************/
  14 // PODs.h
  15 /**************************************************************************/
  16
  17 // Basic structures for Reve. Design criteria:
  18 //
  19 //  * provide basic cross-referencing functionality;
  20 //
  21 //  * small memory/disk footprint (floats / count on compression in
  22 //  split mode);
  23 //
  24 //  * simple usage from tree selections;
  25 //
  26 //  * placement in TClonesArray (composites are TObject derived);
  27 //
  28 //  * minimal member-naming (impossible to make everybody happy).
  29
  30 void DisablePODTObjectStreamers();
  31
  32 /**************************************************************************/
  33 // Vector
  34 /**************************************************************************/
  35
  36 // Minimal Float_t copy of TVector3.
  37 // Used to represent points and momenta.
  38
  39 class Vector
  40 {
  41 public:
  42   Float_t x, y, z;
  43
  44   Vector() : x(0), y(0), z(0) {}
  45   Vector(Float_t _x, Float_t _y, Float_t _z) : x(_x), y(_y), z(_z) {}
  46   virtual ~Vector() {}
  47
  48   Float_t* c_vec() { return &x; }
  49   void Set(Float_t*  v) { x=v[0]; y=v[1]; z=v[2]; }
  50   void Set(Double_t* v) { x=v[0]; y=v[1]; z=v[2]; }
  51   void Set(Float_t  _x, Float_t  _y, Float_t  _z) { x=_x; y=_y; z=_z; }
  52   void Set(Double_t _x, Double_t _y, Double_t _z) { x=_x; y=_y; z=_z; }
  53   void Set(const TVector3& v) { x=v.x(); y=v.y(); z=v.z(); }
  54
  55   Float_t Phi()      const;
  56   Float_t Theta()    const;
  57   Float_t CosTheta() const;
  58   Float_t Eta()      const;
  59
  60   Float_t Mag()  const { return TMath::Sqrt(x*x+y*y+z*z);}
  61   Float_t Mag2() const { return x*x+y*y+z*z;}
  62
  63   Float_t Perp()  const { return TMath::Sqrt(x*x+y*y);}
  64   Float_t Perp2() const { return x*x+y*y;}
  65   Float_t R()     const { return Perp(); }
  66
  67   // need operator +,-,Dot
  68
  69   ClassDef(Vector, 1);
  70 };
  71
  72 inline Float_t Vector::Phi() const
  73 { return x == 0.0 && y == 0.0 ? 0.0 : TMath::ATan2(y,x); }
  74
  75 inline Float_t Vector::Theta() const
  76 { return x == 0.0 && y == 0.0 && z == 0.0 ? 0.0 : TMath::ATan2(Perp(),z); }
  77
  78 inline Float_t Vector::CosTheta() const
  79 { Float_t ptot = Mag(); return ptot == 0.0 ? 1.0 : z/ptot; }
  80
  81 /**************************************************************************/
  82 // PathMark
  83 /**************************************************************************/
  84
  85 class PathMark
  86 {
  87  public:
  88   enum Type_e { Reference, Daughter, Decay };
  89
  90   Vector V, P;
  91   Type_e type;
  92
  93   PathMark(Type_e t=Reference) : type(t) {}
  94   virtual ~PathMark() {}
  95
  96   ClassDef(PathMark, 1);
  97 };
  98
  99 /**************************************************************************/
 100 // MCTrack
 101 /**************************************************************************/
 102
 103 class MCTrack : public TParticle // ?? Copy stuff over ??
 104 {
 105 public:
 106   Int_t   label;       // Label of the track
 107   Int_t   eva_label;   // Label of primary particle
 108
 109   Bool_t  decayed;     // True if decayed during tracking.
 110   // ?? Perhaps end-of-tracking point/momentum would be better.
 111   Float_t t_decay;     // Decay time
 112   Vector  V_decay;     // Decay vertex
 113   Vector  P_decay;     // Decay momentum
 114
 115   MCTrack() { decayed = false; }
 116   virtual ~MCTrack() {}
 117
 118   MCTrack& operator=(const TParticle& p)
 119   { *((TParticle*)this) = p; return *this; }
 120
 121   void ResetPdgCode() { fPdgCode = 0; }
 122
 123   ClassDef(MCTrack, 1);
 124 };
 125
 126
 127 /**************************************************************************/
 128 // MCTrackRef
 129 /**************************************************************************/
 130
 131 // Not used.
 132
 133 class MCTrackRef : public TObject
 134 {
 135 public:
 136   Int_t   label;
 137   Int_t   status;
 138   Vector  V;
 139   Vector  P;
 140   Float_t length;
 141   Float_t time;
 142
 143   MCTrackRef() {}
 144   virtual ~MCTrackRef() {}
 145
 146   ClassDef(MCTrackRef, 1)
 147 };
 148
 149
 150 /**************************************************************************/
 151 // Hit
 152 /**************************************************************************/
 153
 154 // Representation of a hit.
 155
 156 // Members det_id (and subdet_id) serve for cross-referencing into
 157 // geometry. Hits should be stored in det_id (+some label ordering) in
 158 // order to maximize branch compression.
 159
 160
 161 class Hit : public TObject
 162 {
 163 public:
 164   UShort_t det_id;    // Custom detector id
 165   UShort_t subdet_id; // Custom sub-detector id
 166   Int_t    label;     // Label of particle that produced the hit
 167   Int_t    eva_label;
 168   Vector   V;         // Vertex
 169
 170   // ?? Float_t charge. Probably specific.
 171
 172   Hit() {}
 173   virtual ~Hit() {}
 174
 175   ClassDef(Hit, 1);
 176 };
 177
 178
 179 /**************************************************************************/
 180 // Cluster
 181 /**************************************************************************/
 182
 183 // Base class for reconstructed clusters
 184
 185 // ?? Should Hit and cluster have common base? No.
 186
 187 class Cluster : public TObject
 188 {
 189 public:
 190   UShort_t det_id;    // Custom detector id
 191   UShort_t subdet_id; // Custom sub-detector id
 192   Int_t    label[3];  // Labels of particles that contributed hits
 193   // ?? Should include reconstructed track using it? Rather not, separate.
 194
 195   Vector   V;         // Vertex
 196   // Vector   W;         // Cluster widths
 197   // ?? Coord system? Special variables Wz, Wy?
 198
 199   Cluster() {}
 200   virtual ~Cluster() {}
 201
 202   ClassDef(Cluster, 1);
 203 };
 204
 205
 206 /**************************************************************************/
 207 // RecTrack
 208 /**************************************************************************/
 209
 210 class RecTrack : public TObject
 211 {
 212 public:
 213   Int_t   label;       // Label of the track
 214   Int_t   status;      // Status as exported from reconstruction
 215   Int_t   sign;
 216   Vector  V;           // Start vertex from reconstruction
 217   Vector  P;           // Reconstructed momentum at start vertex
 218   Float_t beta;
 219
 220   // PID data missing
 221
 222   RecTrack() {}
 223   virtual ~RecTrack() {}
 224
 225   Float_t Pt() { return P.Perp(); }
 226
 227   ClassDef(RecTrack, 1);
 228 };
 229
 230 // Another class with specified points/clusters
 231
 232
 233 /**************************************************************************/
 234 // RecKink
 235 /**************************************************************************/
 236
 237 class RecKink : public RecTrack
 238 {
 239 public:
 240   Int_t   label_sec;  // Label of the secondary track
 241   Vector  V_end;      // End vertex: last point on the primary track
 242   Vector  V_kink;     // Kink vertex: reconstructed position of the kink
 243   Vector  P_sec;      // Momentum of secondary track
 244
 245   RecKink() : RecTrack() {}
 246   virtual ~RecKink() {}
 247
 248   ClassDef(RecKink, 1);
 249 };
 250
 251
 252 /**************************************************************************/
 253 // RecV0
 254 /**************************************************************************/
 255
 256 class RecV0 : public TObject
 257 {
 258 public:
 259   Int_t  status;
 260
 261   Vector V_neg;       // Vertex of negative track
 262   Vector P_neg;       // Momentum of negative track
 263   Vector V_pos;       // Vertex of positive track
 264   Vector P_pos;       // Momentum of positive track
 265
 266   Vector V_ca;        // Point of closest approach
 267   Vector V0_birth;    // Reconstucted birth point of neutral particle
 268
 269   // ? Data from simulation.
 270   Int_t label;        // Neutral mother label read from kinematics
 271   Int_t pdg;          // PDG code of mother
 272   Int_t d_label[2];   // Daughter labels ?? Rec labels present anyway.
 273
 274   RecV0() {}
 275   virtual ~RecV0() {}
 276
 277   ClassDef(RecV0, 1);
 278 };
 279
 280 /**************************************************************************/
 281 /**************************************************************************/
 282
 283 // Missing primary vertex.
 284
 285 // Missing GenInfo, RecInfo.
 286
 287 class GenInfo : public TObject
 288 {
 289 public:
 290   Bool_t       is_rec;   // is reconstructed
 291   Bool_t       has_V0;
 292   Bool_t       has_kink;
 293   Int_t        label;
 294   Int_t        n_hits;
 295   Int_t        n_clus;
 296
 297   GenInfo() { is_rec = has_V0 = has_kink = false; }
 298   virtual ~GenInfo() {}
 299
 300   ClassDef(GenInfo, 1);
 301 };
 302
 303 /**************************************************************************/
 304 /**************************************************************************/
 305
 306 // This whole construction is highly embarrassing. It requires
 307 // shameless copying of experiment data. What is good about this
 308 // scheme:
 309 //
 310 // 1) Filters can be applied at copy time so that only part of the
 311 // data is copied over.
 312 //
 313 // 2) Once the data is extracted it can be used without experiment
 314 // software. Thus, external service can provide this data and local
 315 // client can be really thin.
 316 //
 317 // 3) Some pretty advanced visualization schemes/selections can be
 318 // implemented in a general framework by providing data extractors
 319 // only. This is also good for PR or VIP displays.
 320 //
 321 // 4) These classes can be extended by particular implementations. The
 322 // container classes will use TClonesArray with user-specified element
 323 // class.
 324
 325 // The common behaviour could be implemented entirely without usage of
 326 // a common base classes, by just specifying names of members that
 327 // retrieve specific data. This is fine as long as one only uses tree
 328 // selections but becomes painful for extraction of data into local
 329 // structures (could a) use interpreter but this is an overkill and
 330 // would cause serious trouble for multi-threaded environment; b) use
 331 // member offsets and data-types from the dictionary).
 332
 333 }
 334
 335 #endif