RawDcsHvMonitorBlock.cxx

Go to the documentation of this file.

// $Id: RawDcsHvMonitorBlock.cxx,v 1.11 2005/08/26 19:04:53 rhatcher Exp $
// 
// RawDcsHvMonitorBlock 
// 
// RawDcsHvMonitorBlock is a Dcs High Voltage Monitor Block
//
// Author:  R. Hatcher 2003.02.26
//

#include "RawData/RawDcsHvMonitorBlock.h"

UInt_t RawDcsHvMonitorBlock::fgDebugFlags = 0;

#include "MessageService/MsgService.h"
CVSID("$Id: RawDcsHvMonitorBlock.cxx,v 1.11 2005/08/26 19:04:53 rhatcher Exp $");
#include "MessageService/MsgFormat.h"

#include "RawData/RawBlockRegistry.h"
REGISTERRAWBLOCK(RawDcsHvMonitorBlock,kMdBlockDcsHvMonitor,kMdBlockSourceDcs);

ClassImp(RawDcsHvMonitorBlock)

enum EDcsHvMonitorBlkPos {
   indx_size      = 0,
   indx_checksum  = 1,
   indx_blockid   = 2,
   zzzz_last      = 3
};

//_____________________________________________________________________________
RawDcsHvMonitorBlock::RawDcsHvMonitorBlock()
  : HvArray(0)
{
   // Default constructor
}

//_____________________________________________________________________________
RawDcsHvMonitorBlock::RawDcsHvMonitorBlock(const Int_t *block)
  : RawDataBlock(block), HvArray(0)
{
   //  stored block format is:
   //---------------------
   //  0   i = # words in block
   //  1   checksum
   //  2   Block Id

   /*
    * The data has the following repeating structure from here
    *  Int_t n = ((i-3)/6) = num blocks (test modulo for errors);
    *  Int_t d[n*6];  d = block+3;
    *  Int_t indx;
    *  d[(indx*6)+0] = timestamp (long secs)
    *  d[(indx*6)+1] = mfcdch (long)
    *  d[(indx*6)+2] = geom(long)
    *  d[(indx*6)+3] = setv(signed long)
    *  d[(indx*6)+4] = readv(signed long)
    *  d[(indx*6)+5] = alarm(long)
    *  indx++;(test if indx is greater than n, if so, finito)

    *  version 1 has timestamp off by 1 hour in sm2 records between 
    *  2003-06-03 12:24:00 and 2003-06-11 03:22:26 in GMT time.  
    *  add one hour to these when making final record.

    *  version 2 has some recs with order screwed up, check this by 
    *  checking whether mfcdch or geom is negative.  if so, then 
    *  swap mfcdch with setv and geom with readv.(version 1 also)

    *  version 3 has none of these problems, and also has the 
    *  new shield and trig pmt values (of adding 10000 to shield and 20000 to trig)
    */
}

//_____________________________________________________________________________
RawDcsHvMonitorBlock::~RawDcsHvMonitorBlock()
{
   // dtor
}

//_____________________________________________________________________________
std::ostream& RawDcsHvMonitorBlock::FormatToOStream(ostream& os, 
                                                    Option_t *option) const
{
        RawDataBlock::FormatToOStream(os,option);
        if (option[0] == 'X') return os;

        Int_t numEntries=GetNumEntries();
        os << " Number of Entries " << numEntries 
        << " Number of Events " << GetNumEvents() << endl;
        for(Int_t i = 0; i < numEntries; i++)
        {
                os << "Timestamp " << GetTimeStamp(i).AsString("c")
                <<" Mainframe " << GetMainframe(i) << " Card " 
                << GetCard(i)
                << " Channel " << GetChannel(i);
                if (GetHvDetector()==Detector::kFar)
                {
                        if (GetFarIsShield(i))
                                os << " Shield Plane " << GetFarShieldPlane(i);
                        else
                                if (GetFarIsTriggerPmt(i))
                                        os << " Trigger Pmt ";
                                else
                                        os << " Plane " << GetPlane(i);
                        os << " Side " << GetSide(i) << " Pmt " << GetPmt(i);
                }
                if (GetHvDetector()==Detector::kNear)
                {
                        if (GetNearIsTriggerPmt(i))
                                os << "  Is Trigger Pmt ";
                        else
                                os << "  Near Plane: " << GetPlane(i);
                }
                os << " Set Voltage " << GetSetVoltage(i) << " Read Voltage " 
                << GetReadVoltage(i) << " Alarms " << GetAlarmbits(i) << endl;
        }
        return os;
}

//_____________________________________________________________________________

void RawDcsHvMonitorBlock::FillHvArray() const
{
        //off by 3 since the first three are 1: num words, 2: checksum
        // and 3:block ID
        HvArray = 3 + GetData();
}

Int_t RawDcsHvMonitorBlock::GetNumEntries() const
{
        // remember, all versions
        // have offset of 3 due to first 3 longs)
        if((fSize-3)%6)
        {
                MSG("RawData",Msg::kError)
                        << " Size of Hv Block screwed up.  Have: " 
                        << (fSize-3)%6 << " left over from modulo 6."
                        << endl;
                return -1;
        }
        return ((fSize-3)/6);
}

Int_t RawDcsHvMonitorBlock::GetNumEvents() const
{
        return 1;
}

