techmodel/physics/AnticounterReader.cpp

/** @file
 * $Source: /home/cvsmanager/yoda/techmodel/physics/AnticounterReader.cpp,v $
 * $Id: AnticounterReader.cpp,v 1.2 2004/08/24 08:00:12 kusanagi Exp $
 * $Author: kusanagi $
 * 
 * Implementation of the AnticounterReader class.
 */

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

extern "C" {
    #include "../forroutines/anticounter/ACphysics.h"
    extern int ACphysics(int length,unsigned short* datapointer,struct datastruct* physicspointer);
    //Struct per il passaggio di dati da e verso la chiamata fortran
}

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 1.2 2004/08/24 08:00:12 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) {
    char *data = new char[length];
    memcpy(data, subData, length);
    int        ERROR;
    datastruct output;
    
    //Call to the routine that unpack anitocounter events
    ERROR = ACphysics(length, (unsigned short*) data, &output);

    //TO BE activated as soon i will know what codes means "error"
    /*if (ERROR != 0) {
        char *errmsg;
        switch (ERROR){
            case 1: errmsg = "---------------------";
        }
    } else {*/
        memcpy(anticounter->header, output.header, sizeof(anticounter->header));
        anticounter->status = output.status;
        anticounter->hitmap = output.hitmap;
        memcpy(anticounter->regist,     output.regist,    sizeof(anticounter->regist));
        memcpy(anticounter->shift,      output.shift,     sizeof(anticounter->shift));
        memcpy(anticounter->counters,   output.counters,  sizeof(anticounter->counters));
        memcpy(anticounter->coinc,      output.coinc,     sizeof(anticounter->coinc));
        anticounter->trigg = output.trigg;
        memcpy(anticounter->clock,      output.clock,     sizeof(anticounter->clock));
        memcpy(anticounter->temp,       output.temp,      sizeof(anticounter->temp));
        memcpy(anticounter->DAC,        output.DAC,       sizeof(anticounter->DAC));
        anticounter->CRC = output.CRC;
    //}
    delete[] data;
}
1	kusanagi	1.1	/** @file
2			* $Source: /home/cvsmanager/yoda/techmodel/physics/AnticounterReader.cpp,v $
3	kusanagi	1.3	* $Id: AnticounterReader.cpp,v 1.2 2004/08/24 08:00:12 kusanagi Exp $
4	kusanagi	1.1	* $Author: kusanagi $
5			*
6			* Implementation of the AnticounterReader class.
7			*/
8
9			#include <string>
10	kusanagi	1.3	#include <log4cxx/logger.h>
11	kusanagi	1.1	#include "AnticounterReader.h"
12
13			extern "C" {
14			#include "../forroutines/anticounter/ACphysics.h"
15			extern int ACphysics(int length,unsigned short* datapointer,struct datastruct* physicspointer);
16			//Struct per il passaggio di dati da e verso la chiamata fortran
17			}
18
19			using namespace pamela;
20			using namespace pamela::anticounter;
21
22	kusanagi	1.3	static log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(_T("pamela.techmodel.anticounter.AnticounterReader"));
23	kusanagi	1.1
24			/**
25			* Constructor.
26			*/
27			AnticounterReader::AnticounterReader(void):
28			TechmodelAlgorithm(PacketType::Physics, "TechmodelAnticounterReader") {
29	kusanagi	1.3	logger->debug(_T("Constructor"));
30	kusanagi	1.1	anticounter = new AnticounterEvent();
31			}
32
33			/**
34			* Get a string with the version info of the algorithm.
35			*/
36			std::string AnticounterReader::GetVersionInfo(void) const {
37			return
38	kusanagi	1.3	"$Header: /home/cvsmanager/yoda/techmodel/physics/AnticounterReader.cpp,v 1.2 2004/08/24 08:00:12 kusanagi Exp $";
39	kusanagi	1.1	}
40
41			/**
42			* Initialize the algorithm with a special run. This will initialize the
43			* event reader routines for all packet types.
44			*/
45			void AnticounterReader::Init(PamelaRun *run) {
46	kusanagi	1.3	logger->debug(_T("Initialize"));
47	kusanagi	1.1	SetInputStream(run);
48			run->WriteSubPacket(this, &anticounter, anticounter->Class());
49			}
50
51			/**
52			* Unpack the anticounter event from an input file.
53			*/
54			void AnticounterReader::RunEvent(int EventNumber) {
55
56			}
57
58			/**
59			* Unpack the Anticounter data event from the physical packet.
60			*/
61			void AnticounterReader::RunEvent(int EventNumber, const char subData[], long int length) {
62	kusanagi	1.3	char *data = new char[length];
63	kusanagi	1.1	memcpy(data, subData, length);
64			int ERROR;
65			datastruct output;
66
67			//Call to the routine that unpack anitocounter events
68			ERROR = ACphysics(length, (unsigned short*) data, &output);
69
70	kusanagi	1.2	//TO BE activated as soon i will know what codes means "error"
71			/*if (ERROR != 0) {
72			char *errmsg;
73			switch (ERROR){
74			case 1: errmsg = "---------------------";
75			}
76			} else {*/
77			memcpy(anticounter->header, output.header, sizeof(anticounter->header));
78			anticounter->status = output.status;
79			anticounter->hitmap = output.hitmap;
80			memcpy(anticounter->regist, output.regist, sizeof(anticounter->regist));
81			memcpy(anticounter->shift, output.shift, sizeof(anticounter->shift));
82			memcpy(anticounter->counters, output.counters, sizeof(anticounter->counters));
83			memcpy(anticounter->coinc, output.coinc, sizeof(anticounter->coinc));
84			anticounter->trigg = output.trigg;
85			memcpy(anticounter->clock, output.clock, sizeof(anticounter->clock));
86			memcpy(anticounter->temp, output.temp, sizeof(anticounter->temp));
87			memcpy(anticounter->DAC, output.DAC, sizeof(anticounter->DAC));
88			anticounter->CRC = output.CRC;
89			//}
90	kusanagi	1.3	delete[] data;
91	kusanagi	1.1	}