AliMUONCluster.h

Go to the documentation of this file.

#ifndef ALIMUONCLUSTER_H
#define ALIMUONCLUSTER_H

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice                               */

// $Id$

// Author Laurent Aphecetche

#ifndef ROOT_TObject
#  include "TObject.h"
#endif
#ifndef ROOT_TVector2
#  include "TVector2.h"
#endif
#ifndef ROOT_TString
#  include "TString.h"
#endif
#ifndef ALI_MP_AREA_H
#  include "AliMpArea.h"
#endif
#ifndef ALI_MP_DIRECTION_H
#  include "AliMpDirection.h"
#endif
#ifndef ALI_MP_ENCODE_PAIR_H
#  include "AliMpEncodePair.h"
#endif

#ifndef ROOT_TObjArray
#  include "TObjArray.h"
#endif

class AliMUONPad;

class AliMUONCluster : public TObject
{
public:
  AliMUONCluster();
  AliMUONCluster(const AliMUONCluster& rhs);
  AliMUONCluster& operator=(const AliMUONCluster& rhs);
  
  virtual ~AliMUONCluster();
  
  Bool_t Contains(const AliMUONPad& pad) const;
  
  TString AsString() const;
  
  static Bool_t AreOverlapping(const AliMUONCluster& c1, const AliMUONCluster& c2);
  
  AliMUONPad* AddPad(const AliMUONPad& pad);

  AliMpArea Area() const;

  AliMpArea Area(Int_t cathode) const;

  Float_t Charge() const;
  Float_t Charge(Int_t cathode) const;

  Float_t ChargeAsymmetry() const;

  Float_t Chi2() const { return fChi2; }

  virtual void Copy(TObject& obj) const;

  Bool_t HasPosition() const { return fHasPosition; }

  Bool_t IsSaturated(Int_t cathode) const { return fIsSaturated[cathode]; }
  
  Bool_t IsSaturated() const { return IsSaturated(0) && IsSaturated(1); }
  
  Int_t MaxChargeCathode() const { return Charge(0) > Charge(1) ? 0:1; }

  Int_t MaxRawChargeCathode() const { return RawCharge(0) > RawCharge(1) ? 0:1; }

  TVector2 MaxPadDimensions(Int_t cathode, Int_t statusMask, Bool_t matchMask) const;
  
  TVector2 MaxPadDimensions(Int_t statusMask, Bool_t matchMask) const;
  
  TVector2 MinPadDimensions(Int_t cathode, Int_t statusMask, Bool_t matchMask) const;
  
  TVector2 MinPadDimensions(Int_t statusMask, Bool_t matchMask) const;
  
  Int_t Multiplicity() const;
  Int_t Multiplicity(Int_t cathode) const;

  Long_t NofPads(Int_t cathode, Int_t statusMask, Bool_t matchMask) const;
  
  Long_t NofPads(Int_t statusMask, Bool_t matchMask=kTRUE) const;
  
  Bool_t IsSortable() const { return kTRUE; }
  
//  Bool_t IsEqual(const TObject* obj) const;
  
  virtual Int_t Compare(const TObject* obj) const;
  
  AliMUONPad* Pad(Int_t index) const;
  
  virtual void Paint(Option_t* opt="");
  
  TVector2 Position() const { return fPosition; }
  TVector2 PositionError() const { return fPositionError; }

  virtual void Print(Option_t* opt="") const;
      
  Float_t RawCharge() const;
  
  Float_t RawCharge(Int_t cathode) const;
    
  Float_t RawChargeAsymmetry() const;
  
  void RemovePad(AliMUONPad* pad);

  void SetCharge(Float_t chargeCath0, Float_t chargeCath1)
  { fHasCharge = kTRUE; fCharge[0]=chargeCath0; fCharge[1]=chargeCath1; }

  void SetChi2(Float_t chi2) { fChi2 = chi2; }

  void SetPosition(const TVector2& pos, const TVector2& errorOnPos) 
  { fHasPosition = kTRUE; fPosition = pos; fPositionError = errorOnPos; }
  
  Int_t Cathode() const;
  
  void AddCluster(const AliMUONCluster& cluster);

  void Clear(Option_t* opt="");
  
  Bool_t IsMonoCathode() const;

//private:
    void DumpMe() const;
  
private:
  TObjArray fPads; 
  Bool_t fHasPosition; 
  TVector2 fPosition; 
  TVector2 fPositionError; 
  Int_t fMultiplicity[2]; 
  Float_t fRawCharge[2]; 
  Bool_t fHasCharge; 
  Float_t fCharge[2]; 
  Float_t fChi2; 
  Bool_t fIsSaturated[2]; 
  
  ClassDef(AliMUONCluster,3) // A cluster of AliMUONPad
};

#endif