FillHeader.cxx

Go to the documentation of this file.

// $Id: FillHeader.cxx,v 1.18 2009/09/18 22:33:08 jyuko Exp $

// MINOS
#include "BeamDataUtil/BDSpillAccessor.h"
#include "BeamDataUtil/BMSpillAna.h"
#include "BeamDataUtil/BeamMonSpill.h"
#include "Conventions/BeamType.h"
#include "Conventions/ReleaseType.h"
#include "DataUtil/DataQualDB.h"
#include "DataUtil/MCInfo.h"
#include "DcsUser/CoilTools.h"
#include "DcsUser/HvStatusFinder.h"
#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "StandardNtuple/NtpStRecord.h"
#include "SpillTiming/SpillServerMonFinder.h"
#include "SpillTiming/SpillTimeFinder.h"
#include "Validity/VldContext.h"

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

// Local
#include "FillHeader.h"

CVSID("$Id: FillHeader.cxx,v 1.18 2009/09/18 22:33:08 jyuko Exp $");

REGISTER_ANP_OBJECT(AlgStore,FillHeader)

using namespace std;

//----------------------------------------------------------------------
Anp::FillHeader::FillHeader()
  :fBeam("Unknown"),
   fBrief(false),
   fSpill(0)
{
}

//----------------------------------------------------------------------
Anp::FillHeader::~FillHeader()
{
   if(fSpill)
   {
      delete fSpill;
   }
}

//----------------------------------------------------------------------
bool Anp::FillHeader::Run(Record &record, TObject *ptr)
{
   //
   // Fill snarl header information
   //

   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 RecCandHeader &ntph = ntprec -> GetHeader();
   const VldContext     vldc = ntph.GetVldContext();
   const VldTimeStamp   vlds = vldc.GetTimeStamp();
   //
   // Create and fill Header
   //
   Header header;
   header.run       = ntph.GetRun();
   header.subrun    = ntph.GetSubRun();
   header.snarl     = ntph.GetSnarl();
   header.timeframe = ntph.GetTimeFrame();
   header.sec       = vlds.GetSec();
   header.nsec      = vlds.GetNanoSec();
   header.trigger   = ntph.GetTrigSrc();
   header.spilltype = ntph.GetRemoteSpillType();
   header.valid     = true;

   if     (vldc.GetDetector() == Detector::kNear)   header.detector = 1;
   else if(vldc.GetDetector() == Detector::kFar)    header.detector = 2;
   else if(vldc.GetDetector() == Detector::kCalDet) header.detector = 3;
      
   if     (vldc.GetSimFlag() == SimFlag::kData) header.simflag = 1;
   else if(vldc.GetSimFlag() == SimFlag::kMC)   header.simflag = 2;
   
   //
   // get software release information
   //
   header.relitype = ntprec -> GetRelease();

   //
   // Fill brief header information and copy Header into Record.
   //   
   if(fBrief)
   {
      record.Set(header);
      return true;
   }

   if(vldc.GetSimFlag() == SimFlag::kData)
   {
      //
      // Set run period
      //
      unsigned int year = 0, month = 0, day = 0;
      vlds.GetDate(true, 0, &year, &month, &day);

      MSG("FillAlg", Msg::kDebug) << "date: " << year << "/" << month << "/" << day << endl;

      if(year == 2005 || (year == 2006 && month < 4))
      {
         header.runperiod = 1;
      }
      else if((year == 2006 && month > 4) || (year == 2007 && month < 9))
      {
         header.runperiod = 2;
      }
      else if((year == 2007 && month > 9) || (year == 2008 && month > 0))
      {
         header.runperiod = 3;
      }

      //
      // Get spill time info for data
      //
      if(SpillTimeFinder::Instance().DataIsAvailable(vldc))
      {
         const VldTimeStamp vts = SpillTimeFinder::Instance().GetTimeOfNearestSpill(vldc);
         
         header.spillsec   = vts.GetSec();
         header.spillnsec  = vts.GetNanoSec();
         header.time2spill = SpillTimeFinder::Instance().GetTimeToNearestSpill(vldc);
      }
      else
      {
         MSG("FillAlg", Msg::kError) << "SpillTimeFinder data is not available" << endl; 
      }
     
      //
      // Get beam data from database storing beam monitoring data
      //
      const BeamMonSpill *beam_spill = BDSpillAccessor::Get().LoadSpill(vlds);

      if(beam_spill)
      { 
         header.beamdsec  = beam_spill -> SpillTime().GetSec();
         header.beamdnsec = beam_spill -> SpillTime().GetNanoSec();
         header.tor101    = beam_spill -> fTor101;
         header.tr101d    = beam_spill -> fTr101d;
         header.tortgt    = beam_spill -> fTortgt;
         header.trtgtd    = beam_spill -> fTrtgtd;
         header.SetBeamType(BeamType::AsString(beam_spill -> BeamType()));

         //
         // Get result of "good spill cut"
         //
         if(!fSpill)
         {
            fSpill = new BMSpillAna();
            fSpill -> UseDatabaseCuts(true);
         }

         fSpill -> SetSpill(*beam_spill);
         fSpill -> SetTimeDiff(header.BeamDTime() - header.SpillTime());

         //
         // Beam passed "good beam" cut
         //
         header.goodbeam = fSpill -> SelectSpill();
      }
      else       
      {
         MSG("FillAlg", Msg::kError) << "Failed to load spill: " << vldc << endl;
      }

      //
      // Get detector coil status and coil current
      //
      CoilTools &ctool = CoilTools::Instance();

      header.goodcoil = ctool.IsOK(vldc);
      header.coilrevs = ctool.IsReverse(vldc);

      //
      // Fill GPS time and error, LI time (trigger PMT hit time) and crate mask
      //
      const SpillServerMon &smon = SpillServerMonFinder::Instance().GetNearestSpill(vldc);

      if(vldc.GetDetector() == Detector::kNear)
      {  
         //
         // Near detector state is good: gps not needed, no li, crates and hv are always on
         //
         header.gpstime   = smon.GetSpillTimeND().GetSec();
         header.gpserror  = smon.GetSpillTimeError();
         header.litime    = 0;
         header.cratemask = 0;
         header.gooddetc  = true;
         header.goodhv    = true;

         const Dcs_Mag_Near *mag = ctool.GetMagNear(vldc); 
         if(mag)
         {
            header.coilcur = mag -> GetCurrent();
         }
         else
         {
            MSG("FillAlg", Msg::kError) << "Failed to get Dcs_Mag_Near pointer" << endl;
         }
      }
      else if(vldc.GetDetector() == Detector::kFar)
      {  
         header.gpstime   = smon.GetSpillTimeFD().GetSec();      
         header.gpserror  = smon.GetSpillTimeError();
         header.litime    = ntprec -> dataquality.litime;
         header.cratemask = ntprec -> dataquality.cratemask;

         //
         // Get far detector state and high voltage status
         //
         header.gooddetc = DataUtil::IsGoodFDData(ntprec);
         header.goodhv   = HvStatus::Good(HvStatusFinder::Instance().GetHvStatus(vldc));

         const BfldDbiCoilState *bfld1 = ctool.GetCoilState(vldc, 1);
         const BfldDbiCoilState *bfld2 = ctool.GetCoilState(vldc, 2);
         if(bfld1 && bfld2)
         {
            header.coilcur = 0.5*(bfld1 -> GetCurrent() + bfld2 -> GetCurrent());
         }
         else
         {
            MSG("FillAlg", Msg::kError) << "Failed to get BfldDbiCoilState pointer(s)" << endl; 
         }       
      }
   }
   else
   {
      //
      // Set runperiod, spill time to trigger, GPS and detector parameters for Monte-Carlo 
      //
      header.runperiod  = 0;
      header.spillsec   = vlds.GetSec();
      header.spillnsec  = vlds.GetNanoSec();
      header.gpstime    = vlds.GetSec();
      header.gpserror   = 0;
      header.litime     = 0;
      header.cratemask  = 0;

      //
      // Set protons/snarl and beam type for Monte-Carlo
      //
      header.beamdsec   = vlds.GetSec();
      header.beamdnsec  = vlds.GetNanoSec();
      header.tor101     = MCInfo::GetMCPoT(vldc.GetDetector(),
                                           BeamType::TagToEnum(fBeam.c_str()),
                                           header.Release());
      header.tr101d     = header.tor101;
      header.tortgt     = header.tor101;
      header.trtgtd     = header.tor101;
      header.coilcur    = 0.0;
      header.time2spill = 0.0;
      header.SetBeamType(fBeam);

      //
      // Monte-Carlo always has "good" beam, coil and detector
      //
      header.goodbeam = true;
      header.goodcoil = true;
      header.gooddetc = true;
      header.goodhv   = true;
   }

   MSG("FillAlg", Msg::kDebug) << header << endl;

   //
   // Copy Header into Record
   //
   record.Set(header);

   return true;
}

//---------------------------------------------------------------------------------------------
void Anp::FillHeader::Config(const Registry& reg)
{
   //
   // Get beam type for Monte-Carlo snarls from Registry or environment
   //

   const char *value_beam = 0;
   if(!reg.Get("FillBeam", value_beam))
   {
      reg.Get("PhysicsNtupleBeam", value_beam);
   }

   if(!value_beam)
   {
      value_beam = std::getenv("PHYSICS_NTUPLE_BEAM");
   }

   if(value_beam)
   {      
      BeamType::BeamType_t beam = BeamType::TagToEnum(value_beam);

      if(beam == BeamType::kUnknown)
      {
         const string tmps(value_beam);

         //
         // Try adding to beam string "i" and "z"
         //
         if(tmps.size() > 6)
         {
            beam = BeamType::TagToEnum((tmps.substr(0, 4)+"z"+tmps.substr(4, 3)+"i").c_str());
         }
      }
      
      //
      // Save valid BeamType string
      //
      if(beam != BeamType::kUnknown) fBeam = BeamType::AsString(beam);
   }

   Anp::Read(reg, "FillHeaderBrief", fBrief);

   if(reg.KeyExists("PrintConfig"))
   {
      cout << "FillHeader::Config" << endl
           << "   BeamType = " << fBeam << endl
           << "   Brief = " << fBrief << endl;
   }
}

---