// "bw_fit_cucu200_3_test.C" 05/27/2008 // // try to compile the file "bw_fit_cucu200_2.C" // same code + extra header files. // #include #include #include "TH1F.h" #include "TH2F.h" #include "TF1.h" #include "TF2.h" #include "TMath.h" #include "TMinuit.h" #include "TCanvas.h" #include "TStyle.h" #include "TROOT.h" #include "TAxis.h" //#include "TGraph.h" #include "TGraphErrors.h" #include "TLegend.h" #include "TString.h" #include "TFrame.h" #include "TFile.h" #include "TAttLine.h" using namespace std; #ifdef __CINT__ //gROOT -> Reset(); #endif TCanvas * c1 = 0; TCanvas * c2 = 0; TCanvas * c3 = 0; TGraph * gr = 0; Int_t verbose = 0; TH1F* proton; TH1F* pbar; TGraphErrors* piplus; TGraphErrors* piminus; TGraphErrors* kplus; TGraphErrors* kminus; // pid - particle // 1 pi+ // -1 pi- // 2 K+ // -2 K- // 3 p+ // -3 p- const Double_t kPionMass = .1395679; const Double_t kKaonMass = .493646; const Double_t kProtonMass = .93827231; // 0 1 2 3 4 5 const Double_t kMass[6] = {0.93827231,0.493646,0.1395679,0.1395679,0.493646,0.93827231}; const Double_t kPiPYields[14] = {227.6,220.1,271.0,263.8,213.5,244.6,226.4,150.2,97.4,73.4,51.0,81.4,71.1,49.0}; const Double_t kPiMYields[14] = {227.1,221.3,273.5,262.0,215.7,198.2,229.5,151.0,74.6,71.3,51.7,86.7,72.7,50.3}; const Double_t kKPYields[12] = {43.0,42.3,44.6,35.9,38.0,31.4,18.8,10.9,5.9,7.3,8.1,9.6}; const Double_t kKMYields[12] = {38.9,39.8,42.4,41.7,35.5,28.2,25.6,14.6,5.4,6.6,5.8,7.2}; Double_t radius; TGraphErrors* pip_m005; TGraphErrors* pip_005; TGraphErrors* pip_010; TGraphErrors* pip_05; TGraphErrors* pip_07; TGraphErrors* pip_09; TGraphErrors* pip_11; TGraphErrors* pip_13; TGraphErrors* pip_22; TGraphErrors* pip_25; TGraphErrors* pip_305; TGraphErrors* pip_315; TGraphErrors* pip_325; TGraphErrors* pip_335; TGraphErrors* pip_353; TGraphErrors* pim_m005; TGraphErrors* pim_005; TGraphErrors* pim_010; TGraphErrors* pim_05; TGraphErrors* pim_07; TGraphErrors* pim_09; TGraphErrors* pim_11; TGraphErrors* pim_13; TGraphErrors* pim_22; TGraphErrors* pim_25; TGraphErrors* pim_305; TGraphErrors* pim_315; TGraphErrors* pim_325; TGraphErrors* pim_335; TGraphErrors* pim_353; TGraphErrors* kp_m005; TGraphErrors* kp_005; TGraphErrors* kp_010; TGraphErrors* kp_05; TGraphErrors* kp_07; TGraphErrors* kp_09; TGraphErrors* kp_11; TGraphErrors* kp_21; TGraphErrors* kp_24; TGraphErrors* kp_295; TGraphErrors* kp_305; TGraphErrors* kp_315; TGraphErrors* kp_33; TGraphErrors* km_m005; TGraphErrors* km_005; TGraphErrors* km_010; TGraphErrors* km_05; TGraphErrors* km_07; TGraphErrors* km_09; TGraphErrors* km_11; TGraphErrors* km_21; TGraphErrors* km_24; TGraphErrors* km_295; TGraphErrors* km_305; TGraphErrors* km_315; TGraphErrors* km_33; TH1F *proton0; TH1F *proton010; TH1F *proton1; TH1F *proton2; TH1F *proton3; TH1F *pbar0; TH1F *pbar010; TH1F *pbar1; TH1F *pbar2; TH1F *pbar3; TF2* flowfunc; //_____________________________________________________________________ //The fit function used for the individual fits. //A delta function for the flow profile is being used // -0.1 < y < 0.1 : x is pt void ppbarmt() { // Double_t xAxis[41] = {-5, -4, -3.5, -3, -2.5, -2, -1.8, -1.6, -1.4, -1.2, -1, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1, 1.2, 1.4, 1.6, 1.8, 2, 2.5, 3, 3.5, 4, 5}; // proton0 = new TH1F("proton0", "proton0", 40, xAxis); proton0 = new TH1F("proton0", "proton0", 40, 0.0, 4.0); proton0->SetBinContent(9,0.9621935); proton0->SetBinContent(10,0.7700493); proton0->SetBinContent(12,0.5452431); proton0->SetBinContent(14,0.3204075); proton0->SetBinContent(16,0.2175067); proton0->SetBinContent(18,0.1339763); proton0->SetBinContent(20,0.07801013); proton0->SetBinContent(23,0.0313385); proton0->SetBinContent(28,0.006505267); proton0->SetBinContent(33,0.001995585); proton0->SetBinError(9,0.1626404); proton0->SetBinError(10,0.08117032); proton0->SetBinError(12,0.0370991); proton0->SetBinError(14,0.02090109); proton0->SetBinError(16,0.01308563); proton0->SetBinError(18,0.008004293); proton0->SetBinError(20,0.005316565); proton0->SetBinError(23,0.001770623); proton0->SetBinError(28,0.0006517963); proton0->SetBinError(33,0.0003119073); proton010 = new TH1F("proton010", "proton010", 40, 0.0, 4.0); proton010->SetBinContent(7,1.359781); proton010->SetBinContent(8,1.200953); proton010->SetBinContent(9,0.9717883); proton010->SetBinContent(10,0.7670724); proton010->SetBinContent(12,0.5314806); proton010->SetBinContent(14,0.3241186); proton010->SetBinContent(16,0.2002205); proton010->SetBinContent(18,0.121423); proton010->SetBinContent(20,0.06457318); proton010->SetBinContent(23,0.02606589); proton010->SetBinContent(28,0.005904807); proton010->SetBinContent(33,0.001537021); proton010->SetBinError(7,0.1940817); proton010->SetBinError(8,0.1343932); proton010->SetBinError(9,0.08440627); proton010->SetBinError(10,0.05893196); proton010->SetBinError(12,0.02707527); proton010->SetBinError(14,0.015802); proton010->SetBinError(16,0.01044247); proton010->SetBinError(18,0.006988453); proton010->SetBinError(20,0.004669499); proton010->SetBinError(23,0.001625219); proton010->SetBinError(28,0.0006654084); proton010->SetBinError(33,0.0003020695); /* proton0 = new TH1F("proton0","proton0",40,0,4); proton0->SetBinContent(5,4.96297); proton0->SetBinContent(6,5.04125); proton0->SetBinContent(7,4.8749); proton0->SetBinContent(8,4.42009); proton0->SetBinContent(9,3.76669); proton0->SetBinContent(10,3.4105); proton0->SetBinContent(11,2.79877); proton0->SetBinContent(12,2.31541); proton0->SetBinContent(13,1.96245); proton0->SetBinContent(14,1.50201); proton0->SetBinContent(15,1.24244); proton0->SetBinContent(16,0.919223); proton0->SetBinContent(17,0.730941); proton0->SetBinContent(18,0.587923); proton0->SetBinContent(19,0.443977); proton0->SetBinContent(20,0.284007); proton0->SetBinContent(21,0.264836); proton0->SetBinContent(22,0.192134); proton0->SetBinContent(23,0.143025); proton0->SetBinContent(24,0.104202); proton0->SetBinContent(25,0.0812759); proton0->SetBinContent(26,0.044497); proton0->SetBinContent(27,0.052073); proton0->SetBinContent(28,0.0304725); proton0->SetBinContent(29,0.0291881); proton0->SetBinError(5,0.506531); proton0->SetBinError(6,0.322073); proton0->SetBinError(7,0.237306); proton0->SetBinError(8,0.185463); proton0->SetBinError(9,0.148428); proton0->SetBinError(10,0.125713); proton0->SetBinError(11,0.103658); proton0->SetBinError(12,0.0872653); proton0->SetBinError(13,0.0746551); proton0->SetBinError(14,0.0617324); proton0->SetBinError(15,0.053318); proton0->SetBinError(16,0.0436244); proton0->SetBinError(17,0.0373493); proton0->SetBinError(18,0.0321217); proton0->SetBinError(19,0.0270196); proton0->SetBinError(20,0.0209373); proton0->SetBinError(21,0.0194187); proton0->SetBinError(22,0.0160671); proton0->SetBinError(23,0.0135146); proton0->SetBinError(24,0.0113023); proton0->SetBinError(25,0.00971433); proton0->SetBinError(26,0.00703559); proton0->SetBinError(27,0.007439); proton0->SetBinError(28,0.0055635); proton0->SetBinError(29,0.00532899); */ // pbar0 = new TH1F("pbar0", "pbar0", 40, xAxis); pbar0 = new TH1F("pbar0", "pbar0", 40, 0.0, 4.0); pbar0->SetBinContent(7,0.9839001); pbar0->SetBinContent(8,0.9515273); pbar0->SetBinContent(9,0.7075449); pbar0->SetBinContent(10,0.5921285); pbar0->SetBinContent(12,0.4213825); pbar0->SetBinContent(14,0.2785274); pbar0->SetBinContent(16,0.1377907); pbar0->SetBinContent(18,0.08526693); pbar0->SetBinContent(20,0.0453942); pbar0->SetBinContent(23,0.01897146); pbar0->SetBinContent(28,0.004062258); pbar0->SetBinContent(33,0.001492373); pbar0->SetBinError(7,0.07546169); pbar0->SetBinError(8,0.05935464); pbar0->SetBinError(9,0.04290121); pbar0->SetBinError(10,0.03526074); pbar0->SetBinError(12,0.01798417); pbar0->SetBinError(14,0.01287493); pbar0->SetBinError(16,0.008091349); pbar0->SetBinError(18,0.005815694); pbar0->SetBinError(20,0.0038784); pbar0->SetBinError(23,0.001355405); pbar0->SetBinError(28,0.0005334261); pbar0->SetBinError(33,0.0002702042); pbar010 = new TH1F("pbar010", "pbar010", 40, 0.0, 4.0); pbar010->SetBinContent(33,0.00129272); pbar010->SetBinContent(28,0.004364775); pbar010->SetBinContent(23,0.01912744); pbar010->SetBinContent(20,0.04946647); pbar010->SetBinContent(18,0.08669129); pbar010->SetBinContent(16,0.1486695); pbar010->SetBinContent(14,0.2671016); pbar010->SetBinContent(12,0.4123684); pbar010->SetBinContent(10,0.6006832); pbar010->SetBinContent(9,0.714512); pbar010->SetBinContent(8,0.8936495); pbar010->SetBinContent(7,0.9839613); pbar010->SetBinError(33,0.0002769998); pbar010->SetBinError(28,0.0005845679); pbar010->SetBinError(23,0.00141298); pbar010->SetBinError(20,0.004098914); pbar010->SetBinError(18,0.006021516); pbar010->SetBinError(16,0.008886296); pbar010->SetBinError(14,0.01370758); pbar010->SetBinError(12,0.01925563); pbar010->SetBinError(10,0.03739713); pbar010->SetBinError(9,0.04478887); pbar010->SetBinError(8,0.05849748); pbar010->SetBinError(7,0.07346757); /* pbar0 = new TH1F("pbar0","pbar0",40,0,4); pbar0->SetBinContent(5,0.345083*10.); pbar0->SetBinContent(6,0.379241*10.); pbar0->SetBinContent(7,0.365338*10.); pbar0->SetBinContent(8,0.327043*10.); pbar0->SetBinContent(9,0.286911*10.); pbar0->SetBinContent(10,0.249952*10.); pbar0->SetBinContent(11,0.210954*10.); pbar0->SetBinContent(12,0.190219*10.); pbar0->SetBinContent(13,0.154686*10.); pbar0->SetBinContent(14,0.114012*10.); pbar0->SetBinContent(15,0.0884939*10.); pbar0->SetBinContent(16,0.0768411*10.); pbar0->SetBinContent(17,0.0477758*10.); pbar0->SetBinContent(18,0.0463364*10.); pbar0->SetBinContent(19,0.0283362*10.); pbar0->SetBinContent(20,0.0217106*10.); pbar0->SetBinContent(21,0.0196272*10.); pbar0->SetBinContent(22,0.0115575*10.); pbar0->SetBinContent(23,0.0118354*10.); pbar0->SetBinContent(24,0.00900192*10.); pbar0->SetBinContent(25,0.00565479*10.); pbar0->SetBinContent(26,0.00440954*10.); pbar0->SetBinContent(27,0.00299023*10.); pbar0->SetBinContent(28,0.00208566*10.); pbar0->SetBinContent(29,0.00283519*10.); pbar0->SetBinError(5,0.0431354*10.); pbar0->SetBinError(6,0.027958*10.); pbar0->SetBinError(7,0.0202033*10.); pbar0->SetBinError(8,0.0156625*10.); pbar0->SetBinError(9,0.0127421*10.); pbar0->SetBinError(10,0.0105063*10.); pbar0->SetBinError(11,0.00878212*10.); pbar0->SetBinError(12,0.00770173*10.); pbar0->SetBinError(13,0.00651347*10.); pbar0->SetBinError(14,0.00527583*10.); pbar0->SetBinError(15,0.00440819*10.); pbar0->SetBinError(16,0.00391111*10.); pbar0->SetBinError(17,0.00296293*10.); pbar0->SetBinError(18,0.00280956*10.); pbar0->SetBinError(19,0.00211795*10.); pbar0->SetBinError(20,0.00179678*10.); pbar0->SetBinError(21,0.00165291*10.); pbar0->SetBinError(22,0.00123204*10.); pbar0->SetBinError(23,0.00121428*10.); pbar0->SetBinError(24,0.00103259*10.); pbar0->SetBinError(25,0.000799708*10.); pbar0->SetBinError(26,0.000688654*10.); pbar0->SetBinError(27,0.000555271*10.); pbar0->SetBinError(28,0.000455129*10.); pbar0->SetBinError(29,0.000517632*10.); */ // 0.75 < y < 0.95 proton1 = new TH1F("proton1","proton1",40,0,4); proton1->SetBinContent(6,4.99); proton1->SetBinContent(7,4.75568); proton1->SetBinContent(8,4.1); proton1->SetBinContent(9,3.6567); proton1->SetBinContent(10,3.20418); proton1->SetBinContent(11,2.54565); proton1->SetBinContent(12,2.14149); proton1->SetBinContent(13,1.80865); proton1->SetBinContent(14,1.42897); proton1->SetBinContent(15,1.11169); proton1->SetBinContent(16,0.848965); proton1->SetBinContent(17,0.675544); proton1->SetBinContent(18,0.511686); proton1->SetBinContent(19,0.363977); proton1->SetBinContent(20,0.291042); proton1->SetBinError(6,0.361064); proton1->SetBinError(7,0.249265); proton1->SetBinError(8,0.191163); proton1->SetBinError(9,0.154939); proton1->SetBinError(10,0.127355); proton1->SetBinError(11,0.100783); proton1->SetBinError(12,0.0831685); proton1->SetBinError(13,0.0704017); proton1->SetBinError(14,0.0591314); proton1->SetBinError(15,0.0495679); proton1->SetBinError(16,0.0418255); proton1->SetBinError(17,0.0359048); proton1->SetBinError(18,0.0303097); proton1->SetBinError(19,0.0256729); proton1->SetBinError(20,0.0264584); pbar1 = new TH1F("pbar1","pbar1",40,0,4); pbar1->SetBinContent(6,0.350163*10.); pbar1->SetBinContent(7,0.303731*10.); pbar1->SetBinContent(8,0.279458*10.); pbar1->SetBinContent(9,0.235054*10.); pbar1->SetBinContent(10,0.201229*10.); pbar1->SetBinContent(11,0.1863*10.); pbar1->SetBinContent(12,0.148166*10.); pbar1->SetBinContent(13,0.131684*10.); pbar1->SetBinContent(14,0.100762*10.); pbar1->SetBinContent(15,0.0784053*10.); pbar1->SetBinContent(16,0.0673877*10.); pbar1->SetBinContent(17,0.0477321*10.); pbar1->SetBinContent(18,0.0377246*10.); pbar1->SetBinContent(19,0.030245*10.); pbar1->SetBinContent(20,0.0233662*10.); pbar1->SetBinError(6,0.0371172*10.); pbar1->SetBinError(7,0.0237174*10.); pbar1->SetBinError(8,0.0179642*10.); pbar1->SetBinError(9,0.0131399*10.); pbar1->SetBinError(10,0.0101896*10.); pbar1->SetBinError(11,0.00863944*10.); pbar1->SetBinError(12,0.00695376*10.); pbar1->SetBinError(13,0.00600429*10.); pbar1->SetBinError(14,0.00493432*10.); pbar1->SetBinError(15,0.00416719*10.); pbar1->SetBinError(16,0.00374955*10.); pbar1->SetBinError(17,0.00303712*10.); pbar1->SetBinError(18,0.00260325*10.); pbar1->SetBinError(19,0.00233345*10.); pbar1->SetBinError(20,0.00236034*10.); // 1.7 < y < 2.4 proton2 = new TH1F("proton2","proton2",40,0,4); proton2->SetBinContent(3,7.08717); proton2->SetBinContent(4,6.22472); proton2->SetBinContent(5,6.2); proton2->SetBinContent(6,5.83158); proton2->SetBinContent(7,4.54903); proton2->SetBinContent(8,4.39635); proton2->SetBinContent(9,4.05905); proton2->SetBinContent(10,3.13093); proton2->SetBinContent(11,2.57794); proton2->SetBinContent(12,1.97477); proton2->SetBinContent(13,1.31337); proton2->SetBinError(3,0.301377); proton2->SetBinError(4,0.287431); proton2->SetBinError(5,0.292923); proton2->SetBinError(6,0.285574); proton2->SetBinError(7,0.290627); proton2->SetBinError(8,0.277495); proton2->SetBinError(9,0.247946); proton2->SetBinError(10,0.209662); proton2->SetBinError(11,0.188517); proton2->SetBinError(12,0.214194); proton2->SetBinError(13,0.364263); pbar2 = new TH1F("pbar2","pbar2",40,0,4); pbar2->SetBinContent(3,0.285589*10.); pbar2->SetBinContent(4,0.285984*10.); pbar2->SetBinContent(5,0.273896*10.); pbar2->SetBinContent(6,0.260172*10.); pbar2->SetBinContent(7,0.253929*10.); pbar2->SetBinContent(8,0.240157*10.); pbar2->SetBinContent(9,0.161381*10.); pbar2->SetBinContent(10,0.171563*10.); pbar2->SetBinContent(11,0.145817*10.); pbar2->SetBinContent(12,0.103228*10.); pbar2->SetBinContent(13,0.0454593*10.); pbar2->SetBinError(3,0.0281399*10.); pbar2->SetBinError(4,0.0291881*10.); pbar2->SetBinError(5,0.0224384*10.); pbar2->SetBinError(6,0.0185837*10.); pbar2->SetBinError(7,0.0184706*10.); pbar2->SetBinError(8,0.0149806*10.); pbar2->SetBinError(9,0.011163*10.); pbar2->SetBinError(10,0.0114375*10.); pbar2->SetBinError(11,0.0107207*10.); pbar2->SetBinError(12,0.0114697*10.); pbar2->SetBinError(13,0.013123*10.); //2.7 < y < 3.1 proton3 = new TH1F("proton3","proton3",40,0,4); proton3->SetBinContent(7,4.47843); proton3->SetBinContent(8,3.53917); proton3->SetBinContent(9,2.8043); proton3->SetBinContent(10,1.96929); proton3->SetBinContent(11,1.61628); proton3->SetBinContent(12,1.3136); proton3->SetBinContent(13,1.01744); proton3->SetBinContent(14,0.811287); proton3->SetBinContent(15,0.590615); proton3->SetBinContent(16,0.443453); proton3->SetBinContent(17,0.261902); proton3->SetBinContent(18,0.217062); proton3->SetBinContent(19,0.166837); proton3->SetBinContent(20,0.116745); proton3->SetBinContent(21,0.105785); proton3->SetBinContent(22,0.0447308); proton3->SetBinError(7,0.246392); proton3->SetBinError(8,0.155088); proton3->SetBinError(9,0.110432); proton3->SetBinError(10,0.0835308); proton3->SetBinError(11,0.0725013); proton3->SetBinError(12,0.0635349); proton3->SetBinError(13,0.0551855); proton3->SetBinError(14,0.0489212); proton3->SetBinError(15,0.0421869); proton3->SetBinError(16,0.037107); proton3->SetBinError(17,0.0294753); proton3->SetBinError(18,0.0270374); proton3->SetBinError(19,0.02578); proton3->SetBinError(20,0.0213145); proton3->SetBinError(21,0.0215932); proton3->SetBinError(22,0.0158147); pbar3 = new TH1F("pbar3","pbar3",40,0,4.); pbar3->SetBinContent(7,0.0868332*10.); pbar3->SetBinContent(8,0.0754641*10.); pbar3->SetBinContent(9,0.0821609*10.); pbar3->SetBinContent(10,0.0619692*10.); pbar3->SetBinContent(11,0.0467873*10.); pbar3->SetBinContent(12,0.0379553*10.); pbar3->SetBinContent(13,0.0241025*10.); pbar3->SetBinContent(14,0.0195507*10.); pbar3->SetBinContent(15,0.016443*10.); pbar3->SetBinContent(16,0.00731048*10.); pbar3->SetBinContent(17,0.00814105*10.); pbar3->SetBinContent(18,0.00310262*10.); pbar3->SetBinContent(19,0.00174816*10.); pbar3->SetBinContent(20,0.00195265*10.); pbar3->SetBinContent(21,0.00035976*10.); pbar3->SetBinContent(22,0.00134999*10.); pbar3->SetBinError(7,0.0113121*10.); pbar3->SetBinError(8,0.00749471*10.); pbar3->SetBinError(9,0.00600555*10.); pbar3->SetBinError(10,0.00463889*10.); pbar3->SetBinError(11,0.00386112*10.); pbar3->SetBinError(12,0.00332057*10.); pbar3->SetBinError(13,0.00259195*10.); pbar3->SetBinError(14,0.00227361*10.); pbar3->SetBinError(15,0.00208712*10.); pbar3->SetBinError(16,0.00145074*10.); pbar3->SetBinError(17,0.0015308*10.); pbar3->SetBinError(18,0.00098638*10.); pbar3->SetBinError(19,0.000713685*10.); pbar3->SetBinError(20,0.000797165*10.); pbar3->SetBinError(21,0.00035976*10.); pbar3->SetBinError(22,0.000779419*10.); } void pionpt() { pip_m005 = new TGraphErrors(20); pip_005 = new TGraphErrors(20); pip_010 = new TGraphErrors(20); pip_05 = new TGraphErrors(20); pip_07 = new TGraphErrors(20); pip_09 = new TGraphErrors(20); pip_11 = new TGraphErrors(20); pip_13 = new TGraphErrors(20); pip_22 = new TGraphErrors(20); pip_25 = new TGraphErrors(20); pip_305 = new TGraphErrors(20); pip_315 = new TGraphErrors(20); pip_325 = new TGraphErrors(20); pip_335 = new TGraphErrors(20); pip_353 = new TGraphErrors(20); pim_m005 = new TGraphErrors(20); pim_005 = new TGraphErrors(20); pim_010 = new TGraphErrors(20); pim_05 = new TGraphErrors(20); pim_07 = new TGraphErrors(20); pim_09 = new TGraphErrors(20); pim_11 = new TGraphErrors(20); pim_13 = new TGraphErrors(20); pim_22 = new TGraphErrors(20); pim_25 = new TGraphErrors(20); pim_305 = new TGraphErrors(20); pim_315 = new TGraphErrors(20); pim_325 = new TGraphErrors(20); pim_335 = new TGraphErrors(20); pim_353 = new TGraphErrors(20); pip_m005->SetPoint(0,0.15,1e+19); pip_m005->SetPointError(0,0,24.3737); pip_m005->SetPoint(1,0.25,319.8); pip_m005->SetPointError(1,0,11.7402); pip_m005->SetPoint(2,0.35,203.464); pip_m005->SetPointError(2,0,5.24643); pip_m005->SetPoint(3,0.45,116.942); pip_m005->SetPointError(3,0,2.42267); pip_m005->SetPoint(4,0.55,77.125); pip_m005->SetPointError(4,0,1.23483); pip_m005->SetPoint(5,0.65,47.8413); pip_m005->SetPointError(5,0,0.736369); pip_m005->SetPoint(6,0.75,31.2874); pip_m005->SetPointError(6,0,0.507616); pip_m005->SetPoint(7,0.85,20.0126); pip_m005->SetPointError(7,0,0.359032); pip_m005->SetPoint(8,0.95,13.1069); pip_m005->SetPointError(8,0,0.265179); pip_m005->SetPoint(9,1.05,9.40824); pip_m005->SetPointError(9,0,0.207591); pip_m005->SetPoint(10,1.15,6.10324); pip_m005->SetPointError(10,0,0.158807); pip_m005->SetPoint(11,1.25,4.27247); pip_m005->SetPointError(11,0,0.126595); pip_m005->SetPoint(12,1.35,3.03011); pip_m005->SetPointError(12,0,0.100063); pip_m005->SetPoint(13,1.45,1.89326); pip_m005->SetPointError(13,0,0.0763437); pip_m005->SetPoint(14,1.55,1.33639); pip_m005->SetPointError(14,0,0.0611252); pip_m005->SetPoint(15,1.65,0.949562); pip_m005->SetPointError(15,0,0.049977); pip_m005->SetPoint(16,1.75,0.6206); pip_m005->SetPointError(16,0,0.0390941); pip_m005->SetPoint(17,1.85,0.46201); pip_m005->SetPointError(17,0,0.0330007); pip_m005->SetPoint(18,1.95,0.290194); pip_m005->SetPointError(18,0,0.0253544); pip_005->SetPoint( 0, 0.55, 16.72901); pip_005->SetPointError( 0, 0.0, 1.408837); pip_005->SetPoint( 1, 0.65, 10.80043); pip_005->SetPointError( 1, 0.0, 0.4036309); pip_005->SetPoint( 2, 0.75, 6.629601); pip_005->SetPointError( 2, 0.0, 0.2488045); pip_005->SetPoint( 3, 0.85, 4.295793); pip_005->SetPointError( 3, 0.0, 0.1871277); pip_005->SetPoint( 4, 0.95, 2.715191); pip_005->SetPointError( 4, 0.0, 0.1279953); pip_005->SetPoint( 5, 1.1, 1.589037); pip_005->SetPointError( 5, 0.0, 0.05748934); pip_005->SetPoint( 6, 1.3, 0.7468455); pip_005->SetPointError( 6, 0.0, 0.03698026); pip_005->SetPoint( 7, 1.5, 0.3510806); pip_005->SetPointError( 7, 0.0, 0.01865975); pip_005->SetPoint( 8, 1.7, 0.1818875); pip_005->SetPointError( 8, 0.0, 0.00975872); pip_005->SetPoint( 9, 1.9, 0.09977826); pip_005->SetPointError( 9, 0.0, 0.006037776); pip_005->SetPoint( 10, 2.25, 0.03188844); pip_005->SetPointError( 10, 0.0, 0.001746114); pip_010->SetPoint( 0, 0.45, 28.30753); pip_010->SetPoint( 1, 0.55, 17.24632); pip_010->SetPoint( 2, 0.65, 10.70474); pip_010->SetPoint( 3, 0.75, 6.720269); pip_010->SetPoint( 4, 0.85, 4.336019); pip_010->SetPoint( 5, 0.95, 2.869512); pip_010->SetPoint( 6, 1.1, 1.537559); pip_010->SetPoint( 7, 1.3, 0.6919332); pip_010->SetPoint( 8, 1.5, 0.3381758); pip_010->SetPoint( 9, 1.7, 0.1702579); pip_010->SetPoint(10, 1.9, 0.09092991); pip_010->SetPoint(11, 2.25, 0.0310628); pip_010->SetPointError( 0, 0.0, 0.36238); pip_010->SetPointError( 1, 0.0, 1.225559); pip_010->SetPointError( 2, 0.0, 0.3916762); pip_010->SetPointError( 3, 0.0, 0.2206333); pip_010->SetPointError( 4, 0.0, 0.1566143); pip_010->SetPointError( 5, 0.0, 0.1031435); pip_010->SetPointError( 6, 0.0, 0.04442475); pip_010->SetPointError( 7, 0.0, 0.0231945); pip_010->SetPointError( 8, 0.0, 0.01343264); pip_010->SetPointError( 9, 0.0, 0.008229787); pip_010->SetPointError(10, 0.0, 0.005428944); pip_010->SetPointError(11, 0.0, 0.001726309); /* pip_005->SetPoint(0,0.15,1e+19*10.); pip_005->SetPointError(0,0,2.17509*10.); pip_005->SetPoint(1,0.25,31.8445*10.); pip_005->SetPointError(1,0,1.13083*10.); pip_005->SetPoint(2,0.35,20.3225*10.); pip_005->SetPointError(2,0,0.540256*10.); pip_005->SetPoint(3,0.45,12.2386*10.); pip_005->SetPointError(3,0,0.287035*10.); pip_005->SetPoint(4,0.55,7.28992*10.); pip_005->SetPointError(4,0,0.170504*10.); pip_005->SetPoint(5,0.65,4.91463*10.); pip_005->SetPointError(5,0,0.114885*10.); pip_005->SetPoint(6,0.75,3.08861*10.); pip_005->SetPointError(6,0,0.0764546*10.); pip_005->SetPoint(7,0.85,2.04681*10.); pip_005->SetPointError(7,0,0.0532043*10.); pip_005->SetPoint(8,0.95,1.29052*10.); pip_005->SetPointError(8,0,0.0372696*10.); pip_005->SetPoint(9,1.05,0.926047*10.); pip_005->SetPointError(9,0,0.0290813*10.); pip_005->SetPoint(10,1.15,0.607085*10.); pip_005->SetPointError(10,0,0.0221972*10.); pip_005->SetPoint(11,1.25,0.404647*10.); pip_005->SetPointError(11,0,0.0164649*10.); pip_005->SetPoint(12,1.35,0.272459*10.); pip_005->SetPointError(12,0,0.0128296*10.); pip_005->SetPoint(13,1.45,0.189166*10.); pip_005->SetPointError(13,0,0.0102289*10.); pip_005->SetPoint(14,1.55,0.13132*10.); pip_005->SetPointError(14,0,0.00802164*10.); pip_005->SetPoint(15,1.65,0.0913431*10.); pip_005->SetPointError(15,0,0.00645893*10.); pip_005->SetPoint(16,1.75,0.0701845*10.); pip_005->SetPointError(16,0,0.00546386*10.); pip_005->SetPoint(17,1.85,0.0520911*10.); pip_005->SetPointError(17,0,0.00446677*10.); pip_005->SetPoint(18,1.95,0.0274166*10.); pip_005->SetPointError(18,0,0.0031449*10.); */ pip_05->SetPoint(0,0.15,4.69491*100.); pip_05->SetPointError(0,0,0.920747*100.); pip_05->SetPoint(1,0.25,3.00898*100.); pip_05->SetPointError(1,0,0.0725318*100.); pip_05->SetPoint(2,0.35,1.97961*100.); pip_05->SetPointError(2,0,0.0341769*100.); pip_05->SetPoint(3,0.45,1.19725*100.); pip_05->SetPointError(3,0,0.0209272*100.); pip_05->SetPoint(4,0.55,0.77941*100.); pip_05->SetPointError(4,0,0.0144236*100.); pip_05->SetPoint(5,0.65,0.464895*100.); pip_05->SetPointError(5,0,0.0099937*100.); pip_05->SetPoint(6,0.75,0.298848*100.); pip_05->SetPointError(6,0,0.00737054*100.); pip_05->SetPoint(7,0.85,0.19815*100.); pip_05->SetPointError(7,0,0.00554064*100.); pip_05->SetPoint(8,0.95,0.130098*100.); pip_05->SetPointError(8,0,0.00422763*100.); pip_05->SetPoint(9,1.05,0.0848951*100.); pip_05->SetPointError(9,0,0.00324367*100.); pip_05->SetPoint(10,1.15,0.0611624*100.); pip_05->SetPointError(10,0,0.00260561*100.); pip_05->SetPoint(11,1.25,0.0389015*100.); pip_05->SetPointError(11,0,0.00198778*100.); pip_05->SetPoint(12,1.35,0.0262157*100.); pip_05->SetPointError(12,0,0.0015639*100.); pip_05->SetPoint(13,1.45,0.017595*100.); pip_05->SetPointError(13,0,0.00123493*100.); pip_05->SetPoint(14,1.55,0.0120179*100.); pip_05->SetPointError(14,0,0.00098126*100.); pip_05->SetPoint(15,1.65,0.00826266*100.); pip_05->SetPointError(15,0,0.000791419*100.); pip_05->SetPoint(16,1.75,0.00579428*100.); pip_05->SetPointError(16,0,0.000979412*100.); pip_07->SetPoint(0,0.15,0.434138*1000.); pip_07->SetPointError(0,0,0.0348708*1000.); pip_07->SetPoint(1,0.25,0.299063*1000.); pip_07->SetPointError(1,0,0.00648911*1000.); pip_07->SetPoint(2,0.35,0.190893*1000.); pip_07->SetPointError(2,0,0.00261645*1000.); pip_07->SetPoint(3,0.45,0.119263*1000.); pip_07->SetPointError(3,0,0.00175595*1000.); pip_07->SetPoint(4,0.55,0.075518*1000.); pip_07->SetPointError(4,0,0.0012405*1000.); pip_07->SetPoint(5,0.65,0.045887*1000.); pip_07->SetPointError(5,0,0.000875668*1000.); pip_07->SetPoint(6,0.75,0.0295133*1000.); pip_07->SetPointError(6,0,0.000647745*1000.); pip_07->SetPoint(7,0.85,0.0192082*1000.); pip_07->SetPointError(7,0,0.000487574*1000.); pip_07->SetPoint(8,0.95,0.0124777*1000.); pip_07->SetPointError(8,0,0.00036699*1000.); pip_07->SetPoint(9,1.05,0.00806112*1000.); pip_07->SetPointError(9,0,0.000279637*1000.); pip_07->SetPoint(10,1.15,0.00569285*1000.); pip_07->SetPointError(10,0,0.000224679*1000.); pip_07->SetPoint(11,1.25,0.00370104*1000.); pip_07->SetPointError(11,0,0.000173127*1000.); pip_07->SetPoint(12,1.35,0.00259927*1000.); pip_07->SetPointError(12,0,0.000139136*1000.); pip_07->SetPoint(13,1.45,0.00163878*1000.); pip_07->SetPointError(13,0,0.000106226*1000.); pip_07->SetPoint(14,1.55,0.00117451*1000.); pip_07->SetPointError(14,0,0.000114621*1000.); pip_07->SetPoint(15,1.65,1e+19*1000.); pip_07->SetPointError(15,0,0.000164806*1000.); pip_09->SetPoint(0,0.15,1e+19*10000.); pip_09->SetPointError(0,0,0.00135905*10000.); pip_09->SetPoint(1,0.25,0.0304125*10000.); pip_09->SetPointError(1,0,0.000396374*10000.); pip_09->SetPoint(2,0.35,0.0191475*10000.); pip_09->SetPointError(2,0,0.000190421*10000.); pip_09->SetPoint(3,0.45,0.0118337*10000.); pip_09->SetPointError(3,0,0.00010852*10000.); pip_09->SetPoint(4,0.55,0.00727143*10000.); pip_09->SetPointError(4,0,7.07567e-05*10000.); pip_09->SetPoint(5,0.65,0.00458066*10000.); pip_09->SetPointError(5,0,4.99524e-05*10000.); pip_09->SetPoint(6,0.75,0.00291474*10000.); pip_09->SetPointError(6,0,3.63407e-05*10000.); pip_09->SetPoint(7,0.85,0.00188877*10000.); pip_09->SetPointError(7,0,2.71184e-05*10000.); pip_09->SetPoint(8,0.95,0.00124639*10000.); pip_09->SetPointError(8,0,2.05741e-05*10000.); pip_09->SetPoint(9,1.05,0.000795915*10000.); pip_09->SetPointError(9,0,1.55347e-05*10000.); pip_09->SetPoint(10,1.15,0.00052189*10000.); pip_09->SetPointError(10,0,1.19541e-05*10000.); pip_09->SetPoint(11,1.25,0.000326377*10000.); pip_09->SetPointError(11,0,9.03125e-06*10000.); pip_09->SetPoint(12,1.35,0.000225549*10000.); pip_09->SetPointError(12,0,8.86039e-06*10000.); pip_09->SetPoint(13,1.45,0.000174226*10000.); pip_09->SetPointError(13,0,1.52806e-05*10000.); pip_11->SetPoint(0,0.15,1e+19*1e+5); pip_11->SetPointError(0,0,0.000464647*1e5); pip_11->SetPoint(1,0.25,0.00297291*1e+5); pip_11->SetPointError(1,0,5.52723e-05*1e+5); pip_11->SetPoint(2,0.35,0.00179572*1e+5); pip_11->SetPointError(2,0,2.61073e-05*1e+5); pip_11->SetPoint(3,0.45,0.00114331*1e+5); pip_11->SetPointError(3,0,1.60364e-05*1e+5); pip_11->SetPoint(4,0.55,0.000711595*1e+5); pip_11->SetPointError(4,0,1.06102e-05*1e+5); pip_11->SetPoint(5,0.65,0.000431862*1e+5); pip_11->SetPointError(5,0,7.25435e-06*1e+5); pip_11->SetPoint(6,0.75,0.000272204*1e+5); pip_11->SetPointError(6,0,5.23083e-06*1e+5); pip_11->SetPoint(7,0.85,0.000178675*1e+5); pip_11->SetPointError(7,0,3.90086e-06*1e+5); pip_11->SetPoint(8,0.95,0.00012069*1e+5); pip_11->SetPointError(8,0,2.99212e-06*1e+5); pip_11->SetPoint(9,1.05,7.14477e-05*1e+5); pip_11->SetPointError(9,0,2.1761e-06*1e+5); pip_11->SetPoint(10,1.15,4.2754e-05*1e+5); pip_11->SetPointError(10,0,1.68605e-06*1e+5); pip_11->SetPoint(11,1.25,2.97697e-05*1e+5); pip_11->SetPointError(11,0,2.05431e-06*1e+5); pip_13->SetPoint(0,0.15,0.000411293*1e+6); pip_13->SetPointError(0,0,1.83752e-05*1e+6); pip_13->SetPoint(1,0.25,0.000293631*1e+6); pip_13->SetPointError(1,0,4.88368e-06*1e+6); pip_13->SetPoint(2,0.35,0.000173892*1e+6); pip_13->SetPointError(2,0,2.39356e-06*1e+6); pip_13->SetPoint(3,0.45,0.000106334*1e+6); pip_13->SetPointError(3,0,1.49425e-06*1e+6); pip_13->SetPoint(4,0.55,6.70087e-05*1e+6); pip_13->SetPointError(4,0,1.02835e-06*1e+6); pip_13->SetPoint(5,0.65,4.19677e-05*1e+6); pip_13->SetPointError(5,0,7.329e-07*1e+6); pip_13->SetPoint(6,0.75,2.62179e-05*1e+6); pip_13->SetPointError(6,0,5.33727e-07*1e+6); pip_13->SetPoint(7,0.85,1.51547e-05*1e+6); pip_13->SetPointError(7,0,3.80296e-07*1e+6); pip_13->SetPoint(8,0.95,9.97805e-06*1e+6); pip_13->SetPointError(8,0,3.06185e-07*1e+6); pip_13->SetPoint(9,1.05,6.63352e-06*1e+6); pip_13->SetPointError(9,0,3.79213e-07*1e+6); pip_22->SetPoint(0,0.25,2.12972e-05*1e+7); pip_22->SetPointError(0,0,1.1466e-06*1e+7); pip_22->SetPoint(1,0.35,1.2707e-05*1e+7); pip_22->SetPointError(1,0,3.89191e-07*1e+7); pip_22->SetPoint(2,0.45,8.42928e-06*1e+7); pip_22->SetPointError(2,0,2.42125e-07*1e+7); pip_22->SetPoint(3,0.55,5.37106e-06*1e+7); pip_22->SetPointError(3,0,1.59287e-07*1e+7); pip_22->SetPoint(4,0.65,3.26224e-06*1e+7); pip_22->SetPointError(4,0,7.52581e-08*1e+7); pip_22->SetPoint(5,0.75,2.11687e-06*1e+7); pip_22->SetPointError(5,0,5.26266e-08*1e+7); pip_22->SetPoint(6,0.85,1.36387e-06*1e+7); pip_22->SetPointError(6,0,3.93061e-08*1e+7); pip_22->SetPoint(7,0.95,8.59106e-07*1e+7); pip_22->SetPointError(7,0,2.70862e-08*1e+7); pip_22->SetPoint(8,1.05,5.58927e-07*1e+7); pip_22->SetPointError(8,0,2.02878e-08*1e+7); pip_22->SetPoint(9,1.15,3.26654e-07*1e+7); pip_22->SetPointError(9,0,1.7337e-08*1e+7); pip_22->SetPoint(10,1.25,2.20623e-07*1e+7); pip_22->SetPointError(10,0,1.41239e-08*1e+7); pip_22->SetPoint(11,1.35,1.4307e-07*1e+7); pip_22->SetPointError(11,0,1.11044e-08*1e+7); pip_22->SetPoint(12,1.45,8.32757e-08*1e+7); pip_22->SetPointError(12,0,8.36953e-09*1e+7); pip_22->SetPoint(13,1.55,8.73963e-08*1e+7); pip_22->SetPointError(13,0,8.56991e-09*1e+7); pip_22->SetPoint(14,1.65,4.26711e-08*1e+7); pip_22->SetPointError(14,0,5.86132e-09*1e+7); pip_22->SetPoint(15,1.75,4.21537e-08*1e+7); pip_22->SetPointError(15,0,5.9027e-09*1e+7); pip_22->SetPoint(16,1.85,1.44142e-08*1e+7); pip_22->SetPointError(16,0,3.60355e-09*1e+7); pip_22->SetPoint(17,1.95,7.01429e-09*1e+7); pip_22->SetPointError(17,0,2.47993e-09*1e+7); pip_22->SetPoint(18,2.05,2.89198e-09*1e+7); pip_22->SetPointError(18,0,1.66969e-09*1e+7); pip_22->SetPoint(19,2.15,3.28559e-09*1e+7); pip_22->SetPointError(19,0,1.89694e-09*1e+7); pip_22->SetPoint(20,2.25,5.34107e-09*1e+7); pip_22->SetPointError(20,0,2.67054e-09*1e+7); pip_22->SetPoint(21,2.35,4.77546e-09*1e+7); pip_22->SetPointError(21,0,2.75711e-09*1e+7); pip_22->SetPoint(22,2.45,1.62968e-09*1e+7); pip_22->SetPointError(22,0,1.02968e-09*1e+7); pip_22->SetPoint(23,2.55,1e+19*1e+7); pip_22->SetPointError(23,0,4.26328e-09*1e+7); pip_25->SetPoint(0,0.25,1e+19*1e+8); pip_25->SetPointError(0,0,9.3311e-08*1e+8); pip_25->SetPoint(1,0.35,1e+19*1e+8); pip_25->SetPointError(1,0,3.46192e-08*1e+8); pip_25->SetPoint(2,0.45,6.79616e-07*1e+8); pip_25->SetPointError(2,0,1.86214e-08*1e+8); pip_25->SetPoint(3,0.55,4.32442e-07*1e+8); pip_25->SetPointError(3,0,1.11433e-08*1e+8); pip_25->SetPoint(4,0.65,2.88402e-07*1e+8); pip_25->SetPointError(4,0,6.59042e-09*1e+8); pip_25->SetPoint(5,0.75,1.76372e-07*1e+8); pip_25->SetPointError(5,0,4.48419e-09*1e+8); pip_25->SetPoint(6,0.85,9.16738e-08*1e+8); pip_25->SetPointError(6,0,3.90898e-09*1e+8); pip_25->SetPoint(7,0.95,5.75022e-08*1e+8); pip_25->SetPointError(7,0,4.06602e-09*1e+8); pip_25->SetPoint(8,1.05,4.06634e-08*1e+8); pip_25->SetPointError(8,0,3.38862e-09*1e+8); pip_25->SetPoint(9,1.15,2.63604e-08*1e+8); pip_25->SetPointError(9,0,2.70452e-09*1e+8); pip_25->SetPoint(10,1.25,1.57826e-08*1e+8); pip_25->SetPointError(10,0,2.14775e-09*1e+8); pip_25->SetPoint(11,1.35,1.185e-08*1e+8); pip_25->SetPointError(11,0,1.975e-09*1e+8); pip_25->SetPoint(12,1.45,7.10475e-09*1e+8); pip_25->SetPointError(12,0,1.62994e-09*1e+8); pip_25->SetPoint(13,1.55,4.56796e-09*1e+8); pip_25->SetPointError(13,0,1.37729e-09*1e+8); pip_25->SetPoint(14,1.65,2.41102e-09*1e+8); pip_25->SetPointError(14,0,1.07824e-09*1e+8); pip_25->SetPoint(15,1.75,1.7539e-09*1e+8); pip_25->SetPointError(15,0,1.01261e-09*1e+8); pip_25->SetPoint(16,1.85,7.46502e-10*1e+8); pip_25->SetPointError(16,0,3.46502e-10*1e+8); pip_25->SetPoint(17,1.95,1e+19*1e+8); pip_25->SetPointError(17,0,8.49904e-10*1e+8); pip_25->SetPoint(18,2.05,1e+19*1e+8); pip_25->SetPointError(18,0,1.01661e-09*1e+8); pip_305->SetPoint(0,0.35,8.73766e-08*1e+9); pip_305->SetPointError(0,0,2.44035e-09*1e+9); pip_305->SetPoint(1,0.45,5.31897e-08*1e+9); pip_305->SetPointError(1,0,8.77045e-10*1e+9); pip_305->SetPoint(2,0.55,3.22571e-08*1e+9); pip_305->SetPointError(2,0,7.64137e-10*1e+9); pip_305->SetPoint(3,0.65,1.97155e-08*1e+9); pip_305->SetPointError(3,0,6.25654e-10*1e+9); pip_305->SetPoint(4,0.75,1.1901e-08*1e+9); pip_305->SetPointError(4,0,4.69696e-10*1e+9); pip_305->SetPoint(5,0.85,8.09748e-09*1e+9); pip_305->SetPointError(5,0,3.71538e-10*1e+9); pip_305->SetPoint(6,0.95,5.28813e-09*1e+9); pip_305->SetPointError(6,0,2.94239e-10*1e+9); pip_305->SetPoint(7,1.05,3.07529e-09*1e+9); pip_305->SetPointError(7,0,1.9728e-10*1e+9); pip_305->SetPoint(8,1.15,2.05926e-09*1e+9); pip_305->SetPointError(8,0,1.4709e-10*1e+9); pip_305->SetPoint(9,1.25,1.54759e-09*1e+9); pip_305->SetPointError(9,0,1.16987e-10*1e+9); pip_305->SetPoint(10,1.35,8.5033e-10*1e+9); pip_305->SetPointError(10,0,8.29837e-11*1e+9); pip_305->SetPoint(11,1.45,5.24649e-10*1e+9); pip_305->SetPointError(11,0,6.55811e-11*1e+9); pip_305->SetPoint(12,1.55,3.93951e-10*1e+9); pip_305->SetPointError(12,0,5.93904e-11*1e+9); pip_305->SetPoint(13,1.65,1.65471e-10*1e+9); pip_305->SetPointError(13,0,4.13677e-11*1e+9); pip_305->SetPoint(14,1.75,1.96004e-10*1e+9); pip_305->SetPointError(14,0,4.75379e-11*1e+9); pip_305->SetPoint(15,1.85,4.26607e-11*1e+9); pip_305->SetPointError(15,0,2.46302e-11*1e+9); pip_305->SetPoint(16,1.95,7.21619e-11*1e+9); pip_305->SetPointError(16,0,3.60809e-11*1e+9); pip_305->SetPoint(17,2.05,1e+19*1e+9); pip_305->SetPointError(17,0,5.73246e-11*1e+9); pip_305->SetPoint(18,2.15,1e+19*1e+9); pip_305->SetPointError(18,0,3.48828e-11*1e+9); pip_315->SetPoint(0,0.25,1e+19*1e+10); pip_315->SetPointError(0,0,3.81971e-10*1e+10); pip_315->SetPoint(1,0.35,1e+19*1e+10); pip_315->SetPointError(1,0,1.10712e-10*1e+10); pip_315->SetPoint(2,0.45,4.99083e-09*1e+10); pip_315->SetPointError(2,0,9.45885e-11*1e+10); pip_315->SetPoint(3,0.55,2.84065e-09*1e+10); pip_315->SetPointError(3,0,9.64181e-11*1e+10); pip_315->SetPoint(4,0.65,2.05175e-09*1e+10); pip_315->SetPointError(4,0,7.0499e-11*1e+10); pip_315->SetPoint(5,0.75,1.20745e-09*1e+10); pip_315->SetPointError(5,0,4.90897e-11*1e+10); pip_315->SetPoint(6,0.85,6.9978e-10*1e+10); pip_315->SetPointError(6,0,3.32475e-11*1e+10); pip_315->SetPoint(7,0.95,4.84964e-10*1e+10); pip_315->SetPointError(7,0,2.42482e-11*1e+10); pip_315->SetPoint(8,1.05,3.29823e-10*1e+10); pip_315->SetPointError(8,0,1.91061e-11*1e+10); pip_315->SetPoint(9,1.15,2.01591e-10*1e+10); pip_315->SetPointError(9,0,1.48615e-11*1e+10); pip_315->SetPoint(10,1.25,1.2609e-10*1e+10); pip_315->SetPointError(10,0,1.32179e-11*1e+10); pip_315->SetPoint(11,1.35,6.56785e-11*1e+10); pip_315->SetPointError(11,0,1.11017e-11*1e+10); pip_315->SetPoint(12,1.45,6.46248e-11*1e+10); pip_315->SetPointError(12,0,1.37781e-11*1e+10); pip_315->SetPoint(13,1.55,2.94476e-11*1e+10); pip_315->SetPointError(13,0,1.47238e-11*1e+10); pip_325->SetPoint(0,0.25,1.23391e-09*1e+11); pip_325->SetPointError(0,0,2.78428e-11*1e+11); pip_325->SetPoint(1,0.35,6.92524e-10*1e+11); pip_325->SetPointError(1,0,1.39146e-11*1e+11); pip_325->SetPoint(2,0.45,5.36701e-10*1e+11); pip_325->SetPointError(2,0,1.88928e-11*1e+11); pip_325->SetPoint(3,0.55,3.16483e-10*1e+11); pip_325->SetPointError(3,0,9.58598e-12*1e+11); pip_325->SetPoint(4,0.65,1.75781e-10*1e+11); pip_325->SetPointError(4,0,7.2368e-12*1e+11); pip_325->SetPoint(5,0.75,1.20851e-10*1e+11); pip_325->SetPointError(5,0,4.92552e-12*1e+11); pip_325->SetPoint(6,0.85,7.46373e-11*1e+11); pip_325->SetPointError(6,0,3.3615e-12*1e+11); pip_325->SetPoint(7,0.95,4.4006e-11*1e+11); pip_325->SetPointError(7,0,2.62052e-12*1e+11); pip_325->SetPoint(8,1.05,2.63215e-11*1e+11); pip_325->SetPointError(8,0,2.55657e-12*1e+11); pip_325->SetPoint(9,1.15,2.49076e-11*1e+11); pip_325->SetPointError(9,0,4.21016e-12*1e+11); pip_335->SetPoint(0,0.25,1.07427e-10*1e+12); pip_335->SetPointError(0,0,7.69303e-12*1e+12); pip_335->SetPoint(1,0.35,5.91896e-11*1e+12); pip_335->SetPointError(1,0,3.70659e-12*1e+12); pip_335->SetPoint(2,0.45,4.43333e-11*1e+12); pip_335->SetPointError(2,0,1.26102e-12*1e+12); pip_335->SetPoint(3,0.55,2.32838e-11*1e+12); pip_335->SetPointError(3,0,6.48525e-13*1e+12); pip_335->SetPoint(4,0.65,1.52876e-11*1e+12); pip_335->SetPointError(4,0,4.23512e-13*1e+12); pip_335->SetPoint(5,0.75,9.88298e-12*1e+12); pip_335->SetPointError(5,0,2.90676e-13*1e+12); pip_335->SetPoint(6,0.85,5.49738e-12*1e+12); pip_335->SetPointError(6,0,2.01679e-13*1e+12); pip_335->SetPoint(7,0.95,3.35403e-12*1e+12); pip_335->SetPointError(7,0,1.59716e-13*1e+12); pip_335->SetPoint(8,1.05,2.23418e-12*1e+12); pip_335->SetPointError(8,0,1.54173e-13*1e+12); pip_335->SetPoint(9,1.15,1.44884e-12*1e+12); pip_335->SetPointError(9,0,1.40724e-13*1e+12); pip_335->SetPoint(10,1.25,8.36609e-13*1e+12); pip_335->SetPointError(10,0,1.22032e-13*1e+12); pip_335->SetPoint(11,1.35,5.03957e-13*1e+12); pip_335->SetPointError(11,0,1.15616e-13*1e+12); pip_335->SetPoint(12,1.45,2.8604e-13*1e+12); pip_335->SetPointError(12,0,1.27921e-13*1e+12); pip_353->SetPoint(0,0.25,1e+19*1e+13); pip_353->SetPointError(0,0,8.10712e-13*1e+13); pip_353->SetPoint(1,0.35,6.58318e-12*1e+13); pip_353->SetPointError(1,0,1.95665e-13*1e+13); pip_353->SetPoint(2,0.45,3.55452e-12*1e+13); pip_353->SetPointError(2,0,8.60833e-14*1e+13); pip_353->SetPoint(3,0.55,2.41665e-12*1e+13); pip_353->SetPointError(3,0,5.74578e-14*1e+13); pip_353->SetPoint(4,0.65,1.40587e-12*1e+13); pip_353->SetPointError(4,0,3.95745e-14*1e+13); pip_353->SetPoint(5,0.75,8.83569e-13*1e+13); pip_353->SetPointError(5,0,3.38833e-14*1e+13); pip_353->SetPoint(6,0.85,5.54491e-13*1e+13); pip_353->SetPointError(6,0,3.26737e-14*1e+13); pip_353->SetPoint(7,0.95,3.20193e-13*1e+13); pip_353->SetPointError(7,0,3.57986e-14*1e+13); pip_353->SetPoint(8,1.05,2.0296e-13*1e+13); pip_353->SetPointError(8,0,1.0148e-13*1e+13); //pi- pim_m005->SetPoint(0,0.15,1e+19); pim_m005->SetPointError(0,0,22.6196); pim_m005->SetPoint(1,0.25,297.681); pim_m005->SetPointError(1,0,11.2193); pim_m005->SetPoint(2,0.35,203.315); pim_m005->SetPointError(2,0,5.27069); pim_m005->SetPoint(3,0.45,119.332); pim_m005->SetPointError(3,0,2.76249); pim_m005->SetPoint(4,0.55,77.9215); pim_m005->SetPointError(4,0,1.7547); pim_m005->SetPoint(5,0.65,46.7584); pim_m005->SetPointError(5,0,1.11329); pim_m005->SetPoint(6,0.75,31.5053); pim_m005->SetPointError(6,0,0.769338); pim_m005->SetPoint(7,0.85,21.5214); pim_m005->SetPointError(7,0,0.521971); pim_m005->SetPoint(8,0.95,13.4177); pim_m005->SetPointError(8,0,0.36973); pim_m005->SetPoint(9,1.05,9.02701); pim_m005->SetPointError(9,0,0.271313); pim_m005->SetPoint(10,1.15,5.9695); pim_m005->SetPointError(10,0,0.197996); pim_m005->SetPoint(11,1.25,4.20908); pim_m005->SetPointError(11,0,0.152479); pim_m005->SetPoint(12,1.35,2.56898); pim_m005->SetPointError(12,0,0.11212); pim_m005->SetPoint(13,1.45,1.86103); pim_m005->SetPointError(13,0,0.0876324); pim_m005->SetPoint(14,1.55,1.25698); pim_m005->SetPointError(14,0,0.068986); pim_m005->SetPoint(15,1.65,0.814651); pim_m005->SetPointError(15,0,0.0533696); pim_m005->SetPoint(16,1.75,0.668283); pim_m005->SetPointError(16,0,0.0460065); pim_m005->SetPoint(17,1.85,0.430371); pim_m005->SetPointError(17,0,0.0359895); pim_m005->SetPoint(18,1.95,0.309153); pim_m005->SetPointError(18,0,0.0289548); pim_005->SetPoint( 0, 0.55, 16.79115); pim_005->SetPointError( 0, 0.0, 0.5977807); pim_005->SetPoint( 1, 0.65, 10.627); pim_005->SetPointError( 1, 0.0, 0.2609868); pim_005->SetPoint( 2, 0.75, 6.720254); pim_005->SetPointError( 2, 0.0, 0.1546215); pim_005->SetPoint( 3, 0.85, 4.216924); pim_005->SetPointError( 3, 0.0, 0.1013848); pim_005->SetPoint( 4, 0.95, 2.804739); pim_005->SetPointError( 4, 0.0, 0.07453509); pim_005->SetPoint( 5, 1.1, 1.487077); pim_005->SetPointError( 5, 0.0, 0.03274832); pim_005->SetPoint( 6, 1.3, 0.7124657); pim_005->SetPointError( 6, 0.0, 0.01994521); pim_005->SetPoint( 7, 1.5, 0.3458683); pim_005->SetPointError( 7, 0.0, 0.01277494); pim_005->SetPoint( 8, 1.7, 0.1707015); pim_005->SetPointError( 8, 0.0, 0.008193933); pim_005->SetPoint( 9, 1.9, 0.08348444); pim_005->SetPointError( 9, 0.0, 0.005265677); pim_005->SetPoint( 10, 2.25, 0.02738612); pim_005->SetPointError( 10, 0.0, 0.00164059); pim_010->SetPoint(11, 2.25, 0.03102243); pim_010->SetPoint(10, 1.9, 0.08790173); pim_010->SetPoint( 9, 1.7, 0.1691953); pim_010->SetPoint( 8, 1.5, 0.3443033); pim_010->SetPoint( 7, 1.3, 0.7120432); pim_010->SetPoint( 6, 1.1, 1.50762); pim_010->SetPoint( 5, 0.95, 2.811368); pim_010->SetPoint( 4, 0.85, 4.27369); pim_010->SetPoint( 3, 0.75, 6.668049); pim_010->SetPoint( 2, 0.65, 10.27046); pim_010->SetPoint( 1, 0.55, 16.65259); pim_010->SetPoint( 0, 0.45, 26.582); pim_010->SetPointError(11, 0.0, 0.001736534); pim_010->SetPointError(10, 0.0, 0.005325526); pim_010->SetPointError( 9, 0.0, 0.008208212); pim_010->SetPointError( 8, 0.0, 0.01298967); pim_010->SetPointError( 7, 0.0, 0.02055274); pim_010->SetPointError( 6, 0.0, 0.03339129); pim_010->SetPointError( 5, 0.0, 0.07217635); pim_010->SetPointError( 4, 0.0, 0.09641846); pim_010->SetPointError( 3, 0.0, 0.1381276); pim_010->SetPointError( 2, 0.0, 0.2048278); pim_010->SetPointError( 1, 0.0, 0.3366433); pim_010->SetPointError( 0, 0.0, 0.7849283); /* pim_005->SetPoint(0,0.15,1e+19*10.); pim_005->SetPointError(0,0,2.26951*10.); pim_005->SetPoint(1,0.25,32.725*10.); pim_005->SetPointError(1,0,1.16064*10.); pim_005->SetPoint(2,0.35,19.4698*10.); pim_005->SetPointError(2,0,0.530097*10.); pim_005->SetPoint(3,0.45,11.4648*10.); pim_005->SetPointError(3,0,0.255341*10.); pim_005->SetPoint(4,0.55,7.1716*10.); pim_005->SetPointError(4,0,0.125818*10.); pim_005->SetPoint(5,0.65,4.66446*10.); pim_005->SetPointError(5,0,0.0741138*10.); pim_005->SetPoint(6,0.75,3.03948*10.); pim_005->SetPointError(6,0,0.0496213*10.); pim_005->SetPoint(7,0.85,1.98071*10.); pim_005->SetPointError(7,0,0.0347279*10.); pim_005->SetPoint(8,0.95,1.26282*10.); pim_005->SetPointError(8,0,0.0253889*10.); pim_005->SetPoint(9,1.05,0.931392*10.); pim_005->SetPointError(9,0,0.0203053*10.); pim_005->SetPoint(10,1.15,0.603968*10.); pim_005->SetPointError(10,0,0.0155633*10.); pim_005->SetPoint(11,1.25,0.408138*10.); pim_005->SetPointError(11,0,0.0122393*10.); pim_005->SetPoint(12,1.35,0.2676*10.); pim_005->SetPointError(12,0,0.00937936*10.); pim_005->SetPoint(13,1.45,0.179605*10.); pim_005->SetPointError(13,0,0.00748353*10.); pim_005->SetPoint(14,1.55,0.132352*10.); pim_005->SetPointError(14,0,0.00625303*10.); pim_005->SetPoint(15,1.65,0.0880857*10.); pim_005->SetPointError(15,0,0.00493185*10.); pim_005->SetPoint(16,1.75,0.0616641*10.); pim_005->SetPointError(16,0,0.00406601*10.); pim_005->SetPoint(17,1.85,0.0485318*10.); pim_005->SetPointError(17,0,0.0034934*10.); pim_005->SetPoint(18,1.95,0.0327529*10.); pim_005->SetPointError(18,0,0.00280854*10.); */ pim_05->SetPoint(0,0.15,4.56402*100.); pim_05->SetPointError(0,0,0.862519*100.); pim_05->SetPoint(1,0.25,2.96427*100.); pim_05->SetPointError(1,0,0.0730639*100.); pim_05->SetPoint(2,0.35,2.00064*100.); pim_05->SetPointError(2,0,0.0350128*100.); pim_05->SetPoint(3,0.45,1.24159*100.); pim_05->SetPointError(3,0,0.0217155*100.); pim_05->SetPoint(4,0.55,0.767047*100.); pim_05->SetPointError(4,0,0.0145479*100.); pim_05->SetPoint(5,0.65,0.469446*100.); pim_05->SetPointError(5,0,0.0101957*100.); pim_05->SetPoint(6,0.75,0.309134*100.); pim_05->SetPointError(6,0,0.00758512*100.); pim_05->SetPoint(7,0.85,0.211247*100.); pim_05->SetPointError(7,0,0.00578814*100.); pim_05->SetPoint(8,0.95,0.13252*100.); pim_05->SetPointError(8,0,0.00431088*100.); pim_05->SetPoint(9,1.05,0.0820801*100.); pim_05->SetPointError(9,0,0.00322193*100.); pim_05->SetPoint(10,1.15,0.0611938*100.); pim_05->SetPointError(10,0,0.00263093*100.); pim_05->SetPoint(11,1.25,0.0420371*100.); pim_05->SetPointError(11,0,0.00208626*100.); pim_05->SetPoint(12,1.35,0.0261373*100.); pim_05->SetPointError(12,0,0.00157328*100.); pim_05->SetPoint(13,1.45,0.0186998*100.); pim_05->SetPointError(13,0,0.00128129*100.); pim_05->SetPoint(14,1.55,0.0116797*100.); pim_05->SetPointError(14,0,0.000973312*100.); pim_05->SetPoint(15,1.65,0.00903574*100.); pim_05->SetPointError(15,0,0.000831807*100.); pim_05->SetPoint(16,1.75,0.0079419*100.); pim_05->SetPointError(16,0,0.00115845*100.); pim_05->SetPoint(17,1.85,1e+19*100.); pim_05->SetPointError(17,0,0.0150446*100.); pim_07->SetPoint(0,0.15,0.340147*1000.); pim_07->SetPointError(0,0,0.0262429*1000.); pim_07->SetPoint(1,0.25,0.300872*1000.); pim_07->SetPointError(1,0,0.00582709*1000.); pim_07->SetPoint(2,0.35,0.193751*1000.); pim_07->SetPointError(2,0,0.00243948*1000.); pim_07->SetPoint(3,0.45,0.118435*1000.); pim_07->SetPointError(3,0,0.00163847*1000.); pim_07->SetPoint(4,0.55,0.0750801*1000.); pim_07->SetPointError(4,0,0.00116985*1000.); pim_07->SetPoint(5,0.65,0.0462721*1000.); pim_07->SetPointError(5,0,0.000838406*1000.); pim_07->SetPoint(6,0.75,0.0297424*1000.); pim_07->SetPointError(6,0,0.000623297*1000.); pim_07->SetPoint(7,0.85,0.019821*1000.); pim_07->SetPointError(7,0,0.000476405*1000.); pim_07->SetPoint(8,0.95,0.0127563*1000.); pim_07->SetPointError(8,0,0.000358941*1000.); pim_07->SetPoint(9,1.05,0.00832967*1000.); pim_07->SetPointError(9,0,0.000275672*1000.); pim_07->SetPoint(10,1.15,0.00583359*1000.); pim_07->SetPointError(10,0,0.000221122*1000.); pim_07->SetPoint(11,1.25,0.0036337*1000.); pim_07->SetPointError(11,0,0.000167078*1000.); pim_07->SetPoint(12,1.35,0.00249294*1000.); pim_07->SetPointError(12,0,0.000133063*1000.); pim_07->SetPoint(13,1.45,0.00168888*1000.); pim_07->SetPointError(13,0,0.000105555*1000.); pim_07->SetPoint(14,1.55,0.0011498*1000.); pim_07->SetPointError(14,0,0.000112209*1000.); pim_07->SetPoint(15,1.65,1e+19*1000.); pim_07->SetPointError(15,0,0.000197763*1000.); pim_09->SetPoint(0,0.15,1e+19*10000.); pim_09->SetPointError(0,0,0.00411111*10000.); pim_09->SetPoint(1,0.25,0.0313853*10000.); pim_09->SetPointError(1,0,0.000409227*10000.); pim_09->SetPoint(2,0.35,0.0192193*10000.); pim_09->SetPointError(2,0,0.000193936*10000.); pim_09->SetPoint(3,0.45,0.0119028*10000.); pim_09->SetPointError(3,0,0.000111627*10000.); pim_09->SetPoint(4,0.55,0.00732427*10000.); pim_09->SetPointError(4,0,7.29045e-05*10000.); pim_09->SetPoint(5,0.65,0.00454721*10000.); pim_09->SetPointError(5,0,5.12023e-05*10000.); pim_09->SetPoint(6,0.75,0.00298234*10000.); pim_09->SetPointError(6,0,3.78544e-05*10000.); pim_09->SetPoint(7,0.85,0.00191204*10000.); pim_09->SetPointError(7,0,2.8097e-05*10000.); pim_09->SetPoint(8,0.95,0.00121702*10000.); pim_09->SetPointError(8,0,2.0952e-05*10000.); pim_09->SetPoint(9,1.05,0.000807806*10000.); pim_09->SetPointError(9,0,1.61207e-05*10000.); pim_09->SetPoint(10,1.15,0.000508249*10000.); pim_09->SetPointError(10,0,1.21495e-05*10000.); pim_09->SetPoint(11,1.25,0.000331231*10000.); pim_09->SetPointError(11,0,9.38367e-06*10000.); pim_09->SetPoint(12,1.35,0.000244553*10000.); pim_09->SetPointError(12,0,9.3713e-06*10000.); pim_09->SetPoint(13,1.45,0.000153049*10000.); pim_09->SetPointError(13,0,1.40893e-05*10000.); pim_11->SetPoint(0,0.15,1e+19*1e+5); pim_11->SetPointError(0,0,0.000153487*1e+5); pim_11->SetPoint(1,0.25,0.00293795*1e+5); pim_11->SetPointError(1,0,5.27416e-05*1e+5); pim_11->SetPoint(2,0.35,0.00180409*1e+5); pim_11->SetPointError(2,0,2.21016e-05*1e+5); pim_11->SetPoint(3,0.45,0.00111433*1e+5); pim_11->SetPointError(3,0,1.29644e-05*1e+5); pim_11->SetPoint(4,0.55,0.000689149*1e+5); pim_11->SetPointError(4,0,8.6238e-06*1e+5); pim_11->SetPoint(5,0.65,0.000430339*1e+5); pim_11->SetPointError(5,0,6.02595e-06*1e+5); pim_11->SetPoint(6,0.75,0.000279539*1e+5); pim_11->SetPointError(6,0,4.42489e-06*1e+5); pim_11->SetPoint(7,0.85,0.000173651*1e+5); pim_11->SetPointError(7,0,3.2224e-06*1e+5); pim_11->SetPoint(8,0.95,0.000113773*1e+5); pim_11->SetPointError(8,0,2.44461e-06*1e+5); pim_11->SetPoint(9,1.05,6.99481e-05*1e+5); pim_11->SetPointError(9,0,1.81883e-06*1e+5); pim_11->SetPoint(10,1.15,4.59563e-05*1e+5); pim_11->SetPointError(10,0,1.59325e-06*1e+5); pim_11->SetPoint(11,1.25,3.16195e-05*1e+5); pim_11->SetPointError(11,0,2.14154e-06*1e+5); pim_13->SetPoint(0,0.15,0.000395856*1e+6); pim_13->SetPointError(0,0,1.96218e-05*1e+6); pim_13->SetPoint(1,0.25,0.000286674*1e+6); pim_13->SetPointError(1,0,6.10084e-06*1e+6); pim_13->SetPoint(2,0.35,0.000182202*1e+6); pim_13->SetPointError(2,0,3.17848e-06*1e+6); pim_13->SetPoint(3,0.45,0.000110459*1e+6); pim_13->SetPointError(3,0,1.94931e-06*1e+6); pim_13->SetPoint(4,0.55,6.71942e-05*1e+6); pim_13->SetPointError(4,0,1.27258e-06*1e+6); pim_13->SetPoint(5,0.65,4.3292e-05*1e+6); pim_13->SetPointError(5,0,8.93045e-07*1e+6); pim_13->SetPoint(6,0.75,2.58207e-05*1e+6); pim_13->SetPointError(6,0,6.22774e-07*1e+6); pim_13->SetPoint(7,0.85,1.63495e-05*1e+6); pim_13->SetPointError(7,0,4.5627e-07*1e+6); pim_13->SetPoint(8,0.95,1.03497e-05*1e+6); pim_13->SetPointError(8,0,3.59678e-07*1e+6); pim_13->SetPoint(9,1.05,6.06457e-06*1e+6); pim_13->SetPointError(9,0,4.05206e-07*1e+6); pim_22->SetPoint(0,0.25,2.0556e-05*1e+7); pim_22->SetPointError(0,0,7.65546e-07*1e+7); pim_22->SetPoint(1,0.35,1.36945e-05*1e+7); pim_22->SetPointError(1,0,2.78495e-07*1e+7); pim_22->SetPoint(2,0.45,8.59132e-06*1e+7); pim_22->SetPointError(2,0,1.68652e-07*1e+7); pim_22->SetPoint(3,0.55,5.28611e-06*1e+7); pim_22->SetPointError(3,0,1.09137e-07*1e+7); pim_22->SetPoint(4,0.65,3.16745e-06*1e+7); pim_22->SetPointError(4,0,5.20374e-08*1e+7); pim_22->SetPoint(5,0.75,1.9011e-06*1e+7); pim_22->SetPointError(5,0,3.39481e-08*1e+7); pim_22->SetPoint(6,0.85,1.16697e-06*1e+7); pim_22->SetPointError(6,0,2.79039e-08*1e+7); pim_22->SetPoint(7,0.95,7.90121e-07*1e+7); pim_22->SetPointError(7,0,2.09235e-08*1e+7); pim_22->SetPoint(8,1.05,5.54116e-07*1e+7); pim_22->SetPointError(8,0,1.66168e-08*1e+7); pim_22->SetPoint(9,1.15,3.08465e-07*1e+7); pim_22->SetPointError(9,0,1.41983e-08*1e+7); pim_22->SetPoint(10,1.25,1.95818e-07*1e+7); pim_22->SetPointError(10,0,1.10683e-08*1e+7); pim_22->SetPoint(11,1.35,1.32737e-07*1e+7); pim_22->SetPointError(11,0,8.9087e-09*1e+7); pim_22->SetPoint(12,1.45,9.43673e-08*1e+7); pim_22->SetPointError(12,0,8.34097e-09*1e+7); pim_22->SetPoint(13,1.55,8.18376e-08*1e+7); pim_22->SetPointError(13,0,9.44979e-09*1e+7); pim_22->SetPoint(14,1.65,3.22522e-08*1e+7); pim_22->SetPointError(14,0,5.88843e-09*1e+7); pim_22->SetPoint(15,1.75,2.30238e-08*1e+7); pim_22->SetPointError(15,0,5.02421e-09*1e+7); pim_22->SetPoint(16,1.85,2.38037e-08*1e+7); pim_22->SetPointError(16,0,5.19439e-09*1e+7); pim_22->SetPoint(17,1.95,1.52067e-08*1e+7); pim_22->SetPointError(17,0,4.21759e-09*1e+7); pim_22->SetPoint(18,2.05,5.27913e-09*1e+7); pim_22->SetPointError(18,0,2.63956e-09*1e+7); pim_22->SetPoint(19,2.15,5.32307e-09*1e+7); pim_22->SetPointError(19,0,2.66154e-09*1e+7); pim_22->SetPoint(20,2.25,6.76242e-09*1e+7); pim_22->SetPointError(20,0,3.02425e-09*1e+7); pim_22->SetPoint(21,2.45,1e+19*1e+7); pim_22->SetPointError(21,0,1.86906e-09*1e+7); pim_22->SetPoint(22,2.55,1e+19*1e+7); pim_22->SetPointError(22,0,1.93739e-09*1e+7); pim_22->SetPoint(23,2.65,1e+19*1e+7); pim_22->SetPointError(23,0,2.05635e-09*1e+7); pim_22->SetPoint(24,2.95,1e+19*1e+7); pim_22->SetPointError(24,0,2.92987e-09*1e+7); pim_25->SetPoint(0,0.15,1e+19*1e+8); pim_25->SetPointError(0,0,1.21811e-07*1e+8); pim_25->SetPoint(1,0.25,1e+19*1e+8); pim_25->SetPointError(1,0,3.43216e-08*1e+8); pim_25->SetPoint(2,0.35,1e+19*1e+8); pim_25->SetPointError(2,0,1.82048e-08*1e+8); pim_25->SetPoint(3,0.45,7.18191e-07*1e+8); pim_25->SetPointError(3,0,9.63256e-09*1e+8); pim_25->SetPoint(4,0.55,4.39885e-07*1e+8); pim_25->SetPointError(4,0,6.1249e-09*1e+8); pim_25->SetPoint(5,0.65,2.69412e-07*1e+8); pim_25->SetPointError(5,0,4.0985e-09*1e+8); pim_25->SetPoint(6,0.75,1.82636e-07*1e+8); pim_25->SetPointError(6,0,3.33891e-09*1e+8); pim_25->SetPoint(7,0.85,1.03988e-07*1e+8); pim_25->SetPointError(7,0,3.41542e-09*1e+8); pim_25->SetPoint(8,0.95,6.4468e-08*1e+8); pim_25->SetPointError(8,0,3.86653e-09*1e+8); pim_25->SetPoint(9,1.05,3.96464e-08*1e+8); pim_25->SetPointError(9,0,3.56035e-09*1e+8); pim_25->SetPoint(10,1.15,2.84605e-08*1e+8); pim_25->SetPointError(10,0,3.42624e-09*1e+8); pim_25->SetPoint(11,1.25,2.19658e-08*1e+8); pim_25->SetPointError(11,0,3.31146e-09*1e+8); pim_25->SetPoint(12,1.35,1.31793e-08*1e+8); pim_25->SetPointError(12,0,2.94697e-09*1e+8); pim_25->SetPoint(13,1.45,6.85745e-09*1e+8); pim_25->SetPointError(13,0,2.42447e-09*1e+8); pim_25->SetPoint(14,1.55,8.81607e-09*1e+8); pim_25->SetPointError(14,0,3.33216e-09*1e+8); pim_25->SetPoint(15,1.65,5.87415e-09*1e+8); pim_25->SetPointError(15,0,2.93707e-09*1e+8); pim_25->SetPoint(16,1.75,7.05366e-09*1e+8); pim_25->SetPointError(16,0,4.30154e-09*1e+8); pim_25->SetPoint(17,1.85,4.56866e-09*1e+8); pim_25->SetPointError(17,0,3.23053e-09*1e+8); pim_305->SetPoint(0,0.35,8.65069e-08*1e+9); pim_305->SetPointError(0,0,3.67201e-09*1e+9); pim_305->SetPoint(1,0.45,5.24373e-08*1e+9); pim_305->SetPointError(1,0,1.29762e-09*1e+9); pim_305->SetPoint(2,0.55,3.10683e-08*1e+9); pim_305->SetPointError(2,0,1.11817e-09*1e+9); pim_305->SetPoint(3,0.65,1.96052e-08*1e+9); pim_305->SetPointError(3,0,8.39794e-10*1e+9); pim_305->SetPoint(4,0.75,1.15094e-08*1e+9); pim_305->SetPointError(4,0,4.98527e-10*1e+9); pim_305->SetPoint(5,0.85,6.98787e-09*1e+9); pim_305->SetPointError(5,0,3.26879e-10*1e+9); pim_305->SetPoint(6,0.95,4.43918e-09*1e+9); pim_305->SetPointError(6,0,2.42538e-10*1e+9); pim_305->SetPoint(7,1.05,3.30578e-09*1e+9); pim_305->SetPointError(7,0,1.84799e-10*1e+9); pim_305->SetPoint(8,1.15,1.86816e-09*1e+9); pim_305->SetPointError(8,0,1.28306e-10*1e+9); pim_305->SetPoint(9,1.25,1.25216e-09*1e+9); pim_305->SetPointError(9,0,9.63196e-11*1e+9); pim_305->SetPoint(10,1.35,8.18651e-10*1e+9); pim_305->SetPointError(10,0,7.3517e-11*1e+9); pim_305->SetPoint(11,1.45,5.61359e-10*1e+9); pim_305->SetPointError(11,0,6.23733e-11*1e+9); pim_305->SetPoint(12,1.55,3.56004e-10*1e+9); pim_305->SetPointError(12,0,5.19285e-11*1e+9); pim_305->SetPoint(13,1.65,1.84326e-10*1e+9); pim_305->SetPointError(13,0,4.02231e-11*1e+9); pim_305->SetPoint(14,1.75,1.22418e-10*1e+9); pim_305->SetPointError(14,0,3.5339e-11*1e+9); pim_305->SetPoint(15,1.85,1.30325e-10*1e+9); pim_305->SetPointError(15,0,4.12124e-11*1e+9); pim_305->SetPoint(16,1.95,6.27783e-11*1e+9); pim_305->SetPointError(16,0,3.13892e-11*1e+9); pim_305->SetPoint(17,2.15,1e+19*1e+9); pim_305->SetPointError(17,0,4.98387e-11*1e+9); pim_315->SetPoint(0,0.25,1e+19*1e+10); pim_315->SetPointError(0,0,5.87139e-10*1e+10); pim_315->SetPoint(1,0.35,1e+19*1e+10); pim_315->SetPointError(1,0,1.6861e-10*1e+10); pim_315->SetPoint(2,0.45,5.11372e-09*1e+10); pim_315->SetPointError(2,0,1.42048e-10*1e+10); pim_315->SetPoint(3,0.55,3.2046e-09*1e+10); pim_315->SetPointError(3,0,1.09467e-10*1e+10); pim_315->SetPoint(4,0.65,2.06172e-09*1e+10); pim_315->SetPointError(4,0,6.32953e-11*1e+10); pim_315->SetPoint(5,0.75,1.21679e-09*1e+10); pim_315->SetPointError(5,0,4.41665e-11*1e+10); pim_315->SetPoint(6,0.85,7.0012e-10*1e+10); pim_315->SetPointError(6,0,2.98532e-11*1e+10); pim_315->SetPoint(7,0.95,4.52558e-10*1e+10); pim_315->SetPointError(7,0,2.1263e-11*1e+10); pim_315->SetPoint(8,1.05,3.1067e-10*1e+10); pim_315->SetPointError(8,0,1.7076e-11*1e+10); pim_315->SetPoint(9,1.15,1.99166e-10*1e+10); pim_315->SetPointError(9,0,1.35515e-11*1e+10); pim_315->SetPoint(10,1.25,1.04001e-10*1e+10); pim_315->SetPointError(10,0,1.09023e-11*1e+10); pim_315->SetPoint(11,1.35,6.5079e-11*1e+10); pim_315->SetPointError(11,0,1.01636e-11*1e+10); pim_315->SetPoint(12,1.45,4.30673e-11*1e+10); pim_315->SetPointError(12,0,1.04453e-11*1e+10); pim_315->SetPoint(13,1.55,1.28006e-11*1e+10); pim_315->SetPointError(13,0,9.05142e-12*1e+10); pim_325->SetPoint(0,0.25,1.24913e-09*1e+11); pim_325->SetPointError(0,0,4.17072e-11*1e+11); pim_325->SetPoint(1,0.35,7.47484e-10*1e+11); pim_325->SetPointError(1,0,2.16322e-11*1e+11); pim_325->SetPoint(2,0.45,5.53239e-10*1e+11); pim_325->SetPointError(2,0,1.77726e-11*1e+11); pim_325->SetPoint(3,0.55,3.27872e-10*1e+11); pim_325->SetPointError(3,0,8.84527e-12*1e+11); pim_325->SetPoint(4,0.65,1.73444e-10*1e+11); pim_325->SetPointError(4,0,6.41505e-12*1e+11); pim_325->SetPoint(5,0.75,1.39215e-10*1e+11); pim_325->SetPointError(5,0,4.75827e-12*1e+11); pim_325->SetPoint(6,0.85,8.39603e-11*1e+11); pim_325->SetPointError(6,0,3.22686e-12*1e+11); pim_325->SetPoint(7,0.95,4.47757e-11*1e+11); pim_325->SetPointError(7,0,2.43909e-12*1e+11); pim_325->SetPoint(8,1.05,2.53713e-11*1e+11); pim_325->SetPointError(8,0,2.31608e-12*1e+11); pim_325->SetPoint(9,1.15,2.64642e-11*1e+11); pim_325->SetPointError(9,0,3.94505e-12*1e+11); pim_335->SetPoint(0,0.25,1.50462e-10*1e+12); pim_335->SetPointError(0,0,1.37352e-11*1e+12); pim_335->SetPoint(1,0.35,5.29292e-11*1e+12); pim_335->SetPointError(1,0,4.22421e-12*1e+12); pim_335->SetPoint(2,0.45,4.46235e-11*1e+12); pim_335->SetPointError(2,0,1.21181e-12*1e+12); pim_335->SetPoint(3,0.55,2.34563e-11*1e+12); pim_335->SetPointError(3,0,6.51312e-13*1e+12); pim_335->SetPoint(4,0.65,1.5485e-11*1e+12); pim_335->SetPointError(4,0,4.15191e-13*1e+12); pim_335->SetPoint(5,0.75,1.02335e-11*1e+12); pim_335->SetPointError(5,0,2.72144e-13*1e+12); pim_335->SetPoint(6,0.85,5.89771e-12*1e+12); pim_335->SetPointError(6,0,1.87631e-13*1e+12); pim_335->SetPoint(7,0.95,3.51571e-12*1e+12); pim_335->SetPointError(7,0,1.42934e-13*1e+12); pim_335->SetPoint(8,1.05,2.1569e-12*1e+12); pim_335->SetPointError(8,0,1.2867e-13*1e+12); pim_335->SetPoint(9,1.15,1.47721e-12*1e+12); pim_335->SetPointError(9,0,1.18271e-13*1e+12); pim_335->SetPoint(10,1.25,9.29011e-13*1e+12); pim_335->SetPointError(10,0,1.06565e-13*1e+12); pim_335->SetPoint(11,1.35,4.01926e-13*1e+12); pim_335->SetPointError(11,0,8.56909e-14*1e+12); pim_335->SetPoint(12,1.45,2.00318e-13*1e+12); pim_335->SetPointError(12,0,8.9585e-14*1e+12); pim_335->SetPoint(13,1.55,1e+19*1e+12); pim_335->SetPointError(13,0,4.48512e-13*1e+12); pim_353->SetPoint(0,0.25,1e+19*1e+13); pim_353->SetPointError(0,0,1.08894e-12*1e+13); pim_353->SetPoint(1,0.35,7.00727e-12*1e+13); pim_353->SetPointError(1,0,2.23157e-13*1e+13); pim_353->SetPoint(2,0.45,3.61177e-12*1e+13); pim_353->SetPointError(2,0,8.55352e-14*1e+13); pim_353->SetPoint(3,0.55,2.56925e-12*1e+13); pim_353->SetPointError(3,0,5.35609e-14*1e+13); pim_353->SetPoint(4,0.65,1.45151e-12*1e+13); pim_353->SetPointError(4,0,3.46385e-14*1e+13); pim_353->SetPoint(5,0.75,9.39817e-13*1e+13); pim_353->SetPointError(5,0,2.97942e-14*1e+13); pim_353->SetPoint(6,0.85,5.12343e-13*1e+13); pim_353->SetPointError(6,0,2.69281e-14*1e+13); pim_353->SetPoint(7,0.95,2.48388e-13*1e+13); pim_353->SetPointError(7,0,2.69415e-14*1e+13); pim_353->SetPoint(8,1.05,2.79575e-13*1e+13); pim_353->SetPointError(8,0,9.88448e-14*1e+13); } void kaonpt() { kp_m005 = new TGraphErrors(20); kp_005 = new TGraphErrors(20); kp_010 = new TGraphErrors(20); kp_05 = new TGraphErrors(20); kp_07 = new TGraphErrors(20); kp_09 = new TGraphErrors(20); kp_11 = new TGraphErrors(20); kp_21 = new TGraphErrors(20); kp_24 = new TGraphErrors(20); kp_295 = new TGraphErrors(20); kp_305 = new TGraphErrors(20); kp_315 = new TGraphErrors(20); kp_33 = new TGraphErrors(20); //kp_35 = new TGraphErrors(20); km_m005 = new TGraphErrors(20); km_005 = new TGraphErrors(20); km_010 = new TGraphErrors(20); km_05 = new TGraphErrors(20); km_07 = new TGraphErrors(20); km_09 = new TGraphErrors(20); km_11 = new TGraphErrors(20); km_21 = new TGraphErrors(20); km_23 = new TGraphErrors(20); km_295 = new TGraphErrors(20); km_305 = new TGraphErrors(20); km_315 = new TGraphErrors(20); km_33 = new TGraphErrors(20); //km_35 = new TGraphErrors(20); kp_m005->SetPoint(0,0.25,17.0891); kp_m005->SetPointError(0,0,8.54456); kp_m005->SetPoint(1,0.35,19.2092); kp_m005->SetPointError(1,0,3.56707); kp_m005->SetPoint(2,0.45,17.2785); kp_m005->SetPointError(2,0,1.76348); kp_m005->SetPoint(3,0.55,14.9671); kp_m005->SetPointError(3,0,0.976345); kp_m005->SetPoint(4,0.65,11.3582); kp_m005->SetPointError(4,0,0.572943); kp_m005->SetPoint(5,0.75,8.15642); kp_m005->SetPointError(5,0,0.390175); kp_m005->SetPoint(6,0.85,6.37264); kp_m005->SetPointError(6,0,0.28614); kp_m005->SetPoint(7,0.95,4.27417); kp_m005->SetPointError(7,0,0.200818); kp_m005->SetPoint(8,1.05,3.4607); kp_m005->SetPointError(8,0,0.164982); kp_m005->SetPoint(9,1.15,2.64152); kp_m005->SetPointError(9,0,0.130775); kp_m005->SetPoint(10,1.25,1.81434); kp_m005->SetPointError(10,0,0.101267); kp_m005->SetPoint(11,1.35,1.39301); kp_m005->SetPointError(11,0,0.08056); kp_m005->SetPoint(12,1.45,0.816749); kp_m005->SetPointError(12,0,0.0586392); kp_m005->SetPoint(13,1.55,0.72309); kp_m005->SetPointError(13,0,0.0512585); kp_m005->SetPoint(14,1.65,0.533778); kp_m005->SetPointError(14,0,0.0420676); kp_m005->SetPoint(15,1.75,0.36482); kp_m005->SetPointError(15,0,0.0333034); kp_m005->SetPoint(16,1.85,0.247156); kp_m005->SetPointError(16,0,0.0264979); kp_m005->SetPoint(17,1.95,0.2202); kp_m005->SetPointError(17,0,0.0241701); kp_005->SetPoint( 0, 0.55, 2.839269); kp_005->SetPointError( 0, 0.0, 2.839269); kp_005->SetPoint( 1, 0.65, 2.804569); kp_005->SetPointError( 1, 0.0, 0.3889237); kp_005->SetPoint( 2, 0.75, 1.940365); kp_005->SetPointError( 2, 0.0, 0.2464266); kp_005->SetPoint( 3, 0.85, 1.32767); kp_005->SetPointError( 3, 0.0, 0.1743317); kp_005->SetPoint( 4, 0.95, 1.003086); kp_005->SetPointError( 4, 0.0, 0.1063269); kp_005->SetPoint( 5, 1.1, 0.5477862); kp_005->SetPointError( 5, 0.0, 0.04238897); kp_005->SetPoint( 6, 1.3, 0.3382674); kp_005->SetPointError( 6, 0.0, 0.02641436); kp_005->SetPoint( 7, 1.5, 0.1418648); kp_005->SetPointError( 7, 0.0, 0.01280035); kp_005->SetPoint( 8, 1.7, 0.08635975); kp_005->SetPointError( 8, 0.0, 0.00754203); kp_005->SetPoint( 9, 1.9, 0.04453428); kp_005->SetPointError( 9, 0.0, 0.004300841); kp_005->SetPoint( 10, 2.25, 0.01829672); kp_005->SetPointError( 10, 0.0, 0.001256704); kp_010->SetPoint( 0, 0.55, 2.90742); kp_010->SetPoint( 1, 0.65, 2.556125); kp_010->SetPoint( 2, 0.75, 1.85967); kp_010->SetPoint( 3, 0.85, 1.287246); kp_010->SetPoint( 4, 0.95, 0.9329636); kp_010->SetPoint( 5, 1.1, 0.5753913); kp_010->SetPoint( 6, 1.3, 0.3008741); kp_010->SetPoint( 7, 1.5, 0.1468043); kp_010->SetPoint( 8, 1.7, 0.08476406); kp_010->SetPoint( 9, 1.9, 0.04448909); kp_010->SetPoint(10, 2.25, 0.01862611); kp_010->SetPointError( 0, 0.0, 1.114638); kp_010->SetPointError( 1, 0.0, 0.2924575); kp_010->SetPointError( 2, 0.0, 0.1674764); kp_010->SetPointError( 3, 0.0, 0.1167247); kp_010->SetPointError( 4, 0.0, 0.07834864); kp_010->SetPointError( 5, 0.0, 0.03323886); kp_010->SetPointError( 6, 0.0, 0.0177743); kp_010->SetPointError( 7, 0.0, 0.01029689); kp_010->SetPointError( 8, 0.0, 0.006636898); kp_010->SetPointError( 9, 0.0, 0.004234845); kp_010->SetPointError(10, 0.0, 0.001330867); /* kp_005->SetPoint(0,0.25,1.84824*10.); kp_005->SetPointError(0,0,1.06708*10.); kp_005->SetPoint(1,0.35,2.32091*10.); kp_005->SetPointError(1,0,0.44666*10.); kp_005->SetPoint(2,0.45,2.03019*10.); kp_005->SetPointError(2,0,0.236005*10.); kp_005->SetPoint(3,0.55,1.29007*10.); kp_005->SetPointError(3,0,0.125898*10.); kp_005->SetPoint(4,0.65,1.06607*10.); kp_005->SetPointError(4,0,0.084812*10.); kp_005->SetPoint(5,0.75,0.755739*10.); kp_005->SetPointError(5,0,0.056645*10.); kp_005->SetPoint(6,0.85,0.61731*10.); kp_005->SetPointError(6,0,0.0421984*10.); kp_005->SetPoint(7,0.95,0.416338*10.); kp_005->SetPointError(7,0,0.0287987*10.); kp_005->SetPoint(8,1.05,0.383938*10.); kp_005->SetPointError(8,0,0.0249922*10.); kp_005->SetPoint(9,1.15,0.268165*10.); kp_005->SetPointError(9,0,0.0187753*10.); kp_005->SetPoint(10,1.25,0.206253*10.); kp_005->SetPointError(10,0,0.0149632*10.); kp_005->SetPoint(11,1.35,0.136217*10.); kp_005->SetPointError(11,0,0.0110852*10.); kp_005->SetPoint(12,1.45,0.076934*10.); kp_005->SetPointError(12,0,0.00785204*10.); kp_005->SetPoint(13,1.55,0.0632883*10.); kp_005->SetPointError(13,0,0.00659826*10.); kp_005->SetPoint(14,1.65,0.0587479*10.); kp_005->SetPointError(14,0,0.00609187*10.); kp_005->SetPoint(15,1.75,0.0358408*10.); kp_005->SetPointError(15,0,0.00448011*10.); kp_005->SetPoint(16,1.85,0.0239317*10.); kp_005->SetPointError(16,0,0.0034908*10.); kp_005->SetPoint(17,1.95,0.0203785*10.); kp_005->SetPointError(17,0,0.0031077*10.); */ kp_05->SetPoint(0,0.15,0.289253*100.); kp_05->SetPointError(0,0,0.0681775*100.); kp_05->SetPoint(1,0.25,0.220815*100.); kp_05->SetPointError(1,0,0.0239507*100.); kp_05->SetPoint(2,0.35,0.242799*100.); kp_05->SetPointError(2,0,0.0150868*100.); kp_05->SetPoint(3,0.45,0.172978*100.); kp_05->SetPointError(3,0,0.0104121*100.); kp_05->SetPoint(4,0.55,0.132442*100.); kp_05->SetPointError(4,0,0.00783148*100.); kp_05->SetPoint(5,0.65,0.111265*100.); kp_05->SetPointError(5,0,0.00613421*100.); kp_05->SetPoint(6,0.75,0.0874937*100.); kp_05->SetPointError(6,0,0.00483841*100.); kp_05->SetPoint(7,0.85,0.0633511*100.); kp_05->SetPointError(7,0,0.00371371*100.); kp_05->SetPoint(8,0.95,0.0438549*100.); kp_05->SetPointError(8,0,0.00282494*100.); kp_05->SetPoint(9,1.05,0.0342848*100.); kp_05->SetPointError(9,0,0.00232206*100.); kp_05->SetPoint(10,1.15,0.0243283*100.); kp_05->SetPointError(10,0,0.00183381*100.); kp_05->SetPoint(11,1.25,0.0169917*100.); kp_05->SetPointError(11,0,0.00144643*100.); kp_05->SetPoint(12,1.35,0.012303*100.); kp_05->SetPointError(12,0,0.00117841*100.); kp_05->SetPoint(13,1.45,0.00852335*100.); kp_05->SetPointError(13,0,0.000935559*100.); kp_05->SetPoint(14,1.55,0.0058608*100.); kp_05->SetPointError(14,0,0.000744323*100.); kp_05->SetPoint(15,1.65,0.00462892*100.); kp_05->SetPointError(15,0,0.000661274*100.); kp_05->SetPoint(16,1.75,0.00341663*100.); kp_05->SetPointError(16,0,0.000882171*100.); kp_07->SetPoint(0,0.15,1e+19*1000.); kp_07->SetPointError(0,0,0.00841657*1000.); kp_07->SetPoint(1,0.25,1e+19*1000.); kp_07->SetPointError(1,0,0.00173973*1000.); kp_07->SetPoint(2,0.35,0.0196194*1000.); kp_07->SetPointError(2,0,0.000769536*1000.); kp_07->SetPoint(3,0.45,0.0165968*1000.); kp_07->SetPointError(3,0,0.000487088*1000.); kp_07->SetPoint(4,0.55,0.0134147*1000.); kp_07->SetPointError(4,0,0.000390021*1000.); kp_07->SetPoint(5,0.65,0.0113412*1000.); kp_07->SetPointError(5,0,0.000349*1000.); kp_07->SetPoint(6,0.75,0.00826236*1000.); kp_07->SetPointError(6,0,0.000294148*1000.); kp_07->SetPoint(7,0.85,0.00611546*1000.); kp_07->SetPointError(7,0,0.000247203*1000.); kp_07->SetPoint(8,0.95,0.00436903*1000.); kp_07->SetPointError(8,0,0.000204599*1000.); kp_07->SetPoint(9,1.05,0.00304194*1000.); kp_07->SetPointError(9,0,0.000166448*1000.); kp_07->SetPoint(10,1.15,0.00235202*1000.); kp_07->SetPointError(10,0,0.000142612*1000.); kp_07->SetPoint(11,1.25,0.00211996*1000.); kp_07->SetPointError(11,0,0.000131474*1000.); kp_07->SetPoint(12,1.35,0.00130527*1000.); kp_07->SetPointError(12,0,0.000100109*1000.); kp_07->SetPoint(13,1.45,0.00086596*1000.); kp_07->SetPointError(13,0,8.37155e-05*1000.); kp_07->SetPoint(14,1.55,0.000598574*1000.); kp_07->SetPointError(14,0,0.000105814*1000.); kp_07->SetPoint(15,1.65,1e+19*1000.); kp_07->SetPointError(15,0,0.000138511*1000.); kp_09->SetPoint(0,0.25,0.00234525*10000.); kp_09->SetPointError(0,0,0.000428183*10000.); kp_09->SetPoint(1,0.35,0.00211324*10000.); kp_09->SetPointError(1,0,0.000160204*10000.); kp_09->SetPoint(2,0.45,0.00147128*10000.); kp_09->SetPointError(2,0,9.23163e-05*10000.); kp_09->SetPoint(3,0.55,0.00122564*10000.); kp_09->SetPointError(3,0,5.75858e-05*10000.); kp_09->SetPoint(4,0.65,0.00111137*10000.); kp_09->SetPointError(4,0,3.90977e-05*10000.); kp_09->SetPoint(5,0.75,0.000773516*10000.); kp_09->SetPointError(5,0,2.59138e-05*10000.); kp_09->SetPoint(6,0.85,0.000598851*10000.); kp_09->SetPointError(6,0,1.93885e-05*10000.); kp_09->SetPoint(7,0.95,0.000429601*10000.); kp_09->SetPointError(7,0,1.45315e-05*10000.); kp_09->SetPoint(8,1.05,0.000320649*10000.); kp_09->SetPointError(8,0,1.1518e-05*10000.); kp_09->SetPoint(9,1.15,0.000228198*10000.); kp_09->SetPointError(9,0,9.02032e-06*10000.); kp_09->SetPoint(10,1.25,0.000185923*10000.); kp_09->SetPointError(10,0,7.96408e-06*10000.); kp_09->SetPoint(11,1.35,0.000136823*10000.); kp_09->SetPointError(11,0,8.92536e-06*10000.); kp_09->SetPoint(12,1.45,1e+19*10000.); kp_09->SetPointError(12,0,2.18572e-05*10000.); kp_11->SetPoint(0,0.35,0.000178633*1e+5); kp_11->SetPointError(0,0,3.99436e-05*1e+5); kp_11->SetPoint(1,0.45,0.000156995*1e+5); kp_11->SetPointError(1,0,1.13598e-05*1e+5); kp_11->SetPoint(2,0.55,0.000132768*1e+5); kp_11->SetPointError(2,0,6.08541e-06*1e+5); kp_11->SetPoint(3,0.65,0.000102195*1e+5); kp_11->SetPointError(3,0,4.16518e-06*1e+5); kp_11->SetPoint(4,0.75,7.78271e-05*1e+5); kp_11->SetPointError(4,0,3.03864e-06*1e+5); kp_11->SetPoint(5,0.85,5.17593e-05*1e+5); kp_11->SetPointError(5,0,2.1078e-06*1e+5); kp_11->SetPoint(6,0.95,4.07006e-05*1e+5); kp_11->SetPointError(6,0,1.62284e-06*1e+5); kp_11->SetPoint(7,1.05,2.88072e-05*1e+5); kp_11->SetPointError(7,0,1.29873e-06*1e+5); kp_11->SetPoint(8,1.15,2.1632e-05*1e+5); kp_11->SetPointError(8,0,1.24272e-06*1e+5); kp_11->SetPoint(9,1.25,1e+19*1e+5); kp_11->SetPointError(9,0,3.4459e-06*1e+5); kp_21->SetPoint(0,0.25,1e+19*1e+6); kp_21->SetPointError(0,0,4.96156e-06*1e+6); kp_21->SetPoint(1,0.35,1e+19*1e+6); kp_21->SetPointError(1,0,1.69267e-06*1e+6); kp_21->SetPoint(2,0.45,1e+19*1e+6); kp_21->SetPointError(2,0,1.50027e-06*1e+6); kp_21->SetPoint(3,0.55,9.18764e-06*1e+6); kp_21->SetPointError(3,0,1.95881e-06*1e+6); kp_21->SetPoint(4,0.65,7.7586e-06*1e+6); kp_21->SetPointError(4,0,2.07357e-06*1e+6); kp_21->SetPoint(5,0.75,6.30923e-06*1e+6); kp_21->SetPointError(5,0,1.21421e-06*1e+6); kp_21->SetPoint(6,0.85,5.01193e-06*1e+6); kp_21->SetPointError(6,0,8.02551e-07*1e+6); kp_21->SetPoint(7,0.95,3.04882e-06*1e+6); kp_21->SetPointError(7,0,4.44717e-07*1e+6); kp_21->SetPoint(8,1.05,2.35543e-06*1e+6); kp_21->SetPointError(8,0,3.23543e-07*1e+6); kp_21->SetPoint(9,1.15,1.1392e-06*1e+6); kp_21->SetPointError(9,0,1.87284e-07*1e+6); kp_21->SetPoint(10,1.25,1.30657e-06*1e+6); kp_21->SetPointError(10,0,1.82956e-07*1e+6); kp_21->SetPoint(11,1.35,1.01881e-06*1e+6); kp_21->SetPointError(11,0,1.51875e-07*1e+6); kp_21->SetPoint(12,1.45,4.99906e-07*1e+6); kp_21->SetPointError(12,0,1.04238e-07*1e+6); kp_21->SetPoint(13,1.55,3.90129e-07*1e+6); kp_21->SetPointError(13,0,1.04266e-07*1e+6); kp_21->SetPoint(14,1.65,1e+19*1e+6); kp_21->SetPointError(14,0,1.453e-07*1e+6); kp_24->SetPoint(0,0.45,1e+19*1e+7); kp_24->SetPointError(0,0,2.24255e-07*1e+7); kp_24->SetPoint(1,0.55,1e+19*1e+7); kp_24->SetPointError(1,0,7.43529e-08*1e+7); kp_24->SetPoint(2,0.65,6.62205e-07*1e+7); kp_24->SetPointError(2,0,3.90887e-08*1e+7); kp_24->SetPoint(3,0.75,4.62776e-07*1e+7); kp_24->SetPointError(3,0,3.12004e-08*1e+7); kp_24->SetPoint(4,0.85,3.46799e-07*1e+7); kp_24->SetPointError(4,0,3.55808e-08*1e+7); kp_24->SetPoint(5,0.95,2.41926e-07*1e+7); kp_24->SetPointError(5,0,3.17664e-08*1e+7); kp_24->SetPoint(6,1.05,1.58541e-07*1e+7); kp_24->SetPointError(6,0,2.50676e-08*1e+7); kp_24->SetPoint(7,1.15,1.62161e-07*1e+7); kp_24->SetPointError(7,0,3.18025e-08*1e+7); kp_24->SetPoint(8,1.25,1e+19*1e+7); kp_24->SetPointError(8,0,9.19013e-08*1e+7); kp_295->SetPoint(0,0.85,2.95407e-08*1e+8); kp_295->SetPointError(0,0,3.53079e-09*1e+8); kp_295->SetPoint(1,0.95,2.05269e-08*1e+8); kp_295->SetPointError(1,0,1.96612e-09*1e+8); kp_295->SetPoint(2,1.05,1.26943e-08*1e+8); kp_295->SetPointError(2,0,1.37689e-09*1e+8); kp_295->SetPoint(3,1.15,7.87579e-09*1e+8); kp_295->SetPointError(3,0,1.00023e-09*1e+8); kp_295->SetPoint(4,1.25,6.31398e-09*1e+8); kp_295->SetPointError(4,0,8.2201e-10*1e+8); kp_295->SetPoint(5,1.35,4.94113e-09*1e+8); kp_295->SetPointError(5,0,6.85212e-10*1e+8); kp_295->SetPoint(6,1.45,3.26681e-09*1e+8); kp_295->SetPointError(6,0,5.29946e-10*1e+8); kp_295->SetPoint(7,1.55,1.94394e-09*1e+8); kp_295->SetPointError(7,0,3.88788e-10*1e+8); kp_295->SetPoint(8,1.65,1.5941e-09*1e+8); kp_295->SetPointError(8,0,3.47862e-10*1e+8); kp_295->SetPoint(9,1.75,8.12471e-10*1e+8); kp_295->SetPointError(9,0,2.44969e-10*1e+8); kp_295->SetPoint(10,1.85,6.53332e-10*1e+8); kp_295->SetPointError(10,0,2.17777e-10*1e+8); kp_295->SetPoint(11,1.95,2.21745e-10*1e+8); kp_295->SetPointError(11,0,1.28024e-10*1e+8); kp_295->SetPoint(12,2.05,4.11989e-10*1e+8); kp_295->SetPointError(12,0,1.84247e-10*1e+8); kp_295->SetPoint(13,2.15,1e+19*1e+8); kp_295->SetPointError(13,0,9.2076e-11*1e+8); kp_295->SetPoint(14,2.25,1e+19*1e+8); kp_295->SetPointError(14,0,1.02151e-10*1e+8); kp_295->SetPoint(15,2.35,1e+19*1e+8); kp_295->SetPointError(15,0,1.11887e-10*1e+8); kp_295->SetPoint(16,2.45,1e+19*1e+8); kp_295->SetPointError(16,0,1.21244e-10*1e+8); kp_305->SetPoint(0,0.75,4.03023e-09*1e+9); kp_305->SetPointError(0,0,4.45065e-10*1e+9); kp_305->SetPoint(1,0.85,2.82081e-09*1e+9); kp_305->SetPointError(1,0,2.42777e-10*1e+9); kp_305->SetPoint(2,0.95,2.11268e-09*1e+9); kp_305->SetPointError(2,0,1.86736e-10*1e+9); kp_305->SetPoint(3,1.05,1.11516e-09*1e+9); kp_305->SetPointError(3,0,1.27918e-10*1e+9); kp_305->SetPoint(4,1.15,5.01185e-10*1e+9); kp_305->SetPointError(4,0,8.35309e-11*1e+9); kp_305->SetPoint(5,1.25,6.49055e-10*1e+9); kp_305->SetPointError(5,0,8.67336e-11*1e+9); kp_305->SetPoint(6,1.35,5.40368e-10*1e+9); kp_305->SetPointError(6,0,7.35348e-11*1e+9); kp_305->SetPoint(7,1.45,3.68993e-10*1e+9); kp_305->SetPointError(7,0,6.06621e-11*1e+9); kp_305->SetPoint(8,1.55,1.92454e-10*1e+9); kp_305->SetPointError(8,0,4.53618e-11*1e+9); kp_305->SetPoint(9,1.65,1.40807e-10*1e+9); kp_305->SetPointError(9,0,4.06475e-11*1e+9); kp_305->SetPoint(10,1.75,1.18761e-10*1e+9); kp_305->SetPointError(10,0,3.9587e-11*1e+9); kp_305->SetPoint(11,1.85,1e+19*1e+9); kp_305->SetPointError(11,0,2.24563e-11*1e+9); kp_305->SetPoint(12,1.95,1e+19*1e+9); kp_305->SetPointError(12,0,3.68231e-11*1e+9); kp_305->SetPoint(13,2.05,1e+19*1e+9); kp_305->SetPointError(13,0,3.1575e-11*1e+9); kp_315->SetPoint(0,0.65,3.5927e-10*1e+10); kp_315->SetPointError(0,0,5.18562e-11*1e+10); kp_315->SetPoint(1,0.75,3.43659e-10*1e+10); kp_315->SetPointError(1,0,2.37643e-11*1e+10); kp_315->SetPoint(2,0.85,2.47208e-10*1e+10); kp_315->SetPointError(2,0,1.63359e-11*1e+10); kp_315->SetPoint(3,0.95,1.58976e-10*1e+10); kp_315->SetPointError(3,0,1.21929e-11*1e+10); kp_315->SetPoint(4,1.05,1.24968e-10*1e+10); kp_315->SetPointError(4,0,1.04503e-11*1e+10); kp_315->SetPoint(5,1.15,6.27383e-11*1e+10); kp_315->SetPointError(5,0,7.29318e-12*1e+10); kp_315->SetPoint(6,1.25,4.52227e-11*1e+10); kp_315->SetPointError(6,0,6.15403e-12*1e+10); kp_315->SetPoint(7,1.35,3.82199e-11*1e+10); kp_315->SetPointError(7,0,5.69749e-12*1e+10); kp_315->SetPoint(8,1.45,2.74866e-11*1e+10); kp_315->SetPointError(8,0,5.72923e-12*1e+10); kp_315->SetPoint(9,1.55,1.31221e-11*1e+10); kp_315->SetPointError(9,0,3.50704e-12*1e+10); kp_315->SetPoint(10,1.65,1.09537e-11*1e+10); kp_315->SetPointError(10,0,3.30265e-12*1e+10); kp_315->SetPoint(11,1.75,5.29222e-12*1e+10); kp_315->SetPointError(11,0,2.36675e-12*1e+10); kp_315->SetPoint(12,1.85,1e+19*1e+10); kp_315->SetPointError(12,0,1.6227e-12*1e+10); kp_315->SetPoint(13,1.95,1e+19*1e+10); kp_315->SetPointError(13,0,3.74417e-12*1e+10); kp_315->SetPoint(14,2.05,1e+19*1e+10); kp_315->SetPointError(14,0,1.38935e-12*1e+10); kp_315->SetPoint(15,2.15,1e+19*1e+10); kp_315->SetPointError(15,0,1.58478e-12*1e+10); kp_315->SetPoint(16,2.25,1e+19*1e+10); kp_315->SetPointError(16,0,1.65703e-12*1e+10); kp_33->SetPoint(0,0.45,1e+19*1e+11); kp_33->SetPointError(0,0,2.16387e-11*1e+11); kp_33->SetPoint(1,0.55,6.44541e-11*1e+11); kp_33->SetPointError(1,0,4.18674e-12*1e+11); kp_33->SetPoint(2,0.65,4.35103e-11*1e+11); kp_33->SetPointError(2,0,2.38794e-12*1e+11); kp_33->SetPoint(3,0.75,3.06766e-11*1e+11); kp_33->SetPointError(3,0,1.74513e-12*1e+11); kp_33->SetPoint(4,0.85,1.88063e-11*1e+11); kp_33->SetPointError(4,0,1.27081e-12*1e+11); kp_33->SetPoint(5,0.95,1.33158e-11*1e+11); kp_33->SetPointError(5,0,1.09827e-12*1e+11); kp_33->SetPoint(6,1.05,1.42346e-11*1e+11); kp_33->SetPointError(6,0,1.25817e-12*1e+11); kp_33->SetPoint(7,1.15,8.28336e-12*1e+11); kp_33->SetPointError(7,0,1.01961e-12*1e+11); kp_33->SetPoint(8,1.25,5.0773e-12*1e+11); kp_33->SetPointError(8,0,8.34702e-13*1e+11); kp_33->SetPoint(9,1.35,3.62631e-12*1e+11); kp_33->SetPointError(9,0,7.40217e-13*1e+11); kp_33->SetPoint(10,1.45,2.47418e-12*1e+11); kp_33->SetPointError(10,0,6.61254e-13*1e+11); kp_33->SetPoint(11,1.55,1.8423e-12*1e+11); kp_33->SetPointError(11,0,6.51351e-13*1e+11); kp_33->SetPoint(12,1.65,8.42401e-13*1e+11); kp_33->SetPointError(12,0,4.86361e-13*1e+11); kp_33->SetPoint(13,1.75,1e+19*1e+11); kp_33->SetPointError(13,0,6.8286e-13*1e+11); kp_33->SetPoint(14,1.85,1e+19*1e+11); kp_33->SetPointError(14,0,6.95957e-13*1e+11); kp_33->SetPoint(15,1.95,1e+19*1e+11); kp_33->SetPointError(15,0,2.44093e-12*1e+11); km_m005->SetPoint(0,0.25,21.299); km_m005->SetPointError(0,0,9.52519); km_m005->SetPoint(1,0.35,13.3885); km_m005->SetPointError(1,0,2.99375); km_m005->SetPoint(2,0.45,16.0492); km_m005->SetPointError(2,0,1.87842); km_m005->SetPoint(3,0.55,15.303); km_m005->SetPointError(3,0,1.25367); km_m005->SetPoint(4,0.65,9.90492); km_m005->SetPointError(4,0,0.696907); km_m005->SetPoint(5,0.75,6.78849); km_m005->SetPointError(5,0,0.45768); km_m005->SetPoint(6,0.85,5.90407); km_m005->SetPointError(6,0,0.335871); km_m005->SetPoint(7,0.95,4.12864); km_m005->SetPointError(7,0,0.229016); km_m005->SetPoint(8,1.05,3.4207); km_m005->SetPointError(8,0,0.180789); km_m005->SetPoint(9,1.15,2.14538); km_m005->SetPointError(9,0,0.128671); km_m005->SetPoint(10,1.25,1.70236); km_m005->SetPointError(10,0,0.103795); km_m005->SetPoint(11,1.35,1.17182); km_m005->SetPointError(11,0,0.0784711); km_m005->SetPoint(12,1.45,0.848992); km_m005->SetPointError(12,0,0.0624192); km_m005->SetPoint(13,1.55,0.606969); km_m005->SetPointError(13,0,0.0495588); km_m005->SetPoint(14,1.65,0.463191); km_m005->SetPointError(14,0,0.0415958); km_m005->SetPoint(15,1.75,0.367511); km_m005->SetPointError(15,0,0.0348826); km_m005->SetPoint(16,1.85,0.22198); km_m005->SetPointError(16,0,0.0261606); km_m005->SetPoint(17,1.95,0.171492); km_m005->SetPointError(17,0,0.0221395); km_005->SetPoint( 0, 0.55, 2.724747); km_005->SetPointError( 0, 0.0, 0.323368); km_005->SetPoint( 1, 0.65, 2.458719); km_005->SetPointError( 1, 0.0, 0.1769825); km_005->SetPoint( 2, 0.75, 1.909245); km_005->SetPointError( 2, 0.0, 0.1140992); km_005->SetPoint( 3, 0.85, 1.230099); km_005->SetPointError( 3, 0.0, 0.07364412); km_005->SetPoint( 4, 0.95, 0.9024825); km_005->SetPointError( 4, 0.0, 0.05422492); km_005->SetPoint( 5, 1.1, 0.5408301); km_005->SetPointError( 5, 0.0, 0.0247889); km_005->SetPoint( 6, 1.3, 0.2763036); km_005->SetPointError( 6, 0.0, 0.0150736); km_005->SetPoint( 7, 1.5, 0.1596649); km_005->SetPointError( 7, 0.0, 0.01011835); km_005->SetPoint( 8, 1.7, 0.06167173); km_005->SetPointError( 8, 0.0, 0.005655977); km_005->SetPoint( 9, 1.9, 0.03868925); km_005->SetPointError( 9, 0.0, 0.003991933); km_005->SetPoint( 10, 2.25, 0.01768691); km_005->SetPointError( 10, 0.0, 0.001250135); km_010->SetPoint(10, 2.25, 0.01705542); km_010->SetPoint( 9, 1.9, 0.04075824); km_010->SetPoint( 8, 1.7, 0.06587045); km_010->SetPoint( 7, 1.5, 0.1450374); km_010->SetPoint( 6, 1.3, 0.2731195); km_010->SetPoint( 5, 1.1, 0.5299263); km_010->SetPoint( 4, 0.95, 0.8520211); km_010->SetPoint( 3, 0.85, 1.205691); km_010->SetPoint( 2, 0.75, 1.750275); km_010->SetPoint( 1, 0.65, 2.35183); km_010->SetPoint( 0, 0.55, 2.834678); km_010->SetPointError(10, 0.0, 0.001227198); km_010->SetPointError( 9, 0.0, 0.004066294); km_010->SetPointError( 8, 0.0, 0.00585648); km_010->SetPointError( 7, 0.0, 0.01003477); km_010->SetPointError( 6, 0.0, 0.01602921); km_010->SetPointError( 5, 0.0, 0.02542808); km_010->SetPointError( 4, 0.0, 0.05296724); km_010->SetPointError( 3, 0.0, 0.0704929); km_010->SetPointError( 2, 0.0, 0.1001465); km_010->SetPointError( 1, 0.0, 0.1455203); km_010->SetPointError( 0, 0.0, 0.2186039); /* km_005->SetPoint(0,0.25,2.54952*10.); km_005->SetPointError(0,0,1.27476*10.); km_005->SetPoint(1,0.35,1.66988*10.); km_005->SetPointError(1,0,0.383096*10.); km_005->SetPoint(2,0.45,1.68784*10.); km_005->SetPointError(2,0,0.192347*10.); km_005->SetPoint(3,0.55,1.39379*10.); km_005->SetPointError(3,0,0.0985557*10.); km_005->SetPoint(4,0.65,0.9918*10.); km_005->SetPointError(4,0,0.0545968*10.); km_005->SetPoint(5,0.75,0.731435*10.); km_005->SetPointError(5,0,0.0374726*10.); km_005->SetPoint(6,0.85,0.581243*10.); km_005->SetPointError(6,0,0.0276469*10.); km_005->SetPoint(7,0.95,0.438002*10.); km_005->SetPointError(7,0,0.0210491*10.); km_005->SetPoint(8,1.05,0.306566*10.); km_005->SetPointError(8,0,0.0160684*10.); km_005->SetPoint(9,1.15,0.225863*10.); km_005->SetPointError(9,0,0.0125868*10.); km_005->SetPoint(10,1.25,0.1514*10.); km_005->SetPointError(10,0,0.00957537*10.); km_005->SetPoint(11,1.35,0.135467*10.); km_005->SetPointError(11,0,0.00840129*10.); km_005->SetPoint(12,1.45,0.103348*10.); km_005->SetPointError(12,0,0.00699962*10.); km_005->SetPoint(13,1.55,0.0660114*10.); km_005->SetPointError(13,0,0.00537193*10.); km_005->SetPoint(14,1.65,0.0432401*10.); km_005->SetPointError(14,0,0.00418018*10.); km_005->SetPoint(15,1.75,0.0358472*10.); km_005->SetPointError(15,0,0.00365864*10.); km_005->SetPoint(16,1.85,0.0190815*10.); km_005->SetPointError(16,0,0.00257295*10.); km_005->SetPoint(17,1.95,0.015555*10.); km_005->SetPointError(17,0,0.00226893*10.); */ km_05->SetPoint(0,0.15,0.326737*100.); km_05->SetPointError(0,0,0.103323*100.); km_05->SetPoint(1,0.25,0.248756*100.); km_05->SetPointError(1,0,0.0241613*100.); km_05->SetPoint(2,0.35,0.219601*100.); km_05->SetPointError(2,0,0.0138062*100.); km_05->SetPoint(3,0.45,0.171299*100.); km_05->SetPointError(3,0,0.00976066*100.); km_05->SetPoint(4,0.55,0.126597*100.); km_05->SetPointError(4,0,0.00745979*100.); km_05->SetPoint(5,0.65,0.115761*100.); km_05->SetPointError(5,0,0.00622338*100.); km_05->SetPoint(6,0.75,0.0691177*100.); km_05->SetPointError(6,0,0.00431144*100.); km_05->SetPoint(7,0.85,0.0577531*100.); km_05->SetPointError(7,0,0.00356121*100.); km_05->SetPoint(8,0.95,0.0462381*100.); km_05->SetPointError(8,0,0.00291273*100.); km_05->SetPoint(9,1.05,0.034*100.); km_05->SetPointError(9,0,0.00232419*100.); km_05->SetPoint(10,1.15,0.0223647*100.); km_05->SetPointError(10,0,0.00176808*100.); km_05->SetPoint(11,1.25,0.0173048*100.); km_05->SetPointError(11,0,0.00146777*100.); km_05->SetPoint(12,1.35,0.00900337*100.); km_05->SetPointError(12,0,0.00101296*100.); km_05->SetPoint(13,1.45,0.00768789*100.); km_05->SetPointError(13,0,0.000893699*100.); km_05->SetPoint(14,1.55,0.00554776*100.); km_05->SetPointError(14,0,0.000728456*100.); km_05->SetPoint(15,1.65,0.00372395*100.); km_05->SetPointError(15,0,0.000596309*100.); km_05->SetPoint(16,1.75,0.00304393*100.); km_05->SetPointError(16,0,0.000844234*100.); km_07->SetPoint(0,0.15,1e+19*1000.); km_07->SetPointError(0,0,0.00968544*1000.); km_07->SetPoint(1,0.25,1e+19*1000.); km_07->SetPointError(1,0,0.00238594*1000.); km_07->SetPoint(2,0.35,0.0215031*1000.); km_07->SetPointError(2,0,0.00100477*1000.); km_07->SetPoint(3,0.45,0.0170041*1000.); km_07->SetPointError(3,0,0.000603833*1000.); km_07->SetPoint(4,0.55,0.0137753*1000.); km_07->SetPointError(4,0,0.0004474*1000.); km_07->SetPoint(5,0.65,0.00984658*1000.); km_07->SetPointError(5,0,0.000340755*1000.); km_07->SetPoint(6,0.75,0.00805408*1000.); km_07->SetPointError(6,0,0.00029196*1000.); km_07->SetPoint(7,0.85,0.00547363*1000.); km_07->SetPointError(7,0,0.000230686*1000.); km_07->SetPoint(8,0.95,0.00422765*1000.); km_07->SetPointError(8,0,0.00019733*1000.); km_07->SetPoint(9,1.05,0.00290095*1000.); km_07->SetPointError(9,0,0.000158733*1000.); km_07->SetPoint(10,1.15,0.00226285*1000.); km_07->SetPointError(10,0,0.000136455*1000.); km_07->SetPoint(11,1.25,0.00167193*1000.); km_07->SetPointError(11,0,0.00011376*1000.); km_07->SetPoint(12,1.35,0.00112271*1000.); km_07->SetPointError(12,0,9.04705e-05*1000.); km_07->SetPoint(13,1.45,0.000779882*1000.); km_07->SetPointError(13,0,7.76012e-05*1000.); km_07->SetPoint(14,1.55,0.000582018*1000.); km_07->SetPointError(14,0,0.000102887*1000.); km_07->SetPoint(15,1.65,1e+19*1000.); km_07->SetPointError(15,0,0.000236553*1000.); km_09->SetPoint(0,0.25,0.00220905*10000.); km_09->SetPointError(0,0,0.000450921*10000.); km_09->SetPoint(1,0.35,0.00187955*10000.); km_09->SetPointError(1,0,0.000150969*10000.); km_09->SetPoint(2,0.45,0.00162395*10000.); km_09->SetPointError(2,0,7.75071e-05*10000.); km_09->SetPoint(3,0.55,0.00129246*10000.); km_09->SetPointError(3,0,4.68209e-05*10000.); km_09->SetPoint(4,0.65,0.000969325*10000.); km_09->SetPointError(4,0,3.13995e-05*10000.); km_09->SetPoint(5,0.75,0.000746561*10000.); km_09->SetPointError(5,0,2.32394e-05*10000.); km_09->SetPoint(6,0.85,0.000542695*10000.); km_09->SetPointError(6,0,1.73446e-05*10000.); km_09->SetPoint(7,0.95,0.000387739*10000.); km_09->SetPointError(7,0,1.32141e-05*10000.); km_09->SetPoint(8,1.05,0.0003076*10000.); km_09->SetPointError(8,0,1.0937e-05*10000.); km_09->SetPoint(9,1.15,0.000210946*10000.); km_09->SetPointError(9,0,8.48549e-06*10000.); km_09->SetPoint(10,1.25,0.000152167*10000.); km_09->SetPointError(10,0,7.14157e-06*10000.); km_09->SetPoint(11,1.35,0.000115626*10000.); km_09->SetPointError(11,0,8.25902e-06*10000.); km_09->SetPoint(12,1.45,1e+19*10000.); km_09->SetPointError(12,0,2.29393e-05*10000.); km_11->SetPoint(0,0.35,0.000143328*1e+5); km_11->SetPointError(0,0,3.8306e-05*1e+5); km_11->SetPoint(1,0.45,0.000162454*1e+5); km_11->SetPointError(1,0,1.33537e-05*1e+5); km_11->SetPoint(2,0.55,0.000117041*1e+5); km_11->SetPointError(2,0,7.12286e-06*1e+5); km_11->SetPoint(3,0.65,9.44107e-05*1e+5); km_11->SetPointError(3,0,4.86886e-06*1e+5); km_11->SetPoint(4,0.75,6.84226e-05*1e+5); km_11->SetPointError(4,0,3.40415e-06*1e+5); km_11->SetPoint(5,0.85,5.2807e-05*1e+5); km_11->SetPointError(5,0,2.5706e-06*1e+5); km_11->SetPoint(6,0.95,4.0619e-05*1e+5); km_11->SetPointError(6,0,1.96569e-06*1e+5); km_11->SetPoint(7,1.05,2.99544e-05*1e+5); km_11->SetPointError(7,0,1.61269e-06*1e+5); km_11->SetPoint(8,1.15,2.21342e-05*1e+5); km_11->SetPointError(8,0,1.63175e-06*1e+5); km_11->SetPoint(9,1.25,1e+19*1e+5); km_11->SetPointError(9,0,6.13252e-06*1e+5); km_21->SetPoint(0,0.25,1.65712e-05*1e+6); km_21->SetPointError(0,0,5.85612e-06*1e+6); km_21->SetPoint(1,0.35,1.75292e-05*1e+6); km_21->SetPointError(1,0,1.85587e-06*1e+6); km_21->SetPoint(2,0.45,1.37856e-05*1e+6); km_21->SetPointError(2,0,1.09296e-06*1e+6); km_21->SetPoint(3,0.55,7.51591e-06*1e+6); km_21->SetPointError(3,0,1.08292e-06*1e+6); km_21->SetPoint(4,0.65,5.84503e-06*1e+6); km_21->SetPointError(4,0,1.03625e-06*1e+6); km_21->SetPoint(5,0.75,4.31475e-06*1e+6); km_21->SetPointError(5,0,6.90912e-07*1e+6); km_21->SetPoint(6,0.85,3.19884e-06*1e+6); km_21->SetPointError(6,0,4.52385e-07*1e+6); km_21->SetPoint(7,0.95,2.67955e-06*1e+6); km_21->SetPointError(7,0,3.18004e-07*1e+6); km_21->SetPoint(8,1.05,1.7367e-06*1e+6); km_21->SetPointError(8,0,2.22362e-07*1e+6); km_21->SetPoint(9,1.15,1.2779e-06*1e+6); km_21->SetPointError(9,0,1.66368e-07*1e+6); km_21->SetPoint(10,1.25,1.00536e-06*1e+6); km_21->SetPointError(10,0,1.33163e-07*1e+6); km_21->SetPoint(11,1.35,7.06667e-07*1e+6); km_21->SetPointError(11,0,1.06534e-07*1e+6); km_21->SetPoint(12,1.45,4.66671e-07*1e+6); km_21->SetPointError(12,0,1.09995e-07*1e+6); km_21->SetPoint(13,1.55,4.02597e-07*1e+6); km_21->SetPointError(13,0,2.01299e-07*1e+6); km_23->SetPoint(0,0.45,1e+19*1e+7); km_23->SetPointError(0,0,9.92118e-08*1e+7); km_23->SetPoint(1,0.55,1e+19*1e+7); km_23->SetPointError(1,0,7.48669e-08*1e+7); km_23->SetPoint(2,0.65,6.17229e-07*1e+7); km_23->SetPointError(2,0,5.83227e-08*1e+7); km_23->SetPoint(3,0.75,4.72414e-07*1e+7); km_23->SetPointError(3,0,5.06481e-08*1e+7); km_23->SetPoint(4,0.85,2.8697e-07*1e+7); km_23->SetPointError(4,0,4.09957e-08*1e+7); km_23->SetPoint(5,0.95,2.44332e-07*1e+7); km_23->SetPointError(5,0,3.91244e-08*1e+7); km_23->SetPoint(6,1.05,1.25639e-07*1e+7); km_23->SetPointError(6,0,3.04718e-08*1e+7); km_23->SetPoint(7,1.15,6.87403e-08*1e+7); km_23->SetPointError(7,0,3.43701e-08*1e+7); km_295->SetPoint(0,0.75,1e+19*1e+8); km_295->SetPointError(0,0,4.69063e-09*1e+8); km_295->SetPoint(1,0.85,2.03098e-08*1e+8); km_295->SetPointError(1,0,1.65029e-09*1e+8); km_295->SetPoint(2,0.95,1.41231e-08*1e+8); km_295->SetPointError(2,0,1.02258e-09*1e+8); km_295->SetPoint(3,1.05,9.21164e-09*1e+8); km_295->SetPointError(3,0,8.58989e-10*1e+8); km_295->SetPoint(4,1.15,6.06341e-09*1e+8); km_295->SetPointError(4,0,6.61572e-10*1e+8); km_295->SetPoint(5,1.25,4.43557e-09*1e+8); km_295->SetPointError(5,0,5.33979e-10*1e+8); km_295->SetPoint(6,1.35,2.70779e-09*1e+8); km_295->SetPointError(6,0,3.90835e-10*1e+8); km_295->SetPoint(7,1.45,1.78771e-09*1e+8); km_295->SetPointError(7,0,3.02177e-10*1e+8); km_295->SetPoint(8,1.55,1.3372e-09*1e+8); km_295->SetPointError(8,0,2.48312e-10*1e+8); km_295->SetPoint(9,1.65,7.01505e-10*1e+8); km_295->SetPointError(9,0,1.81128e-10*1e+8); km_295->SetPoint(10,1.75,4.38509e-10*1e+8); km_295->SetPointError(10,0,1.4617e-10*1e+8); km_295->SetPoint(11,1.85,3.8601e-10*1e+8); km_295->SetPointError(11,0,1.45898e-10*1e+8); km_295->SetPoint(12,1.95,2.32057e-10*1e+8); km_295->SetPointError(12,0,1.16028e-10*1e+8); km_295->SetPoint(13,2.05,1.25769e-10*1e+8); km_295->SetPointError(13,0,8.89318e-11*1e+8); km_295->SetPoint(14,2.15,1e+19*1e+8); km_295->SetPointError(14,0,6.84859e-11*1e+8); km_295->SetPoint(15,2.25,1e+19*1e+8); km_295->SetPointError(15,0,1.08028e-10*1e+8); km_295->SetPoint(16,2.35,1e+19*1e+8); km_295->SetPointError(16,0,1.44192e-10*1e+8); km_305->SetPoint(0,0.65,1e+19*1e+9); km_305->SetPointError(0,0,5.23957e-10*1e+9); km_305->SetPoint(1,0.75,2.87637e-09*1e+9); km_305->SetPointError(1,0,1.94812e-10*1e+9); km_305->SetPoint(2,0.85,1.96678e-09*1e+9); km_305->SetPointError(2,0,1.2591e-10*1e+9); km_305->SetPoint(3,0.95,1.04981e-09*1e+9); km_305->SetPointError(3,0,8.84102e-11*1e+9); km_305->SetPoint(4,1.05,1.12046e-09*1e+9); km_305->SetPointError(4,0,9.30491e-11*1e+9); km_305->SetPoint(5,1.15,5.91333e-10*1e+9); km_305->SetPointError(5,0,7.11882e-11*1e+9); km_305->SetPoint(6,1.25,4.34744e-10*1e+9); km_305->SetPointError(6,0,6.40995e-11*1e+9); km_305->SetPoint(7,1.35,3.05143e-10*1e+9); km_305->SetPointError(7,0,5.66636e-11*1e+9); km_305->SetPoint(8,1.45,1.05006e-10*1e+9); km_305->SetPointError(8,0,3.50018e-11*1e+9); km_305->SetPoint(9,1.55,1.75147e-10*1e+9); km_305->SetPointError(9,0,4.85769e-11*1e+9); km_305->SetPoint(10,1.65,6.57709e-11*1e+9); km_305->SetPointError(10,0,3.28854e-11*1e+9); km_305->SetPoint(11,1.75,4.07434e-11*1e+9); km_305->SetPointError(11,0,2.88099e-11*1e+9); km_305->SetPoint(12,1.85,1e+19*1e+9); km_305->SetPointError(12,0,3.39019e-11*1e+9); km_305->SetPoint(13,1.95,1e+19*1e+9); km_305->SetPointError(13,0,5.727e-11*1e+9); km_315->SetPoint(0,0.65,3.32039e-10*1e+10); km_315->SetPointError(0,0,3.46174e-11*1e+10); km_315->SetPoint(1,0.75,2.52771e-10*1e+10); km_315->SetPointError(1,0,1.52984e-11*1e+10); km_315->SetPoint(2,0.85,1.73718e-10*1e+10); km_315->SetPointError(2,0,1.10758e-11*1e+10); km_315->SetPoint(3,0.95,9.93379e-11*1e+10); km_315->SetPointError(3,0,7.9534e-12*1e+10); km_315->SetPoint(4,1.05,9.14397e-11*1e+10); km_315->SetPointError(4,0,7.39246e-12*1e+10); km_315->SetPoint(5,1.15,4.79349e-11*1e+10); km_315->SetPointError(5,0,5.23013e-12*1e+10); km_315->SetPoint(6,1.25,3.06806e-11*1e+10); km_315->SetPointError(6,0,4.09987e-12*1e+10); km_315->SetPoint(7,1.35,2.12545e-11*1e+10); km_315->SetPointError(7,0,3.44793e-12*1e+10); km_315->SetPoint(8,1.45,1.66365e-11*1e+10); km_315->SetPointError(8,0,3.144e-12*1e+10); km_315->SetPoint(9,1.55,6.20492e-12*1e+10); km_315->SetPointError(9,0,1.96217e-12*1e+10); km_315->SetPoint(10,1.65,7.49565e-12*1e+10); km_315->SetPointError(10,0,2.26002e-12*1e+10); km_315->SetPoint(11,1.75,2.98725e-12*1e+10); km_315->SetPointError(11,0,1.49363e-12*1e+10); km_315->SetPoint(12,1.85,1e+19*1e+10); km_315->SetPointError(12,0,8.29052e-13*1e+10); km_315->SetPoint(13,2.05,1e+19*1e+10); km_315->SetPointError(13,0,1.00481e-12*1e+10); km_315->SetPoint(14,2.15,1e+19*1e+10); km_315->SetPointError(14,0,1.14579e-12*1e+10); km_33->SetPoint(0,0.45,1e+19*1e+11); km_33->SetPointError(0,0,1.91668e-11*1e+11); km_33->SetPoint(1,0.55,3.83558e-11*1e+11); km_33->SetPointError(1,0,2.7397e-12*1e+11); km_33->SetPoint(2,0.65,2.60686e-11*1e+11); km_33->SetPointError(2,0,1.52817e-12*1e+11); km_33->SetPoint(3,0.75,1.84045e-11*1e+11); km_33->SetPointError(3,0,1.12633e-12*1e+11); km_33->SetPoint(4,0.85,1.34336e-11*1e+11); km_33->SetPointError(4,0,9.09835e-13*1e+11); km_33->SetPoint(5,0.95,8.6089e-12*1e+11); km_33->SetPointError(5,0,7.5505e-13*1e+11); km_33->SetPoint(6,1.05,7.21517e-12*1e+11); km_33->SetPointError(6,0,7.60545e-13*1e+11); km_33->SetPoint(7,1.15,3.77953e-12*1e+11); km_33->SetPointError(7,0,5.76374e-13*1e+11); km_33->SetPoint(8,1.25,3.03135e-12*1e+11); km_33->SetPointError(8,0,5.74954e-13*1e+11); km_33->SetPoint(9,1.35,2.11752e-12*1e+11); km_33->SetPointError(9,0,5.22761e-13*1e+11); km_33->SetPoint(10,1.45,1.63121e-12*1e+11); km_33->SetPointError(10,0,4.7996e-13*1e+11); km_33->SetPoint(11,1.55,4.72345e-13*1e+11); km_33->SetPointError(11,0,1.5596e-13*1e+11); km_33->SetPoint(12,1.65,6.03917e-13*1e+11); km_33->SetPointError(12,0,3.48672e-13*1e+11); } Double_t int_func(Double_t* xx, Double_t* param); Double_t PipFit(Double_t* xp, Double_t* par); Double_t KpFit(Double_t* xp, Double_t* par); Double_t ProFit(Double_t* xp, Double_t* par); Double_t PimFit(Double_t* xp, Double_t* par); Double_t KmFit(Double_t* xp, Double_t* par); Double_t PbFit(Double_t* xp, Double_t* par); //void FindCanvas(Char_t* canvasName, Int_t xwidth, Int_t ywidth); //=========================================================== Double_t PipFit(Double_t* xp, Double_t* par) { Double_t beta = flowfunc->GetParameter(6); Double_t temp = flowfunc->GetParameter(7); // Double_t rmin = 0.0; Double_t alpha = flowfunc->GetParameter(8); Double_t integral; Double_t mass = kMass[2]; Double_t mt = sqrt(xp[0]*xp[0]+mass*mass); Double_t con = flowfunc->GetParameter(2); TF1* func_pip = new TF1("func_pip",int_func,0.0,radius+2.,7); // 0 1 2 3 4 5 6 Double_t params[7] = {mt,con,mass,beta,radius,temp,alpha}; func_pip->SetParameters(params); integral = func_pip->Integral(0.,radius); if(integral <= 0 )integral = 0.00000001; return integral; } Double_t KpFit(Double_t* xp, Double_t* par) { Double_t beta = flowfunc->GetParameter(6); Double_t temp = flowfunc->GetParameter(7); // Double_t rmin = 0.0; Double_t alpha = flowfunc->GetParameter(8); Double_t integral; Double_t mass = kMass[1]; Double_t mt = sqrt(xp[0]*xp[0]+mass*mass); Double_t con = flowfunc->GetParameter(1); TF1* func_kp = new TF1("func_kp",int_func,0.0,radius+2.,7); // 0 1 2 3 4 5 6 Double_t params[7] = {mt,con,mass,beta,radius,temp,alpha}; func_kp->SetParameters(params); integral = func_kp->Integral(0.,radius); if(integral <= 0 )integral = 0.00000001; return integral; } Double_t ProFit(Double_t* xp, Double_t* par) { Double_t beta = flowfunc->GetParameter(6); Double_t temp = flowfunc->GetParameter(7); // Double_t rmin = 0.0; Double_t alpha = flowfunc->GetParameter(8); Double_t integral; Double_t mass = kMass[0]; Double_t mt = sqrt(xp[0]*xp[0]+mass*mass); Double_t con = flowfunc->GetParameter(0); TF1* func_pro = new TF1("func_pro",int_func,0.0,radius+2.,7); // 0 1 2 3 4 5 6 Double_t params[7] = {mt,con,mass,beta,radius,temp,alpha}; func_pro->SetParameters(params); integral = func_pro->Integral(0.,radius); if(integral <= 0 )integral = 0.00000001; return integral; } Double_t PimFit(Double_t* xp, Double_t* par) { Double_t beta = flowfunc->GetParameter(6); Double_t temp = flowfunc->GetParameter(7); // Double_t rmin = 0.0; Double_t alpha = flowfunc->GetParameter(8); Double_t integral; Double_t mass = kMass[3]; Double_t mt = sqrt(xp[0]*xp[0]+mass*mass); Double_t con = flowfunc->GetParameter(3); TF1* func_pim = new TF1("func_pim",int_func,0.0,radius+2.,7); // 0 1 2 3 4 5 6 Double_t params[7] = {mt,con,mass,beta,radius,temp,alpha}; func_pim->SetParameters(params); integral = func_pim->Integral(0.,radius); if(integral <= 0 )integral = 0.00000001; return integral; } Double_t KmFit(Double_t* xp, Double_t* par) { Double_t beta = flowfunc->GetParameter(6); Double_t temp = flowfunc->GetParameter(7); // Double_t rmin = 0.0; Double_t alpha = flowfunc->GetParameter(8); Double_t integral; Double_t mass = kMass[4]; Double_t mt = sqrt(xp[0]*xp[0]+mass*mass); Double_t con = flowfunc->GetParameter(4); TF1* func_km = new TF1("func_km",int_func,0.0,radius+2.,7); // 0 1 2 3 4 5 6 Double_t params[7] = {mt,con,mass,beta,radius,temp,alpha}; func_km->SetParameters(params); integral = func_km->Integral(0.,radius); if(integral <= 0 )integral = 0.00000001; return integral; } Double_t PbFit(Double_t* xp, Double_t* par) { Double_t beta = flowfunc->GetParameter(6); Double_t temp = flowfunc->GetParameter(7); // Double_t rmin = 0.0; Double_t alpha = flowfunc->GetParameter(8); Double_t integral; Double_t mass = kMass[5]; Double_t mt = sqrt(xp[0]*xp[0]+mass*mass); Double_t con = flowfunc->GetParameter(5); TF1* func_pbar = new TF1("func_pbar",int_func,0.0,radius+2.,7); // 0 1 2 3 4 5 6 Double_t params[7] = {mt,con,mass,beta,radius,temp,alpha}; func_pbar->SetParameters(params); integral = func_pbar->Integral(0.,radius); if(integral <= 0 )integral = 0.00000001; return integral; } //______________________________________________________________________ //The simultaneous fit function. // Double_t func2D(Double_t* xp, Double_t* pp) { // xp array of dependent variables // pp array of parameters Double_t beta = pp[6]; Double_t temp = pp[7]; // Double_t rmin = 0.0; Double_t alpha = pp[8]; Double_t integral; Int_t y = (Int_t) xp[1]; Double_t mass = kMass[y]; Double_t mt = sqrt(xp[0]*xp[0]+mass*mass); TF1* funcx = new TF1("funcx",int_func,0.0,radius+2.,7); // 0 1 2 3 4 5 6 Double_t params[7] = {mt,pp[y],mass,beta,radius,temp,alpha}; funcx->SetParameters(params); integral = funcx->Integral(0.,radius); if(integral <= 0 )integral = 0.00000001; return integral; } Double_t int_func(Double_t* xx, Double_t* param){ Double_t arg = 0; Double_t out; Double_t rho = TMath::ATanH(param[3]*pow(xx[0]/param[4],param[6])); Double_t pt = sqrt(param[0]*param[0]-param[2]*param[2]); Double_t mt = param[0]; Double_t con = param[1]; Double_t temp = param[5]; out = con * xx[0] * mt * TMath::BesselI0(pt * TMath::SinH(rho)/temp) * TMath::BesselK1(mt * TMath::CosH(rho)/temp); return out; } //______________________________________________________________________ //The method to create simultaneous blast wave fit and corresponding //minuit curves. void flowfit(Int_t rapidity, Double_t rad, Char_t* FileName) { Float_t sys_err = 0.05; // original sys_err = 0.1; Float_t sys_err_proton = 0.05; // original sys_err_proton = 0.1; Float_t sta_err = 1.; Float_t err0; Float_t err1; Int_t bin; radius = rad; if(rapidity == 2)sys_err_proton = 0.15; if(rapidity == 3)sys_err_proton = 0.2; TH2F * multi = new TH2F("multi","multi",40,0,4.0,6,0,6); // multi->GetXaxis()->SetRangeUser(0.0,2.5); //Get the different spectras and add cuts to them. // TFile* hfile = new TFile(FileName); if(rapidity == 0){ /* TH1F* proton = new TH1F(*proton0); TH1F* pbar = new TH1F(*pbar0); TGraphErrors* piplus = new TGraphErrors(*pip_005); TGraphErrors* piminus = new TGraphErrors(*pim_005); TGraphErrors* kplus = new TGraphErrors(*kp_005); TGraphErrors* kminus = new TGraphErrors(*km_005); */ TH1F* proton = new TH1F(*proton010); TH1F* pbar = new TH1F(*pbar010); TGraphErrors* piplus = new TGraphErrors(*pip_010); TGraphErrors* piminus = new TGraphErrors(*pim_010); TGraphErrors* kplus = new TGraphErrors(*kp_010); TGraphErrors* kminus = new TGraphErrors(*km_010); } if(rapidity == 1){ TH1F* proton = new TH1F(*proton1); TH1F* pbar = new TH1F(*pbar1); TGraphErrors* piplus = new TGraphErrors(*pip_11); TGraphErrors* piminus = new TGraphErrors(*pim_11); TGraphErrors* kplus = new TGraphErrors(*kp_11); TGraphErrors* kminus = new TGraphErrors(*km_11); } if(rapidity == 2){ TH1F* proton = new TH1F(*proton2); TH1F* pbar = new TH1F(*pbar2); TGraphErrors* piplus = new TGraphErrors(*pip_22); TGraphErrors* piminus = new TGraphErrors(*pim_22); TGraphErrors* kplus = new TGraphErrors(*kp_21); TGraphErrors* kminus = new TGraphErrors(*km_21); } if(rapidity == 3){ TH1F* proton = new TH1F(*proton3); TH1F* pbar = new TH1F(*pbar3); TGraphErrors* piplus = new TGraphErrors(*pip_305); TGraphErrors* piminus = new TGraphErrors(*pim_305); TGraphErrors* kplus = new TGraphErrors(*kp_295); TGraphErrors* kminus = new TGraphErrors(*km_295); } for (Int_t i=1; i <= proton->GetNbinsX(); i++){ // if ( (i*2.0/40.>0.2) && (i*2.0/40.<=1.7) ){ // if ( (i*4.0/40.>0.2) && (i*4.0/40.<=3.0) ){ if ( (i*4.0/40.>0.2) && (i*4.0/40.<=4.0) ){ err0 = proton->GetBinError(i)*sta_err; err1 = proton->GetBinContent(i)*sys_err_proton; multi->SetBinContent(i,1,proton->GetBinContent(i)); multi->SetBinError (i,1,sqrt(err0*err0 + err1*err1)); } } for (Int_t i=1; i <= pbar->GetNbinsX(); i++){ // if ( (i*2.0/40.>0.2) && (i*2.0/40.<=1.7) ){ // if ( (i*4.0/40.>0.2) && (i*4.0/40.<=3.0) ){ if ( (i*4.0/40.>0.2) && (i*4.0/40.<=4.0) ){ err0 = pbar->GetBinError(i)*sta_err; err1 = pbar->GetBinContent(i)*sys_err_proton; multi->SetBinContent(i,6,pbar->GetBinContent(i)); multi->SetBinError (i,6,sqrt(err0*err0 + err1*err1)); } } for (Int_t i=0; i < 20 ;i++){ if(kplus->GetY()[i] < 100000. && kplus->GetY()[i] > 0 && kplus->GetX()[i] > 0.01 && kplus->GetX()[i] < 100.){ err0 = kplus->GetErrorY(i)*sta_err; err1 = kplus->GetY()[i]*sys_err; bin = int((kplus->GetX()[i])*10.)+1; multi->SetBinContent(bin,2,kplus->GetY()[i]); multi->SetBinError (bin,2,sqrt(err0*err0 + err1*err1)); } } for (Int_t i=0; i < 20 ;i++){ if(kminus->GetY()[i]<100000. && kminus->GetY()[i] > 0 && kminus->GetX()[i] > 0.01 && kminus->GetX()[i] < 100.){ err0 = kminus->GetErrorY(i)*sta_err; err1 = kminus->GetY()[i]*sys_err; bin = int((kminus->GetX()[i])*10.)+1; multi->SetBinContent(bin,5,kminus->GetY()[i]); multi->SetBinError (bin,5,sqrt(err0*err0 + err1*err1)); } } for (Int_t i=0; i < 20 ;i++){ if(piplus->GetY()[i]<100000. && piplus->GetY()[i] > 0 && piplus->GetX()[i] > 0.4 && piplus->GetX()[i] < 3.0){ err0 = piplus->GetErrorY(i)*sta_err; err1 = piplus->GetY()[i]*sys_err; bin = int((piplus->GetX()[i])*10.)+1; multi->SetBinContent(bin,3,piplus->GetY()[i]); multi->SetBinError (bin,3,sqrt(err0*err0 + err1*err1)); } } for (Int_t i=0; i < 20 ;i++){ if(piminus->GetY()[i]<100000. && piminus->GetY()[i] > 0 && piminus->GetX()[i] > 0.4 && piminus->GetX()[i] < 3.0){ err0 = piminus->GetErrorY(i)*sta_err; err1 = piminus->GetY()[i]*sys_err; bin = int((piminus->GetX()[i])*10.)+1; multi->SetBinContent(bin,4,piminus->GetY()[i]); multi->SetBinError (bin,4,sqrt(err0*err0 + err1*err1)); } } //Creating a file to write down the fits in. TFile* chi2depend = new TFile(FileName,"RECREATE"); flowfunc = new TF2("flowfit", func2D, 0, 2.5, 0, 6, 9); flowfunc->SetParNames("Norm p^{+}","Norm K^{+}","Norm#pi^{+}", "Norm#pi^{-}","Norm k{-}", "Norm #bar{p}", "#beta","T","alpha"); flowfunc->SetParameters(32427,3754,4337,4150,2618,7355,0.8,0.12,0.5); if(rapidity == 0) flowfunc->SetParameters(32427,3754,4337,4150,2618,7355,0.8,0.1176,0.3); if(rapidity == 1) flowfunc->SetParameters(32427,3754,4337,4150,2618,7355,0.8,0.1176,0.3); if(rapidity == 2) flowfunc->SetParameters(32427,3754,4337,4150,2618,7355,0.8,0.1176,0.3); if(rapidity == 3) flowfunc->SetParameters(2630,286,3100,290,191,564,0.5,0.13,0.11); //Need parameter limits. Otherwise I end up with negative Bessel //functions. flowfunc->SetParLimits(6,0.2,0.95); flowfunc->SetParLimits(7,0.01,0.2); flowfunc->SetParLimits(8,.0,2.0); multi->Fit(flowfunc); multi->Fit(flowfunc,"+"); cout << "Checking parameters " << flowfunc->GetParameter(1) << endl; flowfunc->Print(); TH1F* pipproj = new TH1F("pipproj","#pi^{+} projection", multi->GetNbinsX(),0.,4.); TH1F* kpproj = new TH1F("kpproj","k^{+} projection", multi->GetNbinsX(),0.,4.); TH1F* proproj = new TH1F("proproj","pro projection", multi->GetNbinsX(),0.,4.); TH1F* pimproj = new TH1F("pimproj","#pi^{-} projection", multi->GetNbinsX(),0.,4.); TH1F* kmproj = new TH1F("kmproj","k^{-} projection", multi->GetNbinsX(),0.,4.); TH1F* pbproj = new TH1F("pbproj","#bar{p} projection", multi->GetNbinsX(),0.,4.); FindCanvas("c2",500,500); c2->Clear(); //Finding the spectras used in the fit. for(Int_t i = 1; i <= multi->GetNbinsX(); i++){ pipproj->SetBinContent(i,multi->GetBinContent(i,3)); pipproj->SetBinError(i,multi->GetBinError(i,3)); kpproj->SetBinContent(i,multi->GetBinContent(i,2)); kpproj->SetBinError(i,multi->GetBinError(i,2)); proproj->SetBinContent(i,multi->GetBinContent(i,1)); proproj->SetBinError(i,multi->GetBinError(i,1)); pimproj->SetBinContent(i,multi->GetBinContent(i,4)); pimproj->SetBinError(i,multi->GetBinError(i,4)); kmproj->SetBinContent(i,multi->GetBinContent(i,5)); kmproj->SetBinError(i,multi->GetBinError(i,5)); pbproj->SetBinContent(i,multi->GetBinContent(i,6)); pbproj->SetBinError(i,multi->GetBinError(i,6)); } //Calculating the projected result of the simultaneous fit. TF1* pipfit = new TF1("pipfit",PipFit,0.2,4.0,0); pipfit->SetLineWidth(1); pipproj->GetListOfFunctions()->Add(pipfit); TF1* kpfit = new TF1("kpfit",KpFit,0.2,4.0,0); kpfit->SetLineWidth(1); kpproj->GetListOfFunctions()->Add(kpfit); TF1* profit = new TF1("profit",ProFit,0.2,4.0,0); profit->SetLineWidth(1); proproj->GetListOfFunctions()->Add(profit); TF1* pimfit = new TF1("pimfit",PimFit,0.2,4.0,0); pimfit->SetLineWidth(1); pimproj->GetListOfFunctions()->Add(pimfit); TF1* kmfit = new TF1("kmfit",KmFit,0.2,4.0,0); kmfit->SetLineWidth(1); kmproj->GetListOfFunctions()->Add(kmfit); TF1* pbfit = new TF1("pbfit",PbFit,0.2,4.0,0); pbfit->SetLineWidth(1); pbproj->GetListOfFunctions()->Add(pbfit); pipproj->GetXaxis()->SetRangeUser(0,5.0); kpproj->GetXaxis()->SetRangeUser(0,5.0); proproj->GetXaxis()->SetRangeUser(0,5.0); pimproj->GetXaxis()->SetRangeUser(0,5.0); kmproj->GetXaxis()->SetRangeUser(0,5.0); pbproj->GetXaxis()->SetRangeUser(0,5.0); c2->cd(); c2->SetFrameFillColor(0); gPad->SetLogy(); gStyle->SetOptStat(0); gStyle->SetOptFit(0); pipproj->SetMinimum(0.000000001); pipproj->SetMarkerColor(2); pipproj->SetMarkerStyle(24); pipproj->SetMarkerSize(0.5); pimproj->SetMinimum(0.001); pimproj->SetMarkerColor(2); pimproj->SetMarkerStyle(20); pimproj->SetMarkerSize(0.5); pimproj->SetTitle("Projection of multifit"); pipproj->SetTitle("Projection of multifit"); kpproj->SetMarkerColor(3); kpproj->SetMarkerStyle(26); kpproj->SetMarkerSize(0.5); kmproj->SetMarkerColor(3); kmproj->SetMarkerStyle(22); kmproj->SetMarkerSize(0.5); proproj->SetMarkerColor(4); proproj->SetMarkerStyle(25); proproj->SetMarkerSize(0.5); pbproj->SetMarkerColor(4); pbproj->SetMarkerStyle(21); pbproj->SetMarkerSize(0.5); pimproj->Draw(); pipproj->Draw("SAME"); kpproj->Draw("SAME"); kmproj->Draw("SAME"); proproj->Draw("SAME"); pbproj->Draw("SAME"); Float_t T = flowfunc->GetParameter(7); Float_t T_err = flowfunc->GetParError(7); Float_t chi2 = flowfunc->GetChisquare(); Float_t ndof = flowfunc->GetNDF(); Float_t beta = flowfunc->GetParameter(6); Float_t beta_err = flowfunc->GetParError(6); Float_t prof = flowfunc->GetParameter(8); Float_t prof_err = flowfunc->GetParError(8); TLatex l; Char_t fittext[50]; l.SetNDC(); l.SetTextColor(2); sprintf(fittext, "#beta_{s} = %3.3f #pm %2.3f", beta, beta_err); l.DrawLatex(0.4, 0.85, fittext); sprintf(fittext, "Temp = %3.3f #pm %2.3f", T, T_err); l.DrawLatex(0.4, 0.8, fittext); sprintf(fittext, "#alpha = %3.3f #pm %2.3f", prof, prof_err); l.DrawLatex(0.4, 0.75, fittext); sprintf(fittext, "#chi^{2}/NDF = %3.1f / %d", chi2, ndof); l.DrawLatex(0.4, 0.70, fittext); pipproj->Write(); kpproj->Write(); proproj->Write(); pimproj->Write(); kmproj->Write(); pbproj->Write(); multi->Write(); FindCanvas("c3",500,500); c3->Clear(); c3->SetFrameFillColor(0); TH2F* hdummy = new TH2F("dummy","Simultaneous minuit", 150,0.1,0.9,150,0.05,0.25); hdummy->Draw(); gMinuit->SetErrorDef(1); TGraph* g = (TGraph*)gMinuit->Contour(30,6,7); g->SetName("Error"); g->Draw(); chi2depend->Write(); } //______________________________________________________________________ void FindCanvas(Char_t* canvasName, Int_t xwidth = 600, Int_t ywidth = 800) { TCanvas *c1 = gROOT->GetListOfCanvases()->FindObject(canvasName); if(!c1) c1 = new TCanvas(canvasName, canvasName, xwidth, ywidth); else c1->SetWindowSize(xwidth, ywidth); }