[u/mrichter/AliRoot.git] / FMD / scripts / TestPreprocessor.C

/* $Id$ */

//====================================================================
//
// Helper classes
//
#include <iostream>
#include <fstream>
#ifndef __CINT__
# include <TString.h>
# include <AliPreprocessor.h>
# include <../FMD/AliFMDPreprocessor.h>
# include <AliShuttleInterface.h>
# include <AliCDBStorage.h>
# include <AliCDBEntry.h>
# include <AliCDBManager.h>
# include <AliCDBId.h>
# include <AliCDBMetaData.h>
# include <AliDCSValue.h>
# include <AliLog.h>
// # include <../FMD/AliFMDCalibZeroSuppression.h>
// # include <../FMD/AliFMDCalibDeadMap.h>
# include <../FMD/AliFMDParameters.h>
# include <../SHUTTLE/TestShuttle/AliTestShuttle.h>
# include <TRandom.h>
# include <TSystem.h>
# include <TObjString.h>
# include <TMap.h>
# include <TError.h>
#endif

namespace { 
  //====================================================================
  //
  // Helper functions
  //
  Float_t Hardware2Ped(int ddl, int board, int chip, int, int) 
  {
    return ((chip & 0xf) | ((board & 0x1F) << 4) | (ddl << 9) & 0x3);
  }
  Float_t Hardware2Noise(int ddl, int board, int chip, int channel, int strip)
  {
    return ((strip & 0x7f) | ((channel & 0xf) << 7));
  }
  Float_t Hardware2Gain(int ddl, int board, int chip, int channel, int strip) 
  {
    return (((strip   & 0x7f) <<  0) | 
	    ((channel & 0x0f) <<  7) | 
	    ((chip    & 0x07) << 11) |
	    ((board   & 0x1f) << 14) | 
	    ((ddl     & 0x03) << 19));
  }

  //====================================================================
  //
  // Helper classes
  //
  //__________________________________________________________________
  class CreateDummyDaData
  {
  public:
    CreateDummyDaData(const char* output,
		      int firstDDL,   int lastDDL, 
		      int firstStrip, int lastStrip)
      : fOutput(output),
	fFirstDDL(firstDDL),     fLastDDL(lastDDL), 
	fFirstStrip(firstStrip), fLastStrip(lastStrip)
    {}
    void Exec()
    {
      std::cout << "Will write on " << fOutput << std::endl;
      std::ofstream file(fOutput.Data());
      if (file.bad()) { 
	std::cerr << "Failed to open output file " << fOutput << std::endl;
	return;
      }
      Header(file);
      for (int ddl = fFirstDDL; ddl <= fLastDDL; ddl++) { 
	int  boards[] = { 0, 16, (ddl==1 ? -1 : 1), (ddl==1 ? -1 : 17), -1};
	int* bptr     = boards;
	int  board    = -1;
	while ((board = (*bptr++)) >= 0) { 
	  for (int chip = 0; chip < 3; chip++) { 
	    for (int channel = 0; channel < (chip == 1 ? 8 : 16); channel++) { 
	      for (int strip = fFirstStrip; strip <= fLastStrip; strip++) {
		Output(file, ddl, board, chip, channel, strip);
	      }
	    } // for channel 
	  } // for chip
	} // while board 
      } // for ddl
      file.close();
    }
    virtual void Header(std::ostream& file) = 0;
    virtual void Output(std::ostream& file, int ddl, int board, int chip, 
			int channel, int strip) = 0;
  protected:
    TString fOutput;
    int fFirstDDL;
    int fLastDDL;
    int fFirstStrip;
    int fLastStrip;
  };

  //__________________________________________________________________
  class CreateDummyPeds : public  CreateDummyDaData
  {
  public:
    CreateDummyPeds(const char* out="peds.csv", 
		    int overSampling=4,
		    int firstDDL=0,   int lastDDL=2, 
		    int firstStrip=0, int lastStrip=127)
      : CreateDummyDaData(out, firstDDL, lastDDL, firstStrip, lastStrip), 
	fOverSampling(overSampling)
    {}
    void Output(std::ostream& file, int ddl, int board, int chip, int channel, 
		int strip)
    {
      // Format is
      //   ddl,board,chip,channel,strip,sample,ped,noise,mu,sigma,chi2
      for (int sample = 0; sample < fOverSampling; sample++) {
	Float_t ped   = Hardware2Ped(ddl, board, chip, channel, strip);
	Float_t noise = Hardware2Noise(ddl, board, chip, channel, strip);
	file // << ddl     << ","
	     << board   << "," 
	     << chip    << ","
	     << channel << ","
	     << strip   << ","
	     << sample  << ","
	     << ped     << ","  
	     << noise   << ","  
	     << chip    << ","  // Predictable mu
	     << channel << ","  // Predictable sigma 
	     << strip           // Predictable chi2/ndf
	     << endl;
      }
    }
    void Header(std::ostream& file) 
    { 
      file << "# Pedestals\n" 
	   << "# ddl,board,chip,channel,strip,sample,mean,noise,mu,sigma,chi"
	   << std::endl;
    }
  protected:
    int fOverSampling;
  };

  //__________________________________________________________________
  class CreateDummyGains : public  CreateDummyDaData
  {
  public:
    CreateDummyGains(const char* out="gains.csv", 
		     int firstDDL=0,   int lastDDL=2, 
		     int firstStrip=0, int lastStrip=127)
      : CreateDummyDaData(out, firstDDL, lastDDL, firstStrip, lastStrip) 
    {}
    void Output(std::ostream& file, int ddl, int board, int chip, int channel, 
		int strip)
    {
      // Format is
      //   ddl,board,chip,channel,strip,gain,error,chi2
      Float_t gain = Hardware2Gain(ddl, board, chip, channel, strip);
      file // << ddl     << ","
	   << board   << "," 
	   << chip    << ","
	   << channel << ","
	   << strip   << ","
	   << gain    << ","  // Predictable gain
	   << board   << ","  // Predictable error
	   << strip           // Predictable chi2/ndf
	   << endl;
    }
    void Header(std::ostream& file) 
    { 
      file << "# Gains\n" 
	   << "# ddl,board,chip,channel,strip,gain,errorchi"
	   << std::endl;
    }
  };
}

//====================================================================
//
// Read back the calibrations written, and check the values 
//
void ReadBack(const char* dbBase="local://$ALICE_ROOT/FMD/")
{
  AliLog::SetModuleDebugLevel("FMD", 1);
  // Set specific storage of FMD ALTRO map 
  AliCDBManager::Instance()->SetDefaultStorage(Form("%s/TestCDB", dbBase));
  AliCDBManager::Instance()->SetSpecificStorage("FMD/Calib/AltroMap",
						"local://$ALICE_ROOT");
  AliCDBManager::Instance()->SetRun(0);
  
  AliFMDParameters* param = AliFMDParameters::Instance();
  std::cout << "Getting the stuff via AliFMDParameters ... " << std::flush;
  param->Init(kTRUE,AliFMDParameters::kPulseGain|
	      AliFMDParameters::kPedestal|
	      AliFMDParameters::kAltroMap);
  std::cout << "done" << std::endl;
  // param->Print("FMD1I[*,*]");
  
  for (UShort_t det = 3; det <= 3; det++) { 
    Char_t  rs[] = { 'I', (det==1 ? '\0' : 'O'), '\0' };
    Char_t* pr   = rs;
    Char_t  rng  = '\0';
    while ((rng = *(pr++)) != '\0') { 
      UShort_t nsec = (rng == 'I' ?  20 :  40);
      UShort_t nstr = (rng == 'I' ? 512 : 256);
      for (UShort_t sec = 0; sec < nsec; sec++) { 
	for (UShort_t str = 0; str < nstr; str++) { 
	  Float_t  gain    = param->GetPulseGain(det,rng,sec,str);
	  Float_t  ped     = param->GetPedestal(det,rng,sec,str);
	  Float_t  noise   = param->GetPedestalWidth(det,rng,sec,str);
	  UInt_t   ddl, board, chip, channel;
	  param->Detector2Hardware(det,rng,sec,str,ddl,board,chip,channel);
	  UShort_t strip   = str % 128;
	  Float_t  eped    = Hardware2Ped(ddl, board, chip, channel, strip);
	  Float_t  enoise  = Hardware2Noise(ddl, board, chip, channel, strip);
	  Float_t  egain   = Hardware2Gain(ddl, board, chip, channel, strip);
	  if (ped  != eped) 
	    Error(Form("FMD%d%c[%2d,%3d] (%d,%2d,%1d,%2d)",
		       det,rng,sec,str,ddl,board,chip,channel),
		  "pedestal=%14.7f != %14.7f", ped, eped);
	  if (noise  != enoise) 
	    Error(Form("FMD%d%c[%2d,%3d] (%d,%2d,%1d,%2d)",
		       det,rng,sec,str,ddl,board,chip,channel),
		  "noise=%14.7f != %14.7f", noise, enoise);
#if 0
	  // Will fail due to rounding errors.
	  if (gain  != egain) 
	    Error(Form("FMD%d%c[%2d,%3d] (%d,%2d,%1d,%2d)",
		       det,rng,sec,str,ddl,board,chip,channel),
		  "gain=%14.7f != %14.7f", gain, egain);
#endif
	}
      }
    }
  }
}

 
//====================================================================
//
// This script runs the test preprocessor. It uses AliTestShuttle to
// simulate a full Shuttle process
//
// The input data is created in the functions
//
//   CreateDCSAliasMap()   creates input that would in the same way come
//                         from DCS 
//   ReadDCSAliasMap()     reads from a file
//   CreateInputFilesMap() creates a list of local files, that can be
//                         accessed by the shuttle 
//
void TestPreprocessor(Bool_t createDummies=kTRUE,
		      const char* dbBase="local://$ALICE_ROOT/FMD/")
{
  // Dummy data
  if (createDummies) { 
    CreateDummyPeds pedMaker;
    pedMaker.Exec();
    CreateDummyGains gainMaker;
    gainMaker.Exec();
  }
  
  // load library - needs to be built using make
  gSystem->Load("libTestSHUTTLE.so"); 

   // create AliTestShuttle instance
  // The parameters are run, startTime, endTime
  AliTestShuttle* shuttle = new AliTestShuttle(0, 0, 1);

  // Set specific storage of FMD ALTRO map 
  AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
  AliCDBManager::Instance()->SetSpecificStorage("FMD/Calib/AltroMap",
						"local://$ALICE_ROOT");
  AliCDBManager::Instance()->SetRun(0);
  // TODO if needed, change location of OCDB and Reference test
  // folders by default they are set to
  // $ALICE_ROOT/TestCDB and TestReference
  AliTestShuttle::SetMainCDB(Form("%s/TestCDB", dbBase));
  AliTestShuttle::SetMainRefStorage(Form("%s/TestReference", dbBase));

  std::cout << "Test OCDB storage URI: " << AliShuttleInterface::GetMainCDB()
	    << "\n"
	    << "Test Reference storage Uri: "
	    << AliShuttleInterface::GetMainRefStorage().Data()
	    << std::endl;
  
  shuttle->AddInputFile(AliShuttleInterface::kDAQ, "FMD", "pedestal", 
			"source1", "peds.csv");
  shuttle->AddInputFile(AliShuttleInterface::kDAQ, "FMD", "gain", 
			"source2", "gains.csv");
  shuttle->SetInputRunType("PHYSICS");

  new AliFMDPreprocessor(shuttle);
  // Test the preprocessor
  shuttle->Process();


  // Read back 
  ReadBack(dbBase);
}
      
//____________________________________________________________________
// We do not use this functions .....yet
TMap* CreateDCSAliasMap()
{
  // Creates a DCS structure
  // The structure is the following:
  // 
  //   TMap (key --> value)
  //     <DCSAlias> --> <valueList>
  //     <DCSAlias> is a string
  //     <valueList> is a TObjArray of AliDCSValue
  //     An AliDCSValue consists of timestamp and a value in form of a
  //     AliSimpleValue 
  // 
  // In this example 6 aliases exists: DCSAlias1 ... DCSAlias6
  // Each contains 1000 values randomly generated by TRandom::Gaus +
  // 5*nAlias 
  TRandom random;
  TMap*   aliasMap = new TMap;
  aliasMap->SetOwner(1);

  for(int nAlias=0;nAlias<6;nAlias++) {
    TObjArray* valueSet = new TObjArray;
    valueSet->SetOwner(1);

    TString aliasName="DCSAlias";
    aliasName += nAlias;
    //printf("\n\n alias: %s\n\n",aliasName.Data());
    for (int timeStamp = 0; timeStamp < 1000; timeStamp += 10) {
      Float_t      x      =  Float_t(random.Gaus()+5*nAlias);
      AliDCSValue* dcsVal = new AliDCSValue(x, timeStamp);
      valueSet->Add(dcsVal);
    }
    aliasMap->Add(new TObjString(aliasName), valueSet);
  }

  return aliasMap;
}

//____________________________________________________________________
TMap* ReadDCSAliasMap()
{
  // Open a file that contains DCS input data
  // 
  // The CDB framework is used to open the file, this means the file
  // is located in 
  //  
  //   $ALICE_ROOT/FMD/TestCDB/<detector>/DCS/Data
  // 
  // The file contains an AliCDBEntry that contains a TMap with the
  // DCS structure.  An explanation of the structure can be found in
  // CreateDCSAliasMap() 
  AliCDBEntry *entry = 
    AliCDBManager::Instance()->GetStorage(AliShuttleInterface::GetMainCDB())
    ->Get("DET/DCS/Data", 0);
  return dynamic_cast<TMap*> (entry->GetObject());
}

//____________________________________________________________________
void WriteDCSAliasMap()
{
  // This writes the output from CreateDCSAliasMap to a CDB file

  TMap*          dcsAliasMap = CreateDCSAliasMap();
  AliCDBMetaData metaData;
  metaData.SetBeamPeriod(0);
  metaData.SetResponsible("Responsible person");
  metaData.SetComment("Test object for TestPreprocessor.C");

  AliCDBId id("DET/DCS/Data", 0, 0);
  
  // look into AliTestShuttle's CDB main folder
  AliCDBManager::Instance()->GetStorage(AliShuttleInterface::GetMainCDB())
    ->Put(dcsAliasMap, id, &metaData);
}

