[u/mrichter/AliRoot.git] / TPC / AliTPCBuffer.cxx

/**************************************************************************
 * Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/
/* $Id$ */

// Storing digits in a binary file
// according to the DDL mapping
// To be used in Alice Data Challenges
// This class is used by AliTPCDDL.C macro
// Author: D.Favretto

#include <Riostream.h>
#include <TObjArray.h>
#include "AliTPCBuffer.h"
#include "AliSimDigits.h"

//#include "TFile.h"
//#include "TTree.h"

ClassImp(AliTPCBuffer)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//___________________________________________________________
  AliTPCBuffer::AliTPCBuffer():TObject(),
    fVerbose(0),
    fNumberOfDigits(0),
    f()
{
  //
  // default
  //
}
//____________________________________________________________
  AliTPCBuffer::AliTPCBuffer(const char* fileName):TObject(),
    fVerbose(0),
    fNumberOfDigits(0),
    f()
{
  // Constructor
#ifndef __DECCXX
  f.open(fileName,ios::binary|ios::out);
#else
  f.open(fileName,ios::out);
#endif
  // fout=new TFile(fileName,"recreate");
  // tree=new TTree("tree","Values");

  remove("TPCdigits.txt");
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////
AliTPCBuffer::~AliTPCBuffer(){
  // The destructor closes the IO stream
  f.close();
  //delete tree;
  //delete fout;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
AliTPCBuffer::AliTPCBuffer(const AliTPCBuffer &source):TObject(source),
    fVerbose(0),
    fNumberOfDigits(0),
    f()
{
  // Copy Constructor
  this->fVerbose=source.fVerbose;
  return;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
AliTPCBuffer& AliTPCBuffer::operator=(const AliTPCBuffer &source){
  //Assigment operator
  this->fVerbose=source.fVerbose;
  return *this;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
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){
  //flag=0 the whole row is written to the root file
  //flag=1 only value in the range [minPad,MaxPasd] are written to the root file
  //flag=2 complementary case of 1
  Int_t Pad;
  Int_t Dig;
  Int_t Time;
  tree->Branch("sec",&sec,"sec/I");
  tree->Branch("SubSec",&SubSec,"SubSec/I");
  tree->Branch("row",&row,"row/I");
  tree->Branch("Pad",&Pad,"Pad/I");
  tree->Branch("Dig",&Dig,"Dig/I");
  tree->Branch("Time",&Time,"Time/I");
  digrow->First();
  do{
    Dig=digrow->CurrentDigit(); //adc
    Time=digrow->CurrentRow(); //time
    Pad =digrow->CurrentColumn(); // pad 
    //    cout<<"Sec "<<sec<<" row "<<row<<" Pad "<<Pad<<" Dig "<<Dig<<" Time "<<Time<<endl; 
    if(Dig>eth){
      switch (flag){
      case 0:{
	tree->Fill();
	fNumberOfDigits++;
      	break;
      }//end case 0
      case 1:{
	  if((Pad>=minPad)&&(Pad<=maxPad)){
	    tree->Fill();
	    fNumberOfDigits++;
	  }
	break;
      }//end case 1
      case 2:{
	if((Pad<minPad)||(Pad>maxPad)){
	  tree->Fill();
	  fNumberOfDigits++;
	}
	break;
      }//end case 2
      };//end switch
    }//end if
  }while (digrow->Next());
  tree->Write();
  return;
}
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
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){
  //It writes TPC digits as par the flag specifications. Being called by AliTPCDDL.C
  //flag=0 the whole row is written into the file
  //flag=1 only value in the range [minPad,MaxPasd] are written into the file
  //flag=2 complementary case of 1

  struct DataPad{
    Int_t Sec;
    Int_t SubSec;
    Int_t Row;
    Int_t Pad;
    Int_t Dig;
    Int_t Time;
  };
  DataPad data;
  data.Sec=sec;
  data.SubSec=SubSec;
  data.Row=row;
  if (!digrow->First()) return;
  Int_t padID=-1;
  Int_t ddlNumber=0;
  ofstream ftxt;
  if (fVerbose==2){
    ftxt.open("TPCdigits.txt",ios::app);
    if(sec<36)
      ddlNumber=sec*2+SubSec;
    else
      ddlNumber=72+(sec-36)*4+SubSec;
  }//end if
  do{
    data.Dig=digrow->CurrentDigit();    //adc
    data.Time=digrow->CurrentRow();     //time
    data.Pad =digrow->CurrentColumn();  // pad 
    if(fVerbose==2)
      if (padID!=data.Pad){
	ftxt<<"S:"<<data.Sec<<" DDL:"<<ddlNumber<<" R:"<<data.Row<<" P:"<<data.Pad<<endl;
	padID=data.Pad;
      }//end if
    if(data.Dig>eth){
      switch (flag){
      case 0:{
	fNumberOfDigits++;
	f.write((char*)(&data),sizeof(data));
	if(fVerbose==2)
	  ftxt<<"A:"<<data.Dig<<" T:"<<data.Time<<endl; 
	break;
      }//end case 0
      case 1:{
	if((data.Pad>=minPad)&&(data.Pad<=maxPad)){
	  f.write((char*)(&data),sizeof(data));
	  if(fVerbose==2)
	    ftxt<<"A:"<<data.Dig<<" T:"<<data.Time<<endl; 
	  fNumberOfDigits++;
	}
	break;
      }//end case 1
      case 2:{
	if((data.Pad<minPad)||(data.Pad>maxPad)){
	  f.write((char*)(&data),sizeof(data));
	  if(fVerbose==2)
	    ftxt<<"A:"<<data.Dig<<" T:"<<data.Time<<endl; 
	  fNumberOfDigits++;
	}
	break;
      }//end case 2
      };//end switch
    }//end if
  }while (digrow->Next());
  if (fVerbose==2)
    ftxt.close();
  return;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
Commit	Line	Data
2e9f335b	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	**************************************************************************/
a763ec6d	15	/* $Id$ */
2e9f335b	16
a763ec6d	17	// Storing digits in a binary file
a763ec6d	18	// according to the DDL mapping
066782e8	19	// To be used in Alice Data Challenges
066782e8	20	// This class is used by AliTPCDDL.C macro
a763ec6d	21	// Author: D.Favretto
066782e8	22
b62e2a95	23	#include <Riostream.h>
b62e2a95	24	#include <TObjArray.h>
2e9f335b	25	#include "AliTPCBuffer.h"
	26	#include "AliSimDigits.h"
	27
	28	//#include "TFile.h"
	29	//#include "TTree.h"
	30
	31	ClassImp(AliTPCBuffer)
	32	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
179c6296	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	{
a763ec6d	49	// Constructor
30c1018e	50	#ifndef __DECCXX
0421c3d1	51	f.open(fileName,ios::binary\|ios::out);
30c1018e	52	#else
0421c3d1	53	f.open(fileName,ios::out);
30c1018e	54	#endif
2e9f335b	55	// fout=new TFile(fileName,"recreate");
2e9f335b	56	// tree=new TTree("tree","Values");
179c6296	57
9f992f70	58	remove("TPCdigits.txt");
2e9f335b	59	}
	60
	61	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
	62	AliTPCBuffer::~AliTPCBuffer(){
066782e8	63	// The destructor closes the IO stream
2e9f335b	64	f.close();
	65	//delete tree;
	66	//delete fout;
	67	}
	68	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
179c6296	69	AliTPCBuffer::AliTPCBuffer(const AliTPCBuffer &source):TObject(source),
	70	fVerbose(0),
	71	fNumberOfDigits(0),
	72	f()
	73	{
2e9f335b	74	// Copy Constructor
a79660fb	75	this->fVerbose=source.fVerbose;
2e9f335b	76	return;
	77	}
	78	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
	79	AliTPCBuffer& AliTPCBuffer::operator=(const AliTPCBuffer &source){
	80	//Assigment operator
a79660fb	81	this->fVerbose=source.fVerbose;
2e9f335b	82	return *this;
	83	}
	84	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
	85	/*
	86	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){
	87	//flag=0 the whole row is written to the root file
	88	//flag=1 only value in the range [minPad,MaxPasd] are written to the root file
	89	//flag=2 complementary case of 1
	90	Int_t Pad;
	91	Int_t Dig;
	92	Int_t Time;
	93	tree->Branch("sec",&sec,"sec/I");
	94	tree->Branch("SubSec",&SubSec,"SubSec/I");
	95	tree->Branch("row",&row,"row/I");
	96	tree->Branch("Pad",&Pad,"Pad/I");
	97	tree->Branch("Dig",&Dig,"Dig/I");
	98	tree->Branch("Time",&Time,"Time/I");
	99	digrow->First();
	100	do{
	101	Dig=digrow->CurrentDigit(); //adc
	102	Time=digrow->CurrentRow(); //time
	103	Pad =digrow->CurrentColumn(); // pad
	104	// cout<<"Sec "<<sec<<" row "<<row<<" Pad "<<Pad<<" Dig "<<Dig<<" Time "<<Time<<endl;
	105	if(Dig>eth){
	106	switch (flag){
	107	case 0:{
	108	tree->Fill();
a763ec6d	109	fNumberOfDigits++;
2e9f335b	110	break;
	111	}//end case 0
	112	case 1:{
	113	if((Pad>=minPad)&&(Pad<=maxPad)){
	114	tree->Fill();
a763ec6d	115	fNumberOfDigits++;
2e9f335b	116	}
	117	break;
	118	}//end case 1
	119	case 2:{
	120	if((Pad<minPad)\|\|(Pad>maxPad)){
	121	tree->Fill();
a763ec6d	122	fNumberOfDigits++;
2e9f335b	123	}
	124	break;
	125	}//end case 2
	126	};//end switch
	127	}//end if
	128	}while (digrow->Next());
	129	tree->Write();
	130	return;
	131	}
	132	*/
	133	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
	134	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){
a79660fb	135	//It writes TPC digits as par the flag specifications. Being called by AliTPCDDL.C
a79660fb	136	//flag=0 the whole row is written into the file
2e9f335b	137	//flag=1 only value in the range [minPad,MaxPasd] are written into the file
2e9f335b	138	//flag=2 complementary case of 1
a79660fb	139
2e9f335b	140	struct DataPad{
	141	Int_t Sec;
	142	Int_t SubSec;
	143	Int_t Row;
	144	Int_t Pad;
	145	Int_t Dig;
	146	Int_t Time;
	147	};
	148	DataPad data;
	149	data.Sec=sec;
	150	data.SubSec=SubSec;
	151	data.Row=row;
7a8519ca	152	if (!digrow->First()) return;
9f992f70	153	Int_t padID=-1;
	154	Int_t ddlNumber=0;
	155	ofstream ftxt;
	156	if (fVerbose==2){
	157	ftxt.open("TPCdigits.txt",ios::app);
	158	if(sec<36)
	159	ddlNumber=sec*2+SubSec;
	160	else
	161	ddlNumber=72+(sec-36)*4+SubSec;
	162	}//end if
2e9f335b	163	do{
9f992f70	164	data.Dig=digrow->CurrentDigit(); //adc
	165	data.Time=digrow->CurrentRow(); //time
	166	data.Pad =digrow->CurrentColumn(); // pad
	167	if(fVerbose==2)
	168	if (padID!=data.Pad){
	169	ftxt<<"S:"<<data.Sec<<" DDL:"<<ddlNumber<<" R:"<<data.Row<<" P:"<<data.Pad<<endl;
	170	padID=data.Pad;
	171	}//end if
2e9f335b	172	if(data.Dig>eth){
	173	switch (flag){
	174	case 0:{
a763ec6d	175	fNumberOfDigits++;
2e9f335b	176	f.write((char*)(&data),sizeof(data));
9f992f70	177	if(fVerbose==2)
9f992f70	178	ftxt<<"A:"<<data.Dig<<" T:"<<data.Time<<endl;
2e9f335b	179	break;
	180	}//end case 0
	181	case 1:{
	182	if((data.Pad>=minPad)&&(data.Pad<=maxPad)){
	183	f.write((char*)(&data),sizeof(data));
9f992f70	184	if(fVerbose==2)
9f992f70	185	ftxt<<"A:"<<data.Dig<<" T:"<<data.Time<<endl;
a763ec6d	186	fNumberOfDigits++;
2e9f335b	187	}
	188	break;
	189	}//end case 1
	190	case 2:{
	191	if((data.Pad<minPad)\|\|(data.Pad>maxPad)){
	192	f.write((char*)(&data),sizeof(data));
9f992f70	193	if(fVerbose==2)
9f992f70	194	ftxt<<"A:"<<data.Dig<<" T:"<<data.Time<<endl;
a763ec6d	195	fNumberOfDigits++;
2e9f335b	196	}
	197	break;
	198	}//end case 2
	199	};//end switch
	200	}//end if
	201	}while (digrow->Next());
9f992f70	202	if (fVerbose==2)
9f992f70	203	ftxt.close();
2e9f335b	204	return;
	205	}
	206	//////////////////////////////////////////////////////////////////////////////////////////////////////////////