[u/mrichter/AliRoot.git] / ITS / AliITSOnlineSDDTP.cxx

/**************************************************************************
 * Copyright(c) 2007-2009, 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.                  *
 **************************************************************************/
#include <TFile.h>
#include "AliITSOnlineSDDTP.h"
#include "AliLog.h"
#include <TH2F.h>
#include <TMath.h>


///////////////////////////////////////////////////////////////////
//                                                               //
// Implemetation of the class SDD Test Pulse analysis            //
// Origin: F.Prino, Torino, prino@to.infn.it                     //
//                                                               //
///////////////////////////////////////////////////////////////////


ClassImp(AliITSOnlineSDDTP)

//______________________________________________________________________
AliITSOnlineSDDTP::AliITSOnlineSDDTP():AliITSOnlineSDD(),fDAC(0.),fLowThreshold(0),fHighThreshold(0),fNSigmaGain(0.),fNSigmaNoise(0.)
{
  // default constructor
  Reset();
  SetNSigmaGain();
  SetNSigmaNoise();
}
//______________________________________________________________________
AliITSOnlineSDDTP::AliITSOnlineSDDTP(Int_t nddl, Int_t ncarlos, Int_t sid, Float_t xDAC):AliITSOnlineSDD(nddl,ncarlos,sid),fDAC(xDAC),fLowThreshold(0),fHighThreshold(0),fNSigmaGain(0.),fNSigmaNoise(0.)
{
  // standard constructor
  Reset();
  SetNSigmaGain();
  SetNSigmaNoise();
}
//______________________________________________________________________
AliITSOnlineSDDTP::~AliITSOnlineSDDTP(){
  // Destructor
}
//______________________________________________________________________
void AliITSOnlineSDDTP::Reset(){
  // reset all counters
  for(Int_t i=0;i<fgkNAnodes;i++){
    fNEvents[i]=0;
    fGoodAnode[i]=1;
    fBaseline[i]=0.;
    fCMN[i]=0.;
    fRawNoise[i]=0.;
    fCorrNoise[i]=0.;
    fSumTPPeak[i]=0.;
    fTPPos[i]=0.;
  }
  ReadBaselines();
}

//______________________________________________________________________
void AliITSOnlineSDDTP::AddEvent(TH2F* hrawd){
  // analyzes current event and sum its contribution to the various counters
  for(Int_t ian=0;ian<fgkNAnodes;ian++){
    Float_t auxmax=0.;
    Int_t auxtb=0;
    if(!fGoodAnode[ian]) continue;
    for(Int_t itb=fFirstGoodTB;itb<=fLastGoodTB;itb++){
      Float_t cnt=hrawd->GetBinContent(itb+1,ian+1);
      if(cnt>auxmax){ 
	auxmax=cnt;
	auxtb=itb;
      }
    }
    if(auxmax>fBaseline[ian]+fNSigmaNoise*fRawNoise[ian]){
      fSumTPPeak[ian]+=auxmax-fBaseline[ian];
      fTPPos[ian]+=auxtb;
      fNEvents[ian]++;
    }
  }
}
//______________________________________________________________________
void AliITSOnlineSDDTP::ReadBaselines(){
  // assume baselines and good anodes are taken from previous run
  TString basfilnam;
  basfilnam.Form("SDDbase_step2_ddl%02dc%02d_sid%d.data",fDDL,fCarlos,fSide);
  FILE* basf=fopen(basfilnam.Data(),"r");
  if(basf==0){
    AliWarning(Form("Baseline file not present (ddl %d  carlos %d side %d, Set all baselines to 20",fDDL,fCarlos,fSide));
    for(Int_t ian=0;ian<fgkNAnodes;ian++){ 
      fBaseline[ian]=20.;
      fEqBaseline[ian]=20;
      fOffsetBaseline[ian]=0;
      fGoodAnode[ian]=1;
    }
    return;
  }
  Int_t check = fscanf(basf,"%d\n",&fHighThreshold);
  if(check<1)AliError("Error while reading file with baselines");
  check = fscanf(basf,"%d\n",&fLowThreshold);
  if(check<1)AliError("Error while reading file with baselines");
  Int_t n,ok,eqbase,offbase;
  Float_t base,rms,cmn,corrnoi;
  for(Int_t ian=0;ian<fgkNAnodes;ian++){
    check = fscanf(basf,"%d %d %f %d %d %f %f %f\n",&n,&ok,&base,&eqbase,&offbase,&rms,&cmn,&corrnoi);
    if(check<1)AliError("Error while reading file with baselines");
    fBaseline[ian]=base;
    fEqBaseline[ian]=eqbase;
    fOffsetBaseline[ian]=offbase;
    fGoodAnode[ian]=ok;
    fRawNoise[ian]=rms;
    fCMN[ian]=cmn;
    fCorrNoise[ian]=corrnoi;
  }
  fclose(basf);
}

//______________________________________________________________________
Bool_t AliITSOnlineSDDTP::IsModuleGood() const{
  //
  // Check if there is at least 1 good anode
  //
  for(Int_t ian=0;ian<fgkNAnodes;ian++){
    if(fGoodAnode[ian]) return kTRUE;
  }
  return kFALSE;
}
//______________________________________________________________________
void AliITSOnlineSDDTP::ValidateAnodes(){
  // tag good/bad channels
  Float_t meang,rmsg;
  StatGain(meang,rmsg);
  Float_t lowlim=meang-fNSigmaGain*rmsg;
  Float_t hilim=meang+fNSigmaGain*rmsg;

  for(Int_t ian=0;ian<fgkNAnodes;ian++){
    if(!fGoodAnode[ian]) continue;
    if(GetChannelGain(ian)<lowlim||GetChannelGain(ian)>hilim) fGoodAnode[ian]=0;
  }
}


//______________________________________________________________________
void AliITSOnlineSDDTP::StatGain(Float_t &mean, Float_t  &rms) const {
  // compute average gain and rms
  Float_t sum=0.,sumq=0.;
  Int_t cnt=0;
  for(Int_t ian=0;ian<fgkNAnodes;ian++){
    if(!fGoodAnode[ian]) continue;
    if(fNEvents[ian]==0) continue;
    Float_t chgain=GetChannelGain(ian);
    sum+=chgain;
    sumq+=chgain*chgain;
    cnt++;
  }
  if(cnt>0){ 
    mean=sum/(Float_t)cnt;
    Float_t variance=sumq/(Float_t)cnt-mean*mean;
    if(variance>0.) rms=TMath::Sqrt(variance);
    else rms = 0;
  }else{ 
    mean=0.;
    rms=0.;
  }
  return;
}

//______________________________________________________________________
void AliITSOnlineSDDTP::WriteToASCII(){
  // writes parameters of each channel into an ASCII file 
  // to be sent to FXS by the DA and processed by the SHUTTLE

  TString outfilnam;
  outfilnam.Form("SDDbase_ddl%02dc%02d_sid%d.data",fDDL,fCarlos,fSide);
  FILE* outf=fopen(outfilnam.Data(),"w");
  fprintf(outf,"%d %d %d\n",fCarlos,fSide,IsModuleGood());
  fprintf(outf,"%d\n",fHighThreshold);
  fprintf(outf,"%d\n",fLowThreshold);
  for(Int_t ian=0;ian<fgkNAnodes;ian++){
    fprintf(outf,"%d %d %8.3f %d %d %8.3f %8.3f %8.3f %8.3f\n",ian,IsAnodeGood(ian),GetAnodeBaseline(ian),GetAnodeEqualizedBaseline(ian),GetAnodeBaselineOffset(ian),GetAnodeRawNoise(ian),GetAnodeCommonMode(ian),GetAnodeCorrNoise(ian),GetChannelGain(ian));
  }
  fclose(outf);  
}
//______________________________________________________________________
TH1F* AliITSOnlineSDDTP::GetBaselineAnodeHisto() const {
  // produce histogram with baseline vs. anode number
  TString hisnam;  
  hisnam.Form("hbase%02dc%02ds%d",fDDL,fCarlos,fSide);
  TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
  for(Int_t ian=0;ian<fgkNAnodes;ian++){
    h->SetBinContent(ian+1,GetAnodeBaseline(ian));
  }
  return h;
}
//______________________________________________________________________
TH1F* AliITSOnlineSDDTP::GetRawNoiseAnodeHisto() const {
  // produce histogram with raw noise vs. anode number
  TString hisnam;  
  hisnam.Form("hnois%02dc%02ds%d",fDDL,fCarlos,fSide);
  TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
  for(Int_t ian=0;ian<fgkNAnodes;ian++){
    h->SetBinContent(ian+1,GetAnodeRawNoise(ian));
  }
  return h;
}
//______________________________________________________________________
TH1F* AliITSOnlineSDDTP::GetCorrNoiseAnodeHisto() const {
  // produce histogram with corrected noise vs. anode number
  TString hisnam;  
  hisnam.Form("hcorn%02dc%02ds%d",fDDL,fCarlos,fSide);
  TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
  for(Int_t ian=0;ian<fgkNAnodes;ian++){
    h->SetBinContent(ian+1,GetAnodeCorrNoise(ian));
  }
  return h;
}
//______________________________________________________________________
TH1F* AliITSOnlineSDDTP::GetCMNCoefAnodeHisto() const {
  // produce histogram with coefficients for common mode noise subtraction
  TString hisnam;  
  hisnam.Form("hcmn%02dc%02ds%d",fDDL,fCarlos,fSide);
  TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
  for(Int_t ian=0;ian<fgkNAnodes;ian++){
    h->SetBinContent(ian+1,GetAnodeCommonMode(ian));
  }
  return h;
}
//______________________________________________________________________
TH1F* AliITSOnlineSDDTP::GetStatusAnodeHisto() const {
  // produce histogram with status bit of each anode
  TString hisnam;  
  hisnam.Form("hgood%02dc%02ds%d",fDDL,fCarlos,fSide);
  TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
  for(Int_t ian=0;ian<fgkNAnodes;ian++){
    h->SetBinContent(ian+1,float(IsAnodeGood(ian)));
  }
  return h;
}
//______________________________________________________________________
TH1F* AliITSOnlineSDDTP::GetGainAnodeHisto() const {
  // produce histogram with gain vs. anode number
  TString hisnam;  
  hisnam.Form("hgain%02dc%02ds%d",fDDL,fCarlos,fSide);
  TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
  for(Int_t ian=0;ian<fgkNAnodes;ian++){
    h->SetBinContent(ian+1,GetChannelGain(ian));
  }
  return h;
}
//______________________________________________________________________
Bool_t AliITSOnlineSDDTP::WriteToROOT(TFile *fil){
  // writes output into a root file
  if(fil==0){ 
    AliWarning("Invalid pointer to ROOT file");
    return kFALSE;    
  }
  TString hisnam;  
  fil->cd();
  hisnam.Form("hgood%02dc%02ds%d",fDDL,fCarlos,fSide);
  TH1F hgood(hisnam.Data(),"",256,-0.5,255.5);
  hisnam.Form("hbase%02dc%02ds%d",fDDL,fCarlos,fSide);
  TH1F hbase(hisnam.Data(),"",256,-0.5,255.5);
  hisnam.Form("hnois%02dc%02ds%d",fDDL,fCarlos,fSide);
  TH1F hnois(hisnam.Data(),"",256,-0.5,255.5);
  hisnam.Form("hcmn%02dc%02ds%d",fDDL,fCarlos,fSide);
  TH1F hcmn(hisnam.Data(),"",256,-0.5,255.5);
  hisnam.Form("hcorn%02dc%02ds%d",fDDL,fCarlos,fSide);
  TH1F hcorn(hisnam.Data(),"",256,-0.5,255.5);
  hisnam.Form("hgain%02dc%02ds%d",fDDL,fCarlos,fSide);
  TH1F hgain(hisnam.Data(),"",256,-0.5,255.5);
  hisnam.Form("htptb%02dc%02ds%d",fDDL,fCarlos,fSide);
  TH1F htptb(hisnam.Data(),"",256,-0.5,255.5);
  for(Int_t ian=0;ian<fgkNAnodes;ian++){
    hgood.SetBinContent(ian+1,float(IsAnodeGood(ian)));
    hbase.SetBinContent(ian+1,GetAnodeBaseline(ian));
    hnois.SetBinContent(ian+1,GetAnodeRawNoise(ian));
    hcmn.SetBinContent(ian+1,GetAnodeCommonMode(ian));
    hcorn.SetBinContent(ian+1,GetAnodeCorrNoise(ian));
    hgain.SetBinContent(ian+1,GetChannelGain(ian));
    htptb.SetBinContent(ian+1,GetTimeBinTPPeak(ian));
  }
  hgood.Write();
  hbase.Write();
  hnois.Write();
  hcmn.Write();
  hcorn.Write();
  hgain.Write();
  htptb.Write();
  return kTRUE;
}
Commit	Line	Data
	1	/**************************************************************************
	2	* Copyright(c) 2007-2009, 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	#include <TFile.h>
	16	#include "AliITSOnlineSDDTP.h"
	17	#include "AliLog.h"
	18	#include <TH2F.h>
	19	#include <TMath.h>
	20
	21
	22	///////////////////////////////////////////////////////////////////
	23	// //
	24	// Implemetation of the class SDD Test Pulse analysis //
	25	// Origin: F.Prino, Torino, prino@to.infn.it //
	26	// //
	27	///////////////////////////////////////////////////////////////////
	28
	29
	30	ClassImp(AliITSOnlineSDDTP)
	31
	32	//______________________________________________________________________
	33	AliITSOnlineSDDTP::AliITSOnlineSDDTP():AliITSOnlineSDD(),fDAC(0.),fLowThreshold(0),fHighThreshold(0),fNSigmaGain(0.),fNSigmaNoise(0.)
	34	{
	35	// default constructor
	36	Reset();
	37	SetNSigmaGain();
	38	SetNSigmaNoise();
	39	}
	40	//______________________________________________________________________
	41	AliITSOnlineSDDTP::AliITSOnlineSDDTP(Int_t nddl, Int_t ncarlos, Int_t sid, Float_t xDAC):AliITSOnlineSDD(nddl,ncarlos,sid),fDAC(xDAC),fLowThreshold(0),fHighThreshold(0),fNSigmaGain(0.),fNSigmaNoise(0.)
	42	{
	43	// standard constructor
	44	Reset();
	45	SetNSigmaGain();
	46	SetNSigmaNoise();
	47	}
	48	//______________________________________________________________________
	49	AliITSOnlineSDDTP::~AliITSOnlineSDDTP(){
	50	// Destructor
	51	}
	52	//______________________________________________________________________
	53	void AliITSOnlineSDDTP::Reset(){
	54	// reset all counters
	55	for(Int_t i=0;i<fgkNAnodes;i++){
	56	fNEvents[i]=0;
	57	fGoodAnode[i]=1;
	58	fBaseline[i]=0.;
	59	fCMN[i]=0.;
	60	fRawNoise[i]=0.;
	61	fCorrNoise[i]=0.;
	62	fSumTPPeak[i]=0.;
	63	fTPPos[i]=0.;
	64	}
	65	ReadBaselines();
	66	}
	67
	68	//______________________________________________________________________
	69	void AliITSOnlineSDDTP::AddEvent(TH2F* hrawd){
	70	// analyzes current event and sum its contribution to the various counters
	71	for(Int_t ian=0;ian<fgkNAnodes;ian++){
	72	Float_t auxmax=0.;
	73	Int_t auxtb=0;
	74	if(!fGoodAnode[ian]) continue;
	75	for(Int_t itb=fFirstGoodTB;itb<=fLastGoodTB;itb++){
	76	Float_t cnt=hrawd->GetBinContent(itb+1,ian+1);
	77	if(cnt>auxmax){
	78	auxmax=cnt;
	79	auxtb=itb;
	80	}
	81	}
	82	if(auxmax>fBaseline[ian]+fNSigmaNoise*fRawNoise[ian]){
	83	fSumTPPeak[ian]+=auxmax-fBaseline[ian];
	84	fTPPos[ian]+=auxtb;
	85	fNEvents[ian]++;
	86	}
	87	}
	88	}
	89	//______________________________________________________________________
	90	void AliITSOnlineSDDTP::ReadBaselines(){
	91	// assume baselines and good anodes are taken from previous run
	92	TString basfilnam;
	93	basfilnam.Form("SDDbase_step2_ddl%02dc%02d_sid%d.data",fDDL,fCarlos,fSide);
	94	FILE* basf=fopen(basfilnam.Data(),"r");
	95	if(basf==0){
	96	AliWarning(Form("Baseline file not present (ddl %d carlos %d side %d, Set all baselines to 20",fDDL,fCarlos,fSide));
	97	for(Int_t ian=0;ian<fgkNAnodes;ian++){
	98	fBaseline[ian]=20.;
	99	fEqBaseline[ian]=20;
	100	fOffsetBaseline[ian]=0;
	101	fGoodAnode[ian]=1;
	102	}
	103	return;
	104	}
	105	Int_t check = fscanf(basf,"%d\n",&fHighThreshold);
	106	if(check<1)AliError("Error while reading file with baselines");
	107	check = fscanf(basf,"%d\n",&fLowThreshold);
	108	if(check<1)AliError("Error while reading file with baselines");
	109	Int_t n,ok,eqbase,offbase;
	110	Float_t base,rms,cmn,corrnoi;
	111	for(Int_t ian=0;ian<fgkNAnodes;ian++){
	112	check = fscanf(basf,"%d %d %f %d %d %f %f %f\n",&n,&ok,&base,&eqbase,&offbase,&rms,&cmn,&corrnoi);
	113	if(check<1)AliError("Error while reading file with baselines");
	114	fBaseline[ian]=base;
	115	fEqBaseline[ian]=eqbase;
	116	fOffsetBaseline[ian]=offbase;
	117	fGoodAnode[ian]=ok;
	118	fRawNoise[ian]=rms;
	119	fCMN[ian]=cmn;
	120	fCorrNoise[ian]=corrnoi;
	121	}
	122	fclose(basf);
	123	}
	124
	125	//______________________________________________________________________
	126	Bool_t AliITSOnlineSDDTP::IsModuleGood() const{
	127	//
	128	// Check if there is at least 1 good anode
	129	//
	130	for(Int_t ian=0;ian<fgkNAnodes;ian++){
	131	if(fGoodAnode[ian]) return kTRUE;
	132	}
	133	return kFALSE;
	134	}
	135	//______________________________________________________________________
	136	void AliITSOnlineSDDTP::ValidateAnodes(){
	137	// tag good/bad channels
	138	Float_t meang,rmsg;
	139	StatGain(meang,rmsg);
	140	Float_t lowlim=meang-fNSigmaGain*rmsg;
	141	Float_t hilim=meang+fNSigmaGain*rmsg;
	142
	143	for(Int_t ian=0;ian<fgkNAnodes;ian++){
	144	if(!fGoodAnode[ian]) continue;
	145	if(GetChannelGain(ian)<lowlim\|\|GetChannelGain(ian)>hilim) fGoodAnode[ian]=0;
	146	}
	147	}
	148
	149
	150	//______________________________________________________________________
	151	void AliITSOnlineSDDTP::StatGain(Float_t &mean, Float_t &rms) const {
	152	// compute average gain and rms
	153	Float_t sum=0.,sumq=0.;
	154	Int_t cnt=0;
	155	for(Int_t ian=0;ian<fgkNAnodes;ian++){
	156	if(!fGoodAnode[ian]) continue;
	157	if(fNEvents[ian]==0) continue;
	158	Float_t chgain=GetChannelGain(ian);
	159	sum+=chgain;
	160	sumq+=chgain*chgain;
	161	cnt++;
	162	}
	163	if(cnt>0){
	164	mean=sum/(Float_t)cnt;
	165	Float_t variance=sumq/(Float_t)cnt-mean*mean;
	166	if(variance>0.) rms=TMath::Sqrt(variance);
	167	else rms = 0;
	168	}else{
	169	mean=0.;
	170	rms=0.;
	171	}
	172	return;
	173	}
	174
	175	//______________________________________________________________________
	176	void AliITSOnlineSDDTP::WriteToASCII(){
	177	// writes parameters of each channel into an ASCII file
	178	// to be sent to FXS by the DA and processed by the SHUTTLE
	179
	180	TString outfilnam;
	181	outfilnam.Form("SDDbase_ddl%02dc%02d_sid%d.data",fDDL,fCarlos,fSide);
	182	FILE* outf=fopen(outfilnam.Data(),"w");
	183	fprintf(outf,"%d %d %d\n",fCarlos,fSide,IsModuleGood());
	184	fprintf(outf,"%d\n",fHighThreshold);
	185	fprintf(outf,"%d\n",fLowThreshold);
	186	for(Int_t ian=0;ian<fgkNAnodes;ian++){
	187	fprintf(outf,"%d %d %8.3f %d %d %8.3f %8.3f %8.3f %8.3f\n",ian,IsAnodeGood(ian),GetAnodeBaseline(ian),GetAnodeEqualizedBaseline(ian),GetAnodeBaselineOffset(ian),GetAnodeRawNoise(ian),GetAnodeCommonMode(ian),GetAnodeCorrNoise(ian),GetChannelGain(ian));
	188	}
	189	fclose(outf);
	190	}
	191	//______________________________________________________________________
	192	TH1F* AliITSOnlineSDDTP::GetBaselineAnodeHisto() const {
	193	// produce histogram with baseline vs. anode number
	194	TString hisnam;
	195	hisnam.Form("hbase%02dc%02ds%d",fDDL,fCarlos,fSide);
	196	TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
	197	for(Int_t ian=0;ian<fgkNAnodes;ian++){
	198	h->SetBinContent(ian+1,GetAnodeBaseline(ian));
	199	}
	200	return h;
	201	}
	202	//______________________________________________________________________
	203	TH1F* AliITSOnlineSDDTP::GetRawNoiseAnodeHisto() const {
	204	// produce histogram with raw noise vs. anode number
	205	TString hisnam;
	206	hisnam.Form("hnois%02dc%02ds%d",fDDL,fCarlos,fSide);
	207	TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
	208	for(Int_t ian=0;ian<fgkNAnodes;ian++){
	209	h->SetBinContent(ian+1,GetAnodeRawNoise(ian));
	210	}
	211	return h;
	212	}
	213	//______________________________________________________________________
	214	TH1F* AliITSOnlineSDDTP::GetCorrNoiseAnodeHisto() const {
	215	// produce histogram with corrected noise vs. anode number
	216	TString hisnam;
	217	hisnam.Form("hcorn%02dc%02ds%d",fDDL,fCarlos,fSide);
	218	TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
	219	for(Int_t ian=0;ian<fgkNAnodes;ian++){
	220	h->SetBinContent(ian+1,GetAnodeCorrNoise(ian));
	221	}
	222	return h;
	223	}
	224	//______________________________________________________________________
	225	TH1F* AliITSOnlineSDDTP::GetCMNCoefAnodeHisto() const {
	226	// produce histogram with coefficients for common mode noise subtraction
	227	TString hisnam;
	228	hisnam.Form("hcmn%02dc%02ds%d",fDDL,fCarlos,fSide);
	229	TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
	230	for(Int_t ian=0;ian<fgkNAnodes;ian++){
	231	h->SetBinContent(ian+1,GetAnodeCommonMode(ian));
	232	}
	233	return h;
	234	}
	235	//______________________________________________________________________
	236	TH1F* AliITSOnlineSDDTP::GetStatusAnodeHisto() const {
	237	// produce histogram with status bit of each anode
	238	TString hisnam;
	239	hisnam.Form("hgood%02dc%02ds%d",fDDL,fCarlos,fSide);
	240	TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
	241	for(Int_t ian=0;ian<fgkNAnodes;ian++){
	242	h->SetBinContent(ian+1,float(IsAnodeGood(ian)));
	243	}
	244	return h;
	245	}
	246	//______________________________________________________________________
	247	TH1F* AliITSOnlineSDDTP::GetGainAnodeHisto() const {
	248	// produce histogram with gain vs. anode number
	249	TString hisnam;
	250	hisnam.Form("hgain%02dc%02ds%d",fDDL,fCarlos,fSide);
	251	TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
	252	for(Int_t ian=0;ian<fgkNAnodes;ian++){
	253	h->SetBinContent(ian+1,GetChannelGain(ian));
	254	}
	255	return h;
	256	}
	257	//______________________________________________________________________
	258	Bool_t AliITSOnlineSDDTP::WriteToROOT(TFile *fil){
	259	// writes output into a root file
	260	if(fil==0){
	261	AliWarning("Invalid pointer to ROOT file");
	262	return kFALSE;
	263	}
	264	TString hisnam;
	265	fil->cd();
	266	hisnam.Form("hgood%02dc%02ds%d",fDDL,fCarlos,fSide);
	267	TH1F hgood(hisnam.Data(),"",256,-0.5,255.5);
	268	hisnam.Form("hbase%02dc%02ds%d",fDDL,fCarlos,fSide);
	269	TH1F hbase(hisnam.Data(),"",256,-0.5,255.5);
	270	hisnam.Form("hnois%02dc%02ds%d",fDDL,fCarlos,fSide);
	271	TH1F hnois(hisnam.Data(),"",256,-0.5,255.5);
	272	hisnam.Form("hcmn%02dc%02ds%d",fDDL,fCarlos,fSide);
	273	TH1F hcmn(hisnam.Data(),"",256,-0.5,255.5);
	274	hisnam.Form("hcorn%02dc%02ds%d",fDDL,fCarlos,fSide);
	275	TH1F hcorn(hisnam.Data(),"",256,-0.5,255.5);
	276	hisnam.Form("hgain%02dc%02ds%d",fDDL,fCarlos,fSide);
	277	TH1F hgain(hisnam.Data(),"",256,-0.5,255.5);
	278	hisnam.Form("htptb%02dc%02ds%d",fDDL,fCarlos,fSide);
	279	TH1F htptb(hisnam.Data(),"",256,-0.5,255.5);
	280	for(Int_t ian=0;ian<fgkNAnodes;ian++){
	281	hgood.SetBinContent(ian+1,float(IsAnodeGood(ian)));
	282	hbase.SetBinContent(ian+1,GetAnodeBaseline(ian));
	283	hnois.SetBinContent(ian+1,GetAnodeRawNoise(ian));
	284	hcmn.SetBinContent(ian+1,GetAnodeCommonMode(ian));
	285	hcorn.SetBinContent(ian+1,GetAnodeCorrNoise(ian));
	286	hgain.SetBinContent(ian+1,GetChannelGain(ian));
	287	htptb.SetBinContent(ian+1,GetTimeBinTPPeak(ian));
	288	}
	289	hgood.Write();
	290	hbase.Write();
	291	hnois.Write();
	292	hcmn.Write();
	293	hcorn.Write();
	294	hgain.Write();
	295	htptb.Write();
	296	return kTRUE;
	297	}
	298