PulserTimeDrift.cxx

Go to the documentation of this file.

#include "PulserTimeDrift.h"

#include "DatabaseInterface/DbiResultSet.h"
#include "MessageService/MsgService.h"
#include <cassert>
#include <math.h>

ClassImp(PulserTimeDrift)
CVSID("$Id: PulserTimeDrift.cxx,v 1.10 2007/03/01 17:06:40 rhatcher Exp $");

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

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




// Constructor
PulserTimeDrift::PulserTimeDrift(
                                 Int_t aggregate,
                                 Int_t index,
                                 Float_t entries, 
                                 Float_t mean, 
                                 Float_t rms) :
  fAggregate(aggregate),
  fChannelIndex(index),
  fEntries(entries),
  fMean(mean),
  fRms(rms)
{
  LEA_CTOR;
}

// Index <---> RawChannelId
Int_t PulserTimeDrift::GetIndex(const RawChannelId& rcid)
{
  if(rcid.GetDetector()==Detector::kFar) {
    Int_t index = rcid.GetCrate()*108
                + rcid.GetVarcId()*36
                + rcid.GetVmm()*6
                + rcid.GetVaAdcSel()*3
                + rcid.GetVaChip();
    return index;
  } else if(rcid.IsNull()) {
    return -1;
  } else {
    // ND not supported.
    assert(0);
  }
  return -1;
}

RawChannelId PulserTimeDrift::GetRawChannelId(Int_t index)
{
  Int_t temp = index;
  Int_t crate = index/108;
  temp -= crate*108;
  Int_t varc  = temp/36;
  temp -= varc*36;
  Int_t vmm  = temp/6;
  temp -= vmm*6;
  Int_t vaadc = temp/3;
  temp -= vaadc*3;
  Int_t vachip  = temp;

  return RawChannelId(Detector::kFar,
                      ElecType::kVA,
                      crate, 
                      varc,
                      vmm,
                      vaadc,
                      vachip,
                      0  // no particular channel on chip
                      );                              
}

// Add
void PulserTimeDrift::Add( Float_t ent, Float_t mean, Float_t rms )
{

  // new entries, new mean:
  double newEntries  = fEntries + ent;
  double newMean     = (fMean*fEntries + ent*mean)/newEntries;

  double oldx2 = (fRms*fRms + fMean*fMean)*fEntries;
  double addx2 = (rms*rms + mean*mean)*ent;
  double newx2 = oldx2 + addx2;
  double newRms = sqrt(fabs(newx2/newEntries - newMean*newMean));

  fEntries = newEntries;
  fMean    = newMean;
  fRms     = newRms;
}


// Database stuff
void PulserTimeDrift::Fill(DbiResultSet& rs, 
                         const DbiValidityRec* /* vrec */ ) {

//
//
//  Purpose:  Fill object from Result Set
//
//  Arguments: 
//    rs           in    Result Set used to fill object
//    vrec         in    Associated validity record (or 0 if filling
//                                                    DbiValidityRec)

   if ( rs.TableName() == "PULSERTIMEDRIFT" ) {
      // Dumb method.
     rs  >> fAggregate >> fChannelIndex >> fEntries >> fMean >> fRms;
   }
   else {      
     // Smart method
     Int_t numCol = rs.NumCols();
     //  The first column (SeqNo) has already been processed.
     for (Int_t curCol = rs.HasRowCounter() ? 3 : 2; curCol <= numCol; ++curCol) {
       string colName = rs.CurColName();
       if ( colName == "AGGREGATENO" )        rs >> fAggregate;
       else if( colName == "CHANNELINDEX" )   rs >> fChannelIndex;
       else if( colName == "ENTRIES" )        rs >> fEntries;
       else if( colName == "MEAN" )           rs >> fMean;
       else if( colName == "RMS" )            rs >> fRms;
       else {
            MSG("Dbi",Msg::kDebug) << "Ignoring column " << curCol 
                                   << "(" << colName << ")"
                                   << "; not part of PulserTimeDrift" 
                                   << endl;
            rs.IncrementCurCol();
         }
      }
   }
   
}


void PulserTimeDrift::Store(DbiOutRowStream& ors,
                          const DbiValidityRec* /* vrec */) const 
{
  //
  //
  //  Purpose:  Stream object to output row stream
  //
  
  ors << fAggregate << fChannelIndex << fEntries << fMean << fRms;
}

---