[u/mrichter/AliRoot.git] / ITS / AliITSOnlineSPDscan.cxx

////////////////////////////////////////////////////////////
// Author: Henrik Tydesjo                                 //
// Interface class to the containers of an online scan.   //
// Directly connected to a TFile with all containers.     //
// Handles reading and writing of this TFile.             //
// Hitmaps and information on nr of events with hits      //
// is stored in this file (AliITSOnlineSPDHitArray and    //
// AliITSOnlineSPDHitEvent). Also some general            //
// information is stored (AliITSOnlineSPDscanInfo).       //
// When switching between different steps of the scan,    //
// the previous step is automatically stored on the file. //
// With this scheme there is no risk of running out of    //
// memory.                                                //
////////////////////////////////////////////////////////////

#include <math.h>

#include <TFile.h>
#include "AliITSOnlineSPDscan.h"
#include "AliITSOnlineSPDscanInfo.h"
#include "AliITSOnlineSPDHitArray.h"
#include "AliITSOnlineSPDHitEvent.h"

AliITSOnlineSPDscan::AliITSOnlineSPDscan(const Char_t *fileName, Bool_t readFromGridFile) :
  fFile(NULL),
  fWrite(kFALSE),
  fCurrentStep(-1),
  fModified(kFALSE),
  fInfoModified(kFALSE),
  fScanInfo(NULL),
  fFileName(fileName)
{
  // constructor, open file for reading or writing
  // look for a previously saved info object 
  // (if file not found create a new one and return, else read)

  Bool_t bRead = readFromGridFile;

  if (!bRead) {
    FILE* fp0 = fopen(fFileName.Data(), "r");
    if (fp0 != NULL) {
      bRead=kTRUE;
      fclose(fp0);
    }
  }

  if (bRead) { // open file for reading
    fFile = TFile::Open(fFileName.Data(), "READ");
    if (fFile==NULL) { // grid file not found, create new local default file
      printf("ERROR: AliITSOnlineSPDscan: File %s not found! Creating 'test999.root' file instead\n",fFileName.Data());
      // create default empty file:
      fFileName = "test999.root";
      fScanInfo = new AliITSOnlineSPDscanInfo();
      fInfoModified=kTRUE;
      fFile = new TFile(fFileName.Data(), "RECREATE");
      fWrite=kTRUE;
    }
    else { // read from file (grid or local)
      fWrite=kFALSE;
      fFile->GetObject("AliITSOnlineSPDscanInfo", fScanInfo);
    }
  }
  else { // create new local file
    fScanInfo = new AliITSOnlineSPDscanInfo();
    fInfoModified=kTRUE;
    fFile = new TFile(fFileName.Data(), "RECREATE");
    fWrite=kTRUE;
  }

  Init();
}

AliITSOnlineSPDscan::AliITSOnlineSPDscan(const AliITSOnlineSPDscan& /*scan*/) :
  fFile(NULL),
  fWrite(kFALSE),
  fCurrentStep(-1),
  fModified(kFALSE),
  fInfoModified(kFALSE),
  fScanInfo(NULL),
  fFileName(".")
{
  printf("This object should not be copied!");
}

AliITSOnlineSPDscan::~AliITSOnlineSPDscan() {
  // destructor
  if (fModified) {
    SaveCurrentStep();
  }
  for (UInt_t hs=0; hs<6; hs++) {
    if (fCurrentHitArray[hs]!=NULL) {
      delete fCurrentHitArray[hs];
      fCurrentHitArray[hs]=NULL;
    }
    if (fCurrentHitEvent[hs]!=NULL) {
      delete fCurrentHitEvent[hs];
      fCurrentHitEvent[hs]=NULL;
    }
  }
  if (fInfoModified) {
    if (!fWrite) {
      fFile->Close();
      delete fFile;
      fFile = new TFile(fFileName.Data(), "UPDATE");
      fWrite=kTRUE;
    }
    fFile->Delete("AliITSOnlineSPDscanInfo;*");
    fFile->WriteTObject(fScanInfo, "AliITSOnlineSPDscanInfo");
  }
  if (fFile!=NULL) {
    delete fFile;
  }
}

AliITSOnlineSPDscan& AliITSOnlineSPDscan::operator=(const AliITSOnlineSPDscan& scan) {
  // assignment operator (should not be used)
  printf("This object should not be copied!");
  if (this!=&scan) {
    // still do nothing...
  }
  return *this;
}

void AliITSOnlineSPDscan::ClearThis() {
  // clear this scan, close file and open new
  for (UInt_t hs=0; hs<6; hs++) {
    if (fCurrentHitArray[hs]!=NULL) {
      delete fCurrentHitArray[hs];
    }
    fCurrentHitArray[hs] = NULL;
    if (fCurrentHitEvent[hs]!=NULL) {
      delete fCurrentHitEvent[hs];
    }
    fCurrentHitEvent[hs] = NULL;
  }
  fScanInfo->ClearThis();
  fFile->Close();
  delete fFile;
  fFile = new TFile(fFileName.Data(), "RECREATE");
  fWrite=kTRUE;
  fFile->WriteTObject(fScanInfo, "AliITSOnlineSPDscanInfo");
  fInfoModified=kTRUE;
}

void AliITSOnlineSPDscan::Init() {
  // init hit arrays and hit events
  for (UInt_t hs=0; hs<6; hs++) {
    fCurrentHitArray[hs]=NULL;
    fCurrentHitEvent[hs]=NULL;
  }

}

UInt_t AliITSOnlineSPDscan::AddScanStep() {
  // add a new scan step
  CreateNewStep();
  return fScanInfo->AddScanStep();
}

void AliITSOnlineSPDscan::CreateNewStep() {
  // create a new step
  // save current step to file (if modified)
  if (fModified) {
    SaveCurrentStep();
  }
  // create new step
  for (UInt_t hs=0; hs<6; hs++) {
    if (fCurrentHitArray[hs]!=NULL) {
      delete fCurrentHitArray[hs];
    }
    fCurrentHitArray[hs] = new AliITSOnlineSPDHitArray();
    if (fCurrentHitEvent[hs]!=NULL) {
      delete fCurrentHitEvent[hs];
    }
    fCurrentHitEvent[hs] = new AliITSOnlineSPDHitEvent();
  }
  fCurrentStep = fScanInfo->GetNSteps();
  fModified=kTRUE;
  fInfoModified=kTRUE;
}

void AliITSOnlineSPDscan::SwitchToStep(UInt_t nsi) {
  // switch to step nsi (save current step first if needed)
  if ((Int_t)nsi!=fCurrentStep) {
    if (fModified) {
      SaveCurrentStep();
    }
    for (UInt_t hs=0; hs<6; hs++) {
      if (fCurrentHitArray[hs]!=NULL) {
	delete fCurrentHitArray[hs];
	fCurrentHitArray[hs]=NULL;
      }
      if (fCurrentHitEvent[hs]!=NULL) {
	delete fCurrentHitEvent[hs];
	fCurrentHitEvent[hs]=NULL;
      }
    }
    if (nsi>=GetNSteps()) {
      FillGap(nsi); // makes fCurrentStep = nsi
    }
    else {
      fCurrentStep=nsi;
      ReadCurrentStep();
    }
  }
}

void AliITSOnlineSPDscan::FillGap(UInt_t nsi) {
  //create new steps until nsi is reached
  while (nsi>=GetNSteps()) {
    fCurrentStep = AddScanStep();
  }
}

void AliITSOnlineSPDscan::ReadCurrentStep() {
  // read current step index into memory
  for (UInt_t hs=0; hs<6; hs++) {
    TString stepName = Form("HitArray_HS%d_Step%d",hs,fCurrentStep);
    fFile->GetObject(stepName.Data(), fCurrentHitArray[hs]);
    TString stepName2 = Form("HitEvent_HS%d_Step%d",hs,fCurrentStep);
    fFile->GetObject(stepName2, fCurrentHitEvent[hs]);
  }
}

void AliITSOnlineSPDscan::SaveCurrentStep() {
  // save current step to file
  if (!fWrite) {
    fFile->Close();
    delete fFile;
    fFile = new TFile(fFileName.Data(), "UPDATE");
    fWrite=kTRUE;
  }
  for (UInt_t hs=0; hs<6; hs++) {
    TString stepName = Form("HitArray_HS%d_Step%d",hs,fCurrentStep);
    TString stepDelete = Form("%s;*",stepName.Data());
    fFile->Delete(stepDelete.Data());
    fFile->WriteTObject(fCurrentHitArray[hs], stepName.Data());
    TString stepName2 = Form("HitEvent_HS%d_Step%d",hs,fCurrentStep);
    TString stepDelete2 = Form("%s;*",stepName2.Data());
    fFile->Delete(stepDelete2.Data());
    fFile->WriteTObject(fCurrentHitEvent[hs], stepName2.Data());
  }
  fModified=kFALSE;
}

void AliITSOnlineSPDscan::SetHits(UInt_t nsi, UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi, UInt_t val) {
  // set nr of hits for pixel
  SwitchToStep(nsi);
  fCurrentHitArray[hs]->SetHits(chipi,coli,rowi,val);
  fModified=kTRUE;
}
void AliITSOnlineSPDscan::IncrementHits(UInt_t nsi, UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi) {
  // increment nr of hits for pixel
  SwitchToStep(nsi);
  fCurrentHitArray[hs]->IncrementHits(chipi,coli,rowi);
  fModified=kTRUE;
}
void AliITSOnlineSPDscan::SetHitEvents(UInt_t nsi, UInt_t hs, UInt_t chipi, Int_t val) {
  // set nr of hit events for a chip
  SwitchToStep(nsi);
  fCurrentHitEvent[hs]->SetHitEvent(chipi,val);
  fModified=kTRUE;
}
void AliITSOnlineSPDscan::SetHitEventsTot(UInt_t nsi, UInt_t hs, Int_t val) {
  // set nr of hit events for 10 chips together
  SetHitEvents(nsi,hs,10,val);
}
void AliITSOnlineSPDscan::IncrementHitEvents(UInt_t nsi, UInt_t hs, UInt_t chipi) {
  // increment nr of hit events for a chip
  SwitchToStep(nsi);
  fCurrentHitEvent[hs]->IncrementHitEvent(chipi);
  fModified=kTRUE;
}
void AliITSOnlineSPDscan::IncrementHitEventsTot(UInt_t nsi, UInt_t hs) {
  // increment nr of hit events for 10 chips
  IncrementHitEvents(nsi,hs,10);
}


UInt_t AliITSOnlineSPDscan::GetHits(UInt_t nsi, UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi) {
  // get nr of hits for pixel
  if (nsi<GetNSteps()) {
    SwitchToStep(nsi);
    return fCurrentHitArray[hs]->GetHits(chipi,coli,rowi);
  }
  else {
    return 0;
  }
}
Float_t AliITSOnlineSPDscan::GetHitsEfficiency(UInt_t nsi, UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi) {
  // get the hit efficiency for pixel
  UInt_t ntr = GetTriggers(nsi);
  if (ntr>0) {
    return ((Float_t)GetHits(nsi,hs,chipi,coli,rowi))/ntr;
  }
  else {
    return 0;
  }
}
Float_t AliITSOnlineSPDscan::GetHitsEfficiencyError(UInt_t nsi, UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi) {
  // get error in hit efficiency for pixel
  Float_t hits = GetHits(nsi,hs,chipi,coli,rowi);
  UInt_t ntr = GetTriggers(nsi);
  return sqrt(hits*(ntr-hits)/ntr)/ntr;
}
UInt_t AliITSOnlineSPDscan::GetHitEvents(UInt_t nsi, UInt_t hs, UInt_t chipi) {
  // get nr of hit events for a chip
  if (nsi<GetNSteps()) {
    SwitchToStep(nsi);
    return fCurrentHitEvent[hs]->GetHitEvent(chipi);
  }
  else {
    return 0;
  }
}
UInt_t AliITSOnlineSPDscan::GetHitEventsTot(UInt_t nsi, UInt_t hs) {
  // get nr of hit events for 10 chips
  return GetHitEvents(nsi,hs,10);
}
Float_t AliITSOnlineSPDscan::GetHitEventsEfficiency(UInt_t nsi, UInt_t hs, UInt_t chipi) {
  // get the hit events efficiency for a chip
  UInt_t ntr = GetTriggers(nsi);
  if (ntr>0) {
    return ((Float_t)GetHitEvents(nsi,hs,chipi))/ntr;
  }
  else {
    return 0;
  }
}
Float_t AliITSOnlineSPDscan::GetHitEventsTotEfficiency(UInt_t nsi, UInt_t hs) {
  // get the hit events efficiency for 10 chips
  return GetHitEventsEfficiency(nsi,hs,10);
}
Float_t AliITSOnlineSPDscan::GetHitEventsEfficiencyError(UInt_t nsi, UInt_t hs, UInt_t chipi) {
  // get error in hit events efficiency for a chip
  Float_t hitevents = (Float_t) GetHitEvents(nsi,hs,chipi);
  UInt_t ntr = GetTriggers(nsi);
  return sqrt(hitevents*(ntr-hitevents)/ntr)/ntr;
}
Float_t AliITSOnlineSPDscan::GetHitEventsTotEfficiencyError(UInt_t nsi, UInt_t hs) {
  // get error in hit events efficiency for 10 chips
  return GetHitEventsEfficiencyError(nsi,hs,10);
}
Float_t AliITSOnlineSPDscan::GetAverageMultiplicity(UInt_t nsi, UInt_t hs, UInt_t chipi) {
  // get average multiplicity for a chip
  Float_t nrhits = 0;
  for (UInt_t chip=0;chip<10;chip++) {
    if (chipi==10 || chip==chipi) {
      for (Int_t col=0; col<32; col++) {
	for (Int_t row=0; row<256; row++) {
	  nrhits+=GetHits(nsi,hs,chip,col,row);
	}
      }
    }
  }
  UInt_t ntr = GetTriggers(nsi);
  if (ntr>0) {
    return nrhits/ntr;
  }
  else {
    return 0;
  }
}
Float_t AliITSOnlineSPDscan::GetAverageMultiplicityTot(UInt_t nsi, UInt_t hs) {
  // get average multiplicity for 10 chips
  return GetAverageMultiplicity(nsi,hs,10);
}


void AliITSOnlineSPDscan::SetType(UInt_t val) {
  // set type
  fScanInfo->SetType(val);
  fInfoModified=kTRUE;
}
void AliITSOnlineSPDscan::SetRunNr(UInt_t val) {
  // set run nr
  fScanInfo->SetRunNr(val);
  fInfoModified=kTRUE;
}
void AliITSOnlineSPDscan::SetRouterNr(UInt_t val) {
  // set router nr
  fScanInfo->SetRouterNr(val);
  fInfoModified=kTRUE;
}
void AliITSOnlineSPDscan::SetHalfStaveScanned(UInt_t val, Bool_t b) {
  // set half stave scanned
  fScanInfo->SetHalfStaveScanned(val,b);
  fInfoModified=kTRUE;
}
void AliITSOnlineSPDscan::SetDataFormat(UInt_t val) {
  // set data format (0=normal 1=histogram)
  fScanInfo->SetDataFormat(val);
  fInfoModified=kTRUE;
}
void AliITSOnlineSPDscan::SetTriggers(UInt_t nsi, UInt_t val) {
  // set nr of triggers
  SwitchToStep(nsi);
  fScanInfo->SetTriggers(nsi,val);
  fInfoModified=kTRUE;
}
void AliITSOnlineSPDscan::SetChipPresent(UInt_t hs, UInt_t chipi, Bool_t val){
  // set chip present
  fScanInfo->SetChipPresent(hs,chipi,val); 
  fInfoModified=kTRUE;
}
void AliITSOnlineSPDscan::SetRowStart(UInt_t val){
  // set row start
  fScanInfo->SetRowStart(val); 
  fInfoModified=kTRUE;
}
void AliITSOnlineSPDscan::SetRowEnd(UInt_t val){
  // set row end
  fScanInfo->SetRowEnd(val); 
  fInfoModified=kTRUE;
}
void AliITSOnlineSPDscan::SetDacStart(UInt_t val){
  // set dac start
  fScanInfo->SetDacStart(val); 
  fInfoModified=kTRUE;
}
void AliITSOnlineSPDscan::SetDacEnd(UInt_t val){
  // set dac end
  fScanInfo->SetDacEnd(val); 
  fInfoModified=kTRUE;
}  
void AliITSOnlineSPDscan::SetDacStep(UInt_t val){
  // set dac step
  fScanInfo->SetDacStep(val); 
  fInfoModified=kTRUE;
}
void AliITSOnlineSPDscan::SetDCSVersion(UInt_t val){
  // set dcs db version
  fScanInfo->SetDCSVersion(val); 
  fInfoModified=kTRUE;
}
void AliITSOnlineSPDscan::IncrementTriggers(UInt_t nsi) {
  // increment nr of triggers
  SwitchToStep(nsi);
  fScanInfo->IncrementTriggers(nsi); 
  fInfoModified=kTRUE;
}


UInt_t AliITSOnlineSPDscan::GetNSteps() const {
  return fScanInfo->GetNSteps();
}
UInt_t AliITSOnlineSPDscan::GetType() const {
  return fScanInfo->GetType();
}
UInt_t AliITSOnlineSPDscan::GetRunNr() const {
  return fScanInfo->GetRunNr();
}
UInt_t AliITSOnlineSPDscan::GetRouterNr() const {
  return fScanInfo->GetRouterNr();
}
Bool_t AliITSOnlineSPDscan::GetHalfStaveScanned(UInt_t val) const {
  return fScanInfo->GetHalfStaveScanned(val);
}
UInt_t AliITSOnlineSPDscan::GetDataFormat() const {
  return fScanInfo->GetDataFormat();
}
UInt_t AliITSOnlineSPDscan::GetTriggers(UInt_t nsi) const {
  return fScanInfo->GetTriggers(nsi);
}
Bool_t AliITSOnlineSPDscan::GetChipPresent(UInt_t hs, UInt_t chipi) const {
  return fScanInfo->GetChipPresent(hs,chipi);
}
UInt_t AliITSOnlineSPDscan::GetRowStart() const {
  return fScanInfo->GetRowStart();
}
UInt_t AliITSOnlineSPDscan::GetRowEnd() const {
  return fScanInfo->GetRowEnd();
}
UInt_t AliITSOnlineSPDscan::GetDacStart() const {
  return fScanInfo->GetDacStart();
}
UInt_t AliITSOnlineSPDscan::GetDacEnd() const {
  return fScanInfo->GetDacEnd();
}
UInt_t AliITSOnlineSPDscan::GetDacStep() const {
  return fScanInfo->GetDacStep();
}
UInt_t AliITSOnlineSPDscan::GetDCSVersion() const {
  return fScanInfo->GetDCSVersion();
}
Commit	Line	Data
b15de2d2	1	////////////////////////////////////////////////////////////
	2	// Author: Henrik Tydesjo //
	3	// Interface class to the containers of an online scan. //
	4	// Directly connected to a TFile with all containers. //
	5	// Handles reading and writing of this TFile. //
	6	// Hitmaps and information on nr of events with hits //
	7	// is stored in this file (AliITSOnlineSPDHitArray and //
	8	// AliITSOnlineSPDHitEvent). Also some general //
	9	// information is stored (AliITSOnlineSPDscanInfo). //
	10	// When switching between different steps of the scan, //
	11	// the previous step is automatically stored on the file. //
	12	// With this scheme there is no risk of running out of //
	13	// memory. //
	14	////////////////////////////////////////////////////////////
	15
a1e17193	16	#include <math.h>
a1e17193	17
b15de2d2	18	#include <TFile.h>
	19	#include "AliITSOnlineSPDscan.h"
	20	#include "AliITSOnlineSPDscanInfo.h"
	21	#include "AliITSOnlineSPDHitArray.h"
	22	#include "AliITSOnlineSPDHitEvent.h"
	23
6ddf3d66	24	AliITSOnlineSPDscan::AliITSOnlineSPDscan(const Char_t *fileName, Bool_t readFromGridFile) :
b15de2d2	25	fFile(NULL),
	26	fWrite(kFALSE),
	27	fCurrentStep(-1),
	28	fModified(kFALSE),
	29	fInfoModified(kFALSE),
53ae21ce	30	fScanInfo(NULL),
53ae21ce	31	fFileName(fileName)
b15de2d2	32	{
b15de2d2	33	// constructor, open file for reading or writing
b15de2d2	34	// look for a previously saved info object
b15de2d2	35	// (if file not found create a new one and return, else read)
6ddf3d66	36
	37	Bool_t bRead = readFromGridFile;
	38
	39	if (!bRead) {
	40	FILE* fp0 = fopen(fFileName.Data(), "r");
	41	if (fp0 != NULL) {
	42	bRead=kTRUE;
	43	fclose(fp0);
	44	}
	45	}
	46
	47	if (bRead) { // open file for reading
	48	fFile = TFile::Open(fFileName.Data(), "READ");
	49	if (fFile==NULL) { // grid file not found, create new local default file
	50	printf("ERROR: AliITSOnlineSPDscan: File %s not found! Creating 'test999.root' file instead\n",fFileName.Data());
	51	// create default empty file:
	52	fFileName = "test999.root";
	53	fScanInfo = new AliITSOnlineSPDscanInfo();
	54	fInfoModified=kTRUE;
	55	fFile = new TFile(fFileName.Data(), "RECREATE");
	56	fWrite=kTRUE;
	57	}
	58	else { // read from file (grid or local)
	59	fWrite=kFALSE;
	60	fFile->GetObject("AliITSOnlineSPDscanInfo", fScanInfo);
	61	}
	62	}
	63	else { // create new local file
b15de2d2	64	fScanInfo = new AliITSOnlineSPDscanInfo();
6ddf3d66	65	fInfoModified=kTRUE;
53ae21ce	66	fFile = new TFile(fFileName.Data(), "RECREATE");
b15de2d2	67	fWrite=kTRUE;
b15de2d2	68	}
6ddf3d66	69
b15de2d2	70	Init();
	71	}
	72
	73	AliITSOnlineSPDscan::AliITSOnlineSPDscan(const AliITSOnlineSPDscan& /scan/) :
	74	fFile(NULL),
	75	fWrite(kFALSE),
	76	fCurrentStep(-1),
	77	fModified(kFALSE),
	78	fInfoModified(kFALSE),
53ae21ce	79	fScanInfo(NULL),
53ae21ce	80	fFileName(".")
b15de2d2	81	{
	82	printf("This object should not be copied!");
	83	}
	84
	85	AliITSOnlineSPDscan::~AliITSOnlineSPDscan() {
	86	// destructor
	87	if (fModified) {
	88	SaveCurrentStep();
	89	}
	90	for (UInt_t hs=0; hs<6; hs++) {
	91	if (fCurrentHitArray[hs]!=NULL) {
	92	delete fCurrentHitArray[hs];
	93	fCurrentHitArray[hs]=NULL;
	94	}
	95	if (fCurrentHitEvent[hs]!=NULL) {
	96	delete fCurrentHitEvent[hs];
	97	fCurrentHitEvent[hs]=NULL;
	98	}
	99	}
	100	if (fInfoModified) {
	101	if (!fWrite) {
	102	fFile->Close();
	103	delete fFile;
53ae21ce	104	fFile = new TFile(fFileName.Data(), "UPDATE");
b15de2d2	105	fWrite=kTRUE;
	106	}
	107	fFile->Delete("AliITSOnlineSPDscanInfo;*");
	108	fFile->WriteTObject(fScanInfo, "AliITSOnlineSPDscanInfo");
08ed0911	109	}
08ed0911	110	if (fFile!=NULL) {
b15de2d2	111	delete fFile;
	112	}
	113	}
	114
	115	AliITSOnlineSPDscan& AliITSOnlineSPDscan::operator=(const AliITSOnlineSPDscan& scan) {
	116	// assignment operator (should not be used)
	117	printf("This object should not be copied!");
	118	if (this!=&scan) {
	119	// still do nothing...
	120	}
	121	return *this;
	122	}
	123
b15de2d2	124	void AliITSOnlineSPDscan::ClearThis() {
	125	// clear this scan, close file and open new
	126	for (UInt_t hs=0; hs<6; hs++) {
	127	if (fCurrentHitArray[hs]!=NULL) {
	128	delete fCurrentHitArray[hs];
	129	}
	130	fCurrentHitArray[hs] = NULL;
	131	if (fCurrentHitEvent[hs]!=NULL) {
	132	delete fCurrentHitEvent[hs];
	133	}
	134	fCurrentHitEvent[hs] = NULL;
	135	}
	136	fScanInfo->ClearThis();
	137	fFile->Close();
	138	delete fFile;
53ae21ce	139	fFile = new TFile(fFileName.Data(), "RECREATE");
b15de2d2	140	fWrite=kTRUE;
	141	fFile->WriteTObject(fScanInfo, "AliITSOnlineSPDscanInfo");
	142	fInfoModified=kTRUE;
	143	}
	144
	145	void AliITSOnlineSPDscan::Init() {
	146	// init hit arrays and hit events
	147	for (UInt_t hs=0; hs<6; hs++) {
	148	fCurrentHitArray[hs]=NULL;
	149	fCurrentHitEvent[hs]=NULL;
	150	}
	151
	152	}
	153
	154	UInt_t AliITSOnlineSPDscan::AddScanStep() {
	155	// add a new scan step
	156	CreateNewStep();
	157	return fScanInfo->AddScanStep();
	158	}
	159
	160	void AliITSOnlineSPDscan::CreateNewStep() {
	161	// create a new step
	162	// save current step to file (if modified)
	163	if (fModified) {
	164	SaveCurrentStep();
	165	}
	166	// create new step
	167	for (UInt_t hs=0; hs<6; hs++) {
	168	if (fCurrentHitArray[hs]!=NULL) {
	169	delete fCurrentHitArray[hs];
	170	}
	171	fCurrentHitArray[hs] = new AliITSOnlineSPDHitArray();
	172	if (fCurrentHitEvent[hs]!=NULL) {
	173	delete fCurrentHitEvent[hs];
	174	}
	175	fCurrentHitEvent[hs] = new AliITSOnlineSPDHitEvent();
	176	}
	177	fCurrentStep = fScanInfo->GetNSteps();
	178	fModified=kTRUE;
	179	fInfoModified=kTRUE;
	180	}
	181
	182	void AliITSOnlineSPDscan::SwitchToStep(UInt_t nsi) {
	183	// switch to step nsi (save current step first if needed)
	184	if ((Int_t)nsi!=fCurrentStep) {
	185	if (fModified) {
	186	SaveCurrentStep();
	187	}
	188	for (UInt_t hs=0; hs<6; hs++) {
	189	if (fCurrentHitArray[hs]!=NULL) {
	190	delete fCurrentHitArray[hs];
	191	fCurrentHitArray[hs]=NULL;
	192	}
	193	if (fCurrentHitEvent[hs]!=NULL) {
	194	delete fCurrentHitEvent[hs];
	195	fCurrentHitEvent[hs]=NULL;
	196	}
	197	}
	198	if (nsi>=GetNSteps()) {
	199	FillGap(nsi); // makes fCurrentStep = nsi
	200	}
	201	else {
	202	fCurrentStep=nsi;
	203	ReadCurrentStep();
204	}
205	}
206	}
207
208	void AliITSOnlineSPDscan::FillGap(UInt_t nsi) {
209	//create new steps until nsi is reached
210	while (nsi>=GetNSteps()) {
211	fCurrentStep = AddScanStep();
212	}
213	}
214
215	void AliITSOnlineSPDscan::ReadCurrentStep() {
216	// read current step index into memory
217	for (UInt_t hs=0; hs<6; hs++) {
53ae21ce	218	TString stepName = Form("HitArray_HS%d_Step%d",hs,fCurrentStep);
	219	fFile->GetObject(stepName.Data(), fCurrentHitArray[hs]);
	220	TString stepName2 = Form("HitEvent_HS%d_Step%d",hs,fCurrentStep);
b15de2d2	221	fFile->GetObject(stepName2, fCurrentHitEvent[hs]);
	222	}
	223	}
	224
	225	void AliITSOnlineSPDscan::SaveCurrentStep() {
	226	// save current step to file
	227	if (!fWrite) {
	228	fFile->Close();
	229	delete fFile;
53ae21ce	230	fFile = new TFile(fFileName.Data(), "UPDATE");
b15de2d2	231	fWrite=kTRUE;
	232	}
	233	for (UInt_t hs=0; hs<6; hs++) {
53ae21ce	234	TString stepName = Form("HitArray_HS%d_Step%d",hs,fCurrentStep);
	235	TString stepDelete = Form("%s;*",stepName.Data());
	236	fFile->Delete(stepDelete.Data());
	237	fFile->WriteTObject(fCurrentHitArray[hs], stepName.Data());
	238	TString stepName2 = Form("HitEvent_HS%d_Step%d",hs,fCurrentStep);
	239	TString stepDelete2 = Form("%s;*",stepName2.Data());
	240	fFile->Delete(stepDelete2.Data());
	241	fFile->WriteTObject(fCurrentHitEvent[hs], stepName2.Data());
b15de2d2	242	}
	243	fModified=kFALSE;
	244	}
	245
	246	void AliITSOnlineSPDscan::SetHits(UInt_t nsi, UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi, UInt_t val) {
	247	// set nr of hits for pixel
	248	SwitchToStep(nsi);
	249	fCurrentHitArray[hs]->SetHits(chipi,coli,rowi,val);
	250	fModified=kTRUE;
	251	}
	252	void AliITSOnlineSPDscan::IncrementHits(UInt_t nsi, UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi) {
	253	// increment nr of hits for pixel
	254	SwitchToStep(nsi);
	255	fCurrentHitArray[hs]->IncrementHits(chipi,coli,rowi);
	256	fModified=kTRUE;
	257	}
	258	void AliITSOnlineSPDscan::SetHitEvents(UInt_t nsi, UInt_t hs, UInt_t chipi, Int_t val) {
	259	// set nr of hit events for a chip
	260	SwitchToStep(nsi);
	261	fCurrentHitEvent[hs]->SetHitEvent(chipi,val);
	262	fModified=kTRUE;
	263	}
	264	void AliITSOnlineSPDscan::SetHitEventsTot(UInt_t nsi, UInt_t hs, Int_t val) {
	265	// set nr of hit events for 10 chips together
	266	SetHitEvents(nsi,hs,10,val);
	267	}
	268	void AliITSOnlineSPDscan::IncrementHitEvents(UInt_t nsi, UInt_t hs, UInt_t chipi) {
	269	// increment nr of hit events for a chip
	270	SwitchToStep(nsi);
	271	fCurrentHitEvent[hs]->IncrementHitEvent(chipi);
	272	fModified=kTRUE;
	273	}
	274	void AliITSOnlineSPDscan::IncrementHitEventsTot(UInt_t nsi, UInt_t hs) {
	275	// increment nr of hit events for 10 chips
	276	IncrementHitEvents(nsi,hs,10);
	277	}
	278
	279
	280	UInt_t AliITSOnlineSPDscan::GetHits(UInt_t nsi, UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi) {
	281	// get nr of hits for pixel
	282	if (nsi<GetNSteps()) {
	283	SwitchToStep(nsi);
	284	return fCurrentHitArray[hs]->GetHits(chipi,coli,rowi);
	285	}
	286	else {
	287	return 0;
	288	}
	289	}
	290	Float_t AliITSOnlineSPDscan::GetHitsEfficiency(UInt_t nsi, UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi) {
	291	// get the hit efficiency for pixel
	292	UInt_t ntr = GetTriggers(nsi);
	293	if (ntr>0) {
	294	return ((Float_t)GetHits(nsi,hs,chipi,coli,rowi))/ntr;
	295	}
	296	else {
	297	return 0;
	298	}
	299	}
	300	Float_t AliITSOnlineSPDscan::GetHitsEfficiencyError(UInt_t nsi, UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi) {
	301	// get error in hit efficiency for pixel
	302	Float_t hits = GetHits(nsi,hs,chipi,coli,rowi);
	303	UInt_t ntr = GetTriggers(nsi);
	304	return sqrt(hits*(ntr-hits)/ntr)/ntr;
	305	}
