packet_gl1p.cc

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file packet_gl1p.cc

#include <packet_gl1p.h>
#include <string.h>

Packet_gl1p::Packet_gl1p(PACKET_ptr data)
  : Packet_w4(data)
{
  sgl1p=0;
}

Packet_gl1p::~Packet_gl1p()
{
  if(sgl1p)
    {
      delete [] sgl1p;
    }
}

int *Packet_gl1p::decode ( int *nwout)
{
  int *p,*k;
  int i, olength;
  int temp[MAX_OUTLENGTH];
  
  int dlength = getDataLength();

  int status = decode_gl1p( temp
            ,(int *)  findPacketDataStart(packet) 
            ,dlength
            ,MAX_OUTLENGTH, &olength);

  if (status || olength<=0 ) return NULL;
 
  p = new int[olength];
  k = p;
  for (i =0; i<olength; i++) *k++ = temp[i];
  *nwout = olength;
  return p;
}
int Packet_gl1p::iValue(const int ich, const int what)
{// int what is used hear instead of char* what to reduce data taking time. 
  if(!sgl1p) demangle();
  if(!sgl1p){
    COUT<<"Failed to fill data structure"<<std::endl;
    return 0;
  }
  switch (what)
    {
    case GL1P_HEADER:
      {
  if(ich<0 || ich>= nGL1Pboards) return 0;
  else return sgl1p[ich].header;
      }
    case GL1P_EVNUMBER:
      {
  if(ich<0 || ich>= nGL1Pboards) return 0;
  else return sgl1p[ich].ev_number;
      }
    case GL1P_MODEBIT:
      {
  if(ich<0 || ich>= nGL1Pboards) return 0;
  else return sgl1p[ich].modebit;
      }
    case GL1P_CLOCK:  
      {// it is supposed that the number of "clock counters" is 4*nGL1Pboards.
  //For example, to get Clock Counter for Scaler A of GL1P board 2 call iValue(5,GL1P_CLOCK)
  if(ich<0 || ich>= 4*nGL1Pboards) return -1;
  else return sgl1p[ich/4].clock[ich%4];
      }
    case GL1P_SCALER: 
      {//Scaler value. The same rule about ich as above.
  if(ich<0 || ich>= 4*nGL1Pboards) return 0;
  else return sgl1p[ich/4].scaler[ich%4];
      }
    default:
      return 0;
    }
}
int Packet_gl1p::iValue(const int ich, const char *what)
{

  
  if(!sgl1p) demangle();
  if(!sgl1p){
    COUT<<"Failed to fill data structure"<<std::endl;
    return 0;
  }

  if (!strcmp(what,"HEADER"))
    {
  if(ich<0 || ich>= nGL1Pboards) return 0;
  else return sgl1p[ich].header;
    }

  else if (!strcmp(what,"EVNUMBER"))
    {
  if(ich<0 || ich>= nGL1Pboards) return 0;
  else return sgl1p[ich].ev_number;
    }
  else if (!strcmp(what,"MODEBIT"))
    {
  if(ich<0 || ich>= nGL1Pboards) return 0;
  else return sgl1p[ich].modebit;
    }
  else if (!strcmp(what,"CLOCK"))
    {
  if(ich<0 || ich>= 4*nGL1Pboards) return -1;
  else return sgl1p[ich/4].clock[ich%4];
    }
  else if (!strcmp(what,"SCALER"))
    {
  if(ich<0 || ich>= 4*nGL1Pboards) return 0;
  else return sgl1p[ich/4].scaler[ich%4];
    }
  else return 0;

}
int Packet_gl1p::fillIntArray (int destination[],    // the data go here 
             const int length,      // space we have in destination
             int * nw,              // words actually used
             const char * what) // type of data (see above)
{
  int i;
  if(!sgl1p) demangle();
  if(!sgl1p){
    COUT<<"Failed to fill data structure"<<std::endl;
    return -1;
  }
  if (!strcmp(what,"CLOCK"))
    {
      if(length>4*nGL1Pboards)*nw=4*nGL1Pboards;
      else *nw=length;
      for(i=0;i<*nw;i++)
  destination[i]=sgl1p[i/4].clock[i%4];
    }
  else if (!strcmp(what,"SCALER"))
    {
      if(length>4*nGL1Pboards)*nw=4*nGL1Pboards;
      else *nw=length;
      for(i=0;i<*nw;i++)
  destination[i]=sgl1p[i/4].scaler[i%4];
    }
  else if (!strcmp(what,"HEADER"))
    {
      if(length>nGL1Pboards)*nw=nGL1Pboards;
      else *nw=length;
      for(i=0;i<*nw;i++)
  destination[i]=sgl1p[i].header;
    }
  else if (!strcmp(what,"EVNUMBER"))
    {
      if(length>nGL1Pboards)*nw=nGL1Pboards;
      else *nw=length;
      for(i=0;i<*nw;i++)
  destination[i]=sgl1p[i].ev_number;
    }
  else if (!strcmp(what,"MODEBIT"))
    {
      if(length>nGL1Pboards)*nw=nGL1Pboards;
      else *nw=length;
      for(i=0;i<*nw;i++)
  destination[i]=sgl1p[i].modebit;
    }
  else
    {
      *nw=0;
    }
  return 0;
}

void Packet_gl1p::dump ( OSTREAM &os)
{
  int i,j,l,m,dlength;
  dlength = getDataLength();

  this->identify(os); 
  if(!sgl1p) demangle();
  if(!sgl1p){
    os<<"Failed to fill sgl1p. Exit"<<std::endl;
    return;
  }

  for(m=0;m<54;m++) os<<"=";
  os << std::endl;
  os << "GL1P data packet: ";
  os << "Detected " << std::dec << nGL1Pboards << " GL1-1P boards in the data packet." <<std::endl;
  for(i=0;i<nGL1Pboards;i++){
    for(m=0;m<54;m++) os<<"-";
    COUT<<std::endl;
    os <<std::dec<<"GL1P["<<i<<"] header word    = 0x" << std::hex << SETW(4) << (unsigned int)sgl1p[i].header << std::endl;
    os <<std::dec<<"Event = " <<SETW(4)<<(unsigned int)sgl1p[i].ev_number<<std::endl;
    os <<"Modebit    = 0x" << std::hex << SETW(3) << sgl1p[i].modebit << std::endl;
    os << "Beam Cross. Counters: ";
    for(j=0;j<4;j++)
      os <<std::dec<<SETW(12)<<(unsigned int)sgl1p[i].clock[j];
    os<<std::endl;
    os << "Scalers             : ";
    for(j=0;j<4;j++)
      os<<SETW(12)<<sgl1p[i].scaler[j];
    os<<std::endl;
  }
  for(m=0;m<54;m++) os<<"-";
  // Raw data 
        j = 0;
  unsigned int* k=(unsigned int *) findPacketDataStart(packet);
  if (k == 0) 
    {
      os << std::endl;
      return;
    }

        while (1)
  {
    os << std::endl << std::dec << SETW(5) << j << " |  ";
    for (l=0;l<6;l++)
    {
        os << std::hex << SETW(8) << k[j++] << " ";
        if (j>=dlength) break;
    }
    if (j>=dlength) break;
  } 
        os << std::endl;
  for(m=0;m<54;m++) os<<"=";
        os << std::dec << std::endl;

}

void Packet_gl1p::demangle()
{
  int sclk[]={1,0,3,2};
  /* 
     The job of this routine is to demangle the data into something
     that can be more properly addressed - the data is copied
     into a GL1 data structure that can be addressed properly.
  */
  int dlength = getDataLength();
  nGL1Pboards=dlength/6;
  if(sgl1p) delete sgl1p;
  if(nGL1Pboards<1) {
    sgl1p=0;
    return;
  }
  sgl1p=new GL1P_DATA[nGL1Pboards];
  if(!sgl1p){
    COUT<<"can't allocate memory for GL1P_DATA structure "<<std::endl;
    return;
  }
  unsigned int* buf = (unsigned int *) findPacketDataStart(packet);
  if (buf == 0) 
    {
      delete [] sgl1p;
      sgl1p = NULL;
      return;
    }
  // unpack the data into a GL1 structure:


  unsigned int  j, idx, idy;
  unsigned char bclock;
  int i;

  for(i=0;i<nGL1Pboards;i++){
    idx=i*6;
    sgl1p[i].header    = (unsigned char)((buf[idx]>>8)&0xFF);
    sgl1p[i].ev_number = (unsigned char)(buf[idx]&0xFF);
    sgl1p[i].modebit   = (unsigned short)((buf[idx]>>16)&0x1FF);
      /* Note the complicated way in which the 20-bit LUT inputs are packed */
    for(j=0;j<4;j++){
      idy=j*8;
      bclock = (unsigned char)((buf[idx+1]>>idy)&0x7F);
      sgl1p[i].clock[sclk[j]] =(bclock&0xF) + ((bclock>>4)&0x7)*15;
      sgl1p[i].scaler[j] = ((buf[idx+2+j]&0xFFFF)<<16) + ((buf[idx+2+j]>>16)&0xFFFF);
    }

  }

}