No ios::binary on Alpha with cxx
[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 AliTPCBuffer::AliTPCBuffer(const char* fileName){
34   // Constructor
35 #ifndef __DECCXX
36   f.open("AliTPCDDL.dat",ios::binary|ios::out);
37 #else
38   f.open("AliTPCDDL.dat",ios::out);
39 #endif
40   // fout=new TFile(fileName,"recreate");
41   // tree=new TTree("tree","Values");
42   fNumberOfDigits=0;
43   fVerbose=0;
44 }
45
46 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
47 AliTPCBuffer::~AliTPCBuffer(){
48   // The destructor closes the IO stream
49   f.close();
50   //delete tree;
51   //delete fout;
52 }
53 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
54 AliTPCBuffer::AliTPCBuffer(const AliTPCBuffer &source){
55   // Copy Constructor
56   this->fVerbose=source.fVerbose;
57   return;
58 }
59 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
60 AliTPCBuffer& AliTPCBuffer::operator=(const AliTPCBuffer &source){
61   //Assigment operator
62   this->fVerbose=source.fVerbose;
63   return *this;
64 }
65 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
66 /*
67 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){
68   //flag=0 the whole row is written to the root file
69   //flag=1 only value in the range [minPad,MaxPasd] are written to the root file
70   //flag=2 complementary case of 1
71   Int_t Pad;
72   Int_t Dig;
73   Int_t Time;
74   tree->Branch("sec",&sec,"sec/I");
75   tree->Branch("SubSec",&SubSec,"SubSec/I");
76   tree->Branch("row",&row,"row/I");
77   tree->Branch("Pad",&Pad,"Pad/I");
78   tree->Branch("Dig",&Dig,"Dig/I");
79   tree->Branch("Time",&Time,"Time/I");
80   digrow->First();
81   do{
82     Dig=digrow->CurrentDigit(); //adc
83     Time=digrow->CurrentRow(); //time
84     Pad =digrow->CurrentColumn(); // pad 
85     //    cout<<"Sec "<<sec<<" row "<<row<<" Pad "<<Pad<<" Dig "<<Dig<<" Time "<<Time<<endl; 
86     if(Dig>eth){
87       switch (flag){
88       case 0:{
89         tree->Fill();
90         fNumberOfDigits++;
91         break;
92       }//end case 0
93       case 1:{
94           if((Pad>=minPad)&&(Pad<=maxPad)){
95             tree->Fill();
96             fNumberOfDigits++;
97           }
98         break;
99       }//end case 1
100       case 2:{
101         if((Pad<minPad)||(Pad>maxPad)){
102           tree->Fill();
103           fNumberOfDigits++;
104         }
105         break;
106       }//end case 2
107       };//end switch
108     }//end if
109   }while (digrow->Next());
110   tree->Write();
111   return;
112 }
113 */
114 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
115 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){
116   //It writes TPC digits as par the flag specifications. Being called by AliTPCDDL.C
117   //flag=0 the whole row is written into the file
118   //flag=1 only value in the range [minPad,MaxPasd] are written into the file
119   //flag=2 complementary case of 1
120
121   struct DataPad{
122     Int_t Sec;
123     Int_t SubSec;
124     Int_t Row;
125     Int_t Pad;
126     Int_t Dig;
127     Int_t Time;
128   };
129   DataPad data;
130   data.Sec=sec;
131   data.SubSec=SubSec;
132   data.Row=row;
133   digrow->First();
134   do{
135     data.Dig=digrow->CurrentDigit(); //adc
136     data.Time=digrow->CurrentRow(); //time
137     data.Pad =digrow->CurrentColumn(); // pad 
138     if(data.Dig>eth){
139       switch (flag){
140       case 0:{
141         fNumberOfDigits++;
142         f.write((char*)(&data),sizeof(data));
143         break;
144       }//end case 0
145       case 1:{
146         if((data.Pad>=minPad)&&(data.Pad<=maxPad)){
147           f.write((char*)(&data),sizeof(data));
148           fNumberOfDigits++;
149         }
150         break;
151       }//end case 1
152       case 2:{
153         if((data.Pad<minPad)||(data.Pad>maxPad)){
154           f.write((char*)(&data),sizeof(data));
155           fNumberOfDigits++;
156         }
157         break;
158       }//end case 2
159       };//end switch
160     }//end if
161   }while (digrow->Next());
162   return;
163 }
164 //////////////////////////////////////////////////////////////////////////////////////////////////////////////