online_distribution/eventlibraries/A_Event.cc

0001 #include "A_Event.h"
0002
0003 #include "EventTypes.h"
0004
0005 #include "packet_collection.h"
0006
0007 #include "packet.h"
0008 #include "Cframe.h"
0009 #include "framePackets.h"
0010 #include "dataBlock.h"
0011
0012 #include "frameRoutines.h"
0013 #include "frameHdr.h"
0014
0015
0016 // the constructor first ----------------
0017 A_Event::A_Event (PHDWORD *data)
0018 {
0019   // set the framlist pointer to 0 just in case.
0020   framelist = 0;
0021
0022
0023   hasMap = 0;
0024   // we always make a pointer-based event.
0025   is_data_type = 0;
0026   errorcode = 0;
0027
0028   // cast the pointer to the EventData pointer
0029   EventData = (evtdata_ptr) data;
0030   if ( getEvtType() & CORRUPTEVENTMASK)
0031     {
0032       errorcode=1;
0033     }
0034   else
0035     {
0036       errorcode = updateFramelist();
0037     }
0038   originBuffer = 0;
0039 }
0040
0041 A_Event::A_Event (int *data)
0042 {
0043   // set the framlist pointer to 0 just in case.
0044   framelist = 0;
0045
0046   hasMap = 0;
0047   // we always make a pointer-based event.
0048   errorcode = 0;
0049   is_data_type = 0;
0050
0051   // cast the pointer to the EventData pointer
0052   EventData = (evtdata_ptr) data;
0053   if ( getEvtType() & CORRUPTEVENTMASK)
0054     {
0055       errorcode=1;
0056     }
0057   else
0058     {
0059       errorcode = updateFramelist();
0060     }
0061
0062 }
0063
0064 A_Event::~A_Event()
0065 {
0066   delete [] framelist;
0067   if (is_data_type) delete [] (PHDWORD *) EventData;
0068   pmap.clear();
0069
0070 }
0071
0072
0073 // the info-type calls
0074 unsigned int
0075 A_Event::getEvtLength() const
0076 {
0077   return EventData->evt_length;
0078 }
0079
0080 int
0081 A_Event::getEvtType() const
0082 {
0083   return EventData->evt_type;
0084 }
0085
0086 int
0087 A_Event::getEvtSequence() const
0088 {
0089   return EventData->evt_sequence;
0090 }
0091
0092 int
0093 A_Event::getRunNumber() const
0094 {
0095   return EventData->run_number;
0096 }
0097
0098 #ifdef WIN32
0099 const ULONGLONG  ticOffset = 35067168000000000UL;
0100 const ULONGLONG  ticFactor = 10000000;
0101 #else
0102 const  unsigned long long  ticOffset = 35067168000000000ULL;
0103 const   unsigned long long ticFactor = 10000000;
0104 #endif
0105
0106
0107 time_t A_Event::getTime() const
0108 {
0109   if ( EventData->time == -1)
0110      {
0111        return (time_t) EventData->date;
0112      }
0113   else
0114     {
0115
0116       unsigned long long  x,y,z;
0117       x = (unsigned int)  EventData->time;
0118       y = (unsigned int)  EventData->date;
0119       z = y | ( x<<32 );
0120       time_t t =  (z - ticOffset) / ticFactor;
0121       return t;
0122     }
0123 }
0124
0125
0126 void A_Event::listFrame ( const int id, OSTREAM &os) const
0127 {
0128   PHDWORD *fp;
0129   PHDWORD *pp;
0130   int i = 0;
0131   int j = 0;
0132
0133   if (id == 0)
0134     {
0135
0136       while ( ( fp = framelist[i++]) )
0137     {
0138       dumpFrame(fp, os);
0139       //os << "Frame " << ++j << "align length: "<< getFrameAlignLength(fp) << std::endl;
0140     }
0141     }
0142   else // find the frame for a given packet
0143     {
0144
0145       while ( (fp = framelist[i++]) )
0146     {
0147       j++;
0148       if ( ( pp = findFramePacketId (fp, id) ) !=  ptrFailure)
0149         {
0150           dumpFrame(fp, os);
0151           //os << "Frame " << j << "align length: "<< getFrameAlignLength(fp) << std::endl;
0152           return;
0153         }
0154     }
0155     }
0156 }
0157
0158 void
0159 A_Event::listHistory(const int id, OSTREAM &os) const
0160 {
0161   os << "History Block: " << std::endl;
0162
0163   int i = 0;
0164   if (id == 0)
0165     {
0166       while ( PHDWORD* fp = framelist[i++] )
0167     {
0168       PHDWORD* h_ptr = findFrameHistoryStart(fp);
0169       UINT len = getFrameHistoryLength(fp);
0170       dumpBlock(h_ptr, len, os);
0171     }
0172     }
0173   else // find the frame for a given packet
0174     {
0175       int j = 0;
0176       while ( PHDWORD* fp = framelist[i++] )
0177     {
0178       j++;
0179       if ( findFramePacketId(fp, id) != ptrFailure )
0180         {
0181           PHDWORD* h_ptr = findFrameHistoryStart(fp);
0182           UINT len = getFrameHistoryLength(fp);
0183           dumpBlock(h_ptr, len, os);
0184           return;
0185         }
0186     }
0187     }
0188   return;
0189 }
0190
0191 void
0192 A_Event::listError( const int id, OSTREAM& os ) const
0193 {
0194   os << "Error Block: " << std::endl;
0195   int i = 0;
0196   if (id == 0)
0197     {
0198       while ( PHDWORD* fp = framelist[i++] )
0199     {
0200       PHDWORD* ptr = findFrameErrorStart(fp);
0201       UINT len = getFrameErrorLength(fp);
0202       dumpBlock(ptr, len, os);
0203       dumpErrorBlock(fp,os);
0204     }
0205     }
0206   else // find the frame for a given packet
0207     {
0208       int j = 0;
0209       while ( PHDWORD* fp = framelist[i++] )
0210     {
0211       j++;
0212       if ( findFramePacketId(fp, id) != ptrFailure )
0213         {
0214           PHDWORD* ptr = findFrameErrorStart(fp);
0215           UINT len = getFrameErrorLength(fp);
0216           dumpBlock(ptr, len, os);
0217           return;
0218         }
0219     }
0220     }
0221 }
0222
0223 void A_Event::dumpFrame(PHDWORD *fp, OSTREAM &os)
0224 {
0225   // DLW: for SEQ number and code, there is no corresponding routine in Cframe.h,
0226   // so I directly unpack the field.  This will break if the frame format ever changes...
0227   //
0228   os << "Frame length:       " << std::dec << getFrameLength(fp) << std::endl;
0229   os << "Frame mark:         " << std::hex << getFrameMark(fp) << std::dec << std::endl;
0230   os << "Frame Hdr version:  " << getFrameHdrVersion(fp) << std::endl;
0231   os << "Frame Hdr length:   " << getFrameHdrLength(fp) << std::endl ;
0232   os << "Frame Status:       " << getFrameStatus(fp) << std::endl;
0233   os << "Frame Seq Number:   " << (((*(fp+3))&0xff000000)>>24) << std::endl;
0234   os << "Frame Seq Code:     " << (((*(fp+3))&0x00ff0000)>>24) << std::endl;
0235   os << "Frame Source id:    " << getFrameSourceId(fp) << std::endl;
0236   os << "Frame data type:    " << getFrameDataType(fp) << std::endl;
0237   os << "Frame type:         " << getFrameType(fp) << std::endl;
0238   os << "Frame Error Length: " << getFrameErrorLength(fp) << std::endl;
0239   os << "Frame Hist Length:  " << getFrameHistoryLength(fp) << std::endl;
0240   os << "Frame align length: " << getFrameAlignLength(fp) << std::endl;
0241   os << "Frame padding:      " << getFramePadding(fp) << std::endl;
0242   unsigned int i = 0;
0243   PHDWORD *p = findFrameAlignBlock(fp);
0244   for (i = 0; i<  getFrameAlignLength(fp); i++ )
0245     {
0246       os << "  - Alignment word " << SETW(2) << i << ":  0x" ;
0247
0248       os.fill('0');
0249       os << SETW(8) << std::hex << *p++ << std::dec << std::endl;
0250       os.fill (' ');
0251     }
0252   os << std::endl;
0253 }
0254
0255 void
0256 A_Event::dumpErrorBlock(PHDWORD *fp, OSTREAM &os)
0257 {
0258   PHDWORD* ptr = findFrameErrorStart(fp);
0259   UINT len = getFrameErrorLength(fp);
0260   UINT nerr = calcNumErrorsV1(len);
0261   if ( nerr == 0 ) return;
0262
0263   errorEntryV1* p = reinterpret_cast<errorEntryV1*>(ptr);
0264   for (UINT i=0; i<nerr; ++i)
0265     {
0266       errorEntryV1& e = *p;
0267       os << "ErrorEntry " << i << ": ";
0268       os << "severity: " << (int) e.severity << " "
0269      << "deviceType: " << (int)e.deviceType << " "
0270      << "deviceId: " << std::dec << e.deviceId << " "
0271      << "errorCode: " << e.errorCode << " "
0272      << "detectCode: " << e.detectCode << " "
0273      << "addData: (" << std::hex << e.addData[0] << "," << std::hex << e.addData[1] << ")"
0274      << std::dec
0275      << std::endl;
0276       p++;
0277     }
0278   os << std::endl;
0279 }
0280
0281 void
0282 A_Event::dumpBlock(PHDWORD* p, UINT len, OSTREAM& os, const int how)
0283 {
0284   if ( len == 0 ) {
0285     os << "   (empty)\n" << std::endl;
0286     return;
0287   }
0288
0289   unsigned int j;
0290   switch (how)
0291     {
0292     case (EVT_HEXADECIMAL):
0293       j = 0;
0294       while (1)
0295     {
0296       os << SETW(5) << j << " |  ";
0297       for ( UINT l=0; l<4; l++ )
0298         {
0299           if ( j >= len ) break;
0300           os << std::hex << SETW(8) << p[j++] << " " ;
0301         }
0302       if ( j >= len ) break;
0303       os << std::dec << std::endl;
0304     }
0305       break;
0306
0307     case (EVT_DECIMAL):
0308       j = 0;
0309       while (1)
0310     {
0311       os << std::dec << SETW(5) << j << " |  ";
0312
0313       for ( UINT l=0; l<6; l++ )
0314         {
0315           os << SETW(10) << p[j++] << " ";
0316           if ( j >= len ) break;
0317         }
0318       if ( j >= len ) break;
0319       os << std::endl;
0320     }
0321       break;
0322
0323     default:
0324       break;
0325     }
0326   os << std::endl << std::endl;
0327
0328 }
0329
0330 unsigned int A_Event::getFrameEntry(const char *what, const int id, const int index) const
0331 {
0332
0333   PHDWORD *fp;
0334   PHDWORD *pp;
0335   int i = 0;
0336   int j = 0;
0337
0338   if (id == 0)
0339     {
0340
0341       while ( ( fp = framelist[i++]) )
0342     {
0343       return getFrameValue( what,fp,index);
0344     }
0345     }
0346   else // find the frame for a given packet
0347     {
0348
0349       while ( (fp = framelist[i++]) )
0350     {
0351       j++;
0352       if ( ( pp = findFramePacketId (fp, id) ) !=  ptrFailure)
0353         {
0354           return getFrameValue( what,fp,index);
0355         }
0356     }
0357     }
0358   return 0;
0359 }
0360
0361
0362
0363
0364 unsigned int A_Event::getFrameValue(const char *what, PHDWORD *fp, const unsigned int index) const
0365 {
0366
0367   if ( strcmp(what,"FRAMELENGTH") == 0)     return getFrameLength(fp);
0368   else if  ( strcmp(what,"FRAMEMARK") ==0)  return  getFrameMark(fp);
0369   else if  ( strcmp(what,"FRAMEHDRVERSION") == 0)  return getFrameHdrVersion(fp);
0370   else if  ( strcmp(what,"FRAMEHDRLENGTH") == 0)  return  getFrameHdrLength(fp);
0371   else if  ( strcmp(what,"FRAMESTATUS") == 0) return  getFrameStatus(fp);
0372   else if  ( strcmp(what,"FRAMESOURCEID") ==0 )return  getFrameSourceId(fp);
0373   else if  ( strcmp(what,"FRAMEDATATYPE") == 0) return getFrameDataType(fp);
0374   else if  ( strcmp(what,"FRAMETYPE") == 0) return  getFrameType(fp);
0375   else if  ( strcmp(what,"FRAMEALIGNLENGTH") == 0) return getFrameAlignLength(fp);
0376   else if  ( strcmp(what,"FRAMEALIGNMENTWORD") == 0)
0377     {
0378       PHDWORD *p = findFrameAlignBlock(fp);
0379       if ( index >= getFrameAlignLength(fp) ) return 0;
0380       return p[index];
0381     }
0382
0383   return 0;
0384 }
0385
0386
0387 // getSubevent (int)
0388 Packet*
0389 A_Event::getPacket (const int id)
0390 {
0391   return getPacket(id,0);
0392 }
0393
0394 #if !defined(SunOS) && !defined(OSF1)
0395
0396 int A_Event::createMap()
0397 {
0398   int i = 0;
0399   PHDWORD *fp;
0400   PHDWORD *pp;
0401
0402   if ( ! framelist )
0403     {
0404       errorcode = -3;
0405     }
0406
0407   if (errorcode)  return 0;
0408
0409   unsigned int pos_in_event;
0410
0411   if (!hasMap)
0412     {
0413
0414       while ( (fp = framelist[i++]) )
0415     {
0416       pp = findFramePacketIndex (fp, 0);
0417
0418
0419       while ( pp  !=  ptrFailure)
0420         {
0421
0422           pos_in_event = ( int )(  pp - ( PHDWORD *) EventData );
0423
0424           //          std::cout << "pos in event = " << pos_in_event <<
0425           //    "  packet length = " << *pp << " ev. length= " <<   getEvtLength() << std::endl;
0426
0427           if (pp && *pp > getEvtLength() - pos_in_event )
0428         {
0429           std::cout << "Found wrong packet length " << *pp
0430                 << std::hex << "(0x" << *pp << ")" << std::dec
0431                 << " packet Id: " <<  getPacketId(pp)
0432                 << " Event: " << getEvtSequence()
0433                 << " EvtLength: " << getEvtLength()
0434                 << " PosInEvent: " << pos_in_event
0435                 << std::endl;
0436           errorcode =-2;
0437           break;
0438         }
0439           if ( pp != 0 && *pp == 0)
0440         {
0441           std::cout << "found 0-length packet" << std::endl;
0442           errorcode =-1;
0443           break;
0444         }
0445
0446
0447           pmap[getPacketId(pp)] = pp;
0448           // std::cout << "Packet id " << getPacketId(pp) << std::endl;
0449
0450           pp =  findNextFramePacket(fp, pp);
0451
0452         }
0453     }
0454       hasMap = 1;
0455     }
0456   return 0;
0457 }
0458
0459
0460 Packet*
0461 A_Event::getPacket (const int id, const int hitFormat)
0462 {
0463
0464   PHDWORD *pp;
0465
0466
0467   if (!hasMap) createMap();
0468   if ( errorcode) return 0;
0469
0470
0471   pp = pmap[id];
0472   if (!pp) return 0;
0473
0474   return makePacket(pp,hitFormat);
0475 }
0476
0477 #else
0478
0479 // the STL-Free solaris version
0480
0481 Packet*
0482 A_Event::getPacket (const int id, const int hitFormat)
0483 {
0484
0485   int i = 0;
0486   PHDWORD *fp;
0487   PHDWORD *pp;
0488   UINT ids = id;
0489   int wanted_hitformat;
0490
0491   while ( fp = framelist[i++] )
0492     {
0493       if ( ( pp = findFramePacketId (fp, ids) ) !=  ptrFailure)
0494     {
0495       return makePacket(pp,hitFormat);
0496     }
0497     }
0498   return 0;
0499 }
0500 #endif
0501
0502 int
0503 A_Event::getPacketList( Packet* sl[], const int ne)
0504 {
0505   int i = 0;
0506   PHDWORD *fp;
0507   PHDWORD *pp;
0508
0509   if (!hasMap) createMap();
0510   if ( errorcode) return 0;
0511
0512   int entries = 0;
0513
0514   while ( (fp = framelist[i++]) )
0515     {
0516
0517       pp = findFramePacketIndex (fp, 0);
0518
0519       while ( pp  !=  ptrFailure)
0520     {
0521       if (getPacketStructure(pp) == Unstructured)
0522         {
0523           sl[entries++] = makePacket(pp,0);
0524           //  sl[entries-1]->identify();
0525
0526         }
0527
0528       if (entries >= ne) return ne;
0529       if ( (pp =  findNextFramePacket(fp, pp)) == ptrFailure)
0530             {
0531               break;
0532             }
0533       if (*pp > getEvtLength())
0534         {
0535           std::cout << "Found wrong packet length " << *pp << std::endl;
0536           break;
0537         }
0538       if ( pp != 0 && *pp == 0)
0539         {
0540           std::cout << "found 0-length packet" << std::endl;
0541           //  PHDWORD *x = pp - 10;
0542           // std::cout << "--------------------------" << std::endl;
0543           // for (i=0; i< 20; i++)
0544           //    {
0545           //      std::cout << i << "  " << x << "  " << std::hex <<*x++ << std::dec << std::endl;
0546           //    }
0547           // std::cout << "--------------------------" << std::endl;
0548
0549
0550           break;
0551         }
0552     }
0553     }
0554   return entries;
0555 }
0556
0557 std::vector<Packet*>  A_Event::getPacketVector()
0558 {
0559   int i = 0;
0560   PHDWORD *fp;
0561   PHDWORD *pp;
0562
0563   std::vector<Packet *> v;
0564
0565   if (!hasMap) createMap();
0566   if ( errorcode) return v;
0567
0568
0569
0570   while ( (fp = framelist[i++]) )
0571     {
0572
0573       pp = findFramePacketIndex (fp, 0);
0574
0575       while ( pp  !=  ptrFailure)
0576     {
0577       if (getPacketStructure(pp) == Unstructured)
0578         {
0579           v.push_back( makePacket(pp,0) );
0580           //  sl[entries-1]->identify();
0581
0582         }
0583
0584       if ( (pp =  findNextFramePacket(fp, pp)) == ptrFailure)
0585             {
0586               break;
0587             }
0588       if (*pp > getEvtLength())
0589         {
0590           std::cout << "Found wrong packet length " << *pp << std::endl;
0591           break;
0592         }
0593       if ( pp != 0 && *pp == 0)
0594         {
0595           std::cout << "found 0-length packet" << std::endl;
0596           //  PHDWORD *x = pp - 10;
0597           // std::cout << "--------------------------" << std::endl;
0598           // for (i=0; i< 20; i++)
0599           //    {
0600           //      std::cout << i << "  " << x << "  " << std::hex <<*x++ << std::dec << std::endl;
0601           //    }
0602           // std::cout << "--------------------------" << std::endl;
0603
0604
0605           break;
0606         }
0607     }
0608     }
0609   return v;
0610 }
0611
0612
0613
0614
0615 Packet *A_Event::makePacket(PHDWORD *pp, const int hitFormat)
0616 {
0617
0618   int wanted_hitformat;
0619
0620   if (getPacketStructure(pp) != Unstructured) return 0;
0621
0622
0623   if (hitFormat)  wanted_hitformat = hitFormat;
0624   else wanted_hitformat  = getUnstructPacketHitFormat(pp);
0625
0626   switch (wanted_hitformat)
0627     {
0628
0629       // pbsc "32 channel format"
0630
0631     case 50400:
0632     case IDHBD_FPGA:
0633     case IDHBD_FPGA0SUP:
0634     case IDFOCAL_FPGATEST:
0635       return new Packet_hbd_fpga(pp);
0636       break;
0637
0638     case IDHBD_FPGASHORT:
0639     case IDHBD_FPGASHORT0SUP:
0640       return new Packet_hbd_fpgashort(pp);
0641       break;
0642
0643     case IDFVTX_DCM0:
0644     case IDFVTX_SIM:
0645       return new Packet_fvtx_dcm0(pp);
0646       break;
0647
0648     case IDCDEVPOLARIMETER:
0649       return new Packet_cdevpolarimeter(pp);
0650       break;
0651
0652     case IDCDEVPOLARIMETERTARGET:
0653       return new Packet_cdevpoltarget(pp);
0654       break;
0655
0656     case IDCDEVIR:
0657       return new Packet_cdevir(pp);
0658       break;
0659
0660     case IDCDEVWCMHISTORY:
0661       return new Packet_cdevwcm(pp);
0662       break;
0663
0664     case IDCDEVBPM:
0665       return new Packet_cdevbpm(pp);
0666       break;
0667
0668     case IDCDEVDVM:
0669       return new Packet_cdevdvm(pp);
0670       break;
0671
0672     case IDCDEVRING:
0673       return new Packet_cdevring(pp);
0674       break;
0675
0676     case IDCDEVRINGPOL:
0677       return new Packet_cdevring(pp);
0678       break;
0679
0680     case IDCDEVRINGFILL:
0681       return new Packet_cdevring(pp);
0682       break;
0683
0684     case IDCDEVRINGNOPOL:
0685       return new Packet_cdevringnopol(pp);
0686       break;
0687
0688     case IDCDEVBUCKETS:
0689       return new Packet_cdevbuckets(pp);
0690       break;
0691
0692       //mlp 10/27/03 added this - the SIS is a straight array of numbers.
0693     case IDCDEVSIS:
0694       return new Packet_id4evt(pp);
0695       break;
0696
0697     case IDCDEVMADCH:
0698       return new Packet_cdevmadch(pp);
0699       break;
0700
0701     case ID4SCALER:
0702       return new Packet_id4scaler(pp);
0703       break;
0704
0705     case IDDIGITIZER_12S:
0706     case IDDIGITIZER_16S:
0707     case IDDIGITIZER_31S:
0708       return new Packet_iddigitizerv2(pp);
0709       break;
0710
0711     case  IDDIGITIZERV3_2S:
0712     case  IDDIGITIZERV3_4S:
0713     case  IDDIGITIZERV3_6S:
0714     case  IDDIGITIZERV3_8S:
0715     case  IDDIGITIZERV3_12S:
0716     case  IDDIGITIZERV3_14S:
0717     case  IDDIGITIZERV3_16S:
0718     case  IDDIGITIZERV3_18S:
0719     case  IDDIGITIZERV3_20S:
0720     case  IDDIGITIZERV3_22S:
0721     case  IDDIGITIZERV3_24S:
0722     case  IDDIGITIZERV3_26S:
0723     case  IDDIGITIZERV3_28S:
0724     case  IDDIGITIZERV3_30S:
0725
0726       return new Packet_iddigitizerv3(pp);
0727       break;
0728
0729     case IDLL1_20S:
0730     case IDLL1v2_20S:
0731       return new Packet_idll1v1(pp);
0732       break;
0733
0734     case IDLL1_MBD:
0735     case IDLL1_EMCAL_MON0:
0736     case IDLL1_EMCAL_MON1:
0737     case IDLL1_EMCAL_MON2:
0738     case IDLL1_EMCAL_MON3:
0739     case IDLL1_JET_EMCAL_MON0:
0740     case IDLL1_JET_EMCAL_MON1:
0741     case IDLL1_JET_EMCAL_MON2:
0742     case IDLL1_JET_EMCAL_MON3:
0743     case IDLL1_JET_EMCAL_MON4:
0744     case IDLL1_JET_HCAL_MON0:
0745     case IDLL1_JET_HCAL_MON1:
0746     case IDLL1_JET_HCAL_MON2:
0747     case IDLL1_JET_HCAL_MON3:
0748     case IDLL1_JET_HCAL_MON4:
0749
0750       return new Packet_idll1v2(pp);
0751       break;
0752
0753     case IDGL1P:
0754       return new Packet_gl1p(pp);
0755       break;
0756
0757     case IDGL1_EVCLOCK:
0758       return new Packet_gl1_evclocks(pp);
0759       break;
0760
0761     case IDGL1PSUM:
0762     case IDGL1PSUMOBS:
0763       return new Packet_gl1psum(pp);
0764       break;
0765
0766     case ID4EVT:
0767       return new Packet_id4evt(pp);
0768       break;
0769
0770     case ID2EVT:
0771       return new Packet_id2evt(pp);
0772       break;
0773
0774     case IDCSTR:
0775       return new Packet_idcstr(pp);
0776       break;
0777
0778     case IDSTARSCALER:
0779       return new Packet_starscaler(pp);
0780       break;
0781
0782     default:
0783       switch (getUnstructPacketWordSize (pp))
0784     {
0785     case 1:
0786       return new Packet_w1(pp);
0787       break;
0788     case 2:
0789       return new Packet_w2(pp);
0790       break;
0791     case 4:
0792       return new Packet_w4(pp);
0793       break;
0794     default:
0795       return new Packet_w4(pp);
0796     }
0797     }
0798
0799   return 0;
0800 }
0801
0802
0803
0804 void
0805 A_Event::identify (OSTREAM &os) const
0806 {
0807   os << " -- Event "   << EventData->evt_sequence;
0808
0809   os << " Run: "  << SETW(5)  << EventData->run_number;
0810
0811   os << " length: "     << SETW(5)  <<EventData->evt_length;
0812
0813   os << " frames: " << SETW(3) << NumberFrames;
0814
0815   os << " type: "      << SETW(2)  << EventData->evt_type ;
0816
0817   os << " (" << get_evt_mnemonic(EventData->evt_type );
0818
0819
0820   if ( ( EventData->evt_type & CORRUPTEVENTMASK ) )
0821   {
0822     os << " *Corrupt* ";
0823   }
0824   os << ") ";
0825
0826   time_t x = getTime();
0827   os << x;
0828
0829   os << std::endl;
0830
0831 };
0832
0833
0834
0835 int
0836 A_Event::existPacket (const int id)
0837 {
0838 #if !defined(SunOS) && !defined(OSF1)
0839
0840   PHDWORD *pp;
0841
0842   if (!hasMap)
0843     {
0844       createMap();
0845     }
0846
0847   pp = pmap[id];
0848
0849   if (!pp)
0850     {
0851       return 0;
0852     }
0853   return 1;
0854 #else
0855   return 0;
0856 #endif
0857 }
0858
0859
0860
0861 // the Copy routine
0862 int
0863 A_Event::Copy (int * array, const unsigned int length, int *nw, const char *what)
0864 {
0865   if (length< getEvtLength() )
0866     {
0867       *nw = 0;
0868       return -1;
0869     }
0870   char *to = (char *) array;
0871   char *from;
0872   unsigned int l;
0873   if ( strcmp (what, "DATA") ==0  )
0874     {
0875       from= (char *)  &EventData->data[0];
0876       l = getEvtLength() - EVTHEADERLENGTH;
0877     }
0878   else
0879     {
0880       from= (char *) EventData;
0881       l = getEvtLength();
0882     }
0883   //  for (i=0; i<l ; i++) *to++ = *from++;
0884   //
0885   *nw = l;
0886   memcpy (to, from, l*4);
0887   return 0;
0888 }
0889
0890 int A_Event::convert()
0891 {
0892   if (is_data_type) return -1;
0893
0894   PHDWORD *tmp;
0895
0896   tmp = new PHDWORD[getEvtLength()];
0897   PHDWORD *from= (PHDWORD *)  EventData;
0898   PHDWORD *to=tmp;
0899   for (unsigned int k=0; k< getEvtLength(); k++)
0900     {
0901       *to++ = *from++;
0902     }
0903
0904   delete [] framelist;
0905   EventData = (evtdata_ptr) tmp;
0906   updateFramelist();
0907
0908   is_data_type = 1;
0909   pmap.clear();
0910   hasMap = 0;
0911   return 0;
0912
0913 }
0914
0915 int A_Event::is_pointer_type() const
0916 {
0917   if (is_data_type) return 0;
0918   else return 1;
0919 }
0920
0921
0922 int A_Event::updateFramelist()
0923 {
0924   // go through the data and see how may,
0925   // if any, frames we have got.
0926   int max_index = EventData->evt_length - EVTHEADERLENGTH;
0927   int index = 0;
0928   int number_of_frames = 0;
0929   int flength;
0930   int cont;
0931   int i;
0932   // count the number of frames, and allocate a properly-sized vector
0933   // with pointers to it.
0934   cont = 1;
0935   while (index < max_index && cont)
0936     {
0937       PHDWORD *f = &EventData->data[index];
0938       // so here we believe that we point to a frame start
0939       if (  validFrameHdr(f) )
0940     {
0941       number_of_frames++;
0942       flength = getFrameLength (f);
0943       index += flength;
0944     }
0945       else
0946     {
0947       COUT << "invalid frame header, frame nr " << number_of_frames << " index = " << index <<  std::endl; //mlpd
0948       COUT << " -- Event*"   << EventData->evt_sequence;
0949
0950       COUT << " Run: "  << SETW(5)  << EventData->run_number;
0951
0952       COUT << " length: "     << SETW(5)  <<EventData->evt_length;
0953
0954       COUT << " type: "      << SETW(2)  << EventData->evt_type
0955            << " (" << get_evt_mnemonic(EventData->evt_type) << ") ";
0956       COUT << std::endl;
0957
0958       for (i=0; i< 8; i++)
0959         COUT << i << "  " << std::hex << f[i] << std::dec << std::endl;
0960
0961       return -1;
0962
0963       // COUT << "I will continue anyway" << std::endl;
0964       // cont = 0;
0965     }
0966     }
0967
0968   // ok, so many frames. get the vector.
0969   framelist = new PHDWORD *[number_of_frames +1];
0970
0971   // NumberFrames is a class data member.
0972   NumberFrames =  number_of_frames;
0973
0974   // now we go through once more and remember the pointers to where the
0975   // frames start
0976   index = 0;
0977   int ifn = 0;
0978   while (index < max_index && cont)
0979     {
0980       PHDWORD *f = &EventData->data[index];
0981       if (  validFrameHdr(f) )
0982     {
0983       framelist[ifn++] = f;
0984       flength = getFrameLength (f);
0985       index += flength;
0986     }
0987       else
0988     {
0989       COUT << "invalid frame header, frame nr " << ifn << " index = " << index <<  std::endl; //mlpd
0990       for (i=0; i< 8; i++)
0991         COUT << i << "  " << std::hex << f[i] << std::dec << std::endl;
0992
0993
0994       cont = 0;
0995     }
0996     }
0997
0998   //we terminate the list of frames with a 0.
0999   framelist[ifn] = 0;
1000   return 0;
1001 }
1002
1003 int A_Event::getErrorCode()
1004 {
1005 #if !defined(SunOS) && !defined(OSF1)
1006   createMap();
1007 #endif
1008   return errorcode;
1009 }