techmodel/physics/TofReader.cpp

/** @file
 * $Source: /home/cvsmanager/yoda/techmodel/physics/TofReader.cpp,v $
 * $Id: TofReader.cpp,v 4.0 2005/03/06 04:33:02 kusanagi Exp $
 * $Author: kusanagi $
 * 
 * Implementation of the CalorimeterReader class.
 */


#include <iostream>
#include <string>
#include <log4cxx/logger.h>
#include "TofReader.h"

extern "C" {
  

 extern struct {
        int         tdcid[12];
        int         evcount[12];
        int         tdcmask[12];
        int         adc[4][12];
        int         tdc[4][12];
        int         temp1[12];
        int         temp2[12];

    } tofvar_; 

  void tofunpack_(unsigned char[], long int*, int*);

    //Struct per il passaggio di dati da e verso la chiamata fortran
}

using namespace pamela;
using namespace pamela::tof;

static log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(_T("pamela.techmodel.tof.TofReader"));
 
/**
 * Constructor.     
 */
TofReader::TofReader(void): 
  TechmodelAlgorithm(PacketType::Physics, "TechmodelTofReader") { 
  logger->debug(_T("Construnctor"));
  tof = new TofEvent();
}

/**
 * Get a string with the version info of the algorithm.
 */
std::string TofReader::GetVersionInfo(void) const {
  return 
    "$Header: /home/cvsmanager/yoda/techmodel/physics/TofReader.cpp,v 4.0 2005/03/06 04:33:02 kusanagi Exp $";
}

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

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

/**
 * Unpack the Tof data event from the physical packet.
 */
void TofReader::RunEvent(int EventNumber, const char subData[], long int length) {
    std::stringstream oss;       
    char *data = new char[length];
    memcpy(data, subData, length);
    int  ERROR = 0;
    
    /*unsigned short convdata[length];
    for (int i = 0; i<length; i++){
        convdata[i] = (unsigned short)((unsigned char)subData[i]&0xFF);
    }*/

    
    //Call to the routine that unpack tof events
    tofunpack_((unsigned char*)data, &length, &ERROR);
    

    if (ERROR != 0) {
        char *errmsg;
        switch (ERROR){
            case 1: errmsg = "GENERIC TOF ERROR";
            break;
            default: errmsg = "TOF ERRROR CODE UNIDENTIFIED";
        }
        oss.str("");
        oss << "Fortran77 function tofunpack: " <<  errmsg;
        logger->warn(oss.str().c_str());
    }
    //  In case of "ERROR != 0" the calunpack will take care to set all 
    //  parameters to zero
    //} else {
    // only for a variable    tof->tof1int   = evento_.IEV2;
    //        memcpy(tof->tof1int, tofvar_.tof1int, sizeof(tofvar_.tof1int));
    //  printf("tof->tof1int[1] %i \n",tof->tof1int[0]);


    // for (int i = 0; i < 6; i++){
    //  tof->tof1int[i] = tofvar_.tof1int[i];
    //};
    //      printf("tof->tof1int[2] %i \n",tof->tof1int[1]);

        memcpy(tof->tdcid,   tofvar_.tdcid,   sizeof(tof->tdcid));
        memcpy(tof->evcount, tofvar_.evcount, sizeof(tof->evcount));
        memcpy(tof->tdcmask, tofvar_.tdcmask, sizeof(tof->tdcmask));
        memcpy(tof->temp1,   tofvar_.temp1,   sizeof(tof->temp1));
        memcpy(tof->temp2,   tofvar_.temp2,   sizeof(tof->temp2));


    //--------have to invert array because of FORTRAN <-> C different management of the indexes

        //        int temptofmat[6][12];
       
        //        memcpy(temptofmat,         toftest_.tofmat,        sizeof(temptofmat));
     
        //        for (int i = 0; i < 6; i++){
        //            for (int j = 0; j < 12; j++){
        //                tof->tofmat[j][i] = temptofmat[i][j];
                //            }
        //        }

        int        tmpadc[12][4];
        int        tmptdc[12][4];
       
        memcpy(tmpadc,         tofvar_.adc,        sizeof(tmpadc));
        memcpy(tmptdc,         tofvar_.tdc,        sizeof(tmptdc));
          
        for (int i = 0; i < 12; i++){
            for (int j = 0; j < 4; j++){
                tof->adc[j][i] = tmpadc[i][j];
                tof->tdc[j][i] = tmptdc[i][j];
            }
        }
 
    delete [] data;
}
1	kusanagi	2.1	/** @file
2	kusanagi	3.0	* $Source: /home/cvsmanager/yoda/techmodel/physics/TofReader.cpp,v $
3	kusanagi	4.4	* $Id: TofReader.cpp,v 4.0 2005/03/06 04:33:02 kusanagi Exp $
4	kusanagi	2.1	* $Author: kusanagi $
5			*
6			* Implementation of the CalorimeterReader class.
7			*/
8
9
10			#include <iostream>
11			#include <string>
12			#include <log4cxx/logger.h>
13			#include "TofReader.h"
14
15			extern "C" {
16
17
18			extern struct {
19			int tdcid[12];
20			int evcount[12];
21			int tdcmask[12];
22			int adc[4][12];
23			int tdc[4][12];
24			int temp1[12];
25			int temp2[12];
26
27			} tofvar_;
28
29			void tofunpack_(unsigned char[], long int, int);
30
31			//Struct per il passaggio di dati da e verso la chiamata fortran
32			}
33
34			using namespace pamela;
35			using namespace pamela::tof;
36
37			static log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(_T("pamela.techmodel.tof.TofReader"));
38
39			/**
40			* Constructor.
41			*/
42			TofReader::TofReader(void):
43			TechmodelAlgorithm(PacketType::Physics, "TechmodelTofReader") {
44			logger->debug(_T("Construnctor"));
45			tof = new TofEvent();
46			}
47
48			/**
49			* Get a string with the version info of the algorithm.
50			*/
51			std::string TofReader::GetVersionInfo(void) const {
52			return
53	kusanagi	4.4	"$Header: /home/cvsmanager/yoda/techmodel/physics/TofReader.cpp,v 4.0 2005/03/06 04:33:02 kusanagi Exp $";
54	kusanagi	2.1	}
55
56			/**
57			* Initialize the algorithm with a special run. This will initialize the
58			* event reader routines for all packet types.
59			*/
60			void TofReader::Init(PamelaRun *run) {
61			logger->debug(_T("Initialize"));
62			SetInputStream(run);
63			run->WriteSubPacket(this, &tof, tof->Class());
64			}
65
66			/**
67			* Unpack the tof event from an input file.
68			*/
69			void TofReader::RunEvent(int EventNumber) {
70
71			}
72
73			/**
74			* Unpack the Tof data event from the physical packet.
75			*/
76			void TofReader::RunEvent(int EventNumber, const char subData[], long int length) {
77			std::stringstream oss;
78			char *data = new char[length];
79			memcpy(data, subData, length);
80			int ERROR = 0;
81
82			/*unsigned short convdata[length];
83			for (int i = 0; i<length; i++){
84			convdata[i] = (unsigned short)((unsigned char)subData[i]&0xFF);
85			}*/
86
87
88			//Call to the routine that unpack tof events
89			tofunpack_((unsigned char*)data, &length, &ERROR);
90
91
92			if (ERROR != 0) {
93			char *errmsg;
94			switch (ERROR){
95			case 1: errmsg = "GENERIC TOF ERROR";
96	kusanagi	3.1	break;
97			default: errmsg = "TOF ERRROR CODE UNIDENTIFIED";
98	kusanagi	2.1	}
99	kusanagi	3.1	oss.str("");
100	kusanagi	2.1	oss << "Fortran77 function tofunpack: " << errmsg;
101			logger->warn(oss.str().c_str());
102			}
103			// In case of "ERROR != 0" the calunpack will take care to set all
104			// parameters to zero
105			//} else {
106			// only for a variable tof->tof1int = evento_.IEV2;
107			// memcpy(tof->tof1int, tofvar_.tof1int, sizeof(tofvar_.tof1int));
108			// printf("tof->tof1int[1] %i \n",tof->tof1int[0]);
109
110
111			// for (int i = 0; i < 6; i++){
112			// tof->tof1int[i] = tofvar_.tof1int[i];
113			//};
114			// printf("tof->tof1int[2] %i \n",tof->tof1int[1]);
115
116			memcpy(tof->tdcid, tofvar_.tdcid, sizeof(tof->tdcid));
117			memcpy(tof->evcount, tofvar_.evcount, sizeof(tof->evcount));
118			memcpy(tof->tdcmask, tofvar_.tdcmask, sizeof(tof->tdcmask));
119			memcpy(tof->temp1, tofvar_.temp1, sizeof(tof->temp1));
120			memcpy(tof->temp2, tofvar_.temp2, sizeof(tof->temp2));
121
122
123			//--------have to invert array because of FORTRAN <-> C different management of the indexes
124
125			// int temptofmat[6][12];
126
127			// memcpy(temptofmat, toftest_.tofmat, sizeof(temptofmat));
128
129			// for (int i = 0; i < 6; i++){
130			// for (int j = 0; j < 12; j++){
131			// tof->tofmat[j][i] = temptofmat[i][j];
132			// }
133			// }
134
135			int tmpadc[12][4];
136			int tmptdc[12][4];
137
138			memcpy(tmpadc, tofvar_.adc, sizeof(tmpadc));
139			memcpy(tmptdc, tofvar_.tdc, sizeof(tmptdc));
140
141			for (int i = 0; i < 12; i++){
142			for (int j = 0; j < 4; j++){
143			tof->adc[j][i] = tmpadc[i][j];
144			tof->tdc[j][i] = tmptdc[i][j];
145			}
146			}
147
148	kusanagi	3.1	delete [] data;
149	kusanagi	2.1	}