During simulation: fill STU region w/ non null time sums
[u/mrichter/AliRoot.git] / TPC / AliTPCBuffer.cxx
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 ClassImp(AliTPCBuffer)
32 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
33 //___________________________________________________________
34   AliTPCBuffer::AliTPCBuffer():TObject(),
35     fVerbose(0),
36     fNumberOfDigits(0),
37     f()
38 {
39   //
40   // default
41   //
42 }
43 //____________________________________________________________
44   AliTPCBuffer::AliTPCBuffer(const char* fileName):TObject(),
45     fVerbose(0),
46     fNumberOfDigits(0),
47     f()
48 {
49   // Constructor
50 #ifndef __DECCXX
51   f.open(fileName,ios::binary|ios::out);
52 #else
53   f.open(fileName,ios::out);
54 #endif
55   // fout=new TFile(fileName,"recreate");
56   // tree=new TTree("tree","Values");
57
58   remove("TPCdigits.txt");
59 }
60
61 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
62 AliTPCBuffer::~AliTPCBuffer(){
63   // The destructor closes the IO stream
64   f.close();
65   //delete tree;
66   //delete fout;
67 }
68 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
69 AliTPCBuffer::AliTPCBuffer(const AliTPCBuffer &source):TObject(source),
70     fVerbose(0),
71     fNumberOfDigits(0),
72     f()
73 {
74   // Copy Constructor
75   this->fVerbose=source.fVerbose;
76   return;
77 }
78 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
79 AliTPCBuffer& AliTPCBuffer::operator=(const AliTPCBuffer &source){
80   //Assigment operator
81   if(this!=&source){
82     this->fVerbose=source.fVerbose;
83   }
84   return *this;
85 }
86 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
87 /*
88 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){
89   //flag=0 the whole row is written to the root file
90   //flag=1 only value in the range [minPad,MaxPasd] are written to the root file
91   //flag=2 complementary case of 1
92   Int_t Pad;
93   Int_t Dig;
94   Int_t Time;
95   tree->Branch("sec",&sec,"sec/I");
96   tree->Branch("SubSec",&SubSec,"SubSec/I");
97   tree->Branch("row",&row,"row/I");
98   tree->Branch("Pad",&Pad,"Pad/I");
99   tree->Branch("Dig",&Dig,"Dig/I");
100   tree->Branch("Time",&Time,"Time/I");
101   digrow->First();
102   do{
103     Dig=digrow->CurrentDigit(); //adc
104     Time=digrow->CurrentRow(); //time
105     Pad =digrow->CurrentColumn(); // pad 
106     //    cout<<"Sec "<<sec<<" row "<<row<<" Pad "<<Pad<<" Dig "<<Dig<<" Time "<<Time<<endl; 
107     if(Dig>eth){
108       switch (flag){
109       case 0:{
110         tree->Fill();
111         fNumberOfDigits++;
112         break;
113       }//end case 0
114       case 1:{
115           if((Pad>=minPad)&&(Pad<=maxPad)){
116             tree->Fill();
117             fNumberOfDigits++;
118           }
119         break;
120       }//end case 1
121       case 2:{
122         if((Pad<minPad)||(Pad>maxPad)){
123           tree->Fill();
124           fNumberOfDigits++;
125         }
126         break;
127       }//end case 2
128       };//end switch
129     }//end if
130   }while (digrow->Next());
131   tree->Write();
132   return;
133 }
134 */
135 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
136 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){
137   //It writes TPC digits as par the flag specifications. Being called by AliTPCDDL.C
138   //flag=0 the whole row is written into the file
139   //flag=1 only value in the range [minPad,MaxPasd] are written into the file
140   //flag=2 complementary case of 1
141
142   struct DataPad{
143     Int_t Sec;
144     Int_t SubSec;
145     Int_t Row;
146     Int_t Pad;
147     Int_t Dig;
148     Int_t Time;
149   };
150   DataPad data;
151   data.Sec=sec;
152   data.SubSec=SubSec;
153   data.Row=row;
154   if (!digrow->First()) return;
155   Int_t padID=-1;
156   Int_t ddlNumber=0;
157   ofstream ftxt;
158   if (fVerbose==2){
159     ftxt.open("TPCdigits.txt",ios::app);
160     if(sec<36)
161       ddlNumber=sec*2+SubSec;
162     else
163       ddlNumber=72+(sec-36)*4+SubSec;
164   }//end if
165   do{
166     data.Dig=digrow->CurrentDigit();    //adc
167     data.Time=digrow->CurrentRow();     //time
168     data.Pad =digrow->CurrentColumn();  // pad 
169     if(fVerbose==2)
170       if (padID!=data.Pad){
171         ftxt<<"S:"<<data.Sec<<" DDL:"<<ddlNumber<<" R:"<<data.Row<<" P:"<<data.Pad<<endl;
172         padID=data.Pad;
173       }//end if
174     if(data.Dig>eth){
175       switch (flag){
176       case 0:{
177         fNumberOfDigits++;
178         f.write((char*)(&data),sizeof(data));
179         if(fVerbose==2)
180           ftxt<<"A:"<<data.Dig<<" T:"<<data.Time<<endl; 
181         break;
182       }//end case 0
183       case 1:{
184         if((data.Pad>=minPad)&&(data.Pad<=maxPad)){
185           f.write((char*)(&data),sizeof(data));
186           if(fVerbose==2)
187             ftxt<<"A:"<<data.Dig<<" T:"<<data.Time<<endl; 
188           fNumberOfDigits++;
189         }
190         break;
191       }//end case 1
192       case 2:{
193         if((data.Pad<minPad)||(data.Pad>maxPad)){
194           f.write((char*)(&data),sizeof(data));
195           if(fVerbose==2)
196             ftxt<<"A:"<<data.Dig<<" T:"<<data.Time<<endl; 
197           fNumberOfDigits++;
198         }
199         break;
200       }//end case 2
201       };//end switch
202     }//end if
203   }while (digrow->Next());
204   if (fVerbose==2)
205     ftxt.close();
206   return;
207 }
208 //////////////////////////////////////////////////////////////////////////////////////////////////////////////