[u/mrichter/AliRoot.git] / HLT / BASE / test / testAliHLTEventDDLBackwardCompatibility.C

// $Id: $

/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        *
 * ALICE Experiment at CERN, All rights reserved.                         *
 *                                                                        *
 * Primary Authors: Artur Szostak <artursz@iafrica.com>                   *
 *                  for The ALICE HLT Project.                            *
 *                                                                        *
 * 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.                  *
 **************************************************************************/

/// @file   testAliHLTEventDDLBackwardCompatibility.C
/// @author Artur Szostak <artursz@iafrica.com>
/// @date   25 June 2010
/// @brief  Test program for backward compatibility of the AliHLTEventDDL structure.
///

#if defined(__CINT__) && (! defined(__MAKECINT__))
#error This macro must be compiled. Try running as testAliHLTEventDDLBackwardCompatibility.C++.
#endif

#if !defined(__CINT__) || defined(__MAKECINT__)
#include "AliHLTDataTypes.h"
#include "AliHLTReadoutList.h"
#include "AliHLTDAQ.h"
#include "AliHLTComponent.h"
#include "AliRawDataHeader.h"
#include "TRandom3.h"
#include "TString.h"
#include "TFile.h"
#include "TTree.h"
#include "Riostream.h"
#include <vector>
#include <algorithm>
#endif

/**
 * Tests to see if the AliHLTReadoutList class handles both AliHLTEventDDLV0
 * and AliHLTEventDDLV1 correctly.
 */
bool CheckReadoutListConvertedCorrectly()
{
	// Initialise the different versions of the structures so that every detector
	// has only its first DDL set.
	union
	{
		AliHLTEventDDL eventddlV0;
		AliHLTEventDDLV0 bitsV0;
	};
	bitsV0.fCount = gkAliHLTDDLListSizeV0;
	if (gkAliHLTDDLListSizeV0 != 30)
	{
		cerr << "ERROR: gkAliHLTDDLListSizeV0 has a value of " << gkAliHLTDDLListSizeV0
			<< " but expected a value of 30." << endl;
		return false;
	}
	bitsV0.fList[0] = 0x00000001; // kITSSPD
	bitsV0.fList[1] = 0x00000001; // kITSSDD
	bitsV0.fList[2] = 0x00000001; // kITSSSD
	bitsV0.fList[3] = 0x00000001; // kTPC
	bitsV0.fList[4] = 0x00000000; // kTPC
	bitsV0.fList[5] = 0x00000000; // kTPC
	bitsV0.fList[6] = 0x00000000; // kTPC
	bitsV0.fList[7] = 0x00000000; // kTPC
	bitsV0.fList[8] = 0x00000000; // kTPC
	bitsV0.fList[9] = 0x00000000; // kTPC
	bitsV0.fList[10] = 0x00000000; // kTPC
	bitsV0.fList[11] = 0x00000001; // kTRD
	bitsV0.fList[12] = 0x00000001; // kTOF
	bitsV0.fList[13] = 0x00000000; // kTOF
	bitsV0.fList[14] = 0x00000000; // kTOF
	bitsV0.fList[15] = 0x00000001; // kHMPID
	bitsV0.fList[16] = 0x00000001; // kPHOS
	bitsV0.fList[17] = 0x00000001; // kCPV
	bitsV0.fList[18] = 0x00000001; // kPMD
	bitsV0.fList[19] = 0x00000001; // kMUONTRK
	bitsV0.fList[20] = 0x00000001; // kMUONTRG
	bitsV0.fList[21] = 0x00000001; // kFMD
	bitsV0.fList[22] = 0x00000001; // kT0
	bitsV0.fList[23] = 0x00000001; // kV0
	bitsV0.fList[24] = 0x00000001; // kZDC
	bitsV0.fList[25] = 0x00000001; // kACORDE
	bitsV0.fList[26] = 0x00000001; // kTRG
	bitsV0.fList[27] = 0x00000001; // kEMCAL
	bitsV0.fList[28] = 0x00000001; // kDAQTEST
	bitsV0.fList[29] = 0x00000001; // kHLT
	
	union
	{
		AliHLTEventDDL eventddlV1;
		AliHLTEventDDLV1 bitsV1;
	};
	bitsV1.fCount = gkAliHLTDDLListSizeV1;
	if (gkAliHLTDDLListSizeV1 != 31)
	{
		cerr << "ERROR: gkAliHLTDDLListSizeV1 has a value of " << gkAliHLTDDLListSizeV1
			<< " but expected a value of 31." << endl;
		return false;
	}
	bitsV1.fList[0] = 0x00000001; // kITSSPD
	bitsV1.fList[1] = 0x00000001; // kITSSDD
	bitsV1.fList[2] = 0x00000001; // kITSSSD
	bitsV1.fList[3] = 0x00000001; // kTPC
	bitsV1.fList[4] = 0x00000000; // kTPC
	bitsV1.fList[5] = 0x00000000; // kTPC
	bitsV1.fList[6] = 0x00000000; // kTPC
	bitsV1.fList[7] = 0x00000000; // kTPC
	bitsV1.fList[8] = 0x00000000; // kTPC
	bitsV1.fList[9] = 0x00000000; // kTPC
	bitsV1.fList[10] = 0x00000000; // kTPC
	bitsV1.fList[11] = 0x00000001; // kTRD
	bitsV1.fList[12] = 0x00000001; // kTOF
	bitsV1.fList[13] = 0x00000000; // kTOF
	bitsV1.fList[14] = 0x00000000; // kTOF
	bitsV1.fList[15] = 0x00000001; // kHMPID
	bitsV1.fList[16] = 0x00000001; // kPHOS
	bitsV1.fList[17] = 0x00000001; // kCPV
	bitsV1.fList[18] = 0x00000001; // kPMD
	bitsV1.fList[19] = 0x00000001; // kMUONTRK
	bitsV1.fList[20] = 0x00000001; // kMUONTRG
	bitsV1.fList[21] = 0x00000001; // kFMD
	bitsV1.fList[22] = 0x00000001; // kT0
	bitsV1.fList[23] = 0x00000001; // kV0
	bitsV1.fList[24] = 0x00000001; // kZDC
	bitsV1.fList[25] = 0x00000001; // kACORDE
	bitsV1.fList[26] = 0x00000001; // kTRG
	bitsV1.fList[27] = 0x00000001; // kEMCAL
	bitsV1.fList[28] = 0x00000000; // kEMCAL
	bitsV1.fList[29] = 0x00000001; // kDAQTEST
	bitsV1.fList[30] = 0x00000001; // kHLT
	
	AliHLTReadoutList rlV0(eventddlV0);
	AliHLTReadoutList rlV1(eventddlV1);
	
	// Check that for both readout list versions only the first DDLs are
	// enabled as expected.
	for (Int_t i = 0; i < AliHLTDAQ::NumberOfDetectors(); ++i)
	for (Int_t j = 0; j < AliHLTDAQ::NumberOfDdls(i); ++j)
	{
		Int_t ddlid = AliHLTDAQ::DdlIDOffset(i) | (j & 0xFF);
		if (j == 0)
		{
			if (rlV0.IsDDLDisabled(ddlid))
			{
				cerr << "ERROR: The first DDL for detector " << AliHLTDAQ::DetectorName(i)
					<< " was not enabled for readout list initialised from AliHLTEventDDLV0."
					<< endl;
				return false;
			}
			if (rlV1.IsDDLDisabled(ddlid))
			{
				cerr << "ERROR: The first DDL for detector " << AliHLTDAQ::DetectorName(i)
					<< " was not enabled for readout list initialised from AliHLTEventDDLV1."
					<< endl;
				return false;
			}
		}
		else
		{
			if (rlV0.IsDDLEnabled(ddlid))
			{
				cerr << "ERROR: DDL " << ddlid << " for detector " << AliHLTDAQ::DetectorName(i)
					<< " was marked enabled for readout list initialised from AliHLTEventDDLV0."
					<< endl;
				return false;
			}
			if (rlV1.IsDDLEnabled(ddlid))
			{
				cerr << "ERROR: DDL " << ddlid << " for detector " << AliHLTDAQ::DetectorName(i)
					<< " was marked enabled for readout list initialised from AliHLTEventDDLV1."
					<< endl;
				return false;
			}
		}
	}
	
	// Check that the internal buffers are identical.
	if (rlV0.BufferSize() != rlV1.BufferSize())
	{
		cerr << "ERROR: Buffer sizes for readout lists are different: rlV0.BufferSize() = "
			<< rlV0.BufferSize() << ", rlV1.BufferSize() = " << rlV1.BufferSize() << endl;
		return false;
	}
	if (memcmp(rlV0.Buffer(), rlV1.Buffer(), rlV0.BufferSize()) != 0)
	{
		cerr << "ERROR: Buffers for the two readout list versions are different." << endl;
		return false;
	}
	
	return true;
}

/**
 * Tests to see if AliHLTComponent::ExtractTriggerData recognises the old format
 * of AliHLTEventTriggerData and handles it correctly.
 */
bool CheckHandlingOfOldAliHLTEventTriggerData()
{
	// Prepare old structure format.
	struct AliHLTEventTriggerDataV0
	{
		AliHLTUInt8_t  fAttributes[gkAliHLTBlockDAttributeCount];
		AliHLTUInt64_t fHLTStatus;
		AliHLTUInt32_t fCommonHeaderWordCnt;
		AliHLTUInt32_t fCommonHeader[gkAliHLTCommonHeaderCount];
		AliHLTEventDDLV0 fReadoutListV0;
	};
	AliHLTEventTriggerDataV0 eventTrigData;
	memset(&eventTrigData, 0x0, sizeof(eventTrigData));
	eventTrigData.fCommonHeaderWordCnt = 8;
	eventTrigData.fHLTStatus = 0x123;
	eventTrigData.fReadoutListV0.fCount = gkAliHLTDDLListSizeV0;
	eventTrigData.fReadoutListV0.fList[0] = 0x00000001; // kITSSPD
	eventTrigData.fReadoutListV0.fList[1] = 0x00000001; // kITSSDD
	eventTrigData.fReadoutListV0.fList[2] = 0x00000001; // kITSSSD
	eventTrigData.fReadoutListV0.fList[3] = 0x00000001; // kTPC
	eventTrigData.fReadoutListV0.fList[4] = 0x00000000; // kTPC
	eventTrigData.fReadoutListV0.fList[5] = 0x00000000; // kTPC
	eventTrigData.fReadoutListV0.fList[6] = 0x00000000; // kTPC
	eventTrigData.fReadoutListV0.fList[7] = 0x00000000; // kTPC
	eventTrigData.fReadoutListV0.fList[8] = 0x00000000; // kTPC
	eventTrigData.fReadoutListV0.fList[9] = 0x00000000; // kTPC
	eventTrigData.fReadoutListV0.fList[10] = 0x00000000; // kTPC
	eventTrigData.fReadoutListV0.fList[11] = 0x00000001; // kTRD
	eventTrigData.fReadoutListV0.fList[12] = 0x00000001; // kTOF
	eventTrigData.fReadoutListV0.fList[13] = 0x00000000; // kTOF
	eventTrigData.fReadoutListV0.fList[14] = 0x00000000; // kTOF
	eventTrigData.fReadoutListV0.fList[15] = 0x00000001; // kHMPID
	eventTrigData.fReadoutListV0.fList[16] = 0x00000001; // kPHOS
	eventTrigData.fReadoutListV0.fList[17] = 0x00000001; // kCPV
	eventTrigData.fReadoutListV0.fList[18] = 0x00000001; // kPMD
	eventTrigData.fReadoutListV0.fList[19] = 0x00000001; // kMUONTRK
	eventTrigData.fReadoutListV0.fList[20] = 0x00000001; // kMUONTRG
	eventTrigData.fReadoutListV0.fList[21] = 0x00000001; // kFMD
	eventTrigData.fReadoutListV0.fList[22] = 0x00000001; // kT0
	eventTrigData.fReadoutListV0.fList[23] = 0x00000001; // kV0
	eventTrigData.fReadoutListV0.fList[24] = 0x00000001; // kZDC
	eventTrigData.fReadoutListV0.fList[25] = 0x00000001; // kACORDE
	eventTrigData.fReadoutListV0.fList[26] = 0x00000001; // kTRG
	eventTrigData.fReadoutListV0.fList[27] = 0x00000001; // kEMCAL
	eventTrigData.fReadoutListV0.fList[28] = 0x00000001; // kDAQTEST
	eventTrigData.fReadoutListV0.fList[29] = 0x00000001; // kHLT
	
	AliHLTComponentTriggerData trigData = {
		sizeof(AliHLTComponentTriggerData),
		sizeof(AliHLTEventTriggerDataV0),
		&eventTrigData
	};
	
	AliHLTReadoutList readoutlistExpected;
	for (Int_t i = 0; i < AliHLTDAQ::NumberOfDetectors(); ++i)
	{
		Int_t ddlid = AliHLTDAQ::DdlIDOffset(i);
		readoutlistExpected.EnableDDLBit(ddlid);
	}
	
	const AliHLTUInt8_t (*attribs)[gkAliHLTBlockDAttributeCount];
	AliHLTUInt64_t status = 0x0;
	const AliRawDataHeader* cdh = NULL;
	AliHLTReadoutList readoutlist;
	
	int result = AliHLTComponent::ExtractTriggerData(trigData, &attribs, &status, &cdh, &readoutlist, true);
	if (result != 0)
	{
		cerr << "ERROR: The method AliHLTComponent::ExtractTriggerData"
			" fails for the old structure format." << endl;
		return false;
	}
	if (attribs != &eventTrigData.fAttributes)
	{
		cerr << "ERROR: The method AliHLTComponent::ExtractTriggerData"
			" fails to locate the attributes structure correctly." << endl;
		return false;
	}
	if (status != 0x123)
	{
		cerr << "ERROR: The method AliHLTComponent::ExtractTriggerData"
			" fails to locate the HLT status word correctly." << endl;
		return false;
	}
	if ((const void*)cdh != (void*)&eventTrigData.fCommonHeader)
	{
		cerr << "ERROR: The method AliHLTComponent::ExtractTriggerData"
			" fails to locate the Common Data Header (CDH) structure correctly." << endl;
		return false;
	}
	if (memcmp(readoutlist.Buffer(), readoutlistExpected.Buffer(), readoutlist.BufferSize()) != 0)
	{
		cerr << "ERROR: The method AliHLTComponent::ExtractTriggerData"
			" fails to extract the readout list correctly." << endl;
		return false;
	}
	
	return true;
}

/**
 * Tests to see if reading old AliHLTReadoutList versions from root files works.
 * \param filename  The name of the file generated by GenerateReadoutListFile.C,
 *      which contains the readout list objects to test.
 */
bool CheckReadingOldFormat(const char* filename = "oldAliHLTReadoutListFormat.root")
{
	TFile file(filename, "READ");
	
	// Load the readout list objects.
	AliHLTReadoutList* rl[5] = {NULL, NULL, NULL, NULL, NULL};
	for (int i = 0; i < 5; ++i)
	{
		char name[1024];
		sprintf(name, "readoutlist%d", i+1);
		rl[i] = dynamic_cast<AliHLTReadoutList*>(file.Get(name));
		if (rl[i] == NULL)
		{
			cerr << "ERROR: Could not get object '" << name
				<< "' from file '" << filename << "'." << endl;
			return false;
		}
	}
	
	// Now load the tree and see that the objects are the same as the readout
	// list objects stored directly to the TFile.
	const char* treename = "rltree";
	TTree* tree = dynamic_cast<TTree*>(file.Get(treename));
	if (tree == NULL)
	{
		cerr << "ERROR: Could not get TTree '" << treename
			<< "' from file '" << filename << "'." << endl;
		return false;
	}
	AliHLTReadoutList* r = new AliHLTReadoutList;
	tree->SetBranchAddress("readoutlist", &r);
	for (int i = 0; i < 5; ++i)
	{
		tree->GetEvent(i);
		if (r->BufferSize() != rl[i]->BufferSize())
		{
			cerr << "ERROR: readoutlist" << i+1
				<< " and the one from the TTree have different sizes."
				<< endl;
			return false;
		}
#if 1 // ROOT_SVN_REVISION < 9999  //FIXME: after fixed https://savannah.cern.ch/bugs/?69241
		r->SetDDLBit(9999999, kTRUE);  // Triggers a reformating of the internal structure to the new version.
#endif
		if (memcmp(r->Buffer(), rl[i]->Buffer(), r->BufferSize()) != 0)
		{
			cerr << "ERROR: readoutlist" << i+1
				<< " and the one from the TTree are different."
				<< endl;
			return false;
		}
	}
	
	// Now check each readout list individually.
	typedef AliHLTReadoutList RL;
	Int_t alwaysoff = RL::kITSSPD
		| RL::kITSSDD
		| RL::kITSSSD
		| RL::kTPC
		| RL::kTRD
		| RL::kTOF
		| RL::kHMPID
		| RL::kPHOS
		| RL::kCPV
		| RL::kPMD
		| RL::kMUONTRK
		| RL::kMUONTRG
		| RL::kFMD
		| RL::kT0
		| RL::kV0
		| RL::kZDC
		| RL::kACORDE;
	
	// We will need to try and set the missing EMCAL DDL bits.
	// Otherwise the DetectorEnabled and DetectorDisabled methods will not
	// give the expected answers.
	for (int i = 24; i < AliHLTDAQ::NumberOfDdls("EMCAL"); ++i)
	{
		for (int j = 1; j <= 3; ++j)
		{
			Int_t ddlid = AliHLTDAQ::DdlIDOffset("EMCAL") | (i & 0xFF);
			rl[j]->EnableDDLBit(ddlid);
		}
	}
	
	int rlnum = 0;
	if (not (rl[rlnum]->DetectorEnabled(RL::kTRG) and
	         rl[rlnum]->DetectorDisabled(alwaysoff | RL::kEMCAL | RL::kDAQTEST | RL::kHLT)
	   ))
	{
		rl[0]->Print();
		cerr << "ERROR: readoutlist" << rlnum+1 << " does not have the correct bits set." << endl;
		rl[rlnum]->Print();
		return false;
	}
	rlnum = 1;
	if (not (rl[rlnum]->DetectorEnabled(RL::kTRG | RL::kEMCAL) and
	         rl[rlnum]->DetectorDisabled(alwaysoff | RL::kDAQTEST | RL::kHLT)
	   ))
	{
		cerr << "ERROR: readoutlist" << rlnum+1 << " does not have the correct bits set." << endl;
		rl[rlnum]->Print();
		return false;
	}
	rlnum = 2;
	if (not (rl[rlnum]->DetectorEnabled(RL::kTRG | RL::kEMCAL | RL::kDAQTEST) and
	         rl[rlnum]->DetectorDisabled(alwaysoff | RL::kHLT)
	   ))
	{
		cerr << "ERROR: readoutlist" << rlnum+1 << " does not have the correct bits set." << endl;
		rl[rlnum]->Print();
		return false;
	}
	rlnum = 3;
	if (not (rl[rlnum]->DetectorEnabled(RL::kTRG | RL::kEMCAL | RL::kDAQTEST | RL::kHLT) and
	         rl[rlnum]->DetectorDisabled(alwaysoff)
	   ))
	{
		cerr << "ERROR: readoutlist" << rlnum+1 << " does not have the correct bits set." << endl;
		rl[rlnum]->Print();
		return false;
	}
	rlnum = 4;
	if (not (rl[rlnum]->DetectorEnabled(RL::kTRG | RL::kDAQTEST | RL::kHLT) and
	         rl[rlnum]->DetectorDisabled(alwaysoff | RL::kEMCAL)
	   ))
	{
		cerr << "ERROR: readoutlist" << rlnum+1 << " does not have the correct bits set." << endl;
		rl[rlnum]->Print();
		return false;
	}
	
	return true;
}

