Fixing code so that components use the new standard DDL_RAW data type.
authorszostak <szostak@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 16 Dec 2007 04:13:00 +0000 (04:13 +0000)
committerszostak <szostak@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 16 Dec 2007 04:13:00 +0000 (04:13 +0000)
HLT/MUON/AliHLTMUONConstants.cxx
HLT/MUON/AliHLTMUONConstants.h
HLT/MUON/AliHLTMUONUtils.h
HLT/MUON/OnlineAnalysis/AliHLTMUONHitReconstructorComponent.cxx
HLT/MUON/OnlineAnalysis/AliHLTMUONTrackerCalibratorComponent.cxx
HLT/MUON/OnlineAnalysis/AliHLTMUONTriggerCalibratorComponent.cxx
HLT/MUON/OnlineAnalysis/AliHLTMUONTriggerReconstructorComponent.cxx
HLT/MUON/macros/RunChain.C

index 0a5c4d1..0c33aad 100644 (file)
@@ -99,18 +99,7 @@ AliHLTMUONConstants::fgkNilPairDecisionStruct = {0, 0, 0, 0};
 
 
 const AliHLTComponentDataType
-AliHLTMUONConstants::fgkTriggerDDLRawDataType = (AliHLTComponentDataType){
-       sizeof(AliHLTComponentDataType),
-       {'D','D','L','T','R','I','G','R'},
-       kAliHLTDataOriginAny
-} | kAliHLTDataOriginMUON;
-
-const AliHLTComponentDataType
-AliHLTMUONConstants::fgkTrackingDDLRawDataType = (AliHLTComponentDataType){
-       sizeof(AliHLTComponentDataType),
-       {'D','D','L','T','R','A','C','K'},
-       kAliHLTDataOriginAny
-} | kAliHLTDataOriginMUON;
+AliHLTMUONConstants::fgkDDLRawDataType = kAliHLTDataTypeDDLRaw | kAliHLTDataOriginMUON;
 
 const AliHLTComponentDataType
 AliHLTMUONConstants::fgkTriggerRecordsBlockDataType = (AliHLTComponentDataType){
index d18677e..6f159f5 100644 (file)
@@ -107,14 +107,14 @@ public:
                return fgkNilPairDecisionStruct;
        }
 
-       static const AliHLTComponentDataType& TriggerDDLRawDataType()
+       // Returns the raw data type for MUON DDLs. To figure out if the DDL format
+       // will be for a tracking DDL or trigger DDL one needs to also check the
+       // sepcification word of the input data block. If one of the first 20 least
+       // significant bits are set then it is a tracker DDL otherwise if it is
+       // the 21st or 22nd bit then it is from the muon trigger.
+       static const AliHLTComponentDataType& DDLRawDataType()
        {
-               return fgkTriggerDDLRawDataType;
-       }
-
-       static const AliHLTComponentDataType& TrackingDDLRawDataType()
-       {
-               return fgkTrackingDDLRawDataType;
+               return fgkDDLRawDataType;
        }
 
        static const AliHLTComponentDataType& TriggerRecordsBlockDataType()
@@ -239,8 +239,7 @@ private:
        static const AliHLTMUONPairDecisionStruct fgkNilPairDecisionStruct; // Nil decision for track pair.
 
        // HLT component input and output data block types:
-       static const AliHLTComponentDataType fgkTriggerDDLRawDataType; // DDL packed data block type from dimuon trigger stations.
-       static const AliHLTComponentDataType fgkTrackingDDLRawDataType; // DDL packed data block type from dimuon tracking stations.
+       static const AliHLTComponentDataType fgkDDLRawDataType; // DDL packed data block type from dimuon spectrometer.
        static const AliHLTComponentDataType fgkTriggerRecordsBlockDataType; // Trigger records block type generated by trigger DDL translation components.
        static const AliHLTComponentDataType fgkTrigRecsDebugBlockDataType; // Debugging information block type generated by trigger DDL translation components.
        static const AliHLTComponentDataType fgkTriggerChannelBlockDataType; // Debugging information about the channels from the hardware trigger.
index d916dde..c6abda5 100644 (file)
@@ -250,6 +250,24 @@ public:
         */
        static AliHLTUInt32_t DDLNumberToSpec(AliHLTInt32_t ddlNo);
 
+       /**
+        * Returns true if the given specification was for a single trigger DDL.
+        */
+       static bool IsTriggerDDL(AliHLTUInt32_t spec)
+       {
+               AliHLTInt32_t ddl = SpecToDDLNumber(spec);
+               return (20 <= ddl and ddl <= 21);
+       }
+
+       /**
+        * Returns true if the given specification was for a single tracker DDL.
+        */
+       static bool IsTrackerDDL(AliHLTUInt32_t spec)
+       {
+               AliHLTInt32_t ddl = SpecToDDLNumber(spec);
+               return (0 <= ddl and ddl <= 19);
+       }
+
        /**
         * These codes indicate the reason why a data block failed its
         * validity check.
index 2506c8b..893316c 100644 (file)
@@ -29,6 +29,7 @@
 #include "AliHLTMUONHitReconstructorComponent.h"
 #include "AliHLTMUONHitReconstructor.h"
 #include "AliHLTMUONConstants.h"
+#include "AliHLTMUONUtils.h"
 #include "AliHLTMUONDataBlockWriter.h"
 #include "AliHLTLogging.h"
 #include "AliHLTSystem.h"
@@ -78,7 +79,7 @@ void AliHLTMUONHitReconstructorComponent::GetInputDataTypes( std::vector<AliHLTC
        ///
        
        list.clear();
-       list.push_back( AliHLTMUONConstants::TrackingDDLRawDataType() );
+       list.push_back( AliHLTMUONConstants::DDLRawDataType() );
 }
 
 
@@ -301,7 +302,9 @@ int AliHLTMUONHitReconstructorComponent::DoEvent(
                        blocks[n].fPtr, blocks[n].fSize
                );
 
-               if (blocks[n].fDataType != AliHLTMUONConstants::TrackingDDLRawDataType())
+               if (blocks[n].fDataType != AliHLTMUONConstants::DDLRawDataType()
+                   or not AliHLTMUONUtils::IsTrackerDDL(blocks[n].fSpecification)
+                  )
                {
                        // Log a message indicating that we got a data block that we
                        // do not know how to handle.
@@ -315,12 +318,12 @@ int AliHLTMUONHitReconstructorComponent::DoEvent(
                        origin[kAliHLTComponentDataTypefOriginSize] = '\0';
                        
                        if (fWarnForUnexpecedBlock)
-                               HLTWarning("Received a data block of a type we cannot handle: '%s' origin: '%s'",
-                                       static_cast<char*>(id), static_cast<char*>(origin)
+                               HLTWarning("Received a data block of a type we cannot handle: '%s' origin: '%s' spec: 0x%X",
+                                       static_cast<char*>(id), static_cast<char*>(origin), blocks[n].fSpecification
                                );
                        else
-                               HLTDebug("Received a data block of a type we cannot handle: '%s' origin: '%s'",
-                                       static_cast<char*>(id), static_cast<char*>(origin)
+                               HLTDebug("Received a data block of a type we cannot handle: '%s' origin: '%s' spec: 0x%X",
+                                       static_cast<char*>(id), static_cast<char*>(origin), blocks[n].fSpecification
                                );
                        
                        continue;
index 4d69ae9..99a1a45 100644 (file)
@@ -755,7 +755,7 @@ void AliHLTMUONTrackerCalibratorComponent::GetInputDataTypes(
        /// Returns the list of input block types expected by this component.
        
        list.clear();
-       list.push_back( AliHLTMUONConstants::TrackingDDLRawDataType() );
+       list.push_back( AliHLTMUONConstants::DDLRawDataType() );
 }
 
 AliHLTComponentDataType AliHLTMUONTrackerCalibratorComponent::GetOutputDataType()
@@ -764,7 +764,7 @@ AliHLTComponentDataType AliHLTMUONTrackerCalibratorComponent::GetOutputDataType(
        /// Returns the type of output block generated by this component.
 
        //TODO: fix.
-       return AliHLTMUONConstants::TrackingDDLRawDataType();
+       return AliHLTMUONConstants::DDLRawDataType();
 }
 
 void AliHLTMUONTrackerCalibratorComponent::GetOutputDataSize(
@@ -995,9 +995,16 @@ Int_t AliHLTMUONTrackerCalibratorComponent::ProcessCalibration(
        const AliHLTComponentBlockData* iter = NULL;
        
        // Loop over all DDL raw data input blocks and decode the event.
-       iter = GetFirstInputBlock( AliHLTMUONConstants::TriggerDDLRawDataType() );
+       iter = GetFirstInputBlock( AliHLTMUONConstants::DDLRawDataType() );
        while (iter != NULL)
        {
+               // Make sure we have the correct muon tracker DDL type.
+               if (not AliHLTMUONUtils::IsTrackerDDL(iter->fSpecification))
+               {
+                       iter = GetNextInputBlock();
+                       continue;
+               }
+
                // decoding rawdata headers
                AliRawReaderMemory* rawReader = new AliRawReaderMemory(
                                reinterpret_cast<UChar_t*>(iter->fPtr), iter->fSize
index 9788bb4..43000f5 100644 (file)
@@ -627,7 +627,7 @@ void AliHLTMUONTriggerCalibratorComponent::GetInputDataTypes(
        /// Returns the list of input block types expected by this component.
 
        list.clear();
-       list.push_back( AliHLTMUONConstants::TriggerDDLRawDataType() );
+       list.push_back( AliHLTMUONConstants::DDLRawDataType() );
 }
 
 
@@ -637,7 +637,7 @@ AliHLTComponentDataType AliHLTMUONTriggerCalibratorComponent::GetOutputDataType(
        /// Returns the type of output block generated by this component.
 
        //TODO: fix.
-       return AliHLTMUONConstants::TriggerDDLRawDataType();
+       return AliHLTMUONConstants::DDLRawDataType();
 }
 
 
@@ -830,9 +830,15 @@ Int_t AliHLTMUONTriggerCalibratorComponent::ProcessCalibration(
        const AliHLTComponentBlockData* iter = NULL;
        
        // Loop over all DDL raw data input blocks and decode the event.
-       iter = GetFirstInputBlock( AliHLTMUONConstants::TriggerDDLRawDataType() );
+       iter = GetFirstInputBlock( AliHLTMUONConstants::DDLRawDataType() );
        while (iter != NULL)
        {
+               // Make sure we have the correct muon trigger DDL type.
+               if (not AliHLTMUONUtils::IsTriggerDDL(iter->fSpecification))
+               {
+                       iter = GetNextInputBlock();
+                       continue;
+               }
                
                // decoding rawdata headers
                AliRawReaderMemory* rawReader = new AliRawReaderMemory(
index d4bc5d1..be6064e 100644 (file)
@@ -76,7 +76,7 @@ void AliHLTMUONTriggerReconstructorComponent::GetInputDataTypes( std::vector<Ali
        ///
        
        list.clear();
-       list.push_back( AliHLTMUONConstants::TriggerDDLRawDataType() );
+       list.push_back( AliHLTMUONConstants::DDLRawDataType() );
 }
 
 
@@ -269,7 +269,9 @@ int AliHLTMUONTriggerReconstructorComponent::DoEvent(
                        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.
@@ -283,12 +285,12 @@ int AliHLTMUONTriggerReconstructorComponent::DoEvent(
                        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' origin: '%s' spec: 0x%X",
+                                       static_cast<char*>(id), static_cast<char*>(origin), 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' origin: '%s' spec: 0x%X",
+                                       static_cast<char*>(id), static_cast<char*>(origin), blocks[n].fSpecification
                                );
                        
                        continue;
index 73caa3d..9d74c0f 100644 (file)
@@ -204,16 +204,16 @@ void RunChain(
        // directory structure.
        if (buildDDLFilePubs)
        {
-               string cmd13 = "-datatype 'DDLTRACK' 'MUON' -dataspec 0x001000";
-               string cmd14 = "-datatype 'DDLTRACK' 'MUON' -dataspec 0x002000";
-               string cmd15 = "-datatype 'DDLTRACK' 'MUON' -dataspec 0x004000";
-               string cmd16 = "-datatype 'DDLTRACK' 'MUON' -dataspec 0x008000";
-               string cmd17 = "-datatype 'DDLTRACK' 'MUON' -dataspec 0x010000";
-               string cmd18 = "-datatype 'DDLTRACK' 'MUON' -dataspec 0x020000";
-               string cmd19 = "-datatype 'DDLTRACK' 'MUON' -dataspec 0x040000";
-               string cmd20 = "-datatype 'DDLTRACK' 'MUON' -dataspec 0x080000";
-               string cmd21 = "-datatype 'DDLTRIGR' 'MUON' -dataspec 0x100000";
-               string cmd22 = "-datatype 'DDLTRIGR' 'MUON' -dataspec 0x200000";
+               string cmd13 = "-datatype 'DDL_RAW ' 'MUON' -dataspec 0x001000";
+               string cmd14 = "-datatype 'DDL_RAW ' 'MUON' -dataspec 0x002000";
+               string cmd15 = "-datatype 'DDL_RAW ' 'MUON' -dataspec 0x004000";
+               string cmd16 = "-datatype 'DDL_RAW ' 'MUON' -dataspec 0x008000";
+               string cmd17 = "-datatype 'DDL_RAW ' 'MUON' -dataspec 0x010000";
+               string cmd18 = "-datatype 'DDL_RAW ' 'MUON' -dataspec 0x020000";
+               string cmd19 = "-datatype 'DDL_RAW ' 'MUON' -dataspec 0x040000";
+               string cmd20 = "-datatype 'DDL_RAW ' 'MUON' -dataspec 0x080000";
+               string cmd21 = "-datatype 'DDL_RAW ' 'MUON' -dataspec 0x100000";
+               string cmd22 = "-datatype 'DDL_RAW ' 'MUON' -dataspec 0x200000";
                for (int i = firstEvent; i < lastEvent+1; i++)
                {
                        if (i != 0)