[u/mrichter/AliRoot.git] / STEER / 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
f3a97c86	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
04cb11d4	24	#include <stdlib.h>
f3a97c86	25	#include "AliRunTag.h"
f3a97c86	26	#include "AliDetectorTag.h"
	27	#include "AliEventTag.h"
	28
	29	ClassImp(AliRunTag)
	30
bec9a2e7	31	//___________________________________________________________________________
17a9d008	32	AliRunTag::AliRunTag() :
	33	TObject(),
	34	fAliceRunId(-1),
	35	fAliceMagneticField(0.0),
850d5792	36	fAliceDipoleField(0.0),
17a9d008	37	fAliceRunStartTime(0),
17a9d008	38	fAliceRunStopTime(0),
bec9a2e7	39	fAlirootVersion(0),
	40	fRootVersion(0),
	41	fGeant3Version(0),
850d5792	42	fLHCPeriod(0),
	43	fRecPass(0),
	44	fProductionName(0),
04cb11d4	45	fAliceRunValidated(0),
04cb11d4	46	fAliceRunGlobalQuality(0),
17a9d008	47	fAliceBeamEnergy(0.0),
bec9a2e7	48	fAliceBeamType(0),
17a9d008	49	fAliceCalibrationVersion(0),
17a9d008	50	fAliceDataType(0),
04cb11d4	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),
17a9d008	63	fNumDetectors(0),
04cb11d4	64	fFileTags(100),
c5caed45	65	fDetectorTag(),
46af88be	66	fLHCTag(),
04cb11d4	67	fActiveTriggerClasses(""),
9ee5d033	68	fQA(),
27293674	69	fQALength(0),
9ee5d033	70	fQAArray(NULL),
27293674	71	fESLength(0),
27293674	72	fEventSpecies(NULL)
f3a97c86	73	{
e16601cf	74	//Default constructor
f3a97c86	75	}
f3a97c86	76
bec9a2e7	77	//___________________________________________________________________________
bec9a2e7	78	AliRunTag::~AliRunTag() {
17a9d008	79	//Destructor
04cb11d4	80	// fEventTag.Delete();
9ee5d033	81	if ( fQAArray )
9ee5d033	82	delete [] fQAArray ;
27293674	83	if ( fEventSpecies )
27293674	84	delete [] fEventSpecies ;
04cb11d4	85	fFileTags.Delete();
27293674	86	}
	87
	88	//___________________________________________________________________________
	89	AliRunTag::AliRunTag(const AliRunTag& tag):
	90	TObject(),
	91	fAliceRunId(tag.fAliceRunId),
	92	fAliceMagneticField(tag.fAliceMagneticField),
850d5792	93	fAliceDipoleField(tag.fAliceDipoleField),
27293674	94	fAliceRunStartTime(tag.fAliceRunStartTime),
b28939aa	95	fAliceRunStopTime(tag.fAliceRunStopTime),
27293674	96	fAlirootVersion(tag.fAlirootVersion),
	97	fRootVersion(tag.fRootVersion),
	98	fGeant3Version(tag.fGeant3Version),
850d5792	99	fLHCPeriod(tag.fLHCPeriod),
	100	fRecPass(tag.fRecPass),
	101	fProductionName(tag.fProductionName),
04cb11d4	102	fAliceRunValidated(tag.fAliceRunValidated),
04cb11d4	103	fAliceRunGlobalQuality(tag.fAliceRunGlobalQuality),
27293674	104	fAliceBeamEnergy(tag.fAliceBeamEnergy),
	105	fAliceBeamType(tag.fAliceBeamType),
	106	fAliceCalibrationVersion(tag.fAliceCalibrationVersion),
	107	fAliceDataType(tag.fAliceDataType),
04cb11d4	108	//fNumEvents(tag.fNumEvents),
bfc9ff63	109	fNumFiles(0),
04cb11d4	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),
27293674	120	fNumDetectors(tag.fNumDetectors),
04cb11d4	121	fFileTags(100),
27293674	122	fDetectorTag(tag.fDetectorTag),
27293674	123	fLHCTag(tag.fLHCTag),
04cb11d4	124	fActiveTriggerClasses(tag.fActiveTriggerClasses),
9ee5d033	125	fQA(tag.fQA),
27293674	126	fQALength(tag.fQALength),
9ee5d033	127	fQAArray(NULL),
27293674	128	fESLength(tag.fESLength),
	129	fEventSpecies(NULL)
	130	{
	131	//copy constructor
	132	if (fQALength == 0 )
9ee5d033	133	fQAArray = NULL ;
27293674	134	else {
9ee5d033	135	fQAArray = new ULong_t[fQALength] ;
9ee5d033	136	memcpy(fQAArray, tag.fQAArray, fQALength*sizeof(ULong_t)) ;
27293674	137	}
	138	if (fESLength == 0 )
	139	fEventSpecies = NULL ;
	140	else {
e1ffd6bc	141	fEventSpecies = new Bool_t[fESLength] ;
27293674	142	memcpy(fEventSpecies, tag.fEventSpecies, fESLength*sizeof(Bool_t)) ;
27293674	143	}
bfc9ff63	144	for (int ifl=0; ifl<tag.fNumFiles; ifl++) {
bfc9ff63	145	AddFileTag(new AliFileTag(*tag.GetFileTag(ifl)));
04cb11d4	146	}
	147
	148
27293674	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 ;
850d5792	157	fAliceDipoleField = tag.fAliceDipoleField ;
27293674	158	fAliceRunStartTime = tag.fAliceRunStartTime ;
	159	fAliceRunStopTime = tag.fAliceRunStopTime ;
	160	fAlirootVersion = tag.fAlirootVersion ;
	161	fRootVersion = tag.fRootVersion ;
	162	fGeant3Version = tag.fGeant3Version ;
850d5792	163	fLHCPeriod = tag.fLHCPeriod ;
	164	fRecPass = tag.fRecPass ;
	165	fProductionName = tag.fProductionName ;
04cb11d4	166	fAliceRunValidated = tag.fAliceRunValidated ;
04cb11d4	167	fAliceRunGlobalQuality = tag.fAliceRunGlobalQuality ;
27293674	168	fAliceBeamEnergy = tag.fAliceBeamEnergy ;
	169	fAliceBeamType = tag.fAliceBeamType ;
	170	fAliceCalibrationVersion = tag.fAliceCalibrationVersion ;
	171	fAliceDataType = tag.fAliceDataType ;
04cb11d4	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;
27293674	184	fNumDetectors = tag.fNumDetectors ;
27293674	185	fDetectorTag = tag.fDetectorTag ;
27293674	186	fLHCTag = tag.fLHCTag ;
04cb11d4	187	fActiveTriggerClasses = tag.fActiveTriggerClasses;
9ee5d033	188	fQA = tag.fQA ;
27293674	189	fQALength = tag.fQALength ;
9ee5d033	190	if (fQAArray)
9ee5d033	191	delete [] fQAArray ;
27293674	192	if (fQALength == 0 )
9ee5d033	193	fQAArray = NULL ;
27293674	194	else {
9ee5d033	195	fQAArray = new ULong_t[fQALength] ;
9ee5d033	196	memcpy(fQAArray, tag.fQAArray, fQALength*sizeof(ULong_t)) ;
27293674	197	}
	198	fESLength = tag.fESLength ;
	199	if (fEventSpecies)
	200	delete [] fEventSpecies ;
	201	if (fESLength == 0 )
	202	fEventSpecies = NULL ;
	203	else {
e1ffd6bc	204	fEventSpecies = new Bool_t[fESLength] ;
27293674	205	memcpy(fEventSpecies, tag.fEventSpecies, fESLength*sizeof(Bool_t)) ;
27293674	206	}
04cb11d4	207	for (int ifl=0; ifl<fNumFiles; ifl++) {
bfc9ff63	208	AddFileTag(new AliFileTag(*tag.GetFileTag(ifl)));
04cb11d4	209	}
	210	// for (int ifile=0; ifile<tag.GetFileTags()->GetEntries(); ifile++)
	211	// AddFileTag(((AliFileTag ) tag.GetFileTags()->At(ifile)));
27293674	212	}
27293674	213	return *this ;
f3a97c86	214	}
f3a97c86	215
4c117ffd	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());
850d5792	221	SetDipoleField(oldtag->GetDipoleField());
4c117ffd	222	SetRunStartTime(oldtag->GetRunStartTime());
	223	SetRunStopTime(oldtag->GetRunStopTime());
	224	SetAlirootVersion(oldtag->GetAlirootVersion());
	225	SetRootVersion(oldtag->GetRootVersion());
	226	SetGeant3Version(oldtag->GetGeant3Version());
850d5792	227	SetLHCPeriod(oldtag->GetLHCPeriod());
	228	SetReconstructionPass(oldtag->GetReconstructionPass());
	229	SetProductionName(oldtag->GetProductionName());
04cb11d4	230	SetRunValidation(oldtag->GetRunValidation());
4c117ffd	231	SetRunQuality(oldtag->GetRunQuality());
	232	SetBeamEnergy(oldtag->GetBeamEnergy());
	233	SetBeamType(oldtag->GetBeamType());
	234	SetCalibVersion(oldtag->GetCalibVersion());
	235	SetDataType(oldtag->GetDataType());
