| ID |
Date |
Author |
Subject |
|
65
|
Tue Apr 16 15:24:45 2024 |
AR | Zn68 Analysis: Au resonance SAMMY fits | |
| Attachment 1: Au_4ev_yield_sammy_fit_det1.pdf
|
|
| Attachment 2: Au_45-48ev_sammy_fit_det1.pdf
|
|
| Attachment 3: Au_59-62ev_sammy_fit_det1.pdf
|
|
| Attachment 4: Au_78ev_sammy_fit_det1.pdf
|
|
| Attachment 5: Au_107ev_sammy_fit_det1.pdf
|
|
|
64
|
Thu Apr 4 09:50:36 2024 |
CLW | First Si analysis 2024 run | Au and Si29 runs normalised by proton number show consistency (dedicated pulses, example detector 4). Plots for tof spectra zooming on one resonance and histogram of counts in this resonance divided by protons with statistical errors.
Plots were produced with the macros attached. |
| Attachment 1: au_counts.pdf
|
|
| Attachment 2: au.pdf
|
|
| Attachment 3: si29_counts.pdf
|
|
| Attachment 4: si29.pdf
|
|
| Attachment 5: consistency.C
|
#include "TCanvas.h"
#include "TBrowser.h"
#include "TH2F.h"
#include "TH1F.h"
#include "TGraph.h"
#include "TGraphErrors.h"
#include "TMath.h"
#include <fstream>
#include "TFrame.h"
#include "TSystem.h"
#include "TLegend.h"
#include "TLegendEntry.h"
#include "TFile.h"
#include "TROOT.h"
#include "TStyle.h"
#include "TBox.h"
#include "TRandom.h"
#include "TObject.h"
#include "TObjString.h"
#include <iostream>
#include <cstdio>
#include <string>
#include <sstream>
#include "TLine.h"
#include "TTree.h"
#include "TBrowser.h"
#include "TF1.h"
#include <TStyle.h>
#include <THStack.h>
#include <TPad.h>
#include "TRandom.h"
void plot(){
// replace this with name of your singles file
TFile *f=new TFile("Single_Si29_ded.root","read");
TString histo, norm, protons;
///file with a list of the histogram names for one detector
// format Zn_T_u3_C6D6_runxxxxxx Zn_A_u3_SILI_runxxxxxx Zn_h_info_C6D6_runxxxxxx
ifstream inni("Si29_C6D64_HistList.dat");
TCanvas *c=new TCanvas();
/// replace this with the tof around a resonance, i.e. binlow is the start of the resonance, binhigh is the end of the resonance
// you can choose any resonance, best is a large one which is usally at big tof values
/// this will be different for Au and for Zn.
float binlow=2250000;
float binhigh=2400000;
TLegend *legend = new TLegend(0.65, 0.38, 0.89, 0.89);
legend->SetBorderSize(1);
legend->SetFillColor(0);
legend->SetTextSize(0.03);
int count2=0;
int count_protons=0;
//// replace this with the number of lines in your file "list"
int lines=59;
float value[lines];
float value2[lines];
float valuesili[lines];
float valuepkup[lines];
float staterror[lines];
while(1){
inni>>histo>>norm>>protons;
if ( ! inni ) break;
char *s;
if(count2==0) s="hist";
if(count2>0)s="hist same";
count2++;
cout<<histo<<" "<<norm<<endl;
TH1F *h=(TH1F*)f->Get(histo);
//TH1F *hnorm=(TH1F*)f->Get(norm);
TH1F *hpro=(TH1F*)f->Get(protons);
int bin1=h->FindBin(binlow); //Ge70Bins
int bin2=h->FindBin(binhigh);
// this gives the total number of count in the resonance
int counter2=h->Integral(bin1,bin2);
value[count2-1]=float(counter2)/hpro->GetBinContent(4)*7E12;
staterror[count2-1]=sqrt(float(counter2))/hpro->GetBinContent(4)*7E12;
value2[count2-1]=float(counter2);
valuesili[count2-1]=float(hpro->GetBinContent(4)/hpro->GetBinContent(8));
valuepkup[count2-1]=float(hpro->GetBinContent(4)/hpro->GetBinContent(7));
h->Scale(1/hpro->GetBinContent(4)*7E12);
h->Rebin(50);
h->SetLineColor(count2);
h->DrawCopy(s);
legend->AddEntry(h,histo, "l");
}
float sum=0;
float weight=0;
float weightsum=0;
for(int i=0;i<count2;i++){
weight=value2[i]/(value[i]*value[i]);
sum=sum+value[i]*weight;
weightsum=weightsum+weight;
cout<<value[i]<<" "<<weight<<" "<<i<<endl;
}
cout<< sum/weightsum <<endl;
float deviation=0;
double stddev=0;
for(int i=0;i<count2;i++){
deviation=(sum/weightsum-value[i])/sum*weightsum*100;
stddev=(sum/weightsum-value[i])*(sum/weightsum-value[i])+stddev;
cout<<" "<<deviation<<" % "<<sqrt(value2[i])/value2[i]*100<<" % counting "<<deviation/(sqrt(value2[i])/value2[i]*100)<< " "<<i<<endl;
}
deviation=sqrt(1/count2*deviation);
cout<<count2<<" "<<sum/count2<<endl;
double stddev2=sqrt(1/(float(count2-1))*stddev);
//STOP PROTON SCALING
cout<<"std dev is "<<stddev2/(sum/weightsum)*100<<" %"<<endl;
legend->Draw();
cout<<" "<<endl;
for(int i=0;i<count2;i++){
cout<<" "<<valuesili[i]<<" Prot/SILI "<<valuepkup[i]<<" Prot/PKUP "<<valuesili[i]/valuepkup[i]<<" SILI/PKUP"<<endl;
}
TH1F *hprosi=new TH1F("","",50,0,50);
TH1F *hprook=new TH1F("","",50,0,50);
TH1F *hsipk=new TH1F("","",50,0,50);
TH1F *hcounts=new TH1F("","",50,0,50);
for(int i=0;i<count2;i++){
hprosi->SetBinContent(i+1,valuesili[i]);
hprook->SetBinContent(i+1,valuepkup[i]);
hsipk->SetBinContent(i+1,valuesili[i]/valuepkup[i]);
hcounts->SetBinContent(i+1,value[i]);
hcounts->SetBinError(i+1,staterror[i]);
}
TCanvas *c3=new TCanvas;
c3->Divide(2,2);
c3->cd(1);
hprosi->Draw();
c3->cd(2);
hprook->Draw();
c3->cd(3);
hsipk->Draw();
c3->cd(4);
hcounts->Draw();
TCanvas *c5=new TCanvas;
hcounts->Draw();
}
void plotau(){
// replace this with name of your singles file
TFile *f=new TFile("Single_Au_ded.root","read");
TString histo, norm, protons;
///file with a list of the histogram names for one detector
// format Zn_T_u3_C6D6_runxxxxxx Zn_A_u3_SILI_runxxxxxx Zn_h_info_C6D6_runxxxxxx
ifstream inni("Au_C6D64_HistList.dat");
TCanvas *c=new TCanvas();
/// replace this with the tof around a resonance, i.e. binlow is the start of the resonance, binhigh is the end of the resonance
// you can choose any resonance, best is a large one which is usally at big tof values
/// this will be different for Au and for Zn.
float binlow=12000000;
float binhigh=14000000;
TLegend *legend = new TLegend(0.65, 0.38, 0.89, 0.89);
legend->SetBorderSize(1);
legend->SetFillColor(0);
legend->SetTextSize(0.03);
int count2=0;
int count_protons=0;
//// replace this with the number of lines in your file "list"
int lines=59;
float value[lines];
float value2[lines];
float valuesili[lines];
float valuepkup[lines];
float staterror[lines];
while(1){
inni>>histo>>norm>>protons;
if ( ! inni ) break;
char *s;
if(count2==0) s="hist";
if(count2>0)s="hist same";
count2++;
cout<<histo<<" "<<norm<<endl;
TH1F *h=(TH1F*)f->Get(histo);
//TH1F *hnorm=(TH1F*)f->Get(norm);
TH1F *hpro=(TH1F*)f->Get(protons);
int bin1=h->FindBin(binlow); //Ge70Bins
int bin2=h->FindBin(binhigh);
// this gives the total number of count in the resonance
int counter2=h->Integral(bin1,bin2);
value[count2-1]=float(counter2)/hpro->GetBinContent(4)*7E12;
staterror[count2-1]=sqrt(float(counter2))/hpro->GetBinContent(4)*7E12;
value2[count2-1]=float(counter2);
valuesili[count2-1]=float(hpro->GetBinContent(4)/hpro->GetBinContent(8));
valuepkup[count2-1]=float(hpro->GetBinContent(4)/hpro->GetBinContent(7));
h->Scale(1/hpro->GetBinContent(4)*7E12);
h->Rebin(50);
h->SetLineColor(count2);
h->DrawCopy(s);
legend->AddEntry(h,histo, "l");
}
float sum=0;
float weight=0;
float weightsum=0;
for(int i=0;i<count2;i++){
weight=value2[i]/(value[i]*value[i]);
sum=sum+value[i]*weight;
weightsum=weightsum+weight;
cout<<value[i]<<" "<<weight<<" "<<i<<endl;
}
cout<< sum/weightsum <<endl;
float deviation=0;
double stddev=0;
for(int i=0;i<count2;i++){
deviation=(sum/weightsum-value[i])/sum*weightsum*100;
stddev=(sum/weightsum-value[i])*(sum/weightsum-value[i])+stddev;
cout<<" "<<deviation<<" % "<<sqrt(value2[i])/value2[i]*100<<" % counting "<<deviation/(sqrt(value2[i])/value2[i]*100)<< " "<<i<<endl;
}
deviation=sqrt(1/count2*deviation);
cout<<count2<<" "<<sum/count2<<endl;
double stddev2=sqrt(1/(float(count2-1))*stddev);
//STOP PROTON SCALING
cout<<"std dev is "<<stddev2/(sum/weightsum)*100<<" %"<<endl;
legend->Draw();
cout<<" "<<endl;
for(int i=0;i<count2;i++){
... 36 more lines ...
|
| Attachment 6: List_Formatter.cpp
|
// g++ -Wall -O3 -g List_Formatter.cpp -o List_Formatter && ./List_Formatter
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main(){
string sample_name = "Au"; //A prefix for the TTOFSort output file histogram names, e.g. Zn1 is the first block of zinc runs
int runlist[]={118026, 118027, 118028, -1};
for(int detn = 1; detn <= 4; detn++){ //Loop over 4 C6D6 detectors
string outname = sample_name; //Create output file name in the format Sample_C6D6#_HistList.dat
outname += "_C6D6";
stringstream formatter;
formatter << detn;
outname += formatter.str(); //This string stream now contains detector name integer converted to string
outname += "_HistList.dat";
ofstream ofile;
ofile.open(outname.c_str());
if(!ofile.is_open()){cout << "ERROR: Cannot open output file " << outname << endl; return 0;}
for(int run_index = 0; run_index < (int)(sizeof(runlist) / sizeof(int)); run_index++){ //Loop over each of the runs
if(runlist[run_index] != -1){
stringstream run_str;
run_str << runlist[run_index]; //Save run number as string
string histname1 = sample_name;
histname1 += "_T_u";
histname1 += formatter.str();
histname1 += "_C6D6_run";
histname1 += run_str.str();
string histname2 = sample_name;
histname2 += "_A_u";
histname2 += formatter.str();
histname2 += "_SILI_run";
histname2 += run_str.str();
string histname3 = sample_name;
histname3 += "_h_info_C6D6_run";
histname3 += run_str.str();
run_str.str(""); //Clear the stringstream
ofile << histname1 << " " << histname2 << " " << histname3 << endl;
}
}
formatter.str(""); //Clear the stringstream
ofile.close();
}
return 0;
}
|
|
63
|
Tue Mar 26 11:04:29 2024 |
AR | Si-29 and Si-28 sample images and info | Sample information Excel sheet attached below.
Images 1-6: Si-29 sample
Images 6-10: Si-28 sample
Image 11: screenshot from Excel sheet for Si-29
Image 12: screenshot from Excel sheet for Si-28
Image 13: screenshot from Excel sheet for Dummy
Both samples were only able to be weighed inside the capsule as they were very crumbly and unable to be weighed alone (see images). The capsule was weighed before the sample was put in it and thus the mass of Si can be found by subtracting the capsule mass from the measured mass.
Average mass Si-29: 0.8568g pm 0.0002
Average mass Si-28: 0.9551 pm 0.0002
Average mass Dummy: 0.0765 pm 0.0001
|
| Attachment 1: IMG_8947.jpg
|
|
| Attachment 2: IMG_8934.jpg
|
|
| Attachment 3: IMG_8932.jpg
|
|
| Attachment 4: IMG_8936.jpg
|
|
| Attachment 5: IMG_8933.jpg
|
|
| Attachment 6: IMG_8940.jpg
|
|
| Attachment 7: IMG_8960.jpg
|
|
| Attachment 8: IMG_8959.jpg
|
|
| Attachment 9: IMG_8957.jpg
|
|
| Attachment 10: IMG_8953.jpg
|
|
| Attachment 11: Silicon_2024_Samples.xlsx
|
|
62
|
Mon Mar 25 09:07:53 2024 |
Nick | Proton Monitoring | https://docs.google.com/spreadsheets/d/18lk27N6Pb2iT_xtDA-1T1c9vVubXTJ0OsaDjOxErP0I/edit?usp=sharing |
|
61
|
Sat Mar 23 15:06:44 2024 |
Nick | Detector Setup - 28/29Si Campaign 2024 | Campaign started yesterday. C6D6s placed at 9 cm distance, angle 125 degrees w.r.t beamline.
Measured calibration sources: Cs137, Y88, AmBe, CmC. Measuring Si-nat over the weekend.
Detector Voltage
| |
|
C6D6_D_1 |
1550 |
|
|
|
|
|
| |
|
C6D6_E_2 |
1590 |
|
|
|
|
|
| |
|
C6D6_H_3 |
1460 |
|
|
|
|
|
| |
|
C6D6_L_4 |
1450 |
|
| Attachment 1: 20240322_145150.JPG
|
|
| Attachment 2: 20240322_144319.JPG
|
|
| Attachment 3: 20240322_144309.JPG
|
|
| Attachment 4: 20240322_144304.JPG
|
|
| Attachment 5: 20240322_144251.JPG
|
|
| Attachment 6: 20240322_144247.JPG
|
|
| Attachment 7: 20240322_144243.JPG
|
|
| Attachment 8: 20240322_144239.JPG
|
|
| Attachment 9: 20240322_144234.JPG
|
|
|
60
|
Fri Mar 1 14:35:04 2024 |
AR | Zn updated wartime v weighted plots | Updated plots with new WFs. Rebinned by 10. |
| Attachment 1: det1_deadcorr_v_weighted_d_Zn.pdf
|
|
| Attachment 2: det1_deadtime_corr_pvd_Zn.pdf
|
|
| Attachment 3: det1_dedcorr_v_weighted_p_Zn.pdf
|
|
| Attachment 4: det1_weighted_pvd_Zn.pdf
|
|
| Attachment 5: det2_deadcorr_v_weighted_d_Zn.pdf
|
|
| Attachment 6: det2_deadcorr_v_weighted_p_Zn.pdf
|
|
| Attachment 7: det2_deadtime_corr_pvd_Zn.pdf
|
|
| Attachment 8: det2_weighted_pvd_Zn.pdf
|
|
| Attachment 9: det3_deadcorr_v_weighted_d_Zn.pdf
|
|
| Attachment 10: det3_deadcorr_v_weighted_p_Zn.pdf
|
|
| Attachment 11: det3_deadtime_corr_pvd_Zn.pdf
|
|
| Attachment 12: det3_deadtime_correction_pvd_Zn.pdf
|
|
| Attachment 13: det3_weighted_pvd_Zn.pdf
|
|
|
59
|
Tue Feb 27 11:37:39 2024 |
AR | Updated Au Deadtime Corrected Spectra & Weighted Spectra Plots | Plots made with new weighting functions. All rebinned by 10.
Attatchments 1-4: Detector 1.
Attatchments 5-8: Detector 2.
Attatchments 9-12: Detector 3. |
| Attachment 1: Det1_Deadtime_Corr_pvd_Au.pdf
|
|
| Attachment 2: Det1_DedCorr_v_Weighted_d_Au.pdf
|
|
| Attachment 3: Det1_DedCorr_v_Weighted_p_Au.pdf
|
|
| Attachment 4: Det1_Weighted_pvd_Au.pdf
|
|
| Attachment 5: Det2_Deadtime_Corr_pvd_Au.pdf
|
|
| Attachment 6: Det2_DedCorr_v_Weighted_d_Au.pdf
|
|
| Attachment 7: Det2_DedCorr_v_Weighted_p_Au.pdf
|
|
| Attachment 8: Det2_Weighted_pvd_Au.pdf
|
|
| Attachment 9: Det3_Deadtime_Corr_pvd_Au.pdf
|
|
| Attachment 10: Det3_DedCorr_v_Weighted_d_Au.pdf
|
|
| Attachment 11: Det3_DedCorr_v_Weighted_p_Au.pdf
|
|
| Attachment 12: Det3_Weighted_pvd_Au.pdf
|
|
|
58
|
Fri Dec 1 15:34:01 2023 |
AR | Corrected BG Subtraction plots for Zn and Au | Updated plots for Zn and Au |
| Attachment 1: Au_BG_correction_comp_weighted_det3_zoomed_rebinned5.pdf
|
|
| Attachment 2: Au_BG_correction_comp_weighted_det2_zoomed_rebinned5.pdf
|
|
| Attachment 3: Au_BG_correction_comp_weighted_det1_zoomed_rebinned5.pdf
|
|
| Attachment 4: Zn_BG_Correction_Comp_Weighted_det3.pdf
|
|
| Attachment 5: Zn_BG_Correction_Comp_weighted_det2.pdf
|
|
| Attachment 6: Zn_BG_Correction_Comp_Weighted_det1.pdf
|
|
|
57
|
Thu Nov 30 14:43:28 2023 |
AR | Zn + Au Background subtraction: Plots | Plots for Zn and Au with Empty subtracted, and compared to weighted spectra.
Note: Au are logged x and y, Zn is only logged x. |
| Attachment 1: Au_BG_correction_det3_inc_uncorr.pdf
|
|
| Attachment 2: Au_BG_correction_det2_inc_uncorr.pdf
|
|
| Attachment 3: Au_BG_Correction_det1_inc_uncorr.pdf
|
|
| Attachment 4: Zn_BG_Correction_det3_R3_inc_uncorr.pdf
|
|
| Attachment 5: Zn_BG_Correction_det3_R2_inc_uncorr.pdf
|
|
| Attachment 6: Zn_BG_Correction_det3_R1_inc_uncorr.pdf
|
|
| Attachment 7: Zn_BG_Correction_det2_R3_inc_uncorr.pdf
|
|
| Attachment 8: Zn_BG_Correction_det2_R2_inc_uncorr.pdf
|
|
| Attachment 9: Zn_BG_Correction_det2_R1_inc_uncorr.pdf
|
|
| Attachment 10: Zn_BG_Correction_det1_R1_inc_uncorr.pdf
|
|
| Attachment 11: Zn_BG_Corrected_det1_R3_inc_uncorr.pdf
|
|
| Attachment 12: Zn_BG_Correction_det1_R2_inc_uncorr.pdf
|
|
| Attachment 13: Au_BG_Correction_Comp_weighted_det3_zoom.pdf
|
|
| Attachment 14: Au_BG_Corection_Comp_Weighted_det2_Zoom.pdf
|
|
| Attachment 15: Au_BG_Correction_Comp_Weighted_det1_Zoom.pdf
|
|
| Attachment 16: Zn_BG_Correction_Comp_Weighted_det3_zoom.pdf
|
|
| Attachment 17: Zn_BG_Correction_Comp_Weighted_det3.pdf
|
|
| Attachment 18: Zn_BG_Correction_Comp_Weighted_det2_zoom.pdf
|
|
| Attachment 19: Zn_BG_Correction_Comp_weighted_det2.pdf
|
|
| Attachment 20: Zn_BG_Correction_Comp_Weighted_det1_zoom.pdf
|
|
| Attachment 21: Zn_BG_Correction_Comp_Weighted_det1.pdf
|
|
|
56
|
Wed Nov 15 13:40:50 2023 |
Claudia | Determination of neutron capture yield and related corrections | Here are all the files needed for calculation of the yield. There is some information that still needs to be added to the energyandyield.c file, for example the atomic mass of your target in amu, the neutron separation energy for the compound nucleus in MeV (this is needed due to using the Weighting technique). Also, you need to add some lines to read the tof histogram, which will then be converted in a neutron energy hisogram and then divided by the flux.
For the conversion to neutron energy we assume an approximate flight path for now. We will determine this more accurately once we have the yields and fit resonances. Emma will need to use a different flux than Annie, because we have a different spallation target. Emma's flux is preliminary, so we also should look at the SILI detectors at some point.
There are some more instances where names for rootfiles and ascii files need to be added. In the first instance, please try and add the missing information and try running the code. I haven't tested it so there may be still problem. To run it you will need to download the 3 rootfiles into the same folder (or move somewhere else and adjust the path name in the .c file.
PLEASE set variable THRESHSCALER to 1 for now. We dont know yet what it is :-) |
| Attachment 1: evalFlux_prelim.root
|
| Attachment 2: nTOF-Ph2_fluence_2009-2011_6Dec2011.root
|
| Attachment 3: BIF_2011_norm.root
|
| Attachment 4: energyandyield.c
|
#include "TCanvas.h"
#include "TBrowser.h"
#include "TH2F.h"
#include "TH1F.h"
#include "TGraph.h"
#include "TGraphErrors.h"
#include "TMath.h"
#include <fstream>
#include "TFrame.h"
#include "TSystem.h"
#include "TLegend.h"
#include "TLegendEntry.h"
#include "TFile.h"
#include "TROOT.h"
#include "TStyle.h"
#include "TBox.h"
#include "TRandom.h"
#include "TObject.h"
#include "TObjString.h"
#include <iostream>
#include <cstdio>
#include <string>
#include <sstream>
#include "TLine.h"
#include "TTree.h"
#include "TBrowser.h"
#include "TF1.h"
#include <TStyle.h>
#include <THStack.h>
#include <TPad.h>
#include "TRandom.h"
using namespace std;
TH1F *toftoene_fixedbin(TH1F *htof,Double_t L,Double_t offset,Int_t binoffset);
void WriteHistogramFile(TString filename,TH1F *h);
float Sn= 0 ; // neutron separation energy in MeV
float Amass= 0; // mass of your nucleus in atomic mass units
/// L flight path in cm, assumed
/// offset ... any offset in time of flight from daq (N/A here, hence 0)
/// binoffset this is just to exclude very low tof bins which are at too high energy to be of interest 10000 should be ok
void run(){
/// LOAD TIME OF FLIGHT SPECTRUM
TH1F *hene=toftoene_fixedbin(NAMEOFTOFSPECTRUM,18500,0,10000);
hene->Draw(); /// draw tof histogram concerted to energy
TH1F *h_me=(TH1F*)hene->Clone();
//// NOW moving on to division by flux
/// the neutron flux is given per bunch assuming a standard proton intensity of 7E12 protons / bunch. Hence the division is by no of protons and then multiplied by 7E12 to get to the number of standard bunches
h_me->Scale(1/(h_mon->GetBinContent(4)/7E12));
/// file that contains the neutron flux. We are looking at the flux in isolethargic units
TFile *fflux = new TFile("nTOF-Ph2_fluence_2009-2011_6Dec2011.root", "read"); //for EMMA: evalFlux_prelim.root
TH1F *sim = (TH1F*)fflux->Get("hNFluenceEVALUATED2011"); // FOR EMMA: hEval_Abs
//Neutron flux that is independent of the binning of the histogram. The number of neutrons between E1 and E1 can be found by multiplying the value in the histogram by the logarithmic bin width, i.e. log(E2)-log(E1)
TH1F *yield1 = (TH1F*)h_me->Clone();
cout<<"DIVIDE BY FLUX"<<endl;
for(Int_t i=1; i<=h_me->GetNbinsX(); i++)
{
float auxbin1 = sim->FindBin(h_me->GetBinCenter(i)); // find the bin in the flux histogram
float scaler1 = TMath::Log(h_me->GetBinLowEdge(i+1)/h_me->GetBinLowEdge(i)); // determine the binwidth of count histogram
yield1->SetBinContent(i,h_me->GetBinContent(i)/(sim->GetBinContent(auxbin1)*scaler1));
// this is the division by the flux. The number of coutns gets divided by the number of neutrons in that particular bin
if(sim->GetBinContent(auxbin1)<=0)yield1->SetBinContent(i,0); // this is in case the flux histgram has a content <=0, so we do not divide by a negative or 0
if(sim->GetBinContent(auxbin1)>0){
float binerr_rel=sqrt(pow(h_me->GetBinError(i)/h_me->GetBinContent(i),2) + pow(sim->GetBinError(auxbin1)/sim->GetBinContent(auxbin1),2));
// this calculates the relative uncertainty taking into consideration the sample uncertainties and the uncertaities in the flux histogram
float binerr=binerr_rel*yield1->GetBinContent(i);
// calculation of absolute uncertainty
if(h_me->GetBinContent(i)==0)binerr=h_me->GetBinError(i)/(sim->GetBinContent(auxbin1)*scaler1);
/// this is again to avoid divition by 0
yield1->SetBinError(i,binerr);
}
}
for(int g=1;g<=h_me->GetNbinsX();g++)
{
yield1->SetBinContent(g,yield1->GetBinContent(g)*threshscaler/(Sn+ Amass/(1.0086649+Amass)*yield1->GetBinCenter(g)/1e6));
yield1->SetBinError(g,yield1->GetBinError(g)*threshscaler/(Sn+ Amass/(1.0086649+Amass)*yield1->GetBinCenter(g)/1e6));
}
// this is an additional correction since the neutron beam size varies slightly with neutrom energy. Emma, you can skip that for now as it will be different for you, and we dont have that information yet.
cout << "BIF CORRECTION" <<endl;
TFile *bif=new TFile("BIF_2011_norm.root","read");
TH1F *hbif=(TH1F*)bif->Get("histo");
for(int f=1;f<=yield1->GetNbinsX();f++){
float center=yield1->GetBinCenter(f);
int binni=hbif->FindBin(center);
yield1->SetBinContent(f,yield1->GetBinContent(f)/hbif->GetBinContent(binni));
float binerr_rel=sqrt(pow(yield1->GetBinError(f)/yield1->GetBinContent(f),2) + pow(hbif->GetBinError(binni)/hbif->GetBinContent(binni),2));
float binerr=binerr_rel*yield1->GetBinContent(f);
if(yield1->GetBinContent(f)==0)binerr=yield1->GetBinError(f)/hbif->GetBinContent(binni);
yield1->SetBinError(f,binerr);
}
cout <<"BIF CORRECTION DONE"<<endl;
yield1->GetXaxis()->SetTitle("energy (eV)");
yield1->GetYaxis()->SetTitle("yield");
cout <<"WRITE FILE"<<endl;
// we are writing the yield as root file and as a data file, since that is the input for resonance fitting.
TFile *gefinalyield= new TFile(NAME, "update");
yield1->Write(histosam);
gefinalyield->Write();
gefinalyield->Close();
cout <<"ROOT FILE WRITTEN"<<endl;
WriteHistogramFile(FILENAME,yield1);
cout <<"TEXT FILE WRITTEN"<<endl;
}
TH1F *toftoene_fixedbin(TH1F *htof,Double_t L,Double_t offset,Int_t binoffset){
int number=htof->GetNbinsX();
float lowedge;
float eneedge[number-binoffset];
const double Mass=939565560.81; //Neutron Mass
const double c0=29.972458; // speed of light
cout<<number<<endl;
for(int i=binoffset;i<=number;i++){
lowedge=htof->GetBinLowEdge(i)+L/c0+offset;
eneedge[number-i]=(1/pow(1-((L/(lowedge)/c0)*(L/(lowedge)/c0)),0.5)-1)*Mass;
if(i==30000)cout<<lowedge<<" "<<eneedge[number-i]<<" "<<number-i<<endl;
}
TH1F *hene =new TH1F("Counts","Counts",number-binoffset-1,eneedge);
hene->GetXaxis()->Set(number-1-binoffset,eneedge);
for(int i=1;i<=hene->GetNbinsX();i++){
hene->SetBinContent(i,htof->GetBinContent(number-i));
hene->SetBinError(i,htof->GetBinError(number-i));
}
return hene;
}
void WriteHistogramFile(TString filename,TH1F *h){
FILE * fout;
fout = fopen(filename,"w");
for(Int_t i=1;i<=h->GetNbinsX();i++)
{
double bincenternew=h->GetBinCenter(i);
double binContent=h->GetBinContent(i);
//if(binContent<0)binContent=0;
double binError=h->GetBinError(i);
if(binError<=0)binError=1e-8;
if(bincenternew>0.02571)fprintf(fout,"%20.10f%20.10f%20.10f\n",bincenternew,binContent,binError);
}
fclose(fout);
cout << "*************************************"<< endl;
cout << " File " << filename <<" written, with format: E_center_bin, Content, error "<<endl;
cout << "*************************************"<< endl;
}
|
|
55
|
Wed Nov 8 11:47:44 2023 |
AR | Zn68 TTOFSort codes | |
| Attachment 1: Process_Au_31-10.C
|
// g++ -Wall -O3 -g `root-config --cflags --ldflags --glibs` process_runs_Zn_full.cpp -o process_runs_Zn_full && ./process_runs_Zn_full
#include <iostream>
#include <TFile.h>
#include <TCanvas.h>
#include <TPad.h>
#include <TAxis.h>
#include <TH1D.h>
#include <TF1.h>
#include <TLegend.h>
#include <TLegendEntry.h>
#include <TDirectory.h>
#include <fstream>
#include <math.h>
#include "/eos/experiment/ntof/codes/TTOFSort/TTOFSort_nTOF.h"
#ifndef __CINT__
#include "/eos/experiment/ntof/codes/TTOFSort/TTOFSort_nTOF.cxx"
#endif
using namespace std;
Double_t caldet1(Double_t x){return(-0.0126844 + 0.000250511 * x);}
//Double_t caldet1b(Double_t x){return(0.0300862 + 0.000239789 * x);}
//Double_t caldet1c(Double_t x){return(-0.00982159 + 0.000243208 * x);}
Double_t caldet2(Double_t x){return(0.00933879 + 0.000223045 * x);}
Double_t caldet3(Double_t x){return(0.0448306 + 0.000295976 * x);}
Double_t caldet4(Double_t x){return(0.039253 + 0.000228249 * x);}
Double_t caldet5(Double_t x){return(0.039253 + 0.000228249 * x);}
Double_t caldet6(Double_t x){return(0.039253 + 0.000228249 * x);}
Double_t wfzn1(Double_t x){return(52.4331 - 15.7227 * x + 129.696 * x * x - 21.3173 * x * x * x + 1.23419 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfzn2(Double_t x){return(54.8656 - 23.9266 * x + 136.114 * x * x - 22.9382 * x * x * x + 1.36142 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfzn3(Double_t x){return(55.0448 - 24.1592 * x + 135.662 * x * x - 22.6676 * x * x * x + 1.32807 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfzn4(Double_t x){return(53.7253 - 20.1490 * x + 133.263 * x * x - 22.2370 * x * x * x + 1.30748 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau1(Double_t x){return(33.0459 - 14.2600 * x + 79.6741 * x * x - 12.5454 * x * x * x + 75.7094 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau2(Double_t x){return(31.1978 - 8.63083 * x + 76.0325 * x * x - 11.7987 * x * x * x + 71.1593 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau3(Double_t x){return(30.1989 - 5.58729 * x + 74.0714 * x * x - 11.4009 * x * x * x + 68.8028 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau4(Double_t x){return(30.0116 - 5.09782 * x + 73.9204 * x * x - 11.4115 * x * x * x + 69.3298 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t dummy_function(Double_t x){return 0.;}
int Zn68(){
Char_t prefix[] = "root://eospublic.cern.ch//eos/experiment/ntof/data/rootfiles/2018/ear1/run";
Char_t suffix[] = ".root";
//Int_t runlist_ZnP[]={108570, 108569, 108568, 108567, 108566, 108565, 108560, 108558, -1};
//Int_t runlist_Zn[]={108347,108348,108349,108350,108351,108352,108353,108354,\
108355,108357,108359,108360,108361,108362,108363,\
108364,108400,108399,108398,108397,108396,108395,\
108411,108410,108409,108408,108407,108406,\
108419,108418,108417,108416,108415,108414,\
108444,108443,108442,108441,108440,108439,108438,108437,108436,\
108435,108434,108433,108432,108431,108430,108429,108428,108427,\
108426,108425,108423,108422,108462,108461,108460,108459,108458,\
108457,108520,108519,108518,108517,108516,108515,108514,108513,\
108512,108523,108527,108526,108525,108524,108539,108538,108537,\
108536,108535,108560,108559,108548,\
108570, 108569, 108568, 108567,108566, 108565, 108560, 108558,-1};
Int_t runlist_E[]={108393,108392,108391,108390,108389,108388,108387,108495,108494,108493,108492,108491,-1};
Int_t runlist_Au[]={108339,108340,108343,108344,108345,108346,108403,108404,108405,108490,108489,-1}; // isue with 108341? remove?
TTOFSort *a = new TTOFSort();
a->SetEnableMonitorPerBunch(); // include information on monitors per bunch
a->AddDetector(kC6D6, 4);
a->AddDetector(kSILI,4);
a->AddDetector(kPKUP,1);
a->SetNewVariableNames_amplitude(kC6D6, "amp"); // use instead of variable amp
a->SetNewVariableNames_amplitude(kSILI ,"amp");
a->SetNewVariableNames_amplitude(kPKUP ,"amp");
//a->SetPriorCut(kC6D6,"PulseIntensity>5E12"); a->SetPriorCut(kC6D6,"PulseIntensity>2E12",&&,"PulseIntensity<5E12");
//a->SetPriorCut(kC6D6,"PulseIntensity>5E12 && detn!=1 && detn!=4 && detn!=5 && detn!=6");
a->SetNewBinParsA(kC6D6, 0.0, 7000, 70000); // CLW: CHANGED BINNING
a->SetNewBinParsA(kSILI, 0.0, 7000, 70000); // CLW: CHANGED BINNING
a->SetNewVariableNames_amplitude(kC6D6, "amp");
a->SetNewFixedDeadtime(kC6D6, 50.0); // fixed deadtime of 30 ns
a->SetNewCoincidencetime (kC6D6, 40.0); // Coincidences between 30 ns
a->UseWeightingFunction(kC6D6, wfau1, wfau2, wfau3, wfau4); //Zero the additonal two C6D6s
a->UseCalibration(kC6D6, caldet1, caldet2, caldet3, caldet4);
a->SetNewCutsEg(kC6D6, 0.200, 10.0);
a->ProcessListOfRuns_Single(prefix, runlist_Au, suffix, "Au_single.root", "Au", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_E, suffix, "Au_single.root", "E", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_Au, suffix, "Au_sum.root", "Au", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_E, suffix, "Au_sum.root", "E", "UPDATE");
return 0;
}
|
| Attachment 2: Process_Au_dedicated_31-10.C
|
// g++ -Wall -O3 -g `root-config --cflags --ldflags --glibs` process_runs_Zn_full.cpp -o process_runs_Zn_full && ./process_runs_Zn_full
#include <iostream>
#include <TFile.h>
#include <TCanvas.h>
#include <TPad.h>
#include <TAxis.h>
#include <TH1D.h>
#include <TF1.h>
#include <TLegend.h>
#include <TLegendEntry.h>
#include <TDirectory.h>
#include <fstream>
#include <math.h>
#include "/eos/experiment/ntof/codes/TTOFSort/TTOFSort_nTOF.h"
#ifndef __CINT__
#include "/eos/experiment/ntof/codes/TTOFSort/TTOFSort_nTOF.cxx"
#endif
using namespace std;
Double_t caldet1(Double_t x){return(-0.0126844 + 0.000250511 * x);}
//Double_t caldet1b(Double_t x){return(0.0300862 + 0.000239789 * x);}
//Double_t caldet1c(Double_t x){return(-0.00982159 + 0.000243208 * x);}
Double_t caldet2(Double_t x){return(0.00933879 + 0.000223045 * x);}
Double_t caldet3(Double_t x){return(0.0448306 + 0.000295976 * x);}
Double_t caldet4(Double_t x){return(0.039253 + 0.000228249 * x);}
Double_t caldet5(Double_t x){return(0.039253 + 0.000228249 * x);}
Double_t caldet6(Double_t x){return(0.039253 + 0.000228249 * x);}
Double_t wfzn1(Double_t x){return(52.4331 - 15.7227 * x + 129.696 * x * x - 21.3173 * x * x * x + 1.23419 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfzn2(Double_t x){return(54.8656 - 23.9266 * x + 136.114 * x * x - 22.9382 * x * x * x + 1.36142 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfzn3(Double_t x){return(55.0448 - 24.1592 * x + 135.662 * x * x - 22.6676 * x * x * x + 1.32807 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfzn4(Double_t x){return(53.7253 - 20.1490 * x + 133.263 * x * x - 22.2370 * x * x * x + 1.30748 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau1(Double_t x){return(33.0459 - 14.2600 * x + 79.6741 * x * x - 12.5454 * x * x * x + 75.7094 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau2(Double_t x){return(31.1978 - 8.63083 * x + 76.0325 * x * x - 11.7987 * x * x * x + 71.1593 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau3(Double_t x){return(30.1989 - 5.58729 * x + 74.0714 * x * x - 11.4009 * x * x * x + 68.8028 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau4(Double_t x){return(30.0116 - 5.09782 * x + 73.9204 * x * x - 11.4115 * x * x * x + 69.3298 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t dummy_function(Double_t x){return 0.;}
int Zn68(){
Char_t prefix[] = "root://eospublic.cern.ch//eos/experiment/ntof/data/rootfiles/2018/ear1/run";
Char_t suffix[] = ".root";
//Int_t runlist_ZnP[]={108570, 108569, 108568, 108567, 108566, 108565, 108560, 108558, -1};
//Int_t runlist_Zn[]={108347,108348,108349,108350,108351,108352,108353,108354,\
108355,108357,108359,108360,108361,108362,108363,\
108364,108400,108399,108398,108397,108396,108395,\
108411,108410,108409,108408,108407,108406,\
108419,108418,108417,108416,108415,108414,\
108444,108443,108442,108441,108440,108439,108438,108437,108436,\
108435,108434,108433,108432,108431,108430,108429,108428,108427,\
108426,108425,108423,108422,108462,108461,108460,108459,108458,\
108457,108520,108519,108518,108517,108516,108515,108514,108513,\
108512,108523,108527,108526,108525,108524,108539,108538,108537,\
108536,108535,108560,108559,108548,\
108570, 108569, 108568, 108567,108566, 108565, 108560, 108558,-1};
Int_t runlist_E[]={108393,108392,108391,108390,108389,108388,108387,108495,108494,108493,108492,108491,-1};
Int_t runlist_Au[]={108339,108340,108343,108344,108345,108346,108403,108404,108405,108490,108489,-1}; // isue with 108341? remove?
TTOFSort *a = new TTOFSort();
a->SetEnableMonitorPerBunch(); // include information on monitors per bunch
a->AddDetector(kC6D6, 4);
a->AddDetector(kSILI,4);
a->AddDetector(kPKUP,1);
a->SetNewVariableNames_amplitude(kC6D6, "amp"); // use instead of variable amp
a->SetNewVariableNames_amplitude(kSILI ,"amp");
a->SetNewVariableNames_amplitude(kPKUP ,"amp");
//a->SetPriorCut(kC6D6,"PulseIntensity>5E12"); a->SetPriorCut(kC6D6,"PulseIntensity>2E12",&&,"PulseIntensity<5E12");
//a->SetPriorCut(kC6D6,"PulseIntensity>5E12 && detn!=1 && detn!=4 && detn!=5 && detn!=6");
a->SetPriorCut(kC6D6,"PulseIntensity>5E12");
a->SetPriorCut(kSILI,"PulseIntensity>5E12");
a->SetPriorCut(kPKUP,"PulseIntensity>5E12");
a->SetNewBinParsA(kC6D6, 0.0, 7000, 70000); // CLW: CHANGED BINNING
a->SetNewBinParsA(kSILI, 0.0, 7000, 70000); // CLW: CHANGED BINNING
a->SetNewVariableNames_amplitude(kC6D6, "amp");
a->SetNewFixedDeadtime(kC6D6, 50.0); // fixed deadtime of 30 ns
a->SetNewCoincidencetime (kC6D6, 40.0); // Coincidences between 30 ns
a->UseWeightingFunction(kC6D6, wfau1, wfau2, wfau3, wfau4); //Zero the additonal two C6D6s
a->UseCalibration(kC6D6, caldet1, caldet2, caldet3, caldet4);
a->SetNewCutsEg(kC6D6, 0.200, 10.0);
a->ProcessListOfRuns_Single(prefix, runlist_Au, suffix, "Au_single_dedicated.root", "Au", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_E, suffix, "Au_single_dedicated.root", "E", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_Au, suffix, "Au_sum_dedicated.root", "Au", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_E, suffix, "Au_sum_dedicated.root", "E", "UPDATE");
return 0;
}
|
| Attachment 3: Process_Au_parasitic_31-10.C
|
// g++ -Wall -O3 -g `root-config --cflags --ldflags --glibs` process_runs_Zn_full.cpp -o process_runs_Zn_full && ./process_runs_Zn_full
#include <iostream>
#include <TFile.h>
#include <TCanvas.h>
#include <TPad.h>
#include <TAxis.h>
#include <TH1D.h>
#include <TF1.h>
#include <TLegend.h>
#include <TLegendEntry.h>
#include <TDirectory.h>
#include <fstream>
#include <math.h>
#include "/eos/experiment/ntof/codes/TTOFSort/TTOFSort_nTOF.h"
#ifndef __CINT__
#include "/eos/experiment/ntof/codes/TTOFSort/TTOFSort_nTOF.cxx"
#endif
using namespace std;
Double_t caldet1(Double_t x){return(-0.0126844 + 0.000250511 * x);}
//Double_t caldet1b(Double_t x){return(0.0300862 + 0.000239789 * x);}
//Double_t caldet1c(Double_t x){return(-0.00982159 + 0.000243208 * x);}
Double_t caldet2(Double_t x){return(0.00933879 + 0.000223045 * x);}
Double_t caldet3(Double_t x){return(0.0448306 + 0.000295976 * x);}
Double_t caldet4(Double_t x){return(0.039253 + 0.000228249 * x);}
Double_t caldet5(Double_t x){return(0.039253 + 0.000228249 * x);}
Double_t caldet6(Double_t x){return(0.039253 + 0.000228249 * x);}
Double_t wfzn1(Double_t x){return(52.4331 - 15.7227 * x + 129.696 * x * x - 21.3173 * x * x * x + 1.23419 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfzn2(Double_t x){return(54.8656 - 23.9266 * x + 136.114 * x * x - 22.9382 * x * x * x + 1.36142 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfzn3(Double_t x){return(55.0448 - 24.1592 * x + 135.662 * x * x - 22.6676 * x * x * x + 1.32807 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfzn4(Double_t x){return(53.7253 - 20.1490 * x + 133.263 * x * x - 22.2370 * x * x * x + 1.30748 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau1(Double_t x){return(33.0459 - 14.2600 * x + 79.6741 * x * x - 12.5454 * x * x * x + 75.7094 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau2(Double_t x){return(31.1978 - 8.63083 * x + 76.0325 * x * x - 11.7987 * x * x * x + 71.1593 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau3(Double_t x){return(30.1989 - 5.58729 * x + 74.0714 * x * x - 11.4009 * x * x * x + 68.8028 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau4(Double_t x){return(30.0116 - 5.09782 * x + 73.9204 * x * x - 11.4115 * x * x * x + 69.3298 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t dummy_function(Double_t x){return 0.;}
int Zn68(){
Char_t prefix[] = "root://eospublic.cern.ch//eos/experiment/ntof/data/rootfiles/2018/ear1/run";
Char_t suffix[] = ".root";
//Int_t runlist_ZnP[]={108570, 108569, 108568, 108567, 108566, 108565, 108560, 108558, -1};
//Int_t runlist_Zn[]={108347,108348,108349,108350,108351,108352,108353,108354,\
108355,108357,108359,108360,108361,108362,108363,\
108364,108400,108399,108398,108397,108396,108395,\
108411,108410,108409,108408,108407,108406,\
108419,108418,108417,108416,108415,108414,\
108444,108443,108442,108441,108440,108439,108438,108437,108436,\
108435,108434,108433,108432,108431,108430,108429,108428,108427,\
108426,108425,108423,108422,108462,108461,108460,108459,108458,\
108457,108520,108519,108518,108517,108516,108515,108514,108513,\
108512,108523,108527,108526,108525,108524,108539,108538,108537,\
108536,108535,108560,108559,108548,\
108570, 108569, 108568, 108567,108566, 108565, 108560, 108558,-1};
Int_t runlist_E[]={108393,108392,108391,108390,108389,108388,108387,108495,108494,108493,108492,108491,-1};
Int_t runlist_Au[]={108339,108340,108343,108344,108345,108346,108403,108404,108405,108490,108489,-1};
TTOFSort *a = new TTOFSort();
a->SetEnableMonitorPerBunch(); // include information on monitors per bunch
a->AddDetector(kC6D6, 4);
a->AddDetector(kSILI,4);
a->AddDetector(kPKUP,1);
a->SetNewVariableNames_amplitude(kC6D6, "amp"); // use instead of variable amp
a->SetNewVariableNames_amplitude(kSILI ,"amp");
a->SetNewVariableNames_amplitude(kPKUP ,"amp");
//a->SetPriorCut(kC6D6,"PulseIntensity>5E12"); a->SetPriorCut(kC6D6,"PulseIntensity>2E12",&&,"PulseIntensity<5E12");
//a->SetPriorCut(kC6D6,"PulseIntensity>2E12 && PulseIntensity<5E12 && detn!=1 && detn!=4 && detn!=5 && detn!=6");
a->SetPriorCut(kC6D6,"PulseIntensity>2E12 && PulseIntensity<5E12");
a->SetPriorCut(kSILI,"PulseIntensity>2E12 && PulseIntensity<5E12");
a->SetPriorCut(kPKUP,"PulseIntensity>2E12 && PulseIntensity<5E12");
a->SetNewBinParsA(kC6D6, 0.0, 7000, 70000); // CLW: CHANGED BINNING
a->SetNewBinParsA(kSILI, 0.0, 7000, 70000); // CLW: CHANGED BINNING
a->SetNewVariableNames_amplitude(kC6D6, "amp");
a->SetNewFixedDeadtime(kC6D6, 50.0); // fixed deadtime of 30 ns
a->SetNewCoincidencetime (kC6D6, 40.0); // Coincidences between 30 ns
a->UseWeightingFunction(kC6D6, wfau1, wfau2, wfau3, wfau4); //Zero the additonal two C6D6s
a->UseCalibration(kC6D6, caldet1, caldet2, caldet3, caldet4);
a->SetNewCutsEg(kC6D6, 0.200, 10.0);
a->ProcessListOfRuns_Single(prefix, runlist_Au, suffix, "Au_single_parasitic.root", "Au", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_E, suffix, "Zn_single_ALL_parasitic.root", "E", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_Au, suffix, "Au_sum_parasitic.root", "Au", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_E, suffix, "Zn_sum_ALL_parasitic.root", "E", "UPDATE");
return 0;
}
|
| Attachment 4: Process_Zn_inc_prob_dedicated.C
|
// g++ -Wall -O3 -g `root-config --cflags --ldflags --glibs` process_runs_Zn_full.cpp -o process_runs_Zn_full && ./process_runs_Zn_full
#include <iostream>
#include <TFile.h>
#include <TCanvas.h>
#include <TPad.h>
#include <TAxis.h>
#include <TH1D.h>
#include <TF1.h>
#include <TLegend.h>
#include <TLegendEntry.h>
#include <TDirectory.h>
#include <fstream>
#include <math.h>
#include "/eos/experiment/ntof/codes/TTOFSort/TTOFSort_nTOF.h"
#ifndef __CINT__
#include "/eos/experiment/ntof/codes/TTOFSort/TTOFSort_nTOF.cxx"
#endif
using namespace std;
Double_t caldet1(Double_t x){return(-0.0126844 + 0.000250511 * x);}
//Double_t caldet1b(Double_t x){return(0.0300862 + 0.000239789 * x);}
//Double_t caldet1c(Double_t x){return(-0.00982159 + 0.000243208 * x);}
Double_t caldet2(Double_t x){return(0.00933879 + 0.000223045 * x);}
Double_t caldet3(Double_t x){return(0.0448306 + 0.000295976 * x);}
Double_t caldet4(Double_t x){return(0.039253 + 0.000228249 * x);}
Double_t caldet5(Double_t x){return(0.039253 + 0.000228249 * x);}
Double_t caldet6(Double_t x){return(0.039253 + 0.000228249 * x);}
Double_t wfzn1(Double_t x){return(52.4331 - 15.7227 * x + 129.696 * x * x - 21.3173 * x * x * x + 1.23419 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfzn2(Double_t x){return(54.8656 - 23.9266 * x + 136.114 * x * x - 22.9382 * x * x * x + 1.36142 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfzn3(Double_t x){return(55.0448 - 24.1592 * x + 135.662 * x * x - 22.6676 * x * x * x + 1.32807 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfzn4(Double_t x){return(53.7253 - 20.1490 * x + 133.263 * x * x - 22.2370 * x * x * x + 1.30748 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau1(Double_t x){return(33.0459 - 14.2600 * x + 79.6741 * x * x - 12.5454 * x * x * x + 75.7094 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau2(Double_t x){return(31.1978 - 8.63083 * x + 76.0325 * x * x - 11.7987 * x * x * x + 71.1593 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau3(Double_t x){return(30.1989 - 5.58729 * x + 74.0714 * x * x - 11.4009 * x * x * x + 68.8028 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau4(Double_t x){return(30.0116 - 5.09782 * x + 73.9204 * x * x - 11.4115 * x * x * x + 69.3298 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t dummy_function(Double_t x){return 0.;}
int Zn68(){
Char_t prefix[] = "root://eospublic.cern.ch//eos/experiment/ntof/data/rootfiles/2018/ear1/run";
Char_t suffix[] = ".root";
//Int_t runlist_ZnP[]={108570, 108569, 108568, 108567, 108566, 108565, 108560, 108558, -1};
Int_t runlist_Zn[]{108347,108348,108349,108350,108351,108352,108353,108355,108357,108359,108360,108361,108362,\
108363,108364,108397,108398,108399,108400,108406,108408,\
108409,108410,108411,108414,108415,108416,108417,108418,108419,\
108422,108423,108425,108426,108427,108428,108429,\
108430,108431,108432,108433,108434,108435,108436,108437,108438,108440,\
108441,108442,108443,108444,108459,108460,108461,\
108512,108513,108514,108515,108516,108517,108518,108519,\
108520,108523,108524,108525,108526,108527,\
108535,108536,108537,108538,108539,108548,108559,108565,-1};
Int_t runlist_E[]={108393,108392,108391,108390,108389,108388,108387,108495,108494,108493,108492,108491,-1};
//Int_t runlist_Au[]={108339,108340,108342,108343,108344,108345,108346,108403,108404,108405,108490,108489,-1};
TTOFSort *a = new TTOFSort();
a->SetEnableMonitorPerBunch(); // include information on monitors per bunch
a->AddDetector(kC6D6, 6);
a->AddDetector(kSILI,4);
a->AddDetector(kPKUP,1);
a->SetNewVariableNames_amplitude(kC6D6, "amp"); // use instead of variable amp
a->SetNewVariableNames_amplitude(kSILI ,"amp");
a->SetNewVariableNames_amplitude(kPKUP ,"amp");
//a->SetPriorCut(kC6D6,"PulseIntensity>5E12"); a->SetPriorCut(kC6D6,"PulseIntensity>2E12",&&,"PulseIntensity<5E12");
a->SetPriorCut(kC6D6,"PulseIntensity>5E12");
a->SetPriorCut(kSILI,"PulseIntensity>5E12");
a->SetPriorCut(kPKUP,"PulseIntensity>5E12");
a->SetNewBinParsA(kC6D6, 0.0, 7000, 70000); // CLW: CHANGED BINNING
a->SetNewBinParsA(kSILI, 0.0, 7000, 70000); // CLW: CHANGED BINNING
a->SetNewVariableNames_amplitude(kC6D6, "amp");
a->SetNewFixedDeadtime(kC6D6, 50.0); // fixed deadtime of 30 ns
a->SetNewCoincidencetime (kC6D6, 40.0); // Coincidences between 30 ns
a->UseWeightingFunction(kC6D6, wfzn1, wfzn2, wfzn3, wfzn4); //Zero the additonal two C6D6s
a->UseCalibration(kC6D6, caldet1, caldet2, caldet3, caldet4);
a->SetNewCutsEg(kC6D6, 0.200, 10.0);
a->ProcessListOfRuns_Single(prefix, runlist_Zn, suffix, "Zn_single_ALL_dedicated.root", "Zn", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_E, suffix, "Zn_single_ALL_dedicated.root", "E", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_Zn, suffix, "Zn_sum_ALL_dedicated.root", "Zn", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_E, suffix, "Zn_sum_ALL_dedicated.root", "E", "UPDATE");
return 0;
}
|
| Attachment 5: Process_Zn_inc_prob_parasitic.C
|
// g++ -Wall -O3 -g `root-config --cflags --ldflags --glibs` process_runs_Zn_full.cpp -o process_runs_Zn_full && ./process_runs_Zn_full
#include <iostream>
#include <TFile.h>
#include <TCanvas.h>
#include <TPad.h>
#include <TAxis.h>
#include <TH1D.h>
#include <TF1.h>
#include <TLegend.h>
#include <TLegendEntry.h>
#include <TDirectory.h>
#include <fstream>
#include <math.h>
#include "/eos/experiment/ntof/codes/TTOFSort/TTOFSort_nTOF.h"
#ifndef __CINT__
#include "/eos/experiment/ntof/codes/TTOFSort/TTOFSort_nTOF.cxx"
#endif
using namespace std;
Double_t caldet1(Double_t x){return(-0.0126844 + 0.000250511 * x);}
//Double_t caldet1b(Double_t x){return(0.0300862 + 0.000239789 * x);}
//Double_t caldet1c(Double_t x){return(-0.00982159 + 0.000243208 * x);}
Double_t caldet2(Double_t x){return(0.00933879 + 0.000223045 * x);}
Double_t caldet3(Double_t x){return(0.0448306 + 0.000295976 * x);}
Double_t caldet4(Double_t x){return(0.039253 + 0.000228249 * x);}
Double_t caldet5(Double_t x){return(0.039253 + 0.000228249 * x);}
Double_t caldet6(Double_t x){return(0.039253 + 0.000228249 * x);}
Double_t wfzn1(Double_t x){return(52.4331 - 15.7227 * x + 129.696 * x * x - 21.3173 * x * x * x + 1.23419 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfzn2(Double_t x){return(54.8656 - 23.9266 * x + 136.114 * x * x - 22.9382 * x * x * x + 1.36142 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfzn3(Double_t x){return(55.0448 - 24.1592 * x + 135.662 * x * x - 22.6676 * x * x * x + 1.32807 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfzn4(Double_t x){return(53.7253 - 20.1490 * x + 133.263 * x * x - 22.2370 * x * x * x + 1.30748 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau1(Double_t x){return(33.0459 - 14.2600 * x + 79.6741 * x * x - 12.5454 * x * x * x + 75.7094 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau2(Double_t x){return(31.1978 - 8.63083 * x + 76.0325 * x * x - 11.7987 * x * x * x + 71.1593 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau3(Double_t x){return(30.1989 - 5.58729 * x + 74.0714 * x * x - 11.4009 * x * x * x + 68.8028 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau4(Double_t x){return(30.0116 - 5.09782 * x + 73.9204 * x * x - 11.4115 * x * x * x + 69.3298 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t dummy_function(Double_t x){return 0.;}
int Zn68(){
Char_t prefix[] = "root://eospublic.cern.ch//eos/experiment/ntof/data/rootfiles/2018/ear1/run";
Char_t suffix[] = ".root";
Int_t runlist_Zn[]={108347,108348,108349,108350,108351,108352,108353,108355,108357,108359,108360,108361,108362,\
108363,108364,108397,108398,108399,108400,108406,108408,\
108409,108410,108411,108414,108415,108416,108417,108418,108419,\
108422,108423,108425,108426,108427,108428,108429,\
108430,108431,108432,108433,108434,108435,108436,108437,108438,108440,\
108441,108442,108443,108444,108459,108460,108461,\
108512,108513,108514,108515,108516,108517,108518,108519,\
108520,108523,108524,108525,108526,108527,\
108535,108536,108537,108538,108539,108548,108559,108565,-1};
Int_t runlist_E[]={108393,108392,108391,108390,108389,108388,108387,108495,108494,108493,108492,108491,-1};
//Int_t runlist_Au[]={108339,108340,108342,108343,108344,108345,108346,108403,108404,108405,108490,108489,-1};
TTOFSort *a = new TTOFSort();
a->SetEnableMonitorPerBunch(); // include information on monitors per bunch
a->AddDetector(kC6D6, 6);
a->AddDetector(kSILI,4);
a->AddDetector(kPKUP,1);
a->SetNewVariableNames_amplitude(kC6D6, "amp"); // use instead of variable amp
a->SetNewVariableNames_amplitude(kSILI ,"amp");
a->SetNewVariableNames_amplitude(kPKUP ,"amp");
//a->SetPriorCut(kC6D6,"PulseIntensity>5E12"); a->SetPriorCut(kC6D6,"PulseIntensity>2E12",&&,"PulseIntensity<5E12");
a->SetPriorCut(kC6D6,"PulseIntensity>2E12 && PulseIntensity<5E12");
//a->SetPriorCut(kC6D6,"PulseIntensity>5E12 && detn!=1 && detn!=4");
a->SetPriorCut(kSILI,"PulseIntensity>2E12 && PulseIntensity<5E12");
a->SetPriorCut(kPKUP,"PulseIntensity>2E12 && PulseIntensity<5E12");
a->SetNewBinParsA(kC6D6, 0.0, 7000, 70000); // CLW: CHANGED BINNING
a->SetNewBinParsA(kSILI, 0.0, 7000, 70000); // CLW: CHANGED BINNING
a->SetNewVariableNames_amplitude(kC6D6, "amp");
a->SetNewFixedDeadtime(kC6D6, 50.0); // fixed deadtime of 30 ns
a->SetNewCoincidencetime (kC6D6, 40.0); // Coincidences between 30 ns
a->UseWeightingFunction(kC6D6, wfzn1, wfzn2, wfzn3, wfzn4); //Zero the additonal two C6D6s
a->UseCalibration(kC6D6, caldet1, caldet2, caldet3, caldet4);
a->SetNewCutsEg(kC6D6, 0.200, 10.0);
a->ProcessListOfRuns_Single(prefix, runlist_Zn, suffix, "Zn_single_ALL_parasitic.root", "Zn", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_E, suffix, "Zn_single_ALL_parasitic.root", "E", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_Zn, suffix, "Zn_sum_ALL_parasitic.root", "Zn", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_E, suffix, "Zn_sum_ALL_parasitic.root", "E", "UPDATE");
return 0;
}
|
| Attachment 6: Process_Zn_inc_prob.C
|
// g++ -Wall -O3 -g `root-config --cflags --ldflags --glibs` process_runs_Zn_full.cpp -o process_runs_Zn_full && ./process_runs_Zn_full
#include <iostream>
#include <TFile.h>
#include <TCanvas.h>
#include <TPad.h>
#include <TAxis.h>
#include <TH1D.h>
#include <TF1.h>
#include <TLegend.h>
#include <TLegendEntry.h>
#include <TDirectory.h>
#include <fstream>
#include <math.h>
#include "/eos/experiment/ntof/codes/TTOFSort/TTOFSort_nTOF.h"
#ifndef __CINT__
#include "/eos/experiment/ntof/codes/TTOFSort/TTOFSort_nTOF.cxx"
#endif
using namespace std;
Double_t caldet1(Double_t x){return(-0.0126844 + 0.000250511 * x);}
//Double_t caldet1b(Double_t x){return(0.0300862 + 0.000239789 * x);}
//Double_t caldet1c(Double_t x){return(-0.00982159 + 0.000243208 * x);}
Double_t caldet2(Double_t x){return(0.00933879 + 0.000223045 * x);}
Double_t caldet3(Double_t x){return(0.0448306 + 0.000295976 * x);}
Double_t caldet4(Double_t x){return(0.039253 + 0.000228249 * x);}
Double_t caldet5(Double_t x){return(0.039253 + 0.000228249 * x);}
Double_t caldet6(Double_t x){return(0.039253 + 0.000228249 * x);}
Double_t wfzn1(Double_t x){return(52.4331 - 15.7227 * x + 129.696 * x * x - 21.3173 * x * x * x + 1.23419 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfzn2(Double_t x){return(54.8656 - 23.9266 * x + 136.114 * x * x - 22.9382 * x * x * x + 1.36142 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfzn3(Double_t x){return(55.0448 - 24.1592 * x + 135.662 * x * x - 22.6676 * x * x * x + 1.32807 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfzn4(Double_t x){return(53.7253 - 20.1490 * x + 133.263 * x * x - 22.2370 * x * x * x + 1.30748 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau1(Double_t x){return(33.0459 - 14.2600 * x + 79.6741 * x * x - 12.5454 * x * x * x + 75.7094 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau2(Double_t x){return(31.1978 - 8.63083 * x + 76.0325 * x * x - 11.7987 * x * x * x + 71.1593 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau3(Double_t x){return(30.1989 - 5.58729 * x + 74.0714 * x * x - 11.4009 * x * x * x + 68.8028 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t wfau4(Double_t x){return(30.0116 - 5.09782 * x + 73.9204 * x * x - 11.4115 * x * x * x + 69.3298 * x * x * x * x);} //Coeff 0.0810697 0.0604489 0
Double_t dummy_function(Double_t x){return 0.;}
int Zn68(){
Char_t prefix[] = "root://eospublic.cern.ch//eos/experiment/ntof/data/rootfiles/2018/ear1/run";
Char_t suffix[] = ".root";
Int_t runlist_Zn[]{108347,108348,108349,108350,108351,108352,108353,108355,108357,108359,108360,108361,108362,\
108363,108364,108397,108398,108399,108400,108406,108408,\
108409,108410,108411,108414,108415,108416,108417,108418,108419,\
108422,108423,108425,108426,108427,108428,108429,\
108430,108431,108432,108433,108434,108435,108436,108437,108438,108440,\
108441,108442,108443,108444,108459,108460,108461,\
108512,108513,108514,108515,108516,108517,108518,108519,\
108520,108523,108524,108525,108526,108527,\
108535,108536,108537,108538,108539,108548,108559,108565,-1};
Int_t runlist_E[]={108393,108392,108391,108390,108389,108388,108387,108495,108494,108493,108492,108491,-1};
//Int_t runlist_Au[]={108339,108340,108342,108343,108344,108345,108346,108403,108404,108405,108490,108489,-1};
TTOFSort *a = new TTOFSort();
a->SetEnableMonitorPerBunch(); // include information on monitors per bunch
a->AddDetector(kC6D6, 6);
a->AddDetector(kSILI,4);
a->AddDetector(kPKUP,1);
a->SetNewVariableNames_amplitude(kC6D6, "amp"); // use instead of variable amp
a->SetNewVariableNames_amplitude(kSILI ,"amp");
a->SetNewVariableNames_amplitude(kPKUP ,"amp");
//a->SetPriorCut(kC6D6,"PulseIntensity>5E12"); a->SetPriorCut(kC6D6,"PulseIntensity>2E12",&&,"PulseIntensity<5E12");
//a->SetPriorCut(kC6D6);
//a->SetPriorCut(kSILI);
//a->SetPriorCut(kPKUP);
a->SetNewBinParsA(kC6D6, 0.0, 7000, 70000); // CLW: CHANGED BINNING
a->SetNewBinParsA(kSILI, 0.0, 7000, 70000); // CLW: CHANGED BINNING
a->SetNewVariableNames_amplitude(kC6D6, "amp");
a->SetNewFixedDeadtime(kC6D6, 50.0); // fixed deadtime of 30 ns
a->SetNewCoincidencetime (kC6D6, 40.0); // Coincidences between 30 ns
a->UseWeightingFunction(kC6D6, wfzn1, wfzn2, wfzn3, wfzn4); //Zero the additonal two C6D6s
a->UseCalibration(kC6D6, caldet1, caldet2, caldet3, caldet4);
a->SetNewCutsEg(kC6D6, 0.200, 10.0);
a->ProcessListOfRuns_Single(prefix, runlist_Zn, suffix, "Zn_single_ALL.root", "Zn", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_E, suffix, "Zn_single_ALL.root", "E", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_Zn, suffix, "Zn_sum_ALL.root", "Zn", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_E, suffix, "Zn_sum_ALL.root", "E", "UPDATE");
return 0;
}
|
|
54
|
Tue Nov 7 13:21:51 2023 |
Emma Walker | Si-30: Comparison between background corrected and uncorrected | Below are graphs for the comparison between background corrected and uncorrected spectra (weighted) for Si-30, Au20, Au22 and Sinatgood.
This is just for C6D6 detector 1 but all detectors are consisitent. All histograms have been rebinned by 100 for clarity. |
| Attachment 1: Comp_backgroundsub_Si_1.pdf
|
|
| Attachment 2: Comp_backgroundsub_Au20_1.pdf
|
|
| Attachment 3: Comp_backgroundsub_Au22_1.pdf
|
|
| Attachment 4: Comp_backgroundsub_Sinatgood_1.pdf
|
|
|
53
|
Mon Nov 6 11:13:11 2023 |
Emma Walker | Comparison of empty, ambient and sample- Si-30 | Below are graphs for each sample (weighted) showing the comparison between ambient spectra, empty/dummy holder and sample spectra.
All four detectors are shown for each sample (Si-30, Au20, Au22, Sinatgood).
All histograms have been rebinned by 50. |
| Attachment 1: Si-30_Background_comp_1.png
|
|
| Attachment 2: Si-30_Background_comp_2.png
|
|
| Attachment 3: Si-30_Background_comp_3.png
|
|
| Attachment 4: Si-30_Background_comp_4.png
|
|
| Attachment 5: Au20_Background_comp_1.png
|
|
| Attachment 6: Au20_Background_comp_2.png
|
|
| Attachment 7: Au20_Background_comp_3.png
|
|
| Attachment 8: Au20_Background_comp_4.png
|
|
| Attachment 9: Au22_Background_comp_1.png
|
|
| Attachment 10: Au22_Background_comp_2.png
|
|
| Attachment 11: Au22_Background_comp_3.png
|
|
| Attachment 12: Au22_Background_comp_4.png
|
|
| Attachment 13: Sinatgood_Background_comp_1.png
|
|
| Attachment 14: Sinatgood_Background_comp_2.png
|
|
| Attachment 15: Sinatgood_Background_comp_3.png
|
|
| Attachment 16: Sinatgood_Background_comp_4.png
|
|
|
52
|
Fri Oct 27 17:13:58 2023 |
Emma Walker | Si-30: Dedicated vs Parasitic before and after removal of ambient | Below are histograms for the weighted spectra (with deadtime correction) with and without ambient for C6D6 detector 1.
For each sample the histogram with ambient is first and then without ambient (please ignore histogram titles).
The Dummy, Empty and C-nat have been rebined by combining 100 to 1.
The Au20, Au22, Si-30 and Sinatgood have been rebined by combining 10 to 1.
Si-30 WF used for: Si-30, Dummy, Empty, C-nat
Au20 WF used for: Au20
Au22 WF used for: Au22
Sinatgood WF used for: Sinatgood |
| Attachment 1: DvsP_1_rebin.pdf
|
|
| Attachment 2: DvsP_1_amb.pdf
|
|
| Attachment 3: DvsP_1_dummy.pdf
|
|
| Attachment 4: DvsP_1_dummyamb.pdf
|
|
| Attachment 5: DvsP_1_empty.pdf
|
|
| Attachment 6: DvsP_1_emptyamb.pdf
|
|
| Attachment 7: DvsP_1_C.pdf
|
|
| Attachment 8: DvsP_1_Camb.pdf
|
|
| Attachment 9: DvsP_1_Au20.pdf
|
|
| Attachment 10: DvsP_1_Au20amb.pdf
|
|
| Attachment 11: DvsP_1_Au22.pdf
|
|
| Attachment 12: DvsP_1_Au22amb.pdf
|
|
| Attachment 13: DvsP_1_Sinatgood.pdf
|
|
| Attachment 14: DvsP_1_Sinatgoodamb.pdf
|
|
|
51
|
Tue Oct 24 11:29:46 2023 |
AR | Weighted Histograms Vs Deadtime*Corrected: 68Zn | |
| Attachment 1: combined_vs_weighted_parasitic_det3.pdf
|
|
| Attachment 2: combined_vs_weighted_parasitic_det2.pdf
|
|
| Attachment 3: combined_vs_weighted_parasitic_all_dets.pdf
|
|
| Attachment 4: combined_vs_weighted_dedicated_det3.pdf
|
|
| Attachment 5: combined_vs_weighted_dedicated_det2.pdf
|
|
| Attachment 6: combined_vs_weighted_dedicated_all_dets.pdf
|
|
| Attachment 7: combined_parasitic_all_dets.pdf
|
|
| Attachment 8: corrected_dedicated_both_dets.pdf
|
|
| Attachment 9: weighted_para_vs_ded_det3.pdf
|
|
| Attachment 10: weighted_para_vs_ded_det3_R3.pdf
|
|
| Attachment 11: weighted_para_vs_ded_det3_R2.pdf
|
|
| Attachment 12: weighted_para_vs_ded_det3_R1.pdf
|
|
| Attachment 13: Weighted_para_vs_ded_det2.pdf
|
|
| Attachment 14: weighted_para_vs_ded_det2_R3.pdf
|
|
| Attachment 15: weighted_para_vs_ded_det2_R1.pdf
|
|
| Attachment 16: weighred_para_vs_ded_det2_R2.pdf
|
|
| Attachment 17: corrected_para_vs_ded_det3.pdf
|
|
| Attachment 18: corrected_para_vs_ded_det3_R3.pdf
|
|
| Attachment 19: corrected_para_vs_ded_det3_R2.pdf
|
|
| Attachment 20: corrected_para_vs_ded_det3_R1.pdf
|
|
| Attachment 21: corrected_para_vs_ded_det2.pdf
|
|
| Attachment 22: corrected_para_vs_ded_det2_R3.pdf
|
|
| Attachment 23: corrected_para_vs_ded_det2_R2.pdf
|
|
| Attachment 24: corrected_para_vs_ded_det2_R1.pdf
|
|
|
50
|
Mon Oct 23 12:47:16 2023 |
Emma Walker | Si-30 weighted and corrected spectra and deadtime correction histograms (parasitic) | Si-30:
Histograms for deadtime correction for all 4 C6D6 detectors for parasitic beam.
Histograms for weighted and deadtime corrected parasitic spectra. |
| Attachment 1: Si_1_corr_pb.pdf
|
|
| Attachment 2: Si_2_corr_pb.pdf
|
|
| Attachment 3: Si_3_corr_pb.pdf
|
|
| Attachment 4: Si_4_corr_pb.pdf
|
|
| Attachment 5: Si_1_wcorr_pb.pdf
|
|
| Attachment 6: Si_2_wcorr_pb.pdf
|
|
| Attachment 7: Si_3_wcorr_pb.pdf
|
|
| Attachment 8: Si_4_wcorr_pb.pdf
|
|
|
49
|
Mon Oct 23 12:39:33 2023 |
Emma Walker | Si-30 corrected weighted and dead time corrections histograms (dedicated) | Si-30:
Histograms for dead time corrections for all 4 C6D6 detectors.
Histograms for weighted and deadtime corrected dedicated spectra. |
| Attachment 1: Si_1_corr_db.pdf
|
|
| Attachment 2: Si_2_corr_db.pdf
|
|
| Attachment 3: Si_3_corr_db.pdf
|
|
| Attachment 4: Si_4_corr_db.pdf
|
|
| Attachment 5: Si_1_wcorr_db.pdf
|
|
| Attachment 6: Si_2_wcorr_db.pdf
|
|
| Attachment 7: Si_3_wcorr_db.pdf
|
|
| Attachment 8: Si_4_wcorr_db.pdf
|
|
|
48
|
Wed Oct 18 12:14:09 2023 |
Emma Walker | Processing file for EAR-1 with WF applied, Si-30 | Weighting function for Si-30, Au22, Au20 and Sinatgood applied for parasitic and dedicated beams. |
| Attachment 1: Weighting_processing.c
|
/// 23.6.23, 9:30 edit CLW - process also other runlists
// g++ -Wall -O3 -g `root-config --cflags --ldflags --glibs` Process_Si.C -o Process_Si && ./Process_Si
// includes header, and source only in compiled script
#include "/eos/experiment/ntof/codes/TTOFSort/TTOFSort_nTOF.h"
#ifndef __CINT__
#include "/eos/experiment/ntof/codes/TTOFSort/TTOFSort_nTOF.cxx"
#endif
// --------------------------------------------------------------------------
//
//
//
// --------------------------------------------------------------------------
Double_t a2e_c6d61(Double_t x) { // from amplitude (channel) to MeV
return (3.71330E-02+ 2.78468E-04* x );
}
Double_t a2e_c6d62(Double_t x) { // from amplitude (channel) to MeV
return (1.21071E-02+ 2.82656E-04* x);
}
Double_t a2e_c6d63(Double_t x) { // from amplitude (channel) to MeV
return (2.74746E-02+ 2.64094E-04* x);
}
Double_t a2e_c6d64(Double_t x) { // from amplitude (channel) to MeV
return (2.96214E-02+ 2.73633E-04* x );
}
Double_t wf_Si(Double_t x) { //WF for silicon 30
return (9.65464 - 6.83768 * x + 26.4596 * x * x - 5.02546 * x * x * x + 0.372149 * x * x * x * x);
}
Double_t wf_Sinatgood(Double_t x) { //WF for silicon natural
return (8.86824 - 1.26346 * x + 18.4828 * x * x - 2.25899 * x * x * x + 0.106017 * x * x * x * x);
}
Double_t wf_Au20(Double_t x) { //WF for 20mm-gold
return (7.93383 + 1.02633 * x + 16.9180 * x * x - 1.95645 * x * x * x + 0.0918222 * x * x * x * x);
}
Double_t wf_Au22(Double_t x) { //WF for 22mm-gold
return (7.93673 + 1.00093 * x + 16.9408 * x * x - 1.96542 * x * x * x + 0.0923510 * x * x * x * x);
}
int main() {
Char_t prefix[] = "/eos/experiment/ntof/processing/official/done/run";
Char_t suffix[] = ".root";
Int_t runlist_co[] = {116215, 116216, 116217, 116218, -1};
Int_t runlist_ba[] = {116208, 116209, 116210, 116211, 116212, 116213, 116214, -1};
Int_t runlist_mn[] = {116203, 116204, 116205, 116206, 116207, -1};
Int_t runlist_bi[] = {116193, 116194, -1};
Int_t runlist_cs[] = {116093, 116159, 116160, 116161, 116296, 116384, 116385,116445,116476,116567 ,-1};
Int_t runlist_y[] = {116094, 116162, 116163, 116164, 116297, 116298, 116380, 116381, 116382,116446,116475,116568, -1};
Int_t runlist_ambe[] = {116095, 116096, 116097, 116165, 116166, 116167, 116168, 116169, 116170, 116171, 116172, 116173, 116174, 116299, 116301, 116302, 116375, 116376,116467,116468,116469,116470,116569 ,116570,116571,-1};
Int_t runlist_cmc[] = {116179, 116180, 116181, 116182, 116183, 116184, 116185, 116186, 116187, 116188, 116189, 116190, 116191, 116192, 116219, 116220, 116221, 116222, 116303, 116304, 116305, 116377,116378, 116379,116447,116448, 116449,116450, 116451,116471,116472,116473,116474, -1};
Int_t runlist_cnat[]={116284, 116285, 116286, 116287, 116288, 116308, 116309, 116310, 116311,
116312,116313,116314,116315,116316,116317,116318,116319,116320, -1};
Int_t runlist_au20mm[] = {116100, 116101, 116102,116322,116548, -1};
Int_t runlist_au22mm[] = { 116226, 116227, 116229, 116231, 116232, 116234, 116235, 116321,116507,116508,116509,116510,-1};
//116225 116505 116506was 'BAD'
Int_t runlist_amb[] = {116103, 116104, 116106, 116108, 116109, 116110, 116111, 116119, 116120, 116121, 116122, 116123, 116127, 116128, 116129, 116130, 116131, 116132, 116133, 116134, 116135, 116141, 116143, 116154, 116155, 116156, 116157, 116158, 116175, 116176, 116177, 116178,116197, 116198, 116199, 116200, 116201, 116202, 116248, 116249, 116250, 116251, 116252, 116253, 116254, 116255, 116257, 116258, 116259,116374, 116386, 116387, 116388, 116389, 116390, 116391, 116392, 116393,116405,116444,116443,116452,116453,116454,116455,116456,116457,116458,116459,116460,116461,116462,116463,116464,116465,116466,116477,116478,116479,116480,116481,116483,116485,116487,116488,116490,116491,116492,116493,116494,116495,116496,116498,116499,116501,116503,116519,116520,116521,116522, -1}; // no beam and no calibration source
Int_t runlist_dummy[] = {116237, 116241, 116242, 116243, 116244, 116245, 116246, 116247, 116253, 116260, 116261, 116420, 116421, 116422, 116423, 116424, 116425, 116426, 116427, 116428, 116429, 116430, 116431, 116432, 116433, 116434, 116435, 116436, 116437, 116438,116439,-1};
//, 116418 too slow 116240 is bad
Int_t runlist_empty[] = {116323, 116324, 116325,116326,116327,116328, -1};
Int_t runlist_30si[] = {116105, 116112, 116113, 116114, 116115, 116116, 116117, 116118, 116124, 116125, 116126, 116136, 116137, 116138, 116139, 116140, 116142, 116144, 116145, 116146, 116147, 116148, 116149, 116150, 116151, 116152, 116153, 116263, 116264, 116265, 116266, 116268, 116269, 116270, 116271, 116272, 116273, 116274, 116275, 116276, 116277, 116278, 116279, 116280, 116281, 116282, 116283, 116358, 116359, 116360, 116361, 116362, 116363, 116364, 116367, 116368, 116369, 116371, 116372, 116373, 116394, 116395, 116396, 116397, 116398, 116399, 116400, 116401, 116402, 116403, 116404, 116406, 116407, 116408, 116409, 116411, 116412, 116413, 116415,116440,116441,116482,116484,116486,116489,116502,116504, -1};
//116365, 116466 are empty (should be Si run) , 116370,116442,116414 (116262 this one was 'bad')
Int_t runlist_sinat[] = {116330, 116331, 116332, 116333, 116335, 116337, 116339, 116341, 116342, 116343, 116344, 116345, 116346, 116347, 116348, 116349, 116350, 116351, 116352, 116353, 116354, 116355, 116356, 116357,116511 ,116512 ,116513 ,116514 ,116517 ,116518 ,116523 ,116524 ,116525 ,116526 ,116527 ,116528 ,116532 ,116533 ,116534 ,116535 ,116536 ,116537 ,116538 ,116539 ,116540 ,116541 ,116542 ,116543 ,116544 ,116545 ,116546 ,-1};
//bad 116529, 116530,116531
Int_t runlist_sinat_good[] = { 116549 ,116551 ,116552 ,116553 ,116554 ,116555 ,116556 ,116557 ,116558 ,116559 ,116560 ,116561 ,116562,116563,116564,116565,116566, -1 };
TTOFSort *a = new TTOFSort();
a->AddDetector(kC6D6, 4);
//a->SetNewBinParsA(kC6D6, 0.0, 6500, 6500000.0);
a->SetNewBinParsT(kC6D6, -10.0, 2.0, 1e3, 5000, 1e9); //Double the nbins (10k here becomes 20k bpd spec)
a->PrintSettings();
a->SetNewFixedDeadtime(kC6D6, 30.0);//fixed deadtime of 30 ns
a->SetNewCoincidencetime(kC6D6, 30.0);//Coincidences between 30 ns
a->SetNewVariableNames_amplitude(kC6D6, "amp");
a->SetNewBinParsA(kC6D6, 0.0, 6500, 70000);
a->SetNewCutsAmp_all(kC6D6, 600, 50000);
a->UseCalibration(kC6D6, a2e_c6d61, a2e_c6d62, a2e_c6d63, a2e_c6d64);
a->SetNewCutsEg(kC6D6, 0.200, 8.0, 0.200, 8.0, 0.200, 8.0, 0.200, 8.0);
a->SetPriorCut(kC6D6, "PulseIntensity<1e7");
//a->ProcessListOfRuns_Sum(prefix, runlist_co, suffix, "Sum_Cal.root", "Co", "RECREATE");
//a->ProcessListOfRuns_Sum(prefix, runlist_bi, suffix, "Sum_Cal.root", "Bi", "UPDATE");
//a->ProcessListOfRuns_Sum(prefix, runlist_ba, suffix, "Sum_Cal.root", "Ba", "UPDATE");
//a->ProcessListOfRuns_Sum(prefix, runlist_mn, suffix, "Sum_Cal.root", "Mn", "UPDATE");
//a->ProcessListOfRuns_Sum(prefix, runlist_cs, suffix, "Sum_Cal.root", "Cs", "UPDATE");
//a->ProcessListOfRuns_Sum(prefix, runlist_y, suffix, "Sum_Cal.root", "Y", "UPDATE");
//a->ProcessListOfRuns_Sum(prefix, runlist_ambe, suffix, "Sum_Cal.root", "Ambe", "UPDATE");
//a->ProcessListOfRuns_Sum(prefix, runlist_cmc, suffix, "Sum_Cal.root", "Cmc", "UPDATE");
//a->ProcessListOfRuns_Sum(prefix, runlist_amb, suffix, "Sum_Amb.root", "Amb", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_co, suffix, "Co.root", "Co", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_bi, suffix, "Bi.root", "Bi", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_ba, suffix, "Ba.root", "Ba", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_mn, suffix, "Mn.root", "Mn", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_cs, suffix, "Cs.root", "Cs", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_y, suffix, "Y.root", "Y", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_ambe, suffix, "Ambe.root", "Ambe", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_cmc, suffix, "Cmc.root", "Cmc", "RECREATE");
a->UseWeightingFunction(kC6D6, wf_Si);
a->ProcessListOfRuns_Sum(prefix, runlist_amb, suffix, "Amb_sum_SiWF.root", "Amb", "RECREATE");
a->UseWeightingFunction(kC6D6, wf_Au20);
a->ProcessListOfRuns_Sum(prefix, runlist_amb, suffix, "Amb_sum_Au20WF.root", "Amb", "RECREATE");
a->UseWeightingFunction(kC6D6, wf_Au22);
a->ProcessListOfRuns_Sum(prefix, runlist_amb, suffix, "Amb_sum_Au22WF.root", "Amb", "RECREATE");
a->UseWeightingFunction(kC6D6, wf_Sinatgood);
a->ProcessListOfRuns_Sum(prefix, runlist_amb, suffix, "Amb_sum_SinatgoodWF.root", "Amb", "RECREATE");
// dedicated >5E12, parasitic 1-5 E12
//a->SetPriorCut(kC6D6, "PulseIntensity>1e12");
a->AddDetector(kSILI, 4);
//a->SetNewBinParsA(kSILI, 0.0, 1e4, 1e5);
a->SetNewVariableNames_amplitude(kSILI, "amp");
//a->SetPriorCut(kSILI, "PulseIntensity>1e12");
a->SetNewBinParsA(kSILI, 0.0, 6500, 70000);
a->SetNewCutsAmp_all(kSILI, 8000, 40000);
a->SetNewCutsTime_all(kSILI, 1E4, 1E9);
a->AddDetector(kPKUP, 1);
a->SetNewVariableNames_amplitude(kPKUP, "amp");
a->SetPriorCut(kPKUP,"amp>5000 && amp<50000");
a->SetNewBinParsA(kPKUP,0.0,6500,70000);
//a->SetPriorCut(kPKUP, "PulseIntensity>1e12");
//a->UseWeightingFunction(kC6D6, wf, wf, wf, wf);
a->SetPriorCut(kC6D6, "PulseIntensity>1e+12");
a->SetPriorCut(kPKUP, "PulseIntensity>1e+12");
a->SetPriorCut(kSILI, "PulseIntensity>1e+12");
//For dedicated pulse
a->SetPriorCut(kC6D6, "PulseIntensity>5e+12");
a->SetPriorCut(kSILI, "PulseIntensity>5e+12");
a->SetPriorCut(kPKUP, "PulseIntensity>5e+12");
a->UseWeightingFunction(kC6D6, wf_Si);
a->ProcessListOfRuns_Sum(prefix, runlist_30si, suffix, "Dedicated_Si_weighting.root", "Si", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_dummy, suffix, "Dedicated_Si_weighting.root", "Dummy", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_cnat, suffix, "Dedicated_Si_weighting.root", "C", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_empty, suffix, "Dedicated_Si_weighting.root", "E", "UPDATE");
a->UseWeightingFunction(kC6D6, wf_Au20);
a->ProcessListOfRuns_Sum(prefix, runlist_au20mm, suffix, "Dedicated_Au20_weighting.root", "Au20", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_dummy, suffix, "Dedicated_Au20_weighting.root", "Dummy", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_cnat, suffix, "Dedicated_Au20_weighting.root", "C", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_empty, suffix, "Dedicated_Au20_weighting.root", "E", "UPDATE");
a->UseWeightingFunction(kC6D6, wf_Au22);
a->ProcessListOfRuns_Sum(prefix, runlist_au22mm, suffix, "Dedicated_Au22_weighting.root", "Au22", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_dummy, suffix, "Dedicated_Au22_weighting.root", "Dummy", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_cnat, suffix, "Dedicated_Au22_weighting.root", "C", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_empty, suffix, "Dedicated_Au22_weighting.root", "E", "UPDATE");
a->UseWeightingFunction(kC6D6, wf_Sinatgood);
a->ProcessListOfRuns_Sum(prefix, runlist_sinat_good, suffix, "Dedicated_Sinatgood_weighting.root", "Sinatgood", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_dummy, suffix, "Dedicated_Sinatgood_weighting.root", "Dummy", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_cnat, suffix, "Dedicated_Sinatgood_weighting.root", "C", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_empty, suffix, "Dedicated_Sinatgood_weighting.root", "E", "UPDATE");
//For parastic pulse
a->SetPriorCut(kC6D6, "PulseIntensity>1e+12 && PulseIntensity<5e+12");
a->SetPriorCut(kSILI, "PulseIntensity>1e+12 && PulseIntensity<5e+12");
a->SetPriorCut(kPKUP, "PulseIntensity>1e+12 && PulseIntensity<5e+12");
a->UseWeightingFunction(kC6D6, wf_Si);
a->ProcessListOfRuns_Sum(prefix, runlist_30si, suffix, "Parasitic_Si_weighting.root", "Si", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_dummy, suffix, "Parasitic_Si_weighting.root", "Dummy", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_cnat, suffix, "Parasitic_Si_weighting.root", "C", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_empty, suffix, "Parasitic_Si_weighting.root", "E", "UPDATE");
a->UseWeightingFunction(kC6D6, wf_Au20);
a->ProcessListOfRuns_Sum(prefix, runlist_au20mm, suffix, "Parasitic_Au20_weighting.root", "Au20", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_dummy, suffix, "Parasitic_Au20_weighting.root", "Dummy", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_cnat, suffix, "Parasitic_Au20_weighting.root", "C", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_empty, suffix, "Parasitic_Au20_weighting.root", "E", "UPDATE");
a->UseWeightingFunction(kC6D6, wf_Au22);
a->ProcessListOfRuns_Sum(prefix, runlist_au22mm, suffix, "Parasitic_Au22_weighting.root", "Au22", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_dummy, suffix, "Parasitic_Au22_weighting.root", "Dummy", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_cnat, suffix, "Parasitic_Au22_weighting.root", "C", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_empty, suffix, "Parasitic_Au22_weighting.root", "E", "UPDATE");
a->UseWeightingFunction(kC6D6, wf_Sinatgood);
a->ProcessListOfRuns_Sum(prefix, runlist_sinat_good, suffix, "Parasitic_Sinatgood_weighting.root", "Sinatgood", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_dummy, suffix, "Parasitic_Sinatgood_weighting.root", "Dummy", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_cnat, suffix, "Parasitic_Sinatgood_weighting.root", "C", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_empty, suffix, "Parasitic_Sinatgood_weighting.root", "E", "UPDATE");
/*
//For total pulse
a->ProcessListOfRuns_Sum(prefix, runlist_30si, suffix, "Sum_Beam.root", "Si", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_au20mm, suffix, "Sum_Beam.root", "Au20", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_au22mm, suffix, "Sum_Beam.root", "Au22", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_dummy, suffix, "Sum_Beam.root", "Dummy", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_cnat, suffix, "Sum_Beam.root", "C", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_empty, suffix, "Sum_Beam.root", "E", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_sinat, suffix, "Sum_Beam.root", "Sinat", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_sinat_good, suffix, "Beam.root", "Sinatgood", "UPDATE");
a->ProcessListOfRuns_Single(prefix, runlist_30si, suffix, "Single_30Si.root", "Si", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_au20mm, suffix, "Single_Au20.root", "Au20", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_au22mm, suffix, "Single_Au22.root", "Au22", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_dummy, suffix, "Single_Dummy.root", "Dummy", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_cnat, suffix, "Single_C.root", "C", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_empty, suffix, "Single_E.root", "E", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_sinat, suffix, "Single_Sinat.root", "Sinat", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_sinat_good, suffix, "Single_Sinatgood.root", "Sinatgood", "RECREATE");
*/
/*
a->SetPriorCut(kC6D6, "PulseIntensity>1e12");
a->SetPriorCut(kC6D6, "tflash>10000");
a->SetTgWindow(kC6D6,10000,15000);
a->SetNewCutsAmp_all(kC6D6, 1800, 50000);
a->ProcessListOfRuns_Sum(prefix, runlist_30si, suffix, "Sum_30Si_hithresh.root", "Si", "RECREATE");
*/
return 0;
}
|
|
47
|
Wed Aug 30 12:08:45 2023 |
Michael Donnachie | Processing files | Here are the Processing files for EAR1 and EAR2 with calibrations. |
| Attachment 1: Process_Si_beam.C
|
/// 23.6.23, 9:30 edit CLW - process also other runlists
// g++ -Wall -O3 -g `root-config --cflags --ldflags --glibs` Process_Si.C -o Process_Si && ./Process_Si
// includes header, and source only in compiled script
#include "/eos/experiment/ntof/codes/TTOFSort/TTOFSort_nTOF.h"
#ifndef __CINT__
#include "/eos/experiment/ntof/codes/TTOFSort/TTOFSort_nTOF.cxx"
#endif
// --------------------------------------------------------------------------
//
//
//
// --------------------------------------------------------------------------
Double_t a2e_c6d61(Double_t x) { // from amplitude (channel) to MeV
return (3.71330E-02+ 2.78468E-04* x );
}
Double_t a2e_c6d62(Double_t x) { // from amplitude (channel) to MeV
return (1.21071E-02+ 2.82656E-04* x);
}
Double_t a2e_c6d63(Double_t x) { // from amplitude (channel) to MeV
return (2.74746E-02+ 2.64094E-04* x);
}
Double_t a2e_c6d64(Double_t x) { // from amplitude (channel) to MeV
return (2.96214E-02+ 2.73633E-04* x );
}
Double_t wf(Double_t x) {
return (0.468282 + 36.0785 * x + 9.54532 * x * x + 0.202353 * x * x * x - 0.0352043 * x * x * x * x);
}
int main() {
Char_t prefix[] = "/eos/experiment/ntof/processing/official/done/run";
Char_t suffix[] = ".root";
Int_t runlist_co[] = {116215, 116216, 116217, 116218, -1};
Int_t runlist_ba[] = {116208, 116209, 116210, 116211, 116212, 116213, 116214, -1};
Int_t runlist_mn[] = {116203, 116204, 116205, 116206, 116207, -1};
Int_t runlist_bi[] = {116193, 116194, -1};
Int_t runlist_cs[] = {116093, 116159, 116160, 116161, 116296, 116384, 116385,116445,116476,116567 ,-1};
Int_t runlist_y[] = {116094, 116162, 116163, 116164, 116297, 116298, 116380, 116381, 116382,116446,116475,116568, -1};
Int_t runlist_ambe[] = {116095, 116096, 116097, 116165, 116166, 116167, 116168, 116169, 116170, 116171, 116172, 116173, 116174, 116299, 116301, 116302, 116375, 116376,116467,116468,116469,116470,116569 ,116570,116571,-1};
Int_t runlist_cmc[] = {116179, 116180, 116181, 116182, 116183, 116184, 116185, 116186, 116187, 116188, 116189, 116190, 116191, 116192, 116219, 116220, 116221, 116222, 116303, 116304, 116305, 116377,116378, 116379,116447,116448, 116449,116450, 116451,116471,116472,116473,116474, -1};
Int_t runlist_cnat[]={116284, 116285, 116286, 116287, 116288, 116308, 116309, 116310, 116311,
116312,116313,116314,116315,116316,116317,116318,116319,116320, -1};
Int_t runlist_au20mm[] = {116100, 116101, 116102,116322,116548, -1};
Int_t runlist_au22mm[] = { 116226, 116227, 116229, 116231, 116232, 116234, 116235, 116321,116507,116508,116509,116510,-1};
//116225 116505 116506was 'BAD'
Int_t runlist_amb[] = {116103, 116104, 116106, 116108, 116109, 116110, 116111, 116119, 116120, 116121, 116122, 116123, 116127, 116128, 116129, 116130, 116131, 116132, 116133, 116134, 116135, 116141, 116143, 116154, 116155, 116156, 116157, 116158, 116175, 116176, 116177, 116178,116197, 116198, 116199, 116200, 116201, 116202, 116248, 116249, 116250, 116251, 116252, 116253, 116254, 116255, 116257, 116258, 116259,116374, 116386, 116387, 116388, 116389, 116390, 116391, 116392, 116393,116405,116444,116443,116452,116453,116454,116455,116456,116457,116458,116459,116460,116461,116462,116463,116464,116465,116466,116477,116478,116479,116480,116481,116483,116485,116487,116488,116490,116491,116492,116493,116494,116495,116496,116498,116499,116501,116503,116519,116520,116521,116522, -1}; // no beam and no calibration source
Int_t runlist_dummy[] = {116237, 116241, 116242, 116243, 116244, 116245, 116246, 116247, 116253, 116260, 116261, 116420, 116421, 116422, 116423, 116424, 116425, 116426, 116427, 116428, 116429, 116430, 116431, 116432, 116433, 116434, 116435, 116436, 116437, 116438,116439,-1};
//, 116418 too slow 116240 is bad
Int_t runlist_empty[] = {116323, 116324, 116325,116326,116327,116328, -1};
Int_t runlist_30si[] = {116105, 116112, 116113, 116114, 116115, 116116, 116117, 116118, 116124, 116125, 116126, 116136, 116137, 116138, 116139, 116140, 116142, 116144, 116145, 116146, 116147, 116148, 116149, 116150, 116151, 116152, 116153, 116263, 116264, 116265, 116266, 116268, 116269, 116270, 116271, 116272, 116273, 116274, 116275, 116276, 116277, 116278, 116279, 116280, 116281, 116282, 116283, 116358, 116359, 116360, 116361, 116362, 116363, 116364, 116367, 116368, 116369, 116371, 116372, 116373, 116394, 116395, 116396, 116397, 116398, 116399, 116400, 116401, 116402, 116403, 116404, 116406, 116407, 116408, 116409, 116411, 116412, 116413, 116415,116440,116441,116482,116484,116486,116489,116502,116504, -1};
//116365, 116466 are empty (should be Si run) , 116370,116442,116414 (116262 this one was 'bad')
Int_t runlist_sinat[] = {116330, 116331, 116332, 116333, 116335, 116337, 116339, 116341, 116342, 116343, 116344, 116345, 116346, 116347, 116348, 116349, 116350, 116351, 116352, 116353, 116354, 116355, 116356, 116357,116511 ,116512 ,116513 ,116514 ,116517 ,116518 ,116523 ,116524 ,116525 ,116526 ,116527 ,116528 ,116532 ,116533 ,116534 ,116535 ,116536 ,116537 ,116538 ,116539 ,116540 ,116541 ,116542 ,116543 ,116544 ,116545 ,116546 ,-1};
//bad 116529, 116530,116531
Int_t runlist_sinat_good[] = { 116549 ,116551 ,116552 ,116553 ,116554 ,116555 ,116556 ,116557 ,116558 ,116559 ,116560 ,116561 ,116562,116563,116564,116565,116566, -1 };
TTOFSort *a = new TTOFSort();
a->AddDetector(kC6D6, 4);
//a->SetNewBinParsA(kC6D6, 0.0, 6500, 6500000.0);
a->SetNewBinParsT(kC6D6, -10.0, 2.0, 1e3, 5000, 1e9); //Double the nbins (10k here becomes 20k bpd spec)
a->PrintSettings();
a->SetNewFixedDeadtime(kC6D6, 30.0);//fixed deadtime of 30 ns
a->SetNewCoincidencetime(kC6D6, 30.0);//Coincidences between 30 ns
a->SetNewVariableNames_amplitude(kC6D6, "amp");
a->SetNewBinParsA(kC6D6, 0.0, 6500, 70000);
a->SetNewCutsAmp_all(kC6D6, 600, 50000);
a->UseCalibration(kC6D6, a2e_c6d61, a2e_c6d62, a2e_c6d63, a2e_c6d64);
a->SetNewCutsEg(kC6D6, 0.200, 8.0, 0.200, 8.0, 0.200, 8.0, 0.200, 8.0);
a->SetPriorCut(kC6D6, "PulseIntensity<1e7");
//a->ProcessListOfRuns_Sum(prefix, runlist_co, suffix, "Sum_Cal.root", "Co", "RECREATE");
//a->ProcessListOfRuns_Sum(prefix, runlist_bi, suffix, "Sum_Cal.root", "Bi", "UPDATE");
//a->ProcessListOfRuns_Sum(prefix, runlist_ba, suffix, "Sum_Cal.root", "Ba", "UPDATE");
//a->ProcessListOfRuns_Sum(prefix, runlist_mn, suffix, "Sum_Cal.root", "Mn", "UPDATE");
//a->ProcessListOfRuns_Sum(prefix, runlist_cs, suffix, "Sum_Cal.root", "Cs", "UPDATE");
//a->ProcessListOfRuns_Sum(prefix, runlist_y, suffix, "Sum_Cal.root", "Y", "UPDATE");
//a->ProcessListOfRuns_Sum(prefix, runlist_ambe, suffix, "Sum_Cal.root", "Ambe", "UPDATE");
//a->ProcessListOfRuns_Sum(prefix, runlist_cmc, suffix, "Sum_Cal.root", "Cmc", "UPDATE");
//a->ProcessListOfRuns_Sum(prefix, runlist_amb, suffix, "Sum_Amb.root", "Amb", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_co, suffix, "Co.root", "Co", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_bi, suffix, "Bi.root", "Bi", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_ba, suffix, "Ba.root", "Ba", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_mn, suffix, "Mn.root", "Mn", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_cs, suffix, "Cs.root", "Cs", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_y, suffix, "Y.root", "Y", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_ambe, suffix, "Ambe.root", "Ambe", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_cmc, suffix, "Cmc.root", "Cmc", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_amb, suffix, "Amb.root", "Amb", "RECREATE");
// dedicated >5E12, parasitic 1-5 E12
//a->SetPriorCut(kC6D6, "PulseIntensity>1e12");
a->AddDetector(kSILI, 4);
//a->SetNewBinParsA(kSILI, 0.0, 1e4, 1e5);
a->SetNewVariableNames_amplitude(kSILI, "amp");
//a->SetPriorCut(kSILI, "PulseIntensity>1e12");
a->SetNewBinParsA(kSILI, 0.0, 6500, 70000);
a->SetNewCutsAmp_all(kSILI, 8000, 40000);
a->SetNewCutsTime_all(kSILI, 1E4, 1E9);
a->AddDetector(kPKUP, 1);
a->SetNewVariableNames_amplitude(kPKUP, "amp");
a->SetPriorCut(kPKUP,"amp>5000 && amp<50000");
a->SetNewBinParsA(kPKUP,0.0,6500,70000);
//a->SetPriorCut(kPKUP, "PulseIntensity>1e12");
//a->UseWeightingFunction(kC6D6, wf, wf, wf, wf);
a->SetPriorCut(kC6D6, "PulseIntensity>1e+12");
a->SetPriorCut(kPKUP, "PulseIntensity>1e+12");
a->SetPriorCut(kSILI, "PulseIntensity>1e+12");
//For dedicated pulse
a->SetPriorCut(kC6D6, "PulseIntensity>5e+12");
a->SetPriorCut(kSILI, "PulseIntensity>5e+12");
a->SetPriorCut(kPKUP, "PulseIntensity>5e+12");
a->ProcessListOfRuns_Sum(prefix, runlist_30si, suffix, "Dedicated_Sum_Beam.root", "Si", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_au20mm, suffix, "Dedicated_Sum_Beam.root", "Au20", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_au22mm, suffix, "Dedicated_Sum_Beam.root", "Au22", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_dummy, suffix, "Dedicated_Sum_Beam.root", "Dummy", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_cnat, suffix, "Dedicated_Sum_Beam.root", "C", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_empty, suffix, "Dedicated_Sum_Beam.root", "E", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_sinat, suffix, "Dedicated_Sum_Beam.root", "Sinat", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_sinat_good, suffix, "Dedicated_Sum_Beam.root", "Sinatgood", "UPDATE");
//For parastic pulse
a->SetPriorCut(kC6D6, "PulseIntensity>1e+12 && PulseIntensity<5e+12");
a->SetPriorCut(kSILI, "PulseIntensity>1e+12 && PulseIntensity<5e+12");
a->SetPriorCut(kPKUP, "PulseIntensity>1e+12 && PulseIntensity<5e+12");
a->ProcessListOfRuns_Sum(prefix, runlist_30si, suffix, "Parasitic_Sum_Beam.root", "Si", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_au20mm, suffix, "Parasitic_Sum_Beam.root", "Au20", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_au22mm, suffix, "Parasitic_Sum_Beam.root", "Au22", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_dummy, suffix, "Parasitic_Sum_Beam.root", "Dummy", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_cnat, suffix, "Parasitic_Sum_Beam.root", "C", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_empty, suffix, "Parasitic_Sum_Beam.root", "E", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_sinat, suffix, "Parasitic_Sum_Beam.root", "Sinat", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_sinat_good, suffix, "Parasitic_Beam.root", "Sinatgood", "UPDATE");
//For total pulse
a->ProcessListOfRuns_Sum(prefix, runlist_30si, suffix, "Sum_Beam.root", "Si", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_au20mm, suffix, "Sum_Beam.root", "Au20", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_au22mm, suffix, "Sum_Beam.root", "Au22", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_dummy, suffix, "Sum_Beam.root", "Dummy", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_cnat, suffix, "Sum_Beam.root", "C", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_empty, suffix, "Sum_Beam.root", "E", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_sinat, suffix, "Sum_Beam.root", "Sinat", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_sinat_good, suffix, "Beam.root", "Sinatgood", "UPDATE");
a->ProcessListOfRuns_Single(prefix, runlist_30si, suffix, "Single_30Si.root", "Si", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_au20mm, suffix, "Single_Au20.root", "Au20", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_au22mm, suffix, "Single_Au22.root", "Au22", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_dummy, suffix, "Single_Dummy.root", "Dummy", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_cnat, suffix, "Single_C.root", "C", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_empty, suffix, "Single_E.root", "E", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_sinat, suffix, "Single_Sinat.root", "Sinat", "RECREATE");
a->ProcessListOfRuns_Single(prefix, runlist_sinat_good, suffix, "Single_Sinatgood.root", "Sinatgood", "RECREATE");
/*
a->SetPriorCut(kC6D6, "PulseIntensity>1e12");
a->SetPriorCut(kC6D6, "tflash>10000");
a->SetTgWindow(kC6D6,10000,15000);
a->SetNewCutsAmp_all(kC6D6, 1800, 50000);
a->ProcessListOfRuns_Sum(prefix, runlist_30si, suffix, "Sum_30Si_hithresh.root", "Si", "RECREATE");
*/
return 0;
}
|
| Attachment 2: Process_Si_EAR2.C
|
/// 23.6.23, 9:30 edit CLW - process also other runlists
// g++ -Wall -O3 -g `root-config --cflags --ldflags --glibs` Process_Si_EAR2.C -o Process_Si_EAR2 && ./Process_Si_EAR2
// includes header, and source only in compiled script
#include "/afs/cern.ch/work/r/rmucciol/public/TTOFSort/TTOFSort_nTOF.h"
#ifndef __CINT__
#include "/afs/cern.ch/work/r/rmucciol/public/TTOFSort/TTOFSort_nTOF.cxx"
#endif
// --------------------------------------------------------------------------
//
//
//
// --------------------------------------------------------------------------
Double_t a2e_c6d61(Double_t x) { // from amplitude (channel) to MeV
return (4.9826533509E-02 + 1.6440658945E-05 * x - 1.0434771608E-12 * x * x);
}
Double_t a2e_c6d62(Double_t x) { // from amplitude (channel) to MeV
return (3.4169825864E-02 + 1.4076790089E-05 * x - 7.9765434038E-13 * x * x);
}
Double_t a2e_c6d63(Double_t x) { // from amplitude (channel) to MeV
return (3.9177392253E-02 + 1.7015644773E-05 * x - 4.0083807516E-13 * x * x);
}
Double_t a2e_c6d64(Double_t x) { // from amplitude (channel) to MeV
return (4.1835244811E-02 + 1.0673010868E-05 * x - 5.3279014370E-14 * x * x);
}
Double_t wf(Double_t x) {
return (0.468282 + 36.0785 * x + 9.54532 * x * x + 0.202353 * x * x * x - 0.0352043 * x * x * x * x);
}
/*
First calibrations
Double_t a2e_sted1(Double_t x) {
return (6.25345e-02 + 3.04647e-03 * x);
}
Double_t a2e_sted2(Double_t x) {
return (6.41447e-02 + 3.62458e-03 * x);
}
Double_t a2e_sted3(Double_t x) {
return (4.83878e-02 + 3.19258e-03 * x);
}
Double_t a2e_sted4(Double_t x) {
return (5.72867e-02 + 3.85617e-03 * x);
}
Double_t a2e_sted5(Double_t x) {
return (4.61653e-02 + 3.09576e-03 * x);
}
Double_t a2e_sted6(Double_t x) {
return (6.01178e-02 + 3.25993e-03 * x);
}
Double_t a2e_sted7(Double_t x) {
return (5.37046e-02 + 3.19335e-03 * x);
}
Double_t a2e_sted8(Double_t x) {
return (5.37046e-02 + 3.19335e-03 * x);
}
*/
/*
Double_t a2e_sted1(Double_t x) {
return (6.88457E-02+ 3.07383E-03* x);
}
Double_t a2e_sted2(Double_t x) {
return (6.30046E-02+ 3.64816E-03* x);
}
Double_t a2e_sted3(Double_t x) {
return (6.16885E-02+ 3.21011E-03* x);
}
Double_t a2e_sted4(Double_t x) {
return (5.76290E-02+ 3.91348E-03* x);
}
Double_t a2e_sted5(Double_t x) {
return (5.48915E-02+ 3.12774E-03* x);
}
Double_t a2e_sted6(Double_t x) {
return (6.94109E-02+ 3.30446E-03* x);
}
Double_t a2e_sted7(Double_t x) {
return (7.06719E-02+ 3.18890E-03* x);
}
Double_t a2e_sted8(Double_t x) {
return (7.06719E-02 + 3.18890E-03 * x);
}
*/
/*
Double_t a2e_sted1(Double_t x) {
return (8.49569E-02+ 3.02467E-03* x+ 5.01828E-08*x*x);
}
Double_t a2e_sted2(Double_t x) {
return (6.63359E-02+ 3.62838E-03* x+ 6.36851E-09*x*x);
}
Double_t a2e_sted3(Double_t x) {
return (6.90246E-02+ 3.17091E-03* x+ 4.80934E-08*x*x);
}
Double_t a2e_sted4(Double_t x) {
return (5.83187E-02+ 3.93397E-03* x+ 1.38546E-08*x*x);
}
Double_t a2e_sted5(Double_t x) {
return (7.26372E-02+ 3.03107E-03* x+ 6.15236E-08*x*x);
}
Double_t a2e_sted6(Double_t x) {
return (6.63090E-02+ 3.34231E-03* x+ -4.15391E-08*x*x);
}
Double_t a2e_sted7(Double_t x) {
return (7.39348E-02+ 3.21695E-03* x+ -3.38091E-08*x*x);
}
Double_t a2e_sted8(Double_t x) {
return (7.39348E-02 + 3.21695E-03 * x + -3.38091E-08 * x * x);
}
*/
/*
Double_t a2e_sted1(Double_t x) {
return (6.12436E-02+ 2.99626E-03* x + 1.45286E-09* x * x);
}
Double_t a2e_sted2(Double_t x) {
return (3.54473E-02+ 3.66036E-03* x + -1.02808E-07* x * x);
}
Double_t a2e_sted3(Double_t x) {
return (5.41069E-02+ 3.10199E-03* x + 3.61722E-08* x * x);
}
Double_t a2e_sted4(Double_t x) {
return (5.82907E-02+ 3.73851E-03* x + 6.26526E-08* x * x);
}
Double_t a2e_sted5(Double_t x) {
return (5.99435E-02+ 2.93709E-03* x + 7.71012E-08* x * x);
}
Double_t a2e_sted6(Double_t x) {
return (6.55392E-02+ 3.18712E-03* x + 1.44503E-08* x * x);
}
Double_t a2e_sted7(Double_t x) {
return (5.01775E-02+ 3.15280E-03* x + -1.29076E-08* x * x);
}
Double_t a2e_sted8(Double_t x) {
return (7.39348E-02 + 3.21695E-03 * x + -3.38091E-08 * x * x);
}
*/
Double_t a2e_sted1(Double_t x) {
return (5.67257E-02+ 2.98739E-03* x + 5.53612E-09* x * x);
}
Double_t a2e_sted2(Double_t x) {
return (3.28429E-02+ 3.65244E-03* x + -1.00906E-07* x * x);
}
Double_t a2e_sted3(Double_t x) {
return (4.94516E-02+ 3.09050E-03* x + 4.55854E-08* x * x);
}
Double_t a2e_sted4(Double_t x) {
return (5.28963E-02+ 3.72607E-03* x + 8.07590E-08* x * x);
}
Double_t a2e_sted5(Double_t x) {
return (5.72747E-02+ 2.91606E-03* x + 9.73475E-08* x * x);
}
Double_t a2e_sted6(Double_t x) {
return (6.56951E-02+ 3.15511E-03* x + 3.41401E-08* x * x);
}
Double_t a2e_sted7(Double_t x) {
return (4.66976E-02+ 3.12827E-03* x + 7.80229E-09* x * x);
}
Double_t a2e_sted8(Double_t x) {
return (7.39348E-02 + 3.21695E-03 * x + -3.38091E-08 * x * x);
}
int main() {
Char_t prefix[] = "/eos/experiment/ntof/processing/official/done/run";
Char_t suffix[] = ".root";
Int_t runlist_cs[] = {216090, 216091, 216104, -1};
Int_t runlist_cmc[] = { 216162,216160,216164,216165,216166,216167,216168, -1 };
Int_t runlist_y[] = {216092, 216103, -1}; //Detector mounting changed between runs 216092 and 216103
Int_t runlist_ambe[] = {216099, 216100, 216101, 216137, 216138, 216139, -1};
Int_t runlist_au20mm[] = {216108, 216157, -1};
Int_t runlist_au22mm[] = {216109, 216158, -1};
Int_t runlist_dummy[] = {216105, 216106, 216107, 216110, 216111, 216112, 216113, 216114, 216115, 216116, 216117, 216118, 216119, 216120, 216121, 216122, -1};
Int_t runlist_30si[] = {216123, 216124, 216125, 216126, 216127, 216128, 216129, 216130, 216131, 216132, 216133, 216134, 216135, -1};
Int_t runlist_sinat[] = {216159, 216160,216161,216169,216170,216171,216172,216173, -1};
Int_t runlist_amb[] = { 216203,216206,216206,216209,216212,216220,216222,216223,216228,216250,216251,216252,216253,216254,216255,216261,216265,216269,216270,216286,216287,216288,216295,216296,216297,216301,216302,216303,216306,216307,-1 };
TTOFSort *a = new TTOFSort();
a->AddDetector(kC6D6, 2);
//a->SetNewBinParsA(kC6D6, 0.0, 6500, 6500000.0);
//a->SetNewBinParsT(kC6D6, -10.0, 2.0, 1e3, 5000, 1e9); //Double the nbins (10k here becomes 20k bpd spec)
a->AddDetector(kSTED, 8);
a->AddDetector(kSILI, 4);
a->AddDetector(kPKUP, 1);
a->PrintSettings();
a->SetNewFixedDeadtime(kSTED, 30.0);//fixed deadtime of 30 ns
a->SetNewCoincidencetime(kSTED, 30.0);//Coincidences between 30 ns
a->SetNewFixedDeadtime(kC6D6, 50.0);//fixed deadtime of 30 ns
a->SetNewCoincidencetime(kC6D6, 50.0);//Coincidences between 30 ns
//a->SetNewVariableNames_amplitude(kSILI, "amp");
a->SetNewVariableNames_amplitude(kC6D6, "amp");
a->SetNewVariableNames_amplitude(kSTED, "amp");
a->SetNewBinParsA(kC6D6, 0.0, 10000, 5000);
//a->SetNewBinParsA(kSILI, 0.0, 6500, 5000);
a->SetNewBinParsA(kSTED, 0.0, 10000, 5000);
//a->SetHandleTgamma(kC6D6, kUsePkup, 0.0);
a->SetPriorCut(kC6D6, "amp>50");
a->SetPriorCut(kSTED, "amp>50");
a->UseCalibration(kSTED, a2e_sted1, a2e_sted2, a2e_sted3, a2e_sted4, a2e_sted5, a2e_sted6, a2e_sted7, a2e_sted8);
//a->SetNewVariableNames_amplitude(kC6D6, "amp");
//a->SetNewBinParsA(kC6D6, 0.0, 6500, 70000);
//a->SetNewCutsAmp_all(kC6D6, 600, 50000);
//a->UseCalibration(kC6D6, a2e_c6d61, a2e_c6d62, a2e_c6d63, a2e_c6d64);
//a->SetNewCutsEg(kC6D6, 0.200, 8.0, 0.200, 8.0, 0.200, 8.0, 0.200, 8.0);
//a->SetPriorCut(kC6D6, "PulseIntensity>1e12");
//a->SetNewBinParsA(kSILI, 0.0, 1e4, 1e5);
//a->SetNewVariableNames_amplitude(kSILI, "amp");
//a->SetPriorCut(kSILI, "PulseIntensity>1e12");
//a->UseWeightingFunction(kC6D6, wf, wf, wf, wf);
a->SetPriorCut(kC6D6, "PulseIntensity<1e7");
a->ProcessListOfRuns_Sum(prefix, runlist_cs, suffix, "EAR2/Sum_Cal.root", "Cs", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_y, suffix, "EAR2/Sum_Cal.root", "Y", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_ambe, suffix, "EAR2/Sum_Cal.root", "AmBe", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_cmc, suffix, "EAR2/Sum_Cal.root", "CmC", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_amb, suffix, "EAR2/Sum_Amb.root", "Amb", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_ambe, suffix, "EAR2/Single_Cal.root", "Ambe", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_cs, suffix, "EAR2/Single_Cal.root", "Cs", "UPDATE");
//a->ProcessListOfRuns_Single(prefix, runlist_y, suffix, "EAR2/Single_Cal.root", "Y", "UPDATE");
//a->ProcessListOfRuns_Single(prefix, runlist_cmc, suffix, "EAR2/Single_Cal.root", "CmC", "UPDATE");
/*
//Deticated pulse
a->SetPriorCut(kC6D6, "PulseIntensity>5e+12");
a->SetPriorCut(kSILI, "PulseIntensity>5e+12");
a->SetPriorCut(kPKUP, "PulseIntensity>5e+12");
a->SetPriorCut(kSTED, "PulseIntensity>5e+12");
a->ProcessListOfRuns_Sum(prefix, runlist_30si, suffix, "EAR2/Dedicated_Sum_Beam.root", "Si", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_au20mm, suffix, "EAR2/Dedicated_Sum_Beam.root", "Au20", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_au22mm, suffix, "EAR2/Dedicated_Sum_Beam.root", "Au22", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_dummy, suffix, "EAR2/Dedicated_Sum_Beam.root", "Dummy", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_sinat, suffix, "EAR2/Dedicated_Sum_Beam.root", "Sinat", "UPDATE");
//parasitic pulse
a->SetPriorCut(kC6D6, "PulseIntensity>1e+12 && PulseIntensity<5e+12");
a->SetPriorCut(kSILI, "PulseIntensity>1e+12 && PulseIntensity<5e+12");
a->SetPriorCut(kPKUP, "PulseIntensity>1e+12 && PulseIntensity<5e+12");
a->SetPriorCut(kSTED, "PulseIntensity>1e+12 && PulseIntensity<5e+12");
a->ProcessListOfRuns_Sum(prefix, runlist_30si, suffix, "EAR2/Parasitic_Sum_Beam.root", "Si", "RECREATE");
a->ProcessListOfRuns_Sum(prefix, runlist_au20mm, suffix, "EAR2/Parasitic_Sum_Beam.root", "Au20", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_au22mm, suffix, "EAR2/Parasitic_Sum_Beam.root", "Au22", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_dummy, suffix, "EAR2/Parasitic_Sum_Beam.root", "Dummy", "UPDATE");
a->ProcessListOfRuns_Sum(prefix, runlist_sinat, suffix, "EAR2/Parasitic_Sum_Beam.root", "Sinat", "UPDATE");
*/
//a->SetPriorCut(kSILI, "PulseIntensity>1e+12");
//a->SetPriorCut(kPKUP, "PulseIntensity>1e+12");
//a->SetPriorCut(kSTED, "PulseIntensity>1e+12");
//a->SetPriorCut(kC6D6, "PulseIntensity>1e+12");
//a->ProcessListOfRuns_Sum(prefix, runlist_30si, suffix, "EAR2/Sum_Beam.root", "Si", "RECREATE");
//a->ProcessListOfRuns_Sum(prefix, runlist_au20mm, suffix, "EAR2/Sum_Beam.root", "Au20", "UPDATE");
//a->ProcessListOfRuns_Sum(prefix, runlist_au22mm, suffix, "EAR2/Sum_Beam.root", "Au22", "UPDATE");
//a->ProcessListOfRuns_Sum(prefix, runlist_dummy, suffix, "EAR2/Sum_Beam.root", "Dummy", "UPDATE");
//a->ProcessListOfRuns_Sum(prefix, runlist_sinat, suffix, "EAR2/Sum_Beam.root", "Sinat", "UPDATE");
//a->ProcessListOfRuns_Single(prefix, runlist_30si, suffix, "EAR2/Single_30Si.root", "Si", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_au20mm, suffix, "EAR2/Single_Au20.root", "Au20", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_au22mm, suffix, "EAR2/Single_Au22.root", "Au22", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_dummy, suffix, "EAR2/Single_Dummy.root", "Dummy", "RECREATE");
//a->ProcessListOfRuns_Single(prefix, runlist_sinat, suffix, "EAR2/Single_Sinat.root", "Sinat", "RECREATE");
return 0;
}
|
|
46
|
Tue Aug 29 10:32:35 2023 |
Michael Donnachie | EAR1 Parasitic vs Dedicated runs | Below are the histograms of parasitic vs dedicated runs for EAR1. Also included are histograms with ambient background removed which closes the gap between parasitic and dedicated histograms. This was preformed by scaling the ambient by counts by a multiplication of (dedicated or parasitic) bunch number/ambient bunch number. There are no legends but the dedicated counts are in black and parasitic counts in red. Only included are C6D6 1 detectors but the other three detectors were equivelant.
|
| Attachment 1: Au22_large_range_ambrem_A.pdf
|
|
| Attachment 2: Au22_large_range.pdf
|
|
| Attachment 3: Dummy_large_range.pdf
|
|
| Attachment 4: Si_large_range.pdf
|
|
| Attachment 5: Si_Resonance_ambrem_B.pdf
|
|
| Attachment 6: Dummy_large_range_ambrem.pdf
|
|
|