return "";
}
+//_____________________________________________________________________________
+void
+AliMUONAttPainter::Invert()
+{
+ /// Invert our cathode/plane states
+
+ if ( IsCathodeDefined() )
+ {
+ Bool_t cath0(IsCathode0());
+ Bool_t cath1(IsCathode1());
+ SetCathode(!cath0,!cath1);
+ }
+
+ if ( IsPlaneDefined() )
+ {
+ Bool_t b(IsBendingPlane());
+ Bool_t nb(IsNonBendingPlane());
+
+ SetPlane(!b,!nb);
+ }
+}
+
//_____________________________________________________________________________
TString
AliMUONAttPainter::PlaneName() const
/// Whether we are valid
Bool_t IsValid() const { return TestBit(kIsValid); }
+ void Invert();
+
/// Set our cathode states
void SetCathode(Bool_t cath0, Bool_t cath1) { SetBit(kIsCathode0,cath0); SetBit(kIsCathode1,cath1); }
/// default ctor
}
+//_____________________________________________________________________________
+AliMUONBusPatchPainter::AliMUONBusPatchPainter(TRootIOCtor* ioCtor)
+: AliMUONVPainter(ioCtor),
+fBusPatchId(-1)
+{
+ /// default streaming ctor
+}
+
//_____________________________________________________________________________
AliMUONBusPatchPainter::AliMUONBusPatchPainter(const AliMUONAttPainter& att,
Int_t busPatchId)
((AliMUONBusPatchPainter&)(object)).fBusPatchId = fBusPatchId;
}
+//_____________________________________________________________________________
+Bool_t
+AliMUONBusPatchPainter::IsIncluded() const
+{
+ /// whether this bus patch is included in the readout or not
+ return ( InteractiveReadOutConfig()->BusPatch(fBusPatchId) > 0 );
+}
+
//_____________________________________________________________________________
TString
AliMUONBusPatchPainter::Describe(const AliMUONVTrackerData& data, Int_t dataIndex,
public:
AliMUONBusPatchPainter();
+ AliMUONBusPatchPainter(TRootIOCtor*);
AliMUONBusPatchPainter(const AliMUONAttPainter& att, Int_t busPatchId);
AliMUONBusPatchPainter(const AliMUONBusPatchPainter& rhs);
AliMUONBusPatchPainter& operator=(const AliMUONBusPatchPainter& rhs);
virtual AliMUONAttPainter Validate(const AliMUONAttPainter& attributes) const;
+ virtual Bool_t IsIncluded() const;
+
private:
Int_t fBusPatchId; ///< our identifier
/// ctor
}
+//_____________________________________________________________________________
+AliMUONChamberPainter::AliMUONChamberPainter(TRootIOCtor* ioCtor)
+: AliMUONVPainter(ioCtor),
+fChamberId(-1)
+{
+ /// ctor
+}
+
//_____________________________________________________________________________
AliMUONChamberPainter::AliMUONChamberPainter(const AliMUONAttPainter& att,
Int_t chamberId)
return AliMUONPainterHelper::Instance()->FormatValue(data.DimensionName(dataIndex).Data(),value);
}
+//_____________________________________________________________________________
+Bool_t
+AliMUONChamberPainter::IsIncluded() const
+{
+ /// whether this chamber is included in the readout or not
+ return ( InteractiveReadOutConfig()->Chamber(fChamberId) > 0 );
+}
+
//_____________________________________________________________________________
void
AliMUONChamberPainter::PaintArea(const AliMUONVTrackerData& data, Int_t dataIndex,
{
public:
AliMUONChamberPainter();
+ AliMUONChamberPainter(TRootIOCtor* ioCtor);
AliMUONChamberPainter(const AliMUONAttPainter& att, Int_t chamberId);
AliMUONChamberPainter(const AliMUONChamberPainter& rhs);
AliMUONChamberPainter& operator=(const AliMUONChamberPainter& rhs);
AliMUONAttPainter Validate(const AliMUONAttPainter& attributes) const;
+ Bool_t IsIncluded() const;
+
private:
Int_t fChamberId; ///< our identifier (0..n)
/// default ctor
}
+//_____________________________________________________________________________
+AliMUONDEPainter::AliMUONDEPainter(TRootIOCtor* ioCtor)
+: AliMUONVPainter(ioCtor),
+fDetElemId(-1)
+{
+ /// default streaming ctor
+}
+
//_____________________________________________________________________________
AliMUONDEPainter::AliMUONDEPainter(const AliMUONAttPainter& att, Int_t detElemId)
: AliMUONVPainter("DE"),
}
}
}
-
+
+//_____________________________________________________________________________
+Bool_t
+AliMUONDEPainter::IsIncluded() const
+{
+ /// whether this detection element is included in the readout or not
+ return ( InteractiveReadOutConfig()->DetectionElement(fDetElemId) > 0 );
+}
+
//_____________________________________________________________________________
void
AliMUONDEPainter::PaintArea(const AliMUONVTrackerData& data, Int_t dataIndex,
{
public:
AliMUONDEPainter();
+ AliMUONDEPainter(TRootIOCtor*);
AliMUONDEPainter(const AliMUONAttPainter& att, Int_t detElemId);
AliMUONDEPainter(const AliMUONDEPainter& rhs);
AliMUONDEPainter& operator=(const AliMUONDEPainter& rhs);
virtual void FillManuList(TObjArray& manuList) const;
+ virtual Bool_t IsIncluded() const;
+
private:
Int_t fDetElemId; ///< our id
if ( !loCircuit ) continue; // empty slot
- AliMpLocalBoard* localBoard = AliMpDDLStore::Instance()->GetLocalBoard(loCircuit, false);
+ AliMpLocalBoard* localBoard = AliMpDDLStore::Instance()->GetLocalBoard(loCircuit, kTRUE);
// skip copy cards
if( !localBoard->IsNotified())
/// ctor
}
+//_____________________________________________________________________________
+AliMUONManuPadPainter::AliMUONManuPadPainter(TRootIOCtor* ioCtor)
+: AliMUONVPainter(ioCtor),
+fDetElemId(-1),
+fManuId(-1),
+fLineColorBck(-1),
+fLineWidthBck(-1),
+fFillColorBck(-1),
+fFillStyleBck(-1)
+{
+ /// ctor
+}
+
//_____________________________________________________________________________
AliMUONManuPadPainter::AliMUONManuPadPainter(const AliMUONVPainter& mother,
Int_t detElemId,
return name;
}
+//_____________________________________________________________________________
+Bool_t
+AliMUONManuPadPainter::IsIncluded() const
+{
+ /// whether this manu is included in the readout or not
+ return ( InteractiveReadOutConfig()->Manu(fDetElemId,fManuId) > 0 );
+}
+
//_____________________________________________________________________________
TString
AliMUONManuPadPainter::Describe(const AliMUONVTrackerData& data, Int_t dataIndex,
class AliMUONManuPadPainter : public AliMUONVPainter
{
public:
+ AliMUONManuPadPainter(TRootIOCtor* ioCtor);
AliMUONManuPadPainter();
AliMUONManuPadPainter(const AliMUONVPainter& mother,
Int_t detElemId,
virtual void DrawHistogramClone(Double_t* values=0x0) const;
+ virtual Bool_t IsIncluded() const;
+
private:
void BackupStyle();
ClassImp(AliMUONManuPainter)
///\endcond
+//_____________________________________________________________________________
+AliMUONManuPainter::AliMUONManuPainter(TRootIOCtor* ioCtor)
+: AliMUONVPainter(ioCtor),
+fDetElemId(-1),
+fManuId(-1)
+{
+ /// ctor
+}
+
//_____________________________________________________________________________
AliMUONManuPainter::AliMUONManuPainter()
: AliMUONVPainter(),
manuList.Add(new AliMpManuUID(fDetElemId,fManuId));
}
+//_____________________________________________________________________________
+Bool_t
+AliMUONManuPainter::IsIncluded() const
+{
+ /// whether this manu is included in the readout or not
+ return ( InteractiveReadOutConfig()->Manu(fDetElemId,fManuId) > 0 );
+}
+
//_____________________________________________________________________________
void
AliMUONManuPainter::PaintArea(const AliMUONVTrackerData& data, Int_t dataIndex,
{
public:
+ AliMUONManuPainter(TRootIOCtor*);
AliMUONManuPainter();
AliMUONManuPainter(const AliMUONAttPainter& att,
Int_t detElemId,
virtual void FillManuList(TObjArray& manuList) const;
+ virtual Bool_t IsIncluded() const;
+
private:
Int_t fDetElemId; ///< our detection element id
Int_t fManuId; ///< our manu id
//______________________________________________________________________________
AliMUONMchViewApplication::AliMUONMchViewApplication(const char* name,
int* argc, char** argv,
- Float_t wfraction,
- Float_t hfraction)
+ UInt_t w, UInt_t h,
+ UInt_t ox, UInt_t oy)
: TRint(name,argc,argv),
fMainFrame(0x0),
fPainterMasterFrame(0x0)
{
/// ctor
- /// wfraction,hfraction are the fractions of display width and height
- /// we want to draw on
-
- UInt_t dw = gClient->GetDisplayWidth();
- UInt_t dh = gClient->GetDisplayHeight();
-
- UInt_t w = (UInt_t)(wfraction*dw);
- UInt_t h = (UInt_t)(hfraction*dh);
+ /// (w,h) is the size in pixel (if 0,0 it will be computed as 70%,90% of display size)
+ /// (ox,oy) is the offset from the top-left of the display
+
+ if (!w | !h)
+ {
+ w = (UInt_t)(gClient->GetDisplayWidth()*0.7);
+ h = (UInt_t)(gClient->GetDisplayHeight()*0.9);
+ }
fMainFrame = new TGMainFrame(gClient->GetRoot(),w,h);
fMainFrame->MapWindow();
fMainFrame->Connect("CloseWindow()","AliMUONMchViewApplication",this,"Terminate()");
-
- UInt_t x = dw/2 - w/2;
- UInt_t y = 0;
-
- fMainFrame->MoveResize(x, y, w, h);
- fMainFrame->SetWMPosition(x, y);
-
+
+ fMainFrame->MoveResize(ox,oy, w, h);
+ fMainFrame->SetWMPosition(ox, oy);
fMainFrame->SetWMSizeHints(w,h,w,h,0,0);
cout << "***************************************************" << endl;
TGTransientFrame* t = new TGTransientFrame(gClient->GetRoot(),gClient->GetRoot(),width,height);
TGTextView* rn = new TGTextView(t);
+
+ rn->AddLine("0.9%");
+ rn->AddLine("");
+ rn->AddLine("New features");
+ rn->AddLine("");
+ rn->AddLine("- Can now read and display HV values from OCDB");
+ rn->AddLine("- New program option --geometry to force geometry of the window");
+ rn->AddLine("- Added possibility, in painters' context menu, to include or exclude part of the detector");
+ rn->AddLine(" (which will be used later on to communicate with LC2 which parts should be read out or not)");
+ rn->AddLine("");
+ rn->AddLine("Improvement");
+ rn->AddLine("");
+ rn->AddLine("- When displaying Gains, the quality information is now decoded");
+ rn->AddLine("");
rn->AddLine("0.94");
rn->AddLine("");
{
public:
AliMUONMchViewApplication(const char* name, int* argc, char** argv,
- Float_t wfraction, Float_t hfraction);
+ UInt_t w=0, UInt_t h=0, UInt_t ox=0, UInt_t oy=0);
virtual ~AliMUONMchViewApplication();
void HandleMenu(Int_t i);
/// Return the version number of the mchview application
- static const char* Version() { return "0.94"; }
+ static const char* Version() { return "0.95"; }
/// Return the SVN revision and version number of the mchview application
static const char* FullVersion() { return Form("mchview Version %s ($Id$)",Version()); }
ClassImp(AliMUONPCBPainter)
/// \endcond
+//_____________________________________________________________________________
+AliMUONPCBPainter::AliMUONPCBPainter(TRootIOCtor* ioCtor)
+: AliMUONVPainter(ioCtor),
+fDetElemId(-1),
+fPCBIndex(-1)
+{
+ /// root streaming ctor
+}
+
//_____________________________________________________________________________
AliMUONPCBPainter::AliMUONPCBPainter()
: AliMUONVPainter(),
return AliMUONPainterHelper::Instance()->FormatValue(data.DimensionName(dataIndex).Data(),value);
}
+//_____________________________________________________________________________
+Bool_t
+AliMUONPCBPainter::IsIncluded() const
+{
+ /// Whether this PCB is included in the read out or not
+ return ( InteractiveReadOutConfig()->PCB(fDetElemId,fPCBIndex) > 0 );
+}
+
//_____________________________________________________________________________
void
AliMUONPCBPainter::PaintArea(const AliMUONVTrackerData& data, Int_t dataIndex,
class AliMUONPCBPainter : public AliMUONVPainter
{
public:
+ AliMUONPCBPainter(TRootIOCtor*);
AliMUONPCBPainter();
AliMUONPCBPainter(const AliMUONAttPainter& att,
Int_t detElemId,
void PaintArea(const AliMUONVTrackerData& data, Int_t dataIndex,
Double_t min, Double_t max);
+ Bool_t IsIncluded() const;
+
private:
Int_t fDetElemId; ///< Detection element this pcb is in
Int_t fPCBIndex; ///< Index of this PCB within the detection element
fOCDBTypes->AddEntry("Pedestals",0);
fOCDBTypes->AddEntry("Gains",1);
fOCDBTypes->AddEntry("Capacitances",2);
+ fOCDBTypes->AddEntry("HV",3);
fOCDBTypes->Select(0);
fOCDBTypes->Resize(100,20);
// create "opposite" attributes
AliMUONAttPainter a1(a);
AliMUONAttPainter a2(a);
-
- if ( a.IsCathodeDefined() )
- {
- a2.SetCathode(!a.IsCathode0(),!a.IsCathode1());
- }
-
- if ( a.IsPlaneDefined() )
- {
- a2.SetPlane(!a.IsBendingPlane(),!a.IsNonBendingPlane());
- }
+
+ a2.Invert();
a1.SetCathodeAndPlaneDisabled(kTRUE);
a2.SetCathodeAndPlaneDisabled(kTRUE);
(AliMUONPainterInterfaceHelper::FindButtonByUserData(*fDataSourceNames,
fCurrentData));
- AliMUONPainterInterfaceHelper::Select(*fDataSourceNames,button->GetTitle());
+ if ( button )
+ {
+ AliMUONPainterInterfaceHelper::Select(*fDataSourceNames,button->GetTitle());
- RestoreDimensionButtons(button->GetTitle(),kFALSE);
+ RestoreDimensionButtons(button->GetTitle(),kFALSE);
+ }
fDataSourceNames->Show();
}
#include "AliMUONPainterRegistry.h"
+#include "AliMpManuIterator.h"
+#include "AliMUON2DMap.h"
+#include "AliMUONCalibParamND.h"
#include "AliMUONPainterMatrix.h"
-#include "AliMUONVTrackerData.h"
+#include "AliMUONTrackerData.h"
#include "AliMUONVTrackerDataMaker.h"
#include "AliLog.h"
#include <TGMenu.h>
fHistoryMenu(0x0),
fMenuBar(0x0),
fHistoryCounter(0),
-fZombies(new TObjArray)
+fZombies(new TObjArray),
+fInteractiveReadOutConfig(0x0)
{
/// ctor
fPainterMatrices->SetOwner(kTRUE);
/// dtor
delete fPainterMatrices;
delete fDataMakers;
+ delete fInteractiveReadOutConfig;
+}
+
+//_____________________________________________________________________________
+void
+AliMUONPainterRegistry::CreateInteractiveReadOutConfig() const
+{
+ fInteractiveReadOutConfig = new AliMUONTrackerData("IROC","IROC",1);
+ fInteractiveReadOutConfig->SetDimensionName(0,"Switch");
+ /// FIXME: should use a version of TrackerData w/ no storage for channels
+ /// (i.e. starting at the manu level, or even bus patch level ?)
+ AliMpManuIterator it;
+ Int_t detElemId;
+ Int_t manuId;
+ AliMUON2DMap store(true);
+
+ while ( it.Next(detElemId,manuId) )
+ {
+ AliMUONVCalibParam* param = new AliMUONCalibParamND(1,64,detElemId,manuId,1);
+ store.Add(param);
+ }
+ fInteractiveReadOutConfig->Add(store);
}
//_____________________________________________________________________________
return fgInstance;
}
+//_____________________________________________________________________________
+AliMUONVTrackerData*
+AliMUONPainterRegistry::InteractiveReadOutConfig() const
+{
+ /// Return an object that contains the parts of the detector selected
+ /// (using the mouse) to be part of the readout.
+
+ if (!fInteractiveReadOutConfig) CreateInteractiveReadOutConfig();
+ return fInteractiveReadOutConfig;
+}
+
//_____________________________________________________________________________
AliMUONPainterMatrix*
AliMUONPainterRegistry::PainterMatrix(Int_t i) const
AliMUONVTrackerData* DataSource(Int_t i) const;
AliMUONVTrackerData* DataSource(const char* name) const;
+
+ AliMUONVTrackerData* InteractiveReadOutConfig() const;
void DataSourceWasRegistered(AliMUONVTrackerData* data); // *SIGNAL*
/// Not implemented
AliMUONPainterRegistry& operator=(const AliMUONPainterRegistry&);
+ void CreateInteractiveReadOutConfig() const;
+
private:
static AliMUONPainterRegistry* fgInstance; ///< unique instance
TObjArray* fPainterMatrices; ///< painter matrices
TGMenuBar* fMenuBar; ///< Menu bar where to put the history menu
Int_t fHistoryCounter; ///< index to get back history menu items
TObjArray* fZombies; ///< data readers to be deleted
+ mutable AliMUONVTrackerData* fInteractiveReadOutConfig; ///< clickable readout configuration
- ClassDef(AliMUONPainterRegistry,3) // Registry for AliMUONVPainter related stuff
+ ClassDef(AliMUONPainterRegistry,4) // Registry for AliMUONVPainter related stuff
};
#endif
#include "AliLog.h"
#include <TString.h>
#include <TSystem.h>
+#include "AliMUONTrackerOCDBDataMaker.h"
///\class AliMUONTrackerACFDataMaker
///
TString stype(type);
stype.ToUpper();
- Bool_t isSingleEvent(kTRUE);
TString filename(gSystem->ExpandPathName(acfPath));
if ( stype == "PEDESTALS" )
{
- fData = new AliMUONTrackerData(Form("PED",number),"Pedestals",2,isSingleEvent);
- fData->SetDimensionName(0,"Mean");
- fData->SetDimensionName(1,"Sigma");
+ fData = AliMUONTrackerOCDBDataMaker::CreateDataPedestals(number);
store = new AliMUON2DMap(kTRUE);
AliMUONTrackerIO::ReadPedestals(filename.Data(),*store);
}
else if ( stype == "GAINS" )
{
- fData = new AliMUONTrackerData(Form("GAIN%d",number),"Gains",5,isSingleEvent);
- fData->SetDimensionName(0,"a1");
- fData->SetDimensionName(1,"a2");
- fData->SetDimensionName(2,"thres");
- fData->SetDimensionName(3,"qual");
- fData->SetDimensionName(4,"sat");
- store = new AliMUON2DMap(kTRUE);
+ fData = AliMUONTrackerOCDBDataMaker::CreateDataGains(number);
+ AliMUONVStore* gains = new AliMUON2DMap(kTRUE);
TString comment;
- AliMUONTrackerIO::ReadGains(filename.Data(),*store,comment);
+ AliMUONTrackerIO::ReadGains(filename.Data(),*gains,comment);
+ store = AliMUONTrackerOCDBDataMaker::SplitQuality(*gains);
+ delete gains;
}
else if ( stype == "CAPACITANCES" )
{
- fData = new AliMUONTrackerData(Form("CAPA%d",number),"Capacitances",2,isSingleEvent);
- fData->SetDimensionName(0,"Capa");
- fData->SetDimensionName(1,"Injection gain");
+ fData = AliMUONTrackerOCDBDataMaker::CreateDataCapacitances(number);
store = new AliMUON1DMap(20000);
AliMUONTrackerIO::ReadCapacitances(filename.Data(),*store);
}
//_____________________________________________________________________________
Bool_t
AliMUONTrackerData::Add(const AliMUONVStore& store)
+{
+ /// Add the given external store to our internal store
+ return InternalAdd(store,kFALSE);
+}
+
+//_____________________________________________________________________________
+Bool_t
+AliMUONTrackerData::Replace(const AliMUONVStore& store)
+{
+ /// Replace our values by values from the given external store
+ Bool_t rv = InternalAdd(store,kTRUE);
+ AliMUONVTrackerData::Replace(store);
+ return rv;
+}
+
+//_____________________________________________________________________________
+Bool_t
+AliMUONTrackerData::InternalAdd(const AliMUONVStore& store, Bool_t replace)
{
/// Add the given external store to our internal store
AliCodeTimerAuto(GetName());
- if ( IsSingleEvent() && fNevents == 1 )
+ if ( !replace)
{
- AliError(Form("%s is supposed to be single event only",GetName()));
- return kFALSE;
+ if ( IsSingleEvent() && fNevents == 1 )
+ {
+ AliError(Form("%s is supposed to be single event only",GetName()));
+ return kFALSE;
+ }
+ ++fNevents;
+ NumberOfEventsChanged();
}
- ++fNevents;
-
- NumberOfEventsChanged();
-
if (!fChannelValues)
{
Int_t numberOfBusPatches(0);
for ( Int_t k = 0; k < nk; ++k )
{
- channel->SetValueAsDoubleFast(i,ix+k,channel->ValueAsDoubleFast(i,ix+k)+value[k]);
-
- manu->SetValueAsDoubleFast(0,ix+k,manu->ValueAsDoubleFast(0,ix+k)+value[k]);
+ Double_t e = replace ? channel->ValueAsDoubleFast(i,ix+k) : 0.0;
+
+ channel->SetValueAsDoubleFast(i,ix+k,channel->ValueAsDoubleFast(i,ix+k)-e+value[k]);
+
+ manu->SetValueAsDoubleFast(0,ix+k,manu->ValueAsDoubleFast(0,ix+k)-e+value[k]);
+
+ busPatch->SetValueAsDoubleFast(0,ix+k,busPatch->ValueAsDoubleFast(0,ix+k)-e+value[k]);
+
+ de->SetValueAsDoubleFast(0,ix+k,de->ValueAsDoubleFast(0,ix+k)-e+value[k]);
+
+ chamber->SetValueAsDoubleFast(0,ix+k,chamber->ValueAsDoubleFast(0,ix+k)-e+value[k]);
- busPatch->SetValueAsDoubleFast(0,ix+k,busPatch->ValueAsDoubleFast(0,ix+k)+value[k]);
-
- de->SetValueAsDoubleFast(0,ix+k,de->ValueAsDoubleFast(0,ix+k)+value[k]);
-
- chamber->SetValueAsDoubleFast(0,ix+k,chamber->ValueAsDoubleFast(0,ix+k)+value[k]);
-
if ( pcb )
{
- pcb->SetValueAsDoubleFast(0,ix+k,pcb->ValueAsDoubleFast(0,ix+k)+value[k]);
+ pcb->SetValueAsDoubleFast(0,ix+k,pcb->ValueAsDoubleFast(0,ix+k)-e+value[k]);
}
}
}
- if ( validChannel )
+ if ( validChannel && !replace )
{
channel->SetValueAsDoubleFast(i,IndexOfOccupancyDimension(),
channel->ValueAsDoubleFast(i,IndexOfOccupancyDimension())+1.0);
AliMUONVCalibParam* param = PCBParam(detElemId,pcbIndex);
- return param ? Value(*param,pcbIndex,dim) : 0.0;
+ return param ? Value(*param,0,dim) : 0.0;
}
//_____________________________________________________________________________
virtual ~AliMUONTrackerData();
virtual Bool_t Add(const AliMUONVStore& channelValues);
-
+
+ virtual Bool_t Replace(const AliMUONVStore& channelValues);
+
virtual Double_t BusPatch(Int_t busPatchId, Int_t dim=0) const;
virtual Double_t Chamber(Int_t chamberId, Int_t dim=0) const;
private:
+ Bool_t InternalAdd(const AliMUONVStore& store, Bool_t replace);
+
Bool_t fIsSingleEvent; ///< whether we can deal with more than one event
AliMUONVStore* fChannelValues; ///< the channel store
AliMUONVStore* fManuValues; ///< the manu store
#include "AliMUONTrackerOCDBDataMaker.h"
-#include "AliMUONTrackerData.h"
#include "AliCDBManager.h"
#include "AliCDBStorage.h"
+#include "AliDCSValue.h"
+#include "AliLog.h"
+#include "AliMUON2DMap.h"
+#include "AliMUONCalibParamND.h"
#include "AliMUONCalibrationData.h"
+#include "AliMUONTrackerData.h"
#include "AliMUONVStore.h"
-#include "AliLog.h"
+#include "AliMpConstants.h"
+#include "AliMpDDLStore.h"
+#include "AliMpDetElement.h"
+#include "AliMpHVNamer.h"
+#include <TClass.h>
+#include <TMap.h>
+#include <TObjArray.h>
+#include <TObjString.h>
#include <TString.h>
///\class AliMUONTrackerOCDBDataMaker
if ( stype == "PEDESTALS" )
{
- fData = new AliMUONTrackerData(Form("PED%d",runNumber),"Pedestals",2,isSingleEvent);
- fData->SetDimensionName(0,"Mean");
- fData->SetDimensionName(1,"Sigma");
+ fData = CreateDataPedestals(runNumber);
store = AliMUONCalibrationData::CreatePedestals(runNumber);
}
else if ( stype == "GAINS" )
{
- fData = new AliMUONTrackerData(Form("GAIN%d",runNumber),"Gains",5,isSingleEvent);
- fData->SetDimensionName(0,"a1");
- fData->SetDimensionName(1,"a2");
- fData->SetDimensionName(2,"thres");
- fData->SetDimensionName(3,"qual");
- fData->SetDimensionName(4,"sat");
- store = AliMUONCalibrationData::CreateGains(runNumber);
+ fData = CreateDataGains(runNumber);
+ AliMUONVStore* gains = AliMUONCalibrationData::CreateGains(runNumber);
+ store = SplitQuality(*gains);
+ delete gains;
}
else if ( stype == "CAPACITANCES" )
{
- fData = new AliMUONTrackerData(Form("CAPA%d",runNumber),"Capacitances",2,isSingleEvent);
- fData->SetDimensionName(0,"Capa");
- fData->SetDimensionName(1,"Injection gain");
+ fData = CreateDataCapacitances(runNumber);
store = AliMUONCalibrationData::CreateCapacitances(runNumber);
}
+ else if ( stype == "HV" )
+ {
+ fData = new AliMUONTrackerData(Form("HV%d",runNumber),"High Voltages",1,!isSingleEvent);
+ fData->SetDimensionName(0,"HV");
+ TMap* m = AliMUONCalibrationData::CreateHV(runNumber);
+ store = CreateHVStore(*m);
+ delete m;
+ }
AliCDBManager::Instance()->SetDefaultStorage(storage);
}
fData->Add(*store);
+
+ delete store;
}
//_____________________________________________________________________________
delete fData;
}
+//_____________________________________________________________________________
+AliMUONVTrackerData*
+AliMUONTrackerOCDBDataMaker::CreateDataCapacitances(Int_t runNumber)
+{
+ /// Create data to hold capa values
+
+ AliMUONVTrackerData* data = new AliMUONTrackerData(Form("CAPA%d",runNumber),"Capacitances",2,kTRUE);
+ data->SetDimensionName(0,"Capa");
+ data->SetDimensionName(1,"Injection gain");
+ return data;
+}
+
+//_____________________________________________________________________________
+AliMUONVTrackerData*
+AliMUONTrackerOCDBDataMaker::CreateDataGains(Int_t runNumber)
+{
+ /// Create data to hold gains values
+
+ AliMUONVTrackerData* data = new AliMUONTrackerData(Form("GAIN%d",runNumber),"Gains",6,kTRUE);
+ data->SetDimensionName(0,"a1");
+ data->SetDimensionName(1,"a2");
+ data->SetDimensionName(2,"thres");
+ data->SetDimensionName(3,"qual1");
+ data->SetDimensionName(4,"qual2");
+ data->SetDimensionName(5,"sat");
+ return data;
+}
+
+//_____________________________________________________________________________
+AliMUONVTrackerData*
+AliMUONTrackerOCDBDataMaker::CreateDataPedestals(Int_t runNumber)
+{
+ /// Create data to hold pedestal values
+
+ AliMUONVTrackerData* data = new AliMUONTrackerData(Form("PED%d",runNumber),"Pedestals",2,kTRUE);
+ data->SetDimensionName(0,"Mean");
+ data->SetDimensionName(1,"Sigma");
+ return data;
+}
+
+//_____________________________________________________________________________
+AliMUONVStore*
+AliMUONTrackerOCDBDataMaker::CreateHVStore(TMap& m)
+{
+ /// Create a store from hv values
+
+ AliMUONVStore* store = new AliMUON2DMap(kTRUE);
+
+ TIter next(&m);
+ TObjString* s;
+ AliMpHVNamer hvNamer;
+
+ while ( ( s = static_cast<TObjString*>(next()) ) )
+ {
+ TString name(s->String());
+
+ Int_t detElemId = hvNamer.DetElemIdFromDCSAlias(name.Data());
+
+ Int_t nindex = 1;
+ Int_t hvIndex = hvNamer.HVIndexFromDCSAlias(name.Data());
+
+ if ( hvIndex > 0 && detElemId >= 500 )
+ {
+ AliFatalClass("FIXME"); // there's now switch aliases which should be taken into account
+ }
+
+ if ( hvIndex == -2 ) // we should consider switch alias there...
+ {
+ nindex = hvNamer.NumberOfPCBs(detElemId);
+ hvIndex = 0;
+ }
+
+ AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
+
+ for ( int i = 0 ; i < nindex; ++i )
+ {
+ Int_t index = hvIndex + i ;
+
+ const AliMpArrayI* manus = de->ManusForHV(index);
+
+ TPair* p = static_cast<TPair*>(m.FindObject(name.Data()));
+ TObjArray* a = static_cast<TObjArray*>(p->Value());
+ TIter n2(a);
+ AliDCSValue* v;
+ Float_t hvValue(0);
+ Int_t n(0);
+ while ( ( v = static_cast<AliDCSValue*>(n2()) ) )
+ {
+ hvValue += v->GetFloat();
+ ++n;
+ }
+ if ( n ) hvValue /= n;
+
+ Int_t N(AliMpConstants::ManuNofChannels());
+
+ for ( Int_t k = 0 ; k < manus->GetSize(); ++k )
+ {
+ Int_t manuId = manus->GetValue(k);
+ AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(store->FindObject(detElemId,manuId));
+ if ( ! param )
+ {
+ param = new AliMUONCalibParamND(1,N,detElemId,manuId,0);
+ store->Add(param);
+ }
+ for ( Int_t j = 0 ; j < N; ++j )
+ {
+ param->SetValueAsDouble(j,0,hvValue);
+ }
+ }
+ }
+ }
+
+ return store;
+
+}
+
//_____________________________________________________________________________
Long64_t
AliMUONTrackerOCDBDataMaker::Merge(TCollection*)
return 0;
}
+//_____________________________________________________________________________
+AliMUONVStore*
+AliMUONTrackerOCDBDataMaker::SplitQuality(const AliMUONVStore& gains)
+{
+ /// Create a new store, identical to source gain store, except that qual
+ /// dimension is "decompacted" in two separated values
+
+ AliMUONVStore* store = gains.Create();
+
+ TIter next(gains.CreateIterator());
+ AliMUONVCalibParam* param;
+
+ while ( ( param = static_cast<AliMUONVCalibParam*>(next()) ) )
+ {
+ AliMUONVCalibParam* nd = new AliMUONCalibParamND(param->Dimension()+1,
+ param->Size(),
+ param->ID0(),
+ param->ID1());
+ for ( Int_t i = 0; i < param->Size(); ++i )
+ {
+ for ( Int_t k = 0; k < param->Dimension(); ++k )
+ {
+ if ( k == 3 ) continue;
+ Int_t m = ( k < 3 ? k : k+1 ) ;
+ nd->SetValueAsDouble(i,m,param->ValueAsFloat(i,k));
+ }
+ Int_t qual = param->ValueAsInt(i,3);
+ Int_t q1 = ( qual & 0xF );
+ Int_t q2 = ( qual & 0xF0 );
+ nd->SetValueAsInt(i,3,q1);
+ nd->SetValueAsInt(i,4,q2);
+ }
+ store->Add(nd);
+ }
+ return store;
+}
# include "TString.h"
#endif
+class TMap;
+class AliMUONVStore;
+
class AliMUONTrackerOCDBDataMaker : public AliMUONVTrackerDataMaker
{
public:
Int_t NumberOfEvents() const { return 1; }
virtual Long64_t Merge(TCollection* li);
+
+ static AliMUONVStore* CreateHVStore(TMap& hvMap);
+ static AliMUONVStore* SplitQuality(const AliMUONVStore& gains);
+
+ static AliMUONVTrackerData* CreateDataPedestals(Int_t runNumber);
+ static AliMUONVTrackerData* CreateDataGains(Int_t runNumber);
+ static AliMUONVTrackerData* CreateDataCapacitances(Int_t runNumber);
private:
/// Not implemented
/// Not implemented
AliMUONTrackerOCDBDataMaker& operator=(const AliMUONTrackerOCDBDataMaker& rhs);
+
private:
Bool_t fIsValid; ///< whether we have valid data
AliMUONVTrackerData* fData; ///< our data
#include "AliCodeTimer.h"
#include "AliLog.h"
+#include "AliMUON2DMap.h"
+#include "AliMUONCalibParamND.h"
+#include "AliMUONPainterRegistry.h"
+#include "AliMpManuUID.h"
#include "AliMUONObjectPair.h"
#include "AliMUONPainterContour.h"
#include "AliMUONPainterGroup.h"
ClassImp(AliMUONVPainter)
///\endcond
+//_____________________________________________________________________________
+AliMUONVPainter::AliMUONVPainter(TRootIOCtor*) : TObject(),
+TQObject(),
+fHistogram(0x0),
+fName(""),
+fPathName(""),
+fType(""),
+fMother(0x0),
+fGroup(0x0),
+fContour(0x0),
+fPainterGroups(0x0),
+fChildren(0x0),
+fResponderGroup(0x0),
+fPlotterGroup(0x0),
+fBorderFactor(1.1),
+fPad(0x0),
+fAttributes(),
+fLineColor(1),
+fLineWidth(1),
+fIsValid(kTRUE)
+{
+ /// streamer ctor
+}
+
//_____________________________________________________________________________
AliMUONVPainter::AliMUONVPainter(const char* type)
: TObject(),
{
PaintOutline();
}
+
+ if ( IsExcluded() )
+ {
+ fContour->PaintArea(2);
+ fContour->PaintOutline(1,1);
+ }
}
//_____________________________________________________________________________
{
/// Default implementation (must be overriden)
AliError(Form("%s : implement me",GetName()));
+ return;
}
//_____________________________________________________________________________
// l->Clear();
l->Delete();
- if ( group )
+ TClassMenuItem* n(0x0);
+
+ l->Add(new TClassMenuItem(TClassMenuItem::kPopupUserFunction,p->IsA(),
+ "Include","Include",p,"",-1,kTRUE));
+ l->Add(new TClassMenuItem(TClassMenuItem::kPopupUserFunction,p->IsA(),
+ "Exclude","Exclude",p,"",-1,kTRUE));
+
+ if ( group )
{
Int_t dim = group->Data()->InternalToExternal(group->DataIndex());
if ( dim < group->Data()->ExternalDimension() )
if ( data && data->IsHistogrammed(dim) )
{
// Add histo drawing to the popup menu
- TClassMenuItem* n = new TClassMenuItem(TClassMenuItem::kPopupUserFunction,p->IsA(),
+ n = new TClassMenuItem(TClassMenuItem::kPopupUserFunction,p->IsA(),
"Draw histogram","DrawHistogram0",p,"",-1,kTRUE);
l->Add(n);
}
- for ( Int_t i = 0; i < data->ExternalDimension()*2; ++i )
+ Int_t nd = data->IsSingleEvent() ? data->ExternalDimension() : data->ExternalDimension()*2;
+
+ for ( Int_t i = 0; i < nd; ++i )
{
- TClassMenuItem* n = new TClassMenuItem(TClassMenuItem::kPopupUserFunction,p->IsA(),
- Form("Draw %s clone",data->DimensionName(i).Data()),
- Form("DrawInternalHistogramClone%d",i),p,"",-1,kTRUE);
+ n = new TClassMenuItem(TClassMenuItem::kPopupUserFunction,p->IsA(),
+ Form("Draw %s clone",data->DimensionName(i).Data()),
+ Form("DrawInternalHistogramClone%d",i),p,"",-1,kTRUE);
l->Add(n);
}
}
SetLine(group->Depth(),group->GetLineColor(),group->GetLineWidth());
}
+
+}
+
+//_____________________________________________________________________________
+void
+AliMUONVPainter::Include()
+{
+ /// Include this painter
+ AliInfo(GetName());
+
+ /// Update the global interactive read out configuration
+ WriteIROC(1);
+}
+
+//_____________________________________________________________________________
+void
+AliMUONVPainter::GetIROCManuList(TObjArray& manuList)
+{
+ /// Get the list of manus spanned by this painter AND by its dual
+
+ FillManuList(manuList);
+
+ // get our dual
+ AliMUONAttPainter att(Attributes());
+
+ att.Invert();
+
+ att.SetCathodeAndPlaneDisabled(kTRUE);
+
+ AliMUONVPainter* p = AliMUONVPainter::CreatePainter(ClassName(),att,ID0(),ID1());
+
+ if (p)
+ {
+ p->FillManuList(manuList);
+ }
+
+ delete p;
+}
+
+//_____________________________________________________________________________
+void
+AliMUONVPainter::WriteIROC(Double_t value)
+{
+ /// Update the interactive readout configuration
+
+ TObjArray manuList;
+ GetIROCManuList(manuList);
+
+ AliMpManuUID* muid;
+ TIter nextm(&manuList);
+ AliMUON2DMap store(true);
+
+ while ((muid=static_cast<AliMpManuUID*>(nextm())))
+ {
+ AliMUONVCalibParam* param = new AliMUONCalibParamND(1,64,
+ muid->DetElemId(),
+ muid->ManuId(),value);
+ store.Add(param);
+ }
+
+ InteractiveReadOutConfig()->Replace(store);
+}
+
+//_____________________________________________________________________________
+void
+AliMUONVPainter::Exclude()
+{
+ /// Exclude this painter
+ AliInfo(GetName());
+
+ /// Update the global interactive read out configuration
+ WriteIROC(0.0);
+}
+
+//_____________________________________________________________________________
+AliMUONVTrackerData*
+AliMUONVPainter::InteractiveReadOutConfig() const
+{
+ /// get the interactive readout config object
+ return AliMUONPainterRegistry::Instance()->InteractiveReadOutConfig();
}
//_____________________________________________________________________________
{
public:
+ AliMUONVPainter(TRootIOCtor*);
AliMUONVPainter(const char* type="");
AliMUONVPainter(const AliMUONVPainter& rhs);
AliMUONVPainter& operator=(const AliMUONVPainter& rhs);
/// SL
void DrawInternalHistogramClone9() { DrawInternalHistogramClone(9); }
+ /// Whether or not the part of the detector represented by this painter should be included in readout.
+ virtual Bool_t IsIncluded() const = 0;
+
+ /// Whether or not the part of the detector represented by this painter should be excluded from readout.
+ Bool_t IsExcluded() const { return ! IsIncluded(); }
+
+ virtual void Include();
+
+ virtual void Exclude();
+
protected:
virtual TCollection* Children() const;
mutable TH1* fHistogram; //!< histogram
+ AliMUONVTrackerData* InteractiveReadOutConfig() const;
+
private:
void FlatList(TList& list);
AliMUONVPainter* GetPainter(Int_t px, Int_t py, Double_t& x, Double_t& y) const;
+ void WriteIROC(Double_t value);
+
+ void GetIROCManuList(TObjArray& manuList);
+
private:
TString fName; ///< our (short) name
Print(wildcard,"summary");
}
+//_____________________________________________________________________________
+Bool_t
+AliMUONVTrackerData::Replace(const AliMUONVStore& store)
+{
+ Emit("Replace(const AliMUONVStore&)");
+}
/// Add values for one event from one full store
virtual Bool_t Add(const AliMUONVStore& store) = 0;
+ /// Replace values
+ virtual Bool_t Replace(const AliMUONVStore& store) = 0;
+
/// Get the value for a given buspatch and given dimension
virtual Double_t BusPatch(Int_t busPatchId, Int_t dim=0) const = 0;
#include "AliMUONMchViewApplication.h"
-#include "AliMUONPainterHelper.h"
+
#include "AliCDBManager.h"
#include "AliCodeTimer.h"
#include "AliLog.h"
-#include <TROOT.h>
-#include <TStyle.h>
+#include "AliMUONPainterHelper.h"
+#include <Riostream.h>
#include <TObjArray.h>
#include <TObjString.h>
-#include <Riostream.h>
+#include <TROOT.h>
+#include <TStyle.h>
//______________________________________________________________________________
Int_t Usage()
cout << "mchview " << endl;
cout << " --version : shows the current version of the program" << endl;
cout << " --use filename.root : reuse a previously saved (from this program) root file. Several --use can be used ;-)" << endl;
+ cout << " --geometry #x#+#+# : manually specify the geometry of the window, ala X11..., e.g. --geometry 1280x900+1600+0 will" << endl;
+ cout << " get a window of size 1280x900, located at (1600,0) from the top-left of the (multihead) display " << endl;
return -1;
}
Int_t nok(0);
TObjArray filesToOpen;
-
+ Bool_t isGeometryFixed(kFALSE);
+ Int_t gix, giy;
+ Int_t gox,goy;
+
for ( Int_t i = 0; i <= args.GetLast(); ++i )
{
TString a(static_cast<TObjString*>(args.At(i))->String());
++i;
nok += 2;
}
+ else if ( a == "--geometry" )
+ {
+ isGeometryFixed = kTRUE;
+ TString g(static_cast<TObjString*>(args.At(i+1))->String());
+ sscanf(g.Data(),"%dx%d+%d+%d",&gix,&giy,&gox,&goy);
+ nok += 2;
+ ++i;
+ }
+
else
{
return Usage();
return Usage();
}
- AliWarningGeneral("main","Remove default storage and run number from here...");
+ AliWarningGeneral("main","FIXME ? Remove default storage and run number from here...");
AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
AliCDBManager::Instance()->SetRun(0);
colors[n+1] = 1;
gStyle->SetPalette(n+2,colors);
delete[] colors;
+
+ UInt_t w(0);
+ UInt_t h(0);
+ UInt_t ox(0);
+ UInt_t oy(0);
+
+ if ( isGeometryFixed )
+ {
+ w = gix;
+ h = giy;
+ ox = gox;
+ oy = goy;
+ }
- AliMUONMchViewApplication* theApp = new AliMUONMchViewApplication("mchview", &argc, argv, 0.7, 0.9);
+ AliMUONMchViewApplication* theApp = new AliMUONMchViewApplication("mchview", &argc, argv, w,h,gox,goy);
AliCodeTimer::Instance()->Print();
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff