TPC/Cal/AliTPCCreateDummyCDB.C

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