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