diff --git a/Toolkit.cpp b/Toolkit.cpp new file mode 100644 index 0000000..606ac4b --- /dev/null +++ b/Toolkit.cpp @@ -0,0 +1,2805 @@ +#include "Toolkit.h" + +#include "TRandom3.h" + +//-------------------------------------------------------------------------- +// ++++++++++++++++++++++ Additional functions used in URANOS ++++++++++++++ + + +//-------------------------------------------------------------------------- +// ++++++++++++++++++++++ Fit functions ++++++++++++++++++++++++++++++++++++ + + + +//Lorentzian Peak Function with offset and slope +Double_t lorentzianPeak(Double_t* x, Double_t* par) +{ + return (0.5*par[0]*par[1]/TMath::Pi()) / TMath::Max(1.e-10,(x[0]-par[2])*(x[0]-par[2])+ .25*par[1]*par[1]) +par[3]; +} + +Double_t gaussoffset(Double_t* x, Double_t* par) +{ + //two gaussians + return (par[0]*( TMath::Exp(-0.5*TMath::Power(((x[0]-par[1])/par[2]),2)) ) +par[3]); +} + +Double_t errf( Double_t *x, Double_t *par) +{ + return par[0]*TMath::Erf((x[0]-par[1])/TMath::Sqrt(2)/par[2])+ par[3]; +} + + +// configures the ROOT output for plots + +void rootlogon() +{ + bool largeStyle = false; + bool atlasStyle = true; + + bool tightMargins = false; + bool largeMargins = true; + + TStyle *plain = new TStyle("Plain", "Plain Style"); + plain->SetCanvasBorderMode(0); + plain->SetPadBorderMode(0); + plain->SetPadColor(0); + plain->SetCanvasColor(0); + plain->SetTitleColor(1); + //plain->SetTitleSize(0.001); + plain->SetStatColor(0); + plain->SetPalette(1) ; + plain->SetAxisColor(1, "X"); + + plain->SetGridWidth(0.1); + plain->SetGridColor(13); + plain->SetGridStyle(3); + + gROOT->SetStyle( "Plain" ); + + gStyle->SetPaperSize(20, 26);//A4 + gStyle->SetPalette(1) ; + + gStyle->SetLineWidth(1.); + //gStyle->SetHistLineWidth(0.5); + + //plain->SetTextSize(1.1); + plain->SetLineStyleString(2,"[12 12]"); + + plain->SetPadTickX(1); + plain->SetPadTickY(1); + + gStyle->SetLabelSize(0.025,"xy"); + gStyle->SetTitleSize(0.025,"xy"); + //gStyle->SetTitleOffset(1.,"x"); + //gStyle->SetTitleOffset(1.,"y"); + //gStyle->SetPadTopMargin(0.1); + //gStyle->SetPadRightMargin(0.1); + //gStyle->SetPadBottomMargin(0.16); + //gStyle->SetPadLeftMargin(0.12); + //gStyle->SetOptFit(0111); + gStyle->SetOptFit(0000); + + TGaxis::SetMaxDigits(3); + gStyle->SetOptStat(""); + //gStyle->SetOptStat(1111); + //gStyle->SetOptStat("e"); + + if (largeStyle) + { + //gStyle->SetLineWidth(3.8); + //gStyle->SetHistLineWidth(3.8); + gStyle->SetTextSize(2.); + + gStyle->SetLabelSize(0.04,"xy"); + gStyle->SetTitleSize(0.042,"xy"); + //gStyle->SetTitleOffset(1.4,"x"); + //gStyle->SetTitleOffset(1.4,"y"); + //gStyle->SetTitleOffset(1.7,"y"); + } + + // ATLAS Style + if (atlasStyle) + { + Int_t font=42; + Double_t tsize=0.025; + Double_t zsize=0.025; + plain->SetTextFont(font); + plain->SetTextSize(tsize); + plain->SetLabelFont(font,"x"); + plain->SetTitleFont(font,"x"); + plain->SetLabelFont(font,"y"); + plain->SetTitleFont(font,"y"); + plain->SetLabelFont(font,"z"); + plain->SetTitleFont(font,"z"); + plain->SetLabelSize(tsize,"x"); + plain->SetTitleSize(tsize,"x"); + plain->SetLabelSize(tsize,"y"); + plain->SetTitleSize(tsize,"y"); + plain->SetLabelSize(tsize,"z"); + plain->SetTitleSize(tsize,"z"); + + plain->SetLegendFont(font); + + //this is really a fucker + plain->SetFuncWidth(1.5); + + if(tightMargins) + { + plain->SetPaperSize(20,26); + plain->SetPadTopMargin(0.05); + plain->SetPadRightMargin(0.05); + plain->SetPadBottomMargin(0.13); + plain->SetPadLeftMargin(0.12); + } + else + { + plain->SetPaperSize(20,26); + plain->SetPadTopMargin(0.05); + plain->SetPadRightMargin(0.07); + plain->SetPadBottomMargin(0.10); + plain->SetPadLeftMargin(0.07); + } + if (largeMargins) + { + plain->SetPaperSize(20,26); + plain->SetPadTopMargin(0.06); + plain->SetPadRightMargin(0.11); + plain->SetPadBottomMargin(0.11); + plain->SetPadLeftMargin(0.11); + } + plain->SetOptTitle(0); + + Int_t icol=0; + plain->SetFrameBorderMode(icol); + plain->SetCanvasBorderMode(icol); + plain->SetPadBorderMode(icol); + plain->SetPadColor(icol); + plain->SetCanvasColor(icol); + plain->SetStatColor(icol); + } + plain->SetBarWidth(3); + + //plain->SetPadTopMargin(0.0); plain->SetPadRightMargin(0.0); plain->SetPadBottomMargin(0.0); plain->SetPadLeftMargin(0.00); +} + + + +//convert colors to RGB + vector getRGBfromHCL(double h, double c0, double l0) + { + vector rgbValues; + float r,g,b; + + float c = c0*l0; + float m = l0-c; + + float h0 = h/60.; + int h0i = floor(h0+0.5); + + float x; + + if (h0 < 2) x = c*(1-fabs(h0 - 1)); + else + { + if (h0 < 4) x = c*(1-fabs(h0-2 - 1)); + else x = c*(1-fabs(h0-4 - 1)); + } + + if (h0<1) + { + r = c; g = x; b = 0; + rgbValues.push_back(r+m); rgbValues.push_back(g+m); rgbValues.push_back(b+m); + return rgbValues; + } + if (h0<2) + { + r = x; g = c; b = 0; + rgbValues.push_back(r+m); rgbValues.push_back(g+m); rgbValues.push_back(b+m); + return rgbValues; + } + if (h0<3) + { + r = 0; g = c; b = x; + rgbValues.push_back(r+m); rgbValues.push_back(g+m); rgbValues.push_back(b+m); + return rgbValues; + } + if (h0<4) + { + r = 0; g = x; b = c; + rgbValues.push_back(r+m); rgbValues.push_back(g+m); rgbValues.push_back(b+m); + return rgbValues; + } + if (h0<5) + { + r = x; g = 0; b = c; + rgbValues.push_back(r+m); rgbValues.push_back(g+m); rgbValues.push_back(b+m); + return rgbValues; + } + if (h0<6) + { + r = c; g = 0; b = x; + rgbValues.push_back(r+m); rgbValues.push_back(g+m); rgbValues.push_back(b+m); + return rgbValues; + } + + rgbValues.push_back(0); rgbValues.push_back(0); rgbValues.push_back(0); + return rgbValues; + } + +// linear function used to generate color codes + float getLinearC(double factor, double cmin, double cmax) + { + return (cmax-(factor*(cmax-cmin))); + } + + // power function used to generate color codes + float getScaledColorValue(double factor, double pow, double cmin, double cmax) + { + return (cmax-(TMath::Power(factor,pow)*(cmax-cmin))); + } + + // set up a linear color table with a number of NCont colors and a number of NRGBs scaled color values in between + // the scale values are set by the a_i e (0,1) + // values of C and L, bothe e (0,1) are set to default values + // typically only the color h e (0,360) has to be varied +void set_plot_styleSingleGradient(float h, Double_t a0, Double_t a1, Double_t a2, Double_t a3, Double_t a4) +{ + const Int_t NRGBs = 5; + const Int_t NCont = 200; + + float cmin = 1; + float cmax = 0.3; + float lmax = 0.9; + float lmin = 0.3; + float pow = 1.5; + + vector stop0 = getRGBfromHCL(h,getScaledColorValue(a0,pow,cmin,cmax),getScaledColorValue(a0,pow,lmin,lmax)); + vector stop1 = getRGBfromHCL(h,getScaledColorValue(a1,pow,cmin,cmax),getScaledColorValue(a1,pow,lmin,lmax)); + vector stop2 = getRGBfromHCL(h,getScaledColorValue(a2,pow,cmin,cmax),getScaledColorValue(a2,pow,lmin,lmax)); + vector stop3 = getRGBfromHCL(h,getScaledColorValue(a3,pow,cmin,cmax),getScaledColorValue(a3,pow,lmin,lmax)); + vector stop4 = getRGBfromHCL(h,getScaledColorValue(a4,pow,cmin,cmax),getScaledColorValue(a4,pow,lmin,lmax)); + + Double_t stops[NRGBs] = { a0, a1, a2, a3, a4 }; + Double_t red[NRGBs] = { stop0.at(0), stop1.at(0), stop2.at(0), stop3.at(0), stop4.at(0) }; + Double_t green[NRGBs] = { stop0.at(1), stop1.at(1), stop2.at(1), stop3.at(1), stop4.at(1) }; + Double_t blue[NRGBs] = { stop0.at(2), stop1.at(2), stop2.at(2), stop3.at(2), stop4.at(2) }; + TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont); + gStyle->SetNumberContours(NCont); +} + + // set up a two-color table with a number of NCont colors and a number of NRGBs scaled color values in between + // the scale values are set by the a_i e (0,1) + // values of C and L, bothe e (0,1) are set to default values + // typically only the colors h1 and h2 e (0,360) have to be varied +void set_plot_styleHeatGradient(Double_t a0, Double_t a1, Double_t a2, Double_t a3, Double_t a4) +{ + const Int_t NRGBs = 5; + const Int_t NCont = 200; + + float cmin = 1; + float cmax = 0.6; + float lmax = 0.9; + float lmin = 0.5; + float pow1 = 0.4; + float pow2 = 2.2; + float h1 = 00; + float h2 = 60; + + vector stop0 = getRGBfromHCL(getLinearC(a0,h1,h2),getScaledColorValue(a0,pow1,cmin,cmax),getScaledColorValue(a0,pow2,lmin,lmax)); + vector stop1 = getRGBfromHCL(getLinearC(a1,h1,h2),getScaledColorValue(a1,pow1,cmin,cmax),getScaledColorValue(a1,pow2,lmin,lmax)); + vector stop2 = getRGBfromHCL(getLinearC(a2,h1,h2),getScaledColorValue(a2,pow1,cmin,cmax),getScaledColorValue(a2,pow2,lmin,lmax)); + vector stop3 = getRGBfromHCL(getLinearC(a3,h1,h2),getScaledColorValue(a3,pow1,cmin,cmax),getScaledColorValue(a3,pow2,lmin,lmax)); + vector stop4 = getRGBfromHCL(getLinearC(a4,h1,h2),getScaledColorValue(a4,pow1,cmin,cmax),getScaledColorValue(a4,pow2,lmin,lmax)); + + Double_t stops[NRGBs] = { a0, a1, a2, a3, a4 }; + Double_t red[NRGBs] = { stop0.at(0), stop1.at(0), stop2.at(0), stop3.at(0), stop4.at(0) }; + Double_t green[NRGBs] = { stop0.at(1), stop1.at(1), stop2.at(1), stop3.at(1), stop4.at(1) }; + Double_t blue[NRGBs] = { stop0.at(2), stop1.at(2), stop2.at(2), stop3.at(2), stop4.at(2) }; + TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont); + gStyle->SetNumberContours(NCont); +} + +// different gradient, see definition 'set_plot_styleHeatGradient' +void set_plot_styleHeatGradient2(Double_t a0, Double_t a1, Double_t a2, Double_t a3, Double_t a4) +{ + const Int_t NRGBs = 5; + const Int_t NCont = 200; + + float cmin = 1; + float cmax = 0.6; + float lmax = 0.9; + float lmin = 0.5; + float pow1 = 0.4; + float pow2 = 2.2; + float h1 = 00; + float h2 = 60; + + vector stop0 = getRGBfromHCL(getLinearC(a0,h1,h2),getScaledColorValue(a0,pow1,cmin,cmax),getScaledColorValue(a0,pow2,lmin,lmax)); + vector stop1 = getRGBfromHCL(getLinearC(a1,h1,h2),getScaledColorValue(a1,pow1,cmin,cmax),getScaledColorValue(a1,pow2,lmin,lmax)); + vector stop2 = getRGBfromHCL(getLinearC(a2,h1,h2),getScaledColorValue(a2,pow1,cmin,cmax),getScaledColorValue(a2,pow2,lmin,lmax)); + vector stop3 = getRGBfromHCL(getLinearC(a3,h1,h2),getScaledColorValue(a3,pow1,cmin,cmax),getScaledColorValue(a3,pow2,lmin,lmax)); + vector stop4 = getRGBfromHCL(getLinearC(a4,h1,h2),getScaledColorValue(a4,pow1,cmin,cmax),getScaledColorValue(a4,pow2,lmin,lmax)); + + Double_t stops[NRGBs] = { a0, a1, a2, a3, a4 }; + Double_t red[NRGBs] = { stop4.at(0), stop3.at(0), stop2.at(0), stop1.at(0), stop0.at(0) }; + Double_t green[NRGBs] = { stop4.at(1), stop3.at(1), stop2.at(1), stop1.at(1), stop0.at(1) }; + Double_t blue[NRGBs] = { stop4.at(2), stop3.at(2), stop2.at(2), stop1.at(2), stop0.at(2) }; + TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont); + gStyle->SetNumberContours(NCont); +} + +// different gradient, see definition 'set_plot_styleHeatGradient' +void set_plot_styleHeatGradientModified(Double_t a0, Double_t a1, Double_t a2, Double_t a3, Double_t a4) +{ + //a0 = 2*a0; a1 = 2*a1;a2 = 2*a2; + const Int_t NRGBs = 5; + const Int_t NCont = 200; + + float cmin = 1; + float cmax = 0.7; + float lmax = 0.95; + float lmin = 0.5; + float pow1 = 0.8; + float pow2 = 2.6; + float h1 = 05; + float h2 = 60; + + vector stop0 = getRGBfromHCL(getLinearC(a0,h1,h2),getScaledColorValue(a0,pow1,cmin,cmax),getScaledColorValue(a0,pow2,lmin,lmax)); + vector stop1 = getRGBfromHCL(getLinearC(a1,h1,h2),getScaledColorValue(a1,pow1,cmin,cmax),getScaledColorValue(a1,pow2,lmin,lmax)); + vector stop2 = getRGBfromHCL(getLinearC(a2,h1,h2),getScaledColorValue(a2,pow1,cmin,cmax),getScaledColorValue(a2,pow2,lmin,lmax)); + vector stop3 = getRGBfromHCL(getLinearC(a3,h1,h2),getScaledColorValue(a3,pow1,cmin,cmax),getScaledColorValue(a3,pow2,lmin,lmax)); + vector stop4 = getRGBfromHCL(getLinearC(a4,h1,h2),getScaledColorValue(a4,pow1,cmin,cmax),getScaledColorValue(a4,pow2,lmin,lmax)); + + Double_t stops[NRGBs] = { a0, a1, a2, a3, a4 }; + Double_t red[NRGBs] = { stop4.at(0), stop2.at(0), stop0.at(0), stop2.at(0), stop4.at(0) }; + Double_t green[NRGBs] = { stop4.at(1), stop2.at(1), stop0.at(1), stop2.at(1), stop4.at(1) }; + Double_t blue[NRGBs] = { stop4.at(2), stop2.at(2), stop0.at(2), stop2.at(2), stop4.at(2) }; + TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont); + gStyle->SetNumberContours(NCont); +} + +// different gradient, see definition 'set_plot_styleHeatGradient' +void set_plot_styleRainbowGradient(Double_t a0, Double_t a1, Double_t a2, Double_t a3, Double_t a4) +{ + const Int_t NRGBs = 9; + const Int_t NCont = 200; + + float cmin = 0.91; + float cmax = 0.9; + float lmax = 0.95; + float lmin = 0.85; + float pow1 = 0.4; //pow1 = 1.5; + float pow2 = 2.2; //pow2 = 1.5; + float h1 = 0; + float h2 = 250; + + Double_t a01 = (a0+a1)/2.; Double_t a12 = (a1+a2)/2.; Double_t a23 = (a2+a3)/2.; Double_t a34 = (a3+a4)/2.; + + vector stop0 = getRGBfromHCL(getLinearC(a0,h1,h2),getScaledColorValue(a0,pow1,cmin,cmax),getScaledColorValue(a0,pow2,lmin,lmax)); + vector stop01 = getRGBfromHCL(getLinearC(a01,h1,h2),getScaledColorValue(a01,pow1,cmin,cmax),getScaledColorValue(a01,pow2,lmin,lmax)); + vector stop1 = getRGBfromHCL(getLinearC(a1,h1,h2),getScaledColorValue(a1,pow1,cmin,cmax),getScaledColorValue(a1,pow2,lmin,lmax)); + vector stop12 = getRGBfromHCL(getLinearC(a12,h1,h2),getScaledColorValue(a12,pow1,cmin,cmax),getScaledColorValue(a12,pow2,lmin,lmax)); + vector stop2 = getRGBfromHCL(getLinearC(a2,h1,h2),getScaledColorValue(a2,pow1,cmin,cmax),getScaledColorValue(a2,pow2,lmin,lmax)); + vector stop23 = getRGBfromHCL(getLinearC(a23,h1,h2),getScaledColorValue(a23,pow1,cmin,cmax),getScaledColorValue(a23,pow2,lmin,lmax)); + vector stop3 = getRGBfromHCL(getLinearC(a3,h1,h2),getScaledColorValue(a3,pow1,cmin,cmax),getScaledColorValue(a3,pow2,lmin,lmax)); + vector stop34 = getRGBfromHCL(getLinearC(a34,h1,h2),getScaledColorValue(a34,pow1,cmin,cmax),getScaledColorValue(a34,pow2,lmin,lmax)); + vector stop4 = getRGBfromHCL(getLinearC(a4,h1,h2),getScaledColorValue(a4,pow1,cmin,cmax),getScaledColorValue(a4,pow2,lmin,lmax)); + + Double_t stops[NRGBs] = { a0, a01, a1, a12, a2, a23, a3, a34, a4 }; + Double_t red[NRGBs] = { stop0.at(0), stop01.at(0), stop1.at(0), stop12.at(0), stop2.at(0), stop23.at(0), stop3.at(0), stop34.at(0), stop4.at(0) }; + Double_t green[NRGBs] = { stop0.at(1), stop01.at(1), stop1.at(1), stop12.at(1), stop2.at(1), stop23.at(1), stop3.at(1), stop34.at(1), stop4.at(1) }; + Double_t blue[NRGBs] = { stop0.at(2), stop01.at(2), stop1.at(2), stop12.at(2), stop2.at(2), stop23.at(2), stop3.at(2), stop34.at(2), stop4.at(2) }; + TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont); + gStyle->SetNumberContours(NCont); +} + +// different gradient, see definition 'set_plot_styleHeatGradient' +void set_plot_styleAllGradient(Double_t a0, Double_t a1, Double_t a2, Double_t a3, Double_t a4) +{ + const Int_t NRGBs = 9; + const Int_t NCont = 200; + + float cmin = 0.991; + float cmax = 0.8; + float lmax = 0.95; + float lmin = 0.9; + float pow1 = 1.5; //pow1 = 1.5; + float pow2 = 1.5; //pow2 = 1.5; + float h1 = 0; + float h2 = 359; + + Double_t a01 = (a0+a1)/2.; Double_t a12 = (a1+a2)/2.; Double_t a23 = (a2+a3)/2.; Double_t a34 = (a3+a4)/2.; + + vector stop0 = getRGBfromHCL(getLinearC(a0,h1,h2),getScaledColorValue(a0,pow1,cmin,cmax),getScaledColorValue(a0,pow2,lmin,lmax)); + vector stop01 = getRGBfromHCL(getLinearC(a01,h1,h2),getScaledColorValue(a01,pow1,cmin,cmax),getScaledColorValue(a01,pow2,lmin,lmax)); + vector stop1 = getRGBfromHCL(getLinearC(a1,h1,h2),getScaledColorValue(a1,pow1,cmin,cmax),getScaledColorValue(a1,pow2,lmin,lmax)); + vector stop12 = getRGBfromHCL(getLinearC(a12,h1,h2),getScaledColorValue(a12,pow1,cmin,cmax),getScaledColorValue(a12,pow2,lmin,lmax)); + vector stop2 = getRGBfromHCL(getLinearC(a2,h1,h2),getScaledColorValue(a2,pow1,cmin,cmax),getScaledColorValue(a2,pow2,lmin,lmax)); + vector stop23 = getRGBfromHCL(getLinearC(a23,h1,h2),getScaledColorValue(a23,pow1,cmin,cmax),getScaledColorValue(a23,pow2,lmin,lmax)); + vector stop3 = getRGBfromHCL(getLinearC(a3,h1,h2),getScaledColorValue(a3,pow1,cmin,cmax),getScaledColorValue(a3,pow2,lmin,lmax)); + vector stop34 = getRGBfromHCL(getLinearC(a34,h1,h2),getScaledColorValue(a34,pow1,cmin,cmax),getScaledColorValue(a34,pow2,lmin,lmax)); + vector stop4 = getRGBfromHCL(getLinearC(a4,h1,h2),getScaledColorValue(a4,pow1,cmin,cmax),getScaledColorValue(a4,pow2,lmin,lmax)); + + Double_t stops[NRGBs] = { a0, a01, a1, a12, a2, a23, a3, a34, a4 }; + Double_t red[NRGBs] = { stop0.at(0), stop01.at(0), stop1.at(0), stop12.at(0), stop2.at(0), stop23.at(0), stop3.at(0), stop34.at(0), stop4.at(0) }; + Double_t green[NRGBs] = { stop0.at(1), stop01.at(1), stop1.at(1), stop12.at(1), stop2.at(1), stop23.at(1), stop3.at(1), stop34.at(1), stop4.at(1) }; + Double_t blue[NRGBs] = { stop0.at(2), stop01.at(2), stop1.at(2), stop12.at(2), stop2.at(2), stop23.at(2), stop3.at(2), stop34.at(2), stop4.at(2) }; + TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont); + gStyle->SetNumberContours(NCont); +} + + +//formats the colorbar to a non-inhumanic scheme +void set_plot_style(Double_t a0, Double_t a1, Double_t a2, Double_t a3, Double_t a4) +{ + const Int_t NRGBs = 5; + const Int_t NCont = 200; + + Double_t stops[NRGBs] = { a0, a1, a2, a3, a4 }; + Double_t red[NRGBs] = { 0.00, 0.00, 0.87, 1.00, 0.51 }; + Double_t green[NRGBs] = { 0.00, 0.81, 1.00, 0.20, 0.00 }; + Double_t blue[NRGBs] = { 0.51, 1.00, 0.12, 0.00, 0.00 }; + TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont); + gStyle->SetNumberContours(NCont); +} + + +// different gradient, see definition 'set_plot_styleHeatGradient' +void set_plot_styleCool() +{ + float a0 = 0, a1 = 0.56, a2= 0.56, a3 = 0.56, a4 = 1; + const Int_t NRGBs = 5; + const Int_t NCont = 200; + + float cmin = 1; + float cmax = 0.3; + float lmax = 0.99; + float lmin = 0.6; + float pow1 = 0.4; + float pow2 = 2.2; + float h1 = 230; + float h2 = 360; + + vector stop0 = getRGBfromHCL(getLinearC(a0,h1,h2),getScaledColorValue(a0,pow1,cmin,cmax),getScaledColorValue(a0,pow2,lmin,lmax)); + vector stop1 = getRGBfromHCL(getLinearC(a1,h1,h2),getScaledColorValue(a1,pow1,cmin,cmax),getScaledColorValue(a1,pow2,lmin,lmax)); + vector stop2 = getRGBfromHCL(getLinearC(a2,h1,h2),getScaledColorValue(a2,pow1,cmin,cmax),getScaledColorValue(a2,pow2,lmin,lmax)); + vector stop3 = getRGBfromHCL(getLinearC(a3,h1,h2),getScaledColorValue(a3,pow1,cmin,cmax),getScaledColorValue(a3,pow2,lmin,lmax)); + vector stop4 = getRGBfromHCL(getLinearC(a4,h1,h2),getScaledColorValue(a4,pow1,cmin,cmax),getScaledColorValue(a4,pow2,lmin,lmax)); + + Double_t stops[NRGBs] = { a0, a1, a2, a3, a4 }; + Double_t red[NRGBs] = { stop0.at(0), stop1.at(0), stop2.at(0), stop3.at(0), stop4.at(0) }; + Double_t green[NRGBs] = { stop0.at(1), stop1.at(1), stop2.at(1), stop3.at(1), stop4.at(1) }; + Double_t blue[NRGBs] = { stop0.at(2), stop1.at(2), stop2.at(2), stop3.at(2), stop4.at(2) }; + TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont); + gStyle->SetNumberContours(NCont); +} + +// modes 0: no luminance scaling, 1: dark at max scale 2: dark at min scale +int getScaledColor(float min, float max, float scale, int mode) +{ + vector rgbValues; + if (mode==0) rgbValues = getRGBfromHCL(getLinearC(scale,min,max),getScaledColorValue(scale,0.4,0.91,0.9),getScaledColorValue(scale,2.2,0.8,0.9)); + else if (mode==1) rgbValues = getRGBfromHCL(getLinearC(scale,min,max),getScaledColorValue(scale,0.2,0.99,0.5),getScaledColorValue(scale,1.5,0.1,0.99)); + else rgbValues = getRGBfromHCL(getLinearC(scale,min,max),getScaledColorValue(scale,0.2,0.99,0.1),getScaledColorValue(scale,0.9,0.99,0.2)); + + return TColor::GetColor(rgbValues.at(0),rgbValues.at(1),rgbValues.at(2)); +} + +// modes 0: no luminance scaling, 1: dark at max scale 2: dark at min scale +vector getScaledColorRGB(float min, float max, float scale, int mode) +{ + vector rgbValues; + if (mode==0) rgbValues = getRGBfromHCL(getLinearC(scale,min,max),getScaledColorValue(scale,0.4,0.91,0.9),getScaledColorValue(scale,2.2,0.8,0.9)); + else if (mode==1) rgbValues = getRGBfromHCL(getLinearC(scale,min,max),getScaledColorValue(scale,0.2,0.99,0.5),getScaledColorValue(scale,1.5,0.1,0.99)); + else rgbValues = getRGBfromHCL(getLinearC(scale,min,max),getScaledColorValue(scale,0.2,0.99,0.1),getScaledColorValue(scale,0.9,0.99,0.2)); + + return rgbValues; +} + + +// fashions up the canvas +void CanvasFashion(TCanvas* c) +{ + c->SetBorderMode(0); + c->SetFillColor(0); +} + +// fashions up TGraphs +// set axis labels and label plot size to large or small using 'setSize' +void TGraphFashion(TGraph* graph, TString xLabel, TString yLabel, Bool_t setSize) +{ + graph->SetFillColor(19); + graph->SetMarkerStyle(21); + graph->SetMarkerSize(1); + graph->GetXaxis()->SetTitle(xLabel); + graph->GetYaxis()->SetTitle(yLabel); + graph->GetXaxis()->SetNoExponent(kTRUE); + graph->GetYaxis()->SetNoExponent(kTRUE); + if (setSize) + { + graph->GetXaxis()->SetLabelSize(0.027); + graph->GetXaxis()->SetTitleSize(0.03); + graph->GetYaxis()->SetLabelSize(0.027); + graph->GetYaxis()->SetTitleSize(0.03); + } +} + +// fashions up TGraphErrors +// set axis labels and label plot size to large or small using 'setSize' +void TGraphErrorFashion(TGraphErrors* graph, TString xLabel, TString yLabel, Bool_t setSize) +{ + graph->SetFillColor(19); + graph->SetMarkerStyle(21); + graph->SetMarkerSize(1.0); + graph->GetXaxis()->SetTitle(xLabel); + graph->GetYaxis()->SetTitle(yLabel); + graph->GetXaxis()->SetNoExponent(kTRUE); + graph->GetYaxis()->SetNoExponent(kTRUE); + if (setSize) + { + graph->GetXaxis()->SetLabelSize(0.04); + graph->GetXaxis()->SetTitleSize(0.03); + graph->GetYaxis()->SetLabelSize(0.04); + graph->GetYaxis()->SetTitleSize(0.03); + } +} + +// fashions up TGraph2Ds +// set axis labels and label plot size to large or small using 'setSize' +void TGraph2DFashion(TGraph2D* graph, TString xLabel, TString yLabel, TString zLabel, Bool_t setSize) +{ + graph->SetFillColor(19); + graph->SetMarkerStyle(21); + graph->SetMarkerSize(1); + graph->GetXaxis()->SetTitle(xLabel); + graph->GetYaxis()->SetTitle(yLabel); + graph->GetZaxis()->SetTitle(zLabel); + graph->GetXaxis()->SetNoExponent(kTRUE); + graph->GetZaxis()->SetNoExponent(kTRUE); + graph->GetYaxis()->SetNoExponent(kTRUE); + if (setSize) + { + graph->GetXaxis()->SetLabelSize(0.027); + graph->GetXaxis()->SetTitleSize(0.03); + graph->GetYaxis()->SetLabelSize(0.027); + graph->GetYaxis()->SetTitleSize(0.03); + graph->GetZaxis()->SetLabelSize(0.027); + graph->GetZaxis()->SetTitleSize(0.03); + } +} + +// fashions up TMultiGraphs +// set axis labels and label plot size to large or small using 'setSize' +void TMultiGraphFashion(TMultiGraph* graph, TString xLabel, TString yLabel, Bool_t setSize) +{ + graph->GetXaxis()->SetTitle(xLabel); + graph->GetYaxis()->SetTitle(yLabel); + graph->GetXaxis()->SetNoExponent(kTRUE); + graph->GetYaxis()->SetNoExponent(kTRUE); + if (setSize) + { + graph->GetXaxis()->SetLabelSize(0.027); + graph->GetXaxis()->SetTitleSize(0.03); + graph->GetYaxis()->SetLabelSize(0.027); + graph->GetYaxis()->SetTitleSize(0.03); + } +} + +// fashions up TF1 functions +// set axis labels and label plot size to large or small using 'setSize' +void TF1Fashion(TF1* hist, TString xLabel, TString yLabel, Bool_t setSize) +{ + if (setSize) + { + hist->GetXaxis()->SetLabelSize(0.027); + hist->GetXaxis()->SetTitleSize(0.03); + hist->GetYaxis()->SetLabelSize(0.027); + hist->GetYaxis()->SetTitleSize(0.03); + } + hist->GetYaxis()->SetTitle(xLabel); + hist->GetXaxis()->SetTitle(yLabel); + hist->GetXaxis()->SetNoExponent(kTRUE); + hist->GetYaxis()->SetNoExponent(kTRUE); + //hist->SetBarOffset(-0.30); + //hist->SetBarWidth(0.5); +} + +// fashions up TH1 histograms +// set axis labels and label plot size to large or small using 'setSize' +void TH1Fashion(TH1* hist, TString xLabel, TString yLabel, Bool_t setSize) +{ + if (setSize) + { + hist->GetXaxis()->SetLabelSize(0.027); + hist->GetXaxis()->SetTitleSize(0.03); + hist->GetYaxis()->SetLabelSize(0.027); + hist->GetYaxis()->SetTitleSize(0.03); + } + hist->GetYaxis()->SetTitle(xLabel); + hist->GetXaxis()->SetTitle(yLabel); + hist->GetXaxis()->SetNoExponent(kTRUE); + hist->GetYaxis()->SetNoExponent(kTRUE); + #ifdef ROOTOLDVERSION + hist->SetBarOffset(-0.30); + #endif + //hist->SetBarWidth(0.5); +} + +// fashions up TProfile histograms +// set axis labels and label plot size to large or small using 'setSize' +void TProfileFashion(TProfile* hist, TString xLabel, TString yLabel, Bool_t setSize) +{ + if (setSize) + { + hist->GetXaxis()->SetLabelSize(0.027); + hist->GetXaxis()->SetTitleSize(0.03); + hist->GetYaxis()->SetLabelSize(0.027); + hist->GetYaxis()->SetTitleSize(0.03); + } + hist->GetYaxis()->SetTitle(xLabel); + hist->GetXaxis()->SetTitle(yLabel); + hist->GetXaxis()->SetNoExponent(kTRUE); + hist->GetYaxis()->SetNoExponent(kTRUE); + #ifdef ROOTOLDVERSION + hist->SetBarOffset(-0.30); + #endif + //hist->SetBarWidth(0.5); +} + + +// fashions up TH2 histograms for the pixelwise plots +// set axis labels and label plot size to large or small using 'setSize' +void TH2Fashion(TH2* hist, Bool_t setSize) +{ + //hist->GetXaxis()->SetRange(0,255); + //hist->GetYaxis()->SetRange(0,255); + if (setSize) + { + hist->GetXaxis()->SetLabelSize(0.02); + hist->GetXaxis()->SetTitleSize(0.03); + hist->GetYaxis()->SetLabelSize(0.02); + hist->GetYaxis()->SetTitleSize(0.03); + hist->GetZaxis()->SetLabelSize(0.015); + } + if (setSize) + { + hist->GetXaxis()->SetLabelSize(0.035); + hist->GetXaxis()->SetTitleSize(0.037); + hist->GetYaxis()->SetLabelSize(0.035); + hist->GetYaxis()->SetTitleSize(0.037); + hist->GetYaxis()->SetTitleOffset(1.); + } + hist->GetXaxis()->SetTitle("Pixel"); + hist->GetYaxis()->SetTitle("Pixel"); + hist->GetXaxis()->SetNoExponent(kTRUE); + hist->GetYaxis()->SetNoExponent(kTRUE); + //gStyle->SetOptStat(0); +} + +// fashions up TH1 histograms +// set axis labels and label plot size to large or small using 'setSize' +void TH2Fashion(TH2* hist, TString xLabel, TString yLabel, Bool_t setSize) +{ + //hist->GetXaxis()->SetRange(0,255); + //hist->GetYaxis()->SetRange(0,255); + if (setSize) + { + hist->GetXaxis()->SetLabelSize(0.02); + hist->GetXaxis()->SetTitleSize(0.03); + hist->GetYaxis()->SetLabelSize(0.02); + hist->GetYaxis()->SetTitleSize(0.03); + hist->GetZaxis()->SetLabelSize(0.015); + } + else + { + hist->GetXaxis()->SetLabelSize(0.035); + hist->GetXaxis()->SetTitleSize(0.045); + hist->GetYaxis()->SetLabelSize(0.035); + hist->GetYaxis()->SetTitleSize(0.045); + hist->GetZaxis()->SetLabelSize(0.03); + } + if (false) + { + hist->GetXaxis()->SetLabelSize(0.035); + hist->GetXaxis()->SetTitleSize(0.037); + hist->GetYaxis()->SetLabelSize(0.035); + hist->GetYaxis()->SetTitleSize(0.037); + hist->GetYaxis()->SetTitleOffset(1.); + } + hist->GetXaxis()->SetTitle(xLabel); + hist->GetYaxis()->SetTitle(yLabel); + hist->GetXaxis()->SetNoExponent(kTRUE); + hist->GetYaxis()->SetNoExponent(kTRUE); + //gStyle->SetOptStat(0); +} + +// fashions up stacked histograms +// set axis labels and label plot size to large or small using 'setSize' +void THStackFashion(THStack* stack, TString xLabel, TString yLabel, Bool_t setSize) +{ + //hist->GetXaxis()->SetRange(0,255); + //hist->GetYaxis()->SetRange(0,255); + if (setSize) + { + stack->GetXaxis()->SetLabelSize(0.03);//originally "2" + stack->GetXaxis()->SetTitleSize(0.03); + stack->GetYaxis()->SetLabelSize(0.03);//originally "2" + stack->GetYaxis()->SetTitleSize(0.03); + } + else + { + stack->GetXaxis()->SetLabelSize(0.035); + stack->GetXaxis()->SetTitleSize(0.045); + stack->GetYaxis()->SetLabelSize(0.035); + stack->GetYaxis()->SetTitleSize(0.045); + } + stack->GetXaxis()->SetTitle(xLabel); + stack->GetYaxis()->SetTitle(yLabel); + stack->GetXaxis()->SetNoExponent(kTRUE); + stack->GetYaxis()->SetNoExponent(kTRUE); + //gStyle->SetOptStat(0); +} + + + +//-------------------------------------------------------------------------- +// ++++++++++++++++++++++ Output/Input +++++++++++++++++++++++++++++++++++++ + + +// plots a TMatrix with z values from zmin to zmax to the specified folder and filename +TH2F* printHisto(Double_t zmin, Double_t zmax, Int_t size, TMatrixF data, TString OutputFolder, TString dataname, Bool_t logPlot) +{ + //cout<<"Generating histograms"; + + Float_t pixel; + TH2F* pixelmatrix = new TH2F("p"+dataname, dataname ,size,0.,size-1,size,0.,size-1); + + for(Int_t l = 0; l < size; l++) + { + for(Int_t m = 0; m < size; m++) + { + pixel = data(l,m); + + pixelmatrix->Fill(l,m, pixel); + } + } + //cout<<"...done"<GetMean(1)<<"+/-"<GetMeanError(1)<<" y: "<GetMean(2)<<"+/-"<GetMeanError(2)<SetLogz(); + + TH2Fashion(pixelmatrix,1); + pixelmatrix->GetZaxis()->SetRangeUser(zmin,zmax); + + set_plot_style(0.00, 0.20, 0.50, 0.7, 1.00); + pixelmatrix->Draw("COLZ"); + + c->SaveAs(OutputFolder+"/"+dataname+".png"); + c->Print(OutputFolder+"/"+dataname+".root"); + + return pixelmatrix; +} + + +// plots a TH1 histogram with y values from zmin to zmax to the specified folder and filename +void printTH1F(Double_t zmin, Double_t zmax, TH1F* histo, TString OutputFolder, TString dataname) +{ + TString separator; + if (OutputFolder.Length() > 1) separator = "/"; + else separator = ""; + + TCanvas* c = new TCanvas("c"+dataname,dataname,1280,1280); + CanvasFashion(c); + + TH1Fashion(histo,"Bins","counts", 1); + if ((zmin*zmax)!=1) histo->GetYaxis()->SetRangeUser(zmin,zmax); + + histo->Draw(""); + + c->SaveAs(OutputFolder+separator+dataname+".png"); + // + histo->Print(OutputFolder+separator+dataname+".root"); +} + +// plots a TH2 histogram with z values from zmin to zmax to the specified folder and filename +void printTH2F(Double_t zmin, Double_t zmax, TH2F* histo, TString OutputFolder, TString dataname) +{ + TString separator; + if (OutputFolder.Length() > 1) separator = "/"; + else separator = ""; + + TCanvas* c = new TCanvas("c"+dataname,dataname,1280,1280); + CanvasFashion(c); + + //TH2Fashion(histo); + //if ((zmin!=0)&&(zmax!=0)) histo->GetZaxis()->SetRangeUser(zmin,zmax); + + if ((zmin!=0)&&(zmax!=0)) c->SetLogz(); + + set_plot_style(0.00, 0.20, 0.50, 0.7, 1.00); + histo->Draw("COLZ"); + + c->SaveAs(OutputFolder+separator+dataname+".png"); + histo->Print(OutputFolder+separator+dataname+".root"); +} + +// exports a TH2 histogram as a tab separated ASCII matrix +void storeTH2ToFile(TString OutputFolder, TString filename, TH2F* th2) +{ + ofstream *stream_out; + + TString separator; + if (OutputFolder.Length() > 1) separator = "/"; + else separator = ""; + + stream_out = new ofstream(OutputFolder+separator+filename,ofstream::out); + + Int_t nX = th2->GetNbinsX(); + Int_t nY = th2->GetNbinsY(); + + for(Int_t i = 0; i < nY; i++) + { + for(Int_t j = 0; j < nX; j++) + { + *stream_out<GetBinContent(j,i))<<"\t"; + } + *stream_out<close(); +} + +// exports an ASCII string to a file +void storeToFile(TString OutputFolder, TString filename, TString what_has_to_be_written, bool new_line) +{ + ofstream *stream_out; + + TString separator; + if (OutputFolder.Length() > 1) separator = "/"; + else separator = ""; + + stream_out = new ofstream(OutputFolder+separator+filename,ofstream::app); + + *stream_out<close(); +} + +// embeds the drawing fonts into the vector graphics, which is not done by default by ROOT +// uses a powershell script invoking ghostscript +// should be generalized without hard coded file paths + void embedFonts(TString path) + { + ofstream *stream_out; + stream_out = new ofstream("fontEmbedscript.ps1",ofstream::out); + + *stream_out<<"$msbuild = \"C:\\Program Files\\gs\\gs9.18\\bin\\gswin64c.exe\""<close(); + + system("powershell.exe -ExecutionPolicy Bypass -File fontEmbedscript.ps1"); + + // $arguments = "-q -dNOPAUSE -dBATCH -dPDFSETTINGS=/prepress -sDEVICE=pdfwrite -sOutputFile=G:\CASCADE\Analyze\Heidi\Efficiency\calc\heidiEfficiencyNew3b.pdf G:\CASCADE\Analyze\Heidi\Efficiency\calc\heidiEfficiencyNew3.pdf" + //start-process $msbuild $arguments + } + + +// 16.01.2015 +// exports a TH1 histogram to a tab separated ASCII matrix +void storeTH1ToFile(TString OutputFolder, TString filename,TH1* histo) +{ + ofstream *stream_out; + stream_out = new ofstream(OutputFolder+"/"+filename,ofstream::out); + + Int_t entries = histo->GetNbinsX(); + + for(Int_t l = 1; l < entries+1; l++) + { + *stream_out<GetBinCenter(l))<<"\t"; + *stream_out<GetBinContent(l))<<"\t"<<"0.0"<<"\t"<GetBinContent(l)))<close(); +} + +// reads an image from the specified folder location and transforms it to a TMatrix +TMatrixF readMatrixPNG(TString folder, TString filename) +{ + QRgb pixelValue; + string imageStr = std::string((folder+filename).Data())+".png"; + QImage matrixImage; + matrixImage.load(QString::fromStdString(imageStr)); + int matrixWidthHere = matrixImage.width(); + int matrixHeightHere = matrixImage.height(); + + TMatrixF matr(matrixWidthHere,matrixHeightHere); + for (int i = 0; i 1) separator = "/"; + else separator = ""; + //fill every value from the file into the according matrix + if (counter<10) dname = folder+separator+filename+"0"+castIntToString(counter)+"."+filetype; + else dname = folder+separator+filename+castIntToString(counter)+"."+filetype; + + if (counter == -1) dname = folder+separator+filename+"."+filetype; + + ifstream input_stream(dname,ios::in); + while ( line.ReadLine(input_stream) ) + { + istrstream stream(line.Data()); + + for(Int_t j = 0; j < size; j++) + { + stream >> temp; + matrix(i,j) = temp; + } + i++; + if(i == size) break; + } + input_stream.close(); + + return matrix; +} + +// counts the files of a specified filetype in the specified folder +Int_t countFiles(TString folder, TString filename, TString filetype) +{ + cout<<"Total number of files: "; + Int_t n = 0; + ifstream f; + + TString separator; + if (folder.Length() > 1) separator = "/"; + else separator = ""; + + f.open(folder+separator+filename+"1"+"."+filetype); + + while (f.good()) + { + f.close(); + n++; + //if (n<10) f.open(folder+"/"+filename+"0"+castIntToString(n)+".dat"); + f.open(folder+separator+filename+castIntToString(n)+"."+filetype); + } + n--; + cout<127) nX = 127; + if (nY>127) nY = 127; + + for(Int_t i = x0; i <= nX; i++) { + for(Int_t j = y0; j <= nY; j++) { + if ((TMath::Power(((i-x)/radiusX),2)+TMath::Power(((j-y)/radiusY),2))<=1) + { + eventcounter+=histo->GetBinContent(i,j); + } + } + } + return eventcounter; +} + + +//-------------------------------------------------------------------------- +// ++++++++++++++++++++++ Cast functions +++++++++++++++++++++++++++++++++++ + +// should be converted to template functions + +string castDoubleToString(double number) +{ + TString s; + s += number; + return (string)s; +} + +string castDoubleToString(double number, Int_t characters) +{ + TString s; + s += number; + s.Resize(characters); + return (string)s; +} + +string castFloatToString(Float_t number) +{ + TString s; + s += number; + return (string)s; +} + +string castFloatToString(Float_t number, Int_t characters) +{ + TString s; + s += number; + s.Resize(characters); + return (string)s; +} + + +string castIntToString(Int_t &number) +{ + TString s; + s += number; + return (string)s; +} + +string castLongToString(Long_t &number) +{ + TString s; + s += number; + return (string)s; +} + +// converts a hex value to base-10 integers +unsigned int heXheX(const TCHAR *value) +{ + struct CHexMap + { + TCHAR chr; + int value; + }; + const unsigned int HexMapL = 16; + CHexMap HexMap[HexMapL] = + { + {'0', 0}, {'1', 1}, + {'2', 2}, {'3', 3}, + {'4', 4}, {'5', 5}, + {'6', 6}, {'7', 7}, + {'8', 8}, {'9', 9}, + {'A', 10}, {'B', 11}, + {'C', 12}, {'D', 13}, + {'E', 14}, {'F', 15} + }; + TCHAR *mstr = _tcsupr(_tcsdup(value)); + TCHAR *s = mstr; + unsigned int result = 0; + if (*s == '0' && *(s + 1) == 'X') s += 2; + bool firsttime = true; + while (*s != '\0') + { + bool found = false; + for (int i = 0; i < HexMapL; i++) + { + if (*s == HexMap[i].chr) + { + if (!firsttime) result <<= 4; + result |= HexMap[i].value; + found = true; + break; + } + } + if (!found) break; + s++; + firsttime = false; + } + free(mstr); + return result; +} + +const std::string intToHex( int i) +{ + std::ostringstream oss; + oss << std::hex << i; + return oss.str(); +} + +// fills zero values in a TMatrix by neighbor extrapolation +// deprecated +void extrapolateZeroValues(TMatrixF &matrix) +{ + Float_t corrSum, corrCounter; + + Int_t ylow = matrix.GetColLwb(); + Int_t ydim = matrix.GetColUpb()+1; + Int_t xlow = matrix.GetRowLwb(); + Int_t xdim = matrix.GetRowUpb()+1; + + + for(Int_t y = ylow; y < ydim; y++) + { + for(Int_t x = xlow; x < xdim; x++) + { + if (matrix(x,y)==0) + { + corrCounter = 0; + corrSum = 0; + + if (x>xlow){ + if (y>ylow){ + if (matrix(x-1,y-1)!=0) {corrSum+=matrix(x-1,y-1); corrCounter++;} + } + if (matrix(x-1,y)!=0) {corrSum+=matrix(x-1,y); corrCounter++;} + if (yylow){ + if (matrix(x+1,y-1)!=0) {corrSum+=matrix(x+1,y-1); corrCounter++;} + } + if (matrix(x+1,y)!=0) {corrSum+=matrix(x+1,y); corrCounter++;} + if (yylow){ + if (matrix(x,y-1)!=0) {corrSum+=matrix(x,y-1); corrCounter++;} + } + if (ymax) max = matrix(x,y); + } + } + + if (max!=0) + { + for(Int_t y = ylow; y < ydim; y++) + { + for(Int_t x = xlow; x < xdim; x++) + { + temp = matrix(x,y)-factor*max; + if (temp>0) redMatrix(x,y) = temp; + } + } + + } + + return redMatrix; +} + +// calculates the gradient matrix of a TMatrix +TMatrixF getGradientMatrix(TMatrixF &matrix) +{ + Int_t ylow = matrix.GetColLwb(); + Int_t ydim = matrix.GetColUpb()+1; + Int_t xlow = matrix.GetRowLwb(); + Int_t xdim = matrix.GetRowUpb()+1; + + TMatrixF gradMatrix(xdim,ydim); gradMatrix=0; + + for(Int_t y = ylow+1; y < ydim-1; y++) + { + for(Int_t x = xlow+1; x < xdim-1; x++) + { + gradMatrix(x,y) = sqrt((TMath::Power(matrix(x-1,y)-matrix(x+1,y),2)+TMath::Power(matrix(x,y-1)-matrix(x,y+1),2))/9.); + } + } + + return gradMatrix; +} + +// calculates the gradient matrix of a TMatrix and stores it to *newMatrix +void getGradientMatrixFromTH2(TH2F* matrix, TH2F* newMatrix) +{ + Int_t ylow = 1; + Int_t ydim = matrix->GetNbinsY(); + Int_t xlow = 1; + Int_t xdim = matrix->GetNbinsX(); + + for(int x=0;x<=xdim;x++) + { + for(int y=0;y<=ydim;y++) + { + if ((x<4)||(y<4)||(x>xdim-4)||(y>ydim-4))newMatrix->SetBinContent(x,y,0); + + } + } + + float gradientX = 0; + float gradientY = 0; + float gradientD1 = 0; + float gradientD2 = 0; + + //TF1* gradientLine = new TF1("gradientLine","pol1",0,10); + TF1* gradientLine = new TF1("gradientLine","[0]+[1]*x",-1,5); + + int px, p0,p1,p2,p3,p4,p5; + TGraphErrors* gradientGraph = new TGraphErrors(6); + + for(Int_t y = ylow+3; y < ydim-3; y++) { + + for(Int_t x = xlow+3; x < xdim-3; x++) { + + px = matrix->GetBinContent(x,y); + + if(px==0) + { + gradientX = 0; + gradientY = 0; + } + else + { + p0 = matrix->GetBinContent(x-3,y); + p1 = matrix->GetBinContent(x-2,y); + p2 = matrix->GetBinContent(x-1,y); + p3 = matrix->GetBinContent(x+1,y); + p4 = matrix->GetBinContent(x+2,y); + p5 = matrix->GetBinContent(x+3,y); + + if( (p0+p1+p2+p3) > 0) + { + gradientGraph->SetPoint(0,0,p0); gradientGraph->SetPointError(0,0,TMath::Sqrt(p0)); + gradientGraph->SetPoint(1,1,p1); gradientGraph->SetPointError(1,0,TMath::Sqrt(p1)); + gradientGraph->SetPoint(2,2,p2); gradientGraph->SetPointError(2,0,TMath::Sqrt(p2)); + gradientGraph->SetPoint(3,3,p3); gradientGraph->SetPointError(3,0,TMath::Sqrt(p3)); + gradientGraph->SetPoint(4,4,p4); gradientGraph->SetPointError(4,0,TMath::Sqrt(p4)); + gradientGraph->SetPoint(5,5,p5); gradientGraph->SetPointError(5,0,TMath::Sqrt(p5)); + + gradientLine->SetParameters(1,0); + gradientGraph->Fit("gradientLine","RQ"); + gradientX = gradientLine->GetParameter(1); + } + else gradientX = 0; + + p0 = matrix->GetBinContent(x,y-3); + p1 = matrix->GetBinContent(x,y-2); + p2 = matrix->GetBinContent(x,y-1); + p3 = matrix->GetBinContent(x,y+1); + p4 = matrix->GetBinContent(x,y+2); + p5 = matrix->GetBinContent(x,y+3); + + if( (p0+p1+p2+p3) > 0) + { + gradientGraph->SetPoint(0,0,p0); gradientGraph->SetPointError(0,0,TMath::Sqrt(p0)); + gradientGraph->SetPoint(1,1,p1); gradientGraph->SetPointError(1,0,TMath::Sqrt(p1)); + gradientGraph->SetPoint(2,2,p2); gradientGraph->SetPointError(2,0,TMath::Sqrt(p2)); + gradientGraph->SetPoint(3,3,p3); gradientGraph->SetPointError(3,0,TMath::Sqrt(p3)); + gradientGraph->SetPoint(4,4,p4); gradientGraph->SetPointError(4,0,TMath::Sqrt(p4)); + gradientGraph->SetPoint(5,5,p5); gradientGraph->SetPointError(5,0,TMath::Sqrt(p5)); + + gradientLine->SetParameters(1,0); + gradientGraph->Fit("gradientLine","RQ"); + gradientY = gradientLine->GetParameter(1); + } + else gradientY = 0; + + p0 = matrix->GetBinContent(x-2,y-2); + p1 = matrix->GetBinContent(x-1,y-1); + p2 = matrix->GetBinContent(x+1,y+1); + p3 = matrix->GetBinContent(x+2,y+2); + + if( (p0+p1+p2+p3) < 0) + { + gradientGraph->SetPoint(0,0,p0); gradientGraph->SetPointError(0,0,TMath::Sqrt(p0)); + gradientGraph->SetPoint(1,1,p1); gradientGraph->SetPointError(1,0,TMath::Sqrt(p1)); + gradientGraph->SetPoint(2,2,p2); gradientGraph->SetPointError(2,0,TMath::Sqrt(p2)); + gradientGraph->SetPoint(3,3,p3); gradientGraph->SetPointError(3,0,TMath::Sqrt(p3)); + + gradientLine->SetParameters(1,0); + gradientGraph->Fit("gradientLine","RQ"); + gradientD1 = gradientLine->GetParameter(1); + } + else gradientD1 = 0; + + p0 = matrix->GetBinContent(x+2,y-2); + p1 = matrix->GetBinContent(x+1,y-1); + p2 = matrix->GetBinContent(x-1,y+1); + p3 = matrix->GetBinContent(x-2,y+2); + + if( (p0+p1+p2+p3) < 0) + { + gradientGraph->SetPoint(0,0,p0); gradientGraph->SetPointError(0,0,TMath::Sqrt(p0)); + gradientGraph->SetPoint(1,1,p1); gradientGraph->SetPointError(1,0,TMath::Sqrt(p1)); + gradientGraph->SetPoint(2,2,p2); gradientGraph->SetPointError(2,0,TMath::Sqrt(p2)); + gradientGraph->SetPoint(3,3,p3); gradientGraph->SetPointError(3,0,TMath::Sqrt(p3)); + + gradientLine->SetParameters(1,0); + gradientGraph->Fit("gradientLine","RQ"); + gradientD2 = gradientLine->GetParameter(1); + } + else gradientD2 = 0; + } + //newMatrix->SetBinContent(x,y, sqrt((TMath::Power(matrix->GetBinContent(x-1,y)-matrix->GetBinContent(x+1,y),2)+TMath::Power(matrix->GetBinContent(x,y-1)-matrix->GetBinContent(x,y+1),2))/9.) ); + + if (gradientX>50) gradientX = 0; + if (gradientY>50) gradientY = 0; + if (gradientD1>50) gradientD1 = 0; + if (gradientD2>50) gradientD2 = 0; + if (gradientX<-50) gradientX = 0; + if (gradientY<-50) gradientY = 0; + if (gradientD1<-50) gradientD1 = 0; + if (gradientD2<-50) gradientD2 = 0; + + newMatrix->SetBinContent(x,y, sqrt(TMath::Power(gradientX,2)+TMath::Power(gradientY,2)+TMath::Power(gradientD1,2)+TMath::Power(gradientD2,2)) ); + } + } + delete gradientLine; + delete gradientGraph; +} + + +// converts an ASCII matrix to a TH2 histogram +TH2F* getTH2fromMatrix(TMatrixF &matrix, TString thName, TString thTitle) +{ + Int_t ylow = matrix.GetColLwb(); + Int_t ydim = matrix.GetColUpb()+1; + Int_t xlow = matrix.GetRowLwb(); + Int_t xdim = matrix.GetRowUpb()+1; + + TH2F* matrixTH = new TH2F(thName, thTitle , xdim-xlow, xlow-0.5 , xdim-1+0.5, ydim-ylow, ylow-0.5 , ydim-1+0.5); + + for(Int_t y = ylow; y < ydim; y++) + { + for(Int_t x = xlow; x < xdim; x++) + { + matrixTH->Fill(x,y,matrix(x,y)); + } + } + + return matrixTH; +} + +// deprecated +TH1F* convoluteGaussian(TH1F* hist, Double_t gaussRelW) +{ + Float_t mDiv = TMath::Abs(hist->GetBinCenter(2) - hist->GetBinCenter(1)); + Int_t nMaxBins = hist->GetNbinsX(); + + Double_t binSum; + + TH1F* convolvedHist = new TH1F(hist->GetName(), hist->GetTitle(), nMaxBins , hist->GetBinCenter(0), hist->GetBinCenter(hist->GetNbinsX()-1)); + + for(Int_t n = 1; n < nMaxBins; n++) + { + //if (hist->GetBinContent(n)==0) continue; + + binSum = 0; + + for(Int_t m = -100; m < 101; m++) + { + if ((n-m > 0)&&(n-m < nMaxBins)) + { + binSum += TMath::Gaus(m*mDiv, 0, gaussRelW/2.35482*hist->GetBinCenter(n), true) * hist->GetBinContent(n-m); + } + } + convolvedHist->SetBinContent(n, binSum); + } + return convolvedHist; +} + +// removes all histograms from the pointer vector from the memory. +void histoClearUp(vector< TObject* >* vectorTH) +{ + TString name; + vector names; + + for(int k=0; ksize();k++) + { + //cout<at(k)->GetName()<at(k)->GetName()) names.push_back(vectorTH->at(k)->GetName()); + //cout<FindObject(names.at(k))) {delete gDirectory->FindObject(names.at(k));} + } + vectorTH->clear(); + cout<<"deleting histos..."<GetXaxis(); + const Int_t nbins = 100; + Double_t xmin = axis->GetXmin(); + Double_t xmax = axis->GetXmax(); + Double_t logXmin = TMath::Log10(xmin); + Double_t logXmax= TMath::Log10(xmax); + Double_t binwidth = (logXmax - logXmin) / nbins; + Double_t xBins[nbins + 1]; + xBins[0] = xmin; + for (Int_t i = 1; i <= nbins; i++) + { + xBins[i] = xmin + TMath::Power(10, logXmin + i * binwidth); + } + + axis->Set(nbins, xBins); +} + + +/** + * replaces the x-axis with a logarithmic x-axis of 1000 bins + * root has no logarithmic binning, so it requires generating a bin array + * @param h + * + */ +void logaxis(TH1* h) +{ + TAxis* axis = h->GetXaxis(); + const Int_t nBins = 1000; + Double_t xMin = axis->GetXmin(); + Double_t xMax = axis->GetXmax(); + Double_t logXmin = TMath::Log10(xMin); + Double_t logXmax= TMath::Log10(xMax); + Double_t binWidth = (logXmax- logXmin) / nBins; + Double_t xBins[nBins + 1]; + xBins[0] = xMin; + for (Int_t binsItr = 1; binsItr <= nBins; binsItr++) + { + xBins[binsItr] = xMin + TMath::Power(10, logXmin + binsItr * binWidth); + } + + axis->Set(nBins, xBins); +} + + +/** + * rebins a logarithmic x-axis from 1000 bins to 100 + * @param h + * + */ +void rebinX(TH1* h) +{ + const Int_t nBinsPrev = 1000; + const Int_t nBins = 100; + TAxis* axis = h->GetXaxis(); + Double_t xMin = axis->GetXmin(); + Double_t xMax = axis->GetXmax(); + + Double_t logXmin = TMath::Log10(xMin); + Double_t logXmax= TMath::Log10(xMax); + Double_t binwidth = (logXmax- logXmin) / nBins; + Double_t xBins[nBins + 1]; + xBins[0] = xMin; + + for (Int_t i = 1; i <= nBins; i++) + { + xBins[i] = xMin + TMath::Power(10, logXmin + i * binwidth); + } + Double_t binContent[nBins + 1]; + for (Int_t i = 1; i <= nBins; i++) { binContent[i] = 0; } + + int binNo; + + for (Int_t i = 1; i <= nBinsPrev + 1; i++) + { + binNo = i / 10; + binContent[binNo] = binContent[binNo] + h->GetBinContent(i); + } + + for (Int_t i = 1; i <= nBinsPrev + 1; i++) + { + h->SetBinContent(i, 0); + } + + //h->Clear(); + + axis->Set(nBins, xBins); + + for (Int_t i = 1; i <= nBins; i++) + { + h->Fill(h->GetBinCenter(i), binContent[i]); + } +} + + +/** + * replaces the y-axis with a logarithmic y-axis of 100 bins + * root has no logarithmic binning, so it requires generating a bin array + * @param h + * + */ +void logYaxis(TH2* h) +{ + TAxis* axis = h->GetYaxis(); + const Int_t nbins = 100; + Double_t xmin = axis->GetXmin(); + Double_t xmax = axis->GetXmax(); + Double_t logXmin = TMath::Log10(xmin); + Double_t logXmax= TMath::Log10(xmax); + Double_t binwidth = (logXmax- logXmin) / nbins; + Double_t xBins[nbins + 1]; + xBins[0] = xmin; + for (Int_t i = 1; i <= nbins; i++) + { + xBins[i] = xmin + TMath::Power(10, logXmin + i * binwidth); + } + + axis->Set(nbins, xBins); +} + + +/** + * calculates neutron transport time in mus + * z0 and z0Alt in mm, energy in MeV + * + * @param z0. + * @param z0Alt. + * @param energy + * @param cosTheta + * @return the Neutron transport Time . + */ +double calcNeutronDiffTime(double z0, double z0Alt, double energy, double cosTheta) +{ + //if (energy<20) nSpeed = 3.9560339/sqrt(81.81/energy/1e9) * 1000.*1000.; + //else nSpeed = 3.9560339/sqrt(81.81/20./1e9) * 1000.*1000.; + //if (energy < nSpeedEnergyCutoff) nSpeed = 3.9560339/sqrt(81.81/nSpeedEnergyCutoff/1e9) * 1000.*1000.; + + if (z0Alt == z0) return 0; + + double nSpeed = 3.9560339 / sqrt(81.81 / energy / 1e9); + + //timeTemp = wwRange/nSpeed; + return fabs((z0Alt - z0) / cosTheta / nSpeed); +} + + +/** + * generates a random number in MeV from an evaporation spectrum with central energy theta + * pointer to an already seeded Random generator is needed + * @param theta + * @param r + * @return abszRnd . + * + */ +double getEvaporationEnergy(double theta, TRandom* r) +{ + bool gotIt; + double abszRnd, ordRnd; + + TF1* spectrumFuncEvaporation = new TF1("spectrumFuncEvaporation", "x*TMath::Exp(-x/[0])", 0.0000, 20); + spectrumFuncEvaporation->SetParameter(0, theta / 1e6); + double maximum = spectrumFuncEvaporation->GetMaximum(0.2, 10); + + gotIt = false; + while (!gotIt) + { + abszRnd = r->Rndm() * 19.; + ordRnd = r->Rndm() * maximum; + //gotIt = true; + if (spectrumFuncEvaporation->Eval(abszRnd) > ordRnd) gotIt = true; + } + + delete spectrumFuncEvaporation; + + return abszRnd; +} + + + + +/** + * generates a random number in MeV from a moderated Californium source spectrum + * pointer to an already seeded Random generator is needed + * @param r + * @return abszRnd + */ +double getModeratedCfEnergy(TRandom* r) +{ + bool gotIt; + double abszRnd, ordRnd; + + //this function is in eV, not MeV like the others + TF1* spectrumMaxwellPhiTempModModFission = new TF1("spectrumMaxwellPhiTempModModFission", "[0]/(TMath::Power([1]/11604.5,2))*TMath::Power(x,2)*TMath::Exp(-x/[1]*11604.5)+[2]*TMath::Power([1]/11604.5,1)/(1+TMath::Power(([3]/x),7)) * 1./(1-[4]/(1+TMath::Power(x/[5],5))) + [6]*x*TMath::SinH(sqrt(2.*(x-[7])/1e6))*TMath::Exp(-(x-[7])/1e6)", 1e-3, 1e7); + spectrumMaxwellPhiTempModModFission->SetParameters(6868, 243, 9600, 0.7171, 0.6023, 0.2103, 0.003933, -3.394e6); + + //spectrumMaxwellPhiTempModModFission->SetParNames("Intensity th","Temperature", "Intensity ratio","scaling 1","scaling 2 [eV]","scaling 3 [eV]", "FissionPar1", "FissionPar2"); + double maximum = 3800; + + gotIt = false; + while (!gotIt) + { + abszRnd = TMath::Power(10, r->Rndm() * 9. - 2.4); + ordRnd = r->Rndm() * maximum; + //gotIt = true; + if (spectrumMaxwellPhiTempModModFission->Eval(abszRnd) > ordRnd) gotIt = true; + } + + delete spectrumMaxwellPhiTempModModFission; + + return (1e-6 * abszRnd); +} + + +/** + * generates a random number in MeV from a fission spectrum + * pointer to an already seeded Random generator is needed + * @param r + * @return abszRnd + */ +double getFissionEnergy(TRandom* r) +{ + bool gotIt; + double abszRnd, ordRnd; + + TF1* spectrumFuncFission = new TF1("spectrumFuncFission", "0.4865*TMath::SinH(sqrt(2*x))*TMath::Exp(-x)", 0.0000, 10); + + double maximum = spectrumFuncFission->GetMaximum(0.2, 3); + + gotIt = false; + while (!gotIt) + { + abszRnd = r->Rndm() * 10.; + ordRnd = r->Rndm() * maximum; + //gotIt = true; + if (spectrumFuncFission->Eval(abszRnd) > ordRnd) gotIt = true; + } + delete spectrumFuncFission; + + return abszRnd; +} + +/** + * generates a random number in MeV from a fission spectrum + * pointer to an already seeded Random generator is needed + * @param r + * @return abszRnd + */ +double getFissionEnergy2(TRandom* r) +{ + bool gotIt; + double abszRnd, ordRnd; + + TF1* spectrumFuncFission = new TF1("spectrumFuncFission", "0.4865*TMath::SinH(sqrt(1.03419*x))*TMath::Exp(-x/1.18)", 0.0000, 10); // X-5 MONTE CARLO TEAM,LA-UR-03-1987,Los Alamos National Laboratory + + double maximum = spectrumFuncFission->GetMaximum(0.2, 3); + + gotIt = false; + while (!gotIt) + { + abszRnd = r->Rndm() * 10.; + ordRnd = r->Rndm() * maximum; + //gotIt = true; + if (spectrumFuncFission->Eval(abszRnd) > ordRnd) gotIt = true; + } + + delete spectrumFuncFission; + + return abszRnd; +} + + +/** + * generates a random Number representing energy in eV according to a thermal Spectrum + * collision partner of given mass massElm and temperature + * pointer to an already seeded Random generator is needed + * @param r + * @return vNeutron + */ +vector getThermalPDF(const double nEnergy, const float massElm, const float temperature, TRandom* r) +{ + float xRnd, rnd1 = 0, rnd2 = 0, rnd3 = 0, abszRnd, ordRnd; + vector vNeutron; + bool gotIt = false; + bool takeTwo = false; + + double kB = 1.38065e-23; + //double mN = 1.6749e-27; + double mN = 939.565 * 1.1111111e-11; + double sqrtPi = sqrt(TMath::Pi()); + double beta = sqrt((1.66e-27) * massElm * 0.5 / kB / temperature); + + double velR = 0.; + double velT = 0.; + double velN = sqrt(2. * nEnergy * 1e6 / mN); + + double y = velN * beta; + + TF1* spectrumFuncTwo = new TF1("spectrumFuncTwo", "2.256758353*TMath::Power(x,2)*TMath::Exp(-x*x)", 0.0000000, 100000); + TF1* spectrumFuncThree = new TF1("spectrumFuncThree", "2.*TMath::Power(x,3)*TMath::Exp(-x*x)", 0.0000000, 100000); + //Plot Range x: [0,3.2] y:[0,0.85] + + TF1* spectrumFunc; + + //calc which distribution to take: low energy or high energy + rnd1 = r->Rndm(); + if (rnd1 < 2. / (sqrtPi * y + 2.)) + { + takeTwo = false; + spectrumFunc = spectrumFuncThree; + } + else + { + takeTwo = true; + spectrumFunc = spectrumFuncTwo; + } + + //get a thermal velocity from the Spectrum + gotIt = false; + while (!gotIt) + { + abszRnd = r->Rndm() * 3.2; + ordRnd = r->Rndm() * 0.85; + if (spectrumFunc->Eval(abszRnd) > ordRnd) gotIt = true; + } + + velT = abszRnd / beta; + + gotIt = false; + while (!gotIt) + { + rnd2 = r->Rndm() * 2. - 1.; + rnd3 = r->Rndm(); + + velR = sqrt(fabs(TMath::Power(velN, 2) + TMath::Power(velT, 2) - 2. * velN * velT * rnd2)); + + if (rnd3 < velR / (velN + velT)) gotIt = true; + } + + // Energy(speed) and cosine + vNeutron.push_back(velR * velR * mN / 2.); + vNeutron.push_back(rnd2); + + delete spectrumFuncTwo; delete spectrumFuncThree; + + return vNeutron; +} + +/** + * generates a random energy from a logarithmic thermal neutron density function + * in eV + * @param spectrumFunc + * @param r + * @return xRnd + */ +double getThermalEnergyLog(const TF1* spectrumFunc, TRandom* r) +{ + double xRnd, yRnd; + bool gotIt = false; + + while (!gotIt) + { + + xRnd = TMath::Power(10, r->Rndm() * 2.7 - 8.9); + yRnd = r->Rndm() * 12.; + + if (spectrumFunc->Eval(xRnd) > yRnd) + { + gotIt = true; + } + } + return xRnd; +} + + +/** + * generates a random energy from a linear thermal neutron density function + * @param spectrumFunc + * @param r + * + */ +double getThermalEnergy(TF1* spectrumFunc, TRandom* r) +{ + double xRnd, yRnd; + bool gotIt = false; + + while (!gotIt) + { + xRnd = r->Rndm() * 0.19e-6 + 0.1e-9; + yRnd = r->Rndm(); + + if (spectrumFunc->Eval(xRnd) > yRnd) + { + gotIt = true; + } + } + + return xRnd; +} + + +/** + * generates a random energy from a logarithmic thermal neutron density function like the CF moderated spectrum + * @param spectrumFunc + * @param r + * + */ +double getThermalEnergyFromSource(const TF1* spectrumFunc, TRandom* r) +{ + double xRnd, yRnd; + bool gotIt = false; + + while (!gotIt) + { + xRnd = TMath::Power(10, r->Rndm() * 2.2 - 2.5); + yRnd = r->Rndm() * 3800.; + + if (spectrumFunc->Eval(xRnd) > yRnd) + { + gotIt = true; + } + } + return xRnd; +} + +/** + * calculates a scalar product + * @param rx1 + * @param ry1 + * @param rz1 + * @param rx2 + * @param ry2 + * @param rz2 + * @returns - evaluated scalar product + */ +double scalarProduct(double rx1, double ry1, double rz1, double rx2, double ry2, double rz2) +{ + return(rx1 * rx2 + ry1 * ry2 + rz1 * rz2); +} + +/** + * finding the intersection of a line and a cylinder mantle + * @param stVx + * @param stVy + * @param stVz + * @param phi + * @param theta + * @param px + * @param py + * @param pz + * @param dRad + * @returns - intersection + */ +double intersectCylinderMantle(double stVx, double stVy, double stVz, double theta, double phi, double px, double py, double pz, double dRad) +{ + double tValue1, tValue2, retValue; + + double sinThetacosPhi = (sin(theta)) * cos(phi); + double sinThetasinPhi = (sin(theta)) * sin(phi); + //double cosTheta = (cos(theta)); + + double c = sinThetacosPhi * (stVx - px) + sinThetasinPhi * (stVy - py); + double c2 = pow(px - stVx, 2) + pow(py - stVy, 2); + + tValue1 = -c + sqrt(c * c - (c2 - dRad * dRad)); + tValue2 = -c - sqrt(c * c - (c2 - dRad * dRad)); + + double xIs1 = stVx + tValue1 * sinThetacosPhi; + double yIs1 = stVy + tValue1 * sinThetasinPhi; + + if (scalarProduct(sinThetacosPhi, sinThetasinPhi, 0, (xIs1 - px), (yIs1 - py), 0) >= 0) + { + retValue = tValue2; + } + else + { + retValue = tValue1; + } + + return retValue; +} + + +/** + * finding the intersection of sphere with a line + * @param stVx + * @param stVy + * @param stVz + * @param theta + * @param phi + * @param px + * @param py + * @param pz + * @param dRad + * @returns - intersection + */ +double intersectSphere(double stVx, double stVy, double stVz, double theta, double phi, double px, double py, double pz, double dRad) +{ + double tValue1, tValue2, retValue; + + double sinThetacosPhi = (sin(theta)) * cos(phi); + double sinThetasinPhi = (sin(theta)) * sin(phi); + double cosTheta = cos(theta); + + double c = sinThetacosPhi * (stVx - px) + sinThetasinPhi * (stVy - py) + cosTheta * (stVz - pz); + double c2 = pow(px - stVx, 2) + pow(py - stVy, 2) + pow(pz - stVz, 2); + + tValue1 = -c + sqrt(c * c - (c2 - dRad * dRad)); + tValue2 = -c - sqrt(c * c - (c2 - dRad * dRad)); + + double xIs1 = stVx + tValue1 * sinThetacosPhi; + double yIs1 = stVy + tValue1 * sinThetasinPhi; + /* + double zIs1 = stVz+tValue1*cos(theta); + double xIs2 = stVx+tValue2*sin(theta)*cos(phi); + double yIs2 = stVy+tValue2*sin(theta)*sin(phi); + double zIs2 = stVz+tValue2*cos(theta); + */ + + bool secondPoint = false; + if (scalarProduct(sinThetacosPhi, sinThetasinPhi, 0, (xIs1 - px), (yIs1 - py), 0) >= 0) + { + secondPoint = true; //take no2 + retValue = tValue2; + } + else + { + secondPoint = false; + retValue = tValue1; + } + + return retValue; +} + +/** + * Deprecated + * Calculate the Cylindrical hit distance + * @param stVx + * @param stVy + * @param stVz + * @param theta + * @param phi + * @param px + * @param py + * @param pz + * @param dRad + * @param xref + * @param yref + * @returns - hit distance + */ +double calcCylindricalHitDist2(double stVx, double stVy, double stVz, double theta, double phi, double px, double py, double pz, double dRad, double xRef, double yRef) +{ + double tValue, retValue; + + tValue = intersectCylinderMantle(stVx, stVy, stVz, theta, phi, px, py, pz, dRad); + + double xIs2 = stVx + tValue * sin(theta) * cos(phi); + double yIs2 = stVy + tValue * sin(theta) * sin(phi); + //double zIs2 = stVz+tValue*cos(theta); + + retValue = sqrt(pow(xRef - xIs2, 2) + pow(yRef - yIs2, 2)); + + return retValue; +} + + +/** + * Calculate the Cylindrical hit distance + * @param stVx + * @param stVy + * @param stVz + * @param theta + * @param phi + * @param px + * @param py + * @param pz + * @param dRad + * @param xref + * @param yref + * @returns - hit distance + */ +double calcCylindricalHitDist(double stVx, double stVy, double stVz, double theta, double phi, double px, double py, double pz, double dRad, double xRef, double yRef) +{ + double tValue, retValue; + + tValue = intersectSphere(stVx, stVy, stVz, theta, phi, px, py, pz, dRad); + + double xIs2 = stVx + tValue * sin(theta) * cos(phi); + double yIs2 = stVy + tValue * sin(theta) * sin(phi); + //double zIs2 = stVz+tValue*cos(theta); + + retValue = sqrt(pow(xRef - xIs2, 2) + pow(yRef - yIs2, 2)); + + return retValue; +} + +/** + * Calculate the cylinder intersection + * @param stVx + * @param stVy + * @param stVz + * @param theta + * @param phi + * @param px + * @param py + * @param pz + * @param dRad + * @returns - cylinder intersection + */ +double intersectCylinder(double stVx, double stVy, double stVz, double theta, double phi, double px, double py, double pz, double dRad) +{ + //takes the projection of the cylinder in the x-y plane, selects between the two intersection points + double tValue1, tValue2; + + double a = pow((sin(theta) * cos(phi)), 2) + pow((sin(theta) * sin(phi)), 2); + double p = sin(theta) * cos(phi) * (stVx - px) + sin(theta) * sin(phi) * (stVy - py) / a; + double q = pow((stVx - px), 2) + pow((stVy - py), 2) - dRad * dRad; + + tValue1 = -0.5 * p + sqrt(pow(0.5 * p, 2) - q); + tValue2 = -0.5 * p - sqrt(pow(0.5 * p, 2) - q); + + double xIs1 = stVx + tValue1 * sin(theta) * cos(phi); + double yIs1 = stVy + tValue1 * sin(theta) * sin(phi); + double zIs1 = stVz + tValue1 * cos(theta); + double xIs2 = stVx + tValue2 * sin(theta) * cos(phi); + double yIs2 = stVy + tValue2 * sin(theta) * sin(phi); + double zIs2 = stVz + tValue2 * cos(theta); + + bool secondPoint = false; + if (scalarProduct(sin(theta) * cos(phi), sin(theta) * sin(phi), 0, (xIs1 - px), (yIs1 - py), 0) > 0) secondPoint = true; //take no2 + else secondPoint = false; + + return 0; //unfinished +} + + +/** + * calculates 3D track ('stVx', 'stVy', 'stVz', 'phi', 'theta') to a line ('px','py','pz') distance + * @param stVx + * @param stVy + * @param stVz + * @param theta + * @param phi + * @param px + * @param py + * @param pz + * @returns - distance to line + */ +double getDistanceToLine(double stVx, double stVy, double stVz, double theta, double phi, double px, double py, double pz) +{ + double distance; + + theta = TMath::Pi() - theta; + + double a1 = sin(theta) * sin(phi); + double a2 = -sin(theta) * cos(phi); + + distance = abs(((px - stVx) * a1 + (py - stVy) * a2) / sqrt(a1 * a1 + a2 * a2)); + + return distance; +} + + +/** + * calculates 3D track ('stVx', 'stVy', 'stVz', 'phi', 'theta') to point ('px','py','pz') distance + * @param stVx + * @param stVy + * @param stVz + * @param theta + * @param phi + * @param px + * @param py + * @param pz + * @param dRad + * @returns - distance to point + */ +double getDistanceToPoint(double stVx, double stVy, double stVz, double theta, double phi, double px, double py, double pz) +{ + double distance; + + theta = TMath::Pi() - theta; //changed 29.11.2018 + + double gx = sin(theta) * cos(phi); + double gy = sin(theta) * sin(phi); + double gz = -cos(theta); //changed 30.11.2018 + + double krx = gy * (stVz - pz) - gz * (stVy - py); + double kry = gz * (stVx - px) - gx * (stVz - pz); + double krz = gx * (stVy - py) - gy * (stVx - px); + + distance = sqrt(krx * krx + kry * kry + krz * krz) / sqrt(gx * gx + gy * gy + gz * gz); + + return distance; +} + + +//DEPRECATED +double getDistanceToPointOLD(double stVx, double stVy, double stVz, double theta, double phi, double px, double py, double pz) +{ + double distance; + + double tx = cos(phi) * (stVz - pz) - tan(theta) * (stVy - py); + double ty = tan(theta) * (stVx - px) - sin(phi) * (stVz - pz); + double tz = sin(phi) * (stVy - py) - cos(phi) * (stVx - px); + + distance = sqrt(1. / (1. + tan(theta) * tan(theta))) * sqrt(tx * tx + ty * ty + tz * tz); + + return distance; +} + +/** + * returns a e polynom of order par[1] at x, given scale factor par[0] + * @param x + * @param par + * @returns - legrendian + */ +Double_t legendrian(double* x, Double_t* par) +{ + return par[0] * legendre_Pl(par[1], x[0]); +} + +/** + * returns a normalized sum of Legendre polynoms of order 0 to 10 at x + * @param x + * @param par + * @returns - legrendian 10 fold + */ +Double_t legendrian10fold(double* x, Double_t* par) +{ + x[0] = TMath::Cos(x[0]); + return 0.159155 * (0.5 * 1. * legendre_Pl(0, x[0]) + 1.5 * par[0] * legendre_Pl(1, x[0]) + 2.5 * par[1] * legendre_Pl(2, x[0]) + 3.5 * par[2] * legendre_Pl(3, x[0]) + 4.5 * par[3] * legendre_Pl(4, x[0]) + 5.5 * par[4] * legendre_Pl(5, x[0]) + 6.5 * par[5] * legendre_Pl(6, x[0]) + 7.5 * par[6] * legendre_Pl(7, x[0]) + 8.5 * par[7] * legendre_Pl(8, x[0]) + 9.5 * par[8] * legendre_Pl(9, x[0]) + 10.5 * par[9] * legendre_Pl(10, x[0])); +} + + +/** + * returns a normalized sum of Legendre polynoms of order 0 to 10 at x as a STRING + * @param par + * @returns - legrendian 10 fold as string + */ +string legendrian10folded(Float_t* par) +{ + return "0.159155*(0.5*1*legendre_Pl(0, TMath::Cos(x)) + 1.5*" + castDoubleToString(par[0]) + "*legendre_Pl(1, TMath::Cos(x)) + 2.5*" + castDoubleToString(par[1]) + "*legendre_Pl(2, TMath::Cos(x)) + 3.5*" + castDoubleToString(par[2]) + "*legendre_Pl(3,TMath::Cos(x)) + 4.5*" + castDoubleToString(par[3]) + "*legendre_Pl(4,TMath::Cos(x)) + 5.5*" + castDoubleToString(par[4]) + "*legendre_Pl(5, TMath::Cos(x)) + 6.5*" + castDoubleToString(par[5]) + "*legendre_Pl(6, TMath::Cos(x))"; +} + +/** + * returns the size of an array + * @param array + * @returns - array size + */ +static int ArraySize(double array[]) +{ + int i = 0; + while (array[i] != NULL) i++; + return i; +} + +int legendreElements = 0; + +/** + * returns a normalized sum of Legendre polynoms of order 0 to N (given by the size of the parameter array, which sets the relative scaling factors) at x, + * @param x + * @param par + * @returns - legrendian N fold + */ +static double legendrianNfold(double* x, Double_t* par) +{ + double result = 0.5; + + int elements = legendreElements; + + x[0] = TMath::Cos(x[0]); + + for (int l = 1; l < elements; l++) + { + result = result + (2. * (l)+1.) * 0.5 * par[l - 1] * legendre_Pl(l, x[0]); + } + + return 0.159155 * result; +} + + +/** + * converts an endf formatted string to a float number + * @param str + * @returns - float of a string + */ +float endfNumberConv(string str) +{ + float pos; + int length = str.length(); + + if (length < 5) return 0; + if (str.substr(5, 1) == " ") return 0; + string sign = str.substr(length - 2, 1); + if ((sign == "+") || (sign == "-")) pos = 2; + sign = str.substr(length - 3, 1); + if ((sign == "+") || (sign == "-")) pos = 3; + + string part1 = str.substr(0, length - pos); + string part2 = str.substr(length - pos, pos); + float number = atof(part1.c_str()) * TMath::Power(10, atof(part2.c_str())); + + return number; +} + + +/** + * searches a value in a matrix by an interval algorithm + * searches the cumulated probability distribution (at row line) for a given probability (value) and extrapolates linearly between upper and lower bound + * additionally log interval search can be activated + * @param matrix + * @param line + * @param value + * @param doLogSearch + * @returns - index of the horizontal position + */ +float getIndexHorizontalPosition(const TMatrixF& matrix, int line, double value, bool doLogSearch) +{ + float result; + + //int index; + + int counter = 0; + + int cols = matrix.GetNcols(); + + int pos; + + //energy is stored in column lower bound + int left = matrix.GetColLwb() + 1; + int right = matrix.GetColUpb(); + + if (value > matrix(line, right)) return right - 1; + if (value < matrix(line, left)) return left; + + while (1) + { + if (doLogSearch) + { + //pos = left+ (log(value)-log(matrix(left,0)))/(log(matrix(right,0))-log(matrix(left,0))) * (right-left); + } + else + { + //pos = left+ (value-matrix(left,0))/(matrix(right,0)-matrix(left,0)) * (right-left); + } + + pos = left + (right - left) * 0.5; + + if (pos >= cols - 2) pos = cols - 2; + if (pos <= 0) pos = 0; + + if (matrix(line, pos) < value) + { + if ((pos < cols - 1) && (matrix(line, pos + 1) > value)) break; + left = pos + 1; + } + else + { + if ((pos > 0) && (matrix(line, pos - 1) < value)) { pos = pos - 1; break; } + right = pos - 1; + } + + counter++; + if ((counter > 300) && (!doLogSearch)) doLogSearch = true; + if ((counter > 100) && (doLogSearch)) doLogSearch = false; + + if (counter > 500) + { + cout << "ERROR in Matrix Search" << endl; + if (doLogSearch) cout << "Log "; cout << "Value: " << value << " failed at position: " << pos << " in " << cols << " columns at line " << line << endl; + return 0; + } + } + + result = pos + (value - matrix(line, pos)) / (matrix(line, pos + 1) - matrix(line, pos)); + + if (result >= pos + 1) result = pos + 0.999; + + return result; +} + + +/** + * searches a value in a matrix by an interval algorithm + * searches the index/energy (first column) and extrapolates linearly between upper and lower bound + * additionally log interval search can be activated + * @param matrix + * @param line + * @param value + * @param doLogSearch + * @returns - index of the position + */ +float getIndexPosition(const TMatrixF& matrix, double value, bool doLogSearch) +{ + float result; + + int counter = 0; + + int rows = matrix.GetNrows(); + + int pos; + + int left = matrix.GetRowLwb(); + int right = matrix.GetRowUpb(); + + if (value > matrix(right, 0)) return right - 1; + if (value < matrix(left, 0)) return left; + + while (1) + { + if (doLogSearch) + { + //pos = left+ (log(value)-log(matrix(left,0)))/(log(matrix(right,0))-log(matrix(left,0))) * (right-left); + } + else + { + //pos = left+ (value-matrix(left,0))/(matrix(right,0)-matrix(left,0)) * (right-left); + } + + pos = left + (right - left) * 0.5; + + if (pos >= rows - 2) pos = rows - 2; + if (pos <= 0) pos = 0; + + if (matrix(pos, 0) < value) + { + if ((pos < rows - 1) && (matrix(pos + 1, 0) > value)) break; + left = pos + 1; + } + else + { + if ((pos > 0) && (matrix(pos - 1, 0) < value)) { pos = pos - 1; break; } + right = pos - 1; + } + + counter++; + if ((counter > 300) && (!doLogSearch)) doLogSearch = true; + if ((counter > 100) && (doLogSearch)) doLogSearch = false; + + if (counter > 500) + { + cout << "ERROR in Matrix Search" << endl; + if (doLogSearch) cout << "Log "; cout << "Value: " << value << " failed at position: " << pos << " in " << rows << " rows" << endl; + return 0; + } + } + + result = pos + (value - matrix(pos, 0)) / (matrix(pos + 1, 0) - matrix(pos, 0)); + + if (result >= pos + 1) result = pos + 0.999; + + return result; +} + + + + +/** + * searches a matrix for an energy value (first column) and returns a linearly extrapolated cross section value (second column) + * @param matrix + * @param energy + * @returns - cross section value + */ +double calcMeanCS(const TMatrixF& matrix, double energy) +{ + float position = getIndexPosition(matrix, energy, true); + int index = position; + float frac = position - index; + + return (1. - frac) * matrix(index, 1) + frac * matrix(index + 1, 1); +} + +/** + * returns cos(thetha) for high energy angle distributions + * for a given energy the index in the the angular distribution probability matrix is searched + * then a linearly interpolated cos(theta) from a random number prob is returned + * @param angleMatrix + * @param cumulatedProbMatrix + * @param energy + * @param prob + * @returns - High Energy Cos Theta + */ +double getHighEnergyCosTheta(const TMatrixF& angleMatrix, const TMatrixF& cumulatedProbMatrix, double energy, double prob) +{ + float energyPosition = getIndexPosition(angleMatrix, energy, false); + int energyIndex = energyPosition; + float energyFrac = energyPosition - energyIndex; + + float anglePosition1 = getIndexHorizontalPosition(cumulatedProbMatrix, energyIndex, prob, false); + int angleIndex1 = anglePosition1; + + float anglePosition2 = getIndexHorizontalPosition(cumulatedProbMatrix, energyIndex + 1, prob, false); + int angleIndex2 = anglePosition2; + + float angleFrac1 = anglePosition1 - angleIndex1; //creates the 0.x fracions + float angleFrac2 = anglePosition2 - angleIndex2; + + double cosThetaLw = (1. - angleFrac1) * angleMatrix(energyIndex, angleIndex1) + angleFrac1 * angleMatrix(energyIndex, angleIndex1 + 1); + double cosThetaHigh = (1. - angleFrac2) * angleMatrix(energyIndex + 1, angleIndex2) + angleFrac2 * angleMatrix(energyIndex + 1, angleIndex2 + 1); + + double cosTheta = (1. - energyFrac) * cosThetaLw + energyFrac * cosThetaHigh; + + return cosTheta; +} + +/** + * generates a random number (from a cumulative dsitribution function) in the range min to max + * pointer to an already seeded Random generator is needed + * @param spectrumFunc + * @param min + * @param max + * @param r + * @returns - angle from cumulative function + */ +double getAngleFromCumulativeFunction(const TF1* spectrumFunc, float min, float max, TRandom* r) +{ + const int steps = 51; + + float result = 0; + + // (cumulative Function | xValues) + TMatrixF cumulativeValueMatrix(steps, 2); + + cumulativeValueMatrix(0, 0) = 0; cumulativeValueMatrix(0, 1) = 0; + + //float stepwidth = fabs(max-min/(steps-1)); + double stepwidth = fabs((max - min) / ((steps - 1) * 1.)); + + for (int i = 1; i < steps; i++) + { + cumulativeValueMatrix(i, 1) = min + (i - 1) * stepwidth; + cumulativeValueMatrix(i, 0) = cumulativeValueMatrix(i - 1, 0) + spectrumFunc->Eval(min + (i - 1) * stepwidth); + } + + result = getIndexPosition(cumulativeValueMatrix, cumulativeValueMatrix(steps - 1, 0) * r->Rndm(), false); + int bin = result; + float frac = result - bin; + + if (bin >= (steps - 1)) bin--; + return (1. - frac) * cumulativeValueMatrix(bin, 1) + frac * cumulativeValueMatrix(bin + 1, 1); +} + + +/** + * generates a legendre function according to the polynomial coefficients which are linearly extrapolated from the matrix according to the given energy + * @param matrix + * @param energy + * @returns - mean Angular Distribution + */ +TF1* calcMeanAngularDistribution(const TMatrixF& matrix, double energy) +{ + Float_t cn1[21]; + Float_t cn2[21]; + + cn1[0] = 0; cn1[1] = 0; + cn2[0] = 0; cn2[1] = 0; + + float position = getIndexPosition(matrix, energy, false); + + int index = position; + float frac = position - index; + int l; + + for (l = 1; l < 21; l++) + { + cn1[l - 1] = matrix(index, l); + cn2[l - 1] = matrix(index + 1, l); + if ((cn1[l - 1] == 0) && (cn2[l - 1] == 0)) break; + if ((frac == 0) && (cn1[l - 1] == 0)) break; + if (l == 21) break; + + } + + if (l < 3) { l = 3; frac = 0; } + const int lastcn = l - 1; + + legendreElements = lastcn; + TF1* legendrian = new TF1("legendrian", legendrianNfold, 0, TMath::Pi(), lastcn); + + for (int l = 0; l < lastcn; l++) + { + legendrian->SetParameter(l, (1 - frac) * cn1[l] + frac * cn2[l]); + } + + return legendrian; +} + +/** + * transposes a matrix (esp. for input images) + * @param inputMatrix + * + */ +void turnInputMatrix(TMatrixF& inputMatrix) +{ + Float_t tmpchg; + Int_t imageSize = inputMatrix.GetNrows(); + for (Int_t im = 0; im < imageSize / 2.; im++) + { + for (Int_t jm = 0; jm < imageSize; jm++) + { + tmpchg = inputMatrix(jm, im); + inputMatrix(jm, im) = inputMatrix(jm, imageSize - 1 - im); + inputMatrix(jm, imageSize - 1 - im) = tmpchg; + } + } + for (Int_t im = 0; im < imageSize; im++) + { + for (Int_t jm = 0; jm < imageSize; jm++) + { + if (imageSize - 1 - im < jm) + { + tmpchg = inputMatrix(jm, im); + inputMatrix(jm, im) = inputMatrix(imageSize - 1 - im, imageSize - 1 - jm); + inputMatrix(imageSize - 1 - im, imageSize - 1 - jm) = tmpchg; + } + } + } +} + + +/** + * converts old gray scale identifiers to new ones + * @param inputMatrix + * @returns - converted old gray scale + */ +int changeInputMatrixValue(int value) +{ + return 0; +} + diff --git a/Toolkit.h b/Toolkit.h new file mode 100644 index 0000000..0cf7412 --- /dev/null +++ b/Toolkit.h @@ -0,0 +1,221 @@ +#include "TGraph2D.h" +#include "TGraph2DErrors.h" +#include "TGraphErrors.h" +#include "TGraph.h" +#include "TMultiGraph.h" +#include "TGaxis.h" +#include "TStyle.h" +#include "TROOT.h" +#include +#include +#include "TFile.h" +#include "TText.h" +//#include "TTree.h" +#include "THStack.h" +#include "TH1.h" +#include "TH2.h" +#include "TH3.h" +#include "TF1.h" +#include "TF2.h" +#include "TProfile.h" +#include "Fit/FitResult.h" +#include "TFitResultPtr.h" +#include "TFitResult.h" +#include "TCanvas.h" +#include "TPad.h" +//#include "TVirtualPad.h" +//#include "TVirtualFitter.h" +#include "TNamed.h" +#include "TMath.h" +#include "TMatrix.h" +#include "TVectorT.h" +#include "TMatrixF.h" +#include "TMatrixD.h" +#include "TMatrixT.h" +#include "TMatrixTSym.h" +#include "TPaveStats.h" +#include "TString.h" +#include "TLatex.h" +#include "TColor.h" +#include +#include "RConfig.h" +#include "Rtypes.h" +#include "TLegend.h" +#include "TSpline.h" +#include "TObject.h" +#include +#include +//#include + + +#include +#include +#include + +#include + +#include "TRandom3.h" + +using namespace std; + + + string castDoubleToString(double number); + + string castDoubleToString(double number, Int_t intacters); + + string castFloatToString(Float_t number); + + string castFloatToString(Float_t number, Int_t intacters); + + string castIntToString(Int_t &number); + + string castLongToString(Long_t &number); + + Double_t lorentzianPeak(Double_t* x, Double_t* par); + + Double_t gaussoffset(Double_t* x, Double_t* par); + + Double_t errf( Double_t *x, Double_t *par); + + void rootlogon(); + + vector getRGBfromHCL(double h, double c0, double l0); + + float getLinearC(double factor, double cmin, double cmax); + + float getScaledColorValue(double factor, double pow, double cmin, double cmax); + + void set_plot_styleSingleGradient(float h, Double_t a0, Double_t a1, Double_t a2, Double_t a3, Double_t a4); + + void set_plot_styleHeatGradient(Double_t a0, Double_t a1, Double_t a2, Double_t a3, Double_t a4); + + void set_plot_styleRainbowGradient(Double_t a0, Double_t a1, Double_t a2, Double_t a3, Double_t a4); + + void set_plot_styleAllGradient(Double_t a0, Double_t a1, Double_t a2, Double_t a3, Double_t a4); + + void set_plot_styleHeatGradientModified(Double_t a0, Double_t a1, Double_t a2, Double_t a3, Double_t a4); + + void set_plot_styleHeatGradient2(Double_t a0, Double_t a1, Double_t a2, Double_t a3, Double_t a4); + + void set_plot_style(Double_t a0, Double_t a1, Double_t a2, Double_t a3, Double_t a4); + + int getScaledColor(float min, float max, float scale, int mode); + + vector getScaledColorRGB(float min, float max, float scale, int mode); + + void set_plot_styleCool(); + + void CanvasFashion(TCanvas* c); + + void TGraphFashion(TGraph* graph, TString xLabel, TString yLabel, Bool_t setSize); + + void TGraphErrorFashion(TGraphErrors* graph, TString xLabel, TString yLabel, Bool_t setSize); + + void TGraph2DFashion(TGraph2D* graph, TString xLabel, TString yLabel, TString zLabel, Bool_t setSize); + + void TMultiGraphFashion(TMultiGraph* graph, TString xLabel, TString yLabel, Bool_t setSize); + + void TF1Fashion(TF1* hist, TString xLabel, TString yLabel, Bool_t setSize); + + void TH1Fashion(TH1* hist, TString xLabel, TString yLabel, Bool_t setSize); + + void TProfileFashion(TProfile* hist, TString xLabel, TString yLabel, Bool_t setSize); + + void TH2Fashion(TH2* hist, Bool_t setSize); + + void TH2Fashion(TH2* hist, TString xLabel, TString yLabel, Bool_t setSize); + + void THStackFashion(THStack* stack, TString xLabel, TString yLabel, Bool_t setSize); + + TH2F* printHisto(Double_t zmin, Double_t zmax, Int_t size, TMatrixF data, TString OutputFolder, TString dataname, Bool_t logPlot); + + void printTH1F(Double_t zmin, Double_t zmax, TH1F* histo, TString OutputFolder, TString dataname); + + void printTH2F(Double_t zmin, Double_t zmax, TH2F* histo, TString OutputFolder, TString dataname); + + void storeTH2ToFile(TString OutputFolder, TString filename, TH2F* th2); + + void storeToFile(TString OutputFolder, TString filename, TString what_has_to_be_written, bool new_line); + + void embedFonts(TString path); + + void storeTH1ToFile(TString OutputFolder, TString filename,TH1* histo); + + TMatrixF readMatrixPNG(TString folder, TString filename); + + TMatrixF readmatrix(TString folder, TString filename, TString filetype, Int_t counter, Int_t size); + + Int_t countFiles(TString folder, TString filename, TString filetype); + + //void deleteStatsTH(vector *allTHs); + + unsigned int heXheX(const TCHAR *value); + + const std::string intToHex( int i); + + void extrapolateZeroValues(TMatrixF &matrix); + + TMatrixF reduceMatrix(TMatrixF &matrix, Float_t factor); + + TMatrixF getGradientMatrix(TMatrixF &matrix); + + void getGradientMatrixFromTH2(TH2F* matrix, TH2F* newMatrix); + + TH2F* getTH2fromMatrix(TMatrixF &matrix, TString thName, TString thTitle); + + TH1F* convoluteGaussian(TH1F* hist, Double_t gaussRelW); + + int countEventsInEllipse(TH2F* histo, double radiusX, double x, double radiusY, double y); + + void histoClearUp(vector* vectorTH); + + double getWWProb(double density, double atWeight, double cs, double lambda); + double getLfromE(double energy); + double getEfromL(double lambda); + TSpline3* getSplinedDetectorEnergyModel(); + int getNumberOfFileEntries(TString dname); + inline double legendre_Pl(int n, double x); + void logXaxis(TH2* h); + void rebinX(TH1* h); + void logaxis(TH1* h); + void logXaxis(TH2* h); + void logYaxis(TH2* h); + double getRLuftWasser(float temperature); + double calcNeutronDiffTime(double z0, double z0Alt, double energy, double cosTheta); + double getEvaporationEnergy(double theta, TRandom* r); + double getModeratedCfEnergy(TRandom* r); + double getFissionEnergy(TRandom* r); + double getFissionEnergy2(TRandom* r); + vector getThermalPDF(const double nEnergy, const float massElm, const float temperature, TRandom* r); + double getThermalEnergyLog(const TF1* spectrumFunc, TRandom* r); + double getThermalEnergy(TF1* spectrumFunc, TRandom* r); + double getThermalEnergyFromSource(const TF1* spectrumFunc, TRandom* r); + double scalarProduct(double rx1, double ry1, double rz1, double rx2, double ry2, double rz2); + double intersectCylinderMantle(double stVx, double stVy, double stVz, double theta, double phi, double px, double py, double pz, double dRad); + double intersectSphere(double stVx, double stVy, double stVz, double theta, double phi, double px, double py, double pz, double dRad); + double calcCylindricalHitDist2(double stVx, double stVy, double stVz, double theta, double phi, double px, double py, double pz, double dRad, double xRef, double yRef); + double calcCylindricalHitDist(double stVx, double stVy, double stVz, double theta, double phi, double px, double py, double pz, double dRad, double xRef, double yRef); + double intersectCylinder(double stVx, double stVy, double stVz, double theta, double phi, double px, double py, double pz, double dRad); + double getDistanceToLine(double stVx, double stVy, double stVz, double theta, double phi, double px, double py, double pz); + double getDistanceToPoint(double stVx, double stVy, double stVz, double theta, double phi, double px, double py, double pz); + double getDistanceToPointOLD(double stVx, double stVy, double stVz, double theta, double phi, double px, double py, double pz); + Double_t legendrian(double* x, Double_t* par); + Double_t legendrian10fold(double* x, Double_t* par); + string legendrian10folded(Float_t* par); + static int ArraySize(double array[]); + static double legendrianNfold(double* x, Double_t* par); + float endfNumberConv(string str); + float getIndexHorizontalPosition(const TMatrixF& matrix, int line, double value, bool doLogSearch); + float getIndexPosition(const TMatrixF& matrix, double value, bool doLogSearch); + double calcMeanCS(const TMatrixF& matrix, double energy); + double getHighEnergyCosTheta(const TMatrixF& angleMatrix, const TMatrixF& cumulatedProbMatrix, double energy, double prob); + double getAngleFromCumulativeFunction(const TF1* spectrumFunc, float min, float max, TRandom* r); + TF1* calcMeanAngularDistribution(const TMatrixF& matrix, double energy); + void turnInputMatrix(TMatrixF& inputMatrix); + int changeInputMatrixValue(int value); + + + + + + diff --git a/ui_dialogshowpic.h b/ui_dialogshowpic.h new file mode 100644 index 0000000..bba4f72 --- /dev/null +++ b/ui_dialogshowpic.h @@ -0,0 +1,82 @@ +/******************************************************************************** +** Form generated from reading UI file 'dialogshowpic.ui' +** +** Created by: Qt User Interface Compiler version 5.15.2 +** +** WARNING! All changes made in this file will be lost when recompiling UI file! +********************************************************************************/ + +#ifndef UI_DIALOGSHOWPIC_H +#define UI_DIALOGSHOWPIC_H + +#include +#include +#include +#include +#include +#include +#include "qcustomplot.h" + +QT_BEGIN_NAMESPACE + +class Ui_DialogShowPic +{ +public: + QDialogButtonBox *buttonBox; + QCustomPlot *widget; + QPushButton *pushButtonPlus; + QPushButton *pushButtonMinus; + QLabel *labelNo; + QLabel *label; + + void setupUi(QDialog *DialogShowPic) + { + if (DialogShowPic->objectName().isEmpty()) + DialogShowPic->setObjectName(QString::fromUtf8("DialogShowPic")); + DialogShowPic->resize(627, 590); + buttonBox = new QDialogButtonBox(DialogShowPic); + buttonBox->setObjectName(QString::fromUtf8("buttonBox")); + buttonBox->setGeometry(QRect(430, 550, 171, 32)); + buttonBox->setOrientation(Qt::Horizontal); + buttonBox->setStandardButtons(QDialogButtonBox::Cancel|QDialogButtonBox::Ok); + widget = new QCustomPlot(DialogShowPic); + widget->setObjectName(QString::fromUtf8("widget")); + widget->setGeometry(QRect(20, 20, 591, 521)); + pushButtonPlus = new QPushButton(DialogShowPic); + pushButtonPlus->setObjectName(QString::fromUtf8("pushButtonPlus")); + pushButtonPlus->setGeometry(QRect(60, 555, 31, 23)); + pushButtonMinus = new QPushButton(DialogShowPic); + pushButtonMinus->setObjectName(QString::fromUtf8("pushButtonMinus")); + pushButtonMinus->setGeometry(QRect(20, 555, 31, 23)); + labelNo = new QLabel(DialogShowPic); + labelNo->setObjectName(QString::fromUtf8("labelNo")); + labelNo->setGeometry(QRect(163, 559, 46, 13)); + label = new QLabel(DialogShowPic); + label->setObjectName(QString::fromUtf8("label")); + label->setGeometry(QRect(107, 557, 51, 16)); + + retranslateUi(DialogShowPic); + QObject::connect(buttonBox, SIGNAL(accepted()), DialogShowPic, SLOT(accept())); + QObject::connect(buttonBox, SIGNAL(rejected()), DialogShowPic, SLOT(reject())); + + QMetaObject::connectSlotsByName(DialogShowPic); + } // setupUi + + void retranslateUi(QDialog *DialogShowPic) + { + DialogShowPic->setWindowTitle(QCoreApplication::translate("DialogShowPic", "Input Matrix View", nullptr)); + pushButtonPlus->setText(QCoreApplication::translate("DialogShowPic", "+", nullptr)); + pushButtonMinus->setText(QCoreApplication::translate("DialogShowPic", "-", nullptr)); + labelNo->setText(QCoreApplication::translate("DialogShowPic", "-", nullptr)); + label->setText(QCoreApplication::translate("DialogShowPic", "Layer #:", nullptr)); + } // retranslateUi + +}; + +namespace Ui { + class DialogShowPic: public Ui_DialogShowPic {}; +} // namespace Ui + +QT_END_NAMESPACE + +#endif // UI_DIALOGSHOWPIC_H diff --git a/ui_mainwindow.h b/ui_mainwindow.h new file mode 100644 index 0000000..2613547 --- /dev/null +++ b/ui_mainwindow.h @@ -0,0 +1,2385 @@ +/******************************************************************************** +** Form generated from reading UI file 'mainwindow.ui' +** +** Created by: Qt User Interface Compiler version 5.14.2 +** +** WARNING! All changes made in this file will be lost when recompiling UI file! +********************************************************************************/ + +#ifndef UI_MAINWINDOW_H +#define UI_MAINWINDOW_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "qcustomplot.h" + +QT_BEGIN_NAMESPACE + +class Ui_MainWindow +{ +public: + QWidget *centralWidget; + QTabWidget *tabWidget; + QWidget *Geometry; + QSlider *sliderSoilMoisture; + QSlider *sliderAirHum; + QLabel *labelSM; + QLabel *labelHum; + QLabel *label_6; + QLabel *label_7; + QGroupBox *groupBox; + QTableView *tableViewLayer; + QCheckBox *checkBox_useImage; + QPushButton *pushButton_Show; + QPushButton *pushButton_6; + QGroupBox *groupBox_11; + QPushButton *pushButton_LoadGeometry; + QPushButton *pushButton_SaveGeometry; + QGroupBox *groupBox_12; + QPushButton *pushButton_RemoveLayer; + QPushButton *pushButton_AddLayer; + QPushButton *pushButton_ReadGeometry; + QSpinBox *spinBox_GroundLayer; + QLabel *label_28; + QLabel *label_29; + QSpinBox *spinBox_StartingLayer; + QLabel *label_27; + QSpinBox *spinBox_DetectorLayer; + QLabel *label_71; + QGroupBox *groupBox_Evaporation; + QRadioButton *radioButton_fission; + QRadioButton *radioButton_fusion; + QRadioButton *radioButton_AmBe; + QLineEdit *lineEdit_xPos; + QLabel *label_55; + QLabel *label_57; + QLineEdit *lineEdit_yPos; + QLabel *label_58; + QLineEdit *lineEdit_zPos; + QLineEdit *lineEdit_zPos_2; + QCheckBox *checkBoxThermal; + QRadioButton *radioButton_NoSource; + QLineEdit *lineEdit_xSize; + QLineEdit *lineEdit_ySize; + QLabel *label_64; + QLabel *label_65; + QRadioButton *radioButton_MonoenergeticSource; + QLineEdit *lineEdit_SourceEnergy; + QRadioButton *radioButton_ThermalSource; + QLabel *label_67; + QRadioButton *radioButton_ModeratedCf; + QLineEdit *lineEdit_zSize; + QLabel *label_72; + QGroupBox *groupBox_20; + QRadioButton *radioButton_LeftToRight; + QRadioButton *radioButton_RightToLeft; + QRadioButton *radioButton_Omni; + QRadioButton *radioButton_TopToBottom; + QRadioButton *radioButton_BottomToTop; + QLabel *label_45; + QLabel *label_10; + QLabel *labelAtm1; + QSlider *sliderAtm1; + QLabel *label_56; + QSlider *sliderSoilPorosity; + QLabel *labelSP; + QLabel *labelrigidity; + QLabel *label_11; + QSlider *sliderRigidity; + QWidget *tab; + QGroupBox *groupBox_3; + QLineEdit *lineEditBeamRad; + QLabel *label_21; + QRadioButton *beamRound; + QRadioButton *beamSquare; + QLabel *label_34; + QCheckBox *checkBox_VolumeSource; + QGroupBox *groupBox_2; + QLineEdit *lineEditSquareDim; + QLabel *label_12; + QLabel *label_35; + QLabel *label_32; + QGroupBox *groupBox_4; + QRadioButton *radioRiver; + QRadioButton *radioCoast; + QLineEdit *lineEdit_River; + QLineEdit *lineEdit_River_2; + QLineEdit *lineEdit_Island; + QRadioButton *radioIsland; + QLineEdit *lineEdit_Lake; + QRadioButton *radioLake; + QRadioButton *radioButton; + QLabel *label_70; + QGroupBox *groupBox_21; + QLabel *label_84; + QCheckBox *checkBox_DomainCutoff; + QLineEdit *lineEditDomainFactor; + QLabel *label_86; + QLineEdit *lineEditDomainMeters; + QLabel *label_87; + QCheckBox *checkBox_DomainCutoffMeters; + QLabel *label_90; + QCheckBox *checkBox_ReflectiveBoundaries; + QCheckBox *checkBox_PeriodicBoundaries; + QGroupBox *groupBox_27; + QCheckBox *checkBox_HEModel; + QCheckBox *checkBox_activateThermal; + QWidget *tab_4; + QSlider *horizontalSliderFPMoist; + QSlider *horizontalSliderFPHum; + QLabel *labelFPMoist; + QLabel *labelFPHum; + QGroupBox *groupBox_9; + QLabel *label_36; + QLineEdit *lineEditDetRad; + QLineEdit *lineEditDetX; + QLabel *label_38; + QLabel *label_14; + QLabel *label_37; + QLabel *label_13; + QLineEdit *lineEditDety; + QCheckBox *checkBoxTransparent; + QLabel *label_39; + QGroupBox *groupBox_13; + QRadioButton *radioButton_Sphere; + QRadioButton *radioButton_Cylinder; + QRadioButton *radioButton_ySheet; + QLabel *label_83; + QRadioButton *radioButton_xSheet; + QGroupBox *groupBox_19; + QGroupBox *groupBox_16; + QRadioButton *radioButton_detectorEnergyBand; + QRadioButton *radioButton_detectorRealistic; + QLineEdit *lineEditDetLength; + QLabel *label_85; + QGroupBox *groupBox_10; + QLabel *label_59; + QLineEdit *lineEditScotoma_2; + QCheckBox *checkBox; + QCheckBox *checkBox_NoMultipleScattering; + QLabel *label_66; + QCheckBox *checkBox_TrackAllLayers; + QLabel *label_69; + QGroupBox *groupBox_15; + QRadioButton *radioButton_detectorLayerEnergyBand; + QRadioButton *radioButton_detectorLayerRealistic; + QGroupBox *groupBox_14; + QLabel *label_3; + QLabel *label_41; + QLabel *label_22; + QLabel *label_40; + QLineEdit *lineEditTHLhigh; + QLineEdit *lineEditTHLlow; + QLineEdit *lineEditScotoma; + QLabel *label_51; + QLabel *label_52; + QLabel *label_79; + QLineEdit *lineEditAntiScotoma; + QLabel *label_80; + QLabel *label_74; + QWidget *tab_2; + QLabel *label_44; + QSpinBox *spinBox_2; + QPushButton *pushButton_2; + QLabel *label_8; + QCheckBox *checkBoxBasicSpectrum; + QLabel *label; + QCustomPlot *WidgetSpectrum; + QGroupBox *groupBox_6; + QCustomPlot *customPlotFP; + QPushButton *pushButton_ActivateFP; + QSlider *horizontalSliderFPHum_2; + QLabel *label_48; + QLabel *label_FPIntegral; + QLabel *labelIntegral; + QLabel *label_49; + QCheckBox *checkBoxFPLog; + QLabel *label_73; + QWidget *tab_5; + QLineEdit *lineEdit_DetectorFile; + QLabel *label_15; + QLineEdit *lineEdit_WorkFolder; + QLineEdit *lineEdit_OutputFolder; + QLabel *label_25; + QLabel *label_17; + QLineEdit *lineEdit_CrosssectionFolder; + QLabel *label_16; + QLabel *label_30; + QLineEdit *lineEdit_InputSpectrumFolder; + QLabel *label_33; + QWidget *tab_3; + QGroupBox *groupBox_7; + QRadioButton *radioButton_expHeat; + QRadioButton *radioButton_expGray; + QRadioButton *radioButton_expHeatInv; + QRadioButton *radioButton_expCool; + QRadioButton *radioButton_expRainbow; + QRadioButton *radioButton_expDeviation; + QSpinBox *spinBoxRebinning; + QLabel *label_53; + QCheckBox *checkBoxFileOutputPDF; + QLabel *label_43; + QGroupBox *groupBox_22; + QCheckBox *checkBoxDetectorDistanceData; + QCheckBox *checkBoxDetectorLayerDistanceData; + QCheckBox *checkBoxTravelDistGraph; + QCheckBox *checkBoxLogTravelDistance; + QGroupBox *groupBox_23; + QCheckBox *checkBoxExportAllTracks; + QCheckBox *checkBoxFileOutput; + QCheckBox *checkBoxFileOutput2; + QLabel *label_89; + QCheckBox *checkBoxFileOutput3; + QGroupBox *groupBox_24; + QCheckBox *checkBoxWarnMAterial; + QCheckBox *checkBoxFileOutputPDF_2; + QSpinBox *spinBoxSaveEvery; + QLabel *label_62; + QLabel *label_63; + QCheckBox *checkBoxCreateFolder; + QCheckBox *checkBoxSaveEvery; + QGroupBox *groupBox_26; + QCheckBox *checkBoxDetectorOriginData; + QCheckBox *checkBoxHighResTrackingData; + QCheckBox *checkBoxDetectorOriginMap; + QCheckBox *checkBoxSelectedMap; + QCheckBox *checkBoxSelectedData; + QCheckBox *checkBoxThermalMap; + QLabel *label_88; + QCheckBox *checkBoxIntermediateData; + QLabel *label_54; + QCheckBox *checkBoxEpithermalMap; + QCheckBox *checkBoxThermalData; + QCheckBox *checkBoxFastMap; + QCheckBox *checkBoxFastData; + QCheckBox *checkBoxEpithermalData; + QCheckBox *checkBoxIntermediateMap; + QCheckBox *checkBoxTrackingData; + QWidget *tab_6; + QGroupBox *groupBox_5; + QRadioButton *radioButton_map; + QRadioButton *radioButton_mapInter; + QRadioButton *radioButton_mapFast; + QRadioButton *radioButton_mapAlbedo; + QCheckBox *checkBoxGradient2; + QRadioButton *radioButton_mapTrackAlbedo; + QLabel *label_60; + QLabel *label_61; + QRadioButton *radioButton_mapTrackFast; + QRadioButton *radioButton_mapTrackInter; + QRadioButton *radioButton_mapTrack; + QRadioButton *radioButton_mapThermal; + QRadioButton *radioButton_mapTrackThermal; + QRadioButton *radioButton_mapTrackEnergy; + QGroupBox *groupBox_8; + QRadioButton *radioButton_NeutronNight; + QRadioButton *radioButton_NeutronCold; + QRadioButton *radioButton_NeutronPolar; + QRadioButton *radioButton_NeutronRainbow; + QSlider *horizontalSliderColor; + QSlider *horizontalSliderColorZero; + QLabel *label_46; + QLabel *label_47; + QLabel *label_50; + QLabel *label_ColorRange; + QCheckBox *checkBoxManual; + QLineEdit *lineEditManualColorZero; + QLineEdit *lineEditManualColor; + QCheckBox *checkBoxLogarithmic; + QRadioButton *radioButton_NeutronGrayScale; + QRadioButton *radioButton_NeutronHot; + QRadioButton *radioButton_NeutronThermal; + QGroupBox *groupBox_17; + QSlider *horizontalSliderDetector; + QLabel *label_75; + QLabel *label_DetectorRange; + QLabel *label_76; + QLabel *label_DetectorRangeMaximum; + QSlider *horizontalSliderDetectorColor; + QLabel *label_78; + QGroupBox *groupBox_18; + QCheckBox *checkBoxNoTrack; + QLabel *label_68; + QCheckBox *checkBoxAutoRefreshRate; + QLineEdit *lineEdit_AutoUpdate; + QLabel *label_82; + QGroupBox *groupBox_25; + QCheckBox *checkBoxClearEveryDisplayRefresh; + QLabel *label_81; + QLineEdit *lineEditClearEveryXNeutrons; + QCheckBox *checkBoxSaveEvery_2; + QFrame *simframe; + QPushButton *pushButton; + QPushButton *pushButton_Pause; + QPushButton *pushButton_stop; + QPushButton *pushButton_Clear; + QPushButton *pushButton_Simulate; + QLabel *label_npers; + QLabel *neutronCountView; + QProgressBar *progressBar; + QLabel *label_31; + QLabel *label_18; + QLineEdit *lineEditRefresh; + QLineEdit *lineEditNeutrinsTotal; + QLabel *label_9; + QLabel *label_timeRemain; + QLabel *label_26; + QLabel *label_Status; + QLabel *label_Status2; + QPushButton *pushButton_SaveConfig; + QPushButton *pushButton_about; + QTabWidget *tabWidget_live; + QWidget *tab_7; + QFrame *liveframe1; + QCustomPlot *customPlot; + QCustomPlot *customPlot2; + QPushButton *pushButton_Enlarge; + QLabel *label_detectorLayerNs2; + QWidget *tab_8; + QFrame *frame; + QCustomPlot *customPlot4; + QLabel *label_24; + QCustomPlot *customPlot6; + QLabel *label_4; + QLabel *label_20; + QProgressBar *detectorLayerRatioBar; + QLabel *label_19; + QProgressBar *detectorRatioBar; + QCheckBox *checkBoxR; + QCheckBox *checkBoxRS; + QLabel *label_Footprint63D; + QLabel *label_Footprint86D; + QLabel *label_Footprint86DL; + QLabel *label_Footprint63DL; + QLabel *label_91; + QLabel *label_92; + QLabel *label_93; + QLabel *label_94; + QLabel *label_FootprintNFL; + QLabel *label_FootprintNF; + QLabel *label_95; + QLabel *label_96; + QLabel *label_97; + QLabel *label_98; + QWidget *tab_9; + QFrame *frame_2; + QCustomPlot *customPlot3; + QLabel *label_23; + QLabel *label_5; + QCheckBox *checkBoxD; + QCustomPlot *customPlot5; + QWidget *tab_10; + QFrame *frame_3; + QCustomPlot *customPlot10; + QLabel *label_77; + QLabel *label_DetNeutrons; + QLabel *label_detectorNs; + QLabel *label_2; + QLabel *label_42; + QLabel *label_detectorLayerNs; + QFrame *frame_4; + QMenuBar *menuBar; + QStatusBar *statusBar; + + void setupUi(QMainWindow *MainWindow) + { + if (MainWindow->objectName().isEmpty()) + MainWindow->setObjectName(QString::fromUtf8("MainWindow")); + MainWindow->resize(1448, 906); + MainWindow->setMinimumSize(QSize(1111, 85)); + MainWindow->setMaximumSize(QSize(1623, 920)); + MainWindow->setStyleSheet(QString::fromUtf8("/***************** SIM FRAME*****************/\n" +"#simframe { background-color: #00589C;\n" +" border-bottom-left-radius: 4px; border-bottom-right-radius: 4px; }\n" +"#simframe QLabel { color: rgba(255,255,255,0.5) }\n" +"#simframe QLineEdit { \n" +" /*background-color: rgba(255,255,255,0.5); border: 0;*/\n" +" background-color: transparent; border: 0; border-bottom: 2px solid rgba(255,255,255,0.5);\n" +" color: rgba(255,255,255,0.5) }\n" +"\n" +"#tabWidget_live QFrame QLabel,\n" +"#tabWidget_live QFrame QRadioButton,\n" +"#tabWidget_live QFrame QCheckBox,\n" +"#tabWidget_live QFrame QGroupBox { color: rgba(255,255,255,0.5) }\n" +"#tabWidget_live QFrame QGroupBox { border: 1px solid rgba(255,255,255,0.5); margin-top: 0.5em; }\n" +"#tabWidget_live QFrame QGroupBox::title {\n" +" subcontrol-origin: margin;\n" +" subcontrol-position: top center; /* position at the top center */\n" +" padding: 0 5px;\n" +" }\n" +"#tabWidget_live QFrame { background-color: #00589C; }\n" +"\n" +"/******************* TABS *" + "******************/\n" +"QTabWidget::pane { /* The tab widget frame */\n" +" border-top: 2px solid#00589C;\n" +"}\n" +"QTabWidget::tab-bar {\n" +" left: 5px; /* move to the right by 5px */\n" +"}\n" +"QTabBar::tab {\n" +" background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,\n" +" stop: 0 #E1E1E1, stop: 0.4 #DDDDDD,\n" +" stop: 0.5 #D8D8D8, stop: 1.0 #D3D3D3);\n" +" border-top-left-radius: 3px; border-top-right-radius: 3px;\n" +" color: #555555;\n" +" min-width: 18ex;\n" +" padding: 4px 8px;\n" +" margin-right: 3px\n" +"}\n" +"QTabBar::tab:selected, QTabBar::tab:hover {\n" +" /*background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,\n" +" stop: 0 #FFFFFF, stop: 0.7 #F8F8F8,\n" +" stop: 0.8 #EFEFEF, stop: 1.0 #D9D9D9);*/\n" +" background-color: #00589C;\n" +" color: white;\n" +" /*border: 2px solid #00589C;\n" +" color: #00589C; */\n" +"}\n" +"QTabBar::tab:!selected {\n" +" " + " margin-top: 5px; /* make non-selected tabs look smaller */\n" +"}\n" +"\n" +"QTabWidget#tabWidget_live::pane { /* The tab widget frame */\n" +" border: 2px solid #00589C;\n" +"}\n" +"QTabWidget#tabWidget_live { \n" +" background-color: green;\n" +"}\n" +"QTabWidget#tabWidget_live::tab-bar {\n" +" left: 45px; /* move to the right by 5px */\n" +"}\n" +"\n" +"/*********** PROGRESS BAR *****************/\n" +"QProgressBar {\n" +" text-align: center;\n" +" background-color: transparent; border: 0;\n" +" border-left: 1px solid rgba(255,255,255,0.5);\n" +" border-right: 1px solid rgba(255,255,255,0.5);\n" +" \n" +"}\n" +"QProgressBar::chunk {\n" +" background-color: rgba(255,255,255,0.5); /*rgba(0,88,156,0.3);*/\n" +" width: 5px;\n" +" margin: 1px;\n" +"}\n" +"/**************** BUTTON *****************/\n" +"QPushButton {\n" +" background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,\n" +" stop: 0 #E1E1E1, stop: 0.4 #DDDDDD,\n" +" stop: 0.5 #D8D8D8, stop:" + " 1.0 #D3D3D3);\n" +" border-radius: 2px;\n" +" max-height: 35px;\n" +" padding: 4px 5px;\n" +" border: 1px outset #D3D3D3\n" +"}\n" +"QPushButton:hover {\n" +" background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,\n" +" stop: 0 #F1F1F1, stop: 0.4 #EEEEEE,\n" +" stop: 0.5 #E8E8E8, stop: 1.0 #E3E3E3);\n" +" border: 1px outset #E3E3E3;\n" +"}\n" +"QPushButton:pressed {\n" +" background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,\n" +" stop: 0 #D1D1D1, stop: 0.4 #CCCCCC,\n" +" stop: 0.5 #C8C8C8, stop: 1.0 #C3C3C3);\n" +" border-style: inset; border: 1px inset #C3C3C3;\n" +"}\n" +"\n" +"/**************** SLIDER *****************/\n" +"\n" +"\n" +"QSlider::groove:horizontal {\n" +" border: 0;\n" +" height: 12px; /* the groove expands to the size of the slider by default. by giving it a height, it has a fixed size */\n" +" /*background: qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:" + "0 #B1B1B1, stop:1 #c4c4c4);*/\n" +"}\n" +"\n" +"QSlider::groove:vertical {\n" +" border: 0;\n" +" width: 12px; /* the groove expands to the size of the slider by default. by giving it a height, it has a fixed size */\n" +" /*background: qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:0 #B1B1B1, stop:1 #c4c4c4);*/\n" +"}\n" +"QSlider::handle:horizontal {\n" +" background: qlineargradient(x1:0, y1:0, x2:1, y2:1, stop:0 #E4E4E4, stop:1 #BfBfBf);\n" +" border: 1px solid #9c9c9c;\n" +" width: 18px;\n" +" margin: -2px 0; /* handle is placed by default on the contents rect of the groove. Expand outside the groove */\n" +" border-radius: 3px;\n" +"}\n" +"QSlider::handle:vertical {\n" +" background: qlineargradient(x1:0, y1:0, x2:1, y2:1, stop:0 #E4E4E4, stop:1 #BfBfBf);\n" +" border: 1px solid #9c9c9c;\n" +" height: 18px;\n" +" margin: 0 -2px; /* handle is placed by default on the contents rect of the groove. Expand outside the groove */\n" +" border-radius: 3px;\n" +"}\n" +"\n" +"QSlider::add-page { back" + "ground: white; border: 1px solid #DDDDDD; }\n" +"#tabWidget_live QFrame QSlider::add-page { border: 1px solid rgba(255,255,255,0.5); }\n" +"\n" +"QSlider::sub-page { background: #00589C; border: 1px solid #DDDDDD; }\n" +"#tabWidget_live QFrame QSlider::sub-page { border: 1px solid rgba(255,255,255,0.5); }\n" +"")); + centralWidget = new QWidget(MainWindow); + centralWidget->setObjectName(QString::fromUtf8("centralWidget")); + tabWidget = new QTabWidget(centralWidget); + tabWidget->setObjectName(QString::fromUtf8("tabWidget")); + tabWidget->setGeometry(QRect(50, 90, 871, 801)); + tabWidget->setAutoFillBackground(false); + tabWidget->setTabShape(QTabWidget::Rounded); + tabWidget->setElideMode(Qt::ElideNone); + tabWidget->setUsesScrollButtons(true); + tabWidget->setDocumentMode(false); + tabWidget->setTabsClosable(false); + tabWidget->setMovable(false); + Geometry = new QWidget(); + Geometry->setObjectName(QString::fromUtf8("Geometry")); + sliderSoilMoisture = new QSlider(Geometry); + sliderSoilMoisture->setObjectName(QString::fromUtf8("sliderSoilMoisture")); + sliderSoilMoisture->setGeometry(QRect(20, 48, 171, 22)); + sliderSoilMoisture->setMinimum(2); + sliderSoilMoisture->setMaximum(100); + sliderSoilMoisture->setValue(20); + sliderSoilMoisture->setSliderPosition(20); + sliderSoilMoisture->setOrientation(Qt::Horizontal); + sliderAirHum = new QSlider(Geometry); + sliderAirHum->setObjectName(QString::fromUtf8("sliderAirHum")); + sliderAirHum->setGeometry(QRect(20, 156, 171, 22)); + sliderAirHum->setMinimum(1); + sliderAirHum->setSliderPosition(20); + sliderAirHum->setOrientation(Qt::Horizontal); + labelSM = new QLabel(Geometry); + labelSM->setObjectName(QString::fromUtf8("labelSM")); + labelSM->setGeometry(QRect(201, 50, 41, 16)); + labelHum = new QLabel(Geometry); + labelHum->setObjectName(QString::fromUtf8("labelHum")); + labelHum->setGeometry(QRect(201, 156, 51, 21)); + label_6 = new QLabel(Geometry); + label_6->setObjectName(QString::fromUtf8("label_6")); + label_6->setGeometry(QRect(20, 28, 161, 16)); + label_7 = new QLabel(Geometry); + label_7->setObjectName(QString::fromUtf8("label_7")); + label_7->setGeometry(QRect(20, 136, 91, 16)); + groupBox = new QGroupBox(Geometry); + groupBox->setObjectName(QString::fromUtf8("groupBox")); + groupBox->setGeometry(QRect(270, 80, 571, 421)); + tableViewLayer = new QTableView(groupBox); + tableViewLayer->setObjectName(QString::fromUtf8("tableViewLayer")); + tableViewLayer->setGeometry(QRect(20, 30, 381, 371)); + tableViewLayer->setMinimumSize(QSize(5, 0)); + tableViewLayer->setBaseSize(QSize(5, 1)); + checkBox_useImage = new QCheckBox(groupBox); + checkBox_useImage->setObjectName(QString::fromUtf8("checkBox_useImage")); + checkBox_useImage->setGeometry(QRect(420, 272, 131, 20)); + pushButton_Show = new QPushButton(groupBox); + pushButton_Show->setObjectName(QString::fromUtf8("pushButton_Show")); + pushButton_Show->setGeometry(QRect(420, 303, 111, 28)); + pushButton_6 = new QPushButton(groupBox); + pushButton_6->setObjectName(QString::fromUtf8("pushButton_6")); + pushButton_6->setGeometry(QRect(420, 230, 111, 28)); + groupBox_11 = new QGroupBox(groupBox); + groupBox_11->setObjectName(QString::fromUtf8("groupBox_11")); + groupBox_11->setGeometry(QRect(410, 341, 151, 61)); + pushButton_LoadGeometry = new QPushButton(groupBox_11); + pushButton_LoadGeometry->setObjectName(QString::fromUtf8("pushButton_LoadGeometry")); + pushButton_LoadGeometry->setGeometry(QRect(10, 20, 61, 28)); + pushButton_SaveGeometry = new QPushButton(groupBox_11); + pushButton_SaveGeometry->setObjectName(QString::fromUtf8("pushButton_SaveGeometry")); + pushButton_SaveGeometry->setGeometry(QRect(80, 20, 61, 28)); + groupBox_12 = new QGroupBox(groupBox); + groupBox_12->setObjectName(QString::fromUtf8("groupBox_12")); + groupBox_12->setGeometry(QRect(410, 20, 151, 201)); + pushButton_RemoveLayer = new QPushButton(groupBox_12); + pushButton_RemoveLayer->setObjectName(QString::fromUtf8("pushButton_RemoveLayer")); + pushButton_RemoveLayer->setGeometry(QRect(10, 30, 31, 28)); + pushButton_AddLayer = new QPushButton(groupBox_12); + pushButton_AddLayer->setObjectName(QString::fromUtf8("pushButton_AddLayer")); + pushButton_AddLayer->setGeometry(QRect(10, 63, 31, 28)); + pushButton_ReadGeometry = new QPushButton(groupBox_12); + pushButton_ReadGeometry->setObjectName(QString::fromUtf8("pushButton_ReadGeometry")); + pushButton_ReadGeometry->setGeometry(QRect(70, 63, 71, 31)); + spinBox_GroundLayer = new QSpinBox(groupBox_12); + spinBox_GroundLayer->setObjectName(QString::fromUtf8("spinBox_GroundLayer")); + spinBox_GroundLayer->setGeometry(QRect(100, 170, 42, 22)); + label_28 = new QLabel(groupBox_12); + label_28->setObjectName(QString::fromUtf8("label_28")); + label_28->setGeometry(QRect(10, 110, 91, 20)); + label_29 = new QLabel(groupBox_12); + label_29->setObjectName(QString::fromUtf8("label_29")); + label_29->setGeometry(QRect(10, 170, 81, 20)); + spinBox_StartingLayer = new QSpinBox(groupBox_12); + spinBox_StartingLayer->setObjectName(QString::fromUtf8("spinBox_StartingLayer")); + spinBox_StartingLayer->setGeometry(QRect(100, 110, 42, 22)); + label_27 = new QLabel(groupBox_12); + label_27->setObjectName(QString::fromUtf8("label_27")); + label_27->setGeometry(QRect(10, 140, 91, 20)); + spinBox_DetectorLayer = new QSpinBox(groupBox_12); + spinBox_DetectorLayer->setObjectName(QString::fromUtf8("spinBox_DetectorLayer")); + spinBox_DetectorLayer->setGeometry(QRect(100, 140, 42, 22)); + label_71 = new QLabel(groupBox_12); + label_71->setObjectName(QString::fromUtf8("label_71")); + label_71->setGeometry(QRect(65, 30, 81, 31)); + groupBox_Evaporation = new QGroupBox(Geometry); + groupBox_Evaporation->setObjectName(QString::fromUtf8("groupBox_Evaporation")); + groupBox_Evaporation->setEnabled(true); + groupBox_Evaporation->setGeometry(QRect(0, 310, 261, 431)); + groupBox_Evaporation->setVisible(false); + groupBox_Evaporation->setFlat(false); + radioButton_fission = new QRadioButton(groupBox_Evaporation); + radioButton_fission->setObjectName(QString::fromUtf8("radioButton_fission")); + radioButton_fission->setGeometry(QRect(20, 27, 171, 20)); + radioButton_fission->setChecked(true); + radioButton_fusion = new QRadioButton(groupBox_Evaporation); + radioButton_fusion->setObjectName(QString::fromUtf8("radioButton_fusion")); + radioButton_fusion->setGeometry(QRect(19, 57, 171, 20)); + radioButton_AmBe = new QRadioButton(groupBox_Evaporation); + radioButton_AmBe->setObjectName(QString::fromUtf8("radioButton_AmBe")); + radioButton_AmBe->setGeometry(QRect(19, 87, 171, 20)); + lineEdit_xPos = new QLineEdit(groupBox_Evaporation); + lineEdit_xPos->setObjectName(QString::fromUtf8("lineEdit_xPos")); + lineEdit_xPos->setGeometry(QRect(18, 260, 51, 22)); + label_55 = new QLabel(groupBox_Evaporation); + label_55->setObjectName(QString::fromUtf8("label_55")); + label_55->setGeometry(QRect(18, 240, 61, 16)); + label_57 = new QLabel(groupBox_Evaporation); + label_57->setObjectName(QString::fromUtf8("label_57")); + label_57->setGeometry(QRect(80, 240, 61, 16)); + lineEdit_yPos = new QLineEdit(groupBox_Evaporation); + lineEdit_yPos->setObjectName(QString::fromUtf8("lineEdit_yPos")); + lineEdit_yPos->setGeometry(QRect(80, 260, 51, 22)); + label_58 = new QLabel(groupBox_Evaporation); + label_58->setObjectName(QString::fromUtf8("label_58")); + label_58->setGeometry(QRect(140, 240, 61, 16)); + lineEdit_zPos = new QLineEdit(groupBox_Evaporation); + lineEdit_zPos->setObjectName(QString::fromUtf8("lineEdit_zPos")); + lineEdit_zPos->setGeometry(QRect(140, 260, 51, 22)); + lineEdit_zPos_2 = new QLineEdit(groupBox_Evaporation); + lineEdit_zPos_2->setObjectName(QString::fromUtf8("lineEdit_zPos_2")); + lineEdit_zPos_2->setEnabled(true); + lineEdit_zPos_2->setGeometry(QRect(200, 307, 51, 22)); + checkBoxThermal = new QCheckBox(groupBox_Evaporation); + checkBoxThermal->setObjectName(QString::fromUtf8("checkBoxThermal")); + checkBoxThermal->setGeometry(QRect(100, 213, 181, 17)); + checkBoxThermal->setChecked(true); + radioButton_NoSource = new QRadioButton(groupBox_Evaporation); + radioButton_NoSource->setObjectName(QString::fromUtf8("radioButton_NoSource")); + radioButton_NoSource->setGeometry(QRect(19, 210, 61, 20)); + lineEdit_xSize = new QLineEdit(groupBox_Evaporation); + lineEdit_xSize->setObjectName(QString::fromUtf8("lineEdit_xSize")); + lineEdit_xSize->setGeometry(QRect(18, 307, 51, 22)); + lineEdit_ySize = new QLineEdit(groupBox_Evaporation); + lineEdit_ySize->setObjectName(QString::fromUtf8("lineEdit_ySize")); + lineEdit_ySize->setGeometry(QRect(80, 307, 51, 22)); + label_64 = new QLabel(groupBox_Evaporation); + label_64->setObjectName(QString::fromUtf8("label_64")); + label_64->setGeometry(QRect(80, 287, 61, 16)); + label_65 = new QLabel(groupBox_Evaporation); + label_65->setObjectName(QString::fromUtf8("label_65")); + label_65->setGeometry(QRect(18, 287, 61, 16)); + radioButton_MonoenergeticSource = new QRadioButton(groupBox_Evaporation); + radioButton_MonoenergeticSource->setObjectName(QString::fromUtf8("radioButton_MonoenergeticSource")); + radioButton_MonoenergeticSource->setGeometry(QRect(19, 149, 141, 20)); + lineEdit_SourceEnergy = new QLineEdit(groupBox_Evaporation); + lineEdit_SourceEnergy->setObjectName(QString::fromUtf8("lineEdit_SourceEnergy")); + lineEdit_SourceEnergy->setGeometry(QRect(170, 150, 51, 20)); + radioButton_ThermalSource = new QRadioButton(groupBox_Evaporation); + radioButton_ThermalSource->setObjectName(QString::fromUtf8("radioButton_ThermalSource")); + radioButton_ThermalSource->setGeometry(QRect(19, 180, 81, 20)); + label_67 = new QLabel(groupBox_Evaporation); + label_67->setObjectName(QString::fromUtf8("label_67")); + label_67->setGeometry(QRect(202, 287, 61, 16)); + radioButton_ModeratedCf = new QRadioButton(groupBox_Evaporation); + radioButton_ModeratedCf->setObjectName(QString::fromUtf8("radioButton_ModeratedCf")); + radioButton_ModeratedCf->setGeometry(QRect(19, 120, 201, 17)); + lineEdit_zSize = new QLineEdit(groupBox_Evaporation); + lineEdit_zSize->setObjectName(QString::fromUtf8("lineEdit_zSize")); + lineEdit_zSize->setGeometry(QRect(140, 307, 51, 22)); + label_72 = new QLabel(groupBox_Evaporation); + label_72->setObjectName(QString::fromUtf8("label_72")); + label_72->setGeometry(QRect(140, 287, 61, 16)); + groupBox_20 = new QGroupBox(groupBox_Evaporation); + groupBox_20->setObjectName(QString::fromUtf8("groupBox_20")); + groupBox_20->setGeometry(QRect(20, 340, 120, 81)); + radioButton_LeftToRight = new QRadioButton(groupBox_20); + radioButton_LeftToRight->setObjectName(QString::fromUtf8("radioButton_LeftToRight")); + radioButton_LeftToRight->setGeometry(QRect(20, 40, 41, 17)); + radioButton_RightToLeft = new QRadioButton(groupBox_20); + radioButton_RightToLeft->setObjectName(QString::fromUtf8("radioButton_RightToLeft")); + radioButton_RightToLeft->setGeometry(QRect(70, 40, 41, 17)); + radioButton_RightToLeft->setLayoutDirection(Qt::RightToLeft); + radioButton_Omni = new QRadioButton(groupBox_20); + radioButton_Omni->setObjectName(QString::fromUtf8("radioButton_Omni")); + radioButton_Omni->setGeometry(QRect(59, 40, 41, 17)); + radioButton_TopToBottom = new QRadioButton(groupBox_20); + radioButton_TopToBottom->setObjectName(QString::fromUtf8("radioButton_TopToBottom")); + radioButton_TopToBottom->setGeometry(QRect(59, 19, 41, 17)); + radioButton_BottomToTop = new QRadioButton(groupBox_20); + radioButton_BottomToTop->setObjectName(QString::fromUtf8("radioButton_BottomToTop")); + radioButton_BottomToTop->setGeometry(QRect(59, 60, 41, 17)); + label_45 = new QLabel(Geometry); + label_45->setObjectName(QString::fromUtf8("label_45")); + label_45->setGeometry(QRect(270, 19, 581, 61)); + label_45->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_45->setWordWrap(true); + label_10 = new QLabel(Geometry); + label_10->setObjectName(QString::fromUtf8("label_10")); + label_10->setGeometry(QRect(20, 189, 171, 21)); + labelAtm1 = new QLabel(Geometry); + labelAtm1->setObjectName(QString::fromUtf8("labelAtm1")); + labelAtm1->setGeometry(QRect(197, 217, 81, 16)); + sliderAtm1 = new QSlider(Geometry); + sliderAtm1->setObjectName(QString::fromUtf8("sliderAtm1")); + sliderAtm1->setGeometry(QRect(20, 214, 171, 22)); + sliderAtm1->setMinimum(700); + sliderAtm1->setMaximum(1050); + sliderAtm1->setSingleStep(10); + sliderAtm1->setPageStep(100); + sliderAtm1->setValue(1020); + sliderAtm1->setSliderPosition(1020); + sliderAtm1->setOrientation(Qt::Horizontal); + label_56 = new QLabel(Geometry); + label_56->setObjectName(QString::fromUtf8("label_56")); + label_56->setGeometry(QRect(19, 82, 161, 16)); + sliderSoilPorosity = new QSlider(Geometry); + sliderSoilPorosity->setObjectName(QString::fromUtf8("sliderSoilPorosity")); + sliderSoilPorosity->setGeometry(QRect(19, 102, 171, 22)); + sliderSoilPorosity->setMinimum(2); + sliderSoilPorosity->setMaximum(90); + sliderSoilPorosity->setValue(50); + sliderSoilPorosity->setSliderPosition(50); + sliderSoilPorosity->setOrientation(Qt::Horizontal); + labelSP = new QLabel(Geometry); + labelSP->setObjectName(QString::fromUtf8("labelSP")); + labelSP->setGeometry(QRect(200, 104, 41, 16)); + labelrigidity = new QLabel(Geometry); + labelrigidity->setObjectName(QString::fromUtf8("labelrigidity")); + labelrigidity->setGeometry(QRect(196, 276, 46, 13)); + label_11 = new QLabel(Geometry); + label_11->setObjectName(QString::fromUtf8("label_11")); + label_11->setGeometry(QRect(20, 253, 161, 21)); + sliderRigidity = new QSlider(Geometry); + sliderRigidity->setObjectName(QString::fromUtf8("sliderRigidity")); + sliderRigidity->setEnabled(true); + sliderRigidity->setGeometry(QRect(20, 271, 171, 22)); + sliderRigidity->setMinimum(10); + sliderRigidity->setMaximum(199); + sliderRigidity->setSingleStep(1); + sliderRigidity->setPageStep(10); + sliderRigidity->setValue(100); + sliderRigidity->setSliderPosition(100); + sliderRigidity->setOrientation(Qt::Horizontal); + tabWidget->addTab(Geometry, QString()); + tab = new QWidget(); + tab->setObjectName(QString::fromUtf8("tab")); + groupBox_3 = new QGroupBox(tab); + groupBox_3->setObjectName(QString::fromUtf8("groupBox_3")); + groupBox_3->setGeometry(QRect(250, 74, 571, 101)); + lineEditBeamRad = new QLineEdit(groupBox_3); + lineEditBeamRad->setObjectName(QString::fromUtf8("lineEditBeamRad")); + lineEditBeamRad->setGeometry(QRect(135, 59, 81, 22)); + lineEditBeamRad->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + label_21 = new QLabel(groupBox_3); + label_21->setObjectName(QString::fromUtf8("label_21")); + label_21->setGeometry(QRect(135, 40, 81, 16)); + label_21->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_21->setWordWrap(true); + beamRound = new QRadioButton(groupBox_3); + beamRound->setObjectName(QString::fromUtf8("beamRound")); + beamRound->setGeometry(QRect(20, 30, 95, 20)); + beamRound->setChecked(false); + beamSquare = new QRadioButton(groupBox_3); + beamSquare->setObjectName(QString::fromUtf8("beamSquare")); + beamSquare->setGeometry(QRect(20, 60, 95, 20)); + beamSquare->setChecked(true); + label_34 = new QLabel(groupBox_3); + label_34->setObjectName(QString::fromUtf8("label_34")); + label_34->setGeometry(QRect(222, 62, 31, 16)); + checkBox_VolumeSource = new QCheckBox(groupBox_3); + checkBox_VolumeSource->setObjectName(QString::fromUtf8("checkBox_VolumeSource")); + checkBox_VolumeSource->setGeometry(QRect(280, 31, 291, 17)); + checkBox_VolumeSource->setChecked(false); + groupBox_2 = new QGroupBox(tab); + groupBox_2->setObjectName(QString::fromUtf8("groupBox_2")); + groupBox_2->setGeometry(QRect(30, 74, 211, 101)); + lineEditSquareDim = new QLineEdit(groupBox_2); + lineEditSquareDim->setObjectName(QString::fromUtf8("lineEditSquareDim")); + lineEditSquareDim->setGeometry(QRect(20, 60, 121, 22)); + lineEditSquareDim->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + label_12 = new QLabel(groupBox_2); + label_12->setObjectName(QString::fromUtf8("label_12")); + label_12->setGeometry(QRect(20, 40, 101, 16)); + label_35 = new QLabel(groupBox_2); + label_35->setObjectName(QString::fromUtf8("label_35")); + label_35->setGeometry(QRect(147, 63, 31, 16)); + label_32 = new QLabel(tab); + label_32->setObjectName(QString::fromUtf8("label_32")); + label_32->setGeometry(QRect(30, 32, 761, 41)); + label_32->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_32->setWordWrap(true); + groupBox_4 = new QGroupBox(tab); + groupBox_4->setObjectName(QString::fromUtf8("groupBox_4")); + groupBox_4->setGeometry(QRect(30, 510, 271, 191)); + radioRiver = new QRadioButton(groupBox_4); + radioRiver->setObjectName(QString::fromUtf8("radioRiver")); + radioRiver->setGeometry(QRect(20, 60, 121, 20)); + radioCoast = new QRadioButton(groupBox_4); + radioCoast->setObjectName(QString::fromUtf8("radioCoast")); + radioCoast->setGeometry(QRect(20, 90, 111, 20)); + lineEdit_River = new QLineEdit(groupBox_4); + lineEdit_River->setObjectName(QString::fromUtf8("lineEdit_River")); + lineEdit_River->setGeometry(QRect(170, 60, 51, 22)); + lineEdit_River_2 = new QLineEdit(groupBox_4); + lineEdit_River_2->setObjectName(QString::fromUtf8("lineEdit_River_2")); + lineEdit_River_2->setGeometry(QRect(170, 90, 51, 22)); + lineEdit_Island = new QLineEdit(groupBox_4); + lineEdit_Island->setObjectName(QString::fromUtf8("lineEdit_Island")); + lineEdit_Island->setGeometry(QRect(170, 119, 51, 22)); + radioIsland = new QRadioButton(groupBox_4); + radioIsland->setObjectName(QString::fromUtf8("radioIsland")); + radioIsland->setGeometry(QRect(20, 122, 141, 20)); + lineEdit_Lake = new QLineEdit(groupBox_4); + lineEdit_Lake->setObjectName(QString::fromUtf8("lineEdit_Lake")); + lineEdit_Lake->setGeometry(QRect(170, 150, 51, 22)); + radioLake = new QRadioButton(groupBox_4); + radioLake->setObjectName(QString::fromUtf8("radioLake")); + radioLake->setGeometry(QRect(20, 152, 141, 20)); + radioButton = new QRadioButton(groupBox_4); + radioButton->setObjectName(QString::fromUtf8("radioButton")); + radioButton->setGeometry(QRect(20, 30, 71, 20)); + radioButton->setChecked(true); + label_70 = new QLabel(tab); + label_70->setObjectName(QString::fromUtf8("label_70")); + label_70->setGeometry(QRect(30, 482, 481, 21)); + label_70->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_70->setWordWrap(true); + groupBox_21 = new QGroupBox(tab); + groupBox_21->setObjectName(QString::fromUtf8("groupBox_21")); + groupBox_21->setGeometry(QRect(30, 200, 521, 131)); + label_84 = new QLabel(groupBox_21); + label_84->setObjectName(QString::fromUtf8("label_84")); + label_84->setGeometry(QRect(20, 30, 181, 21)); + label_84->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_84->setWordWrap(true); + checkBox_DomainCutoff = new QCheckBox(groupBox_21); + checkBox_DomainCutoff->setObjectName(QString::fromUtf8("checkBox_DomainCutoff")); + checkBox_DomainCutoff->setGeometry(QRect(20, 58, 91, 17)); + lineEditDomainFactor = new QLineEdit(groupBox_21); + lineEditDomainFactor->setObjectName(QString::fromUtf8("lineEditDomainFactor")); + lineEditDomainFactor->setGeometry(QRect(106, 55, 41, 22)); + lineEditDomainFactor->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + label_86 = new QLabel(groupBox_21); + label_86->setObjectName(QString::fromUtf8("label_86")); + label_86->setGeometry(QRect(156, 58, 111, 16)); + lineEditDomainMeters = new QLineEdit(groupBox_21); + lineEditDomainMeters->setObjectName(QString::fromUtf8("lineEditDomainMeters")); + lineEditDomainMeters->setGeometry(QRect(104, 87, 41, 22)); + lineEditDomainMeters->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + label_87 = new QLabel(groupBox_21); + label_87->setObjectName(QString::fromUtf8("label_87")); + label_87->setGeometry(QRect(155, 90, 121, 16)); + checkBox_DomainCutoffMeters = new QCheckBox(groupBox_21); + checkBox_DomainCutoffMeters->setObjectName(QString::fromUtf8("checkBox_DomainCutoffMeters")); + checkBox_DomainCutoffMeters->setGeometry(QRect(20, 90, 91, 17)); + label_90 = new QLabel(groupBox_21); + label_90->setObjectName(QString::fromUtf8("label_90")); + label_90->setGeometry(QRect(320, 30, 181, 21)); + label_90->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_90->setWordWrap(true); + checkBox_ReflectiveBoundaries = new QCheckBox(groupBox_21); + checkBox_ReflectiveBoundaries->setObjectName(QString::fromUtf8("checkBox_ReflectiveBoundaries")); + checkBox_ReflectiveBoundaries->setGeometry(QRect(320, 60, 171, 17)); + checkBox_PeriodicBoundaries = new QCheckBox(groupBox_21); + checkBox_PeriodicBoundaries->setObjectName(QString::fromUtf8("checkBox_PeriodicBoundaries")); + checkBox_PeriodicBoundaries->setGeometry(QRect(320, 90, 171, 17)); + groupBox_27 = new QGroupBox(tab); + groupBox_27->setObjectName(QString::fromUtf8("groupBox_27")); + groupBox_27->setGeometry(QRect(30, 350, 281, 101)); + checkBox_HEModel = new QCheckBox(groupBox_27); + checkBox_HEModel->setObjectName(QString::fromUtf8("checkBox_HEModel")); + checkBox_HEModel->setGeometry(QRect(10, 20, 261, 31)); + checkBox_HEModel->setChecked(true); + checkBox_activateThermal = new QCheckBox(groupBox_27); + checkBox_activateThermal->setObjectName(QString::fromUtf8("checkBox_activateThermal")); + checkBox_activateThermal->setGeometry(QRect(10, 60, 231, 17)); + checkBox_activateThermal->setChecked(false); + tabWidget->addTab(tab, QString()); + tab_4 = new QWidget(); + tab_4->setObjectName(QString::fromUtf8("tab_4")); + horizontalSliderFPMoist = new QSlider(tab_4); + horizontalSliderFPMoist->setObjectName(QString::fromUtf8("horizontalSliderFPMoist")); + horizontalSliderFPMoist->setGeometry(QRect(90, 680, 201, 19)); + horizontalSliderFPMoist->setVisible(false); + horizontalSliderFPMoist->setMinimum(4); + horizontalSliderFPMoist->setOrientation(Qt::Horizontal); + horizontalSliderFPHum = new QSlider(tab_4); + horizontalSliderFPHum->setObjectName(QString::fromUtf8("horizontalSliderFPHum")); + horizontalSliderFPHum->setGeometry(QRect(90, 710, 201, 19)); + horizontalSliderFPHum->setVisible(false); + horizontalSliderFPHum->setMinimum(1); + horizontalSliderFPHum->setMaximum(30); + horizontalSliderFPHum->setSingleStep(1); + horizontalSliderFPHum->setOrientation(Qt::Horizontal); + labelFPMoist = new QLabel(tab_4); + labelFPMoist->setObjectName(QString::fromUtf8("labelFPMoist")); + labelFPMoist->setGeometry(QRect(300, 680, 71, 16)); + labelFPMoist->setVisible(false); + labelFPHum = new QLabel(tab_4); + labelFPHum->setObjectName(QString::fromUtf8("labelFPHum")); + labelFPHum->setGeometry(QRect(300, 710, 51, 16)); + labelFPHum->setVisible(false); + groupBox_9 = new QGroupBox(tab_4); + groupBox_9->setObjectName(QString::fromUtf8("groupBox_9")); + groupBox_9->setGeometry(QRect(440, 140, 401, 391)); + label_36 = new QLabel(groupBox_9); + label_36->setObjectName(QString::fromUtf8("label_36")); + label_36->setGeometry(QRect(20, 33, 381, 31)); + label_36->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_36->setWordWrap(true); + lineEditDetRad = new QLineEdit(groupBox_9); + lineEditDetRad->setObjectName(QString::fromUtf8("lineEditDetRad")); + lineEditDetRad->setGeometry(QRect(180, 74, 51, 22)); + lineEditDetX = new QLineEdit(groupBox_9); + lineEditDetX->setObjectName(QString::fromUtf8("lineEditDetX")); + lineEditDetX->setGeometry(QRect(30, 74, 51, 22)); + label_38 = new QLabel(groupBox_9); + label_38->setObjectName(QString::fromUtf8("label_38")); + label_38->setGeometry(QRect(90, 76, 21, 16)); + label_14 = new QLabel(groupBox_9); + label_14->setObjectName(QString::fromUtf8("label_14")); + label_14->setGeometry(QRect(180, 54, 71, 16)); + label_37 = new QLabel(groupBox_9); + label_37->setObjectName(QString::fromUtf8("label_37")); + label_37->setGeometry(QRect(20, 76, 21, 16)); + label_13 = new QLabel(groupBox_9); + label_13->setObjectName(QString::fromUtf8("label_13")); + label_13->setGeometry(QRect(20, 54, 151, 16)); + lineEditDety = new QLineEdit(groupBox_9); + lineEditDety->setObjectName(QString::fromUtf8("lineEditDety")); + lineEditDety->setGeometry(QRect(100, 74, 51, 22)); + checkBoxTransparent = new QCheckBox(groupBox_9); + checkBoxTransparent->setObjectName(QString::fromUtf8("checkBoxTransparent")); + checkBoxTransparent->setGeometry(QRect(20, 290, 101, 20)); + checkBoxTransparent->setChecked(true); + label_39 = new QLabel(groupBox_9); + label_39->setObjectName(QString::fromUtf8("label_39")); + label_39->setGeometry(QRect(20, 270, 371, 21)); + label_39->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_39->setWordWrap(true); + groupBox_13 = new QGroupBox(groupBox_9); + groupBox_13->setObjectName(QString::fromUtf8("groupBox_13")); + groupBox_13->setGeometry(QRect(20, 112, 291, 141)); + radioButton_Sphere = new QRadioButton(groupBox_13); + radioButton_Sphere->setObjectName(QString::fromUtf8("radioButton_Sphere")); + radioButton_Sphere->setGeometry(QRect(20, 20, 111, 17)); + radioButton_Sphere->setChecked(true); + radioButton_Cylinder = new QRadioButton(groupBox_13); + radioButton_Cylinder->setObjectName(QString::fromUtf8("radioButton_Cylinder")); + radioButton_Cylinder->setGeometry(QRect(20, 50, 131, 17)); + radioButton_Cylinder->setChecked(false); + radioButton_ySheet = new QRadioButton(groupBox_13); + radioButton_ySheet->setObjectName(QString::fromUtf8("radioButton_ySheet")); + radioButton_ySheet->setGeometry(QRect(20, 80, 141, 17)); + radioButton_ySheet->setChecked(false); + label_83 = new QLabel(groupBox_13); + label_83->setObjectName(QString::fromUtf8("label_83")); + label_83->setGeometry(QRect(161, 84, 141, 21)); + label_83->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_83->setWordWrap(true); + radioButton_xSheet = new QRadioButton(groupBox_13); + radioButton_xSheet->setObjectName(QString::fromUtf8("radioButton_xSheet")); + radioButton_xSheet->setGeometry(QRect(20, 110, 141, 17)); + radioButton_xSheet->setChecked(false); + groupBox_19 = new QGroupBox(groupBox_13); + groupBox_19->setObjectName(QString::fromUtf8("groupBox_19")); + groupBox_19->setGeometry(QRect(150, 52, 4, 80)); + groupBox_16 = new QGroupBox(groupBox_9); + groupBox_16->setObjectName(QString::fromUtf8("groupBox_16")); + groupBox_16->setGeometry(QRect(10, 320, 381, 61)); + radioButton_detectorEnergyBand = new QRadioButton(groupBox_16); + radioButton_detectorEnergyBand->setObjectName(QString::fromUtf8("radioButton_detectorEnergyBand")); + radioButton_detectorEnergyBand->setGeometry(QRect(20, 30, 141, 17)); + radioButton_detectorEnergyBand->setChecked(true); + radioButton_detectorRealistic = new QRadioButton(groupBox_16); + radioButton_detectorRealistic->setObjectName(QString::fromUtf8("radioButton_detectorRealistic")); + radioButton_detectorRealistic->setGeometry(QRect(210, 30, 141, 17)); + lineEditDetLength = new QLineEdit(groupBox_9); + lineEditDetLength->setObjectName(QString::fromUtf8("lineEditDetLength")); + lineEditDetLength->setEnabled(true); + lineEditDetLength->setGeometry(QRect(250, 74, 51, 22)); + lineEditDetLength->setFrame(true); + label_85 = new QLabel(groupBox_9); + label_85->setObjectName(QString::fromUtf8("label_85")); + label_85->setGeometry(QRect(250, 54, 121, 16)); + groupBox_10 = new QGroupBox(tab_4); + groupBox_10->setObjectName(QString::fromUtf8("groupBox_10")); + groupBox_10->setGeometry(QRect(10, 140, 411, 391)); + label_59 = new QLabel(groupBox_10); + label_59->setObjectName(QString::fromUtf8("label_59")); + label_59->setGeometry(QRect(20, 33, 211, 21)); + label_59->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_59->setWordWrap(true); + lineEditScotoma_2 = new QLineEdit(groupBox_10); + lineEditScotoma_2->setObjectName(QString::fromUtf8("lineEditScotoma_2")); + lineEditScotoma_2->setGeometry(QRect(194, 50, 41, 20)); + checkBox = new QCheckBox(groupBox_10); + checkBox->setObjectName(QString::fromUtf8("checkBox")); + checkBox->setGeometry(QRect(20, 53, 191, 17)); + checkBox_NoMultipleScattering = new QCheckBox(groupBox_10); + checkBox_NoMultipleScattering->setObjectName(QString::fromUtf8("checkBox_NoMultipleScattering")); + checkBox_NoMultipleScattering->setGeometry(QRect(20, 133, 251, 17)); + label_66 = new QLabel(groupBox_10); + label_66->setObjectName(QString::fromUtf8("label_66")); + label_66->setGeometry(QRect(20, 113, 211, 21)); + label_66->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_66->setWordWrap(true); + checkBox_TrackAllLayers = new QCheckBox(groupBox_10); + checkBox_TrackAllLayers->setObjectName(QString::fromUtf8("checkBox_TrackAllLayers")); + checkBox_TrackAllLayers->setGeometry(QRect(20, 210, 251, 17)); + label_69 = new QLabel(groupBox_10); + label_69->setObjectName(QString::fromUtf8("label_69")); + label_69->setGeometry(QRect(20, 176, 341, 31)); + label_69->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_69->setWordWrap(true); + groupBox_15 = new QGroupBox(groupBox_10); + groupBox_15->setObjectName(QString::fromUtf8("groupBox_15")); + groupBox_15->setGeometry(QRect(10, 320, 391, 61)); + radioButton_detectorLayerEnergyBand = new QRadioButton(groupBox_15); + radioButton_detectorLayerEnergyBand->setObjectName(QString::fromUtf8("radioButton_detectorLayerEnergyBand")); + radioButton_detectorLayerEnergyBand->setGeometry(QRect(20, 30, 141, 17)); + radioButton_detectorLayerEnergyBand->setChecked(true); + radioButton_detectorLayerRealistic = new QRadioButton(groupBox_15); + radioButton_detectorLayerRealistic->setObjectName(QString::fromUtf8("radioButton_detectorLayerRealistic")); + radioButton_detectorLayerRealistic->setGeometry(QRect(210, 30, 141, 17)); + groupBox_14 = new QGroupBox(tab_4); + groupBox_14->setObjectName(QString::fromUtf8("groupBox_14")); + groupBox_14->setGeometry(QRect(10, 20, 831, 101)); + label_3 = new QLabel(groupBox_14); + label_3->setObjectName(QString::fromUtf8("label_3")); + label_3->setGeometry(QRect(20, 60, 371, 31)); + label_41 = new QLabel(groupBox_14); + label_41->setObjectName(QString::fromUtf8("label_41")); + label_41->setGeometry(QRect(88, 46, 21, 16)); + label_22 = new QLabel(groupBox_14); + label_22->setObjectName(QString::fromUtf8("label_22")); + label_22->setGeometry(QRect(20, 24, 251, 16)); + label_22->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_22->setWordWrap(true); + label_40 = new QLabel(groupBox_14); + label_40->setObjectName(QString::fromUtf8("label_40")); + label_40->setGeometry(QRect(170, 46, 41, 16)); + lineEditTHLhigh = new QLineEdit(groupBox_14); + lineEditTHLhigh->setObjectName(QString::fromUtf8("lineEditTHLhigh")); + lineEditTHLhigh->setGeometry(QRect(110, 43, 51, 22)); + lineEditTHLlow = new QLineEdit(groupBox_14); + lineEditTHLlow->setObjectName(QString::fromUtf8("lineEditTHLlow")); + lineEditTHLlow->setGeometry(QRect(22, 43, 61, 22)); + lineEditScotoma = new QLineEdit(groupBox_14); + lineEditScotoma->setObjectName(QString::fromUtf8("lineEditScotoma")); + lineEditScotoma->setGeometry(QRect(380, 60, 41, 20)); + label_51 = new QLabel(groupBox_14); + label_51->setObjectName(QString::fromUtf8("label_51")); + label_51->setGeometry(QRect(380, 40, 231, 16)); + label_51->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_51->setWordWrap(true); + label_52 = new QLabel(groupBox_14); + label_52->setObjectName(QString::fromUtf8("label_52")); + label_52->setGeometry(QRect(380, 20, 181, 21)); + label_52->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_52->setWordWrap(true); + label_79 = new QLabel(groupBox_14); + label_79->setObjectName(QString::fromUtf8("label_79")); + label_79->setGeometry(QRect(603, 20, 181, 21)); + label_79->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_79->setWordWrap(true); + lineEditAntiScotoma = new QLineEdit(groupBox_14); + lineEditAntiScotoma->setObjectName(QString::fromUtf8("lineEditAntiScotoma")); + lineEditAntiScotoma->setGeometry(QRect(603, 60, 41, 20)); + label_80 = new QLabel(groupBox_14); + label_80->setObjectName(QString::fromUtf8("label_80")); + label_80->setGeometry(QRect(603, 40, 221, 16)); + label_80->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_80->setWordWrap(true); + label_74 = new QLabel(tab_4); + label_74->setObjectName(QString::fromUtf8("label_74")); + label_74->setGeometry(QRect(20, 550, 731, 51)); + label_74->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_74->setWordWrap(true); + tabWidget->addTab(tab_4, QString()); + tab_2 = new QWidget(); + tab_2->setObjectName(QString::fromUtf8("tab_2")); + label_44 = new QLabel(tab_2); + label_44->setObjectName(QString::fromUtf8("label_44")); + label_44->setGeometry(QRect(510, 158, 41, 20)); + label_44->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + spinBox_2 = new QSpinBox(tab_2); + spinBox_2->setObjectName(QString::fromUtf8("spinBox_2")); + spinBox_2->setGeometry(QRect(551, 158, 42, 22)); + spinBox_2->setMinimum(1); + spinBox_2->setMaximum(8); + spinBox_2->setValue(6); + pushButton_2 = new QPushButton(tab_2); + pushButton_2->setObjectName(QString::fromUtf8("pushButton_2")); + pushButton_2->setGeometry(QRect(520, 80, 111, 28)); + label_8 = new QLabel(tab_2); + label_8->setObjectName(QString::fromUtf8("label_8")); + label_8->setGeometry(QRect(30, 28, 541, 51)); + label_8->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_8->setWordWrap(true); + checkBoxBasicSpectrum = new QCheckBox(tab_2); + checkBoxBasicSpectrum->setObjectName(QString::fromUtf8("checkBoxBasicSpectrum")); + checkBoxBasicSpectrum->setGeometry(QRect(520, 248, 211, 20)); + label = new QLabel(tab_2); + label->setObjectName(QString::fromUtf8("label")); + label->setGeometry(QRect(520, 135, 151, 20)); + label->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter); + WidgetSpectrum = new QCustomPlot(tab_2); + WidgetSpectrum->setObjectName(QString::fromUtf8("WidgetSpectrum")); + WidgetSpectrum->setGeometry(QRect(30, 80, 471, 271)); + groupBox_6 = new QGroupBox(tab_2); + groupBox_6->setObjectName(QString::fromUtf8("groupBox_6")); + groupBox_6->setGeometry(QRect(30, 410, 571, 271)); + customPlotFP = new QCustomPlot(groupBox_6); + customPlotFP->setObjectName(QString::fromUtf8("customPlotFP")); + customPlotFP->setGeometry(QRect(20, 20, 441, 241)); + pushButton_ActivateFP = new QPushButton(customPlotFP); + pushButton_ActivateFP->setObjectName(QString::fromUtf8("pushButton_ActivateFP")); + pushButton_ActivateFP->setGeometry(QRect(330, 10, 91, 23)); + pushButton_ActivateFP->setFlat(false); + horizontalSliderFPHum_2 = new QSlider(groupBox_6); + horizontalSliderFPHum_2->setObjectName(QString::fromUtf8("horizontalSliderFPHum_2")); + horizontalSliderFPHum_2->setGeometry(QRect(470, 98, 21, 141)); + horizontalSliderFPHum_2->setMinimum(1); + horizontalSliderFPHum_2->setMaximum(600); + horizontalSliderFPHum_2->setSingleStep(1); + horizontalSliderFPHum_2->setValue(1); + horizontalSliderFPHum_2->setOrientation(Qt::Vertical); + label_48 = new QLabel(groupBox_6); + label_48->setObjectName(QString::fromUtf8("label_48")); + label_48->setGeometry(QRect(500, 100, 61, 41)); + label_48->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_48->setWordWrap(true); + label_FPIntegral = new QLabel(groupBox_6); + label_FPIntegral->setObjectName(QString::fromUtf8("label_FPIntegral")); + label_FPIntegral->setGeometry(QRect(500, 133, 51, 21)); + labelIntegral = new QLabel(groupBox_6); + labelIntegral->setObjectName(QString::fromUtf8("labelIntegral")); + labelIntegral->setGeometry(QRect(500, 190, 51, 16)); + QFont font; + font.setBold(false); + labelIntegral->setFont(font); + label_49 = new QLabel(groupBox_6); + label_49->setObjectName(QString::fromUtf8("label_49")); + label_49->setGeometry(QRect(500, 170, 61, 16)); + checkBoxFPLog = new QCheckBox(groupBox_6); + checkBoxFPLog->setObjectName(QString::fromUtf8("checkBoxFPLog")); + checkBoxFPLog->setGeometry(QRect(470, 33, 51, 17)); + label_73 = new QLabel(tab_2); + label_73->setObjectName(QString::fromUtf8("label_73")); + label_73->setGeometry(QRect(30, 372, 571, 51)); + label_73->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_73->setWordWrap(true); + tabWidget->addTab(tab_2, QString()); + tab_5 = new QWidget(); + tab_5->setObjectName(QString::fromUtf8("tab_5")); + lineEdit_DetectorFile = new QLineEdit(tab_5); + lineEdit_DetectorFile->setObjectName(QString::fromUtf8("lineEdit_DetectorFile")); + lineEdit_DetectorFile->setEnabled(true); + lineEdit_DetectorFile->setGeometry(QRect(20, 220, 561, 22)); + lineEdit_DetectorFile->setAutoFillBackground(false); + label_15 = new QLabel(tab_5); + label_15->setObjectName(QString::fromUtf8("label_15")); + label_15->setGeometry(QRect(20, 80, 311, 16)); + lineEdit_WorkFolder = new QLineEdit(tab_5); + lineEdit_WorkFolder->setObjectName(QString::fromUtf8("lineEdit_WorkFolder")); + lineEdit_WorkFolder->setGeometry(QRect(20, 280, 561, 22)); + lineEdit_OutputFolder = new QLineEdit(tab_5); + lineEdit_OutputFolder->setObjectName(QString::fromUtf8("lineEdit_OutputFolder")); + lineEdit_OutputFolder->setGeometry(QRect(20, 340, 561, 22)); + label_25 = new QLabel(tab_5); + label_25->setObjectName(QString::fromUtf8("label_25")); + label_25->setGeometry(QRect(20, 200, 271, 16)); + label_17 = new QLabel(tab_5); + label_17->setObjectName(QString::fromUtf8("label_17")); + label_17->setGeometry(QRect(20, 320, 131, 16)); + lineEdit_CrosssectionFolder = new QLineEdit(tab_5); + lineEdit_CrosssectionFolder->setObjectName(QString::fromUtf8("lineEdit_CrosssectionFolder")); + lineEdit_CrosssectionFolder->setGeometry(QRect(20, 100, 561, 22)); + label_16 = new QLabel(tab_5); + label_16->setObjectName(QString::fromUtf8("label_16")); + label_16->setGeometry(QRect(20, 140, 451, 16)); + label_30 = new QLabel(tab_5); + label_30->setObjectName(QString::fromUtf8("label_30")); + label_30->setGeometry(QRect(20, 260, 151, 16)); + lineEdit_InputSpectrumFolder = new QLineEdit(tab_5); + lineEdit_InputSpectrumFolder->setObjectName(QString::fromUtf8("lineEdit_InputSpectrumFolder")); + lineEdit_InputSpectrumFolder->setGeometry(QRect(20, 160, 561, 22)); + label_33 = new QLabel(tab_5); + label_33->setObjectName(QString::fromUtf8("label_33")); + label_33->setGeometry(QRect(20, 18, 511, 51)); + label_33->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_33->setWordWrap(true); + tabWidget->addTab(tab_5, QString()); + tab_3 = new QWidget(); + tab_3->setObjectName(QString::fromUtf8("tab_3")); + groupBox_7 = new QGroupBox(tab_3); + groupBox_7->setObjectName(QString::fromUtf8("groupBox_7")); + groupBox_7->setGeometry(QRect(20, 500, 281, 181)); + radioButton_expHeat = new QRadioButton(groupBox_7); + radioButton_expHeat->setObjectName(QString::fromUtf8("radioButton_expHeat")); + radioButton_expHeat->setGeometry(QRect(20, 28, 82, 17)); + radioButton_expHeat->setChecked(true); + radioButton_expGray = new QRadioButton(groupBox_7); + radioButton_expGray->setObjectName(QString::fromUtf8("radioButton_expGray")); + radioButton_expGray->setGeometry(QRect(170, 30, 101, 17)); + radioButton_expHeatInv = new QRadioButton(groupBox_7); + radioButton_expHeatInv->setObjectName(QString::fromUtf8("radioButton_expHeatInv")); + radioButton_expHeatInv->setGeometry(QRect(20, 58, 141, 17)); + radioButton_expCool = new QRadioButton(groupBox_7); + radioButton_expCool->setObjectName(QString::fromUtf8("radioButton_expCool")); + radioButton_expCool->setGeometry(QRect(170, 90, 101, 17)); + radioButton_expRainbow = new QRadioButton(groupBox_7); + radioButton_expRainbow->setObjectName(QString::fromUtf8("radioButton_expRainbow")); + radioButton_expRainbow->setGeometry(QRect(20, 88, 82, 17)); + radioButton_expDeviation = new QRadioButton(groupBox_7); + radioButton_expDeviation->setObjectName(QString::fromUtf8("radioButton_expDeviation")); + radioButton_expDeviation->setGeometry(QRect(170, 60, 82, 17)); + spinBoxRebinning = new QSpinBox(groupBox_7); + spinBoxRebinning->setObjectName(QString::fromUtf8("spinBoxRebinning")); + spinBoxRebinning->setGeometry(QRect(20, 140, 42, 22)); + spinBoxRebinning->setMinimum(1); + spinBoxRebinning->setMaximum(10); + label_53 = new QLabel(groupBox_7); + label_53->setObjectName(QString::fromUtf8("label_53")); + label_53->setGeometry(QRect(20, 122, 111, 16)); + checkBoxFileOutputPDF = new QCheckBox(groupBox_7); + checkBoxFileOutputPDF->setObjectName(QString::fromUtf8("checkBoxFileOutputPDF")); + checkBoxFileOutputPDF->setGeometry(QRect(170, 130, 151, 20)); + label_43 = new QLabel(tab_3); + label_43->setObjectName(QString::fromUtf8("label_43")); + label_43->setGeometry(QRect(20, 20, 321, 21)); + label_43->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_43->setWordWrap(true); + groupBox_22 = new QGroupBox(tab_3); + groupBox_22->setObjectName(QString::fromUtf8("groupBox_22")); + groupBox_22->setGeometry(QRect(340, 50, 281, 131)); + checkBoxDetectorDistanceData = new QCheckBox(groupBox_22); + checkBoxDetectorDistanceData->setObjectName(QString::fromUtf8("checkBoxDetectorDistanceData")); + checkBoxDetectorDistanceData->setGeometry(QRect(20, 75, 241, 17)); + checkBoxDetectorDistanceData->setChecked(false); + checkBoxDetectorLayerDistanceData = new QCheckBox(groupBox_22); + checkBoxDetectorLayerDistanceData->setObjectName(QString::fromUtf8("checkBoxDetectorLayerDistanceData")); + checkBoxDetectorLayerDistanceData->setGeometry(QRect(20, 95, 251, 17)); + checkBoxDetectorLayerDistanceData->setChecked(false); + checkBoxTravelDistGraph = new QCheckBox(groupBox_22); + checkBoxTravelDistGraph->setObjectName(QString::fromUtf8("checkBoxTravelDistGraph")); + checkBoxTravelDistGraph->setGeometry(QRect(20, 25, 171, 17)); + checkBoxTravelDistGraph->setChecked(true); + checkBoxLogTravelDistance = new QCheckBox(groupBox_22); + checkBoxLogTravelDistance->setObjectName(QString::fromUtf8("checkBoxLogTravelDistance")); + checkBoxLogTravelDistance->setGeometry(QRect(50, 45, 101, 17)); + groupBox_23 = new QGroupBox(tab_3); + groupBox_23->setObjectName(QString::fromUtf8("groupBox_23")); + groupBox_23->setGeometry(QRect(340, 200, 281, 191)); + checkBoxExportAllTracks = new QCheckBox(groupBox_23); + checkBoxExportAllTracks->setObjectName(QString::fromUtf8("checkBoxExportAllTracks")); + checkBoxExportAllTracks->setGeometry(QRect(20, 130, 241, 20)); + checkBoxFileOutput = new QCheckBox(groupBox_23); + checkBoxFileOutput->setObjectName(QString::fromUtf8("checkBoxFileOutput")); + checkBoxFileOutput->setGeometry(QRect(20, 25, 251, 20)); + checkBoxFileOutput2 = new QCheckBox(groupBox_23); + checkBoxFileOutput2->setObjectName(QString::fromUtf8("checkBoxFileOutput2")); + checkBoxFileOutput2->setGeometry(QRect(20, 50, 251, 20)); + label_89 = new QLabel(groupBox_23); + label_89->setObjectName(QString::fromUtf8("label_89")); + label_89->setGeometry(QRect(20, 160, 251, 21)); + label_89->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_89->setWordWrap(true); + checkBoxFileOutput3 = new QCheckBox(groupBox_23); + checkBoxFileOutput3->setObjectName(QString::fromUtf8("checkBoxFileOutput3")); + checkBoxFileOutput3->setGeometry(QRect(20, 90, 251, 20)); + groupBox_24 = new QGroupBox(tab_3); + groupBox_24->setObjectName(QString::fromUtf8("groupBox_24")); + groupBox_24->setGeometry(QRect(340, 400, 281, 181)); + checkBoxWarnMAterial = new QCheckBox(groupBox_24); + checkBoxWarnMAterial->setObjectName(QString::fromUtf8("checkBoxWarnMAterial")); + checkBoxWarnMAterial->setGeometry(QRect(20, 147, 221, 20)); + checkBoxWarnMAterial->setChecked(false); + checkBoxFileOutputPDF_2 = new QCheckBox(groupBox_24); + checkBoxFileOutputPDF_2->setObjectName(QString::fromUtf8("checkBoxFileOutputPDF_2")); + checkBoxFileOutputPDF_2->setGeometry(QRect(20, 26, 261, 20)); + checkBoxFileOutputPDF_2->setChecked(true); + spinBoxSaveEvery = new QSpinBox(groupBox_24); + spinBoxSaveEvery->setObjectName(QString::fromUtf8("spinBoxSaveEvery")); + spinBoxSaveEvery->setGeometry(QRect(142, 105, 42, 22)); + spinBoxSaveEvery->setMinimum(3); + spinBoxSaveEvery->setMaximum(8); + spinBoxSaveEvery->setValue(5); + label_62 = new QLabel(groupBox_24); + label_62->setObjectName(QString::fromUtf8("label_62")); + label_62->setGeometry(QRect(120, 107, 31, 16)); + label_63 = new QLabel(groupBox_24); + label_63->setObjectName(QString::fromUtf8("label_63")); + label_63->setGeometry(QRect(197, 107, 91, 16)); + checkBoxCreateFolder = new QCheckBox(groupBox_24); + checkBoxCreateFolder->setObjectName(QString::fromUtf8("checkBoxCreateFolder")); + checkBoxCreateFolder->setGeometry(QRect(20, 76, 261, 20)); + checkBoxCreateFolder->setChecked(false); + checkBoxSaveEvery = new QCheckBox(groupBox_24); + checkBoxSaveEvery->setObjectName(QString::fromUtf8("checkBoxSaveEvery")); + checkBoxSaveEvery->setGeometry(QRect(20, 105, 101, 20)); + checkBoxSaveEvery->setChecked(false); + groupBox_26 = new QGroupBox(tab_3); + groupBox_26->setObjectName(QString::fromUtf8("groupBox_26")); + groupBox_26->setGeometry(QRect(20, 50, 281, 431)); + checkBoxDetectorOriginData = new QCheckBox(groupBox_26); + checkBoxDetectorOriginData->setObjectName(QString::fromUtf8("checkBoxDetectorOriginData")); + checkBoxDetectorOriginData->setGeometry(QRect(20, 398, 221, 17)); + checkBoxDetectorOriginData->setChecked(false); + checkBoxHighResTrackingData = new QCheckBox(groupBox_26); + checkBoxHighResTrackingData->setObjectName(QString::fromUtf8("checkBoxHighResTrackingData")); + checkBoxHighResTrackingData->setGeometry(QRect(20, 328, 161, 17)); + checkBoxHighResTrackingData->setChecked(false); + checkBoxDetectorOriginMap = new QCheckBox(groupBox_26); + checkBoxDetectorOriginMap->setObjectName(QString::fromUtf8("checkBoxDetectorOriginMap")); + checkBoxDetectorOriginMap->setGeometry(QRect(20, 378, 221, 17)); + checkBoxDetectorOriginMap->setChecked(true); + checkBoxSelectedMap = new QCheckBox(groupBox_26); + checkBoxSelectedMap->setObjectName(QString::fromUtf8("checkBoxSelectedMap")); + checkBoxSelectedMap->setGeometry(QRect(20, 178, 161, 17)); + checkBoxSelectedMap->setChecked(true); + checkBoxSelectedData = new QCheckBox(groupBox_26); + checkBoxSelectedData->setObjectName(QString::fromUtf8("checkBoxSelectedData")); + checkBoxSelectedData->setGeometry(QRect(20, 198, 161, 17)); + checkBoxSelectedData->setChecked(false); + checkBoxThermalMap = new QCheckBox(groupBox_26); + checkBoxThermalMap->setObjectName(QString::fromUtf8("checkBoxThermalMap")); + checkBoxThermalMap->setGeometry(QRect(20, 228, 161, 17)); + checkBoxThermalMap->setChecked(false); + label_88 = new QLabel(groupBox_26); + label_88->setObjectName(QString::fromUtf8("label_88")); + label_88->setGeometry(QRect(20, 358, 171, 21)); + label_88->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_88->setWordWrap(true); + checkBoxIntermediateData = new QCheckBox(groupBox_26); + checkBoxIntermediateData->setObjectName(QString::fromUtf8("checkBoxIntermediateData")); + checkBoxIntermediateData->setGeometry(QRect(20, 98, 181, 17)); + checkBoxIntermediateData->setChecked(false); + label_54 = new QLabel(groupBox_26); + label_54->setObjectName(QString::fromUtf8("label_54")); + label_54->setGeometry(QRect(20, 288, 171, 21)); + label_54->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_54->setWordWrap(true); + checkBoxEpithermalMap = new QCheckBox(groupBox_26); + checkBoxEpithermalMap->setObjectName(QString::fromUtf8("checkBoxEpithermalMap")); + checkBoxEpithermalMap->setGeometry(QRect(20, 28, 141, 17)); + checkBoxEpithermalMap->setChecked(false); + checkBoxThermalData = new QCheckBox(groupBox_26); + checkBoxThermalData->setObjectName(QString::fromUtf8("checkBoxThermalData")); + checkBoxThermalData->setGeometry(QRect(20, 248, 161, 17)); + checkBoxThermalData->setChecked(false); + checkBoxFastMap = new QCheckBox(groupBox_26); + checkBoxFastMap->setObjectName(QString::fromUtf8("checkBoxFastMap")); + checkBoxFastMap->setGeometry(QRect(20, 128, 141, 17)); + checkBoxFastMap->setChecked(false); + checkBoxFastData = new QCheckBox(groupBox_26); + checkBoxFastData->setObjectName(QString::fromUtf8("checkBoxFastData")); + checkBoxFastData->setGeometry(QRect(20, 148, 141, 17)); + checkBoxFastData->setChecked(false); + checkBoxEpithermalData = new QCheckBox(groupBox_26); + checkBoxEpithermalData->setObjectName(QString::fromUtf8("checkBoxEpithermalData")); + checkBoxEpithermalData->setGeometry(QRect(20, 48, 141, 17)); + checkBoxEpithermalData->setChecked(false); + checkBoxIntermediateMap = new QCheckBox(groupBox_26); + checkBoxIntermediateMap->setObjectName(QString::fromUtf8("checkBoxIntermediateMap")); + checkBoxIntermediateMap->setGeometry(QRect(20, 78, 171, 17)); + checkBoxIntermediateMap->setChecked(false); + checkBoxTrackingData = new QCheckBox(groupBox_26); + checkBoxTrackingData->setObjectName(QString::fromUtf8("checkBoxTrackingData")); + checkBoxTrackingData->setGeometry(QRect(20, 308, 161, 17)); + checkBoxTrackingData->setChecked(false); + tabWidget->addTab(tab_3, QString()); + tab_6 = new QWidget(); + tab_6->setObjectName(QString::fromUtf8("tab_6")); + groupBox_5 = new QGroupBox(tab_6); + groupBox_5->setObjectName(QString::fromUtf8("groupBox_5")); + groupBox_5->setGeometry(QRect(530, 20, 301, 241)); + groupBox_5->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter); + groupBox_5->setFlat(false); + radioButton_map = new QRadioButton(groupBox_5); + radioButton_map->setObjectName(QString::fromUtf8("radioButton_map")); + radioButton_map->setGeometry(QRect(20, 50, 121, 20)); + radioButton_mapInter = new QRadioButton(groupBox_5); + radioButton_mapInter->setObjectName(QString::fromUtf8("radioButton_mapInter")); + radioButton_mapInter->setGeometry(QRect(20, 80, 131, 20)); + radioButton_mapFast = new QRadioButton(groupBox_5); + radioButton_mapFast->setObjectName(QString::fromUtf8("radioButton_mapFast")); + radioButton_mapFast->setGeometry(QRect(20, 110, 131, 20)); + radioButton_mapAlbedo = new QRadioButton(groupBox_5); + radioButton_mapAlbedo->setObjectName(QString::fromUtf8("radioButton_mapAlbedo")); + radioButton_mapAlbedo->setGeometry(QRect(20, 140, 141, 20)); + radioButton_mapAlbedo->setCheckable(true); + radioButton_mapAlbedo->setChecked(true); + checkBoxGradient2 = new QCheckBox(groupBox_5); + checkBoxGradient2->setObjectName(QString::fromUtf8("checkBoxGradient2")); + checkBoxGradient2->setGeometry(QRect(20, 210, 151, 17)); + radioButton_mapTrackAlbedo = new QRadioButton(groupBox_5); + radioButton_mapTrackAlbedo->setObjectName(QString::fromUtf8("radioButton_mapTrackAlbedo")); + radioButton_mapTrackAlbedo->setGeometry(QRect(160, 140, 141, 20)); + radioButton_mapTrackAlbedo->setCheckable(true); + radioButton_mapTrackAlbedo->setChecked(false); + label_60 = new QLabel(groupBox_5); + label_60->setObjectName(QString::fromUtf8("label_60")); + label_60->setGeometry(QRect(20, 24, 101, 16)); + label_61 = new QLabel(groupBox_5); + label_61->setObjectName(QString::fromUtf8("label_61")); + label_61->setGeometry(QRect(160, 26, 101, 16)); + radioButton_mapTrackFast = new QRadioButton(groupBox_5); + radioButton_mapTrackFast->setObjectName(QString::fromUtf8("radioButton_mapTrackFast")); + radioButton_mapTrackFast->setGeometry(QRect(160, 110, 131, 20)); + radioButton_mapTrackInter = new QRadioButton(groupBox_5); + radioButton_mapTrackInter->setObjectName(QString::fromUtf8("radioButton_mapTrackInter")); + radioButton_mapTrackInter->setGeometry(QRect(160, 80, 131, 20)); + radioButton_mapTrack = new QRadioButton(groupBox_5); + radioButton_mapTrack->setObjectName(QString::fromUtf8("radioButton_mapTrack")); + radioButton_mapTrack->setGeometry(QRect(160, 50, 131, 20)); + radioButton_mapThermal = new QRadioButton(groupBox_5); + radioButton_mapThermal->setObjectName(QString::fromUtf8("radioButton_mapThermal")); + radioButton_mapThermal->setGeometry(QRect(20, 170, 111, 20)); + radioButton_mapTrackThermal = new QRadioButton(groupBox_5); + radioButton_mapTrackThermal->setObjectName(QString::fromUtf8("radioButton_mapTrackThermal")); + radioButton_mapTrackThermal->setGeometry(QRect(160, 170, 111, 20)); + radioButton_mapTrackEnergy = new QRadioButton(groupBox_5); + radioButton_mapTrackEnergy->setObjectName(QString::fromUtf8("radioButton_mapTrackEnergy")); + radioButton_mapTrackEnergy->setGeometry(QRect(160, 210, 131, 20)); + groupBox_8 = new QGroupBox(tab_6); + groupBox_8->setObjectName(QString::fromUtf8("groupBox_8")); + groupBox_8->setGeometry(QRect(530, 270, 301, 311)); + radioButton_NeutronNight = new QRadioButton(groupBox_8); + radioButton_NeutronNight->setObjectName(QString::fromUtf8("radioButton_NeutronNight")); + radioButton_NeutronNight->setGeometry(QRect(20, 30, 131, 17)); + radioButton_NeutronCold = new QRadioButton(groupBox_8); + radioButton_NeutronCold->setObjectName(QString::fromUtf8("radioButton_NeutronCold")); + radioButton_NeutronCold->setGeometry(QRect(20, 60, 61, 17)); + radioButton_NeutronPolar = new QRadioButton(groupBox_8); + radioButton_NeutronPolar->setObjectName(QString::fromUtf8("radioButton_NeutronPolar")); + radioButton_NeutronPolar->setGeometry(QRect(20, 90, 71, 17)); + radioButton_NeutronRainbow = new QRadioButton(groupBox_8); + radioButton_NeutronRainbow->setObjectName(QString::fromUtf8("radioButton_NeutronRainbow")); + radioButton_NeutronRainbow->setGeometry(QRect(20, 120, 91, 17)); + radioButton_NeutronRainbow->setChecked(true); + horizontalSliderColor = new QSlider(groupBox_8); + horizontalSliderColor->setObjectName(QString::fromUtf8("horizontalSliderColor")); + horizontalSliderColor->setGeometry(QRect(20, 250, 171, 20)); + horizontalSliderColor->setMaximum(199); + horizontalSliderColor->setSingleStep(1); + horizontalSliderColor->setValue(50); + horizontalSliderColor->setOrientation(Qt::Horizontal); + horizontalSliderColorZero = new QSlider(groupBox_8); + horizontalSliderColorZero->setObjectName(QString::fromUtf8("horizontalSliderColorZero")); + horizontalSliderColorZero->setGeometry(QRect(20, 200, 131, 20)); + horizontalSliderColorZero->setMaximum(199); + horizontalSliderColorZero->setOrientation(Qt::Horizontal); + label_46 = new QLabel(groupBox_8); + label_46->setObjectName(QString::fromUtf8("label_46")); + label_46->setGeometry(QRect(19, 160, 161, 16)); + label_46->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_46->setWordWrap(true); + label_47 = new QLabel(groupBox_8); + label_47->setObjectName(QString::fromUtf8("label_47")); + label_47->setGeometry(QRect(20, 180, 101, 21)); + label_47->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_47->setWordWrap(true); + label_50 = new QLabel(groupBox_8); + label_50->setObjectName(QString::fromUtf8("label_50")); + label_50->setGeometry(QRect(20, 230, 101, 21)); + label_50->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_50->setWordWrap(true); + label_ColorRange = new QLabel(groupBox_8); + label_ColorRange->setObjectName(QString::fromUtf8("label_ColorRange")); + label_ColorRange->setGeometry(QRect(97, 158, 71, 16)); + checkBoxManual = new QCheckBox(groupBox_8); + checkBoxManual->setObjectName(QString::fromUtf8("checkBoxManual")); + checkBoxManual->setGeometry(QRect(200, 160, 81, 17)); + lineEditManualColorZero = new QLineEdit(groupBox_8); + lineEditManualColorZero->setObjectName(QString::fromUtf8("lineEditManualColorZero")); + lineEditManualColorZero->setGeometry(QRect(200, 200, 51, 20)); + lineEditManualColor = new QLineEdit(groupBox_8); + lineEditManualColor->setObjectName(QString::fromUtf8("lineEditManualColor")); + lineEditManualColor->setGeometry(QRect(200, 248, 51, 20)); + checkBoxLogarithmic = new QCheckBox(groupBox_8); + checkBoxLogarithmic->setObjectName(QString::fromUtf8("checkBoxLogarithmic")); + checkBoxLogarithmic->setGeometry(QRect(20, 280, 111, 17)); + radioButton_NeutronGrayScale = new QRadioButton(groupBox_8); + radioButton_NeutronGrayScale->setObjectName(QString::fromUtf8("radioButton_NeutronGrayScale")); + radioButton_NeutronGrayScale->setGeometry(QRect(160, 30, 111, 17)); + radioButton_NeutronHot = new QRadioButton(groupBox_8); + radioButton_NeutronHot->setObjectName(QString::fromUtf8("radioButton_NeutronHot")); + radioButton_NeutronHot->setGeometry(QRect(160, 60, 82, 17)); + radioButton_NeutronThermal = new QRadioButton(groupBox_8); + radioButton_NeutronThermal->setObjectName(QString::fromUtf8("radioButton_NeutronThermal")); + radioButton_NeutronThermal->setGeometry(QRect(160, 90, 101, 17)); + groupBox_17 = new QGroupBox(tab_6); + groupBox_17->setObjectName(QString::fromUtf8("groupBox_17")); + groupBox_17->setGeometry(QRect(530, 590, 301, 161)); + horizontalSliderDetector = new QSlider(groupBox_17); + horizontalSliderDetector->setObjectName(QString::fromUtf8("horizontalSliderDetector")); + horizontalSliderDetector->setGeometry(QRect(20, 50, 201, 20)); + horizontalSliderDetector->setMaximum(200); + horizontalSliderDetector->setSingleStep(1); + horizontalSliderDetector->setValue(0); + horizontalSliderDetector->setOrientation(Qt::Horizontal); + label_75 = new QLabel(groupBox_17); + label_75->setObjectName(QString::fromUtf8("label_75")); + label_75->setGeometry(QRect(20, 30, 141, 21)); + label_75->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_75->setWordWrap(true); + label_DetectorRange = new QLabel(groupBox_17); + label_DetectorRange->setObjectName(QString::fromUtf8("label_DetectorRange")); + label_DetectorRange->setGeometry(QRect(230, 50, 51, 16)); + label_76 = new QLabel(groupBox_17); + label_76->setObjectName(QString::fromUtf8("label_76")); + label_76->setGeometry(QRect(20, 130, 131, 21)); + label_76->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_76->setWordWrap(true); + label_DetectorRangeMaximum = new QLabel(groupBox_17); + label_DetectorRangeMaximum->setObjectName(QString::fromUtf8("label_DetectorRangeMaximum")); + label_DetectorRangeMaximum->setGeometry(QRect(140, 128, 51, 16)); + horizontalSliderDetectorColor = new QSlider(groupBox_17); + horizontalSliderDetectorColor->setObjectName(QString::fromUtf8("horizontalSliderDetectorColor")); + horizontalSliderDetectorColor->setGeometry(QRect(20, 100, 141, 20)); + horizontalSliderDetectorColor->setSingleStep(1); + horizontalSliderDetectorColor->setValue(99); + horizontalSliderDetectorColor->setOrientation(Qt::Horizontal); + label_78 = new QLabel(groupBox_17); + label_78->setObjectName(QString::fromUtf8("label_78")); + label_78->setGeometry(QRect(20, 80, 141, 21)); + label_78->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_78->setWordWrap(true); + groupBox_18 = new QGroupBox(tab_6); + groupBox_18->setObjectName(QString::fromUtf8("groupBox_18")); + groupBox_18->setGeometry(QRect(20, 50, 281, 121)); + checkBoxNoTrack = new QCheckBox(groupBox_18); + checkBoxNoTrack->setObjectName(QString::fromUtf8("checkBoxNoTrack")); + checkBoxNoTrack->setGeometry(QRect(20, 40, 151, 17)); + label_68 = new QLabel(groupBox_18); + label_68->setObjectName(QString::fromUtf8("label_68")); + label_68->setGeometry(QRect(20, 20, 241, 21)); + label_68->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + label_68->setWordWrap(true); + checkBoxAutoRefreshRate = new QCheckBox(groupBox_18); + checkBoxAutoRefreshRate->setObjectName(QString::fromUtf8("checkBoxAutoRefreshRate")); + checkBoxAutoRefreshRate->setGeometry(QRect(20, 80, 111, 17)); + checkBoxAutoRefreshRate->setChecked(true); + lineEdit_AutoUpdate = new QLineEdit(groupBox_18); + lineEdit_AutoUpdate->setObjectName(QString::fromUtf8("lineEdit_AutoUpdate")); + lineEdit_AutoUpdate->setGeometry(QRect(130, 78, 51, 22)); + lineEdit_AutoUpdate->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + label_82 = new QLabel(groupBox_18); + label_82->setObjectName(QString::fromUtf8("label_82")); + label_82->setGeometry(QRect(190, 82, 31, 16)); + groupBox_25 = new QGroupBox(tab_6); + groupBox_25->setObjectName(QString::fromUtf8("groupBox_25")); + groupBox_25->setGeometry(QRect(20, 230, 281, 101)); + checkBoxClearEveryDisplayRefresh = new QCheckBox(groupBox_25); + checkBoxClearEveryDisplayRefresh->setObjectName(QString::fromUtf8("checkBoxClearEveryDisplayRefresh")); + checkBoxClearEveryDisplayRefresh->setGeometry(QRect(10, 60, 221, 20)); + checkBoxClearEveryDisplayRefresh->setChecked(false); + label_81 = new QLabel(groupBox_25); + label_81->setObjectName(QString::fromUtf8("label_81")); + label_81->setGeometry(QRect(184, 30, 91, 16)); + lineEditClearEveryXNeutrons = new QLineEdit(groupBox_25); + lineEditClearEveryXNeutrons->setObjectName(QString::fromUtf8("lineEditClearEveryXNeutrons")); + lineEditClearEveryXNeutrons->setGeometry(QRect(122, 30, 51, 20)); + lineEditClearEveryXNeutrons->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + checkBoxSaveEvery_2 = new QCheckBox(groupBox_25); + checkBoxSaveEvery_2->setObjectName(QString::fromUtf8("checkBoxSaveEvery_2")); + checkBoxSaveEvery_2->setGeometry(QRect(10, 29, 101, 20)); + checkBoxSaveEvery_2->setChecked(false); + tabWidget->addTab(tab_6, QString()); + simframe = new QFrame(centralWidget); + simframe->setObjectName(QString::fromUtf8("simframe")); + simframe->setGeometry(QRect(200, 0, 1231, 51)); + simframe->setStyleSheet(QString::fromUtf8("")); + simframe->setFrameShape(QFrame::StyledPanel); + simframe->setFrameShadow(QFrame::Raised); + pushButton = new QPushButton(simframe); + pushButton->setObjectName(QString::fromUtf8("pushButton")); + pushButton->setGeometry(QRect(1165, 13, 51, 25)); + pushButton->setStyleSheet(QString::fromUtf8("")); + pushButton_Pause = new QPushButton(simframe); + pushButton_Pause->setObjectName(QString::fromUtf8("pushButton_Pause")); + pushButton_Pause->setGeometry(QRect(106, 13, 51, 25)); + pushButton_Pause->setCheckable(true); + pushButton_Pause->setChecked(false); + pushButton_Pause->setFlat(false); + pushButton_stop = new QPushButton(simframe); + pushButton_stop->setObjectName(QString::fromUtf8("pushButton_stop")); + pushButton_stop->setGeometry(QRect(163, 13, 41, 25)); + pushButton_Clear = new QPushButton(simframe); + pushButton_Clear->setObjectName(QString::fromUtf8("pushButton_Clear")); + pushButton_Clear->setGeometry(QRect(210, 13, 41, 25)); + pushButton_Simulate = new QPushButton(simframe); + pushButton_Simulate->setObjectName(QString::fromUtf8("pushButton_Simulate")); + pushButton_Simulate->setGeometry(QRect(12, 10, 81, 30)); + pushButton_Simulate->setMinimumSize(QSize(0, 0)); + pushButton_Simulate->setMaximumSize(QSize(16777215, 45)); + pushButton_Simulate->setStyleSheet(QString::fromUtf8("")); + pushButton_Simulate->setFlat(false); + label_npers = new QLabel(simframe); + label_npers->setObjectName(QString::fromUtf8("label_npers")); + label_npers->setGeometry(QRect(740, 7, 91, 20)); + label_npers->setLayoutDirection(Qt::RightToLeft); + neutronCountView = new QLabel(simframe); + neutronCountView->setObjectName(QString::fromUtf8("neutronCountView")); + neutronCountView->setGeometry(QRect(330, 7, 91, 20)); + neutronCountView->setLayoutDirection(Qt::RightToLeft); + neutronCountView->setFrameShadow(QFrame::Plain); + neutronCountView->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + progressBar = new QProgressBar(simframe); + progressBar->setObjectName(QString::fromUtf8("progressBar")); + progressBar->setGeometry(QRect(440, 10, 291, 31)); + progressBar->setValue(1); + progressBar->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop); + progressBar->setTextVisible(false); + progressBar->setInvertedAppearance(false); + progressBar->setTextDirection(QProgressBar::TopToBottom); + label_31 = new QLabel(simframe); + label_31->setObjectName(QString::fromUtf8("label_31")); + label_31->setGeometry(QRect(980, 15, 61, 20)); + label_18 = new QLabel(simframe); + label_18->setObjectName(QString::fromUtf8("label_18")); + label_18->setGeometry(QRect(850, 15, 81, 20)); + lineEditRefresh = new QLineEdit(simframe); + lineEditRefresh->setObjectName(QString::fromUtf8("lineEditRefresh")); + lineEditRefresh->setGeometry(QRect(934, 15, 41, 22)); + lineEditRefresh->setAlignment(Qt::AlignCenter); + lineEditNeutrinsTotal = new QLineEdit(simframe); + lineEditNeutrinsTotal->setObjectName(QString::fromUtf8("lineEditNeutrinsTotal")); + lineEditNeutrinsTotal->setGeometry(QRect(335, 24, 91, 22)); + lineEditNeutrinsTotal->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + lineEditNeutrinsTotal->setDragEnabled(false); + lineEditNeutrinsTotal->setReadOnly(false); + label_9 = new QLabel(simframe); + label_9->setObjectName(QString::fromUtf8("label_9")); + label_9->setGeometry(QRect(270, 24, 71, 20)); + label_timeRemain = new QLabel(simframe); + label_timeRemain->setObjectName(QString::fromUtf8("label_timeRemain")); + label_timeRemain->setGeometry(QRect(740, 24, 91, 20)); + label_timeRemain->setLayoutDirection(Qt::RightToLeft); + label_26 = new QLabel(simframe); + label_26->setObjectName(QString::fromUtf8("label_26")); + label_26->setGeometry(QRect(270, 7, 71, 20)); + label_Status = new QLabel(simframe); + label_Status->setObjectName(QString::fromUtf8("label_Status")); + label_Status->setGeometry(QRect(530, 8, 191, 20)); + QFont font1; + font1.setPointSize(7); + font1.setUnderline(false); + label_Status->setFont(font1); + label_Status->setLayoutDirection(Qt::LeftToRight); + label_Status->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + label_Status2 = new QLabel(simframe); + label_Status2->setObjectName(QString::fromUtf8("label_Status2")); + label_Status2->setGeometry(QRect(490, 27, 231, 20)); + label_Status2->setFont(font1); + label_Status2->setLayoutDirection(Qt::LeftToRight); + label_Status2->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + pushButton_SaveConfig = new QPushButton(simframe); + pushButton_SaveConfig->setObjectName(QString::fromUtf8("pushButton_SaveConfig")); + pushButton_SaveConfig->setGeometry(QRect(1087, 14, 71, 24)); + pushButton_about = new QPushButton(centralWidget); + pushButton_about->setObjectName(QString::fromUtf8("pushButton_about")); + pushButton_about->setGeometry(QRect(6, 11, 191, 31)); + pushButton_about->setMinimumSize(QSize(177, 0)); + pushButton_about->setMaximumSize(QSize(16777215, 43)); + pushButton_about->setAutoFillBackground(false); + pushButton_about->setStyleSheet(QString::fromUtf8("border: 0; border-radius: 0;\n" +"background-color: transparent;")); + QIcon icon; + icon.addFile(QString::fromUtf8("uranos-logo-smallx2.png"), QSize(), QIcon::Normal, QIcon::Off); + pushButton_about->setIcon(icon); + pushButton_about->setIconSize(QSize(177, 51)); + pushButton_about->setFlat(false); + tabWidget_live = new QTabWidget(centralWidget); + tabWidget_live->setObjectName(QString::fromUtf8("tabWidget_live")); + tabWidget_live->setGeometry(QRect(900, 60, 531, 801)); + tabWidget_live->setAutoFillBackground(false); + tabWidget_live->setStyleSheet(QString::fromUtf8("")); + tab_7 = new QWidget(); + tab_7->setObjectName(QString::fromUtf8("tab_7")); + liveframe1 = new QFrame(tab_7); + liveframe1->setObjectName(QString::fromUtf8("liveframe1")); + liveframe1->setGeometry(QRect(0, 0, 531, 771)); + liveframe1->setFrameShape(QFrame::StyledPanel); + liveframe1->setFrameShadow(QFrame::Raised); + customPlot = new QCustomPlot(liveframe1); + customPlot->setObjectName(QString::fromUtf8("customPlot")); + customPlot->setGeometry(QRect(10, 520, 511, 241)); + customPlot2 = new QCustomPlot(liveframe1); + customPlot2->setObjectName(QString::fromUtf8("customPlot2")); + customPlot2->setGeometry(QRect(12, 10, 511, 501)); + pushButton_Enlarge = new QPushButton(liveframe1); + pushButton_Enlarge->setObjectName(QString::fromUtf8("pushButton_Enlarge")); + pushButton_Enlarge->setGeometry(QRect(506, 0, 20, 20)); + label_detectorLayerNs2 = new QLabel(liveframe1); + label_detectorLayerNs2->setObjectName(QString::fromUtf8("label_detectorLayerNs2")); + label_detectorLayerNs2->setGeometry(QRect(30, 750, 61, 20)); + QPalette palette; + QBrush brush(QColor(255, 255, 255, 127)); + brush.setStyle(Qt::SolidPattern); + palette.setBrush(QPalette::Active, QPalette::WindowText, brush); + QBrush brush1(QColor(0, 88, 156, 255)); + brush1.setStyle(Qt::SolidPattern); + palette.setBrush(QPalette::Active, QPalette::Button, brush1); + palette.setBrush(QPalette::Active, QPalette::Text, brush); + palette.setBrush(QPalette::Active, QPalette::ButtonText, brush); + palette.setBrush(QPalette::Active, QPalette::Base, brush1); + palette.setBrush(QPalette::Active, QPalette::Window, brush1); +#if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0) + palette.setBrush(QPalette::Active, QPalette::PlaceholderText, brush); +#endif + palette.setBrush(QPalette::Inactive, QPalette::WindowText, brush); + palette.setBrush(QPalette::Inactive, QPalette::Button, brush1); + palette.setBrush(QPalette::Inactive, QPalette::Text, brush); + palette.setBrush(QPalette::Inactive, QPalette::ButtonText, brush); + palette.setBrush(QPalette::Inactive, QPalette::Base, brush1); + palette.setBrush(QPalette::Inactive, QPalette::Window, brush1); +#if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0) + palette.setBrush(QPalette::Inactive, QPalette::PlaceholderText, brush); +#endif + palette.setBrush(QPalette::Disabled, QPalette::WindowText, brush); + palette.setBrush(QPalette::Disabled, QPalette::Button, brush1); + palette.setBrush(QPalette::Disabled, QPalette::Text, brush); + palette.setBrush(QPalette::Disabled, QPalette::ButtonText, brush); + palette.setBrush(QPalette::Disabled, QPalette::Base, brush1); + palette.setBrush(QPalette::Disabled, QPalette::Window, brush1); +#if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0) + palette.setBrush(QPalette::Disabled, QPalette::PlaceholderText, brush); +#endif + label_detectorLayerNs2->setPalette(palette); + QFont font2; + font2.setPointSize(7); + label_detectorLayerNs2->setFont(font2); + label_detectorLayerNs2->setLayoutDirection(Qt::RightToLeft); + label_detectorLayerNs2->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + tabWidget_live->addTab(tab_7, QString()); + tab_8 = new QWidget(); + tab_8->setObjectName(QString::fromUtf8("tab_8")); + frame = new QFrame(tab_8); + frame->setObjectName(QString::fromUtf8("frame")); + frame->setGeometry(QRect(0, 0, 531, 771)); + frame->setFrameShape(QFrame::StyledPanel); + frame->setFrameShadow(QFrame::Raised); + customPlot4 = new QCustomPlot(frame); + customPlot4->setObjectName(QString::fromUtf8("customPlot4")); + customPlot4->setGeometry(QRect(10, 410, 501, 291)); + label_24 = new QLabel(frame); + label_24->setObjectName(QString::fromUtf8("label_24")); + label_24->setGeometry(QRect(10, 10, 381, 16)); + label_24->setScaledContents(false); + customPlot6 = new QCustomPlot(frame); + customPlot6->setObjectName(QString::fromUtf8("customPlot6")); + customPlot6->setGeometry(QRect(10, 30, 501, 291)); + label_4 = new QLabel(frame); + label_4->setObjectName(QString::fromUtf8("label_4")); + label_4->setGeometry(QRect(10, 390, 361, 16)); + label_4->setScaledContents(false); + label_20 = new QLabel(frame); + label_20->setObjectName(QString::fromUtf8("label_20")); + label_20->setGeometry(QRect(358, 348, 161, 20)); + label_20->setScaledContents(false); + detectorLayerRatioBar = new QProgressBar(frame); + detectorLayerRatioBar->setObjectName(QString::fromUtf8("detectorLayerRatioBar")); + detectorLayerRatioBar->setGeometry(QRect(50, 348, 301, 20)); + QFont font3; + font3.setBold(true); + font3.setUnderline(false); + font3.setStrikeOut(false); + detectorLayerRatioBar->setFont(font3); + detectorLayerRatioBar->setAcceptDrops(false); + detectorLayerRatioBar->setStyleSheet(QString::fromUtf8("background-color: rgb(0, 88, 156);\n" +"color: rgb(255, 255, 255);\n" +"text-align: right;")); + detectorLayerRatioBar->setValue(1); + detectorLayerRatioBar->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter); + detectorLayerRatioBar->setInvertedAppearance(false); + label_19 = new QLabel(frame); + label_19->setObjectName(QString::fromUtf8("label_19")); + label_19->setGeometry(QRect(361, 727, 161, 20)); + label_19->setScaledContents(false); + detectorRatioBar = new QProgressBar(frame); + detectorRatioBar->setObjectName(QString::fromUtf8("detectorRatioBar")); + detectorRatioBar->setGeometry(QRect(50, 728, 301, 20)); + QFont font4; + font4.setBold(true); + detectorRatioBar->setFont(font4); + detectorRatioBar->setStyleSheet(QString::fromUtf8("background-color: rgb(0, 88, 156);\n" +"color: rgb(255, 255, 255);\n" +"text-align: right;")); + detectorRatioBar->setValue(1); + checkBoxR = new QCheckBox(frame); + checkBoxR->setObjectName(QString::fromUtf8("checkBoxR")); + checkBoxR->setGeometry(QRect(460, 390, 51, 20)); + checkBoxRS = new QCheckBox(frame); + checkBoxRS->setObjectName(QString::fromUtf8("checkBoxRS")); + checkBoxRS->setGeometry(QRect(460, 10, 51, 20)); + label_Footprint63D = new QLabel(frame); + label_Footprint63D->setObjectName(QString::fromUtf8("label_Footprint63D")); + label_Footprint63D->setGeometry(QRect(170, 701, 61, 16)); + label_Footprint63D->setScaledContents(false); + label_Footprint86D = new QLabel(frame); + label_Footprint86D->setObjectName(QString::fromUtf8("label_Footprint86D")); + label_Footprint86D->setGeometry(QRect(280, 701, 61, 16)); + label_Footprint86D->setScaledContents(false); + label_Footprint86DL = new QLabel(frame); + label_Footprint86DL->setObjectName(QString::fromUtf8("label_Footprint86DL")); + label_Footprint86DL->setGeometry(QRect(280, 320, 61, 16)); + label_Footprint86DL->setScaledContents(false); + label_Footprint63DL = new QLabel(frame); + label_Footprint63DL->setObjectName(QString::fromUtf8("label_Footprint63DL")); + label_Footprint63DL->setGeometry(QRect(170, 320, 61, 16)); + label_Footprint63DL->setScaledContents(false); + label_91 = new QLabel(frame); + label_91->setObjectName(QString::fromUtf8("label_91")); + label_91->setGeometry(QRect(50, 320, 71, 16)); + label_91->setScaledContents(false); + label_92 = new QLabel(frame); + label_92->setObjectName(QString::fromUtf8("label_92")); + label_92->setGeometry(QRect(120, 320, 41, 16)); + label_92->setScaledContents(false); + label_92->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + label_93 = new QLabel(frame); + label_93->setObjectName(QString::fromUtf8("label_93")); + label_93->setGeometry(QRect(230, 320, 41, 16)); + label_93->setScaledContents(false); + label_93->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + label_94 = new QLabel(frame); + label_94->setObjectName(QString::fromUtf8("label_94")); + label_94->setGeometry(QRect(350, 320, 111, 16)); + label_94->setScaledContents(false); + label_FootprintNFL = new QLabel(frame); + label_FootprintNFL->setObjectName(QString::fromUtf8("label_FootprintNFL")); + label_FootprintNFL->setGeometry(QRect(460, 319, 41, 20)); + label_FootprintNFL->setScaledContents(false); + label_FootprintNF = new QLabel(frame); + label_FootprintNF->setObjectName(QString::fromUtf8("label_FootprintNF")); + label_FootprintNF->setGeometry(QRect(462, 699, 41, 20)); + label_FootprintNF->setScaledContents(false); + label_95 = new QLabel(frame); + label_95->setObjectName(QString::fromUtf8("label_95")); + label_95->setGeometry(QRect(230, 700, 41, 16)); + label_95->setScaledContents(false); + label_95->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + label_96 = new QLabel(frame); + label_96->setObjectName(QString::fromUtf8("label_96")); + label_96->setGeometry(QRect(350, 700, 111, 16)); + label_96->setScaledContents(false); + label_97 = new QLabel(frame); + label_97->setObjectName(QString::fromUtf8("label_97")); + label_97->setGeometry(QRect(50, 700, 71, 16)); + label_97->setScaledContents(false); + label_98 = new QLabel(frame); + label_98->setObjectName(QString::fromUtf8("label_98")); + label_98->setGeometry(QRect(120, 700, 41, 16)); + label_98->setScaledContents(false); + label_98->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + tabWidget_live->addTab(tab_8, QString()); + tab_9 = new QWidget(); + tab_9->setObjectName(QString::fromUtf8("tab_9")); + frame_2 = new QFrame(tab_9); + frame_2->setObjectName(QString::fromUtf8("frame_2")); + frame_2->setGeometry(QRect(0, 0, 531, 771)); + frame_2->setFrameShape(QFrame::StyledPanel); + frame_2->setFrameShadow(QFrame::Raised); + customPlot3 = new QCustomPlot(frame_2); + customPlot3->setObjectName(QString::fromUtf8("customPlot3")); + customPlot3->setGeometry(QRect(10, 30, 501, 311)); + label_23 = new QLabel(frame_2); + label_23->setObjectName(QString::fromUtf8("label_23")); + label_23->setGeometry(QRect(10, 10, 361, 16)); + label_5 = new QLabel(frame_2); + label_5->setObjectName(QString::fromUtf8("label_5")); + label_5->setGeometry(QRect(10, 390, 191, 16)); + checkBoxD = new QCheckBox(frame_2); + checkBoxD->setObjectName(QString::fromUtf8("checkBoxD")); + checkBoxD->setGeometry(QRect(460, 390, 51, 20)); + customPlot5 = new QCustomPlot(frame_2); + customPlot5->setObjectName(QString::fromUtf8("customPlot5")); + customPlot5->setGeometry(QRect(10, 410, 501, 311)); + tabWidget_live->addTab(tab_9, QString()); + tab_10 = new QWidget(); + tab_10->setObjectName(QString::fromUtf8("tab_10")); + frame_3 = new QFrame(tab_10); + frame_3->setObjectName(QString::fromUtf8("frame_3")); + frame_3->setGeometry(QRect(0, 0, 531, 771)); + frame_3->setFrameShape(QFrame::StyledPanel); + frame_3->setFrameShadow(QFrame::Raised); + customPlot10 = new QCustomPlot(frame_3); + customPlot10->setObjectName(QString::fromUtf8("customPlot10")); + customPlot10->setGeometry(QRect(10, 10, 511, 561)); + label_77 = new QLabel(frame_3); + label_77->setObjectName(QString::fromUtf8("label_77")); + label_77->setGeometry(QRect(100, 572, 361, 16)); + label_77->setScaledContents(false); + label_77->setAlignment(Qt::AlignCenter); + label_DetNeutrons = new QLabel(frame_3); + label_DetNeutrons->setObjectName(QString::fromUtf8("label_DetNeutrons")); + label_DetNeutrons->setGeometry(QRect(210, 597, 101, 20)); + label_DetNeutrons->setLayoutDirection(Qt::RightToLeft); + label_detectorNs = new QLabel(frame_3); + label_detectorNs->setObjectName(QString::fromUtf8("label_detectorNs")); + label_detectorNs->setGeometry(QRect(310, 597, 91, 20)); + label_detectorNs->setLayoutDirection(Qt::RightToLeft); + tabWidget_live->addTab(tab_10, QString()); + label_2 = new QLabel(centralWidget); + label_2->setObjectName(QString::fromUtf8("label_2")); + label_2->setGeometry(QRect(898, 64, 59, 22)); + label_2->setStyleSheet(QString::fromUtf8("font-size: 20px; color:#00589C;")); + label_2->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter); + label_42 = new QLabel(centralWidget); + label_42->setObjectName(QString::fromUtf8("label_42")); + label_42->setEnabled(true); + label_42->setGeometry(QRect(30, 3, 141, 41)); + QFont font5; + font5.setFamily(QString::fromUtf8("Calibri")); + font5.setPointSize(23); + font5.setBold(true); + label_42->setFont(font5); + label_42->setStyleSheet(QString::fromUtf8("")); + label_detectorLayerNs = new QLabel(centralWidget); + label_detectorLayerNs->setObjectName(QString::fromUtf8("label_detectorLayerNs")); + label_detectorLayerNs->setGeometry(QRect(1362, 66, 61, 20)); + QPalette palette1; + QBrush brush2(QColor(127, 171, 205, 255)); + brush2.setStyle(Qt::SolidPattern); + palette1.setBrush(QPalette::Active, QPalette::WindowText, brush2); + palette1.setBrush(QPalette::Active, QPalette::Text, brush2); + QBrush brush3(QColor(127, 171, 205, 128)); + brush3.setStyle(Qt::NoBrush); +#if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0) + palette1.setBrush(QPalette::Active, QPalette::PlaceholderText, brush3); +#endif + palette1.setBrush(QPalette::Inactive, QPalette::WindowText, brush2); + palette1.setBrush(QPalette::Inactive, QPalette::Text, brush2); + QBrush brush4(QColor(127, 171, 205, 128)); + brush4.setStyle(Qt::NoBrush); +#if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0) + palette1.setBrush(QPalette::Inactive, QPalette::PlaceholderText, brush4); +#endif + QBrush brush5(QColor(120, 120, 120, 255)); + brush5.setStyle(Qt::SolidPattern); + palette1.setBrush(QPalette::Disabled, QPalette::WindowText, brush5); + palette1.setBrush(QPalette::Disabled, QPalette::Text, brush5); + QBrush brush6(QColor(127, 171, 205, 128)); + brush6.setStyle(Qt::NoBrush); +#if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0) + palette1.setBrush(QPalette::Disabled, QPalette::PlaceholderText, brush6); +#endif + label_detectorLayerNs->setPalette(palette1); + QFont font6; + font6.setPointSize(6); + label_detectorLayerNs->setFont(font6); + label_detectorLayerNs->setLayoutDirection(Qt::RightToLeft); + label_detectorLayerNs->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + frame_4 = new QFrame(centralWidget); + frame_4->setObjectName(QString::fromUtf8("frame_4")); + frame_4->setGeometry(QRect(1360, 65, 71, 21)); + QPalette palette2; + palette2.setBrush(QPalette::Active, QPalette::Button, brush1); + palette2.setBrush(QPalette::Active, QPalette::Base, brush1); + palette2.setBrush(QPalette::Active, QPalette::Window, brush1); + palette2.setBrush(QPalette::Inactive, QPalette::Button, brush1); + palette2.setBrush(QPalette::Inactive, QPalette::Base, brush1); + palette2.setBrush(QPalette::Inactive, QPalette::Window, brush1); + palette2.setBrush(QPalette::Disabled, QPalette::Button, brush1); + palette2.setBrush(QPalette::Disabled, QPalette::Base, brush1); + palette2.setBrush(QPalette::Disabled, QPalette::Window, brush1); + frame_4->setPalette(palette2); + frame_4->setStyleSheet(QString::fromUtf8("background-color: rgb(0, 88, 156)")); + frame_4->setFrameShape(QFrame::StyledPanel); + frame_4->setFrameShadow(QFrame::Raised); + MainWindow->setCentralWidget(centralWidget); + label_42->raise(); + tabWidget->raise(); + simframe->raise(); + pushButton_about->raise(); + tabWidget_live->raise(); + label_2->raise(); + frame_4->raise(); + label_detectorLayerNs->raise(); + menuBar = new QMenuBar(MainWindow); + menuBar->setObjectName(QString::fromUtf8("menuBar")); + menuBar->setGeometry(QRect(0, 0, 1448, 22)); + MainWindow->setMenuBar(menuBar); + statusBar = new QStatusBar(MainWindow); + statusBar->setObjectName(QString::fromUtf8("statusBar")); + MainWindow->setStatusBar(statusBar); + + retranslateUi(MainWindow); + + tabWidget->setCurrentIndex(0); + tabWidget_live->setCurrentIndex(0); + + + QMetaObject::connectSlotsByName(MainWindow); + } // setupUi + + void retranslateUi(QMainWindow *MainWindow) + { + MainWindow->setWindowTitle(QCoreApplication::translate("MainWindow", "URANOS - The Cosmic Neutron Soil Moisture Simulator", nullptr)); + labelSM->setText(QCoreApplication::translate("MainWindow", "10 %", nullptr)); + labelHum->setText(QCoreApplication::translate("MainWindow", "

7 g/m3

", nullptr)); + label_6->setText(QCoreApplication::translate("MainWindow", "Soil Water Content [Vol%]", nullptr)); + label_7->setText(QCoreApplication::translate("MainWindow", "Air Humidity", nullptr)); + groupBox->setTitle(QCoreApplication::translate("MainWindow", "Layers", nullptr)); + checkBox_useImage->setText(QCoreApplication::translate("MainWindow", "Use layer maps", nullptr)); + pushButton_Show->setText(QCoreApplication::translate("MainWindow", "View layer maps", nullptr)); + pushButton_6->setText(QCoreApplication::translate("MainWindow", "Material Codes", nullptr)); + groupBox_11->setTitle(QCoreApplication::translate("MainWindow", "Layer Configuration", nullptr)); + pushButton_LoadGeometry->setText(QCoreApplication::translate("MainWindow", "Load", nullptr)); + pushButton_SaveGeometry->setText(QCoreApplication::translate("MainWindow", "Save", nullptr)); + groupBox_12->setTitle(QCoreApplication::translate("MainWindow", "Layer Control", nullptr)); + pushButton_RemoveLayer->setText(QCoreApplication::translate("MainWindow", "-", nullptr)); + pushButton_AddLayer->setText(QCoreApplication::translate("MainWindow", "+", nullptr)); + pushButton_ReadGeometry->setText(QCoreApplication::translate("MainWindow", "Generate", nullptr)); + label_28->setText(QCoreApplication::translate("MainWindow", "Source Layer", nullptr)); + label_29->setText(QCoreApplication::translate("MainWindow", "Ground Layer", nullptr)); + label_27->setText(QCoreApplication::translate("MainWindow", "Detector Layer", nullptr)); + label_71->setText(QCoreApplication::translate("MainWindow", "

Minimum
Configuration

", nullptr)); + groupBox_Evaporation->setTitle(QCoreApplication::translate("MainWindow", "Load Equipment", nullptr)); + radioButton_fission->setText(QCoreApplication::translate("MainWindow", "Nuclear Fission Source", nullptr)); + radioButton_fusion->setText(QCoreApplication::translate("MainWindow", "Nuclear Fusion Source", nullptr)); + radioButton_AmBe->setText(QCoreApplication::translate("MainWindow", "AmBe Laboratory Source", nullptr)); + lineEdit_xPos->setText(QCoreApplication::translate("MainWindow", "0", nullptr)); + label_55->setText(QCoreApplication::translate("MainWindow", "x Position", nullptr)); + label_57->setText(QCoreApplication::translate("MainWindow", "y Position", nullptr)); + lineEdit_yPos->setText(QCoreApplication::translate("MainWindow", "0", nullptr)); + label_58->setText(QCoreApplication::translate("MainWindow", "z Position", nullptr)); + lineEdit_zPos->setText(QCoreApplication::translate("MainWindow", "0", nullptr)); + lineEdit_zPos_2->setText(QCoreApplication::translate("MainWindow", "0", nullptr)); + checkBoxThermal->setText(QCoreApplication::translate("MainWindow", "Thermonuclear Transport", nullptr)); + radioButton_NoSource->setText(QCoreApplication::translate("MainWindow", "None", nullptr)); + lineEdit_xSize->setText(QCoreApplication::translate("MainWindow", "0", nullptr)); + lineEdit_ySize->setText(QCoreApplication::translate("MainWindow", "0", nullptr)); + label_64->setText(QCoreApplication::translate("MainWindow", "y Size", nullptr)); + label_65->setText(QCoreApplication::translate("MainWindow", "x Size", nullptr)); + radioButton_MonoenergeticSource->setText(QCoreApplication::translate("MainWindow", "Monoenergetic [MeV]", nullptr)); + lineEdit_SourceEnergy->setText(QCoreApplication::translate("MainWindow", "0", nullptr)); + radioButton_ThermalSource->setText(QCoreApplication::translate("MainWindow", "Thermal", nullptr)); + label_67->setText(QCoreApplication::translate("MainWindow", "Radius", nullptr)); + radioButton_ModeratedCf->setText(QCoreApplication::translate("MainWindow", "Moderated Californium Source", nullptr)); + lineEdit_zSize->setText(QCoreApplication::translate("MainWindow", "0", nullptr)); + label_72->setText(QCoreApplication::translate("MainWindow", "z Size", nullptr)); + groupBox_20->setTitle(QCoreApplication::translate("MainWindow", "Source Direction", nullptr)); + radioButton_LeftToRight->setText(QCoreApplication::translate("MainWindow", "->", nullptr)); + radioButton_RightToLeft->setText(QCoreApplication::translate("MainWindow", "<-", nullptr)); + radioButton_Omni->setText(QString()); + radioButton_TopToBottom->setText(QString()); + radioButton_BottomToTop->setText(QString()); + label_45->setText(QCoreApplication::translate("MainWindow", "

Layers are arranged in the vertical direction, representing different materials or 2D gridded patterns
Position z denotes the depth below surface (z=0) in [m] and refers to the upper edge of the layer
Layers override topological presets

", nullptr)); + label_10->setText(QCoreApplication::translate("MainWindow", "

Atmospheric depth

", nullptr)); + labelAtm1->setText(QCoreApplication::translate("MainWindow", "

1020 g/cm2

", nullptr)); + label_56->setText(QCoreApplication::translate("MainWindow", "Soil Porosity [Vol%]", nullptr)); + labelSP->setText(QCoreApplication::translate("MainWindow", "50 %", nullptr)); + labelrigidity->setText(QCoreApplication::translate("MainWindow", "10", nullptr)); + label_11->setText(QCoreApplication::translate("MainWindow", "Cut-off rigidity [GV]", nullptr)); + tabWidget->setTabText(tabWidget->indexOf(Geometry), QCoreApplication::translate("MainWindow", "Physical Parameters", nullptr)); + groupBox_3->setTitle(QCoreApplication::translate("MainWindow", "Source geometry", nullptr)); + lineEditBeamRad->setText(QCoreApplication::translate("MainWindow", "50", nullptr)); + label_21->setText(QCoreApplication::translate("MainWindow", "Radius", nullptr)); + beamRound->setText(QCoreApplication::translate("MainWindow", "round", nullptr)); + beamSquare->setText(QCoreApplication::translate("MainWindow", "quadratic", nullptr)); + label_34->setText(QCoreApplication::translate("MainWindow", "m", nullptr)); + checkBox_VolumeSource->setText(QCoreApplication::translate("MainWindow", "Volume Source extended down to the ground", nullptr)); + groupBox_2->setTitle(QCoreApplication::translate("MainWindow", "Domain", nullptr)); + lineEditSquareDim->setText(QCoreApplication::translate("MainWindow", "100", nullptr)); + label_12->setText(QCoreApplication::translate("MainWindow", "Dimension", nullptr)); + label_35->setText(QCoreApplication::translate("MainWindow", "m", nullptr)); + label_32->setText(QCoreApplication::translate("MainWindow", "

Define the spatial extension of the setup you are simulating. Please adjust the source geometry accordingly.

", nullptr)); + groupBox_4->setTitle(QCoreApplication::translate("MainWindow", "Topological presets (water, land)", nullptr)); + radioRiver->setText(QCoreApplication::translate("MainWindow", "River, width [m]", nullptr)); + radioCoast->setText(QCoreApplication::translate("MainWindow", "Coast at x [m]", nullptr)); + lineEdit_River->setText(QCoreApplication::translate("MainWindow", "10", nullptr)); + lineEdit_River_2->setText(QCoreApplication::translate("MainWindow", "0", nullptr)); + lineEdit_Island->setText(QCoreApplication::translate("MainWindow", "10", nullptr)); + radioIsland->setText(QCoreApplication::translate("MainWindow", "Island, diameter [m]", nullptr)); + lineEdit_Lake->setText(QCoreApplication::translate("MainWindow", "10", nullptr)); + radioLake->setText(QCoreApplication::translate("MainWindow", "Lake, diameter [m]", nullptr)); + radioButton->setText(QCoreApplication::translate("MainWindow", "None", nullptr)); + label_70->setText(QCoreApplication::translate("MainWindow", "

These are some preset examples generating a geometry for the ground layer

", nullptr)); + groupBox_21->setTitle(QCoreApplication::translate("MainWindow", "Computational Boundary Conditions", nullptr)); + label_84->setText(QCoreApplication::translate("MainWindow", "

Open System

", nullptr)); + checkBox_DomainCutoff->setText(QCoreApplication::translate("MainWindow", "Remove if", nullptr)); + lineEditDomainFactor->setText(QCoreApplication::translate("MainWindow", "1.5", nullptr)); + label_86->setText(QCoreApplication::translate("MainWindow", "x domain size", nullptr)); + lineEditDomainMeters->setText(QCoreApplication::translate("MainWindow", "500", nullptr)); + label_87->setText(QCoreApplication::translate("MainWindow", "m beyond domain", nullptr)); + checkBox_DomainCutoffMeters->setText(QCoreApplication::translate("MainWindow", "Remove if", nullptr)); + label_90->setText(QCoreApplication::translate("MainWindow", "

Closed System

", nullptr)); + checkBox_ReflectiveBoundaries->setText(QCoreApplication::translate("MainWindow", "Reflective Boundaries", nullptr)); + checkBox_PeriodicBoundaries->setText(QCoreApplication::translate("MainWindow", "Periodic Boundaries", nullptr)); + groupBox_27->setTitle(QCoreApplication::translate("MainWindow", "Computational Model", nullptr)); + checkBox_HEModel->setText(QCoreApplication::translate("MainWindow", "Experimental High Energy Cascade Model", nullptr)); + checkBox_activateThermal->setText(QCoreApplication::translate("MainWindow", "Thermal Physics Extension Model", nullptr)); + tabWidget->setTabText(tabWidget->indexOf(tab), QCoreApplication::translate("MainWindow", "Computational Parameters", nullptr)); + labelFPMoist->setText(QCoreApplication::translate("MainWindow", "0", nullptr)); + labelFPHum->setText(QCoreApplication::translate("MainWindow", "0", nullptr)); + groupBox_9->setTitle(QCoreApplication::translate("MainWindow", "Detector", nullptr)); + label_36->setText(QCoreApplication::translate("MainWindow", "

Specify the lateral position and radius of the detector

", nullptr)); + lineEditDetRad->setText(QCoreApplication::translate("MainWindow", "9", nullptr)); + lineEditDetX->setText(QCoreApplication::translate("MainWindow", "0", nullptr)); + label_38->setText(QCoreApplication::translate("MainWindow", "y", nullptr)); + label_14->setText(QCoreApplication::translate("MainWindow", "Radius [m]", nullptr)); + label_37->setText(QCoreApplication::translate("MainWindow", "x", nullptr)); + label_13->setText(QCoreApplication::translate("MainWindow", "Position of the center [m]", nullptr)); + lineEditDety->setText(QCoreApplication::translate("MainWindow", "0", nullptr)); + checkBoxTransparent->setText(QCoreApplication::translate("MainWindow", "Transparent", nullptr)); + label_39->setText(QCoreApplication::translate("MainWindow", "

Neutrons are removed upon detection when non-transparent

", nullptr)); + groupBox_13->setTitle(QCoreApplication::translate("MainWindow", "Type", nullptr)); + radioButton_Sphere->setText(QCoreApplication::translate("MainWindow", "Sphere", nullptr)); + radioButton_Cylinder->setText(QCoreApplication::translate("MainWindow", "Vertical Cylinder", nullptr)); + radioButton_ySheet->setText(QCoreApplication::translate("MainWindow", "Sheet along y-Axis", nullptr)); + label_83->setText(QCoreApplication::translate("MainWindow", "

(Full Layer Height)

", nullptr)); + radioButton_xSheet->setText(QCoreApplication::translate("MainWindow", "Sheet along x-Axis", nullptr)); + groupBox_19->setTitle(QString()); + groupBox_16->setTitle(QCoreApplication::translate("MainWindow", "Precision", nullptr)); + radioButton_detectorEnergyBand->setText(QCoreApplication::translate("MainWindow", "Energy Band Model", nullptr)); + radioButton_detectorRealistic->setText(QCoreApplication::translate("MainWindow", "Physics Model", nullptr)); + lineEditDetLength->setText(QCoreApplication::translate("MainWindow", "9", nullptr)); + label_85->setText(QCoreApplication::translate("MainWindow", "Sheet Length [m]", nullptr)); + groupBox_10->setTitle(QCoreApplication::translate("MainWindow", "Detector Layer", nullptr)); + label_59->setText(QCoreApplication::translate("MainWindow", "

Record only for a specific Material

", nullptr)); + lineEditScotoma_2->setText(QCoreApplication::translate("MainWindow", "11", nullptr)); + checkBox->setText(QCoreApplication::translate("MainWindow", "Only Record in Material No", nullptr)); + checkBox_NoMultipleScattering->setText(QCoreApplication::translate("MainWindow", "Record Neutrons only once per Layer", nullptr)); + label_66->setText(QCoreApplication::translate("MainWindow", "

Exclude Multiple Scattering

", nullptr)); + checkBox_TrackAllLayers->setText(QCoreApplication::translate("MainWindow", "Track all Layers", nullptr)); + label_69->setText(QCoreApplication::translate("MainWindow", "

Enable Track Recording (but not Hits) for all Layers, not only the Detector Layer

", nullptr)); + groupBox_15->setTitle(QCoreApplication::translate("MainWindow", "Precision", nullptr)); + radioButton_detectorLayerEnergyBand->setText(QCoreApplication::translate("MainWindow", "Energy Band Model", nullptr)); + radioButton_detectorLayerRealistic->setText(QCoreApplication::translate("MainWindow", "Physics Model", nullptr)); + groupBox_14->setTitle(QCoreApplication::translate("MainWindow", "Detector and Detector Layer", nullptr)); + label_3->setText(QCoreApplication::translate("MainWindow", "

(Default values according to Hydroinnova: 0.0001 - 0.01 MeV)

", nullptr)); + label_41->setText(QCoreApplication::translate("MainWindow", "to", nullptr)); + label_22->setText(QCoreApplication::translate("MainWindow", "

Neutron-sensitive energy band limits

", nullptr)); + label_40->setText(QCoreApplication::translate("MainWindow", "MeV", nullptr)); + lineEditTHLhigh->setText(QCoreApplication::translate("MainWindow", "0.01", nullptr)); + lineEditTHLlow->setText(QCoreApplication::translate("MainWindow", "0.0001", nullptr)); + lineEditScotoma->setText(QCoreApplication::translate("MainWindow", "0", nullptr)); + label_51->setText(QCoreApplication::translate("MainWindow", "

Downward Scotoma Angle [0-360\302\260]

", nullptr)); + label_52->setText(QCoreApplication::translate("MainWindow", "

Blindness Region

", nullptr)); + label_79->setText(QCoreApplication::translate("MainWindow", "

Field of View Limitation

", nullptr)); + lineEditAntiScotoma->setText(QCoreApplication::translate("MainWindow", "360", nullptr)); + label_80->setText(QCoreApplication::translate("MainWindow", "

Downward Accpetance Angle [0-360\302\260]

", nullptr)); + label_74->setText(QCoreApplication::translate("MainWindow", "

Energy Band Model: 100% detection efficiency in the selected energy band.

Physics Model: energy and angular sensitivity according to a real detector.

", nullptr)); + tabWidget->setTabText(tabWidget->indexOf(tab_4), QCoreApplication::translate("MainWindow", "Detector", nullptr)); + label_44->setText(QCoreApplication::translate("MainWindow", "10^", nullptr)); + pushButton_2->setText(QCoreApplication::translate("MainWindow", "View spectrum", nullptr)); + label_8->setText(QCoreApplication::translate("MainWindow", "

Generated neutrons are sampled from an incoming spectrum. URANOS uses the incoming-only part of the analytical spectrum by Sato et al. (2006)

", nullptr)); + checkBoxBasicSpectrum->setText(QCoreApplication::translate("MainWindow", "use a Mean Basic Spectrum", nullptr)); + label->setText(QCoreApplication::translate("MainWindow", "Sampling magnitude:", nullptr)); + groupBox_6->setTitle(QCoreApplication::translate("MainWindow", "Estimated Radial Neutron Distribution at Sea Level", nullptr)); + pushButton_ActivateFP->setText(QCoreApplication::translate("MainWindow", "Auto Refresh", nullptr)); + label_48->setText(QCoreApplication::translate("MainWindow", "Integral Range:", nullptr)); + label_FPIntegral->setText(QCoreApplication::translate("MainWindow", "0", nullptr)); + labelIntegral->setText(QCoreApplication::translate("MainWindow", "0", nullptr)); + label_49->setText(QCoreApplication::translate("MainWindow", "Coverage:", nullptr)); + checkBoxFPLog->setText(QCoreApplication::translate("MainWindow", "Log", nullptr)); + label_73->setText(QCoreApplication::translate("MainWindow", "

Evaluate the domain extension by estimating the footprint size, use the sliders from the 'Physical Parameters' tab to change the environmental conditions.

", nullptr)); + tabWidget->setTabText(tabWidget->indexOf(tab_2), QCoreApplication::translate("MainWindow", "Showcase", nullptr)); + lineEdit_DetectorFile->setText(QCoreApplication::translate("MainWindow", "N/A", nullptr)); + label_15->setText(QCoreApplication::translate("MainWindow", "Cross Section Folder (containing the ENDF databases)", nullptr)); + lineEdit_WorkFolder->setText(QCoreApplication::translate("MainWindow", "default", nullptr)); + lineEdit_OutputFolder->setText(QCoreApplication::translate("MainWindow", "G:/Analyse/Simulation/Cosmics/", nullptr)); + label_25->setText(QCoreApplication::translate("MainWindow", "Detector Energy Calibration File", nullptr)); + label_17->setText(QCoreApplication::translate("MainWindow", "Output Folder", nullptr)); + lineEdit_CrosssectionFolder->setText(QCoreApplication::translate("MainWindow", "G:/Analyse/Simulation/ENDF", nullptr)); + label_16->setText(QCoreApplication::translate("MainWindow", "Input Spectrum Calculation File", nullptr)); + label_30->setText(QCoreApplication::translate("MainWindow", "Work Config Directory", nullptr)); + lineEdit_InputSpectrumFolder->setText(QCoreApplication::translate("MainWindow", "G:/Analyse/Simulation/Cosmics/results19/allHistos0.99_0.00.root", nullptr)); + label_33->setText(QCoreApplication::translate("MainWindow", "

Enter the paths to your folders

End folder paths by a slash \\

", nullptr)); + tabWidget->setTabText(tabWidget->indexOf(tab_5), QCoreApplication::translate("MainWindow", "Folders", nullptr)); + groupBox_7->setTitle(QCoreApplication::translate("MainWindow", "Map Export drawing options", nullptr)); + radioButton_expHeat->setText(QCoreApplication::translate("MainWindow", "Heat Map", nullptr)); + radioButton_expGray->setText(QCoreApplication::translate("MainWindow", "Gray Scale", nullptr)); + radioButton_expHeatInv->setText(QCoreApplication::translate("MainWindow", "Heat Map Inverted", nullptr)); + radioButton_expCool->setText(QCoreApplication::translate("MainWindow", "Dark Corona", nullptr)); + radioButton_expRainbow->setText(QCoreApplication::translate("MainWindow", "Rainbow", nullptr)); + radioButton_expDeviation->setText(QCoreApplication::translate("MainWindow", "Deviation", nullptr)); + label_53->setText(QCoreApplication::translate("MainWindow", "Compress by Factor", nullptr)); + checkBoxFileOutputPDF->setText(QCoreApplication::translate("MainWindow", "PDF Output", nullptr)); + label_43->setText(QCoreApplication::translate("MainWindow", "

Specify the data to be printed to the output folder

", nullptr)); + groupBox_22->setTitle(QCoreApplication::translate("MainWindow", "Histograms", nullptr)); + checkBoxDetectorDistanceData->setText(QCoreApplication::translate("MainWindow", "Detector Distance Data", nullptr)); + checkBoxDetectorLayerDistanceData->setText(QCoreApplication::translate("MainWindow", "Detector Layer Distance Data", nullptr)); + checkBoxTravelDistGraph->setText(QCoreApplication::translate("MainWindow", "Travel Distance Graphs", nullptr)); + checkBoxLogTravelDistance->setText(QCoreApplication::translate("MainWindow", "Log Y Axis", nullptr)); + groupBox_23->setTitle(QCoreApplication::translate("MainWindow", "Individual Neutron Data", nullptr)); + checkBoxExportAllTracks->setText(QCoreApplication::translate("MainWindow", "Export all Tracks", nullptr)); + checkBoxFileOutput->setText(QCoreApplication::translate("MainWindow", "Write Detector Neutron Hits to File", nullptr)); + checkBoxFileOutput2->setText(QCoreApplication::translate("MainWindow", "Write Detector Neutron Tracks to File", nullptr)); + label_89->setText(QCoreApplication::translate("MainWindow", "

Track exporting activates 'Track all Layers'

", nullptr)); + checkBoxFileOutput3->setText(QCoreApplication::translate("MainWindow", "Write Detector Layer Neutron Hits to File", nullptr)); + groupBox_24->setTitle(QCoreApplication::translate("MainWindow", "General Options", nullptr)); + checkBoxWarnMAterial->setText(QCoreApplication::translate("MainWindow", "Undefined Material Warnings", nullptr)); + checkBoxFileOutputPDF_2->setText(QCoreApplication::translate("MainWindow", "Advanced Analysis Raw Output (ROOT)", nullptr)); + label_62->setText(QCoreApplication::translate("MainWindow", "10^", nullptr)); + label_63->setText(QCoreApplication::translate("MainWindow", "Neutrons", nullptr)); + checkBoxCreateFolder->setText(QCoreApplication::translate("MainWindow", "Create new folder for every export", nullptr)); + checkBoxSaveEvery->setText(QCoreApplication::translate("MainWindow", "Export every", nullptr)); + groupBox_26->setTitle(QCoreApplication::translate("MainWindow", "Spatial Distributions", nullptr)); + checkBoxDetectorOriginData->setText(QCoreApplication::translate("MainWindow", "Detector Neutron Origins Data", nullptr)); + checkBoxHighResTrackingData->setText(QCoreApplication::translate("MainWindow", "High Res Track Data", nullptr)); + checkBoxDetectorOriginMap->setText(QCoreApplication::translate("MainWindow", "Detector Neutron Origins Map", nullptr)); + checkBoxSelectedMap->setText(QCoreApplication::translate("MainWindow", "Selected Energy Map", nullptr)); + checkBoxSelectedData->setText(QCoreApplication::translate("MainWindow", "Selected Energy Data", nullptr)); + checkBoxThermalMap->setText(QCoreApplication::translate("MainWindow", "Thermal Energy Map", nullptr)); + label_88->setText(QCoreApplication::translate("MainWindow", "

Detector data output

", nullptr)); + checkBoxIntermediateData->setText(QCoreApplication::translate("MainWindow", "Intermediate Energy Data", nullptr)); + label_54->setText(QCoreApplication::translate("MainWindow", "

Additional data output

", nullptr)); + checkBoxEpithermalMap->setText(QCoreApplication::translate("MainWindow", "Epithermal Map", nullptr)); + checkBoxThermalData->setText(QCoreApplication::translate("MainWindow", "Thermal Energy Data", nullptr)); + checkBoxFastMap->setText(QCoreApplication::translate("MainWindow", "Fast Neutron Map", nullptr)); + checkBoxFastData->setText(QCoreApplication::translate("MainWindow", "Fast Neutron Data", nullptr)); + checkBoxEpithermalData->setText(QCoreApplication::translate("MainWindow", "Epithermal Data", nullptr)); + checkBoxIntermediateMap->setText(QCoreApplication::translate("MainWindow", "Intermediate Energy Map", nullptr)); + checkBoxTrackingData->setText(QCoreApplication::translate("MainWindow", "Track Data", nullptr)); + tabWidget->setTabText(tabWidget->indexOf(tab_3), QCoreApplication::translate("MainWindow", "Export", nullptr)); + groupBox_5->setTitle(QCoreApplication::translate("MainWindow", "Displayed energy window", nullptr)); + radioButton_map->setText(QCoreApplication::translate("MainWindow", "1 eV-1 keV", nullptr)); + radioButton_mapInter->setText(QCoreApplication::translate("MainWindow", "1 keV-0.5 MeV", nullptr)); + radioButton_mapFast->setText(QCoreApplication::translate("MainWindow", "0.5 MeV-10 MeV", nullptr)); + radioButton_mapAlbedo->setText(QCoreApplication::translate("MainWindow", "Detector Selection", nullptr)); + checkBoxGradient2->setText(QCoreApplication::translate("MainWindow", "Gradient View", nullptr)); + radioButton_mapTrackAlbedo->setText(QCoreApplication::translate("MainWindow", "Detector Selection", nullptr)); + label_60->setText(QCoreApplication::translate("MainWindow", "Hit Density", nullptr)); + label_61->setText(QCoreApplication::translate("MainWindow", "Track Density", nullptr)); + radioButton_mapTrackFast->setText(QCoreApplication::translate("MainWindow", "0.5 MeV-10 MeV", nullptr)); + radioButton_mapTrackInter->setText(QCoreApplication::translate("MainWindow", "1 keV-0.5 MeV", nullptr)); + radioButton_mapTrack->setText(QCoreApplication::translate("MainWindow", "1 eV-1 keV", nullptr)); + radioButton_mapThermal->setText(QCoreApplication::translate("MainWindow", "Thermal", nullptr)); + radioButton_mapTrackThermal->setText(QCoreApplication::translate("MainWindow", "Thermal", nullptr)); + radioButton_mapTrackEnergy->setText(QCoreApplication::translate("MainWindow", "Energy Dependent", nullptr)); + groupBox_8->setTitle(QCoreApplication::translate("MainWindow", "Neutron Color Scheme", nullptr)); + radioButton_NeutronNight->setText(QCoreApplication::translate("MainWindow", "Dark Gray Scale", nullptr)); + radioButton_NeutronCold->setText(QCoreApplication::translate("MainWindow", "Cold", nullptr)); + radioButton_NeutronPolar->setText(QCoreApplication::translate("MainWindow", "Polar", nullptr)); + radioButton_NeutronRainbow->setText(QCoreApplication::translate("MainWindow", "URANOS", nullptr)); + label_46->setText(QCoreApplication::translate("MainWindow", "

Color range:

", nullptr)); + label_47->setText(QCoreApplication::translate("MainWindow", "Lower bound:", nullptr)); + label_50->setText(QCoreApplication::translate("MainWindow", "Upper bound:", nullptr)); + label_ColorRange->setText(QCoreApplication::translate("MainWindow", "[0-1]", nullptr)); + checkBoxManual->setText(QCoreApplication::translate("MainWindow", "Manual", nullptr)); + lineEditManualColorZero->setText(QCoreApplication::translate("MainWindow", "0", nullptr)); + lineEditManualColor->setText(QCoreApplication::translate("MainWindow", "0", nullptr)); + checkBoxLogarithmic->setText(QCoreApplication::translate("MainWindow", "Logarithmic", nullptr)); + radioButton_NeutronGrayScale->setText(QCoreApplication::translate("MainWindow", "Gray Scale", nullptr)); + radioButton_NeutronHot->setText(QCoreApplication::translate("MainWindow", "Hot", nullptr)); + radioButton_NeutronThermal->setText(QCoreApplication::translate("MainWindow", "Thermal", nullptr)); + groupBox_17->setTitle(QCoreApplication::translate("MainWindow", "Detector Color Scheme", nullptr)); + label_75->setText(QCoreApplication::translate("MainWindow", "Range of Interest", nullptr)); + label_DetectorRange->setText(QCoreApplication::translate("MainWindow", "-", nullptr)); + label_76->setText(QCoreApplication::translate("MainWindow", "Maximum Color Value:", nullptr)); + label_DetectorRangeMaximum->setText(QCoreApplication::translate("MainWindow", "-", nullptr)); + label_78->setText(QCoreApplication::translate("MainWindow", "Maximum Scale", nullptr)); + groupBox_18->setTitle(QCoreApplication::translate("MainWindow", "Computational Speed", nullptr)); + checkBoxNoTrack->setText(QCoreApplication::translate("MainWindow", "No Track Recording", nullptr)); + label_68->setText(QCoreApplication::translate("MainWindow", "

Disable Tracks and only count Layer hits

", nullptr)); + checkBoxAutoRefreshRate->setText(QCoreApplication::translate("MainWindow", "Auto Update", nullptr)); + lineEdit_AutoUpdate->setText(QCoreApplication::translate("MainWindow", "1", nullptr)); + label_82->setText(QCoreApplication::translate("MainWindow", "s", nullptr)); + groupBox_25->setTitle(QCoreApplication::translate("MainWindow", "Special Purpose", nullptr)); + checkBoxClearEveryDisplayRefresh->setText(QCoreApplication::translate("MainWindow", "Clear every display refresh", nullptr)); + label_81->setText(QCoreApplication::translate("MainWindow", "Neutrons", nullptr)); + lineEditClearEveryXNeutrons->setText(QCoreApplication::translate("MainWindow", "100", nullptr)); + checkBoxSaveEvery_2->setText(QCoreApplication::translate("MainWindow", "Clear every", nullptr)); + tabWidget->setTabText(tabWidget->indexOf(tab_6), QCoreApplication::translate("MainWindow", "Display", nullptr)); + pushButton->setText(QCoreApplication::translate("MainWindow", "Export", nullptr)); + pushButton_Pause->setText(QCoreApplication::translate("MainWindow", "Pause", nullptr)); + pushButton_stop->setText(QCoreApplication::translate("MainWindow", "Stop", nullptr)); + pushButton_Clear->setText(QCoreApplication::translate("MainWindow", "Clear", nullptr)); + pushButton_Simulate->setText(QCoreApplication::translate("MainWindow", "Simulate", nullptr)); + label_npers->setText(QCoreApplication::translate("MainWindow", "neutrons/sec", nullptr)); + neutronCountView->setText(QCoreApplication::translate("MainWindow", "# neutrons", nullptr)); + label_31->setText(QCoreApplication::translate("MainWindow", "neutrons", nullptr)); + label_18->setText(QCoreApplication::translate("MainWindow", "Refresh every", nullptr)); + lineEditRefresh->setText(QCoreApplication::translate("MainWindow", "100", nullptr)); + lineEditNeutrinsTotal->setText(QCoreApplication::translate("MainWindow", "500000", nullptr)); + label_9->setText(QCoreApplication::translate("MainWindow", "maximum:", nullptr)); + label_timeRemain->setText(QCoreApplication::translate("MainWindow", "()", nullptr)); + label_26->setText(QCoreApplication::translate("MainWindow", "#neutrons:", nullptr)); + label_Status->setText(QString()); + label_Status2->setText(QString()); + pushButton_SaveConfig->setText(QCoreApplication::translate("MainWindow", "Save CFG", nullptr)); + pushButton_about->setText(QString()); + pushButton_Enlarge->setText(QCoreApplication::translate("MainWindow", "+", nullptr)); + label_detectorLayerNs2->setText(QCoreApplication::translate("MainWindow", "-", nullptr)); + tabWidget_live->setTabText(tabWidget_live->indexOf(tab_7), QCoreApplication::translate("MainWindow", "Birds-eye View && Spectra", nullptr)); + label_24->setText(QCoreApplication::translate("MainWindow", "Range distribution of Neutrons passing the Detector Layer", nullptr)); + label_4->setText(QCoreApplication::translate("MainWindow", "Range distribution of Neutrons passing the Detector", nullptr)); + label_20->setText(QCoreApplication::translate("MainWindow", "Neutrons with Soil Contact", nullptr)); + detectorLayerRatioBar->setFormat(QCoreApplication::translate("MainWindow", "%p% ", nullptr)); + label_19->setText(QCoreApplication::translate("MainWindow", "Neutrons with Soil Contact", nullptr)); + detectorRatioBar->setFormat(QCoreApplication::translate("MainWindow", "%p% ", nullptr)); + checkBoxR->setText(QCoreApplication::translate("MainWindow", "Log", nullptr)); + checkBoxRS->setText(QCoreApplication::translate("MainWindow", "Log", nullptr)); + label_Footprint63D->setText(QCoreApplication::translate("MainWindow", "0 m", nullptr)); + label_Footprint86D->setText(QCoreApplication::translate("MainWindow", "0 m", nullptr)); + label_Footprint86DL->setText(QCoreApplication::translate("MainWindow", "0 m", nullptr)); + label_Footprint63DL->setText(QCoreApplication::translate("MainWindow", "0 m", nullptr)); + label_91->setText(QCoreApplication::translate("MainWindow", "Footprint: ", nullptr)); + label_92->setText(QCoreApplication::translate("MainWindow", "63 %:", nullptr)); + label_93->setText(QCoreApplication::translate("MainWindow", "86 %:", nullptr)); + label_94->setText(QCoreApplication::translate("MainWindow", "Near Field < 15 m:", nullptr)); + label_FootprintNFL->setText(QCoreApplication::translate("MainWindow", "0 %", nullptr)); + label_FootprintNF->setText(QCoreApplication::translate("MainWindow", "0 %", nullptr)); + label_95->setText(QCoreApplication::translate("MainWindow", "86 %:", nullptr)); + label_96->setText(QCoreApplication::translate("MainWindow", "Near Field < 15 m:", nullptr)); + label_97->setText(QCoreApplication::translate("MainWindow", "Footprint: ", nullptr)); + label_98->setText(QCoreApplication::translate("MainWindow", "63 %:", nullptr)); + tabWidget_live->setTabText(tabWidget_live->indexOf(tab_8), QCoreApplication::translate("MainWindow", "Range View", nullptr)); + label_23->setText(QCoreApplication::translate("MainWindow", "Profile view: horizontal slice along the x-axis", nullptr)); + label_5->setText(QCoreApplication::translate("MainWindow", "Depth of Interactions", nullptr)); + checkBoxD->setText(QCoreApplication::translate("MainWindow", "Log", nullptr)); + tabWidget_live->setTabText(tabWidget_live->indexOf(tab_9), QCoreApplication::translate("MainWindow", "Spatial View", nullptr)); + label_77->setText(QCoreApplication::translate("MainWindow", "Origins of Neutrons measured by the Detector [%]", nullptr)); + label_DetNeutrons->setText(QCoreApplication::translate("MainWindow", "# Total Neutrons:", nullptr)); + label_detectorNs->setText(QCoreApplication::translate("MainWindow", "()", nullptr)); + tabWidget_live->setTabText(tabWidget_live->indexOf(tab_10), QCoreApplication::translate("MainWindow", "Detector", nullptr)); + label_2->setText(QCoreApplication::translate("MainWindow", "Live:", nullptr)); + label_42->setText(QCoreApplication::translate("MainWindow", "U<\\font>RANOS<\\font>", nullptr)); + label_detectorLayerNs->setText(QCoreApplication::translate("MainWindow", "-", nullptr)); + } // retranslateUi + +}; + +namespace Ui { + class MainWindow: public Ui_MainWindow {}; +} // namespace Ui + +QT_END_NAMESPACE + +#endif // UI_MAINWINDOW_H diff --git a/ui_visualizationenlarge.h b/ui_visualizationenlarge.h new file mode 100644 index 0000000..c779ac7 --- /dev/null +++ b/ui_visualizationenlarge.h @@ -0,0 +1,60 @@ +/******************************************************************************** +** Form generated from reading UI file 'visualizationenlarge.ui' +** +** Created by: Qt User Interface Compiler version 5.15.2 +** +** WARNING! All changes made in this file will be lost when recompiling UI file! +********************************************************************************/ + +#ifndef UI_VISUALIZATIONENLARGE_H +#define UI_VISUALIZATIONENLARGE_H + +#include +#include +#include +#include +#include "qcustomplot.h" + +QT_BEGIN_NAMESPACE + +class Ui_VisualizationEnlarge +{ +public: + QCustomPlot *customPlot; + QPushButton *pushButtonPNG; + + void setupUi(QDialog *VisualizationEnlarge) + { + if (VisualizationEnlarge->objectName().isEmpty()) + VisualizationEnlarge->setObjectName(QString::fromUtf8("VisualizationEnlarge")); + VisualizationEnlarge->resize(1212, 1052); + VisualizationEnlarge->setMaximumSize(QSize(1250, 1052)); + customPlot = new QCustomPlot(VisualizationEnlarge); + customPlot->setObjectName(QString::fromUtf8("customPlot")); + customPlot->setGeometry(QRect(0, 0, 1211, 1052)); + customPlot->setMaximumSize(QSize(1250, 1052)); + pushButtonPNG = new QPushButton(customPlot); + pushButtonPNG->setObjectName(QString::fromUtf8("pushButtonPNG")); + pushButtonPNG->setGeometry(QRect(1140, 10, 61, 41)); + + retranslateUi(VisualizationEnlarge); + + QMetaObject::connectSlotsByName(VisualizationEnlarge); + } // setupUi + + void retranslateUi(QDialog *VisualizationEnlarge) + { + VisualizationEnlarge->setWindowTitle(QCoreApplication::translate("VisualizationEnlarge", "Enlarged Visualization", nullptr)); + pushButtonPNG->setText(QCoreApplication::translate("VisualizationEnlarge", "URANOS\n" +"Export", nullptr)); + } // retranslateUi + +}; + +namespace Ui { + class VisualizationEnlarge: public Ui_VisualizationEnlarge {}; +} // namespace Ui + +QT_END_NAMESPACE + +#endif // UI_VISUALIZATIONENLARGE_H