04cb11d4	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());
4c117ffd	246	SetLHCTag(oldtag->GetLHCTag()->GetLuminosity(),oldtag->GetLHCTag()->GetLHCState());
3ace8f92	247	SetDetectorTag(oldtag->GetDetectorTags()->GetIntDetectorMaskDAQ(), oldtag->GetDetectorTags()->GetIntDetectorMaskReco());
04cb11d4	248	SetActiveTriggerClasses(oldtag->GetActiveTriggerClasses());
9ee5d033	249	SetQA(*(oldtag->GetQA())) ;
9ee5d033	250	SetQAArray(oldtag->GetQAArray(), oldtag->GetQALength()) ;
850d5792	251	SetEventSpecies(oldtag->GetEventSpecies(), oldtag->GetESLength()) ;
04cb11d4	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());
4c117ffd	274	}
4c117ffd	275
27293674	276	//___________________________________________________________________________
9ee5d033	277	void AliRunTag::SetQAArray(ULong_t * qa, Int_t qalength) {
27293674	278	//Setter for the qa bits
e1ffd6bc	279	if (qa && qalength > 0) {
e1ffd6bc	280	fQALength = qalength ;
9ee5d033	281	if (fQAArray)
	282	delete [] fQAArray ;
	283	fQAArray = new ULong_t[qalength] ;
	284	memcpy(fQAArray, qa, qalength*sizeof(ULong_t)) ;
e1ffd6bc	285	}
27293674	286	}
	287
	288	//___________________________________________________________________________
	289	void AliRunTag::SetEventSpecies(Bool_t * es, Int_t eslength) {
	290	//setter for the eventspecices
e1ffd6bc	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	}
27293674	298	}
	299
	300
bec9a2e7	301	//___________________________________________________________________________
c5caed45	302	void AliRunTag::SetLHCTag(Float_t lumin, TString type) {
e16601cf	303	//Setter for the LHC tags
04cb11d4	304	fLHCTag.SetLuminosity(lumin);
04cb11d4	305	fLHCTag.SetLHCState(type);
f3a97c86	306	}
f3a97c86	307
bec9a2e7	308	//___________________________________________________________________________
3ace8f92	309	void AliRunTag::SetDetectorTag(UInt_t mask, UInt_t maskReco) {
e16601cf	310	//Setter for the detector tags
3ace8f92	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;
f3a97c86	322	}
f3a97c86	323
bec9a2e7	324	//___________________________________________________________________________
bec9a2e7	325	void AliRunTag::AddEventTag(const AliEventTag & EvTag) {
e16601cf	326	//Adds an entry to the event tag TClonesArray
04cb11d4	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
bfc9ff63	333	if (fNumFiles == fFileTags.GetSize()-1) fFileTags.Expand(fFileTags.GetSize()*2);
04cb11d4	334	// new(fFileTags[fNumFiles++]) AliFileTag(t);
bfc9ff63	335	fFileTags[fNumFiles++] = t;
f3a97c86	336	}
f3a97c86	337
bec9a2e7	338	//___________________________________________________________________________
bec9a2e7	339	void AliRunTag::Clear(const char *) {
e16601cf	340	//Resets the number of events and detectors
04cb11d4	341	// fEventTag.Delete();
	342	// fNumEvents = 0;
	343	fFileTags.Delete();
	344	fNumFiles = 0;
a9d95c96	345	if ( fQAArray ) {
	346	delete [] fQAArray ;
	347	fQAArray = 0x0;
	348	}
b9f60f9d	349	fQALength=0;
a9d95c96	350	if ( fEventSpecies ) {
	351	delete [] fEventSpecies ;
	352	fEventSpecies = 0x0;
	353	}
b9f60f9d	354	fESLength=0;
f3a97c86	355	}
04cb11d4	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
ee6d9bb3	364	while (curev >= ((AliFileTag *) fFileTags[curf])->GetNEvents()) {
04cb11d4	365	curev -= ((AliFileTag *) fFileTags[curf])->GetNEvents();
ee6d9bb3	366	curf++;
04cb11d4	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
ee6d9bb3	379	while (curev >= ((AliFileTag *) fFileTags[curf])->GetNEvents()) {
04cb11d4	380	curev -= ((AliFileTag *) fFileTags[curf])->GetNEvents();
ee6d9bb3	381	curf++;
04cb11d4	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++) {
c035cce6	398	if (!strcmp(((AliFileTag *) fFileTags[iter])->GetGUID(), guid))
04cb11d4	399	return iter;
	400	}
	401	return -1;
	402	}
	403