[u/mrichter/AliRoot.git] / FMD / AliFMDBaseDA.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.                  *
 **************************************************************************/

/** @file    AliFMDBaseDA.cxx
    @author  Hans Hjersing Dalsgaard <canute@nbi.dk>
    @date    Wed Mar 26 11:30:45 2008
    @brief   Base class for detector algorithms.
*/
//
// This is the implementation of the (virtual) base class for the FMD
// detector algorithms(DA). It implements the creation of the relevant
// containers and handles the loop over the raw data. The derived
// classes can control the parameters and action to be taken making
// this the base class for the Pedestal, Gain and Physics DA.
//

#include "AliFMDBaseDA.h"
#include "iostream"
#include "AliFMDRawReader.h"
#include "AliFMDCalibSampleRate.h"
#include "AliFMDCalibStripRange.h"
#include "AliLog.h"
#include "AliRawEventHeaderBase.h"
#include <TDatime.h>
#include <TSystem.h>
#include <TH2F.h>

//_____________________________________________________________________
ClassImp(AliFMDBaseDA)
#if 0 
; // Do not delete  - to let Emacs for mat the code
#endif

//_____________________________________________________________________
const char*
AliFMDBaseDA::GetStripPath(UShort_t det, 
			   Char_t   ring, 
			   UShort_t sec, 
			   UShort_t str, 
			   Bool_t   full) const
{
  // Get the strip path 
  // 
  // Parameters 
  //     det      Detector number
  //     ring     Ring identifier 
  //     sec      Sector number 
  //     str      Strip number
  //     full     If true, return full path 
  // 
  // Return 
  //     The path
  return Form("%s%sFMD%d%c[%02d,%03d]", 
	      (full ? GetSectorPath(det, ring, sec, full) : ""), 
	      (full ? "/" : ""), det, ring, sec, str);
}
//_____________________________________________________________________
const char*
AliFMDBaseDA::GetSectorPath(UShort_t det, 
			    Char_t   ring, 
			    UShort_t sec, 
			    Bool_t   full) const
{
  // Get the strip path 
  // 
  // Parameters 
  //     det      Detector number
  //     ring     Ring identifier 
  //     sec      Sector number 
  //     str      Strip number
  //     full     If true, return full path 
  // 
  // Return 
  //     The path
  return Form("%s%sFMD%d%c[%02d]", 
	      (full ? GetRingPath(det, ring, full) : ""), 
	      (full ? "/" : ""), det, ring, sec);
}
//_____________________________________________________________________
const char*
AliFMDBaseDA::GetRingPath(UShort_t det, 
			  Char_t   ring, 
			  Bool_t   full) const
{
  // Get the strip path 
  // 
  // Parameters 
  //     det      Detector number
  //     ring     Ring identifier 
  //     sec      Sector number 
  //     str      Strip number
  //     full     If true, return full path 
  // 
  // Return 
  //     The path
  return Form("%s%sFMD%d%c", 
	      (full ? GetDetectorPath(det, full) : ""), 
	      (full ? "/" : ""), det, ring);
}
//_____________________________________________________________________
const char*
AliFMDBaseDA::GetDetectorPath(UShort_t det, 
			      Bool_t   full) const
{
  // Get the strip path 
  // 
  // Parameters 
  //     det      Detector number
  //     ring     Ring identifier 
  //     sec      Sector number 
  //     str      Strip number
  //     full     If true, return full path 
  // 
  // Return 
  //     The path
  return Form("%s%sFMD%d", 
	      (full ? fDiagnosticsFilename.Data() : ""), 
	      (full ? ":/" : ""), det);
}

//_____________________________________________________________________
AliFMDBaseDA::AliFMDBaseDA() : 
  TNamed(),
  fDiagnosticsFilename("diagnosticsHistograms.root"),
  fOutputFile(),
  fConditionsFile(),
  fSaveHistograms(kFALSE),
  fMakeSummaries(kFALSE),
  fDetectorArray(),
  fPulseSize(10),
  fPulseLength(10),
  fRequiredEvents(0),
  fCurrentEvent(0), 
  fRunno(0),
  fSummaries(0)
{
  //Constructor
  fSeenDetectors[0] = fSeenDetectors[1] = fSeenDetectors[2] = kFALSE;
  fDetectorArray.SetOwner();
  Rotate("conditions.csv", 3);
  fConditionsFile.open("conditions.csv");
}
//_____________________________________________________________________
AliFMDBaseDA::AliFMDBaseDA(const AliFMDBaseDA & baseDA) : 
  TNamed(baseDA),
  fDiagnosticsFilename(baseDA.fDiagnosticsFilename.Data()),
  fOutputFile(),
  fConditionsFile(),
  fSaveHistograms(baseDA.fSaveHistograms),
  fMakeSummaries(baseDA.fMakeSummaries),
  fDetectorArray(baseDA.fDetectorArray),
  fPulseSize(baseDA.fPulseSize),
  fPulseLength(baseDA.fPulseLength),
  fRequiredEvents(baseDA.fRequiredEvents),
  fCurrentEvent(baseDA.fCurrentEvent),
  fRunno(baseDA.fRunno),
  fSummaries(0)
{
  //Copy constructor
  fSeenDetectors[0] = baseDA.fSeenDetectors[0];
  fSeenDetectors[1] = baseDA.fSeenDetectors[1];
  fSeenDetectors[2] = baseDA.fSeenDetectors[2];

  fDetectorArray.SetOwner();
  
}


//_____________________________________________________________________
AliFMDBaseDA::~AliFMDBaseDA() 
{
  //destructor
}

//_____________________________________________________________________
void AliFMDBaseDA::Run(AliRawReader* reader) 
{
  //Run the FMD DA
  TFile* diagFile = 0;
  if (fSaveHistograms)
    diagFile = TFile::Open(fDiagnosticsFilename.Data(),"RECREATE");

  
  reader->Reset();
  fRunno = reader->GetRunNumber();

  AliFMDRawReader* fmdReader  = new AliFMDRawReader(reader,0);
  TClonesArray*    digitArray = new TClonesArray("AliFMDDigit",0);
  
  Bool_t sodread = kFALSE;
  
  for(Int_t i=0;i<3;i++) {
    if (reader->NextEvent()) { 
      // Read Start-of-Run / Start-of-Files event
      AliWarning(Form("Failed to read the %d%s event",
		      i+1, (i == 0 ? "st" : (i == 1 ? "nd" : "rd"))));
      break;
    }
    
    UInt_t eventType = reader->GetType();
    if(eventType == AliRawEventHeaderBase::kStartOfData || 
       eventType == AliRawEventHeaderBase::kFormatError) { 
      
      WriteConditionsData(fmdReader);
      Init();
      sodread = kTRUE;
      break;
    }
  }
  
  InitContainer(diagFile);
  
  if(!sodread) 
    AliWarning("No SOD event detected!");
  
  int lastProgress = 0;
  
  
  for(Int_t n =1;n <= GetRequiredEvents(); n++) {
    if(!reader->NextEvent()) continue;
    SetCurrentEvent(n);
    digitArray->Clear();
    fmdReader->ReadAdcs(digitArray);
    
    for(Int_t i = 0; i<digitArray->GetEntriesFast();i++) {
      AliFMDDigit* digit = static_cast<AliFMDDigit*>(digitArray->At(i));
      fSeenDetectors[digit->Detector()-1] = kTRUE;
      FillChannels(digit);
    }
    
   
    FinishEvent();
    
    int progress = int((n *100)/ GetRequiredEvents()) ;
    if (progress <= lastProgress) continue;
    lastProgress = progress;
    std::cout << "Progress: " << lastProgress << " / 100 " << std::endl;
    
  }
  
  AliInfo(Form("Looped over %d events",GetCurrentEvent()));
  WriteHeaderToFile();
  
  for(UShort_t det=1;det<=3;det++) {
    if (!fSeenDetectors[det-1]) continue;
    std::cout << "FMD" << det << std::endl;
    UShort_t firstRing = (det == 1 ? 1 : 0);
    for (UShort_t ir = firstRing; ir < 2; ir++) {
      Char_t   ring = (ir == 0 ? 'O' : 'I');
      UShort_t nsec = (ir == 0 ? 40  : 20);
      UShort_t nstr = (ir == 0 ? 256 : 512);

      if (fMakeSummaries) MakeSummary(det, ring);

      std::cout << " Ring " << ring << ": " << std::flush;
      for(UShort_t sec =0; sec < nsec;  sec++)  {
  	for(UShort_t strip = 0; strip < nstr; strip++) {
	  Analyse(det,ring,sec,strip);
  	}
	std::cout << '.' << std::flush;
      }
      if(fSaveHistograms)
      	diagFile->Flush();
      std::cout << "done" << std::endl;
    }
  }
  
  if(fOutputFile.is_open()) {
    fOutputFile.write("# EOF\n",6);
    fOutputFile.close();
  }
  
  Terminate(diagFile);
    
  if(fSaveHistograms ) {
    
    AliInfo("Closing diagnostics file - please wait ...");
    // diagFile->Write();
    diagFile->Close();
    AliInfo("done");
    
  }
}
//_____________________________________________________________________

