TestDataModule.cxx

Go to the documentation of this file.

// $Id: TestDataModule.cxx,v 1.4 2008/09/05 15:42:33 rustem Exp $

// C/C++
#include <cassert>
#include <iomanip>

// ROOT
#include "TClonesArray.h"

// MINOS
#include "CandNtupleSR/NtpSREvent.h"
#include "CandNtupleSR/NtpSRTrack.h"
#include "JobControl/JobCModuleRegistry.h"
#include "JobControl/JobCommand.h"
#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "StandardNtuple/NtpStRecord.h"

// Local
#include "PhysicsNtuple/Default.h"
#include "PhysicsNtuple/Factory.h"
#include "FillBasic.h"
#include "Interface.h"

// Local
#include "TestDataModule.h"

CVSID("$Id: TestDataModule.cxx,v 1.4 2008/09/05 15:42:33 rustem Exp $");

JOBMODULE(TestDataModule, "TestDataModule", "TestDataModule");

//---------------------------------------------------------------------------------------------
Anp::StorekNNData::StorekNNData()
{
}

//---------------------------------------------------------------------------------------------
Anp::StorekNNData::~StorekNNData()
{
}

//---------------------------------------------------------------------------------------------
bool Anp::StorekNNData::Add(const std::string &key, const float data)
{
   return fData.insert(map<string, float>::value_type(key, data)).second;
}

//---------------------------------------------------------------------------------------------
bool Anp::StorekNNData::Get(const std::string &key, float &data)
{
   map<string, float>::const_iterator fit = fData.find(key);
   if(fit != fData.end())
   {
      data = fit -> second;
      return true;
   }

   return false;
}

//---------------------------------------------------------------------------------------------
TestDataModule::TestDataModule()
   :fInterface(new Anp::Interface()),
    fNPass(0),
    fNFail(0),
    fPrintEvent(false),
    fPrintTrack(false),
    fStrip(false),
    fConfig(false)
{
   Anp::Factory<Anp::StorekNNData>::
      Instance().Hold("kNNData", Anp::Handle<Anp::StorekNNData>(new Anp::StorekNNData));
}

//---------------------------------------------------------------------------------------------
TestDataModule::~TestDataModule() 
{
   //
   // Delete interface object
   //
   delete fInterface;
   fInterface = 0;

   //
   // Destroy StorekNNData if it exists
   //
   Anp::Factory<Anp::StorekNNData>::Instance().Remove("kNNData");

   MSG("TestData", Msg::kDebug) 
      << endl
      << "**************************************************" << std::endl
      << "    TestDataModule" << std::endl
      << "      Number of passed records " << fNPass << std::endl
      << "      Number of failed records " << fNFail << std::endl
      << "**************************************************" << std::endl;
}

//---------------------------------------------------------------------------------------------
JobCResult TestDataModule::Reco(MomNavigator *mom)
{   
   NtpStRecord *ntprec = dynamic_cast<NtpStRecord *>(mom -> GetFragment("NtpStRecord")); 
   if(!ntprec)
   {
      MSG("TestData", Msg::kError) << "Failed to get NtpStRecord pointer" << endl;
      return JobCResult::kAOK;
   }

   //
   // Fill interface with data for a new snarl
   //
   if(fInterface -> FillSnarl(ntprec))
   {
      ++fNPass;
   }
   else
   {
      ++fNFail;
      return JobCResult::kAOK; 
   } 

   TClonesArray *event_array = ntprec -> evt;
   TClonesArray *track_array = ntprec -> trk;
   if(!event_array || !track_array)
   {           
      MSG("TestData", Msg::kWarning) << "Invalid TClonesArray object(s)" << endl;
      return JobCResult::kAOK;
   }

   //
   // Iterate over all events and access analysis variables
   //
   for(int ievent = 0; ievent < event_array -> GetEntries(); ++ievent)
   {
      NtpSREvent *event = dynamic_cast<NtpSREvent *>(event_array -> At(ievent));
      if(!event)
      {
         MSG("TestData", Msg::kError) << "NtpSREvent dynamic_cast failed" << endl;
         continue;
      }

      if(fPrintEvent)
      {
         cout << "NtpSREvent - index "<< event -> index << endl << "   ";
         (event -> plane).Print(cout);
      }
      
      TestDataModule::Analyze(event, fPrintEvent);
      assert(event -> index == ievent && "mismatched index");
   }

   //
   // Iterate over all tracks and access analysis variables
   //
   for(int itrack = 0; itrack < track_array -> GetEntries(); ++itrack)
   {
      NtpSRTrack *track = dynamic_cast<NtpSRTrack *>(track_array -> At(itrack));
      if(!track)
      {
         MSG("TestData", Msg::kError) << "NtpSRTrack dynamic_cast failed" << endl;
         continue;
      }
      
      if(fPrintTrack)
      {
         cout << "NtpSRTrack - index "<< track -> index << endl << "   ";
         (track -> plane).Print(cout);
      }
      
      TestDataModule::Analyze(track, fPrintTrack);
      assert(track -> index == itrack && "mismatched index");
      
      if(fPrintTrack && fStrip)
      {
            Anp::PrintStrips(*ntprec, track -> stp, track -> nstrip);
      }
   }

   return JobCResult::kAOK;
}

//---------------------------------------------------------------------------------------------
void TestDataModule::Config(const Registry& reg)
{
   MSG("TestData", Msg::kVerbose) << "TestDataModule::Config()..." << std::endl;

   //
   // Store Registry copy
   //
   fConfig.UnLockValues();
   fConfig.Merge(reg);
   fConfig.LockValues();

   Anp::Read(reg, "TestDataModulePrintEvent", fPrintEvent);
   Anp::Read(reg, "TestDataModulePrintTrack", fPrintTrack);
   Anp::Read(reg, "TestDataModuleStrip", fStrip);
}

//---------------------------------------------------------------------------------------------
void TestDataModule::BeginJob()
{
   MSG("TestData", Msg::kVerbose) << "TestDataModule::BeginJob()..." << std::endl;

   //
   // Configure interface object at the beginning of analysis job
   //
   fInterface -> Config(fConfig);
}

//------------------------------------------------------------------------------------------
void TestDataModule::Analyze(TObject *object, const bool print)
{
   //
   // Extract variables from PhysicsNtuple interface
   //
   const float numubar = fInterface -> GetVar("numubar", object);
   const float rel_ang = fInterface -> GetVar("rel_ang", object);
   const float knn_pid = fInterface -> GetVar("knn_pid", object);
   const float knn_01  = fInterface -> GetVar("knn_01",  object);
   const float knn_10  = fInterface -> GetVar("knn_10",  object);
   const float knn_20  = fInterface -> GetVar("knn_20",  object);
   const float knn_40  = fInterface -> GetVar("knn_40",  object);

   if(print)
   {
      cout << "   anti neutrino selection = " << numubar << endl
           << "   relative angle = " << rel_ang << endl
           << "   knn muon pid = " << knn_pid << endl
           << "   number of scintillator planes = " << knn_01 << endl
           << "   mean track signal = " << knn_10 << endl
           << "   low mean signal over high mean signal = " << knn_20 << endl
           << "   track mean signal over track window mean signal = " << knn_40 << endl;
   }
   
   Anp::Handle<Anp::StorekNNData> data = Anp::Factory<Anp::StorekNNData>::Instance().Get("kNNData");

   if(!data.valid())
   {
      cerr << " TestDataModule::Analyze - Handle<StorekNNData> is invalid" << endl;
      return;
   }

   data -> Add("numubar", numubar);
   data -> Add("rel_ang", rel_ang);

   float numubar_ = -1.0e6, rel_ang_ = -1.0e6;

   data -> Get("numubar", numubar_);
   data -> Get("rel_ang", rel_ang_);
}

---