special matrix, see Config.C of this revision.
2) The shift is automatically corrected for during the clusterization.
3) Added to AliITSUClusterizer (via recoparam) layer-wise option
to allow clusters made of pixels with common corners (but not sides), in order
to decrease the cluster splitting, see testITSU/MakeITSRecoParam.C of this rev.
4) testITSU/itsupcdb.tar.gz is updated with recoparam obj. allowing diagonal
clusters on all layers
//______________________________________________________________________________
AliITSUClusterizer::AliITSUClusterizer(Int_t initNRow)
: fVolID(-1)
+ ,fAllowDiagonalClusterization(kFALSE)
,fSegm(0)
,fRecoParam(0)
,fInputDigits(0)
int charge=0;
for (AliITSUClusterizerClusterDigit *idigit=cand->fFirstDigit;idigit;idigit=idigit->fNext) {
AliITSdigit* dig = idigit->fDigit;
- fSegm->DetToLocal(dig->GetCoord2(),dig->GetCoord1(),cx,cz);
+ fSegm->DetToLocal(dig->GetCoord2(),dig->GetCoord1(),cx,cz); // center of pixel
+ //
+ // account for possible diod shift
+ double ddx,ddz, dx=fSegm->Dpx(dig->GetCoord2()), dz=fSegm->Dpz(dig->GetCoord1());
+ fSegm->GetDiodShift(dig->GetCoord2(),dig->GetCoord1(),ddx,ddz);
+ //
charge += dig->GetSignal();
x += cx;
z += cz;
if (cx>xmx) xmx=cx;
if (cz<zmn) zmn=cz;
if (cz>zmx) zmx=cz;
- px += fSegm->Dpx(dig->GetCoord2());
- pz += fSegm->Dpz(dig->GetCoord1());
+ x += ddx*dx;
+ z += ddz*dz;
+ px += dx;
+ pz += dz;
//
if (!fRawData) {
for(Int_t dlab=0;dlab<maxLbinDigit;dlab++){
lastV=iDigit->fDigit->GetCoord2();
}
// skip cluster parts before this digit
- while (iPrevRow && iPrevRow->fUEnd<iDigit->fDigit->GetCoord1()) {
+ int limCol = iDigit->fDigit->GetCoord1()-fAllowDiagonalClusterization;
+ while (iPrevRow && iPrevRow->fUEnd < limCol) {
iPrevRow=iPrevRow->fNextInRow;
}
// find the longest continous line of digits [iDigit,pDigit]=[iDigit,jDigit)
AttachDigitToCand(cand,pDigit);
++lastU1;
}
- --lastU1;
+ if (!fAllowDiagonalClusterization) --lastU1;
AliITSUClusterizerClusterPart *part=AllocPart();
part->fUBegin=lastU ;
part->fUEnd =lastU1;
void SetLayerID(Int_t id) {fLayerID = id;}\r
void SetVolID(Int_t id) {fVolID = id;}\r
void SetNRow(Int_t nrow);\r
+ void SetAllowDiagonalClusterization(Bool_t v) {fAllowDiagonalClusterization = v;}\r
void PrepareLorentzAngleCorrection(Double_t bz);\r
//\r
// interface methods\r
AliCluster* NextCluster() {return (AliCluster*)fOutputClusters->New(fOutputClusters->GetEntriesFast());}\r
\r
// modifiers\r
+ void SetAllowDiagonalClusterization();\r
+\r
void AttachDigitToCand(AliITSUClusterizerClusterCand *cand,AliITSUClusterizerClusterDigit *digit);\r
void AttachPartToCand(AliITSUClusterizerClusterCand *cand,AliITSUClusterizerClusterPart *part);\r
void DetachPartFromCand(AliITSUClusterizerClusterCand *cand,AliITSUClusterizerClusterPart *part);\r
protected:\r
//\r
Int_t fVolID; // Volume id (module index)\r
+ Bool_t fAllowDiagonalClusterization; // allow clusters with pixels having common corners only\r
const AliITSUSegmentationPix* fSegm; // Segmentation or local coord calc.\r
const AliITSURecoParam* fRecoParam; // reco params\r
//\r
if (!gm) AliFatal("NULL pointer to the geometry!");
return gm->GetModIdInLadder(fModule);
}
+
+//______________________________________________________________________
+void AliITSUHit::Print(Option_t *option) const
+{
+ // print itself
+ printf("Mod%4d Tr:%5d DE:%.2e TOF: %.3e| P:%.3f %.3f %.3f |>%.4f %.4f %.4f >%.4f %.4f %.4f\n",
+ fModule,fTrack,fDestep,fTof,fPx,fPy,fPz, fx0,fy0,fz0,fX,fY,fZ);
+
+}
virtual void GetPositionL(Double_t &x,Double_t &y,Double_t &z,Double_t &t) {Float_t xf,yf,zf,tf;GetPositionL(xf,yf,zf,tf);x=xf,y=yf;z=zf;t=tf;}
virtual void GetPositionL(Double_t &x,Double_t &y,Double_t &z) {Float_t xf,yf,zf,tf;GetPositionL(xf,yf,zf,tf);x=xf,y=yf;z=zf;}
virtual void GetPositionL0(Double_t &x,Double_t &y,Double_t &z,Double_t &t);
-
+ //
+ virtual void Print(Option_t *option="") const;
//
protected:
const Double_t AliITSURecoParam::fgkMaxTr2ClChi2 = 15.;
const Double_t AliITSURecoParam::fgkTanLorentzAngle = 0;
const Double_t AliITSURecoParam::fgkMissPenalty = 2.0;
+const Bool_t AliITSURecoParam::fgkAllowDiagonalClusterization = kFALSE;
//
// hardwired params for TPC-ITS border layer
const Double_t AliITSURecoParam::fgkTPCITSWallRMin = 50.;
,fTPCITSWallZSpanH(fgkTPCITSWallZSpanH)
,fTPCITSWallMaxStep(fgkTPCITSWallMaxStep)
//
+ ,fAllowDiagonalClusterization(0)
,fTanLorentzAngle(0)
,fSigmaY2(0)
,fSigmaZ2(0)
,fTPCITSWallZSpanH(fgkTPCITSWallZSpanH)
,fTPCITSWallMaxStep(fgkTPCITSWallMaxStep)
//
+ ,fAllowDiagonalClusterization(0)
,fTanLorentzAngle(0)
,fSigmaY2(0)
,fSigmaZ2(0)
delete[] fSigmaZ2;
delete[] fMaxTr2ClChi2;
delete[] fMissPenalty;
+ delete[] fAllowDiagonalClusterization;
fTrackingConditions.Delete();
}
fSigmaZ2 = new Double_t[n];
fMaxTr2ClChi2 = new Double_t[n];
fMissPenalty = new Double_t[n];
+ fAllowDiagonalClusterization = new Bool_t[n];
//
for (int i=n;i--;) {
+ fAllowDiagonalClusterization[i] = fgkAllowDiagonalClusterization;
fTanLorentzAngle[i] = fgkTanLorentzAngle;
fSigmaY2[i] = fgkSigmaRoadY*fgkSigmaRoadY;
fSigmaZ2[i] = fgkSigmaRoadZ*fgkSigmaRoadZ;
fMaxTr2ClChi2[lr] = v;
}
+//_____________________________________________________________________________
+void AliITSURecoParam::SetMissPenalty(Int_t lr, Double_t v)
+{
+ // set Lorentz angle value
+ if (lr>=fNLayers) AliFatal(Form("Number of defined layers is %d",fNLayers));
+ fMissPenalty[lr] = v;
+}
+
+//_____________________________________________________________________________
+void AliITSURecoParam::SetAllowDiagonalClusterization(Int_t lr, Bool_t v)
+{
+ // set Lorentz angle value
+ if (lr>=fNLayers) AliFatal(Form("Number of defined layers is %d",fNLayers));
+ fAllowDiagonalClusterization[lr] = v;
+}
+
//========================================================================
//_____________________________________________________________________________
void AliITSURecoParam::Print(Option_t *) const
Double_t GetSigmaZ2(Int_t lr) const;
Double_t GetMaxTr2ClChi2(Int_t lr) const;
Double_t GetMissPenalty(Int_t lr) const;
+ Bool_t GetAllowDiagonalClusterization(Int_t lr) const;
//
Double_t GetNSigmaRoadY() const {return fNSigmaRoadY;}
Double_t GetNSigmaRoadZ() const {return fNSigmaRoadZ;}
void SetSigmaZ2(Int_t lr, Double_t v);
void SetMaxTr2ClChi2(Int_t lr, Double_t v);
void SetMissPenalty(Int_t lr, Double_t v);
+ void SetAllowDiagonalClusterization(Int_t lr, Bool_t v);
//
void SetMaxDforV0dghtrForProlongation(Double_t v) {fMaxDforV0dghtrForProlongation = v;}
void SetMaxDForProlongation(Double_t v) {fMaxDForProlongation = v;}
Double_t fTPCITSWallZSpanH; // half Z span
Double_t fTPCITSWallMaxStep; // max tracking step
//
+ Bool_t* fAllowDiagonalClusterization; //[fNLayers] allow clusters of pixels with common corners only
Double_t* fTanLorentzAngle; //[fNLayers] Optional Lorentz angle for each layer
Double_t* fSigmaY2; //[fNLayers] addition to road width^2
Double_t* fSigmaZ2; //[fNLayers] addition to road width^2
static const Double_t fgkTPCITSWallZSpanH; // half Z span
static const Double_t fgkTPCITSWallMaxStep; // max tracking step
//
+ // clusterization options
+ static const Bool_t fgkAllowDiagonalClusterization; // clusters of pixels with common corners
+ //
private:
AliITSURecoParam(const AliITSURecoParam & param);
AliITSURecoParam & operator=(const AliITSURecoParam ¶m);
- ClassDef(AliITSURecoParam,1) // ITS reco parameters
+ ClassDef(AliITSURecoParam,2) // ITS reco parameters
};
//_____________________________________________________________________________
return (lr<fNLayers)&&fMissPenalty ? fMissPenalty[lr]:fgkMissPenalty; //0;
}
+//_____________________________________________________________________________
+inline Bool_t AliITSURecoParam::GetAllowDiagonalClusterization(Int_t lr) const
+{
+ // are diagonal clusters permitted
+ return (lr<fNLayers)&&fAllowDiagonalClusterization ? fAllowDiagonalClusterization[lr]:fgkAllowDiagonalClusterization;
+}
+
#endif
double bz = 0;
if (field == 0) AliError("Cannot get magnetic field from TGeoGlobalMagField");
else bz = field->SolenoidField();
+ const AliITSURecoParam* recPar = GetRecoParam();
//
for (int ilr=0;ilr<fGeom->GetNLayers();ilr++) {
//
clFinder->SetSegmentation((AliITSUSegmentationPix*)fGeom->GetSegmentation(ilr));
clFinder->SetLayerID(ilr);
clFinder->SetClusters(fClusters[ilr]);
- clFinder->SetRecoParam(GetRecoParam()); // RS: Do we need to set it for every event?
+ clFinder->SetRecoParam(recPar); // RS: Do we need to set it for every event?
+ clFinder->SetAllowDiagonalClusterization(recPar->GetAllowDiagonalClusterization(ilr));
clFinder->PrepareLorentzAngleCorrection(bz);
//
int modF=fGeom->GetFirstModIndex(ilr);
,fNColPerChip(nchips>0 ? ncol/nchips:0)
,fNRow(nrow)
,fNCol(ncol)
+ ,fDiodShiftMatNCol(0)
+ ,fDiodShiftMatNRow(0)
+ ,fDiodShiftMatDim(0)
+ ,fDiodShidtMatX(0)
+ ,fDiodShidtMatZ(0)
{
// Default constructor, sizes in cm
if (nchips) SetUniqueID( AliITSUGeomTGeo::ComposeDetTypeID(id) );
fGuardRgt = src.fGuardRgt;
fGuardLft = src.fGuardLft;
//
+ fDiodShiftMatNCol = src.fDiodShiftMatNCol;
+ fDiodShiftMatNRow = src.fDiodShiftMatNRow;
+ fDiodShiftMatDim = src.fDiodShiftMatDim;
+ delete fDiodShidtMatX; fDiodShidtMatX = 0;
+ delete fDiodShidtMatZ; fDiodShidtMatZ = 0;
+ if (fDiodShiftMatDim) {
+ fDiodShidtMatX = new Double32_t[fDiodShiftMatDim];
+ fDiodShidtMatZ = new Double32_t[fDiodShiftMatDim];
+ for (int i=fDiodShiftMatDim;i--;) {
+ fDiodShidtMatX[i] = src.fDiodShidtMatX[i];
+ fDiodShidtMatZ[i] = src.fDiodShidtMatZ[i];
+ }
+ }
+ //
return *this;
}
,fNColPerChip(src.fNColPerChip)
,fNRow(src.fNRow)
,fNCol(src.fNCol)
+ ,fDiodShiftMatNCol(src.fDiodShiftMatNCol)
+ ,fDiodShiftMatNRow(src.fDiodShiftMatNRow)
+ ,fDiodShiftMatDim(src.fDiodShiftMatDim)
+ ,fDiodShidtMatX(0)
+ ,fDiodShidtMatZ(0)
{
+ // copy constructor
+ if (fDiodShiftMatDim) {
+ fDiodShidtMatX = new Double32_t[fDiodShiftMatDim];
+ fDiodShidtMatZ = new Double32_t[fDiodShiftMatDim];
+ for (int i=fDiodShiftMatDim;i--;) {
+ fDiodShidtMatX[i] = src.fDiodShidtMatX[i];
+ fDiodShidtMatZ[i] = src.fDiodShidtMatZ[i];
+ }
+ }
}
//____________________________________________________________________________RS
delete arr;
//
}
+
+//______________________________________________________________________
+void AliITSUSegmentationPix::SetDiodShiftMatrix(Int_t nrow,Int_t ncol, const Double_t *shiftX, const Double_t *shiftZ)
+{
+ // set matrix of periodic shifts of diod center. provided arrays must be in the format shift[nrow][ncol]
+ if (fDiodShiftMatDim) {
+ delete fDiodShidtMatX;
+ delete fDiodShidtMatZ;
+ fDiodShidtMatX = fDiodShidtMatZ = 0;
+ }
+ //
+ fDiodShiftMatNCol = ncol;
+ fDiodShiftMatNRow = nrow;
+ fDiodShiftMatDim = fDiodShiftMatNCol*fDiodShiftMatNRow;
+ if (fDiodShiftMatDim) {
+ fDiodShidtMatX = new Double32_t[fDiodShiftMatDim];
+ fDiodShidtMatZ = new Double32_t[fDiodShiftMatDim];
+ for (int ir=0;ir<fDiodShiftMatNRow;ir++) {
+ for (int ic=0;ic<fDiodShiftMatNCol;ic++) {
+ int cnt = ic+ir*fDiodShiftMatNCol;
+ fDiodShidtMatX[cnt] = shiftX ? shiftX[cnt] : 0.;
+ fDiodShidtMatZ[cnt] = shiftZ ? shiftZ[cnt] : 0.;
+ }
+ }
+ }
+
+}
+
+//______________________________________________________________________
+void AliITSUSegmentationPix::Print(Option_t* option) const
+{
+ // print itself
+ const double kmc=1e4;
+ printf("Segmentation %d: Size: DX: %.1f DZ: %.1f DY: %.1f | Pitch: X:%.1f Z:%.1f\n",
+ GetUniqueID(),kmc*Dx(),kmc*Dy(),kmc*Dz(),kmc*Dpx(1),kmc*Dpz(1));
+ printf("%d chips along Z: chip Ncol=%d Nrow=%d\n",fNChips, fNColPerChip,fNRow);
+ if (Abs(fPitchZLftCol-fPitchZ)>1e-5) printf("Special left column pitch: %.1f\n",fPitchZLftCol*kmc);
+ if (Abs(fPitchZRgtCol-fPitchZ)>1e-5) printf("Special right column pitch: %.1f\n",fPitchZRgtCol*kmc);
+ printf("Guard-rings: Left: %.1f Right: %.1f Top: %.1f Bottom: %.1f\n",kmc*fGuardLft,kmc*fGuardRgt,kmc*fGuardTop,kmc*fGuardBot);
+ //
+ if (fDiodShiftMatDim) {
+ double dx,dz=0;
+ printf("Diod shift periodicity pattern (X,Z[row][col])\n");
+ for (int irow=0;irow<fDiodShiftMatNRow;irow++) {
+ for (int icol=0;icol<fDiodShiftMatNCol;icol++) {
+ GetDiodShift(irow,icol,dx,dz);
+ printf("%.1f/%.1f |",kmc*dx,kmc*dz);
+ }
+ printf("\n");
+ }
+ }
+}
+
+//______________________________________________________________________
+void AliITSUSegmentationPix::GetDiodShift(Int_t row,Int_t col, Float_t &dx,Float_t &dz) const
+{
+ // obtain optional diod shift
+ if (!fDiodShiftMatDim) {dx=dz=0; return;}
+ int cnt = (col%fDiodShiftMatNCol) + (row%fDiodShiftMatNRow)*fDiodShiftMatNCol;
+ dx = fDiodShidtMatX[cnt];
+ dz = fDiodShidtMatZ[cnt];
+ //
+}
virtual void Neighbours(Int_t iX,Int_t iZ,Int_t* Nlist,Int_t Xlist[10],Int_t Zlist[10]) const;
//
virtual void PrintDefaultParameters() const {AliWarning("No def. parameters defined as const static data members");}
+ virtual void Print(Option_t* option = "") const;
//
virtual Int_t GetDetTypeID() const {return GetUniqueID();}
//
+ void SetDiodShiftMatrix(Int_t nrow,Int_t ncol, const Double_t *shiftX, const Double_t *shiftZ);
+ void GetDiodShift(Int_t row,Int_t col, Float_t &dx,Float_t &dz) const;
+ void GetDiodShift(Int_t row,Int_t col, Double_t &dx,Double_t &dz) const {float dxf,dzf; GetDiodShift(row,col,dxf,dzf); dx=dxf; dz=dzf; }
+ //
Bool_t Store(const char* outf);
static AliITSUSegmentationPix* LoadWithID(UInt_t id, const char* inpf);
static void LoadSegmentations(TObjArray* dest, const char* inpf);
Int_t fNRow; // number of rows
Int_t fNCol; // number of columns (total)
//
+ Int_t fDiodShiftMatNCol; // periodicity of diod shift in columns
+ Int_t fDiodShiftMatNRow; // periodicity of diod shift in rows
+ Int_t fDiodShiftMatDim; // dimension of diod shift matrix
+ Double32_t* fDiodShidtMatX; //[fDiodShiftMatDim] diod shift in X (along column), in fraction of X pitch
+ Double32_t* fDiodShidtMatZ; //[fDiodShiftMatDim] diod shift in Z (along row), in fraction of Z pitch
+ //
static const char* fgkSegmListName; // pattern for segmentations list name
//
- ClassDef(AliITSUSegmentationPix,1) //Segmentation class upgrade pixels
+ ClassDef(AliITSUSegmentationPix,2) //Segmentation class upgrade pixels
};
//
fSeg->DetToLocal(ix,iz,x,z); // pixel center
xdioshift = zdioshift = 0;
+ double dxi = fSeg->Dpx(ix);
+ double dzi = fSeg->Dpz(iz);
CalcDiodeShiftInPixel(ix,iz,xdioshift,zdioshift); // Check and apply diode shift if needed
- double dxi = 0.5*fSeg->Dpx(ix);
- double dzi = 0.5*fSeg->Dpz(iz);
+ xdioshift *= dxi;
+ zdioshift *= dzi;
+ dxi *= 0.5;
+ dzi *= 0.5;
+ // printf("DShift: %d %d -> %.4f %.4f\n",ix,iz,xdioshift,zdioshift);
x1 = (x + xdioshift) - x0; // calculate distance of cell boundaries from injection center
z1 = (z + zdioshift) - z0;
x2 = x1 + dxi; // Upper
}
//_______________________________________________________________________
-void AliITSUSimulationPix::CalcDiodeShiftInPixel(Int_t xlin, Int_t zcol, Float_t &x, Float_t &)
+void AliITSUSimulationPix::CalcDiodeShiftInPixel(Int_t xrow, Int_t zcol, Float_t &x, Float_t &z)
{
//
// Calculates the shift of the diode wrt the geometric center of the pixel.
// The shift can depend on the column or line or both...
// The x and z are passed in cm
//
-
- TString parTitle = fResponseParam->GetTitle();
-
- // M32terP31 is staggered the diode shift within pixel depends on the column
- if ( parTitle.Contains("M32terP31") )
- {
- if ( zcol%2 == 0 ) x += 0.30 * fSeg->Dpx(xlin);
- else x -= 0.19 * fSeg->Dpx(xlin);
- }
-
-
+ ((AliITSUSegmentationPix*)fSeg)->GetDiodShift(xrow,zcol,x,z);
+ //
}
//_______________________________________________________________________
Int_t GetReadOutCycle(Int_t row, Int_t col, Double_t hitTime);
Int_t GetReadOutCycleRollingShutter(Int_t row, Int_t col, Double_t hitTime);
//
- void CalcDiodeShiftInPixel(Int_t xlin, Int_t zcol, Float_t &x, Float_t &z);
+ void CalcDiodeShiftInPixel(Int_t xrow, Int_t zcol, Float_t &x, Float_t &z);
//
private:
void SpreadCharge2D(Double_t x0,Double_t z0, Double_t dy, Int_t ix0,Int_t iz0,
if (generatorFlag==0) {
// Fast generator with parametrized pi,kaon,proton distributions
- int nParticles = 30;//14022;
+ int nParticles = 100;//14022;
AliGenHIJINGpara *gener = new AliGenHIJINGpara(nParticles);
gener->SetMomentumRange(0.1, 10.);
gener->SetPhiRange(0., 360.);
{
//=================== ITS parameters ============================
//
+ const int kDiodShift_NCol_M32terP31 = 2;
+ const int kDiodShift_NRow_M32terP31 = 1;
+
+ const double kDiodShiftM32terP31X[ kDiodShift_NCol_M32terP31 ][ kDiodShift_NRow_M32terP31 ] = {0.30,-0.19};
+ const double kDiodShiftM32terP31Z[ kDiodShift_NCol_M32terP31 ][ kDiodShift_NRow_M32terP31 ] = {0.0 , 0.0 };
// create segmentations:
AliITSUSegmentationPix* seg0 = new AliITSUSegmentationPix(0, // segID (0:9)
5, // chips per module
20.e-4, // default col pitch in cm
18.e-4 // sensor thickness in cm
); // see AliITSUSegmentationPix.h for extra options
+ seg0->SetDiodShiftMatrix(kDiodShift_NRow_M32terP31,kDiodShift_NCol_M32terP31, &kDiodShiftM32terP31X[0][0], &kDiodShiftM32terP31Z[0][0]);
seg0->Store(AliITSUGeomTGeo::GetITSsegmentationFileName());
AliITSUSegmentationPix* seg1 = new AliITSUSegmentationPix(1, // segID (0:9)
5*2, // chips per module
20.e-4, // default col pitch in cm
18.e-4 // sensor thickness in cm
); // see AliITSUSegmentationPix.h for extra options
+ seg1->SetDiodShiftMatrix(kDiodShift_NRow_M32terP31,kDiodShift_NCol_M32terP31, &kDiodShiftM32terP31X[0][0], &kDiodShiftM32terP31Z[0][0]);
seg1->Store(AliITSUGeomTGeo::GetITSsegmentationFileName());
AliITSUSegmentationPix* seg2 = new AliITSUSegmentationPix(2, // segID (0:9)
5*2, // chips per module
20.e-4, // default col pitch in cm
18.e-4 // sensor thickness in cm
); // see AliITSUSegmentationPix.h for extra options
+ seg2->SetDiodShiftMatrix(kDiodShift_NRow_M32terP31,kDiodShift_NCol_M32terP31, &kDiodShiftM32terP31X[0][0], &kDiodShiftM32terP31Z[0][0]);
seg2->Store(AliITSUGeomTGeo::GetITSsegmentationFileName());
//
int nmod,nlad; // modules per ladded, n ladders
recoParamArray->AddLast(itsRecoParam);
}
//
+ int nBranch[7] = {3,3,3,3,3,3,3}; // max branching for the seed on layer
+ int nCands[7] = {250,200,150,100,60,40,20}; // max branching for the TPC seed
+ //
{
AliITSURecoParam * itsRecoParam = AliITSURecoParam::GetLowFluxParam();
- int nBranch[7] = {3,3,3,3,3,3,3}; // max branching for the seed on layer
- int nCands[7] = {250,200,150,100,60,40,20}; // max branching for the TPC seed
//
itsRecoParam->SetNLayers(nLr);
//
itsRecoParam->SetTitle("LowMult");
recoParamArray->AddLast(itsRecoParam);
//******************************************************************
+ for (int i=0;i<nLr;i++) itsRecoParam->SetAllowDiagonalClusterization(i,kTRUE);
+ //
// Add tracking conditions >>>
trCond = new AliITSUTrackCond();
trCond->SetNLayers(nLr);
trCond->AddGroupPattern( kBit5|kBit6 );
//
itsRecoParam->AddTrackingCondition(trCond);
- // Add tracking conditions >>>
+ // Add tracking conditions <<<
}
{
AliITSURecoParam * itsRecoParam = AliITSURecoParam::GetHighFluxParam();
- for (int i=0;i<nLr;i++) trCond->SetMaxBranches(i,nBranch[i]);
- for (int i=0;i<nLr;i++) trCond->SetMaxCandidates(i,nCands[i]);
//
itsRecoParam->SetNLayers(nLr);
//
itsRecoParam->SetTitle("HighMult");
recoParamArray->AddLast(itsRecoParam);
//******************************************************************
+ for (int i=0;i<nLr;i++) itsRecoParam->SetAllowDiagonalClusterization(i,kTRUE);
+ //
// Add tracking conditions >>>
trCond = new AliITSUTrackCond();
trCond->SetNLayers(nLr);
trCond->AddGroupPattern( kBit5|kBit6 );
//
itsRecoParam->AddTrackingCondition(trCond);
- // Add tracking conditions >>>
+ // Add tracking conditions <<<
//
}
//
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff