RawDcsMagnetMonitorBlock.cxx

Go to the documentation of this file.

// $Id: RawDcsMagnetMonitorBlock.cxx,v 1.16 2009/02/28 21:46:16 gmieg Exp $
// 
// RawDcsMagnetMonitorBlock 
// 
// RawDcsMagnetMonitorBlock is a Dcs Magnet Monitor Block
//
// Author:  R. Hatcher 2003.02.26
//
#include <cstring>

#include "RawData/RawDcsMagnetMonitorBlock.h"

UInt_t RawDcsMagnetMonitorBlock::fgDebugFlags = 0;

#include "MessageService/MsgService.h"
CVSID("$Id: RawDcsMagnetMonitorBlock.cxx,v 1.16 2009/02/28 21:46:16 gmieg Exp $");
//#include "MessageService/MsgStream.h"
#include "MessageService/MsgFormat.h"
#include "RawData/RawBlockRegistry.h"

REGISTERRAWBLOCK(RawDcsMagnetMonitorBlock,kMdBlockDcsMagnetMonitor,kMdBlockSourceDcs);

ClassImp(RawDcsMagnetMonitorBlock)

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

//_____________________________________________________________________________
RawDcsMagnetMonitorBlock::RawDcsMagnetMonitorBlock()
  : MagnetArray(0)
{
   // Default constructor
}

//_____________________________________________________________________________
RawDcsMagnetMonitorBlock::RawDcsMagnetMonitorBlock(const Int_t *block)
  : RawDataBlock(block), MagnetArray(0)
{
   //  stored block format is:
   //---------------------
   //  0   # words in block
   //  1   checksum
   //  2   Block Id
   //-----
   /*
    *  The data has the following repeating structure from here
    *  Int_t n = ((i-3)/32) = num blocks (test modulo for errors);
    *  Int_t d[n*32];  d = block+3;
    *  Int_t indx;
    *  d[(indx*32)+0] = timestamp (long sec)
    *  d[(indx*32)+1] = current
    *  d[(indx*32)+2] = voltage
    *  d[(indx*32)+3] = therm1
    *  . . . . 27 more thermocouples
    *  d[(indx*32)+31] = therm29
    *  indx++;(test if indx is greater than n, if so, finito)
    *
    *  FUTURE VERSION FOR SM2 MAGNET'S CURRENT, VOLTAGE AND THERMS
    *  SM1 and SM2 must be able to get supermodule number (version 1 just
    *  returns sm1, version 2 must split depending on info in rawblock, find
    *  version number in blockid).  Version 2 is also one Int_t longer
    *  (supermod number at end of block, d[(indx*32)+32] = supermod)
    */
}

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

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

   MsgFormat ffmt("%9.3f");
   Int_t iArray[30];
   Float_t fArray[30];
   Int_t numEntries=GetNumEntries();
   os << " Number of Entries " << numEntries
    << " Number of Events " << GetNumEvents() << endl;
   if (GetMagDetector()==Detector::kFar)
   {
           for(Int_t i = 0; i < numEntries; i++)
           {
                   os << "Timestamp " << GetTimeStamp(i).AsString("c") << setw(5)
                   << " Current "  << ffmt(GetFarCurrent(i)) << " Voltage " 
                   << ffmt(GetFarVoltage(i)) << " Supermodule number "<<GetFarSupermodule(i);
                   GetFarThermocoupleArray(i,iArray);
                   for(Int_t k = 0; k < 29; k++)
                   {
                           fArray[k] = 0;
                           memcpy(&fArray[k],&iArray[k],4);
                   }
                   for(Int_t j = 0; j < 29; j++)
                   {
                        os << " Thermocouple " << j+1 << " "
                        << ffmt(fArray[j]);
                   }
                   os << " Imbalance voltage " << ffmt(GetFarImbalanceVoltage(i)) << endl;
           }
   }
   if (GetMagDetector()==Detector::kCalDet)
   {
           for(Int_t i = 0; i < numEntries; i++)
           {
                   os << "Timestamp " << GetTimeStamp(i).AsString("c") << setw(5);
                   if (GetCalIsT7(i)==1)
                   {
                           os << " ZT7_BHZ01S7 " << ffmt(GetCalZT7_BHZ01S7(i))
                           << " ZT7_BHZ01NS7 " << ffmt(GetCalZT7_BHZ01NS7(i))
                           << " ZT7_BHZ02 " << ffmt(GetCalZT7_BHZ02(i))
                           << " ZT7_QFO01 " << ffmt(GetCalZT7_QFO01(i))
                           << " ZT7_QDE02 " << ffmt(GetCalZT7_QDE02(i))
                           << " ZT7_QFO03 " << ffmt(GetCalZT7_QFO03(i))
                           << " ZT7_QDE04 " << ffmt(GetCalZT7_QDE04(i))
                           << " ZT7_QFO05 " << ffmt(GetCalZT7_QFO05(i));
                   }
                   if (GetCalIsT11(i)==1)
                   {
                           os << " ZT11_QDE01 " << ffmt(GetCalZT11_QDE01(i))
                           << " ZT11_QFO02 " << ffmt(GetCalZT11_QFO02(i))
                           << " ZT11_BHZ01 " << ffmt(GetCalZT11_BHZ01(i))
                           << " ZT11_QFO03 " << ffmt(GetCalZT11_QFO03(i))
                           << " ZT11_BHZ02 " << ffmt(GetCalZT11_BHZ02(i))
                           << " ZT11_QFO04 " << ffmt(GetCalZT11_QFO04(i))
                           << " ZT11_QDE05 " << ffmt(GetCalZT11_QDE05(i))
                           << " ZT11_QVT01 " << ffmt(GetCalZT11_QVT01(i));
                   }
                   os << endl;
           }
           os << endl;
   }
   if (GetMagDetector()==Detector::kNear)
   {
           for(Int_t i = 0; i < numEntries; i++)
           {
                   os << "Timestamp " << GetTimeStamp(i).AsString("c") << setw(5)
                   << " Current "  << ffmt(GetNearCurrent(i)) << " Voltage " 
                   << ffmt(GetNearVoltage(i)) << " Voltage ref: " 
                   << ffmt(GetNearVoltageReference(i)) 
                   << " On or Off (on is 1): " << GetNearOnOffState(i) 
                   << " Raw Data: " << GetNearRawData(i) << " Remote: "
                   << GetNearLocalRemoteState(i) << "  Interlocks: "
                   << GetNearInterLockState(i) << "  ground fault: "
                   << GetNearGroundFault(i) << " current reg: "
                   << GetNearCurrentRegMode(i);
           }
           os << endl;
   }
   return os;
}

Int_t RawDcsMagnetMonitorBlock::GetMagDetector() const
{
        RawBlockId rbid = GetBlockId();
        return rbid.GetDetector();
}

void RawDcsMagnetMonitorBlock::FillMagnetArray() const
{
        //off by 3 since the first three are 1:num words, 2: checksum
        MagnetArray = 3 + GetData();
}

VldTimeStamp RawDcsMagnetMonitorBlock::GetTimeStamp(Int_t indx) const
{
        FillMagnetArray();
        if (GetMagDetector()==Detector::kCalDet)
                return VldTimeStamp(MagnetArray[indx*11],0);
        if (GetMagDetector()==Detector::kNear)
                return VldTimeStamp(MagnetArray[indx*5],0);
        if (GetMinorId()==1)
                return VldTimeStamp(MagnetArray[(indx*32)],0);
        if (GetMinorId()==2)
                return VldTimeStamp(MagnetArray[(indx*33)],0);
        if (GetMinorId()==3)
                return VldTimeStamp(MagnetArray[(indx*34)],0);
        printf("fell through on minor version number\n");
        exit(1);
}

Float_t RawDcsMagnetMonitorBlock::GetNearCurrent(Int_t indx) const
{
        FillMagnetArray();
        Float_t fValue=0.0;
        if (GetMinorId()==4)
                memcpy(&fValue,&MagnetArray[(indx*5)+1],4);
        return fValue;
}

Float_t RawDcsMagnetMonitorBlock::GetNearVoltage(Int_t indx) const {
        FillMagnetArray();
        Float_t fValue=0.0;
        if (GetMinorId()==4)
                memcpy(&fValue,&MagnetArray[(indx*5)+2],4);
        return fValue;
}

Float_t RawDcsMagnetMonitorBlock::GetNearVoltageReference(Int_t indx) const {
        FillMagnetArray();
        Float_t fValue=0.0;
        if (GetMinorId()==4)
                memcpy(&fValue,&MagnetArray[(indx*5)+3],4);
        return fValue;
}