void AliFMDBaseDA::InitContainer(TDirectory* diagFile)
{
  //Prepare container for diagnostics
  TObjArray* detArray;
  TObjArray* ringArray;
  TObjArray* sectorArray;
    
  TDirectory* savDir   = gDirectory;

  for(UShort_t det=1;det<=3;det++) {
    detArray = new TObjArray();
    detArray->SetOwner();
    fDetectorArray.AddAtAndExpand(detArray,det);

    TDirectory* detDir = 0;
    if (diagFile) {
      diagFile->cd();
      detDir = diagFile->mkdir(GetDetectorPath(det, kFALSE));
    }

    UShort_t FirstRing = (det == 1 ? 1 : 0);
    for (UShort_t ir = FirstRing; ir < 2; ir++) {
      Char_t   ring = (ir == 0 ? 'O' : 'I');
      UShort_t nsec = (ir == 0 ? 40  : 20);
      UShort_t nstr = (ir == 0 ? 256 : 512);
      ringArray = new TObjArray();
      ringArray->SetOwner();
      detArray->AddAtAndExpand(ringArray,ir);


      TDirectory* ringDir = 0;
      if (detDir) { 
	detDir->cd();
	ringDir = detDir->mkdir(GetRingPath(det,ring, kFALSE));
      }
      

      for(UShort_t sec =0; sec < nsec;  sec++)  {
	sectorArray = new TObjArray();
	sectorArray->SetOwner();
	ringArray->AddAtAndExpand(sectorArray,sec);


	TDirectory* secDir = 0;
	if (ringDir) { 
	  ringDir->cd();
	  secDir = ringDir->mkdir(GetSectorPath(det, ring, sec, kFALSE));
	}
	
	for(UShort_t strip = 0; strip < nstr; strip++) {
	  if (secDir) { 
	    secDir->cd();
	    secDir->mkdir(GetStripPath(det, ring, sec, strip, kFALSE));
	  }
	  AddChannelContainer(sectorArray, det, ring, sec, strip);
	}
      }
    }
  }
  savDir->cd();
}

//_____________________________________________________________________ 
void AliFMDBaseDA::WriteConditionsData(AliFMDRawReader* fmdReader) 
{
  //Write the conditions data to file
  AliFMDParameters* pars       = AliFMDParameters::Instance();
  fConditionsFile.write(Form("# %s \n",pars->GetConditionsShuttleID()),14);
  TDatime now;
  fConditionsFile << "# This file created from run number " << fRunno 
		  << " at " << now.AsString() << std::endl;
  
  AliFMDCalibSampleRate* sampleRate = new AliFMDCalibSampleRate();
  AliFMDCalibStripRange* stripRange = new AliFMDCalibStripRange();
  
  fmdReader->ReadSODevent(sampleRate,stripRange,fPulseSize,fPulseLength,
			  fSeenDetectors);

  sampleRate->WriteToFile(fConditionsFile, fSeenDetectors);
  stripRange->WriteToFile(fConditionsFile, fSeenDetectors);

 
  // Zero Suppresion
  
  // Strip Range
  
  fConditionsFile.write("# Gain Events \n",15);
  
  for(UShort_t det=1; det<=3;det++) {
    if (!fSeenDetectors[det-1]) { 
      continue;
    }
    UShort_t firstring = (det == 1 ? 1 : 0);
    for(UShort_t iring = firstring; iring <=1;iring++) {
      Char_t ring = (iring == 1 ? 'I' : 'O');
      for(UShort_t board =0 ; board <=1; board++) {
	
	Int_t idx = GetHalfringIndex(det,ring,board);
	
	fConditionsFile << det                     << ','
			<< ring                    << ','
			<< board                   << ','
			<< fPulseLength.At(idx)    << "\n";
	
      }
    }
  }
  
  fConditionsFile.write("# Gain Pulse \n",14);
  
  for(UShort_t det=1; det<=3;det++) {
    if (!fSeenDetectors[det-1]) { 
      continue;
    }
    UShort_t firstring = (det == 1 ? 1 : 0);
    for(UShort_t iring = firstring; iring <=1;iring++) {
      Char_t ring = (iring == 1 ? 'I' : 'O');
      for(UShort_t board =0 ; board <=1; board++) {
	
	Int_t idx = GetHalfringIndex(det,ring,board);
	
	fConditionsFile << det                     << ','
			<< ring                    << ','
			<< board                   << ','
			<< fPulseSize.At(idx)      << "\n";
	
      }
    }
  }
  // sampleRate->WriteToFile(std::cout, fSeenDetectors);
  // stripRange->WriteToFile(std::cout, fSeenDetectors);

  if(fConditionsFile.is_open()) {
    
    fConditionsFile.write("# EOF\n",6);
    fConditionsFile.close();
    
  }
  
}
//_____________________________________________________________________ 
Int_t AliFMDBaseDA::GetHalfringIndex(UShort_t det, Char_t ring, 
				     UShort_t board) const 
{
  // Get the index corresponding to a half-ring 
  // 
  // Parameters: 
  //   det    Detector number 
  //   ring   Ring identifier 
  //   board  Board number 
  //
  // Return 
  //   Internal index of the board 
  UShort_t iring  =  (ring == 'I' ? 1 : 0);
  
  Int_t index = (((det-1) << 2) | (iring << 1) | (board << 0));
  
  return index-2;
  
}
//_____________________________________________________________________ 
void AliFMDBaseDA::Rotate(const char* base, int max) const
{
  // 
  // Rotate a set of files.   base is the basic name of the files.
  // If the file base.max exists it is removed. 
  // If the file base.n exists (where n < max) it is renamed to
  // base.(n-1).  
  // If the file base exists, it is renamed to base.1 
  //
  // Parameters:
  //   base Base name of the files
  //   max  Maximum number to keep (minus one for the current).

  // Note:  TSystem::AccessPathName returns false if the condition is
  // fulfilled! 

  // Check if we have base.max, and if so, remove it. 
  TString testName(Form("%s.%d", base, max));
  if (!gSystem->AccessPathName(testName.Data())) 
    gSystem->Unlink(testName.Data());
    
  // Loop down from max-1 to 1 and move files 
  for (int i = max-1; i >= 1; i--) { 
    testName = Form("%s.%d", base, i);
    if (!gSystem->AccessPathName(testName.Data())) {
      TString newName(Form("%s.%d", base, i+1));
      gSystem->Rename(testName.Data(), newName.Data());
    }
  }

  // If we have the file base, rename it to base.1 
  testName = Form("%s", base);
  if (!gSystem->AccessPathName(testName.Data())){
    TString newName(Form("%s.%d", base, 1));
    gSystem->Rename(testName.Data(), newName.Data());
  }
}

//_____________________________________________________________________ 
TH2*
AliFMDBaseDA::MakeSummaryHistogram(const char* prefix, const char* title, 
				   UShort_t d, Char_t r) 
{
  Int_t nX = ((d == 1 || r == 'I' || r == 'i') ?  20 :  40);
  Int_t nY = ((d == 1 || r == 'I' || r == 'i') ? 512 : 256);
  
  TH2* ret = new TH2F(Form("%sFMD%d%c", prefix, d, r), 
		      Form("%s for FMD%d%c", title, d, r), 
		      nX, -0.5, nX-0.5, nY, -0.5, nY-0.5);
  ret->SetXTitle("Sector #");
  ret->SetYTitle("Strip #");

  // if (!fSummaries) fSummaries = new TObjArray;
  fSummaries.Add(ret);
  return ret;
}

//_____________________________________________________________________ 
//
// EOF
//
Commit	Line	Data
a0180e76	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
	16	/** @file AliFMDBaseDA.cxx
	17	@author Hans Hjersing Dalsgaard <canute@nbi.dk>
	18	@date Wed Mar 26 11:30:45 2008
	19	@brief Base class for detector algorithms.
	20	*/
	21	//
e9c06036	22	// This is the implementation of the (virtual) base class for the FMD
	23	// detector algorithms(DA). It implements the creation of the relevant
	24	// containers and handles the loop over the raw data. The derived
	25	// classes can control the parameters and action to be taken making
	26	// this the base class for the Pedestal, Gain and Physics DA.
a0180e76	27	//
	28
	29	#include "AliFMDBaseDA.h"
	30	#include "iostream"
a0180e76	31	#include "AliFMDRawReader.h"
1656783c	32	#include "AliFMDCalibSampleRate.h"
bd727bee	33	#include "AliFMDCalibStripRange.h"
a0180e76	34	#include "AliLog.h"
3effc6e7	35	#include "AliRawEventHeaderBase.h"
6cf6e7a0	36	#include <TDatime.h>
6cf6e7a0	37	#include <TSystem.h>
2a082c96	38	#include <TH2F.h>
3effc6e7	39
a0180e76	40	//_____________________________________________________________________
a0180e76	41	ClassImp(AliFMDBaseDA)
e9c06036	42	#if 0
	43	; // Do not delete - to let Emacs for mat the code
	44	#endif
	45
	46	//_____________________________________________________________________
	47	const char*
	48	AliFMDBaseDA::GetStripPath(UShort_t det,
	49	Char_t ring,
	50	UShort_t sec,
	51	UShort_t str,
	52	Bool_t full) const
	53	{
6cf6e7a0	54	// Get the strip path
	55	//
	56	// Parameters
	57	// det Detector number
	58	// ring Ring identifier
	59	// sec Sector number
	60	// str Strip number
	61	// full If true, return full path
	62	//
	63	// Return
	64	// The path
e9c06036	65	return Form("%s%sFMD%d%c[%02d,%03d]",
	66	(full ? GetSectorPath(det, ring, sec, full) : ""),
	67	(full ? "/" : ""), det, ring, sec, str);
	68	}
	69	//_____________________________________________________________________
	70	const char*
	71	AliFMDBaseDA::GetSectorPath(UShort_t det,
	72	Char_t ring,
	73	UShort_t sec,
	74	Bool_t full) const
	75	{
6cf6e7a0	76	// Get the strip path
	77	//
	78	// Parameters
	79	// det Detector number
	80	// ring Ring identifier
	81	// sec Sector number
	82	// str Strip number
	83	// full If true, return full path
	84	//
	85	// Return
	86	// The path
e9c06036	87	return Form("%s%sFMD%d%c[%02d]",
	88	(full ? GetRingPath(det, ring, full) : ""),
	89	(full ? "/" : ""), det, ring, sec);
	90	}
	91	//_____________________________________________________________________
	92	const char*
	93	AliFMDBaseDA::GetRingPath(UShort_t det,
	94	Char_t ring,
	95	Bool_t full) const
	96	{
6cf6e7a0	97	// Get the strip path
	98	//
	99	// Parameters
	100	// det Detector number
	101	// ring Ring identifier
	102	// sec Sector number
	103	// str Strip number
	104	// full If true, return full path
	105	//
	106	// Return
	107	// The path
e9c06036	108	return Form("%s%sFMD%d%c",
	109	(full ? GetDetectorPath(det, full) : ""),
	110	(full ? "/" : ""), det, ring);
	111	}
	112	//_____________________________________________________________________
	113	const char*
	114	AliFMDBaseDA::GetDetectorPath(UShort_t det,
	115	Bool_t full) const
	116	{
6cf6e7a0	117	// Get the strip path
	118	//
	119	// Parameters
	120	// det Detector number
	121	// ring Ring identifier
	122	// sec Sector number
	123	// str Strip number
	124	// full If true, return full path
	125	//
	126	// Return
	127	// The path
e9c06036	128	return Form("%s%sFMD%d",
	129	(full ? fDiagnosticsFilename.Data() : ""),
	130	(full ? ":/" : ""), det);
	131	}
