[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>
# include <iostream>
#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/OCDB/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/OCDB");
  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(const char* runType="PEDESTAL", 
		      Bool_t createDummies=kTRUE,
		      const char* dbBase="local://$ALICE_ROOT/OCDB/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);
  AliTestShuttle::SetMainCDB("local://$ALICE_ROOT/OCDB/FMD/TestCDB");
  AliTestShuttle::SetLocalCDB(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(runType);
  // shuttle->SetInputRunType("PEDESTAL PULSER 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);
}

#ifndef __CINT__
int
main(int argc, char** argv)
{
  Bool_t createDummies = kTRUE;
  TString dbBase   = "local://$ALICE_ROOT/OCDB/FMD/";
  for (int i = 1; i < argc; i++) { 
    if (argv[i][0] == '-') { 
      switch (argv[i][1])  {
      case 'h': 
	std::cout << "Usage: " << argv[0] << " [OPTIONS]\n\n"
		  << "Options:\n"
		  << "\t-h\tThis help\n"
		  << "\t-d\tToggle dummies\n" 
		  << "\t-b DIR\tSet database dir\n" 
		  << std::endl;
	return 0;
      case 'd':  createDummies = !createDummies; break;
      case 'b':  dbBase = argv[++i]; break;
      }
    }
  }
  
  TestPreprocessor(createDummies, dbBase);
  return 0;
}

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