FillNPlane.cxx

Go to the documentation of this file.

// $Id: FillNPlane.cxx,v 1.2 2008/03/31 17:25:35 rustem Exp $

// C++
#include <vector>

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

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

//Local
#include "FillNPlane.h"

REGISTER_ANP_OBJECT(AlgSnarl,FillNPlane)
REGISTER_ANP_OBJECT(AlgEvent,FillNPlane)

using namespace std;

//---------------------------------------------------------------------------------------
Anp::FillNPlane::FillNPlane()
   :fKeyBase(4900),
    fMinStripAdc(200.0)
{
}

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

//------------------------------------------------------------------------------------------
bool Anp::FillNPlane::Run(Record &record)
{
   for(EventIterator ievent = record.EventBegIterator(); ievent != record.EventEndIterator(); ++ievent)
   {
      FillNPlane::Run(*ievent, record, true);
   }

   return true;
}

//----------------------------------------------------------------------
bool Anp::FillNPlane::Run(Event &event, const Record& record, const bool pass)
{ 
   //
   // Count number of planes above pulse height cut
   //
   if(!pass) return true;

   //
   // First loop: collect maximum strip pulse height in each plane
   //
   vector<DataNPlane> dvec;

   double dsum = 0.0, asum = 0.0;
   for(StripIter istrip = record.StripBeg(); istrip != record.StripEnd(); ++istrip)
   {
      if(!istrip -> MatchEvt(event.EventIndex()))
      {
         continue;
      }
      
      asum += istrip -> SigCor();

      if(istrip -> SigCor() > fMinStripAdc)
      {
         dvec.push_back(Anp::DataNPlane(*istrip));
         dsum += istrip -> SigCor();
      }
   }
   
   //
   // No strips above threshold found
   //
   if(dvec.empty())
   {
      event.Add(fKeyBase + 2, static_cast<float>(0.0));
      event.Add(fKeyBase + 3, static_cast<float>(0.0));
      event.Add(fKeyBase + 4, static_cast<float>(0.0));
      event.Add(fKeyBase + 5, static_cast<float>(0.0));
      event.Add(fKeyBase + 6, static_cast<float>(0.0));
      return true;
   }

   //
   // Sort data by plane number
   //
   std::sort(dvec.begin(), dvec.end());

   double min_time = dvec.front().time;
   double max_time = dvec.front().time;
   vector<short> pvec;

   for(vector<DataNPlane>::const_iterator idata = dvec.begin(); idata != dvec.end(); ++idata)
   {
      min_time = min<double>(min_time, idata -> time);
      max_time = max<double>(max_time, idata -> time);
      
      if(std::find(pvec.begin(), pvec.end(), idata -> plane) == pvec.end())
      {
         pvec.push_back(idata -> plane);
      }
   }
   
   //
   // Sort plane numbers
   //
   std::sort(pvec.begin(), pvec.end());

   short icount = 1, ncount = 1, nsize = pvec.size();
   for(int i = 1; i < nsize; ++i)
   {
      if(pvec[i-1] + 1 == pvec[i])
      {
         ++icount;
      }
      else
      {
         ncount = std::max<short>(ncount, icount);
         icount = 1;
      }
   }

   //
   // Maximum number of contiguous planes
   //
   ncount = std::max<short>(ncount, icount);
   
   event.Add(fKeyBase + 1, static_cast<float>(1.0e9*(max_time - min_time)));
   event.Add(fKeyBase + 2, static_cast<float>(dvec.size()));
   event.Add(fKeyBase + 3, static_cast<float>(dsum));
   event.Add(fKeyBase + 4, static_cast<float>(pvec.size()));
   event.Add(fKeyBase + 5, static_cast<float>(ncount));

   if(asum > 0.0)
   {
      event.Add(fKeyBase + 6, static_cast<float>(dsum/asum));
   }

   return true;
}

//-----------------------------------------------------------------------------
void Anp::FillNPlane::Config(const Registry &reg)
{
   //
   // Configure self
   //

   reg.Get("FillNPlaneKeyBase",     fKeyBase);
   reg.Get("FillNPlaneMinStripAdc", fMinStripAdc);

   if(reg.KeyExists("PrintConfig"))
   {
      cout << "FillNPlane::Config" << endl
           << "   KeyBase = " << fKeyBase << endl
           << "   MinStripAdc = " << fMinStripAdc << endl;
   }
}

//-----------------------------------------------------------------------------
Anp::DataNPlane::DataNPlane()
   :plane(-1),
    pulse(-1.0),
    time(-1.0)
{
}

//-----------------------------------------------------------------------------
Anp::DataNPlane::DataNPlane(const Strip &strip)
   :plane(strip.GetPlane()),
    pulse(strip.SigCor()),
    time(strip.Time())
{
}

//-----------------------------------------------------------------------------
bool Anp::operator<(const DataNPlane &lhs, const DataNPlane &rhs)
{
   return (lhs.plane < rhs.plane);
}

//-----------------------------------------------------------------------------
bool Anp::operator==(const DataNPlane &lhs, const DataNPlane &rhs)
{
   return (lhs.plane == rhs.plane);
}

---