#include <iostream>
#include <fstream>
-AliITSOnlineSPDphysAnalyzer::AliITSOnlineSPDphysAnalyzer(const Char_t *fileName, AliITSOnlineCalibrationSPDhandler* handler) :
+using std::ifstream;
+
+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::ProcessNoisyPixels(UInt_t eq, UInt_t nrEvts) {
+ // process noisy pixel data , returns number of chips with enough statistics
+ if (fPhysObj==NULL) {
+ Warning("AliITSOnlineSPDphysAnalyzer::ProcessNoisyPixels","No data!");
+ return 0;
+ }
+ // do we have enough events to even try the algorithm?
+ if (nrEvts < fMinEventsForNoisy) {
+ Warning("AliITSOnlineSPDphysAnalyzer::ProcessNoisyPixels","Nr events (%d) < fMinEventsForNoisy (%d)!",nrEvts,fMinEventsForNoisy);
+ return 0;
+ }
+ // handler should be initialized
+ if (fHandler==NULL) {
+ Error("AliITSOnlineSPDphysAnalyzer::ProcessNoisyPixels","Calibration handler is not initialized!");
+ return 0;
+ }
+
+ UInt_t nrEnoughStatChips = 0;
+
+ for (UInt_t hs=0; hs<6; hs++) {
+ for (UInt_t chip=0; chip<10; chip++) {
+
+ 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 (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 {
+ if (nrMostHits<nrHits) nrMostHits=nrHits;
+ }
+ }
+ }
+
+ 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);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ }
+
+ } // for chip
+ } // for hs
+
+ return nrEnoughStatChips;
+}
+
UInt_t AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels() {
// process dead pixel data , returns number of chips with enough statistics
Warning("AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels","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);
fNrEqHits = 0;
- AliITSOnlineCalibrationSPDhandler *deadPixelHandler = new AliITSOnlineCalibrationSPDhandler();
-
for (UInt_t hs=0; hs<6; hs++) {
- if (!(fHandler->IsActiveHS(GetEqNr(),hs))) {
+ if (!fHandler->IsActiveHS(GetEqNr(),hs)) {
fNrDeadChips+=10;
}
else {
for (UInt_t chip=0; chip<10; chip++) {
- if (!(fHandler->IsActiveChip(GetEqNr(),hs,chip))) {
+ if (!fHandler->IsActiveChip(GetEqNr(),hs,chip)) {
fNrDeadChips++;
}
else {
// perform search for individual dead pixels...
- deadPixelHandler->ResetDead();
Bool_t good=kFALSE;
UInt_t nrPossiblyDeadPixels = 0;
nrPixels++;
if (nrHits==0) {
nrPossiblyDeadPixels++;
- deadPixelHandler->SetDeadPixel(GetEqNr(),hs,chip,col,row);
+ }
+ else {
+ fHandler->UnSetDeadPixel(GetEqNr(),hs,chip,col,row); // unset (no action unless dead before)
}
}
else {
}
fNrEqHits+=nrChipHits;
- // check all pixels that were declared dead from before...
- UInt_t nrDeadBefore = fHandler->GetNrDeadC(GetEqNr(),hs,chip);
- 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); // This was a bug - cannot delete while moving through indices, use tmpHand instead
- tmpHand->SetDeadPixel(GetEqNr(),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));
+ if (nrChipHits>0) {
+ // make sure the chip is not flagged as dead
+ fHandler->SetDeadChip(GetEqNr(),hs,chip,kFALSE);
}
- delete tmpHand;
-
-
if (nrPossiblyDeadPixels==0) {
// no need to see if we have enough statistics...
if (nrChipHits==0) {
nrPossiblyDeadChips++;
- //!!! deadChipHandler->SetDeadChip(GetEqNr(),hs,chip);
possiblyDead->Insert(hs,chip);
good=kFALSE;
// printf("%3d",good);
Double_t p = (Double_t)nrChipHits/nrPixels/n;
// 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);
- break;
+ 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) {
}
} // for hs
- delete deadPixelHandler;
Int_t key,val;
+
// dead chips?
if (fNrEqHits>fMinNrEqHitsForDeadChips) {
while (possiblyDead->Pop(key,val)) {
- fHandler->ActivateChip(GetEqNr(),key,val,kFALSE);
+ fHandler->SetDeadChip(GetEqNr(),key,val,kFALSE);
}
fNrDeadChips+=nrPossiblyDeadChips;
}
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