[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$ */
/** @file    AliFMDParameters.cxx
    @author  Christian Holm Christensen <cholm@nbi.dk>
    @date    Mon Mar 27 12:44:26 2006
    @brief   Manager of FMD parameters     
*/
//____________________________________________________________________
//                                                                          
// 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" // ALIFMDCALIBSAMPLERATE_H
#include "AliFMDCalibStripRange.h" // ALIFMDCALIBSTRIPRANGE_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";
const char* AliFMDParameters::fgkStripRange	 = "FMD/Calib/StripRange";


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

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

//__________________________________________________________________
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::Print(Option_t* option) const
{
  // Print information. 
  // If option contains an 'A' then everything is printed. 
  TString opt(option);
  Bool_t showStrips = opt.Contains("a", TString::kIgnoreCase);
  for (UShort_t det=1 ; det <= 3; det++) {
    std::cout << "FMD" << det << std::endl;
    Char_t rings[] = { 'I', (det == 1 ? '\0' : 'O'), '\0' };
    for (Char_t* ring = rings; *ring != '\0'; ring++) {
      std::cout << " Ring " << *ring << std::endl;
      UShort_t nSec = ( *ring == 'I' ? 20  :  40 );
      UShort_t nStr = ( *ring == 'I' ? 512 : 256 );
      for (UShort_t sec = 0; sec < nSec; sec++) {
	UShort_t min  = GetMinStrip(det, *ring, sec, 0);
	UShort_t max  = GetMaxStrip(det, *ring, sec, 0);
	UShort_t rate = GetSampleRate(det, *ring, sec, 0);
	std::cout << "  Sector " << std::setw(2) << sec 
		  << "  Strip range: " << std::setw(3) << min << "," 
		  << std::setw(3) << max << "  Rate: " << std::setw(2) 
		  << rate << std::endl;
	if (!showStrips) continue;
	std::cout 
	  << "  Strip |     Pedestal      |   Gain   | ZS thr. | Address\n" 
	  << "--------+-------------------+----------+---------+---------" 
	  << std::endl;
        for (UShort_t str = 0; str < nStr; str++) {
	  std::cout << "    " << std::setw(3) << str << " | ";
	  if (IsDead(det, *ring, sec, str)) {
	    std::cout << "dead" << std::endl;
	    continue;
	  }
	  UInt_t ddl, addr;
	  Detector2Hardware(det, *ring, sec, str, ddl, addr);
	  std::cout << std::setw(7) << GetPedestal(det, *ring, sec, str) 
		    << "+/-" << std::setw(7) 
		    << GetPedestalWidth(det, *ring, sec, str) 
		    << " | " << std::setw(8) 
		    << GetPulseGain(det, *ring, sec, str) 
		    << " | " << std::setw(5) 
		    << GetZeroSuppression(det, *ring, sec, str) 
		    << " | 0x" << std::hex << std::setw(4) 
		    << std::setfill('0') << ddl << ",0x" << std::setw(3) 
		    << addr << std::dec << std::setfill(' ') << std::endl;
        }
      }
    }
  }
}

//__________________________________________________________________
void
AliFMDParameters::SetStripRange(UShort_t min, UShort_t max) 
{
  // Set fixed strip range 
  fFixedMinStrip = min;
  fFixedMaxStrip = max;
}

//__________________________________________________________________
void
AliFMDParameters::InitPulseGain()
{
  // Get pulse gain from CDB or used fixed 
  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()
{
  // Initialize the pedestals from CDB 
  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()
{
  // Get Dead-channel-map from CDB 
  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()
{
  // Get 0-suppression from CDB 
  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()
{
  // get Sample rate from CDB
  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()
{
  // Get hardware mapping from CDB
  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;
  }
}

//__________________________________________________________________
void
AliFMDParameters::InitStripRange()
{
  // Get strips read-out from CDB
  AliCDBManager* cdb      = AliCDBManager::Instance();
  AliCDBEntry*   range    = cdb->Get(fgkStripRange);
  if (!range) {
    AliWarning(Form("No %s found in CDB, perhaps you need to "
		    "use AliFMDCalibFaker?", fgkStripRange));
    return;
  }
  AliDebug(1, Form("Got strip range from CDB"));
  fStripRange = dynamic_cast<AliFMDCalibStripRange*>(range->GetObject());
  if (!fStripRange) AliWarning("Invalid strip range object from CDB");
}


//__________________________________________________________________
Float_t
AliFMDParameters::GetThreshold() const
{
  // Get threshold from CDB
  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
{
  // Check if the channel is dead 
  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
{
  // Get zero suppression threshold 
  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 det, Char_t ring, UShort_t sector, 
				UShort_t str) const
{
  // Get sampl rate 
  if (!fSampleRate) return fFixedSampleRate;
  // Need to map sector to digitizier card. 
  UInt_t ret = fSampleRate->Rate(det, ring, sector, str);
  AliDebug(50, Form("Sample rate for FMD%d%c[%2d,%3d]=%d", 
		    det, ring, sector, str, ret));
  return ret;
}

//__________________________________________________________________
UShort_t
AliFMDParameters::GetMinStrip(UShort_t det, Char_t ring, UShort_t sector, 
			      UShort_t str) const
{
  // Get strip range read out 
  if (!fStripRange) return fFixedMinStrip;
  // Need to map sector to digitizier card. 
  UInt_t ret = fStripRange->Min(det, ring, sector, str);
  AliDebug(50, Form("Min strip # for FMD%d%c[%2d,%3d]=%d", 
		    det, ring, sector, str, ret));
  return ret;
}

//__________________________________________________________________
UShort_t
AliFMDParameters::GetMaxStrip(UShort_t det, Char_t ring, UShort_t sector, 
			      UShort_t str) const
{
  // Get strip range read out 
  if (!fStripRange) return fFixedMaxStrip;
  // Need to map sector to digitizier card. 
  UInt_t ret = fStripRange->Max(det, ring, sector, str);
  AliDebug(50, Form("Max strip # for FMD%d%c[%2d,%3d]=%d", 
		    det, ring, sector, str, ret));
  return ret;
}

//__________________________________________________________________
Float_t
AliFMDParameters::GetPedestal(UShort_t detector, Char_t ring, 
			      UShort_t sector, UShort_t strip) const
{
  // Get the pedesal 
  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
{
  // Get the pedesal 
  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
{
  // Get the hardware address to detector index map 
  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
{
  // Map hardware address to detector index
  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			      
{
  // Map detector index to hardware address
  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 = (fkSiDeDxMip 
		* fmd->GetRing('I')->GetSiThickness() 
		* fmd->GetSiDensity());
  }
  return fEdepMip;
}


//____________________________________________________________________
//
// EOF
//
Commit	Line	Data
1a1fdef7	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	**************************************************************************/
1a1fdef7	15	/* $Id$ */
c2fc1258	16	/** @file AliFMDParameters.cxx
	17	@author Christian Holm Christensen <cholm@nbi.dk>
	18	@date Mon Mar 27 12:44:26 2006
	19	@brief Manager of FMD parameters
	20	*/
1a1fdef7	21	//____________________________________________________________________
	22	//
	23	// Forward Multiplicity Detector based on Silicon wafers.
	24	//
	25	// This class is a singleton that handles various parameters of
	26	// the FMD detectors.
088f8e79	27	// Eventually, this class will use the Conditions DB to get the
088f8e79	28	// various parameters, which code can then request from here.
1a1fdef7	29	//
8f6ee336	30	#include "AliLog.h" // ALILOG_H
	31	#include "AliFMDParameters.h" // ALIFMDPARAMETERS_H
	32	#include "AliFMDGeometry.h" // ALIFMDGEOMETRY_H
	33	#include "AliFMDRing.h" // ALIFMDRING_H
	34	#include "AliFMDCalibGain.h" // ALIFMDCALIBGAIN_H
	35	#include "AliFMDCalibPedestal.h" // ALIFMDCALIBPEDESTAL_H
c2fc1258	36	#include "AliFMDCalibSampleRate.h" // ALIFMDCALIBSAMPLERATE_H
c2fc1258	37	#include "AliFMDCalibStripRange.h" // ALIFMDCALIBSTRIPRANGE_H
57c3c593	38	#include "AliFMDAltroMapping.h" // ALIFMDALTROMAPPING_H
	39	#include <AliCDBManager.h> // ALICDBMANAGER_H
	40	#include <AliCDBEntry.h> // ALICDBMANAGER_H
1a1fdef7	41	#include <Riostream.h>
	42
	43	//====================================================================
	44	ClassImp(AliFMDParameters)
	45	#if 0
	46	; // This is here to keep Emacs for indenting the next line
	47	#endif
	48
	49	//____________________________________________________________________
	50	AliFMDParameters* AliFMDParameters::fgInstance = 0;
	51
57c3c593	52	//____________________________________________________________________
	53	const char* AliFMDParameters::fgkPulseGain = "FMD/Calib/PulseGain";
	54	const char* AliFMDParameters::fgkPedestal = "FMD/Calib/Pedestal";
	55	const char* AliFMDParameters::fgkDead = "FMD/Calib/Dead";
	56	const char* AliFMDParameters::fgkSampleRate = "FMD/Calib/SampleRate";
	57	const char* AliFMDParameters::fgkAltroMap = "FMD/Calib/AltroMap";
	58	const char* AliFMDParameters::fgkZeroSuppression = "FMD/Calib/ZeroSuppression";
c2fc1258	59	const char* AliFMDParameters::fgkStripRange = "FMD/Calib/StripRange";
57c3c593	60
57c3c593	61
1a1fdef7	62	//____________________________________________________________________
	63	AliFMDParameters*
	64	AliFMDParameters::Instance()
	65	{
	66	// Get static instance
	67	if (!fgInstance) fgInstance = new AliFMDParameters;
	68	return fgInstance;
	69	}
	70
	71	//____________________________________________________________________
	72	AliFMDParameters::AliFMDParameters()
57c3c593	73	: fIsInit(kFALSE),
02a27b50	74	fkSiDeDxMip(1.664),
8f6ee336	75	fFixedPulseGain(0),
	76	fEdepMip(0),
	77	fZeroSuppression(0),
	78	fSampleRate(0),
	79	fPedestal(0),
	80	fPulseGain(0),
57c3c593	81	fDeadMap(0),
c2fc1258	82	fAltroMap(0),
c2fc1258	83	fStripRange(0)
1a1fdef7	84	{
	85	// Default constructor
	86	SetVA1MipRange();
	87	SetAltroChannelSize();
	88	SetChannelsPerAltro();
	89	SetZeroSuppression();
	90	SetSampleRate();
	91	SetPedestal();
	92	SetPedestalWidth();
	93	SetPedestalFactor();
8f6ee336	94	SetThreshold();
c2fc1258	95	SetStripRange();
1a1fdef7	96	}
1a1fdef7	97
57c3c593	98	//__________________________________________________________________
	99	void
	100	AliFMDParameters::Init()
	101	{
	102	// Initialize the parameters manager. We need to get stuff from the
	103	// CDB here.
	104	if (fIsInit) return;
1e8f773e	105	InitPulseGain();
	106	InitPedestal();
	107	InitDeadMap();
	108	InitSampleRate();
	109	InitZeroSuppression();
	110	InitAltroMap();
	111	fIsInit = kTRUE;
57c3c593	112
1e8f773e	113	}
c2fc1258	114
	115	//__________________________________________________________________
	116	void
	117	AliFMDParameters::Print(Option_t* option) const
	118	{
02a27b50	119	// Print information.
02a27b50	120	// If option contains an 'A' then everything is printed.
c2fc1258	121	TString opt(option);
	122	Bool_t showStrips = opt.Contains("a", TString::kIgnoreCase);
	123	for (UShort_t det=1 ; det <= 3; det++) {
	124	std::cout << "FMD" << det << std::endl;
	125	Char_t rings[] = { 'I', (det == 1 ? '\0' : 'O'), '\0' };
	126	for (Char_t* ring = rings; *ring != '\0'; ring++) {
	127	std::cout << " Ring " << *ring << std::endl;
	128	UShort_t nSec = ( *ring == 'I' ? 20 : 40 );
	129	UShort_t nStr = ( *ring == 'I' ? 512 : 256 );
	130	for (UShort_t sec = 0; sec < nSec; sec++) {
	131	UShort_t min = GetMinStrip(det, *ring, sec, 0);
	132	UShort_t max = GetMaxStrip(det, *ring, sec, 0);
	133	UShort_t rate = GetSampleRate(det, *ring, sec, 0);
	134	std::cout << " Sector " << std::setw(2) << sec
	135	<< " Strip range: " << std::setw(3) << min << ","
	136	<< std::setw(3) << max << " Rate: " << std::setw(2)
	137	<< rate << std::endl;
	138	if (!showStrips) continue;
	139	std::cout
	140	<< " Strip \| Pedestal \| Gain \| ZS thr. \| Address\n"
	141	<< "--------+-------------------+----------+---------+---------"
	142	<< std::endl;
	143	for (UShort_t str = 0; str < nStr; str++) {
	144	std::cout << " " << std::setw(3) << str << " \| ";
	145	if (IsDead(det, *ring, sec, str)) {
	146	std::cout << "dead" << std::endl;
	147	continue;
	148	}
	149	UInt_t ddl, addr;
	150	Detector2Hardware(det, *ring, sec, str, ddl, addr);
	151	std::cout << std::setw(7) << GetPedestal(det, *ring, sec, str)
	152	<< "+/-" << std::setw(7)
	153	<< GetPedestalWidth(det, *ring, sec, str)
	154	<< " \| " << std::setw(8)
	155	<< GetPulseGain(det, *ring, sec, str)
	156	<< " \| " << std::setw(5)
	157	<< GetZeroSuppression(det, *ring, sec, str)
	158	<< " \| 0x" << std::hex << std::setw(4)
	159	<< std::setfill('0') << ddl << ",0x" << std::setw(3)
	160	<< addr << std::dec << std::setfill(' ') << std::endl;
	161	}
	162	}
	163	}
	164	}
	165	}
	166
	167	//__________________________________________________________________
	168	void
	169	AliFMDParameters::SetStripRange(UShort_t min, UShort_t max)
	170	{
02a27b50	171	// Set fixed strip range
c2fc1258	172	fFixedMinStrip = min;
	173	fFixedMaxStrip = max;
	174	}
	175
1e8f773e	176	//__________________________________________________________________
	177	void
	178	AliFMDParameters::InitPulseGain()
	179	{
02a27b50	180	// Get pulse gain from CDB or used fixed
57c3c593	181	AliCDBManager* cdb = AliCDBManager::Instance();
57c3c593	182	AliCDBEntry* gain = cdb->Get(fgkPulseGain);
1e8f773e	183	if (!gain) {
	184	AliWarning(Form("No %s found in CDB, perhaps you need to "
	185	"use AliFMDCalibFaker?", fgkPulseGain));
	186	return;
	187	}
57c3c593	188
1e8f773e	189	AliDebug(1, Form("Got gain from CDB"));
	190	fPulseGain = dynamic_cast<AliFMDCalibGain*>(gain->GetObject());
	191	if (!fPulseGain) AliWarning("Invalid pulser gain object from CDB");
	192	}
	193	//__________________________________________________________________
	194	void
	195	AliFMDParameters::InitPedestal()
	196	{
02a27b50	197	// Initialize the pedestals from CDB
1e8f773e	198	AliCDBManager* cdb = AliCDBManager::Instance();
	199	AliCDBEntry* pedestal = cdb->Get(fgkPedestal);
	200	if (!pedestal) {
	201	AliWarning(Form("No %s found in CDB, perhaps you need to "
	202	"use AliFMDCalibFaker?", fgkPedestal));
	203	return;
57c3c593	204	}
1e8f773e	205	AliDebug(1, Form("Got pedestal from CDB"));
	206	fPedestal = dynamic_cast<AliFMDCalibPedestal*>(pedestal->GetObject());
	207	if (!fPedestal) AliWarning("Invalid pedestal object from CDB");
	208	}
	209
	210	//__________________________________________________________________
	211	void
	212	AliFMDParameters::InitDeadMap()
	213	{
02a27b50	214	// Get Dead-channel-map from CDB
1e8f773e	215	AliCDBManager* cdb = AliCDBManager::Instance();
	216	AliCDBEntry* deadMap = cdb->Get(fgkDead);
	217	if (!deadMap) {
	218	AliWarning(Form("No %s found in CDB, perhaps you need to "
	219	"use AliFMDCalibFaker?", fgkDead));
	220	return;
57c3c593	221	}
1e8f773e	222	AliDebug(1, Form("Got dead map from CDB"));
	223	fDeadMap = dynamic_cast<AliFMDCalibDeadMap*>(deadMap->GetObject());
	224	if (!fDeadMap) AliWarning("Invalid dead map object from CDB");
	225	}
	226
	227	//__________________________________________________________________
	228	void
	229	AliFMDParameters::InitZeroSuppression()
	230	{
02a27b50	231	// Get 0-suppression from CDB
1e8f773e	232	AliCDBManager* cdb = AliCDBManager::Instance();
	233	AliCDBEntry* zeroSup = cdb->Get(fgkZeroSuppression);
	234	if (!zeroSup) {
	235	AliWarning(Form("No %s found in CDB, perhaps you need to "
	236	"use AliFMDCalibFaker?", fgkZeroSuppression));
	237	return;
57c3c593	238	}
1e8f773e	239	AliDebug(1, Form("Got zero suppression from CDB"));
	240	fZeroSuppression =
	241	dynamic_cast<AliFMDCalibZeroSuppression*>(zeroSup->GetObject());
	242	if (!fZeroSuppression)AliWarning("Invalid zero suppression object from CDB");
	243	}
	244
	245	//__________________________________________________________________
	246	void
	247	AliFMDParameters::InitSampleRate()
	248	{
02a27b50	249	// get Sample rate from CDB
1e8f773e	250	AliCDBManager* cdb = AliCDBManager::Instance();
	251	AliCDBEntry* sampRat = cdb->Get(fgkSampleRate);
	252	if (!sampRat) {
	253	AliWarning(Form("No %s found in CDB, perhaps you need to "
	254	"use AliFMDCalibFaker?", fgkSampleRate));
	255	return;
57c3c593	256	}
1e8f773e	257	AliDebug(1, Form("Got zero suppression from CDB"));
	258	fSampleRate = dynamic_cast<AliFMDCalibSampleRate*>(sampRat->GetObject());
	259	if (!fSampleRate) AliWarning("Invalid zero suppression object from CDB");
	260	}
	261
	262	//__________________________________________________________________
	263	void
	264	AliFMDParameters::InitAltroMap()
	265	{
02a27b50	266	// Get hardware mapping from CDB
1e8f773e	267	AliCDBManager* cdb = AliCDBManager::Instance();
	268	AliCDBEntry* hwMap = cdb->Get(fgkAltroMap);
	269	if (!hwMap) {
	270	AliWarning(Form("No %s found in CDB, perhaps you need to "
	271	"use AliFMDCalibFaker?", fgkAltroMap));
	272	fAltroMap = new AliFMDAltroMapping;
	273	return;
57c3c593	274	}
1e8f773e	275	AliDebug(1, Form("Got ALTRO map from CDB"));
	276	fAltroMap = dynamic_cast<AliFMDAltroMapping*>(hwMap->GetObject());
	277	if (!fAltroMap) {
	278	AliWarning("Invalid ALTRO map object from CDB");
	279	fAltroMap = new AliFMDAltroMapping;
57c3c593	280	}
57c3c593	281	}
57c3c593	282
c2fc1258	283	//__________________________________________________________________
	284	void
	285	AliFMDParameters::InitStripRange()
	286	{
02a27b50	287	// Get strips read-out from CDB
c2fc1258	288	AliCDBManager* cdb = AliCDBManager::Instance();
	289	AliCDBEntry* range = cdb->Get(fgkStripRange);
	290	if (!range) {
	291	AliWarning(Form("No %s found in CDB, perhaps you need to "
	292	"use AliFMDCalibFaker?", fgkStripRange));
	293	return;
	294	}
	295	AliDebug(1, Form("Got strip range from CDB"));
	296	fStripRange = dynamic_cast<AliFMDCalibStripRange*>(range->GetObject());
	297	if (!fStripRange) AliWarning("Invalid strip range object from CDB");
	298	}
	299
1e8f773e	300
8f6ee336	301	//__________________________________________________________________
	302	Float_t
	303	AliFMDParameters::GetThreshold() const
	304	{
02a27b50	305	// Get threshold from CDB
8f6ee336	306	if (!fPulseGain) return fFixedThreshold;
	307	return fPulseGain->Threshold();
	308	}
	309
	310	//__________________________________________________________________
	311	Float_t
	312	AliFMDParameters::GetPulseGain(UShort_t detector, Char_t ring,
	313	UShort_t sector, UShort_t strip) const
	314	{
	315	// Returns the pulser calibrated gain for strip # strip in sector #
	316	// sector or ring id ring of detector # detector.
	317	//
	318	// For simulation, this is normally set to
	319	//
	320	// VA1_MIP_Range
	321	// ------------------ * MIP_Energy_Loss
	322	// ALTRO_channel_size
	323	//
	324	if (!fPulseGain) {
	325	if (fFixedPulseGain <= 0)
	326	fFixedPulseGain = fVA1MipRange * GetEdepMip() / fAltroChannelSize;
	327	return fFixedPulseGain;
	328	}
1e8f773e	329	AliDebug(50, Form("pulse gain for FMD%d%c[%2d,%3d]=%f",
	330	detector, ring, sector, strip,
	331	fPulseGain->Value(detector, ring, sector, strip)));
8f6ee336	332	return fPulseGain->Value(detector, ring, sector, strip);
	333	}
	334
	335	//__________________________________________________________________
	336	Bool_t
	337	AliFMDParameters::IsDead(UShort_t detector, Char_t ring,
	338	UShort_t sector, UShort_t strip) const
	339	{
02a27b50	340	// Check if the channel is dead
8f6ee336	341	if (!fDeadMap) return kFALSE;
1e8f773e	342	AliDebug(50, Form("Dead for FMD%d%c[%2d,%3d]=%s",
	343	detector, ring, sector, strip,
	344	fDeadMap->operator()(detector, ring, sector, strip) ?
	345	"no" : "yes"));
8f6ee336	346	return fDeadMap->operator()(detector, ring, sector, strip);
	347	}
	348
	349	//__________________________________________________________________
	350	UShort_t
	351	AliFMDParameters::GetZeroSuppression(UShort_t detector, Char_t ring,
	352	UShort_t sector, UShort_t strip) const
	353	{
02a27b50	354	// Get zero suppression threshold
8f6ee336	355	if (!fZeroSuppression) return fFixedZeroSuppression;
8f6ee336	356	// Need to map strip to ALTRO chip.
1e8f773e	357	AliDebug(50, Form("zero sup. for FMD%d%c[%2d,%3d]=%f",
	358	detector, ring, sector, strip,
	359	fZeroSuppression->operator()(detector, ring,
	360	sector, strip)));
8f6ee336	361	return fZeroSuppression->operator()(detector, ring, sector, strip/128);
	362	}
	363
	364	//__________________________________________________________________
	365	UShort_t
c2fc1258	366	AliFMDParameters::GetSampleRate(UShort_t det, Char_t ring, UShort_t sector,
c2fc1258	367	UShort_t str) const
8f6ee336	368	{
02a27b50	369	// Get sampl rate
8f6ee336	370	if (!fSampleRate) return fFixedSampleRate;
8f6ee336	371	// Need to map sector to digitizier card.
c2fc1258	372	UInt_t ret = fSampleRate->Rate(det, ring, sector, str);
	373	AliDebug(50, Form("Sample rate for FMD%d%c[%2d,%3d]=%d",
	374	det, ring, sector, str, ret));
	375	return ret;
	376	}
	377
	378	//__________________________________________________________________
	379	UShort_t
	380	AliFMDParameters::GetMinStrip(UShort_t det, Char_t ring, UShort_t sector,
	381	UShort_t str) const
	382	{
02a27b50	383	// Get strip range read out
c2fc1258	384	if (!fStripRange) return fFixedMinStrip;
	385	// Need to map sector to digitizier card.
	386	UInt_t ret = fStripRange->Min(det, ring, sector, str);
	387	AliDebug(50, Form("Min strip # for FMD%d%c[%2d,%3d]=%d",
	388	det, ring, sector, str, ret));
	389	return ret;
	390	}
	391
	392	//__________________________________________________________________
	393	UShort_t
	394	AliFMDParameters::GetMaxStrip(UShort_t det, Char_t ring, UShort_t sector,
	395	UShort_t str) const
	396	{
02a27b50	397	// Get strip range read out
c2fc1258	398	if (!fStripRange) return fFixedMaxStrip;
	399	// Need to map sector to digitizier card.
	400	UInt_t ret = fStripRange->Max(det, ring, sector, str);
	401	AliDebug(50, Form("Max strip # for FMD%d%c[%2d,%3d]=%d",
	402	det, ring, sector, str, ret));
	403	return ret;
8f6ee336	404	}
1a1fdef7	405
8f6ee336	406	//__________________________________________________________________
	407	Float_t
	408	AliFMDParameters::GetPedestal(UShort_t detector, Char_t ring,
	409	UShort_t sector, UShort_t strip) const
	410	{
02a27b50	411	// Get the pedesal
8f6ee336	412	if (!fPedestal) return fFixedPedestal;
1e8f773e	413	AliDebug(50, Form("pedestal for FMD%d%c[%2d,%3d]=%f",
	414	detector, ring, sector, strip,
	415	fPedestal->Value(detector, ring, sector, strip)));
8f6ee336	416	return fPedestal->Value(detector, ring, sector, strip);
	417	}
	418
	419	//__________________________________________________________________
	420	Float_t
	421	AliFMDParameters::GetPedestalWidth(UShort_t detector, Char_t ring,
	422	UShort_t sector, UShort_t strip) const
	423	{
02a27b50	424	// Get the pedesal
8f6ee336	425	if (!fPedestal) return fFixedPedestalWidth;
1e8f773e	426	AliDebug(50, Form("pedetal width for FMD%d%c[%2d,%3d]=%f",
	427	detector, ring, sector, strip,
	428	fPedestal->Width(detector, ring, sector, strip)));
8f6ee336	429	return fPedestal->Width(detector, ring, sector, strip);
	430	}
	431
1a1fdef7	432	//__________________________________________________________________
57c3c593	433	AliFMDAltroMapping*
	434	AliFMDParameters::GetAltroMap() const
	435	{
02a27b50	436	// Get the hardware address to detector index map
57c3c593	437	return fAltroMap;
1a1fdef7	438	}
1a1fdef7	439
57c3c593	440
bf000c32	441	//__________________________________________________________________
	442	Bool_t
	443	AliFMDParameters::Hardware2Detector(UInt_t ddl, UInt_t addr, UShort_t& det,
	444	Char_t& ring, UShort_t& sec,
	445	UShort_t& str) const
	446	{
02a27b50	447	// Map hardware address to detector index
57c3c593	448	if (!fAltroMap) return kFALSE;
57c3c593	449	return fAltroMap->Hardware2Detector(ddl, addr, det, ring, sec, str);
bf000c32	450	}
	451
	452	//__________________________________________________________________
	453	Bool_t
	454	AliFMDParameters::Detector2Hardware(UShort_t det, Char_t ring, UShort_t sec,
57c3c593	455	UShort_t str, UInt_t& ddl,
57c3c593	456	UInt_t& addr) const
bf000c32	457	{
02a27b50	458	// Map detector index to hardware address
57c3c593	459	if (!fAltroMap) return kFALSE;
57c3c593	460	return fAltroMap->Detector2Hardware(det, ring, sec, str, ddl, addr);
bf000c32	461	}
bf000c32	462
57c3c593	463
	464	//__________________________________________________________________
	465	Float_t
	466	AliFMDParameters::GetEdepMip() const
	467	{
	468	// Get energy deposited by a MIP in the silicon sensors
	469	if (fEdepMip <= 0){
	470	AliFMDGeometry* fmd = AliFMDGeometry::Instance();
02a27b50	471	fEdepMip = (fkSiDeDxMip
57c3c593	472	* fmd->GetRing('I')->GetSiThickness()
	473	* fmd->GetSiDensity());
	474	}
	475	return fEdepMip;
	476	}
	477
	478
bf000c32	479
	480
	481
1a1fdef7	482	//____________________________________________________________________
	483	//
	484	// EOF
	485	//