//_____________________________________________________________________________
AliAlignObj::AliAlignObj():
+ fVolPath(),
fVolUID(0)
{
// default constructor
}
//_____________________________________________________________________________
-AliAlignObj::AliAlignObj(const char* volpath, UShort_t voluid) : TObject()
+AliAlignObj::AliAlignObj(const char* volpath, UShort_t voluid) :
+ TObject(),
+ fVolPath(volpath),
+ fVolUID(voluid)
{
// standard constructor
//
- fVolPath=volpath;
- fVolUID=voluid;
}
-AliAlignObj::AliAlignObj(const char* volpath, ELayerID detId, Int_t volId) : TObject()
+AliAlignObj::AliAlignObj(const char* volpath, ELayerID detId, Int_t volId) :
+ TObject(),
+ fVolPath(volpath),
+ fVolUID(0)
{
// standard constructor
//
- fVolPath=volpath;
SetVolUID(detId,volId);
}
//_____________________________________________________________________________
AliAlignObj::AliAlignObj(const AliAlignObj& theAlignObj) :
- TObject(theAlignObj)
+ TObject(theAlignObj),
+ fVolPath(theAlignObj.GetVolPath()),
+ fVolUID(theAlignObj.GetVolUID())
{
//copy constructor
- fVolPath = theAlignObj.GetVolPath();
- fVolUID = theAlignObj.GetVolUID();
}
//_____________________________________________________________________________
ClassImp(AliAlignObjMatrix)
//_____________________________________________________________________________
-AliAlignObjMatrix::AliAlignObjMatrix() : AliAlignObj()
+AliAlignObjMatrix::AliAlignObjMatrix() :
+ AliAlignObj(),
+ fMatrix()
{
// Default constructor
//
}
//_____________________________________________________________________________
-AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, UShort_t voluid, Double_t x, Double_t y, Double_t z, Double_t psi, Double_t theta, Double_t phi) : AliAlignObj(volpath, voluid)
+AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, UShort_t voluid, Double_t x, Double_t y, Double_t z, Double_t psi, Double_t theta, Double_t phi) :
+ AliAlignObj(volpath, voluid),
+ fMatrix()
{
// standard constructor with 3 translation + 3 rotation parameters
//
}
//_____________________________________________________________________________
-AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, ELayerID layerId, Int_t volId, Double_t x, Double_t y, Double_t z, Double_t psi, Double_t theta, Double_t phi, Bool_t global) throw (const Char_t *) : AliAlignObj(volpath,layerId,volId)
+AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, ELayerID layerId, Int_t volId, Double_t x, Double_t y, Double_t z, Double_t psi, Double_t theta, Double_t phi, Bool_t global) throw (const Char_t *) :
+ AliAlignObj(volpath,layerId,volId),
+ fMatrix()
{
// standard constructor with 3 translation + 3 rotation parameters
// If the user explicitly sets the global variable to kFALSE then the
//_____________________________________________________________________________
-AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, UShort_t volUID, TGeoMatrix& m) : AliAlignObj(volpath,volUID)
+AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, UShort_t volUID, TGeoMatrix& m) :
+ AliAlignObj(volpath,volUID),
+ fMatrix()
{
// standard constructor with TGeoMatrix
//
}
//_____________________________________________________________________________
-AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, ELayerID layerId, Int_t volId, TGeoMatrix& m) : AliAlignObj(volpath,layerId,volId)
+AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, ELayerID layerId, Int_t volId, TGeoMatrix& m) :
+ AliAlignObj(volpath,layerId,volId),
+ fMatrix()
{
// standard constructor with TGeoMatrix
//
//_____________________________________________________________________________
AliAlignObjMatrix::AliAlignObjMatrix(const AliAlignObj& theAlignObj) :
- AliAlignObj(theAlignObj)
+ AliAlignObj(theAlignObj),
+ fMatrix()
{
//copy constructor
//
private:
+ AliCDBDump(const AliCDBDump & source);
+ AliCDBDump & operator=(const AliCDBDump & source);
AliCDBDump(const char* dbFile, Bool_t readOnly);
virtual ~AliCDBDump();
private:
+ AliCDBLocal(const AliCDBLocal & source);
+ AliCDBLocal & operator=(const AliCDBLocal & source);
AliCDBLocal(const char* baseDir);
virtual ~AliCDBLocal();
//_____________________________________________________________________________
AliCDBManager::AliCDBManager():
- fDefaultStorage(NULL),
- fDrainStorage(NULL),
- fCache(kTRUE),
- fRun(-1)
+ TObject(),
+ fFactories(),
+ fActiveStorages(),
+ fSpecificStorages(),
+ fDefaultStorage(NULL),
+ fDrainStorage(NULL),
+ fEntryCache(),
+ fCache(kTRUE),
+ fRun(-1)
{
// default constuctor
fFactories.SetOwner(1);
///////////////////////////////////////////////////////////
AliCDBParam::AliCDBParam():
-fType(), fURI()
+ fType(),
+ fURI()
{
// constructor
private:
AliCDBManager();
+ AliCDBManager(const AliCDBManager & source);
+ AliCDBManager & operator=(const AliCDBManager & source);
+
static AliCDBManager* fgInstance; // AliCDBManager instance
AliCDBStorage* GetActiveStorage(const AliCDBParam* param);
fResponsible(""),
fBeamPeriod(0),
fAliRootVersion(""),
-fComment("")
+fComment(""),
+fProperties()
{
// default constructor
//_____________________________________________________________________________
AliCDBPath::AliCDBPath() :
-fIsValid(kTRUE),
-fIsWildcard(kFALSE)
+ TObject(),
+ fPath(""),
+ fLevel0(""),
+ fLevel1(""),
+ fLevel2(""),
+ fIsValid(kTRUE),
+ fIsWildcard(kFALSE)
{
// default constructor
//_____________________________________________________________________________
AliCDBPath::AliCDBPath(const AliCDBPath& other):
-TObject(other),
-fPath(other.fPath)
+ TObject(other),
+ fPath(other.fPath),
+ fLevel0(""),
+ fLevel1(""),
+ fLevel2(""),
+ fIsValid(other.fIsValid),
+ fIsWildcard(other.fIsWildcard)
{
// constructor
Init();
//_____________________________________________________________________________
AliCDBPath::AliCDBPath(const char* level0, const char* level1,
const char* level2):
-fLevel0(level0),
-fLevel1(level1),
-fLevel2(level2)
+ TObject(),
+ fPath(""),
+ fLevel0(level0),
+ fLevel1(level1),
+ fLevel2(level2),
+ fIsValid(kTRUE),
+ fIsWildcard(kFALSE)
{
// constructor
//_____________________________________________________________________________
AliCDBPath::AliCDBPath(const char* path):
-fPath(path)
+ TObject(),
+ fPath(path),
+ fLevel0(""),
+ fLevel1(""),
+ fLevel2(""),
+ fIsValid(kTRUE),
+ fIsWildcard(kFALSE)
{
// constructor
//_____________________________________________________________________________
AliCDBPath::AliCDBPath(const TString& path):
-fPath(path)
+ TObject(),
+ fPath(path),
+ fLevel0(""),
+ fLevel1(""),
+ fLevel2(""),
+ fIsValid(kTRUE),
+ fIsWildcard(kFALSE)
{
Init();
InitPath();
TString fType; //! Local, Grid: base folder name - Dump: file name
TString fBaseFolder; //! Local, Grid: base folder name - Dump: file name
+ private:
+ AliCDBStorage(const AliCDBStorage & source);
+ AliCDBStorage & operator=(const AliCDBStorage & source);
+
ClassDef(AliCDBStorage, 0);
};
ClassDef(AliCascadeVertexer,1) // cascade verterxer
};
-inline AliCascadeVertexer::AliCascadeVertexer() {
- fChi2max=33.;
- fDV0min=0.015; fMassWin=0.05; fDBachMin=0.015;
- fDCAmax=0.01; fCPAmax=0.025;
- fRmin=0.5; fRmax=2.5;
+inline AliCascadeVertexer::AliCascadeVertexer() :
+ TObject(),
+ fChi2max(33.),
+ fDV0min(0.015),
+ fMassWin(0.05),
+ fDBachMin(0.015),
+ fDCAmax(0.01),
+ fCPAmax(0.025),
+ fRmin(0.5),
+ fRmax(2.5),
+ fX(0),
+ fY(0),
+ fZ(0)
+{
}
-inline AliCascadeVertexer::AliCascadeVertexer(const Double_t cuts[8]) {
- fChi2max=cuts[0];
- fDV0min=cuts[1]; fMassWin=cuts[2]; fDBachMin=cuts[3];
- fDCAmax=cuts[4]; fCPAmax=cuts[5];
- fRmin=cuts[6]; fRmax=cuts[7];
- fX=fY=fZ=0.;
+inline AliCascadeVertexer::AliCascadeVertexer(const Double_t cuts[8]) :
+ TObject(),
+ fChi2max(cuts[0]),
+ fDV0min(cuts[1]),
+ fMassWin(cuts[2]),
+ fDBachMin(cuts[3]),
+ fDCAmax(cuts[4]),
+ fCPAmax(cuts[5]),
+ fRmin(cuts[6]),
+ fRmax(cuts[7]),
+ fX(0),
+ fY(0),
+ fZ(0)
+{
}
inline void AliCascadeVertexer::SetCuts(const Double_t cuts[8]) {
/*
$Log$
+Revision 1.3 2006/07/20 09:43:46 jgrosseo
+removing dynamic types
+
Revision 1.2 2006/07/04 14:58:11 jgrosseo
revision of AliDCSValue: Removed wrapper classes, reduced storage size per value by factor 2
ClassImp(AliDCSValue)
-AliDCSValue::AliDCSValue() : TObject()
+AliDCSValue::AliDCSValue() :
+ TObject(),
+ fType(kInvalid),
+ fBool(kFALSE),
+ fChar(0),
+ fInt(0),
+ fUInt(0),
+ fFloat(0),
+ fTimeStamp(0)
{
// default constructor
-
- Init();
}
-AliDCSValue::AliDCSValue(Bool_t value, UInt_t timeStamp) : TObject()
+AliDCSValue::AliDCSValue(Bool_t value, UInt_t timeStamp) :
+ TObject(),
+ fType(kBool),
+ fBool(value),
+ fChar(0),
+ fInt(0),
+ fUInt(0),
+ fFloat(0),
+ fTimeStamp(timeStamp)
{
// constructor
-
- Init();
-
- fTimeStamp = timeStamp;
-
- fType = kBool;
- fBool = value;
}
-AliDCSValue::AliDCSValue(Char_t value, UInt_t timeStamp) : TObject()
+AliDCSValue::AliDCSValue(Char_t value, UInt_t timeStamp) :
+ TObject(),
+ fType(kChar),
+ fBool(kFALSE),
+ fChar(value),
+ fInt(0),
+ fUInt(0),
+ fFloat(0),
+ fTimeStamp(timeStamp)
{
// constructor
-
- Init();
-
- fTimeStamp = timeStamp;
-
- fType = kChar;
- fChar = value;
}
-AliDCSValue::AliDCSValue(Int_t value, UInt_t timeStamp) : TObject()
+AliDCSValue::AliDCSValue(Int_t value, UInt_t timeStamp) :
+ TObject(),
+ fType(kInt),
+ fBool(kFALSE),
+ fChar(0),
+ fInt(value),
+ fUInt(0),
+ fFloat(0),
+ fTimeStamp(timeStamp)
{
// constructor
-
- Init();
-
- fTimeStamp = timeStamp;
-
- fType = kInt;
- fInt = value;
}
-AliDCSValue::AliDCSValue(UInt_t value, UInt_t timeStamp) : TObject()
+AliDCSValue::AliDCSValue(UInt_t value, UInt_t timeStamp) :
+ TObject(),
+ fType(kUInt),
+ fBool(kFALSE),
+ fChar(0),
+ fInt(0),
+ fUInt(value),
+ fFloat(0),
+ fTimeStamp(timeStamp)
{
// constructor
-
- Init();
-
- fTimeStamp = timeStamp;
-
- fType = kUInt;
- fUInt = value;
}
-AliDCSValue::AliDCSValue(Float_t value, UInt_t timeStamp) : TObject()
+AliDCSValue::AliDCSValue(Float_t value, UInt_t timeStamp) :
+ TObject(),
+ fType(kFloat),
+ fBool(kFALSE),
+ fChar(0),
+ fInt(0),
+ fUInt(0),
+ fFloat(value),
+ fTimeStamp(timeStamp)
{
// constructor
fFloat = value;
}
-AliDCSValue::AliDCSValue(const AliDCSValue& c) : TObject(c)
+AliDCSValue::AliDCSValue(const AliDCSValue& c) :
+ TObject(c),
+ fType(c.fType),
+ fBool(c.fBool),
+ fChar(c.fChar),
+ fInt(c.fInt),
+ fUInt(c.fUInt),
+ fFloat(c.fFloat),
+ fTimeStamp(c.fTimeStamp)
{
// copy constructor
-
- ((AliDCSValue &)c).Copy(*this);
}
void AliDCSValue::Init()
ClassImp(AliDetectorTag)
//___________________________________________________________________________
- AliDetectorTag::AliDetectorTag() :
- TObject(),
- fITS(kFALSE),
- fTPC(kFALSE),
- fTRD(kFALSE),
- fTOF(kFALSE),
- fHMPID(kFALSE),
- fPHOS(kFALSE),
- fZDC(kFALSE),
- fMUON(kFALSE),
- fPMD(kFALSE),
- fEMCAL(kFALSE),
- fVZERO(kFALSE),
- fTZERO(kFALSE)
+AliDetectorTag::AliDetectorTag() :
+ TObject(),
+ fITS(kFALSE),
+ fTPC(kFALSE),
+ fTRD(kFALSE),
+ fTOF(kFALSE),
+ fHMPID(kFALSE),
+ fPHOS(kFALSE),
+ fZDC(kFALSE),
+ fMUON(kFALSE),
+ fPMD(kFALSE),
+ fEMCAL(kFALSE),
+ fVZERO(kFALSE),
+ fTZERO(kFALSE)
{
// Default constructor
}
//___________________________________________________________________________
-AliDetectorTag::AliDetectorTag(const AliDetectorTag & detTag) : TObject(detTag) {
+AliDetectorTag::AliDetectorTag(const AliDetectorTag & detTag) :
+ TObject(detTag),
+ fITS(detTag.fITS),
+ fTPC(detTag.fTPC),
+ fTRD(detTag.fTRD),
+ fTOF(detTag.fTOF),
+ fHMPID(detTag.fHMPID),
+ fPHOS(detTag.fPHOS),
+ fZDC(detTag.fZDC),
+ fMUON(detTag.fMUON),
+ fPMD(detTag.fPMD),
+ fEMCAL(detTag.fEMCAL),
+ fVZERO(detTag.fVZERO),
+ fTZERO(detTag.fTZERO)
+ {
// DetectorTag copy constructor
- SetITS();
- SetTPC();
- SetTRD();
- SetTOF();
- SetHMPID();
- SetPHOS();
- SetZDC();
- SetMUON();
- SetPMD();
- SetEMCAL();
- SetVZERO();
- SetTZERO();
}
//___________________________________________________________________________
if (this != &detTag) {
TObject::operator=(detTag);
- SetITS();
- SetTPC();
- SetTRD();
- SetTOF();
- SetHMPID();
- SetPHOS();
- SetZDC();
- SetMUON();
- SetPMD();
- SetEMCAL();
- SetVZERO();
- SetTZERO();
+ fITS = detTag.fITS;
+ fTPC = detTag.fTPC;
+ fTRD = detTag.fTRD;
+ fTOF = detTag.fTOF;
+ fHMPID = detTag.fHMPID;
+ fPHOS = detTag.fPHOS;
+ fZDC = detTag.fZDC;
+ fMUON = detTag.fMUON;
+ fPMD = detTag.fPMD;
+ fEMCAL = detTag.fEMCAL;
+ fVZERO = detTag.fVZERO;
+ fTZERO = detTag.fTZERO;
}
return *this;
}
fT0zVertex(esd.fT0zVertex),
fSPDVertex(esd.fSPDVertex),
fPrimaryVertex(esd.fPrimaryVertex),
+ fSPDMult(esd.fSPDMult),
fT0timeStart(esd.fT0timeStart),
fTracks(*((TClonesArray*)esd.fTracks.Clone())),
fHLTConfMapTracks(*((TClonesArray*)esd.fHLTConfMapTracks.Clone())),
}
}
+//______________________________________________________________________________
+AliESD & AliESD::operator=(const AliESD& source) {
+
+ // Assignment operator
+
+ if(&source == this) return *this;
+
+ fEventNumber = source.fEventNumber;
+ fRunNumber = source.fRunNumber;
+ fTriggerMask = source.fTriggerMask;
+ fTriggerCluster = source.fTriggerCluster;
+ fRecoVersion = source.fRecoVersion;
+ fMagneticField = source.fMagneticField;
+ fZDCN1Energy = source.fZDCN1Energy;
+ fZDCP1Energy = source.fZDCP1Energy;
+ fZDCN2Energy = source.fZDCN2Energy;
+ fZDCP2Energy = source.fZDCP2Energy;
+ fZDCEMEnergy = source.fZDCEMEnergy;
+ fZDCParticipants = source.fZDCParticipants;
+ fT0zVertex = source.fT0zVertex;
+ fSPDVertex = source.fSPDVertex;
+ fPrimaryVertex = source.fPrimaryVertex;
+ fSPDMult = source.fSPDMult;
+ fT0timeStart = source.fT0timeStart;
+ fTracks = *((TClonesArray*)source.fTracks.Clone());
+ fHLTConfMapTracks = *((TClonesArray*)source.fHLTConfMapTracks.Clone());
+ fHLTHoughTracks = *((TClonesArray*)source.fHLTHoughTracks.Clone());
+ fMuonTracks = *((TClonesArray*)source.fMuonTracks.Clone());
+ fPmdTracks = *((TClonesArray*)source.fPmdTracks.Clone());
+ fTrdTracks = *((TClonesArray*)source.fTrdTracks.Clone());
+ fV0s = *((TClonesArray*)source.fV0s.Clone());
+ fCascades = *((TClonesArray*)source.fCascades.Clone());
+ fKinks = *((TClonesArray*)source.fKinks.Clone());
+ fV0MIs = *((TClonesArray*)source.fV0MIs.Clone());
+ fCaloClusters = *((TClonesArray*)source.fCaloClusters.Clone());
+ fEMCALClusters = source.fEMCALClusters;
+ fFirstEMCALCluster = source.fFirstEMCALCluster;
+ fPHOSClusters = source.fPHOSClusters;
+ fFirstPHOSCluster = source.fFirstPHOSCluster;
+ fESDFMD = source.fESDFMD;
+
+ for (Int_t i=0; i<24; i++) {
+ fT0time[i] = source.fT0time[i];
+ fT0amplitude[i] = source.fT0amplitude[i];
+ }
+
+ return *this;
+
+}
+
//______________________________________________________________________________
AliESD::~AliESD()
protected:
AliESD(const AliESD&);
+ AliESD &operator=(const AliESD& source);
// Event Identification
Int_t fEventNumber; // Event Number
fID(0),
fClusterType(-1),
fEMCALCluster(kFALSE),
+ fPHOSCluster(kFALSE),
fEnergy(-1),
fDispersion(-1),
fChi2(-1),
fNExMax(0),
fEmcCpvDistance(9999),
fNumberOfDigits(0),
- fDigitAmplitude(0),
- fDigitTime(0),
- fDigitIndex(0)
+ fDigitAmplitude(0x0),
+ fDigitTime(0x0),
+ fDigitIndex(0x0)
{
//
// The default ESD constructor
fID(clus.fID),
fClusterType(clus.fClusterType),
fEMCALCluster(clus.fEMCALCluster),
+ fPHOSCluster(clus.fPHOSCluster),
fEnergy(clus.fEnergy),
fDispersion(clus.fDispersion),
fChi2(clus.fChi2),
fM11(clus.fM11),
fNExMax(clus.fNExMax),
fEmcCpvDistance(clus.fEmcCpvDistance),
- fNumberOfDigits(clus.fNumberOfDigits)
+ fNumberOfDigits(clus.fNumberOfDigits),
+ fDigitAmplitude(0x0),
+ fDigitTime(0x0),
+ fDigitIndex(0x0)
{
//
// The copy constructor
for(Int_t i=0; i<AliPID::kSPECIESN; i++) fPID[i] = clus.fPID[i];
- fDigitAmplitude = 0x0;
- fDigitTime = 0x0;
- fDigitIndex = 0x0;
-
if (clus.fNumberOfDigits > 0) {
if (clus.fDigitAmplitude) {
fDigitAmplitude = new UShort_t[clus.fNumberOfDigits];
}
}
+//_______________________________________________________________________
+AliESDCaloCluster &AliESDCaloCluster::operator=(const AliESDCaloCluster& source)
+{
+ // assignment operator
+
+ if(&source == this) return *this;
+
+ fID = source.fID;
+ fClusterType = source.fClusterType;
+ fEMCALCluster = source.fEMCALCluster;
+ fPHOSCluster = source.fPHOSCluster;
+ fEnergy = source.fEnergy;
+ fDispersion = source.fDispersion;
+ fChi2 = source.fChi2;
+ fPrimaryIndex = source.fPrimaryIndex;
+ fM20 = source.fM20;
+ fM02 = source.fM02;
+ fM11 = source.fM11;
+ fNExMax = source.fNExMax;
+ fEmcCpvDistance = source.fEmcCpvDistance;
+ fNumberOfDigits = source.fNumberOfDigits;
+ delete fDigitAmplitude; fDigitAmplitude=0x0;
+ delete fDigitTime; fDigitTime = 0x0;
+ delete fDigitIndex; fDigitIndex = 0x0;
+
+ fGlobalPos[0] = source.fGlobalPos[0];
+ fGlobalPos[1] = source.fGlobalPos[1];
+ fGlobalPos[2] = source.fGlobalPos[2];
+
+ for(Int_t i=0; i<AliPID::kSPECIESN; i++) fPID[i] = source.fPID[i];
+
+ if (source.fNumberOfDigits > 0) {
+ if (source.fDigitAmplitude) {
+ fDigitAmplitude = new UShort_t[source.fNumberOfDigits];
+ for (Int_t i=0; i<source.fNumberOfDigits; i++)
+ fDigitAmplitude[i]=source.fDigitAmplitude[i];
+ }
+ if (source.fDigitTime) {
+ fDigitTime = new UShort_t[source.fNumberOfDigits];
+ for (Int_t i=0; i<source.fNumberOfDigits; i++)
+ fDigitTime[i]=source.fDigitTime[i];
+ }
+ if (source.fDigitIndex) {
+ fDigitIndex = new UShort_t[source.fNumberOfDigits];
+ for (Int_t i=0; i<source.fNumberOfDigits; i++)
+ fDigitIndex[i]=source.fDigitIndex[i];
+ }
+ }
+
+ return *this;
+
+}
+
//_______________________________________________________________________
AliESDCaloCluster::~AliESDCaloCluster(){
AliESDCaloCluster();
AliESDCaloCluster(const AliESDCaloCluster& clus);
+ AliESDCaloCluster & operator=(const AliESDCaloCluster& source);
virtual ~AliESDCaloCluster();
void SetID(Int_t id) {fID = id;}
ClassImp(AliESDV0MIParams)
-AliESDV0MIParams::AliESDV0MIParams(){
- //
- // Default constructor
- // Consult AliESDV0MI to see actual error parameterization
- //
-
- //
- // This constants are used in the error parameterization using covariance matrix
+AliESDV0MIParams::AliESDV0MIParams() :
+ TObject(),
+ // These constants are used in the error parameterization using covariance matrix
// minimal sigma in AP and DCA
- fPSigmaOffsetD0 = 0.03; // minimal sigma of error estimate
- fPSigmaOffsetAP0 = 0.005; //
+ fPSigmaOffsetD0(0.03), // minimal sigma of error estimate
+ fPSigmaOffsetAP0(0.005),
//
// Effective parameterization of DCA resolution as function of pt and decay radii
//
- fPSigmaMaxDE = 0.5;
- fPSigmaOffsetDE = 0.06;
- fPSigmaCoefDE = 0.02;
- fPSigmaRminDE = 2.7;
+ fPSigmaMaxDE(0.5),
+ fPSigmaOffsetDE(0.06),
+ fPSigmaCoefDE(0.02),
+ fPSigmaRminDE(2.7),
//
//
// Effective parameterization of PA resolution as function of pt and decay radii
//
- fPSigmaBase0APE = 0.005;
- fPSigmaMaxAPE = 0.06;
- fPSigmaR0APE = 0.02;
- fPSigmaR1APE = 0.1;
- fPSigmaP0APE = 0.7*0.4;
- fPSigmaP1APE = 0.3*0.4;
+ fPSigmaBase0APE(0.005),
+ fPSigmaMaxAPE(0.06),
+ fPSigmaR0APE(0.02),
+ fPSigmaR1APE(0.1),
+ fPSigmaP0APE(0.7*0.4),
+ fPSigmaP1APE(0.3*0.4),
//
//
// Minimax parameters
//
- fPMinFractionAP0 =0.5;
- fPMaxFractionAP0 =1.5;
- fPMinAP0 =0.003;
- fPMinFractionD0 =0.5;
- fPMaxFractionD0 =1.5;
- fPMinD0 =0.05;
+ fPMinFractionAP0(0.5),
+ fPMaxFractionAP0(1.5),
+ fPMinAP0(0.003),
+ fPMinFractionD0(0.5),
+ fPMaxFractionD0(1.5),
+ fPMinD0(0.05)
+ //
+
+{
+ //
+ // Default constructor
+ // Consult AliESDV0MI to see actual error parameterization
//
}
const AliExternalTrackParam &t, Int_t i) :
AliESDv0(v),
fPdgCode(kXiMinus),
+ fEffMass(-1),
fChi2Xi(1.e+33),
+ fDcaXiDaughters(-1),
fBachIdx(i)
{
//---------------------------------------------------------------------------------------------
}
AliESDcascade::AliESDcascade(const AliESDcascade& cas) :
- AliESDv0(cas)
+ AliESDv0(cas),
+ fPdgCode(cas.fPdgCode),
+ fEffMass(cas.fEffMass),
+ fChi2Xi(cas.fChi2Xi),
+ fDcaXiDaughters(cas.fDcaXiDaughters),
+ fBachIdx(cas.fBachIdx)
{
//copy constructor
- fPdgCode = cas.fPdgCode;
- fEffMass = cas.fEffMass;
- fChi2Xi = cas.fChi2Xi;
- fDcaXiDaughters = cas.fDcaXiDaughters;
- fBachIdx = cas.fBachIdx;
for (int i=0; i<3; i++) {
fPosXi[i] = cas.fPosXi[i];
fBachMom[i] = cas.fBachMom[i];
}
AliESDv0::AliESDv0(const AliESDv0& rAliESDv0) :
- TObject(rAliESDv0)
+ TObject(rAliESDv0),
+ fPdgCode(rAliESDv0.fPdgCode),
+ fEffMass(rAliESDv0.fEffMass),
+ fDcaV0Daughters(rAliESDv0.fDcaV0Daughters),
+ fChi2V0(rAliESDv0.fChi2V0),
+ fNidx(rAliESDv0.fNidx),
+ fPidx(rAliESDv0.fPidx)
{
- fPdgCode = rAliESDv0.fPdgCode;
- fEffMass = rAliESDv0.fEffMass;
- fDcaV0Daughters = rAliESDv0.fDcaV0Daughters;
- fChi2V0 = rAliESDv0.fChi2V0;
- fNidx = rAliESDv0.fNidx;
- fPidx = rAliESDv0.fPidx;
for (int i=0; i<3; i++) {
fPos[i] = rAliESDv0.fPos[i];
//___________________________________________________________________________
-AliEventTag::AliEventTag(const AliEventTag & EvTag) : TObject(EvTag) {
+AliEventTag::AliEventTag(const AliEventTag & evTag) :
+ TObject(evTag),
+ fAliceEventId(evTag.fAliceEventId),
+ fGUID(evTag.fGUID),
+ fPath(evTag.fPath),
+ fsize(evTag.fsize),
+ fmd5(evTag.fmd5),
+ fturl(evTag.fturl),
+ fNumberOfParticipants(evTag.fNumberOfParticipants),
+ fImpactParameter(evTag.fImpactParameter),
+ fPrimaryVertexFlag(evTag.fPrimaryVertexFlag),
+ fPrimaryVertexX(evTag.fPrimaryVertexX),
+ fPrimaryVertexY(evTag.fPrimaryVertexY),
+ fPrimaryVertexZ(evTag.fPrimaryVertexZ),
+ fPrimaryVertexZError(evTag.fPrimaryVertexZError),
+ fTriggerMask(evTag.fTriggerMask),
+ fTriggerCluster(evTag.fTriggerCluster),
+ fZDCNeutron1Energy(evTag.fZDCNeutron1Energy),
+ fZDCProton1Energy(evTag.fZDCProton1Energy),
+ fZDCNeutron2Energy(evTag.fZDCNeutron2Energy),
+ fZDCProton2Energy(evTag.fZDCProton2Energy),
+ fZDCEMEnergy(evTag.fZDCEMEnergy),
+ fT0VertexZ(evTag.fT0VertexZ),
+ fNumberOfTracks(evTag.fNumberOfTracks),
+ fNumberOfPositiveTracks(evTag.fNumberOfPositiveTracks),
+ fNumberOfNegativeTracks(evTag.fNumberOfNegativeTracks),
+ fNumberOfNeutralTracks(evTag.fNumberOfNeutralTracks),
+ fNumberOfV0s(evTag.fNumberOfV0s),
+ fNumberOfCascades(evTag.fNumberOfCascades),
+ fNumberOfKinks(evTag.fNumberOfKinks),
+ fNumberOfPMDTracks(evTag.fNumberOfPMDTracks),
+ fNumberOfFMDTracks(evTag.fNumberOfFMDTracks),
+ fNumberOfPHOSClusters(evTag.fNumberOfPHOSClusters),
+ fNumberOfEMCALClusters(evTag.fNumberOfEMCALClusters),
+ fNumberOfJetCandidates(evTag.fNumberOfJetCandidates),
+ fMaxJetEnergy(evTag.fMaxJetEnergy),
+ fNumberOfHardPhotonsCandidates(evTag.fNumberOfHardPhotonsCandidates),
+ fMaxNeutralEnergy(evTag.fMaxNeutralEnergy),
+ fNumberOfChargedAbove1GeV(evTag.fNumberOfChargedAbove1GeV),
+ fNumberOfChargedAbove3GeV(evTag.fNumberOfChargedAbove3GeV),
+ fNumberOfChargedAbove10GeV(evTag.fNumberOfChargedAbove10GeV),
+ fNumberOfMuonsAbove1GeV(evTag.fNumberOfMuonsAbove1GeV),
+ fNumberOfMuonsAbove3GeV(evTag.fNumberOfMuonsAbove3GeV),
+ fNumberOfMuonsAbove10GeV(evTag.fNumberOfMuonsAbove10GeV),
+ fNumberOfElectronsAbove1GeV(evTag.fNumberOfElectronsAbove1GeV),
+ fNumberOfElectronsAbove3GeV(evTag.fNumberOfElectronsAbove3GeV),
+ fNumberOfElectronsAbove10GeV(evTag.fNumberOfElectronsAbove10GeV),
+ fNumberOfElectrons(evTag.fNumberOfElectrons),
+ fNumberOfMuons(evTag.fNumberOfMuons),
+ fNumberOfPions(evTag.fNumberOfPions),
+ fNumberOfKaons(evTag.fNumberOfKaons),
+ fNumberOfProtons(evTag.fNumberOfProtons),
+ fNumberOfLambdas(evTag.fNumberOfLambdas),
+ fNumberOfPhotons(evTag.fNumberOfPhotons),
+ fNumberOfPi0s(evTag.fNumberOfPi0s),
+ fNumberOfNeutrons(evTag.fNumberOfNeutrons),
+ fNumberOfKaon0s(evTag.fNumberOfKaon0s),
+ fTotalP(evTag.fTotalP),
+ fMeanPt(evTag.fMeanPt),
+ fMaxPt(evTag.fMaxPt),
+ fTotalNeutralP(evTag.fTotalNeutralP),
+ fMeanNeutralPt(evTag.fMeanNeutralPt),
+ fMaxNeutralPt(evTag.fMaxNeutralPt),
+ fEventPlaneAngle(evTag.fEventPlaneAngle),
+ fHBTRadii(evTag.fHBTRadii)
+ {
// EventTag copy constructor
- SetEventId(EvTag.GetEventId());
- SetGUID(EvTag.GetGUID());
- SetPath(EvTag.GetPath());
- SetMD5(EvTag.GetMD5());
- SetTURL(EvTag.GetTURL());
- SetSize(EvTag.GetSize());
- SetNumOfParticipants(EvTag.GetNumOfParticipants());
- SetImpactParameter(EvTag.GetImpactParameter());
- SetVertexX(EvTag.GetVertexX());
- SetVertexY(EvTag.GetVertexY());
- SetVertexZ(EvTag.GetVertexZ());
- SetVertexFlag(EvTag.GetVertexFlag());
- SetVertexZError(EvTag.GetVertexZError());
- SetTriggerMask(EvTag.GetTriggerMask());
- SetTriggerCluster(EvTag.GetTriggerCluster());
- SetZDCNeutron1Energy(EvTag.GetZDCNeutron1Energy());
- SetZDCProton1Energy(EvTag.GetZDCProton1Energy());
- SetZDCEMEnergy(EvTag.GetZDCEMEnergy());
- SetZDCNeutron2Energy(EvTag.GetZDCNeutron2Energy());
- SetZDCProton2Energy(EvTag.GetZDCProton2Energy());
- SetT0VertexZ(EvTag.GetT0VertexZ());
- SetNumOfTracks(EvTag.GetNumOfTracks());
- SetNumOfPosTracks(EvTag.GetNumOfPosTracks());
- SetNumOfNegTracks(EvTag.GetNumOfNegTracks());
- SetNumOfNeutrTracks(EvTag.GetNumOfNeutrTracks());
- SetNumOfV0s(EvTag.GetNumOfV0s());
- SetNumOfCascades(EvTag.GetNumOfCascades());
- SetNumOfKinks(EvTag.GetNumOfKinks());
- SetNumOfPMDTracks(EvTag.GetNumOfPMDTracks());
- SetNumOfFMDTracks(EvTag.GetNumOfFMDTracks());
- SetNumOfPHOSClusters(EvTag.GetNumOfPHOSClusters());
- SetNumOfEMCALClusters(EvTag.GetNumOfEMCALClusters());
- SetNumOfJetCandidates(EvTag.GetNumOfJetCandidates());
- SetNumOfHardPhotonsCandidates(EvTag.GetNumOfHardPhotonsCandidates());
- SetMaxJetEnergy(EvTag.GetMaxJetEnergy());
- SetMaxNeutralEnergy(EvTag.GetMaxNeutralEnergy());
- SetNumOfChargedAbove1GeV(EvTag.GetNumOfChargedAbove1GeV());
- SetNumOfChargedAbove3GeV(EvTag.GetNumOfChargedAbove3GeV());
- SetNumOfChargedAbove10GeV(EvTag.GetNumOfChargedAbove10GeV());
- SetNumOfMuonsAbove1GeV(EvTag.GetNumOfMuonsAbove1GeV());
- SetNumOfMuonsAbove3GeV(EvTag.GetNumOfMuonsAbove3GeV());
- SetNumOfMuonsAbove10GeV(EvTag.GetNumOfMuonsAbove10GeV());
- SetNumOfElectronsAbove1GeV(EvTag.GetNumOfElectronsAbove1GeV());
- SetNumOfElectronsAbove3GeV(EvTag.GetNumOfElectronsAbove3GeV());
- SetNumOfElectronsAbove10GeV(EvTag.GetNumOfElectronsAbove10GeV());
- SetNumOfElectrons(EvTag.GetNumOfElectrons());
- SetNumOfMuons(EvTag.GetNumOfMuons());
- SetNumOfPions(EvTag.GetNumOfPions());
- SetNumOfKaons(EvTag.GetNumOfKaons());
- SetNumOfProtons(EvTag.GetNumOfProtons());
- SetNumOfLambdas(EvTag.GetNumOfLambdas());
- SetNumOfPhotons(EvTag.GetNumOfPhotons());
- SetNumOfPi0s(EvTag.GetNumOfPi0s());
- SetNumOfNeutrons(EvTag.GetNumOfNeutrons());
- SetNumOfKaon0s(EvTag.GetNumOfKaon0s());
- SetTotalMomentum(EvTag.GetTotalMomentum());
- SetMeanPt(EvTag.GetMeanPt());
- SetMaxPt(EvTag.GetMaxPt());
- SetNeutralTotalMomentum(EvTag.GetNeutralTotalMomentum());
- SetNeutralMeanPt(EvTag.GetNeutralMeanPt());
- SetNeutralMaxPt(EvTag.GetNeutralMaxPt());
- SetEventPlaneAngle(EvTag.GetEventPlaneAngle());
- SetHBTRadii(EvTag.GetHBTRadii());
}
//___________________________________________________________________________
-AliEventTag & AliEventTag::operator=(const AliEventTag &EvTag) {
+AliEventTag & AliEventTag::operator=(const AliEventTag &evTag) {
// EventTag assignment operator
- if (this != &EvTag) {
- TObject::operator=(EvTag);
+ if (this != &evTag) {
+ TObject::operator=(evTag);
- SetEventId(EvTag.GetEventId());
- SetGUID(EvTag.GetGUID());
- SetPath(EvTag.GetPath());
- SetMD5(EvTag.GetMD5());
- SetTURL(EvTag.GetTURL());
- SetSize(EvTag.GetSize());
- SetNumOfParticipants(EvTag.GetNumOfParticipants());
- SetImpactParameter(EvTag.GetImpactParameter());
- SetVertexX(EvTag.GetVertexX());
- SetVertexY(EvTag.GetVertexY());
- SetVertexZ(EvTag.GetVertexZ());
- SetVertexFlag(EvTag.GetVertexFlag());
- SetVertexZError(EvTag.GetVertexZError());
- SetTriggerMask(EvTag.GetTriggerMask());
- SetTriggerCluster(EvTag.GetTriggerCluster());
- SetZDCNeutron1Energy(EvTag.GetZDCNeutron1Energy());
- SetZDCProton1Energy(EvTag.GetZDCProton1Energy());
- SetZDCNeutron2Energy(EvTag.GetZDCNeutron2Energy());
- SetZDCProton2Energy(EvTag.GetZDCProton2Energy());
- SetZDCEMEnergy(EvTag.GetZDCEMEnergy());
- SetT0VertexZ(EvTag.GetT0VertexZ());
- SetNumOfTracks(EvTag.GetNumOfTracks());
- SetNumOfPosTracks(EvTag.GetNumOfPosTracks());
- SetNumOfNegTracks(EvTag.GetNumOfNegTracks());
- SetNumOfNeutrTracks(EvTag.GetNumOfNeutrTracks());
- SetNumOfV0s(EvTag.GetNumOfV0s());
- SetNumOfCascades(EvTag.GetNumOfCascades());
- SetNumOfKinks(EvTag.GetNumOfKinks());
- SetNumOfPMDTracks(EvTag.GetNumOfPMDTracks());
- SetNumOfFMDTracks(EvTag.GetNumOfFMDTracks());
- SetNumOfPHOSClusters(EvTag.GetNumOfPHOSClusters());
- SetNumOfEMCALClusters(EvTag.GetNumOfEMCALClusters());
- SetNumOfJetCandidates(EvTag.GetNumOfJetCandidates());
- SetNumOfHardPhotonsCandidates(EvTag.GetNumOfHardPhotonsCandidates());
- SetMaxJetEnergy(EvTag.GetMaxJetEnergy());
- SetMaxNeutralEnergy(EvTag.GetMaxNeutralEnergy());
- SetNumOfChargedAbove1GeV(EvTag.GetNumOfChargedAbove1GeV());
- SetNumOfChargedAbove3GeV(EvTag.GetNumOfChargedAbove3GeV());
- SetNumOfChargedAbove10GeV(EvTag.GetNumOfChargedAbove10GeV());
- SetNumOfMuonsAbove1GeV(EvTag.GetNumOfMuonsAbove1GeV());
- SetNumOfMuonsAbove3GeV(EvTag.GetNumOfMuonsAbove3GeV());
- SetNumOfMuonsAbove10GeV(EvTag.GetNumOfMuonsAbove10GeV());
- SetNumOfElectronsAbove1GeV(EvTag.GetNumOfElectronsAbove1GeV());
- SetNumOfElectronsAbove3GeV(EvTag.GetNumOfElectronsAbove3GeV());
- SetNumOfElectronsAbove10GeV(EvTag.GetNumOfElectronsAbove10GeV());
- SetNumOfElectrons(EvTag.GetNumOfElectrons());
- SetNumOfMuons(EvTag.GetNumOfMuons());
- SetNumOfPions(EvTag.GetNumOfPions());
- SetNumOfKaons(EvTag.GetNumOfKaons());
- SetNumOfProtons(EvTag.GetNumOfProtons());
- SetNumOfLambdas(EvTag.GetNumOfLambdas());
- SetNumOfPhotons(EvTag.GetNumOfPhotons());
- SetNumOfPi0s(EvTag.GetNumOfPi0s());
- SetNumOfNeutrons(EvTag.GetNumOfNeutrons());
- SetNumOfKaon0s(EvTag.GetNumOfKaon0s());
- SetTotalMomentum(EvTag.GetTotalMomentum());
- SetMeanPt(EvTag.GetMeanPt());
- SetMaxPt(EvTag.GetMaxPt());
- SetNeutralTotalMomentum(EvTag.GetNeutralTotalMomentum());
- SetNeutralMeanPt(EvTag.GetNeutralMeanPt());
- SetNeutralMaxPt(EvTag.GetNeutralMaxPt());
- SetEventPlaneAngle(EvTag.GetEventPlaneAngle());
- SetHBTRadii(EvTag.GetHBTRadii());
+ SetEventId(evTag.GetEventId());
+ SetGUID(evTag.GetGUID());
+ SetPath(evTag.GetPath());
+ SetMD5(evTag.GetMD5());
+ SetTURL(evTag.GetTURL());
+ SetSize(evTag.GetSize());
+ SetNumOfParticipants(evTag.GetNumOfParticipants());
+ SetImpactParameter(evTag.GetImpactParameter());
+ SetVertexX(evTag.GetVertexX());
+ SetVertexY(evTag.GetVertexY());
+ SetVertexZ(evTag.GetVertexZ());
+ SetVertexFlag(evTag.GetVertexFlag());
+ SetVertexZError(evTag.GetVertexZError());
+ SetTriggerMask(evTag.GetTriggerMask());
+ SetTriggerCluster(evTag.GetTriggerCluster());
+ SetZDCNeutron1Energy(evTag.GetZDCNeutron1Energy());
+ SetZDCProton1Energy(evTag.GetZDCProton1Energy());
+ SetZDCNeutron2Energy(evTag.GetZDCNeutron2Energy());
+ SetZDCProton2Energy(evTag.GetZDCProton2Energy());
+ SetZDCEMEnergy(evTag.GetZDCEMEnergy());
+ SetT0VertexZ(evTag.GetT0VertexZ());
+ SetNumOfTracks(evTag.GetNumOfTracks());
+ SetNumOfPosTracks(evTag.GetNumOfPosTracks());
+ SetNumOfNegTracks(evTag.GetNumOfNegTracks());
+ SetNumOfNeutrTracks(evTag.GetNumOfNeutrTracks());
+ SetNumOfV0s(evTag.GetNumOfV0s());
+ SetNumOfCascades(evTag.GetNumOfCascades());
+ SetNumOfKinks(evTag.GetNumOfKinks());
+ SetNumOfPMDTracks(evTag.GetNumOfPMDTracks());
+ SetNumOfFMDTracks(evTag.GetNumOfFMDTracks());
+ SetNumOfPHOSClusters(evTag.GetNumOfPHOSClusters());
+ SetNumOfEMCALClusters(evTag.GetNumOfEMCALClusters());
+ SetNumOfJetCandidates(evTag.GetNumOfJetCandidates());
+ SetNumOfHardPhotonsCandidates(evTag.GetNumOfHardPhotonsCandidates());
+ SetMaxJetEnergy(evTag.GetMaxJetEnergy());
+ SetMaxNeutralEnergy(evTag.GetMaxNeutralEnergy());
+ SetNumOfChargedAbove1GeV(evTag.GetNumOfChargedAbove1GeV());
+ SetNumOfChargedAbove3GeV(evTag.GetNumOfChargedAbove3GeV());
+ SetNumOfChargedAbove10GeV(evTag.GetNumOfChargedAbove10GeV());
+ SetNumOfMuonsAbove1GeV(evTag.GetNumOfMuonsAbove1GeV());
+ SetNumOfMuonsAbove3GeV(evTag.GetNumOfMuonsAbove3GeV());
+ SetNumOfMuonsAbove10GeV(evTag.GetNumOfMuonsAbove10GeV());
+ SetNumOfElectronsAbove1GeV(evTag.GetNumOfElectronsAbove1GeV());
+ SetNumOfElectronsAbove3GeV(evTag.GetNumOfElectronsAbove3GeV());
+ SetNumOfElectronsAbove10GeV(evTag.GetNumOfElectronsAbove10GeV());
+ SetNumOfElectrons(evTag.GetNumOfElectrons());
+ SetNumOfMuons(evTag.GetNumOfMuons());
+ SetNumOfPions(evTag.GetNumOfPions());
+ SetNumOfKaons(evTag.GetNumOfKaons());
+ SetNumOfProtons(evTag.GetNumOfProtons());
+ SetNumOfLambdas(evTag.GetNumOfLambdas());
+ SetNumOfPhotons(evTag.GetNumOfPhotons());
+ SetNumOfPi0s(evTag.GetNumOfPi0s());
+ SetNumOfNeutrons(evTag.GetNumOfNeutrons());
+ SetNumOfKaon0s(evTag.GetNumOfKaon0s());
+ SetTotalMomentum(evTag.GetTotalMomentum());
+ SetMeanPt(evTag.GetMeanPt());
+ SetMaxPt(evTag.GetMaxPt());
+ SetNeutralTotalMomentum(evTag.GetNeutralTotalMomentum());
+ SetNeutralMeanPt(evTag.GetNeutralMeanPt());
+ SetNeutralMaxPt(evTag.GetNeutralMaxPt());
+ SetEventPlaneAngle(evTag.GetEventPlaneAngle());
+ SetHBTRadii(evTag.GetHBTRadii());
}
return *this;
}
//___________________________________________________________________________
-AliEventTagCuts::AliEventTagCuts() {
+AliEventTagCuts::AliEventTagCuts() :
+ TObject(),
+
+
+
+
+ fVxMin(-1000.0), fVxMax(1000.0),
+ fVxFlag(kFALSE),
+ fVyMin(-1000.0), fVyMax(1000.0),
+ fVyFlag(kFALSE),
+ fVzMin(-1000.0), fVzMax(1000.0),
+ fVzFlag(kFALSE),
+ fParticipantsMin(-1), fParticipantMax(10000),
+ fParticipantsFlag(kFALSE),
+ fImpactParamMin(-1.0), fImpactParamMax(1000.0),
+ fImpactParamFlag(kFALSE),
+ fPrimaryVertexFlag(1),
+ fPVFlag(kFALSE),
+
+ fPrimaryVertexZErrorMin(-10000.), fPrimaryVertexZErrorMax(10000.),
+ fPVzErrorFlag(kFALSE),
+ fTriggerMask(0),
+ fTriggerMaskFlag(kFALSE),
+ fTriggerCluster(0),
+ fTriggerClusterFlag(kFALSE),
+
+ fZDCNeutron1EnergyMin(-1.0), fZDCNeutron1EnergyMax(100000.0),
+ fZDCNeutron1EnergyFlag(kFALSE),
+ fZDCProton1EnergyMin(-1.0), fZDCProton1EnergyMax(100000.0),
+ fZDCProton1EnergyFlag(kFALSE),
+ fZDCNeutron2EnergyMin(-1.0), fZDCNeutron2EnergyMax(100000.0),
+ fZDCNeutron2EnergyFlag(kFALSE),
+ fZDCProton2EnergyMin(-1.0), fZDCProton2EnergyMax(100000.0),
+ fZDCProton2EnergyFlag(kFALSE),
+ fZDCEMEnergyMin(-1.0), fZDCEMEnergyMax(100000.0),
+ fZDCEMEnergyFlag(kFALSE),
+ fT0VertexZMin(-10000.0), fT0VertexZMax(10000.0),
+ fT0VertexZFlag(kFALSE),
+ fMultMin(0), fMultMax(100000),
+ fMultFlag(kFALSE),
+ fMultPosMin(-1), fMultPosMax(100000),
+ fMultPosFlag(kFALSE),
+ fMultNegMin(-1), fMultNegMax(100000),
+ fMultNegFlag(kFALSE),
+ fMultNeutrMin(-1), fMultNeutrMax(100000),
+ fMultNeutrFlag(kFALSE),
+ fV0sMin(-1), fV0sMax(1000000),
+ fV0sFlag(kFALSE),
+ fCascadesMin(-1), fCascadesMax(100000),
+ fCascadesFlag(kFALSE),
+ fkinksMin(-1), fkinksMax(1000000),
+ fkinksFlag(kFALSE),
+
+ fPMDTracksMin(-1), fPMDTracksMax(100000),
+ fPMDTracksFlag(kFALSE),
+ fFMDTracksMin(-1), fFMDTracksMax(100000),
+ fFMDTracksFlag(kFALSE),
+ fPHOSClustersMin(-1), fPHOSClustersMax(100000),
+ fPHOSClustersFlag(kFALSE),
+ fEMCALClustersMin(-1), fEMCALClustersMax(100000),
+ fEMCALClustersFlag(kFALSE),
+ fJetCandidatesMin(-1), fJetCandidatesMax(100000),
+ fJetCandidatesFlag(kFALSE),
+
+ fMaxJetEnergy(-1.0),
+ fMaxJetEnergyFlag(kFALSE),
+ fNHardPhotonsCandidatesMin(-1), fNHardPhotonsCandidatesMax(100000),
+ fNHardPhotonsCandidatesFlag(kFALSE),
+ fMaxNeutralEnergy(-1.0),
+ fMaxNeutralFlag(kFALSE),
+ fChargedAbove1GeVMin(-1), fChargedAbove1GeVMax(100000),
+ fChargedAbove1GeVFlag(kFALSE),
+ fChargedAbove3GeVMin(-1), fChargedAbove3GeVMax(100000),
+ fChargedAbove3GeVFlag(kFALSE),
+ fChargedAbove10GeVMin(-1), fChargedAbove10GeVMax(100000),
+ fChargedAbove10GeVFlag(kFALSE),
+ fMuonsAbove1GeVMin(-1), fMuonsAbove1GeVMax(100000),
+ fMuonsAbove1GeVFlag(kFALSE),
+ fMuonsAbove3GeVMin(-1), fMuonsAbove3GeVMax(100000),
+ fMuonsAbove3GeVFlag(kFALSE),
+ fMuonsAbove10GeVMin(-1), fMuonsAbove10GeVMax(100000),
+ fMuonsAbove10GeVFlag(kFALSE),
+ fElectronsAbove1GeVMin(-1), fElectronsAbove1GeVMax(100000),
+ fElectronsAbove1GeVFlag(kFALSE),
+ fElectronsAbove3GeVMin(-1), fElectronsAbove3GeVMax(100000),
+ fElectronsAbove3GeVFlag(kFALSE),
+ fElectronsAbove10GeVMin(-1), fElectronsAbove10GeVMax(100000),
+ fElectronsAbove10GeVFlag(kFALSE),
+ fElectronsMin(-1), fElectronsMax(100000),
+ fElectronsFlag(kFALSE),
+ fMuonsMin(-1), fMuonsMax(100000),
+ fMuonsFlag(kFALSE),
+ fPionsMin(-1), fPionsMax(100000),
+ fPionsFlag(kFALSE),
+ fKaonsMin(-1), fKaonsMax(100000),
+ fKaonsFlag(kFALSE),
+ fProtonsMin(-1), fProtonsMax(100000),
+ fProtonsFlag(kFALSE),
+ fLambdasMin(-1), fLambdasMax(100000),
+ fLambdasFlag(kFALSE),
+ fPhotonsMin(-1), fPhotonsMax(100000),
+ fPhotonFlag(kFALSE),
+ fPi0sMin(-1), fPi0sMax(100000),
+ fPi0sFlag(kFALSE),
+ fNeutronsMin(-1), fNeutronsMax(100000),
+ fNeutronsFlag(kFALSE),
+ fKaon0sMin(-1), fKaon0sMax(100000),
+ fKaon0sFlag(kFALSE),
+ fTotalPMin(-1.0), fTotalPMax(1000000.0),
+ fTotalPFlag(kFALSE),
+ fMeanPtMin(-1.0), fMeanPtMax(100000.0),
+ fMeanPtFlag(kFALSE),
+ fMaxPt(-1.0),
+ fMaxPtFlag(kFALSE),
+ fTotalNeutralPMin(-1.0), fTotalNeutralPMax(1000000.0),
+ fTotalNeutralPFlag(kFALSE),
+ fMeanNeutralPtMin(-1.0), fMeanNeutralPtMax(1000000.0),
+ fMeanNeutralPtFlag(kFALSE),
+ fMaxNeutralPt(-1.0),
+ fMaxNeutralPtFlag(kFALSE),
+ fEventPlaneAngleMin(-10000000.0), fEventPlaneAngleMax(10000000.0),
+ fEventPlaneAngleFlag(kFALSE),
+ fHBTRadiiMin(-1.0), fHBTRadiiMax(100000.0),
+ fHBTRadiiFlag(kFALSE)
+{
//Default constructor which calls the Reset method.
Reset();
}
//_____________________________________________________________________________
AliExternalTrackParam::AliExternalTrackParam(const AliKalmanTrack& track) :
+ fX(0),
fAlpha(track.GetAlpha())
{
//
other.fMaxRings,
other.fMaxSectors,
other.fMaxStrips),
- fData(0)
+ fTotal(fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips),
+ fData(new Float_t[fTotal])
{
// Copy constructor
- fTotal = fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips;
- fData = new Float_t[fTotal];
- for (size_t i = 0; i < fMaxDetectors * fMaxRings
- * fMaxSectors * fMaxStrips; i++)
+ for (Int_t i = 0; i < fTotal; i++)
fData[i] = other.fData[i];
}
//__________________________________________________________
-AliFMDFloatMap::AliFMDFloatMap(size_t maxDet,
- size_t maxRing,
- size_t maxSec,
- size_t maxStr)
+AliFMDFloatMap::AliFMDFloatMap(Int_t maxDet,
+ Int_t maxRing,
+ Int_t maxSec,
+ Int_t maxStr)
: AliFMDMap(maxDet, maxRing, maxSec, maxStr),
- fData(0)
+ fTotal(fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips),
+ fData(new Float_t[fTotal])
{
// Constructor.
// Parameters:
// maxRing Maximum number of rings per detector
// maxSec Maximum number of sectors per ring
// maxStr Maximum number of strips per sector
- fTotal = fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips;
- fData = new Float_t[fTotal];
Reset();
}
fTotal = fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips;
if (fData) delete [] fData;
fData = new Float_t[fTotal];
- for (size_t i = 0; i < fTotal; i++) fData[i] = other.fData[i];
+ for (Int_t i = 0; i < fTotal; i++) fData[i] = other.fData[i];
return *this;
}
AliFMDFloatMap::Reset(const Float_t& val)
{
// Reset map to val
- for (size_t i = 0; i < fTotal; i++) fData[i] = val;
+ for (Int_t i = 0; i < fTotal; i++) fData[i] = val;
}
//__________________________________________________________
class AliFMDFloatMap : public AliFMDMap
{
public:
- AliFMDFloatMap(size_t maxDet = kMaxDetectors,
- size_t maxRing= kMaxRings,
- size_t maxSec = kMaxSectors,
- size_t maxStr = kMaxStrips);
+ AliFMDFloatMap(Int_t maxDet = kMaxDetectors,
+ Int_t maxRing= kMaxRings,
+ Int_t maxSec = kMaxSectors,
+ Int_t maxStr = kMaxStrips);
AliFMDFloatMap(const AliFMDFloatMap& o);
virtual ~AliFMDFloatMap() { delete [] fData; }
AliFMDFloatMap& operator=(const AliFMDFloatMap& o);
UShort_t sec,
UShort_t str) const;
protected:
- size_t fTotal; // Total number of entries
+ Int_t fTotal; // Total number of entries
Float_t* fData; //[fTotal]
- ClassDef(AliFMDFloatMap,1) // Map of floats
+ ClassDef(AliFMDFloatMap,2) // Map of floats
};
#endif
AliMagFMaps::AliMagFMaps(const AliMagFMaps &magf):
AliMagFC(magf),
fSolenoid(0),
+ fSolenoidUser(0),
fL3Option(0)
{
//
ClassImp(AliMultiplicity)
//______________________________________________________________________
-AliMultiplicity::AliMultiplicity():TObject() {
+AliMultiplicity::AliMultiplicity():
+ TObject(),
+ fNtracks(0),
+ fTh(0),
+ fPhi(0),
+ fDeltPhi(0)
+
+{
// Default Constructor
- fNtracks = 0;
- fTh = 0;
- fPhi = 0;
- fDeltPhi = 0;
}
//______________________________________________________________________
-AliMultiplicity::AliMultiplicity(Int_t ntr, Float_t *t, Float_t *ph, Float_t *df):TObject() {
+AliMultiplicity::AliMultiplicity(Int_t ntr, Float_t *t, Float_t *ph, Float_t *df):
+ TObject(),
+ fNtracks(ntr),
+ fTh(0),
+ fPhi(0),
+ fDeltPhi(0)
+{
// Standard constructor
- fNtracks = ntr;
if(ntr>0){
fTh = new Float_t [ntr];
fPhi = new Float_t [ntr];
fDeltPhi[i]=df[i];
}
}
- else {
- fTh = 0;
- fPhi = 0;
- fDeltPhi = 0;
- }
}
//______________________________________________________________________
-AliMultiplicity::AliMultiplicity(const AliMultiplicity& m):TObject(m){
+AliMultiplicity::AliMultiplicity(const AliMultiplicity& m):
+ TObject(m),
+ fNtracks(m.fNtracks),
+ fTh(0),
+ fPhi(0),
+ fDeltPhi(0)
+{
// copy constructor
Duplicate(m);
/*
$Log$
+Revision 1.4 2006/08/08 14:20:49 jgrosseo
+Update to shuttle classes (Alberto)
+
+- Possibility to set the full object's path in the Preprocessor's and
+Shuttle's Store functions
+- Possibility to extend the object's run validity in the same classes
+("startValidity" and "validityInfinite" parameters)
+- Implementation of the StoreReferenceData function to store reference
+data in a dedicated CDB storage.
+
Revision 1.3 2006/07/11 12:42:43 jgrosseo
adding parameters for extended validity range of data produced by preprocessor
//______________________________________________________________________________________________
AliPreprocessor::AliPreprocessor(const char* detector, AliShuttleInterface* shuttle) :
TNamed(detector, ""),
+ fRun(-1),
+ fStartTime(0),
+ fEndTime(0),
fShuttle(shuttle)
{
SetTitle(Form("AliPreprocessor for %s subdetector.", detector));
UInt_t fEndTime; // endtime of current run
private:
+ AliPreprocessor(const AliPreprocessor & source);
+ AliPreprocessor & operator=(const AliPreprocessor & source);
AliShuttleInterface* fShuttle; // link to Shuttle
ClassDef(AliPreprocessor, 0);
fPDGDB(0), //Particle factory object
fConfigFunction(""),
fRandom(0),
+ fBaseFileName(""),
fIsRootGeometry(kFALSE),
fGeometryFileName(""),
fTriggerDescriptor(""),
fPDGDB(0), //Particle factory object
fConfigFunction("\0"),
fRandom(0),
+ fBaseFileName(""),
fIsRootGeometry(kFALSE),
fGeometryFileName(""),
fTriggerDescriptor(""),
fPDGDB(TDatabasePDG::Instance()), //Particle factory object!
fConfigFunction("Config();"),
fRandom(new TRandom3()),
+ fBaseFileName(""),
fIsRootGeometry(kFALSE),
fGeometryFileName(""),
fTriggerDescriptor(""),
//___________________________________________________________________________
-AliRunTagCuts::AliRunTagCuts() {
+AliRunTagCuts::AliRunTagCuts() :
+ TObject(),
+ fAliceRunId(-1),
+ fAliceRunIdFlag(kFALSE),
+ fAliceMagneticField(-1.),
+ fAliceMagneticFieldFlag(kFALSE),
+ fAliceRunStartTimeMin(-1),
+ fAliceRunStartTimeMax(-1),
+ fAliceRunStartTimeFlag(kFALSE),
+ fAliceRunStopTimeMin(-1),
+ fAliceRunStopTimeMax(-1),
+ fAliceRunStopTimeFlag(kFALSE),
+ fAlirootVersion(""),
+ fAlirootVersionFlag(kFALSE),
+ fRootVersion(""),
+ fRootVersionFlag(kFALSE),
+ fGeant3Version(""),
+ fGeant3VersionFlag(kFALSE),
+ fAliceRunQuality(0),
+ fAliceRunQualityFlag(kFALSE),
+ fAliceBeamEnergy(-1),
+ fAliceBeamEnergyFlag(kFALSE),
+ fAliceBeamType(""),
+ fAliceBeamTypeFlag(kFALSE),
+ fAliceCalibrationVersion(-1),
+ fAliceCalibrationVersionFlag(kFALSE),
+ fAliceDataType(-1),
+ fAliceDataTypeFlag(kFALSE)
+{
//Default constructor which calls the Reset method.
- Reset();
}
//___________________________________________________________________________
ClassImp(AliStrLine)
//________________________________________________________
-AliStrLine::AliStrLine() {
+AliStrLine::AliStrLine() :
+ TObject(),
+ fTpar(0),
+ fDebug(0)
+ {
// Default constructor
for(Int_t i=0;i<3;i++) {
fP0[i] = 0.;
fCd[i] = 0.;
}
- fTpar = 0.;
- SetDebug();
}
//________________________________________________________
-AliStrLine::AliStrLine(Double_t *point, Double_t *cd,Bool_t twopoints) {
+AliStrLine::AliStrLine(Double_t *point, Double_t *cd,Bool_t twopoints) :
+ TObject(),
+ fTpar(0),
+ fDebug(0)
+{
// Standard constructor
// if twopoints is true: point and cd are the 3D coordinates of
// two points defininig the straight line
//___________________________________________________________________________
AliTagAnalysis::AliTagAnalysis():
TObject(),
- ftagresult(0)
+ ftagresult(0x0),
+ fTagDirName(),
+ fChain(0x0)
{
//Default constructor for a AliTagAnalysis
}
static TChain *fgChain; //tag chain
TChain *fChain; //tag chain
+
+ private:
+ AliTagAnalysis(const AliTagAnalysis & source);
+ AliTagAnalysis & operator=(const AliTagAnalysis & source);
ClassDef(AliTagAnalysis,0)
};
ClassImp(AliTrackPointArray)
//______________________________________________________________________________
-AliTrackPointArray::AliTrackPointArray()
+AliTrackPointArray::AliTrackPointArray() :
+ TObject(),
+ fNPoints(0),
+ fX(0),
+ fY(0),
+ fZ(0),
+ fSize(0),
+ fCov(0),
+ fVolumeID(0)
{
- fNPoints = fSize = 0;
- fX = fY = fZ = 0;
- fVolumeID = 0;
- fCov = 0;
}
//______________________________________________________________________________
AliTrackPointArray::AliTrackPointArray(Int_t npoints):
- fNPoints(npoints)
+ TObject(),
+ fNPoints(npoints),
+ fX(new Float_t[npoints]),
+ fY(new Float_t[npoints]),
+ fZ(new Float_t[npoints]),
+ fSize(6*npoints),
+ fCov(new Float_t[fSize]),
+ fVolumeID(new UShort_t[npoints])
{
// Constructor
//
- fSize = 6*npoints;
- fX = new Float_t[npoints];
- fY = new Float_t[npoints];
- fZ = new Float_t[npoints];
- fVolumeID = new UShort_t[npoints];
- fCov = new Float_t[fSize];
}
//______________________________________________________________________________
AliTrackPointArray::AliTrackPointArray(const AliTrackPointArray &array):
- TObject(array)
+ TObject(array),
+ fNPoints(array.fNPoints),
+ fX(new Float_t[fNPoints]),
+ fY(new Float_t[fNPoints]),
+ fZ(new Float_t[fNPoints]),
+ fSize(array.fSize),
+ fCov(new Float_t[fSize]),
+ fVolumeID(new UShort_t[fNPoints])
{
// Copy constructor
//
- fNPoints = array.fNPoints;
- fSize = array.fSize;
- fX = new Float_t[fNPoints];
- fY = new Float_t[fNPoints];
- fZ = new Float_t[fNPoints];
- fVolumeID = new UShort_t[fNPoints];
- fCov = new Float_t[fSize];
memcpy(fX,array.fX,fNPoints*sizeof(Float_t));
memcpy(fY,array.fY,fNPoints*sizeof(Float_t));
memcpy(fZ,array.fZ,fNPoints*sizeof(Float_t));
ClassImp(AliTrackPoint)
//______________________________________________________________________________
-AliTrackPoint::AliTrackPoint()
+AliTrackPoint::AliTrackPoint() :
+ TObject(),
+ fX(0),
+ fY(0),
+ fZ(0),
+ fVolumeID(0)
{
// Default constructor
//
- fX = fY = fZ = 0;
- fVolumeID = 0;
memset(fCov,0,6*sizeof(Float_t));
}
//______________________________________________________________________________
-AliTrackPoint::AliTrackPoint(Float_t x, Float_t y, Float_t z, const Float_t *cov, UShort_t volid)
+AliTrackPoint::AliTrackPoint(Float_t x, Float_t y, Float_t z, const Float_t *cov, UShort_t volid) :
+ TObject(),
+ fX(0),
+ fY(0),
+ fZ(0),
+ fVolumeID(0)
{
// Constructor
//
}
//______________________________________________________________________________
-AliTrackPoint::AliTrackPoint(const Float_t *xyz, const Float_t *cov, UShort_t volid)
+AliTrackPoint::AliTrackPoint(const Float_t *xyz, const Float_t *cov, UShort_t volid) :
+ TObject(),
+ fX(0),
+ fY(0),
+ fZ(0),
+ fVolumeID(0)
{
// Constructor
//
//______________________________________________________________________________
AliTrackPoint::AliTrackPoint(const AliTrackPoint &p):
- TObject(p)
+ TObject(p),
+ fX(0),
+ fY(0),
+ fZ(0),
+ fVolumeID(0)
{
// Copy constructor
//
ClassImp(AliTracker)
AliTracker::AliTracker():
+ TObject(),
fX(0),
fY(0),
fZ(0),
if (!fgkFieldMap) AliWarning("Field map is not set. Call AliTracker::SetFieldMap before creating a tracker!");
}
+//__________________________________________________________________________
+AliTracker::AliTracker(const AliTracker &atr):
+ TObject(atr),
+ fX(atr.fX),
+ fY(atr.fY),
+ fZ(atr.fZ),
+ fSigmaX(atr.fSigmaX),
+ fSigmaY(atr.fSigmaY),
+ fSigmaZ(atr.fSigmaZ)
+{
+ //--------------------------------------------------------------------
+ // The default constructor.
+ //--------------------------------------------------------------------
+ if (!fgkFieldMap) AliWarning("Field map is not set. Call AliTracker::SetFieldMap before creating a tracker!");
+}
+
+//__________________________________________________________________________
void AliTracker::SetFieldMap(const AliMagF* map, Bool_t uni) {
//--------------------------------------------------------------------
//This passes the field map to the reconstruction.
class AliTracker : public TObject {
public:
- enum {kTrackInward, kTrackBack, kTrackRefit} Propagation_t; //type of propagation
+ enum Propagation_t {kTrackInward, kTrackBack, kTrackRefit}; //type of propagation
AliTracker();
- AliTracker(const AliTracker &atr): TObject(atr)
- {Fatal("Copy ctor","Not Implemented!\n");}
- // AliTracker & operator=(const AliTracker &)
- // {Fatal("= op","Not Implemented\n");return *this;}
+ AliTracker(const AliTracker &atr);
virtual ~AliTracker(){}
virtual Int_t Clusters2Tracks(AliESD *event)=0;
virtual Int_t PropagateBack(AliESD *event)=0;
ClassDef(AliV0vertexer,1) // V0 verterxer
};
-inline AliV0vertexer::AliV0vertexer() {
- fChi2max=33.;
- fDNmin=0.015; fDPmin=0.015;
- fDCAmax=0.01; fCPAmax=0.025;
- fRmin=0.5; fRmax=2.5;
- fX=fY=fZ=0.;
+inline AliV0vertexer::AliV0vertexer() :
+ TObject(),
+ fChi2max(33.),
+ fDNmin(0.015),
+ fDPmin(0.015),
+ fDCAmax(0.01),
+ fCPAmax(0.025),
+ fRmin(0.5),
+ fRmax(2.5),
+ fX(0),
+ fY(0),
+ fZ(0)
+{
}
-inline AliV0vertexer::AliV0vertexer(const Double_t cuts[7]) {
- fChi2max=cuts[0];
- fDNmin=cuts[1]; fDPmin=cuts[2];
- fDCAmax=cuts[3]; fCPAmax=cuts[4];
- fRmin=cuts[5]; fRmax=cuts[6];
- fX=fY=fZ=0.;
+inline AliV0vertexer::AliV0vertexer(const Double_t cuts[7]) :
+ TObject(),
+ fChi2max(cuts[0]),
+ fDNmin(cuts[1]),
+ fDPmin(cuts[2]),
+ fDCAmax(cuts[3]),
+ fCPAmax(cuts[4]),
+ fRmin(cuts[5]),
+ fRmax(cuts[6]),
+ fX(0),
+ fY(0),
+ fZ(0)
+{
}
inline void AliV0vertexer::SetCuts(const Double_t cuts[7]) {
ClassImp(AliVertex)
//--------------------------------------------------------------------------
-AliVertex::AliVertex() : TNamed() {
+AliVertex::AliVertex() :
+ TNamed(),
+ fSigma(0),
+ fNContributors(0)
+{
//
// Default Constructor, set everything to 0
//
for(Int_t k=0;k<3;k++) fPosition[k] = 0;
- fSigma = 0;
- fNContributors=0;
}
//--------------------------------------------------------------------------
AliVertex::AliVertex(Double_t position[3],Double_t dispersion,
- Int_t nContributors): TNamed() {
+ Int_t nContributors):
+ TNamed(),
+ fSigma(dispersion),
+ fNContributors(nContributors)
+{
//
// Standard Constructor
//
for(Int_t k=0;k<3;k++) fPosition[k] = position[k];
- fSigma = dispersion;
- fNContributors = nContributors;
SetName("BaseVertex");
}
//--------------------------------------------------------------------------
-AliVertex::AliVertex(const AliVertex &source): TNamed(source) {
+AliVertex::AliVertex(const AliVertex &source):
+ TNamed(source),
+ fSigma(source.GetDispersion()),
+ fNContributors(source.GetNContributors())
+{
//
// Copy constructor
//
for(Int_t i=0;i<3;i++)fPosition[i] = source.fPosition[i];
- fSigma = source.GetDispersion();
- fNContributors = source.GetNContributors();
}
//--------------------------------------------------------------------------
TObject(vtxr),
fCurrentVertex(vtxr.fCurrentVertex),
fFirstEvent(vtxr.fFirstEvent),
- fLastEvent(vtxr.fLastEvent)
+ fLastEvent(vtxr.fLastEvent),
+ fDebug(vtxr.fDebug),
+ fMult(vtxr.fMult)
{
// Copy constructor
// Copies are not allowed. The method is protected to avoid misuse.
TObject(),
fVert(),
fCurrentVertex(0),
+fMinTracks(2),
+fMinITSClusters(5),
fTrkArray(),
fTrksToSkip(0),
fNTrksToSkip(0),
fDCAcut(0),
fAlgo(1),
+fNSigma(3),
fDebug(0)
{
//
TObject(),
fVert(),
fCurrentVertex(0),
+fMinTracks(2),
+fMinITSClusters(5),
fTrkArray(),
fTrksToSkip(0),
fNTrksToSkip(0),
fDCAcut(0),
fAlgo(1),
+fNSigma(3),
fDebug(0)
{
//
// fAlgo=5 finds the average point among DCA points of all pairs of tracks
// approximated as straight lines
+ private:
+ AliVertexerTracks(const AliVertexerTracks & source);
+ AliVertexerTracks & operator=(const AliVertexerTracks & source);
ClassDef(AliVertexerTracks,4) // 3D Vertexing with ESD tracks
};
//___________________________________________________________________________
AliXMLCollection::AliXMLCollection() :
TObject(),
- fCollectionName(0)
+ fCollectionName(),
+ fout()
{
//Default constructor
}
fBranches(0),
fTree(new TTree(treename, treename)),
fCurrentIndex(0),
+ fId(0),
fNextName(),
fNextNameCounter(),
fStatus(0)
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff