PamVMC/include/PamVMCRawMgr.h

#ifndef PAMVMCRAWMGR_H
#define PAMVMCRAWMGR_H
#include "CRC.h"
#include <iostream>
#include <fstream>
#include <vector>
#include <stdlib.h>
#include <TObject.h>
#include <TRandom.h>
#include "TString.h"

using namespace std;

typedef vector<char>     PamVMCBuffer;
typedef vector<UChar_t>  UCBuffer;
typedef vector<UShort_t> USBuffer;

class PamVMCRawMgr: public TObject {

 private:

  static PamVMCRawMgr * frm;

  UInt_t fCounter;
  UInt_t fCounterPhys;
  UInt_t fOBT;

  const char* fFilename;
  std::ofstream fFile;


  UInt_t fLen;

  UCBuffer fEvtDataPSCU;   //event
  UCBuffer fEvtDataPadding;
  UInt_t fEvtPadding;

  //++++++++++//
  //  BUFFER  //
  //++++++++++//

  PamVMCBuffer* fbuffer;

 protected:
  PamVMCRawMgr() {
    fCounter=fCounterPhys=fOBT=0;
    fbuffer = new PamVMCBuffer(0);
  };

 public:
  
  ~PamVMCRawMgr(){ 

    delete fbuffer;
    delete fFilename; 
   
  }

  static PamVMCRawMgr * Instance();

  void CreateOutFile(const char* fname){
    fFilename = fname;
    cout<<"OUTPUT RAWFILE: "<<fFilename<<endl;
    fFile.open(fFilename,ios::out | ios::binary);
  }

  UInt_t GetCounter(){ return fCounter; }

  void AddCounter(){ fCounter++; }

  void SetCounter(UInt_t count){ fCounter = count; }

  void AddCounterPhys(){ fCounterPhys++; }

  UInt_t GetCounterPhys(){ return fCounterPhys; }
  
  void SetCounterPhys(UInt_t phcount){ fCounterPhys = phcount; }

  UInt_t GetOBT(){ return fOBT; }

  void SetOBT(UInt_t obt){ fOBT = obt; }

  UInt_t GetLen(){ return fLen; }

  void SetLen(UInt_t len){ fLen = len; }

  void WritePSCU(const UCBuffer* b){ CopyUCharToBuff(b); }
  
  void WritePadding(const UCBuffer* b){ CopyUCharToBuff(b); }

  void WriteEvent(){
    fEvtPadding = 0;
    //fLen=fbuffer->size();
    //AddPadding(fEvtPadding,&fEvtDataPadding);
    UInt_t length = fbuffer->size()+fEvtPadding; // DATA+Padding size;
    DigitizePSCU(length, 0x10, &fEvtDataPSCU);
    
    //cout<<"PADDING "<<fEvtPadding<<" bytes"<<endl;
    UCBuffer::const_iterator p = fEvtDataPSCU.begin();
    while( p!=fEvtDataPSCU.end() )
      {
        char t = char(*p);
        fFile.write(&t,sizeof(char));
        p++;
      }
    fEvtDataPSCU.clear();

    WriteToFile(); //WRITE BUFFER CONTENT TO FILE
    
    if(fEvtPadding){
      UCBuffer::const_iterator p = fEvtDataPadding.begin();
      while( p!=fEvtDataPadding.end() )
        {
          char t = char(*p);
          fFile.write(&t,sizeof(char));
          p++;    
        }    
      fEvtDataPadding.clear();
    }
  }

  void WriteToFile(){
    cout<<"BUFFER SIZE: "<<fbuffer->size()<<endl;
    PamVMCBuffer::const_iterator p = fbuffer->begin();
    while( p!=fbuffer->end() )
      {
        fFile.write(&(*p),sizeof(char));
        p++;
      }
    fbuffer->clear(); //cleaning MAIN buffer
  }

  void FinishRun(){
    WriteToFile();
    Int_t end = EOF;
    char t = char(end);
    fFile.write(&t, sizeof(char));
    fFile.close();
  }

  void CopyUCharToBuff (const UCBuffer * b){
    UCBuffer::const_iterator p = b->begin();
    cout<<"size of UChar DATA:"<<b->size()<<endl;
    while( p!=b->end() )
      {
        //cout<<Int_t(*p)<<endl;
        fbuffer->push_back(char(*p));
        p++;
      }       
  }


  void CopyUShortToBuff (const USBuffer * b){
    USBuffer::const_iterator p = b->begin();
    cout<<"size of UShort DATA:"<<b->size()<<endl;
    UShort_t Data;
    UChar_t tmp[2];
    while( p!=b->end() )
      {
        Data=(*p);
        memcpy(tmp,&Data,sizeof(UShort_t));
        //cout<<Int_t(*p)<<" "<<hex<<tmp[1]<<" "<<hex<<tmp[0]<<endl;
        fbuffer->push_back(char(tmp[1]));
        fbuffer->push_back(char(tmp[0]));
        p++;
      }       
  }


void AddPadding(UInt_t & pad, UCBuffer * b){
  
  Float_t pd0 = (fLen+16)/32.;
  Float_t pd1 = pd0 - (Float_t)Int_t(pd0);
  Float_t padfrac = 32. - pd1 * 32.;
  
  UInt_t padbytes = (UInt_t)padfrac;
  b->clear();
  if ( padbytes > 0 && padbytes < 32 ){
    //
    // here the padding length
    //
    pad = padbytes+32;
    //
    // random padding bytes
    //
    UShort_t Data;
    UChar_t tmp[2];
    for (Int_t ur=0; ur<16; ur++){
      Data=(UShort_t)gRandom->Uniform(0.,RAND_MAX);
      memcpy(tmp,&Data,sizeof(UShort_t));
      //cout<<"DATA"<<hex<<Data<<endl;
      //tmp[1] should be first (swapping bytes)
      //b->push_back(tmp[1]);
      //b->push_back(tmp[0]);
    };
  };

}


void  DigitizePSCU(UInt_t length, UChar_t type, UCBuffer * b){
  //
  UChar_t buff[16];
  //
  // CPU signature
  //  
  buff[0] = 0xFA;
  buff[1] = 0xFE;
  buff[2] = 0xDE;
  //
  // packet type (twice)
  //
  buff[3] = type;
  buff[4] = type;
  //
  // counter
  //
  fCounter++;
  while ( fCounter > 16777215 ){
    fCounter-=16777215;
  };
  //
  buff[5] = (UChar_t)(fCounter >> 16);
  buff[6] = (UChar_t)(fCounter >> 8);
  buff[7] = (UChar_t)fCounter;
  //
  // on board time
  //
  ULong64_t obt = fOBT + 30LL;
  //
  while ( obt > 4294967295LL ){
    obt -= 4294967295LL;
  };
  fOBT = UInt_t(obt);
  //
  buff[8] = (UChar_t)(fOBT >> 24);
  buff[9] = (UChar_t)(fOBT >> 16);
  buff[10] = (UChar_t)(fOBT >> 8);
  buff[11] = (UChar_t)fOBT;
  //
  // Packet length
  //
  fLen = length;
  //
  buff[12] = (UChar_t)(fLen >> 16);
  buff[13] = (UChar_t)(fLen >> 8) ;
  buff[14] = (UChar_t)fLen;
  //
  // CPU header CRC
  //
  buff[15] = (BYTE)CM_Compute_CRC16((UINT16)0, (BYTE*)&buff, (UINT32)15);

  cout<<"Digitizer::DigitizePSCU...  OK " <<endl;

  b->clear();

  for (Int_t i=0; i<16; i++)  b->push_back(buff[i]);
}


  void PrintBinaryUns(unsigned char val){
    for(Int_t i =7; i>=0; i--){
      if(val & (1<<i))
        cout<<"1";
      else
        cout<<"0";
    };
    cout<<endl;    
  }

 
};
#endif
1	nikolas	1.1	#ifndef PAMVMCRAWMGR_H
2			#define PAMVMCRAWMGR_H
3			#include "CRC.h"
4			#include <iostream>
5			#include <fstream>
6			#include <vector>
7	pam-rm2	1.5	#include <stdlib.h>
8	nikolas	1.1	#include <TObject.h>
9	pam-rm2	1.5	#include <TRandom.h>
10	nikolas	1.1	#include "TString.h"
11
12			using namespace std;
13
14			typedef vector<char> PamVMCBuffer;
15			typedef vector<UChar_t> UCBuffer;
16			typedef vector<UShort_t> USBuffer;
17
18			class PamVMCRawMgr: public TObject {
19
20			private:
21
22			static PamVMCRawMgr * frm;
23
24			UInt_t fCounter;
25			UInt_t fCounterPhys;
26			UInt_t fOBT;
27
28	pam-rm2	1.5	const char* fFilename;
29	nikolas	1.1	std::ofstream fFile;
30
31
32			UInt_t fLen;
33
34			UCBuffer fEvtDataPSCU; //event
35			UCBuffer fEvtDataPadding;
36			UInt_t fEvtPadding;
37
38			//++++++++++//
39			// BUFFER //
40			//++++++++++//
41
42			PamVMCBuffer* fbuffer;
43
44			protected:
45			PamVMCRawMgr() {
46			fCounter=fCounterPhys=fOBT=0;
47			fbuffer = new PamVMCBuffer(0);
48			};
49
50			public:
51
52			~PamVMCRawMgr(){
53
54			delete fbuffer;
55			delete fFilename;
56
57			}
58
59			static PamVMCRawMgr * Instance();
60
61	pam-rm2	1.5	void CreateOutFile(const char* fname){
62			fFilename = fname;
63			cout<<"OUTPUT RAWFILE: "<<fFilename<<endl;
64			fFile.open(fFilename,ios::out \| ios::binary);
65			}
66
67	nikolas	1.1	UInt_t GetCounter(){ return fCounter; }
68
69			void AddCounter(){ fCounter++; }
70
71			void SetCounter(UInt_t count){ fCounter = count; }
72
73			void AddCounterPhys(){ fCounterPhys++; }
74
75			UInt_t GetCounterPhys(){ return fCounterPhys; }
76
77			void SetCounterPhys(UInt_t phcount){ fCounterPhys = phcount; }
78
79			UInt_t GetOBT(){ return fOBT; }
80
81			void SetOBT(UInt_t obt){ fOBT = obt; }
82
83			UInt_t GetLen(){ return fLen; }
84
85			void SetLen(UInt_t len){ fLen = len; }
86
87			void WritePSCU(const UCBuffer* b){ CopyUCharToBuff(b); }
88
89			void WritePadding(const UCBuffer* b){ CopyUCharToBuff(b); }
90
91			void WriteEvent(){
92			fEvtPadding = 0;
93			//fLen=fbuffer->size();
94			//AddPadding(fEvtPadding,&fEvtDataPadding);
95			UInt_t length = fbuffer->size()+fEvtPadding; // DATA+Padding size;
96			DigitizePSCU(length, 0x10, &fEvtDataPSCU);
97
98			//cout<<"PADDING "<<fEvtPadding<<" bytes"<<endl;
99			UCBuffer::const_iterator p = fEvtDataPSCU.begin();
100			while( p!=fEvtDataPSCU.end() )
101			{
102			char t = char(*p);
103			fFile.write(&t,sizeof(char));
104			p++;
105			}
106			fEvtDataPSCU.clear();
107
108			WriteToFile(); //WRITE BUFFER CONTENT TO FILE
109
110			if(fEvtPadding){
111			UCBuffer::const_iterator p = fEvtDataPadding.begin();
112			while( p!=fEvtDataPadding.end() )
113			{
114			char t = char(*p);
115			fFile.write(&t,sizeof(char));
116			p++;
117			}
118			fEvtDataPadding.clear();
119			}
120			}
121
122			void WriteToFile(){
123			cout<<"BUFFER SIZE: "<<fbuffer->size()<<endl;
124			PamVMCBuffer::const_iterator p = fbuffer->begin();
125			while( p!=fbuffer->end() )
126			{
127			fFile.write(&(*p),sizeof(char));
128			p++;
129			}
130			fbuffer->clear(); //cleaning MAIN buffer
131			}
132
133			void FinishRun(){
134			WriteToFile();
135			Int_t end = EOF;
136			char t = char(end);
137			fFile.write(&t, sizeof(char));
138			fFile.close();
139			}
140
141			void CopyUCharToBuff (const UCBuffer * b){
142			UCBuffer::const_iterator p = b->begin();
143			cout<<"size of UChar DATA:"<<b->size()<<endl;
144			while( p!=b->end() )
145			{
146			//cout<<Int_t(*p)<<endl;
147			fbuffer->push_back(char(*p));
148			p++;
149			}
150			}
151
152
153			void CopyUShortToBuff (const USBuffer * b){
154			USBuffer::const_iterator p = b->begin();
155			cout<<"size of UShort DATA:"<<b->size()<<endl;
156			UShort_t Data;
157			UChar_t tmp[2];
158			while( p!=b->end() )
159			{
160			Data=(*p);
161			memcpy(tmp,&Data,sizeof(UShort_t));
162			//cout<<Int_t(*p)<<" "<<hex<<tmp[1]<<" "<<hex<<tmp[0]<<endl;
163			fbuffer->push_back(char(tmp[1]));
164			fbuffer->push_back(char(tmp[0]));
165			p++;
166			}
167			}
168
169
170			void AddPadding(UInt_t & pad, UCBuffer * b){
171
172			Float_t pd0 = (fLen+16)/32.;
173			Float_t pd1 = pd0 - (Float_t)Int_t(pd0);
174			Float_t padfrac = 32. - pd1 * 32.;
175
176			UInt_t padbytes = (UInt_t)padfrac;
177			b->clear();
178			if ( padbytes > 0 && padbytes < 32 ){
179			//
180			// here the padding length
181			//
182			pad = padbytes+32;
183			//
184			// random padding bytes
185			//
186			UShort_t Data;
187			UChar_t tmp[2];
188			for (Int_t ur=0; ur<16; ur++){
189	pam-rm2	1.5	Data=(UShort_t)gRandom->Uniform(0.,RAND_MAX);
190	nikolas	1.1	memcpy(tmp,&Data,sizeof(UShort_t));
191			//cout<<"DATA"<<hex<<Data<<endl;
192			//tmp[1] should be first (swapping bytes)
193			//b->push_back(tmp[1]);
194			//b->push_back(tmp[0]);
195			};
196			};
197
198			}
199
200
201			void DigitizePSCU(UInt_t length, UChar_t type, UCBuffer * b){
202			//
203			UChar_t buff[16];
204			//
205			// CPU signature
206			//
207			buff[0] = 0xFA;
208			buff[1] = 0xFE;
209			buff[2] = 0xDE;
210			//
211			// packet type (twice)
212			//
213			buff[3] = type;
214			buff[4] = type;
215			//
216			// counter
217			//
218			fCounter++;
219			while ( fCounter > 16777215 ){
220			fCounter-=16777215;
221			};
222			//
223			buff[5] = (UChar_t)(fCounter >> 16);
224			buff[6] = (UChar_t)(fCounter >> 8);
225			buff[7] = (UChar_t)fCounter;
226			//
227			// on board time
228			//
229			ULong64_t obt = fOBT + 30LL;
230			//
231			while ( obt > 4294967295LL ){
232			obt -= 4294967295LL;
233			};
234			fOBT = UInt_t(obt);
235			//
236			buff[8] = (UChar_t)(fOBT >> 24);
237			buff[9] = (UChar_t)(fOBT >> 16);
238			buff[10] = (UChar_t)(fOBT >> 8);
239			buff[11] = (UChar_t)fOBT;
240			//
241			// Packet length
242			//
243			fLen = length;
244			//
245			buff[12] = (UChar_t)(fLen >> 16);
246			buff[13] = (UChar_t)(fLen >> 8) ;
247			buff[14] = (UChar_t)fLen;
248			//
249			// CPU header CRC
250			//
251			buff[15] = (BYTE)CM_Compute_CRC16((UINT16)0, (BYTE*)&buff, (UINT32)15);
252
253			cout<<"Digitizer::DigitizePSCU... OK " <<endl;
254
255			b->clear();
256
257			for (Int_t i=0; i<16; i++) b->push_back(buff[i]);
258			}
259
260
261			void PrintBinaryUns(unsigned char val){
262			for(Int_t i =7; i>=0; i--){
263			if(val & (1<<i))
264			cout<<"1";
265			else
266			cout<<"0";
267			};
268			cout<<endl;
269			}
270
271
272			};
273			#endif