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   Float_t time;
  92   Type_e type;
  93
  94   PathMark(Type_e t=Reference) : V(), P(), type(t) {}
  95   virtual ~PathMark() {}
  96
  97   const char* type_name();
  98
  99   ClassDef(PathMark, 1);
 100 };
 101
 102 /**************************************************************************/
 103 // MCTrack
 104 /**************************************************************************/
 105
 106 class MCTrack : public TParticle // ?? Copy stuff over ??
 107 {
 108 public:
 109   Int_t   label;       // Label of the track
 110   Int_t   index;       // Index of the track (in some source array)
 111   Int_t   eva_label;   // Label of primary particle
 112
 113   Bool_t  decayed;     // True if decayed during tracking.
 114   // ?? Perhaps end-of-tracking point/momentum would be better.
 115   Float_t t_decay;     // Decay time
 116   Vector  V_decay;     // Decay vertex
 117   Vector  P_decay;     // Decay momentum
 118
 119   MCTrack() : label(-1), index(-1), eva_label(-1),
 120               decayed(false), t_decay(0), V_decay(), P_decay() {}
 121   virtual ~MCTrack() {}
 122
 123   MCTrack& operator=(const TParticle& p)
 124   { *((TParticle*)this) = p; return *this; }
 125
 126   void ResetPdgCode() { fPdgCode = 0; }
 127
 128   ClassDef(MCTrack, 1);
 129 };
 130
 131
 132 /**************************************************************************/
 133 // MCTrackRef
 134 /**************************************************************************/
 135
 136 // Not used.
 137
 138 class MCTrackRef : public TObject
 139 {
 140 public:
 141   Int_t   label;
 142   Int_t   status;
 143   Vector  V;
 144   Vector  P;
 145   Float_t length;
 146   Float_t time;
 147
 148   MCTrackRef() : label(-1), status(-1), V(), P(), length(0), time(0) {}
 149   virtual ~MCTrackRef() {}
 150
 151   ClassDef(MCTrackRef, 1)
 152 };
 153
 154
 155 /**************************************************************************/
 156 // Hit
 157 /**************************************************************************/
 158
 159 // Representation of a hit.
 160
 161 // Members det_id (and subdet_id) serve for cross-referencing into
 162 // geometry. Hits should be stored in det_id (+some label ordering) in
 163 // order to maximize branch compression.
 164
 165
 166 class Hit : public TObject
 167 {
 168 public:
 169   UShort_t det_id;    // Custom detector id
 170   UShort_t subdet_id; // Custom sub-detector id
 171   Int_t    label;     // Label of particle that produced the hit
 172   Int_t    eva_label;
 173   Vector   V;         // Vertex
 174
 175   // ?? Float_t charge. Probably specific.
 176
 177   Hit() : det_id(0), subdet_id(0), label(0), eva_label(0), V() {}
 178   virtual ~Hit() {}
 179
 180   ClassDef(Hit, 1);
 181 };
 182
 183
 184 /**************************************************************************/
 185 // Cluster
 186 /**************************************************************************/
 187
 188 // Base class for reconstructed clusters
 189
 190 // ?? Should Hit and cluster have common base? No.
 191
 192 class Cluster : public TObject
 193 {
 194 public:
 195   UShort_t det_id;    // Custom detector id
 196   UShort_t subdet_id; // Custom sub-detector id
 197   Int_t    label[3];  // Labels of particles that contributed hits
 198   // ?? Should include reconstructed track using it? Rather not, separate.
 199
 200   Vector   V;         // Vertex
 201   // Vector   W;         // Cluster widths
 202   // ?? Coord system? Special variables Wz, Wy?
 203
 204   Cluster() : det_id(0), subdet_id(0), V() { label[0] = label[1] = label [2] = 0; }
 205   virtual ~Cluster() {}
 206
 207   ClassDef(Cluster, 1);
 208 };
 209
 210
 211 /**************************************************************************/
 212 // RecTrack
 213 /**************************************************************************/
 214
 215 class RecTrack : public TObject
 216 {
 217 public:
 218   Int_t   label;       // Label of the track
 219   Int_t   index;       // Index of the track (in some source array)
 220   Int_t   status;      // Status as exported from reconstruction
 221   Int_t   sign;
 222   Vector  V;           // Start vertex from reconstruction
 223   Vector  P;           // Reconstructed momentum at start vertex
 224   Float_t beta;
 225
 226   // PID data missing
 227
 228   RecTrack() : label(-1), index(-1), status(0), sign(0), V(), P(), beta(0) {}
 229   virtual ~RecTrack() {}
 230
 231   Float_t Pt() { return P.Perp(); }
 232
 233   ClassDef(RecTrack, 1);
 234 };
 235
 236 // Another class with specified points/clusters
 237
 238
 239 /**************************************************************************/
 240 // RecKink
 241 /**************************************************************************/
 242
 243 class RecKink : public RecTrack
 244 {
 245 public:
 246   Int_t   label_sec;  // Label of the secondary track
 247   Vector  V_end;      // End vertex: last point on the primary track
 248   Vector  V_kink;     // Kink vertex: reconstructed position of the kink
 249   Vector  P_sec;      // Momentum of secondary track
 250
 251   RecKink() : RecTrack(), label_sec(0), V_end(), V_kink(), P_sec() {}
 252   virtual ~RecKink() {}
 253
 254   ClassDef(RecKink, 1);
 255 };
 256
 257
 258 /**************************************************************************/
 259 // RecV0
 260 /**************************************************************************/
 261
 262 class RecV0 : public TObject
 263 {
 264 public:
 265   Int_t  status;
 266
 267   Vector V_neg;       // Vertex of negative track
 268   Vector P_neg;       // Momentum of negative track
 269   Vector V_pos;       // Vertex of positive track
 270   Vector P_pos;       // Momentum of positive track
 271
 272   Vector V_ca;        // Point of closest approach
 273   Vector V0_birth;    // Reconstucted birth point of neutral particle
 274
 275   // ? Data from simulation.
 276   Int_t label;        // Neutral mother label read from kinematics
 277   Int_t pdg;          // PDG code of mother
 278   Int_t d_label[2];   // Daughter labels ?? Rec labels present anyway.
 279
 280   RecV0() : status(), V_neg(), P_neg(), V_pos(), P_pos(),
 281             V_ca(), V0_birth(), label(0), pdg(0)
 282   { d_label[0] = d_label[1] = 0; }
 283   virtual ~RecV0() {}
 284
 285   ClassDef(RecV0, 1);
 286 };
 287
 288 /**************************************************************************/
 289 /**************************************************************************/
 290
 291 // Missing primary vertex.
 292
 293 // Missing GenInfo, RecInfo.
 294
 295 class GenInfo : public TObject
 296 {
 297 public:
 298   Bool_t       is_rec;   // is reconstructed
 299   Bool_t       has_V0;
 300   Bool_t       has_kink;
 301   Int_t        label;
 302   Int_t        n_hits;
 303   Int_t        n_clus;
 304
 305   GenInfo() : is_rec(false), has_V0(false), has_kink(false),
 306               label(0), n_hits(0), n_clus(0) {}
 307   virtual ~GenInfo() {}
 308
 309   ClassDef(GenInfo, 1);
 310 };
 311
 312 /**************************************************************************/
 313 /**************************************************************************/
 314
 315 // This whole construction is highly embarrassing. It requires
 316 // shameless copying of experiment data. What is good about this
 317 // scheme:
 318 //
 319 // 1) Filters can be applied at copy time so that only part of the
 320 // data is copied over.
 321 //
 322 // 2) Once the data is extracted it can be used without experiment
 323 // software. Thus, external service can provide this data and local
 324 // client can be really thin.
 325 //
 326 // 3) Some pretty advanced visualization schemes/selections can be
 327 // implemented in a general framework by providing data extractors
 328 // only. This is also good for PR or VIP displays.
 329 //
 330 // 4) These classes can be extended by particular implementations. The
 331 // container classes will use TClonesArray with user-specified element
 332 // class.
 333
 334 // The common behaviour could be implemented entirely without usage of
 335 // a common base classes, by just specifying names of members that
 336 // retrieve specific data. This is fine as long as one only uses tree
 337 // selections but becomes painful for extraction of data into local
 338 // structures (could a) use interpreter but this is an overkill and
 339 // would cause serious trouble for multi-threaded environment; b) use
 340 // member offsets and data-types from the dictionary).
 341
 342 }
 343
 344 #endif