fRawStreamTrigger(new AliMUONRawStreamTriggerHP),
fDigitStore(0x0),
fTriggerStore(0x0),
-fLogger(new AliMUONLogger(10000))
-{
+fLogger(new AliMUONLogger(10000)){
/// ctor
if ( !a || !b ) AliFatal("no longer supported");
}
return kTRUE;
}
+
+//______________________________________________________________________________
+void
+AliMUONDigitMaker::SetTryRecover(Bool_t flag)
+{
+ /// Instruct the decoder to try to recover corrupted raw data.
+ /// Only use for specific cases for which you know it will work...
+ fRawStreamTracker->TryRecover(flag);
+}
void Print(Option_t* opt="") const;
+ void SetTryRecover(Bool_t flag);
+
private:
/// Not implemented
#include "AliRecoParam.h"
#include "AliLog.h"
+#include "AliCDBManager.h"
+#include "AliCDBEntry.h"
+
#include <Riostream.h>
ClassImp(AliMUONRecoParam)
fClusterChargeCut(2.0),
fEventSizeSoftLimit(35.0),
fEventSizeHardLimit(45.0),
- fTokenLostLimit(0.0)
+ fTokenLostLimit(0.0),
+ fTryRecover(kFALSE)
{
/// Constructor
ClusterChargeCut(),ClusterChargeCut()*AverageNoisePadCharge()) << endl;
cout << Form("Note that LowestPadCharge is then %7.2f fC",LowestPadCharge()) << endl;
+ if (TryRecover())
+ {
+ cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << endl;
+ cout << "!!! WILL TRY TO RECOVER CORRUPTED RAW DATA !!!" << endl;
+ cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << endl;
+ }
cout<<"\t-----------------------------------------------------"<<endl<<endl;
}
SetEventSizeLimits(35.0,45.0);
SetTokenLostLimit(0.0);
+
+ fTryRecover = kFALSE;
+}
+
+
+//-----------------------------------------------------------------------
+TObjArray*
+AliMUONRecoParam::Create(const char* settings)
+{
+ /// Create pre-defined recoparam array, according to settings.
+ /// settings is case-insensitive.
+ ///
+ /// Currently defined are :
+ ///
+ /// "cosmics" :
+ /// Cosmic (default)
+ /// Calibration
+ /// "ppideal"
+ /// LowFlux (default)
+ /// Calibration
+ /// "ppreal"
+ /// LowFlux (modified to reconstruct real p-p data)
+ /// Calibration
+ /// "pprealsim"
+ /// LowFlux (modified to reconstruct realistic p-p simulation)
+ /// Calibration
+
+ AliMUONRecoParam* param(0x0);
+
+ AliRecoParam::EventSpecie_t defaultParam = AliRecoParam::kLowMult;
+
+ TString stype(settings);
+ stype.ToLower();
+
+ if ( stype == "cosmics" )
+ {
+ // set parameters for cosmic runs
+ param = AliMUONRecoParam::GetCosmicParam();
+ defaultParam = AliRecoParam::kCosmic;
+ }
+ else if ( stype == "ppideal" )
+ {
+ // set default lowFlux parameters
+ param = AliMUONRecoParam::GetLowFluxParam();
+ }
+ else if ( stype == "ppreal" || stype == "pprealsim" || "pprealnofield" )
+ {
+ // common parameters for p-p data and realistic p-p simu
+ param = AliMUONRecoParam::GetLowFluxParam();
+ param->SaveFullClusterInESD(kTRUE, 100.);
+ for (Int_t iCh=0; iCh<10; iCh++)
+ {
+ param->SetDefaultNonBendingReso(iCh,0.4);
+ param->SetDefaultBendingReso(iCh,0.4);
+ }
+ param->SetSigmaCutForTracking(7.);
+ param->SetStripCutForTrigger(1.5);
+ param->SetSigmaCutForTrigger(6.);
+ param->ImproveTracks(kTRUE, 6.);
+ param->SetPedMeanLimits(20, 700);
+ param->SetManuOccupancyLimits(-1.,0.01);
+ param->SetBuspatchOccupancyLimits(-1.,0.01);
+ param->SetFractionOfBuspatchOutsideOccupancyLimit(0.05); // 5 %
+
+ // specific parameters for p-p data or realistic p-p simu
+ if ( stype == "ppreal" || stype == "pprealnofield" )
+ {
+ param->SetPadGoodnessMask(0x400BE80);
+ }
+ else
+ {
+ param->SetPadGoodnessMask(0x8080);
+ }
+
+ if ( stype == "pprealnofield" )
+ {
+ param->TryRecover(kTRUE);
+ }
+ }
+ else
+ {
+ AliErrorClass("Unknown settings !");
+ return 0x0;
+ }
+
+ TObjArray* recoParams = new TObjArray;
+
+ recoParams->AddLast(param);
+
+ // set (dummy) parameters for calibration runs
+ param = AliMUONRecoParam::GetCalibrationParam();
+ recoParams->AddLast(param);
+
+ // set parameters for Pb-Pb runs
+ // param = AliMUONRecoParam::GetHighFluxParam();
+ // recoParams.AddLast(param);
+
+ // identify default parameters (exit if identification failed)
+ Bool_t defaultIsSet = kFALSE;
+ TIter next(recoParams);
+ while ( (param = static_cast<AliMUONRecoParam*>(next())) )
+ {
+ if (param->GetEventSpecie() == defaultParam)
+ {
+ param->SetAsDefault();
+ defaultIsSet = kTRUE;
+ }
+ param->Print("FULL");
+ }
+
+ if (!defaultIsSet)
+ {
+ AliErrorClass("The default reconstruction parameters are not set! Exiting...");
+ return 0x0;
+ }
+
+ return recoParams;
}
+//______________________________________________________________________________
+void
+AliMUONRecoParam::Show(Int_t runNumber, const char* ocdb)
+{
+ /// Show what we have in the designated OCDB for that run, as far as RecoParams are concerned
+
+ AliCDBManager::Instance()->SetDefaultStorage(ocdb);
+ AliCDBManager::Instance()->SetRun(runNumber);
+
+ AliCDBEntry* entry = AliCDBManager::Instance()->Get("MUON/Calib/RecoParam");
+
+ if (!entry) return;
+
+ TObject* o = entry->GetObject();
+
+ if ( o->IsA() == TObjArray::Class() )
+ {
+ TObjArray* array = static_cast<TObjArray*>(o);
+ for ( Int_t i = 0; i <= array->GetLast(); ++i )
+ {
+ AliDetectorRecoParam* p = static_cast<AliDetectorRecoParam*>(array->At(i));
+ cout << Form("array[%d]=%s %s %s",i,
+ p ? p->ClassName() : "",
+ p ? AliRecoParam::GetEventSpecieName(AliRecoParam::Convert(p->GetEventSpecie())) :"",
+ p ? ( p->IsDefault() ? "default" : "") : "" ) << endl;
+ }
+ cout << "=========== dumps below ====== " << endl;
+
+ for ( Int_t i = 0; i <= array->GetLast(); ++i )
+ {
+ AliDetectorRecoParam* p = static_cast<AliDetectorRecoParam*>(array->At(i));
+ if ( p ) p->Print("");
+ }
+ }
+ else
+ {
+ o->Print();
+ }
+}
/// Get the percentage of token lost error we allow
virtual Double_t TokenLostLimit() const { return fTokenLostLimit; }
- /// Set the percentage of token lost error we allo
+ /// Set the percentage of token lost error we allow
virtual void SetTokenLostLimit(Double_t limit) { fTokenLostLimit = limit; }
+ /// Whether or not we try to recover corrupted raw data
+ virtual Bool_t TryRecover() const { return fTryRecover; }
+
+ /// Set the try recover corrupted raw data (use kTRUE only if you know what you are doing. Should be left to kFALSE by default)
+ virtual void TryRecover(Bool_t flag) { fTryRecover = flag; }
+
+ /// Create object ready to be put in OCDB
+ static TObjArray* Create(const char* settings);
+
+ /// Show what is the OCDB for that run
+ static void Show(Int_t runNumber, const char* ocdbPath="raw://");
+
private:
void SetDefaultLimits();
Double32_t fTokenLostLimit; ///< limit on the fraction of token lost error per event we allow
+ Bool_t fTryRecover; ///< try to recover corrupted raw data
+
// functions
void SetLowFluxParam();
void SetHighFluxParam();
void SetCosmicParam();
void SetCalibrationParam();
- ClassDef(AliMUONRecoParam,167) // MUON reco parameters
+ ClassDef(AliMUONRecoParam,168) // MUON reco parameters
// we're at 167 not because we had that many versions, but because at some point (version 15->16)
// 166 was committed by error, and we did not to go reverse afterwards...
};
{
fDigitMaker->SetMakeTriggerDigits(kTRUE);
}
+ if ( GetRecoParam()->TryRecover() )
+ {
+ fDigitMaker->SetTryRecover(kTRUE);
+ }
+ else
+ {
+ fDigitMaker->SetTryRecover(kFALSE);
+ }
}
//_____________________________________________________________________________
TTree& clustersTree) const
{
/// Write the trigger and cluster information into TreeR
-
+
AliCodeTimerAuto("",0)
- AliDebug(1,"");
-
Bool_t ok(kFALSE);
Bool_t alone(kTRUE); // is trigger the only info in TreeR ?
fLogger(0x0),
fLastEventWasEmpty(kFALSE),
fNumberOfPhysicsEvents(0),
-fNumberOfGoodPhysicsEvents(0)
+fNumberOfGoodPhysicsEvents(0),
+fTryRecover(kFALSE),
+fFirstEvent(-1),
+fLastEvent(-1)
{
/// Root IO ctor
}
fLogger(0x0),
fLastEventWasEmpty(kFALSE),
fNumberOfPhysicsEvents(0),
-fNumberOfGoodPhysicsEvents(0)
+fNumberOfGoodPhysicsEvents(0),
+fTryRecover(kFALSE),
+fFirstEvent(-1),
+fLastEvent(-1)
{
/// Ctor in which this object will NOT be the owner of the reader
/// and can NOT apply rewind to it, nor use Next on it.
fLogger(0x0),
fLastEventWasEmpty(kFALSE),
fNumberOfPhysicsEvents(0),
-fNumberOfGoodPhysicsEvents(0)
+fNumberOfGoodPhysicsEvents(0),
+fTryRecover(kFALSE),
+fFirstEvent(-1),
+fLastEvent(-1)
{
/// Ctor in which we take the ownership of the rawReader, so we can rewind
/// and advance it as we wish
fLogger(0x0),
fLastEventWasEmpty(kFALSE),
fNumberOfPhysicsEvents(0),
-fNumberOfGoodPhysicsEvents(0)
+fNumberOfGoodPhysicsEvents(0),
+fTryRecover(kFALSE),
+fFirstEvent(-1),
+fLastEvent(-1)
{
/// Ctor from raw data reader
if (fRawReader)
if ( !IsRunning() ) return kTRUE;
- Bool_t ok = fRawReader->NextEvent();
+ Bool_t ok(kTRUE);
+
+ if ( fLastEvent >= fFirstEvent && fLastEvent > 0 ) // do we have an event range to consider ?
+ {
+ // skip up to first event
+
+ while ( (fNumberOfEvents-1) < fFirstEvent && ( ok = fRawReader->NextEvent() ) )
+ {
+ ++fNumberOfEvents;
+ }
+
+ if ( ok && (fNumberOfEvents-1) <= fLastEvent )
+ {
+ ok = fRawReader->NextEvent();
+ }
+ else
+ {
+ fNumberOfEvents=fLastEvent+1;
+ return kFALSE;
+ }
+ }
+ else
+ {
+ // no event range, just proceed...
+ ok = fRawReader->NextEvent();
+ }
if (!ok)
{
stream.DisableWarnings();
stream.DisableRawReaderErrorLogger();
stream.DisableMUONErrorLogger();
+
+ if ( fTryRecover )
+ {
+ stream.TryRecover(kTRUE);
+ }
+ else
+ {
+ stream.TryRecover(kFALSE);
+ }
if (fLogger)
{
/// Whether last decoded event was empty
Bool_t LastEventWasEmpty() const { return fLastEventWasEmpty; }
+ /// Whether or not we should try to recover corrupted raw data
+ void SetTryRecover(Bool_t flag) { fTryRecover = flag; }
+
+ /// Set the event range to consider
+ void SetEventRange(Int_t first, Int_t last) { fFirstEvent=first; fLastEvent=last; }
+
private:
/// not implemented
AliMUONTrackerDataMaker(const AliMUONTrackerDataMaker& rhs);
Bool_t fLastEventWasEmpty; ///< whether last decoded event was empty
Int_t fNumberOfPhysicsEvents; ///< number of physics events seen
Int_t fNumberOfGoodPhysicsEvents; ///< number of errors with no (fatal) readout error
-
- ClassDef(AliMUONTrackerDataMaker,4) // Producer of AliMUONVTrackerData from raw
+ Bool_t fTryRecover; ///< whether we should try to recover corrupted raw data
+ Int_t fFirstEvent; ///< first event to consider
+ Int_t fLastEvent; ///< last event to consider
+
+ ClassDef(AliMUONTrackerDataMaker,5) // Producer of AliMUONVTrackerData from raw
};
#endif
}
}
- hbp.GetListOfFunctions()->Delete();
- hddl.GetListOfFunctions()->Delete();
hddl.SetStats(kFALSE);
hbp.SetXTitle("Absolute Bus Patch Id");
hbp.SetYTitle("Occupancy (percent)");
/// Normalize and put some text on the readout error histogram
/// Note in particular the treatment of tokenlost errors !
- hrostatus.GetListOfFunctions()->Delete();
- hrostatusnorm.GetListOfFunctions()->Delete();
hrostatusnorm.Reset();
- hrostatusnorm.SetFillStyle(0);
AliMUONVQAChecker::ECheckCode rv(AliMUONVQAChecker::kInfo);
AliMUONVQAChecker::ECheckCode rv(AliMUONVQAChecker::kInfo);
- heventsizeperevent.GetListOfFunctions()->Delete();
-
heventsizeperevent.Reset();
TObjArray messages;
}
else
{
- heventsizeperevent.Add(&heventsize);
- heventsizeperevent.Scale(1.0/neventsseen/1024.0);
+ heventsizeperevent.Add(&heventsize,1.0/neventsseen/1024.0);
heventsizeperevent.SetMinimum(0);
Double_t totalEventSizePerEvent = heventsizeperevent.Integral();
#include "AliMpDetElement.h"
#include "AliMpManuIterator.h"
#include "AliQAv1.h"
-#include "AliRawEquipment.h"
-#include "AliRawEquipmentHeader.h"
-#include "AliRawEventHeaderBase.h"
#include "AliRawReader.h"
-#include "AliRawVEvent.h"
+#include "AliRawEventHeaderBase.h"
#include <Riostream.h>
#include <TH1F.h>
#include <TH1I.h>
Double_t nbuspatches = fBusPatchConfig->GetEntries();
- hrostatus->Fill(1.0*AliMUONQAIndices::kTrackerRawNofMissingBusPatchesFromConfig,nofBusPatchesNotInConfig*nevents/nbuspatches);
+ Int_t bin = hrostatus->FindBin(1.0*AliMUONQAIndices::kTrackerRawNofMissingBusPatchesFromConfig);
+ hrostatus->SetBinContent(bin,nofBusPatchesNotInConfig*nevents/nbuspatches);
Double_t nofBusPatchesNotInData(0);
if ( !data->HasBusPatch(bp->GetId()) ) ++nofBusPatchesNotInData;
}
- hrostatus->Fill(1.0*AliMUONQAIndices::kTrackerRawNofMissingBusPatchesFromDataStream,nofBusPatchesNotInData*nevents/nbuspatches);
+ bin = hrostatus->FindBin(1.0*AliMUONQAIndices::kTrackerRawNofMissingBusPatchesFromDataStream);
+ hrostatus->SetBinContent(bin,nofBusPatchesNotInData*nevents/nbuspatches);
}
//____________________________________________________________________________
-void AliMUONTrackerQADataMakerRec::FillEventSize(const AliRawVEvent* cevent)
+void AliMUONTrackerQADataMakerRec::FillEventSize(AliRawReader* rawReader)
{
/// Fill event size histogram(s)
- if (!cevent)
- {
- AliError("Got a null cevent...");
- return;
- }
-
- AliRawVEvent* event = const_cast<AliRawVEvent*>(cevent); // not good, but the Get*Event() methods are not const...
-
TH1* hnevents = GetRawsData(AliMUONQAIndices::kTrackerNofPhysicsEventsSeen);
TH1* hddlevents = GetRawsData(AliMUONQAIndices::kTrackerDDLNofEventsSeen);
TH1* hDDLEventSize = GetRawsData(AliMUONQAIndices::kTrackerDDLEventSize);
- Double_t eventSize = 0;
-
hnevents->Fill(0.0);
- for ( int i = 0; i < event->GetNSubEvents(); ++i )
+ Int_t offset = AliDAQ::DdlIDOffset("MUONTRK");
+
+ for ( int i = 0; i < AliDAQ::NumberOfDdls("MUONTRK"); ++i )
{
- AliRawVEvent* sub = event->GetSubEvent(i);
-
- for ( int j = 0; j < sub->GetNEquipments(); ++j )
+ rawReader->Reset();
+ rawReader->Select("MUONTRK",i,i);
+ if (rawReader->ReadHeader() )
{
- AliRawVEquipment* eq = sub->GetEquipment(j);
-
- AliRawEquipmentHeader* equipmentHeader = eq->GetEquipmentHeader();
-
- UInt_t uid = equipmentHeader->GetId();
-
- int index;
-
- TString det(AliDAQ::DetectorNameFromDdlID(uid,index));
-
- if (det=="MUONTRK")
- {
- UInt_t ddlsize = equipmentHeader->GetEquipmentSize();
- hDDLEventSize->Fill(uid,ddlsize);
- hddlevents->Fill(uid);
- eventSize += ddlsize;
- }
- }
- }
+ UInt_t ddlsize = rawReader->GetEquipmentSize();
+ hDDLEventSize->Fill(i+offset,ddlsize);
+ hddlevents->Fill(i+offset);
+ }
+ }
+ rawReader->Reset();
}
//____________________________________________________________________________
AliCodeTimerAuto("",0);
+ if ( GetRecoParam()->TryRecover() )
+ {
+ fDigitMaker->SetTryRecover(kTRUE);
+ }
+ else
+ {
+ fDigitMaker->SetTryRecover(kFALSE);
+ }
+
TrackerCalData(AliRecoParam::AConvert(Master()->GetEventSpecie()),kTRUE);
/// Book histograms that are common to Raws and Digits
{
dm->ProcessEvent();
- FillEventSize(rawReader->GetEvent());
-
+ FillEventSize(rawReader);
+
if ( dm->LastEventWasEmpty() )
{
TH1* hrostatus = GetRawsData(AliMUONQAIndices::kTrackerReadoutStatus);
/// Reset those histograms that must be reset (and only those), plus
/// the trackerdata itself.
+ AliInfo("");
+
TIter next(list);
TObject* o;
while ( ( o = next() ) )
{
TString hn(h->GetName());
- if ( hn.Contains("Tracker") )
+ if ( !hn.Contains("TrackerBusPatchConfig") )
{
- if ( !hn.Contains("hTrackerBusPatchNofPads") &&
- !hn.Contains("hTrackerBusPatchConfig" ) )
+ AliInfo(Form("Resetting %s",hn.Data()));
+
+ if ( hn.Contains("DDLMeanEventSize") )
{
- AliDebug(1,Form("Resetting %s",hn.Data()));
- h->Reset();
- }
+ h->Print();
+ h->GetListOfFunctions()->ls();
+ cout << ">>>>>" << endl;
+ }
+
+ h->Reset();
+
+ if ( hn.Contains("DDLMeanEventSize") )
+ {
+ h->Print();
+ h->GetListOfFunctions()->ls();
+ cout << "<<<<<<" << endl;
+ }
}
else
{
- AliDebug(1,Form("Will not reset histogram %s",hn.Data()));
+ // AliDebug(1,Form("Will not reset histogram %s",hn.Data()));
+ AliInfo(Form("Will not reset histogram %s",hn.Data()));
}
}
else
if ( create )
{
array = new TObjArray(AliRecoParam::kNSpecies);
+ array->SetOwner(kTRUE);
}
}
if (array)
{
- array->SetOwner(kFALSE); // as the tracker data will be attached to fQADigitsList which will become the owner
o = array->At(specieIndex);
if (!o && create)
{
if (array)
{
- array->SetOwner(kFALSE); // as the tracker data will be attached to fQARecPointsList which will become the owner
o = array->At(specieIndex);
if (!o && create)
{
if (array)
{
- array->SetOwner(kTRUE);
o = array->At(specieIndex);
if (!o && create)
{
class AliMUONQAMappingCheck;
class AliMUONLogger;
class AliMUONQADataMakerRec;
-class AliRawVEvent;
class AliMUONTrackerQADataMakerRec: public AliMUONVQADataMakerRec {
void FillReadoutStatus(AliMUONLogger& log, AliMUONVTrackerData* data);
- void FillEventSize(const AliRawVEvent* event);
+ void FillEventSize(AliRawReader* rawReader);
void InitCommon();
#if !defined(__CINT__) || defined(__MAKECINT__)
#include "AliMUONRecoParam.h"
-#include "AliMUONCDB.h"
-
#include "AliCDBManager.h"
-#include "AliRecoParam.h"
-
-#include <TObjArray.h>
-#include <TIterator.h>
+#include "AliMUONCDB.h"
#include <Riostream.h>
#endif
-
//-----------------------------------------------------------------------
-void MakeMUONRecoParamArray(Int_t startRun = 0, Int_t endRun = AliCDBRunRange::Infinity(),
- Int_t settingsForCosmicRun = kFALSE)
+void MakeMUONRecoParamArray(Int_t startRun = 0,
+ Int_t endRun = AliCDBRunRange::Infinity(),
+ const char* settings="ppIdeal")
{
/// set the reconstruction parameters and store them in the OCDB ($ALICE_ROOT/OCDB/MUON/Calib/RecoParam/).
+ ///
/// - make a CDB entry for the run range [startRun, endRun]
- /// - the choice between two possible configurations:
- /// - settingsForCosmicRun = kFALSE (default), i.e.
- /// LowFlux (default)
- /// Calibration
- /// - settingsForCosmicRun = kTRUE, i.e.
- /// Cosmic (default)
- /// Calibration
+ ///
+ /// for the possible values of settings, please see AliMUONRecoParam::Create
// init CDB
AliCDBManager* man = AliCDBManager::Instance();
- if(!man->IsDefaultStorageSet()) man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
- man->SetRun(startRun);
- // set RecoParams
- AliMUONRecoParam *param;
- TObjArray recoParams;
-
- AliRecoParam::EventSpecie_t defaultParam = AliRecoParam::kLowMult;
-
- if(!settingsForCosmicRun) {
- // set parameters for p-p runs
- param = AliMUONRecoParam::GetLowFluxParam();
- recoParams.AddLast(param);
- }
- else {
- // set parameters for cosmic runs
- param = AliMUONRecoParam::GetCosmicParam();
- recoParams.AddLast(param);
- defaultParam = AliRecoParam::kCosmic;
- }
-
- // set (dummy) parameters for calibration runs
- param = AliMUONRecoParam::GetCalibrationParam();
- recoParams.AddLast(param);
-
- // set parameters for Pb-Pb runs
- // param = AliMUONRecoParam::GetHighFluxParam();
- // recoParams.AddLast(param);
-
- // identify default parameters (exit if identification failed)
- Bool_t defaultIsSet = kFALSE;
- TIter next(recoParams.MakeIterator());
- while ( (param = static_cast<AliMUONRecoParam*>(next())) ) {
- if (param->GetEventSpecie() == defaultParam) {
- param->SetAsDefault();
- defaultIsSet = kTRUE;
- }
- param->Print("FULL");
- }
- if (!defaultIsSet) {
- cout<<"The default reconstruction parameters are not set! Exiting..."<<endl;
- return;
+ if (!man->IsDefaultStorageSet())
+ {
+ man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
}
- // save RecoParam in CDB
- AliMUONCDB::WriteToCDB(&recoParams, "MUON/Calib/RecoParam", startRun, endRun, "reconstruction parameters for MUON", "Philippe Pillot");
+ man->SetRun(startRun);
+
+ TObjArray* recoParams = AliMUONRecoParam::Create(settings);
+
+ if (recoParams)
+ {
+ // save RecoParam in CDB
+ AliMUONCDB::WriteToCDB(recoParams, "MUON/Calib/RecoParam", startRun, endRun,
+ "reconstruction parameters for MUON", "MakeMUONRecoParamArray $Id$");
+ }
+ delete recoParams;
}