techmodel/physics/AnticounterReader.cpp

/** @file
 * $Source: /home/cvsmanager/yoda/techmodel/physics/AnticounterReader.cpp,v $
 * $Id: AnticounterReader.cpp,v 6.1 2006/03/08 08:17:06 kusanagi Exp $
 * $Author: kusanagi $
 * 
 * Implementation of the AnticounterReader class.
 */

#include <string>
#include <log4cxx/logger.h>
#include "AnticounterReader.h"

extern "C" {
    #include "../forroutines/anticounter/AC.h"
    extern int ACphysics(int, unsigned char[] , struct physicsstruct*);
}

using namespace pamela;
using namespace pamela::anticounter;

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

/**
 * Constructor. 
 */
AnticounterReader::AnticounterReader(void): 
  TechmodelAlgorithm(PacketType::Physics, "TechmodelAnticounterReader") { 
  logger->debug(_T("Constructor"));
  anticounter = new AnticounterEvent();
}

/**
 * Get a string with the version info of the algorithm.
 */
std::string AnticounterReader::GetVersionInfo(void) const {
  return 
    "$Header: /home/cvsmanager/yoda/techmodel/physics/AnticounterReader.cpp,v 6.1 2006/03/08 08:17:06 kusanagi Exp $";
}

/**
 * Initialize the algorithm with a special run. This will initialize the
 * event reader routines for all packet types.
 */
void AnticounterReader::Init(PamelaRun *run) {
  logger->debug(_T("Initialize"));
  SetInputStream(run);
  run->WriteSubPacket(this, &anticounter, anticounter->Class());
}

/**
 * Unpack the anticounter event from an input file.
 */
void AnticounterReader::RunEvent(int EventNumber) {
  
}

/**
 * Unpack the Anticounter data event from the physical packet.
 */
