[u/mrichter/AliRoot.git] / TOF / AliTOFPreprocessor.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, 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.                  *
 **************************************************************************/

/*
$Log$
Revision 1.4  2006/12/19 08:53:27  arcelli
Changed filenames types to TString + split file sources (C.Zampolli)

Revision 1.3  2006/12/18 18:16:53  arcelli
Change in the format of the input data from DAQ FXS (C.Zampolli)

Revision 1.1  2006/10/26 09:09:29  arcelli
prototype for the TOF Shuttle preprocessor (C.Zampolli)

*/  

#include "AliTOFPreprocessor.h"

#include "AliCDBMetaData.h"
#include "AliLog.h"
#include "AliTOFDataDCS.h"
#include "TFile.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "AliTOFCalOnline.h"
#include "AliTOFChannelOnline.h"
#include "AliTOFGeometryV5.h"
#include "TTimeStamp.h"
#include "TH1F.h"
#include "TH2S.h"
#include "TH1S.h"
#include "TH1.h"
#include <Riostream.h>
#include <stdio.h>
#include <stdlib.h>

class TF1;
class AliDCSValue;
class AliTOFGeometry;

// TOF preprocessor class.
// It takes data from DCS and passes them to the class AliTOFDataDCS, which
// processes them. The result is then written to the CDB.
// analogously, it takes data form DAQ (both at Run level and inclusive - 
// of all the runs - level, processes them, and stores both Reference Data
// and Online Calibration files in the CDB. 


ClassImp(AliTOFPreprocessor)

const Int_t AliTOFPreprocessor::fgkBinRangeAve    = 13; // number of bins where to calculate the mean 
const Double_t AliTOFPreprocessor::fgkThrPar    = 0.013; // parameter used to trigger the calculation of the delay

//_____________________________________________________________________________

AliTOFPreprocessor::AliTOFPreprocessor(AliShuttleInterface* shuttle) :
  AliPreprocessor("TOF", shuttle),
  fData(0),
  fh2(0),
  fCal(0),
  fTOFGeometry(0)
{
  // constructor
}

//_____________________________________________________________________________

AliTOFPreprocessor::~AliTOFPreprocessor()
{
  // destructor
  delete fData;
  fData = 0;
  delete fh2;
  fh2 = 0;
  delete fCal;
  fCal = 0;
  delete fTOFGeometry;
  fTOFGeometry = 0;
}

//______________________________________________________________________________
void AliTOFPreprocessor::Initialize(Int_t run, UInt_t startTime,
	UInt_t endTime)
{
  // Creates AliTOFDataDCS object

  AliPreprocessor::Initialize(run, startTime, endTime);

	AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s", run,
		TTimeStamp(startTime).AsString(),
		TTimeStamp(endTime).AsString()));

	fData = new AliTOFDataDCS(fRun, fStartTime, fEndTime);
	fh2 = 0x0;
	fTOFGeometry = new AliTOFGeometryV5();
	fCal = new AliTOFCalOnline(fTOFGeometry);
	fCal->CreateArray();
}

//_____________________________________________________________________________

UInt_t AliTOFPreprocessor::Process(TMap* dcsAliasMap)
{
  // Fills data into a AliTOFDataDCS object

  TH1::AddDirectory(0);
  UInt_t resultDCS=0;
  UInt_t resultDAQ=0;
  UInt_t resultDAQRef=0;
  UInt_t result=0;

  // processing DCS

  if (!dcsAliasMap){
    Log("No DCS map found");
  }
  else {
  // The processing of the DCS input data is forwarded to AliTOFDataDCS
    fData->ProcessData(*dcsAliasMap);
    AliCDBMetaData metaDataDCS;
    metaDataDCS.SetBeamPeriod(0);
    metaDataDCS.SetResponsible("Chiara Zampolli");
    metaDataDCS.SetComment("This preprocessor fills an AliTOFDataDCS object.");     resultDCS = Store("Calib","DCSData",fData, &metaDataDCS);
    //    result+=resultDCS;
    if (!resultDCS){
      Log("Some problems occurred while storing DCS data processing results");
      return 0;
    }
  }

  // processing DAQ

  TFile * daqFile=0x0;

  //retrieving data at Run level
  TList* list = GetFileSources(kDAQ, "RUNLevel");
  if (list)
    {
      AliInfo("The following sources produced files with the id RUNLevel");
      list->Print();
      for (Int_t jj=0;jj<list->GetEntries();jj++){
	TObjString * str = dynamic_cast<TObjString*> (list->At(jj));
	AliInfo(Form("found source %s", str->String().Data()));
	// file to be stored run per run
	TString fileNameRun = GetFile(kDAQ, "RUNLevel", str->GetName());
	if (fileNameRun.Length()>0){
	  AliInfo(Form("Got the file %s, now we can store the Reference Data for the current Run.", fileNameRun.Data()));
	  daqFile = new TFile(fileNameRun.Data(),"READ");
	  fh2 = (TH2S*) daqFile->Get("htof");
	  AliCDBMetaData metaDataHisto;
	  metaDataHisto.SetBeamPeriod(0);
	  metaDataHisto.SetResponsible("Chiara Zampolli");
	  metaDataHisto.SetComment("This preprocessor stores the array of histos object as Reference Data.");
	  resultDAQRef = StoreReferenceData("Calib","DAQData",fh2, &metaDataHisto);
	  //	  result+=resultDAQRef*2;
	  if (!resultDAQRef){
	    Log("some problems occurred::No Reference Data stored, still going on (please check!)");
	  }
	  daqFile->Close();
	  delete daqFile;
	}

	else{
          Log("The input data file from DAQ (run-level) was not found, still going on with Cumulative data file (please check!) "); 
	} 
      }
    }
  else{
    Log("The input data file list from DAQ (run-level) was not found, still going on with Cumulative data file (please check!) "); 
  }

  //Total files, with summed histos

  TList* listTot = GetFileSources(kDAQ, "DELAYS");
  if (listTot)
    {
      AliInfo("The following sources produced files with the id DELAYS");
      listTot->Print();
      for (Int_t jj=0;jj<listTot->GetEntries();jj++){
	TObjString * str = dynamic_cast<TObjString*> (listTot->At(jj));
	AliInfo(Form("found source %s", str->String().Data()));

	// file with summed histos, to extract calib params
	TString fileName = GetFile(kDAQ, "DELAYS", str->GetName());
	if (fileName.Length()>0){
	  AliInfo(Form("Got the file %s, now we can extract some values.", fileName.Data()));

	  daqFile = new TFile(fileName.Data(),"READ");
	  fh2 = (TH2S*) daqFile->Get("htoftot");
	  if (!fh2){
	    Log("some problems occurred:: No histo retrieved, TOF exiting from Shuttle");
	    delete daqFile;
	    return 0;
	  }
	  else {
	    static const Int_t size=fh2->GetNbinsX();
	    static const Int_t nbins=fh2->GetNbinsY();
	    static const Double_t xbinmin=fh2->GetYaxis()->GetBinLowEdge(1);
	    Int_t npads = fCal->NPads();
	    if (size != npads){
	      Log(" number of bins along x different from number of pads, found only a subset of the histograms, TOF exiting from Shuttle");
	      delete daqFile;
	      return 0;
	    }
	    for (Int_t ich=0;ich<size;ich++){
	      TH1S *h1 = new TH1S("h1","h1",nbins,xbinmin-0.5,nbins*1.+xbinmin-0.5);
	      for (Int_t ibin=0;ibin<nbins;ibin++){
		h1->SetBinContent(ibin+1,fh2->GetBinContent(ich+1,ibin+1));
	      }
	      Bool_t found=kFALSE; 
	      Float_t minContent=h1->Integral()*fgkThrPar; 
	      Int_t nbinsX = h1->GetNbinsX();
	      Int_t startBin=1;
	      for (Int_t j=1; j<=nbinsX; j++){
		if ((
		     h1->GetBinContent(j) +     
		     h1->GetBinContent(j+1)+
		     h1->GetBinContent(j+2)+ 
		     h1->GetBinContent(j+3))>minContent){
		  found=kTRUE;
		  startBin=j;
		  break;
		}
	      }
	      if(!found) AliInfo(Form("WARNING!!! no start of fit found for histo # %i",ich));
	      // Now calculate the mean over the interval. 
	      Double_t mean = 0;
	      Double_t sumw2 = 0;
	      Double_t nent = 0;
	      for(Int_t k=0;k<fgkBinRangeAve;k++){
		mean=mean+h1->GetBinCenter(startBin+k)*h1->GetBinContent(startBin+k);                 
		nent=nent+h1->GetBinContent(startBin+k);                 
		sumw2=sumw2+(h1->GetBinCenter(startBin+k))*(h1->GetBinCenter(startBin+k))*(h1->GetBinContent(startBin+k));
	      }
	      mean= mean/nent; //<x>
	      sumw2=sumw2/nent; //<x^2>
	      Double_t rmsmean= 0;
	      rmsmean = TMath::Sqrt((sumw2-mean*mean)/nent);
	      if (ich<npads) {
		AliTOFChannelOnline * ch = fCal->GetChannel(ich);
		ch->SetDelay(mean);
	      }
	    delete h1;
	    h1=0x0;
	    }
	  }
	  daqFile->Close();
	  delete daqFile;
	  AliCDBMetaData metaData;
	  metaData.SetBeamPeriod(0);
	  metaData.SetResponsible("Chiara Zampolli");
	  metaData.SetComment("This preprocessor fills an AliTOFCal object.");
	  resultDAQ = Store("Calib","OnlineDelay",fCal, &metaData);
          if(!resultDAQ){
	    Log("Some problems occurred while storing DAQ data processing results");
	    return 0;
	  }
	}
	else{
	  Log("The Cumulative data file from DAQ does not exist, TOF exiting from Shuttle"); 
          return 0;
	}
      }
    }
  else{
    Log("Problem: no list for Cumulative data file from DAQ was found, TOF exiting from Shuttle");
    return 0;
  }

  //  delete list;
  // list = 0;
  // delete listTot;
  // listTot = 0;
  daqFile=0;

  if(resultDCS ==2|| resultDAQ ==2) {
    result=2;
  }
  else{ 
    result=1;
  }

  return result;
}
Commit	Line	Data
c9fe8530	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, 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
	16	/*
	17	$Log$
9d883ed9	18	Revision 1.4 2006/12/19 08:53:27 arcelli
	19	Changed filenames types to TString + split file sources (C.Zampolli)
	20
9bc469d1	21	Revision 1.3 2006/12/18 18:16:53 arcelli
	22	Change in the format of the input data from DAQ FXS (C.Zampolli)
	23
56071a73	24	Revision 1.1 2006/10/26 09:09:29 arcelli
	25	prototype for the TOF Shuttle preprocessor (C.Zampolli)
	26
c9fe8530	27	*/
	28
	29	#include "AliTOFPreprocessor.h"
	30
	31	#include "AliCDBMetaData.h"
	32	#include "AliLog.h"
	33	#include "AliTOFDataDCS.h"
	34	#include "TFile.h"
	35	#include "TObjArray.h"
	36	#include "TObjString.h"
	37	#include "AliTOFCalOnline.h"
	38	#include "AliTOFChannelOnline.h"
	39	#include "AliTOFGeometryV5.h"
	40	#include "TTimeStamp.h"
	41	#include "TH1F.h"
708db10b	42	#include "TH2S.h"
	43	#include "TH1S.h"
	44	#include "TH1.h"
	45	#include <Riostream.h>
	46	#include <stdio.h>
	47	#include <stdlib.h>
c9fe8530	48
	49	class TF1;
	50	class AliDCSValue;
	51	class AliTOFGeometry;
	52
	53	// TOF preprocessor class.
	54	// It takes data from DCS and passes them to the class AliTOFDataDCS, which
	55	// processes them. The result is then written to the CDB.
	56	// analogously, it takes data form DAQ (both at Run level and inclusive -
	57	// of all the runs - level, processes them, and stores both Reference Data
	58	// and Online Calibration files in the CDB.
	59
	60
	61	ClassImp(AliTOFPreprocessor)
	62
	63	const Int_t AliTOFPreprocessor::fgkBinRangeAve = 13; // number of bins where to calculate the mean
9d883ed9	64	const Double_t AliTOFPreprocessor::fgkThrPar = 0.013; // parameter used to trigger the calculation of the delay
c9fe8530	65
	66	//_____________________________________________________________________________
	67
708db10b	68	AliTOFPreprocessor::AliTOFPreprocessor(AliShuttleInterface* shuttle) :
708db10b	69	AliPreprocessor("TOF", shuttle),
c9fe8530	70	fData(0),
708db10b	71	fh2(0),
c9fe8530	72	fCal(0),
	73	fTOFGeometry(0)
	74	{
	75	// constructor
	76	}
	77
	78	//_____________________________________________________________________________
	79
	80	AliTOFPreprocessor::~AliTOFPreprocessor()
	81	{
	82	// destructor
9d883ed9	83	delete fData;
	84	fData = 0;
	85	delete fh2;
	86	fh2 = 0;
	87	delete fCal;
	88	fCal = 0;
	89	delete fTOFGeometry;
	90	fTOFGeometry = 0;
c9fe8530	91	}
	92
	93	//______________________________________________________________________________
	94	void AliTOFPreprocessor::Initialize(Int_t run, UInt_t startTime,
	95	UInt_t endTime)
	96	{
	97	// Creates AliTOFDataDCS object
	98
	99	AliPreprocessor::Initialize(run, startTime, endTime);
	100
	101	AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s", run,
	102	TTimeStamp(startTime).AsString(),
	103	TTimeStamp(endTime).AsString()));
	104
	105	fData = new AliTOFDataDCS(fRun, fStartTime, fEndTime);
708db10b	106	fh2 = 0x0;
c9fe8530	107	fTOFGeometry = new AliTOFGeometryV5();
	108	fCal = new AliTOFCalOnline(fTOFGeometry);
	109	fCal->CreateArray();
	110	}
	111
	112	//_____________________________________________________________________________
	113
	114	UInt_t AliTOFPreprocessor::Process(TMap* dcsAliasMap)
	115	{
	116	// Fills data into a AliTOFDataDCS object
	117
708db10b	118	TH1::AddDirectory(0);
c9fe8530	119	UInt_t resultDCS=0;
	120	UInt_t resultDAQ=0;
	121	UInt_t resultDAQRef=0;
	122	UInt_t result=0;
	123
	124	// processing DCS
	125
	126	if (!dcsAliasMap){
9d883ed9	127	Log("No DCS map found");
c9fe8530	128	}
	129	else {
	130	// The processing of the DCS input data is forwarded to AliTOFDataDCS
	131	fData->ProcessData(*dcsAliasMap);
	132	AliCDBMetaData metaDataDCS;
	133	metaDataDCS.SetBeamPeriod(0);
	134	metaDataDCS.SetResponsible("Chiara Zampolli");
	135	metaDataDCS.SetComment("This preprocessor fills an AliTOFDataDCS object."); resultDCS = Store("Calib","DCSData",fData, &metaDataDCS);
9d883ed9	136	// result+=resultDCS;
c9fe8530	137	if (!resultDCS){
9d883ed9	138	Log("Some problems occurred while storing DCS data processing results");
9d883ed9	139	return 0;
c9fe8530	140	}
	141	}
	142
	143	// processing DAQ
	144
	145	TFile * daqFile=0x0;
9bc469d1	146
	147	//retrieving data at Run level
	148	TList* list = GetFileSources(kDAQ, "RUNLevel");
c9fe8530	149	if (list)
c9fe8530	150	{
9bc469d1	151	AliInfo("The following sources produced files with the id RUNLevel");
c9fe8530	152	list->Print();
	153	for (Int_t jj=0;jj<list->GetEntries();jj++){
	154	TObjString * str = dynamic_cast<TObjString*> (list->At(jj));
	155	AliInfo(Form("found source %s", str->String().Data()));
	156	// file to be stored run per run
9bc469d1	157	TString fileNameRun = GetFile(kDAQ, "RUNLevel", str->GetName());
	158	if (fileNameRun.Length()>0){
	159	AliInfo(Form("Got the file %s, now we can store the Reference Data for the current Run.", fileNameRun.Data()));
	160	daqFile = new TFile(fileNameRun.Data(),"READ");
708db10b	161	fh2 = (TH2S*) daqFile->Get("htof");
c9fe8530	162	AliCDBMetaData metaDataHisto;
	163	metaDataHisto.SetBeamPeriod(0);
	164	metaDataHisto.SetResponsible("Chiara Zampolli");
	165	metaDataHisto.SetComment("This preprocessor stores the array of histos object as Reference Data.");
708db10b	166	resultDAQRef = StoreReferenceData("Calib","DAQData",fh2, &metaDataHisto);
9d883ed9	167	// result+=resultDAQRef*2;
c9fe8530	168	if (!resultDAQRef){
9d883ed9	169	Log("some problems occurred::No Reference Data stored, still going on (please check!)");
c9fe8530	170	}
	171	daqFile->Close();
	172	delete daqFile;
	173	}
	174
	175	else{
9d883ed9	176	Log("The input data file from DAQ (run-level) was not found, still going on with Cumulative data file (please check!) ");
9d883ed9	177	}
9bc469d1	178	}
	179	}
	180	else{
9d883ed9	181	Log("The input data file list from DAQ (run-level) was not found, still going on with Cumulative data file (please check!) ");
9bc469d1	182	}
	183
	184	//Total files, with summed histos
	185
	186	TList* listTot = GetFileSources(kDAQ, "DELAYS");
	187	if (listTot)
	188	{
	189	AliInfo("The following sources produced files with the id DELAYS");
	190	listTot->Print();
	191	for (Int_t jj=0;jj<listTot->GetEntries();jj++){
	192	TObjString * str = dynamic_cast<TObjString*> (listTot->At(jj));
	193	AliInfo(Form("found source %s", str->String().Data()));
	194
c9fe8530	195	// file with summed histos, to extract calib params
9bc469d1	196	TString fileName = GetFile(kDAQ, "DELAYS", str->GetName());
	197	if (fileName.Length()>0){
	198	AliInfo(Form("Got the file %s, now we can extract some values.", fileName.Data()));
c9fe8530	199
9bc469d1	200	daqFile = new TFile(fileName.Data(),"READ");
708db10b	201	fh2 = (TH2S*) daqFile->Get("htoftot");
708db10b	202	if (!fh2){
9d883ed9	203	Log("some problems occurred:: No histo retrieved, TOF exiting from Shuttle");
	204	delete daqFile;
	205	return 0;
c9fe8530	206	}
c9fe8530	207	else {
708db10b	208	static const Int_t size=fh2->GetNbinsX();
	209	static const Int_t nbins=fh2->GetNbinsY();
	210	static const Double_t xbinmin=fh2->GetYaxis()->GetBinLowEdge(1);
c9fe8530	211	Int_t npads = fCal->NPads();
9bc469d1	212	if (size != npads){
9d883ed9	213	Log(" number of bins along x different from number of pads, found only a subset of the histograms, TOF exiting from Shuttle");
	214	delete daqFile;
	215	return 0;
9bc469d1	216	}
708db10b	217	for (Int_t ich=0;ich<size;ich++){
	218	TH1S h1 = new TH1S("h1","h1",nbins,xbinmin-0.5,nbins1.+xbinmin-0.5);
	219	for (Int_t ibin=0;ibin<nbins;ibin++){
	220	h1->SetBinContent(ibin+1,fh2->GetBinContent(ich+1,ibin+1));
	221	}
c9fe8530	222	Bool_t found=kFALSE;
9bc469d1	223	Float_t minContent=h1->Integral()*fgkThrPar;
c9fe8530	224	Int_t nbinsX = h1->GetNbinsX();
	225	Int_t startBin=1;
	226	for (Int_t j=1; j<=nbinsX; j++){
	227	if ((
	228	h1->GetBinContent(j) +
	229	h1->GetBinContent(j+1)+
	230	h1->GetBinContent(j+2)+
	231	h1->GetBinContent(j+3))>minContent){
	232	found=kTRUE;
	233	startBin=j;
	234	break;
	235	}
	236	}
708db10b	237	if(!found) AliInfo(Form("WARNING!!! no start of fit found for histo # %i",ich));
c9fe8530	238	// Now calculate the mean over the interval.
	239	Double_t mean = 0;
	240	Double_t sumw2 = 0;
	241	Double_t nent = 0;
	242	for(Int_t k=0;k<fgkBinRangeAve;k++){
	243	mean=mean+h1->GetBinCenter(startBin+k)*h1->GetBinContent(startBin+k);
	244	nent=nent+h1->GetBinContent(startBin+k);
	245	sumw2=sumw2+(h1->GetBinCenter(startBin+k))(h1->GetBinCenter(startBin+k))(h1->GetBinContent(startBin+k));
	246	}
c9fe8530	247	mean= mean/nent; //<x>
	248	sumw2=sumw2/nent; //<x^2>
	249	Double_t rmsmean= 0;
	250	rmsmean = TMath::Sqrt((sumw2-mean*mean)/nent);
708db10b	251	if (ich<npads) {
708db10b	252	AliTOFChannelOnline * ch = fCal->GetChannel(ich);
c9fe8530	253	ch->SetDelay(mean);
c9fe8530	254	}
708db10b	255	delete h1;
708db10b	256	h1=0x0;
c9fe8530	257	}
c9fe8530	258	}
	259	daqFile->Close();
	260	delete daqFile;
	261	AliCDBMetaData metaData;
	262	metaData.SetBeamPeriod(0);
	263	metaData.SetResponsible("Chiara Zampolli");
	264	metaData.SetComment("This preprocessor fills an AliTOFCal object.");
	265	resultDAQ = Store("Calib","OnlineDelay",fCal, &metaData);
9d883ed9	266	if(!resultDAQ){
	267	Log("Some problems occurred while storing DAQ data processing results");
	268	return 0;
	269	}
c9fe8530	270	}
c9fe8530	271	else{
9d883ed9	272	Log("The Cumulative data file from DAQ does not exist, TOF exiting from Shuttle");
9d883ed9	273	return 0;
c9fe8530	274	}
	275	}
	276	}
	277	else{
9d883ed9	278	Log("Problem: no list for Cumulative data file from DAQ was found, TOF exiting from Shuttle");
708db10b	279	return 0;
c9fe8530	280	}
c9fe8530	281
9d883ed9	282	// delete list;
	283	// list = 0;
	284	// delete listTot;
	285	// listTot = 0;
c9fe8530	286	daqFile=0;
9d883ed9	287
	288	if(resultDCS ==2\|\| resultDAQ ==2) {
	289	result=2;
	290	}
	291	else{
	292	result=1;
	293	}
	294
c9fe8530	295	return result;
	296	}
	297
	298