modifications made in AliAttrib and AliSignal to overcome a ROOT
feature which always sets the size of TArray objects to a default
of 16 when reading these objects back from a file.
The modified AliAttrib and AliSignal don't rely on a GetSize()
anymore, but determine the number of stored values from the
actual array contents.
13-sep-2006 NvE IceF2k updated for multiple waveforms per OM by making use of the
new AliAttrib::AddNamedSlot facility.
Also some calibration constants dropped from OM data words in IceF2k
and IceCal2Root, since these values are also stored as parameters in
the corresponding (de)calibration functions.
Also for TWR data the values stored in the histos are (baseline-amp),
so that all pulses appear as positive instead of negative and the
resulting histos are baseline corrected.
14-sep-2006 NvE IceCalibrate.cxx updated to correctly process multiple waveforms and hits per OM.
Also some calibration constants dropped from OM data words in IceCalibrate,
since these values are also stored as parameters in the corresponding
(de)calibration functions.
Int_t AliAttrib::GetNgains() const
{
// Provide the number of specified gains for this attribute.
+
+ if (!fGains) return 0;
+
Int_t n=0;
- if (fGains) n=fGains->GetSize();
+ for (Int_t i=1; i<=fGains->GetSize(); i++)
+ {
+ if (GetGainFlag(i)) n=i;
+ }
+
return n;
}
///////////////////////////////////////////////////////////////////////////
Int_t AliAttrib::GetNoffsets() const
{
// Provide the number of specified offsets for this attribute.
+
+ if (!fOffsets) return 0;
+
Int_t n=0;
- if (fOffsets) n=fOffsets->GetSize();
+ for (Int_t i=1; i<=fOffsets->GetSize(); i++)
+ {
+ if (GetOffsetFlag(i)) n=i;
+ }
+
return n;
}
///////////////////////////////////////////////////////////////////////////
Int_t AliAttrib::GetNcalflags() const
{
// Provide the number of specified calib. flags for this attribute.
+
+ if (!fCalflags) return 0;
+
Int_t n=0;
- if (fCalflags) n=fCalflags->GetSize();
+ for (Int_t i=1; i<=fCalflags->GetSize(); i++)
+ {
+ if (fCalflags->At(i-1)) n=i;
+ }
+
return n;
}
///////////////////////////////////////////////////////////////////////////
Int_t AliAttrib::GetNnames() const
{
// Provide the maximum number of specified names for this attribute.
+
+ if (!fNames) return 0;
+
Int_t n=0;
- if (fNames) n=fNames->GetSize();
+ for (Int_t i=1; i<=fNames->GetSize(); i++)
+ {
+ if (fNames->At(i-1)) n=i;
+ }
+
return n;
}
///////////////////////////////////////////////////////////////////////////
return flag;
}
///////////////////////////////////////////////////////////////////////////
+Int_t AliAttrib::GetCalWord(Int_t j) const
+{
+// Provide calib. word of the j-th (default j=1) attribute slot.
+// The word value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
+//
+// Note : The first attribute slot is at j=1.
+// In case j is invalid, 0 is returned.
+
+ if (j<1)
+ {
+ cout << " *AliAttrib::GetCalWord* Invalid argument j = " << j << endl;
+ return 0;
+ }
+
+ Int_t word=0;
+ if (fCalflags)
+ {
+ if (j>0 && j<=(fCalflags->GetSize())) word=fCalflags->At(j-1);
+ }
+ return word;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliAttrib::GetCalWord(TString name) const
+{
+// Provide calib. word of the name-specified attribute slot.
+// The word value stored is : 1000*edge + 100*dead + 10*gainflag + offsetflag.
+//
+// This procedure involves a slot-index search based on the specified name
+// at each invokation. This may become slow in case many slots have been
+// defined and/or when this procedure is invoked many times.
+// In such cases it is preferable to use indexed addressing in the user code
+// either directly or via a few invokations of GetSlotIndex().
+
+ Int_t j=GetSlotIndex(name);
+ Int_t word=0;
+ if (j>0) word=GetCalWord(j);
+ return word;
+}
+///////////////////////////////////////////////////////////////////////////
Float_t AliAttrib::GetGain(Int_t j) const
{
// Provide gain value of the j-th (default j=1) attribute slot.
return val;
}
///////////////////////////////////////////////////////////////////////////
+Int_t AliAttrib::GetNslots() const
+{
+// Provide the number of existing slots.
+
+ Int_t n=GetNcalflags();
+ Int_t nn=GetNnames();
+ Int_t ncalf=GetNcalfuncs();
+ Int_t ndecalf=GetNdecalfuncs();
+ if (n<nn) n=nn;
+ if (n<ncalf) n=ncalf;
+ if (n<ndecalf) n=ndecalf;
+
+ return n;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliAttrib::AddNamedSlot(TString s)
+{
+// Add a new slot with the specified name.
+// In case a slot with the specified name already exists, no action is taken.
+
+ if (GetSlotIndex(s)) return;
+
+ Int_t n=GetNslots();
+ SetSlotName(s,n+1);
+}
+///////////////////////////////////////////////////////////////////////////
void AliAttrib::SetSlotName(TString s,Int_t j)
{
// Set a user defined name for the j-th (default j=1) slot.
// Note : The first attribute slot is at j=1.
+// In case the value of the index j exceeds the maximum number of reserved
+// slots for the names, the number of reserved slots for the names
+// is increased automatically to the corresponding value.
if (j<1)
{
{
// Provide the number of specified calib. functions for this attribute.
+ if (!fCalfuncs) return 0;
+
Int_t n=0;
- if (fCalfuncs) n=fCalfuncs->GetSize();
+ for (Int_t i=1; i<=fCalfuncs->GetSize(); i++)
+ {
+ if (fCalfuncs->At(i-1)) n=i;
+ }
return n;
}
///////////////////////////////////////////////////////////////////////////
{
// Provide the number of specified de-calib. functions for this attribute.
+ if (!fDecalfuncs) return 0;
+
Int_t n=0;
- if (fDecalfuncs) n=fDecalfuncs->GetSize();
+ for (Int_t i=1; i<=fDecalfuncs->GetSize(); i++)
+ {
+ if (fDecalfuncs->At(i-1)) n=i;
+ }
return n;
}
///////////////////////////////////////////////////////////////////////////
Int_t GetGainFlag(TString name) const; // Provide gain flag of the name-specified attribute slot
Int_t GetOffsetFlag(Int_t j=1) const; // Provide offset flag of the j-th attribute slot
Int_t GetOffsetFlag(TString name) const; // Provide offset flag of the name-specified attribute slot
+ Int_t GetCalWord(Int_t j=1) const; // Provide calib. word of the j-th attribute slot
+ Int_t GetCalWord(TString name) const; // Provide calib word of the name-specified attribute slot
void ResetGain(Int_t j=1); // Reset j-th gain value and flag
void ResetGain(TString name); // Reset name-specified gain value and flag
void ResetOffset(Int_t j=1); // Reset j-th offset value and flag
virtual void List(TString name) const; // Printout of name-specified attribute data
virtual void Load(AliAttrib& a,Int_t j=0); // Load j-th slot or all attributes of the input AliAttrib
virtual void Load(AliAttrib& a,TString name);// Load name-specified slot attributes of the input AliAttrib
+ void AddNamedSlot(TString s); // Add a new slot with the specified name
+ virtual Int_t GetNslots() const; // Provide the number of exising slots
void SetSlotName(TString s,Int_t j=1); // Set user defined name for the j-th slot
TString GetSlotName(Int_t j=1) const; // Provide user defined name for the j-th slot
Int_t GetSlotIndex(TString name) const; // Provide the slot index of the matching name
TObjArray* fCalfuncs; // Explicit signal calibration functions
TObjArray* fDecalfuncs; // Explicit signal de-calibration functions
- ClassDef(AliAttrib,4) // Generic handling of detector signal (calibration) attributes.
+ ClassDef(AliAttrib,5) // Generic handling of detector signal (calibration) attributes.
};
#endif
// when entering values and/or errors.
fSignals=0;
fDsignals=0;
+ fSigflags=0;
fWaveforms=0;
fLinks=0;
fDevice=0;
delete fDsignals;
fDsignals=0;
}
+ if (fSigflags)
+ {
+ delete fSigflags;
+ fSigflags=0;
+ }
if (fWaveforms)
{
delete fWaveforms;
// Copy constructor
fSignals=0;
fDsignals=0;
+ fSigflags=0;
fWaveforms=0;
fLinks=0;
fTracks=0;
Double_t val;
for (Int_t i=1; i<=n; i++)
{
- val=s.GetSignal(i);
- SetSignal(val,i);
+ if (s.GetSignalFlag(i))
+ {
+ val=s.GetSignal(i);
+ SetSignal(val,i);
+ }
}
n=s.GetNerrors();
for (Int_t j=1; j<=n; j++)
{
- val=s.GetSignalError(j);
- SetSignalError(val,j);
+ if (s.GetErrorFlag(i))
+ {
+ val=s.GetSignalError(j);
+ SetSignalError(val,j);
+ }
}
n=s.GetNwaveforms();
mode=0;
}
+ Int_t sflag=0;
+ Int_t eflag=0;
+
if (fSignals && (mode==0 || mode==1))
{
- for (Int_t i=0; i<fSignals->GetSize(); i++)
+ for (Int_t i=1; i<=fSignals->GetSize(); i++)
{
- fSignals->AddAt(0,i);
+ fSignals->AddAt(0,i-1);
+ eflag=GetErrorFlag(i);
+ SetSigFlags(0,eflag,i);
}
}
if (fDsignals && (mode==0 || mode==2))
{
- for (Int_t j=0; j<fDsignals->GetSize(); j++)
+ for (Int_t j=1; j<=fDsignals->GetSize(); j++)
{
- fDsignals->AddAt(0,j);
+ fDsignals->AddAt(0,j-1);
+ sflag=GetSignalFlag(j);
+ SetSigFlags(sflag,0,j);
}
}
fDsignals=0;
}
+ Int_t sflag=0;
+ Int_t eflag=0;
+
+ if (mode==0)
+ {
+ delete fSigflags;
+ fSigflags=0;
+ }
+ else if (mode==1)
+ {
+ for (Int_t i=1; i<=fSigflags->GetSize(); i++)
+ {
+ eflag=GetErrorFlag(i);
+ SetSigFlags(0,eflag,i);
+ }
+ }
+ else if (mode==2)
+ {
+ for (Int_t j=1; j<=fSigflags->GetSize(); j++)
+ {
+ sflag=GetSignalFlag(j);
+ SetSigFlags(sflag,0,j);
+ }
+ }
+
DeleteWaveform(0);
}
///////////////////////////////////////////////////////////////////////////
}
fSignals->AddAt(float(sig),j-1);
+
+ Int_t eflag=GetErrorFlag(j);
+ SetSigFlags(1,eflag,j);
}
///////////////////////////////////////////////////////////////////////////
void AliSignal::SetSignal(Double_t sig,TString name)
Float_t sum=(fSignals->At(j-1))+sig;
fSignals->AddAt(sum,j-1);
+
+ Int_t eflag=GetErrorFlag(j);
+ SetSigFlags(1,eflag,j);
}
///////////////////////////////////////////////////////////////////////////
void AliSignal::AddSignal(Double_t sig,TString name)
}
fDsignals->AddAt(float(dsig),j-1);
+
+ Int_t sflag=GetSignalFlag(j);
+ SetSigFlags(sflag,1,j);
}
///////////////////////////////////////////////////////////////////////////
void AliSignal::SetSignalError(Double_t dsig,TString name)
}
}
- Int_t nvalues=GetNvalues();
- Int_t nerrors=GetNerrors();
+ Int_t n=GetNslots();
Int_t nlinkslots=0;
if (GetNlinks()) nlinkslots=fLinks->GetMaxColumn();
- Int_t ncalibs=GetNcalflags();
- Int_t ncalfuncs=GetNcalfuncs();
- Int_t ndecalfuncs=GetNdecalfuncs();
-
- Int_t n=nvalues;
- if (nerrors>n) n=nerrors;
if (nlinkslots>n) n=nlinkslots;
- if (InheritsFrom("AliDevice"))
- {
- if (ncalibs>n) n=ncalibs;
- if (ncalfuncs>n) n=ncalfuncs;
- if (ndecalfuncs>n) n=ndecalfuncs;
- }
TObject* obj=0;
Int_t nrefs=0;
{
for (Int_t i=1; i<=n; i++)
{
- cout << " Slot : " << i;
- if (i<=nvalues) cout << " Signal value : " << GetSignal(i);
- if (i<=nerrors) cout << " error : " << GetSignalError(i);
- AliAttrib::List(i);
- cout << endl;
obj=0;
nrefs=GetIndices(obj,i,posarr);
- for (Int_t k=0; k<nrefs; k++)
+
+ if (GetSignalFlag(i) || GetErrorFlag(i) || GetCalFunction(i) || GetDecalFunction(i) || GetCalWord(i) || nrefs)
{
- pos=posarr.At(k);
- obj=GetLink(i,pos);
- if (obj)
+ cout << " Slot : " << i;
+ if (GetSignalFlag(i)) cout << " Signal value : " << GetSignal(i);
+ if (GetErrorFlag(i)) cout << " error : " << GetSignalError(i);
+ AliAttrib::List(i);
+ cout << endl;
+
+ for (Int_t k=0; k<nrefs; k++)
{
- cout << " Link at position " << pos << " to : " << obj->ClassName();
- if (obj->InheritsFrom("TNamed"))
+ pos=posarr.At(k);
+ obj=GetLink(i,pos);
+ if (obj)
{
- const char* lname=obj->GetName();
- const char* ltitle=obj->GetTitle();
- if (strlen(lname)) cout << " Name : " << lname;
- if (strlen(ltitle)) cout << " Title : " << ltitle;
+ cout << " Link at position " << pos << " to : " << obj->ClassName();
+ if (obj->InheritsFrom("TNamed"))
+ {
+ const char* lname=obj->GetName();
+ const char* ltitle=obj->GetTitle();
+ if (strlen(lname)) cout << " Name : " << lname;
+ if (strlen(ltitle)) cout << " Title : " << ltitle;
+ }
+ cout << endl;
}
- cout << endl;
}
}
}
{
if (j<=n)
{
- cout << " Slot : " << j;
- if (j<=nvalues) cout << " Signal value : " << GetSignal(j);
- if (j<=nerrors) cout << " error : " << GetSignalError(j);
- AliAttrib::List(j);
- cout << endl;
obj=0;
nrefs=GetIndices(obj,j,posarr);
- for (Int_t kj=0; kj<nrefs; kj++)
+
+ if (GetSignalFlag(j) || GetErrorFlag(j) || GetCalFunction(j) || GetDecalFunction(j) || GetCalWord(j) || nrefs)
{
- pos=posarr.At(kj);
- obj=GetLink(j,pos);
- if (obj)
+ cout << " Slot : " << j;
+ if (GetSignalFlag(j)) cout << " Signal value : " << GetSignal(j);
+ if (GetErrorFlag(j)) cout << " error : " << GetSignalError(j);
+ AliAttrib::List(j);
+ cout << endl;
+
+ for (Int_t kj=0; kj<nrefs; kj++)
{
- cout << " Link at position " << pos << " to : " << obj->ClassName();
- if (obj->InheritsFrom("TNamed"))
+ pos=posarr.At(kj);
+ obj=GetLink(j,pos);
+ if (obj)
{
- const char* lnamej=obj->GetName();
- const char* ltitlej=obj->GetTitle();
- if (strlen(lnamej)) cout << " Name : " << lnamej;
- if (strlen(ltitlej)) cout << " Title : " << ltitlej;
+ cout << " Link at position " << pos << " to : " << obj->ClassName();
+ if (obj->InheritsFrom("TNamed"))
+ {
+ const char* lnamej=obj->GetName();
+ const char* ltitlej=obj->GetTitle();
+ if (strlen(lnamej)) cout << " Name : " << lnamej;
+ if (strlen(ltitlej)) cout << " Title : " << ltitlej;
+ }
+ cout << endl;
}
- cout << endl;
}
}
}
Int_t AliSignal::GetNvalues() const
{
// Provide the number of values for this signal.
+
+ if (!fSignals) return 0;
+
Int_t n=0;
- if (fSignals) n=fSignals->GetSize();
+ for (Int_t i=1; i<=fSigflags->GetSize(); i++)
+ {
+ if (GetSignalFlag(i)) n=i;
+ }
+
return n;
}
///////////////////////////////////////////////////////////////////////////
Int_t AliSignal::GetNerrors() const
{
// Provide the number specified errors on the values for this signal.
+
+ if (!fDsignals) return 0;
+
Int_t n=0;
- if (fDsignals) n=fDsignals->GetSize();
+ for (Int_t i=1; i<=fSigflags->GetSize(); i++)
+ {
+ if (GetErrorFlag(i)) n=i;
+ }
+
+ return n;
+}
+///////////////////////////////////////////////////////////////////////////
+void AliSignal::SetSigFlags(Int_t is,Int_t ie,Int_t j)
+{
+// Store signal and/or error value flags of the j-th (default j=1) slot.
+// Note : The first slot is at j=1.
+// In case the value of the index j exceeds the maximum number of reserved
+// slots for the flags, the number of reserved slots for the flags is
+// increased automatically.
+// The value stored is : 10*signalflag + errorflag.
+
+ if (j<1)
+ {
+ cout << " *AliSignal::SetSigFlags* Invalid argument j = " << j << endl;
+ return;
+ }
+
+ if (!fSigflags)
+ {
+ fSigflags=new TArrayI(j);
+ }
+
+ Int_t size=fSigflags->GetSize();
+
+ if (j>size)
+ {
+ fSigflags->Set(j);
+ }
+
+ Int_t word=10*is+ie;
+
+ fSigflags->AddAt(word,j-1);
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetSignalFlag(Int_t j) const
+{
+// Provide signal value flag of the j-th (default j=1) slot.
+//
+// flag = 1 : Signal value was set
+// 0 : Signal value was not set
+//
+// Note : The first attribute slot is at j=1.
+// In case j is invalid, 0 is returned.
+
+ if (j<1)
+ {
+ cout << " *AliSignal::GetSignalFlag* Invalid argument j = " << j << endl;
+ return 0;
+ }
+ Int_t flag=0;
+ if (fSigflags)
+ {
+ if (j>0 && j<=(fSigflags->GetSize()))
+ {
+ Int_t word=fSigflags->At(j-1);
+ flag=word/10;
+ }
+ }
+ return flag;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetSignalFlag(TString name) const
+{
+// Provide signal value flag of the name-specified slot.
+//
+// flag = 1 : Signal value was set
+// 0 : Signal value was not set
+//
+//
+// This procedure involves a slot-index search based on the specified name
+// at each invokation. This may become slow in case many slots have been
+// defined and/or when this procedure is invoked many times.
+// In such cases it is preferable to use indexed addressing in the user code
+// either directly or via a few invokations of GetSlotIndex().
+
+ Int_t j=GetSlotIndex(name);
+ Int_t flag=0;
+ if (j>0) flag=GetSignalFlag(j);
+ return flag;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetErrorFlag(Int_t j) const
+{
+// Provide error value flag of the j-th (default j=1) slot.
+//
+// flag = 1 : Error value was set
+// 0 : Error value was not set
+//
+// Note : The first attribute slot is at j=1.
+// In case j is invalid, 0 is returned.
+
+ if (j<1)
+ {
+ cout << " *AliSignal::GetErrorFlag* Invalid argument j = " << j << endl;
+ return 0;
+ }
+ Int_t flag=0;
+ if (fSigflags)
+ {
+ if (j>0 && j<=(fSigflags->GetSize()))
+ {
+ Int_t word=fSigflags->At(j-1);
+ flag=word%10;
+ }
+ }
+ return flag;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetErrorFlag(TString name) const
+{
+// Provide error value flag of the name-specified slot.
+//
+// flag = 1 : Error value was set
+// 0 : Error value was not set
+//
+//
+// This procedure involves a slot-index search based on the specified name
+// at each invokation. This may become slow in case many slots have been
+// defined and/or when this procedure is invoked many times.
+// In such cases it is preferable to use indexed addressing in the user code
+// either directly or via a few invokations of GetSlotIndex().
+
+ Int_t j=GetSlotIndex(name);
+ Int_t flag=0;
+ if (j>0) flag=GetErrorFlag(j);
+ return flag;
+}
+///////////////////////////////////////////////////////////////////////////
+Int_t AliSignal::GetNslots() const
+{
+// Provide the number of existing slots.
+
+ Int_t n=AliAttrib::GetNslots();
+
+ if (!fSigflags) return n;
+
+ Int_t nflags=0;
+ for (Int_t i=0; i<fSigflags->GetSize(); i++)
+ {
+ if (fSigflags->At(i)) nflags=i+1;
+ }
+
+ if (n<nflags) n=nflags;
+
return n;
}
///////////////////////////////////////////////////////////////////////////
void ListTrack(Int_t j=0) const; // Print info for the j-th (all) assoc. track(s)
Int_t GetNvalues() const; // Provide the number of signal values
Int_t GetNerrors() const; // Provide the number of specified errors
+ virtual Int_t GetNslots() const; // Provide the number of exising slots
Int_t GetNwaveforms() const; // Provide the number of specified waveforms
void SetWaveform(TH1F* waveform,Int_t j=1); // Set the histogram for the j-th waveform
TH1F* GetWaveform(Int_t j=1) const; // Pointer to the histo of the j-th waveform
Int_t GetNtracks(AliTrack* t=0) const; // Provide number of related AliTracks
AliTrack* GetTrack(Int_t j) const; // Access to the related AliTrack number j
AliTrack* GetIdTrack(Int_t id) const; // Access to the related AliTrack with ID=id
+ Int_t GetSignalFlag(Int_t j=1) const; // Provide signal value flag of the j-th slot
+ Int_t GetSignalFlag(TString name) const; // Provide signal value flag of the name specified slot
+ Int_t GetErrorFlag(Int_t j=1) const; // Provide error value flag of the j-th slot
+ Int_t GetErrorFlag(TString name) const; // Provide error value flag of the name specified slot
protected:
+ void SetSigFlags(Int_t is,Int_t ie,Int_t j); // Set flags for signal and/or error value settings
TArrayF* fSignals; // Signal values
TArrayF* fDsignals; // Errors on signal values
+ TArrayI* fSigflags; // Flags to mark setting of signal and/or error values
TObjArray* fWaveforms; // The 1D histograms containing the signal waveforms
AliObjMatrix* fLinks; // Pointers of objects related to the various slots
TObject* fDevice; // Pointer to the device that owns this signal
TObjArray* fTracks; // Pointers to associated tracks
- ClassDef(AliSignal,15) // Generic handling of (extrapolated) detector signals.
+ ClassDef(AliSignal,16) // Generic handling of (extrapolated) detector signals.
};
#endif
and fDresult suppressed for I/O streaming. This will reduce the produced
output filesize.
21-jul-2006 NvE AliSample extended for computation of median.
+12-sep-2006 NvE Memberfunctions GetNslots and AddNamedSlot introduced and various
+ modifications made in AliAttrib and AliSignal to overcome a ROOT
+ feature which always sets the size of TArray objects to a default
+ of 16 when reading these objects back from a file.
+ The modified AliAttrib and AliSignal don't rely on a GetSize()
+ anymore, but determine the number of stored values from the
+ actual array contents.
IceGOM* ome=0; // The event OM pointer
IceGOM* omd=0; // The database OM pointer
Int_t id=0;
- Float_t sig=0;
- Float_t sigc=0;
+ Float_t adc=0,le=0,tot=0; // Uncalibrated values
+ Float_t cadc=0,cle=0,ctot=0; // Calibrated values
TF1* fcal=0;
TF1* fdecal=0;
TString slotname;
for (Int_t ind=1; ind<=omd->GetNnames(); ind++)
{
slotname=omd->GetSlotName(ind);
- ome->SetSlotName(slotname.Data(),ind);
+ ome->AddNamedSlot(slotname);
}
for (Int_t isd=1; isd<=omd->GetNvalues(); isd++)
{
- ome->SetSignal(omd->GetSignal(isd),isd);
+ ome->SetSignal(omd->GetSignal(isd),omd->GetSlotName(isd));
}
}
- else
- {
- for (Int_t ise=8; ise<=ome->GetNvalues(); ise++)
- {
- ome->SetSignal(0,ise);
- }
- ome->SetSignal(1,8);
- ome->SetSignal(1,12);
- ome->SetSignal(1,15);
- }
// Make signals of bad modules available
ome->SetAlive("ADC");
if (!sx) continue;
// ADC (de)calibration
- sig=sx->GetSignal("ADC",-7); // Get uncalibrated signal
+ adc=sx->GetSignal("ADC",-7); // Get uncalibrated signal
fcal=0;
fdecal=0;
if (omd)
}
if (fcal) // Store calibrated signal
{
- sigc=fcal->Eval(sig);
- sx->SetSignal(sigc,"ADC");
- ome->SetCalFunction(0,"ADC");
- ome->SetDecalFunction(fdecal,"ADC");
+ cadc=fcal->Eval(adc);
+ sx->SetSignal(cadc,"ADC");
}
else // Store uncalibrated signal
{
- sx->SetSignal(sig,"ADC");
- ome->SetCalFunction(fcal,"ADC");
- ome->SetDecalFunction(0,"ADC");
+ sx->SetSignal(adc,"ADC");
}
// LE (TDC) (de)calibration
- sig=sx->GetSignal("LE",-7); // Get uncalibrated signal
+ le=sx->GetSignal("LE",-7); // Get uncalibrated signal
fcal=0;
fdecal=0;
if (omd)
fcal=omd->GetCalFunction("LE");
fdecal=omd->GetDecalFunction("LE");
}
- // Store the ADC independent (de)calibration function in the OM
- if (fcal)
- {
- ome->SetCalFunction(0,"LE");
- ome->SetDecalFunction(fdecal,"LE");
- }
- else
- {
- ome->SetCalFunction(fcal,"LE");
- ome->SetDecalFunction(0,"LE");
- }
// Store the hit-specific ADC dependent (de)calibration function in the hit itself
sx->SetCalFunction(fcal,"LE");
sx->SetDecalFunction(fdecal,"LE");
fcal=sx->GetCalFunction("LE");
fdecal=sx->GetDecalFunction("LE");
- sigc=sx->GetSignal("ADC",-7);
- if (sigc>0)
+ if (adc>0)
{
- if (fcal) fcal->SetParameter(3,sigc);
- if (fdecal) fdecal->SetParameter(3,sigc);
+ if (fcal) fcal->SetParameter(3,adc);
+ if (fdecal) fdecal->SetParameter(3,adc);
}
else
{
}
if (fcal) // Store calibrated signal
{
- sigc=fcal->Eval(sig);
- sx->SetSignal(sigc,"LE");
+ cle=fcal->Eval(le);
+ sx->SetSignal(cle,"LE");
sx->SetCalFunction(0,"LE");
sx->SetDecalFunction(fdecal,"LE");
}
else // Store uncalibrated signal
{
- sx->SetSignal(sig,"LE");
+ sx->SetSignal(le,"LE");
sx->SetCalFunction(fcal,"LE");
sx->SetDecalFunction(0,"LE");
}
// TOT (de)calibration
- sig=sx->GetSignal("TOT",-7); // Get uncalibrated signal
+ tot=sx->GetSignal("TOT",-7); // Get uncalibrated signal
fcal=0;
fdecal=0;
if (omd)
}
if (fcal) // Store calibrated signal
{
- sigc=fcal->Eval(sig);
- sx->SetSignal(sigc,"TOT");
- ome->SetCalFunction(0,"TOT");
- ome->SetDecalFunction(fdecal,"TOT");
+ ctot=fcal->Eval(tot);
+ sx->SetSignal(ctot,"TOT");
}
else // Store uncalibrated signal
{
- sx->SetSignal(sig,"TOT");
- ome->SetCalFunction(fcal,"TOT");
- ome->SetDecalFunction(0,"TOT");
+ sx->SetSignal(tot,"TOT");
}
- }
+ } // End of loop over hits of the OM
+ // Set bad OM flags according to dbase info
if (omd)
{
if (omd->GetDeadValue("ADC")) ome->SetDead("ADC");
if (omd->GetDeadValue("LE")) ome->SetDead("LE");
if (omd->GetDeadValue("TOT")) ome->SetDead("TOT");
}
- }
+
+ // Store ADC (de)calibration function in this OM according to dbase info
+ fcal=0;
+ fdecal=0;
+ if (omd)
+ {
+ fcal=omd->GetCalFunction("ADC");
+ fdecal=omd->GetDecalFunction("ADC");
+ }
+ if (fcal) // Calibrated ADC signals were stored
+ {
+ ome->SetCalFunction(0,"ADC");
+ ome->SetDecalFunction(fdecal,"ADC");
+ }
+ else // Uncalibrated ADC signals were stored
+ {
+ ome->SetCalFunction(fcal,"ADC");
+ ome->SetDecalFunction(0,"ADC");
+ }
+
+ // Store ADC independent LE (de)calibration function in this OM according to dbase info
+ fcal=0;
+ fdecal=0;
+ if (omd)
+ {
+ fcal=omd->GetCalFunction("LE");
+ fdecal=omd->GetDecalFunction("LE");
+ }
+ if (fcal) // Calibrated LE signals were stored
+ {
+ ome->SetCalFunction(0,"LE");
+ ome->SetDecalFunction(fdecal,"LE");
+ }
+ else // Uncalibrated LE signals were stored
+ {
+ ome->SetCalFunction(fcal,"LE");
+ ome->SetDecalFunction(0,"LE");
+ }
+
+ // Store TOT (de)calibration function in this OM according to dbase info
+ fcal=0;
+ fdecal=0;
+ if (omd)
+ {
+ fcal=omd->GetCalFunction("TOT");
+ fdecal=omd->GetDecalFunction("TOT");
+ }
+ if (fcal) // Calibrated TOT signals were stored
+ {
+ ome->SetCalFunction(0,"TOT");
+ ome->SetDecalFunction(fdecal,"TOT");
+ }
+ else // Uncalibrated TOT signals were stored
+ {
+ ome->SetCalFunction(fcal,"TOT");
+ ome->SetDecalFunction(0,"TOT");
+ }
+ } // End of loop over OM's of the event
}
///////////////////////////////////////////////////////////////////////////
07-jul-2006 NvE Track Id correctly set in IceLinefit.
28-jul-2006 NvE New class IceChi2 introduced and example macro icechi2.cc added.
Also IcePandel updated to use a Convoluted Pandel pdf.
+14-sep-2006 NvE IceCalibrate.cxx updated to correctly process multiple waveforms and hits per OM.
+ Also some calibration constants dropped from OM data words in IceCalibrate,
+ since these values are also stored as parameters in the corresponding
+ (de)calibration functions.
+
// The basic OM contents
IceAOM om;
+ // Slots to hold the various (de)calibration functions
om.SetSlotName("ADC",1);
om.SetSlotName("LE",2);
om.SetSlotName("TOT",3);
-
+ // Slots with hardware parameters
om.SetSlotName("TYPE",4);
om.SetSlotName("ORIENT",5);
om.SetSlotName("THRESH",6);
om.SetSlotName("SENSIT",7);
- om.SetSlotName("BETA-TDC",8);
- om.SetSlotName("T0",9);
- om.SetSlotName("ALPHA-TDC",10);
- om.SetSlotName("PED-ADC",11);
- om.SetSlotName("BETA-ADC",12);
- om.SetSlotName("KAPPA-ADC",13);
- om.SetSlotName("PED-TOT",14);
- om.SetSlotName("BETA-TOT",15);
- om.SetSlotName("KAPPA-TOT",16);
fInput.seekg(0); // Position at beginning of file
fInput >> dec; // Make sure all integers starting with 0 are taken in decimal format
omx->SetDecalFunction(0,3);
}
- omx->SetSignal(beta,8);
- omx->SetSignal(ped,9);
- omx->SetSignal(alpha,10);
- omx->SetSignal(beta,15);
- omx->SetSignal(0,16);
-
fcal=omx->GetCalFunction(2);
fdecal=omx->GetDecalFunction(2);
if (fcal)
omx->SetDecalFunction(0,3);
}
- omx->SetSignal(ped,11);
- omx->SetSignal(beta,12);
- omx->SetSignal(0,13);
- omx->SetSignal(totped,14);
-
fcal=omx->GetCalFunction(1);
fdecal=omx->GetDecalFunction(1);
if (fcal)
{
dev=new IceAOM();
dev->SetUniqueID(i+1);
-
+ // Slots to hold the various (de)calibration functions
dev->SetSlotName("ADC",1);
dev->SetSlotName("LE",2);
dev->SetSlotName("TOT",3);
-
+ // Slots to hold hardware parameters
dev->SetSlotName("TYPE",4);
dev->SetSlotName("ORIENT",5);
dev->SetSlotName("THRESH",6);
dev->SetSlotName("SENSIT",7);
- dev->SetSlotName("BETA-TDC",8);
- dev->SetSlotName("T0",9);
- dev->SetSlotName("ALPHA-TDC",10);
- dev->SetSlotName("PED-ADC",11);
- dev->SetSlotName("BETA-ADC",12);
- dev->SetSlotName("KAPPA-ADC",13);
- dev->SetSlotName("PED-TOT",14);
- dev->SetSlotName("BETA-TOT",15);
- dev->SetSlotName("KAPPA-TOT",16);
pos[0]=fHeader.x[i];
pos[1]=fHeader.y[i];
dev->SetSignal((Float_t)fHeader.costh[i],5);
dev->SetSignal(fHeader.thresh[i],6);
dev->SetSignal(fHeader.sensit[i],7);
- dev->SetSignal(fHeader.cal[i].beta_t,8);
- dev->SetSignal(fHeader.cal[i].t_0,9);
- dev->SetSignal(fHeader.cal[i].alpha_t,10);
- dev->SetSignal(fHeader.cal[i].ped,11);
- dev->SetSignal(fHeader.cal[i].beta_a,12);
- dev->SetSignal(fHeader.cal[i].kappa,13);
- dev->SetSignal(fHeader.cal[i].ped_tot,14);
- dev->SetSignal(fHeader.cal[i].beta_tot,15);
- dev->SetSignal(fHeader.cal[i].kappa_tot,16);
fOmdb->EnterObject(i+1,1,dev);
}
if (!omx) continue;
- omx->SetSlotName("BASELINE",omx->GetNnames()+1);
- omx->SetSignal(-fEvent.wf[iwf].baseline,"BASELINE");
+ hname="BASELINE-WF";
+ hname+=omx->GetNwaveforms()+1;
+ omx->AddNamedSlot(hname);
+ omx->SetSignal(fEvent.wf[iwf].baseline,hname);
// Fill the waveform histogram
hname="OM";
for (Int_t jbin=1; jbin<=fEvent.wf[iwf].ndigi; jbin++)
{
- histo.SetBinContent(jbin,-fEvent.wf[iwf].digi[jbin-1]);
+ histo.SetBinContent(jbin,fEvent.wf[iwf].baseline-fEvent.wf[iwf].digi[jbin-1]);
}
omx->SetWaveform(&histo,omx->GetNwaveforms()+1);
AliSignal::AddTrack facility instead of AddLink in IceF2k.
Also default split level set to 0 in IceF2k to minimise file size and
I/O time.
-
+13-sep-2006 NvE IceF2k updated for multiple waveforms per OM by making use of the
+ new AliAttrib::AddNamedSlot facility.
+ Also some calibration constants dropped from OM data words in IceF2k
+ and IceCal2Root, since these values are also stored as parameters in
+ the corresponding (de)calibration functions.
+ Also for TWR data the values stored in the histos are (baseline-amp),
+ so that all pulses appear as positive instead of negative and the
+ resulting histos are baseline corrected.
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff