{
/// Constructor
- fSegmentation[1] = fSegmentation[0] = 0x0;
+ fkSegmentation[1] = fkSegmentation[0] = 0x0;
if (fPlot) fDebug = 1;
}
const AliMpVSegmentation* seg[2])
{
/// Prepare for clustering
-// AliCodeTimerAuto("")
+// AliCodeTimerAuto("",0)
for ( Int_t i = 0; i < 2; ++i )
{
- fSegmentation[i] = seg[i];
+ fkSegmentation[i] = seg[i];
}
// Find out the DetElemId
AliMUONClusterFinderMLEM::NextCluster()
{
/// Return next cluster
-// AliCodeTimerAuto("")
+// AliCodeTimerAuto("",0)
// if the list of clusters is not void, pick one from there
TObject* o = fClusterList.At(++fClusterNumber);
/// Starting from a precluster, builds a pixel array, and then
/// extract clusters from this array
- // AliCodeTimerAuto("")
+ // AliCodeTimerAuto("",0)
if (fDebug) {
cout << " *** Event # " << fEventNumber
/// Check precluster in order to attempt to simplify it (mostly for
/// two-cathode preclusters)
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
// Disregard small clusters (leftovers from splitting or noise)
if ((origCluster.Multiplicity()==1 || origCluster.Multiplicity()==2) &&
Int_t cath = pad->Cathode();
Int_t cath1 = TMath::Even(cath);
// Check for edge effect (missing pads on the _other_ cathode)
- AliMpPad mpPad = fSegmentation[cath1]->PadByPosition(pad->Position(),kFALSE);
+ AliMpPad mpPad =
+ fkSegmentation[cath1]->PadByPosition(pad->Position().X(),
+ pad->Position().Y(),kFALSE);
if (!mpPad.IsValid()) continue;
//if (nFlags == 1 && pad->Charge() < fgkZeroSuppression * 3) continue;
if (nFlags == 1 && pad->Charge() < 20) continue;
cout << " Surface = " << pixelI->Size(0)*pixelI->Size(1)*4 << endl;
pixelJ->Print();
cout << " Surface = " << pixelJ->Size(0)*pixelJ->Size(1)*4 << endl;
- cout << " Area surface = " << area.Dimensions().X()*area.Dimensions().Y()*4 << endl;
+ cout << " Area surface = " << area.GetDimensionX()*area.GetDimensionY()*4 << endl;
cout << "-------" << endl;
);
*/
if (cluster.Multiplicity(0) == 0) cath0 = 1;
else if (cluster.Multiplicity(1) == 0) cath1 = 0;
- TVector2 leftDown = cluster.Area(cath0).LeftDownCorner();
- TVector2 rightUp = cluster.Area(cath0).RightUpCorner();
- min[0] = leftDown.X();
- min[1] = leftDown.Y();
- max[0] = rightUp.X();
- max[1] = rightUp.Y();
+
+ Double_t leftDownX, leftDownY;
+ cluster.Area(cath0).LeftDownCorner(leftDownX, leftDownY);
+ Double_t rightUpX, rightUpY;
+ cluster.Area(cath0).RightUpCorner(rightUpX, rightUpY);
+ min[0] = leftDownX;
+ min[1] = leftDownY;
+ max[0] = rightUpX;
+ max[1] = rightUpY;;
if (cath1 != cath0) {
- leftDown = cluster.Area(cath1).LeftDownCorner();
- rightUp = cluster.Area(cath1).RightUpCorner();
- min[0] = TMath::Max (min[0], leftDown.X());
- min[1] = TMath::Max (min[1], leftDown.Y());
- max[0] = TMath::Min (max[0], rightUp.X());
- max[1] = TMath::Min (max[1], rightUp.Y());
+ cluster.Area(cath1).LeftDownCorner(leftDownX, leftDownY);
+ cluster.Area(cath1).RightUpCorner(rightUpX, rightUpY);
+ min[0] = TMath::Max (min[0], leftDownX);
+ min[1] = TMath::Max (min[1], leftDownY);
+ max[0] = TMath::Min (max[0], rightUpX);
+ max[1] = TMath::Min (max[1], rightUpY);
}
// Adjust limits
{
/// Repeat MLEM algorithm until pixel size becomes sufficiently small
- // AliCodeTimerAuto("")
+ // AliCodeTimerAuto("",0)
Int_t nPix = fPixArray->GetLast()+1;
//_____________________________________________________________________________
void AliMUONClusterFinderMLEM::Mlem(AliMUONCluster& cluster,
- Double_t* coef, Double_t* probi,
+ const Double_t* coef, Double_t* probi,
Int_t nIter)
{
/// Use MLEM to find pixel charges
}
//_____________________________________________________________________________
-Int_t AliMUONClusterFinderMLEM::FindNearest(AliMUONPad *pixPtr0)
+Int_t AliMUONClusterFinderMLEM::FindNearest(const AliMUONPad *pixPtr0)
{
/// Find the pixel nearest to the given one
/// (algorithm may be not very efficient)
//_____________________________________________________________________________
void AliMUONClusterFinderMLEM::FindCluster(AliMUONCluster& cluster,
- Int_t *localMax, Int_t iMax)
+ const Int_t *localMax, Int_t iMax)
{
/// Find pixel cluster around local maximum \a iMax and pick up pads
/// overlapping with it
Bool_t same = kFALSE;
if (TMath::Abs(dim0.Y()-dim1.Y()) < fgkDistancePrecision) same = kTRUE; // the same pad size on both planes
- AliMpIntPair cn;
+ Long_t cn;
Bool_t check[2] = {kFALSE, kFALSE};
Int_t nxy[2];
nxy[0] = nxy[1] = 0;
for (Int_t inb = 0; inb < 2; ++inb) {
cn = cluster.NofPads(nonb[inb], 0, kTRUE);
- if (inb == 0 && cn.GetFirst() == 2) check[inb] = kTRUE; // check non-bending plane
- else if (inb == 1 && cn.GetSecond() == 2) check[inb] = kTRUE; // check bending plane
+ if (inb == 0 && AliMp::PairFirst(cn) == 2) check[inb] = kTRUE; // check non-bending plane
+ else if (inb == 1 && AliMp::PairSecond(cn) == 2) check[inb] = kTRUE; // check bending plane
if (same) {
- nxy[0] = TMath::Max (nxy[0], cn.GetFirst());
- nxy[1] = TMath::Max (nxy[1], cn.GetSecond());
+ nxy[0] = TMath::Max (nxy[0], AliMp::PairFirst(cn));
+ nxy[1] = TMath::Max (nxy[1], AliMp::PairSecond(cn));
if (inb == 0 && nxy[0] < 2) nonb[inb] = !nonb[inb];
- else if (inb == 1 && cn.GetSecond() < 2) nonb[inb] = !nonb[inb];
+ else if (inb == 1 && AliMp::PairSecond(cn) < 2) nonb[inb] = !nonb[inb];
}
}
if (same) {
TVector2 pos;
if (inb == 0) pos.Set (pad->X() + idir * (pad->DX()+fgkDistancePrecision), pad->Y());
else pos.Set (pad->X(), pad->Y() + idir * (pad->DY()+fgkDistancePrecision));
- //AliMpPad mppad = fSegmentation[nonb[inb]]->PadByPosition(pos,kTRUE);
- AliMpPad mppad = fSegmentation[nonb[inb]]->PadByPosition(pos,kFALSE);
+ //AliMpPad mppad = fkSegmentation[nonb[inb]]->PadByPosition(pos,kTRUE);
+ AliMpPad mppad = fkSegmentation[nonb[inb]]->PadByPosition(pos.X(), pos.Y(),kFALSE);
if (!mppad.IsValid()) continue; // non-existing pad
- cn = mppad.GetIndices();
- AliMUONPad muonPad(fDetElemId, nonb[inb], cn.GetFirst(), cn.GetSecond(),
- mppad.Position().X(), mppad.Position().Y(),
- mppad.Dimensions().X(), mppad.Dimensions().Y(), 0);
+ AliMUONPad muonPad(fDetElemId, nonb[inb], mppad.GetIx(), mppad.GetIy(),
+ mppad.GetPositionX(), mppad.GetPositionY(),
+ mppad.GetDimensionX(), mppad.GetDimensionY(), 0);
if (inb == 0) muonPad.SetCharge(TMath::Min (amax[j]/100, 5.));
//else muonPad.SetCharge(TMath::Min (amax[j]/15, fgkZeroSuppression));
else muonPad.SetCharge(TMath::Min (amax[j]/15, 6.));
Bool_t mustMatch(kTRUE);
- AliMpIntPair cn = cluster.NofPads(statusToTest,mustMatch);
+ Long_t cn = cluster.NofPads(statusToTest,mustMatch);
- nInX = cn.GetFirst();
- nInY = cn.GetSecond();
+ nInX = AliMp::PairFirst(cn);
+ nInY = AliMp::PairSecond(cn);
}
//_____________________________________________________________________________
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff