[u/mrichter/AliRoot.git] / FMD / AliFMDParameters.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$ */

//____________________________________________________________________
//                                                                          
// Forward Multiplicity Detector based on Silicon wafers. 
//
// This class is a singleton that handles various parameters of
// the FMD detectors.  
// Eventually, this class will use the Conditions DB to get the
// various parameters, which code can then request from here.
//                                                       
#include "AliLog.h"		   // ALILOG_H
#include "AliFMDParameters.h"	   // ALIFMDPARAMETERS_H
#include "AliFMDGeometry.h"	   // ALIFMDGEOMETRY_H
#include "AliFMDRing.h"	           // ALIFMDRING_H
#include "AliFMDCalibGain.h"       // ALIFMDCALIBGAIN_H
#include "AliFMDCalibPedestal.h"   // ALIFMDCALIBPEDESTAL_H
#include "AliFMDCalibSampleRate.h" // ALIFMDCALIBPEDESTAL_H
#include "AliFMDAltroMapping.h"    // ALIFMDALTROMAPPING_H
#include <AliCDBManager.h>         // ALICDBMANAGER_H
#include <AliCDBEntry.h>           // ALICDBMANAGER_H
#include <Riostream.h>

//====================================================================
ClassImp(AliFMDParameters)
#if 0
  ; // This is here to keep Emacs for indenting the next line
#endif

//____________________________________________________________________
AliFMDParameters* AliFMDParameters::fgInstance = 0;

//____________________________________________________________________
const char* AliFMDParameters::fgkPulseGain	 = "FMD/Calib/PulseGain";
const char* AliFMDParameters::fgkPedestal	 = "FMD/Calib/Pedestal";
const char* AliFMDParameters::fgkDead	         = "FMD/Calib/Dead";
const char* AliFMDParameters::fgkSampleRate	 = "FMD/Calib/SampleRate";
const char* AliFMDParameters::fgkAltroMap	 = "FMD/Calib/AltroMap";
const char* AliFMDParameters::fgkZeroSuppression = "FMD/Calib/ZeroSuppression";


//____________________________________________________________________
AliFMDParameters* 
AliFMDParameters::Instance() 
{
  // Get static instance 
  if (!fgInstance) fgInstance = new AliFMDParameters;
  return fgInstance;
}

//____________________________________________________________________
AliFMDParameters::AliFMDParameters() 
  : fIsInit(kFALSE),
    fSiDeDxMip(1.664), 
    fFixedPulseGain(0), 
    fEdepMip(0),
    fZeroSuppression(0), 
    fSampleRate(0), 
    fPedestal(0), 
    fPulseGain(0), 
    fDeadMap(0), 
    fAltroMap(0)
{
  // Default constructor 
  SetVA1MipRange();
  SetAltroChannelSize();
  SetChannelsPerAltro();
  SetZeroSuppression();
  SetSampleRate();
  SetPedestal();
  SetPedestalWidth();
  SetPedestalFactor();
  SetThreshold();
}

//__________________________________________________________________
void
AliFMDParameters::Init()
{
  // Initialize the parameters manager.  We need to get stuff from the
  // CDB here. 
  if (fIsInit) return;
  InitPulseGain();
  InitPedestal();
  InitDeadMap();
  InitSampleRate();
  InitZeroSuppression();
  InitAltroMap();
  fIsInit = kTRUE;
  
}
//__________________________________________________________________
void
AliFMDParameters::InitPulseGain()
{
  AliCDBManager* cdb      = AliCDBManager::Instance();
  AliCDBEntry*   gain     = cdb->Get(fgkPulseGain);
  if (!gain) {
    AliWarning(Form("No %s found in CDB, perhaps you need to "
		    "use AliFMDCalibFaker?", fgkPulseGain));
    return;
  }
  
  AliDebug(1, Form("Got gain from CDB"));
  fPulseGain = dynamic_cast<AliFMDCalibGain*>(gain->GetObject());
  if (!fPulseGain) AliWarning("Invalid pulser gain object from CDB");
}
//__________________________________________________________________
void
AliFMDParameters::InitPedestal()
{
  AliCDBManager* cdb      = AliCDBManager::Instance();
  AliCDBEntry*   pedestal = cdb->Get(fgkPedestal);
  if (!pedestal) {
    AliWarning(Form("No %s found in CDB, perhaps you need to "
		    "use AliFMDCalibFaker?", fgkPedestal));
    return;
  }
  AliDebug(1, Form("Got pedestal from CDB"));
  fPedestal = dynamic_cast<AliFMDCalibPedestal*>(pedestal->GetObject());
  if (!fPedestal) AliWarning("Invalid pedestal object from CDB");
}

//__________________________________________________________________
void
AliFMDParameters::InitDeadMap()
{
  AliCDBManager* cdb      = AliCDBManager::Instance();
  AliCDBEntry*   deadMap  = cdb->Get(fgkDead);
  if (!deadMap) {
    AliWarning(Form("No %s found in CDB, perhaps you need to "
		    "use AliFMDCalibFaker?", fgkDead));
    return;
  }
  AliDebug(1, Form("Got dead map from CDB"));
  fDeadMap = dynamic_cast<AliFMDCalibDeadMap*>(deadMap->GetObject());
  if (!fDeadMap) AliWarning("Invalid dead map object from CDB");
}

//__________________________________________________________________
void
AliFMDParameters::InitZeroSuppression()
{
  AliCDBManager* cdb      = AliCDBManager::Instance();
  AliCDBEntry*   zeroSup  = cdb->Get(fgkZeroSuppression);
  if (!zeroSup) {
    AliWarning(Form("No %s found in CDB, perhaps you need to "
		    "use AliFMDCalibFaker?", fgkZeroSuppression));
    return;
  }
  AliDebug(1, Form("Got zero suppression from CDB"));
  fZeroSuppression = 
    dynamic_cast<AliFMDCalibZeroSuppression*>(zeroSup->GetObject());
  if (!fZeroSuppression)AliWarning("Invalid zero suppression object from CDB");
}

//__________________________________________________________________
void
AliFMDParameters::InitSampleRate()
{
  AliCDBManager* cdb      = AliCDBManager::Instance();
  AliCDBEntry*   sampRat  = cdb->Get(fgkSampleRate);
  if (!sampRat) {
    AliWarning(Form("No %s found in CDB, perhaps you need to "
		    "use AliFMDCalibFaker?", fgkSampleRate));
    return;
  }
  AliDebug(1, Form("Got zero suppression from CDB"));
  fSampleRate = dynamic_cast<AliFMDCalibSampleRate*>(sampRat->GetObject());
  if (!fSampleRate) AliWarning("Invalid zero suppression object from CDB");
}

//__________________________________________________________________
void
AliFMDParameters::InitAltroMap()
{
  AliCDBManager* cdb      = AliCDBManager::Instance();
  AliCDBEntry*   hwMap    = cdb->Get(fgkAltroMap);       
  if (!hwMap) {
    AliWarning(Form("No %s found in CDB, perhaps you need to "
		    "use AliFMDCalibFaker?", fgkAltroMap));
    fAltroMap = new AliFMDAltroMapping;
    return;
  }
  AliDebug(1, Form("Got ALTRO map from CDB"));
  fAltroMap = dynamic_cast<AliFMDAltroMapping*>(hwMap->GetObject());
  if (!fAltroMap) {
    AliWarning("Invalid ALTRO map object from CDB");
    fAltroMap = new AliFMDAltroMapping;
  }
}


//__________________________________________________________________
Float_t
AliFMDParameters::GetThreshold() const
{
  if (!fPulseGain) return fFixedThreshold;
  return fPulseGain->Threshold();
}

//__________________________________________________________________
Float_t
AliFMDParameters::GetPulseGain(UShort_t detector, Char_t ring, 
			       UShort_t sector, UShort_t strip) const
{
  // Returns the pulser calibrated gain for strip # strip in sector #
  // sector or ring id ring of detector # detector. 
  // 
  // For simulation, this is normally set to 
  // 
  //       VA1_MIP_Range 
  //    ------------------ * MIP_Energy_Loss
  //    ALTRO_channel_size
  // 
  if (!fPulseGain) { 
    if (fFixedPulseGain <= 0)
      fFixedPulseGain = fVA1MipRange * GetEdepMip() / fAltroChannelSize;
    return fFixedPulseGain;
  }  
  AliDebug(50, Form("pulse gain for FMD%d%c[%2d,%3d]=%f",
		    detector, ring, sector, strip,
		    fPulseGain->Value(detector, ring, sector, strip)));
  return fPulseGain->Value(detector, ring, sector, strip);
}

//__________________________________________________________________
Bool_t
AliFMDParameters::IsDead(UShort_t detector, Char_t ring, 
			 UShort_t sector, UShort_t strip) const
{
  if (!fDeadMap) return kFALSE;
  AliDebug(50, Form("Dead for FMD%d%c[%2d,%3d]=%s",
		    detector, ring, sector, strip,
		    fDeadMap->operator()(detector, ring, sector, strip) ? 
		    "no" : "yes"));
  return fDeadMap->operator()(detector, ring, sector, strip);
}

//__________________________________________________________________
UShort_t
AliFMDParameters::GetZeroSuppression(UShort_t detector, Char_t ring, 
				     UShort_t sector, UShort_t strip) const
{
  if (!fZeroSuppression) return fFixedZeroSuppression;
  // Need to map strip to ALTRO chip. 
  AliDebug(50, Form("zero sup. for FMD%d%c[%2d,%3d]=%f",
		    detector, ring, sector, strip,
		    fZeroSuppression->operator()(detector, ring, 
						 sector, strip)));
  return fZeroSuppression->operator()(detector, ring, sector, strip/128);
}

//__________________________________________________________________
UShort_t
AliFMDParameters::GetSampleRate(UShort_t ddl) const
{
  if (!fSampleRate) return fFixedSampleRate;
  // Need to map sector to digitizier card. 
  AliDebug(50, Form("Sample rate for %d=%d", ddl, fSampleRate->Rate(ddl)));
  return fSampleRate->Rate(ddl);
}

//__________________________________________________________________
Float_t
AliFMDParameters::GetPedestal(UShort_t detector, Char_t ring, 
			      UShort_t sector, UShort_t strip) const
{
  if (!fPedestal) return fFixedPedestal;
  AliDebug(50, Form("pedestal for FMD%d%c[%2d,%3d]=%f",
		    detector, ring, sector, strip,
		    fPedestal->Value(detector, ring, sector, strip)));
  return fPedestal->Value(detector, ring, sector, strip);
}

//__________________________________________________________________
Float_t
AliFMDParameters::GetPedestalWidth(UShort_t detector, Char_t ring, 
				   UShort_t sector, UShort_t strip) const
{
  if (!fPedestal) return fFixedPedestalWidth;
  AliDebug(50, Form("pedetal width for FMD%d%c[%2d,%3d]=%f",
		    detector, ring, sector, strip,
		    fPedestal->Width(detector, ring, sector, strip)));
  return fPedestal->Width(detector, ring, sector, strip);
}
  
//__________________________________________________________________
AliFMDAltroMapping*
AliFMDParameters::GetAltroMap() const
{
  return fAltroMap;
}


//__________________________________________________________________
Bool_t
AliFMDParameters::Hardware2Detector(UInt_t ddl, UInt_t addr, UShort_t& det,
				    Char_t& ring, UShort_t& sec, 
				    UShort_t& str) const
{
  if (!fAltroMap) return kFALSE;
  return fAltroMap->Hardware2Detector(ddl, addr, det, ring, sec, str);
}

//__________________________________________________________________
Bool_t
AliFMDParameters::Detector2Hardware(UShort_t det, Char_t ring, UShort_t sec, 
				    UShort_t str, UInt_t& ddl, 
				    UInt_t& addr) const			      
{
  if (!fAltroMap) return kFALSE;
  return fAltroMap->Detector2Hardware(det, ring, sec, str, ddl, addr);
}


//__________________________________________________________________
Float_t
AliFMDParameters::GetEdepMip() const 
{ 
  // Get energy deposited by a MIP in the silicon sensors
  if (fEdepMip <= 0){
    AliFMDGeometry* fmd = AliFMDGeometry::Instance();
    fEdepMip = (fSiDeDxMip 
		* fmd->GetRing('I')->GetSiThickness() 
		* fmd->GetSiDensity());
  }
  return fEdepMip;
}


//____________________________________________________________________
//
// EOF
//
Commit	Line	Data
	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
	18	//____________________________________________________________________
	19	//
	20	// Forward Multiplicity Detector based on Silicon wafers.
	21	//
	22	// This class is a singleton that handles various parameters of
	23	// the FMD detectors.
	24	// Eventually, this class will use the Conditions DB to get the
	25	// various parameters, which code can then request from here.
	26	//
	27	#include "AliLog.h" // ALILOG_H
	28	#include "AliFMDParameters.h" // ALIFMDPARAMETERS_H
	29	#include "AliFMDGeometry.h" // ALIFMDGEOMETRY_H
	30	#include "AliFMDRing.h" // ALIFMDRING_H
	31	#include "AliFMDCalibGain.h" // ALIFMDCALIBGAIN_H
	32	#include "AliFMDCalibPedestal.h" // ALIFMDCALIBPEDESTAL_H
	33	#include "AliFMDCalibSampleRate.h" // ALIFMDCALIBPEDESTAL_H
	34	#include "AliFMDAltroMapping.h" // ALIFMDALTROMAPPING_H
	35	#include <AliCDBManager.h> // ALICDBMANAGER_H
	36	#include <AliCDBEntry.h> // ALICDBMANAGER_H
	37	#include <Riostream.h>
	38
	39	//====================================================================
	40	ClassImp(AliFMDParameters)
	41	#if 0
	42	; // This is here to keep Emacs for indenting the next line
	43	#endif
	44
	45	//____________________________________________________________________
	46	AliFMDParameters* AliFMDParameters::fgInstance = 0;
	47
	48	//____________________________________________________________________
	49	const char* AliFMDParameters::fgkPulseGain = "FMD/Calib/PulseGain";
	50	const char* AliFMDParameters::fgkPedestal = "FMD/Calib/Pedestal";
	51	const char* AliFMDParameters::fgkDead = "FMD/Calib/Dead";
	52	const char* AliFMDParameters::fgkSampleRate = "FMD/Calib/SampleRate";
	53	const char* AliFMDParameters::fgkAltroMap = "FMD/Calib/AltroMap";
	54	const char* AliFMDParameters::fgkZeroSuppression = "FMD/Calib/ZeroSuppression";
	55
	56
	57	//____________________________________________________________________
	58	AliFMDParameters*
	59	AliFMDParameters::Instance()
	60	{
	61	// Get static instance
	62	if (!fgInstance) fgInstance = new AliFMDParameters;
	63	return fgInstance;
	64	}
	65
	66	//____________________________________________________________________
	67	AliFMDParameters::AliFMDParameters()
	68	: fIsInit(kFALSE),
	69	fSiDeDxMip(1.664),
	70	fFixedPulseGain(0),
	71	fEdepMip(0),
	72	fZeroSuppression(0),
	73	fSampleRate(0),
	74	fPedestal(0),
	75	fPulseGain(0),
	76	fDeadMap(0),
	77	fAltroMap(0)
	78	{
	79	// Default constructor
	80	SetVA1MipRange();
	81	SetAltroChannelSize();
	82	SetChannelsPerAltro();
	83	SetZeroSuppression();
	84	SetSampleRate();
	85	SetPedestal();
	86	SetPedestalWidth();
	87	SetPedestalFactor();
	88	SetThreshold();
	89	}
	90
	91	//__________________________________________________________________
	92	void
	93	AliFMDParameters::Init()
	94	{
	95	// Initialize the parameters manager. We need to get stuff from the
	96	// CDB here.
	97	if (fIsInit) return;
	98	InitPulseGain();
	99	InitPedestal();
	100	InitDeadMap();
	101	InitSampleRate();
	102	InitZeroSuppression();
	103	InitAltroMap();
	104	fIsInit = kTRUE;
	105
	106	}
	107	//__________________________________________________________________
	108	void
	109	AliFMDParameters::InitPulseGain()
	110	{
	111	AliCDBManager* cdb = AliCDBManager::Instance();
	112	AliCDBEntry* gain = cdb->Get(fgkPulseGain);
	113	if (!gain) {
	114	AliWarning(Form("No %s found in CDB, perhaps you need to "
	115	"use AliFMDCalibFaker?", fgkPulseGain));
	116	return;
	117	}
	118
	119	AliDebug(1, Form("Got gain from CDB"));
	120	fPulseGain = dynamic_cast<AliFMDCalibGain*>(gain->GetObject());
	121	if (!fPulseGain) AliWarning("Invalid pulser gain object from CDB");
	122	}
	123	//__________________________________________________________________
	124	void
	125	AliFMDParameters::InitPedestal()
	126	{
	127	AliCDBManager* cdb = AliCDBManager::Instance();
	128	AliCDBEntry* pedestal = cdb->Get(fgkPedestal);
	129	if (!pedestal) {
	130	AliWarning(Form("No %s found in CDB, perhaps you need to "
	131	"use AliFMDCalibFaker?", fgkPedestal));
	132	return;
	133	}
	134	AliDebug(1, Form("Got pedestal from CDB"));
	135	fPedestal = dynamic_cast<AliFMDCalibPedestal*>(pedestal->GetObject());
	136	if (!fPedestal) AliWarning("Invalid pedestal object from CDB");
	137	}
	138
	139	//__________________________________________________________________
	140	void
	141	AliFMDParameters::InitDeadMap()
	142	{
	143	AliCDBManager* cdb = AliCDBManager::Instance();
	144	AliCDBEntry* deadMap = cdb->Get(fgkDead);
	145	if (!deadMap) {
	146	AliWarning(Form("No %s found in CDB, perhaps you need to "
	147	"use AliFMDCalibFaker?", fgkDead));
	148	return;
	149	}
	150	AliDebug(1, Form("Got dead map from CDB"));
	151	fDeadMap = dynamic_cast<AliFMDCalibDeadMap*>(deadMap->GetObject());
	152	if (!fDeadMap) AliWarning("Invalid dead map object from CDB");
	153	}
	154
	155	//__________________________________________________________________
	156	void
	157	AliFMDParameters::InitZeroSuppression()
	158	{
	159	AliCDBManager* cdb = AliCDBManager::Instance();
	160	AliCDBEntry* zeroSup = cdb->Get(fgkZeroSuppression);
	161	if (!zeroSup) {
	162	AliWarning(Form("No %s found in CDB, perhaps you need to "
	163	"use AliFMDCalibFaker?", fgkZeroSuppression));
	164	return;
	165	}
	166	AliDebug(1, Form("Got zero suppression from CDB"));
	167	fZeroSuppression =
	168	dynamic_cast<AliFMDCalibZeroSuppression*>(zeroSup->GetObject());
	169	if (!fZeroSuppression)AliWarning("Invalid zero suppression object from CDB");
	170	}
	171
	172	//__________________________________________________________________
	173	void
	174	AliFMDParameters::InitSampleRate()
	175	{
	176	AliCDBManager* cdb = AliCDBManager::Instance();
	177	AliCDBEntry* sampRat = cdb->Get(fgkSampleRate);
	178	if (!sampRat) {
	179	AliWarning(Form("No %s found in CDB, perhaps you need to "
	180	"use AliFMDCalibFaker?", fgkSampleRate));
	181	return;
	182	}
	183	AliDebug(1, Form("Got zero suppression from CDB"));
	184	fSampleRate = dynamic_cast<AliFMDCalibSampleRate*>(sampRat->GetObject());
	185	if (!fSampleRate) AliWarning("Invalid zero suppression object from CDB");
	186	}
	187
	188	//__________________________________________________________________
	189	void
	190	AliFMDParameters::InitAltroMap()
	191	{
	192	AliCDBManager* cdb = AliCDBManager::Instance();
	193	AliCDBEntry* hwMap = cdb->Get(fgkAltroMap);
	194	if (!hwMap) {
	195	AliWarning(Form("No %s found in CDB, perhaps you need to "
	196	"use AliFMDCalibFaker?", fgkAltroMap));
	197	fAltroMap = new AliFMDAltroMapping;
	198	return;
	199	}
	200	AliDebug(1, Form("Got ALTRO map from CDB"));
	201	fAltroMap = dynamic_cast<AliFMDAltroMapping*>(hwMap->GetObject());
	202	if (!fAltroMap) {
	203	AliWarning("Invalid ALTRO map object from CDB");
	204	fAltroMap = new AliFMDAltroMapping;
	205	}
	206	}
	207
	208
	209	//__________________________________________________________________
	210	Float_t
	211	AliFMDParameters::GetThreshold() const
	212	{
	213	if (!fPulseGain) return fFixedThreshold;
	214	return fPulseGain->Threshold();
	215	}
	216
	217	//__________________________________________________________________
	218	Float_t
	219	AliFMDParameters::GetPulseGain(UShort_t detector, Char_t ring,
	220	UShort_t sector, UShort_t strip) const
	221	{
	222	// Returns the pulser calibrated gain for strip # strip in sector #
	223	// sector or ring id ring of detector # detector.
	224	//
	225	// For simulation, this is normally set to
	226	//
	227	// VA1_MIP_Range
	228	// ------------------ * MIP_Energy_Loss
	229	// ALTRO_channel_size
	230	//
	231	if (!fPulseGain) {
	232	if (fFixedPulseGain <= 0)
	233	fFixedPulseGain = fVA1MipRange * GetEdepMip() / fAltroChannelSize;
	234	return fFixedPulseGain;
	235	}
	236	AliDebug(50, Form("pulse gain for FMD%d%c[%2d,%3d]=%f",
	237	detector, ring, sector, strip,
	238	fPulseGain->Value(detector, ring, sector, strip)));
	239	return fPulseGain->Value(detector, ring, sector, strip);
	240	}
	241
	242	//__________________________________________________________________
	243	Bool_t
	244	AliFMDParameters::IsDead(UShort_t detector, Char_t ring,
	245	UShort_t sector, UShort_t strip) const
	246	{
	247	if (!fDeadMap) return kFALSE;
	248	AliDebug(50, Form("Dead for FMD%d%c[%2d,%3d]=%s",
	249	detector, ring, sector, strip,
	250	fDeadMap->operator()(detector, ring, sector, strip) ?
	251	"no" : "yes"));
	252	return fDeadMap->operator()(detector, ring, sector, strip);
	253	}
	254
	255	//__________________________________________________________________
	256	UShort_t
	257	AliFMDParameters::GetZeroSuppression(UShort_t detector, Char_t ring,
	258	UShort_t sector, UShort_t strip) const
	259	{
	260	if (!fZeroSuppression) return fFixedZeroSuppression;
	261	// Need to map strip to ALTRO chip.
	262	AliDebug(50, Form("zero sup. for FMD%d%c[%2d,%3d]=%f",
	263	detector, ring, sector, strip,
	264	fZeroSuppression->operator()(detector, ring,
	265	sector, strip)));
	266	return fZeroSuppression->operator()(detector, ring, sector, strip/128);
	267	}
	268
	269	//__________________________________________________________________
	270	UShort_t
	271	AliFMDParameters::GetSampleRate(UShort_t ddl) const
	272	{
	273	if (!fSampleRate) return fFixedSampleRate;
	274	// Need to map sector to digitizier card.
	275	AliDebug(50, Form("Sample rate for %d=%d", ddl, fSampleRate->Rate(ddl)));
	276	return fSampleRate->Rate(ddl);
	277	}
	278
	279	//__________________________________________________________________
	280	Float_t
	281	AliFMDParameters::GetPedestal(UShort_t detector, Char_t ring,
	282	UShort_t sector, UShort_t strip) const
	283	{
	284	if (!fPedestal) return fFixedPedestal;
	285	AliDebug(50, Form("pedestal for FMD%d%c[%2d,%3d]=%f",
	286	detector, ring, sector, strip,
	287	fPedestal->Value(detector, ring, sector, strip)));
	288	return fPedestal->Value(detector, ring, sector, strip);
	289	}
	290
	291	//__________________________________________________________________
	292	Float_t
	293	AliFMDParameters::GetPedestalWidth(UShort_t detector, Char_t ring,
	294	UShort_t sector, UShort_t strip) const
	295	{
	296	if (!fPedestal) return fFixedPedestalWidth;
	297	AliDebug(50, Form("pedetal width for FMD%d%c[%2d,%3d]=%f",
	298	detector, ring, sector, strip,
	299	fPedestal->Width(detector, ring, sector, strip)));
	300	return fPedestal->Width(detector, ring, sector, strip);
	301	}
	302
	303	//__________________________________________________________________
	304	AliFMDAltroMapping*
	305	AliFMDParameters::GetAltroMap() const
	306	{
	307	return fAltroMap;
	308	}
	309
	310
	311	//__________________________________________________________________
	312	Bool_t
	313	AliFMDParameters::Hardware2Detector(UInt_t ddl, UInt_t addr, UShort_t& det,
	314	Char_t& ring, UShort_t& sec,
	315	UShort_t& str) const
	316	{
	317	if (!fAltroMap) return kFALSE;
	318	return fAltroMap->Hardware2Detector(ddl, addr, det, ring, sec, str);
	319	}
	320
	321	//__________________________________________________________________
	322	Bool_t
	323	AliFMDParameters::Detector2Hardware(UShort_t det, Char_t ring, UShort_t sec,
	324	UShort_t str, UInt_t& ddl,
	325	UInt_t& addr) const
	326	{
	327	if (!fAltroMap) return kFALSE;
	328	return fAltroMap->Detector2Hardware(det, ring, sec, str, ddl, addr);
	329	}
	330
	331
	332	//__________________________________________________________________
	333	Float_t
	334	AliFMDParameters::GetEdepMip() const
	335	{
	336	// Get energy deposited by a MIP in the silicon sensors
	337	if (fEdepMip <= 0){
	338	AliFMDGeometry* fmd = AliFMDGeometry::Instance();
	339	fEdepMip = (fSiDeDxMip
	340	* fmd->GetRing('I')->GetSiThickness()
	341	* fmd->GetSiDensity());
	342	}
	343	return fEdepMip;
	344	}
	345
	346
	347
	348
	349
	350	//____________________________________________________________________
	351	//
	352	// EOF
	353	//