//____________________________________________________________________
//
// EOF
//
Commit	Line	Data
f6449cc0	1	/* $Id$ */
	2
	3	//====================================================================
	4	//
	5	// Helper classes
	6	//
	7	#include <iostream>
	8	#include <fstream>
	9	#ifndef __CINT__
	10	# include <TString.h>
	11	# include <AliPreprocessor.h>
	12	# include <../FMD/AliFMDPreprocessor.h>
	13	# include <AliShuttleInterface.h>
	14	# include <AliCDBStorage.h>
	15	# include <AliCDBEntry.h>
	16	# include <AliCDBManager.h>
	17	# include <AliCDBId.h>
	18	# include <AliCDBMetaData.h>
	19	# include <AliDCSValue.h>
	20	# include <AliLog.h>
	21	// # include <../FMD/AliFMDCalibZeroSuppression.h>
	22	// # include <../FMD/AliFMDCalibDeadMap.h>
	23	# include <../FMD/AliFMDParameters.h>
	24	# include <../SHUTTLE/TestShuttle/AliTestShuttle.h>
	25	# include <TRandom.h>
	26	# include <TSystem.h>
	27	# include <TObjString.h>
	28	# include <TMap.h>
	29	# include <TError.h>
	30	#endif
	31
	32	namespace {
	33	//====================================================================
	34	//
	35	// Helper functions
	36	//
	37	Float_t Hardware2Ped(int ddl, int board, int chip, int, int)
	38	{
	39	return ((chip & 0xf) \| ((board & 0x1F) << 4) \| (ddl << 9) & 0x3);
	40	}
	41	Float_t Hardware2Noise(int ddl, int board, int chip, int channel, int strip)
	42	{
	43	return ((strip & 0x7f) \| ((channel & 0xf) << 7));
	44	}
	45	Float_t Hardware2Gain(int ddl, int board, int chip, int channel, int strip)
	46	{
	47	return (((strip & 0x7f) << 0) \|
	48	((channel & 0x0f) << 7) \|
	49	((chip & 0x07) << 11) \|
	50	((board & 0x1f) << 14) \|
	51	((ddl & 0x03) << 19));
	52	}
	53
	54	//====================================================================
	55	//
	56	// Helper classes
	57	//
	58	//__________________________________________________________________
	59	class CreateDummyDaData
	60	{
	61	public:
	62	CreateDummyDaData(const char* output,
	63	int firstDDL, int lastDDL,
	64	int firstStrip, int lastStrip)
65	: fOutput(output),
66	fFirstDDL(firstDDL), fLastDDL(lastDDL),
67	fFirstStrip(firstStrip), fLastStrip(lastStrip)
68	{}
69	void Exec()
70	{
71	std::cout << "Will write on " << fOutput << std::endl;
72	std::ofstream file(fOutput.Data());
73	if (file.bad()) {
74	std::cerr << "Failed to open output file " << fOutput << std::endl;
75	return;
76	}
77	Header(file);
78	for (int ddl = fFirstDDL; ddl <= fLastDDL; ddl++) {
79	int boards[] = { 0, 16, (ddl==1 ? -1 : 1), (ddl==1 ? -1 : 17), -1};
80	int* bptr = boards;
81	int board = -1;
82	while ((board = (*bptr++)) >= 0) {
83	for (int chip = 0; chip < 3; chip++) {
84	for (int channel = 0; channel < (chip == 1 ? 8 : 16); channel++) {
85	for (int strip = fFirstStrip; strip <= fLastStrip; strip++) {
86	Output(file, ddl, board, chip, channel, strip);
87	}
88	} // for channel
89	} // for chip
90	} // while board
91	} // for ddl
92	file.close();
93	}
94	virtual void Header(std::ostream& file) = 0;
95	virtual void Output(std::ostream& file, int ddl, int board, int chip,
96	int channel, int strip) = 0;
97	protected:
98	TString fOutput;
99	int fFirstDDL;
100	int fLastDDL;
101	int fFirstStrip;
102	int fLastStrip;
103	};
104
105	//__________________________________________________________________
106	class CreateDummyPeds : public CreateDummyDaData
107	{
108	public:
109	CreateDummyPeds(const char* out="peds.csv",
110	int overSampling=4,
111	int firstDDL=0, int lastDDL=2,
112	int firstStrip=0, int lastStrip=127)
113	: CreateDummyDaData(out, firstDDL, lastDDL, firstStrip, lastStrip),
114	fOverSampling(overSampling)
115	{}
116	void Output(std::ostream& file, int ddl, int board, int chip, int channel,
117	int strip)
118	{
119	// Format is
120	// ddl,board,chip,channel,strip,sample,ped,noise,mu,sigma,chi2
121	for (int sample = 0; sample < fOverSampling; sample++) {
122	Float_t ped = Hardware2Ped(ddl, board, chip, channel, strip);
123	Float_t noise = Hardware2Noise(ddl, board, chip, channel, strip);
124	file // << ddl << ","
125	<< board << ","
126	<< chip << ","
127	<< channel << ","
128	<< strip << ","
129	<< sample << ","
130	<< ped << ","
131	<< noise << ","
132	<< chip << "," // Predictable mu
133	<< channel << "," // Predictable sigma
134	<< strip // Predictable chi2/ndf
135	<< endl;
136	}
137	}
138	void Header(std::ostream& file)
139	{
140	file << "# Pedestals\n"
141	<< "# ddl,board,chip,channel,strip,sample,mean,noise,mu,sigma,chi"
142	<< std::endl;
143	}
144	protected:
145	int fOverSampling;
146	};
147
148	//__________________________________________________________________
149	class CreateDummyGains : public CreateDummyDaData
150	{
151	public:
152	CreateDummyGains(const char* out="gains.csv",
153	int firstDDL=0, int lastDDL=2,
154	int firstStrip=0, int lastStrip=127)
155	: CreateDummyDaData(out, firstDDL, lastDDL, firstStrip, lastStrip)
156	{}
157	void Output(std::ostream& file, int ddl, int board, int chip, int channel,
158	int strip)
159	{
160	// Format is
161	// ddl,board,chip,channel,strip,gain,error,chi2
162	Float_t gain = Hardware2Gain(ddl, board, chip, channel, strip);
163	file // << ddl << ","
164	<< board << ","
165	<< chip << ","
166	<< channel << ","
167	<< strip << ","
168	<< gain << "," // Predictable gain
169	<< board << "," // Predictable error
170	<< strip // Predictable chi2/ndf
171	<< endl;
172	}
173	void Header(std::ostream& file)
174	{
175	file << "# Gains\n"
176	<< "# ddl,board,chip,channel,strip,gain,errorchi"
177	<< std::endl;
178	}
179	};
180	}
181
182	//====================================================================
183	//
184	// Read back the calibrations written, and check the values
185	//
186	void ReadBack(const char* dbBase="local://$ALICE_ROOT/FMD/")
187	{
188	AliLog::SetModuleDebugLevel("FMD", 1);
189	// Set specific storage of FMD ALTRO map
190	AliCDBManager::Instance()->SetDefaultStorage(Form("%s/TestCDB", dbBase));
191	AliCDBManager::Instance()->SetSpecificStorage("FMD/Calib/AltroMap",
192	"local://$ALICE_ROOT");
193	AliCDBManager::Instance()->SetRun(0);
194
195	AliFMDParameters* param = AliFMDParameters::Instance();
196	std::cout << "Getting the stuff via AliFMDParameters ... " << std::flush;
197	param->Init(kTRUE,AliFMDParameters::kPulseGain\|
198	AliFMDParameters::kPedestal\|
199	AliFMDParameters::kAltroMap);
200	std::cout << "done" << std::endl;
201	// param->Print("FMD1I[,]");
202
203	for (UShort_t det = 3; det <= 3; det++) {
204	Char_t rs[] = { 'I', (det==1 ? '\0' : 'O'), '\0' };
205	Char_t* pr = rs;
206	Char_t rng = '\0';
207	while ((rng = *(pr++)) != '\0') {
208	UShort_t nsec = (rng == 'I' ? 20 : 40);
209	UShort_t nstr = (rng == 'I' ? 512 : 256);
210	for (UShort_t sec = 0; sec < nsec; sec++) {
211	for (UShort_t str = 0; str < nstr; str++) {
212	Float_t gain = param->GetPulseGain(det,rng,sec,str);
213	Float_t ped = param->GetPedestal(det,rng,sec,str);
214	Float_t noise = param->GetPedestalWidth(det,rng,sec,str);
215	UInt_t ddl, board, chip, channel;
216	param->Detector2Hardware(det,rng,sec,str,ddl,board,chip,channel);
217	UShort_t strip = str % 128;
218	Float_t eped = Hardware2Ped(ddl, board, chip, channel, strip);
219	Float_t enoise = Hardware2Noise(ddl, board, chip, channel, strip);
220	Float_t egain = Hardware2Gain(ddl, board, chip, channel, strip);
221	if (ped != eped)
222	Error(Form("FMD%d%c[%2d,%3d] (%d,%2d,%1d,%2d)",
223	det,rng,sec,str,ddl,board,chip,channel),
224	"pedestal=%14.7f != %14.7f", ped, eped);
225	if (noise != enoise)
226	Error(Form("FMD%d%c[%2d,%3d] (%d,%2d,%1d,%2d)",
227	det,rng,sec,str,ddl,board,chip,channel),
228	"noise=%14.7f != %14.7f", noise, enoise);
229	#if 0
230	// Will fail due to rounding errors.
231	if (gain != egain)
232	Error(Form("FMD%d%c[%2d,%3d] (%d,%2d,%1d,%2d)",
233	det,rng,sec,str,ddl,board,chip,channel),
234	"gain=%14.7f != %14.7f", gain, egain);
235	#endif
236	}
237	}
238	}
239	}
240	}
241
242
243	//====================================================================
244	//
245	// This script runs the test preprocessor. It uses AliTestShuttle to
246	// simulate a full Shuttle process
247	//
248	// The input data is created in the functions
249	//
250	// CreateDCSAliasMap() creates input that would in the same way come
251	// from DCS
252	// ReadDCSAliasMap() reads from a file
253	// CreateInputFilesMap() creates a list of local files, that can be
254	// accessed by the shuttle
255	//
256	void TestPreprocessor(Bool_t createDummies=kTRUE,
257	const char* dbBase="local://$ALICE_ROOT/FMD/")
258	{
259	// Dummy data
260	if (createDummies) {
261	CreateDummyPeds pedMaker;
262	pedMaker.Exec();
263	CreateDummyGains gainMaker;
264	gainMaker.Exec();
265	}
266
267	// load library - needs to be built using make
268	gSystem->Load("libTestSHUTTLE.so");
269
270	// create AliTestShuttle instance
271	// The parameters are run, startTime, endTime
272	AliTestShuttle* shuttle = new AliTestShuttle(0, 0, 1);
273
274	// Set specific storage of FMD ALTRO map
275	AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
276	AliCDBManager::Instance()->SetSpecificStorage("FMD/Calib/AltroMap",
277	"local://$ALICE_ROOT");
278	AliCDBManager::Instance()->SetRun(0);
279	// TODO if needed, change location of OCDB and Reference test
280	// folders by default they are set to
281	// $ALICE_ROOT/TestCDB and TestReference
282	AliTestShuttle::SetMainCDB(Form("%s/TestCDB", dbBase));
283	AliTestShuttle::SetMainRefStorage(Form("%s/TestReference", dbBase));
284
285	std::cout << "Test OCDB storage URI: " << AliShuttleInterface::GetMainCDB()
286	<< "\n"
287	<< "Test Reference storage Uri: "
288	<< AliShuttleInterface::GetMainRefStorage().Data()
289	<< std::endl;
290
291	shuttle->AddInputFile(AliShuttleInterface::kDAQ, "FMD", "pedestal",
292	"source1", "peds.csv");
293	shuttle->AddInputFile(AliShuttleInterface::kDAQ, "FMD", "gain",
294	"source2", "gains.csv");
295	shuttle->SetInputRunType("PHYSICS");
296
297	new AliFMDPreprocessor(shuttle);
298	// Test the preprocessor
299	shuttle->Process();
300
301
302	// Read back
303	ReadBack(dbBase);
304	}
305
306	//____________________________________________________________________
307	// We do not use this functions .....yet
308	TMap* CreateDCSAliasMap()
309	{
310	// Creates a DCS structure
311	// The structure is the following:
312	//
313	// TMap (key --> value)
314	// <DCSAlias> --> <valueList>
315	// <DCSAlias> is a string
316	// <valueList> is a TObjArray of AliDCSValue
317	// An AliDCSValue consists of timestamp and a value in form of a
318	// AliSimpleValue
319	//
320	// In this example 6 aliases exists: DCSAlias1 ... DCSAlias6
321	// Each contains 1000 values randomly generated by TRandom::Gaus +
322	// 5*nAlias
323	TRandom random;
324	TMap* aliasMap = new TMap;
325	aliasMap->SetOwner(1);
326
327	for(int nAlias=0;nAlias<6;nAlias++) {
328	TObjArray* valueSet = new TObjArray;
329	valueSet->SetOwner(1);
330
331	TString aliasName="DCSAlias";
332	aliasName += nAlias;
333	//printf("\n\n alias: %s\n\n",aliasName.Data());
334	for (int timeStamp = 0; timeStamp < 1000; timeStamp += 10) {
335	Float_t x = Float_t(random.Gaus()+5*nAlias);
336	AliDCSValue* dcsVal = new AliDCSValue(x, timeStamp);
337	valueSet->Add(dcsVal);
338	}
339	aliasMap->Add(new TObjString(aliasName), valueSet);
340	}
341
342	return aliasMap;
343	}
344
345	//____________________________________________________________________
346	TMap* ReadDCSAliasMap()
347	{
348	// Open a file that contains DCS input data
349	//
350	// The CDB framework is used to open the file, this means the file
351	// is located in
352	//
353	// $ALICE_ROOT/FMD/TestCDB/<detector>/DCS/Data
354	//
355	// The file contains an AliCDBEntry that contains a TMap with the
356	// DCS structure. An explanation of the structure can be found in
357	// CreateDCSAliasMap()
358	AliCDBEntry *entry =
359	AliCDBManager::Instance()->GetStorage(AliShuttleInterface::GetMainCDB())
360	->Get("DET/DCS/Data", 0);
361	return dynamic_cast<TMap*> (entry->GetObject());
362	}
363
364	//____________________________________________________________________
365	void WriteDCSAliasMap()
366	{
367	// This writes the output from CreateDCSAliasMap to a CDB file
368
369	TMap* dcsAliasMap = CreateDCSAliasMap();
370	AliCDBMetaData metaData;
371	metaData.SetBeamPeriod(0);
372	metaData.SetResponsible("Responsible person");
373	metaData.SetComment("Test object for TestPreprocessor.C");
374
375	AliCDBId id("DET/DCS/Data", 0, 0);
376
377	// look into AliTestShuttle's CDB main folder
378	AliCDBManager::Instance()->GetStorage(AliShuttleInterface::GetMainCDB())
379	->Put(dcsAliasMap, id, &metaData);
380	}
381
382	//____________________________________________________________________
383	//
384	// EOF
385	//