/**************************************************************************
- * This file is property of and copyright by the ALICE HLT Project *
+ * This file is property of and copyright by the ALICE HLT Project *
* All rights reserved. *
* *
* Primary Authors: *
* Indranil Das <indra.das@saha.ac.in> *
+ * Artur Szostak <artursz@iafrica.com> *
* *
* 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 *
+ * about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
/* $Id$ */
-/** @file AliHLTMUONTriggerReconstructorComponent.cxx
- @author Indranil Das
- @date
- @brief Implementation of the trigger DDL reconstructor component. */
+///
+/// @file AliHLTMUONTriggerReconstructorComponent.cxx
+/// @author Indranil Das <indra.das@saha.ac.in>, Artur Szostak <artursz@iafrica.com>
+/// @date 18 Sep 2007
+/// @brief Implementation of the trigger DDL reconstructor component.
+///
#include "AliHLTMUONTriggerReconstructorComponent.h"
#include "AliHLTMUONTriggerReconstructor.h"
#include "AliHLTMUONHitReconstructor.h"
#include "AliHLTMUONConstants.h"
+#include "AliHLTMUONUtils.h"
#include "AliHLTMUONDataBlockWriter.h"
+#include "AliRawDataHeader.h"
+#include "AliCDBManager.h"
+#include "AliCDBStorage.h"
+#include "AliGeomManager.h"
+#include "AliMUONGeometryTransformer.h"
+#include "AliMUONGeometryDetElement.h"
+#include "AliMpCDB.h"
+#include "AliMpDDLStore.h"
+#include "AliMpPad.h"
+#include "AliMpSegmentation.h"
+#include "AliMpDEIterator.h"
+#include "AliMpVSegmentation.h"
+#include "AliMpDEManager.h"
+#include "AliMpLocalBoard.h"
+#include "AliMpTriggerCrate.h"
#include <cstdlib>
#include <cerrno>
#include <cassert>
+#include <fstream>
-namespace
-{
- // This is a global object used for automatic component registration,
- // do not use this for calculation.
- AliHLTMUONTriggerReconstructorComponent gAliHLTMUONTriggerReconstructorComponent;
-} // end of namespace
+ClassImp(AliHLTMUONTriggerReconstructorComponent)
-ClassImp(AliHLTMUONTriggerReconstructorComponent)
-
-
AliHLTMUONTriggerReconstructorComponent::AliHLTMUONTriggerReconstructorComponent() :
+ AliHLTMUONProcessor(),
fTrigRec(NULL),
- fDDLDir(""),
- fDDL(0),
+ fDDL(-1),
fWarnForUnexpecedBlock(false),
fSuppressPartialTrigs(false)
{
+ ///
+ /// Default constructor.
+ ///
}
AliHLTMUONTriggerReconstructorComponent::~AliHLTMUONTriggerReconstructorComponent()
{
+ ///
+ /// Default destructor.
+ ///
+
+ if (fTrigRec != NULL) delete fTrigRec;
}
const char* AliHLTMUONTriggerReconstructorComponent::GetComponentID()
{
+ ///
+ /// Inherited from AliHLTComponent. Returns the component ID.
+ ///
+
return AliHLTMUONConstants::TriggerReconstructorId();
}
void AliHLTMUONTriggerReconstructorComponent::GetInputDataTypes( std::vector<AliHLTComponentDataType>& list)
{
+ ///
+ /// Inherited from AliHLTProcessor. Returns the list of expected input data types.
+ ///
+
list.clear();
- list.push_back( AliHLTMUONConstants::TriggerDDLRawDataType() );
+ list.push_back( AliHLTMUONConstants::DDLRawDataType() );
}
AliHLTComponentDataType AliHLTMUONTriggerReconstructorComponent::GetOutputDataType()
{
+ ///
+ /// Inherited from AliHLTComponent. Returns the output data type.
+ ///
+
return AliHLTMUONConstants::TriggerRecordsBlockDataType();
}
unsigned long& constBase, double& inputMultiplier
)
{
+ ///
+ /// Inherited from AliHLTComponent. Returns an estimate of the expected output data size.
+ ///
+
constBase = sizeof(AliHLTMUONTriggerRecordsBlockWriter::HeaderType);
- inputMultiplier = 1;
+ inputMultiplier = 4;
}
AliHLTComponent* AliHLTMUONTriggerReconstructorComponent::Spawn()
{
+ ///
+ /// Inherited from AliHLTComponent. Creates a new object instance.
+ ///
+
return new AliHLTMUONTriggerReconstructorComponent;
}
int AliHLTMUONTriggerReconstructorComponent::DoInit(int argc, const char** argv)
{
- // perform initialization. We check whether our relative output size is
- // specified in the arguments.
-
- HLTInfo("Initialising DHLT Trigger Record Component");
-
- fWarnForUnexpecedBlock = false;
- fSuppressPartialTrigs = false;
- fTrigRec = new AliHLTMUONTriggerReconstructor();
-
- // this is just to get rid of the warning "unused parameter"
- if (argc==0 && argv==NULL) {
- HLTError("Arguments missing, no arguments" );
- }
-
- char lutFileName[500],reglocFileName[500];
-
- int i = 0;
- char* cpErr;
- while ( i < argc )
- {
- HLTDebug("argv[%d] == %s", i, argv[i] );
-
- if ( !strcmp( argv[i], "lut" ) ) {
- if ( argc <= i+1 ) {
- HLTError("LookupTable filename not specified" );
- return EINVAL; /* Invalid argument */
+ ///
+ /// Inherited from AliHLTComponent.
+ /// Parses the command line parameters and initialises the component.
+ ///
+
+ // perform initialization.
+
+ HLTInfo("Initialising dHLT trigger reconstructor component.");
+
+ // Make sure to cleanup fTrigRec if it is still there for some reason.
+ if (fTrigRec != NULL)
+ {
+ delete fTrigRec;
+ fTrigRec = NULL;
+ }
+
+ try
+ {
+ fTrigRec = new AliHLTMUONTriggerReconstructor();
+ }
+ catch (const std::bad_alloc&)
+ {
+ HLTError("Could not allocate more memory for the trigger reconstructor component.");
+ return -ENOMEM;
}
- sprintf(lutFileName,"%s",argv[i+1]);
+ fDDL = -1;
+ fWarnForUnexpecedBlock = false;
+ fSuppressPartialTrigs = false;
+
+ const char* lutFileName = NULL;
+ const char* cdbPath = NULL;
+ Int_t run = -1;
+ bool useCDB = false;
+ bool tryRecover = false;
+
+ for (int i = 0; i < argc; i++)
+ {
+ if (strcmp( argv[i], "-lut" ) == 0)
+ {
+ if ( argc <= i+1 )
+ {
+ HLTError("LookupTable filename not specified." );
+ // Make sure to delete fTrigRec to avoid partial initialisation.
+ delete fTrigRec;
+ fTrigRec = NULL;
+ return -EINVAL;
+ }
+
+ lutFileName = argv[i+1];
+
+ i++;
+ continue;
+ }
+
+ if (strcmp( argv[i], "-ddl" ) == 0)
+ {
+ if ( argc <= i+1 )
+ {
+ HLTError("DDL number not specified. It must be in the range [21..22]" );
+ // Make sure to delete fTrigRec to avoid partial initialisation.
+ delete fTrigRec;
+ fTrigRec = NULL;
+ return -EINVAL;
+ }
+
+ char* cpErr = NULL;
+ unsigned long num = strtoul(argv[i+1], &cpErr, 0);
+ if (cpErr == NULL or *cpErr != '\0')
+ {
+ HLTError("Cannot convert '%s' to a DDL Number.", argv[i+1]);
+ // Make sure to delete fTrigRec to avoid partial initialisation.
+ delete fTrigRec;
+ fTrigRec = NULL;
+ return -EINVAL;
+ }
+ if (num < 21 or 22 < num)
+ {
+ HLTError("The DDL ID number must be in the range [21..22].");
+ // Make sure to delete fTrigRec to avoid partial initialisation.
+ delete fTrigRec;
+ fTrigRec = NULL;
+ return -EINVAL;
+ }
+ fDDL = num - 1; // Convert to DDL number in the range 0..21
+
+ i++;
+ continue;
+ }
+
+ if (strcmp( argv[i], "-cdb" ) == 0)
+ {
+ useCDB = true;
+ continue;
+ }
+
+ if (strcmp( argv[i], "-cdbpath" ) == 0)
+ {
+ if ( argc <= i+1 )
+ {
+ HLTError("The CDB path was not specified." );
+ // Make sure to delete fTrigRec to avoid partial initialisation.
+ delete fTrigRec;
+ fTrigRec = NULL;
+ return -EINVAL;
+ }
+ cdbPath = argv[i+1];
+ useCDB = true;
+ i++;
+ continue;
+ }
+
+ if (strcmp( argv[i], "-run" ) == 0)
+ {
+ if ( argc <= i+1 )
+ {
+ HLTError("The RUN number was not specified." );
+ // Make sure to delete fTrigRec to avoid partial initialisation.
+ delete fTrigRec;
+ fTrigRec = NULL;
+ return -EINVAL;
+ }
+
+ char* cpErr = NULL;
+ run = Int_t( strtoul(argv[i+1], &cpErr, 0) );
+ if (cpErr == NULL or *cpErr != '\0')
+ {
+ HLTError("Cannot convert '%s' to a valid run number."
+ " Expected an integer value.", argv[i+1]
+ );
+ // Make sure to delete fTrigRec to avoid partial initialisation.
+ delete fTrigRec;
+ fTrigRec = NULL;
+ return -EINVAL;
+ }
+
+ i++;
+ continue;
+ }
+
+ if (strcmp( argv[i], "-warn_on_unexpected_block" ) == 0)
+ {
+ fWarnForUnexpecedBlock = true;
+ continue;
+ }
+
+ if (strcmp( argv[i], "-suppress_partial_triggers" ) == 0)
+ {
+ fSuppressPartialTrigs = true;
+ continue;
+ }
+
+ if (strcmp( argv[i], "-tryrecover" ) == 0)
+ {
+ tryRecover = true;
+ continue;
+ }
+
+ HLTError("Unknown option '%s'.", argv[i] );
+ // Make sure to delete fTrigRec to avoid partial initialisation.
+ delete fTrigRec;
+ fTrigRec = NULL;
+ return -EINVAL;
+
+ } // for loop
+
+ if (lutFileName == NULL) useCDB = true;
- i += 2;
- continue;
- }// lut argument
-
- if ( !strcmp( argv[i], "ddl" ) ) {
- if ( argc <= i+1 ) {
- HLTError("DDL number not specified" );
- return EINVAL; /* Invalid argument */
+ if (fDDL == -1)
+ {
+ HLTWarning("DDL number not specified. Cannot check if incomming data is valid.");
}
-
- fDDL = strtoul( argv[i+1], &cpErr, 0 );
- if ( *cpErr )
- {
- HLTError("Cannot convert '%s' to DDL Number ", argv[i+1] );
- return EINVAL;
- }
- //fDDL = atoi(argv[i+1]);
-
- i += 2;
- continue;
- }// ddl argument
-
- if ( !strcmp( argv[i], "rawdir" ) ) {
- if ( argc <= i+1 ) {
- HLTError("DDL directory not specified" );
- return EINVAL; /* Invalid argument */
+
+ int result = 0;
+ if (useCDB)
+ {
+ HLTInfo("Loading lookup table information from CDB for DDL %d.", fDDL+1);
+ if (fDDL == -1)
+ HLTWarning("DDL number not specified. The lookup table loaded from CDB will be empty!");
+ result = ReadCDB(cdbPath, run);
}
-
- fDDLDir = argv[i+1] ;
- i += 2;
- continue;
- }// ddl directory argument
-
- if ( !strcmp( argv[i], "reglocmap" ) ) {
- if ( argc <= i+1 ) {
- HLTError("Regional to Local Card mapping filename not specified" );
- return EINVAL; /* Invalid argument */
+ else
+ {
+ HLTInfo("Loading lookup table information from file %s.", lutFileName);
+ result = ReadLookUpTable(lutFileName);
}
-
- sprintf(reglocFileName,"%s",argv[i+1]);
-
- i += 2;
- continue;
- }// regtolocalmap argument
-
- if ( !strcmp( argv[i], "-warn_on_unexpected_block" ) ) {
- fWarnForUnexpecedBlock = true;
- i++;
- continue;
- }
-
- if ( !strcmp( argv[i], "-suppress_partial_triggers" ) ) {
- fSuppressPartialTrigs = true;
- i++;
- continue;
- }
-
- HLTError("Unknown option '%s'", argv[i] );
- return EINVAL;
-
- }//while loop
-
- int lutline = fTrigRec->GetLutLine();
- AliHLTMUONHitReconstructor::DHLTLut* lookupTable = new AliHLTMUONHitReconstructor::DHLTLut[lutline];
- if(!ReadLookUpTable(lookupTable,lutFileName)){
- HLTError("Failed to read lut, lut cannot be read");
- return ENOENT ; /* No such file or directory */
- }else{
-
- fTrigRec->LoadLookUpTable(lookupTable,fDDL+AliHLTMUONTriggerReconstructor::GetkDDLOffSet());
-
- AliHLTMUONTriggerReconstructor::RegToLoc regToLocMap[128]; // 16(locCard)*8(regCard)
- if(!ReadRegToLocMap(regToLocMap,reglocFileName)){
- HLTError("Failed to read RegToLocMap file");
- return ENOENT ; /* No such file or directory */
- }
-
- if(!(fTrigRec->SetRegToLocCardMap(regToLocMap))){
- HLTError("Failed to assign RegToLocMap to TrigRec Class due to memory problem");
- return ENOMEM ; /*cannot allocate memory*/
- }
-
- }// reading lut
-
- delete []lookupTable;
-
- HLTInfo("Initialisation of DHLT Trigger Record Component is done");
-
- return 0;
+ if (result != 0)
+ {
+ // Error messages already generated in ReadCDB or ReadLookUpTable.
+
+ // Make sure to delete fTrigRec to avoid partial initialisation.
+ delete fTrigRec;
+ fTrigRec = NULL;
+ return result;
+ }
+
+ fTrigRec->TryRecover(tryRecover);
+
+ return 0;
}
int AliHLTMUONTriggerReconstructorComponent::DoDeinit()
{
- HLTInfo("Deinitialising DHLT Trigger Record Component");
+ ///
+ /// Inherited from AliHLTComponent. Performs a cleanup of the component.
+ ///
+
+ HLTInfo("Deinitialising dHLT trigger reconstructor component.");
- if(fTrigRec)
+ if (fTrigRec != NULL)
{
delete fTrigRec;
fTrigRec = NULL;
int AliHLTMUONTriggerReconstructorComponent::DoEvent(
const AliHLTComponentEventData& evtData,
- const AliHLTComponentBlockData* blocks,
- AliHLTComponentTriggerData& trigData,
- AliHLTUInt8_t* outputPtr,
+ const AliHLTComponentBlockData* blocks,
+ AliHLTComponentTriggerData& /*trigData*/,
+ AliHLTUInt8_t* outputPtr,
AliHLTUInt32_t& size,
std::vector<AliHLTComponentBlockData>& outputBlocks
)
{
+ ///
+ /// Inherited from AliHLTProcessor. Processes the new event data.
+ ///
+
// Process an event
unsigned long totalSize = 0; // Amount of memory currently consumed in bytes.
// reconstruction algorithm on the raw data.
for (AliHLTUInt32_t n = 0; n < evtData.fBlockCnt; n++)
{
-#ifdef __DEBUG
- char id[kAliHLTComponentDataTypefIDsize+1];
- for (int i = 0; i < kAliHLTComponentDataTypefIDsize; i++)
- id[i] = blocks[n].fDataType.fID[i];
- id[kAliHLTComponentDataTypefIDsize] = '\0';
- char origin[kAliHLTComponentDataTypefOriginSize+1];
- for (int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++)
- origin[i] = blocks[n].fDataType.fOrigin[i];
- origin[kAliHLTComponentDataTypefOriginSize] = '\0';
-#endif // __DEBUG
- HLTDebug("Handling block: %u, with fDataType.fID = '%s',"
- " fDataType.fID = '%s', fPtr = %p and fSize = %u bytes.",
- n, static_cast<char*>(id), static_cast<char*>(origin),
- blocks[n].fPtr, blocks[n].fSize
+ HLTDebug("Handling block: %u, with fDataType = '%s', fPtr = %p and fSize = %u bytes.",
+ n, DataType2Text(blocks[n].fDataType).c_str(), blocks[n].fPtr, blocks[n].fSize
);
- if (blocks[n].fDataType != AliHLTMUONConstants::TriggerDDLRawDataType())
+ if (blocks[n].fDataType != AliHLTMUONConstants::DDLRawDataType()
+ or not AliHLTMUONUtils::IsTriggerDDL(blocks[n].fSpecification)
+ )
{
// Log a message indicating that we got a data block that we
// do not know how to handle.
- char id[kAliHLTComponentDataTypefIDsize+1];
- for (int i = 0; i < kAliHLTComponentDataTypefIDsize; i++)
- id[i] = blocks[n].fDataType.fID[i];
- id[kAliHLTComponentDataTypefIDsize] = '\0';
- char origin[kAliHLTComponentDataTypefOriginSize+1];
- for (int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++)
- origin[i] = blocks[n].fDataType.fOrigin[i];
- origin[kAliHLTComponentDataTypefOriginSize] = '\0';
-
if (fWarnForUnexpecedBlock)
- HLTWarning("Received a data block of a type we can not handle: %s origin %s",
- static_cast<char*>(id), static_cast<char*>(origin)
+ HLTWarning("Received a data block of a type we cannot handle: '%s', spec: 0x%X",
+ DataType2Text(blocks[n].fDataType).c_str(), blocks[n].fSpecification
);
else
- HLTDebug("Received a data block of a type we can not handle: %s origin %s",
- static_cast<char*>(id), static_cast<char*>(origin)
+ HLTDebug("Received a data block of a type we cannot handle: '%s', spec: 0x%X",
+ DataType2Text(blocks[n].fDataType).c_str(), blocks[n].fSpecification
);
continue;
}
+ if (fDDL != -1)
+ {
+ if (AliHLTMUONUtils::SpecToDDLNumber(blocks[n].fSpecification) != fDDL)
+ {
+ HLTWarning("Received raw data from an unexpected DDL.");
+ }
+ }
+
// Create a new output data block and initialise the header.
AliHLTMUONTriggerRecordsBlockWriter block(outputPtr+totalSize, size-totalSize);
if (not block.InitCommonHeader())
{
- HLTError("There is not enough space in the output buffer for the new data block.",
- " We require at least %u bytes, but have %u bytes left.",
+ HLTError("There is not enough space in the output buffer for the new data block."
+ " We require at least %ufTrigRec->GetkDDLHeaderSize() bytes, but have %u bytes left.",
sizeof(AliHLTMUONTriggerRecordsBlockWriter::HeaderType),
block.BufferSize()
);
break;
}
- AliHLTUInt32_t totalDDLSize = blocks[n].fSize / sizeof(AliHLTUInt32_t);
- AliHLTUInt32_t ddlRawDataSize = totalDDLSize - fTrigRec->GetkDDLHeaderSize();
- AliHLTUInt32_t* buffer = reinterpret_cast<AliHLTUInt32_t*>(blocks[n].fPtr)
- + fTrigRec->GetkDDLHeaderSize();
+ AliHLTUInt32_t totalDDLSize = blocks[n].fSize;
+ if (totalDDLSize < sizeof(AliRawDataHeader))
+ {
+ HLTError("Raw data block %d is %d bytes in size and is too short to"
+ " possibly contain valid DDL raw data. We expect it to have"
+ " at least %d bytes for the commond data header.",
+ n, totalDDLSize, sizeof(AliRawDataHeader)
+ );
+ continue;
+ }
+ AliRawDataHeader* header = reinterpret_cast<AliRawDataHeader*>(blocks[n].fPtr);
+ AliHLTUInt32_t payloadSize = totalDDLSize - sizeof(AliRawDataHeader);
+ AliHLTUInt8_t* buffer = reinterpret_cast<AliHLTUInt8_t*>(header + 1);
AliHLTUInt32_t nofTrigRec = block.MaxNumberOfEntries();
-
+
+ // Decode if this is a scalar event or not.
+ bool scalarEvent = ((header->GetL1TriggerMessage() & 0x1) == 0x1);
+
bool runOk = fTrigRec->Run(
- buffer, ddlRawDataSize,
+ buffer, payloadSize, scalarEvent,
block.GetArray(), nofTrigRec,
fSuppressPartialTrigs
);
if (not runOk)
{
- HLTError("Error while processing of trigger DDL reconstruction algorithm.");
+ HLTError("Error while processing the trigger DDL reconstruction algorithm.");
size = totalSize; // Must tell the framework how much buffer space was used.
- return EIO;
+ return -EIO;
}
// nofTrigRec should now contain the number of triggers actually found
}
-bool AliHLTMUONTriggerReconstructorComponent::ReadLookUpTable(AliHLTMUONHitReconstructor::DHLTLut* lookupTable, const char* lutpath)
+int AliHLTMUONTriggerReconstructorComponent::ReadLookUpTable(const char* lutpath)
{
- if (fDDL < 0 || fDDL >= 2){
- HLTError("DDL number is out of range");
- return false;
- }
-
- int lutLine = fTrigRec->GetLutLine();
-
- FILE* fin = fopen(lutpath, "r");
- if (fin == NULL){
- HLTError("Failed to open file: %s",lutpath);
- return false;
- }
-
- for(int i=0;i<lutLine;i++){
- fscanf(
- fin,
- "%d\t%d\t%d\t%f\t%f\t%f\t%d\t%d\n",
- &lookupTable[i].fIdManuChannel,
- &lookupTable[i].fIX,
- &lookupTable[i].fIY,
- &lookupTable[i].fRealX,
- &lookupTable[i].fRealY,
- &lookupTable[i].fRealZ,
- &lookupTable[i].fPcbZone,
- &lookupTable[i].fPlane
- );
- }
-
- fclose(fin);
- return true;
+ ///
+ /// Read in the lookup table from file.
+ ///
+
+ assert(fTrigRec != NULL);
+
+ fstream file;
+ file.open(lutpath, fstream::binary | fstream::in);
+ if (not file)
+ {
+ HLTError("Could not open file: %s", lutpath);
+ return -ENOENT;
+ }
+
+ file.read(reinterpret_cast<char*>(fTrigRec->LookupTableBuffer()), fTrigRec->LookupTableSize());
+ if (file.eof())
+ {
+ HLTError("The file %s was too short to contain a valid lookup table for this component.", lutpath);
+ file.close();
+ return -EIO;
+ }
+ if (file.fail())
+ {
+ HLTError("Could not read from file: %s", lutpath);
+ file.close();
+ return -EIO;
+ }
+
+ file.close();
+ return 0;
}
-bool AliHLTMUONTriggerReconstructorComponent::ReadRegToLocMap(AliHLTMUONTriggerReconstructor::RegToLoc* regToLocMap,const char* reglocFileName)
+int AliHLTMUONTriggerReconstructorComponent::ReadCDB(const char* cdbPath, Int_t run)
{
- int iTrigDDL,iReg,iLoc,locId,switchWord,detElemId[4];
- int index;
-
- memset(regToLocMap,-1,128*sizeof(AliHLTMUONTriggerReconstructor::RegToLoc));
-
- char s[100];
- ifstream fin(reglocFileName);
-
- if(!fin){
- HLTError("Failed to open file %s",reglocFileName);
- return false;
- }
-
- while(fin.getline(s,100)){
- sscanf(s,"%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d",
- &iTrigDDL,&iReg,&iLoc,&locId,&switchWord,&detElemId[0],&detElemId[1],&detElemId[2],&detElemId[3]);
- if(iTrigDDL==fDDL){
- index = iReg*16 + iLoc;
- regToLocMap[index].fTrigDDL = iTrigDDL ;
- regToLocMap[index].fRegId = iReg ;
- regToLocMap[index].fLoc = iLoc ;
- regToLocMap[index].fLocId = locId ;
- regToLocMap[index].fSwitch = switchWord ;
- for(int idet = 0; idet<4; idet++)
- regToLocMap[index].fDetElemId[idet] = detElemId[idet] ;
- }// if matches with fDDL
- }//file loop
-
- fin.close();
- return true;
+ /// Loads the lookup table containing channel and geometrical position
+ /// information about trigger strips from CDB.
+ /// \param cdbPath This specifies the CDB path to use to load from.
+ /// Can be set to NULL meaning the default storage is used.
+ /// \param run Specifies the run number to use. If set to -1 then the
+ /// default / current run number set for the CDB is used.
+ /// \return 0 on success and non zero codes for errors.
+
+ if (fDDL == -1)
+ {
+ HLTError("No DDL number specified for which to load LUT data from CDB.");
+ return -EINVAL;
+ }
+
+ int result = FetchMappingStores(cdbPath, run);
+ // Error message already generated in FetchMappingStores.
+ if (result != 0) return result;
+ AliMpDDLStore* ddlStore = AliMpDDLStore::Instance();
+
+ AliMpSegmentation* segmentation = AliMpSegmentation::Instance();
+ if (segmentation == NULL)
+ {
+ HLTError("Could not find segmentation mapping (AliMpSegmentation) instance.");
+ return -EIO;
+ }
+
+ // Only load geometry if not already loaded.
+ if (AliGeomManager::GetGeometry() == NULL)
+ {
+ AliGeomManager::LoadGeometry();
+ }
+ AliMUONGeometryTransformer transformer;
+ if (not transformer.LoadGeometryData())
+ {
+ HLTError("Could not load geometry into transformer.");
+ return -ENOENT;
+ }
+
+ AliHLTMUONTriggerRecoLookupTable* lookupTable = fTrigRec->LookupTableBuffer();
+
+ for (Int_t i = 0; i < 8; i++)
+ for (Int_t j = 0; j < 16; j++)
+ for (Int_t k = 0; k < 4; k++)
+ for (Int_t n = 0; n < 2; n++)
+ for (Int_t m = 0; m < 16; m++)
+ {
+ lookupTable->fRow[i][j][k][n][m].fIdFlags = 0x0;
+ lookupTable->fRow[i][j][k][n][m].fX = 0;
+ lookupTable->fRow[i][j][k][n][m].fY = 0;
+ lookupTable->fRow[i][j][k][n][m].fZ = 0;
+ }
+
+ AliMpDEIterator detElemIter;
+ for (Int_t iReg = 0; iReg < 8; iReg++)
+ {
+ AliMpTriggerCrate* crate = ddlStore->GetTriggerCrate(fDDL, iReg);
+ if (crate == NULL)
+ {
+ cerr << "ERROR: Could not get crate for regional header = " << iReg
+ << ", and DDL ID = " << fDDL << endl;
+ continue;
+ }
+
+ for (Int_t iLocBoard = 0; iLocBoard < 16; iLocBoard++)
+ {
+ Int_t boardId = crate->GetLocalBoardId(iLocBoard);
+ if (boardId == 0) continue;
+
+ AliMpLocalBoard* localBoard = ddlStore->GetLocalBoard(boardId);
+ if (localBoard == NULL)
+ {
+ cerr << "ERROR: Could not get loacl board: " << boardId << endl;
+ continue;
+ }
+
+ // skip copy cards
+ if (! localBoard->IsNotified()) continue;
+
+ for (Int_t iChamber = 0; iChamber < 4; iChamber++)
+ {
+ Int_t detElemId = ddlStore->GetDEfromLocalBoard(boardId, iChamber);
+
+ AliHLTUInt32_t idflags = AliHLTMUONUtils::PackRecHitFlags(iChamber+10, detElemId);
+
+ const AliMUONGeometryDetElement* detElemTransform = transformer.GetDetElement(detElemId);
+ if (detElemTransform == NULL)
+ {
+ cerr << "ERROR: Got NULL pointer for geometry transformer for detection element ID = "
+ << detElemId << endl;
+ continue;
+ }
+
+ for (Int_t iCathode = 0; iCathode <= 1; iCathode++)
+ {
+ const AliMpVSegmentation* seg = segmentation->GetMpSegmentation(
+ detElemId, AliMp::GetCathodType(iCathode)
+ );
+
+ for (Int_t bitxy = 0; bitxy < 16; bitxy++)
+ {
+ Int_t offset = 0;
+ if (iCathode && localBoard->GetSwitch(6)) offset = -8;
+
+ AliMpPad pad = seg->PadByLocation(AliMpIntPair(boardId, bitxy+offset), kFALSE);
+
+ if (! pad.IsValid())
+ {
+ // There is no pad associated with the given local board and bit pattern.
+ continue;
+ }
+
+ // Get the global coodinates of the pad.
+ Float_t lx = pad.Position().X();
+ Float_t ly = pad.Position().Y();
+ Float_t gx, gy, gz;
+ detElemTransform->Local2Global(lx, ly, 0, gx, gy, gz);
+
+ // Fill the LUT
+ lookupTable->fRow[iReg][iLocBoard][iChamber][iCathode][bitxy].fIdFlags = idflags;
+ lookupTable->fRow[iReg][iLocBoard][iChamber][iCathode][bitxy].fX = gx;
+ lookupTable->fRow[iReg][iLocBoard][iChamber][iCathode][bitxy].fY = gy;
+ lookupTable->fRow[iReg][iLocBoard][iChamber][iCathode][bitxy].fZ = gz;
+ }
+ }
+ }
+ }
+ }
+
+ return 0;
+}
+
+
+bool AliHLTMUONTriggerReconstructorComponent::GenerateLookupTable(
+ AliHLTInt32_t ddl, const char* filename,
+ const char* cdbPath, Int_t run
+ )
+{
+ /// Generates a binary file containing the lookup table (LUT) from the
+ /// CDB, which can be used for the trigger reconstructor component later.
+ /// @param ddl Must be the DDL for which to generate the DDL,
+ /// in the range [20..21].
+ /// @param filename The name of the LUT file to generate.
+ /// @param cdbPath The CDB path to use.
+ /// @param run The run number to use for the CDB.
+ /// @return True if the generation of the LUT file succeeded.
+
+ AliHLTMUONTriggerReconstructorComponent comp;
+
+ if (ddl < 20 or 21 < ddl)
+ {
+ std::cerr << "ERROR: the DDL number must be in the range [20..21]." << std::endl;
+ return false;
+ }
+
+ char ddlNum[32];
+ char runNum[32];
+ sprintf(ddlNum, "%d", ddl+1);
+ sprintf(runNum, "%d", run);
+ const char* argv[7] = {"-ddl", ddlNum, "-cdbpath", cdbPath, "-run", runNum, NULL};
+ int result = comp.DoInit(6, argv);
+ if (result != 0)
+ {
+ // Error message already generated in DoInit.
+ return false;
+ }
+
+ std::fstream file(filename, std::ios::out);
+ if (not file)
+ {
+ std::cerr << "ERROR: could not open file: " << filename << std::endl;
+ return false;
+ }
+
+ file.write(
+ reinterpret_cast<char*>(comp.fTrigRec->LookupTableBuffer()),
+ comp.fTrigRec->LookupTableSize()
+ );
+ if (not file)
+ {
+ cerr << "ERROR: There was a problem writing to the file: " << filename << endl;
+ return false;
+ }
+ file.close();
+
+ comp.DoDeinit();
+
+ return true;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff