10#include <analysis/variables/MetaVariables.h>
11#include <analysis/variables/MCTruthVariables.h>
13#include <analysis/VariableManager/Utility.h>
14#include <analysis/dataobjects/Particle.h>
15#include <analysis/dataobjects/ParticleList.h>
16#include <analysis/dataobjects/EventKinematics.h>
17#include <analysis/utility/PCmsLabTransform.h>
18#include <analysis/utility/ReferenceFrame.h>
19#include <analysis/utility/EvtPDLUtil.h>
20#include <analysis/utility/ParticleCopy.h>
21#include <analysis/utility/ValueIndexPairSorting.h>
22#include <analysis/ClusterUtility/ClusterUtils.h>
23#include <analysis/variables/VariableFormulaConstructor.h>
25#include <framework/logging/Logger.h>
26#include <framework/datastore/StoreArray.h>
27#include <framework/datastore/StoreObjPtr.h>
28#include <framework/dataobjects/EventExtraInfo.h>
29#include <framework/utilities/Conversion.h>
30#include <framework/utilities/MakeROOTCompatible.h>
31#include <framework/gearbox/Const.h>
33#include <mdst/dataobjects/Track.h>
34#include <mdst/dataobjects/MCParticle.h>
35#include <mdst/dataobjects/ECLCluster.h>
36#include <mdst/dataobjects/TrackFitResult.h>
38#include <boost/algorithm/string.hpp>
46#include <TDatabasePDG.h>
47#include <Math/Vector4D.h>
48#include <Math/VectorUtil.h>
59 if (arguments.size() == 1) {
61 auto func = [var](
const Particle * particle) ->
double {
62 UseReferenceFrame<RestFrame> frame(particle);
63 double result = std::get<double>(var->function(particle));
68 B2FATAL(
"Wrong number of arguments for meta function useRestFrame");
74 if (arguments.size() == 1) {
76 auto func = [var](
const Particle * particle) ->
double {
77 UseReferenceFrame<CMSFrame> frame;
78 double result = std::get<double>(var->function(particle));
83 B2FATAL(
"Wrong number of arguments for meta function useCMSFrame");
89 if (arguments.size() == 1) {
91 auto func = [var](
const Particle * particle) ->
double {
92 UseReferenceFrame<LabFrame> frame;
93 double result = std::get<double>(var->function(particle));
98 B2FATAL(
"Wrong number of arguments for meta function useLabFrame");
104 if (arguments.size() == 2) {
107 int daughterIndexTagB = 0;
110 }
catch (std::invalid_argument&) {
111 B2FATAL(
"Second argument of useTagSideRecoilRestFrame meta function must be integer!");
114 auto func = [var, daughterIndexTagB](
const Particle * particle) ->
double {
115 if (particle->getPDGCode() != 300553)
117 B2ERROR(
"Variable should only be used on a Upsilon(4S) Particle List!");
122 ROOT::Math::PxPyPzEVector pSigB = T.getBeamFourMomentum() - particle->getDaughter(daughterIndexTagB)->get4Vector();
123 Particle tmp(pSigB, -particle->getDaughter(daughterIndexTagB)->getPDGCode());
125 UseReferenceFrame<RestFrame> frame(&tmp);
126 double result = std::get<double>(var->function(particle));
132 B2FATAL(
"Wrong number of arguments for meta function useTagSideRecoilRestFrame");
138 if (arguments.size() == 2) {
140 std::string listName = arguments[1];
141 auto func = [var, listName](
const Particle * particle) ->
double {
142 StoreObjPtr<ParticleList> list(listName);
143 unsigned listSize = list->getListSize();
147 B2WARNING(
"The selected ParticleList contains more than 1 Particles in this event. The variable useParticleRestFrame will use only the first candidate, and the result may not be the expected one."
148 << LogVar(
"ParticleList", listName)
149 << LogVar(
"Number of candidates in the list", listSize));
150 const Particle* p = list->getParticle(0);
151 UseReferenceFrame<RestFrame> frame(p);
152 double result = std::get<double>(var->function(particle));
157 B2FATAL(
"Wrong number of arguments for meta function useParticleRestFrame.");
163 if (arguments.size() == 2) {
165 std::string listName = arguments[1];
166 auto func = [var, listName](
const Particle * particle) ->
double {
167 StoreObjPtr<ParticleList> list(listName);
168 unsigned listSize = list->getListSize();
172 B2WARNING(
"The selected ParticleList contains more than 1 Particles in this event. The variable useParticleRestFrame will use only the first candidate, and the result may not be the expected one."
173 << LogVar(
"ParticleList", listName)
174 << LogVar(
"Number of candidates in the list", listSize));
175 const Particle* p = list->getParticle(0);
177 ROOT::Math::PxPyPzEVector recoil = T.getBeamFourMomentum() - p->get4Vector();
179 Particle pRecoil(recoil, 0);
180 pRecoil.setVertex(particle->getVertex());
181 UseReferenceFrame<RestFrame> frame(&pRecoil);
182 double result = std::get<double>(var->function(particle));
187 B2FATAL(
"Wrong number of arguments for meta function useParticleRestFrame.");
193 if (arguments.size() >= 2) {
195 auto func = [var, arguments](
const Particle * particle) ->
double {
198 ROOT::Math::PxPyPzEVector pSum(0, 0, 0, 0);
200 for (
unsigned int i = 1; i < arguments.size(); i++)
202 auto generalizedIndex = arguments[i];
203 const Particle* dauPart = particle->getParticleFromGeneralizedIndexString(generalizedIndex);
205 pSum += dauPart->get4Vector();
209 Particle tmp(pSum, 0);
210 UseReferenceFrame<RestFrame> frame(&tmp);
211 double result = std::get<double>(var->function(particle));
216 B2FATAL(
"Wrong number of arguments for meta function useDaughterRestFrame.");
222 if (arguments.size() >= 2) {
224 auto func = [var, arguments](
const Particle * particle) ->
double {
227 ROOT::Math::PxPyPzEVector pSum(0, 0, 0, 0);
229 for (
unsigned int i = 1; i < arguments.size(); i++)
231 auto generalizedIndex = arguments[i];
232 const Particle* dauPart = particle->getParticleFromGeneralizedIndexString(generalizedIndex);
234 pSum += dauPart->get4Vector();
239 ROOT::Math::PxPyPzEVector recoil = T.getBeamFourMomentum() - pSum;
241 Particle pRecoil(recoil, 0);
242 UseReferenceFrame<RestFrame> frame(&pRecoil);
243 double result = std::get<double>(var->function(particle));
248 B2FATAL(
"Wrong number of arguments for meta function useDaughterRecoilRestFrame.");
254 if (arguments.size() == 1) {
256 auto func = [var](
const Particle * particle) ->
double {
257 int index = ancestorBIndex(particle);
259 StoreArray<MCParticle> mcparticles;
260 Particle temp(mcparticles[index]);
261 UseReferenceFrame<RestFrame> frame(&temp);
262 double result = std::get<double>(var->function(particle));
267 B2FATAL(
"Wrong number of arguments for meta function useMCancestorBRestFrame.");
273 if (arguments.size() == 1) {
274 auto extraInfoName = arguments[0];
275 auto func = [extraInfoName](
const Particle * particle) ->
double {
276 if (particle ==
nullptr)
278 B2WARNING(
"Returns NaN because the particle is nullptr! If you want EventExtraInfo variables, please use eventExtraInfo() instead");
281 if (particle->hasExtraInfo(extraInfoName))
283 return particle->getExtraInfo(extraInfoName);
291 B2FATAL(
"Wrong number of arguments for meta function extraInfo");
297 if (arguments.size() == 1) {
298 auto extraInfoName = arguments[0];
299 auto func = [extraInfoName](
const Particle*) ->
double {
300 StoreObjPtr<EventExtraInfo> eventExtraInfo;
301 if (not eventExtraInfo.isValid())
303 if (eventExtraInfo->hasExtraInfo(extraInfoName))
305 return eventExtraInfo->getExtraInfo(extraInfoName);
313 B2FATAL(
"Wrong number of arguments for meta function extraInfo");
319 if (arguments.size() == 1) {
322 auto func = [var, key](
const Particle*) ->
double {
324 StoreObjPtr<EventExtraInfo> eventExtraInfo;
325 if (not eventExtraInfo.isValid())
326 eventExtraInfo.create();
327 if (eventExtraInfo->hasExtraInfo(key))
329 return eventExtraInfo->getExtraInfo(key);
333 auto var_result = var->function(
nullptr);
334 if (std::holds_alternative<double>(var_result)) {
335 value = std::get<double>(var_result);
336 }
else if (std::holds_alternative<int>(var_result)) {
337 return std::get<int>(var_result);
338 }
else if (std::holds_alternative<bool>(var_result)) {
339 return std::get<bool>(var_result);
341 eventExtraInfo->addExtraInfo(key, value);
347 B2FATAL(
"Wrong number of arguments for meta function eventCached");
353 if (arguments.size() == 1) {
356 auto func = [var, key](
const Particle * particle) ->
double {
358 if (particle->hasExtraInfo(key))
360 return particle->getExtraInfo(key);
363 double value = std::get<double>(var->function(particle));
371 const_cast<Particle*
>(particle)->addExtraInfo(key, value);
377 B2FATAL(
"Wrong number of arguments for meta function particleCached");
386 if (arguments.size() != 1) B2FATAL(
"Wrong number of arguments for meta function formula");
387 FormulaParser<VariableFormulaConstructor> parser;
389 return parser.parse(arguments[0]);
390 }
catch (std::runtime_error& e) {
397 if (arguments.size() <= 1) {
399 std::string cutString;
400 if (arguments.size() == 1)
401 cutString = arguments[0];
403 auto func = [cut](
const Particle*) ->
int {
405 int number_of_tracks = 0;
406 StoreArray<Track> tracks;
407 for (
const auto& track : tracks)
409 const TrackFitResult* trackFit = track.getTrackFitResultWithClosestMass(
Const::pion);
410 if (!trackFit)
continue;
411 if (trackFit->getChargeSign() == 0) {
415 if (cut->check(&particle))
420 return number_of_tracks;
425 B2FATAL(
"Wrong number of arguments for meta function nCleanedTracks");
431 if (arguments.size() <= 1) {
433 std::string cutString;
434 if (arguments.size() == 1)
435 cutString = arguments[0];
437 auto func = [cut](
const Particle*) ->
int {
439 int number_of_clusters = 0;
440 StoreArray<ECLCluster> clusters;
441 for (
const auto& cluster : clusters)
447 Particle particle(&cluster);
448 if (cut->check(&particle))
449 number_of_clusters++;
452 return number_of_clusters;
457 B2FATAL(
"Wrong number of arguments for meta function nCleanedECLClusters");
463 if (arguments.size() == 1) {
464 std::string cutString = arguments[0];
466 auto func = [cut](
const Particle * particle) ->
bool {
467 if (cut->check(particle))
474 B2FATAL(
"Wrong number of arguments for meta function passesCut");
480 if (arguments.size() == 1) {
481 std::string cutString = arguments[0];
483 auto func = [cut](
const Particle*) ->
bool {
484 if (cut->check(
nullptr))
491 B2FATAL(
"Wrong number of arguments for meta function passesEventCut");
497 if (arguments.size() == 2) {
501 }
catch (std::invalid_argument&) {
502 B2FATAL(
"The first argument of varFor meta function must be a positive integer!");
505 auto func = [pdgCode, var](
const Particle * particle) ->
double {
506 if (std::abs(particle->getPDGCode()) == std::abs(pdgCode))
508 auto var_result = var->function(particle);
509 if (std::holds_alternative<double>(var_result)) {
510 return std::get<double>(var_result);
511 }
else if (std::holds_alternative<int>(var_result)) {
512 return std::get<int>(var_result);
513 }
else if (std::holds_alternative<bool>(var_result)) {
514 return std::get<bool>(var_result);
520 B2FATAL(
"Wrong number of arguments for meta function varFor");
526 if (arguments.size() == 1) {
528 auto func = [var](
const Particle * particle) ->
double {
529 if (particle->getMCParticle())
534 auto var_result = var->function(particle);
535 if (std::holds_alternative<double>(var_result)) {
536 return std::get<double>(var_result);
537 }
else if (std::holds_alternative<int>(var_result)) {
538 return std::get<int>(var_result);
539 }
else if (std::holds_alternative<bool>(var_result)) {
540 return std::get<bool>(var_result);
547 B2FATAL(
"Wrong number of arguments for meta function varForMCGen");
553 if (arguments.size() == 1) {
554 std::string listName = arguments[0];
555 auto func = [listName](
const Particle * particle) ->
int {
558 StoreObjPtr<ParticleList> listOfParticles(listName);
560 if (!(listOfParticles.isValid())) B2FATAL(
"Invalid Listname " << listName <<
" given to nParticlesInList");
562 return listOfParticles->getListSize();
567 B2FATAL(
"Wrong number of arguments for meta function nParticlesInList");
574 if (arguments.size() != 1) {
575 B2FATAL(
"Wrong number of arguments for isInList");
577 auto listName = arguments[0];
579 auto func = [listName](
const Particle * particle) ->
bool {
582 StoreObjPtr<ParticleList> list(listName);
583 if (!(list.isValid()))
585 B2FATAL(
"Invalid Listname " << listName <<
" given to isInList");
589 return list->contains(particle);
598 if (arguments.size() != 1) {
599 B2FATAL(
"Wrong number of arguments for sourceObjectIsInList");
601 auto listName = arguments[0];
603 auto func = [listName](
const Particle * particle) ->
int {
606 StoreObjPtr<ParticleList> list(listName);
607 if (!(list.isValid()))
609 B2FATAL(
"Invalid Listname " << listName <<
" given to sourceObjectIsInList");
615 if (particlesource == Particle::EParticleSourceObject::c_Composite
616 or particlesource == Particle::EParticleSourceObject::c_Undefined)
622 for (
unsigned i = 0; i < list->getListSize(); ++i)
624 Particle* iparticle = list->getParticle(i);
625 if (particle->getMdstSource() == iparticle->getMdstSource())
637 if (arguments.size() != 1) {
638 B2FATAL(
"Wrong number of arguments for mcParticleIsInMCList");
640 auto listName = arguments[0];
642 auto func = [listName](
const Particle * particle) ->
bool {
645 StoreObjPtr<ParticleList> list(listName);
646 if (!(list.isValid()))
647 B2FATAL(
"Invalid Listname " << listName <<
" given to mcParticleIsInMCList");
650 const MCParticle* mcp = particle->getMCParticle();
651 if (mcp ==
nullptr)
return false;
654 for (
unsigned i = 0; i < list->getListSize(); ++i)
656 const MCParticle* imcp = list->getParticle(i)->getMCParticle();
657 if ((imcp !=
nullptr) and (mcp->getArrayIndex() == imcp->getArrayIndex()))
667 B2WARNING(
"isDaughterOfList is outdated and replaced by isDescendantOfList.");
668 std::vector<std::string> new_arguments = arguments;
669 new_arguments.push_back(std::string(
"1"));
670 return isDescendantOfList(new_arguments);
675 B2WARNING(
"isGrandDaughterOfList is outdated and replaced by isDescendantOfList.");
676 std::vector<std::string> new_arguments = arguments;
677 new_arguments.push_back(std::string(
"2"));
678 return isDescendantOfList(new_arguments);
683 if (arguments.size() > 0) {
684 auto listNames = arguments;
685 auto func = [listNames](
const Particle * particle) ->
bool {
687 int generation_flag = -1;
691 }
catch (std::exception& e) {}
693 for (
auto& iListName : listNames)
698 }
catch (std::exception& e) {}
701 auto list_comparison = [](
auto&& self,
const Particle * m,
const Particle * p,
int flag)->
bool {
703 for (
unsigned i = 0; i < m->getNDaughters(); ++i)
705 const Particle* daughter = m->getDaughter(i);
706 if ((flag == 1.) or (flag < 0)) {
707 if (p->isCopyOf(daughter)) {
713 if (daughter->getNDaughters() > 0) {
714 result = self(self, daughter, p, flag - 1);
724 StoreObjPtr<ParticleList> listOfParticles(iListName);
726 if (!(listOfParticles.isValid())) B2FATAL(
"Invalid Listname " << iListName <<
" given to isDescendantOfList");
728 for (
unsigned i = 0; i < listOfParticles->getListSize(); ++i) {
729 Particle* iParticle = listOfParticles->getParticle(i);
730 output = list_comparison(list_comparison, iParticle, particle, generation_flag);
740 B2FATAL(
"Wrong number of arguments for meta function isDescendantOfList");
746 if (arguments.size() > 0) {
747 auto listNames = arguments;
748 auto func = [listNames](
const Particle * particle) ->
bool {
750 int generation_flag = -1;
754 }
catch (std::exception& e) {}
756 if (particle->getMCParticle() ==
nullptr)
761 for (
auto& iListName : listNames)
764 std::stod(iListName);
766 }
catch (std::exception& e) {}
768 auto list_comparison = [](
auto&& self,
const Particle * m,
const Particle * p,
int flag)->
bool {
770 for (
unsigned i = 0; i < m->getNDaughters(); ++i)
772 const Particle* daughter = m->getDaughter(i);
773 if ((flag == 1.) or (flag < 0)) {
774 if (daughter->getMCParticle() !=
nullptr) {
775 if (p->getMCParticle()->getArrayIndex() == daughter->getMCParticle()->getArrayIndex()) {
781 if (daughter->getNDaughters() > 0) {
782 result = self(self, daughter, p, flag - 1);
792 StoreObjPtr<ParticleList> listOfParticles(iListName);
794 if (!(listOfParticles.isValid())) B2FATAL(
"Invalid Listname " << iListName <<
" given to isMCDescendantOfList");
796 for (
unsigned i = 0; i < listOfParticles->getListSize(); ++i) {
797 Particle* iParticle = listOfParticles->getParticle(i);
798 output = list_comparison(list_comparison, iParticle, particle, generation_flag);
808 B2FATAL(
"Wrong number of arguments for meta function isMCDescendantOfList");
814 if (arguments.size() == 1) {
816 auto func = [var](
const Particle * particle) ->
double {
817 double product = 1.0;
818 if (particle->getNDaughters() == 0)
822 if (std::holds_alternative<double>(var->function(particle->getDaughter(0))))
824 for (
unsigned j = 0; j < particle->getNDaughters(); ++j) {
825 product *= std::get<double>(var->function(particle->getDaughter(j)));
827 }
else if (std::holds_alternative<int>(var->function(particle->getDaughter(0))))
829 for (
unsigned j = 0; j < particle->getNDaughters(); ++j) {
830 product *= std::get<int>(var->function(particle->getDaughter(j)));
837 B2FATAL(
"Wrong number of arguments for meta function daughterProductOf");
843 if (arguments.size() == 1) {
845 auto func = [var](
const Particle * particle) ->
double {
847 if (particle->getNDaughters() == 0)
851 if (std::holds_alternative<double>(var->function(particle->getDaughter(0))))
853 for (
unsigned j = 0; j < particle->getNDaughters(); ++j) {
854 sum += std::get<double>(var->function(particle->getDaughter(j)));
856 }
else if (std::holds_alternative<int>(var->function(particle->getDaughter(0))))
858 for (
unsigned j = 0; j < particle->getNDaughters(); ++j) {
859 sum += std::get<int>(var->function(particle->getDaughter(j)));
866 B2FATAL(
"Wrong number of arguments for meta function daughterSumOf");
872 if (arguments.size() == 1) {
874 auto func = [var](
const Particle * particle) ->
double {
876 if (particle->getNDaughters() == 0)
880 if (std::holds_alternative<double>(var->function(particle->getDaughter(0))))
882 for (
unsigned j = 0; j < particle->getNDaughters(); ++j) {
883 double iValue = std::get<double>(var->function(particle->getDaughter(j)));
884 if (std::isnan(iValue))
continue;
885 if (std::isnan(min)) min = iValue;
886 if (iValue < min) min = iValue;
888 }
else if (std::holds_alternative<int>(var->function(particle->getDaughter(0))))
890 for (
unsigned j = 0; j < particle->getNDaughters(); ++j) {
891 int iValue = std::get<int>(var->function(particle->getDaughter(j)));
892 if (std::isnan(min)) min = iValue;
893 if (iValue < min) min = iValue;
900 B2FATAL(
"Wrong number of arguments for meta function daughterLowest");
906 if (arguments.size() == 1) {
908 auto func = [var](
const Particle * particle) ->
double {
910 if (particle->getNDaughters() == 0)
914 if (std::holds_alternative<double>(var->function(particle->getDaughter(0))))
916 for (
unsigned j = 0; j < particle->getNDaughters(); ++j) {
917 double iValue = std::get<double>(var->function(particle->getDaughter(j)));
918 if (std::isnan(iValue))
continue;
919 if (std::isnan(max)) max = iValue;
920 if (iValue > max) max = iValue;
922 }
else if (std::holds_alternative<int>(var->function(particle->getDaughter(0))))
924 for (
unsigned j = 0; j < particle->getNDaughters(); ++j) {
925 int iValue = std::get<int>(var->function(particle->getDaughter(j)));
926 if (std::isnan(max)) max = iValue;
927 if (iValue > max) max = iValue;
934 B2FATAL(
"Wrong number of arguments for meta function daughterHighest");
940 if (arguments.size() == 3) {
941 auto func = [arguments](
const Particle * particle) ->
double {
942 if (particle ==
nullptr)
944 const Particle* dau_i = particle->getParticleFromGeneralizedIndexString(arguments[0]);
945 const Particle* dau_j = particle->getParticleFromGeneralizedIndexString(arguments[1]);
946 auto variablename = arguments[2];
947 if (dau_i ==
nullptr || dau_j ==
nullptr)
949 B2ERROR(
"One of the first two arguments doesn't specify a valid (grand-)daughter!");
953 auto result_j = var->function(dau_j);
954 auto result_i = var->function(dau_i);
956 if (std::holds_alternative<double>(result_j) && std::holds_alternative<double>(result_i))
958 diff = std::get<double>(result_j) - std::get<double>(result_i);
959 }
else if (std::holds_alternative<int>(result_j) && std::holds_alternative<int>(result_i))
961 diff = std::get<int>(result_j) - std::get<int>(result_i);
964 throw std::runtime_error(
"Bad variant access");
966 if (variablename ==
"phi" or variablename ==
"clusterPhi" or std::regex_match(variablename, std::regex(
"use.*Frame\\(phi\\)"))
967 or std::regex_match(variablename, std::regex(
"use.*Frame\\(clusterPhi\\)")))
969 if (fabs(diff) > M_PI) {
971 diff = diff - 2 * M_PI;
973 diff = 2 * M_PI + diff;
981 B2FATAL(
"Wrong number of arguments for meta function daughterDiffOf");
987 if (arguments.size() == 3) {
988 auto func = [arguments](
const Particle * particle) ->
double {
989 if (particle ==
nullptr)
991 const Particle* dau_i = particle->getParticleFromGeneralizedIndexString(arguments[0]);
992 const Particle* dau_j = particle->getParticleFromGeneralizedIndexString(arguments[1]);
993 auto variablename = arguments[2];
994 if (dau_i ==
nullptr || dau_j ==
nullptr)
996 B2ERROR(
"One of the first two arguments doesn't specify a valid (grand-)daughter!");
999 const MCParticle* iMcDaughter = dau_i->getMCParticle();
1000 const MCParticle* jMcDaughter = dau_j->getMCParticle();
1001 if (iMcDaughter ==
nullptr || jMcDaughter ==
nullptr)
1003 Particle iTmpPart(iMcDaughter);
1004 Particle jTmpPart(jMcDaughter);
1006 auto result_j = var->function(&jTmpPart);
1007 auto result_i = var->function(&iTmpPart);
1009 if (std::holds_alternative<double>(result_j) && std::holds_alternative<double>(result_i))
1011 diff = std::get<double>(result_j) - std::get<double>(result_i);
1012 }
else if (std::holds_alternative<int>(result_j) && std::holds_alternative<int>(result_i))
1014 diff = std::get<int>(result_j) - std::get<int>(result_i);
1017 throw std::runtime_error(
"Bad variant access");
1019 if (variablename ==
"phi" or std::regex_match(variablename, std::regex(
"use.*Frame\\(phi\\)")))
1021 if (fabs(diff) > M_PI) {
1023 diff = diff - 2 * M_PI;
1025 diff = 2 * M_PI + diff;
1033 B2FATAL(
"Wrong number of arguments for meta function mcDaughterDiffOf");
1039 if (arguments.size() == 5) {
1045 }
catch (std::invalid_argument&) {
1046 B2FATAL(
"First four arguments of grandDaughterDiffOf meta function must be integers!");
1048 std::vector<std::string> new_arguments;
1049 new_arguments.push_back(std::string(arguments[0] +
":" + arguments[2]));
1050 new_arguments.push_back(std::string(arguments[1] +
":" + arguments[3]));
1051 new_arguments.push_back(arguments[4]);
1052 return daughterDiffOf(new_arguments);
1054 B2FATAL(
"Wrong number of arguments for meta function grandDaughterDiffOf");
1060 std::vector<std::string> new_arguments = arguments;
1061 new_arguments.push_back(std::string(
"phi"));
1062 return daughterDiffOf(new_arguments);
1067 std::vector<std::string> new_arguments = arguments;
1068 new_arguments.push_back(std::string(
"phi"));
1069 return mcDaughterDiffOf(new_arguments);
1074 std::vector<std::string> new_arguments = arguments;
1075 new_arguments.push_back(std::string(
"phi"));
1076 return grandDaughterDiffOf(new_arguments);
1081 std::vector<std::string> new_arguments = arguments;
1082 new_arguments.push_back(std::string(
"clusterPhi"));
1083 return daughterDiffOf(new_arguments);
1088 std::vector<std::string> new_arguments = arguments;
1089 new_arguments.push_back(std::string(
"clusterPhi"));
1090 return grandDaughterDiffOf(new_arguments);
1095 std::vector<std::string> new_arguments = arguments;
1096 new_arguments.push_back(std::string(
"useCMSFrame(phi)"));
1097 return daughterDiffOf(new_arguments);
1102 std::vector<std::string> new_arguments = arguments;
1103 new_arguments.push_back(std::string(
"useCMSFrame(phi)"));
1104 return mcDaughterDiffOf(new_arguments);
1109 std::vector<std::string> new_arguments = arguments;
1110 new_arguments.push_back(std::string(
"useCMSFrame(clusterPhi)"));
1111 return daughterDiffOf(new_arguments);
1116 if (arguments.size() == 3) {
1117 auto func = [arguments](
const Particle * particle) ->
double {
1118 if (particle ==
nullptr)
1120 const Particle* dau_i = particle->getParticleFromGeneralizedIndexString(arguments[0]);
1121 const Particle* dau_j = particle->getParticleFromGeneralizedIndexString(arguments[1]);
1122 if (!(dau_i && dau_j))
1124 B2ERROR(
"One of the first two arguments doesn't specify a valid (grand-)daughter!");
1128 double iValue, jValue;
1129 if (std::holds_alternative<double>(var->function(dau_j)))
1131 iValue = std::get<double>(var->function(dau_i));
1132 jValue = std::get<double>(var->function(dau_j));
1133 }
else if (std::holds_alternative<int>(var->function(dau_j)))
1135 iValue = std::get<int>(var->function(dau_i));
1136 jValue = std::get<int>(var->function(dau_j));
1138 return (jValue - iValue) / (jValue + iValue);
1142 B2FATAL(
"Wrong number of arguments for meta function daughterNormDiffOf");
1148 if (arguments.size() == 2) {
1149 int daughterNumber = 0;
1152 }
catch (std::invalid_argument&) {
1153 B2FATAL(
"First argument of daughterMotherDiffOf meta function must be integer!");
1155 auto variablename = arguments[1];
1156 auto func = [variablename, daughterNumber](
const Particle * particle) ->
double {
1157 if (particle ==
nullptr)
1159 if (daughterNumber >=
int(particle->getNDaughters()))
1164 auto result_mother = var->function(particle);
1165 auto result_daughter = var->function(particle->getDaughter(daughterNumber));
1167 if (std::holds_alternative<double>(result_mother) && std::holds_alternative<double>(result_daughter)) {
1168 diff = std::get<double>(result_mother) - std::get<double>(result_daughter);
1169 }
else if (std::holds_alternative<int>(result_mother) && std::holds_alternative<int>(result_daughter)) {
1170 diff = std::get<int>(result_mother) - std::get<int>(result_daughter);
1172 throw std::runtime_error(
"Bad variant access");
1175 if (variablename ==
"phi" or variablename ==
"useCMSFrame(phi)") {
1176 if (fabs(diff) > M_PI) {
1178 diff = diff - 2 * M_PI;
1180 diff = 2 * M_PI + diff;
1189 B2FATAL(
"Wrong number of arguments for meta function daughterMotherDiffOf");
1195 if (arguments.size() == 2) {
1196 int daughterNumber = 0;
1199 }
catch (std::invalid_argument&) {
1200 B2FATAL(
"First argument of daughterMotherDiffOf meta function must be integer!");
1203 auto func = [var, daughterNumber](
const Particle * particle) ->
double {
1204 if (particle ==
nullptr)
1206 if (daughterNumber >=
int(particle->getNDaughters()))
1210 double daughterValue = 0.0, motherValue = 0.0;
1211 if (std::holds_alternative<double>(var->function(particle))) {
1212 daughterValue = std::get<double>(var->function(particle->getDaughter(daughterNumber)));
1213 motherValue = std::get<double>(var->function(particle));
1214 }
else if (std::holds_alternative<int>(var->function(particle))) {
1215 daughterValue = std::get<int>(var->function(particle->getDaughter(daughterNumber)));
1216 motherValue = std::get<int>(var->function(particle));
1218 return (motherValue - daughterValue) / (motherValue + daughterValue);
1223 B2FATAL(
"Wrong number of arguments for meta function daughterMotherNormDiffOf");
1229 if (arguments.size() >= 1) {
1231 auto func = [arguments](
const Particle * particle) ->
double {
1232 if (particle ==
nullptr)
1237 ROOT::Math::PxPyPzEVector pSum(0, 0, 0, 0);
1238 for (
auto& generalizedIndex : arguments)
1240 const Particle* dauPart = particle->getParticleFromGeneralizedIndexString(generalizedIndex);
1241 if (dauPart) pSum += frame.getMomentum(dauPart);
1243 B2WARNING(
"Trying to access a daughter that does not exist. Index = " << generalizedIndex);
1249 ROOT::Math::PxPyPzEVector pIN = T.getBeamFourMomentum();
1250 ROOT::Math::PxPyPzEVector pRecoil = frame.getMomentum(pIN - particle->get4Vector());
1252 return ROOT::Math::VectorUtil::Angle(pRecoil, pSum);
1256 B2FATAL(
"Wrong number of arguments for meta function angleBetweenDaughterAndRecoil");
1260 Manager::FunctionPtr angleBetweenDaughterAndMissingMomentum(
const std::vector<std::string>& arguments)
1262 if (arguments.size() >= 1) {
1263 auto func = [arguments](
const Particle * particle) ->
double {
1264 if (particle ==
nullptr)
1267 StoreObjPtr<EventKinematics> evtShape;
1270 B2WARNING(
"Cannot find missing momentum information, did you forget to run EventKinematicsModule?");
1273 ROOT::Math::XYZVector missingMomentumCMS = evtShape->getMissingMomentumCMS();
1274 ROOT::Math::PxPyPzEVector missingTotalMomentumCMS(missingMomentumCMS.X(),
1275 missingMomentumCMS.Y(),
1276 missingMomentumCMS.Z(),
1277 evtShape->getMissingEnergyCMS());
1279 ROOT::Math::PxPyPzEVector missingTotalMomentumLab = T.rotateCmsToLab() * missingTotalMomentumCMS;
1282 ROOT::Math::PxPyPzEVector pMiss = frame.getMomentum(missingTotalMomentumLab);
1284 ROOT::Math::PxPyPzEVector pSum(0, 0, 0, 0);
1285 for (
auto& generalizedIndex : arguments)
1287 const Particle* dauPart = particle->getParticleFromGeneralizedIndexString(generalizedIndex);
1288 if (dauPart) pSum += frame.getMomentum(dauPart);
1290 B2WARNING(
"Trying to access a daughter that does not exist. Index = " << generalizedIndex);
1295 return ROOT::Math::VectorUtil::Angle(pMiss, pSum);
1299 B2FATAL(
"Wrong number of arguments for meta function angleBetweenDaughterAndMissingMomentum");
1305 if (arguments.size() == 2 || arguments.size() == 3) {
1307 auto func = [arguments](
const Particle * particle) ->
double {
1308 if (particle ==
nullptr)
1311 std::vector<ROOT::Math::PxPyPzEVector> pDaus;
1315 for (
auto& generalizedIndex : arguments)
1317 const Particle* dauPart = particle->getParticleFromGeneralizedIndexString(generalizedIndex);
1319 pDaus.push_back(frame.getMomentum(dauPart));
1321 B2WARNING(
"Trying to access a daughter that does not exist. Index = " << generalizedIndex);
1327 if (pDaus.size() == 2)
1328 return ROOT::Math::VectorUtil::Angle(pDaus[0], pDaus[1]);
1330 return ROOT::Math::VectorUtil::Angle(pDaus[2], pDaus[0] + pDaus[1]);
1334 B2FATAL(
"Wrong number of arguments for meta function daughterAngle");
1338 double grandDaughterDecayAngle(
const Particle* particle,
const std::vector<double>& arguments)
1340 if (arguments.size() == 2) {
1345 int daughterIndex = std::lround(arguments[0]);
1346 if (daughterIndex >=
int(particle->getNDaughters()))
1348 const Particle* dau = particle->getDaughter(daughterIndex);
1350 int grandDaughterIndex = std::lround(arguments[1]);
1351 if (grandDaughterIndex >=
int(dau->getNDaughters()))
1354 ROOT::Math::XYZVector boost = dau->get4Vector().BoostToCM();
1356 ROOT::Math::PxPyPzEVector motherMomentum = - particle->get4Vector();
1357 motherMomentum = ROOT::Math::Boost(boost) * motherMomentum;
1359 ROOT::Math::PxPyPzEVector grandDaughterMomentum = dau->getDaughter(grandDaughterIndex)->get4Vector();
1360 grandDaughterMomentum = ROOT::Math::Boost(boost) * grandDaughterMomentum;
1362 return ROOT::Math::VectorUtil::Angle(motherMomentum, grandDaughterMomentum);
1365 B2FATAL(
"The variable grandDaughterDecayAngle needs exactly two integers as arguments!");
1371 if (arguments.size() == 2 || arguments.size() == 3) {
1373 auto func = [arguments](
const Particle * particle) ->
double {
1374 if (particle ==
nullptr)
1377 std::vector<ROOT::Math::PxPyPzEVector> pDaus;
1381 if (particle->getParticleSource() == Particle::EParticleSourceObject::c_MCParticle)
1383 for (
auto& generalizedIndex : arguments) {
1384 const MCParticle* mcPart = particle->getMCParticle();
1385 if (mcPart ==
nullptr)
1387 const MCParticle* dauMcPart = mcPart->getParticleFromGeneralizedIndexString(generalizedIndex);
1388 if (dauMcPart ==
nullptr)
1391 pDaus.push_back(frame.getMomentum(dauMcPart->get4Vector()));
1395 for (
auto& generalizedIndex : arguments) {
1396 const Particle* dauPart = particle->getParticleFromGeneralizedIndexString(generalizedIndex);
1397 if (dauPart ==
nullptr)
1400 const MCParticle* dauMcPart = dauPart->getMCParticle();
1401 if (dauMcPart ==
nullptr)
1404 pDaus.push_back(frame.getMomentum(dauMcPart->get4Vector()));
1409 if (pDaus.size() == 2)
1410 return ROOT::Math::VectorUtil::Angle(pDaus[0], pDaus[1]);
1412 return ROOT::Math::VectorUtil::Angle(pDaus[2], pDaus[0] + pDaus[1]);
1416 B2FATAL(
"Wrong number of arguments for meta function mcDaughterAngle");
1420 double daughterClusterAngleInBetween(
const Particle* particle,
const std::vector<double>& daughterIndices)
1422 if (daughterIndices.size() == 2) {
1423 int daughterIndexi = std::lround(daughterIndices[0]);
1424 int daughterIndexj = std::lround(daughterIndices[1]);
1425 if (std::max(daughterIndexi, daughterIndexj) >=
int(particle->getNDaughters())) {
1428 const ECLCluster* clusteri = particle->getDaughter(daughterIndexi)->getECLCluster();
1429 const ECLCluster* clusterj = particle->getDaughter(daughterIndexj)->getECLCluster();
1430 if (clusteri and clusterj) {
1434 ClusterUtils clusutils;
1435 ROOT::Math::PxPyPzEVector pi = frame.getMomentum(clusutils.Get4MomentumFromCluster(clusteri, clusteriBit));
1436 ROOT::Math::PxPyPzEVector pj = frame.getMomentum(clusutils.Get4MomentumFromCluster(clusterj, clusterjBit));
1437 return ROOT::Math::VectorUtil::Angle(pi, pj);
1441 }
else if (daughterIndices.size() == 3) {
1442 int daughterIndexi = std::lround(daughterIndices[0]);
1443 int daughterIndexj = std::lround(daughterIndices[1]);
1444 int daughterIndexk = std::lround(daughterIndices[2]);
1445 if (std::max(std::max(daughterIndexi, daughterIndexj), daughterIndexk) >=
int(particle->getNDaughters())) {
1448 const ECLCluster* clusteri = (particle->getDaughter(daughterIndices[0]))->getECLCluster();
1449 const ECLCluster* clusterj = (particle->getDaughter(daughterIndices[1]))->getECLCluster();
1450 const ECLCluster* clusterk = (particle->getDaughter(daughterIndices[2]))->getECLCluster();
1451 if (clusteri and clusterj and clusterk) {
1456 ClusterUtils clusutils;
1457 ROOT::Math::PxPyPzEVector pi = frame.getMomentum(clusutils.Get4MomentumFromCluster(clusteri, clusteriBit));
1458 ROOT::Math::PxPyPzEVector pj = frame.getMomentum(clusutils.Get4MomentumFromCluster(clusterj, clusterjBit));
1459 ROOT::Math::PxPyPzEVector pk = frame.getMomentum(clusutils.Get4MomentumFromCluster(clusterk, clusterkBit));
1460 return ROOT::Math::VectorUtil::Angle(pk, pi + pj);
1465 B2FATAL(
"Wrong number of arguments for daughterClusterAngleInBetween!");
1471 if (arguments.size() > 1) {
1472 auto func = [arguments](
const Particle * particle) ->
double {
1474 ROOT::Math::PxPyPzEVector pSum;
1476 for (
auto& generalizedIndex : arguments)
1478 const Particle* dauPart = particle->getParticleFromGeneralizedIndexString(generalizedIndex);
1480 pSum += frame.getMomentum(dauPart);
1489 B2FATAL(
"Wrong number of arguments for meta function daughterInvM. At least two integers are needed.");
1495 if (arguments.size() == 2) {
1500 }
catch (std::invalid_argument&) {
1501 B2FATAL(
"Second argument of modulo meta function must be integer!");
1503 auto func = [var, divideBy](
const Particle * particle) ->
int {
1504 auto var_result = var->function(particle);
1505 if (std::holds_alternative<double>(var_result))
1507 return int(std::get<double>(var_result)) % divideBy;
1508 }
else if (std::holds_alternative<int>(var_result))
1510 return std::get<int>(var_result) % divideBy;
1511 }
else if (std::holds_alternative<bool>(var_result))
1513 return int(std::get<bool>(var_result)) % divideBy;
1518 B2FATAL(
"Wrong number of arguments for meta function modulo");
1524 if (arguments.size() == 1) {
1527 auto func = [var](
const Particle * particle) ->
bool {
return std::isnan(std::get<double>(var->function(particle))); };
1530 B2FATAL(
"Wrong number of arguments for meta function isNAN");
1536 if (arguments.size() == 2) {
1538 double defaultOutput;
1541 }
catch (std::invalid_argument&) {
1542 B2FATAL(
"The second argument of ifNANgiveX meta function must be a number!");
1544 auto func = [var, defaultOutput](
const Particle * particle) ->
double {
1545 double output = std::get<double>(var->function(particle));
1546 if (std::isnan(output))
return defaultOutput;
1551 B2FATAL(
"Wrong number of arguments for meta function ifNANgiveX");
1557 if (arguments.size() == 1) {
1560 auto func = [var](
const Particle * particle) ->
bool {
return std::isinf(std::get<double>(var->function(particle))); };
1563 B2FATAL(
"Wrong number of arguments for meta function isInfinity");
1569 if (arguments.size() >= 2) {
1575 for (
size_t i = 1; i < arguments.size(); ++i) {
1578 }
catch (std::invalid_argument&) {
1579 B2FATAL(
"The input flags to meta function unmask() should be integer!");
1585 auto func = [var, finalMask](
const Particle * particle) ->
double {
1587 auto var_result = var->function(particle);
1588 if (std::holds_alternative<double>(var_result))
1591 if (std::isnan(std::get<double>(var_result))) {
1594 value = int(std::get<double>(var_result));
1595 }
else if (std::holds_alternative<int>(var_result))
1597 value = std::get<int>(var_result);
1601 value &= (~finalMask);
1608 B2FATAL(
"Meta function unmask needs at least two arguments!");
1614 if (arguments.size() == 3) {
1616 std::string cutString = arguments[0];
1622 auto func = [cut, variableIfTrue, variableIfFalse](
const Particle * particle) ->
double {
1623 if (particle ==
nullptr)
1625 if (cut->check(particle))
1627 auto var_result = variableIfTrue->function(particle);
1628 if (std::holds_alternative<double>(var_result)) {
1629 return std::get<double>(var_result);
1630 }
else if (std::holds_alternative<int>(var_result)) {
1631 return std::get<int>(var_result);
1632 }
else if (std::holds_alternative<bool>(var_result)) {
1633 return std::get<bool>(var_result);
1637 auto var_result = variableIfFalse->function(particle);
1638 if (std::holds_alternative<double>(var_result)) {
1639 return std::get<double>(var_result);
1640 }
else if (std::holds_alternative<int>(var_result)) {
1641 return std::get<int>(var_result);
1642 }
else if (std::holds_alternative<bool>(var_result)) {
1643 return std::get<bool>(var_result);
1650 B2FATAL(
"Wrong number of arguments for meta function conditionalVariableSelector");
1656 if (arguments.size() > 0) {
1657 std::vector<const Variable::Manager::Var*> variables;
1658 for (
auto& argument : arguments)
1661 auto func = [variables, arguments](
const Particle * particle) ->
double {
1662 double pValueProduct = 1.;
1663 for (
auto variable : variables)
1665 double pValue = std::get<double>(variable->function(particle));
1669 pValueProduct *= pValue;
1671 double pValueSum = 1.;
1672 double factorial = 1.;
1673 for (
unsigned int i = 1; i < arguments.size(); ++i)
1676 pValueSum += pow(-std::log(pValueProduct), i) / factorial;
1678 return pValueProduct * pValueSum;
1682 B2FATAL(
"Wrong number of arguments for meta function pValueCombination");
1688 if (arguments.size() == 1) {
1690 auto func = [var](
const Particle * particle) ->
double {
1691 double pValueProduct = 1.;
1692 if (particle->getNDaughters() == 0)
1697 for (
unsigned j = 0; j < particle->getNDaughters(); ++j)
1699 double pValue = std::get<double>(var->function(particle->getDaughter(j)));
1700 if (pValue < 0)
return -1;
1701 else pValueProduct *= pValue;
1704 double pValueSum = 1.;
1705 double factorial = 1.;
1706 for (
unsigned int i = 1; i < particle->getNDaughters(); ++i)
1709 pValueSum += pow(-std::log(pValueProduct), i) / factorial;
1711 return pValueProduct * pValueSum;
1715 B2FATAL(
"Wrong number of arguments for meta function pValueCombinationOfDaughters");
1721 if (arguments.size() == 1) {
1723 auto func = [var](
const Particle * particle) ->
double {
1724 auto var_result = var->function(particle);
1725 if (std::holds_alternative<double>(var_result))
1727 return std::abs(std::get<double>(var_result));
1728 }
else if (std::holds_alternative<int>(var_result))
1730 return std::abs(std::get<int>(var_result));
1735 B2FATAL(
"Wrong number of arguments for meta function abs");
1741 if (arguments.size() == 2) {
1746 B2FATAL(
"One or both of the used variables doesn't exist!");
1748 auto func = [var1, var2](
const Particle * particle) ->
double {
1750 auto var_result1 = var1->function(particle);
1751 auto var_result2 = var2->function(particle);
1752 if (std::holds_alternative<double>(var_result1))
1754 val1 = std::get<double>(var_result1);
1755 }
else if (std::holds_alternative<int>(var_result1))
1757 val1 = std::get<int>(var_result1);
1759 if (std::holds_alternative<double>(var_result2))
1761 val2 = std::get<double>(var_result2);
1762 }
else if (std::holds_alternative<int>(var_result2))
1764 val2 = std::get<int>(var_result2);
1766 return std::max(val1, val2);
1770 B2FATAL(
"Wrong number of arguments for meta function max");
1776 if (arguments.size() == 2) {
1781 B2FATAL(
"One or both of the used variables doesn't exist!");
1783 auto func = [var1, var2](
const Particle * particle) ->
double {
1785 auto var_result1 = var1->function(particle);
1786 auto var_result2 = var2->function(particle);
1787 if (std::holds_alternative<double>(var_result1))
1789 val1 = std::get<double>(var_result1);
1790 }
else if (std::holds_alternative<int>(var_result1))
1792 val1 = std::get<int>(var_result1);
1794 if (std::holds_alternative<double>(var_result2))
1796 val2 = std::get<double>(var_result2);
1797 }
else if (std::holds_alternative<int>(var_result2))
1799 val2 = std::get<int>(var_result2);
1801 return std::min(val1, val2);
1805 B2FATAL(
"Wrong number of arguments for meta function min");
1811 if (arguments.size() == 1) {
1813 auto func = [var](
const Particle * particle) ->
double {
1814 auto var_result = var->function(particle);
1815 if (std::holds_alternative<double>(var_result))
1816 return std::sin(std::get<double>(var_result));
1817 else if (std::holds_alternative<int>(var_result))
1818 return std::sin(std::get<int>(var_result));
1823 B2FATAL(
"Wrong number of arguments for meta function sin");
1829 if (arguments.size() == 1) {
1831 auto func = [var](
const Particle * particle) ->
double {
1832 auto var_result = var->function(particle);
1833 if (std::holds_alternative<double>(var_result))
1834 return std::asin(std::get<double>(var_result));
1835 else if (std::holds_alternative<int>(var_result))
1836 return std::asin(std::get<int>(var_result));
1841 B2FATAL(
"Wrong number of arguments for meta function asin");
1847 if (arguments.size() == 1) {
1849 auto func = [var](
const Particle * particle) ->
double {
1850 auto var_result = var->function(particle);
1851 if (std::holds_alternative<double>(var_result))
1852 return std::cos(std::get<double>(var_result));
1853 else if (std::holds_alternative<int>(var_result))
1854 return std::cos(std::get<int>(var_result));
1859 B2FATAL(
"Wrong number of arguments for meta function cos");
1865 if (arguments.size() == 1) {
1867 auto func = [var](
const Particle * particle) ->
double {
1868 auto var_result = var->function(particle);
1869 if (std::holds_alternative<double>(var_result))
1870 return std::acos(std::get<double>(var_result));
1871 else if (std::holds_alternative<int>(var_result))
1872 return std::acos(std::get<int>(var_result));
1877 B2FATAL(
"Wrong number of arguments for meta function acos");
1883 if (arguments.size() == 1) {
1885 auto func = [var](
const Particle * particle) ->
double {
return std::tan(std::get<double>(var->function(particle))); };
1888 B2FATAL(
"Wrong number of arguments for meta function tan");
1894 if (arguments.size() == 1) {
1896 auto func = [var](
const Particle * particle) ->
double {
return std::atan(std::get<double>(var->function(particle))); };
1899 B2FATAL(
"Wrong number of arguments for meta function atan");
1905 if (arguments.size() == 1) {
1907 auto func = [var](
const Particle * particle) ->
double {
1908 auto var_result = var->function(particle);
1909 if (std::holds_alternative<double>(var_result))
1910 return std::exp(std::get<double>(var_result));
1911 else if (std::holds_alternative<int>(var_result))
1912 return std::exp(std::get<int>(var_result));
1917 B2FATAL(
"Wrong number of arguments for meta function exp");
1923 if (arguments.size() == 1) {
1925 auto func = [var](
const Particle * particle) ->
double {
1926 auto var_result = var->function(particle);
1927 if (std::holds_alternative<double>(var_result))
1928 return std::log(std::get<double>(var_result));
1929 else if (std::holds_alternative<int>(var_result))
1930 return std::log(std::get<int>(var_result));
1935 B2FATAL(
"Wrong number of arguments for meta function log");
1941 if (arguments.size() == 1) {
1943 auto func = [var](
const Particle * particle) ->
double {
1944 auto var_result = var->function(particle);
1945 if (std::holds_alternative<double>(var_result))
1946 return std::log10(std::get<double>(var_result));
1947 else if (std::holds_alternative<int>(var_result))
1948 return std::log10(std::get<int>(var_result));
1953 B2FATAL(
"Wrong number of arguments for meta function log10");
1959 if (arguments.size() == 1) {
1961 auto func = [var](
const Particle * particle) ->
double {
1962 if (particle ==
nullptr)
1965 StoreArray<Particle> particles;
1966 if (!particle->hasExtraInfo(
"original_index"))
1969 auto originalParticle = particles[particle->getExtraInfo(
"original_index")];
1970 if (!originalParticle)
1972 auto var_result = var->function(originalParticle);
1973 if (std::holds_alternative<double>(var_result))
1975 return std::get<double>(var_result);
1976 }
else if (std::holds_alternative<int>(var_result))
1978 return std::get<int>(var_result);
1979 }
else if (std::holds_alternative<bool>(var_result))
1981 return std::get<bool>(var_result);
1986 B2FATAL(
"Wrong number of arguments for meta function originalParticle");
1992 if (arguments.size() == 2) {
1993 int daughterNumber = 0;
1996 }
catch (std::invalid_argument&) {
1997 B2FATAL(
"First argument of daughter meta function must be integer!");
2000 auto func = [var, daughterNumber](
const Particle * particle) ->
double {
2001 if (particle ==
nullptr)
2003 if (daughterNumber >=
int(particle->getNDaughters()))
2007 auto var_result = var->function(particle->getDaughter(daughterNumber));
2008 if (std::holds_alternative<double>(var_result)) {
2009 return std::get<double>(var_result);
2010 }
else if (std::holds_alternative<int>(var_result)) {
2011 return std::get<int>(var_result);
2012 }
else if (std::holds_alternative<bool>(var_result)) {
2013 return std::get<bool>(var_result);
2019 B2FATAL(
"Wrong number of arguments for meta function daughter");
2025 if (arguments.size() == 2) {
2026 int daughterNumber = 0;
2029 }
catch (std::invalid_argument&) {
2030 B2FATAL(
"First argument of daughter meta function must be integer!");
2033 auto func = [var, daughterNumber](
const Particle * particle) ->
double {
2034 if (particle ==
nullptr)
2036 if (daughterNumber >=
int(particle->getNDaughters()))
2040 StoreArray<Particle> particles;
2041 if (!particle->getDaughter(daughterNumber)->hasExtraInfo(
"original_index"))
2043 auto originalDaughter = particles[particle->getDaughter(daughterNumber)->getExtraInfo(
"original_index")];
2044 if (!originalDaughter)
2047 auto var_result = var->function(originalDaughter);
2048 if (std::holds_alternative<double>(var_result)) {
2049 return std::get<double>(var_result);
2050 }
else if (std::holds_alternative<int>(var_result)) {
2051 return std::get<int>(var_result);
2052 }
else if (std::holds_alternative<bool>(var_result)) {
2053 return std::get<bool>(var_result);
2059 B2FATAL(
"Wrong number of arguments for meta function daughter");
2065 if (arguments.size() == 2) {
2066 int daughterNumber = 0;
2069 }
catch (std::invalid_argument&) {
2070 B2FATAL(
"First argument of mcDaughter meta function must be integer!");
2073 auto func = [var, daughterNumber](
const Particle * particle) ->
double {
2074 if (particle ==
nullptr)
2076 if (particle->getMCParticle())
2078 if (daughterNumber >=
int(particle->getMCParticle()->getNDaughters())) {
2081 Particle tempParticle = Particle(particle->getMCParticle()->getDaughters().at(daughterNumber));
2082 auto var_result = var->function(&tempParticle);
2083 if (std::holds_alternative<double>(var_result)) {
2084 return std::get<double>(var_result);
2085 }
else if (std::holds_alternative<int>(var_result)) {
2086 return std::get<int>(var_result);
2087 }
else if (std::holds_alternative<bool>(var_result)) {
2088 return std::get<bool>(var_result);
2097 B2FATAL(
"Wrong number of arguments for meta function mcDaughter");
2103 if (arguments.size() == 1) {
2105 auto func = [var](
const Particle * particle) ->
double {
2106 if (particle ==
nullptr)
2108 if (particle->getMCParticle())
2110 if (particle->getMCParticle()->getMother() ==
nullptr) {
2113 Particle tempParticle = Particle(particle->getMCParticle()->getMother());
2114 auto var_result = var->function(&tempParticle);
2115 if (std::holds_alternative<double>(var_result)) {
2116 return std::get<double>(var_result);
2117 }
else if (std::holds_alternative<int>(var_result)) {
2118 return std::get<int>(var_result);
2119 }
else if (std::holds_alternative<bool>(var_result)) {
2120 return std::get<bool>(var_result);
2129 B2FATAL(
"Wrong number of arguments for meta function mcMother");
2135 if (arguments.size() == 2) {
2136 int particleNumber = 0;
2139 }
catch (std::invalid_argument&) {
2140 B2FATAL(
"First argument of genParticle meta function must be integer!");
2144 auto func = [var, particleNumber](
const Particle*) ->
double {
2145 StoreArray<MCParticle> mcParticles(
"MCParticles");
2146 if (particleNumber >= mcParticles.getEntries())
2151 MCParticle* mcParticle = mcParticles[particleNumber];
2152 Particle part = Particle(mcParticle);
2153 auto var_result = var->function(&part);
2154 if (std::holds_alternative<double>(var_result))
2156 return std::get<double>(var_result);
2157 }
else if (std::holds_alternative<int>(var_result))
2159 return std::get<int>(var_result);
2160 }
else if (std::holds_alternative<bool>(var_result))
2162 return std::get<bool>(var_result);
2167 B2FATAL(
"Wrong number of arguments for meta function genParticle");
2173 if (arguments.size() == 1) {
2176 auto func = [var](
const Particle*) ->
double {
2177 StoreArray<MCParticle> mcParticles(
"MCParticles");
2178 if (mcParticles.getEntries() == 0)
2183 MCParticle* mcUpsilon4S = mcParticles[0];
2184 if (mcUpsilon4S->isInitial()) mcUpsilon4S = mcParticles[2];
2185 if (mcUpsilon4S->getPDG() != 300553)
2190 Particle upsilon4S = Particle(mcUpsilon4S);
2191 auto var_result = var->function(&upsilon4S);
2192 if (std::holds_alternative<double>(var_result))
2194 return std::get<double>(var_result);
2195 }
else if (std::holds_alternative<int>(var_result))
2197 return std::get<int>(var_result);
2198 }
else if (std::holds_alternative<bool>(var_result))
2200 return std::get<bool>(var_result);
2205 B2FATAL(
"Wrong number of arguments for meta function genUpsilon4S");
2211 if (arguments.size() == 4) {
2212 std::string listName = arguments[0];
2213 std::string rankedVariableName = arguments[1];
2214 std::string returnVariableName = arguments[2];
2215 std::string extraInfoName = rankedVariableName +
"_rank";
2219 }
catch (std::invalid_argument&) {
2220 B2ERROR(
"3rd argument of getVariableByRank meta function (Rank) must be an integer!");
2225 auto func = [var, rank, extraInfoName, listName](
const Particle*)->
double {
2226 StoreObjPtr<ParticleList> list(listName);
2228 const unsigned int numParticles = list->getListSize();
2229 for (
unsigned int i = 0; i < numParticles; i++)
2231 const Particle* p = list->getParticle(i);
2232 if (p->getExtraInfo(extraInfoName) == rank) {
2233 auto var_result = var->function(p);
2234 if (std::holds_alternative<double>(var_result)) {
2235 return std::get<double>(var_result);
2236 }
else if (std::holds_alternative<int>(var_result)) {
2237 return std::get<int>(var_result);
2238 }
else if (std::holds_alternative<bool>(var_result)) {
2239 return std::get<bool>(var_result);
2244 return std::numeric_limits<double>::signaling_NaN();
2248 B2FATAL(
"Wrong number of arguments for meta function getVariableByRank");
2254 if (arguments.size() == 1 or arguments.size() == 2) {
2256 std::string listName = arguments[0];
2257 std::string cutString =
"";
2259 if (arguments.size() == 2) {
2260 cutString = arguments[1];
2265 auto func = [listName, cut](
const Particle*) ->
int {
2267 StoreObjPtr<ParticleList> list(listName);
2269 for (
unsigned int i = 0; i < list->getListSize(); i++)
2271 const Particle* particle = list->getParticle(i);
2272 if (cut->check(particle)) {
2280 B2FATAL(
"Wrong number of arguments for meta function countInList");
2286 if (arguments.size() == 2 or arguments.size() == 3) {
2288 std::string roeListName = arguments[0];
2289 std::string cutString = arguments[1];
2291 if (arguments.size() == 2) {
2292 B2INFO(
"Use pdgCode of electron as default in meta variable veto, other arguments: " << roeListName <<
", " << cutString);
2296 }
catch (std::invalid_argument&) {
2297 B2FATAL(
"Third argument of veto meta function must be integer!");
2304 auto func = [roeListName, cut, pdgCode, flavourType](
const Particle * particle) ->
bool {
2305 StoreObjPtr<ParticleList> roeList(roeListName);
2306 ROOT::Math::PxPyPzEVector vec = particle->get4Vector();
2307 for (
unsigned int i = 0; i < roeList->getListSize(); i++)
2309 const Particle* roeParticle = roeList->getParticle(i);
2310 if (not particle->overlapsWith(roeParticle)) {
2311 ROOT::Math::PxPyPzEVector tempCombination = roeParticle->get4Vector() + vec;
2312 std::vector<int> indices = { particle->getArrayIndex(), roeParticle->getArrayIndex() };
2313 Particle tempParticle = Particle(tempCombination, pdgCode, flavourType, indices, particle->getArrayPointer());
2314 if (cut->check(&tempParticle)) {
2323 B2FATAL(
"Wrong number of arguments for meta function veto");
2329 if (arguments.size() == 1) {
2330 std::string cutString = arguments[0];
2332 auto func = [cut](
const Particle * particle) ->
int {
2334 for (
auto& daughter : particle->getDaughters())
2336 if (cut->check(daughter))
2343 B2FATAL(
"Wrong number of arguments for meta function countDaughters");
2349 if (arguments.size() == 1) {
2350 std::string cutString = arguments[0];
2352 auto func = [cut](
const Particle * particle) ->
int {
2354 std::vector<const Particle*> fspDaughters;
2355 particle->fillFSPDaughters(fspDaughters);
2358 for (
auto& daughter : fspDaughters)
2360 if (cut->check(daughter))
2367 B2FATAL(
"Wrong number of arguments for meta function countFSPDaughters");
2373 if (arguments.size() == 1) {
2374 std::string cutString = arguments[0];
2376 auto func = [cut](
const Particle * particle) ->
int {
2378 std::vector<const Particle*> allDaughters;
2379 particle->fillAllDaughters(allDaughters);
2382 for (
auto& daughter : allDaughters)
2384 if (cut->check(daughter))
2391 B2FATAL(
"Wrong number of arguments for meta function countDescendants");
2395 Manager::FunctionPtr numberOfNonOverlappingParticles(
const std::vector<std::string>& arguments)
2398 auto func = [arguments](
const Particle * particle) ->
int {
2400 int _numberOfNonOverlappingParticles = 0;
2401 for (
const auto& listName : arguments)
2403 StoreObjPtr<ParticleList> list(listName);
2404 if (not list.isValid()) {
2405 B2FATAL(
"Invalid list named " << listName <<
" encountered in numberOfNonOverlappingParticles.");
2407 for (
unsigned int i = 0; i < list->getListSize(); i++) {
2408 const Particle* p = list->getParticle(i);
2409 if (not particle->overlapsWith(p)) {
2410 _numberOfNonOverlappingParticles++;
2414 return _numberOfNonOverlappingParticles;
2421 void appendDaughtersRecursive(Particle* mother)
2424 auto* mcmother = mother->getRelated<MCParticle>();
2429 std::vector<MCParticle*> mcdaughters = mcmother->getDaughters();
2430 StoreArray<Particle> particles;
2432 for (
auto& mcdaughter : mcdaughters) {
2434 Particle tmp_daughter(mcdaughter);
2435 Particle* new_daughter = particles.appendNew(tmp_daughter);
2436 new_daughter->addRelationTo(mcdaughter);
2437 mother->appendDaughter(new_daughter,
false);
2439 if (mcdaughter->getNDaughters() > 0)
2440 appendDaughtersRecursive(new_daughter);
2447 if (arguments.size() == 1) {
2449 auto func = [var](
const Particle * particle) ->
double {
2450 const MCParticle* mcp = particle->getMCParticle();
2455 Particle tmpPart(mcp);
2456 StoreArray<Particle> particles;
2457 Particle* newPart = particles.appendNew(tmpPart);
2458 newPart->addRelationTo(mcp);
2460 appendDaughtersRecursive(newPart);
2462 auto var_result = var->function(newPart);
2463 if (std::holds_alternative<double>(var_result))
2465 return std::get<double>(var_result);
2466 }
else if (std::holds_alternative<int>(var_result))
2468 return std::get<int>(var_result);
2469 }
else if (std::holds_alternative<bool>(var_result))
2471 return std::get<bool>(var_result);
2476 B2FATAL(
"Wrong number of arguments for meta function matchedMC");
2482 if (arguments.size() == 1) {
2485 auto func = [var](
const Particle * particle) ->
double {
2487 const ECLCluster* cluster = particle->getECLCluster();
2490 auto mcps = cluster->getRelationsTo<MCParticle>();
2493 std::vector<std::pair<double, int>> weightsAndIndices;
2494 for (
unsigned int i = 0; i < mcps.size(); ++i)
2495 weightsAndIndices.emplace_back(mcps.weight(i), i);
2498 std::sort(weightsAndIndices.begin(), weightsAndIndices.end(),
2499 ValueIndexPairSorting::higherPair<
decltype(weightsAndIndices)::value_type>);
2502 const MCParticle* mcp = mcps.object(weightsAndIndices[0].second);
2504 Particle tmpPart(mcp);
2505 StoreArray<Particle> particles;
2506 Particle* newPart = particles.appendNew(tmpPart);
2507 newPart->addRelationTo(mcp);
2509 appendDaughtersRecursive(newPart);
2511 auto var_result = var->function(newPart);
2512 if (std::holds_alternative<double>(var_result))
2514 return std::get<double>(var_result);
2515 }
else if (std::holds_alternative<int>(var_result))
2517 return std::get<int>(var_result);
2518 }
else if (std::holds_alternative<bool>(var_result))
2520 return std::get<bool>(var_result);
2529 B2FATAL(
"Wrong number of arguments for meta function clusterBestMatchedMCParticle");
2535 if (arguments.size() == 1) {
2538 auto func = [var](
const Particle * particle) ->
double {
2540 const ECLCluster* cluster = particle->getECLCluster();
2543 auto mcps = cluster->getRelationsTo<MCParticle>();
2546 std::map<int, double> mapMCParticleIndxAndWeight;
2547 getKlongWeightMap(particle, mapMCParticleIndxAndWeight);
2550 if (mapMCParticleIndxAndWeight.size() == 0)
2554 auto maxMap = std::max_element(mapMCParticleIndxAndWeight.begin(), mapMCParticleIndxAndWeight.end(),
2555 [](
const auto & x,
const auto & y) { return x.second < y.second; }
2558 StoreArray<MCParticle> mcparticles;
2559 const MCParticle* mcKlong = mcparticles[maxMap->first];
2561 Particle tmpPart(mcKlong);
2562 auto var_result = var->function(&tmpPart);
2563 if (std::holds_alternative<double>(var_result))
2565 return std::get<double>(var_result);
2566 }
else if (std::holds_alternative<int>(var_result))
2568 return std::get<int>(var_result);
2569 }
else if (std::holds_alternative<bool>(var_result))
2571 return std::get<bool>(var_result);
2580 B2FATAL(
"Wrong number of arguments for meta function clusterBestMatchedMCKlong");
2584 double matchedMCHasPDG(
const Particle* particle,
const std::vector<double>& pdgCode)
2586 if (pdgCode.size() != 1) {
2587 B2FATAL(
"Too many arguments provided to matchedMCHasPDG!");
2589 int inputPDG = std::lround(pdgCode[0]);
2591 const MCParticle* mcp = particle->getMCParticle();
2595 return std::abs(mcp->getPDG()) == inputPDG;
2600 if (arguments.size() == 1) {
2601 std::string listName = arguments[0];
2602 auto func = [listName](
const Particle * particle) ->
double {
2605 StoreObjPtr<ParticleList> listOfParticles(listName);
2607 if (!(listOfParticles.isValid())) B2FATAL(
"Invalid Listname " << listName <<
" given to totalEnergyOfParticlesInList");
2608 double totalEnergy = 0;
2609 int nParticles = listOfParticles->getListSize();
2610 for (
int i = 0; i < nParticles; i++)
2612 const Particle* part = listOfParticles->getParticle(i);
2614 totalEnergy += frame.getMomentum(part).E();
2621 B2FATAL(
"Wrong number of arguments for meta function totalEnergyOfParticlesInList");
2627 if (arguments.size() == 1) {
2628 std::string listName = arguments[0];
2629 auto func = [listName](
const Particle*) ->
double {
2630 StoreObjPtr<ParticleList> listOfParticles(listName);
2632 if (!(listOfParticles.isValid())) B2FATAL(
"Invalid Listname " << listName <<
" given to totalPxOfParticlesInList");
2634 int nParticles = listOfParticles->getListSize();
2636 for (
int i = 0; i < nParticles; i++)
2638 const Particle* part = listOfParticles->getParticle(i);
2639 totalPx += frame.getMomentum(part).Px();
2645 B2FATAL(
"Wrong number of arguments for meta function totalPxOfParticlesInList");
2651 if (arguments.size() == 1) {
2652 std::string listName = arguments[0];
2653 auto func = [listName](
const Particle*) ->
double {
2654 StoreObjPtr<ParticleList> listOfParticles(listName);
2656 if (!(listOfParticles.isValid())) B2FATAL(
"Invalid Listname " << listName <<
" given to totalPyOfParticlesInList");
2658 int nParticles = listOfParticles->getListSize();
2660 for (
int i = 0; i < nParticles; i++)
2662 const Particle* part = listOfParticles->getParticle(i);
2663 totalPy += frame.getMomentum(part).Py();
2669 B2FATAL(
"Wrong number of arguments for meta function totalPyOfParticlesInList");
2675 if (arguments.size() == 1) {
2676 std::string listName = arguments[0];
2677 auto func = [listName](
const Particle*) ->
double {
2678 StoreObjPtr<ParticleList> listOfParticles(listName);
2680 if (!(listOfParticles.isValid())) B2FATAL(
"Invalid Listname " << listName <<
" given to totalPzOfParticlesInList");
2682 int nParticles = listOfParticles->getListSize();
2684 for (
int i = 0; i < nParticles; i++)
2686 const Particle* part = listOfParticles->getParticle(i);
2687 totalPz += frame.getMomentum(part).Pz();
2693 B2FATAL(
"Wrong number of arguments for meta function totalPzOfParticlesInList");
2699 if (arguments.size() > 0) {
2701 auto func = [arguments](
const Particle * particle) ->
double {
2703 ROOT::Math::PxPyPzEVector total4Vector;
2705 std::vector<Particle*> particlePool;
2708 for (
const auto& argument : arguments)
2710 StoreObjPtr <ParticleList> listOfParticles(argument);
2712 if (!(listOfParticles.isValid())) B2FATAL(
"Invalid Listname " << argument <<
" given to invMassInLists");
2713 int nParticles = listOfParticles->getListSize();
2714 for (
int i = 0; i < nParticles; i++) {
2715 bool overlaps =
false;
2716 Particle* part = listOfParticles->getParticle(i);
2717 for (
auto poolPart : particlePool) {
2718 if (part->overlapsWith(poolPart)) {
2724 total4Vector += part->get4Vector();
2725 particlePool.push_back(part);
2729 double invariantMass = total4Vector.M();
2730 return invariantMass;
2735 B2FATAL(
"Wrong number of arguments for meta function invMassInLists");
2739 Manager::FunctionPtr totalECLEnergyOfParticlesInList(
const std::vector<std::string>& arguments)
2741 if (arguments.size() == 1) {
2742 std::string listName = arguments[0];
2743 auto func = [listName](
const Particle * particle) ->
double {
2746 StoreObjPtr<ParticleList> listOfParticles(listName);
2748 if (!(listOfParticles.isValid())) B2FATAL(
"Invalid Listname " << listName <<
" given to totalEnergyOfParticlesInList");
2749 double totalEnergy = 0;
2750 int nParticles = listOfParticles->getListSize();
2751 for (
int i = 0; i < nParticles; i++)
2753 const Particle* part = listOfParticles->getParticle(i);
2754 const ECLCluster* cluster = part->getECLCluster();
2756 if (cluster !=
nullptr) {
2757 totalEnergy += cluster->getEnergy(clusterHypothesis);
2765 B2FATAL(
"Wrong number of arguments for meta function totalECLEnergyOfParticlesInList");
2771 if (arguments.size() == 1) {
2772 std::string listName = arguments[0];
2773 auto func = [listName](
const Particle*) ->
double {
2774 StoreObjPtr<ParticleList> listOfParticles(listName);
2776 if (!(listOfParticles.isValid())) B2FATAL(
"Invalid Listname " << listName <<
" given to maxPtInList");
2777 int nParticles = listOfParticles->getListSize();
2780 for (
int i = 0; i < nParticles; i++)
2782 const Particle* part = listOfParticles->getParticle(i);
2783 const double Pt = frame.getMomentum(part).Pt();
2784 if (Pt > maxPt) maxPt = Pt;
2790 B2FATAL(
"Wrong number of arguments for meta function maxPtInList");
2794 Manager::FunctionPtr eclClusterTrackMatchedWithCondition(
const std::vector<std::string>& arguments)
2796 if (arguments.size() <= 1) {
2798 std::string cutString;
2799 if (arguments.size() == 1)
2800 cutString = arguments[0];
2802 auto func = [cut](
const Particle * particle) ->
double {
2804 if (particle ==
nullptr)
2807 const ECLCluster* cluster = particle->getECLCluster();
2811 auto tracks = cluster->getRelationsFrom<Track>();
2813 for (
const auto& track : tracks) {
2816 if (cut->check(&trackParticle))
2825 B2FATAL(
"Wrong number of arguments for meta function eclClusterSpecialTrackMatched");
2831 if (arguments.size() == 2) {
2832 std::string listName = arguments[0];
2835 auto func = [listName, var](
const Particle*) ->
double {
2836 StoreObjPtr<ParticleList> listOfParticles(listName);
2838 if (!(listOfParticles.isValid())) B2FATAL(
"Invalid list name " << listName <<
" given to averageValueInList");
2839 int nParticles = listOfParticles->getListSize();
2840 if (nParticles == 0)
2845 if (std::holds_alternative<double>(var->function(listOfParticles->getParticle(0))))
2847 for (
int i = 0; i < nParticles; i++) {
2848 average += std::get<double>(var->function(listOfParticles->getParticle(i))) / nParticles;
2850 }
else if (std::holds_alternative<int>(var->function(listOfParticles->getParticle(0))))
2852 for (
int i = 0; i < nParticles; i++) {
2853 average += std::get<int>(var->function(listOfParticles->getParticle(i))) / nParticles;
2860 B2FATAL(
"Wrong number of arguments for meta function averageValueInList");
2866 if (arguments.size() == 2) {
2867 std::string listName = arguments[0];
2870 auto func = [listName, var](
const Particle*) ->
double {
2871 StoreObjPtr<ParticleList> listOfParticles(listName);
2873 if (!(listOfParticles.isValid())) B2FATAL(
"Invalid list name " << listName <<
" given to medianValueInList");
2874 int nParticles = listOfParticles->getListSize();
2875 if (nParticles == 0)
2879 std::vector<double> valuesInList;
2880 if (std::holds_alternative<double>(var->function(listOfParticles->getParticle(0))))
2882 for (
int i = 0; i < nParticles; i++) {
2883 valuesInList.push_back(std::get<double>(var->function(listOfParticles->getParticle(i))));
2885 }
else if (std::holds_alternative<int>(var->function(listOfParticles->getParticle(0))))
2887 for (
int i = 0; i < nParticles; i++) {
2888 valuesInList.push_back(std::get<int>(var->function(listOfParticles->getParticle(i))));
2891 std::sort(valuesInList.begin(), valuesInList.end());
2892 if (nParticles % 2 != 0)
2894 return valuesInList[nParticles / 2];
2897 return 0.5 * (valuesInList[nParticles / 2] + valuesInList[nParticles / 2 - 1]);
2902 B2FATAL(
"Wrong number of arguments for meta function medianValueInList");
2908 if (arguments.size() == 2) {
2909 std::string listName = arguments[0];
2912 auto func = [listName, var](
const Particle*) ->
double {
2913 StoreObjPtr<ParticleList> listOfParticles(listName);
2915 if (!(listOfParticles.isValid())) B2FATAL(
"Invalid list name " << listName <<
" given to sumValueInList");
2916 int nParticles = listOfParticles->getListSize();
2917 if (nParticles == 0)
2922 if (std::holds_alternative<double>(var->function(listOfParticles->getParticle(0))))
2924 for (
int i = 0; i < nParticles; i++) {
2925 sum += std::get<double>(var->function(listOfParticles->getParticle(i)));
2927 }
else if (std::holds_alternative<int>(var->function(listOfParticles->getParticle(0))))
2929 for (
int i = 0; i < nParticles; i++) {
2930 sum += std::get<int>(var->function(listOfParticles->getParticle(i)));
2937 B2FATAL(
"Wrong number of arguments for meta function sumValueInList");
2943 if (arguments.size() == 2) {
2944 std::string listName = arguments[0];
2947 auto func = [listName, var](
const Particle*) ->
double {
2948 StoreObjPtr<ParticleList> listOfParticles(listName);
2950 if (!(listOfParticles.isValid())) B2FATAL(
"Invalid list name " << listName <<
" given to productValueInList");
2951 int nParticles = listOfParticles->getListSize();
2952 if (nParticles == 0)
2957 if (std::holds_alternative<double>(var->function(listOfParticles->getParticle(0))))
2959 for (
int i = 0; i < nParticles; i++) {
2960 product *= std::get<double>(var->function(listOfParticles->getParticle(i)));
2962 }
else if (std::holds_alternative<int>(var->function(listOfParticles->getParticle(0))))
2964 for (
int i = 0; i < nParticles; i++) {
2965 product *= std::get<int>(var->function(listOfParticles->getParticle(i)));
2972 B2FATAL(
"Wrong number of arguments for meta function productValueInList");
2979 if (arguments.size() != 1)
2980 B2FATAL(
"Wrong number of arguments for meta function angleToClosestInList");
2982 std::string listname = arguments[0];
2984 auto func = [listname](
const Particle * particle) ->
double {
2986 StoreObjPtr<ParticleList> list(listname);
2987 if (not list.isValid())
2988 B2FATAL(
"Invalid particle list name " << listname <<
" given to angleToClosestInList");
2991 if (list->getListSize() == 0)
2996 const auto p_this = frame.getMomentum(particle);
2999 double minAngle = 2 * M_PI;
3000 for (
unsigned int i = 0; i < list->getListSize(); ++i)
3002 const Particle* compareme = list->getParticle(i);
3003 const auto p_compare = frame.getMomentum(compareme);
3004 double angle = ROOT::Math::VectorUtil::Angle(p_compare, p_this);
3005 if (minAngle > angle) minAngle = angle;
3015 if (arguments.size() != 2)
3016 B2FATAL(
"Wrong number of arguments for meta function closestInList");
3018 std::string listname = arguments[0];
3023 auto func = [listname, var](
const Particle * particle) ->
double {
3025 StoreObjPtr<ParticleList> list(listname);
3026 if (not list.isValid())
3027 B2FATAL(
"Invalid particle list name " << listname <<
" given to closestInList");
3031 const auto p_this = frame.getMomentum(particle);
3034 double minAngle = 2 * M_PI;
3036 for (
unsigned int i = 0; i < list->getListSize(); ++i)
3038 const Particle* compareme = list->getParticle(i);
3039 const auto p_compare = frame.getMomentum(compareme);
3040 double angle = ROOT::Math::VectorUtil::Angle(p_compare, p_this);
3041 if (minAngle > angle) {
3049 auto var_result = var->function(list->getParticle(iClosest));
3050 if (std::holds_alternative<double>(var_result))
3052 return std::get<double>(var_result);
3053 }
else if (std::holds_alternative<int>(var_result))
3055 return std::get<int>(var_result);
3056 }
else if (std::holds_alternative<bool>(var_result))
3058 return std::get<bool>(var_result);
3067 if (arguments.size() != 1)
3068 B2FATAL(
"Wrong number of arguments for meta function angleToMostB2BInList");
3070 std::string listname = arguments[0];
3072 auto func = [listname](
const Particle * particle) ->
double {
3074 StoreObjPtr<ParticleList> list(listname);
3075 if (not list.isValid())
3076 B2FATAL(
"Invalid particle list name " << listname <<
" given to angleToMostB2BInList");
3079 if (list->getListSize() == 0)
3084 const auto p_this = frame.getMomentum(particle);
3088 double maxAngle = 0;
3089 for (
unsigned int i = 0; i < list->getListSize(); ++i)
3091 const Particle* compareme = list->getParticle(i);
3092 const auto p_compare = frame.getMomentum(compareme);
3093 double angle = ROOT::Math::VectorUtil::Angle(p_compare, p_this);
3094 if (maxAngle < angle) maxAngle = angle;
3104 if (arguments.size() != 1)
3105 B2FATAL(
"Wrong number of arguments for meta function deltaPhiToMostB2BPhiInList");
3107 std::string listname = arguments[0];
3109 auto func = [listname](
const Particle * particle) ->
double {
3111 StoreObjPtr<ParticleList> list(listname);
3112 if (not list.isValid())
3113 B2FATAL(
"Invalid particle list name " << listname <<
" given to deltaPhiToMostB2BPhiInList");
3116 if (list->getListSize() == 0)
3121 const auto phi_this = frame.getMomentum(particle).Phi();
3124 double maxAngle = 0;
3125 for (
unsigned int i = 0; i < list->getListSize(); ++i)
3127 const Particle* compareme = list->getParticle(i);
3128 const auto phi_compare = frame.getMomentum(compareme).Phi();
3129 double angle = std::abs(phi_compare - phi_this);
3130 if (angle > M_PI) {angle = 2 * M_PI - angle;}
3131 if (maxAngle < angle) maxAngle = angle;
3141 if (arguments.size() != 2)
3142 B2FATAL(
"Wrong number of arguments for meta function mostB2BInList");
3144 std::string listname = arguments[0];
3149 auto func = [listname, var](
const Particle * particle) ->
double {
3151 StoreObjPtr<ParticleList> list(listname);
3152 if (not list.isValid())
3153 B2FATAL(
"Invalid particle list name " << listname <<
" given to mostB2BInList");
3157 const auto p_this = frame.getMomentum(particle);
3161 double maxAngle = -1.0;
3163 for (
unsigned int i = 0; i < list->getListSize(); ++i)
3165 const Particle* compareme = list->getParticle(i);
3166 const auto p_compare = frame.getMomentum(compareme);
3167 double angle = ROOT::Math::VectorUtil::Angle(p_compare, p_this);
3168 if (maxAngle < angle) {
3176 auto var_result = var->function(list->getParticle(iMostB2B));
3177 if (std::holds_alternative<double>(var_result))
3179 return std::get<double>(var_result);
3180 }
else if (std::holds_alternative<int>(var_result))
3182 return std::get<int>(var_result);
3183 }
else if (std::holds_alternative<bool>(var_result))
3185 return std::get<bool>(var_result);
3193 if (arguments.size() == 1) {
3194 std::string listName = arguments[0];
3195 auto func = [listName](
const Particle*) ->
double {
3196 StoreObjPtr<ParticleList> listOfParticles(listName);
3198 if (!(listOfParticles.isValid())) B2FATAL(
"Invalid Listname " << listName <<
" given to maxOpeningAngleInList");
3199 int nParticles = listOfParticles->getListSize();
3204 double maxOpeningAngle = -1;
3205 for (
int i = 0; i < nParticles; i++)
3207 ROOT::Math::PxPyPzEVector
v1 = frame.getMomentum(listOfParticles->getParticle(i));
3208 for (
int j = i + 1; j < nParticles; j++) {
3209 ROOT::Math::PxPyPzEVector
v2 = frame.getMomentum(listOfParticles->getParticle(j));
3210 const double angle = ROOT::Math::VectorUtil::Angle(v1, v2);
3211 if (angle > maxOpeningAngle) maxOpeningAngle = angle;
3214 return maxOpeningAngle;
3218 B2FATAL(
"Wrong number of arguments for meta function maxOpeningAngleInList");
3225 if (arguments.size() >= 2) {
3230 auto func = [var, arguments](
const Particle * particle) ->
double {
3231 if (particle ==
nullptr)
3233 B2WARNING(
"Trying to access a daughter that does not exist. Skipping");
3239 ROOT::Math::PxPyPzEVector pSum(0, 0, 0, 0);
3243 for (
unsigned int iCoord = 1; iCoord < arguments.size(); iCoord++)
3245 auto generalizedIndex = arguments[iCoord];
3246 const Particle* dauPart = particle->getParticleFromGeneralizedIndexString(generalizedIndex);
3248 pSum += frame.getMomentum(dauPart);
3250 B2WARNING(
"Trying to access a daughter that does not exist. Index = " << generalizedIndex);
3256 Particle sumOfDaughters(pSum, 100);
3258 auto var_result = var->function(&sumOfDaughters);
3260 if (std::holds_alternative<double>(var_result))
3262 return std::get<double>(var_result);
3263 }
else if (std::holds_alternative<int>(var_result))
3265 return std::get<int>(var_result);
3266 }
else if (std::holds_alternative<bool>(var_result))
3268 return std::get<bool>(var_result);
3273 B2FATAL(
"Wrong number of arguments for meta function daughterCombination");
3276 Manager::FunctionPtr useAlternativeDaughterHypothesis(
const std::vector<std::string>& arguments)
3289 if (arguments.size() >= 2) {
3300 std::unordered_map<unsigned int, int> mapOfReplacedDaughters;
3303 for (
unsigned int iCoord = 1; iCoord < arguments.size(); iCoord++) {
3304 auto replacedDauString = arguments[iCoord];
3306 std::vector<std::string> indexAndMass;
3307 boost::split(indexAndMass, replacedDauString, boost::is_any_of(
":"));
3310 if (indexAndMass.size() > 2) {
3311 B2WARNING(
"The string indicating which daughter's mass should be replaced contains more than two elements separated by a colon. Perhaps you tried to pass a generalized index, which is not supported yet for this variable. The offending string is "
3312 << replacedDauString <<
", while a correct syntax looks like 0:K+.");
3316 if (indexAndMass.size() < 2) {
3317 B2WARNING(
"The string indicating which daughter's mass should be replaced contains only one colon-separated element instead of two. The offending string is "
3318 << replacedDauString <<
", while a correct syntax looks like 0:K+.");
3326 }
catch (std::invalid_argument&) {
3327 B2FATAL(
"Found the string " << indexAndMass[0] <<
"instead of a daughter index.");
3331 TParticlePDG* particlePDG = TDatabasePDG::Instance()->GetParticle(indexAndMass[1].c_str());
3333 B2WARNING(
"Particle not in evt.pdl file! " << indexAndMass[1]);
3338 int pdgCode = particlePDG->PdgCode();
3339 mapOfReplacedDaughters[dauIndex] = pdgCode;
3343 if (mapOfReplacedDaughters.size() != arguments.size() - 1)
3344 B2FATAL(
"Overlapped daughter's index is detected in the meta-variable useAlternativeDaughterHypothesis");
3352 auto func = [var, mapOfReplacedDaughters](
const Particle * particle) ->
double {
3353 if (particle ==
nullptr)
3355 B2WARNING(
"Trying to access a particle that does not exist. Skipping");
3365 ROOT::Math::PxPyPzMVector pSum(0, 0, 0, 0);
3367 for (
unsigned int iDau = 0; iDau < particle->getNDaughters(); iDau++)
3369 const Particle* dauPart = particle->getDaughter(iDau);
3371 B2WARNING(
"Trying to access a daughter that does not exist. Index = " << iDau);
3375 ROOT::Math::PxPyPzMVector dauMom = ROOT::Math::PxPyPzMVector(frame.getMomentum(dauPart));
3379 pdgCode = mapOfReplacedDaughters.at(iDau);
3380 }
catch (std::out_of_range&) {
3387 double p_x = dauMom.Px();
3388 double p_y = dauMom.Py();
3389 double p_z = dauMom.Pz();
3390 dauMom.SetCoordinates(p_x, p_y, p_z, TDatabasePDG::Instance()->GetParticle(pdgCode)->Mass());
3391 const_cast<Particle*
>(dummy->getDaughter(iDau))->set4VectorDividingByMomentumScaling(ROOT::Math::PxPyPzEVector(dauMom));
3394 const int charge = dummy->getDaughter(iDau)->getCharge();
3395 if (TDatabasePDG::Instance()->GetParticle(pdgCode)->Charge() / 3.0 == charge)
3396 const_cast<Particle*
>(dummy->getDaughter(iDau))->setPDGCode(pdgCode);
3398 const_cast<Particle*
>(dummy->getDaughter(iDau))->setPDGCode(-1 * pdgCode);
3404 dummy->set4Vector(ROOT::Math::PxPyPzEVector(pSum));
3406 auto var_result = var->function(dummy);
3409 if (std::holds_alternative<double>(var_result))
3411 return std::get<double>(var_result);
3412 }
else if (std::holds_alternative<int>(var_result))
3414 return std::get<int>(var_result);
3415 }
else if (std::holds_alternative<bool>(var_result))
3417 return std::get<bool>(var_result);
3423 B2FATAL(
"Wrong number of arguments for meta function useAlternativeDaughterHypothesis");
3428 if (arguments.size() == 2) {
3430 std::string arg = arguments[0];
3432 TParticlePDG* part = TDatabasePDG::Instance()->GetParticle(arg.c_str());
3434 if (part !=
nullptr) {
3435 pdg_code = std::abs(part->PdgCode());
3439 }
catch (std::exception& e) {}
3442 if (pdg_code == -1) {
3443 B2FATAL(
"Ancestor " + arg +
" is not recognised. Please provide valid PDG code or particle name.");
3446 auto func = [pdg_code, var](
const Particle * particle) ->
double {
3447 const Particle* p = particle;
3449 int ancestor_level = std::get<double>(
Manager::Instance().getVariable(
"hasAncestor(" + std::to_string(pdg_code) +
", 0)")->function(p));
3450 if ((ancestor_level <= 0) or (std::isnan(ancestor_level)))
3455 const MCParticle* i_p = p->getMCParticle();
3457 for (
int a = 0; a < ancestor_level ; a = a + 1)
3459 i_p = i_p->getMother();
3463 StoreArray<Particle> particles;
3464 Particle* newPart = particles.appendNew(m_p);
3465 newPart->addRelationTo(i_p);
3467 appendDaughtersRecursive(newPart);
3469 auto var_result = var->function(newPart);
3470 if (std::holds_alternative<double>(var_result))
3472 return std::get<double>(var_result);
3473 }
else if (std::holds_alternative<int>(var_result))
3475 return std::get<int>(var_result);
3476 }
else if (std::holds_alternative<bool>(var_result))
3478 return std::get<bool>(var_result);
3483 B2FATAL(
"Wrong number of arguments for meta function varForFirstMCAncestorOfType (expected 2: type and variable of interest)");
3489 if (arguments.size() != 1) {
3490 B2FATAL(
"Number of arguments for nTrackFitResults must be 1, particleType or PDGcode");
3493 std::string arg = arguments[0];
3494 TParticlePDG* part = TDatabasePDG::Instance()->GetParticle(arg.c_str());
3496 if (part !=
nullptr) {
3497 absPdg = std::abs(part->PdgCode());
3501 }
catch (std::exception& e) {}
3504 auto func = [absPdg](
const Particle*) ->
int {
3506 Const::ChargedStable type(absPdg);
3507 StoreArray<Track> tracks;
3509 int nTrackFitResults = 0;
3511 for (
const auto& track : tracks)
3513 const TrackFitResult* trackFit = track.getTrackFitResultWithClosestMass(type);
3515 if (!trackFit)
continue;
3516 if (trackFit->getChargeSign() == 0)
continue;
3521 return nTrackFitResults;
3530 if (arguments.size() == 2) {
3533 auto func = [var, default_val](
const Particle * particle) ->
int {
3534 auto var_result = var->function(particle);
3535 if (std::holds_alternative<double>(var_result))
3537 double value = std::get<double>(var_result);
3538 if (value > std::numeric_limits<int>::max())
3539 value = std::numeric_limits<int>::max();
3540 if (value < std::numeric_limits<int>::min())
3541 value = std::numeric_limits<int>::min();
3542 if (std::isnan(value))
3543 value = default_val;
3544 return static_cast<int>(value);
3545 }
else if (std::holds_alternative<int>(var_result))
3546 return std::get<int>(var_result);
3547 else if (std::holds_alternative<bool>(var_result))
3548 return static_cast<int>(std::get<bool>(var_result));
3549 else return default_val;
3553 B2FATAL(
"Wrong number of arguments for meta function int, please provide variable name and replacement value for NaN!");
3557 VARIABLE_GROUP(
"MetaFunctions");
3558 REGISTER_METAVARIABLE(
"nCleanedECLClusters(cut)", nCleanedECLClusters,
3559 "[Eventbased] Returns the number of clean Clusters in the event\n"
3560 "Clean clusters are defined by the clusters which pass the given cut assuming a photon hypothesis.",
3561 Manager::VariableDataType::c_int);
3562 REGISTER_METAVARIABLE(
"nCleanedTracks(cut)", nCleanedTracks,
3563 "[Eventbased] Returns the number of clean Tracks in the event\n"
3564 "Clean tracks are defined by the tracks which pass the given cut assuming a pion hypothesis.", Manager::VariableDataType::c_int);
3565 REGISTER_METAVARIABLE(
"formula(v1 + v2 * [v3 - v4] / v5^v6)", formula, R
"DOCSTRING(
3566Returns the result of the given formula, where v1 to vN are variables or floating
3567point numbers. Currently the only supported operations are addition (``+``),
3568subtraction (``-``), multiplication (``*``), division (``/``) and power (``^``
3569or ``**``). Parenthesis can be in the form of square brackets ``[v1 * v2]``
3570or normal brackets ``(v1 * v2)``. It will work also with variables taking
3571arguments. Operator precedence is taken into account. For example ::
3573 (daughter(0, E) + daughter(1, E))**2 - p**2 + 0.138
3575.. versionchanged:: release-03-00-00
3576 now both, ``[]`` and ``()`` can be used for grouping operations, ``**`` can
3577 be used for exponent and float literals are possible directly in the
3579)DOCSTRING", Manager::VariableDataType::c_double);
3580 REGISTER_METAVARIABLE("useRestFrame(variable)", useRestFrame,
3581 "Returns the value of the variable using the rest frame of the given particle as current reference frame.\n"
3582 "E.g. ``useRestFrame(daughter(0, p))`` returns the total momentum of the first daughter in its mother's rest-frame", Manager::VariableDataType::c_double);
3583 REGISTER_METAVARIABLE(
"useCMSFrame(variable)", useCMSFrame,
3584 "Returns the value of the variable using the CMS frame as current reference frame.\n"
3585 "E.g. ``useCMSFrame(E)`` returns the energy of a particle in the CMS frame.", Manager::VariableDataType::c_double);
3586 REGISTER_METAVARIABLE(
"useLabFrame(variable)", useLabFrame, R
"DOC(
3587Returns the value of ``variable`` in the *lab* frame.
3590 The lab frame is the default reference frame, usually you don't need to use this meta-variable.
3591 E.g. ``useLabFrame(E)`` returns the energy of a particle in the Lab frame, same as just ``E``.
3593Specifying the lab frame is useful in some corner-cases. For example:
3594``useRestFrame(daughter(0, formula(E - useLabFrame(E))))`` which is the difference of the first daughter's energy in the rest frame of the mother (current particle) with the same daughter's lab-frame energy.
3595)DOC", Manager::VariableDataType::c_double);
3596 REGISTER_METAVARIABLE("useTagSideRecoilRestFrame(variable, daughterIndexTagB)", useTagSideRecoilRestFrame,
3597 "Returns the value of the variable in the rest frame of the recoiling particle to the tag side B meson.\n"
3598 "The variable should only be applied to an Upsilon(4S) list.\n"
3599 "E.g. ``useTagSideRecoilRestFrame(daughter(1, daughter(1, p)), 0)`` applied on a Upsilon(4S) list (``Upsilon(4S)->B+:tag B-:sig``) returns the momentum of the second daughter of the signal B meson in the signal B meson rest frame.", Manager::VariableDataType::c_double);
3600 REGISTER_METAVARIABLE(
"useParticleRestFrame(variable, particleList)", useParticleRestFrame,
3601 "Returns the value of the variable in the rest frame of the first Particle contained in the given ParticleList.\n"
3602 "It is strongly recommended to pass a ParticleList that contains at most only one Particle in each event. "
3603 "When more than one Particle is present in the ParticleList, only the first Particle in the list is used for "
3604 "computing the rest frame and a warning is thrown. If the given ParticleList is empty in an event, it returns NaN.", Manager::VariableDataType::c_double);
3605 REGISTER_METAVARIABLE(
"useRecoilParticleRestFrame(variable, particleList)", useRecoilParticleRestFrame,
3606 "Returns the value of the variable in the rest frame of recoil system against the first Particle contained in the given ParticleList.\n"
3607 "It is strongly recommended to pass a ParticleList that contains at most only one Particle in each event. "
3608 "When more than one Particle is present in the ParticleList, only the first Particle in the list is used for "
3609 "computing the rest frame and a warning is thrown. If the given ParticleList is empty in an event, it returns NaN.", Manager::VariableDataType::c_double);
3610 REGISTER_METAVARIABLE(
"useDaughterRestFrame(variable, daughterIndex_1, [daughterIndex_2, ... daughterIndex_3])", useDaughterRestFrame,
3611 "Returns the value of the variable in the rest frame of the selected daughter particle.\n"
3612 "The daughter is identified via generalized daughter index, e.g. ``0:1`` identifies the second daughter (1) "
3613 "of the first daughter (0). If the daughter index is invalid, it returns NaN.\n"
3614 "If two or more indices are given, the rest frame of the sum of the daughters is used.",
3615 Manager::VariableDataType::c_double);
3616 REGISTER_METAVARIABLE(
"useDaughterRecoilRestFrame(variable, daughterIndex_1, [daughterIndex_2, ... daughterIndex_3])", useDaughterRecoilRestFrame,
3617 "Returns the value of the variable in the rest frame of the recoil of the selected daughter particle.\n"
3618 "The daughter is identified via generalized daughter index, e.g. ``0:1`` identifies the second daughter (1) "
3619 "of the first daughter (0). If the daughter index is invalid, it returns NaN.\n"
3620 "If two or more indices are given, the rest frame of the sum of the daughters is used.",
3621 Manager::VariableDataType::c_double);
3622 REGISTER_METAVARIABLE(
"useMCancestorBRestFrame(variable)", useMCancestorBRestFrame,
3623 "Returns the value of the variable in the rest frame of the ancestor B MC particle.\n"
3624 "If no B or no MC-matching is found, it returns NaN.", Manager::VariableDataType::c_double);
3625 REGISTER_METAVARIABLE(
"passesCut(cut)", passesCut,
3626 "Returns 1 if particle passes the cut otherwise 0.\n"
3627 "Useful if you want to write out if a particle would have passed a cut or not.", Manager::VariableDataType::c_bool);
3628 REGISTER_METAVARIABLE(
"passesEventCut(cut)", passesEventCut,
3629 "[Eventbased] Returns 1 if event passes the cut otherwise 0.\n"
3630 "Useful if you want to select events passing a cut without looping into particles, such as for skimming.\n", Manager::VariableDataType::c_bool);
3631 REGISTER_METAVARIABLE(
"countDaughters(cut)", countDaughters,
3632 "Returns number of direct daughters which satisfy the cut.\n"
3633 "Used by the skimming package (for what exactly?)", Manager::VariableDataType::c_int);
3634 REGISTER_METAVARIABLE(
"countFSPDaughters(cut)", countDescendants,
3635 "Returns number of final-state daughters which satisfy the cut.",
3636 Manager::VariableDataType::c_int);
3637 REGISTER_METAVARIABLE(
"countDescendants(cut)", countDescendants,
3638 "Returns number of descendants for all generations which satisfy the cut.",
3639 Manager::VariableDataType::c_int);
3640 REGISTER_METAVARIABLE(
"varFor(pdgCode, variable)", varFor,
3641 "Returns the value of the variable for the given particle if its abs(pdgCode) agrees with the given one.\n"
3642 "E.g. ``varFor(11, p)`` returns the momentum if the particle is an electron or a positron.", Manager::VariableDataType::c_double);
3643 REGISTER_METAVARIABLE(
"varForMCGen(variable)", varForMCGen,
3644 "Returns the value of the variable for the given particle if the MC particle related to it is primary, not virtual, and not initial.\n"
3645 "If no MC particle is related to the given particle, or the MC particle is not primary, virtual, or initial, NaN will be returned.\n"
3646 "E.g. ``varForMCGen(PDG)`` returns the PDG code of the MC particle related to the given particle if it is primary, not virtual, and not initial.", Manager::VariableDataType::c_double);
3647 REGISTER_METAVARIABLE(
"nParticlesInList(particleListName)", nParticlesInList,
3648 "[Eventbased] Returns number of particles in the given particle List.", Manager::VariableDataType::c_int);
3649 REGISTER_METAVARIABLE(
"isInList(particleListName)", isInList,
3650 "Returns 1 if the particle is in the list provided, 0 if not. Note that this only checks the particle given. For daughters of composite particles, please see :b2:var:`isDaughterOfList`.", Manager::VariableDataType::c_bool);
3651 REGISTER_METAVARIABLE(
"isDaughterOfList(particleListNames)", isDaughterOfList,
3652 "Returns 1 if the given particle is a daughter of at least one of the particles in the given particle Lists.", Manager::VariableDataType::c_bool);
3653 REGISTER_METAVARIABLE(
"isDescendantOfList(particleListName[, anotherParticleListName][, generationFlag = -1])", isDescendantOfList, R
"DOC(
3654 Returns 1 if the given particle appears in the decay chain of the particles in the given ParticleLists.
3656 Passing an integer as the last argument, allows to check if the particle belongs to the specific generation:
3658 * ``isDescendantOfList(<particle_list>,1)`` returns 1 if particle is a daughter of the list,
3659 * ``isDescendantOfList(<particle_list>,2)`` returns 1 if particle is a granddaughter of the list,
3660 * ``isDescendantOfList(<particle_list>,3)`` returns 1 if particle is a great-granddaughter of the list, etc.
3661 * Default value is ``-1`` that is inclusive for all generations.
3662 )DOC", Manager::VariableDataType::c_bool);
3663 REGISTER_METAVARIABLE("isMCDescendantOfList(particleListName[, anotherParticleListName][, generationFlag = -1])", isMCDescendantOfList, R
"DOC(
3664 Returns 1 if the given particle is linked to the same MC particle as any reconstructed daughter of the decay lists.
3666 Passing an integer as the last argument, allows to check if the particle belongs to the specific generation:
3668 * ``isMCDescendantOfList(<particle_list>,1)`` returns 1 if particle is matched to the same particle as any daughter of the list,
3669 * ``isMCDescendantOfList(<particle_list>,2)`` returns 1 if particle is matched to the same particle as any granddaughter of the list,
3670 * ``isMCDescendantOfList(<particle_list>,3)`` returns 1 if particle is matched to the same particle as any great-granddaughter of the list, etc.
3671 * Default value is ``-1`` that is inclusive for all generations.
3673 It makes only sense for lists created with `fillParticleListFromMC` function with ``addDaughters=True`` argument.
3674 )DOC", Manager::VariableDataType::c_bool);
3676 REGISTER_METAVARIABLE("sourceObjectIsInList(particleListName)", sourceObjectIsInList, R
"DOC(
3677Returns 1 if the underlying mdst object (e.g. track, or cluster) was used to create a particle in ``particleListName``, 0 if not.
3680 This only makes sense for particles that are not composite. Returns -1 for composite particles.
3681)DOC", Manager::VariableDataType::c_int);
3683 REGISTER_METAVARIABLE("mcParticleIsInMCList(particleListName)", mcParticleIsInMCList, R
"DOC(
3684Returns 1 if the particle's matched MC particle is also matched to a particle in ``particleListName``
3685(or if either of the lists were filled from generator level `modularAnalysis.fillParticleListFromMC`.)
3687.. seealso:: :b2:var:`isMCDescendantOfList` to check daughters.
3688)DOC", Manager::VariableDataType::c_bool);
3690 REGISTER_METAVARIABLE("isGrandDaughterOfList(particleListNames)", isGrandDaughterOfList,
3691 "Returns 1 if the given particle is a grand daughter of at least one of the particles in the given particle Lists.", Manager::VariableDataType::c_bool);
3692 REGISTER_METAVARIABLE(
"originalParticle(variable)", originalParticle, R
"DOC(
3693 Returns value of variable for the original particle from which the given particle is copied.
3695 The copy of particle is created, for example, when the vertex fit updates the daughters and `modularAnalysis.copyParticles` is called.
3696 Returns NaN if the given particle is not copied and so there is no original particle.
3697 )DOC", Manager::VariableDataType::c_double);
3698 REGISTER_METAVARIABLE("daughter(i, variable)", daughter, R
"DOC(
3699 Returns value of variable for the i-th daughter. E.g.
3701 * ``daughter(0, p)`` returns the total momentum of the first daughter.
3702 * ``daughter(0, daughter(1, p)`` returns the total momentum of the second daughter of the first daughter.
3704 Returns NaN if particle is nullptr or if the given daughter-index is out of bound (>= amount of daughters).
3705 )DOC", Manager::VariableDataType::c_double);
3706 REGISTER_METAVARIABLE("originalDaughter(i, variable)", originalDaughter, R
"DOC(
3707 Returns value of variable for the original particle from which the i-th daughter is copied.
3709 The copy of particle is created, for example, when the vertex fit updates the daughters and `modularAnalysis.copyParticles` is called.
3710 Returns NaN if the daughter is not copied and so there is no original daughter.
3712 Returns NaN if particle is nullptr or if the given daughter-index is out of bound (>= amount of daughters).
3713 )DOC", Manager::VariableDataType::c_double);
3714 REGISTER_METAVARIABLE("mcDaughter(i, variable)", mcDaughter, R
"DOC(
3715 Returns the value of the requested variable for the i-th Monte Carlo daughter of the particle.
3717 Returns NaN if the particle is nullptr, if the particle is not matched to an MC particle,
3718 or if the i-th MC daughter does not exist.
3720 E.g. ``mcDaughter(0, PDG)`` will return the PDG code of the first MC daughter of the matched MC
3721 particle of the reconstructed particle the function is applied to.
3723 The meta variable can also be nested: ``mcDaughter(0, mcDaughter(1, PDG))``.
3724 )DOC", Manager::VariableDataType::c_double);
3725 REGISTER_METAVARIABLE("mcMother(variable)", mcMother, R
"DOC(
3726 Returns the value of the requested variable for the Monte Carlo mother of the particle.
3728 Returns NaN if the particle is nullptr, if the particle is not matched to an MC particle,
3729 or if the MC mother does not exist.
3731 E.g. ``mcMother(PDG)`` will return the PDG code of the MC mother of the matched MC
3732 particle of the reconstructed particle the function is applied to.
3734 The meta variable can also be nested: ``mcMother(mcMother(PDG))``.
3735 )DOC", Manager::VariableDataType::c_double);
3736 REGISTER_METAVARIABLE("genParticle(index, variable)", genParticle, R
"DOC(
3737[Eventbased] Returns the ``variable`` for the ith generator particle.
3738The arguments of the function must be the ``index`` of the particle in the MCParticle Array,
3739and ``variable``, the name of the function or variable for that generator particle.
3740If ``index`` goes beyond the length of the MCParticles array, NaN will be returned.
3742E.g. ``genParticle(0, p)`` returns the total momentum of the first MCParticle, which in a generic decay up to MC15 is
3743the Upsilon(4S) and for MC16 and beyond the initial electron.
3744)DOC", Manager::VariableDataType::c_double);
3745 REGISTER_METAVARIABLE("genUpsilon4S(variable)", genUpsilon4S, R
"DOC(
3746[Eventbased] Returns the ``variable`` evaluated for the generator-level :math:`\Upsilon(4S)`.
3747If no generator level :math:`\Upsilon(4S)` exists for the event, NaN will be returned.
3749E.g. ``genUpsilon4S(p)`` returns the total momentum of the :math:`\Upsilon(4S)` in a generic decay.
3750``genUpsilon4S(mcDaughter(1, p))`` returns the total momentum of the second daughter of the
3751generator-level :math:`\Upsilon(4S)` (i.e. the momentum of the second B meson in a generic decay).
3752)DOC", Manager::VariableDataType::c_double);
3753 REGISTER_METAVARIABLE("daughterProductOf(variable)", daughterProductOf,
3754 "Returns product of a variable over all daughters.\n"
3755 "E.g. ``daughterProductOf(extraInfo(SignalProbability))`` returns the product of the SignalProbabilitys of all daughters.", Manager::VariableDataType::c_double);
3756 REGISTER_METAVARIABLE(
"daughterSumOf(variable)", daughterSumOf,
3757 "Returns sum of a variable over all daughters.\n"
3758 "E.g. ``daughterSumOf(nDaughters)`` returns the number of grand-daughters.", Manager::VariableDataType::c_double);
3759 REGISTER_METAVARIABLE(
"daughterLowest(variable)", daughterLowest,
3760 "Returns the lowest value of the given variable among all daughters.\n"
3761 "E.g. ``useCMSFrame(daughterLowest(p))`` returns the lowest momentum in CMS frame.", Manager::VariableDataType::c_double);
3762 REGISTER_METAVARIABLE(
"daughterHighest(variable)", daughterHighest,
3763 "Returns the highest value of the given variable among all daughters.\n"
3764 "E.g. ``useCMSFrame(daughterHighest(p))`` returns the highest momentum in CMS frame.", Manager::VariableDataType::c_double);
3765 REGISTER_METAVARIABLE(
"daughterDiffOf(daughterIndex_i, daughterIndex_j, variable)", daughterDiffOf, R
"DOC(
3766 Returns the difference of a variable between the two given daughters.
3767 E.g. ``useRestFrame(daughterDiffOf(0, 1, p))`` returns the momentum difference between first and second daughter in the rest frame of the given particle.
3768 (That means that it returns :math:`p_j - p_i`)
3770 The daughters can be provided as generalized daughter indexes, which are simply colon-separated
3771 lists of daughter indexes, ordered starting from the root particle. For example, ``0:1``
3772 identifies the second daughter (1) of the first daughter (0) of the mother particle.
3774 )DOC", Manager::VariableDataType::c_double);
3775 REGISTER_METAVARIABLE("mcDaughterDiffOf(i, j, variable)", mcDaughterDiffOf,
3776 "MC matched version of the `daughterDiffOf` function.", Manager::VariableDataType::c_double);
3777 REGISTER_METAVARIABLE(
"grandDaughterDiffOf(i, j, variable)", grandDaughterDiffOf,
3778 "Returns the difference of a variable between the first daughters of the two given daughters.\n"
3779 "E.g. ``useRestFrame(grandDaughterDiffOf(0, 1, p))`` returns the momentum difference between the first daughters of the first and second daughter in the rest frame of the given particle.\n"
3780 "(That means that it returns :math:`p_j - p_i`)", Manager::VariableDataType::c_double);
3781 MAKE_DEPRECATED(
"grandDaughterDiffOf",
false,
"light-2402-ocicat", R
"DOC(
3782 The difference between any combination of (grand-)daughters can be calculated with the more general variable :b2:var:`daughterDiffOf`
3783 by using generalized daughter indexes.)DOC");
3784 REGISTER_METAVARIABLE("daughterDiffOfPhi(i, j)", daughterDiffOfPhi,
3785 "Returns the difference in :math:`\\phi` between the two given daughters. The unit of the angle is ``rad``.\n"
3786 "The difference is signed and takes account of the ordering of the given daughters.\n"
3787 "The function returns :math:`\\phi_j - \\phi_i`.", Manager::VariableDataType::c_double);
3789 The difference of the azimuthal angle :math:`\\phi` of two daughters can be calculated with the generic variable :b2:var:`daughterDiffOf`.)DOC");
3790 REGISTER_METAVARIABLE("mcDaughterDiffOfPhi(i, j)", mcDaughterDiffOfPhi,
3791 "MC matched version of the `daughterDiffOfPhi` function. The unit of the angle is ``rad``", Manager::VariableDataType::c_double);
3792 MAKE_DEPRECATED(
"mcDaughterDiffOfPhi",
true,
"release-06-00-00", R
"DOC(
3793 The difference of the azimuthal angle :math:`\\phi` of the MC partners of two daughters can be calculated with the generic variable :b2:var:`mcDaughterDiffOf`.)DOC");
3794 REGISTER_METAVARIABLE("grandDaughterDiffOfPhi(i, j)", grandDaughterDiffOfPhi,
3795 "Returns the difference in :math:`\\phi` between the first daughters of the two given daughters. The unit of the angle is ``rad``.\n"
3796 "The difference is signed and takes account of the ordering of the given daughters.\n"
3797 "The function returns :math:`\\phi_j - \\phi_i`.\n", Manager::VariableDataType::c_double);
3798 MAKE_DEPRECATED(
"grandDaughterDiffOfPhi",
true,
"release-06-00-00", R
"DOC(
3799 The difference of the azimuthal angle :math:`\\phi` of two granddaughters can be calculated with the generic variable :b2:var:`grandDaughterDiffOf`.)DOC");
3800 REGISTER_METAVARIABLE("daughterDiffOfClusterPhi(i, j)", daughterDiffOfClusterPhi,
3801 "Returns the difference in :math:`\\phi` between the ECLClusters of two given daughters. The unit of the angle is ``rad``.\n"
3802 "The difference is signed and takes account of the ordering of the given daughters.\n"
3803 "The function returns :math:`\\phi_j - \\phi_i`.\n"
3804 "The function returns NaN if at least one of the daughters is not matched to or not based on an ECLCluster.", Manager::VariableDataType::c_double);
3805 MAKE_DEPRECATED(
"daughterDiffOfClusterPhi",
true,
"release-06-00-00", R
"DOC(
3806 The difference of the azimuthal angle :math:`\\phi` of the related ECL clusters of two daughters can be calculated with the generic variable :b2:var:`daughterDiffOf`.)DOC");
3807 REGISTER_METAVARIABLE("grandDaughterDiffOfClusterPhi(i, j)", grandDaughterDiffOfClusterPhi,
3808 "Returns the difference in :math:`\\phi` between the ECLClusters of the daughters of the two given daughters. The unit of the angle is ``rad``.\n"
3809 "The difference is signed and takes account of the ordering of the given daughters.\n"
3810 "The function returns :math:`\\phi_j - \\phi_i`.\n"
3811 "The function returns NaN if at least one of the daughters is not matched to or not based on an ECLCluster.\n", Manager::VariableDataType::c_double);
3812 MAKE_DEPRECATED(
"grandDaughterDiffOfClusterPhi",
true,
"release-06-00-00", R
"DOC(
3813 The difference of the azimuthal angle :math:`\\phi` of the related ECL clusters of two granddaughters can be calculated with the generic variable :b2:var:`grandDaughterDiffOf`.)DOC");
3814 REGISTER_METAVARIABLE("daughterDiffOfPhiCMS(i, j)", daughterDiffOfPhiCMS,
3815 "Returns the difference in :math:`\\phi` between the two given daughters in the CMS frame. The unit of the angle is ``rad``.\n"
3816 "The difference is signed and takes account of the ordering of the given daughters.\n"
3817 "The function returns :math:`\\phi_j - \\phi_i`.", Manager::VariableDataType::c_double);
3818 MAKE_DEPRECATED(
"daughterDiffOfPhiCMS",
true,
"release-06-00-00", R
"DOC(
3819 The difference of the azimuthal angle :math:`\\phi` of two daughters in the CMS frame can be calculated with the generic variable :b2:var:`daughterDiffOf`.)DOC");
3820 REGISTER_METAVARIABLE("mcDaughterDiffOfPhiCMS(i, j)", daughterDiffOfPhiCMS,
3821 "MC matched version of the `daughterDiffOfPhiCMS` function. The unit of the angle is ``rad``", Manager::VariableDataType::c_double);
3822 MAKE_DEPRECATED(
"mcDaughterDiffOfPhiCMS",
true,
"release-06-00-00", R
"DOC(
3823 The difference of the azimuthal angle :math:`\\phi` of the MC partners of two daughters in the CMS frame can be calculated with the generic variable :b2:var:`mcDaughterDiffOf`.)DOC");
3824 REGISTER_METAVARIABLE("daughterDiffOfClusterPhiCMS(i, j)", daughterDiffOfClusterPhiCMS,
3825 "Returns the difference in :math:`\\phi` between the ECLClusters of two given daughters in the CMS frame. The unit of the angle is ``rad``.\n"
3826 "The difference is signed and takes account of the ordering of the given daughters.\n"
3827 "The function returns :math:`\\phi_j - \\phi_i``.\n"
3828 "The function returns NaN if at least one of the daughters is not matched to or not based on an ECLCluster.", Manager::VariableDataType::c_double);
3829 MAKE_DEPRECATED(
"daughterDiffOfClusterPhiCMS",
true,
"release-06-00-00", R
"DOC(
3830 The difference of the azimuthal angle :math:`\\phi` of the related ECL clusters of two daughters in the CMS frame can be calculated with the generic variable :b2:var:`daughterDiffOf`.)DOC");
3831 REGISTER_METAVARIABLE("daughterNormDiffOf(i, j, variable)", daughterNormDiffOf,
3832 "Returns the normalized difference of a variable between the two given daughters.\n"
3833 "E.g. ``daughterNormDiffOf(0, 1, p)`` returns the normalized momentum difference between first and second daughter in the lab frame.", Manager::VariableDataType::c_double);
3834 REGISTER_METAVARIABLE(
"daughterMotherDiffOf(i, variable)", daughterMotherDiffOf,
3835 "Returns the difference of a variable between the given daughter and the mother particle itself.\n"
3836 "E.g. ``useRestFrame(daughterMotherDiffOf(0, p))`` returns the momentum difference between the given particle and its first daughter in the rest frame of the mother.", Manager::VariableDataType::c_double);
3837 REGISTER_METAVARIABLE(
"daughterMotherNormDiffOf(i, variable)", daughterMotherNormDiffOf,
3838 "Returns the normalized difference of a variable between the given daughter and the mother particle itself.\n"
3839 "E.g. ``daughterMotherNormDiffOf(1, p)`` returns the normalized momentum difference between the given particle and its second daughter in the lab frame.", Manager::VariableDataType::c_double);
3840 REGISTER_METAVARIABLE(
"angleBetweenDaughterAndRecoil(daughterIndex_1, daughterIndex_2, ... )", angleBetweenDaughterAndRecoil, R
"DOC(
3841 Returns the angle between the momentum recoiling against the particle and the sum of the momenta of the given daughters.
3842 The unit of the angle is ``rad``.
3844 The particles are identified via generalized daughter indexes, which are simply colon-separated lists of
3845 daughter indexes, ordered starting from the root particle. For example, ``0:1:3`` identifies the fourth
3846 daughter (3) of the second daughter (1) of the first daughter (0) of the mother particle. ``1`` simply
3847 identifies the second daughter of the root particle.
3849 At least one generalized index has to be given to ``angleBetweenDaughterAndRecoil``.
3852 ``angleBetweenDaughterAndRecoil(0)`` will return the angle between pRecoil and the momentum of the first daughter.
3854 ``angleBetweenDaughterAndRecoil(0, 1)`` will return the angle between pRecoil and the sum of the momenta of the first and second daughter.
3856 ``angleBetweenDaughterAndRecoil(0:0, 3:0)`` will return the angle between pRecoil and the sum of the momenta of the: first daughter of the first daughter, and
3857 the first daughter of the fourth daughter.)DOC", Manager::VariableDataType::c_double);
3858 REGISTER_METAVARIABLE("angleBetweenDaughterAndMissingMomentum(daughterIndex_1, daughterIndex_2, ... )", angleBetweenDaughterAndMissingMomentum, R
"DOC(
3859 Returns the angle between the missing momentum in the event and the sum of the momenta of the given daughters.
3860 The unit of the angle is ``rad``. EventKinematics module has to be called to use this.
3862 The particles are identified via generalized daughter indexes, which are simply colon-separated lists of
3863 daughter indexes, ordered starting from the root particle. For example, ``0:1:3`` identifies the fourth
3864 daughter (3) of the second daughter (1) of the first daughter (0) of the mother particle. ``1`` simply
3865 identifies the second daughter of the root particle.
3867 At least one generalized index has to be given to ``angleBetweenDaughterAndMissingMomentum``.
3870 ``angleBetweenDaughterAndMissingMomentum(0)`` will return the angle between missMom and the momentum of the first daughter.
3872 ``angleBetweenDaughterAndMissingMomentum(0, 1)`` will return the angle between missMom and the sum of the momenta of the first and second daughter.
3874 ``angleBetweenDaughterAndMissingMomentum(0:0, 3:0)`` will return the angle between missMom and the sum of the momenta of the: first daughter of the first daughter, and
3875 the first daughter of the fourth daughter.)DOC", Manager::VariableDataType::c_double);
3876 REGISTER_METAVARIABLE("daughterAngle(daughterIndex_1, daughterIndex_2[, daughterIndex_3])", daughterAngle, R
"DOC(
3877 Returns the angle in between any pair of particles belonging to the same decay tree.
3878 The unit of the angle is ``rad``.
3880 The particles are identified via generalized daughter indexes, which are simply colon-separated lists of
3881 daughter indexes, ordered starting from the root particle. For example, ``0:1:3`` identifies the fourth
3882 daughter (3) of the second daughter (1) of the first daughter (0) of the mother particle. ``1`` simply
3883 identifies the second daughter of the root particle.
3885 Both two and three generalized indexes can be given to ``daughterAngle``. If two indices are given, the
3886 variable returns the angle between the momenta of the two given particles. If three indices are given, the
3887 variable returns the angle between the momentum of the third particle and a vector which is the sum of the
3888 first two daughter momenta.
3891 ``daughterAngle(0, 3)`` will return the angle between the first and fourth daughter.
3892 ``daughterAngle(0, 1, 3)`` will return the angle between the fourth daughter and the sum of the first and
3894 ``daughterAngle(0:0, 3:0)`` will return the angle between the first daughter of the first daughter, and
3895 the first daughter of the fourth daughter.
3897 )DOC", Manager::VariableDataType::c_double);
3898 REGISTER_METAVARIABLE("mcDaughterAngle(daughterIndex_1, daughterIndex_2, [daughterIndex_3])", mcDaughterAngle,
3899 "MC matched version of the `daughterAngle` function. Also works if applied directly to MC particles. The unit of the angle is ``rad``", Manager::VariableDataType::c_double);
3900 REGISTER_VARIABLE(
"grandDaughterDecayAngle(i, j)", grandDaughterDecayAngle,
3901 "Returns the decay angle of the granddaughter in the daughter particle's rest frame.\n"
3902 "It is calculated with respect to the reverted momentum vector of the particle.\n"
3903 "Two arguments representing the daughter and granddaughter indices have to be provided as arguments.\n\n",
"rad");
3904 REGISTER_VARIABLE(
"daughterClusterAngleInBetween(i, j)", daughterClusterAngleInBetween,
3905 "Returns the angle between clusters associated to the two daughters."
3906 "If two indices given: returns the angle between the momenta of the clusters associated to the two given daughters."
3907 "If three indices given: returns the angle between the momentum of the third particle's cluster and a vector "
3908 "which is the sum of the first two daughter's cluster momenta."
3909 "Returns nan if any of the daughters specified don't have an associated cluster."
3910 "The arguments in the argument vector must be integers corresponding to the ith and jth (and kth) daughters.\n\n",
"rad");
3911 REGISTER_METAVARIABLE(
"daughterInvM(i[, j, ...])", daughterInvM, R
"DOC(
3912 Returns the invariant mass adding the Lorentz vectors of the given daughters. The unit of the invariant mass is GeV/:math:`\text{c}^2`
3913 E.g. ``daughterInvM(0, 1, 2)`` returns the invariant Mass :math:`m = \sqrt{(p_0 + p_1 + p_2)^2}` of the first, second and third daughter.
3915 Daughters from different generations of the decay tree can be combined using generalized daughter indexes,
3916 which are simply colon-separated daughter indexes for each generation, starting from the root particle. For
3917 example, ``0:1:3`` identifies the fourth daughter (3) of the second daughter (1) of the first daughter(0) of
3918 the mother particle.
3920 Returns NaN if the given daughter-index is out of bound (>= number of daughters))DOC", Manager::VariableDataType::c_double);
3921 REGISTER_METAVARIABLE("extraInfo(name)", extraInfo,
3922 "Returns extra info stored under the given name.\n"
3923 "The extraInfo has to be set by a module first.\n"
3924 "E.g. ``extraInfo(SignalProbability)`` returns the SignalProbability calculated by the ``MVAExpert`` module.\n"
3925 "If nothing is set under the given name or if the particle is a nullptr, NaN is returned.\n"
3926 "In the latter case please use `eventExtraInfo` if you want to access an EventExtraInfo variable.", Manager::VariableDataType::c_double);
3927 REGISTER_METAVARIABLE(
"eventExtraInfo(name)", eventExtraInfo,
3928 "[Eventbased] Returns extra info stored under the given name in the event extra info.\n"
3929 "The extraInfo has to be set first by another module like MVAExpert in event mode.\n"
3930 "If nothing is set under this name, NaN is returned.", Manager::VariableDataType::c_double);
3931 REGISTER_METAVARIABLE(
"eventCached(variable)", eventCached,
3932 "[Eventbased] Returns value of event-based variable and caches this value in the EventExtraInfo.\n"
3933 "The result of second call to this variable in the same event will be provided from the cache.\n"
3934 "It is recommended to use this variable in order to declare custom aliases as event-based. This is "
3935 "necessary if using the eventwise mode of variablesToNtuple).", Manager::VariableDataType::c_double);
3936 REGISTER_METAVARIABLE(
"particleCached(variable)", particleCached,
3937 "Returns value of given variable and caches this value in the ParticleExtraInfo of the provided particle.\n"
3938 "The result of second call to this variable on the same particle will be provided from the cache.", Manager::VariableDataType::c_double);
3939 REGISTER_METAVARIABLE(
"modulo(variable, n)", modulo,
3940 "Returns rest of division of variable by n.", Manager::VariableDataType::c_int);
3941 REGISTER_METAVARIABLE(
"abs(variable)", abs,
3942 "Returns absolute value of the given variable.\n"
3943 "E.g. abs(mcPDG) returns the absolute value of the mcPDG, which is often useful for cuts.", Manager::VariableDataType::c_double);
3944 REGISTER_METAVARIABLE(
"max(var1,var2)", max,
"Returns max value of two variables.\n", Manager::VariableDataType::c_double);
3945 REGISTER_METAVARIABLE(
"min(var1,var2)", min,
"Returns min value of two variables.\n", Manager::VariableDataType::c_double);
3946 REGISTER_METAVARIABLE(
"sin(variable)", sin,
"Returns sine value of the given variable.", Manager::VariableDataType::c_double);
3947 REGISTER_METAVARIABLE(
"asin(variable)", asin,
"Returns arcsine of the given variable. The unit of the asin() is ``rad``", Manager::VariableDataType::c_double);
3948 REGISTER_METAVARIABLE(
"cos(variable)", cos,
"Returns cosine value of the given variable.", Manager::VariableDataType::c_double);
3949 REGISTER_METAVARIABLE(
"acos(variable)", acos,
"Returns arccosine value of the given variable. The unit of the acos() is ``rad``", Manager::VariableDataType::c_double);
3950 REGISTER_METAVARIABLE(
"tan(variable)", tan,
"Returns tangent value of the given variable.", Manager::VariableDataType::c_double);
3951 REGISTER_METAVARIABLE(
"atan(variable)", atan,
"Returns arctangent value of the given variable. The unit of the atan() is ``rad``", Manager::VariableDataType::c_double);
3952 REGISTER_METAVARIABLE(
"exp(variable)", exp,
"Returns exponential evaluated for the given variable.", Manager::VariableDataType::c_double);
3953 REGISTER_METAVARIABLE(
"log(variable)", log,
"Returns natural logarithm evaluated for the given variable.", Manager::VariableDataType::c_double);
3954 REGISTER_METAVARIABLE(
"log10(variable)", log10,
"Returns base-10 logarithm evaluated for the given variable.", Manager::VariableDataType::c_double);
3955 REGISTER_METAVARIABLE(
"int(variable, nan_replacement)", convertToInt, R
"DOC(
3956 Casts the output of the variable to an integer value.
3959 Overflow and underflow are clipped at maximum and minimum values, respectively. NaN values are replaced with the value of the 2nd argument.
3961 )DOC", Manager::VariableDataType::c_int);
3962 REGISTER_METAVARIABLE("isNAN(variable)", isNAN,
3963 "Returns true if variable value evaluates to nan (determined via std::isnan(double)).\n"
3964 "Useful for debugging.", Manager::VariableDataType::c_bool);
3965 REGISTER_METAVARIABLE(
"ifNANgiveX(variable, x)", ifNANgiveX,
3966 "Returns x (has to be a number) if variable value is nan (determined via std::isnan(double)).\n"
3967 "Useful for technical purposes while training MVAs.", Manager::VariableDataType::c_double);
3968 REGISTER_METAVARIABLE(
"isInfinity(variable)", isInfinity,
3969 "Returns true if variable value evaluates to infinity (determined via std::isinf(double)).\n"
3970 "Useful for debugging.", Manager::VariableDataType::c_bool);
3971 REGISTER_METAVARIABLE(
"unmask(variable, flag1, flag2, ...)", unmask,
3972 "unmask(variable, flag1, flag2, ...) or unmask(variable, mask) sets certain bits in the variable to zero.\n"
3973 "For example, if you want to set the second, fourth and fifth bits to zero, you could call \n"
3974 "``unmask(variable, 2, 8, 16)`` or ``unmask(variable, 26)``.\n"
3975 "", Manager::VariableDataType::c_double);
3976 REGISTER_METAVARIABLE(
"conditionalVariableSelector(cut, variableIfTrue, variableIfFalse)", conditionalVariableSelector,
3977 "Returns one of the two supplied variables, depending on whether the particle passes the supplied cut.\n"
3978 "The first variable is returned if the particle passes the cut, and the second variable is returned otherwise.", Manager::VariableDataType::c_double);
3979 REGISTER_METAVARIABLE(
"pValueCombination(p1, p2, ...)", pValueCombination,
3980 "Returns the combined p-value of the provided p-values according to the formula given in `Nucl. Instr. and Meth. A 411 (1998) 449 <https://doi.org/10.1016/S0168-9002(98)00293-9>`_ .\n"
3981 "If any of the p-values is invalid, i.e. smaller than zero, -1 is returned.", Manager::VariableDataType::c_double);
3982 REGISTER_METAVARIABLE(
"pValueCombinationOfDaughters(variable)", pValueCombinationOfDaughters,
3983 "Returns the combined p-value of the daughter p-values according to the formula given in `Nucl. Instr. and Meth. A 411 (1998) 449 <https://doi.org/10.1016/S0168-9002(98)00293-9>`_ .\n"
3984 "If any of the p-values is invalid, i.e. smaller than zero, -1 is returned.", Manager::VariableDataType::c_double);
3985 REGISTER_METAVARIABLE(
"veto(particleList, cut, pdgCode = 11)", veto,
3986 "Combines current particle with particles from the given particle list and returns 1 if the combination passes the provided cut. \n"
3987 "For instance one can apply this function on a signal Photon and provide a list of all photons in the rest of event and a cut \n"
3988 "around the neutral Pion mass (e.g. ``0.130 < M < 0.140``). \n"
3989 "If a combination of the signal Photon with a ROE photon fits this criteria, hence looks like a neutral pion, the veto-Metavariable will return 1", Manager::VariableDataType::c_bool);
3990 REGISTER_METAVARIABLE(
"matchedMC(variable)", matchedMC,
3991 "Returns variable output for the matched MCParticle by constructing a temporary Particle from it.\n"
3992 "This may not work too well if your variable requires accessing daughters of the particle.\n"
3993 "E.g. ``matchedMC(p)`` returns the total momentum of the related MCParticle.\n"
3994 "Returns NaN if no matched MCParticle exists.", Manager::VariableDataType::c_double);
3995 REGISTER_METAVARIABLE(
"clusterBestMatchedMCParticle(variable)", clusterBestMatchedMCParticle,
3996 "Returns variable output for the MCParticle that is best-matched with the ECLCluster of the given Particle.\n"
3997 "E.g. To get the energy of the MCParticle that matches best with an ECLCluster, one could use ``clusterBestMatchedMCParticle(E)``\n"
3998 "When the variable is called for ``gamma`` and if the ``gamma`` is matched with MCParticle, it works same as `matchedMC`.\n"
3999 "If the variable is called for ``gamma`` that fails to match with an MCParticle, it provides the mdst-level MCMatching information abouth the ECLCluster.\n"
4000 "Returns NaN if the particle is not matched to an ECLCluster, or if the ECLCluster has no matching MCParticles", Manager::VariableDataType::c_double);
4001 REGISTER_METAVARIABLE(
"varForBestMatchedMCKlong(variable)", clusterBestMatchedMCKlong,
4002 "Returns variable output for the Klong MCParticle which has the best match with the ECLCluster of the given Particle.\n"
4003 "Returns NaN if the particle is not matched to an ECLCluster, or if the ECLCluster has no matching Klong MCParticle", Manager::VariableDataType::c_double);
4005 REGISTER_METAVARIABLE(
"countInList(particleList, cut='')", countInList,
"[Eventbased] "
4006 "Returns number of particle which pass given in cut in the specified particle list.\n"
4007 "Useful for creating statistics about the number of particles in a list.\n"
4008 "E.g. ``countInList(e+, isSignal == 1)`` returns the number of correctly reconstructed electrons in the event.\n"
4009 "The variable is event-based and does not need a valid particle pointer as input.", Manager::VariableDataType::c_int);
4010 REGISTER_METAVARIABLE(
"getVariableByRank(particleList, rankedVariableName, variableName, rank)", getVariableByRank, R
"DOC(
4011 [Eventbased] Returns the value of ``variableName`` for the candidate in the ``particleList`` with the requested ``rank``.
4014 The `BestCandidateSelection` module available via `rankByHighest` / `rankByLowest` has to be used before.
4017 The first candidate matching the given rank is used.
4018 Thus, it is not recommended to use this variable in conjunction with ``allowMultiRank`` in the `BestCandidateSelection` module.
4020 The suffix ``_rank`` is automatically added to the argument ``rankedVariableName``,
4021 which either has to be the name of the variable used to order the candidates or the selected outputVariable name without the ending ``_rank``.
4022 This means that your selected name for the rank variable has to end with ``_rank``.
4024 An example of this variable's usage is given in the tutorial `B2A602-BestCandidateSelection <https://gitlab.desy.de/belle2/software/basf2/-/tree/main/analysis/examples/tutorials/B2A602-BestCandidateSelection.py>`_
4025 )DOC", Manager::VariableDataType::c_double);
4026 REGISTER_VARIABLE("matchedMCHasPDG(PDGCode)", matchedMCHasPDG,
4027 "Returns if the absolute value of the PDGCode of the MCParticle related to the Particle matches a given PDGCode."
4028 "Returns 0/NAN/1 if PDGCode does not match/is not available/ matches");
4029 REGISTER_METAVARIABLE(
"numberOfNonOverlappingParticles(pList1, pList2, ...)", numberOfNonOverlappingParticles,
4030 "Returns the number of non-overlapping particles in the given particle lists"
4031 "Useful to check if there is additional physics going on in the detector if one reconstructed the Y4S", Manager::VariableDataType::c_int);
4032 REGISTER_METAVARIABLE(
"totalEnergyOfParticlesInList(particleListName)", totalEnergyOfParticlesInList,
4033 "[Eventbased] Returns the total energy of particles in the given particle List. The unit of the energy is ``GeV``", Manager::VariableDataType::c_double);
4034 REGISTER_METAVARIABLE(
"totalPxOfParticlesInList(particleListName)", totalPxOfParticlesInList,
4035 "[Eventbased] Returns the total momentum Px of particles in the given particle List. The unit of the momentum is ``GeV/c``", Manager::VariableDataType::c_double);
4036 REGISTER_METAVARIABLE(
"totalPyOfParticlesInList(particleListName)", totalPyOfParticlesInList,
4037 "[Eventbased] Returns the total momentum Py of particles in the given particle List. The unit of the momentum is ``GeV/c``", Manager::VariableDataType::c_double);
4038 REGISTER_METAVARIABLE(
"totalPzOfParticlesInList(particleListName)", totalPzOfParticlesInList,
4039 "[Eventbased] Returns the total momentum Pz of particles in the given particle List. The unit of the momentum is ``GeV/c``", Manager::VariableDataType::c_double);
4040 REGISTER_METAVARIABLE(
"invMassInLists(pList1, pList2, ...)", invMassInLists,
4041 "[Eventbased] Returns the invariant mass of the combination of particles in the given particle lists. The unit of the invariant mass is GeV/:math:`\\text{c}^2` ", Manager::VariableDataType::c_double);
4042 REGISTER_METAVARIABLE(
"totalECLEnergyOfParticlesInList(particleListName)", totalECLEnergyOfParticlesInList,
4043 "[Eventbased] Returns the total ECL energy of particles in the given particle List. The unit of the energy is ``GeV``", Manager::VariableDataType::c_double);
4044 REGISTER_METAVARIABLE(
"maxPtInList(particleListName)", maxPtInList,
4045 "[Eventbased] Returns maximum transverse momentum Pt in the given particle List. The unit of the transverse momentum is ``GeV/c``", Manager::VariableDataType::c_double);
4046 REGISTER_METAVARIABLE(
"eclClusterSpecialTrackMatched(cut)", eclClusterTrackMatchedWithCondition,
4047 "Returns if at least one Track that satisfies the given condition is related to the ECLCluster of the Particle.", Manager::VariableDataType::c_double);
4048 REGISTER_METAVARIABLE(
"averageValueInList(particleListName, variable)", averageValueInList,
4049 "[Eventbased] Returns the arithmetic mean of the given variable of the particles in the given particle list.", Manager::VariableDataType::c_double);
4050 REGISTER_METAVARIABLE(
"medianValueInList(particleListName, variable)", medianValueInList,
4051 "[Eventbased] Returns the median value of the given variable of the particles in the given particle list.", Manager::VariableDataType::c_double);
4052 REGISTER_METAVARIABLE(
"sumValueInList(particleListName, variable)", sumValueInList,
4053 "[Eventbased] Returns the sum of the given variable of the particles in the given particle list.", Manager::VariableDataType::c_double);
4054 REGISTER_METAVARIABLE(
"productValueInList(particleListName, variable)", productValueInList,
4055 "[Eventbased] Returns the product of the given variable of the particles in the given particle list.", Manager::VariableDataType::c_double);
4056 REGISTER_METAVARIABLE(
"angleToClosestInList(particleListName)", angleToClosestInList,
4057 "Returns the angle between this particle and the closest particle (smallest opening angle) in the list provided. The unit of the angle is ``rad`` ", Manager::VariableDataType::c_double);
4058 REGISTER_METAVARIABLE(
"closestInList(particleListName, variable)", closestInList,
4059 "Returns `variable` for the closest particle (smallest opening angle) in the list provided.", Manager::VariableDataType::c_double);
4060 REGISTER_METAVARIABLE(
"angleToMostB2BInList(particleListName)", angleToMostB2BInList,
4061 "Returns the angle between this particle and the most back-to-back particle (closest opening angle to 180) in the list provided. The unit of the angle is ``rad`` ", Manager::VariableDataType::c_double);
4062 REGISTER_METAVARIABLE(
"deltaPhiToMostB2BPhiInList(particleListName)", deltaPhiToMostB2BPhiInList,
4063 "Returns the abs(delta phi) between this particle and the most back-to-back particle in phi (closest opening angle to 180) in the list provided. The unit of the angle is ``rad`` ", Manager::VariableDataType::c_double);
4064 REGISTER_METAVARIABLE(
"mostB2BInList(particleListName, variable)", mostB2BInList,
4065 "Returns `variable` for the most back-to-back particle (closest opening angle to 180) in the list provided.", Manager::VariableDataType::c_double);
4066 REGISTER_METAVARIABLE(
"maxOpeningAngleInList(particleListName)", maxOpeningAngleInList,
4067 "[Eventbased] Returns maximum opening angle in the given particle List. The unit of the angle is ``rad`` ", Manager::VariableDataType::c_double);
4068 REGISTER_METAVARIABLE(
"daughterCombination(variable, daughterIndex_1, daughterIndex_2 ... daughterIndex_n)", daughterCombination,R
"DOC(
4069Returns a ``variable`` function only of the 4-momentum calculated on an arbitrary set of (grand)daughters.
4072 ``variable`` can only be a function of the daughters' 4-momenta.
4074Daughters from different generations of the decay tree can be combined using generalized daughter indexes, which are simply colon-separated
4075the list of daughter indexes, starting from the root particle: for example, ``0:1:3`` identifies the fourth
4076daughter (3) of the second daughter (1) of the first daughter (0) of the mother particle.
4079 ``daughterCombination(M, 0, 3, 4)`` will return the invariant mass of the system made of the first, fourth and fifth daughter of particle.
4080 ``daughterCombination(M, 0:0, 3:0)`` will return the invariant mass of the system made of the first daughter of the first daughter and the first daughter of the fourth daughter.
4082)DOC", Manager::VariableDataType::c_double);
4083 REGISTER_METAVARIABLE("useAlternativeDaughterHypothesis(variable, daughterIndex_1:newMassHyp_1, ..., daughterIndex_n:newMassHyp_n)", useAlternativeDaughterHypothesis,R
"DOC(
4084Returns a ``variable`` calculated using new mass hypotheses for (some of) the particle's daughters.
4087 ``variable`` can only be a function of the particle 4-momentum, which is re-calculated as the sum of the daughters' 4-momenta, and the daughters' 4-momentum.
4088 This means that if you made a kinematic fit without updating the daughters' momenta, the result of this variable will not reflect the effect of the kinematic fit.
4089 Also, the track fit is not performed again: the variable only re-calculates the 4-vectors using different mass assumptions.
4090 In the variable, a copy of the given particle is created with daughters' alternative mass assumption (i.e. the original particle and daughters are not changed).
4093 Generalized daughter indexes are not supported (yet!): this variable can be used only on first-generation daughters.
4096 ``useAlternativeDaughterHypothesis(M, 0:K+, 2:pi-)`` will return the invariant mass of the particle assuming that the first daughter is a kaon and the third is a pion, instead of whatever was used in reconstructing the decay.
4097 ``useAlternativeDaughterHypothesis(mRecoil, 1:p+)`` will return the recoil mass of the particle assuming that the second daughter is a proton instead of whatever was used in reconstructing the decay.
4099)DOC", Manager::VariableDataType::c_double);
4100 REGISTER_METAVARIABLE("varForFirstMCAncestorOfType(type, variable)",varForFirstMCAncestorOfType,R
"DOC(Returns requested variable of the first ancestor of the given type.
4101Ancestor type can be set up by PDG code or by particle name (check evt.pdl for valid particle names))DOC", Manager::VariableDataType::c_double);
4103 REGISTER_METAVARIABLE("nTrackFitResults(particleType)", nTrackFitResults,
4104 "[Eventbased] Returns the total number of TrackFitResults for a given particleType. The argument can be the name of particle (e.g. pi+) or PDG code (e.g. 211).",
4105 Manager::VariableDataType::c_int);
int getPDGCode() const
PDG code.
static const ChargedStable pion
charged pion particle
static const double doubleNaN
quiet_NaN
static const ChargedStable electron
electron particle
EHypothesisBit
The hypothesis bits for this ECLCluster (Connected region (CR) is split using this hypothesis.
@ c_nPhotons
CR is split into n photons (N1)
static std::unique_ptr< GeneralCut > compile(const std::string &cut)
@ c_Initial
bit 5: Particle is initial such as e+ or e- and not going to Geant4
@ c_PrimaryParticle
bit 0: Particle is primary particle.
@ c_IsVirtual
bit 4: Particle is virtual and not going to Geant4.
static std::string makeROOTCompatible(std::string str)
Remove special characters that ROOT dislikes in branch names, e.g.
EParticleSourceObject
particle source enumerators
@ c_Flavored
Is either particle or antiparticle.
static const ReferenceFrame & GetCurrent()
Get current rest frame.
std::function< VarVariant(const Particle *)> FunctionPtr
functions stored take a const Particle* and return VarVariant.
const Var * getVariable(std::string name)
Get the variable belonging to the given key.
static Manager & Instance()
get singleton instance.
#define MAKE_DEPRECATED(name, make_fatal, version, description)
Registers a variable as deprecated.
T convertString(const std::string &str)
Converts a string to type T (one of float, double, long double, int, long int, unsigned long int).
double charge(int pdgCode)
Returns electric charge of a particle with given pdg code.
bool hasAntiParticle(int pdgCode)
Checks if the particle with given pdg code has an anti-particle or not.
Particle * copyParticle(const Particle *original)
Function takes argument Particle and creates a copy of it and copies of all its (grand-)^n-daughters.
Abstract base class for different kinds of events.
const std::vector< double > v2
MATLAB generated random vector.
const std::vector< double > v1
MATLAB generated random vector.