[u/mrichter/AliRoot.git] / FMD / AliFMDCalibFaker.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 task creates fake calibrations. Which calibration, depends on
// the bit mask passed to the constructor, or added by `AddCalib'.
//
// The default is to write all calibration parameters to a local
// storage `local://cdb' which is a directory in the current
// directory. 
//                                                       
#include "AliLog.h"		   // ALILOG_H
#include "AliFMDCalibFaker.h"      // ALIFMDCALIBFAKER_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>
#include <TSystem.h>
#include <TMath.h>
#include <TRandom.h>

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

//____________________________________________________________________
AliFMDCalibFaker::AliFMDCalibFaker(Int_t mask, const char* loc) 
  : TTask("FMDCalibFaker", loc),
    fMask(mask),
    fGain(-1),
    fThresholdFactor(.1),
    fThreshold(-1),
    fPedestalMin(20),
    fPedestalMax(30), 
    fDeadChance(0),
    fRate(1),
    fZeroThreshold(0),
    fRunMin(0),
    fRunMax(10)
{
  // Default constructor 
}


#define MAKE_META(meta) \
  do { \
    meta = new AliCDBMetaData; \
    meta->SetResponsible(gSystem->GetUserInfo()->fRealName.Data()); \
    meta->SetAliRootVersion(gROOT->GetVersion()); \
    meta->SetBeamPeriod(1); \
    meta->SetComment("Dummy data for testing"); } while (false);
 

//__________________________________________________________________
void
AliFMDCalibFaker::Exec(Option_t*)
{
  // Make the objects. 
  AliCDBManager*     cdb      = AliCDBManager::Instance();
  AliFMDParameters*  param    = AliFMDParameters::Instance();
  Float_t            maxADC   = param->GetAltroChannelSize();
  TObjArray          cleanup;

  if (GetTitle()) cdb->SetDefaultStorage(GetTitle());
    
  AliCDBMetaData* meta = 0;
  if (TESTBIT(fMask, kPulseGain)) {
    if (fGain <= 0) 
      fGain      = (param->GetVA1MipRange() * param->GetEdepMip() / maxADC);
    fThreshold = fThresholdFactor * param->GetEdepMip();
    AliFMDCalibGain* gain = MakePulseGain();
    AliCDBId         id(AliFMDParameters::fgkPulseGain, fRunMin, fRunMax);
    MAKE_META(meta);
    meta->SetProperty("key1", gain);
    cdb->Put(gain, id, meta);
    cleanup.Add(gain);
    cleanup.Add(meta);
  }  
  if (TESTBIT(fMask, kPedestal)) {
    fPedestalMin = TMath::Max(TMath::Min(fPedestalMin, maxADC), 0.F);
    fPedestalMax = TMath::Max(TMath::Min(fPedestalMax, maxADC), fPedestalMin);
    AliFMDCalibPedestal* pedestal = MakePedestal();
    AliCDBId             id(AliFMDParameters::fgkPedestal, fRunMin, fRunMax);
    MAKE_META(meta);
    meta->SetProperty("key1", pedestal);
    cdb->Put(pedestal, id, meta);
    cleanup.Add(pedestal);
    cleanup.Add(meta);
  }
  if (TESTBIT(fMask, kDeadMap)) {
    fDeadChance = TMath::Max(TMath::Min(fDeadChance, 1.F), 0.F);
    AliFMDCalibDeadMap* deadMap = MakeDeadMap();
    AliCDBId            id(AliFMDParameters::fgkDead, fRunMin, fRunMax);
    MAKE_META(meta);
    meta->SetProperty("key1", deadMap);
    cdb->Put(deadMap, id, meta);
    cleanup.Add(deadMap);
    cleanup.Add(meta);
  }
  if (TESTBIT(fMask, kZeroSuppression)) {
    fZeroThreshold = TMath::Min(fZeroThreshold, UShort_t(maxADC));
    AliFMDCalibZeroSuppression* zeroSup = MakeZeroSuppression();
    AliCDBId                    id(AliFMDParameters::fgkZeroSuppression, 
				   fRunMin, fRunMax);
    MAKE_META(meta);
    meta->SetProperty("key1", zeroSup);
    cdb->Put(zeroSup, id, meta);
    cleanup.Add(zeroSup);
    cleanup.Add(meta);
  }
  if (TESTBIT(fMask, kSampleRate)) {
    fRate = TMath::Max(TMath::Min(fRate, UShort_t(8)), UShort_t(1));
    AliFMDCalibSampleRate* rate = MakeSampleRate();
    AliCDBId               id(AliFMDParameters::fgkSampleRate,fRunMin,fRunMax);
    MAKE_META(meta);
    meta->SetProperty("key1", rate);
    cdb->Put(rate, id, meta);
    cleanup.Add(rate);
    cleanup.Add(meta);
  }
  if (TESTBIT(fMask, kAltroMap)) {
    AliFMDAltroMapping* altroMap = MakeAltroMap();
    AliCDBId            id(AliFMDParameters::fgkAltroMap, fRunMin, fRunMax);
    MAKE_META(meta);
    meta->SetProperty("key1", altroMap);
    cdb->Put(altroMap, id, meta);
    cleanup.Add(altroMap);
    cleanup.Add(meta);
  }
  cdb->Destroy();
  cleanup.Delete();
}


//__________________________________________________________________
AliFMDCalibGain*
AliFMDCalibFaker::MakePulseGain()
{
  // Make the actual data
  AliFMDCalibGain*  gain  = new AliFMDCalibGain;
  // Set threshold 
  gain->Set(fThreshold);
  for (UShort_t det = 1; det <= 3; det++) {
    Char_t rings[] = { 'I', (det == 1 ? '\0' : 'O'), '\0' };
    for (Char_t* ring = rings; *ring != '\0'; ring++) {
      UShort_t nSec = ( *ring == 'I' ? 20  :  40 );
      UShort_t nStr = ( *ring == 'I' ? 512 : 256 );
      for (UShort_t sec = 0; sec < nSec; sec++) {
        for (UShort_t str = 0; str < nStr; str++) {
          gain->Set(det, *ring, sec, str,
                    gRandom->Gaus(fGain, .01 * fGain));
        }
      }
    }
  }
  return gain;
}

//__________________________________________________________________
AliFMDCalibPedestal*
AliFMDCalibFaker::MakePedestal()
{
  // Make the actual data
  AliFMDCalibPedestal*  pedestal  = new AliFMDCalibPedestal;
  for (UShort_t det = 1; det <= 3; det++) {
    Char_t rings[] = { 'I', (det == 1 ? '\0' : 'O'), '\0' };
    for (Char_t* ring = rings; *ring != '\0'; ring++) {
      UShort_t nSec = ( *ring == 'I' ? 20  :  40 );
      UShort_t nStr = ( *ring == 'I' ? 512 : 256 );
      for (UShort_t sec = 0; sec < nSec; sec++) {
        for (UShort_t str = 0; str < nStr; str++) {
          pedestal->Set(det, *ring, sec, str,
			gRandom->Uniform(fPedestalMin, fPedestalMax), 1.5);
        }
      }
    }
  }
  return pedestal;
}

//__________________________________________________________________
AliFMDCalibDeadMap*
AliFMDCalibFaker::MakeDeadMap()
{
  // Make the actual data
  AliFMDCalibDeadMap*  deadmap  = new AliFMDCalibDeadMap;
  for (UShort_t det = 1; det <= 3; det++) {
    Char_t rings[] = { 'I', (det == 1 ? '\0' : 'O'), '\0' };
    for (Char_t* ring = rings; *ring != '\0'; ring++) {
      UShort_t nSec = ( *ring == 'I' ? 20  :  40 );
      UShort_t nStr = ( *ring == 'I' ? 512 : 256 );
      for (UShort_t sec = 0; sec < nSec; sec++) {
        for (UShort_t str = 0; str < nStr; str++) {
          deadmap->operator()(det, *ring, sec, str) = 
	    gRandom->Uniform(0, 1) < fDeadChance;
        }
      }
    }
  }
  return deadmap;
}

//__________________________________________________________________
AliFMDCalibZeroSuppression*
AliFMDCalibFaker::MakeZeroSuppression()
{
  // Make the actual data
  AliFMDCalibZeroSuppression*  zs  = new AliFMDCalibZeroSuppression;
  for (UShort_t det = 1; det <= 3; det++) {
    Char_t rings[] = { 'I', (det == 1 ? '\0' : 'O'), '\0' };
    for (Char_t* ring = rings; *ring != '\0'; ring++) {
      UShort_t nSec = ( *ring == 'I' ? 20  :  40 );
      UShort_t nStr = ( *ring == 'I' ? 512 : 256 );
      for (UShort_t sec = 0; sec < nSec; sec++) {
        for (UShort_t str = 0; str < nStr; str++) {
          zs->operator()(det, *ring, sec, str) =  fZeroThreshold;
        }
      }
    }
  }
  return zs;
}

//__________________________________________________________________
AliFMDCalibSampleRate*
AliFMDCalibFaker::MakeSampleRate()
{
  AliFMDCalibSampleRate*  sampleRate  = new AliFMDCalibSampleRate;
  for (int i = 0; i < 3; i++)
    sampleRate->Set(AliFMDParameters::kBaseDDL+i, fRate);
  return sampleRate;
}

//__________________________________________________________________
AliFMDAltroMapping*
AliFMDCalibFaker::MakeAltroMap()
{
  AliFMDAltroMapping*  m  = new AliFMDAltroMapping;
  return m;
}
  
  
//____________________________________________________________________
//
// EOF
//
Commit	Line	Data
20345ac5	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 task creates fake calibrations. Which calibration, depends on
	23	// the bit mask passed to the constructor, or added by `AddCalib'.
	24	//
	25	// The default is to write all calibration parameters to a local
	26	// storage `local://cdb' which is a directory in the current
	27	// directory.
	28	//
	29	#include "AliLog.h" // ALILOG_H
	30	#include "AliFMDCalibFaker.h" // ALIFMDCALIBFAKER_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	#include <TSystem.h>
	39	#include <TMath.h>
	40	#include <TRandom.h>
	41
	42	//====================================================================
	43	ClassImp(AliFMDCalibFaker)
	44	#if 0
	45	; // This is here to keep Emacs for indenting the next line
	46	#endif
	47
	48	//____________________________________________________________________
	49	AliFMDCalibFaker::AliFMDCalibFaker(Int_t mask, const char* loc)
	50	: TTask("FMDCalibFaker", loc),
	51	fMask(mask),
	52	fGain(-1),
	53	fThresholdFactor(.1),
	54	fThreshold(-1),
	55	fPedestalMin(20),
	56	fPedestalMax(30),
	57	fDeadChance(0),
	58	fRate(1),
	59	fZeroThreshold(0),
	60	fRunMin(0),
	61	fRunMax(10)
	62	{
	63	// Default constructor
	64	}
65
66
67	#define MAKE_META(meta) \
68	do { \
69	meta = new AliCDBMetaData; \
70	meta->SetResponsible(gSystem->GetUserInfo()->fRealName.Data()); \
71	meta->SetAliRootVersion(gROOT->GetVersion()); \
72	meta->SetBeamPeriod(1); \
73	meta->SetComment("Dummy data for testing"); } while (false);
74
75
76	//__________________________________________________________________
77	void
78	AliFMDCalibFaker::Exec(Option_t*)
79	{
80	// Make the objects.
81	AliCDBManager* cdb = AliCDBManager::Instance();
82	AliFMDParameters* param = AliFMDParameters::Instance();
83	Float_t maxADC = param->GetAltroChannelSize();
84	TObjArray cleanup;
85
86	if (GetTitle()) cdb->SetDefaultStorage(GetTitle());
87
88	AliCDBMetaData* meta = 0;
89	if (TESTBIT(fMask, kPulseGain)) {
90	if (fGain <= 0)
91	fGain = (param->GetVA1MipRange() * param->GetEdepMip() / maxADC);
92	fThreshold = fThresholdFactor * param->GetEdepMip();
93	AliFMDCalibGain* gain = MakePulseGain();
94	AliCDBId id(AliFMDParameters::fgkPulseGain, fRunMin, fRunMax);
95	MAKE_META(meta);
96	meta->SetProperty("key1", gain);
97	cdb->Put(gain, id, meta);
98	cleanup.Add(gain);
99	cleanup.Add(meta);
100	}
101	if (TESTBIT(fMask, kPedestal)) {
102	fPedestalMin = TMath::Max(TMath::Min(fPedestalMin, maxADC), 0.F);
103	fPedestalMax = TMath::Max(TMath::Min(fPedestalMax, maxADC), fPedestalMin);
104	AliFMDCalibPedestal* pedestal = MakePedestal();
105	AliCDBId id(AliFMDParameters::fgkPedestal, fRunMin, fRunMax);
106	MAKE_META(meta);
107	meta->SetProperty("key1", pedestal);
108	cdb->Put(pedestal, id, meta);
109	cleanup.Add(pedestal);
110	cleanup.Add(meta);
111	}
112	if (TESTBIT(fMask, kDeadMap)) {
113	fDeadChance = TMath::Max(TMath::Min(fDeadChance, 1.F), 0.F);
114	AliFMDCalibDeadMap* deadMap = MakeDeadMap();
115	AliCDBId id(AliFMDParameters::fgkDead, fRunMin, fRunMax);
116	MAKE_META(meta);
117	meta->SetProperty("key1", deadMap);
118	cdb->Put(deadMap, id, meta);
119	cleanup.Add(deadMap);
120	cleanup.Add(meta);
121	}
122	if (TESTBIT(fMask, kZeroSuppression)) {
123	fZeroThreshold = TMath::Min(fZeroThreshold, UShort_t(maxADC));
124	AliFMDCalibZeroSuppression* zeroSup = MakeZeroSuppression();
125	AliCDBId id(AliFMDParameters::fgkZeroSuppression,
126	fRunMin, fRunMax);
127	MAKE_META(meta);
128	meta->SetProperty("key1", zeroSup);
129	cdb->Put(zeroSup, id, meta);
130	cleanup.Add(zeroSup);
131	cleanup.Add(meta);
132	}
133	if (TESTBIT(fMask, kSampleRate)) {
134	fRate = TMath::Max(TMath::Min(fRate, UShort_t(8)), UShort_t(1));
135	AliFMDCalibSampleRate* rate = MakeSampleRate();
136	AliCDBId id(AliFMDParameters::fgkSampleRate,fRunMin,fRunMax);
137	MAKE_META(meta);
138	meta->SetProperty("key1", rate);
139	cdb->Put(rate, id, meta);
140	cleanup.Add(rate);
141	cleanup.Add(meta);
142	}
143	if (TESTBIT(fMask, kAltroMap)) {
144	AliFMDAltroMapping* altroMap = MakeAltroMap();
145	AliCDBId id(AliFMDParameters::fgkAltroMap, fRunMin, fRunMax);
146	MAKE_META(meta);
147	meta->SetProperty("key1", altroMap);
148	cdb->Put(altroMap, id, meta);
149	cleanup.Add(altroMap);
150	cleanup.Add(meta);
151	}
152	cdb->Destroy();
153	cleanup.Delete();
154	}
155
156
157	//__________________________________________________________________
158	AliFMDCalibGain*
159	AliFMDCalibFaker::MakePulseGain()
160	{
161	// Make the actual data
162	AliFMDCalibGain* gain = new AliFMDCalibGain;
163	// Set threshold
164	gain->Set(fThreshold);
165	for (UShort_t det = 1; det <= 3; det++) {
166	Char_t rings[] = { 'I', (det == 1 ? '\0' : 'O'), '\0' };
167	for (Char_t* ring = rings; *ring != '\0'; ring++) {
168	UShort_t nSec = ( *ring == 'I' ? 20 : 40 );
169	UShort_t nStr = ( *ring == 'I' ? 512 : 256 );
170	for (UShort_t sec = 0; sec < nSec; sec++) {
171	for (UShort_t str = 0; str < nStr; str++) {
172	gain->Set(det, *ring, sec, str,
173	gRandom->Gaus(fGain, .01 * fGain));
174	}
175	}
176	}
177	}
178	return gain;
179	}
180
181	//__________________________________________________________________
182	AliFMDCalibPedestal*
183	AliFMDCalibFaker::MakePedestal()
184	{
185	// Make the actual data
186	AliFMDCalibPedestal* pedestal = new AliFMDCalibPedestal;
187	for (UShort_t det = 1; det <= 3; det++) {
188	Char_t rings[] = { 'I', (det == 1 ? '\0' : 'O'), '\0' };
189	for (Char_t* ring = rings; *ring != '\0'; ring++) {
190	UShort_t nSec = ( *ring == 'I' ? 20 : 40 );
191	UShort_t nStr = ( *ring == 'I' ? 512 : 256 );
192	for (UShort_t sec = 0; sec < nSec; sec++) {
193	for (UShort_t str = 0; str < nStr; str++) {
194	pedestal->Set(det, *ring, sec, str,
195	gRandom->Uniform(fPedestalMin, fPedestalMax), 1.5);
196	}
197	}
198	}
199	}
200	return pedestal;
201	}
202
203	//__________________________________________________________________
204	AliFMDCalibDeadMap*
205	AliFMDCalibFaker::MakeDeadMap()
206	{
207	// Make the actual data
208	AliFMDCalibDeadMap* deadmap = new AliFMDCalibDeadMap;
209	for (UShort_t det = 1; det <= 3; det++) {
210	Char_t rings[] = { 'I', (det == 1 ? '\0' : 'O'), '\0' };
211	for (Char_t* ring = rings; *ring != '\0'; ring++) {
212	UShort_t nSec = ( *ring == 'I' ? 20 : 40 );
213	UShort_t nStr = ( *ring == 'I' ? 512 : 256 );
214	for (UShort_t sec = 0; sec < nSec; sec++) {
215	for (UShort_t str = 0; str < nStr; str++) {
216	deadmap->operator()(det, *ring, sec, str) =
217	gRandom->Uniform(0, 1) < fDeadChance;
218	}
219	}
220	}
221	}
222	return deadmap;
223	}
224
225	//__________________________________________________________________
226	AliFMDCalibZeroSuppression*
227	AliFMDCalibFaker::MakeZeroSuppression()
228	{
229	// Make the actual data
230	AliFMDCalibZeroSuppression* zs = new AliFMDCalibZeroSuppression;
231	for (UShort_t det = 1; det <= 3; det++) {
232	Char_t rings[] = { 'I', (det == 1 ? '\0' : 'O'), '\0' };
233	for (Char_t* ring = rings; *ring != '\0'; ring++) {
234	UShort_t nSec = ( *ring == 'I' ? 20 : 40 );
235	UShort_t nStr = ( *ring == 'I' ? 512 : 256 );
236	for (UShort_t sec = 0; sec < nSec; sec++) {
237	for (UShort_t str = 0; str < nStr; str++) {
238	zs->operator()(det, *ring, sec, str) = fZeroThreshold;
239	}
240	}
241	}
242	}
243	return zs;
244	}
245
246	//__________________________________________________________________
247	AliFMDCalibSampleRate*
248	AliFMDCalibFaker::MakeSampleRate()
249	{
250	AliFMDCalibSampleRate* sampleRate = new AliFMDCalibSampleRate;
251	for (int i = 0; i < 3; i++)
252	sampleRate->Set(AliFMDParameters::kBaseDDL+i, fRate);
253	return sampleRate;
254	}
255
256	//__________________________________________________________________
257	AliFMDAltroMapping*
258	AliFMDCalibFaker::MakeAltroMap()
259	{
260	AliFMDAltroMapping* m = new AliFMDAltroMapping;
261	return m;
262	}
263
264
265
266	//____________________________________________________________________
267	//
268	// EOF
269	//