}
}
//____________________________
-AliFemtoAnalysis::AliFemtoAnalysis(){
+AliFemtoAnalysis::AliFemtoAnalysis() :
+ fPicoEventCollectionVectorHideAway(0),
+ fPairCut(0),
+ fCorrFctnCollection(0),
+ fEventCut(0),
+ fFirstParticleCut(0),
+ fSecondParticleCut(0),
+ fMixingBuffer(0),
+ fPicoEvent(0),
+ fNumEventsToMix(0),
+ fNeventsProcessed(0),
+ fMinSizePartCollection(0)
+{
// mControlSwitch = 0;
- fEventCut = 0;
- fFirstParticleCut = 0;
- fSecondParticleCut = 0;
- fPairCut = 0;
- fCorrFctnCollection= 0;
fCorrFctnCollection = new AliFemtoCorrFctnCollection;
fMixingBuffer = new AliFemtoPicoEventCollection;
- fNeventsProcessed = 0;
- fPicoEvent=0;
-
- fPicoEventCollectionVectorHideAway = 0;
-
- fMinSizePartCollection=0; // minimum # particles in ParticleCollection
-
}
//____________________________
-AliFemtoAnalysis::AliFemtoAnalysis(const AliFemtoAnalysis& a) : AliFemtoBaseAnalysis() {
+AliFemtoAnalysis::AliFemtoAnalysis(const AliFemtoAnalysis& a) :
+ AliFemtoBaseAnalysis(),
+ fPicoEventCollectionVectorHideAway(0),
+ fPairCut(0),
+ fCorrFctnCollection(0),
+ fEventCut(0),
+ fFirstParticleCut(0),
+ fSecondParticleCut(0),
+ fMixingBuffer(0),
+ fPicoEvent(0),
+ fNumEventsToMix(0),
+ fNeventsProcessed(0),
+ fMinSizePartCollection(0)
+{
//AliFemtoAnalysis();
- fEventCut = 0;
- fFirstParticleCut = 0;
- fSecondParticleCut = 0;
- fPairCut = 0;
- fCorrFctnCollection= 0;
fCorrFctnCollection = new AliFemtoCorrFctnCollection;
fMixingBuffer = new AliFemtoPicoEventCollection;
- fNeventsProcessed = 0;
- fPicoEvent=0;
// find the right event cut
fEventCut = a.fEventCut->Clone();
}
}
//______________________
+AliFemtoAnalysis& AliFemtoAnalysis::operator=(const AliFemtoAnalysis& aAna)
+{
+ if (this == &aAna)
+ return *this;
+
+ fCorrFctnCollection = new AliFemtoCorrFctnCollection;
+ fMixingBuffer = new AliFemtoPicoEventCollection;
+
+ // find the right event cut
+ fEventCut = aAna.fEventCut->Clone();
+ // find the right first particle cut
+ fFirstParticleCut = aAna.fFirstParticleCut->Clone();
+ // find the right second particle cut
+ if (aAna.fFirstParticleCut==aAna.fSecondParticleCut)
+ SetSecondParticleCut(fFirstParticleCut); // identical particle hbt
+ else
+ fSecondParticleCut = aAna.fSecondParticleCut->Clone();
+
+ fPairCut = aAna.fPairCut->Clone();
+
+ if ( fEventCut ) {
+ SetEventCut(fEventCut); // this will set the myAnalysis pointer inside the cut
+ cout << " AliFemtoAnalysis::AliFemtoAnalysis(const AliFemtoAnalysis& a) - event cut set " << endl;
+ }
+ if ( fFirstParticleCut ) {
+ SetFirstParticleCut(fFirstParticleCut); // this will set the myAnalysis pointer inside the cut
+ cout << " AliFemtoAnalysis::AliFemtoAnalysis(const AliFemtoAnalysis& a) - first particle cut set " << endl;
+ }
+ if ( fSecondParticleCut ) {
+ SetSecondParticleCut(fSecondParticleCut); // this will set the myAnalysis pointer inside the cut
+ cout << " AliFemtoAnalysis::AliFemtoAnalysis(const AliFemtoAnalysis& a) - second particle cut set " << endl;
+ } if ( fPairCut ) {
+ SetPairCut(fPairCut); // this will set the myAnalysis pointer inside the cut
+ cout << " AliFemtoAnalysis::AliFemtoAnalysis(const AliFemtoAnalysis& a) - pair cut set " << endl;
+ }
+
+ AliFemtoCorrFctnIterator iter;
+ for (iter=aAna.fCorrFctnCollection->begin(); iter!=aAna.fCorrFctnCollection->end();iter++){
+ cout << " AliFemtoAnalysis::AliFemtoAnalysis(const AliFemtoAnalysis& a) - looking for correlation functions " << endl;
+ AliFemtoCorrFctn* fctn = (*iter)->Clone();
+ if (fctn) AddCorrFctn(fctn);
+ else cout << " AliFemtoAnalysis::AliFemtoAnalysis(const AliFemtoAnalysis& a) - correlation function not found " << endl;
+ }
+
+ fNumEventsToMix = aAna.fNumEventsToMix;
+
+ fMinSizePartCollection = aAna.fMinSizePartCollection; // minimum # particles in ParticleCollection
+
+ cout << " AliFemtoAnalysis::AliFemtoAnalysis(const AliFemtoAnalysis& a) - analysis copied " << endl;
+
+ return *this;
+}
+//______________________
AliFemtoCorrFctn* AliFemtoAnalysis::CorrFctn(int n){ // return pointer to n-th correlation function
if ( n<0 || n > (int)fCorrFctnCollection->size() )
return NULL;
AliFemtoAnalysis(const AliFemtoAnalysis& OriginalAnalysis); // copy constructor
virtual ~AliFemtoAnalysis();
+ AliFemtoAnalysis& operator=(const AliFemtoAnalysis& aAna);
+
// Gets and Sets
virtual AliFemtoPairCut* PairCut();
//____________________________
-AliFemtoLikeSignAnalysis::AliFemtoLikeSignAnalysis(unsigned int bins, double min, double max) : AliFemtoAnalysis() {
+AliFemtoLikeSignAnalysis::AliFemtoLikeSignAnalysis(unsigned int bins, double min, double max) :
+ AliFemtoAnalysis(),
+ fVertexBins(0),
+ fOverFlow(0),
+ fUnderFlow(0)
+{
fVertexBins = bins;
fVertexZ[0] = min;
fVertexZ[1] = max;
/* no-op */
}
//____________________________
-AliFemtoLikeSignAnalysis::AliFemtoLikeSignAnalysis(const AliFemtoLikeSignAnalysis& a) : AliFemtoAnalysis(a) {
+AliFemtoLikeSignAnalysis::AliFemtoLikeSignAnalysis(const AliFemtoLikeSignAnalysis& a) :
+ AliFemtoAnalysis(a) ,
+ fVertexBins(0),
+ fOverFlow(0),
+ fUnderFlow(0)
+{
fVertexBins = a.fVertexBins;
fVertexZ[0] = a.fVertexZ[0];
fVertexZ[1] = a.fVertexZ[1];
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
//____________________________
-AliFemtoVertexAnalysis::AliFemtoVertexAnalysis(unsigned int bins, double min, double max){
+AliFemtoVertexAnalysis::AliFemtoVertexAnalysis(unsigned int bins, double min, double max):
+ fVertexBins(0),
+ fOverFlow(0),
+ fUnderFlow(0)
+{
// mControlSwitch = 0;
fEventCut = 0;
fFirstParticleCut = 0;
};
//____________________________
-AliFemtoVertexAnalysis::AliFemtoVertexAnalysis(const AliFemtoVertexAnalysis& a) : AliFemtoAnalysis() {
+AliFemtoVertexAnalysis::AliFemtoVertexAnalysis(const AliFemtoVertexAnalysis& a) :
+ AliFemtoAnalysis(),
+ fVertexBins(0),
+ fOverFlow(0),
+ fUnderFlow(0)
+{
//AliFemtoVertexAnalysis();
fEventCut = 0;
fFirstParticleCut = 0;
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
//____________________________
AliFemtoVertexMultAnalysis::AliFemtoVertexMultAnalysis(unsigned int binsVertex, double minVertex, double maxVertex,
unsigned int binsMult, double minMult, double maxMult)
- : fVertexZBins(binsVertex), fMultBins(binsMult) {
+ :
+ fVertexZBins(binsVertex),
+ fOverFlowVertexZ(0),
+ fUnderFlowVertexZ(0),
+ fMultBins(binsMult) ,
+ fOverFlowMult(0),
+ fUnderFlowMult(0)
+{
// mControlSwitch = 0;
fEventCut = 0;
fFirstParticleCut = 0;
};
//____________________________
-AliFemtoVertexMultAnalysis::AliFemtoVertexMultAnalysis(const AliFemtoVertexMultAnalysis& a) : AliFemtoAnalysis() {
+AliFemtoVertexMultAnalysis::AliFemtoVertexMultAnalysis(const AliFemtoVertexMultAnalysis& a) :
+ AliFemtoAnalysis(),
+ fVertexZBins(a.fVertexZBins),
+ fOverFlowVertexZ(0),
+ fUnderFlowVertexZ(0),
+ fMultBins(a.fMultBins) ,
+ fOverFlowMult(0),
+ fUnderFlowMult(0)
+{
//AliFemtoVertexMultAnalysis();
fEventCut = 0;
fFirstParticleCut = 0;
fPairCut = 0;
fCorrFctnCollection= 0;
fCorrFctnCollection = new AliFemtoCorrFctnCollection;
- fVertexZBins = a.fVertexZBins;
fVertexZ[0] = a.fVertexZ[0];
fVertexZ[1] = a.fVertexZ[1];
fUnderFlowVertexZ = 0;
fOverFlowVertexZ = 0;
- fMultBins = a.fMultBins;
fMult[0] = a.fMult[0];
fMult[1] = a.fMult[1];
fUnderFlowMult = 0;
friend class AliFemtoBaseAnalysis;
public:
- AliFemtoCorrFctn(){/* no-op */};
+ AliFemtoCorrFctn();
AliFemtoCorrFctn(const AliFemtoCorrFctn& aCorrFctn);
virtual ~AliFemtoCorrFctn(){/* no-op */};
+ AliFemtoCorrFctn& operator=(const AliFemtoCorrFctn& aCorrFctn);
virtual AliFemtoString Report() = 0;
- virtual void AddRealPair(const AliFemtoPair* aPair);
- virtual void AddMixedPair(const AliFemtoPair* aPir);
+ virtual void AddRealPair(AliFemtoPair* aPair);
+ virtual void AddMixedPair(AliFemtoPair* aPir);
virtual void EventBegin(const AliFemtoEvent* aEvent) { /* no-op */ }
virtual void EventEnd(const AliFemtoEvent* aEvent) { /* no-op */ }
};
-inline void AliFemtoCorrFctn::AddRealPair(const AliFemtoPair*) { cout << "Not implemented" << endl; }
-inline void AliFemtoCorrFctn::AddMixedPair(const AliFemtoPair*) { cout << "Not implemented" << endl; }
+inline void AliFemtoCorrFctn::AddRealPair(AliFemtoPair*) { cout << "Not implemented" << endl; }
+inline void AliFemtoCorrFctn::AddMixedPair(AliFemtoPair*) { cout << "Not implemented" << endl; }
-inline AliFemtoCorrFctn::AliFemtoCorrFctn(const AliFemtoCorrFctn& c) { fyAnalysis =0; }
+inline AliFemtoCorrFctn::AliFemtoCorrFctn(const AliFemtoCorrFctn& c):fyAnalysis(0) {}
+inline AliFemtoCorrFctn::AliFemtoCorrFctn(): fyAnalysis(0) {/* no-op */};
inline void AliFemtoCorrFctn::SetAnalysis(AliFemtoBaseAnalysis* analysis) { fyAnalysis = analysis; }
+inline AliFemtoCorrFctn& AliFemtoCorrFctn::operator=(const AliFemtoCorrFctn& aCorrFctn) { if (this == &aCorrFctn) return *this; fyAnalysis = aCorrFctn.fyAnalysis; return *this; }
#endif
public:
- AliFemtoEventCut(){/* no-op */}; // default constructor. - Users should write their own
+ AliFemtoEventCut(); // default constructor. - Users should write their own
AliFemtoEventCut(const AliFemtoEventCut& c); // copy constructor
virtual ~AliFemtoEventCut(){/* no-op */}; // destructor
-
+ AliFemtoEventCut& operator=(const AliFemtoEventCut& aCut);
+
virtual bool Pass(const AliFemtoEvent* event) =0; // true if passes, false if not
virtual AliFemtoString Report() =0; // user-written method to return string describing cuts
#endif
};
-inline AliFemtoEventCut::AliFemtoEventCut(const AliFemtoEventCut& c) : AliFemtoCutMonitorHandler() { fyAnalysis=0;}
+inline AliFemtoEventCut::AliFemtoEventCut(const AliFemtoEventCut& c) : AliFemtoCutMonitorHandler(), fyAnalysis(0) { }
inline void AliFemtoEventCut::SetAnalysis(AliFemtoBaseAnalysis* analysis) { fyAnalysis = analysis; }
+inline AliFemtoEventCut::AliFemtoEventCut(): AliFemtoCutMonitorHandler(), fyAnalysis(0){}; // default constructor. - Users should write their own
+inline AliFemtoEventCut& AliFemtoEventCut::operator=(const AliFemtoEventCut& aCut) { if (this == &aCut) return *this; fyAnalysis = aCut.fyAnalysis; return *this; }
#endif
ClassImp(AliFemtoEventReader)
#endif
+AliFemtoEventReader::AliFemtoEventReader(const AliFemtoEventReader& aReader):
+ fEventCut(0),
+ fTrackCut(0),
+ fV0Cut(0),
+ fXiCut(0),
+ fKinkCut(0),
+ fReaderStatus(0),
+ fDebug(0)
+{
+ fEventCut = aReader.fEventCut;
+ fTrackCut = aReader.fTrackCut;
+ fV0Cut = aReader.fV0Cut;
+ fXiCut = aReader.fXiCut;
+ fKinkCut = aReader.fKinkCut;
+ fReaderStatus = aReader.fReaderStatus;
+ fDebug = aReader.fDebug;
+}
+
+AliFemtoEventReader& AliFemtoEventReader::operator=(const AliFemtoEventReader& aReader)
+{
+ if (this == &aReader)
+ return *this;
+
+ fEventCut = aReader.fEventCut;
+ fTrackCut = aReader.fTrackCut;
+ fV0Cut = aReader.fV0Cut;
+ fXiCut = aReader.fXiCut;
+ fKinkCut = aReader.fKinkCut;
+ fReaderStatus = aReader.fReaderStatus;
+ fDebug = aReader.fDebug;
+
+ return *this;
+}
+
+
AliFemtoString AliFemtoEventReader::Report(){
// Create a simple report from the workings of the reader
AliFemtoString temp = "\n This is the base class AliFemtoEventReader reporting";
#include "Infrastructure/AliFemtoString.h"
class AliFemtoEventReader {
-
-public:
+
+ public:
// even tho it's only a base class and never constructed, if you don't have an implementation,
// you get "AliFemtoEventReader type_info node" upon dynamical loading
- AliFemtoEventReader() : fEventCut(0), fTrackCut(0), fV0Cut(0), fXiCut(0), fKinkCut(0), fDebug(1) { /* no-op */ }
+ AliFemtoEventReader() : fEventCut(0), fTrackCut(0), fV0Cut(0), fXiCut(0), fKinkCut(0), fReaderStatus(0), fDebug(1) { /* no-op */ };
+ AliFemtoEventReader(const AliFemtoEventReader& aReader);
virtual ~AliFemtoEventReader(){/* no-op */}
+ AliFemtoEventReader& operator=(const AliFemtoEventReader& aReader);
+
virtual AliFemtoEvent* ReturnHbtEvent() =0;
virtual AliFemtoString Report(); // user-written method to return string describing reader
public:
- AliFemtoPairCut(){/* no-op */}; // default constructor. - Users should write their own
+ AliFemtoPairCut(); // default constructor. - Users should write their own
AliFemtoPairCut(const AliFemtoPairCut& c); // copy constructor
virtual ~AliFemtoPairCut(){/* no-op */}; // destructor
+ AliFemtoPairCut& operator=(const AliFemtoPairCut &aCut);
virtual bool Pass(const AliFemtoPair* pair) =0; // true if passes, false if not
};
-inline AliFemtoPairCut::AliFemtoPairCut(const AliFemtoPairCut& c) : AliFemtoCutMonitorHandler() { fyAnalysis = 0; }
+inline AliFemtoPairCut::AliFemtoPairCut(const AliFemtoPairCut& c) : AliFemtoCutMonitorHandler(), fyAnalysis(0) { }
inline void AliFemtoPairCut::SetAnalysis(AliFemtoBaseAnalysis* analysis) { fyAnalysis = analysis; }
+inline AliFemtoPairCut::AliFemtoPairCut(): AliFemtoCutMonitorHandler(), fyAnalysis(0) {}; // default constructor. - Users should write their own
+inline AliFemtoPairCut& AliFemtoPairCut::operator=(const AliFemtoPairCut &aCut) { if (this == &aCut) return *this; fyAnalysis = aCut.fyAnalysis; return *this; }
+
#endif
friend class AliFemtoBaseAnalysis;
public:
- AliFemtoParticleCut(){/* no-op */}; // default constructor. - Users should write their own
+ AliFemtoParticleCut(); // default constructor. - Users should write their own
AliFemtoParticleCut(const AliFemtoParticleCut&); // copy constructor
virtual ~AliFemtoParticleCut(){/* no-op */}; // destructor
+ AliFemtoParticleCut& operator=(const AliFemtoParticleCut& aCut);
virtual AliFemtoString Report() =0; // user-written method to return string describing cuts
void SetAnalysis(AliFemtoBaseAnalysis*);
protected:
- double fMass;
AliFemtoBaseAnalysis* fyAnalysis; // Link to the base analysis class
+ double fMass;
#ifdef __ROOT__
ClassDef(AliFemtoParticleCut, 0)
#endif
};
-inline AliFemtoParticleCut::AliFemtoParticleCut(const AliFemtoParticleCut& c) : AliFemtoCutMonitorHandler() {
+inline AliFemtoParticleCut::AliFemtoParticleCut(): AliFemtoCutMonitorHandler(), fyAnalysis(0), fMass(0){}; // default constructor. - Users should write their own
+inline AliFemtoParticleCut::AliFemtoParticleCut(const AliFemtoParticleCut& c): AliFemtoCutMonitorHandler(), fyAnalysis(0), fMass(0) {
fMass = c.fMass; fyAnalysis = 0;
#ifdef STHBTDEBUG
cout << " AliFemtoParticleCut::AliFemtoParticleCut(const AliFemtoParticleCut& c) - fMass: " << fMass << endl;
#endif
}
inline void AliFemtoParticleCut::SetAnalysis(AliFemtoBaseAnalysis* analysis) { fyAnalysis = analysis; }
+inline AliFemtoParticleCut& AliFemtoParticleCut::operator=(const AliFemtoParticleCut& aCut) { if (this == &aCut) return *this; fyAnalysis = aCut.fyAnalysis; fMass=aCut.fMass; return *this; }
#endif
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
#endif
//____________________________
-AliFemtoBPLCMS3DCorrFctn::AliFemtoBPLCMS3DCorrFctn(char* title, const int& nbins, const float& QLo, const float& QHi){
+AliFemtoBPLCMS3DCorrFctn::AliFemtoBPLCMS3DCorrFctn(char* title, const int& nbins, const float& QLo, const float& QHi)
+ :
+ fIDNumHisto(0),
+ fIDDenHisto(0),
+ fIDRatHisto(0),
+ fSMNumHisto(0),
+ fSMDenHisto(0),
+ fSMRatHisto(0),
+ fCorrectionHisto(0),
+ fCorrCFHisto(0),
+ fNumerator(0),
+ fDenominator(0),
+ fRatio(0),
+ fQinvHisto(0),
+ fLambda(0),
+ fRout2(0),
+ fRside2(0),
+ fRlong2(0),
+ fPairCut(0),
+ fQinvNormLo(0),
+ fQinvNormHi(0),
+ fNumRealsNorm(0),
+ fNumMixedNorm(0)
+{
// set some stuff...
fQinvNormLo = 0.15;
}
+AliFemtoBPLCMS3DCorrFctn::AliFemtoBPLCMS3DCorrFctn(const AliFemtoBPLCMS3DCorrFctn& aCorrFctn) :
+ fIDNumHisto(0),
+ fIDDenHisto(0),
+ fIDRatHisto(0),
+ fSMNumHisto(0),
+ fSMDenHisto(0),
+ fSMRatHisto(0),
+ fCorrectionHisto(0),
+ fCorrCFHisto(0),
+ fNumerator(0),
+ fDenominator(0),
+ fRatio(0),
+ fQinvHisto(0),
+ fLambda(0),
+ fRout2(0),
+ fRside2(0),
+ fRlong2(0),
+ fPairCut(0),
+ fQinvNormLo(0),
+ fQinvNormHi(0),
+ fNumRealsNorm(0),
+ fNumMixedNorm(0)
+{
+ fIDNumHisto = aCorrFctn.fIDNumHisto;
+ fIDDenHisto = aCorrFctn.fIDDenHisto;
+ fIDRatHisto = aCorrFctn.fIDRatHisto;
+ fSMNumHisto = aCorrFctn.fSMNumHisto;
+ fSMDenHisto = aCorrFctn.fSMDenHisto;
+ fSMRatHisto = aCorrFctn.fSMRatHisto;
+ fCorrectionHisto = aCorrFctn.fCorrectionHisto;
+ fCorrCFHisto = aCorrFctn.fCorrCFHisto;
+ fNumerator = aCorrFctn.fNumerator;
+ fDenominator = aCorrFctn.fDenominator;
+ fRatio = aCorrFctn.fRatio;
+ fQinvHisto = aCorrFctn.fQinvHisto;
+ fLambda = aCorrFctn.fLambda;
+ fRout2 = aCorrFctn.fRout2;
+ fRside2 = aCorrFctn.fRside2;
+ fRlong2 = aCorrFctn.fRlong2;
+ fPairCut = aCorrFctn.fPairCut;
+ fQinvNormLo = aCorrFctn.fQinvNormLo;
+ fQinvNormHi = aCorrFctn.fQinvNormHi;
+ fNumRealsNorm = aCorrFctn.fNumRealsNorm;
+ fNumMixedNorm = aCorrFctn.fNumMixedNorm;
+}
//____________________________
AliFemtoBPLCMS3DCorrFctn::~AliFemtoBPLCMS3DCorrFctn(){
delete fNumerator;
delete fCorrectionHisto;
delete fCorrCFHisto;
}
+//_________________________
+AliFemtoBPLCMS3DCorrFctn& AliFemtoBPLCMS3DCorrFctn::operator=(const AliFemtoBPLCMS3DCorrFctn& aCorrFctn)
+{
+ if (this == &aCorrFctn)
+ return *this;
+ if (fIDNumHisto) delete fIDNumHisto;
+ fIDNumHisto = new TH3D(*aCorrFctn.fIDNumHisto);
+ if (fIDDenHisto) delete fIDDenHisto;
+ fIDDenHisto = new TH3D(*aCorrFctn.fIDDenHisto);
+ if (fIDRatHisto) delete fIDRatHisto;
+ fIDRatHisto = new TH3D(*aCorrFctn.fIDRatHisto);
+ if (fSMNumHisto) delete fSMNumHisto;
+ fSMNumHisto = new TH3D(*aCorrFctn.fSMNumHisto);
+ if (fSMDenHisto) delete fSMDenHisto;
+ fSMDenHisto = new TH3D(*aCorrFctn.fSMDenHisto);
+ if (fSMRatHisto) delete fSMRatHisto;
+ fSMRatHisto = new TH3D(*aCorrFctn.fSMRatHisto);
+
+ if (fCorrectionHisto) delete fCorrectionHisto;
+ fCorrectionHisto = new TH3D(*aCorrFctn.fCorrectionHisto);
+ if (fCorrCFHisto) delete fCorrCFHisto;
+ fCorrCFHisto = new TH3D(*aCorrFctn.fCorrCFHisto);
+ if (fNumerator) delete fNumerator;
+ fNumerator = new TH3D(*aCorrFctn.fNumerator);
+ if (fDenominator) delete fDenominator;
+ fDenominator = new TH3D(*aCorrFctn.fDenominator);
+ if (fRatio) delete fRatio;
+ fRatio = new TH3D(*aCorrFctn.fRatio);
+ if (fQinvHisto) delete fQinvHisto;
+ fQinvHisto = new TH3D(*aCorrFctn.fQinvHisto);
+
+ fLambda = aCorrFctn.fLambda;
+ fRout2 = aCorrFctn.fRout2;
+ fRside2 = aCorrFctn.fRside2;
+ fRlong2 = aCorrFctn.fRlong2;
+ fPairCut = aCorrFctn.fPairCut;
+ fQinvNormLo = aCorrFctn.fQinvNormLo;
+ fQinvNormHi = aCorrFctn.fQinvNormHi;
+ fNumRealsNorm = aCorrFctn.fNumRealsNorm;
+ fNumMixedNorm = aCorrFctn.fNumMixedNorm;
+
+ return *this;
+}
//_________________________
void AliFemtoBPLCMS3DCorrFctn::WriteOutHistos(){
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
class AliFemtoBPLCMS3DCorrFctn : public AliFemtoCorrFctn {
public:
AliFemtoBPLCMS3DCorrFctn(char* title, const int& nbins, const float& QLo, const float& QHi);
+ AliFemtoBPLCMS3DCorrFctn(const AliFemtoBPLCMS3DCorrFctn& aCorrFctn);
virtual ~AliFemtoBPLCMS3DCorrFctn();
+ AliFemtoBPLCMS3DCorrFctn& operator=(const AliFemtoBPLCMS3DCorrFctn& aCorrFctn);
+
virtual AliFemtoString Report();
virtual void AddRealPair(const AliFemtoPair*);
virtual void AddMixedPair(const AliFemtoPair*);
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
#endif
//____________________________
-AliFemtoQinvCorrFctn::AliFemtoQinvCorrFctn(char* title, const int& nbins, const float& QinvLo, const float& QinvHi){
+AliFemtoQinvCorrFctn::AliFemtoQinvCorrFctn(char* title, const int& nbins, const float& QinvLo, const float& QinvHi):
+ fNumerator(0),
+ fDenominator(0),
+ fRatio(0)
+{
// set up numerator
// title = "Num Qinv (MeV/c)";
char TitNum[100] = "Num";
}
+//____________________________
+AliFemtoQinvCorrFctn::AliFemtoQinvCorrFctn(const AliFemtoQinvCorrFctn& aCorrFctn) :
+ fNumerator(0),
+ fDenominator(0),
+ fRatio(0)
+{
+ fNumerator = new TH1D(*aCorrFctn.fNumerator);
+ fDenominator = new TH1D(*aCorrFctn.fDenominator);
+ fRatio = new TH1D(*aCorrFctn.fRatio);
+}
//____________________________
AliFemtoQinvCorrFctn::~AliFemtoQinvCorrFctn(){
delete fNumerator;
delete fDenominator;
delete fRatio;
}
+//_________________________
+AliFemtoQinvCorrFctn& AliFemtoQinvCorrFctn::operator=(const AliFemtoQinvCorrFctn& aCorrFctn)
+{
+ if (this == &aCorrFctn)
+ return *this;
+
+ if (fNumerator) delete fNumerator;
+ fNumerator = new TH1D(*aCorrFctn.fNumerator);
+ if (fDenominator) delete fDenominator;
+ fDenominator = new TH1D(*aCorrFctn.fDenominator);
+ if (fRatio) delete fRatio;
+ fRatio = new TH1D(*aCorrFctn.fRatio);
+
+ return *this;
+}
+
//_________________________
void AliFemtoQinvCorrFctn::Finish(){
// here is where we should normalize, fit, etc...
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
class AliFemtoQinvCorrFctn : public AliFemtoCorrFctn {
public:
AliFemtoQinvCorrFctn(char* title, const int& nbins, const float& QinvLo, const float& QinvHi);
+ AliFemtoQinvCorrFctn(const AliFemtoQinvCorrFctn& aCorrFctn);
virtual ~AliFemtoQinvCorrFctn();
+ AliFemtoQinvCorrFctn& operator=(const AliFemtoQinvCorrFctn& aCorrFctn);
+
virtual AliFemtoString Report();
virtual void AddRealPair(const AliFemtoPair*);
virtual void AddMixedPair(const AliFemtoPair*);
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
ClassImp(AliFemtoBasicEventCut)
#endif
-AliFemtoBasicEventCut::AliFemtoBasicEventCut(){
- fNEventsPassed = fNEventsFailed = 0;
+AliFemtoBasicEventCut::AliFemtoBasicEventCut() :
+ fNEventsPassed(0), fNEventsFailed(0)
+{
+ /* no-op */
}
//------------------------------
//AliFemtoBasicEventCut::~AliFemtoBasicEventCut(){
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
inline int AliFemtoBasicEventCut::NEventsPassed() {return fNEventsPassed;}
inline int AliFemtoBasicEventCut::NEventsFailed() {return fNEventsFailed;}
inline AliFemtoBasicEventCut* AliFemtoBasicEventCut::Clone() { AliFemtoBasicEventCut* c = new AliFemtoBasicEventCut(*this); return c;}
-inline AliFemtoBasicEventCut::AliFemtoBasicEventCut(AliFemtoBasicEventCut& c) : AliFemtoEventCut(c) {
+inline AliFemtoBasicEventCut::AliFemtoBasicEventCut(AliFemtoBasicEventCut& c) : AliFemtoEventCut(c), fNEventsPassed(0), fNEventsFailed(0) {
fEventMult[0] = c.fEventMult[0];
fEventMult[1] = c.fEventMult[1];
fVertZPos[0] = c.fVertZPos[0];
fVertZPos[1] = c.fVertZPos[1];
- fNEventsPassed = 0;
- fNEventsFailed = 0;
}
ClassImp(AliFemtoBasicTrackCut)
#endif
-AliFemtoBasicTrackCut::AliFemtoBasicTrackCut(){
+AliFemtoBasicTrackCut::AliFemtoBasicTrackCut():
+ fCharge(0),
+ fNTracksPassed(0),
+ fNTracksFailed(0)
+{
fNTracksPassed = fNTracksFailed = 0;
fCharge = 1; // takes both charges 0
fNSigmaPion[0] = -100.0; fNSigmaPion[1] = 100.0;
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007-03-07 10:14:49 mchojnacki
* First version on CVS
*
#endif
//__________________
-AliFemtoDummyPairCut::AliFemtoDummyPairCut(){
- fNPairsPassed = fNPairsFailed = 0;
+AliFemtoDummyPairCut::AliFemtoDummyPairCut() :
+ fNPairsPassed(0),
+ fNPairsFailed(0)
+{
+ /* no-op */
}
//__________________
//AliFemtoDummyPairCut::~AliFemtoDummyPairCut(){
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
#endif
};
-inline AliFemtoDummyPairCut::AliFemtoDummyPairCut(const AliFemtoDummyPairCut& c) : AliFemtoPairCut(c) {
- fNPairsPassed = 0;
- fNPairsFailed = 0;
-
-}
+inline AliFemtoDummyPairCut::AliFemtoDummyPairCut(const AliFemtoDummyPairCut& c) : AliFemtoPairCut(c), fNPairsPassed(0), fNPairsFailed(0) { /* no-op */ }
inline AliFemtoDummyPairCut* AliFemtoDummyPairCut::Clone() { AliFemtoDummyPairCut* c = new AliFemtoDummyPairCut(*this); return c;}
#endif
***************************************************************************
*
* $Log$
+ * Revision 1.3 2007/04/27 07:24:34 akisiel
+ * Make revisions needed for compilation from the main AliRoot tree
+ *
* Revision 1.1.1.1 2007/04/25 15:38:41 panos
* Importing the HBT code dir
*
ClassImp(AliFemtoCoulomb)
#endif
-AliFemtoCoulomb::AliFemtoCoulomb() {
+AliFemtoCoulomb::AliFemtoCoulomb() :
+ fFile(""),
+ fRadius(-1.0),
+ fZ1Z2(1.0),
+ fNLines(0)
+{
fFile = "/afs/rhic/star/hbt/coul/AliFemtoCorrectionFiles/correctionpp.dat";
if (!fFile) {
cout << " No file, dummy!" << endl;
assert(0);
}
- fRadius = -1.0;
- fZ1Z2 = 1.0; // Default has been set up to be same sign charges
cout << "You have 1 default Coulomb correction!" << endl;
}
-AliFemtoCoulomb::AliFemtoCoulomb(const char* readFile, const double& radius, const double& charge) {
+AliFemtoCoulomb::AliFemtoCoulomb(const AliFemtoCoulomb& aCoul) :
+ fFile(aCoul.fFile),
+ fRadius(aCoul.fRadius),
+ fZ1Z2(aCoul.fZ1Z2),
+ fNLines(0)
+{
+ CreateLookupTable(fRadius);
+}
+
+AliFemtoCoulomb::AliFemtoCoulomb(const char* readFile, const double& radius, const double& charge) :
+ fFile(readFile),
+ fRadius(radius),
+ fZ1Z2(0),
+ fNLines(0)
+{
fFile = readFile;
fRadius = radius;
CreateLookupTable(fRadius);
}
+AliFemtoCoulomb& AliFemtoCoulomb::operator=(const AliFemtoCoulomb& aCoul)
+{
+ if (this == &aCoul)
+ return *this;
+
+ fFile = aCoul.fFile;
+ fRadius = aCoul.fRadius;
+ fZ1Z2 = aCoul.fZ1Z2;
+
+ CreateLookupTable(fRadius);
+
+ return *this;
+}
+
+
void AliFemtoCoulomb::SetRadius(const double& radius) {
cout << " AliFemtoCoulomb::setRadius() " << endl;
fRadius = radius;
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
public:
AliFemtoCoulomb();
AliFemtoCoulomb(const char *readFile, const double& radius, const double& charge);
+ AliFemtoCoulomb(const AliFemtoCoulomb& aCoul);
virtual ~AliFemtoCoulomb();
+ AliFemtoCoulomb& operator=(const AliFemtoCoulomb& aCoul);
+
void SetRadius(const double& radius);
double GetRadius();
void SetFile(const char *readFile);
ClassImp(AliFemtoCutMonitorHandler)
#endif
// ---------------------------------------------------------------------------
-AliFemtoCutMonitorHandler::AliFemtoCutMonitorHandler() {
+AliFemtoCutMonitorHandler::AliFemtoCutMonitorHandler():
+ fCollectionsEmpty(0), fPassColl(0), fFailColl(0)
+ {
cout << " *** AliFemtoCutMonitorHandler::AliFemtoCutMonitorHandler() " << endl;
fCollectionsEmpty = 0;
fPassColl = new AliFemtoCutMonitorCollection();
fFailColl = new AliFemtoCutMonitorCollection();
}
+// ---------------------------------------------------------------------------
+AliFemtoCutMonitorHandler::AliFemtoCutMonitorHandler(const AliFemtoCutMonitorHandler& aHan):
+ fCollectionsEmpty(0), fPassColl(0), fFailColl(0)
+{
+ fCollectionsEmpty = aHan.fCollectionsEmpty;
+ fPassColl = new AliFemtoCutMonitorCollection();
+ AliFemtoCutMonitorIterator iter;
+ for (iter=aHan.fPassColl->begin(); iter!=aHan.fPassColl->end(); iter++){
+ fPassColl->push_back(*iter);
+ }
+ fFailColl = new AliFemtoCutMonitorCollection();
+ for (iter=aHan.fFailColl->begin(); iter!=aHan.fFailColl->end(); iter++){
+ fFailColl->push_back(*iter);
+ }
+}
+
// ---------------------------------------------------------------------------
AliFemtoCutMonitorHandler::~AliFemtoCutMonitorHandler() {
delete fPassColl;
delete fFailColl;
}
+//__________________________
+AliFemtoCutMonitorHandler& AliFemtoCutMonitorHandler::operator=(const AliFemtoCutMonitorHandler& aHan)
+{
+ if (this == &aHan)
+ return *this;
+
+ AliFemtoCutMonitorIterator iter;
+ if (fPassColl) {
+ fPassColl->clear();
+ delete fPassColl;
+ }
+ if (fFailColl) {
+ fFailColl->clear();
+ delete fFailColl;
+ }
+ fPassColl = new AliFemtoCutMonitorCollection();
+ for (iter=aHan.fPassColl->begin(); iter!=aHan.fPassColl->end(); iter++){
+ fPassColl->push_back(*iter);
+ }
+ fFailColl = new AliFemtoCutMonitorCollection();
+ for (iter=aHan.fFailColl->begin(); iter!=aHan.fFailColl->end(); iter++){
+ fFailColl->push_back(*iter);
+ }
+ return *this;
+}
+
// ---------------------------------------------------------------------------
void AliFemtoCutMonitorHandler::FillCutMonitor(const AliFemtoEvent* event, bool pass) {
if (fCollectionsEmpty) return;
public:
AliFemtoCutMonitorHandler();
+ AliFemtoCutMonitorHandler(const AliFemtoCutMonitorHandler& aHan);
virtual ~AliFemtoCutMonitorHandler();
-
+ AliFemtoCutMonitorHandler& operator=(const AliFemtoCutMonitorHandler& aHan);
+
AliFemtoCutMonitorCollection* PassMonitorColl();
AliFemtoCutMonitorCollection* FailMonitorColl();
AliFemtoCutMonitor* PassMonitor(int n);
***************************************************************************
*
* $Log$
+ * Revision 1.3 2007/04/27 07:24:34 akisiel
+ * Make revisions needed for compilation from the main AliRoot tree
+ *
* Revision 1.1.1.1 2007/04/25 15:38:41 panos
* Importing the HBT code dir
*
//___________________
-AliFemtoEvent::AliFemtoEvent(){
+AliFemtoEvent::AliFemtoEvent():
+ fEventNumber(0),
+ fRunNumber(0),
+ fNumberOfTracks(0),
+ fMagneticField(0),
+ fPrimVertPos(0,0,0),
+ fTrackCollection(0),
+ fV0Collection(0),
+ fXiCollection(0),
+ fKinkCollection(0),
+ fZDCN1Energy(0),
+ fZDCP1Energy(0),
+ fZDCN2Energy(0),
+ fZDCP2Energy(0),
+ fZDCEMEnergy(0),
+ fZDCParticipants(0),
+ fTriggerMask(0),
+ fTriggerCluster(0)
+{
fPrimVertPos[0]=-999.0;
fPrimVertPos[1]=-999.0;
fPrimVertPos[2]=-999.0;
fMagneticField=0.0;
}
//___________________
-AliFemtoEvent::AliFemtoEvent(const AliFemtoEvent& ev, AliFemtoTrackCut* tCut, AliFemtoV0Cut* vCut, AliFemtoXiCut* xCut, AliFemtoKinkCut* kCut){ // copy constructor with track and v0 cuts
+AliFemtoEvent::AliFemtoEvent(const AliFemtoEvent& ev, AliFemtoTrackCut* tCut, AliFemtoV0Cut* vCut, AliFemtoXiCut* xCut, AliFemtoKinkCut* kCut):
+ fEventNumber(0),
+ fRunNumber(0),
+ fNumberOfTracks(0),
+ fMagneticField(0),
+ fPrimVertPos(0,0,0),
+ fTrackCollection(0),
+ fV0Collection(0),
+ fXiCollection(0),
+ fKinkCollection(0),
+ fZDCN1Energy(0),
+ fZDCP1Energy(0),
+ fZDCN2Energy(0),
+ fZDCP2Energy(0),
+ fZDCEMEnergy(0),
+ fZDCParticipants(0),
+ fTriggerMask(0),
+ fTriggerCluster(0)
+{ // copy constructor with track and v0 cuts
//cout << "AliFemtoEvent::AliFemtoEvent(const AliFemtoEvent& ev, AliFemtoTrackCut* tCut, AliFemtoV0Cut* vCut, AliFemtoV0Cut* kCut)" << endl;
fEventNumber = ev.fEventNumber;
fRunNumber = ev.fRunNumber;
}
}
}
+//______________________________
+AliFemtoEvent& AliFemtoEvent::operator=(const AliFemtoEvent& aEvent)
+{
+ if (this == &aEvent)
+ return *this;
+
+ fEventNumber = aEvent.fEventNumber;
+ fRunNumber = aEvent.fRunNumber;
+
+ fZDCN1Energy=aEvent.fZDCN1Energy;
+ fZDCP1Energy=aEvent.fZDCP1Energy;
+ fZDCN2Energy=aEvent.fZDCN2Energy;
+ fZDCP2Energy=aEvent.fZDCP2Energy;
+ fZDCEMEnergy=aEvent.fZDCEMEnergy;
+ fZDCParticipants=aEvent.fZDCParticipants;
+ fNumberOfTracks = aEvent.fNumberOfTracks;
+ fMagneticField= aEvent.fMagneticField;
+
+ fTriggerMask=aEvent.fTriggerMask; // Trigger Type (mask)
+ fTriggerCluster=aEvent.fTriggerCluster;
+ // create collections
+ fTrackCollection = new AliFemtoTrackCollection;
+ fV0Collection = new AliFemtoV0Collection;
+ fXiCollection = new AliFemtoXiCollection;
+ fKinkCollection = new AliFemtoKinkCollection;
+ // copy track collection
+ for ( AliFemtoTrackIterator tIter=aEvent.fTrackCollection->begin(); tIter!=aEvent.fTrackCollection->end(); tIter++) {
+ AliFemtoTrack* trackCopy = new AliFemtoTrack(**tIter);
+ fTrackCollection->push_back(trackCopy);
+ }
+ // copy v0 collection
+ for ( AliFemtoV0Iterator vIter=aEvent.fV0Collection->begin(); vIter!=aEvent.fV0Collection->end(); vIter++) {
+ AliFemtoV0* v0Copy = new AliFemtoV0(**vIter);
+ fV0Collection->push_back(v0Copy);
+ }
+ // copy xi collection
+ for ( AliFemtoXiIterator xIter=aEvent.fXiCollection->begin(); xIter!=aEvent.fXiCollection->end(); xIter++) {
+ AliFemtoXi* xiCopy = new AliFemtoXi(**xIter);
+ fXiCollection->push_back(xiCopy);
+ }
+ // copy kink collection
+ for ( AliFemtoKinkIterator kIter=aEvent.fKinkCollection->begin(); kIter!=aEvent.fKinkCollection->end(); kIter++) {
+ AliFemtoKink* kinkCopy = new AliFemtoKink(**kIter);
+ fKinkCollection->push_back(kinkCopy);
+ }
+
+ return *this;
+}
+
//___________________
AliFemtoEvent::~AliFemtoEvent(){
#ifdef STHBTDEBUG
*
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
#endif
AliFemtoEvent(const AliFemtoEvent&, AliFemtoTrackCut* =0, AliFemtoV0Cut* =0, AliFemtoXiCut* =0, AliFemtoKinkCut* =0); // copy constructor with track and v0 cuts
~AliFemtoEvent();
+ AliFemtoEvent& operator=(const AliFemtoEvent& aEvent);
unsigned short EventNumber() const;
int RunNumber() const;
***********************************************************************
*
* $Log$
+ * Revision 1.3 2007/04/27 07:24:34 akisiel
+ * Make revisions needed for compilation from the main AliRoot tree
+ *
* Revision 1.1.1.1 2007/04/25 15:38:41 panos
* Importing the HBT code dir
*
#include "Infrastructure/phys_constants.h"
#include "Infrastructure/AliFemtoTrack.h"
// -----------------------------------------------------------------------
-AliFemtoKink::AliFemtoKink(const AliFemtoKink& k){ // copy constructor
+AliFemtoKink::AliFemtoKink():
+ fDcaParentDaughter(0), fDcaDaughterPrimaryVertex(0),
+ fDcaParentPrimaryVertex(0), fHitDistanceParentDaughter(0),
+ fHitDistanceParentVertex(0),
+ fDecayAngle(0), fDecayAngleCM(0),
+ fDaughter(),
+ mParent(),
+ mPosition(0,0,0)
+{/* no-op */}
+// -----------------------------------------------------------------------
+AliFemtoKink::AliFemtoKink(const AliFemtoKink& k):
+ fDcaParentDaughter(0), fDcaDaughterPrimaryVertex(0),
+ fDcaParentPrimaryVertex(0), fHitDistanceParentDaughter(0),
+ fHitDistanceParentVertex(0),
+ fDecayAngle(0), fDecayAngleCM(0),
+ fDaughter(),
+ mParent(),
+ mPosition(0,0,0)
+{ // copy constructor
fDcaParentDaughter = k.fDcaParentDaughter;
fDcaDaughterPrimaryVertex = k.fDcaDaughterPrimaryVertex;
***********************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
class AliFemtoKink {
public:
- AliFemtoKink(){/* no-op */}
+ AliFemtoKink();
AliFemtoKink( const AliFemtoKink&); // copy constructor
#ifndef __NO_STAR_DEPENDENCE_ALLOWED__
#ifdef __ROOT__
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
//____________________________
-AliFemtoManager::AliFemtoManager(){
+AliFemtoManager::AliFemtoManager():
+ fAnalysisCollection(0),
+ fEventReader(0),
+ fEventWriterCollection(0)
+{
fAnalysisCollection = new AliFemtoAnalysisCollection;
fEventWriterCollection = new AliFemtoEventWriterCollection;
fEventReader = 0;
}
+//____________________________
+AliFemtoManager::AliFemtoManager(const AliFemtoManager& aManager) :
+ fAnalysisCollection(0),
+ fEventReader(0),
+ fEventWriterCollection(0)
+{
+ fEventReader = aManager.fEventReader;
+ AliFemtoAnalysisIterator AnalysisIter;
+ fAnalysisCollection = new AliFemtoAnalysisCollection;
+ for (AnalysisIter=aManager.fAnalysisCollection->begin();AnalysisIter!=aManager.fAnalysisCollection->end();AnalysisIter++){
+ fAnalysisCollection->push_back(*AnalysisIter);
+ }
+ AliFemtoEventWriterIterator EventWriterIter;
+ fEventWriterCollection = new AliFemtoEventWriterCollection;
+ for (EventWriterIter=aManager.fEventWriterCollection->begin();EventWriterIter!=aManager.fEventWriterCollection->end();EventWriterIter++){
+ fEventWriterCollection->push_back(*EventWriterIter);
+ }
+}
+
//____________________________
AliFemtoManager::~AliFemtoManager(){
delete fEventReader;
}
delete fEventWriterCollection;
}
+//____________________________
+AliFemtoManager& AliFemtoManager::operator=(const AliFemtoManager& aManager)
+{
+ if (this == &aManager)
+ return *this;
+
+ fEventReader = aManager.fEventReader;
+ AliFemtoAnalysisIterator AnalysisIter;
+ if (fAnalysisCollection) {
+ for (AnalysisIter=fAnalysisCollection->begin();AnalysisIter!=fAnalysisCollection->end();AnalysisIter++){
+ delete *AnalysisIter;
+ *AnalysisIter = 0;
+ }
+ delete fAnalysisCollection;
+ }
+ // now delete each EventWriter in the Collection, and then the Collection itself
+ AliFemtoEventWriterIterator EventWriterIter;
+ if (fEventWriterCollection) {
+ for (EventWriterIter=fEventWriterCollection->begin();EventWriterIter!=fEventWriterCollection->end();EventWriterIter++){
+ delete *EventWriterIter;
+ *EventWriterIter = 0;
+ }
+ delete fEventWriterCollection;
+ }
+
+ fAnalysisCollection = new AliFemtoAnalysisCollection;
+ for (AnalysisIter=aManager.fAnalysisCollection->begin();AnalysisIter!=aManager.fAnalysisCollection->end();AnalysisIter++){
+ fAnalysisCollection->push_back(*AnalysisIter);
+ }
+
+ fEventWriterCollection = new AliFemtoEventWriterCollection;
+ for (EventWriterIter=aManager.fEventWriterCollection->begin();EventWriterIter!=aManager.fEventWriterCollection->end();EventWriterIter++){
+ fEventWriterCollection->push_back(*EventWriterIter);
+ }
+ return *this;
+}
+
//____________________________
int AliFemtoManager::Init(){
AliFemtoString readerMessage;
// EventReader
stemp = fEventReader->Report();
// EventWriters
- sprintf(ctemp,"\nAliFemtoManager Reporting %u EventWriters\n",fEventWriterCollection->size());
+ sprintf(ctemp,"\nAliFemtoManager Reporting %u EventWriters\n",(unsigned int) fEventWriterCollection->size());
stemp += ctemp;
AliFemtoEventWriterIterator EventWriterIter;
AliFemtoEventWriter* currentEventWriter;
stemp+=currentEventWriter->Report();
}
// Analyses
- sprintf(ctemp,"\nAliFemtoManager Reporting %u Analyses\n",fAnalysisCollection->size());
+ sprintf(ctemp,"\nAliFemtoManager Reporting %u Analyses\n",(unsigned int) fAnalysisCollection->size());
stemp += ctemp;
AliFemtoAnalysisIterator AnalysisIter;
AliFemtoBaseAnalysis* currentAnalysis;
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
public:
AliFemtoManager();
+ AliFemtoManager(const AliFemtoManager& aManager);
virtual ~AliFemtoManager();
+ AliFemtoManager& operator=(const AliFemtoManager& aManager);
+
// Gets and Sets...
AliFemtoAnalysisCollection* AnalysisCollection();
AliFemtoBaseAnalysis* Analysis(int n); // Access to Analysis within Collection
* corrected calculation of opening angle
**
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
double AliFemtoPair::fMaxDzOuter = 3.2;
-AliFemtoPair::AliFemtoPair(){
+AliFemtoPair::AliFemtoPair() :
+ fTrack1(0), fTrack2(0),
+ fNonIdParNotCalculated(0),
+ fDKSide(0),
+ fDKOut(0),
+ fDKLong(0),
+ fCVK(0),
+ kStarCalc(0),
+ fNonIdParNotCalculatedGlobal(0),
+ fMergingParNotCalculated(0),
+ fWeightedAvSep(0),
+ fFracOfMergedRow(0),
+ fClosestRowAtDCA(0),
+ fMergingParNotCalculatedTrkV0Pos(0),
+ fFracOfMergedRowTrkV0Pos(0),
+ fClosestRowAtDCATrkV0Pos(0),
+ fMergingParNotCalculatedTrkV0Neg(0),
+ fFracOfMergedRowTrkV0Neg(0),
+ fClosestRowAtDCATrkV0Neg(0),
+ fMergingParNotCalculatedV0PosV0Neg(0),
+ fFracOfMergedRowV0PosV0Neg(0),
+ fClosestRowAtDCAV0PosV0Neg(0),
+ fMergingParNotCalculatedV0NegV0Pos(0),
+ fFracOfMergedRowV0NegV0Pos(0),
+ fClosestRowAtDCAV0NegV0Pos(0),
+ fMergingParNotCalculatedV0PosV0Pos(0),
+ fFracOfMergedRowV0PosV0Pos(0),
+ fClosestRowAtDCAV0PosV0Pos(0),
+ fMergingParNotCalculatedV0NegV0Neg(0),
+ fFracOfMergedRowV0NegV0Neg(0),
+ fClosestRowAtDCAV0NegV0Neg(0)
+{
fTrack1 = 0;
fTrack2 = 0;
setDefaultHalfFieldMergingPar();
}
AliFemtoPair::AliFemtoPair(AliFemtoParticle* a, AliFemtoParticle* b)
- : fTrack1(a), fTrack2(b)
+ : fTrack1(a), fTrack2(b),
+ fNonIdParNotCalculated(0),
+ fDKSide(0),
+ fDKOut(0),
+ fDKLong(0),
+ fCVK(0),
+ kStarCalc(0),
+ fNonIdParNotCalculatedGlobal(0),
+ fMergingParNotCalculated(0),
+ fWeightedAvSep(0),
+ fFracOfMergedRow(0),
+ fClosestRowAtDCA(0),
+ fMergingParNotCalculatedTrkV0Pos(0),
+ fFracOfMergedRowTrkV0Pos(0),
+ fClosestRowAtDCATrkV0Pos(0),
+ fMergingParNotCalculatedTrkV0Neg(0),
+ fFracOfMergedRowTrkV0Neg(0),
+ fClosestRowAtDCATrkV0Neg(0),
+ fMergingParNotCalculatedV0PosV0Neg(0),
+ fFracOfMergedRowV0PosV0Neg(0),
+ fClosestRowAtDCAV0PosV0Neg(0),
+ fMergingParNotCalculatedV0NegV0Pos(0),
+ fFracOfMergedRowV0NegV0Pos(0),
+ fClosestRowAtDCAV0NegV0Pos(0),
+ fMergingParNotCalculatedV0PosV0Pos(0),
+ fFracOfMergedRowV0PosV0Pos(0),
+ fClosestRowAtDCAV0PosV0Pos(0),
+ fMergingParNotCalculatedV0NegV0Neg(0),
+ fFracOfMergedRowV0NegV0Neg(0),
+ fClosestRowAtDCAV0NegV0Neg(0)
{
setDefaultHalfFieldMergingPar();
}
AliFemtoPair::~AliFemtoPair() {/* no-op */}
-//AliFemtoPair::AliFemtoPair(const AliFemtoPair &a) {/* missing */}
+AliFemtoPair::AliFemtoPair(const AliFemtoPair &aPair):
+ fTrack1(0), fTrack2(0),
+ fNonIdParNotCalculated(0),
+ fDKSide(0),
+ fDKOut(0),
+ fDKLong(0),
+ fCVK(0),
+ kStarCalc(0),
+ fNonIdParNotCalculatedGlobal(0),
+ fMergingParNotCalculated(0),
+ fWeightedAvSep(0),
+ fFracOfMergedRow(0),
+ fClosestRowAtDCA(0),
+ fMergingParNotCalculatedTrkV0Pos(0),
+ fFracOfMergedRowTrkV0Pos(0),
+ fClosestRowAtDCATrkV0Pos(0),
+ fMergingParNotCalculatedTrkV0Neg(0),
+ fFracOfMergedRowTrkV0Neg(0),
+ fClosestRowAtDCATrkV0Neg(0),
+ fMergingParNotCalculatedV0PosV0Neg(0),
+ fFracOfMergedRowV0PosV0Neg(0),
+ fClosestRowAtDCAV0PosV0Neg(0),
+ fMergingParNotCalculatedV0NegV0Pos(0),
+ fFracOfMergedRowV0NegV0Pos(0),
+ fClosestRowAtDCAV0NegV0Pos(0),
+ fMergingParNotCalculatedV0PosV0Pos(0),
+ fFracOfMergedRowV0PosV0Pos(0),
+ fClosestRowAtDCAV0PosV0Pos(0),
+ fMergingParNotCalculatedV0NegV0Neg(0),
+ fFracOfMergedRowV0NegV0Neg(0),
+ fClosestRowAtDCAV0NegV0Neg(0)
+{
+ fTrack1 = aPair.fTrack1;
+ fTrack2 = aPair.fTrack2;
+
+ fNonIdParNotCalculated = aPair.fNonIdParNotCalculated;
+ fDKSide = aPair.fDKSide;
+ fDKOut = aPair.fDKOut;
+ fDKLong = aPair.fDKLong;
+ fCVK = aPair.fCVK;
+ kStarCalc = aPair.kStarCalc;
+
+ fNonIdParNotCalculatedGlobal = aPair.fNonIdParNotCalculatedGlobal;
+
+ fMergingParNotCalculated = aPair.fMergingParNotCalculated;
+ fWeightedAvSep = aPair.fWeightedAvSep;
+ fFracOfMergedRow = aPair.fFracOfMergedRow;
+ fClosestRowAtDCA = aPair.fClosestRowAtDCA;
+
+ fMergingParNotCalculatedTrkV0Pos = aPair.fMergingParNotCalculatedTrkV0Pos;
+ fFracOfMergedRowTrkV0Pos = aPair.fFracOfMergedRowTrkV0Pos;
+ fClosestRowAtDCATrkV0Pos = aPair.fClosestRowAtDCATrkV0Pos;
+
+ fMergingParNotCalculatedTrkV0Neg = aPair.fMergingParNotCalculatedTrkV0Neg;
+ fFracOfMergedRowTrkV0Neg = aPair.fFracOfMergedRowTrkV0Neg;
+ fClosestRowAtDCATrkV0Neg = aPair.fClosestRowAtDCATrkV0Neg;
+
+ fMergingParNotCalculatedV0PosV0Neg = aPair.fMergingParNotCalculatedV0PosV0Neg;
+ fFracOfMergedRowV0PosV0Neg = aPair.fFracOfMergedRowV0PosV0Neg;
+ fClosestRowAtDCAV0PosV0Neg = aPair.fClosestRowAtDCAV0PosV0Neg;
+
+ fMergingParNotCalculatedV0NegV0Pos = aPair.fMergingParNotCalculatedV0NegV0Pos;
+ fFracOfMergedRowV0NegV0Pos = aPair.fFracOfMergedRowV0NegV0Pos;
+ fClosestRowAtDCAV0NegV0Pos = aPair.fClosestRowAtDCAV0NegV0Pos;
+
+ fMergingParNotCalculatedV0PosV0Pos = aPair.fMergingParNotCalculatedV0PosV0Pos;
+ fFracOfMergedRowV0PosV0Pos = aPair.fFracOfMergedRowV0PosV0Pos;
+ fClosestRowAtDCAV0PosV0Pos = aPair.fClosestRowAtDCAV0PosV0Pos;
+
+ fMergingParNotCalculatedV0NegV0Neg = aPair.fMergingParNotCalculatedV0NegV0Neg;
+ fFracOfMergedRowV0NegV0Neg = aPair.fFracOfMergedRowV0NegV0Neg;
+ fClosestRowAtDCAV0NegV0Neg = aPair.fClosestRowAtDCAV0NegV0Neg;
+}
+
+AliFemtoPair& AliFemtoPair::operator=(const AliFemtoPair &aPair)
+{
+ if (this == &aPair)
+ return *this;
+
+ fTrack1 = aPair.fTrack1;
+ fTrack2 = aPair.fTrack2;
+
+ fNonIdParNotCalculated = aPair.fNonIdParNotCalculated;
+ fDKSide = aPair.fDKSide;
+ fDKOut = aPair.fDKOut;
+ fDKLong = aPair.fDKLong;
+ fCVK = aPair.fCVK;
+ kStarCalc = aPair.kStarCalc;
+
+ fNonIdParNotCalculatedGlobal = aPair.fNonIdParNotCalculatedGlobal;
-//AliFemtoPair& AliFemtoPair::operator=(const AliFemtoPair &a)
+ fMergingParNotCalculated = aPair.fMergingParNotCalculated;
+ fWeightedAvSep = aPair.fWeightedAvSep;
+ fFracOfMergedRow = aPair.fFracOfMergedRow;
+ fClosestRowAtDCA = aPair.fClosestRowAtDCA;
+
+ fMergingParNotCalculatedTrkV0Pos = aPair.fMergingParNotCalculatedTrkV0Pos;
+ fFracOfMergedRowTrkV0Pos = aPair.fFracOfMergedRowTrkV0Pos;
+ fClosestRowAtDCATrkV0Pos = aPair.fClosestRowAtDCATrkV0Pos;
+
+ fMergingParNotCalculatedTrkV0Neg = aPair.fMergingParNotCalculatedTrkV0Neg;
+ fFracOfMergedRowTrkV0Neg = aPair.fFracOfMergedRowTrkV0Neg;
+ fClosestRowAtDCATrkV0Neg = aPair.fClosestRowAtDCATrkV0Neg;
+
+ fMergingParNotCalculatedV0PosV0Neg = aPair.fMergingParNotCalculatedV0PosV0Neg;
+ fFracOfMergedRowV0PosV0Neg = aPair.fFracOfMergedRowV0PosV0Neg;
+ fClosestRowAtDCAV0PosV0Neg = aPair.fClosestRowAtDCAV0PosV0Neg;
+
+ fMergingParNotCalculatedV0NegV0Pos = aPair.fMergingParNotCalculatedV0NegV0Pos;
+ fFracOfMergedRowV0NegV0Pos = aPair.fFracOfMergedRowV0NegV0Pos;
+ fClosestRowAtDCAV0NegV0Pos = aPair.fClosestRowAtDCAV0NegV0Pos;
+
+ fMergingParNotCalculatedV0PosV0Pos = aPair.fMergingParNotCalculatedV0PosV0Pos;
+ fFracOfMergedRowV0PosV0Pos = aPair.fFracOfMergedRowV0PosV0Pos;
+ fClosestRowAtDCAV0PosV0Pos = aPair.fClosestRowAtDCAV0PosV0Pos;
+
+ fMergingParNotCalculatedV0NegV0Neg = aPair.fMergingParNotCalculatedV0NegV0Neg;
+ fFracOfMergedRowV0NegV0Neg = aPair.fFracOfMergedRowV0NegV0Neg;
+ fClosestRowAtDCAV0NegV0Neg = aPair.fClosestRowAtDCAV0NegV0Neg;
+
+ return *this;
+}
//_________________
double AliFemtoPair::mInv() const
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
class AliFemtoPair {
public:
AliFemtoPair();
+ AliFemtoPair(const AliFemtoPair& aPair);
AliFemtoPair(AliFemtoParticle*, AliFemtoParticle*);
-
-
~AliFemtoPair();
- //AliFemtoPair(const AliFemtoPair&);
- //AliFemtoPair& operator=(const AliFemtoPair&);
+ AliFemtoPair& operator=(const AliFemtoPair& aPair);
// track Gets:
AliFemtoParticle* track1() const;
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
//_____________________
-AliFemtoParticle::AliFemtoParticle() : fTrack(0), fV0(0), fKink(0), fHiddenInfo(0) {
+AliFemtoParticle::AliFemtoParticle() :
+ fTpcV0NegPosSample(0),
+ fV0NegZ(0),
+ fV0NegU(0),
+ fV0NegSect(0),
+ fTrack(0), fV0(0), fKink(0), fXi(0),
+ fFourMomentum(0),
+ fHelix(),
+ fNominalTpcExitPoint(0),
+ fNominalTpcEntrancePoint(0),
+ fHiddenInfo(0),
+ fPrimaryVertex(0),
+ fSecondaryVertex(0),
+ fHelixV0Pos(),
+ fTpcV0PosEntrancePoint(0),
+ fTpcV0PosExitPoint(0),
+ fHelixV0Neg(),
+ fTpcV0NegEntrancePoint(0),
+ fTpcV0NegExitPoint(0)
+{
/* no-op for default */
// cout << "Created particle " << this << endl;
}
//_____________________
+AliFemtoParticle::AliFemtoParticle(const AliFemtoParticle& aParticle):
+ fTpcV0NegPosSample(0),
+ fV0NegZ(0),
+ fV0NegU(0),
+ fV0NegSect(0),
+ fTrack(0), fV0(0), fKink(0), fXi(0),
+ fFourMomentum(0),
+ fHelix(),
+ fNominalTpcExitPoint(0),
+ fNominalTpcEntrancePoint(0),
+ fHiddenInfo(0),
+ fPrimaryVertex(0),
+ fSecondaryVertex(0),
+ fHelixV0Pos(),
+ fTpcV0PosEntrancePoint(0),
+ fTpcV0PosExitPoint(0),
+ fHelixV0Neg(),
+ fTpcV0NegEntrancePoint(0),
+ fTpcV0NegExitPoint(0)
+{
+ if (aParticle.fTrack)
+ fTrack = new AliFemtoTrack(*aParticle.fTrack);
+ if (aParticle.fV0)
+ fV0 = new AliFemtoV0(*aParticle.fV0);
+ if (aParticle.fKink)
+ fKink = new AliFemtoKink(*aParticle.fKink);
+ if (aParticle.fXi)
+ fXi = new AliFemtoXi(*aParticle.fXi);
+ fFourMomentum = aParticle.fFourMomentum;
+ fHelix = aParticle.fHelix;
+
+ for (int iter=0; iter<11; iter++)
+ fNominalPosSample[iter] = aParticle.fNominalPosSample[iter];
+
+ if (aParticle.fTpcV0NegPosSample) {
+ fTpcV0NegPosSample = (AliFemtoThreeVector *) malloc(sizeof(AliFemtoThreeVector) * 11);
+ for (int iter=0; iter<11; iter++)
+ fTpcV0NegPosSample[iter] = aParticle.fTpcV0NegPosSample[iter];
+ }
+
+ if (aParticle.fV0NegZ) {
+ fV0NegZ = (float *) malloc(sizeof(float) * 45);
+ for (int iter=0; iter<11; iter++)
+ fV0NegZ[iter] = aParticle.fV0NegZ[iter];
+ }
+ if (aParticle.fV0NegU) {
+ fV0NegU = (float *) malloc(sizeof(float) * 45);
+ for (int iter=0; iter<11; iter++)
+ fV0NegU[iter] = aParticle.fV0NegU[iter];
+ }
+ if (aParticle.fV0NegSect) {
+ fV0NegSect = (int *) malloc(sizeof(int) * 45);
+ for (int iter=0; iter<11; iter++)
+ fV0NegSect[iter] = aParticle.fV0NegSect[iter];
+ }
+
+ fPrimaryVertex = aParticle.fPrimaryVertex;
+ fSecondaryVertex = aParticle.fSecondaryVertex;
+ CalculatePurity();
+ if(aParticle.fHiddenInfo){
+ fHiddenInfo= aParticle.HiddenInfo()->clone();
+ }
+
+ fNominalTpcEntrancePoint = aParticle.fNominalTpcEntrancePoint;
+ fNominalTpcExitPoint = aParticle.fNominalTpcExitPoint;
+
+ for (int iter=0; iter<6; iter++)
+ fPurity[iter] = aParticle.fPurity[iter];
+
+ fHelixV0Pos = aParticle.fHelixV0Pos;
+ fTpcV0PosEntrancePoint = aParticle.fTpcV0PosEntrancePoint;
+ fTpcV0PosExitPoint = aParticle.fTpcV0PosExitPoint;
+ fHelixV0Neg = aParticle.fHelixV0Neg;
+ fTpcV0NegEntrancePoint = aParticle.fTpcV0NegEntrancePoint;
+ fTpcV0NegExitPoint = aParticle.fTpcV0NegExitPoint;
+}
+//_____________________
AliFemtoParticle::~AliFemtoParticle(){
// cout << "Issuing delete for AliFemtoParticle." << endl;
// cout << "Deleted particle " << this << endl;
}
//_____________________
-AliFemtoParticle::AliFemtoParticle(const AliFemtoTrack* const hbtTrack,const double& mass) : fTrack(0), fV0(0), fKink(0), fHiddenInfo(0) {
+AliFemtoParticle::AliFemtoParticle(const AliFemtoTrack* const hbtTrack,const double& mass) :
+ fTpcV0NegPosSample(0),
+ fV0NegZ(0),
+ fV0NegU(0),
+ fV0NegSect(0),
+ fTrack(0), fV0(0), fKink(0), fXi(0),
+ fFourMomentum(0),
+ fHelix(),
+ fNominalTpcExitPoint(0),
+ fNominalTpcEntrancePoint(0),
+ fHiddenInfo(0),
+ fPrimaryVertex(0),
+ fSecondaryVertex(0),
+ fHelixV0Pos(),
+ fTpcV0PosEntrancePoint(0),
+ fTpcV0PosExitPoint(0),
+ fHelixV0Neg(),
+ fTpcV0NegEntrancePoint(0),
+ fTpcV0NegExitPoint(0)
+{
// I know there is a better way to do this...
}
//_____________________
-AliFemtoParticle::AliFemtoParticle(const AliFemtoV0* const hbtV0,const double& mass) : fTrack(0), fV0(0), fKink(0), fHiddenInfo(0) {
+AliFemtoParticle::AliFemtoParticle(const AliFemtoV0* const hbtV0,const double& mass) :
+ fTpcV0NegPosSample(0),
+ fV0NegZ(0),
+ fV0NegU(0),
+ fV0NegSect(0),
+ fTrack(0), fV0(0), fKink(0), fXi(0),
+ fFourMomentum(0),
+ fHelix(),
+ fNominalTpcExitPoint(0),
+ fNominalTpcEntrancePoint(0),
+ fHiddenInfo(0),
+ fPrimaryVertex(0),
+ fSecondaryVertex(0),
+ fHelixV0Pos(),
+ fTpcV0PosEntrancePoint(0),
+ fTpcV0PosExitPoint(0),
+ fHelixV0Neg(),
+ fTpcV0NegEntrancePoint(0),
+ fTpcV0NegExitPoint(0)
+{
fV0 = new AliFemtoV0(*hbtV0);
//fMap[0]= 0;
//fMap[1]= 0;
// ***
}
//_____________________
-AliFemtoParticle::AliFemtoParticle(const AliFemtoKink* const hbtKink,const double& mass) : fTrack(0), fV0(0), fHiddenInfo(0) {
+AliFemtoParticle::AliFemtoParticle(const AliFemtoKink* const hbtKink,const double& mass) :
+ fTpcV0NegPosSample(0),
+ fV0NegZ(0),
+ fV0NegU(0),
+ fV0NegSect(0),
+ fTrack(0), fV0(0), fKink(0), fXi(0),
+ fFourMomentum(0),
+ fHelix(),
+ fNominalTpcExitPoint(0),
+ fNominalTpcEntrancePoint(0),
+ fHiddenInfo(0),
+ fPrimaryVertex(0),
+ fSecondaryVertex(0),
+ fHelixV0Pos(),
+ fTpcV0PosEntrancePoint(0),
+ fTpcV0PosExitPoint(0),
+ fHelixV0Neg(),
+ fTpcV0NegEntrancePoint(0),
+ fTpcV0NegExitPoint(0)
+{
fKink = new AliFemtoKink(*hbtKink);
// fMap[0]= 0;
//fMap[1]= 0;
}
//_____________________
-AliFemtoParticle::AliFemtoParticle(const AliFemtoXi* const hbtXi, const double& mass) {
+AliFemtoParticle::AliFemtoParticle(const AliFemtoXi* const hbtXi, const double& mass) :
+ fTpcV0NegPosSample(0),
+ fV0NegZ(0),
+ fV0NegU(0),
+ fV0NegSect(0),
+ fTrack(0), fV0(0), fKink(0), fXi(0),
+ fFourMomentum(0),
+ fHelix(),
+ fNominalTpcExitPoint(0),
+ fNominalTpcEntrancePoint(0),
+ fHiddenInfo(0),
+ fPrimaryVertex(0),
+ fSecondaryVertex(0),
+ fHelixV0Pos(),
+ fTpcV0PosEntrancePoint(0),
+ fTpcV0PosExitPoint(0),
+ fHelixV0Neg(),
+ fTpcV0NegEntrancePoint(0),
+ fTpcV0NegExitPoint(0)
+{
fXi = new AliFemtoXi(*hbtXi);
// fMap[0]= 0;
//fMap[1]= 0;
fHiddenInfo = 0;
}
//_____________________
+AliFemtoParticle& AliFemtoParticle::operator=(const AliFemtoParticle& aParticle)
+{
+ if (this == &aParticle)
+ return *this;
+
+ if (aParticle.fTrack)
+ fTrack = new AliFemtoTrack(*aParticle.fTrack);
+ if (aParticle.fV0)
+ fV0 = new AliFemtoV0(*aParticle.fV0);
+ if (aParticle.fKink)
+ fKink = new AliFemtoKink(*aParticle.fKink);
+ if (aParticle.fXi)
+ fXi = new AliFemtoXi(*aParticle.fXi);
+ fFourMomentum = aParticle.fFourMomentum;
+ fHelix = aParticle.fHelix;
+
+ for (int iter=0; iter<11; iter++)
+ fNominalPosSample[iter] = aParticle.fNominalPosSample[iter];
+
+ if (fTpcV0NegPosSample) delete fTpcV0NegPosSample;
+ if (aParticle.fTpcV0NegPosSample) {
+ fTpcV0NegPosSample = (AliFemtoThreeVector *) malloc(sizeof(AliFemtoThreeVector) * 11);
+ for (int iter=0; iter<11; iter++)
+ fTpcV0NegPosSample[iter] = aParticle.fTpcV0NegPosSample[iter];
+ }
+
+ if (fV0NegZ) delete fV0NegZ;
+ if (aParticle.fV0NegZ) {
+ fV0NegZ = (float *) malloc(sizeof(float) * 45);
+ for (int iter=0; iter<11; iter++)
+ fV0NegZ[iter] = aParticle.fV0NegZ[iter];
+ }
+ if (fV0NegU) delete fV0NegU;
+ if (aParticle.fV0NegU) {
+ fV0NegU = (float *) malloc(sizeof(float) * 45);
+ for (int iter=0; iter<11; iter++)
+ fV0NegU[iter] = aParticle.fV0NegU[iter];
+ }
+ if (fV0NegSect) delete fV0NegSect;
+ if (aParticle.fV0NegSect) {
+ fV0NegSect = (int *) malloc(sizeof(int) * 45);
+ for (int iter=0; iter<11; iter++)
+ fV0NegSect[iter] = aParticle.fV0NegSect[iter];
+ }
+
+ fPrimaryVertex = aParticle.fPrimaryVertex;
+ fSecondaryVertex = aParticle.fSecondaryVertex;
+ CalculatePurity();
+ if(aParticle.fHiddenInfo){
+ fHiddenInfo= aParticle.fHiddenInfo->clone();
+ }
+
+ fNominalTpcEntrancePoint = aParticle.fNominalTpcEntrancePoint;
+ fNominalTpcExitPoint = aParticle.fNominalTpcExitPoint;
+
+ if (fHiddenInfo) delete fHiddenInfo;
+ if (aParticle.fHiddenInfo)
+ fHiddenInfo = aParticle.HiddenInfo()->clone();
+
+ for (int iter=0; iter<6; iter++)
+ fPurity[iter] = aParticle.fPurity[iter];
+
+ fHelixV0Pos = aParticle.fHelixV0Pos;
+ fTpcV0PosEntrancePoint = aParticle.fTpcV0PosEntrancePoint;
+ fTpcV0PosExitPoint = aParticle.fTpcV0PosExitPoint;
+ fHelixV0Neg = aParticle.fHelixV0Neg;
+ fTpcV0NegEntrancePoint = aParticle.fTpcV0NegEntrancePoint;
+ fTpcV0NegExitPoint = aParticle.fTpcV0NegExitPoint;
+
+ return *this;
+}
+//_____________________
const AliFemtoThreeVector& AliFemtoParticle::NominalTpcExitPoint() const{
// in future, may want to calculate this "on demand" only, sot this routine may get more sophisticated
// for now, we calculate Exit and Entrance points upon instantiation
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.2 2007-04-03 16:00:08 mchojnacki
* Changes to iprove memory managing
*
class AliFemtoParticle{
public:
AliFemtoParticle();
+ AliFemtoParticle(const AliFemtoParticle& aParticle);
AliFemtoParticle(const AliFemtoTrack* const hbtTrack, const double& mass);
AliFemtoParticle(const AliFemtoV0* const hbtV0, const double& mass);
AliFemtoParticle(const AliFemtoKink* const hbtKink, const double& mass);
AliFemtoParticle(const AliFemtoXi* const hbtXi, const double& mass);
~AliFemtoParticle();
+ AliFemtoParticle& operator=(const AliFemtoParticle& aParticle);
+
const AliFemtoLorentzVector& FourMomentum() const;
AliFmPhysicalHelixD& Helix();
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
#include "Infrastructure/AliFemtoPicoEvent.h"
//________________
-AliFemtoPicoEvent::AliFemtoPicoEvent(){
+AliFemtoPicoEvent::AliFemtoPicoEvent() :
+ fFirstParticleCollection(0),
+ fSecondParticleCollection(0),
+ fThirdParticleCollection(0)
+{
fFirstParticleCollection = new AliFemtoParticleCollection;
fSecondParticleCollection = new AliFemtoParticleCollection;
fThirdParticleCollection = new AliFemtoParticleCollection;
}
//_________________
+AliFemtoPicoEvent::AliFemtoPicoEvent(const AliFemtoPicoEvent& aPicoEvent) :
+ fFirstParticleCollection(0),
+ fSecondParticleCollection(0),
+ fThirdParticleCollection(0)
+{
+ AliFemtoParticleIterator iter;
+
+ fFirstParticleCollection = new AliFemtoParticleCollection;
+ if (aPicoEvent.fFirstParticleCollection) {
+ for (iter=aPicoEvent.fFirstParticleCollection->begin();iter!=aPicoEvent.fFirstParticleCollection->end();iter++){
+ fFirstParticleCollection->push_back(*iter);
+ }
+ }
+ fSecondParticleCollection = new AliFemtoParticleCollection;
+ if (aPicoEvent.fSecondParticleCollection) {
+ for (iter=aPicoEvent.fSecondParticleCollection->begin();iter!=aPicoEvent.fSecondParticleCollection->end();iter++){
+ fSecondParticleCollection->push_back(*iter);
+ }
+ }
+ fThirdParticleCollection = new AliFemtoParticleCollection;
+ if (aPicoEvent.fThirdParticleCollection) {
+ for (iter=aPicoEvent.fThirdParticleCollection->begin();iter!=aPicoEvent.fThirdParticleCollection->end();iter++){
+ fThirdParticleCollection->push_back(*iter);
+ }
+ }
+}
+//_________________
AliFemtoPicoEvent::~AliFemtoPicoEvent(){
AliFemtoParticleIterator iter;
+
+ if (fFirstParticleCollection){
+ for (iter=fFirstParticleCollection->begin();iter!=fFirstParticleCollection->end();iter++){
+ delete *iter;
+ }
+ fFirstParticleCollection->clear();
+ delete fFirstParticleCollection;
+ fFirstParticleCollection = 0;
+ }
+
+ if (fSecondParticleCollection){
+ for (iter=fSecondParticleCollection->begin();iter!=fSecondParticleCollection->end();iter++){
+ delete *iter;
+ }
+ fSecondParticleCollection->clear();
+ delete fSecondParticleCollection;
+ fSecondParticleCollection = 0;
+ }
+ if (fThirdParticleCollection){
+ if (fThirdParticleCollection->size() != 0 ) {
+ for (iter=fThirdParticleCollection->begin();iter!=fThirdParticleCollection->end();iter++){
+ delete *iter;
+ }
+ }
+ fThirdParticleCollection->clear();
+ delete fThirdParticleCollection;
+ fThirdParticleCollection = 0;
+ }
+}
+//_________________
+ AliFemtoPicoEvent& AliFemtoPicoEvent::operator=(AliFemtoPicoEvent& aPicoEvent)
+{
+ if (this == &aPicoEvent)
+ return *this;
+ AliFemtoParticleIterator iter;
+
if (fFirstParticleCollection){
for (iter=fFirstParticleCollection->begin();iter!=fFirstParticleCollection->end();iter++){
delete *iter;
delete fThirdParticleCollection;
fThirdParticleCollection = 0;
}
+
+ fFirstParticleCollection = new AliFemtoParticleCollection;
+ if (aPicoEvent.fFirstParticleCollection) {
+ for (iter=aPicoEvent.fFirstParticleCollection->begin();iter!=aPicoEvent.fFirstParticleCollection->end();iter++){
+ fFirstParticleCollection->push_back(*iter);
+ }
+ }
+ fSecondParticleCollection = new AliFemtoParticleCollection;
+ if (aPicoEvent.fSecondParticleCollection) {
+ for (iter=aPicoEvent.fSecondParticleCollection->begin();iter!=aPicoEvent.fSecondParticleCollection->end();iter++){
+ fSecondParticleCollection->push_back(*iter);
+ }
+ }
+ fThirdParticleCollection = new AliFemtoParticleCollection;
+ if (aPicoEvent.fThirdParticleCollection) {
+ for (iter=aPicoEvent.fThirdParticleCollection->begin();iter!=aPicoEvent.fThirdParticleCollection->end();iter++){
+ fThirdParticleCollection->push_back(*iter);
+ }
+ }
+
+ return *this;
}
-//_________________
+
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
class AliFemtoPicoEvent{
public:
AliFemtoPicoEvent();
+ AliFemtoPicoEvent(const AliFemtoPicoEvent& aPicoEvent);
~AliFemtoPicoEvent();
+ AliFemtoPicoEvent& operator=(AliFemtoPicoEvent& aPicoEvent);
+
/* may want to have other stuff in here, like where is primary vertex */
AliFemtoParticleCollection* FirstParticleCollection();
inline AliFemtoParticleCollection* AliFemtoPicoEvent::SecondParticleCollection(){return fSecondParticleCollection;}
inline AliFemtoParticleCollection* AliFemtoPicoEvent::ThirdParticleCollection(){return fThirdParticleCollection;}
-
-
#endif
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
// -----------------------------------
AliFemtoPicoEventCollectionVectorHideAway::AliFemtoPicoEventCollectionVectorHideAway(int bx, double lx, double ux,
- int by, double ly, double uy,
- int bz, double lz, double uz) {
- fBinsx = bx; fMinx = lx; fMaxx = ux;
- fBinsy = by; fMiny = ly; fMaxy = uy;
- fBinsz = bz; fMinz = lz; fMaxz = uz;
-
- fBinsTot = fBinsx * fBinsy * fBinsz;
- fStepx=0; fStepx = (fMaxx-fMinx)/fBinsx;
- fStepy=0; fStepy = (fMaxy-fMiny)/fBinsy;
- fStepz=0; fStepz = (fMaxz-fMinz)/fBinsz;
-
-
- //fCollectionVector = new AliFemtoPicoEventCollectionVector();
- fCollection = 0;
- for ( int i=0; i<fBinsTot; i++) {
- fCollection = new AliFemtoPicoEventCollection();
- fCollectionVector.push_back(fCollection);
- }
+ int by, double ly, double uy,
+ int bz, double lz, double uz):
+ fBinsTot(0),
+ fBinsx(bx), fBinsy(by), fBinsz(bz),
+ fMinx(lx), fMiny(ly), fMinz(lz),
+ fMaxx(ux), fMaxy(uy), fMaxz(uz),
+ fStepx(0), fStepy(0), fStepz(0),
+ fCollection(0),
+ fCollectionVector(0)
+{
+ fBinsTot = fBinsx * fBinsy * fBinsz;
+ fStepx=0; fStepx = (fMaxx-fMinx)/fBinsx;
+ fStepy=0; fStepy = (fMaxy-fMiny)/fBinsy;
+ fStepz=0; fStepz = (fMaxz-fMinz)/fBinsz;
+
+
+ //fCollectionVector = new AliFemtoPicoEventCollectionVector();
+ fCollection = 0;
+ for ( int i=0; i<fBinsTot; i++) {
+ fCollection = new AliFemtoPicoEventCollection();
+ fCollectionVector.push_back(fCollection);
+ }
}
// -----------------------------------
AliFemtoPicoEventCollection* AliFemtoPicoEventCollectionVectorHideAway::PicoEventCollection(int ix, int iy, int iz) {
return PicoEventCollection( ix,iy,iz );
}
+//___________________________________
+AliFemtoPicoEventCollectionVectorHideAway::AliFemtoPicoEventCollectionVectorHideAway(const AliFemtoPicoEventCollectionVectorHideAway& aColl):
+ fBinsTot(0),
+ fBinsx(0), fBinsy(0), fBinsz(0),
+ fMinx(0), fMiny(0), fMinz(0),
+ fMaxx(0), fMaxy(0), fMaxz(0),
+ fStepx(0), fStepy(0), fStepz(0),
+ fCollection(0),
+ fCollectionVector(0)
+{
+ fBinsTot = aColl.fBinsTot;
+ fBinsx = aColl.fBinsx;
+ fBinsy = aColl.fBinsy;
+ fBinsz = aColl.fBinsz;
+ fMinx = aColl.fMinx;
+ fMiny = aColl.fMiny;
+ fMinz = aColl.fMinz;
+ fMaxx = aColl.fMaxx;
+ fMaxy = aColl.fMaxy;
+ fMaxz = aColl.fMaxz;
+ fStepx = aColl.fStepx;
+ fStepy = aColl.fStepy;
+ fStepz = aColl.fStepz;
+ fCollection = aColl.fCollection;
+
+ fCollectionVector.clear();
+ for (int iter=0; aColl.fCollectionVector.size();iter++){
+ fCollectionVector.push_back(aColl.fCollectionVector[iter]);
+ }
+}
+//___________________________________
+AliFemtoPicoEventCollectionVectorHideAway::~AliFemtoPicoEventCollectionVectorHideAway()
+{
+ fCollectionVector.clear();
+}
+//___________________________________
+AliFemtoPicoEventCollectionVectorHideAway& AliFemtoPicoEventCollectionVectorHideAway::operator=(const AliFemtoPicoEventCollectionVectorHideAway& aColl)
+{
+ if (this == &aColl)
+ return *this;
+
+ fBinsTot = aColl.fBinsTot;
+ fBinsx = aColl.fBinsx;
+ fBinsy = aColl.fBinsy;
+ fBinsz = aColl.fBinsz;
+ fMinx = aColl.fMinx;
+ fMiny = aColl.fMiny;
+ fMinz = aColl.fMinz;
+ fMaxx = aColl.fMaxx;
+ fMaxy = aColl.fMaxy;
+ fMaxz = aColl.fMaxz;
+ fStepx = aColl.fStepx;
+ fStepy = aColl.fStepy;
+ fStepz = aColl.fStepz;
+ fCollection = aColl.fCollection;
+
+ fCollectionVector.clear();
+
+ for (int iter=0; aColl.fCollectionVector.size();iter++){
+ fCollectionVector.push_back(aColl.fCollectionVector[iter]);
+ }
+
+ return *this;
+}
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
AliFemtoPicoEventCollectionVectorHideAway(int bx=1, double lx=-FLT_MAX, double ux=FLT_MAX,
int by=1, double ly=-FLT_MAX, double uy=FLT_MAX,
int bz=1, double lz=-FLT_MAX, double uz=FLT_MAX);
+ AliFemtoPicoEventCollectionVectorHideAway(const AliFemtoPicoEventCollectionVectorHideAway& aColl);
+ ~AliFemtoPicoEventCollectionVectorHideAway();
+ AliFemtoPicoEventCollectionVectorHideAway& operator=(const AliFemtoPicoEventCollectionVectorHideAway& aColl);
+
AliFemtoPicoEventCollection* PicoEventCollection(int, int, int);
AliFemtoPicoEventCollection* PicoEventCollection(double x, double y=0, double z=0);
private:
*
***************************************************************************
* $Log$
+ * Revision 1.3 2007/04/27 07:24:34 akisiel
+ * Make revisions needed for compilation from the main AliRoot tree
+ *
* Revision 1.1.1.1 2007/04/25 15:38:41 panos
* Importing the HBT code dir
*
//#include "Infrastructure/AliFemtoTTreeTrack.h"
AliFemtoTrack::AliFemtoTrack():
+ fCharge(0),
+ fPidProbElectron(0),
+ fPidProbPion(0),
+ fPidProbKaon(0),
+ fPidProbProton(0),
+ fPidProbMuon(0),
fTrackId(0),
+ fP(0,0,0),
+ fPt(0),
+ fHelix(),
fFlags(0),
fLabel(0),
fImpactD(0),
fTPCsignalN(0),
fTPCsignalS(0),
fClusters(159),
- fShared(159)
+ fShared(159),
+ fHiddenInfo(0)
{
fHiddenInfo = NULL;
// cout << "Created track " << this << endl;
}
-AliFemtoTrack::AliFemtoTrack(const AliFemtoTrack& t)
+AliFemtoTrack::AliFemtoTrack(const AliFemtoTrack& t) :
+ fCharge(0),
+ fPidProbElectron(0),
+ fPidProbPion(0),
+ fPidProbKaon(0),
+ fPidProbProton(0),
+ fPidProbMuon(0),
+ fTrackId(0),
+ fP(0,0,0),
+ fPt(0),
+ fHelix(),
+ fFlags(0),
+ fLabel(0),
+ fImpactD(0),
+ fImpactZ(0),
+ fCdd(0),
+ fCdz(0),
+ fCzz(0),
+ fITSchi2(0),
+ fITSncls(0),
+ fTPCchi2(0),
+ fTPCncls(0),
+ fTPCnclsF(0),
+ fTPCsignalN(0),
+ fTPCsignalS(0),
+ fClusters(159),
+ fShared(159),
+ fHiddenInfo(0)
{ // copy constructor
fCharge = t.fCharge;
fPidProbElectron = t.fPidProbElectron;
// cout << "Created track " << this << endl;
};
+AliFemtoTrack& AliFemtoTrack::operator=(const AliFemtoTrack& aTrack)
+{
+ if (this == &aTrack)
+ return *this;
+ fCharge = aTrack.fCharge;
+ fPidProbElectron = aTrack.fPidProbElectron;
+ fPidProbPion = aTrack.fPidProbPion;
+ fPidProbKaon = aTrack.fPidProbKaon;
+ fPidProbProton = aTrack.fPidProbProton;
+ fPidProbMuon=aTrack.fPidProbMuon;
+ fP = aTrack.fP;
+ fPt = aTrack.fPt;
+ fHelix = aTrack.fHelix;
+ fTrackId = aTrack.fTrackId;
+ fFlags=aTrack.fFlags;
+ fLabel=aTrack.fLabel;
+ fImpactD=aTrack.fImpactD;
+ fImpactZ=aTrack.fImpactZ;
+ fCdd=aTrack.fCdd;
+ fCdz=aTrack.fCdz;
+ fCzz=aTrack.fCzz;
+ fITSchi2=aTrack.fITSchi2;
+ fITSncls=aTrack.fITSncls;
+ fTPCchi2=aTrack.fTPCchi2;
+ fTPCncls=aTrack.fTPCncls;
+ fTPCnclsF=aTrack.fTPCnclsF;
+ fTPCsignalN=aTrack.fTPCsignalN;
+ fTPCsignalS=aTrack.fTPCsignalS;
+ fClusters=aTrack.fClusters;
+ fShared=aTrack.fShared;
+ if (ValidHiddenInfo())
+ delete fHiddenInfo;
+ if (aTrack.ValidHiddenInfo())
+ fHiddenInfo = aTrack.getHiddenInfo()->clone();
+ else
+ fHiddenInfo = NULL;
+
+ return *this;
+}
+
void AliFemtoTrack::SetCharge(const short& ch){fCharge=ch;}
void AliFemtoTrack::SetPidProbElectron(const float& x){fPidProbElectron = x;}
class StMuTrack;
#endif
-
-
-
class AliFemtoTrack{
public:
AliFemtoTrack();
AliFemtoTrack(const AliFemtoTrack&);// copy constructor
+ AliFemtoTrack& operator=(const AliFemtoTrack& aTrack);
#ifndef __NO_STAR_DEPENDENCE_ALLOWED__
#ifdef __ROOT__
//AliFemtoTrack(const StTrack*, AliFemtoThreeVector); // c-tor from StTrack of STAR DSTs
#include "phys_constants.h"
// -----------------------------------------------------------------------
-AliFemtoV0::AliFemtoV0(const AliFemtoV0& v){ // copy constructor
+AliFemtoV0::AliFemtoV0():
+ fDecayLengthV0(0), fDecayVertexV0(0), fPrimaryVertex(0),
+ fDcaV0Daughters(0), fDcaV0ToPrimVertex(0),
+ fDcaPosToPrimVertex(0), fDcaNegToPrimVertex(0),
+ fMomPos(0), fMomNeg(0),
+ fTpcHitsPos(0), fTpcHitsNeg(0),
+ fChi2V0(0), fClV0(0), fChi2Pos(0), fClPos(0), fChi2Neg(0), fClNeg(0),
+ fDedxPos(0), fErrDedxPos(0), fLenDedxPos(0),
+ fDedxNeg(0), fErrDedxNeg(0), fLenDedxNeg(0),
+ fNufDedxPos(0), fNufDedxNeg(0),
+ fHelixPos(), fHelixNeg(),
+ fMomV0(0),
+ fAlphaV0(0), fPtArmV0(0),
+ fELambda(0), fEK0Short(0),
+ fEPosProton(0), fEPosPion(0),
+ fENegProton(0), fENegPion(0),
+ fMassLambda(0), fMassAntiLambda(0),
+ fMassK0Short(0), fRapLambda(0),
+ fRapK0Short(0), fCTauLambda(0),
+ fCTauK0Short(0), fPtV0(0), fPtotV0(0),
+ fPtPos(0), fPtotPos(0),
+ fPtNeg(0), fPtotNeg(0),
+ fKeyNeg(0), fKeyPos(0),
+ fHiddenInfo(0) /***/
+{ /* no-op */}
+// -----------------------------------------------------------------------
+AliFemtoV0::AliFemtoV0(const AliFemtoV0& v) :
+ fDecayLengthV0(0), fDecayVertexV0(0), fPrimaryVertex(0),
+ fDcaV0Daughters(0), fDcaV0ToPrimVertex(0),
+ fDcaPosToPrimVertex(0), fDcaNegToPrimVertex(0),
+ fMomPos(0), fMomNeg(0),
+ fTpcHitsPos(0), fTpcHitsNeg(0),
+ fChi2V0(0), fClV0(0), fChi2Pos(0), fClPos(0), fChi2Neg(0), fClNeg(0),
+ fDedxPos(0), fErrDedxPos(0), fLenDedxPos(0),
+ fDedxNeg(0), fErrDedxNeg(0), fLenDedxNeg(0),
+ fNufDedxPos(0), fNufDedxNeg(0),
+ fHelixPos(), fHelixNeg(),
+ fMomV0(0),
+ fAlphaV0(0), fPtArmV0(0),
+ fELambda(0), fEK0Short(0),
+ fEPosProton(0), fEPosPion(0),
+ fENegProton(0), fENegPion(0),
+ fMassLambda(0), fMassAntiLambda(0),
+ fMassK0Short(0), fRapLambda(0),
+ fRapK0Short(0), fCTauLambda(0),
+ fCTauK0Short(0), fPtV0(0), fPtotV0(0),
+ fPtPos(0), fPtotPos(0),
+ fPtNeg(0), fPtotNeg(0),
+ fKeyNeg(0), fKeyPos(0),
+ fHiddenInfo(0) /***/
+{ // copy constructor
fDecayLengthV0 = v.fDecayLengthV0;
fDecayVertexV0 = v.fDecayVertexV0;
fDcaV0Daughters = v.fDcaV0Daughters;
fHiddenInfo = v.fHiddenInfo? v.fHiddenInfo->clone() : 0;// GR 11 DEC 02
UpdateV0();
}
+AliFemtoV0& AliFemtoV0::operator=(const AliFemtoV0& aV0)
+{
+ if (this == &aV0)
+ return *this;
+ fDecayLengthV0 = aV0.fDecayLengthV0;
+ fDecayVertexV0 = aV0.fDecayVertexV0;
+ fDcaV0Daughters = aV0.fDcaV0Daughters;
+ fDcaV0ToPrimVertex = aV0.fDcaV0ToPrimVertex;
+ fDcaPosToPrimVertex = aV0.fDcaPosToPrimVertex;
+ fDcaNegToPrimVertex = aV0.fDcaNegToPrimVertex;
+ fMomPos = aV0.fMomPos;
+ fMomNeg = aV0.fMomNeg;
+
+ fTrackTopologyMapPos[0] = aV0.fTrackTopologyMapPos[0];
+ fTrackTopologyMapPos[1] = aV0.fTrackTopologyMapPos[1];
+ fTrackTopologyMapNeg[0] = aV0.fTrackTopologyMapNeg[0];
+ fTrackTopologyMapNeg[1] = aV0.fTrackTopologyMapNeg[1];
+
+ fKeyPos = aV0.fKeyPos;
+ fKeyNeg = aV0.fKeyNeg;
+
+ fTpcHitsPos = aV0.fTpcHitsPos;
+ fTpcHitsNeg = aV0.fTpcHitsNeg;
+
+ fChi2V0 = aV0.fChi2V0;
+ fClV0 = aV0.fClV0;
+ fChi2Pos = aV0.fChi2Pos;
+ fClPos = aV0.fClPos;
+ fChi2Neg = aV0.fChi2Neg;
+ fClNeg = aV0.fClNeg;
+ fDedxPos = aV0.fDedxPos;
+ fErrDedxPos = aV0.fErrDedxPos;//Gael 04Fev2002
+ fLenDedxPos = aV0.fLenDedxPos;//Gael 04Fev2002
+ fDedxNeg = aV0.fDedxNeg;
+ fErrDedxNeg = aV0.fErrDedxNeg;//Gael 04Fev2002
+ fLenDedxNeg = aV0.fLenDedxNeg;//Gael 04Fev2002
+
+ fNufDedxPos = aV0.fNufDedxPos;
+ fNufDedxNeg = aV0.fNufDedxNeg;
+
+ fHelixPos = aV0.fHelixPos;// Gael 12 Sept
+ fHelixNeg = aV0.fHelixNeg;// Gael 12 Sept
+ if (fHiddenInfo) delete fHiddenInfo;
+ fHiddenInfo = aV0.fHiddenInfo? aV0.fHiddenInfo->clone() : 0;// GR 11 DEC 02
+ UpdateV0();
+
+ return *this;
+}
+
// -----------------------------------------------------------------------
void AliFemtoV0::UpdateV0(){
//Calc. derived memebers of the v0 class
***********************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
class AliFemtoV0 {
public:
- AliFemtoV0(){/* no-op */}
+ AliFemtoV0();
AliFemtoV0( const AliFemtoV0&); // copy constructor
#ifdef __ROOT__
#ifndef __NO_STAR_DEPENDENCE_ALLOWED__
AliFemtoV0( StV0MuDst&); // from strangeness V0 micro dst structure
#endif
#endif
- ~AliFemtoV0(){if(fHiddenInfo) delete fHiddenInfo;}
+ virtual ~AliFemtoV0(){if(fHiddenInfo) delete fHiddenInfo;}
+ AliFemtoV0& operator=(const AliFemtoV0& aV0);
float decayLengthV0() const; // 3-d decay distance
#include "Infrastructure/AliFemtoXi.h"
#include "phys_constants.h"
+// -----------------------------------------------------------------------
+AliFemtoXi::AliFemtoXi():
+ fCharge(0), fDecayLengthXi(0),
+ fDecayVertexXi(0),
+ fDcaXiDaughters(0), fDcaXiToPrimVertex(0), fDcaBachelorToPrimVertex(0),
+ fMomBachelor(0), fKeyBachelor(0),
+ fTpcHitsBac(0), fChi2Xi(0), fClXi(0), fChi2Bachelor(0), fClBachelor(0),
+ fDedxBachelor(0), fNufDedxBachelor(0), fMomXi(0),
+ fAlphaXi(0), fPtArmXi(0),
+ fEXi(0), fEOmega(0), fEBacPion(0), fEBacKaon(0),
+ fMassXi(0), fMassOmega(0), fRapXi(0), fRapOmega(0),
+ fCTauXi(0), fCTauOmega(0),
+ fPtXi(0), fPtotXi(0), fPtBac(0), fPtotBac(0),
+ fKeyBac(0)
+{/* no-op */}
// -----------------------------------------------------------------------
void AliFemtoXi::UpdateXi(){
//Calc. derived members of the xi class
class AliFemtoXi : public AliFemtoV0 {
public:
- AliFemtoXi(){/* no-op */}
+ AliFemtoXi();
#ifdef __ROOT__
#ifndef __NO_STAR_DEPENDENCE_ALLOWED__
AliFemtoXi(StXiMuDst&); // from strangeness Xi micro dst structure
#endif
#endif
- ~AliFemtoXi(){/* no-op */}
+ virtual ~AliFemtoXi(){/* no-op */}
void UpdateXi();
float decayLengthXi() const; // 3-d decay distance
/***********************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
***************************************************************************
*
* $Log$
+* Revision 1.3 2007/04/27 07:24:34 akisiel
+* Make revisions needed for compilation from the main AliRoot tree
+*
* Revision 1.1.1.1 2007/04/25 15:38:41 panos
* Importing the HBT code dir
*
const double AliFmHelix::NoSolution = 3.e+33;
-AliFmHelix::AliFmHelix(){ /*noop*/ }
+AliFmHelix::AliFmHelix() :
+ mSingularity(0),
+ mOrigin(0,0,0),
+ mDipAngle(0),
+ mCurvature(0),
+ mPhase(0),
+ mH(0),
+ mCosDipAngle(0),
+ mSinDipAngle(0),
+ mCosPhase(0),
+ mSinPhase(0)
+{ /*noop*/ }
AliFmHelix::AliFmHelix(double c, double d, double phase,
- const AliFmThreeVector<double>& o, int h)
+ const AliFmThreeVector<double>& o, int h) :
+ mSingularity(0),
+ mOrigin(0,0,0),
+ mDipAngle(0),
+ mCurvature(0),
+ mPhase(0),
+ mH(0),
+ mCosDipAngle(0),
+ mSinDipAngle(0),
+ mCosPhase(0),
+ mSinPhase(0)
{
setParameters(c, d, phase, o, h);
}
***************************************************************************
*
* $Log$
+ * Revision 1.1.1.1 2007/04/25 15:38:41 panos
+ * Importing the HBT code dir
+ *
* Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
* First version on CVS
*
public:
/// curvature, dip angle, phase, origin, h
AliFmHelix(double c, double dip, double phase,
- const AliFmThreeVector<double>& o, int h=-1);
+ const AliFmThreeVector<double>& o, int h=-1);
virtual ~AliFmHelix();
// AliFmHelix(const AliFmHelix&); // use default
+////////////////////////////////////////////////////////////////////////////////
+/// ///
+/// AliFemtoEventReaderESD - the reader class for the Alice ESD ///
+/// Reads in ESD information and converts it into internal AliFemtoEvent ///
+/// Reads in AliESDfriend to create shared hit/quality information ///
+/// Authors: Marek Chojnacki mchojnacki@knf.pw.edu.pl ///
+/// Adam Kisiel kisiel@mps.ohio-state.edu ///
+/// ///
+////////////////////////////////////////////////////////////////////////////////
+
/*
*$Id$
*$Log$
+ *Revision 1.4 2007/04/27 07:28:34 akisiel
+ *Remove event number reading due to interface changes
+ *
*Revision 1.3 2007/04/27 07:25:16 akisiel
*Make revisions needed for compilation from the main AliRoot tree
*
*Revision 1.1.1.1 2007/04/25 15:38:41 panos
*Importing the HBT code dir
*
- *Revision 1.5 2007-04-03 16:00:08 mchojnacki
- *Changes to iprove memory managing
- *
- *Revision 1.4 2007/03/13 15:30:03 mchojnacki
- *adding reader for simulated data
- *
- *Revision 1.3 2007/03/08 14:58:03 mchojnacki
- *adding some alice stuff
- *
- *Revision 1.2 2007/03/07 13:36:16 mchojnacki
- *Add some comments
- *
- *Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
- *First version on CVS
- *
*/
#include "AliFemtoEventReaderESD.h"
fNumberofEvent(0),
fCurEvent(0),
fCurFile(0),
+ fListOfFiles(0x0),
fTree(0x0),
fEvent(0x0),
fEsdFile(0x0),
- fEventFriend(0)
+ fEventFriend(0),
+ fSharedList(0x0),
+ fClusterPerPadrow(0x0)
{
fClusterPerPadrow = (list<Int_t> **) malloc(sizeof(list<Int_t> *) * AliESDfriendTrack::kMaxTPCcluster);
for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
}
}
+AliFemtoEventReaderESD::AliFemtoEventReaderESD(const AliFemtoEventReaderESD &aReader) :
+ fInputFile(" "),
+ fFileName(" "),
+ fConstrained(true),
+ fNumberofEvent(0),
+ fCurEvent(0),
+ fCurFile(0),
+ fListOfFiles(0x0),
+ fTree(0x0),
+ fEvent(0x0),
+ fEsdFile(0x0),
+ fEventFriend(0),
+ fSharedList(0x0),
+ fClusterPerPadrow(0x0)
+{
+ fInputFile = aReader.fInputFile;
+ fFileName = aReader.fFileName;
+ fConstrained = aReader.fConstrained;
+ fNumberofEvent = aReader.fNumberofEvent;
+ fCurEvent = aReader.fCurEvent;
+ fCurFile = aReader.fCurFile;
+ fTree = aReader.fTree->CloneTree();
+ fEvent = new AliESD(*aReader.fEvent);
+ fEsdFile = new TFile(aReader.fEsdFile->GetName());
+ fEventFriend = aReader.fEventFriend;
+ fClusterPerPadrow = (list<Int_t> **) malloc(sizeof(list<Int_t> *) * AliESDfriendTrack::kMaxTPCcluster);
+ for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
+ fClusterPerPadrow[tPad] = new list<Int_t>();
+ list<Int_t>::iterator iter;
+ for (iter=aReader.fClusterPerPadrow[tPad]->begin(); iter!=aReader.fClusterPerPadrow[tPad]->end(); iter++) {
+ fClusterPerPadrow[tPad]->push_back(*iter);
+ }
+ }
+ fSharedList = (list<Int_t> **) malloc(sizeof(list<Int_t> *) * AliESDfriendTrack::kMaxTPCcluster);
+ for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
+ fSharedList[tPad] = new list<Int_t>();
+ list<Int_t>::iterator iter;
+ for (iter=aReader.fSharedList[tPad]->begin(); iter!=aReader.fSharedList[tPad]->end(); iter++) {
+ fSharedList[tPad]->push_back(*iter);
+ }
+ }
+ for (unsigned int veciter = 0; veciter<aReader.fListOfFiles.size(); veciter++)
+ fListOfFiles.push_back(aReader.fListOfFiles[veciter]);
+}
//__________________
//Destructor
AliFemtoEventReaderESD::~AliFemtoEventReaderESD()
delete [] fSharedList;
}
+//__________________
+AliFemtoEventReaderESD& AliFemtoEventReaderESD::operator=(const AliFemtoEventReaderESD& aReader)
+{
+ if (this == &aReader)
+ return *this;
+
+ fInputFile = aReader.fInputFile;
+ fFileName = aReader.fFileName;
+ fConstrained = aReader.fConstrained;
+ fNumberofEvent = aReader.fNumberofEvent;
+ fCurEvent = aReader.fCurEvent;
+ fCurFile = aReader.fCurFile;
+ if (fTree) delete fTree;
+ fTree = aReader.fTree->CloneTree();
+ if (fEvent) delete fEvent;
+ fEvent = new AliESD(*aReader.fEvent);
+ if (fEsdFile) delete fEsdFile;
+ fEsdFile = new TFile(aReader.fEsdFile->GetName());
+
+ fEventFriend = aReader.fEventFriend;
+
+ if (fClusterPerPadrow) {
+ for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
+ fClusterPerPadrow[tPad]->clear();
+ delete fClusterPerPadrow[tPad];
+ }
+ delete [] fClusterPerPadrow;
+ }
+
+ if (fSharedList) {
+ for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
+ fSharedList[tPad]->clear();
+ delete fSharedList[tPad];
+ }
+ delete [] fSharedList;
+ }
+
+ fClusterPerPadrow = (list<Int_t> **) malloc(sizeof(list<Int_t> *) * AliESDfriendTrack::kMaxTPCcluster);
+ for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
+ fClusterPerPadrow[tPad] = new list<Int_t>();
+ list<Int_t>::iterator iter;
+ for (iter=aReader.fClusterPerPadrow[tPad]->begin(); iter!=aReader.fClusterPerPadrow[tPad]->end(); iter++) {
+ fClusterPerPadrow[tPad]->push_back(*iter);
+ }
+ }
+ fSharedList = (list<Int_t> **) malloc(sizeof(list<Int_t> *) * AliESDfriendTrack::kMaxTPCcluster);
+ for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
+ fSharedList[tPad] = new list<Int_t>();
+ list<Int_t>::iterator iter;
+ for (iter=aReader.fSharedList[tPad]->begin(); iter!=aReader.fSharedList[tPad]->end(); iter++) {
+ fSharedList[tPad]->push_back(*iter);
+ }
+ }
+ for (unsigned int veciter = 0; veciter<aReader.fListOfFiles.size(); veciter++)
+ fListOfFiles.push_back(aReader.fListOfFiles[veciter]);
+
+ return *this;
+}
//__________________
AliFemtoString AliFemtoEventReaderESD::Report()
{
for (int tNcl=0; tNcl<AliESDfriendTrack::kMaxTPCcluster; tNcl++) {
if (tTrackIndices[tNcl] >= 0) {
tClustIter = find(fClusterPerPadrow[tNcl]->begin(), fClusterPerPadrow[tNcl]->end(), tTrackIndices[tNcl]);
- if (tClustIter == fClusterPerPadrow[tNcl]->end()) {
+ if (tClustIter == fClusterPerPadrow[tNcl]->end()) {
fClusterPerPadrow[tNcl]->push_back(tTrackIndices[tNcl]);
}
else {
AliFemtoTrack* trackCopy = new AliFemtoTrack();
const AliESDtrack *esdtrack=fEvent->GetTrack(i);//getting next track
- const AliESDfriendTrack *tESDfriendTrack = esdtrack->GetFriendTrack();
+ // const AliESDfriendTrack *tESDfriendTrack = esdtrack->GetFriendTrack();
trackCopy->SetCharge((short)esdtrack->GetSign());
+////////////////////////////////////////////////////////////////////////////////
+/// ///
+/// AliFemtoEventReaderESD - the reader class for the Alice ESD ///
+/// Reads in ESD information and converts it into internal AliFemtoEvent ///
+/// Reads in AliESDfriend to create shared hit/quality information ///
+/// Authors: Marek Chojnacki mchojnacki@knf.pw.edu.pl ///
+/// Adam Kisiel kisiel@mps.ohio-state.edu ///
+/// ///
+////////////////////////////////////////////////////////////////////////////////
+
/*
*$Id$
*$Log$
+ *Revision 1.3 2007/04/27 07:25:16 akisiel
+ *Make revisions needed for compilation from the main AliRoot tree
+ *
*Revision 1.1.1.1 2007/04/25 15:38:41 panos
*Importing the HBT code dir
*
- *Revision 1.3 2007/03/13 15:30:03 mchojnacki
- *adding reader for simulated data
- *
- *Revision 1.2 2007/03/07 13:36:17 mchojnacki
- *Add some comments
- *
- *Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
- *First version on CVS
- *
*/
#ifndef AliFemtoEventReaderESD_hh
#define AliFemtoEventReaderESD_hh
-//Reader for ESD files for StHbt version 10 with hidden info part
-//made by Marek Chojnacki mchojnacki@knf.pw.edu.pl
-// Version 11 Added AliESDfriend reading
-// Adam Kisiel kisiel@mps.ohio-state.edu
#include "Base/AliFemtoEventReader.h"
#include "Infrastructure/AliFemtoEnumeration.h"
{
public:
AliFemtoEventReaderESD();
+ AliFemtoEventReaderESD(const AliFemtoEventReaderESD &aReader);
~AliFemtoEventReaderESD();
+
+ AliFemtoEventReaderESD& operator=(const AliFemtoEventReaderESD& aReader);
+
AliFemtoEvent* ReturnHbtEvent();
AliFemtoString Report();
//void SetFileName(const char* fileName);
protected:
private:
- bool GetNextFile();//setting next file to read
+ bool GetNextFile(); // setting next file to read
- string fInputFile; //name of input file
- string fFileName; //name of current ESD file
- bool fConstrained; //flag to set which momentum from ESD file will be use
- int fNumberofEvent;//number of Events in ESD file
- int fCurEvent; //number of current event
- unsigned int fCurFile; //number of current file
- vector<string> fListOfFiles;//list of ESD files
- TTree* fTree;//ESD tree
- AliESD* fEvent;//ESD event
- TFile* fEsdFile;//ESD file
- AliESDfriend* fEventFriend;
+ string fInputFile; // name of input file with ESD filenames
+ string fFileName; // name of current ESD file
+ bool fConstrained; // flag to set which momentum from ESD file will be use
+ int fNumberofEvent; // number of Events in ESD file
+ int fCurEvent; // number of current event
+ unsigned int fCurFile; // number of current file
+ vector<string> fListOfFiles; // list of ESD files
+ TTree* fTree; // ESD tree
+ AliESD* fEvent; // ESD event
+ TFile* fEsdFile; // ESD file
+ AliESDfriend* fEventFriend; // ESD friend informaion
- list<Int_t> **fSharedList;
- list<Int_t> **fClusterPerPadrow;
+ list<Int_t> **fSharedList; //! Table (one list per padrow) of clusters which are shared
+ list<Int_t> **fClusterPerPadrow; //! Table (one list per padrow) of clusters in each padrow
#ifdef __ROOT__
ClassDef(AliFemtoEventReaderESD, 10)
fCurEvent(0),
fCurFile(0),
fEvent(0x0),
- fEventFriend(0)
+ fEventFriend(0),
+ fSharedList(0x0),
+ fClusterPerPadrow(0x0)
{
fClusterPerPadrow = (list<Int_t> **) malloc(sizeof(list<Int_t> *) * AliESDfriendTrack::kMaxTPCcluster);
for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
}
}
+//__________________
+// Copy constructor
+AliFemtoEventReaderESDChain::AliFemtoEventReaderESDChain(const AliFemtoEventReaderESDChain& aReader):
+ fFileName(" "),
+ fConstrained(true),
+ fNumberofEvent(0),
+ fCurEvent(0),
+ fCurFile(0),
+ fEvent(0x0),
+ fEventFriend(0),
+ fSharedList(0x0),
+ fClusterPerPadrow(0x0)
+{
+ fConstrained = aReader.fConstrained;
+ fNumberofEvent = aReader.fNumberofEvent;
+ fCurEvent = aReader.fCurEvent;
+ fCurFile = aReader.fCurFile;
+ fEvent = new AliESD(*aReader.fEvent);
+ fEventFriend = aReader.fEventFriend;
+ fClusterPerPadrow = (list<Int_t> **) malloc(sizeof(list<Int_t> *) * AliESDfriendTrack::kMaxTPCcluster);
+ for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
+ fClusterPerPadrow[tPad] = new list<Int_t>();
+ list<Int_t>::iterator iter;
+ for (iter=aReader.fClusterPerPadrow[tPad]->begin(); iter!=aReader.fClusterPerPadrow[tPad]->end(); iter++) {
+ fClusterPerPadrow[tPad]->push_back(*iter);
+ }
+ }
+ fSharedList = (list<Int_t> **) malloc(sizeof(list<Int_t> *) * AliESDfriendTrack::kMaxTPCcluster);
+ for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
+ fSharedList[tPad] = new list<Int_t>();
+ list<Int_t>::iterator iter;
+ for (iter=aReader.fSharedList[tPad]->begin(); iter!=aReader.fSharedList[tPad]->end(); iter++) {
+ fSharedList[tPad]->push_back(*iter);
+ }
+ }
+}
//__________________
//Destructor
AliFemtoEventReaderESDChain::~AliFemtoEventReaderESDChain()
delete [] fSharedList;
}
+//__________________
+// Assignment operator
+AliFemtoEventReaderESDChain& AliFemtoEventReaderESDChain::operator=(const AliFemtoEventReaderESDChain& aReader)
+{
+ if (this == &aReader)
+ return *this;
+
+ fConstrained = aReader.fConstrained;
+ fNumberofEvent = aReader.fNumberofEvent;
+ fCurEvent = aReader.fCurEvent;
+ fCurFile = aReader.fCurFile;
+ if (fEvent) delete fEvent;
+ fEvent = new AliESD(*aReader.fEvent);
+
+ fEventFriend = aReader.fEventFriend;
+
+ if (fClusterPerPadrow) {
+ for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
+ fClusterPerPadrow[tPad]->clear();
+ delete fClusterPerPadrow[tPad];
+ }
+ delete [] fClusterPerPadrow;
+ }
+
+ if (fSharedList) {
+ for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
+ fSharedList[tPad]->clear();
+ delete fSharedList[tPad];
+ }
+ delete [] fSharedList;
+ }
+
+ fClusterPerPadrow = (list<Int_t> **) malloc(sizeof(list<Int_t> *) * AliESDfriendTrack::kMaxTPCcluster);
+ for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
+ fClusterPerPadrow[tPad] = new list<Int_t>();
+ list<Int_t>::iterator iter;
+ for (iter=aReader.fClusterPerPadrow[tPad]->begin(); iter!=aReader.fClusterPerPadrow[tPad]->end(); iter++) {
+ fClusterPerPadrow[tPad]->push_back(*iter);
+ }
+ }
+ fSharedList = (list<Int_t> **) malloc(sizeof(list<Int_t> *) * AliESDfriendTrack::kMaxTPCcluster);
+ for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
+ fSharedList[tPad] = new list<Int_t>();
+ list<Int_t>::iterator iter;
+ for (iter=aReader.fSharedList[tPad]->begin(); iter!=aReader.fSharedList[tPad]->end(); iter++) {
+ fSharedList[tPad]->push_back(*iter);
+ }
+ }
+
+ return *this;
+}
//__________________
// Simple report
AliFemtoString AliFemtoEventReaderESDChain::Report()
AliFemtoTrack* trackCopy = new AliFemtoTrack();
const AliESDtrack *esdtrack=fEvent->GetTrack(i);//getting next track
- const AliESDfriendTrack *tESDfriendTrack = esdtrack->GetFriendTrack();
+ // const AliESDfriendTrack *tESDfriendTrack = esdtrack->GetFriendTrack();
trackCopy->SetCharge((short)esdtrack->GetSign());
-// AliFemto reader for the ESD objects given back by the chain
-// Version 1:
-// Adam Kisiel, OSU kisiel@mps.ohio-state.edu
+////////////////////////////////////////////////////////////////////////////////
+/// ///
+/// AliFemtoEventReaderESDChain - the reader class for the Alice ESD ///
+/// tailored for the Analysis/Task framework ///
+/// Reads in AliESDfriend to create shared hit/quality information ///
+/// Authors: Adam Kisiel kisiel@mps.ohio-state.edu ///
+/// ///
+////////////////////////////////////////////////////////////////////////////////
#ifndef AliFemtoEventReaderESDChain_hh
#define AliFemtoEventReaderESDChain_hh
#include "Base/AliFemtoEventReader.h"
{
public:
AliFemtoEventReaderESDChain();
+ AliFemtoEventReaderESDChain(const AliFemtoEventReaderESDChain& aReader);
~AliFemtoEventReaderESDChain();
+
+ AliFemtoEventReaderESDChain& operator=(const AliFemtoEventReaderESDChain& aReader);
+
AliFemtoEvent* ReturnHbtEvent();
AliFemtoString Report();
void SetConstrained(const bool constrained);
AliESD* fEvent; //ESD event
AliESDfriend* fEventFriend;
- list<Int_t> **fSharedList;
- list<Int_t> **fClusterPerPadrow;
+ list<Int_t> **fSharedList; //! Table (one list per padrow) of clusters which are shared
+ list<Int_t> **fClusterPerPadrow; //! Table (one list per padrow) of clusters in each padrow
#ifdef __ROOT__
ClassDef(AliFemtoEventReaderESDChain, 1)
-/***************************************************************************
- *
- * $Id$
- *
- * Author: Mike Lisa, Ohio State, lisa@mps.ohio-state.edu
- ***************************************************************************
- *
- * Description: part of STAR HBT Framework: AliFemtoMaker package
- * a simple Q-invariant correlation function
- *
- ***************************************************************************
- *
- * $Log$
- * Revision 1.1.1.1 2007/04/25 15:38:41 panos
- * Importing the HBT code dir
- *
- * Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
- * First version on CVS
- *
- * Revision 1.4 2000/01/25 17:34:45 laue
- * I. In order to run the stand alone version of the AliFemtoMaker the following
- * changes have been done:
- * a) all ClassDefs and ClassImps have been put into #ifdef __ROOT__ statements
- * b) unnecessary includes of StMaker.h have been removed
- * c) the subdirectory AliFemtoMaker/doc/Make has been created including everything
- * needed for the stand alone version
- *
- * II. To reduce the amount of compiler warning
- * a) some variables have been type casted
- * b) some destructors have been declared as virtual
- *
- * Revision 1.3 1999/07/29 02:47:09 lisa
- * 1) add OpeningAngle correlation function 2) add AliFemtoMcEventReader 3) make histos in CorrFctns do errors correctly
- *
- * Revision 1.2 1999/07/06 22:33:20 lisa
- * Adjusted all to work in pro and new - dev itself is broken
- *
- * Revision 1.1.1.1 1999/06/29 16:02:57 lisa
- * Installation of AliFemtoMaker
- *
- **************************************************************************/
+////////////////////////////////////////////////////////////////////////////////
+/// ///
+/// AliFemtoShareQualityCorrFctn - A correlation function that saves the ///
+/// amount of sharing and splitting hits per pair as a function of qinv ///
+/// Authors: Adam Kisiel kisiel@mps.ohio-state.edu ///
+/// ///
+////////////////////////////////////////////////////////////////////////////////
#include "AliFemtoShareQualityCorrFctn.h"
//#include "Infrastructure/AliFemtoHisto.hh"
#endif
//____________________________
-AliFemtoShareQualityCorrFctn::AliFemtoShareQualityCorrFctn(char* title, const int& nbins, const float& QinvLo, const float& QinvHi){
+AliFemtoShareQualityCorrFctn::AliFemtoShareQualityCorrFctn(char* title, const int& nbins, const float& QinvLo, const float& QinvHi):
+ fShareNumerator(0),
+ fShareDenominator(0),
+ fQualityNumerator(0),
+ fQualityDenominator(0)
+{
// set up numerator
// title = "Num Qinv (MeV/c)";
char TitNum[100] = "NumShare";
fQualityDenominator->Sumw2();
}
+//____________________________
+AliFemtoShareQualityCorrFctn::AliFemtoShareQualityCorrFctn(const AliFemtoShareQualityCorrFctn& aCorrFctn) :
+ fShareNumerator(0),
+ fShareDenominator(0),
+ fQualityNumerator(0),
+ fQualityDenominator(0)
+{
+ if (aCorrFctn.fShareNumerator)
+ fShareNumerator = new TH2D(*aCorrFctn.fShareNumerator);
+ if (aCorrFctn.fShareDenominator)
+ fShareDenominator = new TH2D(*aCorrFctn.fShareDenominator);
+ if (aCorrFctn.fQualityNumerator)
+ fQualityNumerator = new TH2D(*aCorrFctn.fQualityNumerator);
+ if (aCorrFctn.fQualityDenominator)
+ fQualityDenominator = new TH2D(*aCorrFctn.fQualityDenominator);
+}
//____________________________
AliFemtoShareQualityCorrFctn::~AliFemtoShareQualityCorrFctn(){
delete fShareNumerator;
delete fQualityDenominator;
}
//_________________________
+AliFemtoShareQualityCorrFctn& AliFemtoShareQualityCorrFctn::operator=(const AliFemtoShareQualityCorrFctn& aCorrFctn)
+{
+ if (this == &aCorrFctn)
+ return *this;
+
+ if (aCorrFctn.fShareNumerator)
+ fShareNumerator = new TH2D(*aCorrFctn.fShareNumerator);
+ else
+ fShareNumerator = 0;
+ if (aCorrFctn.fShareDenominator)
+ fShareDenominator = new TH2D(*aCorrFctn.fShareDenominator);
+ else
+ fShareDenominator = 0;
+ if (aCorrFctn.fQualityNumerator)
+ fQualityNumerator = new TH2D(*aCorrFctn.fQualityNumerator);
+ else
+ fQualityNumerator = 0;
+ if (aCorrFctn.fQualityDenominator)
+ fQualityDenominator = new TH2D(*aCorrFctn.fQualityDenominator);
+ else
+ fQualityDenominator = 0;
+
+ return *this;
+}
+//_________________________
void AliFemtoShareQualityCorrFctn::Finish(){
// here is where we should normalize, fit, etc...
// we should NOT Draw() the histos (as I had done it below),
-/***************************************************************************
- *
- * $Id$
- *
- * Author: Mike Lisa, Ohio State, lisa@mps.ohio-state.edu
- ***************************************************************************
- *
- * Description: part of STAR HBT Framework: AliFemtoMaker package
- * a simple Q-invariant correlation function
- *
- ***************************************************************************
- *
- * $Log$
- * Revision 1.1.1.1 2007/03/07 10:14:49 mchojnacki
- * First version on CVS
- *
- * Revision 1.3 2000/01/25 17:34:45 laue
- * I. In order to run the stand alone version of the AliFemtoMaker the following
- * changes have been done:
- * a) all ClassDefs and ClassImps have been put into #ifdef __ROOT__ statements
- * b) unnecessary includes of StMaker.h have been removed
- * c) the subdirectory AliFemtoMaker/doc/Make has been created including everything
- * needed for the stand alone version
- *
- * II. To reduce the amount of compiler warning
- * a) some variables have been type casted
- * b) some destructors have been declared as virtual
- *
- * Revision 1.2 1999/07/06 22:33:20 lisa
- * Adjusted all to work in pro and new - dev itself is broken
- *
- * Revision 1.1.1.1 1999/06/29 16:02:57 lisa
- * Installation of AliFemtoMaker
- *
- **************************************************************************/
+////////////////////////////////////////////////////////////////////////////////
+/// ///
+/// AliFemtoShareQualityCorrFctn - A correlation function that saves the ///
+/// amount of sharing and splitting hits per pair as a function of qinv ///
+/// Authors: Adam Kisiel kisiel@mps.ohio-state.edu ///
+/// ///
+////////////////////////////////////////////////////////////////////////////////
#ifndef AliFemtoShareQualityCorrFctn_hh
#define AliFemtoShareQualityCorrFctn_hh
class AliFemtoShareQualityCorrFctn : public AliFemtoCorrFctn {
public:
AliFemtoShareQualityCorrFctn(char* title, const int& nbins, const float& QinvLo, const float& QinvHi);
+ AliFemtoShareQualityCorrFctn(const AliFemtoShareQualityCorrFctn& aCorrFctn);
virtual ~AliFemtoShareQualityCorrFctn();
+ AliFemtoShareQualityCorrFctn& operator=(const AliFemtoShareQualityCorrFctn& aCorrFctn);
+
virtual AliFemtoString Report();
virtual void AddRealPair(const AliFemtoPair*);
virtual void AddMixedPair(const AliFemtoPair*);
***************************************************************************
*
* $Log$
+ * Revision 1.3 2007/04/27 07:25:59 akisiel
+ * Make revisions needed for compilation from the main AliRoot tree
+ *
* Revision 1.1.1.1 2007/04/25 15:38:41 panos
* Importing the HBT code dir
*
ClassImp(AliFemtoESDTrackCut)
#endif
-AliFemtoESDTrackCut::AliFemtoESDTrackCut()
+AliFemtoESDTrackCut::AliFemtoESDTrackCut() :
+ fCharge(0),
+ fLabel(0),
+ fStatus(0),
+ fminTPCclsF(0),
+ fminITScls(0),
+ fNTracksPassed(0),
+ fNTracksFailed(0)
{
fNTracksPassed = fNTracksFailed = 0;
fCharge = 0; // takes both charges 0
***************************************************************************
*
* $Log$
+ * Revision 1.3 2007/04/27 07:25:59 akisiel
+ * Make revisions needed for compilation from the main AliRoot tree
+ *
* Revision 1.1.1.1 2007/04/25 15:38:41 panos
* Importing the HBT code dir
*
#endif
//__________________
-AliFemtoQPairCut::AliFemtoQPairCut()
+AliFemtoQPairCut::AliFemtoQPairCut():
+ fNPairsPassed(0),
+ fNPairsFailed(0)
{
fNPairsPassed = fNPairsFailed = 0;
fQlong[0]=-1.0; fQlong[1]=100.0;
#endif
//__________________
-AliFemtoShareQualityPairCut::AliFemtoShareQualityPairCut(){
- fNPairsPassed = fNPairsFailed = 0;
- fShareQualityMax = 1.0;
+AliFemtoShareQualityPairCut::AliFemtoShareQualityPairCut():
+ fNPairsPassed(0),
+ fNPairsFailed(0),
+ fShareQualityMax(1.0)
+{
}
//__________________
AliFemtoShareQualityPairCut::~AliFemtoShareQualityPairCut(){
#endif
};
-inline AliFemtoShareQualityPairCut::AliFemtoShareQualityPairCut(const AliFemtoShareQualityPairCut& c) : AliFemtoPairCut(c) {
- fNPairsPassed = 0;
- fNPairsFailed = 0;
- fShareQualityMax = 1.0; // no cut
-}
+inline AliFemtoShareQualityPairCut::AliFemtoShareQualityPairCut(const AliFemtoShareQualityPairCut& c) :
+ AliFemtoPairCut(c),
+ fNPairsPassed(0),
+ fNPairsFailed(0),
+ fShareQualityMax(1.0) // no cut
+{ /* no-op */ }
inline AliFemtoShareQualityPairCut* AliFemtoShareQualityPairCut::Clone() { AliFemtoShareQualityPairCut* c = new AliFemtoShareQualityPairCut(*this); return c;}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff