RawDcsEnvMonitorBlock.cxx

Go to the documentation of this file.

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

#include "RawData/RawDcsEnvMonitorBlock.h"

UInt_t RawDcsEnvMonitorBlock::fgDebugFlags = 0;

#include "MessageService/MsgService.h"
CVSID("$Id: RawDcsEnvMonitorBlock.cxx,v 1.23 2009/02/28 21:46:16 gmieg Exp $");
#include "MessageService/MsgFormat.h"

#include "RawData/RawBlockRegistry.h"
REGISTERRAWBLOCK(RawDcsEnvMonitorBlock,kMdBlockDcsEnvMonitor,kMdBlockSourceDcs);

ClassImp(RawDcsEnvMonitorBlock)

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

//_____________________________________________________________________________
RawDcsEnvMonitorBlock::RawDcsEnvMonitorBlock()
  : EnvArray(0)
{
   // Default constructor
}

//_____________________________________________________________________________
RawDcsEnvMonitorBlock::RawDcsEnvMonitorBlock(const Int_t *block)
  : RawDataBlock(block), EnvArray(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)/8) = num blocks (test modulo for errors);
    *  Int_t d[n*8];  d = block+3;
    *  Int_t indx;
    *  d[(indx*8)+0] = timestamp (long sec)
    *  d[(indx*8)+1] = temp1
    *  d[(indx*8)+2] = hum1
    *  d[(indx*8)+3] = radon1
    *  d[(indx*8)+4] = pres     all these are floats
    *  d[(indx*8)+5] = temp2
    *  d[(indx*8)+6] = hum2
    *  d[(indx*8)+7] = radon2
    *  indx++;(test if indx is greater than n, if so, finito)
    */
}

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

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

        MsgFormat ffmt("%9.2f");
        Int_t numEntries=GetNumEntries();
        os << " Number of Entries " << numEntries
        << " Number of Events " << GetNumEvents() << endl;
        if (GetEnvDetector()==Detector::kNear)
        {
                Int_t iArray[56];
                Float_t fArray[56];
                for(Int_t i = 0; i < numEntries; i++)
                {
                  os << "Timestamp " << GetTimeStamp(i).AsString("c") << setw(5) 
                  << " Temperature " << ffmt(GetNearTemperature(i)) << " Humidity " 
                  << ffmt(GetNearHumid(i)) << " Radon  " << ffmt(GetNearRadonCounts(i)); 
                  os << " Pressure " << ffmt(GetNearPressure(i));
                  GetNearEnvThermArray(i,iArray);
                  for(Int_t k=0;k<56;k++)
                  {
                                fArray[k] = 0;
                                memcpy(&fArray[k],&iArray[k],4);
                  }
                  for(Int_t j = 0; j < 56; j++)
                  {
                                os << " Thermocouple " << j+1 << " "
                                << ffmt(fArray[j]);
                  }

                }
        }
        if (GetEnvDetector()==Detector::kFar)
        {
                for(Int_t i = 0; i < numEntries; i++)
                {
                  os << "Timestamp " << GetTimeStamp(i).AsString("c") << setw(5) 
                  << " Temperature 1 " << ffmt(GetFarTemperature1(i)) << " Humidity 1" 
                  << ffmt(GetFarHumid1(i)) << " Radon 1 " << ffmt(GetFarRadon1(i)) 
                  << " Pressure 1 " << ffmt(GetFarPressure1(i)) << " Temperature 2 " 
                  << ffmt(GetFarTemperature2(i)) << " Humidity 2 " << ffmt(GetFarHumid2(i) )
                  << " Radon 2 " << ffmt(GetFarRadon2(i));
                  if (GetMinorId()>=2)
                        os << " Pressure 2 " << ffmt(GetFarPressure2(i));
                  os << " Radon factor 1 " << ffmt(GetFarRadonFactor1(i)) << " radon factor 2 " << ffmt(GetFarRadonFactor2(i)) << endl;
                }
        }
        if(GetEnvDetector()==Detector::kCalDet)
        {
                Int_t iArray[32];
                Float_t fArray[32];
                for(Int_t i = 0; i < numEntries; i++)
                {
                        os << "Timestamp " << GetTimeStamp(i).AsString("c") << setw(5)
                        << " Temperature " << ffmt(GetCalTemperature(i)) << " Humidity "
                        << ffmt(GetCalHumid(i)) << " Pressure " << ffmt(GetCalPressure(i));
                        if(GetCalEnvIsTriggerEvent(i))
                        {
                                os << " Triggered event. Rate " << GetCalEnvTriggerRate(i);
                        }
                        GetCalEnvThermArray(i,iArray);
                        for(Int_t k=0;k<32;k++)
                        {
                                fArray[k] = 0;
                                memcpy(&fArray[k],&iArray[k],4);
                        }
                        for(Int_t j = 0; j < 32; j++)
                        {
                                os << " Thermocouple " << j+1 << " "
                                << ffmt(fArray[j]);
                        }
                        if (GetMinorId()>1)
                        {
                                os << " Cerenkov Pressure 1 " << ffmt(GetCalCerPressure1(i))
                                << " Cerenkov Pressure 2 " << ffmt(GetCalCerPressure2(i))
                                << " Cerenkov Pressure 3 " << ffmt(GetCalCerPressure1(i))
                                << " Cerenkov Pressure 4 " << ffmt(GetCalCerPressure1(i))
                                << " Cerenkov Pressure 5 " << ffmt(GetCalCerPressure1(i));
                        }
                        os << endl;
                }
        }
        return os;
}

VldTimeStamp RawDcsEnvMonitorBlock::GetTimeStamp(Int_t indx) const
{
        FillEnvArray();
        if(GetEnvDetector()==Detector::kCalDet)
        {
                if (GetMinorId()==1)
                        return VldTimeStamp(EnvArray[indx*38],0);
                if (GetMinorId()==2)
                        return VldTimeStamp(EnvArray[indx*43],0);
                if (GetMinorId()==3)
                        return VldTimeStamp(EnvArray[indx*51],0);
        }
        if (GetEnvDetector()==Detector::kFar)
        {
                if(GetMinorId()==1)
                        return VldTimeStamp(EnvArray[indx*8],0);
                if(GetMinorId()==2)
                        return VldTimeStamp(EnvArray[indx*9],0);
                if(GetMinorId()==3)
                        return VldTimeStamp(EnvArray[indx*11],0);
        }
        if (GetEnvDetector()==Detector::kNear)
        {
                return VldTimeStamp(EnvArray[indx*61],0);
        }
        return VldTimeStamp(EnvArray[0],0);
}

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

Int_t RawDcsEnvMonitorBlock::GetEnvDetector() const
{
        RawBlockId rbid = GetBlockId();
        return rbid.GetDetector();
}

Int_t RawDcsEnvMonitorBlock::GetNumEntries() const
{
        // remember, all versions
        // have offset of 3 due to first 3 longs)
        if (GetEnvDetector()==Detector::kCalDet)
        {
                if (GetMinorId()==1)
                {
                        if ((fSize-3)%38)
                        {
                                MSG("RawData",Msg::kError)
                                << " Size of Env Block screwed up.  Have: "
                                << (fSize-3)%38 << " left over from modulo 38. "
                                << endl;
                                return -1;
                        }
                        return ((fSize-3)/38);
                }
                if (GetMinorId()==2)
                {
                        if ((fSize-3)%43)
                        {
                                MSG("RawData",Msg::kError)
                                << " Size of Env Block screwed up.  Have: "
                                << (fSize-3)%43 << " left over from modulo 43. "
                                << endl;
                                return -1;
                        }
                        return ((fSize-3)/43);
                }
                if (GetMinorId()==3)
                {
                        if ((fSize-3)%51)
                        {
                                MSG("RawData",Msg::kError)
                                << " Size of Env Block screwed up.  Have: "
                                << (fSize-3)%43 << " left over from modulo 43. "
                                << endl;
                                return -1;
                        }
                        return ((fSize-3)/51);
                }
        }
        if (GetEnvDetector()==Detector::kFar)
        {
                if (GetMinorId()==1)
                {
                        if((fSize-3)%8)
                        {
                                MSG("RawData",Msg::kError)
                                << " Size of Env Block screwed up.  Have: "
                                << (fSize-3)%8 << " left over from modulo 8. "
                                << endl;
                                return -1;
                        }
                        return ((fSize-3)/8);
                }
                if (GetMinorId()==2)
                {
                        if((fSize-3)%9)
                        {
                                MSG("RawData",Msg::kError)
                                << " Size of Env Block screwed up.  Have: "
                                << (fSize-3)%9 << " left over from modulo 9. "
                                << endl;
                                return -1;
                        }
                        return ((fSize-3)/9);
                }
                if (GetMinorId()==3)
                {
                        if((fSize-3)%11)
                        {
                                MSG("RawData",Msg::kError)
                                << " Size of Env Block screwed up.  Have: "
                                << (fSize-3)%11 << " left over from modulo 11. "
                                << endl;
                                return -1;
                        }
                        return ((fSize-3)/11);
                }
        }
        if (GetEnvDetector()==Detector::kNear)
        {
                if((fSize-3)%61)
                {
                        MSG("RawData",Msg::kError)
                        << " Size of Env Block screwed up.  Have: "
                        << (fSize-3)%61 << " left over from modulo 61. "
                        << endl;
                        return -1;                        
                }
                return ((fSize-3)/61);
        }
        MSG("RawData",Msg::kError)
        << " Version number wrong/not implemented." << endl;
        return -1;
}

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

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

