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	#ifndef PAMVMCRAWMGR_H
2	#define PAMVMCRAWMGR_H
3	#include "CRC.h"
4	#include <iostream>
5	#include <fstream>
6	#include <vector>
7	#include <stdlib.h>
8	#include <TObject.h>
9	#include <TRandom.h>
10	#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	const char* fFilename;
29	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	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	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	Data=(UShort_t)gRandom->Uniform(0.,RAND_MAX);
190	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