}
}//void AliRICHChamber::GenerateTresholds()
//______________________________________________________________________________
-void AliRICHChamber::Print(Option_t *option) const
+void AliRICHChamber::Print(Option_t *) const
{
Info(fName.Data(),"r=%8.3f theta=%5.1f phi=%5.1f x=%8.3f y=%8.3f z=%8.3f",
Rho(), Theta()*r2d,Phi()*r2d , X(), Y(), Z());
AliRICHChamber(Int_t iModuleN,AliRICHParam *pParam);
AliRICHChamber(const AliRICHChamber &chamber ) : TNamed(chamber) {}//copy ctor
virtual ~AliRICHChamber() {;}//dtor
- AliRICHChamber& operator=(const AliRICHChamber& rhs){return *this;}
+ AliRICHChamber& operator=(const AliRICHChamber&){return *this;}
void LocaltoGlobal(Float_t pos[3],Float_t Localpos[3]);//Transformation from local to global coordinates, chamber-dependant
void GlobaltoLocal(Float_t pos[3],Float_t localpos[3]);//Transformation from Global to local coordinates, chamber-dependant
void GenerateTresholds(); //Generate pad dependent tresholds
Float_t ROuter() const{return frMax;} // Return outer radius of sensitive volum
void SetZPOS(Float_t p1) {fzPos=p1;}
Float_t ZPosition() const{return fzPos;}
- void SetGeometryModel(AliRICHGeometry* pRICHGeometry) {fGeometry=pRICHGeometry;}
- AliRICHGeometry* GetGeometryModel() const{return fGeometry;}
+ void SetGeometryModel(AliRICHGeometry* pRICHGeometry) {fGeometry=pRICHGeometry;}
+ AliRICHGeometry* GetGeometryModel() const{return fGeometry;}
void SetResponseModel(AliRICHResponse* pRICHResponse) {fResponse=pRICHResponse;}
AliRICHResponse* GetResponseModel() const{return fResponse;}
- void SetSegmentationModel(AliSegmentation* pRICHSegmentation) {fSegmentation=pRICHSegmentation;}
- AliSegmentation* GetSegmentationModel(Int_t i=0) const{return fSegmentation;}
+ void SetSegmentationModel(AliSegmentation* pRICHSegmentation) {fSegmentation=pRICHSegmentation;}
+ AliSegmentation* GetSegmentationModel() const{return fSegmentation;}
void SetReconstructionModel(AliRICHClusterFinder *pRICHReconstruction) {fReconstruction=pRICHReconstruction;}
AliRICHClusterFinder* &GetReconstructionModel() {return fReconstruction;}
void SigGenInit(Float_t x, Float_t y, Float_t z) {fSegmentation->SigGenInit(x, y, z) ;}
}
AliRICHClusterFinder::AliRICHClusterFinder(const AliRICHClusterFinder& ClusterFinder)
+ :TObject(ClusterFinder)
{
// Copy Constructor
}
//
// Minimisation function
-void fcn(Int_t &npar, Double_t *gin, Double_t &f, Double_t *par, Int_t iflag)
+void fcn(Int_t &npar, Double_t */*gin*/, Double_t &f, Double_t *par, Int_t /*iflag*/)
{
+ npar=1;
Int_t i;
Float_t delta;
Float_t chisq=0;
fNdigits = fDigits->GetEntriesFast();
}
-AliRICHClusterFinder& AliRICHClusterFinder::operator=(const AliRICHClusterFinder& rhs)
+AliRICHClusterFinder& AliRICHClusterFinder::operator=(const AliRICHClusterFinder& /*rhs*/)
{
// Assignment operator
return *this;
ClassImp(AliRICHDetect)
//___________________________________________
-AliRICHDetect::AliRICHDetect() : TObject()
+AliRICHDetect::AliRICHDetect()
+ :TNamed()
{
// Default constructor
//___________________________________________
AliRICHDetect::AliRICHDetect(const char *name, const char *title)
- : TObject()
+ :TNamed(name,title)
{
TStyle *mystyle=new TStyle("Plain","mystyle");
AliRICHGeometry* geometry;
iChamber = &(pRICH->Chamber(0));
- segmentation=(AliRICHSegmentationV0*) iChamber->GetSegmentationModel(0);
+ segmentation=(AliRICHSegmentationV0*) iChamber->GetSegmentationModel();
geometry=iChamber->GetGeometryModel();
}
void AliRICHDetect::free_i3tensor(int ***t, long nrl, long nrh, long ncl, long nch,long ndl, long ndh)
-// free a Int_t f3tensor allocated by i3tensor()
-{
+{// free a Int_t f3tensor allocated by i3tensor()
+ nrh++;ndh++;nch++;
int NR_END=1;
free((char*) (t[nrl][ncl]+ndl-NR_END));
class AliRICHDetect;
-class AliRICHDetect : public TObject {
+class AliRICHDetect : public TNamed
+{
public:
AliRICHDetect();
TCanvas *fc4; //Online mesh activation data
ClassDef(AliRICHDetect,1) //Reconstruction module for :RICH version 0
- };
-
-
-
-
+};
+
#endif
//___________________________________________
AliRICHDetectV1::AliRICHDetectV1(const char *name, const char *title)
- : AliRICHDetect()
+ :AliRICHDetect(name,title)
{
TStyle *mystyle=new TStyle("Plain","mystyle");
AliRICHGeometry* geometry;
iChamber = &(pRICH->Chamber(0));
- segmentation=(AliRICHSegmentationV0*) iChamber->GetSegmentationModel(0);
+ segmentation=(AliRICHSegmentationV0*) iChamber->GetSegmentationModel();
geometry=iChamber->GetGeometryModel();
void AliRICHDetectV1::free_i3tensor(int ***t, long nrl, long nrh, long ncl, long nch,long ndl, long ndh)
// free a Int_t f3tensor allocated by i3tensor()
{
+ nrh++;ndh++;nch++;//to remove warning
int NR_END=1;
free((char*) (t[nrl][ncl]+ndl-NR_END));
for (Int_t i =0; i<kNCH; i++) {
iChamber= &(pRICH->Chamber(i));
- segmentation=iChamber->GetSegmentationModel(1);
+ segmentation=iChamber->GetSegmentationModel();
fHitMap[i] = new AliRICHHitMapA1(segmentation, fTDList);
}
inline void AliRICHGeometry::Print(Option_t *option)const
{
- TObject::Print();
+ TObject::Print(option);
cout<<"Radiator Gap thickness: "<<GetGapThickness() <<endl;
cout<<"Proximity Gap thickness: "<<GetProximityGapThickness() <<endl;
cout<<"Quartz window length: "<<GetQuartzLength() <<endl;
if (fHitMap) delete[] fHitMap;
}
-void AliRICHHitMapA1::Clear(const char *opt)
+void AliRICHHitMapA1::Clear(const char */*opt*/)
{
// Clear contents of hit map
virtual Int_t GetHitIndex(Int_t ix, Int_t iy) const;
virtual TObject* GetHit(Int_t ix, Int_t iy) const;
virtual void FlagHit(Int_t ix, Int_t iy);
- virtual Bool_t ValidateHit(Int_t ix, Int_t iy) {return 1;}
+ virtual Bool_t ValidateHit(Int_t, Int_t) {return 1;}
virtual FlagType TestHit(Int_t ix, Int_t iy);
private:
Int_t CheckedIndex(Int_t ix, Int_t iy) const;
// keep galice.root for signal and name differently the file for
// background when add! otherwise the track info for signal will be lost !
-
+ nev++;//to remove warning
Int_t particle;
AliRICHChamber* iChamber;
for (Int_t i =0; i<kNCH; i++) {
iChamber= &(pRICH->Chamber(i));
- segmentation=iChamber->GetSegmentationModel(1);
+ segmentation=iChamber->GetSegmentationModel();
fHitMap[i] = new AliRICHHitMapA1(segmentation, fList);
}
//
ClassImp(AliRICHPatRec)
//___________________________________________
-AliRICHPatRec::AliRICHPatRec() : TObject()
+AliRICHPatRec::AliRICHPatRec() : TNamed()
{
// Default constructor
}
//___________________________________________
AliRICHPatRec::AliRICHPatRec(const char *name, const char *title)
- : TObject()
+ : TNamed(name,title)
{
//Constructor for Bari's pattern recogniton method object
}
{
// not implemented yet
-
+ track++;
+ nphot=10;
+ thetamean=4;
printf("Calling PhotonSelection\n");
}
{
// not implemented yet
-
+ track++;theta++;
printf("Calling FlagPhotons\n");
}
class AliRICHPatRec;
-class AliRICHPatRec : public TObject {
+class AliRICHPatRec : public TNamed
+{
public:
AliRICHPatRec();
ClassImp(AliRICHRecHit1D)
AliRICHRecHit1D::AliRICHRecHit1D(Int_t id, Float_t *rechit, Float_t *photons, Int_t *padsx, Int_t* padsy)
-{
- //
- // Creates a RICH rec. hit object
- //
- fTheta = rechit[0];
- fPhi = rechit[1];
- fOmega = rechit[2];
- fX = rechit[3];
- fY = rechit[4];
- fEmissPoint = rechit[5];
- fGoodPhotons = (Int_t)rechit[6];
- for(Int_t i=0; i<100; i++) {
+{// Creates a RICH rec. hit object
+ id++;//to remove warning
+ fTheta = rechit[0];
+ fPhi = rechit[1];
+ fOmega = rechit[2];
+ fX = rechit[3];
+ fY = rechit[4];
+ fEmissPoint = rechit[5];
+ fGoodPhotons = (Int_t)rechit[6];
+ for(Int_t i=0; i<100; i++) {
fCerPerPhoton[i] = photons[i];
fPadsUsedX[i] = padsx[i];
fPadsUsedY[i] = padsy[i];
- }
-
+ }
}
-
-
//
// Creates a RICH rec. hit object
//
+ id++;//to remove warning
fTheta = rechit[0];
fPhi = rechit[1];
fOmega = rechit[2];
inline void AliRICHResponseV0::Print(Option_t* option) const
{
- TObject::Print();
+ TObject::Print(option);
cout<<"Slope of the charge distribution "<<fChargeSlope <<endl;
cout<<"Width of the charge distribution in x "<<fChargeSpreadX <<endl;
cout<<"Width of the charge distribution in y "<<fChargeSpreadY <<endl;
*/
}
-Float_t AliRICHSegmentationV0::Distance2AndOffset(Int_t iX, Int_t iY, Float_t X, Float_t Y
-, Int_t *dummy)
-
-{
-// Returns the square of the distance between 1 pad
-// labelled by its Channel numbers and a coordinate
-
+Float_t AliRICHSegmentationV0::Distance2AndOffset(Int_t iX, Int_t iY, Float_t X, Float_t Y,Int_t *dummy)
+{// Returns the square of the distance between 1 pad labelled by its Channel numbers and a coordinate
+ dummy=0;
Float_t x,y;
GetPadC(iX,iY,x,y);
return (x-X)*(x-X) + (y-Y)*(y-Y);
void AliRICHSegmentationV0::Draw(const char* opt) const
{
-
+ Info("Draw","%s",opt);
// Dummy draw routine
/*
virtual Float_t GetAnod(Float_t xhit) const;
// Transform from pad to real coordinates
virtual void GetPadI(Float_t x, Float_t y , Int_t &ix, Int_t &iy);
- virtual void GetPadI(Float_t x, Float_t y , Float_t z, Int_t &ix, Int_t &iy)
- {GetPadI(x, y, ix, iy);}
+ virtual void GetPadI(Float_t x, Float_t y , Float_t /*z*/, Int_t &ix, Int_t &iy) {GetPadI(x, y, ix, iy);}
// Transform from real to pad coordinates
virtual void GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y);
virtual void GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y, Float_t &z)
virtual void SetPad(Int_t ix, Int_t iy);
// set hit position
virtual void SetHit(Float_t xhit , Float_t yhit);
- virtual void SetHit(Float_t xhit, Float_t yhit, Float_t zhit)
- {SetHit(xhit, yhit);}
+ virtual void SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/){SetHit(xhit, yhit);}
//
// Iterate over pads
// Initialiser
virtual void FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy);
- virtual void FirstPad(Float_t xhit, Float_t yhit, Float_t zhit, Float_t dx, Float_t dy)
- {FirstPad(xhit, yhit, dx, dy);}
+ virtual void FirstPad(Float_t xhit, Float_t yhit, Float_t /*zhit*/, Float_t dx, Float_t dy){FirstPad(xhit, yhit, dx, dy);}
// Stepper
virtual void NextPad();
// Condition
dummy);
// Number of pads read in parallel and offset to add to x
// (specific to LYON, but mandatory for display)
- virtual void GetNParallelAndOffset(Int_t iX, Int_t iY,
- Int_t *Nparallel, Int_t *Offset) {*Nparallel=1;*Offset=0;}
+ virtual void GetNParallelAndOffset(Int_t /*iX*/, Int_t /*iY*/,Int_t *Nparallel, Int_t *Offset) {*Nparallel=1;*Offset=0;}
// Get next neighbours
- virtual void Neighbours
- (Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10]);
+ virtual void Neighbours (Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10]);
//
// Current Pad during Integration
// x-coordinate
// current sector
virtual Int_t ISector() {return 1;}
// calculate sector from x-y coordinates
- virtual Int_t Sector(Int_t ix, Int_t iy) {return 1;}
- virtual Int_t Sector(Float_t x, Float_t y) {return 1;}
+ virtual Int_t Sector(Int_t,Int_t) {return 1;}
+ virtual Int_t Sector(Float_t,Float_t) {return 1;}
//
// Signal Generation Condition during Stepping
virtual Int_t SigGenCond(Float_t x, Float_t y, Float_t z);
// Debugging utilities
virtual void Draw(const char* = "") const;
// Function for systematic corrections
- virtual void SetCorrFunc(Int_t dum, TF1* func) {fCorr=func;}
+ virtual void SetCorrFunc(Int_t /*dum*/, TF1* func) {fCorr=func;}
virtual TF1* CorrFunc(Int_t) const {return fCorr;}
ClassDef(AliRICHSegmentationV0,1)
Init(0); // ??? remove 0
}
-void AliRICHSegmentationV1::Init(Int_t id)
-{
-// Recalculates all the values after some of them have been changed
-
+void AliRICHSegmentationV1::Init(Int_t /*id*/)
+{//Recalculates all the values after some of them have been changed
+
Float_t csi_length = fNpy*fDpy + fDeadZone;
Float_t csi_width = fNpx*fDpx + 2*fDeadZone;
virtual Int_t Sector(Float_t x, Float_t y); // calculate sector from x-y coordinates
virtual void GetPadI(Float_t x ,Float_t y ,Int_t &ix,Int_t &iy); // Transform from pad to real coordinates
- virtual void GetPadI(Float_t x, Float_t y , Float_t z, Int_t &ix, Int_t &iy) {GetPadI(x, y, ix, iy);}
+ virtual void GetPadI(Float_t x, Float_t y , Float_t /*z*/, Int_t &ix, Int_t &iy) {GetPadI(x, y, ix, iy);}
virtual void GetPadC(Int_t ix,Int_t iy,Float_t &x ,Float_t &y ); // Transform from real to pad coordinates
virtual void GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y, Float_t &z) {z=0; GetPadC(ix, iy, x , y);}
inline void AliRICHSegmentationV1::Print(Option_t *option)const
{
- TObject::Print();
+ TObject::Print(option);
cout<<"Pad width in cm: "<<fDpx <<endl;
cout<<"Pad heights in cm: "<<fDpy <<endl;
cout<<"Pad number along x: "<<fNpx <<endl;
if (fHitMap) delete[] fHitMap;
}
-void AliRICHTresholdMap::Clear(const char *opt)
+void AliRICHTresholdMap::Clear(const char */*opt*/)
{
// Clear contents of hit map
virtual Int_t GetHitIndex(Int_t ix, Int_t iy) const;
virtual TObject* GetHit(Int_t ix, Int_t iy) const;
virtual void FlagHit(Int_t ix, Int_t iy);
- virtual Bool_t ValidateHit(Int_t ix, Int_t iy) {return 1;}
+ virtual Bool_t ValidateHit(Int_t,Int_t) {return 1;}
virtual FlagType TestHit(Int_t ix, Int_t iy);
private:
Int_t CheckedIndex(Int_t ix, Int_t iy) const;
((AliRICHChamber*)fChambers->At(6))->SetGid(7);
- segmentation=Chamber(0).GetSegmentationModel(0);
+ segmentation=Chamber(0).GetSegmentationModel();
geometry=Chamber(0).GetGeometryModel();
response=Chamber(0).GetResponseModel();
AliRICHChamber* iChamber;
iChamber = &(pRICH->Chamber(0));
- segmentation=(AliRICHSegmentationV0*) iChamber->GetSegmentationModel(0);
+ segmentation=(AliRICHSegmentationV0*) iChamber->GetSegmentationModel();
geometry=iChamber->GetGeometryModel();
Float_t distance;
AliRICHGeometry* geometry;
iChamber = &(pRICH->Chamber(0));
- AliRICHSegmentationV1* segmentation=(AliRICHSegmentationV1*) iChamber->GetSegmentationModel(0);
+ AliRICHSegmentationV1* segmentation=(AliRICHSegmentationV1*) iChamber->GetSegmentationModel();
geometry=iChamber->GetGeometryModel();
new TBRIK("S_RICH","S_RICH","void",71.09999,11.5,73.15);