FillShower.cxx

Go to the documentation of this file.

// $Id: FillShower.cxx,v 1.15 2008/01/31 22:18:17 rustem Exp $

// ROOT
#include "TClonesArray.h"

// MINOS
#include "CandNtupleSR/NtpSRShower.h"
#include "DataUtil/EnergyCorrections.h"
#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "RecoBase/CandShowerHandle.h"
#include "Registry/Registry.h"
#include "StandardNtuple/NtpStRecord.h"

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

// Local
#include "FillShower.h"

CVSID("$Id: FillShower.cxx,v 1.15 2008/01/31 22:18:17 rustem Exp $");

REGISTER_ANP_OBJECT(AlgStore,FillShower)

namespace EnergyCorrections{}
using namespace EnergyCorrections;
using namespace std;

//-------------------------------------------------------------------
Anp::FillShower::FillShower()
   :fCorr(true)
{    
}

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

//----------------------------------------------------------------------
bool Anp::FillShower::Run(Record& record, TObject *ptr)
{
   //
   // Fill reconstructed shower information for PhysicsNtuple/Shower.h
   //

   if(!record.GetHeader().IsValid())
   {
      MSG("FillAlg", Msg::kError) << "Header is not valid" << endl;
      return false;
   }

   NtpStRecord *ntprec = dynamic_cast<NtpStRecord *>(ptr);
   if(!ntprec)
   {
      const MomNavigator *mom = dynamic_cast<const MomNavigator *> (ptr);
      if(mom)
      {
         ntprec = dynamic_cast<NtpStRecord *>(mom -> GetFragment("NtpStRecord")); 
      }
      else
      {
         MSG("FillAlg", Msg::kError) << "Failed to find MomNavigator pointer" << endl;
         return false;
      }      
   }

   if(!ntprec)
   {
      MSG("FillAlg", Msg::kError) << "Failed to get NtpStRecord pointer" << endl;
      return false;
   }

   const TClonesArray *shower_array = ntprec -> shw;
   if(!shower_array)
   {
      MSG("FillAlg", Msg::kError) << "NtpStRecord does not have valid shower array." <<endl;
      return true;
   }

   const VldContext vldc = ntprec -> GetHeader().GetVldContext();
   const int nshowers = shower_array -> GetEntries();

   for(int i = 0; i < nshowers; ++i)
   {
      NtpSRShower *ntpshw  = dynamic_cast<NtpSRShower *>(shower_array -> At(i));
      if(!ntpshw)
      {
         MSG("FillAlg", Msg::kWarning) << "No shower at " << i << endl;
         continue;
      }

      if(ntpshw -> index != i)
      {
         MSG("FillAlg", Msg::kWarning) << "Mismatched shower index" << endl;
         continue;
      }

      if(!fBasic.Fill(*ntprec, *ntpshw))
      {
         MSG("FillAlg", Msg::kError) << "Failed to fill basic shower information" << endl;
         continue;
      }

      Shower shower;
      
      shower.index      = ntpshw -> index;
      shower.lin_cc_def = ntpshw -> shwph.linCCgev;
      shower.lin_nc_def = ntpshw -> shwph.linNCgev;
      shower.wt_cc_def  = ntpshw -> shwph.wtCCgev;
      shower.wt_nc_def  = ntpshw -> shwph.wtNCgev;
      shower.em         = ntpshw -> shwph.EMgev;

      if(fCorr)
      {
         shower.lin_cc = FullyCorrectShowerEnergy(ntpshw -> shwph.linCCgev,
                                                  CandShowerHandle::kCC,
                                                  vldc,
                                                  ntprec -> GetRelease());
         
         shower.wt_cc = FullyCorrectShowerEnergy(ntpshw -> shwph.wtCCgev,
                                                 CandShowerHandle::kWtCC,
                                                 vldc,
                                                 ntprec -> GetRelease());
         
         shower.lin_nc = FullyCorrectShowerEnergy(ntpshw -> shwph.linNCgev,
                                                  CandShowerHandle::kNC,
                                                  vldc,
                                                  ntprec -> GetRelease());
         
         shower.wt_nc = FullyCorrectShowerEnergy(ntpshw -> shwph.wtNCgev,
                                                 CandShowerHandle::kWtNC,
                                                 vldc,
                                                 ntprec -> GetRelease());
      }
      else
      {
         shower.lin_cc = ntpshw -> shwph.linCCgev;
         shower.lin_nc = ntpshw -> shwph.linNCgev;
         shower.wt_cc  = ntpshw -> shwph.wtCCgev;
         shower.wt_nc  = ntpshw -> shwph.wtNCgev;
      }
      
      shower.fBasic = fBasic.GetBasic();
      shower.fVtx   = fBasic.GetBegVtx();
      
      record.Add(shower);
   }
   
   return true;
}

//----------------------------------------------------------------------
void Anp::FillShower::Config(const Registry &reg)
{
   //
   // Configure self
   //
   
   Anp::Read(reg, "FillShowerCorr", fCorr);

   fBasic.Config(reg);

   if(reg.KeyExists("PrintConfig"))
   {
      cout << "FillShower::Config" << endl
           << "   Corr = " << fCorr << endl;
   }
}

---