b2bii modules

Collaboration diagram for b2bii modules:

Classes
class	B2BIIMCParticlesMonitorModule
	Declaration of class B2BIIMCParticlesMonitor. More...
class	B2BIIConvertBeamParamsModule
	Convert the IpProfile and Benergy to BeamParameters, BeamSpot, CollisionInvariantMass and CollisionBoostVector. More...
class	B2BIIConvertMdstModule
	Module converts Belle MDST objects (Panther records) to Belle II MDST objects. More...
class	B2BIIFixMdstModule
	Declaration of class B2BIIFixMdst. More...
class	MuidProb
	Class computes probability density for Muid calculation. More...
class	B2BIIMdstInputModule
	Module reads Belle MDST files and converts Belle_event record to Belle II EventMetaData StoreObjectPointer. More...
struct	cal_scale_error_func_set_t
	Structure type cal_scale_error_func_set_t. More...
class	BelleMCOutputModule
	KLM digitization module. More...

Macros
#define	NOMINAL_ENERGY   5.290024915
	Nomial beam energy.

Typedefs
typedef void(*	cal_scale_error_func_t) (double scale[5], const double pt, const double tanl)
	Function pointer type.

Functions
	REG_MODULE (B2BIIConvertBeamParams)
	Register the module.
static double	ecl_adhoc_corr (int Exp, int Run, int iflag05th, double Energy, double)
	The function giving correction factor.
static double	ecl_adhoc_corr_45 (int exp, int, int cid)
	The function giving correction factor in Exp.45.
static double	ecl_mcx3_corr (int, int, double energy, double)
	Correct energy scale (MC) to make pi0 peak nominal.
static double	mpi0pdg (double Energy)
	Make MC mass peak to PDG value.
static bool	operator== (const cal_scale_error_func_set_t &lhs, const cal_scale_error_func_set_t &rhs)
	Operator definition for cal_scale_error_func_set_t.
static void	null_scale (double[5], double, double)
	Dummy function.
static void	get_event_id (int *no_exp, int *no_run, int *no_evt, int *no_frm, int *expmc)
	Get event ID.
static bool	is_already_scaled (void)
	Check if event is already scaled.
double	vfunc (const double x, const double x1, const double yc, const double a1, const double a2)
	vfunc
double	cupfunc (const double x, const double x1, const double x2, const double yc, const double a1, const double a2)
	cupfunc
double	rootfunc (const double x, const double x1, const double x2, const double yc, const double a1, const double a2)
	rootfunc
double	lambdafunc (const double x, const double x1, const double x2, const double yc, const double a1, const double a2, const double a3)
	lambdafunc
static void	cal_scale_error_EXP0723_cosmic_mc (double scale[5], const double pt, const double)
	Scale error for Exp.7-23 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.
static void	cal_scale_error_EXP31_cosmic_mc (double scale[5], double pt, double)
	Scale error for Exp.31 Cosmic MC.
static void	cal_scale_error_EXP33_cosmic_mc (double scale[5], double pt, double)
	Scale error for Exp.33 Cosmic MC.
static void	cal_scale_error_EXP35_cosmic_mc (double scale[5], double pt, double tanl)
	Scale error for Exp.35 Cosmic MC.
static void	cal_scale_error_EXP37_cosmic_mc (double scale[5], double pt, double)
	Scale error for Exp.37 Cosmic MC.
static void	cal_scale_error_EXP3941_cosmic_mc (double scale[5], double pt, double)
	Scale error for Exp.39,41 Cosmic MC.
static void	cal_scale_error_EXP43_cosmic_mc (double scale[5], double pt, double)
	Scale error for Exp.43 Cosmic MC.
static void	cal_scale_error_EXP45_cosmic_mc (double scale[5], double pt, double)
	Scale error for Exp.45 Cosmic MC.
static void	cal_scale_error_EXP47_cosmic_mc (double scale[5], double pt, double)
	Scale error for Exp.47 Cosmic MC.
static void	cal_scale_error_EXP49_cosmic_mc (double scale[5], double pt, double)
	Scale error for Exp.49 Cosmic MC.
static void	cal_scale_error_EXP51_cosmic_mc (double scale[5], double pt, double)
	Scale error for Exp.51 Cosmic MC.
static void	cal_scale_error_EXP53_cosmic_mc (double scale[5], double pt, double)
	Scale error for Exp.53 Cosmic MC.
static void	cal_scale_error_EXP55_cosmic_mc (double scale[5], double pt, double)
	Scale error for Exp.55 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.
static void	cal_scale_error_EXP67_cosmic_mc (double scale[5], double pt, double tanl)
	Scale error for Exp.67 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.
static void	cal_scale_error_EXP0723_cosmic_data (double scale[5], const double pt, const double)
	Scale error for Exp.7-23 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.
static void	cal_scale_error_EXP31_cosmic_data (double scale[5], double pt, double)
	Scale error for Exp.31 Cosmic data.
static void	cal_scale_error_EXP33_cosmic_data (double scale[5], double pt, double)
	Scale error for Exp.33 Cosmic data.
static void	cal_scale_error_EXP35_cosmic_data (double scale[5], double pt, double tanl)
	Scale error for Exp.35 Cosmic data.
static void	cal_scale_error_EXP37_cosmic_data (double scale[5], double pt, double)
	Scale error for Exp.37 Cosmic data.
static void	cal_scale_error_EXP3941_cosmic_data (double scale[5], double pt, double)
	Scale error for Exp.39-41 Cosmic data.
static void	cal_scale_error_EXP43_cosmic_data (double scale[5], double pt, double)
	Scale error for Exp.43 Cosmic data.
static void	cal_scale_error_EXP4547_cosmic_data (double scale[5], double pt, double)
	Scale error for Exp.45,47 Cosmic data.
static void	cal_scale_error_EXP49_cosmic_data (double scale[5], double pt, double)
	Scale error for Exp.49 Cosmic data.
static void	cal_scale_error_EXP51_cosmic_data (double scale[5], double pt, double tanl)
	Scale error for Exp.51 Cosmic data.
static void	cal_scale_error_EXP53_cosmic_data (double scale[5], double pt, double)
	Scale error for Exp.53 Cosmic data.
static void	cal_scale_error_EXP55_cosmic_data (double scale[5], double pt, double tanl)
	Scale error for Exp.55 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.
static void	cal_scale_error_EXP67_cosmic_data (double scale[5], double pt, double tanl)
	Scale error for Exp.67 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.
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.
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.
static void	cal_scale_error_EXP31_hadronic_mc (double scale[5], double pt, double tanl)
	Scale error for Exp.31 Hadron MC.
static void	cal_scale_error_EXP33_hadronic_mc (double scale[5], double pt, double tanl)
	Scale error for Exp.33,35 Hadron MC.
static void	cal_scale_error_EXP35_hadronic_mc (double scale[5], double pt, double tanl)
	Scale error for Exp.33,35 Hadron MC.
static void	cal_scale_error_EXP37_hadronic_mc (double scale[5], double pt, double tanl)
	Scale error for Exp.37 Hadron MC.
static void	cal_scale_error_EXP3941_hadronic_mc (double scale[5], double pt, double)
	Scale error for Exp.39,41 Hadron MC.
static void	cal_scale_error_EXP43_hadronic_mc (double scale[5], double pt, double)
	Scale error for Exp.43 Hadron MC.
static void	cal_scale_error_EXP45_hadronic_mc (double scale[5], double pt, double tanl)
	Scale error for Exp.45 Hadron MC.
static void	cal_scale_error_EXP47_hadronic_mc (double scale[5], double pt, double)
	Scale error for Exp.47 Hadron MC.
static void	cal_scale_error_EXP49_hadronic_mc (double scale[5], double pt, double)
	Scale error for Exp.49 Hadron MC.
static void	cal_scale_error_EXP51_hadronic_mc (double scale[5], double pt, double tanl)
	Scale error for Exp.51 Hadron MC.
static void	cal_scale_error_EXP53_hadronic_mc (double scale[5], double pt, double)
	Scale error for Exp.53 Hadron MC.
static void	cal_scale_error_EXP55_hadronic_mc (double scale[5], double pt, double)
	Scale error for Exp.55 Hadron MC.
static void	cal_scale_error_EXP6165_hadronic_mc (double scale[5], double pt, double)
	Scale error for Exp.61-65 Hadron MC.
static void	cal_scale_error_EXP67_hadronic_mc (double scale[5], double pt, double)
	Scale error for Exp.67 Hadron MC.
static void	cal_scale_error_EXP6971_hadronic_mc (double scale[5], double pt, double)
	Scale error for Exp.69,71 Hadron MC.
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.
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.
static int	scale_error_impl (const int message_level, const int reprocess_version)
	The implementation of B2BIIFixMdstModule::scale_error()
void	recsim_mdst_propgt_ (float *, float[], float[], float[], float[], float[], int *)
	recsim_mdst_propgt from legacy C code
static void	scale_err_ms (Belle::Mdst_trk_fit &fit, const double scale[])
	Scale error.
static void	smear_trk_ms (Belle::Mdst_trk_fit &fit, const double scale[])
	Smear MC tracks.
static void	smear_charged ()
	Smear tracks in Mdst_Charged.
	B2BIIConvertBeamParamsModule ()
	Create parameters.
void	initialize () override
	Initialize phanter banks.
void	beginRun () override
	Set run info in panther and load IPProfile/Benergy and convert the values to payloads.
	B2BIIFixMdstModule ()
	Constructor.
virtual void	initialize () override
	Initialize the module.
virtual void	terminate () override
	Terminates the module.
virtual void	event () override
	Called for each event.
virtual void	beginRun () override
	Called when a new run is started.

Variables
static int	SE_Message_Level
	Message level of scale_error().
static int	SE_Reprocess_Version = 0
	Reprocess verison used in scale_error()
static const struct cal_scale_error_func_set_t	EXP0723_scale
	Scale error for Exp.7-23.
static const struct cal_scale_error_func_set_t	EXP2527_scale
	Scale error for Exp.25-27.
static const struct cal_scale_error_func_set_t	EXP31_scale
	Scale error for Exp.31.
static const struct cal_scale_error_func_set_t	EXP33_scale
	Scale error for Exp.33.
static const struct cal_scale_error_func_set_t	EXP35_scale
	Scale error for Exp.35.
static const struct cal_scale_error_func_set_t	EXP37_scale
	Scale error for Exp.37.
static const struct cal_scale_error_func_set_t	EXP3941_scale
	Scale error for Exp.39,41.
static const struct cal_scale_error_func_set_t	EXP43_scale
	Scale error for Exp.43.
static const struct cal_scale_error_func_set_t	EXP45_scale
	Scale error for Exp.45.
static const struct cal_scale_error_func_set_t	EXP47_scale
	Scale error for Exp.47.
static const struct cal_scale_error_func_set_t	EXP49_scale
	Scale error for Exp.49.
static const struct cal_scale_error_func_set_t	EXP51_scale
	Scale error for Exp.51.
static const struct cal_scale_error_func_set_t	EXP53_scale
	Scale error for Exp.53.
static const struct cal_scale_error_func_set_t	EXP55_scale
	Scale error for Exp.55.
static const struct cal_scale_error_func_set_t	EXP6165_scale
	Scale error for Exp.61-65.
static const struct cal_scale_error_func_set_t	EXP67_scale
	Scale error for Exp.67.
static const struct cal_scale_error_func_set_t	EXP6971_scale
	Scale error for Exp.69-71.
static const struct cal_scale_error_func_set_t	DUMMY_scale
	Dummy scale.
static double	s_benergy_value = NOMINAL_ENERGY
	Beam energy.

Muid user parameters (set via basf)
int	get_reprocess_version ()
	Get reprocess version of input mdst.
bool	good_event ()
	Check if event correspondes to the period when Belle detector not in good condition.
double	Benergy (int expnum=0, int runnum=0)
	Return Beam energy.
void	fix_pi0_brecon (void)
	Fix relation gamma<->pi0 in brecon table.
static double	pi0resol (double, double, const char *, bool, int, int)
	Treat pi0 mass width as a func.
void	correct_ecl (int, int)
	Correct photon's momenta and error matrix.
void	make_pi0 (int, double, double)
	Create Mdst_pi0 from Mdst_gamma and Mdst_ecl to let people get mass-constraint fitted momentum of pi0 after ad_hoc correction.
void	make_pi0_primary_vertex (int, double, double, const HepPoint3D &, const CLHEP::HepSymMatrix &)
	Fill Mdst_pi0 based on the fit result.
void	correct_ecl_primary_vertex (const HepPoint3D &, const CLHEP::HepSymMatrix &)
	Correct ecl using primary vertex.
void	shift_tof (const int mode)
	Shift tof times to account for residuals.
void	shift_tof_set (const int expno, const int runno, const int mode, const int im, const double pmom, const double sgn, double &shift)
	Return time shifts for different exp.
double	vee_mass_nofit (const Belle::Mdst_vee2 &vee2, float scale=1.0)
	Calculates V0 mass with non-constraint fit results.
void	scale_momenta (float scale_data=1.0, float scale_mc=1.0, int mode=0)
	Scale momenta of Mdst_trk.
void	scale_momenta_set (const int, const int, const int, double &)
	Return scale factors for 2001 summer confs.
void	scale_momenta_set_v1 (const int, const int, const int, double &)
	Return scale factors set_v1.
void	scale_momenta_set_v2 (const int, const int, const int, double &)
	Return scale factors set_v2.
void	scale_error (const int message_level=0)
	Apply scale error.
int	set_primary_vertex (HepPoint3D &v, CLHEP::HepSymMatrix &ve)
	Set primary vertex assuming all tracks are pions.
int	add_extra_trk_vee2 ()
	Add Mdst_trk_extra and Mdst_vee_extra to Mdst_trk and Mdst_vee2, respectively.
int	remove_extra_trk_vee2 ()
	Remove extra tracks from Mdst_trk and Mdst_vee2.
void	smear_trk ()
	Apply track smearing (on MC)

Detailed Description

Macro Definition Documentation

NOMINAL_ENERGY

#define NOMINAL_ENERGY   5.290024915

Nomial beam energy.

Definition at line 162 of file B2BIIFixMdstModule.cc.

Typedef Documentation

cal_scale_error_func_t

typedef void(* cal_scale_error_func_t) (double scale[5], const double pt, const double tanl)

Function pointer type.

Definition at line 1438 of file B2BIIFixMdstModule_trk.cc.

Function Documentation

add_extra_trk_vee2()

int add_extra_trk_vee2 ( )

private

Add Mdst_trk_extra and Mdst_vee_extra to Mdst_trk and Mdst_vee2, respectively.

Definition at line 3071 of file B2BIIFixMdstModule_trk.cc.

  {
    Belle::Mdst_event_add_Manager& mevtmgr = Belle::Mdst_event_add_Manager::get_manager();
    if (mevtmgr.count() == 0) { // no Belle::Mdst_event_add table
      return -2;
    } else if (mevtmgr.count() == 1) { // no second entity in Belle::Mdst_event_add table
      mevtmgr.add();
    }
    unsigned flag(mevtmgr[1].flag(0));
    if (flag != 0) return -1;  // do nothing if already added
    Belle::Mdst_trk_extra_Manager& teMgr(Belle::Mdst_trk_extra_Manager::get_manager());
    Belle::Mdst_trk_Manager& tMgr(Belle::Mdst_trk_Manager::get_manager());
    Belle::Mdst_charged_Manager& chMgr(Belle::Mdst_charged_Manager::get_manager());
    const int i_ch(chMgr.count() + 1);
    const int i_trk(tMgr.count() + 1);
    for (std::vector<Belle::Mdst_trk_extra>::const_iterator i = teMgr.begin();
         i != teMgr.end(); ++i) {
      Belle::Mdst_trk& trk(tMgr.add());
      trk.quality((*i).quality());
      for (int j = 0; j < 5; j++) trk.mhyp(j, (*i).mhyp(j));
 
      // Commented out by A. Zupanc: see below
      // Belle::Mdst_trk_fit& tf(trk.mhyp(2));
      if (!(trk.quality() & 15u)) {
        B2FATAL("recsim_mdst_propgt_ is missing");
 
        /*
        Commented by A.Zupanc: the recsim_mdst_propgt_ is missing therefore this part of the code
        can not be executed
 
              Belle::Mdst_charged& ch(chMgr.add());
              ch.charge((tf.helix(2) >= 0) ? 1. : -1.);
 
              float pivot[3], helix[5], error[15], helix0[5], error0[15];
              for (int k = 0; k < 3; k++) pivot[k] = tf.pivot(k);
              for (int k = 0; k < 5; k++) helix[k] = tf.helix(k);
              for (int k = 0; k < 15; k++) error[k] = tf.error(k);
 
              float amass = tf.mass();
 
              // propagate helix to origin
              int iret;
 
              //recsim_mdst_propgt_(&amass, pivot, helix,  error,
              //                    helix0, error0, &iret);
              if (iret == 0) {
                ch.px(-sin(helix0[1]) / fabs(helix0[2]));
                ch.py(cos(helix0[1]) / fabs(helix0[2]));
                ch.pz(helix0[4] / fabs(helix0[2]));
              }
              ch.mass(amass);
              ch.trk(trk);
        */
      } else {
        B2ERROR("Warning from B2BIIFixMdst: strange track in Belle::Mdst_trk_extra: quality="
                << trk.quality());
      }
    }
 
 
    Belle::Mdst_sim_trk_extra_Manager& steMgr
    (Belle::Mdst_sim_trk_extra_Manager::get_manager());
    Belle::Mdst_sim_trk_Manager& stMgr(Belle::Mdst_sim_trk_Manager::get_manager());
    int ist(0);
    for (std::vector<Belle::Mdst_sim_trk_extra>::const_iterator i = steMgr.begin();
         i != steMgr.end(); ++i) {
      Belle::Mdst_sim_trk& strk(stMgr.add());
      int argn = tMgr.count() - teMgr.count() + ist;
      if (argn < tMgr.count()) {
        strk.trk(tMgr[argn]);
      }
      ist++;
      strk.hepevt((*i).hepevt());
      strk.relation(0, (*i).relation(0));
      strk.relation(1, (*i).relation(1));
      strk.relation(2, (*i).relation(2));
    }
 
 
    Belle::Mdst_svd_hit_extra_Manager& sheMgr
    (Belle::Mdst_svd_hit_extra_Manager::get_manager());
    Belle::Mdst_svd_hit_Manager& shMgr(Belle::Mdst_svd_hit_Manager::get_manager());
    for (std::vector<Belle::Mdst_svd_hit_extra>::iterator it = sheMgr.begin();
         it != sheMgr.end(); ++it) {
      Belle::Mdst_svd_hit_extra& she = *it;
      Belle::Mdst_svd_hit& sh(shMgr.add());
      sh.lsa(she.lsa());
      sh.width(she.width());
      sh.electrons(she.electrons());
      sh.dssd(she.dssd());
      sh.type(she.type());
      int argn = tMgr.count() - teMgr.count() + she.trk().get_ID() - 1;
      if (argn < tMgr.count()) {
        sh.trk(tMgr[argn]);
      }
    }
 
 
    Belle::Mdst_vee2_Manager& vMgr(Belle::Mdst_vee2_Manager::get_manager());
    Belle::Mdst_vee2_extra_Manager& veMgr(Belle::Mdst_vee2_extra_Manager::get_manager());
    const int i_vee2(vMgr.count() + 1);
    for (std::vector<Belle::Mdst_vee2_extra>::const_iterator i = veMgr.begin();
         i != veMgr.end(); ++i) {
      Belle::Mdst_vee2& vee(vMgr.add());
      vee.kind((*i).kind());
 
      if ((*i).extra_ID(0)) {
        Belle::Mdst_charged& tmp(chMgr[(*i).extra_ID(0) + i_ch - 2]);
        vee.chgd(0, tmp);
      } else {
        vee.chgd(0, (*i).chgd());
      }
 
      if ((*i).extra_ID(1)) {
        Belle::Mdst_charged& tmp(chMgr[(*i).extra_ID(1) + i_ch - 2]);
        vee.chgd(1, tmp);
      } else {
        vee.chgd(1, (*i).chgd());
      }
 
      vee.px((*i).px());
      vee.py((*i).py());
      vee.pz((*i).pz());
      vee.energy((*i).energy());
      vee.vx((*i).vx());
      vee.vy((*i).vy());
      vee.vz((*i).vz());
      vee.z_dist((*i).z_dist());
      vee.chisq((*i).chisq());
      vee.type((*i).type());
      vee.daut((*i).daut());
    }
    teMgr.remove();
    steMgr.remove();
    sheMgr.remove();
    veMgr.remove();
    if (i_ch & 0xffffff00) B2ERROR("Warning from B2BIIFixMdst: overflow! i_ch = " << i_ch);
    if (i_trk & 0xffffff00) B2ERROR("Warning from B2BIIFixMdst: overflow! i_trk = " << i_trk);
    if (i_vee2 & 0xffffff00) B2ERROR("Warning from B2BIIFixMdst: overflow! i_vee2 = " << i_vee2);
    flag = i_ch & 0xff;
    flag |= ((i_trk & 0xff) << 8);
    flag |= ((i_vee2 & 0xff) << 16);
    mevtmgr[1].flag(0, flag);
    return (int)flag;
  }

B2BIIConvertBeamParamsModule()

B2BIIConvertBeamParamsModule

(

)

Create parameters.

Definition at line 65 of file B2BIIConvertBeamParamsModule.cc.

  {
    addParam("mcFlag", m_mcFlag, "which mc flag to use", m_mcFlag);
    addParam("missingBenergy", m_missingBenergy, "where to store information about runs with missing database info", m_missingBenergy);
    addParam("missingIp", m_missingIp, "where to store information about runs with missing IP profile info", m_missingIp);
    addParam("smearEnergy", m_SmearEnergy, "Allow beam energy smearing for MC generation", true);
    addParam("smearDirection", m_SmearDirection, "Allow beam direction smearing for MC generation", true);
    addParam("smearVertex", m_SmearVertex, "Allow IP position smearing for MC generation", true);
    addParam("generateCMS", m_GenerateCMS, "Generate events in CMS, not lab system.", false);
    addParam("storeBeamParameters", m_storeBeamParameters, "Store the BeamParameters payloads in the localDB", true);
    addParam("storeCollisionAxisCMS", m_storeCollisionAxisCMS,
             "Store the CollisionAxisCMS payloads in the localDB",
             true);
    addParam("storeCollisionInvariantMass", m_storeCollisionInvariantMass, "Store the CollisionInvariantMass payloads in the localDB",
             true);
    addParam("storeCollisionBoostVector", m_storeCollisionBoostVector, "Store the CollisionBoostVector payloads in the localDB", true);
    addParam("storeBeamSpot", m_storeBeamSpot, "Store the BeamSpot payloads in the localDB", true);
  }

B2BIIFixMdstModule()

B2BIIFixMdstModule

(

)

Constructor.

Definition at line 166 of file B2BIIFixMdstModule.cc.

                                         : Module()
  {
 
    setDescription("Used to fix the old Belle I mdst files before processing. This module was taken from the old Belle I code and converted into a basf2 module."
                   "There are a lot of magic numbers in this module, where do they come from? Noone knows..."
                   "Return value is -1 if something went wrong, do not use these events!");
 
    addParam("Scale_momenta", m_scale_momenta, "Apply scale_momenta", 1);
    addParam("scale_momenta_scale_data", m_scale_momenta_scale_data, "scale_momenta scale_data", 0.0f);
    addParam("scale_momenta_scale_mc", m_scale_momenta_scale_mc, "scale_momenta scale_mc", 1.0f);
    addParam("scale_momenta_mode", m_scale_momenta_mode, "scale_momenta_mode", 2);
    addParam("Scale_error", m_scale_error, "Apply scale_error", 1);
 
    addParam("Smear_trk", m_smear_trk, "Do extra-smearing for MC tracks", 2);
    addParam("Extra_trk_vee2", m_add_or_remove_extra_trk_vee2,
             "1: add to Mdst_charged etc, -1: remove (move to Mdst_*_extra), 0:do nothing", 0);
 
    addParam("Correct_ecl", m_correct_ecl, "Apply correct_ecl", 1);
    addParam("Correct_ecl_pv", m_correct_ecl_primary_vertex, "Apply correct_ecl_pv", 0);
    addParam("Correct_ecl_option", m_correct_ecl_option, "Set correct_ecl option", 0);
    addParam("Correct_ecl_version", m_correct_ecl_version, "Set correct_ecl version", 2);
    addParam("Correct_ecl_5s", m_correct_ecl_5s, "Correct_ecl flag for 5S runs", 0); // KM 20080608
 
    addParam("Make_pi0", m_make_pi0, "Apply make_pi0 (after correct_ecl)", 1);
    addParam("Make_pi0_pv", m_make_pi0_primary_vertex, "Apply make_pi0_pv (after correct_ecl)", 0);
    addParam("Make_pi0_option", m_make_pi0_option, "Set make_pi0 option", 0);
    addParam("Make_pi0_lower_limit", m_make_pi0_lower_limit, "Set make_pi0 lower mass limit", 0.0);
    addParam("Make_pi0_upper_limit", m_make_pi0_upper_limit, "Set make_pi0 upper mass limit", 0.0);
 
    addParam("Benergy", m_benergy, "Apply Benergy", 1);
    addParam("BenergyDB", m_benergy_db, "Apply Benergy from DB or file ", 0);
    addParam("BenergyMCDB", m_benergy_mcdb, "Apply Benergy from DB or default value in MC", 0);
 
    addParam("Good_event", m_good_event, "Select good event only", 1);
    addParam("HadronA", m_hadron_a_only, "Select Hadron A event only", 1);
    addParam("HadronB", m_hadron_b_only, "Select Hadron B event only", 1);
    addParam("Level4passed", m_l4passed_only, "Select level4-passed event only", 1);
 
    addParam("Scale_error_dataset", m_scale_error_dataset_name, "Set scale_error_dataset name", std::string(""));
    addParam("Calib_dedx", m_calib_dedx, "Do dedx calibration", 1);
    addParam("Shift_tof_mode", m_shift_tof_mode, "Do tof_correction", 1);
    addParam("Endcap_MX_layer", m_eklm_max_layer, "Max layer number of KLM endcap", 11);
    addParam("UseECL", m_use_ecl, "Use (1) or don't use (0) ECL in muid", 0);
    addParam("ExpNo", m_expno, "Use data's exp # (0) or this value (>0) in muid", 0);
 
    addParam("Table_size", m_table_size, "Check table sizes", 1);
    addParam("Limit_mdst_ecl_trk", m_limit_mdst_ecl_trk, "Limit of mdst_ecl_trk table size", 600);
    addParam("Limit_mdst_klm_cluster_hit", m_limit_mdst_klm_cluster_hit, "Limit of mdst_klm_cluster_hit table size", 450);
 
    m_reprocess_version = 0;
    addParam("Reprocess_version", m_reprocess_version_specified, "Specify reprocess version", -1);
    addParam("5Srun", m_5Srun, "5S,2S,1S run or not", 0);
    addParam("Check_version_consistency", m_check_version_consistency, "Check consistency betw. env. variable and mdst version", 1);
    addParam("SaveResultExtraInfo", m_saveResultExtraInfo,
             "Whether to save result as EventExtraInfo.", false);
  }

beginRun() [1/2]

void beginRun ( )

overridevirtual

Set run info in panther and load IPProfile/Benergy and convert the values to payloads.

Reimplemented from Module.

Definition at line 90 of file B2BIIConvertBeamParamsModule.cc.

  {
    // Fudge a runhead record with all the info we need to be able to get the
    // Beamenergy/IpProfile from the database
    BsClrTab(BBS_CLEAR);
    Belle::Belle_runhead_Manager& runMgr = Belle::Belle_runhead_Manager::get_manager();
    runMgr.add();
    Belle::Belle_runhead& runhead = runMgr[0];
    runhead.ExpMC(m_mcFlag);
    runhead.ExpNo(m_event->getExperiment());
    runhead.RunNo(m_event->getRun());
    B2INFO("Obtaining values for exp " << m_event->getExperiment() << ", run " << m_event->getRun());
    // and then get the values from the database
    Belle::BeamEnergy::flag_database(0);
    Belle::IpProfile::begin_run();
    Belle::Ip_profile_general_Manager& ipMgr = Belle::Ip_profile_general_Manager::get_manager();
 
    if (!Belle::BeamEnergy::usable()) {
      FileSystem::Lock lock(m_missingBenergy);
      if (!lock.lock()) {
        B2ERROR("No BeamEnergy for exp " << m_event->getExperiment() << ", run " << m_event->getRun());
      } else {
        std::ofstream file(m_missingBenergy.c_str(), std::ios::app);
        file << m_event->getExperiment() << "," << m_event->getRun() << std::endl;
      }
      return;
    }
 
    const double Eher = Belle::BeamEnergy::E_HER();
    const double Eler = Belle::BeamEnergy::E_LER();
    const double crossingAngle = Belle::BeamEnergy::Cross_angle();
    const double angleLer = M_PI; //parallel to negative z axis (different from Belle II!)
    const double angleHer = crossingAngle; //in positive z and x direction, verified to be consistent with Upsilon(4S) momentum
 
    // Beam energy spread taken from the hard-coded values in the Belle evtgen:
    // /sw/belle/belle/b20090127_0910/src/util/evtgenutil/basf_if/evtgen.cc
    // The beam energy spread seems not have been logged in the belle DB at all.
    // If you are reading this and you know how to access the run-dependent beam energy spread,
    // please fix this (April 2021)!
    std::vector<double> covarianceHer = {0.00513 * 0.00513}; // Energy spread only. No idea about the direction spread
    std::vector<double> covarianceLer = {0.002375 * 0.002375}; // Energy spread only. No idea about the direction spread
 
    IntervalOfValidity iov(m_event->getExperiment(), m_event->getRun(), m_event->getExperiment(), m_event->getRun());
 
    BeamParameters beamParams;
    beamParams.setLER(Eler, angleLer, 0, covarianceLer);
    beamParams.setHER(Eher, angleHer, 0, covarianceHer);
 
    // set the flags according to the module settings.
    int flags = 0;
    if (m_GenerateCMS)
      flags |= BeamParameters::c_generateCMS;
    if (m_SmearEnergy)
      flags |= BeamParameters::c_smearBeamEnergy;
    if (m_SmearDirection)
      flags |= BeamParameters::c_smearBeamDirection;
    if (m_SmearVertex)
      flags |= BeamParameters::c_smearVertex;
    beamParams.setGenerationFlags(flags);
 
    CollisionAxisCMS collisionAxisCMS;
    CollisionBoostVector collisionBoostVector;
    CollisionInvariantMass collisionInvM;
    ROOT::Math::PxPyPzEVector momentumHER = beamParams.getHER();
    ROOT::Math::PxPyPzEVector cms = momentumHER + beamParams.getLER();
    ROOT::Math::XYZVector boost = -cms.BoostToCM();
    ROOT::Math::VectorUtil::boost(momentumHER, boost);
    double angleXZ = std::atan(momentumHER.X() / momentumHER.Z());
    double angleYZ = std::atan(momentumHER.Y() / momentumHER.Z());
    collisionAxisCMS.setAngles(angleXZ, angleYZ, TMatrixTSym<double>(2));
    collisionAxisCMS.setSpread(TMatrixTSym<double>(2), 0, 0, 0);
    collisionBoostVector.setBoost(B2Vector3D(boost), TMatrixTSym<double>(3));
    //note: maybe we could use Belle::BeamEnergy::E_beam_corr(), Belle::BeamEnergy::E_beam_err()
    collisionInvM.setMass(cms.M(), 0.0, 0.0);
 
    // Boost vector and invariant mass are not intra-run dependent, store now
    if (m_storeCollisionAxisCMS) {
      Database::Instance().storeData(
        "CollisionAxisCMS", &collisionAxisCMS, iov);
    }
    if (m_storeCollisionBoostVector) {
      Database::Instance().storeData(
        "CollisionBoostVector", &collisionBoostVector, iov);
    }
    if (m_storeCollisionInvariantMass) {
      Database::Instance().storeData(
        "CollisionInvariantMass", &collisionInvM, iov);
    }
 
    // and now we continue with the vertex
    if (!Belle::IpProfile::usable()) {
      FileSystem::Lock lock(m_missingIp);
      if (!lock.lock()) {
        B2ERROR("No IpProfile for exp " << m_event->getExperiment() << ", run " << m_event->getRun());
      } else {
        std::ofstream file(m_missingIp.c_str(), std::ios::app);
        file << m_event->getExperiment() << "," << m_event->getRun() << std::endl;
      }
      std::vector<double> covariance; // 0 = no error
      beamParams.setVertex(ROOT::Math::XYZVector(
                             std::numeric_limits<double>::quiet_NaN(),
                             std::numeric_limits<double>::quiet_NaN(),
                             std::numeric_limits<double>::quiet_NaN()), covariance);
      if (m_storeBeamParameters)
        Database::Instance().storeData("BeamParameters", &beamParams, iov);
 
      BeamSpot beamSpot;
      beamSpot.setIP(
        TVector3(std::numeric_limits<double>::quiet_NaN(),
                 std::numeric_limits<double>::quiet_NaN(),
                 std::numeric_limits<double>::quiet_NaN()
                ), TMatrixTSym<double>(3)
      );
      if (m_storeBeamSpot) {
        Database::Instance().storeData("BeamSpot", &beamSpot, iov);
        B2INFO("No IpProfile, created BeamSpot Payload");
      }
      return;
    }
 
    int nbins = std::max(ipMgr.count() - 1, 1);
    B2INFO("exp " << m_event->getExperiment() << ", run " << m_event->getRun() << ": " << nbins << " IpProfile bins");
 
    // need to keep the objects alive until we created the payloads
    std::list<BeamParameters> beamparamsList;
    std::list<BeamSpot> beamspotList;
    // and we want them to be intra-run dependent
    std::unique_ptr<EventDependency> beamparams;
    std::unique_ptr<EventDependency> beamspots;
 
    Belle::Belle_event_Manager& evtMgr = Belle::Belle_event_Manager::get_manager();
    if (!evtMgr.count()) evtMgr.add();
    for (int i = 0; i < nbins; ++i) {
      int evtNr = i * BIN_EVENTS;
      // fudge belle event record to get the correct run dependent ip profile
      Belle::Belle_event& evt = evtMgr[0];
      evt.ExpMC(m_mcFlag);
      evt.ExpNo(m_event->getExperiment());
      evt.RunNo(m_event->getRun());
      evt.EvtNo(evtNr);
      Belle::IpProfile::set_evtbin_number();
      B2ASSERT("something wrong: " << Belle::IpProfile::EvtBinNo() << "!=" << i, Belle::IpProfile::EvtBinNo() == i);
 
      // and convert
      HepPoint3D ip = Belle::IpProfile::e_position();
      HepSymMatrix ipErr = Belle::IpProfile::e_position_err();
 
      beamParams.setVertex(ROOT::Math::XYZVector(ip.x(), ip.y(), ip.z()));
      beamParams.setCovVertex(CLHEPtoROOT(ipErr));
      beamparamsList.emplace_back(beamParams);
 
      BeamSpot beamSpot;
      beamSpot.setIP(CLHEPtoROOT(ip), CLHEPtoROOT(ipErr));
      beamspotList.emplace_back(beamSpot);
 
      if (!beamparams) {
        beamparams = std::make_unique<EventDependency>(&beamparamsList.back(), false);
        beamspots = std::make_unique<EventDependency>(&beamspotList.back(), false);
      } else {
        beamparams->add(evtNr, &beamparamsList.back());
        beamspots->add(evtNr, &beamspotList.back());
      }
    }
    if (beamparamsList.size() < 1) {
      B2ERROR("Something is wrong with exp " << m_event->getExperiment() << ", run " << m_event->getRun() << ": no bins found");
      return;
    }
    if (beamparamsList.size() == 1) {
      // just one bin? no need to store event dependency
      if (m_storeBeamParameters)
        Database::Instance().storeData("BeamParameters", &beamparamsList.back(), iov);
      if (m_storeBeamSpot)
        Database::Instance().storeData("BeamSpot", &beamspotList.back(), iov);
      B2INFO("Created event independent payload");
    } else {
      // otherwise store full information
      if (m_storeBeamParameters)
        Database::Instance().storeData("BeamParameters", beamparams.get(), iov);
      if (m_storeBeamSpot)
        Database::Instance().storeData("BeamSpot", beamspots.get(), iov);
      B2INFO("Created event dependent payload with " << beamparamsList.size() << " entries");
    }
  }

