Belle II Software  release-08-01-10
B2BIIFixMdstModule_trk.cc
1 /**************************************************************************
2  * basf2 (Belle II Analysis Software Framework) *
3  * Author: The Belle II Collaboration *
4  * *
5  * See git log for contributors and copyright holders. *
6  * This file is licensed under LGPL-3.0, see LICENSE.md. *
7  **************************************************************************/
8 //
9 // $Id: B2BIIFixMdst_trk.cc 11331 2011-07-25 11:58:12Z hitoshi $
10 //
11 // $Log$
12 //
13 // Revision 2.0 2015/03/11 tkeck
14 // Conversion to Belle II
15 //
16 // Revision 1.47 2006/05/29
17 // scale_error for exp. 45,47,49
18 //
19 // Revision 1.46 2005/07/28 09:55:00 hitoshi
20 // for exp43 run700-1149 (by Senyo)
21 //
22 // Revision 1.45 2005/07/02 08:07:48 hitoshi
23 // for exp43 run300-699 (by Senyo)
24 //
25 // Revision 1.44 2005/06/06 04:28:01 katayama
26 // New for exp. 43 run - 300 from Miyabayasi and Senyo san
27 //
28 // Revision 1.43 2005/05/14 03:47:34 hitoshi
29 // scale error for exp39 and 41 (by Kusaka)
30 //
31 // Revision 1.42 2005/04/17 09:43:56 hitoshi
32 // for Exp41 r1200-end (by Senyo)
33 //
34 // Revision 1.41 2005/04/15 05:49:28 hitoshi
35 // for Exp41 r800-1199 (by Senyo)
36 //
37 // Revision 1.40 2005/03/31 10:45:30 hitoshi
38 // for Exp41 runno<=799 (by Senyo)
39 //
40 // Revision 1.39 2005/03/08 06:10:02 hitoshi
41 // scale_momenta for Exp39 (by Senyo)
42 //
43 // Revision 1.38 2004/07/26 03:29:46 katayama
44 // scale_error for exp. 37
45 //
46 // Revision 1.37 2004/07/14 07:34:17 katayama
47 // added cassert
48 //
49 // Revision 1.36 2004/07/12 08:27:04 hitoshi
50 // scale error for svd2 (by kusaka)
51 //
52 // Revision 1.35 2004/07/12 05:25:06 hitoshi
53 // scale momenta for exp37 r1400-end (by senyo)
54 //
55 // Revision 1.34 2004/07/09 05:39:37 hitoshi
56 // protection for mis-use for exp>=30
57 //
58 // Revision 1.33 2004/07/09 04:36:07 hitoshi
59 // scale momenta for exp37 run1-1399 (by senyo)
60 //
61 // Revision 1.32 2004/06/23 19:06:55 hitoshi
62 // scale momenta for exp31 (by Senyo)
63 //
64 // Revision 1.31 2004/06/16 06:48:36 hitoshi
65 // scale momenta for exp35 (by Senyo san)
66 //
67 // Revision 1.30 2004/06/06 03:20:47 hitoshi
68 // scale momenta for exp33 (by senyo)
69 //
70 // Revision 1.29 2004/04/25 16:33:33 hitoshi
71 // modified to be able to handle output from low p finder (by kakuno). modified
72 // Benergy to fetch data from DB (by Shibata).
73 //
74 // Revision 1.28 2004/03/09 04:46:00 hitoshi
75 // scale momenta for exp31 run1100-end by Senyo
76 //
77 // Revision 1.27 2004/03/01 03:12:42 hitoshi
78 // scale_momenta for exp31 upto run1099 (by Senyo).
79 //
80 // Revision 1.26 2003/07/31 07:47:58 katayama
81 // New version from Higuhi san
82 //
83 // Revision 1.25 2003/07/11 08:41:23 hitoshi
84 // fixed a bug.
85 //
86 // Revision 1.24 2003/07/11 06:41:22 katayama
87 // for exp. 27 continuum
88 //
89 // Revision 1.23 2003/07/10 13:45:38 hitoshi
90 // update for exp27 run700- (by Sanjay and Senyo).
91 //
92 // Revision 1.22 2003/06/30 22:16:29 hitoshi
93 // update for exp27 (by Miyabayashi, Sanjay, Senyo).
94 //
95 // Revision 1.21 2003/06/24 07:55:17 katayama
96 // Remived unused parameters
97 //
98 // Revision 1.20 2003/06/24 07:38:25 katayama
99 // added cstdio
100 //
101 // Revision 1.19 2003/06/18 12:22:02 katayama
102 // cannot compile with gcc3
103 //
104 // Revision 1.18 2003/06/12 13:25:43 hitoshi
105 // scale_error implemented last year (by Higuchi; valid up to exp19) is incorporated
106 //
107 // Revision 1.17 2003/05/31 09:22:54 hitoshi
108 // updae for exp25 (ny Miyabayashi and Senyo).
109 //
110 // Revision 1.16 2002/12/26 13:35:01 katayama
111 // scale_momenta for exp. 21 and 23 from Senyo san
112 //
113 // Revision 1.15 2002/10/12 15:33:07 hitoshi
114 // A bug fix: 1.46 -> 14.6kG (pointed out by N.root). Negligible effect on V0 mass.
115 //
116 // Revision 1.14 2002/07/04 21:06:44 katayama
117 // Final version
118 //
119 // Revision 1.13 2002/07/03 04:50:54 hitoshi
120 // scale_momenta for exp19 run900 - 1499 (by Senyo san).
121 //
122 // Revision 1.12 2002/06/22 09:40:59 katayama
123 // From Senyo san, for exp. 9 and exp.19 899
124 //
125 // Revision 1.11 2002/06/19 12:10:36 katayama
126 // New for exp. 7 from Senyo and Miyabayashi sans
127 //
128 // Revision 1.10 2002/06/13 00:40:08 hitoshi
129 // added scale momenta factors (from Senyo) for run1000 - end.
130 //
131 // Revision 1.9 2002/06/07 11:54:42 hitoshi
132 // added scale_momenta for run 1 - 999 in e11.
133 //
134 // Revision 1.8 2002/06/04 06:36:34 hitoshi
135 // added scale momenta for e19 runs300-459 (by Senyo).
136 //
137 // Revision 1.7 2002/05/29 07:15:14 hitoshi
138 // added scale momnta factors for exp19 run1-280.
139 //
140 // Revision 1.6 2002/05/24 13:27:45 hitoshi
141 // added scale_momenta for exp13 reprocessed data (by Senyo san).
142 //
143 // Revision 1.5 2002/05/08 12:12:54 hitoshi
144 // added scale_momenta factors for exp17 (by Senyo san).
145 //
146 // Revision 1.4 2002/04/23 15:11:55 hitoshi
147 // new scale factors for e15 mdst reprocessed with 20020405.
148 //
149 // Revision 1.3 2002/04/19 07:24:39 katayama
150 // Added pi0/vertex, calibdedx
151 //
152 // Revision 1.2 2002/04/05 01:19:33 katayama
153 // templates for ecl_primary_vertex
154 //
155 // Revision 1.1 2002/03/13 02:55:20 katayama
156 // First version
157 //
158 //
159 
160 #include <b2bii/modules/B2BIIMdstInput/B2BIIFixMdstModule.h>
161 
162 #include <cstdio>
163 #include <cmath>
164 #include <cfloat>
165 #include <cassert>
166 
167 #include "CLHEP/Vector/ThreeVector.h"
168 #include "CLHEP/Matrix/Vector.h"
169 #include <TRandom.h>
170 
171 #include "belle_legacy/helix/Helix.h"
172 
173 #include "belle_legacy/tables/mdst.h"
174 #include "belle_legacy/tables/belletdf.h"
175 #include "belle_legacy/tables/evtvtx.h"
176 #include "belle_legacy/ip/IpProfile.h"
177 
178 // kfitter
179 #include <analysis/VertexFitting/KFit/VertexFitKFit.h>
180 
181 namespace Belle2 {
188 //==========================================================
189  double B2BIIFixMdstModule::vee_mass_nofit(const Belle::Mdst_vee2& vee2, float scale)
190  {
191 //==========================================================
192 // Calculates V^0 mass with non-constraint fit results.
193 //==========================================================
194 
195  HepPoint3D vtx(vee2.vx(), vee2.vy(), vee2.vz());
196 
197  const double pion_mass = 0.13956995;
198  const double proton_mass = 0.93827231;
199  const double electron_mass = 0.000511;
200 
201  double massp(0.0), massm(0.0);
202  if (1 == vee2.kind()) {
203  massp = pion_mass;
204  massm = pion_mass;
205  } else if (2 == vee2.kind()) {
206  massp = proton_mass;
207  massm = pion_mass;
208  } else if (3 == vee2.kind()) {
209  massp = pion_mass;
210  massm = proton_mass;
211  } else if (4 == vee2.kind()) {
212  massp = electron_mass;
213  massm = electron_mass;
214  }
215 
216 //Calculate mass
217 //in case where decay vtx is outside of beam pipe
218  // if(BsCouTab(MDST_VEE_DAUGHTERS)) {
219  if (vee2.daut()) {
220 
221  Belle::Mdst_vee_daughters& vdau = vee2.daut();
222 
223  CLHEP::HepVector a(5);
224  a[0] = vdau.helix_p(0); a[1] = vdau.helix_p(1);
225  a[2] = vdau.helix_p(2) / scale;
226  a[3] = vdau.helix_p(3); a[4] = vdau.helix_p(4);
227  Belle::Helix helixp(vtx, a);
228 
229  a[0] = vdau.helix_m(0); a[1] = vdau.helix_m(1);
230  a[2] = vdau.helix_m(2) / scale;
231  a[3] = vdau.helix_m(3); a[4] = vdau.helix_m(4);
232  Belle::Helix helixm(vtx, a);
233  // dout(Debugout::DDEBUG,"B2BIIFixMdst_trk") << "outside bp" << std::endl;
234  CLHEP::HepLorentzVector v0 = helixp.momentum(0., massp) + helixm.momentum(0., massm);
235  return v0.mag();
236 
237 //in case where decay vtx is inside of beam pipe
238  } else {
239 
240  Belle::Mdst_charged& chargedp = vee2.chgd(0);
241  Belle::Mdst_trk& trkp = chargedp.trk();
242  Belle::Mdst_trk_fit& trkfp = trkp.mhyp(2);
243  HepPoint3D pvtp(trkfp.pivot_x(), trkfp.pivot_y(), trkfp.pivot_z());
244  CLHEP::HepVector a(5);
245  a[0] = trkfp.helix(0); a[1] = trkfp.helix(1);
246  a[2] = trkfp.helix(2);
247  a[3] = trkfp.helix(3); a[4] = trkfp.helix(4);
248  Belle::Helix helixp(pvtp, a);
249  helixp.bFieldZ(14.6);
250  helixp.pivot(vtx);
251  a = helixp.a();
252  a[2] = a[2] / scale;
253  helixp.a(a);
254 
255  Belle::Mdst_charged& chargedm = vee2.chgd(1);
256  Belle::Mdst_trk& trkm = chargedm.trk();
257  Belle::Mdst_trk_fit& trkfm = trkm.mhyp(2);
258  HepPoint3D pvtm(trkfm.pivot_x(), trkfm.pivot_y(), trkfm.pivot_z());
259  a[0] = trkfm.helix(0); a[1] = trkfm.helix(1);
260  a[2] = trkfm.helix(2);
261  a[3] = trkfm.helix(3); a[4] = trkfm.helix(4);
262  Belle::Helix helixm(pvtm, a);
263  helixm.bFieldZ(14.6);
264  helixm.pivot(vtx);
265  a = helixm.a();
266  a[2] = a[2] / scale;
267  helixm.a(a);
268  // dout(Debugout::DDEBUG,"B2BIIFixMdst_trk") << "inside bp" << std::endl;
269  CLHEP::HepLorentzVector v0 = helixp.momentum(0., massp) + helixm.momentum(0., massm);
270  return v0.mag();
271 
272  }
273 
274  }
275 
276 //===============================================================
277  void B2BIIFixMdstModule::scale_momenta(float scale_data, float scale_mc, int mode)
278  {
279 //===============================================================
280 // Scales charged track momenta, track params. and error
281 // matrices.
282 //======================================================
283 
284  // dout(Debugout::DDEBUG,"B2BIIFixMdst_trk") << "sacel momenta is called" << std::endl;
285 
286 //Check existence of belle_event
287  Belle::Belle_event_Manager& evtmgr = Belle::Belle_event_Manager::get_manager();
288  // dout(Debugout::DDEBUG,"B2BIIFixMdst_trk") << evtmgr.count() << std::endl;
289  if (0 == evtmgr.count()) return; //do nothing if not exist
290  // dout(Debugout::DDEBUG,"B2BIIFixMdst_trk") << "after check" << std::endl;
291 
292  Belle::Mdst_event_add_Manager& mevtmgr = Belle::Mdst_event_add_Manager::get_manager();
293  if (mevtmgr.count() > 0 && 1 == mevtmgr[0].flag_scale()) return; //do nothing if already scaled
294 
295 //check mode
296  if (mode < 0 || mode > 2) {
297  B2ERROR("scale_momenta: invalid mode specified;");
298  B2ERROR("mode must be 0, 1, 2");
299  return;
300  }
301 
302 //set scale factor
303  int expmc = evtmgr[0].ExpMC();
304  int expno = evtmgr[0].ExpNo();
305  int runno = evtmgr[0].RunNo();
306 
307  double scale = 1.;
308  if (1 == expmc) {
309  if (mode == 0) {
310  scale = scale_data;
311  } else {
312  // scale_momenta_set( mode, expno, runno, scale);
313  if (m_reprocess_version == 0) {
314  scale_momenta_set_v1(mode, expno, runno, scale);
315  } else if (m_reprocess_version == 1) {
316  scale_momenta_set_v2(mode, expno, runno, scale);
317  }
318  }
319  } else if (2 == expmc) {
320  scale = scale_mc;
321  }
322 
323  if (1. == scale) return; //do nothing if scale=1
324  // dout(Debugout::DDEBUG,"B2BIIFixMdst_trk") << scale << std::endl;
325 
326 //Turn on flag, save scale factor
327  if (mevtmgr.count() > 0) {
328  mevtmgr[0].flag_scale(1);
329  mevtmgr[0].scale(scale);
330  } else {
331  Belle::Mdst_event_add& meadd = mevtmgr.add();
332  meadd.flag_scale(1);
333  meadd.scale(scale);
334  }
335  // dout(Debugout::DDEBUG,"B2BIIFixMdst_trk") << mevtmgr[0].flag_scale() << std::endl;
336  // dout(Debugout::DDEBUG,"B2BIIFixMdst_trk") << mevtmgr[0].scale() << std::endl;
337 
338 
339 //Scale momenta in mdst_charged
340  Belle::Mdst_charged_Manager& chgmgr = Belle::Mdst_charged_Manager::get_manager();
341  for (std::vector<Belle::Mdst_charged>::iterator it = chgmgr.begin();
342  it != chgmgr.end(); ++it) {
343  Belle::Mdst_charged& charged = *it;
344  charged.px(scale * charged.px());
345  charged.py(scale * charged.py());
346  charged.pz(scale * charged.pz());
347  }
348 
349 //Scale momenta in mdst_vee2
350  Belle::Mdst_vee2_Manager& vee2mgr = Belle::Mdst_vee2_Manager::get_manager();
351  for (std::vector<Belle::Mdst_vee2>::iterator it = vee2mgr.begin();
352  it != vee2mgr.end(); ++it) {
353  Belle::Mdst_vee2& vee2 = *it;
354  double v0mass_scale = vee_mass_nofit(vee2, scale);
355  double v0mass_noscl = vee_mass_nofit(vee2);
356  double esq_scale =
357  (v0mass_scale - v0mass_noscl) * (v0mass_scale + v0mass_noscl)
358  + vee2.energy() * vee2.energy() +
359  (scale - 1.) * (scale + 1.) * (vee2.px() * vee2.px() +
360  vee2.py() * vee2.py() +
361  vee2.pz() * vee2.pz());
362  vee2.energy(std::sqrt(esq_scale));
363  vee2.px(scale * vee2.px());
364  vee2.py(scale * vee2.py());
365  vee2.pz(scale * vee2.pz());
366  }
367 
368 //Scale error matrices in mdst_trk_fit
369  double scalei = 1. / scale;
370  double scalei2 = scalei / scale;
371 
372  Belle::Mdst_trk_fit_Manager& trkfmgr = Belle::Mdst_trk_fit_Manager::get_manager();
373  for (std::vector<Belle::Mdst_trk_fit>::iterator it = trkfmgr.begin();
374  it != trkfmgr.end(); ++it) {
375  Belle::Mdst_trk_fit& trkf = *it;
376  trkf.helix(2, scalei * trkf.helix(2));
377  trkf.error(3, scalei * trkf.error(3));
378  trkf.error(4, scalei * trkf.error(4));
379  trkf.error(5, scalei2 * trkf.error(5));
380  trkf.error(8, scalei * trkf.error(8));
381  trkf.error(12, scalei * trkf.error(12));
382  }
383 
384 //Scale error matrices in mdst_daughters
385  Belle::Mdst_vee_daughters_Manager& vdaumgr = Belle::Mdst_vee_daughters_Manager::get_manager();
386  for (std::vector<Belle::Mdst_vee_daughters>::iterator it = vdaumgr.begin();
387  it != vdaumgr.end(); ++it) {
388  Belle::Mdst_vee_daughters& vdau = *it;
389  vdau.helix_p(2, scalei * vdau.helix_p(2));
390  vdau.error_p(3, scalei * vdau.error_p(3));
391  vdau.error_p(4, scalei * vdau.error_p(4));
392  vdau.error_p(5, scalei2 * vdau.error_p(5));
393  vdau.error_p(8, scalei * vdau.error_p(8));
394  vdau.error_p(12, scalei * vdau.error_p(12));
395 
396  vdau.helix_m(2, scalei * vdau.helix_m(2));
397  vdau.error_m(3, scalei * vdau.error_m(3));
398  vdau.error_m(4, scalei * vdau.error_m(4));
399  vdau.error_m(5, scalei2 * vdau.error_m(5));
400  vdau.error_m(8, scalei * vdau.error_m(8));
401  vdau.error_m(12, scalei * vdau.error_m(12));
402  }
403  }
404 
405 //=====================================================================
406  void B2BIIFixMdstModule::scale_momenta_set(const int mode, const int expno,
407  const int runno, double& scale)
408  {
409 //=====================================================================
410 
411  scale = 1.;
412 
413  if (mode == 1) {
414  //factors for 2001 summer confs. analyses
415  if (expno == 7) {scale = 1.001932; return;}
416  if (expno == 9) {scale = 1.001413; return;}
417  if (expno == 11) {scale = 1.001366; return;}
418  // if(expno==13) {scale = 1.000909; return;} //for '01 summer conf. papers; using up to run400
419  if (expno == 13) {scale = 1.001460; return;} //updated factor using up to run1599
420  if (expno >= 15) {B2ERROR("scale_momenta mode=1: not ready for exp >=15");}
421  }
422 
423  if (mode == 2) {
424  if (expno == 7) {
425  if (runno >= 0 && runno <= 99) {scale = 1.00262126; return;}
426  if (runno >= 100 && runno <= 199) {scale = 1.00253537; return;}
427  if (runno >= 200 && runno <= 299) {scale = 1.00246555; return;}
428  if (runno >= 300 && runno <= 399) {scale = 1.0026452 ; return;}
429  if (runno >= 400 && runno <= 499) {scale = 1.00290386; return;}
430  if (runno >= 500 && runno <= 599) {scale = 1.00287753; return;}
431  if (runno >= 600 && runno <= 699) {scale = 1.00266845; return;}
432  if (runno >= 700 && runno <= 799) {scale = 1.00184472; return;}
433  if (runno >= 800 && runno <= 899) {scale = 1.00200021; return;}
434  if (runno >= 900 && runno <= 999) {scale = 1.00178485; return;}
435  if (runno >= 1000 && runno <= 1099) {scale = 1.00196071; return;}
436  if (runno >= 1100 && runno <= 1199) {scale = 1.00224453; return;}
437  if (runno >= 1200 && runno <= 1299) {scale = 1.00209138; return;}
438  if (runno >= 1300 && runno <= 1399) {scale = 1.00145455; return;}
439  if (runno >= 1400 && runno <= 1499) {scale = 1.00119243; return;}
440  if (runno >= 1500 && runno <= 1599) {scale = 1.00115572; return;}
441  if (runno >= 1600 && runno <= 1699) {scale = 1.00133916; return;}
442  if (runno >= 1700 && runno <= 1799) {scale = 1.00186441; return;}
443  if (runno >= 1800 && runno <= 1899) {scale = 1.00206786; return;}
444  if (runno >= 1900 && runno <= 1999) {scale = 1.00184794; return;}
445  if (runno >= 2000 && runno <= 2099) {scale = 1.00187219; return;}
446  if (runno >= 2100 && runno <= 2199) {scale = 1.00214844; return;}
447  if (runno >= 2200 && runno <= 2299) {scale = 1.00154502; return;}
448  if (runno >= 2300 && runno <= 2399) {scale = 1.00179518; return;}
449  if (runno >= 2400 && runno <= 2499) {scale = 1.00198983; return;}
450  if (runno >= 2500 && runno <= 2599) {scale = 1.00219242; return;}
451  if (runno >= 2600 && runno <= 2699) {scale = 1.00227363; return;}
452  if (runno >= 2700 && runno <= 2799) {scale = 1.00202328; return;}
453  if (runno >= 2800 && runno <= 2899) {scale = 1.00193147; return;}
454  } else if (expno == 9) {
455  if (runno >= 0 && runno <= 99) {scale = 1.00126754; return;}
456  if (runno >= 100 && runno <= 199) {scale = 1.00119683; return;}
457  if (runno >= 200 && runno <= 299) {scale = 1.00123771; return;}
458  if (runno >= 300 && runno <= 399) {scale = 1.00142625; return;}
459  if (runno >= 400 && runno <= 499) {scale = 1.00134481; return;}
460  if (runno >= 500 && runno <= 599) {scale = 1.00131973; return;}
461  if (runno >= 600 && runno <= 699) {scale = 1.00145963; return;}
462  if (runno >= 700 && runno <= 799) {scale = 1.00161304; return;}
463  if (runno >= 800 && runno <= 899) {scale = 1.00141795; return;}
464  if (runno >= 900 && runno <= 999) {scale = 1.00137157; return;}
465  if (runno >= 1000 && runno <= 1099) {scale = 1.00126209; return;}
466  if (runno >= 1100 && runno <= 1199) {scale = 1.00147941; return;}
467  if (runno >= 1200 && runno <= 1299) {scale = 1.00145555; return;}
468  } else if (expno == 11) {
469  if (runno >= 0 && runno <= 99) {scale = 1.00149576; return;}
470  if (runno >= 100 && runno <= 199) {scale = 1.00155153; return;}
471  if (runno >= 200 && runno <= 299) {scale = 1.0013597 ; return;}
472  if (runno >= 300 && runno <= 399) {scale = 1.00147504; return;}
473  if (runno >= 400 && runno <= 499) {scale = 1.00138242; return;}
474  if (runno >= 500 && runno <= 599) {scale = 1.00144554; return;}
475  if (runno >= 600 && runno <= 699) {scale = 1.00136961; return;}
476  if (runno >= 700 && runno <= 799) {scale = 1.00141443; return;}
477  if (runno >= 800 && runno <= 899) {scale = 1.00136617; return;}
478  if (runno >= 900 && runno <= 999) {scale = 1.00126262; return;}
479  if (runno >= 1000 && runno <= 1099) {scale = 1.00133337; return;}
480  if (runno >= 1100 && runno <= 1199) {scale = 1.00137906; return;}
481  if (runno >= 1200 && runno <= 1299) {scale = 1.00127944; return;}
482  //assume same factor for runno>=1300
483  if (runno >= 1300 && runno <= 1399) {scale = 1.00127944; return;}
484  } else if (expno == 13) {
485  if (runno >= 0 && runno <= 99) {scale = 1.00110691; return;}
486  if (runno >= 100 && runno <= 199) {scale = 1.00106123; return;}
487  if (runno >= 200 && runno <= 299) {scale = 1.00109934; return;}
488  if (runno >= 300 && runno <= 399) {scale = 1.00105759; return;}
489  if (runno >= 400 && runno <= 499) {scale = 1.000986887; return;}
490  if (runno >= 500 && runno <= 599) {scale = 1.000928764; return;}
491  if (runno >= 600 && runno <= 699) {scale = 1.00103925; return;}
492  if (runno >= 700 && runno <= 799) {scale = 1.0010591 ; return;}
493  if (runno >= 800 && runno <= 899) {scale = 1.00127043; return;}
494  if (runno >= 900 && runno <= 999) {scale = 1.00154033; return;}
495  if (runno >= 1000 && runno <= 1099) {scale = 1.00180656; return;}
496  if (runno >= 1100 && runno <= 1199) {scale = 1.00202059; return;}
497  if (runno >= 1200 && runno <= 1299) {scale = 1.00184308; return;}
498  if (runno >= 1300 && runno <= 1399) {scale = 1.00180153; return;}
499  if (runno >= 1400 && runno <= 1499) {scale = 1.00189577; return;}
500  if (runno >= 1500 && runno <= 1599) {scale = 1.00176026; return;}
501  //assume same factor for runno>=1600
502  if (runno >= 1600 && runno <= 1699) {scale = 1.00176026; return;}
503 
504  } else if (expno == 15) {
505  if (runno >= 0 && runno <= 99) {scale = 1.00178719; return;}
506  if (runno >= 100 && runno <= 199) {scale = 1.00205712; return;}
507  if (runno >= 200 && runno <= 299) {scale = 1.00197622; return;}
508  if (runno >= 300 && runno <= 399) {scale = 1.00191558; return;}
509  if (runno >= 400 && runno <= 499) {scale = 1.00207795; return;}
510  if (runno >= 500 && runno <= 599) {scale = 1.00191871; return;}
511  if (runno >= 600 && runno <= 699) {scale = 1.00187917; return;}
512  if (runno >= 700 && runno <= 799) {scale = 1.0019573 ; return;}
513  if (runno >= 800 && runno <= 899) {scale = 1.00196562; return;}
514  if (runno >= 900 && runno <= 999) {scale = 1.00205215; return;}
515  if (runno >= 1000 && runno <= 1099) {scale = 1.00200559; return;}
516  if (runno >= 1100 && runno <= 1199) {scale = 1.00198568; return;}
517  if (runno >= 1200 && runno <= 1299) {scale = 1.00212539; return;}
518  if (runno >= 1300 && runno <= 1399) {scale = 1.00199158; return;}
519  if (runno >= 1400 && runno <= 1499) {scale = 1.00208257; return;}
520 
521  } else if (expno >= 17) { B2ERROR("scale_momenta mode=2: not ready for exp >=17");}
522 
523  }
524  return;
525  }
526 
527 //=====================================================================
528  void B2BIIFixMdstModule::scale_momenta_set_v1(const int mode, const int expno,
529  const int runno, double& scale)
530  {
531 //=====================================================================
532 
533  //for e15 mdst processed with b20020405
534 
535  scale = 1.;
536 
537  if (mode == 1) {
538  B2ERROR("scale_momenta mode=1 not ready for exp " << expno);
539  return;
540  }
541 
542  if (mode == 2) {
543  if (expno == 7) {
544  if (runno >= 0 && runno <= 99) {scale = 1.00284313; return;}
545  if (runno >= 100 && runno <= 199) {scale = 1.00272563; return;}
546  if (runno >= 200 && runno <= 299) {scale = 1.00276953; return;}
547  if (runno >= 300 && runno <= 399) {scale = 1.00286722; return;}
548  if (runno >= 400 && runno <= 499) {scale = 1.00318492; return;}
549  if (runno >= 500 && runno <= 599) {scale = 1.00304208; return;}
550  if (runno >= 600 && runno <= 699) {scale = 1.00292413; return;}
551  if (runno >= 700 && runno <= 799) {scale = 1.00201286; return;}
552  if (runno >= 800 && runno <= 899) {scale = 1.00225237; return;}
553  if (runno >= 900 && runno <= 999) {scale = 1.00210375; return;}
554  if (runno >= 1000 && runno <= 1099) {scale = 1.00213222; return;}
555  if (runno >= 1100 && runno <= 1199) {scale = 1.00253683; return;}
556  if (runno >= 1200 && runno <= 1299) {scale = 1.00234023; return;}
557  if (runno >= 1300 && runno <= 1399) {scale = 1.00168421; return;}
558  if (runno >= 1400 && runno <= 1499) {scale = 1.00136169; return;}
559  if (runno >= 1500 && runno <= 1599) {scale = 1.00138431; return;}
560  if (runno >= 1600 && runno <= 1699) {scale = 1.00154521; return;}
561  if (runno >= 1700 && runno <= 1799) {scale = 1.00204405; return;}
562  if (runno >= 1800 && runno <= 1899) {scale = 1.00223498; return;}
563  if (runno >= 1900 && runno <= 1999) {scale = 1.00198975; return;}
564  if (runno >= 2000 && runno <= 2099) {scale = 1.00201868; return;}
565  if (runno >= 2100 && runno <= 2199) {scale = 1.00233875; return;}
566  if (runno >= 2200 && runno <= 2299) {scale = 1.00175269; return;}
567  if (runno >= 2300 && runno <= 2399) {scale = 1.00192858; return;}
568  if (runno >= 2400 && runno <= 2499) {scale = 1.00217693; return;}
569  if (runno >= 2500 && runno <= 2599) {scale = 1.00209337; return;}
570  if (runno >= 2600 && runno <= 2699) {scale = 1.00244277; return;}
571  if (runno >= 2700 && runno <= 2799) {scale = 1.00221485; return;}
572  if (runno >= 2800 && runno <= 2899) {scale = 1.00214678; return;}
573  } else if (expno == 9) {
574  if (runno >= 0 && runno <= 99) {scale = 1.00127702; return;}
575  if (runno >= 100 && runno <= 199) {scale = 1.00119957; return;}
576  if (runno >= 200 && runno <= 299) {scale = 1.00132677; return;}
577  if (runno >= 300 && runno <= 399) {scale = 1.0014785 ; return;}
578  if (runno >= 400 && runno <= 499) {scale = 1.00144872; return;}
579  if (runno >= 500 && runno <= 599) {scale = 1.00145376; return;}
580  if (runno >= 600 && runno <= 699) {scale = 1.00151659; return;}
581  if (runno >= 700 && runno <= 799) {scale = 1.00167384; return;}
582  if (runno >= 800 && runno <= 899) {scale = 1.00153754; return;}
583  if (runno >= 900 && runno <= 999) {scale = 1.0014984 ; return;}
584  if (runno >= 1000 && runno <= 1099) {scale = 1.0013764 ; return;}
585  if (runno >= 1100 && runno <= 1199) {scale = 1.00145545; return;}
586  if (runno >= 1200 && runno <= 1299) {scale = 1.0017164 ; return;}
587  } else if (expno == 11) {
588  if (runno >= 0 && runno <= 99) {scale = 1.00159624; return;}
589  if (runno >= 100 && runno <= 199) {scale = 1.00153365; return;}
590  if (runno >= 200 && runno <= 299) {scale = 1.00143809; return;}
591  if (runno >= 300 && runno <= 399) {scale = 1.00148495; return;}
592  if (runno >= 400 && runno <= 499) {scale = 1.00143193; return;}
593  if (runno >= 500 && runno <= 599) {scale = 1.00141905; return;}
594  if (runno >= 600 && runno <= 699) {scale = 1.0013992 ; return;}
595  if (runno >= 700 && runno <= 799) {scale = 1.00148836; return;}
596  if (runno >= 800 && runno <= 899) {scale = 1.00139019; return;}
597  if (runno >= 900 && runno <= 999) {scale = 1.00151389; return;}
598  if (runno >= 1000 && runno <= 1099) {scale = 1.00142988; return;}
599  if (runno >= 1100 && runno <= 1199) {scale = 1.00143519; return;}
600  if (runno >= 1200 && runno <= 1299) {scale = 1.00132641; return;}
601  } else if (expno == 13) {
602  if (runno >= 0 && runno <= 99) {scale = 1.00126317; return;}
603  if (runno >= 100 && runno <= 199) {scale = 1.00118837; return;}
604  if (runno >= 200 && runno <= 299) {scale = 1.00122276; return;}
605  if (runno >= 300 && runno <= 399) {scale = 1.00113233; return;}
606  if (runno >= 400 && runno <= 499) {scale = 1.00111677; return;}
607  if (runno >= 500 && runno <= 599) {scale = 1.00100963; return;}
608  if (runno >= 600 && runno <= 699) {scale = 1.0011474 ; return;}
609  if (runno >= 700 && runno <= 799) {scale = 1.00116245; return;}
610  if (runno >= 800 && runno <= 899) {scale = 1.00139826; return;}
611  if (runno >= 900 && runno <= 999) {scale = 1.0017014 ; return;}
612  if (runno >= 1000 && runno <= 1099) {scale = 1.00190706; return;}
613  if (runno >= 1100 && runno <= 1199) {scale = 1.00214688; return;}
614  if (runno >= 1200 && runno <= 1299) {scale = 1.00207336; return;}
615  if (runno >= 1300 && runno <= 1399) {scale = 1.00192885; return;}
616  if (runno >= 1400 && runno <= 1499) {scale = 1.00196289; return;}
617  if (runno >= 1500 && runno <= 1599) {scale = 1.00185017; return;}
618  if (runno >= 1600 && runno <= 1699) {scale = 1.00191256; return;}
619  } else if (expno == 15) {
620  if (runno >= 0 && runno <= 99) {scale = 1.001953; return;}
621  if (runno >= 100 && runno <= 199) {scale = 1.00210508; return;}
622  if (runno >= 200 && runno <= 299) {scale = 1.002139; return;}
623  if (runno >= 300 && runno <= 399) {scale = 1.00207803; return;}
624  if (runno >= 400 && runno <= 499) {scale = 1.0022331; return;}
625  if (runno >= 500 && runno <= 599) {scale = 1.00206421; return;}
626  if (runno >= 600 && runno <= 699) {scale = 1.00205153; return;}
627  if (runno >= 700 && runno <= 799) {scale = 1.00214664; return;}
628  if (runno >= 800 && runno <= 899) {scale = 1.0021456; return;}
629  if (runno >= 900 && runno <= 999) {scale = 1.00221055; return;}
630  if (runno >= 1000 && runno <= 1099) {scale = 1.00216472; return;}
631  if (runno >= 1100 && runno <= 1199) {scale = 1.00214208; return;}
632  if (runno >= 1200 && runno <= 1299) {scale = 1.00228874; return;}
633  if (runno >= 1300 && runno <= 1399) {scale = 1.00215047; return;}
634  if (runno >= 1400 && runno <= 1499) {scale = 1.00219808; return;}
635  } else if (expno == 17) {
636  if (runno >= 0 && runno <= 99) {scale = 1.00216742; return;}
637  if (runno >= 100 && runno <= 199) {scale = 1.00229433; return;}
638  if (runno >= 200 && runno <= 299) {scale = 1.0022749 ; return;}
639  if (runno >= 300 && runno <= 399) {scale = 1.00231283; return;}
640  if (runno >= 400 && runno <= 499) {scale = 1.00223654; return;}
641  if (runno >= 500 && runno <= 599) {scale = 1.00236524; return;}
642  if (runno >= 600 && runno <= 699) {scale = 1.00229312; return;}
643  if (runno >= 700 && runno <= 799) {scale = 1.002262 ; return;}
644  if (runno >= 800 && runno <= 899) {scale = 1.00220104; return;}
645  if (runno >= 900 && runno <= 999) {scale = 1.00215475; return;}
646  } else if (expno == 19) {
647  if (runno >= 0 && runno <= 99) {scale = 1.00227682; return;}
648  if (runno >= 100 && runno <= 199) {scale = 1.00235795; return;}
649  if (runno >= 200 && runno <= 299) {scale = 1.00251509; return;}
650  if (runno >= 300 && runno <= 399) {scale = 1.0022106 ; return;}
651  if (runno >= 400 && runno <= 499) {scale = 1.00230963; return;}
652  if (runno >= 500 && runno <= 599) {scale = 1.002229 ; return;}
653  if (runno >= 600 && runno <= 699) {scale = 1.00215402; return;}
654  if (runno >= 700 && runno <= 799) {scale = 1.00217892; return;}
655  if (runno >= 800 && runno <= 899) {scale = 1.0022305 ; return;}
656  if (runno >= 900 && runno <= 999) {scale = 1.0021458 ; return;}
657  if (runno >= 1000 && runno <= 1099) {scale = 1.00215792; return;}
658  if (runno >= 1100 && runno <= 1199) {scale = 1.0022667 ; return;}
659  if (runno >= 1200 && runno <= 1299) {scale = 1.00219581; return;}
660  if (runno >= 1300 && runno <= 1399) {scale = 1.00218378; return;}
661  if (runno >= 1400 && runno <= 1499) {scale = 1.00232172; return;}
662  if (runno >= 1500 && runno <= 1599) {scale = 1.00217172; return;}
663  if (runno >= 1600 && runno <= 1700) {scale = 1.00208639; return;}
664  if (runno >= 1700 && runno <= 1799) {scale = 1.00188253; return;}
665  if (runno >= 1800) {
666  B2ERROR("scale_momenta not ready for this exp,run "
667  << expno << "," << runno);
668  }
669  } else if (expno == 21) {
670  if (runno >= 0 && runno <= 99) {scale = 1.00228182; return;}
671  if (runno >= 100 && runno <= 199) {scale = 1.00233446; return;}
672  if (runno >= 200 && runno <= 299) {scale = 1.00238846; return;}
673  if (runno >= 300 && runno <= 399) {scale = 1.00238061 ; return;}
674  if (runno >= 400) {
675  B2ERROR("scale_momenta not ready for this exp,run "
676  << expno << "," << runno);
677  }
678  } else if (expno == 23) {
679  if (runno >= 0 && runno <= 99) {scale = 1.00216089; return;}
680  if (runno >= 100 && runno <= 199) {scale = 1.0019783; return;}
681  if (runno >= 200 && runno <= 299) {scale = 1.00172162; return;}
682  if (runno >= 300 && runno <= 399) {scale = 1.0017938 ; return;}
683  if (runno >= 400 && runno <= 499) {scale = 1.00177832 ; return;}
684  if (runno >= 500 && runno <= 599) {scale = 1.0017609 ; return;}
685  if (runno >= 600 && runno <= 699) {scale = 1.0017756 ; return;}
686  if (runno >= 700) {
687  B2ERROR("scale_momenta not ready for this exp,run "
688  << expno << "," << runno);
689  }
690  } else if (expno == 25) {
691  if (runno >= 0 && runno <= 99) {scale = 1.00190068; return;}
692  if (runno >= 100 && runno <= 199) {scale = 1.00199038; return;}
693  if (runno >= 200 && runno <= 299) {scale = 1.00196171; return;}
694  if (runno >= 300 && runno <= 399) {scale = 1.00200167; return;}
695  if (runno >= 400 && runno <= 499) {scale = 1.0019667 ; return;}
696  if (runno >= 500 && runno <= 599) {scale = 1.00212109; return;}
697  if (runno >= 600 && runno <= 699) {scale = 1.00202115; return;}
698  if (runno >= 700 && runno <= 799) {scale = 1.00196456; return;}
699  if (runno >= 800 && runno <= 899) {scale = 1.00200392; return;}
700  if (runno >= 900 && runno <= 999) {scale = 1.00199495; return;}
701  if (runno >= 1000 && runno <= 1099) {scale = 1.00202212; return;}
702  if (runno >= 1100 && runno <= 1199) {scale = 1.00205312; return;}
703  if (runno >= 1200 && runno <= 1299) {scale = 1.00200891; return;}
704  if (runno >= 1300 && runno <= 1399) {scale = 1.00196866; return;}
705  if (runno >= 1400 && runno <= 1499) {scale = 1.0020257 ; return;}
706  if (runno >= 1500 && runno <= 1599) {scale = 1.00196995; return;}
707  if (runno >= 1600 && runno <= 1699) {scale = 1.00189232; return;}
708  if (runno >= 1700 && runno <= 1799) {scale = 1.00179028; return;}
709  if (runno >= 1800 && runno <= 1899) {scale = 1.00179459; return;}
710  if (runno >= 1900 && runno <= 1999) {scale = 1.001762 ; return;}
711  if (runno >= 2000 && runno <= 2099) {scale = 1.00179514; return;}
712  if (runno >= 2100 && runno <= 2199) {scale = 1.00175211; return;}
713  if (runno >= 2200) {
714  B2ERROR("scale_momenta not ready for this exp,run "
715  << expno << "," << runno);
716  }
717  } else if (expno == 27) {
718  if (runno >= 0 && runno <= 99) {scale = 1.00192647; return;}
719  if (runno >= 100 && runno <= 199) {scale = 1.0019717 ; return;}
720  if (runno >= 200 && runno <= 299) {scale = 1.00196428; return;}
721  if (runno >= 300 && runno <= 399) {scale = 1.00190998; return;}
722  if (runno >= 400 && runno <= 499) {scale = 1.00204645; return;}
723  if (runno >= 500 && runno <= 599) {scale = 1.0020687 ; return;}
724  if (runno >= 600 && runno <= 699) {scale = 1.00198209; return;}
725 
726  if (runno >= 700 && runno <= 800) {scale = 1.00187505; return;}
727  if (runno >= 801 && runno <= 900) {scale = 1.00186805; return;}
728  if (runno >= 901 && runno <= 1000) {scale = 1.00185576; return;}
729  if (runno >= 1001 && runno <= 1079) {scale = 1.00177176; return;}
730  if (runno >= 1080 && runno <= 1100) {scale = 1.00177184; return;}
731  if (runno >= 1101 && runno <= 1200) {scale = 1.00174057; return;}
732  if (runno >= 1201 && runno <= 1251) {scale = 1.00189649; return;}
733  if (runno >= 1252 && runno <= 1300) {scale = 1.00189999; return;}
734  if (runno >= 1301 && runno <= 1400) {scale = 1.0018818 ; return;}
735  if (runno >= 1401 && runno <= 1500) {scale = 1.00200148; return;}
736  if (runno >= 1501 && runno <= 1600) {scale = 1.00220137; return;}
737  if (runno >= 1601 && runno <= 1632) {scale = 1.00217034; return;}
738  if (runno >= 1633) {
739  B2ERROR("scale_momenta not ready for this exp,run "
740  << expno << "," << runno);
741  }
742  } else if (expno == 31) {
743  if (runno >= 0 && runno <= 99) {scale = 1.000373374; return;}
744  if (runno >= 100 && runno <= 199) {scale = 1.000684843; return;}
745  if (runno >= 200 && runno <= 299) {scale = 1.000741216; return;}
746  if (runno >= 300 && runno <= 399) {scale = 1.00092523 ; return;}
747  if (runno >= 400 && runno <= 499) {scale = 1.00104576 ; return;}
748  if (runno >= 500 && runno <= 599) {scale = 1.00103982 ; return;}
749  if (runno >= 600 && runno <= 699) {scale = 1.0010601 ; return;}
750  if (runno >= 700 && runno <= 799) {scale = 1.000982515; return;}
751  if (runno >= 800 && runno <= 899) {scale = 1.00101577 ; return;}
752  if (runno >= 900 && runno <= 999) {scale = 1.000972193; return;}
753  if (runno >= 1000 && runno <= 1099) {scale = 1.00102536 ; return;}
754  if (runno >= 1100 && runno <= 1199) {scale = 1.00127571 ; return;}
755  if (runno >= 1200 && runno <= 1299) {scale = 1.00117938 ; return;}
756  if (runno >= 1300 && runno <= 1399) {scale = 1.00121084 ; return;}
757  if (runno >= 1400 && runno <= 1499) {scale = 1.00125911 ; return;}
758  if (runno >= 1500 && runno <= 1599) {scale = 1.0012907 ; return;}
759  if (runno >= 1600 && runno <= 1699) {scale = 1.00125362 ; return;}
760  if (runno >= 1700 && runno <= 1799) {scale = 1.00131686 ; return;}
761  if (runno >= 1800) {
762  B2ERROR("scale_momenta not ready for this exp,run "
763  << expno << "," << runno);
764  }
765  } else if (expno == 33) {
766  if (runno >= 0 && runno <= 99) {scale = 1.00136407; return;}
767  if (runno >= 100 && runno <= 199) {scale = 1.0013701 ; return;}
768  if (runno >= 200 && runno <= 299) {scale = 1.00156244; return;}
769  if (runno >= 300 && runno <= 399) {scale = 1.00138501; return;}
770  if (runno >= 400 && runno <= 499) {scale = 1.00148468; return;}
771  if (runno >= 500 && runno <= 599) {scale = 1.0013797 ; return;}
772  if (runno >= 600 && runno <= 699) {scale = 1.00152298; return;}
773  if (runno >= 700 && runno <= 799) {scale = 1.001524 ; return;}
774  if (runno >= 800 && runno <= 899) {scale = 1.0014635 ; return;}
775  if (runno >= 900) {
776  B2ERROR("scale_momenta not ready for this exp,run "
777  << expno << "," << runno);
778  }
779  } else if (expno == 35) {
780  if (runno >= 0 && runno <= 99) {scale = 1.00135452; return;}
781  if (runno >= 100 && runno <= 199) {scale = 1.00135798; return;}
782  if (runno >= 200 && runno <= 299) {scale = 1.00139979; return;}
783  if (runno >= 300 && runno <= 399) {scale = 1.00136061; return;}
784  if (runno >= 400 && runno <= 499) {scale = 1.00135776; return;}
785  if (runno >= 500 && runno <= 599) {scale = 1.00118666; return;}
786  if (runno >= 600 && runno <= 699) {scale = 1.0011346 ; return;}
787  if (runno >= 700) {
788  B2ERROR("scale_momenta not ready for this exp,run "
789  << expno << "," << runno);
790  }
791  } else if (expno == 37) {
792  if (runno >= 0 && runno <= 99) {scale = 1.00076522 ; return;}
793  if (runno >= 100 && runno <= 199) {scale = 1.000875154; return;}
794  if (runno >= 200 && runno <= 299) {scale = 1.000946763; return;}
795  if (runno >= 300 && runno <= 399) {scale = 1.000868444; return;}
796  if (runno >= 400 && runno <= 499) {scale = 1.000781409; return;}
797  if (runno >= 500 && runno <= 599) {scale = 1.000781171; return;}
798  if (runno >= 600 && runno <= 699) {scale = 1.000857962; return;}
799  if (runno >= 700 && runno <= 799) {scale = 1.000756082; return;}
800  if (runno >= 800 && runno <= 899) {scale = 1.000727355; return;}
801  if (runno >= 900 && runno <= 999) {scale = 1.000740236; return;}
802  if (runno >= 1000 && runno <= 1099) {scale = 1.000499606; return;}
803  if (runno >= 1100 && runno <= 1199) {scale = 1.000481664; return;}
804  if (runno >= 1200 && runno <= 1299) {scale = 1.000706924; return;}
805  if (runno >= 1300 && runno <= 1399) {scale = 1.000673738; return;}
806  if (runno >= 1400 && runno <= 1499) {scale = 1.000662648; return;}
807  if (runno >= 1500 && runno <= 1599) {scale = 1.000671198; return;}
808  if (runno >= 1600 && runno <= 1699) {scale = 1.000604364; return;}
809  if (runno >= 1700 && runno <= 1799) {scale = 1.000717372; return;}
810  if (runno >= 1800 && runno <= 1899) {scale = 1.000512399; return;}
811  if (runno >= 1900 && runno <= 1999) {scale = 1.000436958; return;}
812  if (runno >= 2000) {
813  B2ERROR("scale_momenta not ready for this exp,run "
814  << expno << "," << runno);
815  }
816  } else if (expno == 39) {
817  if (runno >= 0 && runno <= 99) {scale = 1.000504342; return;}
818  if (runno >= 100 && runno <= 199) {scale = 1.000704544; return;}
819  if (runno >= 200 && runno <= 299) {scale = 1.00094335 ; return;}
820  if (runno >= 300 && runno <= 399) {scale = 1.000928819; return;}
821  if (runno >= 400 && runno <= 499) {scale = 1.000884638; return;}
822  if (runno >= 500 && runno <= 599) {scale = 1.00083459 ; return;}
823  if (runno >= 600 && runno <= 699) {scale = 1.000767604; return;}
824  if (runno >= 700 && runno <= 799) {scale = 1.000882219; return;}
825  if (runno >= 800 && runno <= 899) {scale = 1.000781437; return;}
826  if (runno >= 900 && runno <= 999) {scale = 1.000853168; return;}
827  if (runno >= 1000 && runno <= 1099) {scale = 1.000926527; return;}
828  if (runno >= 1100 && runno <= 1199) {scale = 1.000942882; return;}
829  if (runno >= 1200 && runno <= 1299) {scale = 1.000932802; return;}
830  if (runno >= 1300 && runno <= 1399) {scale = 1.000898892; return;}
831  if (runno >= 1400) {
832  B2ERROR("scale_momenta not ready for this exp,run "
833  << expno << "," << runno);
834  }
835  } else if (expno == 41) {
836  if (runno >= 0 && runno <= 99) {scale = 1.00178427; return;}
837  if (runno >= 100 && runno <= 199) {scale = 1.00188559; return;}
838  if (runno >= 200 && runno <= 299) {scale = 1.0019292 ; return;}
839  if (runno >= 300 && runno <= 399) {scale = 1.00196352; return;}
840  if (runno >= 400 && runno <= 499) {scale = 1.0019078 ; return;}
841  if (runno >= 500 && runno <= 599) {scale = 1.00185598; return;}
842  if (runno >= 600 && runno <= 699) {scale = 1.00191314; return;}
843  if (runno >= 700 && runno <= 799) {scale = 1.00179647; return;}
844  if (runno >= 800 && runno <= 899) {scale = 1.00189776; return;}
845  if (runno >= 900 && runno <= 999) {scale = 1.00184798; return;}
846  if (runno >= 1000 && runno <= 1099) {scale = 1.00177963; return;}
847  if (runno >= 1100 && runno <= 1199) {scale = 1.00176408; return;}
848  if (runno >= 1200 && runno <= 1299) {scale = 1.00171371; return;}
849  if (runno >= 1300) {
850  B2ERROR("scale_momenta not ready for this exp,run "
851  << expno << "," << runno);
852  }
853  } else if (expno == 43) {
854  if (runno >= 0 && runno <= 99) {scale = 1.00142307; return;}
855  if (runno >= 100 && runno <= 199) {scale = 1.000979455; return;}
856  if (runno >= 200 && runno <= 299) {scale = 1.000974458; return;}
857  if (runno >= 300 && runno <= 399) {scale = 1.00103301; return;}
858  if (runno >= 400 && runno <= 499) {scale = 1.001111994; return;}
859  if (runno >= 500 && runno <= 599) {scale = 1.00100635; return;}
860  if (runno >= 600 && runno <= 699) {scale = 1.00105078; return;}
861  if (runno >= 700 && runno <= 799) {scale = 1.00103593; return;}
862  if (runno >= 800 && runno <= 899) {scale = 1.00105158; return;}
863  if (runno >= 900 && runno <= 999) {scale = 1.000955608; return;}
864  if (runno >= 1000 && runno <= 1099) {scale = 1.00099199; return;}
865  if (runno >= 1100 && runno <= 1199) {scale = 1.0011439; return;}
866  if (runno >= 1200) {
867  B2ERROR("scale_momenta not ready for this exp,run "
868  << expno << "," << runno);
869  }
870  } else if (expno == 45) {
871  if (runno >= 0 && runno <= 99) {scale = 1.00126261; return;}
872  if (runno >= 100 && runno <= 199) {scale = 1.00138601; return;}
873  if (runno >= 200 && runno <= 299) {scale = 1.00135372; return;}
874  if (runno >= 300 && runno <= 399) {scale = 1.00141286; return;}
875  if (runno >= 400 && runno <= 499) {scale = 1.00147822; return;}
876  if (runno >= 500) {
877  B2ERROR("scale_momenta not ready for this exp,run "
878  << expno << "," << runno);
879  }
880  } else if (expno == 47) {
881  if (runno >= 0 && runno <= 99) {scale = 1.00156977; return;}
882  if (runno >= 100 && runno <= 199) {scale = 1.00155614; return;}
883  if (runno >= 200 && runno <= 299) {scale = 1.0016555; return;}
884  if (runno >= 300 && runno <= 399) {scale = 1.00167046; return;}
885  if (runno >= 400 && runno <= 499) {scale = 1.00168705; return;}
886  if (runno >= 500 && runno <= 599) {scale = 1.00169555; return;}
887  if (runno >= 600 && runno <= 699) {scale = 1.00175653; return;}
888  if (runno >= 700 && runno <= 799) {scale = 1.00174358; return;}
889  if (runno >= 800 && runno <= 899) {scale = 1.00174004; return;}
890  if (runno >= 900) {
891  B2ERROR("scale_momenta not ready for this exp,run "
892  << expno << "," << runno);
893  }
894  } else if (expno == 49) {
895  if (runno >= 0 && runno <= 99) {scale = 1.00158837; return;}
896  if (runno >= 100 && runno <= 199) {scale = 1.00163884; return;}
897  if (runno >= 200 && runno <= 299) {scale = 1.00160595; return;}
898  if (runno >= 300 && runno <= 399) {scale = 1.00149916; return;}
899  if (runno >= 400 && runno <= 499) {scale = 1.0014956 ; return;}
900  if (runno >= 500 && runno <= 599) {scale = 1.00156212; return;}
901  if (runno >= 600 && runno <= 699) {scale = 1.00121868; return;}
902  if (runno >= 700 && runno <= 799) {scale = 1.00134613; return;}
903  if (runno >= 800 && runno <= 899) {scale = 1.00138985; return;}
904  if (runno >= 900 && runno <= 999) {scale = 1.00129356; return;}
905  if (runno >= 1000 && runno <= 1099) {scale = 1.00119732; return;}
906  if (runno >= 1100 && runno <= 1199) {scale = 1.00121481; return;}
907  if (runno >= 1200 && runno <= 1299) {scale = 1.00121108; return;}
908  if (runno >= 1300) {
909  B2ERROR("scale_momenta not ready for this exp,run "
910  << expno << "," << runno);
911  }
912  } else if (expno == 51) {
913  if (runno >= 0 && runno <= 99) {scale = 1.00160252; return;}
914  if (runno >= 100 && runno <= 199) {scale = 1.00156099; return;}
915  if (runno >= 200 && runno <= 299) {scale = 1.00154760; return;}
916  if (runno >= 300 && runno <= 399) {scale = 1.00146316; return;}
917  if (runno >= 400 && runno <= 499) {scale = 1.00145525; return;}
918  if (runno >= 500 && runno <= 599) {scale = 1.00134429; return;}
919  if (runno >= 600 && runno <= 699) {scale = 1.00135581; return;}
920  if (runno >= 700 && runno <= 799) {scale = 1.00134382; return;}
921  if (runno >= 800 && runno <= 899) {scale = 1.00126462; return;}
922  if (runno >= 900 && runno <= 999) {scale = 1.00130752; return;}
923  if (runno >= 1000 && runno <= 1099) {scale = 1.00130452; return;}
924  if (runno >= 1100 && runno <= 1199) {scale = 1.00131440; return;}
925  if (runno >= 1200 && runno <= 1299) {scale = 1.00130864; return;}
926  if (runno >= 1300 && runno <= 1399) {scale = 1.00105290; return;}
927  if (runno >= 1400 && runno <= 1499) {scale = 1.00126645; return;}
928  if (runno >= 1500 && runno <= 1599) {scale = 1.00126383; return;}
929  if (runno >= 1600 && runno <= 1699) {scale = 1.00141111; return;}
930  if (runno >= 1700 && runno <= 1799) {scale = 1.00126220; return;}
931  if (runno >= 1800 && runno <= 1899) {scale = 1.00105098; return;}
932  if (runno >= 1900) {
933  B2ERROR("scale_momenta not ready for this exp,run "
934  << expno << "," << runno);
935  }
936  } else if (expno == 53) {
937  if (runno >= 0 && runno <= 99) {scale = 1.0011516; return;}
938  if (runno >= 100 && runno <= 199) {scale = 1.00115527; return;}
939  if (runno >= 200 && runno <= 299) {scale = 1.00114844; return;}
940  if (runno >= 300) {
941  B2ERROR("scale_momenta not ready for this exp,run "
942  << expno << "," << runno);
943  }
944  } else if (expno == 55) {
945  if (runno >= 0 && runno <= 99) {scale = 1.00114284; return;}
946  if (runno >= 100 && runno <= 199) {scale = 1.00111458; return;}
947  if (runno >= 200 && runno <= 299) {scale = 1.00109686; return;}
948  if (runno >= 300 && runno <= 399) {scale = 1.00119475; return;}
949  if (runno >= 400 && runno <= 499) {scale = 1.00117818; return;}
950  if (runno >= 500 && runno <= 599) {scale = 1.00115789; return;}
951  if (runno >= 600 && runno <= 699) {scale = 1.00122261; return;}
952  if (runno >= 700 && runno <= 799) {scale = 1.00118454; return;}
953  if (runno >= 800 && runno <= 899) {scale = 1.00118042; return;}
954  if (runno >= 900 && runno <= 999) {scale = 1.00124759; return;}
955  if (runno >= 1000 && runno <= 1099) {scale = 1.00128055; return;}
956  if (runno >= 1100 && runno <= 1199) {scale = 1.00119131; return;}
957  if (runno >= 1200 && runno <= 1299) {scale = 1.00122238; return;}
958  if (runno >= 1300 && runno <= 1399) {scale = 1.00129538; return;}
959  if (runno >= 1400 && runno <= 1499) {scale = 1.00130387; return;}
960  if (runno >= 1500 && runno <= 1599) {scale = 1.00130858; return;}
961  if (runno >= 1600 && runno <= 1699) {scale = 1.00111854; return;}
962  if (runno >= 1700 && runno <= 1799) {scale = 1.00136261; return;}
963  if (runno >= 1800) {
964  B2ERROR("scale_momenta not ready for this exp,run "
965  << expno << "," << runno);
966  }
967  } else if (expno == 61) {
968  if (runno >= 0 && runno <= 99) {scale = 1.0009992; return;}
969  if (runno >= 100 && runno <= 199) {scale = 1.00113704; return;}
970  if (runno >= 200 && runno <= 299) {scale = 1.00129904; return;}
971  if (runno >= 300 && runno <= 399) {scale = 1.00141879; return;}
972  if (runno >= 400 && runno <= 499) {scale = 1.00146707; return;}
973  if (runno >= 500 && runno <= 599) {scale = 1.00150101; return;}
974  if (runno >= 600 && runno <= 699) {scale = 1.00147322; return;}
975  if (runno >= 700 && runno <= 799) {scale = 1.00153929; return;}
976  if (runno >= 800 && runno <= 899) {scale = 1.00159997; return;}
977  if (runno >= 900 && runno <= 999) {scale = 1.00164032; return;}
978  if (runno >= 1000 && runno <= 1099) {scale = 1.00165878; return;}
979  if (runno >= 1100 && runno <= 1199) {scale = 1.00163475; return;}
980  if (runno >= 1200 && runno <= 1207) {scale = 1.00166193; return;}
981  if (runno >= 1208 && runno <= 1299) {scale = 1.00235824; return;}
982  if (runno >= 1300 && runno <= 1399) {scale = 1.00242282; return;}
983  if (runno >= 1400) {
984  B2ERROR("scale_momenta not ready for this exp,run "
985  << expno << "," << runno);
986  }
987  } else if (expno == 65) {
988  if (runno <= 999) {
989  B2ERROR("scale_momenta not ready for this exp,run "
990  << expno << "," << runno);
991  }
992  if (runno >= 1000 && runno <= 1336) {scale = 1.00145234; return;}
993  if (runno >= 1336) {
994  B2ERROR("scale_momenta not ready for this exp,run "
995  << expno << "," << runno);
996  }
997  } else
998  B2ERROR("scale_momenta mode=2 not ready for exp " << expno);
999  }
1000  return;
1001  }
1002 
1003 //=====================================================================
1004  void B2BIIFixMdstModule::scale_momenta_set_v2(const int mode, const int expno,
1005  const int runno, double& scale)
1006  {
1007 //=====================================================================
1008 
1009  //for e15 mdst processed with b20020405
1010 
1011  scale = 1.;
1012 
1013  if (mode == 1) {
1014  B2ERROR("scale_momenta mode=1 not ready for exp " << expno);
1015  return;
1016  }
1017 
1018  if (mode == 2) {
1019  if (expno == 7) {
1020 
1021  } else if (expno == 9) {
1022 
1023  } else if (expno == 11) {
1024 
1025  } else if (expno == 13) {
1026 
1027  } else if (expno == 15) {
1028 
1029  } else if (expno == 17) {
1030 
1031  } else if (expno == 19) {
1032  B2ERROR("scale_momenta not ready for this exp,run "
1033  << expno << "," << runno);
1034 
1035  } else if (expno == 21) {
1036  B2ERROR("scale_momenta not ready for this exp,run "
1037  << expno << "," << runno);
1038 
1039  } else if (expno == 23) {
1040  B2ERROR("scale_momenta not ready for this exp,run "
1041  << expno << "," << runno);
1042 
1043  } else if (expno == 25) {
1044  B2ERROR("scale_momenta not ready for this exp,run "
1045  << expno << "," << runno);
1046 
1047  } else if (expno == 27) {
1048  B2ERROR("scale_momenta not ready for this exp,run "
1049  << expno << "," << runno);
1050 
1051  } else if (expno == 31) {
1052  if (runno >= 0 && runno <= 137) {
1053  B2ERROR("scale_momenta not ready for this exp,run "
1054  << expno << "," << runno);
1055  }
1056  if (runno >= 138 && runno <= 199) {scale = 1.000931841; return;}
1057  if (runno >= 200 && runno <= 299) {scale = 1.000916397; return;}
1058  if (runno >= 300 && runno <= 399) {scale = 1.00108023 ; return;}
1059  if (runno >= 400 && runno <= 499) {scale = 1.00118662 ; return;}
1060  if (runno >= 500 && runno <= 599) {scale = 1.00117739 ; return;}
1061  if (runno >= 600 && runno <= 699) {scale = 1.00119542 ; return;}
1062  if (runno >= 700 && runno <= 799) {scale = 1.00110396 ; return;}
1063  if (runno >= 800 && runno <= 899) {scale = 1.00109603 ; return;}
1064  if (runno >= 900 && runno <= 999) {scale = 1.00112795 ; return;}
1065  if (runno >= 1000 && runno <= 1099) {scale = 1.00118365 ; return;}
1066  if (runno >= 1100 && runno <= 1199) {scale = 1.00142214 ; return;}
1067  if (runno >= 1200 && runno <= 1299) {scale = 1.00133150 ; return;}
1068  if (runno >= 1300 && runno <= 1399) {scale = 1.00132831 ; return;}
1069  if (runno >= 1400 && runno <= 1499) {scale = 1.00136554 ; return;}
1070  if (runno >= 1500 && runno <= 1599) {scale = 1.00141187 ; return;}
1071  if (runno >= 1600 && runno <= 1699) {scale = 1.00136628 ; return;}
1072  if (runno >= 1700 && runno <= 1799) {scale = 1.00139273 ; return;}
1073  if (runno >= 1800) {
1074  B2ERROR("scale_momenta not ready for this exp,run "
1075  << expno << "," << runno);
1076  }
1077  } else if (expno == 33) {
1078  if (runno >= 0 && runno <= 99) {scale = 1.00149319; return;}
1079  if (runno >= 100 && runno <= 199) {scale = 1.00150915; return;}
1080  if (runno >= 200 && runno <= 299) {scale = 1.00173040; return;}
1081  if (runno >= 300 && runno <= 399) {scale = 1.00150449; return;}
1082  if (runno >= 400 && runno <= 499) {scale = 1.00161519; return;}
1083  if (runno >= 500 && runno <= 599) {scale = 1.00151670; return;}
1084  if (runno >= 600 && runno <= 699) {scale = 1.00164347; return;}
1085  if (runno >= 700 && runno <= 799) {scale = 1.00164165; return;}
1086  if (runno >= 800 && runno <= 899) {scale = 1.00161369; return;}
1087  if (runno >= 900) {
1088  B2ERROR("scale_momenta not ready for this exp,run "
1089  << expno << "," << runno);
1090  }
1091  } else if (expno == 35) {
1092  if (runno >= 0 && runno <= 99) {scale = 1.00147034; return;}
1093  if (runno >= 100 && runno <= 199) {scale = 1.00148523; return;}
1094  if (runno >= 200 && runno <= 299) {scale = 1.00153372; return;}
1095  if (runno >= 300 && runno <= 399) {scale = 1.00148256; return;}
1096  if (runno >= 400 && runno <= 499) {scale = 1.00144902; return;}
1097  if (runno >= 500 && runno <= 599) {scale = 1.00131501; return;}
1098  if (runno >= 600 && runno <= 699) {scale = 1.00126371; return;}
1099  if (runno >= 700) {
1100  B2ERROR("scale_momenta not ready for this exp,run "
1101  << expno << "," << runno);
1102  }
1103  } else if (expno == 37) {
1104  if (runno >= 0 && runno <= 99) {scale = 1.000916277; return;}
1105  if (runno >= 100 && runno <= 199) {scale = 1.001035310; return;}
1106  if (runno >= 200 && runno <= 299) {scale = 1.001123403; return;}
1107  if (runno >= 300 && runno <= 399) {scale = 1.001017718; return;}
1108  if (runno >= 400 && runno <= 499) {scale = 1.000932890; return;}
1109  if (runno >= 500 && runno <= 599) {scale = 1.000928479; return;}
1110  if (runno >= 600 && runno <= 699) {scale = 1.000997938; return;}
1111  if (runno >= 700 && runno <= 799) {scale = 1.000899663; return;}
1112  if (runno >= 800 && runno <= 899) {scale = 1.000860910; return;}
1113  if (runno >= 900 && runno <= 999) {scale = 1.000882920; return;}
1114  if (runno >= 1000 && runno <= 1099) {scale = 1.000616966; return;}
1115  if (runno >= 1100 && runno <= 1199) {scale = 1.000613018; return;}
1116  if (runno >= 1200 && runno <= 1299) {scale = 1.000832338; return;}
1117  if (runno >= 1300 && runno <= 1399) {scale = 1.000803640; return;}
1118  if (runno >= 1400 && runno <= 1499) {scale = 1.000770454; return;}
1119  if (runno >= 1500 && runno <= 1599) {scale = 1.000786608; return;}
1120  if (runno >= 1600 && runno <= 1699) {scale = 1.000718089; return;}
1121  if (runno >= 1700 && runno <= 1799) {scale = 1.000826042; return;}
1122  if (runno >= 1800 && runno <= 1899) {scale = 1.000638150; return;}
1123  if (runno >= 1900 && runno <= 1999) {scale = 1.000529173; return;}
1124  if (runno >= 2000) {
1125  B2ERROR("scale_momenta not ready for this exp,run "
1126  << expno << "," << runno);
1127  }
1128  } else if (expno == 39) {
1129  if (runno >= 0 && runno <= 99) {scale = 1.000610857; return;}
1130  if (runno >= 100 && runno <= 199) {scale = 1.000838583; return;}
1131  if (runno >= 200 && runno <= 299) {scale = 1.00105918 ; return;}
1132  if (runno >= 300 && runno <= 399) {scale = 1.00105841 ; return;}
1133  if (runno >= 400 && runno <= 499) {scale = 1.001025523; return;}
1134  if (runno >= 500 && runno <= 599) {scale = 1.000967373; return;}
1135  if (runno >= 600 && runno <= 699) {scale = 1.000898585; return;}
1136  if (runno >= 700 && runno <= 799) {scale = 1.001003199; return;}
1137  if (runno >= 800 && runno <= 899) {scale = 1.000897072; return;}
1138  if (runno >= 900 && runno <= 999) {scale = 1.000972551; return;}
1139  if (runno >= 1000 && runno <= 1099) {scale = 1.001044677; return;}
1140  if (runno >= 1100 && runno <= 1199) {scale = 1.00106451 ; return;}
1141  if (runno >= 1200 && runno <= 1299) {scale = 1.00108570 ; return;}
1142  if (runno >= 1300 && runno <= 1399) {scale = 1.00102381 ; return;}
1143  if (runno >= 1400) {
1144  B2ERROR("scale_momenta not ready for this exp,run "
1145  << expno << "," << runno);
1146  }
1147  } else if (expno == 41) {
1148  if (runno >= 0 && runno <= 99) {scale = 1.00189378; return;}
1149  if (runno >= 100 && runno <= 199) {scale = 1.00197304; return;}
1150  if (runno >= 200 && runno <= 299) {scale = 1.00204049; return;}
1151  if (runno >= 300 && runno <= 399) {scale = 1.00205065; return;}
1152  if (runno >= 400 && runno <= 499) {scale = 1.00199205; return;}
1153  if (runno >= 500 && runno <= 599) {scale = 1.00195618; return;}
1154  if (runno >= 600 && runno <= 699) {scale = 1.00200889; return;}
1155  if (runno >= 700 && runno <= 799) {scale = 1.00190365; return;}
1156  if (runno >= 800 && runno <= 899) {scale = 1.00204192; return;}
1157  if (runno >= 900 && runno <= 999) {scale = 1.00196542; return;}
1158  if (runno >= 1000 && runno <= 1099) {scale = 1.00189706; return;}
1159  if (runno >= 1100 && runno <= 1199) {scale = 1.00187422; return;}
1160  if (runno >= 1200 && runno <= 1299) {scale = 1.00183714; return;}
1161  if (runno >= 1300) {
1162  B2ERROR("scale_momenta not ready for this exp,run "
1163  << expno << "," << runno);
1164  }
1165  } else if (expno == 43) {
1166  if (runno >= 0 && runno <= 99) {scale = 1.00151737; return;}
1167  if (runno >= 100 && runno <= 199) {scale = 1.00110489; return;}
1168  if (runno >= 200 && runno <= 299) {scale = 1.00108144; return;}
1169  if (runno >= 300 && runno <= 399) {scale = 1.00114918; return;}
1170  if (runno >= 400 && runno <= 499) {scale = 1.00122723; return;}
1171  if (runno >= 500 && runno <= 599) {scale = 1.00111069; return;}
1172  if (runno >= 600 && runno <= 699) {scale = 1.00115667; return;}
1173  if (runno >= 700 && runno <= 799) {scale = 1.00113759; return;}
1174  if (runno >= 800 && runno <= 899) {scale = 1.00115609; return;}
1175  if (runno >= 900 && runno <= 999) {scale = 1.00105426; return;}
1176  //tentative for quality check of 5S mdst in 2009 Ang.-Sep.
1177  // if (runno>=1000 && runno <=1034) {scale = 1.00099199; return;}
1178  // if (runno>=1035 && runno <=1099) {scale = 1.00111222; return;}
1179  if (runno >= 1000 && runno <= 1099) {scale = 1.00111210; return;}
1180  if (runno >= 1100 && runno <= 1199) {scale = 1.00123104; return;}
1181  if (runno >= 1200) {
1182  B2ERROR("scale_momenta not ready for this exp,run "
1183  << expno << "," << runno);
1184  }
1185  } else if (expno == 45) {
1186  if (runno >= 0 && runno <= 99) {scale = 1.00136477; return;}
1187  if (runno >= 100 && runno <= 199) {scale = 1.00151600; return;}
1188  if (runno >= 200 && runno <= 299) {scale = 1.00146757; return;}
1189  if (runno >= 300 && runno <= 399) {scale = 1.00153299; return;}
1190  if (runno >= 400 && runno <= 499) {scale = 1.00159018; return;}
1191  if (runno >= 500) {
1192  B2ERROR("scale_momenta not ready for this exp,run "
1193  << expno << "," << runno);
1194  }
1195  } else if (expno == 47) {
1196  if (runno >= 0 && runno <= 99) {scale = 1.00166672; return;}
1197  if (runno >= 100 && runno <= 199) {scale = 1.00165120; return;}
1198  if (runno >= 200 && runno <= 299) {scale = 1.00175597; return;}
1199  if (runno >= 300 && runno <= 399) {scale = 1.00177319; return;}
1200  if (runno >= 400 && runno <= 499) {scale = 1.00179552; return;}
1201  if (runno >= 500 && runno <= 599) {scale = 1.00179413; return;}
1202  if (runno >= 600 && runno <= 699) {scale = 1.00186237; return;}
1203  if (runno >= 700 && runno <= 799) {scale = 1.00183016; return;}
1204  if (runno >= 800 && runno <= 899) {scale = 1.00184324; return;}
1205  if (runno >= 900) {
1206  B2ERROR("scale_momenta not ready for this exp,run "
1207  << expno << "," << runno);
1208  }
1209  } else if (expno == 49) {
1210  if (runno >= 0 && runno <= 99) {scale = 1.00171645; return;}
1211  if (runno >= 100 && runno <= 199) {scale = 1.00177728; return;}
1212  if (runno >= 200 && runno <= 299) {scale = 1.00173301; return;}
1213  if (runno >= 300 && runno <= 399) {scale = 1.00162075; return;}
1214  if (runno >= 400 && runno <= 499) {scale = 1.00163153; return;}
1215  if (runno >= 500 && runno <= 599) {scale = 1.00168559; return;}
1216  if (runno >= 600 && runno <= 699) {scale = 1.00139227; return;}
1217  if (runno >= 700 && runno <= 799) {scale = 1.00148583; return;}
1218  if (runno >= 800 && runno <= 899) {scale = 1.00150403; return;}
1219  if (runno >= 900 && runno <= 999) {scale = 1.00142759; return;}
1220  if (runno >= 1000 && runno <= 1099) {scale = 1.00134573; return;}
1221  if (runno >= 1100 && runno <= 1199) {scale = 1.00138313; return;}
1222  if (runno >= 1200 && runno <= 1299) {scale = 1.00151369; return;}
1223  if (runno >= 1300) {
1224  B2ERROR("scale_momenta not ready for this exp,run "
1225  << expno << "," << runno);
1226  }
1227  } else if (expno == 51) {
1228  if (runno >= 0 && runno <= 99) {scale = 1.00165035; return;}
1229  if (runno >= 100 && runno <= 199) {scale = 1.00161504; return;}
1230  if (runno >= 200 && runno <= 299) {scale = 1.00160162; return;}
1231  if (runno >= 300 && runno <= 399) {scale = 1.00152725; return;}
1232  if (runno >= 400 && runno <= 499) {scale = 1.00149943; return;}
1233  if (runno >= 500 && runno <= 599) {scale = 1.00141294; return;}
1234  if (runno >= 600 && runno <= 699) {scale = 1.00140154; return;}
1235  if (runno >= 700 && runno <= 799) {scale = 1.00140759; return;}
1236  if (runno >= 800 && runno <= 899) {scale = 1.00133671; return;}
1237  if (runno >= 900 && runno <= 999) {scale = 1.00136792; return;}
1238  if (runno >= 1000 && runno <= 1099) {scale = 1.00135251; return;}
1239  if (runno >= 1100 && runno <= 1199) {scale = 1.00138229; return;}
1240  if (runno >= 1200 && runno <= 1299) {scale = 1.00134938; return;}
1241  if (runno >= 1300 && runno <= 1399) {scale = 1.00106240; return;}
1242  if (runno >= 1400 && runno <= 1499) {scale = 1.00132666; return;}
1243  if (runno >= 1500 && runno <= 1599) {scale = 1.00132654; return;}
1244  if (runno >= 1600 && runno <= 1699) {scale = 1.00146619; return;}
1245  if (runno >= 1700 && runno <= 1799) {scale = 1.00131902; return;}
1246  if (runno >= 1800 && runno <= 1899) {scale = 1.00114243; return;}
1247  if (runno >= 1900) {
1248  B2ERROR("scale_momenta not ready for this exp,run "
1249  << expno << "," << runno);
1250  }
1251  } else if (expno == 53) {
1252  if (runno >= 0 && runno <= 99) {scale = 1.00125475; return;}
1253  if (runno >= 100 && runno <= 199) {scale = 1.00124954; return;}
1254  if (runno >= 200 && runno <= 299) {scale = 1.00122914; return;}
1255  if (runno >= 300) {
1256  B2ERROR("scale_momenta not ready for this exp,run "
1257  << expno << "," << runno);
1258  }
1259  } else if (expno == 55) {
1260  if (runno >= 0 && runno <= 99) {scale = 1.00119352; return;}
1261  if (runno >= 100 && runno <= 199) {scale = 1.00117130; return;}
1262  if (runno >= 200 && runno <= 299) {scale = 1.00115825; return;}
1263  if (runno >= 300 && runno <= 399) {scale = 1.00125005; return;}
1264  if (runno >= 400 && runno <= 499) {scale = 1.00124720; return;}
1265  if (runno >= 500 && runno <= 599) {scale = 1.00122234; return;}
1266  if (runno >= 600 && runno <= 699) {scale = 1.00128709; return;}
1267  if (runno >= 700 && runno <= 799) {scale = 1.00123081; return;}
1268  if (runno >= 800 && runno <= 899) {scale = 1.00124198; return;}
1269  if (runno >= 900 && runno <= 999) {scale = 1.00131118; return;}
1270  if (runno >= 1000 && runno <= 1099) {scale = 1.00132496; return;}
1271  if (runno >= 1100 && runno <= 1199) {scale = 1.00126186; return;}
1272  if (runno >= 1200 && runno <= 1299) {scale = 1.00127849; return;}
1273  if (runno >= 1300 && runno <= 1399) {scale = 1.00135312; return;}
1274  if (runno >= 1400 && runno <= 1499) {scale = 1.00136637; return;}
1275  if (runno >= 1500 && runno <= 1599) {scale = 1.00136270; return;}
1276  if (runno >= 1600 && runno <= 1699) {scale = 1.00118422; return;}
1277  if (runno >= 1700 && runno <= 1799) {scale = 1.00142667; return;}
1278  if (runno >= 1800) {
1279  B2ERROR("scale_momenta not ready for this exp,run "
1280  << expno << "," << runno);
1281  }
1282  } else if (expno == 61) {
1283  if (runno >= 0 && runno <= 99) {scale = 1.00103013; return;}
1284  if (runno >= 100 && runno <= 199) {scale = 1.00116185; return;}
1285  if (runno >= 200 && runno <= 299) {scale = 1.00133560; return;}
1286  if (runno >= 300 && runno <= 399) {scale = 1.00145027; return;}
1287  if (runno >= 400 && runno <= 499) {scale = 1.00147949; return;}
1288  if (runno >= 500 && runno <= 599) {scale = 1.00151022; return;}
1289  if (runno >= 600 && runno <= 699) {scale = 1.00150439; return;}
1290  if (runno >= 700 && runno <= 799) {scale = 1.00155006; return;}
1291  if (runno >= 800 && runno <= 899) {scale = 1.00162396; return;}
1292  if (runno >= 900 && runno <= 999) {scale = 1.00168542; return;}
1293  if (runno >= 1000 && runno <= 1099) {scale = 1.00168249; return;}
1294  if (runno >= 1100 && runno <= 1207) {scale = 1.00166891; return;}
1295  if (runno >= 1208 && runno <= 1299) {scale = 1.00249956; return;}
1296  if (runno >= 1300 && runno <= 1399) {scale = 1.00255134; return;}
1297  if (runno >= 1400) {
1298  B2ERROR("scale_momenta not ready for this exp,run "
1299  << expno << "," << runno);
1300  }
1301  } else if (expno == 63) {
1302  if (runno >= 0 && runno <= 99) {scale = 1.00129667; return;}
1303  if (runno >= 100 && runno <= 199) {scale = 1.00123725; return;}
1304  if (runno >= 200 && runno <= 299) {scale = 1.00126795; return;}
1305  if (runno >= 300 && runno <= 399) {scale = 1.00122458; return;}
1306  if (runno >= 400 && runno <= 499) {scale = 1.00116489; return;}
1307  if (runno >= 500 && runno <= 599) {scale = 1.00116968; return;}
1308  if (runno >= 600 && runno <= 699) {scale = 1.000918379; return;}
1309  if (runno >= 700 && runno <= 799) {scale = 1.0010429; return;}
1310  if (runno >= 800) {
1311  B2ERROR("scale_momenta not ready for this exp,run "
1312  << expno << "," << runno);
1313  }
1314  } else if (expno == 65) {
1315  if (runno >= 0 && runno <= 99) {scale = 1.00116975; return;}
1316  if (runno >= 100 && runno <= 199) {scale = 1.00111926; return;}
1317  if (runno >= 200 && runno <= 299) {scale = 1.00110162; return;}
1318  if (runno >= 300 && runno <= 399) {scale = 1.00109524; return;}
1319  if (runno >= 400 && runno <= 499) {scale = 1.00106913; return;}
1320  if (runno >= 500 && runno <= 599) {scale = 1.00110941; return;}
1321  if (runno >= 600 && runno <= 699) {scale = 1.000897865; return;}
1322  if (runno >= 700 && runno <= 999) {scale = 1.00104385; return;}
1323  if (runno >= 1000 && runno <= 1299) {scale = 1.000876489; return;}
1324  if (runno >= 1000) {
1325  B2ERROR("scale_momenta not ready for this exp,run "
1326  << expno << "," << runno);
1327  }
1328  } else if (expno == 67) {
1329  if (runno >= 0 && runno <= 199) {scale = 1.000826364; return;}
1330  if (runno >= 200 && runno <= 299) {scale = 1.000836576; return;}
1331  if (runno >= 300 && runno <= 399) {scale = 1.000904815; return;}
1332  if (runno >= 400 && runno <= 499) {scale = 1.000966045; return;}
1333  if (runno >= 500 && runno <= 599) {scale = 1.000988147; return;}
1334  if (runno >= 600 && runno <= 699) {scale = 1.000988147; return;}
1335  if (runno >= 700 && runno <= 742) {scale = 1.000837414; return;}
1336  if (runno >= 1000 && runno <= 1099) {scale = 1.000984865; return;}
1337  if (runno >= 1100 && runno <= 1123) {scale = 1.00105248 ; return;}
1338  if (runno >= 1124) {
1339  B2ERROR("scale_momenta not ready for this exp,run "
1340  << expno << "," << runno);
1341  }
1342  } else if (expno == 69) {
1343  if (runno >= 0 && runno <= 99) {scale = 1.000791450; return;}
1344  if (runno >= 100 && runno <= 199) {scale = 1.000891748; return;}
1345  if (runno >= 200 && runno <= 299) {scale = 1.000866165; return;}
1346  if (runno >= 300 && runno <= 399) {scale = 1.000838834; return;}
1347  if (runno >= 400 && runno <= 499) {scale = 1.000811878; return;}
1348  if (runno >= 500 && runno <= 599) {scale = 1.000779810; return;}
1349  if (runno >= 600 && runno <= 699) {scale = 1.000799086; return;}
1350  if (runno >= 700 && runno <= 799) {scale = 1.000833797; return;}
1351  if (runno >= 800 && runno <= 899) {scale = 1.000875203; return;}
1352  if (runno >= 900 && runno <= 999) {scale = 1.000891998; return;}
1353  if (runno >= 1000 && runno <= 1099) {scale = 1.000921074; return;}
1354  if (runno >= 1100 && runno <= 1199) {scale = 1.000900829; return;}
1355  if (runno >= 1200 && runno <= 1299) {scale = 1.000958405; return;}
1356  if (runno >= 1300 && runno <= 1399) {scale = 1.000836841; return;}
1357  if (runno >= 1400) {
1358  B2ERROR("scale_momenta not ready for this exp,run "
1359  << expno << "," << runno);
1360  }
1361  } else if (expno == 71) {
1362  if (runno >= 0 && runno <= 99) {scale = 1.000962999; return;}
1363  if (runno >= 100 && runno <= 199) {scale = 1.001478932; return;}
1364  if (runno >= 200 && runno <= 300) {scale = 1.001486524; return;}
1365  if (runno >= 301 && runno <= 384) {scale = 1.001430843; return;}
1366  if (runno >= 385 && runno <= 499) {scale = 1.001505696; return;}
1367  if (runno >= 500 && runno <= 599) {scale = 1.001523980; return;}
1368  if (runno >= 600 && runno <= 699) {scale = 1.001480830; return;}
1369  if (runno >= 1000 && runno <= 1013) {scale = 1.001480830; return;}
1370  if (runno >= 2000 && runno <= 2099) {scale = 1.001617882; return;}
1371  if (runno >= 2100 && runno <= 2199) {scale = 1.001644395; return;}
1372  if (runno >= 2200 && runno <= 2299) {scale = 1.001722184; return;}
1373  if (runno >= 700 && runno <= 999) {
1374  B2ERROR("scale_momenta not ready for this exp,run "
1375  << expno << "," << runno);
1376  }
1377  if (runno >= 1014 && runno <= 1999) {
1378  B2ERROR("scale_momenta not ready for this exp,run "
1379  << expno << "," << runno);
1380  }
1381  if (runno >= 2299) {
1382  B2ERROR("scale_momenta not ready for this exp,run "
1383  << expno << "," << runno);
1384  }
1385  } else if (expno == 73) {
1386  if (runno >= 0 && runno <= 99) {scale = 1.000721587; return;}
1387  if (runno >= 100 && runno <= 199) {scale = 1.000707089; return;}
1388  if (runno >= 200 && runno <= 299) {scale = 1.000722517; return;}
1389  if (runno >= 300 && runno <= 399) {scale = 1.000722517; return;} //nodata
1390  if (runno >= 400 && runno <= 499) {scale = 1.000750776; return;}
1391  if (runno >= 500 && runno <= 599) {scale = 1.000729771; return;}
1392  if (runno >= 600 && runno <= 699) {scale = 1.000751190; return;}
1393  if (runno >= 700 && runno <= 799) {scale = 1.000702455; return;}
1394  if (runno >= 800 && runno <= 899) {scale = 1.000771074; return;}
1395  if (runno >= 900 && runno <= 999) {scale = 1.000868463; return;}
1396  if (runno >= 1000) {
1397  B2ERROR("scale_momenta not ready for this exp,run "
1398  << expno << "," << runno);
1399  }
1400 
1401  } else
1402  B2ERROR("scale_momenta mode=2 not ready for exp " << expno);
1403  }
1404  return;
1405  }
1406 
1407 //=====================================================================
1408 
1409 // Scale values are obtained from cosmic data.
1410 //
1411 // [EXP]
1412 // EXP15: 20011205_2146
1413 // EXP : 20010507_0455
1414 // EXP7 : 20000517_1555
1415 // EXP7 : 20001015_1102
1416 // EXP9 : 20001228_1026
1417 // [MC]
1418 // 20011214_0817
1419 // 20010523_0725
1420 // 20001228_1026
1421 // 20000911_2205
1422 // 20000517_1555
1423 // 20000430_1200
1424 
1425 // SE_REMOVE_BELLE_HEADER=1 is used for debug. --> normally 0!!!
1426 //#define SE_REMOVE_BELLE_HEADER 0
1427 
1428 
1429 
1431 // Begin of scale_error() implementation
1433 
1434  static int SE_Message_Level;
1435  static int SE_Reprocess_Version = 0;
1438  typedef void (*cal_scale_error_func_t)(double scale[5], const double pt, const double tanl);
1441  struct cal_scale_error_func_set_t {
1442  cal_scale_error_func_t m_hadMC;
1443  cal_scale_error_func_t m_cosMC;
1444  cal_scale_error_func_t m_cosDATA;
1445  };
1446 
1448  static bool operator==(const cal_scale_error_func_set_t& lhs, const cal_scale_error_func_set_t& rhs)
1449  {
1450  return (lhs.m_hadMC == rhs.m_hadMC) && (lhs.m_cosMC == rhs.m_cosMC) && (lhs.m_cosDATA == rhs.m_cosDATA);
1451  }
1452 
1453  /*static bool operator!=(const cal_scale_error_func_set_t& lhs, const cal_scale_error_func_set_t& rhs)
1454  {
1455  return !(lhs == rhs);
1456  }*/
1457 
1459  static void null_scale(double[5], double, double)
1460  {
1461  return;
1462  }
1463 
1464  /***** *****/
1465  /***** misc functions *****/
1466  /***** *****/
1468  static void
1469  get_event_id(int* no_exp, int* no_run, int* no_evt, int* no_frm, int* expmc)
1470  {
1471  *no_exp = -1, *no_run = -1, *no_evt = -1, *no_frm = -1;
1472 
1473  belle_event* belle_event;
1474  belle_event = (struct belle_event*)BsGetEnt(BELLE_EVENT, 1, BBS_No_Index);
1475  if (belle_event) {
1476  *no_exp = belle_event->m_ExpNo;
1477  *no_run = belle_event->m_RunNo;
1478  *no_evt = belle_event->m_EvtNo & 0x0fffffff;
1479  *no_frm = (unsigned int)belle_event->m_EvtNo >> 28;
1480  *expmc = belle_event->m_ExpMC;
1481  }
1482  }
1483 
1485  static bool
1486  is_already_scaled(void)
1487  {
1488  Belle::Mdst_event_add_Manager& addmgr = Belle::Mdst_event_add_Manager::get_manager();
1489  if (addmgr.count() >= 1) {
1490 
1491  if (addmgr[0].flag_error() == 1) {
1492  if (SE_Message_Level >= 1) B2ERROR("scale_error: already applied");
1493  return true;
1494  } else {
1495  if (SE_Message_Level >= 2) B2ERROR("scale_error: to be applied");
1496  addmgr[0].flag_error(1);
1497  return false;
1498  }
1499 
1500  } else {
1501 
1502  static int first = 1;
1503  B2ERROR("scale_error: no Mdst_event_add");
1504  if (first) {
1505  B2ERROR("scale_error: analysis continues");
1506  B2ERROR("scale_error: scale_error will not be applied");
1507  first = 0;
1508  }
1509  return true;
1510  }
1511  }
1512 
1513 
1514  /***** *****/
1515  /***** misc math functions *****/
1516  /***** *****/
1518  inline double
1519  vfunc(const double x, const double x1, const double yc, const double a1, const double a2)
1520  {
1521  return x < x1 ? (x - x1) * a1 + yc :
1522  (x - x1) * a2 + yc ;
1523  }
1525  inline double
1526  cupfunc(const double x, const double x1, const double x2, const double yc, const double a1, const double a2)
1527  {
1528  return x < x1 ? (x - x1) * a1 + yc :
1529  x > x2 ? (x - x2) * a2 + yc : yc;
1530  }
1532  inline double
1533  rootfunc(const double x, const double x1, const double x2, const double yc, const double a1, const double a2)
1534  {
1535  return x < x1 ? (x - x1) * a1 + yc :
1536  x > x2 ? (x2 - x1) * a2 + yc : (x - x1) * a2 + yc;
1537  }
1538 
1540  inline double
1541  lambdafunc(const double x, const double x1, const double x2, const double yc, const double a1, const double a2, const double a3)
1542  {
1543  return x < x1 ? (x - x1) * a1 + yc :
1544  x < x2 ? (x - x1) * a2 + yc : (x - x2) * a3 + (x2 - x1) * a2 + yc;
1545  }
1546 
1547 
1548 
1549  /***** *****/
1550  /***** scaling parameters for EXP07-EXP23 *****/
1551  /***** *****/
1552 
1553 //
1554 // Scale error for Exp.7-23 Cosmic MC
1555 // old day by somebody
1556 //
1558  static void
1559  cal_scale_error_EXP0723_cosmic_mc(double scale[5], const double pt, const double /*tanl*/)
1560  {
1561  // pt
1562  scale[0] = +1.0115E+00 - 3.6966E-02 * pt;
1563  scale[1] = +9.8369E-01 + 3.2783E-02 * pt;
1564  scale[2] = +6.8401E-01 + 1.0190E-01 * pt;
1565  scale[3] = +1.0968E+00 - 3.3011E-02 * pt;
1566  scale[4] = +1.0992E+00 - 2.7929E-02 * pt;
1567  }
1568 
1569 //
1570 // Scale error for Exp.25-27 Cosmic MC
1571 // old day by somebody
1572 //
1574  static void
1575  cal_scale_error_EXP2527_cosmic_mc(double scale[5], const double pt, const double /*tanl*/)
1576  {
1577  // pt
1578  scale[0] = +1.0257E+00 - 0.30671E-01 * pt;
1579  scale[1] = +1.0503E+00 + 0.97257E-02 * pt;
1580  scale[2] = +0.70751E+00 + 0.93039E-01 * pt;
1581  scale[3] = +1.0720E+00 - 0.15976E-01 * pt;
1582  scale[4] = +1.0530E+00 + 0.63696E-02 * pt;
1583  }
1584 
1585 //
1586 // Scale error for Exp.31 Cosmic MC
1587 // July 09th, 2004, by KUSAKA Akito
1588 //
1590  static void
1591  cal_scale_error_EXP31_cosmic_mc(double scale[5], double pt, double /*tanl*/)
1592  {
1593  // pt
1594  scale[0] = 1.0874 - 0.26640E-01 * pt;
1595  scale[1] = 1.0320 + 0.18869E-01 * pt;
1596  scale[2] = 0.75302 + 0.89109E-01 * pt;
1597  scale[3] = 1.1435 - 0.73830E-01 * pt;
1598  scale[4] = 1.1227 - 0.19112E-01 * pt;
1599  }
1600 
1601 //
1602 // Scale error for Exp.33 Cosmic MC for caseA
1603 // June 21th, 2004, by KUSAKA Akito
1604 // July 07th, 2004, modification on scale[3], by KUSAKA Akito
1605 //
1606 //
1607 // Scale error for Exp.35 Cosmic MC for caseB
1608 // February 3rd, 2010, by Takeo Higuchi
1609 //
1611  static void
1612  cal_scale_error_EXP33_cosmic_mc(double scale[5], double pt, double /*tanl*/)
1613  {
1614  if (SE_Reprocess_Version == 0) {
1615  // pt
1616  scale[0] = 1.1197 - 0.15104E-01 * pt;
1617  scale[1] = 1.0502 + 0.22138E-01 * pt;
1618  scale[2] = 0.75267 + 0.85377E-01 * pt;
1619  // Change to linear fit for robustness (Jul. 07th, 2004. KUSAKA Akito)
1620  // scale[3] = 1.3726 +(-0.31170 + 0.74074E-01*pt)*pt;
1621  scale[3] = 1.1608 - 0.43478E-01 * pt;
1622  scale[4] = 1.0936 + 0.18447E-01 * pt;
1623  } else {
1624  // pt
1625  scale[0] = 0.98971 - 0.12162E-01 * pt;
1626  scale[1] = 1.0132 + 0.22283E-01 * pt;
1627  scale[2] = 0.74947 + 0.81233E-01 * pt;
1628  scale[3] = 1.0601 - 0.54626E-01 * pt;
1629  scale[4] = 1.0454 - 0.33036E-02 * pt;
1630  }
1631  }
1632 
1633 //
1634 // Scale error for Exp.35 Cosmic MC for caseA
1635 // June 21th, 2004, by KUSAKA Akito
1636 //
1637 //
1638 // Scale error for Exp.35 Cosmic MC for caseB
1639 // February 3rd, 2010, by Takeo Higuchi
1640 //
1642  static void
1643  cal_scale_error_EXP35_cosmic_mc(double scale[5], double pt, double tanl)
1644  {
1645  if (SE_Reprocess_Version == 0) {
1646  // pt
1647  scale[0] = 1.0835 + 0.79781E-02 * pt;
1648  scale[1] = 1.0685 + 0.13339E-01 * pt;
1649  scale[2] = 0.72615 + 0.96936E-01 * pt;
1650  scale[3] = 1.1298 - 0.35734E-01 * pt;
1651  scale[4] = 1.0994 + 0.13150E-01 * pt;
1652  } else {
1653  // pt
1654  cal_scale_error_EXP33_cosmic_mc(scale, pt, tanl);
1655  }
1656  }
1657 
1658 //
1659 // Scale error for Exp.37 Cosmic MC
1660 // July 21st, 2004, by KUSAKA Akito
1661 //
1663  static void
1664  cal_scale_error_EXP37_cosmic_mc(double scale[5], double pt, double /*tanl*/)
1665  {
1666  // pt
1667  scale[0] = 1.0694 - 0.19048E-01 * pt;
1668  scale[1] = 1.0732 + 0.95531E-02 * pt;
1669  scale[2] = 0.74888 + 0.89957E-01 * pt;
1670  scale[3] = 1.1107 - 0.57216E-01 * pt;
1671  scale[4] = 1.1098 - 0.13305E-01 * pt;
1672  }
1673 
1674 //
1675 // Scale error for Exp.39,41 Cosmic MC
1676 // (Made from Exp.39 Cosmic MC. Confirmed for exp39,41)
1677 // April, 20th, 2005, by KUSAKA Akito
1678 //
1680  static void
1681  cal_scale_error_EXP3941_cosmic_mc(double scale[5], double pt, double /*tanl*/)
1682  {
1683  // pt
1684  scale[0] = 1.055465 - 0.2863498E-01 * pt;
1685  scale[1] = 1.005986 + 0.2709512E-01 * pt;
1686  scale[2] = 0.7459061 + 0.8352030E-01 * pt;
1687  scale[3] = 1.056039 - 0.6258768E-01 * pt;
1688  scale[4] = 1.043329 - 0.2975207E-03 * pt;
1689  }
1690 
1691 //
1692 // Scale error for Exp.43 Cosmic MC
1693 // Sep., 12th, 2005, by KUSAKA Akito
1694 //
1696  static void
1697  cal_scale_error_EXP43_cosmic_mc(double scale[5], double pt, double /*tanl*/)
1698  {
1699  // pt
1700  scale[0] = 1.013759 - 0.8743831E-02 * pt;
1701  scale[1] = 1.071626 - 0.1333353E-01 * pt;
1702  scale[2] = 0.7507483 + 0.8399138E-01 * pt;
1703  scale[3] = 1.054345 - 0.5644758E-01 * pt;
1704  scale[4] = 1.020721 + 0.1323117E-01 * pt;
1705  }
1706 
1707 //
1708 // Scale error for Exp.45 Cosmic MC
1709 // May., 27th, 2006, by fmiyuki
1710 //
1712  static void
1713  cal_scale_error_EXP45_cosmic_mc(double scale[5], double pt, double /*tanl*/)
1714  {
1715  // pt
1716  scale[0] = 1.011008 - 0.2272887E-01 * pt;
1717  scale[1] = 1.030603 + 0.8892579E-02 * pt;
1718  scale[2] = 0.7181793 + 0.9717058E-01 * pt;
1719  scale[3] = 1.065804 - 0.6852337E-01 * pt;
1720  scale[4] = 1.085136 - 0.2324515E-01 * pt;
1721  }
1722 
1723 //
1724 // Scale error for Exp.47 Cosmic MC
1725 // May., 27th, 2006, by fmiyuki
1726 //
1728  static void
1729  cal_scale_error_EXP47_cosmic_mc(double scale[5], double pt, double /*tanl*/)
1730  {
1731  // pt
1732  scale[0] = 0.9806778 - 0.2010826E-02 * pt;
1733  scale[1] = 0.9996797 + 0.2633917E-01 * pt;
1734  scale[2] = 0.7450445 + 0.7637244E-01 * pt;
1735  scale[3] = 1.084419 - 0.6828102E-01 * pt;
1736  scale[4] = 1.013550 + 0.1201861E-01 * pt;
1737  }
1738 
1739 //
1740 // Scale error for Exp.49 Cosmic MC
1741 // May., 27th, 2006, by fmiyuki
1742 //
1744  static void
1745  cal_scale_error_EXP49_cosmic_mc(double scale[5], double pt, double /*tanl*/)
1746  {
1747  // pt
1748  scale[0] = 1.000635 - 0.1659129E-01 * pt;
1749  scale[1] = 1.046513 - 0.2994663E-02 * pt;
1750  scale[2] = 0.7241409 + 0.9558808E-01 * pt;
1751  scale[3] = 1.062597 - 0.6663921E-01 * pt;
1752  scale[4] = 1.076486 - 0.2023062E-01 * pt;
1753  }
1754 
1755 //
1756 // Scale error for Exp.51 Cosmic MC
1757 // May 24th, 2007 by higuchit
1758 //
1760  static void
1761  cal_scale_error_EXP51_cosmic_mc(double scale[5], double pt, double /*tanl*/)
1762  {
1763  // pt
1764  scale[0] = 0.98242 - 0.71780E-02 * pt;
1765  scale[1] = 1.0465 + 0.44401E-03 * pt;
1766  scale[2] = 0.71433 + 0.10176 * pt;
1767  scale[3] = 1.0875 - 0.80972E-01 * pt;
1768  scale[4] = 1.0777 - 0.20428E-01 * pt;
1769  }
1770 
1771 //
1772 // Scale error for Exp.53 Cosmic MC
1773 // May 24th, 2007 by higuchit
1774 //
1776  static void
1777  cal_scale_error_EXP53_cosmic_mc(double scale[5], double pt, double /*tanl*/)
1778  {
1779  // pt
1780  scale[0] = 0.99832 - 0.17290E-01 * pt;
1781  scale[1] = 1.0434 + 0.47995E-02 * pt;
1782  scale[2] = 0.72111 + 0.10093 * pt;
1783  scale[3] = 1.1022 - 0.87951E-01 * pt;
1784  scale[4] = 1.0643 - 0.11962E-01 * pt;
1785  }
1786 
1787 //
1788 // Scale error for Exp.55 Cosmic MC
1789 // June 21st, 2007 by higuchit
1790 //
1792  static void
1793  cal_scale_error_EXP55_cosmic_mc(double scale[5], double pt, double /*tanl*/)
1794  {
1795  // pt
1796  scale[0] = 0.98871 - 0.88399E-02 * pt;
1797  scale[1] = 1.0159 + 0.16468E-01 * pt;
1798  scale[2] = 0.72813 + 0.94737E-01 * pt;
1799  scale[3] = 1.1060 - 0.88323E-01 * pt;
1800  scale[4] = 1.0914 - 0.30607E-01 * pt;
1801  }
1802 
1803 //
1804 // Scale error for Exp.61-65 Cosmic MC
1805 // March 4th, 2009 by higuchit
1806 //
1808  static void
1809  cal_scale_error_EXP6165_cosmic_mc(double scale[5], double pt, double tanl)
1810  {
1811  // pt
1812  scale[0] = 0.97322 - 0.29003E-02 * pt;
1813  scale[1] = 0.94704 + 0.44719E-01 * pt;
1814  scale[2] = 0.73547 + 0.98431E-01 * pt;
1815  scale[3] = 1.0752 - 0.77818E-01 * pt;
1816  scale[4] = 1.0759 - 0.27057E-01 * pt;
1817 
1818  // tanl
1819  scale[0] *= 0.99600 - 0.97573E-02 * tanl;
1820  scale[1] *= 1.0080 - 0.37122E-01 * tanl;
1821  scale[2] *= 0.99150 - 0.13390E-01 * tanl;
1822  scale[3] *= 0.99758 - 0.43508E-01 * tanl;
1823  scale[4] *= 0.99913 + 0.34211E-01 * tanl;
1824  }
1825 
1826 //
1827 // Scale error for Exp.67 Cosmic MC
1828 // October 8th, 2009 by higuchit
1829 //
1831  static void
1832  cal_scale_error_EXP67_cosmic_mc(double scale[5], double pt, double tanl)
1833  {
1834  // pt
1835  scale[0] = 0.99845 - 0.18739E-01 * pt;
1836  scale[1] = 1.0024 + 0.17833E-01 * pt;
1837  scale[2] = 0.72369 + 0.96994E-01 * pt;
1838  scale[3] = 1.0605 - 0.64072E-01 * pt;
1839  scale[4] = 1.0623 - 0.14320E-01 * pt;
1840 
1841  // tanl
1842  scale[0] *= 0.99597 - 0.13069E-01 * tanl;
1843  scale[1] *= 1.0072 - 0.18622E-01 * tanl;
1844  scale[2] *= 0.99515 - 0.16591E-01 * tanl;
1845  scale[3] *= 0.99466 - 0.14489E-02 * tanl;
1846  scale[4] *= 1.0036 - 0.15095E-01 * tanl;
1847  }
1848 
1849 
1850 //
1851 // Scale error for Exp.69 Cosmic MC
1852 // January 29th, 2010 by higuchit
1853 // Scale error for Exp.71 Cosmic MC
1854 // May 12th, 2010 by higuchit
1855 //
1857  static void
1858  cal_scale_error_EXP6971_cosmic_mc(double scale[5], double pt, double tanl)
1859  {
1860  // pt
1861  scale[0] = 0.96783 - 0.37174E-02 * pt;
1862  scale[1] = 0.97888 + 0.34689E-01 * pt;
1863  scale[2] = 0.80870 + 0.68302E-01 * pt;
1864  scale[3] = 1.0615 - 0.60750E-01 * pt;
1865  scale[4] = 1.0372 - 0.52332E-03 * pt;
1866 
1867  // tanl
1868  scale[0] *= 0.99897 + 0.62207E-02 * tanl;
1869  scale[1] *= 1.0037 + 0.10714E-01 * tanl;
1870  scale[2] *= 0.99129 - 0.92521E-02 * tanl;
1871  scale[3] *= 0.99483 - 0.43402E-02 * tanl;
1872  scale[4] *= 1.0062 + 0.15306E-01 * tanl;
1873  }
1874 
1875 
1876 //
1877 // Scale error for Exp.7-23 Cosmic data
1878 // old day by somebody
1879 //
1881  static void
1882  cal_scale_error_EXP0723_cosmic_data(double scale[5], const double pt, const double /*tanl*/)
1883  {
1884  // pt
1885  scale[0] = +1.1280E+00 - 7.6839E-03 * pt;
1886  scale[1] = +1.1368E+00 + 2.8106E-02 * pt;
1887  scale[2] = +7.6448E-01 + 1.1248E-01 * pt;
1888  scale[3] = +1.1396E+00 - 3.6738E-02 * pt;
1889  scale[4] = +1.1766E+00 - 2.7477E-02 * pt;
1890  }
1891 
1892 //
1893 // Scale error for Exp.25-27 Cosmic data
1894 // old day by somebody
1895 //
1897  static void
1898  cal_scale_error_EXP2527_cosmic_data(double scale[5], const double pt, const double /*tanl*/)
1899  {
1900  // pt
1901  scale[0] = +1.1002E+00 + 3.9852E-02 * pt;
1902  scale[1] = rootfunc(pt, 1.0015, 1.6591, 1.0420, -0.31809, 0.17149);
1903  scale[2] = +8.4706E-01 + 0.8914E-01 * pt;
1904  scale[3] = +1.1067E+00 + 1.0304E-02 * pt;
1905  scale[4] = +1.0495E+00 + 3.9923E-02 * pt;
1906  }
1907 
1908 //
1909 // Scale error for Exp.31 Cosmic data
1910 // July 9th, 2004, by KUSAKA Akito
1911 //
1913  static void
1914  cal_scale_error_EXP31_cosmic_data(double scale[5], double pt, double /*tanl*/)
1915  {
1916  // pt
1917  scale[0] = 1.1908 + 0.20678E-02 * pt;
1918  scale[1] = 1.0304 + 0.54826E-01 * pt;
1919  scale[2] = 1.0806 + 0.33829E-01 * pt;
1920  scale[3] = 1.1325 - 0.34811E-01 * pt;
1921  scale[4] = 1.1549 - 0.20974E-01 * pt;
1922  }
1923 
1924 //
1925 // Scale error for Exp.33 Cosmic data for caseA
1926 // June 21th, 2004, by KUSAKA Akito
1927 //
1928 //
1929 // Scale error for Exp.35 Cosmic data for caseB
1930 // February 3rd, 2010, by Takeo Higuchi
1931 //
1933  static void
1934  cal_scale_error_EXP33_cosmic_data(double scale[5], double pt, double /*tanl*/)
1935  {
1936  if (SE_Reprocess_Version == 0) {
1937  // pt
1938  scale[0] = 1.2175 + 0.14290E-01 * pt;
1939  scale[1] = 1.0362 + 0.80614E-01 * pt;
1940  scale[2] = 1.0313 + 0.12930E-01 * pt;
1941  scale[3] = 1.0411 + 0.17319E-01 * pt;
1942  scale[4] = 1.0445 + 0.27526E-01 * pt;
1943  } else {
1944  // pt
1945  scale[0] = 1.2712 - 0.42098E-01 * pt;
1946  scale[1] = 1.0634 - 0.13652E-01 * pt;
1947  scale[2] = 0.95435 + 0.64895E-01 * pt;
1948  scale[3] = 1.0758 + 0.10778E-01 * pt;
1949  scale[4] = 1.0892 - 0.75700E-02 * pt;
1950  }
1951  }
1952 
1953 //
1954 // Scale error for Exp.35 Cosmic data for caseA
1955 // June 21th, 2004, by KUSAKA Akito
1956 // July 07th, 2004, modification on scale[3], by KUSAKA Akito
1957 //
1958 //
1959 // Scale error for Exp.35 Cosmic data for caseB
1960 // February 3rd, 2010, by Takeo Higuchi
1961 //
1963  static void
1964  cal_scale_error_EXP35_cosmic_data(double scale[5], double pt, double tanl)
1965  {
1966  if (SE_Reprocess_Version == 0) {
1967  // pt
1968  scale[0] = 1.1084 + 0.45825E-01 * pt;
1969  scale[1] = 1.1014 + 0.14211E-01 * pt;
1970  scale[2] = 0.99716 + 0.52509E-01 * pt;
1971  scale[3] = 1.1361 - 0.25355E-01 * pt;
1972  scale[4] = 1.1079 - 0.92563E-02 * pt;
1973  } else {
1974  cal_scale_error_EXP33_cosmic_data(scale, pt, tanl);
1975  }
1976  }
1977 
1978 //
1979 // Scale error for Exp.37 Cosmic data
1980 // July 21st, 2004, by KUSAKA Akito
1981 //
1983  static void
1984  cal_scale_error_EXP37_cosmic_data(double scale[5], double pt, double /*tanl*/)
1985  {
1986  // pt
1987  scale[0] = 1.2129 + 0.36787E-01 * pt;
1988  scale[1] = 1.0750 + 0.32722E-01 * pt;
1989  scale[2] = 0.98340 + 0.39096E-01 * pt;
1990  scale[3] = 1.1768 - 0.43894E-01 * pt;
1991  scale[4] = 1.1275 - 0.12562E-02 * pt;
1992  }
1993 
1994 //
1995 // Scale error for Exp.39,41 Cosmic data
1996 // April 20th, 2004, by KUSAKA Akito
1997 //
1999  static void
2000  cal_scale_error_EXP3941_cosmic_data(double scale[5], double pt, double /*tanl*/)
2001  {
2002  // pt
2003  scale[0] = 1.182285 + 0.4142677E-01 * pt;
2004  scale[1] = 1.090022 + 0.2995044E-01 * pt;
2005  scale[2] = 0.9581690 + 0.5764173E-01 * pt;
2006  scale[3] = 1.119173 - 0.2177483E-01 * pt;
2007  scale[4] = 1.126323 - 0.3786523E-02 * pt;
2008  }
2009 
2010 //
2011 // Scale error for Exp.43 Cosmic data
2012 // Sep., 12th, 2005 by KUSAKA Akito
2013 //
2015  static void
2016  cal_scale_error_EXP43_cosmic_data(double scale[5], double pt, double /*tanl*/)
2017  {
2018  // pt
2019  scale[0] = 1.262359 + 0.1411302E-01 * pt;
2020  scale[1] = 1.051793 + 0.6225422E-01 * pt;
2021  scale[2] = 0.9668697 + 0.5492099E-01 * pt;
2022  scale[3] = 1.110838 - 0.2386986E-01 * pt;
2023  scale[4] = 1.106516 + 0.1239970E-01 * pt;
2024  }
2025 
2026 //
2027 // Scale error for Exp.45+47 Cosmic data
2028 // May., 29th, 2006 by fmiyuki
2029 //
2031  static void
2032  cal_scale_error_EXP4547_cosmic_data(double scale[5], double pt, double /*tanl*/)
2033  {
2034  // pt 8bin
2035  scale[0] = 1.164526 + 0.7671143E-01 * pt;
2036  scale[1] = 1.094987 + 0.2949413E-01 * pt;
2037  scale[2] = 1.084826 + 0.2513991E-01 * pt;
2038  scale[3] = 1.099221 - 0.2389658E-02 * pt;
2039  scale[4] = 1.146892 + 0.2682884E-02 * pt;
2040  }
2041 
2042 //
2043 // Scale error for Exp.49 Cosmic data
2044 // May., 27th, 2006 by fmiyuki
2045 //
2047  static void
2048  cal_scale_error_EXP49_cosmic_data(double scale[5], double pt, double /*tanl*/)
2049  {
2050  // pt 8bin
2051  scale[0] = 1.243211 + 0.5776083E-01 * pt;
2052  scale[1] = 1.209483 - 0.3366023E-01 * pt;
2053  scale[2] = 1.059087 + 0.4300838E-01 * pt;
2054  scale[3] = 1.123665 + 0.6342933E-02 * pt;
2055  scale[4] = 1.208850 - 0.3171053E-01 * pt;
2056  }
2057 
2058 //
2059 // Scale error for Exp.51 Cosmic data
2060 // May 24th, 2007 by higuchit
2061 //
2063  static void
2064  cal_scale_error_EXP51_cosmic_data(double scale[5], double pt, double tanl)
2065  {
2066  // pt 5bin
2067  scale[0] = 1.2097 + 0.36177E-01 * pt;
2068  scale[1] = 1.2218 - 0.84772E-02 * pt;
2069  scale[2] = 0.97937 + 0.26397E-01 * pt;
2070  scale[3] = 1.0944 - 0.12745E-02 * pt;
2071  scale[4] = 1.2140 - 0.56809E-01 * pt;
2072 
2073  // tanl
2074  scale[0] *= 1.0492 + 0.72972E-01 * tanl;
2075  scale[1] *= 1.0298 + 0.40625E-02 * tanl;
2076  scale[2] *= 0.93367 + 0.11969E-01 * tanl;
2077  scale[3] *= 1.0170 + 0.41039E-01 * tanl;
2078  scale[4] *= 1.0677 - 0.41684E-01 * tanl;
2079  }
2080 
2081 //
2082 // Scale error for Exp.53 Cosmic data
2083 // May 24th, 2007 by higuchit
2084 //
2086  static void
2087  cal_scale_error_EXP53_cosmic_data(double scale[5], double pt, double /*tanl*/)
2088  {
2089  // pt 5bin
2090  scale[0] = 1.2587 + 0.32782E-01 * pt;
2091  scale[1] = 1.2413 - 0.36535E-01 * pt;
2092  scale[2] = 0.97465 + 0.22937E-01 * pt;
2093  scale[3] = 1.1197 - 0.59050E-02 * pt;
2094  scale[4] = 1.1877 - 0.32893E-01 * pt;
2095  }
2096 
2097 //
2098 // Scale error for Exp.55 Cosmic data
2099 // June 21st, 2007 by higuchit
2100 //
2102  static void
2103  cal_scale_error_EXP55_cosmic_data(double scale[5], double pt, double tanl)
2104  {
2105  // pt 5bin
2106  scale[0] = 1.2654 + 0.15660E-01 * pt;
2107  scale[1] = 1.0278 + 0.81680E-01 * pt;
2108  scale[2] = 0.94291 + 0.54575E-01 * pt;
2109  scale[3] = 1.1151 - 0.52387E-02 * pt;
2110  scale[4] = 1.1020 + 0.10518E-01 * pt;
2111 
2112  // tanl 5bin
2113  scale[0] *= 1.0334 + 0.10236E-01 * tanl;
2114  scale[1] *= 1.0346 + 0.11024E-01 * tanl;
2115  // scale[2] *= 0.91773 -0.52276E-02*tanl;
2116  scale[3] *= 1.0140 + 0.19030E-01 * tanl;
2117  scale[4] *= 1.0345 - 0.90291E-01 * tanl;
2118  }
2119 
2120 //
2121 // Scale error for Exp.61-65 Cosmic data
2122 // March 4th, 2009 by higuchit
2123 //
2125  static void
2126  cal_scale_error_EXP6165_cosmic_data(double scale[5], double pt, double tanl)
2127  {
2128  // pt 5bin
2129  scale[0] = 1.1184 + 0.55671E-01 * pt;
2130  scale[1] = 1.1142 + 0.74526E-02 * pt;
2131  scale[2] = 0.93626 + 0.66670E-01 * pt;
2132  scale[3] = 1.1003 - 0.11587E-01 * pt;
2133  scale[4] = 1.1589 - 0.40223E-01 * pt;
2134 
2135  // tanl 5bin
2136  scale[0] *= 1.0442 - 0.46775E-01 * tanl;
2137  scale[1] *= 1.0337 + 0.44071E-01 * tanl;
2138  // scale[2] *= 0.91898 -0.28268E-02*tanl;
2139  scale[3] *= 1.0037 + 0.29736E-01 * tanl;
2140  scale[4] *= 1.0378 - 0.73239E-01 * tanl;
2141  }
2142 
2143 //
2144 // Scale error for Exp.67 Cosmic data
2145 // October 8th, 2009 by higuchit
2146 //
2148  static void
2149  cal_scale_error_EXP67_cosmic_data(double scale[5], double pt, double tanl)
2150  {
2151  // pt 5bin
2152  scale[0] = 1.1598 + 0.28880E-01 * pt;
2153  scale[1] = 1.0844 + 0.23384E-01 * pt;
2154  scale[2] = 0.94566 + 0.53157E-01 * pt;
2155  scale[3] = 1.1578 - 0.31156E-01 * pt;
2156  scale[4] = 1.0725 + 0.13714E-01 * pt;
2157 
2158  // tanl 5bin
2159  scale[0] *= 1.0223 - 0.56165E-02 * tanl;
2160  scale[1] *= 1.0203 - 0.81857E-02 * tanl;
2161  // scale[2] *= 0.90812 +0.15679E-01*tanl;
2162  scale[3] *= 0.99703 + 0.14976E-01 * tanl;
2163  scale[4] *= 1.0212 + 0.41300E-01 * tanl;
2164  }
2165 
2166 
2167 //
2168 // Scale error for Exp.69 Cosmic data
2169 // January 29th, 2010 by higuchit
2170 // Scale error for Exp.71 Cosmic data
2171 // May 12th, 2010 by higuchit
2172 //
2174  static void
2175  cal_scale_error_EXP6971_cosmic_data(double scale[5], double pt, double tanl)
2176  {
2177  // pt 5bin
2178  scale[0] = 1.2101 + 0.29496E-01 * pt;
2179  scale[1] = 1.0723 + 0.13773E-01 * pt;
2180  scale[2] = 0.90988 + 0.78667E-01 * pt;
2181  scale[3] = 1.1444 - 0.20780E-01 * pt;
2182  scale[4] = 1.0962 + 0.83309E-02 * pt;
2183 
2184  // tanl 5bin
2185  scale[0] *= 1.0207 - 0.17810E-01 * tanl;
2186  scale[1] *= 1.0272 + 0.61498E-01 * tanl;
2187  // scale[2] *= 0.91584 +0.16138E-01*tanl;
2188  scale[3] *= 0.99766 + 0.32434E-01 * tanl;
2189  scale[4] *= 1.0200 - 0.14935E-01 * tanl;
2190  }
2191 
2192 
2193 //
2194 // Scale error for Exp.7-23 Hadron MC
2195 // old day by somebody
2196 //
2198  static void
2199  cal_scale_error_EXP0723_hadronic_mc(double scale[5], const double pt, const double tanl)
2200  {
2201  // pt
2202  scale[0] = vfunc(pt, 0.34602, 1.0605, -0.36011, 0.38189E-01);
2203  scale[1] = 1.0612;
2204  scale[2] = cupfunc(pt, 0.44599, 1.2989, 0.85646, -0.73968, 0.17425);
2205  scale[3] = 1.1460 - 0.57101E-01 * pt;
2206  scale[4] = 1.0859;
2207 
2208  // tanl
2209  scale[0] *= +1.0122E+00 + 1.3568E-04 * tanl + 1.9856E-02 * tanl * tanl;
2210  scale[1] *= +1.0002E+00 - 4.5128E-03 * tanl + 1.6211E-02 * tanl * tanl;
2211  scale[2] *= +9.7051E-01 + 2.6876E-02 * tanl + 8.2365E-02 * tanl * tanl;
2212  scale[3] *= +9.7198E-01 + 3.8373E-02 * tanl + 4.9111E-02 * tanl * tanl;
2213  scale[4] *= +9.8880E-01 + 2.2090E-02 * tanl + 2.2701E-02 * tanl * tanl;
2214  }
2215 
2216 //
2217 // Scale error for Exp.25-27 Hadron MC
2218 // old day by somebody
2219 //
2221  static void
2222  cal_scale_error_EXP2527_hadronic_mc(double scale[5], const double pt, const double tanl)
2223  {
2224  // pt
2225  scale[0] = 1.092E+00 - 0.86138E-01 * pt;
2226  scale[1] = 1.0448E+00 - 0.26158E-01 * pt;
2227  scale[2] = 1.1942E+00 - 1.0025E+00 * pt + 0.85334 * pt * pt - 0.20305 * pt * pt * pt;
2228  scale[3] = 1.1260E+00 - 0.46048E-01 * pt;
2229  scale[4] = 1.0378E+00 + 0.5109E-01 * pt;
2230 
2231  // tanl
2232  scale[0] *= +1.0136E+00 + 0.15293E-01 * tanl;
2233  scale[1] *= +0.9936E+00 + 0.71983E-02 * tanl + 0.14004E-01 * tanl * tanl;
2234  scale[2] *= +0.97532E+00 + 0.22718E-01 * tanl + 0.73556E-01 * tanl * tanl;
2235  scale[3] *= vfunc(tanl, -0.26650, 0.92765, -0.13393, 0.11704);
2236  scale[4] *= +0.98203E+00 + 0.21612E-01 * tanl + 0.32751E-01 * tanl * tanl;
2237  }
2238 
2239 //
2240 // Scale error for Exp.31 Hadron MC
2241 // July 9th, 2004, by KUSAKA Akito
2242 //
2244  static void
2245  cal_scale_error_EXP31_hadronic_mc(double scale[5], double pt, double tanl)
2246  {
2247  // pt
2248  scale[0] = 1.2619 - 0.11170 * pt;
2249  scale[1] = 1.2263 - 0.24619E-01 * pt;
2250  scale[2] = vfunc(pt, 1.1432, 0.87555, -0.24211, 0.10876);
2251  scale[3] = 1.3254 - 0.21162 * pt;
2252  scale[4] = 1.1609 + 0.73808E-02 * pt;
2253 
2254  // tanl
2255  scale[3] *= vfunc(tanl, -0.12026, 0.95892, -0.71461E-01, 0.69535E-01);
2256  }
2257 
2258 //
2259 // Scale error for Exp.33, 35 Hadron MC
2260 // June 19th, 2004, by KUSAKA Akito
2261 // July 09th, 2004, modification on scale[2](pt) for low pt.
2262 // July 09th, 2004, modification on scale[3](tanl) for high tanl.
2263 //
2265  static void
2266  cal_scale_error_EXP33_hadronic_mc(double scale[5], double pt, double tanl)
2267  {
2268  if (SE_Reprocess_Version == 0) {
2269  // pt
2270  scale[0] = 1.3083 - 0.10894 * pt;
2271  scale[1] = 1.2471 - 0.30959E-01 * pt;
2272  // scale[2] = 0.94594 -0.21216E-01*pt;
2273  scale[2] = vfunc(pt, 0.79736, 0.90954, -0.45673, 0.37072E-02);
2274  scale[3] = 1.3307 - 0.17559 * pt;
2275  scale[4] = 1.2408 - 0.29914E-01 * pt;
2276 
2277  // tanl
2278  // scale[3] *= 0.95593 + (0.39351E-01 + 0.10450*tanl)*tanl;
2279  scale[3] *= vfunc(tanl, -0.63864E-01, 0.95936, -0.11035, 0.10057);
2280  } else {
2281  // pt
2282  scale[0] = vfunc(pt, 1.4506, 1.0599, -0.10534, -0.14118);
2283  scale[1] = lambdafunc(pt, 0.23691, 0.47860, 1.1996, -0.39938E-01, 0.23518, -0.62661E-01);
2284  scale[2] = lambdafunc(pt, 0.45865, 0.92603, 0.95622, -0.51715, -0.12868, 0.45187E-01);
2285  scale[3] = 1.2555 - 0.19038 * pt;
2286  scale[4] = vfunc(pt, 0.68946, 1.1772, 0.15927, -0.79017E-01);
2287  }
2288  }
2289 
2290 //
2291 // Scale error for Exp.35 Hadron MC
2292 // February 3rd, 2010, by Takeo Higuchi for caseB
2293 //
2295  static void
2296  cal_scale_error_EXP35_hadronic_mc(double scale[5], double pt, double tanl)
2297  {
2298  cal_scale_error_EXP33_hadronic_mc(scale, pt, tanl);
2299  }
2300 
2301 //
2302 // Scale error for Exp.37 Hadron MC
2303 // July 21st, 2004, by KUSAKA Akito
2304 //
2306  static void
2307  cal_scale_error_EXP37_hadronic_mc(double scale[5], double pt, double tanl)
2308  {
2309  // pt
2310  scale[0] = 1.2548 - 0.87786E-01 * pt;
2311  scale[1] = 1.2562 - 0.89296E-03 * pt;
2312  scale[2] = vfunc(pt, 0.67905, 0.91705, -0.57837, -0.37276E-02);
2313  scale[3] = 1.3180 - 0.19459 * pt;
2314  scale[4] = 1.1652 + 0.33812E-01 * pt;
2315 
2316  // tanl
2317  scale[3] *= vfunc(tanl, -0.47522E-01, 0.96537, -0.41720E-01, 0.68031E-01);
2318  }
2319 
2320 //
2321 // Scale error for Exp.39,41 Hadron MC
2322 // (Made from Exp.39 Hadron MC. Confirmed for exp39,41)
2323 // April 20th, by KUSAKA Akito
2324 //
2326  static void
2327  cal_scale_error_EXP3941_hadronic_mc(double scale[5], double pt, double /*tanl*/)
2328  {
2329  // pt
2330  scale[0] = 1.236096 - 0.1015809 * pt;
2331  scale[1] = 1.248921 - 0.1130577E-01 * pt;
2332  scale[2] = vfunc(pt, 0.5129282, 0.9300365, -0.9450958, -0.1157168E-01);
2333  scale[3] = vfunc(pt, 1.650362, 0.9371865, -0.2142342, 0.7384746E-01);
2334  scale[4] = vfunc(pt, 0.7497343, 1.204451, 0.1333454, -0.7826934E-01);
2335  }
2336 
2337 //
2338 // Scale error for Exp.43 Hadron MC
2339 // Sep. 12th, 2005 by KUSAKA Akito
2340 //
2342  static void
2343  cal_scale_error_EXP43_hadronic_mc(double scale[5], double pt, double /*tanl*/)
2344  {
2345  // pt
2346  scale[0] = 1.240166 - 0.1051634 * pt;
2347  scale[1] = 1.257180 - 0.3122512E-01 * pt;
2348  scale[2] = vfunc(pt, 0.5272015, 0.9386514, -0.9648152, -0.1623573E-01);
2349  scale[3] = 1.280515 - 0.1991213 * pt;
2350  scale[4] = vfunc(pt, 0.6579201, 1.192409, 0.1197880, -0.5404800E-01);
2351  }
2352 
2353 //
2354 // Scale error for Exp.45 Hadron MC
2355 // May. 27th, 2006 by fmiyuki
2356 //
2358  static void
2359  cal_scale_error_EXP45_hadronic_mc(double scale[5], double pt, double tanl)
2360  {
2361  // pt
2362  scale[0] = 1.213823 - .1029683 * pt;
2363  scale[1] = 1.239279 - .3706657E-01 * pt;
2364  scale[2] = vfunc(pt, 0.6145123, 0.8834459, -.4620622, 0.2099150E-01);
2365  scale[3] = 1.253126 - .1884352 * pt;
2366  scale[4] = vfunc(pt, 0.4928604, 1.169158, 0.2063893, -.5428730E-01);
2367 
2368  // tanl
2369  scale[2] *= vfunc(tanl, -.1240821, 0.9274375, -.8750933E-01, 0.8611448E-01);
2370  }
2371 
2372 //
2373 // Scale error for Exp.47 Hadron MC
2374 // May. 27th, 2006 by fmiyuki
2375 //
2377  static void
2378  cal_scale_error_EXP47_hadronic_mc(double scale[5], double pt, double /*tanl*/)
2379  {
2380  // pt
2381  scale[0] = 1.218633 - .1078999 * pt;
2382  scale[1] = 1.237288 - .2890434E-01 * pt;
2383  scale[2] = vfunc(pt, 0.4334312, 0.9027213, -.7119852, 0.1031877E-01);
2384  scale[3] = 1.252394 - .1835607 * pt;
2385  scale[4] = vfunc(pt, 0.6194937, 1.168190, 0.1285120, -.5815693E-01);
2386  }
2387 
2388 //
2389 // Scale error for Exp.49 Hadron MC
2390 // May. 27th, 2006 by fmiyuki
2391 //
2393  static void
2394  cal_scale_error_EXP49_hadronic_mc(double scale[5], double pt, double /*tanl*/)
2395  {
2396  // pt
2397  scale[0] = 1.217751 - .1075724 * pt;
2398  scale[1] = 1.233774 - .3122749E-01 * pt;
2399  scale[2] = vfunc(pt, 0.5276512, 0.8852152, -.7025786, 0.3136450E-01);
2400  scale[3] = 1.258038 - .1949899 * pt;
2401  scale[4] = vfunc(pt, 0.5924365, 1.162905, 0.9632715E-01, -.6221822E-01);
2402 
2403  }
2404 
2405 //
2406 // Scale error for Exp.51 Hadron MC
2407 // May 24th, 2007 by higuchit
2408 //
2410  static void
2411  cal_scale_error_EXP51_hadronic_mc(double scale[5], double pt, double tanl)
2412  {
2413  // pt
2414  scale[0] = vfunc(pt, 0.35776, 1.1919, 0.84229E-01, -0.88550E-01);
2415  scale[1] = vfunc(pt, 0.37833, 1.2394, 0.34089, -0.54440E-01);
2416  scale[2] = lambdafunc(pt, 0.87688, 1.4065, 0.86733, -0.23657, 0.21714E-01, 0.20876);
2417  scale[3] = lambdafunc(pt, 0.39825, 1.0950, 1.2104, 0.11718E-01, -0.21145, -0.89681E-01);
2418  scale[4] = vfunc(pt, 0.48051, 1.1672, 0.19241, -0.32273E-01);
2419 
2420  // tanl
2421  scale[2] *= vfunc(tanl, -0.40697, 0.92948, -0.29453, 0.59416E-01);
2422  }
2423 
2424 //
2425 // Scale error for Exp.53 Hadron MC
2426 // May 24th, 2007 by higuchit
2427 //
2429  static void
2430  cal_scale_error_EXP53_hadronic_mc(double scale[5], double pt, double /*tanl*/)
2431  {
2432  // pt
2433  scale[0] = lambdafunc(pt, 0.50681, 1.2150, 1.2266, 0.99662E-01, -0.23508, -0.52268E-01);
2434  scale[1] = lambdafunc(pt, 0.50787, 1.2308, 1.3108, 0.42334, -0.25502, -0.13522E-01);
2435  scale[2] = vfunc(pt, 1.2149, 0.88700, -0.15323, 0.97993E-01);
2436  scale[3] = lambdafunc(pt, 0.45595, 1.1561, 1.2383, 0.17605, -0.34753, -0.97049E-01);
2437  scale[4] = vfunc(pt, 0.55269, 1.2261, 0.39706, -0.12333);
2438  }
2439 
2440 //
2441 // Scale error for Exp.55 Hadron MC
2442 // June 21st, 2007 by higuchit
2443 //
2445  static void
2446  cal_scale_error_EXP55_hadronic_mc(double scale[5], double pt, double /*tanl*/)
2447  {
2448  // pt
2449  scale[0] = vfunc(pt, 0.34925, 1.1780, 0.89069E-01, -0.10090);
2450  scale[1] = vfunc(pt, 0.35168, 1.2380, 0.41479, -0.63250E-01);
2451  scale[2] = vfunc(pt, 1.2497, 0.88495, -0.14338, 0.94307E-01);
2452  scale[3] = lambdafunc(pt, 0.29565, 1.4502, 1.2139, 0.14353, -0.21211, -0.82968E-01);
2453  scale[4] = vfunc(pt, 1.2496, 1.1216, 0.97174E-02, -0.41166E-01);
2454  }
2455 
2456 //
2457 // Scale error for Exp.61-65 Hadron MC
2458 // March 4th, 2009 by higuchit
2459 //
2461  static void
2462  cal_scale_error_EXP6165_hadronic_mc(double scale[5], double pt, double /*tanl*/)
2463  {
2464  // pt
2465  scale[0] = vfunc(pt, 1.4501, 1.0348, -0.12125, -0.27519E-01);
2466  scale[1] = lambdafunc(pt, 0.48988, 1.5501, 1.2544, 0.21014, -0.10419, 0.74755E-01);
2467  scale[2] = lambdafunc(pt, 0.44993, 1.3616, 0.93316, -0.58441, -0.30814E-01, 0.90806E-01);
2468  scale[3] = 1.2385 - 0.17733 * pt;
2469  scale[4] = vfunc(pt, 0.75590, 1.1726, 0.12749, -0.75183E-01);
2470  }
2471 
2472 //
2473 // Scale error for Exp.67 Hadron MC
2474 // October 8th, 2009 by higuchit
2475 //
2477  static void
2478  cal_scale_error_EXP67_hadronic_mc(double scale[5], double pt, double /*tanl*/)
2479  {
2480  // pt
2481  scale[0] = vfunc(pt, 1.0501, 1.0852, -0.14604, -0.66317E-01);
2482  scale[1] = lambdafunc(pt, 0.37538, 2.5672, 1.2362, 0.14203, -0.58242E-01, 0.28431E-02);
2483  scale[2] = lambdafunc(pt, 0.52700, 1.3506, 0.90327, -0.55627, 0.13131E-02, 0.11059);
2484  scale[3] = 1.2577 - 0.19572 * pt;
2485  scale[4] = vfunc(pt, 0.69484, 1.1636, 0.96169E-01, -0.80421E-01);
2486  }
2487 
2488 
2489 //
2490 // Scale error for Exp.69 Hadron MC
2491 // January 29th, 2010 by higuchit
2492 // Scale error for Exp.71 Hadron MC
2493 // May 12th, 2010 by higuchit
2494 //
2496  static void
2497  cal_scale_error_EXP6971_hadronic_mc(double scale[5], double pt, double /*tanl*/)
2498  {
2499  // pt
2500  scale[0] = vfunc(pt, 1.7258, 1.0126, -0.12693, 0.31924E-01);
2501  scale[1] = lambdafunc(pt, 0.37552, 1.2217, 1.2532, 0.37276, -0.77830E-01, -0.31378E-01);
2502  scale[2] = lambdafunc(pt, 0.40176, 1.1748, 0.95524, -0.72331, -0.53213E-01, 0.90074E-01);
2503  scale[3] = 1.2644 - 0.19783 * pt;
2504  scale[4] = vfunc(pt, 0.56934, 1.1649, 0.13098, -0.52232E-01);
2505  }
2506 
2507 
2508  /***** *****/
2509  /***** scale error core *****/
2510  /***** *****/
2511  static const struct cal_scale_error_func_set_t
2513  EXP0723_scale = {
2514  cal_scale_error_EXP0723_hadronic_mc,
2515  cal_scale_error_EXP0723_cosmic_mc,
2516  cal_scale_error_EXP0723_cosmic_data,
2517  },
2519  EXP2527_scale = {
2520  cal_scale_error_EXP2527_hadronic_mc,
2521  cal_scale_error_EXP2527_cosmic_mc,
2522  cal_scale_error_EXP2527_cosmic_data
2523  },
2525  EXP31_scale = {
2526  cal_scale_error_EXP31_hadronic_mc,
2527  cal_scale_error_EXP31_cosmic_mc,
2528  cal_scale_error_EXP31_cosmic_data
2529  },
2531  EXP33_scale = {
2532  cal_scale_error_EXP33_hadronic_mc,
2533  cal_scale_error_EXP33_cosmic_mc,
2534  cal_scale_error_EXP33_cosmic_data
2535  },
2537  EXP35_scale = {
2538  cal_scale_error_EXP35_hadronic_mc,
2539  cal_scale_error_EXP35_cosmic_mc,
2540  cal_scale_error_EXP35_cosmic_data
2541  },
2543  EXP37_scale = {
2544  cal_scale_error_EXP37_hadronic_mc,
2545  cal_scale_error_EXP37_cosmic_mc,
2546  cal_scale_error_EXP37_cosmic_data
2547  },
2549  EXP3941_scale = {
2550  cal_scale_error_EXP3941_hadronic_mc,
2551  cal_scale_error_EXP3941_cosmic_mc,
2552  cal_scale_error_EXP3941_cosmic_data
2553  },
2555  EXP43_scale = {
2556  cal_scale_error_EXP43_hadronic_mc,
2557  cal_scale_error_EXP43_cosmic_mc,
2558  cal_scale_error_EXP43_cosmic_data
2559  },
2561  EXP45_scale = {
2562  cal_scale_error_EXP45_hadronic_mc,
2563  cal_scale_error_EXP45_cosmic_mc,
2564  cal_scale_error_EXP4547_cosmic_data
2565  },
2567  EXP47_scale = {
2568  cal_scale_error_EXP47_hadronic_mc,
2569  cal_scale_error_EXP47_cosmic_mc,
2570  cal_scale_error_EXP4547_cosmic_data
2571  },
2573  EXP49_scale = {
2574  cal_scale_error_EXP49_hadronic_mc,
2575  cal_scale_error_EXP49_cosmic_mc,
2576  cal_scale_error_EXP49_cosmic_data
2577  },
2579  EXP51_scale = {
2580  cal_scale_error_EXP51_hadronic_mc,
2581  cal_scale_error_EXP51_cosmic_mc,
2582  cal_scale_error_EXP51_cosmic_data
2583  },
2585  EXP53_scale = {
2586  cal_scale_error_EXP53_hadronic_mc,
2587  cal_scale_error_EXP53_cosmic_mc,
2588  cal_scale_error_EXP53_cosmic_data
2589  },
2591  EXP55_scale = {
2592  cal_scale_error_EXP55_hadronic_mc,
2593  cal_scale_error_EXP55_cosmic_mc,
2594  cal_scale_error_EXP55_cosmic_data
2595  },
2597  EXP6165_scale = {
2598  cal_scale_error_EXP6165_hadronic_mc,
2599  cal_scale_error_EXP6165_cosmic_mc,
2600  cal_scale_error_EXP6165_cosmic_data
2601  },
2603  EXP67_scale = {
2604  cal_scale_error_EXP67_hadronic_mc,
2605  cal_scale_error_EXP67_cosmic_mc,
2606  cal_scale_error_EXP67_cosmic_data
2607  },
2609  EXP6971_scale = {
2610  cal_scale_error_EXP6971_hadronic_mc,
2611  cal_scale_error_EXP6971_cosmic_mc,
2612  cal_scale_error_EXP6971_cosmic_data
2613  },
2615  DUMMY_scale = {
2616  null_scale,
2617  null_scale,
2618  null_scale
2619  };
2620 
2621 
2623  static cal_scale_error_func_set_t
2624  get_scale_error_func_for_exprun(const int no_exp, const int /*no_run*/)
2625  {
2626  return
2627  (7 <= no_exp && no_exp <= 23) ? EXP0723_scale :
2628  (25 <= no_exp && no_exp <= 27) ? EXP2527_scale :
2629  (31 == no_exp) ? EXP31_scale :
2630  (33 == no_exp) ? EXP33_scale :
2631  (35 == no_exp) ? EXP35_scale :
2632  (37 == no_exp) ? EXP37_scale :
2633  (39 == no_exp || 41 == no_exp) ? EXP3941_scale :
2634  (43 == no_exp) ? EXP43_scale :
2635  (45 == no_exp) ? EXP45_scale :
2636  (47 == no_exp) ? EXP47_scale :
2637  (49 == no_exp) ? EXP49_scale :
2638  (51 == no_exp) ? EXP51_scale :
2639  (53 == no_exp) ? EXP53_scale :
2640  (55 == no_exp) ? EXP55_scale :
2641  (61 <= no_exp && no_exp <= 65) ? EXP6165_scale :
2642  (67 == no_exp) ? EXP67_scale :
2643  // ( 69==no_exp || 71==no_exp ) ? EXP6971_scale : DUMMY_scale;
2644  (69 <= no_exp && 73 >= no_exp) ? EXP6971_scale : DUMMY_scale;
2645  }
2647  static void
2648  cal_scale_error
2649  (double scale[5],
2650  const double pt, const double tanl,
2651  const int expmc, const int no_exp, const int no_run)
2652  {
2653  double scale_error_hadronic_mc[5] = {1.0, 1.0, 1.0, 1.0, 1.0};
2654  double scale_error_cosmic_mc[5] = {1.0, 1.0, 1.0, 1.0, 1.0};
2655  double scale_error_cosmic_data[5] = {1.0, 1.0, 1.0, 1.0, 1.0};
2656 
2657 
2658  struct cal_scale_error_func_set_t cal_func = get_scale_error_func_for_exprun(no_exp, no_run);
2659  if (cal_func == DUMMY_scale) {
2660  B2ERROR("!!!! scale_error: FATAL: FATAL ERROR occured. Abort !!!!");
2661  // Scale error is not prepared for this EXP number!
2662  assert(0);
2663  }
2664 
2665 
2666  static bool first = true;
2667  static int belle_scale_error_debug_mode = 0;
2668  if (first) {
2669  first = false;
2670  char* belle_scale_error_debug = getenv("BELLE_SCALE_ERROR_DEBUG");
2671  // one of NULL, "none", "cosmic_mc", "cosmic_data", "hadronic_mc"
2672 
2673  if (!belle_scale_error_debug)
2674  belle_scale_error_debug_mode = 0;
2675  else if (!strcasecmp(belle_scale_error_debug, "none"))
2676  belle_scale_error_debug_mode = 1;
2677  else if (!strcasecmp(belle_scale_error_debug, "cosmic_mc"))
2678  belle_scale_error_debug_mode = 2;
2679  else if (!strcasecmp(belle_scale_error_debug, "cosmic_data"))
2680  belle_scale_error_debug_mode = 3;
2681  else if (!strcasecmp(belle_scale_error_debug, "hadron_mc") || !strcasecmp(belle_scale_error_debug, "hadronic_mc"))
2682  belle_scale_error_debug_mode = 4;
2683  else {
2684  B2ERROR("BELLE_SCALE_ERROR_DEBUG=" << belle_scale_error_debug << ": bad directive");
2685  assert(0);
2686  }
2687 
2688  if (belle_scale_error_debug)
2689  B2ERROR("BELLE_SCALE_ERROR_DEBUG=" << belle_scale_error_debug << ": applied");
2690  }
2691 
2692 
2693  switch (belle_scale_error_debug_mode) {
2694  case 0:
2695  (cal_func.m_hadMC)(scale_error_hadronic_mc, pt, tanl);
2696  if (expmc == 1) { // Experiment
2697  if (SE_Message_Level >= 2) B2ERROR("scale_error: info: scale on real data");
2698  (cal_func.m_cosMC)(scale_error_cosmic_mc, pt, tanl);
2699  (cal_func.m_cosDATA)(scale_error_cosmic_data, pt, tanl);
2700  } else {
2701  if (SE_Message_Level >= 2) B2ERROR("scale_error: info: scale on MC data");
2702  }
2703  break;
2704 
2705  case 1:
2706  //1;
2707  break;
2708 
2709  case 2:
2710  (cal_func.m_cosMC)(scale_error_hadronic_mc, pt, tanl);
2711  break;
2712 
2713  case 3:
2714  (cal_func.m_cosDATA)(scale_error_hadronic_mc, pt, tanl);
2715  break;
2716 
2717  case 4:
2718  (cal_func.m_hadMC)(scale_error_hadronic_mc, pt, tanl);
2719  break;
2720  }
2721 
2722 
2723  /* compute scaling factor */
2724  for (int i = 0; i < 5; i++)
2725  scale[i] = scale_error_hadronic_mc[i] * scale_error_cosmic_data[i] / scale_error_cosmic_mc[i];
2726 
2727 
2728  /* message out */
2729  if (SE_Message_Level >= 2) {
2730  B2ERROR("scale_error: info: hadronic MC: "
2731  << scale_error_hadronic_mc[0] << " " << scale_error_hadronic_mc[1] << " "
2732  << scale_error_hadronic_mc[2] << " " << scale_error_hadronic_mc[3] << " "
2733  << scale_error_hadronic_mc[4]);
2734 
2735  B2ERROR("scale_error: info: cosmic MC: "
2736  << scale_error_cosmic_mc[0] << " " << scale_error_cosmic_mc[1] << " "
2737  << scale_error_cosmic_mc[2] << " " << scale_error_cosmic_mc[3] << " "
2738  << scale_error_cosmic_mc[4]);
2739 
2740  B2ERROR("scale_error: info: cosmic data: "
2741  << scale_error_cosmic_data[0] << " " << scale_error_cosmic_data[1] << " "
2742  << scale_error_cosmic_data[2] << " " << scale_error_cosmic_data[3] << " "
2743  << scale_error_cosmic_data[4]);
2744 
2745  B2ERROR("scale_error: info: final scale: "
2746  << scale[0] << " " << scale[1] << " " << scale[2] << " "
2747  << scale[3] << " " << scale[4]);
2748  }
2749  /* check parameter limit */
2750  const double scale_lo = 0.5, scale_hi = 4.0;
2751  bool too_lo = false, too_hi = false;
2752  for (int i = 0; i < 5; i++) {
2753  if (scale[i] < scale_lo) { scale[i] = scale_lo; too_lo = true;}
2754  if (scale[i] > scale_hi) { scale[i] = scale_hi; too_hi = true;}
2755  }
2756 
2757  if (SE_Message_Level >= 1 && (too_lo || too_hi)) {
2758  B2ERROR("scale_error: warning: scale factor beyond the limit: "
2759  << scale_error_hadronic_mc[0] * scale_error_cosmic_data[0] / scale_error_cosmic_mc[0] << " "
2760  << scale_error_hadronic_mc[1] * scale_error_cosmic_data[1] / scale_error_cosmic_mc[1] << " "
2761  << scale_error_hadronic_mc[2] * scale_error_cosmic_data[2] / scale_error_cosmic_mc[2] << " "
2762  << scale_error_hadronic_mc[3] * scale_error_cosmic_data[3] / scale_error_cosmic_mc[3] << " "
2763  << scale_error_hadronic_mc[4] * scale_error_cosmic_data[4] / scale_error_cosmic_mc[4]);
2764  }
2765  }
2766 
2767 
2775  static int scale_error_impl(const int message_level, const int reprocess_version)
2776  {
2777  SE_Message_Level = message_level;
2778  SE_Reprocess_Version = reprocess_version;
2779 
2780  int no_exp{0}, no_run{0}, no_evt{0}, no_frm{0}, expmc{0};
2781  get_event_id(&no_exp, &no_run, &no_evt, &no_frm, &expmc);
2782 
2783  if (DUMMY_scale == get_scale_error_func_for_exprun(no_exp, no_run)) return 2;
2784  if (is_already_scaled()) return 1;
2785 
2786  static int first_exp73 = true;
2787  if (no_exp == 73 && first_exp73) {
2788  first_exp73 = false;
2789  B2ERROR(
2790  "scale_error: warning: scale parameters for exp#71 are tentatively used for exp#73.");
2791  }
2792 
2793  double scale[5] = { // ... temporary
2794  1.0, // dr
2795  1.0, // phi0
2796  1.0, // kappa
2797  1.0, // dz
2798  1.0, // tanl
2799  };
2800 
2801 
2802  // scale error matrices in mdst_trk_fit
2803  Belle::Mdst_trk_fit_Manager& fitmgr = Belle::Mdst_trk_fit_Manager::get_manager();
2804  for (std::vector<Belle::Mdst_trk_fit>::iterator it = fitmgr.begin(); it != fitmgr.end(); ++it) {
2805  Belle::Mdst_trk_fit& fit = *it;
2806  if (fit.helix(2) == 0.) continue;
2807 
2808  const double pt = 1. / fabs(fit.helix(2));
2809  const double tanl = fit.helix(4);
2810 
2811  cal_scale_error(scale, pt, tanl, expmc, no_exp, no_run);
2812 
2813  fit.error(0, scale[0]*scale[0]*fit.error(0));
2814  fit.error(1, scale[1]*scale[0]*fit.error(1));
2815  fit.error(2, scale[1]*scale[1]*fit.error(2));
2816  fit.error(3, scale[2]*scale[0]*fit.error(3));
2817  fit.error(4, scale[2]*scale[1]*fit.error(4));
2818  fit.error(5, scale[2]*scale[2]*fit.error(5));
2819  fit.error(6, scale[3]*scale[0]*fit.error(6));
2820  fit.error(7, scale[3]*scale[1]*fit.error(7));
2821  fit.error(8, scale[3]*scale[2]*fit.error(8));
2822  fit.error(9, scale[3]*scale[3]*fit.error(9));
2823  fit.error(10, scale[4]*scale[0]*fit.error(10));
2824  fit.error(11, scale[4]*scale[1]*fit.error(11));
2825  fit.error(12, scale[4]*scale[2]*fit.error(12));
2826  fit.error(13, scale[4]*scale[3]*fit.error(13));
2827  fit.error(14, scale[4]*scale[4]*fit.error(14));
2828  }
2829 
2830 
2831  // scale error matrices in mdst_daughters
2832  Belle::Mdst_vee_daughters_Manager& daumgr = Belle::Mdst_vee_daughters_Manager::get_manager();
2833  for (std::vector<Belle::Mdst_vee_daughters>::iterator it = daumgr.begin(); it != daumgr.end(); ++it) {
2834  Belle::Mdst_vee_daughters& dau = *it;
2835  if (dau.helix_p(2) == 0. || dau.helix_m(2) == 0.) continue;
2836 
2837  // positive track
2838  const double pt_p = 1. / fabs(dau.helix_p(2));
2839  const double tanl_p = dau.helix_p(4);
2840 
2841  cal_scale_error(scale, pt_p, tanl_p, expmc, no_exp, no_run);
2842 
2843  dau.error_p(0, scale[0]*scale[0]*dau.error_p(0));
2844  dau.error_p(1, scale[1]*scale[0]*dau.error_p(1));
2845  dau.error_p(2, scale[1]*scale[1]*dau.error_p(2));
2846  dau.error_p(3, scale[2]*scale[0]*dau.error_p(3));
2847  dau.error_p(4, scale[2]*scale[1]*dau.error_p(4));
2848  dau.error_p(5, scale[2]*scale[2]*dau.error_p(5));
2849  dau.error_p(6, scale[3]*scale[0]*dau.error_p(6));
2850  dau.error_p(7, scale[3]*scale[1]*dau.error_p(7));
2851  dau.error_p(8, scale[3]*scale[2]*dau.error_p(8));
2852  dau.error_p(9, scale[3]*scale[3]*dau.error_p(9));
2853  dau.error_p(10, scale[4]*scale[0]*dau.error_p(10));
2854  dau.error_p(11, scale[4]*scale[1]*dau.error_p(11));
2855  dau.error_p(12, scale[4]*scale[2]*dau.error_p(12));
2856  dau.error_p(13, scale[4]*scale[3]*dau.error_p(13));
2857  dau.error_p(14, scale[4]*scale[4]*dau.error_p(14));
2858 
2859  // negative track
2860  const double pt_m = 1. / fabs(dau.helix_m(2));
2861  const double tanl_m = dau.helix_m(4);
2862 
2863  cal_scale_error(scale, pt_m, tanl_m, expmc, no_exp, no_run);
2864 
2865  dau.error_m(0, scale[0]*scale[0]*dau.error_m(0));
2866  dau.error_m(1, scale[1]*scale[0]*dau.error_m(1));
2867  dau.error_m(2, scale[1]*scale[1]*dau.error_m(2));
2868  dau.error_m(3, scale[2]*scale[0]*dau.error_m(3));
2869  dau.error_m(4, scale[2]*scale[1]*dau.error_m(4));
2870  dau.error_m(5, scale[2]*scale[2]*dau.error_m(5));
2871  dau.error_m(6, scale[3]*scale[0]*dau.error_m(6));
2872  dau.error_m(7, scale[3]*scale[1]*dau.error_m(7));
2873  dau.error_m(8, scale[3]*scale[2]*dau.error_m(8));
2874  dau.error_m(9, scale[3]*scale[3]*dau.error_m(9));
2875  dau.error_m(10, scale[4]*scale[0]*dau.error_m(10));
2876  dau.error_m(11, scale[4]*scale[1]*dau.error_m(11));
2877  dau.error_m(12, scale[4]*scale[2]*dau.error_m(12));
2878  dau.error_m(13, scale[4]*scale[3]*dau.error_m(13));
2879  dau.error_m(14, scale[4]*scale[4]*dau.error_m(14));
2880  }
2881 
2882  return 0;
2883  }
2884 
2885 
2886  void B2BIIFixMdstModule::scale_error(const int message_level)
2887  {
2888  static int result_before = -1;
2889 
2890  const int result = scale_error_impl(message_level, this->m_reprocess_version);
2891 
2892  if (result != result_before) {
2893  switch (result) {
2894  case 0: {
2895  B2INFO(
2896  "scale_error: info: scale error is properly applied.");
2897  break;
2898  }
2899 
2900  case 1: {
2901  B2ERROR(
2902  "scale_error: warning: scale error is not applied. Reason: it has been already applied.");
2903  break;
2904  }
2905 
2906  case 2: {
2907  int no_exp, no_run, no_evt, no_frm, expmc;
2908  get_event_id(&no_exp, &no_run, &no_evt, &no_frm, &expmc);
2909  B2ERROR(
2910  "scale_error: error: scale error is not applied. Reason: it is not available for exp " << no_exp << ". Exit! (I'll crash job.)");
2911  exit(-1);
2912 // break; // redundant
2913  }
2914 
2915  default: assert(0); // Should not be here!
2916  }
2917 
2918  result_before = result;
2919  }
2920  }
2921 
2922 
2924 // End of scale_error() implementation
2926 
2927 
2928  int B2BIIFixMdstModule::set_primary_vertex(HepPoint3D& epvtx,
2929  CLHEP::HepSymMatrix& epvtx_err)
2930  {
2931 
2932  Belle::Evtvtx_primary_vertex_Manager& evtvtx_mgr
2933  = Belle::Evtvtx_primary_vertex_Manager::get_manager();
2934 
2935  Belle::Evtvtx_trk_Manager& evttrk_mgr = Belle::Evtvtx_trk_Manager::get_manager();
2936 
2937  Belle::Evtvtx_primary_vertex_Manager::iterator itvtx = evtvtx_mgr.begin();
2938  if (itvtx == evtvtx_mgr.end()) return 4;
2939 
2940  if (!(itvtx->quality() == 2 || itvtx->quality() == 3)) return 3;
2941 
2942  // TKECK fit primary vertex with our kfitter!
2943 
2944  Belle2::analysis::VertexFitKFit kv;
2945  HepPoint3D pvtx(itvtx->PV_x(), itvtx->PV_y(), itvtx->PV_z());
2946 
2947  kv.setInitialVertex(pvtx);
2948 
2949  unsigned int nchrgd(0);
2950  for (Belle::Evtvtx_trk_Manager::iterator i = evttrk_mgr.begin(); i != evttrk_mgr.end(); ++i) {
2951 
2952  const Belle::Mdst_charged& p = i->charged();
2953  if (p.trk().mhyp(2).nhits(3) < 2) continue;
2954  if (p.trk().mhyp(2).nhits(4) < 2) continue;
2955 
2956  int hyp = 2;
2957  const HepPoint3D pivot(p.trk().mhyp(hyp).pivot_x(),
2958  p.trk().mhyp(hyp).pivot_y(),
2959  p.trk().mhyp(hyp).pivot_z());
2960  CLHEP::HepVector a(5);
2961  a[0] = p.trk().mhyp(hyp).helix(0);
2962  a[1] = p.trk().mhyp(hyp).helix(1);
2963  a[2] = p.trk().mhyp(hyp).helix(2);
2964  a[3] = p.trk().mhyp(hyp).helix(3);
2965  a[4] = p.trk().mhyp(hyp).helix(4);
2966  CLHEP::HepSymMatrix Ea(5, 0);
2967  Ea[0][0] = p.trk().mhyp(hyp).error(0);
2968  Ea[1][0] = p.trk().mhyp(hyp).error(1);
2969  Ea[1][1] = p.trk().mhyp(hyp).error(2);
2970  Ea[2][0] = p.trk().mhyp(hyp).error(3);
2971  Ea[2][1] = p.trk().mhyp(hyp).error(4);
2972  Ea[2][2] = p.trk().mhyp(hyp).error(5);
2973  Ea[3][0] = p.trk().mhyp(hyp).error(6);
2974  Ea[3][1] = p.trk().mhyp(hyp).error(7);
2975  Ea[3][2] = p.trk().mhyp(hyp).error(8);
2976  Ea[3][3] = p.trk().mhyp(hyp).error(9);
2977  Ea[4][0] = p.trk().mhyp(hyp).error(10);
2978  Ea[4][1] = p.trk().mhyp(hyp).error(11);
2979  Ea[4][2] = p.trk().mhyp(hyp).error(12);
2980  Ea[4][3] = p.trk().mhyp(hyp).error(13);
2981  Ea[4][4] = p.trk().mhyp(hyp).error(14);
2982  Belle::Helix helix(pivot, a, Ea);
2983 
2984  CLHEP::HepLorentzVector mom;
2985  CLHEP::HepSymMatrix err(7, 0);
2986  HepPoint3D pos(0, 0, 0);
2987  if (pivot.x() != 0. ||
2988  pivot.y() != 0. ||
2989  pivot.z() != 0.) {
2990  helix.pivot(HepPoint3D(0., 0., 0.));
2991  mom = helix.momentum(0., 0.13957f, pos, err);
2992  } else {
2993  mom = helix.momentum(0., 0.13957f, pos, err);
2994  }
2995 
2996  kv.addTrack(mom, pos, err, p.charge());
2997  ++nchrgd;
2998  }
2999 
3000  if (Belle::IpProfile::usable()) {
3001  // event depend. IP position and error matrix
3002  HepPoint3D ip_position = Belle::IpProfile::e_position();
3003  CLHEP::HepSymMatrix ip_err = Belle::IpProfile::e_position_err();
3004  kv.setIpProfile(ip_position, ip_err);
3005  }
3006  // Fit
3007  unsigned int err(1);
3008  if (nchrgd > 2 || (nchrgd > 0 && Belle::IpProfile::usable())) err = kv.doFit();
3009  if (err == 0) {
3010  epvtx = kv.getVertex();
3011  epvtx_err = kv.getVertexError();
3012  }
3013  return err;
3014 
3015  /*
3016  kvertexfitter kv;
3017 
3018  HepPoint3D pvtx(itvtx->PV_x(), itvtx->PV_y(), itvtx->PV_z());
3019 
3020  kv.initialVertex(pvtx);
3021 
3022  Ptype ptype_pi_plus("PI+");
3023  Ptype ptype_pi_minus("PI-");
3024 
3025  unsigned int nchrgd(0);
3026  for(Belle::Evtvtx_trk_Manager::iterator i = evttrk_mgr.begin();
3027  i != evttrk_mgr.end(); ++i){
3028  // if(!good_charged(i->charged())) continue;
3029 
3030  if(i->charged().trk().mhyp(2).nhits(3) < 2) continue;
3031  if(i->charged().trk().mhyp(2).nhits(4) < 2) continue;
3032 
3033  Particle tmp(i->charged(),
3034  (i->charged().charge()>0.0 ? ptype_pi_plus : ptype_pi_minus));
3035  addTrack2fit(kv, tmp);
3036  ++nchrgd;
3037  }
3038 
3039  if(Belle::IpProfile::usable()){
3040 
3041  // event depend. IP position and error matrix
3042  HepPoint3D ip_position = Belle::IpProfile::e_position();
3043  HepSymMatrix ip_err = Belle::IpProfile::e_position_err();
3044  // HepSymMatrix m_ip_err_b = Belle::IpProfile::e_position_err_b_life_smeared();
3045 
3046  // Add IP profile information
3047  addBeam2fit(kv, ip_position, ip_err);
3048  }
3049  // Fit
3050  unsigned int err(1);
3051  if(nchrgd>2||(nchrgd>0&&Belle::IpProfile::usable())) err = kv.fit();
3052  if(err==0) {
3053  epvtx = kv.get_vertex();
3054  epvtx_err = kv.get_err_vertex();
3055  }
3056  return err;
3057  */
3058  }
3059 
3060 
3061 //========================================================
3062 // Add Mdst_trk_extra and Mdst_vee_extra
3063 // to Mdst_trk and Mdst_vee2, respectively.
3064 //=======================================================
3066  extern "C"
3067  void recsim_mdst_propgt_(float*, float[], float[], float[],
3068  float[], float[], int*);
3069 
3070  int
3071  B2BIIFixMdstModule::add_extra_trk_vee2()
3072  {
3073  Belle::Mdst_event_add_Manager& mevtmgr = Belle::Mdst_event_add_Manager::get_manager();
3074  if (mevtmgr.count() == 0) { // no Belle::Mdst_event_add table
3075  return -2;
3076  } else if (mevtmgr.count() == 1) { // no second entity in Belle::Mdst_event_add table
3077  mevtmgr.add();
3078  }
3079  unsigned flag(mevtmgr[1].flag(0));
3080  if (flag != 0) return -1; // do nothing if already added
3081  Belle::Mdst_trk_extra_Manager& teMgr(Belle::Mdst_trk_extra_Manager::get_manager());
3082  Belle::Mdst_trk_Manager& tMgr(Belle::Mdst_trk_Manager::get_manager());
3083  Belle::Mdst_charged_Manager& chMgr(Belle::Mdst_charged_Manager::get_manager());
3084  const int i_ch(chMgr.count() + 1);
3085  const int i_trk(tMgr.count() + 1);
3086  for (std::vector<Belle::Mdst_trk_extra>::const_iterator i = teMgr.begin();
3087  i != teMgr.end(); ++i) {
3088  Belle::Mdst_trk& trk(tMgr.add());
3089  trk.quality((*i).quality());
3090  for (int j = 0; j < 5; j++) trk.mhyp(j, (*i).mhyp(j));
3091 
3092  // Commented out by A. Zupanc: see below
3093  // Belle::Mdst_trk_fit& tf(trk.mhyp(2));
3094  if (!(trk.quality() & 15u)) {
3095  B2FATAL("recsim_mdst_propgt_ is missing");
3096 
3097  /*
3098  Commented by A.Zupanc: the recsim_mdst_propgt_ is missing therefore this part of the code
3099  can not be executed
3100 
3101  Belle::Mdst_charged& ch(chMgr.add());
3102  ch.charge((tf.helix(2) >= 0) ? 1. : -1.);
3103 
3104  float pivot[3], helix[5], error[15], helix0[5], error0[15];
3105  for (int k = 0; k < 3; k++) pivot[k] = tf.pivot(k);
3106  for (int k = 0; k < 5; k++) helix[k] = tf.helix(k);
3107  for (int k = 0; k < 15; k++) error[k] = tf.error(k);
3108 
3109  float amass = tf.mass();
3110 
3111  // propagate helix to origin
3112  int iret;
3113 
3114  //recsim_mdst_propgt_(&amass, pivot, helix, error,
3115  // helix0, error0, &iret);
3116  if (iret == 0) {
3117  ch.px(-sin(helix0[1]) / fabs(helix0[2]));
3118  ch.py(cos(helix0[1]) / fabs(helix0[2]));
3119  ch.pz(helix0[4] / fabs(helix0[2]));
3120  }
3121  ch.mass(amass);
3122  ch.trk(trk);
3123  */
3124  } else {
3125  B2ERROR("Warning from B2BIIFixMdst: strange track in Belle::Mdst_trk_extra: quality="
3126  << trk.quality());
3127  }
3128  }
3129 
3130 
3131  Belle::Mdst_sim_trk_extra_Manager& steMgr
3132  (Belle::Mdst_sim_trk_extra_Manager::get_manager());
3133  Belle::Mdst_sim_trk_Manager& stMgr(Belle::Mdst_sim_trk_Manager::get_manager());
3134  int ist(0);
3135  for (std::vector<Belle::Mdst_sim_trk_extra>::const_iterator i = steMgr.begin();
3136  i != steMgr.end(); ++i) {
3137  Belle::Mdst_sim_trk& strk(stMgr.add());
3138  int argn = tMgr.count() - teMgr.count() + ist;
3139  if (argn < tMgr.count()) {
3140  strk.trk(tMgr[argn]);
3141  }
3142  ist++;
3143  strk.hepevt((*i).hepevt());
3144  strk.relation(0, (*i).relation(0));
3145  strk.relation(1, (*i).relation(1));
3146  strk.relation(2, (*i).relation(2));
3147  }
3148 
3149 
3150  Belle::Mdst_svd_hit_extra_Manager& sheMgr
3151  (Belle::Mdst_svd_hit_extra_Manager::get_manager());
3152  Belle::Mdst_svd_hit_Manager& shMgr(Belle::Mdst_svd_hit_Manager::get_manager());
3153  for (std::vector<Belle::Mdst_svd_hit_extra>::iterator it = sheMgr.begin();
3154  it != sheMgr.end(); ++it) {
3155  Belle::Mdst_svd_hit_extra& she = *it;
3156  Belle::Mdst_svd_hit& sh(shMgr.add());
3157  sh.lsa(she.lsa());
3158  sh.width(she.width());
3159  sh.electrons(she.electrons());
3160  sh.dssd(she.dssd());
3161  sh.type(she.type());
3162  int argn = tMgr.count() - teMgr.count() + she.trk().get_ID() - 1;
3163  if (argn < tMgr.count()) {
3164  sh.trk(tMgr[argn]);
3165  }
3166  }
3167 
3168 
3169  Belle::Mdst_vee2_Manager& vMgr(Belle::Mdst_vee2_Manager::get_manager());
3170  Belle::Mdst_vee2_extra_Manager& veMgr(Belle::Mdst_vee2_extra_Manager::get_manager());
3171  const int i_vee2(vMgr.count() + 1);
3172  for (std::vector<Belle::Mdst_vee2_extra>::const_iterator i = veMgr.begin();
3173  i != veMgr.end(); ++i) {
3174  Belle::Mdst_vee2& vee(vMgr.add());
3175  vee.kind((*i).kind());
3176 
3177  if ((*i).extra_ID(0)) {
3178  Belle::Mdst_charged& tmp(chMgr[(*i).extra_ID(0) + i_ch - 2]);
3179  vee.chgd(0, tmp);
3180  } else {
3181  vee.chgd(0, (*i).chgd());
3182  }
3183 
3184  if ((*i).extra_ID(1)) {
3185  Belle::Mdst_charged& tmp(chMgr[(*i).extra_ID(1) + i_ch - 2]);
3186  vee.chgd(1, tmp);
3187  } else {
3188  vee.chgd(1, (*i).chgd());
3189  }
3190 
3191  vee.px((*i).px());
3192  vee.py((*i).py());
3193  vee.pz((*i).pz());
3194  vee.energy((*i).energy());
3195  vee.vx((*i).vx());
3196  vee.vy((*i).vy());
3197  vee.vz((*i).vz());
3198  vee.z_dist((*i).z_dist());
3199  vee.chisq((*i).chisq());
3200  vee.type((*i).type());
3201  vee.daut((*i).daut());
3202  }
3203  teMgr.remove();
3204  steMgr.remove();
3205  sheMgr.remove();
3206  veMgr.remove();
3207  if (i_ch & 0xffffff00) B2ERROR("Warning from B2BIIFixMdst: overflow! i_ch = " << i_ch);
3208  if (i_trk & 0xffffff00) B2ERROR("Warning from B2BIIFixMdst: overflow! i_trk = " << i_trk);
3209  if (i_vee2 & 0xffffff00) B2ERROR("Warning from B2BIIFixMdst: overflow! i_vee2 = " << i_vee2);
3210  flag = i_ch & 0xff;
3211  flag |= ((i_trk & 0xff) << 8);
3212  flag |= ((i_vee2 & 0xff) << 16);
3213  mevtmgr[1].flag(0, flag);
3214  return (int)flag;
3215  }
3216 #if 0
3217  int
3218  B2BIIFixMdstModule::remove_extra_trk_vee2()
3219  {
3220  Belle::Mdst_event_add_Manager& mevtmgr = Belle::Mdst_event_add_Manager::get_manager();
3221  if (mevtmgr.count() <= 1) { // no Belle::Mdst_event_add table
3222  return -2;
3223  }
3224  unsigned flag(mevtmgr[1].flag(0));
3225  if (0 == flag) return -1; // do nothing if no extra tracks in Belle::Mdst_charged etc.
3226  const int i_ch(flag & 0xff);
3227  const int i_trk((flag >> 8) & 0xff);
3228  const int i_vee2((flag >> 16) & 0xff);
3229  Belle::Mdst_charged_Manager& chMgr(Belle::Mdst_charged_Manager::get_manager());
3230  Belle::Mdst_trk_Manager& tMgr(Belle::Mdst_trk_Manager::get_manager());
3231  Belle::Mdst_vee2_Manager& veeMgr(Belle::Mdst_vee2_Manager::get_manager());
3232  if (i_ch) {
3233  while (chMgr.count() >= i_ch) chMgr.remove(chMgr[chMgr.count() - 1]);
3234  }
3235  if (i_trk) {
3236  while (tMgr.count() >= i_trk) tMgr.remove(tMgr[tMgr.count() - 1]);
3237  }
3238  if (i_vee2) {
3239  while (veeMgr.count() >= i_vee2) veeMgr.remove(veeMgr[veeMgr.count() - 1]);
3240  }
3241  flag = 0;
3242  mevtmgr[1].flag(0, flag);
3243  return 0;
3244  }
3245 #else
3246  int
3247  B2BIIFixMdstModule::remove_extra_trk_vee2()
3248  {
3249  Belle::Mdst_event_add_Manager& mevtmgr = Belle::Mdst_event_add_Manager::get_manager();
3250  if (mevtmgr.count() <= 1) { // no Belle::Mdst_event_add table
3251  return -2;
3252  }
3253  unsigned flag(mevtmgr[1].flag(0));
3254  if (0 == flag) return -1; // do nothing if no extra tracks in Belle::Mdst_charged etc.
3255  const int i_ch(flag & 0xff);
3256  const int i_trk((flag >> 8) & 0xff);
3257  const int i_vee2((flag >> 16) & 0xff);
3258  //Belle::Mdst_charged_Manager////& chMgr(Belle::Mdst_charged_Manager::get_manager());
3259  Belle::Mdst_trk_Manager& tMgr(Belle::Mdst_trk_Manager::get_manager());
3260  Belle::Mdst_vee2_Manager& veeMgr(Belle::Mdst_vee2_Manager::get_manager());
3261  Belle::Mdst_trk_extra_Manager& teMgr(Belle::Mdst_trk_extra_Manager::get_manager());
3262  Belle::Mdst_vee2_extra_Manager& veeeMgr(Belle::Mdst_vee2_extra_Manager::get_manager());
3263  if (i_trk) {
3264  std::vector<int> extra_ID;
3265  if (teMgr.count()) teMgr.remove();
3266  for (std::vector<Belle::Mdst_trk>::iterator i = tMgr.begin();
3267  i != tMgr.end(); ++i) {
3268  if ((*i).get_ID() < i_trk) {
3269  extra_ID.push_back(0);
3270  continue;
3271  }
3272  if (!((*i).quality() & 16u)) {
3273  B2ERROR("Warning from B2BIIFixMdst: inconsistency between Belle::Mdst_trk and Belle::Mdst_evet_add"
3274  );
3275  }
3276  Belle::Mdst_trk_extra& trk(teMgr.add());
3277  for (int j = 0; j < 5; j++) trk.mhyp(j, (*i).mhyp(j));
3278  trk.quality((*i).quality());
3279  extra_ID.push_back(trk.get_ID());
3280  }
3281  if (i_vee2) {
3282  if (veeeMgr.count()) veeeMgr.remove();
3283  for (std::vector<Belle::Mdst_vee2>::iterator i = veeMgr.begin();
3284  i != veeMgr.end(); ++i) {
3285  if ((*i).get_ID() < i_vee2) continue;
3286  if (!((*i).chgd(0).trk().quality() & 16u) && !((*i).chgd(1).trk().quality() & 16u)) {
3287  B2ERROR("Warning from B2BIIFixMdst: inconsistency between Belle::Mdst_vee2 and Belle::Mdst_evet_add"
3288  );
3289  }
3290  Belle::Mdst_vee2_extra& vee(veeeMgr.add());
3291  vee.kind((*i).kind());
3292  const int extra_id0(extra_ID[(*i).chgd(0).trk_ID() - 1]);
3293  const int extra_id1(extra_ID[(*i).chgd(1).trk_ID() - 1]);
3294  if (extra_id0) {
3295  vee.extra(0, teMgr[extra_id0 - 1]);
3296  } else {
3297  vee.chgd((*i).chgd(0));
3298  }
3299  if (extra_id1) {
3300  vee.extra(1, teMgr[extra_id1 - 1]);
3301  } else {
3302  if (vee.chgd_ID()) {
3303  B2ERROR("Warning from B2BIIFixMdst: both tracks of Belle::Mdst_vee2_extra are good track"
3304  );
3305  }
3306  vee.chgd((*i).chgd(1));
3307  }
3308 
3309  vee.px((*i).px());
3310  vee.py((*i).py());
3311  vee.pz((*i).pz());
3312  vee.energy((*i).energy());
3313  vee.vx((*i).vx());
3314  vee.vy((*i).vy());
3315  vee.vz((*i).vz());
3316  vee.z_dist((*i).z_dist());
3317  vee.chisq((*i).chisq());
3318  vee.type((*i).type());
3319  vee.daut((*i).daut());
3320  }
3321  int id = BsCouTab(MDST_VEE2);
3322  while (id >= i_vee2) BsDelEnt(MDST_VEE2, id--);
3323  }
3324  int id = BsCouTab(MDST_TRK);
3325  while (id >= i_trk) BsDelEnt(MDST_TRK, id--);
3326  }
3327  if (i_ch) {
3328  int id = BsCouTab(MDST_CHARGED);
3329  while (id >= i_ch) BsDelEnt(MDST_CHARGED, id--);
3330  }
3331  flag = 0;
3332  mevtmgr[1].flag(0, flag);
3333  return 0;
3334  }
3335 
3336 //=======================================================================
3337 //Perform extra-smearing for MC tracks. The relevant code is extracted
3338 //from the module smear_trk originally coded by Marko Staric.
3339 //=======================================================================
3340 
3341  static void scale_err_ms(Belle::Mdst_trk_fit& fit, const double scale[]);
3342  static void smear_trk_ms(Belle::Mdst_trk_fit& fit, const double scale[]);
3343  static void smear_charged();
3345 //==========================
3346  void B2BIIFixMdstModule::smear_trk()
3347  {
3348 //==========================
3349  int expNo = 0, runNo = 0, expmc = 1;
3350  Belle::Belle_event_Manager& evtMgr = Belle::Belle_event_Manager::get_manager();
3351  if (evtMgr.count()) {
3352  expNo = evtMgr[0].ExpNo();
3353  runNo = evtMgr[0].RunNo();
3354  expmc = evtMgr[0].ExpMC();
3355  }
3356  if (expmc == 1) return; // nothing done for real data
3357 
3358  Belle::Mdst_event_add_Manager& addmgr = Belle::Mdst_event_add_Manager::get_manager();
3359  if (addmgr.count() == 0) {
3360  B2ERROR("No Belle::Mdst_event_add table -> kill the job");
3361  exit(-1);
3362  } else if (addmgr.count() >= 2) {
3363  if (addmgr[1].flag(1) != 0) return; //do nothing if already smeared
3364  }
3365 
3366  int flag_err = addmgr[0].flag_error();
3367 
3368  static bool start = true;
3369  if (start) {
3370  start = false;
3371  B2INFO("smear_trk: MC events -> track smearing is ON\n");
3372  }
3373 
3374  double scale_mc[5] = {1, 1, 1, 1, 1};
3375  double scale_rd[5] = {1, 1, 1, 1, 1};
3376  double scale[5];
3377 
3378  Belle::Mdst_trk_fit_Manager& fitmgr = Belle::Mdst_trk_fit_Manager::get_manager();
3379  for (std::vector<Belle::Mdst_trk_fit>::iterator it = fitmgr.begin(); it != fitmgr.end(); ++it) {
3380  Belle::Mdst_trk_fit& fit = *it;
3381  if (fit.helix(2) == 0.) continue;
3382 
3383  double pt = 1. / fabs(fit.helix(2));
3384  double tanl = fit.helix(4);
3385 
3386  cal_scale_error(scale_mc, pt, tanl, 0, expNo, runNo);
3387  cal_scale_error(scale_rd, pt, tanl, 1, expNo, runNo);
3388  for (int i = 0; i < 5; i++) scale[i] = scale_rd[i] / scale_mc[i];
3389 
3390  if (flag_err == 0) scale_err_ms(fit, scale_mc);
3391  smear_trk_ms(fit, scale);
3392  scale_err_ms(fit, scale);
3393  }
3394 
3395  if (m_smear_trk == 2) smear_charged();
3396 
3397  //set flag indicating already-err-scaled
3398  addmgr[0].flag_error(1);
3399 
3400  //set flag indicating already-smeared
3401  if (addmgr.count() == 1) {
3402  Belle::Mdst_event_add& meadd = addmgr.add();
3403  meadd.flag(1, 1);
3404  } else if (addmgr.count() >= 2) {
3405  addmgr[1].flag(1, 1);
3406  }
3407 
3408  }
3409 
3410 //====================================================
3411  void scale_err_ms(Belle::Mdst_trk_fit& fit, const double scale[])
3412  {
3413 //====================================================
3414  fit.error(0, scale[0]*scale[0]*fit.error(0));
3415  fit.error(1, scale[1]*scale[0]*fit.error(1));
3416  fit.error(2, scale[1]*scale[1]*fit.error(2));
3417  fit.error(3, scale[2]*scale[0]*fit.error(3));
3418  fit.error(4, scale[2]*scale[1]*fit.error(4));
3419  fit.error(5, scale[2]*scale[2]*fit.error(5));
3420  fit.error(6, scale[3]*scale[0]*fit.error(6));
3421  fit.error(7, scale[3]*scale[1]*fit.error(7));
3422  fit.error(8, scale[3]*scale[2]*fit.error(8));
3423  fit.error(9, scale[3]*scale[3]*fit.error(9));
3424  fit.error(10, scale[4]*scale[0]*fit.error(10));
3425  fit.error(11, scale[4]*scale[1]*fit.error(11));
3426  fit.error(12, scale[4]*scale[2]*fit.error(12));
3427  fit.error(13, scale[4]*scale[3]*fit.error(13));
3428  fit.error(14, scale[4]*scale[4]*fit.error(14));
3429 
3430  }
3431 
3432 //====================================================
3433  void smear_trk_ms(Belle::Mdst_trk_fit& fit, const double scale[])
3434  {
3435 //====================================================
3436  const int n = 5;
3437  double a[n][n];
3438  int k = 0;
3439  for (int i = 0; i < n; i++) {
3440  for (int j = 0; j <= i; j++) {
3441  a[i][j] = fit.error(k) * (scale[i] * scale[j] - 1.0);
3442  if (i != j) a[j][i] = a[i][j];
3443  k++;
3444  }
3445  }
3446 
3447  double u[n][n];
3448  //int pozdef = 1;
3449  for (int j = 0; j < n; j++) {
3450  double s = a[j][j];
3451  for (int k2 = 0; k2 < j; k2++) s -= u[j][k2] * u[j][k2];
3452  if (s > 0) {
3453  u[j][j] = sqrt(s);
3454  for (int i = j + 1; i < n; i++) {
3455  s = a[i][j];
3456  for (int k3 = 0; k3 < j; k3++) s -= u[i][k3] * u[j][k3];
3457  u[i][j] = s / u[j][j];
3458  }
3459  } else {
3460  for (int i = j; i < n; i++) u[i][j] = 0;
3461  //pozdef = 0;
3462  }
3463  }
3464 
3465  double g[n];
3466  for (int i = 0; i < n; i++) g[i] = gRandom->Gaus();
3467  double x[n];
3468  for (int i = 0; i < n; i++) {
3469  x[i] = 0;
3470  if (u[i][i] > 0) {
3471  for (int j = 0; j <= i; j++) x[i] += u[i][j] * g[j];
3472  }
3473  }
3474  for (int i = 0; i < n; i++) fit.helix(i, fit.helix(i) + x[i]);
3475 
3476  }
3477 
3478 //====================
3479  void smear_charged()
3480  {
3481 //====================
3482  Belle::Mdst_charged_Manager& chgmgr = Belle::Mdst_charged_Manager::get_manager();
3483  for (std::vector<Belle::Mdst_charged>::iterator it = chgmgr.begin(); it != chgmgr.end(); ++it) {
3484  Belle::Mdst_charged& c = *it;
3485  Belle::Mdst_trk_fit& t = c.trk().mhyp(2);
3486 
3487  double kp = std::abs(t.helix(2));
3488  kp = std::max(kp, 1.e-10);
3489  kp = std::min(kp, 1.e10);
3490  c.px(-sin(t.helix(1)) / kp);
3491  c.py(cos(t.helix(1)) / kp);
3492  c.pz(t.helix(4) / kp);
3493  }
3494 
3495  }
3496 
3497 #endif
3499 } // namespace Belle
Belle2::B2BIIFixMdstModule::m_smear_trk
int m_smear_trk
Do extra-smearing for MC tracks.
Definition: B2BIIFixMdstModule.h:155
Belle2::B2BIIFixMdstModule::m_reprocess_version
int m_reprocess_version
Reprocess version (=0:old; =1:new)
Definition: B2BIIFixMdstModule.h:181
Belle2::analysis::KFitBase::addTrack
enum KFitError::ECode addTrack(const KFitTrack &kp)
Add a track to the fitter object.
Definition: KFitBase.cc:38
Belle2::analysis::VertexFitKFit
VertexFitKFit is a derived class from KFitBase to perform vertex-constraint kinematical fit.
Definition: VertexFitKFit.h:34
Belle2::analysis::VertexFitKFit::setInitialVertex
enum KFitError::ECode setInitialVertex(const HepPoint3D &v)
Set an initial vertex point for the vertex-vertex constraint fit.
Definition: VertexFitKFit.cc:50
Belle2::analysis::VertexFitKFit::getVertexError
const CLHEP::HepSymMatrix getVertexError(void) const
Get a fitted vertex error matrix.
Definition: VertexFitKFit.cc:132
Belle2::analysis::VertexFitKFit::doFit
enum KFitError::ECode doFit(void)
Perform a vertex-constraint fit.
Definition: VertexFitKFit.cc:215
Belle2::analysis::VertexFitKFit::setIpProfile
enum KFitError::ECode setIpProfile(const HepPoint3D &ip, const CLHEP::HepSymMatrix &ipe)
Set an IP-ellipsoid shape for the vertex constraint fit.
Definition: VertexFitKFit.cc:64
Belle2::analysis::VertexFitKFit::getVertex
const HepPoint3D getVertex(const int flag=KFitConst::kAfterFit) const
Get a vertex position.
Definition: VertexFitKFit.cc:113
Belle2::operator==
bool operator==(const DecayNode &node1, const DecayNode &node2)
Compare two Decay Nodes: They are equal if All daughter decay nodes are equal or one of the daughter ...
Definition: DecayNode.cc:48
Belle2::EXP6165_scale
static const struct cal_scale_error_func_set_t EXP6165_scale
Scale error for Exp.61-65.
Definition: B2BIIFixMdstModule_trk.cc:2597
Belle2::cal_scale_error_EXP0723_cosmic_data
static void cal_scale_error_EXP0723_cosmic_data(double scale[5], const double pt, const double)
Scale error for Exp.7-23 Cosmic data.
Definition: B2BIIFixMdstModule_trk.cc:1882
Belle2::cal_scale_error_EXP4547_cosmic_data
static void cal_scale_error_EXP4547_cosmic_data(double scale[5], double pt, double)
Scale error for Exp.45,47 Cosmic data.
Definition: B2BIIFixMdstModule_trk.cc:2032
Belle2::cal_scale_error_EXP0723_hadronic_mc
static void cal_scale_error_EXP0723_hadronic_mc(double scale[5], const double pt, const double tanl)
Scale error for Exp.7-23 Hadron MC.
Definition: B2BIIFixMdstModule_trk.cc:2199
Belle2::smear_trk_ms
static void smear_trk_ms(Belle::Mdst_trk_fit &fit, const double scale[])
Smear MC tracks.
Definition: B2BIIFixMdstModule_trk.cc:3433
Belle2::cupfunc
double cupfunc(const double x, const double x1, const double x2, const double yc, const double a1, const double a2)
cupfunc
Definition: B2BIIFixMdstModule_trk.cc:1526
Belle2::cal_scale_error_EXP0723_cosmic_mc
static void cal_scale_error_EXP0723_cosmic_mc(double scale[5], const double pt, const double)
Scale error for Exp.7-23 Cosmic MC.
Definition: B2BIIFixMdstModule_trk.cc:1559
Belle2::cal_scale_error_EXP37_cosmic_data
static void cal_scale_error_EXP37_cosmic_data(double scale[5], double pt, double)
Scale error for Exp.37 Cosmic data.
Definition: B2BIIFixMdstModule_trk.cc:1984
Belle2::cal_scale_error_EXP43_hadronic_mc
static void cal_scale_error_EXP43_hadronic_mc(double scale[5], double pt, double)
Scale error for Exp.43 Hadron MC.
Definition: B2BIIFixMdstModule_trk.cc:2343
Belle2::B2BIIFixMdstModule::scale_momenta_set_v2
void scale_momenta_set_v2(const int, const int, const int, double &)
Return scale factors set_v2.
Definition: B2BIIFixMdstModule_trk.cc:1004
Belle2::cal_scale_error_EXP6971_cosmic_mc
static void cal_scale_error_EXP6971_cosmic_mc(double scale[5], double pt, double tanl)
Scale error for Exp.69-71 Cosmic MC.
Definition: B2BIIFixMdstModule_trk.cc:1858
Belle2::cal_scale_error_EXP35_cosmic_data
static void cal_scale_error_EXP35_cosmic_data(double scale[5], double pt, double tanl)
Scale error for Exp.35 Cosmic data.
Definition: B2BIIFixMdstModule_trk.cc:1964
Belle2::cal_scale_error_EXP45_hadronic_mc
static void cal_scale_error_EXP45_hadronic_mc(double scale[5], double pt, double tanl)
Scale error for Exp.45 Hadron MC.
Definition: B2BIIFixMdstModule_trk.cc:2359
Belle2::cal_scale_error_EXP43_cosmic_mc
static void cal_scale_error_EXP43_cosmic_mc(double scale[5], double pt, double)
Scale error for Exp.43 Cosmic MC.
Definition: B2BIIFixMdstModule_trk.cc:1697
Belle2::EXP2527_scale
static const struct cal_scale_error_func_set_t EXP2527_scale
Scale error for Exp.25-27.
Definition: B2BIIFixMdstModule_trk.cc:2519
Belle2::cal_scale_error_EXP67_cosmic_mc
static void cal_scale_error_EXP67_cosmic_mc(double scale[5], double pt, double tanl)
Scale error for Exp.67 Cosmic MC.
Definition: B2BIIFixMdstModule_trk.cc:1832
Belle2::cal_scale_error_EXP6165_cosmic_data
static void cal_scale_error_EXP6165_cosmic_data(double scale[5], double pt, double tanl)
Scale error for Exp.61-65 Cosmic data.
Definition: B2BIIFixMdstModule_trk.cc:2126
Belle2::cal_scale_error_EXP51_hadronic_mc
static void cal_scale_error_EXP51_hadronic_mc(double scale[5], double pt, double tanl)
Scale error for Exp.51 Hadron MC.
Definition: B2BIIFixMdstModule_trk.cc:2411
Belle2::cal_scale_error_EXP53_hadronic_mc
static void cal_scale_error_EXP53_hadronic_mc(double scale[5], double pt, double)
Scale error for Exp.53 Hadron MC.
Definition: B2BIIFixMdstModule_trk.cc:2430
Belle2::EXP45_scale
static const struct cal_scale_error_func_set_t EXP45_scale
Scale error for Exp.45.
Definition: B2BIIFixMdstModule_trk.cc:2561
Belle2::recsim_mdst_propgt_
void recsim_mdst_propgt_(float *, float[], float[], float[], float[], float[], int *)
recsim_mdst_propgt from legacy C code
Belle2::cal_scale_error_EXP31_hadronic_mc
static void cal_scale_error_EXP31_hadronic_mc(double scale[5], double pt, double tanl)
Scale error for Exp.31 Hadron MC.
Definition: B2BIIFixMdstModule_trk.cc:2245
Belle2::cal_scale_error_EXP3941_cosmic_mc
static void cal_scale_error_EXP3941_cosmic_mc(double scale[5], double pt, double)
Scale error for Exp.39,41 Cosmic MC.
Definition: B2BIIFixMdstModule_trk.cc:1681
Belle2::cal_scale_error_EXP53_cosmic_mc
static void cal_scale_error_EXP53_cosmic_mc(double scale[5], double pt, double)
Scale error for Exp.53 Cosmic MC.
Definition: B2BIIFixMdstModule_trk.cc:1777
Belle2::cal_scale_error_EXP31_cosmic_mc
static void cal_scale_error_EXP31_cosmic_mc(double scale[5], double pt, double)
Scale error for Exp.31 Cosmic MC.
Definition: B2BIIFixMdstModule_trk.cc:1591
Belle2::EXP3941_scale
static const struct cal_scale_error_func_set_t EXP3941_scale
Scale error for Exp.39,41.
Definition: B2BIIFixMdstModule_trk.cc:2549
Belle2::EXP31_scale
static const struct cal_scale_error_func_set_t EXP31_scale
Scale error for Exp.31.
Definition: B2BIIFixMdstModule_trk.cc:2525
Belle2::cal_scale_error_EXP3941_cosmic_data
static void cal_scale_error_EXP3941_cosmic_data(double scale[5], double pt, double)
Scale error for Exp.39-41 Cosmic data.
Definition: B2BIIFixMdstModule_trk.cc:2000
Belle2::cal_scale_error_EXP49_cosmic_mc
static void cal_scale_error_EXP49_cosmic_mc(double scale[5], double pt, double)
Scale error for Exp.49 Cosmic MC.
Definition: B2BIIFixMdstModule_trk.cc:1745
Belle2::EXP6971_scale
static const struct cal_scale_error_func_set_t EXP6971_scale
Scale error for Exp.69-71.
Definition: B2BIIFixMdstModule_trk.cc:2609
Belle2::SE_Reprocess_Version
static int SE_Reprocess_Version
Reprocess verison used in scale_error()
Definition: B2BIIFixMdstModule_trk.cc:1435
Belle2::cal_scale_error_EXP67_cosmic_data
static void cal_scale_error_EXP67_cosmic_data(double scale[5], double pt, double tanl)
Scale error for Exp.67 Cosmic data.
Definition: B2BIIFixMdstModule_trk.cc:2149
Belle2::cal_scale_error_EXP33_cosmic_data
static void cal_scale_error_EXP33_cosmic_data(double scale[5], double pt, double)
Scale error for Exp.33 Cosmic data.
Definition: B2BIIFixMdstModule_trk.cc:1934
Belle2::cal_scale_error_EXP49_hadronic_mc
static void cal_scale_error_EXP49_hadronic_mc(double scale[5], double pt, double)
Scale error for Exp.49 Hadron MC.
Definition: B2BIIFixMdstModule_trk.cc:2394
Belle2::smear_charged
static void smear_charged()
Smear tracks in Mdst_Charged.
Definition: B2BIIFixMdstModule_trk.cc:3479
Belle2::cal_scale_error_EXP6165_cosmic_mc
static void cal_scale_error_EXP6165_cosmic_mc(double scale[5], double pt, double tanl)
Scale error for Exp.61-65 Cosmic MC.
Definition: B2BIIFixMdstModule_trk.cc:1809
Belle2::cal_scale_error_EXP55_cosmic_data
static void cal_scale_error_EXP55_cosmic_data(double scale[5], double pt, double tanl)
Scale error for Exp.55 Cosmic data.
Definition: B2BIIFixMdstModule_trk.cc:2103
Belle2::B2BIIFixMdstModule::smear_trk
void smear_trk()
Apply track smearing (on MC)
Definition: B2BIIFixMdstModule_trk.cc:3346
Belle2::EXP43_scale
static const struct cal_scale_error_func_set_t EXP43_scale
Scale error for Exp.43.
Definition: B2BIIFixMdstModule_trk.cc:2555
Belle2::B2BIIFixMdstModule::remove_extra_trk_vee2
int remove_extra_trk_vee2()
Remove extra tracks from Mdst_trk and Mdst_vee2.
Definition: B2BIIFixMdstModule_trk.cc:3247
Belle2::cal_scale_error
static void cal_scale_error(double scale[5], const double pt, const double tanl, const int expmc, const int no_exp, const int no_run)
Calculate scale error.
Definition: B2BIIFixMdstModule_trk.cc:2649
Belle2::EXP47_scale
static const struct cal_scale_error_func_set_t EXP47_scale
Scale error for Exp.47.
Definition: B2BIIFixMdstModule_trk.cc:2567
Belle2::cal_scale_error_EXP53_cosmic_data
static void cal_scale_error_EXP53_cosmic_data(double scale[5], double pt, double)
Scale error for Exp.53 Cosmic data.
Definition: B2BIIFixMdstModule_trk.cc:2087
Belle2::rootfunc
double rootfunc(const double x, const double x1, const double x2, const double yc, const double a1, const double a2)
rootfunc
Definition: B2BIIFixMdstModule_trk.cc:1533
Belle2::EXP53_scale
static const struct cal_scale_error_func_set_t EXP53_scale
Scale error for Exp.53.
Definition: B2BIIFixMdstModule_trk.cc:2585
Belle2::EXP0723_scale
static const struct cal_scale_error_func_set_t EXP0723_scale
Scale error for Exp.7-23.
Definition: B2BIIFixMdstModule_trk.cc:2513
Belle2::lambdafunc
double lambdafunc(const double x, const double x1, const double x2, const double yc, const double a1, const double a2, const double a3)
lambdafunc
Definition: B2BIIFixMdstModule_trk.cc:1541
Belle2::EXP51_scale
static const struct cal_scale_error_func_set_t EXP51_scale
Scale error for Exp.51.
Definition: B2BIIFixMdstModule_trk.cc:2579
Belle2::scale_error_impl
static int scale_error_impl(const int message_level, const int reprocess_version)
The implementation of B2BIIFixMdstModule::scale_error()
Definition: B2BIIFixMdstModule_trk.cc:2775
Belle2::EXP67_scale
static const struct cal_scale_error_func_set_t EXP67_scale
Scale error for Exp.67.
Definition: B2BIIFixMdstModule_trk.cc:2603
Belle2::cal_scale_error_EXP33_cosmic_mc
static void cal_scale_error_EXP33_cosmic_mc(double scale[5], double pt, double)
Scale error for Exp.33 Cosmic MC.
Definition: B2BIIFixMdstModule_trk.cc:1612
Belle2::B2BIIFixMdstModule::scale_momenta_set_v1
void scale_momenta_set_v1(const int, const int, const int, double &)
Return scale factors set_v1.
Definition: B2BIIFixMdstModule_trk.cc:528
Belle2::cal_scale_error_EXP37_hadronic_mc
static void cal_scale_error_EXP37_hadronic_mc(double scale[5], double pt, double tanl)
Scale error for Exp.37 Hadron MC.
Definition: B2BIIFixMdstModule_trk.cc:2307
Belle2::cal_scale_error_EXP37_cosmic_mc
static void cal_scale_error_EXP37_cosmic_mc(double scale[5], double pt, double)
Scale error for Exp.37 Cosmic MC.
Definition: B2BIIFixMdstModule_trk.cc:1664
Belle2::B2BIIFixMdstModule::add_extra_trk_vee2
int add_extra_trk_vee2()
Add Mdst_trk_extra and Mdst_vee_extra to Mdst_trk and Mdst_vee2, respectively.
Definition: B2BIIFixMdstModule_trk.cc:3071
Belle2::SE_Message_Level
static int SE_Message_Level
Message level of scale_error().
Definition: B2BIIFixMdstModule_trk.cc:1434
Belle2::DUMMY_scale
static const struct cal_scale_error_func_set_t DUMMY_scale
Dummy scale.
Definition: B2BIIFixMdstModule_trk.cc:2615
Belle2::cal_scale_error_func_t
void(* cal_scale_error_func_t)(double scale[5], const double pt, const double tanl)
Function pointer type.
Definition: B2BIIFixMdstModule_trk.cc:1438
Belle2::cal_scale_error_EXP67_hadronic_mc
static void cal_scale_error_EXP67_hadronic_mc(double scale[5], double pt, double)
Scale error for Exp.67 Hadron MC.
Definition: B2BIIFixMdstModule_trk.cc:2478
Belle2::cal_scale_error_EXP45_cosmic_mc
static void cal_scale_error_EXP45_cosmic_mc(double scale[5], double pt, double)
Scale error for Exp.45 Cosmic MC.
Definition: B2BIIFixMdstModule_trk.cc:1713
Belle2::B2BIIFixMdstModule::set_primary_vertex
int set_primary_vertex(HepPoint3D &v, CLHEP::HepSymMatrix &ve)
Set primary vertex assuming all tracks are pions.
Definition: B2BIIFixMdstModule_trk.cc:2928
Belle2::EXP35_scale
static const struct cal_scale_error_func_set_t EXP35_scale
Scale error for Exp.35.
Definition: B2BIIFixMdstModule_trk.cc:2537
Belle2::cal_scale_error_EXP47_cosmic_mc
static void cal_scale_error_EXP47_cosmic_mc(double scale[5], double pt, double)
Scale error for Exp.47 Cosmic MC.
Definition: B2BIIFixMdstModule_trk.cc:1729
Belle2::cal_scale_error_EXP33_hadronic_mc
static void cal_scale_error_EXP33_hadronic_mc(double scale[5], double pt, double tanl)
Scale error for Exp.33,35 Hadron MC.
Definition: B2BIIFixMdstModule_trk.cc:2266
Belle2::cal_scale_error_EXP6971_hadronic_mc
static void cal_scale_error_EXP6971_hadronic_mc(double scale[5], double pt, double)
Scale error for Exp.69,71 Hadron MC.
Definition: B2BIIFixMdstModule_trk.cc:2497
Belle2::cal_scale_error_EXP49_cosmic_data
static void cal_scale_error_EXP49_cosmic_data(double scale[5], double pt, double)
Scale error for Exp.49 Cosmic data.
Definition: B2BIIFixMdstModule_trk.cc:2048
Belle2::B2BIIFixMdstModule::scale_momenta
void scale_momenta(float scale_data=1.0, float scale_mc=1.0, int mode=0)
Scale momenta of Mdst_trk.
Definition: B2BIIFixMdstModule_trk.cc:277
Belle2::scale_err_ms
static void scale_err_ms(Belle::Mdst_trk_fit &fit, const double scale[])
Scale error.
Definition: B2BIIFixMdstModule_trk.cc:3411
Belle2::EXP49_scale
static const struct cal_scale_error_func_set_t EXP49_scale
Scale error for Exp.49.
Definition: B2BIIFixMdstModule_trk.cc:2573
Belle2::B2BIIFixMdstModule::scale_error
void scale_error(const int message_level=0)
Apply scale error.
Definition: B2BIIFixMdstModule_trk.cc:2886
Belle2::cal_scale_error_EXP55_cosmic_mc
static void cal_scale_error_EXP55_cosmic_mc(double scale[5], double pt, double)
Scale error for Exp.55 Cosmic MC.
Definition: B2BIIFixMdstModule_trk.cc:1793
Belle2::EXP37_scale
static const struct cal_scale_error_func_set_t EXP37_scale
Scale error for Exp.37.
Definition: B2BIIFixMdstModule_trk.cc:2543
Belle2::get_event_id
static void get_event_id(int *no_exp, int *no_run, int *no_evt, int *no_frm, int *expmc)
Get event ID.
Definition: B2BIIFixMdstModule_trk.cc:1469
Belle2::B2BIIFixMdstModule::scale_momenta_set
void scale_momenta_set(const int, const int, const int, double &)
Return scale factors for 2001 summer confs.
Definition: B2BIIFixMdstModule_trk.cc:406
Belle2::cal_scale_error_EXP55_hadronic_mc
static void cal_scale_error_EXP55_hadronic_mc(double scale[5], double pt, double)
Scale error for Exp.55 Hadron MC.
Definition: B2BIIFixMdstModule_trk.cc:2446
Belle2::cal_scale_error_EXP2527_cosmic_data
static void cal_scale_error_EXP2527_cosmic_data(double scale[5], const double pt, const double)
Scale error for Exp.25-27 Cosmic data.
Definition: B2BIIFixMdstModule_trk.cc:1898
Belle2::cal_scale_error_EXP35_hadronic_mc
static void cal_scale_error_EXP35_hadronic_mc(double scale[5], double pt, double tanl)
Scale error for Exp.33,35 Hadron MC.
Definition: B2BIIFixMdstModule_trk.cc:2296
Belle2::cal_scale_error_EXP2527_cosmic_mc
static void cal_scale_error_EXP2527_cosmic_mc(double scale[5], const double pt, const double)
Scale error for Exp.25-27 Cosmic MC.
Definition: B2BIIFixMdstModule_trk.cc:1575
Belle2::cal_scale_error_EXP6971_cosmic_data
static void cal_scale_error_EXP6971_cosmic_data(double scale[5], double pt, double tanl)
Scale error for Exp.69,71 Cosmic data.
Definition: B2BIIFixMdstModule_trk.cc:2175
Belle2::null_scale
static void null_scale(double[5], double, double)
Dummy function.
Definition: B2BIIFixMdstModule_trk.cc:1459
Belle2::is_already_scaled
static bool is_already_scaled(void)
Check if event is already scaled.
Definition: B2BIIFixMdstModule_trk.cc:1486
Belle2::EXP33_scale
static const struct cal_scale_error_func_set_t EXP33_scale
Scale error for Exp.33.
Definition: B2BIIFixMdstModule_trk.cc:2531
Belle2::vfunc
double vfunc(const double x, const double x1, const double yc, const double a1, const double a2)
vfunc
Definition: B2BIIFixMdstModule_trk.cc:1519
Belle2::cal_scale_error_EXP43_cosmic_data
static void cal_scale_error_EXP43_cosmic_data(double scale[5], double pt, double)
Scale error for Exp.43 Cosmic data.
Definition: B2BIIFixMdstModule_trk.cc:2016
Belle2::B2BIIFixMdstModule::vee_mass_nofit
double vee_mass_nofit(const Belle::Mdst_vee2 &vee2, float scale=1.0)
Calculates V0 mass with non-constraint fit results.
Definition: B2BIIFixMdstModule_trk.cc:189
Belle2::EXP55_scale
static const struct cal_scale_error_func_set_t EXP55_scale
Scale error for Exp.55.
Definition: B2BIIFixMdstModule_trk.cc:2591
Belle2::get_scale_error_func_for_exprun
static cal_scale_error_func_set_t get_scale_error_func_for_exprun(const int no_exp, const int)
Get scale error fucntion for different Exp.
Definition: B2BIIFixMdstModule_trk.cc:2624
Belle2::cal_scale_error_EXP31_cosmic_data
static void cal_scale_error_EXP31_cosmic_data(double scale[5], double pt, double)
Scale error for Exp.31 Cosmic data.
Definition: B2BIIFixMdstModule_trk.cc:1914
Belle2::cal_scale_error_EXP51_cosmic_data
static void cal_scale_error_EXP51_cosmic_data(double scale[5], double pt, double tanl)
Scale error for Exp.51 Cosmic data.
Definition: B2BIIFixMdstModule_trk.cc:2064
Belle2::cal_scale_error_EXP3941_hadronic_mc
static void cal_scale_error_EXP3941_hadronic_mc(double scale[5], double pt, double)
Scale error for Exp.39,41 Hadron MC.
Definition: B2BIIFixMdstModule_trk.cc:2327
Belle2::cal_scale_error_EXP35_cosmic_mc
static void cal_scale_error_EXP35_cosmic_mc(double scale[5], double pt, double tanl)
Scale error for Exp.35 Cosmic MC.
Definition: B2BIIFixMdstModule_trk.cc:1643
Belle2::cal_scale_error_EXP6165_hadronic_mc
static void cal_scale_error_EXP6165_hadronic_mc(double scale[5], double pt, double)
Scale error for Exp.61-65 Hadron MC.
Definition: B2BIIFixMdstModule_trk.cc:2462
Belle2::cal_scale_error_EXP2527_hadronic_mc
static void cal_scale_error_EXP2527_hadronic_mc(double scale[5], const double pt, const double tanl)
Scale error for Exp.25-27 Hadron MC.
Definition: B2BIIFixMdstModule_trk.cc:2222
Belle2::cal_scale_error_EXP51_cosmic_mc
static void cal_scale_error_EXP51_cosmic_mc(double scale[5], double pt, double)
Scale error for Exp.51 Cosmic MC.
Definition: B2BIIFixMdstModule_trk.cc:1761
Belle2::cal_scale_error_EXP47_hadronic_mc
static void cal_scale_error_EXP47_hadronic_mc(double scale[5], double pt, double)
Scale error for Exp.47 Hadron MC.
Definition: B2BIIFixMdstModule_trk.cc:2378
Belle2::sqrt
double sqrt(double a)
sqrt for double
Definition: beamHelpers.h:28
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17
Belle2::cal_scale_error_func_set_t
Structure type cal_scale_error_func_set_t.
Definition: B2BIIFixMdstModule_trk.cc:1441
Belle2::cal_scale_error_func_set_t::m_cosMC
cal_scale_error_func_t m_cosMC
For cosmic MC.
Definition: B2BIIFixMdstModule_trk.cc:1443
Belle2::cal_scale_error_func_set_t::m_cosDATA
cal_scale_error_func_t m_cosDATA
For cosmic data.
Definition: B2BIIFixMdstModule_trk.cc:1444
Belle2::cal_scale_error_func_set_t::m_hadMC
cal_scale_error_func_t m_hadMC
For hadronic MC.
Definition: B2BIIFixMdstModule_trk.cc:1442