Release version of ITS code
authorfca <fca@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 Jul 2000 16:07:20 +0000 (16:07 +0000)
committerfca <fca@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 Jul 2000 16:07:20 +0000 (16:07 +0000)
124 files changed:
ITS/AliITS.cxx
ITS/AliITS.h
ITS/AliITSAlignmentModule.cxx [new file with mode: 0644]
ITS/AliITSAlignmentModule.h [new file with mode: 0644]
ITS/AliITSAlignmentTrack.cxx [new file with mode: 0644]
ITS/AliITSAlignmentTrack.h [new file with mode: 0644]
ITS/AliITSClusterFinder.cxx
ITS/AliITSClusterFinder.h
ITS/AliITSClusterFinderSDD.cxx
ITS/AliITSClusterFinderSDD.h
ITS/AliITSClusterFinderSPD.cxx
ITS/AliITSClusterFinderSPD.h
ITS/AliITSClusterFinderSSD.cxx
ITS/AliITSClusterFinderSSD.h
ITS/AliITSDetType.h
ITS/AliITSHuffman.cxx
ITS/AliITSHuffman.h
ITS/AliITSMap.cxx
ITS/AliITSMap.h
ITS/AliITSMapA1.cxx [new file with mode: 0644]
ITS/AliITSMapA1.h [new file with mode: 0644]
ITS/AliITSMapA2.cxx [new file with mode: 0644]
ITS/AliITSMapA2.h [new file with mode: 0644]
ITS/AliITSRawCluster.cxx
ITS/AliITSRawCluster.h
ITS/AliITSRecPoint.cxx [new file with mode: 0644]
ITS/AliITSRecPoint.h
ITS/AliITSclusterSSD.cxx
ITS/AliITSclusterSSD.h
ITS/AliITSdcsSSD.cxx
ITS/AliITSdcsSSD.h
ITS/AliITSdictSSD.cxx
ITS/AliITSdictSSD.h
ITS/AliITSdigit.cxx
ITS/AliITSdigit.h
ITS/AliITSdisplay.cxx [new file with mode: 0644]
ITS/AliITSdisplay.h [new file with mode: 0644]
ITS/AliITSetfSDD.cxx
ITS/AliITSetfSDD.h
ITS/AliITSgeom.cxx
ITS/AliITSgeom.h
ITS/AliITSgeomSDD.cxx
ITS/AliITSgeomSDD.h
ITS/AliITSgeomSPD.cxx
ITS/AliITSgeomSPD300.cxx
ITS/AliITSgeomSPD425.cxx
ITS/AliITSgeomSSD.cxx
ITS/AliITSgeomSSD.h
ITS/AliITShit.cxx
ITS/AliITShit.h
ITS/AliITSmodule.cxx
ITS/AliITSpackageSSD.cxx
ITS/AliITSpackageSSD.h
ITS/AliITSpoints.cxx [new file with mode: 0644]
ITS/AliITSpoints.h [new file with mode: 0644]
ITS/AliITSresponse.cxx [new file with mode: 0644]
ITS/AliITSresponse.h
ITS/AliITSresponseSDD.cxx
ITS/AliITSresponseSDD.h
ITS/AliITSresponseSPD.h
ITS/AliITSresponseSSD.cxx
ITS/AliITSresponseSSD.h
ITS/AliITSsegmentation.cxx [new file with mode: 0644]
ITS/AliITSsegmentation.h
ITS/AliITSsegmentationSDD.cxx
ITS/AliITSsegmentationSDD.h
ITS/AliITSsegmentationSPD.cxx
ITS/AliITSsegmentationSPD.h
ITS/AliITSsegmentationSSD.cxx
ITS/AliITSsegmentationSSD.h
ITS/AliITSsimulation.h
ITS/AliITSsimulationFastPoints.cxx
ITS/AliITSsimulationFastPoints.h
ITS/AliITSsimulationFastPointsV0.cxx [new file with mode: 0644]
ITS/AliITSsimulationFastPointsV0.h [new file with mode: 0644]
ITS/AliITSsimulationSDD.cxx
ITS/AliITSsimulationSDD.h
ITS/AliITSsimulationSPD.cxx
ITS/AliITSsimulationSPD.h
ITS/AliITSsimulationSSD.cxx
ITS/AliITSsimulationSSD.h
ITS/AliITSstatistics.cxx
ITS/AliITSstatistics.h
ITS/AliITSstatistics2.cxx
ITS/AliITSstatistics2.h
ITS/AliITStrack.cxx [new file with mode: 0644]
ITS/AliITStrack.h [new file with mode: 0644]
ITS/AliITSv1.cxx
ITS/AliITSv1.h
ITS/AliITSv3.cxx
ITS/AliITSv3.h
ITS/AliITSv5.cxx
ITS/AliITSv5.h
ITS/AliITSvtest.cxx [new file with mode: 0644]
ITS/AliITSvtest.h [new file with mode: 0644]
ITS/AlignITSmacro.C [new file with mode: 0644]
ITS/AlignITSmacro2.C [new file with mode: 0644]
ITS/AlignITSmacro3.C [new file with mode: 0644]
ITS/AlignITSmacro3A.C [new file with mode: 0644]
ITS/AlignITSmacro3B.C [new file with mode: 0644]
ITS/AlignITSmacro3C.C [new file with mode: 0644]
ITS/AlignITSmacro3R.C [new file with mode: 0644]
ITS/AlignITSmacro3Rphi.C [new file with mode: 0644]
ITS/AlignITSmacro3Z.C [new file with mode: 0644]
ITS/AnalysisITSAlignment.cxx [new file with mode: 0644]
ITS/AnalysisITSAlignment.h [new file with mode: 0644]
ITS/Config.C
ITS/ITSDigitsToClusters.C [new file with mode: 0644]
ITS/ITSHitsToDigits.C [new file with mode: 0644]
ITS/ITSHitsToFastPoints.C [new file with mode: 0644]
ITS/ITSLinkDef.h
ITS/ITSdigitsTest.C
ITS/ITShuffman.C [new file with mode: 0644]
ITS/ITSmixedpoints.C [new file with mode: 0644]
ITS/ITSreadClustTest.C [new file with mode: 0644]
ITS/ITSreadRecPointsTest.C [new file with mode: 0644]
ITS/ITSreadTest.C [new file with mode: 0644]
ITS/ITSstream.C [new file with mode: 0644]
ITS/Makefile
ITS/SPD_ntuple.C [new file with mode: 0644]
ITS/SPDclusterTest.C [new file with mode: 0644]
ITS/vertex.cxx [new file with mode: 0755]
ITS/vertex.h [new file with mode: 0755]
ITS/vertexmacro.C [new file with mode: 0755]

index fcb1c27..8525fde 100644 (file)
 
 /*
 $Log$
-Revision 1.15  2000/06/28 14:41:12  fca
-Corrections to the custom Streamer
-
-Revision 1.14  2000/06/15 09:27:52  barbera
-Problems with the HP compiler fixed
-
-Revision 1.13  2000/06/13 15:32:44  nilsen
-fix compilation error on HP and DEC unix.
-
-Revision 1.12  2000/06/12 23:43:16  nilsen
-New ITS code replacing the old structure and simulations code.
-
-Revision 1.9.2.8  2000/06/12 18:05:59  barbera
-fixed posible compilation errors on HP unix
-
-Revision 1.9.2.7  2000/06/11 20:20:18  barbera
-New AliITS base clase  for the new structure.
-
 Revision 1.9.2.3  2000/02/02 13:42:09  barbera
 fixed AliITS.cxx for new AliRun structure. Added ITS hits list to list of hits which will have their track numbers updated
 
@@ -104,7 +86,6 @@ the AliITS class.
 #include <TRandom.h>
 #include <TVector.h>
 #include <TObjArray.h>
-#include <TClonesArray.h>
 #include <TROOT.h>
 #include <TObjectTable.h>
 
@@ -113,16 +94,16 @@ the AliITS class.
 #include "AliRun.h"
 #include "AliITS.h"
 #include "AliITSMap.h"
+#include "AliITSDetType.h"
 #include "AliITSClusterFinder.h"
 #include "AliITSsimulation.h"
-#include "AliITSsimulationFastPoints.h"
 #include "AliITSsegmentationSPD.h"
 #include "AliITSresponseSPD.h"
 #include "AliITSsegmentationSDD.h"
 #include "AliITSresponseSDD.h"
 #include "AliITSsegmentationSSD.h"
 #include "AliITSresponseSSD.h"
-//#include "AliITStrack.h"
+
 
 
 ClassImp(AliITS)
@@ -140,13 +121,14 @@ AliITS::AliITS() : AliDetector() {
 
   fIshunt     = 0;
   fEuclidOut  = 0;
+
+  //fNDetTypes = fgkNTYPES;
   fIdN        = 0;
   fIdName     = 0;
   fIdSens     = 0;
   fITSmodules = 0;
   //
   fDetTypes   = 0;
-  SetNDetTypes();
   //
   fDtype  = 0;
   fNdtype = 0;
@@ -154,6 +136,7 @@ AliITS::AliITS() : AliDetector() {
   fNctype = 0;
   fRecPoints = 0;
   fNRecPoints = 0;
+  fTreeC = 0;
   //
   fITSgeom=0;
 }
@@ -176,16 +159,19 @@ AliITS::AliITS(const char *name, const char *title):AliDetector(name,title){
   fHits       = new TClonesArray("AliITShit", 1560);
   gAlice->AddHitList(fHits);
 
-  SetNDetTypes();
+  //fNDetTypes = fgkNTYPES;
+
+  fNdtype = new Int_t[fgkNTYPES];
+  fDtype = new TObjArray(fgkNTYPES);
+
+  fNctype = new Int_t[fgkNTYPES];
+  fCtype = new TObjArray(fgkNTYPES);
 
-  fNdtype = 0;
-  fDtype = 0;
-  fCtype  = 0;
-  fNctype = 0;
 
   fRecPoints = 0;
   fNRecPoints = 0;
 
+  fTreeC = 0;
 
   fITSmodules = 0; 
 
@@ -195,38 +181,38 @@ AliITS::AliITS(const char *name, const char *title):AliDetector(name,title){
   fIdName     = 0;
   fIdSens     = 0;
  
-  fDetTypes = new TObjArray(fNDetTypes);  
+  fDetTypes = new TObjArray(fgkNTYPES);  
 
   Int_t i;
-  for(i=0;i<fNDetTypes;i++) {
+  for(i=0;i<fgkNTYPES;i++) {
     (*fDetTypes)[i]=new AliITSDetType(); 
+    fNdtype[i]=0;
+    fNctype[i]=0;
    }
   //
 
-   fNdtype = new Int_t[fNDetTypes];
-   fDtype = new TObjArray(fNDetTypes);
-
-   fNctype = new Int_t[fNDetTypes];
-   fCtype = new TObjArray(fNDetTypes);
-
   SetMarkerColor(kRed);
 
   fITSgeom=0;
 }
 //___________________________________________________________________________
 AliITS::AliITS(AliITS &source){
+  // copy constructor
   if(this==&source) return;
   printf("Error: You are not allowed to make a copy of the AliITS\n");
   exit(1);
 }
 //____________________________________________________________________________
 AliITS& AliITS::operator=(AliITS &source){
+  // assignment operator
   if(this==&source) return *this;
   printf("Error: You are not allowed to make a copy of the AliITS\n");
   exit(1);
+  return *this; //fake return
 }
 //____________________________________________________________________________
 void AliITS::ClearModules(){
+
   //clear the modules TObjArray
   Int_t i;
 
@@ -236,12 +222,13 @@ void AliITS::ClearModules(){
        Int_t indSDD = fITSgeom->GetModuleIndex(4,fITSgeom->GetNladders(4),
                                                fITSgeom->GetNdetectors(4));
       for(i=0;i<fITSmodules->GetEntriesFast();i++){
+            if(!fITSmodules->At(i)) continue;
            if(i<indSPD)
-               delete (AliITSmodule *) fITSmodules->At(i);
+             delete (AliITSmodule *) fITSmodules->At(i);
            else if(i<indSDD)
-               delete (AliITSmodule *) fITSmodules->At(i);
+             delete (AliITSmodule *) fITSmodules->At(i);
            else
-               delete (AliITSmodule *) fITSmodules->At(i);
+             delete (AliITSmodule *) fITSmodules->At(i);
       } // end for i
   }// end if fITSmodules!=0
 
@@ -269,13 +256,13 @@ AliITS::~AliITS(){
   //
   Int_t i;
   if(fDtype) {
-    for(i=0;i<fNDetTypes;i++) {
+    for (i=0;i<fgkNTYPES;i++) {
       delete (*fDtype)[i];
       fNdtype[i]=0;
     }
   }
 
-  for(i=0;i<fNDetTypes;i++) {
+  for (i=0;i<fgkNTYPES;i++) {
       delete (*fCtype)[i];
       fNctype[i]=0;
   }
@@ -288,7 +275,7 @@ AliITS::~AliITS(){
   }
 
   if (fTreeC) delete fTreeC;
-  
+
 }
 
 //___________________________________________
@@ -299,7 +286,7 @@ AliITSDetType* AliITS::DetType(Int_t id)
 
 }
 //___________________________________________
-void AliITS::SetClasses(Int_t id, char* digit, char* cluster)
+void AliITS::SetClasses(Int_t id, const char *digit, const char *cluster)
 {
   //set the digit and cluster classes to be used for the id detector type
     ((AliITSDetType*) (*fDetTypes)[id])->ClassNames(digit,cluster);
@@ -363,13 +350,11 @@ void AliITS::AddRealDigit(Int_t id, Int_t *digits)
 
 }
 //_____________________________________________________________________________
-void AliITS::AddDigit(Int_t id, AliITSdigit *d) 
+void AliITS::AddSimDigit(Int_t id, AliITSdigit *d) 
 {
 
   // add a simulated digit
 
-  // should have ctors of type AliITSdigitSDD(const AliITSdigitSDD &)
-
   TClonesArray &ldigits = *((TClonesArray*)(*fDtype)[id]);
 
   switch(id)
@@ -388,7 +373,7 @@ void AliITS::AddDigit(Int_t id, AliITSdigit *d)
 }
 
 //_____________________________________________________________________________
-void AliITS::AddDigit(Int_t id,Float_t phys,Int_t *digits,Int_t *tracks,Float_t *charges){
+void AliITS::AddSimDigit(Int_t id,Float_t phys,Int_t *digits,Int_t *tracks,Int_t *hits,Float_t *charges){
 
   // add a simulated digit to the list
 
@@ -396,13 +381,13 @@ void AliITS::AddDigit(Int_t id,Float_t phys,Int_t *digits,Int_t *tracks,Float_t
   switch(id)
   {
   case 0:
-     new(ldigits[fNdtype[id]++]) AliITSdigitSPD(digits,tracks);
+     new(ldigits[fNdtype[id]++]) AliITSdigitSPD(digits,tracks,hits);
      break;
   case 1:
-     new(ldigits[fNdtype[id]++]) AliITSdigitSDD(phys,digits,tracks,charges);
+     new(ldigits[fNdtype[id]++]) AliITSdigitSDD(phys,digits,tracks,hits,charges);
      break;
   case 2:
-     new(ldigits[fNdtype[id]++]) AliITSdigitSSD(digits,tracks);
+     new(ldigits[fNdtype[id]++]) AliITSdigitSSD(digits,tracks,hits);
      break;
   }
  
@@ -414,8 +399,6 @@ void AliITS::AddCluster(Int_t id, AliITSRawCluster *c)
 
   // add a cluster to the list
 
-  // should have ctors of type AliITSRawClusterSDD(const AliITSRawClusterSDD &)
-
   TClonesArray &lcl = *((TClonesArray*)(*fCtype)[id]);
 
   switch(id)
@@ -455,7 +438,7 @@ void AliITS::ResetDigits()
     if (!fDtype) return;
 
     Int_t i;
-    for(i=0;i<fNDetTypes;i++ ) {
+    for (i=0;i<fgkNTYPES;i++ ) {
        if ((*fDtype)[i])    ((TClonesArray*)(*fDtype)[i])->Clear();
        if (fNdtype)  fNdtype[i]=0;
     }
@@ -467,10 +450,11 @@ void AliITS::ResetDigits(Int_t i)
     //
     // Reset number of digits and the digits array for this branch
     //
-       if ((*fDtype)[i])    ((TClonesArray*)(*fDtype)[i])->Clear();
-       if (fNdtype)  fNdtype[i]=0;
-
+  if ((*fDtype)[i])    ((TClonesArray*)(*fDtype)[i])->Clear();
+  if (fNdtype)  fNdtype[i]=0;
 }
+
+
 //____________________________________________
 void AliITS::ResetClusters()
 {
@@ -479,12 +463,13 @@ void AliITS::ResetClusters()
     //
 
     Int_t i;
-    for(i=0;i<fNDetTypes;i++ ) {
+    for (i=0;i<fgkNTYPES;i++ ) {
        if ((*fCtype)[i])    ((TClonesArray*)(*fCtype)[i])->Clear();
        if (fNctype)  fNctype[i]=0;
     }
 
 }
+
 //____________________________________________
 void AliITS::ResetClusters(Int_t i)
 {
@@ -535,7 +520,6 @@ void AliITS::Init(){
   SetDefaults();
 
   Int_t i;
-
   printf("\n");
   for(i=0;i<35;i++) printf("*");
   printf(" ITS_INIT ");
@@ -565,8 +549,8 @@ void AliITS::SetDefaults()
   if (!iDetType->GetSegmentationModel()) SetSegmentationModel(0,seg0); 
   if (!iDetType->GetResponseModel()) SetResponseModel(0,resp0); 
   // set digit and raw cluster classes to be used
-  const char *kData=resp0->DataType();
-  if (strstr(kData,"real")) {
+  const char *kData0=resp0->DataType();
+  if (strstr(kData0,"real")) {
       iDetType->ClassNames("AliITSdigit","AliITSRawClusterSPD");
   } else iDetType->ClassNames("AliITSdigitSPD","AliITSRawClusterSPD");
 
@@ -576,9 +560,9 @@ void AliITS::SetDefaults()
   iDetType=DetType(1); 
   if (!iDetType->GetSegmentationModel()) SetSegmentationModel(1,seg1); 
   if (!iDetType->GetResponseModel()) SetResponseModel(1,resp1); 
-  kData=resp1->DataType();
-  Option_t *opt=resp1->ZeroSuppOption();
-  if ((!strstr(opt,"2D")) && (!strstr(opt,"1D")) || strstr(kData,"real") ) {
+  const char *kData1=resp1->DataType();
+  const char *kopt=resp1->ZeroSuppOption();
+  if ((!strstr(kopt,"2D")) && (!strstr(kopt,"1D")) || strstr(kData1,"real") ) {
       iDetType->ClassNames("AliITSdigit","AliITSRawClusterSDD");
   } else iDetType->ClassNames("AliITSdigitSDD","AliITSRawClusterSDD");
 
@@ -588,12 +572,12 @@ void AliITS::SetDefaults()
   iDetType=DetType(2); 
   if (!iDetType->GetSegmentationModel()) SetSegmentationModel(2,seg2); 
   if (!iDetType->GetResponseModel()) SetResponseModel(2,resp2); 
-  kData=resp2->DataType();
-  if (strstr(kData,"real")) {
+  const char *kData2=resp2->DataType();
+  if (strstr(kData2,"real")) {
       iDetType->ClassNames("AliITSdigit","AliITSRawClusterSSD");
   } else iDetType->ClassNames("AliITSdigitSSD","AliITSRawClusterSSD");
 
-  if (fNDetTypes>3) {
+  if (fgkNTYPES>3) {
     Warning("SetDefaults","Only the three basic detector types are initialised!");
   } 
 
@@ -601,6 +585,18 @@ void AliITS::SetDefaults()
 
 
 //_____________________________________________________________________________
+void AliITS::SetDefaultSimulation()
+{
+  // to be written
+
+}
+//_____________________________________________________________________________
+void AliITS::SetDefaultClusterFinders()
+{
+  // to be written
+
+}
+//_____________________________________________________________________________
 
 void AliITS::MakeTreeC(Option_t *option)
 {
@@ -616,8 +612,8 @@ void AliITS::MakeTreeC(Option_t *option)
 
      // one branch for Clusters per type of detector
      Int_t i;
-     for(i=0; i<fNDetTypes ;i++) {
-        if (fNDetTypes==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
+     for (i=0; i<fgkNTYPES ;i++) {
+        if (fgkNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
        else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
        if (fCtype   && fTreeC) {
           TreeC()->Branch(branchname,&((*fCtype)[i]), buffersize);
@@ -649,10 +645,10 @@ void AliITS::GetTreeC(Int_t event)
     TBranch *branch;
     if (fTreeC) {
         Int_t i;
-       for(i=0; i<fNDetTypes; i++) {
-           if (fNDetTypes==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
-           else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
-           if (fCtype) {
+       for (i=0; i<fgkNTYPES; i++) {
+          if (fgkNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
+          else  sprintf(branchname,"%sClusters%d",GetName(),i+1);
+          if (fCtype) {
                branch = fTreeC->GetBranch(branchname);
                 if (branch) branch->SetAddress(&((*fCtype)[i]));
            }
@@ -680,25 +676,23 @@ void AliITS::MakeBranch(Option_t* option){
   
    char *det[3] = {"SPD","SDD","SSD"};
 
-   char *kDigclass;
-   char *kClclass;
+   char digclass[40];
+   char clclass[40];
 
    Int_t i;
-   for(i=0; i<fNDetTypes ;i++) {
+   for (i=0; i<fgkNTYPES ;i++) {
        AliITSDetType *iDetType=DetType(i); 
-       iDetType->GetClassNames(kDigclass,kClclass);
-       //printf("i, digclass, recclass %d %s %s\n",i,kDigclass,kClclass); 
+       iDetType->GetClassNames(digclass,clclass);
+       //printf("i, digclass, recclass %d %s %s\n",i,digclass,clclass); 
        // digits
-       (*fDtype)[i] = new TClonesArray(kDigclass,100); 
-       fNdtype[i]=0;
+       (*fDtype)[i] = new TClonesArray(digclass,10000); 
        // clusters
-       (*fCtype)[i] = new TClonesArray(kClclass,100); 
-       fNctype[i]=0;
+       (*fCtype)[i] = new TClonesArray(clclass,10000); 
    }
 
 
-  for(i=0; i<fNDetTypes ;i++) {
-      if (fNDetTypes==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
+  for (i=0; i<fgkNTYPES ;i++) {
+      if (fgkNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
       else  sprintf(branchname,"%sDigits%d",GetName(),i+1);
       
       if (fDtype   && gAlice->TreeD()) {
@@ -710,7 +704,7 @@ void AliITS::MakeBranch(Option_t* option){
   // only one branch for rec points for all detector types
   sprintf(branchname,"%sRecPoints",GetName());
 
-  fRecPoints=new TClonesArray("AliITSRecPoint",1000);
+  fRecPoints=new TClonesArray("AliITSRecPoint",10000);
 
   if (fRecPoints && gAlice->TreeR()) {
     gAlice->TreeR()->Branch(branchname,&fRecPoints, buffersize);
@@ -737,8 +731,8 @@ void AliITS::SetTreeAddress()
 
   Int_t i;
   if (treeD) {
-      for(i=0; i<fNDetTypes; i++) {
-         if (fNDetTypes==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
+      for (i=0; i<fgkNTYPES; i++) {
+         if (fgkNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
          else  sprintf(branchname,"%sDigits%d",GetName(),i+1);
          if (fDtype) {
              branch = treeD->GetBranch(branchname);
@@ -764,6 +758,11 @@ void AliITS::InitModules(Int_t size,Int_t &nmodules){
 
   //initialize the modules array
 
+  if(fITSmodules){ 
+    //this->ClearModules();
+      delete fITSmodules;
+  }
+
     Int_t nl,indexMAX,index;
     Int_t indSPD,indSDD;
 
@@ -796,7 +795,7 @@ void AliITS::InitModules(Int_t size,Int_t &nmodules){
 }
 
 //____________________________________________________________________________
-void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t lastev,Int_t nmodules,Option_t *option,Text_t *filename){
+void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,Option_t *option,Text_t *filename){
 
   // fill the modules with the sorted by module hits; add hits from background
   // if option=Add
@@ -806,10 +805,10 @@ void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t lastev,Int_t nmodules,Opti
 
     static Bool_t first=kTRUE;
     static TFile *file;
-    char *add = strstr(option,"Add");
+    char *addBgr = strstr(option,"Add");
 
 
-    if (add ) {
+    if (addBgr ) {
        if(first) {
            cout<<"filename "<<filename<<endl;
            file=new TFile(filename);
@@ -846,18 +845,6 @@ void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t lastev,Int_t nmodules,Opti
        //printf("background - ntracks1 - %d\n",ntracks1);
    }
 
-    // store temporarily coordinates of signal particles - see where delete
-    static Int_t *signal;
-    Int_t i;
-    if(!signal) signal=new Int_t[nmodules];
-    memset(signal,0,sizeof(int)*nmodules);
-//    Float_t xhit[nmodules][4];
-    Float_t **xhit = new Float_t*[nmodules];
-    for(i=0;i<nmodules;i++) xhit[i] = new Float_t[4];
-//    Float_t yhit[nmodules][4];
-    Float_t **yhit = new Float_t*[nmodules];
-    for(i=0;i<nmodules;i++) yhit[i] = new Float_t[4];
-
     Int_t npart = gAlice->GetEvent(evnt);
     if(npart<=0) return;
     TClonesArray *itsHits = this->Hits();
@@ -874,19 +861,11 @@ void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t lastev,Int_t nmodules,Opti
        iTH->GetEvent(t);
        Int_t nhits = itsHits->GetEntriesFast();
         if (!nhits) continue;
-               // cout << nhits << " hits in track " << t << endl;
        for(h=0; h<nhits; h++){
            itsHit = (AliITShit *)itsHits->UncheckedAt(h);
            itsHit->GetDetectorID(lay,lad,det);
            index = fITSgeom->GetModuleIndex(lay,lad,det);
            mod = this->GetModule(index);
-           if (add) {
-               xhit[index][signal[index]]=itsHit->fX;
-               yhit[index][signal[index]]=itsHit->fY;
-               signal[index]++;
-                if (signal[index] >4) 
-                      printf("index,nsignal %d %d\n",index,signal[index]);
-           }
            if(lay == 1 || lay == 2)
                mod->AddHit((AliITShit *) itsHit,t,h);
            else if(lay == 3 || lay == 4)
@@ -901,14 +880,14 @@ void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t lastev,Int_t nmodules,Opti
 
     // open the file with background
     
-    if (add ) {
-          Int_t track,i,isig;
+    if (addBgr ) {
+          Int_t track,i;
           ntracks =(Int_t)trH1->GetEntries();
            //printf("background - ntracks1 %d\n",ntracks);
            //printf("background - Start loop over tracks \n");     
             //   Loop over tracks
 
-           for(track=0; track<ntracks; track++) {
+           for (track=0; track<ntracks; track++) {
 
                if (fHits2)       fHits2->Clear();
                trH1->GetEvent(track);
@@ -920,18 +899,6 @@ void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t lastev,Int_t nmodules,Opti
                    index = fITSgeom->GetModuleIndex(lay,lad,det);
                    mod = this->GetModule(index);
 
-                    Float_t xbgr=itsHit->fX;
-                   Float_t ybgr=itsHit->fY;
-                   Float_t ebgr=itsHit->GetIonization();
-                   Bool_t cond=kFALSE;
-                   
-                   for(isig =0; isig < signal[index]; isig++) {
-                       Float_t dist= 
-                            (xbgr-xhit[index][isig])*(xbgr-xhit[index][isig])
-                           +(ybgr-yhit[index][isig])*(ybgr-yhit[index][isig]);
-                       if (dist<0.2&& ebgr!=0) cond=kTRUE; // check this number for ITS!
-                   }
-                   if (!cond) continue;
                    if(lay == 1 || lay == 2)
                       mod->AddHit((AliITShit *) itsHit,track,i);
                    else if(lay == 3 || lay == 4)
@@ -949,38 +916,27 @@ void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t lastev,Int_t nmodules,Opti
             TFile *fileAli=0;
            
            if (fAli) fileAli =fAli->GetCurrentFile();
-            //printf("fAli, file %p %p\n",fAli,file);
            file->cd();
 
     } // end if add
 
-
-    for(i=0;i<nmodules;i++) delete[] xhit[i];
-    delete[] xhit;
-    for(i=0;i<nmodules;i++) delete[] yhit[i];
-    delete[] yhit;
-    //if (evnt==lastev) {delete [] signal; delete signal;}
-
     //gObjectTable->Print();
 
 }
 
 
 //____________________________________________________________________________
-void AliITS::HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t lastev,Int_t size,
-Option_t *option,Option_t *opt,Text_t *filename)
+void AliITS::HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size, Option_t *option, Option_t *opt,Text_t *filename)
 {
     // keep galice.root for signal and name differently the file for 
     // background when add! otherwise the track info for signal will be lost !
   
    char *all = strstr(opt,"All");
    char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),strstr(opt,"SSD")};
-   //printf("Det 1 2 3 %s %s %s \n",det[0],det[1],det[2]);
 
    Int_t nmodules;
    InitModules(size,nmodules); 
-   FillModules(evNumber,bgrev,lastev,nmodules,option,filename);
-   //printf("nmodules %d\n",nmodules);
+   FillModules(evNumber,bgrev,nmodules,option,filename);
 
    TBranch *branch;
    AliITSsimulation* sim;
@@ -989,8 +945,7 @@ Option_t *option,Option_t *opt,Text_t *filename)
    AliITSgeom *geom = GetITSgeom();
 
    Int_t id,module;
-   for(id=0;id<3;id++) {
-        //printf("id %d All %s  det[id] %s \n",id,all,det[id]);
+   for (id=0;id<fgkNTYPES;id++) {
         if (!all && !det[id]) continue;
        branch = (TBranch*)branches->UncheckedAt(id);
        AliITSDetType *iDetType=DetType(id); 
@@ -998,11 +953,11 @@ Option_t *option,Option_t *opt,Text_t *filename)
        if (!sim) {
            Error("HitsToDigits","The simulation class was not instantiated!");
            exit(1);
-          // or SetDefaultSimulation(id,iDetType*);
+          // or SetDefaultSimulation();
        }
        Int_t first = geom->GetStartDet(id);
        Int_t last = geom->GetLastDet(id);
-       //printf("det type %d first, last %d %d \n",id,first,last);
+       printf("det type %d first, last %d %d \n",id,first,last);
        for(module=first;module<=last;module++) {
            AliITSmodule *mod = (AliITSmodule *)fITSmodules->At(module);
            sim->DigitiseModule(mod,module,evNumber);
@@ -1015,10 +970,10 @@ Option_t *option,Option_t *opt,Text_t *filename)
        } // loop over modules
    } // loop over detector types
 
-
    ClearModules();
 
-   //Int_t nentries=(Int_t)gAlice->TreeD()->GetEntries();
+   Int_t nentries=(Int_t)gAlice->TreeD()->GetEntries();
+   printf("nentries in TreeD %d\n",nentries);
 
    char hname[30];
    sprintf(hname,"TreeD%d",evNumber);
@@ -1032,6 +987,7 @@ Option_t *option,Option_t *opt,Text_t *filename)
 //____________________________________________________________________________
 void AliITS::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t *opt)
 {
+  // cluster finding and reconstruction of space points
   
    char *all = strstr(opt,"All");
    char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),strstr(opt,"SSD")};
@@ -1050,7 +1006,7 @@ void AliITS::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t *opt)
    AliITSgeom *geom = GetITSgeom();
 
    Int_t id,module;
-   for(id=0;id<fNDetTypes;id++) {
+   for (id=0;id<fgkNTYPES;id++) {
         if (!all && !det[id]) continue;
        branch = (TBranch*)branches->UncheckedAt(id);
        AliITSDetType *iDetType=DetType(id); 
@@ -1058,15 +1014,13 @@ void AliITS::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t *opt)
        if (!rec) {
            Error("DigitsToRecPoints","The cluster finder class was not instantiated!");
            exit(1);
-          // or SetDefaultClusterFinder(id,iDetType*);
+          // or SetDefaultClusterFinders();
        }
         TClonesArray *itsDigits  = this->DigitsAddress(id);
 
        Int_t first = geom->GetStartDet(id);
        Int_t last = geom->GetLastDet(id);
-       //printf("det type %d first, last %d %d \n",id,first,last);
        for(module=first;module<=last;module++) {
-             //printf("AliITS: module=%d\n",module);
               this->ResetDigits();
               if (all) gAlice->TreeD()->GetEvent(lastentry+module);
              else gAlice->TreeD()->GetEvent(lastentry+(module-first));
@@ -1083,9 +1037,9 @@ void AliITS::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t *opt)
    } // loop over detector types
 
 
-   //Int_t nentries=(Int_t)gAlice->TreeR()->GetEntries();
-
-   //Int_t ncentries=(Int_t)TC->GetEntries();
+   Int_t nentries=(Int_t)gAlice->TreeR()->GetEntries();
+   Int_t ncentries=(Int_t)iTC->GetEntries();
+   printf(" nentries ncentries %d %d\n", nentries, ncentries);
 
    char hname[30];
    sprintf(hname,"TreeR%d",evNumber);
@@ -1100,7 +1054,7 @@ void AliITS::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t *opt)
 
 
 //____________________________________________________________________________
-void AliITS::HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t lastev,Int_t size,
+void AliITS::HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t size,
 Option_t *option,Option_t *opt,Text_t *filename)
 {
     // keep galice.root for signal and name differently the file for 
@@ -1110,23 +1064,40 @@ Option_t *option,Option_t *opt,Text_t *filename)
    char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),strstr(opt,"SSD")};
 
    Int_t nmodules;
-   InitModules(size,nmodules); 
-   FillModules(evNumber,bgrev,lastev,nmodules,option,filename);
-
-   static AliITSsimulationFastPoints* sim=0;
-   if (!sim) sim = new AliITSsimulationFastPoints(); 
+   InitModules(size,nmodules);
+   FillModules(evNumber,bgrev,nmodules,option,filename);
 
 
+   AliITSsimulation* sim;
    AliITSgeom *geom = GetITSgeom();
 
+   TRandom *random=new TRandom[9];
+   random[0].SetSeed(111);
+   random[1].SetSeed(222);
+   random[2].SetSeed(333);             
+   random[3].SetSeed(444);
+   random[4].SetSeed(555);
+   random[5].SetSeed(666);             
+   random[6].SetSeed(777);
+   random[7].SetSeed(888);
+   random[8].SetSeed(999);             
+
+
    Int_t id,module;
-   for(id=0;id<3;id++) {
+   for (id=0;id<fgkNTYPES;id++) {
         if (!all && !det[id]) continue;
+       AliITSDetType *iDetType=DetType(id); 
+       sim = (AliITSsimulation*)iDetType->GetSimulationModel();
+       if (!sim) {
+           Error("HitsToFastPoints","The simulation class was not instantiated!");
+           exit(1);
+          // or SetDefaultSimulation();
+       }
        Int_t first = geom->GetStartDet(id);
        Int_t last = geom->GetLastDet(id);
        for(module=first;module<=last;module++) {
            AliITSmodule *mod = (AliITSmodule *)fITSmodules->At(module);
-           sim->CreateFastRecPoints(mod);
+           sim->CreateFastRecPoints(mod,module,random);
            gAlice->TreeR()->Fill(); 
            ResetRecPoints();
        } // loop over modules
@@ -1143,85 +1114,62 @@ Option_t *option,Option_t *opt,Text_t *filename)
    // reset tree
    gAlice->TreeR()->Reset();
 
+   delete [] random;
+
 }
 
-//______________________________________________________________________________
-void AliITS::Streamer(TBuffer &R__b)
-{
+//____________________________________________________________________________
+void AliITS::Streamer(TBuffer &R__b){
    // Stream an object of class AliITS.
 
-  Int_t i, j, l;
+   Int_t i;
 
    if (R__b.IsReading()) {
       Version_t R__v = R__b.ReadVersion();
       if (R__v) {
          AliDetector::Streamer(R__b);
+         R__b >> fIdN;
+         R__b.ReadArray(fIdSens); 
+         for(i=0;i<fIdN;i++) fIdName[i].Streamer(R__b);
          R__b >> fITSgeom;
          R__b >> fITSmodules;
          R__b >> fEuclidOut;
-         R__b >> fIdN;
-         delete []fIdSens; 
-         fIdSens = new Int_t[fIdN];
-         R__b.ReadFastArray(fIdSens,fIdN);
-         if(fIdName!=0) delete[] fIdName;
-         fIdName = new char*[fIdN];
-         for(i=0;i<fIdN;i++){
-             R__b >> l;
-             fIdName[i] = new char[l+1]; // add room for null character.
-             for(j=0;j<l;j++) R__b >> fIdName[i][j];
-             fIdName[i][l] = '\0'; // Null terminate this string.
-         } // end for i
-         //R__b.ReadArray(fIdName);
          R__b >> fMajorVersion;
          R__b >> fMinorVersion;
          R__b >> fDetTypes;
-         R__b >> fNDetTypes;
          R__b >> fDtype;
          delete []fNdtype; 
-         fNdtype = new Int_t[fNDetTypes];
-         R__b.ReadFastArray(fNdtype,fNDetTypes);
+         fNdtype = new Int_t[fgkNTYPES];
+         R__b.ReadFastArray(fNdtype,fgkNTYPES);
          R__b >> fCtype;
          delete []fNctype; 
-         fNctype = new Int_t[fNDetTypes];
-         R__b.ReadFastArray(fNctype,fNDetTypes);
+         fNctype = new Int_t[fgkNTYPES];
+         R__b.ReadFastArray(fNctype,fgkNTYPES);
          R__b >> fRecPoints;
          R__b >> fNRecPoints;
-         R__b >> fTracks;
          R__b >> fTreeC;
       } // end if R__v
    } else { // writing
       R__b.WriteVersion(AliITS::IsA());
       AliDetector::Streamer(R__b);
+      R__b << fIdN;
+      R__b.WriteArray(fIdSens,fIdN); 
+      for(i=0;i<fIdN;i++) fIdName[i].Streamer(R__b);
       R__b << fITSgeom;
       R__b << fITSmodules;
       R__b << fEuclidOut;
-      R__b << fIdN;
-      R__b.WriteFastArray(fIdSens,fIdN);
-      for(i=0;i<fIdN;i++){
-         l = strlen(fIdName[i]);
-         R__b << l;
-         for(j=0;j<l;j++) R__b << fIdName[i][j];
-      } // end for i
-      //R__b.WriteArray(fIdName, __COUNTER__);
       R__b << fMajorVersion;
       R__b << fMinorVersion;
       R__b << fDetTypes;
-      R__b << fNDetTypes;
       R__b << fDtype;
-      R__b.WriteFastArray(fNdtype,fNDetTypes);
+      R__b.WriteFastArray(fNdtype,fgkNTYPES);
       R__b << fCtype;
-      R__b.WriteFastArray(fNctype,fNDetTypes);
+      R__b.WriteFastArray(fNctype,fgkNTYPES);
       R__b << fRecPoints;
-      // fRecPoints->Streamer(R__b);
       R__b << fNRecPoints;
-      R__b << fTracks;
-      //      fTracks->Streamer(R__b);
       R__b << fTreeC;
    } // end if
+
 }
 
-ClassImp(AliITSRecPoint)
-ClassImp(AliITSsegmentation)
-ClassImp(AliITSresponse)       
-//ClassImp(AliITStrack)
 
index cfc4bd5..e4d71f5 100644 (file)
@@ -11,6 +11,7 @@
 
 #include <TObjArray.h>
 #include <TBranch.h>
+#include <TString.h>
 #include <TTree.h>
 #include <TFile.h>
 #include <TObjectTable.h>
 #include "AliITSgeom.h"
 #include "AliITSsegmentation.h"
 #include "AliITSresponse.h"
-#include "AliITSDetType.h"
 #include "AliITShit.h"
 #include "AliITSdigit.h"
 #include "AliITSmodule.h"
 #include "AliITSRecPoint.h"
 #include "AliITSRawCluster.h"
 
-
+class AliITSDetType;
 class AliITSsimulation;
 class AliITSClusterFinder;
-//class AliITStrack;
 
 class AliITS : public AliDetector {
 
@@ -42,13 +41,11 @@ class AliITS : public AliDetector {
 
     virtual void   AddHit(Int_t track, Int_t *vol, Float_t *hits);
     virtual void   AddRealDigit(Int_t branch, Int_t *digits);
-    virtual void   AddDigit(Int_t branch, AliITSdigit *d);
-    virtual void   AddDigit(Int_t branch,Float_t phys,Int_t* digits, Int_t* tracks, Float_t* trkcharges); 
+    virtual void   AddSimDigit(Int_t branch, AliITSdigit *d);
+    virtual void   AddSimDigit(Int_t branch,Float_t phys,Int_t* digits,Int_t* tracks,Int_t *hits,Float_t* trkcharges); 
     //
     virtual void   AddCluster(Int_t branch, AliITSRawCluster *c);
     virtual void   AddRecPoint(const AliITSRecPoint &p);
-    virtual void   AddTrack(Float_t* tracks) {}
-//    virtual void   AddTrack(const AliITStrack&) {} 
 
     virtual void   ResetDigits();                   // depending on how the
     virtual void   ResetDigits(Int_t branch);       // tree will be filled only
@@ -56,16 +53,15 @@ class AliITS : public AliDetector {
     virtual void   ResetClusters(Int_t branch);     // the pair will be kept
     virtual void   ResetRecPoints();
 
-    virtual void   BuildGeometry() {}
-    virtual void   CreateGeometry() {}
-    virtual void   CreateMaterials() {}
-
+    // get geometry version - detailed (major) or coarse (minor)
     void GetGeometryVersion(Int_t &a,Int_t &b) const 
                   {a = fMajorVersion;b=fMinorVersion;return;}
     virtual Int_t  IsVersion() const {return 1;}
             Int_t  DistancetoPrimitive(Int_t px, Int_t py);
     virtual void   Init();
     virtual void   SetDefaults();
+    virtual void   SetDefaultSimulation();
+    virtual void   SetDefaultClusterFinders();
     // create separate tree for clusters - declustering refining
     virtual  void  MakeTreeC(Option_t *option="C");
     void           GetTreeC(Int_t event);
@@ -75,26 +71,24 @@ class AliITS : public AliDetector {
     virtual void   StepManager() {}
     // sort hits by module
     virtual void   InitModules(Int_t size,Int_t &nmodules);  
-    virtual void   FillModules(Int_t evnt,Int_t bgrev,Int_t lastev,
+    virtual void   FillModules(Int_t evnt,Int_t bgrev,
                        Int_t nmodules,Option_t *opt,Text_t *filename);
     virtual void   ClearModules();
     // Digitisation
-    void HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t lastev,Int_t size,
+    void HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size,
                  Option_t *add, Option_t *det, Text_t *filename);
     // Reconstruct hits
     void DigitsToRecPoints(Int_t evNumber,Int_t lastEntry,Option_t *det);
     // Fast simulation of space points from hits
-    void HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t lastev,Int_t size,
+    void HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t size,
                  Option_t *add, Option_t *det, Text_t *filename);
 
-
-
     // Write digits into raw data format
     virtual void Digits2RawData() {}
+    // Decode raw data and store digits
+    virtual void RawData2Digits() {}
 
     // Configuration Methods (per detector type )
-    // Set number of detector types
-    virtual void   SetNDetTypes(Int_t ndtypes=3) {fNDetTypes=ndtypes;}
     // Set response 
     virtual void   SetResponseModel(Int_t id, AliITSresponse *response);
     // Set segmentation 
@@ -104,13 +98,15 @@ class AliITS : public AliDetector {
     // Set reconstruction 
     virtual void   SetReconstructionModel(Int_t id, AliITSClusterFinder *rec);
     // Set class names for digit and rec point 
-    virtual void   SetClasses(Int_t id, char* digit, char* cluster);
+    virtual void   SetClasses(Int_t id, const char *digit, const char *cluster);
 
 
     // Getters
     // ITS geometry functions
     virtual AliITSgeom  *GetITSgeom() const {return fITSgeom;}
+    // return pointer to the array of modules
     virtual TObjArray   *GetModules() const {return fITSmodules;}
+    // return pointer to a particular module
     AliITSmodule *GetModule(Int_t index) {return (AliITSmodule *)
                                              (fITSmodules->At(index));}
 
@@ -127,44 +123,44 @@ class AliITS : public AliDetector {
 
     // Return pointer to rec points 
     TClonesArray  *RecPoints()   {return fRecPoints;}
-    // Return pointer to tracks 
-    TClonesArray  *Tracks()   {return fTracks;}
 
     // Return pointer to DetType #id
     AliITSDetType  *DetType(Int_t id);
-    Int_t           NDetTypes() {return fNDetTypes;}
+    //Int_t           NDetTypes() {return fNDetTypes;}
 
     // Return pointer to the tree of clusters
     TTree          *TreeC() {return fTreeC;}
 
+
  protected:
 
+    static const Int_t fgkNTYPES=3;          // Number of detector types
+
     AliITSgeom  *fITSgeom;                   // Pointer to ITS geometry
     TObjArray   *fITSmodules;                // Pointer to ITS modules
 
     Bool_t fEuclidOut;                       // Flag to write out geometry 
-                                             //in euclid format
+                                             // in euclid format
     Int_t  fIdN;                             // the number of layers
     Int_t  *fIdSens;                         //[fIdN] layer identifier
-    char **fIdName;                          //layer identifier
+    TString *fIdName;                        //[fIdN] layer identifier
     // Geometry and Stepmanager version numbers used.
     Int_t fMajorVersion,fMinorVersion;       //detailed and coarse(minor) versions
     //
     //
+
+    // Int_t             fNDetTypes;           //Number of detector types
     TObjArray            *fDetTypes;           // List of detector types
-    Int_t                 fNDetTypes;          // Number of Detector types
 
-    TObjArray            *fDtype;              // List of digits
-    Int_t                *fNdtype;             //[fNDetTypes] Number of digits per type of
+    TObjArray            *fDtype;              //[fgkNTYPES]  List of digits
+    Int_t                *fNdtype;             //[fgkNTYPES] Number of digits per type of
                                                // detector 
-    TObjArray            *fCtype;              // List of clusters
-    Int_t                *fNctype;             //[fNDetTypes] Number of clusters per type
+    TObjArray            *fCtype;              //[fgkNTYPES] List of clusters
+    Int_t                *fNctype;             //[fgkNTYPES] Number of clusters per type
                                                // of detector
 
-
     TClonesArray         *fRecPoints;          // List of reconstructed points
     Int_t                 fNRecPoints;         // Number of rec points
-    TClonesArray         *fTracks;             // List of reconstructed tracks
     TTree                *fTreeC;              // Tree for raw clusters
 
 
diff --git a/ITS/AliITSAlignmentModule.cxx b/ITS/AliITSAlignmentModule.cxx
new file mode 100644 (file)
index 0000000..0f7e4e7
--- /dev/null
@@ -0,0 +1,454 @@
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+/* $Id$ */
+/* $Author$ */
+/* $Date$ */
+/* $Name$ */
+/* $Header$ */
+/*
+   $Log$
+   Revision 1.1.2.3  2000/06/04 16:35:09  nilsen
+   One more try to fix log comments.
+
+   Revision 1.1.2.2  2000/03/04 23:39:36  nilsen
+   Fixed the logs???
+ */
+/* Revision 1.1.2.1  2000/03/02 20:12:23  nilsen */
+/* A new class usefull for ITS detector Alignment Studdies */
+/* */
+/* $Revision$ */
+
+// Standard C & C++ libraries
+#include <TObject.h>
+
+// Standard Root Libraries
+#include <TParticle.h>
+
+// ITS libraries
+#include "AliITSgeom.h"
+#include "AliITSAlignmentTrack.h"
+#include "AliITSAlignmentModule.h"
+
+ClassImp(AliITSAlignmentModule)
+
+//______________________________________________________________________
+AliITSAlignmentModule::AliITSAlignmentModule(){
+
+    findex = -1;
+    flay   = -1;
+    flad   = -1;
+    fdet   = -1;
+    fx0[0] = 0.0;
+    fx0[1] = 0.0;
+    fx0[2] = 0.0;
+    fangles[0] = 0.0;
+    fangles[1] = 0.0;
+    fangles[2] = 0.0;
+    fM[0][0]   = 0.0;
+    fM[0][1]   = 0.0;
+    fM[0][2]   = 0.0;
+    fM[1][0]   = 0.0;
+    fM[1][1]   = 0.0;
+    fM[1][2]   = 0.0;
+    fM[2][0]   = 0.0;
+    fM[2][1]   = 0.0;
+    fM[2][2]   = 0.0;
+    ftrksM =0;
+    fChi2 = 0.0;
+}
+//______________________________________________________________________
+AliITSAlignmentModule::AliITSAlignmentModule(Int_t index,AliITSgeom *gm,
+                                         Int_t ntrk,AliITSAlignmentTrack *trk){
+    Float_t x,y,z,n;
+    Int_t   i,j;
+
+    findex = index;
+    gm->GetModuleId(index,flay,flad,fdet);
+    gm->GetRotMatrix(index,(Double_t *) &(fM[0][0]));
+    gm->GetTrans(flay,flad,fdet,x,y,z);
+    fx0[0] = (Double_t )x;
+    fx0[1] = (Double_t )y;
+    fx0[2] = (Double_t )z;
+    gm->GetAngles(flay,flad,fdet,x,y,z);
+    fangles[0] = (Double_t )x;
+    fangles[1] = (Double_t )y;
+    fangles[2] = (Double_t )z;
+    ftrksM = new TObjArray();
+    fChi2 = 0.0;
+
+    for(i=0;i<ntrk;i++){
+       n = 0;
+       for(j=0;j<trk[i].GetNumberOfClustersSl();j++){
+           if(trk[i].GetIndex(j,index)==findex){
+               ftrksM->AddAtFree((TObject *) &trk[i]);
+               break; // break out of the j loop
+           } // end if
+       } // end for j
+    } // end for i
+}
+//______________________________________________________________________
+Double_t AliITSAlignmentModule::ComputeChi2(){
+    Float_t n;
+    Int_t   i,j,ntrk,ntr;
+
+    ntrk = ftrksM->GetEntriesFast();
+    fChi2 = 0.0;
+    for(i=0;i<ntrk;i++){
+       n = 0;
+       ntr =((AliITSAlignmentTrack *)(ftrksM->At(i)))->GetNumberOfClustersSl();
+       for(j=0;j<ntr;j++){
+               fChi2 += (Double_t) ((AliITSAlignmentTrack *)(ftrksM->At(i)))->
+                                    GetChi2();
+               n++;
+       } // end for j
+       if(n==0){
+           fChi2 = -1.0;
+       }else{
+           fChi2 /= (Double_t) n;
+       } // end if n==0
+    } // end for i
+    return fChi2;
+}
+//______________________________________________________________________
+void AliITSAlignmentModule::lnsrch(Int_t npar,Double_t *xold,Double_t fold,
+                                  Double_t *g,Double_t *p,Double_t *x,
+                                  Double_t &f, Double_t stpmax,Int_t &check){
+    Double_t ALF = 1.0e-4, TOLX = 1.0E-7;
+
+    Int_t    i;
+    Double_t a,alam,alam2=0.0,alamin,b,disc,f2=0.0,rhs1,rhs2,slope,sum,temp,
+            test,tmplam;
+
+    check = 0;
+    for(sum=0.0,i=0;i<npar;i++) sum += p[i]*p[i];
+    sum = TMath::Sqrt(sum);
+    if(sum>stpmax) for(i=0;i<npar;i++) p[i] *= stpmax/sum;
+    for(slope=0.0,i=0;i<npar;i++) slope += g[i]*p[i];
+    if(slope >=0.0) printf("Error: round off problem in lnsrch.\n");
+    test = 0.0;
+    for(i=0;i<npar;i++){
+       temp = TMath::Abs(p[i])/TMath::Max(TMath::Abs(xold[i]),1.0);
+       if(temp > test) test = temp;
+    } // end for i
+    alamin = TOLX/test;
+    alam = 1.0;
+    for(;;){
+       for(i=0;i<npar;i++) x[i] = xold[i] + alam*p[i];
+       f = Chi2(x);
+       if(alam < alamin){
+           for(i=0;i<npar;i++) x[i] = xold[i];
+           check = 1;
+           return;
+       }else if(f <= fold+ALF*alam*slope) return;
+       else{
+           if(alam == 1.0) tmplam = -slope/(2.0*(f-fold-slope));
+           else{
+               rhs1 = f-fold-alam*slope;
+               rhs2 = f2-fold-alam2*slope;
+               a = (rhs1/(alam*alam)-rhs2/(alam2*alam2))/(alam-alam2);
+               b = (-alam2*rhs1/(alam*alam)+alam*rhs2/(alam2*alam2))/(alam*alam);
+               if(a==0.0) tmplam = -slope/(2.0*b);
+               else{
+                   disc = b*b - 3.0*a*slope;
+                   if(disc<0.0) tmplam = 0.5*alam;
+                   else if(b<=0.0) tmplam = (-b+TMath::Sqrt(disc))/(3.0*a);
+                   else tmplam = -slope/(b+TMath::Sqrt(disc));
+               } // end if a == 0.0
+               if(tmplam > 0.5*alam) tmplam = 0.5*alam;
+           } // end if alam == 1.0
+       } // end if alam < alamin
+       alam2 = alam;
+       f2 = f;
+       alam = TMath::Max(tmplam,0.1*alam);
+    } // end for ever loop
+
+}
+//______________________________________________________________________
+void AliITSAlignmentModule::MRVMminimization(Int_t npar,Double_t *p,
+                                            Double_t &fret,Double_t gtol,
+                                            Int_t &iter){
+    Int_t ITMAX = 200;
+    Double_t EPS = 3.0e-8, TOLX = 4.0*EPS, STPMX = 100.0;
+
+    Int_t    check,i,its,j;
+    Double_t den,fac,fad,fae,fp,stpmax,sum=0.0,sumdg,sumxi,temp,test;
+    Double_t *dg,*g,*hdg,**hessin,*pnew,*xi;
+
+    // allocate space.
+    dg     = new Double_t[npar];
+    g      = new Double_t[npar];
+    hdg    = new Double_t[npar];
+    hessin = new Double_t * [npar];
+    for(i=0;i<npar;i++) hessin[i] = new Double_t[npar];
+    pnew   = new Double_t[npar];
+    xi     = new Double_t[npar];
+
+    // init function values
+    fp = Chi2(p);
+    dChi2(p,g);
+
+    for(i=0;i<npar;i++){
+       for(j=0;j<npar;j++) hessin[i][j] = 0.0;
+       hessin[i][i] = 1.0;
+       xi[i] = -g[i];
+       sum += p[i]*p[i];
+    } // end for i
+    stpmax = STPMX*TMath::Max(TMath::Sqrt(sum),(Double_t)(npar+1));
+
+    for(its=0;its<ITMAX;its++){
+       iter = its;
+       lnsrch(npar,p,fp,g,xi,pnew,fret,stpmax,check);
+       fp = fret;
+       for(i=0;i<npar;i++){
+           xi[i] = pnew[i] - p[i];
+           p[i] = pnew[i];
+       } // end for i
+       test = 0.0;
+       for(i=0;i<npar;i++){
+           temp = TMath::Abs(xi[i])/TMath::Max(TMath::Abs(p[i]),1.0);
+           if(temp > test) test = temp;
+       } // end for i
+       if(test<TOLX) break;
+       for(i=0;i<npar;i++) dg[i] = g[i];
+       dChi2(p,g);
+       test = 0.0;
+       den = TMath::Max(fret,1.0);
+       for(i=0;i<npar;i++){
+           temp = TMath::Abs(g[i])*TMath::Max(TMath::Abs(p[i]),1.0)/den;
+           if(temp>test) test=temp;
+       } // end for i
+       if(test<gtol) break;
+       for(i=0;i<npar;i++) dg[i] = g[i] - dg[i];
+       for(i=0;i<npar;i++){
+           hdg[i] = 0.0;
+           for(j=0;j<npar;j++) hdg[i] += hessin[i][j]*dg[j];
+       } // end for i
+       fac = fae = sumdg = sumxi = 0.0;
+       for(i=0;i<npar;i++){
+           fac += dg[i]*xi[i];
+           fae += dg[i]*hdg[i];
+           sumdg += TMath::Sqrt(dg[i]);
+           sumxi += TMath::Sqrt(xi[i]);
+       } // end for i
+       if(fac>TMath::Sqrt(EPS*sumdg*sumxi)){
+           fac = 1.0/fac;
+           fad = 1.0/fae;
+           for(i=0;i<npar;i++) dg[i] = fac*xi[i]-fad*hdg[i];
+           for(i=0;i<npar;i++) for(j=i;j<npar;j++){
+               hessin[i][j] += fac*xi[i]*xi[j] - fad*hdg[i]*hdg[j] + 
+                                                 fae*dg[i]*dg[j];
+               hessin[j][i] = hessin[i][j];
+           } // end for i,j
+       } // end if fac>...
+       for(i=0;i<npar;i++){
+           xi[i] = 0.0;
+           for(j=0;j<npar;j++) xi[i] -= hessin[i][j]*g[j];
+       } // end for i
+    } // end for its
+    if(its==ITMAX) printf("Error: too many iterations\n");
+    delete[] dg;
+    delete[] g;
+    delete[] hdg;
+    delete[] pnew;
+    delete[] xi;
+    for(i=0;i<npar;i++) delete[] hessin[i];
+    delete[] hessin;
+}
+//______________________________________________________________________
+void AliITSAlignmentModule::SetByAngles(Double_t *th){
+   Double_t  sx,cx,sy,cy,sz,cz;
+
+   sx = TMath::Sin(th[0]); cx = TMath::Cos(th[0]);
+   sy = TMath::Sin(th[1]); cy = TMath::Cos(th[1]);
+   sz = TMath::Sin(th[2]); cz = TMath::Cos(th[2]);
+   for(Int_t i=0;i<3;i++) fangles[i]   = th[i];
+   fM[0][0] =  cz*cy;
+   fM[0][1] = -cz*sy*sx - sz*cx;
+   fM[0][2] = -cz*sy*cx + sz*sx;
+   fM[1][0] =  sz*cy;
+   fM[1][1] = -sz*sy*sx + cz*cx;
+   fM[1][2] = -sz*sy*cx - cz*sx;
+   fM[2][0] =  sy;
+   fM[2][1] =  cy*sx;
+   fM[2][2] =  cy*cx;
+}
+//______________________________________________________________________
+void AliITSAlignmentModule::dfMdthx(Double_t dfMx[3][3]){
+   Double_t  sx,cx,sy,cy,sz,cz;
+
+   sx = TMath::Sin(fangles[0]); cx = TMath::Cos(fangles[0]);
+   sy = TMath::Sin(fangles[1]); cy = TMath::Cos(fangles[1]);
+   sz = TMath::Sin(fangles[2]); cz = TMath::Cos(fangles[2]);
+   dfMx[0][0] =  0.0;
+   dfMx[0][1] = -cz*sy*cx + sz*sx;
+   dfMx[0][2] =  cz*sy*sx + sz*cx;
+   dfMx[1][0] =  0.0;
+   dfMx[1][1] = -sz*sy*cx - cz*sx;
+   dfMx[1][2] =  sz*sy*sx - cz*cx;
+   dfMx[2][0] =  0.0;
+   dfMx[2][1] =  cy*cx;
+   dfMx[2][2] = -cy*sx;
+}
+//______________________________________________________________________
+void AliITSAlignmentModule::dfMdthy(Double_t dfMx[3][3]){
+   Double_t  sx,cx,sy,cy,sz,cz;
+
+   sx = TMath::Sin(fangles[0]); cx = TMath::Cos(fangles[0]);
+   sy = TMath::Sin(fangles[1]); cy = TMath::Cos(fangles[1]);
+   sz = TMath::Sin(fangles[2]); cz = TMath::Cos(fangles[2]);
+   dfMx[0][0] = -cz*sy;
+   dfMx[0][1] = -cz*cy*sx;
+   dfMx[0][2] = -cz*cy*cx;
+   dfMx[1][0] = -sz*sy;
+   dfMx[1][1] = -sz*cy*sx;
+   dfMx[1][2] = -sz*cy*cx;
+   dfMx[2][0] =  cy;
+   dfMx[2][1] = -sy*sx;
+   dfMx[2][2] = -sy*cx;
+}
+//______________________________________________________________________
+void AliITSAlignmentModule::dfMdthz(Double_t dfMx[3][3]){
+   Double_t  sx,cx,sy,cy,sz,cz;
+
+   sx = TMath::Sin(fangles[0]); cx = TMath::Cos(fangles[0]);
+   sy = TMath::Sin(fangles[1]); cy = TMath::Cos(fangles[1]);
+   sz = TMath::Sin(fangles[2]); cz = TMath::Cos(fangles[2]);
+   dfMx[0][0] = -sz*cy;
+   dfMx[0][1] =  sz*sy*sx - cz*cx;
+   dfMx[0][2] =  sz*sy*cx + cz*sx;
+   dfMx[1][0] =  cz*cy;
+   dfMx[1][1] = -cz*sy*sx - sz*cx;
+   dfMx[1][2] = -cz*sy*cx + sz*sx;
+   dfMx[2][0] =  0.0;
+   dfMx[2][1] =  0.0;
+   dfMx[2][2] =  0.0;
+}
+//______________________________________________________________________
+void AliITSAlignmentModule::LtoG(Double_t xl[],Double_t xg[]){
+
+    Int_t i;
+    for(i=0;i<3;i++) xg[i] = fx0[i];
+    for(i=0;i<3;i++)for(Int_t j=0;j<3;j++) xg[i] += fM[j][i]*xl[j];
+}
+//______________________________________________________________________
+void AliITSAlignmentModule::GtoL(Double_t xg[],Double_t xl[]){
+    Int_t i;
+    for(i=0;i<3;i++) xl[i] = 0.0;
+    for(i=0;i<3;i++)for(Int_t j=0;j<3;j++)xl[i]+=fM[i][j]*(xg[j]-fx0[j]);
+}
+//______________________________________________________________________
+Double_t AliITSAlignmentModule::Chi2(Double_t p[]){
+    Int_t    i,j,k,l,n=0,indx;
+    Double_t chi=0.0,xo[3],xi[3],xg[3],Ex[3][3];
+    AliITSAlignmentTrack *tr;
+
+    for(i=0;i<3;i++) fx0[i] = p[i];
+    SetByAngles(&(p[3]));
+
+    for(i=0;i<ftrksM->GetEntriesFast();i++) {
+       tr = (AliITSAlignmentTrack *)(ftrksM->At(i));
+       for(j=0;j<tr->GetNumberOfClustersSl();j++){
+           tr->GetIndex(j,indx);
+           if(indx==findex){
+               n++;
+               tr->GetPointG(j,(Double_t *)xi);
+               tr->func(xi,xo);
+               tr->GetPointL(j,(Double_t *)xi);
+               tr->GetErrorG(j,(Double_t **)Ex);
+               LtoG(xi,xg);
+               for(k=0;k<3;k++)for(l=0;l<3;l++)
+                   chi += (xg[k] - xo[k])*Ex[k][l]*(xg[l]-xo[l]);
+           } // end if indx==findex
+       } // end for j
+    } // end for i
+    if(n<7) return chi;
+    return chi/(Double_t)(n-6);
+}
+//______________________________________________________________________
+void AliITSAlignmentModule::dChi2(Double_t p[],Double_t dChi2[]){
+    Int_t    i,j,k,l,m,n=0,indx;
+    Double_t chi[6]={0.0,0.0,0.0,0.0,0.0,0.0},xo[3],xi[3],xg[3],Ex[3][3];
+    Double_t dxdp[3][6],fMx[3][3],fMy[3][3],fMz[3][3];
+    AliITSAlignmentTrack *tr;
+
+    for(i=0;i<3;i++) fx0[i] = p[i];
+    SetByAngles(&(p[3]));
+    dfMdthx(fMx);
+    dfMdthy(fMy);
+    dfMdthz(fMz);
+    for(i=0;i<3;i++)for(j=0;j<6;j++)  dxdp[i][j] = 0.0;
+    dxdp[0][0] = 1.0; // dx/dx
+    dxdp[1][1] = 1.0; // dy/dy
+    dxdp[2][2] = 1.0; // dz/dz
+
+    for(i=0;i<ftrksM->GetEntriesFast();i++) {
+       tr = (AliITSAlignmentTrack *)(ftrksM->At(i));
+       for(j=0;j<tr->GetNumberOfClustersSl();j++){
+           tr->GetIndex(j,indx);
+           if(indx==findex){
+               n++;
+               tr->GetPointG(j,(Double_t *)xi);
+               tr->func(xi,xo);
+               tr->GetPointL(j,(Double_t *)xi);
+               tr->GetErrorG(j,(Double_t **)Ex);
+               LtoG(xi,xg);
+               for(m=0;m<3;m++) for(k=0;k<3;k++){
+                   dxdp[m][3] += fMx[m][k]*xi[k];
+                   dxdp[m][4] += fMy[m][k]*xi[k];
+                   dxdp[m][5] += fMz[m][k]*xi[k];
+               } // end for m
+               for(m=0;m<6;m++){
+                   for(k=0;k<3;k++)for(l=0;l<3;l++)
+                       chi[m] += (xg[k] - xo[k])*Ex[k][l]*dxdp[l][m];
+               } // end for m
+           } // end if indx==findex
+       } // end for j
+    } // end for i
+    if(n<7) return ;
+    for(m=0;m<6;m++) chi[m] /= (Double_t)(n-6);
+    return;
+}
+//______________________________________________________________________
+void AliITSAlignmentModule::AlignModule(){
+    static Int_t npar=6;
+    Int_t    iter,i;
+    //Double_t p[npar],fret,gtol=1.0E-5;
+    Double_t p[6],fret,gtol=1.0E-5;
+
+    for(i=0;i<3;i++) {p[i] = fx0[i]; p[i+3] = fangles[i];}
+    MRVMminimization(npar,(Double_t *)p,fret,gtol,iter);
+    for(i=0;i<3;i++) {fx0[i] = p[i]; fangles[i] = p[i+3];}
+    printf("AlignModule #%d:Xt=(%e,%e,%e) cm angles=(%e,%e,%e)rad,"
+          " Chi2=%e loops=%d\n",findex,
+          fx0[0],fx0[1],fx0[2],fangles[0],fangles[1],fangles[2],fret,iter);
+}
+//______________________________________________________________________
+void AliITSAlignmentModule::Streamer(TBuffer &R__b){
+   // Stream an object of class AliITSAlignmentModule.
+
+   if (R__b.IsReading()) {
+      Version_t R__v = R__b.ReadVersion(); if (R__v) { }
+      TObject::Streamer(R__b);
+      R__b >> findex;
+      R__b >> flay;
+      R__b >> flad;
+      R__b >> fdet;
+      R__b >> ftrksM;
+      R__b >> fChi2;
+//      R__b.ReadStaticArray(fx0);
+//      R__b.ReadStaticArray((double*)fM);
+//      R__b.ReadStaticArray(fangles);
+   } else {
+      R__b.WriteVersion(AliITSAlignmentModule::IsA());
+      TObject::Streamer(R__b);
+      R__b << findex;
+      R__b << flay;
+      R__b << flad;
+      R__b << fdet;
+      R__b << ftrksM;
+      R__b << fChi2;
+//      R__b.WriteArray(fx0, 3);
+//      R__b.WriteArray((double*)fM, 9);
+//      R__b.WriteArray(fangles, 3);
+   }
+}
diff --git a/ITS/AliITSAlignmentModule.h b/ITS/AliITSAlignmentModule.h
new file mode 100644 (file)
index 0000000..dc2701c
--- /dev/null
@@ -0,0 +1,79 @@
+#ifndef ALIITSALIGNMENTMODULE_H
+#define ALIITSALIGNMENTMODULE_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+/* $Id$ */
+/* $Author$ */
+/* $Date$ */
+/* $Name$ */
+/* $Header$ */
+/*
+  $Log$
+  Revision 1.1.2.2  2000/03/04 23:39:56  nilsen
+  Fixed the logs???
+
+  Revision 1.1.2.1  2000/03/02 20:12:57  nilsen
+  A new class useful for ITS detector Alignment studdies
+*/
+/* $Revision$ */
+
+// Standard C & C++ libraries
+#include <TObject.h>
+
+// Standard Root Libraries
+#include "TParticle.h"
+
+// ITS libraries
+#include "AliITSgeom.h"
+
+class AliITSAlignmentModule : public TObject{
+///////////////////////////////////////////////////////////////////////////
+//      A track class define exclusively for the use in doing ITS detector
+// alignment studdies. Not intended for general use.
+// Author: B. S. Nilsen
+// Date:   January 17 2000
+///////////////////////////////////////////////////////////////////////////
+
+ protected:
+
+    Int_t     findex,flay,flad,fdet;
+    TObjArray *ftrksM;
+    Double_t  fChi2;
+    Double_t  fx0[3],fM[3][3],fangles[3];
+
+ public:
+
+    AliITSAlignmentModule();
+    AliITSAlignmentModule(Int_t index,AliITSgeom *gm,
+                         Int_t  ntrk,AliITSAlignmentTrack *trk);
+    virtual ~AliITSAlignmentModule() {;}; // default destructor OK
+    Int_t GetIndex(){return findex;}
+    void GetId(Int_t &lay,Int_t &lad,Int_t &det){lay=flay;lad=flad;det=fdet;}
+    Double_t * GetTranslationVector(){return fx0;}
+    Double_t * GetRotationAngles(){return fangles;}
+    Double_t ComputeChi2();
+    Double_t GetChi2(){return fChi2;}
+    void AlignModule();
+    void lnsrch(Int_t npar,Double_t *xold,Double_t fold,Double_t *g,
+               Double_t *p,Double_t *x,Double_t &f,Double_t stpmax,
+               Int_t &check);
+    void MRVMminimization(Int_t npar,Double_t *p,Double_t &fret,Double_t gtol,
+                         Int_t &iter);
+    void SetByAngles(Double_t *th);
+
+ private:
+    void dfMdthx(Double_t dfMx[3][3]);
+    void dfMdthy(Double_t dfMx[3][3]);
+    void dfMdthz(Double_t dfMx[3][3]);
+    void LtoG(Double_t xl[],Double_t xg[]);
+    void GtoL(Double_t xg[],Double_t xl[]);
+    Double_t Chi2(Double_t p[]);
+    void dChi2(Double_t p[],Double_t dChi2[]);
+    
+
+    ClassDef(AliITSAlignmentModule,1) // Module class for ITS Alignment
+
+
+};
+#endif
diff --git a/ITS/AliITSAlignmentTrack.cxx b/ITS/AliITSAlignmentTrack.cxx
new file mode 100644 (file)
index 0000000..52549bc
--- /dev/null
@@ -0,0 +1,400 @@
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+/* $Id$ */
+/* $Author$ */
+/* $Date$ */
+/* $Name$ */
+/* $Header$ */
+/*
+   $Log$
+   Revision 1.1.2.2  2000/06/04 16:35:37  nilsen
+   One more try to fix log comments.
+
+   Revision 1.1.2.1  2000/03/02 20:13:52  nilsen
+   A new class useful for ITS detector alignment studdies.
+ */
+/* $Revision$ */
+
+// Standard Root Libraries
+#include <TMath.h>
+
+// ITS libraries
+#include "AliITSgeom.h"
+#include "AliITSAlignmentTrack.h"
+#include "AliITSstatistics.h"
+#include "AliITSstatistics2.h"
+
+ClassImp(AliITSAlignmentTrack)
+
+//______________________________________________________________________
+AliITSAlignmentTrack::AliITSAlignmentTrack(){
+
+    ftrack=fnclust=0,fnclustMax=0;
+    ffunc=-1;
+    fclust=0;
+    for(Int_t i=0;i<10;i++) fpar[i]=0.0;
+    fpx=fpy=fpz=fp=fpt=0.0;
+    fChi2=-1.0;
+}
+//______________________________________________________________________
+AliITSAlignmentTrack::~AliITSAlignmentTrack(){
+
+    ftrack=fnclust=0,fnclustMax=0;
+    ffunc=-1;
+    delete[] fclust;
+    fclust=0;
+    for(Int_t i=0;i<10;i++) fpar[i]=0.0;
+    fpx=fpy=fpz=fp=fpt=0.0;
+    fChi2=-1.0;
+}
+//______________________________________________________________________
+void AliITSAlignmentTrack::func0(Double_t *go,Double_t *gi){
+    Double_t x,y,z;
+
+    x = gi[0];
+    y = gi[1];
+    z = gi[2];
+    x = fpar[0]+fpar[1]*z;
+    y = fpar[2]+fpar[3]*z;
+    go[0] = x;
+    go[1] = y;
+    go[2] = z;
+    return;
+}
+//______________________________________________________________________
+void AliITSAlignmentTrack::func1(Double_t *go,Double_t *gi){
+    Double_t x,y,z;
+
+    x = gi[0];
+    y = gi[1];
+    z = gi[2];
+    x = fpar[0]+fpar[1]*y;
+    z = fpar[2]+fpar[3]*y;
+    go[0] = x;
+    go[1] = y;
+    go[2] = z;
+    return;
+}
+//______________________________________________________________________
+void AliITSAlignmentTrack::func2(Double_t *go,Double_t *gi){
+    Double_t x,y,z,r,th;
+
+    x = gi[0];
+    y = gi[1];
+    z = gi[2];
+    th = TMath::ATan2(y-fpar[1],x-fpar[0]);
+    r  = TMath::Hypot(x-fpar[0],y-fpar[1]);
+    if(th<0.0) th += 2.0*TMath::Pi();
+    x = fpar[0]+fpar[2]*TMath::Cos(th);
+    y = fpar[1]+fpar[2]*TMath::Sin(th);
+    z = fpar[3]+fpar[4]*r;
+    go[0] = x;
+    go[1] = y;
+    go[2] = z;
+    return;
+}
+//______________________________________________________________________
+void AliITSAlignmentTrack::func(Double_t *go,Double_t *gi){
+
+    switch (ffunc){
+    case 0:
+       func0(go,gi);
+       return;
+    case 1:
+       func1(go,gi);
+       return;
+    case 2:
+       func2(go,gi);
+       return;
+    } // end switch
+}
+//______________________________________________________________________
+Double_t AliITSAlignmentTrack::ComputeChi2(){
+    Int_t    i,j,k,l;
+    Double_t chi2=0.0,go[3],gi[3];
+
+    switch (ffunc) {
+    case -1:
+       return -1.0;
+       break;
+    case 0:
+       for(i=0;i<fnclust;i++){
+           for(j=0;j<3;j++)gi[j] = fclust[i].fxg[j];
+           func0(go,gi);
+           for(k=0;k<2;k++) for(l=0;l<2;l++) {
+               //if(k==2 || l==2) continue;
+               chi2 += (go[k] - gi[k])*fclust[i].fExg[k][l]*(go[l] - gi[l]);
+           } // end for k,l
+       } // end for i
+       break;
+    case 1:
+       for(i=0;i<fnclust;i++){
+           for(j=0;j<3;j++)gi[j] = fclust[i].fxg[j];
+           func1(go,gi);
+           for(k=0;k<3;k++) for(l=0;l<3;l++){
+               if(k==1 || l==1) continue;
+               chi2 += (go[k] - gi[k])*fclust[i].fExg[k][l]*(go[l] - gi[l]);
+           } // end for k,l
+       } // end for i
+       break;
+    case 2:
+       for(i=0;i<fnclust;i++){
+           for(j=0;j<3;j++)gi[j] = fclust[i].fxg[j];
+           func0(go,gi);
+           for(k=0;k<3;k++) for(l=0;l<3;l++){
+               chi2 += (go[k] - gi[k])*fclust[i].fExg[k][l]*(go[l] - gi[l]);
+           } // end for k,l
+       } // end for i
+       break;
+    } // end switch
+
+    fChi2 = (Float_t) chi2;
+
+    return  chi2;
+}
+//______________________________________________________________________
+Int_t AliITSAlignmentTrack::FindCircleCenter(Double_t *xc,Double_t *x1,
+                                           Double_t  *x2,Double_t *x3){
+////////////////////////////////////////////////////////////////////////
+//     This was derived as folows. Given three non-linear points find
+// the circle that is therefor defined by those three non-linar points.
+// Assume that the circle is centers at xc,yc and has a radous R. Then
+// (1) R^2 = (x1-xc)^2 + (y1-yc)^2
+// (2) R^2 = (x2-xc)^2 + (y2-yc)^2
+// (3) R^2 = (x3-xc)^2 + (y3-yc)^2.
+// Now consider the two equations derived from the above
+// (1) - (2) = x1^2 - x2^2 -2xc(x1-x2) + y1^2 - y2y2 -2yc(y1-y2) = 0
+// (1) - (3) = x1^2 - x3^2 -2xc(x1-x3) + y1^2 - y3y2 -2yc(y1-y3) = 0
+// solving these two equations for x0 and y0 gives
+// xc = +{(y1-y2)*(y1-y3)*(y1-y3)+x1*x1*(y1-y3)+x2*x2*(y3-y1)+x3*x3*(y1-y2)}/2d
+// yc = -{(x1-x2)*(x1-x3)*(x1-x3)+y1*y1*(x1-x3)+y2*y2*(x3-x1)+y3*y3*(x1-x2)}/2d
+// with d = (x1-x2)*(y1-y3) - (x1-x3)*(y1-y2)
+////////////////////////////////////////////////////////////////////////
+    Double_t d;
+
+    d = (x1[0]-x2[0])*(x1[1]-x3[1]) - (x1[0]-x3[0])*(x1[1]-x2[1]);
+    if(d==0.0) return 0;  // fits to a line!
+
+    xc[0] = (x1[1]-x2[1])*(x1[1]-x3[1])*(x1[1]-x3[1])+
+            x1[0]*x1[0]*(x1[1]-x3[1])+
+             x2[0]*x2[0]*(x3[1]-x1[1])+
+             x3[0]*x3[0]*(x1[1]-x2[1]);
+    xc[1] = (x1[0]-x2[0])*(x1[0]-x3[0])*(x1[0]-x3[0])+
+             x1[1]*x1[1]*(x1[0]-x3[0])+
+            x2[1]*x2[1]*(x3[0]-x1[0])+
+             x3[1]*x3[1]*(x1[0]-x2[0]);
+    xc[0] = +0.5*xc[0]/d;
+    xc[1] = -0.5*xc[1]/d;
+
+    return 1;
+}
+//______________________________________________________________________
+Int_t AliITSAlignmentTrack::FitTrackToLineG(){
+// Xg = fpar[0] + fpar[1] * Zg
+// Yg = fpar[2] + fpar[3] * Zg;
+// Local Variables
+    Int_t   i;
+    Double_t x,y,z,wx,wy;
+    Double_t a,b,c,d;
+    AliITSstatistics2 *sx = new AliITSstatistics2(4);
+    AliITSstatistics2 *sy = new AliITSstatistics2(4);
+    Double_t b0,d0;
+
+    fChi2 = -1.0;
+    ffunc = 0;
+    if(fnclust<3) return -1;
+
+    b  = (fclust[0].fxg[0]-fclust[fnclust].fxg[0])/
+         (fclust[0].fxg[2]-fclust[fnclust].fxg[2]);
+    d  = (fclust[0].fxg[1]-fclust[fnclust].fxg[1])/
+         (fclust[0].fxg[2]-fclust[fnclust].fxg[2]);
+    do{
+       b0 = b;
+       d0 = d;
+       for(i=0;i<fnclust;i++){
+           sx->Reset();
+           sy->Reset();
+           x    = fclust[i].fxg[0];
+           y    = fclust[i].fxg[1];
+           z    = fclust[i].fxg[2];
+           wx   = 1./(1./fclust[i].fExg[0][0] +
+                      (1./fclust[i].fExg[2][2])*b0*b0);// 1.0/rms^2
+           wy   = 1./(1./fclust[i].fExg[1][1] +
+                      (1./fclust[i].fExg[2][2])*d0*d0);// 1.0/rms^2
+           sx->AddValue(x,z,wx);
+           sy->AddValue(y,z,wy);
+       } // end for i
+       fChi2  = sx->FitToLine(a,b);
+       fChi2 += sy->FitToLine(c,d);
+       //} while(fabs(b0-b)<1.E-5 && fabs(d0-d)<1.E-5);
+    } while(TMath::Abs(b0-b)<1.E-5 && TMath::Abs(d0-d)<1.E-5);
+    fpar[0] = a;
+    fpar[1] = b;
+    fpar[2] = c;
+    fpar[3] = d;
+    return 0;
+}
+//______________________________________________________________________
+Int_t AliITSAlignmentTrack::FitTrackToLineL(AliITSgeom *gm){
+// X = fpar[0] + fpar[1] * y;
+// Z = fpar[2] + fpar[3] * y;
+// in the local coordinate system of the detector fclust[0].findex.
+   // Local Variables
+   Int_t   i,j,k;
+   Double_t wx/*,wy*/,wz,Exll[3][3];
+   Double_t a,b,c,d;
+   Double_t xg[3],xl[3],x2g[3],x2l[3];
+   AliITSstatistics2 *Fx  = new AliITSstatistics2(2);
+   AliITSstatistics2 *Fz  = new AliITSstatistics2(2);
+
+   fChi2 = -1.0;
+   ffunc = 1;
+   if(fnclust<3) return -1;
+
+   Int_t Npts = fnclust;
+   for(i=0;i<Npts;i++){
+       for(j=0;j<3;j++)for(k=0;k<3;k++) Exll[j][k] = fclust[i].fExl[j][k];
+       for(j=0;j<3;j++){x2l[j] = fclust[i].fxl[j];}
+       gm->LtoL(fclust[i].findex,fclust[0].findex,x2l,xl);
+       gm->LtoLErrorMatrix(fclust[i].findex,fclust[0].findex,
+                          (Double_t **) fclust[i].fExl,(Double_t **) Exll);
+       wx = Exll[0][0];
+       wz = Exll[2][2];
+       Fx->AddValue(xl[0],xl[1],wx);
+       Fz->AddValue(xl[2],xl[1],wz);
+   } // end for i
+   fChi2  = Fx->FitToLine(a,b);
+   fChi2 += Fz->FitToLine(c,d);
+   fpar[0] = a;
+   fpar[1] = b;
+   fpar[2] = c;
+   fpar[3] = d;
+   // convert to global if posible.
+   xl[0]  = a;
+   xl[1]  = 0.0;
+   xl[2]  = c;
+   x2l[0] = a+b;
+   x2l[1] = 1.0;
+   x2l[2] = c+d;
+   gm->LtoG(fclust[0].findex,xl,xg);
+   gm->LtoG(fclust[0].findex,x2l,x2g);
+   c = xg[2] - x2g[2];
+   if(c!=0.0){
+       b = (xg[0] - x2g[0])/c;
+       d = (xg[1] - x2g[1])/c;
+       a = xg[0] - b*xg[2];
+       c = xg[1] - d*xg[2];
+       fpar[4] = a;
+       fpar[5] = b;
+       fpar[6] = c;
+       fpar[7] = d;
+   }else{
+       fpar[4] = 0.0;
+       fpar[5] = 0.0;
+       fpar[6] = 0.0;
+       fpar[7] = 0.0;
+       return -1;
+   }// end if c!=0.0
+   return 0;
+}
+//______________________________________________________________________
+void AliITSAlignmentTrack::FitToFunction(Int_t n,AliITSgeom *gm){
+    Int_t i,j,k,l;
+    Double_t r,w,xc[3],x1[3],x2[3],x3[3];
+    AliITSstatistics2 *sa = new AliITSstatistics2(4);
+    AliITSstatistics2 *sb = new AliITSstatistics2(4);
+
+    ffunc = -1;
+    if(fnclust<3) return;
+
+    switch (n){
+    case -1:
+       return;
+       break;
+    case 0:
+       ffunc = 0;
+       FitTrackToLineG();
+       return;
+       break;
+    case 1:
+       ffunc = 1;
+       FitTrackToLineL(gm);
+       return;
+       break;
+    case 2:
+       ffunc = 2;
+       sa->Reset();
+       sb->Reset();
+       for(i=0;i<fnclust;i++){
+           for(l=0;l<3;l++) x1[l] = (Double_t) fclust[i].fxg[l];
+           r = TMath::Hypot((Double_t)x1[0],(Double_t)x1[1]);
+           w = (Double_t) (fclust[i].fExg[2][2]);
+           sb->AddValue((Double_t)fclust[i].fxg[2],r,w);
+           if(i<fnclust-2)for(j=i+1;j<fnclust-1;j++)for(k=j+1;k<fnclust;k++){
+               for(l=0;l<3;l++) x2[l] = (Double_t) fclust[j].fxg[l];
+               for(l=0;l<3;l++) x3[l] = (Double_t) fclust[k].fxg[l];
+               w = 0.0;
+               w += TMath::Hypot((Double_t)fclust[i].fExg[0][0],
+                                 (Double_t)fclust[i].fExg[1][1]);
+               w += TMath::Hypot(w,
+                           TMath::Hypot((Double_t)fclust[j].fExg[0][0],
+                                        (Double_t)fclust[j].fExg[1][1]));
+               w += TMath::Hypot(w,
+                           TMath::Hypot((Double_t)fclust[k].fExg[0][0],
+                                        (Double_t)fclust[k].fExg[1][1]));
+               if(FindCircleCenter(xc,x1,x2,x3)==0){ // Can't find circle
+                   FitToFunction(1,gm); // fit to line.
+                   return;
+               } // end if
+               sa->AddValue(xc[1],xc[0],w);
+           } // end for j,k
+       } // end for i
+       fpar[0] = sa->GetMeanX();
+       fpar[1] = sa->GetMeanY();
+       fpar[2] = sb->GetMeanX();
+       fChi2   = sb->FitToLine(fpar[3],fpar[4]);
+       fChi2   = (Float_t) ComputeChi2();
+       return;
+       break;
+    default:
+       return;
+       break;
+    } // end switch
+    return;
+}
+//______________________________________________________________________
+void AliITSAlignmentTrack::Streamer(TBuffer &R__b){
+   // Stream an object of class AliITSAlignmentTrack.
+
+   if (R__b.IsReading()) {
+      Version_t R__v = R__b.ReadVersion(); if (R__v) { }
+      TObject::Streamer(R__b);
+      R__b >> ftrack;
+      R__b >> fnclust;
+      R__b >> fnclustMax;
+//      R__b >> fclust;
+      R__b >> ffunc;
+      R__b.ReadStaticArray(fpar);
+      R__b >> fChi2;
+      R__b >> fpx;
+      R__b >> fpy;
+      R__b >> fpz;
+      R__b >> fp;
+      R__b >> fpt;
+   } else {
+      R__b.WriteVersion(AliITSAlignmentTrack::IsA());
+      TObject::Streamer(R__b);
+      R__b << ftrack;
+      R__b << fnclust;
+      R__b << fnclustMax;
+//      R__b << fclust;
+      R__b << ffunc;
+      R__b.WriteArray(fpar, 10);
+      R__b << fChi2;
+      R__b << fpx;
+      R__b << fpy;
+      R__b << fpz;
+      R__b << fp;
+      R__b << fpt;
+   }
+}
diff --git a/ITS/AliITSAlignmentTrack.h b/ITS/AliITSAlignmentTrack.h
new file mode 100644 (file)
index 0000000..a802bb7
--- /dev/null
@@ -0,0 +1,158 @@
+#ifndef ALIITSALIGNMENTTRACK_H
+#define ALIITSALIGNMENTTRACK_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+/* $Id$ */
+/* $Author$ */
+/* $Date$ */
+/* $Name$ */
+/* $Header$ */
+/*
+   $Log$
+   Revision 1.1.2.4  2000/06/04 16:35:24  nilsen
+   One more try to fix log comments.
+
+   Revision 1.1.2.3  2000/03/12 16:05:55  nilsen
+   Fixed but in $Log$
+   Fixed but in Revision 1.1.2.4  2000/06/04 16:35:24  nilsen
+   Fixed but in One more try to fix log comments.
+   Fixed but in, hopefully.
+  
+   Revision 1.1.2.2  2000/03/04 23:40:19  nilsen
+   Fixed the logs???
+  
+   Revision 1.1.2.1  2000/03/02 20:14:25  nilsen
+   A new class useful for ITS detector alignment studdies. 
+*/
+/*   $Revision$ */
+
+// Standard C & C++ libraries
+
+// Standard Root Libraries
+#include <TObject.h>
+#include <TParticle.h>
+
+// ITS libraries
+#include "AliITSgeom.h"
+
+struct TClustAl_sl{
+    Int_t   findex;
+    Float_t fxg[3],fExg[3][3];
+    Float_t fxl[3],fExl[3][3];
+};
+
+
+
+class AliITSAlignmentTrack : public TObject{
+///////////////////////////////////////////////////////////////////////////
+//      A track class define exclusively for the use in doing ITS detector
+// alignment studdies. Not intended for general use.
+// Author: B. S. Nilsen
+// Date:   January 17 2000
+///////////////////////////////////////////////////////////////////////////
+
+ protected:
+
+    Int_t        ftrack,fnclust,fnclustMax;
+    TClustAl_sl  *fclust;
+    Int_t        ffunc;
+    Double_t     fpar[10];
+    Float_t      fChi2;
+    Float_t      fpx,fpy,fpz,fp,fpt;
+    // x=fp[0]+fp[1]*z and y=fp[2]+fp[3]*z                 : ffunc = 0
+    //
+    // x=fp[0]+fp[1]*y and z=fp[2]+fp[3]*y                 : ffunc = 1
+    //
+    // x=fp[0]+fp[2]*cos(th), y=fp[1]+fp[2]*sin(th),
+    // and z=fp[3]+f[4]*th   th[i]=atan2(y[i]-y0,x[i]-x0)  : ffunc = 2
+
+ public:
+
+    AliITSAlignmentTrack();
+    virtual ~AliITSAlignmentTrack();
+
+    void CreatePoints(Int_t n){fclust = new TClustAl_sl[n];fnclustMax=n;
+                  fnclust=0;for(Int_t j=0;j<fnclustMax;j++)
+                 for(Int_t i=0;i<3;i++)fclust[j].fxl[i]=fclust[j].fxg[i]=0.0;}
+    Int_t AddPointL(Int_t n,Int_t indx,Float_t *lp,Float_t **lep){
+       if(n>=fnclustMax)return 0;fclust[n].findex=indx;
+       for(Int_t i=0;i<3;i++){fclust[n].fxl[i]=lp[i];for(Int_t j=0;j<3;j++)
+           fclust[n].fExl[i][j]=lep[i][j];}return -1;}
+    Int_t AddPointLastL(Int_t indx,Float_t *lp,Float_t **lep){
+       if(++fnclust>=fnclustMax)return 0;//+first
+       fclust[fnclust].findex=indx;
+       for(Int_t i=0;i<3;i++){fclust[fnclust].fxl[i]=lp[i];
+          for(Int_t j=0;j<3;j++)fclust[fnclust].fExl[i][j]=lep[i][j];
+       }return -1;}
+    Int_t GetPointL(Int_t n,Float_t *lp){if(n>=fnclustMax)return 0;
+                       for(Int_t i=0;i<3;i++)
+                          lp[i]=fclust[n].fxl[i];return -1;}
+    Int_t GetPointL(Int_t n,Double_t *lp){if(n>=fnclustMax)return 0;
+                       for(Int_t i=0;i<3;i++)
+                          lp[i]=(Double_t)fclust[n].fxl[i];return -1;}
+    Int_t GetPointG(Int_t n,Float_t *gp){if(n>=fnclustMax)return 0;
+                       for(Int_t i=0;i<3;i++)
+                          gp[i]=fclust[n].fxg[i];return -1;}
+    Int_t GetPointG(Int_t n,Double_t *gp){if(n>=fnclustMax)return 0;
+                       for(Int_t i=0;i<3;i++)
+                          gp[i]=(Double_t)fclust[n].fxg[i];return -1;}
+    Int_t GetErrorG(Int_t n,Float_t **gp){if(n>=fnclustMax)return 0;
+                       for(Int_t i=0;i<3;i++)for(Int_t j=0;j<3;j++)
+                          gp[i][j]=fclust[n].fExg[i][j];return -1;}
+    Int_t GetErrorG(Int_t n,Double_t **gp){if(n>=fnclustMax)return 0;
+                       for(Int_t i=0;i<3;i++)for(Int_t j=0;j<3;j++)
+                          gp[i][j]=(Double_t)fclust[n].fExg[i][j];return -1;}
+    Int_t GetErrorL(Int_t n,Float_t **gp){if(n>=fnclustMax)return 0;
+                       for(Int_t i=0;i<3;i++)for(Int_t j=0;j<3;j++)
+                          gp[i][j]=fclust[n].fExl[i][j];return -1;}
+    Int_t GetErrorL(Int_t n,Double_t **gp){if(n>=fnclustMax)return 0;
+                       for(Int_t i=0;i<3;i++)for(Int_t j=0;j<3;j++)
+                          gp[i][j]=(Double_t)fclust[n].fExl[i][j];return -1;}
+    Int_t GetIndex(Int_t n,Int_t &indx){if(n>=fnclustMax)return 0;
+                                              indx=fclust[n].findex;return -1;}
+
+    void SetGlobalPosition(AliITSgeom *gm){
+       for(Int_t i=0;i<fnclust;i++){
+           gm->LtoG(fclust[i].findex,fclust[i].fxl,fclust[i].fxg);
+         gm->LtoGErrorMatrix(fclust[i].findex,(Double_t **) fclust[i].fExl,
+                            (Double_t **) fclust[i].fExg);}}
+    void SetTrackNumber(Int_t trk) {ftrack=trk;}
+    void SetTParticle(TParticle *prt){fpx=prt->Px();fpy=prt->Py();
+                                      fpz=prt->Pz();fp=prt->P();fpt=prt->Pt();}
+    void SetPx(Float_t px) {fpx=px;}
+    void SetPy(Float_t py) {fpy=py;}
+    void SetPz(Float_t pz) {fpz=pz;}
+    void SetP(Float_t p) {fp=p;}
+    void SetPt(Float_t pt) {fpt=pt;}
+    void SetParameter(Int_t n,Double_t a) {if(n>=0&&n<10);fpar[n]=a;}
+    void SetChi2(Float_t chi2) {fChi2=chi2;}
+    void SetFunctionNumber(Int_t fn) {ffunc = fn;}
+
+    Int_t GetTrackNumber() {return ftrack;}
+    Int_t GetNumberOfClustersSl() {return fnclust;}
+    Float_t GetPx() {return fpx;}
+    Float_t GetPy() {return fpy;}
+    Float_t GetPz() {return fpz;}
+    Float_t GetP() {return fp;}
+    Float_t GetPt() {return fpt;}
+    Double_t GetParameter(Int_t n) {if(n>=0&&n<10) return fpar[n]; return -1.;}
+    Float_t GetChi2() {return fChi2;}
+    Int_t   GetfunID() {return ffunc;}
+
+    void FitToFunction(Int_t n,AliITSgeom *gm);
+    void func(Double_t *go,Double_t *gi);
+    void func0(Double_t *go,Double_t *gi);
+    void func1(Double_t *go,Double_t *gi);
+    void func2(Double_t *go,Double_t *gi);
+    Int_t FitTrackToLineG();
+    Int_t FitTrackToLineL(AliITSgeom *gm);
+    Int_t FindCircleCenter(Double_t *xc,Double_t *x1,
+                          Double_t *x2,Double_t *x3);
+
+    private:
+    Double_t ComputeChi2();
+
+    ClassDef(AliITSAlignmentTrack,1) // Track class for ITS Alignment
+
+};
+#endif
index c925bc4..74bac6d 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-
 #include "AliITSClusterFinder.h"
-#include "TTree.h"
 #include "AliRun.h"
-#include <TCanvas.h>
-#include <TH1.h>
-#include <TPad.h>
-#include <TGraph.h> 
-#include <TPostScript.h> 
-#include <TMinuit.h> 
-
-class AliITSRecPointNew;
+#include "AliITS.h"
 
 //----------------------------------------------------------
 
index 509fcd8..21b5df0 100644 (file)
@@ -3,17 +3,22 @@
 
 
 ////////////////////////////////////////////////
-//  ITS Cluster Finder Class                 //
+//  ITS Cluster Finder Class                  //
 ////////////////////////////////////////////////
 
-#include "AliITSMap.h"
+#include <TObject.h>
+#include <TClonesArray.h>
+
+class AliITSMap;
+class AliITSresponse;
+class AliITSsegmentation;
+class AliITSRawCluster;
+class AliITS;
 
 //---------------------------------------------------------------
 class AliITSClusterFinder :public TObject
 {
 public:
-  TClonesArray           *fDigits;      // digits
-  Int_t                   fNdigits;     // num of digits
   
   AliITSClusterFinder(AliITSsegmentation *seg, AliITSresponse *resp, TClonesArray *digits);
   AliITSClusterFinder();
@@ -97,6 +102,11 @@ public:
   }
   
   // set the fitting methods in the derived classes 
+
+  // data members
+
+  TClonesArray           *fDigits;      // digits
+  Int_t                   fNdigits;     // num of digits
   
 protected:
   AliITSresponse         *fResponse;      // response
index 72dc8e1..fb44bc7 100644 (file)
@@ -15,6 +15,9 @@
 
 
 #include "AliITSClusterFinderSDD.h"
+#include "AliITSMapA2.h"
+#include "AliITSMapA1.h"
+#include "AliITS.h"
 #include "AliRun.h"
 
 
@@ -31,13 +34,12 @@ AliITSClusterFinderSDD::AliITSClusterFinderSDD
     fDigits=digits;
     fClusters=recp;
     fNclusters= fClusters->GetEntriesFast();
-    printf("SDD: fNclusters %d\n",fNclusters);
     SetCutAmplitude();
     SetDAnode();
     SetDTime();
-    SetMap();
     SetMinPeak();
     SetNCells();
+    SetMap();
 }
 
 //_____________________________________________________________________________
@@ -49,15 +51,25 @@ AliITSClusterFinderSDD::AliITSClusterFinderSDD()
     fDigits=0;
     fClusters=0;
     fNclusters=0;
+    fMap=0;
+    fMapA2=0;
     SetCutAmplitude();
     SetDAnode();
     SetDTime();
-    SetMap();
     SetMinPeak();
     SetNCells();
 
 }
 
+//_____________________________________________________________________________
+AliITSClusterFinderSDD::~AliITSClusterFinderSDD()
+{
+    // destructor
+
+    if(fMap) delete fMap;
+    if(fMapA2) delete fMapA2;
+
+}
 //__________________________________________________________________________
 AliITSClusterFinderSDD::AliITSClusterFinderSDD(const AliITSClusterFinderSDD &source){
   //     Copy Constructor 
@@ -65,6 +77,7 @@ AliITSClusterFinderSDD::AliITSClusterFinderSDD(const AliITSClusterFinderSDD &sou
   this->fClusters = source.fClusters ;
   this->fNclusters = source.fNclusters ;
   this->fMap = source.fMap ;
+  this->fMapA2 = source.fMapA2 ;
   this->fCutAmplitude = source.fCutAmplitude ;
   this->fDAnode = source.fDAnode ;
   this->fDTime = source.fDTime ;
@@ -81,6 +94,7 @@ AliITSClusterFinderSDD&
   this->fClusters = source.fClusters ;
   this->fNclusters = source.fNclusters ;
   this->fMap = source.fMap ;
+  this->fMapA2 = source.fMapA2 ;
   this->fCutAmplitude = source.fCutAmplitude ;
   this->fDAnode = source.fDAnode ;
   this->fDTime = source.fDTime ;
@@ -93,30 +107,8 @@ AliITSClusterFinderSDD&
 void AliITSClusterFinderSDD::SetMap()
 {
   // set map
-    if(!fMap) fMap=new AliITSMapA2(fSegmentation);
-
-}
-//_____________________________________________________________________________
-void AliITSClusterFinderSDD::FillMap()
-{
-  // fCoord1 = anode #
-  // fCoord2 = time sample
-
-  if (!fDigits) return; 
-  Int_t ndigits = fDigits->GetEntriesFast();
-  //printf("FillMap: ndigits %d\n",ndigits);
-  if (!ndigits) return;
-
-    AliITSdigitSDD *dig;
-    Int_t ndig;
-    for(ndig=0; ndig<ndigits; ndig++) {
-        dig = (AliITSdigitSDD*)fDigits->UncheckedAt(ndig);
-        Double_t signal=dig->fSignal;
-       //printf("FillMap: ndig fCoord1 fCoord2 signal %d %d %d %f\n",ndig,dig->fCoord1,dig->fCoord2,signal);
-        fMap->SetHit(dig->fCoord1,dig->fCoord2,signal);
-    }
-
+    if(!fMapA2) fMapA2=new AliITSMapA2(fSegmentation,fDigits,(double)fCutAmplitude);
+    if(!fMap) fMap=new AliITSMapA1(fSegmentation,fDigits);
 
 }
 //_____________________________________________________________________________
@@ -128,7 +120,6 @@ void AliITSClusterFinderSDD::Find1DClusters()
     AliITS *iTS=(AliITS*)gAlice->GetModule("ITS");
 
    // retrieve the parameters 
-   Int_t i;
    Int_t fNofMaps = fSegmentation->Npz();
    Int_t fMaxNofSamples = fSegmentation->Npx();
    Int_t fNofAnodes = fNofMaps/2;
@@ -139,7 +130,7 @@ void AliITSClusterFinderSDD::Find1DClusters()
    
    Float_t anodePitch = fSegmentation->Dpz(dummy);
    // map the signal
-   FillMap();
+   fMapA2->FillMap();
 
    // Piergiorgio's code - do not subtract baseline since we start
    // from digits and do not duplicate arrays, i.e. use fMap instead
@@ -147,11 +138,9 @@ void AliITSClusterFinderSDD::Find1DClusters()
  
 
   Int_t nofFoundClusters = 0;
-
+  Int_t i;
   Float_t **dfadc = new Float_t*[fNofMaps];
   for(i=0;i<fNofMaps;i++) dfadc[i] = new Float_t[fMaxNofSamples];
-   
-  
   Float_t fadc, fadc1, fadc2;
   Int_t j,k,idx,l,m;
   for(j=0;j<2;j++) {
@@ -159,8 +148,8 @@ void AliITSClusterFinderSDD::Find1DClusters()
       idx = j*fNofAnodes+k;
       // signal (fadc) & derivative (dfadc)
       for(l=0; l<fMaxNofSamples; l++) {
-       fadc2=(Float_t)fMap->GetSignal(idx,l);
-       fadc1=(Float_t)fMap->GetSignal(idx,l-1);
+       fadc2=(Float_t)fMapA2->GetSignal(idx,l);
+       fadc1=(Float_t)fMapA2->GetSignal(idx,l-1);
        if(l>0) dfadc[k][l-1] = fadc2-fadc1;
       } // samples
     } // anodes
@@ -192,10 +181,10 @@ void AliITSClusterFinderSDD::Find1DClusters()
        for(m=0;m<10;m++) {
          Int_t id = it+m;
          if(id>=fMaxNofSamples) break;
-          fadc=fMap->GetSignal(idx,id);
+          fadc=fMapA2->GetSignal(idx,id);
          if(fadc > fadcmax) {
            fadcmax = fadc;
-           if(fadc > fCutAmplitude) { lthra++; lthrt++; }
+           if(fadc > 0) { lthra++; lthrt++; }
            imax = id;
          }
          if(dfadc[k][id] > dfadcmax) {
@@ -205,19 +194,19 @@ void AliITSClusterFinderSDD::Find1DClusters()
        }
        it = imaxd;
        // skip if no signal over threshold
-       if(fMap->GetSignal(idx,imax) < fCutAmplitude) {it++; continue;}
+       if(fMapA2->TestHit(idx,imax) == kEmpty) {it++; continue;}
 
        if(k>0) {
-         if(fMap->GetSignal(idx-1,imax) > fCutAmplitude) lthra++;
+         if(fMapA2->TestHit(idx-1,imax) != kEmpty) lthra++;
        }
        if(k<fNofAnodes-1)
-         if(fMap->GetSignal(idx+1,imax) > fCutAmplitude) lthra++;
+         if(fMapA2->TestHit(idx+1,imax) != kEmpty) lthra++;
 
        if(imax>0) {
-         if(fMap->GetSignal(idx,imax-1) > fCutAmplitude) lthrt++;
+         if(fMapA2->TestHit(idx,imax-1) != kEmpty) lthrt++;
        }
        if(imax<fMaxNofSamples)
-         if(fMap->GetSignal(idx,imax+1) > fCutAmplitude) lthrt++;
+         if(fMapA2->TestHit(idx,imax+1) != kEmpty) lthrt++;
        
        // cluster charge
        Int_t tstart = it-1;
@@ -244,7 +233,7 @@ void AliITSClusterFinderSDD::Find1DClusters()
          Float_t clusterPeakAmplitude = 0.;
           Int_t its;
          for(its=tstart; its<=tstop; its++) {
-            fadc=fMap->GetSignal(idx,its);
+            fadc=fMapA2->GetSignal(idx,its);
            clusterCharge += fadc;
            if(fadc > clusterPeakAmplitude) clusterPeakAmplitude = fadc;
            clusterTime += fadc*its;
@@ -283,12 +272,8 @@ void AliITSClusterFinderSDD::Find1DClusters()
     } // anodes
   } // detectors (2)
 
-  Int_t nofClusters = fClusters->GetEntriesFast();
-  nofClusters -= fNclusters;
-
-  //printf("SDD- Find1Dclust: fNclusters nofClusters %d %d \n",fNclusters, nofClusters);
 
-  fMap->ClearMap();
+  fMapA2->ClearMap();
   
   for(i=0;i<fNofMaps;i++) delete[] dfadc[i];
   delete [] dfadc;
@@ -309,8 +294,6 @@ void  AliITSClusterFinderSDD::GroupClusters()
   Int_t nofClusters = fClusters->GetEntriesFast();
   nofClusters -= fNclusters;
 
-  //printf("SDD- GroupClusters: fNclusters nofClusters %d %d \n",fNclusters, nofClusters);
-
   AliITSRawClusterSDD *clusterI;
   AliITSRawClusterSDD *clusterJ;
 
@@ -328,8 +311,8 @@ void  AliITSClusterFinderSDD::GroupClusters()
       if(clusterI->T() < fTimeStep*10) fDAnode = 1.2;
       Bool_t pair = clusterI->Brother(clusterJ,fDAnode,fDTime);
       if(!pair) continue;
-      //      clusterI->Print();
-      //      clusterJ->Print();
+      //      clusterI->PrintInfo();
+      //      clusterJ->PrintInfo();
       clusterI->Add(clusterJ);
       label[j] = 1;
       fClusters->RemoveAt(j);
@@ -351,8 +334,6 @@ void AliITSClusterFinderSDD::SelectClusters()
   Int_t nofClusters = fClusters->GetEntriesFast();
   nofClusters -= fNclusters;
 
-  //printf("SDD- SelectClusters: fNclusters nofClusters %d %d \n",fNclusters, nofClusters);
-
   Int_t i;
   for(i=0; i<nofClusters; i++) { 
     AliITSRawClusterSDD *clusterI = (AliITSRawClusterSDD*) fClusters->At(i);
@@ -376,7 +357,6 @@ void AliITSClusterFinderSDD::SelectClusters()
 void AliITSClusterFinderSDD::GetRecPoints()
 {
   // get rec points
-  //static Int_t counter=0;
 
   AliITS *iTS=(AliITS*)gAlice->GetModule("ITS");
 
@@ -384,31 +364,32 @@ void AliITSClusterFinderSDD::GetRecPoints()
   Int_t nofClusters = fClusters->GetEntriesFast();
   nofClusters -= fNclusters;
 
-  //printf("SDD- GetRecPoints: fNclusters nofClusters %d %d \n",fNclusters, nofClusters);
-
-//  const Float_t kdEdXtoQ = 2.778e+2; // KeV -> number of e-hole pairs in Si
   const Float_t kconvGeV = 1.e-6; // GeV -> KeV
   const Float_t kconv = 1.0e-4; 
   const Float_t kRMSx = 38.0*kconv; // microns->cm ITS TDR Table 1.3
   const Float_t kRMSz = 28.0*kconv; // microns->cm ITS TDR Table 1.3
 
-  Int_t i;
+  fMap->FillMap();
+
+  Int_t i, ix, iz;
   for(i=0; i<nofClusters; i++) { 
     AliITSRawClusterSDD *clusterI = (AliITSRawClusterSDD*) fClusters->At(i);
+    fSegmentation->GetPadIxz(clusterI->X(),clusterI->Z(),ix,iz);
+    AliITSdigitSDD *dig = (AliITSdigitSDD*)fMap->GetHit(iz-1,ix-1);
     AliITSRecPoint rnew;
     rnew.SetX(clusterI->X());
     rnew.SetZ(clusterI->Z());
     rnew.SetQ(clusterI->Q());   // in KeV - should be ADC
-    //rnew.SetdEdX((clusterI->Q())/kdEdXtoQ);
     rnew.SetdEdX(kconvGeV*clusterI->Q());
     rnew.SetSigmaX2(kRMSx*kRMSx);
     rnew.SetSigmaZ2(kRMSz*kRMSz);
-    rnew.SetProbability(1.);
+    rnew.fTracks[0]=dig->fTracks[0];
+    rnew.fTracks[1]=dig->fTracks[1];
+    rnew.fTracks[2]=dig->fTracks[2];
     iTS->AddRecPoint(rnew);
-   //counter++;
   } // I clusters
-  //printf("counter %d\n",counter);
 
+  fMap->ClearMap();
 }
 
 //_____________________________________________________________________________
index f2c5a48..e4172da 100644 (file)
@@ -7,6 +7,8 @@
 
 #include "AliITSClusterFinder.h"
 
+class AliITSMapA2;
+
 class AliITSClusterFinderSDD :
  public AliITSClusterFinder
 
@@ -16,14 +18,12 @@ public:
   (AliITSsegmentation *seg, 
    AliITSresponse *response, TClonesArray *digits,TClonesArray *recpoints);
   AliITSClusterFinderSDD();
-  virtual ~AliITSClusterFinderSDD(){
-    // destructor
-  }
+  virtual ~AliITSClusterFinderSDD();
   AliITSClusterFinderSDD(const AliITSClusterFinderSDD &source); // copy constructor
   AliITSClusterFinderSDD& operator=(const AliITSClusterFinderSDD &source); // assignment operator
   
   virtual void SetMap();
-  virtual void SetCutAmplitude(Float_t thres=1.2) {
+  virtual void SetCutAmplitude(Float_t thres=0.0) {
     // set cut amplitude
     fCutAmplitude=thres;
   }
@@ -39,13 +39,11 @@ public:
     // SetMinPeak
     fMinPeak=minpeak;
   }
-  virtual void SetNCells(Int_t minc=4) {
+  virtual void SetNCells(Int_t minc=5) {
     // setNCells
     fMinNCells=minc;
   }
   
-  void FillMap();
-  
   // Search for clusters
   virtual void FindRawClusters();
   void  Find1DClusters();
@@ -57,7 +55,7 @@ private:
   
   TClonesArray       *fClusters;      // clusters
   Int_t               fNclusters;     // num of clusters
-  AliITSMapA2        *fMap;           // map
+  AliITSMapA2        *fMapA2;         // signal map
   Float_t             fCutAmplitude;  // cut amplitude
   Float_t             fDAnode;        // fDanode
   Float_t             fDTime;         // fDtime
@@ -65,7 +63,6 @@ private:
   Int_t               fMinPeak;       // min peak
   Int_t               fMinNCells;     // min num of cells
   
-  
   ClassDef(AliITSClusterFinderSDD,1) // SDD clustering - Piergiorgio C. algo
     };
 #endif
index 026bf0a..815c372 100644 (file)
@@ -15,6 +15,8 @@
 
 
 #include "AliITSClusterFinderSPD.h"
+#include "AliITSMapA1.h"
+#include "AliITS.h"
 #include "AliRun.h"
 
 
@@ -44,13 +46,21 @@ AliITSClusterFinderSPD::AliITSClusterFinderSPD()
   fDigits=0;
   fClusters=0;
   fNclusters=0;
+  fMap=0;
   SetDx();
   SetDz();
-  SetMap();
   SetNCells();
   
 }
 
+//_____________________________________________________________________________
+AliITSClusterFinderSPD::~AliITSClusterFinderSPD()
+{
+  // destructor
+  if (fMap) delete fMap;
+
+
+}
 //__________________________________________________________________________
 AliITSClusterFinderSPD::AliITSClusterFinderSPD(const AliITSClusterFinderSPD &source){
   //     Copy Constructor 
@@ -122,13 +132,13 @@ void AliITSClusterFinderSPD::Find1DClusters()
        id = it+m;
        if(id >= fMaxNofSamples) break;    // ! no possible for the fadc 
        
-       if(fMap->GetHitIndex(k,id)) {   // start of the cluster
+       if(fMap->TestHit(k,id) == kUnused) {   // start of the cluster
          lclx += 1;
          if(lclx == 1) xstart = id;
          
        }
        
-       if(lclx > 0 && !fMap->GetHitIndex(k,id)) {  
+       if(lclx > 0 && fMap->TestHit(k,id) == kEmpty) {  
          // end of cluster if a gap exists
          xstop = id-1;
          ilcl = 1;
@@ -143,14 +153,14 @@ void AliITSClusterFinderSPD::Find1DClusters()
       if(id >= fMaxNofSamples && lclx == 0) break; // the x row finished
       
       if(id < fMaxNofSamples && ilcl == 0 && lclx > 0) {  
-       // cluster end is outside of the window,
+                                  // cluster end is outside of the window,
        mmax += 5;                 // increase mmax and repeat the cluster
-       // finding
+                                  // finding
        it -= 1;
       }
       
       if(id >= fMaxNofSamples && lclx > 0) {  // the x row finished but
-       xstop = fMaxNofSamples - 1;          // the end cluster exists
+       xstop = fMaxNofSamples - 1;           // the end cluster exists
        ilcl = 1;
       } 
       
@@ -161,11 +171,10 @@ void AliITSClusterFinderSPD::Find1DClusters()
        mmax = 10;
            nofFoundClusters++;
            Float_t clusterCharge = 0.;
-            // get this from segmentation when this will be implemented
             Float_t zpitch = fSegmentation->Dpz(k+1); 
            Float_t clusterZ, dummyX; 
             Int_t dummy=0;
-            fSegmentation->GetCellCxz(dummy,k,dummyX,clusterZ);
+            fSegmentation->GetPadCxz(dummy,k,dummyX,clusterZ);
             Float_t zstart = clusterZ - 0.5*zpitch;
             Float_t zstop = clusterZ + 0.5*zpitch;
            Float_t clusterX = 0.;
@@ -177,7 +186,7 @@ void AliITSClusterFinderSPD::Find1DClusters()
             Int_t its;
            for(its=xstart; its<=xstop; its++) {
               Int_t firedpixel=0;
-              if (fMap->GetHitIndex(k,its)) firedpixel=1; 
+              if (fMap->GetHitIndex(k,its)>=0) firedpixel=1; 
              clusterCharge += firedpixel;
               clusterX +=its + 0.5;
            }
@@ -204,6 +213,8 @@ void AliITSClusterFinderSPD::Find1DClusters()
       }    // new cluster (ilcl=1)
     } // X direction loop (it)
   } // Z direction loop (k)
+
+  //fMap->ClearMap();
   return;
   
 }
@@ -217,12 +228,11 @@ void  AliITSClusterFinderSPD::GroupClusters()
   // get number of clusters for this module
   Int_t nofClusters = fClusters->GetEntriesFast();
   nofClusters -= fNclusters;
-  //printf("Group: fNclusters nofClusters %d %d\n",fNclusters, nofClusters);
   
   AliITSRawClusterSPD *clusterI;
   AliITSRawClusterSPD *clusterJ;
   
-  Int_t *label = new Int_t [nofClusters];  // activate this for DEC machines
+  Int_t *label=new Int_t[nofClusters];  
   Int_t i,j;
   for(i=0; i<nofClusters; i++) label[i] = 0;
   for(i=0; i<nofClusters; i++) {
@@ -237,8 +247,8 @@ void  AliITSClusterFinderSPD::GroupClusters()
        //    if((clusterI->XStop() == clusterJ->XStart()-1)||(clusterI->XStart()==clusterJ->XStop()+1)) cout<<"!! Diagonal cluster"<<endl;
        /*    
              cout << "clusters " << i << "," << j << " before grouping" << endl;
-             clusterI->Print();
-             clusterJ->Print();
+             clusterI->PrintInfo();
+             clusterJ->PrintInfo();
        */    
        clusterI->Add(clusterJ);
        //        cout << "remove cluster " << j << endl;
@@ -246,7 +256,7 @@ void  AliITSClusterFinderSPD::GroupClusters()
        fClusters->RemoveAt(j);
        /*
          cout << "cluster  " << i << " after grouping" << endl;
-         clusterI->Print();
+         clusterI->PrintInfo();
        */
       }  // pair
     } // J clusters  
@@ -257,7 +267,7 @@ void  AliITSClusterFinderSPD::GroupClusters()
   //cout << " Nomber of clusters at the group end ="<< totalNofClusters<<endl;
   
   delete [] label;
-  
+
   return;
   
   
@@ -272,25 +282,34 @@ void AliITSClusterFinderSPD::GetRecPoints()
   // get number of clusters for this module
   Int_t nofClusters = fClusters->GetEntriesFast();
   nofClusters -= fNclusters;
-  //printf("GetRecP: fNclusters nofClusters %d %d\n",fNclusters, nofClusters);
+
   
   const Float_t kconv = 1.0e-4;
   const Float_t kRMSx = 12.0*kconv; // microns -> cm ITS TDR Table 1.3
   const Float_t kRMSz = 70.0*kconv; // microns -> cm ITS TDR Table 1.3
 
-  Int_t i;
+  Float_t spdLength = fSegmentation->Dz();
+  Float_t spdWidth = fSegmentation->Dx();
+
+  Int_t i, ix, iz;
   for(i=0; i<nofClusters; i++) { 
     AliITSRawClusterSPD *clusterI = (AliITSRawClusterSPD*) fClusters->At(i);
+    fSegmentation->GetPadIxz(clusterI->X(),clusterI->Z(),ix,iz);
+    AliITSdigitSPD *dig = (AliITSdigitSPD*)fMap->GetHit(iz-1,ix-1);
     AliITSRecPoint rnew;
-    rnew.SetX(clusterI->X()*kconv);
-    rnew.SetZ(clusterI->Z()*kconv);
+    rnew.SetX((clusterI->X() - spdWidth/2)*kconv);
+    rnew.SetZ((clusterI->Z() - spdLength/2)*kconv);
     rnew.SetQ(1.);
     rnew.SetdEdX(0.);
     rnew.SetSigmaX2(kRMSx*kRMSx);
     rnew.SetSigmaZ2(kRMSz*kRMSz);
-    rnew.SetProbability(1.);
+    rnew.fTracks[0]=dig->fTracks[0];
+    rnew.fTracks[1]=dig->fTracks[1];
+    rnew.fTracks[2]=dig->fTracks[2];
     iTS->AddRecPoint(rnew);
   } // I clusters
+
+  fMap->ClearMap();
   
 }
 //_____________________________________________________________________________
@@ -301,5 +320,6 @@ void AliITSClusterFinderSPD::FindRawClusters()
   Find1DClusters();
   GroupClusters();
   GetRecPoints();
+
 }
 
index 89d2ce3..23a3459 100644 (file)
@@ -7,6 +7,8 @@
 
 #include "AliITSClusterFinder.h"
 
+class AliITSMapA1;
+
 class AliITSClusterFinderSPD :
   public AliITSClusterFinder
 
@@ -16,9 +18,7 @@ public:
   (AliITSsegmentation *segmentation,
    TClonesArray *digits, TClonesArray *recpoints);
   AliITSClusterFinderSPD();
-  virtual ~AliITSClusterFinderSPD(){
-    // destructor
-  }
+  virtual ~AliITSClusterFinderSPD();
   AliITSClusterFinderSPD(const AliITSClusterFinderSPD &source); // copy constructor
   AliITSClusterFinderSPD& operator=(const AliITSClusterFinderSPD &source); // assignment operator
   
@@ -49,14 +49,13 @@ private:
   
   TClonesArray       *fClusters;      // clusters
   Int_t               fNclusters;     // num of clusters
-  AliITSMapA1        *fMap;           // map
   Float_t             fDz;            // dz
   Float_t             fDx;            // dx
   
-  Int_t               fMinNCells;     // min num of cells
+  Int_t               fMinNCells;     // min num of cells in the cluster
   
   ClassDef(AliITSClusterFinderSPD,1)  // SPD clustering - Boris B. algo based
-    // on Piergiorgio's algo
+                                      // on Piergiorgio's algo
     };
 #endif
 
index c3b894e..cf43646 100644 (file)
@@ -28,7 +28,11 @@ Automatic combination routines improved (traps)
 */
 
 #include "AliRun.h"
+#include "AliITS.h"
+#include "AliITSMapA1.h"
 #include "AliITSClusterFinderSSD.h"
+#include "AliITSclusterSSD.h"
+#include "AliITSpackageSSD.h"
  
 
 const Int_t debug=0;
@@ -49,6 +53,8 @@ AliITSClusterFinderSSD::AliITSClusterFinderSSD(AliITSsegmentation *seg, TClonesA
     fDigits=digits;
     fRecPoints=recp;
     
+    fMap = new AliITSMapA1(fSegmentation,fDigits);  
+  
     fITS=(AliITS*)gAlice->GetModule("ITS");
     
     fClusterP =  new TClonesArray ("AliITSclusterSSD",200);    
@@ -77,7 +83,9 @@ AliITSClusterFinderSSD::AliITSClusterFinderSSD(AliITSsegmentation *seg, TClonesA
     fSegmentation->Angles(StereoP,StereoN);
     fTanP=TMath::Tan(StereoP);
     fTanN=TMath::Tan(StereoN);
+
     fPNsignalRatio=7./8.;         // warning: hard-wired number
+
 }
 
 //-------------------------------------------------------
@@ -88,6 +96,9 @@ AliITSClusterFinderSSD::~AliITSClusterFinderSSD() {
     delete fPackages;        
     delete fDigitsIndexP;        
     delete fDigitsIndexN; 
+    
+    delete fMap;
+
 }
 
 //-------------------------------------------------------
@@ -96,18 +107,18 @@ void AliITSClusterFinderSSD::InitReconstruction()
 
   register Int_t i; //iterator
 
-  for(i=0;i<fNClusterP;i++)
+  for (i=0;i<fNClusterP;i++)
     {
       fClusterP->RemoveAt(i);
     }
   fNClusterP  =0;
-  for(i=0;i<fNClusterN;i++)
+  for (i=0;i<fNClusterN;i++)
     {
       fClusterN->RemoveAt(i);
     }
   fNClusterN=0;
 
-  for(i=0;i<fNPackages;i++)
+  for (i=0;i<fNPackages;i++)
     {
       fPackages->RemoveAt(i);
     }
@@ -128,9 +139,6 @@ void AliITSClusterFinderSSD::InitReconstruction()
 //---------------------------------------------
 void AliITSClusterFinderSSD::FindRawClusters() 
 {
-
-
-
 //Piotr Krzysztof Skowronski
 //Warsaw University of Technology
 //skowron@if.pw.edu.pl
@@ -144,6 +152,7 @@ void AliITSClusterFinderSSD::FindRawClusters()
 // 5. Creates clusters 
 
   InitReconstruction();  //ad. 1
+  fMap->FillMap();
   FillDigitsIndex();
   SortDigits();
   FindNeighbouringDigits(); //ad. 2
@@ -152,7 +161,8 @@ void AliITSClusterFinderSSD::FindRawClusters()
   ConsumeClusters();
   PackagesToPoints();   //ad. 5
   ReconstructNotConsumedClusters();
+  
+  fMap->ClearMap();
 }
 
 
@@ -185,7 +195,7 @@ void AliITSClusterFinderSSD::FindNeighbouringDigits()
    dnumber = 1;
    dbuffer[0]=lDigitsIndexP[0];
    //If next digit is a neighbour of previous, adds to last cluster this digit
-   for(i=1; i<fNDigitsP; i++) {
+   for (i=1; i<fNDigitsP; i++) {
      //reads new digit
      currentstripNo = ((AliITSdigitSSD*)lDigits[lDigitsIndexP[i]])->
                                                             GetStripNumber(); 
@@ -194,12 +204,12 @@ void AliITSClusterFinderSSD::FindNeighbouringDigits()
            ==  (currentstripNo-1) ) dbuffer[dnumber++]=lDigitsIndexP[i];
      else  { 
        //create a new one side cluster
-       new(lClusterP[fNClusterP++]) AliITSclusterSSD(dnumber,dbuffer,fDigits,SIDEP); 
+       new(lClusterP[fNClusterP++]) AliITSclusterSSD(dnumber,dbuffer,fDigits,fgkSIDEP); 
        dbuffer[0]=lDigitsIndexP[i];
        dnumber = 1;
      }
    } // end loop over fNDigitsP
-   new(lClusterP[fNClusterP++]) AliITSclusterSSD(dnumber,dbuffer,fDigits,SIDEP);
+   new(lClusterP[fNClusterP++]) AliITSclusterSSD(dnumber,dbuffer,fDigits,fgkSIDEP);
 
 
    //process N side 
@@ -207,18 +217,18 @@ void AliITSClusterFinderSSD::FindNeighbouringDigits()
    dnumber = 1;
    dbuffer[0]=lDigitsIndexN[0];
    //If next digit is a neighbour of previous, adds to last cluster this digit
-   for(i=1; i<fNDigitsN; i++) { 
+   for (i=1; i<fNDigitsN; i++) { 
      currentstripNo = ((AliITSdigitSSD*)(lDigits[lDigitsIndexN[i]]))->
                                                             GetStripNumber();
      if ( (((AliITSdigitSSD*)lDigits[lDigitsIndexN[i-1]])->GetStripNumber()) 
            == (currentstripNo-1) ) dbuffer[dnumber++]=lDigitsIndexN[i];
      else {
-       new(lClusterN[fNClusterN++]) AliITSclusterSSD(dnumber,dbuffer,fDigits,SIDEN);
+       new(lClusterN[fNClusterN++]) AliITSclusterSSD(dnumber,dbuffer,fDigits,fgkSIDEN);
        dbuffer[0]=lDigitsIndexN[i];
        dnumber = 1;
      }
    } // end loop over fNDigitsN
-   new(lClusterN[fNClusterN++]) AliITSclusterSSD(dnumber,dbuffer,fDigits,SIDEN);
+   new(lClusterN[fNClusterN++]) AliITSclusterSSD(dnumber,dbuffer,fDigits,fgkSIDEN);
    delete [] dbuffer; 
  
  } // end condition on  NDigits 
@@ -236,7 +246,7 @@ void AliITSClusterFinderSSD::SeparateOverlappedClusters()
 //Warsaw University of Technology
 //skowron@if.pw.edu.pl
 
-  register Int_t i,j; //iterator
+  register Int_t i; //iterator
 
   Float_t  factor=0.75;            // How many percent must be lower signal 
                                    // on the middle one digit
@@ -253,12 +263,12 @@ void AliITSClusterFinderSSD::SeparateOverlappedClusters()
 
   splitlist = new TArrayI(300);
 
-  for(i=0;i<initPsize;i++)
+  for (i=0;i<initPsize;i++)
   {
     if (( ((AliITSclusterSSD*)(*fClusterP)[i])->GetNumOfDigits())==1) continue;
     if (( ((AliITSclusterSSD*)(*fClusterP)[i])->GetNumOfDigits())==2) continue;
         Int_t nj=(((AliITSclusterSSD*)(*fClusterP)[i])->GetNumOfDigits()-1);
-        for(j=1; j<nj; j++)
+        for (Int_t j=1; j<nj; j++)
           {
             signal1=((AliITSclusterSSD*)(*fClusterP)[i])->GetDigitSignal(j);
             signal0=((AliITSclusterSSD*)(*fClusterP)[i])->GetDigitSignal(j-1);
@@ -270,17 +280,17 @@ void AliITSClusterFinderSSD::SeparateOverlappedClusters()
             }
          } // end loop over number of digits
           //split this cluster if necessary
-          if(numerofsplits>0) SplitCluster(splitlist,numerofsplits,i,SIDEP); 
+          if(numerofsplits>0) SplitCluster(splitlist,numerofsplits,i,fgkSIDEP); 
          numerofsplits=0;
 
          //in signed places (splitlist)
   } // end loop over clusters on Pside
 
-  for(i=0;i<initNsize;i++) {
+  for (i=0;i<initNsize;i++) {
     if (( ((AliITSclusterSSD*)(*fClusterN)[i])->GetNumOfDigits())==1) continue;
     if (( ((AliITSclusterSSD*)(*fClusterN)[i])->GetNumOfDigits())==2) continue;
        Int_t nj=(((AliITSclusterSSD*)(*fClusterN)[i])->GetNumOfDigits()-1);
-       for(j=1; j<nj; j++)
+       for (Int_t j=1; j<nj; j++)
           {
             signal1=((AliITSclusterSSD*)(*fClusterN)[i])->GetDigitSignal(j);
             signal0=((AliITSclusterSSD*)(*fClusterN)[i])->GetDigitSignal(j-1);
@@ -290,7 +300,7 @@ void AliITSClusterFinderSSD::SeparateOverlappedClusters()
                (*splitlist)[numerofsplits++]=j;  
           } // end loop over number of digits 
           //split this cluster into more clusters
-          if(numerofsplits>0) SplitCluster(splitlist,numerofsplits,i,SIDEN);
+          if(numerofsplits>0) SplitCluster(splitlist,numerofsplits,i,fgkSIDEN);
          numerofsplits=0;                                                              //in signed places (splitlist)
   } // end loop over clusters on Nside
 
@@ -325,7 +335,7 @@ void AliITSClusterFinderSSD::SplitCluster(TArrayI *list, Int_t nsplits, Int_t in
   // side true means P side
   if (side) {
      curentcluster =((AliITSclusterSSD*)((*fClusterP)[index])) ;
-     for(i = nsplits; i>0 ;i--) {  
+     for (i = nsplits; i>0 ;i--) {  
          NN=curentcluster->SplitCluster((*list)[(i-1)],tmpdigits);
          new ((*fClusterP)[fNClusterP]) AliITSclusterSSD(NN,tmpdigits,fDigits,side);
         ( (AliITSclusterSSD*)((*fClusterP)[fNClusterP]) )->
@@ -340,7 +350,7 @@ void AliITSClusterFinderSSD::SplitCluster(TArrayI *list, Int_t nsplits, Int_t in
      } // end loop over nplits
   } else {
      curentcluster =((AliITSclusterSSD*)((*fClusterN)[index]));
-     for(i = nsplits; i>0 ;i--) {  
+     for (i = nsplits; i>0 ;i--) {  
          NN=curentcluster->SplitCluster((*list)[(i-1)],tmpdigits);
         new ((*fClusterN)[fNClusterN]) AliITSclusterSSD(NN,tmpdigits,fDigits,side);
         ((AliITSclusterSSD*)((*fClusterN)[fNClusterN]))->
@@ -449,14 +459,14 @@ void AliITSClusterFinderSSD::FillDigitsIndex()
  
  AliITSdigitSSD *dig; 
  
- for(i = 0 ; i< N; i++ ) {
+ for ( i = 0 ; i< N; i++ ) {
       dig=(AliITSdigitSSD*)fDigits->UncheckedAt(i);
       if(dig->IsSideP()) { 
            bit=1;
            tmp=dig->GetStripNumber();
           // I find this totally unnecessary - it's just a 
           // CPU consuming double check
-           for(k=0;k<PNs;k++)
+           for( k=0;k<PNs;k++)
             {
              if (tmp==PSidx[k])
               {
@@ -473,7 +483,7 @@ void AliITSClusterFinderSSD::FillDigitsIndex()
          bit=1;
          tmp=dig->GetStripNumber();
         // same as above
-         for(k=0;k<NNs;k++)
+         for( k=0;k<NNs;k++)
           {
            if (tmp==NSidx[k])
             {
@@ -509,11 +519,11 @@ void AliITSClusterFinderSSD::SortDigits()
 
   Int_t i;
   if(fNDigitsP>1) 
-  for(i=0;i<fNDigitsP-1;i++)
+  for (i=0;i<fNDigitsP-1;i++)
   if (SortDigitsP(0,(fNDigitsP-1-i))==0) break;
 
   if(fNDigitsN>1) 
-    for(i=0;i<fNDigitsN-1;i++)
+    for (i=0;i<fNDigitsN-1;i++)
   if(SortDigitsN(0,(fNDigitsN-1-i))==0) break;
 }
 
@@ -530,11 +540,11 @@ void AliITSClusterFinderSSD::FillClIndexArrays(Int_t* arrayP, Int_t *arrayN)
 
 
   register Int_t i;
-  for(i=0; i<fNClusterP;i++)
+  for (i=0; i<fNClusterP;i++)
     {
       arrayP[i]=i;
     }
-  for(i=0; i<fNClusterN;i++)
+  for (i=0; i<fNClusterN;i++)
     {
       arrayN[i]=i;
     }
@@ -553,12 +563,12 @@ void AliITSClusterFinderSSD::SortClusters(Int_t* arrayP, Int_t *arrayN)
 
   Int_t i;
   if(fNClusterP>1) 
-    for(i=0;i<fNClusterP-1;i++)
+    for (i=0;i<fNClusterP-1;i++)
       if (SortClustersP(0,(fNClusterP-1),arrayP)==0)  break;
     
     
   if(fNClusterN>1) 
-    for(i=0;i<fNClusterN-1;i++)
+    for (i=0;i<fNClusterN-1;i++)
       if (SortClustersN(0,(fNClusterN-1),arrayN)==0)  break;
 
 }
@@ -652,7 +662,7 @@ void AliITSClusterFinderSSD::ClustersToPackages()
                                           // MB: well, that's not true that one
                                           //cannot sort objects in TClonesArray
   
-  Int_t i,k;    //iterator
+  register Int_t i;    //iterator
   AliITSpackageSSD *currentpkg;
   AliITSclusterSSD *currentP;
   AliITSclusterSSD *currentN;
@@ -678,7 +688,8 @@ void AliITSClusterFinderSSD::ClustersToPackages()
   currentpkg = (AliITSpackageSSD*)((*fPackages)[0]);
   
   //main loop on sorted P side clusters 
-  for(i=0;i<fNClusterP;i++) {  
+  Int_t k;
+  for (i=0;i<fNClusterP;i++) {  
       //Take new P side cluster
       currentP = GetPSideCluster(oneSclP[i]);
       currentN = GetNSideCluster(oneSclN[lastNclIndex]);
@@ -706,7 +717,7 @@ void AliITSClusterFinderSSD::ClustersToPackages()
          }
           tmplastNclIndex=lastNclIndex;  
          //Check if next N side clusters crosses with it too
-          for(k=1;k<fSFF+1;k++) {
+          for (Int_t k=1;k<fSFF+1;k++) {
              //check if we are not out of array 
               if ((tmplastNclIndex+k)<fNClusterN) {
                   fcurrN = GetNSideCluster( oneSclN[tmplastNclIndex+k] );
@@ -759,7 +770,7 @@ void AliITSClusterFinderSSD::ClustersToPackages()
                     currentpkg->AddPSideCluster(oneSclP[i]);          
                     //Check, if next N side clusters crosses with it too
                     tmplastNclIndex=lastNclIndex;
-                    for(k=1;k<fSFF+1;k++) {
+                    for (Int_t k=1;k<fSFF+1;k++) {
                       //Check if we are not out of array
                       if ((tmplastNclIndex+k)<fNClusterN) {
                          fcurrN = GetNSideCluster(oneSclN[tmplastNclIndex+k]);
@@ -811,7 +822,7 @@ void AliITSClusterFinderSSD::PackagesToPoints()
  Int_t clusterIndex;
  Bool_t clusterSide;
 
- for(i=0;i<fNPackages;i++) {
+ for (i=0;i<fNPackages;i++) {
     //get pointer to next package
     currentpkg = (AliITSpackageSSD*)((*fPackages)[i]); 
     NumNcl = currentpkg->GetNumOfClustersN();
@@ -881,7 +892,7 @@ void AliITSClusterFinderSSD::
 ResolveClusterWithOneCross(AliITSpackageSSD *currentpkg, Int_t clusterIndex, Bool_t clSide)
 {
 
-   if (clSide == SIDEP) ResolvePClusterWithOneCross(currentpkg,clusterIndex);
+   if (clSide == fgkSIDEP) ResolvePClusterWithOneCross(currentpkg,clusterIndex);
    else  ResolveNClusterWithOneCross(currentpkg,clusterIndex);
 
 }
@@ -944,7 +955,7 @@ ie:
   ns = clusterN->GetTotalSignal();
   posClusterN = GetClusterZ(clusterN);
   posErrorClusterN = clusterN->GetPositionError();
-  pkg->DelCluster(clusterIndex,SIDEP);
+  pkg->DelCluster(clusterIndex,fgkSIDEP);
   sigClusterN = ps/fPNsignalRatio;
   // there is no sonse to check how signal ratio is far from perfect 
   // matching line if the if below it is true
@@ -952,7 +963,7 @@ ie:
       sigClusterN=ns;
       if (debug) cout<<"n1 < p1/fPNsignalRatio";
       if (debug) cout<<"Attempting to del cluster N "<<clusterIdx<<" ... \n";
-      pkg->DelClusterOI(clusterIdx,SIDEN);
+      pkg->DelClusterOI(clusterIdx,fgkSIDEN);
   } else {
       //Let's see how signal ratio is far from perfect matching line
       Chicomb = DistToPML(ps,ns);
@@ -960,7 +971,7 @@ ie:
       if (Chicomb > falpha2) {
          //it is near, so we can risk throwing this cluster away too
         if (debug) cout<<"Attempting to del cluster N "<<clusterIdx<<"...\n"; 
-         pkg->DelClusterOI(clusterIdx,SIDEN);
+         pkg->DelClusterOI(clusterIdx,fgkSIDEN);
       } else {
          clusterN->CutTotalSignal(sigClusterN);
         if (debug) cout <<"Signal cut  |||||||||||||\n";
@@ -1013,7 +1024,7 @@ ResolveNClusterWithOneCross(AliITSpackageSSD *pkg, Int_t clusterIndex)
   ps = clusterP->GetTotalSignal();
   posClusterP = GetClusterZ(clusterP);
   posErrorClusterP = clusterP->GetPositionError();
-  pkg->DelCluster(clusterIndex,SIDEN);
+  pkg->DelCluster(clusterIndex,fgkSIDEN);
   sigClusterP=ns*fPNsignalRatio;
   // there is no sonse to check how signal ratio is far from perfect 
   // matching line if the if below it is true
@@ -1021,7 +1032,7 @@ ResolveNClusterWithOneCross(AliITSpackageSSD *pkg, Int_t clusterIndex)
       sigClusterP = ps;
       if (debug) cout<<"ps < ns*fPNsignalRatio";
       if (debug) cout<<"Attempting to del cluster P "<<clusterIdx<<" ... \n";
-      pkg->DelClusterOI(clusterIdx,SIDEP);
+      pkg->DelClusterOI(clusterIdx,fgkSIDEP);
   } else {
       //Let's see how signal ratio is far from perfect matching line
        Chicomb = DistToPML(ps,ns);
@@ -1029,7 +1040,7 @@ ResolveNClusterWithOneCross(AliITSpackageSSD *pkg, Int_t clusterIndex)
        if (Chicomb > falpha2) {
           //it is near, so we can risk frowing this cluster away too
           if (debug) cout<<"Attempting to del cluster P "<<clusterIdx<<"...\n";
-         pkg->DelClusterOI(clusterIdx,SIDEP);
+         pkg->DelClusterOI(clusterIdx,fgkSIDEP);
        } else {
           clusterN->CutTotalSignal(sigClusterP);
          if (debug) cout <<"Signal cut  ------------\n";
@@ -1060,9 +1071,9 @@ ResolvePackageBestCombin(AliITSpackageSSD *pkg)
   Int_t Ncombin; //Number of combinations
   Int_t itera;   //iterator
   Int_t sizet=1;   //size of array to allocate 
+
   Int_t NP = pkg->GetNumOfClustersP();
-  for(itera =2; itera <= NP ;itera ++) {
+  for (itera =2; itera <= NP ;itera ++) {
      sizet=sizet*itera;
      if (sizet > 10000) {
        sizet=10000;
@@ -1070,9 +1081,9 @@ ResolvePackageBestCombin(AliITSpackageSSD *pkg)
      }
   }
 
-  Int_t **combin = new Int_t*[sizet]; //2D array to keep combinations in
+  Int_t** combin = new Int_t*[sizet]; //2D array to keep combinations in
 
-  for(itera =0; itera <sizet;itera++) {
+  for (itera =0; itera <sizet;itera++) {
    combin[itera] = new Int_t[NP+1];
   }
      
@@ -1086,7 +1097,7 @@ ResolvePackageBestCombin(AliITSpackageSSD *pkg)
   Int_t bc = GetBestComb(combin,Ncombin,NP,pkg); 
   if (debug) cout<<"  bc "<<bc <<"\n";
               
-  for(itera =0; itera < NP; itera ++) {
+  for (itera =0; itera < NP; itera ++) {
       clusterP = pkg->GetPSideCluster(itera);
       //carefully here
       //becase AliITSclusterSSD::GetCross returns index in 
@@ -1095,7 +1106,7 @@ ResolvePackageBestCombin(AliITSpackageSSD *pkg)
       CreateNewRecPoint(clusterP, clusterN, 0.75);
   } 
 
-  for(itera =0; itera <sizet;itera++) {
+  for (itera =0; itera <sizet;itera++) {
      delete [](combin[itera]);
   }
   delete [] combin;  
@@ -1140,8 +1151,8 @@ ResolveOneBestMatchingPoint(AliITSpackageSSD *pkg)
               }          
  
  
- pkg->DelClusterOI(pi, SIDEP);
- pkg->DelClusterOI(ni, SIDEN);
+ pkg->DelClusterOI(pi, fgkSIDEP);
+ pkg->DelClusterOI(ni, fgkSIDEN);
  
  if (split) {
    if (debug) cout<<"spltting package ...\n";
@@ -1222,12 +1233,12 @@ void AliITSClusterFinderSSD:: ResolvePackageWithOnePSideCluster(AliITSpackageSSD
  XPerr = clusterP->GetPositionError();
  p1err = clusterP->GetTotalSignalError();
    
- for(k=0;k<NN;k++) {
+ for (k=0;k<NN;k++) {
     SN[k]    = pkg->GetNSideCluster(k)->GetTotalSignal();
     SNerr[k] = pkg->GetNSideCluster(k)->GetTotalSignalError();
     sumsig   += SN[k];
  }
- for(k=0;k<NN;k++) {
+ for (k=0;k<NN;k++) {
     clusterN = pkg->GetNSideCluster(k);
     SP[k]= p1*SN[k]/sumsig;
     SPerr[k] = p1err*SN[k]/sumsig;
@@ -1287,13 +1298,13 @@ void AliITSClusterFinderSSD::ResolvePackageWithOneNSideCluster(AliITSpackageSSD
  
  n1err=clusterN->GetTotalSignalError();
    
- for(k=0;k<NP;k++) {
+ for (k=0;k<NP;k++) {
     SP[k] = pkg->GetPSideCluster(k)->GetTotalSignal();
     sumsig += SP[k];
     SPerr[k] = pkg->GetPSideCluster(k)->GetTotalSignalError();
  }
 
- for(k=0;k<NP;k++) {
+ for (k=0;k<NP;k++) {
     clusterP = pkg->GetPSideCluster(k);
     SN[k]= n1*SP[k]/sumsig;
     XP[k]=GetClusterZ(clusterP);
@@ -1497,6 +1508,9 @@ CreateNewRecPoint(Float_t P, Float_t dP, Float_t N, Float_t dN,
 
   Float_t p=P;
   Float_t n=N;
+  Int_t stripP, stripN;
+  Int_t sigP, sigN;
+  AliITSdigitSSD *digP, *digN;
   if (GetCrossing(P,N)) {
      GetCrossingError(dP,dN);
      AliITSRawClusterSSD cnew;
@@ -1509,8 +1523,7 @@ CreateNewRecPoint(Float_t P, Float_t dP, Float_t N, Float_t dN,
         printf("multiplicity > 100 - increase the dimension of the arrays %d\n",nstripsP);
         nstripsP=100;
      }
-     Int_t i;
-     for(i=0;i<nstripsP;i++) {
+     for(int i=0;i<nstripsP;i++) {
        // check if 'clusterP->GetDigitStripNo(i)' returns the digit index
        cnew.fIndexMap[i] = clusterP->GetDigitStripNo(i); 
      } 
@@ -1518,7 +1531,7 @@ CreateNewRecPoint(Float_t P, Float_t dP, Float_t N, Float_t dN,
         printf("multiplicity > 100 - increase the dimension of the arrays %d\n",nstripsN);
         nstripsN=100;
      }
-     for(i=0;i<nstripsN;i++) {
+     for(int i=0;i<nstripsN;i++) {
        // check if 'clusterN->GetDigitStripNo(i)' returns the digit index
        cnew.fIndexMapN[i] = clusterN->GetDigitStripNo(i); 
      }
@@ -1526,6 +1539,11 @@ CreateNewRecPoint(Float_t P, Float_t dP, Float_t N, Float_t dN,
      cnew.fQErr=dSig;
      //cnew.fProbability=(float)prob; 
      fITS->AddCluster(2,&cnew);
+     fSegmentation->GetPadIxz(P,N,stripP,stripN);
+     digP = (AliITSdigitSSD*)fMap->GetHit(1,stripP);
+     digN = (AliITSdigitSSD*)fMap->GetHit(0,stripN);
+     sigP = digP->fSignal;
+     sigN = digN->fSignal;
      // add the rec point info
      AliITSRecPoint rnew;
      rnew.SetX(P*kconv);
@@ -1535,6 +1553,15 @@ CreateNewRecPoint(Float_t P, Float_t dP, Float_t N, Float_t dN,
      rnew.SetSigmaX2( kRMSx* kRMSx); 
      rnew.SetSigmaZ2( kRMSz* kRMSz);
      rnew.SetProbability((float)prob);
+     if(sigP > sigN) {
+        rnew.fTracks[0]=digP->fTracks[0];
+        rnew.fTracks[1]=digP->fTracks[1];
+        rnew.fTracks[2]=digP->fTracks[2];
+     } else {
+        rnew.fTracks[0]=digN->fTracks[0];
+        rnew.fTracks[1]=digN->fTracks[1];
+        rnew.fTracks[2]=digN->fTracks[2];
+     }
      fITS->AddRecPoint(rnew);
      /*
      // it was
@@ -1616,8 +1643,8 @@ Bool_t AliITSClusterFinderSSD::Strip2Local( Float_t stripP, Float_t stripN, Floa
  X=P;
  Z=N;
  if (debug) cout<<"P="<<stripP<<" N="<<stripN<<"   X = "<<X<<" Z = "<<Z<<"\n";
- if ((Z<2.1)&&(Z>-2.1)&&(X<3.65)&&(X>-3.65)) return true; 
-    else return false;  
+ if ((Z<2.1)&&(Z>-2.1)&&(X<3.65)&&(X>-3.65)) return kTRUE; 
+    else return kFALSE;  
 
 }
 
@@ -1660,12 +1687,11 @@ Int_t AliITSClusterFinderSSD::GetBestComb
   Float_t chi;
   Float_t ps, ns;       //signal of P cluster and N cluster
 
-  Int_t i,j;
-  for(i=0;i<Ncomb;i++)
+  for (Int_t i=0;i<Ncomb;i++)
     {
       chi=0;
       
-      for(j=0;j<Ncl;j++)
+      for (Int_t j=0;j<Ncl;j++)
       {
         ps = pkg->GetPSideCluster(j)->GetTotalSignal();  //carrefully here, different functions
         ns = GetNSideCluster(comb[i][j])->GetTotalSignal(); 
@@ -1708,8 +1734,7 @@ void AliITSClusterFinderSSD::GetBestMatchingPoint
        
   bestchi=DistToPML(  pkg->GetPSideCluster(0)->GetTotalSignal(),
                   pkg->GetNSideCluster(0)->GetTotalSignal()  );
-  Int_t i,j;
-  for(i = 0; i< pkg->GetNumOfClustersP(); i++)
+  for (Int_t i = 0; i< pkg->GetNumOfClustersP(); i++)
     {
       
       p =  pkg->GetPSideClusterIdx(i);   
@@ -1717,7 +1742,7 @@ void AliITSClusterFinderSSD::GetBestMatchingPoint
       nc=curPcl->GetCrossNo();
       ps=curPcl->GetTotalSignal();
       
-      for(j = 0; j< nc; j++)
+      for (Int_t j = 0; j< nc; j++)
         {
          n=curPcl->GetCross(j);
          curNcl= GetNSideCluster(n);
@@ -1820,8 +1845,8 @@ AliITSclusterSSD* AliITSClusterFinderSSD::GetCluster(Int_t idx, Bool_t side)
 void AliITSClusterFinderSSD::ConsumeClusters()
 {
 
- Int_t i;
- for(i=0;i<fNPackages;i++)
+
+ for ( Int_t i=0;i<fNPackages;i++)
   {
     ((AliITSpackageSSD*)((*fPackages)[i]))->ConsumeClusters();
   }
@@ -1847,9 +1872,10 @@ void AliITSClusterFinderSSD::ReconstructNotConsumedClusters()
   const Float_t kRMSx = 20.0*kconv; // microns->cm ITS TDR Table 1.3
   const Float_t kRMSz = 830.0*kconv; // microns->cm ITS TDR Table 1.3
   
-  for(i=0;i<fNClusterP;i++)
+  Int_t stripP,stripN;
+  AliITSdigitSSD *dig;
+  for (i=0;i<fNClusterP;i++)
     {
-      //printf("P side cluster: cluster number %d\n",i);
       cluster = GetPSideCluster(i);
       if (!cluster->IsConsumed())
         {
@@ -1875,8 +1901,7 @@ void AliITSClusterFinderSSD::ReconstructNotConsumedClusters()
                printf("multiplicity > 100 - increase the dimension of the arrays %d\n",nstripsP);
                nstripsP=100;
              }
-              Int_t k;
-             for(k=0;k<nstripsP;k++) {
+             for(int k=0;k<nstripsP;k++) {
                // check if 'clusterP->GetDigitStripNo(i)' returns 
                // the digit index and not smth else
                cnew.fIndexMap[k] = cluster->GetDigitStripNo(k); 
@@ -1885,6 +1910,8 @@ void AliITSClusterFinderSSD::ReconstructNotConsumedClusters()
              cnew.fQErr=sigerr;
              //cnew.fProbability=0.75; 
              fITS->AddCluster(2,&cnew);
+             fSegmentation->GetPadIxz((x1+x2)/2,(z1+z2)/2,stripP,stripN);
+             dig = (AliITSdigitSSD*)fMap->GetHit(1,stripP);
              // add the rec point info
              AliITSRecPoint rnew;
               rnew.SetX(kconv*(x1+x2)/2);
@@ -1894,6 +1921,9 @@ void AliITSClusterFinderSSD::ReconstructNotConsumedClusters()
              rnew.SetSigmaX2( kRMSx* kRMSx);
              rnew.SetSigmaZ2( kRMSz* kRMSz);
               rnew.SetProbability(0.75);
+             rnew.fTracks[0]=dig->fTracks[0];
+             rnew.fTracks[1]=dig->fTracks[1];
+             rnew.fTracks[2]=dig->fTracks[2];
               fITS->AddRecPoint(rnew);
              /*
               fPointsM->AddLast( (TObject*) 
@@ -1906,9 +1936,8 @@ void AliITSClusterFinderSSD::ReconstructNotConsumedClusters()
         }
     }
 
-  for(i=0;i<fNClusterN;i++)
+  for (i=0;i<fNClusterN;i++)
     {
-      // printf("N side cluster: cluster number %d\n",i);
       cluster = GetNSideCluster(i);
       if (!cluster->IsConsumed())
         {
@@ -1936,8 +1965,7 @@ void AliITSClusterFinderSSD::ReconstructNotConsumedClusters()
                printf("multiplicity > 100 - increase the dimension of the arrays %d\n",nstripsN);
                nstripsN=100;
              }
-              Int_t k;
-             for(k=0;k<nstripsN;k++) {
+             for(int k=0;k<nstripsN;k++) {
                // check if 'clusterP->GetDigitStripNo(i)' returns 
                // the digit index and not smth else
                cnew.fIndexMapN[k] = cluster->GetDigitStripNo(k); 
@@ -1947,6 +1975,8 @@ void AliITSClusterFinderSSD::ReconstructNotConsumedClusters()
              //cnew.fProbability=0.75; 
              fITS->AddCluster(2,&cnew);
              // add the rec point info
+             fSegmentation->GetPadIxz((x1+x2)/2,(z1+z2)/2,stripP,stripN);
+             dig = (AliITSdigitSSD*)fMap->GetHit(0,stripN);
              AliITSRecPoint rnew;
               rnew.SetX(kconv*(x1+x2)/2);
               rnew.SetZ(kconv*(z1+z2)/2);
@@ -1955,6 +1985,9 @@ void AliITSClusterFinderSSD::ReconstructNotConsumedClusters()
              rnew.SetSigmaX2( kRMSx* kRMSx);
              rnew.SetSigmaZ2( kRMSz* kRMSz);
               rnew.SetProbability(0.75);
+             rnew.fTracks[0]=dig->fTracks[0];
+             rnew.fTracks[1]=dig->fTracks[1];
+             rnew.fTracks[2]=dig->fTracks[2];
               fITS->AddRecPoint(rnew);
              /*
               fPointsM->AddLast( (TObject*) 
index 8b85cff..f8c0d0a 100644 (file)
@@ -4,17 +4,15 @@
  * See cxx source for full Copyright notice                               */
 
 
-#include <TObject.h>
 #include <TArrayS.h>
-#include <TClonesArray.h>
 #include <TRandom.h>
 #include <TMath.h>
 
-#include "AliITS.h"
-#include "AliITSclusterSSD.h"
-#include "AliITSpackageSSD.h"
 #include "AliITSClusterFinder.h"
 
+class AliITSclusterSSD;
+class AliITSpackageSSD;
+
 
 class AliITSClusterFinderSSD: public AliITSClusterFinder 
 {
@@ -139,9 +137,10 @@ public:
   Float_t falpha2;
   Float_t falpha3;
   Float_t fPNsignalRatio;
+
     
-  static const Bool_t SIDEP=kTRUE;
-  static const Bool_t SIDEN=kFALSE;
+  static const Bool_t fgkSIDEP=kTRUE;
+  static const Bool_t fgkSIDEN=kFALSE;
 
   Int_t fSFF;              //forward stepping factor 
   Int_t fSFB;              //backward stepping factor 
index 3799365..18ba69e 100644 (file)
@@ -8,6 +8,7 @@
 #include "AliITSsegmentation.h"
 #include "AliITSresponse.h"
 
+
 class AliITSClusterFinder;
 class AliITSsimulation;
 
@@ -47,7 +48,7 @@ class AliITSDetType:public TObject
 // Configure reconstruction model
       fReconst = thisReconstruction;
   }
-  void    ClassNames(char * digit, char * cluster) { 
+  void    ClassNames(const char *digit, const char *cluster) { 
     // Set class names for digits and clusters
     fDigClassName=digit; fClustClassName=cluster; 
   } 
@@ -70,10 +71,10 @@ class AliITSDetType:public TObject
   }
   //  
   
-  void GetClassNames(char* &digit, char*  &cluster) 
+  void GetClassNames(char *digit,char *cluster) 
     { 
       // Get class names for digits and rec points
-      digit=fDigClassName; cluster=fClustClassName; 
+      strcpy(digit,fDigClassName.Data()); strcpy(cluster,fClustClassName.Data()); 
     } 
   
 protected:
@@ -83,13 +84,11 @@ protected:
   AliITSresponse       *fResponse;         // response
   AliITSsegmentation   *fSegmentation;     // segmentation
   
-  char*              fDigClassName;      //!
-                                         // string
-  char*              fClustClassName;    //! 
-                                         // string
+  TString              fDigClassName;      // string
+  TString              fClustClassName;    // string
   
   ClassDef(AliITSDetType,1)
     
-    };
+};
 
 #endif
index 2c3cdaa..72fc4a0 100644 (file)
@@ -27,7 +27,7 @@ AliITSHNode::AliITSHNode()
 
 AliITSHNode::AliITSHNode(UChar_t sym, ULong_t freq)
 {
-  // constructor
+  // standard constructor
     fSymbol=sym;
     fFrequency=freq;
     fLeft=0;
@@ -104,10 +104,10 @@ AliITSHTable::AliITSHTable(Int_t size)
   fHNodes = new TObjArray;
   fNnodes=0;
   fSym= new Short_t[fSize];
-  for(Short_t i=0;i<fSize;i++) {
+  for (Short_t i=0;i<fSize;i++) {
        fSym[i]=i;
   }
-  Clear(); 
+  ClearTable(); 
 
 }
 
@@ -145,8 +145,7 @@ void AliITSHTable::GetFrequencies(Int_t len, UChar_t *stream)
   printf("Get Frequencies: sym %p \n",fSym);
 
   // use temporarily the fCode array to store the frequencies
-  Int_t i;
-  for(i=0; i< len; i++) {
+  for (Int_t i=0; i< len; i++) {
       Int_t idx=TMath::BinarySearch(fSize,fSym,(Short_t)stream[i]);
       if (idx == (Int_t)stream[i]) fCode[idx]++;
       // test
@@ -163,8 +162,7 @@ void AliITSHTable::BuildHTable()
 {
   // build Htable
 
-  Int_t i;
-  for(i=0; i< fSize; i++) {
+  for (Int_t i=0; i< fSize; i++) {
     //printf("i,fCode[i] %d %d\n",i,(Int_t)fCode[i]);
      if (fCode[i] > 0) {
         fNnodes++;
@@ -197,7 +195,7 @@ void AliITSHTable::BuildHTable()
 
     }
 
-    Clear();
+    ClearTable();
 
     AliITSHNode *start= (AliITSHNode*)fHNodes->UncheckedAt(0);
     SpanTree(start,0,0);
@@ -205,8 +203,7 @@ void AliITSHTable::BuildHTable()
     // check the Huffman table
 
     cout << "...Done, Huffman Table is: \n";
-    Int_t c;
-    for(c=0; c <= 255; c++) {
+    for (int c=0; c <= 255; c++) {
       if (fCodeLen[c] > 0) cout << "Symbol " << c << " Coded as " << fCode[c] << " and long " << (int) fCodeLen[c] << " bits.\n"; 
     }
 
@@ -263,36 +260,10 @@ void AliITSHTable::ResetHNodes()
 }
 
 //_____________________________________________________________________________
-void AliITSHTable::Clear()
+void AliITSHTable::ClearTable()
 {
   // clear
     memset(fCodeLen,0,sizeof(UChar_t)*fSize);
     memset(fCode,0,sizeof(ULong_t)*fSize);
 }
 
-//___________________________________________________________________________
-void AliITSHTable::Streamer(TBuffer &R__b)
-{
-   // Stream an object of class AliITSHTable.
-
-   if (R__b.IsReading()) {
-      Version_t R__v = R__b.ReadVersion(); if (R__v) { }
-      TObject::Streamer(R__b);
-      R__b >> fSize;
-      R__b.ReadArray(fCodeLen);
-      R__b.ReadArray(fCode);
-      R__b.ReadArray(fSym);
-      R__b >> fHNodes;
-      R__b >> fNnodes;
-   } else {
-      R__b.WriteVersion(AliITSHTable::IsA());
-      TObject::Streamer(R__b);
-      R__b << fSize;
-      R__b.WriteArray(fCodeLen, fSize);
-      R__b.WriteArray(fCode, fSize);
-      R__b.WriteArray(fSym, fSize);
-      R__b << fHNodes;
-      R__b << fNnodes;
-   }
-}
-
index d3649ef..bbd0e35 100644 (file)
@@ -18,14 +18,6 @@ class AliITSInStream;
 class AliITSHNode: public TObject  {
 
  public:
-
-  UChar_t    fSymbol;        // comment to be written
-  ULong_t    fFrequency;     // comment to be written
-  AliITSHNode     *fLeft;    // comment to be written
-  AliITSHNode     *fRight;   // comment to be written
-  AliITSHNode     *fFather;  // not used
-  
- public:
   AliITSHNode();
   AliITSHNode(UChar_t symbol, ULong_t freq);
   virtual   ~AliITSHNode() {
@@ -41,7 +33,15 @@ class AliITSHNode: public TObject  {
   Int_t Compare(TObject *obj);
   
   ClassDef(AliITSHNode,1)     //HuffT node object for set:ITS
-    };
+
+ public:
+
+  UChar_t    fSymbol;        // comment to be written
+  ULong_t    fFrequency;     // comment to be written
+  AliITSHNode     *fLeft;    // comment to be written
+  AliITSHNode     *fRight;   // comment to be written
+  AliITSHNode     *fFather;  // not used
+};
 
 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 //  Attention! Next class has kept deliberaty in 
@@ -79,15 +79,15 @@ public:
   void BuildHTable();   
   Bool_t SpanTree(AliITSHNode*start, ULong_t code, UChar_t len);
   void ResetHNodes();
-  void Clear();
+  void ClearTable();
   
  protected:
 
   Int_t          fSize;     // size of the arrays
-  UChar_t       *fCodeLen;  //[fSize] number of bits array
-  ULong_t       *fCode;     //[fSize] coded symbols array
+  UChar_t       *fCodeLen;  //![fSize] number of bits array
+  ULong_t       *fCode;     //![fSize] coded symbols array
   
-  Short_t       *fSym;      //[fSize] array of input symbols
+  Short_t       *fSym;      //![fSize] array of input symbols
   TObjArray     *fHNodes;   // array of nodes
   Int_t          fNnodes;   // number of nodes
 
index ce23b6e..0ed43cb 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-#include <TH1.h>
+
 #include "AliITSMap.h"
 
 ClassImp(AliITSMap)
 
-ClassImp(AliITSMapA1)
-
-AliITSMapA1::AliITSMapA1(AliITSsegmentation *seg)
-{
-  //constructor
-  fSegmentation = seg;
-  fNpz=fSegmentation->Npz();
-  fNpx=fSegmentation->Npx();
-  fMaxIndex=fNpz*fNpx+fNpx;             // 2 halves of detector
-  
-  fHitMap = new Int_t[fMaxIndex];
-  fObjects = 0;
-  ClearMap();
-}
-
-AliITSMapA1::AliITSMapA1(AliITSsegmentation *seg, TObjArray *obj)
-{
-  //constructor
-  fSegmentation = seg;
-  fNpz=fSegmentation->Npz();
-  fNpx=fSegmentation->Npx();
-  fMaxIndex=fNpz*fNpx+fNpx;             // 2 halves of detector
-  
-  fHitMap = new Int_t[fMaxIndex];
-  fObjects =  obj;
-  if (fObjects) fNobjects = fObjects->GetEntriesFast();
-  ClearMap();
-}
-
-
-AliITSMapA1::~AliITSMapA1()
-{
-  //destructor
-  if (fHitMap) delete[] fHitMap;
-}
-
-//__________________________________________________________________________
-AliITSMapA1::AliITSMapA1(const AliITSMapA1 &source){
-  //     Copy Constructor 
-  if(&source == this) return;
-  this->fNpx = source.fNpx;
-  this->fNpz = source.fNpz;
-  this->fObjects = source.fObjects;
-  this->fNobjects = source.fNobjects;
-  this->fMaxIndex = source.fMaxIndex;
-  this->fHitMap = source.fHitMap;
-  return;
-}
-
-//_________________________________________________________________________
-AliITSMapA1& 
-  AliITSMapA1::operator=(const AliITSMapA1 &source) {
-  //    Assignment operator
-  if(&source == this) return *this;
-  this->fNpx = source.fNpx;
-  this->fNpz = source.fNpz;
-  this->fObjects = source.fObjects;
-  this->fNobjects = source.fNobjects;
-  this->fMaxIndex = source.fMaxIndex;
-  this->fHitMap = source.fHitMap;
-  return *this;
-}
-
-void AliITSMapA1::ClearMap()
-{
-  //clear array
-  memset(fHitMap,0,sizeof(int)*fMaxIndex);
-}
-
-void AliITSMapA1::SetArray(TObjArray *obj)
-{
-  // set array of objects
-  fObjects =  obj;
-  if (fObjects) fNobjects = fObjects->GetEntriesFast();
-}
-
-
-Int_t AliITSMapA1::CheckedIndex(Int_t iz, Int_t ix)
-{
-  //check boundaries and return an index in array
-  Int_t index=fNpx*iz+ix;
-  if (index > fMaxIndex) {
-    printf("\n \n \n Try to read/write outside array !!!! \n \n %d %d %d %d %d %d",iz,ix, fMaxIndex, index, fNpz, fNpx);
-    // force crash
-    return  -1;
-  } else {
-    return index;
-  }
-}
-
-
-void  AliITSMapA1::FillMap()
-{
-  // fill array with digits indices
-  Int_t ndigits = fObjects->GetEntriesFast();
-  //printf("MapA1: ndigits fNobjects %d %d \n",ndigits,fNobjects);
-  if (!ndigits) return;
-  
-  AliITSdigit *dig;
-  Int_t ndig;
-  for(ndig=0; ndig<ndigits; ndig++) {
-    dig = (AliITSdigit*)fObjects->UncheckedAt(ndig);
-    //printf("MapA1: ndig fCoord1 fCoord2 %d %d %d \n",dig->fCoord1,dig->fCoord2,ndig);
-    SetHit(dig->fCoord1,dig->fCoord2,ndig);
-  }
-  
-}
-
-void  AliITSMapA1::SetHit(Int_t iz, Int_t ix, Int_t idigit)
-{
-  // set the digit index at a certain position in array
-  fHitMap[CheckedIndex(iz, ix)]=idigit+1;
-}
-
-void AliITSMapA1::DeleteHit(Int_t iz, Int_t ix)
-{
-  // delete an entry in array
-  fHitMap[CheckedIndex(iz, ix)]=0;
-}
-
-void AliITSMapA1::FlagHit(Int_t iz, Int_t ix)
-{
-  // flag an entry in array
-  fHitMap[CheckedIndex(iz, ix)]=
-    -TMath::Abs(fHitMap[CheckedIndex(iz, ix)]);
-}
-
-Int_t AliITSMapA1::GetHitIndex(Int_t iz, Int_t ix)
-{
-  // return the digit index from a specific entry in array
-  return TMath::Abs(fHitMap[CheckedIndex(iz, ix)])-1;
-}
-
-TObject* AliITSMapA1::GetHit(Int_t iz, Int_t ix)
-{
-  // return the pointer to the digit 
-  Int_t index=GetHitIndex(iz,ix);
-  // Force crash if index does not exist ! 
-  return (index <0) ? 0 : fObjects->UncheckedAt(GetHitIndex(iz,ix));
-}
-
-
-Flag_t AliITSMapA1::TestHit(Int_t iz, Int_t ix)
-{
-  // check whether the digit has already been flagged
-  Int_t inf=fHitMap[CheckedIndex(iz, ix)]; 
-  if (inf < 0) {
-    return kUsed;
-  } else if (inf == 0) {
-       return kEmpty;
-  } else {
-    return kUnused;
-    }
-}
-//_______________________________________________________________________
-void AliITSMapA1::Streamer(TBuffer &R__b)
-{
-   // Stream an object of class AliITSMapA1.
-
-   if (R__b.IsReading()) {
-      Version_t R__v = R__b.ReadVersion(); if (R__v) { }
-      AliITSMap::Streamer(R__b);
-      R__b >> fSegmentation;
-      R__b >> fNpx;
-      R__b >> fNpz;
-      R__b >> fObjects;
-      R__b >> fNobjects;
-      R__b >> fMaxIndex;
-      R__b.ReadArray(fHitMap);
-   } else {
-      R__b.WriteVersion(AliITSMapA1::IsA());
-      AliITSMap::Streamer(R__b);
-      R__b << fSegmentation;
-      R__b << fNpx;
-      R__b << fNpz;
-      R__b << fObjects;
-      R__b << fNobjects;
-      R__b << fMaxIndex;
-      R__b.WriteArray(fHitMap,fMaxIndex);
-   }
-}
-
-//========================================================================
-ClassImp(AliITSMapA2)
-
-  AliITSMapA2::AliITSMapA2(AliITSsegmentation *seg)
-{
-  //constructor
-  fSegmentation = seg;
-  fNpz=fSegmentation->Npz();
-  fNpx=fSegmentation->Npx();
-  fMaxIndex=fNpz*fNpx+fNpx;             // 2 halves of detector
-  
-  fHitMap = new Double_t[fMaxIndex];
-  fMapThreshold=0.;
-  ClearMap();
-}
-
-//--------------------------------------
-AliITSMapA2::AliITSMapA2(AliITSsegmentation *seg, TObjArray *hist, Double_t thresh)
-{
-  //constructor
-  fSegmentation = seg;
-  fNpz=fSegmentation->Npz();
-  fNpx=fSegmentation->Npx();
-  fMaxIndex=fNpz*fNpx+fNpx;             // 2 halves of detector
-  
-  fHitMap = new Double_t[fMaxIndex];
-    fObjects =  hist;
-    if (fObjects) fNobjects = fObjects->GetEntriesFast();
-    fMapThreshold = thresh;
-    ClearMap();
-}
-//--------------------------------------
-
-
-AliITSMapA2::~AliITSMapA2()
-{
-  //destructor
-  if (fHitMap) delete[] fHitMap;
-}
-//--------------------------------------
-
-//__________________________________________________________________________
-AliITSMapA2::AliITSMapA2(const AliITSMapA2 &source){
-  //     Copy Constructor 
-  if(&source == this) return;
-  this->fMapThreshold = source.fMapThreshold;
-  this->fHitMap = source.fHitMap;
-  return;
-}
-
-//_________________________________________________________________________
-AliITSMapA2& 
-  AliITSMapA2::operator=(const AliITSMapA2 &source) {
-  //    Assignment operator
-  if(&source == this) return *this;
-  this->fMapThreshold = source.fMapThreshold;
-  this->fHitMap = source.fHitMap;
-  return *this;
-}
-
-void AliITSMapA2::ClearMap()
-{
-  //clear array
-  memset(fHitMap,0,sizeof(Double_t)*fMaxIndex);
-}
-
-//--------------------------------------
-void  AliITSMapA2::FillMap()
-{
-  
-  // fills signal map from digits - apply a threshold for signal
-   
-  if (!fObjects) return; 
-  
-  Int_t ndigits = fObjects->GetEntriesFast();
-  printf("MapA2: ndigits fNobjects %d %d \n",ndigits,fNobjects);
-  if (!ndigits) return;
-  
-  AliITSdigit *dig;
-  Int_t ndig;
-  for(ndig=0; ndig<ndigits; ndig++) {
-    dig = (AliITSdigit*)fObjects->UncheckedAt(ndig);
-    Double_t signal = (Double_t)(dig->fSignal);
-    if (signal >= fMapThreshold) SetHit(dig->fCoord1,dig->fCoord2,signal);
-  }
-}
-
-//--------------------------------------
-void  AliITSMapA2::SetHit(Int_t iz, Int_t ix, Double_t signal)
-{
-  // set signal at a certain position in array
-  fHitMap[CheckedIndex(iz, ix)]=signal;
-  
-}
-
-//--------------------------------------
-void AliITSMapA2::DeleteHit(Int_t iz, Int_t ix)
-{
-  //set the entry value to zero
-  fHitMap[CheckedIndex(iz, ix)]=0;
-}
-
-//--------------------------------------
-void AliITSMapA2::FlagHit(Int_t iz, Int_t ix)
-{
-  //flag an entry
-  fHitMap[CheckedIndex(iz, ix)]=
-    -1000.*TMath::Abs((Int_t)(fHitMap[CheckedIndex(iz, ix)])+1.);
-  
-}
-
-//--------------------------------------
-Int_t AliITSMapA2::GetHitIndex(Int_t iz, Int_t ix)
-{
-  //return the index of an entry in array 
-  return CheckedIndex(iz, ix);
-}
-
-//--------------------------------------
-TObject* AliITSMapA2::GetHit(Int_t i, Int_t dummy)
-{
-  
-  //return a pointer to the 1D histogram
-  if (fObjects) {
-    
-    return fObjects->UncheckedAt(i); 
-    
-  } else return NULL;
-  
-}
-
-//--------------------------------------
-Double_t AliITSMapA2::GetSignal(Int_t iz, Int_t ix)
-{
-  //get signal in a cell 
-  Int_t index=GetHitIndex(iz,ix);
-  return (index <0) ? 0. : fHitMap[CheckedIndex(iz, ix)];
-}
-
-//--------------------------------------
-Double_t AliITSMapA2::GetSignal(Int_t index)
-{
-  //get signal in a cell 
-  if (index<fMaxIndex) return (index <0) ? 0. : fHitMap[index];
-  else return 0.;
-}
-//--------------------------------------
-Flag_t AliITSMapA2::TestHit(Int_t iz, Int_t ix)
-{
-  // check if the entry has already been flagged
-    Int_t inf=(Int_t)fHitMap[CheckedIndex(iz, ix)];
-    
-    if (inf <= -1000) {
-      return kUsed;
-    } else if (inf == 0) {
-      return kEmpty;
-    } else {
-      return kUnused;
-    }
-}
-
-//--------------------------------------
-void  AliITSMapA2::FillMapFromHist()
-{
-  
-  // fills map from 1D histograms
-  
-  if (!fObjects) return; 
-  
-  // an example
-  Int_t i,j;
-  for(i=0; i<fNobjects; i++) {
-    TH1F *hist =(TH1F *)fObjects->UncheckedAt(i);
-    Int_t nsamples = hist->GetNbinsX();
-    for(j=0; j<nsamples; j++) {
-      Double_t signal = (Double_t)(hist->GetBinContent(j+1));
-      if (signal >= fMapThreshold) SetHit(i,j,signal);
-    }
-  }
-  
-}
-//--------------------------------------
-void  AliITSMapA2::FillHist()
-{
-  
-  // fill 1D histograms from map
-  if (!fObjects) return; 
-  
-  // an example
-  Int_t i,j;
-  for(i=0; i<fNobjects; i++) {
-    TH1F *hist =(TH1F *)fObjects->UncheckedAt(i);
-    for(j=0; j<fNpx; j++) {
-      Double_t signal=GetSignal(i,j);
-      if (signal >= fMapThreshold) hist->Fill((Float_t)j,signal);
-    }
-  }
-  
-}
-//--------------------------------------
-void  AliITSMapA2::ResetHist()
-{
-  //
-  // Reset histograms 
-  //
-  
-  if (!fObjects) return; 
-  
-  Int_t i;
-  for(i=0; i<fNobjects; i++) {
-    if ((*fObjects)[i])    ((TH1F*)(*fObjects)[i])->Reset();
-  }
-  
-}
-//______________________________________________________________________________
-void AliITSMapA2::Streamer(TBuffer &R__b)
-{
-   // Stream an object of class AliITSMapA2.
 
-   if (R__b.IsReading()) {
-      Version_t R__v = R__b.ReadVersion(); if (R__v) { }
-      AliITSMapA1::Streamer(R__b);
-      R__b.ReadArray(fHitMap);
-      R__b >> fMapThreshold;
-   } else {
-      R__b.WriteVersion(AliITSMapA2::IsA());
-      AliITSMapA1::Streamer(R__b);
-      R__b.WriteArray(fHitMap, fMaxIndex); // fMaxIndex is from AliITSMapA1.
-      R__b << fMapThreshold;
-   }
-}
index 97ddeee..b6e8d4c 100644 (file)
@@ -2,9 +2,9 @@
 #define ALIITSMAP_H
 
 
-#include "AliITS.h"
+#include <TObject.h>
 
-typedef enum {kEmpty, kUsed, kUnused} Flag_t;
+typedef enum {kEmpty, kUsed, kUnused} FlagType;
 
 //___________________________________________________________________________
 
@@ -13,104 +13,28 @@ class AliITSMap :
 
 public:
   virtual ~AliITSMap() {}
+    // Fill hits from list of digits into hit map
   virtual  void  FillMap()                                       =0;
+    // Clear the map
   virtual  void  ClearMap()                                      =0;
+    // Set a single hit
   virtual  void  SetHit(Int_t iz, Int_t ix, Int_t idigit)        =0;
+    // Delete a single hit
   virtual  void  DeleteHit(Int_t iz, Int_t ix)                   =0;
-  virtual  void   FlagHit(Int_t iz, Int_t ix)                    =0;    
+    // Flag a hit as used
+  virtual  void  FlagHit(Int_t iz, Int_t ix)                     =0;    
+    // Get index of hit in the list of digits
   virtual Int_t  GetHitIndex(Int_t iz, Int_t ix)                 =0;
+    // Get pointer to digit
   virtual TObject * GetHit(Int_t iz, Int_t ix)                   =0;
-  virtual Flag_t TestHit(Int_t iz, Int_t ix)                     =0;
+    // Test hit status
+  virtual FlagType TestHit(Int_t iz, Int_t ix)                   =0;
+    // Get signal from map
   virtual Double_t  GetSignal(Int_t iz, Int_t ix)                =0;
   
   ClassDef(AliITSMap,1) //virtual base class for ITS Hit/Digit Map
 
-    };
-
-
-class AliITSMapA1 :
-  public AliITSMap 
-{
-  
-public:
-  AliITSMapA1() {
-    // constructor
-  }
-  AliITSMapA1(AliITSsegmentation *seg);
-  AliITSMapA1(AliITSsegmentation *seg, TObjArray *dig);
-  AliITSMapA1(const AliITSMapA1 &source); // copy constructor
-  AliITSMapA1& operator=(const AliITSMapA1 &source); // assignment operator
-  
-  virtual ~AliITSMapA1();
-  virtual  void  FillMap();
-  virtual  void  ClearMap();    
-  virtual Double_t  GetSignal(Int_t iz, Int_t ix) {
-    // get signal
-    return 0.;
-  }
-  virtual  void  SetHit(Int_t iz, Int_t ix, Int_t idigit);
-  virtual void  DeleteHit(Int_t iz, Int_t ix);
-  virtual Int_t  GetHitIndex(Int_t iz, Int_t ix);
-  virtual TObject*  GetHit(Int_t iz, Int_t ix);
-  virtual  void  FlagHit(Int_t iz, Int_t ix);    
-  virtual Flag_t TestHit(Int_t iz, Int_t ix);
-  Int_t  CheckedIndex(Int_t iz, Int_t ix);
-  Int_t   MaxIndex() {
-    // max index
-    return fMaxIndex;
-  }
-  void SetArray(TObjArray *obj);
-  
-protected:
-  AliITSsegmentation *fSegmentation;   // segmentation class
-  Int_t fNpx;                          // fNpx
-  Int_t fNpz;                          // fNpz
-  TObjArray  *fObjects;                // object
-  Int_t fNobjects;                     // nu of object
-  Int_t fMaxIndex;                     // max index
-  
-private:
-  Int_t *fHitMap;                      // hit map
-
-  ClassDef(AliITSMapA1,1) // Implements Hit/Digit Map for SDD - read tree
-    };
-
-
-class AliITSMapA2 :
-public AliITSMapA1 
-{
-
-public:
-  AliITSMapA2(AliITSsegmentation *seg);
-  AliITSMapA2(AliITSsegmentation *seg, TObjArray *hist,Double_t thresh);
-  virtual ~AliITSMapA2();
-  AliITSMapA2(const AliITSMapA2 &source); // copy constructor
-  AliITSMapA2& operator=(const AliITSMapA2 &source); // assignment operator
-  virtual  void  FillMap();
-  virtual  void  ClearMap();    
-  virtual  void  SetHit(Int_t iz, Int_t ix, Int_t signal){
-    // set hit
-  }
-  virtual  void  FlagHit(Int_t iz, Int_t ix);    
-  virtual  void  DeleteHit(Int_t iz, Int_t ix);
-  virtual Int_t  GetHitIndex(Int_t iz, Int_t ix);
-  virtual TObject * GetHit(Int_t iz, Int_t dummy);
-  virtual Flag_t TestHit(Int_t iz, Int_t ix);
-  virtual Double_t  GetSignal(Int_t iz, Int_t ix);
-  void  SetHit(Int_t iz, Int_t ix, Double_t signal);
-  Double_t  GetSignal(Int_t index);
-
-private:
-  Double_t *fHitMap;        // fHitMap
-  Double_t fMapThreshold;   // fMapThreshold
-
-  void  FillMapFromHist();
-  void  FillHist();
-  void  ResetHist();
-  
-  ClassDef(AliITSMapA2,1) // Implements Signal Map for SDD -fill or read hist
-    };
-
+};
 
 #endif 
 
diff --git a/ITS/AliITSMapA1.cxx b/ITS/AliITSMapA1.cxx
new file mode 100644 (file)
index 0000000..5639fef
--- /dev/null
@@ -0,0 +1,184 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+
+#include "AliITSMapA1.h"
+#include "AliITSsegmentation.h"
+#include "AliITSresponse.h"
+#include "AliITSdigit.h"
+
+#include <TObjArray.h>
+#include <TMath.h>
+
+
+ClassImp(AliITSMapA1)
+
+AliITSMapA1::AliITSMapA1(AliITSsegmentation *seg)
+{
+  //constructor
+  fSegmentation = seg;
+  fNpz=fSegmentation->Npz();
+  fNpx=fSegmentation->Npx();
+  fMaxIndex=fNpz*fNpx+fNpx;             // 2 halves of detector
+  
+  fHitMap = new Int_t[fMaxIndex];
+  fObjects = 0;
+  ClearMap();
+}
+
+AliITSMapA1::AliITSMapA1(AliITSsegmentation *seg, TObjArray *obj)
+{
+  //constructor
+  fSegmentation = seg;
+  fNpz=fSegmentation->Npz();
+  fNpx=fSegmentation->Npx();
+  fMaxIndex=fNpz*fNpx+fNpx;             // 2 halves of detector
+  
+  fHitMap = new Int_t[fMaxIndex];
+  fObjects =  obj;
+  if (fObjects) fNobjects = fObjects->GetEntriesFast();
+  ClearMap();
+}
+
+
+AliITSMapA1::~AliITSMapA1()
+{
+  //destructor
+  if (fHitMap) delete[] fHitMap;
+}
+
+//__________________________________________________________________________
+AliITSMapA1::AliITSMapA1(const AliITSMapA1 &source){
+  //     Copy Constructor 
+  if(&source == this) return;
+  this->fNpx = source.fNpx;
+  this->fNpz = source.fNpz;
+  this->fObjects = source.fObjects;
+  this->fNobjects = source.fNobjects;
+  this->fMaxIndex = source.fMaxIndex;
+  this->fHitMap = source.fHitMap;
+  return;
+}
+
+//_________________________________________________________________________
+AliITSMapA1& 
+  AliITSMapA1::operator=(const AliITSMapA1 &source) {
+  //    Assignment operator
+  if(&source == this) return *this;
+  this->fNpx = source.fNpx;
+  this->fNpz = source.fNpz;
+  this->fObjects = source.fObjects;
+  this->fNobjects = source.fNobjects;
+  this->fMaxIndex = source.fMaxIndex;
+  this->fHitMap = source.fHitMap;
+  return *this;
+}
+
+void AliITSMapA1::ClearMap()
+{
+  //clear array
+  memset(fHitMap,0,sizeof(int)*fMaxIndex);
+}
+
+void AliITSMapA1::SetArray(TObjArray *obj)
+{
+  // set array of objects
+  fObjects =  obj;
+  if (fObjects) fNobjects = fObjects->GetEntriesFast();
+}
+
+
+Int_t AliITSMapA1::CheckedIndex(Int_t iz, Int_t ix)
+{
+  //check boundaries and return an index in array
+  Int_t index=fNpx*iz+ix;
+  if (index > fMaxIndex) {
+    printf("\n \n \n Try to read/write outside array !!!! \n \n %d %d %d %d %d %d",iz,ix, fMaxIndex, index, fNpz, fNpx);
+    // force crash
+    return  -1;
+  } else {
+    return index;
+  }
+}
+
+
+void  AliITSMapA1::FillMap()
+{
+  // fill array with digits indices
+  Int_t ndigits = fObjects->GetEntriesFast();
+  if (!ndigits) return;
+  
+  AliITSdigit *dig;
+  for (Int_t ndig=0; ndig<ndigits; ndig++) {
+    dig = (AliITSdigit*)fObjects->UncheckedAt(ndig);
+    SetHit(dig->fCoord1,dig->fCoord2,ndig);
+  }
+  
+}
+
+void  AliITSMapA1::SetHit(Int_t iz, Int_t ix, Int_t idigit)
+{
+  // set the digit index at a certain position in array
+  fHitMap[CheckedIndex(iz, ix)]=idigit+1;
+}
+
+void AliITSMapA1::DeleteHit(Int_t iz, Int_t ix)
+{
+  // delete an entry in array
+  fHitMap[CheckedIndex(iz, ix)]=0;
+}
+
+void AliITSMapA1::FlagHit(Int_t iz, Int_t ix)
+{
+  // flag an entry in array
+  fHitMap[CheckedIndex(iz, ix)]=
+    -TMath::Abs(fHitMap[CheckedIndex(iz, ix)]);
+}
+
+Int_t AliITSMapA1::GetHitIndex(Int_t iz, Int_t ix)
+{
+  // return the digit index from a specific entry in array
+  if (fHitMap[CheckedIndex(iz, ix)]) return TMath::Abs(fHitMap[CheckedIndex(iz, ix)])-1;
+  else  return 0;
+}
+
+TObject* AliITSMapA1::GetHit(Int_t iz, Int_t ix)
+{
+  // return the pointer to the digit 
+  Int_t index=GetHitIndex(iz,ix);
+  // Force crash if index does not exist ! 
+  return (index <0) ? 0 : fObjects->UncheckedAt(GetHitIndex(iz,ix));
+}
+
+Double_t AliITSMapA1::GetSignal(Int_t iz, Int_t ix)
+{
+  // get a pad signal 
+  AliITSdigit *dig = (AliITSdigit*)GetHit(iz,ix);
+  return (Double_t)dig->fSignal;
+
+}
+
+FlagType AliITSMapA1::TestHit(Int_t iz, Int_t ix)
+{
+  // check whether the digit has already been flagged
+  Int_t inf=fHitMap[CheckedIndex(iz, ix)]; 
+  if (inf < 0) {
+      return kUsed;
+  } else if (inf == 0) {
+      return kEmpty;
+  } else {
+      return kUnused;
+  }
+}
diff --git a/ITS/AliITSMapA1.h b/ITS/AliITSMapA1.h
new file mode 100644 (file)
index 0000000..75e5eff
--- /dev/null
@@ -0,0 +1,66 @@
+#ifndef ALIITSMAPA1_H
+#define ALIITSMAPA1_H
+
+
+#include "AliITSMap.h"
+class AliITSsegmentation;
+class TObjArray;
+
+
+class AliITSMapA1 :
+  public AliITSMap 
+{
+  
+public:
+  AliITSMapA1() {
+    // constructor
+  }
+  AliITSMapA1(AliITSsegmentation *seg);
+  AliITSMapA1(AliITSsegmentation *seg, TObjArray *dig);
+  AliITSMapA1(const AliITSMapA1 &source);
+    // Assignment operator
+  AliITSMapA1& operator=(const AliITSMapA1 &source);
+  
+  virtual ~AliITSMapA1();
+    // Fill hits from list of digits into hit map
+  virtual  void  FillMap();
+    // Clear the hit map
+  virtual  void  ClearMap();    
+    // Set a single hit
+  virtual  void  SetHit(Int_t iz, Int_t ix, Int_t idigit);
+    // Delete a single hit
+  virtual  void  DeleteHit(Int_t iz, Int_t ix);
+    // Get index of hit in the list of digits
+  virtual Int_t  GetHitIndex(Int_t iz, Int_t ix);
+    // Get pointer to digit
+  virtual TObject* GetHit(Int_t iz, Int_t ix);
+    // Flag a hit as used
+  virtual  void  FlagHit(Int_t iz, Int_t ix);    
+    // Test hit status
+  virtual FlagType TestHit(Int_t iz, Int_t ix);
+    // Get signal from map
+  virtual Double_t  GetSignal(Int_t iz, Int_t ix); 
+    // Get max index inmap
+  Int_t   MaxIndex() {return fMaxIndex;}
+   // Set the array of objects
+  void SetArray(TObjArray *obj);
+  
+protected:
+    // Check index
+  Int_t   CheckedIndex(Int_t iz, Int_t ix);
+
+  AliITSsegmentation *fSegmentation;   // segmentation class
+  Int_t fNpx;                          // fNpx
+  Int_t fNpz;                          // fNpz
+  TObjArray  *fObjects;                // object
+  Int_t fNobjects;                     // number of objects
+  Int_t fMaxIndex;                     // max index in map
+  
+private:
+  Int_t *fHitMap;                      //! [fMaxIndex]
+
+  ClassDef(AliITSMapA1,1)              // Implements Hit/Digit Map 
+};
+
+#endif 
+
diff --git a/ITS/AliITSMapA2.cxx b/ITS/AliITSMapA2.cxx
new file mode 100644 (file)
index 0000000..27b6115
--- /dev/null
@@ -0,0 +1,258 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+#include <TH1.h>
+#include <TObjArray.h>
+#include <TMath.h>
+
+#include "AliITSMapA2.h"
+#include "AliITSsegmentation.h"
+#include "AliITSresponse.h"
+#include "AliITSdigit.h"
+
+
+ClassImp(AliITSMapA2)
+
+  AliITSMapA2::AliITSMapA2(AliITSsegmentation *seg)
+{
+  //constructor
+  fScaleSizeZ=1;
+  fScaleSizeX=1;
+  fSegmentation = seg;
+  fNpz=fSegmentation->Npz();
+  fNpx=fSegmentation->Npx();
+  fMaxIndex=fNpz*fNpx+fNpx;             // 2 halves of detector
+  
+  fHitMap = new Double_t[fMaxIndex];
+  fMapThreshold=0.;
+  ClearMap();
+}
+//--------------------------------------
+  AliITSMapA2::AliITSMapA2(AliITSsegmentation *seg, Int_t scalesizeX, Int_t scalesizeZ)
+{
+  //constructor
+  fSegmentation = seg;
+  fScaleSizeX=scalesizeX;
+  fScaleSizeZ=scalesizeZ;
+  fNpz=fScaleSizeZ*fSegmentation->Npz();
+  fNpx=fScaleSizeX*fSegmentation->Npx();
+  fMaxIndex=fNpz*fNpx+fNpx;             // 2 halves of detector
+  
+  fHitMap = new Double_t[fMaxIndex];
+  fMapThreshold=0.;
+  ClearMap();
+}
+
+//--------------------------------------
+AliITSMapA2::AliITSMapA2(AliITSsegmentation *seg, TObjArray *obj, Double_t thresh)
+{
+  //constructor
+  fScaleSizeZ=1;
+  fScaleSizeX=1;
+  fSegmentation = seg;
+  fNpz=fSegmentation->Npz();
+  fNpx=fSegmentation->Npx();
+  fMaxIndex=fNpz*fNpx+fNpx;             // 2 halves of detector
+  
+  fHitMap = new Double_t[fMaxIndex];
+  fObjects =  obj;
+  if (fObjects) fNobjects = fObjects->GetEntriesFast();
+  fMapThreshold = thresh;
+  ClearMap();
+}
+//--------------------------------------
+
+
+AliITSMapA2::~AliITSMapA2()
+{
+  //destructor
+  if (fHitMap) delete[] fHitMap;
+}
+//--------------------------------------
+
+//__________________________________________________________________________
+AliITSMapA2::AliITSMapA2(const AliITSMapA2 &source){
+  //     Copy Constructor 
+  if(&source == this) return;
+  this->fMapThreshold = source.fMapThreshold;
+  this->fScaleSizeX = source.fScaleSizeX;
+  this->fScaleSizeZ = source.fScaleSizeZ;
+  this->fHitMap = source.fHitMap;
+  return;
+}
+
+//_________________________________________________________________________
+AliITSMapA2& 
+  AliITSMapA2::operator=(const AliITSMapA2 &source) {
+  //    Assignment operator
+  if(&source == this) return *this;
+  this->fMapThreshold = source.fMapThreshold;
+  this->fScaleSizeX = source.fScaleSizeX;
+  this->fScaleSizeZ = source.fScaleSizeZ;
+  this->fHitMap = source.fHitMap;
+  return *this;
+}
+
+//_________________________________________________________________________
+void AliITSMapA2::ClearMap()
+{
+  //clear array
+  memset(fHitMap,0,sizeof(Double_t)*fMaxIndex);
+}
+
+//--------------------------------------
+void  AliITSMapA2::FillMap()
+{
+  
+  // fills signal map from digits - apply a threshold for signal
+   
+  if (!fObjects) return; 
+  
+  Int_t ndigits = fObjects->GetEntriesFast();
+  if (!ndigits) return;
+  
+  AliITSdigit *dig;
+  for (Int_t ndig=0; ndig<ndigits; ndig++) {
+    dig = (AliITSdigit*)fObjects->UncheckedAt(ndig);
+    Double_t signal = (Double_t)(dig->fSignal);
+    if (signal >= fMapThreshold) SetHit(dig->fCoord1,dig->fCoord2,signal);
+  }
+}
+
+//--------------------------------------
+void  AliITSMapA2::SetHit(Int_t iz, Int_t ix, Double_t signal)
+{
+  // set signal at a certain position in array
+  fHitMap[CheckedIndex(iz, ix)]=signal;
+  
+}
+
+//--------------------------------------
+void AliITSMapA2::DeleteHit(Int_t iz, Int_t ix)
+{
+  //set the entry value to zero
+  fHitMap[CheckedIndex(iz, ix)]=0;
+}
+
+//--------------------------------------
+void AliITSMapA2::FlagHit(Int_t iz, Int_t ix)
+{
+  //flag an entry
+  fHitMap[CheckedIndex(iz, ix)]=
+    -1000.*TMath::Abs((Int_t)(fHitMap[CheckedIndex(iz, ix)])+1.);
+  
+}
+
+//--------------------------------------
+Int_t AliITSMapA2::GetHitIndex(Int_t iz, Int_t ix)
+{
+  //return the index of an entry in array 
+  return CheckedIndex(iz, ix);
+}
+
+//--------------------------------------
+TObject* AliITSMapA2::GetHit(Int_t i, Int_t dummy)
+{
+  
+  //return a pointer to the 1D histogram
+  if (fObjects) {
+    
+    return fObjects->UncheckedAt(i); 
+    
+  } else return NULL;
+  
+}
+
+//--------------------------------------
+Double_t AliITSMapA2::GetSignal(Int_t iz, Int_t ix)
+{
+  //get signal in a cell 
+  Int_t index=GetHitIndex(iz,ix);
+  return (index <0) ? 0. : fHitMap[CheckedIndex(iz, ix)];
+}
+
+//--------------------------------------
+Double_t AliITSMapA2::GetSignal(Int_t index)
+{
+  //get signal in a cell 
+  if (index<fMaxIndex) return (index <0) ? 0. : fHitMap[index];
+  else return 0.;
+}
+//--------------------------------------
+FlagType AliITSMapA2::TestHit(Int_t iz, Int_t ix)
+{
+  // check if the entry has already been flagged
+    Int_t inf=(Int_t)fHitMap[CheckedIndex(iz, ix)];
+    
+    if (inf <= -1000) {
+      return kUsed;
+    } else if (inf == 0) {
+      return kEmpty;
+    } else {
+      return kUnused;
+    }
+}
+
+//--------------------------------------
+void  AliITSMapA2::FillMapFromHist()
+{
+  
+  // fills map from 1D histograms
+  
+  if (!fObjects) return; 
+  
+  // an example
+  for( Int_t i=0; i<fNobjects; i++) {
+    TH1F *hist =(TH1F *)fObjects->UncheckedAt(i);
+    Int_t nsamples = hist->GetNbinsX();
+    for( Int_t j=0; j<nsamples; j++) {
+      Double_t signal = (Double_t)(hist->GetBinContent(j+1));
+      if (signal >= fMapThreshold) SetHit(i,j,signal);
+    }
+  }
+  
+}
+//--------------------------------------
+void  AliITSMapA2::FillHist()
+{
+  
+  // fill 1D histograms from map
+  if (!fObjects || fScaleSizeX != 1) return; 
+  
+  // an example
+  for( Int_t i=0; i<fNobjects; i++) {
+    TH1F *hist =(TH1F *)fObjects->UncheckedAt(i);
+    for( Int_t j=0; j<fNpx; j++) {
+      Double_t signal=GetSignal(i,j);
+      if (signal >= fMapThreshold) hist->Fill((Float_t)j,signal);
+    }
+  }
+  
+}
+//--------------------------------------
+void  AliITSMapA2::ResetHist()
+{
+  //
+  // Reset histograms 
+  //
+  
+  if (!fObjects) return; 
+  
+  for( Int_t i=0; i<fNobjects; i++) {
+    if ((*fObjects)[i])    ((TH1F*)(*fObjects)[i])->Reset();
+  }
+  
+}
+
diff --git a/ITS/AliITSMapA2.h b/ITS/AliITSMapA2.h
new file mode 100644 (file)
index 0000000..45dd8d0
--- /dev/null
@@ -0,0 +1,55 @@
+#ifndef ALIITSMAPA2_H
+#define ALIITSMAPA2_H
+
+
+#include "AliITSMapA1.h"
+
+class AliITSMapA2 :
+public AliITSMapA1 
+{
+
+public:
+  AliITSMapA2(AliITSsegmentation *seg);
+  AliITSMapA2(AliITSsegmentation *seg,Int_t scalesizeX,Int_t scalesizeZ);
+  AliITSMapA2(AliITSsegmentation *seg, TObjArray *hist,Double_t thresh);
+  virtual ~AliITSMapA2();
+  AliITSMapA2(const AliITSMapA2 &source); // copy constructor
+   // assignment operator
+  AliITSMapA2& operator=(const AliITSMapA2 &source);
+   // fill pad signals into map 
+  virtual  void  FillMap();
+   // clear map
+  virtual  void  ClearMap();    
+   // set hit
+  virtual  void  SetHit(Int_t iz, Int_t ix, Int_t signal){}
+    // Flag a hit as used
+  virtual  void  FlagHit(Int_t iz, Int_t ix);    
+  virtual  void  DeleteHit(Int_t iz, Int_t ix);
+    // Get index in the map
+  virtual Int_t  GetHitIndex(Int_t iz, Int_t ix);
+    // Get object (1D histogram)
+  virtual TObject *GetHit(Int_t iz, Int_t dummy);
+    // Test hit status
+  virtual FlagType TestHit(Int_t iz, Int_t ix);
+    // Get signal
+  virtual Double_t  GetSignal(Int_t iz, Int_t ix);
+   // set hit
+  void  SetHit(Int_t iz, Int_t ix, Double_t signal);
+    // Get signal
+  Double_t  GetSignal(Int_t index);
+
+private:
+  void  FillMapFromHist();
+  void  FillHist();
+  void  ResetHist();
+
+  Double_t *fHitMap;         //! [fMaxIndex]
+  Double_t fMapThreshold;    // threshold for signal
+  Int_t    fScaleSizeX;      // scale factor on x
+  Int_t    fScaleSizeZ;      // scale factor on z
+
+  ClassDef(AliITSMapA2,1) // Implements Signal Map
+};
+
+
+#endif 
index 668518a..150834b 100644 (file)
@@ -17,8 +17,7 @@ AliITSRawClusterSDD::AliITSRawClusterSDD(Int_t wing, Float_t Anode,Float_t Time,
   fNanodes = 1;
   fNsamples = Samples;
   Int_t sign = 1;
-  Int_t i;
-  for(i=0;i<fWing; i++) sign*=(-1);
+  for(Int_t i=0;i<fWing; i++) sign*=(-1);
   fX = DriftPath*sign/10000.;
   fZ = AnodeOffset/10000.;
 }
@@ -48,7 +47,7 @@ Bool_t AliITSRawClusterSDD::Brother(AliITSRawClusterSDD* cluster,Float_t danode,
 }
 
 //--------------------------------------
-void AliITSRawClusterSDD::Print() {
+void AliITSRawClusterSDD::PrintInfo() {
   // print
   cout << ", Anode " << fAnode << ", Time: " << fTime << ", Charge: " << fQ;
   cout << ", Samples: " << fNsamples;
@@ -124,7 +123,7 @@ Bool_t AliITSRawClusterSPD::Brother(AliITSRawClusterSPD* cluster,Float_t dz,Floa
 }
 
 //--------------------------------------
-void AliITSRawClusterSPD::Print() 
+void AliITSRawClusterSPD::PrintInfo() 
 {
   // print
   cout << ", Z: " << fZ << ", X: " << fX << ", Charge: " << fQ<<endl;
index 9e194b6..4e09bc9 100644 (file)
@@ -17,14 +17,14 @@ class AliITSRawCluster : public TObject {
 public:
   
   AliITSRawCluster() {
+    fMultiplicity=0;
     /*
       for (int k=0;k<100;k++) {
-      fIndexMap[k]=-1;
+          fIndexMap[k]=-1;
       }
       fNcluster[0]=fNcluster[1]=-1;
       fChi2=-1; 
     */
-    fMultiplicity=0;
   }
   
   virtual ~AliITSRawCluster() {
@@ -37,7 +37,7 @@ public:
   
 public:
 
-  Int_t       fMultiplicity;      // cluster multiplicity
+  Int_t       fMultiplicity;        // cluster multiplicity
   //Int_t       fIndexMap[100];     // indices of digits
   //Int_t       fNcluster[2];
   //Float_t     fChi2;
@@ -69,7 +69,7 @@ public:
   
   void Add(AliITSRawClusterSPD* clJ); 
   Bool_t Brother(AliITSRawClusterSPD* cluster,Float_t dz,Float_t dx);
-  void Print();
+  void PrintInfo();
   // Getters
   Float_t Q() const {
     // Q
@@ -160,7 +160,7 @@ public:
   
   void Add(AliITSRawClusterSDD* clJ); 
   Bool_t Brother(AliITSRawClusterSDD* cluster,Float_t dz,Float_t dx);
-  void Print();
+  void PrintInfo();
   // Getters
   Float_t X() const {
     //X
@@ -220,16 +220,16 @@ class AliITSRawClusterSSD : public AliITSRawCluster {
 public:
   
   AliITSRawClusterSSD() {
+    fMultiplicityN=0;
+    fQErr=0; 
+    fStatus=-1;
     /*
       for (int k=0;k<100;k++) {
-      fIndexMapN[k]=-1;
+         fIndexMapN[k]=-1;
       }
+      fProbability=0;
+      fChi2N=-1;
     */
-    fMultiplicityN=0;
-    // fProbability=0;
-    fQErr=0; 
-    //fChi2N=-1;
-    fStatus=-1;
   }
   AliITSRawClusterSSD(Float_t Prob,Int_t Sp,Int_t Sn);
   virtual ~AliITSRawClusterSSD() {
@@ -247,20 +247,18 @@ public:
 
    
 public:
-  // Float_t fProbability;    // The probability that this is a "real" point
-  //Int_t   fIndexMapN[100];  // indices of digits for Nside - the corresponding
-                                // info for P side is carried in the base class
-  //Float_t fChi2N;
-  
   Int_t   fMultiplicityN;  // The number of N side strips involved 
-  // in this point calculations
+                           // in this point calculations
+  Float_t fQErr;           // Total charge error
   Int_t   fStatus;         // Flag status : 0 - real point
-  //               1 - ghost 
-  //               2 - EIC ? 
-  //               3 - single side 
+                           //               1 - ghost 
+                           //               2 - EIC ? 
+                           //               3 - single side 
   
-  Float_t fQErr;           // Total charge error
+  // Float_t fProbability;    // The probability that this is a "real" point
+  // Int_t  fIndexMapN[100];  // indices of digits for Nside - the corresponding
+                                // info for P side is carried in the base class
+  // Float_t fChi2N;
   ClassDef(AliITSRawClusterSSD,1)  // AliITSRawCluster class for SSD
 
 };
diff --git a/ITS/AliITSRecPoint.cxx b/ITS/AliITSRecPoint.cxx
new file mode 100644 (file)
index 0000000..28fd789
--- /dev/null
@@ -0,0 +1,8 @@
+////////////////////////////////////////////////
+//  Reconstructed point class for set:ITS     //
+////////////////////////////////////////////////
+
+
+#include "AliITSRecPoint.h"
+
+ClassImp(AliITSRecPoint)
index 0cccf1b..bbc725d 100644 (file)
@@ -57,7 +57,8 @@ class AliITSRecPoint : public TObject {
     Float_t   fSigmaX2;   //Sigma X square of cluster
     Float_t   fSigmaZ2;   //Sigma Z square of cluster
 
-    Float_t   fProbability; // only temporary solution! - The probability 
+    Float_t   fProbability; // only temporary solution! - it will be out  
+                            // The probability 
                             // that this is a "real" point in SSD 
 
   ClassDef(AliITSRecPoint,1)  // AliITSRecPoint class
index 150d328..40daea7 100644 (file)
@@ -1,5 +1,6 @@
 #include <iostream.h>
 
+#include "AliITSdigit.h"
 #include "AliITSclusterSSD.h"
 
 ClassImp(AliITSclusterSSD)
@@ -7,7 +8,7 @@ ClassImp(AliITSclusterSSD)
 AliITSclusterSSD::AliITSclusterSSD()
 {
   // default constructor
-       fSide        = true;
+       fSide        = kTRUE;
        fDigits      = 0;
        fNDigits     = 0;
        fDigitsIndex = 0;
@@ -63,11 +64,11 @@ AliITSclusterSSD::AliITSclusterSSD(const AliITSclusterSSD &OneSCluster)
   fNCrosses = OneSCluster.fNCrosses;
   fConsumed = OneSCluster.fConsumed;
   Int_t i;
-  for(i = 0; i< fNCrosses ; i++)
+  for (i = 0; i< fNCrosses ; i++)
    {
      fCrossedClusterIndexes[i] = OneSCluster.fCrossedClusterIndexes[i];
    }
-  for(i = 0; i< fNDigits ; i++)
+  for (i = 0; i< fNDigits ; i++)
   {
     fDigitsIndex[i]=OneSCluster.fDigitsIndex[i];
   }
@@ -90,11 +91,11 @@ AliITSclusterSSD& AliITSclusterSSD::operator=(const AliITSclusterSSD & OneSClust
   fNCrosses = OneSCluster.fNCrosses;
   fConsumed = OneSCluster.fConsumed;
   Int_t i;
-  for(i = 0; i< fNCrosses ; i++)
+  for (i = 0; i< fNCrosses ; i++)
    {
      fCrossedClusterIndexes[i] = OneSCluster.fCrossedClusterIndexes[i];
    }
-  for(i = 0; i< fNDigits ; i++)
+  for (i = 0; i< fNDigits ; i++)
   {
     fDigitsIndex[i]=OneSCluster.fDigitsIndex[i];
   }
@@ -115,8 +116,7 @@ Int_t AliITSclusterSSD::SplitCluster(Int_t where, Int_t *outdigits)
   Int_t ind = 0;
     outdigits[ind++]=(*fDigitsIndex)[where];
                      //coping border strip (it is shared by this two clusters)
-    Int_t i;
-    for(i = (where+1); i < tmp; i++)
+    for (Int_t i = (where+1); i < tmp; i++)
      {
        outdigits[ind++]=(*fDigitsIndex)[i];  //"moving" strips from this to the new one 
        (*fDigitsIndex)[i]=-1;   
@@ -172,8 +172,8 @@ Double_t AliITSclusterSSD::CentrOfGravity()
   
   if (fRightNeighbour) ret+=(GetDigitStripNo(fNDigits -1)*0.5*GetDigitSignal(fNDigits -1));
       else ret+=(GetDigitStripNo(fNDigits -1)*GetDigitSignal(fNDigits-1));
-  Int_t i;
-  for(i=1;i<fNDigits-1;i++)
+      
+  for (Int_t i=1;i<fNDigits-1;i++)
     {
       ret +=GetDigitStripNo(i)*GetDigitSignal(i);
     }
@@ -203,8 +203,8 @@ Float_t AliITSclusterSSD::GetTotalSignal()
       if (fRightNeighbour) fTotalSignal += (Float_t)(0.5*GetDigitSignal(fNDigits -1));
       else fTotalSignal += (Float_t)GetDigitSignal(fNDigits-1);
       //printf("GetTotalSignal :i  DigitSignal %d %d \n",fNDigits -1,GetDigitSignal(fNDigits -1)); 
-      Int_t i;         
-      for(i = 1;i<fNDigits -1;i++) 
+                               
+      for (Int_t i = 1;i<fNDigits -1;i++) 
         {
          fTotalSignal += (Float_t)GetDigitSignal(i);
          //printf("GetTotalSignal :i  DigitSignal %d %d \n",i,GetDigitSignal(i)); 
@@ -219,8 +219,7 @@ Float_t  AliITSclusterSSD::GetTotalSignalError()
 {
   // comment to be written
   Float_t err =0;
-  Int_t i;
-  for(i =1; i<fNDigits -1; i++)
+  for (Int_t i =1; i<fNDigits -1; i++)
     {
       err+=0.1*GetDigitSignal(i);   
     } 
@@ -251,11 +250,11 @@ void AliITSclusterSSD::DelCross(Int_t index)
   // comment to be written
 Int_t i,j; //iterators
 
-for(i =0;i<fNCrosses;i++)
+for (i =0;i<fNCrosses;i++)
  {
   if ((*fCrossedClusterIndexes)[i] == index)
    {
-     for(j=i;j<fNCrosses-1;j++)
+     for (j=i;j<fNCrosses-1;j++)
       {
         (*fCrossedClusterIndexes)[j]=(*fCrossedClusterIndexes)[j+1];
       }
@@ -277,28 +276,26 @@ Int_t  *AliITSclusterSSD::GetTracks(Int_t &nt)
   
    
    fNTrack =0;
-   for(i=0;i<10;i++)
+   for (i=0;i<10;i++)
     {
      fTrack[i] = 0;
     }
    
    tidx=GetDigit(0)->GetTracks();
         
-   for(i = 0; i<3;i++)
+   for (i = 0; i<3;i++)
    {
     fTrack[i]=tidx[i];
     if (fTrack[i] != 0) fNTrack++;
    }
-   for(i = 1; i<fNDigits; i++)
+   for (i = 1; i<fNDigits; i++)
    {
     tidx=GetDigit(i)->GetTracks();
-    Int_t j;
-    for(j = 0; j<3;j++)
+    for (Int_t j = 0; j<3;j++)
     {
      bit = 1;
      if (tidx[j]==0) break;
-     Int_t k;
-     for(k = 0; k < fNTrack;k++)
+     for (Int_t k = 0; k < fNTrack;k++)
       {
        if (tidx[j]==fTrack[k]) bit =0;
       }
@@ -380,8 +377,7 @@ Double_t  AliITSclusterSSD::GetPositionError()
 Bool_t AliITSclusterSSD::IsCrossingWith(Int_t idx)
 {
   // comment to be written
- Int_t i;
- for(i =0; i< fNCrosses;i++)
+ for (Int_t i =0; i< fNCrosses;i++)
   {
     if (GetCross(i) == idx) return kTRUE;
   }
index 8ac723d..0ab0428 100644 (file)
@@ -3,9 +3,9 @@
 
 #include "TObject.h"
 #include "TArrayI.h"
-#include "AliITSdigit.h"
 #include "TClonesArray.h"
 
+class AliITSdigitSSD;
 
 class AliITSclusterSSD : public TObject
 {
index 7b48282..4e59473 100644 (file)
@@ -29,7 +29,7 @@ AliITSdcsSSD::AliITSdcsSSD(AliITSsegmentation *seg, AliITSresponse *resp)
        npar=6;
     }
 
-    Float_t *detpar = new Float_t [npar];
+    Float_t *detpar= new Float_t[npar];
     resp->GetDetParam(detpar);
 
     fNInvalid = detpar[0];
@@ -41,12 +41,11 @@ AliITSdcsSSD::AliITSdcsSSD(AliITSsegmentation *seg, AliITSresponse *resp)
     fCouplingNL = detpar[5]; 
 
 
-    Option_t *opt,*dummy;
+    char opt[30],dummy[20];
     resp->ParamOptions(opt,dummy);
     if (strstr(opt,"SetInvalid")) SetInvalidMC(fNInvalid,fISigma);
-        
-        delete [] detpar;
 
+    delete [] detpar;
 }
 
 //_____________________________________________________________________
@@ -169,8 +168,8 @@ void AliITSdcsSSD::GetInvalidParam(Float_t &mean, Float_t &sigma) {
 Bool_t AliITSdcsSSD::IsValidP(Int_t strip) {
   // isvalidP
     Int_t nElem = fInvalidP->GetSize();
-    Int_t i;
-    for(i = 0; i<nElem; i++)
+    //printf("IsValidP: nElem %d\n",nElem);
+    for(Int_t i = 0; i<nElem; i++)
        if(fInvalidP->At(i) == strip) return kFALSE;
     return kTRUE;
 }
@@ -180,8 +179,8 @@ Bool_t AliITSdcsSSD::IsValidP(Int_t strip) {
 Bool_t AliITSdcsSSD::IsValidN(Int_t strip) {
   // is valid N
     Int_t nElem = fInvalidN->GetSize();
-    Int_t i;
-    for(i = 0; i<nElem; i++)
+    //printf("IsValidN: nElem %d\n",nElem);
+    for(Int_t i = 0; i<nElem; i++)
        if(fInvalidN->At(i) == strip) return kFALSE;
     return kTRUE;
 }
index 17bd003..cf35296 100644 (file)
@@ -4,10 +4,6 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-#include <TObject.h>
-#include <TArrayS.h>
-#include <TRandom.h>
-
 //____________________________________________________________________
 //
 //  Class AliITSdcsSSD 
@@ -26,6 +22,9 @@
 //___________________________________________________________________
 //
 
+#include <TObject.h>
+#include <TArrayS.h>
+#include <TRandom.h>
 
 class AliITSsegmentation;
 class AliITSresponse;
index 5377d07..df55a7a 100644 (file)
@@ -1,22 +1,15 @@
 
 #include <stdio.h>
-#include <TObjArray.h>
 
-#include "AliITSsegmentationSSD.h"
-#include "AliITSresponseSSD.h"
-#include "AliITSsimulationSSD.h"
 #include "AliITSdictSSD.h"
-#include "AliITSdcsSSD.h"
-#include "AliITS.h"
-#include "AliRun.h"
 
 
 void AliITSdictSSD::AddTrack(Int_t track) {
   // add track
     if (fTracks > 9) return;
-    Int_t exist = 0,i;
+    Int_t exist = 0;
     
-    for(i=0; i<10; i++) 
+    for(Int_t i=0; i<10; i++) 
      {
        if(track == fTrack[i]) 
         {
index 12865cd..b18e55b 100644 (file)
@@ -3,10 +3,6 @@
 
 #include <TArrayF.h>
 
-#include "AliITSdcsSSD.h"
-
-class AliITSdcsSSD;
-
 class AliITSdictSSD  {
 
 public:
index af7c69b..e68d289 100644 (file)
@@ -33,7 +33,7 @@ ClassImp(AliITSdigitSPD)
 }
 
 //_____________________________________________________________________________
-AliITSdigitSPD::AliITSdigitSPD(Int_t *digits,Int_t *tracks) {  
+AliITSdigitSPD::AliITSdigitSPD(Int_t *digits,Int_t *tracks,Int_t *hits) {  
   //
   // Creates a simulated SPD digit object 
   //
@@ -42,16 +42,16 @@ AliITSdigitSPD::AliITSdigitSPD(Int_t *digits,Int_t *tracks) {
   fCoord2        = digits[1];
   fSignal        = digits[2];
   
-  Int_t i;
-  for(i=0; i<3; i++) {
+  for(Int_t i=0; i<3; i++) {
     fTracks[i]    = tracks[i];
+    fHits[i]      = hits[i];
   }
 }
 
 
 ClassImp(AliITSdigitSDD)
   //________________________________________________________________________
-  AliITSdigitSDD::AliITSdigitSDD(Float_t phys,Int_t *digits) {
+AliITSdigitSDD::AliITSdigitSDD(Float_t phys,Int_t *digits) {
   //
   // Creates a simulated SDD digit object to be updated
   //
@@ -62,7 +62,7 @@ ClassImp(AliITSdigitSDD)
 }
 
 //_____________________________________________________________________________
-AliITSdigitSDD::AliITSdigitSDD(Float_t phys,Int_t *digits,Int_t *tracks, Float_t *charges) {
+AliITSdigitSDD::AliITSdigitSDD(Float_t phys,Int_t *digits,Int_t *tracks,Int_t *hits,Float_t *charges) {
   //
   // Creates a simulated SDD digit object 
   //
@@ -71,17 +71,17 @@ AliITSdigitSDD::AliITSdigitSDD(Float_t phys,Int_t *digits,Int_t *tracks, Float_t
   fSignal        = digits[2];
   fPhysics       = phys;
   
-  Int_t i;
-  for(i=0; i<3; i++) {
+  for(Int_t i=0; i<3; i++) {
     fTcharges[i]  = charges[i];
     fTracks[i]    = tracks[i];
+    fHits[i]      = hits[i];
   }
 }
 
 
 ClassImp(AliITSTransientDigit)
   //_______________________________________________________________________
-  AliITSTransientDigit::AliITSTransientDigit(Float_t phys,Int_t *digits): 
+AliITSTransientDigit::AliITSTransientDigit(Float_t phys,Int_t *digits): 
     AliITSdigitSDD(phys,digits) {
   //
   // Creates a digit object in a list of digits to be updated
@@ -108,7 +108,7 @@ AliITSTransientDigit&
 
 ClassImp(AliITSdigitSSD)
   //__________________________________________________________________________
-  AliITSdigitSSD::AliITSdigitSSD(Int_t *digits) {
+AliITSdigitSSD::AliITSdigitSSD(Int_t *digits) {
   //
   // Creates a real SSD digit object 
   //
@@ -120,7 +120,7 @@ ClassImp(AliITSdigitSSD)
 }
 
 //_____________________________________________________________________________
-AliITSdigitSSD::AliITSdigitSSD(Int_t *digits,Int_t *tracks) {
+AliITSdigitSSD::AliITSdigitSSD(Int_t *digits,Int_t *tracks,Int_t *hits) {
   //
   // Creates a simulated SSD digit object 
   // 
@@ -128,10 +128,10 @@ AliITSdigitSSD::AliITSdigitSSD(Int_t *digits,Int_t *tracks) {
   fCoord1        = digits[0];
   fCoord2        = digits[1];
   fSignal        = digits[2];
-
-  Int_t i;
-  for(i=0; i<3; i++) {
+  
+  for(Int_t i=0; i<3; i++) {
     fTracks[i]    = tracks[i];
+    fHits[i]      = hits[i];
   }
 }
 
index 02d3884..d51fd4b 100644 (file)
@@ -15,7 +15,7 @@ public:
   
   Int_t fCoord1;  // Cell number on Z axis (SPD+SDD) , flag for side type (SSD)
   Int_t fCoord2 ; // Cell number on X axis (SPD+SDD) , strip number (SSD)
-  Int_t fSignal;  // Signal 
+  Int_t fSignal;  // Signal in ADC counts
   
 public:
   AliITSdigit() {
@@ -23,7 +23,7 @@ public:
     fSignal=fCoord1=fCoord2=0;
   }
   AliITSdigit(Int_t *digits);
-  virtual   ~AliITSdigit() {
+  virtual ~AliITSdigit() {
     // destructor
   }
   
@@ -37,18 +37,21 @@ public:
   
     // debugging  -- goes to the dictionary
   Int_t       fTracks[3];         // tracks making this digit 
+  Int_t       fHits[3];           // hits associated to the tracks 
+                                  // 3 hits temporarily - it will be only 1
   
 public:
   AliITSdigitSPD() {
     // constructor
     fSignal=fCoord1=fCoord2=0;
-    fTracks[0]=fTracks[1]=fTracks[2]=0;
+    fTracks[0]=fTracks[1]=fTracks[2]=-3;
+    fHits[0]=fHits[1]=fHits[2]=-1;
   }
   
   AliITSdigitSPD(Int_t *digits);
-  AliITSdigitSPD(Int_t *digits, Int_t *tracks);
+  AliITSdigitSPD(Int_t *digits, Int_t *tracks, Int_t *hits);
   
-  virtual   ~AliITSdigitSPD(){
+  virtual ~AliITSdigitSPD(){
     // destructor
   }
   virtual int *GetTracks() {
@@ -66,6 +69,8 @@ public:
   
   // debugging  -- goes to the dictionary
   Int_t       fTracks[3];         // tracks making this digit 
+  Int_t       fHits[3];           // hits associated to the tracks
+                                  // 3 hits temporarily - it will be only 1
   Float_t     fTcharges[3];       // charge per track making this digit 
   Float_t     fPhysics;           // signal particles contribution to signal
   
@@ -73,14 +78,15 @@ public:
   AliITSdigitSDD() {
     // constructor
     fSignal=fCoord1=fCoord2=0;
-    fTracks[0]=fTracks[1]=fTracks[2]=0;
+    fTracks[0]=fTracks[1]=fTracks[2]=-3;
+    fHits[0]=fHits[1]=fHits[2]=-1;
     fPhysics=0; fTcharges[0]=fTcharges[1]=fTcharges[2]=0;
   }
   
   AliITSdigitSDD(Float_t phys,Int_t *digits);
-  AliITSdigitSDD( Float_t phys, Int_t *digits, Int_t *tracks, Float_t *charges);
+  AliITSdigitSDD( Float_t phys, Int_t *digits, Int_t *tracks, Int_t *hits, Float_t *charges);
   
-  virtual   ~AliITSdigitSDD(){
+  virtual ~AliITSdigitSDD(){
     // destructor
   }
   virtual int *GetTracks() {
@@ -123,18 +129,21 @@ public:
   
   // debugging  -- goes to the dictionary
   Int_t       fTracks[3];         // tracks making this digit 
+  Int_t       fHits[3];           // hits associated to the tracks
+                                  // 3 hits temporarily - it will be only 1
   
 public:
   AliITSdigitSSD() {
     // constructor
     fSignal=fCoord1=fCoord2=0;
-    fTracks[0]=fTracks[1]=fTracks[2]=0;
+    fTracks[0]=fTracks[1]=fTracks[2]=-3;
+    fHits[0]=fHits[1]=fHits[2]=-1;
   }
   
   AliITSdigitSSD(Int_t *digits);
-  AliITSdigitSSD(Int_t *digits, Int_t *tracks);
+  AliITSdigitSSD(Int_t *digits, Int_t *tracks, Int_t *hits);
   
-  virtual   ~AliITSdigitSSD(){
+  virtual ~AliITSdigitSSD(){
     // destructor
   }
   
diff --git a/ITS/AliITSdisplay.cxx b/ITS/AliITSdisplay.cxx
new file mode 100644 (file)
index 0000000..a640d97
--- /dev/null
@@ -0,0 +1,1791 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/*
+$Log$
+Revision 1.10  1999/11/10 07:37:04  fca
+Pads do not inherit editability from canvas any more
+
+Revision 1.9  1999/11/09 07:38:51  fca
+Changes for compatibility with version 2.23 of ROOT
+
+Revision 1.8  1999/09/29 09:24:23  fca
+Introduction of the Copyright and cvs Log
+
+*/
+
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliDisplay                                                           //
+//                                                                      //
+// Utility class to display ALICE outline, tracks, hits,..              //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+#include <TROOT.h>
+#include <TTree.h>
+#include <TButton.h>
+#include <TColor.h>
+#include <TStyle.h>
+#include <TCanvas.h>
+#include <TView.h>
+#include <TText.h>
+#include <TPolyMarker3D.h>
+#include <TPaveLabel.h>
+#include <TPaveText.h>
+#include <TList.h>
+#include <TDiamond.h>
+#include <TNode.h>
+#include <TArc.h>
+#include <TTUBE.h>
+#include <TSlider.h>
+#include <TSliderBox.h>
+#include <TGaxis.h>
+#include <TVirtualX.h>
+#include <TMath.h>
+#include <TMatrix.h>
+#include <TH2.h>
+#include <TObjArray.h>
+#include <X3DBuffer.h>
+
+#include "AliRun.h"
+#include "AliDetector.h"
+#include "AliITS.h"
+#include "AliITSdigitNew.h"
+#include "AliITSMap.h"
+#include "AliITSresponseV0.h"
+#include "AliITSdisplay.h"
+#include "AliITSpoints.h"
+#include "TParticle.h"
+
+
+const  Int_t kMAXHIST = 20; 
+
+static Int_t  sModule=0; 
+
+
+ClassImp(AliITSdisplay)
+
+
+//_____________________________________________________________________________
+AliITSdisplay::AliITSdisplay()
+{
+   fPoints = 0;
+   fPhits = 0;
+   fRpoints = 0;
+   fR2points = 0;
+   fCpoints = 0;
+   fCanvas = 0;
+
+   fMap = 0;
+
+}
+
+//_____________________________________________________________________________
+AliITSdisplay::AliITSdisplay(Int_t size)
+{
+// Create an event display object.
+// A canvas named "edisplay" is created with a vertical size in pixels
+//
+//    A QUICK Overview of the Event Display functions
+//    ===============================================
+//
+//  The event display can ve invoked by executing the macro "display.C"
+// A canvas like in the picture below will appear.
+//
+//  On the left side of the canvas, the following buttons appear:
+//   *Next*       to move to the next event
+//   *Previous*   to move to the previous event
+
+//   *Pick*       Select this option to be able to point on a track with the
+//                mouse. Once on the track, use the right button to select
+//                an action. For example, select SetMarkerAttributes to
+//                change the marker type/color/size for the track.
+//   *Zoom*       Select this option (default) if you want to zoom.
+//                To zoom, simply select the selected area with the left button.
+//   *UnZoom*     To revert to the previous picture size.
+//
+//   slider R     On the left side, the vertical slider can be used to
+//                set the default picture size.
+//
+//    When you are in Zoom mode, you can click on the black part of the canvas
+//  to select special options with the right mouse button.
+
+//
+//  When you are in pick mode, you can "Inspect" the object pointed by the mouse.
+//  When you are on a track, select the menu item "InspectParticle"
+//  to display the current particle attributes.
+//
+//  You can activate the Root browser by selecting the Inspect menu
+//  in the canvas tool bar menu. Then select "Start Browser"
+//  This will open a new canvas with the browser. At this point, you may want
+//  to display some histograms (from the Trees). Go to the "File" menu
+//  of the browser and click on "New canvas".
+//  In the browser, click on item "ROOT files" in the left pane.
+//  Click on galice.root.
+//  Click on TH
+//  Click on TPC for example
+//  Click on any variable (eg TPC.fX) to histogram the variable.
+//
+//   If you are lost, you can click on HELP in any Root canvas or browser.
+//Begin_Html
+/*
+<img src="gif/aliITSdisplay.gif">
+*/
+//End_Html
+
+
+   fPad = 0;
+
+   gAlice->SetDisplay(this);
+   
+   // Set module view by default
+   fTheta = -90;
+   fPhi   =  90;
+   fPsi   =  180;
+
+   fYmodule = 0;
+
+   fModule = 393;
+   fNmodules = 0;
+
+   AliITS *ITS  = (AliITS*)gAlice->GetModule("ITS");
+   AliITSgeom *gm=ITS->GetITSgeom();
+   gm->GetModuleId(fModule,fLayer,fLadder,fDetector);   
+
+   //   fRzone   = 1.e10;
+   fDrawClusters  = kTRUE;
+   fDrawCoG       = kTRUE;
+   fDrawCathCor  = kFALSE;
+   fDrawHist  = kFALSE;
+
+   fMap = 0;
+
+
+   fZoomMode      = 1;
+   fZooms         = 0;
+   fClustersCuts  = 0;
+   fPoints        = 0;
+   fPhits         = 0;
+   fRpoints       = 0;
+   fR2points = 0;
+   fCpoints = 0;
+
+   /*
+   // Initialize display default parameters
+   SetRange(3.5,3.5);
+   // Create colors
+   CreateColors();
+   // Create display canvas
+   Int_t ysize = size;
+   if (ysize < 100) ysize = 750;
+   Int_t xsize = Int_t(size*830./ysize);
+   fCanvas = new TCanvas("ModuleCanvas", "ITS Clusters Display",14,47,xsize,ysize);
+   fCanvas->ToggleEventStatus();
+   
+   // Create main display pad
+   fPad = new TPad("mviewpad", "ITS display",0.15,0,0.9,1);
+   fPad->Draw();
+   fPad->Modified();
+   fPad->SetFillColor(1);
+   fPad->SetBorderSize(2);
+
+   fCanvas->cd();
+
+   // Create colors pad
+   fColPad = new TPad("colpad", "Colors pad",0.9,0,1,1);
+   fColPad->Draw();
+   fColPad->Modified();
+   fColPad->SetFillColor(19);
+   fColPad->SetBorderSize(2);
+   fColPad->cd();
+   DisplayColorScale();
+
+   fCanvas->cd();
+
+   // Create user interface control pad
+   DisplayButtons();
+   fCanvas->cd();
+
+   // Create Range and mode pad
+   Float_t dxtr     = 0.15;
+   Float_t dytr     = 0.45;
+   fTrigPad = new TPad("mtrigger", "range and mode pad",0,0,dxtr,dytr);
+   fTrigPad->SetEditable(kFALSE);
+   fTrigPad->Draw();
+   fTrigPad->cd();
+   fTrigPad->SetFillColor(22);
+   fTrigPad->SetBorderSize(2);
+   fRangeSlider = new TSlider("mrange","range",0.7,0.42,0.9,0.98);
+   fRangeSlider->SetObject(this);
+   //char pickmode[] = "gAlice->Display()->SetPickMode()";
+   char pickmode[] = "((AliITSdisplay*)(gAlice->Display()))->SetPickMode()";
+   Float_t db = 0.09;
+   fPickButton = new TButton("Pick",pickmode,0.05,0.32,0.65,0.32+db);
+   fPickButton->SetFillColor(38);
+   fPickButton->Draw();
+   //char zoommode[] = "gAlice->Display()->SetZoomMode()";
+   char zoommode[] = "((AliITSdisplay*)(gAlice->Display()))->SetZoomMode()";
+   fZoomButton = new TButton("Zoom",zoommode,0.05,0.21,0.65,0.21+db);
+   fZoomButton->SetFillColor(38);
+   fZoomButton->Draw();
+   fArcButton = new TArc(.8,fZoomButton->GetYlowNDC()+0.5*db,0.33*db);
+   fArcButton->SetFillColor(kGreen);
+   fArcButton->Draw();
+   //char butUnzoom[] = "gAlice->Display()->UnZoom()";
+   char butUnzoom[] = "((AliITSdisplay*)(gAlice->Display()))->UnZoom()";
+   TButton *button = new TButton("UnZoom",butUnzoom,0.05,0.05,0.95,0.15);
+   button->SetFillColor(38);
+   button->Draw();
+   AppendPad(); // append display object as last object to force selection
+
+   fCanvas->cd();
+   fCanvas->Update();
+   */
+
+   CreateModuleCanvas(size);
+
+}
+
+//_____________________________________________________________________________
+void AliITSdisplay::CreateModuleCanvas(Int_t size)
+{
+
+   // Initialize display default parameters
+   SetRange(3.5,3.5);
+   // Create colors
+   CreateColors();
+   // Create display canvas
+   Int_t ysize = size;
+   if (ysize < 100) ysize = 750;
+   Int_t xsize = Int_t(size*830./ysize);
+   fCanvas = new TCanvas("ModuleCanvas", "ITS Clusters Display",14,47,xsize,ysize);
+   fCanvas->ToggleEventStatus();
+
+    Int_t wtopx, wtopy;
+    UInt_t ww,wh;
+    fCanvas->GetCanvasPar(wtopx,wtopy,ww,wh);
+
+      Float_t cx = gStyle->GetScreenFactor();
+
+    printf("CreateCanvas: cx wtopx wtopy ww wh %f %d %d %d %d\n", cx,wtopx,wtopy,ww,wh);
+      Int_t dum1,dum2;
+      UInt_t fCw,fCh;
+
+      Int_t fCanvasID=fCanvas->GetCanvasID();
+      gVirtualX->GetGeometry(fCanvasID, dum1, dum2, fCw, fCh);
+
+    printf("CreateCanvas: fCw, fCh %d %d \n", fCw, fCh );
+
+
+   
+   // Create main display pad
+   fPad = new TPad("mviewpad", "ITS display",0.15,0,0.9,1);
+   fPad->Draw();
+   fPad->Modified();
+   fPad->SetFillColor(1);
+   fPad->SetBorderSize(2);
+
+   fCanvas->cd();
+
+   // Create colors pad
+   fColPad = new TPad("colpad", "Colors pad",0.9,0,1,1);
+   fColPad->Draw();
+   fColPad->Modified();
+   fColPad->SetFillColor(19);
+   fColPad->SetBorderSize(2);
+   fColPad->cd();
+   DisplayColorScale();
+
+   fCanvas->cd();
+
+   // Create user interface control pad
+   DisplayButtons();
+   fCanvas->cd();
+
+   // Create Range and mode pad
+   Float_t dxtr     = 0.15;
+   Float_t dytr     = 0.45;
+   fTrigPad = new TPad("mtrigger", "range and mode pad",0,0,dxtr,dytr);
+   fTrigPad->SetEditable(kFALSE);
+   fTrigPad->Draw();
+   fTrigPad->cd();
+   fTrigPad->SetFillColor(22);
+   fTrigPad->SetBorderSize(2);
+   fRangeSlider = new TSlider("mrange","range",0.7,0.42,0.9,0.98);
+   fRangeSlider->SetObject(this);
+
+   // to use  "gAlice->Display()->SetPickMode()" KEEP "trigger" instead
+   // of "mtrigger" and "range" instead of "mrange" !!!! - do NOT change
+   // the pad names if mix methods from AliDisplay and AliITSdisplay !
+
+   //char pickmode[] = "gAlice->Display()->SetPickMode()";
+   char pickmode[] = "((AliITSdisplay*)(gAlice->Display()))->SetPickMode()";
+   Float_t db = 0.09;
+   fPickButton = new TButton("Pick",pickmode,0.05,0.32,0.65,0.32+db);
+   fPickButton->SetFillColor(38);
+   fPickButton->Draw();
+   //char zoommode[] = "gAlice->Display()->SetZoomMode()";
+   char zoommode[] = "((AliITSdisplay*)(gAlice->Display()))->SetZoomMode()";
+   fZoomButton = new TButton("Zoom",zoommode,0.05,0.21,0.65,0.21+db);
+   fZoomButton->SetFillColor(38);
+   fZoomButton->Draw();
+   fArcButton = new TArc(.8,fZoomButton->GetYlowNDC()+0.5*db,0.33*db);
+   fArcButton->SetFillColor(kGreen);
+   fArcButton->Draw();
+   //char butUnzoom[] = "gAlice->Display()->UnZoom()";
+   char butUnzoom[] = "((AliITSdisplay*)(gAlice->Display()))->UnZoom()";
+   TButton *button = new TButton("UnZoom",butUnzoom,0.05,0.05,0.95,0.15);
+   button->SetFillColor(38);
+   button->Draw();
+   AppendPad(); // append display object as last object to force selection
+
+   fCanvas->cd();
+   fCanvas->Update();
+}
+
+
+//_____________________________________________________________________________
+AliITSdisplay::~AliITSdisplay()
+{
+  // Delete space point structure
+  if (fPoints) fPoints->Delete();
+  delete fPoints;
+  fPoints     = 0;
+  //
+  if (fPhits) fPhits->Delete();
+  delete fPhits;
+  fPhits     = 0;
+  //
+  if (fRpoints) fRpoints->Delete();
+  delete fRpoints;
+  fRpoints     = 0;
+//
+  if (fR2points) fR2points->Delete();
+  delete fR2points;
+  fR2points     = 0;
+//
+  if (fCpoints) fCpoints->Delete();
+  delete fCpoints;
+  fCpoints     = 0;
+}
+
+//_____________________________________________________________________________
+void AliITSdisplay::Clear(Option_t *)
+{
+//    Delete graphics temporary objects
+}
+
+//_____________________________________________________________________________
+void AliITSdisplay::DisplayButtons()
+{
+//    Create the user interface buttons
+
+
+   fButtons = new TPad("buttons", "newpad",0,0.45,0.15,1);
+   fButtons->SetEditable(kFALSE);
+   fButtons->Draw();
+   fButtons->SetFillColor(38);
+   fButtons->SetBorderSize(2);
+   fButtons->cd();
+
+//   Int_t butcolor = 33;
+   Float_t dbutton = 0.08;
+   Float_t y  = 0.96;
+   Float_t dy = 0.014;
+   Float_t x0 = 0.05;
+   Float_t x1 = 0.95;
+
+   TButton *button;
+   char but1[] = "((AliITSdisplay*)(gAlice->Display()))->ShowNextEvent(1)";
+   button = new TButton("Next",but1,x0,y-dbutton,x1,y);
+   button->SetFillColor(38);
+   button->Draw();
+
+   y -= dbutton +dy;
+   //char but2[] = "gAlice->Display()->ShowNextEvent(-1)";
+   char but2[] = "((AliITSdisplay*)(gAlice->Display()))->ShowNextEvent(-1)";
+   button = new TButton("Previous",but2,x0,y-dbutton,x1,y);
+   button->SetFillColor(38);
+   button->Draw();
+
+   y -= dbutton + dy;
+   char but3[] = "((AliITSdisplay*)(gAlice->Display()))->NextModule(1)";
+   button = new TButton("Module +", but3, x0, y - dbutton, x1, y);
+   button->SetFillColor(38);
+   button->Draw();
+    
+   y -= dbutton + dy;
+   char but4[] = "((AliITSdisplay*)(gAlice->Display()))->NextModule(-1)";
+   button = new TButton("Module -", but4, x0, y - dbutton, x1, y);
+   button->SetFillColor(38);
+   button->Draw();
+
+   y -= dbutton + dy;
+   char but5[] = "((AliITSdisplay*)(gAlice->Display()))->DrawHistograms()";
+   button = new TButton("DrawHist", but5, x0, y - dbutton, x1, y);
+   button->SetFillColor(38);
+   button->Draw();
+   /*
+   y -= dbutton +dy;
+   char but6[] = "((AliITSdisplay*)(gAlice->Display()))->Trigger()";
+   button = new TButton("Trigger",but6,x0,y-dbutton,x1,y);
+   button->SetFillColor(38);
+   button->Draw();
+   */
+   // display logo
+   TDiamond *diamond = new TDiamond(0.05,0.015,0.95,0.22);
+   diamond->SetFillColor(50);
+   diamond->SetTextAlign(22);
+   diamond->SetTextColor(5);
+   diamond->SetTextSize(0.11);
+   diamond->Draw();
+   diamond->AddText(".. ");
+   diamond->AddText("ROOT");
+   diamond->AddText("ITS");
+   diamond->AddText("... ");
+   diamond->AddText(" ");
+}
+
+//_____________________________________________________________________________
+void AliITSdisplay::CreateColors()
+{
+//    Create the colors palette used to display clusters
+
+  Int_t k,i;
+  Int_t color;
+  Float_t r,g,b;
+  
+  for (k=1;k<=5;k++) {
+    switch(k) {
+    case 1:
+      for (i=1;i<=5;i++) {
+        r=1.;
+        g=i*0.2;  
+        b=0.;
+        color=i;
+        color=260+23-color;
+        new TColor(color,r,g,b);
+      } 
+      break;
+    case 2:
+      for (i=1;i<=4;i++) {
+        r=1.1-i*0.2;
+        g=1.;  
+        b=0.;
+        color=i+5;
+        color=260+23-color;
+        new TColor(color,r,g,b);
+      } 
+      break;
+    case 3:
+      for (i=1;i<=4;i++) {
+        r=0.;
+        g=1.;  
+        b=i*0.2+0.2;
+        color=i+9;
+        color=260+23-color;
+        new TColor(color,r,g,b);
+      } 
+      break;
+    case 4:
+      for (i=1;i<=4;i++) {
+        r=0.;
+        g=1.1-i*0.2;  
+        b=1.;
+        color=i+13;
+        color=260+23-color;
+        new TColor(color,r,g,b);
+      } 
+      break;
+    case 5:
+      for (i=1;i<=5;i++) {
+        r=i*0.2;
+        g=0.;  
+        b=1.;
+        color=i+17;
+        color=260+23-color;
+        new TColor(color,r,g,b);
+      } 
+      break;
+    }
+    
+  }
+
+}
+
+//_____________________________________________________________________________
+void AliITSdisplay::DisplayColorScale()
+{
+
+   Int_t i;
+   Int_t color;
+   Float_t xlow, ylow, xup, yup, hs;
+   Float_t x1, y1, x2, y2;
+   x1 = y1 = 0;
+   x2 = y2 = 20;
+
+   printf("DisplayColorScale - gPad %p\n",gPad);
+
+   /*
+   gPad->SetFillColor(0);
+   gPad->Clear();
+   gPad->Range(x1,y1,x2,y2);
+   */
+
+   fColPad->SetFillColor(0);
+   fColPad->Clear();
+   fColPad->Range(x1,y1,x2,y2);
+
+   TText *text = new TText(0,0,"");
+   text->SetTextFont(61);
+   text->SetTextSize(0.2);
+   text->SetTextAlign(22);
+
+   /*
+   AliMUON *MUON  = (AliMUON*)gAlice->GetModule("MUON");
+   AliMUONchamber *iChamber = &(MUON->Chamber(fChamber-1));
+   AliMUONresponse * response=iChamber->GetResponseModel();
+   Int_t adcmax= (Int_t) response->MaxAdc();
+   */
+
+   Int_t adcmax=1024;
+   
+
+   TBox *box;
+   char label[8];
+//*-* draw colortable boxes
+   hs = (y2-y1)/Float_t(22);
+   xlow=x1+1;
+   xup=x2-9;
+   for (i=0;i<22;i++) {
+       ylow = y1 + hs*(Float_t(i));
+       yup  = y1 + hs*(Float_t(i+1));
+         color = 261+i;
+        Double_t logscale=Double_t(i+1)*(TMath::Log(adcmax)/22);
+         Int_t scale=(Int_t)TMath::Exp(logscale);
+        sprintf(label,"%d",scale);
+         box = new TBox(xlow, ylow, xup, yup);
+         box->SetFillColor(color);
+         box->Draw();
+         text->DrawText(xup+4, 0.5*(ylow+yup),label);
+   }
+}
+
+//______________________________________________________________________________
+Int_t AliITSdisplay::DistancetoPrimitive(Int_t px, Int_t)
+{
+// Compute distance from point px,py to objects in event
+
+   gPad->SetCursor(kCross);
+   
+   if (gPad == fTrigPad) return 9999;
+
+   const Int_t big = 9999;
+   Int_t dist   = big;
+   Float_t xmin = gPad->GetX1();
+   Float_t xmax = gPad->GetX2();
+   Float_t dx   = 0.02*(xmax - xmin);
+   Float_t x    = gPad->AbsPixeltoX(px);
+   if (x < xmin+dx || x > xmax-dx) return dist;
+
+   if (fZoomMode) return 0;
+   else           return 7;
+}
+
+//_____________________________________________________________________________
+void AliITSdisplay::Draw(Option_t *)
+{
+//    Display current event
+
+   printf("Draw\n");
+
+   fPad->cd();
+
+   DrawView(fTheta, fPhi, fPsi);   
+   // Display the event number and title
+   fPad->cd();
+   DrawTitle();
+}
+
+
+//_____________________________________________________________________________
+void AliITSdisplay::DrawClusters()
+{
+//    Draw clusters for ITS modules
+
+   if (!fDrawClusters) return;
+
+   Int_t ndigits, digit;
+   TObjArray *points;
+   AliITSpoints *pm;
+
+   LoadDigits(fModule);
+      
+   fClustersCuts = 0;
+      points = Points();
+      if (!points) return;
+      ndigits = points->GetEntriesFast();
+      for (digit=0;digit<ndigits;digit++){
+         pm = (AliITSpoints*)points->UncheckedAt(digit);
+         if (!pm) continue;
+         Float_t *pxyz;
+         pxyz=pm->GetP();
+        TMarker3DBox *marker=pm->GetMarker(0);
+        if (marker) marker->Draw();
+        pm->Draw();
+         fClustersCuts +=pm->GetN();
+
+      }
+
+    sModule=fModule;
+}
+
+//_____________________________________________________________________________
+void AliITSdisplay::DrawHits()
+{
+//    Draw hits for ITS modules
+
+   LoadHits(fModule);
+
+   Int_t ntracks, track;
+   TObjArray *points;
+   AliITSpoints *pm;
+
+   fHitsCuts = 0;
+      points = Phits();
+      if (!points) return;
+      ntracks = points->GetEntriesFast();
+      for (track=0;track<ntracks;track++) {
+         pm = (AliITSpoints*)points->UncheckedAt(track);
+        if (!pm) continue;
+         pm->Draw();
+         fHitsCuts += pm->GetN();
+      }
+}
+
+
+//_____________________________________________________________________________
+void AliITSdisplay::DrawCoG()
+{
+//    Draw rec hits for ITS module
+
+  /*
+    if (!fDrawCoG) return;
+   LoadCoG(fChamber,fCathode);
+
+   Int_t ncog, icog;
+   TObjArray *points;
+   AliITSpoints *pm;
+
+      points = Rpoints();
+      if (!points) return;
+      ncog = points->GetEntriesFast();
+      for (icog=0;icog<ncog;icog++) {
+         pm = (AliITSpoints*)points->UncheckedAt(icog);
+        if (!pm) continue;
+         pm->Draw();
+      }
+  */
+}
+//_____________________________________________________________________________
+void AliITSdisplay::DrawCoG2()
+{
+//    Draw rec hits for ITS module
+
+  /*
+
+   if (!fDrawCoG) return;
+  
+
+  if (fCathode==1) {
+     LoadCoG2(fChamber,2);
+  } else if (fCathode==2) {
+     LoadCoG2(fChamber,1);
+  }
+
+   Int_t ncog, icog;
+   TObjArray *points;
+   AliITSpoints *pm;
+
+      points = R2points();
+      if (!points) return;
+      ncog = points->GetEntriesFast();
+      for (icog=0;icog<ncog;icog++) {
+         pm = (AliITSpoints*)points->UncheckedAt(icog);
+        if (!pm) continue;
+         pm->Draw();
+      }
+  */
+}
+//_____________________________________________________________________________
+void AliITSdisplay::DrawCathCor()
+{
+//    Draw hits for ITS chambers
+
+  /*
+    
+   if (!fDrawCathCor) return;
+
+   LoadCathCor(fChamber);
+
+   Int_t ncog, icog;
+   TObjArray *points;
+   AliITSpoints *pm;
+
+      points = Cpoints();
+      if (!points) return;
+      ncog = points->GetEntriesFast();
+      for (icog=0;icog<ncog;icog++) {
+         pm = (AliITSpoints*)points->UncheckedAt(icog);
+        if (!pm) continue;
+         pm->Draw();
+      }
+  */
+}
+
+//_____________________________________________________________________________
+void AliITSdisplay::DrawTitle(Option_t *option)
+{
+//    Draw the event title
+
+   Float_t xmin = gPad->GetX1();
+   Float_t xmax = gPad->GetX2();
+   Float_t ymin = gPad->GetY1();
+   Float_t ymax = gPad->GetY2();
+   Float_t dx   = xmax-xmin;
+   Float_t dy   = ymax-ymin;
+
+   if (strlen(option) == 0) {
+      TPaveText *title = new TPaveText(xmin +0.01*dx, ymax-0.09*dy, xmin +0.5*dx, ymax-0.01*dy);
+      title->SetBit(kCanDelete);
+      title->SetFillColor(42);
+      title->Draw();
+      char ptitle[100];
+      sprintf(ptitle,"Alice event: %d, Run:%d Module:%d",gAlice->GetHeader()->GetEvent(), gAlice->GetHeader()->GetRun(),fModule);
+      title->AddText(ptitle);
+      Int_t nparticles = gAlice->Particles()->GetEntriesFast();
+      sprintf(ptitle,"Nparticles = %d Nhits = %d Npads fired = %d",nparticles, fHitsCuts,fClustersCuts);
+      title->AddText(ptitle);
+   } else {
+      TPaveLabel *label = new TPaveLabel(xmin +0.01*dx, ymax-0.07*dy, xmin +0.2*dx, ymax-0.01*dy,option);
+      label->SetBit(kCanDelete);
+      label->SetFillColor(42);
+      label->Draw();
+   }
+}
+
+//_____________________________________________________________________________
+void AliITSdisplay::DrawView(Float_t theta, Float_t phi, Float_t psi)
+{
+//    Draw a view of ITS clusters
+
+  printf("DrawView - fPad gPad %p %p\n",fPad,gPad);
+
+   gPad->SetCursor(kWatch);
+   gPad->SetFillColor(1);
+   gPad->Clear();
+   gPad->SetFillColor(1);
+
+   Int_t iret=0;
+   TView *view = new TView(1);
+
+   printf("DrawView - view %p \n",view);
+
+   Float_t range = fRrange*fRangeSlider->GetMaximum();
+
+   printf("DrawView - range fRrange fRangeSlider %f %f %f \n",range,fRrange,fRangeSlider->GetMaximum());
+   view->SetRange(-range,-range,-range,range, range, range);
+   fZoomX0[0] = -1;
+   fZoomY0[0] = -1;
+   fZoomX1[0] =  1;
+   fZoomY1[0] =  1;
+   fZooms = 0;
+
+// Display ITS Chamber Geometry
+// gAlice->GetGeometry()->Draw("same");
+   char NodeName[7];
+   sprintf(NodeName,"ITS%d",100+fModule);
+   printf("Node name %s\n", NodeName);
+   
+   TNode *node1=gAlice->GetGeometry()->GetNode(NodeName);
+   if (node1) node1->Draw("same");  
+
+//add clusters to the pad
+   DrawClusters();
+   DrawHits();
+   //DrawCoG();
+   // DrawCoG2();
+   //DrawCathCor();
+
+  printf("DrawView - before append fPad gPad %p %p\n",fPad,gPad);
+   // add itself to the list (must be last)
+   AppendPad();
+   view->SetView(phi, theta, psi, iret);
+}
+
+
+//______________________________________________________________________________
+void AliITSdisplay::ExecuteEvent(Int_t event, Int_t px, Int_t py)
+{
+//  Execute action corresponding to the mouse event
+
+   static Float_t x0, y0, x1, y1;
+
+   static Int_t pxold, pyold;
+   static Int_t px0, py0;
+   static Int_t linedrawn;
+   Float_t temp;
+
+
+   /*
+   //printf("ExecuteEvent - px py %d %d\n",px,py);
+
+   int px1 = gPad->GetEventX();
+   int py1 = gPad->GetEventY();
+   float uxmin = gPad->GetUxmin();
+   float uxmax = gPad->GetUxmax();
+   int pxmin = gPad->XtoAbsPixel(uxmin);
+   int pxmax = gPad->XtoAbsPixel(uxmax);
+
+   //printf("ExecuteEvent - px1 py1 uxmin uxmax pxmin pxmax %d %d %f %f %d %d\n",px1,py1,uxmin,uxmax,pxmin,pxmax);
+
+   Float_t x = gPad->AbsPixeltoX(px);
+   Float_t y = gPad->AbsPixeltoY(py);
+   //printf("x=%.3g, y=%.3g \n",gPad->PadtoX(x),gPad->PadtoY(y));
+
+   TObject *select = gPad->GetSelected();
+   if(!select) {printf("no select \n"); return;}
+   if (select->InheritsFrom("AliITSdisplay")) printf("Inherits from AliITSdisplay \n");
+
+   if (select->InheritsFrom("TCanvas")) printf("Inherits from TCanvas \n");
+   if (select->InheritsFrom("TView")) printf("Inherits from TView \n");
+
+    Float_t x,y;
+
+   // x,y in the -1,1 scale
+      x = gPad->AbsPixeltoX(px);
+      y = gPad->AbsPixeltoY(py);
+     
+   printf("abspixeltoX: px py %d %d x=%.3g, y=%.3g \n",px,py,x,y);
+   printf("x=%.3g, y=%.3g \n",gPad->PadtoX(x),gPad->PadtoY(y));
+
+   // it should be smth like ? - no ! 
+      x = gPad->AbsPixeltoX(px)*fRrange*fRangeSlider->GetMaximum();
+      y = gPad->AbsPixeltoY(py)*fRrange*fRangeSlider->GetMaximum();
+      // now find out how to convert these x,y to x,y in detector system
+
+      Int_t dum1,dum2;
+      UInt_t fCw, fCh;
+      Float_t fYsizeReal, fXsizeReal;
+
+      Int_t fCanvasID=fCanvas->GetCanvasID();
+      gVirtualX->GetGeometry(fCanvasID, dum1, dum2, fCw, fCh);
+
+    printf("Exec: fCw, fCh %d %d \n", fCw, fCh );
+
+   if (fCw < fCh) {
+      fYsizeReal = 20;
+      fXsizeReal = fYsizeReal*Float_t(fCw)/Float_t(fCh);
+   }
+   else {
+      fXsizeReal = 20;
+      fYsizeReal = fXsizeReal*Float_t(fCh)/Float_t(fCw);
+   }
+
+    printf("Exec: fYsizeReal, fXsizeReal %f %f \n",fYsizeReal, fXsizeReal);
+
+      fXsizeReal = fXsizeReal*Float_t(px)/Float_t(fCw);
+      fYsizeReal = fYsizeReal*Float_t(py)/Float_t(fCh);
+
+    printf("Exec: fYsizeReal, fXsizeReal %f %f \n",fYsizeReal, fXsizeReal);
+
+   */
+
+    if (!gPad) return;
+
+    Float_t scale[3],center[3];
+    Int_t irep;
+    gPad->GetView()->FindScope(scale,center,irep);
+    for(int i=0;i<3;i++) {
+      //printf("Exec: scale center irep %f %f %d \n",scale[i],center[i],irep);
+    }
+    Float_t x,y;
+   // x,y in the -1,1 scale
+    x = gPad->AbsPixeltoX(px);
+    y = gPad->AbsPixeltoY(py);
+    Float_t xhit=x*scale[0]/(fRrange*fRangeSlider->GetMaximum());
+    Float_t yhit=y*scale[0]/(fRrange*fRangeSlider->GetMaximum());
+    //printf("Exec: x*scale y*scale xhit yhit%f %f %f %f  \n",x*scale[0],y*scale[1],xhit,yhit);
+    
+    Int_t anode, timebin;
+    GetPadIxy(anode,timebin,x*scale[0],y*scale[0]);
+    //printf("Exec: anode timebin %d %d  \n",anode,timebin);
+
+
+   if (px == 0 && py == 0) { //when called by sliders
+      if (event == kButton1Up) {
+         Draw();
+      }
+      return;
+   }
+   if (!fZoomMode && gPad->GetView()) {
+      gPad->GetView()->ExecuteRotateView(event, px, py);
+      return;
+   }
+
+   // something to zoom ?
+   gPad->SetCursor(kCross);
+   
+   switch (event) {
+
+   case kButton1Down:
+      gVirtualX->SetLineColor(-1);
+      gPad->TAttLine::Modify();  //Change line attributes only if necessary
+      x0 = gPad->AbsPixeltoX(px);
+      y0 = gPad->AbsPixeltoY(py);
+      px0   = px; py0   = py;
+      pxold = px; pyold = py;
+      linedrawn = 0;
+      return;
+
+   case kButton1Motion:
+      if (linedrawn) gVirtualX->DrawBox(px0, py0, pxold, pyold, TVirtualX::kHollow);
+      pxold = px;
+      pyold = py;
+      linedrawn = 1;
+      gVirtualX->DrawBox(px0, py0, pxold, pyold, TVirtualX::kHollow);
+      return;
+
+   case kButton1Up:
+      gPad->GetCanvas()->FeedbackMode(kFALSE);
+      if (px == px0) return;
+      if (py == py0) return;
+      x1 = gPad->AbsPixeltoX(px);
+      y1 = gPad->AbsPixeltoY(py);
+
+      if (x1 < x0) {temp = x0; x0 = x1; x1 = temp;}
+      if (y1 < y0) {temp = y0; y0 = y1; y1 = temp;}
+      gPad->Range(x0,y0,x1,y1);
+      if (fZooms < kMAXZOOM-1) {
+         fZooms++;
+         fZoomX0[fZooms] = x0;
+         fZoomY0[fZooms] = y0;
+         fZoomX1[fZooms] = x1;
+         fZoomY1[fZooms] = y1;
+      }
+      gPad->Modified(kTRUE);
+      return;
+   }
+
+}
+//___________________________________________
+void AliITSdisplay::LoadDigits(Int_t module)
+{
+// Read digits info and store x,y,z info in arrays fPoints
+
+   printf("LoadDigits - fZooms %d\n",fZooms);
+
+   if (module > fNmodules ) return;
+
+   fModule=module;
+
+   ResetPoints();
+
+   AliITS *ITS  = (AliITS*)gAlice->GetModule("ITS");
+   AliITSgeom *geom = ITS->GetITSgeom();
+
+   // get detector type
+   AliITSDetType *iDetType = ITS->DetType(fLayer); 
+   Int_t id=(Int_t)((fLayer-1)/2);
+
+   // for the moment do only SDD
+   if (id != 1) return;
+
+   TClonesArray *ITSdigits  = ITS->DigitsAddress(id);
+   if (ITSdigits == 0) return;
+
+   Int_t nent=(Int_t)gAlice->TreeD()->GetEntries();
+   printf("Entries in TreeD - nent %d\n",nent);
+   Int_t lastSPD=geom->GetLastSPD();
+   Int_t lastSDD=geom->GetLastSDD();
+   if (nent < lastSDD) {
+      printf("You have not done the digitisation for all det types !!!");
+      module=fModule-lastSPD;
+   }
+
+
+   ITS->ResetDigits();
+   gAlice->TreeD()->GetEvent(module);
+   //gAlice->TreeD()->GetEvent(nent-nofmodules+module-1);
+   Int_t ndigits = ITSdigits->GetEntriesFast();
+   printf("Found %d digits for module %d in det type %d \n",ndigits,fModule,id+1);
+   if (ndigits == 0) return;
+   if (fPoints == 0) fPoints = new TObjArray(ndigits);
+   
+   //AliITSresponseV0* resp = (AliITSresponseV0*)iDetType->GetResponseModel();
+   AliITSresponse* resp = (AliITSresponse*)iDetType->GetResponseModel();
+   resp->SetDetSize(38400,75200);
+   resp->SetDetParam(376,256,40.,6.);
+
+   if (!fMap) fMap = new AliITSMapA2(resp); 
+   if (sModule != fModule) fMap->ClearMap();
+
+
+   // if parameters in response where changed during digitisation set these
+   // parameters here as well !! resp->SetDetParam(....), SetDetSize(...)
+   // or pass in the constructor of display the pointer to a response 
+   // instantiation done in ITSdisplay.C !
+
+   AliITSdigitSDD  *mdig;
+   AliITSpoints *points = 0;
+   TMarker3DBox *marker=0;
+   Float_t xl[3], dx[3];
+   //
+   //loop over all digits and store their position
+   Int_t adcsatm=1024;
+   Int_t npoints=1;
+   for (Int_t digit=0;digit<ndigits;digit++) {
+        mdig    = (AliITSdigitSDD*)ITSdigits->UncheckedAt(digit);
+        //
+        // First get all needed parameters
+        //
+        Int_t charge=0;
+        Int_t chargecolor=0;
+        Int_t signal=mdig->fSignal;
+        for (int i=0;i<3;i++) {charge += mdig->fTcharges[i];}
+       //printf("charge %d\n",charge);
+        Int_t chargeindex=Int_t(TMath::Log(charge)/(TMath::Log(adcsatm)/22));
+        Int_t index=Int_t(TMath::Log(signal)/(TMath::Log(adcsatm)/22));
+        Int_t color=261+index;
+        if (color>282) color=282;
+        if (charge) chargecolor=261+chargeindex;
+        if (chargecolor>282) chargecolor=282;
+        Int_t anode=mdig->fCellX ;  
+        Int_t timebin=mdig->fCellY; 
+        fMap->SetHit(anode,timebin,(Double_t)signal);
+       // get the center of the pad - add on x and y half of pad size
+        GetPadCxy(anode,timebin,xl,dx);
+      
+        Float_t xpad=xl[0];
+        Float_t ypad=xl[1];
+        Float_t zpad=xl[2];
+
+        Float_t dpx=dx[0];
+        Float_t dpy=dx[1];
+        Float_t dpz=dx[2];
+
+        //printf("anode timebin charge signal %d %d %d %d \n",anode, timebin,charge,signal);
+        //printf("xpad ypad zpad %f %f %f\n",xpad,ypad,zpad);
+       //printf(" dpx dpz %f %f \n",dpx,dpz);
+       //
+       // Then set the objects
+       //
+        points = new AliITSpoints(npoints);
+       fPoints->AddAt(points,digit);
+
+        points->SetMarkerColor(color);
+        points->SetMarkerStyle(21);
+        //points->SetMarkerSize(0.5);
+        points->SetMarkerSize(0.7);
+        points->SetParticle(-1);
+        points->SetDigitIndex(digit);
+        points->SetPoint(0,xpad,ypad,zpad);    
+       marker=new TMarker3DBox(xpad,ypad,zpad,dpx,dpy,dpz,0,0);
+       //marker->SetLineColor(2);
+       marker->SetLineColor(chargecolor);
+       marker->SetFillStyle(1001);
+       marker->SetFillColor(color);
+       marker->SetRefObject((TObject*)points);
+       points->Set3DMarker(0, marker);
+
+   }
+}
+//___________________________________________
+void AliITSdisplay::GetPadCxy(Int_t anode, Int_t timebin, Float_t *xl, Float_t *dx  )
+
+{
+   AliITS *ITS  = (AliITS*)gAlice->GetModule("ITS");
+   // get detector type
+   AliITSDetType *iDetType = ITS->DetType(fLayer); 
+   AliITSresponse* resp = (AliITSresponse*)iDetType->GetResponseModel();
+
+
+    Int_t na,ns;
+    Float_t clock, speed;
+    resp->GetDetParam(na,ns,clock,speed);
+    //printf("resp na ns clock speed %p %d %d %f %f\n",resp,na,ns,clock,speed);
+
+    Float_t timestep=1000./clock;
+    Float_t pitch=resp->Pitch();
+    Float_t width=resp->Width();
+    Float_t length=resp->Length();
+    //printf("timestep pitch width length %f %f %f %f \n",timestep,pitch,width,length);
+
+    const Float_t kconv=10000;  // um->cm
+
+
+    //Float_t driftpath=timebin*timestep*speed;
+    Float_t driftpath=(timebin+1)*timestep*speed;
+    if (anode >= na) xl[0]=(length-driftpath)/kconv;
+    else xl[0]= -(length-driftpath)/kconv;
+    if (anode >= na) anode-=na;
+    //xl[2]=(anode*pitch-width/2)/kconv;
+    xl[2]=((anode+1)*pitch-width/2)/kconv;
+    xl[1]=fYmodule;
+    //printf("anode timebin %d %d \n",anode,timebin);
+    //printf("anode*pitch timebin*timestep*speed %f %f\n",anode*pitch,timebin*timestep*speed);
+
+    // keep these for drawing
+    //dx[0]=timestep*speed/kconv/2.1;
+    //dx[1]=0;
+    //dx[2]=pitch/kconv/2.05;
+
+    dx[0]=timestep*speed/kconv/2;
+    dx[1]=0;
+    dx[2]=pitch/kconv/2;
+}
+
+//___________________________________________
+void AliITSdisplay::GetPadIxy(Int_t &anode, Int_t &timebin,Float_t x,Float_t z)
+{
+   AliITS *ITS  = (AliITS*)gAlice->GetModule("ITS");
+   // get detector type
+   AliITSDetType *iDetType = ITS->DetType(fLayer); 
+   AliITSresponse* resp = (AliITSresponse*)iDetType->GetResponseModel();
+
+
+    Int_t na,ns;
+    Float_t clock, speed;
+    resp->GetDetParam(na,ns,clock,speed);
+
+    Float_t timestep=1000./clock;
+    Float_t pitch=resp->Pitch();
+    Float_t width=resp->Width();
+    Float_t length=resp->Length();
+
+    const Float_t kconv=10000;  // cm->um
+
+    Float_t driftpath=length-TMath::Abs(kconv*x);
+    timebin=(Int_t)(driftpath/speed/timestep);
+    anode=kconv*z/pitch + na/2;
+    if (x > 0) anode += na;
+
+    timebin+=1;
+    anode+=1;
+    //printf("anode timebin %d %d\n",anode,timebin);
+
+}
+//___________________________________________
+void AliITSdisplay::LoadCoG(Int_t chamber, Int_t cathode)
+{
+// Read raw clusters info and store x,y,z info in arrays fRpoints
+// Loop on all detectors
+
+  /*
+
+   if (chamber > 10) return;
+
+   ResetRpoints();
+
+   AliITS *ITS  = (AliITS*)gAlice->GetModule("ITS");
+   AliITSchamber*  iChamber;
+
+   TClonesArray *ITSrawclust  = ITS->RawClustAddress(chamber-1);
+   if (ITSrawclust == 0) return;
+
+   ITS->ResetRawClusters();
+
+
+   Int_t nent=(Int_t)gAlice->TreeR()->GetEntries();
+   gAlice->TreeR()->GetEvent(nent-2+cathode-1);
+   //gAlice->TreeR()->GetEvent(cathode);
+   Int_t nrawcl = ITSrawclust->GetEntriesFast();
+   if (nrawcl == 0) return;
+   if (fRpoints == 0) fRpoints = new TObjArray(nrawcl);
+         
+   iChamber = &(ITS->Chamber(chamber-1));
+   Float_t zpos=iChamber->ZPosition();  
+   AliITSRawCluster  *mRaw;
+   AliITSpoints *points = 0;
+   //
+   //loop over all raw clusters and store their position
+   points = new AliITSpoints(nrawcl);
+   for (Int_t iraw=0;iraw<nrawcl;iraw++) {
+       mRaw   = (AliITSRawCluster*)ITSrawclust->UncheckedAt(iraw);
+       fRpoints->AddAt(points,iraw);
+        points->SetMarkerColor(51);
+        points->SetMarkerStyle(2);
+        points->SetMarkerSize(1.);
+        points->SetParticle(-1);
+        points->SetHitIndex(-1);
+        points->SetTrackIndex(-1);
+        points->SetDigitIndex(-1);
+        points->SetPoint(iraw,mRaw->fX,mRaw->fY,zpos);
+   }
+  */
+}
+//___________________________________________
+void AliITSdisplay::LoadCoG2(Int_t chamber, Int_t cathode)
+{
+// Read raw clusters info and store x,y,z info in arrays fRpoints
+// Loop on all detectors
+  /*
+
+   if (chamber > 10) return;
+
+   ResetR2points();
+
+   AliITS *ITS  = (AliITS*)gAlice->GetModule("ITS");
+   AliMUONchamber*  iChamber;
+
+   TClonesArray *MUONrawclust  = MUON->RawClustAddress(chamber-1);
+   if (MUONrawclust == 0) return;
+
+   MUON->ResetRawClusters();
+
+   Int_t nent=(Int_t)gAlice->TreeR()->GetEntries();
+   gAlice->TreeR()->GetEvent(nent-2+cathode-1);
+   //gAlice->TreeR()->GetEvent(cathode);
+   Int_t nrawcl = MUONrawclust->GetEntriesFast();
+   if (nrawcl == 0) return;
+   if (fR2points == 0) fR2points = new TObjArray(nrawcl);
+         
+   iChamber = &(MUON->Chamber(chamber-1));
+   Float_t zpos=iChamber->ZPosition();  
+   AliMUONRawCluster  *mRaw;
+   AliMUONpoints *points = 0;
+   //
+   //loop over all raw clusters and store their position
+   points = new AliMUONpoints(nrawcl);
+   for (Int_t iraw=0;iraw<nrawcl;iraw++) {
+       mRaw   = (AliMUONRawCluster*)MUONrawclust->UncheckedAt(iraw);
+       fR2points->AddAt(points,iraw);
+        points->SetMarkerColor(51);
+        points->SetMarkerStyle(4);
+        points->SetMarkerSize(1.3);
+        points->SetParticle(-1);
+        points->SetHitIndex(-1);
+        points->SetTrackIndex(-1);
+        points->SetDigitIndex(-1);
+        points->SetPoint(iraw,mRaw->fX,mRaw->fY,zpos);
+   }
+  */
+}
+//___________________________________________
+void AliITSdisplay::LoadCathCor(Int_t chamber)
+{
+// Read correlation info and store x,y,z info in arrays fCpoints
+// Loop on all detectors
+
+  /*
+     if (chamber > 10) return;
+     fChamber=chamber;
+     ResetCpoints();
+
+     AliMUON *MUON  = (AliMUON*)gAlice->GetModule("MUON");
+     AliMUONchamber*  iChamber;
+     iChamber = &(MUON->Chamber(chamber-1));
+     Float_t zpos=iChamber->ZPosition();  // check with Andreas
+
+
+   //new
+     MUON->GetTreeC(fEvent);
+     TTree *TC=MUON->TreeC();
+     if (!TC) return;
+     //     Int_t nent=(Int_t)TC->GetEntries();
+     TClonesArray *MUONcorrel  = MUON->CathCorrelAddress(chamber-1);
+     if (MUONcorrel == 0) return;
+
+     MUON->ResetCorrelation();
+     TC->GetEvent();
+
+     Int_t ncor = MUONcorrel->GetEntries();
+     if (!ncor) return;
+     if (!fCpoints) fCpoints = new TObjArray(ncor);
+         
+     AliMUONcorrelation  *mCor;
+     AliMUONpoints *points = 0;
+   //
+   //loop over all raw clusters and store their position
+     points = new AliMUONpoints(ncor);
+     for (Int_t icor=0;icor<ncor;icor++) {
+          mCor   = (AliMUONcorrelation*)MUONcorrel->UncheckedAt(icor);
+         fCpoints->AddAt(points,icor);
+          points->SetMarkerColor(4);
+          points->SetMarkerStyle(4);
+          points->SetMarkerSize(0.8);
+          points->SetParticle(-1);
+          points->SetHitIndex(-1);
+          points->SetTrackIndex(-1);
+          points->SetDigitIndex(-1);
+          points->SetPoint(icor,mCor->fX[0],mCor->fY[0],zpos);
+    }
+  */
+}
+
+//___________________________________________
+void AliITSdisplay::LoadHits(Int_t module)
+{
+
+// Read hits info and store x,y,z info in arrays fPhits
+// Loop on all detectors
+
+
+   if (module > fNmodules || fNmodules==0) return;
+
+   fModule=module;
+   printf("LoadModuleHits - fModule module %d %d\n",fModule,module);
+   ResetPhits();
+
+   AliITS *ITS  = (AliITS*)gAlice->GetModule("ITS");
+   AliITSgeom *geom = ITS->GetITSgeom();
+
+   // try fITSmodules first (memory) - check also TreeH with the condition
+   // if (module != fModule) continue; - see the speed
+
+    TObjArray *mods = ITS->GetModules();
+    Int_t nentries=(Int_t)mods->GetEntriesFast();
+    printf("nentries %d\n",nentries);
+
+    AliITSmodule *mod = (AliITSmodule *)mods->UncheckedAt(fModule);
+    TObjArray *fHits = mod->GetHits();
+    Int_t nhits = fHits->GetEntriesFast();
+    if (fPhits == 0) fPhits = new TObjArray(nhits);
+    printf("LoadModuleHits - fPhits fModule nhits %p %d %d\n",fPhits,fModule,nhits);
+    AliITSpoints *points = 0;
+    AliITShit *mHit = 0;
+    Int_t idtrack, idhit;
+    for (Int_t hit=0;hit<nhits;hit++) {
+        mHit = (AliITShit*)fHits->UncheckedAt(hit);
+        mod->GetHitTrackAndHitIndex(hit,idtrack,idhit);
+        printf("hit eloss %d %f\n",hit,mHit->GetIonization());
+        printf("layer ladder det %d %d %d\n",mHit->GetLayer(),mHit->GetLadder(),mHit->GetDetector());
+        if (!mHit->GetIonization()) continue;
+        //fYmodule=mHit->fY;
+        Float_t xl[3], xg[3];
+        xg[0]=mHit->fX;
+        xg[1]=mHit->fY;
+        xg[2]=mHit->fZ;
+
+       geom->GtoL(fModule,xg,xl);
+        printf("hit xhit yhit zhit %d %f %f %f\n",hit,xl[0],xl[1],xl[2]);
+        Float_t x,y,z,tof;
+        mHit->GetPositionL(x,y,z,tof);
+        printf("hit x y z %d %f %f %f\n",hit,x,y,z);
+
+        fYmodule=xl[1];
+        //
+       // Retrieve info and set the objects
+       //
+       points = new AliITSpoints();
+       points->SetMarkerColor(kRed);
+       points->SetMarkerStyle(5);
+       points->SetMarkerSize(1.);
+       points->SetParticle(mHit->fTrack);
+       points->SetHitIndex(idhit);
+       points->SetTrackIndex(idtrack);
+       //points->SetPoint(0,mHit->fX,mHit->fY,mHit->fZ);
+       points->SetPoint(0,xl[0],xl[1],xl[2]);
+       fPhits->AddAt(points,hit);
+    }
+
+}
+
+//_____________________________________________________________________________
+void AliITSdisplay::NextModule(Int_t delta)
+{
+  // to go from module to next module if delta = 1
+  // or previous module otherwise
+    if (delta == 1) {
+       if (fModule < fNmodules) fModule++;
+    } else {
+       if (fModule > 1) fModule--;
+    }
+    if (!fPad) return;
+    fPad->Clear();
+    Draw();
+}
+
+//_____________________________________________________________________________
+void AliITSdisplay::Paint(Option_t *)
+{
+//    Paint miscellaneous items
+
+}
+
+//_____________________________________________________________________________
+void AliITSdisplay::DrawHistograms()
+{
+
+  // better write a class for this - see TInspectCanvas - with a methode
+  // called xxxx and here just do smth like it's done for Inspect() in TObject
+  //gROOT->ProcessLine(Form("TInspectCanvas::Inspector((TObject *)0x%lx);",(Long_t)this));
+  // with xxxx instead of Inspector - so one can create buttons on the 
+  // new canvas and have more choices
+
+
+   printf("DrawHistograms: fZooms fZoomMode  %d %d ! \n",fZooms,fZoomMode);
+
+   if (!fZooms) return;
+
+    Float_t scale[3],center[3];
+    Int_t irep;
+    gPad->GetView()->FindScope(scale,center,irep);
+
+    Int_t amin, tmin, amax, tmax;
+    GetPadIxy(amin,tmin, fZoomX0[fZooms]*scale[0], fZoomY0[fZooms]*scale[0]);
+    printf("DrawHist: amin tmin %d %d  \n",amin,tmin);
+    GetPadIxy(amax,tmax, fZoomX1[fZooms]*scale[0], fZoomY1[fZooms]*scale[0]);
+    printf("DrawHist: amax tmax %d %d  \n",amax,tmax);
+
+    if ((fZoomX0[fZooms] < 0 && fZoomX1[fZooms] > 0) || (fZoomX0[fZooms] > 0 && fZoomX1[fZooms] < 0) ) tmax=256;
+
+    if( amax-amin > kMAXHIST) {
+        Error("DrawHistograms","Too many histograms %d! Zoom a smaller area and try again!",amax-amin);
+        return;
+    }
+    Int_t nbinx = amax-amin; 
+    Int_t nbiny = tmax-tmin;
+
+   fDrawHist = kTRUE;
+   TObjArray *fHis=0;
+
+    //create or set the new canvas c2
+   TVirtualPad *padsav = gPad;
+   TCanvas *c2 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("c2");
+   /*
+   if(c2) {
+     if (fHis) {
+       fHis->Delete(); 
+       delete fHis;     
+     }                
+   }
+   */
+   if(c2) delete c2->GetPrimitive("h2map");
+   else     c2=new TCanvas("c2","c2",14,47,830,750);
+   c2->cd();
+
+   TPad *hpad = new TPad("hpad","",0.01,0.01,0.99,0.99);
+   hpad->SetFillColor(0);
+   //hpad->Draw();
+   hpad->Divide(2,nbinx/2,0.,0.);
+   hpad->Draw();
+
+   char title[30], name[10];
+   sprintf(title,"Signal map for module %d",fModule);
+    TH2F *fTH2F = new TH2F("h2map",title,nbinx,amin,amax,nbiny,tmin,tmax);
+    fHis=new TObjArray(nbinx);
+
+   //TH1F *h1=new TH1F(" ","",nbiny,(float)tmin,(float)tmax);
+
+   for (int i=amin;i<amax;i++) {
+     //h1->Reset();
+      printf("i, i-amin  %d %d \n",i,i-amin);
+      (*fHis)[i-amin] = new TH1F(" "," ",nbiny,(float)tmin,(float)tmax);
+      //sprintf(title,"Projection on anode=%d",i);
+      sprintf(title,"anode=%d",i);
+      sprintf(name,"h%d",i);
+      ((TH1F*)((*fHis)[i-amin]))->SetTitle(title);
+      ((TH1F*)((*fHis)[i-amin]))->SetTitleSize(2.);
+      ((TH1F*)((*fHis)[i-amin]))->SetTitleOffset(2.);
+      ((TH1F*)((*fHis)[i-amin]))->SetLabelSize(0.05);
+      //((TH1F*)((*fHis)[i-amin]))->SetYTitle(title);
+      ((TH1F*)((*fHis)[i-amin]))->SetName(name);
+      ((TH1F*)((*fHis)[i-amin]))->SetStats(0);
+      //h1->SetTitle(title);
+      //h1->SetTitleSize(0.04);
+      //h1->SetYTitle(title);
+      //h1->SetName(title);
+      hpad->cd(i-amin+1);
+      for (int j=tmin;j<tmax;j++) {
+       ((TH1F*)((*fHis)[i-amin]))->Fill((float)j,(float)fMap->GetSignal(i,j));
+       //h1->Fill((float)j,(float)fMap->GetSignal(i,j));
+          fTH2F->Fill((float)i,(float)j,(float)fMap->GetSignal(i,j));
+      }
+      ((TH1F*)((*fHis)[i-amin]))->Smooth(1);
+      //((TH1F*)((*fHis)[i-amin]))->Fit("gaus","ql");
+      ((TH1F*)((*fHis)[i-amin]))->Draw();
+      //h1->Fit("gaus","ql");
+      //h1->Draw();
+      //hpad->Update();
+   }
+   c2->Update();
+   //c2->SetFillColor(1);
+   //fTH2F->Draw("LEGO2");
+
+   padsav->cd();
+   
+   fDrawHist=kFALSE;
+
+   /*
+  if (fHis) {
+     fHis->Delete(); 
+     delete fHis;     
+  }                
+   
+   */
+
+
+   /*
+   //create or set the new canvas c2
+   TVirtualPad *padsav = gPad;
+   TCanvas *c2 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("c2");
+   if(c2) delete c2->GetPrimitive("Projection");
+   if(c2) delete c2->GetPrimitive("h2map");
+   else     c2=new TCanvas("c2","c2",14,47,830,750);
+   c2->cd();
+
+   c2->SetFillColor(1);
+   fTH2F->Draw("LEGO2");
+
+   TPad *hpad = new TPad("hpad","",0.01,0.01,0.99,0.99);
+   hpad->SetFillColor(11);
+   hpad->Divide(1,nbinx/2,0.,0.);
+   hpad->Draw();
+   // -empty projections !!
+
+   //draw slice corresponding to mouse position
+   for(int i=amin;i<amax;i++) {
+     hpad->cd(i-amin+1);
+     //Int_t biny = fTH2F->GetYaxis()->FindBin(y);
+     //TH1D *hp = fTH2F->ProjectionX("",biny,biny);
+     TH1D *hp = fTH2F->ProjectionY("",i,i);
+     char title[80];
+     sprintf(title,"Projection on anode=%d",i);
+     hp->SetName("Projection");
+     hp->SetTitle(title);
+     //hp->Fit("gaus","ql");
+     hp->Draw();
+     hpad->Update();
+   }
+     c2->Update();
+     padsav->cd();
+   
+   fDrawHist=kFALSE;
+   */
+}
+
+//_____________________________________________________________________________
+void AliITSdisplay::SetPickMode()
+{
+   fZoomMode = 0;
+
+   fArcButton->SetY1(fPickButton->GetYlowNDC()+0.5*fPickButton->GetHNDC());
+   fTrigPad->Modified();
+}
+
+//_____________________________________________________________________________
+void AliITSdisplay::SetZoomMode()
+{
+   fZoomMode = 1;
+
+   fArcButton->SetY1(fZoomButton->GetYlowNDC()+0.5*fZoomButton->GetHNDC());
+   fTrigPad->Modified();
+}
+
+//_____________________________________________________________________________
+void AliITSdisplay::SetModule(Int_t layer, Int_t ladder, Int_t detector)
+{
+// Set chamber and cathode number
+   fLayer = layer;
+   fLadder = ladder;
+   fDetector = ladder;
+
+   AliITS *ITS  = (AliITS*)gAlice->GetModule("ITS");
+   AliITSgeom *gm=ITS->GetITSgeom();
+   fModule=gm->GetModuleIndex(fLayer,fLadder,fDetector);
+
+   if (!fPad) return;
+   fPad->Clear();
+   Draw();
+}
+
+//_____________________________________________________________________________
+void AliITSdisplay::SetModuleNumber(Int_t module)
+{
+// Set chamber and cathode number
+   fModule=module;
+
+   AliITS *ITS  = (AliITS*)gAlice->GetModule("ITS");
+   AliITSgeom *gm=ITS->GetITSgeom();
+   gm->GetModuleId(fModule,fLayer,fLadder,fDetector);   
+
+   if (!fPad) return;
+   fPad->Clear();
+   Draw();
+}
+//_____________________________________________________________________________
+void AliITSdisplay::SetRange(Float_t rrange, Float_t zrange)
+{
+// Set view range along R and Z
+   fRrange = rrange;
+   fZrange = zrange;
+
+   if (!fPad) return;
+   fPad->Clear();
+   Draw();
+}
+   
+//_____________________________________________________________________________
+void AliITSdisplay::SetView(Float_t theta, Float_t phi, Float_t psi)
+{
+//  change viewing angles for current event
+
+   fPad->cd();
+   fPhi   = phi;
+   fTheta = theta;
+   fPsi   = psi;
+   Int_t iret = 0;
+
+   TView *view = gPad->GetView();
+   printf("SetView view %p \n",view);
+   if (view) view->SetView(fPhi, fTheta, fPsi, iret);
+   Draw();
+   //else      Draw();
+
+   gPad->Modified();
+}
+
+//_____________________________________________________________________________
+void AliITSdisplay::ShowNextEvent(Int_t delta)
+{
+//  Display (current event_number+delta)
+//    delta =  1  shown next event
+//    delta = -1 show previous event
+  if (delta) {
+     gAlice->Clear();
+     Int_t current_event = gAlice->GetHeader()->GetEvent();
+     Int_t new_event     = current_event + delta;
+     gAlice->GetEvent(new_event);
+     fEvent=new_event;
+     if (!gAlice->TreeD() || !gAlice->TreeD() ) return; 
+   }
+  AliITS *ITS  = (AliITS*)gAlice->GetModule("ITS");
+  ITS->ClearModules();
+  ITS->InitModules(-1,fNmodules); 
+  ITS->FillModules(fEvent,0,fNmodules," "," "); //memory problems ?
+
+  fPad->cd(); 
+  Draw();
+}
+
+//_____________________________________________________________________________
+
+void AliITSdisplay::SetEvent(Int_t newevent)
+{
+    gAlice->GetEvent(newevent);
+    fEvent=newevent;
+    if (!gAlice->TreeD() || !gAlice->TreeD() ) return; 
+    if (!fPad) return;
+    AliITS *ITS  = (AliITS*)gAlice->GetModule("ITS");
+    ITS->ClearModules();
+    ITS->InitModules(-1,fNmodules); 
+    ITS->FillModules(fEvent,0,fNmodules," "," "); //memory problems ?
+    fPad->cd(); 
+    fPad->Clear();
+    Draw();
+
+}
+//______________________________________________________________________________
+void AliITSdisplay::UnZoom()
+{
+   printf("UnZoom - fZooms %d\n",fZooms);
+   if (fZooms <= 0) return;
+   fZooms--;
+   TPad *pad = (TPad*)gPad->GetPadSave();
+   printf("UnZoom - pad fPad gPad %p %p %p\n",pad,fPad,gPad);
+
+   //pad->cd();
+
+   pad->Range(fZoomX0[fZooms],fZoomY0[fZooms], fZoomX1[fZooms],fZoomY1[fZooms]);
+   pad->Modified();
+}
+
+//_____________________________________________________________________________
+void AliITSdisplay::ResetPoints()
+{
+  //
+  // Reset array of points
+  //
+  if (fPoints) {
+    fPoints->Delete();
+    delete fPoints;
+    fPoints = 0;
+  }
+}
+//_____________________________________________________________________________
+void AliITSdisplay::ResetPhits()
+{
+  //
+  // Reset array of points
+  //
+  if (fPhits) {
+    fPhits->Delete();
+    delete fPhits;
+    fPhits = 0;
+  }
+}
+//_____________________________________________________________________________
+void AliITSdisplay::ResetRpoints()
+{
+  //
+  // Reset array of points
+  //
+  if (fRpoints) {
+    fRpoints->Delete();
+    delete fRpoints;
+    fRpoints = 0;
+  }
+}
+//_____________________________________________________________________________
+void AliITSdisplay::ResetR2points()
+{
+  //
+  // Reset array of points
+  //
+  if (fR2points) {
+    fR2points->Delete();
+    delete fR2points;
+    fR2points = 0;
+  }
+}
+//_____________________________________________________________________________
+void AliITSdisplay::ResetCpoints()
+{
+  //
+  // Reset array of points
+  //
+  if (fCpoints) {
+    fCpoints->Delete();
+    delete fCpoints;
+    fCpoints = 0;
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
diff --git a/ITS/AliITSdisplay.h b/ITS/AliITSdisplay.h
new file mode 100644 (file)
index 0000000..4170e9d
--- /dev/null
@@ -0,0 +1,157 @@
+#ifndef AliITSdisplay_H
+#define AliITSdisplay_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+//////////////////////////////////////////////////////////////////////////
+//                                                                      //
+// AliDisplay                                                           //
+//                                                                      //
+// Utility class to display ALice outline, tracks, hits,..              //
+//                                                                      //
+//////////////////////////////////////////////////////////////////////////
+
+//#ifndef ROOT_TObject
+#include <TObject.h>
+//#endif
+#include "AliDisplay.h"
+
+class TCanvas;
+class TPad;
+class TList;
+class TSlider;
+class TButton;
+class TArc;
+class AliITSMapA2;
+
+const Int_t kMAXZOOM = 20;
+
+class AliITSdisplay : public AliDisplay {
+
+private:
+   Int_t             fEvent;
+
+   Int_t             fLayer;
+   Int_t             fLadder;
+   Int_t             fDetector;
+   Int_t             fModule;
+   Int_t             fNmodules;
+
+   Float_t             fYmodule;
+   Option_t            *fOption;   // option for type od det ?
+
+   Int_t             fPdgParticle;
+   Int_t             fPdgParent;
+
+   Int_t             fZoomMode;             //=1 if in zoom mode
+
+   Bool_t            fDrawHist;             //Flag True if draw histograms
+   AliITSMapA2      *fMap;                
+
+   Bool_t            fDrawClusters;         //Flag True if Clusters to be drawn
+   Bool_t            fDrawCoG;              //Flag True if CoG to be drawn
+   Bool_t            fDrawCathCor;          //Flag True if correlated point 
+                                            //to be drawn
+   Float_t           fTheta;                //Viewing angle theta
+   Float_t           fPhi;                  //Viewing angle phi
+   Float_t           fPsi;                  //Viewving angle psi (rotation on display)
+  //   Float_t           fRzone;                //
+   Float_t           fRrange;               //Size of view in R
+   Float_t           fZrange;               //Size of view along Z
+   Float_t           fZoomX0[20];           //Low x range of zoom number i
+   Float_t           fZoomY0[20];           //Low y range of zoom number i
+   Float_t           fZoomX1[20];           //High x range of zoom number i
+   Float_t           fZoomY1[20];           //High y range of zoom number i
+   Int_t             fZooms;                //Number of zooms
+
+   Int_t             fHitsCuts;             //Number of hits surviving cuts
+   Int_t             fClustersCuts;         //Number of clusters surviving cuts
+
+   TCanvas          *fCanvas;               //Pointer to the display canvas
+   TPad             *fTrigPad;              //Pointer to the trigger pad 
+   TPad             *fColPad;               //Pointer to the colors pad 
+   TPad             *fButtons;              //Pointer to the buttons pad
+   TPad             *fPad;                  //Pointer to the event display main pad
+   TSlider          *fRangeSlider;          //Range slider
+   TButton          *fPickButton;           //Button to activate Pick mode
+   TButton          *fZoomButton;           //Button to activate Zoom mode
+   TArc             *fArcButton;            //Gren/Red button to show Pick/Zoom mode
+   TObjArray        *fPoints;               //Array of points for each cathode
+   TObjArray        *fPhits;                //Array of hit points for each chamber
+   TObjArray        *fRpoints;              //Array of cog points for each cathode
+   TObjArray        *fR2points;              //Array of cog points for each cathode
+   TObjArray        *fCpoints;              //Array of correlated points for each first cathode
+
+
+public:
+                     AliITSdisplay();
+                     AliITSdisplay(Int_t size);
+   virtual          ~AliITSdisplay();
+   virtual void      Clear(Option_t *option="");
+   virtual void      CreateModuleCanvas(Int_t size);
+   virtual void      DisplayButtons();
+   virtual void      CreateColors();
+   virtual void      DisplayColorScale();
+   virtual Int_t     DistancetoPrimitive(Int_t px, Int_t py);
+   virtual void      Draw(Option_t *option="");
+   virtual void      DrawClusters();
+   virtual void      DrawHits();
+   virtual void      DrawCoG();
+   virtual void      DrawCoG2();
+   virtual void      DrawCathCor();
+   
+   virtual void      DrawTitle(Option_t *option="");
+   virtual void      DrawView(Float_t theta, Float_t phi, Float_t psi=0);
+   virtual void      ExecuteEvent(Int_t event, Int_t px, Int_t py);
+   Int_t             GetZoomMode() {return fZoomMode;}
+   Int_t             GetLayer() {return fLayer;}
+   Int_t             GetLadder() {return fLadder;}
+   Int_t             GetDetector() {return fDetector;}
+   Int_t             GetModule() {return fModule;}
+   Int_t             GetEvent() {return fEvent;}
+   Float_t           GetYmodule() {return fYmodule;}
+   Bool_t            GetDrawHistOpt() {return fDrawHist;}
+   AliITSMapA2      *GetMap() {return fMap;}
+   void              GetPadCxy(Int_t,Int_t,Float_t *,Float_t *);
+   void              GetPadIxy(Int_t &,Int_t &,Float_t,Float_t);
+   virtual void      LoadDigits(Int_t module);
+   virtual void      LoadHits(Int_t module);
+   virtual void      LoadCoG(Int_t chamber, Int_t cathode);
+   virtual void      LoadCoG2(Int_t chamber, Int_t cathode);
+   virtual void      LoadCathCor(Int_t chamber);
+   TPad             *Pad() {return fPad;}
+   TObjArray        *Points() {return fPoints;}
+   TObjArray        *Phits() {return fPhits;}
+   TObjArray        *Rpoints() {return fRpoints;}
+   TObjArray        *R2points() {return fR2points;}
+   TObjArray        *Cpoints() {return fCpoints;}
+   virtual void      Paint(Option_t *option="");
+   virtual void      SetModule(Int_t layer=1, Int_t ladder=1, Int_t detector=1); // *MENU*
+   virtual void      SetModuleNumber(Int_t module=393); // *MENU*
+   virtual void      SetParticle(Int_t code=-211) {fPdgParticle=code;}// *MENU*
+   virtual void      SetParent(Int_t code=0) {fPdgParent=code;}// *MENU* 
+   virtual void      SetEvent(Int_t newevent=0); // *MENU*   
+   virtual void      SetDrawHist(Bool_t draw=kFALSE) {fDrawHist=draw;}   // *MENU*
+   virtual void      SetDrawClusters(Bool_t draw=kTRUE) {fDrawClusters=draw;}   // *MENU*
+   virtual void      SetDrawCoG(Bool_t draw=kTRUE) {fDrawCoG=draw;}   // *MENU*
+   virtual void      SetDrawCathCor(Bool_t draw=kFALSE) {fDrawCathCor=draw;} // *MENU*
+   virtual void      SetRange(Float_t rrange=250., Float_t zrange=1050.); // *MENU*
+   virtual void      SetView(Float_t theta=-90, Float_t phi=90, Float_t psi=180); // *MENU* 
+   virtual void      SetPickMode();
+   virtual void      SetZoomMode();
+   virtual void      ShowNextEvent(Int_t delta=1);
+   virtual void      UnZoom(); // *MENU*
+   virtual void      DrawHistograms();
+   virtual void      NextModule(Int_t delta=1);
+   virtual void      ResetPoints();
+   virtual void      ResetPhits();
+   virtual void      ResetRpoints();
+   virtual void      ResetR2points();
+   virtual void      ResetCpoints();
+
+   ClassDef(AliITSdisplay, 0)   //Utility class to display ITS clusters...
+};
+
+#endif
index 865c62d..b28e796 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-Revision 1.1.2.2  2000/06/12 18:09:36  barbera
-fixed posible compilation errors on HP unix
-
-Revision 1.1.2.1  2000/01/12 20:21:30  nilsen
-missed AliITSetfSDD files ealier
-
-$Name$
-$Author$
-$Id$
-*/
-
 #include <iostream.h>
 #include <TMath.h>
 #include "AliITSetfSDD.h"
@@ -35,70 +22,57 @@ $Id$
 // Written by Piergiorgio Cerello
 // November 23 1999
 //
-// AliITSmapSDD is the map of SDDs.
-//
-//Begin_Html
-/*
-<img src="picts/ITS/AliITShit_Class_Diagram.gif">
-</pre>
-<br clear=left>
-<font size=+2 color=red>
-<p>This show the relasionships between the ITS hit class and the rest of Aliroot.
-</font>
-<pre>
-*/
-//End_Htm
-//extern Int_t power(Int_t b, Int_t e);
-
 //_____________________________________________________________________________
 ClassImp(AliITSetfSDD)
 
 Int_t ppower(Int_t b, Int_t e) {
-  Int_t power = 1,i;
-  for(i=0; i<e; i++) power *= b;
+  Int_t power = 1;
+  for(Int_t i=0; i<e; i++) power *= b;
   return power;
 }
 
-AliITSetfSDD::AliITSetfSDD(Double_t timeclock)
+AliITSetfSDD::AliITSetfSDD(Double_t timestep)
 {
   // sampling time in ns
-  fSamplingTime = 1000./timeclock;
+
+  fSamplingTime = timestep;
+
   fT0 = 0.;
-  fDf = ppower(10,9)/(fMaxNofSamples*fSamplingTime);
+  fDf = ppower(10,9)/(fkMaxNofSamples*fSamplingTime);
   fA0 = 9000.;
 
-  Int_t i,j,k;
-  for(i=0; i<fMaxNofPoles; i++) {
-    fZero_M[i] = 0.;
-    fZero_R[i] = 0.;
-    fZero_I[i] = 0.;
-    fPole_M[i] = 0.;
-    fPole_R[i] = 0.;
-    fPole_I[i] = 0.;
+  Int_t i,j;
+  for(i=0; i<fkMaxNofPoles; i++) {
+    fZeroM[i] = 0.;
+    fZeroR[i] = 0.;
+    fZeroI[i] = 0.;
+    fPoleM[i] = 0.;
+    fPoleR[i] = 0.;
+    fPoleI[i] = 0.;
   }
-  fPole_M[0] = 1.;
-  fPole_R[0] = -2100000.;
-  fPole_I[0] = fPole_R[0];
-  fPole_M[1] = 1.;
-  fPole_R[1] = -2100000.;
-  fPole_I[1] = -fPole_R[1];
+  fPoleM[0] = 1.;
+  fPoleR[0] = -2100000.;
+  fPoleI[0] = fPoleR[0];
+  fPoleM[1] = 1.;
+  fPoleR[1] = -2100000.;
+  fPoleI[1] = -fPoleR[1];
 
    // Compute Transfer Function
 
   Double_t PI = acos(-1.);
-  for(i=0; i<=fMaxNofSamples/2; i++) {
+  for(i=0; i<=fkMaxNofSamples/2; i++) {
     Double_t frequency = fDf*i;
     Double_t VM = fA0;
     Double_t VA = 0.;
-    for(k=0; k<fMaxNofPoles; k++) {
-      if(fZero_M[k]) {
-        Double_t VZR = -fZero_R[k];
-        Double_t VZI = frequency - fZero_I[k];
+    for(Int_t k=0; k<fkMaxNofPoles; k++) {
+      if(fZeroM[k]) {
+        Double_t VZR = -fZeroR[k];
+        Double_t VZI = frequency - fZeroI[k];
         Double_t VZM = TMath::Sqrt(VZR*VZR+VZI*VZI);
         Double_t VZA = TMath::ATan2(VZI,VZR);
        //      cout << "VZM: " << VZM << ", VZA: " << VZA << endl;
        //      cout << "VZR: " << VZR << ", VZI: " << VZI << endl;
-        for(j=1; j<= (Int_t) fZero_M[k]; j++) {
+        for(j=1; j<= (Int_t) fZeroM[k]; j++) {
           VM *= VZM;
           VA += VZA;
           if(VA >= PI) VA -= (2.*PI);
@@ -107,14 +81,14 @@ AliITSetfSDD::AliITSetfSDD(Double_t timeclock)
         }
       }
 
-      if(fPole_M[k]) {
-        Double_t VPR = -fPole_R[k];
-        Double_t VPI = frequency - fPole_I[k];
+      if(fPoleM[k]) {
+        Double_t VPR = -fPoleR[k];
+        Double_t VPI = frequency - fPoleI[k];
        Double_t VPM = TMath::Sqrt(VPR*VPR+VPI*VPI);
        Double_t VPA = TMath::ATan2(VPI,VPR);
        //cout << "VPM: " << VPM << ", VPA: " << VPA << endl;
        //cout << "VPR: " << VPR << ", VPI: " << VPI << endl;
-        for(j=1; j<= (Int_t) fPole_M[k]; j++) {
+        for(j=1; j<= (Int_t) fPoleM[k]; j++) {
           VM /= VPM;
           VA -= VPA;
           if(VA >= PI) VA -= (2.*PI);
@@ -126,64 +100,64 @@ AliITSetfSDD::AliITSetfSDD(Double_t timeclock)
       Double_t VI = VM*sin(VA);
       //cout << "VM: " << VM << ", VA: " << VA << endl;
       //cout << "VR: " << VR << ", VI: " << VI << endl;
-      fTf_R[i] = VR*ppower(10,9);
-      fTf_I[i] = VI*ppower(10,9);
-      //cout << "fTf_R[" << i << "] = " << fTf_R[i] << endl;
-      //cout << "fTf_I[" << i << "] = " << fTf_I[i] << endl;
+      fTfR[i] = VR*ppower(10,9);
+      fTfI[i] = VI*ppower(10,9);
+      //cout << "fTfR[" << i << "] = " << fTfR[i] << endl;
+      //cout << "fTfI[" << i << "] = " << fTfI[i] << endl;
       if(i) {
-        fTf_R[fMaxNofSamples-i] = fTf_R[i];
-        fTf_I[fMaxNofSamples-i] = -fTf_I[i];
+        fTfR[fkMaxNofSamples-i] = fTfR[i];
+        fTfI[fkMaxNofSamples-i] = -fTfI[i];
       }
     }
   }
   
   // Compute Fourier Weights
 
-  for(i=0; i<=fMaxNofSamples/2; i++) {
-    fW_R[i] = cos(-2.*PI*i/fMaxNofSamples);
-    fW_I[i] = sin(-2.*PI*i/fMaxNofSamples);
+  for(i=0; i<=fkMaxNofSamples/2; i++) {
+    fWR[i] = cos(-2.*PI*i/fkMaxNofSamples);
+    fWI[i] = sin(-2.*PI*i/fkMaxNofSamples);
     if(i) {
-      fW_R[fMaxNofSamples-i] = fW_R[i];
-      fW_I[fMaxNofSamples-i] = -fW_I[i];
+      fWR[fkMaxNofSamples-i] = fWR[i];
+      fWI[fkMaxNofSamples-i] = -fWI[i];
     }
   }
 
 }
 
-void AliITSetfSDD::Print()
+void AliITSetfSDD::PrintElectronics()
 {
-  Int_t i;
   cout << "Sampling Time " << fSamplingTime << endl;
-  cout << "Number of Time Samples " << fMaxNofSamples << endl;
+  cout << "Number of Time Samples " << fkMaxNofSamples << endl;
   cout << "fT0 " << fT0 << endl;
   cout << "fDf " << fDf << endl;
   cout << "fA0 " << fA0 << endl;
 
   cout << "Zero's and Pole's" << endl;
-  cout << "fZero_M " << endl;
-  for(i=0; i<fMaxNofPoles; i++) cout << fZero_M[i] << endl;
+  cout << "fZeroM " << endl;
+  Int_t i;
+  for(i=0; i<fkMaxNofPoles; i++) cout << fZeroM[i] << endl;
   cout << "fZero_R " << endl;
-  for(i=0; i<fMaxNofPoles; i++) cout << fZero_R[i] << endl;
-  cout << "fZero_I " << endl;
-  for(i=0; i<fMaxNofPoles; i++) cout << fZero_I[i] << endl;
-  cout << "fPole_M " << endl;
-  for(i=0; i<fMaxNofPoles; i++) cout << fPole_M[i] << endl;
-  cout << "fPole_R " << endl;
-  for(i=0; i<fMaxNofPoles; i++) cout << fPole_R[i] << endl;
-  cout << "fPole_I " << endl;
-  for(i=0; i<fMaxNofPoles; i++) cout << fPole_I[i] << endl;
+  for(i=0; i<fkMaxNofPoles; i++) cout << fZeroR[i] << endl;
+  cout << "fZeroI " << endl;
+  for(i=0; i<fkMaxNofPoles; i++) cout << fZeroI[i] << endl;
+  cout << "fPoleM " << endl;
+  for(i=0; i<fkMaxNofPoles; i++) cout << fPoleM[i] << endl;
+  cout << "fPoleR " << endl;
+  for(i=0; i<fkMaxNofPoles; i++) cout << fPoleR[i] << endl;
+  cout << "fPoleI " << endl;
+  for(i=0; i<fkMaxNofPoles; i++) cout << fPoleI[i] << endl;
 
   cout << "Transfer function" << endl;
   cout << "Real Part" << endl;
-  for(i=0; i<fMaxNofSamples; i++) cout << fTf_R[i] << endl;
+  for(i=0; i<fkMaxNofSamples; i++) cout << fTfR[i] << endl;
   cout << "Imaginary Part " << endl;
-  for(i=0; i<fMaxNofSamples; i++) cout << fTf_I[i] << endl;
+  for(i=0; i<fkMaxNofSamples; i++) cout << fTfI[i] << endl;
 
   cout << "Fourier Weights" << endl;
   cout << "Real Part" << endl;
-  for(i=0; i<fMaxNofSamples; i++) cout << fW_R[i] << endl;
+  for(i=0; i<fkMaxNofSamples; i++) cout << fWR[i] << endl;
   cout << "Imaginary Part " << endl;
-  for(i=0; i<fMaxNofSamples; i++) cout << fW_I[i] << endl;
+  for(i=0; i<fkMaxNofSamples; i++) cout << fWI[i] << endl;
 }
 
 
index 5c618ac..d60c091 100644 (file)
@@ -14,42 +14,40 @@ class AliITSetfSDD : public TObject {
 //
 // AliITSetfSDD is the class describing the electronics for the ITS SDDs. 
 //
-// Data members:
-//
 ////////////////////////////////////////////////////////////////////////
+  
+ public:
+    
+  AliITSetfSDD() {};                 // default constructor
+  AliITSetfSDD(Double_t timestep);
+  ~AliITSetfSDD() {;}  
+  Double_t GetWeightReal(Int_t n) { return fWR[n]; }
+  Double_t GetWeightImag(Int_t n) { return fWI[n]; }
+  Double_t GetTraFunReal(Int_t n) { return fTfR[n]; }
+  Double_t GetTraFunImag(Int_t n) { return fTfI[n]; }
+  Int_t GetSamples() { return fkMaxNofSamples; }
+  void PrintElectronics();          // Print Electronics parameters  
 
  private:
+
+  static const Int_t fkMaxNofPoles = 5;
+  static const Int_t fkMaxNofSamples = 1024;
   
   Double_t fSamplingTime;      //
   Double_t fT0;                //
   Double_t fDf;                //
   Double_t fA0;                //
-  static const Int_t fMaxNofPoles = 5;
-  Double_t fZero_M[fMaxNofPoles];  // 
-  Double_t fZero_R[fMaxNofPoles];  // 
-  Double_t fZero_I[fMaxNofPoles];  // 
-  Double_t fPole_M[fMaxNofPoles];  // 
-  Double_t fPole_R[fMaxNofPoles];  // 
-  Double_t fPole_I[fMaxNofPoles];  // 
-  static const Int_t fMaxNofSamples = 256;
-  Double_t fTf_R[fMaxNofSamples];     // Transfer function (real part)
-  Double_t fTf_I[fMaxNofSamples];     // Transfer function (imaginary part)
-  Double_t fW_R[fMaxNofSamples];     // Fourier Weights (real part)
-  Double_t fW_I[fMaxNofSamples];     // Fourier Weights (imaginary part)
-  
- public:
-    
-  AliITSetfSDD() {};                 // default constructor
-  AliITSetfSDD(Double_t);
-  ~AliITSetfSDD() {;}  
-  Double_t GetWeightReal(Int_t n) { return fW_R[n]; }
-  Double_t GetWeightImag(Int_t n) { return fW_I[n]; }
-  Double_t GetTraFunReal(Int_t n) { return fTf_R[n]; }
-  Double_t GetTraFunImag(Int_t n) { return fTf_I[n]; }
-  Int_t GetSamples() { return fMaxNofSamples; }
-  void Print();          // Print Electronics parameters  
+  Double_t fZeroM[fkMaxNofPoles];  // 
+  Double_t fZeroR[fkMaxNofPoles];  // 
+  Double_t fZeroI[fkMaxNofPoles];  // 
+  Double_t fPoleM[fkMaxNofPoles];  // 
+  Double_t fPoleR[fkMaxNofPoles];  // 
+  Double_t fPoleI[fkMaxNofPoles];  // 
+  Double_t fTfR[fkMaxNofSamples];     // Transfer function (real part)
+  Double_t fTfI[fkMaxNofSamples];     // Transfer function (imaginary part)
+  Double_t fWR[fkMaxNofSamples];     // Fourier Weights (real part)
+  Double_t fWI[fkMaxNofSamples];     // Fourier Weights (imaginary part)
   
-  friend class AliITSmapSDD;
   ClassDef(AliITSetfSDD,1)  // Class for SDD electornics
     };
     
index cb1ef81..2b72c54 100644 (file)
 
 /*
 $Log$
-Revision 1.4.4.10  2000/06/12 18:09:49  barbera
-fixed posible compilation errors on HP unix
-
-Revision 1.4.4.9  2000/06/11 20:29:22  barbera
-Minore modifications.
-
 Revision 1.4.4.5  2000/03/04 23:42:39  nilsen
 Updated the comments/documentations and improved the maintainability of the
 code.
@@ -241,32 +235,32 @@ pixel coordinate system.
 // Int_t GetStartSPD()
 //     This functions returns the starting module index number for the
 // silicon pixels detectors (SPD). Typically this is zero. To loop over all
-// of the pixel detectors do: for(i=GetStartSPD();i<=GetLastSPD();i++)
+// of the pixel detectors do: for(Int_t i=GetStartSPD();i<=GetLastSPD();i++)
 //
 // Int_t GetLastSPD()
 //     This functions returns the last module index number for the
 // silicon pixels detectors (SPD). To loop over all of the pixel detectors 
-// do: for(i=GetStartSPD();i<=GetLastSPD();i++)
+// do: for(Int_t i=GetStartSPD();i<=GetLastSPD();i++)
 //
 // Int_t GetStartSDD()
 //     This functions returns the starting module index number for the
 // silicon drift detectors (SDD). To loop over all of the drift detectors 
-// do: for(i=GetStartSDD();i<=GetLastSDD();i++)
+// do: for(Int_t i=GetStartSDD();i<=GetLastSDD();i++)
 //
 // Int_t GetLastSDD()
 //     This functions returns the last module index number for the
 // silicon drift detectors (SDD). To loop over all of the drift detectors 
-// do: for(i=GetStartSDD();i<=GetLastSDD();i++)
+// do: for(Int_t i=GetStartSDD();i<=GetLastSDD();i++)
 //
 // Int_t GetStartSSD()
 //     This functions returns the starting module index number for the
 // silicon strip detectors (SSD). To loop over all of the strip detectors 
-// do: for(i=GetStartSSD();i<=GetLastSSD();i++)
+// do: for(Int_t i=GetStartSSD();i<=GetLastSSD();i++)
 //
 // Int_t GetStartSSD()
 //     This functions returns the last module index number for the
 // silicon strip detectors (SSD). To loop over all of the strip detectors 
-// do: for(i=GetStartSSD();i<=GetLastSSD();i++)
+// do: for(Int_t i=GetStartSSD();i<=GetLastSSD();i++)
 //
 // TObject *GetShape(Int_t lay,Int_t lad,Int_t det)
 //     This functions returns the shape object AliITSgeomSPD, AliITSgeomSDD,
@@ -277,9 +271,10 @@ pixel coordinate system.
 ////////////////////////////////////////////////////////////////////////
 
 #include <iostream.h>
-#include <fstream.h>
 #include <iomanip.h>
 #include <stdio.h>
+
+
 #include "AliITSgeom.h"
 #include "AliITSgeomSPD300.h"
 #include "AliITSgeomSPD425.h"
@@ -314,9 +309,8 @@ AliITSgeom::~AliITSgeom(){
 ////////////////////////////////////////////////////////////////////////
   // Default destructor.
   // if arrays exist delete them. Then set everything to zero.
-   Int_t i;
    if(fGm!=0){
-      for(i=0;i<fNlayers;i++) delete[] fGm[i];
+      for(Int_t i=0;i<fNlayers;i++) delete[] fGm[i];
       delete[] fGm;
    } // end if fGm!=0
    if(fNlad!=0) delete[] fNlad;
@@ -340,6 +334,7 @@ AliITSgeom::AliITSgeom(const char *filename){
    Int_t    l,a,d;
    Float_t  x,y,z,o,p,q,r,s,t;
    Double_t oor,pr,qr,rr,sr,tr; // Radians
+   Double_t ppr,rrr;       // Added by S. Vanadia for tracking rotation matrix;
    Double_t lr[9];
    Double_t si; // sin(angle)
    Double_t pi = TMath::Pi(), byPI = pi/180.;
@@ -392,6 +387,17 @@ AliITSgeom::AliITSgeom(const char *filename){
       i = d + a*fNdet[l]; // position of this detector
       g = &(fGm[l][i]);
 
+      //part coming from the tracking
+      g->angles[0] = o;        // Added 25-05-00 S. Vanadia
+      g->angles[1] = p;
+      g->angles[2] = q;
+      g->angles[3] = r;
+      g->angles[4] = s;
+      g->angles[5] = t;
+      //printf("angles from file: %f %f %f %f %f %f\n",o,p,q,r,s,t);
+      //printf("constructor angles: %f %f %f %f %f %f\n", g->angles[0], g->angles[1], g->angles[2], g->angles[3], g->angles[4], g->angles[5]);
+      // end part coming from tracking
+
       oor = byPI*o;
       pr = byPI*p;
       qr = byPI*q;
@@ -399,6 +405,29 @@ AliITSgeom::AliITSgeom(const char *filename){
       sr = byPI*s;
       tr = byPI*t;
 
+      // Tracking rotation matrix 25-5-2000
+      if (l==0) { 
+                  ppr = (Double_t)(p+90.0)*byPI;
+                  rrr = (Double_t)(r+90.0)*byPI; 
+               }
+          else { 
+                 ppr = (Double_t)(p-90.0)*byPI;
+                 rrr = (Double_t)(r-90.0)*byPI;
+               }
+                
+
+      g->rottrack[0][0]=TMath::Sin(oor)*TMath::Cos(ppr);
+      g->rottrack[1][0]=TMath::Sin(oor)*TMath::Sin(ppr);
+      g->rottrack[2][0]=TMath::Cos(oor);
+      g->rottrack[0][1]=TMath::Sin(qr)*TMath::Cos(rrr);
+      g->rottrack[1][1]=TMath::Sin(qr)*TMath::Sin(rrr);
+      g->rottrack[2][1]=TMath::Cos(qr);
+      g->rottrack[0][2]=TMath::Sin(sr)*TMath::Cos(tr);
+      g->rottrack[1][2]=TMath::Sin(sr)*TMath::Sin(tr);
+      g->rottrack[2][2]=TMath::Cos(sr);
+      // End tracking rotation matrix
+
+
       g->fx0   = x;
       g->fy0   = y;
       g->fz0   = z;
@@ -516,6 +545,7 @@ AliITSgeom& AliITSgeom::operator=(const AliITSgeom &source){
 // class is then modified by introducing some misalignment.
 ////////////////////////////////////////////////////////////////////////
    Int_t i,j,k;
+   Int_t ii,jj;
 
    if(this == &source) return *this; // don't assign to ones self.
 
@@ -544,12 +574,72 @@ AliITSgeom& AliITSgeom::operator=(const AliITSgeom &source){
          fGm[i][j].frx = source.fGm[i][j].frx;
          fGm[i][j].fry = source.fGm[i][j].fry;
          fGm[i][j].frz = source.fGm[i][j].frz;
+
+         fGm[i][j].angles[0] = source.fGm[i][j].angles[0];     // Added S.Vanadia
+         fGm[i][j].angles[1] = source.fGm[i][j].angles[1];
+         fGm[i][j].angles[2] = source.fGm[i][j].angles[2];
+         fGm[i][j].angles[3] = source.fGm[i][j].angles[3];
+         fGm[i][j].angles[4] = source.fGm[i][j].angles[4];
+         fGm[i][j].angles[5] = source.fGm[i][j].angles[5];
+
          for(k=0;k<9;k++) fGm[i][j].fr[k] = source.fGm[i][j].fr[k];
+         for (ii=0;ii<3;ii++)                                  // Added S. Vanadia
+            for (jj=0;jj<3;jj++)
+                fGm[i][j].rottrack[ii][jj] = source.fGm[i][j].rottrack[ii][jj];
       } // end for j
    } // end for i
    return *this;
 }
 //________________________________________________________________________
+void AliITSgeom::GtoLtracking(Int_t lay,Int_t lad,Int_t det,
+                              const Double_t *g,Double_t *l){
+////////////////////////////////////////////////////////////////////////
+// Added by S. Vanadia 25-5-2000
+////////////////////////////////////////////////////////////////////////
+   Double_t x,y,z;
+   AliITSgeomS *gl;
+   
+   lay--;lad--;det--;  
+   
+   gl = &(fGm[lay][fNdet[lay]*lad+det]);
+       
+   x    = g[0] - gl->fx0;
+   y    = g[1] - gl->fy0;
+   z    = g[2] - gl->fz0;
+   
+   l[0] = gl->rottrack[0][0]*x + gl->rottrack[1][0]*y + gl->rottrack[2][0]*z;
+   l[1] = gl->rottrack[0][1]*x + gl->rottrack[1][1]*y + gl->rottrack[2][1]*z;
+   l[2] = gl->rottrack[0][2]*x + gl->rottrack[1][2]*y + gl->rottrack[2][2]*z;
+       
+   return;
+}
+//________________________________________________________________________
+void AliITSgeom::LtoGtracking(Int_t lay,Int_t lad,Int_t det,
+                              const Double_t *l,Double_t *g){
+////////////////////////////////////////////////////////////////////////
+// Added by S. Vanadia 25-5-2000
+////////////////////////////////////////////////////////////////////////
+
+   Double_t xx,yy,zz;
+   AliITSgeomS *gl;
+   
+   lay--;lad--;det--;  
+   
+   gl = &(fGm[lay][fNdet[lay]*lad+det]);
+  
+   xx    = gl->rottrack[0][0]*l[0] + gl->rottrack[0][1]*l[1] + gl->rottrack[0][2]*l[2];
+   yy    = gl->rottrack[1][0]*l[0] + gl->rottrack[1][1]*l[1] + gl->rottrack[1][2]*l[2];
+   zz    = gl->rottrack[2][0]*l[0] + gl->rottrack[2][1]*l[1] + gl->rottrack[2][2]*l[2];
+
+
+   g[0] = xx + gl->fx0;
+   g[1] = yy + gl->fy0;
+   g[2] = zz + gl->fz0;
+      
+
+   return;
+}
+//________________________________________________________________________
 void AliITSgeom::GtoL(Int_t lay,Int_t lad,Int_t det,
                        const Double_t *g,Double_t *l){
 ////////////////////////////////////////////////////////////////////////
@@ -1274,6 +1364,7 @@ ofstream & AliITSgeom::PrintGeom(ofstream &lRb){
 ////////////////////////////////////////////////////////////////////////
    // Stream an object of class AliITSgeom.
     Int_t i,j,k;
+    Int_t ii, jj;
 
     lRb.setf(ios::scientific);
     lRb << fNlayers << " ";
@@ -1287,8 +1378,17 @@ ofstream & AliITSgeom::PrintGeom(ofstream &lRb){
        lRb <<setprecision(16) << fGm[i][j].frx << " ";
        lRb <<setprecision(16) << fGm[i][j].fry << " ";
        lRb <<setprecision(16) << fGm[i][j].frz << "\n";
+       lRb <<setprecision(32) << fGm[i][j].angles[0] << " ";
+       lRb <<setprecision(32) << fGm[i][j].angles[1] << " ";
+       lRb <<setprecision(32) << fGm[i][j].angles[2] << " ";
+       lRb <<setprecision(32) << fGm[i][j].angles[3] << " ";
+       lRb <<setprecision(32) << fGm[i][j].angles[4] << " ";
+       lRb <<setprecision(32) << fGm[i][j].angles[5] << "\n";
        for(k=0;k<9;k++) lRb <<setprecision(16) << fGm[i][j].fr[k] << " ";
        lRb << "\n";
+       for (ii=0;ii<3;ii++)                                    // Added S. Vanadia
+            for (jj=0;jj<3;jj++)
+                lRb <<setprecision(64) << fGm[i][j].rottrack[ii][jj] << " ";
       } // end for i,j
 //      lRb << fShape;
       return lRb;
@@ -1305,6 +1405,7 @@ ifstream & AliITSgeom::ReadGeom(ifstream &lRb){
 ////////////////////////////////////////////////////////////////////////
    // Stream an object of class AliITSgeom.
     Int_t i,j,k;
+    Int_t ii, jj;
 
       lRb >> fNlayers;
       if(fNlad!=0) delete[] fNlad;
@@ -1328,7 +1429,16 @@ ifstream & AliITSgeom::ReadGeom(ifstream &lRb){
              lRb >> fGm[i][j].frx;
              lRb >> fGm[i][j].fry;
              lRb >> fGm[i][j].frz;
+             lRb >> fGm[i][j].angles[0];
+             lRb >> fGm[i][j].angles[1];
+             lRb >> fGm[i][j].angles[2];
+             lRb >> fGm[i][j].angles[3];
+             lRb >> fGm[i][j].angles[4];
+             lRb >> fGm[i][j].angles[5];
              for(k=0;k<9;k++) lRb >> fGm[i][j].fr[k];
+             for (ii=0;ii<3;ii++)                                      // Added S. Vanadia
+               for (jj=0;jj<3;jj++)
+                 lRb >> fGm[i][j].rottrack[ii][jj];
          } // end for j
       } // end for i
 //      lRb >> fShape;
@@ -1692,28 +1802,29 @@ void AliITSgeom::Streamer(TBuffer &lRb){
 ////////////////////////////////////////////////////////////////////////
    // Stream an object of class AliITSgeom.
     Int_t i,j,k,n;
+    Int_t ii,jj;
 
 
-    //   printf("AliITSgeomStreamer starting\n");
+    //printf("AliITSgeomStreamer starting\n");
    if (lRb.IsReading()) {
       Version_t lRv = lRb.ReadVersion(); if (lRv) { }
       TObject::Streamer(lRb);
-//      printf("AliITSgeomStreamer reading fNlayers\n");
+      //printf("AliITSgeomStreamer reading fNlayers\n");
       lRb >> fNlayers;
       if(fNlad!=0) delete[] fNlad;
       if(fNdet!=0) delete[] fNdet;
       fNlad = new Int_t[fNlayers];
       fNdet = new Int_t[fNlayers];
-//      printf("AliITSgeomStreamer fNlad\n");
+      //printf("AliITSgeomStreamer fNlad\n");
       for(i=0;i<fNlayers;i++) lRb >> fNlad[i];
-//      printf("AliITSgeomStreamer fNdet\n");
+      //printf("AliITSgeomStreamer fNdet\n");
       for(i=0;i<fNlayers;i++) lRb >> fNdet[i];
       if(fGm!=0){
          for(i=0;i<fNlayers;i++) delete[] fGm[i];
          delete[] fGm;
       } // end if fGm!=0
       fGm = new AliITSgeomS*[fNlayers];
-//      printf("AliITSgeomStreamer AliITSgeomS\n");
+      // printf("AliITSgeomStreamer AliITSgeomS\n");
       for(i=0;i<fNlayers;i++){
          n     = fNlad[i]*fNdet[i];
          fGm[i] = new AliITSgeomS[n];
@@ -1725,7 +1836,16 @@ void AliITSgeom::Streamer(TBuffer &lRb){
              lRb >> fGm[i][j].frx;
              lRb >> fGm[i][j].fry;
              lRb >> fGm[i][j].frz;
+             lRb >> fGm[i][j].angles[0];
+             lRb >> fGm[i][j].angles[1];
+             lRb >> fGm[i][j].angles[2];
+             lRb >> fGm[i][j].angles[3];
+             lRb >> fGm[i][j].angles[4];
+             lRb >> fGm[i][j].angles[5];
              for(k=0;k<9;k++) lRb >> fGm[i][j].fr[k];
+             for (ii=0;ii<3;ii++)                    // Added S. Vanadia
+                for (jj=0;jj<3;jj++)
+                    lRb >> fGm[i][j].rottrack[ii][jj];
          } // end for j
       } // end for i
       /*
@@ -1750,10 +1870,19 @@ void AliITSgeom::Streamer(TBuffer &lRb){
          lRb << fGm[i][j].frx;
          lRb << fGm[i][j].fry;
          lRb << fGm[i][j].frz;
+         lRb << fGm[i][j].angles[0];
+         lRb << fGm[i][j].angles[1];
+         lRb << fGm[i][j].angles[2];
+         lRb << fGm[i][j].angles[3];
+         lRb << fGm[i][j].angles[4];
+         lRb << fGm[i][j].angles[5];
          for(k=0;k<9;k++) lRb << fGm[i][j].fr[k];
+         for (ii=0;ii<3;ii++)                                  // Added S. Vanadia
+            for (jj=0;jj<3;jj++)
+                lRb << fGm[i][j].rottrack[ii][jj];
       } // end for i,j
       // lRb << fShape;
       //if (fShape) fShape->Streamer(lRb);
    } // end if reading
-   //   printf("AliITSgeomStreamer Finished\n");
+   //printf("AliITSgeomStreamer Finished\n");
 }
index 6456bb1..77a2f81 100644 (file)
@@ -18,7 +18,9 @@
 // a specialized structure for ease of implementation.
 /////////////////////////////////////////////////////////////////////////
 #include <fstream.h>
-#include "TObjArray.h"
+#include <TObjArray.h>
+#include <TVector.h>
+
 #include "AliITSgeomSPD.h"
 #include "AliITSgeomSDD.h"
 #include "AliITSgeomSSD.h"
@@ -29,6 +31,8 @@ struct AliITSgeomS {
     Float_t fx0,fy0,fz0; // Translation vector
     Float_t frx,fry,frz; // Rotation about axis, angle radians
     Float_t fr[9];       // the rotation matrix
+    Float_t angles[6];   // module center, theta and phi
+    Double_t rottrack[3][3]; // the tracking rotation matrix
 };
 
 //_______________________________________________________________________
@@ -137,6 +141,21 @@ class AliITSgeom : public TObject {
     // global coordinate system to the local coordinate system used to do
     // tracking.
 
+    void GtoLtracking(Int_t lay,Int_t lad,Int_t det,const Double_t *g,Double_t *l);
+    void LtoGtracking(Int_t lay,Int_t lad,Int_t det,const Double_t *l,Double_t *g);
+    void GetCenterThetaPhi(Int_t lay,Int_t lad,Int_t det, TVector &x) const {
+                       x(0) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fx0;
+                      x(1) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fy0;
+                      x(2) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].fz0;                                                
+                      x(3) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].angles[0];
+                      x(4) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].angles[1];
+                      x(5) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].angles[2];
+                      x(6) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].angles[3];
+                      x(7) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].angles[4];
+                      x(8) = fGm[lay-1][fNdet[lay-1]*(lad-1)+det-1].angles[5];
+
+}
+
  private:
     Int_t        fNlayers; // The number of layers.
     Int_t        *fNlad;   // Array of the number of ladders/layer(layer)
index 8c41da6..8427227 100644 (file)
@@ -15,9 +15,6 @@
 
 /*
 $Log$
-Revision 1.2.4.6  2000/06/11 20:29:39  barbera
-Minore changes.
-
 Revision 1.2.4.2  2000/03/04 23:55:35  nilsen
 Fixed up comments/documentation.
 
index 1c2e001..ad25000 100644 (file)
@@ -7,9 +7,9 @@
 
 #include <TObject.h>
 #include "TBRIK.h"
-#include "AliITSgeom.h"
+//#include "AliITSgeom.h"
 
-// temporary 
+class AliITSgeom;
 
 class AliITSgeomSDD: public TObject {
  public:
index a920d9d..f919a62 100644 (file)
@@ -15,9 +15,6 @@
 
 /*
 $Log$
-Revision 1.2.4.5  2000/06/11 20:30:05  barbera
-Minore changes.
-
 Revision 1.3  2000/03/07 18:46:59  nilsen
 Merged form ITS-working to HEAD. Minor changes
 
index 19fc1f5..547f424 100644 (file)
 
 /*
 $Log$
-Revision 1.1.2.6  2000/06/12 18:10:03  barbera
-fixed posible compilation errors on HP unix
-
-Revision 1.1.2.5  2000/06/11 20:30:36  barbera
-Minore changes.
-
 Revision 1.4  2000/06/10 20:34:37  nilsen
 Fixed compilation warning with HP unix.
 
index 207ba84..d74cfd4 100644 (file)
 
 /*
 $Log$
-Revision 1.1.2.6  2000/06/12 18:10:18  barbera
-fixed posible compilation errors on HP unix
-
-Revision 1.1.2.5  2000/06/11 20:30:56  barbera
-Minore changes.
-
 Revision 1.4  2000/06/10 20:34:22  nilsen
 Fixed compilation warning with HP unix.
 
index 77b4c0d..30eaa0f 100644 (file)
@@ -15,9 +15,6 @@
 
 /*
 $Log$
-Revision 1.2.4.6  2000/06/11 20:30:21  barbera
-Minore changes.
-
 Revision 1.2.4.2  2000/03/04 23:55:59  nilsen
 Fixed up the comments/documentation
 
index 2b736b2..3e0a261 100644 (file)
@@ -7,8 +7,10 @@
 
 #include <TObject.h>
 #include "TBRIK.h"
-#include "AliITSgeom.h"
-// temporarily - to be able to compile the code
+//#include "AliITSgeom.h"
+
+
+class AliITSgeom;
 
 class AliITSgeomSSD: public TObject {
 
index 45a430a..342991a 100644 (file)
@@ -15,9 +15,6 @@
 
 /*
 $Log$
-Revision 1.3.4.4  2000/06/11 20:31:37  barbera
-Coding conventions update.
-
 Revision 1.3.4.2  2000/03/04 23:43:57  nilsen
 Fixed up the comments/documentation.
 
index 51a6423..16c7491 100644 (file)
@@ -8,7 +8,6 @@
 #include "AliDetector.h"
 #include "TParticle.h"
 #include "AliHit.h" 
-#include "AliDigit.h"
 #include "AliITSgeom.h"
 
 
index 057851b..3891594 100644 (file)
 
 /*
 $Log$
-Revision 1.4  2000/06/12 23:49:02  nilsen
-New ITS code replacing the old structure and simulations code.
-
-Revision 1.3.4.4  2000/06/12 18:10:32  barbera
-fixed posible compilation errors on HP unix
-
-Revision 1.3.4.3  2000/06/11 20:34:20  barbera
-Update class for the new structures.
-
 Revision 1.3.4.2  2000/03/02 21:42:29  nilsen 
 Linked AliDetector::fDigit to AliITSmodule::fDigitsM and AliITS::fITSRecPoints
 to AliITSmodule::fRecPointsM. Renamed AliITSmodule::fPointsM to fRecPointsM.
@@ -46,11 +37,9 @@ Introduction of the Copyright and cvs Log
 
 */
 
-#include "AliITSmodule.h"
 
 #include "AliRun.h"
 #include "AliITS.h"
-#include "AliITShit.h"
 
 ClassImp(AliITSmodule)
 
@@ -92,9 +81,8 @@ AliITSmodule::~AliITSmodule() {
     // we must first destroy all of it's members.
 
     fIndex   = 0;
-    Int_t i;
     if(fHitsM){
-       for(i=0;i<fHitsM->GetEntriesFast();i++) 
+       for(Int_t i=0;i<fHitsM->GetEntriesFast();i++) 
            delete ((AliITShit *)(fHitsM->At(i)));
        // must delete each object in the TObjArray.
        delete fHitsM;
@@ -119,7 +107,7 @@ AliITSmodule& AliITSmodule::operator=(const AliITSmodule &source){
 ////////////////////////////////////////////////////////////////////////
   printf("AliITSmodule error: AliITSmodule class has not to be copied! Exit.\n");
   exit(1);
-  return *this;
+  return *this; // fake return neded on Sun
 } 
 
 //_________________________________________________________________________
@@ -129,19 +117,18 @@ AliITSmodule& AliITSmodule::operator=(const AliITSmodule &source){
 Int_t AliITSmodule::AddHit(AliITShit* hit,Int_t t,Int_t h) {
 // Hits management
 
-    Int_t i;
     fHitsM->AddLast(new AliITShit(*hit));
     Int_t fNhitsM = fHitsM->GetEntriesFast();
     if(fNhitsM-1>=fTrackIndex->GetSize()){ // need to expand the TArrayI
        TArrayI *p = new TArrayI(fNhitsM+64);
-       for(i=0;i<fTrackIndex->GetSize();i++) 
+       for(Int_t i=0;i<fTrackIndex->GetSize();i++) 
            (*p)[i] = fTrackIndex->At(i);
        delete fTrackIndex;
        fTrackIndex = p;
     } // end if
     if(fNhitsM-1>=fHitIndex->GetSize()){ // need to expand the TArrayI
        TArrayI *p = new TArrayI(fNhitsM+64);
-       for(i=0;i<fHitIndex->GetSize();i++) 
+       for(Int_t i=0;i<fHitIndex->GetSize();i++) 
            (*p)[i] = fHitIndex->At(i);
        delete fHitIndex;
        fHitIndex = p;
index 5c36f8f..e2214e8 100644 (file)
@@ -1,4 +1,8 @@
+#include <iostream.h>
+#include <TClonesArray.h>
+
 #include "AliITSpackageSSD.h"
+
 //************************************************
 //Piotr Krzysztof Skowronski
 //Warsaw University of Technology
@@ -75,12 +79,12 @@ AliITSpackageSSD::AliITSpackageSSD(const AliITSpackageSSD &package)
   fNclustersN= package.fNclustersN;
   fNclustersP= package.fNclustersP;
   
-  for(i =0; i<fNclustersN;i++)
+  for ( i =0; i<fNclustersN;i++)
     {
       fClusterNIndexes[i]= package.fClusterNIndexes[i]; 
     }
   
-  for(i =0; i<fNclustersP;i++)
+  for ( i =0; i<fNclustersP;i++)
     {
       fClusterPIndexes[i]= package.fClusterPIndexes[i]; 
     }
@@ -105,12 +109,12 @@ fClustersP = package.fClustersP;
 fNclustersN= package.fNclustersN;
 fNclustersP= package.fNclustersP;
 
-for(i =0; i<fNclustersN;i++)
+for ( i =0; i<fNclustersN;i++)
   {
     fClusterNIndexes[i]= package.fClusterNIndexes[i]; 
   }
 
-for(i =0; i<fNclustersP;i++)
+for ( i =0; i<fNclustersP;i++)
   {
     fClusterPIndexes[i]= package.fClusterPIndexes[i]; 
   }
@@ -189,7 +193,7 @@ AliITSpackageSSD::GetClusterWithOneCross
   {
     //index=ind;
     index =fNclustersP-1; 
-    side=SIDEP;
+    side=fgkSIDEP;
     return kTRUE;
   }
  
@@ -198,7 +202,7 @@ AliITSpackageSSD::GetClusterWithOneCross
   {
     //index=ind;
     index = fNclustersN-1;
-    side=SIDEN;
+    side=fgkSIDEN;
     return kTRUE;
   }
   
@@ -208,7 +212,7 @@ AliITSpackageSSD::GetClusterWithOneCross
   {
     //index=ind;
     index = 0;
-    side=SIDEP;
+    side=fgkSIDEP;
     return kTRUE;
   }
   
@@ -218,7 +222,7 @@ AliITSpackageSSD::GetClusterWithOneCross
   {
 //    index=ind;
     index = 0;  
-    side=SIDEN;
+    side=fgkSIDEN;
     return kTRUE;
   }
   
@@ -232,7 +236,7 @@ AliITSpackageSSD::GetClusterWithOneCross
 
 void AliITSpackageSSD::DelCluster(Int_t index, Bool_t side)
 {
-  if(side==SIDEP) DelPCluster(index); else DelNCluster(index);
+  if(side==fgkSIDEP) DelPCluster(index); else DelNCluster(index);
 }
 /*******************************************************/
 void AliITSpackageSSD::DelPCluster(Int_t index)
@@ -248,14 +252,14 @@ void AliITSpackageSSD::DelPCluster(Int_t index)
   AliITSclusterSSD *clToDel = GetPSideCluster(index); //cluster to be deleted
   Int_t ncr = clToDel->GetCrossNo();
   
-  for(i =0;i<ncr;i++)
+  for (i =0;i<ncr;i++)
    {
     idx = clToDel->GetCross(i);
     ((AliITSclusterSSD *)((*fClustersN)[idx])   )->DelCross(clToDelIdx);
    }
  
  
- for(i=index;i<fNclustersP-1;i++)
+ for (i=index;i<fNclustersP-1;i++)
   {
        (*fClusterPIndexes)[i]=(*fClusterPIndexes)[i+1];
   }
@@ -263,7 +267,7 @@ void AliITSpackageSSD::DelPCluster(Int_t index)
  if (debug) cout<<"Cluster P ("<<index<<") deleted\n";
 
 
- for(i=0;i<fNclustersN;i++)
+ for (i=0;i<fNclustersN;i++)
   {
     if ( (GetNSideCluster(i)->GetCrossNo())==0) DelNCluster(i);
   }
@@ -285,21 +289,21 @@ void AliITSpackageSSD::DelNCluster(Int_t index)
   AliITSclusterSSD *clToDel = GetNSideCluster(index); //cluster to be deleted
   Int_t ncr = clToDel->GetCrossNo();
   
-  for(i =0;i<ncr;i++)
+  for (i =0;i<ncr;i++)
    {
     idx = clToDel->GetCross(i);
     ((AliITSclusterSSD *)((*fClustersP)[idx])   )->DelCross(clToDelIdx);
    }
  
  
- for(i=index;i<fNclustersN-1;i++)
+ for (i=index;i<fNclustersN-1;i++)
   {
        (*fClusterNIndexes)[i]=(*fClusterNIndexes)[i+1];
   }
  fNclustersN--; 
  if (debug) cout<<"Cluster N ("<<index<<") deleted\n";
 
- for(i=0;i<fNclustersP;i++)
+ for (i=0;i<fNclustersP;i++)
   {
     if ( (GetPSideCluster(i)->GetCrossNo())==0) DelPCluster(i);
   }
@@ -329,7 +333,7 @@ void AliITSpackageSSD::DelPClusterOI(Int_t index)
     }
    else
     {
-     for(i=1;i<fNclustersP-1;i++)
+     for (i=1;i<fNclustersP-1;i++)
        {
          if( ((*fClusterPIndexes)[i])==index)
          {
@@ -368,7 +372,7 @@ void AliITSpackageSSD::DelNClusterOI(Int_t index)
     }
    else
     {
-     for(i=1;i<fNclustersN-1;i++)
+     for (i=1;i<fNclustersN-1;i++)
        {
          if( ((*fClusterNIndexes)[i])==index)
          {
@@ -387,7 +391,7 @@ void AliITSpackageSSD::DelNClusterOI(Int_t index)
 
 void AliITSpackageSSD::DelClusterOI(Int_t index, Bool_t side)
 {
- if (side == SIDEP)
+ if (side == fgkSIDEP)
   {    
     DelPClusterOI(index);
   } 
@@ -411,8 +415,7 @@ void  AliITSpackageSSD::GetAllCombinations(Int_t**array,Int_t &num,Int_t sizet)
   
   if (debug) PrintClusters();
 
-  Int_t i;
-  for(i=0;i<fNclustersP;i++)
+  for (Int_t i=0;i<fNclustersP;i++)
    {
      takenNcl[i]=-1;
    }
@@ -441,49 +444,31 @@ void  AliITSpackageSSD::MakeCombin
  //this cluster
  AliITSclusterSSD *cl=GetPSideCluster(np);
 
- //printf("np %d cl %p\n",np,cl);
-
  Int_t NC = cl->GetCrossNo();  //number of crosses for this cluster
  Int_t indcro;                 //index of given cluster on side N that 
                                // this cluster crosses with
    
- // printf("NC %d \n",NC);
-
-
  if (np == fNclustersP-1) {
-   //printf("if \n");
-   for(i=0;i<NC;i++) {
+   for (i=0;i<NC;i++) {
      indcro=cl->GetCross(i);
-     //printf("if: i indcro %d %d\n",i, indcro);
      if(IsFree(indcro,np,occup)) {
         occup[np]=indcro;
-       //printf("if- isFree: i np occup[np] %d %d %d\n",i,np,occup[np]);
         for(j=0;j<fNclustersP;j++)  
         {
-         //printf("if- for: j nu occup[j] %d %d %d\n",j, nu, occup[j]);
           if (nu<sizet) arr[nu][j]=occup[j];
           else {
-            //printf("MakeComb - exceeding array size! i j %d %d\n",i,j);
               continue;}
-          //printf("if- for: j nu arr[nu][j] %d %d %d\n",j, nu, arr[nu][j]);
-           
         }
       
         occup[np]=-1;
         if (nu<sizet-1) nu++;
-       //printf("i j nu %d %d %d \n",i,j,nu);
      }
    }
   } else {
-    // printf("else \n");
-
-    for(i=0;i<NC;i++) {
+    for (i=0;i<NC;i++) {
        indcro=cl->GetCross(i);
-       //printf("else: i indcro %d %d\n",i, indcro);
        if(IsFree(indcro,np,occup)) {
          occup[np]=indcro;
-         //printf("else:recursive call - i np occup %d %d %d\n",i,np,occup[np]);
          if (nu<sizet) MakeCombin(arr,nu,(np+1),occup,sizet);
          //else printf("MakeComb - exceeding array size!\n");
        }
@@ -497,8 +482,7 @@ void  AliITSpackageSSD::MakeCombin
 Bool_t  AliITSpackageSSD::IsFree(Int_t idx, Int_t nn, Int_t *lis)
 {
 
-  Int_t i;
-  for(i=0;i<nn;i++)
+  for (Int_t i=0;i<nn;i++)
     {
       if (lis[i]==idx) return kFALSE;
     }
@@ -511,10 +495,10 @@ void AliITSpackageSSD::PrintClusters()
 
 Int_t i,j;
 cout<<"SIDE P\n";
-for(i=0;i<fNclustersP;i++)
+for (i=0;i<fNclustersP;i++)
  {
    cout<<i<<".  IO="<<GetPSideClusterIdx(i)<<" NC="<<GetPSideCluster(i)->GetCrossNo()<<"     C. IDXs : ";
-   for(j=0;j<GetPSideCluster(i)->GetCrossNo();j++)
+   for (j=0;j<GetPSideCluster(i)->GetCrossNo();j++)
     {
       cout<<GetPSideCluster(i)->GetCross(j)<<" ";
     }
@@ -525,10 +509,10 @@ for(i=0;i<fNclustersP;i++)
  }
 
 cout <<"SIDE N\n";
-for(i=0;i<fNclustersN;i++)
+for (i=0;i<fNclustersN;i++)
  {
    cout<<i<<".  IO="<<GetNSideClusterIdx(i)<<" NC="<<GetNSideCluster(i)->GetCrossNo()<<"     C. IDXs : ";
-   for(j=0;j<GetNSideCluster(i)->GetCrossNo();j++)
+   for (j=0;j<GetNSideCluster(i)->GetCrossNo();j++)
     {
       cout<<GetNSideCluster(i)->GetCross(j)<<" ";
     }
@@ -563,8 +547,7 @@ Int_t AliITSpackageSSD::GetNextPIdx(Int_t OI)
 {
  //Returns index of next P cluster OI in package; OI == Original Inedx (in TClonesArray)
  //if not egsist return -1;
- Int_t i;
- for(i =0; i<fNclustersP-1;i++)
+ for (Int_t i =0; i<fNclustersP-1;i++)
   {
     if(GetPSideClusterIdx(i) == OI)
        return GetPSideClusterIdx(i+1);
@@ -577,8 +560,7 @@ Int_t AliITSpackageSSD::GetPrvPIdx(Int_t OI)
  //Returns index of previous P cluster  OI in package; OI == Original Inedx (in TClonesArray)
  //if not egsist return -1;
  
- Int_t i;
- for(i =1; i<fNclustersP;i++)
+ for (Int_t i =1; i<fNclustersP;i++)
   {
     if(GetPSideClusterIdx(i) == OI)
        return GetPSideClusterIdx(i-1);
@@ -590,8 +572,7 @@ Int_t AliITSpackageSSD::GetNextNIdx(Int_t OI)
 {
 //Returns index of next N cluster OI in package; OI == Original Inedx (in TClonesArray)
  //if not egsist return -1;
- Int_t i;
- for(i =0; i<fNclustersN-1;i++)
+ for (Int_t i =0; i<fNclustersN-1;i++)
   {
     if(GetNSideClusterIdx(i) == OI)
        return GetNSideClusterIdx(i+1);
@@ -605,8 +586,7 @@ Int_t  AliITSpackageSSD::GetPrvNIdx(Int_t OI)
  //Returns index of previous N cluster OI in package; OI == Original Inedx (in TClonesArray)
  //if not egsist return -1;
  
- Int_t i;
- for(i =1; i<fNclustersN;i++)
+ for (Int_t i =1; i<fNclustersN;i++)
   {
     if(GetNSideClusterIdx(i) == OI)
        return GetNSideClusterIdx(i-1);
@@ -620,7 +600,7 @@ void  AliITSpackageSSD::SplitPackage(Int_t pi, Int_t ni, AliITSpackageSSD* pkg)
   // split package of clusters
   Int_t p=-1, n=-1;
   Int_t i;
-  for(i=0;i<fNclustersN;i++)
+  for (i=0;i<fNclustersN;i++)
    {
      if((*fClusterNIndexes)[i]==ni) 
       {
@@ -629,7 +609,7 @@ void  AliITSpackageSSD::SplitPackage(Int_t pi, Int_t ni, AliITSpackageSSD* pkg)
       }
     }