beginRun() [2/2]

void beginRun ( )

overridevirtual

Called when a new run is started.

Reimplemented from Module.

Definition at line 379 of file B2BIIFixMdstModule.cc.

  {
 
    if (m_5Srun == 0 && m_correct_ecl_5s == 1) m_5Srun = 1;
 
    m_reprocess_version = get_reprocess_version();
    B2INFO("reprocess version= " << m_reprocess_version);
 
    Belle::IpProfile::begin_run();
 
    if (m_benergy_db == 0) Belle::BeamEnergy::begin_run();
 
    Belle::Belle_runhead_Manager& evtmgr = Belle::Belle_runhead_Manager::get_manager();
    Belle::Belle_runhead_Manager::const_iterator belleevt = evtmgr.begin();
    if (belleevt != evtmgr.end() && (*belleevt)) {
      int expmc = belleevt->ExpMC();
      int exp = belleevt->ExpNo();
      int run = belleevt->RunNo();
      //if(m_benergy==1 && expmc==1) s_benergy_value = Benergy(exp, run);
 
      if (((31 <= exp && exp <= 55) || (69 <= exp && exp <= 73)) && m_check_version_consistency == 1) {
        char* env = std::getenv("USE_GRAND_REPROCESS_DATA");
        if ((env && m_reprocess_version == 0) ||
            (!env && m_reprocess_version == 1)) {
          B2ERROR("Env. variable USE_GRAND_REPROCESS_DATA and input mdst reprocess version=" << m_reprocess_version <<
                  " (=0:old; =1:new) are inconsistent -> kill the job. Set USE_GRAND_REPROCESS_DATA or input mdst file properly and retry.");
          exit(-1);
        }
      }
 
      if (m_calib_dedx != 0) {
        if (expmc == 1 || m_reprocess_version == 0 || m_calib_dedx == -1)
          Belle::Calib_dEdx_begin_run(m_reprocess_version, m_5Srun);
      }
 
      if (m_mapped_expno > 0) Muid_begin_run(expmc, exp, run);
 
    } else {
      B2ERROR("[B2BIIFixMdst] Error: Cannot read \"Belle::Belle_RunHead\".");
    }
  }

Benergy()

double Benergy ( int  expnum = 0, int  runnum = 0  )

private

Return Beam energy.

Definition at line 540 of file B2BIIFixMdstModule.cc.

  {
 
    double energy(NOMINAL_ENERGY);
    double factor(0.001);
 
    //  if( m_benergy_db == 0 && BsCouTab(BELLE_EVENT) > 0 ){
    if (m_benergy_db == 0) {
      Belle::Belle_event_Manager& bevt_mgr = Belle::Belle_event_Manager::get_manager();
      Belle::Belle_event_Manager::const_iterator bevt = bevt_mgr.begin();
      if (bevt != bevt_mgr.end() && (*bevt)) {
        if (bevt->ExpMC() == 1) energy = Belle::BeamEnergy::E_beam2();
        if (bevt->ExpMC() == 2) {
          if (m_benergy_mcdb == 0) return energy;    //energy = 5.290000;
          else energy = Belle::BeamEnergy::E_beam2();
        }
        return energy;
      }
    }
 
    if ((expnum == 0 || runnum == 0) && BsCouTab(BELLE_EVENT) > 0) {
      Belle::Belle_event& bevt = Belle::Belle_event_Manager::get_manager()[0];
      if (bevt.ExpMC() == 1) {
        expnum = bevt.ExpNo();
        runnum = bevt.RunNo();
      }
    }
 
    if (expnum == 5) {
      if (runnum >= 74 && runnum <= 472)      energy += -0.540 * factor;
    } else if (expnum == 7) {
      if (runnum >= 6 && runnum <= 475)      energy +=  0.305 * factor;
      else if (runnum >= 538 && runnum <= 895)  energy += -1.016 * factor;
      else if (runnum >= 904 && runnum <= 1079) energy += -1.065 * factor;
      else if (runnum >= 1101 && runnum <= 1248) energy += -0.608 * factor;
      else if (runnum >= 1257 && runnum <= 1399) energy += -1.132 * factor;
      else if (runnum >= 1400 && runnum <= 1599) energy += -1.446 * factor;
      else if (runnum >= 1600 && runnum <= 1799) energy += -1.836 * factor;
      else if (runnum >= 1800 && runnum <= 1999) energy += -1.829 * factor;
      else if (runnum >= 2000 && runnum <= 2156) energy += -1.732 * factor;
      else if (runnum >= 2294 && runnum <= 2599) energy += -2.318 * factor;
      else if (runnum >= 2600 && runnum <= 2865) energy += -1.363 * factor;
    } else if (expnum == 9) {
      if (runnum >= 17   && runnum <= 399)   energy += -2.767 * factor;
      else if (runnum >= 400  && runnum <= 499)   energy += -2.826 * factor;
      else if (runnum >= 500  && runnum <= 593)   energy += -2.311 * factor;
      else if (runnum >= 601  && runnum <= 699)   energy += -2.138 * factor;
      else if (runnum >= 700  && runnum <= 899)   energy += -2.267 * factor;
      else if (runnum >= 900  && runnum <= 999)   energy += -2.412 * factor;
      else if (runnum >= 1000 && runnum <= 1099)   energy += -2.229 * factor;
      else if (runnum >= 1100 && runnum <= 1220)   energy += -1.842 * factor;
      //new(2001/06/23)
    } else if (expnum == 11) {
      if (runnum >= 1   && runnum <= 161) energy += -2.173 * factor;
      if (runnum >= 261 && runnum <= 399) energy += -1.392 * factor;
      if (runnum >= 400 && runnum <= 499) energy += -1.321 * factor;
      if (runnum >= 500 && runnum <= 599) energy += -1.394 * factor;
      if (runnum >= 600 && runnum <= 699) energy += -1.827 * factor;
      if (runnum >= 700 && runnum <= 799) energy += -1.912 * factor;
      if (runnum >= 800 && runnum <= 899) energy += -1.603 * factor;
      if (runnum >= 900 && runnum <= 998) energy += -1.759 * factor;
      if (runnum >= 1001 && runnum <= 1099) energy += -1.915 * factor;
      if (runnum >= 1100 && runnum <= 1199) energy += -1.513 * factor;
      if (runnum >= 1200 && runnum <= 1287) energy += -0.639 * factor;
    } else if (expnum == 13) {
      if (runnum >= 1 && runnum <= 99) energy +=  0.279 * factor;
      if (runnum >= 100 && runnum <= 198) energy +=  0.140 * factor;
      if (runnum >= 200 && runnum <= 297) energy += -0.095 * factor;
      if (runnum >= 301 && runnum <= 440) energy +=  0.232 * factor;
      if (runnum >= 551  && runnum <= 699)  energy += -0.385 * factor;
      if (runnum >= 700  && runnum <= 799)  energy += -0.654 * factor;
      if (runnum >= 800  && runnum <= 899)  energy += -0.972 * factor;
      if (runnum >= 900  && runnum <= 999)  energy += -0.770 * factor;
      if (runnum >= 1000 && runnum <= 1099) energy += -0.353 * factor;
      if (runnum >= 1100 && runnum <= 1199) energy += -0.490 * factor;
      if (runnum >= 1200 && runnum <= 1299) energy += -0.687 * factor;
      if (runnum >= 1300 && runnum <= 1399) energy += -0.545 * factor;
      //if ( runnum >=1400 && runnum <=1523 ) energy += -0.783*factor;
      if (runnum >= 1400) energy += -0.783 * factor;
      // there isn't sufficient amount of data between 1589..1623 (0.1 fb-1),
      // so we decided to take the value of last run range, which should be
      // better than 0 correction.   (c.f. dcpvrare_ml:0146 and 0147)
 
    } else if (expnum == 15) {
      //    // new February 15, 2002
      //    if(runnum < 764 ) energy = 5.288103;
      //    if(runnum > 763 && runnum < 951 ) energy = 5.286505;
      //    if(runnum > 950 ) energy = 5.287404;
      // new February 20, 2002
      if (runnum <  764)                  energy = 5.288103;
      if (runnum >  763 && runnum <  951) energy = 5.287005;
      if (runnum >  950 && runnum < 1251) energy = 5.287804;
      if (runnum > 1250)                  energy = 5.288603;
 
    } else if (expnum == 17) {
      if (runnum <= 199)                energy = 5.288702;
      if (runnum >= 200 && runnum <= 399) energy = 5.289202;
      if (runnum >= 400 && runnum <= 485) energy = 5.289401;
      if (runnum >= 545 && runnum <= 799) energy = 5.289501;
      if (runnum >= 800 && runnum <= 937) energy = 5.289401;
 
    } else if (expnum == 19) {
      if (runnum >= 64  && runnum <= 199) energy = 5.2887023;
      if (runnum >= 200 && runnum <= 299) energy = 5.2886025;
      if (runnum >= 300 && runnum <= 399) energy = 5.28830299;
      if (runnum >= 400 && runnum <= 459) energy = 5.28820313;
      if (runnum >= 461 && runnum <= 599) energy = 5.28830299;
      if (runnum >= 600 && runnum <= 666) energy = 5.28780366;
      if (runnum >= 763 && runnum <= 999) energy = 5.28820313;
      if (runnum >= 1000 && runnum <= 1099) energy = 5.28780366;
      if (runnum >= 1100 && runnum <= 1199) energy = 5.28770378;
      if (runnum >= 1200 && runnum <= 1399) energy = 5.28750402;
      if (runnum >= 1400 && runnum <= 1499) energy = 5.28740413;
      if (runnum >= 1500 && runnum <= 1599) energy = 5.28720434;
      if (runnum >= 1600 && runnum <= 1643) energy = 5.28760390;
 
 
      // Dec 28th, 2002
 
    } else if (expnum == 21) {
      if (runnum >= 0 && runnum <= 180) energy = 5.28650496;
      if (runnum >= 181 && runnum <= 324) energy = 5.2880034;
    } else if (expnum == 23) {
      if (runnum >= 0 && runnum <= 238) energy = 5.28860254;
      if (runnum >= 357 && runnum <= 607) energy = 5.28880222;
 
      //May 31st, 2003
 
    } else if (expnum == 25) {
      if (runnum >= 0 && runnum <= 99) energy = 5.28950099;
      if (runnum >= 100 && runnum <= 199) energy = 5.28870238;
      if (runnum >= 200 && runnum <= 299) energy = 5.28910171;
      if (runnum >= 300 && runnum <= 399) energy = 5.28890205;
      if (runnum >= 400 && runnum <= 799) energy = 5.28850269;
      if (runnum >= 800 && runnum <= 899) energy = 5.28790353;
      if (runnum >= 900 && runnum <= 999) energy = 5.28810326;
      if (runnum >= 1000 && runnum <= 1099) energy = 5.28830298;
      if (runnum >= 1100 && runnum <= 1199) energy = 5.28820313;
      if (runnum >= 1200 && runnum <= 1299) energy = 5.28780366;
      if (runnum >= 1300 && runnum <= 1462) energy = 5.28820313;
      if (runnum >= 1600 && runnum <= 1699) energy = 5.28830299;
      if (runnum >= 1700 && runnum <= 1799) energy = 5.28780366;
      if (runnum >= 1800 && runnum <= 1899) energy = 5.28810327;
      if (runnum >= 1900 && runnum <= 2122) energy = 5.28830299;
 
      //June 30th , 2003
 
    } else if (expnum == 27) {
      if (runnum >= 0 && runnum <= 180) energy = 5.28860254;
      if (runnum >= 181 && runnum <= 288) energy = 5.28870238;
      if (runnum >= 367 && runnum <= 499) energy = 5.28880222;
      if (runnum >= 500 && runnum <= 590) energy = 5.28890206;
      if (runnum >= 591 && runnum <= 699) energy = 5.28910172;
      if (runnum >= 700 && runnum <= 1079) energy = 5.28900189;
      if (runnum >= 1252 && runnum <= 1299) energy = 5.28850269;
      if (runnum >= 1300 && runnum <= 1632) energy = 5.28870238;
 
      //March 9th , 2004
 
    } else if (expnum == 31) {
      if (runnum >=   0 && runnum <= 166) energy = 5.287404131;
      if (runnum >= 231 && runnum <= 470) energy = 5.287903534;
      if (runnum >= 471 && runnum <= 698) energy = 5.28810327;
      if (runnum >= 699 && runnum <= 804) energy = 5.288602541;
      if (runnum >= 805 && runnum <= 936) energy = 5.288702384;
      if (runnum >= 1071 && runnum <= 1440) energy = 5.288902;
      if (runnum >= 1441 && runnum <= 1715) energy = 5.289301;
 
    } else if (expnum >= 32) {
      B2ERROR("Warning: Benergy is not ready for exp >=32.");
    }
    return energy;
  }

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  )

static

Calculate scale error.

Definition at line 2648 of file B2BIIFixMdstModule_trk.cc.

  {
    double scale_error_hadronic_mc[5] = {1.0, 1.0, 1.0, 1.0, 1.0};
    double scale_error_cosmic_mc[5]   = {1.0, 1.0, 1.0, 1.0, 1.0};
    double scale_error_cosmic_data[5] = {1.0, 1.0, 1.0, 1.0, 1.0};
 
 
    struct cal_scale_error_func_set_t cal_func = get_scale_error_func_for_exprun(no_exp, no_run);
    if (cal_func == DUMMY_scale) {
      B2ERROR("!!!! scale_error: FATAL: FATAL ERROR occured. Abort !!!!");
      // Scale error is not prepared for this EXP number!
      assert(0);
    }
 
 
    static bool first = true;
    static int belle_scale_error_debug_mode = 0;
    if (first) {
      first = false;
      char* belle_scale_error_debug = getenv("BELLE_SCALE_ERROR_DEBUG");
      // one of NULL, "none", "cosmic_mc", "cosmic_data", "hadronic_mc"
 
      if (!belle_scale_error_debug)
        belle_scale_error_debug_mode = 0;
      else if (!strcasecmp(belle_scale_error_debug, "none"))
        belle_scale_error_debug_mode = 1;
      else if (!strcasecmp(belle_scale_error_debug, "cosmic_mc"))
        belle_scale_error_debug_mode = 2;
      else if (!strcasecmp(belle_scale_error_debug, "cosmic_data"))
        belle_scale_error_debug_mode = 3;
      else if (!strcasecmp(belle_scale_error_debug, "hadron_mc") || !strcasecmp(belle_scale_error_debug, "hadronic_mc"))
        belle_scale_error_debug_mode = 4;
      else {
        B2ERROR("BELLE_SCALE_ERROR_DEBUG=" << belle_scale_error_debug << ": bad directive");
        assert(0);
      }
 
      if (belle_scale_error_debug)
        B2ERROR("BELLE_SCALE_ERROR_DEBUG=" << belle_scale_error_debug << ": applied");
    }
 
 
    switch (belle_scale_error_debug_mode) {
      case 0:
        (cal_func.m_hadMC)(scale_error_hadronic_mc, pt, tanl);
        if (expmc == 1) { // Experiment
          if (SE_Message_Level >= 2) B2ERROR("scale_error: info: scale on real data");
          (cal_func.m_cosMC)(scale_error_cosmic_mc, pt, tanl);
          (cal_func.m_cosDATA)(scale_error_cosmic_data, pt, tanl);
        } else {
          if (SE_Message_Level >= 2) B2ERROR("scale_error: info: scale on MC data");
        }
        break;
 
      case 1:
        //1;
        break;
 
      case 2:
        (cal_func.m_cosMC)(scale_error_hadronic_mc, pt, tanl);
        break;
 
      case 3:
        (cal_func.m_cosDATA)(scale_error_hadronic_mc, pt, tanl);
        break;
 
      case 4:
        (cal_func.m_hadMC)(scale_error_hadronic_mc, pt, tanl);
        break;
    }
 
 
    /* compute scaling factor */
    for (int i = 0; i < 5; i++)
      scale[i] = scale_error_hadronic_mc[i] * scale_error_cosmic_data[i] / scale_error_cosmic_mc[i];
 
 
    /* message out */
    if (SE_Message_Level >= 2) {
      B2ERROR("scale_error: info: hadronic MC: "
              << scale_error_hadronic_mc[0] << " " << scale_error_hadronic_mc[1] << " "
              << scale_error_hadronic_mc[2] << " " << scale_error_hadronic_mc[3] << " "
              << scale_error_hadronic_mc[4]);
 
      B2ERROR("scale_error: info: cosmic MC: "
              << scale_error_cosmic_mc[0] << " " << scale_error_cosmic_mc[1] << " "
              << scale_error_cosmic_mc[2] << " " << scale_error_cosmic_mc[3] << " "
              << scale_error_cosmic_mc[4]);
 
      B2ERROR("scale_error: info: cosmic data: "
              << scale_error_cosmic_data[0] << " " << scale_error_cosmic_data[1] << " "
              << scale_error_cosmic_data[2] << " " << scale_error_cosmic_data[3] << " "
              << scale_error_cosmic_data[4]);
 
      B2ERROR("scale_error: info: final scale: "
              << scale[0] << " " << scale[1] << " " << scale[2] << " "
              << scale[3] << " " << scale[4]);
    }
    /* check parameter limit */
    const double scale_lo = 0.5, scale_hi = 4.0;
    bool too_lo = false, too_hi = false;
    for (int i = 0; i < 5; i++) {
      if (scale[i] < scale_lo) { scale[i] = scale_lo; too_lo = true;}
      if (scale[i] > scale_hi) { scale[i] = scale_hi; too_hi = true;}
    }
 
    if (SE_Message_Level >= 1 && (too_lo || too_hi)) {
      B2ERROR("scale_error: warning: scale factor beyond the limit: "
              << scale_error_hadronic_mc[0] * scale_error_cosmic_data[0] / scale_error_cosmic_mc[0] << " "
              << scale_error_hadronic_mc[1] * scale_error_cosmic_data[1] / scale_error_cosmic_mc[1] << " "
              << scale_error_hadronic_mc[2] * scale_error_cosmic_data[2] / scale_error_cosmic_mc[2] << " "
              << scale_error_hadronic_mc[3] * scale_error_cosmic_data[3] / scale_error_cosmic_mc[3] << " "
              << scale_error_hadronic_mc[4] * scale_error_cosmic_data[4] / scale_error_cosmic_mc[4]);
    }
  }

cal_scale_error_EXP0723_cosmic_data()

static void cal_scale_error_EXP0723_cosmic_data ( double  scale[5], const double  pt, const double    )

static

Scale error for Exp.7-23 Cosmic data.

Definition at line 1882 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = +1.1280E+00 - 7.6839E-03 * pt;
    scale[1] = +1.1368E+00 + 2.8106E-02 * pt;
    scale[2] = +7.6448E-01 + 1.1248E-01 * pt;
    scale[3] = +1.1396E+00 - 3.6738E-02 * pt;
    scale[4] = +1.1766E+00 - 2.7477E-02 * pt;
  }

cal_scale_error_EXP0723_cosmic_mc()

static void cal_scale_error_EXP0723_cosmic_mc ( double  scale[5], const double  pt, const double    )

static

Scale error for Exp.7-23 Cosmic MC.

Definition at line 1559 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = +1.0115E+00 - 3.6966E-02 * pt;
    scale[1] = +9.8369E-01 + 3.2783E-02 * pt;
    scale[2] = +6.8401E-01 + 1.0190E-01 * pt;
    scale[3] = +1.0968E+00 - 3.3011E-02 * pt;
    scale[4] = +1.0992E+00 - 2.7929E-02 * pt;
  }

cal_scale_error_EXP0723_hadronic_mc()

static void cal_scale_error_EXP0723_hadronic_mc ( double  scale[5], const double  pt, const double  tanl  )

static

Scale error for Exp.7-23 Hadron MC.

Definition at line 2199 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = vfunc(pt, 0.34602, 1.0605, -0.36011, 0.38189E-01);
    scale[1] = 1.0612;
    scale[2] = cupfunc(pt, 0.44599, 1.2989, 0.85646, -0.73968, 0.17425);
    scale[3] = 1.1460 - 0.57101E-01 * pt;
    scale[4] = 1.0859;
 
    // tanl
    scale[0] *= +1.0122E+00 + 1.3568E-04 * tanl + 1.9856E-02 * tanl * tanl;
    scale[1] *= +1.0002E+00 - 4.5128E-03 * tanl + 1.6211E-02 * tanl * tanl;
    scale[2] *= +9.7051E-01 + 2.6876E-02 * tanl + 8.2365E-02 * tanl * tanl;
    scale[3] *= +9.7198E-01 + 3.8373E-02 * tanl + 4.9111E-02 * tanl * tanl;
    scale[4] *= +9.8880E-01 + 2.2090E-02 * tanl + 2.2701E-02 * tanl * tanl;
  }

cal_scale_error_EXP2527_cosmic_data()

static void cal_scale_error_EXP2527_cosmic_data ( double  scale[5], const double  pt, const double    )

static

Scale error for Exp.25-27 Cosmic data.

Definition at line 1898 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = +1.1002E+00 + 3.9852E-02 * pt;
    scale[1] = rootfunc(pt, 1.0015, 1.6591, 1.0420, -0.31809, 0.17149);
    scale[2] = +8.4706E-01 + 0.8914E-01 * pt;
    scale[3] = +1.1067E+00 + 1.0304E-02 * pt;
    scale[4] = +1.0495E+00 + 3.9923E-02 * pt;
  }

cal_scale_error_EXP2527_cosmic_mc()

static void cal_scale_error_EXP2527_cosmic_mc ( double  scale[5], const double  pt, const double    )

static

Scale error for Exp.25-27 Cosmic MC.

Definition at line 1575 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = +1.0257E+00 - 0.30671E-01 * pt;
    scale[1] = +1.0503E+00 + 0.97257E-02 * pt;
    scale[2] = +0.70751E+00 + 0.93039E-01 * pt;
    scale[3] = +1.0720E+00 - 0.15976E-01 * pt;
    scale[4] = +1.0530E+00 + 0.63696E-02 * pt;
  }

cal_scale_error_EXP2527_hadronic_mc()

static void cal_scale_error_EXP2527_hadronic_mc ( double  scale[5], const double  pt, const double  tanl  )

static

Scale error for Exp.25-27 Hadron MC.

Definition at line 2222 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 1.092E+00 - 0.86138E-01 * pt;
    scale[1] = 1.0448E+00 - 0.26158E-01 * pt;
    scale[2] = 1.1942E+00 - 1.0025E+00 * pt + 0.85334 * pt * pt - 0.20305 * pt * pt * pt;
    scale[3] = 1.1260E+00 - 0.46048E-01 * pt;
    scale[4] = 1.0378E+00 + 0.5109E-01 * pt;
 
    // tanl
    scale[0] *= +1.0136E+00 + 0.15293E-01 * tanl;
    scale[1] *= +0.9936E+00 + 0.71983E-02 * tanl + 0.14004E-01 * tanl * tanl;
    scale[2] *= +0.97532E+00 + 0.22718E-01 * tanl + 0.73556E-01 * tanl * tanl;
    scale[3] *= vfunc(tanl, -0.26650, 0.92765, -0.13393, 0.11704);
    scale[4] *= +0.98203E+00 + 0.21612E-01 * tanl + 0.32751E-01 * tanl * tanl;
  }

cal_scale_error_EXP31_cosmic_data()

static void cal_scale_error_EXP31_cosmic_data ( double  scale[5], double  pt, double    )

static

Scale error for Exp.31 Cosmic data.

Definition at line 1914 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 1.1908  + 0.20678E-02 * pt;
    scale[1] = 1.0304  + 0.54826E-01 * pt;
    scale[2] = 1.0806  + 0.33829E-01 * pt;
    scale[3] = 1.1325   - 0.34811E-01 * pt;
    scale[4] = 1.1549   - 0.20974E-01 * pt;
  }

cal_scale_error_EXP31_cosmic_mc()

static void cal_scale_error_EXP31_cosmic_mc ( double  scale[5], double  pt, double    )

static

Scale error for Exp.31 Cosmic MC.

Definition at line 1591 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 1.0874   - 0.26640E-01 * pt;
    scale[1] = 1.0320  + 0.18869E-01 * pt;
    scale[2] = 0.75302 + 0.89109E-01 * pt;
    scale[3] = 1.1435   - 0.73830E-01 * pt;
    scale[4] = 1.1227   - 0.19112E-01 * pt;
  }

cal_scale_error_EXP31_hadronic_mc()

static void cal_scale_error_EXP31_hadronic_mc ( double  scale[5], double  pt, double  tanl  )

static

Scale error for Exp.31 Hadron MC.

Definition at line 2245 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 1.2619  - 0.11170 * pt;
    scale[1] = 1.2263  - 0.24619E-01 * pt;
    scale[2] = vfunc(pt, 1.1432, 0.87555, -0.24211, 0.10876);
    scale[3] = 1.3254  - 0.21162 * pt;
    scale[4] = 1.1609 + 0.73808E-02 * pt;
 
    // tanl
    scale[3] *= vfunc(tanl, -0.12026, 0.95892, -0.71461E-01, 0.69535E-01);
  }

cal_scale_error_EXP33_cosmic_data()

static void cal_scale_error_EXP33_cosmic_data ( double  scale[5], double  pt, double    )

static

Scale error for Exp.33 Cosmic data.

Definition at line 1934 of file B2BIIFixMdstModule_trk.cc.

  {
    if (SE_Reprocess_Version == 0) {
      // pt
      scale[0] = 1.2175  + 0.14290E-01 * pt;
      scale[1] = 1.0362  + 0.80614E-01 * pt;
      scale[2] = 1.0313  + 0.12930E-01 * pt;
      scale[3] = 1.0411  + 0.17319E-01 * pt;
      scale[4] = 1.0445  + 0.27526E-01 * pt;
    } else {
      // pt
      scale[0] = 1.2712  - 0.42098E-01 * pt;
      scale[1] = 1.0634  - 0.13652E-01 * pt;
      scale[2] = 0.95435 + 0.64895E-01 * pt;
      scale[3] = 1.0758  + 0.10778E-01 * pt;
      scale[4] = 1.0892  - 0.75700E-02 * pt;
    }
  }

cal_scale_error_EXP33_cosmic_mc()

static void cal_scale_error_EXP33_cosmic_mc ( double  scale[5], double  pt, double    )

static

Scale error for Exp.33 Cosmic MC.

Definition at line 1612 of file B2BIIFixMdstModule_trk.cc.

  {
    if (SE_Reprocess_Version == 0) {
      // pt
      scale[0] = 1.1197  - 0.15104E-01 * pt;
      scale[1] = 1.0502  + 0.22138E-01 * pt;
      scale[2] = 0.75267 + 0.85377E-01 * pt;
      // Change to linear fit for robustness (Jul. 07th, 2004. KUSAKA Akito)
      // scale[3] = 1.3726  +(-0.31170 + 0.74074E-01*pt)*pt;
      scale[3] = 1.1608   - 0.43478E-01 * pt;
      scale[4] = 1.0936  + 0.18447E-01 * pt;
    } else {
      // pt
      scale[0] = 0.98971 - 0.12162E-01 * pt;
      scale[1] = 1.0132  + 0.22283E-01 * pt;
      scale[2] = 0.74947 + 0.81233E-01 * pt;
      scale[3] = 1.0601  - 0.54626E-01 * pt;
      scale[4] = 1.0454  - 0.33036E-02 * pt;
    }
  }

cal_scale_error_EXP33_hadronic_mc()

static void cal_scale_error_EXP33_hadronic_mc ( double  scale[5], double  pt, double  tanl  )

static

Scale error for Exp.33,35 Hadron MC.

Definition at line 2266 of file B2BIIFixMdstModule_trk.cc.

  {
    if (SE_Reprocess_Version == 0) {
      // pt
      scale[0] = 1.3083  - 0.10894 * pt;
      scale[1] = 1.2471  - 0.30959E-01 * pt;
      // scale[2] = 0.94594 -0.21216E-01*pt;
      scale[2] = vfunc(pt, 0.79736, 0.90954, -0.45673, 0.37072E-02);
      scale[3] = 1.3307  - 0.17559 * pt;
      scale[4] = 1.2408  - 0.29914E-01 * pt;
 
      // tanl
      // scale[3] *= 0.95593 + (0.39351E-01 + 0.10450*tanl)*tanl;
      scale[3] *= vfunc(tanl, -0.63864E-01, 0.95936, -0.11035, 0.10057);
    } else {
      // pt
      scale[0] = vfunc(pt, 1.4506, 1.0599, -0.10534, -0.14118);
      scale[1] = lambdafunc(pt, 0.23691, 0.47860, 1.1996, -0.39938E-01, 0.23518, -0.62661E-01);
      scale[2] = lambdafunc(pt, 0.45865, 0.92603, 0.95622, -0.51715, -0.12868, 0.45187E-01);
      scale[3] = 1.2555 - 0.19038 * pt;
      scale[4] = vfunc(pt, 0.68946, 1.1772, 0.15927, -0.79017E-01);
    }
  }

cal_scale_error_EXP35_cosmic_data()

static void cal_scale_error_EXP35_cosmic_data ( double  scale[5], double  pt, double  tanl  )

static

Scale error for Exp.35 Cosmic data.

Definition at line 1964 of file B2BIIFixMdstModule_trk.cc.

  {
    if (SE_Reprocess_Version == 0) {
      // pt
      scale[0] = 1.1084  + 0.45825E-01 * pt;
      scale[1] = 1.1014  + 0.14211E-01 * pt;
      scale[2] = 0.99716 + 0.52509E-01 * pt;
      scale[3] = 1.1361  - 0.25355E-01 * pt;
      scale[4] = 1.1079  - 0.92563E-02 * pt;
    } else {
      cal_scale_error_EXP33_cosmic_data(scale, pt, tanl);
    }
  }

cal_scale_error_EXP35_cosmic_mc()

static void cal_scale_error_EXP35_cosmic_mc ( double  scale[5], double  pt, double  tanl  )

static

Scale error for Exp.35 Cosmic MC.

Definition at line 1643 of file B2BIIFixMdstModule_trk.cc.

  {
    if (SE_Reprocess_Version == 0) {
      // pt
      scale[0] = 1.0835  + 0.79781E-02 * pt;
      scale[1] = 1.0685  + 0.13339E-01 * pt;
      scale[2] = 0.72615 + 0.96936E-01 * pt;
      scale[3] = 1.1298  - 0.35734E-01 * pt;
      scale[4] = 1.0994  + 0.13150E-01 * pt;
    } else {
      // pt
      cal_scale_error_EXP33_cosmic_mc(scale, pt, tanl);
    }
  }

cal_scale_error_EXP35_hadronic_mc()

static void cal_scale_error_EXP35_hadronic_mc ( double  scale[5], double  pt, double  tanl  )

static

Scale error for Exp.33,35 Hadron MC.

Definition at line 2296 of file B2BIIFixMdstModule_trk.cc.

  {
    cal_scale_error_EXP33_hadronic_mc(scale, pt, tanl);
  }

cal_scale_error_EXP37_cosmic_data()

static void cal_scale_error_EXP37_cosmic_data ( double  scale[5], double  pt, double    )

static

Scale error for Exp.37 Cosmic data.

Definition at line 1984 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 1.2129  + 0.36787E-01 * pt;
    scale[1] = 1.0750  + 0.32722E-01 * pt;
    scale[2] = 0.98340 + 0.39096E-01 * pt;
    scale[3] = 1.1768   - 0.43894E-01 * pt;
    scale[4] = 1.1275   - 0.12562E-02 * pt;
  }

cal_scale_error_EXP37_cosmic_mc()

static void cal_scale_error_EXP37_cosmic_mc ( double  scale[5], double  pt, double    )

static

Scale error for Exp.37 Cosmic MC.

Definition at line 1664 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 1.0694   - 0.19048E-01 * pt;
    scale[1] = 1.0732  + 0.95531E-02 * pt;
    scale[2] = 0.74888 + 0.89957E-01 * pt;
    scale[3] = 1.1107   - 0.57216E-01 * pt;
    scale[4] = 1.1098   - 0.13305E-01 * pt;
  }

cal_scale_error_EXP37_hadronic_mc()

static void cal_scale_error_EXP37_hadronic_mc ( double  scale[5], double  pt, double  tanl  )

static

Scale error for Exp.37 Hadron MC.

Definition at line 2307 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 1.2548  - 0.87786E-01 * pt;
    scale[1] = 1.2562  - 0.89296E-03 * pt;
    scale[2] = vfunc(pt, 0.67905, 0.91705, -0.57837, -0.37276E-02);
    scale[3] = 1.3180  - 0.19459 * pt;
    scale[4] = 1.1652 + 0.33812E-01 * pt;
 
    // tanl
    scale[3] *= vfunc(tanl, -0.47522E-01, 0.96537, -0.41720E-01, 0.68031E-01);
  }

cal_scale_error_EXP3941_cosmic_data()

static void cal_scale_error_EXP3941_cosmic_data ( double  scale[5], double  pt, double    )

static

Scale error for Exp.39-41 Cosmic data.

Definition at line 2000 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 1.182285  + 0.4142677E-01 * pt;
    scale[1] = 1.090022  + 0.2995044E-01 * pt;
    scale[2] = 0.9581690 + 0.5764173E-01 * pt;
    scale[3] = 1.119173   - 0.2177483E-01 * pt;
    scale[4] = 1.126323   - 0.3786523E-02 * pt;
  }

cal_scale_error_EXP3941_cosmic_mc()

static void cal_scale_error_EXP3941_cosmic_mc ( double  scale[5], double  pt, double    )

static

Scale error for Exp.39,41 Cosmic MC.

Definition at line 1681 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 1.055465  - 0.2863498E-01 * pt;
    scale[1] = 1.005986  + 0.2709512E-01 * pt;
    scale[2] = 0.7459061 + 0.8352030E-01 * pt;
    scale[3] = 1.056039  - 0.6258768E-01 * pt;
    scale[4] = 1.043329  - 0.2975207E-03 * pt;
  }

cal_scale_error_EXP3941_hadronic_mc()

static void cal_scale_error_EXP3941_hadronic_mc ( double  scale[5], double  pt, double    )

static

Scale error for Exp.39,41 Hadron MC.

Definition at line 2327 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 1.236096  - 0.1015809 * pt;
    scale[1] = 1.248921  - 0.1130577E-01 * pt;
    scale[2] = vfunc(pt, 0.5129282, 0.9300365, -0.9450958, -0.1157168E-01);
    scale[3] = vfunc(pt, 1.650362,  0.9371865, -0.2142342, 0.7384746E-01);
    scale[4] = vfunc(pt, 0.7497343, 1.204451,   0.1333454, -0.7826934E-01);
  }

cal_scale_error_EXP43_cosmic_data()

static void cal_scale_error_EXP43_cosmic_data ( double  scale[5], double  pt, double    )

static

Scale error for Exp.43 Cosmic data.

Definition at line 2016 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 1.262359  + 0.1411302E-01 * pt;
    scale[1] = 1.051793  + 0.6225422E-01 * pt;
    scale[2] = 0.9668697 + 0.5492099E-01 * pt;
    scale[3] = 1.110838   - 0.2386986E-01 * pt;
    scale[4] = 1.106516  + 0.1239970E-01 * pt;
  }

cal_scale_error_EXP43_cosmic_mc()

static void cal_scale_error_EXP43_cosmic_mc ( double  scale[5], double  pt, double    )

static

Scale error for Exp.43 Cosmic MC.

Definition at line 1697 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 1.013759    - 0.8743831E-02 * pt;
    scale[1] = 1.071626    - 0.1333353E-01 * pt;
    scale[2] = 0.7507483   + 0.8399138E-01 * pt;
    scale[3] = 1.054345    - 0.5644758E-01 * pt;
    scale[4] = 1.020721    + 0.1323117E-01 * pt;
  }

cal_scale_error_EXP43_hadronic_mc()

static void cal_scale_error_EXP43_hadronic_mc ( double  scale[5], double  pt, double    )

static

Scale error for Exp.43 Hadron MC.

Definition at line 2343 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 1.240166    - 0.1051634 * pt;
    scale[1] = 1.257180    - 0.3122512E-01 * pt;
    scale[2] = vfunc(pt, 0.5272015, 0.9386514, -0.9648152, -0.1623573E-01);
    scale[3] = 1.280515    - 0.1991213 * pt;
    scale[4] = vfunc(pt, 0.6579201, 1.192409, 0.1197880, -0.5404800E-01);
  }

cal_scale_error_EXP4547_cosmic_data()

static void cal_scale_error_EXP4547_cosmic_data ( double  scale[5], double  pt, double    )

static

Scale error for Exp.45,47 Cosmic data.

Definition at line 2032 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt 8bin
    scale[0] =  1.164526    + 0.7671143E-01 * pt;
    scale[1] =  1.094987    + 0.2949413E-01 * pt;
    scale[2] =  1.084826    + 0.2513991E-01 * pt;
    scale[3] =  1.099221    - 0.2389658E-02 * pt;
    scale[4] =  1.146892    + 0.2682884E-02 * pt;
  }

cal_scale_error_EXP45_cosmic_mc()

static void cal_scale_error_EXP45_cosmic_mc ( double  scale[5], double  pt, double    )

static

Scale error for Exp.45 Cosmic MC.

Definition at line 1713 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] =  1.011008    - 0.2272887E-01 * pt;
    scale[1] =  1.030603    + 0.8892579E-02 * pt;
    scale[2] =  0.7181793   + 0.9717058E-01 * pt;
    scale[3] =  1.065804    - 0.6852337E-01 * pt;
    scale[4] =  1.085136    - 0.2324515E-01 * pt;
  }

cal_scale_error_EXP45_hadronic_mc()

static void cal_scale_error_EXP45_hadronic_mc ( double  scale[5], double  pt, double  tanl  )

static

Scale error for Exp.45 Hadron MC.

Definition at line 2359 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] =  1.213823    - .1029683 * pt;
    scale[1] =  1.239279    - .3706657E-01 * pt;
    scale[2] = vfunc(pt, 0.6145123, 0.8834459, -.4620622, 0.2099150E-01);
    scale[3] =  1.253126    - .1884352 * pt;
    scale[4] = vfunc(pt, 0.4928604, 1.169158, 0.2063893, -.5428730E-01);
 
    // tanl
    scale[2] *= vfunc(tanl, -.1240821, 0.9274375, -.8750933E-01, 0.8611448E-01);
  }

cal_scale_error_EXP47_cosmic_mc()

static void cal_scale_error_EXP47_cosmic_mc ( double  scale[5], double  pt, double    )

static

Scale error for Exp.47 Cosmic MC.

Definition at line 1729 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 0.9806778    - 0.2010826E-02 * pt;
    scale[1] = 0.9996797    + 0.2633917E-01 * pt;
    scale[2] = 0.7450445    + 0.7637244E-01 * pt;
    scale[3] =  1.084419    - 0.6828102E-01 * pt;
    scale[4] =  1.013550    + 0.1201861E-01 * pt;
  }

cal_scale_error_EXP47_hadronic_mc()

static void cal_scale_error_EXP47_hadronic_mc ( double  scale[5], double  pt, double    )

static

Scale error for Exp.47 Hadron MC.

Definition at line 2378 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 1.218633    - .1078999 * pt;
    scale[1] = 1.237288    - .2890434E-01 * pt;
    scale[2] = vfunc(pt, 0.4334312, 0.9027213, -.7119852, 0.1031877E-01);
    scale[3] =  1.252394    - .1835607 * pt;
    scale[4] = vfunc(pt, 0.6194937, 1.168190, 0.1285120, -.5815693E-01);
  }

cal_scale_error_EXP49_cosmic_data()

static void cal_scale_error_EXP49_cosmic_data ( double  scale[5], double  pt, double    )

static

Scale error for Exp.49 Cosmic data.

Definition at line 2048 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt 8bin
    scale[0] =  1.243211    + 0.5776083E-01 * pt;
    scale[1] =  1.209483    - 0.3366023E-01 * pt;
    scale[2] =  1.059087    + 0.4300838E-01 * pt;
    scale[3] =  1.123665    + 0.6342933E-02 * pt;
    scale[4] =  1.208850    - 0.3171053E-01 * pt;
  }

cal_scale_error_EXP49_cosmic_mc()

static void cal_scale_error_EXP49_cosmic_mc ( double  scale[5], double  pt, double    )

static

Scale error for Exp.49 Cosmic MC.

Definition at line 1745 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 1.000635    - 0.1659129E-01 * pt;
    scale[1] = 1.046513    - 0.2994663E-02 * pt;
    scale[2] = 0.7241409   + 0.9558808E-01 * pt;
    scale[3] = 1.062597    - 0.6663921E-01 * pt;
    scale[4] = 1.076486    - 0.2023062E-01 * pt;
  }

cal_scale_error_EXP49_hadronic_mc()

static void cal_scale_error_EXP49_hadronic_mc ( double  scale[5], double  pt, double    )

static

Scale error for Exp.49 Hadron MC.

Definition at line 2394 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] =  1.217751    - .1075724 * pt;
    scale[1] =  1.233774    - .3122749E-01 * pt;
    scale[2] = vfunc(pt, 0.5276512, 0.8852152, -.7025786, 0.3136450E-01);
    scale[3] =  1.258038    - .1949899 * pt;
    scale[4] = vfunc(pt, 0.5924365, 1.162905, 0.9632715E-01, -.6221822E-01);
 
  }

cal_scale_error_EXP51_cosmic_data()

static void cal_scale_error_EXP51_cosmic_data ( double  scale[5], double  pt, double  tanl  )

static

Scale error for Exp.51 Cosmic data.

Definition at line 2064 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt 5bin
    scale[0] =  1.2097      + 0.36177E-01 * pt;
    scale[1] =  1.2218      - 0.84772E-02 * pt;
    scale[2] =  0.97937     + 0.26397E-01 * pt;
    scale[3] =  1.0944      - 0.12745E-02 * pt;
    scale[4] =  1.2140      - 0.56809E-01 * pt;
 
    // tanl
    scale[0] *= 1.0492      + 0.72972E-01 * tanl;
    scale[1] *= 1.0298      + 0.40625E-02 * tanl;
    scale[2] *= 0.93367     + 0.11969E-01 * tanl;
    scale[3] *= 1.0170      + 0.41039E-01 * tanl;
    scale[4] *= 1.0677      - 0.41684E-01 * tanl;
  }

cal_scale_error_EXP51_cosmic_mc()

static void cal_scale_error_EXP51_cosmic_mc ( double  scale[5], double  pt, double    )

static

Scale error for Exp.51 Cosmic MC.

Definition at line 1761 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 0.98242     - 0.71780E-02 * pt;
    scale[1] = 1.0465      + 0.44401E-03 * pt;
    scale[2] = 0.71433     + 0.10176    * pt;
    scale[3] = 1.0875      - 0.80972E-01 * pt;
    scale[4] = 1.0777      - 0.20428E-01 * pt;
  }

cal_scale_error_EXP51_hadronic_mc()

static void cal_scale_error_EXP51_hadronic_mc ( double  scale[5], double  pt, double  tanl  )

static

Scale error for Exp.51 Hadron MC.

Definition at line 2411 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = vfunc(pt, 0.35776, 1.1919, 0.84229E-01, -0.88550E-01);
    scale[1] = vfunc(pt, 0.37833, 1.2394, 0.34089,     -0.54440E-01);
    scale[2] = lambdafunc(pt, 0.87688, 1.4065, 0.86733, -0.23657, 0.21714E-01, 0.20876);
    scale[3] = lambdafunc(pt, 0.39825, 1.0950, 1.2104, 0.11718E-01, -0.21145, -0.89681E-01);
    scale[4] = vfunc(pt, 0.48051, 1.1672, 0.19241,     -0.32273E-01);
 
    // tanl
    scale[2] *= vfunc(tanl, -0.40697, 0.92948, -0.29453, 0.59416E-01);
  }

cal_scale_error_EXP53_cosmic_data()

static void cal_scale_error_EXP53_cosmic_data ( double  scale[5], double  pt, double    )

static

Scale error for Exp.53 Cosmic data.

Definition at line 2087 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt 5bin
    scale[0] =  1.2587      + 0.32782E-01 * pt;
    scale[1] =  1.2413      - 0.36535E-01 * pt;
    scale[2] =  0.97465     + 0.22937E-01 * pt;
    scale[3] =  1.1197      - 0.59050E-02 * pt;
    scale[4] =  1.1877      - 0.32893E-01 * pt;
  }

cal_scale_error_EXP53_cosmic_mc()

static void cal_scale_error_EXP53_cosmic_mc ( double  scale[5], double  pt, double    )

static

Scale error for Exp.53 Cosmic MC.

Definition at line 1777 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 0.99832     - 0.17290E-01 * pt;
    scale[1] = 1.0434      + 0.47995E-02 * pt;
    scale[2] = 0.72111     + 0.10093    * pt;
    scale[3] = 1.1022      - 0.87951E-01 * pt;
    scale[4] = 1.0643      - 0.11962E-01 * pt;
  }

cal_scale_error_EXP53_hadronic_mc()

static void cal_scale_error_EXP53_hadronic_mc ( double  scale[5], double  pt, double    )

static

Scale error for Exp.53 Hadron MC.

Definition at line 2430 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = lambdafunc(pt, 0.50681, 1.2150, 1.2266, 0.99662E-01, -0.23508, -0.52268E-01);
    scale[1] = lambdafunc(pt, 0.50787, 1.2308, 1.3108, 0.42334, -0.25502, -0.13522E-01);
    scale[2] = vfunc(pt, 1.2149, 0.88700, -0.15323, 0.97993E-01);
    scale[3] = lambdafunc(pt, 0.45595, 1.1561, 1.2383, 0.17605, -0.34753, -0.97049E-01);
    scale[4] = vfunc(pt, 0.55269, 1.2261, 0.39706, -0.12333);
  }

cal_scale_error_EXP55_cosmic_data()

static void cal_scale_error_EXP55_cosmic_data ( double  scale[5], double  pt, double  tanl  )

static

Scale error for Exp.55 Cosmic data.

Definition at line 2103 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt 5bin
    scale[0] =  1.2654      + 0.15660E-01 * pt;
    scale[1] =  1.0278      + 0.81680E-01 * pt;
    scale[2] =  0.94291     + 0.54575E-01 * pt;
    scale[3] =  1.1151      - 0.52387E-02 * pt;
    scale[4] =  1.1020      + 0.10518E-01 * pt;
 
    // tanl 5bin
    scale[0] *= 1.0334      + 0.10236E-01 * tanl;
    scale[1] *= 1.0346      + 0.11024E-01 * tanl;
    // scale[2] *= 0.91773     -0.52276E-02*tanl;
    scale[3] *= 1.0140      + 0.19030E-01 * tanl;
    scale[4] *= 1.0345      - 0.90291E-01 * tanl;
  }

cal_scale_error_EXP55_cosmic_mc()

static void cal_scale_error_EXP55_cosmic_mc ( double  scale[5], double  pt, double    )

static

Scale error for Exp.55 Cosmic MC.

Definition at line 1793 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 0.98871     - 0.88399E-02 * pt;
    scale[1] = 1.0159      + 0.16468E-01 * pt;
    scale[2] = 0.72813     + 0.94737E-01 * pt;
    scale[3] = 1.1060      - 0.88323E-01 * pt;
    scale[4] = 1.0914      - 0.30607E-01 * pt;
  }

cal_scale_error_EXP55_hadronic_mc()

static void cal_scale_error_EXP55_hadronic_mc ( double  scale[5], double  pt, double    )

static

Scale error for Exp.55 Hadron MC.

Definition at line 2446 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = vfunc(pt, 0.34925, 1.1780, 0.89069E-01, -0.10090);
    scale[1] = vfunc(pt, 0.35168, 1.2380, 0.41479, -0.63250E-01);
    scale[2] = vfunc(pt, 1.2497, 0.88495, -0.14338, 0.94307E-01);
    scale[3] = lambdafunc(pt, 0.29565, 1.4502, 1.2139, 0.14353, -0.21211, -0.82968E-01);
    scale[4] = vfunc(pt, 1.2496, 1.1216, 0.97174E-02, -0.41166E-01);
  }

cal_scale_error_EXP6165_cosmic_data()

static void cal_scale_error_EXP6165_cosmic_data ( double  scale[5], double  pt, double  tanl  )

static

Scale error for Exp.61-65 Cosmic data.

Definition at line 2126 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt 5bin
    scale[0] =  1.1184      + 0.55671E-01 * pt;
    scale[1] =  1.1142      + 0.74526E-02 * pt;
    scale[2] =  0.93626     + 0.66670E-01 * pt;
    scale[3] =  1.1003      - 0.11587E-01 * pt;
    scale[4] =  1.1589      - 0.40223E-01 * pt;
 
    // tanl 5bin
    scale[0] *= 1.0442      - 0.46775E-01 * tanl;
    scale[1] *= 1.0337      + 0.44071E-01 * tanl;
    // scale[2] *= 0.91898     -0.28268E-02*tanl;
    scale[3] *= 1.0037      + 0.29736E-01 * tanl;
    scale[4] *= 1.0378      - 0.73239E-01 * tanl;
  }

cal_scale_error_EXP6165_cosmic_mc()

static void cal_scale_error_EXP6165_cosmic_mc ( double  scale[5], double  pt, double  tanl  )

static

Scale error for Exp.61-65 Cosmic MC.

Definition at line 1809 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 0.97322     - 0.29003E-02 * pt;
    scale[1] = 0.94704     + 0.44719E-01 * pt;
    scale[2] = 0.73547     + 0.98431E-01 * pt;
    scale[3] = 1.0752      - 0.77818E-01 * pt;
    scale[4] = 1.0759      - 0.27057E-01 * pt;
 
    // tanl
    scale[0] *= 0.99600     - 0.97573E-02 * tanl;
    scale[1] *= 1.0080      - 0.37122E-01 * tanl;
    scale[2] *= 0.99150     - 0.13390E-01 * tanl;
    scale[3] *= 0.99758     - 0.43508E-01 * tanl;
    scale[4] *= 0.99913     + 0.34211E-01 * tanl;
  }

cal_scale_error_EXP6165_hadronic_mc()

static void cal_scale_error_EXP6165_hadronic_mc ( double  scale[5], double  pt, double    )

static

Scale error for Exp.61-65 Hadron MC.

Definition at line 2462 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = vfunc(pt, 1.4501, 1.0348, -0.12125, -0.27519E-01);
    scale[1] = lambdafunc(pt, 0.48988, 1.5501, 1.2544, 0.21014, -0.10419, 0.74755E-01);
    scale[2] = lambdafunc(pt, 0.44993, 1.3616, 0.93316, -0.58441, -0.30814E-01, 0.90806E-01);
    scale[3] = 1.2385      - 0.17733 * pt;
    scale[4] = vfunc(pt, 0.75590, 1.1726, 0.12749, -0.75183E-01);
  }

cal_scale_error_EXP67_cosmic_data()

static void cal_scale_error_EXP67_cosmic_data ( double  scale[5], double  pt, double  tanl  )

static

Scale error for Exp.67 Cosmic data.

Definition at line 2149 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt 5bin
    scale[0] =  1.1598      + 0.28880E-01 * pt;
    scale[1] =  1.0844      + 0.23384E-01 * pt;
    scale[2] =  0.94566     + 0.53157E-01 * pt;
    scale[3] =  1.1578      - 0.31156E-01 * pt;
    scale[4] =  1.0725      + 0.13714E-01 * pt;
 
    // tanl 5bin
    scale[0] *= 1.0223      - 0.56165E-02 * tanl;
    scale[1] *= 1.0203      - 0.81857E-02 * tanl;
    // scale[2] *= 0.90812     +0.15679E-01*tanl;
    scale[3] *= 0.99703     + 0.14976E-01 * tanl;
    scale[4] *= 1.0212      + 0.41300E-01 * tanl;
  }

cal_scale_error_EXP67_cosmic_mc()

static void cal_scale_error_EXP67_cosmic_mc ( double  scale[5], double  pt, double  tanl  )

static

Scale error for Exp.67 Cosmic MC.

Definition at line 1832 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 0.99845     - 0.18739E-01 * pt;
    scale[1] = 1.0024      + 0.17833E-01 * pt;
    scale[2] = 0.72369     + 0.96994E-01 * pt;
    scale[3] = 1.0605      - 0.64072E-01 * pt;
    scale[4] = 1.0623      - 0.14320E-01 * pt;
 
    // tanl
    scale[0] *= 0.99597     - 0.13069E-01 * tanl;
    scale[1] *= 1.0072      - 0.18622E-01 * tanl;
    scale[2] *= 0.99515     - 0.16591E-01 * tanl;
    scale[3] *= 0.99466     - 0.14489E-02 * tanl;
    scale[4] *= 1.0036      - 0.15095E-01 * tanl;
  }

cal_scale_error_EXP67_hadronic_mc()

static void cal_scale_error_EXP67_hadronic_mc ( double  scale[5], double  pt, double    )

static

Scale error for Exp.67 Hadron MC.

Definition at line 2478 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = vfunc(pt, 1.0501, 1.0852, -0.14604, -0.66317E-01);
    scale[1] = lambdafunc(pt, 0.37538, 2.5672, 1.2362, 0.14203, -0.58242E-01, 0.28431E-02);
    scale[2] = lambdafunc(pt, 0.52700, 1.3506, 0.90327, -0.55627, 0.13131E-02, 0.11059);
    scale[3] = 1.2577      - 0.19572 * pt;
    scale[4] = vfunc(pt, 0.69484, 1.1636, 0.96169E-01, -0.80421E-01);
  }

cal_scale_error_EXP6971_cosmic_data()

static void cal_scale_error_EXP6971_cosmic_data ( double  scale[5], double  pt, double  tanl  )

static

Scale error for Exp.69,71 Cosmic data.

Definition at line 2175 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt 5bin
    scale[0] =  1.2101      + 0.29496E-01 * pt;
    scale[1] =  1.0723      + 0.13773E-01 * pt;
    scale[2] =  0.90988     + 0.78667E-01 * pt;
    scale[3] =  1.1444      - 0.20780E-01 * pt;
    scale[4] =  1.0962      + 0.83309E-02 * pt;
 
    // tanl 5bin
    scale[0] *= 1.0207      - 0.17810E-01 * tanl;
    scale[1] *= 1.0272      + 0.61498E-01 * tanl;
    // scale[2] *= 0.91584     +0.16138E-01*tanl;
    scale[3] *= 0.99766     + 0.32434E-01 * tanl;
    scale[4] *= 1.0200      - 0.14935E-01 * tanl;
  }

cal_scale_error_EXP6971_cosmic_mc()

static void cal_scale_error_EXP6971_cosmic_mc ( double  scale[5], double  pt, double  tanl  )

static

Scale error for Exp.69-71 Cosmic MC.

Definition at line 1858 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = 0.96783     - 0.37174E-02 * pt;
    scale[1] = 0.97888     + 0.34689E-01 * pt;
    scale[2] = 0.80870     + 0.68302E-01 * pt;
    scale[3] = 1.0615      - 0.60750E-01 * pt;
    scale[4] = 1.0372      - 0.52332E-03 * pt;
 
    // tanl
    scale[0] *= 0.99897     + 0.62207E-02 * tanl;
    scale[1] *= 1.0037      + 0.10714E-01 * tanl;
    scale[2] *= 0.99129     - 0.92521E-02 * tanl;
    scale[3] *= 0.99483     - 0.43402E-02 * tanl;
    scale[4] *= 1.0062      + 0.15306E-01 * tanl;
  }

cal_scale_error_EXP6971_hadronic_mc()

static void cal_scale_error_EXP6971_hadronic_mc ( double  scale[5], double  pt, double    )

static

Scale error for Exp.69,71 Hadron MC.

Definition at line 2497 of file B2BIIFixMdstModule_trk.cc.

  {
    // pt
    scale[0] = vfunc(pt, 1.7258, 1.0126, -0.12693, 0.31924E-01);
    scale[1] = lambdafunc(pt, 0.37552, 1.2217, 1.2532, 0.37276, -0.77830E-01, -0.31378E-01);
    scale[2] = lambdafunc(pt, 0.40176, 1.1748, 0.95524, -0.72331, -0.53213E-01, 0.90074E-01);
    scale[3] = 1.2644      - 0.19783 * pt;
    scale[4] = vfunc(pt, 0.56934, 1.1649, 0.13098, -0.52232E-01);
  }

correct_ecl()

void correct_ecl ( int  option, int  version  )

private

Correct photon's momenta and error matrix.

Definition at line 1226 of file B2BIIFixMdstModule_ecl.cc.

  {
 
    int ecl_threshold(0);
    if (m_reprocess_version == 0) {
      ecl_threshold = 1;
    } else if (m_reprocess_version == 1) {
      ecl_threshold = 0;
    }
 
    //dout(Debugout::INFO,"B2BIIFixMdst_ecl") << "This is version1.2.1" << std::endl;
    // dout(Debugout::INFO,"B2BIIFixMdst_ecl") << "entering correct_ecl()" << std::endl;
    // Check whether "version" is supported.
    if (version < 1 || version > 2) {
      B2WARNING("correct_ecl :: Warning! ");
      B2WARNING("version=" << version << " is not supported! ");
      B2WARNING("Exit doing nothing!");
    }
 
    //---------------------
    // Control sequence based on belle_event table.
    //---------------------
    Belle::Belle_event_Manager& evtmgr = Belle::Belle_event_Manager::get_manager();
    if (0 == evtmgr.count()) {
      // Do nothing if not exist, because we can not know whether
      // this event is Exp. data or MC.
      return;
    }
    //Check data or mc. Data:expmc=1, MC:expmc=2.
    int expmc = evtmgr[0].ExpMC();
    // Exp, Run, number to be given to correction func.
    int Eno = evtmgr[0].ExpNo();
    int Rno = evtmgr[0].RunNo();
 
    // If option is 0 and this event is MC, do nothing.
    // Modify : Exp.61 processed by b20080502, MC is also corrected.
    //org if( option==0 && expmc==2 )
    if (option == 0 && expmc == 2) {
      //if( Eno<55) //test
      //std::cout<<"ecl_threshold="<<ecl_threshold<<std::endl;
      //      if( Eno<60 || ( Eno==61 && Rno>1209 ) /* 5S scan runs. */
      //   || ( Eno==61 && m_correct_ecl_5s==1 ) /* Exp.61 old lib case.*/
      //   || ( Eno==65 && Rno>1000 ) /* 1S runs.*/
      //   || ( Eno==65 && m_correct_ecl_5s==1 ) /* Exp.65 old lib case.*/)
      if (ecl_threshold == 1) {
        return;
      }
    }
 
    // Correction curve version control.
    int i_previous(0);
    // Mdst_event_add table is there?
    Belle::Mdst_event_add_Manager& mevtmgr = Belle::Mdst_event_add_Manager::get_manager();
    // When Mdst_event_add exists,
    if (mevtmgr.count() > 0) {
      // Up to Exp.13, same treatment as V1.0 2001/Nov./30th
      //if( Eno <= 13 )
      // Modify; Exp.13 moved to same treatment as Exp.15 or later.
      // 20020524 Kenkichi Miyabayashi.
      if (Eno <= 11) {
        // If already the energy is corrected, exit.
        if (mevtmgr[0].flag(3) == 1) {
          return;
        }
        // Otherwise, set the flag at proper entity, flag(3).
        // Note that frag(1) and frag(2) have already been used
        // in scale_momenta().
        mevtmgr[0].flag(3, 1);
      }
      // Exp.13 and later...last update 2002/May./24 K.Miya.
      else { // Exp.15 and later...last update 2002/Feb./20
        // If well-established version was already applied, exit.
        if (mevtmgr[0].flag(3) >= version) {
          return;
        }
        // Otherwise, check the previous version.
        i_previous = mevtmgr[0].flag(3);
        if (i_previous == 0 || i_previous == 1) {
          mevtmgr[0].flag(3, version);
        } else { // Previous version is unsupported one.
          // Make Warning and exit.
          B2WARNING("correct_ecl :: Warning! ");
          B2WARNING("Previously, uncorrect version was used. ");
          B2WARNING(" Exit doing nothing");
          return;
        }
      }
    } else { // Create Mdst_event_add and set flag.
      Belle::Mdst_event_add& meadd = mevtmgr.add();
      // Up to Exp.13, same treatment as before.
      if (Eno <= 13) {
        meadd.flag(3, 1);
      } else { // For Exp.15, set version.
        meadd.flag(3, version);
      }
    }
 
    //--------------------------
    // If no ad_hoc correction has been applied so far or
    // correction curve is new version,
    // overwrite proper panther tables.
    //--------------------------
    // Get Mdst_ecl and Mdst_gamma.
    Belle::Mdst_ecl_Manager&   eclmgr   = Belle::Mdst_ecl_Manager::get_manager();
    Belle::Mdst_gamma_Manager& gammamgr = Belle::Mdst_gamma_Manager::get_manager();
 
    // Get Mdst_ecl_aux. Added 20060413
    Belle::Mdst_ecl_aux_Manager& eclauxmgr = Belle::Mdst_ecl_aux_Manager::get_manager();
    std::vector<Belle::Mdst_ecl_aux>::iterator itaux = eclauxmgr.begin();
 
    // Correct energy and error matrix in Mdst_ecl.
    double factor;
    double factor13;
 
    for (std::vector<Belle::Mdst_ecl>::iterator itecl = eclmgr.begin();
         itecl != eclmgr.end(); ++itecl) {
      Belle::Mdst_ecl& shower = *itecl;
      // Shower energy and polar angle
      double shower_energy = shower.energy();
      double shower_theta  = shower.theta();
 
      // Fix wrong calib. for Exp. 45.
      //      if( Eno==45 )
      if (expmc == 1 && m_reprocess_version == 0 && Eno == 45) {
        int cellID = (*itaux).cId();
        double factor45 = ecl_adhoc_corr_45(Eno, Rno, cellID);
        //if( factor45!=1.0 )
        //{
        //int idecl=shower.get_ID();
        // dout(Debugout::DDEBUG,"B2BIIFixBelle::Mdst_ecl")<<"Exp45 fix idecl="<<idecl<<" cellID="<<cellID
        //<<" factor45="<<factor45<<std::endl;
        //}
 
        shower.energy(shower.energy() / factor45);
        double factor452 = factor45 * factor45;
        shower.error(0, shower.error(0) / factor452); // Energy diagonal.
        shower.error(1, shower.error(1) / factor45); // Energy-phi.
        shower.error(3, shower.error(3) / factor45); // Energy-theta.
 
        // Here, also take care of Belle::Mdst_gamma.
        for (std::vector<Belle::Mdst_gamma>::iterator itgam45 = gammamgr.begin();
             itgam45 != gammamgr.end(); ++itgam45) {
          Belle::Mdst_gamma& gamma45 = *itgam45;
          if (gamma45.ecl().get_ID() == shower.get_ID()) {
            gamma45.px(gamma45.px() / factor45);
            gamma45.py(gamma45.py() / factor45);
            gamma45.pz(gamma45.pz() / factor45);
            //int idgam=gamma45.get_ID();
            //if( factor45!=1.0 )
            //{
            // dout(Debugout::DDEBUG,"B2BIIFixBelle::Mdst_ecl")<< "Exp45 fix idgamma="<<idgam<<std::endl;
            //}
          }
        }
      }
 
      // control sequence by option and expmc.
      // option=0
      switch (option) {
        case 0: // Option set as default.
          if (expmc == 2) { // This event record is MC data.
            // processed b20080331 or older, already skip.
            //KM std::cout<<"mdst_ecl"<<std::endl;
            factor
              = ecl_mcx3_corr(Eno, Rno, shower_energy, cos(shower_theta));
          } else { // Exp. data.
            //Original definition.
            //factor
            // = ecl_adhoc_corr( Eno, Rno,
            //  shower_energy, cos(shower_theta));
            //Modified 20081222
            factor
              = ecl_adhoc_corr(Eno, Rno, ecl_threshold,
                               shower_energy, cos(shower_theta));
            // Special treatment of Exp.15 processed by b20020125.
            if (Eno == 15 && i_previous == 1) {
              // dout(Debugout::INFO,"B2BIIFixBelle::Mdst_ecl") << "Exp.15 version=1 applied case!" << std::endl;
              //dout(Debugout::INFO,"B2BIIFixBelle::Mdst_ecl") << "ecl factor=" << factor << " " ;
              // Original scaling is done by Exp.13 curve.
              //Original definition.
              //factor13
              //= ecl_adhoc_corr( 13, 1,
              //shower_energy, cos(shower_theta));
              //Modified 20081222
              factor13
                = ecl_adhoc_corr(13, 1, ecl_threshold,
                                 shower_energy, cos(shower_theta));
              factor = factor / factor13;
              //dout(Debugout::INFO,"B2BIIFixBelle::Mdst_ecl") << "factor(rel)=" << factor << " ";
            }
          }
          break;
        case 1:
          if (expmc == 2) { // This event record is MC data.
            factor = 1.0 / mpi0pdg(shower.energy());
 
          } else { // This event record is real data.
            //Original definition.
            //factor
            // = ecl_adhoc_corr( Eno, Rno,
            //     shower.energy(), cos(shower.theta()));
            //Modified 20081222
            factor
              = ecl_adhoc_corr(Eno, Rno, ecl_threshold,
                               shower.energy(), cos(shower.theta()));
            // Special treatment of Exp.15 processed by b20020125.
            if (Eno == 15 && i_previous == 1) {
              // Original scaling is done by Exp.13 curve.
              //Original definition.
              //factor13
              // = ecl_adhoc_corr( 13, 1,
              //         shower_energy, cos(shower_theta));
              //Modified 20081222
              factor13
                = ecl_adhoc_corr(13, 1, ecl_threshold,
                                 shower_energy, cos(shower_theta));
              factor = factor / factor13;
              //dout(Debugout::INFO,"B2BIIFixBelle::Mdst_ecl") << "factor(rel)=" << factor << " ";
            }
 
            factor = factor / mpi0pdg(shower.energy());
          }
          break;
        default:
          factor = 1.0;
      }
 
      // energy correction.
      shower.energy(shower.energy() / factor);
 
      // error matrix correction.
      double factor2 = factor * factor;
      shower.error(0, shower.error(0) / factor2); // Energy diagonal.
      shower.error(1, shower.error(1) / factor); // Energy-phi.
      shower.error(3, shower.error(3) / factor); // Energy-theta.
 
      // Incriment Belle::Mdst_ecl_aux pointer.
      ++itaux;
    }
 
    // Correct energy in Belle::Mdst_gamma.
    for (std::vector<Belle::Mdst_gamma>::iterator itgam = gammamgr.begin();
         itgam != gammamgr.end(); ++itgam) {
      Belle::Mdst_gamma& gamma = *itgam;
      // Create the gamma's 3vector
      CLHEP::Hep3Vector gamma_3v(gamma.px(), gamma.py(), gamma.pz());
      double gamma_energy = gamma_3v.mag();
      double gamma_cos    = gamma_3v.cosTheta();
 
      // control sequence by option and expmc.
      switch (option) {
        case 0: // Option as default.
          if (expmc == 2) { // This event record is MC data.
            // processed b20080331 or older, already skip.
            //KM std::cout<<"mdst_gamma"<<std::endl;
            factor
              = ecl_mcx3_corr(Eno, Rno, gamma_energy, gamma_cos);
          } else { // Exp. data.
            //Original definition
            //factor
            // = ecl_adhoc_corr( Eno, Rno,
            //     gamma_energy, gamma_cos);
            //Modified 20081222
            factor
              = ecl_adhoc_corr(Eno, Rno, ecl_threshold,
                               gamma_energy, gamma_cos);
            // Special treatment of Exp.15 processed by b20020125.
            if (Eno == 15 && i_previous == 1) {
              // dout(Debugout::INFO,"B2BIIFixBelle::Mdst_ecl") << "Exp.15 version=1 applied case!" << std::endl;
              //dout(Debugout::INFO,"B2BIIFixBelle::Mdst_ecl") << "factor=" << factor << " " ;
              // Original scaling is done by Exp.13 curve.
              //Original definition.
              //factor13
              // = ecl_adhoc_corr( 13, 1,
              //         gamma_energy, gamma_cos);
              //Modified 20081222
              factor13
                = ecl_adhoc_corr(13, 1, ecl_threshold,
                                 gamma_energy, gamma_cos);
              factor = factor / factor13;
              //dout(Debugout::INFO,"B2BIIFixBelle::Mdst_ecl") << "gamma factor(rel)=" << factor << " " << std::endl;
            }
          }
          break;
        case 1:
          if (expmc == 2) {
            factor = 1.0 / mpi0pdg(gamma_3v.mag());
 
          } else {
            //Original definition.
            //factor
            // = ecl_adhoc_corr( Eno, Rno,
            //     gamma_3v.mag(), gamma_3v.cosTheta());
            //Modified 20081222
            factor
              = ecl_adhoc_corr(Eno, Rno, ecl_threshold,
                               gamma_3v.mag(), gamma_3v.cosTheta());
            // Special treatment of Exp.15 processed by b20020125.
            if (Eno == 15 && i_previous == 1) {
              // dout(Debugout::INFO,"B2BIIFixBelle::Mdst_ecl") << "Exp.15 version=1 applied case!" << std::endl;
              //dout(Debugout::INFO,"B2BIIFixBelle::Mdst_ecl") << "factor=" << factor << " " ;
              // Original scaling is done by Exp.13 curve.
              //Original definition.
              //factor13
              // = ecl_adhoc_corr( 13, 1,
              //         gamma_energy, gamma_cos);
              //Modified 20081222
              factor13
                = ecl_adhoc_corr(13, 1, ecl_threshold,
                                 gamma_energy, gamma_cos);
              factor = factor / factor13;
              //dout(Debugout::INFO,"B2BIIFixBelle::Mdst_ecl") << "gamma factor(rel)=" << factor << " " << std::endl;
            }
            factor = factor / mpi0pdg(gamma_3v.mag());
          }
          break;
        default:
          factor = 1.0;
      }
 
      // factor should be used as a division.
      gamma.px(gamma.px() / factor);
      gamma.py(gamma.py() / factor);
      gamma.pz(gamma.pz() / factor);
    }
  }

correct_ecl_primary_vertex()

void correct_ecl_primary_vertex ( const HepPoint3D &  epvtx, const CLHEP::HepSymMatrix &  epvtx_err  )

private

Correct ecl using primary vertex.

Definition at line 2275 of file B2BIIFixMdstModule_ecl.cc.

  {
 
    Belle::Mdst_gamma_Manager& Gamma  = Belle::Mdst_gamma_Manager::get_manager();
 
    for (std::vector<Belle::Mdst_gamma>::iterator
         it = Gamma.begin(); it != Gamma.end(); ++it) {
      double r(it->ecl().r());
      double theta(it->ecl().theta());
      double phi(it->ecl().phi());
      //    double stheta(std::sqrt(it->ecl().error(2)));
      //    double sphi(std::sqrt(it->ecl().error(5)));
      double st(std::sin(theta));
      double ct(std::cos(theta));
      double sp(std::sin(phi));
      double cp(std::cos(phi));
      HepPoint3D gamma_pos(r * st * cp, r * st * sp, r * ct);
      CLHEP::Hep3Vector gamma_vec(gamma_pos - epvtx);
      double hsq(gamma_vec.perp2());
      double rsq(gamma_vec.mag2());
      double stheta_sq_new = it->ecl().error(5) + epvtx_err(3, 3) * (hsq / (rsq * rsq));
      CLHEP::Hep3Vector gamma_dir(gamma_vec.unit());
      double e(it->ecl().energy());
      it->px(e * gamma_dir.x());
      it->py(e * gamma_dir.y());
      it->pz(e * gamma_dir.z());
      it->ecl().theta(gamma_dir.theta());
      it->ecl().r(gamma_vec.mag());
      it->ecl().error(5, stheta_sq_new);
    }
  }

cupfunc()

double cupfunc ( const double  x, const double  x1, const double  x2, const double  yc, const double  a1, const double  a2  )

inline

cupfunc

Definition at line 1526 of file B2BIIFixMdstModule_trk.cc.

  {
    return x < x1 ? (x - x1) * a1 + yc :
           x > x2 ? (x - x2) * a2 + yc : yc;
  }

ecl_adhoc_corr()

static double ecl_adhoc_corr ( int  Exp, int  Run, int  iflag05th, double  Energy, double    )

static

The function giving correction factor.

Corresponding Data/MC so that energy in data should be divided by this.

Definition at line 155 of file B2BIIFixMdstModule_ecl.cc.

  {
    double return_value;
 
    // Default.
    return_value = 1.0;
 
    double x = std::log10(Energy * 1000.0);
    switch (Exp) {
      case 7:
        //if( x < 2.5 )
        //{
        //   return_value = 0.85445 + 0.89162e-1*x
        //      -0.96202e-2*x*x -0.10944e-2*x*x*x;
        //}
        // New curve for b20020416 processed mdst.
        if (x < 2.6) {
          return_value = 0.85878 + 0.81947e-1 * x - 0.99708e-2 * x * x
                         - 0.28161e-3 * x * x * x;
        }
        break;
      case 9:
        //if( x < 3.0 )
        //{
        //   return_value = 0.83416 + 0.93534e-1*x
        //      -0.71632e-2*x*x -0.19072e-2*x*x*x;
        //}
        // New curve for b20020416 processed mdst.
        if (x < 3.2) {
          return_value = 0.86582 + 0.63194e-1 * x - 0.59391e-2 * x * x
                         + 0.17727e-2 * x * x * x - 0.62325e-3 * x * x * x * x;
        }
        break;
      case 11:
        // Proper curve for b20010507 processed mdst.
        //if( x < 3.0 )
        //{
        //   return_value = 0.84927 + 0.86308e-1*x
        //      -0.93898e-2*x*x -0.10557e-2*x*x*x;
        //}
        //
        // Proper curve for b20020416 processed mdst.
        if (x < 3.7) {
          if (x < 3.0) {
            return_value = 0.88989 + 0.41082e-1 * x
                           - 0.21919e-2 * x * x + 0.27116e-2 * x * x * x - 0.89113e-3 * x * x * x * x;
          } else { // Linear extrapolation to unity.
            return_value = 0.994441 + 4.90176e-3 * (x - 3.0);
          }
        }
        break;
      case 13:
        // Proper curve for b20010507 processed mdst.
        //if( x < 3.0 )
        //{
        //return_value = 0.78138 + 0.17899*x
        // -0.48821e-1*x*x +0.43692e-2*x*x*x;
        //}
        //
        // Proper curve for b20020416 processed mdst.
        if (x < 3.2) {
          return_value = 0.87434 + 0.62145e-1 * x
                         - 0.29691e-2 * x * x - 0.15843e-2 * x * x * x + 0.86858e-4 * x * x * x * x;
        }
        break;
      case 15:
        // Proper curve for b20020125 processed mdst.
        //if( x < 3.0 )
        //{
        //   return_value = 0.86858 + 0.75587e-1*x
        //      -0.11150e-1*x*x -0.21454e-4*x*x*x;
        //}
        //else if( x < 3.67 ) // Lenear extrapolation to be unity.
        //{
        //   return_value = 0.994412 + 8.11e-3*( x - 3.0 );
        //}
        // Proper curve for b20020416 processed mdst.
        if (x < 3.2) {
          return_value = 0.83073 + 0.10137 * x
                         - 0.59946e-2 * x * x - 0.56516e-2 * x * x * x + 0.87225e-3 * x * x * x * x;
        }
 
        break;
      case 17:
        // Proper curve for b20020416 processed mdst.
        if (x < 3.0) {
          return_value = 0.89260 + 0.54731e-1 * x
                         - 0.25736e-2 * x * x - 0.16493e-2 * x * x * x + 0.1032e-3 * x * x * x * x;
        } else if (x < 3.5) {
          return_value = 0.997459 + 0.0059039 * (x - 3.0);
        }
        break;
      case 19:
        // Correction curve obtained by Run001-299 HadronB
        // processed by b20020416.
        if (Run < 300) {
          if (x < 3.0) {
            return_value = 0.86432 + 0.87554e-1 * x
                           - 0.84182e-2 * x * x - 0.39880e-2 * x * x * x + 0.69435e-3 * x * x * x * x;
          }
        }
        if (299 < Run && Run < 900) { // For Run300-899 or later by b20020416.
          if (x < 2.9) {
            return_value = 0.92082 + 0.45896e-1 * x
                           - 0.68067e-2 * x * x + 0.94055e-3 * x * x * x - 0.27717e-3 * x * x * x * x;
          }
        }
        if (899 < Run) { // Till the end.
          if (x < 3.1) {
            return_value = 0.85154 + 0.97812e-1 * x
                           - 0.85774e-2 * x * x - 0.59092e-2 * x * x * x + 0.1121e-2 * x * x * x * x;
          }
        }
        break;
      case 21:
        // Proper curve for b20021205 processed mdst.
        if (x < 3.0) {
          return_value = 0.84940 + 0.86266e-1 * x
                         - 0.82204e-2 * x * x - 0.12912e-2 * x * x * x;
        }
        break;
      case 23:
        // Proper curve for b20021205 processed mdst.
        if (x < 3.1) {
          return_value = 0.85049 + 0.85418e-1 * x
                         - 0.45747e-2 * x * x - 0.40081e-2 * x * x * x + 0.52113e-3 * x * x * x * x;
        }
        break;
      case 25:
        if (x < 3.0) {
          return_value = 0.87001 + 0.73693e-1 * x
                         - 0.80094e-2 * x * x - 0.78527e-3 * x * x * x + 0.25888e-4 * x * x * x * x;
        }
        break;
      case 27: // It turned out no signif. change through all the runs.
        if (x < 2.85) {
          return_value = 0.90051 + 0.56094e-1 * x
                         - 0.14842e-1 * x * x + 0.55555e-2 * x * x * x - 0.10378e-2 * x * x * x * x;
        }
        break;
      case 31:
        if (iflag05th == 1) { // For 0.5MeV threshold.
          // For b20040429.
          if (x < 2.95) {
            return_value = 0.80295 + 0.13395 * x
                           - 0.10773e-1 * x * x - 0.85861e-2 * x * x * x + 0.15331e-2 * x * x * x * x;
          }
        } else { // For theta-dep. threshold.
          if (x < 3.25) {
            return_value = 0.57169 + 0.32548 * x
                           - 0.41157e-1 * x * x - 0.21971e-1 * x * x * x + 0.50114e-2 * x * x * x * x;
          }
        }
        break;
      case 33:
        if (iflag05th == 1) { // For 0.5MeV threshold.
          // For b20040429.
          if (x < 2.64) {
            return_value = 0.81153 + 0.10847 * x
                           - 0.24652e-2 * x * x - 0.54738e-2 * x * x * x + 0.41243e-3 * x * x * x * x;
          }
        } else { // For theta-dep. threshold, b20090127.
          if (x < 3.15) {
            return_value = 0.59869 + 0.29276 * x
                           - 0.15849e-1 * x * x - 0.31322e-1 * x * x * x + 0.62491e-2 * x * x * x * x;
          }
        }
        break;
      case 35:
        if (iflag05th == 1) { // For 0.5MeV threshold.
          // For b20040429.
          if (x < 2.54) {
            return_value = 0.83528 + 0.10402 * x
                           - 0.62047e-2 * x * x - 0.62411e-2 * x * x * x + 0.10312e-2 * x * x * x * x;
          }
        } else { // For theta-dep. threshold, b20090127.
          if (x < 3.2) {
            return_value =  0.58155 + 0.30642 * x
                            - 0.16981e-1 * x * x - 0.32609e-1 * x * x * x + 0.64874e-2 * x * x * x * x;
          }
        }
        break;
      case 37:
        if (iflag05th == 1) { // For 0.5MeV threshold.
          if (x < 2.5) {
            return_value = 0.83706 + 0.10726 * x
                           - 0.62423e-2 * x * x - 0.42425e-2 * x * x * x;
          }
        } else { // For theta-dep. threshold.
          if (x < 3.15) {
            return_value =  0.58801 + 0.30569 * x
                            - 0.18832e-1 * x * x - 0.32116e-1 * x * x * x + 0.64899e-2 * x * x * x * x;
          }
        }
        break;
      case 39:
        if (iflag05th == 1) { // For 0.5MeV threshold.
          if (x < 3.0) {
            if (x < 2.8) {
              return_value = 0.80827 + 0.095353 * x
                             - 0.14818e-2 * x * x - 0.23854e-2 * x * x * x - 0.22454e-3 * x * x * x * x;
            } else {
              return_value = 0.0112468 * (x - 2.8) + 0.997847;
            }
          }
        } else { // For theta-dep. threshold.
          if (x < 3.25) {
            return_value = 0.61133 + 0.27115 * x
                           - 0.12724e-1 * x * x - 0.28167e-1 * x * x * x + 0.54699e-2 * x * x * x * x;
          }
        }
        break;
      case 41:
        if (iflag05th == 1) { // For 0.5MeV threshold.
          if (Run < 800) {
            if (x < 2.5) {
              return_value = 0.90188 + 0.76563e-1 * x
                             - 0.16328e-1 * x * x + 0.56816e-3 * x * x * x;
            }
          }
          if (799 < Run) { // Run1200-1261 no signif. change from Run800-1199.
            if (x < 2.95) {
              return_value = 0.88077 + 0.71720e-1 * x
                             - 0.92197e-2 * x * x - 0.15932e-2 * x * x * x + 0.38133e-3 * x * x * x * x;
            }
          }
        } else { // For theta-dep. threshold.
          if (x < 3.2) {
            return_value =  0.57808 + 0.31083 * x
                            - 0.20247e-1 * x * x - 0.31658e-1 * x * x * x + 0.64087e-2 * x * x * x * x;
          }
        }
        break;
      case 43: // modified 20090829.
        if (iflag05th == 1) { // For 0.5MeV threshold.
          if (Run < 300) {
            if (x < 3.3) {
              return_value = 0.85592 + 0.93352e-1 * x
                             - 0.93144e-2 * x * x - 0.43681e-2 * x * x * x + 0.7971e-3 * x * x * x * x;
            }
          }
          if (299 < Run && Run < 700) { // added 20050630.
            if (x < 3.0) {
              return_value = 0.89169 + 0.73301e-1 * x
                             - 0.13856e-1 * x * x + 0.47303e-3 * x * x * x;
            }
          }
          if (699 < Run) { // added 20050727
            if (x < 3.1) {
              return_value = 0.90799 + 0.69815e-1 * x
                             - 0.17490e-1 * x * x + 0.14651e-2 * x * x * x;
            }
          }
        } else { // For theta-dep. threshold b20090127.
          if (x < 3.25) {
            return_value = 0.58176 + 0.30245 * x - 0.16390e-1 * x * x
                           - 0.32258e-1 * x * x * x + 0.64121e-2 * x * x * x * x;
          }
          //if( 999 < Run ){// For 5S runs, 2/fb, obsolete 20091209.
          //if( x < 3.3 ){
          //return_value = 0.58463 + 0.29780*x -0.14441e-1*x*x
          //-0.32323e-1*x*x*x + 0.63607e-2*x*x*x*x;
          //}
          //}
        }
        break;
      case 45:
        if (iflag05th == 1) { // For 0.5MeV threshold.
          if (x < 3.1) { // added 20060413
            return_value = 0.84823 + 0.10394 * x
                           - 0.92233e-2 * x * x - 0.72700e-2 * x * x * x + 0.14552e-2 * x * x * x * x;
          }
        } else { // For theta-dep. threshold b20090127.
          if (x < 3.25) {
            return_value = 0.62797 + 0.23897 * x
                           + 0.10261e-1 * x * x - 0.35700e-1 * x * x * x + 0.63846e-2 * x * x * x * x;
          }
        }
        break;
      case 47:
        if (iflag05th == 1) { // For 0.5MeV threshold.
          if (x < 3.1) { // added 20060420
            return_value = 0.86321 + 0.82987e-1 * x
                           - 0.12139e-1 * x * x - 0.12920e-3 * x * x * x;
          }
        } else { // For theta-dep. threshold b20090127.
          if (x < 3.25) {
            return_value = 0.58061 + 0.30399 * x
                           - 0.17520e-1 * x * x - 0.31559e-1 * x * x * x + 0.62681e-2 * x * x * x * x;
          }
        }
        break;
      case 49:
        if (iflag05th == 1) { // For 0.5MeV threshold.
          if (x < 3.13) { // added 20060511
            if (x < 2.80) {
              return_value = 0.85616 + 0.78041e-1 * x
                             - 0.38987e-2 * x * x - 0.31224e-2 * x * x * x + 0.33374e-3 * x * x * x * x;
            } else {
              return_value = ((1.0 - 0.99608) / (3.13 - 2.80)) * (x - 2.80) + 0.99608;
            }
          }
        } else { // For theta-dep. threshold b20090127.
          if (x < 3.3) {
            return_value = 0.57687 + 0.29948 * x
                           - 0.10594e-1 * x * x - 0.34561e-1 * x * x * x + 0.67064e-2 * x * x * x * x;
          }
        }
        break;
      case 51:
        if (iflag05th == 1) { // For 0.5MeV threshold, added 20070323.
          if (x < 3.07) {
            return_value = 0.89063 + 0.72152e-1 * x
                           - 0.14143e-1 * x * x + 0.73116e-3 * x * x * x;
          }
        } else { // For theta-dep. threshold b20090127.
          if (x < 3.3) {
            return_value = 0.59310 + 0.28618 * x
                           - 0.13858e-1 * x * x - 0.30230e-1 * x * x * x + 0.59173e-2 * x * x * x * x;
          }
        }
        break;
      case 53: // modified 20090807.
        if (iflag05th == 1) { // For 0.5MeV threshold.
          if (x < 2.63) {
            //std::cout<<"Exp.53 0.5MeV threshold."<<std::endl;
            return_value = 0.83425 + 0.10468 * x
                           - 0.53641e-2 * x * x - 0.60276e-2 * x * x * x + 0.77763e-3 * x * x * x * x;
          }
        } else { // For theta-dep. threshold b20090127.
          if (x < 3.1) {
            //std::cout<<"Exp.53 theta-dep. threshold."<<std::endl;
            return_value = 0.66100 + 0.25192 * x
                           - 0.16419e-1 * x * x - 0.25720e-1 * x * x * x + 0.52189e-2 * x * x * x * x;
          }
        }
        break;
      case 55:
        if (iflag05th == 1) { // For 0.5MeV threshold.
          if (x < 3.3) {
            return_value = 0.86202 + 0.79575e-1 * x
                           - 0.66721e-2 * x * x - 0.28609e-2 * x * x * x + 0.42784e-3 * x * x * x * x;
          }
        } else { // For theta-dep. threshold b20090127.
          if (x < 3.25) {
            return_value = 0.58789 + 0.29310 * x
                           - 0.15784e-1 * x * x - 0.30619e-1 * x * x * x + 0.60648e-2 * x * x * x * x;
          }
        }
        break;
      case 61:
        if (Run < 1210) { // On 4S by Th.-dep. threshold.
          if (x < 3.5) {
            return_value = 0.68839 + 0.18218 * x
                           - 0.23140e-2 * x * x - 0.17439e-1 * x * x * x + 0.29960e-2 * x * x * x * x;
          }
        }
        if (Run > 1209) { // 5S scan.
          if (iflag05th == 1) { // processed by 0.5MeV threshold.
            if (x < 3.3) {
              if (x < 2.8) {
                return_value = 0.94294 - 0.77497e-2 * x
                               - 0.43464e-3 * x * x + 0.99837e-2 * x * x * x - 0.23726e-2 * x * x * x * x;
              } else {
                return_value = 0.0162997 * (x - 2.80) + 0.991162;
              }
            }
          } else { // 5S scan. by Th.-dep. threshold.
            if (x < 3.5) {
              return_value = 0.64816 + 0.22492 * x
                             - 0.91745e-2 * x * x - 0.21736e-1 * x * x * x + 0.41333e-2 * x * x * x * x;
            }
          }
        }
        break;
      case 63:
        if (x < 3.4) {
          return_value = 0.69302 + 0.18393 * x
                         - 0.10983e-1 * x * x - 0.14148e-1 * x * x * x + 0.27298e-2 * x * x * x * x;
        }
        break;
      case 65:
        if (Run > 1000) { // 1S run turned out to be same as 5S scan.
          if (iflag05th == 1) { // For 0.5MeV threshold.
            if (x < 3.3) {
              if (x < 2.8) {
                return_value = 0.94294 - 0.77497e-2 * x
                               - 0.43464e-3 * x * x + 0.99837e-2 * x * x * x - 0.23726e-2 * x * x * x * x;
              } else {
                return_value = 0.0162997 * (x - 2.80) + 0.991162;
              }
            }
          } else { // For theta-dep. threshold, b20090127.
            if (x < 3.6) {
              return_value = 0.70987 + 0.16230 * x
                             - 0.64867e-2 * x * x - 0.12021e-1 * x * x * x + 0.20874e-2 * x * x * x * x;
            }
          }
        } else { // 4S runs processed with new lib.
          if (x < 3.4) {
            return_value = 0.66833 + 0.20602 * x
                           - 0.14322e-1 * x * x - 0.15712e-1 * x * x * x + 0.31114e-2 * x * x * x * x;
          }
        }
        break;
      case 67:
        if (x < 3.4) {
          return_value = 0.64196 + 0.23069 * x
                         - 0.20303e-1 * x * x - 0.15680e-1 * x * x * x + 0.31611e-2 * x * x * x * x;
        }
        break;
      case 69:
        if (x < 3.35) {
          //return_value = 0.64196 + 0.23752*x
          //-0.85197e-2*x*x -0.24366e-1*x*x*x +0.46397e-2*x*x*x*x;
          return_value = 0.99 * (0.64196 + 0.23752 * x
                                 - 0.85197e-2 * x * x - 0.24366e-1 * x * x * x
                                 + 0.46397e-2 * x * x * x * x);
        }
        break;
      case 71:
        if (x < 3.35) {
          return_value = 0.66541 + 0.12579 * x
                         + 0.89999e-1 * x * x - 0.58305e-1 * x * x * x + 0.86969e-2 * x * x * x * x;
        }
        break;
      case 73:
        if (x < 3.45) {
          return_value = 0.62368 + 0.24142 * x
                         - 0.11677e-1 * x * x - 0.22477e-1 * x * x * x + 0.42765e-2 * x * x * x * x;
        }
        break;
    }
    // This return value has to be used as division.
    // i.e. E_corrected = E_original/return_vale.
    return return_value;
  }

ecl_adhoc_corr_45()

static double ecl_adhoc_corr_45 ( int  exp, int  , int  cid  )

static

The function giving correction factor in Exp.45.

Definition at line 598 of file B2BIIFixMdstModule_ecl.cc.

  {
 
    const int bcid[] = {
      243, 244, 316, 317, 318, 412, 413, 414, 508, 509, 510, 604, 605, 606
    };
 
    const double bcfact[] = {
      1.06215, 1.06589, 0.953827, 1.06607, 0.943696, 0.910855, 1.01201,
      1.01704, 0.954612, 1.02761, 1.00716, 1.0319, 1.03135, 1.05782
    };
 
    if (exp != 45) return 1.;
 
    for (int i = 0 ; i < 14 ; i++)
      if (bcid[i] == cid)
        return bcfact[i];
 
    return 1.;
  }

ecl_mcx3_corr()

static double ecl_mcx3_corr ( int  , int  , double  energy, double    )

static

Correct energy scale (MC) to make pi0 peak nominal.

Definition at line 623 of file B2BIIFixMdstModule_ecl.cc.

  {
    //KM std::cout<<"ecl_mcx3_corr called."<<std::endl;
    double return_value;
    double x = std::log10(energy * 1000.0);
    return_value = 1.0;
    if (x < 3.2) {
      return_value = 0.72708 + 0.22735 * x
                     - 0.20603e-1 * x * x - 0.24644e-1 * x * x * x + 0.53480e-2 * x * x * x * x;
    }
    //std::cout<<"energy="<<energy<<" ecl_mcx3="<<return_value<<std::endl;
    return return_value;
  }

event()

void event ( )

overridevirtual

Called for each event.

Reimplemented from Module.

Definition at line 235 of file B2BIIFixMdstModule.cc.

  {
    int result;
 
    if (!m_eventExtraInfo.isValid())
      m_eventExtraInfo.create();
 
    if ((BsCouTab(BELLE_EVENT) == 0) || (BsCouTab(MDST_EVENT_ADD) == 0)) {
      B2INFO("Warning from B2BIIFixMdst: No Belle_event or Mdst_event_add table; no correction for event");
      if (m_saveResultExtraInfo)
        m_eventExtraInfo->addExtraInfo("FixMdstResult", -1);
      setReturnValue(-1);
      return;
    }
 
    if (m_add_or_remove_extra_trk_vee2 == 1) {
      add_extra_trk_vee2();
    } else if (m_add_or_remove_extra_trk_vee2 == -1) {
      remove_extra_trk_vee2();
    }
 
    if (m_scale_momenta == 1) scale_momenta(m_scale_momenta_scale_data,
                                              m_scale_momenta_scale_mc,
                                              m_scale_momenta_mode);
 
    if (m_scale_error == 1) scale_error();
 
    if (m_smear_trk != 0) smear_trk();
 
    if (m_correct_ecl == 1) correct_ecl(m_correct_ecl_option, m_correct_ecl_version);
 
    HepPoint3D pv;
    CLHEP::HepSymMatrix dpv(3, 0);
    int err(1);
    if (m_correct_ecl_primary_vertex == 1) {
      err = set_primary_vertex(pv, dpv);
      if (err == 0)correct_ecl_primary_vertex(pv, dpv);
    }
 
    if (m_make_pi0 == 1 || m_make_pi0_primary_vertex == 1) {
      if (m_make_pi0_primary_vertex == 1 && err == 0) {
        make_pi0_primary_vertex(m_make_pi0_option, m_make_pi0_lower_limit, m_make_pi0_upper_limit, pv, dpv);
      } else {
        make_pi0(m_make_pi0_option, m_make_pi0_lower_limit, m_make_pi0_upper_limit);
      }
      fix_pi0_brecon();
    }
 
    if (m_benergy == 1) s_benergy_value = Benergy();
 
    if (m_good_event == 1) {
      if (good_event()) {
        result = 1;
      } else {
        if (m_saveResultExtraInfo)
          m_eventExtraInfo->addExtraInfo("FixMdstResult", -1);
        setReturnValue(-1);
        B2DEBUG(99, "B2BIIFixMdst: Not a good event");
        return;
      }
    } else {
      result = 0;
    }
 
    if (m_l4passed_only == 1) {
      if (BsCouTab(L4_SUMMARY)) {
        struct l4_summary* l =
          (struct l4_summary*) BsGetEnt(L4_SUMMARY, 1, BBS_No_Index);
        if (l->m_type == 0) {
          if (m_saveResultExtraInfo)
            m_eventExtraInfo->addExtraInfo("FixMdstResult", -1);
          setReturnValue(-1);
          B2DEBUG(99, "B2BIIFixMdst: L4 cut");
          return;
        }
      }
    }
 
    if (m_hadron_a_only == 1) {
      Belle::Evtcls_flag_Manager&   EvtFlagMgr  = Belle::Evtcls_flag_Manager::get_manager();
      Belle::Evtcls_flag_Manager::iterator  it1 = EvtFlagMgr.begin();
      if (it1 != EvtFlagMgr.end() && *it1) {
        if ((*it1).flag(0) < 10) {
          if (m_saveResultExtraInfo)
            m_eventExtraInfo->addExtraInfo("FixMdstResult", -1);
          setReturnValue(-1);
          B2DEBUG(99, "B2BIIFixMdst: HadA cut");
          return;
        }
      }
    }
 
    if (m_hadron_b_only == 1) {
      Belle::Evtcls_hadronic_flag_Manager& HadMgr
        = Belle::Evtcls_hadronic_flag_Manager::get_manager();
      Belle::Evtcls_hadronic_flag_Manager::iterator ith = HadMgr.begin();
      if (ith != HadMgr.end() && *ith) {
        if ((*ith).hadronic_flag(2) <= 0) {
          if (m_saveResultExtraInfo)
            m_eventExtraInfo->addExtraInfo("FixMdstResult", -1);
          setReturnValue(-1);
          B2DEBUG(99, "B2BIIFixMdst: HadB cut");
          return;
        }
      }
    }
 
    if (m_table_size == 1) {
      Belle::Belle_event_Manager& bevt = Belle::Belle_event_Manager::get_manager();
      //    if( bevt[0].ExpNo() >=39 ) {
      if ((m_reprocess_version == 0 && bevt.count() > 0 && bevt[0].ExpNo() >= 39) ||
          (m_reprocess_version >= 1)) {
        if (Belle::Mdst_ecl_trk_Manager::get_manager().count() > m_limit_mdst_ecl_trk) {
          if (m_saveResultExtraInfo)
            m_eventExtraInfo->addExtraInfo("FixMdstResult", -1);
          setReturnValue(-1);
          B2INFO("B2BIIFixMdst: " <<  Belle::Mdst_ecl_trk_Manager::get_manager().count() << " " << m_limit_mdst_ecl_trk);
          return;
        }
        if (Belle::Mdst_klm_cluster_hit_Manager::get_manager().count()
            > m_limit_mdst_klm_cluster_hit) {
          if (m_saveResultExtraInfo)
            m_eventExtraInfo->addExtraInfo("FixMdstResult", -1);
          setReturnValue(-1);
          B2INFO("B2BIIFixMdst: " <<  Belle::Mdst_klm_cluster_hit_Manager::get_manager().count() << " " << m_limit_mdst_klm_cluster_hit);
          return;
        }
      }
    }
 
    if (m_calib_dedx != 0) {
      Belle::Belle_event_Manager& bevt = Belle::Belle_event_Manager::get_manager();
      if (bevt[0].ExpMC() == 1 || m_reprocess_version == 0 || m_calib_dedx == -1) Belle::Calib_dEdx();
    }
 
    if (m_shift_tof_mode > 0) shift_tof(m_shift_tof_mode);
 
    if (m_mapped_expno > 0) Muid_event();
 
    if (m_saveResultExtraInfo)
      m_eventExtraInfo->addExtraInfo("FixMdstResult", result);
    setReturnValue(result);
  }

fix_pi0_brecon()

void fix_pi0_brecon ( void  )

private

Fix relation gamma<->pi0 in brecon table.

Definition at line 36 of file B2BIIFixMdstModule_brecon.cc.

  {
    Belle::Brecon_Manager& breconmgr = Belle::Brecon_Manager::get_manager();
    if (!breconmgr.count()) return;
    Belle::Mdst_pi0_Manager& pi0mgr = Belle::Mdst_pi0_Manager::get_manager();
 
    for (std::vector<Belle::Brecon>::iterator it = breconmgr.begin();
         it != breconmgr.end(); ++it) {
 
      // select the table of pi0->gamma gamma
      if (std::abs((*it).pcode()) != 111) continue;
      const int da_first((*it).daFirst());
      const int da_last((*it).daLast());
      if (da_first < 1 || da_last < 1) continue;
      if (da_last - da_first != 1) continue;
      const Belle::Brecon& gamma1(breconmgr[da_first - 1]);
      const Belle::Brecon& gamma2(breconmgr[da_last - 1]);
      if (gamma1.stable() != 2 || gamma2.stable() != 2) continue;
 
      // find corresponding Mdst_pi0
      int pi0_ID(-1);
      const Belle::Panther_ID g1(gamma1.idmdst());
      const Belle::Panther_ID g2(gamma2.idmdst());
      for (std::vector<Belle::Mdst_pi0>::const_iterator it2 = pi0mgr.begin();
           it2 != pi0mgr.end(); ++it2) {
        const Belle::Panther_ID da1((*it2).gamma_ID(0));
        const Belle::Panther_ID da2((*it2).gamma_ID(1));
        if ((g1 == da1 && g2 == da2) || (g1 == da2 && g2 == da1)) {
          pi0_ID = (int)(*it2).get_ID();
          break;
        }
      }
 
      // modify brecon table
      switch (pi0_ID) {
        case -1: // corresponding Mdst_pi0 is not found after make_pi0
          (*it).stable(0);
          (*it).idmdst(0);
          break;
        default:
          (*it).stable(4);
          (*it).idmdst(pi0_ID);
          break;
      }
    }
  }

get_event_id()

static void get_event_id ( int *  no_exp, int *  no_run, int *  no_evt, int *  no_frm, int *  expmc  )

static

Get event ID.

Definition at line 1469 of file B2BIIFixMdstModule_trk.cc.

  {
    *no_exp = -1, *no_run = -1, *no_evt = -1, *no_frm = -1;
 
    belle_event* belle_event;
    belle_event = (struct belle_event*)BsGetEnt(BELLE_EVENT, 1, BBS_No_Index);
    if (belle_event) {
      *no_exp = belle_event->m_ExpNo;
      *no_run = belle_event->m_RunNo;
      *no_evt = belle_event->m_EvtNo & 0x0fffffff;
      *no_frm = (unsigned int)belle_event->m_EvtNo >> 28;
      *expmc  = belle_event->m_ExpMC;
    }
  }

get_reprocess_version()

int get_reprocess_version ( )

private

Get reprocess version of input mdst.

Definition at line 422 of file B2BIIFixMdstModule.cc.

  {
 
    int version(0);
    Belle::Belle_version_Manager& bvmgr = Belle::Belle_version_Manager::get_manager();
 
    if (m_reprocess_version_specified >= 0) {
      //*** version set forcedly ***
      version = m_reprocess_version_specified;
      B2INFO("reprocess version forcedly set to " << version);
 
    } else {
      //*** version set based on info. in run-header ***
      Belle::Belle_processing_Manager& bpmgr = Belle::Belle_processing_Manager::get_manager();
      Belle::Belle_runhead_Manager& evtmgr = Belle::Belle_runhead_Manager::get_manager();
      Belle::Belle_runhead_Manager::const_iterator belleevt = evtmgr.begin();
 
      int expmc(0), exp(0), run(0);
      if (belleevt != evtmgr.end() && (*belleevt)) {
        expmc = belleevt->ExpMC();
        exp = belleevt->ExpNo();
        run = belleevt->RunNo();
      }
 
      int B_l_d = 0;
      //int Date  = 0;
      if (bpmgr.count() > 0) {
        int i = bpmgr.count() - 1;
        B_l_d = bpmgr[i].Belle_level_date();
        //Date  = bpmgr[i].Date();
      }
 
      if (bvmgr.count() > 0) {
        //Belle::Belle_version is in run-header: MC or (DATA with level > 20081107)
        //      int j = bvmgr.count() - 1;
        int j = 0;
        int chk = std::abs(bvmgr[j].SVD())
                  + std::abs(bvmgr[j].CDC())
                  + std::abs(bvmgr[j].ECL());
        if (chk == 0) {
          version = 0;
        } else {
          version = 1;
        }
      } else {
        //no Belle::Belle_version in run-header: DATA with level <= 20081107
        if (expmc == 2 || (expmc == 1
                           && B_l_d > 20081107))
          B2ERROR("No Belle::Belle_version table in run-header for MC or (Data processed with Belle_level > 20081107). Strange !");
 
        if (B_l_d == 20081107) {
          version = 1;
          //exception: U(1S) run w/old tracking & old ECL
          //    if( exp==65 && run >= 1000 && Date <= 20081130 ) version = 0;
          if (exp == 65 && run >= 1000) version = 0;
        } else {
          version = 0;
        }
      }
    }
 
    if (bvmgr.count() == 0) {
      Belle::Belle_version& bv = bvmgr.add();
      bv.SVD(version);
      bv.CDC(version);
      bv.ECL(version);
    } else if (bvmgr.count() > 0) {
      if (bvmgr[0].SVD() != version) {
        B2WARNING("Belle::Belle_version_SVD(=" << bvmgr[0].SVD() << ") is inconsistent with version(=" << version <<
                  "); replace it anyway");
        bvmgr[0].SVD(version);
      }
      if (bvmgr[0].CDC() != version) {
        B2WARNING("Belle::Belle_version_CDC(=" << bvmgr[0].CDC() << ") is inconsistent with version(=" << version <<
                  "); replace it anyway");
        bvmgr[0].CDC(version);
      }
      if (bvmgr[0].ECL() != version) {
        B2WARNING("Belle::Belle_version_ECL(=" << bvmgr[0].ECL() << ") is inconsistent with version(=" << version <<
                  "); replace it anyway");
        bvmgr[0].ECL(version);
      }
    }
 
    return version;
  }

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    )

static

Get scale error fucntion for different Exp.

Definition at line 2624 of file B2BIIFixMdstModule_trk.cc.

  {
    return
      (7 <= no_exp && no_exp <= 23) ? EXP0723_scale :
      (25 <= no_exp && no_exp <= 27) ? EXP2527_scale :
      (31 == no_exp)               ? EXP31_scale   :
      (33 == no_exp)               ? EXP33_scale   :
      (35 == no_exp)               ? EXP35_scale   :
      (37 == no_exp)               ? EXP37_scale   :
      (39 == no_exp || 41 == no_exp) ? EXP3941_scale :
      (43 == no_exp)               ? EXP43_scale   :
      (45 == no_exp)               ? EXP45_scale   :
      (47 == no_exp)               ? EXP47_scale   :
      (49 == no_exp)               ? EXP49_scale   :
      (51 == no_exp)               ? EXP51_scale   :
      (53 == no_exp)               ? EXP53_scale   :
      (55 == no_exp)               ? EXP55_scale   :
      (61 <= no_exp && no_exp <= 65) ? EXP6165_scale :
      (67 == no_exp)               ? EXP67_scale   :
      // ( 69==no_exp || 71==no_exp ) ? EXP6971_scale : DUMMY_scale;
      (69 <= no_exp && 73 >= no_exp) ? EXP6971_scale : DUMMY_scale;
  }

good_event()

bool good_event ( )

private

Check if event correspondes to the period when Belle detector not in good condition.

Definition at line 509 of file B2BIIFixMdstModule.cc.

  {
 
    bool ret = true;
 
    Belle::Mdst_quality_Manager& qmgr = Belle::Mdst_quality_Manager::get_manager();
    if (0 == qmgr.count()) return ret; //do nothing if not exist
 
    for (std::vector<Belle::Mdst_quality>::iterator it = qmgr.begin();
         it != qmgr.end(); ++it) {
      Belle::Mdst_quality& q = *it;
      std::string c(q.name()());
      //    if((strcmp(c,"SVD ")==0) && (q.quality() & 0x02)) ret = false;
      //also to remove exp9 bad svd events
      if ((strcmp(c.c_str(), "SVD ") == 0) && (q.quality() & 0x8002)) ret = false;
    }
    return ret;
  }

initialize() [1/2]

void initialize ( )

overridevirtual

Initialize phanter banks.

Reimplemented from Module.

Definition at line 84 of file B2BIIConvertBeamParamsModule.cc.

  {
    BsInit(0);
    m_event.isRequired();
  }

initialize() [2/2]

void initialize ( )

overridevirtual

Initialize the module.

Reimplemented from Module.

Definition at line 223 of file B2BIIFixMdstModule.cc.

  {
    Muid_init();
    if (m_saveResultExtraInfo)
      m_eventExtraInfo.registerInDataStore();
  }

is_already_scaled()

static bool is_already_scaled ( void  )

static

Check if event is already scaled.

Definition at line 1486 of file B2BIIFixMdstModule_trk.cc.

  {
    Belle::Mdst_event_add_Manager& addmgr = Belle::Mdst_event_add_Manager::get_manager();
    if (addmgr.count() >= 1) {
 
      if (addmgr[0].flag_error() == 1) {
        if (SE_Message_Level >= 1) B2ERROR("scale_error: already applied");
        return true;
      } else {
        if (SE_Message_Level >= 2) B2ERROR("scale_error: to be applied");
        addmgr[0].flag_error(1);
        return false;
      }
 
    } else {
 
      static int first = 1;
      B2ERROR("scale_error: no Mdst_event_add");
      if (first) {
        B2ERROR("scale_error: analysis continues");
        B2ERROR("scale_error: scale_error will not be applied");
        first = 0;
      }
      return true;
    }
  }

lambdafunc()

double lambdafunc ( const double  x, const double  x1, const double  x2, const double  yc, const double  a1, const double  a2, const double  a3  )

inline

lambdafunc

Definition at line 1541 of file B2BIIFixMdstModule_trk.cc.

  {
    return x < x1 ? (x - x1) * a1 + yc :
           x < x2 ? (x - x1) * a2 + yc : (x - x2) * a3 + (x2 - x1) * a2 + yc;
  }

make_pi0()

void make_pi0 ( int  option, double  low_limit, double  up_limit  )

private

Create Mdst_pi0 from Mdst_gamma and Mdst_ecl to let people get mass-constraint fitted momentum of pi0 after ad_hoc correction.

Definition at line 1569 of file B2BIIFixMdstModule_ecl.cc.

  {
    //---------------------
    // Check Exp. number and Data/MC.
    //---------------------
    Belle::Belle_event_Manager& evtmgr = Belle::Belle_event_Manager::get_manager();
    if (0 == evtmgr.count()) {
      // Do nothing if not exist, because we can not know whether
      // this event is Exp. data or MC.
      return;
    }
    //Check data or mc. Data:expmc=1, MC:expmc=2.
    int expmc = evtmgr[0].ExpMC();
    // Check Exp. number.
    int Eno = evtmgr[0].ExpNo();
    // Set mcdata frag to be compatible with pi0resol func.
    bool mcdata = 0;
    if (expmc == 2) {
      mcdata = 1;
    }
 
    // pi0 mass of PDG.
    const double mpi0_pdg = 0.1349739;
 
    // Default mass window.
    // const double low_default = 0.1178;
    // const double up_default  = 0.1502;
    const double low_default = 0.080;  // modified 20040606
    const double up_default  = 0.180;  // modified 20040606
 
    // Maximum iteration of fit.
    const int iter_max = 5;
 
    // Check whether proper option and mass window are given.
    switch (option) {
      case 0:    // option=0 case, set default mass window.
        low_limit = low_default;
        up_limit = up_default;
        break;
      case 1:   // option=1 case, check given mass window.
        if (mpi0_pdg < low_limit || up_limit < mpi0_pdg) {
          // If mass window is not correct, do nothing.
          B2ERROR("Invalid mass window between ");
          B2ERROR(" and " << up_limit);
          return;
        }
        break;
      case 2: // pi0 cand. are selected by -Xsigma < Mgg-Mpi0 < +Xsigma.
        // dout(Debugout::DDEBUG,"B2BIIFixBelle::Mdst_ecl") << "option=2 was selected." << std::endl;
        //dbg dout(Debugout::INFO,"B2BIIFixBelle::Mdst_ecl") << "mass window is " << low_limit << " & ";
        //dbg dout(Debugout::INFO,"B2BIIFixBelle::Mdst_ecl") << up_limit << std::endl;
        if (0.0 < low_limit || up_limit < 0.0) {
          B2ERROR("option=2 was selected. ");
          B2ERROR("Invalid mass window! " << low_limit);
          B2ERROR(" should be negative, and " << up_limit);
          B2ERROR(" should be positive.");
          return;
        }
        break;
      default: // Otherwise, invalid option, do nothing.
        B2ERROR("Invalid option=" << option);
        return;
    }
 
    // At first, clear already existing Belle::Mdst_pi0.
    Belle::Mdst_pi0_Manager::get_manager().remove();
 
    // Get Belle::Mdst_gamma for photon's momentum
    // and get Belle::Mdst_ecl for error matrix.
    Belle::Mdst_gamma_Manager& gammamgr = Belle::Mdst_gamma_Manager::get_manager();
 
    // Re-allocate Belle::Mdst_pi0 table.
    Belle::Mdst_pi0_Manager& pi0mgr = Belle::Mdst_pi0_Manager::get_manager();
 
    // If Only one photon in the event, no need to do anything.
    if (gammamgr.count() < 2) {
      return;
    }
 
    // Make combination of two Belle::Mdst_gamma.
    for (std::vector<Belle::Mdst_gamma>::iterator itgamma = gammamgr.begin();
         itgamma != gammamgr.end(); ++itgamma) {
      Belle::Mdst_gamma& gamma1 = *itgamma;
      CLHEP::Hep3Vector gamma1_3v(gamma1.px(), gamma1.py(), gamma1.pz());
      CLHEP::HepLorentzVector gamma1_lv(gamma1_3v, gamma1_3v.mag());
 
      Belle::Mdst_ecl& ecl1 = gamma1.ecl();
 
      for (std::vector<Belle::Mdst_gamma>::iterator jtgamma = itgamma + 1;
           jtgamma != gammamgr.end(); ++jtgamma) {
        Belle::Mdst_gamma& gamma2 = *jtgamma;
        CLHEP::Hep3Vector gamma2_3v(gamma2.px(), gamma2.py(), gamma2.pz());
        CLHEP::HepLorentzVector gamma2_lv(gamma2_3v, gamma2_3v.mag());
 
        Belle::Mdst_ecl& ecl2 = gamma2.ecl();
 
        // Invariant mass before const. fit.
        CLHEP::HepLorentzVector gamgam_lv = gamma1_lv + gamma2_lv;
        const double mass_before = gamgam_lv.mag();
 
        // In the case of option=0 or 1, criteria is controlled
        // by the inv. mass.
        double mass_ctrl{0};
        if (option == 0 || option == 1) {
          mass_ctrl = mass_before;
        }
        if (option == 2) {
          // Asymmetric lineshape is taken into account.
          if (mass_before * mpi0pdg(mass_before) < mpi0_pdg) {
            mass_ctrl = (mass_before * mpi0pdg(mass_before) - mpi0_pdg) /
                        pi0resol(gamgam_lv.vect().mag(),
                                 gamgam_lv.theta() * 180. / M_PI, "lower",
                                 mcdata, Eno, option);
          } else {
            mass_ctrl = (mass_before * mpi0pdg(mass_before) - mpi0_pdg) /
                        pi0resol(gamgam_lv.vect().mag(),
                                 gamgam_lv.theta() * 180. / M_PI, "higher",
                                 mcdata, Eno, option);
          }
        }
 
        // If invariant mass is inside the window,
        // if( low_limit < mass_before && mass_before < up_limit ) // old.
        if (low_limit < mass_ctrl && mass_ctrl < up_limit) {
          // dout(Debugout::DDEBUG,"B2BIIFixBelle::Mdst_ecl")<<"mass="<<mass_before;
          // dout(Debugout::DDEBUG,"B2BIIFixBelle::Mdst_ecl")<<" p="<<gamgam_lv.vect().mag()<<" theta=";
          // dout(Debugout::DDEBUG,"B2BIIFixBelle::Mdst_ecl")<<gamgam_lv.theta()<<" mcdata="<<mcdata;
          // dout(Debugout::DDEBUG,"B2BIIFixBelle::Mdst_ecl")<<" higher="<<
          //   pi0resol(gamgam_lv.vect().mag(),
          //    gamgam_lv.theta()*180./M_PI,
          //  "higher",mcdata, Eno, option )<<" or ";
          // dout(Debugout::DDEBUG,"B2BIIFixBelle::Mdst_ecl")<<" lower="<<
          //   pi0resol(gamgam_lv.vect().mag(),
          //    gamgam_lv.theta()*180./M_PI,
          //  "lower",mcdata, Eno, option )<<std::endl;
          // Error matrix(covariant matrix)
          CLHEP::HepMatrix V(6, 6, 0);
 
          V[0][0] = ecl1.error(0);
          V[0][1] = V[1][0] = ecl1.error(1);
          V[1][1] = ecl1.error(2);
          V[0][2] = V[2][0] = ecl1.error(3);
          V[1][2] = V[2][1] = ecl1.error(4);
          V[2][2] = ecl1.error(5);
          V[3][3] = ecl2.error(0);
          V[3][4] = V[4][3] = ecl2.error(1);
          V[4][4] = ecl2.error(2);
          V[3][5] = V[5][3] = ecl2.error(3);
          V[4][5] = V[5][4] = ecl2.error(4);
          V[5][5] = ecl2.error(5);
 
          // Measurements; i.e. initial parameters.
          CLHEP::HepMatrix y0(6, 1);
          y0[0][0] = ecl1.energy();
          y0[1][0] = ecl1.phi();
          y0[2][0] = ecl1.theta();
          y0[3][0] = ecl2.energy();
          y0[4][0] = ecl2.phi();
          y0[5][0] = ecl2.theta();
 
          // Copy them to proper matrix which is given to fit.
          CLHEP::HepMatrix y(y0);
          // Delivative.
          CLHEP::HepMatrix Dy(6, 1, 0);
 
          int iter = 0;
          double f_old = DBL_MAX;
          double chi2_old = DBL_MAX;
          double /*mass_gg,*/ chi2 = DBL_MAX;
          bool exit_flag = false;
 
          // Set parameters to decide whether converged.
          const double Df_limit = 0.1;
          const double Dchi2_limit = 0.1;
          // Do mass constraint fit; iterate until convergence.
          while (1) {
            const double& E1 = y[0][0];
            const double& E2 = y[3][0];
            const double sin_theta1 = std::sin(y[2][0]);
            const double cos_theta1 = std::cos(y[2][0]);
            const double sin_theta2 = std::sin(y[5][0]);
            const double cos_theta2 = std::cos(y[5][0]);
            const double Dphi = y[1][0] - y[4][0];
            const double cos_Dphi = std::cos(Dphi);
            const double sin_Dphi = std::sin(Dphi);
            const double open_angle = sin_theta1 * sin_theta2 * cos_Dphi
                                      + cos_theta1 * cos_theta2;
            const double mass2_gg = 2 * E1 * E2 * (1 - open_angle);
            //mass_gg = (mass2_gg > 0) ? std::sqrt(mass2_gg) : -std::sqrt(-mass2_gg);
 
            // No more iteration. Break to return.
            if (exit_flag || ++iter > iter_max)
              break;
 
            // constraint
            CLHEP::HepMatrix f(1, 1);
            f[0][0] = mass2_gg - (mpi0_pdg * mpi0_pdg);
 
            // dG/dq_i, G = (M_gg - M_pi0) = 0 is the constraint.
            CLHEP::HepMatrix B(1, 6);
            B[0][0] = mass2_gg / E1;
            B[0][1] = 2 * E1 * E2 * sin_theta1 * sin_theta2 * sin_Dphi;
            B[0][2] = 2 * E1 * E2 * (-cos_theta1 * sin_theta2 * cos_Dphi
                                     + sin_theta1 * cos_theta2);
            B[0][3] = mass2_gg / E2;
            B[0][4] = -B[0][1];
            B[0][5] = 2 * E1 * E2 * (-sin_theta1 * cos_theta2 * cos_Dphi
                                     + cos_theta1 * sin_theta2);
 
            const double sigma2_mass2_gg = (B * V * B.T())[0][0];
 
            // Proceed one step to get newer value y.
            Dy = V * B.T() * (B * Dy - f) / sigma2_mass2_gg;
            y = y0 + Dy;
            int ierr;
            chi2 = (Dy.T() * V.inverse(ierr) * Dy)[0][0];
            double Dchi2 = fabs(chi2 - chi2_old);
            chi2_old = chi2;
            double Df = fabs(f[0][0] - f_old);
            f_old = f[0][0];
 
            // When chi-sq. change is small enough and mass is
            if (Dchi2 < Dchi2_limit && Df < Df_limit)
              exit_flag = true;;
 
          }
          // Sort fitted result into proper variables.
          double pi0_E = y[0][0] + y[3][0];
          double pi0_px = y[0][0] * std::cos(y[1][0]) * std::sin(y[2][0])
                          + y[3][0] * std::cos(y[4][0]) * std::sin(y[5][0]);
          double pi0_py = y[0][0] * std::sin(y[1][0]) * std::sin(y[2][0])
                          + y[3][0] * std::sin(y[4][0]) * std::sin(y[5][0]);
          double pi0_pz = y[0][0] * std::cos(y[2][0]) + y[3][0] * std::cos(y[5][0]);
          double pi0_mass = mass_before;
 
          //  m_chi2 = chi2;  // protect...
          double pi0_chi2 = (chi2 > FLT_MAX) ? FLT_MAX : chi2;
 
          // Fill Belle::Mdst_pi0 based on the fit result.
          Belle::Mdst_pi0& pi0 = pi0mgr.add();
          pi0.gamma(0, gamma1);
          pi0.gamma(1, gamma2);
          pi0.px(pi0_px);
          pi0.py(pi0_py);
          pi0.pz(pi0_pz);
          pi0.energy(pi0_E);
          pi0.mass(pi0_mass);
          pi0.chisq(pi0_chi2);
        }
      }
    }
  }

make_pi0_primary_vertex()

void make_pi0_primary_vertex ( int  option, double  low_limit, double  up_limit, const HepPoint3D &  , const CLHEP::HepSymMatrix &  epvtx_err  )

private

Fill Mdst_pi0 based on the fit result.

