[u/mrichter/AliRoot.git] / FMD / AliFMDPreprocessor.cxx

/**************************************************************************
 * Copyright(c) 2004, 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$ */
/** @file    AliFMDPreprocessor.cxx
    @author  Hans Hjersing Dalsgaard <canute@nbi.dk>
    @date    Mon Mar 27 12:39:09 2006
    @brief   Shuttle "preprocessor" for the FMD
*/
//___________________________________________________________________
//
// The class processes data points from DCS (via Amanada), and DAQ DA
// files (via FXS) to make calibration data for the FMD. 
//
// Data points: 
//    *  Nothing yet. 
//
// DAQ FXS file:
//    * pedestals - a (ASCII) Comma Separated Values files with the
//                  fields 
//                       rcu	 DDL number 
//                       board   FEC board number 
//                       chip    ALTRO chip number on FEC
//                       channel ALTRO channel number
//                       strip   VA1 strip number
//                       sample  Sample number
//                       ped     Mean of ADC spectra
//                       noise   Spread of ADC spectra
//                       mu      Mean of Gaussian fit to ADC spectra
//                       sigma   Variance of Gaussian fit to ADC spectra
//                       chi2    Chi^2 per degrees of freedom of fit
//    * Gains     - a (ASCII) Comma Separated Values files with the
//                  fields 
//                       rcu	 DDL number 
//                       board   FEC board number 
//                       chip    ALTRO chip number on FEC
//                       channel ALTRO channel number
//                       strip   VA1 strip number
//                       gain    Slope of gain
//                       error   Error on gain
//                       chi2    Chi^2 per degrees of freedom of fit
//                  
// See also 
//
//   http://aliceinfo.cern.ch/Offline/Activities/Shuttle.html
//
// Latest changes by Christian Holm Christensen
//

// #include <iostream>

#include <fstream>
#include "AliFMDPreprocessor.h"
#include "AliFMDCalibPedestal.h"
#include "AliFMDCalibGain.h"
#include "AliFMDCalibStripRange.h"
#include "AliFMDCalibSampleRate.h"
#include "AliFMDParameters.h"
#include "AliCDBMetaData.h"
#include "AliCDBManager.h"
// #include "AliDCSValue.h"
#include "AliLog.h"
#include <TTimeStamp.h>
// #include <TFile.h>
#include <TObjString.h>
#include <TString.h>
#include <TNamed.h>


ClassImp(AliFMDPreprocessor)
#if 0 // Do not remove - here to make Emacs happy
;
#endif 


//____________________________________________________
AliFMDPreprocessor::AliFMDPreprocessor(AliShuttleInterface* shuttle)
  : AliPreprocessor("FMD", shuttle)
{
  AddRunType("PHYSICS");
  AddRunType("STANDALONE");
  AddRunType("PEDESTAL");
  AddRunType("GAIN");
}


//____________________________________________________
Bool_t AliFMDPreprocessor::GetAndCheckFileSources(TList*&     list,
						  Int_t       system, 
						  const char* id) 
{
  // Convinience function 
  // Parameters: 
  //   list     On return, list of files. 
  //   system   Alice system (DAQ, DCS, ...)
  //   id       File id
  // Return:
  //   kTRUE on success. 
  list = GetFileSources(system, id);
  if (!list) { 
    TString sys;
    switch (system) { 
    case kDAQ: sys = "DAQ";     break;
    case kDCS: sys = "DCS";     break;
    default:   sys = "unknown"; break;
    }
    Log(Form("Failed to get file sources for %s/%s", sys.Data(), system));
    return kFALSE;
  }
  return kTRUE;
}

//____________________________________________________
AliCDBEntry* 
AliFMDPreprocessor::GetFromCDB(const char* second, const char* third)
{
  return GetFromOCDB(second, third);
}


//____________________________________________________
UInt_t AliFMDPreprocessor::Process(TMap* /* dcsAliasMap */)
{
  // Main member function. 
  // Parameters: 
  //    dcsAliassMap   Map of DCS data point aliases.
  // Return 
  //    0 on success, >0 otherwise 
  Bool_t resultPed   = kTRUE;
  Bool_t resultGain  = kTRUE;
  Bool_t resultRange = kTRUE;
  Bool_t resultRate  = kTRUE;
  Bool_t resultZero  = kTRUE;

  // Do we need this ?
  // if(!dcsAliasMap) return 1;
  // 
  // Invoking the cdb manager and the FMD parameters class
  // AliCDBManager* cdb   = AliCDBManager::Instance();
  // cdb->SetDefaultStorage("local://$ALICE_ROOT");
  // cdb->SetRun(0);
  AliFMDParameters* pars = AliFMDParameters::Instance();
  pars->Init(this, false, AliFMDParameters::kAltroMap);
  // This is if the SOR contains Fee parameters, and we run a DA to
  // extract these parameters.   The same code could work if we get
  // the information from DCS via the FXS 
  TList* files = 0;
  AliFMDCalibSampleRate*      calibRate  = 0;
  AliFMDCalibStripRange*      calibRange = 0;
  AliFMDCalibZeroSuppression* calibZero  = 0;
  // Disabled for now. 
  //#if 0
  if (GetAndCheckFileSources(files, kDAQ,pars->GetConditionsShuttleID()))
    GetInfoCalibration(files, calibRate, calibRange, calibZero);
  resultRate  = (!calibRate  ? kFALSE : kTRUE);
  resultRange = (!calibRange ? kFALSE : kTRUE);
  resultZero  = (!calibZero  ? kFALSE : kTRUE);
  //#endif

  // Gt the run type 
  TString runType(GetRunType()); 

  //Creating calibration objects
  AliFMDCalibPedestal* calibPed  = 0;
  AliFMDCalibGain*     calibGain = 0;
  if (runType.Contains("PEDESTAL", TString::kIgnoreCase)) { 
    if (GetAndCheckFileSources(files, kDAQ, pars->GetPedestalShuttleID())) {
      if(files->GetSize())
	calibPed = GetPedestalCalibration(files);
    }
    resultPed = (calibPed ? kTRUE : kFALSE);
  }
  if (runType.Contains("GAIN", TString::kIgnoreCase)) {
    if (GetAndCheckFileSources(files, kDAQ, pars->GetGainShuttleID())) {
      if(files->GetSize())
	calibGain = GetGainCalibration(files);
    }
    resultGain = (calibGain ? kTRUE : kFALSE);
  }
  
  //Storing Calibration objects  
  AliCDBMetaData metaData;
  metaData.SetBeamPeriod(0);
  metaData.SetResponsible("Hans H. Dalsgaard");
  metaData.SetComment("Preprocessor stores pedestals and gains for the FMD.");
  
  if(calibPed)  { 
    resultPed  = Store("Calib","Pedestal", calibPed, &metaData, 0, kTRUE);
    delete calibPed;
  }
  if(calibGain) { 
    resultGain = Store("Calib","PulseGain", calibGain, &metaData, 0, kTRUE);
    delete calibGain;
  }
  if(calibRange) { 
    resultRange = Store("Calib","StripRange", calibRange, &metaData, 0, kTRUE);
    delete calibRange;
  }
  if(calibRate) { 
    resultRate = Store("Calib","SampleRate", calibRate, &metaData, 0, kTRUE);
    delete calibRate;
  }
  if(calibZero) { 
    resultZero = Store("Calib","ZeroSuppression", calibZero,&metaData,0,kTRUE);
    delete calibZero;
  }

  //#if 0
  // Disabled until we implement GetInfoCalibration properly
  Bool_t success = (resultPed && resultGain  && resultRange && 
		    resultRate  && resultZero);
  //#endif
  //  Bool_t success = resultPed && resultGain;
  Log(Form("FMD preprocessor was %s", (success ? "successful" : "failed")));
  return (success ? 0 : 1);
}

//____________________________________________________________________
Bool_t
AliFMDPreprocessor::GetInfoCalibration(TList* files, 
				       AliFMDCalibSampleRate*&      s,
				       AliFMDCalibStripRange*&      r, 
				       AliFMDCalibZeroSuppression*& z)
{
  // Get info calibrations. 
  // Parameters:
  //     files List of files. 
  //     s     On return, newly allocated object 
  //     r     On return, newly allocated object 
  //     z     On return, newly allocated object 
  // Return: 
  //     kTRUE on success
  if (!files) return kTRUE; // Should really be false
  if (files->GetEntries() <= 0) return kTRUE;
  
  s = new AliFMDCalibSampleRate();
  r = new AliFMDCalibStripRange();
  z = new AliFMDCalibZeroSuppression();
  
  AliFMDParameters*    pars     = AliFMDParameters::Instance();
  TIter                iter(files);
  TObjString*          fileSource;

  while((fileSource = dynamic_cast<TObjString*>(iter.Next()))) {
    const Char_t* filename = GetFile(kDAQ, pars->GetConditionsShuttleID(), fileSource->GetName());
    std::ifstream in(filename);
    if(!in) {
      Log(Form("File %s not found!", filename));
      continue;
    }
    s->ReadFromFile(in);
    r->ReadFromFile(in);
  }
  return kTRUE;
}

  
//____________________________________________________________________
AliFMDCalibPedestal* 
AliFMDPreprocessor::GetPedestalCalibration(TList* pedFiles)
{
  // Read DAQ DA produced CSV files of pedestals, and return a
  // calibration object. 
  // Parameters:
  //   pedFiles     List of pedestal files 
  // Return 
  //   A pointer to a newly allocated AliFMDCalibPedestal object, or
  //   null in case of errors. 
  if(!pedFiles) return 0;

  AliFMDCalibPedestal* calibPed = new AliFMDCalibPedestal();
  AliFMDParameters*    pars     = AliFMDParameters::Instance();
  TIter                iter(pedFiles);
  TObjString*          fileSource;
  
  while((fileSource = dynamic_cast<TObjString*>(iter.Next()))) {
    const Char_t* filename = GetFile(kDAQ, pars->GetPedestalShuttleID(), fileSource->GetName());
    std::ifstream in(filename);
    if(!in) {
      Log(Form("File %s not found!", filename));
      continue;
    }

    // Get header (how long is it ?)
    TString header;
    header.ReadLine(in);
    header.ToLower();
    if(!header.Contains("pedestal")) {
      Log("File header is not from pedestal!");
      continue;
    }
    Log("File contains data from pedestals");
    
    // Read columns line
    int lineno = 2;
    header.ReadLine(in);
    
    // Loop until EOF
    while(in.peek()!=EOF) {
      if(in.bad()) { 
	Log(Form("Bad read at line %d in %s", lineno, filename));
	break;
      }
      UShort_t det, sec, strip;
      Char_t ring;
      Float_t ped, noise, mu, sigma, chi2ndf;
      Char_t c[8];
	  
      in >> det      >> c[0] 
	 >> ring     >> c[1]
	 >> sec      >> c[2]
	 >> strip    >> c[3]
	 >> ped      >> c[4]
	 >> noise    >> c[5]
	 >> mu       >> c[6]
	 >> sigma    >> c[7]
	 >> chi2ndf;
      lineno++;
      
      // Ignore trailing garbage 
      // if (strip > 127) continue;
      
      //Setting DDL to comply with the FMD in DAQ
      // UInt_t FmdDDLBase = 3072; 
      // ddl = ddl - FmdDDLBase;
      //Setting the pedestals via the hardware address
      
      
      // pars->Hardware2Detector(ddl,board,chip,channel,det,ring,sec,str);
      // strip += str;
     
      calibPed->Set(det,ring,sec,strip,ped,noise);
     
    }
  }
  return calibPed;
}	

//____________________________________________________________________
AliFMDCalibGain* 
AliFMDPreprocessor::GetGainCalibration(TList* gainFiles)
{
  // Read DAQ DA produced CSV files of pedestals, and return a
  // calibration object. 
  // Parameters:
  //   pedFiles     List of pedestal files 
  // Return 
  //   A pointer to a newly allocated AliFMDCalibPedestal object, or
  //   null in case of errors. 
  if(!gainFiles) return 0;
  
  AliFMDCalibGain*  calibGain  = new AliFMDCalibGain();
  AliFMDParameters* pars       = AliFMDParameters::Instance();
  TIter             iter(gainFiles);
  TObjString*       fileSource;
  while((fileSource = dynamic_cast<TObjString *>(iter.Next()))) {
    const Char_t* filename = GetFile(kDAQ, pars->GetGainShuttleID(), fileSource->GetName());
    std::ifstream in(filename);
    if(!in) {
      Log(Form("File %s not found!", filename));
      continue;
    }

    //Get header (how long is it ?)
    TString header;
    header.ReadLine(in);
    header.ToLower();
    if(!header.Contains("gain")) {
      Log("File header is not from gain!");
      continue;
    }
    Log("File contains data from pulse gain");

    // Read column headers
    header.ReadLine(in);

    int lineno  = 2;
    // Read until EOF 
    while(in.peek()!=EOF) {
      if(in.bad()) { 
	Log(Form("Bad read at line %d in %s", lineno, filename));
	break;
      }
      UShort_t det, sec, strip;
      Char_t ring;
      
      Float_t gain,error,  chi2ndf;
      Char_t c[6];
      
      in >> det      >> c[0] 
	 >> ring     >> c[1]
	 >> sec      >> c[2]
	 >> strip    >> c[3]
	 >> gain     >> c[4]
	 >> error    >> c[5]
	 >> chi2ndf;
      lineno++;
      // Ignore trailing garbage
      //if(strip > 127) continue;
      
      //Setting DDL to comply with the FMD in DAQ
      // UInt_t FmdDDLBase = 3072; 
      // ddl = ddl - FmdDDLBase;
      //Setting the pedestals via the hardware address
      //   pars->Hardware2Detector(ddl,board,chip,channel,det,ring,sec,str);

      // strip += str;
      calibGain->Set(det,ring,sec,strip,gain);
    }
  }
  return calibGain;
}

//____________________________________________________________________
//
// EOF
//
Commit	Line	Data
f6449cc0	1	/**************************************************************************
	2	* Copyright(c) 2004, 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	/* $Id$ */
	16	/** @file AliFMDPreprocessor.cxx
	17	@author Hans Hjersing Dalsgaard <canute@nbi.dk>
	18	@date Mon Mar 27 12:39:09 2006
	19	@brief Shuttle "preprocessor" for the FMD
	20	*/
	21	//___________________________________________________________________
	22	//
	23	// The class processes data points from DCS (via Amanada), and DAQ DA
	24	// files (via FXS) to make calibration data for the FMD.
	25	//
	26	// Data points:
	27	// * Nothing yet.
	28	//
	29	// DAQ FXS file:
	30	// * pedestals - a (ASCII) Comma Separated Values files with the
	31	// fields
	32	// rcu DDL number
	33	// board FEC board number
	34	// chip ALTRO chip number on FEC
	35	// channel ALTRO channel number
	36	// strip VA1 strip number
	37	// sample Sample number
	38	// ped Mean of ADC spectra
	39	// noise Spread of ADC spectra
	40	// mu Mean of Gaussian fit to ADC spectra
	41	// sigma Variance of Gaussian fit to ADC spectra
	42	// chi2 Chi^2 per degrees of freedom of fit
	43	// * Gains - a (ASCII) Comma Separated Values files with the
	44	// fields
	45	// rcu DDL number
	46	// board FEC board number
	47	// chip ALTRO chip number on FEC
	48	// channel ALTRO channel number
	49	// strip VA1 strip number
	50	// gain Slope of gain
	51	// error Error on gain
	52	// chi2 Chi^2 per degrees of freedom of fit
	53	//
826a3db2	54	// See also
	55	//
	56	// http://aliceinfo.cern.ch/Offline/Activities/Shuttle.html
	57	//
f6449cc0	58	// Latest changes by Christian Holm Christensen
	59	//
	60
	61	// #include <iostream>
	62
	63	#include <fstream>
	64	#include "AliFMDPreprocessor.h"
	65	#include "AliFMDCalibPedestal.h"
	66	#include "AliFMDCalibGain.h"
dc02d468	67	#include "AliFMDCalibStripRange.h"
dc02d468	68	#include "AliFMDCalibSampleRate.h"
f6449cc0	69	#include "AliFMDParameters.h"
	70	#include "AliCDBMetaData.h"
	71	#include "AliCDBManager.h"
	72	// #include "AliDCSValue.h"
	73	#include "AliLog.h"
	74	#include <TTimeStamp.h>
	75	// #include <TFile.h>
	76	#include <TObjString.h>
	77	#include <TString.h>
	78	#include <TNamed.h>
	79
	80
	81	ClassImp(AliFMDPreprocessor)
	82	#if 0 // Do not remove - here to make Emacs happy
	83	;
	84	#endif
	85
bece5229	86
	87	//____________________________________________________
	88	AliFMDPreprocessor::AliFMDPreprocessor(AliShuttleInterface* shuttle)
	89	: AliPreprocessor("FMD", shuttle)
	90	{
	91	AddRunType("PHYSICS");
	92	AddRunType("STANDALONE");
	93	AddRunType("PEDESTAL");
	94	AddRunType("GAIN");
	95	}
	96
	97
dc02d468	98	//____________________________________________________
	99	Bool_t AliFMDPreprocessor::GetAndCheckFileSources(TList*& list,
	100	Int_t system,
	101	const char* id)
	102	{
	103	// Convinience function
	104	// Parameters:
	105	// list On return, list of files.
	106	// system Alice system (DAQ, DCS, ...)
	107	// id File id
	108	// Return:
	109	// kTRUE on success.
	110	list = GetFileSources(system, id);
	111	if (!list) {
	112	TString sys;
	113	switch (system) {
	114	case kDAQ: sys = "DAQ"; break;
	115	case kDCS: sys = "DCS"; break;
	116	default: sys = "unknown"; break;
	117	}
	118	Log(Form("Failed to get file sources for %s/%s", sys.Data(), system));
	119	return kFALSE;
	120	}
	121	return kTRUE;
	122	}
	123
	124	//____________________________________________________
	125	AliCDBEntry*
	126	AliFMDPreprocessor::GetFromCDB(const char* second, const char* third)
	127	{
	128	return GetFromOCDB(second, third);
	129	}
	130
	131
f6449cc0	132	//____________________________________________________
	133	UInt_t AliFMDPreprocessor::Process(TMap* /* dcsAliasMap */)
	134	{
	135	// Main member function.
	136	// Parameters:
	137	// dcsAliassMap Map of DCS data point aliases.
	138	// Return
826a3db2	139	// 0 on success, >0 otherwise
	140	Bool_t resultPed = kTRUE;
	141	Bool_t resultGain = kTRUE;
	142	Bool_t resultRange = kTRUE;
	143	Bool_t resultRate = kTRUE;
	144	Bool_t resultZero = kTRUE;
f6449cc0	145
	146	// Do we need this ?
	147	// if(!dcsAliasMap) return 1;
	148	//
	149	// Invoking the cdb manager and the FMD parameters class
	150	// AliCDBManager* cdb = AliCDBManager::Instance();
	151	// cdb->SetDefaultStorage("local://$ALICE_ROOT");
	152	// cdb->SetRun(0);
	153	AliFMDParameters* pars = AliFMDParameters::Instance();
dc02d468	154	pars->Init(this, false, AliFMDParameters::kAltroMap);
dc02d468	155	// This is if the SOR contains Fee parameters, and we run a DA to
	156	// extract these parameters. The same code could work if we get
	157	// the information from DCS via the FXS
	158	TList* files = 0;
dc02d468	159	AliFMDCalibSampleRate* calibRate = 0;
	160	AliFMDCalibStripRange* calibRange = 0;
	161	AliFMDCalibZeroSuppression* calibZero = 0;
826a3db2	162	// Disabled for now.
b0dbd59f	163	//#if 0
ae3f7f5f	164	if (GetAndCheckFileSources(files, kDAQ,pars->GetConditionsShuttleID()))
bd44b1d9	165	GetInfoCalibration(files, calibRate, calibRange, calibZero);
	166	resultRate = (!calibRate ? kFALSE : kTRUE);
	167	resultRange = (!calibRange ? kFALSE : kTRUE);
	168	resultZero = (!calibZero ? kFALSE : kTRUE);
b0dbd59f	169	//#endif
826a3db2	170
dc02d468	171	// Gt the run type
	172	TString runType(GetRunType());
	173
f6449cc0	174	//Creating calibration objects
dc02d468	175	AliFMDCalibPedestal* calibPed = 0;
dc02d468	176	AliFMDCalibGain* calibGain = 0;
bd44b1d9	177	if (runType.Contains("PEDESTAL", TString::kIgnoreCase)) {
ae3f7f5f	178	if (GetAndCheckFileSources(files, kDAQ, pars->GetPedestalShuttleID())) {
bd44b1d9	179	if(files->GetSize())
	180	calibPed = GetPedestalCalibration(files);
	181	}
	182	resultPed = (calibPed ? kTRUE : kFALSE);
	183	}
bece5229	184	if (runType.Contains("GAIN", TString::kIgnoreCase)) {
ae3f7f5f	185	if (GetAndCheckFileSources(files, kDAQ, pars->GetGainShuttleID())) {
bd44b1d9	186	if(files->GetSize())
	187	calibGain = GetGainCalibration(files);
	188	}
	189	resultGain = (calibGain ? kTRUE : kFALSE);
	190	}
f6449cc0	191
	192	//Storing Calibration objects
	193	AliCDBMetaData metaData;
	194	metaData.SetBeamPeriod(0);
	195	metaData.SetResponsible("Hans H. Dalsgaard");
	196	metaData.SetComment("Preprocessor stores pedestals and gains for the FMD.");
	197
dc02d468	198	if(calibPed) {
826a3db2	199	resultPed = Store("Calib","Pedestal", calibPed, &metaData, 0, kTRUE);
dc02d468	200	delete calibPed;
	201	}
	202	if(calibGain) {
826a3db2	203	resultGain = Store("Calib","PulseGain", calibGain, &metaData, 0, kTRUE);
dc02d468	204	delete calibGain;
	205	}
	206	if(calibRange) {
826a3db2	207	resultRange = Store("Calib","StripRange", calibRange, &metaData, 0, kTRUE);
dc02d468	208	delete calibRange;
	209	}
	210	if(calibRate) {
826a3db2	211	resultRate = Store("Calib","SampleRate", calibRate, &metaData, 0, kTRUE);
dc02d468	212	delete calibRate;
	213	}
	214	if(calibZero) {
bd44b1d9	215	resultZero = Store("Calib","ZeroSuppression", calibZero,&metaData,0,kTRUE);
dc02d468	216	delete calibZero;
dc02d468	217	}
826a3db2	218
b0dbd59f	219	//#if 0
dc02d468	220	// Disabled until we implement GetInfoCalibration properly
826a3db2	221	Bool_t success = (resultPed && resultGain && resultRange &&
826a3db2	222	resultRate && resultZero);
b0dbd59f	223	//#endif
b0dbd59f	224	// Bool_t success = resultPed && resultGain;
826a3db2	225	Log(Form("FMD preprocessor was %s", (success ? "successful" : "failed")));
826a3db2	226	return (success ? 0 : 1);
dc02d468	227	}
	228
	229	//____________________________________________________________________
	230	Bool_t
	231	AliFMDPreprocessor::GetInfoCalibration(TList* files,
	232	AliFMDCalibSampleRate*& s,
	233	AliFMDCalibStripRange*& r,
	234	AliFMDCalibZeroSuppression*& z)
	235	{
	236	// Get info calibrations.
	237	// Parameters:
	238	// files List of files.
	239	// s On return, newly allocated object
	240	// r On return, newly allocated object
	241	// z On return, newly allocated object
	242	// Return:
	243	// kTRUE on success
	244	if (!files) return kTRUE; // Should really be false
	245	if (files->GetEntries() <= 0) return kTRUE;
	246
	247	s = new AliFMDCalibSampleRate();
	248	r = new AliFMDCalibStripRange();
	249	z = new AliFMDCalibZeroSuppression();
	250
ae3f7f5f	251	AliFMDParameters* pars = AliFMDParameters::Instance();
dc02d468	252	TIter iter(files);
	253	TObjString* fileSource;
	254
	255	while((fileSource = dynamic_cast<TObjString*>(iter.Next()))) {
ae3f7f5f	256	const Char_t* filename = GetFile(kDAQ, pars->GetConditionsShuttleID(), fileSource->GetName());
dc02d468	257	std::ifstream in(filename);
dc02d468	258	if(!in) {
826a3db2	259	Log(Form("File %s not found!", filename));
dc02d468	260	continue;
dc02d468	261	}
b0dbd59f	262	s->ReadFromFile(in);
b0dbd59f	263	r->ReadFromFile(in);
dc02d468	264	}
dc02d468	265	return kTRUE;
f6449cc0	266	}
f6449cc0	267
dc02d468	268
f6449cc0	269	//____________________________________________________________________
	270	AliFMDCalibPedestal*
	271	AliFMDPreprocessor::GetPedestalCalibration(TList* pedFiles)
	272	{
	273	// Read DAQ DA produced CSV files of pedestals, and return a
	274	// calibration object.
	275	// Parameters:
	276	// pedFiles List of pedestal files
	277	// Return
	278	// A pointer to a newly allocated AliFMDCalibPedestal object, or
	279	// null in case of errors.
	280	if(!pedFiles) return 0;
	281
	282	AliFMDCalibPedestal* calibPed = new AliFMDCalibPedestal();
	283	AliFMDParameters* pars = AliFMDParameters::Instance();
	284	TIter iter(pedFiles);
	285	TObjString* fileSource;
	286
	287	while((fileSource = dynamic_cast<TObjString*>(iter.Next()))) {
ae3f7f5f	288	const Char_t* filename = GetFile(kDAQ, pars->GetPedestalShuttleID(), fileSource->GetName());
f6449cc0	289	std::ifstream in(filename);
f6449cc0	290	if(!in) {
826a3db2	291	Log(Form("File %s not found!", filename));
f6449cc0	292	continue;
	293	}
	294
	295	// Get header (how long is it ?)
	296	TString header;
	297	header.ReadLine(in);
	298	header.ToLower();
	299	if(!header.Contains("pedestal")) {
826a3db2	300	Log("File header is not from pedestal!");
f6449cc0	301	continue;
	302	}
	303	Log("File contains data from pedestals");
	304
	305	// Read columns line
	306	int lineno = 2;
	307	header.ReadLine(in);
	308
	309	// Loop until EOF
bd44b1d9	310	while(in.peek()!=EOF) {
f6449cc0	311	if(in.bad()) {
826a3db2	312	Log(Form("Bad read at line %d in %s", lineno, filename));
f6449cc0	313	break;
f6449cc0	314	}
3bae5d02	315	UShort_t det, sec, strip;
3bae5d02	316	Char_t ring;
f6449cc0	317	Float_t ped, noise, mu, sigma, chi2ndf;
3bae5d02	318	Char_t c[8];
f6449cc0	319
3bae5d02	320	in >> det >> c[0]
	321	>> ring >> c[1]
	322	>> sec >> c[2]
	323	>> strip >> c[3]
	324	>> ped >> c[4]
	325	>> noise >> c[5]
	326	>> mu >> c[6]
	327	>> sigma >> c[7]
f6449cc0	328	>> chi2ndf;
f6449cc0	329	lineno++;
bd44b1d9	330
f6449cc0	331	// Ignore trailing garbage
3bae5d02	332	// if (strip > 127) continue;
f6449cc0	333
bd44b1d9	334	//Setting DDL to comply with the FMD in DAQ
3bae5d02	335	// UInt_t FmdDDLBase = 3072;
3bae5d02	336	// ddl = ddl - FmdDDLBase;
f6449cc0	337	//Setting the pedestals via the hardware address
bd44b1d9	338
3bae5d02	339
	340	// pars->Hardware2Detector(ddl,board,chip,channel,det,ring,sec,str);
	341	// strip += str;
bd44b1d9	342
f6449cc0	343	calibPed->Set(det,ring,sec,strip,ped,noise);
bd44b1d9	344
f6449cc0	345	}
	346	}
	347	return calibPed;
	348	}
	349
	350	//____________________________________________________________________
	351	AliFMDCalibGain*
	352	AliFMDPreprocessor::GetGainCalibration(TList* gainFiles)
	353	{
	354	// Read DAQ DA produced CSV files of pedestals, and return a
	355	// calibration object.
	356	// Parameters:
	357	// pedFiles List of pedestal files
	358	// Return
	359	// A pointer to a newly allocated AliFMDCalibPedestal object, or
	360	// null in case of errors.
	361	if(!gainFiles) return 0;
	362
	363	AliFMDCalibGain* calibGain = new AliFMDCalibGain();
	364	AliFMDParameters* pars = AliFMDParameters::Instance();
	365	TIter iter(gainFiles);
	366	TObjString* fileSource;
	367	while((fileSource = dynamic_cast<TObjString *>(iter.Next()))) {
ae3f7f5f	368	const Char_t* filename = GetFile(kDAQ, pars->GetGainShuttleID(), fileSource->GetName());
f6449cc0	369	std::ifstream in(filename);
f6449cc0	370	if(!in) {
826a3db2	371	Log(Form("File %s not found!", filename));
f6449cc0	372	continue;
	373	}
	374
	375	//Get header (how long is it ?)
	376	TString header;
	377	header.ReadLine(in);
	378	header.ToLower();
	379	if(!header.Contains("gain")) {
826a3db2	380	Log("File header is not from gain!");
f6449cc0	381	continue;
	382	}
	383	Log("File contains data from pulse gain");
	384
	385	// Read column headers
	386	header.ReadLine(in);
	387
	388	int lineno = 2;
	389	// Read until EOF
bd44b1d9	390	while(in.peek()!=EOF) {
f6449cc0	391	if(in.bad()) {
826a3db2	392	Log(Form("Bad read at line %d in %s", lineno, filename));
f6449cc0	393	break;
f6449cc0	394	}
3bae5d02	395	UShort_t det, sec, strip;
	396	Char_t ring;
	397
f6449cc0	398	Float_t gain,error, chi2ndf;
3bae5d02	399	Char_t c[6];
	400
	401	in >> det >> c[0]
	402	>> ring >> c[1]
	403	>> sec >> c[2]
	404	>> strip >> c[3]
	405	>> gain >> c[4]
	406	>> error >> c[5]
f6449cc0	407	>> chi2ndf;
	408	lineno++;
	409	// Ignore trailing garbage
3bae5d02	410	//if(strip > 127) continue;
f6449cc0	411
bd44b1d9	412	//Setting DDL to comply with the FMD in DAQ
3bae5d02	413	// UInt_t FmdDDLBase = 3072;
3bae5d02	414	// ddl = ddl - FmdDDLBase;
f6449cc0	415	//Setting the pedestals via the hardware address
3bae5d02	416	// pars->Hardware2Detector(ddl,board,chip,channel,det,ring,sec,str);
f6449cc0	417
3bae5d02	418	// strip += str;
f6449cc0	419	calibGain->Set(det,ring,sec,strip,gain);
	420	}
	421	}
	422	return calibGain;
	423	}
	424
	425	//____________________________________________________________________
	426	//
	427	// EOF
	428	//