AliPHOS() ;
AliPHOS(const char* name, const char* title="") ;
- AliPHOS(const AliPHOS & phos) {
+ AliPHOS(const AliPHOS & phos) : AliDetector(phos) {
// cpy ctor: no implementation yet
// requested by the Coding Convention
Fatal("cpy ctor", "not implemented") ;
//____________________________________________________________________________
AliPHOSAnalyze::AliPHOSAnalyze(const AliPHOSAnalyze & ana)
+ : TObject(ana)
{
// copy ctor
( (AliPHOSAnalyze &)ana ).Copy(*this) ;
public:
AliPHOSCalibrManager() ; // ctor
- AliPHOSCalibrManager(const AliPHOSCalibrManager & manager) {
+ AliPHOSCalibrManager(const AliPHOSCalibrManager & manager) : TNamed(manager) {
// cpy ctor: no need
// requested by the Coding Convention
Fatal("cpy ctor", "not implemented") ;
}
//____________________________________________________________________________
AliPHOSCalibrationData::AliPHOSCalibrationData(const AliPHOSCalibrationData & cd)
+ : TObject(cd)
{
//copy ctor
fData = new TArrayF(*cd.fData) ;
public:
AliPHOSCalibrator() ; // ctor
AliPHOSCalibrator(const char* run, const char * title = "Default") ;
- AliPHOSCalibrator(const AliPHOSCalibrator & ctor) {
+ AliPHOSCalibrator(const AliPHOSCalibrator & ctor) : TTask(ctor) {
// cpy ctor: no implementation yet
// requested by the Coding Convention
Fatal("cpy ctor", "not implemented") ;
AliPHOSClusterizer() ; // default ctor
AliPHOSClusterizer(const TString alirunFileName, const TString eventFolderName = AliConfig::fgkDefaultEventFolderName) ;
- AliPHOSClusterizer(const AliPHOSClusterizer & clusterizer) { ; }
+ AliPHOSClusterizer(const AliPHOSClusterizer & clusterizer) : TTask(clusterizer) { ; }
virtual ~AliPHOSClusterizer() ; // dtor
virtual Float_t GetEmcClusteringThreshold()const {Warning("GetEmcClusteringThreshold", "Not Defined" ) ; return 0. ; }
virtual Float_t GetEmcLocalMaxCut()const {Warning("GetEmcLocalMaxCut", "Not Defined" ) ; return 0. ; }
virtual Float_t GetCpvClusteringThreshold()const {Warning("GetCpvClusteringThreshold", "Not Defined" ) ; return 0. ; }
virtual Float_t GetCpvLocalMaxCut()const {Warning("GetCpvLocalMaxCut", "Not Defined" ) ; return 0. ; }
virtual Float_t GetCpvLogWeight()const {Warning("GetCpvLogWeight", "Not Defined" ) ; return 0. ; }
- virtual const char * GetRecPointsBranch() const {Warning("GetRecPointsBranch", "Not Defined" ) ; return 0 ; } ;
virtual const Int_t GetRecPointsInRun() const {Warning("GetRecPointsInRun", "Not Defined" ) ; return 0 ; }
- virtual const char * GetDigitsBranch() const{Warning("GetDigitsBranch", "Not Defined" ) ; return 0 ; } ;
virtual void MakeClusters() {Warning("MakeClusters", "Not Defined" ) ; }
virtual void Print()const {Warning("Print", "Not Defined" ) ; }
- virtual void SetEmcClusteringThreshold(Float_t cluth) {Warning("SetEmcClusteringThreshold", "Not Defined" ) ; }
- virtual void SetEmcLocalMaxCut(Float_t cut) {Warning("SetEmcLocalMaxCut", "Not Defined" ) ; }
+ virtual void SetEmcClusteringThreshold(Float_t) = 0;//{Warning("SetEmcClusteringThreshold", "Not Defined" ) ; }
+ virtual void SetEmcLocalMaxCut(Float_t ) = 0;//cut) {Warning("SetEmcLocalMaxCut", "Not Defined" ) ; }
- virtual void SetEmcLogWeight(Float_t w) {Warning("SetEmcLogWeight", "Not Defined" ) ; }
- virtual void SetEmcTimeGate(Float_t gate) {Warning("SetEmcTimeGate", "Not Defined" ) ; }
- virtual void SetCpvClusteringThreshold(Float_t cluth) {Warning("SetCpvClusteringThreshold", "Not Defined" ) ; }
- virtual void SetCpvLocalMaxCut(Float_t cut) {Warning("SetCpvLocalMaxCut", "Not Defined" ) ; }
- virtual void SetCpvLogWeight(Float_t w) {Warning("SetCpvLogWeight", "Not Defined" ) ; }
- virtual void SetDigitsBranch(const char * title) {Warning("SetDigitsBranch", "Not Defined" ) ; }
- virtual void SetRecPointsBranch(const char *title) {Warning("SetRecPointsBranch", "Not Defined" ) ; }
- virtual void SetUnfolding(Bool_t toUnfold ){Warning("SetUnfolding", "Not Defined" ) ;}
+ virtual void SetEmcLogWeight(Float_t) = 0;// w) {Warning("SetEmcLogWeight", "Not Defined" ) ; }
+ virtual void SetEmcTimeGate(Float_t) = 0;// gate) {Warning("SetEmcTimeGate", "Not Defined" ) ; }
+ virtual void SetCpvClusteringThreshold(Float_t) = 0;// cluth) {Warning("SetCpvClusteringThreshold", "Not Defined" ) ; }
+ virtual void SetCpvLocalMaxCut(Float_t) = 0;// cut) {Warning("SetCpvLocalMaxCut", "Not Defined" ) ; }
+ virtual void SetCpvLogWeight(Float_t) = 0;// w) {Warning("SetCpvLogWeight", "Not Defined" ) ; }
+ virtual void SetUnfolding(Bool_t) = 0;// toUnfold ){Warning("SetUnfolding", "Not Defined" ) ;}
void SetEventFolderName(TString name) { fEventFolderName = name ; }
AliPHOSClusterizer & operator = (const AliPHOSClusterizer & rvalue) {return *this ;}
AliPHOSClusterizerv1() ;
AliPHOSClusterizerv1(const TString alirunFileNameFile, const TString eventFolderName = AliConfig::fgkDefaultEventFolderName);
- AliPHOSClusterizerv1(const AliPHOSClusterizerv1 & clu) {
+ AliPHOSClusterizerv1(const AliPHOSClusterizerv1 & clu) : AliPHOSClusterizer(clu) {
// cpy ctor: no implementation yet
// requested by the Coding Convention
Fatal("cpy ctor", "not implemented") ;
//____________________________________________________________________________
-void AliPHOSCpvRecPoint::Print(Option_t * option)
+void AliPHOSCpvRecPoint::Print(Option_t *)
{
// Print the list of digits belonging to the cluster
AliPHOSCpvRecPoint() ;
AliPHOSCpvRecPoint(const char * opt) ;
- AliPHOSCpvRecPoint(const AliPHOSCpvRecPoint & rp) {
+ AliPHOSCpvRecPoint(const AliPHOSCpvRecPoint & rp) : AliPHOSEmcRecPoint(rp) {
// cpy ctor requested by Coding Convention
// but not yet needed
assert(0==1) ;
Bool_t IsEmc(void) const {return kFALSE ; } // tells that this is not a EMC
Bool_t IsCPV(void) const {return kTRUE ; } // true if the recpoint is in CPV
Bool_t IsSortable() const { return kTRUE ; } // tells that this is a sortable object
- void Print(Option_t * opt = "void") ;
+ void Print(Option_t *) ;
AliPHOSCpvRecPoint & operator = (const AliPHOSCpvRecPoint & rvalue) {
// assignement operator requested by coding convention but not needed
}
//____________________________________________________________________________
-AliPHOSDigit::AliPHOSDigit(const AliPHOSDigit & digit)
+AliPHOSDigit::AliPHOSDigit(const AliPHOSDigit & digit) : AliDigitNew(digit)
{
// copy ctor
}
//____________________________________________________________________________
-void AliPHOSDigit::Print(Option_t *option) const
+void AliPHOSDigit::Print(Option_t *) const
{
printf("PHOS digit: Amp=%d, Id=%d, Time=%f, NPrim=%d ",fAmp,fId,fTime,fNprimary);
for(Int_t index = 0; index <fNprimary; index ++ )
Int_t GetPrimary(Int_t index) const ;
Float_t GetTime(void) const {return fTime ;}
Bool_t IsSortable() const { return kTRUE ; }
- void Print(Option_t *option) const;
+ void Print(Option_t *) const;
void SetAmp(Int_t Amp) { fAmp=Amp ; }
void SetTime(Float_t Time) {fTime = Time ;}
void ShiftPrimary(Int_t shift); // shift to separate different TreeK in merging
//____________________________________________________________________________
AliPHOSDigitizer::AliPHOSDigitizer(const AliPHOSDigitizer & d)
+ : AliDigitizer(d)
{
// copyy ctor
public:
- AliPHOSEMCAGeometry();
- AliPHOSEMCAGeometry(const AliPHOSEMCAGeometry & cpv) {
- // cpy ctor requested by Coding Convention but not yet needed
- assert(0==1) ;
- }
+ AliPHOSEMCAGeometry();
+ AliPHOSEMCAGeometry(const AliPHOSEMCAGeometry & cpv) : TObject(cpv) {
+ // cpy ctor requested by Coding Convention but not yet needed
+ assert(0==1) ;
+ }
virtual ~AliPHOSEMCAGeometry(void) {}
AliPHOSEMCAGeometry & operator = (const AliPHOSEMCAGeometry & rvalue) {
}
//____________________________________________________________________________
-void AliPHOSEmcRecPoint::Print(Option_t * option) const
+void AliPHOSEmcRecPoint::Print(Option_t *) const
{
// Print the list of digits belonging to the cluster
Float_t GetTime(void) const{return fTime ; }
Bool_t IsEmc(void) const { return kTRUE ; } // true if the recpoint is in EMC
Bool_t IsSortable() const {return kTRUE ; } // says that emcrecpoints are sortable objects
- void Print(Option_t * opt = "void")const ;
+ void Print(Option_t *)const ;
void Purify(Float_t threshold) ; //Removes digits below threshold
Float_t GetM2x() const {return fM2x; } // Get second X-moment
//____________________________________________________________________________
AliPHOSFastRecParticle::AliPHOSFastRecParticle(const AliPHOSFastRecParticle & rp)
+ : TParticle(rp)
{
// copy ctor
{
// Calculates the position of the PHOS modules in ALICE global coordinate system
- Double_t const kRADDEG = 180.0 / kPI ;
+ Double_t const kRADDEG = 180.0 / TMath::Pi() ;
Float_t pphi = 2 * TMath::ATan( GetOuterBoxSize(0) / ( 2.0 * GetIPtoUpperCPVsurface() ) ) ;
pphi *= kRADDEG ;
if (pphi > fAngle){
}
Float_t phi = GetPHOSAngle( tmpPHOS->GetPHOSMod()) ;
- Double_t const kRADDEG = 180.0 / kPI ;
+ Double_t const kRADDEG = 180.0 / TMath::Pi() ;
Float_t rphi = phi / kRADDEG ;
TRotation rot ;
TRotation dummy = rot.Invert() ; // to transform from original frame to rotate frame
gpos.Transform(rot) ; // rotate the baby
+ gmat = 0; // Not implemented yet
}
}
Float_t phi = GetPHOSAngle( tmpPHOS->GetPHOSMod()) ;
- Double_t const kRADDEG = 180.0 / kPI ;
+ Double_t const kRADDEG = 180.0 / TMath::Pi() ;
Float_t rphi = phi / kRADDEG ;
TRotation rot ;
pos.SetY(y0) ;
Float_t phi = GetPHOSAngle( phosmodule) ;
- Double_t const kRADDEG = 180.0 / kPI ;
+ Double_t const kRADDEG = 180.0 / TMath::Pi() ;
Float_t rphi = phi / kRADDEG ;
TRotation rot ;
fgGeom = 0;
fRotMatrixArray = 0; }
- AliPHOSGeometry(const AliPHOSGeometry & geom) {
+ AliPHOSGeometry(const AliPHOSGeometry & geom) : AliGeometry(geom) {
// cpy ctor requested by Coding Convention but not yet needed
assert(0==1) ;
AliPHOSGetter(){ // ctor: this is a singleton, the ctor should never be called but cint needs it as public
Fatal("ctor", "AliPHOSGetter is a singleton default ctor not callable") ;
}
- AliPHOSGetter(const AliPHOSGetter & obj) {
+ AliPHOSGetter(const AliPHOSGetter & obj) : TObject(obj) {
// cpy ctor requested by Coding Convention
Fatal("cpy ctor", "not implemented") ;
}
ClassImp(AliPHOSHit)
//____________________________________________________________________________
- AliPHOSHit::AliPHOSHit(const AliPHOSHit & hit)
+ AliPHOSHit::AliPHOSHit(const AliPHOSHit & hit) : AliHit(hit)
{
// copy ctor
fX = hit.fX ;
//____________________________________________________________________________
AliPHOSImpact::AliPHOSImpact(const AliPHOSImpact & hit)
+ : AliHit(hit)
{
// copy ctor
public:
AliPHOSJet() ; // ctor
- AliPHOSJet(const AliPHOSJet & jet) {
+ AliPHOSJet(const AliPHOSJet & jet) : TObject(jet){
// copy ctor: no implementation yet
Fatal("cpy ctor", "not implemented") ;
}
public:
AliPHOSJetFinder() ; // ctor
- AliPHOSJetFinder(const AliPHOSJetFinder & jet) {
+ AliPHOSJetFinder(const AliPHOSJetFinder & jet) : TNamed(jet) {
// copy ctor: no implementation yet
Fatal("cpy ctor", "not implemented") ;
}
public:
AliPHOSLoader();
- AliPHOSLoader(const AliPHOSLoader & obj){}
+ AliPHOSLoader(const AliPHOSLoader & obj) : AliLoader(obj) {}
AliPHOSLoader(const Char_t *detname,const Char_t *eventfoldername);
virtual ~AliPHOSLoader() ;
AliPHOSPID() ; // ctor
AliPHOSPID (const TString alirunFileName, const TString eventFolderName = AliConfig::fgkDefaultEventFolderName) ;
- AliPHOSPID(const AliPHOSPID & pid) {;}
+ AliPHOSPID(const AliPHOSPID & pid) : TTask(pid) {;}
virtual ~AliPHOSPID() ; // dtor
virtual void Exec(Option_t * option) { Warning("Exec", "not defined" ) ; }
fCheckable = 0;
} ; // default ctor (not to be used)
AliPHOSQAChecker(const char * name, const char * title) ; // ctor
- AliPHOSQAChecker(AliPHOSQAChecker& obj) {assert(0==1);}
+ AliPHOSQAChecker(AliPHOSQAChecker& obj) : TTask(obj) {assert(0==1);}
virtual ~AliPHOSQAChecker() ; // dtor
void Alarms() { ExecuteTask("A") ; }
AliPHOSQAFloatCheckable(){} // default ctor not to be used
AliPHOSQAFloatCheckable(const char * name) ; // ctor
- AliPHOSQAFloatCheckable(AliPHOSQAFloatCheckable& obj) {assert(0==1);}
+ AliPHOSQAFloatCheckable(AliPHOSQAFloatCheckable& obj)
+ : AliPHOSQAVirtualCheckable(obj) {assert(0==1);}
virtual ~AliPHOSQAFloatCheckable() ; // dtor
virtual Float_t GetValue() const { return fValue ; }
AliPHOSQAIntCheckable(){} // default ctor not to be used
AliPHOSQAIntCheckable(const char * name) ; // ctor
- AliPHOSQAIntCheckable(AliPHOSQAIntCheckable& obj) {assert(0==1);}
+ AliPHOSQAIntCheckable(AliPHOSQAIntCheckable& obj)
+ : AliPHOSQAVirtualCheckable(obj) {assert(0==1);}
virtual ~AliPHOSQAIntCheckable() ; // dtor
virtual Float_t GetValue() const { return (Float_t)fValue ; }
fObject = 0;
} // default ctor not to be used
AliPHOSQAObjectCheckable(const char * name) ; // ctor
- AliPHOSQAObjectCheckable(AliPHOSQAObjectCheckable& obj) {assert(0==1);}
+ AliPHOSQAObjectCheckable(AliPHOSQAObjectCheckable& obj) : AliPHOSQAVirtualCheckable(obj)
+ {assert(0==1);}
virtual ~AliPHOSQAObjectCheckable() ; // dtor
virtual TObject * GetObject() const { return fObject ; }
fAlarms = 0;
} // default ctor not to be used
AliPHOSQAVirtualCheckable(const char * name) ; // ctor
- AliPHOSQAVirtualCheckable(AliPHOSQAVirtualCheckable& obj) {assert(0==1);}
+ AliPHOSQAVirtualCheckable(AliPHOSQAVirtualCheckable& obj) : TNamed(obj) {assert(0==1);}
virtual ~AliPHOSQAVirtualCheckable() ; // dtor
void AddChecker(AliPHOSQAChecker * ch) ;
//____________________________________________________________________________
AliPHOSRecParticle::AliPHOSRecParticle(const AliPHOSRecParticle & rp)
+ : AliPHOSFastRecParticle(rp)
{
// copy ctor
clustertext ->Draw("");
}
gPad->Update() ;
- Print() ;
+ Print("dummy") ;
delete[] xi ;
delete[] zi ;
}
}
}
//____________________________________________________________________________
-void AliPHOSRecPoint::EvalAll(Float_t logWeight,TClonesArray * digits)
+void AliPHOSRecPoint::EvalAll(Float_t,TClonesArray * digits)
{
//evaluates (if necessary) all RecPoint data members
AliPHOSRecPoint() ; // ctor
AliPHOSRecPoint(const char * opt) ; // ctor
- AliPHOSRecPoint(const AliPHOSRecPoint & rp) {
+ AliPHOSRecPoint(const AliPHOSRecPoint & rp) : AliRecPoint(rp) {
// cpy ctor requested by Coding Convention
// but not yet needed
assert(0==1) ;
virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
virtual void Draw(Option_t * option="") ;
virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py) ;
- virtual void EvalAll(Float_t logWeight,TClonesArray * digits) ;
+ virtual void EvalAll(Float_t ,TClonesArray * digits) ;
virtual void EvalPHOSMod(AliPHOSDigit * digit) ;
virtual void EvalPrimaries(TClonesArray * digits) ;
virtual void GetGlobalPosition(TVector3 & gpos, TMatrix & gmat) const ; // return global position in ALICE
return kTRUE ;
}
virtual void Paint(Option_t * option="");
- virtual void Print(Option_t * opt = "void") const {
+ virtual void Print(Option_t *) const {
// Print prototype
}
AliPHOSReconstructioner() ; //ctor
AliPHOSReconstructioner(const char * headreFile, const char * branchName = "Default");
- AliPHOSReconstructioner(const AliPHOSReconstructioner & rec) {
+ AliPHOSReconstructioner(const AliPHOSReconstructioner & rec) : TTask(rec) {
// cpy ctor:
// requested by the Coding Convention
Fatal("cpy ctor", "not implemented") ;
}
//____________________________________________________________________________
-AliPHOSSDigitizer::AliPHOSSDigitizer(const AliPHOSSDigitizer & sd) {
+AliPHOSSDigitizer::AliPHOSSDigitizer(const AliPHOSSDigitizer & sd)
+ : TTask(sd)
+{
//cpy ctor
fA = sd.fA ;
public:
- AliPHOSSupportGeometry();
- AliPHOSSupportGeometry(const AliPHOSSupportGeometry & cpv) {
- // cpy ctor requested by Coding Convention but not yet needed
- assert(0==1) ;
- }
+ AliPHOSSupportGeometry();
+ AliPHOSSupportGeometry(const AliPHOSSupportGeometry & geom) : TObject(geom) {
+ // cpy ctor requested by Coding Convention but not yet needed
+ assert(0==1) ;
+ }
virtual ~AliPHOSSupportGeometry(void) {}
AliPHOSSupportGeometry & operator = (const AliPHOSSupportGeometry & rvalue) {
//____________________________________________________________________________
AliPHOSTrackSegment::AliPHOSTrackSegment( const AliPHOSTrackSegment & ts)
+ : TObject(ts)
{
// Copy ctor
AliPHOSTrackSegmentMaker();
AliPHOSTrackSegmentMaker(const TString alirunFileName, const TString eventFolderName = AliConfig::fgkDefaultEventFolderName) ;
- AliPHOSTrackSegmentMaker(const AliPHOSTrackSegmentMaker & tsmaker) { ; }
+ AliPHOSTrackSegmentMaker(const AliPHOSTrackSegmentMaker & tsmaker) : TTask(tsmaker) { ; }
virtual ~ AliPHOSTrackSegmentMaker() ;
virtual void Exec(Option_t * option){Warning("Exec", "Not Defined" ) ; }
AliPHOSTrackSegmentMakerv1() ;
AliPHOSTrackSegmentMakerv1(const TString alirunFileNameFile, const TString eventFolderName = AliConfig::fgkDefaultEventFolderName);
- AliPHOSTrackSegmentMakerv1(const AliPHOSTrackSegmentMakerv1 & tsm) {
+ AliPHOSTrackSegmentMakerv1(const AliPHOSTrackSegmentMakerv1 & tsm) : AliPHOSTrackSegmentMaker(tsm) {
// cpy ctor: no implementation yet
// requested by the Coding Convention
Fatal("cpy ctor", "not implemented") ;
const Int_t kColorPHOS = kRed ;
const Int_t kColorXTAL = kBlue ;
- Double_t const kRADDEG = 180.0 / kPI ;
+ Double_t const kRADDEG = 180.0 / TMath::Pi() ;
AliPHOSGeometry * geom = GetGeometry() ;
AliPHOSEMCAGeometry * emcg = geom->GetEMCAGeometry() ;
*/
//END_HTML
- const Double_t kRADDEG = 180.0 / kPI ;
+ const Double_t kRADDEG = 180.0 / TMath::Pi() ;
const Int_t kColorCPV = kGreen ;
const Int_t kColorFrame = kYellow ;
const Int_t kColorGassiplex = kRed;
// --- Position PHOS mdules in ALICE setup ---
Int_t idrotm[99] ;
- Double_t const kRADDEG = 180.0 / kPI ;
+ Double_t const kRADDEG = 180.0 / TMath::Pi() ;
Float_t * phosParams = geom->GetPHOSParams() ;
Float_t r = geom->GetIPtoOuterCoverDistance() + phosParams[3] - geom->GetCPVBoxSize(1) ;
AliPHOSv0() {}
AliPHOSv0(const char *name, const char *title="") ;
- AliPHOSv0(const AliPHOSv0 & phos) {
+ AliPHOSv0(const AliPHOSv0 & phos) : AliPHOS(phos) {
// cpy ctor: no implementation yet
// requested by the Coding Convention
Fatal("cpy ctor", "not implemented") ;
// dtor
}
- virtual void AddHit( Int_t shunt, Int_t primary, Int_t track, Int_t id, Float_t *hits ) {
+// virtual void AddHit( Int_t shunt, Int_t primary, Int_t track, Int_t id, Float_t *hits ) {
+ virtual void AddHit( Int_t, Int_t, Int_t, Int_t, Float_t*) {
// useless since there are no hits
Fatal("AddHit", "not to be used with v0") ;
}
AliPHOSv1(void) ;
AliPHOSv1(const char *name, const char *title="") ;
- AliPHOSv1(const AliPHOSv1 & phos) {
+ AliPHOSv1(const AliPHOSv1 & phos) : AliPHOSv0(phos) {
// cpy ctor: no implementation yet
// requested by the Coding Convention
Fatal("cpy ctor", "not implemented") ;
const Int_t kColorPHOS = kRed ;
- Double_t const kRADDEG = 180.0 / kPI ;
+ Double_t const kRADDEG = 180.0 / TMath::Pi() ;
new TBRIK( "BigBox", "PHOS box", "void", GetBigBox(0)/2,
GetBigBox(1)/2,
// --- Position PHOS mdules in ALICE setup ---
Int_t idrotm[99] ;
- Double_t const kRADDEG = 180.0 / kPI ;
+ Double_t const kRADDEG = 180.0 / TMath::Pi() ;
for( Int_t i = 1; i <= GetGeometry()->GetNModules(); i++ ) {
AliPHOSvFast() ;
AliPHOSvFast(const char *name, const char *title="") ;
- AliPHOSvFast(const AliPHOSvFast & fast) {
+ AliPHOSvFast(const AliPHOSvFast & fast) : AliPHOS(fast) {
// cpy ctor: no implementation yet
// requested by the Coding Convention
assert(0==1) ;
}
virtual ~AliPHOSvFast(void) ;
- virtual void AddHit( Int_t shunt, Int_t primary, Int_t track, Int_t id, Float_t *hits ) {
- // useless since there are no hits
- assert(0==1) ;
- }
void AddRecParticle(const AliPHOSFastRecParticle & rp) ; // adds primary particle to the RecParticles list
virtual void BuildGeometry(void) ; // creates the geometry for the ROOT display
virtual void CreateGeometry(void) ; // creates the geometry for GEANT
AliPHOSvImpacts(void) ;
AliPHOSvImpacts(const char *name, const char *title="") ;
- AliPHOSvImpacts(const AliPHOSvImpacts & phos) {
+ AliPHOSvImpacts(const AliPHOSvImpacts & phos) : AliPHOSv1(phos) {
// cpy ctor: no implementation yet
// requested by the Coding Convention
Fatal("cpy ctor", "not implemented") ;