Definition at line 1822 of file B2BIIFixMdstModule_ecl.cc.

  {
#if 0
    // pi0 mass of PDG.
    const double mpi0_pdg = 0.1349739;
 
    // Default mass window.
    const double low_default = 0.1178;
    const double up_default  = 0.1502;
 
    // Maximum iteration of fit.
    const int iter_max = 5;
 
    // Check whether proper option and mass window are given.
    switch (option) {
      case 0:    // option=0 case, set default mass window.
        low_limit = low_default;
        up_limit = up_default;
        break;
      case 1:   // option=1 case, check given mass window.
        if (mpi0_pdg < low_limit || up_limit < mpi0_pdg) {
          // If mass window is not correct, do nothing.
          dout(Debugout::ERR, "B2BIIFixBelle::Mdst_ecl") << "Invalid mass window between " << low_limit;
          dout(Debugout::ERR, "B2BIIFixBelle::Mdst_ecl") << " and " << up_limit << std::endl;
          return;
        }
        break;
      default: // Otherwise, invalid option, do nothing.
        dout(Debugout::ERR, "B2BIIFixBelle::Mdst_ecl") << "Invalid option=" << option << std::endl;
        return;
    }
 
    // At first, clear already existing Belle::Mdst_pi0.
    Belle::Mdst_pi0_Manager::get_manager().remove();
 
    // Get Belle::Mdst_gamma for photon's momentum
    // and get Belle::Mdst_ecl for error matrix.
    Belle::Mdst_gamma_Manager& gammamgr = Belle::Mdst_gamma_Manager::get_manager();
 
    // Re-allocate Belle::Mdst_pi0 table.
    Belle::Mdst_pi0_Manager& pi0mgr = Belle::Mdst_pi0_Manager::get_manager();
 
    // If Only one photon in the event, no need to do anything.
    if (gammamgr.count() < 2) {
      return;
    }
 
    // Make combination of two Belle::Mdst_gamma.
    for (std::vector<Belle::Mdst_gamma>::iterator itgamma = gammamgr.begin();
         itgamma != gammamgr.end(); ++itgamma) {
      Belle::Mdst_gamma& gamma1 = *itgamma;
      CLHEP::Hep3Vector gamma1_3v(gamma1.px(), gamma1.py(), gamma1.pz());
      CLHEP::HepLorentzVector gamma1_lv(gamma1_3v, gamma1_3v.mag());
 
      Belle::Mdst_ecl& ecl1 = gamma1.ecl();
 
      const double r_i       = ecl1.r();
      const double dzr_i     = std::sqrt(epvtx_err[2][2]) / r_i;
 
      const double theta_i0  = ecl1.theta();
      const double sin_th_i0 = std::sin(theta_i0);
 
      for (std::vector<Belle::Mdst_gamma>::iterator jtgamma = itgamma + 1;
           jtgamma != gammamgr.end(); ++jtgamma) {
        Belle::Mdst_gamma& gamma2 = *jtgamma;
        CLHEP::Hep3Vector gamma2_3v(gamma2.px(), gamma2.py(), gamma2.pz());
        CLHEP::HepLorentzVector gamma2_lv(gamma2_3v, gamma2_3v.mag());
 
        Belle::Mdst_ecl& ecl2 = gamma2.ecl();
 
        // Invariant mass before const. fit.
        CLHEP::HepLorentzVector gamgam_lv = gamma1_lv + gamma2_lv;
        const double mass_before = gamgam_lv.mag();
 
        // If invariant mass is inside the window,
        if (low_limit < mass_before && mass_before < up_limit) {
          // Error matrix(covariant matrix)
          CLHEP::HepMatrix V(6, 6, 0);
 
          V[0][0] = ecl1.error(0);
          V[0][1] = V[1][0] = ecl1.error(1);
          V[1][1] = ecl1.error(2);
          V[0][2] = V[2][0] = ecl1.error(3);
          V[1][2] = V[2][1] = ecl1.error(4);
          V[2][2] = ecl1.error(5);
          V[3][3] = ecl2.error(0);
          V[3][4] = V[4][3] = ecl2.error(1);
          V[4][4] = ecl2.error(2);
          V[3][5] = V[5][3] = ecl2.error(3);
          V[4][5] = V[5][4] = ecl2.error(4);
          V[5][5] = ecl2.error(5);
 
          // Correlation term
          const double r_j      = ecl2.r();
          const double dzr_j    = sqrt(epvtx_err[2][2]) / r_j;
 
          const double theta_j0  = ecl2.theta();
          const double sin_th_j0 = std::sin(theta_j0);
 
          V[2][5] = V[5][2] = dzr_i * sin_th_i0 * dzr_j * sin_th_j0;
          // Measurements; i.e. initial parameters.
          CLHEP::HepMatrix y0(6, 1);
          y0[0][0] = ecl1.energy();
          y0[1][0] = ecl1.phi();
          y0[2][0] = ecl1.theta();
          y0[3][0] = ecl2.energy();
          y0[4][0] = ecl2.phi();
          y0[5][0] = ecl2.theta();
 
          // Copy them to proper matrix which is given to fit.
          CLHEP::HepMatrix y(y0);
          // Delivative.
          CLHEP::HepMatrix Dy(6, 1, 0);
 
          int iter = 0;
          double Df, f_old = DBL_MAX;
          double Dchi2, chi2_old = DBL_MAX;
          double mass_gg, chi2 = DBL_MAX;
          bool exit_flag = false;
 
          // Set parameters to decide whether converged.
          const double Df_limit = 0.1;
          const double Dchi2_limit = 0.1;
          // Do mass constraint fit; iterate until convergence.
          while (1) {
            const double& E1 = y[0][0];
            const double& E2 = y[3][0];
            const double sin_theta1 = std::sin(y[2][0]);
            const double cos_theta1 = std::cos(y[2][0]);
            const double sin_theta2 = std::sin(y[5][0]);
            const double cos_theta2 = std::cos(y[5][0]);
            const double Dphi = y[1][0] - y[4][0];
            const double cos_Dphi = std::cos(Dphi);
            const double sin_Dphi = std::sin(Dphi);
            const double open_angle = sin_theta1 * sin_theta2 * cos_Dphi
                                      + cos_theta1 * cos_theta2;
            const double mass2_gg = 2 * E1 * E2 * (1 - open_angle);
            mass_gg = (mass2_gg > 0) ? std::sqrt(mass2_gg) : -std::sqrt(-mass2_gg);
 
            // No more iteration. Break to return.
            if (exit_flag || ++iter > iter_max)
              break;
 
            // constraint
            CLHEP::HepMatrix f(1, 1);
            f[0][0] = mass2_gg - (mpi0_pdg * mpi0_pdg);
 
            // dG/dq_i, G = (M_gg - M_pi0) = 0 is the constraint.
            CLHEP::HepMatrix B(1, 6);
            B[0][0] = mass2_gg / E1;
            B[0][1] = 2 * E1 * E2 * sin_theta1 * sin_theta2 * sin_Dphi;
            B[0][2] = 2 * E1 * E2 * (-cos_theta1 * sin_theta2 * cos_Dphi
                                     + sin_theta1 * cos_theta2);
            B[0][3] = mass2_gg / E2;
            B[0][4] = -B[0][1];
            B[0][5] = 2 * E1 * E2 * (-sin_theta1 * cos_theta2 * cos_Dphi
                                     + cos_theta1 * sin_theta2);
 
            const double sigma2_mass2_gg = (B * V * B.T())[0][0];
 
            // Proceed one step to get newer value y.
            Dy = V * B.T() * (B * Dy - f) / sigma2_mass2_gg;
            y = y0 + Dy;
            int ierr;
            chi2 = (Dy.T() * V.inverse(ierr) * Dy)[0][0];
            Dchi2 = fabs(chi2 - chi2_old);
            chi2_old = chi2;
            Df = fabs(f[0][0] - f_old);
            f_old = f[0][0];
 
            // When chi-sq. change is small enough and mass is
            if (Dchi2 < Dchi2_limit && Df < Df_limit)
              exit_flag = true;;
 
          }
          // Sort fitted result into proper variables.
          double pi0_E = y[0][0] + y[3][0];
          double pi0_px = y[0][0] * std::cos(y[1][0]) * std::sin(y[2][0])
                          + y[3][0] * std::cos(y[4][0]) * std::sin(y[5][0]);
          double pi0_py = y[0][0] * std::sin(y[1][0]) * std::sin(y[2][0])
                          + y[3][0] * std::sin(y[4][0]) * std::sin(y[5][0]);
          double pi0_pz = y[0][0] * std::cos(y[2][0]) + y[3][0] * std::cos(y[5][0]);
          double pi0_mass = mass_before;
 
          //  m_chi2 = chi2;  // protect...
          double pi0_chi2 = (chi2 > FLT_MAX) ? FLT_MAX : chi2;
 
          // Fill Belle::Mdst_pi0 based on the fit result.
          Belle::Mdst_pi0& pi0 = pi0mgr.add();
          pi0.gamma(0, gamma1);
          pi0.gamma(1, gamma2);
          pi0.px(pi0_px);
          pi0.py(pi0_py);
          pi0.pz(pi0_pz);
          pi0.energy(pi0_E);
          pi0.mass(pi0_mass);
          pi0.chisq(pi0_chi2);
        }
      }
    }
#else
    // pi0 mass of PDG. ;
    const double mpi0_pdg = 0.1349739;
    const double m2pi0_pdg = mpi0_pdg * mpi0_pdg;
    // Default mass window.;
    const double low_default = 0.1178;
    const double up_default  = 0.1502;
    // Maximum iteration of fit.;
    const int iter_max = 5;
 
    // Check whether proper option and mass window are given.;
    switch (option) {
      case 0:    // option=0 case, set default mass window.;
        low_limit = low_default;
        up_limit = up_default;
        break;
      case 1:   // option=1 case, check given mass window.;
        if (mpi0_pdg < low_limit || up_limit < mpi0_pdg) {
          // If mass window is not correct, do nothing.;
          B2ERROR("Invalid mass window between " << low_limit);
          B2ERROR(" and " << up_limit);
          return;
        }
        break;
      default: // Otherwise, invalid option, do nothing.;
        B2ERROR("Invalid option=" << option);
        return;
    }
    Belle::Mdst_pi0_Manager&  pi0_mgr     = Belle::Mdst_pi0_Manager::get_manager();
    Belle::Mdst_gamma_Manager& gamma_mgr  = Belle::Mdst_gamma_Manager::get_manager();
 
    // At first, clear already existing Belle::Mdst_pi0.;
    Belle::Mdst_pi0_Manager::get_manager().remove();
    // If Only one photon in the event, no need to do anything.;
    if (gamma_mgr.count() < 2) {
      return;
    }
 
    for (std::vector<Belle::Mdst_gamma>::iterator i = gamma_mgr.begin();
         i != gamma_mgr.end(); ++i) {
      const Belle::Mdst_gamma& gamma_i = *i;
      if (!gamma_i.ecl()) {
        continue;
      }
      const Belle::Mdst_ecl& ecl_i = gamma_i.ecl();
      const double r_i      = ecl_i.r();
      const double e_i0     = ecl_i.energy();
      const double phi_i0   = ecl_i.phi();
      const double theta_i0 = ecl_i.theta();
 
      const double sin_th_i0 = std::sin(theta_i0);
      const double cos_th_i0 = std::cos(theta_i0);
 
      CLHEP::HepSymMatrix err_i(3, 0);
      err_i[0][0] = ecl_i.error(0);
      err_i[1][0] = ecl_i.error(1); err_i[1][1] = ecl_i.error(2);
      err_i[2][0] = ecl_i.error(3); err_i[2][1] = ecl_i.error(4); err_i[2][2] = ecl_i.error(5);
 
      const double dzr_i = std::sqrt(epvtx_err[2][2]) / r_i;
 
      for (std::vector<Belle::Mdst_gamma>::iterator j = i + 1; j != gamma_mgr.end(); ++j) {
        const Belle::Mdst_gamma& gamma_j = *j;
        if (!gamma_j.ecl()) {
          continue;
        }
        const Belle::Mdst_ecl& ecl_j = gamma_j.ecl();
        const double r_j      = ecl_j.r();
        const double e_j0     = ecl_j.energy();
        const double phi_j0   = ecl_j.phi();
        const double theta_j0 = ecl_j.theta();
 
        const double sin_th_j0 = std::sin(theta_j0);
        const double cos_th_j0 = std::cos(theta_j0);
 
        CLHEP::HepSymMatrix err_j(3, 0);
        err_j[0][0] = ecl_j.error(0);
        err_j[1][0] = ecl_j.error(1); err_j[1][1] = ecl_j.error(2);
        err_j[2][0] = ecl_j.error(3); err_j[2][1] = ecl_j.error(4); err_j[2][2] = ecl_j.error(5);
 
        const double dzr_j = sqrt(epvtx_err[2][2]) / r_j;
 
        // -------------------------------------------------------------------- ;
 
        double dth_i_x_dth_j = dzr_i * sin_th_i0 * dzr_j * sin_th_j0;
 
        double det = err_i[2][2] * err_j[2][2] - dth_i_x_dth_j * dth_i_x_dth_j;
 
 
        double e_i = e_i0, phi_i = phi_i0, sin_th_i = sin_th_i0, cos_th_i = cos_th_i0;
        double e_j = e_j0, phi_j = phi_j0, sin_th_j = sin_th_j0, cos_th_j = cos_th_j0;
 
 
        double dphi     = phi_i - phi_j;
        double sin_dphi = std::sin(dphi);
        double cos_dphi = std::cos(dphi);
 
        // Cos of opening angle ;
        double cos_th_ij = sin_th_i * sin_th_j * cos_dphi + cos_th_i * cos_th_j;
        double m2_ij     = 2.0 * e_i * e_j * (1.0 - cos_th_ij);
        double mass      = std::sqrt(m2_ij);
 
        if (mass < low_limit || mass > up_limit)
          continue;
 
        double de_i = 0.0, dphi_i = 0.0, dtheta_i = 0.0;
        double de_j = 0.0, dphi_j = 0.0, dtheta_j = 0.0;
 
        int it = 0;
 
        double f      = 1.0e+6;
        double chisq  = 1.0e+6;
        double df = 0.0, dchisq = 0.0;
 
        const double del_chisq = 0.1;
        const double del_f   = 0.1;
        //const int icovar  = 1;
 
        double mass0     = 0.0;
        double dmass0    = 0.0;
        //double dmass     = 0.0;
        //double sdev      = 0.0;
 
        do {
 
          const double dcos_th_ij_dphi_i = -sin_th_i * sin_th_j * sin_dphi;
          const double dcos_th_ij_dphi_j =  sin_th_i * sin_th_j * sin_dphi;
          const double dcos_th_ij_dth_i  =  cos_th_i * sin_th_j * cos_dphi - sin_th_i * cos_th_j;
          const double dcos_th_ij_dth_j  =  cos_th_j * sin_th_i * cos_dphi - sin_th_j * cos_th_i;
 
          const double dm2_de_i  = m2_ij / e_i;
          const double dm2_de_j  = m2_ij / e_j;
 
          const double dm2_dcos_th_ij = -2.0 * e_i * e_j;
 
          const double dm2_dphi_i = dm2_dcos_th_ij * dcos_th_ij_dphi_i;
          const double dm2_dphi_j = dm2_dcos_th_ij * dcos_th_ij_dphi_j;
          const double dm2_dth_i  = dm2_dcos_th_ij * dcos_th_ij_dth_i;
          const double dm2_dth_j  = dm2_dcos_th_ij * dcos_th_ij_dth_j;
 
          double dm2_2
            = dm2_de_i * dm2_de_i     * err_i[0][0]
              + dm2_de_j * dm2_de_j     * err_j[0][0]
              + dm2_dphi_i * dm2_dphi_i * err_i[1][0]
              + dm2_dphi_j * dm2_dphi_j * err_j[1][0]
              + dm2_dth_i * dm2_dth_i   * err_i[2][0]
              + dm2_dth_j * dm2_dth_j   * err_j[2][0]
              + 2.0 * dm2_dth_i * dm2_dth_j * dth_i_x_dth_j;
 
          if (dm2_2 < 0.0) {
            dm2_2 = 0.0;
          }
          if (it++ == 0) {
            mass0  = mass;
            dmass0 = std::sqrt(dm2_2);
            /*if (mass0 > 0.0) {
              dmass = 0.5 * dmass0 / mass;
            }*/
          }
          //const double residual = mass - mpi0_pdg;
          //const double pull     = residual / dmass;
          if (it >= iter_max ||
              mass < low_default || mass > up_default) {
            //sdev = (dmass > 0.0) ? pull : -100;
            break;
          }
 
          const double del_m2
            = (m2pi0_pdg - m2_ij
               + dm2_de_i   * de_i
               + dm2_de_j   * de_j
               + dm2_dphi_i * dphi_i
               + dm2_dphi_j * dphi_j
               + dm2_dth_i  * dtheta_i
               + dm2_dth_j  * dtheta_j) / dm2_2;
 
          de_i     = del_m2 * dm2_de_i   * err_i[0][0];
          de_j     = del_m2 * dm2_de_j   * err_j[0][0];
          dphi_i   = del_m2 * dm2_dphi_i * err_i[1][1];
          dphi_j   = del_m2 * dm2_dphi_j * err_j[1][1];
          dtheta_i = del_m2 * (dm2_dth_i  * err_i[2][2] + dm2_dth_j  * dth_i_x_dth_j);
          dtheta_j = del_m2 * (dm2_dth_j  * err_j[2][2] + dm2_dth_i  * dth_i_x_dth_j);
 
 
          dchisq = chisq;
          chisq
            = de_i * de_i     / err_i[0][0]
              + de_j * de_j     / err_j[0][0]
              + dphi_i * dphi_i / err_i[1][1]
              + dphi_j * dphi_j / err_j[1][1]
              + (dtheta_i * dtheta_i * err_i[2][2]
                 + dtheta_j * dtheta_j * err_j[2][2]
                 + 2.0 * dtheta_i * dtheta_j * dth_i_x_dth_j) / det;
          dchisq -= chisq;
 
 
          e_i     = e_i0     + de_i;
          e_j     = e_j0     + de_j;
          phi_i   = phi_i0   + dphi_i;
          phi_j   = phi_j0   + dphi_j;
          double theta_i = theta_i0 + dtheta_i;
          double theta_j = theta_j0 + dtheta_j;
 
          sin_th_i = std::sin(theta_i);
          cos_th_i = std::cos(theta_i);
          sin_th_j = std::sin(theta_j);
          cos_th_j = std::cos(theta_j);
 
          dth_i_x_dth_j = dzr_i * sin_th_i * dzr_j * sin_th_j;
          det = err_i[2][2] * err_j[2][2] - dth_i_x_dth_j * dth_i_x_dth_j;
 
          dphi     = phi_i - phi_j;
          sin_dphi = std::sin(dphi);
          cos_dphi = std::cos(dphi);
 
          cos_th_ij = sin_th_i * sin_th_j * cos_dphi + cos_th_i * cos_th_j;
          m2_ij     = 2.0 * e_i * e_j * (1.0 - cos_th_ij);
          mass      = std::sqrt(m2_ij);
 
          df = f;
          f = fabs(m2pi0_pdg - m2_ij) / dmass0;
          df -= f;
          ++it;
        } while (std::fabs(df) > del_f || std::fabs(dchisq) > del_chisq);
        const double cos_phi_i = std::cos(phi_i);
        const double cos_phi_j = std::cos(phi_j);
        const double sin_phi_i = std::sin(phi_i);
        const double sin_phi_j = std::sin(phi_j);
 
        const CLHEP::HepLorentzVector p4_i(e_i * sin_th_i * cos_phi_i,
                                           e_i * sin_th_i * sin_phi_i, e_i * cos_th_i, e_i);
        const CLHEP::HepLorentzVector p4_j(e_j * sin_th_j * cos_phi_j,
                                           e_j * sin_th_j * sin_phi_j, e_j * cos_th_j, e_j);
 
        const CLHEP::HepLorentzVector p4_pi0(p4_i + p4_j);
 
        // Fill Belle::Mdst_pi0 based on the fit result.;
        Belle::Mdst_pi0& pi0 = pi0_mgr.add();
        pi0.gamma(0, gamma_i);
        pi0.gamma(1, gamma_j);
        pi0.px(p4_pi0.x());
        pi0.py(p4_pi0.y());
        pi0.pz(p4_pi0.z());
        pi0.energy(p4_pi0.e());
        pi0.mass(mass0);
        pi0.chisq(chisq);
      }
    }
#endif
    return;
  }

mpi0pdg()

static double mpi0pdg ( double  Energy )

static

Make MC mass peak to PDG value.

Definition at line 642 of file B2BIIFixMdstModule_ecl.cc.

  {
    // return value.
    double return_value;
    // pi0 mass in PDG.
    const double m_pdg = 134.9766;
 
    // default = do nothing.
    return_value = 1.0;
 
    if (0.1 < Energy && Energy < 1.0) {
      double x = log10(Energy * 1000.0);
      // Curve given by S.Uchida at 2001/07/17.
      return_value
        = m_pdg / (135.21 + 5.3812 * x - 4.2160 * x * x + 0.74650 * x * x * x);
    }
    // This return value has to be used as product.
    // i.e. E_corrected = E_original*return_value.
    return return_value;
  }

null_scale()

static void null_scale ( double  [5], double  , double    )

static

Dummy function.

Definition at line 1459 of file B2BIIFixMdstModule_trk.cc.

  {
    return;
  }

operator==()

static bool operator== ( const cal_scale_error_func_set_t &  lhs, const cal_scale_error_func_set_t &  rhs  )

static

Operator definition for cal_scale_error_func_set_t.

Definition at line 1448 of file B2BIIFixMdstModule_trk.cc.

  {
    return (lhs.m_hadMC == rhs.m_hadMC) && (lhs.m_cosMC == rhs.m_cosMC) && (lhs.m_cosDATA == rhs.m_cosDATA);
  }

pi0resol()

double pi0resol ( double  p, double  theta, const char *  side, bool  mcdata, int  , int    )

staticprivate

Treat pi0 mass width as a func.

of pi0 momentum.

Definition at line 685 of file B2BIIFixMdstModule_ecl.cc.

  {
// option is added to become compatible with future gsim modification.
    int iside = 0;
 
    if (!strcmp(side, "lower"))  iside = 1;
    if (!strcmp(side, "higher")) iside = 2;
    if (iside == 0) {
      B2ERROR("Error pi0resol. Wrong input parameter=" << side);
      return -1;
    }
//  dout(Debugout::INFO,"B2BIIFixMdst_ecl") <<" iside="<<iside<<std::endl;
//----------------------------------------------------
//        20 <= theta  <= 45
//----------------------------------------------------
//   0.15 < p  < 0.8
//    -- data   L: lower side  H: higher side
    const double data_thf_pl_L[] = { 9.8233, -13.3489, 18.3271, -7.6668};
    const double derr_thf_pl_L[] = { 0.3274, 0.755, 0.8611, 0.521};
    const double data_thf_pl_H[] = { 6.1436, -7.9668, 12.4766, -5.3201};
    const double derr_thf_pl_H[] = { 0.2903, 0.6754, 0.7724, 0.466};
//   0.8 < p  < 5.3
//    -- data   L: lower side  H: higher side
    const double data_thf_ph_L[] = { 7.1936, -0.6378, 0.5912, -0.075};
    const double derr_thf_ph_L[] = { 0.1975, 0.2036, 0.0793, 0.0121};
    const double data_thf_ph_H[] = { 4.4923, 0.5532, 0.2658, -0.0343};
    const double derr_thf_ph_H[] = { 0.1883, 0.2019, 0.0803, 0.0122};
//----------------------------------------------------
//        20 <= theta  <= 45
//----------------------------------------------------
//   0.15 < p  < 0.8
//    -- MC   L: lower side  H: higher side
    const double mc_thf_pl_L[] = { 4.8093, 3.4567, -3.7898, 1.7553};
    const double merr_thf_pl_L[] = { 0.2145, 0.527, 0.6153, 0.3712};
    const double mc_thf_pl_H[] = { 4.6176, -2.9049, 4.2994, -1.4776};
    const double merr_thf_pl_H[] = { 0.1969, 0.4826, 0.555, 0.3346};
//   0.8 < p  < 5.3
//    -- MC   L: lower side  H: higher side
    const double mc_thf_ph_L[] = { 6.3166, -0.5993, 0.5845, -0.0695};
    const double merr_thf_ph_L[] = { 0.1444, 0.1468, 0.0571, 0.0087};
    const double mc_thf_ph_H[] = { 2.9719, 1.7999, -0.2418, 0.028};
    const double merr_thf_ph_H[] = { 0.1318, 0.1362, 0.0538, 0.0082};
 
//----------------------------------------------------
//        45 <= theta  <= 100
//----------------------------------------------------
//   0.15 < p  < 0.8
//    -- data   L: lower side  H: higher side
    const double data_thm_pl_L[] = { 7.7573, -4.8855, 6.5561, -2.4788};
    const double derr_thm_pl_L[] = { 0.1621, 0.4894, 0.6882, 0.4985};
    const double data_thm_pl_H[] = { 6.9075, -10.5036, 18.5196, -9.224};
    const double derr_thm_pl_H[] = { 0.1458, 0.4383, 0.639, 0.4726};
//   0.8 < p  < 5.3
//    -- data   L: lower side  H: higher side
    const double data_thm_ph_L[] = { 5.2347, 2.1827, -0.6563, 0.1545};
    const double derr_thm_ph_L[] = { 0.0986, 0.1281, 0.0627, 0.0117};
    const double data_thm_ph_H[] = { 3.2114, 3.3806, -0.8635, 0.1371};
    const double derr_thm_ph_H[] = { 0.0927, 0.1205, 0.058, 0.0106};
//
//----------------------------------------------------
//        45 <= theta  <= 100
//----------------------------------------------------
//   0.15 < p  < 0.8
//    -- MC   L: lower side  H: higher side
    const double mc_thm_pl_L[] = { 6.1774, -2.1831, 3.6615, -1.1813};
    const double merr_thm_pl_L[] = {   0.11, 0.327, 0.476, 0.3655};
    const double mc_thm_pl_H[] = { 4.0239, -0.7485, 3.6203, -1.4823};
    const double merr_thm_pl_H[] = { 0.0991, 0.3034, 0.4223, 0.3069};
//   0.8 < p  < 5.3
//    -- MC   L: lower side  H: higher side
    const double mc_thm_ph_L[] = { 4.5966, 2.261, -0.4938, 0.0984};
    const double merr_thm_ph_L[] = { 0.0711, 0.0917, 0.0448, 0.0081};
    const double mc_thm_ph_H[] = { 3.4609, 2.0069, -0.0498, -0.0018};
    const double merr_thm_ph_H[] = { 0.0966, 0.1314, 0.0574, 0.0086};
//
//----------------------------------------------------
//        100 <= theta  <= 150
//----------------------------------------------------
//   0.15 < p  < 0.8
//    -- data   L: lower side  H: higher side
    const double data_thb_pl_L[] = {11.5829, -21.6715, 30.2368, -13.0389};
    const double derr_thb_pl_L[] = { 0.2742, 0.7256, 0.9139, 0.6006};
    const double data_thb_pl_H[] = { 8.0227, -14.7387, 23.1042, -10.4233};
    const double derr_thb_pl_H[] = { 0.2466, 0.6512, 0.8239, 0.5419};
//   0.8 < p  < 5.3
//    -- data   L: lower side  H: higher side
    const double data_thb_ph_L[] = { 7.5872, -1.8994, 1.6526, -0.2755};
    const double derr_thb_ph_L[] = { 0.1999, 0.2638, 0.1422, 0.0335};
    const double data_thb_ph_H[] = { 6.3542, -2.5164, 2.5763, -0.4803};
    const double derr_thb_ph_H[] = { 0.1885, 0.2527, 0.136, 0.0318};
//----------------------------------------------------
//        100 <= theta  <= 150
//----------------------------------------------------
//   0.15 < p  < 0.8
//    -- MC   L: lower side  H: higher side
    const double mc_thb_pl_L[] = { 5.2707, 2.5607, -3.1377, 1.8434};
    const double merr_thb_pl_L[] = { 0.1801, 0.5048, 0.6741, 0.4343};
 
    const double mc_thb_pl_H[] = { 2.5867, 7.6982, -10.0677, 5.312};
    const double merr_thb_pl_H[] = { 0.1658, 0.4651, 0.6063, 0.3925};
//   0.8 < p  < 5.3
//    -- MC   L: lower side  H: higher side
    const double mc_thb_ph_L[] = { 6.5206, -1.5103, 1.9054, -0.3609};
    const double merr_thb_ph_L[] = { 0.1521, 0.2048, 0.1108, 0.0255};
    const double mc_thb_ph_H[] = { 3.4397, 2.2372, -0.1214, -0.0004};
    const double merr_thb_ph_H[] = { 0.1324, 0.1822, 0.1065, 0.0252};
 
//
    double resol;
    double para[4] = { };
    double error[4] = { };
 
    double pbuf = p;
//--
//       theta< 45
//---
    if (theta <= 45.) {
//--
//                       p-low
//---
      if (pbuf <= 0.8) {
        if (!mcdata) {
          //--  data
          for (int i = 0; i <= 3; i++) {
            if (iside == 1) {
              para[i] = data_thf_pl_L[i];
              error[i] = derr_thf_pl_L[i];
            } else {
              para[i] = data_thf_pl_H[i];
              error[i] = derr_thf_pl_H[i];
            }
          } // for
        } else {
          //--  mc
          for (int i = 0; i <= 3; i++) {
            if (iside == 1) {
              para[i] = mc_thf_pl_L[i];
              error[i] = merr_thf_pl_L[i];
            } else {
              para[i] = mc_thf_pl_H[i];
              error[i] = merr_thf_pl_H[i];
            }
          }  //for
        }
      } else {
//--
//                       p-high
//---
//  use p= 5.2 value  if p >= 5.2 for forward region
        if (pbuf >= 5.2) {pbuf = 5.2;}
        if (!mcdata) {
          //--  data
          for (int i = 0; i <= 3; i++) {
            if (iside == 1) {
              para[i] = data_thf_ph_L[i];
              error[i] = derr_thf_ph_L[i];
            } else {
              para[i] = data_thf_ph_H[i];
              error[i] = derr_thf_ph_H[i];
            }
          }// for
        } else {
          //--  mc
          for (int i = 0; i <= 3; i++) {
            if (iside == 1) {
              para[i] = mc_thf_ph_L[i];
              error[i] = merr_thf_ph_L[i];
            } else {
              para[i] = mc_thf_ph_H[i];
              error[i] = merr_thf_ph_H[i];
            }
          }// for
        }
      } // p-range
//--
//     45<  theta< 100
//---
    } else if (theta <= 100.) {
//--
//                       p-low
//---
      if (pbuf <= 0.8) {
        if (!mcdata) {
          //--  data
          for (int i = 0; i <= 3; i++) {
            if (iside == 1) {
              para[i] = data_thm_pl_L[i];
              error[i] = derr_thm_pl_L[i];
            } else {
              para[i] = data_thm_pl_H[i];
              error[i] = derr_thm_pl_H[i];
            }
          } // for
        } else {
          //--  mc
          for (int i = 0; i <= 3; i++) {
            if (iside == 1) {
              para[i] = mc_thm_pl_L[i];
              error[i] = merr_thm_pl_L[i];
            } else {
              para[i] = mc_thm_pl_H[i];
              error[i] = merr_thm_pl_H[i];
            }
          } //for
        }
      } else {
//--
//                       p-high
//---
//  use p= 5.2 value  if p >= 5.2 for middle region
        if (pbuf >= 5.2) {pbuf = 5.2;}
        if (!mcdata) {
          //--  data
          for (int i = 0; i <= 3; i++) {
            if (iside == 1) {
              para[i] = data_thm_ph_L[i];
              error[i] = derr_thm_ph_L[i];
            } else {
              para[i] = data_thm_ph_H[i];
              error[i] = derr_thm_ph_H[i];
            }
          }  //for
        } else {
          //--  mc
          for (int i = 0; i <= 3; i++) {
            if (iside == 1) {
              para[i] = mc_thm_ph_L[i];
              error[i] = merr_thm_ph_L[i];
            } else {
              para[i] = mc_thm_ph_H[i];
              error[i] = merr_thm_ph_H[i];
            }
          }  //for
        }
      } // p-range
//--
//       theta> 100
//---
    } else {
//--
//                       p-low
//---
      if (pbuf <= 0.8) {
        if (!mcdata) {
          //--  data
          for (int i = 0; i <= 3; i++) {
            if (iside == 1) {
              para[i] = data_thb_pl_L[i];
              error[i] = derr_thb_pl_L[i];
            } else {
              para[i] = data_thb_pl_H[i];
              error[i] = derr_thb_pl_H[i];
            }
          }  //for
        } else {
          //--  mc
          for (int i = 0; i <= 3; i++) {
            if (iside == 1) {
              para[i] = mc_thb_pl_L[i];
              error[i] = merr_thb_pl_L[i];
            } else {
              para[i] = mc_thb_pl_H[i];
              error[i] = merr_thb_pl_H[i];
            }
          }  //for
        }
      } else {
//--
//                       p-high
//---
//  use p= 3.0 value  if p >= 3.0 for backward region
        if (pbuf >= 3.0) {pbuf = 3.0;}
        if (!mcdata) {
          //--  data
          for (int i = 0; i <= 3; i++) {
            if (iside == 1) {
              para[i] = data_thb_ph_L[i];
              error[i] = derr_thb_ph_L[i];
            } else {
              para[i] = data_thb_ph_H[i];
              error[i] = derr_thb_ph_H[i];
            }
          }  //for
        } else {
          //--  mc
          for (int i = 0; i <= 3; i++) {
            if (iside == 1) {
              para[i] = mc_thb_ph_L[i];
              error[i] = merr_thb_ph_L[i];
            } else {
              para[i] = mc_thb_ph_H[i];
              error[i] = merr_thb_ph_H[i];
            }
          }  //for
        }
      } // p-range
 
 
    }  //theta range
//--
//  evaluate resolution in the unit of GeV.
//--
    resol = para[0] + para[1] * pbuf + para[2] * pbuf * pbuf +
            para[3] * pbuf * pbuf * pbuf;
    resol = resol / 1000.;
 
//--
// Evaluate the error od sigma using diagonal errors.
//--
    double eresol = error[0] * error[0] + (pbuf * error[1]) * (pbuf * error[1])
                    + (pbuf * pbuf * error[2]) * (pbuf * pbuf * error[2])
                    + (pbuf * pbuf * pbuf * error[3]) * (pbuf * pbuf * pbuf * error[3]);
    eresol = sqrt(eresol) / 1000.;
 
    B2DEBUG(19, "B2BIIFixMdst_ecl" << LogVar("theta", theta) << LogVar("p", pbuf)
            << LogVar("para0", para[0]) << LogVar("para1", para[1]) << LogVar("para2", para[2]) << LogVar("para3", para[3])
            << LogVar("resol", resol) << LogVar("er", eresol));
    return resol;
  }

remove_extra_trk_vee2()

int remove_extra_trk_vee2 ( )

private

Remove extra tracks from Mdst_trk and Mdst_vee2.

Definition at line 3247 of file B2BIIFixMdstModule_trk.cc.

  {
    Belle::Mdst_event_add_Manager& mevtmgr = Belle::Mdst_event_add_Manager::get_manager();
    if (mevtmgr.count() <= 1) { // no Belle::Mdst_event_add table
      return -2;
    }
    unsigned flag(mevtmgr[1].flag(0));
    if (0 == flag) return -1;  // do nothing if no extra tracks in Belle::Mdst_charged etc.
    const int i_ch(flag & 0xff);
    const int i_trk((flag >> 8) & 0xff);
    const int i_vee2((flag >> 16) & 0xff);
    //Belle::Mdst_charged_Manager////& chMgr(Belle::Mdst_charged_Manager::get_manager());
    Belle::Mdst_trk_Manager& tMgr(Belle::Mdst_trk_Manager::get_manager());
    Belle::Mdst_vee2_Manager& veeMgr(Belle::Mdst_vee2_Manager::get_manager());
    Belle::Mdst_trk_extra_Manager& teMgr(Belle::Mdst_trk_extra_Manager::get_manager());
    Belle::Mdst_vee2_extra_Manager& veeeMgr(Belle::Mdst_vee2_extra_Manager::get_manager());
    if (i_trk) {
      std::vector<int> extra_ID;
      if (teMgr.count()) teMgr.remove();
      for (std::vector<Belle::Mdst_trk>::iterator i = tMgr.begin();
           i != tMgr.end(); ++i) {
        if ((*i).get_ID() < i_trk) {
          extra_ID.push_back(0);
          continue;
        }
        if (!((*i).quality() & 16u)) {
          B2ERROR("Warning from B2BIIFixMdst: inconsistency between Belle::Mdst_trk and Belle::Mdst_evet_add"
                 );
        }
        Belle::Mdst_trk_extra& trk(teMgr.add());
        for (int j = 0; j < 5; j++) trk.mhyp(j, (*i).mhyp(j));
        trk.quality((*i).quality());
        extra_ID.push_back(trk.get_ID());
      }
      if (i_vee2) {
        if (veeeMgr.count()) veeeMgr.remove();
        for (std::vector<Belle::Mdst_vee2>::iterator i = veeMgr.begin();
             i != veeMgr.end(); ++i) {
          if ((*i).get_ID() < i_vee2) continue;
          if (!((*i).chgd(0).trk().quality() & 16u) && !((*i).chgd(1).trk().quality() & 16u)) {
            B2ERROR("Warning from B2BIIFixMdst: inconsistency between Belle::Mdst_vee2 and Belle::Mdst_evet_add"
                   );
          }
          Belle::Mdst_vee2_extra& vee(veeeMgr.add());
          vee.kind((*i).kind());
          const int extra_id0(extra_ID[(*i).chgd(0).trk_ID() - 1]);
          const int extra_id1(extra_ID[(*i).chgd(1).trk_ID() - 1]);
          if (extra_id0) {
            vee.extra(0, teMgr[extra_id0 - 1]);
          } else {
            vee.chgd((*i).chgd(0));
          }
          if (extra_id1) {
            vee.extra(1, teMgr[extra_id1 - 1]);
          } else {
            if (vee.chgd_ID()) {
              B2ERROR("Warning from B2BIIFixMdst: both tracks of Belle::Mdst_vee2_extra are good track"
                     );
            }
            vee.chgd((*i).chgd(1));
          }
 
          vee.px((*i).px());
          vee.py((*i).py());
          vee.pz((*i).pz());
          vee.energy((*i).energy());
          vee.vx((*i).vx());
          vee.vy((*i).vy());
          vee.vz((*i).vz());
          vee.z_dist((*i).z_dist());
          vee.chisq((*i).chisq());
          vee.type((*i).type());
          vee.daut((*i).daut());
        }
        int id = BsCouTab(MDST_VEE2);
        while (id >= i_vee2) BsDelEnt(MDST_VEE2, id--);
      }
      int id = BsCouTab(MDST_TRK);
      while (id >= i_trk) BsDelEnt(MDST_TRK, id--);
    }
    if (i_ch) {
      int id = BsCouTab(MDST_CHARGED);
      while (id >= i_ch) BsDelEnt(MDST_CHARGED, id--);
    }
    flag = 0;
    mevtmgr[1].flag(0, flag);
    return 0;
  }

rootfunc()

double rootfunc ( const double  x, const double  x1, const double  x2, const double  yc, const double  a1, const double  a2  )

inline

rootfunc

Definition at line 1533 of file B2BIIFixMdstModule_trk.cc.

  {
    return x < x1 ? (x - x1) * a1 + yc :
           x > x2 ? (x2 - x1) * a2 + yc : (x - x1) * a2 + yc;
  }

scale_err_ms()

void scale_err_ms ( Belle::Mdst_trk_fit &  fit, const double  scale[]  )

static

Scale error.

Definition at line 3411 of file B2BIIFixMdstModule_trk.cc.

  {
//====================================================
    fit.error(0, scale[0]*scale[0]*fit.error(0));
    fit.error(1, scale[1]*scale[0]*fit.error(1));
    fit.error(2, scale[1]*scale[1]*fit.error(2));
    fit.error(3, scale[2]*scale[0]*fit.error(3));
    fit.error(4, scale[2]*scale[1]*fit.error(4));
    fit.error(5, scale[2]*scale[2]*fit.error(5));
    fit.error(6, scale[3]*scale[0]*fit.error(6));
    fit.error(7, scale[3]*scale[1]*fit.error(7));
    fit.error(8, scale[3]*scale[2]*fit.error(8));
    fit.error(9, scale[3]*scale[3]*fit.error(9));
    fit.error(10, scale[4]*scale[0]*fit.error(10));
    fit.error(11, scale[4]*scale[1]*fit.error(11));
    fit.error(12, scale[4]*scale[2]*fit.error(12));
    fit.error(13, scale[4]*scale[3]*fit.error(13));
    fit.error(14, scale[4]*scale[4]*fit.error(14));
 
  }

scale_error()

void scale_error ( const int  message_level = 0 )

private

Apply scale error.

Definition at line 2886 of file B2BIIFixMdstModule_trk.cc.

  {
    static int result_before = -1;
 
    const int result = scale_error_impl(message_level, this->m_reprocess_version);
 
    if (result != result_before) {
      switch (result) {
        case 0: {
          B2INFO(
            "scale_error: info: scale error is properly applied.");
          break;
        }
 
        case 1: {
          B2ERROR(
            "scale_error: warning: scale error is not applied. Reason: it has been already applied.");
          break;
        }
 
        case 2: {
          int no_exp, no_run, no_evt, no_frm, expmc;
          get_event_id(&no_exp, &no_run, &no_evt, &no_frm, &expmc);
          B2ERROR(
            "scale_error: error: scale error is not applied. Reason: it is not available for exp " << no_exp << ". Exit! (I'll crash job.)");
          exit(-1);
//          break; // redundant
        }
 
        default: assert(0); // Should not be here!
      }
 
      result_before = result;
    }
  }

scale_error_impl()

static int scale_error_impl ( const int  message_level, const int  reprocess_version  )

static

The implementation of B2BIIFixMdstModule::scale_error()

Returns

0 if scale error is properly applied. 1 if scale error is already applied. 2 if scale error for this exp is not available.

See also

B2BIIFixMdstModule::scale_error()