306	UInt_t AliITSOnlineSPDscan::GetHitEvents(UInt_t nsi, UInt_t hs, UInt_t chipi) {
307	// get nr of hit events for a chip
308	if (nsi<GetNSteps()) {
309	SwitchToStep(nsi);
310	return fCurrentHitEvent[hs]->GetHitEvent(chipi);
311	}
312	else {
313	return 0;
314	}
315	}
316	UInt_t AliITSOnlineSPDscan::GetHitEventsTot(UInt_t nsi, UInt_t hs) {
317	// get nr of hit events for 10 chips
318	return GetHitEvents(nsi,hs,10);
319	}
320	Float_t AliITSOnlineSPDscan::GetHitEventsEfficiency(UInt_t nsi, UInt_t hs, UInt_t chipi) {
321	// get the hit events efficiency for a chip
322	UInt_t ntr = GetTriggers(nsi);
323	if (ntr>0) {
324	return ((Float_t)GetHitEvents(nsi,hs,chipi))/ntr;
325	}
326	else {
327	return 0;
328	}
329	}
330	Float_t AliITSOnlineSPDscan::GetHitEventsTotEfficiency(UInt_t nsi, UInt_t hs) {
331	// get the hit events efficiency for 10 chips
332	return GetHitEventsEfficiency(nsi,hs,10);
333	}
334	Float_t AliITSOnlineSPDscan::GetHitEventsEfficiencyError(UInt_t nsi, UInt_t hs, UInt_t chipi) {
335	// get error in hit events efficiency for a chip
336	Float_t hitevents = (Float_t) GetHitEvents(nsi,hs,chipi);
337	UInt_t ntr = GetTriggers(nsi);
338	return sqrt(hitevents*(ntr-hitevents)/ntr)/ntr;
339	}
340	Float_t AliITSOnlineSPDscan::GetHitEventsTotEfficiencyError(UInt_t nsi, UInt_t hs) {
341	// get error in hit events efficiency for 10 chips
342	return GetHitEventsEfficiencyError(nsi,hs,10);
343	}
344	Float_t AliITSOnlineSPDscan::GetAverageMultiplicity(UInt_t nsi, UInt_t hs, UInt_t chipi) {
345	// get average multiplicity for a chip
346	Float_t nrhits = 0;
347	for (UInt_t chip=0;chip<10;chip++) {
348	if (chipi==10 \|\| chip==chipi) {
349	for (Int_t col=0; col<32; col++) {
350	for (Int_t row=0; row<256; row++) {
351	nrhits+=GetHits(nsi,hs,chip,col,row);
352	}
353	}
354	}
355	}
356	UInt_t ntr = GetTriggers(nsi);
357	if (ntr>0) {
358	return nrhits/ntr;
359	}
360	else {
361	return 0;
362	}
363	}
364	Float_t AliITSOnlineSPDscan::GetAverageMultiplicityTot(UInt_t nsi, UInt_t hs) {
365	// get average multiplicity for 10 chips
366	return GetAverageMultiplicity(nsi,hs,10);
367	}
368
369
370	void AliITSOnlineSPDscan::SetType(UInt_t val) {
371	// set type
372	fScanInfo->SetType(val);
373	fInfoModified=kTRUE;
374	}
375	void AliITSOnlineSPDscan::SetRunNr(UInt_t val) {
376	// set run nr
377	fScanInfo->SetRunNr(val);
378	fInfoModified=kTRUE;
379	}
380	void AliITSOnlineSPDscan::SetRouterNr(UInt_t val) {
381	// set router nr
382	fScanInfo->SetRouterNr(val);
383	fInfoModified=kTRUE;
384	}
ad18504e	385	void AliITSOnlineSPDscan::SetHalfStaveScanned(UInt_t val, Bool_t b) {
	386	// set half stave scanned
	387	fScanInfo->SetHalfStaveScanned(val,b);
	388	fInfoModified=kTRUE;
	389	}
	390	void AliITSOnlineSPDscan::SetDataFormat(UInt_t val) {
	391	// set data format (0=normal 1=histogram)
	392	fScanInfo->SetDataFormat(val);
	393	fInfoModified=kTRUE;
	394	}
b15de2d2	395	void AliITSOnlineSPDscan::SetTriggers(UInt_t nsi, UInt_t val) {
b15de2d2	396	// set nr of triggers
3db5f733	397	SwitchToStep(nsi);
b15de2d2	398	fScanInfo->SetTriggers(nsi,val);
	399	fInfoModified=kTRUE;
	400	}
	401	void AliITSOnlineSPDscan::SetChipPresent(UInt_t hs, UInt_t chipi, Bool_t val){
	402	// set chip present
	403	fScanInfo->SetChipPresent(hs,chipi,val);
	404	fInfoModified=kTRUE;
	405	}
	406	void AliITSOnlineSPDscan::SetRowStart(UInt_t val){
	407	// set row start
	408	fScanInfo->SetRowStart(val);
	409	fInfoModified=kTRUE;
	410	}
	411	void AliITSOnlineSPDscan::SetRowEnd(UInt_t val){
	412	// set row end
	413	fScanInfo->SetRowEnd(val);
	414	fInfoModified=kTRUE;
	415	}
	416	void AliITSOnlineSPDscan::SetDacStart(UInt_t val){
	417	// set dac start
	418	fScanInfo->SetDacStart(val);
	419	fInfoModified=kTRUE;
	420	}
	421	void AliITSOnlineSPDscan::SetDacEnd(UInt_t val){
	422	// set dac end
	423	fScanInfo->SetDacEnd(val);
	424	fInfoModified=kTRUE;
	425	}
	426	void AliITSOnlineSPDscan::SetDacStep(UInt_t val){
	427	// set dac step
	428	fScanInfo->SetDacStep(val);
	429	fInfoModified=kTRUE;
	430	}
53ae21ce	431	void AliITSOnlineSPDscan::SetDCSVersion(UInt_t val){
	432	// set dcs db version
	433	fScanInfo->SetDCSVersion(val);
	434	fInfoModified=kTRUE;
	435	}
b15de2d2	436	void AliITSOnlineSPDscan::IncrementTriggers(UInt_t nsi) {
b15de2d2	437	// increment nr of triggers
3db5f733	438	SwitchToStep(nsi);
b15de2d2	439	fScanInfo->IncrementTriggers(nsi);
	440	fInfoModified=kTRUE;
	441	}
	442
	443
	444
	445	UInt_t AliITSOnlineSPDscan::GetNSteps() const {
	446	return fScanInfo->GetNSteps();
	447	}
	448	UInt_t AliITSOnlineSPDscan::GetType() const {
	449	return fScanInfo->GetType();
	450	}
	451	UInt_t AliITSOnlineSPDscan::GetRunNr() const {
	452	return fScanInfo->GetRunNr();
	453	}
	454	UInt_t AliITSOnlineSPDscan::GetRouterNr() const {
	455	return fScanInfo->GetRouterNr();
	456	}
ad18504e	457	Bool_t AliITSOnlineSPDscan::GetHalfStaveScanned(UInt_t val) const {
	458	return fScanInfo->GetHalfStaveScanned(val);
	459	}
	460	UInt_t AliITSOnlineSPDscan::GetDataFormat() const {
	461	return fScanInfo->GetDataFormat();
	462	}
b15de2d2	463	UInt_t AliITSOnlineSPDscan::GetTriggers(UInt_t nsi) const {
	464	return fScanInfo->GetTriggers(nsi);
	465	}
	466	Bool_t AliITSOnlineSPDscan::GetChipPresent(UInt_t hs, UInt_t chipi) const {
	467	return fScanInfo->GetChipPresent(hs,chipi);
	468	}
	469	UInt_t AliITSOnlineSPDscan::GetRowStart() const {
	470	return fScanInfo->GetRowStart();
	471	}
	472	UInt_t AliITSOnlineSPDscan::GetRowEnd() const {
	473	return fScanInfo->GetRowEnd();
	474	}
	475	UInt_t AliITSOnlineSPDscan::GetDacStart() const {
	476	return fScanInfo->GetDacStart();
	477	}
	478	UInt_t AliITSOnlineSPDscan::GetDacEnd() const {
	479	return fScanInfo->GetDacEnd();
	480	}
	481	UInt_t AliITSOnlineSPDscan::GetDacStep() const {
	482	return fScanInfo->GetDacStep();
	483	}
53ae21ce	484	UInt_t AliITSOnlineSPDscan::GetDCSVersion() const {
	485	return fScanInfo->GetDCSVersion();
	486	}