Int_t RawDcsMagnetMonitorBlock::GetNearRawData(Int_t indx) const {
        FillMagnetArray();
        if (GetMinorId()==4)
                return MagnetArray[(indx*5)+4];
                //memcpy(&iValue,&MagnetArray[(indx*5)+4],4);
        return 0;
}

Int_t RawDcsMagnetMonitorBlock::GetNearLocalRemoteState(Int_t indx) const {
        Int_t raw = GetNearRawData(indx);
        return (raw%2);
}

Int_t RawDcsMagnetMonitorBlock::GetNearInterLockState(Int_t indx) const {
        Int_t raw = GetNearRawData(indx);
        return (raw/2)%2;
}

Int_t RawDcsMagnetMonitorBlock::GetNearOnOffState(Int_t indx) const {
        Int_t raw = GetNearRawData(indx);
        return (raw/4)%2;
}

Int_t RawDcsMagnetMonitorBlock::GetNearGroundFault(Int_t indx) const {
        Int_t raw = GetNearRawData(indx);
        return (raw/8)%2;
}

Int_t RawDcsMagnetMonitorBlock::GetNearDCOverCurrent(Int_t indx) const {
        Int_t raw = GetNearRawData(indx);
        return (raw/16)%2;
}

Int_t RawDcsMagnetMonitorBlock::GetNearOverTemp(Int_t indx) const {
        Int_t raw = GetNearRawData(indx);
        return (raw/32)%2;
}

Int_t RawDcsMagnetMonitorBlock::GetNearCurrentRegMode(Int_t indx) const {
        Int_t raw = GetNearRawData(indx);
        return (raw/64)%2;
}

Int_t RawDcsMagnetMonitorBlock::GetNearExternalRef(Int_t indx) const {
        Int_t raw = GetNearRawData(indx);
        return (raw/128)%2;
}

Int_t RawDcsMagnetMonitorBlock::GetNearPolarity(Int_t indx) const {
        Int_t raw = GetNearRawData(indx);
        return (raw/256)%2;
}


Float_t RawDcsMagnetMonitorBlock::GetFarCurrent(Int_t indx) const
{
        FillMagnetArray();
        Float_t fValue=0.0;
        if (GetMinorId()==1)
                memcpy(&fValue,&MagnetArray[(indx*32)+1],4);
        if (GetMinorId()==2)
                memcpy(&fValue,&MagnetArray[(indx*33)+1],4);
        if (GetMinorId()==3)
                memcpy(&fValue,&MagnetArray[(indx*34)+1],4);
        return fValue;
}

Float_t RawDcsMagnetMonitorBlock::GetFarVoltage(Int_t indx) const
{
        FillMagnetArray();
        Float_t fValue = 0.0;
        if (GetMinorId()==1)
                memcpy(&fValue,&MagnetArray[(indx*32)+2],4);
        if (GetMinorId()==2)
                memcpy(&fValue,&MagnetArray[(indx*33)+2],4);
        if (GetMinorId()==3)
                memcpy(&fValue,&MagnetArray[(indx*34)+2],4);
        return fValue;
}

Float_t RawDcsMagnetMonitorBlock::GetFarImbalanceVoltage(Int_t indx) const
{
        FillMagnetArray();
        Float_t fValue = 0.0;
        if (GetMinorId()<3)
                return fValue;
        memcpy(&fValue,&MagnetArray[(indx*34)+33],4);
        return fValue;
}

Int_t RawDcsMagnetMonitorBlock::GetFarSupermodule(Int_t indx) const
{
        FillMagnetArray();
        Int_t iValue=0;
        if (GetMinorId()==1)
                return 1;
        if (GetMinorId()==2)
        {
                memcpy(&iValue,&MagnetArray[(indx*33)+32],4);
                return iValue;
        }
        if (GetMinorId()==3)
        {
                memcpy(&iValue,&MagnetArray[(indx*34)+32],4);
                return iValue;
        }
        return 0;
}

void RawDcsMagnetMonitorBlock::GetFarThermocoupleArray(Int_t indx, Int_t iArray[30]) const
{
        FillMagnetArray();
        if (GetMinorId()==1)
                for(Int_t i = 0; i < 29; i++)
                {
                        iArray[i] = MagnetArray[(indx*32)+3+i];
                }
        if (GetMinorId()==2)
                for (Int_t i = 0; i < 30; i++)
                {
                        iArray[i] = MagnetArray[(indx*33)+3+i];
                }
        if (GetMinorId()==3)
                for (Int_t i = 0; i < 30; i++)
                {
                        iArray[i] = MagnetArray[(indx*34)+3+i];
                }
}

Int_t RawDcsMagnetMonitorBlock::GetNumEntries() const
{
        if (GetMagDetector()==Detector::kCalDet)
        {
                if((fSize-3)%18)
                {
                        MSG("RawData",Msg::kError)
                                << " Size of Magnet Block screwed up.  Have: "
                                << (fSize-3)%18 << " left over from modulo 18. "
                                << endl;
                        return -1;
                }
                return ((fSize-3)/18);
        }
        if (GetMinorId()==1)
        {
                if((fSize-3)%32)
                {
                        MSG("RawData",Msg::kError)
                                << " Size of Magnet Block screwed up.  Have: "
                                << (fSize-3)%32 << " left over from modulo 32. "
                                << endl;
                        return -1;
                }
                return ((fSize-3)/32);
        }
        if (GetMinorId()==2)
        {
                if((fSize-3)%33)
                {
                        MSG("RawData",Msg::kError)
                                << " Size of Magnet Block screwed up.  Have: "
                                << (fSize-3)%33 << " left over from modulo 33. "
                                << endl;
                        return -1;
                }
                return ((fSize-3)/33);
        }
        if (GetMinorId()==3)
        {
                if((fSize-3)%34)
                {
                        MSG("RawData",Msg::kError)
                                << " Size of Magnet Block screwed up.  Have: "
                                << (fSize-3)%34 << " left over from modulo 34. "
                                << endl;
                        return -1;
                }
                return ((fSize-3)/34);
        }
        if ((GetMinorId()==4)&&(GetMagDetector()==Detector::kNear))
        {
                if((fSize-3)%5)
                {
                        MSG("RawData",Msg::kError)
                                << " Size of Magnet Block screwed up.  Have: "
                                << (fSize-3)%5 << " left over from modulo 34. "
                                << endl;
                        return -1;
                }
                return ((fSize-3)/5);
        }
        return 0;
}

Int_t RawDcsMagnetMonitorBlock::GetNumEvents() const
{
        return GetNumEntries();
}

VldContext RawDcsMagnetMonitorBlock::GetVldContext() const
{
        RawBlockId rbid = GetBlockId();
        return VldContext(rbid.GetDetector(),rbid.GetSimFlag(),GetTimeStamp(0));
}

//_____________________________________________________________________________

Int_t RawDcsMagnetMonitorBlock::GetCalIsT7(Int_t indx) const
{
        if(GetMagDetector()!=Detector::kCalDet)
                return 0;
        FillMagnetArray();
        return MagnetArray[(indx*18)+1];
}

Int_t RawDcsMagnetMonitorBlock::GetCalIsT11(Int_t indx) const
{
        if (GetCalIsT7(indx)==1)
                return 0;
        return 1;
}

Float_t RawDcsMagnetMonitorBlock::GetCalZT7_BHZ01S7(Int_t indx) const
{
        if(GetMagDetector()!=Detector::kCalDet)
                return 0.0;
        FillMagnetArray();
        Float_t fValue=0;
        memcpy(&fValue,&MagnetArray[(indx*18)+2],4);
        return fValue;
}

Float_t RawDcsMagnetMonitorBlock::GetCalZT7_BHZ01NS7(Int_t indx) const
{
        if(GetMagDetector()!=Detector::kCalDet)
                return 0.0;
        FillMagnetArray();
        Float_t fValue=0;
        memcpy(&fValue,&MagnetArray[(indx*18)+3],4);
        return fValue;
}

Float_t RawDcsMagnetMonitorBlock::GetCalZT7_BHZ02(Int_t indx) const
{
        if(GetMagDetector()!=Detector::kCalDet)
                return 0.0;
        FillMagnetArray();
        Float_t fValue=0;
        memcpy(&fValue,&MagnetArray[(indx*18)+4],4);
        return fValue;
}

Float_t RawDcsMagnetMonitorBlock::GetCalZT7_QFO01(Int_t indx) const
{
        if(GetMagDetector()!=Detector::kCalDet)
                return 0.0;
        FillMagnetArray();
        Float_t fValue=0;
        memcpy(&fValue,&MagnetArray[(indx*18)+5],4);
        return fValue;
}

Float_t RawDcsMagnetMonitorBlock::GetCalZT7_QDE02(Int_t indx) const
{
        if(GetMagDetector()!=Detector::kCalDet)
                return 0.0;
        FillMagnetArray();
        Float_t fValue=0;
        memcpy(&fValue,&MagnetArray[(indx*18)+6],4);
        return fValue;
}

Float_t RawDcsMagnetMonitorBlock::GetCalZT7_QFO03(Int_t indx) const
{
        if(GetMagDetector()!=Detector::kCalDet)
                return 0.0;
        FillMagnetArray();
        Float_t fValue=0;
        memcpy(&fValue,&MagnetArray[(indx*18)+7],4);
        return fValue;
}

Float_t RawDcsMagnetMonitorBlock::GetCalZT7_QDE04(Int_t indx) const
{
        if(GetMagDetector()!=Detector::kCalDet)
                return 0.0;
        FillMagnetArray();
        Float_t fValue=0;
        memcpy(&fValue,&MagnetArray[(indx*18)+8],4);
        return fValue;
}

Float_t RawDcsMagnetMonitorBlock::GetCalZT7_QFO05(Int_t indx) const
{
        if(GetMagDetector()!=Detector::kCalDet)
                return 0.0;
        FillMagnetArray();
        Float_t fValue=0;
        memcpy(&fValue,&MagnetArray[(indx*18)+9],4);
        return fValue;
}

Float_t RawDcsMagnetMonitorBlock::GetCalZT11_QDE01(Int_t indx) const
{
        if(GetMagDetector()!=Detector::kCalDet)
                return 0.0;
        FillMagnetArray();
        Float_t fValue=0;
        memcpy(&fValue,&MagnetArray[(indx*18)+10],4);
        return fValue;
}

Float_t RawDcsMagnetMonitorBlock::GetCalZT11_QFO02(Int_t indx) const
{
        if(GetMagDetector()!=Detector::kCalDet)
                return 0.0;
        FillMagnetArray();
        Float_t fValue=0;
        memcpy(&fValue,&MagnetArray[(indx*18)+11],4);
        return fValue;
}

Float_t RawDcsMagnetMonitorBlock::GetCalZT11_BHZ01(Int_t indx) const
{
        if(GetMagDetector()!=Detector::kCalDet)
                return 0.0;
        FillMagnetArray();
        Float_t fValue=0;
        memcpy(&fValue,&MagnetArray[(indx*18)+12],4);
        return fValue;
}

Float_t RawDcsMagnetMonitorBlock::GetCalZT11_QFO03(Int_t indx) const
{
        if(GetMagDetector()!=Detector::kCalDet)
                return 0.0;
        FillMagnetArray();
        Float_t fValue=0;
        memcpy(&fValue,&MagnetArray[(indx*18)+13],4);
        return fValue;
}

Float_t RawDcsMagnetMonitorBlock::GetCalZT11_BHZ02(Int_t indx) const
{
        if(GetMagDetector()!=Detector::kCalDet)
                return 0.0;
        FillMagnetArray();
        Float_t fValue=0;
        memcpy(&fValue,&MagnetArray[(indx*18)+14],4);
        return fValue;
}

Float_t RawDcsMagnetMonitorBlock::GetCalZT11_QFO04(Int_t indx) const
{
        if(GetMagDetector()!=Detector::kCalDet)
                return 0.0;
        FillMagnetArray();
        Float_t fValue=0;
        memcpy(&fValue,&MagnetArray[(indx*18)+15],4);
        return fValue;
}

Float_t RawDcsMagnetMonitorBlock::GetCalZT11_QDE05(Int_t indx) const
{
        if(GetMagDetector()!=Detector::kCalDet)
                return 0.0;
        FillMagnetArray();
        Float_t fValue=0;
        memcpy(&fValue,&MagnetArray[(indx*18)+16],4);
        return fValue;
}

Float_t RawDcsMagnetMonitorBlock::GetCalZT11_QVT01(Int_t indx) const
{
        if(GetMagDetector()!=Detector::kCalDet)
                return 0.0;
        FillMagnetArray();
        Float_t fValue=0;
        memcpy(&fValue,&MagnetArray[(indx*18)+17],4);
        return fValue;
}

---