Definition at line 2775 of file B2BIIFixMdstModule_trk.cc.

  {
    SE_Message_Level = message_level;
    SE_Reprocess_Version = reprocess_version;
 
    int no_exp{0}, no_run{0}, no_evt{0}, no_frm{0}, expmc{0};
    get_event_id(&no_exp, &no_run, &no_evt, &no_frm, &expmc);
 
    if (DUMMY_scale == get_scale_error_func_for_exprun(no_exp, no_run)) return 2;
    if (is_already_scaled()) return 1;
 
    static int first_exp73 = true;
    if (no_exp == 73 && first_exp73) {
      first_exp73 = false;
      B2ERROR(
        "scale_error: warning: scale parameters for exp#71 are tentatively used for exp#73.");
    }
 
    double scale[5] = { // ... temporary
      1.0, // dr
      1.0, // phi0
      1.0, // kappa
      1.0, // dz
      1.0, // tanl
    };
 
 
    // scale error matrices in mdst_trk_fit
    Belle::Mdst_trk_fit_Manager& fitmgr = Belle::Mdst_trk_fit_Manager::get_manager();
    for (std::vector<Belle::Mdst_trk_fit>::iterator it = fitmgr.begin(); it != fitmgr.end(); ++it) {
      Belle::Mdst_trk_fit& fit = *it;
      if (fit.helix(2) == 0.) continue;
 
      const double pt   = 1. / fabs(fit.helix(2));
      const double tanl = fit.helix(4);
 
      cal_scale_error(scale, pt, tanl, expmc, no_exp, no_run);
 
      fit.error(0, scale[0]*scale[0]*fit.error(0));
      fit.error(1, scale[1]*scale[0]*fit.error(1));
      fit.error(2, scale[1]*scale[1]*fit.error(2));
      fit.error(3, scale[2]*scale[0]*fit.error(3));
      fit.error(4, scale[2]*scale[1]*fit.error(4));
      fit.error(5, scale[2]*scale[2]*fit.error(5));
      fit.error(6, scale[3]*scale[0]*fit.error(6));
      fit.error(7, scale[3]*scale[1]*fit.error(7));
      fit.error(8, scale[3]*scale[2]*fit.error(8));
      fit.error(9, scale[3]*scale[3]*fit.error(9));
      fit.error(10, scale[4]*scale[0]*fit.error(10));
      fit.error(11, scale[4]*scale[1]*fit.error(11));
      fit.error(12, scale[4]*scale[2]*fit.error(12));
      fit.error(13, scale[4]*scale[3]*fit.error(13));
      fit.error(14, scale[4]*scale[4]*fit.error(14));
    }
 
 
    // scale error matrices in mdst_daughters
    Belle::Mdst_vee_daughters_Manager& daumgr = Belle::Mdst_vee_daughters_Manager::get_manager();
    for (std::vector<Belle::Mdst_vee_daughters>::iterator it = daumgr.begin(); it != daumgr.end(); ++it) {
      Belle::Mdst_vee_daughters& dau = *it;
      if (dau.helix_p(2) == 0. || dau.helix_m(2) == 0.) continue;
 
      // positive track
      const double pt_p   = 1. / fabs(dau.helix_p(2));
      const double tanl_p = dau.helix_p(4);
 
      cal_scale_error(scale, pt_p, tanl_p, expmc, no_exp, no_run);
 
      dau.error_p(0, scale[0]*scale[0]*dau.error_p(0));
      dau.error_p(1, scale[1]*scale[0]*dau.error_p(1));
      dau.error_p(2, scale[1]*scale[1]*dau.error_p(2));
      dau.error_p(3, scale[2]*scale[0]*dau.error_p(3));
      dau.error_p(4, scale[2]*scale[1]*dau.error_p(4));
      dau.error_p(5, scale[2]*scale[2]*dau.error_p(5));
      dau.error_p(6, scale[3]*scale[0]*dau.error_p(6));
      dau.error_p(7, scale[3]*scale[1]*dau.error_p(7));
      dau.error_p(8, scale[3]*scale[2]*dau.error_p(8));
      dau.error_p(9, scale[3]*scale[3]*dau.error_p(9));
      dau.error_p(10, scale[4]*scale[0]*dau.error_p(10));
      dau.error_p(11, scale[4]*scale[1]*dau.error_p(11));
      dau.error_p(12, scale[4]*scale[2]*dau.error_p(12));
      dau.error_p(13, scale[4]*scale[3]*dau.error_p(13));
      dau.error_p(14, scale[4]*scale[4]*dau.error_p(14));
 
      // negative track
      const double pt_m   = 1. / fabs(dau.helix_m(2));
      const double tanl_m = dau.helix_m(4);
 
      cal_scale_error(scale, pt_m, tanl_m, expmc, no_exp, no_run);
 
      dau.error_m(0, scale[0]*scale[0]*dau.error_m(0));
      dau.error_m(1, scale[1]*scale[0]*dau.error_m(1));
      dau.error_m(2, scale[1]*scale[1]*dau.error_m(2));
      dau.error_m(3, scale[2]*scale[0]*dau.error_m(3));
      dau.error_m(4, scale[2]*scale[1]*dau.error_m(4));
      dau.error_m(5, scale[2]*scale[2]*dau.error_m(5));
      dau.error_m(6, scale[3]*scale[0]*dau.error_m(6));
      dau.error_m(7, scale[3]*scale[1]*dau.error_m(7));
      dau.error_m(8, scale[3]*scale[2]*dau.error_m(8));
      dau.error_m(9, scale[3]*scale[3]*dau.error_m(9));
      dau.error_m(10, scale[4]*scale[0]*dau.error_m(10));
      dau.error_m(11, scale[4]*scale[1]*dau.error_m(11));
      dau.error_m(12, scale[4]*scale[2]*dau.error_m(12));
      dau.error_m(13, scale[4]*scale[3]*dau.error_m(13));
      dau.error_m(14, scale[4]*scale[4]*dau.error_m(14));
    }
 
    return 0;
  }

scale_momenta()

void scale_momenta ( float  scale_data = 1.0, float  scale_mc = 1.0, int  mode = 0  )

private

Scale momenta of Mdst_trk.

Definition at line 277 of file B2BIIFixMdstModule_trk.cc.

  {
//===============================================================
// Scales charged track momenta, track params. and error
// matrices.
//======================================================
 
    // dout(Debugout::DDEBUG,"B2BIIFixMdst_trk") << "sacel momenta is called" << std::endl;
 
//Check existence of belle_event
    Belle::Belle_event_Manager& evtmgr = Belle::Belle_event_Manager::get_manager();
    // dout(Debugout::DDEBUG,"B2BIIFixMdst_trk") << evtmgr.count() << std::endl;
    if (0 == evtmgr.count()) return; //do nothing if not exist
    // dout(Debugout::DDEBUG,"B2BIIFixMdst_trk") << "after check" << std::endl;
 
    Belle::Mdst_event_add_Manager& mevtmgr = Belle::Mdst_event_add_Manager::get_manager();
    if (mevtmgr.count() > 0 && 1 == mevtmgr[0].flag_scale()) return; //do nothing if already scaled
 
//check mode
    if (mode < 0 || mode > 2) {
      B2ERROR("scale_momenta: invalid mode specified;");
      B2ERROR("mode must be 0, 1, 2");
      return;
    }
 
//set scale factor
    int expmc = evtmgr[0].ExpMC();
    int expno = evtmgr[0].ExpNo();
    int runno = evtmgr[0].RunNo();
 
    double scale = 1.;
    if (1 == expmc) {
      if (mode == 0) {
        scale = scale_data;
      } else {
        //      scale_momenta_set( mode, expno, runno, scale);
        if (m_reprocess_version == 0) {
          scale_momenta_set_v1(mode, expno, runno, scale);
        } else if (m_reprocess_version == 1) {
          scale_momenta_set_v2(mode, expno, runno, scale);
        }
      }
    } else if (2 == expmc) {
      scale = scale_mc;
    }
 
    if (1. == scale) return; //do nothing if scale=1
    // dout(Debugout::DDEBUG,"B2BIIFixMdst_trk") << scale << std::endl;
 
//Turn on flag, save scale factor
    if (mevtmgr.count() > 0) {
      mevtmgr[0].flag_scale(1);
      mevtmgr[0].scale(scale);
    } else {
      Belle::Mdst_event_add& meadd = mevtmgr.add();
      meadd.flag_scale(1);
      meadd.scale(scale);
    }
    // dout(Debugout::DDEBUG,"B2BIIFixMdst_trk") << mevtmgr[0].flag_scale() << std::endl;
    // dout(Debugout::DDEBUG,"B2BIIFixMdst_trk") << mevtmgr[0].scale() << std::endl;
 
 
//Scale momenta in mdst_charged
    Belle::Mdst_charged_Manager& chgmgr = Belle::Mdst_charged_Manager::get_manager();
    for (std::vector<Belle::Mdst_charged>::iterator it = chgmgr.begin();
         it != chgmgr.end(); ++it) {
      Belle::Mdst_charged& charged = *it;
      charged.px(scale * charged.px());
      charged.py(scale * charged.py());
      charged.pz(scale * charged.pz());
    }
 
//Scale momenta in mdst_vee2
    Belle::Mdst_vee2_Manager& vee2mgr = Belle::Mdst_vee2_Manager::get_manager();
    for (std::vector<Belle::Mdst_vee2>::iterator it = vee2mgr.begin();
         it != vee2mgr.end(); ++it) {
      Belle::Mdst_vee2& vee2 = *it;
      double v0mass_scale = vee_mass_nofit(vee2, scale);
      double v0mass_noscl = vee_mass_nofit(vee2);
      double esq_scale =
        (v0mass_scale - v0mass_noscl) * (v0mass_scale + v0mass_noscl)
        +  vee2.energy() * vee2.energy() +
        (scale - 1.) * (scale + 1.) * (vee2.px() * vee2.px() +
                                       vee2.py() * vee2.py() +
                                       vee2.pz() * vee2.pz());
      vee2.energy(std::sqrt(esq_scale));
      vee2.px(scale * vee2.px());
      vee2.py(scale * vee2.py());
      vee2.pz(scale * vee2.pz());
    }
 
//Scale error matrices in mdst_trk_fit
    double scalei = 1. / scale;
    double scalei2 = scalei / scale;
 
    Belle::Mdst_trk_fit_Manager& trkfmgr = Belle::Mdst_trk_fit_Manager::get_manager();
    for (std::vector<Belle::Mdst_trk_fit>::iterator it = trkfmgr.begin();
         it != trkfmgr.end(); ++it) {
      Belle::Mdst_trk_fit& trkf = *it;
      trkf.helix(2, scalei * trkf.helix(2));
      trkf.error(3, scalei * trkf.error(3));
      trkf.error(4, scalei * trkf.error(4));
      trkf.error(5, scalei2 * trkf.error(5));
      trkf.error(8, scalei * trkf.error(8));
      trkf.error(12, scalei * trkf.error(12));
    }
 
//Scale error matrices in mdst_daughters
    Belle::Mdst_vee_daughters_Manager& vdaumgr = Belle::Mdst_vee_daughters_Manager::get_manager();
    for (std::vector<Belle::Mdst_vee_daughters>::iterator it = vdaumgr.begin();
         it != vdaumgr.end(); ++it) {
      Belle::Mdst_vee_daughters& vdau = *it;
      vdau.helix_p(2, scalei * vdau.helix_p(2));
      vdau.error_p(3, scalei * vdau.error_p(3));
      vdau.error_p(4, scalei * vdau.error_p(4));
      vdau.error_p(5, scalei2 * vdau.error_p(5));
      vdau.error_p(8, scalei * vdau.error_p(8));
      vdau.error_p(12, scalei * vdau.error_p(12));
 
      vdau.helix_m(2, scalei * vdau.helix_m(2));
      vdau.error_m(3, scalei * vdau.error_m(3));
      vdau.error_m(4, scalei * vdau.error_m(4));
      vdau.error_m(5, scalei2 * vdau.error_m(5));
      vdau.error_m(8, scalei * vdau.error_m(8));
      vdau.error_m(12, scalei * vdau.error_m(12));
    }
  }

scale_momenta_set()

void scale_momenta_set ( const int  mode, const int  expno, const int  runno, double &  scale  )

private

Return scale factors for 2001 summer confs.

analyses, only for exp < 17

Definition at line 406 of file B2BIIFixMdstModule_trk.cc.

  {
//=====================================================================
 
    scale = 1.;
 
    if (mode == 1) {
      //factors for 2001 summer confs. analyses
      if (expno == 7) {scale = 1.001932; return;}
      if (expno == 9) {scale = 1.001413; return;}
      if (expno == 11) {scale = 1.001366; return;}
      //    if(expno==13) {scale = 1.000909; return;} //for '01 summer conf. papers; using up to run400
      if (expno == 13) {scale = 1.001460; return;} //updated factor using up to run1599
      if (expno >= 15) {B2ERROR("scale_momenta mode=1: not ready for exp >=15");}
    }
 
    if (mode == 2) {
      if (expno == 7) {
        if (runno >=   0 && runno <=  99) {scale = 1.00262126; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00253537; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00246555; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.0026452 ; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00290386; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00287753; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00266845; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00184472; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00200021; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00178485; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00196071; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00224453; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00209138; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.00145455; return;}
        if (runno >= 1400 && runno <= 1499) {scale = 1.00119243; return;}
        if (runno >= 1500 && runno <= 1599) {scale = 1.00115572; return;}
        if (runno >= 1600 && runno <= 1699) {scale = 1.00133916; return;}
        if (runno >= 1700 && runno <= 1799) {scale = 1.00186441; return;}
        if (runno >= 1800 && runno <= 1899) {scale = 1.00206786; return;}
        if (runno >= 1900 && runno <= 1999) {scale = 1.00184794; return;}
        if (runno >= 2000 && runno <= 2099) {scale = 1.00187219; return;}
        if (runno >= 2100 && runno <= 2199) {scale = 1.00214844; return;}
        if (runno >= 2200 && runno <= 2299) {scale = 1.00154502; return;}
        if (runno >= 2300 && runno <= 2399) {scale = 1.00179518; return;}
        if (runno >= 2400 && runno <= 2499) {scale = 1.00198983; return;}
        if (runno >= 2500 && runno <= 2599) {scale = 1.00219242; return;}
        if (runno >= 2600 && runno <= 2699) {scale = 1.00227363; return;}
        if (runno >= 2700 && runno <= 2799) {scale = 1.00202328; return;}
        if (runno >= 2800 && runno <= 2899) {scale = 1.00193147; return;}
      } else if (expno == 9) {
        if (runno >=   0 && runno <=  99) {scale = 1.00126754; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00119683; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00123771; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00142625; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00134481; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00131973; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00145963; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00161304; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00141795; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00137157; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00126209; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00147941; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00145555; return;}
      } else if (expno == 11) {
        if (runno >=   0 && runno <=  99) {scale = 1.00149576; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00155153; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.0013597 ; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00147504; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00138242; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00144554; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00136961; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00141443; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00136617; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00126262; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00133337; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00137906; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00127944; return;}
        //assume same factor for runno>=1300
        if (runno >= 1300 && runno <= 1399) {scale = 1.00127944; return;}
      } else if (expno == 13) {
        if (runno >=   0 && runno <=  99) {scale = 1.00110691; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00106123; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00109934; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00105759; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.000986887; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.000928764; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00103925; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.0010591 ; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00127043; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00154033; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00180656; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00202059; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00184308; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.00180153; return;}
        if (runno >= 1400 && runno <= 1499) {scale = 1.00189577; return;}
        if (runno >= 1500 && runno <= 1599) {scale = 1.00176026; return;}
        //assume same factor for runno>=1600
        if (runno >= 1600 && runno <= 1699) {scale = 1.00176026; return;}
 
      } else if (expno == 15) {
        if (runno >=   0 && runno <=  99) {scale = 1.00178719; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00205712; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00197622; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00191558; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00207795; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00191871; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00187917; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.0019573 ; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00196562; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00205215; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00200559; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00198568; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00212539; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.00199158; return;}
        if (runno >= 1400 && runno <= 1499) {scale = 1.00208257; return;}
 
      } else if (expno >= 17) { B2ERROR("scale_momenta mode=2: not ready for exp >=17");}
 
    }
    return;
  }

scale_momenta_set_v1()

void scale_momenta_set_v1 ( const int  mode, const int  expno, const int  runno, double &  scale  )

private

Return scale factors set_v1.

Definition at line 528 of file B2BIIFixMdstModule_trk.cc.

  {
//=====================================================================
 
    //for e15 mdst processed with b20020405
 
    scale = 1.;
 
    if (mode == 1) {
      B2ERROR("scale_momenta mode=1 not ready for exp " << expno);
      return;
    }
 
    if (mode == 2) {
      if (expno == 7) {
        if (runno >=   0 && runno <=  99) {scale = 1.00284313; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00272563; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00276953; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00286722; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00318492; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00304208; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00292413; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00201286; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00225237; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00210375; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00213222; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00253683; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00234023; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.00168421; return;}
        if (runno >= 1400 && runno <= 1499) {scale = 1.00136169; return;}
        if (runno >= 1500 && runno <= 1599) {scale = 1.00138431; return;}
        if (runno >= 1600 && runno <= 1699) {scale = 1.00154521; return;}
        if (runno >= 1700 && runno <= 1799) {scale = 1.00204405; return;}
        if (runno >= 1800 && runno <= 1899) {scale = 1.00223498; return;}
        if (runno >= 1900 && runno <= 1999) {scale = 1.00198975; return;}
        if (runno >= 2000 && runno <= 2099) {scale = 1.00201868; return;}
        if (runno >= 2100 && runno <= 2199) {scale = 1.00233875; return;}
        if (runno >= 2200 && runno <= 2299) {scale = 1.00175269; return;}
        if (runno >= 2300 && runno <= 2399) {scale = 1.00192858; return;}
        if (runno >= 2400 && runno <= 2499) {scale = 1.00217693; return;}
        if (runno >= 2500 && runno <= 2599) {scale = 1.00209337; return;}
        if (runno >= 2600 && runno <= 2699) {scale = 1.00244277; return;}
        if (runno >= 2700 && runno <= 2799) {scale = 1.00221485; return;}
        if (runno >= 2800 && runno <= 2899) {scale = 1.00214678; return;}
      } else if (expno == 9) {
        if (runno >=   0 && runno <=  99) {scale = 1.00127702; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00119957; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00132677; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.0014785 ; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00144872; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00145376; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00151659; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00167384; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00153754; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.0014984 ; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.0013764 ; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00145545; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.0017164 ; return;}
      } else if (expno == 11) {
        if (runno >=   0 && runno <=  99) {scale = 1.00159624; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00153365; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00143809; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00148495; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00143193; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00141905; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.0013992 ; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00148836; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00139019; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00151389; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00142988; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00143519; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00132641; return;}
      } else if (expno == 13) {
        if (runno >=   0 && runno <=  99) {scale = 1.00126317; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00118837; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00122276; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00113233; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00111677; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00100963; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.0011474 ; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00116245; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00139826; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.0017014 ; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00190706; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00214688; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00207336; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.00192885; return;}
        if (runno >= 1400 && runno <= 1499) {scale = 1.00196289; return;}
        if (runno >= 1500 && runno <= 1599) {scale = 1.00185017; return;}
        if (runno >= 1600 && runno <= 1699) {scale = 1.00191256; return;}
      } else if (expno == 15) {
        if (runno >=   0 && runno <=  99) {scale = 1.001953;   return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00210508; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.002139;   return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00207803; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.0022331;  return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00206421; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00205153; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00214664; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.0021456;  return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00221055; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00216472; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00214208; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00228874; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.00215047; return;}
        if (runno >= 1400 && runno <= 1499) {scale = 1.00219808; return;}
      } else if (expno == 17) {
        if (runno >=   0 && runno <=  99) {scale = 1.00216742; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00229433; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.0022749 ; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00231283; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00223654; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00236524; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00229312; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.002262  ; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00220104; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00215475; return;}
      } else if (expno == 19) {
        if (runno >=   0 && runno <=  99) {scale = 1.00227682; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00235795; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00251509; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.0022106 ; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00230963; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.002229  ; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00215402; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00217892; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.0022305 ; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.0021458 ; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00215792; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.0022667 ; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00219581; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.00218378; return;}
        if (runno >= 1400 && runno <= 1499) {scale = 1.00232172; return;}
        if (runno >= 1500 && runno <= 1599) {scale = 1.00217172; return;}
        if (runno >= 1600 && runno <= 1700) {scale = 1.00208639; return;}
        if (runno >= 1700 && runno <= 1799) {scale = 1.00188253; return;}
        if (runno >= 1800) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 21) {
        if (runno >=   0 && runno <=  99) {scale = 1.00228182; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00233446; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00238846; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00238061 ; return;}
        if (runno >= 400) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 23) {
        if (runno >=   0 && runno <=  99) {scale = 1.00216089; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.0019783; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00172162; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.0017938 ; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00177832 ; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.0017609 ; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.0017756 ; return;}
        if (runno >= 700) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 25) {
        if (runno >=   0 && runno <=  99) {scale = 1.00190068; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00199038; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00196171; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00200167; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.0019667 ; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00212109; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00202115; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00196456; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00200392; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00199495; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00202212; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00205312; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00200891; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.00196866; return;}
        if (runno >= 1400 && runno <= 1499) {scale = 1.0020257 ; return;}
        if (runno >= 1500 && runno <= 1599) {scale = 1.00196995; return;}
        if (runno >= 1600 && runno <= 1699) {scale = 1.00189232; return;}
        if (runno >= 1700 && runno <= 1799) {scale = 1.00179028; return;}
        if (runno >= 1800 && runno <= 1899) {scale = 1.00179459; return;}
        if (runno >= 1900 && runno <= 1999) {scale = 1.001762  ; return;}
        if (runno >= 2000 && runno <= 2099) {scale = 1.00179514; return;}
        if (runno >= 2100 && runno <= 2199) {scale = 1.00175211; return;}
        if (runno >= 2200) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 27) {
        if (runno >=   0 && runno <=  99) {scale = 1.00192647; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.0019717 ; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00196428; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00190998; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00204645; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.0020687 ; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00198209; return;}
 
        if (runno >= 700 && runno <= 800) {scale = 1.00187505; return;}
        if (runno >= 801 && runno <= 900) {scale = 1.00186805; return;}
        if (runno >= 901 && runno <= 1000) {scale = 1.00185576; return;}
        if (runno >= 1001 && runno <= 1079) {scale = 1.00177176; return;}
        if (runno >= 1080 && runno <= 1100) {scale = 1.00177184; return;}
        if (runno >= 1101 && runno <= 1200) {scale = 1.00174057; return;}
        if (runno >= 1201 && runno <= 1251) {scale = 1.00189649; return;}
        if (runno >= 1252 && runno <= 1300) {scale = 1.00189999; return;}
        if (runno >= 1301 && runno <= 1400) {scale = 1.0018818 ; return;}
        if (runno >= 1401 && runno <= 1500) {scale = 1.00200148; return;}
        if (runno >= 1501 && runno <= 1600) {scale = 1.00220137; return;}
        if (runno >= 1601 && runno <= 1632) {scale = 1.00217034; return;}
        if (runno >= 1633) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 31) {
        if (runno >=   0 && runno <=  99) {scale = 1.000373374; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.000684843; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.000741216; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00092523 ; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00104576 ; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00103982 ; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.0010601  ; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.000982515; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00101577 ; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.000972193; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00102536 ; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00127571 ; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00117938 ; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.00121084 ; return;}
        if (runno >= 1400 && runno <= 1499) {scale = 1.00125911 ; return;}
        if (runno >= 1500 && runno <= 1599) {scale = 1.0012907  ; return;}
        if (runno >= 1600 && runno <= 1699) {scale = 1.00125362 ; return;}
        if (runno >= 1700 && runno <= 1799) {scale = 1.00131686 ; return;}
        if (runno >= 1800) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 33) {
        if (runno >=   0 && runno <=  99) {scale = 1.00136407; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.0013701 ; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00156244; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00138501; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00148468; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.0013797 ; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00152298; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.001524  ; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.0014635 ; return;}
        if (runno >= 900) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 35) {
        if (runno >=   0 && runno <=  99) {scale = 1.00135452; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00135798; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00139979; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00136061; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00135776; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00118666; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.0011346 ; return;}
        if (runno >= 700) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 37) {
        if (runno >=   0 && runno <=  99) {scale = 1.00076522 ; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.000875154; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.000946763; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.000868444; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.000781409; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.000781171; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.000857962; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.000756082; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.000727355; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.000740236; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.000499606; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.000481664; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.000706924; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.000673738; return;}
        if (runno >= 1400 && runno <= 1499) {scale = 1.000662648; return;}
        if (runno >= 1500 && runno <= 1599) {scale = 1.000671198; return;}
        if (runno >= 1600 && runno <= 1699) {scale = 1.000604364; return;}
        if (runno >= 1700 && runno <= 1799) {scale = 1.000717372; return;}
        if (runno >= 1800 && runno <= 1899) {scale = 1.000512399; return;}
        if (runno >= 1900 && runno <= 1999) {scale = 1.000436958; return;}
        if (runno >= 2000) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 39) {
        if (runno >=   0 && runno <=  99) {scale = 1.000504342; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.000704544; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00094335 ; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.000928819; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.000884638; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00083459 ; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.000767604; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.000882219; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.000781437; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.000853168; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.000926527; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.000942882; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.000932802; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.000898892; return;}
        if (runno >= 1400) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 41) {
        if (runno >=   0 && runno <=  99) {scale = 1.00178427; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00188559; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.0019292 ; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00196352; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.0019078 ; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00185598; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00191314; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00179647; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00189776; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00184798; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00177963; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00176408; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00171371; return;}
        if (runno >= 1300) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 43) {
        if (runno >=   0 && runno <=  99) {scale = 1.00142307; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.000979455; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.000974458; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00103301; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.001111994; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00100635; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00105078; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00103593; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00105158; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.000955608; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00099199; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.0011439; return;}
        if (runno >= 1200) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 45) {
        if (runno >=   0 && runno <=  99) {scale = 1.00126261; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00138601; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00135372; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00141286; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00147822; return;}
        if (runno >= 500) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 47) {
        if (runno >=   0 && runno <=  99) {scale = 1.00156977; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00155614; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.0016555; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00167046; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00168705; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00169555; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00175653; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00174358; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00174004; return;}
        if (runno >= 900) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 49) {
        if (runno >=   0 && runno <=  99) {scale = 1.00158837; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00163884; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00160595; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00149916; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.0014956 ; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00156212; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00121868; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00134613; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00138985; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00129356; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00119732; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00121481; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00121108; return;}
        if (runno >= 1300) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 51) {
        if (runno >=   0 && runno <=  99) {scale = 1.00160252; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00156099; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00154760; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00146316; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00145525; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00134429; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00135581; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00134382; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00126462; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00130752; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00130452; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00131440; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00130864; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.00105290; return;}
        if (runno >= 1400 && runno <= 1499) {scale = 1.00126645; return;}
        if (runno >= 1500 && runno <= 1599) {scale = 1.00126383; return;}
        if (runno >= 1600 && runno <= 1699) {scale = 1.00141111; return;}
        if (runno >= 1700 && runno <= 1799) {scale = 1.00126220; return;}
        if (runno >= 1800 && runno <= 1899) {scale = 1.00105098; return;}
        if (runno >= 1900) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 53) {
        if (runno >=   0 && runno <=  99) {scale = 1.0011516; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00115527; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00114844; return;}
        if (runno >= 300) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 55) {
        if (runno >=   0 && runno <=  99) {scale = 1.00114284; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00111458; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00109686; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00119475; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00117818; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00115789; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00122261; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00118454; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00118042; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00124759; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00128055; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00119131; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00122238; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.00129538; return;}
        if (runno >= 1400 && runno <= 1499) {scale = 1.00130387; return;}
        if (runno >= 1500 && runno <= 1599) {scale = 1.00130858; return;}
        if (runno >= 1600 && runno <= 1699) {scale = 1.00111854; return;}
        if (runno >= 1700 && runno <= 1799) {scale = 1.00136261; return;}
        if (runno >= 1800) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 61) {
        if (runno >=   0 && runno <=  99) {scale = 1.0009992; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00113704; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00129904; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00141879; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00146707; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00150101; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00147322; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00153929; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00159997; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00164032; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00165878; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00163475; return;}
        if (runno >= 1200 && runno <= 1207) {scale = 1.00166193; return;}
        if (runno >= 1208 && runno <= 1299) {scale = 1.00235824; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.00242282; return;}
        if (runno >= 1400) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 65) {
        if (runno <= 999) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
        if (runno >= 1000 && runno <= 1336) {scale = 1.00145234; return;}
        if (runno >= 1336) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else
        B2ERROR("scale_momenta mode=2 not ready for exp " << expno);
    }
    return;
  }

scale_momenta_set_v2()

void scale_momenta_set_v2 ( const int  mode, const int  expno, const int  runno, double &  scale  )

private

Return scale factors set_v2.

Definition at line 1004 of file B2BIIFixMdstModule_trk.cc.

  {
//=====================================================================
 
    //for e15 mdst processed with b20020405
 
    scale = 1.;
 
    if (mode == 1) {
      B2ERROR("scale_momenta mode=1 not ready for exp " << expno);
      return;
    }
 
    if (mode == 2) {
      if (expno == 7) {
 
      } else if (expno == 9) {
 
      } else if (expno == 11) {
 
      } else if (expno == 13) {
 
      } else if (expno == 15) {
 
      } else if (expno == 17) {
 
      } else if (expno == 19) {
        B2ERROR("scale_momenta not ready for this exp,run "
                << expno << "," << runno);
 
      } else if (expno == 21) {
        B2ERROR("scale_momenta not ready for this exp,run "
                << expno << "," << runno);
 
      } else if (expno == 23) {
        B2ERROR("scale_momenta not ready for this exp,run "
                << expno << "," << runno);
 
      } else if (expno == 25) {
        B2ERROR("scale_momenta not ready for this exp,run "
                << expno << "," << runno);
 
      } else if (expno == 27) {
        B2ERROR("scale_momenta not ready for this exp,run "
                << expno << "," << runno);
 
      } else if (expno == 31) {
        if (runno >=   0 && runno <= 137) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
        if (runno >= 138 && runno <= 199) {scale = 1.000931841; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.000916397; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00108023 ; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00118662 ; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00117739 ; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00119542 ; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00110396 ; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00109603 ; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00112795 ; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00118365 ; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00142214 ; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00133150 ; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.00132831 ; return;}
        if (runno >= 1400 && runno <= 1499) {scale = 1.00136554 ; return;}
        if (runno >= 1500 && runno <= 1599) {scale = 1.00141187 ; return;}
        if (runno >= 1600 && runno <= 1699) {scale = 1.00136628 ; return;}
        if (runno >= 1700 && runno <= 1799) {scale = 1.00139273 ; return;}
        if (runno >= 1800) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 33) {
        if (runno >=   0 && runno <=  99) {scale = 1.00149319; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00150915; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00173040; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00150449; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00161519; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00151670; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00164347; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00164165; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00161369; return;}
        if (runno >= 900) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 35) {
        if (runno >=   0 && runno <=  99) {scale = 1.00147034; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00148523; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00153372; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00148256; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00144902; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00131501; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00126371; return;}
        if (runno >= 700) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 37) {
        if (runno >=   0 && runno <=  99) {scale = 1.000916277; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.001035310; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.001123403; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.001017718; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.000932890; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.000928479; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.000997938; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.000899663; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.000860910; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.000882920; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.000616966; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.000613018; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.000832338; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.000803640; return;}
        if (runno >= 1400 && runno <= 1499) {scale = 1.000770454; return;}
        if (runno >= 1500 && runno <= 1599) {scale = 1.000786608; return;}
        if (runno >= 1600 && runno <= 1699) {scale = 1.000718089; return;}
        if (runno >= 1700 && runno <= 1799) {scale = 1.000826042; return;}
        if (runno >= 1800 && runno <= 1899) {scale = 1.000638150; return;}
        if (runno >= 1900 && runno <= 1999) {scale = 1.000529173; return;}
        if (runno >= 2000) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 39) {
        if (runno >=   0 && runno <=  99) {scale = 1.000610857; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.000838583; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00105918 ; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00105841 ; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.001025523; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.000967373; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.000898585; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.001003199; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.000897072; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.000972551; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.001044677; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00106451 ; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00108570 ; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.00102381 ; return;}
        if (runno >= 1400) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 41) {
        if (runno >=   0 && runno <=  99) {scale = 1.00189378; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00197304; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00204049; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00205065; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00199205; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00195618; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00200889; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00190365; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00204192; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00196542; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00189706; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00187422; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00183714; return;}
        if (runno >= 1300) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 43) {
        if (runno >=   0 && runno <=  99) {scale = 1.00151737; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00110489; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00108144; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00114918; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00122723; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00111069; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00115667; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00113759; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00115609; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00105426; return;}
        //tentative for quality check of 5S mdst in 2009 Ang.-Sep.
        //      if (runno>=1000 && runno <=1034) {scale = 1.00099199; return;}
        //      if (runno>=1035 && runno <=1099) {scale = 1.00111222; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00111210; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00123104; return;}
        if (runno >= 1200) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 45) {
        if (runno >=   0 && runno <=  99) {scale = 1.00136477; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00151600; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00146757; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00153299; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00159018; return;}
        if (runno >= 500) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 47) {
        if (runno >=   0 && runno <=  99) {scale = 1.00166672; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00165120; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00175597; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00177319; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00179552; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00179413; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00186237; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00183016; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00184324; return;}
        if (runno >= 900) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 49) {
        if (runno >=   0 && runno <=  99) {scale = 1.00171645; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00177728; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00173301; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00162075; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00163153; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00168559; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00139227; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00148583; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00150403; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00142759; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00134573; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00138313; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00151369; return;}
        if (runno >= 1300) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 51) {
        if (runno >=   0 && runno <=  99) {scale = 1.00165035; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00161504; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00160162; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00152725; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00149943; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00141294; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00140154; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00140759; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00133671; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00136792; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00135251; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00138229; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00134938; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.00106240; return;}
        if (runno >= 1400 && runno <= 1499) {scale = 1.00132666; return;}
        if (runno >= 1500 && runno <= 1599) {scale = 1.00132654; return;}
        if (runno >= 1600 && runno <= 1699) {scale = 1.00146619; return;}
        if (runno >= 1700 && runno <= 1799) {scale = 1.00131902; return;}
        if (runno >= 1800 && runno <= 1899) {scale = 1.00114243; return;}
        if (runno >= 1900) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 53) {
        if (runno >=   0 && runno <=  99) {scale = 1.00125475; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00124954; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00122914; return;}
        if (runno >= 300) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 55) {
        if (runno >=   0 && runno <=  99) {scale = 1.00119352; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00117130; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00115825; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00125005; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00124720; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00122234; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00128709; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00123081; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00124198; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00131118; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00132496; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.00126186; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.00127849; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.00135312; return;}
        if (runno >= 1400 && runno <= 1499) {scale = 1.00136637; return;}
        if (runno >= 1500 && runno <= 1599) {scale = 1.00136270; return;}
        if (runno >= 1600 && runno <= 1699) {scale = 1.00118422; return;}
        if (runno >= 1700 && runno <= 1799) {scale = 1.00142667; return;}
        if (runno >= 1800) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 61) {
        if (runno >=   0 && runno <=  99) {scale = 1.00103013; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00116185; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00133560; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00145027; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00147949; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00151022; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.00150439; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.00155006; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.00162396; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.00168542; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.00168249; return;}
        if (runno >= 1100 && runno <= 1207) {scale = 1.00166891; return;}
        if (runno >= 1208 && runno <= 1299) {scale = 1.00249956; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.00255134; return;}
        if (runno >= 1400) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 63) {
        if (runno >=   0 && runno <=  99) {scale = 1.00129667; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00123725; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00126795; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00122458; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00116489; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00116968; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.000918379; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.0010429; return;}
        if (runno >= 800) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 65) {
        if (runno >=   0 && runno <=  99) {scale = 1.00116975; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.00111926; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.00110162; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.00109524; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.00106913; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.00110941; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.000897865; return;}
        if (runno >= 700 && runno <= 999) {scale = 1.00104385; return;}
        if (runno >= 1000 && runno <= 1299) {scale = 1.000876489; return;}
        if (runno >= 1000) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 67) {
        if (runno >=   0 && runno <= 199) {scale = 1.000826364; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.000836576; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.000904815; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.000966045; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.000988147; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.000988147; return;}
        if (runno >= 700 && runno <= 742) {scale = 1.000837414; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.000984865; return;}
        if (runno >= 1100 && runno <= 1123) {scale = 1.00105248 ; return;}
        if (runno >= 1124) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 69) {
        if (runno >=   0 && runno <=  99) {scale = 1.000791450; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.000891748; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.000866165; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.000838834; return;}
        if (runno >= 400 && runno <= 499) {scale = 1.000811878; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.000779810; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.000799086; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.000833797; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.000875203; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.000891998; return;}
        if (runno >= 1000 && runno <= 1099) {scale = 1.000921074; return;}
        if (runno >= 1100 && runno <= 1199) {scale = 1.000900829; return;}
        if (runno >= 1200 && runno <= 1299) {scale = 1.000958405; return;}
        if (runno >= 1300 && runno <= 1399) {scale = 1.000836841; return;}
        if (runno >= 1400) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 71) {
        if (runno >=   0 && runno <=  99) {scale = 1.000962999; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.001478932; return;}
        if (runno >= 200 && runno <= 300) {scale = 1.001486524; return;}
        if (runno >= 301 && runno <= 384) {scale = 1.001430843; return;}
        if (runno >= 385 && runno <= 499) {scale = 1.001505696; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.001523980; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.001480830; return;}
        if (runno >= 1000 && runno <= 1013) {scale = 1.001480830; return;}
        if (runno >= 2000 && runno <= 2099) {scale = 1.001617882; return;}
        if (runno >= 2100 && runno <= 2199) {scale = 1.001644395; return;}
        if (runno >= 2200 && runno <= 2299) {scale = 1.001722184; return;}
        if (runno >= 700 && runno <= 999) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
        if (runno >= 1014 && runno <= 1999) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
        if (runno >= 2299) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
      } else if (expno == 73) {
        if (runno >=   0 && runno <=  99) {scale = 1.000721587; return;}
        if (runno >= 100 && runno <= 199) {scale = 1.000707089; return;}
        if (runno >= 200 && runno <= 299) {scale = 1.000722517; return;}
        if (runno >= 300 && runno <= 399) {scale = 1.000722517; return;} //nodata
        if (runno >= 400 && runno <= 499) {scale = 1.000750776; return;}
        if (runno >= 500 && runno <= 599) {scale = 1.000729771; return;}
        if (runno >= 600 && runno <= 699) {scale = 1.000751190; return;}
        if (runno >= 700 && runno <= 799) {scale = 1.000702455; return;}
        if (runno >= 800 && runno <= 899) {scale = 1.000771074; return;}
        if (runno >= 900 && runno <= 999) {scale = 1.000868463; return;}
        if (runno >= 1000) {
          B2ERROR("scale_momenta not ready for this exp,run "
                  << expno << "," << runno);
        }
 
      } else
        B2ERROR("scale_momenta mode=2 not ready for exp " << expno);
    }
    return;
  }

set_primary_vertex()

int set_primary_vertex ( HepPoint3D &  v, CLHEP::HepSymMatrix &  ve  )

private

Set primary vertex assuming all tracks are pions.

Definition at line 2928 of file B2BIIFixMdstModule_trk.cc.

  {
 
    Belle::Evtvtx_primary_vertex_Manager& evtvtx_mgr
      = Belle::Evtvtx_primary_vertex_Manager::get_manager();
 
    Belle::Evtvtx_trk_Manager& evttrk_mgr = Belle::Evtvtx_trk_Manager::get_manager();
 
    Belle::Evtvtx_primary_vertex_Manager::iterator itvtx = evtvtx_mgr.begin();
    if (itvtx == evtvtx_mgr.end()) return 4;
 
    if (!(itvtx->quality() == 2 || itvtx->quality() == 3)) return 3;
 
    // TKECK fit primary vertex with our kfitter!
 
    Belle2::analysis::VertexFitKFit kv;
    HepPoint3D pvtx(itvtx->PV_x(), itvtx->PV_y(), itvtx->PV_z());
 
    kv.setInitialVertex(pvtx);
 
    unsigned int nchrgd(0);
    for (Belle::Evtvtx_trk_Manager::iterator i = evttrk_mgr.begin(); i != evttrk_mgr.end(); ++i) {
 
      const Belle::Mdst_charged& p = i->charged();
      if (p.trk().mhyp(2).nhits(3) < 2) continue;
      if (p.trk().mhyp(2).nhits(4) < 2) continue;
 
      int hyp = 2;
      const HepPoint3D pivot(p.trk().mhyp(hyp).pivot_x(),
                             p.trk().mhyp(hyp).pivot_y(),
                             p.trk().mhyp(hyp).pivot_z());
      CLHEP::HepVector  a(5);
      a[0] = p.trk().mhyp(hyp).helix(0);
      a[1] = p.trk().mhyp(hyp).helix(1);
      a[2] = p.trk().mhyp(hyp).helix(2);
      a[3] = p.trk().mhyp(hyp).helix(3);
      a[4] = p.trk().mhyp(hyp).helix(4);
      CLHEP::HepSymMatrix Ea(5, 0);
      Ea[0][0] = p.trk().mhyp(hyp).error(0);
      Ea[1][0] = p.trk().mhyp(hyp).error(1);
      Ea[1][1] = p.trk().mhyp(hyp).error(2);
      Ea[2][0] = p.trk().mhyp(hyp).error(3);
      Ea[2][1] = p.trk().mhyp(hyp).error(4);
      Ea[2][2] = p.trk().mhyp(hyp).error(5);
      Ea[3][0] = p.trk().mhyp(hyp).error(6);
      Ea[3][1] = p.trk().mhyp(hyp).error(7);
      Ea[3][2] = p.trk().mhyp(hyp).error(8);
      Ea[3][3] = p.trk().mhyp(hyp).error(9);
      Ea[4][0] = p.trk().mhyp(hyp).error(10);
      Ea[4][1] = p.trk().mhyp(hyp).error(11);
      Ea[4][2] = p.trk().mhyp(hyp).error(12);
      Ea[4][3] = p.trk().mhyp(hyp).error(13);
      Ea[4][4] = p.trk().mhyp(hyp).error(14);
      Belle::Helix helix(pivot, a, Ea);
 
      CLHEP::HepLorentzVector mom;
      CLHEP::HepSymMatrix err(7, 0);
      HepPoint3D pos(0, 0, 0);
      if (pivot.x() != 0. ||
          pivot.y() != 0. ||
          pivot.z() != 0.) {
        helix.pivot(HepPoint3D(0., 0., 0.));
        mom = helix.momentum(0., 0.13957f, pos, err);
      } else {
        mom = helix.momentum(0., 0.13957f, pos, err);
      }
 
      kv.addTrack(mom, pos, err, p.charge());
      ++nchrgd;
    }
 
    if (Belle::IpProfile::usable()) {
      // event depend. IP position and error matrix
      HepPoint3D ip_position = Belle::IpProfile::e_position();
      CLHEP::HepSymMatrix ip_err = Belle::IpProfile::e_position_err();
      kv.setIpProfile(ip_position, ip_err);
    }
    // Fit
    unsigned int err(1);
    if (nchrgd > 2 || (nchrgd > 0 && Belle::IpProfile::usable())) err = kv.doFit();
    if (err == 0) {
      epvtx = kv.getVertex();
      epvtx_err = kv.getVertexError();
    }
    return err;
 
    /*
    kvertexfitter kv;
 
    HepPoint3D pvtx(itvtx->PV_x(), itvtx->PV_y(), itvtx->PV_z());
 
    kv.initialVertex(pvtx);
 
    Ptype ptype_pi_plus("PI+");
    Ptype ptype_pi_minus("PI-");
 
    unsigned int nchrgd(0);
    for(Belle::Evtvtx_trk_Manager::iterator i = evttrk_mgr.begin();
    i != evttrk_mgr.end(); ++i){
      //      if(!good_charged(i->charged())) continue;
 
      if(i->charged().trk().mhyp(2).nhits(3) < 2) continue;
      if(i->charged().trk().mhyp(2).nhits(4) < 2) continue;
 
      Particle tmp(i->charged(),
       (i->charged().charge()>0.0 ? ptype_pi_plus : ptype_pi_minus));
      addTrack2fit(kv, tmp);
      ++nchrgd;
    }
 
    if(Belle::IpProfile::usable()){
 
      // event depend. IP position and error matrix
      HepPoint3D ip_position = Belle::IpProfile::e_position();
      HepSymMatrix ip_err = Belle::IpProfile::e_position_err();
      //    HepSymMatrix m_ip_err_b = Belle::IpProfile::e_position_err_b_life_smeared();
 
      // Add IP profile information
      addBeam2fit(kv, ip_position, ip_err);
    }
    // Fit
    unsigned int err(1);
    if(nchrgd>2||(nchrgd>0&&Belle::IpProfile::usable())) err = kv.fit();
    if(err==0) {
      epvtx = kv.get_vertex();
      epvtx_err = kv.get_err_vertex();
    }
    return err;
    */
  }

shift_tof()

void shift_tof ( const int  mode )

private

Shift tof times to account for residuals.

Based on scale_momenta code

Definition at line 59 of file B2BIIFixMdstModule_tof.cc.

  {
//===============================================================
// Shifts tof times to account for residuals.
// Based on scale_momenta code
//======================================================
//Check existence of belle_event
 
    Belle::Belle_event_Manager& evtmgr = Belle::Belle_event_Manager::get_manager();
    if (evtmgr.count() == 0) return;  //do nothing if no Belle::Belle_Event
 
    Belle::Mdst_event_add_Manager& addmgr = Belle::Mdst_event_add_Manager::get_manager();
    if (addmgr.count() == 0) return;  //do nothing if no Belle::Mdst_Event_Add
    if (addmgr[0].flag(4) != 0) return; //do nothing if already shifted
 
//check mode
    if (mode < 0 || mode > 2) {
      B2ERROR("shift_tof: invalid mode specified;");
      B2ERROR("mode must be 0, 1, 2");
      return;
    }
 
    int expmc = evtmgr[0].ExpMC();
    int expno = evtmgr[0].ExpNo();
    int runno = evtmgr[0].RunNo();
 
    if (expmc == 2) return;  //for now, apply no shift to MC
 
    addmgr[0].flag(4, 1);    //set flag
 
    // Loop over all charged tracks
 
    Belle::Mdst_charged_Manager& ChgMgr = Belle::Mdst_charged_Manager::get_manager();
    for (std::vector<Belle::Mdst_charged>::iterator it = ChgMgr.begin();
         it != ChgMgr.end(); ++it) {
      Belle::Mdst_charged& Chg = *it;
      if (Chg) {
        // Get mdst_tof table for the track
        Belle::Mdst_tof& Tof = Chg.tof();
        if (Tof) {
          // Get momentum and charge of track
          TVector3 Mom(Chg.px(), Chg.py(), Chg.pz());
          double pmom = Mom.Mag();
          double sgn = Chg.charge();
          // Loop over mass hypotheses
          for (int im = 0; im < 5; im++) {
            double shift = 0.;
            shift_tof_set(expno, runno, mode, im, pmom, sgn, shift);
            if (fabs(shift) < .005) continue;
            double ot = Tof.tof_exp(im);              //old t (expected)
            double odt = ot - Tof.tof();              //old dt
            double opid = Tof.pid(im);                //old pid
//         double ocl=Tof.cl(im);                    //old cl
            int ndf = (int)(Tof.ndf(im) + .001);      //ndf
            if (opid > 0. && opid < 1.) {
              double ct = ot + shift;                //corr t
              double cdt = ct - Tof.tof();           //corr dt
              double err = fabs(odt) / sqrt(-2.*log(opid)); //est error
              double cch = pow(cdt / err, 2);        //corr chisq
              double cpid = exp(-.5 * cch);          //corr pid
              double ccl = TMath::Prob(cch, ndf);    //corr cl
              Tof.tof_exp(im, ct);
              Tof.pid(im, cpid);
              Tof.cl(im, ccl);
            }
          }
        }
      }
    }
  }

shift_tof_set()

void shift_tof_set ( const int  expno, const int  runno, const int  mode, const int  im, const double  pmom, const double  sgn, double &  shift  )

private

Return time shifts for different exp.

Definition at line 129 of file B2BIIFixMdstModule_tof.cc.

  {
    static const double m[5] = {.000511, .10566, .13957, .49368, .93827};
    shift = 0.;
    double beta = pmom / sqrt(pmom * pmom + m[im] * m[im]);
    switch (expno) {
      case 7:
        if (mode == 1) {
          switch (im) {
            case 2:
              if (runno < 536) shift = 0.;
              else if (runno < 1440) shift = .5054 - .5216 * std::min(beta, .955);
              else shift = .8321 - .8648 * std::min(beta, .96);
              break;
            case 3:
              if (runno < 536) shift = -.0414 * exp(-pow(beta - .538, 2) / .0569);
              else if (runno < 1440) shift = -12.3 * exp(-pow(beta + .288, 2) / .1197);
              else shift = 0.;
              break;
            case 4:
              if (sgn > 0.) {
                shift = -.876 * exp(-pow(beta + .1818, 2) / .1947);
              } else {
                if (runno < 1440)
                  shift = .01 - .1028 * exp(-pow(beta - .4454, 2) / .00272);
                else shift = .01 - .064 * exp(-pow(beta - .4273, 2) / .00317);
              }
              break;
            default:
              break;
          } // end switch(im)
        } // end if(mode)
        break;
      case  9:
      case 11:
      case 13:
        if (mode == 1) {
          switch (im) {
            case 2:
              shift = 1.089 - 1.131 * std::min(beta, .955);
              break;
            case 4:
              if (sgn > 0.) shift = -.876 * exp(-pow(beta + .1818, 2) / .1947);
              else shift = .01 - .1028 * exp(-pow(beta - .4454, 2) / .00272);
              break;
            default:
              break;
          } // end switch(im)
        } // end if(mode)
        break;
      case 15:
        if (mode == 1) {
          switch (im) {
            case 2:
//      if(sgn>0.) shift=-4.73+9.853*beta-5.139*beta*beta;
//  The following stmt replaced the one above on 6/7/02 to remove the
// -16 ps value at beta=1.  MWP
              if (sgn > 0.) shift = -.0183 * exp(-pow(beta - .911, 2) / .00161);
              break;
            case 3:
              shift = -6.6 * exp(-beta / .1);
              break;
            case 4:
              if (sgn > 0.) shift = -.736 * exp(-pow(beta + .04158, 2) / .119);
              else shift = .02 - .1475 * exp(-pow(beta - .4267, 2) / .00249);
              break;
            default:
              break;
          }  // end switch(im)
        }  // end if(mode)
        break;
      case 17:
      case 19:                 //same corrections for Exps 17 and 19
        if (mode == 1) {
          switch (im) {
            case 4:
              if (sgn > 0.) shift = -.3259 * exp(-pow(beta - .1042, 2) / .0817);
              else shift = .02 - .1475 * exp(-pow(beta - .4267, 2) / .00249);
              break;
            default:
              break;
          } // end switch(im)
        } // end if(mode)
      default:
        break;
    }  // end switch(expno)
  }

smear_charged()

void smear_charged ( )

static

Smear tracks in Mdst_Charged.

Definition at line 3479 of file B2BIIFixMdstModule_trk.cc.

  {
//====================
    Belle::Mdst_charged_Manager& chgmgr = Belle::Mdst_charged_Manager::get_manager();
    for (std::vector<Belle::Mdst_charged>::iterator it = chgmgr.begin(); it != chgmgr.end(); ++it) {
      Belle::Mdst_charged& c = *it;
      Belle::Mdst_trk_fit& t = c.trk().mhyp(2);
 
      double kp = std::abs(t.helix(2));
      kp = std::max(kp, 1.e-10);
      kp = std::min(kp,  1.e10);
      c.px(-sin(t.helix(1)) / kp);
      c.py(cos(t.helix(1)) / kp);
      c.pz(t.helix(4) / kp);
    }
 
  }

smear_trk()

void smear_trk ( )

private

Apply track smearing (on MC)

Definition at line 3346 of file B2BIIFixMdstModule_trk.cc.

  {
//==========================
    int expNo = 0, runNo = 0, expmc = 1;
    Belle::Belle_event_Manager& evtMgr = Belle::Belle_event_Manager::get_manager();
    if (evtMgr.count()) {
      expNo  = evtMgr[0].ExpNo();
      runNo  = evtMgr[0].RunNo();
      expmc  = evtMgr[0].ExpMC();
    }
    if (expmc == 1) return; // nothing done for real data
 
    Belle::Mdst_event_add_Manager& addmgr = Belle::Mdst_event_add_Manager::get_manager();
    if (addmgr.count() == 0) {
      B2ERROR("No Belle::Mdst_event_add table -> kill the job");
      exit(-1);
    } else if (addmgr.count() >= 2) {
      if (addmgr[1].flag(1) != 0) return;  //do nothing if already smeared
    }
 
    int flag_err = addmgr[0].flag_error();
 
    static bool start = true;
    if (start) {
      start = false;
      B2INFO("smear_trk: MC events -> track smearing is ON\n");
    }
 
    double scale_mc[5] = {1, 1, 1, 1, 1};
    double scale_rd[5] = {1, 1, 1, 1, 1};
    double scale[5];
 
    Belle::Mdst_trk_fit_Manager& fitmgr = Belle::Mdst_trk_fit_Manager::get_manager();
    for (std::vector<Belle::Mdst_trk_fit>::iterator it = fitmgr.begin(); it != fitmgr.end(); ++it) {
      Belle::Mdst_trk_fit& fit = *it;
      if (fit.helix(2) == 0.) continue;
 
      double pt = 1. / fabs(fit.helix(2));
      double tanl = fit.helix(4);
 
      cal_scale_error(scale_mc, pt, tanl, 0, expNo, runNo);
      cal_scale_error(scale_rd, pt, tanl, 1, expNo, runNo);
      for (int i = 0; i < 5; i++) scale[i] = scale_rd[i] / scale_mc[i];
 
      if (flag_err == 0) scale_err_ms(fit, scale_mc);
      smear_trk_ms(fit, scale);
      scale_err_ms(fit, scale);
    }
 
    if (m_smear_trk == 2) smear_charged();
 
    //set flag indicating already-err-scaled
    addmgr[0].flag_error(1);
 
    //set flag indicating already-smeared
    if (addmgr.count() == 1) {
      Belle::Mdst_event_add& meadd = addmgr.add();
      meadd.flag(1, 1);
    } else if (addmgr.count() >= 2) {
      addmgr[1].flag(1, 1);
    }
 
  }

smear_trk_ms()

void smear_trk_ms ( Belle::Mdst_trk_fit &  fit, const double  scale[]  )

static

Smear MC tracks.

Definition at line 3433 of file B2BIIFixMdstModule_trk.cc.

  {
//====================================================
    const int n = 5;
    double a[n][n];
    int k = 0;
    for (int i = 0; i < n; i++) {
      for (int j = 0; j <= i; j++) {
        a[i][j] = fit.error(k) * (scale[i] * scale[j] - 1.0);
        if (i != j) a[j][i] = a[i][j];
        k++;
      }
    }
 
    double u[n][n];
    //int pozdef = 1;
    for (int j = 0; j < n; j++) {
      double s = a[j][j];
      for (int k2 = 0; k2 < j; k2++) s -= u[j][k2] * u[j][k2];
      if (s > 0) {
        u[j][j] = sqrt(s);
        for (int i = j + 1; i < n; i++) {
          s = a[i][j];
          for (int k3 = 0; k3 < j; k3++) s -= u[i][k3] * u[j][k3];
          u[i][j] = s / u[j][j];
        }
      } else {
        for (int i = j; i < n; i++) u[i][j] = 0;
        //pozdef = 0;
      }
    }
 
    double g[n];
    for (int i = 0; i < n; i++) g[i] = gRandom->Gaus();
    double x[n];
    for (int i = 0; i < n; i++) {
      x[i] = 0;
      if (u[i][i] > 0) {
        for (int j = 0; j <= i; j++) x[i] += u[i][j] * g[j];
      }
    }
    for (int i = 0; i < n; i++) fit.helix(i, fit.helix(i) + x[i]);
 
  }

terminate()

void terminate ( )

overridevirtual

Terminates the module.

Reimplemented from Module.

Definition at line 230 of file B2BIIFixMdstModule.cc.

  {
    Muid_term();
  }

vee_mass_nofit()

double vee_mass_nofit ( const Belle::Mdst_vee2 &  vee2, float  scale = 1.0  )

private

Calculates V0 mass with non-constraint fit results.

Definition at line 189 of file B2BIIFixMdstModule_trk.cc.

  {
//==========================================================
// Calculates V^0 mass with non-constraint fit results.
//==========================================================
 
    HepPoint3D vtx(vee2.vx(), vee2.vy(), vee2.vz());
 
    const double     pion_mass = 0.13956995;
    const double   proton_mass = 0.93827231;
    const double electron_mass = 0.000511;
 
    double massp(0.0), massm(0.0);
    if (1 == vee2.kind()) {
      massp = pion_mass;
      massm = pion_mass;
    } else if (2 == vee2.kind()) {
      massp = proton_mass;
      massm = pion_mass;
    } else if (3 == vee2.kind()) {
      massp = pion_mass;
      massm = proton_mass;
    } else if (4 == vee2.kind()) {
      massp = electron_mass;
      massm = electron_mass;
    }
 
//Calculate mass
//in case where decay vtx is outside of beam pipe
    //  if(BsCouTab(MDST_VEE_DAUGHTERS)) {
    if (vee2.daut()) {
 
      Belle::Mdst_vee_daughters& vdau = vee2.daut();
 
      CLHEP::HepVector a(5);
      a[0] = vdau.helix_p(0); a[1] = vdau.helix_p(1);
      a[2] = vdau.helix_p(2) / scale;
      a[3] = vdau.helix_p(3); a[4] = vdau.helix_p(4);
      Belle::Helix  helixp(vtx, a);
 
      a[0] = vdau.helix_m(0); a[1] = vdau.helix_m(1);
      a[2] = vdau.helix_m(2) / scale;
      a[3] = vdau.helix_m(3); a[4] = vdau.helix_m(4);
      Belle::Helix  helixm(vtx, a);
      // dout(Debugout::DDEBUG,"B2BIIFixMdst_trk") << "outside bp" << std::endl;
      CLHEP::HepLorentzVector v0 = helixp.momentum(0., massp) + helixm.momentum(0., massm);
      return v0.mag();
 
//in case where decay vtx is inside of beam pipe
    } else {
 
      Belle::Mdst_charged& chargedp = vee2.chgd(0);
      Belle::Mdst_trk&      trkp     = chargedp.trk();
      Belle::Mdst_trk_fit& trkfp    = trkp.mhyp(2);
      HepPoint3D pvtp(trkfp.pivot_x(), trkfp.pivot_y(), trkfp.pivot_z());
      CLHEP::HepVector a(5);
      a[0] = trkfp.helix(0); a[1] = trkfp.helix(1);
      a[2] = trkfp.helix(2);
      a[3] = trkfp.helix(3); a[4] = trkfp.helix(4);
      Belle::Helix  helixp(pvtp, a);
      helixp.bFieldZ(14.6);
      helixp.pivot(vtx);
      a = helixp.a();
      a[2] = a[2] / scale;
      helixp.a(a);
 
      Belle::Mdst_charged& chargedm = vee2.chgd(1);
      Belle::Mdst_trk&      trkm     = chargedm.trk();
      Belle::Mdst_trk_fit& trkfm    = trkm.mhyp(2);
      HepPoint3D pvtm(trkfm.pivot_x(), trkfm.pivot_y(), trkfm.pivot_z());
      a[0] = trkfm.helix(0); a[1] = trkfm.helix(1);
      a[2] = trkfm.helix(2);
      a[3] = trkfm.helix(3); a[4] = trkfm.helix(4);
      Belle::Helix  helixm(pvtm, a);
      helixm.bFieldZ(14.6);
      helixm.pivot(vtx);
      a = helixm.a();
      a[2] = a[2] / scale;
      helixm.a(a);
      // dout(Debugout::DDEBUG,"B2BIIFixMdst_trk") << "inside bp" << std::endl;
      CLHEP::HepLorentzVector v0 = helixp.momentum(0., massp) + helixm.momentum(0., massm);
      return v0.mag();
 
    }
 
  }

vfunc()

double vfunc ( const double  x, const double  x1, const double  yc, const double  a1, const double  a2  )

inline

vfunc

Definition at line 1519 of file B2BIIFixMdstModule_trk.cc.

  {
    return x < x1 ? (x - x1) * a1 + yc :
           (x - x1) * a2 + yc ;
  }

Variable Documentation

DUMMY_scale

const struct cal_scale_error_func_set_t DUMMY_scale

static

Initial value:

= {
    null_scale,
    null_scale,
    null_scale
  }

Dummy scale.

Definition at line 2615 of file B2BIIFixMdstModule_trk.cc.

EXP0723_scale

const struct cal_scale_error_func_set_t EXP0723_scale

static

Initial value:

= {
    cal_scale_error_EXP0723_hadronic_mc,
    cal_scale_error_EXP0723_cosmic_mc,
    cal_scale_error_EXP0723_cosmic_data,
  }

Scale error for Exp.7-23.

Definition at line 2513 of file B2BIIFixMdstModule_trk.cc.

EXP2527_scale

const struct cal_scale_error_func_set_t EXP2527_scale

static

Initial value:

= {
    cal_scale_error_EXP2527_hadronic_mc,
    cal_scale_error_EXP2527_cosmic_mc,
    cal_scale_error_EXP2527_cosmic_data
  }

Scale error for Exp.25-27.

Definition at line 2519 of file B2BIIFixMdstModule_trk.cc.

EXP31_scale

const struct cal_scale_error_func_set_t EXP31_scale

static

Initial value:

= {
    cal_scale_error_EXP31_hadronic_mc,
    cal_scale_error_EXP31_cosmic_mc,
    cal_scale_error_EXP31_cosmic_data
  }

Scale error for Exp.31.

Definition at line 2525 of file B2BIIFixMdstModule_trk.cc.

EXP33_scale

const struct cal_scale_error_func_set_t EXP33_scale

static

Initial value:

= {
    cal_scale_error_EXP33_hadronic_mc,
    cal_scale_error_EXP33_cosmic_mc,
    cal_scale_error_EXP33_cosmic_data
  }

Scale error for Exp.33.

Definition at line 2531 of file B2BIIFixMdstModule_trk.cc.

EXP35_scale

const struct cal_scale_error_func_set_t EXP35_scale

static

Initial value:

= {
    cal_scale_error_EXP35_hadronic_mc,
    cal_scale_error_EXP35_cosmic_mc,
    cal_scale_error_EXP35_cosmic_data
  }

Scale error for Exp.35.

Definition at line 2537 of file B2BIIFixMdstModule_trk.cc.

EXP37_scale

const struct cal_scale_error_func_set_t EXP37_scale

static

Initial value:

= {
    cal_scale_error_EXP37_hadronic_mc,
    cal_scale_error_EXP37_cosmic_mc,
    cal_scale_error_EXP37_cosmic_data
  }

Scale error for Exp.37.

Definition at line 2543 of file B2BIIFixMdstModule_trk.cc.

EXP3941_scale

const struct cal_scale_error_func_set_t EXP3941_scale

static

Initial value:

= {
    cal_scale_error_EXP3941_hadronic_mc,
    cal_scale_error_EXP3941_cosmic_mc,
    cal_scale_error_EXP3941_cosmic_data
  }

Scale error for Exp.39,41.

Definition at line 2549 of file B2BIIFixMdstModule_trk.cc.

EXP43_scale

const struct cal_scale_error_func_set_t EXP43_scale

static

Initial value:

= {
    cal_scale_error_EXP43_hadronic_mc,
    cal_scale_error_EXP43_cosmic_mc,
    cal_scale_error_EXP43_cosmic_data
  }

Scale error for Exp.43.

Definition at line 2555 of file B2BIIFixMdstModule_trk.cc.

EXP45_scale

const struct cal_scale_error_func_set_t EXP45_scale

static

Initial value:

= {
    cal_scale_error_EXP45_hadronic_mc,
    cal_scale_error_EXP45_cosmic_mc,
    cal_scale_error_EXP4547_cosmic_data
  }

Scale error for Exp.45.

Definition at line 2561 of file B2BIIFixMdstModule_trk.cc.

EXP47_scale

const struct cal_scale_error_func_set_t EXP47_scale

static

Initial value:

= {
    cal_scale_error_EXP47_hadronic_mc,
    cal_scale_error_EXP47_cosmic_mc,
    cal_scale_error_EXP4547_cosmic_data
  }

Scale error for Exp.47.

Definition at line 2567 of file B2BIIFixMdstModule_trk.cc.

EXP49_scale

const struct cal_scale_error_func_set_t EXP49_scale

static

Initial value:

= {
    cal_scale_error_EXP49_hadronic_mc,
    cal_scale_error_EXP49_cosmic_mc,
    cal_scale_error_EXP49_cosmic_data
  }

Scale error for Exp.49.

Definition at line 2573 of file B2BIIFixMdstModule_trk.cc.

EXP51_scale

const struct cal_scale_error_func_set_t EXP51_scale

static

Initial value:

= {
    cal_scale_error_EXP51_hadronic_mc,
    cal_scale_error_EXP51_cosmic_mc,
    cal_scale_error_EXP51_cosmic_data
  }

Scale error for Exp.51.

Definition at line 2579 of file B2BIIFixMdstModule_trk.cc.

EXP53_scale

const struct cal_scale_error_func_set_t EXP53_scale

static

Initial value:

= {
    cal_scale_error_EXP53_hadronic_mc,
    cal_scale_error_EXP53_cosmic_mc,
    cal_scale_error_EXP53_cosmic_data
  }

Scale error for Exp.53.

Definition at line 2585 of file B2BIIFixMdstModule_trk.cc.

EXP55_scale

const struct cal_scale_error_func_set_t EXP55_scale

static

Initial value:

= {
    cal_scale_error_EXP55_hadronic_mc,
    cal_scale_error_EXP55_cosmic_mc,
    cal_scale_error_EXP55_cosmic_data
  }

Scale error for Exp.55.

Definition at line 2591 of file B2BIIFixMdstModule_trk.cc.

EXP6165_scale

const struct cal_scale_error_func_set_t EXP6165_scale

static

Initial value:

= {
    cal_scale_error_EXP6165_hadronic_mc,
    cal_scale_error_EXP6165_cosmic_mc,
    cal_scale_error_EXP6165_cosmic_data
  }

Scale error for Exp.61-65.

Definition at line 2597 of file B2BIIFixMdstModule_trk.cc.

EXP67_scale

const struct cal_scale_error_func_set_t EXP67_scale

static

Initial value:

= {
    cal_scale_error_EXP67_hadronic_mc,
    cal_scale_error_EXP67_cosmic_mc,
    cal_scale_error_EXP67_cosmic_data
  }

Scale error for Exp.67.

Definition at line 2603 of file B2BIIFixMdstModule_trk.cc.

EXP6971_scale

const struct cal_scale_error_func_set_t EXP6971_scale

static

Initial value:

= {
    cal_scale_error_EXP6971_hadronic_mc,
    cal_scale_error_EXP6971_cosmic_mc,
    cal_scale_error_EXP6971_cosmic_data
  }

Scale error for Exp.69-71.

Definition at line 2609 of file B2BIIFixMdstModule_trk.cc.

s_benergy_value

double s_benergy_value = NOMINAL_ENERGY

static

Beam energy.

Definition at line 171 of file B2BIIFixMdstModule.h.

SE_Message_Level

int SE_Message_Level

static

Message level of scale_error().

0: none, 1: warning, 2: info

Definition at line 1434 of file B2BIIFixMdstModule_trk.cc.

SE_Reprocess_Version

int SE_Reprocess_Version = 0

static

Reprocess verison used in scale_error()

Definition at line 1435 of file B2BIIFixMdstModule_trk.cc.