force raw QA only for selected detectors

[u/mrichter/AliRoot.git] / STEER / AliMultiplicity.cxx

diff --git a/STEER/AliMultiplicity.cxx b/STEER/AliMultiplicity.cxx
index a92ebaee78d670b4783a133dbd26124c83e99368..d3332f8fba8f1a43d80a4afd690ebb92ae3ebcf7 100644 (file)
--- a/STEER/AliMultiplicity.cxx
+++ b/STEER/AliMultiplicity.cxx
@@ -7,66 +7,70 @@ ClassImp(AliMultiplicity)
 AliMultiplicity::AliMultiplicity():
   TObject(),
   fNtracks(0),
+  fNsingle(0),
+  fLabels(0),
+  fLabelsL2(0),
   fTh(0),
   fPhi(0),
   fDeltPhi(0),
-  fLabels(0),
-  fNsingle(0),
   fThsingle(0),
   fPhisingle(0)
-
 {
   // Default Constructor
-  fFiredChips[0] = -1;
-  fFiredChips[1] = -1;
+  fFiredChips[0] = 0;
+  fFiredChips[1] = 0;
 }
 
 //______________________________________________________________________
-AliMultiplicity::AliMultiplicity(Int_t ntr, Float_t *t,  Float_t *ph, Float_t *df, Int_t *labels, Int_t ns, Float_t *ts, Float_t *ps):
+AliMultiplicity::AliMultiplicity(Int_t ntr, Float_t *t,  Float_t *ph, Float_t *df, Int_t *labels, Int_t* labelsL2, Int_t ns, Float_t *ts, Float_t *ps):
   TObject(),
   fNtracks(ntr),
+  fNsingle(ns),
+  fLabels(0),
+  fLabelsL2(0),
   fTh(0),
   fPhi(0),
   fDeltPhi(0),
-  fLabels(0),
-  fNsingle(ns),
   fThsingle(0),
   fPhisingle(0)
 {
 // Standard constructor
   if(ntr>0){
-    fTh = new Float_t [ntr];
-    fPhi = new Float_t [ntr];
-    fDeltPhi = new Float_t [ntr];
     fLabels = new Int_t[ntr];
+    fLabelsL2 = new Int_t[ntr];
+    fTh = new Double_t [ntr];
+    fPhi = new Double_t [ntr];
+    fDeltPhi = new Double_t [ntr];
     for(Int_t i=0;i<fNtracks;i++){
       fTh[i]=t[i];
       fPhi[i]=ph[i];
       fDeltPhi[i]=df[i];
       fLabels[i] = labels[i];
+      fLabelsL2[i] = labelsL2[i];
     }
   }
   if(ns>0){
-    fThsingle = new Float_t [ns];
-    fPhisingle = new Float_t [ns];
+    fThsingle = new Double_t [ns];
+    fPhisingle = new Double_t [ns];
     for(Int_t i=0;i<fNsingle;i++){
       fThsingle[i]=ts[i];
       fPhisingle[i]=ps[i];
     }
   }
-  fFiredChips[0] = -1;
-  fFiredChips[1] = -1;
+  fFiredChips[0] = 0;
+  fFiredChips[1] = 0;
 }
 
 //______________________________________________________________________
 AliMultiplicity::AliMultiplicity(const AliMultiplicity& m):
   TObject(m),
   fNtracks(m.fNtracks),
+  fNsingle(m.fNsingle),
+  fLabels(0),
+  fLabelsL2(0),
   fTh(0),
   fPhi(0),
   fDeltPhi(0),
-  fLabels(0),
-  fNsingle(m.fNsingle),
   fThsingle(0),
   fPhisingle(0)
 {
@@ -84,6 +88,7 @@ AliMultiplicity &AliMultiplicity::operator=(const AliMultiplicity& m){
   if(fPhi)delete [] fPhi;fPhi = 0; 
   if(fDeltPhi)delete [] fDeltPhi;fDeltPhi = 0; 
   if(fLabels)delete [] fLabels;fLabels = 0;
+  if(fLabelsL2)delete [] fLabelsL2;fLabelsL2 = 0;
   if(fThsingle)delete [] fThsingle;fThsingle = 0;
   if(fPhisingle)delete [] fPhisingle;fPhisingle = 0;
   Duplicate(m);
@@ -91,37 +96,54 @@ AliMultiplicity &AliMultiplicity::operator=(const AliMultiplicity& m){
   return *this;
 }
 
+void AliMultiplicity::Copy(TObject &obj) const {
+  
+  // this overwrites the virtual TOBject::Copy()
+  // to allow run time copying without casting
+  // in AliESDEvent
+
+  if(this==&obj)return;
+  AliMultiplicity *robj = dynamic_cast<AliMultiplicity*>(&obj);
+  if(!robj)return; // not an AliMultiplicity
+  *robj = *this;
+
+}
+
+
 //______________________________________________________________________
 void AliMultiplicity::Duplicate(const AliMultiplicity& m){
   // used by copy constructor and assignment operator
   fNtracks = m.fNtracks;
   if(fNtracks>0){
-    fTh = new Float_t[fNtracks];
-    fPhi = new Float_t[fNtracks];
-    fDeltPhi = new Float_t[fNtracks];
+    fTh = new Double_t[fNtracks];
+    fPhi = new Double_t[fNtracks];
+    fDeltPhi = new Double_t[fNtracks];
     fLabels = new Int_t[fNtracks];
+    fLabelsL2 = new Int_t[fNtracks];
   }
   else {
     fTh = 0;
     fPhi = 0;
     fDeltPhi = 0;
     fLabels = 0;
+    fLabelsL2 = 0;
   }
   fNsingle = m.fNsingle;
   if(fNsingle>0){
-    fThsingle = new Float_t[fNsingle];
-    fPhisingle = new Float_t[fNsingle];
+    fThsingle = new Double_t[fNsingle];
+    fPhisingle = new Double_t[fNsingle];
   }
   else {
     fThsingle = 0;
     fPhisingle = 0;
   }
-  memcpy(fTh,m.fTh,fNtracks*sizeof(Float_t));
-  memcpy(fPhi,m.fPhi,fNtracks*sizeof(Float_t));
-  memcpy(fDeltPhi,m.fDeltPhi,fNtracks*sizeof(Float_t));
-  if (m.fLabels)   memcpy(fLabels,m.fLabels,fNtracks*sizeof(Int_t));
-  if (m.fThsingle) memcpy(fThsingle,m.fThsingle,fNsingle*sizeof(Float_t));
-  if (m.fPhisingle) memcpy(fPhisingle,m.fPhisingle,fNsingle*sizeof(Float_t));
+  if(m.fTh)memcpy(fTh,m.fTh,fNtracks*sizeof(Double_t));
+  if(m.fPhi)memcpy(fPhi,m.fPhi,fNtracks*sizeof(Double_t));
+  if(m.fDeltPhi)memcpy(fDeltPhi,m.fDeltPhi,fNtracks*sizeof(Double_t));
+  if(m.fLabels)memcpy(fLabels,m.fLabels,fNtracks*sizeof(Int_t));
+  if(m.fLabelsL2)memcpy(fLabelsL2,m.fLabelsL2,fNtracks*sizeof(Int_t));
+  if(m.fThsingle)memcpy(fThsingle,m.fThsingle,fNsingle*sizeof(Double_t));
+  if(m.fPhisingle)memcpy(fPhisingle,m.fPhisingle,fNsingle*sizeof(Double_t));
 
   fFiredChips[0] = m.fFiredChips[0];
   fFiredChips[1] = m.fFiredChips[1];
@@ -134,6 +156,7 @@ AliMultiplicity::~AliMultiplicity(){
   if(fPhi)delete [] fPhi;fPhi = 0; 
   if(fDeltPhi)delete [] fDeltPhi;fDeltPhi = 0; 
   if(fLabels)delete [] fLabels;fLabels = 0;
+  if(fLabelsL2)delete [] fLabelsL2;fLabelsL2 = 0;
   if(fThsingle)delete [] fThsingle;fThsingle = 0;
   if(fPhisingle)delete [] fPhisingle;fPhisingle = 0;