a0180e76	132
a0180e76	133	//_____________________________________________________________________
427e8f99	134	AliFMDBaseDA::AliFMDBaseDA() :
427e8f99	135	TNamed(),
a0180e76	136	fDiagnosticsFilename("diagnosticsHistograms.root"),
a0180e76	137	fOutputFile(),
ce5a8b1a	138	fConditionsFile(),
a0180e76	139	fSaveHistograms(kFALSE),
2a082c96	140	fMakeSummaries(kFALSE),
a0180e76	141	fDetectorArray(),
29b7c86f	142	fPulseSize(10),
	143	fPulseLength(10),
	144	fRequiredEvents(0),
6cf6e7a0	145	fCurrentEvent(0),
2a082c96	146	fRunno(0),
2a082c96	147	fSummaries(0)
c5569fbc	148	{
c5569fbc	149	//Constructor
6cf6e7a0	150	fSeenDetectors[0] = fSeenDetectors[1] = fSeenDetectors[2] = kFALSE;
a0180e76	151	fDetectorArray.SetOwner();
6cf6e7a0	152	Rotate("conditions.csv", 3);
ce5a8b1a	153	fConditionsFile.open("conditions.csv");
a0180e76	154	}
	155	//_____________________________________________________________________
	156	AliFMDBaseDA::AliFMDBaseDA(const AliFMDBaseDA & baseDA) :
	157	TNamed(baseDA),
a7e41e8d	158	fDiagnosticsFilename(baseDA.fDiagnosticsFilename.Data()),
a0180e76	159	fOutputFile(),
ce5a8b1a	160	fConditionsFile(),
a0180e76	161	fSaveHistograms(baseDA.fSaveHistograms),
2a082c96	162	fMakeSummaries(baseDA.fMakeSummaries),
a0180e76	163	fDetectorArray(baseDA.fDetectorArray),
427e8f99	164	fPulseSize(baseDA.fPulseSize),
427e8f99	165	fPulseLength(baseDA.fPulseLength),
a0180e76	166	fRequiredEvents(baseDA.fRequiredEvents),
6cf6e7a0	167	fCurrentEvent(baseDA.fCurrentEvent),
2a082c96	168	fRunno(baseDA.fRunno),
2a082c96	169	fSummaries(0)
a0180e76	170	{
c5569fbc	171	//Copy constructor
408bf2b4	172	fSeenDetectors[0] = baseDA.fSeenDetectors[0];
	173	fSeenDetectors[1] = baseDA.fSeenDetectors[1];
	174	fSeenDetectors[2] = baseDA.fSeenDetectors[2];
	175
a0180e76	176	fDetectorArray.SetOwner();
	177
	178	}
	179
82d71828	180
a0180e76	181	//_____________________________________________________________________
e9c06036	182	AliFMDBaseDA::~AliFMDBaseDA()
e9c06036	183	{
a0180e76	184	//destructor
a0180e76	185	}
	186
	187	//_____________________________________________________________________
e9c06036	188	void AliFMDBaseDA::Run(AliRawReader* reader)
e9c06036	189	{
c5569fbc	190	//Run the FMD DA
e9c06036	191	TFile* diagFile = 0;
	192	if (fSaveHistograms)
	193	diagFile = TFile::Open(fDiagnosticsFilename.Data(),"RECREATE");
a0180e76	194
427e8f99	195
3effc6e7	196
427e8f99	197
7bce699b	198
a0180e76	199	reader->Reset();
6cf6e7a0	200	fRunno = reader->GetRunNumber();
6cf6e7a0	201
e9c06036	202	AliFMDRawReader* fmdReader = new AliFMDRawReader(reader,0);
e9c06036	203	TClonesArray* digitArray = new TClonesArray("AliFMDDigit",0);
3effc6e7	204
c5569fbc	205	Bool_t sodread = kFALSE;
200d06f9	206
200d06f9	207	for(Int_t i=0;i<3;i++) {
133f1578	208	if (reader->NextEvent()) {
	209	// Read Start-of-Run / Start-of-Files event
	210	AliWarning(Form("Failed to read the %d%s event",
	211	i+1, (i == 0 ? "st" : (i == 1 ? "nd" : "rd"))));
	212	break;
	213	}
29b7c86f	214
200d06f9	215	UInt_t eventType = reader->GetType();
	216	if(eventType == AliRawEventHeaderBase::kStartOfData \|\|
	217	eventType == AliRawEventHeaderBase::kFormatError) {
	218
	219	WriteConditionsData(fmdReader);
	220	Init();
c5569fbc	221	sodread = kTRUE;
200d06f9	222	break;
200d06f9	223	}
29b7c86f	224	}
200d06f9	225
7bce699b	226	InitContainer(diagFile);
7bce699b	227
c5569fbc	228	if(!sodread)
29b7c86f	229	AliWarning("No SOD event detected!");
3effc6e7	230
1656783c	231	int lastProgress = 0;
a0180e76	232
7bce699b	233
7bce699b	234
e9c06036	235	for(Int_t n =1;n <= GetRequiredEvents(); n++) {
e9c06036	236	if(!reader->NextEvent()) continue;
3effc6e7	237	SetCurrentEvent(n);
e9c06036	238	digitArray->Clear();
e9c06036	239	fmdReader->ReadAdcs(digitArray);
7bce699b	240
e9c06036	241	for(Int_t i = 0; i<digitArray->GetEntriesFast();i++) {
e9c06036	242	AliFMDDigit* digit = static_cast<AliFMDDigit*>(digitArray->At(i));
408bf2b4	243	fSeenDetectors[digit->Detector()-1] = kTRUE;
e9c06036	244	FillChannels(digit);
a0180e76	245	}
e9c06036	246
7bce699b	247
e9c06036	248	FinishEvent();
7bce699b	249
e9c06036	250	int progress = int((n *100)/ GetRequiredEvents()) ;
	251	if (progress <= lastProgress) continue;
	252	lastProgress = progress;
	253	std::cout << "Progress: " << lastProgress << " / 100 " << std::endl;
7bce699b	254
e9c06036	255	}
7bce699b	256
a0180e76	257	AliInfo(Form("Looped over %d events",GetCurrentEvent()));
	258	WriteHeaderToFile();
	259
	260	for(UShort_t det=1;det<=3;det++) {
408bf2b4	261	if (!fSeenDetectors[det-1]) continue;
e9c06036	262	std::cout << "FMD" << det << std::endl;
c5569fbc	263	UShort_t firstRing = (det == 1 ? 1 : 0);
c5569fbc	264	for (UShort_t ir = firstRing; ir < 2; ir++) {
a0180e76	265	Char_t ring = (ir == 0 ? 'O' : 'I');
	266	UShort_t nsec = (ir == 0 ? 40 : 20);
	267	UShort_t nstr = (ir == 0 ? 256 : 512);
2a082c96	268
	269	if (fMakeSummaries) MakeSummary(det, ring);
	270
e9c06036	271	std::cout << " Ring " << ring << ": " << std::flush;
a0180e76	272	for(UShort_t sec =0; sec < nsec; sec++) {
	273	for(UShort_t strip = 0; strip < nstr; strip++) {
	274	Analyse(det,ring,sec,strip);
a0180e76	275	}
e9c06036	276	std::cout << '.' << std::flush;
a0180e76	277	}
427e8f99	278	if(fSaveHistograms)
7bce699b	279	diagFile->Flush();
e9c06036	280	std::cout << "done" << std::endl;
a0180e76	281	}
a0180e76	282	}
7bce699b	283
a0180e76	284	if(fOutputFile.is_open()) {
a0180e76	285	fOutputFile.write("# EOF\n",6);
a0180e76	286	fOutputFile.close();
a0180e76	287	}
a0180e76	288
7bce699b	289	Terminate(diagFile);
7bce699b	290
a0180e76	291	if(fSaveHistograms ) {
f7f0b643	292
e9c06036	293	AliInfo("Closing diagnostics file - please wait ...");
e9c06036	294	// diagFile->Write();
ce5a8b1a	295	diagFile->Close();
e9c06036	296	AliInfo("done");
7bce699b	297
a0180e76	298	}
	299	}
	300	//_____________________________________________________________________
	301
