RawDcsChillerMonitorBlock.cxx

Go to the documentation of this file.

// $Id: RawDcsChillerMonitorBlock.cxx,v 1.3 2005/09/02 22:30:07 rhatcher Exp $
// 
// RawDcsChillerMonitorBlock 
// 
// RawDcsChillerMonitorBlock is a Dcs Chiller System Monitor Block
//
// Author:  E. Beall 2004-02-04
//

#include "RawData/RawDcsChillerMonitorBlock.h"

UInt_t RawDcsChillerMonitorBlock::fgDebugFlags = 0;

#include "MessageService/MsgService.h"
CVSID("$Id: RawDcsChillerMonitorBlock.cxx,v 1.3 2005/09/02 22:30:07 rhatcher Exp $");
#include "MessageService/MsgFormat.h"

#include "RawData/RawBlockRegistry.h"
REGISTERRAWBLOCK(RawDcsChillerMonitorBlock,kMdBlockDcsChillerMonitor,kMdBlockSourceDcs);

ClassImp(RawDcsChillerMonitorBlock)

//_____________________________________________________________________________
RawDcsChillerMonitorBlock::RawDcsChillerMonitorBlock()
{
   // Default constructor
}

//_____________________________________________________________________________
RawDcsChillerMonitorBlock::RawDcsChillerMonitorBlock(const Int_t *block)
   : RawDataBlock(block)
{
   //  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)/4) = num blocks (test modulo for errors);
    *  Int_t d[n*4];  d = block+3;
    *  Int_t indx;
    *  d[(indx*4)+0] = timestamp (long sec)
    *  d[(indx*4)+1] = rackno (long)
    *  d[(indx*4)+2] = raw(long)
    *  d[(indx*4)+3] = status(signed long)
    *  indx++;(test if indx is greater than n, if so, finito)
        *                                          *
    */
}

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

//_____________________________________________________________________________
std::ostream& RawDcsChillerMonitorBlock::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 << "  [" << i << "]"
          << " Timestamp " << GetTimeStamp(i).AsString("c") << endl
          << "      ReturnWt         " << setw(15) << GetReturnWt(i)
          << "      DischargeFct     " << setw(15) << GetDischargeFct(i) << endl
          << "      ReturnCwt        " << setw(15) << GetReturnCwt(i)
          << "      DischargeCwt     " << setw(15) << GetDischargeCwt(i) << endl
          << "      StateFluidCooler " << setw(15) << GetStateFluidCooler(i)
          << "      StatePumpP4      " << setw(15) << GetStatePumpP4(i) << endl
          << "      StateChiller1    " << setw(15) << GetStateChiller1(i)
          << "      StateChiller2    " << setw(15) << GetStateChiller2(i) << endl
          << "      DetReturnCwt     " << setw(15) << GetDetReturnCwt(i)
          << "      DetSupplyCwt     " << setw(15) << GetDetSupplyCwt(i) << endl
          << "      StatePumpP5      " << setw(15) << GetStatePumpP5(i)
          << "      StateDetAlarm    " << setw(15) << GetStateDetAlarm(i) << endl
          << "      AhuS1RmTemp      " << setw(15) << GetAhuS1RmTemp(i)
          << "      Hx3ColdRetWt     " << setw(15) << GetHx3ColdRetWt(i) << endl
          << "      Hx3WarmDischWt   " << setw(15) << GetHx3WarmDischWt(i)
          << "      StatePumpP1      " << setw(15) << GetStatePumpP1(i) << endl
          << "      Fcu1RmTemp       " << setw(15) << GetFcu1RmTemp(i)
          << "      Fcu2RmTemp       " << setw(15) << GetFcu2RmTemp(i) << endl
          << "      S1RmTemp         " << setw(15) << GetS1RmTemp(i)
          << "      SurfaceTemp      " << setw(15) << GetSurfaceTemp(i) << endl;
    }
   return os;
}

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

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

