}
-//____________________________________________________________________
-AliMUON::AliMUON(const AliMUON& rMUON)
- : AliDetector(rMUON)
-{
-/// Protected copy constructor
-
- AliFatal("Not implemented.");
-}
-
//____________________________________________________________________
AliMUON::~AliMUON()
{
delete fRawWriter;
}
-//________________________________________________________________________
-AliMUON& AliMUON::operator = (const AliMUON& rhs)
-{
-/// Protected assignement operator
-
- if (this == &rhs) return *this;
-
- AliFatal("Not implemented.");
-
- return *this;
-}
-
//_____________________________________________________________________________
void AliMUON::AddGeometryBuilder(AliMUONVGeometryBuilder* geomBuilder)
{
#include "TObjArray.h"
///
+/// \class AliMUON1DArray
/// This class is simply a wrapper to a TObjArray, offering in addition a
/// control over the replacement policy when you add
/// something to it.
///
+/// \author Laurent Aphecetche
+/// \cond CLASSIMP
ClassImp(AliMUON1DArray)
+/// \endcond
//_____________________________________________________________________________
AliMUON1DArray::AliMUON1DArray(Int_t theSize)
: AliMUONV1DStore(),
fArray(0x0)
{
- //
- // Default ctor
- //
+/// Default ctor
+
if ( theSize )
{
fArray = new TObjArray(theSize);
: AliMUONV1DStore(),
fArray(0x0)
{
+/// Copy constructor
+
other.CopyTo(*this);
}
AliMUON1DArray&
AliMUON1DArray::operator=(const AliMUON1DArray& other)
{
+/// Assignment operator
+
other.CopyTo(*this);
return *this;
}
//_____________________________________________________________________________
AliMUON1DArray::~AliMUON1DArray()
{
- //
- // dtor, we're the owner of our internal array.
- //
+/// dtor, we're the owner of our internal array.
+
delete fArray;
}
void
AliMUON1DArray::CopyTo(AliMUON1DArray& dest) const
{
- //
- // Make a deep copy
- //
+/// Make a deep copy
+
delete dest.fArray;
dest.fArray = new TObjArray;
dest.fArray->SetOwner(kTRUE);
TObject*
AliMUON1DArray::Get(Int_t i) const
{
- //
- // Get the object located at index i, if it exists, and if i is correct.
- //
+/// Get the object located at index i, if it exists, and if i is correct.
+
if ( i >= 0 && i < fArray->GetSize() )
{
return fArray->At(i);
Bool_t
AliMUON1DArray::Set(Int_t i, TObject* object, Bool_t replace)
{
- //
- // Set the object located at i
- // If replace=kFALSE and there's already an object at location i,
- // this method fails and returns kFALSE, otherwise it returns kTRUE
- //
+/// Set the object located at i
+/// If replace=kFALSE and there's already an object at location i,
+/// this method fails and returns kFALSE, otherwise it returns kTRUE
+
if ( i >= 0 && i < fArray->GetSize() )
{
TObject* o = Get(i);
/// \class AliMUON1DArray
/// \brief Implementation of AliMUONV1DStore
///
-/// \author Laurent Aphecetche
+// Author Laurent Aphecetche
#ifndef ALIMUON1DARRAY_H
#define ALIMUON1DARRAY_H
#include "AliLog.h"
#include "AliMpExMap.h"
-///
-/// Basic implementation of AliMUONV2DStore container using
+/// \class AliMUON2DMap
+/// \brief Basic implementation of AliMUONV2DStore container using
/// AliMpExMap internally.
/// What we store is a "double" map : an AliMpExMap of AliMpExMaps
///
+/// \author Laurent Aphecetche
+/// \cond CLASSIMP
ClassImp(AliMUON2DMap)
+/// \endcond
//_____________________________________________________________________________
AliMUON2DMap::AliMUON2DMap() : AliMUONV2DStore(), fMap(new AliMpExMap(true))
{
- //
- // ctor.
- //
+/// Default constructor.
}
//_____________________________________________________________________________
: AliMUONV2DStore(),
fMap(0x0)
{
- other.CopyTo(*this);
+ /// Copy constructor.
+
+ other.CopyTo(*this);
}
//_____________________________________________________________________________
AliMUON2DMap&
AliMUON2DMap::operator=(const AliMUON2DMap& other)
{
+/// Assignment operator
+
other.CopyTo(*this);
return *this;
}
//_____________________________________________________________________________
AliMUON2DMap::~AliMUON2DMap()
{
- //
- // dtor. we delete the map, which will delete the objects, as we're owner.
- //
+/// Destructor.
+/// We delete the map, which will delete the objects, as we're owner.
+
delete fMap;
}
void
AliMUON2DMap::CopyTo(AliMUON2DMap&) const
{
- //
- // Copy this into dest.
- //
+/// Copy this into dest.
+
AliFatal("Implement me if needed");
}
TObject*
AliMUON2DMap::Get(Int_t i, Int_t j) const
{
- //
- // Return the value at position (i,j).
- //
+/// Return the value at position (i,j).
+
TObject* o = fMap->GetValue(i);
if ( o )
{
void
AliMUON2DMap::Print(Option_t*) const
{
- //
- // Not implemented (yet?)
- //
+/// Not implemented (yet?)
}
//_____________________________________________________________________________
Bool_t
AliMUON2DMap::Set(Int_t i, Int_t j, TObject* object, Bool_t replace)
{
- //
- // Set the object at position (i,j).
- // If replace==kTRUE, we don't care if there's an object there already,
- // otherwise we might refuse to set if the (i,j) location is already
- // filled (in which case we return kFALSE).
+/// Set the object at position (i,j).
+/// If replace==kTRUE, we don't care if there's an object there already,
+/// otherwise we might refuse to set if the (i,j) location is already
+/// filled (in which case we return kFALSE).
TObject* o = fMap->GetValue(i);
if ( !o )
/// \brief Basic implementation of AliMUONV2DStore container using
/// AliMpExMap internally.
///
-/// \author Laurent Aphecetche
+// Author Laurent Aphecetche
#ifndef AliMUON2DMAP_H
#define AliMUON2DMAP_H
virtual TObject* Get(Int_t i, Int_t j) const;
virtual Bool_t Set(Int_t i, Int_t j, TObject* object, Bool_t replace);
- virtual Bool_t IsOwner() const { return kTRUE; }
+ /// Whether or not this container is the owner of its contents.
+ virtual Bool_t IsOwner() const { return kTRUE; }
virtual void Print(Option_t* opt="") const;
#include "TMath.h"
#include "TString.h"
+/// \class AliMUONCalibParam1I
+///
/// This class is implementing the AliMUONVCalibParam interface.
///
/// It stores a given number of integers.
///
/// You might consider just as it is, namely a C++ wrapper to
/// a plain int[] array.
+///
+/// \author Laurent Aphecetche
+/// \cond CLASSIMP
ClassImp(AliMUONCalibParam1I)
+/// \endcond
//_____________________________________________________________________________
AliMUONCalibParam1I::AliMUONCalibParam1I()
fSize(0),
fValues(0x0)
{
- //
- // Default ctor.
- //
+/// Default constructor.
}
//_____________________________________________________________________________
: AliMUONVCalibParam(),
fSize(theSize)
{
- //
- // Normal ctor, where theSize specifies the number of channels handled
- // by this object, and fillWithValue the default value assigned to each
- // channel.
- //
+/// Normal constructor, where theSize specifies the number of channels handled
+/// by this object, and fillWithValue the default value assigned to each
+/// channel.
+
if ( fSize > 0 )
{
fValues = new Int_t[fSize];
fSize(0),
fValues(0x0)
{
- //
- // Copy ctor
- //
+/// Copy constructor
+
other.CopyTo(*this);
}
AliMUONCalibParam1I&
AliMUONCalibParam1I::operator=(const AliMUONCalibParam1I& other)
{
- //
- // Assignment operator
- //
+/// Assignment operator
+
AliMUONVCalibParam::operator=(other);
other.CopyTo(*this);
return *this;
//_____________________________________________________________________________
AliMUONCalibParam1I::~AliMUONCalibParam1I()
{
- //
- // dtor.
- //
+/// Destructor.
+
delete[] fValues;
}
void
AliMUONCalibParam1I::CopyTo(AliMUONCalibParam1I& destination) const
{
- //
- // Copy this into destination.
- //
+/// Copy this into destination.
+
delete[] destination.fValues;
destination.fSize = fSize;
if ( fSize > 0 )
void
AliMUONCalibParam1I::Print(Option_t* opt) const
{
- //
- // Output this object to stdout.
- // If opt=="full", then all channels are printed, otherwise
- // only the general characteristics are printed.
- //
+/// Output this object to stdout.
+/// If opt=="full", then all channels are printed, otherwise
+/// only the general characteristics are printed.
+
TString sopt(opt);
sopt.ToUpper();
cout << "AliMUONCalibParam1I - Size=" << Size()
void
AliMUONCalibParam1I::SetValueAsFloat(Int_t i, Int_t j, Float_t value)
{
- //
- // Set the value as a float, which is casted to an int prior to storage.
- //
+/// Set the value as a float, which is casted to an int prior to storage.
+
SetValueAsInt(i,j,TMath::Nint(value));
}
void
AliMUONCalibParam1I::SetValueAsInt(Int_t i, Int_t j, Int_t value)
{
- //
- // Set the value for a given channel.
- // (i,j) are checked for correctness before use.
- //
+/// Set the value for a given channel.
+/// (i,j) are checked for correctness before use.
+
if ( j != 0 || i >= fSize || i < 0 )
{
AliError(Form("Invalid (i,j)=(%d,%d) max allowed is (%d,%d)",
Float_t
AliMUONCalibParam1I::ValueAsFloat(Int_t i, Int_t j) const
{
- //
- // Return one value as a float.
- //
+/// Return one value as a float.
+
return 1.0*ValueAsInt(i,j);
}
Int_t
AliMUONCalibParam1I::ValueAsInt(Int_t i, Int_t j) const
{
- //
- // Return one value as an integer, after checking that (i,j)
- // are valid indices.
- //
+/// Return one value as an integer, after checking that (i,j)
+/// are valid indices.
+
if ( j != 0 || i >= fSize || i < 0 )
{
AliError(Form("Invalid (i,j)=(%d,%d) max allowed is (%d,%d)",
/// \ingroup base
/// \class AliMUONCalibParam1I
-/// \brief Implementation of AliMUONVCalibParam.
-///
-/// Handle the case of 1 integer parameter per channel.
+/// \brief Implementation of AliMUONVCalibParam,
+/// handle the case of 1 integer parameter per channel.
///
-/// \author Laurent Aphecetche
+// Author Laurent Aphecetche
#ifndef ALIMUONCALIBPARAM1I_H
#define ALIMUONCALIBPARAM1I_H
#include "TString.h"
///
-/// Implementation of AliMUONVCalibParam for pair of floats.
+/// \class AliMUONCalibParam2F
+/// \brief Implementation of AliMUONVCalibParam for pair of floats.
///
+/// Handle the case of 2 floating point parameters per channel.
/// Conceptually, this class is the equivalent of a vector or float pairs,
/// but it is implemented using bare Float_t[] array.
///
+/// \author Laurent Aphecetche
+/// \cond CLASSIMP
ClassImp(AliMUONCalibParam2F)
+/// \endcond
//_____________________________________________________________________________
AliMUONCalibParam2F::AliMUONCalibParam2F()
fN(0),
fValues(0x0)
{
- //
- // Default ctor.
- //
+/// Default constructor.
}
//_____________________________________________________________________________
fSize(theSize),
fN(fSize*Dimension())
{
- //
- // Normal ctor, where theSize specifies the number of channels handled
- // by this object, and fillWithValue the default value assigned to each
- // channel.
- //
+/// Normal constructor, where theSize specifies the number of channels handled
+/// by this object, and fillWithValue the default value assigned to each
+/// channel.
+
if ( fN > 0 )
{
fValues = new Float_t[fN];
fN(0),
fValues(0x0)
{
+/// Copy constructor.
+
other.CopyTo(*this);
}
AliMUONCalibParam2F&
AliMUONCalibParam2F::operator=(const AliMUONCalibParam2F& other)
{
+/// Assignment operator
+
other.CopyTo(*this);
return *this;
}
//_____________________________________________________________________________
AliMUONCalibParam2F::~AliMUONCalibParam2F()
{
- //
- // dtor
- //
+/// Destructor
+
delete[] fValues;
}
void
AliMUONCalibParam2F::CopyTo(AliMUONCalibParam2F& destination) const
{
- //
- // Copy *this to destination
- //
+/// Copy *this to destination
+
delete[] destination.fValues;
destination.fN = fN;
destination.fSize = fSize;
Int_t
AliMUONCalibParam2F::Index(Int_t i, Int_t j) const
{
- //
- // Compute the 1D index of the internal storage from the pair (i,j)
- // Returns -1 if the (i,j) pair is invalid
- //
+/// Compute the 1D index of the internal storage from the pair (i,j)
+/// Returns -1 if the (i,j) pair is invalid
+
if ( i >= 0 && i < Size() && j >= 0 && j < Dimension() )
{
return i + Size()*j;
void
AliMUONCalibParam2F::Print(Option_t* opt) const
{
- //
- // Output this object to stdout.
- // If opt=="full", then all channels are printed, otherwise
- // only the general characteristics are printed.
- //
+/// Output this object to stdout.
+/// If opt=="full", then all channels are printed, otherwise
+/// only the general characteristics are printed.
+
TString sopt(opt);
sopt.ToUpper();
cout << "AliMUONCalibParam2F - Size=" << Size()
void
AliMUONCalibParam2F::SetValueAsFloat(Int_t i, Int_t j, Float_t value)
{
- //
- // Set one value as a float, after checking that the indices are correct.
- //
+/// Set one value as a float, after checking that the indices are correct.
+
Int_t ix = Index(i,j);
if ( ix < 0 )
void
AliMUONCalibParam2F::SetValueAsInt(Int_t i, Int_t j, Int_t value)
{
- //
- // Set one value as an int.
- //
+/// Set one value as an int.
+
SetValueAsFloat(i,j,static_cast<Float_t>(value));
}
Float_t
AliMUONCalibParam2F::ValueAsFloat(Int_t i, Int_t j) const
{
- //
- // Return the value as a float (which it is), after checking indices.
- //
+/// Return the value as a float (which it is), after checking indices.
+
Int_t ix = Index(i,j);
if ( ix < 0 )
Int_t
AliMUONCalibParam2F::ValueAsInt(Int_t i, Int_t j) const
{
- //
- // Return the value as an int, by rounding the internal float value.
- //
+/// Return the value as an int, by rounding the internal float value.
+
Float_t v = ValueAsFloat(i,j);
return TMath::Nint(v);
}
/// \ingroup base
/// \class AliMUONCalibParam2F
-/// \brief Implementation of AliMUONVCalibParam.
+/// \brief Implementation of AliMUONVCalibParam for pair of floats
///
-/// Handle the case of 2 floating point parameters per channel.
-///
-///
-/// \author Laurent Aphecetche
+// Author Laurent Aphecetche
#ifndef ALIMUONCALIBPARAM2F_H
#define ALIMUONCALIBPARAM2F_H
virtual ~AliMUONCalibParam2F();
- virtual Int_t Dimension() const { return 2; }
+ /// Return dimension (here 2)
+ virtual Int_t Dimension() const { return 2; }
virtual void Print(Option_t* opt="") const;
virtual void SetValueAsFloat(Int_t i, Int_t j, Float_t value);
virtual void SetValueAsInt(Int_t i, Int_t j, Int_t value);
- virtual Int_t Size() const { return fSize; }
+ /// Return size - the number of float pair we hold
+ virtual Int_t Size() const { return fSize; }
virtual Float_t ValueAsFloat(Int_t i, Int_t j=0) const;
virtual Int_t ValueAsInt(Int_t i, Int_t j=0) const;
#include "AliMUONVCalibParam.h"
#include "Riostream.h"
+/// \class AliMUONCalibrationData
+///
+/// For the moment, this class stores pedestals, gains and deadchannels
+/// that are fetched from the CDB.
///
/// This class is to be considered as a convenience class.
/// Its aim is to ease retrieval of calibration data from the
/// It acts as a "facade" to a bunch of underlying
/// containers/calibration classes.
///
+/// \author Laurent Aphecetche
+/// \cond CLASSIMP
ClassImp(AliMUONCalibrationData)
+/// \endcond
//_____________________________________________________________________________
AliMUONCalibrationData::AliMUONCalibrationData(Int_t runNumber,
fTriggerLut(0x0),
fTriggerEfficiency(0x0)
{
- //
- // Default ctor.
+/// Default ctor.
+
// If deferredInitialization is false, we read *all* calibrations
// at once.
// So when using this class to access only one kind of calibrations (e.g.
// only pedestals), you should put deferredInitialization to kTRUE, which
// will instruct this object to fetch the data only when neeeded.
- //
+
if ( deferredInitialization == kFALSE )
{
OnDemandGains();
}
}
-//_____________________________________________________________________________
-AliMUONCalibrationData::AliMUONCalibrationData(const AliMUONCalibrationData&)
-: TObject()
-{
- AliFatal("Implement me if needed");
-}
-
-//_____________________________________________________________________________
-AliMUONCalibrationData&
-AliMUONCalibrationData::operator=(const AliMUONCalibrationData&)
-{
- AliFatal("Implement me if needed");
- return *this;
-}
-
//_____________________________________________________________________________
AliMUONCalibrationData::~AliMUONCalibrationData()
{
- //
- // dtor. Note that we're the owner of our pointers.
- //
+/// Destructor. Note that we're the owner of our pointers.
+
delete fPedestals;
delete fGains;
delete fDeadChannels;
AliMUONVCalibParam*
AliMUONCalibrationData::DeadChannels(Int_t detElemId, Int_t manuId) const
{
- //
- // Return the calibration for a given (detElemId, manuId) pair
- // Note that for DeadChannel, it's "legal" to return 0x0 (e.g. if a manu
- // is perfect, we might simply forget it in the store).
- //
+/// Return the calibration for a given (detElemId, manuId) pair
+/// Note that for DeadChannel, it's "legal" to return 0x0 (e.g. if a manu
+/// is perfect, we might simply forget it in the store).
+
return
static_cast<AliMUONVCalibParam*>(OnDemandDeadChannels()->Get(detElemId,manuId));
}
AliMUONV2DStore*
AliMUONCalibrationData::OnDemandDeadChannels() const
{
- //
- // Create (if needed) and return the internal store for DeadChannels.
- //
+/// Create (if needed) and return the internal store for DeadChannels.
+
if (!fDeadChannels)
{
AliCDBEntry* entry = GetEntry("MUON/Calib/DeadChannels");
AliCDBEntry*
AliMUONCalibrationData::GetEntry(const char* path) const
{
- //
- // Access the CDB for a given path (e.g. MUON/Calib/Pedestals),
- // and return the corresponding CDBEntry.
- //
+/// Access the CDB for a given path (e.g. MUON/Calib/Pedestals),
+/// and return the corresponding CDBEntry.
+
return AliCDBManager::Instance()->Get(path,fRunNumber);
}
AliMUONVCalibParam*
AliMUONCalibrationData::Gains(Int_t detElemId, Int_t manuId) const
{
- //
- // Return the gains for a given (detElemId, manuId) pair
- // Note that, unlike the DeadChannel case, if the result is 0x0, that's an
- // error (meaning that we should get gains for all channels).
- //
+/// Return the gains for a given (detElemId, manuId) pair
+/// Note that, unlike the DeadChannel case, if the result is 0x0, that's an
+/// error (meaning that we should get gains for all channels).
+
AliMUONVCalibParam* gain =
static_cast<AliMUONVCalibParam*>(OnDemandGains()->Get(detElemId,manuId));
if (!gain)
AliMUONV2DStore*
AliMUONCalibrationData::OnDemandGains() const
{
- //
- // Create (if needed) and return the internal store for gains.
- //
+/// Create (if needed) and return the internal store for gains.
+
if (!fGains)
{
AliCDBEntry* entry = GetEntry("MUON/Calib/Gains");
AliMUONVCalibParam*
AliMUONCalibrationData::GlobalTriggerBoardMasks() const
{
- //
- // Return the masks for the global trigger board.
- //
+/// Return the masks for the global trigger board.
+
return OnDemandGlobalTriggerBoardMasks();
}
AliMUONVCalibParam*
AliMUONCalibrationData::OnDemandGlobalTriggerBoardMasks() const
{
- //
- // Create (if needed) and return the internal store for GlobalTriggerBoardMasks.
- //
+/// Create (if needed) and return the internal store for GlobalTriggerBoardMasks.
+
if (!fGlobalTriggerBoardMasks)
{
AliCDBEntry* entry = GetEntry("MUON/Calib/GlobalTriggerBoardMasks");
AliMUONVCalibParam*
AliMUONCalibrationData::LocalTriggerBoardMasks(Int_t localBoardNumber) const
{
- //
- // Return the masks for a given trigger local board.
- //
+/// Return the masks for a given trigger local board.
+
AliMUONVCalibParam* ltbm =
static_cast<AliMUONVCalibParam*>(OnDemandLocalTriggerBoardMasks()->Get(localBoardNumber));
if (!ltbm)
AliMUONV1DStore*
AliMUONCalibrationData::OnDemandLocalTriggerBoardMasks() const
{
- //
- // Create (if needed) and return the internal store for LocalTriggerBoardMasks.
- //
+/// Create (if needed) and return the internal store for LocalTriggerBoardMasks.
+
if (!fLocalTriggerBoardMasks)
{
AliCDBEntry* entry = GetEntry("MUON/Calib/LocalTriggerBoardMasks");
AliMUONV2DStore*
AliMUONCalibrationData::OnDemandPedestals() const
{
- //
- // Create (if needed) and return the internal storage for pedestals.
- //
+/// Create (if needed) and return the internal storage for pedestals.
+
if (!fPedestals)
{
AliCDBEntry* entry = GetEntry("MUON/Calib/Pedestals");
void
AliMUONCalibrationData::Print(Option_t*) const
{
- //
- // A very basic dump of our guts.
- //
+/// A very basic dump of our guts.
+
cout << "RunNumber " << RunNumber()
<< " fGains=" << fGains
<< " fPedestals=" << fPedestals
AliMUONVCalibParam*
AliMUONCalibrationData::Pedestals(Int_t detElemId, Int_t manuId) const
{
- //
- // Return the pedestals for a given (detElemId, manuId) pair.
- // A return value of 0x0 is considered an error, meaning we should get
- // pedestals for all channels.
- //
+/// Return the pedestals for a given (detElemId, manuId) pair.
+/// A return value of 0x0 is considered an error, meaning we should get
+/// pedestals for all channels.
+
AliMUONVCalibParam* ped =
static_cast<AliMUONVCalibParam*>(OnDemandPedestals()->Get(detElemId,manuId));
if (!ped)
AliMUONVCalibParam*
AliMUONCalibrationData::RegionalTriggerBoardMasks(Int_t index) const
{
- //
- // Return the masks for a given trigger regional board.
- //
+/// Return the masks for a given trigger regional board.
+
AliMUONVCalibParam* rtbm =
static_cast<AliMUONVCalibParam*>(OnDemandRegionalTriggerBoardMasks()->Get(index));
if (!rtbm)
AliMUONV1DStore*
AliMUONCalibrationData::OnDemandRegionalTriggerBoardMasks() const
{
- //
- // Create (if needed) and return the internal store for RegionalTriggerBoardMasks.
- //
+/// Create (if needed) and return the internal store for RegionalTriggerBoardMasks.
+
if (!fRegionalTriggerBoardMasks)
{
AliCDBEntry* entry = GetEntry("MUON/Calib/RegionalTriggerBoardMasks");
AliMUONTriggerEfficiencyCells*
AliMUONCalibrationData::TriggerEfficiency() const
{
- //
- // Return the trigger efficiency.
- //
+/// Return the trigger efficiency.
+
return OnDemandTriggerEfficiency();
}
AliMUONTriggerEfficiencyCells*
AliMUONCalibrationData::OnDemandTriggerEfficiency() const
{
- //
- //
- //
+/// \todo: add comment
+
if (!fTriggerEfficiency)
{
AliCDBEntry* entry = GetEntry("MUON/Calib/TriggerEfficiency");
AliMUONTriggerLut*
AliMUONCalibrationData::TriggerLut() const
{
- //
- // Return the trigger look up table.
- //
+/// Return the trigger look up table.
+
return OnDemandTriggerLut();
}
AliMUONTriggerLut*
AliMUONCalibrationData::OnDemandTriggerLut() const
{
- //
- //
- //
+/// \todo: add comment
+
if (!fTriggerLut)
{
AliCDBEntry* entry = GetEntry("MUON/Calib/TriggerLut");
/// \ingroup base
/// \class AliMUONCalibrationData
/// \brief Single entry point to access MUON calibration data.
-///
-/// For the moment, this class stores pedestals, gains and deadchannels
-/// that are fetched from the CDB.
///
-/// \author Laurent Aphecetche
+// Author Laurent Aphecetche
#ifndef ALIMUONCALIBRATIONDATA_H
#define ALIMUONCALIBRATIONDATA_H
#include "AliMUONHit.h"
#include "AliLog.h"
+/// \cond CLASSIMP
ClassImp(AliMUONChamber)
+/// \endcond
+//_______________________________________________________
AliMUONChamber::AliMUONChamber()
: TObject(),
fId(0),
AliDebug(1, Form("ctor this = %p", this) );
}
-//_______________________________________________________
-AliMUONChamber::AliMUONChamber(const AliMUONChamber& rChamber)
- : TObject(rChamber)
-{
-/// Protected copy constructor
-
- AliFatal("Not implemented.");
- // Dummy copy constructor
-}
-
//_______________________________________________________
AliMUONChamber::~AliMUONChamber()
{
AliDebug(1, Form("dtor this = %p", this));
}
-//_______________________________________________________
-AliMUONChamber & AliMUONChamber::operator =(const AliMUONChamber& rhs)
-{
-/// Protected assignement operator
-
- if (this == &rhs) return *this;
-
- AliFatal("Not implemented.");
-
- return *this;
-}
-
//_____________________________________________________
void AliMUONChamber::ChargeCorrelationInit()
{
AliMUONChamber(Int_t id);
virtual ~AliMUONChamber();
-//
-// Get chamber Id
+/// Get chamber Id
virtual Int_t GetId() const {return fId;}
-//
-//
-// Set response model
+
+/// Set response model
virtual void SetResponseModel(AliMUONResponse* thisResponse) {fResponse=thisResponse;}
-//
-// Get pointer to response model
+
+/// Get pointer to response model
virtual AliMUONResponse* &ResponseModel(){return fResponse;}
//
// Member function forwarding to the segmentation and response models
//
-// Calculate pulse height from energy loss
+/// Calculate pulse height from energy loss
virtual Float_t IntPH(Float_t eloss) {return fResponse->IntPH(eloss);}
// Initialisation of charge fluctuation for given hit
// Configuration forwarding
//
-// Define signal distribution region
-// by number of sigmas of the distribution function
+/// Define signal distribution region
+/// by number of sigmas of the distribution function
virtual void SetSigmaIntegration(Float_t p1)
{fResponse->SetSigmaIntegration(p1);}
-// Set the single electron pulse-height (ADCchan/e)
+/// Set the single electron pulse-height (ADCchan/e)
virtual void SetChargeSlope(Float_t p1) {fResponse->SetChargeSlope(p1);}
-// Set width of charge distribution function
+/// Set width of charge distribution function
virtual void SetChargeSpread(Float_t p1, Float_t p2) {fResponse->SetChargeSpread(p1,p2);}
-// Set maximum ADC count value
+/// Set maximum ADC count value
virtual void SetMaxAdc(Int_t p1) {fResponse->SetMaxAdc(p1);}
//
// Cluster formation method (charge disintegration)
virtual void DisIntegration(AliMUONHit* hit,
Int_t& x, Float_t newclust[6][500]);
-//
+/// Set charge correlation
virtual void SetChargeCorrel(Float_t correl) {fResponse->SetChargeCorrel(correl);}
protected:
: AliMUONChamber(),
fkGeomTransformer(0)
{
-// Default constructor
+/// Default constructor
}
//-------------------------------------------
-AliMUONChamberTrigger::AliMUONChamberTrigger(const AliMUONChamberTrigger& right)
- : AliMUONChamber(right)
-{
-/// Protected copy constructor (not implemented)
-
- AliFatal("Copy constructor not provided.");
+AliMUONChamberTrigger:: ~AliMUONChamberTrigger()
+{
+/// Destructor
}
//-------------------------------------------
: AliMUONChamber(id),
fkGeomTransformer(kGeometryTransformer)
{
-// Constructor using chamber id
+/// Constructor using chamber id
}
-//-------------------------------------------
-AliMUONChamberTrigger&
-AliMUONChamberTrigger::operator=(const AliMUONChamberTrigger& right)
-{
-/// Protected assignement operator (not implemented)
-
- // check assignement to self
- if (this == &right) return *this;
-
- AliFatal("Assignement operator not provided.");
-
- return *this;
-}
-
//-------------------------------------------
void AliMUONChamberTrigger::DisIntegration(AliMUONHit* hit,
Int_t& nnew,
Float_t newclust[6][500])
{
-//
-// Generates pad hits (simulated cluster)
-// using the segmentation and the response model
+/// Generates pad hits (simulated cluster)
+/// using the segmentation and the response model
Float_t tof = hit->Age();
public:
AliMUONChamberTrigger();
AliMUONChamberTrigger(Int_t id, const AliMUONGeometryTransformer* kGeometry);
- virtual ~AliMUONChamberTrigger(){}
+ virtual ~AliMUONChamberTrigger();
// Cluster formation method (charge disintegration)
#include "AliMUONDataIterator.h"
#include "AliMUONDigit.h"
-/// A helper class to dump data from AliRoot-generated root files.
+/// \class AliMUONCheck
+/// \brief A helper class to dump data from AliRoot-generated root files.
///
/// Only implemented for digits so far, it is meant as a replacement
/// of the MUONCheck.C macro, or to be used by this macro to simplify it.
///
+/// \author Laurent Aphecetche
+/// \cond CLASSIMP
ClassImp(AliMUONCheck)
+/// \endcond
//_____________________________________________________________________________
AliMUONCheck::AliMUONCheck(const char* galiceFile,
fRunLoader(0x0),
fData(0x0)
{
- // ctor
+/// Standard constructor
fRunLoader = AliRunLoader::Open(fFileName.Data(),"MUONFolder","READ");
if (!fRunLoader)
}
}
-//_____________________________________________________________________________
-AliMUONCheck::AliMUONCheck(const AliMUONCheck& rhs) : TObject(rhs)
-{
- // copy ctor
- AliFatal("Implement me if needed");
-}
-
-//_____________________________________________________________________________
-AliMUONCheck&
-AliMUONCheck::operator=(const AliMUONCheck&)
-{
- // assignement operator
- AliFatal("Implement me if needed")
- return *this;
-}
-
//_____________________________________________________________________________
AliMUONCheck::~AliMUONCheck()
{
- // dtor
+/// Destructor
+
delete fData;
}
void
AliMUONCheck::DumpDigits(Option_t* opt) const
{
- // Dump the digits to screen
+/// Dump the digits to screen
+
if ( !IsValid() ) return;
Int_t nevents = fRunLoader->GetNumberOfEvents();
/// \class AliMUONCheck
/// \brief A helper class to dump data from AliRoot-generated root files.
///
-/// Only implemented for digits so far, it is meant as a replacement
-/// of the MUONCheck.C macro, or to be used by this macro to simplify it.
-///
-/// \author Laurent Aphecetche
+// Author Laurent Aphecetche
#ifndef ROOT_TObject
# include "TObject.h"
AliMUONCheck(const char* galiceFile, Int_t firstEvent=0, Int_t lastEvent=-1);
virtual ~AliMUONCheck();
+ /// Return true if contains valid data
Bool_t IsValid() const { return (fData!=0); }
void DumpDigits(Option_t* opt="") const;
#include "AliRun.h"
#include "AliLog.h"
+/// \cond CLASSIMP
ClassImp(AliMUONCommonGeometryBuilder)
+/// \endcond
//______________________________________________________________________________//___________________________________________
AliMUONCommonGeometryBuilder::AliMUONCommonGeometryBuilder(AliMUON* muon)
: AliMUONVGeometryBuilder(-1),
fMUON(muon)
{
-/// Standars constructor
+/// Standard constructor
}
//______________________________________________________________________________//___________________________________________
const AliMUONCommonGeometryBuilder& right)
: AliMUONVGeometryBuilder(right)
{
- /// copy constructor (not implemented)
+/// Copy constructor (not implemented)
AliFatal("Copy constructor not provided.");
}
AliMUONCommonGeometryBuilder&
AliMUONCommonGeometryBuilder::operator=(const AliMUONCommonGeometryBuilder& right)
{
- /// assignement operator (not implemented)
+/// Assignement operator (not implemented)
// check assignement to self
if (this == &right) return *this;
// $Id$
-/// \ingroup base
+/// \ingroup sim
/// \class AliMUONCommonGeometryBuilder
/// \brief Class to build common materials
///
virtual ~AliMUONCommonGeometryBuilder();
virtual void CreateMaterials();
- virtual void CreateGeometry() {}
- virtual void SetSensitiveVolumes() {}
- virtual void SetTransformations() {}
+ virtual void CreateGeometry() {} ///< No geometry is created
+ virtual void SetSensitiveVolumes() {} ///< No sensitive volumes are set
+ virtual void SetTransformations() {} ///< No transformations are set
protected:
AliMUONCommonGeometryBuilder(const AliMUONCommonGeometryBuilder& right);
private:
// data members
- AliMUON* fMUON; ///< Class to build common materials
+ AliMUON* fMUON; ///< the MUON detector class
- ClassDef(AliMUONCommonGeometryBuilder,1) // Common MUON geometry definitions
+ ClassDef(AliMUONCommonGeometryBuilder,1) // Class to build common materials
};
#endif //ALI_MUON_COMMON_GEOMETRY_BUILDER_H
/// by the way).
///
+/// \cond CLASSIMP
+ClassImp(AliMUONConstants)
+/// \endcond
+
Int_t AliMUONConstants::fgNCh = 14;
Int_t AliMUONConstants::fgNTrackingCh = 10;
Int_t AliMUONConstants::fgNTriggerCh = 4;
Int_t AliMUONConstants::fgMaxZoom = 20;
-ClassImp(AliMUONConstants)
-
//______________________________________________________________________________
Int_t AliMUONConstants::ChamberNumber(Float_t z)
{
static Float_t PitchSt1() {return fgPitchSt1;}
protected:
+ /// Default constructor
AliMUONConstants() : TObject() {}
+ /// Destructor
virtual ~AliMUONConstants(){}
private:
#include "TArrayI.h"
#include "TString.h"
+/// \cond CLASSIMP
ClassImp(AliMUONData)
+/// \endcond
//_____________________________________________________________________________
AliMUONData::AliMUONData():
fSplitLevel(0),
fCurrentEvent(-1)
{
- // Constructor for AliMUONData
-}
-
-//_____________________________________________________________________________
-AliMUONData::AliMUONData(const AliMUONData& rMUONData):TNamed(rMUONData)
-{
-// Protected copy constructor
-
- AliFatal("Not implemented.");
+/// Standard constructor
}
//_____________________________________________________________________________
AliMUONData::~AliMUONData()
{
- // Destructor for AliMUONData
+/// Destructor for AliMUONData
if (fHits) {
fHits->Delete();
delete fHits;
}
}
-//_____________________________________________________________________________
-AliMUONData& AliMUONData::operator=(const AliMUONData& rhs)
-{
-// Protected assignement operator
-
- if (this == &rhs) return *this;
-
- AliFatal("Not implemented.");
-
- return *this;
-}
-
-
//_____________________________________________________________________________
void AliMUONData::AddDigit(Int_t id, Int_t *tracks, Int_t *charges, Int_t *digits)
{
- //
- // Add a MUON digit to the list of Digits of the detection plane id
- //
+/// Add a MUON digit to the list of Digits of the detection plane id
+
TClonesArray &ldigits = * Digits(id) ;
new(ldigits[fNdigits[id]++]) AliMUONDigit(tracks,charges,digits);
}
//_____________________________________________________________________________
void AliMUONData::AddDigit(Int_t id, const AliMUONDigit& digit)
{
- //
- // Add a MUON digit to the list of Digits of the detection plane id
- //
+/// Add a MUON digit to the list of Digits of the detection plane id
+
TClonesArray &ldigits = * Digits(id) ;
new(ldigits[fNdigits[id]++]) AliMUONDigit(digit);
}
//_____________________________________________________________________________
void AliMUONData::AddSDigit(Int_t id, Int_t *tracks, Int_t *charges, Int_t *sdigits)
{
- //
- // Add a MUON Sdigit to the list of SDigits of the detection plane id
- //
+/// Add a MUON Sdigit to the list of SDigits of the detection plane id
+
TClonesArray &lSdigits = * SDigits(id) ;
new(lSdigits[fNSdigits[id]++]) AliMUONDigit(tracks,charges,sdigits);
}
//_____________________________________________________________________________
void AliMUONData::AddSDigit(Int_t id, const AliMUONDigit& Sdigit)
{
- //
- // Add a MUON Sdigit to the list of SDigits of the detection plane id
- //
+/// Add a MUON Sdigit to the list of SDigits of the detection plane id
+
TClonesArray &lSdigits = * SDigits(id) ;
new(lSdigits[fNSdigits[id]++]) AliMUONDigit(Sdigit);
}
//_____________________________________________________________________________
void AliMUONData::AddGlobalTrigger(const AliMUONGlobalTrigger& trigger )
{
- // add a MUON Global Trigger to the list (only one GlobalTrigger per event !);
+/// Add a MUON Global Trigger to the list (only one GlobalTrigger per event !);
+
TClonesArray &globalTrigger = *fGlobalTrigger;
new(globalTrigger[fNglobaltrigger++]) AliMUONGlobalTrigger(trigger);
}
Float_t phi, Float_t length, Float_t destep,
Float_t Xref,Float_t Yref,Float_t Zref)
{
- // Add new hit to the hit list
+/// Add new hit to the hit list
+
TClonesArray &lhits = *fHits;
new(lhits[fNhits++]) AliMUONHit(fIshunt, track, iChamber,
idpart, X, Y, Z,
Float_t Xref,Float_t Yref,Float_t Zref)
{
// Add new hit to the hit list
+
TClonesArray &lhits = *fHits;
new(lhits[fNhits++]) AliMUONHit(fIshunt, track, detElemId,
idpart, X, Y, Z,
//____________________________________________________________________________
void AliMUONData::AddLocalTrigger(const AliMUONLocalTrigger& trigger)
{
- // add a MUON Local Trigger to the list
+/// add a MUON Local Trigger to the list
+
TClonesArray &localTrigger = *fLocalTrigger;
new(localTrigger[fNlocaltrigger++]) AliMUONLocalTrigger(trigger);
}
//_____________________________________________________________________________
void AliMUONData::AddRawCluster(Int_t id, const AliMUONRawCluster& c)
{
- //
- // Add a MUON rawcluster to the list in the detection plane id
- //
+/// Add a MUON rawcluster to the list in the detection plane id
+
TClonesArray &lrawcl = *((TClonesArray*) fRawClusters->At(id));
new(lrawcl[fNrawclusters[id]++]) AliMUONRawCluster(c);
}
//_____________________________________________________________________________
void AliMUONData::AddRecTrack(const AliMUONTrack& track)
{
- //
- // Add a MUON rectrack
- //
+/// Add a MUON rectrack
+
TClonesArray &lrectracks = *fRecTracks;
new(lrectracks[fNrectracks++]) AliMUONTrack(track);
}
//_____________________________________________________________________________
void AliMUONData::AddRecTriggerTrack(const AliMUONTriggerTrack& triggertrack)
{
- //
- // Add a MUON triggerrectrack
- //
+/// Add a MUON triggerrectrack
+
TClonesArray &lrectriggertracks = *fRecTriggerTracks;
new(lrectriggertracks[fNrectriggertracks++]) AliMUONTriggerTrack(triggertrack);
}
//____________________________________________________________________________
TClonesArray* AliMUONData::Digits(Int_t DetectionPlane) const
{
- //Getting List of Digits
+/// Getting List of Digits
+
if (fDigits)
return ( (TClonesArray*) fDigits->At(DetectionPlane) );
else
//____________________________________________________________________________
TClonesArray* AliMUONData::SDigits(Int_t DetectionPlane) const
{
- //Getting List of SDigits
+/// Getting List of SDigits
+
if (fSDigits)
return ( (TClonesArray*) fSDigits->At(DetectionPlane) );
else
//____________________________________________________________________________
Bool_t AliMUONData::IsRawClusterBranchesInTree()
{
- // Checking if there are RawCluster Branches In TreeR
+/// Checking if there are RawCluster Branches In TreeR
+
if (TreeR()==0x0) {
AliError("No treeR in memory");
return kFALSE;
//____________________________________________________________________________
Bool_t AliMUONData::IsDigitsBranchesInTree()
{
- // Checking if there are RawCluster Branches In TreeR
+/// Checking if there are RawCluster Branches In TreeR
+
if (TreeD()==0x0) {
AliError("No treeD in memory");
return kFALSE;
//____________________________________________________________________________
Bool_t AliMUONData::IsTriggerBranchesInTree()
{
- // Checking if there are Trigger Branches In TreeR
+/// Checking if there are Trigger Branches In TreeR
if (TreeR()==0x0) {
AliError("No treeR in memory");
return kFALSE;
//____________________________________________________________________________
Bool_t AliMUONData::IsTriggerBranchesInTreeD()
{
- // Checking if there are Trigger Branches In TreeR
+/// Checking if there are Trigger Branches In TreeR
if (TreeD()==0x0) {
AliError("No treeD in memory");
return kFALSE;
//____________________________________________________________________________
Bool_t AliMUONData::IsTrackBranchesInTree()
{
- // Checking if there are Track Branches In TreeT
+/// Checking if there are Track Branches In TreeT
if (TreeT()==0x0) {
AliError("No treeT in memory");
return kFALSE;
//____________________________________________________________________________
Bool_t AliMUONData::IsTriggerTrackBranchesInTree()
{
- // Checking if there are TriggerTrack Branches In TreeT
+/// Checking if there are TriggerTrack Branches In TreeT
if (TreeT()==0x0) {
AliError("No treeT in memory");
return kFALSE;
//____________________________________________________________________________
void AliMUONData::Fill(Option_t* option)
{
- // Method to fill the trees
+/// Method to fill the trees
const char *cH = strstr(option,"H");
const char *cD = strstr(option,"D"); // Digits branches in TreeD
const char *cS = strstr(option,"S"); // SDigits branches in TreeS
//_____________________________________________________________________________
void AliMUONData::MakeBranch(Option_t* option)
{
- //
- // Create Tree branches for the MUON.
- //
+/// Create Tree branches for the MUON.
+
const Int_t kBufferSize = 4000;
char branchname[30];
//____________________________________________________________________________
TClonesArray* AliMUONData::RawClusters(Int_t DetectionPlane)
{
- // Getting Raw Clusters
+/// Getting Raw Clusters
+
if (fRawClusters)
return ( (TClonesArray*) fRawClusters->At(DetectionPlane) );
else
TClonesArray*
AliMUONData::LocalTrigger() const
{
+/// Getting local trigger
+
return fLocalTrigger;
}
void
AliMUONData::GetDigits() const
{
- // Load the digits from TreeD for the current event.
+/// Load the digits from TreeD for the current event.
+
Int_t event = fLoader->GetRunLoader()->GetEventNumber();
if ( fCurrentEvent != event )
{
TClonesArray*
AliMUONData::GlobalTrigger() const
{
- // Return the global trigger
+/// Return the global trigger
+
return fGlobalTrigger;
}
//____________________________________________________________________________
void AliMUONData::ResetDigits()
{
- //
- // Reset number of digits and the digits array for this detector
- //
+/// Reset number of digits and the digits array for this detector
+
if (fDigits == 0x0) return;
for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
if ((*fDigits)[i]) ((TClonesArray*)fDigits->At(i))->Clear("C");
//____________________________________________________________________________
void AliMUONData::ResetSDigits()
{
- //
- // Reset number of Sdigits and the Sdigits array for this detector
- //
+/// Reset number of Sdigits and the Sdigits array for this detector
+
if (fSDigits == 0x0) return;
for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
if ((*fSDigits)[i]) ((TClonesArray*)fSDigits->At(i))->Clear();
//______________________________________________________________________________
void AliMUONData::ResetHits()
{
- // Reset number of clusters and the cluster array for this detector
+/// Reset number of clusters and the cluster array for this detector
+
fNhits = 0;
if (fHits) fHits->Clear();
}
//_______________________________________________________________________________
void AliMUONData::ResetRawClusters()
{
- // Reset number of raw clusters and the raw clust array for this detector
- //
+/// Reset number of raw clusters and the raw clust array for this detector
+
for ( int i=0;i<AliMUONConstants::NTrackingCh();i++ ) {
if ((*fRawClusters)[i]) ((TClonesArray*)fRawClusters->At(i))->Clear();
if (fNrawclusters) fNrawclusters[i]=0;
//_______________________________________________________________________________
void AliMUONData::ResetTrigger()
{
- // Reset Local and Global Trigger
+/// Reset Local and Global Trigger
+
fNglobaltrigger = 0;
if (fGlobalTrigger) fGlobalTrigger->Clear();
fNlocaltrigger = 0;
//____________________________________________________________________________
void AliMUONData::ResetRecTracks()
{
- // Reset tracks information
+/// Reset tracks information
+
fNrectracks = 0;
if (fRecTracks) fRecTracks->Delete(); // necessary to delete in case of memory allocation
}
//____________________________________________________________________________
void AliMUONData::ResetRecTriggerTracks()
{
- // Reset tracks information
+/// Reset tracks information
+
fNrectriggertracks = 0;
if (fRecTriggerTracks) fRecTriggerTracks->Delete(); // necessary to delete in case of memory allocation
}
//_____________________________________________________________________________
void AliMUONData::SetTreeAddress(Option_t* option)
{
- //Setting Addresses to the events trees
+/// Setting Addresses to the events trees
+
const char *cH = strstr(option,"H");
const char *cD = strstr(option,"D"); // Digits branches in TreeD
const char *cS = strstr(option,"S"); // SDigits branches in TreeS
void
AliMUONData::Print(Option_t* opt) const
{
- // Dump object on screen
+/// Dump object on screen
+
TString options(opt);
options.ToUpper();
virtual void AddRecTrack(const AliMUONTrack& track);
virtual void AddRecTriggerTrack(const AliMUONTriggerTrack& triggertrack);
- TClonesArray* Hits() {return fHits;}
+ TClonesArray* Hits() {return fHits;} ///< Return hits
TClonesArray* Digits(Int_t DetectionPlane) const;
TClonesArray* SDigits(Int_t DetectionPlane) const;
TClonesArray* LocalTrigger() const;
TClonesArray* GlobalTrigger() const;
TClonesArray* RawClusters(Int_t DetectionPlane);
- TClonesArray* RecTracks() {return fRecTracks;}
+
+ /// Return reconstructed tracks
+ TClonesArray* RecTracks() {return fRecTracks;}
+ /// Return reconstructed trigger tracks
TClonesArray* RecTriggerTracks() {return fRecTriggerTracks;}
+ /// Load hits for \a i th entry in hits three
void GetTrack(Int_t it) const {fLoader->TreeH()->GetEvent(it);}
+ /// Get number of entries in hits three
Int_t GetNtracks() const {return (Int_t) fLoader->TreeH()->GetEntries();}
void GetDigits() const;
+ /// Load sdigits tree
void GetSDigits() const {fLoader->TreeS()->GetEvent(0);}
+ /// Load raw clusters tree
void GetRawClusters() const {fLoader->TreeR()->GetEvent(0);}
+ /// Load trigger tree
void GetTrigger() const {fLoader->TreeR()->GetEvent(0);}
+ /// Load trigger D tree
void GetTriggerD() const {fLoader->TreeD()->GetEvent(0);}
+ /// Return split level
Int_t GetSplitLevel() const {return fSplitLevel;}
+ /// Return reconstructed tracks
void GetRecTracks() const {fLoader->TreeT()->GetEvent(0);}
+ /// Return reconstructed trigger tracks
void GetRecTriggerTracks() const {fLoader->TreeT()->GetEvent(0);}
Bool_t IsRawClusterBranchesInTree();
Bool_t IsTrackBranchesInTree();
Bool_t IsTriggerTrackBranchesInTree();
+ /// Get loader
virtual AliLoader* GetLoader() const { return fLoader; }
+ /// Set loader
virtual void SetLoader(AliLoader * loader) {fLoader=loader;}
virtual void Fill(Option_t* opt=" ");
virtual void MakeBranch(Option_t *opt=" ");
virtual void SetTreeAddress(Option_t *opt=" ");
+ /// Set split level
void SetSplitLevel(Int_t SplitLevel) {fSplitLevel=SplitLevel;}
virtual void Print(Option_t* opt="") const;
virtual void ResetRecTracks();
virtual void ResetRecTriggerTracks();
+ /// Return tree with hits
TTree* TreeH() {return fLoader->TreeH(); }
+ /// Return tree with digits
TTree* TreeD() {return fLoader->TreeD(); }
+ /// Return tree with summable digits
TTree* TreeS() {return fLoader->TreeS(); }
+ /// Return tree with raw clusters
TTree* TreeR() {return fLoader->TreeR(); }
+ /// Return tree with tracks
TTree* TreeT() {return fLoader->TreeT(); }
+ /// Return tree with particles
TTree* TreeP() {return fLoader->TreeP(); }
// TIterator* CreateDigitIterator(AliMUONData::EChamberIteration type);
/// \author L. Aphecetche
///
+/// \cond CLASSIMP
+ClassImp(AliMUONDataDigitIterator)
+/// \endcond
+
//_____________________________________________________________________________
AliMUONDataDigitIterator::AliMUONDataDigitIterator(const AliMUONData* data,
Int_t firstChamber,
fFirstChamber(firstChamber),
fLastChamber(lastChamber)
{
- //
- // Ctor
- //
+ /// Standard constructor
Reset();
}
:
AliMUONVDataIterator()
{
+ /// Copy constructor
+
rhs.CopyTo(*this);
}
+//_____________________________________________________________________________
+AliMUONDataDigitIterator::~AliMUONDataDigitIterator()
+{
+ /// Destructor
+}
+
//_____________________________________________________________________________
AliMUONDataDigitIterator&
AliMUONDataDigitIterator::operator=(const AliMUONDataDigitIterator& rhs)
{
+ /// Assignment operator
+
rhs.CopyTo(*this);
return *this;
}
void
AliMUONDataDigitIterator::CopyTo(AliMUONDataDigitIterator& destination) const
{
- // Copy *this to destination
+ /// Copy *this to destination
destination.fData=fData;
destination.fFirstChamber=fFirstChamber;
destination.fLastChamber=fLastChamber;
TObject*
AliMUONDataDigitIterator::Next()
{
- // Return current element and self-position to the next one.
+ /// Return current element and self-position to the next one.
TObject* rv(0x0);
Bool_t
AliMUONDataDigitIterator::Remove()
{
- // Remove current element.
+ /// Remove current element.
if ( fDigits )
{
void
AliMUONDataDigitIterator::Reset()
{
- // Resets the iterator
+ /// Reset the iterator
fData->GetDigits();
fCurrentDigit = 0;
fCurrentChamber = fFirstChamber;
AliMUONDataDigitIterator(const AliMUONData* data, Int_t firstChamber, Int_t lastChamber);
AliMUONDataDigitIterator(const AliMUONDataDigitIterator& rhs);
AliMUONDataDigitIterator& operator=(const AliMUONDataDigitIterator& rhs);
- virtual ~AliMUONDataDigitIterator() {}
+ virtual ~AliMUONDataDigitIterator();
TObject* Next();
AliMUONDataInterface::AliMUONDataInterface()
: TObject(), fData(NULL, "MUON", "MUON")
{
-// Set all internal pointers to NULL and indices to -1.
+/// Set all internal pointers to NULL and indices to -1.
Reset();
}
-AliMUONDataInterface::AliMUONDataInterface(const AliMUONDataInterface& rhs)
- : TObject(rhs)
-{
-// Protected copy constructor
-
- AliFatal("Not implemented.");
-}
-
AliMUONDataInterface::~AliMUONDataInterface()
{
-// Delete the runloader if we created it.
-// If the runloader is not to be deleted then call Reset just before
-// the destructor is called.
+/// Delete the runloader if we created it.
+/// If the runloader is not to be deleted then call Reset just before
+/// the destructor is called.
if (fRunloader != NULL && fCreatedRunLoader)
delete fRunloader;
}
-AliMUONDataInterface&
-AliMUONDataInterface::operator=(const AliMUONDataInterface& rhs)
-{
-// Protected assignement operator
-
- if (this == &rhs) return *this;
-
- AliFatal("Not implemented.");
-
- return *this;
-}
-
-
void AliMUONDataInterface::Reset()
{
-// Sets all internal pointers to NULL and indices to -1.
-// Note: No resources are released!
-// Specificaly AliRunLoader is not deleted.
+/// Sets all internal pointers to NULL and indices to -1.
+/// Note: No resources are released!
+/// Specificaly AliRunLoader is not deleted.
fCreatedRunLoader = kFALSE;
fRunloader = NULL;
Bool_t AliMUONDataInterface::UseCurrentRunLoader()
{
-// Tries to fetch the current runloader with AliRunLoader::GetRunLoader. If nothing is
-// currently loaded then kFALSE is returned and AliMUONDataInterface is reset.
+/// Tries to fetch the current runloader with AliRunLoader::GetRunLoader. If nothing is
+/// currently loaded then kFALSE is returned and AliMUONDataInterface is reset.
Reset();
fRunloader = AliRunLoader::GetRunLoader();
Bool_t AliMUONDataInterface::FetchMuonLoader(TString filename, TString foldername)
{
- // fetches the muon loader for the given filename/foldername
+/// Fetches the muon loader for the given filename/foldername
fMuonloader = fRunloader->GetLoader("MUONLoader");
if (fMuonloader == NULL)
Bool_t AliMUONDataInterface::LoadLoaders(TString filename, TString foldername)
{
-// Load the run and muon loaders from the specified file and folder.
-// kTRUE is returned on success and kFALSE on failure.
+/// Load the run and muon loaders from the specified file and folder.
+/// kTRUE is returned on success and kFALSE on failure.
fRunloader = AliRunLoader::Open(filename, foldername, "READ");
if (fRunloader == NULL)
Bool_t AliMUONDataInterface::FetchLoaders(TString filename, TString foldername)
{
-// Fetch the run loader and muon loader objects from memory if they already exist,
-// or from memory if they do not.
-// If the currently loaded run loader (if any) is not refering to the file and folder
-// we are interested in then it is deleted and reopened with the required file and
-// folder names.
+/// Fetch the run loader and muon loader objects from memory if they already exist,
+/// or from memory if they do not.
+/// If the currently loaded run loader (if any) is not refering to the file and folder
+/// we are interested in then it is deleted and reopened with the required file and
+/// folder names.
if (fRunloader == NULL)
{
Bool_t AliMUONDataInterface::FetchEvent(Int_t event)
{
-// Fetch the specified event from the runloader and reset all the track, cathode
-// and address flags to force them to be reloaded.
-// If a negative event number is specified then the current runloader event
-// number is used.
+/// Fetch the specified event from the runloader and reset all the track, cathode
+/// and address flags to force them to be reloaded.
+/// If a negative event number is specified then the current runloader event
+/// number is used.
if (fEventnumber < 0)
{
Bool_t AliMUONDataInterface::FetchTreeK()
{
-// Fetch the Kine tree from the current run loader.
+/// Fetch the Kine tree from the current run loader.
if (fRunloader->TreeK() == NULL)
{
Bool_t AliMUONDataInterface::FetchTreeH()
{
-// Fetch the Hits tree from the current muon loader.
-// Set all the required addresses etc...
+/// Fetch the Hits tree from the current muon loader.
+/// Set all the required addresses etc...
if (fMuonloader->TreeH() == NULL)
{
Bool_t AliMUONDataInterface::FetchTreeS()
{
-// Fetch the S-Digits tree from the current muon loader.
-// Set all the required addresses etc...
+/// Fetch the S-Digits tree from the current muon loader.
+/// Set all the required addresses etc...
if (fMuonloader->TreeS() == NULL)
{
Bool_t AliMUONDataInterface::FetchTreeD()
{
-// Fetch the digits tree from the current muon loader.
-// Set all the required addresses etc...
+/// Fetch the digits tree from the current muon loader.
+/// Set all the required addresses etc...
if (fMuonloader->TreeD() == NULL)
{
Bool_t AliMUONDataInterface::FetchTreeR()
{
- // Fetch the reconstructed objects tree from the current muon loader.
- // Note: The addresses must still be set.
+/// Fetch the reconstructed objects tree from the current muon loader.
+/// Note: The addresses must still be set.
if (fMuonloader->TreeR() == NULL)
{
Bool_t AliMUONDataInterface::FetchTreeT()
{
- // fetch the reconstructed tracks tree from the current muon loader
- // note : the addresses must still be set.
+/// fetch the reconstructed tracks tree from the current muon loader
+/// note : the addresses must still be set.
if (fMuonloader->TreeT() == NULL)
{
fMuonloader->LoadTracks("READ");
Int_t AliMUONDataInterface::NumberOfEvents(TString filename, TString foldername)
{
-// Returns the number of events in the specified file/folder, and -1 on error.
+/// Returns the number of events in the specified file/folder, and -1 on error.
if ( ! FetchLoaders(filename, foldername) ) return -1;
return fRunloader->GetNumberOfEvents();
Int_t AliMUONDataInterface::NumberOfParticles(TString filename, TString foldername, Int_t event)
{
-// Returns the number of events in the specified file/folder, and -1 on error.
+/// Returns the number of events in the specified file/folder, and -1 on error.
if ( ! FetchLoaders(filename, foldername) ) return -1;
if ( ! FetchEvent(event) ) return -1;
TString filename, TString foldername, Int_t event, Int_t particle
)
{
-// Returns the specified particle in the given file, folder and event.
-// NULL is returned on error.
+/// Returns the specified particle in the given file, folder and event.
+/// NULL is returned on error.
if ( ! FetchLoaders(filename, foldername) ) return NULL;
if ( ! FetchEvent(event) ) return NULL;
Int_t AliMUONDataInterface::NumberOfTracks(TString filename, TString foldername, Int_t event)
{
-// Returns the number of tracks in the specified file/folder and event.
-// -1 is returned on error.
+/// Returns the number of tracks in the specified file/folder and event.
+/// -1 is returned on error.
if ( ! FetchLoaders(filename, foldername) ) return -1;
if ( ! FetchEvent(event) ) return -1;
TString filename, TString foldername, Int_t event, Int_t track
)
{
-// Returns the number of hits in the specified file/folder, event and track.
-// -1 is returned on error.
+/// Returns the number of hits in the specified file/folder, event and track.
+/// -1 is returned on error.
if ( ! FetchLoaders(filename, foldername) ) return -1;
if ( ! FetchEvent(event) ) return -1;
Int_t track, Int_t hit
)
{
-// Returns the specified hit in the given file, folder, event and track.
-// NULL is returned on error.
+/// Returns the specified hit in the given file, folder, event and track.
+/// NULL is returned on error.
if ( ! FetchLoaders(filename, foldername) ) return NULL;
if ( ! FetchEvent(event) ) return NULL;
Int_t chamber, Int_t cathode
)
{
-// Returns the number of s-digits in the given file, folder, event,
-// chamber and cathode. -1 is returned on error.
+/// Returns the number of s-digits in the given file, folder, event,
+/// chamber and cathode. -1 is returned on error.
Assert( 0 <= chamber && chamber <= 13 );
Assert( 0 <= cathode && cathode <= 1 );
Int_t chamber, Int_t cathode, Int_t sdigit
)
{
-// Returns the specified s-digit in the given file, folder, event,
-// chamber and cathode. NULL is returned on error.
+/// Returns the specified s-digit in the given file, folder, event,
+/// chamber and cathode. NULL is returned on error.
Assert( 0 <= chamber && chamber <= 13 );
Assert( 0 <= cathode && cathode <= 1 );
Int_t chamber, Int_t cathode
)
{
-// Returns the number of digits in the given file, folder, event,
-// chamber and cathode. -1 is returned on error.
+/// Returns the number of digits in the given file, folder, event,
+/// chamber and cathode. -1 is returned on error.
Assert( 0 <= chamber && chamber <= 13 );
Assert( 0 <= cathode && cathode <= 1 );
Int_t chamber, Int_t cathode, Int_t digit
)
{
-// Returns the specified digit in the given file, folder, event,
-// chamber and cathode. NULL is returned on error.
+/// Returns the specified digit in the given file, folder, event,
+/// chamber and cathode. NULL is returned on error.
Assert( 0 <= chamber && chamber <= 13 );
Assert( 0 <= cathode && cathode <= 1 );
TString filename, TString foldername, Int_t event, Int_t chamber
)
{
-// Returns the number of raw clusters in the specified file, folder, event and chamber.
-// -1 is returned or error.
+/// Returns the number of raw clusters in the specified file, folder, event and chamber.
+/// -1 is returned or error.
Assert( 0 <= chamber && chamber <= 13 );
if ( ! FetchLoaders(filename, foldername) ) return -1;
Int_t chamber, Int_t cluster
)
{
-// Fetch the specified raw cluster from the given file, folder, event and chamber number.
-// NULL is returned on error.
+/// Fetch the specified raw cluster from the given file, folder, event and chamber number.
+/// NULL is returned on error.
Assert( 0 <= chamber && chamber <= 13 );
if ( ! FetchLoaders(filename, foldername) ) return NULL;
Int_t AliMUONDataInterface::NumberOfLocalTriggers(TString filename, TString foldername, Int_t event)
{
-// Return the number of local trigger objects in the specified file, folder and
-// event number. -1 is returned on error.
+/// Return the number of local trigger objects in the specified file, folder and
+/// event number. -1 is returned on error.
if ( ! FetchLoaders(filename, foldername) ) return -1;
if ( ! FetchEvent(event) ) return -1;
TString filename, TString foldername, Int_t event, Int_t trigger
)
{
-// Fetch the specified local trigger object from the given file, folder and event number.
-// NULL is returned on error.
+/// Fetch the specified local trigger object from the given file, folder and event number.
+/// NULL is returned on error.
if ( ! FetchLoaders(filename, foldername) ) return NULL;
if ( ! FetchEvent(event) ) return NULL;
Bool_t AliMUONDataInterface::SetFile(TString filename, TString foldername)
{
-// Set the current file and folder from which to fetch data.
-// kTRUE is returned if the run and muon loaders were found, else kFALSE.
+/// Set the current file and folder from which to fetch data.
+/// kTRUE is returned if the run and muon loaders were found, else kFALSE.
return FetchLoaders(filename, foldername);
}
Bool_t AliMUONDataInterface::GetEvent(Int_t event)
{
-// Select the current event from which to fetch data.
-// kTRUE is returned if the event was found, else kFALSE is returned.
+/// Select the current event from which to fetch data.
+/// kTRUE is returned if the event was found, else kFALSE is returned.
if (fRunloader == NULL)
{
Int_t AliMUONDataInterface::NumberOfEvents()
{
-// Get the number of events in the currently selected file.
-// -1 is returned on error.
+/// Get the number of events in the currently selected file.
+/// -1 is returned on error.
if (fRunloader == NULL)
{
Int_t AliMUONDataInterface::NumberOfParticles()
{
-// Get the number of particles in the current event.
-// -1 is returned on error.
+/// Get the number of particles in the current event.
+/// -1 is returned on error.
if (fRunloader == NULL)
{
TParticle* AliMUONDataInterface::Particle(Int_t particle)
{
-// Fetch the specified particle from the current event.
-// NULL is returned on error.
+/// Fetch the specified particle from the current event.
+/// NULL is returned on error.
if (fRunloader == NULL)
{
Int_t AliMUONDataInterface::NumberOfTracks()
{
-// Get the number of tracks in the current event.
-// -1 is returned on error.
+/// Get the number of tracks in the current event.
+/// -1 is returned on error.
if (fRunloader == NULL)
{
Int_t AliMUONDataInterface::NumberOfHits(Int_t track)
{
-// Get the number of hits for the given track in the current event.
-// -1 is returned on error.
+/// Get the number of hits for the given track in the current event.
+/// -1 is returned on error.
if (fRunloader == NULL)
{
AliMUONHit* AliMUONDataInterface::Hit(Int_t track, Int_t hit)
{
-// Fetch the specified hit from the current event.
-// NULL is returned on error.
+/// Fetch the specified hit from the current event.
+/// NULL is returned on error.
if (fRunloader == NULL)
{
Int_t AliMUONDataInterface::NumberOfSDigits(Int_t chamber, Int_t cathode)
{
-// Get the number of s-digits on the chamber, cathode in the current event.
-// -1 is returned on error.
+/// Get the number of s-digits on the chamber, cathode in the current event.
+/// -1 is returned on error.
Assert( 0 <= chamber && chamber <= 13 );
Assert( 0 <= cathode && cathode <= 1 );
AliMUONDigit* AliMUONDataInterface::SDigit(Int_t chamber, Int_t cathode, Int_t sdigit)
{
-// Fetch the specified s-digits on the chamber, cathode from the current event.
-// NULL is returned on error.
+/// Fetch the specified s-digits on the chamber, cathode from the current event.
+/// NULL is returned on error.
Assert( 0 <= chamber && chamber <= 13 );
Assert( 0 <= cathode && cathode <= 1 );
Int_t AliMUONDataInterface::NumberOfDigits(Int_t chamber, Int_t cathode)
{
-// Get the number of digits on the chamber, cathode in the current event.
-// -1 is returned on error.
+/// Get the number of digits on the chamber, cathode in the current event.
+/// -1 is returned on error.
Assert( 0 <= chamber && chamber <= 13 );
Assert( 0 <= cathode && cathode <= 1 );
AliMUONDigit* AliMUONDataInterface::Digit(Int_t chamber, Int_t cathode, Int_t digit)
{
-// Fetch the specified digits on the chamber, cathode from the current event.
-// NULL is returned on error.
+/// Fetch the specified digits on the chamber, cathode from the current event.
+/// NULL is returned on error.
Assert( 0 <= chamber && chamber <= 13 );
Assert( 0 <= cathode && cathode <= 1 );
Int_t AliMUONDataInterface::NumberOfRawClusters(Int_t chamber)
{
-// Get the number of raw clusters on the given chamber in the current event.
-// -1 is returned on error.
+/// Get the number of raw clusters on the given chamber in the current event.
+/// -1 is returned on error.
Assert( 0 <= chamber && chamber <= 13 );
AliMUONRawCluster* AliMUONDataInterface::RawCluster(Int_t chamber, Int_t cluster)
{
-// Fetch the specified raw cluster on the given chamber from the current event.
-// NULL is returned on error.
+/// Fetch the specified raw cluster on the given chamber from the current event.
+/// NULL is returned on error.
Assert( 0 <= chamber && chamber <= 13 );
Int_t AliMUONDataInterface::NumberOfLocalTriggers()
{
-// Get the number of local trigger objects in the current event.
-// -1 is returned on error.
+/// Get the number of local trigger objects in the current event.
+/// -1 is returned on error.
if (fRunloader == NULL)
{
AliMUONLocalTrigger* AliMUONDataInterface::LocalTrigger(Int_t trigger)
{
-// Fetch the specified local trigger object from the current event.
-// NULL is returned on error.
+/// Fetch the specified local trigger object from the current event.
+/// NULL is returned on error.
if (fRunloader == NULL)
{
Int_t AliMUONDataInterface::NumberOfGlobalTriggers()
{
-
- // Get the number of local trigger objects in the current event.
- // -1 is returned on error.
+/// Get the number of local trigger objects in the current event.
+/// -1 is returned on error.
if (fRunloader == NULL)
{
AliMUONGlobalTrigger* AliMUONDataInterface::GlobalTrigger(Int_t trigger)
{
- // Fetch the specified local trigger object from the current event.
- // NULL is returned on error.
+/// Fetch the specified local trigger object from the current event.
+/// NULL is returned on error.
if (fRunloader == NULL)
{
Int_t AliMUONDataInterface::NumberOfRecTracks()
{
- // Fetch the number of reconstructed tracks from the current event.
- // NULL is returned on error.
+/// Fetch the number of reconstructed tracks from the current event.
+/// NULL is returned on error.
if (fRunloader == NULL)
{
AliMUONTrack* AliMUONDataInterface::RecTrack(Int_t rectrack)
{
- // Fetch the specified reconstructed track object from the current event.
- // NULL is returned on error.
+/// Fetch the specified reconstructed track object from the current event.
+/// NULL is returned on error.
if (fRunloader == NULL)
{
// Currently only implemented for digits, as a proof-of-principle.
//
+/// \cond CLASSIMP
+ClassImp(AliMUONDataIterator)
+/// \endcond
+
namespace
{
void GetChamberNumbers(AliMUONDataIterator::EIterationStyle type,
}
}
-ClassImp(AliMUONDataIterator)
-
//_____________________________________________________________________________
AliMUONDataIterator::AliMUONDataIterator()
:
#include "Riostream.h"
#include "TString.h"
-///
+/// \class AliMUONDigit
/// A class representing a digit in the MUON spectrometer
/// either in tracking or trigger chambers.
///
/// with no electronic noise whatsoever) or digits (either real digits or
/// simulated ones but including electronic noise and de-calibration, to
/// closely ressemble real ones).
-///
+/// \cond CLASSIMP
ClassImp(AliMUONDigit)
+/// \endcond
//_____________________________________________________________________________
AliMUONDigit::AliMUONDigit()
fPhysics(0),
fHit(0)
{
- //
- // Default constructor
- //
+ /// Default constructor
}
//_____________________________________________________________________________
fPhysics(0),
fHit(0)
{
- //
- // copy constructor
- //
+ /// Copy constructor
+
(static_cast<const AliMUONDigit&>(digit)).Copy(*this);
}
fHit(0)
{
- //
- // Creates a MUON digit object to be updated
- // \deprecated
- //
+ /// Creates a MUON digit object to be updated
+ /// \deprecated
+
fPadX = digits[0];
fPadY = digits[1];
fCathode = digits[2];
fPhysics(0),
fHit(0)
{
- //
- // Creates a MUON digit object
- //
- // \deprecated
+ /// Creates a MUON digit object
+ /// \deprecated
+
fPadX = digits[0];
fPadY = digits[1];
fCathode = digits[2];
//_____________________________________________________________________________
AliMUONDigit::~AliMUONDigit()
{
- //
- // Destructor
- //
+ /// Destructor
+
delete[] fTcharges;
delete[] fTracks;
}
void
AliMUONDigit::AddTrack(Int_t trackNumber, Int_t trackCharge)
{
- //
- // Add 1 track information to the track list we keep.
- // The implementation below is dumb, you've been warned !
- //
+ /// Add 1 track information to the track list we keep.
+ /// The implementation below is dumb, you've been warned !
// First check if track is already there, in which
// case we simply increment its charge.
void
AliMUONDigit::Clear(Option_t*)
{
- //
- // Reset this digit, in particular the internal arrays are deleted.
- //
+ /// Reset this digit, in particular the internal arrays are deleted.
+
delete[] fTracks;
delete[] fTcharges;
fTracks=0x0;
//_____________________________________________________________________________
Int_t AliMUONDigit::Compare(const TObject *obj) const
{
- //
- // The order defined below is first by DE, then Signal, then
- // manuId, and then manuChannel, i.e. it should be a total ordering...
- //
+ /// The order defined below is first by DE, then Signal, then
+ /// manuId, and then manuChannel, i.e. it should be a total ordering...
const AliMUONDigit* d = static_cast<const AliMUONDigit*>(obj);
void
AliMUONDigit::Copy(TObject& obj) const
{
- //
- // Copy this line to line.
- //
+ /// Copy this line to line.
+
TObject::Copy(obj);
AliMUONDigit& digit = static_cast<AliMUONDigit&>(obj);
Bool_t
AliMUONDigit::IsNoiseOnly() const
{
- // Whether this (simulated only) digit is only due to noise.
+ /// Whether this (simulated only) digit is only due to noise.
+
return (fFlags & fgkNoiseOnlyMask );
}
Bool_t
AliMUONDigit::IsSaturated() const
{
- // Whether this digit is saturated or not.
+ /// Whether this digit is saturated or not.
+
return (fFlags & fgkSaturatedMask );
}
void
AliMUONDigit::NoiseOnly(Bool_t value)
{
- //
- // Set the NoiseOnly status of this digit.
- //
+ /// Set the NoiseOnly status of this digit.
+
if ( value )
{
fFlags |= fgkNoiseOnlyMask;
AliMUONDigit&
AliMUONDigit::operator=(const AliMUONDigit& digit)
{
- //
- // Assignement operator.
- //
+ /// Assignement operator.
+
AliMUONDigit a(digit);
a.Copy(*this);
return *this;
void
AliMUONDigit::PatchTracks(Int_t mask)
{
- //
- // Add mask to each track number.
- //
+ /// Add mask to each track number.
+
for ( Int_t i = 0; i < Ntracks(); ++i )
{
fTracks[i] += mask;
void
AliMUONDigit::Print(Option_t* opt) const
{
- //
- // Dump to screen.
- // If opt=="tracks", info on tracks are printed too.
- //
+ /// Dump to screen.
+ /// If opt=="tracks", info on tracks are printed too.
+
cout << "<AliMUONDigit>: DetEle " << setw(5) << DetElemId()
<< " Cath " << setw(2) << Cathode()
<< " (Ix,Iy)=(" << setw(3) << PadX() << "," << setw(3) << PadY()
void
AliMUONDigit::Saturated(Bool_t value)
{
- //
- // Set the saturation status of this digit.
- //
+ /// Set the saturation status of this digit.
+
if ( value )
{
fFlags |= fgkSaturatedMask;
Int_t
AliMUONDigit::Track(Int_t i) const
{
- //
- // Return the i-th track number (if i is >=0 and < Ntracks()) or -1.
- //
+ /// Return the i-th track number (if i is >=0 and < Ntracks()) or -1.
+
if ( i >= 0 && i < fNtracks )
{
return fTracks[i];
Int_t
AliMUONDigit::TrackCharge(Int_t i) const
{
- //
- // Return the i-th track charge (if i is >=0 and < Ntracjs()) or -1.
- //
+ /// Return the i-th track charge (if i is >=0 and < Ntracjs()) or -1.
+
if ( i >= 0 && i < fNtracks )
{
return fTcharges[i];
public:
AliMUONDigit();
AliMUONDigit(const AliMUONDigit& rhs);
- /// \deprecated
+ // deprecated
AliMUONDigit(Int_t *digits);
- /// \deprecated
+ // deprecated
AliMUONDigit(Int_t *tracks, Int_t *charges, Int_t *digits);
virtual ~AliMUONDigit();
AliMUONDigit& operator=(const AliMUONDigit& rhs);
- virtual Bool_t IsSortable() const {return kTRUE;}
+ virtual Bool_t IsSortable() const {return kTRUE;} ///< Return true if sortable
virtual int Compare(const TObject *obj) const;
- virtual Int_t DetElemId()const {return fDetElemId;}
- virtual Int_t PadX() const {return fPadX;}
- virtual Int_t PadY() const {return fPadY;}
- virtual Int_t Cathode() const {return fCathode;}
+ virtual Int_t DetElemId()const {return fDetElemId;} ///< Return detection element ID
+ virtual Int_t PadX() const {return fPadX;} ///< Return pad number along x
+ virtual Int_t PadY() const {return fPadY;} ///< Return pad number along y
+ virtual Int_t Cathode() const {return fCathode;} ///< Return cathode number
- virtual Int_t Signal() const {return fSignal;}
+ virtual Int_t Signal() const {return fSignal;} ///< Return signal amplitude
- virtual Int_t Physics() const {return fPhysics;}
+ virtual Int_t Physics() const {return fPhysics;} ///< Return MC physics contribution to signal
- virtual Int_t Hit() const {return fHit;}
+ virtual Int_t Hit() const {return fHit;} ///< Return MC hit number
- virtual Int_t Ntracks() const { return fNtracks; }
+ virtual Int_t Ntracks() const { return fNtracks; } ///< Return MC tracks making to this digit
virtual void AddTrack(Int_t trackNumber, Int_t trackCharge);
virtual Int_t Track(Int_t i) const;
virtual Int_t TrackCharge(Int_t i) const;
- virtual Int_t ADC() const { return fADC; }
- virtual Int_t ManuId() const { return fManuId; }
- virtual Int_t ManuChannel() const { return fManuChannel; }
+ virtual Int_t ADC() const { return fADC; } ///< Return ADC value
+ virtual Int_t ManuId() const { return fManuId; } ///< Return Id of the MANU chip
+ virtual Int_t ManuChannel() const { return fManuChannel; } ///< Return Channel within the MANU chip
virtual Bool_t IsSaturated() const;
virtual Bool_t IsNoiseOnly() const;
virtual void Saturated(Bool_t saturated=kTRUE);
virtual void SetElectronics(Int_t manuId, Int_t manuChannel);
virtual void SetADC(Int_t adc) { fADC=adc; }
- virtual void SetDetElemId(Int_t id) {fDetElemId = id;}
- virtual void SetPadX(Int_t pad) {fPadX = pad;}
- virtual void SetPadY(Int_t pad) {fPadY = pad;}
- virtual void SetSignal(Int_t q) {fSignal = q;}
- virtual void AddSignal(Int_t q) {fSignal += q;}
- virtual void AddPhysicsSignal(Int_t q) {fPhysics += q;}
- virtual void SetHit(Int_t n) {fHit = n;}
- virtual void SetCathode(Int_t c) {fCathode = c;}
- virtual void SetPhysicsSignal(Int_t q) {fPhysics = q; }
+ virtual void SetDetElemId(Int_t id) {fDetElemId = id;} ///< Set detection element ID
+ virtual void SetPadX(Int_t pad) {fPadX = pad;} ///< Set pad number along x
+ virtual void SetPadY(Int_t pad) {fPadY = pad;} ///< Set pad number along y
+ virtual void SetSignal(Int_t q) {fSignal = q;} ///< Set signal amplitude
+ virtual void AddSignal(Int_t q) {fSignal += q;} ///< Add signal amplitude
+ virtual void AddPhysicsSignal(Int_t q) {fPhysics += q;} ///< Add MC physics contribution to signal
+ virtual void SetHit(Int_t n) {fHit = n;} ///< Set MC hit number
+ virtual void SetCathode(Int_t c) {fCathode = c;} ///< Set cathode number
+ virtual void SetPhysicsSignal(Int_t q) {fPhysics = q; } ///< Set MC physics contribution to signal
virtual void Print(Option_t* opt="") const;
*/
virtual void Clear(Option_t*);
- /// Add mask to the track numbers.
+ // Add mask to the track numbers.
virtual void PatchTracks(Int_t mask);
private:
/* $Id$ */
-//////////////////////////////////////////////////////////////////////////
-// //
-// AliDisplay //
-// //
-// Utility class to display ALICE outline, tracks, hits,.. //
-// //
-//////////////////////////////////////////////////////////////////////////
+/// \class AliMUONDisplay
+/// Create an event display object.
+/// A canvas named "edisplay" is created with a vertical size in pixels \n
+///
+/// A QUICK Overview of the Event Display functions \n
+/// =============================================== \n
+///
+/// The event display can ve invoked by executing the macro "display.C" \n
+/// A canvas like in the picture below will appear.
+///
+/// On the left side of the canvas, the following buttons appear:
+/// - *Next* to move to the next event
+/// - *Previous* to move to the previous event
+/// - *Pick* Select this option to be able to point on a track with the
+/// mouse. Once on the track, use the right button to select
+/// an action. For example, select SetMarkerAttributes to
+/// change the marker type/color/size for the track.
+/// - *Zoom* Select this option (default) if you want to zoom.
+/// To zoom, simply select the selected area with the left button.
+/// - *UnZoom* To revert to the previous picture size.
+///
+/// - slider R On the left side, the vertical slider can be used to
+/// set the default picture size.
+///
+/// When you are in Zoom mode, you can click on the black part of the canvas
+/// to select special options with the right mouse button.
+///
+/// When you are in pick mode, you can "Inspect" the object pointed by the mouse.
+/// When you are on a track, select the menu item "InspectParticle"
+/// to display the current particle attributes.
+///
+/// You can activate the Root browser by selecting the Inspect menu
+/// in the canvas tool bar menu. Then select "Start Browser"
+/// This will open a new canvas with the browser. At this point, you may want
+/// to display some histograms (from the Trees). Go to the "File" menu
+/// of the browser and click on "New canvas".
+/// In the browser, click on item "ROOT files" in the left pane.
+/// Click on galice.root.
+/// Click on TH
+/// Click on TPC for example
+/// Click on any variable (eg TPC.fX) to histogram the variable.
+///
+/// If you are lost, you can click on HELP in any Root canvas or browser.
+
+//Begin_Html
+/*
+<img src="gif/AliMUONDisplay.gif">
+*/
+//End_Html
#include "AliMUONDisplay.h"
#include "AliMUON.h"
#include <TPolyLine3D.h>
#include <TBox.h>
-
-
+/// \cond CLASSIMP
ClassImp(AliMUONDisplay)
-
+/// \endcond
//_____________________________________________________________________________
AliMUONDisplay::AliMUONDisplay()
- : AliDisplay()
+ : AliDisplay(),
+ fEvent(0),
+ fChamber(0),
+ fCathode(0),
+ fDrawClusters(kTRUE),
+ fDrawCoG(kTRUE),
+ fDrawTracks(kFALSE),
+ fClustersCuts(0),
+ fColPad(0),
+ fPoints(0),
+ fPhits(0),
+ fRpoints(0),
+ fNextCathode(0),
+ fLoader(0),
+ fMUONData(0)
{
-// Constructor
- fPoints = 0;
- fPhits = 0;
- fRpoints = 0;
- fCanvas = 0;
- fNextCathode = kFALSE;
- fColPad = 0;
+/// Default constructor
}
//_____________________________________________________________________________
AliMUONDisplay::AliMUONDisplay(Int_t size, AliLoader * loader)
- : AliDisplay()
+ : AliDisplay(),
+ fEvent(0),
+ fChamber(1),
+ fCathode(1),
+ fDrawClusters(kTRUE),
+ fDrawCoG(kTRUE),
+ fDrawTracks(kFALSE),
+ fClustersCuts(0),
+ fColPad(0),
+ fPoints(0),
+ fPhits(0),
+ fRpoints(0),
+ fNextCathode(kFALSE),
+ fLoader(loader),
+ fMUONData(0)
+
{
-// Create an event display object.
-// A canvas named "edisplay" is created with a vertical size in pixels
-//
-// A QUICK Overview of the Event Display functions
-// ===============================================
-//
-// The event display can ve invoked by executing the macro "display.C"
-// A canvas like in the picture below will appear.
-//
-// On the left side of the canvas, the following buttons appear:
-// *Next* to move to the next event
-// *Previous* to move to the previous event
-
-// *Pick* Select this option to be able to point on a track with the
-// mouse. Once on the track, use the right button to select
-// an action. For example, select SetMarkerAttributes to
-// change the marker type/color/size for the track.
-// *Zoom* Select this option (default) if you want to zoom.
-// To zoom, simply select the selected area with the left button.
-// *UnZoom* To revert to the previous picture size.
-//
-// slider R On the left side, the vertical slider can be used to
-// set the default picture size.
-//
-// When you are in Zoom mode, you can click on the black part of the canvas
-// to select special options with the right mouse button.
-
-//
-// When you are in pick mode, you can "Inspect" the object pointed by the mouse.
-// When you are on a track, select the menu item "InspectParticle"
-// to display the current particle attributes.
-//
-// You can activate the Root browser by selecting the Inspect menu
-// in the canvas tool bar menu. Then select "Start Browser"
-// This will open a new canvas with the browser. At this point, you may want
-// to display some histograms (from the Trees). Go to the "File" menu
-// of the browser and click on "New canvas".
-// In the browser, click on item "ROOT files" in the left pane.
-// Click on galice.root.
-// Click on TH
-// Click on TPC for example
-// Click on any variable (eg TPC.fX) to histogram the variable.
-//
-// If you are lost, you can click on HELP in any Root canvas or browser.
-//Begin_Html
-/*
-<img src="gif/AliMUONDisplay.gif">
-*/
-//End_Html
-
+/// Standard constructor to create an event display object.
fPad = 0;
// Initialize display default parameters
SetRange(200,2000);
+
// Set front view by default
fTheta = 0;
fPhi = -90;
fPsi = 0;
- fChamber = 1;
- fCathode = 1;
- // fRzone = 1.e10;
- fDrawClusters = kTRUE;
- fDrawCoG = kTRUE;
- fDrawTracks = kFALSE;
fZoomMode = 1;
fZooms = 0;
- fClustersCuts = 0;
- fPoints = 0;
- fPhits = 0;
- fRpoints = 0;
+
// Create colors
CreateColors();
// Create display canvas
fTrigPad->SetEditable(kFALSE);
fButtons->SetEditable(kFALSE);
fCanvas->Update();
- fNextCathode = kFALSE;
- fLoader = loader;
+
// initialize container
if(fLoader)
fMUONData = new AliMUONData(fLoader,"MUON","MUON");
fMUONData =0x0;
}
-AliMUONDisplay::AliMUONDisplay(const AliMUONDisplay & display)
- : AliDisplay(display)
-{
-// Protected copy constructor
-
- AliFatal("Not implemented.");
-}
-
-
-
//_____________________________________________________________________________
AliMUONDisplay::~AliMUONDisplay()
{
+/// Destructor
+
// Delete space point structure
if (fPoints) fPoints->Delete();
delete fPoints;
//_____________________________________________________________________________
void AliMUONDisplay::Clear(Option_t *)
{
-// Delete graphics temporary objects
+/// Delete graphics temporary objects
}
//_____________________________________________________________________________
void AliMUONDisplay::DisplayButtons()
{
-// Create the user interface buttons
+/// Create the user interface buttons
fButtons = new TPad("buttons", "newpad",0,0.45,0.15,1);
//_____________________________________________________________________________
void AliMUONDisplay::CreateColors() const
{
-// Create the colors palette used to display clusters
+/// Create the colors palette used to display clusters
Int_t k,i;
Int_t color;
//_____________________________________________________________________________
void AliMUONDisplay::DisplayColorScale()
{
-// Display pulse height color scale
+/// Display pulse height color scale
+
Int_t i;
Int_t color;
Float_t xlow, ylow, xup, yup, hs;
//______________________________________________________________________________
Int_t AliMUONDisplay::DistancetoPrimitive(Int_t px, Int_t)
{
-// Compute distance from point px,py to objects in event
+/// Compute distance from point px,py to objects in event
gPad->SetCursor(kCross);
//_____________________________________________________________________________
void AliMUONDisplay::Draw(Option_t *)
{
-// Display current event
+/// Display current event
if (!fDrawTracks)
DrawChamber();
//_____________________________________________________________________________
void AliMUONDisplay::DrawChamber()
{
+/// Display current event
fDrawTracks = kFALSE;
fPad->cd();
//_____________________________________________________________________________
void AliMUONDisplay::DrawReco(Option_t *)
{
-// Display current event
+/// Display current event
fDrawTracks = kTRUE;
// print kinematics of generated particles
//_____________________________________________________________________________
void AliMUONDisplay::PrintKinematics()
{
+/// Print kinematic tree
+
AliRunLoader * runLoader;
TParticle *particle = new TParticle();
Int_t nPart;
delete particle;
}
+//_____________________________________________________________________________
void AliMUONDisplay::DrawSegmentation()
{
- // to be re-written for new seg
-// Draw graphical representation of segmenatation
-// Attention: still experimental code
+/// \todo to be re-written for new seg
+/// Draw graphical representation of segmenatation
+/// Attention: still experimental code
// Int_t icat=1;
// AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
//_____________________________________________________________________________
void AliMUONDisplay::DrawClusters()
{
-// Draw clusters for MUON chambers
+/// Draw clusters for MUON chambers
Int_t ndigits, digit;
TObjArray *points;
//_____________________________________________________________________________
void AliMUONDisplay::DrawHits()
{
-// Draw hits for MUON chambers
+/// Draw hits for MUON chambers
LoadHits(fChamber);
//_____________________________________________________________________________
void AliMUONDisplay::DrawCoG()
{
-// Draw hits for MUON chambers
+/// Draw hits for MUON chambers
+
if (!fDrawCoG) return;
if (fChamber > 10) return;
LoadCoG(fChamber,fCathode);
//_____________________________________________________________________________
void AliMUONDisplay::DrawTracks()
{
-// Draw tracks
+/// Draw tracks
+
if (!fDrawTracks) return;
LoadTracks();
void AliMUONDisplay::DrawTitle(Option_t *option)
{
-// Draw the event title
+/// Draw the event title
Float_t xmin = gPad->GetX1();
Float_t xmax = gPad->GetX2();
//_____________________________________________________________________________
void AliMUONDisplay::DrawView(Float_t theta, Float_t phi, Float_t psi)
{
- // Draw a view of MUON clusters
+/// Draw a view of MUON clusters
+
AliInfo(" Draw View");
gPad->SetCursor(kWatch);
//_____________________________________________________________________________
void AliMUONDisplay::DrawGlobalView(Float_t theta, Float_t phi, Float_t psi)
{
-// Draw a view of muons chambers with tracks
+/// Draw a view of muons chambers with tracks
gPad->SetCursor(kWatch);
// gPad->SetFillColor(39);
//______________________________________________________________________________
void AliMUONDisplay::ExecuteEvent(Int_t event, Int_t px, Int_t py)
{
-// Execute action corresponding to the mouse event
+/// Execute action corresponding to the mouse event
static Float_t x0, y0, x1, y1;
//___________________________________________
void AliMUONDisplay::LoadDigits(Int_t chamber, Int_t cathode)
{
-// Read digits info and store x,y,z info in arrays fPoints
-// Loop on all detectors
+/// Read digits info and store x,y,z info in arrays fPoints.
+/// Loop on all detectors
if (chamber > 14) return;
fChamber = chamber;
//___________________________________________
void AliMUONDisplay::LoadCoG(Int_t chamber, Int_t /*cathode*/)
{
-// Read raw clusters info and store x,y,z info in arrays fRpoints
-// Loop on all detectors
+/// Read raw clusters info and store x,y,z info in arrays fRpoints.
+/// Loop on all detectors
if (chamber > 10) return;
//___________________________________________
void AliMUONDisplay::LoadTracks()
{
-// Load tracks
+/// Load tracks
+
AliMUONTrack* recTrack = 0;
AliMUONTrackParam* trackParam = 0;
TClonesArray * trackParamAtHit = 0;
}
+//___________________________________________
void AliMUONDisplay::PrintTrack(Int_t iRecTracks, AliMUONTrack *recTrack)
{
+/// Print reconstructed track
+
AliMUONTrackParam *trackParam;
Float_t vertex[3], momentum[3];
Float_t pYZ, bendingSlope, nonBendingSlope, chi2dof;
//___________________________________________
void AliMUONDisplay::LoadHits(Int_t chamber)
{
- // Read hits info and store x,y,z info in arrays fPhits
- // Loop on all detectors
+/// Read hits info and store x,y,z info in arrays fPhits.
+/// Loop on all detectors
if (chamber > 14) return;
Int_t track;
//_____________________________________________________________________________
void AliMUONDisplay::Paint(Option_t *)
{
-// Paint miscellaneous items
+/// Paint miscellaneous items
}
//_____________________________________________________________________________
void AliMUONDisplay::SetPickMode()
{
-// Set parameters for pick mode.
-//
+/// Set parameters for pick mode.
+
fZoomMode = 0;
fArcButton->SetY1(fPickButton->GetYlowNDC()+0.5*fPickButton->GetHNDC());
//_____________________________________________________________________________
void AliMUONDisplay::SetZoomMode()
{
-// Set parameters for zoom mode
+/// Set parameters for zoom mode
+
fZoomMode = 1;
fArcButton->SetY1(fZoomButton->GetYlowNDC()+0.5*fZoomButton->GetHNDC());
//_____________________________________________________________________________
void AliMUONDisplay::NextChamber(Int_t delta)
{
- // to go from chamber to next chamber if delta = 1
- // or previous chamber otherwise
+/// To go from chamber to next chamber if delta = 1
+/// or previous chamber otherwise
if (delta == 1) {
if (fChamber < AliMUONConstants::NCh()) fChamber++;
} else {
//_____________________________________________________________________________
void AliMUONDisplay::NextCathode()
{
- // to switch to other cathode plane
+/// To switch to other cathode plane
+
if (!fPad) return;
fPad->Clear();
if (fCathode == 1) {
//_____________________________________________________________________________
void AliMUONDisplay::Trigger()
{
+/// Print global trigger output
AliMUONGlobalTrigger* globalTrig;
//_____________________________________________________________________________
void AliMUONDisplay::SetChamberAndCathode(Int_t chamber, Int_t cathode)
{
-// Set chamber and cathode number
+/// Set chamber and cathode number
+
fChamber = chamber;
fCathode = cathode;
DrawChamber();
}
+//_____________________________________________________________________________
void AliMUONDisplay::SetEvent(Int_t newevent)
{
-// Chose event
+/// Chose event
+
gAlice->GetEvent(newevent);
fEvent=newevent;
if (!gAlice->TreeD()) return;
//_____________________________________________________________________________
void AliMUONDisplay::SetRange(Float_t rrange, Float_t zrange)
{
-// Set view range along R and Z
+/// Set view range along R and Z
+
fRrange = rrange;
fZrange = zrange;
//_____________________________________________________________________________
void AliMUONDisplay::SetView(Float_t theta, Float_t phi, Float_t psi)
{
-// change viewing angles for current event
+/// Change viewing angles for current event
fPad->cd();
fPhi = phi;
//_____________________________________________________________________________
void AliMUONDisplay::ShowNextEvent(Int_t delta)
{
+/// Display (current event_number + delta)
+/// - delta = 1 shown next event
+/// - delta = -1 show previous event
+
AliRunLoader * runLoader;
if (fLoader)
runLoader = fLoader->GetRunLoader();
else
runLoader = 0x0;
-// Display (current event_number + delta)
-// delta = 1 shown next event
-// delta = -1 show previous event
if (delta) {
//runLoader->CleanDetectors();
//runLoader->CleanKinematics();
//______________________________________________________________________________
void AliMUONDisplay::UnZoom()
{
-// Unzoom
+/// Unzoom
+
if (fZooms <= 0) return;
fZooms--;
TPad *pad = (TPad*)gPad->GetPadSave();
//_____________________________________________________________________________
void AliMUONDisplay::ResetPoints()
{
- //
- // Reset array of points
- //
+/// Reset array of points
+
if (fPoints) {
fPoints->Delete();
delete fPoints;
//_____________________________________________________________________________
void AliMUONDisplay::ResetPhits()
{
- //
- // Reset array of points
- //
+/// Reset array of points
+
if (fPhits) {
fPhits->Delete();
delete fPhits;
//_____________________________________________________________________________
void AliMUONDisplay::ResetRpoints()
{
- //
- // Reset array of points
- //
+/// Reset array of points
+
if (fRpoints) {
fRpoints->Clear();
// delete fRpoints;
fRpoints = 0;
}
}
-
-AliMUONDisplay & AliMUONDisplay::operator = (const AliMUONDisplay & rhs)
-{
-// Protected assignement operator
-
- if (this == &rhs) return *this;
-
- AliFatal("Not implemented.");
-
- return *this;
-}
-
-
-
-
-
-
-
-
-
/// \class AliMUONDisplay
/// \brief Utility class to display MUON events
-//////////////////////////////////////////////////////////////////////////
-// //
-// AliDisplay //
-// //
-// Utility class to display ALice outline, tracks, hits,.. //
-// //
-//////////////////////////////////////////////////////////////////////////
-
#include "AliDisplay.h"
class AliLoader;
virtual void DrawTitle(Option_t *option="");
virtual void DrawView(Float_t theta, Float_t phi, Float_t psi=0);
virtual void DrawGlobalView(Float_t theta, Float_t phi, Float_t psi=0);
+ /// Not implemented function
virtual void DrawP(Float_t,Float_t,Float_t,Float_t,Float_t,Int_t){}
virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
- Int_t GetZoomMode() const {return fZoomMode;}
- Int_t GetChamber() const {return fChamber;}
- Int_t GetCathode() const {return fCathode;}
+ Int_t GetZoomMode() const {return fZoomMode;} ///< Return zoom mode
+ Int_t GetChamber() const {return fChamber;} ///< Return current chamber
+ Int_t GetCathode() const {return fCathode;} ///< Return current cathode
- AliMUONData* GetMUONData() {return fMUONData;}
- AliLoader* GetLoader() {return fLoader;}
+ AliMUONData* GetMUONData() {return fMUONData;} ///< Return MUON data
+ AliLoader* GetLoader() {return fLoader;} ///< Return loader
virtual void LoadDigits(Int_t chamber, Int_t cathode);
virtual void LoadHits(Int_t chamber);
virtual void LoadCoG(Int_t chamber, Int_t cathode);
virtual void LoadTracks();
- TPad *Pad() {return fPad;}
- TObjArray *Points() {return fPoints;}
- TObjArray *Phits() {return fPhits;}
- TObjArray *Rpoints() {return fRpoints;}
+ TPad *Pad() {return fPad;} ///< Return pad
+ TObjArray *Points() {return fPoints;} ///< Return points for each cathode
+ TObjArray *Phits() {return fPhits;} ///< Return hit points for each chamber
+ TObjArray *Rpoints() {return fRpoints;} ///< Return cog points for each cathode
virtual void Paint(Option_t *option="");
virtual void SetDrawClusters(Bool_t draw=kTRUE) {fDrawClusters=draw;} // *MENU*
virtual void SetChamberAndCathode(Int_t chamber=1, Int_t cathode=1); // *MENU*
#include "AliLog.h"
#include "AliMUONLocalStruct.h"
+/// \class AliMUONGlobalTrigger
+/// Global Trigger algorithm data output.
+/// Built from Local and Regional algorithms. \n
+/// Update for copy & assigment operator,
+/// add SetGlobalPattern and GetGlobalPattern method for rawdata
+/// (Ch. Finck)
+/// \author Ph. Crochet
+
+/// \cond CLASSIMP
ClassImp(AliMUONGlobalTrigger)
-
-/// ------------------
-/// Class AliMUONGlobalTrigger
-/// ------------------
-// Global Trigger algorithm data output
-// built from Local and Regional algorithms
-/// Ph. Crochet
-///
-/// update for copy & assigment operator
-/// add SetGlobalPattern and GetGlobalPattern method for rawdata
-/// Ch. Finck
-
+/// \endcond
//----------------------------------------------------------------------
AliMUONGlobalTrigger::AliMUONGlobalTrigger()
fPairLikeHpt(0),
fPairLikeApt(0)
{
- //
- // constructor
- //
+ /// Default constructor
}
+
//----------------------------------------------------------------------
AliMUONGlobalTrigger::AliMUONGlobalTrigger(const AliMUONGlobalTrigger& theMUONGlobalTrig)
- : TObject(theMUONGlobalTrig)
-{
- //
- // copy constructor
- //
- fSinglePlusLpt = theMUONGlobalTrig.fSinglePlusLpt;
- fSinglePlusHpt = theMUONGlobalTrig.fSinglePlusHpt;
- fSinglePlusApt = theMUONGlobalTrig.fSinglePlusApt;
-
- fSingleMinusLpt = theMUONGlobalTrig.fSingleMinusLpt;
- fSingleMinusHpt = theMUONGlobalTrig.fSingleMinusHpt;
- fSingleMinusApt = theMUONGlobalTrig.fSingleMinusApt;
-
- fSingleUndefLpt = theMUONGlobalTrig.fSingleUndefLpt;
- fSingleUndefHpt = theMUONGlobalTrig.fSingleUndefHpt;
- fSingleUndefApt = theMUONGlobalTrig.fSingleUndefApt;
-
- fPairUnlikeLpt = theMUONGlobalTrig.fPairUnlikeLpt;
- fPairUnlikeHpt = theMUONGlobalTrig.fPairUnlikeHpt;
- fPairUnlikeApt = theMUONGlobalTrig.fPairUnlikeApt;
+ : TObject(theMUONGlobalTrig),
- fPairLikeLpt = theMUONGlobalTrig.fPairLikeLpt;
- fPairLikeHpt = theMUONGlobalTrig.fPairLikeHpt;
- fPairLikeApt = theMUONGlobalTrig.fPairLikeApt;
+ fSinglePlusLpt(theMUONGlobalTrig.fSinglePlusLpt),
+ fSinglePlusHpt(theMUONGlobalTrig.fSinglePlusHpt),
+ fSinglePlusApt(theMUONGlobalTrig.fSinglePlusApt),
+
+ fSingleMinusLpt(theMUONGlobalTrig.fSingleMinusLpt),
+ fSingleMinusHpt(theMUONGlobalTrig.fSingleMinusHpt),
+ fSingleMinusApt(theMUONGlobalTrig.fSingleMinusApt),
+
+ fSingleUndefLpt(theMUONGlobalTrig.fSingleUndefLpt),
+ fSingleUndefHpt(theMUONGlobalTrig.fSingleUndefHpt),
+ fSingleUndefApt(theMUONGlobalTrig.fSingleUndefApt),
+
+ fPairUnlikeLpt(theMUONGlobalTrig.fPairUnlikeLpt),
+ fPairUnlikeHpt(theMUONGlobalTrig.fPairUnlikeHpt),
+ fPairUnlikeApt(theMUONGlobalTrig.fPairUnlikeApt),
+
+ fPairLikeLpt(theMUONGlobalTrig.fPairLikeLpt),
+ fPairLikeHpt(theMUONGlobalTrig.fPairLikeHpt),
+ fPairLikeApt(theMUONGlobalTrig.fPairLikeApt)
+{
+ /// Copy constructor
+}
+
+//----------------------------------------------------------------------
+AliMUONGlobalTrigger::~AliMUONGlobalTrigger()
+{
+ /// Destructor
}
//----------------------------------------------------------------------
AliMUONGlobalTrigger& AliMUONGlobalTrigger::operator=(const AliMUONGlobalTrigger& theMUONGlobalTrig)
{
- // assignement operator
- //
- // equal operator (useful for non-pointer member in TClonesArray)
+ /// Assignement operator;
+ /// equal operator (useful for non-pointer member in TClonesArray)
if (this == &theMUONGlobalTrig)
return *this;
Int_t *singleMinus,
Int_t *singleUndef,
Int_t *pairUnlike, Int_t *pairLike)
-{
- //
- // Set the Global Trigger object
- //
- fSinglePlusLpt = singlePlus[0];
- fSinglePlusHpt = singlePlus[1];
- fSinglePlusApt = singlePlus[2];
+ : TObject(),
+
+ fSinglePlusLpt(singlePlus[0]),
+ fSinglePlusHpt(singlePlus[1]),
+ fSinglePlusApt(singlePlus[2]),
- fSingleMinusLpt = singleMinus[0];
- fSingleMinusHpt = singleMinus[1];
- fSingleMinusApt = singleMinus[2];
+ fSingleMinusLpt(singleMinus[0]),
+ fSingleMinusHpt(singleMinus[1]),
+ fSingleMinusApt(singleMinus[2]),
- fSingleUndefLpt = singleUndef[0];
- fSingleUndefHpt = singleUndef[1];
- fSingleUndefApt = singleUndef[2];
+ fSingleUndefLpt(singleUndef[0]),
+ fSingleUndefHpt(singleUndef[1]),
+ fSingleUndefApt(singleUndef[2]),
- fPairUnlikeLpt = pairUnlike[0];
- fPairUnlikeHpt = pairUnlike[1];
- fPairUnlikeApt = pairUnlike[2];
+ fPairUnlikeLpt(pairUnlike[0]),
+ fPairUnlikeHpt(pairUnlike[1]),
+ fPairUnlikeApt(pairUnlike[2]),
- fPairLikeLpt = pairLike[0];
- fPairLikeHpt = pairLike[1];
- fPairLikeApt = pairLike[2];
+ fPairLikeLpt(pairLike[0]),
+ fPairLikeHpt(pairLike[1]),
+ fPairLikeApt(pairLike[2])
+
+{
+ /// Set the Global Trigger object
}
//-----------------------------------------------------------
void AliMUONGlobalTrigger:: SetGlobalPattern(Int_t gloTrigPat)
{
- //
- // set class member from global pattern
- // coming from rawdata
- //
+ /// Set class member from global pattern
+ /// coming from rawdata
+
fSinglePlusLpt = (gloTrigPat ) & 0x1;
fSinglePlusHpt = (gloTrigPat >> 1) & 0x1;
fSinglePlusApt = (gloTrigPat >> 2) & 0x1;
//-----------------------------------------------------------
Int_t AliMUONGlobalTrigger::GetGlobalPattern() const
{
+ /// Global trigger pattern calculation
+ /// from class member values
- //
- // global trigger pattern calculation
- // from class member values
- //
Int_t gloTrigPat = 0;
if (SinglePlusLpt()) gloTrigPat|= 0x1;
/// \ingroup base
/// \class AliMUONGlobalTrigger
-/// \brief global trigger object
-/// \author Ph. Crochet
+/// \brief Global trigger object
+// Author Ph. Crochet
#include <TObject.h>
AliMUONGlobalTrigger(const AliMUONGlobalTrigger& rhs); // copy constructor
AliMUONGlobalTrigger(Int_t *singlePlus, Int_t *singleMinus,
Int_t *singleUndef, Int_t *pairUnlike, Int_t *pairLike);
- virtual ~AliMUONGlobalTrigger(){;}
+ virtual ~AliMUONGlobalTrigger();
AliMUONGlobalTrigger& operator=(const AliMUONGlobalTrigger& rhs);
-
+
+ /// Return number of Single Plus Low pt
Int_t SinglePlusLpt() const {return fSinglePlusLpt;}
+ /// Return number of Single Plus High pt
Int_t SinglePlusHpt() const {return fSinglePlusHpt ;}
+ /// Return number of Single Plus All pt
Int_t SinglePlusApt() const {return fSinglePlusApt ;}
+ /// Return number of Single Minus Low pt
Int_t SingleMinusLpt() const {return fSingleMinusLpt ;}
+ /// Return number of Single Minus High pt
Int_t SingleMinusHpt() const {return fSingleMinusHpt;}
+ /// Return number of Single Minus All pt
Int_t SingleMinusApt() const {return fSingleMinusApt;}
+ /// Return number of Single Undefined Low pt
Int_t SingleUndefLpt() const {return fSingleUndefLpt ;}
+ /// Return number of Single Undefined High pt
Int_t SingleUndefHpt() const {return fSingleUndefHpt ;}
+ /// Return number of Single Undefined All pt
Int_t SingleUndefApt() const {return fSingleUndefApt ;}
+ /// Return number of Unlike sign pair Low pt
Int_t PairUnlikeLpt() const {return fPairUnlikeLpt ;}
+ /// Return number of Unlike sign pair High pt
Int_t PairUnlikeHpt() const {return fPairUnlikeHpt ;}
+ /// Return number of Unlike sign pair All pt
Int_t PairUnlikeApt() const {return fPairUnlikeApt ;}
+ /// Return number of Like sign pair Low pt
Int_t PairLikeLpt() const {return fPairLikeLpt ;}
+ /// Return number of Like sign pair High pt
Int_t PairLikeHpt() const {return fPairLikeHpt ;}
+ /// Return number of Like sign pair All pt
Int_t PairLikeApt() const {return fPairLikeApt ;}
void SetGlobalPattern(Int_t globalPattern);
/* $Id$ */
-// MUON classe for MonteCarlo Hits, inherited from AliHit for the
+// MUON class for MonteCarlo Hits, inherited from AliHit for the
// In addition to the ALiHit data member fX, fY, fZ and fTrack, AliMUONHit contains some info about the particle crossing the chamber:
// Impulsion: fPtot, fPx, fPy and fPz
// Reference position at the center of the chamber (wire plane) fXref, fYref and fZref
#include "AliMUONGeometryStore.h"
+/// \cond CLASSIMP
ClassImp(AliMUONHit)
+/// \endcond
//___________________________________________
AliMUONHit::AliMUONHit()
- : AliHit()
+ : AliHit(),
+ fIsDetElemId(kTRUE),
+ fDetElemId(0),
+ fParticle(0),
+ fTheta(0),
+ fPhi(0),
+ fTlength(0),
+ fEloss(0),
+ fAge(0),
+ fPHfirst(0),
+ fPHlast(0),
+ fPTot(0),
+ fPx(0),
+ fPy(0),
+ fPz(0),
+ fXref(0),
+ fYref(0),
+ fZref(0)
{
-// Default constructor
+/// Default constructor
}
//___________________________________________
-AliMUONHit::AliMUONHit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
- AliHit(shunt, track)
+AliMUONHit::AliMUONHit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits)
+ : AliHit(shunt, track),
+ fIsDetElemId(kFALSE),
+ fDetElemId(vol[0]),
+ fParticle(hits[0]),
+ fTheta(hits[4]),
+ fPhi(hits[5]),
+ fTlength(hits[6]),
+ fEloss(hits[7]),
+ fAge(hits[14]),
+ fPHfirst((Int_t)hits[8]),
+ fPHlast((Int_t)hits[9]),
+ fPTot(hits[10]),
+ fPx(hits[11]),
+ fPy(hits[12]),
+ fPz(hits[13]),
+ fXref(0),
+ fYref(0),
+ fZref(0)
{
-// Constructor
-// TBR
-
- fIsDetElemId = kFALSE;
- fDetElemId = vol[0];
- fParticle = hits[0];
+/// Constructor
+/// \deprecated TBR
+
fX = hits[1];
fY = hits[2];
fZ = hits[3];
- fTheta = hits[4];
- fPhi = hits[5];
- fTlength = hits[6];
- fEloss = hits[7];
- fPHfirst = (Int_t) hits[8];
- fPHlast = (Int_t) hits[9];
- fPTot = hits[10];
- fPx = hits[11];
- fPy = hits[12];
- fPz = hits[13];
- fAge = hits[14];
- fXref = 0.;
- fYref = 0.;
- fZref = 0.;
}
//___________________________________________
AliMUONHit::AliMUONHit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits,
- Bool_t /*isDetElemId*/) :
- AliHit(shunt, track)
+ Bool_t /*isDetElemId*/)
+ : AliHit(shunt, track),
+ fIsDetElemId(kTRUE),
+ fDetElemId(vol[0]),
+ fParticle(hits[0]),
+ fTheta(hits[4]),
+ fPhi(hits[5]),
+ fTlength(hits[6]),
+ fEloss(hits[7]),
+ fAge(hits[14]),
+ fPHfirst((Int_t)hits[8]),
+ fPHlast((Int_t)hits[9]),
+ fPTot(hits[10]),
+ fPx(hits[11]),
+ fPy(hits[12]),
+ fPz(hits[13]),
+ fXref(0),
+ fYref(0),
+ fZref(0)
{
-// Constructor
+/// Constructor
- fIsDetElemId = kTRUE;
- fDetElemId = vol[0];
- fParticle = hits[0];
fX = hits[1];
fY = hits[2];
fZ = hits[3];
- fTheta = hits[4];
- fPhi = hits[5];
- fTlength = hits[6];
- fEloss = hits[7];
- fPHfirst = (Int_t) hits[8];
- fPHlast = (Int_t) hits[9];
- fPTot = hits[10];
- fPx = hits[11];
- fPy = hits[12];
- fPz = hits[13];
- fAge = hits[14];
- fXref = 0.;
- fYref = 0.;
- fZref = 0.;
}
//___________________________________________
AliMUONHit::AliMUONHit(Int_t shunt, Int_t track, Int_t iChamber, Int_t idpart,
Float_t X, Float_t Y, Float_t Z, Float_t tof, Float_t momentum,
- Float_t theta, Float_t phi, Float_t length, Float_t destep):
- AliHit(shunt, track)
+ Float_t theta, Float_t phi, Float_t length, Float_t destep)
+ : AliHit(shunt, track),
+ fIsDetElemId(kFALSE),
+ fDetElemId(iChamber),
+ fParticle(idpart),
+ fTheta(theta),
+ fPhi(phi),
+ fTlength(length),
+ fEloss(destep),
+ fAge(tof),
+ fPHfirst(0),
+ fPHlast(0),
+ fPTot(momentum),
+ fPx(momentum * TMath::Sin(theta) * TMath::Cos(phi)),
+ fPy(momentum * TMath::Sin(theta) * TMath::Sin(phi)),
+ fPz(momentum * TMath::Cos(theta)),
+ fXref(0),
+ fYref(0),
+ fZref(0)
{
-// Constructor
-// TBR
+/// Constructor
+/// \deprecated TBR
- fIsDetElemId = kFALSE;
- fDetElemId = iChamber;
- fParticle = idpart;
fX = X;
fY = Y;
fZ = Z;
- fTheta = theta;
- fPhi = phi;
- fTlength = length;
- fEloss = destep;
- fPHfirst = 0;
- fPHlast = 0;
- fPTot = momentum;
- fPx = momentum * TMath::Sin(theta) * TMath::Cos(phi);
- fPy = momentum * TMath::Sin(theta) * TMath::Sin(phi);
- fPz = momentum * TMath::Cos(theta) ;
- fAge = tof;
- fXref = 0.;
- fYref = 0.;
- fZref = 0.;
}
//___________________________________________
AliMUONHit::AliMUONHit(Int_t shunt, Int_t track, Int_t detElemId, Int_t idpart,
Float_t X, Float_t Y, Float_t Z, Float_t tof, Float_t momentum,
Float_t theta, Float_t phi, Float_t length, Float_t destep,
- Bool_t /*isDetElemId*/):
- AliHit(shunt, track)
+ Bool_t /*isDetElemId*/)
+ : AliHit(shunt, track),
+ fIsDetElemId(kTRUE),
+ fDetElemId(detElemId),
+ fParticle(idpart),
+ fTheta(theta),
+ fPhi(phi),
+ fTlength(length),
+ fEloss(destep),
+ fAge(tof),
+ fPHfirst(0),
+ fPHlast(0),
+ fPTot(momentum),
+ fPx(momentum * TMath::Sin(theta) * TMath::Cos(phi)),
+ fPy(momentum * TMath::Sin(theta) * TMath::Sin(phi)),
+ fPz(momentum * TMath::Cos(theta)),
+ fXref(0),
+ fYref(0),
+ fZref(0)
{
-// Constructor
- fIsDetElemId = kTRUE;
- fDetElemId = detElemId;
- fParticle = idpart;
+/// Constructor
fX = X;
fY = Y;
fZ = Z;
- fTheta = theta;
- fPhi = phi;
- fTlength = length;
- fEloss = destep;
- fPHfirst = 0;
- fPHlast = 0;
- fPTot = momentum;
- fPx = momentum * TMath::Sin(theta) * TMath::Cos(phi);
- fPy = momentum * TMath::Sin(theta) * TMath::Sin(phi);
- fPz = momentum * TMath::Cos(theta) ;
- fAge = tof;
- fXref = 0.;
- fYref = 0.;
- fZref = 0.;
}
//-----------------------------------------------------------------------------------------------
AliMUONHit::AliMUONHit(Int_t shunt, Int_t track, Int_t iChamber, Int_t idpart,
Float_t X, Float_t Y, Float_t Z, Float_t tof, Float_t momentum,
Float_t theta, Float_t phi, Float_t length, Float_t destep,
- Float_t Xref,Float_t Yref,Float_t Zref):
- AliHit(shunt, track)
+ Float_t Xref,Float_t Yref,Float_t Zref)
+ : AliHit(shunt, track),
+ fIsDetElemId(kFALSE),
+ fDetElemId(iChamber),
+ fParticle(idpart),
+ fTheta(theta),
+ fPhi(phi),
+ fTlength(length),
+ fEloss(destep),
+ fAge(tof),
+ fPHfirst(0),
+ fPHlast(0),
+ fPTot(momentum),
+ fPx(momentum * TMath::Sin(theta) * TMath::Cos(phi)),
+ fPy(momentum * TMath::Sin(theta) * TMath::Sin(phi)),
+ fPz(momentum * TMath::Cos(theta)),
+ fXref(Xref),
+ fYref(Yref),
+ fZref(Zref)
{
-// Constructor
-// TBR
+/// Constructor
+/// \deprecated TBR
- fIsDetElemId = kFALSE;
- fDetElemId = iChamber;
- fParticle = idpart;
fX = X;
fY = Y;
fZ = Z;
- fTheta = theta;
- fPhi = phi;
- fTlength = length;
- fEloss = destep;
- fPHfirst = 0;
- fPHlast = 0;
- fPTot = momentum;
- fPx = momentum * TMath::Sin(theta) * TMath::Cos(phi);
- fPy = momentum * TMath::Sin(theta) * TMath::Sin(phi);
- fPz = momentum * TMath::Cos(theta) ;
- fAge = tof;
- fXref = Xref;
- fYref = Yref;
- fZref = Zref;
}
//-----------------------------------------------------------------------------------------------
AliMUONHit::AliMUONHit(Int_t shunt, Int_t track, Int_t detElemId, Int_t idpart,
Float_t X, Float_t Y, Float_t Z, Float_t tof, Float_t momentum,
Float_t theta, Float_t phi, Float_t length, Float_t destep,
Float_t Xref,Float_t Yref,Float_t Zref,
- Bool_t /*isDetElemId*/):
- AliHit(shunt, track)
+ Bool_t /*isDetElemId*/)
+ : AliHit(shunt, track),
+ fIsDetElemId(kTRUE),
+ fDetElemId(detElemId),
+ fParticle(idpart),
+ fTheta(theta),
+ fPhi(phi),
+ fTlength(length),
+ fEloss(destep),
+ fAge(tof),
+ fPHfirst(0),
+ fPHlast(0),
+ fPTot(momentum),
+ fPx(momentum * TMath::Sin(theta) * TMath::Cos(phi)),
+ fPy(momentum * TMath::Sin(theta) * TMath::Sin(phi)),
+ fPz(momentum * TMath::Cos(theta)),
+ fXref(Xref),
+ fYref(Yref),
+ fZref(Zref)
{
-// Constructor
- fIsDetElemId = kTRUE;
- fDetElemId = detElemId;
- fParticle = idpart;
+/// Constructor
+
fX = X;
fY = Y;
fZ = Z;
- fTheta = theta;
- fPhi = phi;
- fTlength = length;
- fEloss = destep;
- fPHfirst = 0;
- fPHlast = 0;
- fPTot = momentum;
- fPx = momentum * TMath::Sin(theta) * TMath::Cos(phi);
- fPy = momentum * TMath::Sin(theta) * TMath::Sin(phi);
- fPz = momentum * TMath::Cos(theta) ;
- fAge = tof;
- fXref = Xref;
- fYref = Yref;
- fZref = Zref;
+}
+
+//-----------------------------------------------------------------------------------------------
+AliMUONHit::~AliMUONHit()
+{
+/// Dectructor
}
//-----------------------------------------------------------------------------------------------
Int_t AliMUONHit::DetElemId()const
{
-// Return detection element ID
+/// Return detection element ID
if (!fIsDetElemId) {
AliWarning("Detection element Id is not defined.");
return 0;
}
- // end of TBR
return fDetElemId;
}
//-----------------------------------------------------------------------------------------------
Int_t AliMUONHit::Chamber() const
{
-// Return chamber ID
+/// Return chamber ID
if (!fIsDetElemId)
return fDetElemId;
/// \class AliMUONHit
/// \brief MonteCarlo hit
///
-/// MUON classe for MonteCarlo Hits, inherited from AliHit for the
+/// MUON class for MonteCarlo Hits, inherited from AliHit for the
/// In addition to the ALiHit data member fX, fY, fZ and fTrack, AliMUONHit contains some info about the particle crossing the chamber:
/// Impulsion: fPtot, fPx, fPy and fPz
/// Reference position at the center of the chamber (wire plane) fXref, fYref and fZref
Float_t X, Float_t Y, Float_t Z, Float_t tof, Float_t momentum,
Float_t theta, Float_t phi, Float_t length, Float_t destep,
Float_t Xref, Float_t Yref, Float_t Zref, Bool_t isNew);
- virtual ~AliMUONHit() {}
+ virtual ~AliMUONHit();
Int_t DetElemId()const;
Int_t Chamber() const;
- virtual void Print(Option_t* opt="") const;
-
- Float_t Particle() const {return fParticle;}
- Float_t Theta() const {return fTheta;}
- Float_t Phi() const {return fPhi;}
- Float_t Tlength() const {return fTlength;}
- Float_t Eloss() const {return fEloss;}
- Float_t Age() const {return fAge;}
- Int_t PHfirst() const {return fPHfirst;}
- Int_t PHlast() const {return fPHlast;}
- Float_t Momentum() const {return fPTot;}
- Float_t Px() const {return fPx;}
- Float_t Py() const {return fPy;}
- Float_t Pz() const {return fPz;}
- Float_t Cx() const {return fPx/fPTot;}
- Float_t Cy() const {return fPy/fPTot;}
- Float_t Cz() const {return fPz/fPTot;}
-
- Float_t Xref() const {return fXref;}
- Float_t Yref() const {return fYref;}
- Float_t Zref() const {return fZref;}
+ virtual void Print(Option_t* opt="") const;
+ Float_t Particle() const {return fParticle;} ///< Return particle id
+ Float_t Theta() const {return fTheta;} ///< Return incident theta angle in degrees
+ Float_t Phi() const {return fPhi;} ///< Return incident phi angle in degrees
+ Float_t Tlength() const {return fTlength;} ///< Return track length inside the chamber
+ Float_t Eloss() const {return fEloss;} ///< Return Ionisation energy loss in gas
+ Float_t Age() const {return fAge;} ///< Return Particle Age
+ Int_t PHfirst() const {return fPHfirst;} ///< Return First padhit
+ Int_t PHlast() const {return fPHlast;} ///< Return Last padhit
+
+ Float_t Momentum() const {return fPTot;} ///< Return local momentum P of the entering track
+ Float_t Px() const {return fPx;} ///< Return Px
+ Float_t Py() const {return fPy;} ///< Return Py
+ Float_t Pz() const {return fPz;} ///< Return Pz
+ Float_t Cx() const {return fPx/fPTot;} ///< Return Px/PTot
+ Float_t Cy() const {return fPy/fPTot;} ///< Return Py/PTot
+ Float_t Cz() const {return fPz/fPTot;} ///< Return Pz/PTot
+
+ Float_t Xref() const {return fXref;} ///< Return X position of hit in the center of the chamber (without angle effect)
+ Float_t Yref() const {return fYref;} ///< Return Y position of hit in the center of the chamber (without angle effect)
+ Float_t Zref() const {return fZref;} ///< Return Z position of hit in the center of the chamber (without angle effect)
private:
Bool_t fIsDetElemId; ///< False if fDetElemId contains Chamber Id (old code)
Float_t fTheta ; ///< Incident theta angle in degrees
Float_t fPhi ; ///< Incident phi angle in degrees
Float_t fTlength; ///< Track length inside the chamber
- Float_t fEloss; ///< ionisation energy loss in gas
+ Float_t fEloss; ///< Ionisation energy loss in gas
Float_t fAge; ///< Particle Age
Int_t fPHfirst; ///< First padhit
Int_t fPHlast; ///< Last padhit
#include "AliMUONConstants.h"
#include "AliLog.h"
+/// \cond CLASSIMP
ClassImp(AliMUONLoader)
+/// \endcond
+
//___________________________________________________________________
AliMUONLoader::AliMUONLoader()
: AliLoader(),
: AliLoader(detname,eventfoldername),
fMUONData(0)
{
+/// Standard contructor with name of the top folder of the tree
}
//_______________________________________________________________________________
AliMUONLoader::AliMUONLoader(const Char_t * detname,TFolder* eventfolder)
: AliLoader(detname,eventfolder),
- fMUONData(0)
+ fMUONData(0)
{
/// Constructor
}
-//___________________________________________
-AliMUONLoader::AliMUONLoader(const AliMUONLoader& rhs)
- : AliLoader(rhs)
-{
-/// Protected copy constructor
-
- AliFatal("Not implemented.");
-}
//_______________________________________________________________________________
AliMUONLoader::~AliMUONLoader()
{
/// Destructor
}
-//-------------------------------------------------------------------
-AliMUONLoader&
-AliMUONLoader::operator=(const AliMUONLoader& rhs)
-{
-/// Protected assignement operator
-
- if (this == &rhs) return *this;
- AliFatal("Not implemented.");
-
- return *this;
-}
-
//_______________________________________________________________________________
void AliMUONLoader::SetMUONData(AliMUONData * MUONData)
{
#include "AliLog.h"
#include "AliMUONLocalStruct.h"
-ClassImp(AliMUONLocalTrigger)
-
-/// ------------------
-/// Class AliMUONLocalTrigger
-/// ------------------
+/// \class AliMUONLocalTrigger
/// Local Trigger algorithm data outputs
-/// (contains local trigger decision and bit patterns)
-/// Ph. Crochet
-///
-/// add SetLocalStruct method for rawdata
-/// Ch. Finck
+/// (contains local trigger decision and bit patterns) \n
+/// Add SetLocalStruct method for rawdata (Ch. Finck)
+/// \author Ph. Crochet
+
+/// \cond CLASSIMP
+ClassImp(AliMUONLocalTrigger)
+/// \endcond
//----------------------------------------------------------------------
AliMUONLocalTrigger::AliMUONLocalTrigger()
fLoDecision(0),
fDigits(0)
{
- //
- // constructor
- //
+/// Default constructor
}
//----------------------------------------------------------------------
AliMUONLocalTrigger::AliMUONLocalTrigger(const AliMUONLocalTrigger& theMUONLocalTrig)
: TObject(theMUONLocalTrig)
{
- //
- // copy constructor (useful for TClonesArray)
- //
+/// Copy constructor (useful for TClonesArray)
+
fLoCircuit = theMUONLocalTrig.fLoCircuit;
fLoStripX = theMUONLocalTrig.fLoStripX;
fLoDev = theMUONLocalTrig.fLoDev;
//----------------------------------------------------------------------
AliMUONLocalTrigger& AliMUONLocalTrigger::operator=(const AliMUONLocalTrigger& theMUONLocalTrig)
{
- // assigment operator
- //
- // equal operator (useful for non-pointer member in TClonesArray)
+/// Assigment operator;
+/// equal operator (useful for non-pointer member in TClonesArray)
if (this == &theMUONLocalTrig)
return *this;
//----------------------------------------------------------------------
AliMUONLocalTrigger::AliMUONLocalTrigger(const Int_t* localtr, const TArrayI& digits)
{
- //
- // add a local trigger object
- //
+/// Add a local trigger object
+
fLoCircuit = localtr[0];
fLoStripX = localtr[1];
fLoDev = localtr[2];
//----------------------------------------------------------------------
Char_t AliMUONLocalTrigger::GetLoDecision()
{
- // get local decision
- // from H(L)pt
- // returns local trigger decision
+/// Get local decision
+/// from H(L)pt;
+/// returns local trigger decision
fLoDecision = (fLoLpt & 0x3);
fLoDecision |= (fLoHpt << 2) & 0xC;
void AliMUONLocalTrigger::GetDigit(
Int_t i, Int_t& chamber, Int_t& cathode, Int_t& digit) const
{
-// Returns the i'th digit that fired this circuit.
-// The number of digits can be found with NumberOfDigits(), that is
-// i is valid in the range [ 0 , NumberOfDigits() - 1 ]
+/// Returns the i'th digit that fired this circuit.
+/// The number of digits can be found with NumberOfDigits(), that is
+/// i is valid in the range [ 0 , NumberOfDigits() - 1 ]
Int_t digitnumber = fDigits[i];
DecodeDigitNumber(digitnumber, chamber, cathode, digit);
Int_t AliMUONLocalTrigger::EncodeDigitNumber(Int_t chamber, Int_t cathode,
Int_t digit)
{
-// Encodes a 32-bit digit number from digit information to be stored
-// in internal integer arrays. Note that the value of the digit parameter
-// can not be larger than 0x07FFFFFF.
+/// Encodes a 32-bit digit number from digit information to be stored
+/// in internal integer arrays. Note that the value of the digit parameter
+/// can not be larger than 0x07FFFFFF.
assert( 0 <= cathode && cathode <= 1 );
assert( 0 <= chamber && chamber <= 13 );
void AliMUONLocalTrigger::DecodeDigitNumber(Int_t digitnumber, Int_t& chamber,
Int_t& cathode, Int_t& digit)
{
-// Decodes a digit number into information about the digit.
-// One can subsequently fetch the digit with
-// AliMUONDataInterface::Digit(chamber, cathode, digit)
+/// Decodes a digit number into information about the digit.
+/// One can subsequently fetch the digit with
+/// AliMUONDataInterface::Digit(chamber, cathode, digit)
cathode = (digitnumber >> 31) & 0x1;
chamber = (digitnumber >> 27) & 0xF;
//----------------------------------------------------------------------
void AliMUONLocalTrigger::SetLocalStruct(Int_t loCircuit, AliMUONLocalStruct& localStruct)
{
- //
- // Set local trigger info from rawdata localStruct
- //
+/// Set local trigger info from rawdata localStruct
// set id'
SetLoCircuit(loCircuit);
/// \ingroup base
/// \class AliMUONLocalTrigger
/// \brief Reconstructed Local Trigger object
-/// \author Ph. Crochet
+// Author Ph. Crochet
#include <TObject.h>
#include <TArrayI.h>
AliMUONLocalTrigger& operator=(const AliMUONLocalTrigger& rhs);
// getter methods
+ //
+ /// Return Circuit number
Int_t LoCircuit() const {return fLoCircuit;}
+ /// Return X strip in MT11
Int_t LoStripX() const {return fLoStripX;}
+ /// Return Deviation
Int_t LoDev() const {return fLoDev;}
+ /// Return Y strip in MT11
Int_t LoStripY() const {return fLoStripY;}
+ /// Return Low pt
Int_t LoLpt() const {return fLoLpt;}
+ /// Return High p
Int_t LoHpt() const {return fLoHpt;}
+ /// Return All pt
Int_t LoApt() const {return fLoApt;}
-
+ /// Return X strip pattern for chamber 11
UShort_t GetX1Pattern() const {return fX1Pattern;}
+ /// Return X strip pattern for chamber 12
UShort_t GetX2Pattern() const {return fX2Pattern;}
+ /// Return X strip pattern for chamber 21
UShort_t GetX3Pattern() const {return fX3Pattern;}
+ /// Return X strip pattern for chamber 22
UShort_t GetX4Pattern() const {return fX4Pattern;}
+ /// Return Y strip pattern for chamber 11
UShort_t GetY1Pattern() const {return fY1Pattern;}
+ /// Return Y strip pattern for chamber 12
UShort_t GetY2Pattern() const {return fY2Pattern;}
+ /// Return Y strip pattern for chamber 21
UShort_t GetY3Pattern() const {return fY3Pattern;}
+ /// Return Y strip pattern for chamber 22
UShort_t GetY4Pattern() const {return fY4Pattern;}
Char_t GetLoDecision();
// setter methods
+ //
+ /// Set Circuit number
void SetLoCircuit(Int_t loCir) {fLoCircuit = loCir;}
+ /// Set X strip in MT11
void SetLoStripX(Int_t loStrX) {fLoStripX = loStrX;}
+ /// Set Deviation
void SetLoDev(Int_t loDev) {fLoDev = loDev;}
+ /// Set Y strip in MT11
void SetLoStripY(Int_t loStrY) {fLoStripY = loStrY;}
+ /// Set Low pt
void SetLoLpt(Int_t loLpt) {fLoLpt = loLpt;}
+ /// Set High pt
void SetLoHpt(Int_t loHpt) {fLoHpt = loHpt;}
+ /// Set All pt
void SetLoApt(Int_t loApt) {fLoApt = loApt;}
+ /// Set X strip pattern for chamber 11
void SetX1Pattern(UShort_t pat) {fX1Pattern = pat;}
+ /// Set X strip pattern for chamber 12
void SetX2Pattern(UShort_t pat) {fX2Pattern = pat;}
+ /// Set X strip pattern for chamber 21
void SetX3Pattern(UShort_t pat) {fX3Pattern = pat;}
+ /// Set X strip pattern for chamber 22
void SetX4Pattern(UShort_t pat) {fX4Pattern = pat;}
+ /// Set Y strip pattern for chamber 11
void SetY1Pattern(UShort_t pat) {fY1Pattern = pat;}
+ /// Set Y strip pattern for chamber 12
void SetY2Pattern(UShort_t pat) {fY2Pattern = pat;}
+ /// Set Y strip pattern for chamber 21
void SetY3Pattern(UShort_t pat) {fY3Pattern = pat;}
+ /// Set Y strip pattern for chamber 22
void SetY4Pattern(UShort_t pat) {fY4Pattern = pat;}
void SetLocalStruct(Int_t loCircuit, AliMUONLocalStruct& localStruct);
// data link
+ //
+ /// Return number of digits in the list
Int_t NumberOfDigits() const { return fDigits.GetSize(); }
+ /// Return \a i th digit number in the list
Int_t GetDigitNumber(Int_t i) const { return fDigits[i]; }
void GetDigit(Int_t i, Int_t& chamber, Int_t& cathode, Int_t& digit) const;
#include <TMath.h>
#include <TRandom.h>
+/// \cond CLASSIMP
ClassImp(AliMUONMathieson)
+/// \endcond
//__________________________________________________________________________
- AliMUONMathieson::AliMUONMathieson() :
+AliMUONMathieson::AliMUONMathieson() :
fSqrtKx3(0.),
fKx2(0.),
fKx4(0.),
{
/// Default constructor
+}
+
+//__________________________________________________________________________
+AliMUONMathieson::~AliMUONMathieson()
+{
+/// Destructor
}
//__________________________________________________________________________
{
public:
AliMUONMathieson();
- virtual ~AliMUONMathieson(){}
+ virtual ~AliMUONMathieson();
- // Get anode cathode Pitch
+ /// Get anode cathode Pitch
Float_t Pitch() const {return fPitch;}
// Set anode cathode Pitch
void SetPitch(Float_t p1);
// Set Mathieson parameters
- // Mathieson \sqrt{Kx3} and derived Kx2 and Kx4
- void SetSqrtKx3AndDeriveKx2Kx4(Float_t SqrtKx3);
- // Mathieson \sqrt{Kx3}
+ //
+
+ /// Mathieson \a sqrt{Kx3} and derived \a Kx2 and \a Kx4
+ void SetSqrtKx3AndDeriveKx2Kx4(Float_t SqrtKx3);
+
+ /// Mathieson \a sqrt{Kx3}
void SetSqrtKx3(Float_t p1) {fSqrtKx3 = p1;};
- // Mathieson Kx2
+
+ /// Mathieson \a Kx2
void SetKx2(Float_t p1) {fKx2 = p1;};
- // Mathieson Kx4
+
+ /// Mathieson \a Kx4
void SetKx4(Float_t p1) {fKx4 = p1;};
- // Mathieson \sqrt{Ky3} and derived Ky2 and Ky4
+
+ /// Mathieson \a sqrt{Ky3} and derived \a Ky2 and \a Ky4
void SetSqrtKy3AndDeriveKy2Ky4(Float_t SqrtKy3);
- // Mathieson \sqrt{Ky3}
+
+ /// Mathieson \a sqrt{Ky3}
void SetSqrtKy3(Float_t p1) {fSqrtKy3 = p1;};
- // Mathieson Ky2
+
+ /// Mathieson \a Ky2
void SetKy2(Float_t p1) {fKy2 = p1;};
- // Mathieson Ky4
+
+ /// Mathieson \a Ky4
void SetKy4(Float_t p1) {fKy4 = p1;};
+
/// \deprecated To be removed when old (s)digitizers go off.
Float_t IntXY(Int_t id, AliMUONGeometrySegmentation* segmentation) const;
- /// Charge integration on region (x1,y1,x2,y2).
+
+ /// Charge integration on region \a (x1,y1,x2,y2).
Float_t IntXY(Float_t xi1, Float_t yi1, Float_t xi2, Float_t yi2) const;
private:
Float_t fKy4; ///< Mathieson Ky4 = Ky1/Ky2/Sqrt(Ky3)
Float_t fPitch; ///< anode-cathode pitch
Float_t fInversePitch; ///< 1/Pitch
- ClassDef(AliMUONMathieson,3) // Implementation of Mathieson response
+
+ ClassDef(AliMUONMathieson,3) // Implementation of Mathieson response
};
#endif
#include "AliMUONDigit.h"
#include "AliLog.h"
+/// \cond CLASSIMP
ClassImp(AliMUONPoints)
+/// \endcond
//_____________________________________________________________________________
AliMUONPoints::AliMUONPoints()
- : AliPoints()
+ : AliPoints(),
+ fHitIndex(0),
+ fTrackIndex(0),
+ fDigitIndex(0),
+ fMatrix(0)
+
{
- //
- // Default constructor
- //
- fHitIndex = 0;
- fTrackIndex = 0;
- fDigitIndex = 0;
+ /// Default constructor
+
fMarker[0] = fMarker[1] = fMarker[2]=0;
- fMatrix = 0;
}
//_____________________________________________________________________________
AliMUONPoints::AliMUONPoints(Int_t npoints)
- :AliPoints(npoints)
+ : AliPoints(npoints),
+ fHitIndex(0),
+ fTrackIndex(0),
+ fDigitIndex(0),
+ fMatrix(0)
{
- //
- // Standard constructor
- //
- fHitIndex = 0;
- fTrackIndex = 0;
- fDigitIndex = 0;
+ /// Standard constructor
+
fMarker[0] = fMarker[1] = fMarker[2]=0;
- fMatrix = 0;
}
-//_____________________________________________________________________________
-AliMUONPoints::AliMUONPoints(const AliMUONPoints& points)
- : AliPoints(points)
-{
-// Protected copy constructor
-
- AliFatal("Not implemented.");
-}
-
//_____________________________________________________________________________
AliMUONPoints::~AliMUONPoints()
{
- //
- // Default destructor
- //
+ /// Destructor
+
fHitIndex = 0;
fTrackIndex = 0;
fDigitIndex = 0;
//_____________________________________________________________________________
void AliMUONPoints::DumpHit() const
{
- //
- // Dump hit corresponding to this point
- //
+ /// Dump hit corresponding to this point
+
AliMUONHit *hit = GetHit();
if (hit) hit->Dump();
}
//_____________________________________________________________________________
void AliMUONPoints::DumpDigit() const
{
- //
- // Dump digit corresponding to this point
- //
+ /// Dump digit corresponding to this point
+
AliMUONDigit *digit = GetDigit();
if (digit) digit->Dump();
}
//_____________________________________________________________________________
void AliMUONPoints::InspectHit()
{
- //
- // Inspect hit corresponding to this point
- //
+ /// Inspect hit corresponding to this point
if (fHitIndex < 0 ) return;
TVirtualPad *padsav = gPad;
//_____________________________________________________________________________
void AliMUONPoints::InspectDigit()
{
- //
- // Inspect digit corresponding to this point
- //
+ /// Inspect digit corresponding to this point
+
if (fDigitIndex < 0) return;
TVirtualPad *padsav = gPad;
AliMUONDigit *digit = GetDigit();
//_____________________________________________________________________________
Int_t AliMUONPoints::GetTrackIndex() const
{
- //
- // Dump digit corresponding to this point
- //
+ /// Dump digit corresponding to this point
Inspect();
/*
//_____________________________________________________________________________
AliMUONHit *AliMUONPoints::GetHit() const
{
- //
- // Returns pointer to hit index in AliRun::fParticles
- //
+ /// Returns pointer to hit index in AliRun::fParticles
+
AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
pMUON->TreeH()->GetEvent(fTrackIndex);
//_____________________________________________________________________________
AliMUONDigit *AliMUONPoints::GetDigit() const
{
- //
- // Returns pointer to digit index in AliRun::fParticles
- //
+ /// Returns pointer to digit index in AliRun::fParticles
AliMUONDisplay *display=(AliMUONDisplay*)gAlice->Display();
Int_t chamber=display->GetChamber();
if (fDigitIndex < 0 || fDigitIndex >= ndigits) return 0;
return (AliMUONDigit*)muonDigits->UncheckedAt(fDigitIndex);
}
-//_____________________________________________________________________________
-
-AliMUONPoints& AliMUONPoints::operator= (const AliMUONPoints& rhs)
-{
-// Protected assignement operator
-
- if (this == &rhs) return *this;
-
- AliFatal("Not implemented.");
-
- return *this;
-}
AliMUONPoints();
AliMUONPoints(Int_t npoints);
virtual ~AliMUONPoints();
-
+
+ /// Return hit index
Int_t GetHitIndex() const {return fHitIndex;}
Int_t GetTrackIndex() const; // *MENU*
+ /// Return digit index
Int_t GetDigitIndex() const {return fDigitIndex;}
+ /// Return associated 3D-marker
TMarker3DBox *GetMarker(Int_t i) const {return fMarker[i];}
AliMUONHit *GetHit() const;
AliMUONDigit *GetDigit() const;
virtual void DumpHit() const; // *MENU*
virtual void InspectDigit(); // *MENU*
virtual void DumpDigit() const; // *MENU*
+ /// Set hit index
virtual void SetHitIndex(Int_t hitindex) {fHitIndex = hitindex;}
+ /// Set track index
virtual void SetTrackIndex(Int_t trackindex) {fTrackIndex = trackindex;}
+ /// Set digit index
virtual void SetDigitIndex(Int_t digitindex) {fDigitIndex = digitindex;}
+ /// Set associated 3D-marker
virtual void Set3DMarker(Int_t i,TMarker3DBox *marker) {fMarker[i] = marker;}
+ /// Set matrix
virtual void SetMatrix(TMatrixF *matrix) {fMatrix = matrix;}
protected:
#include "AliMUONRawCluster.h"
+/// \cond CLASSIMP
ClassImp(AliMUONRawCluster)
-
+/// \endcond
AliMUONRawCluster::AliMUONRawCluster()
- : TObject()
+ : TObject(),
+ fClusterType(0),
+ fGhost(0),
+ fDetElemId(0)
{
/// Constructor
fTracks[0]=fTracks[1]=fTracks[2]=-1;
}
}
fNcluster[0]=fNcluster[1]=-1;
- fGhost=0;
- fDetElemId = 0;
fErrXY[0] = 0.144;
fErrXY[1] = 0.01;
}
/* $Id$ */
-// -----------------------
-// Class AliMUONRecoCheck
-// -----------------------
-// Utility class to check the muon reconstruction. Reconstructed tracks are compared
-// to reference tracks. The reference tracks are built from AliTrackReference for the
-// hit in chamber (0..9) and from kinematics for the vertex parameters.
+/// \class AliMUONRecoCheck
+/// \brief Utility class to check reconstruction
+/// Reconstructed tracks are compared to reference tracks.
+/// The reference tracks are built from AliTrackReference for the
+/// hit in chamber (0..9) and from kinematics for the vertex parameters.
#include "AliMUON.h"
#include "AliMUONRecoCheck.h"
#include <TParticle.h>
+/// \cond CLASSIMP
ClassImp(AliMUONRecoCheck)
+/// \endcond
//_____________________________________________________________________________
AliMUONRecoCheck::AliMUONRecoCheck(Char_t *chLoader)
{
/// Constructor
+
fMuonTrackRef = new TClonesArray("AliMUONTrack", 10);
// open the run loader
fRecoTracks = 0;
}
-//____________________________________________________________________
-AliMUONRecoCheck::AliMUONRecoCheck(const AliMUONRecoCheck& rhs)
- : TObject(rhs)
-{
-/// Protected copy constructor
-
- AliFatal("Not implemented.");
-}
-
//_____________________________________________________________________________
AliMUONRecoCheck::~AliMUONRecoCheck()
{
delete fMUONData;
}
-//________________________________________________________________________
-AliMUONRecoCheck& AliMUONRecoCheck::operator = (const AliMUONRecoCheck& rhs)
-{
-/// Protected assignement operator
-
- if (this == &rhs) return *this;
-
- AliFatal("Not implemented.");
-
- return *this;
-}
-
//_____________________________________________________________________________
void AliMUONRecoCheck::MakeTrackRef()
{
AliMUONRecoCheck(Char_t *chLoader);
virtual ~AliMUONRecoCheck();
+ /// Return MUON data
AliMUONData* GetMUONData() {return fMUONData;}
void MakeTrackRef();
+ /// Add track reference
void AddMuonTrackReference(const AliMUONTrack *muonTrack)
{new ((*fMuonTrackRef)[fMuonTrackRef->GetEntriesFast()]) AliMUONTrack(*muonTrack);}
+
void PrintEvent() const;
void ResetTracks() const;
+ /// Return run loader
AliRunLoader* GetRunLoader() {return fRunLoader;}
void CleanMuonTrackRef();
void ReconstructibleTracks();
+ /// Return number of reconstructible tracks
Int_t GetNumberOfReconstuctibleTracks() {return fReconstructibleTracks;}
+ /// Return number of reconstructed tracks
Int_t GetNumberOfRecoTracks() {return fRecoTracks;}
TClonesArray *GetTrackReco();
+ /// Return reference muon tracks
TClonesArray *GetMuonTrackRef() {return fMuonTrackRef;}
protected:
#include <TObjString.h>
#include <TMap.h>
+/// \cond CLASSIMP
ClassImp(AliMUONSegFactory)
+/// \endcond
//______________________________________________________________________________
AliMUONSegFactory::AliMUONSegFactory(const AliMUONGeometryTransformer* geometry)
/// Default constructor
}
-//______________________________________________________________________________
-AliMUONSegFactory::AliMUONSegFactory(const AliMUONSegFactory& rhs)
- : TObject(rhs)
-{
-/// Protected copy constructor
-
- AliFatal("Not implemented.");
-}
-
//______________________________________________________________________________
AliMUONSegFactory::~AliMUONSegFactory()
// The segmentation is supposed to be deleted in the client code
}
-//______________________________________________________________________________
-AliMUONSegFactory& AliMUONSegFactory::operator=(const AliMUONSegFactory& rhs)
-{
- // Protected assignement operator
-
- if (this == &rhs) return *this;
-
- AliFatal("Not implemented.");
-
- return *this;
-}
-
//
// Private methods
//
//______________________________________________________________________________
Bool_t AliMUONSegFactory::IsGeometryDefined(Int_t ichamber)
{
-// Return true, if det elements for the chamber with the given ichamber Id
-// are defined in geometry (the geometry builder for this chamber was activated)
+/// Return true, if det elements for the chamber with the given ichamber Id
+/// are defined in geometry (the geometry builder for this chamber was activated)
if ( ! fkTransformer ||
! fkTransformer->GetModuleTransformer(ichamber, false) )
AliMUONVGeometryDESegmentation*
AliMUONSegFactory::CreateDESegmentation(Int_t detElemId, Int_t cath)
{
-// Create DE segmentation, operating in local DE reference frame
+/// Create DE segmentation, operating in local DE reference frame
// Check detElemId & cath
if ( ! AliMpDEManager::IsValid(detElemId, cath, true) ) return 0;
AliMUONGeometrySegmentation*
AliMUONSegFactory::CreateModuleSegmentation(Int_t moduleId, Int_t cath)
{
-// Create module segmentation, operating in global reference frame
-// Detection elements are defined via DE names map.
+/// Create module segmentation, operating in global reference frame
+/// Detection elements are defined via DE names map.
// Check cathod & module Id
if ( ! AliMpDEManager::IsValidCathod(cath, true) ||
//__________________________________________________________________________
void AliMUONSegFactory::BuildStation3()
{
- //--------------------------------------------------------
- // Configuration for Chamber TC5/6 (Station 3) ----------
- //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+/// Configuration for Chamber TC5/6 (Station 3) ----------
AliMUONGeometrySegmentation* segmentation[2];
//__________________________________________________________________________
void AliMUONSegFactory::BuildStation4()
{
- //--------------------------------------------------------
- // Configuration for Chamber TC7/8 (Station 4) ----------
- //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
+/// Configuration for Chamber TC7/8 (Station 4) ----------
AliMUONGeometrySegmentation* segmentation[2];
//__________________________________________________________________________
void AliMUONSegFactory::BuildStation5()
{
- //--------------------------------------------------------
- // Configuration for Chamber TC9/10 (Station 5) ---------
- //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+/// Configuration for Chamber TC9/10 (Station 5) ---------
AliMUONGeometrySegmentation* segmentation[2];
//__________________________________________________________________________
void AliMUONSegFactory::BuildStation6()
{
- //--------------------------------------------------------
- // Configuration for Trigger stations
- //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+/// Configuration for Trigger stations
AliMUONGeometrySegmentation *chamberSeg[2];
/* $Id$ */
-/// \ingroup sim
+/// \ingroup base
/// \class AliMUONSegFactory
/// \brief New factory for building segmentations at all levels
///
ClassDef(AliMUONSegFactory,0) // MUON Factory for Chambers and Segmentation
};
+/// Return segmentation
inline AliMUONSegmentation* AliMUONSegFactory::GetSegmentation() const
{ return fSegmentation; }
#include "AliMUONGeometryEnvelopeStore.h"
#include "AliMUONConstants.h"
+/// \cond CLASSIMP
ClassImp(AliMUONSlatGeometryBuilder)
-
+/// \endcond
//______________________________________________________________________________
AliMUONSlatGeometryBuilder::AliMUONSlatGeometryBuilder(AliMUON* muon)
// $Id$
// Revision of includes 07/05/2004
//
-/// \ingroup base
+/// \ingroup sim
/// \class AliMUONSlatGeometryBuilder
/// \brief MUON Station3 geometry construction class
///
#include "AliMUONSt12QuadrantSegmentation.h"
#include "AliMUONConstants.h"
+/// \cond CLASSIMP
ClassImp(AliMUONSt12QuadrantSegmentation)
+/// \endcond
//______________________________________________________________________________
AliMUONSt12QuadrantSegmentation::AliMUONSt12QuadrantSegmentation(
fYt(0.),
fCorrA(0)
{
-// Normal constructor
+/// Standard constructor
fSectorSegmentation = dynamic_cast<AliMpSectorSegmentation*>(segmentation);
if (fSectorSegmentation)
fIwt(0),
fXt(0.),
fYt(0.),
- fCorrA(0) {
-// Default Constructor
+ fCorrA(0)
+{
+/// Default Constructor
AliDebug(1, Form("default (empty) ctor this = %p", this));
}
//______________________________________________________________________________
-AliMUONSt12QuadrantSegmentation::AliMUONSt12QuadrantSegmentation(const AliMUONSt12QuadrantSegmentation& rhs)
- : AliMUONVGeometryDESegmentation(rhs)
+AliMUONSt12QuadrantSegmentation::~AliMUONSt12QuadrantSegmentation()
{
-// Copy constructor
- AliFatal("Copy constructor is not implemented.");
-}
-
-//______________________________________________________________________________
-AliMUONSt12QuadrantSegmentation::~AliMUONSt12QuadrantSegmentation() {
-// Destructor
+/// Destructor
AliDebug(1, Form("dtor this = %p", this));
delete fSectorIterator;
}
-//
-// operators
-//
-
-//______________________________________________________________________________
-AliMUONSt12QuadrantSegmentation&
-AliMUONSt12QuadrantSegmentation::operator=(const AliMUONSt12QuadrantSegmentation& rhs)
-{
-// Copy operator
-
- // check assignement to self
- if (this == &rhs) return *this;
-
- AliFatal("Assignment operator is not implemented.");
-
- return *this;
-}
-
//
// private methods
//
//______________________________________________________________________________
void AliMUONSt12QuadrantSegmentation::UpdateCurrentPadValues(const AliMpPad& pad)
{
-// Updates current pad values.
-// ---
+/// Updates current pad values.
fIx = pad.GetIndices().GetFirst();
fIy = pad.GetIndices().GetSecond();
//______________________________________________________________________________
void AliMUONSt12QuadrantSegmentation::SetPadSize(Float_t /*p1*/, Float_t /*p2*/)
{
-// Set pad size Dx*Dy
-// ---
+/// Set pad size Dx*Dy
AliFatal("Not uniform pad size.");
}
//______________________________________________________________________________
void AliMUONSt12QuadrantSegmentation::SetDAnod(Float_t d)
{
-// Set anod pitch
-// ---
+/// Set anod pitch
fWireD = d;
}
//______________________________________________________________________________
Bool_t AliMUONSt12QuadrantSegmentation::HasPad(Float_t x, Float_t y, Float_t /*z*/)
{
-// Returns true if a pad exists in the given position
+/// Returns true if a pad exists in the given position
// fSector->GetMotifMap()->Print();
//______________________________________________________________________________
Bool_t AliMUONSt12QuadrantSegmentation::HasPad(Int_t ix, Int_t iy)
{
-// Returns true if a pad with given indices exists
+/// Returns true if a pad with given indices exists
AliMpPad pad = fSectorSegmentation->PadByIndices(AliMpIntPair(ix,iy), false);
//______________________________________________________________________________
AliMUONGeometryDirection AliMUONSt12QuadrantSegmentation::GetDirection()
{
-// Returns the direction with a constant pad size
-// (Direction or coordinate where the resolution is the best)
+/// Returns the direction with a constant pad size
+/// (Direction or coordinate where the resolution is the best)
switch ( fSector->GetDirection() ) {
case kX: return kDirX;
const AliMpVSegmentation*
AliMUONSt12QuadrantSegmentation::GetMpSegmentation() const
{
-// Returns the mapping segmentation
-// (provides access to electronics info)
+/// Returns the mapping segmentation
+/// (provides access to electronics info)
return fSectorSegmentation;
}
//______________________________________________________________________________
Float_t AliMUONSt12QuadrantSegmentation::GetAnod(Float_t xhit) const
{
-// Anod wire coordinate closest to xhit
-// Returns for a hit position xhit the position of the nearest anode wire
-// From AliMUONSegmentationV01.
-// ---
+/// Anod wire coordinate closest to xhit
+/// Returns for a hit position xhit the position of the nearest anode wire
+/// From AliMUONSegmentationV01.
Float_t wire= (xhit>0) ? Int_t(xhit/fWireD) + 0.5
: Int_t(xhit/fWireD) - 0.5;
void AliMUONSt12QuadrantSegmentation::GetPadI(Float_t x, Float_t y, Float_t /*z*/,
Int_t& ix, Int_t& iy)
{
-// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
-// ---
+/// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
GetPadI(x, y, ix, iy);
}
void AliMUONSt12QuadrantSegmentation::GetPadI(Float_t x, Float_t y,
Int_t& ix, Int_t& iy)
{
-// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
-// If there is no pad, ix = 0, iy = 0 are returned.
-// ---
+/// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
+/// If there is no pad, ix = 0, iy = 0 are returned.
AliMpPad pad = fSectorSegmentation->PadByPosition(TVector2(x,y), true);
void AliMUONSt12QuadrantSegmentation::GetPadC(Int_t ix, Int_t iy,
Float_t& x, Float_t& y, Float_t& z)
{
-// Transform from pad to real coordinates
-// ---
+/// Transform from pad to real coordinates
z = fZ;
GetPadC(ix, iy, x , y);
void AliMUONSt12QuadrantSegmentation::GetPadC(Int_t ix, Int_t iy,
Float_t& x, Float_t& y)
{
-// Transform from pad to real coordinates
-// If there is no pad, x = 0., y = 0. are returned.
-// ---
+/// Transform from pad to real coordinates
+/// If there is no pad, x = 0., y = 0. are returned.
AliMpPad pad = fSectorSegmentation->PadByIndices(AliMpIntPair(ix,iy), true);
//______________________________________________________________________________
void AliMUONSt12QuadrantSegmentation::Init(Int_t chamber)
{
-// Initialize segmentation
-// ---
+/// Initialize segmentation
// find Npx, Npy and save this info
//______________________________________________________________________________
Float_t AliMUONSt12QuadrantSegmentation::Dpx() const
{
-// Get pad size in x
-// ---
+/// Get pad size in x
AliFatal( "Not uniform pad size.");
return 0.;
//______________________________________________________________________________
Float_t AliMUONSt12QuadrantSegmentation::Dpy() const
{
-// Get pad size in y
-// ---
+/// Get pad size in y
AliFatal("Not uniform pad size.");
return 0.;
//______________________________________________________________________________
Float_t AliMUONSt12QuadrantSegmentation::Dpx(Int_t isector) const
{
-// Pad size in x by sector
-// ---
+/// Pad size in x by sector
return fSectorSegmentation->PadDimensions(isector).X()*2.0;
}
//______________________________________________________________________________
Float_t AliMUONSt12QuadrantSegmentation::Dpy(Int_t isector) const
{
-// Pad size in x, y by Sector
-// ---
+/// Pad size in x, y by Sector
return fSectorSegmentation->PadDimensions(isector).Y()*2.0;
}
//______________________________________________________________________________
Int_t AliMUONSt12QuadrantSegmentation::Npx() const
{
-// Maximum number of Pads in x
-// hard coded for the time being
-// ---
+/// Maximum number of Pads in x
+/// hard coded for the time being
return fSectorSegmentation->MaxPadIndexX();
}
//______________________________________________________________________________
Int_t AliMUONSt12QuadrantSegmentation::Npy() const
{
-// Maximum number of Pads in y
-// hard coded for the time being
-// ---
+/// Maximum number of Pads in y
+/// hard coded for the time being
return fSectorSegmentation->MaxPadIndexY();
}
//______________________________________________________________________________
void AliMUONSt12QuadrantSegmentation::SetPad(Int_t ix, Int_t iy)
{
-// Set pad position.
-// Sets virtual pad coordinates, needed for evaluating pad response
-// outside the tracking program.
-// From AliMUONSegmentationV01.
-// ---
+/// Set pad position.
+/// Sets virtual pad coordinates, needed for evaluating pad response
+/// outside the tracking program.
+/// From AliMUONSegmentationV01.
GetPadC(ix, iy, fX, fY);
fZone = Sector(ix, iy);
//______________________________________________________________________________
void AliMUONSt12QuadrantSegmentation::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
{
-// Set hit position
-// Sets virtual hit position, needed for evaluating pad response
-// outside the tracking program
-// From AliMUONSegmentationV01.
+/// Set hit position
+/// Sets virtual hit position, needed for evaluating pad response
+/// outside the tracking program
+/// From AliMUONSegmentationV01.
fXhit = xhit;
fYhit = yhit;
void AliMUONSt12QuadrantSegmentation::FirstPad(Float_t xhit, Float_t yhit, Float_t /*zhit*/,
Float_t dx, Float_t dy)
{
-// Iterate over pads - initialiser
-// ---
+/// Iterate over pads - initialiser
// Sets the current pad to that located in the hit position
//______________________________________________________________________________
void AliMUONSt12QuadrantSegmentation::NextPad()
{
-// Iterate over pads - stepper
-// ---
+/// Iterate over pads - stepper
fSectorIterator->Next();
//______________________________________________________________________________
Int_t AliMUONSt12QuadrantSegmentation::MorePads()
{
-// Iterate over pads - condition
-// ---
+/// Iterate over pads - condition
if (fSectorIterator->IsDone())
return 0;
Float_t AliMUONSt12QuadrantSegmentation::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
-// ---
+/// Returns the square of the distance between 1 pad
+/// labelled by its channel numbers and a coordinate
AliMpPad pad = fSectorSegmentation->PadByIndices(AliMpIntPair(iX, iY));
void AliMUONSt12QuadrantSegmentation::GetNParallelAndOffset(Int_t /*iX*/, Int_t /*iY*/,
Int_t* /*Nparallel*/, Int_t* /*Offset*/)
{
-// Number of pads read in parallel and offset to add to x
-// (specific to LYON, but mandatory for display)
-// ---
+/// Number of pads read in parallel and offset to add to x
+/// (specific to LYON, but mandatory for display)
AliFatal( "Not yet implemented.");
}
Int_t* Nlist,
Int_t Xlist[10], Int_t Ylist[10])
{
-// Get next neighbours
-// ---
+/// Get next neighbours
AliMpPad pad = fSectorSegmentation->PadByIndices(AliMpIntPair(iX,iY));
Int_t &i = *Nlist;
//______________________________________________________________________________
Int_t AliMUONSt12QuadrantSegmentation::Ix()
{
-// Current pad cursor during disintegration
-// x, y-coordinate
-// ---
+/// Current pad cursor during disintegration
+/// x, y-coordinate
return fSectorIterator->CurrentItem().GetIndices().GetFirst();
}
//______________________________________________________________________________
Int_t AliMUONSt12QuadrantSegmentation::Iy()
{
-// Current pad cursor during disintegration
-// x, y-coordinate
-// ---
+/// Current pad cursor during disintegration
+/// x, y-coordinate
return fSectorIterator->CurrentItem().GetIndices().GetSecond();
}
//______________________________________________________________________________
Int_t AliMUONSt12QuadrantSegmentation::ISector()
{
-// Current sector
-// ---
+/// Current sector
return fZone;
}
//______________________________________________________________________________
Int_t AliMUONSt12QuadrantSegmentation::Sector(Int_t ix, Int_t iy)
{
-// Calculate sector from pad coordinates
-// ---
+/// Calculate sector from pad coordinates
return fSectorSegmentation
->Zone(fSectorSegmentation->PadByIndices(AliMpIntPair(ix, iy)));
//______________________________________________________________________________
Int_t AliMUONSt12QuadrantSegmentation::Sector(Float_t x, Float_t y)
{
-// Calculate sector from pad coordinates
-// ---
+/// Calculate sector from pad coordinates
return fSectorSegmentation
->Zone(fSectorSegmentation
void AliMUONSt12QuadrantSegmentation::IntegrationLimits(Float_t& x1, Float_t& x2,
Float_t& y1, Float_t& y2)
{
-// Current integration limits
-// ---
+/// Current integration limits
x1 = fXhit - fX - Dpx(fZone)/2.;
x2 = x1 + Dpx(fZone);
//______________________________________________________________________________
Int_t AliMUONSt12QuadrantSegmentation::SigGenCond(Float_t x, Float_t y, Float_t /*z*/)
{
-// Signal Generation Condition during Stepping
-// 0: don't generate signal
-// 1: generate signal
-// Comments:
-//
-// Crossing of pad boundary and mid plane between neighbouring wires is checked.
-// To correctly simulate the dependence of the spatial resolution on the angle
-// of incidence signal must be generated for constant steps on
-// the projection of the trajectory along the anode wire.
-//
-// Signal will be generated if particle crosses pad boundary or
-// boundary between two wires.
-//
-// From AliMUONSegmentationV01
-// ---
+/// Signal Generation Condition during Stepping
+/// - 0: don't generate signal
+/// - 1: generate signal
+///
+/// Comments: \n
+///
+/// Crossing of pad boundary and mid plane between neighbouring wires is checked.
+/// To correctly simulate the dependence of the spatial resolution on the angle
+/// of incidence signal must be generated for constant steps on
+/// the projection of the trajectory along the anode wire.
+///
+/// Signal will be generated if particle crosses pad boundary or
+/// boundary between two wires.
+///
+/// From AliMUONSegmentationV01
Int_t ixt, iyt;
GetPadI(x, y, ixt, iyt);
//______________________________________________________________________________
void AliMUONSt12QuadrantSegmentation::SigGenInit(Float_t x, Float_t y, Float_t /*z*/)
{
-// Initialise signal generation at coord (x,y,z)
-// Initialises pad and wire position during stepping.
-// From AliMUONSegmentationV01
-// ---
+/// Initialise signal generation at coord (x,y,z)
+/// Initialises pad and wire position during stepping.
+/// From AliMUONSegmentationV01
fXt = x;
fYt = y;
//______________________________________________________________________________
void AliMUONSt12QuadrantSegmentation::GiveTestPoints(Int_t& n, Float_t* x, Float_t* y) const
{
-// Test points for auto calibration
-// Returns test point on the pad plane.
-// Used during determination of the segmoid correction of the COG-method
-// From AliMUONSegmentationV01
-// ---
+/// Test points for auto calibration
+/// Returns test point on the pad plane.
+/// Used during determination of the segmoid correction of the COG-method
+/// From AliMUONSegmentationV01
n=1;
x[0] = (fRmax+fRmin)/2/TMath::Sqrt(2.);
//______________________________________________________________________________
void AliMUONSt12QuadrantSegmentation::Draw(const char * /*opt*/)
{
-// Draw the segmentation zones.
-// (Called from AliMUON::BuildGeometry)
-// ---
+/// Draw the segmentation zones.
+/// (Called from AliMUON::BuildGeometry)
AliWarning("Not yet implemented.");
}
//______________________________________________________________________________
void AliMUONSt12QuadrantSegmentation::SetCorrFunc(Int_t isec, TF1* func)
{
-// Set the correction function.
-// From AliMUONSegmentationV01
-// ---
+/// Set the correction function.
+/// From AliMUONSegmentationV01
fCorrA->AddAt(func, isec);
}
//______________________________________________________________________________
TF1* AliMUONSt12QuadrantSegmentation::CorrFunc(Int_t isec) const
{
-// Get the correction Function.
-// From AliMUONSegmentationV01
-// ---
+/// Get the correction Function.
+/// From AliMUONSegmentationV01
return (TF1*) fCorrA->At(isec);
}
/// \ingroup base
/// \class AliMUONSt12QuadrantSegmentation
-/// \brief Segmentation for MUON quadrants of stations 1 and 2
-
-// Class AliMUONSt12QuadrantSegmentation
-// -------------------------------------
-// Segmentation for MUON quadrants of stations 1 and 2 using
-// the mapping package
-//
-// Author: Ivana Hrivnacova, IPN Orsay
+/// \brief Segmentation for MUON quadrants of stations 1 and 2 using
+/// the mapping package
+///
+/// \author Ivana Hrivnacova, IPN Orsay
#include "AliMpStationType.h"
#include "AliMpPlaneType.h"
#include "AliMUONGeometryModule.h"
#include "AliMUONGeometryEnvelopeStore.h"
+/// \cond CLASSIMP
ClassImp(AliMUONSt1GeometryBuilder)
+/// \endcond
//______________________________________________________________________________
AliMUONSt1GeometryBuilder::AliMUONSt1GeometryBuilder(AliMUON* muon)
: AliMUONVGeometryBuilder(0, 1),
fMUON(muon)
{
-// Standard constructor
+/// Standard constructor
}
: AliMUONVGeometryBuilder(),
fMUON(0)
{
-// Default constructor
+/// Default constructor
}
AliMUONSt1GeometryBuilder::AliMUONSt1GeometryBuilder(const AliMUONSt1GeometryBuilder& rhs)
: AliMUONVGeometryBuilder(rhs)
{
-// Protected copy constructor
+/// Protected copy constructor
AliFatal("Copy constructor is not implemented.");
}
//______________________________________________________________________________
-AliMUONSt1GeometryBuilder::~AliMUONSt1GeometryBuilder() {
-//
+AliMUONSt1GeometryBuilder::~AliMUONSt1GeometryBuilder()
+{
+/// Destructor
}
//______________________________________________________________________________
AliMUONSt1GeometryBuilder&
AliMUONSt1GeometryBuilder::operator = (const AliMUONSt1GeometryBuilder& rhs)
{
-// Protected assignement operator
+/// Protected assignement operator
// check assignement to self
if (this == &rhs) return *this;
//______________________________________________________________________________
void AliMUONSt1GeometryBuilder::CreateGeometry()
{
-// From AliMUONv1::CreateGeometry()
-// ---
+/// From AliMUONv1::CreateGeometry()
//********************************************************************
// Station 1 **
//______________________________________________________________________________
void AliMUONSt1GeometryBuilder::SetTransformations()
{
-// Defines the transformations for the station2 chambers.
-// ---
+/// Define the transformations for the station2 chambers.
Double_t zpos1= - AliMUONConstants::DefaultChamberZ(0);
SetTranslation(0, TGeoTranslation(0., 0., zpos1));
//______________________________________________________________________________
void AliMUONSt1GeometryBuilder::SetSensitiveVolumes()
{
-// Defines the sensitive volumes for station1 chambers.
-// ---
+/// Define the sensitive volumes for station1 chambers.
GetGeometry(0)->SetSensitiveVolume("S01G");
GetGeometry(1)->SetSensitiveVolume("S02G");
// $Id$
// Revision of includes 07/05/2004
-/// \ingroup base
+/// \ingroup sim
/// \class AliMUONSt1GeometryBuilder
/// \brief MUON Station1 coarse geometry construction class
///
#include "TArrayI.h"
#endif
+/// \cond CLASSIMP
+ClassImp(AliMUONSt1GeometryBuilderV2)
+/// \endcond
+
// Thickness Constants
const GReal_t AliMUONSt1GeometryBuilderV2::fgkHzPadPlane=0.0148/2.; //Pad plane
const GReal_t AliMUONSt1GeometryBuilderV2::fgkHzFoam = 2.503/2.; //Foam of mechanicalplane
const Int_t AliMUONSt1GeometryBuilderV2::fgkFR4BoxNameOffset=400;
const Int_t AliMUONSt1GeometryBuilderV2::fgkDaughterCopyNoOffset=1000;
-ClassImp(AliMUONSt1GeometryBuilderV2)
-
//______________________________________________________________________________
AliMUONSt1GeometryBuilderV2::AliMUONSt1GeometryBuilderV2(AliMUON* muon)
: AliMUONVGeometryBuilder(0, 1),
fMUON(muon)
{
+/// Standard constructor
+
// set path to mapping data files
if (! gSystem->Getenv("MINSTALL")) {
TString dirPath = gSystem->Getenv("ALICE_ROOT");
: AliMUONVGeometryBuilder(),
fMUON(0)
{
-// Default Constructor
-// --
+/// Default Constructor
}
//______________________________________________________________________________
AliMUONSt1GeometryBuilderV2::AliMUONSt1GeometryBuilderV2(const AliMUONSt1GeometryBuilderV2& rhs)
: AliMUONVGeometryBuilder(rhs)
{
-// Dummy copy constructor
+/// Dummy copy constructor
AliFatal("Copy constructor is not implemented.");
}
//______________________________________________________________________________
AliMUONSt1GeometryBuilderV2::~AliMUONSt1GeometryBuilderV2()
{
-// Destructor
+/// Destructor
}
AliMUONSt1GeometryBuilderV2&
AliMUONSt1GeometryBuilderV2::operator = (const AliMUONSt1GeometryBuilderV2& rhs)
{
+/// Assignment operator
+
// check assignement to self
if (this == &rhs) return *this;
TString
AliMUONSt1GeometryBuilderV2::QuadrantEnvelopeName(Int_t chamber, Int_t quadrant) const
{
-// Generate unique envelope name from chamber Id and quadrant number
-// ---
+/// Generate unique envelope name from chamber Id and quadrant number
return Form("%s%d", Form("%s%d",fgkQuadrantEnvelopeName,chamber), quadrant);
}
//______________________________________________________________________________
void AliMUONSt1GeometryBuilderV2::CreateHole()
{
-// Create all the elements found inside a foam hole
-// --
+/// Create all the elements found inside a foam hole
+
Int_t* idtmed = fMUON->GetIdtmed()->GetArray()-1099;
Int_t idAir = idtmed[1100]; // medium 1
//Int_t idCopper = idtmed[1109]; // medium 10 = copper
//______________________________________________________________________________
void AliMUONSt1GeometryBuilderV2::CreateDaughterBoard()
{
-// Create all the elements in a daughter board
-// --
+/// Create all the elements in a daughter board
+
Int_t* idtmed = fMUON->GetIdtmed()->GetArray()-1099;
Int_t idAir = idtmed[1100]; // medium 1
//Int_t idCopper = idtmed[1109]; // medium 10 = copper
//______________________________________________________________________________
void AliMUONSt1GeometryBuilderV2::CreateInnerLayers()
{
-// Create the layer of sensitive volumes with gas
-// and the copper layer.
-// --
+/// Create the layer of sensitive volumes with gas
+/// and the copper layer.
// Gas Medium
Int_t* idtmed = fMUON->GetIdtmed()->GetArray()-1099;
//______________________________________________________________________________
void AliMUONSt1GeometryBuilderV2::CreateQuadrant(Int_t chamber)
{
-// create the quadrant (bending and non-bending planes)
-// for the given chamber
-// --
+/// Create the quadrant (bending and non-bending planes)
+/// for the given chamber
CreateFrame(chamber);
Int_t segNumber,
const TVector2& dimensions)
{
-// create all the elements in the copper plane
-// --
+/// Create all the elements in the copper plane
Int_t* idtmed = fMUON->GetIdtmed()->GetArray()-1099;
Int_t idAir = idtmed[1100]; // medium 1
const TVector2& dimensions,
Int_t nofHoles)
{
-// Create a segment of a plane (this includes a foam layer,
-// holes in the foam to feed the kaptons through, kapton connectors
-// and the mother board.)
-// --
+/// Create a segment of a plane (this includes a foam layer,
+/// holes in the foam to feed the kaptons through, kapton connectors
+/// and the mother board.)
CreateFoamBox(segNumber,dimensions);
//______________________________________________________________________________
void AliMUONSt1GeometryBuilderV2::CreateFrame(Int_t chamber)
{
-// Create the non-sensitive elements of the frame for the <chamber>
-//
-//
-// Model and notation:
-//
-// The Quadrant volume name starts with SQ
-// The volume segments are numbered 00 to XX.
-//
-// OutTopFrame
-// (SQ02-16)
-// ------------
-// OutEdgeFrame / |
-// (SQ17-24) / | InVFrame (SQ00-01)
-// / |
-// | |
-// OutVFrame | _- -
-// (SQ25-39) | | InArcFrame (SQ42-45)
-// | |
-// -------------
-// InHFrame (SQ40-41)
-//
-//
-// 06 February 2003 - Overlapping volumes resolved.
-// One quarter chamber is comprised of three TUBS volumes: SQMx, SQNx, and SQFx,
-// where SQMx is the Quadrant Middle layer for chamber <x> ( posZ in [-3.25,3.25]),
-// SQNx is the Quadrant Near side layer for chamber <x> ( posZ in [-6.25,3-.25) ), and
-// SQFx is the Quadrant Far side layer for chamber <x> ( posZ in (3.25,6.25] ).
-//---
+/// Create the non-sensitive elements of the frame for the \a chamber
+///
+/// Model and notation: \n
+/// \n
+/// The Quadrant volume name starts with SQ \n
+/// The volume segments are numbered 00 to XX \n
+/// \n
+/// OutTopFrame \n
+/// (SQ02-16) \n
+/// ------------ \n
+/// OutEdgeFrame / | \n
+/// (SQ17-24) / | InVFrame (SQ00-01) \n
+/// / | \n
+/// | | \n
+/// OutVFrame | _- - \n
+/// (SQ25-39) | | InArcFrame (SQ42-45) \n
+/// | | \n
+/// ------------- \n
+/// InHFrame (SQ40-41) \n
+/// \n
+/// \n
+/// 06 February 2003 - Overlapping volumes resolved. \n
+/// One quarter chamber is comprised of three TUBS volumes: SQMx, SQNx, and SQFx,
+/// where SQMx is the Quadrant Middle layer for chamber \a chamber ( posZ in [-3.25,3.25]),
+/// SQNx is the Quadrant Near side layer for chamber \a chamber ( posZ in [-6.25,3-.25) ), and
+/// SQFx is the Quadrant Far side layer for chamber \a chamber ( posZ in (3.25,6.25] ).
const Float_t kNearFarLHC=2.4; // Near and Far TUBS Origin wrt LHC Origin
//______________________________________________________________________________
void AliMUONSt1GeometryBuilderV2::PlaceInnerLayers(Int_t chamber)
{
-// Place the gas and copper layers for the specified chamber.
-// --
+/// Place the gas and copper layers for the specified chamber.
// Rotation Matrices
Int_t rot1, rot2, rot3, rot4;
void AliMUONSt1GeometryBuilderV2::PlaceSector(AliMpSector* sector,SpecialMap specialMap,
const TVector3& where, Bool_t reflectZ, Int_t chamber)
{
-// Place all the segments in the mother volume, at the position defined
-// by the sector's data.
-// --
+/// Place all the segments in the mother volume, at the position defined
+/// by the sector's data.
+
+/// \cond SKIP
static Int_t segNum=1;
Int_t sgn;
}// end of special motif case
}
}
+/// \endcond
}
//______________________________________________________________________________
TString AliMUONSt1GeometryBuilderV2::GasVolumeName(const TString& name, Int_t chamber) const
{
-// Inserts the chamber number into the name.
-// ---
+/// Insert the chamber number into the name.
TString newString(name);
return newString;
}
-/*
-//______________________________________________________________________________
-Bool_t AliMUONSt1GeometryBuilderV2::IsInChamber(Int_t ich, Int_t volGid) const
-{
-// True if volume <volGid> is part of the sensitive
-// volumes of chamber <ich>
-// ---
- for (Int_t i = 0; i < fChamberV2[ich]->GetSize(); i++) {
- if (fChamberV2[ich]->At(i) == volGid) return kTRUE;
- }
- return kFALSE;
-}
-*/
-
-//
-// protected methods
-//
-
-/*
-//______________________________________________________________________________
-Int_t AliMUONSt1GeometryBuilderV2::GetChamberId(Int_t volId) const
-{
-// Check if the volume with specified volId is a sensitive volume (gas)
-// of some chamber and returns the chamber number;
-// if not sensitive volume - return 0.
-// ---
-
- for (Int_t i = 1; i <=2; i++)
- if (IsInChamber(i-1,volId)) return i;
-
- for (Int_t i = 3; i <= AliMUONConstants::NCh(); i++)
- if (volId==((AliMUONChamber*)(*fChambers)[i-1])->GetGid()) return i;
-
- return 0;
-}
-*/
-
//
// public methods
//
//______________________________________________________________________________
void AliMUONSt1GeometryBuilderV2::CreateMaterials()
{
+/// Define materials specific to station 1
+
// Materials and medias defined in MUONv1:
//
// AliMaterial( 9, "ALUMINIUM$", 26.98, 13., 2.7, 8.9, 37.2);
//______________________________________________________________________________
void AliMUONSt1GeometryBuilderV2::CreateGeometry()
{
-// Create the detailed GEANT geometry for the dimuon arm station1
-// --
+/// Create the detailed GEANT geometry for the dimuon arm station1
+
AliDebug(1,"Called");
// Define chamber volumes as virtual
//______________________________________________________________________________
void AliMUONSt1GeometryBuilderV2::SetTransformations()
{
-// Defines the transformations for the station2 chambers.
-// ---
+/// Define the transformations for the station2 chambers.
if (gAlice->GetModule("SHIL")) {
SetMotherVolume(0, "YOUT1");
//______________________________________________________________________________
void AliMUONSt1GeometryBuilderV2::SetSensitiveVolumes()
{
-// Defines the sensitive volumes for station2 chambers.
-// ---
+/// Define the sensitive volumes for station2 chambers.
GetGeometry(0)->SetSensitiveVolume("SA1G");
GetGeometry(0)->SetSensitiveVolume("SB1G");
// $Id$
// Revision of includes 07/05/2004
//
-/// \ingroup base
+/// \ingroup sim
/// \class AliMUONSt1GeometryBuilderV2
/// \brief MUON Station1 detailed geometry construction class
///
TString FR4BoxName(Int_t segNumber) const;
TString GasVolumeName(const TString& name, Int_t chamber) const;
- void AddChamberGid(Int_t id,Int_t volName,Int_t idx);
- //Bool_t IsInChamber(Int_t ich, Int_t volGid) const;
-
- GReal_t TotalHzPlane() const ; // Total mechanical plane half Size
- GReal_t TotalHzDaughter() const ; // Total daughter plane half Size
- GReal_t TotalHz() const ; // Total plane half Size
+ GReal_t TotalHzPlane() const ;
+ GReal_t TotalHzDaughter() const ;
+ GReal_t TotalHz() const ;
// Data members
//
// inline functions
+/// Return total mechanical plane half Size
inline GReal_t AliMUONSt1GeometryBuilderV2::TotalHzPlane() const
//{ return fgkHzPadPlane + fgkHzFoam + fgkHzFR4; }
{ return fgkHzFoam + fgkHzFR4; }
+/// Return total daughter plane half Size
inline GReal_t AliMUONSt1GeometryBuilderV2::TotalHzDaughter() const
{ return fgkHzBergPlastic + fgkHzDaughter; }
+/// Return total plane half Size
inline GReal_t AliMUONSt1GeometryBuilderV2::TotalHz() const
{ return TotalHzPlane() + TotalHzDaughter(); }
+/// Return middle quadrant layer name for chamber \a chamber
inline TString AliMUONSt1GeometryBuilderV2::QuadrantMLayerName(Int_t chamber) const
{ return Form("%s%d",fgkQuadrantMLayerName,chamber); }
+/// Return nearer quadrant layer name for chamber \a chamber
inline TString AliMUONSt1GeometryBuilderV2::QuadrantNLayerName(Int_t chamber) const
{ return Form("%s%d",fgkQuadrantNLayerName,chamber); }
+/// Return farther quadrant layer name for chamber \a chamber
inline TString AliMUONSt1GeometryBuilderV2::QuadrantFLayerName(Int_t chamber) const
{ return Form("%s%d",fgkQuadrantFLayerName,chamber); }
+/// Return plane segment name for segment \a segNumber
inline TString AliMUONSt1GeometryBuilderV2::PlaneSegmentName(Int_t segNumber) const
{ return Form("S%.3d", segNumber); }
+/// Return foam box name for segment \a segNumber
inline TString AliMUONSt1GeometryBuilderV2::FoamBoxName(Int_t segNumber) const
{ return Form("S%.3d", segNumber + fgkFoamBoxNameOffset); }
+/// Return FR4 box name for segment \a segNumber
inline TString AliMUONSt1GeometryBuilderV2::FR4BoxName(Int_t segNumber) const
{ return Form("S%.3d", segNumber + fgkFR4BoxNameOffset); }
:fDelta(delta),
fRotAngle(rotAngle)
{
-// normal constructor
+/// Standard constructor
}
//__________________________________________________________________________
:fDelta(TVector2(0.,0.)),
fRotAngle(0.)
{
-// default constructor
+/// Default constructor
}
//__________________________________________________________________________
fRotAngle(src.fRotAngle)
{
-// copy constructor
+/// Copy constructor
}
//__________________________________________________________________________
AliMUONSt1SpecialMotif::~AliMUONSt1SpecialMotif()
{
-// destructor
+/// Destructor
}
AliMUONSt1SpecialMotif(const TVector2& delta,Double_t rotAngle=0.);
AliMUONSt1SpecialMotif(const AliMUONSt1SpecialMotif& src);
virtual ~AliMUONSt1SpecialMotif();
-
+
+ /// Return offset
TVector2 GetDelta() const {return fDelta;}
+
+ /// Return rotation angle in degrees (0 = vertical)
Double_t GetRotAngle() const {return fRotAngle;}
private:
#include "AliMUONGeometryModule.h"
#include "AliMUONGeometryEnvelopeStore.h"
+/// \cond CLASSIMP
ClassImp(AliMUONSt2GeometryBuilder)
+/// \endcond
//______________________________________________________________________________
AliMUONSt2GeometryBuilder::AliMUONSt2GeometryBuilder(AliMUON* muon)
// $Id$
// Revision of includes 07/05/2004
//
-/// \ingroup base
+/// \ingroup sim
/// \class AliMUONSt2GeometryBuilder
/// \brief MUON Station2 coarse geometry construction class
///
#include "AliMUONConstants.h"
#define PI 3.14159
+
+/// \cond CLASSIMP
ClassImp(AliMUONSt2GeometryBuilderV2)
+/// \endcond
//______________________________________________________________________________
AliMUONSt2GeometryBuilderV2::AliMUONSt2GeometryBuilderV2(AliMUON* muon)
// $Id$
// Revision of includes 07/05/2004
//
-/// \ingroup base
+/// \ingroup sim
/// \class AliMUONSt2GeometryBuilderV2
/// \brief MUON Station2 detailed geometry construction class
///
/* $Id$ */
-//*********************************************************
-// Segmentation classes for slat modules
-// This class works with local coordinates
-// of the slats via the class AliMUONGeometrySegmentation
-// This class contains the size of the slats and the
-// and the differents PCB densities.
-// (from old AliMUONSegmentationSlatModule)
-// Gines, Subatech, Nov04
-// Add electronics mapping
-// Christian, Subatech, Mai 05
-//*********************************************************
+/// \class AliMUONSt345SlatSegmentation
+/// \brief Segmentation classes for slat modules
+///
+/// This class works with local coordinates
+/// of the slats via the class AliMUONGeometrySegmentation
+/// This class contains the size of the slats and the
+/// and the differents PCB densities.
+/// (from old AliMUONSegmentationSlatModule)
+///
+/// Add electronics mapping - Christian, Subatech, Mai 05
+///
+/// \author Gines Martinez, Subatech, Nov04
#include <TArrayI.h>
#include <TArrayF.h>
#include "AliMUONSt345SlatSegmentation.h"
#include "AliLog.h"
+/// \cond CLASSIMP
ClassImp(AliMUONSt345SlatSegmentation)
-
+/// \endcond
AliMUONSt345SlatSegmentation::AliMUONSt345SlatSegmentation()
: AliMUONVGeometryDESegmentation(),
fIymax(0),
fInitDone(kFALSE)
{
- // default constructor
+/// Default constructor
AliDebug(1,Form("this=%p default (empty) ctor",this));
}
fInitDone(kFALSE)
{
- // Non default constructor
+/// Standard constructor
+
fNsec = 4; // 4 sector densities at most per slat
fNDiv = new TArrayI(fNsec);
fDpxD = new TArrayF(fNsec);
}
//----------------------------------------------------------------------
-AliMUONSt345SlatSegmentation::AliMUONSt345SlatSegmentation(const AliMUONSt345SlatSegmentation& rhs)
-: AliMUONVGeometryDESegmentation(rhs),
- fBending(0),
- fId(0),
- fDpx(0),
- fDpy(0),
- fNpx(999999),
- fNpy(999999),
- fWireD(0.25),
- fXhit(0.),
- fYhit(0.),
- fIx(0),
- fIy(0),
- fX(0.),
- fY(0.),
- fIxmin(0),
- fIxmax(0),
- fIymin(0),
- fIymax(0)
-{
-// Copy constructor
- AliFatal("Not implemented");
-}
-//----------------------------------------------------------------------
AliMUONSt345SlatSegmentation::~AliMUONSt345SlatSegmentation()
{
- // Destructor
+/// Destructor
AliDebug(1, Form("dtor this = %p", this));
delete fDpxD;
delete fDpyD;
}
-//----------------------------------------------------------------------
-AliMUONSt345SlatSegmentation& AliMUONSt345SlatSegmentation::operator=(const AliMUONSt345SlatSegmentation& rhs)
-{
- // Protected assignement operator
- if (this == &rhs) return *this;
- AliFatal("Not implemented.");
- return *this;
-}
-
//------------------------------------------------------------------------
Float_t AliMUONSt345SlatSegmentation::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
+/// Returns the square of the distance between 1 pad
+/// labelled by its Channel numbers and a coordinate
+
Float_t x,y;
GetPadC(iX,iY,x,y);
return (x-X)*(x-X) + (y-Y)*(y-Y);
//____________________________________________________________________________
Float_t AliMUONSt345SlatSegmentation::Dpx(Int_t isec) const
{
- // Return x-strip width
+/// Return x-strip width
+
return (*fDpxD)[isec];
}
//____________________________________________________________________________
Float_t AliMUONSt345SlatSegmentation::Dpy(Int_t isec) const
{
- // Return y-strip width
+/// Return y-strip width
+
return (*fDpyD)[isec];
}
//_____________________________________________________________________________
Float_t AliMUONSt345SlatSegmentation::GetAnod(Float_t xhit) const
{
- // Returns for a hit position xhit the position of the nearest anode wire
+/// Returns for a hit position xhit the position of the nearest anode wire
+
Float_t wire= (xhit>0)? Int_t(xhit/fWireD)+0.5:Int_t(xhit/fWireD)-0.5;
return fWireD*wire;
}
//_____________________________________________________________________________
Bool_t AliMUONSt345SlatSegmentation::HasPad(Int_t ix, Int_t iy)
{
-// Return true if pas with given indices exists
+/// Return true if pas with given indices exists
if ( ix < 1 || ix > Npx() || iy < 1 || iy > Npy() )
{
//--------------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
{
- // Returns real coordinates (x,y) for given pad coordinates (ix,iy)
+/// Returns real coordinates (x,y) for given pad coordinates (ix,iy)
if (ix < 1 || ix > Npx() || iy < 1 || iy > Npy() ){
AliWarning(Form("ix %d or iy %d out of boundaries: Npx=%d and Npy=%d",ix, iy, Npx(), Npy()));
//_____________________________________________________________________________
void AliMUONSt345SlatSegmentation::GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
{
-// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
+/// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
// Find sector isec
Int_t isec=-1;
//-------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::GetPadI(Float_t x, Float_t y , Float_t /*z*/, Int_t &ix, Int_t &iy)
{
-// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
+/// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
GetPadI(x, y, ix, iy);
}
//_______________________________________________________________
void AliMUONSt345SlatSegmentation::SetPadDivision(Int_t ndiv[4])
{
- // Defines the pad size perp. to the anode wire (y) for different sectors.
- // Pad sizes are defined as integral fractions ndiv of a basis pad size
- // fDpx
- //
+/// Defines the pad size perp. to the anode wire (y) for different sectors.
+/// Pad sizes are defined as integral fractions ndiv of a basis pad size
+/// fDpx
+
for (Int_t i=0; i<4; i++) {
(*fNDiv)[i]=ndiv[i];
}
//____________________________________________________________________________
void AliMUONSt345SlatSegmentation::SetPadSize(Float_t p1, Float_t p2)
{
- // Sets the padsize
+/// Sets the padsize
+
fDpx=p1;
fDpy=p2;
}
//_______________________________________________________________
void AliMUONSt345SlatSegmentation::SetPcbBoards(Int_t n[4])
{
- //
- // Set PcbBoard segmentation zones for each density
- // n[0] slat type parameter
- // n[1] PcbBoards for highest density sector fNDiv[1] etc ...
+/// Set PcbBoard segmentation zones for each density
+/// n[0] slat type parameter
+/// n[1] PcbBoards for highest density sector fNDiv[1] etc ...
fRtype = n[0];
n[0] = 0;
//-------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::SetPad(Int_t ix, Int_t iy)
{
- //
- // Sets virtual pad coordinates, needed for evaluating pad response
- // outside the tracking program
+/// Sets virtual pad coordinates, needed for evaluating pad response
+/// outside the tracking program
+
GetPadC(ix,iy,fX,fY);
fSector=Sector(ix,iy);
}
//---------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::SetHit(Float_t x, Float_t y)
{
- // Set current hit
- //
+/// Set current hit
+
fXhit = x;
fYhit = y;
//----------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
{
- // Set current hit
+/// Set current hit
SetHit(xhit, yhit);
}
//----------------------------------------------------------
void AliMUONSt345SlatSegmentation::FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
{
-// Initialises iteration over pads for charge distribution algorithm
-//
+/// Initialises iteration over pads for charge distribution algorithm
+
//
// Find the wire position (center of charge distribution)
Float_t x0a = GetAnod(xhit);
//----------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::FirstPad(Float_t xhit, Float_t yhit, Float_t /*zhit*/, Float_t dx, Float_t dy)
{
-// Initialises iteration over pads for charge distribution algorithm
+/// Initialises iteration over pads for charge distribution algorithm
FirstPad(xhit, yhit, dx, dy);
}
//----------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::NextPad()
{
- // Stepper for the iteration over pads
- //
+/// Stepper for the iteration over pads
+
// Step to next pad in the integration region
// step from left to right
if (fIx != fIxmax) {
//-------------------------------------------------------------------------
Int_t AliMUONSt345SlatSegmentation::MorePads()
{
- // Stopping condition for the iterator over pads
- //
+/// Stopping condition for the iterator over pads
+
// Are there more pads in the integration region
return (fIx != -999 || fIy != -999);
//--------------------------------------------------------------------------
Int_t AliMUONSt345SlatSegmentation::Sector(Int_t ix, Int_t iy)
{
- //
- // Determine segmentation zone from pad coordinates
- //
+/// Determine segmentation zone from pad coordinates
+
Int_t isec = -1;
for (Int_t i = 0; i < fNsec; i++) {
if (ix <= fNpxS[i]) {
void AliMUONSt345SlatSegmentation::
IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
{
- // Returns integration limits for current pad
- //
+/// Returns integration limits for current pad
+
x1=fXhit-fX-Dpx(fSector)/2.;
x2=x1+Dpx(fSector);
y1=fYhit-fY-Dpy(fSector)/2.;
void AliMUONSt345SlatSegmentation::
Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])
{
- // Returns list of next neighbours for given Pad (iX, iY)
+/// Returns list of next neighbours for given Pad (iX, iY)
+
Int_t i=0;
// step right
if (iX+1 <= fNpx) {
//--------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::Init(Int_t detectionElementId)
{
- //
- // Fill the arrays fCx (x-contour) and fNpxS (ix-contour) for each sector
- // These arrays help in converting from real to pad co-ordinates and
- // vice versa
- //
- // Segmentation is defined by rectangular modules approximating
- // concentric circles as shown below
- //
+/// Fill the arrays fCx (x-contour) and fNpxS (ix-contour) for each sector
+/// These arrays help in converting from real to pad co-ordinates and
+/// vice versa
+///
+/// Segmentation is defined by rectangular modules approximating
+/// concentric circles as shown below
+
// PCB module size in cm
// printf("\n Initialise Segmentation SlatModule \n");
/// \ingroup base
/// \class AliMUONSt345SlatSegmentation
/// \brief Segmentation for slat modules
-///
-///*********************************************************
-/// Segmentation classes for slat modules
-/// This class works with local coordinates
-/// of the slats via the class AliMUONGeometrySegmentation
-/// This class contains the size of the slats and the
-/// and the differents PCB densities.
-///*********************************************************
#include "AliMUONVGeometryDESegmentation.h"
virtual ~AliMUONSt345SlatSegmentation();
virtual Float_t Distance2AndOffset(Int_t iX, Int_t iY, Float_t X, Float_t Y, Int_t * dummy); // Distance between 1 pad and a position
- virtual Float_t Dpx() const {return fDpx;} // Pad size in x
- virtual Float_t Dpy() const {return fDpy;} // Pad size in y
+ virtual Float_t Dpx() const {return fDpx;} ///< Pad size in x
+ virtual Float_t Dpy() const {return fDpy;} ///< Pad size in y
virtual Float_t Dpx(Int_t isec) const; // Pad size in x by Sector
virtual Float_t Dpy(Int_t isec) const; // Pad size in y by Sector
- virtual void Draw(const char */*opt*/ = "") {} // Not implemented
+ virtual void Draw(const char */*opt*/ = "") {} ///< Not implemented
virtual void FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy); // Initialisation for pad iteration
virtual void FirstPad(Float_t xhit, Float_t yhit, Float_t zhit, Float_t dx, Float_t dy);
- virtual Bool_t HasPad(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/) { return true; }
+ virtual Bool_t HasPad(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/) { return true; } ///< Not implemented
virtual Bool_t HasPad(Int_t ix, Int_t iy);
- virtual AliMUONGeometryDirection GetDirection() { return kDirUndefined; }
- virtual const AliMpVSegmentation* GetMpSegmentation() const { return 0; }
+ virtual AliMUONGeometryDirection GetDirection() { return kDirUndefined; } ///< Not implemented
+ virtual const AliMpVSegmentation* GetMpSegmentation() const { return 0; } ///< Not implemented
virtual Float_t GetAnod(Float_t xhit) const; // Anod wire coordinate closest to xhit
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);
virtual void GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y);
+ /// Returns real coordinates (x,y,z) for given pad coordinates (ix,iy)
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);}
virtual void IntegrationLimits(Float_t& x1, Float_t& x2, Float_t& y1, Float_t& y2); //Current integration limits
- virtual Int_t ISector() {return fSector;} // Current Pad during Integration (current sector)
- virtual Int_t Ix() {return fIx;} // x-coordinate
- virtual Int_t Iy() {return fIy;} // y-coordinate
+ virtual Int_t ISector() {return fSector;} ///< Current Pad during Integration (current sector)
+ virtual Int_t Ix() {return fIx;} ///< x-coordinate
+ virtual Int_t Iy() {return fIy;} ///< y-coordinate
virtual Int_t MorePads(); // Condition
virtual void Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10]); // Get next neighbours
virtual void NextPad(); // Stepper
- virtual Int_t Npx() const {return fNpx;} // Maximum number of Pads in x
- virtual Int_t Npy() const {return fNpy;} // Maximum number of Pads in y
+ virtual Int_t Npx() const {return fNpx;} ///< Maximum number of Pads in x
+ virtual Int_t Npy() const {return fNpy;} ///< Maximum number of Pads in y
- virtual void SetDAnod(Float_t D) {fWireD = D;}; // Anod pitch
- virtual Int_t Sector(Int_t ix, Int_t iy); // Calculate sector from pad coordinates
- virtual void SetHit(Float_t xhit, Float_t yhit); // Set hit position
+ virtual void SetDAnod(Float_t D) {fWireD = D;}; ///< Anod pitch
+ virtual Int_t Sector(Int_t ix, Int_t iy); // Calculate sector from pad coordinates
+ virtual void SetHit(Float_t xhit, Float_t yhit); // Set hit position
virtual void SetHit(Float_t xhit, Float_t yhit, Float_t zhit);
- virtual void SetId(Int_t id) {fId=id;} // Setting detection element
+ virtual void SetId(Int_t id) {fId=id;} ///< Setting detection element
virtual void SetPad(Int_t ix, Int_t iy); // Set pad position
virtual void SetPadDivision(Int_t ndiv[4]); // Set Slat Segmentation Parameters
virtual void SetPadSize(Float_t p1, Float_t p2); // Pad size Dx*Dy
virtual void SetPcbBoards(Int_t n[4]); // Set Segmentation Zones (PCB Boards)
// The following function could be obsolet for this class, but they are pure virtual in AliSegmentation
- virtual void GetNParallelAndOffset(Int_t /*iX*/, Int_t /*iY*/, Int_t */*Nparallel*/, Int_t */*Offset*/) {};
- virtual Int_t SigGenCond(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/){return 0;} ; // Signal Generation Condition during Stepping
- virtual void SigGenInit(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/){}; // Initialise signal gneration at coord (x,y,z)
- virtual void GiveTestPoints(Int_t &/*n*/, Float_t * /*x*/, Float_t */*y*/) const{}; // Test points for auto calibration
- virtual void SetCorrFunc(Int_t /*dum*/, TF1* /*func*/){}; // Function for systematic corrections, Set the correction function
- virtual TF1* CorrFunc(Int_t) const {return 0x0;} // Get the correction Function
- virtual Int_t Sector(Float_t /*x*/, Float_t /*y*/) {return 1;}
+ virtual void GetNParallelAndOffset(Int_t /*iX*/, Int_t /*iY*/, Int_t */*Nparallel*/, Int_t */*Offset*/) {}; ///< Not implemented
+ virtual Int_t SigGenCond(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/){return 0;} ; ///< Signal Generation Condition during Stepping
+ virtual void SigGenInit(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/){}; ///< Initialise signal gneration at coord (x,y,z)
+ virtual void GiveTestPoints(Int_t &/*n*/, Float_t * /*x*/, Float_t */*y*/) const{}; ///< Test points for auto calibration
+ virtual void SetCorrFunc(Int_t /*dum*/, TF1* /*func*/){}; ///< Function for systematic corrections, Set the correction function
+ virtual TF1* CorrFunc(Int_t) const {return 0x0;} ///< Get the correction Function
+ virtual Int_t Sector(Float_t /*x*/, Float_t /*y*/) {return 1;} ///< Current sector
virtual void Init(Int_t detectionElementId); // Initialisation
// Current integration limits
#include "Riostream.h"
+/// \cond CLASSIMP
ClassImp(AliMUONSt345SlatSegmentationV2)
+/// \endcond
namespace
{
fXhit(FMAX),
fYhit(FMAX)
{
-// Default ctor
+/// Default ctor
AliDebug(1,Form("this=%p default (empty) ctor",this));
}
fXhit(FMAX),
fYhit(FMAX)
{
- //
- // Normal ctor.
- //
+/// Normal ctor.
fSlatSegmentation = dynamic_cast<AliMpSlatSegmentation*>(segmentation);
if (fSlatSegmentation)
fSlatSegmentation));
}
-//______________________________________________________________________________
-AliMUONSt345SlatSegmentationV2::AliMUONSt345SlatSegmentationV2(
- const AliMUONSt345SlatSegmentationV2& right)
- : AliMUONVGeometryDESegmentation(right)
-{
-/// Protected copy constructor (not implemented)
-
- AliFatal("Copy constructor not provided.");
-}
-
//_____________________________________________________________________________
AliMUONSt345SlatSegmentationV2::~AliMUONSt345SlatSegmentationV2()
{
-// Destructor
+/// Destructor
AliDebug(1,Form("dtor this=%p",this));
delete fPadIterator;
}
-//______________________________________________________________________________
-AliMUONSt345SlatSegmentationV2&
-AliMUONSt345SlatSegmentationV2::operator=(const AliMUONSt345SlatSegmentationV2& right)
-{
-/// Protected assignement operator (not implemented)
-
- // check assignement to self
- if (this == &right) return *this;
-
- AliFatal("Assignement operator not provided.");
-
- return *this;
-}
-
//_____________________________________________________________________________
TF1*
AliMUONSt345SlatSegmentationV2::CorrFunc(Int_t /*isec*/) const
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
return 0x0;
Float_t
AliMUONSt345SlatSegmentationV2::Distance2AndOffset(Int_t /*iX*/, Int_t /*iY*/,
Float_t /*x*/, Float_t /*y*/, Int_t* /*dummy*/){
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
return 0.0;
void
AliMUONSt345SlatSegmentationV2::Draw(Option_t* /*opt*/)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
}
Float_t
AliMUONSt345SlatSegmentationV2::Dpx() const
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
return 0.0;
Float_t
AliMUONSt345SlatSegmentationV2::Dpy() const
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
return 0.0;
Float_t
AliMUONSt345SlatSegmentationV2::Dpx(int ipcb) const
{
-// Get pad size in x
+/// Get pad size in x
AliMpPCB* pcb = fSlat->GetPCB(ipcb);
if (!pcb)
Float_t
AliMUONSt345SlatSegmentationV2::Dpy(int ipcb) const
{
-// Get pad size in y
+/// Get pad size in y
AliMpPCB* pcb = fSlat->GetPCB(ipcb);
if (!pcb)
AliMUONSt345SlatSegmentationV2::FirstPad(Float_t xhit, Float_t yhit,Float_t /*zhit*/,
Float_t dx, Float_t dy)
{
- // OK. We will do it in 2 steps. First get the area over which to
- // iterate, based on hit coordinates and (dx,dy). This first step
- // has nothing to do with segmentation in the first place, but with
- // how we simulate the fact that at some point the charge is shared
- // amongst several pads.
- // The second step is the actual pad iteration and is handled by
- // a specific class (which has to do only with iteration...)
- //
- // FIXME: this method should not be here in the first place, IMHO.
- //
+/// OK. We will do it in 2 steps. First get the area over which to
+/// iterate, based on hit coordinates and (dx,dy). This first step
+/// has nothing to do with segmentation in the first place, but with
+/// how we simulate the fact that at some point the charge is shared
+/// amongst several pads.
+/// The second step is the actual pad iteration and is handled by
+/// a specific class (which has to do only with iteration...)
+///
+/// \todo FIXME: this method should not be here in the first place, IMHO.
// Find the wire position (center of charge distribution)
Float_t xwire = GetAnod(xhit);
Float_t
AliMUONSt345SlatSegmentationV2::GetAnod(Float_t xhit) const
{
- // Gets the x-coordinate of the wire which is the closest to xhit.
+/// Gets the x-coordinate of the wire which is the closest to xhit.
Int_t n = Int_t(xhit/AliMUONConstants::Pitch());
Float_t wire = (xhit>0) ? n+0.5 : n-0.5;
AliMUONGeometryDirection
AliMUONSt345SlatSegmentationV2::GetDirection()
{
-// Not implemented
+/// Not implemented
//AliWarning("Not Implemented");
return kDirUndefined;
const AliMpVSegmentation*
AliMUONSt345SlatSegmentationV2::GetMpSegmentation() const
{
-// Returns the mapping segmentation
-// (provides access to electronics info)
+/// Returns the mapping segmentation
+/// (provides access to electronics info)
return fSlatSegmentation;
}
AliMUONSt345SlatSegmentationV2::GetNParallelAndOffset(Int_t /*iX*/, Int_t /*iY*/,
Int_t* /*Nparallel*/, Int_t* /*Offset*/)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
}
AliMUONSt345SlatSegmentationV2::GetPadC(Int_t ix, Int_t iy,
Float_t& x, Float_t& y, Float_t& z)
{
-// Transform from pad to real coordinates
+/// Transform from pad to real coordinates
z = 0;
GetPadC(ix,iy,x,y);
AliMUONSt345SlatSegmentationV2::GetPadC(Int_t ix, Int_t iy,
Float_t& x, Float_t& y)
{
-// Transform from pad to real coordinates
+/// Transform from pad to real coordinates
AliMpPad pad =
fSlatSegmentation->PadByIndices(AliMpIntPair(ix,iy),kTRUE);
AliMUONSt345SlatSegmentationV2::GetPadI(Float_t x, Float_t y, Float_t /*z*/,
Int_t& ix, Int_t& iy)
{
-// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
+/// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
GetPadI(x,y,ix,iy);
}
AliMUONSt345SlatSegmentationV2::GetPadI(Float_t x, Float_t y,
Int_t& ix, Int_t& iy)
{
-// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
+/// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
AliMpPad pad = fSlatSegmentation->PadByPosition(TVector2(x,y), kTRUE);
AliMUONSt345SlatSegmentationV2::GiveTestPoints(Int_t& /*n*/,
Float_t* /*x*/, Float_t* /*y*/) const
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
}
Bool_t
AliMUONSt345SlatSegmentationV2::HasPad(Float_t x, Float_t y, Float_t z)
{
-// Returns true if a pad exists in the given position
+/// Returns true if a pad exists in the given position
Int_t ix, iy;
GetPadI(x,y,z,ix,iy);
Bool_t
AliMUONSt345SlatSegmentationV2::HasPad(Int_t ix, Int_t iy)
{
-// Returns true if a pad with given indices exists
+/// Returns true if a pad with given indices exists
return fSlatSegmentation->HasPad(AliMpIntPair(ix,iy));
}
AliMUONSt345SlatSegmentationV2::IntegrationLimits(Float_t& x1, Float_t& x2,
Float_t& y1, Float_t& y2)
{
- //
- // Returns integration limits for current pad
- //
+/// Returns integration limits for current pad
// x1 = fXhit - fX - Dpx(fSector)/2.;
// x2 = x1 + Dpx(fSector);
Int_t
AliMUONSt345SlatSegmentationV2::ISector()
{
- // FIXME: remove the usage of ISector from all the code.
+/// \todo FIXME: remove the usage of ISector from all the code.
+
return -10;
}
Int_t
AliMUONSt345SlatSegmentationV2::Ix()
{
-// Current pad cursor during disintegration
-// x, y-coordinate
+/// Current pad cursor during disintegration
+/// x, y-coordinate
if ( fPadIterator )
{
Int_t
AliMUONSt345SlatSegmentationV2::Iy()
{
-// Current pad cursor during disintegration
-// x, y-coordinate
+/// Current pad cursor during disintegration
+/// x, y-coordinate
if ( fPadIterator )
{
Int_t
AliMUONSt345SlatSegmentationV2::MorePads()
{
+/// Iterate over pads - condition
+
return (fPadIterator && !fPadIterator->IsDone());
}
AliMUONSt345SlatSegmentationV2::Neighbours(Int_t iX, Int_t iY, Int_t* Nlist,
Int_t Xlist[10], Int_t Ylist[10])
{
- // Find pad at (ix,iy) for which we'll search neighbours.
+/// Find pad at (ix,iy) for which we'll search neighbours.
+
AliMpPad pad =
fSlatSegmentation->PadByIndices(AliMpIntPair(iX,iY),kTRUE);
void
AliMUONSt345SlatSegmentationV2::NextPad()
{
-// Iterate over pads - stepper
+/// Iterate over pads - stepper
if ( fPadIterator )
{
Int_t
AliMUONSt345SlatSegmentationV2::Npx() const
{
-// Maximum number of Pads in x
+/// Maximum number of Pads in x
return fSlatSegmentation->MaxPadIndexX()+1;
}
Int_t
AliMUONSt345SlatSegmentationV2::Npy() const
{
-// Maximum number of Pads in y
+/// Maximum number of Pads in y
return fSlatSegmentation->MaxPadIndexY()+1;
}
void
AliMUONSt345SlatSegmentationV2::Print(Option_t* /*opt*/) const
{
-// Printing
+/// Printing
cout << "DetElemId=" << fDetElemId << " PlaneType="
<< fPlaneType << " Npx,Npy=" << Npx() << "," << Npy() << " fSlat=" << fSlat
Int_t
AliMUONSt345SlatSegmentationV2::Sector(Int_t ix, Int_t /*iy*/)
{
-// Calculate sector from pad coordinates
+/// Calculate sector from pad coordinates
return fSlat->FindPCBIndex(ix);
}
Int_t
AliMUONSt345SlatSegmentationV2::Sector(Float_t x, Float_t y)
{
-// Calculate sector from pad coordinates
+/// Calculate sector from pad coordinates
return fSlat->FindPCBIndex(x,y);
}
void
AliMUONSt345SlatSegmentationV2::SetCorrFunc(Int_t /*isec*/,TF1* /*func*/)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
}
void
AliMUONSt345SlatSegmentationV2::SetDAnod(float /*d*/)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
}
void
AliMUONSt345SlatSegmentationV2::SetHit(Float_t x, Float_t y, Float_t)
{
-// Set hit position
-// Sets virtual hit position, needed for evaluating pad response
-// outside the tracking program
+/// Set hit position
+/// Sets virtual hit position, needed for evaluating pad response
+/// outside the tracking program
fXhit = x;
fYhit = y;
void
AliMUONSt345SlatSegmentationV2::SetPad(Int_t ix, Int_t iy)
{
-// Set pad position.
-// Sets virtual pad coordinates, needed for evaluating pad response
-// outside the tracking program.
+/// Set pad position.
+/// Sets virtual pad coordinates, needed for evaluating pad response
+/// outside the tracking program.
fCurrentPad =
fSlatSegmentation->PadByIndices(AliMpIntPair(ix,iy),kTRUE);
void
AliMUONSt345SlatSegmentationV2::SetPadSize(float /*p1*/,float /*p2*/)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
}
Int_t
AliMUONSt345SlatSegmentationV2::SigGenCond(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
return 0;
void
AliMUONSt345SlatSegmentationV2::SigGenInit(Float_t,Float_t,Float_t)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
}
void SetDAnod(float d);
- void Init(int /*chamber*/) {}
+ void Init(int /*chamber*/) {} ///< Not implemented
void Draw(Option_t* opt = "");
Float_t Dpx() const;
const AliMpVSegmentation* GetMpSegmentation() const;
- /// to be deprecated. Use the one below w/o z instead.
+ /// \deprecated. Use the one below w/o z instead.
void GetPadC(Int_t ix, Int_t iy, Float_t& x, Float_t& y, Float_t& z);
/// From pad indices to coordinates (cm).
#include "AliMUONTransientDigit.h"
#include "AliLog.h"
+/// \cond CLASSIMP
ClassImp(AliMUONTransientDigit)
+/// \endcond
//____________________________________________________________________________
AliMUONTransientDigit::AliMUONTransientDigit() :
/// Default constructor
}
-//____________________________________________________________________________
-AliMUONTransientDigit::AliMUONTransientDigit(const AliMUONTransientDigit& digit) :
- AliMUONDigit(digit)
-{
-/// Protected copy constructor
-
- AliFatal( "Not implemented.");
-}
-
-
AliMUONTransientDigit::AliMUONTransientDigit(Int_t ich, Int_t *digits) :
AliMUONDigit(digits),
fChamber(ich),
delete fTrackList;
}
-////////////////////////////////////////////////////////////////////////
-AliMUONTransientDigit&
-AliMUONTransientDigit::operator =(const AliMUONTransientDigit& rhs)
-{
-/// Protected assignement operator
-
- if (this == &rhs) return *this;
-
- AliFatal("Not implemented.");
-
- return *this;
-}
-
////////////////////////////////////////////////////////////////////////
void AliMUONTransientDigit::AddToTrackList(Int_t track, Int_t charge)
{
+/// Add track to the track list
+
TVector *pTrInfo = new TVector(3);
TVector &trInfo = *pTrInfo;
trInfo(0) = track;
////////////////////////////////////////////////////////////////////////
void AliMUONTransientDigit::UpdateTrackList(Int_t track, Int_t charge)
{
+/// Update track charge if track already in the track list,
+/// or add the track to the list
+
Int_t lastEntry = fTrackList->GetLast();
TVector *pVect = static_cast<TVector*>(fTrackList->At(lastEntry));
if ( static_cast<Int_t>((*pVect)(0)) == track) {
////////////////////////////////////////////////////////////////////////
Int_t AliMUONTransientDigit::GetTrack(Int_t i) const
{
+/// Return \a i th track from the list
+
if (i > fTrackList->GetEntriesFast()) return 0;
TVector *pVect = static_cast<TVector*>(fTrackList->At(i));
return static_cast<Int_t>((*pVect)(0));
////////////////////////////////////////////////////////////////////////
Int_t AliMUONTransientDigit::GetCharge(Int_t i) const
{
+/// Return the charge of \a i th track in the list
+
if (i > fTrackList->GetEntriesFast()) return 0;
TVector *pVect = static_cast<TVector*>(fTrackList->At(i));
return static_cast<Int_t>((*pVect)(1));
/// \ingroup base
/// \class AliMUONTransientDigit
/// \brief MUON transient digit
+///
+/// Extends AliMUONDigit with a list of contributing tracks
#include "AliMUONDigit.h"
AliMUONTransientDigit(Int_t rpad, Int_t *digits);
virtual ~AliMUONTransientDigit();
+ /// Return chamber number
Int_t Chamber() const {return fChamber;}
+ /// Return number of tracks in the list
Int_t GetNTracks() const {return fTrackList->GetEntriesFast();}
Int_t GetTrack(Int_t i) const;
Int_t GetCharge(Int_t i) const;
#include "AliMUONConstants.h"
#include "AliLog.h"
+/// \cond CLASSIMP
ClassImp(AliMUONTriggerCircuit)
+/// \endcond
//----------------------------------------------------------------------
AliMUONTriggerCircuit::AliMUONTriggerCircuit()
fX2m(0),
fX2ud(0)
{
-// Constructor
+/// Constructor
fOrMud[0]=fOrMud[1]=0;
Int_t i;
}
//----------------------------------------------------------------------
-AliMUONTriggerCircuit::AliMUONTriggerCircuit(const AliMUONTriggerCircuit& theMUONTriggerCircuit)
- : TObject(theMUONTriggerCircuit)
+AliMUONTriggerCircuit::~AliMUONTriggerCircuit()
{
-// Protected copy constructor
-
- AliFatal("Not implemented.");
-}
-
-//----------------------------------------------------------------------
-AliMUONTriggerCircuit &
-AliMUONTriggerCircuit::operator=(const AliMUONTriggerCircuit& rhs)
-{
-// Protected assignement operator
-
- if (this == &rhs) return *this;
-
- AliFatal("Not implemented.");
-
- return *this;
-}
+/// Destructor
+}
//----------------------------------------------------------------------
void AliMUONTriggerCircuit::Init(Int_t iCircuit) {
-// initialize circuit characteristics
+/// initialize circuit characteristics
fIdCircuit=AliMUONTriggerConstants::CircuitId(iCircuit);
LoadX2();
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::CircuitNumber(Int_t idCircuit) const {
-// returns circuit number iCircuit (0-234) corresponding to circuit idCircuit
+/// returns circuit number iCircuit (0-234) corresponding to circuit idCircuit
Int_t iCircuit=0;
for (Int_t i=0; i<234; i++) {
if (AliMUONTriggerConstants::CircuitId(i)==idCircuit) {
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::ModuleNumber(Int_t idModule) const {
-// returns module number imod (from 0 to 63) corresponding to module idmodule
+/// returns module number imod (from 0 to 63) corresponding to module idmodule
Int_t absidModule=TMath::Abs(idModule);
Int_t iModule=0;
for (Int_t i=0; i<63; i++) {
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::Module(Int_t idCircuit) const {
-// returns ModuleId where Circuit idCircuit is sitting
+/// returns ModuleId where Circuit idCircuit is sitting
return Int_t(idCircuit/10);
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::Position(Int_t idCircuit) const {
-// returns position of idCircuit in correcponding Module
+/// returns position of idCircuit in correcponding Module
return TMath::Abs(idCircuit)-TMath::Abs(Module(idCircuit))*10;
}
//----------------------------------------------------------------------
void AliMUONTriggerCircuit::LoadX2() {
-// initialize fX2m, fX2ud and fOrMud
+/// initialize fX2m, fX2ud and fOrMud
Int_t idModule=Module(fIdCircuit); // corresponding module Id.
// and its number of X strips
//----------------------------------------------------------------------
void AliMUONTriggerCircuit::LoadXCode(){
-// assign a Id. number to each X strip of current circuit
-// Id.=(corresponding module Id.)*100+(Id. strip of module)
+/// assign a Id. number to each X strip of current circuit
+/// Id.=(corresponding module Id.)*100+(Id. strip of module)
// first part : fill XMC11 XMC12 and strips 8 to 24 (middle) XMC21 XMC22
Int_t iStripCircMT1=0, iStripCircMT2=8;
//----------------------------------------------------------------------
void AliMUONTriggerCircuit::LoadYCode(){
-// assign a Id. number to each Y strip of current circuit
-// Id.=(corresponding module Id.)*100+(Id. strip of module)
-// note : for Y plane fill only "central part" of circuit
-// (upper and lower parts are filled in PreHandlingY of AliMUONTriggerDecision)
+/// assign a Id. number to each Y strip of current circuit
+/// Id.=(corresponding module Id.)*100+(Id. strip of module)
+/// note : for Y plane fill only "central part" of circuit
+/// (upper and lower parts are filled in PreHandlingY of AliMUONTriggerDecision)
Int_t idModule=Module(fIdCircuit); // corresponding module Id.
// and its number of Y strips
//----------------------------------------------------------------------
Float_t AliMUONTriggerCircuit::PtCal(Int_t istripX, Int_t idev, Int_t istripY){
-// returns calculated pt for circuit/istripX/idev/istripY according
-// to the formula of the TRD. Note : idev (input) is in [0+30]
+/// returns calculated pt for circuit/istripX/idev/istripY according
+/// to the formula of the TRD. Note : idev (input) is in [0+30]
// Int_t jdev = idev - 15; // jdev in [-15+15]
Int_t istripX2=istripX+idev+1; // find istripX2 using istripX and idev
//---------------------------------------------------------------------
void AliMUONTriggerCircuit::LoadYPos2(){
-// fill fYpos11 and fYpos21 -> y position of X declusterized strips
+/// fill fYpos11 and fYpos21 -> y position of X declusterized strips
Int_t chamber, cathode;
Int_t code, idModule, idStrip, idSector;
//----------------------------------------------------------------------
void AliMUONTriggerCircuit::LoadXPos2(){
-// fill fXpos11 -> x position of Y strips for the first plane only
-// fXpos11 contains the x position of Y strip for the current circuit
-// taking into account whether or nor not part(s) of the circuit
-// (middle, up or down) has(have) 16 strips
+/// fill fXpos11 -> x position of Y strips for the first plane only
+/// fXpos11 contains the x position of Y strip for the current circuit
+/// taking into account whether or nor not part(s) of the circuit
+/// (middle, up or down) has(have) 16 strips
Float_t x, y, z;
Int_t istrip, idDE;
//--- methods which return member data related info
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetIdCircuit() const {
-// returns circuit Id
+/// returns circuit Id
return fIdCircuit;
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetIdModule() const {
-// returns module Id
+/// returns module Id
return Module(fIdCircuit);
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetNstripX() const {
-// returns the number of X strips in the module where the circuit is sitting
+/// returns the number of X strips in the module where the circuit is sitting
return AliMUONTriggerConstants::NstripX(ModuleNumber(Module(fIdCircuit)));
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetNstripY() const {
-// returns the number of Y strips in the module where the circuit is sitting
+/// returns the number of Y strips in the module where the circuit is sitting
return AliMUONTriggerConstants::NstripY(ModuleNumber(Module(fIdCircuit)));
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetPosCircuit() const {
-// returns the position of the circuit in its module
+/// returns the position of the circuit in its module
return Position(fIdCircuit);
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetIdCircuitD() const {
-// returns the Id of the circuit down
+/// returns the Id of the circuit down
Int_t idModule=Module(fIdCircuit);
Int_t idModuleD=(TMath::Abs(idModule)+10)*(TMath::Abs(idModule)/idModule);
return (TMath::Abs(idModuleD)*10+1)*(TMath::Abs(idModule)/idModule);
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetICircuitD() const {
-// returns the number of the circuit down
+/// returns the number of the circuit down
Int_t idModule=Module(fIdCircuit);
Int_t idModuleD=(TMath::Abs(idModule)+10)*(TMath::Abs(idModule)/idModule);
Int_t idCircuitD=
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetIdCircuitU() const {
-// returns the Id of the circuit up
+/// returns the Id of the circuit up
Int_t idModule=Module(fIdCircuit);
Int_t idModuleU=(TMath::Abs(idModule)-10)*(TMath::Abs(idModule)/idModule);
return (TMath::Abs(idModuleU)*10+1)*(TMath::Abs(idModule)/idModule);
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetICircuitU() const {
-// returns the number of the circuit up
+/// returns the number of the circuit up
Int_t idModule=Module(fIdCircuit);
Int_t idModuleU=(TMath::Abs(idModule)-10)*(TMath::Abs(idModule)/idModule);
Int_t idCircuitU=
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetX2m() const {
-// returns fX2m
+/// returns fX2m
return fX2m;
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetX2ud() const {
-// returns fX2ud
+/// returns fX2ud
return fX2ud;
}
//----------------------------------------------------------------------
void AliMUONTriggerCircuit::GetOrMud(Int_t orMud[2]) const {
-// returns fOrMud
+/// returns fOrMud
orMud[0]=fOrMud[0];
orMud[1]=fOrMud[1];
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetXcode(Int_t chamber, Int_t istrip) const {
-// returns X code of circuit/chamber/istrip (warning : chamber in [0,3])
+/// returns X code of circuit/chamber/istrip (warning : chamber in [0,3])
return fXcode[chamber][istrip];
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuit::GetYcode(Int_t chamber, Int_t istrip) const {
-// returns Y code of circuit/chamber/istrip (warning : chamber in [0,3])
+/// returns Y code of circuit/chamber/istrip (warning : chamber in [0,3])
return fYcode[chamber][istrip];
}
//----------------------------------------------------------------------
Float_t AliMUONTriggerCircuit::GetY11Pos(Int_t istrip) const {
-// returns Y position of X strip istrip in MC11
+/// returns Y position of X strip istrip in MC11
return fYpos11[istrip];
}
//----------------------------------------------------------------------
Float_t AliMUONTriggerCircuit::GetY21Pos(Int_t istrip) const {
-// returns Y position of X strip istrip in MC21
+/// returns Y position of X strip istrip in MC21
return fYpos21[istrip];
}
//----------------------------------------------------------------------
void
AliMUONTriggerCircuit::Print(Option_t* ) const
{
-// prints-out data member
+/// prints-out data member
cout << "IdCircuit " << fIdCircuit << " X2m,X2ud=" << fX2m << ","
<< fX2ud;
for ( Int_t i = 0; i < 2; ++i )
sprintf(s,"Ycode[%d]",i);
dump(s,fYcode[i],32);
}
- // Int_t fIdCircuit; // circuit Id number
+// Int_t fIdCircuit; // circuit Id number
// Int_t fX2m; // internal info needed by TriggerDecision
// Int_t fX2ud; // internal info needed by TriggerDecision
// Int_t fOrMud[2]; // internal info needed by TriggerDecision
Int_t AliMUONTriggerCircuit::DetElemId(Int_t ichamber, Int_t idModule)
{
-// adpated to official numbering (09/20/05)
-// returns the detection element Id for given chamber and module
-// ichamber (from 11 to 14), idModule (from -97 to 97)
+/// adpated to official numbering (09/20/05)
+/// returns the detection element Id for given chamber and module
+/// ichamber (from 11 to 14), idModule (from -97 to 97)
//
Int_t itmp=0;
Int_t linenumber=Int_t(idModule/10);
{
public:
AliMUONTriggerCircuit();
- virtual ~AliMUONTriggerCircuit(){;}
+ virtual ~AliMUONTriggerCircuit();
// initializations
void Init(Int_t iCircuit);
#include "AliMpVSegmentation.h"
#include "AliMUONGeometryTransformer.h"
+/// \cond CLASSIMP
ClassImp(AliMUONTriggerCircuitNew)
+/// \endcond
//----------------------------------------------------------------------
AliMUONTriggerCircuitNew::AliMUONTriggerCircuitNew()
: TObject(),
fILocalBoard(0)
{
- // Constructor
+/// Constructor
Int_t i;
for (i=0; i<16; i++) { fXpos11[i]=0.; }
}
//----------------------------------------------------------------------
-AliMUONTriggerCircuitNew::AliMUONTriggerCircuitNew(const AliMUONTriggerCircuitNew& theMUONTriggerCircuit)
-: TObject(theMUONTriggerCircuit)
+AliMUONTriggerCircuitNew::~AliMUONTriggerCircuitNew()
{
- // Protected copy constructor
-
- AliFatal("Not implemented.");
-}
-
-//----------------------------------------------------------------------
-AliMUONTriggerCircuitNew &
-AliMUONTriggerCircuitNew::operator=(const AliMUONTriggerCircuitNew& rhs)
-{
- // Protected assignement operator
-
- if (this == &rhs) return *this;
-
- AliFatal("Not implemented.");
-
- return *this;
-}
+/// Destructor
+}
//----------------------------------------------------------------------
void AliMUONTriggerCircuitNew::Init(Int_t iCircuit, const AliMUONTriggerCrateStore& crates)
{
- // initialize circuit characteristics
+/// initialize circuit characteristics
fILocalBoard=iCircuit+1;//AliMUONTriggerConstants::CircuitId(iCircuit);
LoadXPos(crates);
//---------------------------------------------------------------------
void AliMUONTriggerCircuitNew::LoadYPos(const AliMUONTriggerCrateStore& crates)
{
- // fill fYpos11 and fYpos21 -> y position of X declusterized strips
+/// fill fYpos11 and fYpos21 -> y position of X declusterized strips
const AliMUONLocalTriggerBoard* localBoard = crates.LocalBoard(fILocalBoard);
//----------------------------------------------------------------------
void AliMUONTriggerCircuitNew::LoadXPos(const AliMUONTriggerCrateStore& crates)
{
- // fill fXpos11 -> x position of Y strips for the first plane only
- // fXpos11 contains the x position of Y strip for the current circuit
- // taking into account whether or nor not part(s) of the circuit
- // (middle, up or down) has(have) 16 strips (handdled by means of switchs)
+/// fill fXpos11 -> x position of Y strips for the first plane only
+/// fXpos11 contains the x position of Y strip for the current circuit
+/// taking into account whether or nor not part(s) of the circuit
+/// (middle, up or down) has(have) 16 strips (handdled by means of switchs)
const AliMUONLocalTriggerBoard* localBoard = crates.LocalBoard(fILocalBoard);
const Int_t iFirstStrip, const Int_t iLastStrip, Int_t liStripCircuit,
const Bool_t doubling)
{
- // fill
+/// fill
Double_t xyGlobal[4]={0.,0.,0.,0.};
for (Int_t istrip=iFirstStrip; istrip<iLastStrip; istrip++) {
AliMpPad pad = seg->PadByIndices(AliMpIntPair(istrip,0),kTRUE);
const Int_t iFirstStrip, const Int_t iLastStrip,
Int_t liStripCircuit, Float_t *tab)
{
- // fill
+/// fill
Double_t xyGlobal[4]={0.,0.,0.,0.};
for (Int_t istrip=iFirstStrip; istrip<iLastStrip; istrip++) {
AliMpPad pad = seg->PadByIndices(AliMpIntPair(icol-1,istrip),kTRUE);
//--- methods which return member data related info
//----------------------------------------------------------------------
Float_t AliMUONTriggerCircuitNew::GetY11Pos(Int_t istrip) const {
- // returns Y position of X strip istrip in MC11
+/// returns Y position of X strip istrip in MC11
return fYpos11[istrip];
}
//----------------------------------------------------------------------
Float_t AliMUONTriggerCircuitNew::GetY21Pos(Int_t istrip) const {
- // returns Y position of X strip istrip in MC21
+/// returns Y position of X strip istrip in MC21
return fYpos21[istrip];
}
//----------------------------------------------------------------------
Float_t AliMUONTriggerCircuitNew::GetX11Pos(Int_t istrip) const {
- // returns X position of Y strip istrip in MC11
+/// returns X position of Y strip istrip in MC11
return fXpos11[istrip];
}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
Int_t AliMUONTriggerCircuitNew::DetElemId(Int_t ichamber, char side, Int_t iline)
{
- // returns detection element Id for chamber iChamber, side side and line iline
+/// returns detection element Id for chamber iChamber, side side and line iline
Int_t itmp=0;
if ( side == 'R' ) { // right side
switch (iline) // (from 1 to 9, from bottom to top)
Int_t
AliMUONTriggerCircuitNew::DetElemId(Int_t iChamber, const char* boardName)
{
- // returns detection element Id for chamber iChamber and board boardName
+/// returns detection element Id for chamber iChamber and board boardName
char side = boardName[5];
Int_t iline = boardName[4] - '0';
return DetElemId(iChamber,side,iline);
Int_t& iLine,
Int_t& iCol)
{
- // get side, line and col from board boardName
- // note: icol = icol -1 for iline = 5 w.r.t other ilines
+/// get side, line and col from board boardName
+/// note: icol = icol -1 for iline = 5 w.r.t other ilines
side = boardName[0];
iLine = boardName[4] - '0';
iCol = boardName[2] - '0';
Int_t
AliMUONTriggerCircuitNew::FirstStrip(const char* boardName)
{
- // returns the first strip from mapping for board boardName
- // take care of special case for boards RC1L6B12 & LC1L6B12
+/// returns the first strip from mapping for board boardName
+/// take care of special case for boards RC1L6B12 & LC1L6B12
Int_t iFirstStrip = -1;
Int_t boardNumber = atoi(boardName+6);
char side;
Int_t detElemId, const AliMpPad& pad,
Double_t xyGlobal[4])
{
- // returns pad x & y positions and x & y pad dimensions in global coordinates
- // note: no need for transformation for pad dimensions
+/// returns pad x & y positions and x & y pad dimensions in global coordinates
+/// note: no need for transformation for pad dimensions
// get the pad position and dimensions
Double_t xl1 = pad.Position().X();
{
public:
AliMUONTriggerCircuitNew();
- virtual ~AliMUONTriggerCircuitNew(){;}
+ virtual ~AliMUONTriggerCircuitNew();
// initializations
void Init(Int_t iCircuit, const AliMUONTriggerCrateStore& crates);
#include "AliMUONTriggerConstants.h"
+/// \cond CLASSIMP
ClassImp(AliMUONTriggerConstants)
+/// \endcond
//----------------------------------------------------------------------
AliMUONTriggerConstants::AliMUONTriggerConstants()
: TNamed()
{
-// constructor
- ;
+/// Default constructor
}
//----------------------------------------------------------------------
AliMUONTriggerConstants::~AliMUONTriggerConstants()
{
-// destructor
- ;
+/// Destructor
}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
Int_t AliMUONTriggerConstants::Nmodule()
{
-// returns fgkNmodule
+/// returns fgkNmodule
return fgkNmodule;
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerConstants::ModuleId(Int_t imodule)
{
-// returns fgkModuleId
+/// returns fgkModuleId
return fgkModuleId[imodule];
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerConstants::NstripX(Int_t imodule)
{
-// returns fgkNstripX
+/// returns fgkNstripX
return fgkNstripX[imodule];
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerConstants::NstripY(Int_t imodule)
{
-// return fgkNstripY
+/// return fgkNstripY
return fgkNstripY[imodule];
}
//----------------------------------------------------------------------
Float_t AliMUONTriggerConstants::XcMin(Int_t imodule)
{
-// returns fgkXcMin
+/// returns fgkXcMin
return fgkXcMin[imodule];
}
//----------------------------------------------------------------------
Float_t AliMUONTriggerConstants::XcMax(Int_t imodule)
{
-// returns fgkXcMax
+/// returns fgkXcMax
return fgkXcMax[imodule];
}
//----------------------------------------------------------------------
Int_t AliMUONTriggerConstants::CircuitId(Int_t icircuit)
{
-// returns fgkCircuitId
+/// returns fgkCircuitId
return fgkCircuitId[icircuit];
}
//----------------------------------------------------------------------
Float_t AliMUONTriggerConstants::StripWidth(Int_t istrip)
{
-// returns fgkStripWidth
+/// returns fgkStripWidth
return fgkStripWidth[istrip];
}
//----------------------------------------------------------------------
Float_t AliMUONTriggerConstants::StripLength(Int_t istrip)
{
-// returns fgkStripLength
+/// returns fgkStripLength
return fgkStripLength[istrip];
}
///
/// \author Laurent Aphecetche
+/// \cond CLASSIMP
ClassImp(AliMUONTriggerCrateStore)
+/// \endcond
//_____________________________________________________________________________
AliMUONTriggerCrateStore::AliMUONTriggerCrateStore()
fCurrentCrate(0x0),
fCurrentLocalBoard(-1)
{
- // ctor
+/// Default constructor
}
//_____________________________________________________________________________
AliMUONTriggerCrateStore::~AliMUONTriggerCrateStore()
{
- // dtor
+/// Destructor
delete fCrateIterator;
delete fLBIterator;
delete fCrates;
// $Id$
-/// \ingroup sim
+/// \ingroup base
/// \class AliMUONTriggerCrateStore
/// \brief A container for AliMUONTriggerCrate objects.
///
void ReadFromFile(const char* crateFile =
"$ALICE_ROOT/MUON/mapping/data/stationTrigger/crate.dat");
+protected:
+ AliMUONTriggerCrateStore(const AliMUONTriggerCrateStore& rhs);
+ AliMUONTriggerCrateStore& operator = (const AliMUONTriggerCrateStore& rhs);
+
private:
void AddCrate(const char* crateName);
#include "AliMpTrigger.h"
#include "AliLog.h"
-//
-// A class to store and give access to the trigger chamber efficiency.
-//
-// Efficiency is stored per cathode, on "cells" of a given size.
-//
-// The main method of this class is IsTriggered().
-//
-// $ALICE_ROOT/MUON/data/TriggerChamberefficiencyCells.dat contains efficiency
-// for each chamber (i.e. DetElement).
-// The efficiency cells goes from right to left and
-// from bottom to top of the chamber, namely, the efficiencies tabulated in the
-// file refers to the following reference frame:
-//
-//x
-//<----------------------------------|
-// |
-// --------------------------- |
-// | 0.97 | 0.97 | 0.97 | 0.97 | |
-// --------------------------- |
-// | 0.97 | 0.97 | 0.97 | 0.97 | |
-// --------------------------- |
-// | 0.97 | 0.97 | 0.97 | 0.97 | |
-// --------------------------- |
-// |
-// \/ y
-//
-// The file can be edited in order to change efficiency in a chosen region
-// of the chamber.
-//
-// But please note that this object is also available from the CDB
-// (generated using the MUONCDB.C macro)
-//
+/// \class AliMUONTriggerEfficiencyCells
+/// A class to store and give access to the trigger chamber efficiency.
+///
+/// Efficiency is stored per cathode, on "cells" of a given size.
+///
+/// The main method of this class is IsTriggered().
+///
+/// $ALICE_ROOT/MUON/data/TriggerChamberefficiencyCells.dat contains efficiency
+/// for each chamber (i.e. DetElement).
+/// The efficiency cells goes from right to left and
+/// from bottom to top of the chamber, namely, the efficiencies tabulated in the
+/// file refers to the following reference frame:
+///
+/// <pre>
+/// x
+/// <----------------------------------|
+/// |
+/// --------------------------- |
+/// | 0.97 | 0.97 | 0.97 | 0.97 | |
+/// --------------------------- |
+/// | 0.97 | 0.97 | 0.97 | 0.97 | |
+/// --------------------------- |
+/// | 0.97 | 0.97 | 0.97 | 0.97 | |
+/// --------------------------- |
+/// |
+/// \/ y
+/// </pre>
+/// The file can be edited in order to change efficiency in a chosen region
+/// of the chamber.
+///
+/// But please note that this object is also available from the CDB
+/// (generated using the MUONCDB.C macro)
+///
+/// \author Diego Stocco; INFN Torino
+/// \cond CLASSIMP
ClassImp(AliMUONTriggerEfficiencyCells)
+/// \endcond
//__________________________________________________________________________
AliMUONTriggerEfficiencyCells::AliMUONTriggerEfficiencyCells()
:
TObject()
{
- // Default ctor.
+/// Default constructor.
Reset();
}
:
TObject()
{
- // Ctor using an ASCII file.
+/// Constructor using an ASCII file.
Reset();
ReadFile(filename);
}
//__________________________________________________________________________
AliMUONTriggerEfficiencyCells::~AliMUONTriggerEfficiencyCells()
{
- // dtor. Does nothing ;-)
+/// Destructor. Does nothing ;-)
}
//__________________________________________________________________________
Float_t AliMUONTriggerEfficiencyCells::GetCellEfficiency(Int_t detElemId, Int_t cathode, Float_t x, Float_t y)
{
- // Get the efficiency at a given position (x,y) for a given cathode
+/// Get the efficiency at a given position (x,y) for a given cathode
Int_t chamber = FindChamberIndex(detElemId);
Int_t slat = FindSlatIndex(detElemId);
//__________________________________________________________________________
void AliMUONTriggerEfficiencyCells::GetCellEfficiency(Int_t detElemId, Float_t x, Float_t y, Float_t &eff1, Float_t &eff2)
{
- // Get the efficiencies of the 2 cathode at a given location (x,y)
+/// Get the efficiencies of the 2 cathode at a given location (x,y)
+
Int_t chamber = FindChamberIndex(detElemId);
Int_t slat = FindSlatIndex(detElemId);
TArrayI cell = CellByCoord(detElemId,x,y);
Bool_t
AliMUONTriggerEfficiencyCells::IsTriggered(Int_t detElemId, Int_t cathode, Float_t x, Float_t y)
{
- // Random decision of whether a given "location" (x,y) trigs or not.
+/// Random decision of whether a given "location" (x,y) trigs or not.
+
Float_t efficiency = GetCellEfficiency(detElemId, cathode, x, y);
Bool_t trigger = kTRUE;
if(gRandom->Rndm()>efficiency)
void
AliMUONTriggerEfficiencyCells::IsTriggered(Int_t detElemId, Float_t x, Float_t y, Bool_t &trig1, Bool_t &trig2)
{
- // Whether or not a given location (x,y) has a chance to trig, on each cathode.
+/// Whether or not a given location (x,y) has a chance to trig, on each cathode.
+
Float_t eff1 = 0.0;
Float_t eff2 = 0.0;
GetCellEfficiency(detElemId, x, y, eff1, eff2);
//__________________________________________________________________________
TArrayI AliMUONTriggerEfficiencyCells::CellByCoord(Int_t detElemId, Float_t x, Float_t y)
{
- // Get the efficiencies at a given location.
+/// Get the efficiencies at a given location.
+
Int_t chamber = FindChamberIndex(detElemId);
Int_t slat = FindSlatIndex(detElemId);
Int_t cell[2]={-1,-1};
//__________________________________________________________________________
void AliMUONTriggerEfficiencyCells::ReadFile(const char* filename)
{
- // Reads a file containing the efficiency map.
+/// Reads a file containing the efficiency map.
+
TString fileName = gSystem->ExpandPathName(filename);
ifstream file(fileName.Data());
Int_t datInt=0, detEl=0, chamber=0, rpc=0;
//__________________________________________________________________________
Int_t AliMUONTriggerEfficiencyCells::FindChamberIndex(Int_t detElemId)
{
- // From detElemId to chamber number
+/// From detElemId to chamber number
+
Int_t offset = 100*(AliMUONConstants::NTrackingCh()+1);
Int_t chamber = (detElemId-offset)/100;
return chamber;
//__________________________________________________________________________
Int_t AliMUONTriggerEfficiencyCells::FindSlatIndex(Int_t detElemId)
{
- // From detElemId to slat index.
+/// From detElemId to slat index.
+
Int_t offset = 100*(AliMUONConstants::NTrackingCh()+1);
Int_t chamber = FindChamberIndex(detElemId);
Int_t slat = detElemId-offset-(chamber*100);
//__________________________________________________________________________
TVector2 AliMUONTriggerEfficiencyCells::ChangeReferenceFrame(Float_t x, Float_t y, Float_t x0, Float_t y0)
{
- //(x0,y0) position of the local reference frame (center of the chamber)
+/// (x0,y0) position of the local reference frame (center of the chamber)
+
Float_t x1 = x0-x;//reflection of axis
Float_t y1 = y+y0;
return TVector2(x1,y1);
void
AliMUONTriggerEfficiencyCells::Reset()
{
- //
- // Sets our internal array contents to zero.
- //
+/// Sets our internal array contents to zero.
+
for(Int_t chamber=0; chamber<4; chamber++)
{
for(Int_t slat=0; slat<18; slat++)
fCellContent[chamber][slat][cath][ix][iy]=0.0;
}
}
- }
+ }
}
}
}
/// \class AliMUONTriggerEfficiencyCells
/// \brief Store and give access to the trigger chamber efficiency.
///
-/// \author: Diego Stocco; INFN Torino
+// Author: Diego Stocco; INFN Torino
#ifndef ALIMUONTRIGGEREFFICIENCYCELLS_H
#define ALIMUONTRIGGEREFFICIENCYCELLS_H
#include "AliMUONGeometryModule.h"
#include "AliMUONGeometryEnvelopeStore.h"
+/// \cond CLASSIMP
ClassImp(AliMUONTriggerGeometryBuilder)
+/// \endcond
//______________________________________________________________________________
AliMUONTriggerGeometryBuilder::AliMUONTriggerGeometryBuilder(AliMUON* muon)
// $Id$
// Revision of includes 07/05/2004
//
-/// \ingroup base
+/// \ingroup sim
/// \class AliMUONTriggerGeometryBuilder
/// \brief MUON Trigger stations geometry construction class
///
/* $Id$ */
-// -----------------------------------
-// Class AliMUONTriggerLut
-// -----------------------------------
-// Local Trigger Look Up Table - reading interface
-// LUT data is stored into TH3S histograms and readout
-// from the Local Trigger algorithm.
+/// \class AliMUONTriggerLut
+/// Local Trigger Look Up Table - reading interface
+/// LUT data is stored into TH3S histograms and readout
+/// from the Local Trigger algorithm.
#include "AliMUONTriggerLut.h"
#include "TFile.h"
#include "TH3.h"
+/// \cond CLASSIMP
ClassImp(AliMUONTriggerLut)
+/// \endcond
//----------------------------------------------------------------------
AliMUONTriggerLut::AliMUONTriggerLut()
: TNamed()
{
-// constructor
+/// Default constructor
+
fLptPlus = fLptMinu = fLptUnde = 0;
fHptPlus = fHptMinu = fHptUnde = 0;
fAptPlus = fAptMinu = fAptUnde = 0;
//----------------------------------------------------------------------
AliMUONTriggerLut::~AliMUONTriggerLut()
{
- // destructor
+/// Destructor
+
delete fLptPlus;
delete fLptMinu;
delete fLptUnde;
delete fAptUnde;
}
-//----------------------------------------------------------------------
-AliMUONTriggerLut::AliMUONTriggerLut (const AliMUONTriggerLut& theMUONTriggerLut)
- : TNamed(theMUONTriggerLut)
-{
-// Protected copy constructor
-
- AliFatal("Not implemented.");
-}
-
-//----------------------------------------------------------------------
-AliMUONTriggerLut &
-AliMUONTriggerLut::operator=(const AliMUONTriggerLut& rhs)
-{
-// Protected assignement operator
-
- if (this == &rhs) return *this;
-
- AliFatal( "Not implemented.");
-
- return *this;
-}
-
void
AliMUONTriggerLut::ReadFromFile(const char* filename)
{
-// return output of LuT for corresponding TH3S
+/// Return output of LuT for corresponding TH3S
+
TFile f(filename);
if ( f.IsZombie() )
Int_t ystrip, Int_t lutLpt[2],
Int_t lutHpt[2], Int_t lutApt[2])
{
- // return output of LuT for corresponding TH3S
+/// Return output of LuT for corresponding TH3S
if ( !fLptPlus )
{
//----------------------------------------------------------------------
Int_t AliMUONTriggerLut::GetMask(Int_t ystrip)
{
- // returns the mask corresponding to ystrip
+/// Return the mask corresponding to ystrip
+
Int_t tabMask[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
Int_t mask=0;
tabMask[ystrip]=1;
/* $Id$ */
-//**********************************************************************
-// Segmentation classe for trigger chambers.
-// In the present version the method use global strip coordinates except
-// HasPad. The conversion is made via GetPadLoc2Glo.
-// To be improved in the future.
-//**********************************************************************
+/// \class AliMUONTriggerSegmentation
+/// \brief Segmentation classe for trigger chambers.
+/// In the present version the method use global strip coordinates except
+/// HasPad. The conversion is made via GetPadLoc2Glo.
+/// To be improved in the future.
#include "AliMUONTriggerSegmentation.h"
#include "AliLog.h"
#include "Riostream.h"
-//___________________________________________
+/// \cond CLASSIMP
ClassImp(AliMUONTriggerSegmentation)
+/// \endcond
+//___________________________________________
AliMUONTriggerSegmentation::AliMUONTriggerSegmentation()
: AliMUONVGeometryDESegmentation(),
fBending(0),
fRpcHalfXsize(0),
fRpcHalfYsize(0)
{
-// Default constructor
+/// Default constructor
// add to St345SlatSegmentation
for (Int_t i=0; i<7; i++) {
fRpcHalfXsize(0),
fRpcHalfYsize(0)
{
- // Non default constructor
+/// Standard constructor
+
fNsec = 7;
// add to St345SlatSegmentation
for (Int_t i=0; i<7; i++) {
AliDebug(1, Form("ctor this = %p", this) );
}
-//----------------------------------------------------------------------
-AliMUONTriggerSegmentation::AliMUONTriggerSegmentation(const AliMUONTriggerSegmentation& rhs) : AliMUONVGeometryDESegmentation(rhs)
-{
-// Copy constructor
-
- AliFatal("Not implemented.");
-}
//----------------------------------------------------------------------
AliMUONTriggerSegmentation::~AliMUONTriggerSegmentation()
{
- // Destructor
+/// Destructor
AliDebug(1, Form("dtor this = %p", this) );
}
//----------------------------------------------------------------------
-AliMUONTriggerSegmentation& AliMUONTriggerSegmentation::operator=(const AliMUONTriggerSegmentation& rhs)
-{
-// Protected assignement operator
- if (this == &rhs) return *this;
- AliFatal("Not implemented.");
- return *this;
-}
-//----------------------------------------------------------------------
Int_t AliMUONTriggerSegmentation::ModuleColNum(Int_t ix)
{
-// returns column number (from 0 to 6) in which the (global) module
-// ix is sitting (could return 7 if ix=isec)
+/// returns column number (from 0 to 6) in which the (global) module
+/// ix is sitting (could return 7 if ix=isec)
+
return TMath::Abs(ix)-Int_t(TMath::Abs(ix)/10)*10-1;
}
//----------------------------------------------------------------------
Bool_t AliMUONTriggerSegmentation::HasPad(Int_t ix, Int_t iy)
{
-// check if steping outside the limits (iy=1,2... iy=0,1...)
+/// check if steping outside the limits (iy=1,2... iy=0,1...)
+
Bool_t hasPad = true;
Int_t ixGlo = 0;
Int_t iyGlo = 0;
//____________________________________________________________________________
Float_t AliMUONTriggerSegmentation::Dpx(Int_t isec) const
{
-// return x-strip width in sector isec
+/// return x-strip width in sector isec
+
Float_t size = (isec<8) ? fStripXsize[isec-1] : fStripXsize[isec-2]/2.;
return size;
}
//____________________________________________________________________________
Float_t AliMUONTriggerSegmentation::Dpy(Int_t isec) const
{
-// return y-strip width in sector isec
+/// return y-strip width in sector isec
+
Float_t size = (isec<8) ? fStripYsize[isec-1] : fStripYsize[isec-2];
return size;
}
void AliMUONTriggerSegmentation::GetPadLoc2Glo(Int_t ixLoc, Int_t iyLoc,
Int_t &ixGlo, Int_t &iyGlo)
{
-// converts ixLoc & iyLoc into ixGlo & iyGLo (module,strip number)
+/// converts ixLoc & iyLoc into ixGlo & iyGLo (module,strip number)
+
ixGlo = 0; // see AliMUONTriggerConstants::fgkModuleI
iyGlo = 0; // from 0 to (fNtrip-1) in module
if (fBending) {
void AliMUONTriggerSegmentation::GetPadGlo2Loc(Int_t ixGlo, Int_t iyGlo,
Int_t &ixLoc, Int_t &iyLoc)
{
-// converts ixGlo & iyGlo into ixLoc & iyLoc
+/// converts ixGlo & iyGlo into ixLoc & iyLoc
+
ixLoc = 0;
iyLoc = 0;
if (fBending) {
//----------------------------------------------------------------------------
void AliMUONTriggerSegmentation::GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
{
-// Returns local real coordinates (x,y) for local pad coordinates (ix,iy)
+/// Returns local real coordinates (x,y) for local pad coordinates (ix,iy)
x = 0.;
y = 0.;
//_____________________________________________________________________________
void AliMUONTriggerSegmentation::GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
{
-// Returns global pad coordinates (ix,iy) for local real coordinates (x,y)
+/// Returns global pad coordinates (ix,iy) for local real coordinates (x,y)
+
ix = -1;
iy = -1;
//-------------------------------------------------------------------------
void AliMUONTriggerSegmentation::GetPadI(Float_t x, Float_t y , Float_t /*z*/, Int_t &ix, Int_t &iy)
{
-// Returns global pad coordinates (ix,iy) for local real coordinates (x,y)
+/// Returns global pad coordinates (ix,iy) for local real coordinates (x,y)
+
GetPadI(x, y, ix, iy);
}
//-------------------------------------------------------------------------
void AliMUONTriggerSegmentation::SetLineNumber(Int_t iLineNumber){
-// Set line number
+/// Set line number
+
fLineNumber = iLineNumber;
}
//-------------------------------------------------------------------------
void AliMUONTriggerSegmentation::SetPad(Int_t ix, Int_t iy)
{
- // Sets virtual pad coordinates, needed for evaluating pad response
- // outside the tracking program
+/// Sets virtual pad coordinates, needed for evaluating pad response
+/// outside the tracking program
+
GetPadC(ix,iy,fX,fY);
fIx = ix; // used in IntegrationLimits
fIy = iy;
//---------------------------------------------------------------------------
void AliMUONTriggerSegmentation::SetHit(Float_t x, Float_t y)
{
- // Set current hit
+/// Set current hit
+
fXhit = x;
fYhit = y;
}
//----------------------------------------------------------------------------
void AliMUONTriggerSegmentation::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
{
- // Set current hit
+/// Set current hit
+
SetHit(xhit, yhit);
}
//--------------------------------------------------------------------------
Int_t AliMUONTriggerSegmentation::Sector(Int_t ix, Int_t iy)
{
-// determine segmentation zone from pad coordinates (from 1 to 8)
+/// determine segmentation zone from pad coordinates (from 1 to 8)
+
if (!fBending && ModuleColNum(ix)==6 && iy>7) {
return 8; // sector 8: diff. strip width within same module
} else {
void AliMUONTriggerSegmentation::IntegrationLimits(Float_t& x1,Float_t& x2,
Float_t& x3, Float_t& x4)
{
-// need to return (only) x4 = dist. betwwen the hit and the closest border of
-// the current strip
+/// need to return (only) x4 = dist. betwwen the hit and the closest border of
+/// the current strip
Int_t ix,iy;
Float_t xstrip,ystrip;
void AliMUONTriggerSegmentation::
Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])
{
-//-----------------BENDING-----------------------------------------
-// Returns list of 10 next neighbours for given X strip (ix, iy)
-// neighbour number 4 in the list -
-// neighbour number 3 in the list |
-// neighbour number 2 in the list |_ Upper part
-// neighbour number 1 in the list |
-// neighbour number 0 in the list -
-// X strip (ix, iy)
-// neighbour number 5 in the list -
-// neighbour number 6 in the list | _ Lower part
-// neighbour number 7 in the list |
-// neighbour number 8 in the list |
-// neighbour number 9 in the list -
-
-//-----------------NON-BENDING-------------------------------------
-// Returns list of 10 next neighbours for given Y strip (ix, iy)
-// neighbour number 9 8 7 6 5 (Y strip (ix, iy)) 0 1 2 3 4 in the list
-// \_______/ \_______/
-// left right
+/// <pre>
+///-----------------BENDING-----------------------------------------
+/// Returns list of 10 next neighbours for given X strip (ix, iy)
+/// neighbour number 4 in the list -
+/// neighbour number 3 in the list |
+/// neighbour number 2 in the list |_ Upper part
+/// neighbour number 1 in the list |
+/// neighbour number 0 in the list -
+/// X strip (ix, iy)
+/// neighbour number 5 in the list -
+/// neighbour number 6 in the list | _ Lower part
+/// neighbour number 7 in the list |
+/// neighbour number 8 in the list |
+/// neighbour number 9 in the list -
+///
+///-----------------NON-BENDING-------------------------------------
+/// Returns list of 10 next neighbours for given Y strip (ix, iy)
+/// neighbour number 9 8 7 6 5 (Y strip (ix, iy)) 0 1 2 3 4 in the list
+/// \\_______/ \\_______/
+/// left right
Int_t absiX = TMath::Abs(iX);
Int_t modNum = ModuleColNum(absiX); // from 0 to 6
Float_t stripXsize[7],
Float_t offset)
{
+/// Initialize
+
// printf(" fBending: %d \n",fBending);
Int_t nStripMax = 0;
void
AliMUONTriggerSegmentation::Print(Option_t*) const
{
-// Printing
+/// Printing
cout << "fId=" << fId << " fBending=" << fBending << " fNsec="
<< fNsec << " Nx,Ny=" << fNpx << "," << fNpy
AliMUONTriggerSegmentation();
virtual ~AliMUONTriggerSegmentation();
- virtual Float_t Distance2AndOffset(Int_t /*iX*/, Int_t /*iY*/, Float_t /*X*/, Float_t /*Y*/, Int_t * /*dummy*/) {return 0.;} // Distance between 1 pad and a position
- virtual Float_t Dpx() const {return 0.;} // Pad size in x
- virtual Float_t Dpy() const {return 0.;} // Pad size in y
+ virtual Float_t Distance2AndOffset(Int_t /*iX*/, Int_t /*iY*/, Float_t /*X*/, Float_t /*Y*/, Int_t * /*dummy*/) {return 0.;} ///< Distance between 1 pad and a position
+ virtual Float_t Dpx() const {return 0.;} ///< Pad size in x
+ virtual Float_t Dpy() const {return 0.;} ///< Pad size in y
virtual Float_t Dpx(Int_t isec) const; // Pad size in x by Sector
virtual Float_t Dpy(Int_t isec) const; // Pad size in y by Sector
- virtual void Draw(const char */*opt*/ = "") {} // Not implemented
- 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*/) {}
+ virtual void Draw(const char */*opt*/ = "") {} ///< Not implemented
+ virtual void FirstPad(Float_t /*xhit*/, Float_t /*yhit*/, Float_t /*dx*/, Float_t /*dy*/){} ///< Not implemented
+ virtual void FirstPad(Float_t /*xhit*/, Float_t /*yhit*/, Float_t /*zhit*/, Float_t /*dx*/, Float_t /*dy*/) {} ///< Not implemented
- virtual Bool_t HasPad(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/) { return true; }
+ virtual Bool_t HasPad(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/) { return true; } ///< Not implemented
virtual Bool_t HasPad(Int_t ix, Int_t iy);
- virtual AliMUONGeometryDirection GetDirection() { return kDirUndefined; }
- virtual const AliMpVSegmentation* GetMpSegmentation() const { return 0; }
+ virtual AliMUONGeometryDirection GetDirection() { return kDirUndefined; } ///< Not implemented
+ virtual const AliMpVSegmentation* GetMpSegmentation() const { return 0; } ///< Not implemented
- virtual Float_t GetAnod(Float_t /*xhit*/) const {return 0; } // Anod wire coordinate closest to xhit
+ virtual Float_t GetAnod(Float_t /*xhit*/) const {return 0; } ///< Anod wire coordinate closest to xhit
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);
virtual void GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y);
+ /// Returns real coordinates (x,y,z) for given pad coordinates (ix,iy)
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);}
virtual void GetPadLoc2Glo(Int_t ixLoc, Int_t iyLoc, Int_t &ixGlo, Int_t &iyGlo);
virtual void GetPadGlo2Loc(Int_t ixLoc, Int_t iyLoc, Int_t &ixGlo, Int_t &iyGlo);
virtual void IntegrationLimits(Float_t& x1, Float_t& x2, Float_t& y1, Float_t& y2); //Current integration limits
- virtual Int_t ISector() {return fSector;} // Current Pad during Integration (current sector)
- virtual Int_t Ix() {return fIx;} // x-coordinate
- virtual Int_t Iy() {return fIy;} // y-coordinate
+ virtual Int_t ISector() {return fSector;} ///< Current Pad during Integration (current sector)
+ virtual Int_t Ix() {return fIx;} ///< x-coordinate
+ virtual Int_t Iy() {return fIy;} ///< y-coordinate
// virtual Int_t MorePads(); // Condition
- virtual Int_t MorePads(){return 0;}; // Condition
+ virtual Int_t MorePads(){return 0;}; ///< Condition
virtual void Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10]); // Get next neighbours
- virtual void NextPad(){} // Stepper
+ virtual void NextPad(){} ///< Stepper
- virtual Int_t Npx() const {return fNpx;} // Maximum number of Pads in x
- virtual Int_t Npy() const {return fNpy;} // Maximum number of Pads in y
+ virtual Int_t Npx() const {return fNpx;} ///< Maximum number of Pads in x
+ virtual Int_t Npy() const {return fNpy;} ///< Maximum number of Pads in y
- virtual void SetDAnod(Float_t /*D*/) {/*fWireD = D*/;}; // Anod pitch
+ virtual void SetDAnod(Float_t /*D*/) {/*fWireD = D*/;}; ///< Anod pitch
virtual Int_t Sector(Int_t ix, Int_t iy); // Calculate sector from pad coordinates
virtual void SetHit(Float_t xhit, Float_t yhit); // Set hit position
virtual void SetHit(Float_t xhit, Float_t yhit, Float_t zhit);
- virtual void SetId(Int_t id) {fId=id;} // Setting detection element
- virtual void SetPad(Int_t ix, Int_t iy); // Set pad position
- virtual void SetPadDivision(Int_t /*ndiv[4]*/){} // Set Slat Segmentation Parameters
- virtual void SetPadSize(Float_t /*p1*/, Float_t /*p2*/){;}; // Pad size Dx*Dy
- virtual void SetPcbBoards(Int_t /*n[4]*/){} // Set Segmentation Zones (PCB Boards)
+ virtual void SetId(Int_t id) {fId=id;} ///< Setting detection element
+ virtual void SetPad(Int_t ix, Int_t iy); // Set pad position
+ virtual void SetPadDivision(Int_t /*ndiv[4]*/){} ///< Set Slat Segmentation Parameters
+ virtual void SetPadSize(Float_t /*p1*/, Float_t /*p2*/){;}; ///< Pad size Dx*Dy
+ virtual void SetPcbBoards(Int_t /*n[4]*/){} ///< Set Segmentation Zones (PCB Boards)
// add to St345SlatSegmentation
virtual void SetLineNumber(Int_t iLineNumber);
virtual Int_t ModuleColNum(Int_t ixGlo);
// add to St345SlatSegmentation
// The following function could be obsolet for this class, but they are pure virtual in AliSegmentation
- virtual void GetNParallelAndOffset(Int_t /*iX*/, Int_t /*iY*/, Int_t */*Nparallel*/, Int_t */*Offset*/){};
- virtual Int_t SigGenCond(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/){return 0;} ; // Signal Generation Condition during Stepping
- virtual void SigGenInit(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/){}; // Initialise signal gneration at coord (x,y,z)
- virtual void GiveTestPoints(Int_t &/*n*/, Float_t * /*x*/, Float_t */*y*/) const{}; // Test points for auto calibration
- virtual void SetCorrFunc(Int_t /*dum*/, TF1* /*func*/){}; // Function for systematic corrections, Set the correction function
- virtual TF1* CorrFunc(Int_t) const {return 0x0;} // Get the correction Function
+ virtual void GetNParallelAndOffset(Int_t /*iX*/, Int_t /*iY*/, Int_t */*Nparallel*/, Int_t */*Offset*/){};///< Not implemented
+ virtual Int_t SigGenCond(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/){return 0;} ; ///< Signal Generation Condition during Stepping
+ virtual void SigGenInit(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/){}; ///< Initialise signal gneration at coord (x,y,z)
+ virtual void GiveTestPoints(Int_t &/*n*/, Float_t * /*x*/, Float_t */*y*/) const{}; ///< Test points for auto calibration
+ virtual void SetCorrFunc(Int_t /*dum*/, TF1* /*func*/){}; ///< Function for systematic corrections, Set the correction function
+ virtual TF1* CorrFunc(Int_t) const {return 0x0;} ///< Get the correction Function
virtual Int_t Sector(Float_t /*x*/, Float_t /*y*/) {return 1;}
- virtual void Init(Int_t /*detectionElementId*/){} // Initialisation
+ virtual void Init(Int_t /*detectionElementId*/){} ///< Initialisation
virtual void Init(Int_t detectionElementId,
Int_t nStrip[7],
Float_t stripYsize[7],
#include "TClass.h"
#include "TString.h"
+/// \cond CLASSIMP
ClassImp(AliMUONTriggerSegmentationV2)
+/// \endcond
namespace
{
fYhit(FMAX),
fLineNumber(-1)
{
- //
- // Default ctor (empty).
- //
+/// Default ctor (empty).
+
AliDebug(1,Form("this=%p default (empty) ctor",this));
}
fYhit(FMAX),
fLineNumber(-1)
{
- //
- // Normal ctor.
- //
+/// Normal ctor.
fSlatSegmentation = dynamic_cast<AliMpTriggerSegmentation*>(segmentation);
if (fSlatSegmentation)
fSlatSegmentation));
}
-//_____________________________________________________________________________
-AliMUONTriggerSegmentationV2::AliMUONTriggerSegmentationV2(const AliMUONTriggerSegmentationV2& rhs) : AliMUONVGeometryDESegmentation(rhs)
-{
-// Copy constructor
- AliFatal("Not implemented.");
-}
-
//_____________________________________________________________________________
AliMUONTriggerSegmentationV2::~AliMUONTriggerSegmentationV2()
{
- // Destructor
- AliDebug(1,Form("this=%p",this));
-}
+/// Destructor
-//_____________________________________________________________________________
-AliMUONTriggerSegmentationV2& AliMUONTriggerSegmentationV2::operator=(const AliMUONTriggerSegmentationV2& rhs)
-{
-// Protected assignement operator
- if (this == &rhs) return *this;
- AliFatal("Not implemented.");
- return *this;
+ AliDebug(1,Form("this=%p",this));
}
//_____________________________________________________________________________
TF1*
AliMUONTriggerSegmentationV2::CorrFunc(Int_t) const
{
-// Not implemented
+/// Not implemented
AliFatal("Not implemented");
return 0x0;
AliMUONTriggerSegmentationV2::Distance2AndOffset(Int_t, Int_t,
Float_t, Float_t, Int_t*)
{
-// Not implemented
+/// Not implemented
AliFatal("Not implemented");
return 0;
void
AliMUONTriggerSegmentationV2::Draw(Option_t*)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
}
Float_t
AliMUONTriggerSegmentationV2::Dpx() const
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
return 0.0;
Float_t
AliMUONTriggerSegmentationV2::Dpy() const
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
return 0.0;
Float_t
AliMUONTriggerSegmentationV2::Dpx(Int_t sectorCode) const
{
-// Get pad size in x
+/// Get pad size in x
Int_t ixLA, iyLA;
Decode(sectorCode,ixLA,iyLA);
Float_t
AliMUONTriggerSegmentationV2::Dpy(Int_t sectorCode) const
{
-// Get pad size in y
+/// Get pad size in y
Int_t ixLA, iyLA;
Decode(sectorCode,ixLA,iyLA);
AliMUONTriggerSegmentationV2::FirstPad(Float_t /*xhit*/, Float_t /*yhit*/, Float_t /*zhit*/,
Float_t /*dx*/, Float_t /*dy*/)
{
-// Not implemented
+/// Not implemented
AliFatal("Not implemented");
}
Float_t
AliMUONTriggerSegmentationV2::GetAnod(Float_t) const
{
-// Not implemented
+/// Not implemented
AliFatal("Not implemented");
return 0.0;
AliMUONGeometryDirection
AliMUONTriggerSegmentationV2::GetDirection()
{
-// Not implemented
+/// Not implemented
//AliWarning("Not Implemented");
return kDirUndefined;
const AliMpVSegmentation*
AliMUONTriggerSegmentationV2::GetMpSegmentation() const
{
-// Returns the mapping segmentation
-// (provides access to electronics info)
+/// Returns the mapping segmentation
+/// (provides access to electronics info)
return fSlatSegmentation;
}
void
AliMUONTriggerSegmentationV2::GetNParallelAndOffset(Int_t,Int_t,Int_t*,Int_t*)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
}
AliMUONTriggerSegmentationV2::GetPadC(Int_t ix, Int_t iy,
Float_t& x, Float_t& y, Float_t& z)
{
-// Transform from pad to real coordinates
+/// Transform from pad to real coordinates
z = 0;
GetPadC(ix,iy,x,y);
AliMUONTriggerSegmentationV2::GetPadC(Int_t ixGlo, Int_t iyGlo,
Float_t& x, Float_t& y)
{
-// Transform from pad to real coordinates
+/// Transform from pad to real coordinates
Int_t ixLA,iyLA;
IGlo2ILoc(ixGlo,iyGlo,ixLA,iyLA);
AliMUONTriggerSegmentationV2::GetPadI(Float_t x, Float_t y, Float_t,
Int_t& ix, Int_t& iy)
{
-// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
+/// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
GetPadI(x,y,ix,iy);
}
AliMUONTriggerSegmentationV2::GetPadI(Float_t x, Float_t y,
Int_t& ixGlo, Int_t& iyGlo)
{
-// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
+/// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
AliDebug(2,Form("%s x=%e y=%e ixGlo,iyGlo=%d,%d\n",
fSlatSegmentation->GetName(),
AliMUONTriggerSegmentationV2::GetPadLoc2Glo(Int_t ix, Int_t iy,
Int_t& ixGlo, Int_t& iyGlo) const
{
- //
- // Converts from local (in PC convention) to (ix,iy) to global (ix,iy)
- //
+/// Converts from local (in PC convention) to (ix,iy) to global (ix,iy)
ixGlo=iyGlo=-1; // starts with invalid values
AliMUONTriggerSegmentationV2::GetPadGlo2Loc(Int_t ixGlo, Int_t iyGlo,
Int_t& ix, Int_t& iy) const
{
- //
- // Converts from global (ix,iy) to local (ix,iy) (in PC convention)
- //
+/// Converts from global (ix,iy) to local (ix,iy) (in PC convention)
ix=iy=-1; // starts with invalid values
Bool_t
AliMUONTriggerSegmentationV2::HasPad(Float_t x, Float_t y, Float_t /*z*/)
{
-// Returns true if a pad exists in the given position
-
- //
- // Well, 2 implementations are possible here
- // Either reuse HasPad(int,int), or get it from scratch using
- // underlying fSlatSegmentation.
- // Took second option, but w/o checking whether this is the faster.
- // The second option is commented out below, for the record.
+/// Returns true if a pad exists in the given position
+///
+/// Well, 2 implementations are possible here
+/// Either reuse HasPad(int,int), or get it from scratch using
+/// underlying fSlatSegmentation.
+/// Took second option, but w/o checking whether this is the faster.
+/// The second option is commented out below, for the record.
// Int_t ix, iy;
// GetPadI(x,y,z,ix,iy);
Bool_t
AliMUONTriggerSegmentationV2::HasPad(Int_t ixGlo, Int_t iyGlo)
{
-// Returns true if a pad with given indices exists
+/// Returns true if a pad with given indices exists
Int_t ixLA, iyLA;
IGlo2ILoc(ixGlo,iyGlo,ixLA,iyLA);
AliMUONTriggerSegmentationV2::IGlo2ILoc(Int_t ixGlo, Int_t iyGlo,
Int_t& ixLA, Int_t& iyLA) const
{
-// FIXME: add comment
+/// \todo FIXME: add comment
Int_t ixPC, iyPC;
GetPadGlo2Loc(ixGlo,iyGlo,ixPC,iyPC);
AliMUONTriggerSegmentationV2::ILoc2IGlo(Int_t ixLA, Int_t iyLA,
Int_t& ixGlo, Int_t& iyGlo) const
{
-// FIXME: add comment
+/// \todo FIXME: add comment
Int_t ixPC, iyPC;
LA2PC(ixLA,iyLA,ixPC,iyPC);
Int_t
AliMUONTriggerSegmentationV2::ISector()
{
- // FIXME: remove the usage of ISector from all the code.
+/// \todo FIXME: remove the usage of ISector from all the code.
+
return -10;
}
Float_t& x3,
Float_t& x4)
{
- // x1 : hit x(y) position
- // x2 : x(y) coordinate of the main strip
- // x3 : current strip real x(y) coordinate
- // x4 : dist. between x(y) hit pos. and the closest border of the current strip
- //
- // Note : need to return (only) x4.
+/// \param x1 : hit x(y) position
+/// \param x2 : x(y) coordinate of the main strip
+/// \param x3 : current strip real x(y) coordinate
+/// \param x4 : dist. between x(y) hit pos. and the closest border of the current strip
+///
+/// Note : need to return (only) x4.
AliFatal("Check me before usage. ResponseTrigger does not use me, while"
"ResponseTriggerV1 does ?");
Int_t
AliMUONTriggerSegmentationV2::Ix()
{
-// Current pad cursor during disintegration
-// x, y-coordinate
+/// Current pad cursor during disintegration
+/// x, y-coordinate
if ( fCurrentPad.IsValid() )
{
Int_t
AliMUONTriggerSegmentationV2::Iy()
{
-// Current pad cursor during disintegration
-// x, y-coordinate
+/// Current pad cursor during disintegration
+/// x, y-coordinate
if ( fCurrentPad.IsValid() )
{
AliMUONTriggerSegmentationV2::LA2PC(Int_t ixLA, Int_t iyLA,
Int_t& ixPC, Int_t& iyPC) const
{
- //
- // From LA to PC conventions for integers indices.
- //
+/// From LA to PC conventions for integers indices.
+
ixPC=iyPC=-1;
if ( ixLA<0 || iyLA<0 ) return;
Int_t
AliMUONTriggerSegmentationV2::LineNumber() const
{
-// FIXME: add comment
+/// \todo FIXME: add comment
return 10-fLineNumber;
}
Int_t
AliMUONTriggerSegmentationV2::ModuleColNum(Int_t ixGlo) const
{
- // returns column number (from 0 to 6) in which the (global) module
- // ix is sitting (could return 7 if ix=isec)
+/// returns column number (from 0 to 6) in which the (global) module
+/// ix is sitting (could return 7 if ix=isec)
+
return TMath::Abs(ixGlo)-Int_t(TMath::Abs(ixGlo)/10)*10-1;
}
Int_t
AliMUONTriggerSegmentationV2::MorePads()
{
-// Not implemented
+/// Not implemented
AliFatal("Not implemented");
return 0;
Int_t /*Xlist*/[10],
Int_t /*Ylist*/[10])
{
+/// Not implemented
+
//-----------------BENDING-----------------------------------------
// Returns list of 10 next neighbours for given X strip (ix, iy)
// neighbour number 4 in the list -
void
AliMUONTriggerSegmentationV2::NextPad()
{
-// Not implemented
+/// Not implemented
AliFatal("Not implemented");
}
Int_t
AliMUONTriggerSegmentationV2::Npx() const
{
-// Maximum number of Pads in x
-// hard coded for the time being
+/// Maximum number of Pads in x
+/// hard coded for the time being
return 124;// FIXME: this should not have to be done, if only we'd stick
// to a local (ix,iy) convention !!!
Int_t
AliMUONTriggerSegmentationV2::Npy() const
{
-// Maximum number of Pads in y
-// hard coded for the time being
+/// Maximum number of Pads in y
+/// hard coded for the time being
return 64;
// return fSlatSegmentation->MaxPadIndexY()+1;
AliMUONTriggerSegmentationV2::PC2LA(Int_t ixPC, Int_t iyPC,
Int_t& ixLA, Int_t& iyLA) const
{
- //
- // From PC to LA conventions for integers indices.
- //
+/// From PC to LA conventions for integers indices.
+
ixLA=iyLA=-1;
if ( ixPC<0 || iyPC<0 ) return;
void
AliMUONTriggerSegmentationV2::Print(Option_t* opt) const
{
-// Printing
+/// Printing
TString sopt(opt);
Int_t
AliMUONTriggerSegmentationV2::Sector(Int_t ix, Int_t iy)
{
-// Calculate sector from pad coordinates
+/// Calculate sector from pad coordinates
Int_t ixLA, iyLA;
IGlo2ILoc(ix,iy,ixLA,iyLA);
Int_t
AliMUONTriggerSegmentationV2::Sector(Float_t, Float_t)
{
-// Not implemented
+/// Not implemented
AliFatal("Not implemented");
return 0;
void
AliMUONTriggerSegmentationV2::SetCorrFunc(Int_t,TF1*)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
}
void
AliMUONTriggerSegmentationV2::SetDAnod(Float_t)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
}
void
AliMUONTriggerSegmentationV2::SetHit(Float_t x, Float_t y)
{
-// Set hit position
-// Sets virtual hit position, needed for evaluating pad response
-// outside the tracking program
+/// Set hit position
+/// Sets virtual hit position, needed for evaluating pad response
+/// outside the tracking program
fXhit = x;
fYhit = y;
void
AliMUONTriggerSegmentationV2::SetHit(Float_t x, Float_t y, Float_t)
{
-// Set hit position
-// Sets virtual hit position, needed for evaluating pad response
-// outside the tracking program
+/// Set hit position
+/// Sets virtual hit position, needed for evaluating pad response
+/// outside the tracking program
SetHit(x,y);
}
void
AliMUONTriggerSegmentationV2::SetPad(Int_t ix, Int_t iy)
{
-// Set pad position.
-// Sets virtual pad coordinates, needed for evaluating pad response
-// outside the tracking program.
+/// Set pad position.
+/// Sets virtual pad coordinates, needed for evaluating pad response
+/// outside the tracking program.
Int_t ixLA, iyLA;
IGlo2ILoc(ix,iy,ixLA,iyLA);
void
AliMUONTriggerSegmentationV2::SetPadSize(Float_t,Float_t)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
}
Int_t
AliMUONTriggerSegmentationV2::SigGenCond(Float_t,Float_t,Float_t)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
return 0;
void
AliMUONTriggerSegmentationV2::SigGenInit(Float_t,Float_t,Float_t)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
}
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 Init(Int_t) {}
+ virtual void Init(Int_t) {} ///< Not implemented
virtual void IntegrationLimits(Float_t& x1, Float_t& x2, Float_t& y1, Float_t& y2);
#include "AliMUONV1DStore.h"
-///
+/// \class AliMUONV1DStore
/// Defines an interface equivalent to a list of TObject, indexed
/// by integer (somehow a vector, except that indices are not necessarily
/// sequential).
/// It's extremely simple and hopefully allow many implementations.
/// It also makes the object ownership self-evident.
///
+/// \author Laurent Aphecetche
+/// \cond CLASSIMP
ClassImp(AliMUONV1DStore)
+/// \endcond
//_____________________________________________________________________________
AliMUONV1DStore::AliMUONV1DStore()
{
+/// Default constructor
}
//_____________________________________________________________________________
AliMUONV1DStore::~AliMUONV1DStore()
{
+/// Destructor
}
/// \class AliMUONV1DStore
/// \brief Generic container indexed by a single integer.
///
-/// \author Laurent Aphecetche
+// Author Laurent Aphecetche
#ifndef AliMUONV1DSTORE_H
#define AliMUONV1DSTORE_H
#include "AliMUONV2DStore.h"
-///
+/// \class AliMUONV2DStore
/// Defines an interface equivalent to a 2D array of TObject, indexed
/// by a pair of integers (somehow a matrix,
/// except that indices are not necessarily sequential).
/// It's extremely simple and hopefully allow many implementations.
/// It also makes the object ownership self-evident.
///
+/// \author Laurent Aphecetche
+/// \cond CLASSIMP
ClassImp(AliMUONV2DStore)
+/// \endcond
//_____________________________________________________________________________
AliMUONV2DStore::AliMUONV2DStore()
{
+/// Default constructor
}
//_____________________________________________________________________________
AliMUONV2DStore::~AliMUONV2DStore()
{
+/// Destructor
}
/// \class AliMUONV2DStore
/// \brief Generic container indexed by a pair of integers.
///
-/// \author Laurent Aphecetche
+// Author Laurent Aphecetche
#ifndef AliMUONV2DSTORE_H
#define AliMUONV2DSTORE_H
///
/// \author Laurent Aphecetche
+/// \cond CLASSIMP
ClassImp(AliMUONVCalibParam)
+/// \endcond
//_____________________________________________________________________________
AliMUONVCalibParam::AliMUONVCalibParam() : TObject()
{
- // ctor
+/// Default constructor
}
//_____________________________________________________________________________
AliMUONVCalibParam::~AliMUONVCalibParam()
{
- //
- // dtor (virtual).
- //
+/// Destructor.
}
#include <string>
+/// \cond CLASSIMP
ClassImp(AliMUONv1)
+/// \endcond
//___________________________________________
AliMUONv1::AliMUONv1()
fAngleEffectNorma->SetParameter(3,-1.490e-03);
}
-//_____________________________________________________________________________
-AliMUONv1::AliMUONv1(const AliMUONv1& right)
- : AliMUON(right)
-{
-/// Copy constructor (not implemented)
-
- AliFatal("Copy constructor not provided.");
-}
-
//___________________________________________
AliMUONv1::~AliMUONv1()
{
delete fAngleEffectNorma;
}
-//_____________________________________________________________________________
-AliMUONv1& AliMUONv1::operator=(const AliMUONv1& right)
-{
-/// Assignement operator (not implemented)
-
- // check assignement to self
- if (this == &right) return *this;
-
- AliFatal("Assignement operator not provided.");
-
- return *this;
-}
-
//__________________________________________________
void AliMUONv1::CreateGeometry()
{
Int_t AliMUONv1::GetChamberId(Int_t volId) const
{
/// Check if the volume with specified volId is a sensitive volume (gas)
-/// of some chamber and returns the chamber number;
+/// of some chamber and return the chamber number;
/// if not sensitive volume - return 0.
for (Int_t i = 0; i < AliMUONConstants::NCh(); i++) {
virtual void CreateGeometry();
virtual void CreateMaterials();
virtual void Init();
+
+ /// Return the version number of this detector
virtual Int_t IsVersion() const {return 1;}
+
virtual void StepManager();
+ /// Set option to take into account angle effect
void SetAngleEffect(Bool_t Opt)
{ fAngleEffect = Opt; }
+
+ /// Set max step max in active gas
void SetStepMaxInActiveGas(Float_t StepMax)
{fStepMaxInActiveGas = StepMax; }
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff