yoda/techmodel/EventReader.cpp

/** @file
 * $Author: kusanagi $
 * $Date: 2006/05/30 19:58:25 $
 * $Revision: 6.6 $
 * 
 * Implementation of the functions of a sample Algorithm class.
 * This file can be used as a templace to develop your own algorithm.
 */

#include <log4cxx/logger.h>
#include "EventReader.h"
#include "ReaderAlgorithms.h"

extern "C" {
    #include "CRC.h"
}

using namespace pamela;
using namespace pamela::techmodel;

static log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(_T("pamela.techmodel.EventReader"));

unsigned int EventReader::maxPackets     = 0;
unsigned int EventReader::prevPckCounter = 0;
unsigned int EventReader::prevPckOBT     = 0;


/**
 * Constructor. 
 */
EventReader::EventReader(int packetsLimit = -1): 
  TechmodelAlgorithm(0, "TechmodelEventReader"){ 
  EventReader::maxPackets = packetsLimit;
  logger->debug(_T("Constructor"));
  Header = new EventHeader();

  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::PhysEndRun,      new PhysEndRunReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibCalPulse1,  new CalibCalPulse1Reader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibCalPulse2,  new CalibCalPulse2Reader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Physics,         new PhysicsReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibTrkBoth,    new CalibTrkBothReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibTrk1,       new CalibTrk1Reader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibTrk2,       new CalibTrk2Reader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibTof,        new CalibTofReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibS4,         new CalibS4Reader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibCalPed,     new CalibCalPedReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Calib1_Ac1,      new Calib1_Ac1Reader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Calib2_Ac1,      new Calib2_Ac1Reader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Calib1_Ac2,      new Calib1_Ac2Reader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Calib2_Ac2,      new Calib2_Ac2Reader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibCal,        new CalibCalReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::RunHeader,       new RunHeaderReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::RunTrailer,      new RunTrailerReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibHeader,     new CalibHeaderReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibTrailer,    new CalibTrailerReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::InitHeader,      new InitHeaderReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::InitTrailer,     new InitTrailerReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::EventTrk,        new EventTrkReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Log,             new LogReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::VarDump,         new VarDumpReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::ArrDump,         new ArrDumpReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::TabDump,         new TabDumpReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Tmtc,            new TmtcReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Mcmd,            new McmdReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::ForcedFECmd,     new ForcedFECmdReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Ac1Init,         new Ac1InitReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalInit,         new CalInitReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::TrkInit,         new TrkInitReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::TofInit,         new TofInitReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::TrgInit,         new TrgInitReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::NdInit,          new NdInitReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::S4Init,          new S4InitReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Ac2Init,         new Ac2InitReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalAlarm,        new CalAlarmReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Ac1Alarm,        new Ac1AlarmReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::TrkAlarm,        new TrkAlarmReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::TrgAlarm,        new TrgAlarmReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::TofAlarm,        new TofAlarmReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::S4Alarm,         new S4AlarmReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Ac2Alarm,        new Ac2AlarmReader));  
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::TsbT,            new TsbTReader));
  TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::TsbB,            new TsbBReader));
}

/**
 * Get a string with the version info of the algorithm.
 */
std::string EventReader::GetVersionInfo(void) const {
  return 
    "$Header: /home/cvsmanager/yoda/techmodel/EventReader.cpp,v 6.6 2006/05/30 19:58:25 kusanagi Exp $\n";
}

/**
 * Initialize the algorithm with a special run. This will initialize the
 * event reader routines for all packet types.
 */
void EventReader::Init(PamelaRun *run) {
    SetInputStream(run);
    //Create the structure of directories and create xxx.Header.root files
    run->WriteHeaders(this, &Header); 

    //Create the xxx.root in it's specific directory
    for (AlgorithmMap::iterator i = TechmodelAlgorithmMap.begin(); 
       i != TechmodelAlgorithmMap.end(); i++) {
       oss.str("");
       oss << "Initializing algo " << i->second->GetAlgorithmName();
       logger->debug(oss.str().c_str());
       i->second->Init(run);
    }
    Run = dynamic_cast<TechmodelPamelaRun*>(run);
}

static void SkipToNextHeader(ifstream *);

/**
 * Read the next event header, call the reader algorithms that
 * correspond to its packet type, and read the event trailer.
 */
void EventReader::RunEvent(int EventNumber) {
  stringstream oss;
  int step = 0;
  const PacketType* type;
  unsigned char *header;
  while (!InputFile->eof() && ((step++ < maxPackets) || (maxPackets == 0))){
    try {
      if (FindStart(*&header, 16)) {
            UnpackPscuHeader(*&header);
            type = Header->GetPscuHeader()->GetPacketType();
            AlgorithmMap::iterator i = TechmodelAlgorithmMap.find(type); 
            if (i != TechmodelAlgorithmMap.end()) {
                TechmodelAlgorithm *EventAlgorithm(i->second);
                EventAlgorithm->RunEvent(EventNumber, Header->GetPscuHeader()->GetPacketLenght());
                Run->FillTrees(type);
                Header->GetCounter()->Increment(type);
                logger->info(Header->GetPscuHeader()->Print());
            } else {
                oss.str("");
                oss << "\n No way to read events of type  " << type->GetName().c_str() << Header->GetPscuHeader()->Print();
                throw NotExistingAlgorithmException(oss.str().c_str()); //to exctract to an higher level and delete the logger!
            }
      }
    // In case of exception have to save the packet in a specific root file??
    } catch (NotExistingAlgorithmException exc) {
      oss.str("");
      oss << exc.print() << " " << Header->GetPscuHeader()->Print();
      logger->error(oss.str().c_str());
    } catch (WrongCRCHeaderException exc) {
      oss.str("");
      oss << exc.print();
      logger->error(oss.str().c_str());
    } catch (WrongCRCException exc) {
      oss.str("");
      oss << exc.print() << " " << Header->GetPscuHeader()->Print();
      logger->error(oss.str().c_str());
      archiveCorruptedPacket(Header->GetPscuHeader()->FileOffset, Header->GetPscuHeader()->PacketLenght);
    } catch (UnidentifiedPacketException exc) {
      oss.str("");
      oss << exc.print() << " " << Header->GetPscuHeader()->Print();
      logger->error(oss.str().c_str());
    } catch (NotExistingCounterException exc) {
      oss.str("");
      oss << exc.print() << " " << Header->GetPscuHeader()->Print();
      logger->error(oss.str().c_str());
    } catch (LengthException exc) {
      oss.str("");
      oss << exc.print() << " " << Header->GetPscuHeader()->Print();
      logger->error(oss.str().c_str());
    } catch (BackwardCounterException exc) {
      oss.str("");
      oss << exc.print() << " " << Header->GetPscuHeader()->Print();
      logger->error(oss.str().c_str());
    } catch (...) {
      logger->error("Couldn't read the event. Skipping to the next header. \n");
    }
    if ((step%1000) == 0) std::cout << step/1000 << "K \n";
    oss.str("");
    oss << "----endPck " << Header->GetPscuHeader()->GetCounter() << "\n";
    logger->info(oss.str().c_str());
  }
    Header->GetCounter()->PrintCounters();
    //if (corruptedPacketFile.is_open()) corruptedPacketFile.close();
}

/**
 * Unpack the PSCU header from a file into the structure.
 */
void EventReader::UnpackPscuHeader(unsigned char *header) throw (WrongCRCHeaderException, LengthException, BackwardCounterException) {
  if (header == NULL) throw LengthException("errore di lunghezza");
  stringstream oss;
  int response = 0;

  unsigned char PacketId1    = header[3];
  unsigned char PacketId2    = header[4];
  unsigned int  Counter      = (((UINT32)header[5]<<16)&0x00FF0000) + (((UINT32)header[6]<<8)&0x0000FF00) + (((UINT32)header[7])&0x000000FF);
  unsigned int  OrbitalTime  = (((UINT32)header[8]<<24)&0xFF000000) + (((UINT32)header[9]<<16)&0x00FF0000) +  (((UINT32)header[10]<<8)&0x0000FF00) + (((UINT32)header[11])&0x000000FF);
  unsigned int  PacketLenght = (((UINT32)header[12]<<16)&0x00FF0000) +  (((UINT32)header[13]<<8)&0x0000FF00) + (((UINT32)header[14])&0x000000FF);
  unsigned char CRC          = header[15];
  unsigned char FileOffset   = header[15];

  long int initPos = InputFile->tellg();
  // Check parameters anomalies. If initPos < 16 it is the first packet 
  // (supposing a correct starting packet!)
  if ((Counter < prevPckCounter) && (initPos > 16)){
    response = prevPckCounter - Counter;
    //oss.str("");
    //oss << "Packet counter is less than before of " << (prevPckCounter - Counter);
    //throw BackwardCounterException(oss.str().c_str());
    //logger->error(oss.str().c_str());
  }

  if ((Counter > prevPckCounter + 1) && (initPos > 16)){
    oss.str("");
    oss << "Packet counter is greater than before of " << (Counter - prevPckCounter);
    logger->error(oss.str().c_str());
  }
  
  if ((OrbitalTime == prevPckOBT) && (PacketId1 == 0x10) && (initPos > 16)) {
    oss.str("");
    oss << "Onboard Time of this packet is equal to the previous packet OBT";
    logger->error(oss.str().c_str());
    logger->error(Header->GetPscuHeader()->Print());
  }

  if ((OrbitalTime < prevPckOBT) && (initPos > 16)) {
    oss.str("");
    oss << " Onboard Time is less than before of " << (prevPckOBT - OrbitalTime);
    logger->error(oss.str().c_str());
  }

  if ( ((BYTE)CM_Compute_CRC16(0, (BYTE*)header, 15) == (BYTE)header[15]) && (PacketId1 == PacketId2)){
    prevPckCounter = Counter;
    prevPckOBT     = OrbitalTime;
    long int finalPos;
    Header->GetPscuHeader()->SetPacketId(PacketId1, PacketId2);
    Header->GetPscuHeader()->SetCounter(Counter);
    Header->GetPscuHeader()->SetOrbitalTime(OrbitalTime);
    //PacketLength is the length of the whole DATApacket starting from the first byte after the header
    //plus the CRC legth (which varies for each type of packet)
    Header->GetPscuHeader()->SetPacketLenght(PacketLenght);
    Header->GetPscuHeader()->SetCRC(CRC);
    Header->GetPscuHeader()->SetFileOffset(((long int)(InputFile->tellg()) - 16));
  } else {
     //Here i should extract the block of Data for later analysis 
    InputFile->seekg(-(13), std::ios::cur);
    oss.str("");
    oss << "CRC Header Error on packet:" << PscuHeader::Print((char*)header);
    throw WrongCRCHeaderException(oss.str().c_str());
  }

  if (response > 0){
    oss.str("");
    oss << "Packet counter is less than before of " << response;
    throw BackwardCounterException(oss.str().c_str());
  }
}


/**
 * Unpack the trailer of a PSCU event into the structure.
 */
void EventReader::UnpackPscuTrailer(void) throw (std::exception) {

}

int EventReader::archiveCorruptedPacket(long int offset, long int length) {
        if (!corruptedPacketFile.is_open()) {
                oss.str("");
                oss << Run->GetUnpackPath().c_str() << "Corrupted.dat";
                cout << oss.str().c_str() << "\n";
                cout << dec << offset << "\n";
                cout << dec << length << "\n";
                corruptedPacketFile.open(oss.str().c_str(), ios::out);
        }
        char *buffer = new char[length];
        InputFile->seekg(offset, ios_base::beg );
        InputFile->read(buffer, length);
        corruptedPacketFile.write(buffer, length);
        InputFile->seekg(offset + 1, ios_base::beg );
}

/**
 * Find the next starting poin for the PSCU event looking for a {0xFA, 0xFE, 0xDE} sequence
 */
bool EventReader::FindStart(unsigned char *header, long lenght) throw (std::exception) {
//search an hexadecimal sequence in a file
//subSign    ------> pointer to the sequence buffer
//subSignDim ------> dimension of the buffer
// at exit
// return true if founds a match (else false)
// subF point rigth after the match, if found. Else EOF.
//Maurizio 15/11/2002-----------------------
  const int subSignDim = 3;
  const unsigned char subSign[subSignDim]={0xFA, 0xFE, 0xDE};
//------------------------------------------
  int subIndex = 0;
  char dataByte;
 
  int  buffSize = 64;
  int  index = 0;
  char buffer[buffSize];
  char *offset;
  bool flagOverPad = false;

  while (!InputFile->eof()) {
    InputFile->read(buffer, buffSize);
    index = 0;
    offset = &buffer[0];
    while (index < buffSize - 3){
        if (!(memcmp(offset, subSign, 3))){
                InputFile->seekg(index - buffSize + 16, std::ios::cur);
                if (flagOverPad){
                        oss.str("");
                        oss << "\n This packet beginning is farther than 64 byte from the end of the previous."
                        << "\n Below the is the last already unpacked packet";
                        logger->error(oss.str().c_str());
                        logger->error(Header->GetPscuHeader()->Print());
                }
                memcpy(header, offset, lenght);
                return true;
        }
        index++;
        offset++;
    }
    //Needs to guarantee the overap of the buffer(s) in several loop
    flagOverPad = true;
    InputFile->seekg( -3 , std::ios::cur);
  }
  return false;
} 

ClassImp(EventReader)
1	/** @file
2	* $Author: kusanagi $
3	* $Date: 2006/05/30 19:58:25 $
4	* $Revision: 6.6 $
5	*
6	* Implementation of the functions of a sample Algorithm class.
7	* This file can be used as a templace to develop your own algorithm.
8	*/
9
10	#include <log4cxx/logger.h>
11	#include "EventReader.h"
12	#include "ReaderAlgorithms.h"
13
14	extern "C" {
15	#include "CRC.h"
16	}
17
18	using namespace pamela;
19	using namespace pamela::techmodel;
20
21	static log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(_T("pamela.techmodel.EventReader"));
22
23	unsigned int EventReader::maxPackets = 0;
24	unsigned int EventReader::prevPckCounter = 0;
25	unsigned int EventReader::prevPckOBT = 0;
26
27
28	/**
29	* Constructor.
30	*/
31	EventReader::EventReader(int packetsLimit = -1):
32	TechmodelAlgorithm(0, "TechmodelEventReader"){
33	EventReader::maxPackets = packetsLimit;
34	logger->debug(_T("Constructor"));
35	Header = new EventHeader();
36
37	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::PhysEndRun, new PhysEndRunReader));
38	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibCalPulse1, new CalibCalPulse1Reader));
39	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibCalPulse2, new CalibCalPulse2Reader));
40	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Physics, new PhysicsReader));
41	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibTrkBoth, new CalibTrkBothReader));
42	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibTrk1, new CalibTrk1Reader));
43	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibTrk2, new CalibTrk2Reader));
44	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibTof, new CalibTofReader));
45	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibS4, new CalibS4Reader));
46	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibCalPed, new CalibCalPedReader));
47	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Calib1_Ac1, new Calib1_Ac1Reader));
48	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Calib2_Ac1, new Calib2_Ac1Reader));
49	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Calib1_Ac2, new Calib1_Ac2Reader));
50	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Calib2_Ac2, new Calib2_Ac2Reader));
51	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibCal, new CalibCalReader));
52	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::RunHeader, new RunHeaderReader));
53	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::RunTrailer, new RunTrailerReader));
54	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibHeader, new CalibHeaderReader));
55	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalibTrailer, new CalibTrailerReader));
56	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::InitHeader, new InitHeaderReader));
57	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::InitTrailer, new InitTrailerReader));
58	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::EventTrk, new EventTrkReader));
59	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Log, new LogReader));
60	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::VarDump, new VarDumpReader));
61	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::ArrDump, new ArrDumpReader));
62	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::TabDump, new TabDumpReader));
63	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Tmtc, new TmtcReader));
64	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Mcmd, new McmdReader));
65	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::ForcedFECmd, new ForcedFECmdReader));
66	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Ac1Init, new Ac1InitReader));
67	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalInit, new CalInitReader));
68	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::TrkInit, new TrkInitReader));
69	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::TofInit, new TofInitReader));
70	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::TrgInit, new TrgInitReader));
71	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::NdInit, new NdInitReader));
72	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::S4Init, new S4InitReader));
73	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Ac2Init, new Ac2InitReader));
74	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::CalAlarm, new CalAlarmReader));
75	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Ac1Alarm, new Ac1AlarmReader));
76	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::TrkAlarm, new TrkAlarmReader));
77	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::TrgAlarm, new TrgAlarmReader));
78	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::TofAlarm, new TofAlarmReader));
79	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::S4Alarm, new S4AlarmReader));
80	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::Ac2Alarm, new Ac2AlarmReader));
81	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::TsbT, new TsbTReader));
82	TechmodelAlgorithmMap.insert(AlgorithmMap::value_type(PacketType::TsbB, new TsbBReader));
83	}
84
85	/**
86	* Get a string with the version info of the algorithm.
87	*/
88	std::string EventReader::GetVersionInfo(void) const {
89	return
90	"$Header: /home/cvsmanager/yoda/techmodel/EventReader.cpp,v 6.6 2006/05/30 19:58:25 kusanagi Exp $\n";
91	}
92
93	/**
94	* Initialize the algorithm with a special run. This will initialize the
95	* event reader routines for all packet types.
96	*/
97	void EventReader::Init(PamelaRun *run) {
98	SetInputStream(run);
99	//Create the structure of directories and create xxx.Header.root files
100	run->WriteHeaders(this, &Header);
101
102	//Create the xxx.root in it's specific directory
103	for (AlgorithmMap::iterator i = TechmodelAlgorithmMap.begin();
104	i != TechmodelAlgorithmMap.end(); i++) {
105	oss.str("");
106	oss << "Initializing algo " << i->second->GetAlgorithmName();
107	logger->debug(oss.str().c_str());
108	i->second->Init(run);
109	}
110	Run = dynamic_cast<TechmodelPamelaRun*>(run);
111	}
112
113	static void SkipToNextHeader(ifstream *);
114
115	/**
116	* Read the next event header, call the reader algorithms that
117	* correspond to its packet type, and read the event trailer.
118	*/
119	void EventReader::RunEvent(int EventNumber) {
120	stringstream oss;
121	int step = 0;
122	const PacketType* type;
123	unsigned char *header;
124	while (!InputFile->eof() && ((step++ < maxPackets) \|\| (maxPackets == 0))){
125	try {
126	if (FindStart(*&header, 16)) {
127	UnpackPscuHeader(*&header);
128	type = Header->GetPscuHeader()->GetPacketType();
129	AlgorithmMap::iterator i = TechmodelAlgorithmMap.find(type);
130	if (i != TechmodelAlgorithmMap.end()) {
131	TechmodelAlgorithm *EventAlgorithm(i->second);
132	EventAlgorithm->RunEvent(EventNumber, Header->GetPscuHeader()->GetPacketLenght());
133	Run->FillTrees(type);
134	Header->GetCounter()->Increment(type);
135	logger->info(Header->GetPscuHeader()->Print());
136	} else {
137	oss.str("");
138	oss << "\n No way to read events of type " << type->GetName().c_str() << Header->GetPscuHeader()->Print();
139	throw NotExistingAlgorithmException(oss.str().c_str()); //to exctract to an higher level and delete the logger!
140	}
141	}
142	// In case of exception have to save the packet in a specific root file??
143	} catch (NotExistingAlgorithmException exc) {
144	oss.str("");
145	oss << exc.print() << " " << Header->GetPscuHeader()->Print();
146	logger->error(oss.str().c_str());
147	} catch (WrongCRCHeaderException exc) {
148	oss.str("");
149	oss << exc.print();
150	logger->error(oss.str().c_str());
151	} catch (WrongCRCException exc) {
152	oss.str("");
153	oss << exc.print() << " " << Header->GetPscuHeader()->Print();
154	logger->error(oss.str().c_str());
155	archiveCorruptedPacket(Header->GetPscuHeader()->FileOffset, Header->GetPscuHeader()->PacketLenght);
156	} catch (UnidentifiedPacketException exc) {
157	oss.str("");
158	oss << exc.print() << " " << Header->GetPscuHeader()->Print();
159	logger->error(oss.str().c_str());
160	} catch (NotExistingCounterException exc) {
161	oss.str("");
162	oss << exc.print() << " " << Header->GetPscuHeader()->Print();
163	logger->error(oss.str().c_str());
164	} catch (LengthException exc) {
165	oss.str("");
166	oss << exc.print() << " " << Header->GetPscuHeader()->Print();
167	logger->error(oss.str().c_str());
168	} catch (BackwardCounterException exc) {
169	oss.str("");
170	oss << exc.print() << " " << Header->GetPscuHeader()->Print();
171	logger->error(oss.str().c_str());
172	} catch (...) {
173	logger->error("Couldn't read the event. Skipping to the next header. \n");
174	}
175	if ((step%1000) == 0) std::cout << step/1000 << "K \n";
176	oss.str("");
177	oss << "----endPck " << Header->GetPscuHeader()->GetCounter() << "\n";
178	logger->info(oss.str().c_str());
179	}
180	Header->GetCounter()->PrintCounters();
181	//if (corruptedPacketFile.is_open()) corruptedPacketFile.close();
182	}
183
184	/**
185	* Unpack the PSCU header from a file into the structure.
186	*/
187	void EventReader::UnpackPscuHeader(unsigned char *header) throw (WrongCRCHeaderException, LengthException, BackwardCounterException) {
188	if (header == NULL) throw LengthException("errore di lunghezza");
189	stringstream oss;
190	int response = 0;
191
192	unsigned char PacketId1 = header[3];
193	unsigned char PacketId2 = header[4];
194	unsigned int Counter = (((UINT32)header[5]<<16)&0x00FF0000) + (((UINT32)header[6]<<8)&0x0000FF00) + (((UINT32)header[7])&0x000000FF);
195	unsigned int OrbitalTime = (((UINT32)header[8]<<24)&0xFF000000) + (((UINT32)header[9]<<16)&0x00FF0000) + (((UINT32)header[10]<<8)&0x0000FF00) + (((UINT32)header[11])&0x000000FF);
196	unsigned int PacketLenght = (((UINT32)header[12]<<16)&0x00FF0000) + (((UINT32)header[13]<<8)&0x0000FF00) + (((UINT32)header[14])&0x000000FF);
197	unsigned char CRC = header[15];
198	unsigned char FileOffset = header[15];
199
200	long int initPos = InputFile->tellg();
201	// Check parameters anomalies. If initPos < 16 it is the first packet
202	// (supposing a correct starting packet!)
203	if ((Counter < prevPckCounter) && (initPos > 16)){
204	response = prevPckCounter - Counter;
205	//oss.str("");
206	//oss << "Packet counter is less than before of " << (prevPckCounter - Counter);
207	//throw BackwardCounterException(oss.str().c_str());
208	//logger->error(oss.str().c_str());
209	}
210
211	if ((Counter > prevPckCounter + 1) && (initPos > 16)){
212	oss.str("");
213	oss << "Packet counter is greater than before of " << (Counter - prevPckCounter);
214	logger->error(oss.str().c_str());
215	}
216
217	if ((OrbitalTime == prevPckOBT) && (PacketId1 == 0x10) && (initPos > 16)) {
218	oss.str("");
219	oss << "Onboard Time of this packet is equal to the previous packet OBT";
220	logger->error(oss.str().c_str());
221	logger->error(Header->GetPscuHeader()->Print());
222	}
223
224	if ((OrbitalTime < prevPckOBT) && (initPos > 16)) {
225	oss.str("");
226	oss << " Onboard Time is less than before of " << (prevPckOBT - OrbitalTime);
227	logger->error(oss.str().c_str());
228	}
229
230	if ( ((BYTE)CM_Compute_CRC16(0, (BYTE*)header, 15) == (BYTE)header[15]) && (PacketId1 == PacketId2)){
231	prevPckCounter = Counter;
232	prevPckOBT = OrbitalTime;
233	long int finalPos;
234	Header->GetPscuHeader()->SetPacketId(PacketId1, PacketId2);
235	Header->GetPscuHeader()->SetCounter(Counter);
236	Header->GetPscuHeader()->SetOrbitalTime(OrbitalTime);
237	//PacketLength is the length of the whole DATApacket starting from the first byte after the header
238	//plus the CRC legth (which varies for each type of packet)
239	Header->GetPscuHeader()->SetPacketLenght(PacketLenght);
240	Header->GetPscuHeader()->SetCRC(CRC);
241	Header->GetPscuHeader()->SetFileOffset(((long int)(InputFile->tellg()) - 16));
242	} else {
243	//Here i should extract the block of Data for later analysis
244	InputFile->seekg(-(13), std::ios::cur);
245	oss.str("");
246	oss << "CRC Header Error on packet:" << PscuHeader::Print((char*)header);
247	throw WrongCRCHeaderException(oss.str().c_str());
248	}
249
250	if (response > 0){
251	oss.str("");
252	oss << "Packet counter is less than before of " << response;
253	throw BackwardCounterException(oss.str().c_str());
254	}
255	}
256
257
258	/**
259	* Unpack the trailer of a PSCU event into the structure.
260	*/
261	void EventReader::UnpackPscuTrailer(void) throw (std::exception) {
262
263	}
264
265	int EventReader::archiveCorruptedPacket(long int offset, long int length) {
266	if (!corruptedPacketFile.is_open()) {
267	oss.str("");
268	oss << Run->GetUnpackPath().c_str() << "Corrupted.dat";
269	cout << oss.str().c_str() << "\n";
270	cout << dec << offset << "\n";
271	cout << dec << length << "\n";
272	corruptedPacketFile.open(oss.str().c_str(), ios::out);
273	}
274	char *buffer = new char[length];
275	InputFile->seekg(offset, ios_base::beg );
276	InputFile->read(buffer, length);
277	corruptedPacketFile.write(buffer, length);
278	InputFile->seekg(offset + 1, ios_base::beg );
279	}
280
281	/**
282	* Find the next starting poin for the PSCU event looking for a {0xFA, 0xFE, 0xDE} sequence
283	*/
284	bool EventReader::FindStart(unsigned char *header, long lenght) throw (std::exception) {
285	//search an hexadecimal sequence in a file
286	//subSign ------> pointer to the sequence buffer
287	//subSignDim ------> dimension of the buffer
288	// at exit
289	// return true if founds a match (else false)
290	// subF point rigth after the match, if found. Else EOF.
291	//Maurizio 15/11/2002-----------------------
292	const int subSignDim = 3;
293	const unsigned char subSign[subSignDim]={0xFA, 0xFE, 0xDE};
294	//------------------------------------------
295	int subIndex = 0;
296	char dataByte;
297
298	int buffSize = 64;
299	int index = 0;
300	char buffer[buffSize];
301	char *offset;
302	bool flagOverPad = false;
303
304	while (!InputFile->eof()) {
305	InputFile->read(buffer, buffSize);
306	index = 0;
307	offset = &buffer[0];
308	while (index < buffSize - 3){
309	if (!(memcmp(offset, subSign, 3))){
310	InputFile->seekg(index - buffSize + 16, std::ios::cur);
311	if (flagOverPad){
312	oss.str("");
313	oss << "\n This packet beginning is farther than 64 byte from the end of the previous."
314	<< "\n Below the is the last already unpacked packet";
315	logger->error(oss.str().c_str());
316	logger->error(Header->GetPscuHeader()->Print());
317	}
318	memcpy(header, offset, lenght);
319	return true;
320	}
321	index++;
322	offset++;
323	}
324	//Needs to guarantee the overap of the buffer(s) in several loop
325	flagOverPad = true;
326	InputFile->seekg( -3 , std::ios::cur);
327	}
328	return false;
329	}
330
331	ClassImp(EventReader)