/**
 * Runs the unit tests for backward compatibility of AliHLTEventDDL succeeded.
 * \returns true if the tests were passed and false otherwise.
 */
bool testAliHLTEventDDLBackwardCompatibility()
{
	if (not CheckReadoutListConvertedCorrectly()) return false;
	if (not CheckHandlingOfOldAliHLTEventTriggerData()) return false;
	if (not CheckReadingOldFormat()) return false;
	return true;
}

#ifndef __MAKECINT__

int main(int /*argc*/, const char** /*argv*/)
{
	bool resultOk = testAliHLTEventDDLBackwardCompatibility();
	if (not resultOk) return 1;
	return 0;
}

#endif // __MAKECINT__
Commit	Line	Data
7c69da51	1	// $Id: $
	2
	3	/**************************************************************************
	4	* This file is property of and copyright by the ALICE HLT Project *
	5	* ALICE Experiment at CERN, All rights reserved. *
	6	* *
	7	* Primary Authors: Artur Szostak <artursz@iafrica.com> *
	8	* for The ALICE HLT Project. *
	9	* *
	10	* Permission to use, copy, modify and distribute this software and its *
	11	* documentation strictly for non-commercial purposes is hereby granted *
	12	* without fee, provided that the above copyright notice appears in all *
	13	* copies and that both the copyright notice and this permission notice *
	14	* appear in the supporting documentation. The authors make no claims *
	15	* about the suitability of this software for any purpose. It is *
	16	* provided "as is" without express or implied warranty. *
	17	**************************************************************************/
	18
	19	/// @file testAliHLTEventDDLBackwardCompatibility.C
	20	/// @author Artur Szostak <artursz@iafrica.com>
	21	/// @date 25 June 2010
	22	/// @brief Test program for backward compatibility of the AliHLTEventDDL structure.
	23	///
	24
	25	#if defined(__CINT__) && (! defined(__MAKECINT__))
	26	#error This macro must be compiled. Try running as testAliHLTEventDDLBackwardCompatibility.C++.
	27	#endif
	28
	29	#if !defined(__CINT__) \|\| defined(__MAKECINT__)
	30	#include "AliHLTDataTypes.h"
	31	#include "AliHLTReadoutList.h"
	32	#include "AliHLTDAQ.h"
e4d966f5	33	#include "AliHLTComponent.h"
e4d966f5	34	#include "AliRawDataHeader.h"
7c69da51	35	#include "TRandom3.h"
	36	#include "TString.h"
	37	#include "TFile.h"
	38	#include "TTree.h"
	39	#include "Riostream.h"
	40	#include <vector>
	41	#include <algorithm>
	42	#endif
	43
	44	/**
	45	* Tests to see if the AliHLTReadoutList class handles both AliHLTEventDDLV0
	46	* and AliHLTEventDDLV1 correctly.
	47	*/
	48	bool CheckReadoutListConvertedCorrectly()
	49	{
	50	// Initialise the different versions of the structures so that every detector
	51	// has only its first DDL set.
	52	union
	53	{
	54	AliHLTEventDDL eventddlV0;
	55	AliHLTEventDDLV0 bitsV0;
	56	};
	57	bitsV0.fCount = gkAliHLTDDLListSizeV0;
	58	if (gkAliHLTDDLListSizeV0 != 30)
	59	{
	60	cerr << "ERROR: gkAliHLTDDLListSizeV0 has a value of " << gkAliHLTDDLListSizeV0
	61	<< " but expected a value of 30." << endl;
	62	return false;
	63	}
	64	bitsV0.fList[0] = 0x00000001; // kITSSPD
	65	bitsV0.fList[1] = 0x00000001; // kITSSDD
	66	bitsV0.fList[2] = 0x00000001; // kITSSSD
	67	bitsV0.fList[3] = 0x00000001; // kTPC
	68	bitsV0.fList[4] = 0x00000000; // kTPC
	69	bitsV0.fList[5] = 0x00000000; // kTPC
	70	bitsV0.fList[6] = 0x00000000; // kTPC
	71	bitsV0.fList[7] = 0x00000000; // kTPC
	72	bitsV0.fList[8] = 0x00000000; // kTPC
	73	bitsV0.fList[9] = 0x00000000; // kTPC
	74	bitsV0.fList[10] = 0x00000000; // kTPC
	75	bitsV0.fList[11] = 0x00000001; // kTRD
	76	bitsV0.fList[12] = 0x00000001; // kTOF
	77	bitsV0.fList[13] = 0x00000000; // kTOF
	78	bitsV0.fList[14] = 0x00000000; // kTOF
	79	bitsV0.fList[15] = 0x00000001; // kHMPID
	80	bitsV0.fList[16] = 0x00000001; // kPHOS
	81	bitsV0.fList[17] = 0x00000001; // kCPV
	82	bitsV0.fList[18] = 0x00000001; // kPMD
	83	bitsV0.fList[19] = 0x00000001; // kMUONTRK
	84	bitsV0.fList[20] = 0x00000001; // kMUONTRG
	85	bitsV0.fList[21] = 0x00000001; // kFMD
	86	bitsV0.fList[22] = 0x00000001; // kT0
	87	bitsV0.fList[23] = 0x00000001; // kV0
	88	bitsV0.fList[24] = 0x00000001; // kZDC
	89	bitsV0.fList[25] = 0x00000001; // kACORDE
	90	bitsV0.fList[26] = 0x00000001; // kTRG
	91	bitsV0.fList[27] = 0x00000001; // kEMCAL
	92	bitsV0.fList[28] = 0x00000001; // kDAQTEST
	93	bitsV0.fList[29] = 0x00000001; // kHLT
	94
	95	union
	96	{
	97	AliHLTEventDDL eventddlV1;
	98	AliHLTEventDDLV1 bitsV1;
99	};
100	bitsV1.fCount = gkAliHLTDDLListSizeV1;
101	if (gkAliHLTDDLListSizeV1 != 31)
102	{
103	cerr << "ERROR: gkAliHLTDDLListSizeV1 has a value of " << gkAliHLTDDLListSizeV1
104	<< " but expected a value of 31." << endl;
105	return false;
106	}
107	bitsV1.fList[0] = 0x00000001; // kITSSPD
108	bitsV1.fList[1] = 0x00000001; // kITSSDD
109	bitsV1.fList[2] = 0x00000001; // kITSSSD
110	bitsV1.fList[3] = 0x00000001; // kTPC
111	bitsV1.fList[4] = 0x00000000; // kTPC
112	bitsV1.fList[5] = 0x00000000; // kTPC
113	bitsV1.fList[6] = 0x00000000; // kTPC
114	bitsV1.fList[7] = 0x00000000; // kTPC
115	bitsV1.fList[8] = 0x00000000; // kTPC
116	bitsV1.fList[9] = 0x00000000; // kTPC
117	bitsV1.fList[10] = 0x00000000; // kTPC
118	bitsV1.fList[11] = 0x00000001; // kTRD
119	bitsV1.fList[12] = 0x00000001; // kTOF
120	bitsV1.fList[13] = 0x00000000; // kTOF
121	bitsV1.fList[14] = 0x00000000; // kTOF
122	bitsV1.fList[15] = 0x00000001; // kHMPID
123	bitsV1.fList[16] = 0x00000001; // kPHOS
124	bitsV1.fList[17] = 0x00000001; // kCPV
125	bitsV1.fList[18] = 0x00000001; // kPMD
126	bitsV1.fList[19] = 0x00000001; // kMUONTRK
127	bitsV1.fList[20] = 0x00000001; // kMUONTRG
128	bitsV1.fList[21] = 0x00000001; // kFMD
129	bitsV1.fList[22] = 0x00000001; // kT0
130	bitsV1.fList[23] = 0x00000001; // kV0
131	bitsV1.fList[24] = 0x00000001; // kZDC
132	bitsV1.fList[25] = 0x00000001; // kACORDE
133	bitsV1.fList[26] = 0x00000001; // kTRG
134	bitsV1.fList[27] = 0x00000001; // kEMCAL
135	bitsV1.fList[28] = 0x00000000; // kEMCAL
136	bitsV1.fList[29] = 0x00000001; // kDAQTEST
137	bitsV1.fList[30] = 0x00000001; // kHLT
138
139	AliHLTReadoutList rlV0(eventddlV0);
140	AliHLTReadoutList rlV1(eventddlV1);
141
142	// Check that for both readout list versions only the first DDLs are
143	// enabled as expected.
144	for (Int_t i = 0; i < AliHLTDAQ::NumberOfDetectors(); ++i)
145	for (Int_t j = 0; j < AliHLTDAQ::NumberOfDdls(i); ++j)
146	{
147	Int_t ddlid = AliHLTDAQ::DdlIDOffset(i) \| (j & 0xFF);
148	if (j == 0)
149	{
150	if (rlV0.IsDDLDisabled(ddlid))
151	{
152	cerr << "ERROR: The first DDL for detector " << AliHLTDAQ::DetectorName(i)
153	<< " was not enabled for readout list initialised from AliHLTEventDDLV0."
154	<< endl;
155	return false;
156	}
157	if (rlV1.IsDDLDisabled(ddlid))
158	{
159	cerr << "ERROR: The first DDL for detector " << AliHLTDAQ::DetectorName(i)
160	<< " was not enabled for readout list initialised from AliHLTEventDDLV1."
161	<< endl;
162	return false;
163	}
164	}
165	else
166	{
167	if (rlV0.IsDDLEnabled(ddlid))
168	{
169	cerr << "ERROR: DDL " << ddlid << " for detector " << AliHLTDAQ::DetectorName(i)
170	<< " was marked enabled for readout list initialised from AliHLTEventDDLV0."
171	<< endl;
172	return false;
173	}
174	if (rlV1.IsDDLEnabled(ddlid))
175	{
176	cerr << "ERROR: DDL " << ddlid << " for detector " << AliHLTDAQ::DetectorName(i)
177	<< " was marked enabled for readout list initialised from AliHLTEventDDLV1."
178	<< endl;
179	return false;
180	}
181	}
182	}
183
184	// Check that the internal buffers are identical.
185	if (rlV0.BufferSize() != rlV1.BufferSize())
186	{
187	cerr << "ERROR: Buffer sizes for readout lists are different: rlV0.BufferSize() = "
188	<< rlV0.BufferSize() << ", rlV1.BufferSize() = " << rlV1.BufferSize() << endl;
189	return false;
190	}
191	if (memcmp(rlV0.Buffer(), rlV1.Buffer(), rlV0.BufferSize()) != 0)
192	{
193	cerr << "ERROR: Buffers for the two readout list versions are different." << endl;
194	return false;
195	}
196
197	return true;
198	}
199
e4d966f5	200	/**
	201	* Tests to see if AliHLTComponent::ExtractTriggerData recognises the old format
	202	* of AliHLTEventTriggerData and handles it correctly.
	203	*/
	204	bool CheckHandlingOfOldAliHLTEventTriggerData()
	205	{
	206	// Prepare old structure format.
	207	struct AliHLTEventTriggerDataV0
	208	{
	209	AliHLTUInt8_t fAttributes[gkAliHLTBlockDAttributeCount];
	210	AliHLTUInt64_t fHLTStatus;
	211	AliHLTUInt32_t fCommonHeaderWordCnt;
	212	AliHLTUInt32_t fCommonHeader[gkAliHLTCommonHeaderCount];
	213	AliHLTEventDDLV0 fReadoutListV0;
	214	};
	215	AliHLTEventTriggerDataV0 eventTrigData;
	216	memset(&eventTrigData, 0x0, sizeof(eventTrigData));
	217	eventTrigData.fCommonHeaderWordCnt = 8;
	218	eventTrigData.fHLTStatus = 0x123;
	219	eventTrigData.fReadoutListV0.fCount = gkAliHLTDDLListSizeV0;
	220	eventTrigData.fReadoutListV0.fList[0] = 0x00000001; // kITSSPD
	221	eventTrigData.fReadoutListV0.fList[1] = 0x00000001; // kITSSDD
	222	eventTrigData.fReadoutListV0.fList[2] = 0x00000001; // kITSSSD
	223	eventTrigData.fReadoutListV0.fList[3] = 0x00000001; // kTPC
	224	eventTrigData.fReadoutListV0.fList[4] = 0x00000000; // kTPC
	225	eventTrigData.fReadoutListV0.fList[5] = 0x00000000; // kTPC
	226	eventTrigData.fReadoutListV0.fList[6] = 0x00000000; // kTPC
	227	eventTrigData.fReadoutListV0.fList[7] = 0x00000000; // kTPC
	228	eventTrigData.fReadoutListV0.fList[8] = 0x00000000; // kTPC
	229	eventTrigData.fReadoutListV0.fList[9] = 0x00000000; // kTPC
	230	eventTrigData.fReadoutListV0.fList[10] = 0x00000000; // kTPC
	231	eventTrigData.fReadoutListV0.fList[11] = 0x00000001; // kTRD
	232	eventTrigData.fReadoutListV0.fList[12] = 0x00000001; // kTOF
	233	eventTrigData.fReadoutListV0.fList[13] = 0x00000000; // kTOF
	234	eventTrigData.fReadoutListV0.fList[14] = 0x00000000; // kTOF
	235	eventTrigData.fReadoutListV0.fList[15] = 0x00000001; // kHMPID
	236	eventTrigData.fReadoutListV0.fList[16] = 0x00000001; // kPHOS
	237	eventTrigData.fReadoutListV0.fList[17] = 0x00000001; // kCPV
	238	eventTrigData.fReadoutListV0.fList[18] = 0x00000001; // kPMD
	239	eventTrigData.fReadoutListV0.fList[19] = 0x00000001; // kMUONTRK
	240	eventTrigData.fReadoutListV0.fList[20] = 0x00000001; // kMUONTRG
	241	eventTrigData.fReadoutListV0.fList[21] = 0x00000001; // kFMD
	242	eventTrigData.fReadoutListV0.fList[22] = 0x00000001; // kT0
	243	eventTrigData.fReadoutListV0.fList[23] = 0x00000001; // kV0
	244	eventTrigData.fReadoutListV0.fList[24] = 0x00000001; // kZDC
	245	eventTrigData.fReadoutListV0.fList[25] = 0x00000001; // kACORDE
	246	eventTrigData.fReadoutListV0.fList[26] = 0x00000001; // kTRG
	247	eventTrigData.fReadoutListV0.fList[27] = 0x00000001; // kEMCAL
	248	eventTrigData.fReadoutListV0.fList[28] = 0x00000001; // kDAQTEST
	249	eventTrigData.fReadoutListV0.fList[29] = 0x00000001; // kHLT
	250
	251	AliHLTComponentTriggerData trigData = {
	252	sizeof(AliHLTComponentTriggerData),
	253	sizeof(AliHLTEventTriggerDataV0),
	254	&eventTrigData
	255	};
	256
	257	AliHLTReadoutList readoutlistExpected;
	258	for (Int_t i = 0; i < AliHLTDAQ::NumberOfDetectors(); ++i)
	259	{
	260	Int_t ddlid = AliHLTDAQ::DdlIDOffset(i);
	261	readoutlistExpected.EnableDDLBit(ddlid);
	262	}
	263
264	const AliHLTUInt8_t (*attribs)[gkAliHLTBlockDAttributeCount];
265	AliHLTUInt64_t status = 0x0;
266	const AliRawDataHeader* cdh = NULL;
267	AliHLTReadoutList readoutlist;
268
269	int result = AliHLTComponent::ExtractTriggerData(trigData, &attribs, &status, &cdh, &readoutlist, true);
270	if (result != 0)
271	{
272	cerr << "ERROR: The method AliHLTComponent::ExtractTriggerData"
273	" fails for the old structure format." << endl;
274	return false;
275	}
276	if (attribs != &eventTrigData.fAttributes)
277	{
278	cerr << "ERROR: The method AliHLTComponent::ExtractTriggerData"
279	" fails to locate the attributes structure correctly." << endl;
280	return false;
281	}
282	if (status != 0x123)
283	{
284	cerr << "ERROR: The method AliHLTComponent::ExtractTriggerData"
285	" fails to locate the HLT status word correctly." << endl;
286	return false;
287	}
288	if ((const void)cdh != (void)&eventTrigData.fCommonHeader)
289	{
290	cerr << "ERROR: The method AliHLTComponent::ExtractTriggerData"
291	" fails to locate the Common Data Header (CDH) structure correctly." << endl;
292	return false;
293	}
294	if (memcmp(readoutlist.Buffer(), readoutlistExpected.Buffer(), readoutlist.BufferSize()) != 0)
295	{
296	cerr << "ERROR: The method AliHLTComponent::ExtractTriggerData"
297	" fails to extract the readout list correctly." << endl;
298	return false;
299	}
300
301	return true;
302	}
303
7c69da51	304	/**
	305	* Tests to see if reading old AliHLTReadoutList versions from root files works.
	306	* \param filename The name of the file generated by GenerateReadoutListFile.C,
	307	* which contains the readout list objects to test.
	308	*/
	309	bool CheckReadingOldFormat(const char* filename = "oldAliHLTReadoutListFormat.root")
	310	{
	311	TFile file(filename, "READ");
	312
	313	// Load the readout list objects.
	314	AliHLTReadoutList* rl[5] = {NULL, NULL, NULL, NULL, NULL};
	315	for (int i = 0; i < 5; ++i)
	316	{
	317	char name[1024];
	318	sprintf(name, "readoutlist%d", i+1);
	319	rl[i] = dynamic_cast<AliHLTReadoutList*>(file.Get(name));
	320	if (rl[i] == NULL)
	321	{
	322	cerr << "ERROR: Could not get object '" << name
	323	<< "' from file '" << filename << "'." << endl;
	324	return false;
	325	}
	326	}
	327
	328	// Now load the tree and see that the objects are the same as the readout
	329	// list objects stored directly to the TFile.
	330	const char* treename = "rltree";
	331	TTree* tree = dynamic_cast<TTree*>(file.Get(treename));
	332	if (tree == NULL)
	333	{
	334	cerr << "ERROR: Could not get TTree '" << treename
	335	<< "' from file '" << filename << "'." << endl;
	336	return false;
	337	}
	338	AliHLTReadoutList* r = new AliHLTReadoutList;
	339	tree->SetBranchAddress("readoutlist", &r);
	340	for (int i = 0; i < 5; ++i)
	341	{
	342	tree->GetEvent(i);
	343	if (r->BufferSize() != rl[i]->BufferSize())
	344	{
	345	cerr << "ERROR: readoutlist" << i+1
	346	<< " and the one from the TTree have different sizes."
	347	<< endl;
	348	return false;
	349	}
489fb1d7	350	#if 1 // ROOT_SVN_REVISION < 9999 //FIXME: after fixed https://savannah.cern.ch/bugs/?69241
	351	r->SetDDLBit(9999999, kTRUE); // Triggers a reformating of the internal structure to the new version.
	352	#endif
7c69da51	353	if (memcmp(r->Buffer(), rl[i]->Buffer(), r->BufferSize()) != 0)
	354	{
	355	cerr << "ERROR: readoutlist" << i+1
	356	<< " and the one from the TTree are different."
	357	<< endl;
	358	return false;
	359	}
	360	}
	361
	362	// Now check each readout list individually.
	363	typedef AliHLTReadoutList RL;
	364	Int_t alwaysoff = RL::kITSSPD
	365	\| RL::kITSSDD
	366	\| RL::kITSSSD
	367	\| RL::kTPC
	368	\| RL::kTRD
	369	\| RL::kTOF
	370	\| RL::kHMPID
	371	\| RL::kPHOS
	372	\| RL::kCPV
	373	\| RL::kPMD
	374	\| RL::kMUONTRK
	375	\| RL::kMUONTRG
	376	\| RL::kFMD
	377	\| RL::kT0
	378	\| RL::kV0
	379	\| RL::kZDC
	380	\| RL::kACORDE;
	381
	382	// We will need to try and set the missing EMCAL DDL bits.
	383	// Otherwise the DetectorEnabled and DetectorDisabled methods will not
	384	// give the expected answers.
	385	for (int i = 24; i < AliHLTDAQ::NumberOfDdls("EMCAL"); ++i)
	386	{
	387	for (int j = 1; j <= 3; ++j)
	388	{
	389	Int_t ddlid = AliHLTDAQ::DdlIDOffset("EMCAL") \| (i & 0xFF);
	390	rl[j]->EnableDDLBit(ddlid);
	391	}
	392	}
	393
	394	int rlnum = 0;
	395	if (not (rl[rlnum]->DetectorEnabled(RL::kTRG) and
	396	rl[rlnum]->DetectorDisabled(alwaysoff \| RL::kEMCAL \| RL::kDAQTEST \| RL::kHLT)
	397	))
	398	{
	399	rl[0]->Print();
	400	cerr << "ERROR: readoutlist" << rlnum+1 << " does not have the correct bits set." << endl;
	401	rl[rlnum]->Print();
	402	return false;
	403	}
	404	rlnum = 1;
	405	if (not (rl[rlnum]->DetectorEnabled(RL::kTRG \| RL::kEMCAL) and
	406	rl[rlnum]->DetectorDisabled(alwaysoff \| RL::kDAQTEST \| RL::kHLT)
	407	))
	408	{
	409	cerr << "ERROR: readoutlist" << rlnum+1 << " does not have the correct bits set." << endl;
	410	rl[rlnum]->Print();
	411	return false;
	412	}
	413	rlnum = 2;
	414	if (not (rl[rlnum]->DetectorEnabled(RL::kTRG \| RL::kEMCAL \| RL::kDAQTEST) and
	415	rl[rlnum]->DetectorDisabled(alwaysoff \| RL::kHLT)
	416	))
417	{
418	cerr << "ERROR: readoutlist" << rlnum+1 << " does not have the correct bits set." << endl;
419	rl[rlnum]->Print();
420	return false;
421	}
422	rlnum = 3;
423	if (not (rl[rlnum]->DetectorEnabled(RL::kTRG \| RL::kEMCAL \| RL::kDAQTEST \| RL::kHLT) and
424	rl[rlnum]->DetectorDisabled(alwaysoff)
425	))
426	{
427	cerr << "ERROR: readoutlist" << rlnum+1 << " does not have the correct bits set." << endl;
428	rl[rlnum]->Print();
429	return false;
430	}
431	rlnum = 4;
432	if (not (rl[rlnum]->DetectorEnabled(RL::kTRG \| RL::kDAQTEST \| RL::kHLT) and
433	rl[rlnum]->DetectorDisabled(alwaysoff \| RL::kEMCAL)
434	))
435	{
436	cerr << "ERROR: readoutlist" << rlnum+1 << " does not have the correct bits set." << endl;
437	rl[rlnum]->Print();
438	return false;
439	}
440
441	return true;
442	}
443
444	/**
445	* Runs the unit tests for backward compatibility of AliHLTEventDDL succeeded.
446	* \returns true if the tests were passed and false otherwise.
447	*/
448	bool testAliHLTEventDDLBackwardCompatibility()
449	{
450	if (not CheckReadoutListConvertedCorrectly()) return false;
e4d966f5	451	if (not CheckHandlingOfOldAliHLTEventTriggerData()) return false;
7c69da51	452	if (not CheckReadingOldFormat()) return false;
	453	return true;
	454	}
	455
	456	#ifndef __MAKECINT__
	457
	458	int main(int /argc/, const char** /argv/)
	459	{
	460	bool resultOk = testAliHLTEventDDLBackwardCompatibility();
	461	if (not resultOk) return 1;
	462	return 0;
	463	}
	464
	465	#endif // __MAKECINT__