fixing coding convention viols. RecPoint macro updated.
authoramastros <amastros@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 13 Mar 2011 14:25:35 +0000 (14:25 +0000)
committeramastros <amastros@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 13 Mar 2011 14:25:35 +0000 (14:25 +0000)
ITS/UPGRADE/AliITSupgrade.cxx
ITS/UPGRADE/AliITSupgrade.h
ITS/UPGRADE/AliITSupgradeDigitizer.cxx
ITS/UPGRADE/readRecPoint.C

index f6e16c1..ce8674c 100644 (file)
 #include "AliRun.h"             //CreateMaterials()    
 #include "AliMC.h"             //CreateMaterials()    
 #include "AliMagF.h"            //CreateMaterials()
-#include "AliCDBManager.h"      //CreateMaterials()
-#include "AliCDBEntry.h"        //CreateMaterials()
 #include "AliITSupgrade.h"      //class header
 #include "AliITShit.h"           // StepManager()
 #include "AliITSDigitUpgrade.h"
 #include "AliTrackReference.h"   // StepManager()
-#include "AliITSDetTypeSim.h"
+#include "AliITSsegmentationUpgrade.h"
+
 ClassImp(AliITSupgrade) 
 //__________________________________________________________________________________________________
   AliITSupgrade::AliITSupgrade():
@@ -51,7 +50,7 @@ ClassImp(AliITSupgrade)
     fNlayers(0),
     fHalfLength(0),
     fSdigits(0),
-    fDigits(0),
+    fDigitArray(0),
     fSegmentation(0x0)
 {
   //
@@ -75,9 +74,14 @@ AliITSupgrade::AliITSupgrade(const char *name,const char *title, Bool_t isBeamPi
   fNlayers(0),
   fHalfLength(0),
   fSdigits(0),
-  fDigits(0),
+  fDigitArray(0),
   fSegmentation(0x0)
 {
+  // Default values are used in order to simulate the standard ITS material budget (see The ALICE Collaboration et al 2008 JINST 3 S08002 - Figure 3.2).
+  // The cell segmentation is chosen to achieve the tracking resolution as described in Table 3.2 of The ALICE Collaboration et al 2008 JINST 3 S08002,
+  // apart from SPD0 where the 9 um value is considered : resolution*sqrt(12)
+  // Cilinder lenghts are chosen according to Table 1 of the Alignment paper : http://iopscience.iop.org/1748-0221/5/03/P03003
+
   fNlayers = 6;
   fWidths.Set(fNlayers);
   fRadii.Set(fNlayers);
@@ -86,14 +90,10 @@ AliITSupgrade::AliITSupgrade(const char *name,const char *title, Bool_t isBeamPi
   fCopper.Set(fNlayers);
   fHalfLength.Set(fNlayers);
 
-  // Default values are used in order to simulate the standard ITS material budget (see The ALICE Collaboration et al 2008 JINST 3 S08002 - Figure 3.2).
-  // The cell segmentation is chosen to achieve the tracking resolution as described in Table 3.2 of The ALICE Collaboration et al 2008 JINST 3 S08002,
-  // apart from SPD0 where the 9 um value is considered : resolution*sqrt(12)
-  // Cilinder lenghts are chosen according to Table 1 of the Alignment paper : http://iopscience.iop.org/1748-0221/5/03/P03003
 
-  Double_t xsz[6]={31.18*1e-04,41.6*1e-04,131.6*1e-04,131.6*1e-04,69.3*1e-04,69.3*1e-04};
+  Double_t xsz[6]={31.18*1e-04,41.6*1e-04,121.2e-04,121.4*1e-04,69.3*1e-04,69.3*1e-04};
   Double_t zsz[6]={416*1e-04,416*1e-04,97*1e-04,97*1e-04,2875*1e-04,2875*1e-04};
-  Double_t Lhalf[6]={14.1,14.1,22.2,29.7,43.1,48.9};
+  Double_t halfL[6]={14.1,14.1,22.2,29.7,43.1,48.9};
   Double_t r[6]={4.,7.6,14.9,23.8,39.1,43.6};
   Double_t thick[6]={75.*1e-04,150.*1e-04,150.*1e-04,150.*1e-04,150.*1e-04,150.*1e-04};
 
@@ -105,25 +105,25 @@ AliITSupgrade::AliITSupgrade(const char *name,const char *title, Bool_t isBeamPi
   if(isBeamPipe){
     fRadiusBP = 2.9;
     fWidthBP = 0.08;
-    fHalfLengthBP = Lhalf[0];
+    fHalfLengthBP = halfL[0];
   }
 
   // setting the geonetry parameters and the segmentation
   Int_t npixHalf[6], npixR[6];
-  Double_t HalfL[6], xszInt[6];
+  Double_t halfLmod[6], xszInt[6];
   Int_t c[6]={1,1,1,1,1,1};
 
   for(Int_t i=0; i<nlayers; i++){
     // recalc length 
-    npixHalf[i]=(Int_t)(Lhalf[i]/zsz[i]);
-    HalfL[i]=npixHalf[i]*zsz[i];
+    npixHalf[i]=(Int_t)(halfL[i]/zsz[i]);
+    halfLmod[i]=npixHalf[i]*zsz[i];
     // recalc segmentation 
     npixR[i] = (Int_t)(2*TMath::Pi()*r[i]/xsz[i]);
     xszInt[i]= 2*TMath::Pi()*r[i]/npixR[i];
     xsizeSi.AddAt(xszInt[i],i);
     zsizeSi.AddAt(zsz[i],i);
 
-    fHalfLength.AddAt(HalfL[i],i);
+    fHalfLength.AddAt(halfLmod[i],i);
 
     fRadii.AddAt(r[i],i);
     fWidths.AddAt(thick[i],i);
@@ -151,12 +151,12 @@ AliITSupgrade::AliITSupgrade(const char *name,const char *title, TArrayD widths,
   fNlayers(widths.GetSize()),
   fHalfLength(halfLengths),
   fSdigits(0),
-  fDigits(0),
+  fDigitArray(0),
   fSegmentation(0x0)
 {
-
   //
-  // constructor
+  // constructor to set all the geometrical/segmentation specs from outside
+  // 
   for(Int_t i=0;i<fNlayers;i++){
     fWidths.Set(i+1);
     fWidths.AddAt(widths.At(i),i);
@@ -177,7 +177,7 @@ AliITSupgrade::AliITSupgrade(const char *name,const char *title, TArrayD widths,
 AliITSupgrade::~AliITSupgrade(){
 
   if(fSdigits) {fSdigits->Delete(); delete fSdigits;}
-  if(fDigits)  {fDigits->Delete(); delete fDigits;}
+  if(fDigitArray)  {fDigitArray->Delete(); delete fDigitArray;}
 }
 
 
@@ -330,8 +330,10 @@ void AliITSupgrade::StepManager()
 //__________________________________________________________________________________________________
 TGeoVolumeAssembly * AliITSupgrade::CreateVol()
 {
-  
-   TGeoVolumeAssembly *vol = new TGeoVolumeAssembly("ITSupgrade");
+//
+// method to create the Upgrade Geometry (silicon, copper cylinders and beampipe)
+//  
+  TGeoVolumeAssembly *vol = new TGeoVolumeAssembly("ITSupgrade");
   TGeoMedium *si   =gGeoManager->GetMedium("ITS_UpgradeSi");
   TGeoMedium *cu   =gGeoManager->GetMedium("ITS_UpgradeCu");
   TGeoMedium *be   =gGeoManager->GetMedium("ITS_UpgradeBe");
@@ -346,7 +348,6 @@ TGeoVolumeAssembly * AliITSupgrade::CreateVol()
       if(fCopper.At(ivol)){
         vol->AddNode(layerCu,ivol);
       }
-
     }else{
 
       TGeoVolume *layer = gGeoManager->MakeTubs(Form("LayerSilicon%i",ivol),si,  fRadii.At(ivol),   fRadii.At(ivol)+fWidths.At(ivol)  ,fHalfLength.At(ivol),0,(360./fNSectors));
@@ -370,21 +371,22 @@ TGeoVolumeAssembly * AliITSupgrade::CreateVol()
      vol->AddNode(beampipe,0);
    }
   return vol;
-
-  
 }
 //_________________________________________________________________________________________________
 void AliITSupgrade::SetFullSegmentation(TArrayD xsize,TArrayD zsize){
+//
+// Upgrade detector specs specified in used constructor are stored in a file .
+// for further usage (loc<->master<->tracking reference system changes)
 
-  Bool_t Check=kFALSE;
+  Bool_t check=kFALSE;
   for(Int_t lay = 0; lay< xsize.GetSize(); lay++){
     Double_t arch = fRadii.At(lay)*(TMath::Pi()*2/fNSectors);
     Int_t nPixRPhi = (Int_t)(arch/xsize.At(lay));
     Int_t nPixZed = (Int_t)((2*fHalfLength.At(lay))/zsize.At(lay));
-    if(nPixRPhi>9999)Check=kTRUE;
-    if(nPixZed>99999)Check=kTRUE;
+    if(nPixRPhi>9999)check=kTRUE;
+    if(nPixZed>99999)check=kTRUE;
   }
-  if(Check) AliFatal(" Segmentation is too small!! ");
+  if(check) AliFatal(" Segmentation is too small!! ");
   if(fSegmentation) fSegmentation->SetNSectors(fNSectors);
   TArrayD nSect(1);
   nSect.AddAt(fNSectors,0);
@@ -483,7 +485,7 @@ void AliITSupgrade::Hits2SDigits(){
   
 }
 //____________________________
-void AliITSupgrade::Hit2SumDig(TClonesArray *hits,TObjArray *pSDig, Int_t *nSdigit)
+void AliITSupgrade::Hit2SumDig(TClonesArray *hits,const TObjArray *pSDig, Int_t *nSdigit)
 {
   // Adds  sdigits of this hit to the list
   //   Returns: none
@@ -553,7 +555,7 @@ void AliITSupgrade::MakeBranch(Option_t *option){
 
   if(cD&&fLoader->TreeD()){
     DigitsCreate();
-    for(Int_t i=0;i<fNlayers;i++) MakeBranchInTree(fLoader->TreeD(),Form("Layer%d",i),&((*fDigits)[i]),kBufSize,0);
+    for(Int_t i=0;i<fNlayers;i++) MakeBranchInTree(fLoader->TreeD(),Form("Layer%d",i),&((*fDigitArray)[i]),kBufSize,0);
   }
   AliDebug(1,"Stop.");
 }
@@ -578,7 +580,7 @@ void AliITSupgrade::SetTreeAddress()
   if(fLoader->TreeD() && fLoader->TreeD()->GetBranch("Layer0")){
     DigitsCreate(); 
     for(int i=0;i<fNlayers;i++){
-      fLoader->TreeD()->SetBranchAddress(Form("Layer%d",i),&((*fDigits)[i]));
+      fLoader->TreeD()->SetBranchAddress(Form("Layer%d",i),&((*fDigitArray)[i]));
     }
   }
   AliDebug(1,"Stop.");
@@ -606,6 +608,10 @@ void AliITSupgrade::PrintSummary()
 }
 //____________________________________________________________________________________________________ 
 void AliITSupgrade::SetSegmentationX(Double_t x, Int_t lay){
+//
+// Virtual dimension in X direction is written into the file
+// (-> see SetFullSegmentation)
+
 TFile *f = TFile::Open("Segmentation.root","UPDATE");
 if(!f) { 
   AliError("\n\n\n Segmentation.root file does not exist. The segmentation is 0! \n\n\n");
@@ -625,6 +631,11 @@ else {
 }
 //____________________________________________________________________________________________________ 
 void AliITSupgrade::SetSegmentationZ(Double_t z, Int_t lay){
+//
+// Virtual dimension in X direction is written into the file
+// (-> see SetFullSegmentation)
+//
+
 
 TFile *f = TFile::Open("Segmentation.root","UPDATE");
 if(!f) { 
index d52e0f4..f3ed157 100644 (file)
@@ -23,7 +23,6 @@
 //
 
 #include "AliITS.h"             //base class 
-#include "AliITSsegmentationUpgrade.h"
 #include "AliITSupgradeDigitizer.h"
 #include <TArrayS.h>
     
@@ -33,6 +32,8 @@ class TArrayD;
 class TClonesArray;
 class TObjArray;
 class AiITShit;
+class AliITSsegmentationUpgrade;
+
 class AliITSupgrade : public AliITS //TObject-TNamed-AliModule-AliDetector-AliITS-AliITSupgrade
 {
  public:
@@ -64,16 +65,16 @@ class AliITSupgrade : public AliITS //TObject-TNamed-AliModule-AliDetector-AliIT
      
      
      
-  TObjArray*      DigitsList()            const{return fDigits;}//get digits list for all layers
-  TClonesArray*   DigitsList(Int_t layer) const{return fDigits ? (TClonesArray *)fDigits->At(layer):0;}//get digits list for chamber
-  void            DigitsCreate()            {if (fDigits) return; 
-    fDigits=new TObjArray(fNlayers);
-    for(Int_t i=0;i<fNlayers;i++)fDigits->AddAt(new TClonesArray("AliITSDigitUpgrade"),i);}//create digits list
-  void          DigitsReset ()              {if(fDigits)for(int i=0;i<fNlayers;i++)fDigits->At(i)->Clear();                     }//clean digits list
+  TObjArray*      DigitsList()            const{return fDigitArray;}//get digits list for all layers
+  TClonesArray*   DigitsList(Int_t layer) const{return fDigitArray ? (TClonesArray *)fDigitArray->At(layer):0;}//get digits list for chamber
+  void            DigitsCreate()            {if (fDigitArray) return; 
+    fDigitArray=new TObjArray(fNlayers);
+    for(Int_t i=0;i<fNlayers;i++)fDigitArray->AddAt(new TClonesArray("AliITSDigitUpgrade"),i);}//create digits list
+  void          DigitsReset ()              {if(fDigitArray)for(int i=0;i<fNlayers;i++)fDigitArray->At(i)->Clear();                     }//clean digits list
 
   AliDigitizer*   CreateDigitizer  (AliRunDigitizer *m) const {return new AliITSupgradeDigitizer(m);}  //from AliModule invoked from AliSimulation::RunDigitization()
            
-  void Hit2SumDig(TClonesArray *hits,TObjArray *pSDig, Int_t *nSdigit);
+  void Hit2SumDig(TClonesArray *hits,const TObjArray *pSDig, Int_t *nSdigit);
 
   enum EMedia {kAir=0,kSi=1,kBe=2, kCu=3};                         //media ids used in CreateMaterials  
     
@@ -95,21 +96,21 @@ class AliITSupgrade : public AliITS //TObject-TNamed-AliModule-AliDetector-AliIT
   void PrintSummary();
 
  protected:
-  TArrayD fWidths;
-  TArrayD fRadii;
-  Int_t fNSectors;
-  TArrayD fRadiiCu;
-  TArrayD fWidthsCu;
-  TArrayS fCopper;
-  Bool_t fBeampipe;
-  Double_t fRadiusBP;
-  Double_t fWidthBP;
-  Double_t fHalfLengthBP;
-  Int_t   fNlayers;
-  TArrayD fHalfLength;
-  TObjArray            *fSdigits;                 //![fNlayers] list of sdigits
-  TObjArray            *fDigits;                     //![fNlayers] list of digits per layer
-  AliITSsegmentationUpgrade *fSegmentation;
+  TArrayD fWidths;                           // thicknesses of silicon cylinders
+  TArrayD fRadii;                            // radii of silicon cylinders
+  Int_t fNSectors;                           // number of sectors
+  TArrayD fRadiiCu;                          // radii of copper cylinders 
+  TArrayD fWidthsCu;                         // thicknesses of copper cylinders
+  TArrayS   fCopper;                         // check to set the copper cylinder 
+  Bool_t fBeampipe;                           // boolean to set beam pipe vol in geometry
+  Double_t fRadiusBP;                         // beam pipe radius
+  Double_t fWidthBP;                         // thickness of the beam pipe             
+  Double_t fHalfLengthBP;                    // 1/2 beam pipe cyclinder length
+  Int_t   fNlayers;                          // # of layers
+  TArrayD fHalfLength;                       // 1/2 silicon and copper cylinder lengths
+  TObjArray            *fSdigits;             //![fNlayers] list of sdigits
+  TObjArray            *fDigitArray;          //![fNlayers] list of digits per layer
+  AliITSsegmentationUpgrade *fSegmentation;   //virtual segmentation class
   
  private:
   AliITSupgrade(const AliITSupgrade& u);              //dummy copy constructor
index b346f9d..c44c4e9 100644 (file)
@@ -24,6 +24,7 @@
 #include "AliITSupgradeDigitizer.h"
 #include "AliITSDigitUpgrade.h"
 #include "AliITSupgrade.h"
+#include "AliITSsegmentationUpgrade.h"
 #include <TObjArray.h>
 #include <TClonesArray.h>
 
index 9b91dc0..584dcec 100644 (file)
@@ -1,34 +1,42 @@
 void readRecPoint(){
-  gSystem->Load("libITSUpgradeSim");
+   gSystem->Load("libITSUpgradeSim");
   gSystem->Load("libITSUpgradeBase");
   gSystem->Load("libITSUpgradeRec");
   gROOT->SetStyle("Plain");
+  gStyle->SetOptStat(1111111);
   Int_t nbins=100;
   Int_t xmin=0;
   Int_t xmax=50000;//00*1e-09;
 
-  const Int_t nLayers = 6;
 
   AliITSsegmentationUpgrade *seg = new AliITSsegmentationUpgrade();
   if(!seg){
     printf("no segmentation info available... Exiting");
     return;
   }
+  Int_t nLayers = seg->GetNLayers();
 
-  TH1D *hNel[nLayers];
+  TH1D **hNel, **hNsect;
+  hNel = new TH1D[nLayers]; 
+  hNsect = new TH1D[nLayers]; 
+ // [nLayers];
   for(Int_t i=0; i< nLayers; i++ ) {
   hNel[i] = new TH1D(Form("hNel%i",i),Form("cluster charge distribution [ Layer %i] ",i),nbins,xmin,xmax);
   hNel[i]->SetXTitle("N electrons");
+  hNsect[i] = new TH1D(Form("hNsect%i",i),Form("cluster entries per sector [ Layer %i] ",i),seg->GetNSectors(),-0.5,seg->GetNSectors()-0.5);
+  hNsect[i]->SetXTitle("Sector Number");
+  hNsect[i]->SetYTitle("# clusters");
+  hNsect[i]->SetMinimum(0);
   }
+
   TH1D * type = new TH1D("hCluType"," cluster type" , 50,0,15 );
 
   TH2F *xyGlob = new TH2F("xyGlob"," X - Y Global coordinates ",100,-50,50,100,-50,50);
   xyGlob->SetXTitle("cm"); 
- xyGlob->SetMarkerStyle(7); 
-  TH1F *zGlob  = new TH1F("zGlob", " Z Global coordinates ",200, -100,100 );
+  xyGlob->SetMarkerStyle(7); 
+  TH1F *zGlob  = new TH1F("zGlob", " Z Global coordinates ",200, -50,50 );
   zGlob->SetXTitle("cm"); 
 
-
   gAlice=NULL;
   AliRunLoader* runLoader = AliRunLoader::Open("galice.root");
   runLoader->LoadgAlice();
@@ -41,10 +49,9 @@ void readRecPoint(){
 
   AliITSLoader *dl = (AliITSLoader*)runLoader->GetDetectorLoader("ITS");
 
-
   TTree *clusTree = 0x0;
 
-  TClonesArray statITSCluster("AliITSRecPoint");
+  TClonesArray statITSCluster("AliITSRecPointU");
 
   for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
     runLoader->GetEvent(iEvent);
@@ -60,33 +67,43 @@ void readRecPoint(){
     Double_t charge=0.;
     Int_t nCluster = ITSCluster->GetEntriesFast();
     for(Int_t i=0; i<nCluster; i++){
-      AliITSRecPoint *recp = (AliITSRecPoint*)ITSCluster->UncheckedAt(i);
+      AliITSRecPointU *recp = (AliITSRecPointU*)ITSCluster->UncheckedAt(i);
       Double_t xyz[3]={-1,-1,-1};
-      seg->DetToGlobal(recp->GetLayer(), recp->GetDetLocalX(), recp->GetDetLocalZ(), xyz[0],xyz[1],xyz[2]) ;
+      seg->DetToGlobal(recp->GetLayer(), recp->GetModule(), recp->GetDetLocalX(), recp->GetDetLocalZ(), xyz[0],xyz[1],xyz[2]) ;
       xyGlob->Fill(xyz[0],xyz[1]);
       zGlob->Fill(xyz[2]);
       charge=recp->GetQ();
-      // cout<< "layer "<< recp->GetLayer() << "   local system    X "<< recp->GetDetLocalX() << " Z "<< recp->GetDetLocalZ() <<endl;  
       type->Fill(recp->GetType());
       hNel[recp->GetLayer()]->Fill(charge);
+      hNsect[recp->GetLayer()]->Fill(recp->GetModule());
     }
-
   }
+  
+ Int_t size = 400;
 
-  TCanvas *xyCanv =  new TCanvas("xvCanvClus","RecPoint X-Y Positions",500,500);
+  TCanvas *xyCanv =  new TCanvas("xvCanvClus","RecPoint X-Y Positions",10,10,size,size);
   xyCanv->cd();
   xyGlob->Draw();
-  TCanvas *zCanv =  new TCanvas("zCanvClus","RecPoint Z Positions",500,500);
+
+  TCanvas *zCanv =  new TCanvas("zCanvClus","RecPoint Z Positions",size+20,10,size,size);
   zCanv->cd();
   zGlob->Draw();
-  new TCanvas();
+  TCanvas *typeCanv = new TCanvas("ClusType","Cluster type distribution",10,size+40,2*size+10,size);
   type->Draw();
 
-  TCanvas *c = new TCanvas("c","Cluster charge distribution",1000,800);
-  c->Divide(3,2);
-  for(Int_t ip =1; ip<=6; ip++){
+
+  TCanvas *c = new TCanvas("c","Cluster charge distribution",900,0, 1000,550);
+   c->Divide(3,(nLayers/3));
+  for(Int_t ip =1; ip<=nLayers; ip++){
     c->cd(ip);
     hNel[ip-1]->Draw();
+  }
+  TCanvas *cS = new TCanvas("cS","clusters in sectors",900,640,1000,550);
+   cS->Divide(3,(nLayers/3));
+  for(Int_t ip =1; ip<=nLayers; ip++){
+    cS->cd(ip);
+    hNsect[ip-1]->Draw();
   } 
 }