packages/trackbase/ClusterErrorPara.cc

0001 #include "ClusterErrorPara.h"
0002
0003 #include "TrkrCluster.h"
0004
0005 #include <TF1.h>
0006
0007 #include <algorithm>
0008 #include <cmath>
0009 #include <iostream>
0010 #include <string>
0011
0012 namespace
0013 {
0014
0015   //! convenience square method
0016   template <class T>
0017   constexpr T square(const T& x)
0018   {
0019     return x * x;
0020   }
0021 }  // namespace
0022
0023 ClusterErrorPara::ClusterErrorPara()
0024 {
0025   f0 = new TF1("f0", "pol1", 0, 10);
0026   f0->SetParameter(0, 0.0163943);
0027   f0->SetParameter(1, 0.0192931);
0028
0029   f1 = new TF1("f1", "pol2", 0, 10);
0030   f1->SetParameter(0, 0.0119384);
0031   f1->SetParameter(1, 0.0253197);
0032   f1->SetParameter(2, 0.0404213);
0033
0034   f2 = new TF1("f2", "pol2", 0, 10);
0035   f2->SetParameter(0, 0.0107316);
0036   f2->SetParameter(1, 0.0294968);
0037   f2->SetParameter(2, 0.0414098);
0038   // f2->SetParameter(3,9.75877);
0039
0040   fz0 = new TF1("fz0", "pol2", -2, 2);
0041   fz0->SetParameter(0, 0.0520278);
0042   fz0->SetParameter(1, -0.00578699);
0043   fz0->SetParameter(2, 0.0156972);
0044
0045   fz1 = new TF1("fz1", "pol4", -2, 2);
0046   fz1->SetParameter(0, 0.0383233);
0047   fz1->SetParameter(1, -0.00577128);
0048   fz1->SetParameter(2, 0.0770914);
0049   fz1->SetParameter(3, -0.0818139);
0050   fz1->SetParameter(4, 0.050305);
0051
0052   fz2 = new TF1("fz2", "pol2", -2, 2);
0053   fz2->SetParameter(0, 0.0371611);
0054   fz2->SetParameter(1, -0.000694558);
0055   fz2->SetParameter(2, 0.0437917);
0056
0057   fmm_55_2 = new TF1("fmm_55_2", "pol2", -2, 2);
0058   fmm_55_2->SetParameter(0, 0.0430592);
0059   fmm_55_2->SetParameter(1, -0.000177174);
0060   fmm_55_2->SetParameter(2, 0.0914288);
0061
0062   fmm_56_2 = new TF1("fmm_56_2", "pol2", -2, 2);
0063   fmm_56_2->SetParameter(0, 0.00363897);
0064   fmm_56_2->SetParameter(1, 0.0109713);
0065   fmm_56_2->SetParameter(2, 0.032354);
0066
0067   fmm_3 = new TF1("fmm_3", "pol2", -2, 2);
0068   fmm_3->SetParameter(0, 0.00305396);
0069   fmm_3->SetParameter(1, 0.00505814);
0070   fmm_3->SetParameter(2, 0.0395137);
0071
0072   fadcz0 = new TF1("fadcz0", "pol5", 0, 20000);
0073   fadcz0->SetParameter(0, 2.08854);
0074   fadcz0->SetParameter(1, -0.0536847);
0075   fadcz0->SetParameter(2, 0.000989393);
0076   fadcz0->SetParameter(3, -9.54492e-06);
0077   fadcz0->SetParameter(4, 4.42178e-08);
0078   fadcz0->SetParameter(5, -7.79669e-11);
0079
0080   fadcz1 = new TF1("fadcz1", "pol5", 0, 20000);
0081   fadcz1->SetParameter(0, 2.35278);
0082   fadcz1->SetParameter(1, -0.0535903);
0083   fadcz1->SetParameter(2, 0.00088052);
0084   fadcz1->SetParameter(3, -7.75203e-06);
0085   fadcz1->SetParameter(4, 3.35361e-08);
0086   fadcz1->SetParameter(5, -5.61371e-11);
0087
0088   fadcz2 = new TF1("fadcz2", "pol5", 0, 20000);
0089   fadcz2->SetParameter(0, 2.53191);
0090   fadcz2->SetParameter(1, -0.062285);
0091   fadcz2->SetParameter(2, 0.00103893);
0092   fadcz2->SetParameter(3, -9.18354e-06);
0093   fadcz2->SetParameter(4, 3.9802e-08);
0094   fadcz2->SetParameter(5, -6.67137e-11);
0095
0096   fadcz0fine = new TF1("fadcz0fine", "[0]+([1]/pow(x-[2],2))", 0, 20000);
0097   fadcz0fine->SetParameter(0, 9.63983e-01);
0098   fadcz0fine->SetParameter(1, 2.68585e+01);
0099   fadcz0fine->SetParameter(2, -4.78664e+00);
0100
0101   fadcz1fine = new TF1("fadcz1fine", "[0]+([1]/pow(x-[2],2))", 0, 20000);
0102   fadcz1fine->SetParameter(0, 9.85546e-01);
0103   fadcz1fine->SetParameter(1, 1.12622e+02);
0104   fadcz1fine->SetParameter(2, -1.26552e+01);
0105
0106   fadcz2fine = new TF1("fadcz2fine", "[0]+([1]/pow(x-[2],2))", 0, 20000);
0107   fadcz2fine->SetParameter(0, 9.71125e-01);
0108   fadcz2fine->SetParameter(1, 6.67244e+01);
0109   fadcz2fine->SetParameter(2, -3.55034e+00);
0110
0111   fadcphi0 = new TF1("fadcphi0", "pol4", 0, 20000);
0112   fadcphi0->SetParameter(0, 1.79273);
0113   fadcphi0->SetParameter(1, -0.0306044);
0114   fadcphi0->SetParameter(2, 0.000355984);
0115   fadcphi0->SetParameter(3, -2.09e-06);
0116   fadcphi0->SetParameter(4, 4.26161e-09);
0117   //  fadcphi0->SetParameter(5,-4.22758e-11);
0118
0119   fadcphi0fine = new TF1("fadcphi0fine", "pol2", 0, 20000);
0120   fadcphi0fine->SetParameter(0, 1.02625);
0121   fadcphi0fine->SetParameter(1, -0.00167294);
0122   fadcphi0fine->SetParameter(2, 2.2912e-5);
0123
0124   fadcphi1 = new TF1("fadcphi1", "pol4", 0, 20000);
0125   fadcphi1->SetParameter(0, 2.12873);
0126   fadcphi1->SetParameter(1, -0.0369604);
0127   fadcphi1->SetParameter(2, 0.00042828);
0128   fadcphi1->SetParameter(3, -2.3665e-06);
0129   fadcphi1->SetParameter(4, 4.87683e-09);
0130
0131   fadcphi1fine = new TF1("fadcphi1fine", "pol4", 0, 20000);
0132   fadcphi1fine->SetParameter(0, 1.11749);
0133   fadcphi1fine->SetParameter(1, -0.00354277);
0134   fadcphi1fine->SetParameter(2, 5.60236e-05);
0135   fadcphi1fine->SetParameter(3, -4.46412e-07);
0136   fadcphi1fine->SetParameter(4, 1.22689e-09);
0137
0138   fadcphi2 = new TF1("fadcphi2", "pol5", 0, 20000);
0139   fadcphi2->SetParameter(0, 2.29);
0140   fadcphi2->SetParameter(1, -0.0474362);
0141   fadcphi2->SetParameter(2, 0.000717789);
0142   fadcphi2->SetParameter(3, -6.00737e-06);
0143   fadcphi2->SetParameter(4, 2.52007e-08);
0144   fadcphi2->SetParameter(5, -4.14747e-11);
0145
0146   fadcphi2fine1 = new TF1("fadcphi2fine1", "pol4", 0, 20000);
0147   fadcphi2fine1->SetParameter(0, 1.39404);
0148   fadcphi2fine1->SetParameter(1, -0.0202245);
0149   fadcphi2fine1->SetParameter(2, 0.000394666);
0150   fadcphi2fine1->SetParameter(3, -3.37831e-06);
0151   fadcphi2fine1->SetParameter(4, 1.05017e-08);
0152
0153   fadcphi2fine2 = new TF1("fadcphi2fine2", "pol1", 0, 20000);
0154   fadcphi2fine2->SetParameter(0, 0.997);
0155   fadcphi2fine2->SetParameter(1, 0.00047);
0156
0157   f0fine = new TF1("f0fine", "pol2", 0, 20000);
0158   f0fine->SetParameter(0, 0.98611);
0159   f0fine->SetParameter(1, -0.169505);
0160   f0fine->SetParameter(2, 1.12907);
0161
0162   f1fine = new TF1("f1fine", "pol3", 0, 20000);
0163   f1fine->SetParameter(0, 0.968625);
0164   f1fine->SetParameter(1, -0.38894);
0165   f1fine->SetParameter(2, 3.36493);
0166   f1fine->SetParameter(3, -6.72275);
0167   /*
0168   f2fine = new TF1("f2fine","pol4",0,20000);
0169   f2fine->SetParameter(0,1.23748);
0170   f2fine->SetParameter(1,-2.56956);
0171   f2fine->SetParameter(2,15.8147);
0172   f2fine->SetParameter(3,-42.4668);
0173   f2fine->SetParameter(4,43.6083);
0174   */
0175   f2fine = new TF1("f2fine", "pol5", 0, 20000);
0176   f2fine->SetLineColor(kBlue);
0177   f2fine->SetParameter(0, 1.14119);
0178   f2fine->SetParameter(1, -2.81483);
0179   f2fine->SetParameter(2, 19.1877);
0180   f2fine->SetParameter(3, -57.214);
0181   f2fine->SetParameter(4, 72.2359);
0182   f2fine->SetParameter(5, -20.3802);
0183
0184   fz0fine = new TF1("fz0fine", "pol2", 0, 20000);
0185   fz0fine->SetParameter(0, 0.96933);
0186   fz0fine->SetParameter(1, -0.0458534);
0187   fz0fine->SetParameter(2, 0.231419);
0188
0189   fz1fine = new TF1("fz1fine", "pol3", 0, 20000);
0190   fz1fine->SetParameter(0, 0.886262);
0191   fz1fine->SetParameter(1, -0.0818167);
0192   fz1fine->SetParameter(2, 0.805824);
0193   fz1fine->SetParameter(3, -0.425423);
0194
0195   fz2fine = new TF1("fz2fine", "pol5", 0, 20000);
0196   fz2fine->SetLineColor(kBlue);
0197   fz2fine->SetParameter(0, 0.880153);
0198   fz2fine->SetParameter(1, 0.552461);
0199   fz2fine->SetParameter(2, -2.57007);
0200   fz2fine->SetParameter(3, 7.509);
0201   fz2fine->SetParameter(4, -9.23698);
0202   fz2fine->SetParameter(5, 4.23039);
0203
0204   static const double invsqrt12 = 1. / std::sqrt(12);
0205
0206   pitcherr_phi_mvtx = 0.002688 * invsqrt12;
0207   pitcherr_phi_intt = 0.0078 * invsqrt12;
0208   pitcherr_phi_mm1 = 0.1 * invsqrt12;
0209   pitcherr_phi_mm2 = 31.6 * invsqrt12;
0210   pitcherr_z_mvtx = 0.002924 * invsqrt12;
0211   pitcherr_z_intt = 1.6 * invsqrt12;
0212   pitcherr_z_mm1 = 54.2 * invsqrt12;
0213   pitcherr_z_mm2 = 0.2 * invsqrt12;
0214   pull_fine_phi[0] = 1.055549;
0215   pull_fine_phi[1] = 1.049109;
0216   pull_fine_phi[2] = 1.043427;
0217   pull_fine_phi[3] = 1.200730;
0218   pull_fine_phi[4] = 1.157397;
0219   pull_fine_phi[5] = 1.357292;
0220   pull_fine_phi[6] = 1.367113;
0221   pull_fine_phi[7] = 0.999609;
0222   pull_fine_phi[8] = 1.020689;
0223   pull_fine_phi[9] = 1.032753;
0224   pull_fine_phi[10] = 1.018574;
0225   pull_fine_phi[11] = 1.035928;
0226   pull_fine_phi[12] = 1.024522;
0227   pull_fine_phi[13] = 1.035439;
0228   pull_fine_phi[14] = 1.020409;
0229   pull_fine_phi[15] = 1.035957;
0230   pull_fine_phi[16] = 1.033798;
0231   pull_fine_phi[17] = 1.032753;
0232   pull_fine_phi[18] = 1.030573;
0233   pull_fine_phi[19] = 1.035131;
0234   pull_fine_phi[20] = 1.031460;
0235   pull_fine_phi[21] = 1.039708;
0236   pull_fine_phi[22] = 1.015784;
0237   pull_fine_phi[23] = 1.013265;
0238   pull_fine_phi[24] = 0.997548;
0239   pull_fine_phi[25] = 0.990299;
0240   pull_fine_phi[26] = 0.999642;
0241   pull_fine_phi[27] = 1.005518;
0242   pull_fine_phi[28] = 1.012272;
0243   pull_fine_phi[29] = 1.016701;
0244   pull_fine_phi[30] = 1.013685;
0245   pull_fine_phi[31] = 1.025059;
0246   pull_fine_phi[32] = 1.030672;
0247   pull_fine_phi[33] = 1.031959;
0248   pull_fine_phi[34] = 1.040878;
0249   pull_fine_phi[35] = 1.045917;
0250   pull_fine_phi[36] = 1.052541;
0251   pull_fine_phi[37] = 1.056798;
0252   pull_fine_phi[38] = 1.000142;
0253   pull_fine_phi[39] = 1.028008;
0254   pull_fine_phi[40] = 0.980509;
0255   pull_fine_phi[41] = 0.981643;
0256   pull_fine_phi[42] = 0.988486;
0257   pull_fine_phi[43] = 0.987750;
0258   pull_fine_phi[44] = 0.989536;
0259   pull_fine_phi[45] = 0.992817;
0260   pull_fine_phi[46] = 0.993260;
0261   pull_fine_phi[47] = 0.994378;
0262   pull_fine_phi[48] = 0.988871;
0263   pull_fine_phi[49] = 0.985053;
0264   pull_fine_phi[50] = 0.985631;
0265   pull_fine_phi[51] = 0.987169;
0266   pull_fine_phi[52] = 0.992417;
0267   pull_fine_phi[53] = 0.996130;
0268   pull_fine_phi[54] = 0.996966;
0269   pull_fine_phi[55] = 0.943431;
0270   pull_fine_phi[56] = 0.000000;
0271   pull_fine_phi[57] = 0.000000;
0272   pull_fine_phi[58] = 0.000000;
0273   pull_fine_phi[59] = 0.000000;
0274
0275   pull_fine_phi[3] *= 1.007551;
0276   pull_fine_phi[4] *= 1.006760;
0277   pull_fine_phi[5] *= 1.026019;
0278   pull_fine_phi[6] *= 1.030869;
0279   pull_fine_phi[55] *= 0.988674;
0280
0281   pull_fine_z[0] = 1.117666;
0282   pull_fine_z[1] = 1.119458;
0283   pull_fine_z[2] = 1.123506;
0284   pull_fine_z[3] = 1.971984;
0285   pull_fine_z[4] = 0.643933;
0286   pull_fine_z[5] = 0.638478;
0287   pull_fine_z[6] = 2.039448;
0288   pull_fine_z[7] = 1.047709;
0289   pull_fine_z[8] = 1.021305;
0290   pull_fine_z[9] = 1.014697;
0291   pull_fine_z[10] = 1.011649;
0292   pull_fine_z[11] = 1.014099;
0293   pull_fine_z[12] = 1.018134;
0294   pull_fine_z[13] = 1.004908;
0295   pull_fine_z[14] = 1.016988;
0296   pull_fine_z[15] = 1.007906;
0297   pull_fine_z[16] = 1.006559;
0298   pull_fine_z[17] = 1.006695;
0299   pull_fine_z[18] = 1.010511;
0300   pull_fine_z[19] = 1.008526;
0301   pull_fine_z[20] = 1.012481;
0302   pull_fine_z[21] = 1.005427;
0303   pull_fine_z[22] = 1.008053;
0304   pull_fine_z[23] = 0.984082;
0305   pull_fine_z[24] = 1.016605;
0306   pull_fine_z[25] = 1.020224;
0307   pull_fine_z[26] = 1.014571;
0308   pull_fine_z[27] = 1.017648;
0309   pull_fine_z[28] = 1.021230;
0310   pull_fine_z[29] = 1.022464;
0311   pull_fine_z[30] = 1.026075;
0312   pull_fine_z[31] = 1.028448;
0313   pull_fine_z[32] = 1.025604;
0314   pull_fine_z[33] = 1.025361;
0315   pull_fine_z[34] = 1.031499;
0316   pull_fine_z[35] = 1.036946;
0317   pull_fine_z[36] = 1.037130;
0318   pull_fine_z[37] = 1.036079;
0319   pull_fine_z[38] = 0.966569;
0320   pull_fine_z[39] = 3.431897;
0321   pull_fine_z[40] = 1.000976;
0322   pull_fine_z[41] = 1.000437;
0323   pull_fine_z[42] = 0.999851;
0324   pull_fine_z[43] = 1.003534;
0325   pull_fine_z[44] = 1.002914;
0326   pull_fine_z[45] = 1.003099;
0327   pull_fine_z[46] = 1.008661;
0328   pull_fine_z[47] = 1.015236;
0329   pull_fine_z[48] = 1.009287;
0330   pull_fine_z[49] = 1.011966;
0331   pull_fine_z[50] = 1.005105;
0332   pull_fine_z[51] = 1.014257;
0333   pull_fine_z[52] = 1.020858;
0334   pull_fine_z[53] = 1.018221;
0335   pull_fine_z[54] = 1.012372;
0336   pull_fine_z[55] = 1.007561;
0337   pull_fine_z[56] = 0.000000;
0338   pull_fine_z[57] = 0.000000;
0339   pull_fine_z[58] = 0.000000;
0340   pull_fine_z[59] = 0.000000;
0341
0342   pull_fine_z[3] *= 0.691672;
0343   pull_fine_z[4] *= 1.203607;
0344   pull_fine_z[5] *= 1.360947;
0345   pull_fine_z[6] *= 0.583844;
0346   pull_fine_z[39] *= 0.928246;
0347   pull_fine_z[3] *= 0.498090;
0348   pull_fine_z[4] *= 1.090848;
0349   pull_fine_z[5] *= 0.967529;
0350   pull_fine_z[6] *= 0.820550;
0351   pull_fine_z[55] *= 1.548348;
0352   pull_fine_phi[0] *= 0.976810;
0353   pull_fine_phi[1] *= 0.979091;
0354   pull_fine_phi[2] *= 0.985423;
0355   pull_fine_phi[3] *= 0.848807;
0356   pull_fine_phi[4] *= 0.879689;
0357   pull_fine_phi[5] *= 0.724431;
0358   pull_fine_phi[6] *= 0.717564;
0359   pull_fine_phi[7] *= 1.087427;
0360   pull_fine_phi[8] *= 1.025145;
0361   pull_fine_phi[9] *= 1.020610;
0362   pull_fine_phi[10] *= 1.026286;
0363   pull_fine_phi[11] *= 1.019533;
0364   pull_fine_phi[12] *= 1.022289;
0365   pull_fine_phi[13] *= 1.020049;
0366   pull_fine_phi[14] *= 1.020093;
0367   pull_fine_phi[15] *= 1.017107;
0368   pull_fine_phi[16] *= 1.017730;
0369   pull_fine_phi[17] *= 1.014773;
0370   pull_fine_phi[18] *= 1.016468;
0371   pull_fine_phi[19] *= 1.014107;
0372   pull_fine_phi[20] *= 1.015574;
0373   pull_fine_phi[21] *= 1.015261;
0374   pull_fine_phi[22] *= 1.055006;
0375   pull_fine_phi[23] *= 1.081166;
0376   pull_fine_phi[24] *= 1.037136;
0377   pull_fine_phi[25] *= 1.033333;
0378   pull_fine_phi[26] *= 1.032861;
0379   pull_fine_phi[27] *= 1.032109;
0380   pull_fine_phi[28] *= 1.035788;
0381   pull_fine_phi[29] *= 1.034689;
0382   pull_fine_phi[30] *= 1.034438;
0383   pull_fine_phi[31] *= 1.036618;
0384   pull_fine_phi[32] *= 1.035785;
0385   pull_fine_phi[33] *= 1.039290;
0386   pull_fine_phi[34] *= 1.036625;
0387   pull_fine_phi[35] *= 1.038621;
0388   pull_fine_phi[36] *= 1.038185;
0389   pull_fine_phi[37] *= 1.036850;
0390   pull_fine_phi[38] *= 1.059049;
0391   pull_fine_phi[39] *= 1.122510;
0392   pull_fine_phi[40] *= 1.045074;
0393   pull_fine_phi[41] *= 1.041234;
0394   pull_fine_phi[42] *= 1.041916;
0395   pull_fine_phi[43] *= 1.038968;
0396   pull_fine_phi[44] *= 1.037942;
0397   pull_fine_phi[45] *= 1.037845;
0398   pull_fine_phi[46] *= 1.035315;
0399   pull_fine_phi[47] *= 1.036548;
0400   pull_fine_phi[48] *= 1.032359;
0401   pull_fine_phi[49] *= 1.030394;
0402   pull_fine_phi[50] *= 1.031460;
0403   pull_fine_phi[51] *= 1.032054;
0404   pull_fine_phi[52] *= 1.031856;
0405   pull_fine_phi[53] *= 1.031389;
0406   pull_fine_phi[54] *= 1.030922;
0407   pull_fine_phi[55] *= 1.010915;
0408   pull_fine_phi[56] *= 1.271132;
0409   pull_fine_phi[57] *= 0.000000;
0410   pull_fine_z[0] *= 0.903223;
0411   pull_fine_z[1] *= 0.906998;
0412   pull_fine_z[2] *= 0.909652;
0413   pull_fine_z[3] *= 1.379617;
0414   pull_fine_z[4] *= 0.877200;
0415   pull_fine_z[5] *= 0.944639;
0416   pull_fine_z[6] *= 1.130620;
0417   pull_fine_z[7] *= 1.074286;
0418   pull_fine_z[8] *= 1.031207;
0419   pull_fine_z[9] *= 1.026923;
0420   pull_fine_z[10] *= 1.029683;
0421   pull_fine_z[11] *= 1.023258;
0422   pull_fine_z[12] *= 1.024277;
0423   pull_fine_z[13] *= 1.022564;
0424   pull_fine_z[14] *= 1.023237;
0425   pull_fine_z[15] *= 1.020460;
0426   pull_fine_z[16] *= 1.022844;
0427   pull_fine_z[17] *= 1.022628;
0428   pull_fine_z[18] *= 1.020984;
0429   pull_fine_z[19] *= 1.018908;
0430   pull_fine_z[20] *= 1.019514;
0431   pull_fine_z[21] *= 1.020316;
0432   pull_fine_z[22] *= 1.044147;
0433   pull_fine_z[23] *= 1.054320;
0434   pull_fine_z[24] *= 1.031116;
0435   pull_fine_z[25] *= 1.029622;
0436   pull_fine_z[26] *= 1.026101;
0437   pull_fine_z[27] *= 1.025649;
0438   pull_fine_z[28] *= 1.027153;
0439   pull_fine_z[29] *= 1.025389;
0440   pull_fine_z[30] *= 1.024853;
0441   pull_fine_z[31] *= 1.026242;
0442   pull_fine_z[32] *= 1.027198;
0443   pull_fine_z[33] *= 1.027609;
0444   pull_fine_z[34] *= 1.024212;
0445   pull_fine_z[35] *= 1.026990;
0446   pull_fine_z[36] *= 1.026987;
0447   pull_fine_z[37] *= 1.025806;
0448   pull_fine_z[38] *= 1.036276;
0449   pull_fine_z[39] *= 1.029688;
0450   pull_fine_z[40] *= 1.028911;
0451   pull_fine_z[41] *= 1.026570;
0452   pull_fine_z[42] *= 1.023386;
0453   pull_fine_z[43] *= 1.025188;
0454   pull_fine_z[44] *= 1.024090;
0455   pull_fine_z[45] *= 1.022645;
0456   pull_fine_z[46] *= 1.023954;
0457   pull_fine_z[47] *= 1.022967;
0458   pull_fine_z[48] *= 1.021187;
0459   pull_fine_z[49] *= 1.022650;
0460   pull_fine_z[50] *= 1.021918;
0461   pull_fine_z[51] *= 1.021044;
0462   pull_fine_z[52] *= 1.021689;
0463   pull_fine_z[53] *= 1.020743;
0464   pull_fine_z[54] *= 1.022534;
0465   pull_fine_z[55] *= 0.784192;
0466   pull_fine_z[56] *= 0.767927;
0467   pull_fine_z[57] *= 0.000000;
0468   pull_fine_z[55] *= 0.876383;
0469   pull_fine_z[56] *= 0.766922;
0470   pull_fine_z[3] *= 2.000261;
0471   pull_fine_z[4] *= 1.127752;
0472   pull_fine_z[5] *= 0.804010;
0473   pull_fine_z[6] *= 0.567351;
0474 }
0475
0476 //_________________________________________________________________________________
0477 ClusterErrorPara::error_t ClusterErrorPara::get_clusterv5_modified_error(TrkrCluster* cluster, double /*unused*/, TrkrDefs::cluskey key)
0478 {
0479   int layer = TrkrDefs::getLayer(key);
0480
0481   double phierror = cluster->getRPhiError();
0482   double zerror = cluster->getZError();
0483   if (TrkrDefs::getTrkrId(key) == TrkrDefs::tpcId)
0484   {
0485     if (layer == 7 || layer == 22 || layer == 23 || layer == 38 || layer == 39)
0486     {
0487       phierror *= 4;
0488       zerror *= 4;
0489     }
0490     if (cluster->getEdge() >= 3)
0491     {
0492       phierror *= 4;
0493     }
0494     if (cluster->getOverlap() >= 2)
0495     {
0496       phierror *= 2;
0497     }
0498     if (cluster->getPhiSize() == 1)
0499     {
0500       phierror *= 10;
0501     }
0502     if (cluster->getPhiSize() >= 5)
0503     {
0504       phierror *= 10;
0505     }
0506
0507     phierror = std::min(phierror, 0.1);
0508     if (phierror < 0.0005)
0509     {
0510       phierror = 0.1;
0511     }
0512   }
0513   return std::make_pair(square(phierror), square(zerror));
0514 }
0515
0516 //_________________________________________________________________________________
0517 ClusterErrorPara::error_t ClusterErrorPara::get_cluster_error(TrkrCluster* cluster, double cluster_r, TrkrDefs::cluskey key, float qOverR, float slope)
0518 {
0519   float r = cluster_r;
0520   float R = std::abs(1.0 / qOverR);
0521   double alpha = (r * r) / (2 * r * R);
0522   double beta = std::abs(std::atan(slope));
0523   return get_cluster_error(cluster, key, alpha, beta);
0524 }
0525
0526 double ClusterErrorPara::tpc_phi_error(int layer, double alpha, TrkrCluster* cluster)
0527 {
0528   double phierror = 0;
0529
0530   int sector = -1;
0531   if (layer >= 7 && layer < 23)
0532   {
0533     sector = 0;
0534   }
0535   else if (layer >= 23 && layer < 39)
0536   {
0537     sector = 1;
0538   }
0539   else if (layer >= 39 && layer < 55)
0540   {
0541     sector = 2;
0542   }
0543   phierror = 0.0005;
0544
0545   if (sector != -1)
0546   {
0547     phierror = 0.0005;
0548   }
0549
0550   if (sector == 0)
0551   {
0552     // phierror = 0.019886;
0553     phierror = f0->Eval(alpha);
0554     if (cluster->getMaxAdc() != 0)
0555     {
0556       if (cluster->getMaxAdc() > 150)
0557       {
0558         phierror *= 0.54 * 0.9;
0559       }
0560       else
0561       {
0562         phierror *= fadcphi0->Eval(cluster->getMaxAdc());
0563         phierror *= fadcphi0fine->Eval(cluster->getMaxAdc());
0564       }
0565     }
0566     if (cluster->getEdge() >= 5)
0567     {
0568       phierror *= 2;
0569     }
0570
0571     if (cluster->getPhiSize() == 1)
0572     {
0573       phierror *= 1.5;
0574     }
0575     if (cluster->getPhiSize() == 4)
0576     {
0577       phierror *= 1.5;
0578     }
0579     if (cluster->getPhiSize() >= 5)
0580     {
0581       phierror *= 2.5;
0582     }
0583
0584     phierror *= f0fine->Eval(alpha);
0585   }
0586
0587   if (sector == 1)
0588   {
0589     // phierror = 0.018604;
0590     phierror = f1->Eval(alpha);
0591     if (cluster->getMaxAdc() != 0)
0592     {
0593       if (cluster->getMaxAdc() > 160)
0594       {
0595         phierror *= 0.6;
0596       }
0597       else
0598       {
0599         phierror *= fadcphi1->Eval(cluster->getMaxAdc());
0600       }
0601       if (cluster->getEdge() >= 5)
0602       {
0603         phierror *= 2;
0604       }
0605       if (cluster->getMaxAdc() > 140)
0606       {
0607         phierror *= 0.95;
0608       }
0609       else
0610       {
0611         phierror *= fadcphi1fine->Eval(cluster->getMaxAdc());
0612       }
0613     }
0614     phierror *= 0.975;
0615     if (cluster->getPhiSize() == 1)
0616     {
0617       phierror *= 4;
0618     }
0619     if (cluster->getPhiSize() == 4)
0620     {
0621       phierror *= 1.2;
0622     }
0623     if (cluster->getPhiSize() >= 5)
0624     {
0625       phierror *= 2;
0626     }
0627
0628     phierror *= f1fine->Eval(alpha);
0629   }
0630
0631   if (sector == 2)
0632   {
0633     // phierror = 0.02043;
0634
0635     phierror = f2->Eval(alpha);
0636     if (cluster->getMaxAdc())
0637     {
0638       if (cluster->getMaxAdc() > 170)
0639       {
0640         phierror *= 0.6 * 0.95;
0641       }
0642       else
0643       {
0644         phierror *= fadcphi2->Eval(cluster->getMaxAdc());
0645         if (cluster->getMaxAdc() < 100)
0646         {
0647           phierror *= fadcphi2fine1->Eval(cluster->getMaxAdc());
0648         }
0649       }
0650     }
0651     if (cluster->getEdge() >= 5)
0652     {
0653       phierror *= 2;
0654     }
0655
0656     if (cluster->getPhiSize() == 1)
0657     {
0658       phierror *= 10;
0659     }
0660     if (cluster->getPhiSize() >= 6)
0661     {
0662       phierror *= 10;
0663     }
0664
0665     phierror *= f2fine->Eval(alpha);
0666   }
0667   if (layer == 7)
0668   {
0669     phierror *= (3 * 0.72);
0670   }
0671   if (layer == 22 || layer == 23)
0672   {
0673     phierror *= (3 * 0.8);
0674   }
0675   if (layer == 38)
0676   {
0677     phierror *= (3 * 0.9);
0678   }
0679   if (layer == 39)
0680   {
0681     phierror *= (3 * 1.05);
0682   }
0683
0684   phierror = std::min(phierror, 0.1);
0685   if (phierror < 0.0005)
0686   {
0687     phierror = 0.1;
0688   }
0689
0690   return phierror;
0691 }
0692 double ClusterErrorPara::tpc_z_error(int layer, double beta, TrkrCluster* cluster)
0693 {
0694   double zerror = 0.05;
0695
0696   int sector = -1;
0697   if (layer >= 7 && layer < 23)
0698   {
0699     sector = 0;
0700   }
0701   else if (layer >= 23 && layer < 39)
0702   {
0703     sector = 1;
0704   }
0705   else if (layer >= 39 && layer < 55)
0706   {
0707     sector = 2;
0708   }
0709   if (sector != -1)
0710   {
0711     zerror = 0.05;
0712   }
0713
0714   if (sector == 0)
0715   {
0716     zerror = fz0->Eval(beta);
0717     if (cluster->getMaxAdc() > 180)
0718     {
0719       zerror *= 0.5;
0720     }
0721     else
0722     {
0723       zerror *= fadcz0->Eval(cluster->getMaxAdc());
0724     }
0725     zerror *= fz0fine->Eval(beta);
0726     zerror *= fadcz0fine->Eval(cluster->getMaxAdc());
0727   }
0728
0729   if (sector == 1)
0730   {
0731     zerror = fz1->Eval(beta);
0732     if (cluster->getMaxAdc() > 180)
0733     {
0734       zerror *= 0.6;
0735     }
0736     else
0737     {
0738       zerror *= fadcz1->Eval(cluster->getMaxAdc());
0739     }
0740     zerror *= fz1fine->Eval(beta);
0741     zerror *= fadcz1fine->Eval(cluster->getMaxAdc());
0742     zerror *= 0.98;
0743     //    zerror *= 1.05913
0744   }
0745   if (sector == 2)
0746   {
0747     zerror = fz2->Eval(beta);
0748     if (cluster->getMaxAdc() > 170)
0749     {
0750       zerror *= 0.6;
0751     }
0752     else
0753     {
0754       zerror *= fadcz2->Eval(cluster->getMaxAdc());
0755     }
0756     zerror *= fz2fine->Eval(beta);
0757     zerror *= fadcz2fine->Eval(cluster->getMaxAdc());
0758     // zerrror *= 1.15575;
0759   }
0760   if (layer == 7)
0761   {
0762     zerror *= (3.5 * 1.13);
0763   }
0764   if (layer == 22)
0765   {
0766     zerror *= (3.5 * 0.9);
0767   }
0768   if (layer == 23)
0769   {
0770     zerror *= (3.5 * 0.95);
0771   }
0772   if (layer == 38)
0773   {
0774     zerror *= (3.5 * 0.85);
0775   }
0776
0777   zerror = std::min(zerror, 0.2);
0778   if (zerror < 0.0002)
0779   {
0780     zerror = 0.2;
0781   }
0782
0783   return zerror;
0784 }
0785
0786 double ClusterErrorPara::mm_phi_error(int layer, double alpha, TrkrCluster* cluster)
0787 {
0788   double phierror = 0;
0789   if (layer == 55)
0790   {
0791     if (cluster->getPhiSize() == 1)
0792     {
0793       phierror = pitcherr_phi_mm1;
0794     }
0795     else if (cluster->getPhiSize() == 2)
0796     {
0797       phierror = fmm_55_2->Eval(alpha);
0798     }
0799     else if (cluster->getPhiSize() >= 3)
0800     {
0801       phierror = fmm_3->Eval(alpha);
0802     }
0803     phierror *= scale_mm_0;
0804   }
0805   else if (layer == 56)
0806   {
0807     phierror = pitcherr_phi_mm2;
0808   }
0809   return phierror;
0810 }
0811
0812 double ClusterErrorPara::mm_z_error(int layer, double beta, TrkrCluster* cluster)
0813 {
0814   double zerror = 0;
0815   if (layer == 55)
0816   {
0817     zerror = pitcherr_z_mm1;
0818   }
0819   else if (layer == 56)
0820   {
0821     if (cluster->getZSize() == 1)
0822     {
0823       zerror = pitcherr_z_mm2;
0824     }
0825     else if (cluster->getZSize() == 2)
0826     {
0827       zerror = fmm_56_2->Eval(beta);
0828     }
0829     else if (cluster->getZSize() >= 3)
0830     {
0831       zerror = fmm_3->Eval(beta);
0832     }
0833     zerror *= scale_mm_1;
0834   }
0835   return zerror;
0836 }
0837
0838 double ClusterErrorPara::mvtx_phi_error(TrkrCluster* cluster) const
0839 {
0840   double phierror = 0;
0841   static constexpr std::array<double, 7> scalefactors_mvtx_phi = {{0.36, 0.6, 0.37, 0.49, 0.4, 0.37, 0.33}};
0842   phierror = pitcherr_phi_mvtx;  // 0.00077595876
0843   //  std::cout << " phistart: " << phierror  << " phisize: " << cluster->getPhiSize() << "zsize: " << cluster->getZSize() << std::endl;
0844   if (cluster->getPhiSize() == 1 && cluster->getZSize() == 1)
0845   {
0846     phierror = pitcherr_phi_mvtx * scalefactors_mvtx_phi[0];
0847   }
0848   else if (cluster->getPhiSize() == 2 && cluster->getZSize() == 1)
0849   {
0850     phierror = pitcherr_phi_mvtx * scalefactors_mvtx_phi[1];
0851   }
0852   else if (cluster->getPhiSize() == 1 && cluster->getZSize() == 2)
0853   {
0854     phierror = pitcherr_phi_mvtx * scalefactors_mvtx_phi[2];
0855   }
0856   else if (cluster->getPhiSize() == 2 && cluster->getZSize() == 2)
0857   {
0858     phierror = pitcherr_phi_mvtx * scalefactors_mvtx_phi[0];
0859   }
0860   else if (cluster->getPhiSize() == 2 && cluster->getZSize() == 3)
0861   {
0862     phierror = pitcherr_phi_mvtx * scalefactors_mvtx_phi[1];
0863   }
0864   else if (cluster->getPhiSize() == 3 && cluster->getZSize() == 2)
0865   {
0866     phierror = pitcherr_phi_mvtx * scalefactors_mvtx_phi[2];
0867   }
0868   else if (cluster->getPhiSize() == 3 && cluster->getZSize() == 3)
0869   {
0870     phierror = pitcherr_phi_mvtx * scalefactors_mvtx_phi[3];
0871   }
0872   else
0873   {
0874     phierror = pitcherr_phi_mvtx * cluster->getPhiSize();
0875   }
0876   //  std::cout << " phi after size: " << phierror  << std::endl;
0877   phierror *= scale_mvtx;
0878   // else zerror = pitcherr_z_mvtx*cluster->getZSize();
0879   //  std::cout << " phi: " << phierror  << std::endl;
0880   return phierror;
0881 }
0882
0883 double ClusterErrorPara::mvtx_phi_error(const TrkrCluster* cluster) const
0884 {
0885   double phierror = 0;
0886   static constexpr std::array<double, 7> scalefactors_mvtx_phi = {{0.36, 0.6, 0.37, 0.49, 0.4, 0.37, 0.33}};
0887   phierror = pitcherr_phi_mvtx;  // 0.00077595876
0888   //  std::cout << " phistart: " << phierror  << " phisize: " << cluster->getPhiSize() << "zsize: " << cluster->getZSize() << std::endl;
0889   if (cluster->getPhiSize() == 1 && cluster->getZSize() == 1)
0890   {
0891     phierror = pitcherr_phi_mvtx * scalefactors_mvtx_phi[0];
0892   }
0893   else if (cluster->getPhiSize() == 2 && cluster->getZSize() == 1)
0894   {
0895     phierror = pitcherr_phi_mvtx * scalefactors_mvtx_phi[1];
0896   }
0897   else if (cluster->getPhiSize() == 1 && cluster->getZSize() == 2)
0898   {
0899     phierror = pitcherr_phi_mvtx * scalefactors_mvtx_phi[2];
0900   }
0901   else if (cluster->getPhiSize() == 2 && cluster->getZSize() == 2)
0902   {
0903     phierror = pitcherr_phi_mvtx * scalefactors_mvtx_phi[0];
0904   }
0905   else if (cluster->getPhiSize() == 2 && cluster->getZSize() == 3)
0906   {
0907     phierror = pitcherr_phi_mvtx * scalefactors_mvtx_phi[1];
0908   }
0909   else if (cluster->getPhiSize() == 3 && cluster->getZSize() == 2)
0910   {
0911     phierror = pitcherr_phi_mvtx * scalefactors_mvtx_phi[2];
0912   }
0913   else if (cluster->getPhiSize() == 3 && cluster->getZSize() == 3)
0914   {
0915     phierror = pitcherr_phi_mvtx * scalefactors_mvtx_phi[3];
0916   }
0917   else
0918   {
0919     phierror = pitcherr_phi_mvtx * cluster->getPhiSize();
0920   }
0921   //  std::cout << " phi after size: " << phierror  << std::endl;
0922   phierror *= scale_mvtx;
0923   // else zerror = pitcherr_z_mvtx*cluster->getZSize();
0924   //  std::cout << " phi: " << phierror  << std::endl;
0925   return phierror;
0926 }
0927
0928 double ClusterErrorPara::mvtx_z_error(TrkrCluster* cluster) const
0929 {
0930   double zerror = 0;
0931
0932   zerror = pitcherr_z_mvtx;
0933   static constexpr std::array<double, 4> scalefactors_z = {{0.47, 0.48, 0.71, 0.55}};
0934   if (cluster->getZSize() == 2 && cluster->getPhiSize() == 2)
0935   {
0936     zerror = pitcherr_z_mvtx * scalefactors_z[0];
0937   }
0938   else if (cluster->getZSize() == 2 && cluster->getPhiSize() == 3)
0939   {
0940     zerror = pitcherr_z_mvtx * scalefactors_z[1];
0941   }
0942   else if (cluster->getZSize() == 3 && cluster->getPhiSize() == 2)
0943   {
0944     zerror = pitcherr_z_mvtx * scalefactors_z[2];
0945   }
0946   else if (cluster->getZSize() == 3 && cluster->getPhiSize() == 3)
0947   {
0948     zerror = pitcherr_z_mvtx * scalefactors_z[3];
0949   }
0950   zerror *= scale_mvtx_z;
0951   return zerror;
0952 }
0953 double ClusterErrorPara::mvtx_z_error(const TrkrCluster* cluster) const
0954 {
0955   double zerror = 0;
0956
0957   zerror = pitcherr_z_mvtx;
0958   static constexpr std::array<double, 4> scalefactors_z = {{0.47, 0.48, 0.71, 0.55}};
0959   if (cluster->getZSize() == 2 && cluster->getPhiSize() == 2)
0960   {
0961     zerror = pitcherr_z_mvtx * scalefactors_z[0];
0962   }
0963   else if (cluster->getZSize() == 2 && cluster->getPhiSize() == 3)
0964   {
0965     zerror = pitcherr_z_mvtx * scalefactors_z[1];
0966   }
0967   else if (cluster->getZSize() == 3 && cluster->getPhiSize() == 2)
0968   {
0969     zerror = pitcherr_z_mvtx * scalefactors_z[2];
0970   }
0971   else if (cluster->getZSize() == 3 && cluster->getPhiSize() == 3)
0972   {
0973     zerror = pitcherr_z_mvtx * scalefactors_z[3];
0974   }
0975   zerror *= scale_mvtx_z;
0976   return zerror;
0977 }
0978
0979 double ClusterErrorPara::intt_phi_error(int layer, TrkrCluster* cluster) const
0980 {
0981   double phierror = 0;
0982   static constexpr std::array<double, 3> scalefactors_intt_phi = {{0.85, 0.4, 0.33}};
0983
0984   if (cluster->getPhiSize() == 1 && layer < 5)
0985   {
0986     phierror = pitcherr_phi_intt * scalefactors_intt_phi[0];
0987   }
0988   else if (cluster->getPhiSize() == 2 && layer < 5)
0989   {
0990     phierror = pitcherr_phi_intt * scalefactors_intt_phi[1];
0991   }
0992   else if (cluster->getPhiSize() == 2 && layer > 4)
0993   {
0994     phierror = pitcherr_phi_intt * scalefactors_intt_phi[2];
0995   }
0996   else
0997   {
0998     phierror = pitcherr_phi_intt * cluster->getPhiSize();
0999   }
1000   if (layer == 3)
1001   {
1002     phierror *= scale_intt_3;
1003   }
1004   if (layer == 4)
1005   {
1006     phierror *= scale_intt_4;
1007   }
1008   if (layer == 5)
1009   {
1010     phierror *= scale_intt_5;
1011   }
1012   if (layer == 6)
1013   {
1014     phierror *= scale_intt_6;
1015   }
1016
1017   return phierror;
1018 }
1019
1020 double ClusterErrorPara::intt_z_error(TrkrCluster* cluster) const
1021 {
1022   double zerror = 0;
1023   zerror = pitcherr_z_intt * cluster->getZSize();
1024   return zerror;
1025 }
1026 double ClusterErrorPara::intt_phi_error(int layer, const TrkrCluster* cluster) const
1027 {
1028   double phierror = 0;
1029   static constexpr std::array<double, 3> scalefactors_intt_phi = {{0.85, 0.4, 0.33}};
1030
1031   if (cluster->getPhiSize() == 1 && layer < 5)
1032   {
1033     phierror = pitcherr_phi_intt * scalefactors_intt_phi[0];
1034   }
1035   else if (cluster->getPhiSize() == 2 && layer < 5)
1036   {
1037     phierror = pitcherr_phi_intt * scalefactors_intt_phi[1];
1038   }
1039   else if (cluster->getPhiSize() == 2 && layer > 4)
1040   {
1041     phierror = pitcherr_phi_intt * scalefactors_intt_phi[2];
1042   }
1043   else
1044   {
1045     phierror = pitcherr_phi_intt * cluster->getPhiSize();
1046   }
1047   if (layer == 3)
1048   {
1049     phierror *= scale_intt_3;
1050   }
1051   if (layer == 4)
1052   {
1053     phierror *= scale_intt_4;
1054   }
1055   if (layer == 5)
1056   {
1057     phierror *= scale_intt_5;
1058   }
1059   if (layer == 6)
1060   {
1061     phierror *= scale_intt_6;
1062   }
1063
1064   return phierror;
1065 }
1066
1067 double ClusterErrorPara::intt_z_error(const TrkrCluster* cluster) const
1068 {
1069   double zerror = 0;
1070   zerror = pitcherr_z_intt * cluster->getZSize();
1071   return zerror;
1072 }
1073
1074 //_________________________________________________________________________________
1075 ClusterErrorPara::error_t ClusterErrorPara::get_cluster_error(TrkrCluster* cluster, TrkrDefs::cluskey key, double alpha, double beta)
1076 {
1077   int layer = TrkrDefs::getLayer(key);
1078   double phierror = 0;
1079   double zerror = 0;
1080   switch (TrkrDefs::getTrkrId(key))
1081   {
1082   default:
1083     break;
1084
1085   case TrkrDefs::micromegasId:
1086     phierror = mm_phi_error(layer, alpha, cluster);
1087     zerror = mm_z_error(layer, beta, cluster);
1088
1089     break;
1090   case TrkrDefs::mvtxId:
1091
1092     phierror = mvtx_phi_error(cluster);
1093     zerror = mvtx_z_error(cluster);
1094     //      std::cout << "   z: " << zerror  << " l: " << layer  << std::endl;
1095     break;
1096
1097   case TrkrDefs::inttId:
1098
1099     phierror = intt_phi_error(layer, cluster);
1100     zerror = intt_z_error(cluster);
1101     break;
1102
1103   case TrkrDefs::tpcId:
1104     phierror = tpc_phi_error(layer, alpha, cluster);
1105     zerror = tpc_z_error(layer, beta, cluster);
1106     /*
1107     std::cout << " phi: " << phierror << " | " << phierror2 << " l: " << layer << " a " << alpha << " maxadc: " << cluster->getMaxAdc() << std::endl;
1108     std::cout << "   z: " << zerror  << " | " << zerror2 << " l: " << layer << " b " << beta << " maxadc: " << cluster->getMaxAdc() << " adc: " << cluster->getAdc() << std::endl;
1109     */
1110     break;
1111   }
1112   if (pull_fine_phi[layer] != 0)
1113   {
1114     phierror *= pull_fine_phi[layer];
1115   }
1116   if (pull_fine_z[layer] != 0)
1117   {
1118     zerror *= pull_fine_z[layer];
1119   }
1120
1121   if (phierror == 0)
1122   {
1123     phierror = 100;
1124   }
1125   if (zerror == 0)
1126   {
1127     zerror = 100;
1128   }
1129
1130   return std::make_pair(square(phierror), square(zerror));
1131   //  return std::make_pair(phierror,zerror);
1132 }
1133 //_________________________________________________________________________________
1134
1135 ClusterErrorPara::error_t ClusterErrorPara::get_simple_cluster_error(TrkrCluster* cluster, double cluster_r, TrkrDefs::cluskey key)
1136 {
1137   double alpha = 0.17;
1138   double beta = 0.4;
1139   if (cluster_r > 100000)
1140   {
1141     alpha = 0.17001;
1142   }
1143   int layer = TrkrDefs::getLayer(key);
1144   double phierror = 0;
1145   double zerror = 0;
1146   switch (TrkrDefs::getTrkrId(key))
1147   {
1148   default:
1149     break;
1150
1151   case TrkrDefs::micromegasId:
1152     phierror = mm_phi_error(layer, 0.27, cluster);
1153     zerror = mm_z_error(layer, 0.4, cluster);
1154
1155     break;
1156   case TrkrDefs::mvtxId:
1157
1158     phierror = mvtx_phi_error(cluster);
1159     zerror = mvtx_z_error(cluster);
1160     //      std::cout << "   z: " << zerror  << " l: " << layer  << std::endl;
1161     break;
1162
1163   case TrkrDefs::inttId:
1164
1165     phierror = intt_phi_error(layer, cluster);
1166     zerror = intt_z_error(cluster);
1167     break;
1168
1169   case TrkrDefs::tpcId:
1170     phierror = tpc_phi_error(layer, alpha, cluster);
1171     zerror = tpc_z_error(layer, beta, cluster);
1172
1173     break;
1174   }
1175   if (pull_fine_phi[layer] != 0)
1176   {
1177     phierror *= pull_fine_phi[layer];
1178   }
1179   if (pull_fine_z[layer] != 0)
1180   {
1181     zerror *= pull_fine_z[layer];
1182   }
1183
1184   if (phierror == 0)
1185   {
1186     phierror = 100;
1187   }
1188   if (zerror == 0)
1189   {
1190     zerror = 100;
1191   }
1192
1193   return std::make_pair(square(phierror), square(zerror));
1194 }
1195
1196 //_________________________________________________________________________________
1197 ClusterErrorPara::error_t ClusterErrorPara::get_fix_tpc_cluster_error(TrkrCluster* cluster, TrkrDefs::cluskey key)
1198 {
1199   int layer = TrkrDefs::getLayer(key);
1200   double phierror = 0;
1201   double zerror = 0;
1202
1203   phierror = mvtx_phi_error(cluster);
1204   zerror = mvtx_z_error(cluster);
1205
1206   if (pull_fine_phi[layer] != 0)
1207   {
1208     phierror *= pull_fine_phi[layer];
1209   }
1210   if (pull_fine_z[layer] != 0)
1211   {
1212     zerror *= pull_fine_z[layer];
1213   }
1214
1215   if (phierror == 0)
1216   {
1217     phierror = 100;
1218   }
1219   if (zerror == 0)
1220   {
1221     zerror = 100;
1222   }
1223
1224   return std::make_pair(square(phierror), square(zerror));
1225 }
1226
1227 //_________________________________________________________________________________
1228 ClusterErrorPara::error_t ClusterErrorPara::get_si_cluster_error(const TrkrCluster* cluster, TrkrDefs::cluskey key)
1229 {
1230   int layer = TrkrDefs::getLayer(key);
1231   double phierror = 0;
1232   double zerror = 0;
1233   switch (TrkrDefs::getTrkrId(key))
1234   {
1235   default:
1236     break;
1237
1238   case TrkrDefs::mvtxId:
1239
1240     phierror = mvtx_phi_error(cluster);
1241     zerror = mvtx_z_error(cluster);
1242     //      std::cout << "   z: " << zerror  << " l: " << layer  << std::endl;
1243     break;
1244
1245   case TrkrDefs::inttId:
1246
1247     phierror = intt_phi_error(layer, cluster);
1248     zerror = intt_z_error(cluster);
1249     break;
1250   }
1251   if (pull_fine_phi[layer] != 0)
1252   {
1253     phierror *= pull_fine_phi[layer];
1254   }
1255   if (pull_fine_z[layer] != 0)
1256   {
1257     zerror *= pull_fine_z[layer];
1258   }
1259
1260   if (phierror == 0)
1261   {
1262     phierror = 100;
1263   }
1264   if (zerror == 0)
1265   {
1266     zerror = 100;
1267   }
1268
1269   return std::make_pair(square(phierror), square(zerror));
1270 }