particleDataTable.h

Go to the documentation of this file.

//
//    Copyright 2010
//
//    This file is part of rootpwa
//
//    rootpwa is free software: you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation, either version 3 of the License, or
//    (at your option) any later version.
//
//    rootpwa is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with rootpwa. If not, see <http://www.gnu.org/licenses/>.
//
//-------------------------------------------------------------------------
// File and Version Information:
// $Rev::                             $: revision of last commit
// $Author::                          $: author of last commit
// $Date::                            $: date of last commit
//
// Description:
//      singleton class that manages all particle data
//
//
// Author List:
//      Boris Grube          TUM            (original author)
//
//
//-------------------------------------------------------------------------


#ifndef PARTICLEDATATABLE_H
#define PARTICLEDATATABLE_H


#include <string>
#include <vector>
#include <map>
#include <set>

#include <boost/bimap.hpp>

#include "particleProperties.h"


namespace rpwa {


        class particleDataTable {

        public:

                static particleDataTable& instance() { return _instance; }  

                static bool isInTable(const std::string& partName);  

                static const particleProperties* entry(const std::string& partName,
                                                       const bool         warnIfNotExistent = true);  

                static bool addEntry(const particleProperties& partProp);  

                static std::vector<const particleProperties*>
                entriesMatching(const particleProperties&            prototype,
                                const std::string&                   sel,
                                const double                         minMass            = 0,
                                const double                         minMassWidthFactor = 0,
                                const std::vector<std::string>&      whiteList          = std::vector<std::string>(),
                                const std::vector<std::string>&      blackList          = std::vector<std::string>(),
                                const particleProperties::decayMode& decay              = particleProperties::decayMode(),
                                const bool&                          forceDecayCheck    = true);  

                static unsigned int nmbEntries() { return _dataTable.size(); }  

                typedef std::map<std::string, particleProperties>::const_iterator iterator;
                static iterator begin() { return _dataTable.begin(); }  
                static iterator end()   { return _dataTable.end();   }  

                static std::ostream& print(std::ostream& out);  
                static std::ostream& dump (std::ostream& out);  

                static bool readFile(const std::string& fileName = "./particleDataTable.txt");  
                static bool read(std::istream& in);  

                static bool readDecayModeFile(const std::string& fileName);  

                static std::string  particleNameFromGeantId(const int id);
                static void         geantIdAndChargeFromParticleName(const std::string& name,
                                                                    int&               id,
                                                                    int&               charge);
                static unsigned int geantIdFromParticleName(const std::string& name);

                static void clear() { _dataTable.clear(); }  

                static bool debug() { return _debug; }                             
                static void setDebug(const bool debug = true) { _debug = debug; }  


        private:

                particleDataTable () { }
                ~particleDataTable() { }
                particleDataTable (const particleDataTable&);
                particleDataTable& operator =(const particleDataTable&);

                static particleDataTable                         _instance;   
                static std::map<std::string, particleProperties> _dataTable;  

                static boost::bimap<std::string, unsigned int> _nameGeantIdMap; 

                static bool _debug;  

        };


        inline
        std::ostream&
        operator <<(std::ostream&            out,
                    const particleDataTable& dataTable)
        {
                return dataTable.print(out);
        }


        inline
        std::istream&
        operator >>(std::istream&      in,
                    particleDataTable& dataTable)
        {
                dataTable.read(in);
                return in;
        }


} // namespace rpwa


#endif  // PARTICLEDATATABLE_H