#include "AliMUONLogger.h"
#include "AliMUONPadStatusMaker.h"
#include "AliMUONPadStatusMapMaker.h"
+#include "AliMUONRecoParam.h"
#include "AliMUONVCalibParam.h"
#include "AliMUONVDigit.h"
#include "AliMUONVDigitStore.h"
//_____________________________________________________________________________
AliMUONDigitCalibrator::AliMUONDigitCalibrator(const AliMUONCalibrationData& calib,
+ const AliMUONRecoParam* recoParams,
const char* calibMode)
: TObject(),
fLogger(new AliMUONLogger(20000)),
fPedestals(0x0),
fGains(0x0),
fApplyGains(0),
-fCapacitances(0x0)
+fCapacitances(0x0),
+fNumberOfBadPads(0),
+fNumberOfPads(0)
{
/// ctor
+ Ctor(calibMode,calib,recoParams);
+}
+
+//_____________________________________________________________________________
+AliMUONDigitCalibrator::AliMUONDigitCalibrator(const AliMUONCalibrationData& calib,
+ const char* calibMode)
+: TObject(),
+fLogger(new AliMUONLogger(20000)),
+fStatusMaker(0x0),
+fStatusMapMaker(0x0),
+fPedestals(0x0),
+fGains(0x0),
+fApplyGains(0),
+fCapacitances(0x0),
+fNumberOfBadPads(0),
+fNumberOfPads(0)
+{
+ /// ctor
+
+ Ctor(calibMode,calib,0x0);
+}
+
+//_____________________________________________________________________________
+void
+AliMUONDigitCalibrator::Ctor(const char* calibMode,
+ const AliMUONCalibrationData& calib,
+ const AliMUONRecoParam* recoParams)
+{
+ /// designated ctor
+
TString cMode(calibMode);
cMode.ToUpper();
fStatusMaker = new AliMUONPadStatusMaker(calib);
+ Int_t mask(0x8080);
+
// this is here that we decide on our "goodness" policy, i.e.
// what do we call an invalid pad (a pad maybe bad because its HV
// was too low, or its pedestals too high, etc..)
- // FIXME: find a way not to hard-code the goodness policy (i.e. the limits)
- // here...
- fStatusMaker->SetHVSt12Limits(1300,1600);
- fStatusMaker->SetHVSt345Limits(1500,2000);
- fStatusMaker->SetPedMeanLimits(50,200);
- fStatusMaker->SetPedSigmaLimits(0.1,3);
-
- Int_t mask(0x8080);
- //FIXME: kind of fake one for the moment, we consider dead only
- // if ped and/or hv value missing.
- //WARNING : getting this mask wrong is a very effective way of getting
- //no digits at all out of this class ;-)
+ if ( recoParams )
+ {
+ fStatusMaker->SetHVSt12Limits(recoParams->HVSt12LowLimit(),recoParams->HVSt12HighLimit());
+ fStatusMaker->SetHVSt345Limits(recoParams->HVSt345LowLimit(),recoParams->HVSt345HighLimit());
+ fStatusMaker->SetPedMeanLimits(recoParams->PedMeanLowLimit(),recoParams->PedMeanHighLimit());
+ fStatusMaker->SetPedSigmaLimits(recoParams->PedSigmaLowLimit(),recoParams->PedSigmaHighLimit());
+ fStatusMaker->SetGainA1Limits(recoParams->GainA1LowLimit(),recoParams->GainA1HighLimit());
+ fStatusMaker->SetGainA2Limits(recoParams->GainA2LowLimit(),recoParams->GainA2HighLimit());
+ fStatusMaker->SetGainThresLimits(recoParams->GainThresLowLimit(),recoParams->GainThresHighLimit());
+ mask = recoParams->PadGoodnessMask();
+ //WARNING : getting this mask wrong is a very effective way of getting
+ //no digits at all out of this class ;-)
+ }
Bool_t deferredInitialization = kTRUE;
AliInfo("Summary of messages:");
fLogger->Print();
+ AliInfo(Form("We have seen %g pads, and rejected %g (%7.2f %%)",
+ fNumberOfPads,fNumberOfBadPads,
+ ( fNumberOfPads > 0 ) ? fNumberOfBadPads*100.0/fNumberOfPads : 0 ));
+
delete fLogger;
}
while ( ( digit = static_cast<AliMUONVDigit*>(next() ) ) )
{
+ if ( digit->IsCalibrated() )
+ {
+ fLogger->Log("ERROR : trying to calibrate a digit twice");
+ return;
+ }
+
+ digit->Calibrated(kTRUE);
+
if ( digit->DetElemId() != detElemId )
{
// Find out occupancy of that DE
}
}
- CalibrateDigit(*digit,nsigmas);
+ Float_t charge(0.0);
+ Int_t statusMap;
+ Bool_t isSaturated(kFALSE);
+
+ Bool_t ok = IsValidDigit(digit->DetElemId(),digit->ManuId(),digit->ManuChannel(),&statusMap);
+
+ digit->SetStatusMap(statusMap);
+
+ if (ok)
+ {
+ ++fNumberOfPads;
+ charge = CalibrateDigit(digit->DetElemId(),digit->ManuId(),digit->ManuChannel(),
+ digit->ADC(),nsigmas,&isSaturated);
+ }
+ else
+ {
+ ++fNumberOfBadPads;
+ }
+
+ digit->SetCharge(charge);
+ digit->Saturated(isSaturated);
}
}
//_____________________________________________________________________________
-void
-AliMUONDigitCalibrator::CalibrateDigit(AliMUONVDigit& digit, Double_t nsigmas)
+Float_t
+AliMUONDigitCalibrator::CalibrateDigit(Int_t detElemId, Int_t manuId, Int_t manuChannel,
+ Float_t adc, Float_t nsigmas,
+ Bool_t* isSaturated) const
+
{
/// Calibrate one digit
- if ( digit.IsCalibrated() )
- {
- fLogger->Log("ERROR : trying to calibrate a digit twice");
- return;
- }
- Int_t statusMap = fStatusMapMaker->StatusMap(digit.DetElemId(),
- digit.ManuId(),
- digit.ManuChannel());
-
- digit.SetStatusMap(statusMap);
- digit.Calibrated(kTRUE);
+ AliMUONVCalibParam* pedestal = static_cast<AliMUONVCalibParam*>
+ (fPedestals->FindObject(detElemId,manuId));
- if ( ( statusMap & AliMUONPadStatusMapMaker::SelfDeadMask() ) != 0 )
+ if (!pedestal)
{
- // pad itself is bad (not testing its neighbours at this stage)
- digit.SetCharge(0);
- fLogger->Log(Form("%s:%d:Channel detElemId %d manuId %d "
- "manuChannel %d is bad %x",__FILE__,__LINE__,
- digit.DetElemId(),digit.ManuId(),
- digit.ManuChannel(),digit.StatusMap()));
+ // no pedestal -> no charge
+ fLogger->Log(Form("Got a null pedestal object for DE,manu=%d,%d",detElemId,manuId));
+ return 0.0;
}
- else
+
+
+ AliMUONVCalibParam* gain = static_cast<AliMUONVCalibParam*>
+ (fGains->FindObject(detElemId,manuId));
+
+ if (!gain)
{
- // If the channel is good, go on with the calibration itself.
-
- AliMUONVCalibParam* pedestal = static_cast<AliMUONVCalibParam*>
- (fPedestals->FindObject(digit.DetElemId(),digit.ManuId()));
-
- if (!pedestal)
+ if ( fApplyGains != fgkNoGain )
{
- // no pedestal -> no charge
- digit.SetCharge(0);
-
- fLogger->Log(Form("Got a null pedestal object for DE,manu=%d,%d",
- digit.DetElemId(),digit.ManuId()));
- return;
+ // no gain -> no charge
+ fLogger->Log(Form("Got a null gain object for DE,manu=%d,%d",
+ detElemId,manuId));
+ return 0.0;
}
+ }
+
+ Float_t padc = adc-pedestal->ValueAsFloat(manuChannel,0);
+ Float_t charge(0);
+ Float_t capa(1.0);
+
+ if ( fApplyGains == fgkGainConstantCapa )
+ {
+ capa = 0.2; // pF
+ }
+ else if ( fApplyGains == fgkGain )
+ {
+ AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
+ Int_t serialNumber = de->GetManuSerialFromId(manuId);
- AliMUONVCalibParam* gain = static_cast<AliMUONVCalibParam*>
- (fGains->FindObject(digit.DetElemId(),digit.ManuId()));
-
- if (!gain)
+ AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(fCapacitances->FindObject(serialNumber));
+
+ if ( param )
{
- if ( fApplyGains != fgkNoGain )
- {
- // no gain -> no charge
- digit.SetCharge(0);
-
- fLogger->Log(Form("Got a null gain object for DE,manu=%d,%d",
- digit.DetElemId(),digit.ManuId()));
- return;
- }
+ capa = param->ValueAsFloat(manuChannel);
}
-
- Int_t manuChannel = digit.ManuChannel();
- Float_t adc = digit.ADC();
- Float_t padc = adc-pedestal->ValueAsFloat(manuChannel,0);
- Float_t charge(0);
- Float_t capa(1.0);
-
- if ( fApplyGains == fgkGainConstantCapa )
+ else
{
- capa = 0.2; // pF
+ fLogger->Log(Form("No capa found for serialNumber=%d",serialNumber));
+ capa = 0.0;
}
- else if ( fApplyGains == fgkGain )
+ }
+
+ if ( padc > nsigmas*pedestal->ValueAsFloat(manuChannel,1) )
+ {
+ if ( fApplyGains != fgkNoGain )
{
- AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(digit.DetElemId());
-
- Int_t serialNumber = de->GetManuSerialFromId(digit.ManuId());
-
- AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(fCapacitances->FindObject(serialNumber));
-
- if ( param )
+ Float_t a0 = gain->ValueAsFloat(manuChannel,0);
+ Float_t a1 = gain->ValueAsFloat(manuChannel,1);
+ Int_t thres = gain->ValueAsInt(manuChannel,2);
+ if ( padc < thres )
{
- capa = param->ValueAsFloat(digit.ManuChannel());
+ charge = a0*padc;
}
else
{
- fLogger->Log(Form("No capa found for serialNumber=%d",serialNumber));
- capa = 0.0;
+ charge = a0*thres + a0*(padc-thres) + a1*(padc-thres)*(padc-thres);
}
}
-
- if ( padc > nsigmas*pedestal->ValueAsFloat(manuChannel,1) )
+ else
{
- if ( fApplyGains != fgkNoGain )
- {
- Float_t a0 = gain->ValueAsFloat(manuChannel,0);
- Float_t a1 = gain->ValueAsFloat(manuChannel,1);
- Int_t thres = gain->ValueAsInt(manuChannel,2);
- if ( padc < thres )
- {
- charge = a0*padc;
- }
- else
- {
- charge = a0*thres + a0*(padc-thres) + a1*(padc-thres)*(padc-thres);
- }
- }
- else
- {
- charge = padc;
- }
+ charge = padc;
}
-
- charge *= capa;
- digit.SetCharge(charge);
-
+ }
+
+ charge *= capa;
+
+ if ( isSaturated )
+ {
Int_t saturation(3000);
-
+
if ( gain )
{
saturation = gain->ValueAsInt(manuChannel,4);
}
-
+
if ( padc >= saturation )
{
- digit.Saturated(kTRUE);
+ *isSaturated = kTRUE;
+ }
+ else
+ {
+ isSaturated = kFALSE;
}
}
+
+ return charge;
}
+
+//_____________________________________________________________________________
+Bool_t
+AliMUONDigitCalibrator::IsValidDigit(Int_t detElemId, Int_t manuId, Int_t manuChannel,
+ Int_t* statusMap) const
+
+{
+ /// Check if a given pad is ok or not.
+
+ // First a protection against bad input parameters
+ AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
+ if (!de) return kFALSE; // not existing DE
+ if (!de->IsExistingChannel(manuId,manuChannel))
+ {
+ // non-existing (might happen when we get parity errors in read-out
+ // that spoils the manuId
+ return kFALSE;
+ }
+ if (!de->IsConnectedChannel(manuId,manuChannel))
+ {
+ // existing (in read-out), but not connected channel
+ return kFALSE;
+ }
+
+ // ok, now we have a valid channel number, so let's see if that pad
+ // behaves or not ;-)
+
+ Int_t sm = fStatusMapMaker->StatusMap(detElemId,manuId,manuChannel);
+
+ if (statusMap) *statusMap = sm;
+
+ if ( ( sm & AliMUONPadStatusMapMaker::SelfDeadMask() ) != 0 )
+ {
+ // pad itself is bad (not testing its neighbours at this stage)
+ return kFALSE;
+ }
+
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Int_t
+AliMUONDigitCalibrator::PadStatus(Int_t detElemId, Int_t manuId, Int_t manuChannel) const
+{
+ /// Return the status of the given pad
+ return fStatusMaker->PadStatus(detElemId,manuId,manuChannel);
+}
+
+//_____________________________________________________________________________
+Int_t
+AliMUONDigitCalibrator::StatusMap(Int_t detElemId, Int_t manuId, Int_t manuChannel) const
+{
+ /// Return the status map of the given pad
+ return fStatusMapMaker->StatusMap(detElemId,manuId,manuChannel);
+
+}
+
class AliMUONVDigit;
class AliMUONPadStatusMaker;
class AliMUONPadStatusMapMaker;
+class AliMUONRecoParam;
class TExMap;
class AliMUONDigitCalibrator : public TObject
{
public:
- AliMUONDigitCalibrator(const AliMUONCalibrationData& calib, const char* calibMode="NOGAIN");
+
+ AliMUONDigitCalibrator(const AliMUONCalibrationData& calib,
+ const AliMUONRecoParam* recoParams,
+ const char* calibMode="NOGAIN");
+
+ AliMUONDigitCalibrator(const AliMUONCalibrationData& calib,
+ const char* calibMode="NOGAIN");
virtual ~AliMUONDigitCalibrator();
virtual void Calibrate(AliMUONVDigitStore& digitStore);
-
-private:
- /// Not implemented
- AliMUONDigitCalibrator(const AliMUONDigitCalibrator& other);
- /// Not implemented
- AliMUONDigitCalibrator& operator=(const AliMUONDigitCalibrator& other);
- virtual void CalibrateDigit(AliMUONVDigit& digit, Double_t nsigmas);
+ Bool_t IsValidDigit(Int_t detElemId, Int_t manuId, Int_t manuChannel,
+ Int_t* statusMap=0x0) const;
+
+ Float_t CalibrateDigit(Int_t detElemId, Int_t manuId, Int_t manuChannel,
+ Float_t adc, Float_t nsigmas,
+ Bool_t* isSaturated=0x0) const;
+
+ Int_t PadStatus(Int_t detElemId, Int_t manuId, Int_t manuChannel) const;
+
+ Int_t StatusMap(Int_t detElemId, Int_t manuId, Int_t manuChannel) const;
+private:
+
+ /// Not implemented
+ AliMUONDigitCalibrator(const AliMUONDigitCalibrator& other);
+ /// Not implemented
+ AliMUONDigitCalibrator& operator=(const AliMUONDigitCalibrator& other);
+
+ void Ctor(const char* calibMode,
+ const AliMUONCalibrationData& calib,
+ const AliMUONRecoParam* recoParams);
+
private:
- AliMUONLogger* fLogger; //!< to log repeated messages
- AliMUONPadStatusMaker* fStatusMaker; //!< to build pad statuses
- AliMUONPadStatusMapMaker* fStatusMapMaker; //!< to build status map
- AliMUONVStore* fPedestals; //!< pedestal values
- AliMUONVStore* fGains; //!< gain values
- Int_t fApplyGains; //!< whether we should apply gains or not, capa or not...
- AliMUONVStore* fCapacitances; //!< capa values
-
- static const Int_t fgkNoGain; //!< do not apply gain calib at all
- static const Int_t fgkGainConstantCapa; //!< apply gain (from OCDB) with constant capa
- static const Int_t fgkGain; //!< apply gain and capa (from OCDB)
-
- ClassDef(AliMUONDigitCalibrator,7) // Calibrate raw digit
+ AliMUONLogger* fLogger; //!< to log repeated messages
+ AliMUONPadStatusMaker* fStatusMaker; //!< to build pad statuses
+ AliMUONPadStatusMapMaker* fStatusMapMaker; //!< to build status map
+ AliMUONVStore* fPedestals; //!< pedestal values
+ AliMUONVStore* fGains; //!< gain values
+ Int_t fApplyGains; //!< whether we should apply gains or not, capa or not...
+ AliMUONVStore* fCapacitances; //!< capa values
+ Double_t fNumberOfBadPads; //!< # of times we've rejected a bad pad
+ Double_t fNumberOfPads; //!< # of pads we've seen
+
+ static const Int_t fgkNoGain; //!< do not apply gain calib at all
+ static const Int_t fgkGainConstantCapa; //!< apply gain (from OCDB) with constant capa
+ static const Int_t fgkGain; //!< apply gain and capa (from OCDB)
+
+ ClassDef(AliMUONDigitCalibrator,8) // Calibrate raw digit
};
#endif
/// \endcond
//_____________________________________________________________________________
-AliMUONLegacyClusterServer::AliMUONLegacyClusterServer(const AliMUONGeometryTransformer& transformer, AliMUONVClusterStore* store)
+AliMUONLegacyClusterServer::AliMUONLegacyClusterServer(const AliMUONGeometryTransformer& transformer,
+ AliMUONVClusterStore* store,
+ Bool_t bypassSt4, Bool_t bypassSt5)
: AliMUONVClusterServer(), fTransformer(transformer), fClusterStore(store), fTriggerTrackStore(0x0),
-fBypass(0x0)
+fBypass(0x0),
+fBypassSt4(bypassSt4),
+fBypassSt5(bypassSt5)
{
/// ctor. Mode Read : we'll only server clusters from existing store
}
AliCodeTimerAuto(Form("Chamber %d",chamberId));
- if ( fBypass && chamberId >= 6 )
+ if ( fBypassSt4 && ( chamberId == 6 || chamberId == 7 ) )
{
return fBypass->GenerateClusters(chamberId,clusterStore);
}
-
+
+ if ( fBypassSt5 && ( chamberId == 8 || chamberId == 9 ) )
+ {
+ return fBypass->GenerateClusters(chamberId,clusterStore);
+ }
+
AliDebug(1,Form("chamberId=%d fClusterStore(%p).GetSize()=%d clusterStore(%p).GetSize()=%d",
chamberId,
fClusterStore,fClusterStore->GetSize(),
Bool_t
AliMUONLegacyClusterServer::UseTriggerTrackStore(AliMUONVTriggerTrackStore* trackStore)
{
- /// Tells us to use trigger track store, and thus to bypass St45 clusters
+ /// Tells us to use trigger track store, and thus to bypass St4 and/or 5 clusters
fTriggerTrackStore = trackStore; // not owner
delete fBypass;
fBypass = new AliMUONTriggerTrackToTrackerClusters(fTransformer,fTriggerTrackStore);
class AliMUONLegacyClusterServer : public AliMUONVClusterServer
{
public:
- AliMUONLegacyClusterServer(const AliMUONGeometryTransformer& transformer, AliMUONVClusterStore* store=0x0);
+ AliMUONLegacyClusterServer(const AliMUONGeometryTransformer& transformer,
+ AliMUONVClusterStore* store=0x0,
+ Bool_t bypassSt4=kFALSE,
+ Bool_t bypassSt5=kFALSE);
virtual ~AliMUONLegacyClusterServer();
AliMUONLegacyClusterServer& operator=(const AliMUONLegacyClusterServer& rhs);
const AliMUONGeometryTransformer& fTransformer; //!< geometry convertor
- AliMUONVClusterStore* fClusterStore; //!< cluster store
- AliMUONVTriggerTrackStore* fTriggerTrackStore; //!< trigger track store
- AliMUONTriggerTrackToTrackerClusters* fBypass; //!< bypass
-
- ClassDef(AliMUONLegacyClusterServer,1) // Implementation of AliMUONVClusterServer
+ AliMUONVClusterStore* fClusterStore; //!< cluster store
+ AliMUONVTriggerTrackStore* fTriggerTrackStore; //!< trigger track store
+ AliMUONTriggerTrackToTrackerClusters* fBypass; //!< bypass
+ Bool_t fBypassSt4; //!< whether we should bypass station 4
+ Bool_t fBypassSt5; //!< whether we should bypass station 5
+
+ ClassDef(AliMUONLegacyClusterServer,2) // Implementation of AliMUONVClusterServer
};
#endif
TString calibMode = GetRecoParam()->GetCalibrationMode();
- fDigitCalibrator = new AliMUONDigitCalibrator(*fCalibrationData,calibMode.Data());
+ fDigitCalibrator = new AliMUONDigitCalibrator(*fCalibrationData,GetRecoParam(),calibMode.Data());
}
//_____________________________________________________________________________
{
if (AliMUONReconstructor::GetRecoParam()->UseChamber(i))
{
- if ( i >= 6 && AliMUONReconstructor::GetRecoParam()->BypassSt45() ) continue;
+ if ( ( i == 6 || i == 7 ) && AliMUONReconstructor::GetRecoParam()->BypassSt4() ) continue;
+ if ( ( i == 8 || i == 9 ) && AliMUONReconstructor::GetRecoParam()->BypassSt5() ) continue;
fClusterServer->Clusterize(i,*fClusterStore,area);
}
fInputClusterStore->Connect(*clustersTree,kFALSE);
}
delete fClusterServer;
- fClusterServer = new AliMUONLegacyClusterServer(*fTransformer,fInputClusterStore);
+ fClusterServer = new AliMUONLegacyClusterServer(*fTransformer,fInputClusterStore,
+ AliMUONReconstructor::GetRecoParam()->BypassSt4(),
+ AliMUONReconstructor::GetRecoParam()->BypassSt5());
SetupClusterServer(*fClusterServer);
}
fTrackReco->EventReconstructTrigger(*fTriggerCircuit,*fTriggerStore,*(TriggerTrackStore()));
}
- if ( AliMUONReconstructor::GetRecoParam()->BypassSt45() && TriggerTrackStore()->GetSize() > 5 )
+ if ( ( AliMUONReconstructor::GetRecoParam()->BypassSt4() ||
+ AliMUONReconstructor::GetRecoParam()->BypassSt5() ) &&
+ TriggerTrackStore()->GetSize() > 5 )
{
// Hard cut to reject shower events
{
/// Setup the cluster server
- if ( AliMUONReconstructor::GetRecoParam()->BypassSt45() )
+ if ( AliMUONReconstructor::GetRecoParam()->BypassSt4() ||
+ AliMUONReconstructor::GetRecoParam()->BypassSt5() )
{
Bool_t ok = clusterServer.UseTriggerTrackStore(TriggerTrackStore());
+ TString msg1;
+ TString msg2;
+
+ if ( AliMUONReconstructor::GetRecoParam()->BypassSt45() )
+ {
+ msg1 = "STATIONS 4 AND 5";
+ msg2 = "THOSE TWO STATIONS";
+ }
+ else if ( AliMUONReconstructor::GetRecoParam()->BypassSt4() )
+ {
+ msg1 = "STATION 4";
+ msg2 = "THAT STATION";
+ }
+ else if ( AliMUONReconstructor::GetRecoParam()->BypassSt5() )
+ {
+ msg1 = "STATION 5";
+ msg2 = "THAT STATION";
+ }
+
if ( ok )
-
{
- AliWarning("WILL USE TRIGGER TRACKS TO GENERATE CLUSTERS IN STATIONS 4 AND 5, THUS BYPASSING REAL CLUSTERS IN THOSE TWO STATIONS !!!");
+ AliWarning(Form("WILL USE TRIGGER TRACKS TO GENERATE CLUSTERS IN %s, "
+ "THUS BYPASSING REAL CLUSTERS IN %s!!!",msg1.Data(),msg2.Data()));
}
else
{
- AliWarning("BYPASSING OF ST45 REQUESTED, BUT CLUSTERSERVER DOES NOT SEEM TO SUPPORT IT !!!");
+ AliWarning("BYPASSING OF ST4 AND/OR 5 REQUESTED, BUT CLUSTERSERVER DOES NOT SEEM TO SUPPORT IT !!!");
}
}
}
(used for Kalman tracking only)
- <code>UseChamber(Int_t iCh, Bool_t flag)</code>: set the chambers to be used (disable the clustering if the chamber is not used).
- <code>RequestStation(Int_t iSt, Bool_t flag)</code>: impose/release the condition "at least 1 cluster per station" for that station.
-- <code>BypassSt45(Bool_t value)</code>: make the primary track candidate from the trigger track instead of using station 4 and 5.
+- <code>BypassSt45(Bool_t st4, Bool_t st5)</code>: make the primary track candidate from the trigger track instead of using stations 4 and/or 5.
We can use the method Print("FULL") to printout all the parameters and options set in the class AliMUONRecoParam.
#endif
// Data file, OCDB on Grid
-TString input="alien:///alice/data/2008/LHC08a/000024841/raw/08000024841010.10.root";
-//TString input="alien:///alice/data/2008/LHC08a/000021931/raw/08000021931001.50.root";
-TString ocdbPath = "alien://folder=/alice/data/2008/LHC08a/OCDB";
+TString input="alien:///alice/data/2008/LHC08b/000037057/raw/08000037057021.10.root";
+TString ocdbPath = "alien://folder=/alice/data/2008/LHC08b/OCDB";
// Data file, OCDB locally
//TString input="$ALICE_ROOT/MUON/test_out.100/raw.root";
AliCDBManager* man = AliCDBManager::Instance();
man->SetDefaultStorage(ocdbPath.Data());
- //man->SetSpecificStorage("MUON/Calib/Mapping","local://$ALICE_ROOT");
- //man->SetSpecificStorage("MUON/Calib/DDLStore","local://$ALICE_ROOT");
- //man->SetSpecificStorage("MUON/Calib/Gains","local://$ALICE_ROOT");
+
+ man->SetSpecificStorage("MUON/Calib/Mapping","local://$ALICE_ROOT");
+ man->SetSpecificStorage("MUON/Calib/DDLStore","local://$ALICE_ROOT");
gRandom->SetSeed(seed);
AliTracker::SetFieldMap(field, kFALSE);
AliReconstruction *MuonRec = new AliReconstruction();
-
MuonRec->SetInput(input.Data());
MuonRec->SetRunVertexFinder(kFALSE);
MuonRec->SetRunLocalReconstruction("MUON");
MuonRec->SetRunTracking("MUON");
MuonRec->SetFillESD(" ");
MuonRec->SetLoadAlignData("MUON");
- MuonRec->SetNumberOfEventsPerFile(1000);
+ MuonRec->SetNumberOfEventsPerFile(0);
MuonRec->SetOption("MUON",recoptions.Data());
- // MuonRec->SetEventRange(319,319);
- MuonRec->SetWriteAOD();
- //MuonRec.SetEventRange(0,100);
AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetCosmicParam();
- muonRecoParam->BypassSt45(kTRUE);
+ muonRecoParam->BypassSt45(kTRUE,kFALSE);
muonRecoParam->RequestStation(2,kFALSE);
+ muonRecoParam->SetPadGoodnessMask(0x400BE80);
TString caliboption = caliboption1;
if ( calib == 2 ) caliboption = caliboption2;
muonRecoParam->SetCalibrationMode(caliboption.Data());
- //muonRecoParam->SetClusteringMode("PEAKFIT");
- //muonRecoParam->SetClusteringMode("PEAKCOG");
muonRecoParam->Print("FULL");
- AliRecoParam::Instance()->RegisterRecoParam(muonRecoParam);
-
+
+ AliMUONReconstructor::SetRecoParam(muonRecoParam);
+
+ MuonRec->SetRunQA("MUON:ALL");
+
MuonRec->Run();
delete MuonRec;