Int_t RawDcsChillerMonitorBlock::GetNumEvents() const
{
        Int_t numEvents = 1;
        Int_t numEntries = GetNumEntries();
        FillChillerArray();

        //seek throughout for the number of events (not entries)
        //so look for entries where
        // FOR CHILLER THERE IS ONLY ONE EVENT PER BLOCK

        numEvents=numEntries;
        return numEvents;
}

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

Float_t RawDcsChillerMonitorBlock::GetReturnWt(Int_t indx) const
{
        FillChillerArray();
        Float_t fValue = 0.0;
        memcpy(&fValue,&ChillerArray[(indx*21)+1],4);
        return fValue;
}

Float_t RawDcsChillerMonitorBlock::GetDischargeFct(Int_t indx) const
{
        FillChillerArray();
        Float_t fValue = 0.0;
        memcpy(&fValue,&ChillerArray[(indx*21)+2],4);
        return fValue;
}

Float_t RawDcsChillerMonitorBlock::GetReturnCwt(Int_t indx) const
{
        FillChillerArray();
        Float_t fValue = 0.0;
        memcpy(&fValue,&ChillerArray[(indx*21)+3],4);
        return fValue;
}

Float_t RawDcsChillerMonitorBlock::GetDischargeCwt(Int_t indx) const
{
        FillChillerArray();
        Float_t fValue = 0.0;
        memcpy(&fValue,&ChillerArray[(indx*21)+4],4);
        return fValue;
}

Float_t RawDcsChillerMonitorBlock::GetDetReturnCwt(Int_t indx) const
{
        FillChillerArray();
        Float_t fValue = 0.0;
        memcpy(&fValue,&ChillerArray[(indx*21)+9],4);
        return fValue;
}

Float_t RawDcsChillerMonitorBlock::GetDetSupplyCwt(Int_t indx) const
{
        FillChillerArray();
        Float_t fValue = 0.0;
        memcpy(&fValue,&ChillerArray[(indx*21)+10],4);
        return fValue;
}

Float_t RawDcsChillerMonitorBlock::GetAhuS1RmTemp(Int_t indx) const
{
        FillChillerArray();
        Float_t fValue = 0.0;
        memcpy(&fValue,&ChillerArray[(indx*21)+13],4);
        return fValue;
}

Float_t RawDcsChillerMonitorBlock::GetHx3ColdRetWt(Int_t indx) const
{
        FillChillerArray();
        Float_t fValue = 0.0;
        memcpy(&fValue,&ChillerArray[(indx*21)+14],4);
        return fValue;
}

Float_t RawDcsChillerMonitorBlock::GetHx3WarmDischWt(Int_t indx) const
{
        FillChillerArray();
        Float_t fValue = 0.0;
        memcpy(&fValue,&ChillerArray[(indx*21)+15],4);
        return fValue;
}

Float_t RawDcsChillerMonitorBlock::GetFcu1RmTemp(Int_t indx) const
{
        FillChillerArray();
        Float_t fValue = 0.0;
        memcpy(&fValue,&ChillerArray[(indx*21)+17],4);
        return fValue;
}

Float_t RawDcsChillerMonitorBlock::GetFcu2RmTemp(Int_t indx) const
{
        FillChillerArray();
        Float_t fValue = 0.0;
        memcpy(&fValue,&ChillerArray[(indx*21)+18],4);
        return fValue;
}

Float_t RawDcsChillerMonitorBlock::GetS1RmTemp(Int_t indx) const
{
        FillChillerArray();
        Float_t fValue = 0.0;
        memcpy(&fValue,&ChillerArray[(indx*21)+19],4);
        return fValue;
}

Float_t RawDcsChillerMonitorBlock::GetSurfaceTemp(Int_t indx) const
{
        FillChillerArray();
        Float_t fValue = 0.0;
        memcpy(&fValue,&ChillerArray[(indx*21)+20],4);
        return fValue;
}

---