void AnticounterReader::RunEvent(int EventNumber, const char subData[], long int length) {
    std::stringstream oss;
    char *data = new char[length];
    memcpy(data, subData, length);
    struct physicsstruct output[2] = {0};
    
    
    //Call to the routine that unpack anitocounter events
    //anticounter->ERROR = ACphysics(length, (unsigned char*) data, &(*output));
    anticounter->unpackError = ACphysics(length, (unsigned char*) data, output);
    
        oss.str("");
        switch (anticounter->unpackError){
            case 0xFF: 
            oss << "Anticounter unpacking: " << "data (physics or calibration) from both cards found";
            logger->debug(oss.str().c_str());
            break;
            case 0xF0: 
            oss << "Anticounter unpacking: " << "only data from main card found";
            logger->error(oss.str().c_str());
            break;
            case 0x0F: 
            oss << "Anticounter unpacking: " << "only data from extra card found";
            logger->error(oss.str().c_str());
            break;
            case 0x00: 
            oss << "Anticounter unpacking: " << "no data found";
            logger->error(oss.str().c_str());
            break;
            oss << "Anticounter unpacking: " << "ANTICOUNTER ERRROR CODE UNIDENTIFIED";
            logger->error(oss.str().c_str());
        }


    for(int i = 0; i<2; i++){
        memcpy(anticounter->header[i], output[i].header, sizeof(anticounter->header[i]));
        anticounter->status[i] = output[i].status;
        anticounter->hitmap[i] = output[i].hitmap;
        memcpy(anticounter->regist[i],     output[i].regist,    sizeof(output[i].regist));
        memcpy(anticounter->shift[i],      output[i].shift,     sizeof(output[i].shift));
        memcpy(anticounter->counters[i],   output[i].counters,  sizeof(output[i].counters));
        memcpy(anticounter->coinc[i],      output[i].coinc,     sizeof(output[i].coinc));
        anticounter->trigg[i] = output[i].trigg;
        memcpy(anticounter->clock[i],      output[i].clock,     sizeof(output[i].clock));
        memcpy(anticounter->temp[i],       output[i].temp,      sizeof(output[i].temp));
        memcpy(anticounter->DAC[i],        output[i].DAC,       sizeof(output[i].DAC));
        anticounter->CRC[i]         = output[i].CRC;
        anticounter->CRCcheck[i]    = output[i].CRCcheck;
    }

    //}
    delete [] data;
}
1	/** @file
2	* $Source: /home/cvsmanager/yoda/techmodel/physics/AnticounterReader.cpp,v $
3	* $Id: AnticounterReader.cpp,v 6.1 2006/03/08 08:17:06 kusanagi Exp $
4	* $Author: kusanagi $
5	*
6	* Implementation of the AnticounterReader class.
7	*/
8
9	#include <string>
10	#include <log4cxx/logger.h>
11	#include "AnticounterReader.h"
12
13	extern "C" {
14	#include "../forroutines/anticounter/AC.h"
15	extern int ACphysics(int, unsigned char[] , struct physicsstruct*);
16	}
17
18	using namespace pamela;
19	using namespace pamela::anticounter;
20
21	static log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(_T("pamela.techmodel.anticounter.AnticounterReader"));
22
23	/**
24	* Constructor.
25	*/
26	AnticounterReader::AnticounterReader(void):
27	TechmodelAlgorithm(PacketType::Physics, "TechmodelAnticounterReader") {
28	logger->debug(_T("Constructor"));
29	anticounter = new AnticounterEvent();
30	}
31
32	/**
33	* Get a string with the version info of the algorithm.
34	*/
35	std::string AnticounterReader::GetVersionInfo(void) const {
36	return
37	"$Header: /home/cvsmanager/yoda/techmodel/physics/AnticounterReader.cpp,v 6.1 2006/03/08 08:17:06 kusanagi Exp $";
38	}
39
40	/**
41	* Initialize the algorithm with a special run. This will initialize the
42	* event reader routines for all packet types.
43	*/
44	void AnticounterReader::Init(PamelaRun *run) {
45	logger->debug(_T("Initialize"));
46	SetInputStream(run);
47	run->WriteSubPacket(this, &anticounter, anticounter->Class());
48	}
49
50	/**
51	* Unpack the anticounter event from an input file.
52	*/
53	void AnticounterReader::RunEvent(int EventNumber) {
54
55	}
56
57	/**
58	* Unpack the Anticounter data event from the physical packet.
59	*/
60	void AnticounterReader::RunEvent(int EventNumber, const char subData[], long int length) {
61	std::stringstream oss;
62	char *data = new char[length];
63	memcpy(data, subData, length);
64	struct physicsstruct output[2] = {0};
65
66
67
68	//Call to the routine that unpack anitocounter events
69	//anticounter->ERROR = ACphysics(length, (unsigned char) data, &(output));
70	anticounter->unpackError = ACphysics(length, (unsigned char*) data, output);
71
72	oss.str("");
73	switch (anticounter->unpackError){
74	case 0xFF:
75	oss << "Anticounter unpacking: " << "data (physics or calibration) from both cards found";
76	logger->debug(oss.str().c_str());
77	break;
78	case 0xF0:
79	oss << "Anticounter unpacking: " << "only data from main card found";
80	logger->error(oss.str().c_str());
81	break;
82	case 0x0F:
83	oss << "Anticounter unpacking: " << "only data from extra card found";
84	logger->error(oss.str().c_str());
85	break;
86	case 0x00:
87	oss << "Anticounter unpacking: " << "no data found";
88	logger->error(oss.str().c_str());
89	break;
90	oss << "Anticounter unpacking: " << "ANTICOUNTER ERRROR CODE UNIDENTIFIED";
91	logger->error(oss.str().c_str());
92	}
93
94
95	for(int i = 0; i<2; i++){
96	memcpy(anticounter->header[i], output[i].header, sizeof(anticounter->header[i]));
97	anticounter->status[i] = output[i].status;
98	anticounter->hitmap[i] = output[i].hitmap;
99	memcpy(anticounter->regist[i], output[i].regist, sizeof(output[i].regist));
100	memcpy(anticounter->shift[i], output[i].shift, sizeof(output[i].shift));
101	memcpy(anticounter->counters[i], output[i].counters, sizeof(output[i].counters));
102	memcpy(anticounter->coinc[i], output[i].coinc, sizeof(output[i].coinc));
103	anticounter->trigg[i] = output[i].trigg;
104	memcpy(anticounter->clock[i], output[i].clock, sizeof(output[i].clock));
105	memcpy(anticounter->temp[i], output[i].temp, sizeof(output[i].temp));
106	memcpy(anticounter->DAC[i], output[i].DAC, sizeof(output[i].DAC));
107	anticounter->CRC[i] = output[i].CRC;
108	anticounter->CRCcheck[i] = output[i].CRCcheck;
109	}
110
111	//}
112	delete [] data;
113	}