3 #pragma link off all globals; 
    4 #pragma link off all classes; 
    5 #pragma link off all functions; 
    6 #pragma link C++ nestedclasses; 
    7 #pragma link C++ class Belle2::Particle+;  
    8 #pragma link C++ class Belle2::ParticleList+;  
    9 #pragma link C++ class Belle2::RestOfEvent+;  
   10 #pragma link C++ class Belle2::TagVertex+;  
   11 #pragma link C++ class Belle2::ContinuumSuppression+;  
   12 #pragma link C++ class Belle2::FlavorTaggerInfo+;  
   13 #pragma link C++ class Belle2::FlavorTaggerInfoMap+;  
   14 #pragma link C++ class Belle2::StringWrapper+;  
   15 #pragma link C++ class Belle2::EventShapeContainer+;  
   16 #pragma link C++ class Belle2::EventKinematics+;  
   17 #pragma link C++ class Belle2::TauPairDecay+;  
   18 #pragma link C++ class Belle2::ECLEnergyCloseToTrack+;  
   19 #pragma link C++ class Belle2::ECLTRGInformation+;  
   20 #pragma link C++ class Belle2::ECLTriggerCell+;  
   22 #pragma link C++ class vector<Belle2::Particle*>-; 
   23 #pragma link C++ class vector<const Belle2::Particle*>-; 
   25 #pragma link C++ class Belle2::ParticleExtraInfoMap+;  
   26 #pragma link C++ class Belle2::ParticleExtraInfoMap::IndexMap+;  
   27 #pragma link C++ class map<string, unsigned int>+;  
   28 #pragma link C++ class vector<map<string, unsigned int> >+;  
   29 #pragma link C++ class Belle2::Btube+;  
   30 #pragma link C++ class Eigen::Matrix<double,3,1,0,3,1>+;  
   31 #pragma link C++ class Eigen::PlainObjectBase<Eigen::Matrix<double,3,1,0,3,1> >+;  
   32 #pragma link C++ class Eigen::EigenBase<Eigen::Matrix<double,3,1,0,3,1> >+;  
   33 #pragma link C++ class Eigen::MatrixBase<Eigen::Matrix<double,3,1,0,3,1> >+;  
   34 #pragma link C++ class Eigen::DenseStorage<double,3,3,1,0>+;  
   35 #pragma link C++ class Eigen::DenseBase<Eigen::Matrix<double,3,1,0,3,1> >+;  
   36 #pragma link C++ class Eigen::DenseCoeffsBase<Eigen::Matrix<double,3,1,0,3,1>,0>+;  
   37 #pragma link C++ class Eigen::DenseCoeffsBase<Eigen::Matrix<double,3,1,0,3,1>,1>+;  
   38 #pragma link C++ class Eigen::DenseCoeffsBase<Eigen::Matrix<double,3,1,0,3,1>,3>+;  
   39 #pragma link C++ class Eigen::internal::plain_array<double,3,0,0>+;  
   45   sourceClass="Belle2::Particle"                                                      \
 
   46   source="float m_momentumScale"                                                      \
 
   48   targetClass="Belle2::Particle"                                                      \
 
   49   target="m_momentumScalingFactor"                                                    \
 
   50   code="{m_momentumScalingFactor = onfile.m_momentumScale;}"                          \
 
   56   sourceClass="Belle2::Particle"                                                      \
 
   57   source="Belle2::Particle::EParticleSourceObject m_particleType"                     \
 
   59   targetClass="Belle2::Particle"                                                      \
 
   60   target="m_particleSource"                                                           \
 
   61   code="{if (onfile.m_particleType == 4)                                              \
 
   62            m_particleSource = Belle2::Particle::EParticleSourceObject::c_MCParticle;  \
 
   63          else if (onfile.m_particleType == 5)                                         \
 
   64            m_particleSource = Belle2::Particle::EParticleSourceObject::c_Composite;   \
 
   65          else m_particleSource = onfile.m_particleType;                               \
 
   72   sourceClass="Belle2::TagVertex"               \
 
   73   source="float m_MCdeltaT"                     \
 
   75   targetClass="Belle2::TagVertex"               \
 
   77   code="{m_mcDeltaT = onfile.m_MCdeltaT;}"      \
 
   81   sourceClass="Belle2::TagVertex"               \
 
   82   source="TVector3 m_MCtagV"                    \
 
   84   targetClass="Belle2::TagVertex"               \
 
   86   code="{m_mcTagV = onfile.m_MCtagV;}"          \
 
   91   sourceClass="Belle2::TagVertex"                              \
 
   92   source="TMatrixFSym m_tagVertexErrMatrix"                    \
 
   94   targetClass="Belle2::TagVertex"                              \
 
   95   target="m_tagVertexErrMatrix"                                \
 
   96   code="{m_tagVertexErrMatrix = onfile.m_tagVertexErrMatrix;}" \
 
  101   sourceClass="Belle2::TagVertex"               \
 
  102   source="TVector3 m_tagVertex"                 \
 
  104   targetClass="Belle2::TagVertex"               \
 
  105   target="m_tagVertex"                          \
 
  106   code="{m_tagVertex = ROOT::Math::XYZVector(onfile.m_tagVertex.X(), onfile.m_tagVertex.Y(), onfile.m_tagVertex.Z());}"    \
 
  111   sourceClass="Belle2::TagVertex"               \
 
  112   source="TVector3 m_mcTagV"                    \
 
  114   targetClass="Belle2::TagVertex"               \
 
  116   code="{m_mcTagV = ROOT::Math::XYZVector(onfile.m_mcTagV.X(), onfile.m_mcTagV.Y(), onfile.m_mcTagV.Z());}"          \
 
  121   sourceClass="Belle2::TagVertex"                           \
 
  122   source="TVector3 m_constraintCenter"                      \
 
  124   targetClass="Belle2::TagVertex"                           \
 
  125   target="m_constraintCenter"                               \
 
  126   code="{m_constraintCenter = ROOT::Math::XYZVector(onfile.m_constraintCenter.X(), onfile.m_constraintCenter.Y(), onfile.m_constraintCenter.Z());}"  \
 
  133   sourceClass="Belle2::EventKinematics"        \
 
  134   source="bool m_builtFromMC"                  \
 
  136   targetClass="Belle2::EventKinematics"        \
 
  137   target="m_builtFromMC"                       \
 
  138   code="{m_builtFromMC = false;}"              \
 
  143   sourceClass="Belle2::EventKinematics"                   \
 
  144   source="TVector3 m_missingMomentum"                     \
 
  146   targetClass="Belle2::EventKinematics"                   \
 
  147   target="m_missingMomentum"                              \
 
  148   code="{m_missingMomentum = ROOT::Math::XYZVector(onfile.m_missingMomentum.X(), onfile.m_missingMomentum.Y(), onfile.m_missingMomentum.Z());}"  \
 
  153   sourceClass="Belle2::EventKinematics"                        \
 
  154   source="TVector3 m_missingMomentumCMS"                       \
 
  156   targetClass="Belle2::EventKinematics"                        \
 
  157   target="m_missingMomentumCMS"                                \
 
  158   code="{m_missingMomentumCMS = ROOT::Math::XYZVector(onfile.m_missingMomentumCMS.X(), onfile.m_missingMomentumCMS.Y(), onfile.m_missingMomentumCMS.Z());}" \
 
  165   sourceClass="Belle2::RestOfEvent"            \
 
  166   source="bool m_useKLMEnergy"                 \
 
  168   targetClass="Belle2::RestOfEvent"            \
 
  169   target="m_useKLMEnergy"                      \
 
  170   code="{m_useKLMEnergy = false;}"             \
 
  177   sourceClass="Belle2::ContinuumSuppression"  \
 
  178   source="TVector3 m_thrustO"                 \
 
  180   targetClass="Belle2::ContinuumSuppression"  \
 
  182   code="{m_thrustO = ROOT::Math::XYZVector(onfile.m_thrustO.X(), onfile.m_thrustO.Y(), onfile.m_thrustO.Z());}"      \
 
  185   sourceClass="Belle2::ContinuumSuppression"  \
 
  186   source="TVector3 m_thrustB"                 \
 
  188   targetClass="Belle2::ContinuumSuppression"  \
 
  190   code="{m_thrustB = ROOT::Math::XYZVector(onfile.m_thrustB.X(), onfile.m_thrustB.Y(), onfile.m_thrustB.Z());}"      \
 
  197   sourceClass="Belle2::EventShapeContainer"     \
 
  198   source="TVector3 m_thrustAxis"                \
 
  200   targetClass="Belle2::EventShapeContainer"     \
 
  201   target="m_thrustAxis"                         \
 
  202   code="{m_thrustAxis = ROOT::Math::XYZVector(onfile.m_thrustAxis.X(), onfile.m_thrustAxis.Y(), onfile.m_thrustAxis.Z());}"  \
 
  207   sourceClass="Belle2::EventShapeContainer"             \
 
  208   source="TVector3 m_spherocityAxis"                    \
 
  210   targetClass="Belle2::EventShapeContainer"             \
 
  211   target="m_spherocityAxis"                             \
 
  212   code="{m_spherocityAxis = ROOT::Math::XYZVector(onfile.m_spherocityAxis.X(), onfile.m_spherocityAxis.Y(), onfile.m_spherocityAxis.Z());}"  \
 
  217   sourceClass="Belle2::EventShapeContainer"                                                           \
 
  218   source="TVector3 m_sphericityEigenvector[3]"                                                        \
 
  220   targetClass="Belle2::EventShapeContainer"                                                           \
 
  221   target="m_sphericityEigenvector"                                                                    \
 
  222   code="{for (int i = 0; i < 3; i++)                                                                  \
 
  223            m_sphericityEigenvector[i] = ROOT::Math::XYZVector(onfile.m_sphericityEigenvector[i].X(),  \
 
  224                                                               onfile.m_sphericityEigenvector[i].Y(),  \
 
  225                                                               onfile.m_sphericityEigenvector[i].Z()); \
 
  231   sourceClass="Belle2::EventShapeContainer"                                                                   \
 
  232   source="TLorentzVector m_forwardHemisphere4Momentum"                                                        \
 
  234   targetClass="Belle2::EventShapeContainer"                                                                   \
 
  235   target="m_forwardHemisphere4Momentum"                                                                       \
 
  236   code="{m_forwardHemisphere4Momentum = ROOT::Math::PxPyPzEVector(onfile.m_forwardHemisphere4Momentum.Px(),   \
 
  237                                                                   onfile.m_forwardHemisphere4Momentum.Py(),   \
 
  238                                                                   onfile.m_forwardHemisphere4Momentum.Pz(),   \
 
  239                                                                   onfile.m_forwardHemisphere4Momentum.E());}" \
 
  244   sourceClass="Belle2::EventShapeContainer"                                                                     \
 
  245   source="TLorentzVector m_backwardHemisphere4Momentum"                                                         \
 
  247   targetClass="Belle2::EventShapeContainer"                                                                     \
 
  248   target="m_backwardHemisphere4Momentum"                                                                        \
 
  249   code="{m_backwardHemisphere4Momentum = ROOT::Math::PxPyPzEVector(onfile.m_backwardHemisphere4Momentum.Px(),   \
 
  250                                                                    onfile.m_backwardHemisphere4Momentum.Py(),   \
 
  251                                                                    onfile.m_backwardHemisphere4Momentum.Pz(),   \
 
  252                                                                    onfile.m_backwardHemisphere4Momentum.E());}" \
 
  257   sourceClass="Belle2::ParticleList"             \
 
  258   source="std::string m_thisListName; int m_pdg" \
 
  260   targetClass="Belle2::ParticleList"             \
 
  261   target="m_isReserved"                          \
 
  262   code="{std::string label = onfile.m_thisListName.substr(onfile.m_thisListName.find_first_of(':')+1);                                                 \
 
  263          if ((Belle2::Const::finalStateParticlesSet.contains(Belle2::Const::ParticleType(abs(onfile.m_pdg))) and label == \"all\") or label == \"V0\") \
 
  264            m_isReserved = true;                                                                                                                        \
 
  266            m_isReserved = false;}"                                                                                                                     \