[u/mrichter/AliRoot.git] / EMCAL / AliEMCALCalibData.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, 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$ */

//_________________________________________________________________________
///*-- Author: Yves Schutz (SUBATECH)
//           : Aleksei Pavlinov (WSU); Jun 30, 2006 - ALICE numbering scheme
///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// class for EMCAL calibration                                               //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include <TMath.h>

#include "AliEMCALCalibData.h"

ClassImp(AliEMCALCalibData)

//________________________________________________________________
AliEMCALCalibData::AliEMCALCalibData()
{
  // Default constructor
  Reset();
}

//________________________________________________________________
AliEMCALCalibData::AliEMCALCalibData(const char* name)
{
  // Constructor
  TString namst = "Calib_";
  namst += name;
  SetName(namst.Data());
  SetTitle(namst.Data());
  Reset();
}

//________________________________________________________________
AliEMCALCalibData::AliEMCALCalibData(const AliEMCALCalibData& calibda) :
  TNamed(calibda)
{
  // copy constructor
  SetName(calibda.GetName());
  SetTitle(calibda.GetName());
  Reset();

  Int_t nSMod = AliEMCALGeoParams::fgkEMCALModules; //12
  Int_t nCol  = AliEMCALGeoParams::fgkEMCALCols;    //48
  Int_t nRow  = AliEMCALGeoParams::fgkEMCALRows;    //24
  Int_t nRow2 = AliEMCALGeoParams::fgkEMCALRows;    //12 - Modules 11 and 12 are half modules

  for(Int_t supermodule=0; supermodule<nSMod; supermodule++) {
    if(supermodule >= 10)
      nRow = nRow2;
    for(Int_t column=0; column<nCol; column++) {
      for(Int_t row=0; row<nRow; row++) {
	fADCchannel[supermodule][column][row] = 
	  calibda.GetADCchannel(supermodule,column,row);
	fADCpedestal[supermodule][column][row] = 
	  calibda.GetADCpedestal(supermodule,column,row);
      }
    }
  }
}


//________________________________________________________________
AliEMCALCalibData &AliEMCALCalibData::operator =(const AliEMCALCalibData& calibda)
{
  // assignment operator
  SetName(calibda.GetName());
  SetTitle(calibda.GetName());
  Reset();

  Int_t nSMod = AliEMCALGeoParams::fgkEMCALModules; //12
  Int_t nCol  = AliEMCALGeoParams::fgkEMCALCols;    //48
  Int_t nRow  = AliEMCALGeoParams::fgkEMCALRows;    //24
  Int_t nRow2 = AliEMCALGeoParams::fgkEMCALRows/2;  //12 - Modules 11 and 12 are half modules

  for(Int_t supermodule=0; supermodule<nSMod; supermodule++) {
    if(supermodule >= 10)
      nRow = nRow2;
    for(Int_t column=0; column<nCol; column++) {
      for(Int_t row=0; row<nRow; row++) {
	fADCchannel[supermodule][column][row] = 
	  calibda.GetADCchannel(supermodule,column,row);
	fADCpedestal[supermodule][column][row] = 
	  calibda.GetADCpedestal(supermodule,column,row);
      }
    }
  }
  return *this;
}

//________________________________________________________________
AliEMCALCalibData::~AliEMCALCalibData()
{
  // Destructor
}

//________________________________________________________________
void AliEMCALCalibData::Reset()
{
  // Set all pedestals to 0 and all ADC channels widths to 1
  //memset(fADCchannel ,1,12*48*24*sizeof(Float_t));
  //memset(fADCpedestal,0,12*48*24*sizeof(Float_t));

  Int_t nSMod = AliEMCALGeoParams::fgkEMCALModules; //12
  Int_t nCol  = AliEMCALGeoParams::fgkEMCALCols;    //48
  Int_t nRow  = AliEMCALGeoParams::fgkEMCALRows;    //24
  Int_t nRow2 = AliEMCALGeoParams::fgkEMCALRows/2;  //12 - Modules 11 and 12 are half modules
  for (Int_t supermodule=0; supermodule<nSMod; supermodule++){
    if(supermodule >= 10)
      nRow = nRow2;
    for (Int_t column=0; column<nCol; column++){
      for (Int_t row=0; row<nRow; row++){
        fADCpedestal[supermodule][column][row]=0.;
        fADCchannel [supermodule][column][row]=1.;
      }
    }
  } 
}

//________________________________________________________________
void  AliEMCALCalibData::Print(Option_t *option) const
{
  // Print tables of pedestals and ADC channels widths

  Int_t nSMod = AliEMCALGeoParams::fgkEMCALModules; //12
  Int_t nCol  = AliEMCALGeoParams::fgkEMCALCols;    //48
  Int_t nRow  = AliEMCALGeoParams::fgkEMCALRows;    //24
  Int_t nRow2 = AliEMCALGeoParams::fgkEMCALRows/2;  //12 - Modules 11 and 12 are half modules
  if (strstr(option,"ped")) {
    printf("\n	----	Pedestal values	----\n\n");
    for (Int_t supermodule=0; supermodule<nSMod; supermodule++){
      if(supermodule >= 10)
	nRow = nRow2;
      printf("============== Supermodule %d\n",supermodule+1);
      for (Int_t column=0; column<nCol; column++){
	for (Int_t row=0; row<nRow; row++){
	  printf(" %2.4f ",fADCpedestal[supermodule][column][row]);
	}
	printf("\n");
      }
    } 
  }


  if (strstr(option,"gain")) {
    printf("\n	----	ADC channel values	----\n\n");
    for (Int_t supermodule=0; supermodule<nSMod; supermodule++){
      if(supermodule >= 10) 
	nRow = nRow2;
      printf("============== Supermodule %d\n",supermodule+1);
      for (Int_t column=0; column<nCol; column++){
	for (Int_t row=0; row<nRow; row++){
	  printf(" %2.4f ",fADCchannel[supermodule][column][row]);
	}
	printf("\n");
      }
    }   
  }
}

//________________________________________________________________
Float_t AliEMCALCalibData::GetADCchannel(Int_t supermodule, Int_t column, Int_t row) const
{
  // Set ADC channel witdth values
  // All indexes start from 0!
  // Supermodule, column,raw should follow the ALICE convention:
  // supermodule 0:11, column 0:47, row 0:23

  return fADCchannel[supermodule][column][row];
}

//________________________________________________________________
Float_t AliEMCALCalibData::GetADCpedestal(Int_t supermodule, Int_t column, Int_t row) const
{
  // Get ADC pedestal values
 return fADCpedestal[supermodule][column][row];
}

//________________________________________________________________
void AliEMCALCalibData::SetADCchannel(Int_t supermodule, Int_t column, Int_t row, Float_t value)
{ 
  // Set ADC channel width values
  fADCchannel[supermodule][column][row] = value;
}

//________________________________________________________________
void AliEMCALCalibData::SetADCpedestal(Int_t supermodule, Int_t column, Int_t row, Float_t value)
{
  // Set ADC pedestal values
  fADCpedestal[supermodule][column][row] = value;
}

//________________________________________________________________
void AliEMCALCalibData::Fill(const AliEMCALCalibData *cd1, const AliEMCALCalibData *cd2, Bool_t print)
{
  // Fill for (relative) recalibration to undo calibration 
  // from 1 and apply calibration from 2.

  Int_t nSMod = AliEMCALGeoParams::fgkEMCALModules; //12
  Int_t nCol  = AliEMCALGeoParams::fgkEMCALCols;    //48
  Int_t nRow  = AliEMCALGeoParams::fgkEMCALRows;    //24
  Int_t nRow2 = AliEMCALGeoParams::fgkEMCALRows/2;  //12 - Modules 11 and 12 are half modules
  for (Int_t supermodule=0; supermodule<nSMod; supermodule++) {
    if(supermodule >= 10)
      nRow = nRow2;
    for (Int_t column=0; column<nCol; column++) {
      for (Int_t row=0; row<nRow; row++){
        Double_t adc1 = cd1->GetADCchannel(supermodule, column, row);
        Double_t ped1 = cd1->GetADCpedestal(supermodule, column, row);
        Double_t adc2 = cd2->GetADCchannel(supermodule, column, row);
        Double_t ped2 = cd2->GetADCpedestal(supermodule, column, row);
        Double_t adc = adc2/adc1;
        Double_t ped = ped2-adc*ped1;
        if (print)
          printf("%d %d %d: %f %f %f %f -> %f %f\n",supermodule,column,row,adc1,ped1,adc2,ped2,adc,ped);
        fADCchannel [supermodule][column][row]=adc;
        fADCpedestal[supermodule][column][row]=ped;
      }
    }
  } 
}
Commit	Line	Data
f565d89d	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, 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
	16	/* $Id$ */
	17
63b315c5	18	//_________________________________________________________________________
	19	///*-- Author: Yves Schutz (SUBATECH)
	20	// : Aleksei Pavlinov (WSU); Jun 30, 2006 - ALICE numbering scheme
f565d89d	21	///////////////////////////////////////////////////////////////////////////////
	22	// //
	23	// class for EMCAL calibration //
	24	// //
	25	///////////////////////////////////////////////////////////////////////////////
	26
090026bf	27	#include <TMath.h>
090026bf	28
f565d89d	29	#include "AliEMCALCalibData.h"
	30
	31	ClassImp(AliEMCALCalibData)
	32
	33	//________________________________________________________________
	34	AliEMCALCalibData::AliEMCALCalibData()
	35	{
	36	// Default constructor
	37	Reset();
	38	}
	39
	40	//________________________________________________________________
	41	AliEMCALCalibData::AliEMCALCalibData(const char* name)
	42	{
	43	// Constructor
	44	TString namst = "Calib_";
	45	namst += name;
	46	SetName(namst.Data());
	47	SetTitle(namst.Data());
	48	Reset();
	49	}
	50
	51	//________________________________________________________________
	52	AliEMCALCalibData::AliEMCALCalibData(const AliEMCALCalibData& calibda) :
	53	TNamed(calibda)
	54	{
	55	// copy constructor
	56	SetName(calibda.GetName());
	57	SetTitle(calibda.GetName());
	58	Reset();
	59
0c5b726e	60	Int_t nSMod = AliEMCALGeoParams::fgkEMCALModules; //12
	61	Int_t nCol = AliEMCALGeoParams::fgkEMCALCols; //48
	62	Int_t nRow = AliEMCALGeoParams::fgkEMCALRows; //24
	63	Int_t nRow2 = AliEMCALGeoParams::fgkEMCALRows; //12 - Modules 11 and 12 are half modules
f565d89d	64
f565d89d	65	for(Int_t supermodule=0; supermodule<nSMod; supermodule++) {
9219ceb6	66	if(supermodule >= 10)
beb28b95	67	nRow = nRow2;
f565d89d	68	for(Int_t column=0; column<nCol; column++) {
	69	for(Int_t row=0; row<nRow; row++) {
	70	fADCchannel[supermodule][column][row] =
	71	calibda.GetADCchannel(supermodule,column,row);
	72	fADCpedestal[supermodule][column][row] =
	73	calibda.GetADCpedestal(supermodule,column,row);
	74	}
	75	}
	76	}
	77	}
	78
	79
	80	//________________________________________________________________
	81	AliEMCALCalibData &AliEMCALCalibData::operator =(const AliEMCALCalibData& calibda)
	82	{
	83	// assignment operator
	84	SetName(calibda.GetName());
	85	SetTitle(calibda.GetName());
	86	Reset();
	87
0c5b726e	88	Int_t nSMod = AliEMCALGeoParams::fgkEMCALModules; //12
	89	Int_t nCol = AliEMCALGeoParams::fgkEMCALCols; //48
	90	Int_t nRow = AliEMCALGeoParams::fgkEMCALRows; //24
	91	Int_t nRow2 = AliEMCALGeoParams::fgkEMCALRows/2; //12 - Modules 11 and 12 are half modules
f565d89d	92
f565d89d	93	for(Int_t supermodule=0; supermodule<nSMod; supermodule++) {
9219ceb6	94	if(supermodule >= 10)
beb28b95	95	nRow = nRow2;
f565d89d	96	for(Int_t column=0; column<nCol; column++) {
	97	for(Int_t row=0; row<nRow; row++) {
	98	fADCchannel[supermodule][column][row] =
	99	calibda.GetADCchannel(supermodule,column,row);
	100	fADCpedestal[supermodule][column][row] =
	101	calibda.GetADCpedestal(supermodule,column,row);
	102	}
	103	}
	104	}
	105	return *this;
	106	}
	107
	108	//________________________________________________________________
	109	AliEMCALCalibData::~AliEMCALCalibData()
	110	{
	111	// Destructor
	112	}
	113
	114	//________________________________________________________________
	115	void AliEMCALCalibData::Reset()
	116	{
	117	// Set all pedestals to 0 and all ADC channels widths to 1
0c5b726e	118	//memset(fADCchannel ,1,124824*sizeof(Float_t));
0c5b726e	119	//memset(fADCpedestal,0,124824*sizeof(Float_t));
0e76a7bf	120
	121	Int_t nSMod = AliEMCALGeoParams::fgkEMCALModules; //12
	122	Int_t nCol = AliEMCALGeoParams::fgkEMCALCols; //48
	123	Int_t nRow = AliEMCALGeoParams::fgkEMCALRows; //24
	124	Int_t nRow2 = AliEMCALGeoParams::fgkEMCALRows/2; //12 - Modules 11 and 12 are half modules
	125	for (Int_t supermodule=0; supermodule<nSMod; supermodule++){
	126	if(supermodule >= 10)
	127	nRow = nRow2;
	128	for (Int_t column=0; column<nCol; column++){
	129	for (Int_t row=0; row<nRow; row++){
	130	fADCpedestal[supermodule][column][row]=0.;
	131	fADCchannel [supermodule][column][row]=1.;
	132	}
	133	}
	134	}
f565d89d	135	}
	136
	137	//________________________________________________________________
	138	void AliEMCALCalibData::Print(Option_t *option) const
	139	{
	140	// Print tables of pedestals and ADC channels widths
	141
0c5b726e	142	Int_t nSMod = AliEMCALGeoParams::fgkEMCALModules; //12
	143	Int_t nCol = AliEMCALGeoParams::fgkEMCALCols; //48
	144	Int_t nRow = AliEMCALGeoParams::fgkEMCALRows; //24
	145	Int_t nRow2 = AliEMCALGeoParams::fgkEMCALRows/2; //12 - Modules 11 and 12 are half modules
f565d89d	146	if (strstr(option,"ped")) {
	147	printf("\n ---- Pedestal values ----\n\n");
	148	for (Int_t supermodule=0; supermodule<nSMod; supermodule++){
9219ceb6	149	if(supermodule >= 10)
beb28b95	150	nRow = nRow2;
f565d89d	151	printf("============== Supermodule %d\n",supermodule+1);
	152	for (Int_t column=0; column<nCol; column++){
	153	for (Int_t row=0; row<nRow; row++){
636af9b4	154	printf(" %2.4f ",fADCpedestal[supermodule][column][row]);
f565d89d	155	}
	156	printf("\n");
	157	}
	158	}
	159	}
	160
	161
	162	if (strstr(option,"gain")) {
	163	printf("\n ---- ADC channel values ----\n\n");
	164	for (Int_t supermodule=0; supermodule<nSMod; supermodule++){
9219ceb6	165	if(supermodule >= 10)
beb28b95	166	nRow = nRow2;
f565d89d	167	printf("============== Supermodule %d\n",supermodule+1);
	168	for (Int_t column=0; column<nCol; column++){
	169	for (Int_t row=0; row<nRow; row++){
636af9b4	170	printf(" %2.4f ",fADCchannel[supermodule][column][row]);
f565d89d	171	}
	172	printf("\n");
	173	}
	174	}
	175	}
	176	}
	177
	178	//________________________________________________________________
	179	Float_t AliEMCALCalibData::GetADCchannel(Int_t supermodule, Int_t column, Int_t row) const
	180	{
	181	// Set ADC channel witdth values
63b315c5	182	// All indexes start from 0!
	183	// Supermodule, column,raw should follow the ALICE convention:
	184	// supermodule 0:11, column 0:47, row 0:23
f565d89d	185
63b315c5	186	return fADCchannel[supermodule][column][row];
f565d89d	187	}
	188
	189	//________________________________________________________________
	190	Float_t AliEMCALCalibData::GetADCpedestal(Int_t supermodule, Int_t column, Int_t row) const
	191	{
	192	// Get ADC pedestal values
63b315c5	193	return fADCpedestal[supermodule][column][row];
f565d89d	194	}
	195
	196	//________________________________________________________________
	197	void AliEMCALCalibData::SetADCchannel(Int_t supermodule, Int_t column, Int_t row, Float_t value)
	198	{
	199	// Set ADC channel width values
63b315c5	200	fADCchannel[supermodule][column][row] = value;
f565d89d	201	}
	202
	203	//________________________________________________________________
	204	void AliEMCALCalibData::SetADCpedestal(Int_t supermodule, Int_t column, Int_t row, Float_t value)
	205	{
	206	// Set ADC pedestal values
63b315c5	207	fADCpedestal[supermodule][column][row] = value;
f565d89d	208	}
0e76a7bf	209
	210	//________________________________________________________________
	211	void AliEMCALCalibData::Fill(const AliEMCALCalibData cd1, const AliEMCALCalibData cd2, Bool_t print)
	212	{
	213	// Fill for (relative) recalibration to undo calibration
	214	// from 1 and apply calibration from 2.
	215
	216	Int_t nSMod = AliEMCALGeoParams::fgkEMCALModules; //12
	217	Int_t nCol = AliEMCALGeoParams::fgkEMCALCols; //48
	218	Int_t nRow = AliEMCALGeoParams::fgkEMCALRows; //24
	219	Int_t nRow2 = AliEMCALGeoParams::fgkEMCALRows/2; //12 - Modules 11 and 12 are half modules
	220	for (Int_t supermodule=0; supermodule<nSMod; supermodule++) {
	221	if(supermodule >= 10)
	222	nRow = nRow2;
	223	for (Int_t column=0; column<nCol; column++) {
	224	for (Int_t row=0; row<nRow; row++){
	225	Double_t adc1 = cd1->GetADCchannel(supermodule, column, row);
	226	Double_t ped1 = cd1->GetADCpedestal(supermodule, column, row);
	227	Double_t adc2 = cd2->GetADCchannel(supermodule, column, row);
	228	Double_t ped2 = cd2->GetADCpedestal(supermodule, column, row);
	229	Double_t adc = adc2/adc1;
	230	Double_t ped = ped2-adc*ped1;
	231	if (print)
	232	printf("%d %d %d: %f %f %f %f -> %f %f\n",supermodule,column,row,adc1,ped1,adc2,ped2,adc,ped);
	233	fADCchannel [supermodule][column][row]=adc;
	234	fADCpedestal[supermodule][column][row]=ped;
	235	}
	236	}
	237	}
	238	}
	239