Default.cxx

Go to the documentation of this file.

// $Id: Default.cxx,v 1.26 2009/10/15 18:30:13 jyuko Exp $

// C++
#include <cmath>
#include <cstring>
#include <fstream>
#include <iostream>

// ROOT
#include "TDirectory.h"
#include "TH1.h"

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

// Local
#include "PhysicsNtuple/Record.h"
#include "PhysicsNtuple/Default.h"

//
// Mutex for locking access to ROOT functions
//
namespace Anp
{
   static Mutex ROOTMutex;
   static Mutex MAINMutex;
}

using namespace std;

//----------------------------------------------------------------------
// define numerical constants - is this a good way to do this?
//----------------------------------------------------------------------
namespace Anp
{
   static const double GNUMINearX = 1.48844; // meters
   static const double GNUMINearY = 0.0;     // meters
   static const double GNUMINearZ = 1036.49; // meters

   static const double GNUMIFarX = 0.0;      // meters
   static const double GNUMIFarY = 0.0;      // meters
   static const double GNUMIFarZ = 735.34E3; // meters

   static const double GNUMICosZ = 0.998318471;
   static const double GNUMISinZ = 0.057967487;
}

//----------------------------------------------------------------------
const Anp::CoordXYZ Anp::gnumi_to_near(const CoordXYZ pos)
{
   CoordXYZ new_pos;
   
   new_pos.x =   pos.x + GNUMINearX;
   new_pos.z =  (pos.z - GNUMINearZ) * GNUMICosZ + pos.y * GNUMISinZ;
   new_pos.y = -(pos.z - GNUMINearZ) * GNUMISinZ + pos.y * GNUMICosZ;

   return new_pos;
}

//----------------------------------------------------------------------
const Anp::CoordXYZ Anp::near_to_gnumi(const CoordXYZ pos)
{
   CoordXYZ new_pos;
   
   new_pos.x = pos.x - GNUMINearX;
   new_pos.z = pos.z * GNUMICosZ - pos.y * GNUMISinZ + GNUMINearZ;
   new_pos.y = pos.z * GNUMISinZ + pos.y * GNUMICosZ;

   return new_pos;
}

//----------------------------------------------------------------------
const Anp::CoordXYZ Anp::gnumi_to_far(const CoordXYZ pos)
{
   CoordXYZ new_pos = pos;
   
   new_pos.z = (pos.z - GNUMIFarZ) * GNUMICosZ - pos.y * GNUMISinZ;
   new_pos.y = (pos.z - GNUMIFarZ) * GNUMISinZ + pos.y * GNUMICosZ;

   return new_pos;
}

//----------------------------------------------------------------------
const Anp::CoordXYZ Anp::far_to_gnumi(const CoordXYZ pos)
{
   CoordXYZ new_pos = pos;
   
   new_pos.z =  pos.z * GNUMICosZ + pos.y * GNUMISinZ + GNUMIFarZ;
   new_pos.y = -pos.z * GNUMISinZ + pos.y * GNUMICosZ;

   return new_pos;
}

//------------------------------------------------------------------------------------------
double Anp::angle(const double x, const double y)
{
   const double radius = std::sqrt(x*x + y*y);
   
   if(!(radius > 0.0))
   {
      return 0.0;
   }
   
   if(!(+x < radius))
   {
      return std::acos(+1.0);
   }
   if(!(-x < radius))
   {
      return std::acos(-1.0);
   }

   double angle = std::acos(x/radius);
   
   if(y < 0.0)
   {
      angle = 2.0 * pi() - angle;
   }

   return angle;
}