VldContext RawDcsHvMonitorBlock::GetVldContext() const
{
           // build validity context
        RawBlockId rbid = GetBlockId();
        return VldContext(rbid.GetDetector(),rbid.GetSimFlag(),GetTimeStamp(0));
}

Int_t RawDcsHvMonitorBlock::GetFarIsShield(Int_t indx) const
{
        if (GetMinorId()<3)
        {
                if ( (GetPlane(indx)<100) && (GetCard(indx)==12) )
                        return 1;
        }
        else if (GetMinorId()==3)
        {
                if ((GetRawGeometry(indx) > 10000)&& (GetRawGeometry(indx)<20000) )
                        return 1;
        }
        return 0;
}

Int_t RawDcsHvMonitorBlock::GetFarShieldPlane(Int_t indx) const
{
        if (GetFarIsShield(indx)==0)
                return 0;
        if (GetMinorId()<3)
        {
                return GetPlane(indx);
        }
        return ((GetRawGeometry(indx)/10)-1000);
}

Int_t RawDcsHvMonitorBlock::GetFarIsTriggerPmt(Int_t indx) const
{
        if ( (GetMinorId()<3) && (GetRawChannel(indx)==3015) )
                return 1;
        if (GetMinorId()==3)
                if (GetRawGeometry(indx)>=20000)
                        return 1;
        return 0;
}

Int_t RawDcsHvMonitorBlock::GetNearIsTriggerPmt(Int_t indx) const
{
        return GetFarIsTriggerPmt(indx);
}

Int_t RawDcsHvMonitorBlock::GetChannel(Int_t indx) const
{
        Int_t nRawChan = GetRawChannel(indx);
        Int_t temp = nRawChan/1000;
        nRawChan = nRawChan - (temp*1000);
        Int_t nCard = nRawChan/16;
        return (nRawChan-(nCard*16));
}

Int_t RawDcsHvMonitorBlock::GetMainframe(Int_t indx) const
{
        return (GetRawChannel(indx)/1000);
}

Int_t RawDcsHvMonitorBlock::GetCard(Int_t indx) const
{
        Int_t nRawChan = GetRawChannel(indx);
        Int_t temp = nRawChan/1000;
        nRawChan = nRawChan - (temp*1000);
        return (nRawChan/16);
}

Int_t RawDcsHvMonitorBlock::GetHvDetector() const
{
        RawBlockId rbid = GetBlockId();
        return rbid.GetDetector();
}

Int_t RawDcsHvMonitorBlock::GetPlane(Int_t indx) const
{
        if (GetHvDetector()==Detector::kFar)
        {
                if ( (GetFarIsTriggerPmt(indx)) || ( ((GetRawGeometry(indx)/10)<100) && (GetCard(indx)==12)) )
                        return 0;
        }
        return (GetRawGeometry(indx)/10);
}

Int_t RawDcsHvMonitorBlock::GetSide(Int_t indx) const
{
        Int_t iRawGeom = GetRawGeometry(indx);
        Int_t iTemp = iRawGeom/10;
        iRawGeom = iRawGeom - (iTemp*10);
        return (iRawGeom/3);
}

Int_t RawDcsHvMonitorBlock::GetPmt(Int_t indx) const
{
        Int_t iRawGeom = GetRawGeometry(indx);
        Int_t iTemp = iRawGeom/10;
        iRawGeom = iRawGeom - (iTemp*10);
        iTemp = iRawGeom/3;
        return (iRawGeom-(iTemp*3));
}

Int_t RawDcsHvMonitorBlock::GetRawChannel(Int_t indx) const
{
        FillHvArray();
        Int_t hvtemp = HvArray[(indx*6)+1];
        if (GetMinorId()==3)
                return hvtemp;
        if (hvtemp<0)
                return HvArray[(indx*6)+3];
        return hvtemp;
}

Int_t RawDcsHvMonitorBlock::GetRawGeometry(Int_t indx) const
{
        FillHvArray();
        Int_t hvtemp = HvArray[(indx*6)+2];
        if (GetMinorId()==3)
                return hvtemp;
        if (hvtemp<0)
                return HvArray[(indx*6)+4];
        return hvtemp;
}

Int_t RawDcsHvMonitorBlock::GetSetVoltage(Int_t indx) const
{
        FillHvArray();
        Int_t hvtemp = HvArray[(indx*6)+1];
        if (hvtemp<0)
                return hvtemp;
        return HvArray[(indx*6)+3];
}

Int_t RawDcsHvMonitorBlock::GetReadVoltage(Int_t indx) const
{
        FillHvArray();
        Int_t hvtemp = HvArray[(indx*6)+2];
        if (hvtemp<0)
                return hvtemp;
        return HvArray[(indx*6)+4];
}

VldTimeStamp RawDcsHvMonitorBlock::GetTimeStamp(Int_t indx) const
{
        FillHvArray();
        Int_t temptime=HvArray[(indx*6)];
        if (GetMinorId()==1)
/* fix the temptime offset to be between 2003-06-03 12:24 and 2003011 03:22:26 */
                if ((temptime>1054643040)&&(temptime<1055301756))
                        if ((GetMainframe(indx)<=8)&&(GetMainframe(indx)>=5))
                                temptime=temptime+3600;
        return VldTimeStamp(temptime,0);
}

---