Back to home page

sPhenix code displayed by LXR
 
 

    

File indexing completed on 2025-08-03 08:20:40 

0001 #include <packet_gl1.h>
0002 #include <string.h>
0003 
0004 Packet_gl1::Packet_gl1(PACKET_ptr data)
0005   : Packet_w4 (data){sgl1=0;}
0006 
0007 Packet_gl1::~Packet_gl1()
0008 {
0009   if(sgl1)delete sgl1;
0010 }
0011 
0012 int *Packet_gl1::decode ( int *nwout)
0013 {
0014   int *p,*k;
0015   int olength;
0016   int temp[MAX_OUTLENGTH];
0017   int i;
0018   int dlength = getDataLength();
0019 
0020   int status = decode_gl1( temp
0021                   ,(int *)  findPacketDataStart(packet) 
0022                   ,dlength
0023                   ,MAX_OUTLENGTH, &olength);
0024 
0025   if (status || olength<=0 ) return NULL;
0026  
0027   p = new int[olength];
0028   k = p;
0029   for (i =0; i<olength; i++) *k++ = temp[i];
0030   *nwout = olength;
0031   return p;
0032 }
0033 
0034 int Packet_gl1::iValue(const int ich, const char *what)
0035 {
0036 
0037   
0038   if(!sgl1) demangle();
0039   if(!sgl1){
0040     COUT<<"Failed to fill data structure"<<std::endl;
0041     return 0;
0042   }
0043   // GL1-3
0044   if (strcmp(what,"HEADER3")==0)
0045     {
0046       return sgl1->gl3_payload.gl3_header;
0047     }
0048   /* return time */
0049   else if ( strcmp(what,"YEAR")==0)
0050     {
0051       return sgl1->gl3_payload.timestamp.year;
0052     }
0053   else if ( strcmp(what,"MONTH")==0)
0054     {
0055       return sgl1->gl3_payload.timestamp.month;
0056     }
0057   else if ( strcmp(what,"DATE")==0)
0058     {
0059       return sgl1->gl3_payload.timestamp.date;
0060     }
0061   else if ( strcmp(what,"DAY")==0)
0062     {
0063       return sgl1->gl3_payload.timestamp.day;
0064     }
0065   else if ( strcmp(what,"HOUR")==0)
0066     {
0067       return sgl1->gl3_payload.timestamp.hour;
0068     }
0069   else if ( strcmp(what,"MIN")==0)
0070     {
0071       return sgl1->gl3_payload.timestamp.min;
0072     }
0073   else if ( strcmp(what,"SEC")==0)
0074     {
0075       return sgl1->gl3_payload.timestamp.sec;
0076     }
0077 
0078   else if (strcmp(what,"ALIGNMENT")==0)
0079     {
0080       return sgl1->gl3_payload.alignment;
0081     }
0082   else if ( strcmp(what,"CROSSCTR")==0)
0083     {
0084       return sgl1->gl3_payload.bunch_crossing_counter;
0085     }
0086   else if ( strcmp(what,"BEAMCTR0")==0)
0087     {
0088       return sgl1->gl3_payload.beam_crossing_counter[0];
0089     }
0090   else if ( strcmp(what,"BEAMCTR1")==0)
0091     {
0092       return sgl1->gl3_payload.beam_crossing_counter[1];
0093     }
0094   else if ( strcmp(what,"GACCEPT")==0)
0095     {
0096       return sgl1->gl3_payload.granule_accept_vector;
0097     }
0098   else if (strcmp(what,"ACPTORINP")==0)
0099     {
0100       return sgl1->gl3_payload.accept_or_input;
0101     }
0102   else if ( strcmp(what,"ACPTCTR")==0)
0103     {
0104       return sgl1->gl3_payload.gl1_accept_counter;
0105     }
0106   else if ( strcmp(what,"GRANCTR")==0)
0107     {
0108       if( (ich<0) || (ich>31) ) {
0109     return 0;
0110       }
0111       else{
0112     return sgl1->gl3_payload.granule_accept[ich];
0113       }
0114     }
0115   else if ( strcmp(what,"GDISABLE")==0)
0116     {
0117       return sgl1->gl3_payload.granule_disables;
0118     }
0119  else if ( strcmp(what,"FACCEPT")==0)
0120     {
0121       return sgl1->gl3_payload.forced_accepts;
0122     }
0123   // GL1-2 
0124   else if (strcmp(what,"HEADER2")==0)
0125     {
0126       return sgl1->gl2_payload.gl2_header;
0127     }
0128   else if ( strcmp(what,"PACCEPT")==0)
0129     {
0130       return sgl1->gl2_payload.partition_accept;
0131     }
0132   else if (strcmp(what,"MODEBITS")==0)
0133     {
0134       return sgl1->gl2_payload.mode_bits;
0135     }
0136   else if ( strcmp(what,"RBITS0")==0)
0137     {
0138       return sgl1->gl2_payload.reduced_bits[0];
0139     }
0140   else if ( strcmp(what,"RBITS1")==0)
0141     {
0142       return sgl1->gl2_payload.reduced_bits[1];
0143     }
0144   else if ( strcmp(what,"DCMFULL")==0)
0145     {
0146       return sgl1->gl2_payload.dcm_full_fem_busy;
0147     }
0148   else if ( strcmp(what,"FEMUNREL")==0)
0149     {
0150       return sgl1->gl2_payload.fem_unreliable;
0151     }
0152   else if ( strcmp(what,"GBUSY")==0)
0153     {
0154       return sgl1->gl2_payload.granule_busy;
0155     }
0156   else if ( strcmp(what,"PXBAR")==0)
0157     {
0158       return sgl1->gl2_payload.part_busy_xbar_out;
0159     }
0160   else if ( strcmp(what,"PBUSY")==0)
0161     {
0162       return sgl1->gl2_payload.part_busy_bus;
0163     }
0164 
0165   // GL1-1
0166   else if (strcmp(what,"HEADER1")==0)
0167     {
0168       if( (ich<0) || (ich>=sgl1->gl1_boards) ) {
0169     return 0;
0170       }
0171       else{
0172     return sgl1->gl1_payload[ich].gl1_header;
0173       }
0174     }
0175   else if ( strcmp(what,"LUTINPUT")==0)
0176     {// it is supposed that lut input is defined as: ich= i*8+lutinput,
0177       // were i is GL1-1 board number
0178       if( (ich<0) || (ich>=8*sgl1->gl1_boards) ) {
0179     return 0;
0180       }
0181       else{
0182         return sgl1->gl1_payload[ich/8].lut_input[ich%8];
0183       }
0184     }
0185   else if ( strcmp(what,"RAWTRIG")==0)
0186     {
0187       if( (ich<0) || (ich>=sgl1->gl1_boards) ) {
0188     return 0;
0189       }
0190       else{
0191         return sgl1->gl1_payload[ich].lut_output;
0192       }
0193     }
0194   else if ( strcmp(what,"TRIGBUSY")==0)
0195     {
0196       if( (ich<0) || (ich>=sgl1->gl1_boards) ) {
0197     return 0;
0198       }
0199       else{
0200         return sgl1->gl1_payload[ich].trigger_busy;
0201       }
0202     }
0203   else if ( strcmp(what,"LIVETRIG")==0)
0204     {
0205       if( (ich<0) || (ich>=sgl1->gl1_boards) ) {
0206     return 0;
0207       }
0208       else{
0209         return sgl1->gl1_payload[ich].live_trig_out;
0210       }
0211     }
0212   else if ( strcmp(what,"SCALEDTRIG")==0)
0213     {
0214       if( (ich<0) || (ich>=sgl1->gl1_boards) ) {
0215     return 0;
0216       }
0217       else{
0218         return sgl1->gl1_payload[ich].scaled_trig_out;
0219       }
0220     }
0221   else if ( strcmp(what,"TRIGPARXBAR")==0)
0222     {
0223       if( (ich<0) || (ich>=sgl1->gl1_boards) ) {
0224     return 0;
0225       }
0226       else{
0227         return sgl1->gl1_payload[ich].trig_part_xbar_out;
0228       }
0229     }
0230 
0231 
0232   else return 0;
0233 
0234 }
0235 int Packet_gl1::iValue(const int ich, const  int what)
0236 {
0237 
0238   
0239   if(!sgl1) demangle();
0240   if(!sgl1){
0241     std::cout<<"Failed to fill data structure"<<std::endl;
0242     return 0;
0243   }
0244   switch (what) {
0245   // GL1-3
0246   case HEADER3:
0247     {
0248       return sgl1->gl3_payload.gl3_header;
0249     }
0250   /* return time */
0251   case YEAR:
0252     {
0253       return sgl1->gl3_payload.timestamp.year;
0254     }
0255   case MONTH:
0256     {
0257       return sgl1->gl3_payload.timestamp.month;
0258     }
0259   case DATE:
0260     {
0261       return sgl1->gl3_payload.timestamp.date;
0262     }
0263   case DAY:
0264     {
0265       return sgl1->gl3_payload.timestamp.day;
0266     }
0267   case HOUR:
0268     {
0269       return sgl1->gl3_payload.timestamp.hour;
0270     }
0271   case MIN:
0272     {
0273       return sgl1->gl3_payload.timestamp.min;
0274     }
0275   case SECGL1:
0276     {
0277       return sgl1->gl3_payload.timestamp.sec;
0278     }
0279 
0280   case ALIGNMENT:
0281     {
0282       return sgl1->gl3_payload.alignment;
0283     }
0284   case CROSSCTR:
0285     {
0286       return sgl1->gl3_payload.bunch_crossing_counter;
0287     }
0288   case BEAMCTR0:
0289     {
0290       return sgl1->gl3_payload.beam_crossing_counter[0];
0291     }
0292   case BEAMCTR1:
0293     {
0294       return sgl1->gl3_payload.beam_crossing_counter[1];
0295     }
0296   case GACCEPT:
0297     {
0298       return sgl1->gl3_payload.granule_accept_vector;
0299     }
0300   case ACPTORINP:
0301     {
0302       return sgl1->gl3_payload.accept_or_input;
0303     }
0304   case ACPTCTR:
0305     {
0306       return sgl1->gl3_payload.gl1_accept_counter;
0307     }
0308   case GRANCTR:
0309     {
0310       if( (ich<0) || (ich>31) ) {
0311     return 0;
0312       }
0313       else{
0314     return sgl1->gl3_payload.granule_accept[ich];
0315       }
0316     }
0317   case GDISABLE:
0318     {
0319       return sgl1->gl3_payload.granule_disables;
0320     }
0321  case FACCEPT:
0322     {
0323       return sgl1->gl3_payload.forced_accepts;
0324     }
0325   // GL1-2 
0326   case HEADER2:
0327     {
0328       return sgl1->gl2_payload.gl2_header;
0329     }
0330   case PACCEPT:
0331     {
0332       return sgl1->gl2_payload.partition_accept;
0333     }
0334   case MODEBITS:
0335     {
0336       return sgl1->gl2_payload.mode_bits;
0337     }
0338   case RBITS0:
0339     {
0340       return sgl1->gl2_payload.reduced_bits[0];
0341     }
0342   case RBITS1:
0343     {
0344       return sgl1->gl2_payload.reduced_bits[1];
0345     }
0346   case DCMFULL:
0347     {
0348       return sgl1->gl2_payload.dcm_full_fem_busy;
0349     }
0350   case FEMUNREL:
0351     {
0352       return sgl1->gl2_payload.fem_unreliable;
0353     }
0354   case GBUSY:
0355     {
0356       return sgl1->gl2_payload.granule_busy;
0357     }
0358   case PXBAR:
0359     {
0360       return sgl1->gl2_payload.part_busy_xbar_out;
0361     }
0362   case PBUSY:
0363     {
0364       return sgl1->gl2_payload.part_busy_bus;
0365     }
0366 
0367   // GL1-1
0368   case HEADER1:
0369     {
0370       if( (ich<0) || (ich>=sgl1->gl1_boards) ) {
0371     return 0;
0372       }
0373       else{
0374     return sgl1->gl1_payload[ich].gl1_header;
0375       }
0376     }
0377   case LUTINPUT:
0378     {// it is supposed that lut input is defined as: ich= i*8+lutinput,
0379       // were i is GL1-1 board number
0380       if( (ich<0) || (ich>=8*sgl1->gl1_boards) ) {
0381     return 0;
0382       }
0383       else{
0384         return sgl1->gl1_payload[ich/8].lut_input[ich%8];
0385       }
0386     }
0387   case RAWTRIG:
0388     {
0389       if( (ich<0) || (ich>=sgl1->gl1_boards) ) {
0390     return 0;
0391       }
0392       else{
0393         return sgl1->gl1_payload[ich].lut_output;
0394       }
0395     }
0396   case TRIGBUSY:
0397     {
0398       if( (ich<0) || (ich>=sgl1->gl1_boards) ) {
0399     return 0;
0400       }
0401       else{
0402         return sgl1->gl1_payload[ich].trigger_busy;
0403       }
0404     }
0405   case LIVETRIG:
0406     {
0407       if( (ich<0) || (ich>=sgl1->gl1_boards) ) {
0408     return 0;
0409       }
0410       else{
0411         return sgl1->gl1_payload[ich].live_trig_out;
0412       }
0413     }
0414   case SCALEDTRIG:
0415     {
0416       if( (ich<0) || (ich>=sgl1->gl1_boards) ) {
0417     return 0;
0418       }
0419       else{
0420         return sgl1->gl1_payload[ich].scaled_trig_out;
0421       }
0422     }
0423   case TRIGPARXBAR:
0424     {
0425       if( (ich<0) || (ich>=sgl1->gl1_boards) ) {
0426     return 0;
0427       }
0428       else{
0429         return sgl1->gl1_payload[ich].trig_part_xbar_out;
0430       }
0431     }
0432   default:
0433     {
0434       return 0;
0435     }
0436   }
0437 
0438   return 0;
0439 
0440 }
0441 
0442 void Packet_gl1::dump ( OSTREAM &os)
0443 {
0444   int i,j,l,m,dlength;
0445   dlength = getDataLength();
0446 
0447     this->identify(os); 
0448     if(!sgl1) demangle();
0449     if(!sgl1){
0450       os<<"Failed to fill sgl1. Exit"<<std::endl;
0451       return;
0452     }
0453 
0454     // output some useful information:
0455     const char* days[]={
0456       "Non",
0457       "Sun",
0458       "Mon",
0459       "Tue",
0460       "Wed",
0461       "Thu",
0462       "Fri",
0463       "Sat"
0464     };
0465     std::ios::fmtflags oldFlags = os.flags();
0466     char oldFill;
0467     oldFill=os.fill('0');
0468     for(m=0;m<54;m++) os<<"=";
0469     os << std::endl;
0470     os << "GL1 data packet:" << std::endl;
0471     os << "Detected " << std::dec << sgl1->gl1_boards << " GL1-1 boards in the data packet." <<std::endl;
0472         os << "--> GL1-3 <--"<<std::endl;
0473     os << "GL1-3 header word    = 0x" << std::hex << SETW(4) << sgl1->gl3_payload.gl3_header << std::endl;
0474     os << "Time: " <<std::dec<<SETW(2)<<(sgl1->gl3_payload.timestamp.hour)<<":"<<SETW(2)<<(sgl1->gl3_payload.timestamp.min)<<":"
0475        <<SETW(2)<<(sgl1->gl3_payload.timestamp.sec)<<" "<<SETW(2)<<days[(sgl1->gl3_payload.timestamp.day)]
0476        <<", "<<(sgl1->gl3_payload.timestamp.month)<<"/"<<SETW(2)<<(sgl1->gl3_payload.timestamp.date)<<"/"
0477        <<SETW(4)<<(sgl1->gl3_payload.timestamp.year)<<std::endl;
0478     os <<"Alignment = 0x"<<std::hex<<SETW(4)<<sgl1->gl3_payload.alignment<<std::endl;
0479         os << "Beam Cross. Counter  = 0x" << SETW(8) 
0480        << sgl1->gl3_payload.beam_crossing_counter[1];
0481     os << SETW(8)
0482        << sgl1->gl3_payload.beam_crossing_counter[0] << std::endl;
0483     os << "Bunch Cross. Counter = 0x" << SETW(4) << sgl1->gl3_payload.bunch_crossing_counter << std::endl;
0484     os << "Granule Accept Vector    = 0x" << SETW(8) << sgl1->gl3_payload.granule_accept_vector << std::endl;
0485     os << "Accept OR input          = 0x" << SETW(8) << sgl1->gl3_payload.accept_or_input << std::endl;
0486 //  os.flags(std::ios::right|(oldFlags^std::ios::left));
0487 //  os.fill(' ');
0488     os << "Accept Counter       = " << sgl1->gl3_payload.gl1_accept_counter << std::endl;
0489     os << "Granule Accept Counters:"<< std::endl;
0490 
0491     for(i=3;i>=0;i--)
0492       {
0493         for(j=7;j>=0;j--)
0494           {
0495         l=i*8+j;
0496         if(l<10) os <<" ["<< std::dec<<SETW(1)<<l<<"]=0x"<<std::hex<<SETW(4)<<sgl1->gl3_payload.granule_accept[l]<<" ";
0497         else os <<"["<< std::dec<<SETW(2)<<l<<"]=0x"<<std::hex<<SETW(4)<<sgl1->gl3_payload.granule_accept[l]<<" ";
0498           }
0499         os<<std::endl;
0500       }
0501     os.flags(oldFlags);
0502     os.fill('0');
0503     os << "Granule Disables         = 0x" << std::hex << SETW(8) << sgl1->gl3_payload.granule_disables << std::endl;
0504     os << "Forced Accepts           = 0x" << SETW(8) << sgl1->gl3_payload.forced_accepts << std::endl;
0505     os << "--> GL1-2 <--"<<std::endl;
0506     os << "GL1-2 header word    = 0x" << SETW(4) << sgl1->gl2_payload.gl2_header << std::endl;
0507     os << "Partition Accept Vector  = 0x" << SETW(8) << sgl1->gl2_payload.partition_accept << std::endl;
0508     os << "Mode bits = 0x"<< SETW(4) << sgl1->gl2_payload.mode_bits << std::endl;
0509     os << "Reduced bits             = 0x" << SETW(8)<<sgl1->gl2_payload.reduced_bits[1]
0510        << sgl1->gl2_payload.reduced_bits[0] << std::endl;
0511         os << "DCM Full/FEM Busy Vector = 0x" << SETW(8) << sgl1->gl2_payload.dcm_full_fem_busy << std::endl;
0512         os << "FEM Unreliable Vector    = 0x" << SETW(8) << sgl1->gl2_payload.fem_unreliable << std::endl;
0513     os << "Granule busy             = 0x" << SETW(8) << sgl1->gl2_payload.granule_busy << std::endl;
0514     os << "Partition busy Xbar Out  = 0x" << SETW(8) << sgl1->gl2_payload.part_busy_xbar_out << std::endl;
0515     os << "Partition busy bus       = 0x" << SETW(8) << sgl1->gl2_payload.part_busy_bus << std::endl;
0516     for(i=0;i<sgl1->gl1_boards;i++)
0517       {
0518         os << std::dec << SETW(1) << "--> GL1-1[" << i << "] <--" << std::endl;
0519         os << SETW(1) << "GL1-1[" << i << "] header word = 0x" << std::hex << SETW(4) << sgl1->gl1_payload[i].gl1_header << std::endl;
0520         os << "LUT inputs ";
0521         for(j=7;j>=0;j--)
0522           os << "["<< std::dec << SETW(1) << j <<"]<-0x"<< std::hex << SETW(5) <<sgl1->gl1_payload[i].lut_input[j]<<" ";
0523         os <<std::endl;
0524         os << "LUT Out (Raw Triggers)   = 0x" << std::hex << SETW(8) << sgl1->gl1_payload[i].lut_output << std::endl;
0525         os << "Trigger busy input       = 0x" << SETW(8) << sgl1->gl1_payload[i].trigger_busy << std::endl;
0526         os << "Live Triggers            = 0x" << SETW(8) << sgl1->gl1_payload[i].live_trig_out << std::endl;
0527         os << "Scaled Triggers          = 0x" << SETW(8) << sgl1->gl1_payload[i].scaled_trig_out << std::endl;
0528         os << "Trig->Part Xbar Out      = 0x" << SETW(8) << sgl1->gl1_payload[i].trig_part_xbar_out << std::endl;
0529         os << std::dec << std::endl;
0530       }
0531 
0532     // Finally, a generic HEX dump:
0533 
0534         j = 0;
0535     int* k=( int *) findPacketDataStart(packet);
0536         if ( k ==0 ) return;
0537 
0538     while (1)
0539       {
0540         os << std::endl << std::dec << SETW(5) << j << " |  ";
0541         for (l=0;l<4;l++)
0542           {
0543         os << std::hex << SETW(8) << k[j++] << " ";
0544         if (j>=dlength) break;
0545           }
0546         if (j>=dlength) break;
0547       } 
0548         os << std::endl;
0549     for(m=0;m<54;m++) os<<"=";
0550         os << std::dec << std::endl;
0551     os.fill(oldFill);
0552 }
0553 
0554 void Packet_gl1::demangle()
0555 {
0556 
0557   /* 
0558      The job of this routine is to demangle the data into something
0559      that can be more properly addressed - the data is copied
0560      into a GL1 data structure that can be addressed properly.
0561   */
0562   int  check_length;
0563   if(sgl1) delete sgl1;
0564   sgl1=new GL1_EVENT_DATA;
0565   if(!sgl1){
0566     COUT<<"can't allocate memory for GL1_EVENT_DATA structure "<<std::endl;
0567     return;
0568   }
0569   int dlength = getDataLength();
0570 
0571   // First board will have 21 16-bit words in readout to keep the total number even at 46.
0572   // If there is an even number of GL1-1 boards total (or an odd number of additional 
0573   // GL1-1 boards) then the last GL1-1 board will have to read out 22
0574   // 16-bit words to keep the total an intergral number of 16-bit words.
0575     
0576   sgl1->gl1_boards = 1;
0577   check_length = 2*(dlength-46);  // remaining 16-bit words
0578   while( check_length>=21 ){
0579       (sgl1->gl1_boards)++;
0580       check_length-=21;
0581   }
0582  
0583   if(sgl1->gl1_boards>NUM_GL1_BOARDS)
0584   {
0585     sgl1->gl1_boards = NUM_GL1_BOARDS;
0586   }
0587   unsigned int* buf = (unsigned int *) findPacketDataStart(packet);
0588   if (buf == 0) return;
0589 
0590   // unpack the data into a GL1 structure:
0591 
0592 
0593   unsigned int idx;
0594   /* GL1-3 data */
0595 
0596   sgl1->gl3_payload.gl3_header = buf[0]&0xFFFF;
0597   sgl1->gl3_payload.timestamp.year  = 2000 + (10*((buf[0]>>20)&0xF) + ((buf[0]>>16)&0xF));
0598   sgl1->gl3_payload.timestamp.month = 10*((buf[1]>>12)&0xF) + ((buf[1]>>8)&0xF);
0599   sgl1->gl3_payload.timestamp.date  = 10*((buf[1]>>4)&0xF) + (buf[1]&0xF);
0600   sgl1->gl3_payload.timestamp.day   = (buf[1]>>24)&0x7;
0601   sgl1->gl3_payload.timestamp.hour  = 10*((buf[1]>>20)&0xF) + ((buf[1]>>16)&0xF);
0602   sgl1->gl3_payload.timestamp.min   = 10*((buf[2]>>12)&0xF) + ((buf[2]>>8)&0xF) ;
0603   sgl1->gl3_payload.timestamp.sec   = 10*((buf[2]>>4)&0xF) + (buf[2]&0xF);
0604 
0605   sgl1->gl3_payload.alignment = (buf[2]&0xFFFF0000)>>16;
0606 
0607   sgl1->gl3_payload.beam_crossing_counter[1] = 
0608     ((buf[3]&0xFFFF)<<16) + ((buf[3]&0xFFFF0000)>>16); 
0609   sgl1->gl3_payload.beam_crossing_counter[0] = 
0610     ((buf[4]&0xFFFF)<<16) + ((buf[4]&0xFFFF0000)>>16);
0611 
0612   sgl1->gl3_payload.bunch_crossing_counter = (buf[5]&0xFFFF);
0613   sgl1->gl3_payload.granule_accept_vector = (buf[5]&0xFFFF0000) + (buf[6]&0xFFFF);
0614   sgl1->gl3_payload.accept_or_input = (buf[6]&0xFFFF0000)+(buf[7]&0xFFFF);
0615   sgl1->gl3_payload.gl1_accept_counter = (buf[7]&0xFFFF0000)+(buf[8]&0xFFFF);
0616   for(unsigned int j=0;j<32;j+=2){
0617     sgl1->gl3_payload.granule_accept[31-j] = (buf[8+(j/2)]&0xFFFF0000)>>16;
0618     sgl1->gl3_payload.granule_accept[31-(j+1)] = buf[8+(j/2)+1]&0xFFFF;
0619   } 
0620   sgl1->gl3_payload.granule_disables = (buf[24]&0xFFFF0000)+(buf[25]&0xFFFF);
0621   sgl1->gl3_payload.forced_accepts = (buf[25]&0xFFFF0000)+(buf[26]&0xFFFF);
0622 
0623   /* GL1-2 */
0624 
0625   sgl1->gl2_payload.gl2_header = (buf[26]&0xFFFF0000)>>16;
0626   sgl1->gl2_payload.partition_accept = ((buf[27]&0xFFFF)<<16) + ((buf[27]&0xFFFF0000)>>16);
0627   sgl1->gl2_payload.mode_bits = (buf[28]&0xFFFF);
0628 
0629   sgl1->gl2_payload.reduced_bits[1] =
0630     (buf[28]&0xFFFF0000)+(buf[29]&0xFFFF); 
0631   sgl1->gl2_payload.reduced_bits[0] =
0632     (buf[29]&0xFFFF0000)+(buf[30]&0xFFFF); 
0633 
0634   sgl1->gl2_payload.dcm_full_fem_busy = (buf[30]&0xFFFF0000) + (buf[31]&0xFFFF);
0635   sgl1->gl2_payload.fem_unreliable = (buf[31]&0xFFFF0000) + (buf[32]&0xFFFF);
0636   sgl1->gl2_payload.granule_busy = (buf[32]&0xFFFF0000) + (buf[33]&0xFFFF);
0637   sgl1->gl2_payload.part_busy_xbar_out = (buf[33]&0xFFFF0000) + (buf[34]&0xFFFF);
0638   sgl1->gl2_payload.part_busy_bus = (buf[34]&0xFFFF0000) + (buf[35]&0xFFFF);
0639  
0640   /* GL1 data */
0641 
0642   idx = 35;
0643   for(int i=0; i<sgl1->gl1_boards;i++){
0644 
0645     if( (i%2)==0 ) {   // even numbered boards
0646 
0647       sgl1->gl1_payload[i].gl1_header = (buf[idx]&0xFFFF0000)>>16;
0648       idx++;
0649 
0650       /* Note the complicated way in which the 20-bit LUT inputs are packed */
0651 
0652       sgl1->gl1_payload[i].lut_input[7] = ((buf[idx]&0xFFFF)<<4)+((buf[idx]&0xF0000000)>>28);
0653       sgl1->gl1_payload[i].lut_input[6] = ((buf[idx]&0x0FFF0000)>>8)+((buf[idx+1]&0xFF00)>>8);
0654       sgl1->gl1_payload[i].lut_input[5] = ((buf[idx+1]&0xFF)<<12)+((buf[idx+1]&0xFFF00000)>>20);
0655       sgl1->gl1_payload[i].lut_input[4] = ((buf[idx+1]&0xF0000)<<16)+(buf[idx+2]&0xFFFF);
0656       sgl1->gl1_payload[i].lut_input[3] = ((buf[idx+2]&0xFFFF0000)>>12)+((buf[idx+3]&0xF000)>>12);
0657       sgl1->gl1_payload[i].lut_input[2] = ((buf[idx+3]&0xFFF)<<8)+((buf[idx+3]&0xFF000000)>>24);
0658       sgl1->gl1_payload[i].lut_input[1] = ((buf[idx+3]&0xFF0000)>>4)+((buf[idx+4]&0xFFF0)>>4);
0659       sgl1->gl1_payload[i].lut_input[0] = ((buf[idx+4]&0xF)<<16)+((buf[idx+4]&0xFFFF0000)>>16);
0660       idx+=5;
0661 
0662       sgl1->gl1_payload[i].lut_output = ((buf[idx]&0xFFFF0000)>>16) + ((buf[idx]&0xFFFF)<<16);
0663       idx++;
0664       sgl1->gl1_payload[i].trigger_busy = ((buf[idx]&0xFFFF0000)>>16) + ((buf[idx]&0xFFFF)<<16);
0665       idx++;
0666       sgl1->gl1_payload[i].live_trig_out = ((buf[idx]&0xFFFF0000)>>16) + ((buf[idx]&0xFFFF)<<16);
0667       idx++;
0668       sgl1->gl1_payload[i].scaled_trig_out = ((buf[idx]&0xFFFF0000)>>16) + ((buf[idx]&0xFFFF)<<16);
0669       idx++;
0670       sgl1->gl1_payload[i].trig_part_xbar_out = ((buf[idx]&0xFFFF0000)>>16) + ((buf[idx]&0xFFFF)<<16);
0671       idx++;
0672 
0673     }
0674     else   // odd numbered boards
0675     {
0676  
0677       sgl1->gl1_payload[i].gl1_header = buf[idx]&0xFFFF;
0678 
0679       /* Note the complicated way in which the 20-bit LUT inputs are packed */
0680 
0681       sgl1->gl1_payload[i].lut_input[7] = ((buf[idx]&0xFFFF0000)>>12)+((buf[idx+1]&0xF000)>>12);
0682       sgl1->gl1_payload[i].lut_input[6] = ((buf[idx+1]&0x0FFF)<<8) + ((buf[idx+1]&0xFF000000)>>24);
0683       sgl1->gl1_payload[i].lut_input[5] = ((buf[idx+1]&0xFF0000)>>4) + ((buf[idx+2]&0xFFF0)>>4);
0684       sgl1->gl1_payload[i].lut_input[4] = ((buf[idx+2]&0xF)<<16) + ((buf[idx+2]&0xFFFF0000)>>16);
0685       sgl1->gl1_payload[i].lut_input[3] = ((buf[idx+3]&0xFFFF)<<4) + ((buf[idx+3]&0xF0000000)>>28);
0686       sgl1->gl1_payload[i].lut_input[2] = ((buf[idx+3]&0xFFF0000)>>8) + ((buf[idx+4]&0xFF00)>>8);
0687       sgl1->gl1_payload[i].lut_input[1] = ((buf[idx+4]&0xFF)<<12) + ((buf[idx+4]&0xFFF00000)>>20);
0688       sgl1->gl1_payload[i].lut_input[0] = ((buf[idx+4]&0xF0000)) + ((buf[idx+5]&0xFFFF));
0689       idx+=5;
0690 
0691       sgl1->gl1_payload[i].lut_output = ((buf[idx]&0xFFFF0000)) + ((buf[idx+1]&0xFFFF));
0692       idx++;
0693       sgl1->gl1_payload[i].trigger_busy = ((buf[idx]&0xFFFF0000)) + ((buf[idx+1]&0xFFFF));
0694       idx++;
0695       sgl1->gl1_payload[i].live_trig_out = ((buf[idx]&0xFFFF0000)) + ((buf[idx+1]&0xFFFF));
0696       idx++;
0697       sgl1->gl1_payload[i].scaled_trig_out = ((buf[idx]&0xFFFF0000)) + ((buf[idx+1]&0xFFFF));
0698       idx++;
0699       sgl1->gl1_payload[i].trig_part_xbar_out = ((buf[idx]&0xFFFF0000)) + ((buf[idx+1]&0xFFFF));
0700       idx++;
0701       
0702     }
0703 
0704   }
0705 
0706 }
0707 
0708 
0709 
0710 
0711 
0712 
0713
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!