/**************************************************************************
- * Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
+ * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
* *
* Author: The ALICE Off-line Project. *
* Contributors are mentioned in the code where appropriate. *
* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
+
+/* $Id$ */
+
////////////////////////////////////////////////////////////////////////////
// Implementation of the ITS clusterer V2 class //
// //
// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch //
+// Revised: Enrico Fragiacomo, enrico.fragiacomo@ts.infn.it //
// //
///////////////////////////////////////////////////////////////////////////
+#include <Riostream.h>
+
#include "AliITSClusterFinderV2SSD.h"
#include "AliITSRecPoint.h"
#include "AliITSdigitSSD.h"
#include "AliITSCalibrationSSD.h"
+Short_t *AliITSClusterFinderV2SSD::fgPairs = 0x0;
+Int_t AliITSClusterFinderV2SSD::fgPairsSize = 0;
+
ClassImp(AliITSClusterFinderV2SSD)
}
+//______________________________________________________________________
+AliITSClusterFinderV2SSD::AliITSClusterFinderV2SSD(const AliITSClusterFinderV2SSD &cf) : AliITSClusterFinderV2(cf), fLastSSD1(cf.fLastSSD1),
+fYpitchSSD(cf.fYpitchSSD),
+fHwSSD(cf.fHwSSD),
+fHlSSD(cf.fHlSSD),
+fTanP(cf.fTanP),
+fTanN(cf.fTanN)
+{
+ // Copy constructor
+
+}
+
+//______________________________________________________________________
+AliITSClusterFinderV2SSD& AliITSClusterFinderV2SSD::operator=(const AliITSClusterFinderV2SSD& cf ){
+ // Assignment operator
+
+ this->~AliITSClusterFinderV2SSD();
+ new(this) AliITSClusterFinderV2SSD(cf);
+ return *this;
+}
+
void AliITSClusterFinderV2SSD::FindRawClusters(Int_t mod){
Int_t smaxall=alldigits->GetEntriesFast();
if (smaxall==0) return;
- TObjArray *digits = new TObjArray;
+ // TObjArray *digits = new TObjArray;
+ TObjArray digits;
for (Int_t i=0;i<smaxall; i++){
AliITSdigitSSD *d=(AliITSdigitSSD*)alldigits->UncheckedAt(i);
d->SetSignal(Int_t(q));
if (d->GetSignal()<3) continue;
- digits->AddLast(d);
+ digits.AddLast(d);
}
- Int_t smax = digits->GetEntriesFast();
+ Int_t smax = digits.GetEntriesFast();
if (smax==0) return;
const Int_t kMax=1000;
Float_t y=0., q=0., qmax=0.;
Int_t lab[4]={-2,-2,-2,-2};
- AliITSdigitSSD *d=(AliITSdigitSSD*)digits->UncheckedAt(0);
+ AliITSdigitSSD *d=(AliITSdigitSSD*)digits.UncheckedAt(0);
q += d->GetSignal();
y += d->GetCoord2()*d->GetSignal();
qmax=d->GetSignal();
milab[0]=d->GetTrack(0); milab[1]=d->GetTrack(1); milab[2]=d->GetTrack(2);
for (Int_t s=1; s<smax; s++) {
- d=(AliITSdigitSSD*)digits->UncheckedAt(s);
+ d=(AliITSdigitSSD*)digits.UncheckedAt(s);
Int_t strip=d->GetCoord2();
if ((strip-curr) > 1 || flag!=d->GetCoord1()) {
c[*n].SetY(y/q);
CheckLabels2(milab);
c[*n].SetLabels(milab);
//Split suspiciously big cluster
- /*
- if (nd>10&&nd<16){
- c[*n].SetY(y/q-0.3*nd);
- c[*n].SetQ(0.5*q);
- (*n)++;
- if (*n==MAX) {
- Error("FindClustersSSD","Too many 1D clusters !");
- return;
- }
- c[*n].SetY(y/q-0.0*nd);
- c[*n].SetQ(0.5*q);
- c[*n].SetNd(nd);
- (*n)++;
- if (*n==MAX) {
- Error("FindClustersSSD","Too many 1D clusters !");
- return;
- }
- //
- c[*n].SetY(y/q+0.3*nd);
- c[*n].SetQ(0.5*q);
- c[*n].SetNd(nd);
- c[*n].SetLabels(milab);
- }
- else{
- */
if (nd>4&&nd<25) {
c[*n].SetY(y/q-0.25*nd);
c[*n].SetQ(0.5*q);
// This function creates ITS clusters from raw data
//------------------------------------------------------------
rawReader->Reset();
+ /*
+ const UInt_t *evid; evid = rawReader->GetEventId();
+ cout<<"Event="<<evid[0]<<endl;
+ */
AliITSRawStreamSSD inputSSD(rawReader);
+ // rawReader->SelectEquipment(-1,0,15);
FindClustersSSD(&inputSSD,clusters);
}
Float_t q = 0.;
Float_t y = 0.;
Int_t nDigits = 0;
- Int_t prevStrip = -1;
- Int_t prevFlag = -1;
- Int_t prevModule = -1;
Float_t gain=0;
+ Float_t noise=0.;
+ Float_t pedestal=0.;
+ Float_t oldnoise=0.;
AliITSCalibrationSSD* cal=NULL;
-
+
+ Int_t matrix[12][1536];
+ Int_t iddl=-1;
+ Int_t iad=-1;
+ Int_t oddl = -1;
+ Int_t oad = -1;
+ Int_t oadc = -1;
+ Int_t ostrip = -1;
+ Int_t osignal = 65535;
+ Int_t n=0;
+ Bool_t next=0;
// read raw data input stream
while (kTRUE) {
- Bool_t next = input->Next();
-
- if(input->GetSignal()<(3*4.) && next) continue;
- // check if a new cluster starts
- Int_t strip = input->GetCoord2();
- Int_t flag = input->GetCoord1();
- if ((!next || (input->GetModuleID() != prevModule)||
- (strip-prevStrip > 1) || (flag != prevFlag)) &&
- (nDigits > 0)) {
- if (nClusters[prevFlag] == kMax) {
- Error("FindClustersSSD", "Too many 1D clusters !");
- return;
+
+ // reset signal matrix
+ for(Int_t i=0; i<12; i++) { for(Int_t j=0; j<1536; j++) { matrix[i][j] = 65535;} }
+
+ if(osignal!=65535) {
+ n++;
+ matrix[oadc][ostrip] = osignal; // recover data from previous occurence of input->Next()
+ }
+
+ // buffer data for ddl=iddl and ad=iad
+ while(kTRUE) {
+
+ next = input->Next();
+ if((!next)&&(input->flag)) continue;
+ Int_t ddl=input->GetDDL();
+ Int_t ad=input->GetAD();
+ Int_t adc = input->GetADC(); adc = (adc<6)? adc : adc - 2;
+ Int_t strip = input->GetStrip();
+ if(input->GetSideFlag()) strip=1535-strip;
+ Int_t signal = input->GetSignal();
+ //cout<<ddl<<" "<<ad<<" "<<adc<<" "<<strip<<" "<<signal<<endl;
+
+ if((ddl==iddl)&&(ad==iad)) {n++; matrix[adc][strip] = signal;}
+ else {oddl=iddl; oad=iad; oadc = adc; ostrip = strip; osignal=signal; iddl=ddl; iad=ad; break;}
+
+ if(!next) {oddl=iddl; oad=iad; oadc = adc; ostrip = strip; osignal=signal; iddl=ddl; iad=ad; break;}
+ //break;
+ }
+
+ // No SSD data
+ if(!next && oddl<0) break;
+
+ if(n==0) continue; // first occurence
+ n=0; osignal=0;
+
+ // fill 1Dclusters
+ for(Int_t iadc=0; iadc<12; iadc++) { // loop over ADC index for ddl=oddl and ad=oad
+
+ Int_t iimod = (oad - 1) * 12 + iadc;
+ Int_t iModule = AliITSRawStreamSSD::GetModuleNumber(oddl,iimod);
+ if(iModule==-1) continue;
+ // cout<<"ddl="<<oddl<<" ad"<<oad<<" module="<<iModule<<endl;
+ cal = (AliITSCalibrationSSD*)GetResp(iModule);
+
+ Bool_t first = 0;
+
+ for(Int_t istrip=0; istrip<768; istrip++) { // P-side
+ Int_t signal = matrix[iadc][istrip];
+ pedestal = cal->GetPedestalP(istrip);
+ matrix[iadc][istrip]=signal-(Int_t)pedestal;
}
- Ali1Dcluster& cluster = clusters1D[prevFlag][nClusters[prevFlag]++];
- cluster.SetY(y/q);
- cluster.SetQ(q);
- cluster.SetNd(nDigits);
- cluster.SetLabels(lab);
-
- //Split suspiciously big cluster
- if (nDigits > 4&&nDigits < 25) {
- cluster.SetY(y/q - 0.25*nDigits);
- cluster.SetQ(0.5*q);
- if (nClusters[prevFlag] == kMax) {
- Error("FindClustersSSD", "Too many 1D clusters !");
- return;
+
+ Float_t cmode=0;
+ for(Int_t l=0; l<6; l++) {
+ cmode=0;
+ for(Int_t n=20; n<108; n++) cmode+=matrix[iadc][l*128+n];
+ cmode/=88.;
+ for(Int_t n=0; n<128; n++) matrix[iadc][l*128+n]-=(Int_t)cmode;
+
+ }
+
+ for(Int_t istrip=0; istrip<768; istrip++) { // P-side
+
+ Int_t signal = TMath::Abs(matrix[iadc][istrip]);
+
+ oldnoise = noise;
+ noise = cal->GetNoiseP(istrip); if(noise<1.) signal = 65535;
+ if(signal<5*noise) signal = 65535; // in case ZS was not done in hw do it now
+ if( (signal<30.) || (istrip<10) || (istrip>758) ) signal=65535;
+
+ if (signal!=65535) {
+ gain = cal->GetGainP(istrip);
+ signal = (Int_t) ( signal * gain ); // signal is corrected for gain
+ signal = (Int_t) cal->ADCToKeV( signal ); // signal is converted in KeV
+
+ q += signal; // add digit to current cluster
+ y += istrip * signal;
+ nDigits++;
+ first=1;
+ }
+
+ else if(first) {
+
+ if ( ((nDigits==1)&&(q>5*oldnoise)) || (nDigits>1) ) {
+
+ Ali1Dcluster& cluster = clusters1D[0][nClusters[0]++];
+ cluster.SetY(y/q);
+ cluster.SetQ(q);
+ cluster.SetNd(nDigits);
+ cluster.SetLabels(lab);
+
+ //Split suspiciously big cluster
+ if (nDigits > 4&&nDigits < 25) {
+ cluster.SetY(y/q - 0.25*nDigits);
+ cluster.SetQ(0.5*q);
+ if (nClusters[0] == kMax) {
+ Error("FindClustersSSD", "Too many 1D clusters !");
+ return;
+ }
+ Ali1Dcluster& cluster2 = clusters1D[0][nClusters[0]++];
+ cluster2.SetY(y/q + 0.25*nDigits);
+ cluster2.SetQ(0.5*q);
+ cluster2.SetNd(nDigits);
+ cluster2.SetLabels(lab);
+ }
+
+ }
+
+ y = q = 0.;
+ nDigits = 0;
+ first=0;
}
- Ali1Dcluster& cluster2 = clusters1D[prevFlag][nClusters[prevFlag]++];
- cluster2.SetY(y/q + 0.25*nDigits);
- cluster2.SetQ(0.5*q);
- cluster2.SetNd(nDigits);
- cluster2.SetLabels(lab);
+
+ } // loop over strip on P-side
+
+ // if last strip does have signal
+ if(first) {
+
+ if ( ((nDigits==1)&&(q>5*oldnoise)) || (nDigits>1) ) {
+
+ Ali1Dcluster& cluster = clusters1D[0][nClusters[0]++];
+ cluster.SetY(y/q);
+ cluster.SetQ(q);
+ cluster.SetNd(nDigits);
+ cluster.SetLabels(lab);
+
+ //Split suspiciously big cluster
+ if (nDigits > 4&&nDigits < 25) {
+ cluster.SetY(y/q - 0.25*nDigits);
+ cluster.SetQ(0.5*q);
+ if (nClusters[0] == kMax) {
+ Error("FindClustersSSD", "Too many 1D clusters !");
+ return;
+ }
+ Ali1Dcluster& cluster2 = clusters1D[0][nClusters[0]++];
+ cluster2.SetY(y/q + 0.25*nDigits);
+ cluster2.SetQ(0.5*q);
+ cluster2.SetNd(nDigits);
+ cluster2.SetLabels(lab);
+ }
+
+ }
+ y = q = 0.;
+ nDigits = 0;
+ first=0;
}
- y = q = 0.;
- nDigits = 0;
- }
+
+ for(Int_t istrip=768; istrip<1536; istrip++) { // P-side
+ Int_t signal = matrix[iadc][istrip];
+ pedestal = cal->GetPedestalN(1535-istrip);
+ matrix[iadc][istrip]=signal-(Int_t)pedestal;
+ }
+
+ for(Int_t l=6; l<12; l++) {
+ Float_t cmode=0;
+ for(Int_t n=20; n<108; n++) cmode+=matrix[iadc][l*128+n];
+ cmode/=88.;
+ for(Int_t n=0; n<128; n++) matrix[iadc][l*128+n]-=(Int_t)cmode;
+ }
+
+ oldnoise = 0.;
+ noise = 0.;
+ for(Int_t istrip=768; istrip<1536; istrip++) { // N-side
+
+ Int_t signal = TMath::Abs(matrix[iadc][istrip]);
+ //cout<<"####"<<" "<<oddl<<" "<<oad<<" "<<iadc<<" "<<istrip<<" "<<signal<<endl;
- if (!next || (input->GetModuleID() != prevModule)) {
- Int_t iModule = prevModule;
+ Int_t strip = 1535-istrip;
- // when all data from a module was read, search for clusters
- if (prevFlag >= 0) {
+ oldnoise = noise;
+ noise = cal->GetNoiseN(strip); if(noise<1.) signal=65535;
+ if(signal<5*noise) signal = 65535; // in case ZS was not done in hw do it now
+ if( (signal<30.) || (istrip<778) || (istrip>1526) ) signal=65535;
+
+ if (signal!=65535) {
+ // cout<<"ddl="<<oddl<<" ad"<<oad<<" module="<<iModule<<" strip= "<<istrip<<
+ // " sig="<<signal<<" "<<cal->GetPedestalN(strip)<<endl;
+ gain = cal->GetGainN(strip);
+ signal = (Int_t) ( signal * gain); // signal is corrected for gain
+ signal = (Int_t) cal->ADCToKeV( signal ); // signal is converted in KeV
+
+ // add digit to current cluster
+ q += signal;
+ y += strip * signal;
+ nDigits++;
+ first=1;
+ }
+
+ else if(first) {
+
+ if ( ((nDigits==1)&&(q>5*oldnoise)) || (nDigits>1) ) {
+
+ Ali1Dcluster& cluster = clusters1D[1][nClusters[1]++];
+ cluster.SetY(y/q);
+ cluster.SetQ(q);
+ cluster.SetNd(nDigits);
+ cluster.SetLabels(lab);
+
+ //Split suspiciously big cluster
+ if (nDigits > 4&&nDigits < 25) {
+ cluster.SetY(y/q - 0.25*nDigits);
+ cluster.SetQ(0.5*q);
+ if (nClusters[1] == kMax) {
+ Error("FindClustersSSD", "Too many 1D clusters !");
+ return;
+ }
+ Ali1Dcluster& cluster2 = clusters1D[1][nClusters[1]++];
+ cluster2.SetY(y/q + 0.25*nDigits);
+ cluster2.SetQ(0.5*q);
+ cluster2.SetNd(nDigits);
+ cluster2.SetLabels(lab);
+ }
+
+ }
+ y = q = 0.;
+ nDigits = 0;
+ first=0;
+ }
+
+ } // loop over strips on N-side
+
+ if(first) {
+
+ if ( ((nDigits==1)&&(q>5*oldnoise)) || (nDigits>1) ) {
+
+ Ali1Dcluster& cluster = clusters1D[1][nClusters[1]++];
+ cluster.SetY(y/q);
+ cluster.SetQ(q);
+ cluster.SetNd(nDigits);
+ cluster.SetLabels(lab);
+
+ //Split suspiciously big cluster
+ if (nDigits > 4&&nDigits < 25) {
+ cluster.SetY(y/q - 0.25*nDigits);
+ cluster.SetQ(0.5*q);
+ if (nClusters[1] == kMax) {
+ Error("FindClustersSSD", "Too many 1D clusters !");
+ return;
+ }
+ Ali1Dcluster& cluster2 = clusters1D[1][nClusters[1]++];
+ cluster2.SetY(y/q + 0.25*nDigits);
+ cluster2.SetQ(0.5*q);
+ cluster2.SetNd(nDigits);
+ cluster2.SetLabels(lab);
+ }
+
+ }
+ y = q = 0.;
+ nDigits = 0;
+ first=0;
+ }
+
+ // create recpoints
+ if((nClusters[0])&&(nClusters[1])) {
+
+ //cout<<"creating recpoint for module="<<iModule<<" "<<nClusters[0]<<" "<<nClusters[1]<<endl;
clusters[iModule] = new TClonesArray("AliITSRecPoint");
fModule = iModule;
+ // fModule = 500;
FindClustersSSD(&clusters1D[0][0], nClusters[0],
&clusters1D[1][0], nClusters[1], clusters[iModule]);
Int_t nClusters = clusters[iModule]->GetEntriesFast();
nClustersSSD += nClusters;
}
- if (!next) break;
nClusters[0] = nClusters[1] = 0;
y = q = 0.;
nDigits = 0;
- cal = (AliITSCalibrationSSD*)GetResp(input->GetModuleID());
-
- }
-
- if(input->GetSideFlag()==0) gain = cal->GetGainP(input->GetStrip());
- else gain = cal->GetGainN(input->GetStrip());
-
- // add digit to current cluster
- q += cal->ADCToKeV( gain * input->GetSignal() ); // signal is corrected for gain and converted in KeV
- y += strip * cal->ADCToKeV( gain * input->GetSignal() );
- nDigits++;
- prevStrip = strip;
- prevFlag = flag;
- prevModule = input->GetModuleID();
+ } // loop over adc
+ if(!next) break;
}
-
+
Info("FindClustersSSD", "found clusters in ITS SSD: %d", nClustersSSD);
}
// Actual SSD cluster finder
//------------------------------------------------------------
+ // Float_t xyz[3];
+
const TGeoHMatrix *mT2L=AliITSgeomTGeo::GetTracking2LocalMatrix(fModule);
TClonesArray &cl=*clusters;
for (Int_t i=0;i<3000;i++) {cnegative[i]=0; cused1[i]=0;}
for (Int_t i=0;i<3000;i++) {cpositive[i]=0; cused2[i]=0;}
for (Int_t i=0;i<30000;i++) {negativepair[i]=0; positivepair[i]=0;}
- static Short_t pairs[1000][1000];
- memset(pairs,0,sizeof(Short_t)*1000000);
-// Short_t ** pairs = new Short_t*[1000];
-// for (Int_t i=0; i<1000; i++) {
-// pairs[i] = new Short_t[1000];
-// memset(pairs[i],0,sizeof(Short_t)*1000);
-// }
+
+ if ((np*nn) > fgPairsSize) {
+ if (fgPairs) delete [] fgPairs;
+ fgPairsSize = 4*np*nn;
+ fgPairs = new Short_t[fgPairsSize];
+ }
+ memset(fgPairs,0,sizeof(Short_t)*np*nn);
+
//
// find available pairs
//
positivepair[j*10+cpositive[j]] =i;
cnegative[i]++; //counters
cpositive[j]++;
- pairs[i][j]=100;
+ fgPairs[i*nn+j]=100;
}
}
}
+
+ //
+ // try to recover points out of but close to the module boundaries
//
for (Int_t i=0; i<np; i++) {
Float_t yp=pos[i].GetY()*fYpitchSSD;
if (pos[i].GetQ()<3) continue;
for (Int_t j=0; j<nn; j++) {
if (neg[j].GetQ()<3) continue;
+ // if both 1Dclusters have an other cross continue
if (cpositive[j]&&cnegative[i]) continue;
Float_t yn=neg[j].GetY()*fYpitchSSD;
Float_t zt=(2*fHlSSD*tanp + yp - yn)/(tann+tanp);
zt-=fHlSSD; yt-=fHwSSD;
if (TMath::Abs(yt)<fHwSSD+0.1)
if (TMath::Abs(zt)<fHlSSD+0.15) {
+ // tag 1Dcluster (eventually will produce low quality recpoint)
if (cnegative[i]==0) pos[i].SetNd(100); // not available pair
if (cpositive[j]==0) neg[j].SetNd(100); // not available pair
negativepair[i*10+cnegative[i]] =j; //index
positivepair[j*10+cpositive[j]] =i;
cnegative[i]++; //counters
cpositive[j]++;
- pairs[i][j]=100;
+ fgPairs[i*nn+j]=100;
}
}
}
+
//
Float_t lp[5];
Int_t milab[10];
zt-=fHlSSD; yt-=fHwSSD;
ybest=yt; zbest=zt;
qbest=0.5*(pos[ip].GetQ()+neg[j].GetQ());
+
+ //cout<<yt<<" "<<zt<<" "<<qbest<<endl;
+
{
Double_t loc[3]={ybest,0.,zbest},trk[3]={0.,0.,0.};
mT2L->MasterToLocal(loc,trk);
milab[3]=(((ip<<10) + j)<<10) + idet; // pos|neg|det
Int_t info[3] = {pos[ip].GetNd(),neg[j].GetNd(),fNlayer[fModule]};
AliITSRecPoint * cl2;
- if(clusters){
+
+ if(clusters){ // Note clusters != 0 when method is called for rawdata
+
+
cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
+
+ // cl2-> GetGlobalXYZ(xyz); cout<<"rec "<<xyz[0]<<" "<<xyz[1]<<" "<<xyz[2]<<endl;
+
cl2->SetChargeRatio(ratio);
cl2->SetType(1);
- pairs[ip][j]=1;
+ fgPairs[ip*nn+j]=1;
if ((pos[ip].GetNd()+neg[j].GetNd())>6){ //multi cluster
cl2->SetType(2);
- pairs[ip][j]=2;
+ fgPairs[ip*nn+j]=2;
}
cused1[ip]++;
cused2[j]++;
}
- else{
+ else{ // Note clusters == 0 when method is called for digits
+
cl2 = new AliITSRecPoint(milab,lp,info);
+
+ // cl2-> GetGlobalXYZ(xyz); cout<<"rec "<<xyz[0]<<" "<<xyz[1]<<" "<<xyz[2]<<endl;
+
cl2->SetChargeRatio(ratio);
cl2->SetType(1);
- pairs[ip][j]=1;
+ fgPairs[ip*nn+j]=1;
if ((pos[ip].GetNd()+neg[j].GetNd())>6){ //multi cluster
cl2->SetType(2);
- pairs[ip][j]=2;
+ fgPairs[ip*nn+j]=2;
}
cused1[ip]++;
cused2[j]++;
+ //cout<<"AliITSClusterFinderV2SSD "<<fModule<<" gold"<<endl;
fDetTypeRec->AddRecPoint(*cl2);
}
ncl++;
if (TMath::Abs(pcharge-neg[in].GetQ())<10){
//
// add first pair
- if (pairs[ip][in]==100){ //
+ if (fgPairs[ip*nn+in]==100){ //
Float_t yp=pos[ip].GetY()*fYpitchSSD;
Float_t yn=neg[in].GetY()*fYpitchSSD;
Float_t zt=(2*fHlSSD*tanp + yp - yn)/(tann+tanp);
AliITSRecPoint * cl2;
if(clusters){
+
cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
+
+ // cl2-> GetGlobalXYZ(xyz); cout<<"rec "<<xyz[0]<<" "<<xyz[1]<<" "<<xyz[2]<<endl;
+
cl2->SetChargeRatio(ratio);
cl2->SetType(5);
- pairs[ip][in] = 5;
+ fgPairs[ip*nn+in] = 5;
if ((pos[ip].GetNd()+neg[in].GetNd())>6){ //multi cluster
cl2->SetType(6);
- pairs[ip][in] = 6;
+ fgPairs[ip*nn+in] = 6;
}
}
else{
cl2 = new AliITSRecPoint(milab,lp,info);
cl2->SetChargeRatio(ratio);
cl2->SetType(5);
- pairs[ip][in] = 5;
+ fgPairs[ip*nn+in] = 5;
if ((pos[ip].GetNd()+neg[in].GetNd())>6){ //multi cluster
cl2->SetType(6);
- pairs[ip][in] = 6;
+ fgPairs[ip*nn+in] = 6;
}
-
+ //cout<<"AliITSClusterFinderV2SSD "<<fModule<<" silver1"<<endl;
+
fDetTypeRec->AddRecPoint(*cl2);
}
ncl++;
// add second pair
// if (!(cused1[ip2] || cused2[in])){ //
- if (pairs[ip2][in]==100){
+ if (fgPairs[ip2*nn+in]==100){
Float_t yp=pos[ip2].GetY()*fYpitchSSD;
Float_t yn=neg[in].GetY()*fYpitchSSD;
Float_t zt=(2*fHlSSD*tanp + yp - yn)/(tann+tanp);
AliITSRecPoint * cl2;
if(clusters){
cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
+
+ // cl2-> GetGlobalXYZ(xyz); cout<<"rec "<<xyz[0]<<" "<<xyz[1]<<" "<<xyz[2]<<endl;
+
cl2->SetChargeRatio(ratio);
cl2->SetType(5);
- pairs[ip2][in] =5;
+ fgPairs[ip2*nn+in] =5;
if ((pos[ip2].GetNd()+neg[in].GetNd())>6){ //multi cluster
cl2->SetType(6);
- pairs[ip2][in] =6;
+ fgPairs[ip2*nn+in] =6;
}
}
else{
cl2 = new AliITSRecPoint(milab,lp,info);
cl2->SetChargeRatio(ratio);
cl2->SetType(5);
- pairs[ip2][in] =5;
+ fgPairs[ip2*nn+in] =5;
if ((pos[ip2].GetNd()+neg[in].GetNd())>6){ //multi cluster
cl2->SetType(6);
- pairs[ip2][in] =6;
+ fgPairs[ip2*nn+in] =6;
}
-
+
+ // cout<<"AliITSClusterFinderV2SSD "<<fModule<<" silver2"<<endl;
fDetTypeRec->AddRecPoint(*cl2);
}
ncl++;
//
// add first pair
// if (!(cused1[ip]||cused2[jn])){
- if (pairs[ip][jn]==100){
+ if (fgPairs[ip*nn+jn]==100){
Float_t yn=neg[jn].GetY()*fYpitchSSD;
Float_t yp=pos[ip].GetY()*fYpitchSSD;
Float_t zt=(2*fHlSSD*tanp + yp - yn)/(tann+tanp);
AliITSRecPoint * cl2;
if(clusters){
cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
+
+ // cl2-> GetGlobalXYZ(xyz); cout<<"rec "<<xyz[0]<<" "<<xyz[1]<<" "<<xyz[2]<<endl;
+
cl2->SetChargeRatio(ratio);
cl2->SetType(7);
- pairs[ip][jn] =7;
+ fgPairs[ip*nn+jn] =7;
if ((pos[ip].GetNd()+neg[jn].GetNd())>6){ //multi cluster
cl2->SetType(8);
- pairs[ip][jn]=8;
+ fgPairs[ip*nn+jn]=8;
}
}
cl2 = new AliITSRecPoint(milab,lp,info);
cl2->SetChargeRatio(ratio);
cl2->SetType(7);
- pairs[ip][jn] =7;
+ fgPairs[ip*nn+jn] =7;
if ((pos[ip].GetNd()+neg[jn].GetNd())>6){ //multi cluster
cl2->SetType(8);
- pairs[ip][jn]=8;
+ fgPairs[ip*nn+jn]=8;
}
+ //cout<<"AliITSClusterFinderV2SSD "<<fModule<<" silverN1"<<endl;
fDetTypeRec->AddRecPoint(*cl2);
}
//
// add second pair
// if (!(cused1[ip]||cused2[jn2])){
- if (pairs[ip][jn2]==100){
+ if (fgPairs[ip*nn+jn2]==100){
Float_t yn=neg[jn2].GetY()*fYpitchSSD;
Double_t yp=pos[ip].GetY()*fYpitchSSD;
Double_t zt=(2*fHlSSD*tanp + yp - yn)/(tann+tanp);
AliITSRecPoint * cl2;
if(clusters){
cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
+
+ // cl2-> GetGlobalXYZ(xyz); cout<<"rec "<<xyz[0]<<" "<<xyz[1]<<" "<<xyz[2]<<endl;
+
cl2->SetChargeRatio(ratio);
- pairs[ip][jn2]=7;
+ fgPairs[ip*nn+jn2]=7;
cl2->SetType(7);
if ((pos[ip].GetNd()+neg[jn2].GetNd())>6){ //multi cluster
cl2->SetType(8);
- pairs[ip][jn2]=8;
+ fgPairs[ip*nn+jn2]=8;
}
}
else{
cl2 = new AliITSRecPoint(milab,lp,info);
cl2->SetChargeRatio(ratio);
- pairs[ip][jn2]=7;
+ fgPairs[ip*nn+jn2]=7;
cl2->SetType(7);
if ((pos[ip].GetNd()+neg[jn2].GetNd())>6){ //multi cluster
cl2->SetType(8);
- pairs[ip][jn2]=8;
+ fgPairs[ip*nn+jn2]=8;
}
-
+ //cout<<"AliITSClusterFinderV2SSD "<<fModule<<" silverN2"<<endl;
+
fDetTypeRec->AddRecPoint(*cl2);
}
}
}
if (j<0) continue; // not proper cluster
+
Int_t count =0;
for (Int_t di=0;di<cnegative[ip];di++){
Int_t jc = negativepair[ip*10+di];
if (TMath::Abs(chargedif)<minchargediff+4.) count++;
}
if (count>1) continue;
- if (pairs[ip][j]<100) continue;
+ if (fgPairs[ip*nn+j]<100) continue;
//
//almost gold clusters
Float_t yp=pos[ip].GetY()*fYpitchSSD;
AliITSRecPoint * cl2;
if(clusters){
cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
+
+ // cl2-> GetGlobalXYZ(xyz); cout<<"rec "<<xyz[0]<<" "<<xyz[1]<<" "<<xyz[2]<<endl;
+
cl2->SetChargeRatio(ratio);
cl2->SetType(10);
- pairs[ip][j]=10;
+ fgPairs[ip*nn+j]=10;
if ((pos[ip].GetNd()+neg[j].GetNd())>6){ //multi cluster
cl2->SetType(11);
- pairs[ip][j]=11;
+ fgPairs[ip*nn+j]=11;
}
cused1[ip]++;
cused2[j]++;
cl2 = new AliITSRecPoint(milab,lp,info);
cl2->SetChargeRatio(ratio);
cl2->SetType(10);
- pairs[ip][j]=10;
+ fgPairs[ip*nn+j]=10;
if ((pos[ip].GetNd()+neg[j].GetNd())>6){ //multi cluster
cl2->SetType(11);
- pairs[ip][j]=11;
+ fgPairs[ip*nn+j]=11;
}
cused1[ip]++;
cused2[j]++;
+ //cout<<"AliITSClusterFinderV2SSD "<<fModule<<" 2x2"<<endl;
+
fDetTypeRec->AddRecPoint(*cl2);
}
ncl++;
// Int_t j = negativepair[10*i+di];
if (neg[j].GetQ()<3) continue;
if (cused2[j]||cused1[i]) continue;
- if (pairs[i][j]>0 &&pairs[i][j]<100) continue;
+ if (fgPairs[i*nn+j]>0 &&fgPairs[i*nn+j]<100) continue;
ratio = (pos[i].GetQ()-neg[j].GetQ())/(pos[i].GetQ()+neg[j].GetQ());
Float_t yn=neg[j].GetY()*fYpitchSSD;
Float_t zt=(2*fHlSSD*tanp + yp - yn)/(tann+tanp);
AliITSRecPoint * cl2;
if(clusters){
cl2 = new (cl[ncl]) AliITSRecPoint(milab,lp,info);
+
+ // cl2-> GetGlobalXYZ(xyz); cout<<"rec "<<xyz[0]<<" "<<xyz[1]<<" "<<xyz[2]<<endl;
+
cl2->SetChargeRatio(ratio);
cl2->SetType(100+cpositive[j]+cnegative[i]);
}
cl2 = new AliITSRecPoint(milab,lp,info);
cl2->SetChargeRatio(ratio);
cl2->SetType(100+cpositive[j]+cnegative[i]);
+
+ //cout<<"AliITSClusterFinderV2SSD "<<fModule<<" other"<<endl;
+
fDetTypeRec->AddRecPoint(*cl2);
}
ncl++;
//cl2->SetType(0);
/*
- if (pairs[i][j]<100){
- printf("problem:- %d\n", pairs[i][j]);
+ if (fgPairs[i*nn+j]<100){
+ printf("problem:- %d\n", fgPairs[i*nn+j]);
}
if (cnegative[i]<2&&cpositive[j]<2){
- printf("problem:- %d\n", pairs[i][j]);
+ printf("problem:- %d\n", fgPairs[i*nn+j]);
}
*/
}
}
}
-// for (Int_t i=0; i<1000; i++) delete [] pairs[i];
-// delete [] pairs;
-
}
-