Line data Source code
1 : /**************************************************************************
2 : * Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
3 : * *
4 : * Author: The ALICE Off-line Project. *
5 : * Contributors are mentioned in the code where appropriate. *
6 : * *
7 : * Permission to use, copy, modify and distribute this software and its *
8 : * documentation strictly for non-commercial purposes is hereby granted *
9 : * without fee, provided that the above copyright notice appears in all *
10 : * copies and that both the copyright notice and this permission notice *
11 : * appear in the supporting documentation. The authors make no claims *
12 : * about the suitability of this software for any purpose. It is *
13 : * provided "as is" without express or implied warranty. *
14 : **************************************************************************/
15 : /* $Id$ */
16 :
17 : // Storing digits in a binary file
18 : // according to the DDL mapping
19 : // To be used in Alice Data Challenges
20 : // This class is used by AliTPCDDL.C macro
21 : // Author: D.Favretto
22 :
23 : #include <Riostream.h>
24 : #include <TObjArray.h>
25 : #include "AliTPCBuffer.h"
26 : #include "AliSimDigits.h"
27 :
28 : //#include "TFile.h"
29 : //#include "TTree.h"
30 :
31 : using std::ios;
32 : using std::ofstream;
33 : using std::endl;
34 12 : ClassImp(AliTPCBuffer)
35 : //////////////////////////////////////////////////////////////////////////////////////////////////////////////
36 : //___________________________________________________________
37 0 : AliTPCBuffer::AliTPCBuffer():TObject(),
38 0 : fVerbose(0),
39 0 : fNumberOfDigits(0),
40 0 : f()
41 0 : {
42 : //
43 : // default
44 : //
45 0 : }
46 : //____________________________________________________________
47 4 : AliTPCBuffer::AliTPCBuffer(const char* fileName):TObject(),
48 4 : fVerbose(0),
49 4 : fNumberOfDigits(0),
50 4 : f()
51 20 : {
52 : // Constructor
53 : #ifndef __DECCXX
54 4 : f.open(fileName,ios::binary|ios::out);
55 : #else
56 : f.open(fileName,ios::out);
57 : #endif
58 : // fout=new TFile(fileName,"recreate");
59 : // tree=new TTree("tree","Values");
60 :
61 4 : remove("TPCdigits.txt");
62 8 : }
63 :
64 : //////////////////////////////////////////////////////////////////////////////////////////////////////////////
65 24 : AliTPCBuffer::~AliTPCBuffer(){
66 : // The destructor closes the IO stream
67 4 : f.close();
68 : //delete tree;
69 : //delete fout;
70 12 : }
71 : //////////////////////////////////////////////////////////////////////////////////////////////////////////////
72 0 : AliTPCBuffer::AliTPCBuffer(const AliTPCBuffer &source):TObject(source),
73 0 : fVerbose(0),
74 0 : fNumberOfDigits(0),
75 0 : f()
76 0 : {
77 : // Copy Constructor
78 0 : this->fVerbose=source.fVerbose;
79 0 : return;
80 0 : }
81 : //////////////////////////////////////////////////////////////////////////////////////////////////////////////
82 : AliTPCBuffer& AliTPCBuffer::operator=(const AliTPCBuffer &source){
83 : //Assigment operator
84 0 : if(this!=&source){
85 0 : this->fVerbose=source.fVerbose;
86 0 : }
87 0 : return *this;
88 : }
89 : //////////////////////////////////////////////////////////////////////////////////////////////////////////////
90 : /*
91 : void AliTPCBuffer::WriteRow(Int_t eth,AliSimDigits *digrow,Int_t minPad,Int_t maxPad,Int_t flag,Int_t sec,Int_t SubSec,Int_t row){
92 : //flag=0 the whole row is written to the root file
93 : //flag=1 only value in the range [minPad,MaxPasd] are written to the root file
94 : //flag=2 complementary case of 1
95 : Int_t Pad;
96 : Int_t Dig;
97 : Int_t Time;
98 : tree->Branch("sec",&sec,"sec/I");
99 : tree->Branch("SubSec",&SubSec,"SubSec/I");
100 : tree->Branch("row",&row,"row/I");
101 : tree->Branch("Pad",&Pad,"Pad/I");
102 : tree->Branch("Dig",&Dig,"Dig/I");
103 : tree->Branch("Time",&Time,"Time/I");
104 : digrow->First();
105 : do{
106 : Dig=digrow->CurrentDigit(); //adc
107 : Time=digrow->CurrentRow(); //time
108 : Pad =digrow->CurrentColumn(); // pad
109 : // cout<<"Sec "<<sec<<" row "<<row<<" Pad "<<Pad<<" Dig "<<Dig<<" Time "<<Time<<endl;
110 : if(Dig>eth){
111 : switch (flag){
112 : case 0:{
113 : tree->Fill();
114 : fNumberOfDigits++;
115 : break;
116 : }//end case 0
117 : case 1:{
118 : if((Pad>=minPad)&&(Pad<=maxPad)){
119 : tree->Fill();
120 : fNumberOfDigits++;
121 : }
122 : break;
123 : }//end case 1
124 : case 2:{
125 : if((Pad<minPad)||(Pad>maxPad)){
126 : tree->Fill();
127 : fNumberOfDigits++;
128 : }
129 : break;
130 : }//end case 2
131 : };//end switch
132 : }//end if
133 : }while (digrow->Next());
134 : tree->Write();
135 : return;
136 : }
137 : */
138 : //////////////////////////////////////////////////////////////////////////////////////////////////////////////
139 : void AliTPCBuffer::WriteRowBinary(Int_t eth,AliSimDigits *digrow,Int_t minPad,Int_t maxPad,Int_t flag,Int_t sec,Int_t SubSec,Int_t row){
140 : //It writes TPC digits as par the flag specifications. Being called by AliTPCDDL.C
141 : //flag=0 the whole row is written into the file
142 : //flag=1 only value in the range [minPad,MaxPasd] are written into the file
143 : //flag=2 complementary case of 1
144 :
145 : struct DataPad{
146 : Int_t Sec;
147 : Int_t SubSec;
148 : Int_t Row;
149 : Int_t Pad;
150 : Int_t Dig;
151 : Int_t Time;
152 : };
153 46656 : DataPad data;
154 23328 : data.Sec=sec;
155 23328 : data.SubSec=SubSec;
156 23328 : data.Row=row;
157 36532 : if (!digrow->First()) return;
158 : Int_t padID=-1;
159 : Int_t ddlNumber=0;
160 10124 : ofstream ftxt;
161 10124 : if (fVerbose==2){
162 0 : ftxt.open("TPCdigits.txt",ios::app);
163 0 : if(sec<36)
164 0 : ddlNumber=sec*2+SubSec;
165 : else
166 0 : ddlNumber=72+(sec-36)*4+SubSec;
167 : }//end if
168 : do{
169 938894 : data.Dig=digrow->CurrentDigit(); //adc
170 469447 : data.Time=digrow->CurrentRow(); //time
171 469447 : data.Pad =digrow->CurrentColumn(); // pad
172 469447 : if(fVerbose==2)
173 0 : if (padID!=data.Pad){
174 0 : ftxt<<"S:"<<data.Sec<<" DDL:"<<ddlNumber<<" R:"<<data.Row<<" P:"<<data.Pad<<endl;
175 0 : padID=data.Pad;
176 0 : }//end if
177 469447 : if(data.Dig>eth){
178 514608 : switch (flag){
179 : case 0:{
180 379125 : fNumberOfDigits++;
181 379125 : f.write((char*)(&data),sizeof(data));
182 379125 : if(fVerbose==2)
183 0 : ftxt<<"A:"<<data.Dig<<" T:"<<data.Time<<endl;
184 : break;
185 : }//end case 0
186 : case 1:{
187 52331 : if((data.Pad>=minPad)&&(data.Pad<=maxPad)){
188 4852 : f.write((char*)(&data),sizeof(data));
189 4852 : if(fVerbose==2)
190 0 : ftxt<<"A:"<<data.Dig<<" T:"<<data.Time<<endl;
191 4852 : fNumberOfDigits++;
192 4852 : }
193 : break;
194 : }//end case 1
195 : case 2:{
196 52331 : if((data.Pad<minPad)||(data.Pad>maxPad)){
197 40309 : f.write((char*)(&data),sizeof(data));
198 40309 : if(fVerbose==2)
199 0 : ftxt<<"A:"<<data.Dig<<" T:"<<data.Time<<endl;
200 40309 : fNumberOfDigits++;
201 40309 : }
202 : break;
203 : }//end case 2
204 : };//end switch
205 : }//end if
206 938894 : }while (digrow->Next());
207 10124 : if (fVerbose==2)
208 0 : ftxt.close();
209 : return;
210 33452 : }
211 : //////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
