#include <iostream>
#include <fstream>
-AliITSOnlineSPDphysAnalyzer::AliITSOnlineSPDphysAnalyzer(const Char_t *fileName, AliITSOnlineCalibrationSPDhandler* handler) :
+AliITSOnlineSPDphysAnalyzer::AliITSOnlineSPDphysAnalyzer(const Char_t *fileName, AliITSOnlineCalibrationSPDhandler* handler, Bool_t readFromGridFile) :
fFileName(fileName),fPhysObj(NULL),fHandler(handler),
fNrEnoughStatChips(0),fNrDeadChips(0),fNrInefficientChips(0),
fNrEqHits(0),fbDeadProcessed(kFALSE),
- fThreshNoisy(1),fThreshNoisyExp(-12),fThreshDead(1),fThreshDeadExp(-12),
+ fThreshNoisy(1e-9),fThreshDead(1e-9),
fMinEventsForNoisy(10000),fMinEventsForDead(10000),
- fDefinitelyNoisyRatio(0.1),
- fMinNrEqHitsForDeadChips(60000),fRatioToMeanForInefficientChip(0.1)//!!!
+ fDefinitelyNoisyRatio(0.3),
+ fMinNrEqHitsForDeadChips(60000),fRatioToMeanForInefficientChip(0.1)
{
// constructor
- Init();
+ Init(readFromGridFile);
}
AliITSOnlineSPDphysAnalyzer::AliITSOnlineSPDphysAnalyzer(AliITSOnlineSPDphys* physObj, AliITSOnlineCalibrationSPDhandler* handler) :
fFileName("test.root"),fPhysObj(NULL),fHandler(handler),
fNrEnoughStatChips(0),fNrDeadChips(0),fNrInefficientChips(0),
fNrEqHits(0),fbDeadProcessed(kFALSE),
- fThreshNoisy(1),fThreshNoisyExp(-12),fThreshDead(1),fThreshDeadExp(-12),
+ fThreshNoisy(1e-9),fThreshDead(1e-9),
fMinEventsForNoisy(10000),fMinEventsForDead(10000),
- fDefinitelyNoisyRatio(0.1),
- fMinNrEqHitsForDeadChips(60000),fRatioToMeanForInefficientChip(0.1)//!!!
+ fDefinitelyNoisyRatio(0.3),
+ fMinNrEqHitsForDeadChips(60000),fRatioToMeanForInefficientChip(0.1)
{
// alt constructor
fPhysObj = physObj;
fFileName("test.root"),fPhysObj(NULL),fHandler(NULL),
fNrEnoughStatChips(0),fNrDeadChips(0),fNrInefficientChips(0),
fNrEqHits(0),fbDeadProcessed(kFALSE),
- fThreshNoisy(1),fThreshNoisyExp(-12),fThreshDead(1),fThreshDeadExp(-12),
+ fThreshNoisy(1e-9),fThreshDead(1e-9),
fMinEventsForNoisy(10000),fMinEventsForDead(10000),
- fDefinitelyNoisyRatio(0.1),
- fMinNrEqHitsForDeadChips(60000),fRatioToMeanForInefficientChip(0.1)//!!!
+ fDefinitelyNoisyRatio(0.3),
+ fMinNrEqHitsForDeadChips(60000),fRatioToMeanForInefficientChip(0.1)
{
// copy constructor, only copies the filename and params (not the processed data)
fFileName=handle.fFileName;
fThreshNoisy = handle.fThreshNoisy;
- fThreshNoisyExp = handle.fThreshNoisyExp;
fThreshDead = handle.fThreshDead;
- fThreshDeadExp = handle.fThreshDeadExp;
fMinEventsForNoisy = handle.fMinEventsForNoisy;
fMinEventsForDead = handle.fMinEventsForDead;
fDefinitelyNoisyRatio = handle.fDefinitelyNoisyRatio;
fFileName=handle.fFileName;
fThreshNoisy = handle.fThreshNoisy;
- fThreshNoisyExp = handle.fThreshNoisyExp;
fThreshDead = handle.fThreshDead;
- fThreshDeadExp = handle.fThreshDeadExp;
fMinEventsForNoisy = handle.fMinEventsForNoisy;
fMinEventsForDead = handle.fMinEventsForDead;
fDefinitelyNoisyRatio = handle.fDefinitelyNoisyRatio;
return *this;
}
-void AliITSOnlineSPDphysAnalyzer::Init() {
+void AliITSOnlineSPDphysAnalyzer::Init(Bool_t readFromGridFile) {
// initialize container obj
- FILE* fp0 = fopen(fFileName.Data(), "r");
- if (fp0 == NULL) {
- return;
- }
- else {
- fclose(fp0);
+ if (!readFromGridFile) {
+ FILE* fp0 = fopen(fFileName.Data(), "r");
+ if (fp0 == NULL) {
+ return;
+ }
+ else {
+ fclose(fp0);
+ }
}
- fPhysObj = new AliITSOnlineSPDphys(fFileName.Data());
+ fPhysObj = new AliITSOnlineSPDphys(fFileName.Data(), readFromGridFile);
}
void AliITSOnlineSPDphysAnalyzer::SetParam(const Char_t *pname, const Char_t *pval) {
// printf("Setting Param %s to %s\n",name.Data(),val.Data());
if (name.CompareTo("MistakeProbabilityNoisy")==0) {
Double_t mistakeProbabilityNoisy = val.Atof();
- fThreshNoisy = mistakeProbabilityNoisy;
- fThreshNoisyExp = 0;
- Exponent(fThreshNoisy,fThreshNoisyExp);
- fThreshNoisy/=(20*6*10*32*256);
- Exponent(fThreshNoisy,fThreshNoisyExp);
+ fThreshNoisy = mistakeProbabilityNoisy/(20*6*10*32*256);
}
else if (name.CompareTo("MistakeProbabilityDead")==0) {
Double_t mistakeProbabilityDead = val.Atof();
- fThreshDead = mistakeProbabilityDead;
- fThreshDeadExp = 0;
- Exponent(fThreshDead,fThreshDeadExp);
- fThreshDead/=(20*6*10*32*256);
- Exponent(fThreshDead,fThreshDeadExp);
+ fThreshDead = mistakeProbabilityDead/(20*6*10*32*256);
}
else if (name.CompareTo("fMinEventsForNoisy")==0) {
fMinEventsForNoisy = val.Atoi();
Double_t p = (Double_t)nrChipHits/nrPixels/n;
- Double_t bin = 1;
- Int_t binExp = 0;
// Bin(n,k=0):
- for (UInt_t i=0; i<n; i++) {
- bin*=(1-p);
- Exponent(bin,binExp);
- }
+ Double_t bin = pow((Double_t)(1-p),(Double_t)n);
// Bin(n,k)
UInt_t k=1;
- while (((binExp>fThreshNoisyExp || (binExp==fThreshNoisyExp && bin>fThreshNoisy)) || k<n*p) && k<=n) {
+ while ((bin>fThreshNoisy || k<n*p) && k<=n) {
k++;
bin = bin*(n-k+1)/k*p/(1-p);
- Exponent(bin,binExp);
}
// can we find noisy pixels...?
return nrEnoughStatChips;
}
-
-UInt_t AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels() {
- // process dead pixel data , returns number of chips with enough statistics
+UInt_t AliITSOnlineSPDphysAnalyzer::ProcessNoisyPixels(UInt_t eq, UInt_t nrEvts) {
+ // process noisy pixel data , returns number of chips with enough statistics
if (fPhysObj==NULL) {
- Warning("AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels","No data!");
+ Warning("AliITSOnlineSPDphysAnalyzer::ProcessNoisyPixels","No data!");
return 0;
}
// do we have enough events to even try the algorithm?
- if (GetNrEvents() < fMinEventsForDead) {
- Warning("AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels","Nr events (%d) < fMinEventsForDead (%d)!",GetNrEvents(),fMinEventsForDead);
+ if (nrEvts < fMinEventsForNoisy) {
+ Warning("AliITSOnlineSPDphysAnalyzer::ProcessNoisyPixels","Nr events (%d) < fMinEventsForNoisy (%d)!",nrEvts,fMinEventsForNoisy);
return 0;
}
// handler should be initialized
if (fHandler==NULL) {
- Error("AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels","Calibration handler is not initialized!");
+ Error("AliITSOnlineSPDphysAnalyzer::ProcessNoisyPixels","Calibration handler is not initialized!");
return 0;
}
-
- AliITSOnlineCalibrationSPDhandler *deadChipHandler = new AliITSOnlineCalibrationSPDhandler();
- AliITSIntMap* possiblyIneff = new AliITSIntMap();
-
- fNrEnoughStatChips = 0;
- fNrDeadChips = 0;
- fNrInefficientChips = 0;
- UInt_t nrPossiblyDeadChips = 0;
- fNrEqHits = 0;
+
+ UInt_t nrEnoughStatChips = 0;
for (UInt_t hs=0; hs<6; hs++) {
for (UInt_t chip=0; chip<10; chip++) {
- Bool_t good=kFALSE;
-
- AliITSOnlineCalibrationSPDhandler *deadPixelHandler = new AliITSOnlineCalibrationSPDhandler();
- UInt_t nrPossiblyDeadPixels = 0;
UInt_t nrPixels = 0;
UInt_t nrChipHits = 0;
+ UInt_t nrMostHits = 0;
for (UInt_t col=0; col<32; col++) {
for (UInt_t row=0; row<256; row++) {
UInt_t nrHits = fPhysObj->GetHits(hs,chip,col,row);
nrChipHits += nrHits;
- if (!fHandler->IsPixelNoisy(GetEqNr(),hs,chip,col,row)) {
- // don't include noisy pixels
- nrPixels++;
- if (nrHits==0) {
- nrPossiblyDeadPixels++;
- deadPixelHandler->SetDeadPixel(GetEqNr(),hs,chip,col,row);
- }
+ // if (nrHits>0) nrPixels++; // don't include pixels that might be dead
+ nrPixels++;
+ if (nrHits>fDefinitelyNoisyRatio*nrEvts) {
+ fHandler->SetNoisyPixel(eq,hs,chip,col,row);
+ nrPixels--;
+ nrChipHits-=nrHits;
}
else {
- nrChipHits -= nrHits; // this is needed when running offline (online nrHits should be 0 already)
+ if (nrMostHits<nrHits) nrMostHits=nrHits;
}
}
}
- fNrEqHits+=nrChipHits;
-
- // check all pixels that were declared dead from before...
- UInt_t nrDeadBefore = fHandler->GetNrDeadC(GetEqNr(),hs,chip);
- UInt_t nrNoisyNow = fHandler->GetNrNoisyC(GetEqNr(),hs,chip);
- if (nrDeadBefore+nrNoisyNow==8192) {
- if (nrChipHits>0) {
- fHandler->UnSetDeadChip(GetEqNr(),hs,chip);
- }
- }
- else {
- AliITSOnlineCalibrationSPDhandler *tmpHand = new AliITSOnlineCalibrationSPDhandler();
- for (UInt_t index=0; index<nrDeadBefore; index++) {
- UInt_t col = fHandler->GetDeadColAtC(GetEqNr(),hs,chip,index);
- UInt_t row = fHandler->GetDeadRowAtC(GetEqNr(),hs,chip,index);
- if (fPhysObj->GetHits(hs,chip,col,row)>0) {
- // fHandler->UnSetDeadPixel(GetEqNr(),hs,chip,col,row);
- tmpHand->SetDeadPixel(GetEqNr(),hs,chip,col,row);
+
+ if (nrChipHits>0) { // otherwise there are for sure no noisy
+ // Binomial with n events and probability p for pixel hit
+ UInt_t n = nrEvts;
+ if (nrPixels>0 && n>0) {
+
+ Double_t p = (Double_t)nrChipHits/nrPixels/n;
+
+ // Bin(n,k=0):
+ Double_t bin = pow((Double_t)(1-p),(Double_t)n);
+ // Bin(n,k)
+ UInt_t k=1;
+ while ((bin>fThreshNoisy || k<n*p) && k<=n) {
+ k++;
+ bin = bin*(n-k+1)/k*p/(1-p);
+ }
+
+ // can we find noisy pixels...?
+ if (k<=n) {
+ // printf("eq %d , hs %d , chip %d : Noisy level = %d\n",GetEqNr(),hs,chip,k);
+ nrEnoughStatChips++;
+ // add noisy pixels to handler
+ UInt_t noiseLimit=k;
+ if (nrMostHits>=noiseLimit) {
+ for (UInt_t col=0; col<32; col++) {
+ for (UInt_t row=0; row<256; row++) {
+ UInt_t nrHits = fPhysObj->GetHits(hs,chip,col,row);
+ if (nrHits >= noiseLimit) {
+ fHandler->SetNoisyPixel(eq,hs,chip,col,row);
+ }
+ }
+ }
+ }
}
}
- UInt_t nrToRemove = tmpHand->GetNrDead();
- for (UInt_t index=0; index<nrToRemove; index++) {
- fHandler->UnSetDeadPixel(GetEqNr(),hs,chip,tmpHand->GetDeadColAtC(GetEqNr(),hs,chip,index),tmpHand->GetDeadRowAtC(GetEqNr(),hs,chip,index));
- }
- delete tmpHand;
+
}
+ } // for chip
+ } // for hs
+ return nrEnoughStatChips;
+}
- if (nrPossiblyDeadPixels==0) {
- // no need to see if we have enough statistics...
- fNrEnoughStatChips++;
- good=kTRUE;
- delete deadPixelHandler;
- good=kTRUE;
- printf("%3d",good);
- if (chip==9) printf("\n");
- continue;
- }
+UInt_t AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels() {
+ // process dead pixel data , returns number of chips with enough statistics
+ if (fPhysObj==NULL) {
+ Warning("AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels","No data!");
+ return 0;
+ }
- if (nrChipHits==0) {
- nrPossiblyDeadChips++;
- deadChipHandler->SetDeadChip(GetEqNr(),hs,chip);
- delete deadPixelHandler;
- good=kFALSE;
- printf("%3d",good);
- if (chip==9) printf("\n");
- continue;
- }
+ // do we have enough events to even try the algorithm?
+ if (GetNrEvents() < fMinEventsForDead) {
+ Warning("AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels","Nr events (%d) < fMinEventsForDead (%d)!",GetNrEvents(),fMinEventsForDead);
+ return 0;
+ }
+ // handler should be initialized
+ if (fHandler==NULL) {
+ Error("AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels","Calibration handler is not initialized!");
+ return 0;
+ }
- // Binomial with n events and probability p for pixel hit
- UInt_t n = GetNrEvents();
- if (nrPixels>0 && n>0) {
+ AliITSIntMap* possiblyDead = new AliITSIntMap();
+ AliITSIntMap* possiblyIneff = new AliITSIntMap();
- Double_t p = (Double_t)nrChipHits/nrPixels/n;
+ fNrEnoughStatChips = 0;
+ fNrDeadChips = 0;
+ fNrInefficientChips = 0;
+ UInt_t nrPossiblyDeadChips = 0;
+ fNrEqHits = 0;
- // probability of falsely assigning a dead pixel
- Double_t falselyDeadProb = 1;
- Int_t falselyDeadProbExp = 0;
- for (UInt_t i=0; i<n; i++) {
- falselyDeadProb*=(1-p);
- Exponent(falselyDeadProb,falselyDeadProbExp);
- }
- // can we find dead pixels...?
- if (falselyDeadProbExp<fThreshDeadExp || (falselyDeadProbExp==fThreshDeadExp && falselyDeadProb<fThreshDead)) {
- fNrEnoughStatChips++;
- good=kTRUE;
- // add dead pixels to handler
- fHandler->AddDeadFrom(deadPixelHandler);
+ for (UInt_t hs=0; hs<6; hs++) {
+ if (!fHandler->IsActiveHS(GetEqNr(),hs)) {
+ fNrDeadChips+=10;
+ }
+ else {
+ for (UInt_t chip=0; chip<10; chip++) {
+ if (!fHandler->IsActiveChip(GetEqNr(),hs,chip)) {
+ fNrDeadChips++;
}
else {
- // this might be an inefficient chip
- possiblyIneff->Insert(hs*10+chip,nrChipHits);
- }
+ // perform search for individual dead pixels...
+ Bool_t good=kFALSE;
+
+ UInt_t nrPossiblyDeadPixels = 0;
+ UInt_t nrPixels = 0;
+ UInt_t nrChipHits = 0;
+ for (UInt_t col=0; col<32; col++) {
+ for (UInt_t row=0; row<256; row++) {
+ UInt_t nrHits = fPhysObj->GetHits(hs,chip,col,row);
+ nrChipHits += nrHits;
+ if (!fHandler->IsPixelNoisy(GetEqNr(),hs,chip,col,row)) {
+ // don't include noisy pixels
+ nrPixels++;
+ if (nrHits==0) {
+ nrPossiblyDeadPixels++;
+ }
+ else {
+ fHandler->UnSetDeadPixel(GetEqNr(),hs,chip,col,row); // unset (no action unless dead before)
+ }
+ }
+ else {
+ nrChipHits -= nrHits; // this is needed when running offline (online nrHits should be 0 already)
+ }
+ }
+ }
+ fNrEqHits+=nrChipHits;
- }
- else {
- if (n>0) {
- // this is a completely noisy chip... put in category enough stat
- fNrEnoughStatChips++;
- good=kTRUE;
- }
- }
+ if (nrChipHits>0) {
+ // make sure the chip is not flagged as dead
+ fHandler->SetDeadChip(GetEqNr(),hs,chip,kFALSE);
+ }
- delete deadPixelHandler;
+ if (nrPossiblyDeadPixels==0) {
+ // no need to see if we have enough statistics...
+ fNrEnoughStatChips++;
+ good=kTRUE;
+ // printf("%3d",good);
+ // if (chip==9) printf("\n");
+ continue;
+ }
- printf("%3d",good);
- if (chip==9) printf("\n");
+ if (nrChipHits==0) {
+ nrPossiblyDeadChips++;
+ possiblyDead->Insert(hs,chip);
+ good=kFALSE;
+ // printf("%3d",good);
+ // if (chip==9) printf("\n");
+ continue;
+ }
- } // for chip
+ // Binomial with n events and probability p for pixel hit
+ UInt_t n = GetNrEvents();
+ if (nrPixels>0 && n>0) {
+
+ Double_t p = (Double_t)nrChipHits/nrPixels/n;
+
+ // probability of falsely assigning a dead pixel
+ Double_t falselyDeadProb = pow((Double_t)(1-p),(Double_t)n);
+ // printf("falselyprob=%e\n",falselyDeadProb);
+
+ // can we find dead pixels...?
+ if (falselyDeadProb<fThreshDead) {
+ fNrEnoughStatChips++;
+ good=kTRUE;
+ // add dead pixels to handler
+ for (UInt_t col=0; col<32; col++) {
+ for (UInt_t row=0; row<256; row++) {
+ UInt_t nrHits = fPhysObj->GetHits(hs,chip,col,row);
+ if (nrHits==0) {
+ if (!fHandler->IsPixelNoisy(GetEqNr(),hs,chip,col,row)) {
+ // don't include noisy pixels
+ fHandler->SetDeadPixel(GetEqNr(),hs,chip,col,row);
+ }
+ }
+ }
+ }
+ }
+ if (!good) {
+ // this might be an inefficient chip
+ possiblyIneff->Insert(hs*10+chip,nrChipHits);
+ }
+
+ }
+ else {
+ if (n>0) {
+ // this is a completely noisy chip... put in category enough stat
+ fNrEnoughStatChips++;
+ good=kTRUE;
+ }
+ }
+
+ // printf("%3d",good);
+ // if (chip==9) printf("\n");
+
+ }
+ } // for chip
+ }
} // for hs
+
+ Int_t key,val;
// dead chips?
if (fNrEqHits>fMinNrEqHitsForDeadChips) {
- fHandler->AddDeadFrom(deadChipHandler);
- fNrDeadChips=nrPossiblyDeadChips;
- }
- else {
- fNrDeadChips=0;
+ while (possiblyDead->Pop(key,val)) {
+ fHandler->SetDeadChip(GetEqNr(),key,val,kFALSE);
+ }
+ fNrDeadChips+=nrPossiblyDeadChips;
}
- delete deadChipHandler;
-
+ delete possiblyDead;
// inefficient chips?
- Int_t key,val;
while (possiblyIneff->Pop(key,val)) {
if (val<fNrEqHits/60*fRatioToMeanForInefficientChip) {
fNrInefficientChips++;
valExp--;
}
}
+//____________________________________________________________________________________________________
+TH2F* AliITSOnlineSPDphysAnalyzer::GetPhysicalHitMapTot() {
+ // creates and returns a pointer to a hitmap histo (equipment opened up)
+ // physical representation of the half stave hitmap.
-
-
+ if (fPhysObj==NULL) {
+ Error("AliITSOnlineSPDphysAnalyzer::GetPhysicalHitMapTot","No data!");
+ return NULL;
+ }
+ TString histoname = Form("Eq %d",GetEqNr());
+ TH2F* hPhysicalHitMapTot = new TH2F(histoname.Data(),histoname.Data(),32*10,-0.5,32*10-0.5,256*6,-0.5,256*6-0.5);
+ hPhysicalHitMapTot->SetNdivisions(-10,"X");
+ hPhysicalHitMapTot->SetNdivisions(-006,"Y");
+ hPhysicalHitMapTot->SetTickLength(0,"X");
+ hPhysicalHitMapTot->SetTickLength(0,"Y");
+ hPhysicalHitMapTot->GetXaxis()->SetLabelColor(gStyle->GetCanvasColor());
+ hPhysicalHitMapTot->GetYaxis()->SetLabelColor(gStyle->GetCanvasColor());
+ Int_t correctChip=-1;
+ for (UInt_t hs=0; hs<6; hs++) {
+ for (UInt_t chipNr=0; chipNr<10; chipNr++) {
+ if(GetEqNr()<10) correctChip=9-chipNr;
+ else correctChip=chipNr;
+ for (UInt_t col=0; col<32; col++) {
+ for (UInt_t row=0; row<256; row++) {
+ if(hs>1) hPhysicalHitMapTot->Fill(correctChip*32+(31-col),(5-hs)*256+row,fPhysObj->GetHits(hs,chipNr,col,row));
+ else hPhysicalHitMapTot->Fill(correctChip*32+col,(5-hs)*256+row,fPhysObj->GetHits(hs,chipNr,col,row));
+ }
+ }
+ }
+ }
+ return hPhysicalHitMapTot;
+}
+//_____________________________________________________________________________________________________
TH2F* AliITSOnlineSPDphysAnalyzer::GetHitMapTot() {
// creates and returns a pointer to a hitmap histo (half sector style a la spdmood)
+ // This histogram shown the read out numbering pattern, it is not the physical one.
if (fPhysObj==NULL) {
Error("AliITSOnlineSPDphysAnalyzer::GetHitMapTot","No data!");
return NULL;
}
return fHitMapTot;
}
-
+//________________________________________________________________________________________________________
TH2F* AliITSOnlineSPDphysAnalyzer::GetHitMapChip(UInt_t hs, UInt_t chip) {
// creates and returns a pointer to a hitmap histo (chip style a la spdmood)
if (fPhysObj==NULL) {
returnHisto->SetMinimum(0);
for (UInt_t col=0; col<32; col++) {
for (UInt_t row=0; row<256; row++) {
- returnHisto->Fill(col,row,fPhysObj->GetHits(hs,chip,col,row));
+ if(hs<2) returnHisto->Fill(31-col,row,fPhysObj->GetHits(hs,chip,col,row));
+ else returnHisto->Fill(col,row,fPhysObj->GetHits(hs,chip,col,row));
}
}
return returnHisto;
}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff