10 #include <analysis/modules/ParticleListManipulator/ParticleListManipulatorModule.h>
14 #include <framework/datastore/DataStore.h>
17 #include <framework/logging/Logger.h>
20 #include <analysis/DecayDescriptor/ParticleListName.h>
21 #include <analysis/utility/ValueIndexPairSorting.h>
36 ParticleListManipulatorModule::ParticleListManipulatorModule():
40 setDescription(
"Manipulates ParticleLists: copies/merges/performs particle selection");
46 vector<string> defaultList;
48 "list of input ParticleList names", defaultList);
52 addParam(
"variable",
m_variableName,
"Variable which defines the best duplicate (see ``selectLowest`` for ordering)",
53 std::string(
"mdstIndex"));
55 "If true, duplicate with lowest value of ``variable`` is accepted, otherwise higher one.",
true);
58 "If true, the output ParticleList will be saved by RootOutput. If false, it will be ignored when writing the file.",
false);
74 B2ERROR(
"ParticleListManipulatorModule::initialize Invalid output ParticleList name: " <<
m_outputListName);
84 string listLabel = mother->
getLabel();
88 " but the label 'all' is forbidden for user-defined lists of final-state particles." <<
89 " It could introduce *very* dangerous bugs.");
90 }
else if ((listLabel ==
"MC") or (listLabel ==
"V0" and not((
"K_S0:mdst" ==
m_inputListNames[0])
95 " but the label " << listLabel <<
" is not allowed for merged or copied particle lists.");
104 B2ERROR(
"ParticleListManipulatorModule: cannot copy Particles from " << listName <<
105 " to itself! Use applyCuts() (ParticleSelector module) instead.");
107 B2ERROR(
"Invalid input ParticleList name: " << listName);
121 B2ERROR(
"Variable '" <<
m_variableName <<
"' is not available in Variable::Manager!");
125 B2ERROR(
"Variable '" <<
m_variableName <<
"' has wrong data type! It must be either double or integer.");
155 std::vector<int> idSeq;
162 typedef std::pair<double, unsigned int> ValueIndexPair;
163 std::vector<ValueIndexPair> valueToIndex;
168 if (!inPList.
isValid())
continue;
170 std::vector<int> fsParticles = inPList->getList(ParticleList::EParticleType::c_FlavorSpecificParticle,
false);
171 const std::vector<int>& scParticles = inPList->getList(ParticleList::EParticleType::c_SelfConjugatedParticle,
false);
172 const std::vector<int>& fsAntiParticles = inPList->getList(ParticleList::EParticleType::c_FlavorSpecificParticle,
true);
174 fsParticles.insert(fsParticles.end(), scParticles.begin(), scParticles.end());
175 fsParticles.insert(fsParticles.end(), fsAntiParticles.begin(), fsAntiParticles.end());
177 for (
int fsParticle : fsParticles) {
180 if (
m_cut->check(part)) {
181 double value = std::numeric_limits<double>::quiet_NaN();;
195 std::stable_sort(valueToIndex.begin(), valueToIndex.end(), ValueIndexPairSorting::lowerPair<ValueIndexPair>);
197 std::stable_sort(valueToIndex.begin(), valueToIndex.end(), ValueIndexPairSorting::higherPair<ValueIndexPair>);
201 for (
const auto& candidate : valueToIndex) {
204 std::vector<int> idSeq;
217 idSequence.push_back(p->getPDGCode());
219 if (p->getNDaughters() == 0) {
220 idSequence.push_back(p->getMdstArrayIndex());
222 idSequence.push_back(p->getNDaughters());
223 auto daughters = p->getDaughters();
225 sort(daughters.begin(), daughters.end(), [](
const auto a,
const auto b) {
226 return a->getPDGCode() > b->getPDGCode();
229 for (
const auto& daughter : daughters)
237 bool sameSeq = (idSeqIN == idSeqOUT);
The ParticleType class for identifying different particle types.
static const ParticleSet finalStateParticlesSet
set of final set particles that can be created by the ParticleLoader
EStoreFlags
Flags describing behaviours of objects etc.
@ c_WriteOut
Object/array should be saved by output modules.
@ c_DontWriteOut
Object/array should be NOT saved by output modules.
Represents a particle in the DecayDescriptor.
int getPDGCode() const
Return PDG code.
std::string getLabel() const
The label of this particle, "default" returned, when no label set.
bool init(const std::string &str)
Initialise the DecayDescriptor from given string.
const DecayDescriptorParticle * getMother() const
return mother.
static std::unique_ptr< GeneralCut > compile(const std::string &cut)
Creates an instance of a cut and returns a unique_ptr to it, if you need a copy-able object instead y...
void setDescription(const std::string &description)
Sets the description of the module.
void setPropertyFlags(unsigned int propertyFlags)
Sets the flags for the module properties.
@ c_ParallelProcessingCertified
This module can be run in parallel processing mode safely (All I/O must be done through the data stor...
bool m_isSelfConjugatedParticle
flag that indicates whether an anti-particle does not exist and therefore the output anti-ParticleLis...
bool m_preferLowest
Select the duplicate with the lowest value (instead of highest).
virtual void initialize() override
Initialize the Module.
virtual void event() override
Event processor.
std::string m_variableName
Variable which defines the best duplicate.
std::vector< std::string > m_inputListNames
input ParticleList names
StoreArray< Particle > m_particles
StoreArray of Particles.
std::vector< std::vector< int > > m_particlesInTheList
This vector holds unique identifiers (vector of ints) of all particles that are already included in t...
std::unique_ptr< Variable::Cut > m_cut
cut object which performs the cuts
bool isUnique(const std::vector< int > &idSequence)
Compares input idSequence to all sequences already included in the list.
const Variable::Manager::Var * m_variable
Variable which defines the best duplicate selection.
std::string m_cutParameter
selection criteria
DecayDescriptor m_decaydescriptor
Decay descriptor of the particle being selected.
bool m_writeOut
toggle Particle List btw.
int m_pdgCode
PDG code of the particles.
StoreObjPtr< ParticleList > m_particleList
output particle list
std::string m_outputAntiListName
output anti-particle list name
StoreObjPtr< ParticleList > m_antiParticleList
output anti-particle list
void fillUniqueIdentifier(const Particle *p, std::vector< int > &idSequence)
Fills unique identifier for the input particle.
std::string m_outputListName
output ParticleList name
Class to store reconstructed particles.
int getArrayIndex() const
Returns this object's array index (in StoreArray), or -1 if not found.
bool isRequired(const std::string &name="")
Ensure this array/object has been registered previously.
Type-safe access to single objects in the data store.
bool isValid() const
Check whether the object was created.
const Var * getVariable(std::string name)
Get the variable belonging to the given key.
static Manager & Instance()
get singleton instance.
void addParam(const std::string &name, T ¶mVariable, const std::string &description, const T &defaultValue)
Adds a new parameter to the module.
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
std::string antiParticleListName(const std::string &listName)
Returns name of anti-particle-list corresponding to listName.
Abstract base class for different kinds of events.
VariableDataType variabletype
data type of variable
FunctionPtr function
Pointer to function.