]> jspc29.x-matter.uni-frankfurt.de Git - radhard.git/commitdiff
Analyzer: clean up
authorBenjamin Linnik <blinnik@jspc61.x-matter.uni-frankfurt.de>
Wed, 6 Dec 2017 17:52:23 +0000 (18:52 +0100)
committerBenjamin Linnik <blinnik@jspc61.x-matter.uni-frankfurt.de>
Wed, 6 Dec 2017 17:52:23 +0000 (18:52 +0100)
MABS_run_analyzer/ChargeSpektrum.c
MABS_run_analyzer/HistogramType.c

index 8be67374a2442c3a9714d2b6c5426c9f2968ea44..1d8801bb56337776a50980067a207d07ea543eed 100644 (file)
@@ -68,24 +68,24 @@ void ChargeSpektrum(TString runnumber = "")
     datainputPosVeto =new TNtupleO("Position Veto", "data", "x:y:xerr:yerr");
     vector<TH1FO*> compareHistogramVectorDepletion, compareHistogramVectorDepletionSum;   
     vector<TNtupleO*> ntupleVectorDepltetion1, ntupleVectorDepltetion2, ntupleVectorDepltetion3;
-        
+    
     // variables for temperature analysis
     vector<HistogramType*> compareHistogramClassVectorTemp;
     TNtupleO *averageChargeCollectedSeed, *averageChargeCollectedSum;
     vector<TNtupleO*> vectorAverageChargeCollectedSeed;
     averageChargeCollectedSum =new TNtupleO("Average charge collected by Sum", "data", "x:y:xerr:yerr");
     averageChargeCollectedSeed =new TNtupleO("Average charge collected by Seed", "data", "x:y:xerr:yerr");
-        
+    
     // variables for RTS analysis
     vector<TH1FO*> compareHistogramVectorRTSSeed, compareHistogramVectorRTSSum;
-        
+    
     // variables for cluster multiplicity
     vector<TH1FO*> compareHistogramVectorClusterMultiplicity;
     vector<TNtupleO*> ntupleVectorAvgChargeColl;
     
     // f0 analysis variables  
     vector<TH1FO*> compareHistogramAllRunsVectorF0;
-        
+    
     // leakage current analysis variables  
     vector<TH1FO*> compareHistogramLeakageCurrent;
     
@@ -108,366 +108,366 @@ void ChargeSpektrum(TString runnumber = "")
                 runs[runi]->fillTTreeWithMoreThenInitialNoiseValues(true);
                 
                 
-//                 if (runi == 1)
-//                     runs[runi]->setSubMatrixBorders(0,100,0,100);
-//                 if (runi == 2)
-//                     runs[runi]->setSubMatrixBorders(100,120,100,120);
+                //                 if (runi == 1)
+                //                     runs[runi]->setSubMatrixBorders(0,100,0,100);
+                //                 if (runi == 2)
+                //                     runs[runi]->setSubMatrixBorders(100,120,100,120);
                 //runs[runi]->setFixedThresholdValueElectrons(1440);   
-//             float_t cutval = runs[runi]->histogramwoRTS->Sum->GetBinCenter(runs[runi]->histogramwoRTS->Sum->FindLastBinAbove(3,1));
-//                 runs[runi]->setFixedThresholdValueADU(cutval*0.6);
+                //             float_t cutval = runs[runi]->histogramwoRTS->Sum->GetBinCenter(runs[runi]->histogramwoRTS->Sum->FindLastBinAbove(3,1));
+                //                 runs[runi]->setFixedThresholdValueADU(cutval*0.6);
                 //runs[runi]->setNoisethresholdborderADU(800);
-             //runs[runi]->setNoisethresholdborderE(220);
-//                 runs[runi]->analyzeFrame(680);
-//                   continue;
-//             runs[runi]->setFixedThresholdValueADU(30);
-                    
-
+                //runs[runi]->setNoisethresholdborderE(220);
+                //                 runs[runi]->analyzeFrame(680);
+                //                   continue;
+                //             runs[runi]->setFixedThresholdValueADU(30);
+                
+                
                 // creates or opens .root file, can analyze the RAW data
                 if (runListForceAnalysis.size() >= (unsigned)runi+1)
                 {
                     if (runListForceAnalysis[runi])
                         runs[runi]->error=runs[runi]->analyzeRun(true); // creates or opens .root file, can analyze the RAW data
-                    else
-                        runs[runi]->error=runs[runi]->analyzeRun(false); // creates or opens .root file, can analyze the RAW data
+                        else
+                            runs[runi]->error=runs[runi]->analyzeRun(false); // creates or opens .root file, can analyze the RAW data
                 } else
                     runs[runi]->error=runs[runi]->analyzeRun(false); // creates or opens .root file, can analyze the RAW data
-                if (runs[runi]->error) // first time analysis without forcing new ROOT file failed, retry with forcing new analysis
-                {
-                    runs[runi]->error = false;
-                    runs[runi]->error=runs[runi]->analyzeRun(true);
-                }                
-                if (!runs[runi]->error)
-                {
-                    if (runListCustomTitle.size() >= (unsigned)runi+1)
+                    if (runs[runi]->error) // first time analysis without forcing new ROOT file failed, retry with forcing new analysis
+                    {
+                        runs[runi]->error = false;
+                        runs[runi]->error=runs[runi]->analyzeRun(true);
+                    }                
+                    if (!runs[runi]->error)
                     {
-                        if (runListCustomTitle[runi].Length()>0)
+                        if (runListCustomTitle.size() >= (unsigned)runi+1)
                         {
-                            runs[runi]->setLabel(runListCustomTitle[runi]);
-                        }
-                    }
-                    compareHistogramClassVectorMABSBot.push_back(runs[runi]->histogramwoRTS);
-                    
-                    //         gROOT->SetBatch(kTRUE);
-                    if (!isBatch)
-                        gROOT->SetBatch(kFALSE);
-                    
-                    // use only lower case when matching anaylsis types
-                                        
-                    if (analysisType.Contains("clas")) { // classic analysis                        
-                        compareHistogramClassVectorClassic.push_back(runs[runi]->histogram->normalized);
-                        if (runi+1 == numberRuns) 
-                            compareHistogramClassVectorVector.push_back(compareHistogramClassVectorClassic);
-                    }   
-                    
-                    if (analysisType.Contains("clusthresh")) { // cluster charge > 2 * noise in cluster
-                        compareHistogramClassVectorClusterThreshold.push_back(runs[runi]->histogramthreshold->normalized);
-                        if (runi+1 == numberRuns) 
-                            compareHistogramClassVectorVector.push_back(compareHistogramClassVectorClusterThreshold);
-                    }    
-                    
-                    if (analysisType.Contains("dynthresh") || analysisType.Contains("dynamicalthresh")) { // fixed threshold analysis
-                        vector<HistogramType*> compareHistogramClassVectorDynamicalThreshold;
-                        compareHistogramClassVectorDynamicalThreshold.push_back(runs[runi]->histogram);
-                        compareHistogramClassVectorDynamicalThreshold.push_back(runs[runi]->histogramdynamicalthreshold);
-                        plotAllRuns(&compareHistogramClassVectorDynamicalThreshold);
-                        compareHistogramClassVectorDynamicalThreshold.clear();
-                    }   
-                    
-                    if (analysisType.Contains("cali")) { // calibrated analysis
-                        compareHistogramClassVectorCalibrated.push_back(runs[runi]->histogram->normalized->calibrated);
-                        if (runi+1 == numberRuns)
-                            compareHistogramClassVectorVector.push_back(compareHistogramClassVectorCalibrated);
-                    }  
-                    
-                    if (analysisType.Contains("signal")) { // F0 analysis for some frames, quantitatively
-                        runs[runi]->processed->plotSignal(100,1000);
-                    } 
-                    
-                    if (analysisType.Contains("depl")) { // depletion analysis
-                        compareHistogramVectorDepletion.push_back(runs[runi]->histogramdynamicalthreshold->normalized->SeedPerc);
-                                               
-                        datainputPosVeto->itsHistogramType = runs[runi]->histogramdynamicalthreshold;
-                        datainputPosVeto->xaxisTitle = "Voltage";
-                        datainputPosVeto->yaxisTitle = "Position Veto";
-                        datainputPosVeto->Fill(runs[runi]->labbook.depletionV,runs[runi]->histogramdynamicalthreshold->posVeto,0,0);
-                        if (runi+1 == numberRuns) {
-                            ntupleVectorDepltetion1.push_back(datainputPosVeto); 
-                            ntupleVectorVector.push_back(ntupleVectorDepltetion1);
-                        }
-                        
-                        prop2ndpixelfire->itsHistogramType = runs[runi]->histogramdynamicalthreshold;
-                        prop2ndpixelfire->xaxisTitle = "Voltage";
-                        prop2ndpixelfire->yaxisTitle = "Propability for second pixel to fire";
-                        prop2ndpixelfire->Fill(runs[runi]->labbook.depletionV,runs[runi]->histogramdynamicalthreshold->clustermultiplicity->GetBinContent(2),0,0);
-                        if (runi+1 == numberRuns) {
-                            ntupleVectorDepltetion2.push_back(prop2ndpixelfire);
-                            ntupleVectorVector.push_back(ntupleVectorDepltetion2);
-                        }
-                        Double_t* AverageCharge = new Double_t[(*runs[runi]->histogramdynamicalthreshold->a_Sum).size()];
-                        Double_t* TotalHits = new Double_t[(*runs[runi]->histogramdynamicalthreshold->a_Sum).size()];
-                        for (UInt_t sumi = 0; sumi < (*runs[runi]->histogramdynamicalthreshold->a_Sum).size(); sumi++) {
-                            AverageCharge[sumi] = 0;
-                            TotalHits[sumi] = 0;
-                            for (Int_t bini = 1; bini <= (*runs[runi]->histogramdynamicalthreshold->a_Sum)[sumi]->GetXaxis()->GetNbins();++bini) {
-                                AverageCharge[sumi] += (*runs[runi]->histogramdynamicalthreshold->a_Sum)[sumi]->GetBinContent(bini)*(*runs[runi]->histogramdynamicalthreshold->a_Sum)[sumi]->GetBinCenter(bini);
-                                TotalHits[sumi] += (*runs[runi]->histogramdynamicalthreshold->a_Sum)[sumi]->GetBinContent(bini);
+                            if (runListCustomTitle[runi].Length()>0)
+                            {
+                                runs[runi]->setLabel(runListCustomTitle[runi]);
                             }
-                            AverageCharge[sumi] /= TotalHits[sumi]/runs[runi]->histogramdynamicalthreshold->gain;
                         }
+                        compareHistogramClassVectorMABSBot.push_back(runs[runi]->histogramwoRTS);
                         
-                        TNtupleO *numpixelincl;
-                        numpixelincl =new TNtupleO("Average charge collected", "data", "x:y:xerr:yerr");
-                        numpixelincl->itsHistogramType = runs[runi]->histogram;
-                        numpixelincl->xaxisTitle = "Number of pixel in cluster";
-                        numpixelincl->yaxisTitle = "Average charge collected [e]";
-                        for (UInt_t sumi = 0; sumi < (*runs[runi]->histogramdynamicalthreshold->a_Sum).size(); sumi++) {
-                            if (!(sumi%2))
-                                compareHistogramVectorDepletionSum.push_back((*runs[runi]->histogram->normalized->a_Sum)[sumi]);
-                            numpixelincl->Fill(sumi+1,AverageCharge[sumi],0,0);
-                        }
-                        ntupleVectorDepltetion3.push_back(numpixelincl);
-                        if (runi+1 == numberRuns) {
-                            ntupleVectorVector.push_back(ntupleVectorDepltetion3);
-                            compareHistogramVectorVector.push_back(compareHistogramVectorDepletion); 
-                            compareHistogramVectorVector.push_back(compareHistogramVectorDepletionSum);     
-                        }
-                    }
-                    
-                    if (analysisType.Contains("rts")) { // rts studies                        
-                        vector<HistogramType*> compareHistogramClassVectorRTS;                        
-                        compareHistogramClassVectorRTS.push_back(runs[runi]->histogramwoRTS);
-                        compareHistogramClassVectorRTS.push_back(runs[runi]->histogram);
-                        // plot and clear compareHistogramClassVectorRTS vector,
-                        plotAllRuns(&compareHistogramClassVectorRTS);
-                        compareHistogramClassVectorRTS.clear();
-                       
-                        compareHistogramVectorRTSSeed.push_back(runs[runi]->histogramwoRTS->normalized->Seed);
-                        compareHistogramVectorRTSSum.push_back(*(runs[runi]->histogramwoRTS->normalized->Sum));
+                        //         gROOT->SetBatch(kTRUE);
+                        if (!isBatch)
+                            gROOT->SetBatch(kFALSE);
                         
-                        runs[runi]->plot1DHistogram(runs[runi]->histogramwoRTS->pixeltimefiredDistrib);
-                        runs[runi]->plot1DHistogram(runs[runi]->histogramwoRTS->LeakageCurrentInPixelSorted);
+                        // use only lower case when matching anaylsis types
                         
-                        if (runi+1 == numberRuns) {
-                            compareHistogramVectorVector.push_back(compareHistogramVectorRTSSeed); 
-                            compareHistogramVectorVector.push_back(compareHistogramVectorRTSSum); 
-                        }
-                    }
-                    
-                    if (analysisType.Contains("seedf")) { // seedfit: seed integral anaylsis
-                        runs[runi]->plot1DHistogram( runs[runi]->histogram->normalized->Seed, "gaus", true, false, false, runs[runi]->histogram->fixedThresholdValue);
-                        runs[runi]->plot1DHistogram( runs[runi]->histogramdynamicalthreshold->normalized->Seed, "gaus", true, false, false, runs[runi]->histogram->fixedThresholdValue);
+                        if (analysisType.Contains("clas")) { // classic analysis                        
+                            compareHistogramClassVectorClassic.push_back(runs[runi]->histogram->normalized);
+                            if (runi+1 == numberRuns) 
+                                compareHistogramClassVectorVector.push_back(compareHistogramClassVectorClassic);
+                        }   
                         
-                        vector<TH1FO*> compareHistogramVectorSeedFit;                         
-                        compareHistogramVectorSeedFit.push_back(runs[runi]->histogram->Seed);
-                        compareHistogramVectorSeedFit.push_back(runs[runi]->histogramdynamicalthreshold->Seed);
-                        CompareHistograms(&compareHistogramVectorSeedFit);
-                        compareHistogramVectorSeedFit.clear();
+                        if (analysisType.Contains("clusthresh")) { // cluster charge > 2 * noise in cluster
+                            compareHistogramClassVectorClusterThreshold.push_back(runs[runi]->histogramthreshold->normalized);
+                            if (runi+1 == numberRuns) 
+                                compareHistogramClassVectorVector.push_back(compareHistogramClassVectorClusterThreshold);
+                        }    
                         
-                        datainputIntSeed->itsHistogramType = runs[runi]->histogram->normalized;
-                        datainputIntSeed->xaxisTitle = "Voltage";
-                        datainputIntSeed->yaxisTitle = "Integral of Seed";
-                        datainputIntSeed->Fill(runs[runi]->labbook.depletionV,runs[runi]->histogram->integralSeed,0,runs[runi]->histogram->integralSeedErr);
-                        if (runi+1 == numberRuns) {
-                            ntupleVectorSeed.push_back(datainputIntSeed); 
-                            ntupleVectorVector.push_back(ntupleVectorSeed);
-                        }
-                    }
-                    
-                    if (analysisType.Contains("sumf")) { // seedfit: seed integral anaylsis
-                        runs[runi]->plot1DHistogram(*(runs[runi]->histogram->normalized->Sum), "gaus", true, false, false, runs[runi]->histogram->fixedThresholdValue);
-                        runs[runi]->plot1DHistogram(*(runs[runi]->histogramdynamicalthreshold->normalized->Sum), "gaus", true, false, false, runs[runi]->histogram->fixedThresholdValue);
-                        
-                        vector<TH1FO*> compareHistogramVectorSumFit;                         
-                        compareHistogramVectorSumFit.push_back(*(runs[runi]->histogram->Sum));
-                        compareHistogramVectorSumFit.push_back(*(runs[runi]->histogramdynamicalthreshold->Sum));
-                        CompareHistograms(&compareHistogramVectorSumFit);
-                        compareHistogramVectorSumFit.clear();
-                         
-                        datainputIntSum->itsHistogramType = runs[runi]->histogram->normalized;
-                        datainputIntSum->xaxisTitle = "Voltage";
-                        datainputIntSum->yaxisTitle = "Integral of Sum";
-                        datainputIntSum->Fill(runs[runi]->labbook.depletionV,runs[runi]->histogram->integralSum,0,runs[runi]->histogram->integralSumErr);
-                        if (runi+1 == numberRuns) {
-                            ntupleVectorSum.push_back(datainputIntSum); 
-                            ntupleVectorVector.push_back(ntupleVectorSeed);
-                        }                 
-                    }
-                    
-                    if (analysisType.Contains("cluster")) { // analyze cluster formation
-                        // show cluster multiplicity
-                        compareHistogramVectorClusterMultiplicity.push_back(runs[runi]->histogram->normalized->clustermultiplicity);
-//                         runs[runi]->plot1DHistogram( runs[runi]->histogram->clustermultiplicity);                        
+                        if (analysisType.Contains("dynthresh") || analysisType.Contains("dynamicalthresh")) { // fixed threshold analysis
+                            vector<HistogramType*> compareHistogramClassVectorDynamicalThreshold;
+                            compareHistogramClassVectorDynamicalThreshold.push_back(runs[runi]->histogram);
+                            compareHistogramClassVectorDynamicalThreshold.push_back(runs[runi]->histogramdynamicalthreshold);
+                            plotAllRuns(&compareHistogramClassVectorDynamicalThreshold);
+                            compareHistogramClassVectorDynamicalThreshold.clear();
+                        }   
                         
-                        vector<TH1FO*> compareHistogramVectorCluster; 
-                        compareHistogramVectorCluster.push_back(runs[runi]->histogram->Sum9);
-                        compareHistogramVectorCluster.push_back(runs[runi]->histogram->Sum25);
-                        CompareHistograms(&compareHistogramVectorCluster);
-                        compareHistogramVectorCluster.clear();
+                        if (analysisType.Contains("cali")) { // calibrated analysis
+                            compareHistogramClassVectorCalibrated.push_back(runs[runi]->histogram->normalized->calibrated);
+                            if (runi+1 == numberRuns)
+                                compareHistogramClassVectorVector.push_back(compareHistogramClassVectorCalibrated);
+                        }  
                         
+                        if (analysisType.Contains("signal")) { // F0 analysis for some frames, quantitatively
+                            runs[runi]->processed->plotSignal(100,1000);
+                        } 
                         
-                        vector<TH1FO*> compareHistogramVectorCluster2; 
-                        compareHistogramVectorCluster2.push_back(runs[runi]->histogram->Seed);
-                        compareHistogramVectorCluster2.push_back(runs[runi]->histogram->a_Sum9[1]);
-                        compareHistogramVectorCluster2.push_back(runs[runi]->histogram->Sum9);
-                        compareHistogramVectorCluster2.push_back(runs[runi]->histogram->a_Sum25[1]);
-                        compareHistogramVectorCluster2.push_back(runs[runi]->histogram->Sum25);
-                        CompareHistograms(&compareHistogramVectorCluster2);
-                        compareHistogramVectorCluster2.clear();
-                        
-                        Double_t AverageCharge25[25];
-                        Double_t TotalHits25[25];
-                        for (UInt_t sumi = 0; sumi < 25; sumi++) {
-                            AverageCharge25[sumi] = 0;
-                            TotalHits25[sumi] = 0;
-                            for (Int_t bini = 1; bini <= runs[runi]->histogramdynamicalthreshold->a_Sum25[sumi]->GetXaxis()->GetNbins();++bini) {
-                                AverageCharge25[sumi] += runs[runi]->histogramdynamicalthreshold->a_Sum25[sumi]->GetBinContent(bini)*runs[runi]->histogramdynamicalthreshold->a_Sum25[sumi]->GetBinCenter(bini);
-                                TotalHits25[sumi] += runs[runi]->histogramdynamicalthreshold->a_Sum25[sumi]->GetBinContent(bini);
+                        if (analysisType.Contains("depl")) { // depletion analysis
+                            compareHistogramVectorDepletion.push_back(runs[runi]->histogramdynamicalthreshold->normalized->SeedPerc);
+                            
+                            datainputPosVeto->itsHistogramType = runs[runi]->histogramdynamicalthreshold;
+                            datainputPosVeto->xaxisTitle = "Voltage";
+                            datainputPosVeto->yaxisTitle = "Position Veto";
+                            datainputPosVeto->Fill(runs[runi]->labbook.depletionV,runs[runi]->histogramdynamicalthreshold->posVeto,0,0);
+                            if (runi+1 == numberRuns) {
+                                ntupleVectorDepltetion1.push_back(datainputPosVeto); 
+                                ntupleVectorVector.push_back(ntupleVectorDepltetion1);
+                            }
+                            
+                            prop2ndpixelfire->itsHistogramType = runs[runi]->histogramdynamicalthreshold;
+                            prop2ndpixelfire->xaxisTitle = "Voltage";
+                            prop2ndpixelfire->yaxisTitle = "Propability for second pixel to fire";
+                            prop2ndpixelfire->Fill(runs[runi]->labbook.depletionV,runs[runi]->histogramdynamicalthreshold->clustermultiplicity->GetBinContent(2),0,0);
+                            if (runi+1 == numberRuns) {
+                                ntupleVectorDepltetion2.push_back(prop2ndpixelfire);
+                                ntupleVectorVector.push_back(ntupleVectorDepltetion2);
+                            }
+                            Double_t* AverageCharge = new Double_t[(*runs[runi]->histogramdynamicalthreshold->a_Sum).size()];
+                            Double_t* TotalHits = new Double_t[(*runs[runi]->histogramdynamicalthreshold->a_Sum).size()];
+                            for (UInt_t sumi = 0; sumi < (*runs[runi]->histogramdynamicalthreshold->a_Sum).size(); sumi++) {
+                                AverageCharge[sumi] = 0;
+                                TotalHits[sumi] = 0;
+                                for (Int_t bini = 1; bini <= (*runs[runi]->histogramdynamicalthreshold->a_Sum)[sumi]->GetXaxis()->GetNbins();++bini) {
+                                    AverageCharge[sumi] += (*runs[runi]->histogramdynamicalthreshold->a_Sum)[sumi]->GetBinContent(bini)*(*runs[runi]->histogramdynamicalthreshold->a_Sum)[sumi]->GetBinCenter(bini);
+                                    TotalHits[sumi] += (*runs[runi]->histogramdynamicalthreshold->a_Sum)[sumi]->GetBinContent(bini);
+                                }
+                                AverageCharge[sumi] /= TotalHits[sumi]/runs[runi]->histogramdynamicalthreshold->gain;
+                            }
+                            
+                            TNtupleO *numpixelincl;
+                            numpixelincl =new TNtupleO("Average charge collected", "data", "x:y:xerr:yerr");
+                            numpixelincl->itsHistogramType = runs[runi]->histogram;
+                            numpixelincl->xaxisTitle = "Number of pixel in cluster";
+                            numpixelincl->yaxisTitle = "Average charge collected [e]";
+                            for (UInt_t sumi = 0; sumi < (*runs[runi]->histogramdynamicalthreshold->a_Sum).size(); sumi++) {
+                                if (!(sumi%2))
+                                    compareHistogramVectorDepletionSum.push_back((*runs[runi]->histogram->normalized->a_Sum)[sumi]);
+                                numpixelincl->Fill(sumi+1,AverageCharge[sumi],0,0);
+                            }
+                            ntupleVectorDepltetion3.push_back(numpixelincl);
+                            if (runi+1 == numberRuns) {
+                                ntupleVectorVector.push_back(ntupleVectorDepltetion3);
+                                compareHistogramVectorVector.push_back(compareHistogramVectorDepletion); 
+                                compareHistogramVectorVector.push_back(compareHistogramVectorDepletionSum);     
                             }
-//                             AverageCharge25[sumi] /= TotalHits25[sumi]/runs[runi]->histogramdynamicalthreshold->gain;
                         }
                         
-                        TNtupleO *numpixelincl2;
-                        numpixelincl2 =new TNtupleO("Average charge collected", "data", "x:y:xerr:yerr");
-                        numpixelincl2->itsHistogramType = runs[runi]->histogram;
-                        numpixelincl2->Title = "5x5 cluster";
-                        numpixelincl2->xaxisTitle = "Number of pixel in cluster";
-                        numpixelincl2->yaxisTitle = "Average charge collected [ADU]";
-                        for (UInt_t sumi = 0; sumi < 25; sumi++) {
-                            numpixelincl2->Fill(sumi+1,AverageCharge25[sumi],0,0);
+                        if (analysisType.Contains("rts")) { // rts studies                        
+                            vector<HistogramType*> compareHistogramClassVectorRTS;                        
+                            compareHistogramClassVectorRTS.push_back(runs[runi]->histogramwoRTS);
+                            compareHistogramClassVectorRTS.push_back(runs[runi]->histogram);
+                            // plot and clear compareHistogramClassVectorRTS vector,
+                            plotAllRuns(&compareHistogramClassVectorRTS);
+                            compareHistogramClassVectorRTS.clear();
+                            
+                            compareHistogramVectorRTSSeed.push_back(runs[runi]->histogramwoRTS->normalized->Seed);
+                            compareHistogramVectorRTSSum.push_back(*(runs[runi]->histogramwoRTS->normalized->Sum));
+                            
+                            runs[runi]->plot1DHistogram(runs[runi]->histogramwoRTS->pixeltimefiredDistrib);
+                            runs[runi]->plot1DHistogram(runs[runi]->histogramwoRTS->LeakageCurrentInPixelSorted);
+                            
+                            if (runi+1 == numberRuns) {
+                                compareHistogramVectorVector.push_back(compareHistogramVectorRTSSeed); 
+                                compareHistogramVectorVector.push_back(compareHistogramVectorRTSSum); 
+                            }
                         }
-                        ntupleVectorAvgChargeColl.push_back(numpixelincl2);
                         
-                        Double_t AverageCharge9[9];
-                        Double_t TotalHits9[9];
-                        for (UInt_t sumi = 0; sumi < 9; sumi++) {
-                            AverageCharge9[sumi] = 0;
-                            TotalHits9[sumi] = 0;
-                            for (Int_t bini = 1; bini <= runs[runi]->histogramdynamicalthreshold->a_Sum9[sumi]->GetXaxis()->GetNbins();++bini) {
-                                AverageCharge9[sumi] += runs[runi]->histogramdynamicalthreshold->a_Sum9[sumi]->GetBinContent(bini)*runs[runi]->histogramdynamicalthreshold->a_Sum9[sumi]->GetBinCenter(bini);
-                                TotalHits9[sumi] += runs[runi]->histogramdynamicalthreshold->a_Sum9[sumi]->GetBinContent(bini);
+                        if (analysisType.Contains("seedf")) { // seedfit: seed integral anaylsis
+                            runs[runi]->plot1DHistogram( runs[runi]->histogram->normalized->Seed, "gaus", true, false, false, runs[runi]->histogram->fixedThresholdValue);
+                            runs[runi]->plot1DHistogram( runs[runi]->histogramdynamicalthreshold->normalized->Seed, "gaus", true, false, false, runs[runi]->histogram->fixedThresholdValue);
+                            
+                            vector<TH1FO*> compareHistogramVectorSeedFit;                         
+                            compareHistogramVectorSeedFit.push_back(runs[runi]->histogram->Seed);
+                            compareHistogramVectorSeedFit.push_back(runs[runi]->histogramdynamicalthreshold->Seed);
+                            CompareHistograms(&compareHistogramVectorSeedFit);
+                            compareHistogramVectorSeedFit.clear();
+                            
+                            datainputIntSeed->itsHistogramType = runs[runi]->histogram->normalized;
+                            datainputIntSeed->xaxisTitle = "Voltage";
+                            datainputIntSeed->yaxisTitle = "Integral of Seed";
+                            datainputIntSeed->Fill(runs[runi]->labbook.depletionV,runs[runi]->histogram->integralSeed,0,runs[runi]->histogram->integralSeedErr);
+                            if (runi+1 == numberRuns) {
+                                ntupleVectorSeed.push_back(datainputIntSeed); 
+                                ntupleVectorVector.push_back(ntupleVectorSeed);
                             }
-//                             AverageCharge9[sumi] /= TotalHits9[sumi]/runs[runi]->histogramdynamicalthreshold->gain;
                         }
                         
-                        TNtupleO *numpixelincl;
-                        numpixelincl =new TNtupleO("Average charge collected", "data", "x:y:xerr:yerr");
-                        numpixelincl->itsHistogramType = runs[runi]->histogram;
-                        numpixelincl->Title = "3x3 cluster";
-                        numpixelincl->xaxisTitle = "Number of pixel in cluster";
-                        numpixelincl->yaxisTitle = "Average charge collected [ADU]";
-                        for (UInt_t sumi = 0; sumi < 9; sumi++) {
-                            numpixelincl->Fill(sumi+1,AverageCharge9[sumi],0,0);
+                        if (analysisType.Contains("sumf")) { // seedfit: seed integral anaylsis
+                            runs[runi]->plot1DHistogram(*(runs[runi]->histogram->normalized->Sum), "gaus", true, false, false, runs[runi]->histogram->fixedThresholdValue);
+                            runs[runi]->plot1DHistogram(*(runs[runi]->histogramdynamicalthreshold->normalized->Sum), "gaus", true, false, false, runs[runi]->histogram->fixedThresholdValue);
+                            
+                            vector<TH1FO*> compareHistogramVectorSumFit;                         
+                            compareHistogramVectorSumFit.push_back(*(runs[runi]->histogram->Sum));
+                            compareHistogramVectorSumFit.push_back(*(runs[runi]->histogramdynamicalthreshold->Sum));
+                            CompareHistograms(&compareHistogramVectorSumFit);
+                            compareHistogramVectorSumFit.clear();
+                            
+                            datainputIntSum->itsHistogramType = runs[runi]->histogram->normalized;
+                            datainputIntSum->xaxisTitle = "Voltage";
+                            datainputIntSum->yaxisTitle = "Integral of Sum";
+                            datainputIntSum->Fill(runs[runi]->labbook.depletionV,runs[runi]->histogram->integralSum,0,runs[runi]->histogram->integralSumErr);
+                            if (runi+1 == numberRuns) {
+                                ntupleVectorSum.push_back(datainputIntSum); 
+                                ntupleVectorVector.push_back(ntupleVectorSeed);
+                            }                 
                         }
-                        ntupleVectorAvgChargeColl.push_back(numpixelincl);
                         
-                        if (runi+1 == numberRuns) {
-                            compareHistogramVectorVector.push_back(compareHistogramVectorClusterMultiplicity);
-                            ntupleVectorVector.push_back(ntupleVectorAvgChargeColl);
+                        if (analysisType.Contains("cluster")) { // analyze cluster formation
+                            // show cluster multiplicity
+                            compareHistogramVectorClusterMultiplicity.push_back(runs[runi]->histogram->normalized->clustermultiplicity);
+                            //                         runs[runi]->plot1DHistogram( runs[runi]->histogram->clustermultiplicity);                        
+                            
+                            vector<TH1FO*> compareHistogramVectorCluster; 
+                            compareHistogramVectorCluster.push_back(runs[runi]->histogram->Sum9);
+                            compareHistogramVectorCluster.push_back(runs[runi]->histogram->Sum25);
+                            CompareHistograms(&compareHistogramVectorCluster);
+                            compareHistogramVectorCluster.clear();
+                            
+                            
+                            vector<TH1FO*> compareHistogramVectorCluster2; 
+                            compareHistogramVectorCluster2.push_back(runs[runi]->histogram->Seed);
+                            compareHistogramVectorCluster2.push_back(runs[runi]->histogram->a_Sum9[1]);
+                            compareHistogramVectorCluster2.push_back(runs[runi]->histogram->Sum9);
+                            compareHistogramVectorCluster2.push_back(runs[runi]->histogram->a_Sum25[1]);
+                            compareHistogramVectorCluster2.push_back(runs[runi]->histogram->Sum25);
+                            CompareHistograms(&compareHistogramVectorCluster2);
+                            compareHistogramVectorCluster2.clear();
+                            
+                            Double_t AverageCharge25[25];
+                            Double_t TotalHits25[25];
+                            for (UInt_t sumi = 0; sumi < 25; sumi++) {
+                                AverageCharge25[sumi] = 0;
+                                TotalHits25[sumi] = 0;
+                                for (Int_t bini = 1; bini <= runs[runi]->histogramdynamicalthreshold->a_Sum25[sumi]->GetXaxis()->GetNbins();++bini) {
+                                    AverageCharge25[sumi] += runs[runi]->histogramdynamicalthreshold->a_Sum25[sumi]->GetBinContent(bini)*runs[runi]->histogramdynamicalthreshold->a_Sum25[sumi]->GetBinCenter(bini);
+                                    TotalHits25[sumi] += runs[runi]->histogramdynamicalthreshold->a_Sum25[sumi]->GetBinContent(bini);
+                                }
+                                //                             AverageCharge25[sumi] /= TotalHits25[sumi]/runs[runi]->histogramdynamicalthreshold->gain;
+                            }
+                            
+                            TNtupleO *numpixelincl2;
+                            numpixelincl2 =new TNtupleO("Average charge collected", "data", "x:y:xerr:yerr");
+                            numpixelincl2->itsHistogramType = runs[runi]->histogram;
+                            numpixelincl2->Title = "5x5 cluster";
+                            numpixelincl2->xaxisTitle = "Number of pixel in cluster";
+                            numpixelincl2->yaxisTitle = "Average charge collected [ADU]";
+                            for (UInt_t sumi = 0; sumi < 25; sumi++) {
+                                numpixelincl2->Fill(sumi+1,AverageCharge25[sumi],0,0);
+                            }
+                            ntupleVectorAvgChargeColl.push_back(numpixelincl2);
+                            
+                            Double_t AverageCharge9[9];
+                            Double_t TotalHits9[9];
+                            for (UInt_t sumi = 0; sumi < 9; sumi++) {
+                                AverageCharge9[sumi] = 0;
+                                TotalHits9[sumi] = 0;
+                                for (Int_t bini = 1; bini <= runs[runi]->histogramdynamicalthreshold->a_Sum9[sumi]->GetXaxis()->GetNbins();++bini) {
+                                    AverageCharge9[sumi] += runs[runi]->histogramdynamicalthreshold->a_Sum9[sumi]->GetBinContent(bini)*runs[runi]->histogramdynamicalthreshold->a_Sum9[sumi]->GetBinCenter(bini);
+                                    TotalHits9[sumi] += runs[runi]->histogramdynamicalthreshold->a_Sum9[sumi]->GetBinContent(bini);
+                                }
+                                //                             AverageCharge9[sumi] /= TotalHits9[sumi]/runs[runi]->histogramdynamicalthreshold->gain;
+                            }
+                            
+                            TNtupleO *numpixelincl;
+                            numpixelincl =new TNtupleO("Average charge collected", "data", "x:y:xerr:yerr");
+                            numpixelincl->itsHistogramType = runs[runi]->histogram;
+                            numpixelincl->Title = "3x3 cluster";
+                            numpixelincl->xaxisTitle = "Number of pixel in cluster";
+                            numpixelincl->yaxisTitle = "Average charge collected [ADU]";
+                            for (UInt_t sumi = 0; sumi < 9; sumi++) {
+                                numpixelincl->Fill(sumi+1,AverageCharge9[sumi],0,0);
+                            }
+                            ntupleVectorAvgChargeColl.push_back(numpixelincl);
+                            
+                            if (runi+1 == numberRuns) {
+                                compareHistogramVectorVector.push_back(compareHistogramVectorClusterMultiplicity);
+                                ntupleVectorVector.push_back(ntupleVectorAvgChargeColl);
+                            }
+                            
                         }
                         
-                    }
-                    
-                    if (analysisType.Contains("temp")) { // analyze temperatur dependance
-                        compareHistogramClassVectorTemp.push_back(runs[runi]->histogramfixedthreshold->normalized);
+                        if (analysisType.Contains("temp")) { // analyze temperatur dependance
+                            compareHistogramClassVectorTemp.push_back(runs[runi]->histogramfixedthreshold->normalized);
+                            
+                            Double_t AverageChargeTempSeed = 0;
+                            Double_t AverageChargeTempSum = 0;
+                            Double_t TotalHitsTemp = 0;
+                            for (Int_t bini = 1; bini <= runs[runi]->histogramfixedthreshold->normalized->Seed->GetXaxis()->GetNbins();++bini) {
+                                AverageChargeTempSeed += runs[runi]->histogramfixedthreshold->normalized->Seed->GetBinContent(bini)*runs[runi]->histogramfixedthreshold->normalized->Seed->GetBinCenter(bini);
+                                TotalHitsTemp += runs[runi]->histogramfixedthreshold->normalized->Seed->GetBinContent(bini);
+                            }  
+                            AverageChargeTempSeed /= TotalHitsTemp;
+                            for (Int_t bini = 1; bini <= (*runs[runi]->histogramfixedthreshold->normalized->Sum)->GetXaxis()->GetNbins();++bini) {
+                                AverageChargeTempSum += (*runs[runi]->histogramfixedthreshold->normalized->Sum)->GetBinContent(bini)*(*runs[runi]->histogramfixedthreshold->normalized->Sum)->GetBinCenter(bini);
+                            }
+                            AverageChargeTempSum /= TotalHitsTemp;
+                            
+                            averageChargeCollectedSeed->itsHistogramType = runs[runi]->histogramfixedthreshold->normalized;
+                            averageChargeCollectedSeed->xaxisTitle = "Temperature [°C]";
+                            averageChargeCollectedSeed->yaxisTitle = "Average charge collected [ADU]";
+                            
+                            averageChargeCollectedSum->itsHistogramType = runs[runi]->histogramfixedthreshold->normalized;
+                            averageChargeCollectedSum->xaxisTitle = "Temperature [°C]";                        
+                            averageChargeCollectedSum->yaxisTitle = "Average charge collected [ADU]";
+                            
+                            averageChargeCollectedSeed->Fill(runs[runi]->labbook.tempSens,AverageChargeTempSeed,2,0);
+                            averageChargeCollectedSum->Fill(runs[runi]->labbook.tempSens,AverageChargeTempSum,2,0);
+                            
+                            if (runi+1 == numberRuns) {
+                                compareHistogramClassVectorVector.push_back(compareHistogramClassVectorTemp);
+                                vectorAverageChargeCollectedSeed.push_back(averageChargeCollectedSeed);
+                                vectorAverageChargeCollectedSeed.push_back(averageChargeCollectedSum);
+                                ntupleVectorVector.push_back(vectorAverageChargeCollectedSeed);
+                            }
+                            
+                        }
                         
-                        Double_t AverageChargeTempSeed = 0;
-                        Double_t AverageChargeTempSum = 0;
-                        Double_t TotalHitsTemp = 0;
-                        for (Int_t bini = 1; bini <= runs[runi]->histogramfixedthreshold->normalized->Seed->GetXaxis()->GetNbins();++bini) {
-                            AverageChargeTempSeed += runs[runi]->histogramfixedthreshold->normalized->Seed->GetBinContent(bini)*runs[runi]->histogramfixedthreshold->normalized->Seed->GetBinCenter(bini);
-                            TotalHitsTemp += runs[runi]->histogramfixedthreshold->normalized->Seed->GetBinContent(bini);
-                        }      
-                        AverageChargeTempSeed /= TotalHitsTemp;
-                        for (Int_t bini = 1; bini <= (*runs[runi]->histogramfixedthreshold->normalized->Sum)->GetXaxis()->GetNbins();++bini) {
-                            AverageChargeTempSum += (*runs[runi]->histogramfixedthreshold->normalized->Sum)->GetBinContent(bini)*(*runs[runi]->histogramfixedthreshold->normalized->Sum)->GetBinCenter(bini);
+                        if (analysisType.Contains("f0") || analysisType.Contains("f1")) { // analyze cluster formation
+                            // Plot F0 signal
+                            vector<TH1FO*> compareHistogramVectorF0;
+                            compareHistogramVectorF0.push_back(runs[runi]->averageF0DistrEnd);
+                            compareHistogramVectorF0.push_back(runs[runi]->averageF0DistrStart);
+                            CompareHistograms(&compareHistogramVectorF0);                        
+                            compareHistogramVectorF0.clear();
+                            
+                            // Plot overall F0 and F1 signal
+                            vector<TH1FO*> compareHistogramVectorF0F1;
+                            compareHistogramVectorF0F1.push_back(runs[runi]->averageF0Distr);
+                            compareHistogramVectorF0F1.push_back(runs[runi]->averageF1Distr);
+                            CompareHistograms(&compareHistogramVectorF0F1);                        
+                            compareHistogramVectorF0F1.clear();
+                            
+                            compareHistogramAllRunsVectorF0.push_back(runs[runi]->averageF0Distr);
+                            runs[runi]->plot1DHistogram( runs[runi]->averageF0Distr, "gaus", true);
+                            
+                            compareHistogramAllRunsVectorF0.push_back(runs[runi]->averageF0Distr);
+                            runs[runi]->plot1DHistogram( runs[runi]->averageF0Distr, "gaus", true);
                         }
-                        AverageChargeTempSum /= TotalHitsTemp;
                         
-                        averageChargeCollectedSeed->itsHistogramType = runs[runi]->histogramfixedthreshold->normalized;
-                        averageChargeCollectedSeed->xaxisTitle = "Temperature [°C]";
-                        averageChargeCollectedSeed->yaxisTitle = "Average charge collected [ADU]";
-            
-                        averageChargeCollectedSum->itsHistogramType = runs[runi]->histogramfixedthreshold->normalized;
-                        averageChargeCollectedSum->xaxisTitle = "Temperature [°C]";
-                        averageChargeCollectedSum->yaxisTitle = "Average charge collected [ADU]";
                         
-                        averageChargeCollectedSeed->Fill(runs[runi]->labbook.tempSens,AverageChargeTempSeed,2,0);
-                        averageChargeCollectedSum->Fill(runs[runi]->labbook.tempSens,AverageChargeTempSum,2,0);
                         
-                        if (runi+1 == numberRuns) {
-                            compareHistogramClassVectorVector.push_back(compareHistogramClassVectorTemp);
-                            vectorAverageChargeCollectedSeed.push_back(averageChargeCollectedSeed);
-                            vectorAverageChargeCollectedSeed.push_back(averageChargeCollectedSum);
-                            ntupleVectorVector.push_back(vectorAverageChargeCollectedSeed);
+                        if (analysisType.Contains("leak")) { // analyze cluster formation
+                            // Plot leakage current            
+                            compareHistogramLeakageCurrent.push_back(runs[runi]->histogramwoRTS->LeakageCurrentDistrib);
+                            if (runi+1 == numberRuns) {
+                                compareHistogramVectorVector.push_back(compareHistogramLeakageCurrent);     
+                            }
+                            
+                            runs[runi]->plot1DHistogram(runs[runi]->histogramdynamicalthreshold->Veto, "GaussTail", true);
+                            runs[runi]->plot1DHistogram(runs[runi]->histogramwoRTS->LeakageCurrentInPixelSorted, "", false, true);
                         }
-                                    
-                    }
-                                        
-                    if (analysisType.Contains("f0") || analysisType.Contains("f1")) { // analyze cluster formation
-                        // Plot F0 signal
-                        vector<TH1FO*> compareHistogramVectorF0;
-                        compareHistogramVectorF0.push_back(runs[runi]->averageF0DistrEnd);
-                        compareHistogramVectorF0.push_back(runs[runi]->averageF0DistrStart);
-                        CompareHistograms(&compareHistogramVectorF0);                        
-                        compareHistogramVectorF0.clear();
                         
-                        // Plot overall F0 and F1 signal
-                        vector<TH1FO*> compareHistogramVectorF0F1;
-                        compareHistogramVectorF0F1.push_back(runs[runi]->averageF0Distr);
-                        compareHistogramVectorF0F1.push_back(runs[runi]->averageF1Distr);
-                        CompareHistograms(&compareHistogramVectorF0F1);                        
-                        compareHistogramVectorF0F1.clear();
                         
-                        compareHistogramAllRunsVectorF0.push_back(runs[runi]->averageF0Distr);
-                        runs[runi]->plot1DHistogram( runs[runi]->averageF0Distr, "gaus", true);
                         
-                        compareHistogramAllRunsVectorF0.push_back(runs[runi]->averageF0Distr);
-                        runs[runi]->plot1DHistogram( runs[runi]->averageF0Distr, "gaus", true);
-                    }
-                    
-                    
-                    
-                    if (analysisType.Contains("leak")) { // analyze cluster formation
-                        // Plot leakage current            
-                        compareHistogramLeakageCurrent.push_back(runs[runi]->histogramwoRTS->LeakageCurrentDistrib);
-                        if (runi+1 == numberRuns) {
-                            compareHistogramVectorVector.push_back(compareHistogramLeakageCurrent);     
-                        }
+                        // write all histograms to a dat file, can be imported by ORIGIN or Excel. Leave this line ;)
+                        runs[runi]->writeAllHistogramsToFile();
                         
-                        runs[runi]->plot1DHistogram(runs[runi]->histogramdynamicalthreshold->Veto, "GaussTail", true);
-                        runs[runi]->plot1DHistogram(runs[runi]->histogramwoRTS->LeakageCurrentInPixelSorted, "", false, true);
                     }
-                    
-                    
-
-                    // write all histograms to a dat file, can be imported by ORIGIN or Excel. Leave this line ;)
-                    runs[runi]->writeAllHistogramsToFile();
-                     
-                }
-                //cout << runs[runi]->histogram
+                    //cout << runs[runi]->histogram
             }
         }
     } // loop over all runs end
-
     
-for (std::vector< std::vector<TH1FO*> > ::iterator curHistogramVector = compareHistogramVectorVector.begin(); curHistogramVector != compareHistogramVectorVector.end(); curHistogramVector++)  {
-    CompareHistograms(&(*curHistogramVector));
-    writeObservableToFile(&(*curHistogramVector));
-}
-
-for (std::vector< std::vector<HistogramType*> > ::iterator curHistogramClassVector = compareHistogramClassVectorVector.begin(); curHistogramClassVector != compareHistogramClassVectorVector.end(); curHistogramClassVector++)  {
-    printSummaryTable(&(*curHistogramClassVector));
-    plotAllRuns(&(*curHistogramClassVector));
-    writeOneHistogramTypeToFile(&(*curHistogramClassVector));
-}
-
-for (std::vector< std::vector<TNtupleO*> > ::iterator curNtupleVector = ntupleVectorVector.begin(); curNtupleVector != ntupleVectorVector.end(); curNtupleVector++)  {
-    plot1DData(&(*curNtupleVector));
-}
-
-
-// Don't change this
-gROOT->SetBatch(kTRUE);
-plotAllRuns(&compareHistogramClassVectorMABSBot);
-cout << "" << endl;
+    
+    for (std::vector< std::vector<TH1FO*> > ::iterator curHistogramVector = compareHistogramVectorVector.begin(); curHistogramVector != compareHistogramVectorVector.end(); curHistogramVector++)  {
+        CompareHistograms(&(*curHistogramVector));
+        writeObservableToFile(&(*curHistogramVector));
+    }
+    
+    for (std::vector< std::vector<HistogramType*> > ::iterator curHistogramClassVector = compareHistogramClassVectorVector.begin(); curHistogramClassVector != compareHistogramClassVectorVector.end(); curHistogramClassVector++)  {
+        printSummaryTable(&(*curHistogramClassVector));
+        plotAllRuns(&(*curHistogramClassVector));
+        writeOneHistogramTypeToFile(&(*curHistogramClassVector));
+    }
+    
+    for (std::vector< std::vector<TNtupleO*> > ::iterator curNtupleVector = ntupleVectorVector.begin(); curNtupleVector != ntupleVectorVector.end(); curNtupleVector++)  {
+        plot1DData(&(*curNtupleVector));
+    }
+    
+    
+    // Don't change this
+    gROOT->SetBatch(kTRUE);
+    plotAllRuns(&compareHistogramClassVectorMABSBot);
+    cout << "" << endl;
 }
index 9002c0ce5753e0d53fab46b68d4b215fc36bee62..265ef6cd1192384ad69fd693da88e3e7cd814aee 100644 (file)
@@ -500,7 +500,6 @@ Double_t* HistogramType::FitPerform(TH1FO* histogrampointer, TString fitFuncType
             fitFunc->SetParName(2,"Gaussian sigma");
             fitFunc->SetParameter(2,def_gausssig);
             fitFunc->SetParLimits(2,0.0,100.0);
-                            
             fitFunc->SetLineWidth(4);
             fitFunc->SetLineColor(kGreen);