Chnges in the pad geometry - 3 pad lengths introduced.
authorkowal2 <kowal2@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 18 Mar 2002 17:59:13 +0000 (17:59 +0000)
committerkowal2 <kowal2@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 18 Mar 2002 17:59:13 +0000 (17:59 +0000)
TPC/AliTPC.cxx
TPC/AliTPCParam.cxx
TPC/AliTPCParam.h
TPC/AliTPCParamCR.cxx
TPC/AliTPCParamCR.h
TPC/AliTPCParamSR.cxx
TPC/AliTPCParamSR.h
TPC/AliTPCtracker.cxx
TPC/AliTPCtracker.h

index a840e735f7b1255352a86c175588d033fddd9fea..9c5d75c535ceff01bfa261638ac69e531f5fd177 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.53  2002/02/25 11:02:56  kowal2
+Changes towards speeding up the code. Thanks to Marian Ivanov.
+
 Revision 1.52  2002/02/18 09:26:09  kowal2
 Removed compiler warning
 
@@ -1572,7 +1575,8 @@ void AliTPC::SetDefaults(){
 
   AliTPCParamSR *param=(AliTPCParamSR*)gDirectory->Get("75x40_100x60");
   AliTPCPRF2D    * prfinner   = new AliTPCPRF2D;
-  AliTPCPRF2D    * prfouter   = new AliTPCPRF2D;
+  AliTPCPRF2D    * prfouter1   = new AliTPCPRF2D;
+  AliTPCPRF2D    * prfouter2   = new AliTPCPRF2D;  
   AliTPCRF1D     * rf    = new AliTPCRF1D(kTRUE);
   rf->SetGauss(param->GetZSigma(),param->GetZWidth(),1.);
   rf->SetOffset(3*param->GetZSigma());
@@ -1585,12 +1589,14 @@ void AliTPC::SetDefaults(){
      exit(3);
   }
   prfinner->Read("prf_07504_Gati_056068_d02");
-  prfouter->Read("prf_10006_Gati_047051_d03");
+  prfouter1->Read("prf_10006_Gati_047051_d03");
+  prfouter2->Read("prf_15006_Gati_047051_d03");  
   f->Close();
   savedir->cd();
 
   param->SetInnerPRF(prfinner);
-  param->SetOuterPRF(prfouter); 
+  param->SetOuter1PRF(prfouter1); 
+  param->SetOuter2PRF(prfouter2);
   param->SetTimeRF(rf);
 
   // set fTPCParam
@@ -1626,8 +1632,8 @@ void AliTPC::Hits2Digits(Int_t eventnumber)
 
   cerr<<"Digitizing TPC -- normal digits...\n";
 
- for(Int_t isec=0;isec<fTPCParam->GetNSector();isec++) if (IsSectorActive(isec)) Hits2DigitsSector(isec);
-
+  for(Int_t isec=0;isec<fTPCParam->GetNSector();isec++) if (IsSectorActive(isec)) Hits2DigitsSector(isec); 
+   
   // write results
 
   char treeName[100];
@@ -2244,7 +2250,24 @@ void AliTPC::MakeSector(Int_t isec,Int_t nrows,TTree *TH,
          rowNumber = index[2];
          //transform position to local digit coordinates
          //relative to nearest pad row 
-         if ((rowNumber<0)||rowNumber>=fTPCParam->GetNRow(isec)) continue;       
+         if ((rowNumber<0)||rowNumber>=fTPCParam->GetNRow(isec)) continue;
+  Float_t x1,y1;
+         if (isec <fTPCParam->GetNInnerSector()) {
+           x1 = xyz[1]*fTPCParam->GetInnerPadPitchWidth();
+           y1 = fTPCParam->GetYInner(rowNumber);
+         }
+         else{
+           x1=xyz[1]*fTPCParam->GetOuterPadPitchWidth();
+           y1 = fTPCParam->GetYOuter(rowNumber);
+         }
+
+         x1=TMath::Abs(x1);
+         if (y1-0.5 <x1) {
+           xyz[3]=0.;}
+         else{ 
+           if (y1 -1.<x1){
+             xyz[3]*=0.5;}
+         }                    
          nofElectrons[rowNumber]++;      
          //----------------------------------
          // Expand vector if necessary
index 8f32e747c5022a1590cc370bb6315a2f19f947f1..c800f7cebcfc90df276eb8eacac26a51fe7dbb0b 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.12  2002/02/05 09:12:26  hristov
+Small mods for gcc 3.02
+
 Revision 1.11  2000/11/02 07:33:48  kowal2
 Automatic streamer generation.
 
@@ -300,10 +303,10 @@ void AliTPCParam::SetDefault()
   //
   //sector default parameters
   //
-  const static  Float_t kInnerRadiusLow = 82.97;
-  const static  Float_t kOuterRadiusLow = 133.58;
-  const static  Float_t kInnerRadiusUp  = 133.17;
-  const static  Float_t kOuterRadiusUp  = 247.78;
+  const static  Float_t kInnerRadiusLow = 83.0;
+  const static  Float_t kInnerRadiusUp  = 133.2;
+  const static  Float_t kOuterRadiusLow = 133.5;
+  const static  Float_t kOuterRadiusUp  = 247.7;
   const static  Float_t kInnerAngle = 20; // 20 degrees
   const static  Float_t kInnerAngleShift = 10;
   const static  Float_t kOuterAngle = 20; //  20 degrees
@@ -314,13 +317,24 @@ void AliTPCParam::SetDefault()
   const static  Float_t kOuterWireMount = 1.370825926;
   const static  Float_t kZLength =250.;
   const static  Int_t   kGeometryType = 0; //straight rows 
+  const static Int_t kNRowLow = 63;
+  const static Int_t kNRowUp1 = 64;
+  const static Int_t kNRowUp2 = 32;
+  const static Int_t  kNRowUp = 96;
   //
   //wires default parameters
   //
   const static Int_t    kNInnerWiresPerPad = 3;
   const static Int_t    kInnerDummyWire = 2;
+  const static Float_t  kInnerWWPitch = 0.25;
+  const static Float_t  kRInnerFirstWire = 84.475;
+  const static Float_t  kRInnerLastWire = 132.475;
   const static Float_t  kInnerOffWire = 0.5;
-  const static Int_t    kNOuterWiresPerPad = 4;
+  const static Int_t    kNOuter1WiresPerPad = 4;
+  const static Int_t    kNOuter2WiresPerPad = 6;
+  const static Float_t  kOuterWWPitch = 0.25;  
+  const static Float_t  kROuterFirstWire = 134.225;
+  const static Float_t  kROuterLastWire = 246.975;
   const static Int_t    kOuterDummyWire = 2;
   const static Float_t  kOuterOffWire = 0.5;
   //
@@ -330,10 +344,13 @@ void AliTPCParam::SetDefault()
   const static Float_t  kInnerPadPitchWidth = 0.40;
   const static Float_t  kInnerPadLength = 0.75;
   const static Float_t  kInnerPadWidth = 0.40;
-  const static Float_t  kOuterPadPitchLength = 1.0;
+  const static Float_t  kOuter1PadPitchLength = 1.0;
   const static Float_t  kOuterPadPitchWidth = 0.6;
-  const static Float_t  kOuterPadLength = 1.0;
+  const static Float_t  kOuter1PadLength = 1.0;
   const static Float_t  kOuterPadWidth = 0.6;
+  const static Float_t  kOuter2PadPitchLength = 1.5;
+  const static Float_t  kOuter2PadLength = 1.5;
+
   const static Bool_t   kBMWPCReadout = kTRUE; //MWPC readout - another possibility GEM 
   const static Int_t    kNCrossRows = 1; //number of rows to cross-talk
   
@@ -386,15 +403,26 @@ void AliTPCParam::SetDefault()
   SetSectorAngles(kInnerAngle,kInnerAngleShift,kOuterAngle,kOuterAngleShift);
   SetZLength(kZLength);
   SetGeometryType(kGeometryType);
+  SetRowNLow(kNRowLow);
+  SetRowNUp1 (kNRowUp1);
+  SetRowNUp2(kNRowUp2);
+  SetRowNUp(kNRowUp);
   //
   //set wire parameters
   //
   SetInnerNWires(kNInnerWiresPerPad);
   SetInnerDummyWire(kInnerDummyWire);
   SetInnerOffWire(kInnerOffWire);
-  SetOuterNWires(kNOuterWiresPerPad);
+  SetOuter1NWires(kNOuter1WiresPerPad);
+  SetOuter2NWire(kNOuter2WiresPerPad);
   SetOuterDummyWire(kOuterDummyWire);
   SetOuterOffWire(kOuterOffWire);
+  SetInnerWWPitch(kInnerWWPitch);
+  SetRInnerFirstWire(kRInnerFirstWire);
+  SetRInnerLastWire(kRInnerLastWire);
+  SetOuterWWPitch(kOuterWWPitch);
+  SetROuterFirstWire(kROuterFirstWire);
+  SetROuterLastWire(kROuterLastWire);  
   //
   //set pad parameter
   //
@@ -402,9 +430,11 @@ void AliTPCParam::SetDefault()
   SetInnerPadPitchWidth(kInnerPadPitchWidth);
   SetInnerPadLength(kInnerPadLength);
   SetInnerPadWidth(kInnerPadWidth);
-  SetOuterPadPitchLength(kOuterPadPitchLength);
+  SetOuter1PadPitchLength(kOuter1PadPitchLength); 
+  SetOuter2PadPitchLength(kOuter2PadPitchLength);
   SetOuterPadPitchWidth(kOuterPadPitchWidth);
-  SetOuterPadLength(kOuterPadLength);
+  SetOuter1PadLength(kOuter1PadLength);
+  SetOuter2PadLength(kOuter2PadLength);
   SetOuterPadWidth(kOuterPadWidth); 
   SetMWPCReadout(kBMWPCReadout);
   SetNCrossRows(kNCrossRows);
@@ -493,26 +523,21 @@ Bool_t AliTPCParam::Update()
   fTotalNormFac = fPadCoupling*fChipNorm*kQel*1.e15*fChipGain*fADCSat/fADCDynRange;
   fNoiseNormFac = kQel*1.e15*fChipGain*fADCSat/fADCDynRange;
   //wire section 
-  Int_t nwire;
+  /*  Int_t nwire;
   Float_t wspace; //available space for wire
   Float_t dummyspace; //dummyspace for wire
-
-  fInnerWWPitch = Float_t((Double_t)fInnerPadPitchLength/(Double_t)fNInnerWiresPerPad);  
   wspace =fInnerRadiusUp-fInnerRadiusLow-2*fInnerOffWire;
   nwire = Int_t(wspace/fInnerWWPitch);
   wspace = Float_t(nwire)*fInnerWWPitch;
-  dummyspace =(fInnerRadiusUp-fInnerRadiusLow-wspace)/2.; 
-  fRInnerFirstWire = fInnerRadiusLow+dummyspace;
-  fRInnerLastWire = fRInnerFirstWire+fInnerWWPitch*(Float_t)(nwire);
-
-  fOuterWWPitch = Float_t((Double_t)fOuterPadPitchLength/(Double_t)fNOuterWiresPerPad);  
+  dummyspace =(fInnerRadiusUp-fInnerRadiusLow-wspace)/2.;  
   wspace =fOuterRadiusUp-fOuterRadiusLow-2*fOuterOffWire;
   nwire = Int_t(wspace/fOuterWWPitch);
   wspace = Float_t(nwire)*fOuterWWPitch;
   dummyspace =(fOuterRadiusUp-fOuterRadiusLow-wspace)/2.; 
   fROuterFirstWire = fOuterRadiusLow+dummyspace;
   fROuterLastWire = fROuterFirstWire+fOuterWWPitch*(Float_t)(nwire);
-
+  */
   
   //
   //response data
@@ -544,6 +569,16 @@ Int_t AliTPCParam::GetNRowUp() const
   //get the number of pad rows in up sector
   return fNRowUp;
 }
+Int_t AliTPCParam::GetNRowUp1() const
+{
+  //get the number of pad rows in up1 sector
+  return fNRowUp1;
+}
+Int_t AliTPCParam::GetNRowUp2() const
+{
+  //get the number of pad rows in up2 sector
+  return fNRowUp2;
+}
 Float_t AliTPCParam::GetPadRowRadiiLow(Int_t irow) const
 {
   //get the pad row (irow) radii
@@ -580,4 +615,21 @@ Int_t AliTPCParam::GetNPadsUp(Int_t irow) const
   else
     return 0;
 }
+Float_t AliTPCParam::GetYInner(Int_t irow) const
+{
+  return fYInner[irow];
+}
+
+
+Float_t AliTPCParam::GetYOuter(Int_t irow) const
+{
+  return fYOuter[irow];
+}
+
+
+
+
+
+
+
 
index e4b7570cf5dc5278e5fe80bd3ee799a902f29e67..ec0097fcba51e57f5204f446c8d08173670096a4 100644 (file)
@@ -126,25 +126,42 @@ public:
   void  SetZLength(Float_t zlength) {fZLength = zlength;} 
   void  SetGeometryType(Int_t type) {fGeometryType = type;}
   //
+  // pad rows geometry
+  //
+  void SetRowNLow( Int_t NRowLow){fNRowLow = NRowLow;}
+  void SetRowNUp1 (Int_t NRowUp1){fNRowUp1 = NRowUp1 ;} //upper sec short pads 
+  void SetRowNUp2 (Int_t NRowUp2){fNRowUp2 = NRowUp2 ;} //upper sec long pads
+  void SetRowNUp (Int_t NRowUp){fNRowUp = NRowUp ;}  
+  //
   //set wire parameters
   //
   void  SetInnerNWires(Int_t nWires){  fNInnerWiresPerPad=nWires;}
   void  SetInnerDummyWire(Int_t dummy) {fInnerDummyWire  = dummy;}
   void  SetInnerOffWire(Float_t offset) {fInnerOffWire =offset;}    
-  void  SetOuterNWires(Int_t nWires){  fNOuterWiresPerPad=nWires;}
+  void  SetOuter1NWires(Int_t nWires){  fNOuter1WiresPerPad=nWires;}
+  void  SetOuter2NWire(Int_t nWires){  fNOuter2WiresPerPad=nWires;}
   void  SetOuterDummyWire(Int_t dummy) {fOuterDummyWire  = dummy;}
-  void  SetOuterOffWire(Float_t offset) {fOuterOffWire =offset;}    
+  void  SetOuterOffWire(Float_t offset) {fOuterOffWire =offset;} 
+  void  SetInnerWWPitch( Float_t wwPitch) {fInnerWWPitch = wwPitch;}
+  void  SetRInnerFirstWire(Float_t firstWire){fRInnerFirstWire = firstWire;}
+  void  SetRInnerLastWire(Float_t lastWire){fRInnerLastWire = lastWire;}
+  void  SetOuterWWPitch(Float_t wwPitch){fOuterWWPitch = wwPitch;}
+  void  SetLastWireUp1(Float_t wireUp1){fLastWireUp1 = wireUp1;} 
+  void  SetROuterFirstWire(Float_t firstWire){fROuterFirstWire = firstWire;}
+  void  SetROuterLastWire(Float_t lastWire){fROuterLastWire = lastWire;}   
   //
   //set pad parameter
   //
   void  SetInnerPadPitchLength(Float_t PadPitchLength){  fInnerPadPitchLength=PadPitchLength;}
   void  SetInnerPadPitchWidth(Float_t PadPitchWidth){  fInnerPadPitchWidth = PadPitchWidth;}
   void  SetInnerPadLength(Float_t PadLength){  fInnerPadLength=PadLength;}
-  void  SetInnerPadWidth(Float_t PadWidth) {  fInnerPadWidth=PadWidth;}  
-  void  SetOuterPadPitchLength(Float_t PadPitchLength){  fOuterPadPitchLength=PadPitchLength;}
+  void  SetInnerPadWidth(Float_t PadWidth) {  fInnerPadWidth=PadWidth;} 
+  void  SetOuter1PadPitchLength(Float_t PadPitchLength){  fOuter1PadPitchLength=PadPitchLength;}
+  void  SetOuter2PadPitchLength(Float_t PadPitchLength){  fOuter2PadPitchLength=PadPitchLength;}
   void  SetOuterPadPitchWidth(Float_t PadPitchWidth){  fOuterPadPitchWidth = PadPitchWidth;}
-  void  SetOuterPadLength(Float_t PadLength){  fOuterPadLength=PadLength;}
-  void  SetOuterPadWidth(Float_t PadWidth) {  fOuterPadWidth=PadWidth;} 
+  void  SetOuter1PadLength(Float_t PadLength){  fOuter1PadLength=PadLength;}
+  void  SetOuter2PadLength(Float_t PadLength){  fOuter2PadLength=PadLength;}
+  void  SetOuterPadWidth(Float_t PadWidth) {  fOuterPadWidth=PadWidth;}
   void  SetMWPCReadout(Bool_t type) {fBMWPCReadout = type;}
   void  SetNCrossRows(Int_t rows){fNCrossRows = rows;}
   //
@@ -205,10 +222,12 @@ public:
   Float_t  GetInnerOffWire() const {return fInnerOffWire;}
   Float_t  GetRInnerFirstWire() const {return fRInnerFirstWire;}
   Float_t  GetRInnerLastWire() const {return fRInnerLastWire;}
-  Int_t    GetOuterNWires() const {return fNOuterWiresPerPad;}
+  Int_t    GetOuter1NWires() const {return fNOuter1WiresPerPad;}
+  Int_t    GetOuter2NWires() const {return fNOuter2WiresPerPad;}
   Float_t  GetOuterWWPitch() const {return fOuterWWPitch;}  
   Int_t    GetOuterDummyWire() const {return fOuterDummyWire;}
   Float_t  GetOuterOffWire() const {return fOuterOffWire;}
+  Float_t  GetLastWireUp1()  {return fLastWireUp1;}
   Float_t  GetROuterFirstWire() const {return fROuterFirstWire;}
   Float_t  GetROuterLastWire() const {return fROuterLastWire;}  
   Float_t  GetWWPitch(Int_t isector = 0) const  {
@@ -219,20 +238,28 @@ public:
   Float_t  GetInnerPadPitchLength() const {return fInnerPadPitchLength;}
   Float_t  GetInnerPadPitchWidth() const {return fInnerPadPitchWidth;}
   Float_t  GetInnerPadLength() const {return fInnerPadLength;}
-  Float_t  GetInnerPadWidth() const  {return fInnerPadWidth;}  
-  Float_t  GetOuterPadPitchLength() const {return fOuterPadPitchLength;}
+  Float_t  GetInnerPadWidth() const  {return fInnerPadWidth;}
+  Float_t  GetOuter1PadPitchLength() const {return fOuter1PadPitchLength;}
+  Float_t  GetOuter2PadPitchLength() const {return fOuter2PadPitchLength;}  
   Float_t  GetOuterPadPitchWidth() const {return fOuterPadPitchWidth;}
-  Float_t  GetOuterPadLength() const {return fOuterPadLength;}
+  Float_t  GetOuter1PadLength() const {return fOuter1PadLength;}
+  Float_t  GetOuter2PadLength() const {return fOuter2PadLength;}
   Float_t  GetOuterPadWidth()  const {return fOuterPadWidth;}  
   Bool_t   GetMWPCReadout() const {return fBMWPCReadout;}
   Int_t    GetNCrossRows() const {return fNCrossRows;}
   Float_t  GetPadPitchWidth(Int_t isector = 0) const  {
     return ( (isector < fNInnerSector) ? fInnerPadPitchWidth :fOuterPadPitchWidth);}
-  Float_t  GetPadPitchLength(Int_t isector = 0)  const {
-    return ( (isector < fNInnerSector) ? fInnerPadPitchLength :fOuterPadPitchLength);} 
-
+  Float_t  GetPadPitchLength(Int_t isector = 0, Int_t padrow=0)  const
+  {
+    if (isector < fNInnerSector) {return fInnerPadPitchLength;} 
+    else { 
+     return ((padrow<fNRowUp1) ? fOuter1PadPitchLength:fOuter2PadPitchLength);
+    }
+  }
   Int_t GetNRowLow() const;   //get the number of pad rows in low sector
   Int_t GetNRowUp() const;    //get the number of pad rows in up sector
+  Int_t GetNRowUp1() const;  // number of short rows in up sector  
+  Int_t GetNRowUp2() const;  // number of long rows in up sector
   Int_t GetNRow(Int_t isec) const {return  ((isec<fNInnerSector) ?  fNRowLow:fNRowUp);}
   Int_t GetNRowsTotal(){return fNtRows;}  //get total nuber of rows
   Float_t GetPadRowRadiiLow(Int_t irow) const; //get the pad row (irow) radii
@@ -243,7 +270,10 @@ public:
   Int_t GetNPadsLow(Int_t irow) const;    //get the number of pads in row irow 
   Int_t GetNPadsUp(Int_t irow) const;     //get the number of pads in row irow
   Int_t GetNPads(Int_t isector,Int_t irow) const{
-     return ( (isector < fNInnerSector) ?GetNPadsLow(irow) : GetNPadsUp(irow));}    
+     return ( (isector < fNInnerSector) ?GetNPadsLow(irow) : GetNPadsUp(irow));} 
+
+  Float_t GetYInner(Int_t irow) const; // wire length in low sec row
+  Float_t GetYOuter(Int_t irow) const; // wire length in up sec row  
   //
   //get GAS parameters 
   //
@@ -314,7 +344,9 @@ protected :
   Float_t fInnerOffWire;      //oofset of first wire to the begining of the sector
   Float_t fRInnerFirstWire;   //position of the first wire                -calculated
   Float_t fRInnerLastWire;    //position of the last wire                 -calculated
-  Int_t   fNOuterWiresPerPad; //Number of wires per pad
+  Float_t fLastWireUp1;     //position of the last wire in outer1 sector
+  Int_t   fNOuter1WiresPerPad; //Number of wires per pad
+  Int_t   fNOuter2WiresPerPad;  
   Float_t fOuterWWPitch;      //pitch between wires in outer sector      -calculated
   Int_t   fOuterDummyWire;    //number of wires without pad readout
   Float_t fOuterOffWire;      //oofset of first wire to the begining of the sector
@@ -327,20 +359,26 @@ protected :
   Float_t   fInnerPadPitchWidth;     //Inner pad pitch width
   Float_t   fInnerPadLength;         //Inner pad  length
   Float_t   fInnerPadWidth;          //Inner pad  width
-  Float_t   fOuterPadPitchLength;    //Outer pad pitch length
+  Float_t   fOuter1PadPitchLength;    //Outer pad pitch length
+  Float_t   fOuter2PadPitchLength;    
   Float_t   fOuterPadPitchWidth;     //Outer pad pitch width
-  Float_t   fOuterPadLength;         //Outer pad  length
+  Float_t   fOuter1PadLength;         //Outer pad  length
+  Float_t   fOuter2PadLength;
   Float_t   fOuterPadWidth;          //Outer pad  width
   Bool_t    fBMWPCReadout;           //indicate wire readout - kTRUE or GEM readout -kFALSE
   Int_t     fNCrossRows;             //number of rows to crostalk calculation
       
-  Int_t fNRowLow;           //number of pad rows per low sector    -calculated
+  Int_t fNRowLow;           //number of pad rows per low sector        -set
+  Int_t fNRowUp1;            //number of short pad rows per sector up  -set
+  Int_t fNRowUp2;            //number of long pad rows per sector up   -set
   Int_t fNRowUp;            //number of pad rows per sector up     -calculated
   Int_t fNtRows;            //total number of rows in TPC          -calculated
   Float_t  fPadRowLow[600]; //Lower sector, pad row radii          -calculated
   Float_t  fPadRowUp[600];  //Upper sector, pad row radii          -calculated 
   Int_t    fNPadsLow[600];  //Lower sector, number of pads per row -calculated
-  Int_t    fNPadsUp[600];   //Upper sector, number of pads per row -calculated  
+  Int_t    fNPadsUp[600];   //Upper sector, number of pads per row -calculated
+  Float_t  fYInner[600];     //Inner sector, wire-length
+  Float_t  fYOuter[600];     //Outer sector, wire-length   
   //---------------------------------------------------------------------
   //   ALICE TPC Gas Parameters
   //--------------------------------------------------------------------
@@ -490,7 +528,10 @@ inline Int_t   AliTPCParam::Transform2to3(Float_t *xyz, Int_t *index)  const
   if  (index[1]<fNInnerSector)   
     index[2] =TMath::Nint((xyz[0]-fPadRowLow[0])/fInnerPadPitchLength);
   else
-    index[2] = TMath::Nint((xyz[0]-fPadRowUp[0])/fOuterPadPitchLength);
+    if (xyz[0] < fLastWireUp1 )
+      index[2] = TMath::Nint((xyz[0]-fPadRowUp[0])/fOuter1PadPitchLength);
+    else 
+      index[2] = TMath::Nint(fNRowUp1+(xyz[0]-fPadRowUp[64])/fOuter2PadPitchLength);
   index[0]=3;
   return index[2];
 }
@@ -504,7 +545,10 @@ inline void   AliTPCParam::Transform3to4(Float_t *xyz, Int_t *index)  const
   if  (index[1]<fNInnerSector)   
     xyz[0] -=index[2]*fInnerPadPitchLength+fPadRowLow[0];
   else
-    xyz[0] -=index[2]*fOuterPadPitchLength+fPadRowUp[0];
+    if (index[2]<fNRowUp1)
+      xyz[0] -=index[2]*fOuter1PadPitchLength+fPadRowUp[0];
+    else 
+      xyz[0] -=(index[2]-fNRowUp1)*fOuter2PadPitchLength+fPadRowUp[64];
   index[0]  =4;
 }
 
@@ -517,7 +561,10 @@ inline void   AliTPCParam::Transform4to3(Float_t *xyz, Int_t *index) const
   if  (index[1]<fNInnerSector)   
     xyz[0] +=index[2]*fInnerPadPitchLength+fPadRowLow[0];
   else
-    xyz[0] +=index[2]*fOuterPadPitchLength+fPadRowUp[0];
+    if(index[2]<fNRowUp1)
+      xyz[0] +=index[2]*fOuter1PadPitchLength+fPadRowUp[0];
+    else 
+      xyz[0] +=index[2]*fOuter2PadPitchLength+fPadRowUp[64];
   index[0]  =3;
 }
 