e9c06036	302	void AliFMDBaseDA::InitContainer(TDirectory* diagFile)
e9c06036	303	{
c5569fbc	304	//Prepare container for diagnostics
a0180e76	305	TObjArray* detArray;
	306	TObjArray* ringArray;
	307	TObjArray* sectorArray;
	308
e9c06036	309	TDirectory* savDir = gDirectory;
e9c06036	310
a0180e76	311	for(UShort_t det=1;det<=3;det++) {
	312	detArray = new TObjArray();
	313	detArray->SetOwner();
	314	fDetectorArray.AddAtAndExpand(detArray,det);
e9c06036	315
	316	TDirectory* detDir = 0;
	317	if (diagFile) {
	318	diagFile->cd();
	319	detDir = diagFile->mkdir(GetDetectorPath(det, kFALSE));
	320	}
	321
a0180e76	322	UShort_t FirstRing = (det == 1 ? 1 : 0);
	323	for (UShort_t ir = FirstRing; ir < 2; ir++) {
	324	Char_t ring = (ir == 0 ? 'O' : 'I');
	325	UShort_t nsec = (ir == 0 ? 40 : 20);
	326	UShort_t nstr = (ir == 0 ? 256 : 512);
	327	ringArray = new TObjArray();
	328	ringArray->SetOwner();
	329	detArray->AddAtAndExpand(ringArray,ir);
e9c06036	330
	331
	332	TDirectory* ringDir = 0;
	333	if (detDir) {
	334	detDir->cd();
	335	ringDir = detDir->mkdir(GetRingPath(det,ring, kFALSE));
	336	}
	337
	338
a0180e76	339	for(UShort_t sec =0; sec < nsec; sec++) {
	340	sectorArray = new TObjArray();
	341	sectorArray->SetOwner();
	342	ringArray->AddAtAndExpand(sectorArray,sec);
e9c06036	343
	344
	345	TDirectory* secDir = 0;
	346	if (ringDir) {
	347	ringDir->cd();
	348	secDir = ringDir->mkdir(GetSectorPath(det, ring, sec, kFALSE));
	349	}
	350
a0180e76	351	for(UShort_t strip = 0; strip < nstr; strip++) {
e9c06036	352	if (secDir) {
	353	secDir->cd();
	354	secDir->mkdir(GetStripPath(det, ring, sec, strip, kFALSE));
	355	}
a0180e76	356	AddChannelContainer(sectorArray, det, ring, sec, strip);
	357	}
	358	}
	359	}
	360	}
e9c06036	361	savDir->cd();
a0180e76	362	}
ce5a8b1a	363
ce5a8b1a	364	//_____________________________________________________________________
3effc6e7	365	void AliFMDBaseDA::WriteConditionsData(AliFMDRawReader* fmdReader)
e9c06036	366	{
c5569fbc	367	//Write the conditions data to file
ce5a8b1a	368	AliFMDParameters* pars = AliFMDParameters::Instance();
ce5a8b1a	369	fConditionsFile.write(Form("# %s \n",pars->GetConditionsShuttleID()),14);
6cf6e7a0	370	TDatime now;
	371	fConditionsFile << "# This file created from run number " << fRunno
	372	<< " at " << now.AsString() << std::endl;
427e8f99	373
3effc6e7	374	AliFMDCalibSampleRate* sampleRate = new AliFMDCalibSampleRate();
3effc6e7	375	AliFMDCalibStripRange* stripRange = new AliFMDCalibStripRange();
427e8f99	376
408bf2b4	377	fmdReader->ReadSODevent(sampleRate,stripRange,fPulseSize,fPulseLength,
408bf2b4	378	fSeenDetectors);
bd727bee	379
408bf2b4	380	sampleRate->WriteToFile(fConditionsFile, fSeenDetectors);
408bf2b4	381	stripRange->WriteToFile(fConditionsFile, fSeenDetectors);
bd727bee	382
bd727bee	383
427e8f99	384	// Zero Suppresion
	385
	386	// Strip Range
	387
29b7c86f	388	fConditionsFile.write("# Gain Events \n",15);
bd727bee	389
29b7c86f	390	for(UShort_t det=1; det<=3;det++) {
408bf2b4	391	if (!fSeenDetectors[det-1]) {
	392	continue;
	393	}
29b7c86f	394	UShort_t firstring = (det == 1 ? 1 : 0);
	395	for(UShort_t iring = firstring; iring <=1;iring++) {
	396	Char_t ring = (iring == 1 ? 'I' : 'O');
	397	for(UShort_t board =0 ; board <=1; board++) {
	398
	399	Int_t idx = GetHalfringIndex(det,ring,board);
	400
	401	fConditionsFile << det << ','
	402	<< ring << ','
	403	<< board << ','
	404	<< fPulseLength.At(idx) << "\n";
	405
	406	}
	407	}
	408	}
bd727bee	409
29b7c86f	410	fConditionsFile.write("# Gain Pulse \n",14);
bd727bee	411
29b7c86f	412	for(UShort_t det=1; det<=3;det++) {
408bf2b4	413	if (!fSeenDetectors[det-1]) {
	414	continue;
	415	}
29b7c86f	416	UShort_t firstring = (det == 1 ? 1 : 0);
	417	for(UShort_t iring = firstring; iring <=1;iring++) {
	418	Char_t ring = (iring == 1 ? 'I' : 'O');
	419	for(UShort_t board =0 ; board <=1; board++) {
	420
	421	Int_t idx = GetHalfringIndex(det,ring,board);
	422
	423	fConditionsFile << det << ','
	424	<< ring << ','
	425	<< board << ','
	426	<< fPulseSize.At(idx) << "\n";
	427
	428	}
	429	}
	430	}
2d6778fb	431	// sampleRate->WriteToFile(std::cout, fSeenDetectors);
	432	// stripRange->WriteToFile(std::cout, fSeenDetectors);
	433
1656783c	434	if(fConditionsFile.is_open()) {
ce5a8b1a	435
427e8f99	436	fConditionsFile.write("# EOF\n",6);
1656783c	437	fConditionsFile.close();
	438
	439	}
ce5a8b1a	440
ce5a8b1a	441	}
427e8f99	442	//_____________________________________________________________________
6cf6e7a0	443	Int_t AliFMDBaseDA::GetHalfringIndex(UShort_t det, Char_t ring,
	444	UShort_t board) const
	445	{
	446	// Get the index corresponding to a half-ring
	447	//
	448	// Parameters:
	449	// det Detector number
	450	// ring Ring identifier
	451	// board Board number
	452	//
	453	// Return
	454	// Internal index of the board
427e8f99	455	UShort_t iring = (ring == 'I' ? 1 : 0);
	456
	457	Int_t index = (((det-1) << 2) \| (iring << 1) \| (board << 0));
	458
29b7c86f	459	return index-2;
427e8f99	460
427e8f99	461	}
6cf6e7a0	462	//_____________________________________________________________________
	463	void AliFMDBaseDA::Rotate(const char* base, int max) const
	464	{
	465	//
	466	// Rotate a set of files. base is the basic name of the files.
	467	// If the file base.max exists it is removed.
	468	// If the file base.n exists (where n < max) it is renamed to
	469	// base.(n-1).
	470	// If the file base exists, it is renamed to base.1
	471	//
	472	// Parameters:
	473	// base Base name of the files
	474	// max Maximum number to keep (minus one for the current).
	475
	476	// Note: TSystem::AccessPathName returns false if the condition is
	477	// fulfilled!
	478
	479	// Check if we have base.max, and if so, remove it.
	480	TString testName(Form("%s.%d", base, max));
	481	if (!gSystem->AccessPathName(testName.Data()))
	482	gSystem->Unlink(testName.Data());
	483
	484	// Loop down from max-1 to 1 and move files
	485	for (int i = max-1; i >= 1; i--) {
	486	testName = Form("%s.%d", base, i);
	487	if (!gSystem->AccessPathName(testName.Data())) {
	488	TString newName(Form("%s.%d", base, i+1));
	489	gSystem->Rename(testName.Data(), newName.Data());
	490	}
	491	}
	492
	493	// If we have the file base, rename it to base.1
	494	testName = Form("%s", base);
	495	if (!gSystem->AccessPathName(testName.Data())){
	496	TString newName(Form("%s.%d", base, 1));
	497	gSystem->Rename(testName.Data(), newName.Data());
	498	}
	499	}
427e8f99	500
2a082c96	501	//_____________________________________________________________________
	502	TH2*
	503	AliFMDBaseDA::MakeSummaryHistogram(const char* prefix, const char* title,
	504	UShort_t d, Char_t r)
	505	{
	506	Int_t nX = ((d == 1 \|\| r == 'I' \|\| r == 'i') ? 20 : 40);
	507	Int_t nY = ((d == 1 \|\| r == 'I' \|\| r == 'i') ? 512 : 256);
	508
	509	TH2* ret = new TH2F(Form("%sFMD%d%c", prefix, d, r),
	510	Form("%s for FMD%d%c", title, d, r),
	511	nX, -0.5, nX-0.5, nY, -0.5, nY-0.5);
	512	ret->SetXTitle("Sector #");
	513	ret->SetYTitle("Strip #");
	514
	515	// if (!fSummaries) fSummaries = new TObjArray;
	516	fSummaries.Add(ret);
	517	return ret;
	518	}
ce5a8b1a	519
a0180e76	520	//_____________________________________________________________________
	521	//
	522	// EOF
	523	//