#include "AliMUON1DMap.h"
#include "AliMUON2DMap.h"
#include "AliMUONCalibParamND.h"
+#include "AliMUONRejectList.h"
#include "AliMUONSparseHisto.h"
#include "AliMUONVStore.h"
#include "AliMpBusPatch.h"
#include "AliMpDCSNamer.h"
#include "AliMpManuIterator.h"
#include "AliMpEncodePair.h"
+#include "AliMpSegmentation.h"
#include <Riostream.h>
#include <TClass.h>
#include <TMath.h>
#include <TObjArray.h>
#include <TObjString.h>
#include <TString.h>
+#include <TTimeStamp.h>
#include <TVector2.h>
+#include <cassert>
#include <float.h>
/// \class AliMUONTrackerData
///
/// \author Laurent Aphecetche, Subatech
+using std::cout;
+using std::endl;
///\cond CLASSIMP
ClassImp(AliMUONTrackerData)
///\endcond
fXmax(0.0),
fIsChannelLevelEnabled(kTRUE),
fIsManuLevelEnabled(kTRUE),
+fIsBustPatchLevelEnabled(kTRUE),
+fIsPCBLevelEnabled(kTRUE),
fNofDDLs(0),
fNofEventsPerDDL(0x0)
{
/// ctor
- memset(fHistogramming,0,sizeof(Int_t)); // histogramming is off by default. Use MakeHistogramForDimension to turn it on.
+ memset(fHistogramming,0,fExternalDimension*sizeof(Int_t)); // histogramming is off by default. Use MakeHistogramForDimension to turn it on.
fExternalDimensionNames->SetOwner(kTRUE);
fDimensionNames->SetOwner(kTRUE);
fDimensionNames->AddAt(new TObjString("occ"),IndexOfOccupancyDimension());
Clear();
}
+//_____________________________________________________________________________
+AliMUONTrackerData::AliMUONTrackerData(const char* name, const char* title,
+ const AliMUONVStore& manuValues)
+: AliMUONVTrackerData(name,title),
+fIsSingleEvent(kFALSE),
+fChannelValues(0x0),
+fManuValues(0x0),
+fBusPatchValues(0x0),
+fDEValues(0x0),
+fChamberValues(0x0),
+fPCBValues(0x0),
+fDimension(0),
+fNevents(0),
+fDimensionNames(0x0),
+fExternalDimensionNames(0x0),
+fExternalDimension(0),
+fHistogramming(0x0),
+fHistos(0x0),
+fXmin(0.0),
+fXmax(0.0),
+fIsChannelLevelEnabled(kFALSE),
+fIsManuLevelEnabled(kTRUE),
+fIsBustPatchLevelEnabled(kTRUE),
+fIsPCBLevelEnabled(kTRUE),
+fNofDDLs(0),
+fNofEventsPerDDL(0x0)
+{
+ /// ctor with pre-computed values at the manu level
+ /// In this case, we force fIsChannelLevelEnabled = kFALSE
+ /// ctor
+
+ if (manuValues.GetSize()==0)
+ {
+ AliFatal("Cannot create a tracker data from nothing in that case !");
+ }
+
+ if ( !AliMpDDLStore::Instance(kFALSE) && !AliMpManuStore::Instance(kFALSE) )
+ {
+ AliError("Cannot work without (full) mapping");
+ return;
+ }
+
+ TIter next(manuValues.CreateIterator());
+ AliMUONVCalibParam* m = static_cast<AliMUONVCalibParam*>(next());
+
+ Int_t dimension = ( m->Dimension() - fgkExtraDimension - fgkVirtualExtraDimension ) / 2;
+
+ fDimension = External2Internal(dimension)+fgkExtraDimension;
+
+ fDimensionNames = new TObjArray(fDimension+fgkVirtualExtraDimension);
+ fExternalDimensionNames = new TObjArray(dimension);
+ fExternalDimension = dimension;
+ fHistogramming = new Int_t[fExternalDimension];
+ memset(fHistogramming,0,fExternalDimension*sizeof(Int_t)); // histogramming is off by default. Use MakeHistogramForDimension to turn it on.
+
+ fExternalDimensionNames->SetOwner(kTRUE);
+ fDimensionNames->SetOwner(kTRUE);
+ fDimensionNames->AddAt(new TObjString("occ"),IndexOfOccupancyDimension());
+ fDimensionNames->AddAt(new TObjString("N"),IndexOfNumberDimension());
+ fDimensionNames->AddAt(new TObjString("n"),NumberOfDimensions()-fgkVirtualExtraDimension);
+ Clear();
+ TArrayI nevents(AliDAQ::NumberOfDdls("MUONTRK"));
+ AssertStores();
+
+ next.Reset();
+ AliMUONVCalibParam* external;
+
+ while ( ( external = static_cast<AliMUONVCalibParam*>(next()) ) )
+ {
+ Int_t detElemId, manuId;
+
+ GetDEManu(*external,detElemId,manuId);
+
+ AliMUONVCalibParam* chamber(0x0);
+ AliMUONVCalibParam* de(0x0);
+ AliMUONVCalibParam* busPatch(0x0);
+ AliMUONVCalibParam* pcb(0x0);
+ AliMUONVCalibParam* manu(0x0);
+ AliMUONVCalibParam* channel(0x0);
+ AliMpDetElement* mpde(0x0);
+
+ AliMUONVCalibParam* wec = new AliMUONCalibParamND(external->Dimension()-1,1,detElemId,manuId,0);
+ // as external, but without event count
+ wec->SetValueAsDouble(0,0,external->ValueAsDouble(0,0));
+ wec->SetValueAsDouble(0,1,external->ValueAsDouble(0,1));
+ wec->SetValueAsDouble(0,2,external->ValueAsDouble(0,2));
+ wec->SetValueAsDouble(0,3,external->ValueAsDouble(0,3));
+
+ Int_t mid = GetParts(wec,chamber,de,busPatch,pcb,manu,channel,mpde);
+
+ if ( manuId != mid )
+ {
+ AliError(Form("Something is wrong for DE %5d : manuId = %d vs mid = %d",detElemId,manuId,mid));
+ continue;
+ }
+
+ if ( manuId < 0 )
+ {
+ AliError("Got a < 0 manuId. Should not happen here !");
+ continue;
+ }
+
+ assert(channel==0x0);
+
+ Int_t n1 = manu->ValueAsInt(0,IndexOfNumberDimension());
+ Int_t n2 = external->ValueAsInt(0,IndexOfNumberDimension());
+ if ( n1 != n2 )
+ {
+ AliError(Form("Incoherent number of manu channels for DE %5d MANU %5d : %d vs %d",
+ detElemId,manuId,n1,n2));
+ }
+
+ Int_t nevt = external->ValueAsInt(0,4);
+
+ Int_t busPatchId = AliMpDDLStore::Instance()->GetBusPatchId(detElemId,manuId);
+
+ Int_t ddl = AliMpDDLStore::Instance()->GetDDLfromBus(busPatchId);
+
+ if ( nevents[ddl] == 0 )
+ {
+ nevents[ddl] = nevt;
+ }
+ else
+ {
+ if ( nevents.At(ddl) != nevt )
+ {
+ AliError(Form("Nevt mismatch for DE %5d MANU %5d DDL %d : %d vs %d",
+ detElemId,manuId,ddl,nevents.At(ddl),nevt));
+ continue;
+ }
+ }
+
+ for ( Int_t i = 0; i < wec->Dimension()-1; ++i )
+ {
+ manu->SetValueAsDouble(0,i,manu->ValueAsDouble(0,i) + wec->ValueAsDouble(0,i));
+
+ busPatch->SetValueAsDouble(0,i,busPatch->ValueAsDouble(0,i) + wec->ValueAsDouble(0,i));
+
+ de->SetValueAsDouble(0,i,de->ValueAsDouble(0,i) + wec->ValueAsDouble(0,i));
+
+ chamber->SetValueAsDouble(0,i,chamber->ValueAsDouble(0,i) + wec->ValueAsDouble(0,i));
+ }
+ delete wec;
+ }
+
+ UpdateNumberOfEvents(&nevents);
+
+}
+
+//_____________________________________________________________________________
+AliMUONTrackerData::AliMUONTrackerData(const char* name, const char* title,
+ const AliMUONVStore& deOrBpValues, Int_t val)
+: AliMUONVTrackerData(name,title),
+fIsSingleEvent(kFALSE),
+fChannelValues(0x0),
+fManuValues(0x0),
+fBusPatchValues(0x0),
+fDEValues(0x0),
+fChamberValues(0x0),
+fPCBValues(0x0),
+fDimension(0),
+fNevents(0),
+fDimensionNames(0x0),
+fExternalDimensionNames(0x0),
+fExternalDimension(0),
+fHistogramming(0x0),
+fHistos(0x0),
+fXmin(0.0),
+fXmax(0.0),
+fIsChannelLevelEnabled(kFALSE),
+fIsManuLevelEnabled(kFALSE),
+fIsBustPatchLevelEnabled(kFALSE),
+fIsPCBLevelEnabled(kFALSE),
+fNofDDLs(0),
+fNofEventsPerDDL(0x0)
+{
+ /// ctor with values at the detection element OR bus patch level
+ /// In this case, we force fIsChannelLevelEnabled = fIsManuLevelEnabled = kFALSE
+ /// ctor
+
+ if (deOrBpValues.GetSize()==0)
+ {
+ AliFatal("Cannot create a tracker data from nothing in that case !");
+ }
+
+ if ( !AliMpDDLStore::Instance(kFALSE) && !AliMpManuStore::Instance(kFALSE) )
+ {
+ AliError("Cannot work without (full) mapping");
+ return;
+ }
+
+ if ( val == 1 )
+ {
+ BuildFromDEStore(deOrBpValues);
+ }
+ else if ( val == 2 )
+ {
+ BuildFromBPStore(deOrBpValues);
+ }
+ else
+ {
+ AliFatal("Wrong parameter. Must be 1 or 2");
+ }
+
+
+}
+
+//_____________________________________________________________________________
+void AliMUONTrackerData::BuildFromDEStore(const AliMUONVStore& deValues)
+{
+ /// Fill internals from a store of values at the detection element level
+
+ TIter next(deValues.CreateIterator());
+ AliMUONVCalibParam* m = static_cast<AliMUONVCalibParam*>(next());
+
+ Int_t dimension = ( m->Dimension() - fgkExtraDimension - fgkVirtualExtraDimension ) / 2;
+
+ fDimension = External2Internal(dimension)+fgkExtraDimension;
+
+ fDimensionNames = new TObjArray(fDimension+fgkVirtualExtraDimension);
+ fExternalDimensionNames = new TObjArray(dimension);
+ fExternalDimension = dimension;
+ fHistogramming = new Int_t[fExternalDimension];
+ memset(fHistogramming,0,fExternalDimension*sizeof(Int_t)); // histogramming is off by default. Use MakeHistogramForDimension to turn it on.
+
+ fExternalDimensionNames->SetOwner(kTRUE);
+ fDimensionNames->SetOwner(kTRUE);
+ fDimensionNames->AddAt(new TObjString("occ"),IndexOfOccupancyDimension());
+ fDimensionNames->AddAt(new TObjString("N"),IndexOfNumberDimension());
+ fDimensionNames->AddAt(new TObjString("n"),NumberOfDimensions()-fgkVirtualExtraDimension);
+ Clear();
+ TArrayI nevents(AliDAQ::NumberOfDdls("MUONTRK"));
+ AssertStores();
+
+ next.Reset();
+ AliMUONVCalibParam* external;
+
+ while ( ( external = static_cast<AliMUONVCalibParam*>(next()) ) )
+ {
+ Int_t detElemId = external->ID0();
+
+ AliMpDetElement* mpde = AliMpDDLStore::Instance()->GetDetElement(detElemId,kFALSE);
+
+ if (!mpde)
+ {
+ AliError(Form("Got an invalid DE (%d) from external store",detElemId));
+ continue;
+ }
+
+ Int_t chamberId = AliMpDEManager::GetChamberId(detElemId);
+ AliMUONVCalibParam* chamber = ChamberParam(chamberId,kTRUE);
+ AliMUONVCalibParam* de = DetectionElementParam(detElemId,kTRUE);
+
+ AliMUONVCalibParam* wec = new AliMUONCalibParamND(external->Dimension()-1,1,detElemId,0,0);
+ // as external, but without event count
+ wec->SetValueAsDouble(0,0,external->ValueAsDouble(0,0));
+ wec->SetValueAsDouble(0,1,external->ValueAsDouble(0,1));
+ wec->SetValueAsDouble(0,2,external->ValueAsDouble(0,2));
+ wec->SetValueAsDouble(0,3,external->ValueAsDouble(0,3));
+
+ Int_t n1 = de->ValueAsInt(0,IndexOfNumberDimension());
+ Int_t n2 = external->ValueAsInt(0,IndexOfNumberDimension());
+ if ( n1 != n2 )
+ {
+ AliError(Form("Incoherent number of dimensions for DE%d : %d vs %d",
+ detElemId,n1,n2));
+ continue;
+ }
+
+ Int_t nevt = external->ValueAsInt(0,4);
+
+ Int_t ddl = mpde->GetDdlId();
+
+ if ( nevents[ddl] == 0 )
+ {
+ nevents[ddl] = nevt;
+ }
+ else
+ {
+ if ( nevents.At(ddl) != nevt )
+ {
+ AliError(Form("Nevt mismatch for DE %5d DDL %d : %d vs %d",
+ detElemId,ddl,nevents.At(ddl),nevt));
+ continue;
+ }
+ }
+
+ for ( Int_t i = 0; i < wec->Dimension()-1; ++i )
+ {
+ de->SetValueAsDouble(0,i,de->ValueAsDouble(0,i) + wec->ValueAsDouble(0,i));
+
+ chamber->SetValueAsDouble(0,i,chamber->ValueAsDouble(0,i) + wec->ValueAsDouble(0,i));
+ }
+ delete wec;
+ }
+
+ UpdateNumberOfEvents(&nevents);
+}
+
+//_____________________________________________________________________________
+void AliMUONTrackerData::BuildFromBPStore(const AliMUONVStore& bpValues)
+{
+ /// Fill internals from a store of values at the bus patch level
+
+ fIsBustPatchLevelEnabled = kTRUE;
+
+ TIter next(bpValues.CreateIterator());
+ AliMUONVCalibParam* m = static_cast<AliMUONVCalibParam*>(next());
+
+ Int_t dimension = ( m->Dimension() - fgkExtraDimension - fgkVirtualExtraDimension ) / 2;
+
+ fDimension = External2Internal(dimension)+fgkExtraDimension;
+
+ fDimensionNames = new TObjArray(fDimension+fgkVirtualExtraDimension);
+ fExternalDimensionNames = new TObjArray(dimension);
+ fExternalDimension = dimension;
+ fHistogramming = new Int_t[fExternalDimension];
+ memset(fHistogramming,0,fExternalDimension*sizeof(Int_t)); // histogramming is off by default. Use MakeHistogramForDimension to turn it on.
+
+ fExternalDimensionNames->SetOwner(kTRUE);
+ fDimensionNames->SetOwner(kTRUE);
+ fDimensionNames->AddAt(new TObjString("occ"),IndexOfOccupancyDimension());
+ fDimensionNames->AddAt(new TObjString("N"),IndexOfNumberDimension());
+ fDimensionNames->AddAt(new TObjString("n"),NumberOfDimensions()-fgkVirtualExtraDimension);
+ Clear();
+ TArrayI nevents(AliDAQ::NumberOfDdls("MUONTRK"));
+ AssertStores();
+
+ next.Reset();
+ AliMUONVCalibParam* external;
+
+ while ( ( external = static_cast<AliMUONVCalibParam*>(next()) ) )
+ {
+ Int_t busPatchId = external->ID0();
+
+ AliMpBusPatch* mpbp = AliMpDDLStore::Instance()->GetBusPatch(busPatchId,kFALSE);
+
+ if (!mpbp)
+ {
+ AliError(Form("Got an invalid buspatchId (%d) from external store",busPatchId));
+ continue;
+ }
+
+ Int_t detElemId = AliMpDDLStore::Instance()->GetDEfromBus(busPatchId);
+ Int_t chamberId = AliMpDEManager::GetChamberId(detElemId);
+ AliMUONVCalibParam* chamber = ChamberParam(chamberId,kTRUE);
+ AliMUONVCalibParam* de = DetectionElementParam(detElemId,kTRUE);
+ AliMUONVCalibParam* bp = BusPatchParam(busPatchId,kTRUE);
+
+ AliMUONVCalibParam* wec = new AliMUONCalibParamND(external->Dimension()-1,1,busPatchId,0,0);
+ // as external, but without event count
+ wec->SetValueAsDouble(0,0,external->ValueAsDouble(0,0));
+ wec->SetValueAsDouble(0,1,external->ValueAsDouble(0,1));
+ wec->SetValueAsDouble(0,2,external->ValueAsDouble(0,2));
+ wec->SetValueAsDouble(0,3,external->ValueAsDouble(0,3));
+
+ Int_t n1 = bp->ValueAsInt(0,IndexOfNumberDimension());
+ Int_t n2 = external->ValueAsInt(0,IndexOfNumberDimension());
+ if ( n1 != n2 )
+ {
+ AliError(Form("Incoherent number of dimensions for BP%d : %d vs %d",
+ busPatchId,n1,n2));
+ continue;
+ }
+
+ Int_t nevt = external->ValueAsInt(0,4);
+
+ Int_t ddl = mpbp->GetDdlId();
+
+ if ( nevents[ddl] == 0 )
+ {
+ nevents[ddl] = nevt;
+ }
+ else
+ {
+ if ( nevents.At(ddl) != nevt )
+ {
+ AliError(Form("Nevt mismatch for BP %5d DDL %d : %d vs %d",
+ busPatchId,ddl,nevents.At(ddl),nevt));
+ continue;
+ }
+ }
+
+ for ( Int_t i = 0; i < wec->Dimension()-1; ++i )
+ {
+ bp->SetValueAsDouble(0,i,bp->ValueAsDouble(0,i) + wec->ValueAsDouble(0,i));
+
+ de->SetValueAsDouble(0,i,de->ValueAsDouble(0,i) + wec->ValueAsDouble(0,i));
+
+ chamber->SetValueAsDouble(0,i,chamber->ValueAsDouble(0,i) + wec->ValueAsDouble(0,i));
+ }
+ delete wec;
+ }
+
+ UpdateNumberOfEvents(&nevents);
+}
+
+//_____________________________________________________________________________
+AliMUONTrackerData::AliMUONTrackerData(const char* name, const char* title,
+ const AliMUONRejectList& rejectList)
+: AliMUONVTrackerData(name,title),
+fIsSingleEvent(kFALSE),
+fChannelValues(0x0),
+fManuValues(0x0),
+fBusPatchValues(0x0),
+fDEValues(0x0),
+fChamberValues(0x0),
+fPCBValues(0x0),
+fDimension(External2Internal(1)+fgkExtraDimension),
+fNevents(0),
+fDimensionNames(new TObjArray(fDimension+fgkVirtualExtraDimension)),
+fExternalDimensionNames(new TObjArray(1)),
+fExternalDimension(1),
+fHistogramming(new Int_t[fExternalDimension]),
+fHistos(0x0),
+fXmin(0.0),
+fXmax(0.0),
+fIsChannelLevelEnabled(kTRUE),
+fIsManuLevelEnabled(kTRUE),
+fIsBustPatchLevelEnabled(kTRUE),
+fIsPCBLevelEnabled(kFALSE),
+fNofDDLs(0),
+fNofEventsPerDDL(0x0)
+{
+
+ /// ctor with values from the given rejectlist
+
+ if ( !AliMpDDLStore::Instance(kFALSE) && !AliMpManuStore::Instance(kFALSE) )
+ {
+ AliError("Cannot work without (full) mapping");
+ return;
+ }
+
+ memset(fHistogramming,0,fExternalDimension*sizeof(Int_t)); // histogramming is off by default. Use MakeHistogramForDimension to turn it on.
+
+ fExternalDimensionNames->SetOwner(kTRUE);
+ fDimensionNames->SetOwner(kTRUE);
+ fDimensionNames->AddAt(new TObjString("occ"),IndexOfOccupancyDimension());
+ fDimensionNames->AddAt(new TObjString("N"),IndexOfNumberDimension());
+ fDimensionNames->AddAt(new TObjString("n"),NumberOfDimensions()-fgkVirtualExtraDimension);
+ Clear();
+ TArrayI nevents(AliDAQ::NumberOfDdls("MUONTRK"));
+ AssertStores();
+
+
+ for ( Int_t chamberId = 0; chamberId < AliMpConstants::NofChambers(); ++chamberId )
+ {
+// AliMUONVCalibParam* chamber = ChamberParam(chamberId,kTRUE);
+
+ // FIXME : update the chamber value ?
+
+ AliMpDEIterator deit;
+
+ deit.First(chamberId);
+
+ while ( !deit.IsDone() )
+ {
+ AliMpDetElement* mpde = deit.CurrentDE();
+
+ Int_t detElemId = mpde->GetId();
+
+ AliMUONVCalibParam* de = DetectionElementParam(detElemId,kTRUE);
+
+ DispatchValue(*de,0,rejectList.DetectionElementProbability(detElemId),0.0,mpde->NofChannels());
+
+ for ( Int_t iBusPatch = 0; iBusPatch < mpde->GetNofBusPatches(); ++iBusPatch )
+ {
+ Int_t busPatchId = mpde->GetBusPatchId(iBusPatch);
+
+ AliMUONVCalibParam* bp = BusPatchParam(busPatchId,kTRUE);
+
+ AliMpBusPatch* mpbp = AliMpDDLStore::Instance()->GetBusPatch(busPatchId);
+
+ Int_t nch(0);
+
+ for ( Int_t iManu = 0 ;iManu < mpbp->GetNofManus(); ++iManu )
+ {
+ Int_t manuId = mpbp->GetManuId(iManu);
+
+ nch += mpde->NofChannelsInManu(manuId);
+
+ AliMUONVCalibParam* manu = ManuParam(detElemId,manuId,kTRUE);
+
+ DispatchValue(*manu,0,rejectList.ManuProbability(detElemId,manuId),0.0,mpde->NofChannelsInManu(manuId));
+
+ AliMUONVCalibParam* c = ChannelParam(detElemId,manuId);
+
+ if (!c)
+ {
+ c = new AliMUONCalibParamND(Dimension(),
+ AliMpConstants::ManuNofChannels(),
+ detElemId,
+ manuId,
+ 0.0);
+ fChannelValues->Add(c);
+ }
+
+ for ( Int_t manuChannel = 0; manuChannel < AliMpConstants::ManuNofChannels(); ++manuChannel )
+ {
+ DispatchValue(*c,manuChannel,rejectList.ChannelProbability(detElemId,manuId,manuChannel),0.0,1);
+ }
+ }
+
+ DispatchValue(*bp,0,rejectList.BusPatchProbability(busPatchId),0.0,nch);
+
+ }
+
+ deit.Next();
+ }
+
+ }
+
+
+ SetDimensionName(0,"RejectProba");
+
+ UpdateNumberOfEvents(0x0);
+}
+
//_____________________________________________________________________________
AliMUONTrackerData::~AliMUONTrackerData()
{
// First cross check we have compatible objects.
+ AliCodeTimerAuto("",0);
+
if ( fIsChannelLevelEnabled != data.fIsChannelLevelEnabled )
{
AliError("Incompatible IsChannelLevelEnabled status");
if ( ( !fHistogramming && data.fHistogramming ) || ( fHistogramming && !data.fHistogramming )
|| fXmin != data.fXmin || fXmax != data.fXmax )
{
- AliError(Form("Incompatible histogramming (%x vs %x) (xmax = %e vs %e ; xmin = %e vs %e)",
+ AliError(Form("Incompatible histogramming (%p vs %p) (xmax = %e vs %e ; xmin = %e vs %e)",
fHistogramming,data.fHistogramming,fXmax,data.fXmax,fXmin,data.fXmin));
return kFALSE;
}
}
}
+ for ( Int_t i = 0 ; i < fNofDDLs; ++i )
+ {
+ fNevents = TMath::Max(fNevents,fNofEventsPerDDL[i]);
+ }
+
return kTRUE;
}
//_____________________________________________________________________________
Bool_t
-AliMUONTrackerData::InternalAdd(const AliMUONVStore& store, TArrayI* nevents, Bool_t replace)
+AliMUONTrackerData::UpdateNumberOfEvents(TArrayI* nevents)
{
- /// Add the given external store to our internal store
+ /// Update the number of events
- AliCodeTimerAuto(GetName());
-
- if ( !replace)
- {
- if ( IsSingleEvent() && NumberOfEvents(-1) == 1 )
- {
- AliError(Form("%s is supposed to be single event only",GetName()));
- return kFALSE;
- }
- }
-
if (!fNofDDLs)
{
fNofDDLs = AliDAQ::NumberOfDdls("MUONTRK");
fNofEventsPerDDL[i] = 0;
}
}
-
+
if (nevents)
{
if (nevents->GetSize() != fNofDDLs )
fNevents = TMath::Max(fNevents,fNofEventsPerDDL[i]);
}
}
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+void
+AliMUONTrackerData::AssertStores()
+{
+ /// Insure our stores are allocated
if (!fChamberValues)
{
// get number of bus patches and number of detection element
// to initialize fBusPatchValues and fDEValues below
+ if (!AliMpDDLStore::Instance(false))
+ {
+ AliMpCDB::LoadAll();
+ }
+
TIter next(AliMpDDLStore::Instance()->CreateBusPatchIterator());
while ( next() ) ++numberOfBusPatches;
AliMpDEIterator deIt;
deIt.Next();
}
- if ( fIsChannelLevelEnabled )
- {
- fChannelValues = new AliMUON2DMap(kTRUE);
- }
+ if ( fIsChannelLevelEnabled )
+ {
+ fChannelValues = new AliMUON2DMap(kTRUE);
+ }
if ( fIsManuLevelEnabled )
{
fManuValues = new AliMUON2DMap(kTRUE);
}
- fPCBValues = new AliMUON2DMap(kFALSE);
- fBusPatchValues = new AliMUON1DMap(numberOfBusPatches);
+ if ( fIsPCBLevelEnabled )
+ {
+ fPCBValues = new AliMUON2DMap(kFALSE);
+ }
+ if ( fIsBustPatchLevelEnabled )
+ {
+ fBusPatchValues = new AliMUON1DMap(numberOfBusPatches);
+ }
fDEValues = new AliMUON1DMap(numberOfDEs);
fChamberValues = new AliMUON1DArray;
}
+}
+
+//_____________________________________________________________________________
+Bool_t
+AliMUONTrackerData::InternalAdd(const AliMUONVStore& store, TArrayI* nevents, Bool_t replace)
+{
+ /// Add the given external store to our internal store
+
+ AliCodeTimerAuto(GetName(),0);
+
+ if ( !replace)
+ {
+ if ( IsSingleEvent() && NumberOfEvents(-1) == 1 )
+ {
+ AliError(Form("%s is supposed to be single event only",GetName()));
+ return kFALSE;
+ }
+ }
+
+ UpdateNumberOfEvents(nevents);
+
+ AssertStores();
TIter next(store.CreateIterator());
AliMUONVCalibParam* external;
return kFALSE;
}
-
- AliMUONVCalibParam* chamber, *de, *busPatch, *pcb, *manu, *channel;
- AliMpDetElement* mpde;
+ AliMUONVCalibParam* chamber(0x0);
+ AliMUONVCalibParam* de(0x0);
+ AliMUONVCalibParam* busPatch(0x0);
+ AliMUONVCalibParam* pcb(0x0);
+ AliMUONVCalibParam* manu(0x0);
+ AliMUONVCalibParam* channel(0x0);
+ AliMpDetElement* mpde(0x0);
Int_t manuId = GetParts(external,chamber,de,busPatch,pcb,manu,channel,mpde);
{
/// Create storage for one bus patch
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
AliMpBusPatch* bp = AliMpDDLStore::Instance()->GetBusPatch(busPatchId);
{
/// Create storage for one chamber
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
AliMUONVCalibParam* chamber = new AliMUONCalibParamND(Dimension(),1,chamberId,0,0.0);
//_____________________________________________________________________________
AliMUONVCalibParam*
AliMUONTrackerData::ChannelParam(Int_t detElemId, Int_t manuId,
- AliMUONVCalibParam* external) const
+ const AliMUONVCalibParam* external) const
{
/// Return (if it exist) the VCalibParam for a given manu
{
fNofEventsPerDDL[i] = 0;
}
+ fNevents = 0;
NumberOfEventsChanged();
}
{
/// Create a double version of VCalibParam, for internal use
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
AliMUONVCalibParam* c = new AliMUONCalibParamND(Dimension(),
param.Size(),
{
/// Create storage for one detection element
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
AliMUONVCalibParam* de = new AliMUONCalibParamND(Dimension(),1,detElemId,0,0.0);
manuId = AliMp::PairSecond(pair);
if ( !detElemId )
{
- AliError(Form("DE %d manuId %d from serial %d is not correct !",
- detElemId,manuId,serial));
+ AliDebug(1,Form("DE %d manuId %d from serial %d is not correct !",
+ detElemId,manuId,serial));
}
}
else
{
/// Get containers at all levels
+ chamber = de = busPatch = pcb = manu = channel = 0x0;
+ mpde = 0x0;
+
AliMpDDLStore* ddlStore = AliMpDDLStore::Instance();
Int_t detElemId;
GetDEManu(*external,detElemId,manuId);
- mpde = ddlStore->GetDetElement(detElemId);
+ mpde = ddlStore->GetDetElement(detElemId,kFALSE);
if (!mpde) // can happen if reading e.g. capacitances store where we have data for non-connected manus
{
return -1;
}
+ // explicitely check that de,manu is correct
+ const AliMpVSegmentation* mpseg = AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId, manuId,kFALSE);
+
+ if (!mpseg)
+ {
+ return -1;
+ }
+
Int_t chamberId = AliMpDEManager::GetChamberId(detElemId);
Int_t busPatchId = ddlStore->GetBusPatchId(detElemId,manuId);
+ if ( busPatchId <= 0 )
+ {
+ return -1;
+ }
+
Int_t pcbIndex = -1;
AliMp::StationType stationType = mpde->GetStationType();
pcbIndex = namer.ManuId2PCBIndex(detElemId,manuId);
}
- channel = ChannelParam(detElemId,manuId,external);
+ if ( fIsChannelLevelEnabled )
+ {
+ channel = ChannelParam(detElemId,manuId,external);
+ }
manu = ManuParam(detElemId,manuId,kTRUE);
{
/// Create storage for one manu
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
AliMUONVCalibParam* manu = new AliMUONCalibParamND(Dimension(),1,detElemId,manuId,0.0);
while ( ( o = next() ) )
{
const AliMUONTrackerData* data = dynamic_cast<const AliMUONTrackerData*>(o);
- if (!o)
+ if (!data)
{
AliError(Form("Object named %s is not an AliMUONTrackerData ! Skipping it",
o->GetName()));
{
/// Create storage for one PCB (station345 only)
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
AliMpDCSNamer namer("TRACKER");
if ( index >= fExternalDimension )
{
- AliError(Form("Index out of bounds : %d / %d",index,fExternalDimension));
+ AliError(Form("%s : dimension %s : Index out of bounds : %d / %d",
+ GetName(),
+ name,index,fExternalDimension));
return;
}
return;
}
+ AliWarning(Form("Will %s make histogram for data %s index %d : that might ressemble a memory leak depending on the input data",
+ value ? "":"not", GetName(),index));
fHistogramming[index] = value;
fXmin = xmin;
fXmax = xmax;
}
}
+//_____________________________________________________________________________
+Bool_t
+AliMUONTrackerData::ExportAsASCIIOccupancyFile(const char* filename, Int_t runNumber) const
+{
+ /// Export only the occupancy part, in a format compatible with what
+ /// the online occupancy DA is writing
+
+ if ( ! AliMpDDLStore::Instance(kFALSE) )
+ {
+ AliError("Mapping not loaded. Cannot work");
+ return kFALSE;
+ }
+
+ if (!fManuValues)
+ {
+ AliError("No manu values. Cannot work");
+ return kFALSE;
+ }
+
+ ofstream out(filename);
+
+ if (out.bad())
+ {
+ AliError(Form("Cannot create file %s",filename));
+ return kFALSE;
+ }
+
+ out << "//===========================================================================" << endl;
+ out << "// Hit counter exported from $Id$" << endl;
+ out << "//===========================================================================" << endl;
+ out << "//" << endl;
+ out << "// * Run Number : " << runNumber << endl;
+ out << "// * File Creation Date : " << TTimeStamp().AsString("l") << endl;
+ out << "//---------------------------------------------------------------------------" << endl;
+ out << "// BP MANU SUM_N NEVENTS" << endl;
+ out << "//---------------------------------------------------------------------------" << endl;
+
+ TIter next(fManuValues->CreateIterator());
+ AliMUONVCalibParam* manu;
+
+ while ( ( manu = static_cast<AliMUONVCalibParam*>(next()) ) )
+ {
+ Int_t detElemId = manu->ID0();
+ Int_t manuId = manu->ID1();
+ Int_t busPatchId = AliMpDDLStore::Instance()->GetBusPatchId(detElemId,manuId);
+ Int_t ddl = AliMpDDLStore::Instance()->GetDDLfromBus( busPatchId);
+ if ( busPatchId < 0 || ddl < 0 )
+ {
+ AliError(Form("Got invalid (DE,manu,bp,ddl)=(%d,%d,%d,%d). Skipping it",detElemId,manuId,busPatchId,ddl));
+ continue;
+ }
+ Int_t nevents = fNofEventsPerDDL[ddl];
+
+ out << Form("%5d %5d %10d %10d",busPatchId,manuId,manu->ValueAsInt(0,IndexOfOccupancyDimension()),nevents) << endl;
+ }
+
+ out.close();
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+void AliMUONTrackerData::DispatchValue(AliMUONVCalibParam& param,
+ Int_t index,
+ Double_t y,
+ Double_t ey,
+ Int_t nchannels)
+{
+ /// fills the calibparam with a single value
+
+ Double_t sumn = 1000.0; // or any value strictly above 1
+ Double_t sumw = sumn*y;
+ Double_t sumw2 = (sumn-1)*ey*ey+sumw*sumw/sumn;
+
+ param.SetValueAsDouble(index,0,sumw);
+ param.SetValueAsDouble(index,1,sumw2);
+ param.SetValueAsDouble(index,2,sumn);
+ param.SetValueAsDouble(index,3,nchannels);
+
+}