@@ -558,16 +605,17 @@ inline void AliTPCParam::Transform4to8(Float_t *xyz, Int_t *index) const
   //
   //transform xyz coordinates to 'digit' coordinates
   //
+
+  xyz[2]/=fZWidth;  
   if  (index[1]<fNInnerSector) {    
     xyz[0]/=fInnerPadPitchLength;
     xyz[1]/=fInnerPadPitchWidth;
-    xyz[2]/=fZWidth;
   }
-  else{    
-    xyz[0]/=fOuterPadPitchLength;
-    xyz[1]/=fOuterPadPitchWidth;
-    xyz[2]/=fZWidth;
-  }        
+  else{  
+    xyz[1]/=fOuterPadPitchWidth;  
+    if (index[2]<fNRowUp1 ) xyz[0]/=fOuter1PadPitchLength;      
+    else xyz[0]/=fOuter2PadPitchLength;     
+  }
   index[0]=8;
 }
 
@@ -576,16 +624,16 @@ inline void AliTPCParam::Transform8to4(Float_t *xyz, Int_t *index) const
   //
   //transforms 'digit' coordinates to xyz coordinates
   //
+  xyz[2]*=fZWidth;
   if  (index[1]<fNInnerSector) {    
     xyz[0]*=fInnerPadPitchLength;
-    xyz[1]*=fInnerPadPitchWidth;
-    xyz[2]*=fZWidth;
+    xyz[1]*=fInnerPadPitchWidth;    
   }
-  else{    
-    xyz[0]*=fOuterPadPitchLength;
-    xyz[1]*=fOuterPadPitchWidth;
-    xyz[2]*=fZWidth;
-  }        
+  else{  
+    xyz[1]*=fOuterPadPitchWidth;  
+    if (index[2] < fNRowUp1 ) xyz[0]*=fOuter1PadPitchLength;
+    else xyz[0]*=fOuter2PadPitchLength;           
+  } 
   index[0]=4;
 }
 
@@ -594,17 +642,16 @@ inline void  AliTPCParam::Transform6to8(Float_t *xyz, Int_t *index) const
   //
   //transforms cylindrical xyz coordinates to 'digit' coordinates
   //
-  
+  xyz[2]/=fZWidth;
   if  (index[1]<fNInnerSector) {    
     xyz[0]/=fInnerPadPitchLength;
     xyz[1]*=xyz[0]/fInnerPadPitchWidth;
-    xyz[2]/=fZWidth;
   }
-  else{   
-    xyz[0]/=fOuterPadPitchLength;
+  else{ 
     xyz[1]*=xyz[0]/fOuterPadPitchWidth;
-    xyz[2]/=fZWidth;
-  }        
+    if (index[2] < fNRowUp1 ) xyz[0]/=fOuter1PadPitchLength;
+    else xyz[0]/=fOuter2PadPitchLength;       
+  }
   index[0]=8;
 }
 
@@ -613,20 +660,17 @@ inline void  AliTPCParam::Transform8to6(Float_t *xyz, Int_t *index) const
   //
   //transforms 'digit' coordinates to cylindrical xyz coordinates 
   //
-  
+  xyz[2]*=fZWidth;
   if  (index[1]<fNInnerSector) {    
     xyz[0]*=fInnerPadPitchLength;
     xyz[1]/=xyz[0]/fInnerPadPitchWidth;
-    xyz[2]*=fZWidth;
   }
-  else{   
-    xyz[0]*=fOuterPadPitchLength;
-    xyz[1]/=xyz[0]/fOuterPadPitchWidth;
-    xyz[2]*=fZWidth;
-  }        
+  else{ 
+    xyz[1]/=xyz[0]/fOuterPadPitchWidth;  
+    if (index[2] < fNRowUp1 ) xyz[0]*=fOuter1PadPitchLength;
+    else xyz[0]*=fOuter2PadPitchLength;                
+  }  
   index[0]=6;
 }
 
-
-
 #endif  
index 055781ad07513025f7d0614ec256c25c9d7d4f5b..ebf1e2f323b44f5101b2f75ce1269c97c9abd17a 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.5  2001/01/26 19:57:22  hristov
+Major upgrade of AliRoot code
+
 Revision 1.4  2000/11/02 07:33:15  kowal2
 Improvements of the code.
 
@@ -64,7 +67,8 @@ AliTPCParamCR::AliTPCParamCR()
   //
   //constructor set the default parameters
   fInnerPRF=0;
-  fOuterPRF=0;
+  fOuter1PRF=0;
+  fOuter2PRF=0;
   fTimeRF = 0;
   fFacSigma = Float_t(2.);
   SetDefault();
@@ -76,7 +80,8 @@ AliTPCParamCR::~AliTPCParamCR()
   //
   //destructor destroy some dynmicaly alocated variables
   if (fInnerPRF != 0) delete fInnerPRF;
-  if (fOuterPRF != 0) delete fOuterPRF;
+  if (fOuter1PRF != 0) delete fOuter1PRF;
+  if (fOuter2PRF != 0) delete fOuter2PRF;
   if (fTimeRF != 0) delete fTimeRF;
 }
 
@@ -96,7 +101,7 @@ Int_t  AliTPCParamCR::CalcResponse(Float_t* xyz, Int_t * index, Int_t dummy)
   //we suppose that coordinata is expressed in float digits 
   // it's mean coordinate system 8
   //xyz[0] - float padrow xyz[1] is float pad  (center pad is number 0) and xyz[2] is float time bin
-  if ( (fInnerPRF==0)||(fOuterPRF==0)||(fTimeRF==0) ){ 
+  if ( (fInnerPRF==0)||(fOuter1PRF==0) ||(fOuter2PRF==0)||(fTimeRF==0) ){ 
     Error("AliTPCParamCR", "response function were not adjusted");
     return -1;
   }
@@ -108,8 +113,11 @@ Int_t  AliTPCParamCR::CalcResponse(Float_t* xyz, Int_t * index, Int_t dummy)
     sfpadrow =fFacSigma*fInnerPRF->GetSigmaY()/fInnerPadPitchLength;
     sfpad    =fFacSigma*fInnerPRF->GetSigmaX()/fInnerPadPitchWidth;
   }else{
-    sfpadrow =fFacSigma*fOuterPRF->GetSigmaY()/fOuterPadPitchLength;
-    sfpad    =fFacSigma*fOuterPRF->GetSigmaX()/fOuterPadPitchWidth;
+    if(index[2]<fNRowUp1){
+      sfpadrow =fFacSigma*fOuter1PRF->GetSigmaY()/fOuter1PadPitchLength;
+      sfpad    =fFacSigma*fOuter1PRF->GetSigmaX()/fOuterPadPitchWidth;}
+    else{ sfpadrow =fFacSigma*fOuter2PRF->GetSigmaY()/fOuter2PadPitchLength;
+    sfpad    =fFacSigma*fOuter2PRF->GetSigmaX()/fOuterPadPitchWidth;}
   }
 
   Int_t fpadrow = TMath::Nint(xyz[0]-sfpadrow);  //"first" padrow
@@ -129,9 +137,11 @@ Int_t  AliTPCParamCR::CalcResponse(Float_t* xyz, Int_t * index, Int_t dummy)
       Float_t dx = (xyz[1]-Float_t(pad));
       if (index[1]<fNInnerSector)
        padres[padrow-fpadrow][pad-fpad]=fInnerPRF->GetPRF(dx*fInnerPadPitchWidth,dy*fInnerPadPitchLength);
-      else
-       padres[padrow-fpadrow][pad-fpad]=fOuterPRF->GetPRF(dx*fOuterPadPitchWidth,dy*fOuterPadPitchLength);      
-    }
+      else{
+       if(index[2]<fNRowUp1){
+         padres[padrow-fpadrow][pad-fpad]=fOuter1PRF->GetPRF(dx*fOuterPadPitchWidth,dy*fOuter1PadPitchLength);}
+       else{ padres[padrow-fpadrow][pad-fpad]=fOuter2PRF->GetPRF(dx*fOuterPadPitchWidth,dy*fOuter2PadPitchLength);}}}     
+    
   //calculate time response function
 
   Int_t time;
@@ -194,49 +204,50 @@ void AliTPCParamCR::XYZtoCRXYZ(Float_t *xyz,
          
 Bool_t AliTPCParamCR::Update()
 {
-  
-  //
-  // update some calculated parameter which must be updated after changing "base"
-  // parameters 
-  // for example we can change size of pads and according this recalculate number
-  // of pad rows, number of of pads in given row ....
   Int_t i;
   if (AliTPCParam::Update()==kFALSE) return kFALSE;
   fbStatus = kFALSE;
 
-  // adjust lower sectors pad row positions and pad numbers 
-  fNRowLow   =  (Int_t(1.0001*(fRInnerLastWire-fRInnerFirstWire)/fInnerWWPitch)
-              -2*fInnerDummyWire)/fNInnerWiresPerPad;  
-  if ( kMaxRows<fNRowLow) fNRowUp = kMaxRows;
-  if (1>fNRowLow) return kFALSE;
-  Float_t firstpad = fRInnerFirstWire+(fInnerDummyWire-0.5)*fInnerWWPitch
-    +fInnerPadPitchLength/2.;
-      
-  for (i = 0;i<fNRowLow;i++) 
-    {
-       Float_t x  = firstpad +fInnerPadPitchLength*(Float_t)i;       
-       Float_t y = (x-0.5*fInnerPadPitchLength)*tan(fInnerAngle/2.)-fInnerFrameSpace-
-                   fInnerPadPitchWidth/2.;
-       fPadRowLow[i] = x;
-       fNPadsLow[i] = 1+2*(Int_t)(y/fInnerPadPitchWidth) ;
-       }
+ Float_t firstrow = fInnerRadiusLow + 2.225 ;   
+ for( i= 0;i<fNRowLow;i++)
+   {
+     Float_t x = firstrow + fInnerPadPitchLength*(Float_t)i;  
+     fPadRowLow[i]=x;
+     // number of pads per row
+/*Float_t y = (x-0.5*fInnerPadPitchLength)*tan(fInnerAngle/2.)-fInnerWireMount-
+       fInnerPadPitchWidth/2.;*/
+     Float_t y = x*tan(fInnerAngle/2.)-fInnerWireMount;
+     fYInner[i]=y;
+     fNPadsLow[i] = 1+2*(Int_t)(y/fInnerPadPitchWidth) ;
 
-  // adjust upper sectors pad row positions and pad numbers
-  fNRowUp   = (Int_t((fROuterLastWire-fROuterFirstWire+0.001)/fOuterWWPitch)
-              -2*fOuterDummyWire)/fNOuterWiresPerPad; 
-  if ( kMaxRows<fNRowUp) fNRowUp = kMaxRows;
-  if (1>fNRowUp) return kFALSE;
-  firstpad = fROuterFirstWire+(fOuterDummyWire-0.5)*fOuterWWPitch
-    +fOuterPadPitchLength/2.;
-  for (i = 0;i<fNRowUp;i++) 
-    {
-       Float_t x  = firstpad + fOuterPadPitchLength*(Float_t)i;      
-       Float_t y = (x-0.5*fOuterPadPitchLength)*tan(fOuterAngle/2.)-fOuterFrameSpace-
-                   fInnerPadPitchWidth/2.;
-       fPadRowUp[i] = x;
+   }
+ firstrow = fOuterRadiusLow + 1.6;
+ for(i=0;i<fNRowUp;i++)
+   {
+     if(i<fNRowUp1){
+       Float_t x = firstrow + fOuter1PadPitchLength*(Float_t)i; 
+       fPadRowUp[i]=x;
+/*Float_t y =(x-0.5*fOuter1PadPitchLength)*tan(fOuterAngle/2.)-fOuterWireMount-
+  fOuterPadPitchWidth/2.;*/
+       Float_t y = x*tan(fInnerAngle/2.)-fInnerWireMount;
        fNPadsUp[i] = 1+2*(Int_t)(y/fOuterPadPitchWidth) ;
-    }
+       fYOuter[i] = y;   
+       if(i==fNRowUp1-1) {
+           fLastWireUp1=fPadRowUp[i] +0.375;
+           firstrow = fPadRowUp[i] + 0.5*(fOuter1PadPitchLength+fOuter2PadPitchLength);
+       }
+     }
+     else
+       {
+        Float_t x = firstrow + fOuter2PadPitchLength*(Float_t)(i-64);
+/*Float_t y =(x-0.5*fOuter2PadPitchLength)*tan(fOuterAngle/2.)-fOuterWireMount-
+  fOuterPadPitchWidth/2.;*/
+        Float_t y = x*tan(fInnerAngle/2.)-fInnerWireMount;
+         fNPadsUp[i] = 1+2*(Int_t)(y/fOuterPadPitchWidth) ;
+        fYOuter[i] = y;
+       }
+   }   
+     
   fNtRows = fNInnerSector*fNRowLow+fNOuterSector*fNRowUp;
   fbStatus = kTRUE;
   return kTRUE;
index 9e72d02094be4ad66a18e7159d102b4eb5d41249..f307f79ca2629acbbd8421420bda1336305f3c75 100644 (file)
@@ -35,15 +35,18 @@ public:
   Bool_t Update();            //recalculate and check geometric parameters 
   void SetDefault();          //set default parameters
   void   SetInnerPRF(AliTPCPRF2D * prf) {fInnerPRF = prf;}
-  void   SetOuterPRF(AliTPCPRF2D * prf) {fOuterPRF = prf;}
+  void   SetOuter1PRF(AliTPCPRF2D * prf) {fOuter1PRF = prf;}
+  void   SetOuter2PRF(AliTPCPRF2D * prf) {fOuter2PRF = prf;}
   void   SetTimeRF(AliTPCRF1D * timerf) {fTimeRF = timerf;}
 
   AliTPCPRF2D * GetInnerPRF() const {return fInnerPRF;}
-  AliTPCPRF2D * GetOuterPRF() const {return fOuterPRF;}
+  AliTPCPRF2D * GetOuter1PRF() const {return fOuter1PRF;}
+  AliTPCPRF2D * GetOuter2PRF() const {return fOuter2PRF;}
   AliTPCRF1D  * GetTimeRF()   const {return fTimeRF;}
 protected:
   AliTPCPRF2D * fInnerPRF;         //!pad response function object for inner sector
-  AliTPCPRF2D * fOuterPRF;         //!pad response function object for inner sector  
+  AliTPCPRF2D * fOuter1PRF;         //!pad response function object for inner sector 
+  AliTPCPRF2D * fOuter2PRF;  
   AliTPCRF1D  * fTimeRF;           //!time response function object
   Float_t       fFacSigma;         //factor-how many sigma of response I accept
   ClassDef(AliTPCParamCR,1)  //parameter  object for set:TPC
index bb758fff41bbd1adab601540109aed81c67dc6dc..11b1f58ed133f7e53187adc7a7a5f00733ee3fa6 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.6  2002/02/25 11:02:56  kowal2
+Changes towards speeding up the code. Thanks to Marian Ivanov.
+
 Revision 1.5  2001/12/06 07:49:30  kowal2
 corrected number of pads calculation
 
@@ -75,7 +78,8 @@ AliTPCParamSR::AliTPCParamSR()
   //
   //constructor set the default parameters
   fInnerPRF=0;
-  fOuterPRF=0;
+  fOuter1PRF=0;
+  fOuter2PRF=0;
   fTimeRF = 0;
   fFacSigmaPadRow = Float_t(kFacSigmaPadRow);
   fFacSigmaPad = Float_t(kFacSigmaPad);
@@ -89,7 +93,8 @@ AliTPCParamSR::~AliTPCParamSR()
   //
   //destructor destroy some dynmicaly alocated variables
   if (fInnerPRF != 0) delete fInnerPRF;
-  if (fOuterPRF != 0) delete fOuterPRF;
+  if (fOuter1PRF != 0) delete fOuter1PRF;
+  if (fOuter2PRF != 0) delete fOuter2PRF;
   if (fTimeRF != 0) delete fTimeRF;
 }
 
@@ -109,7 +114,7 @@ Int_t  AliTPCParamSR::CalcResponse(Float_t* xyz, Int_t * index, Int_t row)
   //we suppose that coordinate is expressed in float digits 
   // it's mean coordinate system 8
   //xyz[0] - float padrow xyz[1] is float pad  (center pad is number 0) and xyz[2] is float time bin
-  if ( (fInnerPRF==0)||(fOuterPRF==0)||(fTimeRF==0) ){ 
+  if ( (fInnerPRF==0)||(fOuter1PRF==0)||(fOuter2PRF==0) ||(fTimeRF==0) ){ 
     Error("AliTPCParamSR", "response function was not adjusted");
     return -1;
   }
@@ -120,9 +125,15 @@ Int_t  AliTPCParamSR::CalcResponse(Float_t* xyz, Int_t * index, Int_t row)
   if (index[1]<fNInnerSector){
     sfpadrow =fFacSigmaPadRow*fInnerPRF->GetSigmaY()/fInnerPadPitchLength;
     sfpad    =fFacSigmaPad*fInnerPRF->GetSigmaX()/fInnerPadPitchWidth;
-  }else{
-    sfpadrow =fFacSigmaPadRow*fOuterPRF->GetSigmaY()/fOuterPadPitchLength;
-    sfpad    =fFacSigmaPad*fOuterPRF->GetSigmaX()/fOuterPadPitchWidth;
+  }
+  else{
+  if(row<fNRowUp1){
+    sfpadrow =fFacSigmaPadRow*fOuter1PRF->GetSigmaY()/fOuter1PadPitchLength;
+    sfpad    =fFacSigmaPad*fOuter1PRF->GetSigmaX()/fOuterPadPitchWidth;}
+    else{
+      sfpadrow =fFacSigmaPadRow*fOuter2PRF->GetSigmaY()/fOuter2PadPitchLength;
+      sfpad    =fFacSigmaPad*fOuter2PRF->GetSigmaX()/fOuterPadPitchWidth;
+    }   
   }
 
   Int_t fpadrow = TMath::Max(TMath::Nint(index[2]+xyz[0]-sfpadrow),0);  //"first" padrow
@@ -161,12 +172,15 @@ Int_t  AliTPCParamSR::CalcResponse(Float_t* xyz, Int_t * index, Int_t row)
   Int_t padrow, pad;
   for (padrow = fpadrow;padrow<=lpadrow;padrow++)
     for (pad = fpad;pad<=lpad;pad++){
-      Float_t dy = (-xyz[0]+Float_t(index[2]-padrow));
-      Float_t dx = (-xyz[1]+Float_t(pad));
+      Float_t dy = (xyz[0]+Float_t(index[2]-padrow));
+      Float_t dx = (xyz[1]+Float_t(pad));
       if (index[1]<fNInnerSector)
        padres[padrow-fpadrow][pad-fpad]=fInnerPRF->GetPRF(dx*fInnerPadPitchWidth,dy*fInnerPadPitchLength);
-      else
-       padres[padrow-fpadrow][pad-fpad]=fOuterPRF->GetPRF(dx*fOuterPadPitchWidth,dy*fOuterPadPitchLength);          }
+      else{
+       if(row<fNRowUp1){
+       padres[padrow-fpadrow][pad-fpad]=fOuter1PRF->GetPRF(dx*fOuterPadPitchWidth,dy*fOuter1PadPitchLength);}
+       else{
+         padres[padrow-fpadrow][pad-fpad]=fOuter2PRF->GetPRF(dx*fOuterPadPitchWidth,dy*fOuter2PadPitchLength);}}}
   //calculate time response function
   Int_t time;
   for (time = ftime;time<=ltime;time++) 
@@ -306,8 +320,10 @@ void AliTPCParamSR::GetClusterSize(Float_t *x, Int_t *index, Float_t *angle, Int
   if (GetTimeRF()!=0) sigma[0]+=GetTimeRF()->GetSigma()*GetTimeRF()->GetSigma();
   if ( (index[1]<fNInnerSector) &&(GetInnerPRF()!=0))   
     sigma[1]+=GetInnerPRF()->GetSigmaX()*GetInnerPRF()->GetSigmaX();
-  if ( (index[1]>=fNInnerSector) && (GetOuterPRF()!=0))
-    sigma[1]+=GetOuterPRF()->GetSigmaX()*GetOuterPRF()->GetSigmaX();
+  if ( (index[1]>=fNInnerSector) &&(index[2]<fNRowUp1) && (GetOuter1PRF()!=0))
+    sigma[1]+=GetOuter1PRF()->GetSigmaX()*GetOuter1PRF()->GetSigmaX();
+  if( (index[1]>=fNInnerSector) &&(index[2]>=fNRowUp1) && (GetOuter2PRF()!=0))
+    sigma[1]+=GetOuter2PRF()->GetSigmaX()*GetOuter2PRF()->GetSigmaX();
 
 
   sigma[0]/= GetZWidth()*GetZWidth();
@@ -350,57 +366,58 @@ Float_t * AliTPCParamSR::GetAnglesAccMomentum(Float_t *x, Int_t * index, Float_t
          
 Bool_t AliTPCParamSR::Update()
 {
-  
-  //
-  // update some calculated parameter which must be updated after changing "base"
-  // parameters 
-  // for example we can change size of pads and according this recalculate number
-  // of pad rows, number of of pads in given row ....
   Int_t i;
   if (AliTPCParam::Update()==kFALSE) return kFALSE;
   fbStatus = kFALSE;
 
-  // adjust lower sectors pad row positions and pad numbers 
-  fNRowLow   =  (Int_t(1.001+((fRInnerLastWire-fRInnerFirstWire)/fInnerWWPitch))
-              -2*fInnerDummyWire)/fNInnerWiresPerPad;  
-  if ( kMaxRows<fNRowLow) fNRowUp = kMaxRows;
-  if (1>fNRowLow) return kFALSE;
-  //Float_t firstpad = fRInnerFirstWire+(fInnerDummyWire-0.5)*fInnerWWPitch
-  //    +fInnerPadPitchLength/2.;
-  Float_t lastpad = fRInnerLastWire-(fInnerDummyWire-0.5)*fInnerWWPitch
-    -fInnerPadPitchLength/2.;
-  Float_t firstpad = lastpad-Float_t(fNRowLow-1)*fInnerPadPitchLength;  
-  for (i = 0;i<fNRowLow;i++) 
-    {
-       Float_t x  = firstpad +fInnerPadPitchLength*(Float_t)i;       
-       Float_t y = (x-0.5*fInnerPadPitchLength)*tan(fInnerAngle/2.)-fInnerWireMount-
-                   fInnerPadPitchWidth/2.;
-       fPadRowLow[i] = x;
-       fNPadsLow[i] = 1+2*(Int_t)(y/fInnerPadPitchWidth) ;
+ Float_t firstrow = fInnerRadiusLow + 2.225 ;   
+ for( i= 0;i<fNRowLow;i++)
+   {
+     Float_t x = firstrow + fInnerPadPitchLength*(Float_t)i;  
+     fPadRowLow[i]=x;
+     // number of pads per row
+     Float_t y = (x-0.5*fInnerPadPitchLength)*tan(fInnerAngle/2.)-fInnerWireMount-
+       fInnerPadPitchWidth/2.;
+     fYInner[i]  = x*tan(fInnerAngle/2.)-fInnerWireMount;
+     fNPadsLow[i] = 1+2*(Int_t)(y/fInnerPadPitchWidth) ;
+   }
+ firstrow = fOuterRadiusLow + 1.6;
+ for(i=0;i<fNRowUp;i++)
+   {
+     if(i<fNRowUp1){
+       Float_t x = firstrow + fOuter1PadPitchLength*(Float_t)i; 
+       fPadRowUp[i]=x;
+    Float_t y =(x-0.5*fOuter1PadPitchLength)*tan(fOuterAngle/2.)-fOuterWireMount-
+         fOuterPadPitchWidth/2.;
+     fYOuter[i]= x*tan(fOuterAngle/2.)-fOuterWireMount;
+     fNPadsUp[i] = 1+2*(Int_t)(y/fOuterPadPitchWidth) ;
+     if(i==fNRowUp1-1) {
+       fLastWireUp1=fPadRowUp[i] +0.375;
+       firstrow = fPadRowUp[i] + 0.5*(fOuter1PadPitchLength+fOuter2PadPitchLength);
+     }
+     }
+     else
+       {
+        Float_t x = firstrow + fOuter2PadPitchLength*(Float_t)(i-64);
+         fPadRowUp[i]=x;
+Float_t y =(x-0.5*fOuter2PadPitchLength)*tan(fOuterAngle/2.)-fOuterWireMount-
+          fOuterPadPitchWidth/2.;
+         fNPadsUp[i] = 1+2*(Int_t)(y/fOuterPadPitchWidth) ; 
        }
-
-  // adjust upper sectors pad row positions and pad numbers
-  fNRowUp   = (Int_t(1.001+((fROuterLastWire-fROuterFirstWire)/fOuterWWPitch))
-              -2*fOuterDummyWire)/fNOuterWiresPerPad; 
-  if ( kMaxRows<fNRowUp) fNRowUp = kMaxRows;
-  if (1>fNRowUp) return kFALSE;
-  firstpad = fROuterFirstWire+(fOuterDummyWire-0.5)*fOuterWWPitch
-    +fOuterPadPitchLength/2.;
-  for (i = 0;i<fNRowUp;i++) 
-    {
-       Float_t x  = firstpad + fOuterPadPitchLength*(Float_t)i;      
-       Float_t y = (x-0.5*fOuterPadPitchLength)*tan(fOuterAngle/2.)-fOuterWireMount-
-                   fOuterPadPitchWidth/2.;
-       fPadRowUp[i] = x;
-       fNPadsUp[i] = 1+2*(Int_t)(y/fOuterPadPitchWidth) ;
-    }
-  fNtRows = fNInnerSector*fNRowLow+fNOuterSector*fNRowUp;
-  fbStatus = kTRUE;
-  return kTRUE;
+     fYOuter[i]  = fPadRowUp[i]*tan(fOuterAngle/2.)-fOuterWireMount;
+   }
+ fNtRows = fNInnerSector*fNRowLow+fNOuterSector*fNRowUp;
+ fbStatus = kTRUE;
+ return kTRUE;
+}
+Float_t AliTPCParamSR::GetYInner(Int_t irow) const
+{
+  return fYInner[irow];
+}
+Float_t AliTPCParamSR::GetYOuter(Int_t irow) const
+{
+  return fYOuter[irow];
 }
-
 
 void AliTPCParamSR::Streamer(TBuffer &R__b)
 {
@@ -427,7 +444,7 @@ Int_t  AliTPCParamSR::CalcResponseFast(Float_t* xyz, Int_t * index, Int_t row)
   //we suppose that coordinate is expressed in float digits 
   // it's mean coordinate system 8
   //xyz[0] - float padrow xyz[1] is float pad  (center pad is number 0) and xyz[2] is float time bin
-  if ( (fInnerPRF==0)||(fOuterPRF==0)||(fTimeRF==0) ){ 
+  if ( (fInnerPRF==0)||(fOuter1PRF==0)||(fOuter2PRF==0) ||(fTimeRF==0) ){ 
     Error("AliTPCParamSR", "response function was not adjusted");
     return -1;
   }
@@ -442,8 +459,9 @@ Int_t  AliTPCParamSR::CalcResponseFast(Float_t* xyz, Int_t * index, Int_t row)
  
 
   static Float_t prfinner[2*padrn][5*padn];  //pad divided by 50
-  static Float_t prfouter[2*padrn][5*padn];  //prfouter division
-  
+  static Float_t prfouter1[2*padrn][5*padn];  //prfouter division
+  static Float_t prfouter2[2*padrn][5*padn];
+
   static Float_t rftime[5*timen];         //time division
   static Int_t blabla=0;
   static Float_t zoffset=0;
@@ -470,15 +488,21 @@ Int_t  AliTPCParamSR::CalcResponseFast(Float_t* xyz, Int_t * index, Int_t row)
        prfinner[j][i] =
          fInnerPRF->GetPRF((i-2.5*fpadn)/fpadn
                            *fInnerPadPitchWidth,(j-fpadrn)/fpadrn*fInnerPadPitchLength);
-       prfouter[j][i] =
-         fOuterPRF->GetPRF((i-2.5*fpadn)/fpadn
-                           *fOuterPadPitchWidth,(j-fpadrn)/fpadrn*fOuterPadPitchLength);
+       prfouter1[j][i] =
+         fOuter1PRF->GetPRF((i-2.5*fpadn)/fpadn
+                           *fOuterPadPitchWidth,(j-fpadrn)/fpadrn*fOuter1PadPitchLength);
+
+       //
+       prfouter2[j][i] =
+         fOuter2PRF->GetPRF((i-2.5*fpadn)/fpadn
+                           *fOuterPadPitchWidth,(j-fpadrn)/fpadrn*fOuter2PadPitchLength);
       }
     }      
-  }
+  } // the above is calculated only once
+
   // calculate central padrow, pad, time
-  Int_t npads = GetNPads(index[1],index[2]);
-  Int_t cpadrow = index[2];
+  Int_t npads = GetNPads(index[1],index[3]);
+  Int_t cpadrow = index[2]; // electrons are here
   Int_t cpad    = TMath::Nint(xyz[1]);
   Int_t ctime   = TMath::Nint(xyz[2]+zoffset2);
   //calulate deviation
@@ -504,9 +528,22 @@ Int_t  AliTPCParamSR::CalcResponseFast(Float_t* xyz, Int_t * index, Int_t row)
   Int_t ftime =  (ctime>1) ? -2: -ctime;
   Int_t ltime =  (ctime<maxt-2) ? 2: maxt-ctime-1;
 
-  Int_t apadrow= TMath::Nint((dpadrow-fpadrow)*fpadrn+fpadrn);
-  //Int_t apadrow= TMath::Nint((-dpadrow-fpadrow)*fpadrn+fpadrn);
-  
+  // cross talk from long pad to short one
+  if(row==fNRowUp1-1 && fpadrow==-1) {
+    dpadrow *= fOuter2PadPitchLength;
+    dpadrow += fOuterWWPitch;
+    dpadrow /= fOuter1PadPitchLength;
+  }    
+  // cross talk from short pad to long one
+  if(row==fNRowUp1 && fpadrow==1){ 
+    dpadrow *= fOuter1PadPitchLength;
+    if(dpadrow < -0.) dpadrow = -1.; //protection against 3rd wire
+    dpadrow += fOuterWWPitch;
+    dpadrow /= fOuter2PadPitchLength;
+    
+  }
+  // "normal"
+  Int_t apadrow = TMath::Nint((dpadrow-fpadrow)*fpadrn+fpadrn);
   for (Int_t ipadrow = fpadrow; ipadrow<=lpadrow;ipadrow++){
     if ( (apadrow<0) || (apadrow>=2*padrn)) 
       continue;
@@ -515,8 +552,12 @@ Int_t  AliTPCParamSR::CalcResponseFast(Float_t* xyz, Int_t * index, Int_t row)
        Float_t cweight;
        if (index[1]<fNInnerSector)
          cweight=prfinner[apadrow][apad];
-       else
-         cweight=prfouter[apadrow][apad];
+       else{
+         if(row < fNRowUp1)
+           cweight=prfouter1[apadrow][apad];
+          else cweight=prfouter2[apadrow][apad];
+       }
+
        //      if (cweight<fResponseThreshold) continue;
        Int_t atime = TMath::Nint((dtime-ftime)*ftimen+2.5*ftimen);
        for (Int_t itime = ftime;itime<=ltime;itime++){ 
index 6f78f91f9c360fe278706e04b3c322474af30727..31823efbd7311d18a2b6700e1e2ef9e9c44f488f 100644 (file)
@@ -40,16 +40,23 @@ public:
   Bool_t Update();            //recalculate and check geometric parameters 
   void SetDefault();          //set default parameters
   void   SetInnerPRF(AliTPCPRF2D * prf) {fInnerPRF = prf;}
-  void   SetOuterPRF(AliTPCPRF2D * prf) {fOuterPRF = prf;}
+  void   SetOuter1PRF(AliTPCPRF2D * prf) {fOuter1PRF = prf;} //e.k
+  void   SetOuter2PRF(AliTPCPRF2D * prf) {fOuter2PRF = prf;} //e.k
   void   SetTimeRF(AliTPCRF1D * timerf) {fTimeRF = timerf;}
 
   AliTPCPRF2D * GetInnerPRF() const {return fInnerPRF;}
-  AliTPCPRF2D * GetOuterPRF() const {return fOuterPRF;}
+  AliTPCPRF2D * GetOuter1PRF() const {return fOuter1PRF;} //e.k
+  AliTPCPRF2D * GetOuter2PRF() const {return fOuter2PRF;} //e.k
   AliTPCRF1D  * GetTimeRF()   const {return fTimeRF;}
   void SetFacSigmaPadRow(Float_t fac=3.) {fFacSigmaPadRow=fac;}
   void SetFacSigmaPad(Float_t fac=3.) {fFacSigmaPad=fac;}
   void SetFacSigmaTime(Float_t fac=3.) {fFacSigmaTime=fac;}
 
+  //  Float_t GetPadRowRadiiLow(Int_t irow) const;
+  //  Float_t GetPadRowRadiiUp(Int_t irow) const;
+  Float_t GetYInner(Int_t irow) const; //e,k
+  Float_t GetYOuter(Int_t irow) const; //e.k
+
   virtual Float_t GetPrimaryLoss(Float_t *x, Int_t *index, Float_t *angle);
   virtual Float_t GetTotalLoss(Float_t *x, Int_t *index, Float_t *angle);
 
@@ -59,8 +66,9 @@ public:
   virtual Float_t * GetAnglesAccMomentum(Float_t *x, Int_t * index, Float_t* momentum, Float_t *angle); 
  
 protected:
-  AliTPCPRF2D * fInnerPRF;         //pad response function object for inner sector
-  AliTPCPRF2D * fOuterPRF;         //pad response function object for inner sector  
+  AliTPCPRF2D * fInnerPRF;         //pad response function  for inner sector
+  AliTPCPRF2D * fOuter1PRF;        //pad response function  for outer sector  
+  AliTPCPRF2D * fOuter2PRF; 
   AliTPCRF1D  * fTimeRF;           //time response function object
   Float_t      fFacSigmaPadRow;    //factor-how many sigma of response I accept
   Float_t      fFacSigmaPad;       //factor-how many sigma of response I accept
index d5333698f06a26c29b686ab3ca42628cd76507a0..e090a96ab150dbaffbdab87e5275cc431a392310 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.16  2001/11/08 16:39:03  hristov
+Additional protection (M.Masera)
+
 Revision 1.15  2001/11/08 16:36:33  hristov
 Updated V2 stream of tracking (Yu.Belikov). The new long waited features are: 1) Possibility to pass the primary vertex position to the trackers (both for the TPC and the ITS) 2) Possibility to specify the number of tracking passes together with applying (or not applying) the vertex constraint (ITS only) 3) Possibility to make some use of partial PID provided by the TPC when doing tracking in the ITS (ITS only) 4) V0 reconstruction with a helix minimisation of the DCA. (new macros: AliV0FindVertices.C and AliV0Comparison.C) 4a) ( Consequence of the 4) )  All the efficiencies and resolutions are from now on calculated including *secondary*particles* too. (Don't be surprised by the drop in efficiency etc)
 
@@ -311,7 +314,8 @@ Int_t AliTPCtracker::FollowProlongation(AliTPCseed& t, Int_t rf) {
   if (alpha < 0.            ) alpha += 2.*TMath::Pi();  
   Int_t s=Int_t(alpha/fSectors->GetAlpha())%fN;
 
-  for (Int_t nr=fSectors->GetRowNumber(xt)-1; nr>=rf; nr--) {
+  Int_t nrows=fSectors->GetRowNumber(xt)-1;
+  for (Int_t nr=nrows; nr>=rf; nr--) {
     Double_t x=fSectors->GetX(nr), ymax=fSectors->GetMaxY(nr);
     if (!t.PropagateTo(x)) return 0;
 
@@ -924,11 +928,14 @@ void AliTPCtracker::AliTPCSector::Setup(const AliTPCParam *par, Int_t f) {
      fAlpha=par->GetOuterAngle();
      fAlphaShift=par->GetOuterAngleShift();
      fPadPitchWidth=par->GetOuterPadPitchWidth();
-     fPadPitchLength=par->GetOuterPadPitchLength();
+     f1PadPitchLength=par->GetOuter1PadPitchLength();
+     f2PadPitchLength=par->GetOuter2PadPitchLength();
 
      fN=par->GetNRowUp();
      fRow=new AliTPCRow[fN];
-     for (Int_t i=0; i<fN; i++) fRow[i].SetX(par->GetPadRowRadiiUp(i));
+     for (Int_t i=0; i<fN; i++){ 
+     fRow[i].SetX(par->GetPadRowRadiiUp(i));
+     }
   } 
 }
 
index 2c093b91245877b4de08fbac2224a4f7fa582a35..99adbf2e03a4ed380187fca02659ae375eb3ff02 100644 (file)
@@ -80,11 +80,24 @@ public:
      Double_t GetAlphaShift() const {return fAlphaShift;}
      Int_t GetRowNumber(Double_t x) const {
         //return pad row number for this x
-        Double_t r=fRow[fN-1].GetX();
-        if (x > r) return fN;
-        r=fRow[0].GetX();
-        if (x < r) return -1;
-        return Int_t((x-r)/fPadPitchLength + 0.5);
+       Double_t r;
+       if (fN < 63){
+        r=fRow[fN-1].GetX();
+        if (x > r) return fN;
+        r=fRow[0].GetX();
+        if (x < r) return -1;
+        return Int_t((x-r)/fPadPitchLength + 0.5);}
+       else{   
+          r=fRow[fN-1].GetX();
+          if (x > r) return fN;
+          r=fRow[0].GetX();
+          if (x < r) return -1;
+         Double_t r1=fRow[64].GetX();
+         if(x<r1){       
+           return Int_t((x-r)/f1PadPitchLength + 0.5);}
+         else{
+           return (Int_t((x-r1)/f2PadPitchLength + 0.5)+64);} 
+       }
      }
      Double_t GetPadPitchWidth()  const {return fPadPitchWidth;}
      Double_t GetPadPitchLength() const {return fPadPitchLength;}
@@ -95,7 +108,9 @@ public:
      Double_t fAlpha;                    //opening angle
      Double_t fAlphaShift;               //shift angle;
      Double_t fPadPitchWidth;            //pad pitch width
-     Double_t fPadPitchLength;           //pad pitch length    
+     Double_t fPadPitchLength;           //pad pitch length 
+     Double_t f1PadPitchLength;           //pad pitch length
+     Double_t f2PadPitchLength;   
    private:
      AliTPCSector(const AliTPCSector &s);           //dummy copy contructor
      AliTPCSector& operator=(const AliTPCSector &s);//dummy assignment operator