Interface.cxx

Go to the documentation of this file.

// $Id: Interface.cxx,v 1.16 2010/01/08 23:02:13 jyuko Exp $

// C/C++
#include <cstdlib>
#include <iomanip>
#include <iostream>

// MINOS
#include "CandNtupleSR/NtpSREvent.h"
#include "CandNtupleSR/NtpSRTrack.h"
#include "Registry/Registry.h"
#include "Util/UtilString.h"

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

// Local
#include "RunAlgStore.h"
#include "Interface.h"

using namespace std;

//---------------------------------------------------------------------------------------------
Anp::Interface::Interface()
   :fAlgStore(new Anp::RunAlgStore()),
    fAlgSnarl(new Anp::RunAlgSnarl()),
    fBlock(new DataBlock()),
    fRecord(new Anp::Record()),
    fPrint(true),
    fQuiet(true),
    fValid(false),
    fNSnarlPass(0),
    fNSnarlFail(0),
    fNEvent(0),
    fNTrack(0),
    fDefault(-1.0e6),
    fKeys()
{
}

//---------------------------------------------------------------------------------------------
Anp::Interface::~Interface()
{   
   //
   // inform AlgSnarl algorithms that processing is completed
   //
   fAlgSnarl -> End(*fBlock);
   
   delete fAlgStore;
   delete fAlgSnarl;

   if(fPrint)
   {
      cout << "--------------------------------------------------------------------" << endl
           << "                    Printing Interface summary " << endl
           << "--------------------------------------------------------------------" << endl      
           << "Number of passed snarls: " << fNSnarlPass << endl
           << "Number of failed snarls: " << fNSnarlFail << endl
           << "Number of requested events: " << fNEvent << endl
           << "Number of requested tracks: " << fNTrack << endl
           << *fBlock
           << "--------------------------------------------------------------------" << endl
           << "                    End of Interface summary " << endl
           << "--------------------------------------------------------------------" << endl;
   }

   delete fBlock;
   delete fRecord;
}

//---------------------------------------------------------------------------------------------
bool Anp::Interface::FillSnarl(TObject *record)
{
   if(!record)
   {
      ++fNSnarlFail;
      return false;
   }

   fRecord -> Clear();

   if(fAlgStore -> Run(*fRecord, record) && fAlgSnarl -> Run(*fRecord))
   {
      fBlock -> Add(*fRecord);
      ++fNSnarlPass;
      fValid = true;
   }
   else
   {
      fRecord -> Clear();
      ++fNSnarlFail;
      fValid = false;
   }
   
   if(!fQuiet)
   {
      if(fValid)
      {
         cout << "Interface::FillSnarl - filled new snarl" << endl;
         fRecord -> Print();
      }   
      else
      {
         cout << "Interface::FillSnarl - failed new snarl" << endl;
      }
   }
   return fValid;
}

//---------------------------------------------------------------------------------------------
const map<short, float> Anp::Interface::GetData(TObject *object) const
{
   //
   // Gather data map of data items
   //   from Track if object points to NtpSRTrack
   //   from Event if object points to NtpSREvent
   //

   map<short, float> dmap;

   if(!fValid)
   {
      cerr << "Interface::GetData - invalid current snarl state" << endl;
      return dmap;
   }

   NtpSREvent* ntpevt = dynamic_cast<NtpSREvent *>(object);   
   if(ntpevt)
   {
      const EventIter ievent = std::find(fRecord -> EventBeg(), fRecord -> EventEnd(), ntpevt -> index);
      if(ievent == fRecord -> EventEnd())
      {
         if(fPrint)
         {
            cerr << "Interface::GetData - failed to find event with index: " << ntpevt -> index << endl;
         }
         return dmap;
      }

      ++fNEvent;

      for(DataIter dit = ievent -> DataBeg(); dit != ievent -> DataEnd(); ++dit)
      {
         dmap[dit -> Key()] = dit -> Data();
      }

      if(!fQuiet)
      {
         cout << "Interface::GetData - " << dmap.size() 
              << " data elements for NtpSREvent with index: " << ntpevt -> index << endl;
      }
   }

   NtpSRTrack* ntptrk = dynamic_cast<NtpSRTrack *>(object);
   if(ntptrk)
   {
      const TrackIter itrack = std::find(fRecord -> TrackBeg(), fRecord -> TrackEnd(), ntptrk -> index);
      if(itrack == fRecord -> TrackEnd())
      {
         if(fPrint)
         {
            cerr << "Interface::GetData - failed to find track with index: " << ntptrk -> index << endl;
         }
         return dmap;    
      }

      ++fNTrack;

      for(DataIter dit = itrack -> DataBeg(); dit != itrack -> DataEnd(); ++dit)
      {
         dmap[dit -> Key()] = dit -> Data();
      }

      if(!fQuiet)
      {
         cout << "Interface::GetData - " << dmap.size() 
              << " data elements for NtpSRTrack with index: " << ntptrk -> index << endl;
      }
   }   

   if(!fQuiet)
   {
      for(map<short, float>::const_iterator dit = dmap.begin(); dit != dmap.end(); ++dit)
      {
         cout << "   (key, data) = (" << dit -> first << ", " << dit -> second << ")" << endl;
      }
   }

   return dmap;
}


//---------------------------------------------------------------------------------------------
float Anp::Interface::GetVar(const string &vname, TObject *object) const
{
   //
   // Find and fill variable named "vname"
   //    from Track if TObject inherits from NtpSRTrack
   //    from Event if TObject inherits from NtpSREvent
   //

   if(!fValid)
   {
      cerr << "Interface::GetVar - invalid current snarl state" << endl;
      return fDefault;
   }

   const KeyMap::const_iterator kit = fKeys.find(vname);
   if(kit == fKeys.end())
   {
      cerr << "Interface::GetVar - unknown variable: " << vname << endl;
      return fDefault;      
   }

   //
   // Collect variables for this object
   //
   const map<short, float> dmap = Interface::GetData(object);

   if(dmap.empty())
   {
      return fDefault;
   }

   const map<short, float>::const_iterator dit = dmap.find(kit -> second);
   if(dit != dmap.end())
   {
      return dit -> second;
   }

   return fDefault;
}

//---------------------------------------------------------------------------------------------
void Anp::Interface::Config(const Registry& reg_)
{ 
   //
   // Configure RunAlgStore and RunAlgSnarl algorithms
   //

   Registry reg(reg_);
   
   //
   // Read Registry from a text file, if it exists, and then merge it with this Registry
   //
   const char *value_path = 0;
   if(reg.Get("InterfaceConfigPath", value_path) && value_path)
   {
      Registry nreg(false);
      if(Anp::ReadRegistry(std::string(value_path), nreg, fQuiet))
      {
         reg.UnLockKeys();
         reg.UnLockValues();
         reg.Merge(nreg);
         reg.RemoveKey("InterfaceConfigPath");
      }
      else
      {
         cerr << "Interface::Config - failed to read Registry:\n   " << value_path << endl;
      }
   }

   Anp::Read(reg, "InterfacePrint", fPrint);
   Anp::Read(reg, "InterfaceQuiet", fQuiet);

   reg.Get("InterfaceDefault", fDefault);

   //
   // Read (string, int) key pairs separated by "," or " "
   //
   unsigned int widthS = 0;

   const char *value_keys = 0;
   if(reg.Get("InterfaceKeys", value_keys) && value_keys)
   {
      vector<string> kvec;
      UtilString::StringTok(kvec, string(value_keys), ", ");

      //
      // Now iterate over keys and separate them by "="
      //
      for(vector<string>::const_iterator kit = kvec.begin(); kit != kvec.end(); ++kit)
      {
         vector<string> pvec;
         UtilString::StringTok(pvec, *kit, "=");

         if(pvec.size() != 2)
         {
            cerr << "Interface::Config - failed to parse key: " << *kit << endl;
            continue;
         }

         const string keyS = pvec.front();
         const int    keyI = std::atoi(pvec.back().c_str());
         
         if(!(keyI > 0))
         {
            cerr << "Interface::Config - failed to parse key: " << *kit << endl;
            continue;       
         }

         if(!fKeys.insert(KeyMap::value_type(keyS, keyI)).second)
         {
            cerr << "Interface::Config - key already exists: " << *kit << endl;
            continue;       
         }
         else
         {
            widthS = std::max<unsigned int>(widthS, keyS.size());
         }
      }
   }

   if(reg.KeyExists("PrintConfig"))
   {
      cout << "Interface::Config" << endl
           << "   Print = " << fPrint << endl
           << "   Quiet = " << fQuiet << endl
           << "   Default = " << fDefault << endl
           << "   Added " << fKeys.size() << " key(s)" << endl;
      
      for(KeyMap::const_iterator kit = fKeys.begin(); kit != fKeys.end(); ++kit)
      {
         cout << "   " << std::setw(widthS) << std::left << kit -> first 
              << " = " << kit -> second << endl;
      }

      if(reg.KeyExists("InterfacePrintConfig"))
      {
         reg.PrettyPrint(std::cout);
      }
   }

   //
   // Configure algorithms
   //
   fAlgStore -> Config(reg);
   fAlgSnarl -> Config(reg);
}

---