//_____________________________________________________________________________

Float_t RawDcsEnvMonitorBlock::GetFarTemperature1(Int_t indx) const
{
        FillEnvArray();
        Float_t fValue=0.0;
        if (GetEnvDetector()==Detector::kCalDet)
        {
                if (GetMinorId()==1)
                        memcpy(&fValue,&EnvArray[(indx*38)+3],4);
                if (GetMinorId()==2)
                        memcpy(&fValue,&EnvArray[(indx*43)+3],4);
                if (GetMinorId()==3)
                        memcpy(&fValue, &EnvArray[(indx*51)+3],4);
                return fValue;
        }
        if (GetEnvDetector()==Detector::kFar)
        {
                if (GetMinorId()==1)
                        memcpy(&fValue,&EnvArray[(indx*8)+1],4);
                if (GetMinorId()==2)
                        memcpy(&fValue,&EnvArray[(indx*9)+1],4);
                if (GetMinorId()==3)
                        memcpy(&fValue,&EnvArray[(indx*11)+1],4);
                return fValue;
        }
        return 0;
}

Float_t RawDcsEnvMonitorBlock::GetCalTemperature(Int_t indx) const
{
        return GetFarTemperature1(indx);
}

Float_t RawDcsEnvMonitorBlock::GetFarHumid1(Int_t indx) const
{
        FillEnvArray();
        Float_t fValue=0.0;
        if (GetEnvDetector()==Detector::kCalDet)
        {
                if (GetMinorId()==1)
                        memcpy(&fValue,&EnvArray[(indx*38)+4],4);
                if (GetMinorId()==2)
                        memcpy(&fValue,&EnvArray[(indx*43)+4],4);
                if (GetMinorId()==3)
                        memcpy(&fValue, &EnvArray[(indx*51)+4],4);
                return fValue;
        }
        if (GetEnvDetector()==Detector::kFar)
        {
                if (GetMinorId()==1)
                        memcpy(&fValue,&EnvArray[(indx*8)+2],4);
                if (GetMinorId()==2)
                        memcpy(&fValue,&EnvArray[(indx*9)+2],4);
                if (GetMinorId()==3)
                        memcpy(&fValue,&EnvArray[(indx*11)+2],4);
                return fValue;
        }
        return 0;
}

Float_t RawDcsEnvMonitorBlock::GetCalHumid(Int_t indx) const
{
        return GetFarHumid1(indx);
}

Float_t RawDcsEnvMonitorBlock::GetFarRadon1(Int_t indx) const
{
        FillEnvArray();
        Float_t fValue=0.0;
        if (GetEnvDetector()==Detector::kCalDet)
        {
                return fValue;
        }
        if (GetEnvDetector()==Detector::kFar)
        {
                if (GetMinorId()==1)
                        memcpy(&fValue,&EnvArray[(indx*8)+3],4);
                if (GetMinorId()==2)
                        memcpy(&fValue,&EnvArray[(indx*9)+3],4);
                if (GetMinorId()==3)
                        memcpy(&fValue,&EnvArray[(indx*11)+3],4);
        }
        return fValue;
}

Float_t RawDcsEnvMonitorBlock::GetFarPressure1(Int_t indx) const
{
        FillEnvArray();
        Float_t fValue=0.0;
        if (GetEnvDetector()==Detector::kCalDet)
        {
                if (GetMinorId()==1)
                        memcpy(&fValue,&EnvArray[(indx*38)+5],4);
                if (GetMinorId()==2)
                        memcpy(&fValue,&EnvArray[(indx*43)+5],4);
                if (GetMinorId()==3)
                        memcpy(&fValue, &EnvArray[(indx*51)+5],4);
                return fValue;
        }
        if (GetEnvDetector()==Detector::kFar)
        {
                if (GetMinorId()==1)
                        memcpy(&fValue,&EnvArray[(indx*8)+4],4);
                if (GetMinorId()==2)
                        memcpy(&fValue,&EnvArray[(indx*9)+4],4);
                if (GetMinorId()==3)
                        memcpy(&fValue,&EnvArray[(indx*11)+4],4);
                return fValue;
        }
        return fValue;
}

Float_t RawDcsEnvMonitorBlock::GetCalPressure(Int_t indx) const
{
        return GetFarPressure1(indx);
}

Float_t RawDcsEnvMonitorBlock::GetFarTemperature2(Int_t indx) const
{
        FillEnvArray();
        Float_t fValue=0.0;
        if (GetEnvDetector()==Detector::kCalDet)
        {
                return fValue;
        }
        if (GetEnvDetector()==Detector::kFar)
        {
                if (GetMinorId()==1)
                        memcpy(&fValue,&EnvArray[(indx*8)+5],4);
                if (GetMinorId()==2)
                        memcpy(&fValue,&EnvArray[(indx*9)+5],4);
                if (GetMinorId()==3)
                        memcpy(&fValue,&EnvArray[(indx*11)+5],4);
        }
        return fValue;
}

Float_t RawDcsEnvMonitorBlock::GetFarHumid2(Int_t indx) const
{
        FillEnvArray();
        Float_t fValue=0.0;
        if (GetEnvDetector()==Detector::kCalDet)
        {
                return fValue;
        }
        if (GetEnvDetector()==Detector::kFar)
        {
                if (GetMinorId()==1)
                        memcpy(&fValue,&EnvArray[(indx*8)+6],4);
                if (GetMinorId()==2)
                        memcpy(&fValue,&EnvArray[(indx*9)+6],4);
                if (GetMinorId()==3)
                        memcpy(&fValue,&EnvArray[(indx*11)+6],4);
        }
        return fValue;
}

Float_t RawDcsEnvMonitorBlock::GetFarRadon2(Int_t indx) const
{
        FillEnvArray();
        Float_t fValue=0.0;
        if (GetEnvDetector()==Detector::kCalDet)
        {
                return fValue;
        }
        if (GetEnvDetector()==Detector::kFar)
        {
                if (GetMinorId()==1)
                        memcpy(&fValue,&EnvArray[(indx*8)+7],4);
                if (GetMinorId()==2)
                        memcpy(&fValue,&EnvArray[(indx*9)+7],4);
                if (GetMinorId()==3)
                        memcpy(&fValue,&EnvArray[(indx*11)+7],4);
        }
        return fValue;
}

Float_t RawDcsEnvMonitorBlock::GetFarPressure2(Int_t indx) const
{
        if ( (GetMinorId()==1) || (GetEnvDetector()==Detector::kCalDet) )
                return 0.0;
        FillEnvArray();
        Float_t fValue=0.0;
        if (GetEnvDetector()==Detector::kFar)
                memcpy(&fValue,&EnvArray[(indx*9)+8],4);
        if (GetMinorId()==3)
                memcpy(&fValue,&EnvArray[(indx*11)+8],4);
        return fValue;
}

Float_t RawDcsEnvMonitorBlock::GetFarRadonFactor1(Int_t indx) const
{
        if ( (GetMinorId()<3) || (GetEnvDetector()==Detector::kCalDet) )
                return 0.0;
        FillEnvArray();
        Float_t fValue=0.0;
        memcpy(&fValue,&EnvArray[(indx*11)+9],4);
        return fValue;
}

Float_t RawDcsEnvMonitorBlock::GetFarRadonFactor2(Int_t indx) const
{
        if ( (GetMinorId()<3) || (GetEnvDetector()==Detector::kCalDet) )
                return 0.0;
        FillEnvArray();
        Float_t fValue=0.0;
        memcpy(&fValue,&EnvArray[(indx*11)+10],4);
        return fValue;
}

void RawDcsEnvMonitorBlock::GetCalEnvThermArray(Int_t indx, Int_t iArray[30]) const
{
        FillEnvArray();
        if (GetEnvDetector()!=Detector::kCalDet)
                return;
        if (GetMinorId()==1)
        {
                for (Int_t i=0; i < 32; i++)
                {
                        iArray[i] = EnvArray[(indx*38)+i+6];
                }
        }
        if (GetMinorId()==2)
        {
                for (Int_t i=0; i < 32; i++)
                {
                        iArray[i] = EnvArray[(indx*43)+i+6];
                }
        }
        if (GetMinorId()==3)
        {
                for (Int_t i=0;i<32;i++)
                {
                        iArray[i]=EnvArray[(indx*51)+i+6];
                }
        }
}

Int_t RawDcsEnvMonitorBlock::GetCalEnvTriggerRate(Int_t indx) const
{
        if (GetEnvDetector()!=Detector::kCalDet)
                return 0;
        FillEnvArray();
        if (GetMinorId()==1)
                return EnvArray[(indx*38)+1];
        if (GetMinorId()==2)
                return EnvArray[(indx*43)+1];
        if (GetMinorId()==3)
                return EnvArray[(indx*51)+1];
        return 0;
}

Int_t RawDcsEnvMonitorBlock::GetCalEnvIsTriggerEvent(Int_t indx) const
{
        if (GetEnvDetector()!=Detector::kCalDet)
                return 0;
        FillEnvArray();
        if (GetMinorId()==1)
                return EnvArray[(indx*38)+2];
        if (GetMinorId()==2)
                return EnvArray[(indx*43)+2];
        if (GetMinorId()==3)
                return EnvArray[(indx*51)+2];
        return 0;
}

Float_t RawDcsEnvMonitorBlock::GetCalCerPressure1(Int_t indx) const
{
        if (GetEnvDetector()!=Detector::kCalDet)
                return 0.0;
        FillEnvArray();
        Float_t fValue=0.0;
        if (GetMinorId()==1)
                return fValue;
        if (GetMinorId()==2)
                memcpy(&fValue,&EnvArray[(indx*43)+38],4);
        if (GetMinorId()==3)
                memcpy(&fValue,&EnvArray[(indx*51)+38],4);
        return fValue;;
}

Float_t RawDcsEnvMonitorBlock::GetCalCerPressure2(Int_t indx) const
{
        if (GetEnvDetector()!=Detector::kCalDet)
                return 0.0;
        FillEnvArray();
        Float_t fValue=0.0;
        if (GetMinorId()==1)
                return 0.0;
        if (GetMinorId()==2)
                memcpy(&fValue,&EnvArray[(indx*43)+39],4);
        if (GetMinorId()==3)
                memcpy(&fValue,&EnvArray[(indx*51)+39],4);
        return fValue;
}

Float_t RawDcsEnvMonitorBlock::GetCalCerPressure3(Int_t indx) const
{
        if (GetEnvDetector()!=Detector::kCalDet)
                return 0;
        FillEnvArray();
        Float_t fValue=0.0;
        if (GetMinorId()==1)
                return 0;
        if (GetMinorId()==2)
                memcpy(&fValue,&EnvArray[(indx*43)+40],4);
        if (GetMinorId()==3)
                memcpy(&fValue,&EnvArray[(indx*51)+40],4);
        return fValue;
}

Float_t RawDcsEnvMonitorBlock::GetCalCerPressure4(Int_t indx) const
{
        if (GetEnvDetector()!=Detector::kCalDet)
                return 0;
        FillEnvArray();
        Float_t fValue=0.0;
        if (GetMinorId()==1)
                return 0;
        if (GetMinorId()==2)
                memcpy(&fValue,&EnvArray[(indx*43)+41],4);
        if (GetMinorId()==3)
                memcpy(&fValue,&EnvArray[(indx*51)+41],4);
        return fValue;
}

Float_t RawDcsEnvMonitorBlock::GetCalCerPressure5(Int_t indx) const
{
        if (GetEnvDetector()!=Detector::kCalDet)
                return 0;
        FillEnvArray();
        Float_t fValue=0.0;
        if (GetMinorId()==1)
                return 0;
        if (GetMinorId()==2)
                memcpy(&fValue,&EnvArray[(indx*43)+42],4);
        if (GetMinorId()==3)
                memcpy(&fValue,&EnvArray[(indx*51)+42],4);
        return fValue;
}

