TPC/Cal/AliTPCCreateDummyCDB.C

   1 /// \file AliTPCCreateDummyCDB.C
   2
   3 #if !defined( __CINT__) || defined(__MAKECINT__)
   4
   5 #include <iostream>
   6 #include <TRandom.h>
   7 #include <TClonesArray.h>
   8 #include <TFile.h>
   9
  10 #include <AliAlignObj.h>
  11 #include <AliAlignObjParams.h>
  12 #include <AliCDBManager.h>
  13 #include <AliCDBStorage.h>
  14 #include <AliCDBEntry.h>
  15 #include <AliCDBMetaData.h>
  16
  17 #include "AliTPCROC.h"
  18 #include "AliTPCCalROC.h"
  19 #include "AliTPCCalPad.h"
  20 #include "AliTPCCalDet.h"
  21 #include "AliTPCParamSR.h"
  22
  23 #endif
  24
  25 // run number for the dummy file
  26 Int_t gkDummyRun = 0;
  27 char *gCDBpath   = "local://$ALICE_ROOT/OCDB";
  28 AliCDBStorage* gStorLoc = 0;
  29
  30 //
  31 //Float_t gTSample    = 2.0000000e-07;
  32 //
  33 //
  34 Float_t gMeanGain   = 1;
  35 Float_t gSigmaGain  = 0;
  36 //
  37 Float_t gMeanTime0  = 0;
  38 Float_t gSigmaTime0 = 0;
  39 //
  40 Float_t gMeanNoise  = 1;
  41 Float_t gSigmaNoise = 0;
  42 //
  43 //
  44 Float_t gMeanPedestal  = 0;
  45 Float_t gSigmaPedestal = 0;
  46 //
  47 // Missalignment
  48 //
  49 Float_t gSigmaDx    = 0;
  50 Float_t gSigmaDy    = 0;
  51 Float_t gSigmaDz    = 0;
  52 Float_t gSigmaAngle = 0;
  53
  54
  55
  56
  57 TObject* CreatePadObject(const char* shortName, const char* description, Float_t value, Float_t sigma=0)
  58 {
  59   AliTPCCalPad *calPad = new AliTPCCalPad(shortName, description);
  60   for (UInt_t det=0; det<AliTPCROC::Instance()->GetNSectors(); det++){
  61     AliTPCCalROC *calROC = calPad->GetCalROC(det);
  62     for (UInt_t channel=0; channel<calROC->GetNchannels(); channel++){
  63       Float_t rvalue = gRandom->Gaus(value,sigma);
  64       calROC->SetValue(channel, rvalue);
  65     }
  66   }
  67   return calPad;
  68 }
  69
  70
  71 void StoreObject(const char* cdbPath, TObject* object, AliCDBMetaData* metaData)
  72 {
  73   AliCDBId id1(cdbPath, gkDummyRun, AliCDBRunRange::Infinity());
  74   gStorLoc->Put(object, id1, metaData);
  75 }
  76
  77
  78 AliCDBMetaData* CreateMetaObject(const char* objectClassName)
  79 {
  80   AliCDBMetaData *md1= new AliCDBMetaData();
  81   md1->SetObjectClassName(objectClassName);
  82   md1->SetResponsible("Marian Ivanov");
  83   md1->SetBeamPeriod(1);
  84   md1->SetAliRootVersion("05-06-00"); //root version
  85   md1->SetComment("The dummy values in this calibration file are for testing only");
  86
  87   return md1;
  88 }
  89
  90
  91 void CDBAlignmentObjectCreation(const char *fileName, const char *arrayName, const char *detName){
  92   // make instance of storage
  93   AliCDBManager *CDB = AliCDBManager::Instance();
  94   AliCDBStorage* storLoc = CDB->GetStorage(gCDBpath);
  95
  96   // create or get from a file the TClonesArray of alignment objects
  97   // for given detector, DET should be TPC, TRD ...
  98   TFile* f = TFile::Open(fileName,"READ");
  99   TClonesArray* tc = ((TClonesArray*) f->Get(arrayName));
 100
 101   // AliCDBStorage::Put will make a file containing that TClonesArray in
 102   // the CDB directory structure
 103   AliCDBMetaData *md= new AliCDBMetaData();
 104   md->SetObjectClassName("TClonesArray");
 105   md->SetResponsible("Your name here");
 106   md->SetComment("Alignment objects storage example. Please give more details here.");
 107   AliCDBId id(Form("%s/Align/Data",detName),0,0); //you have to specify the run validity,
 108 // although in the case of saving ideal objects makes not much sense
 109   storLoc->Put(tc,id,md);
 110
 111   // In this way it's good enough because AliSimulation is then expecting
 112   // as default to find the files in $ALICE_ROOT/DET/Align/Data
 113   // Then just
 114   // AliSimulation sim
 115   // sim.Run()
 116   // Look at the AliInfo messages from AliSimulation::Run() to check that
 117   // the expected CDB objects have been retrieved.
 118 }
 119
 120
 121
 122
 123 void GenerateRndTPC(Float_t sigmatrx=0., Float_t sigmatry=0, Float_t sigmatrz=0, Float_t sigmarot = 0.){
 124
 125   TClonesArray *array = new TClonesArray("AliAlignObjParams",10000);
 126   TClonesArray &alobj = *array;
 127
 128   TFile f("TPC_alignment.root","RECREATE");
 129
 130   TRandom *rnd   = new TRandom(4357);
 131   AliAlignObjParams o;
 132   Int_t j = 0;
 133   for (Int_t iLayer = AliGeomManager::kTPC1; iLayer <= AliGeomManager::kTPC2; iLayer++) {
 134     for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer); iModule++) {
 135
 136       Float_t dx = (rnd->Uniform()-0.5)*sigmatrx;
 137       Float_t dy = (rnd->Uniform()-0.5)*sigmatry;
 138       Float_t dz = (rnd->Uniform()-0.5)*sigmatrz;
 139       Float_t dpsi = (rnd->Uniform()-0.5)*sigmarot;
 140       Float_t dtheta = (rnd->Uniform()-0.5)*sigmarot;
 141       Float_t dphi = (rnd->Uniform()-0.5)*sigmarot;
 142
 143       UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iModule);
 144       const char *path = AliGeomManager::GetVolPath(volid);
 145       new(alobj[j]) AliAlignObjParams(path, volid, dx, dy, dz, dpsi, dtheta, dphi);
 146       j++;
 147     }
 148   }
 149   f.cd();
 150   f.WriteObject(array,"TPCAlignObjs","kSingleKey");
 151   f.Close();
 152   array->Delete();
 153   CDBAlignmentObjectCreation("TPC_alignment.root","TPCAlignObjs","TPC");
 154 }
 155
 156
 157
 158 void AliTPCCreateDummyCDB()
 159 {
 160   cout << endl << "TPC :: Creating dummy CDB with event number " << gkDummyRun << endl;
 161
 162
 163   AliCDBManager *man = AliCDBManager::Instance();
 164   gStorLoc = man->GetStorage(gCDBpath);
 165   if (!gStorLoc)
 166     return;
 167
 168   TObject* obj = 0;
 169   AliCDBMetaData* metaData = 0;
 170
 171   //
 172   // Gain factor (relative) - normalized to 1 - spread 0
 173   //
 174   metaData = CreateMetaObject("AliTPCCalPad");
 175   obj = CreatePadObject("PadGainFactor","TPC Gain Factor (local -pad- variations)", gMeanGain , gSigmaGain);
 176   StoreObject("TPC/Calib/PadGainFactor", obj, metaData);
 177   //
 178   // Time0 fluctuation   - normalized to 0  - spread 0.00 mus
 179   //
 180   metaData = CreateMetaObject("AliTPCCalPad");
 181   obj = CreatePadObject("PadTime0","TPC Time 0  (local -pad- variations)", gMeanTime0 , gSigmaTime0);
 182   StoreObject("TPC/Calib/PadTime0", obj, metaData);
 183   //
 184   // Noise  fluctuation   - normalized to 1.0  - spread - 0.0
 185   //
 186   metaData = CreateMetaObject("AliTPCCalPad");
 187   obj = CreatePadObject("PadNoise","TPC Noise  (local -pad- variations)", gMeanNoise , gSigmaNoise);
 188   StoreObject("TPC/Calib/PadNoise", obj, metaData);
 189   //
 190   // Pedestals
 191   //
 192   metaData = CreateMetaObject("AliTPCCalPad");
 193   obj = CreatePadObject("PadPedestal","TPC pedestals  (local -pad- variations)", gMeanPedestal, gSigmaPedestal);
 194   StoreObject("TPC/Calib/Pedestals", obj, metaData);
 195   //
 196   // Parameters
 197   //
 198   metaData = CreateMetaObject("AliTPCParam");
 199   AliTPCParam * param = new AliTPCParamSR;
 200   //  param->SetTSample(gTSample);
 201   param->Update();
 202   StoreObject("TPC/Calib/Parameters", param, metaData);
 203   //
 204   //
 205   // generate random missalignemnt - TO BE MODIFIED ACCCRDING NEW ALIROOT
 206   //
 207   //  GenerateRndTPC(gSigmaDx,gSigmaDy,gSigmaDz,gSigmaAngle);
 208   //
 209   // ExB
 210   //
 211   //
 212   // Put there your mag field
 213   //     to simulate distortion the scaling factor in magf can be used
 214   //     currently scaling factor 0 used - no magnetic field
 215   //
 216   metaData = CreateMetaObject("AliTPCExB");
 217   AliMagF* field = new AliMagF("Maps","Maps", 0., 0., AliMagF::k5kG));
 218   AliTPCExBFirst *exbfirst = new  AliTPCExBFirst(field,2.83000000000000000e+04,50,50,50);
 219   StoreObject("TPC/Calib/ExB", exbfirst, metaData);
 220
 221 }