PulserGain.cxx

Go to the documentation of this file.

// $Id: PulserGain.cxx,v 1.7 2006/01/25 13:52:17 cpw1 Exp $
//
// PulserGain.cxx
//
// Dbi object for raw gain curve info
//
// Author: Phil Adamson 7/2003
//
// $Log: PulserGain.cxx,v $
// Revision 1.7  2006/01/25 13:52:17  cpw1
// Make methods ZCMean and ZCError const
//
//
// Revision 1.6  2005/10/27 09:37:27  cpw1
// Add methods ZCMean and ZCError
//
// Revision 1.5  2004/10/25 20:01:43  murgia
// Initialize numPoints to zero. Set numPoint to expected number of points.
//
// Revision 1.4  2004/10/21 10:20:16  west
// gcc 3.4: Replace DbiReader/DbiWriter.cxx -> .tpl and move after CVSID
//
// Revision 1.3  2004/10/05 21:39:48  murgia
// Fixed code to write points with low light levels. Added call to EndFile.
//
// Revision 1.2  2004/09/17 16:58:38  phil.adamson
// Try to fix aggregate number and stripend missing bugs
//
// Revision 1.1  2004/09/08 21:50:51  pa
// Checkin of new PulserCalibration version. MIght even work
//
//

#include "PulserCalibration/PulserGain.h"
#include "MessageService/MsgService.h"
#include "DatabaseInterface/DbiResultSet.h"
#include "DatabaseInterface/DbiValidityRec.h"
#include <cstring>
#include "Plex/PlexStripEndId.h"
ClassImp(PulserGain)

CVSID("$Id: PulserGain.cxx,v 1.7 2006/01/25 13:52:17 cpw1 Exp $");

  //........
  
#include "DatabaseInterface/DbiResultPtr.tpl"
  template class DbiResultPtr<PulserGain>;
#include "DatabaseInterface/DbiWriter.tpl"
  template class DbiWriter<PulserGain>;


PulserGain::PulserGain()
{
  fAggregateNo = -1;
  fStripEnd = -1;
  for (int i=0;i<40;i++) {
     fMean[i] = -1;
     fError[i] = -1;
     fNumEntries[i] = -1;
     fNumTriggers[i] = -1;
  }
  fFirstPoint = fLastPoint = 0;
  fNumPoints = 0;

}

/*
PulserGain::PulserGain(Int_t aggNo, Int_t seid, Float_t *mean, 
                             Float_t *error, Float_t *num_entries) :
  fAggregateNo(aggNo) , fStripEnd(seid) 
{
  memset(fMean,0,40*sizeof(Float_t));
  memset(fError,0,40*sizeof(Float_t));
  memset(fNumEntries,0,40*sizeof(Float_t));
  memset(fNumTriggers,0,40*sizeof(Float_t));
  fFirstPoint = fLastPoint = 0;
  
}
*/

void PulserGain::New(Int_t aggNo, Int_t points, Int_t stripEndKey)
{
  fAggregateNo = aggNo;
  fStripEnd = stripEndKey;
  fNumPoints =points;
  memset(fMean,0,40*sizeof(Float_t));
  memset(fError,0,40*sizeof(Float_t));
  memset(fNumEntries,0,40*sizeof(Float_t));
  memset(fNumTriggers,0,40*sizeof(Float_t));
  fFirstPoint = fLastPoint = 0;  
}
 
bool PulserGain::AddPoint(Int_t point, const PulserSummary &ps,int aggNo,int expectedPoints)
{

  //  if ((fFirstPoint!=0)&&(point!=(1+fLastPoint))) return false;
  // Some channels might be missing a point with low pulse height.
  if (!(point>fLastPoint)) return false;
  fStripEnd = ps.GetStripEndId().BuildPlnStripEndKey();
  fAggregateNo = aggNo;
  fMean[point-1] = ps.GetMean();
  fError[point-1] =ps.GetError();
  fNumEntries[point-1] = ps.GetEntries();
  fNumTriggers[point-1] = ps.GetTriggers();
  fNumPoints = expectedPoints;
  //  ++fNumPoints;
  fLastPoint = point;
  if (fFirstPoint==0) fFirstPoint = point;

  return true;
}
 
void PulserGain::Fill(DbiResultSet& rs,
                         const DbiValidityRec* /* vrec */)
{
  rs >> fAggregateNo >> fStripEnd >> fNumPoints >> fFirstPoint >> fLastPoint;
  for (int i=0;i<40;i++) rs >> fMean[i];
  for (int i=0;i<40;i++) rs >> fError[i];
  for (int i=0;i<40;i++) rs >> fNumEntries[i];
  for (int i=0;i<40;i++) rs >> fNumTriggers[i];
} 

void PulserGain::Store(DbiOutRowStream& ors,
                          const DbiValidityRec* /* vrec */) const
{
  ors << fAggregateNo << fStripEnd << fNumPoints << fFirstPoint << fLastPoint;
  for (int i=0;i<40;i++) ors << fMean[i];
  for (int i=0;i<40;i++) ors << fError[i];
  for (int i=0;i<40;i++) ors << fNumEntries[i];
  for (int i=0;i<40;i++) ors << fNumTriggers[i];

}

bool PulserGain::Add(const PulserGain &pg)
{
  assert(pg.GetAggregateNo()==fAggregateNo);
  const float * mean = pg.GetMean();
  const float * error = pg.GetError();
  const float * numentries = pg.GetNumEntries();
  const float * numtriggers = pg.GetNumTriggers();

  // Allow Add() to add to either end of the curve.
 if (pg.GetFirstPoint()==1+fLastPoint) {
    // add to end
    fLastPoint = pg.GetLastPoint();
  }
  else if(pg.GetLastPoint()==fFirstPoint-1) {
    // add to start
    fFirstPoint = pg.GetFirstPoint();
  }
  else {
    // Fragments don't join up
    MSG("Pulser",Msg::kError) << "This should never happen!\n";
    return false;
    // This should never happen, though!
  }
  for (int i=pg.GetFirstPoint();i<=pg.GetLastPoint();i++) {
    fMean[i-1] = mean[i-1];
    fError[i-1] = error[i-1];
    fNumEntries[i-1] = numentries[i-1];
    fNumTriggers[i-1] = numtriggers[i-1];
    fNumPoints = pg.GetNumPoints();
    //    ++fNumPoints;
  }
  return true;
}

Float_t PulserGain::ZCMean(Int_t i) const {
  // Return zero-corrected mean for point i
  Float_t zcmean = fMean[i] * fNumEntries[i] / fNumTriggers[i];
  return zcmean;
}

Float_t PulserGain::ZCError(Int_t i) const {
  // Return zero-corrected error for point i
  Float_t zcerr = fNumEntries[i]*fError[i]*fError[i];
  zcerr+= (1.-fNumEntries[i]/fNumTriggers[i])*fMean[i]*fMean[i];
  zcerr = sqrt(fNumEntries[i]*zcerr)/fNumTriggers[i];
  return zcerr;
}

---