//----------------------------------------------------------------------
bool Anp::ReadRegistry(const std::string &filepath, Registry &reg, const bool quiet)
{
   if(!quiet)
   {
      std::cout << "-------------------------------------------------------------" << std::endl;
      std::cout << "Configuraton file:" << std::endl << "   " << filepath << std::endl;
      std::cout << std::endl;
   }

   std::ifstream infile(filepath.c_str());
   if(!infile || !infile.is_open())
   {
      std::cerr << "Anp::ReadRegistry - failed to open file: " << filepath << std::endl;
      if(quiet)
      {
         std::cout << "-------------------------------------------------------------" << std::endl;
      }
      return false;
   }

   reg.UnLockKeys();
   reg.UnLockValues();
   
   while(!infile.eof())
   {
      std::string line;
      std::getline(infile, line);

      if(line.empty() || line.find("#",0) != std::string::npos)
      {
         continue;
      }
      
      const std::string::size_type nbeg = line.find_first_of("[", 0);
      const std::string::size_type nend = line.find_first_of("]", 0);

      if(nbeg == std::string::npos || nend == std::string::npos || !(nbeg < nend))
      {
         if(!quiet) std::cout << "   Failed to parse name" << std::endl;
         continue;
      }

      const std::string::size_type vbeg = line.find_first_of("[", nend + 1);
      const std::string::size_type vend = line.find_first_of("]", nend + 1);
      
      if(vbeg == std::string::npos || vend == std::string::npos || !(vbeg < vend))
      {
         if(!quiet) std::cout << "   Failed to parse value" << std::endl;
         continue;
      }

      const std::string::size_type tbeg = line.find_first_of("[", vend + 1);
      const std::string::size_type tend = line.find_first_of("]", vend + 1);
      
      if(tbeg == std::string::npos || tend == std::string::npos || !(tbeg < tend))
      {
         if(!quiet) std::cout << "   Failed to parse type" << std::endl;
         continue;
      }

      const std::string name  = line.substr(nbeg + 1, nend - nbeg - 1);
      const std::string value = line.substr(vbeg + 1, vend - vbeg - 1);
      const std::string type  = line.substr(tbeg + 1, tend - tbeg - 1);
      
      if(!quiet) std:: cout << "   " << name  << " = " << value << " (" << type << ")" << std::endl;

      if(reg.KeyExists(name.c_str()))
      {
         std::cerr << "Anp::ReadRegistry - key [" << name << "] already exists" << std::endl;
         continue;
      }

      if(type == "string")
      {
         reg.Set(name.c_str(), value.c_str());
      }
      else if(type == "double")
      {
         const double value_double = std::atof(value.c_str());
         reg.Set(name.c_str(), value_double);
      }
      else if(type == "int")
      {
         if(value.find(".",0) != std::string::npos)
         {
            if(!quiet) std::cerr << "   Forcing conversion of double to integer" << std::endl;
            const int value_int = static_cast<int>(std::atof(value.c_str()));
            reg.Set(name.c_str(), value_int);
         }
         else
         {
            const int value_int = std::atoi(value.c_str());
            reg.Set(name.c_str(), value_int);
         }
      }
   }
   
   if(infile.is_open())
   {
      infile.close();
   }

   reg.LockKeys();
   reg.LockValues();

   if(!quiet)
   {
      std::cout << "-------------------------------------------------------------" << std::endl;
   }
   
   return true;
}

//----------------------------------------------------------------------
const std::pair<std::string, bool> Anp::GetString(const std::string &prefix,
                                                  const std::string &key,
                                                  const Registry &reg)
{
   std::pair<std::string, bool> result(std::string(""), false);
   
   if(prefix.empty() && key.empty())
   {
      return result;
   }

   const char *value_char = 0;
   if(reg.Get((prefix + key).c_str(), value_char)  && value_char)
   {
      result.first = value_char;
      result.second = true;      
   }
   else if(reg.Get(key.c_str(), value_char)  && value_char)
   {
      result.first = value_char;
      result.second = true;     
   }

   return result;
}

//--------------------------------------------------------------------------------------------
bool Anp::Read(const Registry &reg, const string &key, bool &value)
{
   //
   // Read "const char*" key from Registry and convert it boolean. Return 
   // true if "value" is modified based on Registry value and false otherwise.
   //

   if(key.empty())
   {
      cerr << "Anp::Read - key is empty for bool type" << endl;
      return false;
   }

   const char *value_char = 0;
   if(reg.Get(key.c_str(), value_char)  && value_char)
   {
      if(std::strcmp(value_char, "yes") == 0 ||
         std::strcmp(value_char, "Yes") == 0 ||
         std::strcmp(value_char, "true") == 0 ||
         std::strcmp(value_char, "True") == 0)
      {
         value = true;
         return true;
      }
      else if(std::strcmp(value_char, "no") == 0 ||
              std::strcmp(value_char, "No") == 0 ||
              std::strcmp(value_char, "false") == 0 ||
              std::strcmp(value_char, "False") == 0)
      {
         value = false;
         return true;
      }
   }

   return false;
}

//----------------------------------------------------------------------
bool Anp::Read(const Registry &reg, const std::string &key, std::string &value)
{
   const char *value_char = 0;
   if(!reg.Get(key.c_str(), value_char) || !value_char)
   {
      return false;
   }

   value = std::string(value_char);
   return true;
}

//--------------------------------------------------------------------------------------------
int Anp::SetKey(Registry &reg, const std::string &key, const std::string &value)
{
   //
   // Recursively walk through Registry and add "value" at "key"
   //
   if(key.empty())
   {
      cerr << "Anp::SetKey - key string is empty" << endl;
      return 0;
   }
   if(value.empty())
   {
      cerr << "Anp::SetKey - value string is empty" << endl;
      return 0;
   }

   const bool klock = reg.KeysLocked();
   const bool vlock = reg.ValuesLocked();

   if(klock) reg.UnLockKeys();
   if(vlock) reg.UnLockValues();
   reg.Set(key.c_str(), value.c_str());

   Registry::RegistryKey rkey = reg.Key();
   vector<string> rvec;
   
   const char* charkey = 0;
   while( (charkey = rkey()) )
   {
      if(charkey && reg.GetTypeAsString(charkey) == "Registry")
      {
         rvec.push_back(charkey);
      }
   }
   
   int nadd = 1;
   for(vector<string>::const_iterator sit = rvec.begin(); sit != rvec.end(); ++sit)
   {
      const string &skey = *sit;
      
      Registry dreg;
      if(!reg.Get(skey.c_str(), dreg))
      {
         cerr << "SelectKinem::GetAlg - failed to get Registry at: " << skey << endl;
         continue;
      }
      
      //
      // Recursively walk through Registry daughter objects
      //
      nadd += Anp::SetKey(dreg, key, value);
      reg.Set(skey.c_str(), dreg);
   }
   
   if(klock) reg.LockKeys();
   if(vlock) reg.LockValues();

   return nadd;
}

//--------------------------------------------------------------------------------------------
TDirectory* Anp::GetDir(std::string path, TDirectory *dir)
{
   //
   // Recursively reate directory path in dir
   //
   if(!dir || path.empty() || path == "/")
   {
      return dir;
   }
   
   // remove trailing slash if present
   if(path.substr(path.size() - 1, 1) == "/")
   {
      path = path.substr(0, path.size() - 1);
   }

   std::string::size_type pos = path.find_last_of('/');
   if(pos != std::string::npos)
   {
      // recursively walk upward until all slash characters are removed
      dir = Anp::GetDir(path.substr(0, pos), dir);

      // make directory path of last substring without slash
      path = path.substr(pos + 1, path.size() - pos);
   }

   Anp::Lock<Mutex> lock(Anp::GetROOTMutex());

   if(dir -> Get(path.c_str()))
   {
      return dynamic_cast<TDirectory *>(dir -> Get(path.c_str()));
   }
   
   return dir -> mkdir(path.c_str());
}

//--------------------------------------------------------------------------------------------
TH1* Anp::SetDir(TH1 *h, TDirectory *dir, const string &name)
{
   if(h)
   {
      Anp::Lock<Mutex> lock(Anp::GetROOTMutex());

      if(!name.empty())
      {
         h -> SetName(name.c_str());
      }

      h -> SetDirectory(dir);
   }

   return h;
}

//--------------------------------------------------------------------------------------------
Anp::Mutex& Anp::GetMainMutex()
{
   return MAINMutex;
}

//--------------------------------------------------------------------------------------------
Anp::Mutex& Anp::GetROOTMutex()
{
   return ROOTMutex;
}

---