/* $Id$ */
-// ------------------
+//-----------------------------------------------------------------------------
// Class AliMUON
// ------------------
// AliDetector class for MUON subsystem
// providing simulation data management
+//-----------------------------------------------------------------------------
#include "Riostream.h"
#include <TClass.h>
#include <TObjArray.h>
#include <Riostream.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)
#include "AliMpExMap.h"
#include "AliMUON1DMapIterator.h"
-///
+//-----------------------------------------------------------------------------
/// \class AliMUON1DMap
/// This class is simply a wrapper to an AliMpExMap, offering in addition a
/// control over the replacement policy when you add
/// something to it.
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUON1DMap)
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUON1DMapIterator
/// Implementation of TIterator for 1Dmaps
///
/// A simple implementation of VDataIterator for 1Dmaps.
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
#include "AliMUON1DMapIterator.h"
#include "AliMpExMap.h"
#include "AliMpDEManager.h"
#include "AliMpConstants.h"
+//-----------------------------------------------------------------------------
/// \class AliMUON2DMap
/// Basic implementation of AliMUONVStore container using
/// AliMpExMap internally.
/// What we store is a "double" map : an AliMpExMap of AliMpExMaps
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUON2DMap)
#include "AliMUON2DMapIterator.h"
+//-----------------------------------------------------------------------------
/// \class AliMUON2DMapIterator
/// Implementation of TIterator for 2Dmaps
///
/// A simple implementation of VDataIterator for 2Dmaps.
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
#include "AliMpExMap.h"
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUON2DMapIteratorByI
///
/// Implementation of TIterator for 2D maps
/// (i,j) used to index values in the map).
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
#include "AliMUON2DMapIteratorByI.h"
#include <TObjArray.h>
#include <TObjString.h>
+//-----------------------------------------------------------------------------
/// \class AliMUON2DStoreValidator
///
/// Determine which channels, manus, DEs, stations are missing
/// contains k TObjString = Form("%d",manuChannel)
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUON2DStoreValidator)
#include <Riostream.h>
+//-----------------------------------------------------------------------------
/// \class AliMUONBlockHeader
/// Block structure for tracker raw data
/// each DDL contains two blocks,
/// the header of the block contains the front end DSP id, trigger words and paddind word
///
/// \author Christian Finck
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONBlockHeader)
#include <Riostream.h>
#include <string.h>
+//-----------------------------------------------------------------------------
/// \class AliMUONBusStruct
/// Bus patch structure for tracker raw data
/// each Dsp contains at most 5 bus patch structure
/// 12 bits for charge)
///
/// \author Christian Finck
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONBusStruct)
/* $Id$ */
+//-----------------------------------------------------------------------------
/// \class AliMUONCDB
///
/// Helper class to experience the OCDB
/// For more information, please see READMECDB
///
// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
#include "AliMUONCDB.h"
#include "TMath.h"
#include "TString.h"
-///
+//-----------------------------------------------------------------------------
/// \class AliMUONCalibParamND
///
/// Handle the case of N floating point (double precision) parameters per channel.
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONCalibParamND)
#include "TMath.h"
#include "TString.h"
-///
+//-----------------------------------------------------------------------------
/// \class AliMUONCalibParamNF
///
/// Handle the case of N floating point parameters per channel.
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONCalibParamNF)
#include "TMath.h"
#include "TString.h"
-///
+//-----------------------------------------------------------------------------
/// \class AliMUONCalibParamNI
///
/// Handle the case of N integer parameters per channel.
/// and use the correct type.
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONCalibParamNI)
#include "Riostream.h"
#include "TMap.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONCalibrationData
///
/// For the moment, this class stores pedestals, gains, hv (for tracker)
/// containers/calibration classes.
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONCalibrationData)
/* $Id$ */
-// -----------------------
+//-----------------------------------------------------------------------------
// Class AliMUONChamber
// -----------------------
// MUON tracking chamber class
// now only providing DisIntegration function
+//-----------------------------------------------------------------------------
// --- ROOT includes ---
#include <TRandom.h>
#include "AliMUONGeometryTransformer.h"
#include "AliLog.h"
-///
+//-----------------------------------------------------------------------------
/// \class AliMUONChamberTrigger
///
/// Implementation of AliMUONChamber for the trigger
///
/// \deprecated This class is to be deprecated.
///
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONChamberTrigger)
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONCheck
///
/// This class check the ESD tree, providing the matching with the trigger
/// DumpDigit() as a replacement of the function from MUONCheck.C macro.
///
/// \author Frederic Yermia, INFN Torino
+//-----------------------------------------------------------------------------
#include "AliMUONCheck.h"
#include "AliMUONConstants.h"
#include "Riostream.h"
#include "AliMUONCheckItemIterator.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONCheckItem
///
/// A structure used to gather information at different levels (ch,manu,de,chamber)
///
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONCheckItem)
#include "AliMpExMap.h"
#include "AliMUONCheckItem.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONCheckItemIterator
///
/// Iterator on AliMUONCheckItem objects
///
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONCheckItemIterator)
#include "AliLog.h"
#include "AliMUONPad.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONCluster
///
/// A group of adjacent pads
///
/// \author Laurent Aphecetche
///
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONCluster)
/* $Id$ */
-// -------------------------------
+//-----------------------------------------------------------------------------
// Class AliMUONClusterFinderAZ
// -------------------------------
// Clusterizer class based on the Expectation-Maximization algorithm
// Author: Alexander Zinchenko, JINR Dubna
+//-----------------------------------------------------------------------------
#include "AliMUONClusterFinderAZ.h"
#include "AliMpVSegmentation.h"
#include "TVector2.h"
#include "AliMUONVDigitStore.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONClusterFinderCOG
///
/// A very basic (and mostly useless, probably) cluster finder.
/// direction with the better resolution.
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONClusterFinderCOG)
/* $Id$ */
+//-----------------------------------------------------------------------------
/// \class AliMUONClusterFinderMLEM
///
/// Clusterizer class based on the Expectation-Maximization algorithm
///
/// \author Laurent Aphecetche (for the "new" C++ structure) and
/// Alexander Zinchenko, JINR Dubna, for the hardcore of it ;-)
+//-----------------------------------------------------------------------------
#include "AliMUONClusterFinderMLEM.h"
#include "AliLog.h"
#include "AliMUONVDigitStore.h"
#include <Riostream.h>
+//-----------------------------------------------------------------------------
/// \class AliMUONClusterFinderSimpleFit
///
/// Basic cluster finder
/// FIXME: this one is still at the developping stage...
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONClusterFinderSimpleFit)
/* $Id$ */
+//-----------------------------------------------------------------------------
/// \class AliMUONClusterReconstructor
///
/// This class is just a steering class to loop over detection elements of tracking chambers,
///
/// \author C. Finck and L. Aphecetche, Subatech
///
+//-----------------------------------------------------------------------------
#include "AliMUONClusterReconstructor.h"
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONClusterSplitterMLEM
///
/// Splitter class for the MLEM algorithm...
///
/// \author Laurent Aphecetche (for the "new" C++ structure) and
/// Alexander Zinchenko, JINR Dubna, for the hardcore of it ;-)
+//-----------------------------------------------------------------------------
#include "AliMUONClusterSplitterMLEM.h"
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONClusterStoreV1
///
/// Implementation of VClusterStore.
///
/// \author Laurent Aphecetche, Subatech
///
+//-----------------------------------------------------------------------------
#include "AliMUONClusterStoreV1.h"
**************************************************************************/
// $Id$
-//
+
+//-----------------------------------------------------------------------------
// Class AliMUONCommonGeometryBuilder
// ----------------------------------
// Geometry construction common to all stations
// (material definition).
// separated from AliMUONGeometryBuilder
+//-----------------------------------------------------------------------------
#include <TVirtualMC.h>
#include "TClass.h"
#include "AliMpConstants.h"
-///
+//-----------------------------------------------------------------------------
/// \class AliMUONConstants
/// This class holds various constants to be used in many places,
/// such as the number of tracking and trigger chambers,
/// Those constants should as much as possible replace hard-coded values
/// which are to be considered strictly illegal in the MUON code (or any code,
/// by the way).
-///
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONConstants)
#include "AliMUONDspHeader.h"
#include "AliMUONBlockHeader.h"
-///
+
+//-----------------------------------------------------------------------------
/// \class AliMUONDDLTracker
///
/// A wrapper object for 1 DDL of the MUON tracking chambers.
///
/// \author C. Finck
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONDDLTracker)
#include "AliMUONRegHeader.h"
#include "AliMUONDarcHeader.h"
-///
+
+//-----------------------------------------------------------------------------
/// \class AliMUONDDLTrigger
///
/// One DDL for trigger part of the MUON spectrometer.
///
/// \author C. Finck
-///
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONDDLTrigger)
#include "AliMUONDarcHeader.h"
#include "AliMUONRegHeader.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONDarcHeader
/// Darc structure for trigger raw data.
/// Each DDL contains one Darc structure
/// regional structures.
///
/// \author Christian Finck
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONDarcHeader)
#include <TNtuple.h>
#include <TSystem.h>
-///
+//-----------------------------------------------------------------------------
/// \class AliMUONDataInterface
///
/// An easy to use interface to the MUON data data stored in
/// it is the easiest.
///
/// \author Laurent Aphecetche, Subatech
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONDataInterface)
#include "AliMUONDigit.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONDigit
/// A class representing a digit (with MC information if possible)
/// in the MUON spectrometer either in tracking or trigger chambers.
/// This class is used to represent either sdigits (purely simulated digit,
/// with no electronic noise whatsoever) or digits (simulated ones but
/// including electronic noise and de-calibration, to closely ressemble real ones).
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONDigit)
#include "AliMUONVStore.h"
#include "AliMUONVCalibParam.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONDigitCalibrator
/// Class used to calibrate digits (either real or simulated ones).
///
/// bad digits).
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
* provided "as is" without express or implied warranty. *
**************************************************************************/
+// $Id$
+
+//-----------------------------------------------------------------------------
/// \class AliMUONDigitMaker
/// MUON Digit maker from rawdata.
///
/// and for trigger. Create trigger inverse mapping.
///
/// \author Ch. Finck, oct 06
+//-----------------------------------------------------------------------------
#include "AliMUONDigitMaker.h"
#include "AliMUONDigitStoreV1.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONDigitStoreV1
///
/// (Legacy) Implementation of AliMUONVDigitStore.
/// to data stores.
///
// \author Laurent Aphecetche, Subatech
-///
+//-----------------------------------------------------------------------------
#include "AliLog.h"
#include "AliMUONDigit.h"
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONDigitStoreV1Iterator
///
/// Implementation of TIteraor for AliMUONVDigitStoreV1
/// Reuses the AliMUONTOTCAStoreIterator iterator
///
/// \author Laurent Aphecetche, Subatech
+//-----------------------------------------------------------------------------
#include "AliMUONDigitStoreV1Iterator.h"
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONDigitStoreV2R
///
/// Concrete implementation of AliMUONVDigitStore for real digits, using
/// the AliMUONDigitStoreVImpl base implementation
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
#include "AliMUONDigitStoreV2R.h"
#include "AliMUONDigitStoreV2S.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONDigitStoreV2S
///
/// Concrete implementation of AliMUONVDigitStore for simulated digits, using
/// the AliMUONDigitStoreVImpl base implementation
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
#include "AliMUONDigit.h"
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONDigitStoreVImpl
///
/// Base implementation of VDigitStore, where digits are simply put
/// methods.
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
#include "AliMUONDigitStoreVImpl.h"
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONDigitStoreVImplIterator
///
/// Implementation of AliMUONVDataIterator for AliMUONDigitStoreVImpl
///
/// \author Laurent Aphecetche, Subatech
///
+//-----------------------------------------------------------------------------
#include "AliMUONDigitStoreVImplIterator.h"
#include <TSystem.h>
#include "AliMUONGeometryTransformer.h" //ADDED for trigger noise
-///
+
+//-----------------------------------------------------------------------------
/// \class AliMUONDigitizerV3
/// The digitizer is performing the transformation to go from SDigits (digits
/// w/o any electronic noise) to Digits (w/ electronic noise, and decalibration)
/// here, at the digitization level).
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
namespace
{
#include "AliMUONBusStruct.h"
#include <Riostream.h>
+//-----------------------------------------------------------------------------
/// \class AliMUONDspHeader
/// DSP structure for tracker raw data.
/// Each block contains at most 5 Dsp structures.
/// and event word (1 for nb of word is odd and 0 if not
///
/// \author Christian Finck
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONDspHeader)
**************************************************************************/
// $Id$
-//
+
+//-----------------------------------------------------------------------------
// Class AliMUONGMSSubprocessor
// -----------------------------
// The shuttle subprocessor for GMS data
// Author: Ivana Hrivnacova, IPN Orsay
// 16/09/2006
+//-----------------------------------------------------------------------------
#include "AliMUONGMSSubprocessor.h"
#include "AliMUONPreprocessor.h"
#include "AliMUONGainEventGenerator.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONGainEventGenerator
///
/// Generate raw data files that mimics the one we'll get from the
/// the first step, to check that everything is OK in the whole procedure.
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
#include "AliMUONCalibrationData.h"
#include "AliMUONVStore.h"
#include <TSystem.h>
#include <sstream>
-///
+//-----------------------------------------------------------------------------
/// \class AliMUONGainSubprocessor
///
/// Implementation of AliMUONVSubprocessor class to deal with MUON TRK Gains.
///
/// \author L. Aphecetche
///
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONGainSubprocessor)
**************************************************************************/
// $Id$
-//
-// ----------------------------
+
+//-----------------------------------------------------------------------------
// Class AliMUONGeometry
// ----------------------------
// Manager class for geometry construction via geometry builders.
// Author: Ivana Hrivnacova, IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMUONGeometry.h"
#include "AliMUONGeometryTransformer.h"
**************************************************************************/
// $Id$
-//
-// ----------------------------
+
+//-----------------------------------------------------------------------------
// Class AliMUONGeometryBuilder
// ----------------------------
// Manager class for geometry construction via geometry builders.
// Author: Ivana Hrivnacova, IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMUONGeometryBuilder.h"
#include "AliMUONVGeometryBuilder.h"
**************************************************************************/
// $Id$
-//
+
+//-----------------------------------------------------------------------------
// Class AliMUONGeometryConstituent
// -----------------------------
// Helper class for definititon of an assembly of volumes.
// Author: Ivana Hrivnacova, IPN Orsay
// 23/01/2004
+//-----------------------------------------------------------------------------
#include <TGeoMatrix.h>
**************************************************************************/
// $Id$
-//
-// --------------------------------------
+
+//-----------------------------------------------------------------------------
// Class AliMUONGeometryDetElement
// --------------------------------------
// The class defines the detection element.
// Author: Ivana Hrivnacova, IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMUONGeometryDetElement.h"
**************************************************************************/
// $Id$
-//
+
+//-----------------------------------------------------------------------------
// Class AliMUONGeometryEnvelope
// -----------------------------
// Helper class for definititon of an assembly of volumes.
// Author: Ivana Hrivnacova, IPN Orsay
// 23/01/2004
+//-----------------------------------------------------------------------------
#include <TGeoMatrix.h>
#include <TString.h>
// $Id$
-// ----------------------------------
+//-----------------------------------------------------------------------------
// Class AliMUONGeometryEnvelopeStore
// ----------------------------------
// Class for definititon of the temporary volume envelopes
// used in geometry construction
// Author: Ivana Hrivnacova, IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMUONGeometryEnvelopeStore.h"
#include "AliMUONGeometryEnvelope.h"
// $Id$
//
-//__________________________________________________________________
+//-----------------------------------------------------------------------------
/// \class AliMUONGeometryMisAligner
///
/// This performs the misalignment on an existing muon arm geometry
/// two angles are alignable as well.
///
/// \author Bruce Becker, Javier Castillo
+//-----------------------------------------------------------------------------
#include "AliMUONGeometryMisAligner.h"
#include "AliMUONGeometryTransformer.h"
**************************************************************************/
// $Id$
-//
+
+//-----------------------------------------------------------------------------
// Class AliMUONGeometryModule
// -----------------------------
// Class for definition of the detector module parameters
// sensitive volumes and detection elements).
//
// Author: Ivana Hrivnacova, IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMUONGeometryModule.h"
#include "AliMUONGeometryModuleTransformer.h"
**************************************************************************/
// $Id$
-//
-// -------------------------------------
+
+//-----------------------------------------------------------------------------
// Class AliMUONGeometryModuleTransformer
// -------------------------------------
// Class for definition of the detector module transformations
// Author: Ivana Hrivnacova, IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMUONGeometryModuleTransformer.h"
#include "AliMUONGeometryDetElement.h"
**************************************************************************/
// $Id$
-//
-// ----------------------------
+
+//-----------------------------------------------------------------------------
// Class AliMUONGeometryTransformer
// ----------------------------
// Top container class for geometry transformations
// Author: Ivana Hrivnacova, IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMUONGeometryTransformer.h"
#include "AliMUONGeometryModuleTransformer.h"
#include "AliLog.h"
#include "AliMUONLocalStruct.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONGlobalTrigger
/// Global Trigger algorithm data output.
/// Built from Local and Regional algorithms. \n
/// add SetGlobalPattern and GetGlobalPattern method for rawdata
/// (Ch. Finck)
/// \author Ph. Crochet
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONGlobalTrigger)
/* $Id$ */
+//-----------------------------------------------------------------------------
/// \class AliMUONGlobalTriggerBoard
/// Global trigger implementation:
/// - inputs are regional responses
/// \todo Change member functions comments in capital letters to normal text
///
/// \author Rachid Guernane (LPCCFd)
+//-----------------------------------------------------------------------------
#include "AliMUONGlobalTriggerBoard.h"
#include "AliLog.h"
#include "TString.h"
#include "TSystem.h"
-/// $Id$
-///
+//-----------------------------------------------------------------------------
/// \class AliMUONHVNamer
///
/// A utility class to manage HV DCS aliases names, in particular the
/// two conventions used to number the detection elements within a detector.
///
/// \author: Laurent Aphecetche, Subatech
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONHVNamer)
**************************************************************************/
/// $Id$
+
+//-----------------------------------------------------------------------------
/// \class AliMUONHVSubprocessor
///
/// A subprocessor to read HV values for one run
/// from the MUON TRK, and dumps this copy into the CDB
///
/// \author Laurent Aphecetche, Subatech
+//-----------------------------------------------------------------------------
#include "AliMUONHVSubprocessor.h"
#include "AliMUONHVNamer.h"
/* $Id$ */
+//-----------------------------------------------------------------------------
// 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
// Cumulated path along the active volume fTlength for spliting of hits for very inclined tracks
// Energy loss of the particle inside the gas active volume.
// Incident fTheta and fPhi angle with respect of the wire plane of the chamber.
-//
+//-----------------------------------------------------------------------------
#include "AliMUONHit.h"
#include "AliMpDEManager.h"
/* $Id$ */
-// ------------------------
+//-----------------------------------------------------------------------------
// Class AliMUONHitForRec
// ------------------------
// Hit for reconstruction in ALICE dimuon spectrometer
// Author: J. Gosset
+//-----------------------------------------------------------------------------
#include "AliTrackReference.h"
#include "AliMUONHitForRec.h"
#include "AliMUONHitStoreV1.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONHitStoreV1
///
/// Implementation of AliMUONVHitStore
///
/// \author Laurent Aphecetche, Subatech
-///
+//-----------------------------------------------------------------------------
#include <TClonesArray.h>
#include <TTree.h>
#include "AliMUONLocalStruct.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONLocalStruct
/// Local structure for trigger raw data.
/// The structure includes the information
/// x position)
///
/// \author Christian Finck
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONLocalStruct)
#include <Riostream.h>
#include <TArrayS.h>
+//-----------------------------------------------------------------------------
/// \class AliMUONLocalTrigger
/// Local Trigger algorithm data outputs
/// (contains local trigger decision and bit patterns) \n
/// Add SetLocalStruct method for rawdata (Ch. Finck)
/// \author Ph. Crochet
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONLocalTrigger)
/* $Id$ */
+//-----------------------------------------------------------------------------
/// \class AliMUONLocalTriggerBoard
/// A local trigger board has as input a bit pattern and returns
/// the local trigger response after comparison w/ a LUT
/// \todo Change member functions comments in capital letters to normal text
///
/// \author Rachid Guernane (LPCCFd)
+//-----------------------------------------------------------------------------
#include "AliMUONLocalTriggerBoard.h"
#include "AliMUONTriggerLut.h"
#include "AliLog.h"
#include "Riostream.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONLogger
///
/// A logger that keeps track of the number of times a message appeared.
/// only once when DigitizerV3 is destroyed.
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONLogger)
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONMCDataInterface
///
/// Easy to use MC data accessor
///
/// \author Laurent Aphecetche, Subatech
-///
+//-----------------------------------------------------------------------------
#include "AliMUONMCDataInterface.h"
#include "AliMUONVDigitStore.h"
/* $Id$ */
-// -----------------------
+//-----------------------------------------------------------------------------
// Class AliMUONMathieson
// -----------------------
// Implementation of Mathieson response
// Separated from other classes by CH. Finck with removing circular
// dependencies
+//-----------------------------------------------------------------------------
#include "AliMUONMathieson.h"
#include "AliLog.h"
#include <Riostream.h>
+//-----------------------------------------------------------------------------
/// \class AliMUONObjectPair
///
/// The equivalent of a std::pair<TObject*,TObject*> ;-)
/// we decide on the ownership of the first and/or second object...
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONObjectPair)
#include "TVector2.h"
#include "TMath.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONPad
///
/// Object gathering information about a hit pad.
/// get neighboring information.
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONPad)
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONPadStatusMaker
///
/// Make a 2DStore of pad statuses, using different sources of information,
/// like pedestal values, gain values, and HV values.
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
#include "AliMUONPadStatusMaker.h"
**************************************************************************/
// $Id$
+
+//-----------------------------------------------------------------------------
/// \class AliMUONPadStatusMapMaker
///
/// Convert a pad status container into a pad status *map* container
/// (i.e. a non-existing neighbour is considered = bad).
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
#include "AliMUONPadStatusMapMaker.h"
/* $Id$ */
-//===================================================================
+//-----------------------------------------------------------------------------
//This class was prepared by INFN Cagliari, July 2006
//(authors: H.Woehri, A.de Falco)
//
// for information about the dimuon, use PrintInfo with the appropriate
// printflag
// To be used together with AliMUONTrackLight
-//===================================================================
+//-----------------------------------------------------------------------------
//MUON classes
* provided "as is" without express or implied warranty. *
**************************************************************************/
-///
+// $Id$
+
+//-----------------------------------------------------------------------------
/// \class AliMUONPayloadTracker
/// Decodes rawdata from buffer and stores in TClonesArray.
/// First version implement for Tracker
///
/// \author Christian Finck
+//-----------------------------------------------------------------------------
#include "AliMUONPayloadTracker.h"
* provided "as is" without express or implied warranty. *
**************************************************************************/
+// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONPayloadTrigger
/// Class Payload
///
/// First version implement for Trigger
///
/// \author Christian Finck
+//-----------------------------------------------------------------------------
#include "AliMUONPayloadTrigger.h"
#include <TSystem.h>
#include "AliDAQ.h"
-///
+//-----------------------------------------------------------------------------
/// \class AliMUONPedestalEventGenerator
///
/// Generate simulated pedestal events for MUON TRK, to be able to e.g. test
/// + raw (date files, one per LDC), depending of ctor and MakeDDL() method.
///
/// \author L. Aphecetche
-///
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONPedestalEventGenerator)
#include <TSystem.h>
#include <sstream>
-///
+//-----------------------------------------------------------------------------
/// \class AliMUONPedestalSubprocessor
///
/// Implementation of AliMUONVSubprocessor class to deal with MUON TRK pedestals.
///---------------------------------------------------------------------------\n
///
/// \author L. Aphecetche
-///
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONPedestalSubprocessor)
/* $Id$ */
+//-----------------------------------------------------------------------------
/// \class AliMUONPixel
/// Basic object of the cluster / rec. point finder based
/// on Expectation-Minimization approach (AZ cluster finder)
///
/// \author Alexander Zinchenko, JINR Dubna
+//-----------------------------------------------------------------------------
#include "AliMUONPixel.h"
#include "AliMUONVDigitStore.h"
//#include "AliCodeTimer.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONPreClusterFinder
///
/// Implementation of AliMUONVClusterFinder
/// This class simply find adjacent pads to form clusters
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
ClassImp(AliMUONPreClusterFinder)
#include "AliMUONVDigit.h"
#include "AliMUONVDigitStore.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONPreClusterFinderV2
///
/// Implementation of AliMUONVClusterFinder
/// This one ressembles the preclustering stage in the original ClusterFinderAZ
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
ClassImp(AliMUONPreClusterFinderV2)
#include <Riostream.h>
//#include "AliCodeTimer.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONPreClusterFinderV3
///
/// Implementation of AliMUONVClusterFinder
/// should not depend on the order of the input digits.
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
ClassImp(AliMUONPreClusterFinderV3)
#include "Riostream.h"
#include "TObjArray.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONPreprocessor
///
/// Shuttle preprocessor for MUON subsystems (TRK and TRG)
/// (of type AliMUONVSubprocessor).
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONPreprocessor)
/* $Id$ */
-// -------------------------
+//-----------------------------------------------------------------------------
// Class AliMUONRawCluster
// -------------------------
// Class for the MUON RecPoint
// It contains the properties of the physics cluters found in the tracking chambers
// RawCluster contains also the information from the both cathode of the chambers.
+//-----------------------------------------------------------------------------
#include "Riostream.h"
/* $Id $ */
-///////////////////////////////////////////////////////////////////////////////
-///
+//-----------------------------------------------------------------------------
/// \class AliMUONRawStreamTracker
/// This class provides access to MUON digits in raw data.
///
/// Version implement for Tracker
///
/// \author Christian Finck & Laurent Aphecetche
-///////////////////////////////////////////////////////////////////////////////
+//-----------------------------------------------------------------------------
#include "AliMUONRawStreamTracker.h"
/* $Id $ */
-///////////////////////////////////////////////////////////////////////////////
-///
+//-----------------------------------------------------------------------------
/// \class AliMUONRawStreamTrigger
/// This class provides access to MUON digits in raw data.
///
///
/// First version implement for Trigger
/// \author Christian Finck
-///
-///////////////////////////////////////////////////////////////////////////////
+//-----------------------------------------------------------------------------
#include "AliMUONRawStreamTrigger.h"
/* $Id$ */
+//-----------------------------------------------------------------------------
/// \class AliMUONRawWriter
/// MUON Raw Data generaton in ALICE-MUON
/// Raw data structure could be found in Alice-note.
/// Using AliMpDDLStore::GetBusPatchId.
///
/// \author Ch. Finck, Feb. 07.
+//-----------------------------------------------------------------------------
#include "AliMUONRawWriter.h"
#include "AliMUONRealDigit.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONRealDigit
///
/// Implementation of AliMUONVDigit for real digit.
/// This class should store the bare minimum in order to save disk space
///
/// \author Laurent Aphecetche
-///
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONRealDigit)
/* $Id$ */
+//-----------------------------------------------------------------------------
/// \class AliMUONRecoCheck
/// 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 "AliMUONRecoCheck.h"
#include "AliMUONHitForRec.h"
/* $Id$ */
+//-----------------------------------------------------------------------------
/// \class AliMUONRecoTrack
/// This class represents a reconstructed muon track
/// in the tree of reconstructed events.
///
/// \author Mihaela Gheata, Andrei Gheata 09/10/00
+//-----------------------------------------------------------------------------
#include <Riostream.h>
**************************************************************************/
/* $Id$ */
+//-----------------------------------------------------------------------------
/// \class AliMUONReconstructor
///
/// Implementation of AliReconstructor for MUON subsystem.
/// DIGITSTOREV2R : use the V2R implementation of the digitstore
///
/// \author Laurent Aphecetche, Subatech
+//-----------------------------------------------------------------------------
#include "AliMUONReconstructor.h"
#include "AliMUONRegHeader.h"
#include "AliMUONLocalStruct.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONRegHeader
/// Regional structure for trigger raw data.
/// Each Reg structure contains 16 (at most) local card structure.
/// regional inputs
///
/// \author Christian Finck
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONRegHeader)
#include "AliMUONRegionalTrigger.h"
#include "AliLog.h"
-// -----------------------------
+//-----------------------------------------------------------------------------
// Class AliMUONRegionalTrigger
// -----------------------------
// Regional Trigger algorithm data outputs
// Author: Ch. Finck
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONRegionalTrigger)
/* $Id$ */
+//-----------------------------------------------------------------------------
/// \class AliMUONRegionalTriggerBoard
/// Dimuon regional trigger implementation:
/// - entry are local board responses
/// \todo Change member functions comments in capital letters to normal text
///
/// \author Rachid Guernane (LPCCFd)
+//-----------------------------------------------------------------------------
#include "AliMUONRegionalTriggerBoard.h"
/* $Id$ */
-// -------------------------
+//-----------------------------------------------------------------------------
// Class AliMUONResponse
// -------------------------
// Chamber response base class
-// ...
+//-----------------------------------------------------------------------------
#include "AliMUONResponse.h"
* provided "as is" without express or implied warranty. *
**************************************************************************/
-// -----------------------------
+/* $Id$ */
+
+//-----------------------------------------------------------------------------
// Class AliMUONResponseFactory
// -----------------------------
// Factory for muon response
// Class separated from AliMUONFactoryV4
-
-/* $Id$ */
+//-----------------------------------------------------------------------------
#include "AliMUONResponseFactory.h"
#include "AliRun.h"
/* $Id$ */
-// -------------------------------
+
+//-----------------------------------------------------------------------------
// Class AliMUONResponseTrigger
// -------------------------------
// Implementation
// of RPC response
+//-----------------------------------------------------------------------------
#include "AliMUONResponseTrigger.h"
/* $Id$ */
-// ------------------
+//-----------------------------------------------------------------------------
// Class AliMUONTriggerResponseV1
// ------------------
// Trigger chamber response
// with cluster size activated
+//-----------------------------------------------------------------------------
#include "AliMUONResponseTriggerV1.h"
#include "AliMUON.h"
/* $Id$ */
-// --------------------------
+//-----------------------------------------------------------------------------
// Class AliMUONResponseV0
// --------------------------
// Implementation of
// Mathieson response
+//-----------------------------------------------------------------------------
#include "AliMUONResponseV0.h"
#include "AliMUON.h"
#include "AliMUONVDigitStore.h"
#include "AliMUONVHitStore.h"
-///
+//-----------------------------------------------------------------------------
/// The sdigitizer performs the transformation from hits (energy deposits by
/// the transport code) to sdigits (equivalent of charges on pad).
///
/// Please note that we do *not* merge sdigits after creation, which means
/// that after sdigitization, a given pad can have several sdigits. This
/// merging is taken care of later on by the digitizer(V3).
-///
+//-----------------------------------------------------------------------------
ClassImp(AliMUONSDigitizerV2)
// $Id$
//
+//-----------------------------------------------------------------------------
/// \class AliMUONSlatGeometryBuilder
/// This Builder is designed according to the enveloppe methode. The basic idea is to be able to allow moves
/// of the slats on the support panels.
/// Reference system is the one described in the note ALICE-INT-2003-038 v.2 EDMS Id 406391
///
/// \author Eric Dumonteil (dumontei@cea.fr)
+//-----------------------------------------------------------------------------
#include "AliMUONSlatGeometryBuilder.h"
#include "AliMUON.h"
**************************************************************************/
// $Id$
-//
+
+//-----------------------------------------------------------------------------
// Class AliMUONSt1GeometryBuilder
// -------------------------------
// MUON Station1 coarse geometry construction class.
// Extracted from AliMUONv1
// by Ivana Hrivnacova, IPN Orsay
// Included in AliRoot 2004/01/23
+//-----------------------------------------------------------------------------
#include <TVirtualMC.h>
#include <TGeoMatrix.h>
// $Id$
//
-// Authors: David Guez, Ivana Hrivnacova, Marion MacCormick; IPN Orsay
-//
+//-----------------------------------------------------------------------------
// Class AliMUONSt1GeometryBuilderV2
// ---------------------------------
// MUON Station1 detailed geometry construction class.
// (Originally defined in AliMUONv2.cxx - now removed.)
// Included in AliRoot 2004/01/23
+// Authors: David Guez, Ivana Hrivnacova, Marion MacCormick; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMUONSt1GeometryBuilderV2.h"
#include "AliMUONSt1SpecialMotif.h"
/* $Id$ */
-// Authors: David Guez, Ivana Hrivnacova, Marion MacCormick; IPN Orsay
-//
+//-----------------------------------------------------------------------------
// Class AliMUONSt1SpecialMotif
// ----------------------------
// Encapsulate the distance between the center of a given daughter card
// and the pad/kapton connector.
// Included in AliRoot 2003/01/28
+// Authors: David Guez, Ivana Hrivnacova, Marion MacCormick; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMUONSt1SpecialMotif.h"
**************************************************************************/
// $Id$
-//
+
+//-----------------------------------------------------------------------------
// Class AliMUONSt2GeometryBuilder
// -------------------------------
// MUON Station2 coarse geometry construction class.
// Extracted from AliMUONv1
// Dummy version of station 2 with the right DE id (Ch. Finck)
+//-----------------------------------------------------------------------------
#include <TVirtualMC.h>
#include <TGeoMatrix.h>
**************************************************************************/
// $Id$
-//
+
+//-----------------------------------------------------------------------------
// Class AliMUONSt2GeometryBuilderV2
-// -------------------------------
+// ---------------------------------
// MUON Station2 coarse geometry construction class.
-//********************************************************************
// Author: SANJOY PAL ,Prof. SUKALYAN CHATTOPADHAYAY [SINP, KOLKATA]
// & Dr.SHAKEEL AHMAD (AMU), INDIA
-//********************************************************************
+//-----------------------------------------------------------------------------
#include <TVirtualMC.h>
**************************************************************************/
// $Id$
-//
-// ------------------------------------
+
+//-----------------------------------------------------------------------------
// Class AliMUONStringIntMap
// ------------------------------------
// Helper class that substitutes map <string, int>
// which ALICE does not allow to use
// Author: Ivana Hrivnacova, IPN Orsay
+//-----------------------------------------------------------------------------
#include <Riostream.h>
#include <TObjString.h>
// $Id$
-///
+//-----------------------------------------------------------------------------
/// \class AliMUONTOTCAStoreIterator
///
/// An iterator to access TObject stored in a TObjArray of TClonesArray
///
///
/// \author Laurent Aphecetche, Subatech
-///
+//-----------------------------------------------------------------------------
#include "AliMUONTOTCAStoreIterator.h"
/* $Id$ */
-///////////////////////////////////////////////////
-//
-// Reconstructed track
-// in
-// ALICE
-// dimuon
-// spectrometer
-//
-///////////////////////////////////////////////////
+//-----------------------------------------------------------------------------
+// Class AliMUONTrack
+//-------------------
+// Reconstructed track in ALICE dimuon spectrometer
+//-----------------------------------------------------------------------------
#include "AliMUONTrack.h"
/* $Id$ */
-////////////////////////////////////
-///
+//-----------------------------------------------------------------------------
/// \class AliMUONTrackHitPattern
///
/// This class propagates tracks to trigger chambers
/// * GetHitPattern
///
/// \author Diego Stocco
-///
-////////////////////////////////////
+//-----------------------------------------------------------------------------
#include "AliMUONTrackHitPattern.h"
/* $Id$ */
-//===================================================================
-//This class was prepared by INFN Cagliari, July 2006
-//(authors: H.Woehri, A.de Falco)
-//
-//
+//-----------------------------------------------------------------------------
// Compact information for the muon generated tracks in the MUON arm
// useful at the last stage of the analysis chain
// provides a link between the reconstructed track and the generated particle
// mother process
//
// To be used together with AliMUONPairLight
-//===================================================================
+//
+// This class was prepared by INFN Cagliari, July 2006
+// (authors: H.Woehri, A.de Falco)
+//-----------------------------------------------------------------------------
#include "AliMUONTrackLight.h"
#include "AliMUONTrack.h"
/* $Id$ */
+//-----------------------------------------------------------------------------
/// \class AliMUONTrackReconstructor
/// MUON track reconstructor using the original method
///
///
/// It contains as methods, among others:
/// - MakeTracks to build the tracks
-///
+//-----------------------------------------------------------------------------
#include "AliMUONTrackReconstructor.h"
/* $Id$ */
+//-----------------------------------------------------------------------------
/// \class AliMUONTrackReconstructorK
-/////////////////////////////////////
///
/// MUON track reconstructor using the kalman method
///
/// It contains as methods, among others:
/// - MakeTracks to build the tracks
///
-////////////////////////////////////
+//-----------------------------------------------------------------------------
#include "AliMUONTrackReconstructorK.h"
#include "AliMUONConstants.h"
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONTrackStoreV1
///
/// Implementation of AliMUONTrackStoreV1, which should be backward
/// compatible, i.e. able to read old TreeT files
///
/// \author Laurent Aphecetche, Subatech
-///
+//-----------------------------------------------------------------------------
#include "AliMUONTrackStoreV1.h"
#include "Riostream.h"
#include "TObjArray.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONTrackerPreprocessor
///
/// Shuttle preprocessor for MUON tracker
/// (of type AliMUONVSubprocessor).
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONTrackerPreprocessor)
// $Id$
-
-///
+//-----------------------------------------------------------------------------
/// \class AliMUONTreeManager
///
/// Helper class to handle the relationships TTree<->MUON data containers
/// TTree to store the relationship branch -> MUON store classname.
///
/// \author Laurent Aphecetche, Subatech
+//-----------------------------------------------------------------------------
#include "AliMUONTreeManager.h"
/* $Id$ */
+//-----------------------------------------------------------------------------
/// \class AliMUONTriggerBoard
-/// TRIGGER BOARD SUPER CLASS IMPLEMENTATION
-/// CAN BE A LOCAL, REGIONAL, OR GLOBAL BOARD
-/// REGIONAL BOARD IS PER CONVENTION
-/// ALWAYS IN THE SLOT 0
-/// \todo Change comments in capital letters to normal text
+///
+/// Trigger board super class implementation.
+/// Can be a local, regional, or global board
+/// Regional board is per convention always in the slot 0
///
/// \author Rachid Guernane (LPCCFd)
+//-----------------------------------------------------------------------------
#include "AliMUONTriggerBoard.h"
#include "AliLog.h"
/* $Id$ */
+//-----------------------------------------------------------------------------
/// \class AliMUONTriggerChamberEff
-/// implementation of the trigger chamber efficiency determination from
+/// Implementation of the trigger chamber efficiency determination from
/// data, and returns the
/// efficiencyCells.dat with the calculated efficiencies
///
/// \author Diego Stocco (Torino)
+//-----------------------------------------------------------------------------
#include "AliMUONTriggerChamberEff.h"
#include "AliMUONVDigit.h"
/* $Id$ */
+//-----------------------------------------------------------------------------
/// \class AliMUONTriggerCircuit
/// Contains as data members the Y positions of the X declusturized strips and
/// the X positions of the (doubled or not) Y strips.
/// local trigger output (see AliMUONTrackReconstructor::MakeTriggerTrack)
///
/// \author Philippe Crochet (LPCCFd)
+//-----------------------------------------------------------------------------
#include "AliMUONTriggerCircuit.h"
/* $Id$ */
+//-----------------------------------------------------------------------------
/// \class AliMUONTriggerCrate
/// Collection of trigger boards
/// - one regional
/// - sixteen local
/// slot 0 holds the regional board
/// \author Rachid Guernane (LPCCFd)
+//-----------------------------------------------------------------------------
#include <TObjArray.h>
#include <TSystem.h>
#include <Riostream.h>
-///
+
+//-----------------------------------------------------------------------------
/// \class AliMUONTriggerCrateStore
///
/// A container of trigger crate objects that offers iteration
/// over both the crates themselves and the local boards they contain
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONTriggerCrateStore)
#include <fstream>
#include <cassert>
+//-----------------------------------------------------------------------------
/// \class AliMUONTriggerEfficiencyCells
/// A class to store and give access to the trigger chamber efficiency.
///
/// (generated using the MUONCDB.C macro)
///
/// \author Diego Stocco; INFN Torino
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONTriggerEfficiencyCells)
/* $Id$ */
-//*-- Author: Rachid Guernane (LPCCFd)
-//* Manager class for muon trigger electronics
-//* Client of trigger board classes
-//* Debugged by Ph. Crochet & Ch. Finck
-//* Interfaced with new mapping Ch. Finck
-//*
+//-----------------------------------------------------------------------------
+// Class AliMUONTriggerElectronics
+//--------------------------------
+// Manager class for muon trigger electronics
+// Client of trigger board classes
+// Debugged by Ph. Crochet & Ch. Finck
+// Interfaced with new mapping Ch. Finck
+//
+// Author: Rachid Guernane (LPCCFd)
+//-----------------------------------------------------------------------------
#include "AliLoader.h"
#include "AliLog.h"
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONTriggerGUI
/// Graphical User Interface utility class for the MUON trigger detector
/// It creates, after initialisation with a data file, a sensitive map
/// of the trigger boards
/// \author Bogdan Vulpescu, LPC Clermont-Ferrand
+//-----------------------------------------------------------------------------
#include "AliMUONTriggerGUI.h"
#include "AliMUONTriggerGUIboard.h"
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONTriggerGUIbdmap
///
/// The gui map of a single board object, strips/digits
///
/// \author Bogdan Vulpescu, LPC Clermont-Ferrand
+//-----------------------------------------------------------------------------
#include <TPolyLine.h>
#include <TStyle.h>
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONTriggerGUIboard
///
/// Single trigger board object with geometry information, strips and digits
///
/// \author Bogdan Vulpescu, LPC Clermont-Ferrand
+//-----------------------------------------------------------------------------
#include <TBox.h>
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONTriggerGUIdimap
///
/// The digit maps of the four trigger chambers, all boards
///
/// \author Bogdan Vulpescu, LPC Clermont-Ferrand
+//-----------------------------------------------------------------------------
#include <TCanvas.h>
#include <TGButton.h>
// $Id$
-// -----------------------------------
-// Class AliMUONTriggerGeometryBuilder
+//-----------------------------------------------------------------------------
+/// Class AliMUONTriggerGeometryBuilder
// -----------------------------------
// MUON Trigger stations geometry
// construction class.
// Author: Philippe Crochet (LPCCFd)
// Support for trigger chambers added April 07 by Enrico Scomparin (INFN To)
+//-----------------------------------------------------------------------------
#include <TVirtualMC.h>
#include <TGeoMatrix.h>
/* $Id$ */
-/// -----------------------
-/// Class AliMUONTriggerLut
-/// -----------------------
+//-----------------------------------------------------------------------------
+/// \class AliMUONTriggerLut
+///
/// Local Trigger Look Up Table
/// reading interface LUT data is stored into TH3S histograms and readout
/// from the Local Trigger algorithm
-/// Author: Philippe Crochet
+/// \author Philippe Crochet
+//-----------------------------------------------------------------------------
#include "AliMUONTriggerLut.h"
fAptMinu(0),
fAptUnde(0)
{
- //ctor
+/// ctor
}
//----------------------------------------------------------------------
// $Id$
-///
+//-----------------------------------------------------------------------------
/// \class AliMUONTriggerStoreV1
///
/// Implementation of AliMUONVTriggerStore, which is backward compatible,
/// before the introduction of the AliMUONVStore concept.
///
/// \author Laurent Aphecetche, Subatech
+//-----------------------------------------------------------------------------
#include "AliMUONTriggerStoreV1.h"
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONTriggerTrackStoreV1
///
/// Implementation of AliMUONVTriggerTrackStore which should be
/// the introduction of the AliMUONVStore concept
///
/// \author Laurent Aphecetche, Subatech
+//-----------------------------------------------------------------------------
#include "AliMUONTriggerTrackStoreV1.h"
#include "AliLog.h"
-///
+//-----------------------------------------------------------------------------
/// \class AliMUONVCalibParam
///
/// Defines an interface for a calibration container object.
/// can be identified by a single integer)
///
/// \author Laurent Aphecetche, Subatech
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONVCalibParam)
#include "AliMUONVClusterFinder.h"
#include "AliLog.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONVClusterFinder
///
/// Defines an interface for a cluster finder.
/// particular DE)
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONVClusterFinder)
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONVClusterStore
///
/// An interface of a cluster container
/// This is likely to change to something like AliMUONVCluster...
///
/// \author Laurent Aphecetche, Subatech
+//-----------------------------------------------------------------------------
#include "AliMUONVClusterStore.h"
#include "AliMUONRawCluster.h"
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONVDigit
///
/// This is the base class of a MUON digit that most client code should deal with.
/// the (half) dimensions (in cm) of the pad it corresponds to.
///
/// \author Laurent Aphecetche, Subatech
+//-----------------------------------------------------------------------------
#include "AliMUONVDigit.h"
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONVDigitStore
///
/// Interface for a digit (or sdigit) container
/// can create iterators to loop over (part of) the elements.
///
/// \author Laurent Aphecetche, Subatech
+//-----------------------------------------------------------------------------
#include "AliMUONVDigitStore.h"
**************************************************************************/
// $Id$
-//
+
+//-----------------------------------------------------------------------------
// Class AliMUONVGeometryBuilder
// -----------------------------
// Abstract base class for geometry construction per geometry module(s).
// Author: Ivana Hrivnacova, IPN Orsay
// 23/01/2004
+//-----------------------------------------------------------------------------
#include "AliMUONVGeometryBuilder.h"
#include "AliMUONGeometryModule.h"
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONVHitStore
///
/// Base class of a MUON hit store
///
/// \author Laurent Aphecetche, Subatech
///
+//-----------------------------------------------------------------------------
#include "AliMUONVHitStore.h"
#include "AliMUONHit.h"
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONVStore
///
/// A store is a container, which can be searched for (using FindObject methods),
///
/// In the write case, one *must* specify a concrete class for the container
///
+//-----------------------------------------------------------------------------
#include "AliMUONVStore.h"
#include "AliMUONVSubprocessor.h"
+//-----------------------------------------------------------------------------
/// \class AliMUONVSubprocessor
///
/// Base class for a shuttle sub-task for MUON (either TRK or TRG)
/// to be performed within the MUON shuttle's preprocessors
///
/// \author Laurent Aphecetche
-///
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMUONVSubprocessor)
/* $Id$ */
-////////////////////////////////////
-///
+//-----------------------------------------------------------------------------
/// \class AliMUONVTrackReconstructor
/// Virtual MUON track reconstructor in ALICE (class renamed from AliMUONEventReconstructor)
///
/// quality of the tracks.
///
/// \author Philippe Pillot
-///
-////////////////////////////////////
+//-----------------------------------------------------------------------------
#include "AliMUONVTrackReconstructor.h"
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONVTrackStore
///
/// Base class of a track store
/// might evolve to a virtual AliMUONVTrack for instance in the future...
///
/// \author Laurent Aphecetche, Subatech
+//-----------------------------------------------------------------------------
#include "AliMUONVTrackStore.h"
#include "AliMUONTrack.h"
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONVTriggerStore
///
/// Base class of a trigger container, which holds local, regional and
/// global information for one event.
///
/// \author Laurent Aphecetche, Subatech
-///
+//-----------------------------------------------------------------------------
#include "AliMUONVTriggerStore.h"
#include "AliMUONLocalTrigger.h"
// $Id$
+//-----------------------------------------------------------------------------
/// \class AliMUONVTriggerTrackStore
///
/// Base class of a trigger track store
///
/// \author Laurent Aphecetche, Subatech
+//-----------------------------------------------------------------------------
#include "AliMUONVTriggerTrackStore.h"
#include "AliMUONTriggerTrack.h"
/* $Id$ */
-// --------------------
+//-----------------------------------------------------------------------------
// Class AliMUONv1
// --------------------
// AliDetector class for MUON subsystem which implements
// functions for simulation
+//-----------------------------------------------------------------------------
#include "AliMUONv1.h"
#include "AliMUONConstants.h"
// $Id$
// $MpId: AliMpArea.cxx,v 1.8 2006/05/24 13:58:29 ivana Exp $
// Category: basic
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpArea
// ----------------
// Class that defines a rectangle area positioned in plane..
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpArea.h"
#include "AliMpConstants.h"
// $Id$
// $MpId: AliMpArrayI.cxx,v 1.5 2006/05/24 13:58:29 ivana Exp $
// Category: basic
-// ------------------------
+
+//-----------------------------------------------------------------------------
// Class AliMpArrayI
// ------------------------
// Helper class for sorted integer array
// Author:Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpArrayI.h"
// $Id$
// $MpId: AliMpBusPatch.cxx,v 1.4 2006/05/24 13:58:34 ivana Exp $
-//
-// --------------------
+
+//-----------------------------------------------------------------------------
// Class AliMpBusPatch
// --------------------
// The class defines the properties of BusPatch
// Author: Ivana Hrivnacova, IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpBusPatch.h"
#include "AliMpConstants.h"
// $MpId: $
// Category: management
-// -----------------------
+//-----------------------------------------------------------------------------
// Class AliMpCDB
// -----------------------
// Manager class for mapping CDB IO
// Author: Ivana Hrivnacova, IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpCDB.h"
// $Id$
// $MpId: AliMpCathodType.h,v 1.8 2006/05/24 13:58:07 ivana Exp $
+//-----------------------------------------------------------------------------
// \ingroup basic
// \enum AliMpCathodType
// Enumeration for refering to cath0 and cath1.
//
// \author Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpCathodType.h"
// $Id$
// $MpId: AliMpConnection.cxx,v 1.7 2006/05/24 13:58:41 ivana Exp $
// Category: motif
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpConnection
// ----------------
// Class that defines a connexion properties.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpConnection.h"
#include "AliLog.h"
// $Id$
// $MpId: AliMpConstants.cxx,v 1.11 2006/05/24 13:58:29 ivana Exp $
// Category: basic
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpConstants
// --------------------
// Class for globally used constants definition.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpConstants.h"
// $Id$
// $MpId: AliMpDDL.cxx,v 1.4 2006/05/24 13:58:34 ivana Exp $
// Category: management
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpDDL
// --------------------
// The class defines electronics properties of DDL
// Authors: Ivana Hrivnacova, IPN Orsay
// Christian Finck, SUBATECH Nantes
+//-----------------------------------------------------------------------------
#include "AliMpDDL.h"
#include "AliMpDEManager.h"
// $Id$
// $MpId: AliMpDDLStore.cxx,v 1.4 2006/05/24 13:58:34 ivana Exp $
// Category: management
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpDDLStore
// --------------------
// The top container class for DDLs, det elements and bus patched
// via various characteristics.
// Authors: Ivana Hrivnacova, IPN Orsay
// Christian Finck, SUBATECH Nantes
+//-----------------------------------------------------------------------------
#include "AliMpDDLStore.h"
#include "AliMpConstants.h"
// $MpId: AliMpDEIterator.cxx,v 1.6 2006/05/24 13:58:34 ivana Exp $
// Category: management
-// ------------------------
+//-----------------------------------------------------------------------------
// Class AliMpDEIterator
// ------------------------
// The iterator over valid detection elements
// Author: Ivana Hrivnacova, IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpDEIterator.h"
#include "AliMpDEStore.h"
// $Id$
// $MpId: AliMpDEManager.cxx,v 1.4 2006/05/24 13:58:34 ivana Exp $
// Category: management
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpDEManager
// --------------------
// The manager class for definition of detection element types
// Authors: Ivana Hrivnacova, IPN Orsay
// Laurent Aphecetche, SUBATECH Nantes
+//-----------------------------------------------------------------------------
#include "AliMpDEManager.h"
#include "AliMpDEStore.h"
// $Id$
// $MpId: AliMpDEStore.cxx,v 1.4 2006/05/24 13:58:34 ivana Exp $
// Category: management
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpDEStore
// --------------------
// The container class for detection element objects
// Authors: Ivana Hrivnacova, IPN Orsay
// Laurent Aphecetche, Christian Finck, SUBATECH Nantes
+//-----------------------------------------------------------------------------
#include "AliMpDEStore.h"
#include "AliMpDEManager.h"
#include <TGTextEntry.h>
// Category: graphics
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpDEVisu
// -----------------------
// GUI for drawing segmentation
// motif manu and associated channels
// date: 2007/01/26
// Author: Ch. Finck
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMpDEVisu)
// $Id$
// $MpId: AliMpDetElement.cxx,v 1.4 2006/05/24 13:58:34 ivana Exp $
// Category: management
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpDetElement
// --------------------
// The class defines the electronics properties of detection element
// Authors: Ivana Hrivnacova, IPN Orsay
// Laurent Aphecetche, Christian Finck, SUBATECH Nantes
+//-----------------------------------------------------------------------------
#include "AliMpDetElement.h"
// $Id$
// $MpId: AliMpExMap.cxx,v 1.5 2006/05/24 13:58:29 ivana Exp $
// Category: basic
-// ------------------------
+
+//-----------------------------------------------------------------------------
// Class AliMpExMap
// ------------------------
// Helper class making Root persistent TExMap
// Author:Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpExMap.h"
#include "AliMpIntPair.h"
// $Id$
// $MpId: AliMpFiles.cxx,v 1.12 2006/05/23 13:09:54 ivana Exp $
// Category: basic
-// ----------------
+
+//-----------------------------------------------------------------------------
// Class AliMpFiles
// ----------------
// Class for generating file names and paths.
//
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpFiles.h"
// $Id$
// $MpId: AliMpGraphContext.cxx,v 1.11 2006/05/24 13:58:32 ivana Exp $
// Category: graphics
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpGraphContext
// -----------------------
// Class describing a the correspondance between a given area
// in pad, and a zone of real (cm) position
// Included in AliRoot: 2003/05/02
// Author: David GUEZ, IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpGraphContext.h"
#include "TString.h"
#include "TMap.h"
-///
+//-----------------------------------------------------------------------------
/// \class AliMpHelper
///
/// Helper class used to parse mapping files for St345 slats.
///
/// \author L. Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMpHelper)
// $Id$
// $MpId: AliMpIntPair.cxx,v 1.7 2006/05/24 13:58:29 ivana Exp $
// Category: basic
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpIntPair
// --------------
// Class that defines the pair of integers.
//
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpIntPair.h"
#include "TVector2.h"
#include "TMath.h"
-///
+//-----------------------------------------------------------------------------
/// \class AliMpIteratorPainter
///
/// A painter for a group of pads, which is defined by an iterator
///
///
/// \author L. Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMpIteratorPainter)
* provided "as is" without express or implied warranty. *
**************************************************************************/
+// $Id$
-//
-// --------------------
+//-----------------------------------------------------------------------------
// Class AliMpLocalBoard
// --------------------
// The class defines the properties of local board
// Author: Ch. Finck, Subatech Nantes
+//-----------------------------------------------------------------------------
#include "AliMpLocalBoard.h"
#include "AliMpConstants.h"
#include "TArrayI.h"
#include "TList.h"
-///
+
+//-----------------------------------------------------------------------------
/// \class AliMpManuList
///
/// A sort of cache for mapping information we use often (or that are
/// time consuming to recompute).
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMpManuList)
// $Id$
// $MpId: AliMpMotif.cxx,v 1.8 2006/05/24 13:58:41 ivana Exp $
// Category: motif
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpMotif
// ----------------
// Class that defines a motif with its unique ID
// and the motif type.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpMotif.h"
// $Id$
// $MpId: AliMpMotifMap.cxx,v 1.16 2006/05/24 13:58:41 ivana Exp $
// Category: motif
-// -------------------
+
+//-----------------------------------------------------------------------------
// Class AliMpMotifMap
// -------------------
// Class describing the motif map container, where motifs are
// mapped to their string IDs.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpMotifMap.h"
#include "AliMpVMotif.h"
// $Id$
// $MpId: AliMpMotifPainter.cxx,v 1.9 2006/05/24 13:58:32 ivana Exp $
// Category: graphics
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpMotifPainter
// -----------------------
// Class for drawing a motif into canvas
// Included in AliRoot: 2003/05/02
// Authors: David Guez, IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpMotifPainter.h"
#include "AliMpGraphContext.h"
// $Id$
// $MpId: AliMpMotifPosition.cxx,v 1.9 2006/05/24 13:58:41 ivana Exp $
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpMotifPosition
// ------------------------
// Class that represents a placed motif.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpMotifPosition.h"
#include "AliMpMotifPositionPadIterator.h"
// $Id$
// $MpId: AliMpMotifPositionPadIterator.cxx,v 1.6 2006/05/24 13:58:41 ivana Exp $
// Category: motif
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpMotifPositionPadIterator
// -----------------------------------
// Class, which defines an iterator over the pads of a given motif type
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpMotifPositionPadIterator.h"
#include "AliMpMotifPosition.h"
// $Id$
// $MpId: AliMpMotifReader.cxx,v 1.10 2006/05/24 13:58:41 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpMotifReader
// -------------------
// Class that takes care of reading the sector data.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpFiles.h"
#include "AliMpMotifReader.h"
// $Id$
// $MpId: AliMpMotifSpecial.cxx,v 1.12 2006/05/24 13:58:41 ivana Exp $
// Category: motif
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpMotifSpecial
// -----------------------
// Class that defines a motif with its unique ID
// and the motif type.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpMotifSpecial.h"
#include "AliMpMotifType.h"
// $Id$
// $MpId: AliMpMotifType.cxx,v 1.10 2006/05/24 13:58:41 ivana Exp $
// Category: motif
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpMotifType
// --------------------
// Class that defines the motif properties.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpMotifType.h"
#include "AliMpMotifTypePadIterator.h"
// $Id$
// $MpId: AliMpMotifTypePadIterator.cxx,v 1.6 2006/05/24 13:58:41 ivana Exp $
// Category: motif
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpMotifTypePadIterator
// -------------------------------
// Class, which defines an iterator over the pads of a given motif type
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpMotifTypePadIterator.h"
#include "AliMpMotifType.h"
// $Id$
// $MpId: AliMpNeighboursPadIterator.cxx,v 1.12 2006/05/24 13:58:46 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpNeighboursPadIterator
// --------------------------------
// Class, which defines an iterator over the pads surrounding a given pad
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpNeighboursPadIterator.h"
#include "AliMpIntPair.h"
#include "TMath.h"
#include <sstream>
-///
+
+//-----------------------------------------------------------------------------
/// \class AliMpPCB
///
/// A PCB for station 3,4 or 5
/// the enveloppe.
///
/// \author L. Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMpPCB)
#include "Riostream.h"
#include "TMath.h"
-///
+
+//-----------------------------------------------------------------------------
/// \class AliMpPCBPadIterator
///
/// Iterates over slat pads within a region of constant pad size.
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMpPCBPadIterator)
// $Id$
// $MpId: AliMpPCBPainter.cxx,v 1.8 2006/05/24 13:58:32 ivana Exp $
-///
+
+//-----------------------------------------------------------------------------
/// \class AliMpPCBPainter
///
/// Class for drawing a PCB into canvas
///
/// \author L. Aphecetche
+//-----------------------------------------------------------------------------
#include "AliMpPCBPainter.h"
// $Id$
// $MpId: AliMpPad.cxx,v 1.9 2006/05/24 13:58:29 ivana Exp $
// Category: basic
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpPad
// ---------------
// Class which encapsuate all informations about a pad
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
// root [0] .x testSectorAreaIterator.C
// Real time 0:00:56, CP time 36.270
+//-----------------------------------------------------------------------------
#include "AliMpPad.h"
#include "AliLog.h"
// $Id$
// $MpId: AliMpPadIteratorPtr.cxx,v 1.7 2006/05/24 13:58:29 ivana Exp $
// Category: basic
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpPadIteratorPtr
// --------------------------
// Pointer to the virtual pad iterator;
//
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpPadIteratorPtr.h"
#include "AliMpVPadIterator.h"
// $Id$
// $MpId: AliMpPadPair.cxx,v 1.7 2006/05/24 13:58:29 ivana Exp $
// Category: basic
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpPadPair
// ------------------
// Wrap up for std::pair<AliMpPad, AliMpPad>
// to avoid problems with CINT.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpPadPair.h"
// $Id$
// $MpId: AliMpPadRow.cxx,v 1.8 2006/05/24 13:58:46 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpPadRow
// ------------------
// Class describing a pad row composed of the pad row segments.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpPadRow.h"
#include "AliMpPadRowLSegment.h"
// $Id$
// $MpId: AliMpPadRowLSegment.cxx,v 1.6 2006/05/24 13:58:46 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpPadRowLSegment
// -------------------------
// Class describing a pad row segment composed of the
//
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpPadRowLSegment.h"
#include "AliMpPadRow.h"
// $Id$
// $MpId: AliMpPadRowRSegment.cxx,v 1.6 2006/05/24 13:58:46 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpPadRowRSegment
// -------------------------
// Class describing a pad row segment composed of the
//
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpPadRowRSegment.h"
#include "AliMpPadRow.h"
// $Id$
// $MpId: AliMpRow.cxx,v 1.9 2006/05/24 13:58:46 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpRow
// --------------
// Class describing a row composed of the row segments.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpRow.h"
#include "AliMpVRowSegment.h"
// $Id$
// $MpId: AliMpRowPainter.cxx,v 1.8 2006/05/24 13:58:32 ivana Exp $
// Category: graphics
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpRowPainter
// ---------------------
// Class for drawing a row into canvas
// Included in AliRoot: 2003/05/02
// Authors: David Guez, IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpRowPainter.h"
#include "AliMpGraphContext.h"
// $Id$
// $MpId: AliMpRowSegment.cxx,v 1.10 2006/05/24 13:58:46 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpRowSegment
// ---------------------
// Class describing a row segment composed of the
// the identic motifs.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpRowSegment.h"
#include "AliMpRow.h"
// $Id$
// $MpId: AliMpRowSegmentLSpecial.cxx,v 1.7 2006/05/24 13:58:46 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpRowSegmentLSpecial
// -----------------------------
// Class describing a special inner row segment composed of the
// pad rows.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include <Riostream.h>
#include <TMath.h>
// $Id$
// $MpId: AliMpRowSegmentPainter.cxx,v 1.8 2006/05/24 13:58:32 ivana Exp $
// Category: graphics
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpRowSegmentPainter
// ----------------------------
// Class for drawing a motif into canvas
// Included in AliRoot: 2003/05/02
// Authors: David Guez, IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpRowSegmentPainter.h"
#include "AliMpGraphContext.h"
// $Id$
// $MpId: AliMpRowSegmentRSpecial.cxx,v 1.7 2006/05/24 13:58:46 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpRowSegmentRSpecial
// -----------------------------
// Class describing a special outer row segment composed of the
// pad rows.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpRowSegmentRSpecial.h"
#include "AliMpRow.h"
// $Id$
// $MpId: AliMpSector.cxx,v 1.14 2006/05/24 13:58:46 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpSector
// -----------------
// Class describing the sector of the MUON chamber of station 1.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpSector.h"
#include "AliMpSectorPadIterator.h"
// $Id$
// $MpId: AliMpSectorAreaHPadIterator.cxx,v 1.7 2006/05/24 13:58:46 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpSectorAreaHPadIterator
// ---------------------------------
// Class, which defines an iterator over the pads
// inside a given area in a sector in horizontal direction.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpSectorAreaHPadIterator.h"
#include "AliMpSectorSegmentation.h"
// $Id$
// $MpId: AliMpSectorAreaVPadIterator.cxx,v 1.8 2006/05/24 13:58:46 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpSectorAreaVPadIterator
// ---------------------------------
// Class, which defines an iterator over the pads
// inside a given area in a sector in vertical direction.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpSectorAreaVPadIterator.h"
#include "AliMpSectorSegmentation.h"
// $Id$
// $MpId: AliMpSectorPadIterator.cxx,v 1.6 2006/05/24 13:58:46 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpSectorPadIterator
// ----------------------------
// Class, which defines an iterator over the pads of a sector
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
+
#include "AliMpSectorPadIterator.h"
#include "AliMpIntPair.h"
// $Id$
// $MpId: AliMpSectorPainter.cxx,v 1.8 2006/05/24 13:58:32 ivana Exp $
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpSectorPainter
// ------------------------
// Class for drawing a sector into canvas
// Included in AliRoot: 2003/05/02
// Authors: David Guez, IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpSectorPainter.h"
#include "AliMpGraphContext.h"
// $Id$
// $MpId: AliMpSectorReader.cxx,v 1.9 2006/05/24 13:58:46 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpSectorReader
// -----------------------
// Class that takes care of reading the sector data.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpSectorReader.h"
#include "AliMpSector.h"
// $Id$
// $MpId: AliMpSectorSegmentation.cxx,v 1.15 2006/05/24 13:58:46 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpSectorSegmentation
// -----------------------------
// Class describing the segmentation of the sector.
// finding pad neighbour.
//
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpSectorSegmentation.h"
#include "AliMpSector.h"
// $MpId: AliMpSegmentation.cxx,v 1.7 2006/05/24 13:58:34 ivana Exp $
// Category: management
-// -----------------------
+//-----------------------------------------------------------------------------
// Class AliMpSegmentation
// -----------------------
// Singleton container class for mapping segmentations
// Authors: Ivana Hrivnacova, IPN Orsay
// Laurent Aphecetche, SUBATECH
+//-----------------------------------------------------------------------------
#include "AliMpSegmentation.h"
#include "TArrayI.h"
-///
+//-----------------------------------------------------------------------------
/// Representation of a slat cathode (bending or non-bending).
///
/// A slat can be viewed as a "collection" of PCBs of various densities
/// width varies)
//
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMpSlat)
* provided "as is" without express or implied warranty. *
**************************************************************************/
-///
+
+//-----------------------------------------------------------------------------
/// \class AliMpSlatMotifMap
//
/// Basically this class provide a garbage collection of AliMpMotif and
///
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
// $Id$
#include "AliMpSlat.h"
#include "AliMpPCBPadIterator.h"
-///
+
+//-----------------------------------------------------------------------------
/// \class AliMpSlatPadIterator
///
/// Implementation of AliMpVPadIterator for slats.
/// AliMpSlatZonePadIterator objects.
///
/// \author L. Aphecetche
-///
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMpSlatPadIterator)
// $Id$
// $MpId: AliMpSlatPainter.cxx,v 1.10 2006/05/24 13:58:32 ivana Exp $
-///
+
+//-----------------------------------------------------------------------------
/// \class AliMpSlatPainter
///
/// Class for drawing a slat into canvas
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
#include "AliMpSlatPainter.h"
// $Id$
// $MpId: AliMpSlatSegmentation.cxx,v 1.12 2006/05/24 13:58:50 ivana Exp $
+//-----------------------------------------------------------------------------
// Caution !!
// Implementation note.
// The position(s) used in the interface are supposed to be relative
// to the slat center (AliMpSlat::Position()), whereas internally
// the x,y are relative to bottom-left corner.
+//-----------------------------------------------------------------------------
#include "AliMpSlatSegmentation.h"
#include <sstream>
-///
+
+//-----------------------------------------------------------------------------
/// \class AliMpSt345Reader
//
/// Read slat and pcb ASCII files.
/// - AliMpPCB ReadPCB()
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMpSt345Reader)
// $Id$
// $MpId: AliMpStationType.h,v 1.9 2006/05/24 13:58:07 ivana Exp $
+//-----------------------------------------------------------------------------
// \enum AliMpStationType
// Enumeration for refering to a MUON station
//
// Author: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpStationType.h"
// $Id$
// $MpId: AliMpStringObjMap.cxx,v 1.4 2006/05/24 13:58:29 ivana Exp $
-// ------------------------------------
+//-----------------------------------------------------------------------------
// Class AliMpStringObjMap
// ------------------------------------
// Helper class that substitutes map <string, int>
// which ALICE does not allow to use
// Author: Ivana Hrivnacova, IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpStringObjMap.h"
// $Id$
// $MpId: AliMpSubZone.cxx,v 1.8 2006/05/24 13:58:46 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpSubZone
// ------------------
// Class describing a zone segment composed of the
// line segments with the same motif type.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpSubZone.h"
#include "AliMpVRowSegment.h"
// $Id$
// $MpId: AliMpSubZonePainter.cxx,v 1.8 2006/05/24 13:58:32 ivana Exp $
// Category: graphics
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpSubZonePainter
// -------------------------
// Class for drawing a subzone into canvas
// Included in AliRoot: 2003/05/02
// Authors: David Guez, IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpSubZonePainter.h"
#include "AliMpGraphContext.h"
#include "TArrayI.h"
#include "TObjArray.h"
-///
+//-----------------------------------------------------------------------------
/// \class AliMpTrigger
///
/// A trigger 'slat' object.
/// "locations".
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMpTrigger)
* provided "as is" without express or implied warranty. *
**************************************************************************/
+// $Id$
+// $MpId: AliMpTrigger.cxx,v 1.4 2006/05/24 13:58:52 ivana Exp $
-//
-// --------------------
+//-----------------------------------------------------------------------------
// Class AliMpTriggerCrate
// --------------------
// The class defines the properties of trigger crate
// Author: Ch. Finck, Subatech Nantes
+//-----------------------------------------------------------------------------
#include "AliMpTriggerCrate.h"
#include "AliMpDEManager.h"
#include <TArrayI.h>
#include <sstream>
-///
+//-----------------------------------------------------------------------------
/// \class AliMpTriggerReader
/// Read trigger slat ASCII files
/// Basically provides two methods:
/// - AliMpPCB* ReadPCB()
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMpTriggerReader)
#include "AliMpSlat.h"
#include "AliMpTrigger.h"
-///
+//-----------------------------------------------------------------------------
/// \class AliMpTriggerSegmentation
///
/// Implementation of AliMpVSegmentation for trigger slats.
/// \todo Implement CreateIterator method, if needed.
///
/// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
/// \cond CLASSIMP
ClassImp(AliMpTriggerSegmentation)
// $Id$
// $MpId: AliMpVIndexed.cxx,v 1.7 2006/05/24 13:58:29 ivana Exp $
// Category: basic
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpVIndexed
// -------------------
// Class that defines the limits of global pad indices.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpVIndexed.h"
// $Id$
// $MpId: AliMpVMotif.cxx,v 1.9 2006/05/24 13:58:41 ivana Exp $
// Category: motif
-///
+
+//-----------------------------------------------------------------------------
// Class AliMpVMotif
// -----------------
// Class that defines a motif with its unique ID
// and the motif type.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpVMotif.h"
#include "AliMpMotifType.h"
// $Id$
// $MpId: AliMpVPadIterator.cxx,v 1.6 2006/05/24 13:58:29 ivana Exp $
// Category: basic
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpVPadIterator
// -----------------------
// Abstract base class, which defines an iterator over pads
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpVPadIterator.h"
// $Id$
// $MpId: AliMpVPadRowSegment.cxx,v 1.7 2006/05/24 13:58:46 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpVPadRowSegment
// --------------------
// The abstract base class for a pad row segment composed of the
// the identic pads.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpVPadRowSegment.h"
#include "AliMpPadRow.h"
// $Id$
// $MpId: AliMpVPainter.cxx,v 1.10 2006/05/24 13:58:32 ivana Exp $
// Category: graphics
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpVPainter
// --------------
// Class for drawing objects into canvas
// Included in AliRoot: 2003/05/02
// Authors: David Guez, IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpVPainter.h"
#include "AliMpGraphContext.h"
// $Id$
// $MpId: AliMpVRowSegment.cxx,v 1.6 2006/05/24 13:58:46 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpVRowSegment
// ----------------------
// Class describing an interface for a row segment.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpVRowSegment.h"
// $Id$
// $MpId: AliMpVRowSegmentSpecial.cxx,v 1.9 2006/05/24 13:58:46 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpVRowSegmentSpecial
// ----------------------------
// Class describing a special row segment composed of the
// pad rows.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpVRowSegmentSpecial.h"
#include "AliMpRow.h"
// $Id$
// $MpId: AliMpVSegmentation.cxx,v 1.5 2006/05/24 13:58:29 ivana Exp $
// Category: basic
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpVSegmentation
// ------------------------
// The abstract base class for the segmentation.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
// Laurent Aphecetche, SUBATECH
+//-----------------------------------------------------------------------------
+
#include "AliMpVSegmentation.h"
#include "AliMpArea.h"
// $Id$
// $MpId: AliMpZone.cxx,v 1.7 2006/05/24 13:58:46 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpZone
// ---------------
// Class describing a zone composed of the zone segments.
// The zone contains pads of the same dimensions.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpZone.h"
#include "AliMpSubZone.h"
// $Id$
// $MpId: AliMpZonePainter.cxx,v 1.8 2006/05/24 13:58:32 ivana Exp $
// Category: graphics
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpZonePainter
// ----------------------
// Class for drawing a zone into canvas
// Included in AliRoot: 2003/05/02
// Authors: David Guez, IPN Orsay
+//-----------------------------------------------------------------------------
#include "AliMpZonePainter.h"
#include "AliMpGraphContext.h"
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff