Default.h

Go to the documentation of this file.

#ifndef ANP_DEFAULT_H
#define ANP_DEFAULT_H

// C++
#include <map>
#include <string>
#include <sstream>

// ROOT
#include "Rtypes.h"

// MINOS
#include "Util/UtilString.h"
#include "Registry/Registry.h"

// Local
#include "PhysicsNtuple/Mutex.h"

class TH1;
class TDirectory;
class Registry;

namespace Anp
{
   //-------------------------------------------------------------------------------
   // Read Registry
   //-------------------------------------------------------------------------------   
   bool ReadRegistry(const std::string &filepath, Registry &reg, bool quiet = true);


   const std::pair<std::string, bool> GetString(const std::string &prefix,
                                                const std::string &key,
                                                const Registry &reg);

   bool Read(const Registry &reg, const std::string &key, bool &value);
   bool Read(const Registry &reg, const std::string &key, std::string &value);

   int SetKey(Registry &reg, const std::string &key, const std::string &value);
   
   //-------------------------------------------------------------------------------
   // Get if exits and create otherwise TDirectory from path
   //-------------------------------------------------------------------------------   
   TDirectory* GetDir(std::string path, TDirectory *dir);

   TH1* SetDir(TH1 *h, TDirectory *dir, const std::string &name = "");
   
   Mutex& GetMainMutex();
   Mutex& GetROOTMutex();

   //-------------------------------------------------------------------------------
   // Geometry functions
   //-------------------------------------------------------------------------------
   float uv2x(float u, float v);
   float uv2y(float u, float v);

   float xy2u(float x, float y);
   float xy2v(float x, float y);   
   
   double pi();

   double angle(double x, double y);

   struct CoordXYZ
   {
      CoordXYZ() : x(-1.0e6), y(-1.0e6), z(-1.0e6) {}
      double x;
      double y;
      double z;
   };
   
   const CoordXYZ gnumi_to_near(const CoordXYZ pos);
   const CoordXYZ near_to_gnumi(const CoordXYZ pos);

   const CoordXYZ gnumi_to_far(const CoordXYZ pos);
   const CoordXYZ far_to_gnumi(const CoordXYZ pos);
}

//----------------------------------------------------------------------
// inlined global functions
//----------------------------------------------------------------------   
inline float Anp::uv2x(const float u, const float v) { return (u - v)*0.707106781; }
inline float Anp::uv2y(const float u, const float v) { return (u + v)*0.707106781; }

inline float Anp::xy2u(const float x, const float y) { return (y + x)*0.707106781; }
inline float Anp::xy2v(const float x, const float y) { return (y - x)*0.707106781; }

inline double Anp::pi() { return 3.1415926536; }

//--------------------------------------------------------------------------------------------
// templated function that reads registry key and pareses to individual objects
//--------------------------------------------------------------------------------------------
namespace Anp
{
   template<typename T>
      inline std::vector<T> ReadList(const Registry &reg,
                                     const std::string &key,
                                     const std::string &sep)
   {
      std::vector<T> lvec;

      const char *list_char = 0;
      if(!reg.Get(key.c_str(), list_char) || !list_char)
      {
         return lvec;
      }
      
      std::vector<std::string> svec;
      UtilString::StringTok(svec, list_char, sep.c_str());
      
      if(svec.empty())
      {
         return lvec;
      }
      
      for(unsigned int i = 0; i < svec.size(); ++i)
      {
         std::stringstream valS;
         T valT;
         
         valS << svec[i];
         valS >> valT;
         
         if(valS.fail())
         {
            std::cerr << "ReadList<T> - stringstream operator>> failed for: " << svec[i] << std::endl;
         }
         else
         {       
            lvec.push_back(valT);
         }
      }
      
      return lvec;
   }
}

//--------------------------------------------------------------------------------------------
// templated function that prints list
//--------------------------------------------------------------------------------------------
namespace Anp
{
   template<typename T>
      void PrintList(const std::string &name,
                     const std::vector<T> &lvec)
   {
      for(unsigned int ipos = 0; ipos < lvec.size(); ++ipos)
      {
         if(ipos == 0)
         {
            std::cout << name << " = " << lvec[ipos];
         }
         else
         {
            std::cout << ", " << lvec[ipos];
         }

         if(ipos + 1 == lvec.size())
         {
            std::cout << std::endl;
         }       
      }
   }
}

#endif

---