Int_t RawDcsEnvMonitorBlock::GetCalCounter1(Int_t indx) const
{
        if (GetEnvDetector()!=Detector::kCalDet)
                return 0;
        FillEnvArray();
        if (GetMinorId()<3)
                return 0;
        return EnvArray[(indx*51)+43];
}

Int_t RawDcsEnvMonitorBlock::GetCalCounter2(Int_t indx) const
{
        if (GetEnvDetector()!=Detector::kCalDet)
                return 0;
        FillEnvArray();
        if (GetMinorId()<3)
                return 0;
        return EnvArray[(indx*51)+44];
}

Int_t RawDcsEnvMonitorBlock::GetCalCounter3(Int_t indx) const
{
        if (GetEnvDetector()!=Detector::kCalDet)
                return 0;
        FillEnvArray();
        if (GetMinorId()<3)
                return 0;
        return EnvArray[(indx*51)+45];
}

Int_t RawDcsEnvMonitorBlock::GetCalCounter4(Int_t indx) const
{
        if (GetEnvDetector()!=Detector::kCalDet)
                return 0;
        FillEnvArray();
        if (GetMinorId()<3)
                return 0;
        return EnvArray[(indx*51)+46];
}

Int_t RawDcsEnvMonitorBlock::GetCalCounter5(Int_t indx) const
{
        if (GetEnvDetector()!=Detector::kCalDet)
                return 0;
        FillEnvArray();
        if (GetMinorId()<3)
                return 0;
        return EnvArray[(indx*51)+47];
}

Int_t RawDcsEnvMonitorBlock::GetCalCounter6(Int_t indx) const
{
        if (GetEnvDetector()!=Detector::kCalDet)
                return 0;
        FillEnvArray();
        if (GetMinorId()<3)
                return 0;
        return EnvArray[(indx*51)+48];
}

Int_t RawDcsEnvMonitorBlock::GetCalCounter7(Int_t indx) const
{
        if (GetEnvDetector()!=Detector::kCalDet)
                return 0;
        FillEnvArray();
        if (GetMinorId()<3)
                return 0;
        return EnvArray[(indx*51)+49];
}

Int_t RawDcsEnvMonitorBlock::GetCalCounter8(Int_t indx) const
{
        if (GetEnvDetector()!=Detector::kCalDet)
                return 0;
        FillEnvArray();
        if (GetMinorId()<3)
                return 0;
        return EnvArray[(indx*51)+50];
}

Float_t RawDcsEnvMonitorBlock::GetNearTemperature(Int_t indx) const
{
        FillEnvArray();
        if (GetEnvDetector()!=Detector::kNear)
                return 0.0;
        Float_t fValue=0.0;
        memcpy(&fValue,&EnvArray[(indx*61)+1],4);
        return fValue;
}

Float_t RawDcsEnvMonitorBlock::GetNearHumid(Int_t indx) const
{
        FillEnvArray();
        if (GetEnvDetector()!=Detector::kNear)
                return 0.0;
        Float_t fValue=0.0;
        memcpy(&fValue,&EnvArray[(indx*61)+2],4);
        return fValue;
}

Float_t RawDcsEnvMonitorBlock::GetNearPressure(Int_t indx) const
{
        FillEnvArray();
        if (GetEnvDetector()!=Detector::kNear)
                return 0.0;
        Float_t fValue=0.0;
        memcpy(&fValue,&EnvArray[(indx*61)+3],4);
        return fValue;
}

Int_t RawDcsEnvMonitorBlock::GetNearRadonCounts(Int_t indx) const
{
        FillEnvArray();
        if (GetEnvDetector()!=Detector::kNear)
                return 0;
        return EnvArray[(indx*61)+4];
}

void RawDcsEnvMonitorBlock::GetNearEnvThermArray(Int_t indx, Int_t iArray[56]) const
{
        FillEnvArray();
        if (GetEnvDetector()!=Detector::kNear)
                return;
        for (Int_t i=0;i<56;i++)
        {
                iArray[i]=EnvArray[(indx*61)+i+5];
        }
}

---