AliDebug(2,Form(" The ToT and Time, uncorr (counts) = %d , %d", fTofClusters[ii]->GetToT(),fTofClusters[ii]->GetTDC()));
tToT = (Double_t)(fTofClusters[ii]->GetToT()*AliTOFGeometry::ToTBinWidth());
tToT*=1.E-3; //ToT in ns
+
+ /* check TOT limits and set new TOT in case */
+ if (tToT < AliTOFGeometry::SlewTOTMin()) tToT = AliTOFGeometry::SlewTOTMin();
+ if (tToT > AliTOFGeometry::SlewTOTMax()) tToT = AliTOFGeometry::SlewTOTMax();
+
AliDebug(2,Form(" The ToT and Time, uncorr (ns)= %e, %e",fTofClusters[ii]->GetTDC()*AliTOFGeometry::TdcBinWidth()*1.E-3,tToT));
timeCorr=par[0]+par[1]*tToT+par[2]*tToT*tToT+par[3]*tToT*tToT*tToT+par[4]*tToT*tToT*tToT*tToT+par[5]*tToT*tToT*tToT*tToT*tToT; // the time correction (ns)
}
-/*************************************************************************\r
- * * Copyright(c) 1998-2008, ALICE Experiment at CERN, All rights reserved. *\r
- * * *\r
- * * Author: The ALICE Off-line Project. *\r
- * * Contributors are mentioned in the code where appropriate. *\r
- * * *\r
- * * Permission to use, copy, modify and distribute this software and its *\r
- * * documentation strictly for non-commercial purposes is hereby granted *\r
- * * without fee, provided that the above copyright notice appears in all *\r
- * * copies and that both the copyright notice and this permission notice *\r
- * * appear in the supporting documentation. The authors make no claims *\r
- * * about the suitability of this software for any purpose. It is *\r
- * * provided "as is" without express or implied warranty. *\r
- * **************************************************************************/\r
-\r
-////////////////////////////////////////////////////////////////////////////\r
-// //\r
-// The SAX XML file handler used in the TOFda //\r
-// //\r
-// Author: //\r
-// Chiara Zampolli (Chiara.Zampolli@cern.ch) //\r
-// //\r
-////////////////////////////////////////////////////////////////////////////\r
-\r
-#include <cstdlib>\r
-#include <Riostream.h>\r
-\r
-#include <TList.h>\r
-#include <TObject.h>\r
-#include <TXMLAttr.h>\r
-#include <TSAXParser.h>\r
-\r
-#include "AliLog.h"\r
-#include "AliTOFDaConfigHandler.h"\r
-\r
-ClassImp(AliTOFDaConfigHandler)\r
-\r
- \r
-//_____________________________________________________________________________\r
-AliTOFDaConfigHandler::AliTOFDaConfigHandler()\r
- :TObject(),\r
- fDebugFlag(0),\r
- fT0Flag(0)\r
-{\r
- //\r
- // AliTOFDaConfigHandler default constructor\r
- //\r
-}\r
-\r
-//_____________________________________________________________________________\r
-AliTOFDaConfigHandler::AliTOFDaConfigHandler(const AliTOFDaConfigHandler &sh)\r
- :TObject(sh),\r
- fDebugFlag(sh.fDebugFlag),\r
- fT0Flag(sh.fT0Flag)\r
-{\r
- //\r
- // AliTOFDaConfigHandler copy constructor\r
- //\r
-}\r
-\r
-//_____________________________________________________________________________\r
-AliTOFDaConfigHandler &AliTOFDaConfigHandler::operator=(const AliTOFDaConfigHandler &sh)\r
-{\r
- //\r
- // Assignment operator\r
- //\r
- if (&sh == this) return *this;\r
- \r
- new (this) AliTOFDaConfigHandler(sh);\r
- return *this;\r
-}\r
-\r
-//_____________________________________________________________________________\r
-AliTOFDaConfigHandler::~AliTOFDaConfigHandler()\r
-{\r
- //\r
- // AliTOFDaConfigHandler destructor\r
- // \r
-}\r
-\r
-//_____________________________________________________________________________\r
-void AliTOFDaConfigHandler::OnStartDocument()\r
-{\r
- // if something should happen right at the beginning of the\r
- // XML document, this must happen here\r
- AliInfo("Reading XML file for TOF da Config");\r
-}\r
-\r
-//_____________________________________________________________________________\r
-void AliTOFDaConfigHandler::OnEndDocument()\r
-{\r
- // if something should happen at the end of the XML document\r
- // this must be done here\r
-}\r
-\r
-//_____________________________________________________________________________\r
-void AliTOFDaConfigHandler::OnStartElement(const char *name, const TList *attributes)\r
-{\r
- // when a new XML element is found, it is processed here\r
-\r
- // set the current system if necessary\r
- TString strName(name);\r
- AliDebug(2,Form("name = %s",strName.Data()));\r
- TXMLAttr* attr;\r
- TIter next(attributes);\r
- while ((attr = (TXMLAttr*) next())) {\r
- TString attrName = attr->GetName();\r
- AliDebug(2,Form("Name = %s",attrName.Data())); \r
- if (attrName == "DebugFlag"){\r
- fDebugFlag = ((TString)(attr->GetValue())).Atoi();\r
- }\r
- if (attrName == "t0Flag"){\r
- TString t0Flag = (TString)(attr->GetValue());\r
- if (t0Flag == "ON" || t0Flag == "On" || t0Flag == "on"){ \r
- fT0Flag = 1;\r
- }\r
- else if (t0Flag == "OFF" || t0Flag == "Off"|| t0Flag == "off"){\r
- fT0Flag = 0;\r
- }\r
- else {\r
- AliWarning("Invalid T0 Flag. Keeping t0 off");\r
- fT0Flag = 0;\r
- }\r
- }\r
- } \r
- AliDebug(2,Form("Debug Flag = %i",fDebugFlag)); \r
- AliDebug(2,Form("T0 Flag = %i",fT0Flag)); \r
- return;\r
-}\r
-//_____________________________________________________________________________\r
-void AliTOFDaConfigHandler::OnEndElement(const char *name)\r
-{\r
- // do everything that needs to be done when an end tag of an element is found\r
- TString strName(name);\r
- AliDebug(2,Form("name = %s",strName.Data()));\r
-}\r
-\r
-//_____________________________________________________________________________\r
-void AliTOFDaConfigHandler::OnCharacters(const char *characters)\r
-{\r
- // copy the text content of an XML element\r
- //fContent = characters;\r
- TString strCharacters(characters);\r
- AliDebug(2,Form("characters = %s",strCharacters.Data()));\r
-}\r
-\r
-//_____________________________________________________________________________\r
-void AliTOFDaConfigHandler::OnComment(const char* /*text*/)\r
-{\r
- // comments within the XML file are ignored\r
-}\r
-\r
-//_____________________________________________________________________________\r
-void AliTOFDaConfigHandler::OnWarning(const char *text)\r
-{\r
- // process warnings here\r
- AliInfo(Form("Warning: %s",text));\r
-}\r
-\r
-//_____________________________________________________________________________\r
-void AliTOFDaConfigHandler::OnError(const char *text)\r
-{\r
- // process errors here\r
- AliError(Form("Error: %s",text));\r
-}\r
-\r
-//_____________________________________________________________________________\r
-void AliTOFDaConfigHandler::OnFatalError(const char *text)\r
-{\r
- // process fatal errors here\r
- AliFatal(Form("Fatal error: %s",text));\r
-}\r
-\r
-//_____________________________________________________________________________\r
-void AliTOFDaConfigHandler::OnCdataBlock(const char* /*text*/, Int_t /*len*/)\r
-{\r
- // process character data blocks here\r
- // not implemented and should not be used here\r
-}\r
-\r
+/*************************************************************************
+ * * Copyright(c) 1998-2008, ALICE Experiment at CERN, All rights reserved. *
+ * * *
+ * * Author: The ALICE Off-line Project. *
+ * * Contributors are mentioned in the code where appropriate. *
+ * * *
+ * * Permission to use, copy, modify and distribute this software and its *
+ * * documentation strictly for non-commercial purposes is hereby granted *
+ * * without fee, provided that the above copyright notice appears in all *
+ * * copies and that both the copyright notice and this permission notice *
+ * * appear in the supporting documentation. The authors make no claims *
+ * * about the suitability of this software for any purpose. It is *
+ * * provided "as is" without express or implied warranty. *
+ * **************************************************************************/
+
+////////////////////////////////////////////////////////////////////////////
+// //
+// The SAX XML file handler used in the TOFda //
+// //
+// Author: //
+// Chiara Zampolli (Chiara.Zampolli@cern.ch) //
+// Roberto Preghenella (R+) (preghenella@bo.infn.it) //
+// //
+////////////////////////////////////////////////////////////////////////////
+
+#include <cstdlib>
+#include <Riostream.h>
+
+#include <TList.h>
+#include <TObject.h>
+#include <TXMLAttr.h>
+#include <TSAXParser.h>
+
+#include "AliLog.h"
+#include "AliTOFDaConfigHandler.h"
+
+ClassImp(AliTOFDaConfigHandler)
+
+
+//_____________________________________________________________________________
+AliTOFDaConfigHandler::AliTOFDaConfigHandler()
+:TObject(),
+ fMeanMultiplicity(0),
+ fMaxHits(0)
+{
+ //
+ // AliTOFDaConfigHandler default constructor
+ //
+}
+
+//_____________________________________________________________________________
+AliTOFDaConfigHandler::AliTOFDaConfigHandler(const AliTOFDaConfigHandler &sh)
+ :TObject(sh),
+ fMeanMultiplicity(sh.fMeanMultiplicity),
+ fMaxHits(sh.fMaxHits)
+{
+ //
+ // AliTOFDaConfigHandler copy constructor
+ //
+}
+
+//_____________________________________________________________________________
+AliTOFDaConfigHandler &AliTOFDaConfigHandler::operator=(const AliTOFDaConfigHandler &sh)
+{
+ //
+ // Assignment operator
+ //
+ if (&sh == this) return *this;
+
+ new (this) AliTOFDaConfigHandler(sh);
+ return *this;
+}
+
+//_____________________________________________________________________________
+AliTOFDaConfigHandler::~AliTOFDaConfigHandler()
+{
+ //
+ // AliTOFDaConfigHandler destructor
+ //
+}
+
+//_____________________________________________________________________________
+void AliTOFDaConfigHandler::OnStartDocument()
+{
+ // if something should happen right at the beginning of the
+ // XML document, this must happen here
+ AliInfo("Reading XML file for TOF da Config");
+}
+
+//_____________________________________________________________________________
+void AliTOFDaConfigHandler::OnEndDocument()
+{
+ // if something should happen at the end of the XML document
+ // this must be done here
+}
+
+//_____________________________________________________________________________
+void AliTOFDaConfigHandler::OnStartElement(const char *name, const TList *attributes)
+{
+ // when a new XML element is found, it is processed here
+
+ // set the current system if necessary
+ TString strName(name);
+ AliDebug(2,Form("name = %s",strName.Data()));
+ TXMLAttr* attr;
+ TIter next(attributes);
+ while ((attr = (TXMLAttr*) next())) {
+ TString attrName = attr->GetName();
+ AliDebug(2,Form("Name = %s",attrName.Data()));
+ if (attrName == "MeanMultiplicity"){
+ fMeanMultiplicity = ((TString)(attr->GetValue())).Atoi();
+ }
+ if (attrName == "MaxHits"){
+ fMaxHits = ((TString)(attr->GetValue())).Atoi();
+ }
+ }
+ AliDebug(2,Form("MeanMultiplicity = %d",fMeanMultiplicity));
+ AliDebug(2,Form("MaxHits = %d",fMaxHits));
+ return;
+}
+//_____________________________________________________________________________
+void AliTOFDaConfigHandler::OnEndElement(const char *name)
+{
+ // do everything that needs to be done when an end tag of an element is found
+ TString strName(name);
+ AliDebug(2,Form("name = %s",strName.Data()));
+}
+
+//_____________________________________________________________________________
+void AliTOFDaConfigHandler::OnCharacters(const char *characters)
+{
+ // copy the text content of an XML element
+ //fContent = characters;
+ TString strCharacters(characters);
+ AliDebug(2,Form("characters = %s",strCharacters.Data()));
+}
+
+//_____________________________________________________________________________
+void AliTOFDaConfigHandler::OnComment(const char* /*text*/)
+{
+ // comments within the XML file are ignored
+}
+
+//_____________________________________________________________________________
+void AliTOFDaConfigHandler::OnWarning(const char *text)
+{
+ // process warnings here
+ AliInfo(Form("Warning: %s",text));
+}
+
+//_____________________________________________________________________________
+void AliTOFDaConfigHandler::OnError(const char *text)
+{
+ // process errors here
+ AliError(Form("Error: %s",text));
+}
+
+//_____________________________________________________________________________
+void AliTOFDaConfigHandler::OnFatalError(const char *text)
+{
+ // process fatal errors here
+ AliFatal(Form("Fatal error: %s",text));
+}
+
+//_____________________________________________________________________________
+void AliTOFDaConfigHandler::OnCdataBlock(const char* /*text*/, Int_t /*len*/)
+{
+ // process character data blocks here
+ // not implemented and should not be used here
+}
+
// to get the necessary flags to run (e.g. debug flag) //
// //
// Chiara.Zampolli (Chiara.Zampolli@cern.ch) //
+// Roberto Preghenella (R+) (preghenella@bo.infn.it) //
+// //
// //
////////////////////////////////////////////////////////////////////////////
void OnFatalError(const char *name);
void OnCdataBlock(const char *name, Int_t len);
- Int_t GetDebugFlag() const {return fDebugFlag;}
- Int_t GetT0Flag() const {return fT0Flag;}
+ Int_t GetMeanMultiplicity() const {return fMeanMultiplicity;};
+ Int_t GetMaxHits() const {return fMaxHits;};
private:
- Int_t fDebugFlag; // debug flag: 0-->off, 1-->first level of debug, 2-->second level of debug, 3-->third level of debug
- Int_t fT0Flag; // flag for using T0: 0-->off, 1-->on
- ClassDef(AliTOFDaConfigHandler,0);
+ Int_t fMeanMultiplicity; // mean multiplicity
+ Int_t fMaxHits; // max hits
+
+ ClassDef(AliTOFDaConfigHandler,1);
};
#endif
--- /dev/null
+/*************************************************************************\r
+ * * Copyright(c) 1998-2008, ALICE Experiment at CERN, All rights reserved. *\r
+ * * *\r
+ * * Author: The ALICE Off-line Project. *\r
+ * * Contributors are mentioned in the code where appropriate. *\r
+ * * *\r
+ * * Permission to use, copy, modify and distribute this software and its *\r
+ * * documentation strictly for non-commercial purposes is hereby granted *\r
+ * * without fee, provided that the above copyright notice appears in all *\r
+ * * copies and that both the copyright notice and this permission notice *\r
+ * * appear in the supporting documentation. The authors make no claims *\r
+ * * about the suitability of this software for any purpose. It is *\r
+ * * provided "as is" without express or implied warranty. *\r
+ * **************************************************************************/\r
+\r
+////////////////////////////////////////////////////////////////////////////\r
+// //\r
+// The SAX XML file handler used in the TOFda //\r
+// //\r
+// Author: //\r
+// Chiara Zampolli (Chiara.Zampolli@cern.ch) //\r
+// //\r
+////////////////////////////////////////////////////////////////////////////\r
+\r
+#include <cstdlib>\r
+#include <Riostream.h>\r
+\r
+#include <TList.h>\r
+#include <TObject.h>\r
+#include <TXMLAttr.h>\r
+#include <TSAXParser.h>\r
+\r
+#include "AliLog.h"\r
+#include "AliTOFDaConfigHandler.h"\r
+\r
+ClassImp(AliTOFDaConfigHandler)\r
+\r
+ \r
+//_____________________________________________________________________________\r
+AliTOFDaConfigHandler::AliTOFDaConfigHandler()\r
+ :TObject(),\r
+ fDebugFlag(0),\r
+ fT0Flag(0)\r
+{\r
+ //\r
+ // AliTOFDaConfigHandler default constructor\r
+ //\r
+}\r
+\r
+//_____________________________________________________________________________\r
+AliTOFDaConfigHandler::AliTOFDaConfigHandler(const AliTOFDaConfigHandler &sh)\r
+ :TObject(sh),\r
+ fDebugFlag(sh.fDebugFlag),\r
+ fT0Flag(sh.fT0Flag)\r
+{\r
+ //\r
+ // AliTOFDaConfigHandler copy constructor\r
+ //\r
+}\r
+\r
+//_____________________________________________________________________________\r
+AliTOFDaConfigHandler &AliTOFDaConfigHandler::operator=(const AliTOFDaConfigHandler &sh)\r
+{\r
+ //\r
+ // Assignment operator\r
+ //\r
+ if (&sh == this) return *this;\r
+ \r
+ new (this) AliTOFDaConfigHandler(sh);\r
+ return *this;\r
+}\r
+\r
+//_____________________________________________________________________________\r
+AliTOFDaConfigHandler::~AliTOFDaConfigHandler()\r
+{\r
+ //\r
+ // AliTOFDaConfigHandler destructor\r
+ // \r
+}\r
+\r
+//_____________________________________________________________________________\r
+void AliTOFDaConfigHandler::OnStartDocument()\r
+{\r
+ // if something should happen right at the beginning of the\r
+ // XML document, this must happen here\r
+ AliInfo("Reading XML file for TOF da Config");\r
+}\r
+\r
+//_____________________________________________________________________________\r
+void AliTOFDaConfigHandler::OnEndDocument()\r
+{\r
+ // if something should happen at the end of the XML document\r
+ // this must be done here\r
+}\r
+\r
+//_____________________________________________________________________________\r
+void AliTOFDaConfigHandler::OnStartElement(const char *name, const TList *attributes)\r
+{\r
+ // when a new XML element is found, it is processed here\r
+\r
+ // set the current system if necessary\r
+ TString strName(name);\r
+ AliDebug(2,Form("name = %s",strName.Data()));\r
+ TXMLAttr* attr;\r
+ TIter next(attributes);\r
+ while ((attr = (TXMLAttr*) next())) {\r
+ TString attrName = attr->GetName();\r
+ AliDebug(2,Form("Name = %s",attrName.Data())); \r
+ if (attrName == "DebugFlag"){\r
+ fDebugFlag = ((TString)(attr->GetValue())).Atoi();\r
+ }\r
+ if (attrName == "t0Flag"){\r
+ TString t0Flag = (TString)(attr->GetValue());\r
+ if (t0Flag == "ON" || t0Flag == "On" || t0Flag == "on"){ \r
+ fT0Flag = 1;\r
+ }\r
+ else if (t0Flag == "OFF" || t0Flag == "Off"|| t0Flag == "off"){\r
+ fT0Flag = 0;\r
+ }\r
+ else {\r
+ AliWarning("Invalid T0 Flag. Keeping t0 off");\r
+ fT0Flag = 0;\r
+ }\r
+ }\r
+ } \r
+ AliDebug(2,Form("Debug Flag = %i",fDebugFlag)); \r
+ AliDebug(2,Form("T0 Flag = %i",fT0Flag)); \r
+ return;\r
+}\r
+//_____________________________________________________________________________\r
+void AliTOFDaConfigHandler::OnEndElement(const char *name)\r
+{\r
+ // do everything that needs to be done when an end tag of an element is found\r
+ TString strName(name);\r
+ AliDebug(2,Form("name = %s",strName.Data()));\r
+}\r
+\r
+//_____________________________________________________________________________\r
+void AliTOFDaConfigHandler::OnCharacters(const char *characters)\r
+{\r
+ // copy the text content of an XML element\r
+ //fContent = characters;\r
+ TString strCharacters(characters);\r
+ AliDebug(2,Form("characters = %s",strCharacters.Data()));\r
+}\r
+\r
+//_____________________________________________________________________________\r
+void AliTOFDaConfigHandler::OnComment(const char* /*text*/)\r
+{\r
+ // comments within the XML file are ignored\r
+}\r
+\r
+//_____________________________________________________________________________\r
+void AliTOFDaConfigHandler::OnWarning(const char *text)\r
+{\r
+ // process warnings here\r
+ AliInfo(Form("Warning: %s",text));\r
+}\r
+\r
+//_____________________________________________________________________________\r
+void AliTOFDaConfigHandler::OnError(const char *text)\r
+{\r
+ // process errors here\r
+ AliError(Form("Error: %s",text));\r
+}\r
+\r
+//_____________________________________________________________________________\r
+void AliTOFDaConfigHandler::OnFatalError(const char *text)\r
+{\r
+ // process fatal errors here\r
+ AliFatal(Form("Fatal error: %s",text));\r
+}\r
+\r
+//_____________________________________________________________________________\r
+void AliTOFDaConfigHandler::OnCdataBlock(const char* /*text*/, Int_t /*len*/)\r
+{\r
+ // process character data blocks here\r
+ // not implemented and should not be used here\r
+}\r
+\r
--- /dev/null
+#ifndef ALITOFDACONFIGHANDLER_H
+#define ALITOFDACONFIGHANDLER_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * * See cxx source for full Copyright notice */
+/* $Id$ */
+
+////////////////////////////////////////////////////////////////////////////
+// //
+// The SAX XML file handler used by the TOF DA for PHYSICS runs //
+// to get the necessary flags to run (e.g. debug flag) //
+// //
+// Chiara.Zampolli (Chiara.Zampolli@cern.ch) //
+// //
+////////////////////////////////////////////////////////////////////////////
+
+#include <TObject.h>
+class TString;
+
+class AliTOFDaConfigHandler : public TObject {
+
+public:
+
+ AliTOFDaConfigHandler();
+ AliTOFDaConfigHandler(const AliTOFDaConfigHandler &sh);
+ virtual ~AliTOFDaConfigHandler();
+ AliTOFDaConfigHandler &operator=(const AliTOFDaConfigHandler &sh);
+
+ // functions to interface to TSAXHandler
+ void OnStartDocument();
+ void OnEndDocument();
+ void OnStartElement(const char *name, const TList *attributes);
+ void OnEndElement(const char *name);
+ void OnCharacters(const char *name);
+ void OnComment(const char *name);
+ void OnWarning(const char *name);
+ void OnError(const char *name);
+ void OnFatalError(const char *name);
+ void OnCdataBlock(const char *name, Int_t len);
+
+ Int_t GetDebugFlag() const {return fDebugFlag;}
+ Int_t GetT0Flag() const {return fT0Flag;}
+
+ private:
+ Int_t fDebugFlag; // debug flag: 0-->off, 1-->first level of debug, 2-->second level of debug, 3-->third level of debug
+ Int_t fT0Flag; // flag for using T0: 0-->off, 1-->on
+
+ ClassDef(AliTOFDaConfigHandler,0);
+};
+#endif
+
const Float_t AliTOFGeometry::fgkToTBin = 48.8; // time-over-threshold bin width [ps]
const Float_t AliTOFGeometry::fgkBunchCrossingBin = fgkTdcBin * 1024; // bunch-crossing bin width [ps]
+const Float_t AliTOFGeometry::fgkSlewTOTMin = 10.; // min TOT for slewing correction [ns]
+const Float_t AliTOFGeometry::fgkSlewTOTMax = 16.; // max TOT for slewing correction [ns]
+
const Float_t AliTOFGeometry::fgkDeadTime = 25E+03; // Single channel dead time (ps)
const Float_t AliTOFGeometry::fgkMatchingWindow = fgkTdcBin*TMath::Power(2,13); // Matching window (ps)
static Float_t ToTBinWidth() {return fgkToTBin;};
static Float_t BunchCrossingBinWidth() {return fgkBunchCrossingBin;};
+ static Float_t SlewTOTMin() {return fgkSlewTOTMin;};
+ static Float_t SlewTOTMax() {return fgkSlewTOTMax;};
+
virtual void ImportGeometry();
virtual void SetHoles(Bool_t holes) {fHoles = holes;};
virtual Bool_t GetHoles() const {return fHoles;};
static const Float_t fgkToTBin; // time-over-threshold bin width [ps]
static const Float_t fgkBunchCrossingBin; // bunch-crossing bin width [ps]
+ static const Float_t fgkSlewTOTMin; // min TOT for slewing correction [ns]
+ static const Float_t fgkSlewTOTMax; // max TOT for slewing correction [ns]
+
ClassDef(AliTOFGeometry,8) // TOF Geometry base class
};
--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+///////////////////////////////////////////////////////////////
+// //
+// This class provides the minimum-size TOF hit info //
+// //
+// author: Roberto Preghenella (R+) //
+// preghenella@bo.infn.it //
+// //
+///////////////////////////////////////////////////////////////
+
+#include "AliTOFHitField.h"
+
+ClassImp(AliTOFHitField)
+
+//-----------------------------------------------------------------------------
+
+AliTOFHitField::AliTOFHitField() :
+ fIndex(0),
+ fTimeBin(0),
+ fTOTBin(0),
+ fDeltaBC(0),
+ fL0L1Latency(0)
+{
+ /*
+ * default constructor
+ */
+}
+
+//-----------------------------------------------------------------------------
+
+AliTOFHitField::~AliTOFHitField()
+{
+ /*
+ * default destructor
+ */
+}
+
+//-----------------------------------------------------------------------------
+
+AliTOFHitField::AliTOFHitField(const AliTOFHitField &source) :
+ fIndex(source.fIndex),
+ fTimeBin(source.fTimeBin),
+ fTOTBin(source.fTOTBin),
+ fDeltaBC(source.fDeltaBC),
+ fL0L1Latency(source.fL0L1Latency)
+{
+ /*
+ * default constructor
+ */
+}
+
+//-----------------------------------------------------------------------------
+
+AliTOFHitField &
+AliTOFHitField::operator=(const AliTOFHitField &source)
+{
+ /*
+ * operator=
+ */
+
+ if(this==&source) return *this;
+ fIndex = source.fIndex;
+ fTimeBin = source.fTimeBin;
+ fTOTBin = source.fTOTBin;
+ fDeltaBC = source.fDeltaBC;
+ fL0L1Latency =source.fL0L1Latency;
+ return *this;
+}
+
--- /dev/null
+#ifndef ALITOFHITFIELD_H
+#define ALITOFHITFIELD_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+///////////////////////////////////////////////////////////////
+// //
+// This class provides the minimum-size TOF hit info //
+// //
+// author: Roberto Preghenella (R+) //
+// preghenella@bo.infn.it //
+// //
+///////////////////////////////////////////////////////////////
+
+#include "TROOT.h"
+
+class AliTOFHitField
+{
+
+ public:
+
+ AliTOFHitField(); // default constructor
+ virtual ~AliTOFHitField(); // default destructor
+ AliTOFHitField(const AliTOFHitField &source); // copy constructor
+ AliTOFHitField &operator=(const AliTOFHitField &source); // operator=
+
+ UInt_t GetIndex() const {return fIndex;}; // get index
+ UShort_t GetTimeBin() const {return fTimeBin;}; // get time bin
+ UShort_t GetTOTBin() const {return fTOTBin;}; // get TOT bin
+ UChar_t GetDeltaBC() const {return fDeltaBC;}; // get delta BC
+ UShort_t GetL0L1Latency() const {return fL0L1Latency;}; // get L0-L1 latency
+
+ void SetIndex(UInt_t value) {fIndex = value;}; // set index
+ void SetTimeBin(UShort_t value) {fTimeBin = value;}; // set time bin
+ void SetTOTBin(UShort_t value) {fTOTBin = value;}; // set TOT bin
+ void SetDeltaBC(UChar_t value) {fDeltaBC = value;}; // set delta BC
+ void SetL0L1Latency(UShort_t value) {fL0L1Latency = value;}; // set L0-L1 latency
+
+ private:
+
+ UInt_t fIndex; // channel index
+ UShort_t fTimeBin; // time bin [24.4 ps]
+ UShort_t fTOTBin; // TOT bin [48.8 ps]
+ UChar_t fDeltaBC; // delta BC [BC bins]
+ UShort_t fL0L1Latency; // L0-L1 latency [BC bins]
+
+ ClassDef(AliTOFHitField, 1);
+};
+
+#endif /* ALITOFHITFIELD_H */
AliDebug(1,Form(" Number of LV dps = %d",fNumberOfLVdataPoints));
if (!MergeHVmap()) return kFALSE;
+ if (fNumberOfLVdataPoints==0) return kFALSE;
if (!MergeLVmap()) return kFALSE;
if (!MergeMaps()) return kFALSE;
}
}
+ if (fNumberOfHVdataPoints==0) {
+ AliInfo("Valid LV dps not found. By default all HV TOF channels (except the ones in the PHOS holes) switched ON.");
+ for (int i=0; i<kNsectors; i++)
+ for (int j=0; j<kNplates; j++) {
+ for (Int_t iBin=0; iBin<kNpads; iBin++) dummy[iBin]=-1;
+ if ( (i==13 || i==14 || i==15) && j==2) {
+ FillHVarrayPerDataPoint(i,j,0,dummy);
+ AliTOFDCSmaps *object = new AliTOFDCSmaps(0,dummy);
+ InsertHVDataPoint(object);
+ }
+ else {
+ FillHVarrayPerDataPoint(i,j,1,dummy);
+ AliTOFDCSmaps *object = new AliTOFDCSmaps(0,dummy);
+ InsertHVDataPoint(object);
+ }
+ }
+
+ for (int i=0; i<kNsectors; i++)
+ for (int j=0; j<kNplates; j++) {
+ for (Int_t iBin=0; iBin<kNpads; iBin++) dummy[iBin]=-1;
+ if ( (i==13 || i==14 || i==15) && j==2) {
+ FillHVarrayPerDataPoint(i,j,0,dummy);
+ AliTOFDCSmaps *object = new AliTOFDCSmaps(999999,dummy);
+ InsertHVDataPoint(object);
+ }
+ else {
+ FillHVarrayPerDataPoint(i,j,1,dummy);
+ AliTOFDCSmaps *object = new AliTOFDCSmaps(999999,dummy);
+ InsertHVDataPoint(object);
+ }
+ }
+ }
+
return kTRUE;
}
}
}
+ if (fNumberOfLVdataPoints==0) {
+ AliInfo("Valid LV dps not found. By default all LV TOF channels switched ON.");
+ for (int i=0; i<kNddl; i++) {
+ for (Int_t iBin=0; iBin<kNpads; iBin++) dummy[iBin]=-1;
+ FillLVarrayPerDataPoint(i,0,dummy);
+ AliTOFDCSmaps *object = new AliTOFDCSmaps(0,dummy);
+ InsertLVDataPoint(object);
+ }
+
+ for (int i=0; i<kNddl; i++) {
+ for (Int_t iBin=0; iBin<kNpads; iBin++) dummy[iBin]=-1;
+ FillLVarrayPerDataPoint(i,0,dummy);
+ AliTOFDCSmaps *object = new AliTOFDCSmaps(999999,dummy);
+ InsertLVDataPoint(object);
+ }
+
+ }
+
return kTRUE;
}
#include "AliTOFCableLengthMap.h"
#include "AliTOFcalibHisto.h"
#include "AliTOFFEEDump.h"
-
+#include "TChain.h"
+#include "AliTOFDeltaBCOffset.h"
+#include "AliTOFCTPLatency.h"
+#include "AliTOFT0Fill.h"
+#include "AliTOFT0FillOnlineCalib.h"
+#include "AliTOFHitField.h"
+#include "AliTOFChannelOffline.h"
+#include "TF1.h"
+#include "TGeoManager.h"
+#include "AliGeomManager.h"
// TOF preprocessor class.
// It takes data from DCS and passes them to the class AliTOFDataDCS, which
}
//_____________________________________________________________________________
-UInt_t AliTOFPreprocessor::ProcessDCSDataPoints(TMap * const dcsAliasMap)
+UInt_t AliTOFPreprocessor::ProcessDCSDataPoints(TMap *dcsAliasMap)
{
// Fills data into a AliTOFDataDCS object
}
//_____________________________________________________________________________
-UInt_t AliTOFPreprocessor::ProcessHVandLVdps(TMap * const dcsAliasMap)
+UInt_t AliTOFPreprocessor::ProcessHVandLVdps(TMap *dcsAliasMap)
{
//
//Fills data into a AliTOFLvHvDataPoints object
fIsStatusMapChanged=kTRUE;
}
}
-
+
// check with plots. Start...
/*
for (Int_t ii=0; ii<91*96*18; ii++) {
return 0;
}
+
//_____________________________________________________________________________
UInt_t AliTOFPreprocessor::ProcessOnlineDelays()
return 0;
}
+
+//_____________________________________________________________________________
+
+UInt_t
+AliTOFPreprocessor::ProcessT0Fill()
+{
+ // Processing data from DAQ for T0-fill measurement
+
+ Log("Processing T0-fill");
+
+#if 0
+ /* instance and setup CDB manager */
+ AliCDBManager *cdb = AliCDBManager::Instance();
+ /* load geometry */
+ if (!gGeoManager) AliGeomManager::LoadGeometry();
+#endif
+
+ /* get params from OCDB */
+ AliCDBEntry *cdbe = NULL;
+
+ /* get T0-fill calibration params */
+ cdbe = GetFromOCDB("Calib", "T0FillOnlineCalib");
+ if (!cdbe) {
+ Log("cannot get \"T0FillOnlineCalib\" entry from OCDB");
+ return 21;
+ }
+ AliTOFT0FillOnlineCalib *t0FillOnlineCalibObject = (AliTOFT0FillOnlineCalib *)cdbe->GetObject();
+ if (!t0FillOnlineCalibObject) {
+ Log("cannot get \"T0FillOnlineCalib\" object from CDB entry");
+ return 21;
+ }
+ Float_t t0FillCalibOffset = t0FillOnlineCalibObject->GetOffset();
+ Float_t t0FillCalibCoefficient = t0FillOnlineCalibObject->GetCoefficient();
+ Log(Form("got \"T0FillOnlineCalib\" object: offset=%f coeff=%f", t0FillCalibOffset, t0FillCalibCoefficient));
+
+ /* get online status from OCDB */
+ cdbe = GetFromOCDB("Calib", "Status");
+ if (!cdbe) {
+ Log("cannot get \"Status\" entry from OCDB");
+ return 21;
+ }
+ AliTOFChannelOnlineStatusArray *statusArray = (AliTOFChannelOnlineStatusArray *)cdbe->GetObject();
+ if (!statusArray) {
+ Log("cannot get \"Status\" object from CDB entry");
+ return 21;
+ }
+ Log("got \"Status\" object");
+
+ /* get offline calibration from OCDB */
+ cdbe = GetFromOCDB("Calib", "ParOffline");
+ if (!cdbe) {
+ Log("cannot get \"ParOffline\" entry from OCDB");
+ return 21;
+ }
+ TObjArray *offlineArray = (TObjArray *)cdbe->GetObject();
+ AliTOFChannelOffline *channelOffline;
+ if (!offlineArray) {
+ Log("cannot get \"ParOffline\" object from CDB entry");
+ return 21;
+ }
+ Log("got \"ParOffline\" object");
+
+ /* get deltaBC offset from OCDB */
+ cdbe = GetFromOCDB("Calib", "DeltaBCOffset");
+ if (!cdbe) {
+ Log("cannot get \"DeltaBCOffset\" entry from OCDB");
+ return 21;
+ }
+ AliTOFDeltaBCOffset *deltaBCOffsetObject = (AliTOFDeltaBCOffset *)cdbe->GetObject();
+ if (!deltaBCOffsetObject) {
+ Log("cannot get \"DeltaBCOffset\" object from CDB entry");
+ return 21;
+ }
+ Int_t deltaBCOffset = deltaBCOffsetObject->GetDeltaBCOffset();
+ Log(Form("got \"DeltaBCOffset\" object: deltaBCOffset=%d (BC bins)", deltaBCOffset));
+
+ /* get CTP latency from OCDB */
+ cdbe = GetFromOCDB("Calib", "CTPLatency");
+ if (!cdbe) {
+ Log("cannot get \"CTPLatency\" entry from OCDB");
+ return 21;
+ }
+ AliTOFCTPLatency *ctpLatencyObject = (AliTOFCTPLatency *)cdbe->GetObject();
+ if (!ctpLatencyObject) {
+ Log("cannot get \"CTPLatency\" object from CDB entry");
+ return 21;
+ }
+ Float_t ctpLatency = ctpLatencyObject->GetCTPLatency();
+ Log(Form("got \"CTPLatency\" object: ctpLatency=%f (ps)", ctpLatency));
+
+ /* get file sources from FXS */
+ TList *fileList = GetFileSources(kDAQ, "HITS");
+ if (!fileList || fileList->GetEntries() == 0) {
+ Log("cannot get DAQ source file list or empty list");
+ return 21;
+ }
+ Log(Form("got DAQ source file list: %d files", fileList->GetEntries()));
+ fileList->Print();
+
+ /* create tree chain using file sources */
+ TChain chain("hitTree");
+ for (Int_t ifile = 0; ifile < fileList->GetEntries(); ifile++) {
+ TObjString *str = (TObjString *)fileList->At(ifile);
+ TString filename = GetFile(kDAQ, "HITS", str->GetName());
+ chain.Add(filename);
+ Log(Form("file added to input chain: source=%s, filename=%s", str->String().Data(), filename.Data()));
+ }
+ Int_t nhits = chain.GetEntries();
+ Log(Form("input chain ready: %d hits", nhits));
+
+ /* setup input chain */
+ AliTOFHitField *hit = new AliTOFHitField();
+ chain.SetBranchAddress("hit", &hit);
+
+ /* create calib histo and geometry */
+ AliTOFcalibHisto calibHisto;
+ calibHisto.LoadCalibHisto();
+ AliTOFGeometry tofGeo;
+
+ /* constants */
+ Float_t c = TMath::C() * 1.e2 / 1.e12; /* cm/ps */
+ Float_t c_1 = 1. / c;
+ /* variables */
+ Int_t index, timebin, totbin, deltaBC, l0l1latency, det[5];
+ Float_t timeps, totns, corrps, length, timeexp, timezero, pos[3], latencyWindow;
+
+ /* histos */
+ TH1F *hT0Fill = new TH1F("hT0Fill", "T0 fill;t - t_{exp}^{(c)} (ps);", 2000, -24400., 24400.);
+
+ /* loop over hits */
+ for (Int_t ihit = 0; ihit < nhits; ihit++) {
+
+ /* get entry */
+ chain.GetEntry(ihit);
+
+ /* get hit info */
+ index = hit->GetIndex();
+ timebin = hit->GetTimeBin();
+ totbin = hit->GetTOTBin();
+ deltaBC = hit->GetDeltaBC();
+ l0l1latency = hit->GetL0L1Latency();
+ latencyWindow = statusArray->GetLatencyWindow(index) * 1.e3;
+
+ /* convert time in ps and tot in ns */
+ timeps = timebin * AliTOFGeometry::TdcBinWidth();
+ totns = totbin * AliTOFGeometry::ToTBinWidth() * 1.e-3;
+ /* get calibration correction in ps */
+ channelOffline = (AliTOFChannelOffline *)offlineArray->At(index);
+ if (totns < AliTOFGeometry::SlewTOTMin()) totns = AliTOFGeometry::SlewTOTMin();
+ if (totns > AliTOFGeometry::SlewTOTMax()) totns = AliTOFGeometry::SlewTOTMax();
+ corrps = 0.;
+ for (Int_t ipar = 0; ipar < 6; ipar++) corrps += channelOffline->GetSlewPar(ipar) * TMath::Power(totns, ipar);
+ corrps *= 1.e3;
+ /* perform time correction */
+ timeps = timeps + (deltaBC - deltaBCOffset) * AliTOFGeometry::BunchCrossingBinWidth() + l0l1latency * AliTOFGeometry::BunchCrossingBinWidth() + ctpLatency - latencyWindow - corrps;
+ /* compute length and expected time */
+ tofGeo.GetVolumeIndices(index, det);
+ tofGeo.GetPosPar(det, pos);
+ length = 0.;
+ for (Int_t i = 0; i < 3; i++) length += pos[i] * pos[i];
+ length = TMath::Sqrt(length);
+ timeexp = length * c_1;
+ /* compute time zero */
+ timezero = timeps - timeexp;
+
+ /* fill histos */
+ hT0Fill->Fill(timezero);
+ }
+
+ /* rebin until maximum bin has required minimum entries */
+ Int_t maxBin = hT0Fill->GetMaximumBin();
+ Int_t maxBinContent = hT0Fill->GetBinContent(maxBin);
+ Float_t binWidth = hT0Fill->GetBinWidth(maxBin);
+ while (maxBinContent < 400 && binWidth < 90.) {
+ hT0Fill->Rebin(2);
+ maxBin = hT0Fill->GetMaximumBin();
+ maxBinContent = hT0Fill->GetBinContent(maxBin);
+ binWidth = hT0Fill->GetBinWidth(maxBin);
+ }
+ Float_t maxBinCenter = hT0Fill->GetBinCenter(maxBin);
+
+ /* rough landau fit of the edge */
+ TF1 *landau = (TF1 *)gROOT->GetFunction("landau");
+ landau->SetParameter(1, maxBinCenter);
+ Float_t fitMin = maxBinCenter - 1000.; /* fit from 10 ns before max */
+ Float_t fitMax = maxBinCenter + binWidth; /* fit until a bin width above max */
+ hT0Fill->Fit("landau", "q0", "", fitMin, fitMax);
+ /* get rough landau mean and sigma to set a better fit range */
+ Float_t mean = landau->GetParameter(1);
+ Float_t sigma = landau->GetParameter(2);
+ /* better landau fit of the edge */
+ fitMin = maxBinCenter - 3. * sigma;
+ fitMax = mean;
+ hT0Fill->Fit("landau", "q0", "", fitMin, fitMax);
+ /* print params */
+ mean = landau->GetParameter(1);
+ sigma = landau->GetParameter(2);
+ Float_t meane = landau->GetParError(1);
+ Float_t sigmae = landau->GetParError(2);
+ Log(Form("edge fit: mean = %f +- %f ps", mean, meane));
+ Log(Form("edge fit: sigma = %f +- %f ps", sigma, sigmae));
+ Float_t edge = mean - 3. * sigma;
+ Float_t edgee = TMath::Sqrt(meane * meane + 3. * sigmae * 3. * sigmae);
+ Log(Form("edge fit: edge = %f +- %f ps", edge, edgee));
+ /* apply calibration to get T0-fill from egde */
+ Float_t t0Fill = edge * t0FillCalibCoefficient + t0FillCalibOffset;
+ Log(Form("estimated T0-fill: %f ps", t0Fill));
+
+ /* create T0-fill object */
+ AliTOFT0Fill *t0FillObject = new AliTOFT0Fill();
+ t0FillObject->SetT0Fill(t0Fill);
+
+ /* store reference data */
+ if(fStoreRefData){
+ AliCDBMetaData metaDataHisto;
+ metaDataHisto.SetBeamPeriod(0);
+ metaDataHisto.SetResponsible("Roberto Preghenella");
+ metaDataHisto.SetComment("online T0-fill histogram");
+ if (!StoreReferenceData("Calib","T0Fill", hT0Fill, &metaDataHisto)) {
+ Log("error while storing reference data");
+ delete hT0Fill;
+ delete hit;
+ delete t0FillObject;
+ return 21;
+ }
+ Log("reference data successfully stored");
+ }
+
+ AliCDBMetaData metaData;
+ metaData.SetBeamPeriod(0);
+ metaData.SetResponsible("Roberto Preghenella");
+ metaData.SetComment("online T0-fill measurement");
+ if (!Store("Calib", "T0Fill", t0FillObject, &metaData, 0, kFALSE)) {
+ Log("error while storing T0-fill object");
+ delete hT0Fill;
+ delete hit;
+ delete t0FillObject;
+ return 21;
+ }
+ Log("T0-fill object successfully stored");
+
+ delete hT0Fill;
+ delete hit;
+ delete t0FillObject;
+ return 0;
+
+}
+
+
//_____________________________________________________________________________
UInt_t AliTOFPreprocessor::ProcessPulserData()
//_____________________________________________________________________________
-UInt_t AliTOFPreprocessor::Process(TMap * const dcsAliasMap)
+UInt_t AliTOFPreprocessor::Process(TMap *dcsAliasMap)
{
//
// Main AliTOFPreprocessor method called by SHUTTLE
Int_t iresultNoise = ProcessNoiseData();
return iresultNoise;
}
-
+
if (runType == "PHYSICS") {
- Int_t iresultDAQ = ProcessOnlineDelays();
+ // Int_t iresultDAQ = ProcessOnlineDelays();
+ Int_t iresultDAQ = ProcessT0Fill();
if (iresultDAQ != 0) {
return iresultDAQ;
}
protected:
virtual void Initialize(Int_t run, UInt_t startTime, UInt_t endTime);
- virtual UInt_t Process(TMap * const dcsAliasMap);
+ virtual UInt_t Process(TMap *dcsAliasMap);
virtual Bool_t ProcessDCS();
private:
AliTOFPreprocessor(const AliTOFPreprocessor & proc); // copy constructor
AliTOFPreprocessor& operator=(const AliTOFPreprocessor & proc);
- UInt_t ProcessDCSDataPoints(TMap * const dcsAliasMap);
- UInt_t ProcessHVandLVdps(TMap * const dcsAliasMap);
+ UInt_t ProcessDCSDataPoints(TMap *dcsAliasMap);
+ UInt_t ProcessHVandLVdps(TMap *dcsAliasMap);
UInt_t ProcessOnlineDelays();
UInt_t ProcessPulserData();
UInt_t ProcessNoiseData();
UInt_t ProcessFEEData(); // dummy, for the time being
+ UInt_t ProcessT0Fill();
void FillWithCosmicCalibration(AliTOFChannelOnlineArray *cal); // fill with cosmic calibration
void FillWithCableLengthMap(AliTOFChannelOnlineArray *cal); // fill with cable-lenght map
--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+/*
+ *
+ *
+ * this class defines the T0Fill online calibration object to be stored
+ * in OCDB in order to obtain a corrected T0Fill from online algorithm
+ *
+ *
+ */
+
+#include "AliTOFT0FillOnlineCalib.h"
+
+ClassImp(AliTOFT0FillOnlineCalib)
+
+//_________________________________________________________
+
+AliTOFT0FillOnlineCalib::AliTOFT0FillOnlineCalib() :
+ TObject(),
+ fOffset(0.),
+ fCoefficient(0.)
+{
+ /*
+ * default constructor
+ */
+}
+
+//_________________________________________________________
+
+AliTOFT0FillOnlineCalib::~AliTOFT0FillOnlineCalib()
+{
+ /*
+ * default destructor
+ */
+}
+
+//_________________________________________________________
+
+AliTOFT0FillOnlineCalib::AliTOFT0FillOnlineCalib(const AliTOFT0FillOnlineCalib &source) :
+ TObject(source),
+ fOffset(source.fOffset),
+ fCoefficient(source.fCoefficient)
+{
+ /*
+ * copy constructor
+ */
+}
+
+//_________________________________________________________
+
+AliTOFT0FillOnlineCalib &
+AliTOFT0FillOnlineCalib::operator=(const AliTOFT0FillOnlineCalib &source)
+{
+ /*
+ * operator=
+ */
+
+ if (this == &source) return *this;
+ TObject::operator=(source);
+ fOffset = source.fOffset;
+ fCoefficient = source.fCoefficient;
+ return *this;
+}
+
--- /dev/null
+#ifndef ALITOFT0FILLONLINECALIB_H
+#define ALITOFT0FILLONLINECALIB_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+/* $Id$ */
+
+/*
+ *
+ *
+ * this class defines the T0Fill online calibration object to be stored
+ * in OCDB in order to obtain a corrected T0Fill from online algorithm
+ *
+ *
+ *
+ */
+
+#include "TObject.h"
+
+class AliTOFT0FillOnlineCalib :
+public TObject
+{
+
+ public:
+
+ AliTOFT0FillOnlineCalib(); // default constructor
+ virtual ~AliTOFT0FillOnlineCalib(); // default destructor
+ AliTOFT0FillOnlineCalib(const AliTOFT0FillOnlineCalib &source); // copy constructor
+ AliTOFT0FillOnlineCalib &operator=(const AliTOFT0FillOnlineCalib &source); // operator=
+ Float_t GetOffset() const {return fOffset;}; // getter
+ Float_t GetCoefficient() const {return fCoefficient;}; // getter
+ void SetOffset(Float_t value) {fOffset = value;}; // setter
+ void SetCoefficient(Float_t value) {fCoefficient = value;}; // setter
+
+ private:
+
+ Float_t fOffset; // offset (ps)
+ Float_t fCoefficient; // coefficient
+
+ ClassDef(AliTOFT0FillOnlineCalib, 1);
+};
+
+#endif /* ALITOFT0FILLOnlineCalib_H */
calibHisto.SetFullCorrectionFlag(AliTOFcalibHisto::kTimeSlewingCorr, kFALSE);
/* OCDB init */
+ Float_t slewPar[6] = {0.,0.,0.,0.,0.,0.};
Float_t par[6] = {0.,0.,0.,0.,0.,0.};
AliCDBManager *man = AliCDBManager::Instance();
man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
Int_t nChannels = AliTOFGeometry::NSectors()*(2*(AliTOFGeometry::NStripC()+AliTOFGeometry::NStripB())+AliTOFGeometry::NStripA())*AliTOFGeometry::NpadZ()*AliTOFGeometry::NpadX();
/* common time-slewing params */
- for (Int_t iSlew = 1; iSlew < 6; iSlew++)
- par[iSlew] = calibHisto.GetCalibPar(AliTOFcalibHisto::kTimeSlewingPar, iSlew);
+ for (Int_t iSlew = 0; iSlew < 6; iSlew++)
+ slewPar[iSlew] = calibHisto.GetCalibPar(AliTOFcalibHisto::kTimeSlewingPar, iSlew);
/* channel-related params */
for (Int_t ipad = 0 ; ipad<nChannels; ipad++){
AliTOFChannelOffline *calChannelOffline = (AliTOFChannelOffline*)tofCalOffline->At(ipad);
- par[0] = calibHisto.GetFullCorrection(ipad);
+ par[0] = slewPar[0] + calibHisto.GetFullCorrection(ipad);
+ par[1] = slewPar[1];
+ par[2] = slewPar[2];
+ par[3] = slewPar[3];
+ par[4] = slewPar[4];
+ par[5] = slewPar[5];
calChannelOffline->SetSlewPar(par);
}
--- /dev/null
+MakeCDBEntryT0FillOnlineCalib(Float_t offset = 0., Float_t coefficient = 0., Int_t startRun = 0, Int_t endRun = AliCDBRunRange::Infinity())
+{
+
+ /* create object */
+ AliTOFT0FillOnlineCalib *obj = new AliTOFT0FillOnlineCalib();
+ obj->SetOffset(offset);
+ obj->SetCoefficient(coefficient);
+
+ /* create cdb info */
+ AliCDBId id("TOF/Calib/T0FillOnlineCalib", startRun, endRun);
+ AliCDBMetaData *md = new AliCDBMetaData();
+ md->SetResponsible("Roberto Preghenella");
+ md->SetComment("Online T0-fill calibration parameters");
+ md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
+ md->SetBeamPeriod(0);
+
+ /* put object in cdb */
+ AliCDBManager *cdb = AliCDBManager::Instance();
+ cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
+ cdb->GetDefaultStorage()->Put(obj, id, md);
+
+}
<!DOCTYPE TOFConfig [
<!ELEMENT TOFConfig (Folder)>
<!ELEMENT Folder EMPTY>
-<!ATTLIST Folder DebugFlag CDATA #REQUIRED>
-<!ATTLIST Folder t0Flag CDATA #REQUIRED>
+<!ATTLIST Folder MeanMultiplicity CDATA #REQUIRED>
+<!ATTLIST Folder MaxMits CDATA #REQUIRED>
]>
<TOFConfig>
-<Folder DebugFlag="2" t0Flag="On">
+<Folder MeanMultiplicity="20" MaxHits="10000000">
</Folder>
</TOFConfig>
AliTestShuttle::SetMainRefStorage("local://$ALICE_ROOT/OCDB/SHUTTLE/TestShuttle/TestReference");
// create AliTestShuttle instance
- Int_t nrun = 7;
+ Int_t nrun = 104892;
AliTestShuttle* shuttle = new AliTestShuttle(nrun, 30, 980);
//setting run type to physiscs
shuttle->SetInputRunType(RunType);
shuttle->SetDCSInput(dcsAliasMap);
// processing files. for the time being, the files are local.
+ shuttle->AddInputFile(AliTestShuttle::kDAQ, "TOF", "HITS", "MON", "$ALICE_ROOT/TOF/ShuttleInput/Hits.root");
shuttle->AddInputFile(AliTestShuttle::kDAQ, "TOF", "DELAYS", "MON", "$ALICE_ROOT/TOF/ShuttleInput/Total.root");
shuttle->AddInputFile(AliTestShuttle::kDAQ, "TOF", "RUNLevel", "MON", "$ALICE_ROOT/TOF/ShuttleInput/Partial.root");
shuttle->AddInputFile(AliTestShuttle::kDCS, "TOF", "TofFeeLightMap", "", "$ALICE_ROOT/TOF/ShuttleInput/TOFFEElight.20090616.102605.8000");
gBenchmark->Stop("process");
gBenchmark->Print("process");
- // checking the file which should have been created
- AliCDBEntry* chkEntry = AliCDBManager::Instance()->GetStorage(AliShuttleInterface::GetMainCDB())->Get("TOF/Calib/ParOnlineDelay", nrun);
- if (!chkEntry)
- {
- printf("The file is not there. Something went wrong.\n");
- return;
- }
-
- AliTOFDataDCS* output = dynamic_cast<AliTOFDataDCS*> (chkEntry->GetObject());
- // If everything went fine, draw the result
- if (output)
- printf("Output found.\n");
- // output->Draw();
}
+
TMap* CreateDCSAliasMap()
{
// Creates a DCS structure
aliasMap->SetOwner(1);
TRandom random;
+ /*
TDatime *datime = new TDatime();
Int_t time = datime->GetTime();
Int_t date = datime->GetDate();
Int_t pid = gSystem->GetPid();
delete datime;
Int_t iseed = TMath::Abs(10000 * pid + time - date);
+ */
- //Float_t thrHVv=7.75, thrHVc=3, thrLVv=2.75, thrLVc=2.5,
- //thrFEEthr=1.5, thrFEEt=10, thrTemp=35, thrPress=1000;
- //Float_t tentHVv=6.75, tentHVc=2, tentLVv=1.75, tentLVc=1.5,
- // tentFEEthr=0.5, te result=0;
- //ntFEEt=20, tentTemp=25, tentPress=900;
- //Float_t sigmaHVv=1, sigmaHVc=0.25, sigmaLVv=0.25, sigmaLVc=0.25,
- // sigmaFEEthr=0.05, sigmaFEEt=5, sigmaTemp=1, sigmaPress=10;
Float_t tentHVv=6500, tentHVi=80;
Float_t sigmaHVv=10, sigmaHVi=10;
- Float_t tent=0, sigma=0, thr=0;
+ Float_t tent=0, sigma=0;//, thr=0;
// to have all the aliases, decomment the following line:
Int_t NAliases=360, NHV=90;
+
// if not all the aliases are there, use this:
//Int_t NAliases=120, NHV=90;
+ TString sindex;
+ TString aliasName;
+
for(int nAlias=0;nAlias<NAliases;nAlias++) {
TObjArray* valueSet = new TObjArray;
valueSet->SetOwner(1);
- TString sindex;
- TString aliasName;
if (nAlias<NHV){
aliasName = "tof_hv_vp_";
sindex.Form("%02i",nAlias);
//thr=-thrHVc;
}
// gauss generation of values
- for (int timeStamp=0;timeStamp<1000;timeStamp+=10){
+ for (int timeStamp=0;timeStamp<6000;timeStamp+=10){
//for (int timeStamp=0;timeStamp<1;timeStamp++){
Float_t gaussvalue = (Float_t) (random.Gaus(tent,sigma));
if (TMath::Abs(gaussvalue-tent)>sigma){
}
aliasMap->Add(new TObjString(aliasName), valueSet);
+
+ }
+
+
+
+
+ const Int_t kNsectors = 18;
+ const Int_t kNplates = 5;
+
+ UInt_t baseWord = 0;
+ UInt_t oldBaseWord = 0;
+
+ for(int i=0;i<kNsectors;i++)
+ for(int j=0;j<kNplates;j++) {
+
+ TObjArray* valueSetHV = new TObjArray;
+ valueSetHV->SetOwner(1);
+
+ aliasName = "TOF_HVSTATUS_";
+ sindex.Form("SM%02dMOD%1d",i,j);
+ aliasName += sindex;
+
+
+ //for (int timeStamp=0;timeStamp<6000;timeStamp+=600) {
+ for (int timeStamp=0;timeStamp<1201;timeStamp+=600) {
+ if (timeStamp==0 /*|| timeStamp==1200*/) {
+ baseWord = CreateHVword(i,j, kTRUE);
+ oldBaseWord = baseWord;
+ AliDCSValue* dcsVal = new AliDCSValue(baseWord, timeStamp);
+ valueSetHV->Add(dcsVal);
+ }
+ else {
+ if (random.Uniform(0.,1.)>=0.5) {
+ baseWord = CreateHVword(i,j, kFALSE);
+ if (baseWord<=oldBaseWord) {
+ oldBaseWord = baseWord;
+ AliDCSValue* dcsVal = new AliDCSValue(baseWord, timeStamp);
+ valueSetHV->Add(dcsVal);
+ }
+ else {
+ AliDCSValue* dcsVal = new AliDCSValue(oldBaseWord, timeStamp);
+ valueSetHV->Add(dcsVal);
+ }
+ //Info(Form(" %2d %1d %s %d %d",i,j,aliasName,timeStamp,baseWord));
+ }
+ }
+ }
+
+ /*
+ baseWord = CreateHVword(i,j, kTRUE);
+ AliDCSValue* dcsVal0 = new AliDCSValue(baseWord, 0);
+ valueSetHV->Add(dcsVal0);
+
+ if ((i==0 && j==2) || (i==9 && j==4)) {
+ baseWord = CreateHVword(i,j, kFALSE);
+ AliDCSValue* dcsVal1 = new AliDCSValue(baseWord, 600);
+ valueSetHV->Add(dcsVal1);
+ }
+
+ baseWord = CreateHVword(i,j, kTRUE);
+ AliDCSValue* dcsVal2 = new AliDCSValue(baseWord, 1200);
+ valueSetHV->Add(dcsVal2);
+ */
+
+ aliasMap->Add(new TObjString(aliasName), valueSetHV);
+
+ }
+
+
+ const Int_t kNddl = 72;
+ baseWord = 0;
+ oldBaseWord = 0;
+
+ for(int i=0;i<kNddl;i++) {
+
+ TObjArray* valueSetLV = new TObjArray;
+ valueSetLV->SetOwner(1);
+
+ aliasName = "TOF_FEACSTATUS_";
+ sindex.Form("%02d",i);
+ aliasName += sindex;
+
+
+ //for (int timeStamp=0;timeStamp<6000;timeStamp+=600) {
+ for (int timeStamp=0;timeStamp<1201;timeStamp+=400) {
+ if (timeStamp==0 /*|| timeStamp==1200*/) {
+ baseWord = CreateLVword(kTRUE);
+ AliDCSValue* dcsVal = new AliDCSValue(baseWord, timeStamp);
+ valueSetLV->Add(dcsVal);
+ oldBaseWord = baseWord;
+ //Info(Form(" %2d %s %d %d",i,aliasName,timeStamp,baseWord));
+ }
+ else {
+ if (random.Uniform(0.,1.)>=0.5) {
+ baseWord = CreateLVword(kFALSE);
+ if (baseWord<=oldBaseWord) {
+ oldBaseWord = baseWord;
+ AliDCSValue* dcsVal = new AliDCSValue(baseWord, timeStamp);
+ valueSetLV->Add(dcsVal);
+ }
+ else {
+ AliDCSValue* dcsVal = new AliDCSValue(oldBaseWord, timeStamp);
+ valueSetLV->Add(dcsVal);
+ }
+ //Info(Form(" %2d %1d %s %d %d",i,j,aliasName,timeStamp,baseWord));
+ }
+ }
+ }
+
+ /*
+ baseWord = CreateLVword(kTRUE);
+ AliDCSValue* dcsVal0 = new AliDCSValue(baseWord, 0);
+ valueSetLV->Add(dcsVal0);
+
+ if (i==7 || i==9) {
+ baseWord = CreateLVword(kFALSE);
+ AliDCSValue* dcsVal1 = new AliDCSValue(baseWord, 400);
+ valueSetLV->Add(dcsVal1);
+ }
+ else if (i==50 || i==35) {
+ baseWord = CreateLVword(kFALSE);
+ AliDCSValue* dcsVal2 = new AliDCSValue(baseWord, 800);
+ valueSetLV->Add(dcsVal2);
+ }
+
+ baseWord = CreateLVword(kTRUE);
+ AliDCSValue* dcsVal3 = new AliDCSValue(baseWord, 1200);
+ valueSetLV->Add(dcsVal3);
+ */
+
+ aliasMap->Add(new TObjString(aliasName), valueSetLV);
+
}
+
return aliasMap;
}
+
+UInt_t CreateHVword(Int_t nSector, Int_t nPlate, Bool_t isAtBorder) {
+ //
+ //
+ //
+
+ UInt_t baseWord = 0;
+ UInt_t word = 0;
+ TRandom random;
+
+ for (Int_t iStrip=0; iStrip<AliTOFGeometry::NStrip(nPlate); iStrip++) {
+
+ if (isAtBorder) {
+ word = 1;
+ if (nPlate==2 && nSector>=13 && nSector<=15)
+ word = 0;
+ }
+ else {
+ random.Uniform(0.,1.)<0.5 ? word = 0 : word = 1;
+ if (nPlate==2 && nSector>=13 && nSector<=15)
+ word = 0;
+ word = 0;
+ }
+
+ AliBitPacking::PackWord(word,baseWord,iStrip,iStrip);
+ }
+
+ return baseWord;
+
+}
+
+
+UInt_t CreateLVword(Bool_t isAtBorder) {
+ //
+ //
+ //
+
+ UInt_t baseWord = 0;
+ UInt_t word = 0;
+ TRandom random;
+
+ for (Int_t iFeac=0; iFeac<8; iFeac++) {
+
+ if (isAtBorder)
+ word = 1;
+ else {
+ random.Uniform(0.,1.)<0.5 ? word = 0 : word = 1;
+ word = 0;
+ }
+
+ AliBitPacking::PackWord(word,baseWord,iFeac,iFeac);
+ }
+
+ return baseWord;
+
+}
+
+
TMap* ReadDCSAliasMap()
{
// Open a file that contains DCS input data
AliCDBManager::Instance()->Put(dcsAliasMap, id, &metaData);
}
+
+
+++ /dev/null
-/*
-$Id: TOFPreprocessor.C 38207 2010-01-13 14:08:33Z rpreghen $
-*/
-
-// This class runs the test TOF preprocessor
-// It uses AliTestShuttle to simulate a full Shuttle process
-
-// The input data is created in the functions
-// CreateDCSAliasMap() creates input that would in the same way come from DCS
-// ReadDCSAliasMap() reads from a file
-// CreateInputFilesMap() creates a list of local files, that can be accessed by the shuttle
-
-
-#ifndef __CINT__
-#include "TDatime.h"
-#include "TMap.h"
-#include "TFile.h"
-#include "TObjString.h"
-#include "TRandom.h"
-#include "TBenchmark.h"
-#include "TString.h"
-
-#include "AliBitPacking.h"
-#include "AliCDBEntry.h"
-#include "AliCDBManager.h"
-#include "AliCDBStorage.h"
-#include "AliDCSValue.h"
-#include "AliLog.h"
-#include "AliTestShuttle.h"
-#include "AliShuttleInterface.h"
-
-#include "AliTOFDataDCS.h"
-#include "AliTOFPreprocessor.h"
-#include "AliTOFGeometry.h"
-//#include "AliTOFChannelOnlineArray.h"
-#endif
-
-void TOFPreprocessorLVHV(Char_t * RunType="PHYSICS");
-TMap* CreateDCSAliasMap();
-TMap* ReadDCSAliasMap();
-//TMap* CreateInputFilesMap();
-UInt_t CreateHVword(Int_t sec, Int_t pla, Bool_t isAtBorder);
-UInt_t CreateLVword(Bool_t isAtBorder);
-
-
-
-extern TBenchmark *gBenchmark;
-void TOFPreprocessorLVHV(Char_t * RunType)
-{
- gSystem->Load("$ALICE_ROOT/SHUTTLE/TestShuttle/libTestShuttle.so");
-
- AliLog::SetClassDebugLevel("AliTOFPreprocessor",2);
- // initialize location of CDB
- AliTestShuttle::SetMainCDB("local://$ALICE_ROOT/OCDB/SHUTTLE/TestShuttle/TestCDB");
- AliTestShuttle::SetMainRefStorage("local://$ALICE_ROOT/OCDB/SHUTTLE/TestShuttle/TestReference");
-
- // create AliTestShuttle instance
- Int_t nrun = 7;
- AliTestShuttle* shuttle = new AliTestShuttle(nrun, 30, 980);
- //setting run type to physiscs
- shuttle->SetInputRunType(RunType);
- shuttle->SetTimeCreated(20);
- shuttle->SetDCSQueryOffset(20);
-
- // Generation of "fake" input DCS data
- TMap* dcsAliasMap = CreateDCSAliasMap();
-
- TFile *file=TFile::Open("dcsMap.root","RECREATE");
- file->cd();
- dcsAliasMap->Write();
- file->Close();
-
-
- // now give the alias map to the shuttle
- shuttle->SetDCSInput(dcsAliasMap);
-
- // processing files. for the time being, the files are local.
- shuttle->AddInputFile(AliTestShuttle::kDAQ, "TOF", "DELAYS", "MON", "$ALICE_ROOT/TOF/ShuttleInput/Total.root");
- shuttle->AddInputFile(AliTestShuttle::kDAQ, "TOF", "RUNLevel", "MON", "$ALICE_ROOT/TOF/ShuttleInput/Partial.root");
- shuttle->AddInputFile(AliTestShuttle::kDCS, "TOF", "TofFeeLightMap", "", "$ALICE_ROOT/TOF/ShuttleInput/TOFFEElight.20090616.102605.8000");
- shuttle->AddInputFile(AliTestShuttle::kDCS, "TOF", "TofFeeMap", "", "$ALICE_ROOT/TOF/ShuttleInput/TOFFEE.20091217.194708.105517");
-
- TString filename;
- TString LDCname;
- //char filename[100];
- //char LDCname[5];
-
- for (Int_t iLDC=0;iLDC<2;iLDC++){
- filename.Form("$ALICE_ROOT/TOF/ShuttleInput/TOFoutPulserLDC_%02i.root",iLDC*2);
- LDCname.Form("LDC%i",iLDC*2);
- shuttle->AddInputFile(AliTestShuttle::kDAQ, "TOF", "PULSER", LDCname, filename);
- filename.Form("$ALICE_ROOT/TOF/ShuttleInput/TOFoutNoiseLDC_%02i.root",iLDC*2);
- LDCname.Form("LDC%i",iLDC*2);
- shuttle->AddInputFile(AliTestShuttle::kDAQ, "TOF", "NOISE", LDCname, filename);
- }
-
-
- // instantiation of the preprocessor
- AliPreprocessor* pp = new AliTOFPreprocessor(shuttle);
- pp->Print();
-
- // preprocessing
- gBenchmark->Start("process");
- shuttle->Process();
- gBenchmark->Stop("process");
- gBenchmark->Print("process");
-
- // checking the file which should have been created
- AliCDBEntry* chkEntry = AliCDBManager::Instance()->GetStorage(AliShuttleInterface::GetMainCDB())->Get("TOF/Calib/ParOnlineDelay", nrun);
- if (!chkEntry)
- {
- printf("The file is not there. Something went wrong.\n");
- return;
- }
-
- AliTOFDataDCS* output = dynamic_cast<AliTOFDataDCS*> (chkEntry->GetObject());
- // If everything went fine, draw the result
- if (output)
- printf("Output found.\n");
- // output->Draw();
-
-
- //shuttle->Delete();
-
-}
-
-TMap* CreateDCSAliasMap()
-{
- // Creates a DCS structure
- // The structure is the following:
- // TMap (key --> value)
- // <DCSAlias> --> <valueList>
- // <DCSAlias> is a string
- // <valueList> is a TObjArray of AliDCSValue
- // An AliDCSValue consists of timestamp and a value in form of a AliSimpleValue
-
- // In this example 6 aliases exists: DCSAlias1 ... DCSAlias6
- // Each contains 1000 values randomly generated by TRandom::Gaus + 5*nAlias
-
- TMap* aliasMap = new TMap;
- aliasMap->SetOwner(1);
-
- TRandom random;
- /*
- TDatime *datime = new TDatime();
- Int_t time = datime->GetTime();
- Int_t date = datime->GetDate();
- Int_t pid = gSystem->GetPid();
- delete datime;
- Int_t iseed = TMath::Abs(10000 * pid + time - date);
- */
-
-
- Float_t tentHVv=6500, tentHVi=80;
- Float_t sigmaHVv=10, sigmaHVi=10;
-
- Float_t tent=0, sigma=0;//, thr=0;
- // to have all the aliases, decomment the following line:
- Int_t NAliases=360, NHV=90;
-
-
- // if not all the aliases are there, use this:
- //Int_t NAliases=120, NHV=90;
-
- TString sindex;
- TString aliasName;
-
- for(int nAlias=0;nAlias<NAliases;nAlias++) {
-
- TObjArray* valueSet = new TObjArray;
- valueSet->SetOwner(1);
-
- if (nAlias<NHV){
- aliasName = "tof_hv_vp_";
- sindex.Form("%02i",nAlias);
- aliasName += sindex;
- //aliasName += nAlias;
- tent=tentHVv;
- sigma=sigmaHVv;
- // thr=thrHVv;
- }
- else if (nAlias<NHV*2){
- // aliasName = "HVvneg";
- //aliasName += nAlias-NHV;
- aliasName = "tof_hv_vn_";
- sindex.Form("%02i",nAlias-NHV);
- aliasName += sindex;
- tent=-tentHVv;
- sigma=-sigmaHVv;
- //thr=-thrHVv;
- }
- else if (nAlias<NHV*3){
- // aliasName = "HVcpos";
- //aliasName += nAlias-2*NHV;
- aliasName = "tof_hv_ip_";
- sindex.Form("%02i",nAlias-2*NHV);
- aliasName += sindex;
- tent=tentHVi;
- sigma=sigmaHVi;
- //thr=thrHVc;
- }
- else if (nAlias<NHV*4){
- // aliasName = "HVcneg";
- //aliasName += nAlias-3*NHV;
- aliasName = "tof_hv_in_";
- sindex.Form("%02i",nAlias-3*NHV);
- aliasName += sindex;
- tent=-tentHVi;
- sigma=-sigmaHVi;
- //thr=-thrHVc;
- }
- // gauss generation of values
- for (int timeStamp=0;timeStamp<6000;timeStamp+=10){
- //for (int timeStamp=0;timeStamp<1;timeStamp++){
- Float_t gaussvalue = (Float_t) (random.Gaus(tent,sigma));
- if (TMath::Abs(gaussvalue-tent)>sigma){
- AliDCSValue* dcsVal = new AliDCSValue(gaussvalue, timeStamp);
- valueSet->Add(dcsVal);
- }
- }
-
- aliasMap->Add(new TObjString(aliasName), valueSet);
-
- }
-
-
-
-
- const Int_t kNsectors = 18;
- const Int_t kNplates = 5;
-
- UInt_t baseWord = 0;
- UInt_t oldBaseWord = 0;
-
- for(int i=0;i<kNsectors;i++)
- for(int j=0;j<kNplates;j++) {
-
- TObjArray* valueSetHV = new TObjArray;
- valueSetHV->SetOwner(1);
-
- aliasName = "TOF_HVSTATUS_";
- sindex.Form("SM%02dMOD%1d",i,j);
- aliasName += sindex;
-
-
- //for (int timeStamp=0;timeStamp<6000;timeStamp+=600) {
- for (int timeStamp=0;timeStamp<1201;timeStamp+=600) {
- if (timeStamp==0 /*|| timeStamp==1200*/) {
- baseWord = CreateHVword(i,j, kTRUE);
- oldBaseWord = baseWord;
- AliDCSValue* dcsVal = new AliDCSValue(baseWord, timeStamp);
- valueSetHV->Add(dcsVal);
- }
- else {
- if (random.Uniform(0.,1.)>=0.5) {
- baseWord = CreateHVword(i,j, kFALSE);
- if (baseWord<=oldBaseWord) {
- oldBaseWord = baseWord;
- AliDCSValue* dcsVal = new AliDCSValue(baseWord, timeStamp);
- valueSetHV->Add(dcsVal);
- }
- else {
- AliDCSValue* dcsVal = new AliDCSValue(oldBaseWord, timeStamp);
- valueSetHV->Add(dcsVal);
- }
- //Info(Form(" %2d %1d %s %d %d",i,j,aliasName,timeStamp,baseWord));
- }
- }
- }
-
- /*
- baseWord = CreateHVword(i,j, kTRUE);
- AliDCSValue* dcsVal0 = new AliDCSValue(baseWord, 0);
- valueSetHV->Add(dcsVal0);
-
- if ((i==0 && j==2) || (i==9 && j==4)) {
- baseWord = CreateHVword(i,j, kFALSE);
- AliDCSValue* dcsVal1 = new AliDCSValue(baseWord, 600);
- valueSetHV->Add(dcsVal1);
- }
-
- baseWord = CreateHVword(i,j, kTRUE);
- AliDCSValue* dcsVal2 = new AliDCSValue(baseWord, 1200);
- valueSetHV->Add(dcsVal2);
- */
-
- aliasMap->Add(new TObjString(aliasName), valueSetHV);
-
- }
-
-
- const Int_t kNddl = 72;
- baseWord = 0;
- oldBaseWord = 0;
-
- for(int i=0;i<kNddl;i++) {
-
- TObjArray* valueSetLV = new TObjArray;
- valueSetLV->SetOwner(1);
-
- aliasName = "TOF_FEACSTATUS_";
- sindex.Form("%02d",i);
- aliasName += sindex;
-
-
- //for (int timeStamp=0;timeStamp<6000;timeStamp+=600) {
- for (int timeStamp=0;timeStamp<1201;timeStamp+=400) {
- if (timeStamp==0 /*|| timeStamp==1200*/) {
- baseWord = CreateLVword(kTRUE);
- AliDCSValue* dcsVal = new AliDCSValue(baseWord, timeStamp);
- valueSetLV->Add(dcsVal);
- oldBaseWord = baseWord;
- //Info(Form(" %2d %s %d %d",i,aliasName,timeStamp,baseWord));
- }
- else {
- if (random.Uniform(0.,1.)>=0.5) {
- baseWord = CreateLVword(kFALSE);
- if (baseWord<=oldBaseWord) {
- oldBaseWord = baseWord;
- AliDCSValue* dcsVal = new AliDCSValue(baseWord, timeStamp);
- valueSetLV->Add(dcsVal);
- }
- else {
- AliDCSValue* dcsVal = new AliDCSValue(oldBaseWord, timeStamp);
- valueSetLV->Add(dcsVal);
- }
- //Info(Form(" %2d %1d %s %d %d",i,j,aliasName,timeStamp,baseWord));
- }
- }
- }
-
- /*
- baseWord = CreateLVword(kTRUE);
- AliDCSValue* dcsVal0 = new AliDCSValue(baseWord, 0);
- valueSetLV->Add(dcsVal0);
-
- if (i==7 || i==9) {
- baseWord = CreateLVword(kFALSE);
- AliDCSValue* dcsVal1 = new AliDCSValue(baseWord, 400);
- valueSetLV->Add(dcsVal1);
- }
- else if (i==50 || i==35) {
- baseWord = CreateLVword(kFALSE);
- AliDCSValue* dcsVal2 = new AliDCSValue(baseWord, 800);
- valueSetLV->Add(dcsVal2);
- }
-
- baseWord = CreateLVword(kTRUE);
- AliDCSValue* dcsVal3 = new AliDCSValue(baseWord, 1200);
- valueSetLV->Add(dcsVal3);
- */
-
- aliasMap->Add(new TObjString(aliasName), valueSetLV);
-
- }
-
-
- return aliasMap;
-}
-
-
-UInt_t CreateHVword(Int_t nSector, Int_t nPlate, Bool_t isAtBorder) {
- //
- //
- //
-
- UInt_t baseWord = 0;
- UInt_t word = 0;
- TRandom random;
-
- for (Int_t iStrip=0; iStrip<AliTOFGeometry::NStrip(nPlate); iStrip++) {
-
- if (isAtBorder) {
- word = 1;
- if (nPlate==2 && nSector>=13 && nSector<=15)
- word = 0;
- }
- else {
- random.Uniform(0.,1.)<0.5 ? word = 0 : word = 1;
- if (nPlate==2 && nSector>=13 && nSector<=15)
- word = 0;
- word = 0;
- }
-
- AliBitPacking::PackWord(word,baseWord,iStrip,iStrip);
- }
-
- return baseWord;
-
-}
-
-
-UInt_t CreateLVword(Bool_t isAtBorder) {
- //
- //
- //
-
- UInt_t baseWord = 0;
- UInt_t word = 0;
- TRandom random;
-
- for (Int_t iFeac=0; iFeac<8; iFeac++) {
-
- if (isAtBorder)
- word = 1;
- else {
- random.Uniform(0.,1.)<0.5 ? word = 0 : word = 1;
- word = 0;
- }
-
- AliBitPacking::PackWord(word,baseWord,iFeac,iFeac);
- }
-
- return baseWord;
-
-}
-
-
-TMap* ReadDCSAliasMap()
-{
- // Open a file that contains DCS input data
- // The CDB framework is used to open the file, this means the file is located
- // in $ALICE_ROOT/SHUTTLE/TestShuttle/TestCDB/<detector>/DCS/Data
- // The file contains an AliCDBEntry that contains a TMap with the DCS structure.
- // An explanation of the structure can be found in CreateDCSAliasMap()
-
- AliCDBEntry *entry = AliCDBManager::Instance()->Get("TOF/DCS/Data", 0);
- return dynamic_cast<TMap*> (entry->GetObject());
-}
-
-void WriteDCSAliasMap()
-{
- // This writes the output from CreateDCSAliasMap to a CDB file
-
- TMap* dcsAliasMap = CreateDCSAliasMap();
-
- AliCDBMetaData metaData;
- metaData.SetBeamPeriod(0);
- metaData.SetResponsible("Chiara");
- metaData.SetComment("Test object for TOFPreprocessor.C");
-
- AliCDBId id("TOF/DCS/Data", 0, 0);
-
- // initialize location of CDB
- AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/OCDB/SHUTTLE/TestShuttle/TestCDB");
-
- AliCDBManager::Instance()->Put(dcsAliasMap, id, &metaData);
-}
#pragma link C++ class AliTOFrawData+;
#pragma link C++ class AliTOFRawStream+;
#pragma link C++ class AliTOFHitData+;
+#pragma link C++ class AliTOFHitField+;
#pragma link C++ class AliTOFHitDataBuffer+;
#pragma link C++ class AliTOFDecoder+;
#pragma link C++ class AliTOFChannelOffline+;
#pragma link C++ class AliTOFDeltaBCOffset+;
#pragma link C++ class AliTOFCTPLatency+;
#pragma link C++ class AliTOFT0Fill+;
+#pragma link C++ class AliTOFT0FillOnlineCalib+;
#pragma link C++ class AliTOFDCSmaps+;
#pragma link C++ class AliTOFLvHvDataPoints+;
TOF DA for online calibration
Contact: Chiara.Zampolli@bo.infn.it
-Link: www.bo.infn.it/~zampolli
+ Roberto.Preghenella@bo.infn.it
+
Run Type: PHYSICS
DA Type: MON
-Number of events needed: depending on the run, being run-level
-Input Files: TOFdaTotal.root, to be updated if existing
-Output Files: TOFdaRun.root, TOFdaTotal.root, both to be exported to the DAQ FXS
-Trigger types used: PHYSICS_EVENT
+Number of events needed:
+Input Files: no input
+Output Files: TOFdaHits.root
+Event types used: PHYSICS_EVENT
*/
-#define FILE_TOTAL "TOFdaTotal.root"
-#define FILE_RUN "TOFdaRun.root"
+#define FILE_HITS "TOFdaHits.root"
// DATE
#include "event.h"
#include <stdlib.h>
//AliRoot
-#include <AliTOFRawStream.h>
-#include <AliRawReaderDate.h>
-#include <AliRawReader.h>
-#include <AliTOFGeometry.h>
-#include <AliT0RawReader.h>
-#include <AliDAQ.h>
-#include <AliTOFHitData.h>
-#include <AliTOFHitDataBuffer.h>
-#include <AliTOFDaConfigHandler.h>
+#include "TROOT.h"
+#include "AliTOFRawStream.h"
+#include "AliRawReaderDate.h"
+#include "AliRawReader.h"
+#include "AliDAQ.h"
+#include "AliTOFHitData.h"
+#include "AliTOFHitDataBuffer.h"
+#include "AliTOFDaConfigHandler.h"
+#include "AliTOFHitField.h"
+#include "AliTOFcalibHisto.h"
+#include "AliLog.h"
//ROOT
-#include <TFile.h>
-#include <TKey.h>
-#include <TH2S.h>
-#include <TObject.h>
-#include <TMath.h>
-#include <TSystem.h>
+#include "TFile.h"
+#include "TKey.h"
+#include "TH2S.h"
+#include "TObject.h"
+#include "TMath.h"
+#include "TSystem.h"
#include "TROOT.h"
#include "TPluginManager.h"
#include "TSAXParser.h"
+#include "TTree.h"
/* Main routine
Arguments:
1- monitoring data source
*/
-int main(int argc, char **argv) {
-
+int
+main(int argc, char **argv)
+{
+
/* magic line from Rene */
gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo",
- "*",
- "TStreamerInfo",
- "RIO",
- "TStreamerInfo()");
-
- AliTOFGeometry * geom = new AliTOFGeometry();
-
- static const Int_t size = AliTOFGeometry::NPadXSector()*AliTOFGeometry::NSectors();
- static const Int_t nbins = 500;
- static const Int_t binmin = -20;
- const Float_t c = 2.99792458E10; //speed of light [cm/s]
- TH1F::AddDirectory(0);
- TH2S * htofPartial = new TH2S("htof","histo with delays",
- size,-0.5,size*1.-0.5,
- nbins,binmin-0.5,nbins*1.+binmin-0.5);
+ "*",
+ "TStreamerInfo",
+ "RIO",
+ "TStreamerInfo()");
- int status;
/* log start of process */
printf("TOF DA started\n");
-
+
/* check that we got some arguments = list of files */
if (argc!=2) {
printf("Wrong number of arguments\n");
return -1;
}
+ /*
+ * CONFIG
+ */
+
/* retrieve config file */
int getConfigFile = daqDA_DB_getFile("TOFPhysicsConfig.xml","TOFPhysicsConfig.xml");
if (getConfigFile != 0){
printf("Failed to retrieve config file from DB! returning...\n");
return -1;
}
-
+ /* parse config file */
AliTOFDaConfigHandler* tofHandler = new AliTOFDaConfigHandler();
TSAXParser *parser = new TSAXParser();
parser->ConnectToHandler("AliTOFDaConfigHandler", tofHandler);
printf("Failed parsing config file! retunring... \n");
return -1;
}
-
- Int_t debugFlag = tofHandler->GetDebugFlag();
- printf("The debug flag is %i\n",debugFlag);
- Int_t t0Flag = tofHandler->GetT0Flag();
- printf("The T0 flag is %i\n\n",t0Flag);
- if (t0Flag) {
- printf("The T0 time will be subtracted from the measured TOF time. So, in TDC bins: \n");
- printf("tof = tofRaw - (rawReaderT0->GetData(51,0)+rawReaderT0->GetData(52,0))/2) \n\n");
+ /* setup config params */
+ Int_t meanMultiplicity = tofHandler->GetMeanMultiplicity(); /* average expected TOF multiplicity */
+ Int_t maxHits = tofHandler->GetMaxHits(); /* max number of hits to be collected */
+ printf("current settings:\n");
+ printf(" - meanMultiplicity = %d\n", meanMultiplicity);
+ printf(" - maxHits = %d\n", maxHits);
+ /* constants */
+ const Int_t nChannels = 157248;
+ Int_t noiseCheckTrigger = 10; /* first noise check after 10 events */
+ Float_t meanChannelRate = (Float_t)meanMultiplicity / (Float_t)nChannels; /* average expected channel rate (hits/event) */
+ Float_t noiseThreshold = 10. * meanChannelRate; /* noise threshold (hits/event) */
+ Int_t minNoiseHits = 10; /* min number of channel hits to check noise */
+ /* counters and flags */
+ Int_t nEvents, totHits;
+ Int_t nChHits[nChannels];
+ Bool_t noiseFlag[nChannels];
+ /* variables */
+ Int_t nhits, ddl, slot, trm, chain, tdc, channel, indexEO, index, timebin, totbin, deltaBC, l0l1latency;
+ Float_t noiseHitThreshold;
+
+ /*
+ * INIT
+ */
+
+ /* init counters and flags */
+ nEvents = 0;
+ totHits = 0;
+ for (Int_t ich = 0; ich < nChannels; ich++) {
+ nChHits[ich] = 0;
+ noiseFlag[ich] = 0;
}
- else {
- printf("The T0 time will not be used.\n");
- printf("tof = tofRaw \n\n");
- }
-
- /* init some counters */
- int nevents_physics=0;
- int nevents_total=0;
-
- Int_t iev=0;
- Int_t nPDBEntriesToT = 0;
- Int_t nDBEntriesToT = 0;
- AliTOFHitData *HitData;
- Int_t dummy = -1;
- Int_t Volume[5];
- for (Int_t i=0;i<5;i++) Volume[i]=-1;
- AliTOFRawStream *rawStreamTOF = new AliTOFRawStream();
- AliTOFHitDataBuffer *DataBuffer;
- AliTOFHitDataBuffer *PackedDataBuffer;
- Int_t nDBEntries = 0;
- Int_t nPDBEntries = 0;
+ /* TOF raw data handling */
+ AliTOFRawStream *rawStream = new AliTOFRawStream();
+ AliTOFHitDataBuffer *pdb = NULL;
+ AliTOFHitData *hit = NULL;
+ /* calib histo */
+ AliTOFcalibHisto calibHisto;
+ calibHisto.LoadCalibHisto();
+ /* open output file */
+ TFile *fileOut = new TFile(FILE_HITS, "RECREATE");
+ /* create hit field data structure */
+ AliTOFHitField *hitField = new AliTOFHitField();
+ /* create temporary tree */
+ TTree *tempTree = new TTree("tempTree", "temporary tree");
+ tempTree->Branch("hit", "AliTOFHitField", &hitField);
+ /* create output tree */
+ TTree *outTree = new TTree("hitTree", "hit tree");
+ outTree->Branch("hit", "AliTOFHitField", &hitField);
+
+ /*
+ * ONLINE MONITOR
+ */
+
+ AliLog::SetGlobalLogLevel(AliLog::kFatal);
struct eventHeaderStruct *event;
- eventTypeType eventT;
-
+ int ret;
/* define data source : this is argument 1 */
- status=monitorSetDataSource( argv[1] );
- if (status!=0) {
- printf("monitorSetDataSource() failed : %s\n",monitorDecodeError(status));
+ ret = monitorSetDataSource(argv[1]);
+ if (ret != 0) {
+ printf("monitorSetDataSource() failed : %s\n",monitorDecodeError(ret));
return -1;
}
-
/* declare monitoring program */
- status=monitorDeclareMp( __FILE__ );
- if (status!=0) {
- printf("monitorDeclareMp() failed : %s\n",monitorDecodeError(status));
+ ret = monitorDeclareMp("tofDA");
+ if (ret != 0) {
+ printf("monitorDeclareMp() failed : %s\n",monitorDecodeError(ret));
return -1;
}
-
/* define wait event timeout - 1s max */
monitorSetNowait();
monitorSetNoWaitNetworkTimeout(1000);
-
- /* main loop (infinite) */
- for(;;) {
+
+ /* loop over events */
+ while (1) {
/* check shutdown condition */
if (daqDA_checkShutdown()) break;
+ /*
+ * NOISE CHECK
+ */
+
+ /* check number of events and check noise */
+ if (nEvents >= noiseCheckTrigger || totHits >= maxHits) {
+ noiseHitThreshold = noiseThreshold * nEvents;
+ printf("noise check triggered after %d events: threshold is %f hits\n", nEvents, noiseHitThreshold);
+ /* loop over all channels */
+ for (Int_t ich = 0; ich < nChannels; ich++) {
+ /* check */
+ if (nChHits[ich] < minNoiseHits || noiseFlag[ich] || nChHits[ich] < noiseHitThreshold) continue;
+ printf("channel %d tagged as noisy (%d hits): disabled\n", ich, nChHits[ich]);
+ noiseFlag[ich] = kTRUE;
+ totHits -= nChHits[ich];
+ } /* end of loop over all channels */
+ /* set new noise check trigger value */
+ noiseCheckTrigger *= 10;
+ } /* end of noise check */
+
+ /* break loop when maximum number of hits exceeded */
+ if (totHits >= maxHits) {
+ printf("maximum number of hits exceeded (%d): stop hit collection\n", maxHits);
+ break;
+ }
+
+ /*
+ * GET EVENT
+ */
+
/* get next event (blocking call until timeout) */
- status=monitorGetEventDynamic((void **)&event);
- if (status==MON_ERR_EOF) {
+ ret = monitorGetEventDynamic((void **)&event);
+ if (ret == MON_ERR_EOF) {
printf ("End of File detected\n");
break; /* end of monitoring file has been reached */
}
-
- if (status!=0) {
- printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(status));
+ if (ret != 0) {
+ printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(ret));
break;
}
-
/* retry if got no event */
if (event==NULL) continue;
-
- iev++;
-
- /* use event - here, just write event id to result file */
- nevents_total++;
- eventT=event->eventType;
- switch (event->eventType) {
-
- /* START OF RUN */
- case START_OF_RUN:
- break;
- /* END START OF RUN */
-
- /* END OF RUN */
- case END_OF_RUN:
- break;
- /* END END OF RUN */
-
- case PHYSICS_EVENT:
- nevents_physics++;
- AliRawReader *rawReader = new AliRawReaderDate((void*)event);
- //rawReader->RequireHeader(kFALSE);
-
- //T0 event
- Int_t meantime = 0;
- AliT0RawReader *rawReaderT0 = new AliT0RawReader(rawReader,kTRUE);
- if (!rawReaderT0->Next()) {
- printf("T0: no raw data found!\n");
- }
- else {
- /*
- Int_t allData[105][5];
- for (Int_t i=0; i<105; i++) {
- allData[i][0]=rawReaderT0->GetData(i,0);
- }
- meantime = allData[49][0];
- */
- //meantime = rawReaderT0->GetData(49,0); //OLD
- meantime = (Int_t)((rawReaderT0->GetData(51,0)+rawReaderT0->GetData(52,0))/2.); //Alla
- if (debugFlag > 0) {
- printf("\nT0 for the current event:\n"); // debugging purpose
- printf("time zero = %i (TDC bin)\n", meantime); // debugging purpose
- printf("time zero = %f (ns)\n\n", (Float_t)(meantime)*24.4*1E-3); // debugging purpose
- }
- }
-
- delete rawReaderT0;
- rawReaderT0 = 0x0;
- rawReader->Reset();
-
- //TOF event
- dummy = -1;
- for (Int_t ii=0; ii<5; ii++) Volume[ii]=-1;
- rawStreamTOF->SetRawReader(rawReader);
- //rawReader->ReadHeader();
- rawStreamTOF->ResetBuffers();
- rawStreamTOF->DecodeDDL(0, AliDAQ::NumberOfDdls("TOF") - 1,0);
- nPDBEntriesToT = 0;
- nDBEntriesToT = 0;
- for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls("TOF"); iDDL++) {
-
- /* read decoded data */
- DataBuffer = rawStreamTOF->GetDataBuffer(iDDL);
- PackedDataBuffer = rawStreamTOF->GetPackedDataBuffer(iDDL);
-
- /* get buffer entries */
- nDBEntries = DataBuffer->GetEntries();
- nPDBEntries = PackedDataBuffer->GetEntries();
- nPDBEntriesToT+=nPDBEntries;
- nDBEntriesToT+=nDBEntries;
-
- //for (Int_t iHit = 0; iHit < nDBEntries; iHit++) {
- // HitData = DataBuffer->GetHit(iHit);
- /* store volume information */
- // rawStreamTOF->EquipmentId2VolumeId(HitData, Volume);
- //}
- /* reset buffer */
- DataBuffer->Reset();
-
- /* read data buffer hits */
- for (Int_t iHit = 0; iHit < nPDBEntries; iHit++) {
- HitData = PackedDataBuffer->GetHit(iHit);
- /* add volume information */
- HitData->SetDDLID(iDDL);
- rawStreamTOF->EquipmentId2VolumeId(HitData, Volume);
- if (Volume[0]==-1 ||
- Volume[1]==-1 ||
- Volume[2]==-1 ||
- Volume[3]==-1 ||
- Volume[4]==-1) continue;
- else {
- dummy = Volume[3];
- Volume[3] = Volume[4];
- Volume[4] = dummy;
- Int_t tofRaw = (Int_t)((Double_t)HitData->GetTime()*1E3/AliTOFGeometry::TdcBinWidth());
- Int_t tof;
- if (!t0Flag) tof = tofRaw;
- else tof = tofRaw - meantime;
- Int_t index = geom->GetIndex(Volume);
- Float_t pos[3];
- geom->GetPosPar(Volume,pos);
- Float_t texp = TMath::Sqrt(pos[0]*pos[0]+pos[1]*pos[1]+pos[2]*pos[2])/c*1E9; //expected time in ns
- Float_t texpBin = texp*1E3/AliTOFGeometry::TdcBinWidth(); //expected time in number of TDC bin
- Int_t deltabin = tof-TMath::Nint(texpBin); //to be used with real data; rounding expected time to Int_t
- htofPartial->Fill(index,deltabin); //channel index start from 0, bin index from 1
- //debugging printings
- if (debugFlag > 1) {
- printf("tofRaw = %i, tof = %i \n",tofRaw,tof);
- }
- if (debugFlag > 2) {
- printf("sector %2d, plate %1d, strip %2d, padz %1d, padx %2d \n",Volume[0],Volume[1],Volume[2],Volume[3],Volume[4]); // too verbose
- printf("pos x = %f, pos y = %f, pos z = %f \n",pos[0],pos[1],pos[2]); // too verbose
- printf("expected time = %f (ns)\n",texp); // too verbose
- printf("expected time bin = %f (TDC bin)\n",texpBin); // too verbose
- printf("measured time bin = %i (TDC bin) with %f (ns) and ACQ bit = %i \n",tof, HitData->GetTime(), HitData->GetACQ()); // too verbose
- printf("index = %6d, deltabin = %d , filling index = %6d, and bin = %d\n",index, deltabin, index, deltabin); // too verbose
- }
-
- }
- /* reset buffer */
- PackedDataBuffer->Reset();
- }
- }
- //if (debugFlag) {
- // printf(" Packed Hit Buffer Entries = %i \n",nPDBEntriesToT); // too verbose
- // printf(" Hit Buffer Entries = %i \n",nDBEntriesToT); // too verbose
- //}
-
- delete rawReader;
- rawReader = 0x0;
- }
+ /* check event type */
+ if (event->eventType != PHYSICS_EVENT) continue;
+ /* increment number of events */
+ nEvents++;
- /* free resources */
- free(event);
+ /*
+ * DECODE EVENT
+ */
+
+ /* create raw reader */
+ AliRawReader *rawReader = new AliRawReaderDate((void *)event);
+ /* setup raw stream */
+ rawStream->SetRawReader(rawReader);
+ /* reset buffers */
+ rawStream->ResetBuffers();
+ /* decode */
+ rawStream->DecodeDDL(0, AliDAQ::NumberOfDdls("TOF") - 1, 0);
+
+ /*
+ * HIT MANIPULATION
+ */
+
+ /* loop over DDLs */
+ for (Int_t iddl = 0; iddl < AliDAQ::NumberOfDdls("TOF"); iddl++) {
+ /* get packed-data buffer */
+ pdb = rawStream->GetPackedDataBuffer(iddl);
+ nhits = pdb->GetEntries();
+ /* loop over hits in buffer */
+ for (Int_t ihit = 0; ihit < nhits; ihit++) {
+ /* get hit */
+ hit = pdb->GetHit(ihit);
+ /* get channel info */
+ ddl = iddl;
+ slot = hit->GetSlotID();
+ trm = slot - 3;
+ chain = hit->GetChain();
+ tdc = hit->GetTDC();
+ channel = hit->GetChan();
+ indexEO = calibHisto.GetIndexEO(ddl, trm, chain, tdc, channel);
+ index = calibHisto.GetCalibMap(AliTOFcalibHisto::kIndex, indexEO);
+ if (index < 0) continue;
+ /* check noise flag */
+ if (noiseFlag[index]) continue;
+ /* increment number of channel hits and total hits */
+ nChHits[index]++;
+ totHits++;
+ /* get signal info */
+ timebin = hit->GetTimeBin();
+ totbin = hit->GetTOTBin();
+ deltaBC = hit->GetDeltaBunchID();
+ l0l1latency = hit->GetL0L1Latency();
+ /* set hit field data */
+ hitField->SetIndex(index);
+ hitField->SetTimeBin(timebin);
+ hitField->SetTOTBin(totbin);
+ hitField->SetDeltaBC(deltaBC);
+ hitField->SetL0L1Latency(l0l1latency);
+ /* fill temp tree */
+ tempTree->Fill();
+ } /* end of loop over hits in buffer */
+ } /* end of loop over DDLs */
- /* exit when last event received, no need to wait for TERM signal */
- if (eventT==END_OF_RUN) {
- printf("EOR event detected\n");
- break;
- }
-
- }
-
- delete rawStreamTOF;
- rawStreamTOF = 0x0;
-
- delete geom;
- geom = 0x0;
-
- //write the Run level file
- TFile * fileRun = new TFile (FILE_RUN,"RECREATE");
- htofPartial->Write();
- fileRun->Close();
-
- //write the Total file
- TH2S *htoftot = 0x0;
- TFile * filetot = 0x0;
- Bool_t isThere=kFALSE;
- const char *dirname = "./";
- TString filename = FILE_TOTAL;
- if((gSystem->FindFile(dirname,filename))!=NULL){
- isThere=kTRUE;
- printf("%s found \n",FILE_TOTAL);
- }
- if (isThere) {
-
- TFile * filetot1 = new TFile (FILE_TOTAL,"READ");
- //look for the file
- if (!filetot1->IsZombie()){
- printf("updating file %s \n",FILE_TOTAL);
- TIter next(filetot1->GetListOfKeys());
- TKey *key;
- //look for the histogram
- while ((key=(TKey*)next())){
- const char * namekey = key->GetName();
- if (strcmp(namekey,"htoftot")==0) {
- printf(" histo found \n");
- htoftot = (TH2S*) filetot1->Get("htoftot");
- htoftot->AddDirectory(0);
- htoftot->Add(htofPartial);
- break;
- }
- }
- }
- filetot1->Close();
- delete filetot1;
- filetot1=0x0;
- }
- else {
- printf(" no %s file found \n",FILE_TOTAL);
- htoftot = new TH2S(*htofPartial);
- htoftot->SetName("htoftot");
- htoftot->AddDirectory(0);
- }
-
- filetot = new TFile (FILE_TOTAL,"RECREATE");
- filetot->cd();
- htoftot->Write();
- filetot->Close();
+ /* delete raw reader */
+ delete rawReader;
+
+ } /* end of loop over events */
+
+ /* final noise check */
+ noiseHitThreshold = noiseThreshold * nEvents;
+ printf("final noise check after %d events: threshold is %f hits\n", nEvents, noiseHitThreshold);
+ /* loop over all channels */
+ for (Int_t ich = 0; ich < nChannels; ich++) {
+ /* check */
+ if (nChHits[ich] < minNoiseHits || noiseFlag[ich] || nChHits[ich] < noiseHitThreshold) continue;
+ printf("channel %d tagged as noisy (%d hits): disabled\n", ich, nChHits[ich]);
+ noiseFlag[ich] = kTRUE;
+ totHits -= nChHits[ich];
+ } /* end of loop over all channels */
- delete fileRun;
- delete filetot;
- delete htofPartial;
- delete htoftot;
-
- fileRun = 0x0;
- filetot = 0x0;
- htofPartial = 0x0;
- htoftot = 0x0;
-
- /* write report */
- printf("Run #%s, received %d physics events out of %d\n",
- getenv("DATE_RUN_NUMBER"),nevents_physics,nevents_total);
-
- status = 0;
+ /* copy hits into output tree from temp tree */
+ printf("copy hits from temporary tree into output tree\n");
+ printf("temporary tree contains %d hits\n", (Int_t)tempTree->GetEntries());
+ for (Int_t ihit = 0; ihit < tempTree->GetEntries(); ihit++) {
+ /* get entry */
+ tempTree->GetEntry(ihit);
+ /* check noise flag */
+ if (noiseFlag[hitField->GetIndex()]) continue;
+ /* fill output tree */
+ outTree->Fill();
+ } /* end of copy hits into output tree from temp tree */
+ printf("output tree contains %d hits\n", (Int_t)outTree->GetEntries());
+
+ /* write output tree on file */
+ fileOut->cd();
+ outTree->Write();
+ fileOut->Close();
/* export file to FXS */
- if (daqDA_FES_storeFile(FILE_RUN, "RUNLevel"))
- status=-2;
- if (daqDA_FES_storeFile(FILE_TOTAL, "DELAYS"))
- status=-2;
+ if (daqDA_FES_storeFile(FILE_HITS, "HITS"))
+ return -2;
- return status;
+ return 0;
}
--- /dev/null
+/*
+
+TOF DA for online calibration
+
+Contact: Chiara.Zampolli@bo.infn.it
+Link: www.bo.infn.it/~zampolli
+Run Type: PHYSICS
+DA Type: MON
+Number of events needed: depending on the run, being run-level
+Input Files: TOFdaTotal.root, to be updated if existing
+Output Files: TOFdaRun.root, TOFdaTotal.root, both to be exported to the DAQ FXS
+Trigger types used: PHYSICS_EVENT
+
+*/
+
+#define FILE_TOTAL "TOFdaTotal.root"
+#define FILE_RUN "TOFdaRun.root"
+
+// DATE
+#include "event.h"
+#include "monitor.h"
+#include "daqDA.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+//AliRoot
+#include <AliTOFRawStream.h>
+#include <AliRawReaderDate.h>
+#include <AliRawReader.h>
+#include <AliTOFGeometry.h>
+#include <AliT0RawReader.h>
+#include <AliDAQ.h>
+#include <AliTOFHitData.h>
+#include <AliTOFHitDataBuffer.h>
+#include <AliTOFDaConfigHandler.h>
+
+//ROOT
+#include <TFile.h>
+#include <TKey.h>
+#include <TH2S.h>
+#include <TObject.h>
+#include <TMath.h>
+#include <TSystem.h>
+#include "TROOT.h"
+#include "TPluginManager.h"
+#include "TSAXParser.h"
+
+/* Main routine
+ Arguments:
+ 1- monitoring data source
+*/
+int main(int argc, char **argv) {
+
+ /* magic line from Rene */
+ gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo",
+ "*",
+ "TStreamerInfo",
+ "RIO",
+ "TStreamerInfo()");
+
+ AliTOFGeometry * geom = new AliTOFGeometry();
+
+ static const Int_t size = AliTOFGeometry::NPadXSector()*AliTOFGeometry::NSectors();
+ static const Int_t nbins = 500;
+ static const Int_t binmin = -20;
+ const Float_t c = 2.99792458E10; //speed of light [cm/s]
+ TH1F::AddDirectory(0);
+ TH2S * htofPartial = new TH2S("htof","histo with delays",
+ size,-0.5,size*1.-0.5,
+ nbins,binmin-0.5,nbins*1.+binmin-0.5);
+
+ int status;
+
+ /* log start of process */
+ printf("TOF DA started\n");
+
+ /* check that we got some arguments = list of files */
+ if (argc!=2) {
+ printf("Wrong number of arguments\n");
+ return -1;
+ }
+
+ /* retrieve config file */
+ int getConfigFile = daqDA_DB_getFile("TOFPhysicsConfig.xml","TOFPhysicsConfig.xml");
+ if (getConfigFile != 0){
+ printf("Failed to retrieve config file from DB! returning...\n");
+ return -1;
+ }
+
+ AliTOFDaConfigHandler* tofHandler = new AliTOFDaConfigHandler();
+ TSAXParser *parser = new TSAXParser();
+ parser->ConnectToHandler("AliTOFDaConfigHandler", tofHandler);
+ if (parser->ParseFile("./TOFPhysicsConfig.xml") != 0) {
+ printf("Failed parsing config file! retunring... \n");
+ return -1;
+ }
+
+ Int_t debugFlag = tofHandler->GetDebugFlag();
+ printf("The debug flag is %i\n",debugFlag);
+ Int_t t0Flag = tofHandler->GetT0Flag();
+ printf("The T0 flag is %i\n\n",t0Flag);
+ if (t0Flag) {
+ printf("The T0 time will be subtracted from the measured TOF time. So, in TDC bins: \n");
+ printf("tof = tofRaw - (rawReaderT0->GetData(51,0)+rawReaderT0->GetData(52,0))/2) \n\n");
+ }
+ else {
+ printf("The T0 time will not be used.\n");
+ printf("tof = tofRaw \n\n");
+ }
+
+ /* init some counters */
+ int nevents_physics=0;
+ int nevents_total=0;
+
+ Int_t iev=0;
+
+ Int_t nPDBEntriesToT = 0;
+ Int_t nDBEntriesToT = 0;
+ AliTOFHitData *HitData;
+ Int_t dummy = -1;
+ Int_t Volume[5];
+ for (Int_t i=0;i<5;i++) Volume[i]=-1;
+ AliTOFRawStream *rawStreamTOF = new AliTOFRawStream();
+ AliTOFHitDataBuffer *DataBuffer;
+ AliTOFHitDataBuffer *PackedDataBuffer;
+ Int_t nDBEntries = 0;
+ Int_t nPDBEntries = 0;
+
+ struct eventHeaderStruct *event;
+ eventTypeType eventT;
+
+ /* define data source : this is argument 1 */
+ status=monitorSetDataSource( argv[1] );
+ if (status!=0) {
+ printf("monitorSetDataSource() failed : %s\n",monitorDecodeError(status));
+ return -1;
+ }
+
+ /* declare monitoring program */
+ status=monitorDeclareMp( __FILE__ );
+ if (status!=0) {
+ printf("monitorDeclareMp() failed : %s\n",monitorDecodeError(status));
+ return -1;
+ }
+
+ /* define wait event timeout - 1s max */
+ monitorSetNowait();
+ monitorSetNoWaitNetworkTimeout(1000);
+
+ /* main loop (infinite) */
+ for(;;) {
+
+ /* check shutdown condition */
+ if (daqDA_checkShutdown()) break;
+
+ /* get next event (blocking call until timeout) */
+ status=monitorGetEventDynamic((void **)&event);
+ if (status==MON_ERR_EOF) {
+ printf ("End of File detected\n");
+ break; /* end of monitoring file has been reached */
+ }
+
+ if (status!=0) {
+ printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(status));
+ break;
+ }
+
+ /* retry if got no event */
+ if (event==NULL) continue;
+
+ iev++;
+
+ /* use event - here, just write event id to result file */
+ nevents_total++;
+ eventT=event->eventType;
+ switch (event->eventType) {
+
+ /* START OF RUN */
+ case START_OF_RUN:
+ break;
+ /* END START OF RUN */
+
+ /* END OF RUN */
+ case END_OF_RUN:
+ break;
+ /* END END OF RUN */
+
+ case PHYSICS_EVENT:
+ nevents_physics++;
+ AliRawReader *rawReader = new AliRawReaderDate((void*)event);
+ //rawReader->RequireHeader(kFALSE);
+
+ //T0 event
+ Int_t meantime = 0;
+ AliT0RawReader *rawReaderT0 = new AliT0RawReader(rawReader,kTRUE);
+ if (!rawReaderT0->Next()) {
+ printf("T0: no raw data found!\n");
+ }
+ else {
+ /*
+ Int_t allData[105][5];
+ for (Int_t i=0; i<105; i++) {
+ allData[i][0]=rawReaderT0->GetData(i,0);
+ }
+ meantime = allData[49][0];
+ */
+ //meantime = rawReaderT0->GetData(49,0); //OLD
+ meantime = (Int_t)((rawReaderT0->GetData(51,0)+rawReaderT0->GetData(52,0))/2.); //Alla
+ if (debugFlag > 0) {
+ printf("\nT0 for the current event:\n"); // debugging purpose
+ printf("time zero = %i (TDC bin)\n", meantime); // debugging purpose
+ printf("time zero = %f (ns)\n\n", (Float_t)(meantime)*24.4*1E-3); // debugging purpose
+ }
+ }
+
+ delete rawReaderT0;
+ rawReaderT0 = 0x0;
+ rawReader->Reset();
+
+ //TOF event
+ dummy = -1;
+ for (Int_t ii=0; ii<5; ii++) Volume[ii]=-1;
+ rawStreamTOF->SetRawReader(rawReader);
+ //rawReader->ReadHeader();
+ rawStreamTOF->ResetBuffers();
+ rawStreamTOF->DecodeDDL(0, AliDAQ::NumberOfDdls("TOF") - 1,0);
+ nPDBEntriesToT = 0;
+ nDBEntriesToT = 0;
+ for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls("TOF"); iDDL++) {
+
+ /* read decoded data */
+ DataBuffer = rawStreamTOF->GetDataBuffer(iDDL);
+ PackedDataBuffer = rawStreamTOF->GetPackedDataBuffer(iDDL);
+
+ /* get buffer entries */
+ nDBEntries = DataBuffer->GetEntries();
+ nPDBEntries = PackedDataBuffer->GetEntries();
+ nPDBEntriesToT+=nPDBEntries;
+ nDBEntriesToT+=nDBEntries;
+
+ //for (Int_t iHit = 0; iHit < nDBEntries; iHit++) {
+ // HitData = DataBuffer->GetHit(iHit);
+ /* store volume information */
+ // rawStreamTOF->EquipmentId2VolumeId(HitData, Volume);
+ //}
+ /* reset buffer */
+ DataBuffer->Reset();
+
+ /* read data buffer hits */
+ for (Int_t iHit = 0; iHit < nPDBEntries; iHit++) {
+ HitData = PackedDataBuffer->GetHit(iHit);
+ /* add volume information */
+ HitData->SetDDLID(iDDL);
+ rawStreamTOF->EquipmentId2VolumeId(HitData, Volume);
+ if (Volume[0]==-1 ||
+ Volume[1]==-1 ||
+ Volume[2]==-1 ||
+ Volume[3]==-1 ||
+ Volume[4]==-1) continue;
+ else {
+ dummy = Volume[3];
+ Volume[3] = Volume[4];
+ Volume[4] = dummy;
+ Int_t tofRaw = (Int_t)((Double_t)HitData->GetTime()*1E3/AliTOFGeometry::TdcBinWidth());
+ Int_t tof;
+ if (!t0Flag) tof = tofRaw;
+ else tof = tofRaw - meantime;
+ Int_t index = geom->GetIndex(Volume);
+ Float_t pos[3];
+ geom->GetPosPar(Volume,pos);
+ Float_t texp = TMath::Sqrt(pos[0]*pos[0]+pos[1]*pos[1]+pos[2]*pos[2])/c*1E9; //expected time in ns
+ Float_t texpBin = texp*1E3/AliTOFGeometry::TdcBinWidth(); //expected time in number of TDC bin
+ Int_t deltabin = tof-TMath::Nint(texpBin); //to be used with real data; rounding expected time to Int_t
+ htofPartial->Fill(index,deltabin); //channel index start from 0, bin index from 1
+ //debugging printings
+ if (debugFlag > 1) {
+ printf("tofRaw = %i, tof = %i \n",tofRaw,tof);
+ }
+ if (debugFlag > 2) {
+ printf("sector %2d, plate %1d, strip %2d, padz %1d, padx %2d \n",Volume[0],Volume[1],Volume[2],Volume[3],Volume[4]); // too verbose
+ printf("pos x = %f, pos y = %f, pos z = %f \n",pos[0],pos[1],pos[2]); // too verbose
+ printf("expected time = %f (ns)\n",texp); // too verbose
+ printf("expected time bin = %f (TDC bin)\n",texpBin); // too verbose
+ printf("measured time bin = %i (TDC bin) with %f (ns) and ACQ bit = %i \n",tof, HitData->GetTime(), HitData->GetACQ()); // too verbose
+ printf("index = %6d, deltabin = %d , filling index = %6d, and bin = %d\n",index, deltabin, index, deltabin); // too verbose
+ }
+
+ }
+ /* reset buffer */
+ PackedDataBuffer->Reset();
+ }
+ }
+ //if (debugFlag) {
+ // printf(" Packed Hit Buffer Entries = %i \n",nPDBEntriesToT); // too verbose
+ // printf(" Hit Buffer Entries = %i \n",nDBEntriesToT); // too verbose
+ //}
+
+ delete rawReader;
+ rawReader = 0x0;
+ }
+
+ /* free resources */
+ free(event);
+
+ /* exit when last event received, no need to wait for TERM signal */
+ if (eventT==END_OF_RUN) {
+ printf("EOR event detected\n");
+ break;
+ }
+
+ }
+
+ delete rawStreamTOF;
+ rawStreamTOF = 0x0;
+
+ delete geom;
+ geom = 0x0;
+
+ //write the Run level file
+ TFile * fileRun = new TFile (FILE_RUN,"RECREATE");
+ htofPartial->Write();
+ fileRun->Close();
+
+ //write the Total file
+ TH2S *htoftot = 0x0;
+ TFile * filetot = 0x0;
+ Bool_t isThere=kFALSE;
+ const char *dirname = "./";
+ TString filename = FILE_TOTAL;
+ if((gSystem->FindFile(dirname,filename))!=NULL){
+ isThere=kTRUE;
+ printf("%s found \n",FILE_TOTAL);
+ }
+ if (isThere) {
+
+ TFile * filetot1 = new TFile (FILE_TOTAL,"READ");
+ //look for the file
+ if (!filetot1->IsZombie()){
+ printf("updating file %s \n",FILE_TOTAL);
+ TIter next(filetot1->GetListOfKeys());
+ TKey *key;
+ //look for the histogram
+ while ((key=(TKey*)next())){
+ const char * namekey = key->GetName();
+ if (strcmp(namekey,"htoftot")==0) {
+ printf(" histo found \n");
+ htoftot = (TH2S*) filetot1->Get("htoftot");
+ htoftot->AddDirectory(0);
+ htoftot->Add(htofPartial);
+ break;
+ }
+ }
+ }
+ filetot1->Close();
+ delete filetot1;
+ filetot1=0x0;
+ }
+ else {
+ printf(" no %s file found \n",FILE_TOTAL);
+ htoftot = new TH2S(*htofPartial);
+ htoftot->SetName("htoftot");
+ htoftot->AddDirectory(0);
+ }
+
+ filetot = new TFile (FILE_TOTAL,"RECREATE");
+ filetot->cd();
+ htoftot->Write();
+ filetot->Close();
+
+ delete fileRun;
+ delete filetot;
+ delete htofPartial;
+ delete htoftot;
+
+ fileRun = 0x0;
+ filetot = 0x0;
+ htofPartial = 0x0;
+ htoftot = 0x0;
+
+ /* write report */
+ printf("Run #%s, received %d physics events out of %d\n",
+ getenv("DATE_RUN_NUMBER"),nevents_physics,nevents_total);
+
+ status = 0;
+
+ /* export file to FXS */
+ if (daqDA_FES_storeFile(FILE_RUN, "RUNLevel"))
+ status=-2;
+ if (daqDA_FES_storeFile(FILE_TOTAL, "DELAYS"))
+ status=-2;
+
+ return status;
+}
AliTOFrawData.cxx\
AliTOFRawStream.cxx\
AliTOFHitData.cxx\
+ AliTOFHitField.cxx\
AliTOFHitDataBuffer.cxx\
AliTOFDecoder.cxx\
AliTOFChannelOffline.cxx \
AliTOFDeltaBCOffset.cxx \
AliTOFCTPLatency.cxx \
AliTOFT0Fill.cxx \
+ AliTOFT0FillOnlineCalib.cxx \
AliTOFLvHvDataPoints.cxx \
AliTOFDCSmaps.cxx
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff