New base AliCluster class (Jouri+Cvetan)
authorcvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 15 Mar 2007 17:24:53 +0000 (17:24 +0000)
committercvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 15 Mar 2007 17:24:53 +0000 (17:24 +0000)
24 files changed:
ITS/AliITSClusterFinderSDD.cxx
ITS/AliITSClusterFinderSPD.cxx
ITS/AliITSClusterFinderSSD.cxx
ITS/AliITSClusterFinderV2.cxx
ITS/AliITSClusterFinderV2SDD.cxx
ITS/AliITSClusterFinderV2SPD.cxx
ITS/AliITSClusterFinderV2SSD.cxx
ITS/AliITSRecPoint.cxx
ITS/AliITSRecPoint.h
ITS/AliITSclusterV2.cxx
ITS/AliITSsimulationFastPoints.cxx
ITS/AliITSsimulationFastPointsV0.cxx
ITS/AliITStrackerMI.cxx
ITS/AliITStrackerV2.cxx
STEER/AliCluster.cxx
STEER/AliCluster.h
STEER/AliClusterTGeo.cxx
STEER/AliClusterTGeo.h
TPC/AliTPCcluster.cxx
TPC/AliTPCclusterMI.cxx
TPC/AliTPCclusterMI.h
TPC/AliTPCtrackerMI.cxx
TPC/AliTPCtrackerMI.h
TRD/AliTRDcluster.cxx

index 51b207d..89faf24 100644 (file)
@@ -951,18 +951,19 @@ void AliITSClusterFinderSDD::GetRecPoints(){
             if (!dig) dig = (AliITSdigitSDD*)Map()->GetHit(iz-1,ix+1); 
             if (!dig) printf("SDD: cannot assign the track number!\n");
         } //  end if !dig
-        AliITSRecPoint rnew(fDetTypeRec->GetITSgeom());
-       rnew.SetXZ(fModule,clusterI->X(),clusterI->Z());
-        rnew.SetQ(clusterI->Q());   // in KeV - should be ADC
+
+       Int_t lab[4] = {-3141593,-3141593,-3141593,ind};
+       if (dig) {
+         lab[0] = dig->GetTrack(0);
+         lab[1] = dig->GetTrack(1);
+         lab[2] = dig->GetTrack(2);
+       }
+       Float_t hit[5] = {clusterI->X(),clusterI->Z(),kRMSx*kRMSx,kRMSz*kRMSz,clusterI->Q()};
+       Int_t info[3] = {0,0,lyr};
+
+        AliITSRecPoint rnew(lab,hit,info,kTRUE);
         rnew.SetdEdX(kconvGeV*clusterI->Q());
-        rnew.SetSigmaDetLocX2(kRMSx*kRMSx);
-        rnew.SetSigmaZ2(kRMSz*kRMSz);
 
-        if(dig) rnew.SetLabel(dig->GetTrack(0),0);
-        if(dig) rnew.SetLabel(dig->GetTrack(1),1);
-        if(dig) rnew.SetLabel(dig->GetTrack(2),2);
-       rnew.SetDetectorIndex(ind);
-       rnew.SetLayer(lyr);
        fDetTypeRec->AddRecPoint(rnew);        
     } // I clusters
 //    Map()->ClearMap();
index 6d9b0be..9d6ab86 100644 (file)
@@ -419,17 +419,14 @@ void AliITSClusterFinderSPD::DigitToPoint(Int_t nclus,
 
         Double_t sigma2x = (kconv*errxcenter[i]) * (kconv*errxcenter[i]);
         Double_t sigma2z = (kconv*errzcenter[i]) * (kconv*errzcenter[i]);
-        AliITSRecPoint rnew(fDetTypeRec->GetITSgeom());
-        rnew.SetXZ(fModule,xg,zg);
-        rnew.SetQ(1.);
+
+       Int_t lab[4] = {tr1clus[i],tr2clus[i],tr3clus[i],ind};
+       Float_t hit[5] = {xg,zg,sigma2x,sigma2z,1.0};
+       Int_t info[3] = {0,0,lyr};
+
+        AliITSRecPoint rnew(lab,hit,info,kTRUE);
         rnew.SetdEdX(0.);
-        rnew.SetSigmaDetLocX2(sigma2x);
-        rnew.SetSigmaZ2(sigma2z);
-        rnew.SetLabel(tr1clus[i],0);
-        rnew.SetLabel(tr2clus[i],1);
-        rnew.SetLabel(tr3clus[i],2);
-       rnew.SetDetectorIndex(ind);
-       rnew.SetLayer(lyr);
+
        fDetTypeRec->AddRecPoint(rnew); 
     } // end for i
 }
index 13149a4..f7224f8 100644 (file)
@@ -763,32 +763,15 @@ Bool_t AliITSClusterFinderSSD::CreateNewRecPoint(Float_t P,Float_t dP,
        fDetTypeRec->AddCluster(2,&cnew);
        //fITS->AddCluster(2,&cnew);
        //AliITSRecPoint rnew;
-        AliITSRecPoint rnew(fDetTypeRec->GetITSgeom());
-        rnew.SetXZ(fModule,P*kconv,N*kconv);
-       //rnew.SetX(P*kconv);
-       //rnew.SetZ(N*kconv);
-     rnew.SetQ(signal);
-     rnew.SetdEdX(dedx);
-        rnew.SetSigmaDetLocX2( kRMSx* kRMSx);
-       //     rnew.SetSigmaX2( kRMSx* kRMSx); 
-    rnew.SetSigmaZ2( kRMSz* kRMSz);
-
-         rnew.SetLabel(tr[0],0);
-        rnew.SetLabel(tr[1],1);
-        rnew.SetLabel(tr[2],2);
-        rnew.SetDetectorIndex(ind);
-        rnew.SetLayer(lyr);
-
-       rnew.SetNy(nstripsP);
-       rnew.SetNz(nstripsN);
-
-    //rnew.fTracks[0]=tr[0];
-    // rnew.fTracks[1]=tr[1];
-    //rnew.fTracks[2]=tr[2];
-     //rnew.SetMultP(nstripsP);
-     //rnew.SetMultN(nstripsN);
-        fDetTypeRec->AddRecPoint(rnew);
-       //    fITS->AddRecPoint(rnew);
+       Int_t lab[4] = {tr[0],tr[1],tr[2],ind};
+       Float_t hit[5] = {P*kconv,N*kconv,kRMSx*kRMSx,kRMSz*kRMSz,signal};
+       Int_t info[3] = {nstripsP,nstripsN,lyr};
+
+       AliITSRecPoint rnew(lab,hit,info,kTRUE);
+       rnew.SetdEdX(dedx);
+
+       fDetTypeRec->AddRecPoint(rnew);
+       //    fITS->AddRecPoint(rnew);
      return kTRUE;
     } // end if
     return kFALSE;  
index c12045d..6e675d1 100644 (file)
@@ -233,7 +233,8 @@ MakeCluster(Int_t k,Int_t max,AliBin *bins,UInt_t m,AliITSRecPoint &c) {
   Int_t i=k/max, j=k-i*max;
 
   c.SetQ(c.GetQ()+q);
-  c.SetYZ(GetModule(),c.GetY()+i*q,c.GetZ()+j*q);
+  c.SetY(c.GetY()+i*q);
+  c.SetZ(c.GetZ()+j*q);
   c.SetSigmaY2(c.GetSigmaY2()+i*i*q);
   c.SetSigmaZ2(c.GetSigmaZ2()+j*j*q);
 
index c6ed0c8..a40da4f 100644 (file)
 #include "AliITSsegmentationSDD.h"
 #include <TClonesArray.h>
 #include "AliITSdigitSDD.h"
+#include "AliAlignObj.h"
 
 ClassImp(AliITSClusterFinderV2SDD)
 
-extern AliRun *gAlice;
-
 AliITSClusterFinderV2SDD::AliITSClusterFinderV2SDD(AliITSDetTypeRec* dettyp):AliITSClusterFinderV2(dettyp),
 fNySDD(256),
 fNzSDD(256),
@@ -142,7 +141,7 @@ FindClustersSDD(AliBin* bins[2], Int_t nMaxBin, Int_t nzBins,
         
       for (k=0; k<npeaks; k++) {
          if (idx[k] < 0) continue; //removed peak
-         AliITSRecPoint c(fDetTypeRec->GetITSgeom());
+         AliITSRecPoint c;
          MakeCluster(idx[k], nzBins, bins[s], msk[k], c);
         //mi change
         Int_t milab[10];
@@ -222,7 +221,8 @@ FindClustersSDD(AliBin* bins[2], Int_t nMaxBin, Int_t nzBins,
         //      c.SetY(y);
         //  c.SetZ(z);
         CorrectPosition(z,y);
-        c.SetYZ(fModule,y,z);
+        c.SetY(y);
+        c.SetZ(z);
         c.SetNy(maxj-minj+1);
         c.SetNz(maxi-mini+1);
         c.SetType(npeaks);
@@ -244,6 +244,8 @@ FindClustersSDD(AliBin* bins[2], Int_t nMaxBin, Int_t nzBins,
             c.SetLabel(milab[1],1);
             c.SetLabel(milab[2],2);
             c.SetLayer(fNlayer[fModule]);
+            UShort_t id=AliAlignObj::LayerToVolUID(fNlayer[fModule]+AliAlignObj::kSPD1,fNdet[fModule]);
+            c.SetVolumeId(id);
           }
         }
         if(clusters) new (cl[ncl]) AliITSRecPoint(c); 
index 3fe8cb9..06d4f01 100644 (file)
@@ -199,13 +199,13 @@ Int_t AliITSClusterFinderV2SPD::ClustersSPD(AliBin* bins, TClonesArray* digits,T
        if(!rawdata) milab[3]=fNdet[iModule];
        Int_t info[3] = {ymax-ymin+1,zmax-zmin+1,fNlayer[iModule]};
        if(!rawdata){
-        AliITSRecPoint cl(iModule,fDetTypeRec->GetITSgeom(),milab,hit,info);
+        AliITSRecPoint cl(milab,hit,info);
         fDetTypeRec->AddRecPoint(cl);
        }
         else{
          Int_t label[4]={milab[0],milab[1],milab[2],milab[3]};
          new (clusters->AddrAt(nclu)) 
-               AliITSRecPoint(iModule,fDetTypeRec->GetITSgeom(),label, hit,info);
+               AliITSRecPoint(label, hit,info);
        } 
        nclu++;
       }// for iiy
index 25b19c8..329f8f8 100644 (file)
@@ -229,7 +229,7 @@ void AliITSClusterFinderV2SSD::FindClustersSSD(AliITSRawStream* input,
   while (kTRUE) {
     Bool_t next = input->Next();
 
-    if(input->GetSignal()<3 && next) continue;
+    if(input->GetSignal()<(3*4.29) && next) continue;
     // check if a new cluster starts
     Int_t strip = input->GetCoord2();
     Int_t flag = input->GetCoord1();
@@ -284,8 +284,8 @@ void AliITSClusterFinderV2SSD::FindClustersSSD(AliITSRawStream* input,
     }
 
     // add digit to current cluster
-    q += input->GetSignal();
-    y += strip * input->GetSignal();
+    q += input->GetSignal()/4.29;
+    y += strip * input->GetSignal()/4.29;
     nDigits++;
     prevStrip = strip;
     prevFlag = flag;
@@ -411,7 +411,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
       Int_t info[3] = {pos[ip].GetNd(),neg[j].GetNd(),fNlayer[fModule]};
       AliITSRecPoint * cl2;
       if(clusters){
-       cl2 = new (cl[ncl]) AliITSRecPoint(fModule,fDetTypeRec->GetITSgeom(),milab,lp,info);
+       cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
        cl2->SetChargeRatio(ratio);     
        cl2->SetType(1);
        pairs[ip][j]=1;
@@ -424,7 +424,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
        
       }
       else{
-       cl2 = new AliITSRecPoint(fModule,fDetTypeRec->GetITSgeom(),milab,lp,info);      
+       cl2 = new AliITSRecPoint(milab,lp,info);        
        cl2->SetChargeRatio(ratio);     
        cl2->SetType(1);
        pairs[ip][j]=1;
@@ -480,7 +480,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
 
          AliITSRecPoint * cl2;
          if(clusters){
-           cl2 = new (cl[ncl]) AliITSRecPoint(fModule,fDetTypeRec->GetITSgeom(),milab,lp,info);
+           cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
            cl2->SetChargeRatio(ratio);         
            cl2->SetType(5);
            pairs[ip][in] = 5;
@@ -490,7 +490,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
            }       
          }
          else{
-           cl2 = new AliITSRecPoint(fModule,fDetTypeRec->GetITSgeom(),milab,lp,info);
+           cl2 = new AliITSRecPoint(milab,lp,info);
            cl2->SetChargeRatio(ratio);         
            cl2->SetType(5);
            pairs[ip][in] = 5;
@@ -535,7 +535,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
          
          AliITSRecPoint * cl2;
          if(clusters){
-           cl2 = new (cl[ncl]) AliITSRecPoint(fModule,fDetTypeRec->GetITSgeom(),milab,lp,info);
+           cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
            cl2->SetChargeRatio(ratio);         
            cl2->SetType(5);
            pairs[ip2][in] =5;
@@ -545,7 +545,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
            }
          }
          else{
-           cl2 = new AliITSRecPoint(fModule,fDetTypeRec->GetITSgeom(),milab,lp,info);
+           cl2 = new AliITSRecPoint(milab,lp,info);
            cl2->SetChargeRatio(ratio);         
            cl2->SetType(5);
            pairs[ip2][in] =5;
@@ -607,7 +607,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
 
          AliITSRecPoint * cl2;
          if(clusters){
-           cl2 = new (cl[ncl]) AliITSRecPoint(fModule,fDetTypeRec->GetITSgeom(),milab,lp,info);
+           cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
            cl2->SetChargeRatio(ratio);         
            cl2->SetType(7);
            pairs[ip][jn] =7;
@@ -618,7 +618,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
 
          }
          else{
-           cl2 = new AliITSRecPoint(fModule,fDetTypeRec->GetITSgeom(),milab,lp,info);
+           cl2 = new AliITSRecPoint(milab,lp,info);
            cl2->SetChargeRatio(ratio);         
            cl2->SetType(7);
            pairs[ip][jn] =7;
@@ -660,7 +660,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
          Int_t info[3] = {pos[ip].GetNd(),neg[jn2].GetNd(),fNlayer[fModule]};
          AliITSRecPoint * cl2;
          if(clusters){
-           cl2 = new (cl[ncl]) AliITSRecPoint(fModule,fDetTypeRec->GetITSgeom(),milab,lp,info);
+           cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
            cl2->SetChargeRatio(ratio);         
            pairs[ip][jn2]=7;
            cl2->SetType(7);
@@ -671,7 +671,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
            
          }
          else{
-           cl2 = new AliITSRecPoint(fModule,fDetTypeRec->GetITSgeom(),milab,lp,info);
+           cl2 = new AliITSRecPoint(milab,lp,info);
            cl2->SetChargeRatio(ratio);         
            pairs[ip][jn2]=7;
            cl2->SetType(7);
@@ -761,7 +761,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
       Int_t info[3] = {pos[ip].GetNd(),neg[j].GetNd(),fNlayer[fModule]};
       AliITSRecPoint * cl2;
       if(clusters){
-       cl2 = new (cl[ncl]) AliITSRecPoint(fModule,fDetTypeRec->GetITSgeom(),milab,lp,info);
+       cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
        cl2->SetChargeRatio(ratio);     
        cl2->SetType(10);
        pairs[ip][j]=10;
@@ -773,7 +773,7 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
        cused2[j]++;      
       }
       else{
-       cl2 = new AliITSRecPoint(fModule,fDetTypeRec->GetITSgeom(),milab,lp,info);
+       cl2 = new AliITSRecPoint(milab,lp,info);
        cl2->SetChargeRatio(ratio);     
        cl2->SetType(10);
        pairs[ip][j]=10;
@@ -828,12 +828,12 @@ FindClustersSSD(Ali1Dcluster* neg, Int_t nn,
        Int_t info[3] = {pos[i].GetNd(),neg[j].GetNd(),fNlayer[fModule]};
        AliITSRecPoint * cl2;
        if(clusters){
-         cl2 = new (cl[ncl]) AliITSRecPoint(fModule,fDetTypeRec->GetITSgeom(),milab,lp,info);
+         cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
          cl2->SetChargeRatio(ratio);
          cl2->SetType(100+cpositive[j]+cnegative[i]);    
        }
        else{
-         cl2 = new AliITSRecPoint(fModule,fDetTypeRec->GetITSgeom(),milab,lp,info);
+         cl2 = new AliITSRecPoint(milab,lp,info);
          cl2->SetChargeRatio(ratio);
          cl2->SetType(100+cpositive[j]+cnegative[i]);
          fDetTypeRec->AddRecPoint(*cl2);
index b8d5565..e9c6fdb 100644 (file)
 
 
 #include "AliITSRecPoint.h"
-#include "AliITSgeom.h"
+#include "AliAlignObj.h"
+
 ClassImp(AliITSRecPoint)
 
 //_____________________________________________________________
 AliITSRecPoint::AliITSRecPoint(): AliCluster(),
-fX(0),
-fXloc(0),
-fZloc(0),
-fdEdX(0),
-fIndex(0),
-fQ(0),
-fLayer(0),
-fNz(0),
-fNy(0),
-fChargeRatio(0),
-fType(0),
-fDeltaProb(0),
-fGeom(0){
-    // default creator
-}
-
-//_____________________________________________________________
-AliITSRecPoint::AliITSRecPoint(AliITSgeom* geom): AliCluster(),
-fX(0),
 fXloc(0),
 fZloc(0),
 fdEdX(0),
@@ -66,15 +48,14 @@ fNz(0),
 fNy(0),
 fChargeRatio(0),
 fType(0),
-fDeltaProb(0),
-fGeom(geom) {
-    // default creator
-
+fDeltaProb(0)
+{
+    // default constructor
 }
 
 //________________________________________________________________________
-AliITSRecPoint::AliITSRecPoint(Int_t module,AliITSgeom* geom,Int_t *lab,Float_t *hit, Int_t *info):AliCluster(lab,hit),
-fX(0),
+AliITSRecPoint::AliITSRecPoint(Int_t *lab,Float_t *hit, Int_t *info, Bool_t local):
+AliCluster(AliAlignObj::LayerToVolUID((info[2]+AliAlignObj::kSPD1),lab[3]&0x3FF),hit,0,0,lab),
 fXloc(0),
 fZloc(0),
 fdEdX(0),
@@ -85,28 +66,47 @@ fNz(info[1]),
 fNy(info[0]),
 fChargeRatio(0),
 fType(0),
-fDeltaProb(0),
-fGeom(geom)
+fDeltaProb(0)
 {
   //standard constructor used in AliITSClusterFinderV2
 
+  if (!local) { // Cluster V2
+    Double_t txyz[3] = {GetX(), GetY(), GetZ()};
+    Double_t lxyz[3] = {0, 0, 0};
+    GetTracking2LocalMatrix()->LocalToMaster(txyz,lxyz);
+    fXloc = lxyz[0]; fZloc = lxyz[2];
+  }
+  else {
+    switch (fLayer) {
+    case 0:
+    case 1:
+      fdEdX = 0;
+      break;
+    case 2:
+    case 3:
+      fdEdX=fQ*1e-6;
+      break;
+    case 4:
+    case 5:
+      fdEdX=fQ*2.16;
+      break;
+    default:
+      AliError(Form("Wrong ITS layer %d (0 -> 5)",fLayer));
+      break;
+    }
+
+    Double_t lxyz[3] = {fXloc, 0, fZloc};
+    Double_t txyz[3] = {0, 0, 0};
+    GetTracking2LocalMatrix()->MasterToLocal(lxyz,txyz);
+
+    SetX(0.); SetY(txyz[1]); SetZ(txyz[2]);
 
-  fType=0;
-  fDeltaProb=0.;
-  
-  fGeom = geom;
-  fGeom->TrackingV2ToDetL(module,fY,fZ,fXloc,fZloc);
-  if(module<fGeom->GetStartSDD()) fdEdX=0.;
-  if(module>=fGeom->GetStartSDD() && module<fGeom->GetStartSSD()){
-    fdEdX=fQ*1e-6;
   }
-  if(module>=fGeom->GetStartSSD()) fdEdX=fQ*2.16;
-  
-  
+
 }
+
 //_______________________________________________________________________
 AliITSRecPoint::AliITSRecPoint(const AliITSRecPoint& pt):AliCluster(pt),
-fX(pt.fX),
 fXloc(pt.fXloc),
 fZloc(pt.fZloc),
 fdEdX(pt.fdEdX),
@@ -117,8 +117,8 @@ fNz(pt.fNz),
 fNy(pt.fNy),
 fChargeRatio(pt.fChargeRatio),
 fType(pt.fType),
-fDeltaProb(pt.fDeltaProb),
-fGeom(pt.fGeom){
+fDeltaProb(pt.fDeltaProb)
+{
   //Copy constructor
 
 }
@@ -133,24 +133,6 @@ AliITSRecPoint& AliITSRecPoint::operator=(const AliITSRecPoint& source){
 
 }
 
-//________________________________________________________________________
-AliITSRecPoint::AliITSRecPoint(Int_t *lab,Float_t *hit, Int_t *info):AliCluster(lab,hit),
-fX(0),
-fXloc(0),
-fZloc(0),
-fdEdX(0),
-fIndex(lab[3]),
-fQ(hit[4]),
-fLayer(info[2]),
-fNz(info[1]),
-fNy(info[0]),
-fChargeRatio(0),
-fType(0),
-fDeltaProb(0),
-fGeom(0){
-  //standard constructor used in AliITSClusterFinderV2
-}
-
 //----------------------------------------------------------------------
 void AliITSRecPoint::Print(ostream *os){
     ////////////////////////////////////////////////////////////////////////
@@ -171,12 +153,12 @@ void AliITSRecPoint::Print(ostream *os){
 #endif
  
     fmt = os->setf(ios::fixed);  // set fixed floating point output
-    *os << fTracks[0]<< " " << fTracks[1] << " " << fTracks[2] << " ";
+    *os << GetLabel(0) << " " << GetLabel(1) << " " << GetLabel(2) << " ";
     *os << fXloc << " " << fZloc << " " << fQ << " ";
     fmt = os->setf(ios::scientific); // set scientific for dEdX.
     *os << fdEdX << " ";
     fmt = os->setf(ios::fixed); // every fixed
-    *os << fSigmaY2 << " " << fSigmaZ2;
+    *os << GetSigmaY2() << " " << GetSigmaZ2();
     os->flags(fmt); // reset back to old formating.
     return;
 }
@@ -186,10 +168,16 @@ void AliITSRecPoint::Read(istream *is){
 // Standard input format for this class.
 ////////////////////////////////////////////////////////////////////////
  
-
-    *is >> fTracks[0] >> fTracks[1] >> fTracks[2] >> fXloc >> fZloc >> fQ;
-    *is >> fdEdX >> fSigmaY2 >> fSigmaZ2;
-    return;
+  Int_t lab[4];
+  Float_t hit[5];
+  lab[3] = 0; // ??
+  *is >> lab[0] >> lab[1] >> lab[2] >> hit[0] >> hit[1] >> hit[4];
+  *is >> fdEdX >> hit[2] >> hit[3];
+  Int_t info[3] = {0,0,0};
+  AliITSRecPoint rp(lab,hit,info,kTRUE);
+  *this = rp;
+
+  return;
 }
 //----------------------------------------------------------------------
 ostream &operator<<(ostream &os,AliITSRecPoint &p){
index 56b0260..f88fcb7 100644 (file)
 #include <AliCluster.h>
 #include <Riostream.h>
 #include <AliLog.h>
-#include <AliITSgeom.h>
-
 
 class AliITSRecPoint : public AliCluster {
  public:
   AliITSRecPoint();
-  AliITSRecPoint(AliITSgeom* geom);
-  AliITSRecPoint(Int_t *lab,Float_t *hit, Int_t *info);
-  AliITSRecPoint(Int_t module,AliITSgeom* geom,Int_t *lab,
-                Float_t *hit, Int_t *info);
+  AliITSRecPoint(Int_t *lab,Float_t *hit, Int_t *info, Bool_t local = kFALSE);
   AliITSRecPoint(const AliITSRecPoint& pt);
   AliITSRecPoint& operator=(const AliITSRecPoint &source);
   
   virtual ~AliITSRecPoint() {}; // distructor
-  Bool_t IsSortable() const {return kTRUE;} // allows for sorting
-  Int_t  *GetTracks(){return fTracks;}// Returns pointer to track array
-  Int_t   GetNTracks() const {return 3;} // returns track array size
+  Bool_t  IsSortable() const {return kTRUE;} // allows for sorting
   Float_t GetDetLocalX() const {return fXloc;} // gets fX
   Float_t GetDetLocalZ() const {return fZloc;} // gets fZ
   Float_t GetdEdX() const {return fdEdX;} // gets fdEdX
-  Float_t GetSigmaDetLocX2() const {return fSigmaY2;} // gets fSigmaX2
-  void SetdEdX(Float_t dedx){fdEdX=dedx;} // sets fdEdX
-  void SetSigmaDetLocX2(Float_t sx2){fSigmaY2=sx2;} // sets fSigmaX2
+  Float_t GetSigmaDetLocX2() const {return GetSigmaY2();} // gets fSigmaX2
+  void    SetdEdX(Float_t dedx){fdEdX=dedx;} // sets fdEdX
   Int_t Compare(const TObject *) const {return 0;} //to be defined
   void Print(ostream *os); 
   // Reads in the content of this class in the format of Print
@@ -55,22 +47,6 @@ class AliITSRecPoint : public AliCluster {
   virtual void Print(Option_t *option="") const {TObject::Print(option);}
   virtual Int_t Read(const char *name) {return TObject::Read(name);}
   
-  void SetITSgeom(AliITSgeom* geom) {fGeom=geom;}
-
-  virtual void SetY(Float_t  y ){fY=y;
-    AliError("For consistency, Use method SetYZ. Data members are only partially set\n");}
-  virtual void SetZ(Float_t  z ){fZ=z;
-    AliError("For consistency, Use method SetYZ. Data members are only partially set\n");}
-  void SetYZ(Int_t module, Float_t y, Float_t z){
-    fY=y;fZ=z;
-    if(fGeom)fGeom->TrackingV2ToDetL(module,y,z,fXloc,fZloc);
-    else AliError("Geometry not set. \n");
-  }
-  void SetXZ(Int_t module, Float_t x, Float_t z){
-    fXloc=x;fZloc=z;
-    if(fGeom)fGeom->DetLToTrackingV2(module,x,z,fY,fZ);
-    else AliError("Geometry not set. Nothing done!!!!!\n");
-  }
   void Use(Int_t = 0) {fQ=-fQ;}
   void UnUse() {fQ=TMath::Abs(fQ);}
   void SetQ(Float_t q) {fQ=q;}
@@ -96,13 +72,7 @@ class AliITSRecPoint : public AliCluster {
   Int_t GetType() const {return fType;}  // type of the cluster
   Float_t GetDeltaProbability() const{return fDeltaProb;} //probability to belong to the delta ray
   
-  // The following two methods deal with the misaligned x position
-  // of a cluster in the tracking coordidate system 
-  virtual Float_t GetX() const {return fX;}
-  virtual void SetX(Float_t x) {fX=x;}
-
  protected:
-  Float_t   fX;        // X coordinate in the misaligned tracking system 
 
   Float_t   fXloc ;        //X of cluster (local coordinates)
   Float_t   fZloc ;        //Z of cluster (local coordinates)
@@ -117,9 +87,7 @@ class AliITSRecPoint : public AliCluster {
   Int_t    fType;         //quality factor of the cluster
   Float_t  fDeltaProb;    // probability to be deleta electron
     
-  AliITSgeom* fGeom;     //!pointer to ITS geometry
-
-  ClassDef(AliITSRecPoint,3)  // AliITSRecPoint class
+  ClassDef(AliITSRecPoint,5)  // AliITSRecPoint class
 };
 // Input and output function for standard C++ input/output.
 ostream& operator<<(ostream &os,AliITSRecPoint &source);
index e52d42a..da8f2eb 100644 (file)
@@ -36,7 +36,8 @@ fDeltaProb(0) {
 }
 
 //_______________________________________________________
-AliITSclusterV2::AliITSclusterV2(Int_t *lab,Float_t *hit, Int_t *info) : AliCluster(lab,hit),
+AliITSclusterV2::AliITSclusterV2(Int_t *lab,Float_t *hit, Int_t *info): 
+  AliCluster(0,hit,0.,0.,lab),
 fIndex(lab[3]),
 fQ(hit[4]),
 fLayer(info[2]),
index 45eb1a3..c236f93 100644 (file)
@@ -129,18 +129,12 @@ void AliITSsimulationFastPoints::CreateFastRecPoints(AliITSmodule *mod,
        if ( (hitdestep+deltaDe) > thrde ){
          locals[0] += deltaXl;
          locals[2] += deltaZl;
-         AliITSRecPoint rp(gm);
-         rp.SetLabel(hit->GetTrack(),0);
-         //                rp.fTracks[0]=mod->GetHitTrackIndex(ihit);
-         rp.SetLabel(-3,1);
-         rp.SetLabel(-3,2);
-         rp.SetXZ(module,locals[0],locals[2]);
+         Int_t lab[4] = {hit->GetTrack(),-3,-3,ind};
+         Float_t hit[5] = {locals[0],locals[2],sigmarphi*sigmarphi,sigmaz*sigmaz,kdEdXtoQ*(hitdestep+deltaDe)};
+         Int_t info[3] = {0,0,lyr};
+         AliITSRecPoint rp(lab,hit,info,kTRUE);
          rp.SetdEdX(hitdestep+deltaDe);
-         rp.SetQ(kdEdXtoQ*(hitdestep+deltaDe));  // number of e
-         rp.SetSigmaDetLocX2(sigmarphi*sigmarphi);
-         rp.SetSigmaZ2(sigmaz*sigmaz);
-         rp.SetDetectorIndex(ind);
-         rp.SetLayer(lyr);
+
          new (pt[irecp]) AliITSRecPoint(rp);
          irecp++;
        } // end if ( (hitdestep+deltaDe)
index 114c788..517a66c 100644 (file)
@@ -130,28 +130,19 @@ void AliITSsimulationFastPointsV0::AddSPD(Float_t &e,
   //  const Float_t kdEdXtoQ = ;
   const Float_t kRMSx = 12.0*kmicronTocm; // microns->cm ITS TDR Table 1.3
   const Float_t kRMSz = 70.0*kmicronTocm; // microns->cm ITS TDR Table 1.3
-  Float_t a1,a2; // general float.
   
-  AliITSgeom* gm = mod->GetITS()->GetITSgeom();
-
-  AliITSRecPoint rpSPD(gm);
-
-  rpSPD.SetLabel(trackNumber,0);
-  rpSPD.SetLabel(-3,1);
-  rpSPD.SetLabel(-3,2);
-  rpSPD.SetXZ(mod->GetIndex(),fSx->GetMean(),fSz->GetMean());
-  rpSPD.SetdEdX(e);
-  rpSPD.SetQ(1.0);
-  a1 = fSx->GetRMS(); a1 *= a1; a1 += kRMSx*kRMSx;
+  Int_t lab[4] = {trackNumber,-3,-3,mod->GetIndex()};
+  Float_t a1 = fSx->GetRMS(); a1 *= a1; a1 += kRMSx*kRMSx;
   //  if(a1>1.E5) printf("addSPD: layer=%d track #%d dedx=%e sigmaX2= %e ",
   //               mod->GetLayer(),trackNumber,e,a1);
-  rpSPD.SetSigmaDetLocX2(a1);
-  a2 = fSz->GetRMS(); a2 *= a2; a2 += kRMSz*kRMSz;
+  Float_t a2 = fSz->GetRMS(); a2 *= a2; a2 += kRMSz*kRMSz;
   //  if(a1>1.E5) printf(" sigmaZ2= %e\n",a2);
-  rpSPD.SetSigmaZ2(a2);
-  rpSPD.SetDetectorIndex(mod->GetIndex());
-  rpSPD.SetLayer(mod->GetLayer());
-  //(mod->GetITS())->AddRecPoint(rpSPD);
+  Float_t hit[5] = {fSx->GetMean(),fSz->GetMean(),a1,a2,1.0};
+  Int_t info[3] = {0,0,mod->GetLayer()};
+
+  AliITSRecPoint rpSPD(lab,hit,info,kTRUE);
+  rpSPD.SetdEdX(e);
+
   new (pt[fNrecp]) AliITSRecPoint(rpSPD);
   fNrecp++;
 }
@@ -164,26 +155,19 @@ void AliITSsimulationFastPointsV0::AddSDD(Float_t &e,
   const Float_t kdEdXtoQ = 2.778e+8; 
   const Float_t kRMSx = 38.0*kmicronTocm; // microns->cm ITS TDR Table 1.3
   const Float_t kRMSz = 28.0*kmicronTocm; // microns->cm ITS TDR Table 1.3
-  Float_t a1,a2; // general float.
-  AliITSgeom* gm = mod->GetITS()->GetITSgeom();
-
-  AliITSRecPoint rpSDD(gm);
 
-  rpSDD.SetLabel(trackNumber,0);
-  rpSDD.SetLabel(-3,1);
-  rpSDD.SetLabel(-3,2);
-  rpSDD.SetXZ(mod->GetIndex(),fSx->GetMean(),fSz->GetMean());
-  rpSDD.SetdEdX(e);
-  rpSDD.SetQ(kdEdXtoQ*e);
-  a1 = fSx->GetRMS(); a1 *= a1; a1 += kRMSx*kRMSx;
-  //  if(a1>1.E5) printf("addSDD: layer=%d track #%d dedx=%e sigmaX2= %e ",
+  Int_t lab[4] = {trackNumber,-3,-3,mod->GetIndex()};
+  Float_t a1 = fSx->GetRMS(); a1 *= a1; a1 += kRMSx*kRMSx;
+  //  if(a1>1.E5) printf("addSPD: layer=%d track #%d dedx=%e sigmaX2= %e ",
   //               mod->GetLayer(),trackNumber,e,a1);
-  rpSDD.SetSigmaDetLocX2(a1);
-  a2 = fSz->GetRMS(); a2 *= a2; a2 += kRMSz*kRMSz;
+  Float_t a2 = fSz->GetRMS(); a2 *= a2; a2 += kRMSz*kRMSz;
   //  if(a1>1.E5) printf(" sigmaZ2= %e\n",a2);
-  rpSDD.SetSigmaZ2(a2);
-  rpSDD.SetDetectorIndex(mod->GetIndex());
-  rpSDD.SetLayer(mod->GetLayer());
+  Float_t hit[5] = {fSx->GetMean(),fSz->GetMean(),a1,a2,kdEdXtoQ*e};
+  Int_t info[3] = {0,0,mod->GetLayer()};
+
+  AliITSRecPoint rpSDD(lab,hit,info,kTRUE);
+  rpSDD.SetdEdX(e);
+
   new (pt[fNrecp]) AliITSRecPoint(rpSDD);
   fNrecp++;
 
@@ -197,27 +181,19 @@ void AliITSsimulationFastPointsV0::AddSSD(Float_t &e,
   const Float_t kdEdXtoQ = 2.778e+8;
   const Float_t kRMSx = 20.0*kmicronTocm;  // microns->cm ITS TDR Table 1.3
   const Float_t kRMSz = 830.0*kmicronTocm; // microns->cm ITS TDR Table 1.3
-  Float_t a1,a2; // general float.
 
-  AliITSgeom* gm = mod->GetITS()->GetITSgeom();
-  AliITSRecPoint rpSSD(gm);
+  Int_t lab[4] = {trackNumber,-3,-3,mod->GetIndex()};
+  Float_t a1 = fSx->GetRMS(); a1 *= a1; a1 += kRMSx*kRMSx;
+  //  if(a1>1.E5) printf("addSPD: layer=%d track #%d dedx=%e sigmaX2= %e ",
+  //               mod->GetLayer(),trackNumber,e,a1);
+  Float_t a2 = fSz->GetRMS(); a2 *= a2; a2 += kRMSz*kRMSz;
+  //  if(a1>1.E5) printf(" sigmaZ2= %e\n",a2);
+  Float_t hit[5] = {fSx->GetMean(),fSz->GetMean(),a1,a2,kdEdXtoQ*e};
+  Int_t info[3] = {0,0,mod->GetLayer()};
 
-  rpSSD.SetLabel(trackNumber,0);
-  rpSSD.SetLabel(-3,1);
-  rpSSD.SetLabel(-3,2);
-  rpSSD.SetXZ(mod->GetIndex(),fSx->GetMean(),fSz->GetMean());
+  AliITSRecPoint rpSSD(lab,hit,info,kTRUE);
   rpSSD.SetdEdX(e);
-  rpSSD.SetQ(kdEdXtoQ*e);
-  a1 = fSx->GetRMS(); a1 *= a1; a1 += kRMSx*kRMSx;
-  //  if(a1>1.E5) printf("addSSD: layer=%d track #%d dedx=%e sigmaX2= %e ",
-  //               mod->GetLayer(),trackNumber,e,a1);
-  rpSSD.SetSigmaDetLocX2(a1);
-  a2 = fSz->GetRMS(); a2 *= a2; a2 += kRMSz*kRMSz;
-  //  if(a1>1.E5) printf(" sigmaZ2= %e RMSx=%e RMSz=%e\n",a2,fSx->GetRMS(),fSz->GetRMS());
-  rpSSD.SetSigmaZ2(a2);
-  rpSSD.SetDetectorIndex(mod->GetIndex());
-  rpSSD.SetLayer(mod->GetLayer());
+
   new (pt[fNrecp]) AliITSRecPoint(rpSSD);
   fNrecp++;
 
index 9cf7090..244b9b9 100644 (file)
@@ -210,29 +210,11 @@ Int_t AliITStrackerMI::LoadClusters(TTree *cTree) {
       Int_t ncl=clusters->GetEntriesFast();
       SignDeltas(clusters,GetZ());
  
-      //*** The Delta transformation
-      TGeoHMatrix delta; 
-      AliITSgeomTGeo::GetTrackingMatrix(j,delta);
-      TGeoHMatrix m;
-      AliITSgeomTGeo::GetOrigMatrix(j,m);
-      delta.MultiplyLeft(&(m.Inverse()));
-      const TGeoHMatrix *tm = AliITSgeomTGeo::GetTracking2LocalMatrix(j);
-      delta.MultiplyLeft(&(tm->Inverse())); 
-      //***
-
       while (ncl--) {
         AliITSRecPoint *c=(AliITSRecPoint*)clusters->UncheckedAt(ncl);
+        detector=c->GetDetectorIndex();
 
-        //*** Shift the cluster to the misaligned position
-        Double_t  xyz[3]={c->GetX(),c->GetY(),c->GetZ()};
-        Double_t mxyz[3]={0.};                    
-        
-        delta.LocalToMaster(xyz,mxyz);
-
-        c->SetX(mxyz[0]);
-        c->AliCluster::SetY(mxyz[1]);
-        c->AliCluster::SetZ(mxyz[2]);
-       //***
+       if (!c->Misalign()) AliWarning("Can't misalign this cluster !");
 
         fgLayers[i].InsertCluster(new AliITSRecPoint(*c));
       }
@@ -241,7 +223,7 @@ Int_t AliITStrackerMI::LoadClusters(TTree *cTree) {
       if (i<2){
        for (Float_t ydead = 0; ydead < 1.31 ; ydead+=(i+1.)*0.018){     
          Int_t lab[4] = {0,0,0,detector};
-         Int_t info[3] = {0,0,0};
+         Int_t info[3] = {0,0,i};
          Float_t hit[5]={0,0,0.004/12.,0.001/12.,0};
          if (i==0) hit[0] =ydead-0.4;
          if (i==1) hit[0]=ydead-3.75; 
index 996488a..592064c 100644 (file)
@@ -23,6 +23,7 @@
 
 #include <new>
 
+#include <TError.h>
 #include <TFile.h>
 #include <TTree.h>
 #include <TRandom.h>
@@ -183,29 +184,10 @@ Int_t AliITStrackerV2::LoadClusters(TTree *cTree) {
       if (!cTree->GetEvent(j)) continue;
       Int_t ncl=clusters->GetEntriesFast();
  
-      //*** The Delta transformation
-      TGeoHMatrix delta; 
-      AliITSgeomTGeo::GetTrackingMatrix(j,delta);
-      TGeoHMatrix m;
-      AliITSgeomTGeo::GetOrigMatrix(j,m);
-      delta.MultiplyLeft(&(m.Inverse()));
-      const TGeoHMatrix *tm = AliITSgeomTGeo::GetTracking2LocalMatrix(j);
-      delta.MultiplyLeft(&(tm->Inverse())); 
-      //***
-
       while (ncl--) {
         AliITSRecPoint *c=(AliITSRecPoint*)clusters->UncheckedAt(ncl);
 
-        //*** Shift the cluster to the misaligned position
-        Double_t  xyz[3]={c->GetX(),c->GetY(),c->GetZ()};
-        Double_t mxyz[3]={0.};                    
-        
-        delta.LocalToMaster(xyz,mxyz);
-
-        c->SetX(mxyz[0]);
-        c->AliCluster::SetY(mxyz[1]);
-        c->AliCluster::SetZ(mxyz[2]);
-       //***
+       if (!c->Misalign()) AliWarning("Can't misalign this cluster !");
 
         Int_t idx=c->GetDetectorIndex();
         AliITSdetector &det=fgLayers[i].GetDetector(idx);
index 18390de..0db6992 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
-
 //-------------------------------------------------------------------------
-//               Implementation of the Cluster class
-// that is the base for AliTPCcluster, AliITSclusterV2 and AliTRDcluster
-//      Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
+//                         Class AliCluster
+// This is the future base for managing the clusters in barrel detectors.
+// It is fully interfaced with the ROOT geometrical modeller TGeo.
+// Each cluster contains XYZ coordinates in the local tracking c.s. and
+// the unique ID of the sensitive detector element which continas the
+// cluster. The coordinates in global c.s. are computed using the interface
+// to TGeo and will be not overwritten by the derived sub-detector cluster
+// classes.
+//
+// cvetan.cheshkov@cern.ch & jouri.belikov@cern.ch    5/3/2007
 //-------------------------------------------------------------------------
 
+#include <TGeoManager.h>
+#include <TGeoMatrix.h>
+#include <TGeoPhysicalNode.h>
+
 #include "AliCluster.h"
+#include "AliLog.h"
+#include "AliAlignObj.h"
 
 ClassImp(AliCluster)
-//_____________________________________________________________________________
-AliCluster::AliCluster(): 
-  fY(0), fZ(0), fSigmaY2(0), fSigmaZ2(0) 
-{
-  //
-  //default constructor
-  //
+
+//______________________________________________________________________________
+AliCluster::AliCluster():
+  TObject(),
+  fX(0),
+  fY(0),
+  fZ(0),
+  fSigmaY2(0),
+  fSigmaZ2(0),
+  fSigmaYZ(0),
+  fVolumeId(0),
+  fIsMisaligned(kFALSE)
+{
+  // Default constructor
   fTracks[0]=fTracks[1]=fTracks[2]=-3141593; 
 }
 
-//_____________________________________________________________________________
-AliCluster::AliCluster(Int_t *lab, Float_t *hit): 
-  fY(hit[0]), fZ(hit[1]), fSigmaY2(hit[2]), fSigmaZ2(hit[3]) 
+//______________________________________________________________________________
+AliCluster::AliCluster(UShort_t volId,
+                              const Float_t *hit,
+                              Float_t x,
+                              Float_t sigyz,
+                              const Int_t *lab):
+  TObject(),
+  fX(x),
+  fY(hit[0]),
+  fZ(hit[1]),
+  fSigmaY2(hit[2]),
+  fSigmaZ2(hit[3]),
+  fSigmaYZ(sigyz),
+  fVolumeId(volId),
+  fIsMisaligned(kFALSE)
 {
-  //
-  // Creates a simulated cluster
-  //
-  fTracks[0]  = lab[0];
-  fTracks[1]  = lab[1];
-  fTracks[2]  = lab[2];
+  // Constructor
+  if (lab) {
+    fTracks[0] = lab[0];
+    fTracks[1] = lab[1];
+    fTracks[2] = lab[2];
+  }
+  else
+    fTracks[0]=fTracks[1]=fTracks[2]=-3141593; 
+}
+
+//______________________________________________________________________________
+AliCluster::AliCluster(UShort_t volId,
+                              Float_t x, Float_t y, Float_t z,
+                              Float_t sy2, Float_t sz2, Float_t syz,
+                              const Int_t *lab):
+  TObject(),
+  fX(x),
+  fY(y),
+  fZ(z),
+  fSigmaY2(sy2),
+  fSigmaZ2(sz2),
+  fSigmaYZ(syz),
+  fVolumeId(volId),
+  fIsMisaligned(kFALSE)
+{
+  // Constructor
+  if (lab) {
+    fTracks[0] = lab[0];
+    fTracks[1] = lab[1];
+    fTracks[2] = lab[2];
+  }
+  else
+    fTracks[0]=fTracks[1]=fTracks[2]=-3141593; 
+}
+
+//______________________________________________________________________________
+AliCluster::AliCluster(const AliCluster& cluster):
+  TObject(cluster),
+  fX(cluster.fX),
+  fY(cluster.fY),
+  fZ(cluster.fZ),
+  fSigmaY2(cluster.fSigmaY2),
+  fSigmaZ2(cluster.fSigmaZ2),
+  fSigmaYZ(cluster.fSigmaYZ),
+  fVolumeId(cluster.fVolumeId),
+  fIsMisaligned(cluster.fIsMisaligned)
+{
+  // Copy constructor
+  fTracks[0] = cluster.fTracks[0];
+  fTracks[1] = cluster.fTracks[1];
+  fTracks[2] = cluster.fTracks[2];
+}
+
+//______________________________________________________________________________
+AliCluster & AliCluster::operator=(const AliCluster& cluster)
+{
+  // Assignment operator
+
+  if(&cluster == this) return *this;
+
+  fX = cluster.fX;
+  fY = cluster.fY;
+  fZ = cluster.fZ;
+  fSigmaY2 = cluster.fSigmaY2;
+  fSigmaZ2 = cluster.fSigmaZ2;
+  fSigmaYZ = cluster.fSigmaYZ;
+  fVolumeId = cluster.fVolumeId;
+  fIsMisaligned = cluster.fIsMisaligned;
+
+  fTracks[0] = cluster.fTracks[0];
+  fTracks[1] = cluster.fTracks[1];
+  fTracks[2] = cluster.fTracks[2];
+
+  return *this;
+}
+
+//______________________________________________________________________________
+Bool_t AliCluster::GetGlobalXYZ(Float_t xyz[3]) const
+{
+  // Get the global coordinates of the cluster
+  // All the needed information is taken only
+  // from TGeo.
+
+  xyz[0] = xyz[1] = xyz[2] = 0;
+
+  if (!gGeoManager || !gGeoManager->IsClosed()) {
+    AliError("Can't get the global coordinates! gGeoManager doesn't exist or it is still opened!");
+    return kFALSE;
+  }
+
+  const TGeoHMatrix *mt = GetTracking2LocalMatrix();
+  if (!mt) return kFALSE;
+  Double_t txyz[3] = {fX, fY, fZ};
+  Double_t lxyz[3] = {0, 0, 0};
+  mt->LocalToMaster(txyz,lxyz);
+
+  TGeoHMatrix *ml = GetMatrix();
+  if (!ml) return kFALSE;
+  Double_t gxyz[3] = {0, 0, 0};
+  ml->LocalToMaster(lxyz,gxyz);
+  xyz[0] = gxyz[0]; xyz[1] = gxyz[1]; xyz[2] = gxyz[2];
+  return kTRUE;
+}
+
+//______________________________________________________________________________
+Bool_t AliCluster::GetGlobalCov(Float_t cov[6]) const
+{
+  // Get the global covariance matrix of the cluster coordinates
+  // All the needed information is taken only
+  // from TGeo.
+  for (Int_t i = 0; i < 6; i++) cov[i] = 0;
+
+  if (!gGeoManager || !gGeoManager->IsClosed()) {
+    AliError("Can't get the global coordinates! gGeoManager doesn't exist or it is still opened!");
+    return kFALSE;
+  }
+
+  const TGeoHMatrix *mt = GetTracking2LocalMatrix();
+  if (!mt) return kFALSE;
+
+  TGeoHMatrix *ml = GetMatrix();
+  if (!ml) return kFALSE;
+
+  TGeoHMatrix m;
+  Double_t tcov[9] = { 0, 0, 0, 0, fSigmaY2, fSigmaYZ, 0, fSigmaYZ, fSigmaZ2 };
+  m.SetRotation(tcov);
+  m.Multiply(&mt->Inverse());
+  m.Multiply(&ml->Inverse());
+  m.MultiplyLeft(mt);
+  m.MultiplyLeft(ml);
+  Double_t *ncov = m.GetRotationMatrix();
+  cov[0] = ncov[0]; cov[1] = ncov[1]; cov[2] = ncov[2];
+  cov[3] = ncov[4]; cov[4] = ncov[5];
+  cov[5] = ncov[8];
+
+  return kTRUE;
+}
+
+//______________________________________________________________________________
+Bool_t AliCluster::GetXRefPlane(Float_t &xref) const
+{
+  // Get the distance between the origin and the ref.plane.
+  // All the needed information is taken only
+  // from TGeo.
+  xref = 0;
+
+  const TGeoHMatrix *mt = GetTracking2LocalMatrix();
+  if (!mt) return kFALSE;
+
+  TGeoHMatrix *ml = GetMatrix();
+  if (!ml) return kFALSE;
+
+  TGeoHMatrix m = *mt;
+  m.MultiplyLeft(ml);
+
+  xref = (m.Inverse()).GetTranslation()[0];
+  return kTRUE;
+}
+
+//______________________________________________________________________________
+Bool_t AliCluster::Misalign()
+{
+  // ...
+  // All the needed information is taken only
+  // from TGeo.
+  if (!gGeoManager || !gGeoManager->IsClosed()) {
+    AliError("Can't get the PN entry! gGeoManager doesn't exist or it is still opened!");
+    return kFALSE;
+  }
+
+  if (fIsMisaligned) {
+    AliError("The cluster was already misaligned!");
+    return kFALSE;
+  }
+
+  const TGeoHMatrix *mt = GetTracking2LocalMatrix();
+  if (!mt) return kFALSE;
+
+  TGeoHMatrix *ml = GetMatrix();
+  if (!ml) return kFALSE;
+
+  TGeoHMatrix *mlorig = GetMatrix(kTRUE);
+  if (!mlorig) return kFALSE;
+
+  TGeoHMatrix delta = *mt;
+  delta.MultiplyLeft(ml);
+  delta.MultiplyLeft(&(mlorig->Inverse()));
+  delta.MultiplyLeft(&(mt->Inverse()));
+
+  Double_t xyzorig[3] = {fX, fY, fZ};
+  Double_t xyz[3] = {0, 0, 0};
+  delta.LocalToMaster(xyzorig,xyz);
+  fX = xyz[0]; fY = xyz[1]; fZ = xyz[2];
+  fIsMisaligned = kTRUE;
+  return kTRUE;
+}
+
+//______________________________________________________________________________
+TGeoHMatrix* AliCluster::GetMatrix(Bool_t original) const
+{
+  // Get the matrix which transforms from the
+  // local TGeo alignable volume c.s. to the global one.
+  // In case the cluster was already misaligned, get the
+  // ideal matrix from TGeo. The option 'original'
+  // can be used to force the calculation of the ideal
+  // matrix.
+  if (!fIsMisaligned && (original == kFALSE)) {
+    TGeoPNEntry *pne = GetPNEntry();
+    if (!pne) return NULL;
+
+    TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
+    if (pnode) return pnode->GetMatrix();
+
+    const char* path = pne->GetTitle();
+    if (!gGeoManager->cd(path)) {
+      AliError(Form("Volume path %s not valid!",path));
+      return NULL;
+    }
+    return gGeoManager->GetCurrentMatrix();
+  }
+  else {
+    const char* symname = AliAlignObj::SymName(fVolumeId);
+    if (!symname) return NULL;
+
+    static TGeoHMatrix m;
+    if (AliAlignObj::GetOrigGlobalMatrix(symname,m))
+      return &m;
+    else
+      return NULL;
+  }
+}
+
+//______________________________________________________________________________
+const TGeoHMatrix* AliCluster::GetTracking2LocalMatrix() const
+{
+  // Get the matrix which is stored with the PN entries in TGeo.
+  // The matrix makes the transformation from the tracking c.s. to
+  // global one.
+  TGeoPNEntry *pne = GetPNEntry();
+  if (!pne) return NULL;
+
+  const TGeoHMatrix *m = pne->GetMatrix();
+  if (!m)
+    AliError(Form("TGeoPNEntry (%s) contains no matrix !",pne->GetName()));
+
+  return m;
+}
+
+//______________________________________________________________________________
+TGeoPNEntry* AliCluster::GetPNEntry() const
+{
+  // Get a pointer to the physical node entry
+  // corresponding to the alignable volume to
+  // which the cluster belongs
+
+  if (!gGeoManager || !gGeoManager->IsClosed()) {
+    AliError("Can't get the PN entry! gGeoManager doesn't exist or it is still opened!");
+    return NULL;
+  }
+
+  const char* symname = AliAlignObj::SymName(fVolumeId);
+  if (!symname) return NULL;
+
+  TGeoPNEntry* pne = gGeoManager->GetAlignableEntry(symname);
+  if (!pne)
+    AliError(Form("The symbolic volume name %s does not correspond to a physical entry!",
+                 symname));
+  return pne;
 }
index f33deb8..e88b0b7 100644 (file)
@@ -3,56 +3,82 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* $Id$ */
-
 //-------------------------------------------------------------------------
-//                          Class AliCluster
-//                Generic class for clusters
-//       Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch 
+//                         Class AliCluster
+// This is the future base for managing the clusters in barrel detectors.
+// It is fully interfaced with the ROOT geometrical modeller TGeo.
+// Each cluster contains XYZ coordinates in the local tracking c.s. and
+// the unique ID of the sensitive detector element which continas the
+// cluster. The coordinates in global c.s. are computed using the interface
+// to TGeo and will be not overwritten by the derived sub-detector cluster
+// classes.
+//
+// cvetan.cheshkov@cern.ch  & jouri.belikov@cern.ch     5/3/2007
 //-------------------------------------------------------------------------
 
 #include <TObject.h>
 
-//_____________________________________________________________________________
+class TGeoHMatrix;
+class TGeoPNEntry;
+
 class AliCluster : public TObject {
-public:
+ public:
   AliCluster();
+  AliCluster(UShort_t volId, const Float_t *hit, Float_t x = 0, Float_t sigyz = 0, const Int_t *lab = NULL);
+  AliCluster(UShort_t volId,
+                Float_t x, Float_t y, Float_t z,
+                Float_t sy2, Float_t sz2, Float_t syz,
+                const Int_t *lab = NULL);
+  AliCluster(const AliCluster& cluster);
+  AliCluster &operator=(const AliCluster& cluster);
   virtual ~AliCluster() {;}
-  AliCluster(Int_t *lab, Float_t *hit);
-  void SetLabel(Int_t lab, Int_t i) {fTracks[i]=lab;}
-
-  virtual void SetX(Float_t /*x*/){}
-  virtual void SetY(Float_t y)      {fY=y;}
-  virtual void SetZ(Float_t z)      {fZ=z;}
-  virtual void SetDetector(Int_t /*detector*/) {}
-  void SetSigmaY2(Float_t sy2)      {fSigmaY2=sy2;}
-  void SetSigmaZ2(Float_t sz2)      {fSigmaZ2=sz2;}
-
-  Int_t GetLabel(Int_t i) const {return fTracks[i];}
-  virtual Float_t GetX()          const {return 0;}
-  Float_t GetY()          const {return fY;}
-  Float_t GetZ()          const {return fZ;}
-  virtual Int_t GetDetector()  const {return 0;}
-  Float_t GetSigmaY2()    const {return fSigmaY2;}
-  Float_t GetSigmaZ2()    const {return fSigmaZ2;}
-
-  //PH  virtual void Use() = 0;
-  //PH The pure virtual function has been temporarily replaced by 
-  //PH virtual function with empty body. This correction somehow helps
-  //PH to write/read TClonesArray with AliITSclusterV2 objects, but obviously
-  //PH hides some more tricky problems (to be investigated)
+
+  Int_t    GetLabel(Int_t i) const {return fTracks[i];}
+  Float_t  GetX()            const {return fX;}
+  Float_t  GetY()            const {return fY;}
+  Float_t  GetZ()            const {return fZ;}
+  Float_t  GetSigmaY2()      const {return fSigmaY2;}
+  Float_t  GetSigmaZ2()      const {return fSigmaZ2;}
+  Float_t  GetSigmaYZ()      const {return fSigmaYZ;}
+  UShort_t GetVolumeId()     const {return fVolumeId;}
+
   virtual void Use(Int_t = 0) {;}
 
-protected:
-  Int_t     fTracks[3];//labels of overlapped tracks
-  Float_t   fY ;       //Y of cluster
-  Float_t   fZ ;       //Z of cluster
-  Float_t   fSigmaY2;  //Sigma Y square of cluster
-  Float_t   fSigmaZ2;  //Sigma Z square of cluster
-  
-  ClassDef(AliCluster,2)  // Time Projection Chamber clusters
-};
+  Bool_t   GetGlobalXYZ(Float_t xyz[3]) const;
+  Bool_t   GetGlobalCov(Float_t cov[6]) const;
+  Bool_t   GetXRefPlane(Float_t &xref) const;
 
-#endif
+  Bool_t   Misalign();
+
+  void     SetLabel(Int_t lab,Int_t i)
+  { if (i>=0 && i<3) fTracks[i] = lab;}
+  void     SetX(Float_t x) {fX = x;}
+  void     SetY(Float_t y) {fY = y;}
+  void     SetZ(Float_t z) {fZ = z;}
+  void     SetSigmaY2(Float_t sigy2) {fSigmaY2 = sigy2;}
+  void     SetSigmaZ2(Float_t sigz2) {fSigmaZ2 = sigz2;}
+  void     SetVolumeId(UShort_t id)  {fVolumeId = id;}
 
+ protected:
 
+  const TGeoHMatrix*   GetTracking2LocalMatrix() const;
+
+ private:
+
+  TGeoHMatrix*         GetMatrix(Bool_t original = kFALSE) const;
+  TGeoPNEntry*         GetPNEntry() const;
+
+  Int_t    fTracks[3];//MC labels
+  Float_t  fX;        // X of the cluster in the tracking c.s.
+  Float_t  fY;        // Y of the cluster in the tracking c.s.
+  Float_t  fZ;        // Z of the cluster in the tracking c.s.
+  Float_t  fSigmaY2;  // Sigma Y square of cluster
+  Float_t  fSigmaZ2;  // Sigma Z square of cluster
+  Float_t  fSigmaYZ;  // Non-diagonal element of cov.matrix
+  UShort_t fVolumeId; // Volume ID of the detector element
+  Bool_t   fIsMisaligned; // Cluster was misagned or not?
+
+  ClassDef(AliCluster,3) // Barrel detectors cluster
+};
+
+#endif
index a4c3e84..54d8e12 100644 (file)
@@ -52,6 +52,26 @@ AliClusterTGeo::AliClusterTGeo():
   fTracks[0]=fTracks[1]=fTracks[2]=-3141593; 
 }
 
+//_____________________________________________________________________________
+AliClusterTGeo::AliClusterTGeo(Int_t *lab, Float_t *hit): 
+  TObject(),
+  fX(0),
+  fY(hit[0]),
+  fZ(hit[1]),
+  fSigmaY2(hit[2]),
+  fSigmaZ2(hit[3]),
+  fSigmaYZ(0),
+  fVolumeId(0),
+  fIsMisaligned(kFALSE)
+{
+  //
+  // Creates a simulated cluster
+  //
+  fTracks[0]  = lab[0];
+  fTracks[1]  = lab[1];
+  fTracks[2]  = lab[2];
+}
+
 //______________________________________________________________________________
 AliClusterTGeo::AliClusterTGeo(UShort_t volId,
                               const Float_t *hit,
index 85d295b..9629c11 100644 (file)
@@ -24,6 +24,7 @@ class TGeoPNEntry;
 class AliClusterTGeo : public TObject {
  public:
   AliClusterTGeo();
+  AliClusterTGeo(Int_t *lab, Float_t *hit);
   AliClusterTGeo(UShort_t volId, const Float_t *hit, Float_t x = 0, Float_t sigyz = 0, const Int_t *lab = NULL);
   AliClusterTGeo(UShort_t volId,
                 Float_t x, Float_t y, Float_t z,
@@ -51,7 +52,8 @@ class AliClusterTGeo : public TObject {
   Bool_t   Misalign();
 
   void     SetLabel(Int_t lab,Int_t i)
-  { if (i>0 && i<3) fTracks[i] = lab;}
+  { if (i>=0 && i<3) fTracks[i] = lab;}
+  void     SetX(Float_t x) {fX = x;}
   void     SetY(Float_t y) {fY = y;}
   void     SetZ(Float_t z) {fZ = z;}
   void     SetSigmaY2(Float_t sigy2) {fSigmaY2 = sigy2;}
@@ -76,7 +78,7 @@ class AliClusterTGeo : public TObject {
   UShort_t fVolumeId; // Volume ID of the detector element
   Bool_t   fIsMisaligned; // Cluster was misagned or not?
 
-  ClassDef(AliClusterTGeo,1) // Barrel detectors cluster
+  ClassDef(AliClusterTGeo,3) // Barrel detectors cluster
 };
 
 #endif
index 4d9a325..22232c0 100644 (file)
@@ -25,9 +25,9 @@
 
 ClassImp(AliTPCcluster)
 //
-AliTPCcluster:: AliTPCcluster(Int_t *lab, Float_t *hit)
-              :AliCluster(lab,hit),
-               fQ(0.)
+AliTPCcluster::AliTPCcluster(Int_t *lab, Float_t *hit):
+  AliCluster(0,hit,0.,0.,lab),
+  fQ(0.)
 {
   //
   // constructor
index 72afac8..49d8ba6 100644 (file)
@@ -35,7 +35,6 @@ ClassImp(AliTPCclusterMI)
 
 AliTPCclusterMI::AliTPCclusterMI(Bool_t withInfo):
   AliCluster(),
-  fX(0),
   fQ(0),
   fType(0),
   fMax(0),
@@ -54,7 +53,6 @@ AliTPCclusterMI::AliTPCclusterMI(Bool_t withInfo):
 
 AliTPCclusterMI::AliTPCclusterMI(const AliTPCclusterMI & cluster):
   AliCluster(cluster),
-  fX(cluster.fX),
   fQ(cluster.fQ),
   fType(cluster.fType),
   fMax(cluster.fMax),
@@ -80,7 +78,6 @@ AliTPCclusterMI & AliTPCclusterMI::operator = (const AliTPCclusterMI & cluster)
   //  AliInfo("Asignment operator\n");
 
   (AliCluster&)(*this) = (AliCluster&)cluster;
-  fX    = cluster.fX;
   fQ    = cluster.fQ;
   fType = cluster.fType;
   fMax  = cluster.fMax;
@@ -98,8 +95,7 @@ AliTPCclusterMI & AliTPCclusterMI::operator = (const AliTPCclusterMI & cluster)
 
 
 AliTPCclusterMI::AliTPCclusterMI(Int_t *lab, Float_t *hit) : 
-  AliCluster(lab,hit),
-  fX(0),
+  AliCluster(0,hit,0.,0.,lab),
   fQ(0),
   fType(0),
   fMax(0),
@@ -137,5 +133,5 @@ Int_t AliTPCclusterMI::Compare(const TObject* obj) const
   //
   // compare according y
   AliTPCclusterMI * o2 = (AliTPCclusterMI*)obj;
-  return (o2->GetY()>fY)? -1:1; 
+  return (o2->GetY()>GetY())? -1:1; 
 }
index 421f44c..cf776e9 100644 (file)
@@ -24,8 +24,6 @@ public:
   virtual Bool_t IsSortable() const; 
   virtual Int_t Compare(const TObject* obj) const;
   inline  void Use(Int_t inc=10);
-  virtual Float_t GetX() const { return fX;}
-  virtual void  SetX(Float_t x) { fX = x;}
   virtual Int_t GetDetector() const {return fDetector;}
   virtual Int_t GetRow() const {return fRow;}
   virtual void SetDetector(Int_t detector){fDetector = (UChar_t)(detector%256);}
@@ -46,7 +44,6 @@ public:
   void SetInfo(AliTPCclusterInfo * info) { fInfo = info;}
 
 private:
-  Float_t   fX;        //X position of cluster
   Short_t   fQ ;       //Q of cluster (in ADC counts)  
   Char_t    fType;     //type of the cluster 0 means golden 
   Short_t   fMax;      //maximal amplitude in cluster
@@ -56,7 +53,7 @@ private:
   Float_t   fTimeBin;  //time bin coordinate
   Float_t   fPad;  //pad coordinate
   AliTPCclusterInfo * fInfo;  // pointer to the cluster debug info
-  ClassDef(AliTPCclusterMI,3)  // Time Projection Chamber clusters
+  ClassDef(AliTPCclusterMI,4)  // Time Projection Chamber clusters
 };
 
 void AliTPCclusterMI::Use(Int_t inc) 
index 6095121..d62e100 100644 (file)
@@ -1177,7 +1177,7 @@ Int_t  AliTPCtrackerMI::LoadClusters()
     Int_t sec,row;
     fParam->AdjustSectorRow(clrow->GetID(),sec,row);
     for (Int_t icl=0; icl<clrow->GetArray()->GetEntriesFast(); icl++){
-      Transform((AliCluster*)(clrow->GetArray()->At(icl)));
+      Transform((AliTPCclusterMI*)(clrow->GetArray()->At(icl)));
     }
     //
     AliTPCRow * tpcrow=0;
@@ -1241,7 +1241,7 @@ void AliTPCtrackerMI::UnloadClusters()
   return ;
 }
 
-void   AliTPCtrackerMI::Transform(AliCluster * cluster){
+void   AliTPCtrackerMI::Transform(AliTPCclusterMI * cluster){
   //
   // 
   //
@@ -1254,9 +1254,9 @@ void   AliTPCtrackerMI::Transform(AliCluster * cluster){
   else{
     // chack Loading of Geo matrices from GeoManager - TEMPORARY FIX
   }
-  cluster->SetX(posC[0]);
-  cluster->SetY(posC[1]);
-  cluster->SetZ(posC[2]);
+  //cluster->SetX(posC[0]);
+  //cluster->SetY(posC[1]);
+  //cluster->SetZ(posC[2]);
 }
 
 //_____________________________________________________________________________
index fe720c8..bc7d95e 100644 (file)
@@ -42,7 +42,7 @@ public:
   virtual Int_t LoadClusters (TTree * tree);
   Int_t  LoadClusters();
   void   UnloadClusters();
-  void   Transform(AliCluster * cluster);
+  void   Transform(AliTPCclusterMI * cluster);
   //
   void SetIO();  //set default IO from folders
   void SetIO(TTree * input, TTree * output, AliESD * event);
index 49fc165..3f83072 100644 (file)
@@ -61,17 +61,17 @@ AliTRDcluster::AliTRDcluster(const AliTRDrecPoint &p)
   // Constructor from AliTRDrecPoint
   //
 
-  fTracks[0] = p.GetTrackIndex(0);
-  fTracks[1] = p.GetTrackIndex(1);
-  fTracks[2] = p.GetTrackIndex(2);
-  fY         = p.GetY();
-  fZ         = p.GetZ();
+  SetLabel(p.GetTrackIndex(0),0);
+  SetLabel(p.GetTrackIndex(1),1);
+  SetLabel(p.GetTrackIndex(2),2);
+  SetY(p.GetY());
+  SetZ(p.GetZ());
 
   //fSigmaY2   = p.GetSigmaY2();
   //fSigmaZ2   = p.GetSigmaZ2();  
   // Why is this ????
-  fSigmaY2   = 0.2;
-  fSigmaZ2   = 5.0;  
+  SetSigmaY2(0.2);
+  SetSigmaZ2(5.0);  
 
 }
 
@@ -89,14 +89,14 @@ AliTRDcluster::AliTRDcluster(const AliTRDcluster &c)
   // Copy constructor 
   //
 
-  fTracks[0] = c.GetLabel(0);
-  fTracks[1] = c.GetLabel(1);
-  fTracks[2] = c.GetLabel(2);
+  SetLabel(c.GetLabel(0),0);
+  SetLabel(c.GetLabel(1),1);
+  SetLabel(c.GetLabel(2),2);
 
-  fY         = c.GetY();
-  fZ         = c.GetZ();
-  fSigmaY2   = c.GetSigmaY2();
-  fSigmaZ2   = c.GetSigmaZ2();  
+  SetY(c.GetY());
+  SetZ(c.GetZ());
+  SetSigmaY2(c.GetSigmaY2());
+  SetSigmaZ2(c.GetSigmaZ2());  
 
   for (Int_t i = 0; i < 7; i++) {
     fSignals[i] = c.fSignals[i];