[u/mrichter/AliRoot.git] / STEER / STEERBase / AliRunTag.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.                  *
 **************************************************************************/

/* $Id$ */

//-----------------------------------------------------------------
//           Implementation of the RunTag class
//   This is the class to deal with the tags in the run level
//   Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
//-----------------------------------------------------------------

#include <stdlib.h>
#include "AliRunTag.h"
#include "AliDetectorTag.h"
#include "AliEventTag.h"

ClassImp(AliRunTag)

//___________________________________________________________________________
  AliRunTag::AliRunTag() :
    TObject(),
    fAliceRunId(-1),
    fAliceMagneticField(0.0),
    fAliceDipoleField(0.0),
    fAliceRunStartTime(0),
    fAliceRunStopTime(0),
    fAlirootVersion(0),
    fRootVersion(0),
    fGeant3Version(0),
    fLHCPeriod(0),
    fRecPass(0),
    fProductionName(0),
    fAliceRunValidated(0),
    fAliceRunGlobalQuality(0),
    fAliceBeamEnergy(0.0),
    fAliceBeamType(0),
    fAliceCalibrationVersion(0),
    fAliceDataType(0),
    //    fNumEvents(0),
    fNumFiles(0),
    fBeamTriggers(0),
    fCollisionTriggers(0),
    fEmptyTriggers(0),
    fASideTriggers(0),
    fCSideTriggers(0),
    fHMTriggers(0),
    fMuonTriggers(0),
    fCollisionRate(0.0),
    fMeanVertex(0.0),
    fVertexQuality(0.0),
    fNumDetectors(0),
    fFileTags(100),
    fDetectorTag(),
    fLHCTag(), 
    fActiveTriggerClasses(""),
    fQA(),  
    fQALength(0), 
    fQAArray(NULL), 
    fESLength(0), 
    fEventSpecies(NULL)
{
  //Default constructor
}

//___________________________________________________________________________
AliRunTag::~AliRunTag() {
  //Destructor
  //  fEventTag.Delete();
  if ( fQAArray ) 
    delete [] fQAArray ; 
  if ( fEventSpecies )
    delete [] fEventSpecies ; 
  fFileTags.Delete();
}

//___________________________________________________________________________
AliRunTag::AliRunTag(const AliRunTag& tag):
TObject(),
fAliceRunId(tag.fAliceRunId),
fAliceMagneticField(tag.fAliceMagneticField),
fAliceDipoleField(tag.fAliceDipoleField),
fAliceRunStartTime(tag.fAliceRunStartTime),
fAliceRunStopTime(tag.fAliceRunStopTime),
fAlirootVersion(tag.fAlirootVersion),
fRootVersion(tag.fRootVersion),
fGeant3Version(tag.fGeant3Version),
fLHCPeriod(tag.fLHCPeriod),
fRecPass(tag.fRecPass),
fProductionName(tag.fProductionName),
fAliceRunValidated(tag.fAliceRunValidated),
fAliceRunGlobalQuality(tag.fAliceRunGlobalQuality),
fAliceBeamEnergy(tag.fAliceBeamEnergy),
fAliceBeamType(tag.fAliceBeamType),
fAliceCalibrationVersion(tag.fAliceCalibrationVersion),
fAliceDataType(tag.fAliceDataType),
//fNumEvents(tag.fNumEvents),
fNumFiles(0),
fBeamTriggers(tag.fBeamTriggers),
fCollisionTriggers(tag.fCollisionTriggers),
fEmptyTriggers(tag.fEmptyTriggers),
fASideTriggers(tag.fASideTriggers),
fCSideTriggers(tag.fCSideTriggers),
fHMTriggers(tag.fHMTriggers),
fMuonTriggers(tag.fMuonTriggers),
fCollisionRate(tag.fCollisionRate),
fMeanVertex(tag.fMeanVertex),
fVertexQuality(tag.fVertexQuality),
fNumDetectors(tag.fNumDetectors),
fFileTags(100),
fDetectorTag(tag.fDetectorTag),
fLHCTag(tag.fLHCTag), 
fActiveTriggerClasses(tag.fActiveTriggerClasses),
fQA(tag.fQA),
fQALength(tag.fQALength),
fQAArray(NULL), 
fESLength(tag.fESLength),
fEventSpecies(NULL)
{
  //copy constructor
  if (fQALength == 0 ) 
    fQAArray = NULL ; 
  else {
    fQAArray = new ULong_t[fQALength] ; 
    memcpy(fQAArray, tag.fQAArray, fQALength*sizeof(ULong_t)) ;
  }
  if (fESLength == 0 ) 
    fEventSpecies = NULL ; 
  else {
    fEventSpecies = new Bool_t[fESLength] ; 
    memcpy(fEventSpecies, tag.fEventSpecies, fESLength*sizeof(Bool_t)) ;
  }
  for (int ifl=0; ifl<tag.fNumFiles; ifl++) {
    AddFileTag(new AliFileTag(*tag.GetFileTag(ifl)));
  }
    

}

//___________________________________________________________________________
AliRunTag& AliRunTag::operator = (const AliRunTag& tag) {
//assignment operator
  if(&tag != this) {
    fAliceRunId               = tag.fAliceRunId ; 
    fAliceMagneticField       = tag.fAliceMagneticField ;
    fAliceDipoleField         = tag.fAliceDipoleField ;
    fAliceRunStartTime        = tag.fAliceRunStartTime ; 
    fAliceRunStopTime         = tag.fAliceRunStopTime ; 
    fAlirootVersion           = tag.fAlirootVersion ; 
    fRootVersion              = tag.fRootVersion ;
    fGeant3Version            = tag.fGeant3Version ; 
    fLHCPeriod                = tag.fLHCPeriod ; 
    fRecPass                  = tag.fRecPass ; 
    fProductionName           = tag.fProductionName ; 
    fAliceRunValidated        = tag.fAliceRunValidated ; 
    fAliceRunGlobalQuality    = tag.fAliceRunGlobalQuality ; 
    fAliceBeamEnergy          = tag.fAliceBeamEnergy ;
    fAliceBeamType            = tag.fAliceBeamType ; 
    fAliceCalibrationVersion  = tag.fAliceCalibrationVersion ; 
    fAliceDataType            = tag.fAliceDataType ; 
    //    fNumEvents                = tag.fNumEvents ;
    fNumFiles                 = tag.fNumFiles;
    fBeamTriggers             = tag.fBeamTriggers;
    fCollisionTriggers	      = tag.fCollisionTriggers;
    fEmptyTriggers	      = tag.fEmptyTriggers;
    fASideTriggers	      = tag.fASideTriggers;
    fCSideTriggers	      = tag.fCSideTriggers;
    fHMTriggers               = tag.fHMTriggers;
    fMuonTriggers             = tag.fMuonTriggers;
    fCollisionRate	      = tag.fCollisionRate;
    fMeanVertex		      = tag.fMeanVertex;
    fVertexQuality	      = tag.fVertexQuality;
    fNumDetectors             = tag.fNumDetectors ; 
    fDetectorTag              = tag.fDetectorTag ;
    fLHCTag                   = tag.fLHCTag ;  
    fActiveTriggerClasses     = tag.fActiveTriggerClasses;
    fQA                       = tag.fQA ;      
    fQALength                 = tag.fQALength ; 
    if (fQAArray) 
      delete [] fQAArray ; 
    if (fQALength == 0 ) 
      fQAArray = NULL ; 
    else {
      fQAArray = new ULong_t[fQALength] ; 
      memcpy(fQAArray, tag.fQAArray, fQALength*sizeof(ULong_t)) ;
    }
    fESLength                 = tag.fESLength ; 
    if (fEventSpecies)
      delete [] fEventSpecies ; 
    if (fESLength == 0 ) 
      fEventSpecies = NULL ; 
    else {
      fEventSpecies = new Bool_t[fESLength] ; 
      memcpy(fEventSpecies, tag.fEventSpecies, fESLength*sizeof(Bool_t)) ;
    }
    for (int ifl=0; ifl<fNumFiles; ifl++) {
      AddFileTag(new AliFileTag(*tag.GetFileTag(ifl)));
    }
//     for (int ifile=0; ifile<tag.GetFileTags()->GetEntries(); ifile++)
//       AddFileTag(*((AliFileTag *) tag.GetFileTags()->At(ifile)));
  }
  return *this ; 
}

//___________________________________________________________________________
void AliRunTag::CopyStandardContent(AliRunTag *oldtag) {
  //function that copies the run, lhc and detector levels
  SetRunId(oldtag->GetRunId());
  SetMagneticField(oldtag->GetMagneticField());
  SetDipoleField(oldtag->GetDipoleField());
  SetRunStartTime(oldtag->GetRunStartTime());
  SetRunStopTime(oldtag->GetRunStopTime());
  SetAlirootVersion(oldtag->GetAlirootVersion());
  SetRootVersion(oldtag->GetRootVersion());
  SetGeant3Version(oldtag->GetGeant3Version());
  SetLHCPeriod(oldtag->GetLHCPeriod());
  SetReconstructionPass(oldtag->GetReconstructionPass());
  SetProductionName(oldtag->GetProductionName());
  SetRunValidation(oldtag->GetRunValidation());
  SetRunQuality(oldtag->GetRunQuality());
  SetBeamEnergy(oldtag->GetBeamEnergy());
  SetBeamType(oldtag->GetBeamType());
  SetCalibVersion(oldtag->GetCalibVersion());
  SetDataType(oldtag->GetDataType());
  SetBeamTriggers(oldtag->GetBeamTriggers());
  SetCollisionTriggers(oldtag->GetCollisionTriggers());
  SetEmptyTriggers(oldtag->GetEmptyTriggers());
  SetASideTriggers(oldtag->GetASideTriggers());
  SetCSideTriggers(oldtag->GetCSideTriggers());
  SetHMTriggers(oldtag->GetHMTriggers());
  SetMuonTriggers(oldtag->GetMuonTriggers());
  SetCollisionRate(oldtag->GetCollisionRate());
  SetMeanVertex(oldtag->GetMeanVertex());
  SetVertexQuality(oldtag->GetVertexQuality());
  SetLHCTag(oldtag->GetLHCTag()->GetLuminosity(),oldtag->GetLHCTag()->GetLHCState());
  SetDetectorTag(oldtag->GetDetectorTags()->GetIntDetectorMaskDAQ(), oldtag->GetDetectorTags()->GetIntDetectorMaskReco());
  SetActiveTriggerClasses(oldtag->GetActiveTriggerClasses());
  SetQA(*(oldtag->GetQA())) ;  	
  SetQAArray(oldtag->GetQAArray(), oldtag->GetQALength()) ;  
  SetEventSpecies(oldtag->GetEventSpecies(), oldtag->GetESLength()) ;  
  for (int ifile=0; ifile<oldtag->GetNFiles(); ifile++) {
    AliFileTag *ntag = new AliFileTag();
    ntag->CopyFileInfo((const AliFileTag &) *(oldtag->GetFileTag(ifile)));
    AddFileTag(ntag);
  }
}

void AliRunTag::UpdateFromRunTable(AliRunTag *tabtag)
{
  SetBeamTriggers(tabtag->GetBeamTriggers());
  SetCollisionTriggers(tabtag->GetCollisionTriggers());
  SetEmptyTriggers(tabtag->GetEmptyTriggers());
  SetASideTriggers(tabtag->GetASideTriggers());
  SetCSideTriggers(tabtag->GetCSideTriggers());
  SetHMTriggers(tabtag->GetHMTriggers());
  SetMuonTriggers(tabtag->GetMuonTriggers());
  SetCollisionRate(tabtag->GetCollisionRate());
  SetMeanVertex(tabtag->GetMeanVertex());
  SetVertexQuality(tabtag->GetVertexQuality());
  SetRunQuality(tabtag->GetRunQuality());
  fLHCTag.UpdateFromRunTable(*tabtag->GetLHCTag());
  fDetectorTag.UpdateFromRunTable(*tabtag->GetDetectorTags());
}

//___________________________________________________________________________
void AliRunTag::SetQAArray(ULong_t * qa, Int_t qalength) {
  //Setter for the qa bits 
  if (qa && qalength > 0) {
    fQALength = qalength ; 
    if (fQAArray) 
      delete [] fQAArray ; 
    fQAArray = new ULong_t[qalength] ; 
    memcpy(fQAArray, qa, qalength*sizeof(ULong_t)) ;
  }
}

//___________________________________________________________________________
void AliRunTag::SetEventSpecies(Bool_t * es, Int_t eslength) {
  //setter for the eventspecices 
  if (es && eslength >0 ) {
    fESLength = eslength ; 
    if (fEventSpecies) 
      delete [] fEventSpecies ; 
    fEventSpecies = new Bool_t[eslength] ;
    memcpy(fEventSpecies, es, eslength*sizeof(Bool_t)) ; 
  }
}


//___________________________________________________________________________
void AliRunTag::SetLHCTag(Float_t lumin, TString type) {
  //Setter for the LHC tags
  fLHCTag.SetLuminosity(lumin);
  fLHCTag.SetLHCState(type);
}

//___________________________________________________________________________
void AliRunTag::SetDetectorTag(UInt_t mask, UInt_t maskReco) {
  //Setter for the detector tags
  fDetectorTag.SetDetectorMaskDAQ(mask);
  if (maskReco == 0)
    fDetectorTag.SetDetectorMaskReco(mask);
  else
    fDetectorTag.SetDetectorMaskReco(maskReco);

  int ndet = 0;
  for (int iter=0; iter<32; iter++)  
    ndet += (mask & (1 << iter)) > 0;
  
  fNumDetectors = ndet;
}

//___________________________________________________________________________
void AliRunTag::AddEventTag(const AliEventTag & EvTag) {
  //Adds an entry to the event tag TClonesArray
  ((AliFileTag *) fFileTags[fNumFiles-1])->AddEventTag(EvTag);
  //  new(fEventTag[fNumEvents++]) AliEventTag(EvTag);
}

void AliRunTag::AddFileTag(AliFileTag *t) {
  //Adds an entry for each file tag
  if (fNumFiles == fFileTags.GetSize()-1) fFileTags.Expand(fFileTags.GetSize()*2);
  //  new(fFileTags[fNumFiles++]) AliFileTag(t);
  fFileTags[fNumFiles++] = t;
}

//___________________________________________________________________________
void AliRunTag::Clear(const char *) {
  //Resets the number of events and detectors
  //  fEventTag.Delete();
  //  fNumEvents = 0;
  fFileTags.Delete();
  fNumFiles = 0;
  if ( fQAArray ) {
    delete [] fQAArray ;
    fQAArray = 0x0;
  } 
  fQALength=0;
  if ( fEventSpecies ) {
    delete [] fEventSpecies ;
    fEventSpecies = 0x0;
  } 
  fESLength=0;
}

const AliEventTag* AliRunTag::GetEventTag(int evt) const
{
  int curev = evt;
  int curf = 0;

  if (evt >= GetNEvents()) return 0;
 
  while (curev >= ((AliFileTag *) fFileTags[curf])->GetNEvents()) {
    curev -= ((AliFileTag *) fFileTags[curf])->GetNEvents();
    curf++;
  }
  return ((AliFileTag *) fFileTags[curf])->GetEventTag(curev);
}

AliFileTag *AliRunTag::GetFileTagForEvent(int evt) 
{
  // Returns FileTag in which the given event is
  int curev = evt;
  int curf = 0;

  if (evt >= GetNEvents()) return 0;
 
  while (curev >= ((AliFileTag *) fFileTags[curf])->GetNEvents()) {
    curev -= ((AliFileTag *) fFileTags[curf])->GetNEvents();
    curf++;
  }
  return (AliFileTag *) fFileTags[curf];
}

Int_t       AliRunTag::GetNEvents() const
{
  Int_t evtot = 0;
  for (int iter=0; iter<fNumFiles; iter++)
    evtot += ((AliFileTag *) fFileTags[iter])->GetNEvents();

  return evtot;
}

Int_t      AliRunTag::GetFileId(const char *guid)
{
  for (int iter=0; iter<fNumFiles; iter++) {
    if (!strcmp(((AliFileTag *) fFileTags[iter])->GetGUID(), guid))
      return iter;
  }
  return -1;
}
Commit	Line	Data
	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	/* $Id$ */
	17
	18	//-----------------------------------------------------------------
	19	// Implementation of the RunTag class
	20	// This is the class to deal with the tags in the run level
	21	// Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
	22	//-----------------------------------------------------------------
	23
	24	#include <stdlib.h>
	25	#include "AliRunTag.h"
	26	#include "AliDetectorTag.h"
	27	#include "AliEventTag.h"
	28
	29	ClassImp(AliRunTag)
	30
	31	//___________________________________________________________________________
	32	AliRunTag::AliRunTag() :
	33	TObject(),
	34	fAliceRunId(-1),
	35	fAliceMagneticField(0.0),
	36	fAliceDipoleField(0.0),
	37	fAliceRunStartTime(0),
	38	fAliceRunStopTime(0),
	39	fAlirootVersion(0),
	40	fRootVersion(0),
	41	fGeant3Version(0),
	42	fLHCPeriod(0),
	43	fRecPass(0),
	44	fProductionName(0),
	45	fAliceRunValidated(0),
	46	fAliceRunGlobalQuality(0),
	47	fAliceBeamEnergy(0.0),
	48	fAliceBeamType(0),
	49	fAliceCalibrationVersion(0),
	50	fAliceDataType(0),
	51	// fNumEvents(0),
	52	fNumFiles(0),
	53	fBeamTriggers(0),
	54	fCollisionTriggers(0),
	55	fEmptyTriggers(0),
	56	fASideTriggers(0),
	57	fCSideTriggers(0),
	58	fHMTriggers(0),
	59	fMuonTriggers(0),
	60	fCollisionRate(0.0),
	61	fMeanVertex(0.0),
	62	fVertexQuality(0.0),
	63	fNumDetectors(0),
	64	fFileTags(100),
	65	fDetectorTag(),
	66	fLHCTag(),
	67	fActiveTriggerClasses(""),
	68	fQA(),
	69	fQALength(0),
	70	fQAArray(NULL),
	71	fESLength(0),
	72	fEventSpecies(NULL)
	73	{
	74	//Default constructor
	75	}
	76
	77	//___________________________________________________________________________
	78	AliRunTag::~AliRunTag() {
	79	//Destructor
	80	// fEventTag.Delete();
	81	if ( fQAArray )
	82	delete [] fQAArray ;
	83	if ( fEventSpecies )
	84	delete [] fEventSpecies ;
	85	fFileTags.Delete();
	86	}
	87
	88	//___________________________________________________________________________
	89	AliRunTag::AliRunTag(const AliRunTag& tag):
	90	TObject(),
	91	fAliceRunId(tag.fAliceRunId),
	92	fAliceMagneticField(tag.fAliceMagneticField),
	93	fAliceDipoleField(tag.fAliceDipoleField),
	94	fAliceRunStartTime(tag.fAliceRunStartTime),
	95	fAliceRunStopTime(tag.fAliceRunStopTime),
	96	fAlirootVersion(tag.fAlirootVersion),
	97	fRootVersion(tag.fRootVersion),
	98	fGeant3Version(tag.fGeant3Version),
	99	fLHCPeriod(tag.fLHCPeriod),
	100	fRecPass(tag.fRecPass),
	101	fProductionName(tag.fProductionName),
	102	fAliceRunValidated(tag.fAliceRunValidated),
	103	fAliceRunGlobalQuality(tag.fAliceRunGlobalQuality),
	104	fAliceBeamEnergy(tag.fAliceBeamEnergy),
	105	fAliceBeamType(tag.fAliceBeamType),
	106	fAliceCalibrationVersion(tag.fAliceCalibrationVersion),
	107	fAliceDataType(tag.fAliceDataType),
	108	//fNumEvents(tag.fNumEvents),
	109	fNumFiles(0),
	110	fBeamTriggers(tag.fBeamTriggers),
	111	fCollisionTriggers(tag.fCollisionTriggers),
	112	fEmptyTriggers(tag.fEmptyTriggers),
	113	fASideTriggers(tag.fASideTriggers),
	114	fCSideTriggers(tag.fCSideTriggers),
	115	fHMTriggers(tag.fHMTriggers),
	116	fMuonTriggers(tag.fMuonTriggers),
	117	fCollisionRate(tag.fCollisionRate),
	118	fMeanVertex(tag.fMeanVertex),
	119	fVertexQuality(tag.fVertexQuality),
	120	fNumDetectors(tag.fNumDetectors),
	121	fFileTags(100),
	122	fDetectorTag(tag.fDetectorTag),
	123	fLHCTag(tag.fLHCTag),
	124	fActiveTriggerClasses(tag.fActiveTriggerClasses),
	125	fQA(tag.fQA),
	126	fQALength(tag.fQALength),
	127	fQAArray(NULL),
	128	fESLength(tag.fESLength),
	129	fEventSpecies(NULL)
	130	{
	131	//copy constructor
	132	if (fQALength == 0 )
	133	fQAArray = NULL ;
	134	else {
	135	fQAArray = new ULong_t[fQALength] ;
	136	memcpy(fQAArray, tag.fQAArray, fQALength*sizeof(ULong_t)) ;
	137	}
	138	if (fESLength == 0 )
	139	fEventSpecies = NULL ;
	140	else {
	141	fEventSpecies = new Bool_t[fESLength] ;
	142	memcpy(fEventSpecies, tag.fEventSpecies, fESLength*sizeof(Bool_t)) ;
	143	}
	144	for (int ifl=0; ifl<tag.fNumFiles; ifl++) {
	145	AddFileTag(new AliFileTag(*tag.GetFileTag(ifl)));
	146	}
	147
	148
	149	}
	150
	151	//___________________________________________________________________________
	152	AliRunTag& AliRunTag::operator = (const AliRunTag& tag) {
	153	//assignment operator
	154	if(&tag != this) {
	155	fAliceRunId = tag.fAliceRunId ;
	156	fAliceMagneticField = tag.fAliceMagneticField ;
	157	fAliceDipoleField = tag.fAliceDipoleField ;
	158	fAliceRunStartTime = tag.fAliceRunStartTime ;
	159	fAliceRunStopTime = tag.fAliceRunStopTime ;
	160	fAlirootVersion = tag.fAlirootVersion ;
	161	fRootVersion = tag.fRootVersion ;
	162	fGeant3Version = tag.fGeant3Version ;
	163	fLHCPeriod = tag.fLHCPeriod ;
	164	fRecPass = tag.fRecPass ;
	165	fProductionName = tag.fProductionName ;
	166	fAliceRunValidated = tag.fAliceRunValidated ;
	167	fAliceRunGlobalQuality = tag.fAliceRunGlobalQuality ;
	168	fAliceBeamEnergy = tag.fAliceBeamEnergy ;
	169	fAliceBeamType = tag.fAliceBeamType ;
	170	fAliceCalibrationVersion = tag.fAliceCalibrationVersion ;
	171	fAliceDataType = tag.fAliceDataType ;
	172	// fNumEvents = tag.fNumEvents ;
	173	fNumFiles = tag.fNumFiles;
	174	fBeamTriggers = tag.fBeamTriggers;
	175	fCollisionTriggers = tag.fCollisionTriggers;
	176	fEmptyTriggers = tag.fEmptyTriggers;
	177	fASideTriggers = tag.fASideTriggers;
	178	fCSideTriggers = tag.fCSideTriggers;
	179	fHMTriggers = tag.fHMTriggers;
	180	fMuonTriggers = tag.fMuonTriggers;
	181	fCollisionRate = tag.fCollisionRate;
	182	fMeanVertex = tag.fMeanVertex;
	183	fVertexQuality = tag.fVertexQuality;
	184	fNumDetectors = tag.fNumDetectors ;
	185	fDetectorTag = tag.fDetectorTag ;
	186	fLHCTag = tag.fLHCTag ;
	187	fActiveTriggerClasses = tag.fActiveTriggerClasses;
	188	fQA = tag.fQA ;
	189	fQALength = tag.fQALength ;
	190	if (fQAArray)
	191	delete [] fQAArray ;
	192	if (fQALength == 0 )
	193	fQAArray = NULL ;
	194	else {
	195	fQAArray = new ULong_t[fQALength] ;
	196	memcpy(fQAArray, tag.fQAArray, fQALength*sizeof(ULong_t)) ;
	197	}
	198	fESLength = tag.fESLength ;
	199	if (fEventSpecies)
	200	delete [] fEventSpecies ;
	201	if (fESLength == 0 )
	202	fEventSpecies = NULL ;
	203	else {
	204	fEventSpecies = new Bool_t[fESLength] ;
	205	memcpy(fEventSpecies, tag.fEventSpecies, fESLength*sizeof(Bool_t)) ;
	206	}
	207	for (int ifl=0; ifl<fNumFiles; ifl++) {
	208	AddFileTag(new AliFileTag(*tag.GetFileTag(ifl)));
	209	}
	210	// for (int ifile=0; ifile<tag.GetFileTags()->GetEntries(); ifile++)
	211	// AddFileTag(((AliFileTag ) tag.GetFileTags()->At(ifile)));
	212	}
	213	return *this ;
	214	}
	215
	216	//___________________________________________________________________________
	217	void AliRunTag::CopyStandardContent(AliRunTag *oldtag) {
	218	//function that copies the run, lhc and detector levels
	219	SetRunId(oldtag->GetRunId());
	220	SetMagneticField(oldtag->GetMagneticField());
	221	SetDipoleField(oldtag->GetDipoleField());
	222	SetRunStartTime(oldtag->GetRunStartTime());
	223	SetRunStopTime(oldtag->GetRunStopTime());
	224	SetAlirootVersion(oldtag->GetAlirootVersion());
	225	SetRootVersion(oldtag->GetRootVersion());
	226	SetGeant3Version(oldtag->GetGeant3Version());
	227	SetLHCPeriod(oldtag->GetLHCPeriod());
	228	SetReconstructionPass(oldtag->GetReconstructionPass());
	229	SetProductionName(oldtag->GetProductionName());
	230	SetRunValidation(oldtag->GetRunValidation());
	231	SetRunQuality(oldtag->GetRunQuality());
	232	SetBeamEnergy(oldtag->GetBeamEnergy());
	233	SetBeamType(oldtag->GetBeamType());
	234	SetCalibVersion(oldtag->GetCalibVersion());
	235	SetDataType(oldtag->GetDataType());
	236	SetBeamTriggers(oldtag->GetBeamTriggers());
	237	SetCollisionTriggers(oldtag->GetCollisionTriggers());
	238	SetEmptyTriggers(oldtag->GetEmptyTriggers());
	239	SetASideTriggers(oldtag->GetASideTriggers());
	240	SetCSideTriggers(oldtag->GetCSideTriggers());
	241	SetHMTriggers(oldtag->GetHMTriggers());
	242	SetMuonTriggers(oldtag->GetMuonTriggers());
	243	SetCollisionRate(oldtag->GetCollisionRate());
	244	SetMeanVertex(oldtag->GetMeanVertex());
	245	SetVertexQuality(oldtag->GetVertexQuality());
	246	SetLHCTag(oldtag->GetLHCTag()->GetLuminosity(),oldtag->GetLHCTag()->GetLHCState());
	247	SetDetectorTag(oldtag->GetDetectorTags()->GetIntDetectorMaskDAQ(), oldtag->GetDetectorTags()->GetIntDetectorMaskReco());
	248	SetActiveTriggerClasses(oldtag->GetActiveTriggerClasses());
	249	SetQA(*(oldtag->GetQA())) ;
	250	SetQAArray(oldtag->GetQAArray(), oldtag->GetQALength()) ;
	251	SetEventSpecies(oldtag->GetEventSpecies(), oldtag->GetESLength()) ;
	252	for (int ifile=0; ifile<oldtag->GetNFiles(); ifile++) {
	253	AliFileTag *ntag = new AliFileTag();
	254	ntag->CopyFileInfo((const AliFileTag &) *(oldtag->GetFileTag(ifile)));
	255	AddFileTag(ntag);
	256	}
	257	}
	258
	259	void AliRunTag::UpdateFromRunTable(AliRunTag *tabtag)
	260	{
	261	SetBeamTriggers(tabtag->GetBeamTriggers());
	262	SetCollisionTriggers(tabtag->GetCollisionTriggers());
	263	SetEmptyTriggers(tabtag->GetEmptyTriggers());
	264	SetASideTriggers(tabtag->GetASideTriggers());
	265	SetCSideTriggers(tabtag->GetCSideTriggers());
	266	SetHMTriggers(tabtag->GetHMTriggers());
	267	SetMuonTriggers(tabtag->GetMuonTriggers());
	268	SetCollisionRate(tabtag->GetCollisionRate());
	269	SetMeanVertex(tabtag->GetMeanVertex());
	270	SetVertexQuality(tabtag->GetVertexQuality());
	271	SetRunQuality(tabtag->GetRunQuality());
	272	fLHCTag.UpdateFromRunTable(*tabtag->GetLHCTag());
	273	fDetectorTag.UpdateFromRunTable(*tabtag->GetDetectorTags());
	274	}
	275
	276	//___________________________________________________________________________
	277	void AliRunTag::SetQAArray(ULong_t * qa, Int_t qalength) {
	278	//Setter for the qa bits
	279	if (qa && qalength > 0) {
	280	fQALength = qalength ;
	281	if (fQAArray)
	282	delete [] fQAArray ;
	283	fQAArray = new ULong_t[qalength] ;
	284	memcpy(fQAArray, qa, qalength*sizeof(ULong_t)) ;
	285	}
	286	}
	287
	288	//___________________________________________________________________________
	289	void AliRunTag::SetEventSpecies(Bool_t * es, Int_t eslength) {
	290	//setter for the eventspecices
	291	if (es && eslength >0 ) {
	292	fESLength = eslength ;
	293	if (fEventSpecies)
	294	delete [] fEventSpecies ;
	295	fEventSpecies = new Bool_t[eslength] ;
	296	memcpy(fEventSpecies, es, eslength*sizeof(Bool_t)) ;
	297	}
	298	}
	299
	300
	301	//___________________________________________________________________________
	302	void AliRunTag::SetLHCTag(Float_t lumin, TString type) {
	303	//Setter for the LHC tags
	304	fLHCTag.SetLuminosity(lumin);
	305	fLHCTag.SetLHCState(type);
	306	}
	307
	308	//___________________________________________________________________________
	309	void AliRunTag::SetDetectorTag(UInt_t mask, UInt_t maskReco) {
	310	//Setter for the detector tags
	311	fDetectorTag.SetDetectorMaskDAQ(mask);
	312	if (maskReco == 0)
	313	fDetectorTag.SetDetectorMaskReco(mask);
	314	else
	315	fDetectorTag.SetDetectorMaskReco(maskReco);
	316
	317	int ndet = 0;
	318	for (int iter=0; iter<32; iter++)
	319	ndet += (mask & (1 << iter)) > 0;
	320
	321	fNumDetectors = ndet;
	322	}
	323
	324	//___________________________________________________________________________
	325	void AliRunTag::AddEventTag(const AliEventTag & EvTag) {
	326	//Adds an entry to the event tag TClonesArray
	327	((AliFileTag *) fFileTags[fNumFiles-1])->AddEventTag(EvTag);
	328	// new(fEventTag[fNumEvents++]) AliEventTag(EvTag);
	329	}
	330
	331	void AliRunTag::AddFileTag(AliFileTag *t) {
	332	//Adds an entry for each file tag
	333	if (fNumFiles == fFileTags.GetSize()-1) fFileTags.Expand(fFileTags.GetSize()*2);
	334	// new(fFileTags[fNumFiles++]) AliFileTag(t);
	335	fFileTags[fNumFiles++] = t;
	336	}
	337
	338	//___________________________________________________________________________
	339	void AliRunTag::Clear(const char *) {
	340	//Resets the number of events and detectors
	341	// fEventTag.Delete();
	342	// fNumEvents = 0;
	343	fFileTags.Delete();
	344	fNumFiles = 0;
	345	if ( fQAArray ) {
	346	delete [] fQAArray ;
	347	fQAArray = 0x0;
	348	}
	349	fQALength=0;
	350	if ( fEventSpecies ) {
	351	delete [] fEventSpecies ;
	352	fEventSpecies = 0x0;
	353	}
	354	fESLength=0;
	355	}
	356
	357	const AliEventTag* AliRunTag::GetEventTag(int evt) const
	358	{
	359	int curev = evt;
	360	int curf = 0;
	361
	362	if (evt >= GetNEvents()) return 0;
	363
	364	while (curev >= ((AliFileTag *) fFileTags[curf])->GetNEvents()) {
	365	curev -= ((AliFileTag *) fFileTags[curf])->GetNEvents();
	366	curf++;
	367	}
	368	return ((AliFileTag *) fFileTags[curf])->GetEventTag(curev);
	369	}
	370
	371	AliFileTag *AliRunTag::GetFileTagForEvent(int evt)
	372	{
	373	// Returns FileTag in which the given event is
	374	int curev = evt;
	375	int curf = 0;
	376
	377	if (evt >= GetNEvents()) return 0;
	378
	379	while (curev >= ((AliFileTag *) fFileTags[curf])->GetNEvents()) {
	380	curev -= ((AliFileTag *) fFileTags[curf])->GetNEvents();
	381	curf++;
	382	}
	383	return (AliFileTag *) fFileTags[curf];
	384	}
	385
	386	Int_t AliRunTag::GetNEvents() const
	387	{
	388	Int_t evtot = 0;
	389	for (int iter=0; iter<fNumFiles; iter++)
	390	evtot += ((AliFileTag *) fFileTags[iter])->GetNEvents();
	391
	392	return evtot;
	393	}
	394
	395	Int_t AliRunTag::GetFileId(const char *guid)
	396	{
	397	for (int iter=0; iter<fNumFiles; iter++) {
	398	if (!strcmp(((AliFileTag *) fFileTags[iter])->GetGUID(), guid))
	399	return iter;
	400	}
	401	return -1;
	402	}
	403