ROOT logo
/**************************************************************************
 * 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.                  *
 **************************************************************************/

/* $Id$ */

//-------------------------------------------------------------------------
//                          Class AliGRPPreprocessor
//                  Global Run Parameters (GRP) preprocessor
//    Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
//    Modified: Ernesto.Lopez.Torres@cern.ch  CEADEN-CERN
//    Modified: Chiara.Zampolli@cern.ch  CERN
//-------------------------------------------------------------------------

#include <TChain.h>
#include <TList.h>
#include <TMap.h>
#include <THashList.h>
#include <TObjString.h>
#include <TObjArray.h>
#include <TGraph.h>
#include <TString.h>
#include <TFile.h>
#include <TPRegexp.h>
#include <Bytes.h>

#include <float.h>

#include "AliGRPPreprocessor.h"
#include "AliGRPObject.h"
#include "AliDCSSensor.h"
#include "AliSplineFit.h"
#include "AliDCSSensorArray.h"
#include "AliRawEventHeaderVersions.h"

#include "AliTriggerConfiguration.h"
#include "AliTriggerRunScalers.h"
#include "AliTriggerInput.h"

#include "AliCDBMetaData.h"
#include "AliESDVertex.h"
#include "AliLHCReader.h"
#include "AliLHCData.h"
#include "AliDCSArray.h"
#include "AliDAQ.h"
#include "AliLTUConfig.h"
#include "AliQAThresholds.h"

class AliLog;
class AliDCSValue;
class AliShuttleInterface;

// needed for ReceivePromptRecoParameters

#include <TSQLServer.h>
#include <TSQLResult.h>
#include <TSQLRow.h>
#include <AliCDBManager.h>
#include <AliCDBMetaData.h>
#include <AliCDBId.h>
#include <AliTriggerConfiguration.h>
#include "AliCTPTimeParams.h"
#include "AliLHCClockPhase.h"

using std::ifstream;
ClassImp(AliGRPPreprocessor)


const Double_t kFitFraction = -1.;                 // Fraction of DCS sensor fits required

//_______________________________________________________________

  const Int_t AliGRPPreprocessor::fgknDAQLbPar = 6; // num parameters in the logbook used to fill the GRP object
  const Int_t AliGRPPreprocessor::fgknDCSDP = 48;   // number of dcs dps
  const Int_t AliGRPPreprocessor::fgknDCSDPHallProbes = 40;   // number of dcs dps
  const Int_t AliGRPPreprocessor::fgknLHCDP = 9;   // number of dcs dps from LHC data
  const Int_t AliGRPPreprocessor::fgkDCSDPHallTopShift = 4;   // shift from the top to get tp the Hall Probes names in the list of DCS DPs
  const Int_t AliGRPPreprocessor::fgkDCSDPNonWorking = 5; // number of non working DCS DPs
  const char* AliGRPPreprocessor::fgkDCSDataPoints[AliGRPPreprocessor::fgknDCSDP] = {
                   "L3Polarity",
                   "DipolePolarity",
                   "L3Current",
                   "DipoleCurrent",
		   "L3_BSF17_H1",
		   "L3_BSF17_H2",
		   "L3_BSF17_H3",
		   "L3_BSF17_Temperature",
		   "L3_BSF4_H1",
		   "L3_BSF4_H2",
		   "L3_BSF4_H3",
		   "L3_BSF4_Temperature",
		   "L3_BKF17_H1",
		   "L3_BKF17_H2",
		   "L3_BKF17_H3",
		   "L3_BKF17_Temperature",
		   "L3_BKF4_H1",
		   "L3_BKF4_H2",
		   "L3_BKF4_H3",
		   "L3_BKF4_Temperature",
		   "L3_BSF13_H1",
		   "L3_BSF13_H2",
		   "L3_BSF13_H3",
		   "L3_BSF13_Temperature",
		   "L3_BSF8_H1",
		   "L3_BSF8_H2",
		   "L3_BSF8_H3",
		   "L3_BSF8_Temperature",
		   "L3_BKF13_H1",
		   "L3_BKF13_H2",
		   "L3_BKF13_H3",
		   "L3_BKF13_Temperature",
		   "L3_BKF8_H1",
		   "L3_BKF8_H2",
		   "L3_BKF8_H3",
		   "L3_BKF8_Temperature",
		   "Dipole_Inside_H1",
		   "Dipole_Inside_H2",
		   "Dipole_Inside_H3",
		   "Dipole_Inside_Temperature",
		   "Dipole_Outside_H1",
		   "Dipole_Outside_H2",
		   "Dipole_Outside_H3",
		   "Dipole_Outside_Temperature",
                   "CavernTemperature",
                   "CavernAtmosPressure",
                   "SurfaceAtmosPressure",
                   "CavernAtmosPressure2"
                 };

  const char* AliGRPPreprocessor::fgkDCSDataPointsHallProbes[AliGRPPreprocessor::fgknDCSDPHallProbes] = {
		   "L3_BSF17_H1",
		   "L3_BSF17_H2",
		   "L3_BSF17_H3",
		   "L3_BSF17_Temperature",
		   "L3_BSF4_H1",
		   "L3_BSF4_H2",
		   "L3_BSF4_H3",
		   "L3_BSF4_Temperature",
		   "L3_BKF17_H1",
		   "L3_BKF17_H2",
		   "L3_BKF17_H3",
		   "L3_BKF17_Temperature",
		   "L3_BKF4_H1",
		   "L3_BKF4_H2",
		   "L3_BKF4_H3",
		   "L3_BKF4_Temperature",
		   "L3_BSF13_H1",
		   "L3_BSF13_H2",
		   "L3_BSF13_H3",
		   "L3_BSF13_Temperature",
		   "L3_BSF8_H1",
		   "L3_BSF8_H2",
		   "L3_BSF8_H3",
		   "L3_BSF8_Temperature",
		   "L3_BKF13_H1",
		   "L3_BKF13_H2",
		   "L3_BKF13_H3",
		   "L3_BKF13_Temperature",
		   "L3_BKF8_H1",
		   "L3_BKF8_H2",
		   "L3_BKF8_H3",
		   "L3_BKF8_Temperature",
		   "Dipole_Inside_H1",
		   "Dipole_Inside_H2",
		   "Dipole_Inside_H3",
		   "Dipole_Inside_Temperature",
		   "Dipole_Outside_H1",
		   "Dipole_Outside_H2",
		   "Dipole_Outside_H3",
		   "Dipole_Outside_Temperature"
                 };
                 
  const Short_t kSensors = 45; // start index position of sensor in DCS DPs
  const Short_t kNumSensors = 3; // Number of sensors in DCS DPs (CavernAtmosPressure, SurfaceAtmosPressure, CavernAtmosPressure2)


  const char* AliGRPPreprocessor::fgkLHCDataPoints[AliGRPPreprocessor::fgknLHCDP] = {
	  "LHC_Beam_Energy",
	  "LHC_MachineMode",
	  "LHC_BeamMode",
          "LHC_Beams_Particle_Type",
	  "BPTX_Phase_Shift_B1",
	  "BPTX_Phase_Shift_B2",
	  "LHC_Particle_Type_B1",
	  "LHC_Particle_Type_B2",
	  "LHC_Data_Quality_Flag"
  };

  const char* kppError[] = {
                   "",
                   "(DAQ logbook ERROR)",
                   "(DAQ FXS ERROR)",
                   "(Trigger Scalers not found in FXS - ERROR)",
                   "(DCS data points ERROR)",
                   "(Trigger Configuration ERROR)",
                   "(DAQ logbook ERROR determining partition of the run)",
                   "(CTP timing ERROR)",
		   "(SPD Mean Vertex ERROR)",
		   "(FXS Error for LHC Data)",
		   "(LHC Data Error)",
		   "(LHC Clock Phase Error (from LHC Data))",
		   "(LTU Configuration Error)",
		   "(DQM Failure)",
                   "(Trigger Aliases wrong or not found in DCS FXS - ERROR)"
  };

//_______________________________________________________________

AliGRPPreprocessor::AliGRPPreprocessor(AliShuttleInterface* shuttle):
	AliPreprocessor("GRP",shuttle),  fPressure(0), fmaxFloat(0), fminFloat(0),fmaxDouble(0), fminDouble(0), fmaxInt(0), fminInt(0), fmaxUInt(0), fminUInt(0),fdaqStartEndTimeOk(kTRUE),ffailedDPs(new TObjArray(fgknDCSDP))
{
	// constructor - shuttle must be instantiated!

	AddRunType("COSMIC");
	AddRunType("LASER");
	AddRunType("PHYSICS");
	AddRunType("CALIBRATION_BC");
	AddRunType("CALIBRATION_CENTRAL");
	AddRunType("CALIBRATION_EMD");
	AddRunType("CALIBRATION_MB");
	AddRunType("CALIBRATION_SEMICENTRAL");
	AddRunType("CALIBRATION");
	AddRunType("PEDESTAL");
	AddRunType("STANDALONE");
	AddRunType("GAIN");
	AddRunType("NOISE");
	AddRunType("PULSER");
        AddRunType("STANDALONE_PULSER");
        AddRunType("STANDALONE_BC");

	fmaxFloat = FLT_MAX;
	fminFloat = -FLT_MAX;
	fmaxDouble = DBL_MAX;
	fminDouble = -DBL_MAX;
	fmaxInt = kMaxInt;
	fminInt = kMinInt;
	fmaxUInt = kMaxUInt;
	fminUInt = 0;

	AliInfo(Form("Max allowed float = %6.5e",fmaxFloat));
	AliInfo(Form("Min allowed float = %6.5e",fminFloat));
	AliInfo(Form("Max allowed double = %6.5e",fmaxDouble));
	AliInfo(Form("Min allowed double = %6.5e",fminDouble));
	AliInfo(Form("Max allowed integer = %d",fmaxInt));
	AliInfo(Form("Min allowed integer = %d",fminInt));
	AliInfo(Form("Max allowed unsigned integer = %u",(Int_t)fmaxUInt));
	AliInfo(Form("Min allowed unsigned integer = %u",(Int_t)fminUInt));

	ffailedDPs->SetOwner(kTRUE);
}

//_______________________________________________________________

AliGRPPreprocessor::~AliGRPPreprocessor()
{
	//destructor
	
	delete fPressure;
	delete ffailedDPs;

}

//_______________________________________________________________

void AliGRPPreprocessor::Initialize(Int_t run, UInt_t startTime, UInt_t endTime)
{
	// Initialize preprocessor

	AliPreprocessor::Initialize(run, startTime, endTime);
	
	AliInfo("Initialization of the GRP preprocessor.");
	AliInfo(Form("Start Time DCS = %d",GetStartTimeDCSQuery()));
	AliInfo(Form("End Time DCS = %d",GetEndTimeDCSQuery()));
	TClonesArray * array = new TClonesArray("AliDCSSensor",kNumSensors); 
	for(Int_t j = 0; j < kNumSensors; j++) {
		AliDCSSensor * sens = new ((*array)[j])AliDCSSensor;
		sens->SetStringID(fgkDCSDataPoints[j+kSensors]);
	}
	AliInfo(Form("Pressure Entries: %d",array->GetEntries()));
	
	fPressure = new AliDCSSensorArray(GetStartTimeDCSQuery(), GetEndTimeDCSQuery(), array);

	ffailedDPs->Clear(); // cleaning ffailedDPs for current run
	for (Int_t iDP=0; iDP < fgknDCSDP; iDP++){
		TObjString* dp = new TObjString(fgkDCSDataPoints[iDP]);
		ffailedDPs->AddAt(dp,iDP);
	}

}

//_______________________________________________________________

UInt_t AliGRPPreprocessor::Process(TMap* valueMap)
{
	// process data retrieved by the Shuttle
	
	// retrieving "partition" and "detector" fields from DAQ logbook to 
	// determine the partition in which the run was taken
	// the partition is used to decide how to react in case of errors for CTP

	TString partition = (TString)GetRunParameter("partition");  
	TString detector = (TString)GetRunParameter("detector");   

	AliGRPObject *grpobj = new AliGRPObject();  // object to store data
	grpobj->SetBeamEnergyIsSqrtSHalfGeV(); // new format

	//=================//
	// DAQ logbook     //
	//=================//

	Log("*************** Processing DAQ logbook");

	UInt_t error = 0;
	
	Int_t iDaqLB = ProcessDaqLB(grpobj);
	TString runType = (TString)GetRunType();
	TString beamType = (TString)GetRunParameter("beamType");
	if(iDaqLB == fgknDAQLbPar) {
		Log(Form("DAQ Logbook, successful! Retrieved %d/%d entries",iDaqLB,fgknDAQLbPar));
	} else {
		Log(Form("DAQ Logbook, could not get all expected entries!!! Retrieved only %d/%d entries",iDaqLB,fgknDAQLbPar));
		error |= 1;
	}

	//=================//
	// DAQ FXS         //
	//=================//

	Log("*************** Processing DAQ FXS");

	UInt_t iDaqFxs = ProcessDaqFxs();
	if( iDaqFxs == 0 ) {
		Log(Form("DAQ FXS, successful!"));
	} else {
		Log(Form("DAQ FXS, could not store run raw tag file!!!"));
		error |= 2;
	}
	
	//=================//
	// DCS FXS         //
	//=================//

	Log("*************** Processing DCS FXS");

	UInt_t iDcsFxs = ProcessDcsFxs(partition, detector);
	if( iDcsFxs == 0 ) {
		Log(Form("DCS FXS, successful!"));
	} else  if (iDcsFxs ==1) {
		Log(Form("Could not store CTP scalers!!!"));
		error |= 4;
	} else  if (iDcsFxs == 2) {
		Log(Form("Could not store CTP aliases!!!"));
		error |= 8192;
	} else{
		Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without CTP scalers...",partition.Data(),detector.Data()));
		error |= 32;
	}
	
	//=================//
	// DCS data points //
	//=================//

	Log("*************** Processing DCS DPs");

	Log(Form("Starting DCS Query at %d and finishing at %d",GetStartTimeDCSQuery(),GetEndTimeDCSQuery()));
	Int_t entries = ProcessDcsDPs( valueMap, grpobj );
	Log(Form("entries found = %d (should be %d)",entries, fgknDCSDP-fgkDCSDPNonWorking));
	if (fdaqStartEndTimeOk){
		if( entries < fgknDCSDP - fgkDCSDPNonWorking ) { // L3_BSF4_H3, L3_BSF17_H1, L3_BSF17_H2, L3_BSF17_H3, L3_BSF17_Temperature are not working yet...  
			Log(Form("Possible problem with the DCS data points!!! Only %d/%d entries found - Please read further for more details",entries,fgknDCSDP-fgkDCSDPNonWorking));
			Log(Form("The DPs giving problems were:"));
			for (Int_t iDP = 0; iDP < fgknDCSDP; iDP++){
				TObjString *dpString = (TObjString*)ffailedDPs->At(iDP);
				if (dpString){
					TString name = dpString->String();
					if (name != "L3_BSF4_H3" && name != "L3_BSF17_H1" && name != "L3_BSF17_H2" && name != "L3_BSF17_H3" && name != "L3_BSF17_Temperature" ){
						Log(Form("******** %s ******** not present, but foreseen --> causing an ERROR",name.Data()));
					}
					else {
						Log(Form(" %s is not present, but was not generating any error since it is not ready in DCS - check the other DPs in this list!",name.Data()));
					}
				}
			}
			error |= 8;
		}
		else  Log(Form("DCS data points, successful!"));
	}
	else Log(Form("Statistical values for DCS DPs could not be computed due to missing DAQ_time_start and DAQ_time_end fields in DAQ logbook")); 
	
	//=======================//
	// Trigger Configuration //
	//=======================//

	Log("*************** Processing Trigger Configuration");

	const char * triggerConf = GetTriggerConfiguration();

	if (partition.IsNull() && !detector.IsNull()){ // standalone partition
		Log("STANDALONE partition for current run, using Trigger Configuration dummy value");
		AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyConfig");
		if (!cdbEntry) {
			Log(Form("No dummy CTP configuration entry found, going into error..."));
			error |= 16;
		}
		else{
			AliTriggerConfiguration *runcfg = (AliTriggerConfiguration*)cdbEntry->GetObject();
			if (!runcfg){
				Log(Form("dummy CTP config not found in OCDB entry, going into error..."));
				error |= 16;
			}
			else {
				TString titleCTPcfg = Form("CTP cfg for run %i from Dummy entry in OCDB",fRun);
				runcfg->SetTitle(titleCTPcfg);
				AliCDBMetaData metaData;
				metaData.SetResponsible("Roman Lietava");
				metaData.SetComment("CTP run configuration from dummy entry in OCDB");
				if (!Store("CTP","Config", runcfg, &metaData, 0, 0)) {
					Log("Unable to store the dummy CTP run configuration object to OCDB!");
					error |= 16;
				}
			}
		}
	}

	else if (!partition.IsNull() && detector.IsNull()){ // global partition
		Log("GLOBAL partition for current run, using Trigger Configuration from DAQ Logbook");
		if (triggerConf!= NULL) {
			Log("Found trigger configuration in DAQ logbook");
			AliTriggerConfiguration *runcfg = AliTriggerConfiguration::LoadConfigurationFromString(triggerConf);	  
			if (!runcfg) {
				Log("Bad CTP run configuration file from DAQ logbook! The corresponding CDB entry will not be filled!");
				error |= 16;
			}
			else {
				TString titleCTPcfg = Form("CTP cfg for run %i from DAQ",fRun);
				runcfg->SetTitle(titleCTPcfg);
				AliCDBMetaData metaData;
				metaData.SetBeamPeriod(0);
				metaData.SetResponsible("Roman Lietava");
				metaData.SetComment("CTP run configuration from DAQ logbook");
				if (!Store("CTP","Config", runcfg, &metaData, 0, 0)) {
					Log("Unable to store the CTP run configuration object to OCDB!");
					error |= 16;
				}
			}
		}

		else {
			Log("Trigger configuration NULL in DAQ logbook");
			error |= 16;
		}
	}

	else {
		Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without trigger configuration...",partition.Data(),detector.Data()));
		error |= 32;
	}

        //===========================//
	// Trigger Timing Parameters //
        //===========================//

	Log("*************** Processing Trigger Time Params");
	
	const char * triggerCTPtiming = GetCTPTimeParams();

	if (partition.IsNull() && !detector.IsNull()){ // standalone partition
		Log("STANDALONE partition for current run, using CTP timing params dummy value");
		AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyCTPtime");
		if (!cdbEntry) {
			Log(Form("No dummy CTP timing parameters entry found, going into error..."));
			error |= 64;
		}
		else{
			AliCTPTimeParams *runCTPtiming = (AliCTPTimeParams*)cdbEntry->GetObject();
			if (!runCTPtiming){
				Log(Form("dummy CTP timing parameters not found in OCDB entry, going into error..."));
				error |= 64;
			}
			else {
				TString titleCTPtiming = Form("CTP timing params for run %i from Dummy entry in OCDB",fRun);
				runCTPtiming->SetTitle(titleCTPtiming);
				AliCDBMetaData metadata;
				metadata.SetResponsible("Roman Lietava");
				metadata.SetComment("CTP run timing parameters from dummy entry in OCDB");
				if (!Store("CTP","CTPtiming", runCTPtiming, &metadata, 0, 0)) {
					Log("Unable to store the dummy CTP timing params object to OCDB!");
					error |= 64;
				}
			}
		}
	}

	else if (!partition.IsNull() && detector.IsNull()){ // global partition
		Log("GLOBAL partition for current run, using Trigger Timing Parameters from DAQ Logbook");
		if (triggerCTPtiming!= NULL) {
			Log("Found trigger timing params in DAQ logbook");
			AliDebug(2,Form("%s",triggerCTPtiming));
			AliCTPTimeParams *runCTPtiming = AliCTPTimeParams::LoadCTPTimeParamsFromString(triggerCTPtiming);	  
			if (!runCTPtiming) {
				Log("Bad CTP trigger timing params file from DAQ logbook! The corresponding CDB entry will not be filled!");
				error |= 64;
			}
			else {
				TString titleCTPtiming = Form("CTP timing params for run %i from DAQ",fRun);
				runCTPtiming->SetTitle(titleCTPtiming);
				AliCDBMetaData metadata;
				metadata.SetBeamPeriod(0);
				metadata.SetResponsible("Roman Lietava");
				metadata.SetComment("CTP timing params from DAQ logbook");
				if (!Store("CTP","CTPtiming", runCTPtiming, &metadata, 0, 0)) {
					Log("Unable to store the CTP timing params object to OCDB!");
					error |= 64;
				}
			}
		}

		else {
			Log("Trigger timing params NULL in DAQ logbook");
			error |= 64;
		}
	}

	else {
		Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without trigger timing parameters...",partition.Data(),detector.Data()));
		error |= 32;
	}

        //===========================//
	// LTU Configuration         //
        //===========================//

	Log("*************** Processing LTU Configuration");
	
	if (partition.IsNull() && !detector.IsNull()){ // standalone partition
		Log("STANDALONE partition for current run, using LTU configuration dummy value");
		AliCDBEntry *cdbEntry = GetFromOCDB("CTP","DummyLTUConfig");
		if (!cdbEntry) {
			Log(Form("No dummy LTU Config entry found, going into error..."));
			error |= 2048;
		}
		else{
			TObjArray *ltuConfig = (TObjArray*)cdbEntry->GetObject();
			if (!ltuConfig){
				Log(Form("dummy LTU Config not found in OCDB entry, going into error..."));
				error |= 2048;
			}
			else {
				AliCDBMetaData metadata;
				metadata.SetResponsible("Roman Lietava");
				metadata.SetComment("LTU Config from dummy entry in OCDB");
				if (!Store("CTP","LTUConfig", ltuConfig, &metadata, 0, 0)) {
					Log("Unable to store the dummy LTU Config object to OCDB!");
					error |= 2048;
				}
			}
		}
	}

	else if (!partition.IsNull() && detector.IsNull()){ // global partition
	
		Log("GLOBAL partition for current run, getting LTU Config from DAQ Logbook (logbook_detectors table)");
		UInt_t  detectorMask = (UInt_t)(((TString)GetRunParameter("detectorMask")).Atoi());
		Printf ("detectormask = %d",detectorMask);
		TObjArray * ltuarray = new TObjArray();
		ltuarray->SetOwner(1);
		Bool_t isLTUok = kTRUE;
		for(Int_t i = 0; i<AliDAQ::kNDetectors-2; i++){
			if ((detectorMask >> i) & 0x1) {
				TString det = AliDAQ::OfflineModuleName(i);
				TString detCTPName = AliTriggerInput::fgkCTPDetectorName[i];
				if (detCTPName == "CTP") {
					detCTPName="TRG"; // converting according to what is found in DAQ logbook_detectors					
					Printf("Processing CTP (CTP Detector name %s) --> SKIPPING, CTP does not have any LTU!!!!!!",detCTPName.Data());
					continue;
				}				
				Printf("Processing detector %s (CTP Detector name %s)",det.Data(),detCTPName.Data());
				TString* ltu = GetLTUConfig(detCTPName.Data());
				if (!ltu){
					Log(Form("No LTU Configuration from DAQ logbook for detector %s (BUT it was expected)! The corresponding CDB entry will not be filled!",detCTPName.Data()));
					error |= 2048;
					isLTUok = kFALSE;
					break;
				}
				else{
					Float_t ltuFineDelay1 = ltu[0].Atof();
					Float_t ltuFineDelay2 = ltu[1].Atof();
					Float_t ltuBCDelayAdd = ltu[2].Atof();
					const char* name = AliDAQ::DetectorName(i);
					AliLTUConfig* ltuConfig = new AliLTUConfig((UChar_t)AliDAQ::DetectorID(name),ltuFineDelay1,ltuFineDelay2,ltuBCDelayAdd);
					ltuarray->AddAtAndExpand(ltuConfig,i);
				}				
			}
		}
		if (isLTUok){
			AliCDBMetaData metadata;
			metadata.SetBeamPeriod(0);
			metadata.SetResponsible("Roman Lietava");
			metadata.SetComment("LTU Configuration for current run");
			if (!Store("CTP","LTUConfig", ltuarray, &metadata, 0, 0)) {
				Log("Unable to store the LTU Config object to OCDB!");
				error |= 2048;
			}		
		}
		delete ltuarray;
	}

	else {
		Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error without trigger timing parameters...",partition.Data(),detector.Data()));
		error |= 32;
	}


	//=================//
	// LHC Data        //
	//=================//

	if (runType == "PHYSICS"){  // processing the LHC file only in PHYSICS runs
		Log("*************** Processing LHC Data");

		UInt_t iLHCData = ProcessLHCData(grpobj);
		
		if( iLHCData == 0 ) {
			Log(Form("LHC Data from FXS, successful!"));
		} else  if (iLHCData == 1) {
			Log(Form("LHC Data, problems with FXS!"));
			error |= 256;
		} else  if (iLHCData == 2) {
			Log(Form("LHC Data, problems with DAQ_time_start/DAQ_time_end!"));
			error |= 512;
		} else if (iLHCData ==3){
			Log(Form("Problems in storing LHC Phase - going into Error"));
			error |= 1024;
		} else if (iLHCData ==4){
			Log(Form("Problems with LHC Phase - going into Error"));
			error |= 1024;
		} else{
			Log(Form("LHC Data problems"));
			error |= 512;
		}
	
	}

	//==================//
	// SPD Mean Vertex  //
	//==================//

	Log("*************** Processing SPD Mean Vertex");

	if (runType == "PHYSICS"){
		UInt_t iSPDMeanVertex = ProcessSPDMeanVertex();
		if( iSPDMeanVertex == 1 ) {
			Log(Form("SPD Mean Vertex, successful!"));
		} else {
			Log(Form("SPD Mean Vertex failed!!!"));
			error |= 128; 
		}
	}
	else {
		Log("SPD Mean Vertex not processed since runType != PHYSICS");
	}

	//=================//
	// DQM FXS         //
	//=================//

	Log("*************** Processing DQM FXS");

	UInt_t iDqmFxs = ProcessDqmFxs();
	if( iDqmFxs == 1 ) {
		Log(Form("DQM FXS, successful!"));
	} else {
		Log(Form("DQM FXS failed!!!"));
		error |= 4096;
	}

	// storing AliGRPObject in OCDB

	AliCDBMetaData md;
	md.SetResponsible("Chiara Zampolli");
	md.SetComment("Output parameters from the GRP preprocessor.");
	
	Bool_t result = kTRUE;
	result = Store("GRP", "Data", grpobj, &md); 
	delete grpobj;

	if (result && !error ) {
		Log("GRP Preprocessor Success");
		return 0;
	} else {
		Log( Form("GRP Preprocessor FAILS!!! %s%s%s%s%s%s%s%s%s%s%s%s%s%s",
			  kppError[(error&1)?1:0],
			  kppError[(error&2)?2:0],
			  kppError[(error&4)?3:0],
			  kppError[(error&8)?4:0],
			  kppError[(error&16)?5:0],
			  kppError[(error&32)?6:0],
			  kppError[(error&64)?7:0],
			  kppError[(error&128)?8:0],
			  kppError[(error&256)?9:0],
			  kppError[(error&512)?10:0],
			  kppError[(error&1024)?11:0],
			  kppError[(error&2048)?12:0],
			  kppError[(error&4096)?13:0],
			  kppError[(error&8192)?14:0]
			  ));
		return error;
	}


}

//_______________________________________________________________

UInt_t AliGRPPreprocessor::ProcessLHCData(AliGRPObject *grpobj)
{
	//
	//Getting the LHC Data from DCS FXS
	//

	TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
	TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
	if (timeStartString.IsNull() || timeEndString.IsNull()){
		if (timeStartString.IsNull()){ 
			AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
		}
		else if (timeEndString.IsNull()){
			AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
		}
		return 2;
	}  

	Double_t timeStart = timeStartString.Atof();
	Double_t timeEnd = timeEndString.Atof();

	TString fileName = GetFile(kDCS, "LHCData","");
	if (fileName.Length()>0){
		AliInfo("Got The LHC Data file");
		AliLHCReader lhcReader;

		// Processing data to be put in AliGRPObject

		// Energy
		Log("*************Energy ");
		TObjArray* energyArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[0]);
		if (energyArray){			
			Float_t energy = ProcessEnergy(energyArray,timeStart);
			if (energy != -1.) {
				grpobj->SetBeamEnergy(energy);
				grpobj->SetBeamEnergyIsSqrtSHalfGeV(kTRUE);
			}
			delete energyArray;
		}
		else {
			AliError("Energy not found in LHC Data file!!!");
		}	

		Double_t timeBeamModeEnd = timeEnd;        // max validity for Beam Mode 
		Double_t timeMachineModeEnd = timeEnd;     // max validity for Machine Mode
 		Double_t timeBeamEnd = timeEnd;            // max validity for Beam Type
 		Double_t timeBeamTypeEnd[2] = {timeEnd, timeEnd}; // max validity for Beam Type1,2
		Double_t timeBeamModeStart = -1;    // min validity for Beam Mode
		Double_t timeMachineModeStart = -1; // min validity for Machine Mode
		Double_t timeBeamStart = -1;        // min validity for Beam Type
		Double_t timeBeamTypeStart[2] = {-1,-1};        // min validity for Beam Type1,2
		Int_t indexBeamMode = -1;                  // index of measurement used to set Beam Mode
	        Int_t indexMachineMode = -1;               // index of measurement used to set Machine Mode
		Int_t indexBeam = -1;                      // index of measurement used to set Beam Type
		Int_t indexBeamType[2] = {-1, -1};                      // index of measurement used to set Beam Type1,2
		Bool_t foundBeamModeStart = kFALSE;        // flag to be set in case an entry for the Beam Mode is found before (or at) SOR
		Bool_t foundMachineModeStart = kFALSE;     // flag to be set in case an entry for the Machine Mode is found before (or at) SOR
		Bool_t foundBeamStart = kFALSE;            // flag to be set in case an entry for the Beam Type is found before (or at) SOR
		Bool_t foundBeamTypeStart[2] = {kFALSE, kFALSE};            // flag to be set in case an entry for the Beam Type1,2 is found before (or at) SOR
		Bool_t flagBeamMode = kFALSE;  //flag set true if a changed occurred in BeamMode
		Bool_t flagMachineMode = kFALSE;  //flag set true if a changed occurred in MachineMode
		Bool_t flagBeam = kFALSE;  //flag set true if a changed occurred in BeamType
		Bool_t flagBeamType[2] = {kFALSE, kFALSE};  //flag set true if a changed occurred in BeamType1,2
		
		Double_t arrayTimes[5]={2.E9, 2.E9, 2.E9, 2.E9, 2.E9}; // array to keep track of the times of the possible changes of the LHC DPs; each entry set to Wed May 18 2033, 03:33:20 GMT (ALICE should not be running anymore...)
		                                                       // arrayTimes elements order correspond to the one used in the array of the strings fgkLHCDataPoints, i.e.:
		                                                       // arrayTimes[0] --> MachineMode
		                                                       // arrayTimes[1] --> BeamMode
		                                                       // arrayTimes[2] --> BeamType (when written together)
		                                                       // arrayTimes[3] --> BeamType1 (when written separate)
		                                                       // arrayTimes[4] --> BeamType2 (when written separate)

		// BeamMode
		Log("*************BeamMode (LHCState) ");
		TObjArray* beamModeArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[2]);
		Int_t nBeamMode = -1;
		if (beamModeArray){	
			nBeamMode = beamModeArray->GetEntries();	
			if (nBeamMode==0){
				AliInfo("Found zero entries for the Beam Mode, leaving it empty");
			}
			else{
				for (Int_t iBeamMode = 0; iBeamMode<nBeamMode; iBeamMode++){
					AliDCSArray* beamMode = (AliDCSArray*)beamModeArray->At(iBeamMode);
					if (beamMode){
						if (beamMode->GetTimeStamp()<=timeStart && beamMode->GetTimeStamp()>=timeBeamModeStart){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
							timeBeamModeStart = beamMode->GetTimeStamp();
							indexBeamMode = iBeamMode;
							foundBeamModeStart = kTRUE;
						}
						else {
							break;

						}
					}
				}
				if (!foundBeamModeStart){
					AliInfo("No value for the Beam Mode found before start of run, the Beam Mode will remain empty");
				}
				else {
					AliDCSArray* beamMode = (AliDCSArray*)beamModeArray->At(indexBeamMode);
					TObjString* beamModeString = beamMode->GetStringArray(0);
					AliInfo(Form("LHC State (corresponding to BeamMode) = %s (set at %f)",(beamModeString->String()).Data(),beamMode->GetTimeStamp()));
					grpobj->SetLHCState(beamModeString->String());
					if (indexBeamMode < nBeamMode-1){
						AliDCSArray* beamMode1 = (AliDCSArray*)beamModeArray->At(indexBeamMode+1);
						if (beamMode1){
							if (beamMode1->GetTimeStamp()<=timeStart){
								AliError("you did not choose the correct value! there is still something before (or at) SOR, but later than this!");
							}
							else if (beamMode1->GetTimeStamp()>timeStart && beamMode1->GetTimeStamp()<=timeEnd){
								timeBeamModeEnd = beamMode1->GetTimeStamp();
								TObjString* beamModeString1 = beamMode1->GetStringArray(0);
							        TString bmString0 = beamModeString->String();
							        TString bmString1 = beamModeString1->String();
								if (bmString0.CompareTo(bmString1.Data(),TString::kIgnoreCase) == -1){
									AliWarning(Form("The beam mode changed from %s to %s during the run at timestamp %f! Setting it to %s and keeping track of the time of the change to set MaxTimeLHCValidity afterward",bmString0.Data(), bmString1.Data(), timeBeamModeEnd, bmString0.Data()));
									flagBeamMode = kTRUE;
									arrayTimes[1]=timeBeamModeEnd;

								}
							}
						}
						else {
							AliInfo("Invalid pointer for the first entry for Beam Mode after the first valid one, not considering anything after what has already been found");
						}
					}
				}
			}
			delete beamModeArray;
		}
		else{
			AliError("Beam mode array not found in LHC Data file!!!");
		}
		
		// MachineMode
		Log("*************MachineMode ");
		TObjArray* machineModeArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[1]);
		Int_t nMachineMode = -1;
		if (machineModeArray){
			nMachineMode = machineModeArray->GetEntries();
			if (nMachineMode==0){
				AliInfo("No Machine Mode found, leaving it empty");
			}
			else{
				for (Int_t iMachineMode = 0; iMachineMode<nMachineMode; iMachineMode++){
					AliDCSArray* machineMode = (AliDCSArray*)machineModeArray->At(iMachineMode);
					if (machineMode){
						if (machineMode->GetTimeStamp()<=timeStart && machineMode->GetTimeStamp()>=timeMachineModeStart){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
							timeMachineModeStart = machineMode->GetTimeStamp();
							indexMachineMode = iMachineMode;
							foundMachineModeStart = kTRUE;
						}
						else{
							break;
						}
					}
				}
				if (!foundMachineModeStart){
					AliInfo("No value for the Machine Mode found before start of run, the Machine Mode will remain empty");
				}
				else {
					AliDCSArray* machineMode = (AliDCSArray*)machineModeArray->At(indexMachineMode);
					TObjString* machineModeString = machineMode->GetStringArray(0);
					AliInfo(Form("MachineMode = %s (set at %f)",(machineModeString->String()).Data(),machineMode->GetTimeStamp()));
					grpobj->SetMachineMode(machineModeString->String());
					if (indexMachineMode < nMachineMode-1){
						AliDCSArray* machineMode1 = (AliDCSArray*)machineModeArray->At(indexMachineMode+1);
						if (machineMode1){
							if (machineMode1->GetTimeStamp()>timeStart && machineMode1->GetTimeStamp()<=timeEnd){
								timeMachineModeEnd = machineMode1->GetTimeStamp();
								TObjString* machineModeString1 = machineMode1->GetStringArray(0);
							        TString mmString0 = machineModeString->String();
							        TString mmString1 = machineModeString1->String();
								if (mmString0.CompareTo(mmString1.Data(),TString::kIgnoreCase) == -1){
									AliWarning(Form("The machine mode changed from %s to %s during the run at timestamp %f! Setting it to %s and keeping track of the time of the change to set MaxTimeLHCValidity afterward",mmString0.Data(),mmString1.Data(),timeMachineModeEnd,mmString0.Data()));
									flagMachineMode = kTRUE;
									arrayTimes[0]=timeMachineModeEnd;
								}
							}
						}
						else {
							AliInfo("Invalid pointer for the first entry for Machine Mode after the first valid one, not considering anything after what has already been found");
						}
					}
				}
			}
			delete machineModeArray;
		}
		else{
			AliError("Machine mode array not found in LHC Data file!!!");
		}
		
		// BeamType1 and BeamType2 - both put in the same string
		Log("*************BeamType ");
		TObjArray* beamArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[3]);
		if (beamArray){			
			Int_t nBeam = beamArray->GetEntries();
			if (nBeam==0){
				AliInfo("No Beam Type found, leaving it empty");
			}
			else{
				for (Int_t iBeam = 0; iBeam<nBeam; iBeam++){
					AliDCSArray* beam = (AliDCSArray*)beamArray->At(iBeam);
					if (beam){
						if (beam->GetTimeStamp()<=timeStart && beam->GetTimeStamp()>=timeBeamStart){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
							timeBeamStart = beam->GetTimeStamp();
							indexBeam = iBeam;
							foundBeamStart = kTRUE;
						}
						else{
							break;
						}
					}
				}
				if (!foundBeamStart){
					AliInfo("No value for the Beam Type found before start of run, the (common) Beam Type will remain empty");
				}
				else {
					AliDCSArray* beam = (AliDCSArray*)beamArray->At(indexBeam);
					TObjString* beamString = beam->GetStringArray(0);
					TString beamType = beamString->String();
					AliInfo(Form("Beam Type = %s",beamType.Data()));	
					if (beamType.CompareTo("PROTON",TString::kIgnoreCase) == 0){
						AliInfo("Setting beam type to p-p");
						grpobj->SetBeamType("p-p");
					}
					else { // if there is no PROTON beam, we suppose it is Pb, and we put A-A
						AliInfo("Setting beam type to A-A");
						grpobj->SetBeamType("A-A");
					}
					/*
					  else if (beamType.CompareTo("LEAD82",TString::kIgnoreCase) == 0){
						AliInfo("Setting beam type to Pb-Pb");
						grpobj->SetBeamType("Pb-Pb");
					}
					else{
						AliError("Beam Type not known, leaving it empty");
					}
					*/
					if (indexBeam < nBeam-1){
						AliDCSArray* beam1 = (AliDCSArray*)beamArray->At(indexBeam+1);
						if (beam1){
							if (beam1->GetTimeStamp()>timeStart && beam1->GetTimeStamp()<=timeEnd){
								timeBeamEnd = beam1->GetTimeStamp();
								TObjString* beamString1 = beam1->GetStringArray(0);
								TString beamType1 = beamString1->String();
								if (beamType.CompareTo(beamType1.Data(),TString::kIgnoreCase) == -1){
									AliWarning(Form("The Beam Type changed from %s to %s during the run at timestamp %f! Setting it to %s and keeping track of the time of the change to set MaxTimeLHCValidity afterward",beamType.Data(),(beamString1->String()).Data(),timeBeamEnd,beamType.Data()));
									flagBeam = kTRUE;
									arrayTimes[2] = timeBeamEnd;
								}
							}
						}
						else {
							AliInfo("Invalid pointer for the first entry for Beam Type after the first valid one, not considering anything after what has already been found");
						}
					}
				}
			}
			delete beamArray;
		}
		else{
			AliError("Beam Type array not found in LHC Data file!!!");
		}		

		// BeamType1 and BeamType2 - in separete string
		Log("*************BeamType, 1 and 2 ");
		Int_t indexBeamTypeString = 6;  // index of the string with the alias of BeanType1 in the array fgkLHCDataPoints
		TString combinedBeamType = "-";  // combined beam type, built from beam type 1 and beam type 2
		TString combinedBeamTypeFromLHC = "-";  // combined beam type, built from beam type 1 and beam type 2 AS SENT FROM LHC
		for (Int_t ibeamType = 0; ibeamType<2; ibeamType++){
			beamArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[indexBeamTypeString+ibeamType]);
			if (beamArray){			
				Int_t nBeam = beamArray->GetEntries();
				if (nBeam==0){
					AliInfo(Form("No Beam Type %s found, leaving it empty",fgkLHCDataPoints[indexBeamTypeString+ibeamType]));
				}
				else{
					for (Int_t iBeam = 0; iBeam<nBeam; iBeam++){
						AliDCSArray* beam = (AliDCSArray*)beamArray->At(iBeam);
						if (beam){
							if (beam->GetTimeStamp()<=timeStart && beam->GetTimeStamp()>=timeBeamTypeStart[ibeamType]){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
								timeBeamTypeStart[ibeamType] = beam->GetTimeStamp();
								indexBeamType[ibeamType] = iBeam;
								foundBeamTypeStart[ibeamType] = kTRUE;
							}
							else{
								break;
							}
						}
					}
					if (!foundBeamTypeStart[ibeamType]){
						AliInfo(Form("No value for the Beam Type %s found before start of run, the Beam Type %d will remain empty", fgkLHCDataPoints[indexBeamTypeString+ibeamType], ibeamType));
					}
					else {
						AliDCSArray* beam = (AliDCSArray*)beamArray->At(indexBeam);
						TObjString* beamString = beam->GetStringArray(0);
						TString beamType = beamString->String();
						AliInfo(Form("Beam Type (for %s) = %s", fgkLHCDataPoints[indexBeamTypeString+ibeamType], beamType.Data()));
						TString singleBeam = ParseBeamTypeString(beamType,ibeamType);
						AliInfo(Form("Single Beam Type for beam %d set to %s", ibeamType, singleBeam.Data()));
						grpobj->SetSingleBeamType(ibeamType, singleBeam);
						if (beamType.CompareTo("PROTON",TString::kIgnoreCase) == 0){
							AliInfo(Form("Setting beam %d for combined beam type to p", ibeamType));
							if (ibeamType == 0) combinedBeamType.Prepend("p"); 
							else combinedBeamType.Append("p");
						}
						else { // if there is no PROTON beam, we suppose it is Pb, and we put A-A
							AliInfo(Form("Setting beam %d for combined beam type to A",ibeamType));
							if (ibeamType == 0) combinedBeamType.Prepend("A");
							else combinedBeamType.Append("A");
						}
						if (ibeamType == 0) combinedBeamTypeFromLHC.Prepend(beamType); 
						else combinedBeamTypeFromLHC.Append(beamType);
						/*
						  else if (beamType.CompareTo("LEAD82",TString::kIgnoreCase) == 0){
						  AliInfo("Setting beam type to Pb-Pb");
						  grpobj->SetSingleBeamType(ibeamType, "Pb-Pb");
						  }
						  else{
						  AliError("Beam Type not known, leaving it empty");
						  }
						*/
						if (indexBeamType[ibeamType] < nBeam-1){
							AliDCSArray* beam1 = (AliDCSArray*)beamArray->At(indexBeam+1);
							if (beam1){
								if (beam1->GetTimeStamp()>timeStart && beam1->GetTimeStamp()<=timeEnd){
									timeBeamTypeEnd[ibeamType] = beam1->GetTimeStamp();
									TObjString* beamString1 = beam1->GetStringArray(0);
									TString beamType1 = beamString1->String();
									if (beamType.CompareTo(beamType1.Data(),TString::kIgnoreCase) == -1){
										AliWarning(Form("The Beam Type for %s changed from %s to %s during the run at timestamp %f! Setting it to %s and keeping track of the time of the change to set MaxTimeLHCValidity afterward",fgkLHCDataPoints[indexBeamTypeString+ibeamType],beamType.Data(),(beamString1->String()).Data(),timeBeamEnd,beamType.Data()));
										flagBeamType[ibeamType] = kTRUE;
										arrayTimes[3+ibeamType] = timeBeamTypeEnd[ibeamType];
									}
								}
							}
							else {
								AliInfo(Form("Invalid pointer for the first entry for Beam Type %s after the first valid one, not considering anything after what has already been found",fgkLHCDataPoints[indexBeamTypeString+ibeamType]));
							}
						}
					}
				}
				delete beamArray;
			}
			else{
				AliError(Form("Beam Type %s array not found in LHC Data file!!!",fgkLHCDataPoints[indexBeamTypeString+ibeamType]));
			}		
		}
		AliInfo(Form("Setting combined beam type to %s",combinedBeamType.Data()));
		grpobj->SetBeamType(combinedBeamType);
		AliInfo(Form("Setting combined beam type form LHC to %s",combinedBeamTypeFromLHC.Data()));
		grpobj->SetBeamTypeFromLHC(combinedBeamTypeFromLHC);
		
		// Setting minTimeLHCValidity
		if (flagBeamMode == kTRUE || flagMachineMode == kTRUE || flagBeam == kTRUE || flagBeamType[0] == kTRUE || flagBeamType[1] == kTRUE){ 
			Double_t minTimeLHCValidity= TMath::MinElement(5,arrayTimes);
			AliWarning(Form("Setting MaxTimeLHCValidity to %f",minTimeLHCValidity));
			grpobj->SetMaxTimeLHCValidity(minTimeLHCValidity);
		}
		/* 
		   // Old way to determine the Maximum Time during which the LHC info is valid
		if (timeBeamModeEnd!=0 || timeMachineModeEnd!=0 || timeBeamEnd !=0){
			Double_t minTimeLHCValidity;
			if (flagBeamMode == kFALSE && flagMachineMode == kFALSE && flagBeam == kTRUE){ // flagBeam only true --> it is the only one that changed
				minTimeLHCValidity = timeBeamEnd;
			}
			else if (flagBeamMode == kFALSE && flagMachineMode == kTRUE && flagBeam == kFALSE){ // flagMachineMode only true
				minTimeLHCValidity = timeMachineModeEnd;
			}
			else if (flagBeamMode == kTRUE && flagMachineMode == kFALSE && flagBeam == kFALSE){ // flagBeamMode only true
				minTimeLHCValidity = timeBeamModeEnd;
			}
			else if (flagBeamMode == kFALSE && flagMachineMode == kTRUE && flagBeam == kTRUE){ // flagBeam and flagMachineMode only true
				minTimeLHCValidity= TMath::Min(timeBeamEnd,timeMachineModeEnd);
			}
			else if (flagBeamMode == kTRUE && flagMachineMode == kFALSE && flagBeam == kTRUE){ // flagBeam and flagBeamMode only true
				minTimeLHCValidity= TMath::Min(timeBeamEnd,timeBeamModeEnd);
			}
			else if (flagBeamMode == kTRUE && flagMachineMode == kTRUE && flagBeam == kFALSE){ // flagMachineMode and flagBeamMode only true
				minTimeLHCValidity= TMath::Min(timeMachineModeEnd,timeBeamModeEnd);
			}
			else {
				Double_t arrayTimes[3] = {timeBeamModeEnd,timeMachineModeEnd,timeBeamEnd};// flagMachineMode and flagBeamMode and flagBeam 
				minTimeLHCValidity= TMath::MinElement(3,arrayTimes);
			}
			AliWarning(Form("Setting MaxTimeLHCValidity to %f",minTimeLHCValidity));
			grpobj->SetMaxTimeLHCValidity(minTimeLHCValidity);
		}
		*/
		
		// Data Quality Flag --> storing start and end values of periods within the run during which the value was found to be FALSE
		Log("*************Data Quality Flag ");
		TObjArray* dataQualityArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[8]);
		Int_t nDataQuality = -1;
		Double_t timeDataQualityStart = -1; // min validity for Data Quality Flag
	        Int_t indexDataQuality = -1;               // index of first measurement used to set Data Quality Flag
		Bool_t foundDataQualityStart = kFALSE;     // flag to be set in case an entry for the Data Quality Flag is found before (or at) SOR

		if (dataQualityArray){
			nDataQuality = dataQualityArray->GetEntries();
			if (nDataQuality==0){
				AliInfo("No Data Quality Flag found, leaving it empty");
			}
			else{
				for (Int_t iDataQuality = 0; iDataQuality<nDataQuality; iDataQuality++){
					AliDCSArray* dataQuality = (AliDCSArray*)dataQualityArray->At(iDataQuality);
					if (dataQuality){
						if (dataQuality->GetTimeStamp()<=timeStart && dataQuality->GetTimeStamp()>=timeDataQualityStart){// taking always the very last entry: if two measurements have the same timestamp, the last one is taken
							timeDataQualityStart = dataQuality->GetTimeStamp();
							indexDataQuality = iDataQuality;
							foundDataQualityStart = kTRUE;
						}
						else{
							// we suppose here that if the first measurement is not before SOR, then none will be (they MUST be in chronological order!!!) 
							break;
						}
					}
				}
				if (!foundDataQualityStart){
					// The Data Quality Flag should be found and TRUE at the start of the run. For the time being, if it is not found, don't do anything, but it means there is a problem..
					AliInfo("No value for the Data Quality Flag found before start of run, the Data Quality Flag will remain empty");
				}
				else {
					// counting how many FALSE values there are
					Bool_t foundEndOfFalse = kFALSE;
					Int_t nFalse = 0;
					for (Int_t iDataQuality = indexDataQuality; iDataQuality < nDataQuality; iDataQuality ++){
						AliDCSArray* dataQuality = (AliDCSArray*)dataQualityArray->At(iDataQuality);
						AliDebug(4,Form("dataQuality->GetTimeStamp() = %f, timeDataQualityStart = %f, timeEnd = %f", dataQuality->GetTimeStamp(), timeDataQualityStart, timeEnd ));
						if (dataQuality->GetTimeStamp()>=timeDataQualityStart && dataQuality->GetTimeStamp()<=timeEnd){ // considering only values between the first valid and the end of the run
							Bool_t dataQualityFlag = dataQuality->GetBool(0);
							AliDebug(3,Form("DataQuality = %d (set at %f)",(Int_t)dataQualityFlag,dataQuality->GetTimeStamp()));
							if (dataQualityFlag != kTRUE){
								if (iDataQuality == indexDataQuality) {  // the first Data Quality value should be TRUE, but ignoring the problem now...
									AliError("The first value for the Data Quality MUST be TRUE! Ignoring for now...");
								}
								nFalse++;
							}
						}
					}

					AliInfo(Form("Found %d FALSE values for the Data Quality Flag",nFalse));
					Double_t falses[nFalse*2];  // dimensioning this to the maximum possible, as if each false value was followed by a true one --> the false periods correspond to the number of falses

					Int_t iDataQuality = indexDataQuality;
					if (nFalse > 0){
						Int_t iFalse = 0;
						// filling the info about the periods when the flag was set to FALSE
						// starting, like for the other DPS, from the measurement closest to SOR (the index of which is iDataQuality)
						while (iDataQuality < nDataQuality){
							AliDebug(3,Form("iDataQuality = %d",iDataQuality));
							AliDCSArray* dataQuality = (AliDCSArray*)dataQualityArray->At(iDataQuality);
							if (dataQuality->GetTimeStamp()>=timeDataQualityStart && dataQuality->GetTimeStamp()<=timeEnd){ // considering only values between the first valid and the end of the run
								Bool_t dataQualityFlag = dataQuality->GetBool(0);
								AliDebug(3,Form("DataQuality = %d (set at %f)",(Int_t)dataQualityFlag,dataQuality->GetTimeStamp()));
								if (dataQualityFlag == kTRUE){
									// found TRUE value, continuing
									iDataQuality++;
									continue;
								}
								else{
									/*
									// the check was already done before
									if (iDataQuality == indexDataQuality) {  // the first Data Quality value should be TRUE, but ignoring the problem now...
									AliError("The first value for the Data Quality MUST be TRUE! Ignoring for now...");
									}
									*/
									falses[iFalse*2] = dataQuality->GetTimeStamp();
									foundEndOfFalse = kFALSE;
									Int_t iDataQualityNext = iDataQuality+1;
									while (iDataQualityNext < nDataQuality){
										AliDCSArray* dataQualityNext = (AliDCSArray*)dataQualityArray->At(iDataQualityNext);
										if (dataQualityNext->GetTimeStamp()>timeDataQualityStart && dataQualityNext->GetTimeStamp()<=timeEnd && dataQualityNext->GetTimeStamp() > dataQuality->GetTimeStamp()){ // considering only values between the first valid and the end of the run, and subsequent to the current value
											Bool_t dataQualityFlagNext = dataQualityNext->GetBool(0);
											AliDebug(3,Form("DataQualityNext = %d (set at %f)",(Int_t)dataQualityFlagNext,dataQualityNext->GetTimeStamp()));
											if (dataQualityFlagNext == kTRUE){
												// found TRUE value, first FALSE period completed
												foundEndOfFalse = kTRUE;
												falses[iFalse*2+1] = dataQualityNext->GetTimeStamp();
												iFalse++;
												break;
											}
											iDataQualityNext++;
										}
									}
									if (!foundEndOfFalse) {
										AliInfo("Please, note that the last FALSE value lasted until the end of the run");
										falses[iFalse*2+1] = timeEnd;
										iFalse++;
										break;
									}
									iDataQuality = iDataQualityNext+1;
								}
							}
						}
						grpobj->SetNFalseDataQualityFlag(iFalse);
						grpobj->SetFalseDataQualityFlagPeriods(falses);
					}
				}
			}
			delete dataQualityArray;
		}
		else{
			AliError("Data Quality Flag array not found in LHC Data file!!!");
		}

		// Processing data to go to AliLHCData object
		AliLHCData* dt = new AliLHCData(fileName.Data(),timeStart,timeEnd);
		// storing AliLHCData in OCDB
		if (dt){
		  AliInfo(Form("Filled %d records to AliLHCData object",dt->GetData().GetEntriesFast()));
		  AliCDBMetaData md;
		  md.SetResponsible("Ruben Shahoyan");
		  md.SetComment("LHC data from the GRP preprocessor.");
		  Bool_t result = kTRUE;
		  result = Store("GRP", "LHCData", dt, &md); 
		  delete dt;
		  if (!result){
			Log(Form("Problems in storing LHC Data - but not going into Error"));
		  }
		}

		// processing LHC Phase

		TObjArray *beam1phase = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[4]);
		TObjArray *beam2phase = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[5]);
		if (beam1phase == 0x0 || beam2phase == 0x0){
			Log(Form("Problems in retrieving LHC Clock data from LHC file"));
			return 4;
		}			
		AliLHCClockPhase *phaseObj = ProcessLHCClockPhase(beam1phase,beam2phase,timeEnd);
		delete beam1phase;
		delete beam2phase;
		if (phaseObj){
			AliInfo(Form("LHC Phase found"));
			AliCDBMetaData mdPhase;
			mdPhase.SetResponsible("Cvetan Cheshkov");
			mdPhase.SetComment("LHC Clock Phase");
			Bool_t result = kTRUE;
			result = Store("Calib", "LHCClockPhase", phaseObj, &mdPhase); 
			delete phaseObj;
			if (!result) return 3;
		}
		else return 4;
	}
	
	else {
		AliError("No LHCData file found in FXS");
		return 1;
	}

	return 0;
}

//_______________________________________________________________

UInt_t AliGRPPreprocessor::ProcessSPDMeanVertex()
{
	//
	//Getting the SPD Mean Vertex
	//

	TList* list = GetForeignFileSources("SPD", kDAQ, "VertexDiamond");
	Bool_t storeResult = kTRUE;
	if (list !=0x0 && list->GetEntries()!=0)
		{
			AliInfo("The following sources produced files with the id VertexDiamond from SPD");
			list->Print();
			for (Int_t jj=0;jj<list->GetEntries();jj++){
				TObjString * str = dynamic_cast<TObjString*> (list->At(jj)); 
				if (!str){
					AliError(Form("Expecting a TObjString in the list for the %d-th source, but something else was found.",jj));
					continue;
				}
				AliInfo(Form("found source %s", str->String().Data()));
				TString fileNameRun = GetForeignFile("SPD", kDAQ, "VertexDiamond", str->GetName());
				if (fileNameRun.Length()>0){
					AliInfo(Form("Got the file %s", fileNameRun.Data()));
					TFile daqFile(fileNameRun.Data(),"READ");
					if (daqFile.IsOpen()) {
						AliESDVertex* meanVtx = dynamic_cast<AliESDVertex*>(daqFile.Get("MeanVertexPos"));
						if (meanVtx){
							meanVtx->Print();	
							// storing in the OCDB 
							AliCDBMetaData md;
							md.SetResponsible("Cvetan Cheshkov");
							md.SetComment("SPD Mean Vertex");					
							storeResult = Store("Calib", "MeanVertexSPD", meanVtx, &md, 0, kTRUE); 
						}
						else{
							AliWarning("No SPD Mean Vertex object found in file");
						} 
					}
					else {
						AliError("Can't open file");
						storeResult = kFALSE;
					}
				}
				else{
					AliWarning("No file found for current source for SPD Mean Vertex");
				}
			}
		}
	else {
		AliWarning("No list found for SPD Mean Vertex");
	}

	if (list) delete list;

	return storeResult;
}
//_______________________________________________________________

UInt_t AliGRPPreprocessor::ProcessDqmFxs()
{
	//
	// Processing DQM fxs information
	//

	// TriggerClassesAndHistosToClone
	TList* list = GetFileSources(kDQM, "TriggerClassesAndHistosToClone");
	Bool_t openFileResult = kTRUE;
	Bool_t storeResultQAThr = kTRUE;
	if (list !=0x0 && list->GetEntries()!=0){
		AliInfo("The following sources produced files with the id TriggerClassesAndHistosToClone for GRP");
		list->Print();
		for (Int_t jj=0;jj<list->GetEntries();jj++){
			TObjString * str = dynamic_cast<TObjString*> (list->At(jj)); 
			if (!str){
				AliError(Form("Expecting a TObjString in the list for the %d-th source, but something else was found.",jj));
				continue;
			}
			AliInfo(Form("found source %s", str->String().Data()));
			TString fileNameRun = GetFile(kDQM, "TriggerClassesAndHistosToClone", str->GetName());
			if (fileNameRun.Length()>0){
				AliInfo(Form("Got the file %s", fileNameRun.Data()));
				TFile dqmFile(fileNameRun.Data(),"READ");
				if (dqmFile.IsOpen()) {
					dqmFile.ls();
				}
				else {
					AliError("Can't open file");
					openFileResult = kFALSE;
				}
			}
			else{
				AliWarning("No file found for current source for DQM TriggerClassesAndHistosToClone");
			}
		}
	}
	else {
		AliWarning("No list found for DQM TriggerClassesAndHistosToClone");
	}
	
	if (list) delete list;

	// QAThresholds
	TObjArray* qaThrArray = new TObjArray();
	for (Int_t idet = 0; idet < AliDAQ::kNDetectors; idet++){
		TString detName = AliDAQ::OnlineName(idet);
		if (detName == "TRI" || detName == "HLT" || detName == "TST") continue;   // skipping TRI, HLT, TST since they do not produce QAThresholds
		AliDebug(2, Form("Processing QAThreshold for detector %s",detName.Data())); 
		TList* listQAThr = GetForeignFileSources(detName.Data(), kDQM, "QAThresholds");
		if (listQAThr !=0x0){
			if (listQAThr->GetEntries() > 1){
				AliError(Form("More than one sources found for QAThresholds from detector %s, skipping",detName.Data()));
				continue;
			}
			else if (listQAThr->GetEntries()==1){
				AliInfo(Form("The following source produced files with the id QAThresholds for GRP, coming from detector %s:",detName.Data()));
				listQAThr->Print();
				TObjString * str = dynamic_cast<TObjString*> (listQAThr->At(0)); 
				if (!str){
					AliError(Form("Expecting a TObjString in the list for detector %s, but something else was found.",detName.Data()));
					delete listQAThr;
					continue;
				}
				AliInfo(Form("found source %s", str->String().Data()));
				TString fileNameRun = GetForeignFile(detName.Data(), kDQM, "QAThresholds", str->GetName());
				if (fileNameRun.Length()>0){
					AliInfo(Form("Got the file %s", fileNameRun.Data()));
					TFile dqmFile(fileNameRun.Data(),"READ");
					if (dqmFile.IsOpen()) {
						AliQAThresholds* qaThr = dynamic_cast<AliQAThresholds*>(dqmFile.Get(detName.Data()));
						if (qaThr){
							Int_t qaThrId = qaThr->GetDetectorId();
							if (qaThrId != idet){
								AliError(Form("Expecting QA threshold for detector %s, but found that for detector %s, skipping",detName.Data(), AliDAQ::OnlineName(qaThrId)));
								delete listQAThr;
								continue;
							}
							else{
								qaThrArray->AddAtAndExpand(qaThr, qaThrId);
								delete listQAThr;
							}
						}
						else {
							AliError(Form("No QAThresholds object found in the file for detector %s, skipping",detName.Data()));
							delete listQAThr;
							continue;
						}
					}			      
					else {
						AliError(Form("Can't open QAThreshold file for detector %s, skipping",detName.Data()));
						delete listQAThr;
						continue;					
					}
				}
				else{
					AliWarning(Form("No file found for DQM QAThreshold for detector %s, skipping",detName.Data()));
					delete listQAThr;
					continue;
				}
			}
			else {
				AliError(Form("No sources found for QAThresholds from detector %s, skipping",detName.Data()));
				delete listQAThr;
				continue;
			}
		}
		else {
			AliWarning(Form("No list found for DQM QAThreshold for detector %s, skipping",detName.Data()));
			continue;
		}
	}
	if (qaThrArray->GetEntries() > 0){
		AliCDBMetaData md;
		md.SetResponsible("Barthélémy von Haller");
		md.SetComment("QA Threshold TObjArray");					
		storeResultQAThr = Store("Calib", "QAThresholds", qaThrArray, &md, 0, kTRUE); 
	}
	else{
		Printf("No valid QAThresholds entries found, storing nothing in the OCDB");
	}

	Printf("openFileResult for QAThr processing would be %d, but we return kTRUE anyway", (Int_t)openFileResult);
	Printf("storeResultQAThr for QAThr processing would be %d, but we return kTRUE anyway", (Int_t)storeResultQAThr);
	//	return storeResultQAThr;
	return kTRUE;  // temporary!!
}


//_______________________________________________________________

Int_t AliGRPPreprocessor::ProcessDaqLB(AliGRPObject* grpObj)
{
	//Getting the DAQ lb information
	
	time_t timeStart = (time_t)(((TString)GetRunParameter("DAQ_time_start")).Atoi());
	time_t timeEnd = (time_t)(((TString)GetRunParameter("DAQ_time_end")).Atoi());
	Float_t beamEnergy = (Float_t)(((TString)GetRunParameter("beamEnergy")).Atof());
	TString beamType = (TString)GetRunParameter("beamType");
	Char_t numberOfDetectors = (Char_t)(((TString)GetRunParameter("numberOfDetectors")).Atoi());
	UInt_t  detectorMask = (UInt_t)(((TString)GetRunParameter("detectorMask")).Atoi());
	TString lhcPeriod = (TString)GetRunParameter("LHCperiod");
	TString runType = (TString)GetRunType();

	if (timeEnd >= 2.E9) AliFatal("ALICE run finshed later than Wed May 18 2033, 03:33:20 GMT, maximum time allowed for LHC data --> fix the GRP preprocessor!!!");

	UInt_t nparameter = 0;
	if (timeStart != 0){
		grpObj->SetTimeStart(timeStart);
		Log(Form("Start time for run %d: %d",fRun, (Int_t)timeStart));
		nparameter++;
	} 
	else {
		Log(Form("Start time not put in logbook, setting to invalid in GRP entry, and causing an error!"));
	}

	if (timeEnd != 0){
		grpObj->SetTimeEnd(timeEnd);
		Log(Form("End time for run %d: %i",fRun, (Int_t)timeEnd));
		nparameter++;
	} 
	else {
		Log(Form("End time not put in logbook, setting to invalid in GRP entry, and causing an error!"));
	}

	if (beamEnergy != 0){
		Log(Form("Beam Energy for run %d: %f (NOT USING IT TO FILL THE GRP OBJECT, taking it from the LHC file)",fRun, beamEnergy));
	} 
	else {
		Log(Form("Beam Energy not put in logbook, but not using it anyway for the GRP object (taking it from the LHC file)"));
	}

		
	if (beamType.Length() != 0){
		Log(Form("Beam Type for run %d: %s (NOT USING IT TO FILL THE GRP OBJECT, taking it from the LHC file)",fRun, beamType.Data()));
	} 
	else {
		Log(Form("Beam Type not put in logbook, but not using it anyway for the GRP entry (taking it from the LHC file)"));
	}
		
	if (numberOfDetectors != 0){
		grpObj->SetNumberOfDetectors(numberOfDetectors);
		Log(Form("Number Of Detectors for run %d: %d",fRun, (Int_t)numberOfDetectors));
		nparameter++;
	} 
	else {
		Log(Form("Number Of Detectors not put in logbook, setting to invalid in GRP entry, and causing an error!"));
	}

	if (detectorMask != 0){
		grpObj->SetDetectorMask(detectorMask);
		Log(Form("Detector Mask for run %d: %d",fRun, detectorMask));
		nparameter++;
	} 
	else {
		Log(Form("Detector Mask not put in logbook, setting to invalid in GRP entry, and causing an error!"));
	}

	if (lhcPeriod.Length() != 0) {
		grpObj->SetLHCPeriod(lhcPeriod);
		Log(Form("LHC period (DAQ) for run %d: %s",fRun, lhcPeriod.Data()));
		nparameter++;
	} 
	else {
		Log(Form("LHCperiod not put in logbook, setting to invalid in GRP entry, and causing an error!"));
	}
	if (runType.Length() != 0) {
		grpObj->SetRunType(runType);
		Log(Form("Run Type (DAQ) for run %d: %s",fRun, runType.Data()));
		nparameter++;
	} 
	else {
		Log(Form("Run Type not put in logbook, setting to invalid in GRP entry, and causing an error!"));
	}

	return nparameter;
}
//_______________________________________________________________

UInt_t AliGRPPreprocessor::ProcessDaqFxs()
{
	//======DAQ FXS======//
	
	AliRawEventHeaderV3_9::Class()->IgnoreTObjectStreamer(); // to avoid trying reading TObject store in AliRawEventHeaderV3_9 - temporary fix 
	AliRawEventHeaderV3_11::Class()->IgnoreTObjectStreamer(); // to avoid trying reading TObject store in AliRawEventHeaderV3_11 - temporary fix 
	AliRawEventHeaderV3_12::Class()->IgnoreTObjectStreamer(); // to avoid trying reading TObject store in AliRawEventHeaderV3_12 - temporary fix 
	AliRawEventHeaderV3_13::Class()->IgnoreTObjectStreamer(); // to avoid trying reading TObject store in AliRawEventHeaderV3_13 - temporary fix 
	Log("Processing DAQ FXS");
	TList* list = GetFileSources(kDAQ);  	
	if (!list) {
		Log("No raw data tag list: connection problems with DAQ FXS logbook!");
		return 1;
	}
	
	if (list->GetEntries() == 0) {
		Log("no raw data tags in this run: nothing to merge!");
		delete  list; list=0;
		return 0;
	}
	
	TChain *fRawTagChain = new TChain("T");
	Int_t nFiles=0;
	Int_t nCorruptedFiles=0;
	TIterator* iter = list->MakeIterator();
	TObject* obj = 0;
	while ((obj = iter->Next())) {
		TObjString* objStr = dynamic_cast<TObjString*> (obj);
		if (objStr) {
			Log(Form("Found source %s", objStr->String().Data()));
			TList* list2 = GetFileIDs(kDAQ, objStr->String());
			if (!list2) {
				Log("No list with ids from DAQ was found: connection problems with DAQ FXS logbook!");
				delete fRawTagChain; fRawTagChain=0;
				return 1;
			}
			Log(Form("Number of ids: %d",list2->GetEntries()));
			for(Int_t i = 0; i < list2->GetEntries(); i++) {
				TObjString *idStr = (TObjString *)list2->At(i);
				if (idStr->String().CompareTo("QAThreshold") == 0 || idStr->String().CompareTo("TriggerClassesAndHistosToClone") == 0) {
					Log(Form("Skipping file with Id %s",idStr->String().Data()));
					continue; 
				}
				TString fileName = GetFile(kDAQ,idStr->String().Data(),objStr->String().Data());
				if (fileName.Length() > 0) {
					if(!CheckFileRecords(fileName.Data())){
						Log(Form("The file records for \"%s\" are corrupted! The chain is skipping it.",fileName.Data()));
						nCorruptedFiles++;
					}else{
						Log(Form("Adding file in the chain: %s",fileName.Data()));
						fRawTagChain->Add(fileName.Data());
						nFiles++;
					}
				} else {
					Log(Form("Could not retrieve file with id %s from source %s: "
						 "connection problems with DAQ FXS!",
						 idStr->String().Data(), objStr->String().Data()));
					delete list; list=0;
					delete list2; list2=0;
					delete fRawTagChain; fRawTagChain=0;
					return 2;
				}
			}
			delete list2;
		}
	}

	if (nFiles == 0){
		Log("no raw data tags in this run: it could be that one or more files were found in the DAQ FXS, but they were ignored, since not interesting for the raw data tag: nothing to merge!");
		delete iter;
		iter = 0;
		delete list;
		list = 0;
		delete fRawTagChain; 
		fRawTagChain=0;
		return 0;
	}
	
	TString fRawDataFileName = "GRP_Merged.tag.root";
	if(nCorruptedFiles!=0)
		Log(Form("Merging %d raw data tags into file: %s. %d corrupted files skipped", nFiles, fRawDataFileName.Data(), nCorruptedFiles));
	else
		Log(Form("Merging %d raw data tags into file: %s", nFiles, fRawDataFileName.Data()));
	
	if (fRawTagChain->Merge(fRawDataFileName) < 1 ) {
		Log(Form("Error merging %d raw data files!!!",nFiles));
		delete iter;
		iter = 0;
		delete list;
		list = 0;
		delete fRawTagChain; 
		fRawTagChain=0;
		return 3;
	}
		
	TString outputfile = Form("Run%d.Merged.RAW.tag.root", fRun);
	Bool_t result = StoreRunMetadataFile(fRawDataFileName.Data(),outputfile.Data());
	
	if (!result) {
		Log("Problem storing raw data tags in local file!!!");
	} else {
		Log("Raw data tags merged successfully!!");
	}
	
	delete iter;
	iter = 0;
	delete list;
	list = 0;
	delete fRawTagChain; fRawTagChain=0;
	
	if (result == kFALSE) {
		return 4;
	}
	
	return 0;
	
}

//_______________________________________________________________
UInt_t AliGRPPreprocessor::ProcessDcsFxs(TString partition, TString detector)
{

	// processing the info
	// stored in the DCS FXS
	// coming from the trigger

	// Get the CTP counters information
	//              +
	// Get the CTP aliases information

	if (partition.IsNull() && !detector.IsNull()){ // standalone partition
		Log("STANDALONE partition for current run, using Trigger Scalers and Trigger Aliases dummy values");

		AliCDBEntry *cdbEntryScalers = GetFromOCDB("CTP","DummyScalers");
		if (!cdbEntryScalers) {
			Log(Form("No dummy CTP scalers entry found, going into error..."));
			return 1;
		}
		else{
			AliTriggerRunScalers *scalers = (AliTriggerRunScalers*)cdbEntryScalers->GetObject();
			if (!scalers){
				Log(Form("CTP dummy scalers not found in OCDB entry, going into error..."));
				return 1;
			}
			else {
				AliCDBMetaData metaData;
				metaData.SetResponsible("Roman Lietava");
				metaData.SetComment("CTP scalers from dummy entry in OCDB");
				if (!Store("CTP","Scalers", scalers, &metaData, 0, 0)) {
					Log("Unable to store the dummy CTP scalers object to OCDB!");
					delete scalers;
					return 1;
				}
			}
		}

		AliCDBEntry *cdbEntryAliases = GetFromOCDB("CTP","DummyAliases");
		if (!cdbEntryAliases) {
			Log(Form("No dummy CTP aliases entry found, going into error..."));
			return 2;
		}
		else{
			THashList *aliases = dynamic_cast<THashList*>(cdbEntryAliases->GetObject());
			if (!aliases){
				Log(Form("CTP dummy aliases not found in OCDB entry, going into error..."));
				return 2;
			}
			else {
				AliCDBMetaData metaData;
				metaData.SetResponsible("Evgeny Kryshen");
				metaData.SetComment("CTP mapping of trigger classes to trigger aliases");
				if (!Store("CTP","Aliases", aliases, &metaData, 0, 0)) {
					Log("Unable to store the dummy CTP aliases object to OCDB!");
					delete aliases;					
					return 2;
				}
			}
		}
	}

	else if (!partition.IsNull() && detector.IsNull()){ // global partition
		Log("GLOBAL partition for current run, using CTP scalers from DCS FXS");
		TString countersfile = GetFile(kDCS, "CTP_xcounters","");
		if (countersfile.IsNull()) {
			Log("No CTP counters files has been found: empty source!");
			return 1;
		}
		else {
			Log(Form("File with Id CTP_xcounters found in DCS FXS! Copied to %s",countersfile.Data()));
			AliTriggerRunScalers *scalers = AliTriggerRunScalers::ReadScalers(countersfile);
			if (!scalers) {
				Log("Bad CTP counters file! The corresponding CDB entry will not be filled!");
				return 1;
			}
			else {
				AliCDBMetaData metaData;
				metaData.SetBeamPeriod(0);
				metaData.SetResponsible("Roman Lietava");
				metaData.SetComment("CTP scalers");
				if (!Store("CTP","Scalers", scalers, &metaData, 0, 0)) {
					Log("Unable to store the CTP scalers object to OCDB!");
					delete scalers;					
					return 1;
				}
			}
			delete scalers;
		}



		TString aliasesFile = GetFile(kDCS, "CTP_aliases","");
		if (aliasesFile.IsNull()) {
			Log("No CTP aliases files has been found: empty source!");
			return 2;
		}
		else {
			Log(Form("File with Id CTP_aliases found in DCS FXS! Copied to %s",aliasesFile.Data()));
			// We build the THashList of TNamed("triggerclass","comma_separated_list_of_corresponding_aliases")
			THashList* trClasses2Aliases = ProcessAliases(aliasesFile);
			if (!trClasses2Aliases) {
				Log("Bad CTP aliases file! The corresponding CDB entry will not be filled!");
				return 2;
			}
			else {
				AliCDBMetaData metaData;
				metaData.SetBeamPeriod(0);
				metaData.SetResponsible("Evgeny Kryshen");
				metaData.SetComment("CTP mapping of trigger classes to trigger aliases");
				if (!Store("CTP","Aliases", trClasses2Aliases, &metaData, 0, 0)) {
					Log("Unable to store the CTP aliases object to OCDB!");
					delete trClasses2Aliases;					
					return 2;
				}
			}
			delete trClasses2Aliases;
		}
	}
	

	else{	
		Log(Form("Incorrect field in DAQ logbook for partition = %s and detector = %s, going into error...",partition.Data(),detector.Data()));
		return 3;
	}

	return 0;

}

//_______________________________________________________________
THashList* AliGRPPreprocessor::ProcessAliases(const char* aliasesFile)
{

	//
	// build the THashList of triggerclasses-to-triggeraliases from text file  
	// each line of the file is supposed to be a string composed by
	// triggerclass+spaces+commaseparatedlistofcorrespondingaliases\n
	// it will add a TNamed("triggerclass","commaseparatedlistofcorrespondingaliases")
	// to the hashlist
	//

	if (gSystem->AccessPathName(aliasesFile)) {
		Printf("file (%s) not found", aliasesFile);
		return 0;
	}

	ifstream *file = new ifstream(aliasesFile);
	if (!*file) {
		Printf("Error opening file (%s) !",aliasesFile);
		file->close();
		delete file;
		return 0;
	}

	THashList *hList = new THashList(10);
	hList->SetName("List of trigger classes to trigger aliases strings");

	TString strLine;
	while (strLine.ReadLine(*file)) {

	    // safety for null lines, tabs instead of whitespaces, trailing carriage return, leading or trailing spaces/tabs
		if (strLine.IsNull()) continue;
		strLine.ReplaceAll('\t',' ');
		strLine.Remove(TString::kLeading,' ');
		strLine.Remove(TString::kTrailing,'\r');
		strLine.Remove(TString::kTrailing,' ');

		TObjArray* arr = strLine.Tokenize(' ');
		if(arr->GetEntries() != 2){
			Printf("The line:\n%s\nunexpectedly contains %d tokens, instead of two.",strLine.Data(),arr->GetEntries());
			delete arr;
			return 0;
		}
		TObjString *osTC = (TObjString*) arr->At(0);
		TObjString *osTAlist = (TObjString*) arr->At(1);
		TNamed *ctoa = new TNamed(osTC->GetName(),osTAlist->GetName());
		hList->Add(ctoa);
		delete arr;
	}

	file->close();
	delete file;

	return hList;
}

//_______________________________________________________________
Int_t AliGRPPreprocessor::ProcessDcsDPs(TMap* valueMap, AliGRPObject* grpObj)
{

	//
	// processing DCS DPs
	//

	Int_t entries = 0;  // counting the entries that are in the DCS DB, not taking care whether they have values or not
	Int_t nL3Entries = 0;
	Int_t nDipoleEntries = 0;
	Int_t nEnvEntries = 0;
	Int_t nHallProbesEntries = 0;
	nL3Entries = ProcessL3DPs(valueMap, grpObj);
	nDipoleEntries = ProcessDipoleDPs(valueMap, grpObj);
	nEnvEntries = ProcessEnvDPs(valueMap, grpObj);
	nHallProbesEntries = ProcessHPDPs(valueMap, grpObj);
	grpObj->SetPolarityConventionLHC();  // after the dipole cables swap we comply with LHC convention
	Log(Form("L3Entries = %d, nDipoleEntries =%d, nEnvEntries = %d, nHallProbesEntries = %d", nL3Entries, nDipoleEntries, nEnvEntries, nHallProbesEntries));
	entries = nL3Entries + nDipoleEntries + nEnvEntries + nHallProbesEntries;
	return entries;

}

//_______________________________________________________________

Int_t AliGRPPreprocessor::ProcessL3DPs(const TMap* valueMap, AliGRPObject* grpObj)
{

	// processing DPs
	// related to 
	// L3 info

	Int_t nL3Entries = 0;

	TObjArray *array = 0x0;
	Int_t indexDP = -1;
	Bool_t isZero = kTRUE; // flag to monitor L3Current. If set to true, the magnet is OFF, and the polarity can change

	AliInfo(Form("==========L3Current==========="));
	Bool_t outOfRange = kFALSE;  // flag to monitor if any value collected by DCS is out of range
	indexDP = kL3Current;
	array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
	if(!array) {
		Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
	} 
	else {
		if (array->GetEntries() == 0){
			AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
		}
		else {
			Float_t *floatDCS = ProcessFloatAllMagnet(array, indexDP, isZero);
			if (floatDCS != NULL){
				grpObj->SetL3Current(floatDCS);
			}
			else{
				outOfRange = kTRUE;
			}	
			if (floatDCS){
				delete[] floatDCS;
				floatDCS = 0x0;
			}
		}
		if (!outOfRange) {
			nL3Entries++;
			ffailedDPs->RemoveAt(indexDP);
		}
	}

	if (array) array = 0x0;

	AliInfo(Form("==========L3Polarity==========="));
	indexDP = kL3Polarity;
	array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
	if(!array) {
		Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
	} 
	else {
		if (array->GetEntries() == 0){
			AliError(Form("No entries found in array! setting %s Polarity to invalid...",fgkDCSDataPoints[indexDP]));
		}
		else {
			Bool_t change = kFALSE;
			Char_t charDCS = ProcessBool(array,change);
			if (change == kFALSE){
				grpObj->SetL3Polarity(charDCS);
				AliInfo(Form("%s set to %d",fgkDCSDataPoints[indexDP],(Int_t)(grpObj->GetL3Polarity())));
				ffailedDPs->RemoveAt(indexDP);
				nL3Entries++;
			}
			else if (isZero){
				AliInfo(Form("%s set to invalid, but magnet was OFF (according to the current), DP not considered wrong",fgkDCSDataPoints[indexDP]));
				ffailedDPs->RemoveAt(indexDP);
				nL3Entries++;
			}
			else {
				AliError(Form("%s value changed within the run, while the magnet was ON (according to the current), setting it to invalid and considering the DP as wrong",fgkDCSDataPoints[indexDP]));
			}
		}
	}

	return nL3Entries;

}
//_______________________________________________________________

Int_t AliGRPPreprocessor::ProcessDipoleDPs(const TMap* valueMap, AliGRPObject* grpObj)
{
	// processing DPs
	// related to 
	// the Dipole info

	Int_t nDipoleEntries = 0;
	TObjArray *array = 0x0;
	Int_t indexDP = -1;
	Bool_t isZero = kTRUE; // flag to monitor L3Current. If set to true, the magnet is OFF, and the polarity can change

	AliInfo(Form("==========DipoleCurrent==========="));
	Bool_t outOfRange = kFALSE;  // flag to monitor if any value collected by DCS is out of range
	indexDP = kDipoleCurrent;
	array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
	if(!array) {
		Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
	} 
	else {
		if (array->GetEntries() == 0){
			AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
		}
		else {
			Float_t *floatDCS = ProcessFloatAllMagnet(array, indexDP, isZero);
			if (floatDCS != NULL){
				grpObj->SetDipoleCurrent(floatDCS);
			} 
			else{
				outOfRange=kTRUE;
			}
			if (floatDCS){
				delete[] floatDCS;
				floatDCS = 0x0;
			}
		}
		if (!outOfRange) {
			nDipoleEntries++;
			ffailedDPs->RemoveAt(indexDP);
		}
	}

	if (array) array = 0x0;

	AliInfo(Form("==========DipolePolarity==========="));
	indexDP = kDipolePolarity;
	array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
	if(!array) {
		Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
	} 
	else {
		if (array->GetEntries() == 0){
			AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
		}
		else {
			Bool_t change = kFALSE;
			Char_t charDCS = ProcessBool(array,change);
			if (!change){
				grpObj->SetDipolePolarity(charDCS);
				AliInfo(Form("%s set to %d",fgkDCSDataPoints[indexDP],(Int_t)(grpObj->GetDipolePolarity())));
				ffailedDPs->RemoveAt(indexDP);
				nDipoleEntries++;
			}
			else if (isZero){
				AliInfo(Form("%s set to invalid, but magnet was OFF (according to the current), DP not considered wrong",fgkDCSDataPoints[indexDP]));
				ffailedDPs->RemoveAt(indexDP);
				nDipoleEntries++;
			}
			else{
				AliError(Form("%s value changed within the run while the magnet was ON (according to the current), setting it to invalid and considering the DP as wrong", fgkDCSDataPoints[indexDP]));
			}
		}
	}

	return nDipoleEntries;

}
//_______________________________________________________________

Int_t AliGRPPreprocessor::ProcessEnvDPs(TMap* valueMap, AliGRPObject* grpObj)
{
	// processing DPs
	// related to 
	// evironment conditions (temperature, pressure) info

	Int_t nEnvEntries = 0;
	TObjArray *array = 0x0;
	Int_t indexDP = -1;

	AliInfo(Form("==========CavernTemperature==========="));
	Bool_t outOfRange = kFALSE;  // flag to monitor if any value collected by DCS is out of range
	indexDP = kCavernTemperature;
	array = (TObjArray *)valueMap->GetValue(fgkDCSDataPoints[indexDP]);
	if(!array) {
		Log(Form("%s not found in the map!!!",fgkDCSDataPoints[indexDP]));
	} 
	else {
		if (array->GetEntries() == 0){
			AliError(Form("No entries found in array! setting %s to invalid...",fgkDCSDataPoints[indexDP]));
		}
		else {
			Float_t *floatDCS = ProcessFloatAll(array);
			if (floatDCS != NULL){
				grpObj->SetCavernTemperature(floatDCS);
			}
			else{
				outOfRange = kTRUE;
			}
			if (floatDCS){
				delete[] floatDCS;
				floatDCS = 0x0;
			}
		}
		if (!outOfRange) {
			ffailedDPs->RemoveAt(indexDP);
			nEnvEntries++;
		}
	}

	if (array) array = 0x0;

	AliInfo(Form("========== AtmosPressures (Cavern + Surface + Cavern2) ==========="));
	AliDCSSensorArray *dcsSensorArray = GetPressureMap(valueMap);
	//dcsSensorArray->Print();
	if( fPressure->NumFits()<kNumSensors ) {
		Log(Form("Check the pressure sensor values! Not all the %d pressure sensors have been fit",kNumSensors));
	} 
	Log(Form("Number of fits performed = %d",fPressure->NumFits()));

	AliInfo(Form("==========CavernAtmosPressure==========="));
	indexDP = kCavernAtmosPressure;
	AliDCSSensor* sensorCavernP2 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
	TGraph* graph = sensorCavernP2->GetGraph();
	AliDebug(3,Form("index = %d",indexDP));
	AliDebug(3,Form("name = %s",fgkDCSDataPoints[indexDP]));
	AliDebug(2,Form("graph = %p",graph));
	AliDebug(3,Form("sensorCavernP2 = %p", sensorCavernP2));
	if(sensorCavernP2->GetFit() || graph) {
		if (sensorCavernP2->GetFit()){
			Log(Form("Fit for sensor %s found",fgkDCSDataPoints[indexDP]));
		}
		else {
			Log(Form("Fit for sensor %s not found, but the graph is there - NOT going into error",fgkDCSDataPoints[indexDP]));
		}
		grpObj->SetCavernAtmosPressure(sensorCavernP2);
		ffailedDPs->RemoveAt(indexDP);
		nEnvEntries++;
	} 
	//if (sensorP2) delete sensorP2;
	else {
		Log(Form("ERROR!!! Neither graph nor fit found for sensor %s - this will not increase the number of found DCS DPs and will cause an error", fgkDCSDataPoints[indexDP] ));
	}
	
	AliInfo(Form("==========SurfaceAtmosPressure==========="));
	indexDP = kSurfaceAtmosPressure;
	AliDCSSensor* sensorP2 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
	graph = sensorP2->GetGraph();
	AliDebug(3,Form("index = %d",indexDP));
	AliDebug(3,Form("name = %s",fgkDCSDataPoints[indexDP]));
	AliDebug(2,Form("graph = %p",graph));	
	AliDebug(3,Form("sensorP2 = %p", sensorP2));
	if(sensorP2->GetFit() || graph) {
		if (sensorP2->GetFit()){
			Log(Form("Fit for sensor %s found",fgkDCSDataPoints[indexDP]));
		}
		else {
			Log(Form("Fit for sensor %s not found, but the graph is there - NOT going into error",fgkDCSDataPoints[indexDP]));
		}
		grpObj->SetSurfaceAtmosPressure(sensorP2);
		ffailedDPs->RemoveAt(indexDP);
		nEnvEntries++;
	} 
	//if (sensorP2) delete sensorP2;
	else {
		Log(Form("ERROR!!! Neither graph nor fit found for sensor %s - this will not increase the number of found DCS DPs and will cause an error", fgkDCSDataPoints[indexDP] ));
	}

	AliInfo(Form("==========CavernAtmosPressure2==========="));
	indexDP = kCavernAtmosPressure2;
	AliDCSSensor* sensorCavernP22 = dcsSensorArray->GetSensor(fgkDCSDataPoints[indexDP]);
	graph = sensorCavernP22->GetGraph();
	AliDebug(3,Form("index = %d",indexDP));
	AliDebug(3,Form("name = %s",fgkDCSDataPoints[indexDP]));
	AliDebug(2,Form("graph = %p",graph));	
	AliDebug(3,Form("sensorCavernP2_2 = %p", sensorCavernP22));
	if(sensorCavernP22->GetFit() || graph) {
		if (sensorCavernP22->GetFit()){
			Log(Form("Fit for sensor %s found",fgkDCSDataPoints[indexDP]));
		}
		else {
			Log(Form("Fit for sensor %s not found, but the graph is there - NOT going into error",fgkDCSDataPoints[indexDP]));
		}
		grpObj->SetCavernAtmosPressure2(sensorCavernP22);
		ffailedDPs->RemoveAt(indexDP);
		nEnvEntries++;
	} 
	//if (sensorP2) delete sensorP2;
	else {
		Log(Form("ERROR!!! Neither graph nor fit found for sensor %s - this will not increase the number of found DCS DPs and will cause an error", fgkDCSDataPoints[indexDP] ));
	}
	
	
	return nEnvEntries;
}
//_______________________________________________________________

Int_t AliGRPPreprocessor::ProcessHPDPs(const TMap* valueMap, AliGRPObject* grpObj)
{
	// processing DPs
	// related to 
	// Hall Probes info

	Int_t nHPEntries = 0;
	TObjArray *array = 0x0;
	Int_t indexDP = -1;
	Bool_t outOfRange; // flag to monitor if any value collected by DCS is out of range

	if (fgknDCSDPHallProbes != AliGRPObject::GetNumberOfHP()){
		AliError(Form("Number of Hall probes expected in GRP Preprocessor (i.e. %d) different from number of Hall Probes foreseen in GRP object (i.e. %d). Looping on entries from GRP object anyway.", fgknDCSDPHallProbes, AliGRPObject::GetNumberOfHP()));
	}
	for (indexDP = 0; indexDP < AliGRPObject::GetNumberOfHP(); indexDP++){
		outOfRange = kFALSE; // resetting outOfRange flag at each HP
		AliInfo(Form("==========%s===========",AliGRPObject::GetHPDP(indexDP)));
		array = (TObjArray *)valueMap->GetValue(AliGRPObject::GetHPDP(indexDP));
		if(!array) {
			Log(Form("%s not found in the map!!!",AliGRPObject::GetHPDP(indexDP)));
		} 
		else {
			if (array->GetEntries() == 0){
				AliError(Form("No entries found in array! setting %s to invalid...",AliGRPObject::GetHPDP(indexDP)));
			}
			else {
				Float_t *floatDCS = ProcessFloatAll(array);
				if (floatDCS != NULL){
					AliDebug(2,Form("value[0] = %f, value[1] = %f, value[2] = %f, value[3] = %f, value[4] = %f",floatDCS[0],floatDCS[1],floatDCS[2],floatDCS[3],floatDCS[4])); 
					grpObj->SetHallProbes((AliGRPObject::DP_HallProbes)indexDP,floatDCS);
					for (Int_t kk = 0 ; kk< 5; kk++){
						AliDebug(2,Form("HallProbe[%d][%d]=%f",indexDP,kk,grpObj->GetHallProbes((AliGRPObject::DP_HallProbes)indexDP,(AliGRPObject::Stats)kk)));
					}
				}
				else{
					outOfRange = kTRUE;
				}
				if (floatDCS){
					delete[] floatDCS;
					floatDCS = 0x0;
				}
			}
			if (!outOfRange) {
				ffailedDPs->RemoveAt(indexDP + fgkDCSDPHallTopShift);  // 7 = shift in the complete list of DPs to get to the Hall Probes
				nHPEntries++;
			}
		}
	}
		
	Log(Form("Hall Probes = %d ", nHPEntries));
	return nHPEntries;
}

//_________________________________________________________________________

AliSplineFit* AliGRPPreprocessor::GetSplineFit(const TObjArray *array, const TString& stringID){


	// 
	// returning Spline Fit 
	// 

	Int_t entriesarray = array->GetEntries();
	Float_t* value = new Float_t[entriesarray];
	Float_t* time = new Float_t[entriesarray];
	AliDCSValue* v = 0x0;
	for (Int_t iarray = 0; iarray < entriesarray; iarray++){
		v = (AliDCSValue*)array->At(iarray);
		value[iarray] = v->GetFloat();
		time[iarray] = v->GetTimeStamp();
		AliDebug(2,Form("iarray = %d, value = %f, time = %f",iarray,value[iarray],time[iarray]));
	}
	TGraph* gr = new TGraph(entriesarray,value,time);
	if (!gr ) {
		AliWarning(Form("%s: no input graph to compute SplineFit",stringID.Data()));
		return NULL;
	}
	AliSplineFit *fit = new AliSplineFit();
	fit->SetMinPoints(10);
	fit->InitKnots(gr,10,10,0.0);
	fit->SplineFit(2);
	fit->Cleanup();
	return fit;
}

//_________________________________________________________________________

TString AliGRPPreprocessor::ProcessChar(const TObjArray *array)
{

	// 
	// processing char
	//

	TString aDCSString="";
	
	AliDCSValue *v = 0x0;
	for(Int_t iCount = 0; iCount < array->GetEntries(); iCount++) {
		v = (AliDCSValue *)array->At(iCount);
		if (((Int_t)(v->GetTimeStamp()) < (Int_t)GetStartTimeDCSQuery()) || ((Int_t)(v->GetTimeStamp()) > (Int_t)GetEndTimeDCSQuery())) {
			AliError(Form("DCS values for the parameter outside the queried interval"));
			continue;
		}
		if (iCount > 0) {
			if (aDCSString != v->GetChar())
			AliError(Form("DCS values for the parameter changed from %s to %c within the queried interval", aDCSString.Data(), (Char_t)v->GetChar()));
		}
		aDCSString = (TString)v->GetChar();  // keeping always last value in the array
	}
	return aDCSString;
}

//__________________________________________________________________________________________________________________

Float_t* AliGRPPreprocessor::ProcessFloatAll(const TObjArray* array)
{
	// 
	// processing Float values using Mean, Median, Standard Deviation wrt Mean, Standar Deviation wrt Median 
	//
	// parameters[0] = mean
	// parameters[1] = truncated mean (calculated excluding points outside +/- 3RMS from mean
	// parameters[2] = median
	// parameters[3] = standard deviation wrt mean
	// parameters[4] = standard deviation wrt median
	//

	TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
	TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
	if (timeStartString.IsNull() || timeStartString.IsNull()){
		if (timeStartString.IsNull()){ 
			AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
		}
		else if (timeStartString.IsNull()){
			AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
		}
		fdaqStartEndTimeOk = kFALSE;
		return 0;
	}  

	Int_t timeStart = (Int_t)(timeStartString.Atoi());
	Int_t timeEnd = (Int_t)(timeEndString.Atoi());
	Float_t* parameters = new Float_t[5];
	Int_t iCounts = 0;
	Int_t iCountsRun = 0;
	Int_t nCounts = array->GetEntries();
	Float_t valueBeforeSOR = 0;
	Float_t valueAfterEOR = 0;
	Int_t timestampBeforeSOR = -1;
	Int_t timestampAfterEOR = -1;
	Int_t ientrySOR = -1;
	Int_t ientryEOR = -1;
	Float_t* arrayValues = 0x0; 
	Double_t* arrayWeights = 0x0; 
	Bool_t truncMeanFlag = kTRUE;  // flag to indicate whether Truncated Mean should be calculated or not
	Bool_t sdFlag = kTRUE;  // flag to indicate whether SD (wrt Mean/Median) should be calculated or not

	for(Int_t i = 0; i < nCounts; i++) {
		AliDCSValue *v = (AliDCSValue *)array->At(i);
		if ((v->GetFloat() <= fminFloat) || (v->GetFloat() >= fmaxFloat)) {
			AliError(Form("Error! Float value found in DCS map at %d-th entry is OUT OF RANGE: value = %6.5e",i,v->GetFloat()));
			if (v->GetFloat() < fminFloat) AliInfo(Form("The value is smaller than %6.5e",fminFloat));
			if (v->GetFloat() > fmaxFloat) AliInfo(Form("The value is greater than %6.5e",fmaxFloat));
			delete [] parameters;
			return NULL;
		}
		if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
			AliDebug(2,Form("%d-th entry = %f at timestamp %i",i,v->GetFloat(),v->GetTimeStamp()));
			iCounts += 1;
			// look for the last value before SOR and the first value before EOR
			if (((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) && (Int_t)(v->GetTimeStamp()) < timeStart) {
				timestampBeforeSOR = (Int_t)(v->GetTimeStamp());
				AliDebug(2,Form("timestamp of last value before SOR = %d, with DAQ_time_start = %d",timestampBeforeSOR,timeStart));
				valueBeforeSOR = v->GetFloat();
			}
			else if ((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery() && (Int_t)(v->GetTimeStamp()) > timeEnd && timestampAfterEOR == -1){
				timestampAfterEOR = (Int_t)(v->GetTimeStamp());
				valueAfterEOR = v->GetFloat();
				AliDebug(2,Form("timestamp of first value after EOR = %d, with DAQ_time_end = %d",timestampAfterEOR,timeEnd));
			}
			// check if there are DPs between DAQ_time_start and DAQ_time_end
			if(((Int_t)(v->GetTimeStamp()) >= timeStart) &&((Int_t)(v->GetTimeStamp()) <= timeEnd)) {
				if (ientrySOR == -1) ientrySOR = i;  // first entry after SOR
				if (ientryEOR < i) ientryEOR = i;  // last entry before EOR
				AliDebug(2,Form("entry between SOR and EOR"));
				iCountsRun += 1;
			}
		}
		else {
			AliError(Form("DCS values for the parameter outside the queried interval: timestamp = %d",v->GetTimeStamp()));
		}
	}

	if (timestampBeforeSOR == -1){
		AliWarning("No value found before SOR");
	}
	if (timestampAfterEOR == -1){
		AliWarning("No value found after EOR");
	}

	AliDebug(2,Form("Number of valid entries (within DCS query interval) = %i, from a total amount of %i entries",iCounts,nCounts));
	AliDebug(2,Form("Last value before DAQ_time_start (SOR) = %f at timestamp = %d",valueBeforeSOR,timestampBeforeSOR));
	AliDebug(2,Form("First value after DAQ_time_end (EOR)   = %f at timestamp = %d",valueAfterEOR,timestampAfterEOR));
	AliInfo(Form("Found %d entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)",iCountsRun));
	AliDebug(2,Form("Index of first entry after DAQ_time_start (SOR) = %d ",ientrySOR));
	AliDebug(2,Form("Index of first entry before DAQ_time_end (EOR) = %d ",ientryEOR));

	Int_t nentriesUsed = 0;
	if (iCountsRun > 1){
		AliInfo("Using entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)");
		AliDebug(2,"Calculating (weighted) Mean and Median");
		arrayValues = new Float_t[iCountsRun]; 
		arrayWeights = new Double_t[iCountsRun]; 
		nentriesUsed = iCountsRun;
		for (Int_t i = ientrySOR; i <= ientryEOR; i++){
			AliDCSValue *v = (AliDCSValue *)array->At(i);
			Int_t timestamp2 = 0;
			if (i < ientryEOR){
				AliDCSValue *v1 = (AliDCSValue *)array->At(i+1);
				timestamp2 = (Int_t)v1->GetTimeStamp();
			}
			else {
				timestamp2 = timeEnd+1;
			}
			arrayWeights[i-ientrySOR] = (Double_t)(timestamp2 - (Int_t)v->GetTimeStamp());
			arrayValues[i-ientrySOR] = v->GetFloat();
		}
		parameters[0] = TMath::Mean(iCountsRun,arrayValues,arrayWeights);
		parameters[2] = TMath::Median(iCountsRun,arrayValues,arrayWeights);
	}
	else if (iCountsRun == 1){
		AliDCSValue* v = (AliDCSValue *)array->At(ientrySOR);
		nentriesUsed = 2;
		if (timestampBeforeSOR != -1 && timestampBeforeSOR != (Int_t)v->GetTimeStamp()){
			AliWarning("Using single entry between DAQ_time_start (SOR) and DAQ_time_end (EOR) and last entry before SOR. Truncated mean won't be calculated.");
			arrayValues = new Float_t[2];
			arrayWeights = new Double_t[2];
			arrayValues[0] = valueBeforeSOR;
			arrayWeights[0] = (Double_t)((Int_t)v->GetTimeStamp()-timestampBeforeSOR);
			arrayValues[1] = v->GetFloat();
			arrayWeights[1] = (Double_t)(timeEnd+1-(Int_t)v->GetTimeStamp());
			AliDebug(2, Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0])); 
			AliDebug(2, Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1])); 
			parameters[0] = TMath::Mean(2,arrayValues,arrayWeights);
			parameters[2] = TMath::Median(2,arrayValues,arrayWeights);
			truncMeanFlag = kFALSE;
		}
		else{
			AliError("Cannot calculate mean, truncated mean, median, SD wrt mean, SD wrt median for current DP - only one value collected during the run, but no value before with which to calculate the statistical quantities");
			parameters[0] = AliGRPObject::GetInvalidFloat();
			parameters[1] = AliGRPObject::GetInvalidFloat();
			parameters[2] = AliGRPObject::GetInvalidFloat();
			parameters[3] = AliGRPObject::GetInvalidFloat();
			parameters[4] = AliGRPObject::GetInvalidFloat();
			return parameters;
		}
	}
	else { // iCountsRun == 0, using only the point immediately before SOR
		if (timestampBeforeSOR == -1){
			AliError("Cannot set mean, truncated mean, median, SD wrt mean, SD wrt median for current DP - no points during the run collected, and point before SOR missing");
			parameters[0] = AliGRPObject::GetInvalidFloat();
			parameters[1] = AliGRPObject::GetInvalidFloat();
			parameters[2] = AliGRPObject::GetInvalidFloat();
			parameters[3] = AliGRPObject::GetInvalidFloat();
			parameters[4] = AliGRPObject::GetInvalidFloat();
			return parameters;
		}
		else {
			AliWarning("Using only last entry before SOR. Truncated mean and Standard deviations (wrt mean/median) won't be calculated.");
			AliDebug(2,Form("value = %f",valueBeforeSOR)); 
			parameters[0] = valueBeforeSOR;
			parameters[2] = valueBeforeSOR;
			truncMeanFlag = kFALSE;
			sdFlag = kFALSE;
		}
	}

	AliDebug(2, Form("nentriesUsed = %d", nentriesUsed));
	Float_t temp = 0;
	Float_t temp1 = 0;
	Float_t sumweights = 0; 
	Int_t entriesTruncMean = 0;
	Float_t* arrayValuesTruncMean = new Float_t[nentriesUsed]; 
	Double_t* arrayWeightsTruncMean = new Double_t[nentriesUsed]; 

	// calculating SD wrt Mean and Median
	AliDebug(2,"Calculating SD wrt Mean and SD wrt Median");
	if (sdFlag){
		for (Int_t i =0; i< nentriesUsed; i++){
			AliDebug(2,Form("Entry %d: value = %f, weight = %f",i,arrayValues[i],arrayWeights[i]));
			temp += (arrayValues[i]-parameters[2])*(arrayValues[i]-parameters[2]);
			temp1 += arrayWeights[i]*(arrayValues[i]-parameters[0])*(arrayValues[i]-parameters[0]);
			sumweights += arrayWeights[i];
		}
		// setting SD wrt Mean 
		if (sumweights != 0 ){
			parameters[3] = TMath::Sqrt(temp1/sumweights);
		}
		else {
			AliError("Sum of weights to calculate Standard Deviation (wrt mean) <= 0, setting the SD to invalid");
			parameters[3] = AliGRPObject::GetInvalidFloat();
		}
		// setting SD wrt Median
		if (nentriesUsed != 0){
			parameters[4] = TMath::Sqrt(temp/nentriesUsed);
		}
		else{
			AliError("Number of entries used to calculate Standard Deviation (wrt median) <= 0, setting the SD to invalid");
			parameters[4] = AliGRPObject::GetInvalidFloat();
		}
	}
	else {
		parameters[3] = AliGRPObject::GetInvalidFloat();
		parameters[4] = AliGRPObject::GetInvalidFloat();
	}		

	// calculating truncated mean (this comes afterwards since you need the SD wrt Mean)
	if (truncMeanFlag){
		AliDebug(2,"Calculating Truncated Mean");
		for (Int_t i =0; i< nentriesUsed; i++){
			AliDebug(2,Form("Entry %d: value = %f, weight = %f",i,arrayValues[i],arrayWeights[i]));
			if ((arrayValues[i]<=parameters[0]+3*parameters[3]) && (arrayValues[i]>=parameters[0]-3*parameters[3])){
				arrayValuesTruncMean[entriesTruncMean]=arrayValues[i];
				arrayWeightsTruncMean[entriesTruncMean]=arrayWeights[i];
				AliDebug(2,Form("For Truncated Mean: Entry %d: value = %f, weight = %f",entriesTruncMean,arrayValuesTruncMean[entriesTruncMean],arrayWeightsTruncMean[entriesTruncMean]));
				entriesTruncMean++;			
			}
			else{
				AliDebug(2,"Discarding entry");
			}
		}
		// setting truncated mean 
		if (entriesTruncMean >1){
			AliDebug(2,Form("%d entries used for truncated mean",entriesTruncMean));
			parameters[1] = TMath::Mean(entriesTruncMean,arrayValuesTruncMean,arrayWeightsTruncMean);
		}
		else{	
			AliDebug(2,Form("Too few entries (%d) to calculate truncated mean",entriesTruncMean));
			parameters[1] = AliGRPObject::GetInvalidFloat();
		}
	}
	else{
			parameters[1] = AliGRPObject::GetInvalidFloat();
	}

	if (arrayValues){
		delete [] arrayValues;
	} 
	if (arrayWeights){
		delete [] arrayWeights;
	} 
	delete [] arrayValuesTruncMean;
	delete [] arrayWeightsTruncMean;

	AliInfo(Form("(weighted) mean = %f ",parameters[0]));
	AliInfo(Form("(weighted) truncated mean = %f ",parameters[1]));
	AliInfo(Form("median = %f ",parameters[2]));
	AliInfo(Form("(weighted) standard deviation with (weighted) mean = %f ",parameters[3]));
	AliInfo(Form("standard deviation with median = %f ",parameters[4]));
	
	return parameters;
}

//__________________________________________________________________________________________________________________

Float_t* AliGRPPreprocessor::ProcessFloatAllMagnet(const TObjArray* array, Int_t indexDP, Bool_t &isZero)
{
	// 
	// processing Float values using Mean, Median, Standard Deviation wrt Mean, Standar Deviation wrt Median 
	// used for L3 and Dipole magnets, using isZero flag to decide whther the magnet was OFF/ON
	// the flag is set according to the L3/Dipole current value
	// current threshold for L3 = 350 A (value provided by DCS)
	// current threshold for Dipole = 450 A (value provided by DCS)
	//
	// parameters[0] = mean
	// parameters[1] = truncated mean (calculated excluding points outside +/- 3RMS from mean
	// parameters[2] = median
	// parameters[3] = standard deviation wrt mean
	// parameters[4] = standard deviation wrt median
	//

	AliInfo(Form("indexDP = %d",indexDP)); 

	Int_t nCounts = array->GetEntries();
	for(Int_t i = 0; i < nCounts; i++) {
		AliDCSValue *v = (AliDCSValue *)array->At(i);
		if ((v->GetFloat() <= fminFloat) || (v->GetFloat() >= fmaxFloat)) {
			AliError(Form("Error! Float value found in DCS map at %d-th entry is OUT OF RANGE: value = %6.5e",i,v->GetFloat()));
			if (v->GetFloat() < fminFloat) AliInfo(Form("The value is smaller than %6.5e",fminFloat));
			if (v->GetFloat() > fmaxFloat) AliInfo(Form("The value is greater than %6.5e",fmaxFloat));
			return NULL;
		}
		if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
			AliDebug(2,Form("%d-th entry = %f",i,v->GetFloat()));
			if (indexDP == kL3Current && v->GetFloat() > 350 && isZero == kTRUE) isZero=kFALSE; 
			if (indexDP == kDipoleCurrent && v->GetFloat() > 450 && isZero == kTRUE) isZero=kFALSE; 
		}
		else {
			AliError(Form("DCS values for the parameter outside the queried interval"));
		}
	}

	return ProcessFloatAll(array);
}


//_______________________________________________________________

Char_t AliGRPPreprocessor::ProcessBool(const TObjArray* array, Bool_t &change)
{
	// 
	// processing Boolean values
	//

	Bool_t aDCSBool = kTRUE;

	AliDCSValue *v = 0x0;

	for(Int_t iCount = 0; iCount < array->GetEntries(); iCount++) {
		v = (AliDCSValue *)array->At(iCount);
		if (((Int_t)(v->GetTimeStamp()) < (Int_t)GetStartTimeDCSQuery()) || ((Int_t)(v->GetTimeStamp()) > (Int_t)GetEndTimeDCSQuery())) {
			AliError(Form("DCS values for the parameter outside the queried interval"));
			continue;
		}
		if (iCount > 0) {
			if (aDCSBool != v->GetBool()) {
				AliError(Form("DCS values for the parameter changed from %d to %d within the queried interval", (UInt_t)aDCSBool, (UInt_t)v->GetBool()));
				change = kTRUE;
			}
		}
		aDCSBool = v->GetBool(); // always keeping last value
		AliDebug(2,Form("Bool = %d",(Int_t)aDCSBool));
	}
	
	Char_t caDCSBool = (Char_t) aDCSBool;
	return caDCSBool;
	
}

//_______________________________________________________________

Float_t AliGRPPreprocessor::ProcessInt(const TObjArray* array)
{
	// 
	// processing Int values, returning mean
	// AliGRPObject::GetInvalidFloat() is returned if any of the DCS values
	// are outside the queried time interval or their value is out of range
	//

	TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
	TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
	if (timeStartString.IsNull() || timeStartString.IsNull()){
		if (timeStartString.IsNull()){ 
			AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
		}
		else if (timeStartString.IsNull()){
			AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
		}
		return 0;
	}  

	Int_t timeStart = (Int_t)(timeStartString.Atoi());
	Int_t timeEnd = (Int_t)(timeEndString.Atoi());
	Float_t aDCSArrayMean = 0.0;
	Int_t iCounts = 0;
	Float_t valueBeforeSOR = 0;
	Float_t valueAfterEOR = 0;
	Int_t timestampBeforeSOR = -1;
	Int_t timestampAfterEOR = -1;
	Int_t ientrySOR = -1;
	Int_t ientryEOR = -1;
	Float_t* arrayValues = 0x0; 
	Double_t* arrayWeights = 0x0; 
	Int_t iCountsRun = 0;
	Int_t nCounts = array->GetEntries();

	for(Int_t i = 0; i < nCounts; i++) {
		AliDCSValue* v = (AliDCSValue *)array->At(i);
		if ((v->GetInt() < fminInt) || (v->GetInt() > fmaxInt)) {
			AliError(Form("Error! Int value found in DCS map at %d-th entry is OUT OF RANGE: value = %d",i, v->GetInt()));
			return AliGRPObject::GetInvalidFloat();
		}
		if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
			AliDebug(2,Form("%d-th entry = %d at timestamp %i",i,v->GetInt(),v->GetTimeStamp()));
			iCounts += 1;
			// look for the last value before SOR and the first value before EOR
			if (((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) && (Int_t)(v->GetTimeStamp()) < timeStart) {
				timestampBeforeSOR = (Int_t)(v->GetTimeStamp());
				AliDebug(2,Form("timestamp of last entry before SOR = %d, with DAQ_time_start = %d",timestampBeforeSOR,timeStart));
				valueBeforeSOR = (Float_t) v->GetInt();
			}
			else if ((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery() && (Int_t)(v->GetTimeStamp()) > timeEnd && timestampAfterEOR == -1){
				timestampAfterEOR = (Int_t)(v->GetTimeStamp());
				valueAfterEOR = (Float_t) v->GetInt();
				AliDebug(2,Form("timestamp of first entry after EOR = %d, with DAQ_time_end = %d",timestampAfterEOR,timeEnd));
			}
			// check if there are DPs between DAQ_time_start and DAQ_time_end
			if(((Int_t)(v->GetTimeStamp()) >= timeStart) &&((Int_t)(v->GetTimeStamp()) <= timeEnd)) {
				if (ientrySOR == -1) ientrySOR = i;  // first entry after SOR
				if (ientryEOR < i) ientryEOR = i;  // last entry before EOR
				AliDebug(2,Form("entry between SOR and EOR"));
				iCountsRun += 1;
			}
		}
		else {
			AliError(Form("DCS values for the parameter outside the queried interval: timestamp = %d",v->GetTimeStamp()));
		}
	}

	if (timestampBeforeSOR == -1){
		AliWarning("No value found before SOR!");
	}
	if (timestampAfterEOR == -1){
		AliWarning("No value found after EOR!");
	}

	AliDebug(2,Form("Number of valid entries (within query interval) = %i, starting from %i entries",iCounts,nCounts));
	AliDebug(2,Form("Last value before DAQ_time_start (SOR) = %f at timestamp = %d",valueBeforeSOR,timestampBeforeSOR));
	AliDebug(2,Form("First value after DAQ_time_end (EOR)   = %f at timestamp = %d",valueAfterEOR,timestampAfterEOR));
	AliInfo(Form("Found %d entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)",iCountsRun));
	AliDebug(2,Form("Index of first entry after DAQ_time_start (SOR) = %d ",ientrySOR));
	AliDebug(2,Form("Index of first entry before DAQ_time_end (EOR) = %d ",ientryEOR));

	Int_t nentriesUsed = 0;
	if (iCountsRun > 1){
		AliInfo("Using entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)");
		AliDebug(2,"Calculating (weighted) Mean");
		arrayValues = new Float_t[iCountsRun]; 
		arrayWeights = new Double_t[iCountsRun]; 
		nentriesUsed = iCountsRun;
		for (Int_t i = ientrySOR; i <= ientryEOR; i++){
			AliDCSValue *v = (AliDCSValue *)array->At(i);
			Int_t timestamp2 = 0;
			if (i < ientryEOR){
				AliDCSValue *v1 = (AliDCSValue *)array->At(i+1);
				timestamp2 = (Int_t)v1->GetTimeStamp();
			}
			else {
				timestamp2 = timeEnd+1;
			}
			arrayWeights[i-ientrySOR] = (Double_t)(timestamp2 - (Int_t)v->GetTimeStamp());
			arrayValues[i-ientrySOR] = (Float_t)v->GetInt();
		}
		aDCSArrayMean = TMath::Mean(iCountsRun,arrayValues,arrayWeights);
		delete [] arrayValues;
		delete [] arrayWeights;
	}
	else if (iCountsRun == 1){
		AliDCSValue* v = (AliDCSValue *)array->At(ientrySOR);
		nentriesUsed = 2;
		if (timestampBeforeSOR != -1 && timestampBeforeSOR != (Int_t)v->GetTimeStamp()){
			AliWarning("Using single entry between DAQ_time_start (SOR) and DAQ_time_end (EOR) and last entry before SOR.");
			arrayValues = new Float_t[2];
			arrayWeights = new Double_t[2];
			arrayValues[0] = valueBeforeSOR;
			arrayWeights[0] = (Double_t)((Int_t)v->GetTimeStamp()-timestampBeforeSOR);
			arrayValues[1] = (Float_t)v->GetInt();
			arrayWeights[1] = (Double_t)(timeEnd+1-(Int_t)v->GetTimeStamp());
			AliDebug(2,Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0])); 
			AliDebug(2,Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1])); 
			aDCSArrayMean = TMath::Mean(2,arrayValues,arrayWeights);
			delete [] arrayValues;
			delete [] arrayWeights;
		}
		else{
			AliError("Cannot calculate mean - only one value collected during the run, but no value before with which to calculate the statistical quantities");
			return AliGRPObject::GetInvalidFloat();
		}
	}
	else { // iCountsRun == 0, using the point immediately before SOR and the one immediately after EOR
		if (timestampBeforeSOR == -1 || timestampAfterEOR == -1){
			if (timestampBeforeSOR == -1){
				AliError("Cannot calculate mean - no points during the run collected, and point before SOR missing");
			}
			if (timestampAfterEOR == -1){
				AliError("Cannot calculate maen - no points during the run collected, and point after EOR missing");
			}
			return AliGRPObject::GetInvalidFloat();
		}
		else {
			AliWarning("Using last entry before SOR and first entry after EOR.");
			nentriesUsed = 2;
			arrayValues = new Float_t[2];
			arrayWeights = new Double_t[2];
			arrayValues[0] = valueBeforeSOR;
			arrayWeights[0] = (Double_t)(timestampAfterEOR - timestampBeforeSOR);
			arrayValues[1] = valueAfterEOR;
			arrayWeights[1] = 1.;
			AliDebug(2,Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0])); 
			AliDebug(2,Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1])); 
			aDCSArrayMean = TMath::Mean(1,arrayValues,arrayWeights);
			delete [] arrayValues;
			delete [] arrayWeights;
		}
	}

	AliDebug(2, Form("nentriesUsed = %d", nentriesUsed));
	AliInfo(Form("mean = %f ", aDCSArrayMean));
	return aDCSArrayMean;

}
//_______________________________________________________________

Float_t AliGRPPreprocessor::ProcessUInt(const TObjArray* array)
{
	// 
	// processing Int values, returning mean 
	// AliGRPObject::GetInvalidFloat() is returned if any of the DCS values
	// are outside the queried time interval or their value is out of range
	//

	TString timeStartString = (TString)GetRunParameter("DAQ_time_start");
	TString timeEndString = (TString)GetRunParameter("DAQ_time_end");
	if (timeStartString.IsNull() || timeStartString.IsNull()){
		if (timeStartString.IsNull()){ 
			AliError("DAQ_time_start not set in logbook! Setting statistical values for current DP to invalid");
		}
		else if (timeStartString.IsNull()){
			AliError("DAQ_time_end not set in logbook! Setting statistical values for current DP to invalid");
		}
		return 0;
	}  

	Int_t timeStart = (Int_t)(timeStartString.Atoi());
	Int_t timeEnd = (Int_t)(timeEndString.Atoi());
	Float_t aDCSArrayMean = 0.0;
	Int_t iCounts = 0;
	Float_t valueBeforeSOR = 0;
	Float_t valueAfterEOR = 0;
	Int_t timestampBeforeSOR = -1;
	Int_t timestampAfterEOR = -1;
	Int_t ientrySOR = -1;
	Int_t ientryEOR = -1;
	Float_t* arrayValues = 0x0; 
	Double_t* arrayWeights = 0x0; 
	Int_t iCountsRun = 0;
	Int_t nCounts = array->GetEntries();

	for(Int_t i = 0; i < nCounts; i++) {
		AliDCSValue* v = (AliDCSValue *)array->At(i);
		if ((v->GetUInt() < fminUInt) || (v->GetUInt() > fmaxUInt)) {
			AliError(Form("Error! UInt value found in DCS map at %d-th entry is OUT OF RANGE: value = %u",i,v->GetUInt()));
			return AliGRPObject::GetInvalidFloat();
		}
		if(((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) &&((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery())) {
			AliDebug(2,Form("%d-th entry = %d at timestamp %i",i,v->GetUInt(),v->GetTimeStamp()));
			iCounts += 1;
			// look for the last value before SOR and the first value before EOR
			if (((Int_t)(v->GetTimeStamp()) >= (Int_t)GetStartTimeDCSQuery()) && (Int_t)(v->GetTimeStamp()) < timeStart) {
				timestampBeforeSOR = (Int_t)(v->GetTimeStamp());
				AliDebug(2,Form("timestamp of last entry before SOR = %d, with DAQ_time_start = %d",timestampBeforeSOR,timeStart));
				valueBeforeSOR = (Float_t)v->GetUInt();
			}
			else if ((Int_t)(v->GetTimeStamp()) <= (Int_t)GetEndTimeDCSQuery() && (Int_t)(v->GetTimeStamp()) > timeEnd && timestampAfterEOR == -1){
				timestampAfterEOR = (Int_t)(v->GetTimeStamp());
				valueAfterEOR = (Float_t)v->GetUInt();
				AliDebug(2,Form("timestamp of first entry after EOR = %d, with DAQ_time_end = %d",timestampAfterEOR,timeEnd));
			}
			// check if there are DPs between DAQ_time_start and DAQ_time_end
			if(((Int_t)(v->GetTimeStamp()) >= timeStart) &&((Int_t)(v->GetTimeStamp()) <= timeEnd)) {
				if (ientrySOR == -1) ientrySOR = i;  // first entry after SOR
				if (ientryEOR < i) ientryEOR = i;  // last entry before EOR
				AliDebug(2,Form("entry between SOR and EOR"));
				iCountsRun += 1;
			}
		}
		else {
			AliError(Form("DCS values for the parameter outside the queried interval: timestamp = %d",v->GetTimeStamp()));
		}
	}

	if (timestampBeforeSOR == -1){
		AliWarning("No value found before SOR!");
	}
	if (timestampAfterEOR == -1){
		AliWarning("No value found after EOR!");
	}

	AliDebug(2,Form("Number of valid entries (within query interval) = %i, starting from %i entries",iCounts,nCounts));
	AliDebug(2,Form("Last value before DAQ_time_start (SOR) = %f at timestamp = %d",valueBeforeSOR,timestampBeforeSOR));
	AliDebug(2,Form("First value after DAQ_time_end (EOR)   = %f at timestamp = %d",valueAfterEOR,timestampAfterEOR));
	AliInfo(Form("Found %d entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)",iCountsRun));
	AliDebug(2,Form("Index of first entry after DAQ_time_start (SOR) = %d ",ientrySOR));
	AliDebug(2,Form("Index of first entry before DAQ_time_end (EOR) = %d ",ientryEOR));

	Int_t nentriesUsed = 0;
	if (iCountsRun > 1){
		AliInfo("Using entries between DAQ_time_start (SOR) and DAQ_time_end (EOR)");
		AliDebug(2,"Calculating (weighted) Mean");
		arrayValues = new Float_t[iCountsRun]; 
		arrayWeights = new Double_t[iCountsRun]; 
		nentriesUsed = iCountsRun;
		for (Int_t i = ientrySOR; i <= ientryEOR; i++){
			AliDCSValue *v = (AliDCSValue *)array->At(i);
			Int_t timestamp2 = 0;
			if (i < ientryEOR){
				AliDCSValue *v1 = (AliDCSValue *)array->At(i+1);
				timestamp2 = (Int_t)v1->GetTimeStamp();
			}
			else {
				timestamp2 = timeEnd+1;
			}
			arrayWeights[i-ientrySOR] = (Double_t)(timestamp2 - (Int_t)v->GetTimeStamp());
			arrayValues[i-ientrySOR] = (Float_t)v->GetUInt();
		}
		aDCSArrayMean = TMath::Mean(iCountsRun,arrayValues,arrayWeights);
		delete [] arrayValues;
		delete [] arrayWeights;
	}
	else if (iCountsRun == 1){
		AliDCSValue* v = (AliDCSValue *)array->At(ientrySOR);
		nentriesUsed = 2;
		if (timestampBeforeSOR != -1 && timestampBeforeSOR != (Int_t)v->GetTimeStamp()){
			AliWarning("Using single entry between DAQ_time_start (SOR) and DAQ_time_end (EOR) and last entry before SOR.");
			arrayValues = new Float_t[2];
			arrayWeights = new Double_t[2];
			arrayValues[0] = valueBeforeSOR;
			arrayWeights[0] = (Double_t)((Int_t)v->GetTimeStamp()-timestampBeforeSOR);
			arrayValues[1] = (Float_t)v->GetUInt();
			arrayWeights[1] = (Double_t)(timeEnd+1-(Int_t)v->GetTimeStamp());
			AliDebug(2,Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0])); 
			AliDebug(2,Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1])); 
			aDCSArrayMean = TMath::Mean(2,arrayValues,arrayWeights);
			delete [] arrayValues;
			delete [] arrayWeights;
		}
		else{
			AliError("Cannot calculate mean - only one value collected during the run, but no value before with which to calculate the statistical quantities");
			return AliGRPObject::GetInvalidFloat();
		}
	}
	else { // iCountsRun == 0, using the point immediately before SOR and the one immediately after EOR
		if (timestampBeforeSOR == -1 || timestampAfterEOR == -1){
			if (timestampBeforeSOR == -1){
				AliError("Cannot calculate mean - no points during the run collected, and point before SOR missing");
			}
			if (timestampAfterEOR == -1){
				AliError("Cannot calculate maen - no points during the run collected, and point after EOR missing");
			}
			return AliGRPObject::GetInvalidFloat();
		}
		else {
			AliWarning("Using last entry before SOR and first entry after EOR.");
			nentriesUsed = 2;
			arrayValues = new Float_t[2];
			arrayWeights = new Double_t[2];
			arrayValues[0] = valueBeforeSOR;
			arrayWeights[0] = (Double_t)(timestampAfterEOR - timestampBeforeSOR);
			arrayValues[1] = valueAfterEOR;
			arrayWeights[1] = 1.;
			AliDebug(2,Form("value0 = %f, with weight = %f",arrayValues[0],arrayWeights[0])); 
			AliDebug(2,Form("value1 = %f, with weight = %f",arrayValues[1],arrayWeights[1])); 
			aDCSArrayMean = TMath::Mean(1,arrayValues,arrayWeights);
			delete [] arrayValues;
			delete [] arrayWeights;
		}
	}

	AliDebug(2, Form("nentriesUsed = %d", nentriesUsed));
	AliInfo(Form("mean = %f ",aDCSArrayMean));
	return aDCSArrayMean;

}


//_______________________________________________________________

AliDCSSensorArray *AliGRPPreprocessor::GetPressureMap(TMap* dcsAliasMap)
{
	// extract DCS pressure maps. Perform fits to save space
	
	TMap *map = fPressure->ExtractDCS(dcsAliasMap);
	if (map) {
		AliDebug(2,Form("Map has %d entries",map->GetEntries()));
		fPressure->MakeSplineFit(map);
		Double_t fitFraction = fPressure->NumFits()/fPressure->NumSensors(); 
		if (fitFraction > kFitFraction ) {
			AliInfo(Form("Pressure values extracted, %d fits performed for %d sensors.", fPressure->NumFits(),fPressure->NumSensors()));
		} else { 
			AliInfo("Too few pressure maps fitted!!!");
		}
	} else {
		AliInfo("no atmospheric pressure map extracted!!!");
	}
	delete map;
	
	return fPressure;
}


  
//_______________________________________________________________
Int_t AliGRPPreprocessor::ReceivePromptRecoParameters(UInt_t run, const char* dbHost, Int_t dbPort, const char* dbName, const char* user, const char* password, const char *cdbRoot, TString &gdc)
{
	//
	// Retrieves logbook and trigger information from the online logbook
	// This information is needed for prompt reconstruction
	//
	// Parameters are:
	// Run number
	// DAQ params: dbHost, dbPort, dbName, user, password, logbookTable, triggerTable
	// cdbRoot
	//
	// returns:
	//         positive on success: the return code is the run number of last run processed of the same run type already processed by the SHUTTLE
	//         0 on success and no run was found
	//         negative on error
	//
	// This function is NOT called during the preprocessor run in the Shuttle!
	//
	
	// defaults
	if (dbPort == 0)
		dbPort = 3306;
	
	// CDB connection
	AliCDBManager* cdb = AliCDBManager::Instance();
	cdb->SetDefaultStorage(cdbRoot);
	
	// SQL connection
	TSQLServer* server = TSQLServer::Connect(Form("mysql://%s:%d/%s", dbHost, dbPort, dbName), user, password);
	
	if (!server)
		{
			Printf("ERROR: Could not connect to DAQ LB");
			return -1;
		}
	
	// main logbook
	TString sqlQuery;
	sqlQuery.Form("SELECT DAQ_time_start, run_type, detectorMask, L3_magnetCurrent, Dipole_magnetCurrent,beamType, DAQ_time_end FROM logbook WHERE run = %d", run);
	TSQLResult* result = server->Query(sqlQuery);
	if (!result)
		{
			Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
			return -2;
		}
	
	if (result->GetRowCount() == 0)
		{
			Printf("ERROR: Run %d not found", run);
			delete result;
			return -3;
		}
	
	TSQLRow* row = result->Next();
	if (!row)
		{
			Printf("ERROR: Could not receive data from run %d", run);
			delete result;
			return -4;
		}
	
	TString timeStartString(row->GetField(0));
	TString runType(row->GetField(1));
	TString detectorMaskString(row->GetField(2));
	TString l3CurrentString(row->GetField(3));
	TString dipoleCurrentString(row->GetField(4));
	TString beamTypeString(row->GetField(5));
	TString timeEndString(row->GetField(6));

	time_t timeStart = (time_t)(timeStartString.Atoi());
	time_t timeEnd   = (time_t)(timeEndString.Atoi());
	UInt_t detectorMask = (UInt_t)(detectorMaskString.Atoi());
	Float_t l3Current = (Float_t)(TMath::Abs(l3CurrentString.Atof()));
	Float_t dipoleCurrent = (Float_t)(TMath::Abs(dipoleCurrentString.Atof()));
	Char_t l3Polarity = (l3CurrentString.Atof() < 0) ? 1 : 0;
	Char_t dipolePolarity = (dipoleCurrentString.Atof() < 0) ? 1 : 0;
	if (beamTypeString.CompareTo("Pb-Pb",TString::kIgnoreCase) == 0){
		beamTypeString="A-A";
	}
	
	AliGRPObject * grpObj = new AliGRPObject();
	grpObj->SetTimeStart(timeStart); 
	grpObj->SetTimeEnd((timeEnd!=0 && timeEnd>timeStart) ? timeEnd : timeStart+24*3600 ); 
	grpObj->SetRunType((TString)(row->GetField(1)));
	grpObj->SetDetectorMask(detectorMask);
	grpObj->SetL3Current(l3Current,(AliGRPObject::Stats)0);
	grpObj->SetDipoleCurrent(dipoleCurrent,(AliGRPObject::Stats)0);
	grpObj->SetL3Polarity(l3Polarity);
	grpObj->SetDipolePolarity(dipolePolarity);
	grpObj->SetPolarityConventionLHC();  // after the dipole cables swap we comply with LHC convention
	grpObj->SetBeamType(beamTypeString);

	delete row;
	row = 0;
	
	delete result;
	result = 0;
	
	Printf("Storing GRP/GRP/Data object with the following content");
	grpObj->Dump();
	
	AliCDBMetaData metadata;
	metadata.SetResponsible("Jan Fiete Grosse-Oetringhaus & Chiara Zampolli");
	metadata.SetComment("GRP Output parameters received during online running");
	
	AliCDBId id("GRP/GRP/Data", run, run);
	Bool_t success = cdb->Put(grpObj, id, &metadata);
	
	delete grpObj;
	
	if (!success)
		{
			Printf("ERROR: Could not store GRP/GRP/Data into OCDB");
			return -5;
		}
	
	// Receive trigger information
	sqlQuery.Form("SELECT configFile FROM logbook_trigger_config WHERE run = %d", run);
	result = server->Query(sqlQuery);
	if (!result)
		{
			Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
			return -11;
		}
	
	if (result->GetRowCount() == 0)
		{
			Printf("ERROR: Run %d not found in logbook_trigger_config", run);
			delete result;
			return -12;
		}
	
	row = result->Next();
	if (!row)
		{
			Printf("ERROR: Could not receive logbook_trigger_config data from run %d", run);
			delete result;
			return -13;
		}
	
	TString triggerConfig(row->GetField(0));
	
	delete row;
	row = 0;
	
	delete result;
	result = 0;
	
	Printf("Found trigger configuration: %s", triggerConfig.Data());
	
	AliTriggerConfiguration *runcfg = AliTriggerConfiguration::LoadConfigurationFromString(triggerConfig);
	if (!runcfg)
		{
			Printf("ERROR: Could not create CTP configuration object");
			return -14;
		}
	
	metadata.SetComment("CTP run configuration received during online running");
	
	AliCDBId id2("GRP/CTP/Config", run, run);
	success = cdb->Put(runcfg, id2, &metadata);
	
	delete runcfg;
	runcfg = 0;
	
	if (!success)
		{
			Printf("ERROR: Could not store GRP/CTP/Config into OCDB");
			return -15;
		}
	

	// Receive list of GDCs for this run
	sqlQuery.Form("SELECT GDC FROM logbook_stats_GDC WHERE run = %d", run);
	result = server->Query(sqlQuery);
	if (!result)
		{
			Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
			return -24;
		}
	
	if (result->GetRowCount() == 0)
		{
			Printf("ERROR: Run %d not found in logbook_stats_GDC", run);
			delete result;
			return -25;
		}

	gdc = "";
	for (Int_t iGDC = 0; iGDC < result->GetRowCount(); iGDC++) {
	  row = result->Next();
	  if (!row)
	    {
	      Printf("ERROR: Could not receive logbook_stats_GDC data from run %d", run);
	      delete result;
	      return -26;
	    }
	  gdc += row->GetField(0);
	  gdc += " ";
	}

	delete row;
	row = 0;
	
	delete result;
	result = 0;
	
	Printf("Found GDC: %s", gdc.Data());

	// get last run with same run type that was already processed by the SHUTTLE
	
	sqlQuery.Form("SELECT max(logbook.run) FROM logbook LEFT JOIN logbook_shuttle ON logbook_shuttle.run = logbook.run WHERE run_type = '%s' AND shuttle_done = 1", runType.Data());
	result = server->Query(sqlQuery);
	if (!result)
		{
			Printf("ERROR: Can't execute query <%s>!", sqlQuery.Data());
			return -21;
		}
	
	if (result->GetRowCount() == 0)
		{
			Printf("ERROR: No result with query <%s>", sqlQuery.Data());
			delete result;
			return -22;
		}
	
	row = result->Next();
	if (!row)
		{
			Printf("ERROR: Could not receive data for query <%s>", sqlQuery.Data());
			delete result;
			return -23;
		}
	
	TString lastRunStr(row->GetField(0));
	Int_t lastRun = lastRunStr.Atoi();
	
	Printf("Last run with same run type %s is %d", runType.Data(), lastRun);
	
	delete row;
	row = 0;
	
	delete result;
	result = 0;
	
	server->Close();
	delete server;
	server = 0;
	
	return lastRun;
}
//------------------------------------------------------------------------------------------------------
Float_t AliGRPPreprocessor::ProcessEnergy(TObjArray* const array, Double_t timeStart){

	//
	// Method to processo LHC Energy information
	// Only the first value is returned, provided that it is withing DAQ_time_start and DAQ_time_end
	//

	Int_t nCounts = array->GetEntries();
	Float_t energy = -1;
	Double_t timeEnergy = -1;
	Int_t indexEnergy = -1;
	Bool_t foundEnergy = kFALSE;

	AliDebug(2,Form("Energy measurements = %d\n",nCounts));
	if (nCounts ==0){
		AliWarning("No Energy values found! Beam Energy remaining invalid!");
	}
	else{
		for (Int_t i = 0; i < nCounts; i++){
			AliDCSArray *dcs = (AliDCSArray*)array->At(i);
			if (dcs){
				if (dcs->GetTimeStamp()<=timeStart && dcs->GetTimeStamp()>=timeEnergy){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
					timeEnergy = dcs->GetTimeStamp();
					indexEnergy = i;
					foundEnergy = kTRUE;
				}
				else{
					break;
				}
			}
		}
		if (!foundEnergy){
			AliInfo("No value for the Energy found before start of run, the Energy will remain invalid");
		}
		else {
			AliDCSArray* dcs = (AliDCSArray*)array->At(indexEnergy);
			energy = (Float_t)(TMath::Nint(((Double_t)(dcs->GetInt(0)))*120/1000)); // sqrt(s)/2 energy in GeV
			AliInfo(Form("Energy value found = %d (at %f), converting --> sqrt(s)/2 = %f (GeV)", dcs->GetInt(0),dcs->GetTimeStamp(),energy));
		}
	}

	return energy;
}
//------------------------------------------------------------------------------------------------------
AliLHCClockPhase* AliGRPPreprocessor::ProcessLHCClockPhase(TObjArray *beam1phase,TObjArray *beam2phase, Double_t timeEnd)
{
  //
  // Method to process LHC-Clock Phase data
  // Only the values between DAQ_time_start and DAQ_time_end are kept
  //
  AliLHCClockPhase *phaseObj = new AliLHCClockPhase;

  Bool_t foundBeam1Phase = kFALSE, foundBeam2Phase = kFALSE;
  const Float_t threshold = 0.050; // we store the measurement only in case they differ with more 50ps from the previous one 

  TString timeCreatedStr = GetRunParameter("time_created");
  Double_t timeCreated = timeCreatedStr.Atof();

  Int_t nCounts = beam1phase->GetEntries();
  AliDebug(2,Form("Beam1 phase measurements = %d\n",nCounts));
  if (nCounts ==0){
    AliWarning("No beam1 LHC clock phase values found!");
    delete phaseObj;
    return NULL;
  }
  else{
    Double_t prevPhase = 0;
    for (Int_t i = 0; i < nCounts; i++){
      AliDCSArray *dcs = (AliDCSArray*)beam1phase->At(i);
      if (dcs){
	      //if (dcs->GetTimeStamp()>=timeStart && dcs->GetTimeStamp()<=timeEnd) {
	      if (dcs->GetTimeStamp()>=timeCreated && dcs->GetTimeStamp()<=timeEnd) {
	  if ((i == 0) || (i == (nCounts-1)) ||
	      !foundBeam1Phase ||
	      (TMath::Abs(dcs->GetDouble(0)-prevPhase) > threshold)) {
	    prevPhase = dcs->GetDouble(0);
	    foundBeam1Phase = kTRUE;
	    AliInfo(Form("B1 Clk Phase = %f at TS = %f",
			 (Float_t)dcs->GetDouble(0),dcs->GetTimeStamp()));  
	    phaseObj->AddPhaseB1DP((UInt_t)dcs->GetTimeStamp(),(Float_t)dcs->GetDouble(0));
	  }
	}
      }
    }
    if (!foundBeam1Phase){
      AliError("No beam1 LHC clock phase values found within the run!");
      delete phaseObj;
      return NULL;
    }
  }

  nCounts = beam2phase->GetEntries();
  AliDebug(2,Form("Beam2 phase measurements = %d\n",nCounts));
  if (nCounts ==0){
    AliWarning("No beam2 LHC clock phase values found!");
    delete phaseObj;
    return NULL;
  }
  else{
    Double_t prevPhase = 0;
    for (Int_t i = 0; i < nCounts; i++){
      AliDCSArray *dcs = (AliDCSArray*)beam2phase->At(i);
      if (dcs){
	if (dcs->GetTimeStamp()>=timeCreated && dcs->GetTimeStamp()<=timeEnd) {
	  if ((i == 0) || (i == (nCounts-1)) ||
	      !foundBeam2Phase ||
	      (TMath::Abs(dcs->GetDouble(0)-prevPhase) > threshold)) {
	    prevPhase = dcs->GetDouble(0);
	    foundBeam2Phase = kTRUE;
	    AliInfo(Form("B2 Clk Phase = %f at TS = %f",
			 (Float_t)dcs->GetDouble(0),dcs->GetTimeStamp()));  
	    phaseObj->AddPhaseB2DP((UInt_t)dcs->GetTimeStamp(),(Float_t)dcs->GetDouble(0));
	  }
	}
      }
    }
    if (!foundBeam2Phase){
      AliError("No beam2 LHC clock phase values found within the run!");
      delete phaseObj;
      return NULL;
    }
  }

  return phaseObj;
}
//------------------------------------------------------------------------------------------------------
TString AliGRPPreprocessor::ParseBeamTypeString(TString beamType, Int_t iBeamType)
{
	// Method to return the convention for the separate beam type
	// in the form A*1000+Z
	// e.g.: Pb82 --> 208000 + 82 = 208082
	//       p --> 1000 + 1 = 1001

	Int_t a = 0;
	Int_t z = 0;
	TString separateString("");
	Log(Form("Setting Beam Type for beam %d to A*1000+Z",iBeamType));
	if (beamType.CompareTo("PROTON",TString::kIgnoreCase) == 0){
		Log(Form("Beam type %d is PROTON --> The single beam type will be set to 1001 (A = 1, Z = 1)",iBeamType));
		separateString = "1001";
		return separateString;
	}
	else { 
		TPRegexp regexpA("\\D+");
		TPRegexp regexpZ("\\d+");
		TObjArray* arrayA = regexpA.MatchS(beamType);
		TObjArray* arrayZ = regexpZ.MatchS(beamType);
		if (arrayA->GetEntries() != 1 || arrayZ->GetEntries() != 1){
			Log(Form("The beamType string for beam %d does not contain the necessary information! Returning the info as published by LHC (i.e. %s)",iBeamType, beamType.Data()));
			return beamType;
		}
		else{
			TString strA = ((TObjString*)(arrayA->At(0)))->String();
			TString strZ = ((TObjString*)(arrayZ->At(0)))->String();
			if (strA.CompareTo("LEAD",TString::kIgnoreCase) == 0 || strA.CompareTo("PB",TString::kIgnoreCase) == 0){
				Log(Form("Beam %d is %s --> A = 208",iBeamType, strA.Data()));
				a = 208;
			}
			else{
				Log(Form("This beam was not foreseen so far, leaving A=0"));
			}
			z = strZ.Atoi();
			Log(Form("Beam %d has Z = %d",iBeamType, z));
			separateString = Form("%d",a*1000+z);
			return separateString;
		}					     
	}
	       
	return separateString;

}
	    
//------------------------------------------------------------------------------------------------------
Bool_t AliGRPPreprocessor::CheckFileRecords(const char* fileName) const
{
    // Check file logical records as in TFile::Map()
    // returning false in case the position of the final record is bigger than the file size
    // It should allow to mark as bad all and only raw tag files which would crash the chaining
    // done in ProcessDaqFxs
    //
    TFile *f = TFile::Open(fileName);
    if(!f){
	Printf("could not open file \"%s\"",fileName);
	return kFALSE;
    }

    Short_t  keylen,cycle;
    UInt_t   datime;
    Int_t    nbytes,date,time,objlen,nwheader;
    date = 0;
    time = 0;
    Long64_t seekkey,seekpdir;
    char    *buffer;
    char     nwhc;
    const Int_t kBEGIN = 100;
    Long64_t fBEGIN = (Long64_t)kBEGIN;    //First used word in file following the file header
    Long64_t idcur = fBEGIN;
    Long64_t fEND = f->GetEND();            //Last used byte in file

    nwheader = 64;
    Int_t nread = nwheader;

    char header[kBEGIN];
    char classname[512];

    while (idcur < fEND) {
	f->Seek(idcur);
	if (idcur+nread >= fEND) nread = fEND-idcur-1;
	if (f->ReadBuffer(header, nread)) {
	    // ReadBuffer returns kTRUE in case of failure.
	    Printf("%s: failed to read the key data from disk at %lld.",f->GetName(),idcur);
	    break;
	}

	buffer=header;
	frombuf(buffer, &nbytes);
	if (!nbytes) {
	    Printf("Address = %lld\tNbytes = %d\t=====E R R O R=======", idcur, nbytes);
	    date = 0; time = 0;
	    break;
	}
	if (nbytes < 0) {
	    Printf("Address = %lld\tNbytes = %d\t=====G A P===========", idcur, nbytes);
	    idcur -= nbytes;
	    f->Seek(idcur);
	    continue;
	    //return kFALSE; // these gaps are not always critical
	}
	Version_t versionkey;
	frombuf(buffer, &versionkey);
	frombuf(buffer, &objlen);
	frombuf(buffer, &datime);
	frombuf(buffer, &keylen);
	frombuf(buffer, &cycle);
	if (versionkey > 1000) {
	    frombuf(buffer, &seekkey);
	    frombuf(buffer, &seekpdir);
	} else {
	    Int_t skey,sdir;
	    frombuf(buffer, &skey);  seekkey  = (Long64_t)skey;
	    frombuf(buffer, &sdir);  seekpdir = (Long64_t)sdir;
	}
	frombuf(buffer, &nwhc);
	for (int i = 0;i < nwhc; i++) frombuf(buffer, &classname[i]);
	classname[(int)nwhc] = '\0'; //cast to avoid warning with gcc3.4
	Long64_t fSeekFree = f->GetSeekFree();
	Long64_t fSeekInfo = f->GetSeekInfo();
	Long64_t fSeekKeys = f->GetSeekKeys();
	if (idcur == fSeekFree) strlcpy(classname,"FreeSegments",512);
	if (idcur == fSeekInfo) strlcpy(classname,"StreamerInfo",512);
	if (idcur == fSeekKeys) strlcpy(classname,"KeysList",512);
	TDatime::GetDateTime(datime, date, time);
	/*
	if (objlen != nbytes-keylen) {
	    Float_t cx = Float_t(objlen+keylen)/Float_t(nbytes);
	    Printf("%d/%06d  At:%lld  N=%-8d  %-14s CX = %5.2f",date,time,idcur,nbytes,classname,cx);
	} else {
	    Printf("%d/%06d  At:%lld  N=%-8d  %-14s",date,time,idcur,nbytes,classname);
	}
	*/
	idcur += nbytes;
    }
    //Printf("%d/%06d  At:%lld  N=%-8d  %-14s",date,time,idcur,1,"END");
    if(idcur > f->GetSize()){
	AliWarning("Bad file: final record position bigger than file size");
	return kFALSE;
    }
    return kTRUE;
}

 AliGRPPreprocessor.cxx:1
 AliGRPPreprocessor.cxx:2
 AliGRPPreprocessor.cxx:3
 AliGRPPreprocessor.cxx:4
 AliGRPPreprocessor.cxx:5
 AliGRPPreprocessor.cxx:6
 AliGRPPreprocessor.cxx:7
 AliGRPPreprocessor.cxx:8
 AliGRPPreprocessor.cxx:9
 AliGRPPreprocessor.cxx:10
 AliGRPPreprocessor.cxx:11
 AliGRPPreprocessor.cxx:12
 AliGRPPreprocessor.cxx:13
 AliGRPPreprocessor.cxx:14
 AliGRPPreprocessor.cxx:15
 AliGRPPreprocessor.cxx:16
 AliGRPPreprocessor.cxx:17
 AliGRPPreprocessor.cxx:18
 AliGRPPreprocessor.cxx:19
 AliGRPPreprocessor.cxx:20
 AliGRPPreprocessor.cxx:21
 AliGRPPreprocessor.cxx:22
 AliGRPPreprocessor.cxx:23
 AliGRPPreprocessor.cxx:24
 AliGRPPreprocessor.cxx:25
 AliGRPPreprocessor.cxx:26
 AliGRPPreprocessor.cxx:27
 AliGRPPreprocessor.cxx:28
 AliGRPPreprocessor.cxx:29
 AliGRPPreprocessor.cxx:30
 AliGRPPreprocessor.cxx:31
 AliGRPPreprocessor.cxx:32
 AliGRPPreprocessor.cxx:33
 AliGRPPreprocessor.cxx:34
 AliGRPPreprocessor.cxx:35
 AliGRPPreprocessor.cxx:36
 AliGRPPreprocessor.cxx:37
 AliGRPPreprocessor.cxx:38
 AliGRPPreprocessor.cxx:39
 AliGRPPreprocessor.cxx:40
 AliGRPPreprocessor.cxx:41
 AliGRPPreprocessor.cxx:42
 AliGRPPreprocessor.cxx:43
 AliGRPPreprocessor.cxx:44
 AliGRPPreprocessor.cxx:45
 AliGRPPreprocessor.cxx:46
 AliGRPPreprocessor.cxx:47
 AliGRPPreprocessor.cxx:48
 AliGRPPreprocessor.cxx:49
 AliGRPPreprocessor.cxx:50
 AliGRPPreprocessor.cxx:51
 AliGRPPreprocessor.cxx:52
 AliGRPPreprocessor.cxx:53
 AliGRPPreprocessor.cxx:54
 AliGRPPreprocessor.cxx:55
 AliGRPPreprocessor.cxx:56
 AliGRPPreprocessor.cxx:57
 AliGRPPreprocessor.cxx:58
 AliGRPPreprocessor.cxx:59
 AliGRPPreprocessor.cxx:60
 AliGRPPreprocessor.cxx:61
 AliGRPPreprocessor.cxx:62
 AliGRPPreprocessor.cxx:63
 AliGRPPreprocessor.cxx:64
 AliGRPPreprocessor.cxx:65
 AliGRPPreprocessor.cxx:66
 AliGRPPreprocessor.cxx:67
 AliGRPPreprocessor.cxx:68
 AliGRPPreprocessor.cxx:69
 AliGRPPreprocessor.cxx:70
 AliGRPPreprocessor.cxx:71
 AliGRPPreprocessor.cxx:72
 AliGRPPreprocessor.cxx:73
 AliGRPPreprocessor.cxx:74
 AliGRPPreprocessor.cxx:75
 AliGRPPreprocessor.cxx:76
 AliGRPPreprocessor.cxx:77
 AliGRPPreprocessor.cxx:78
 AliGRPPreprocessor.cxx:79
 AliGRPPreprocessor.cxx:80
 AliGRPPreprocessor.cxx:81
 AliGRPPreprocessor.cxx:82
 AliGRPPreprocessor.cxx:83
 AliGRPPreprocessor.cxx:84
 AliGRPPreprocessor.cxx:85
 AliGRPPreprocessor.cxx:86
 AliGRPPreprocessor.cxx:87
 AliGRPPreprocessor.cxx:88
 AliGRPPreprocessor.cxx:89
 AliGRPPreprocessor.cxx:90
 AliGRPPreprocessor.cxx:91
 AliGRPPreprocessor.cxx:92
 AliGRPPreprocessor.cxx:93
 AliGRPPreprocessor.cxx:94
 AliGRPPreprocessor.cxx:95
 AliGRPPreprocessor.cxx:96
 AliGRPPreprocessor.cxx:97
 AliGRPPreprocessor.cxx:98
 AliGRPPreprocessor.cxx:99
 AliGRPPreprocessor.cxx:100
 AliGRPPreprocessor.cxx:101
 AliGRPPreprocessor.cxx:102
 AliGRPPreprocessor.cxx:103
 AliGRPPreprocessor.cxx:104
 AliGRPPreprocessor.cxx:105
 AliGRPPreprocessor.cxx:106
 AliGRPPreprocessor.cxx:107
 AliGRPPreprocessor.cxx:108
 AliGRPPreprocessor.cxx:109
 AliGRPPreprocessor.cxx:110
 AliGRPPreprocessor.cxx:111
 AliGRPPreprocessor.cxx:112
 AliGRPPreprocessor.cxx:113
 AliGRPPreprocessor.cxx:114
 AliGRPPreprocessor.cxx:115
 AliGRPPreprocessor.cxx:116
 AliGRPPreprocessor.cxx:117
 AliGRPPreprocessor.cxx:118
 AliGRPPreprocessor.cxx:119
 AliGRPPreprocessor.cxx:120
 AliGRPPreprocessor.cxx:121
 AliGRPPreprocessor.cxx:122
 AliGRPPreprocessor.cxx:123
 AliGRPPreprocessor.cxx:124
 AliGRPPreprocessor.cxx:125
 AliGRPPreprocessor.cxx:126
 AliGRPPreprocessor.cxx:127
 AliGRPPreprocessor.cxx:128
 AliGRPPreprocessor.cxx:129
 AliGRPPreprocessor.cxx:130
 AliGRPPreprocessor.cxx:131
 AliGRPPreprocessor.cxx:132
 AliGRPPreprocessor.cxx:133
 AliGRPPreprocessor.cxx:134
 AliGRPPreprocessor.cxx:135
 AliGRPPreprocessor.cxx:136
 AliGRPPreprocessor.cxx:137
 AliGRPPreprocessor.cxx:138
 AliGRPPreprocessor.cxx:139
 AliGRPPreprocessor.cxx:140
 AliGRPPreprocessor.cxx:141
 AliGRPPreprocessor.cxx:142
 AliGRPPreprocessor.cxx:143
 AliGRPPreprocessor.cxx:144
 AliGRPPreprocessor.cxx:145
 AliGRPPreprocessor.cxx:146
 AliGRPPreprocessor.cxx:147
 AliGRPPreprocessor.cxx:148
 AliGRPPreprocessor.cxx:149
 AliGRPPreprocessor.cxx:150
 AliGRPPreprocessor.cxx:151
 AliGRPPreprocessor.cxx:152
 AliGRPPreprocessor.cxx:153
 AliGRPPreprocessor.cxx:154
 AliGRPPreprocessor.cxx:155
 AliGRPPreprocessor.cxx:156
 AliGRPPreprocessor.cxx:157
 AliGRPPreprocessor.cxx:158
 AliGRPPreprocessor.cxx:159
 AliGRPPreprocessor.cxx:160
 AliGRPPreprocessor.cxx:161
 AliGRPPreprocessor.cxx:162
 AliGRPPreprocessor.cxx:163
 AliGRPPreprocessor.cxx:164
 AliGRPPreprocessor.cxx:165
 AliGRPPreprocessor.cxx:166
 AliGRPPreprocessor.cxx:167
 AliGRPPreprocessor.cxx:168
 AliGRPPreprocessor.cxx:169
 AliGRPPreprocessor.cxx:170
 AliGRPPreprocessor.cxx:171
 AliGRPPreprocessor.cxx:172
 AliGRPPreprocessor.cxx:173
 AliGRPPreprocessor.cxx:174
 AliGRPPreprocessor.cxx:175
 AliGRPPreprocessor.cxx:176
 AliGRPPreprocessor.cxx:177
 AliGRPPreprocessor.cxx:178
 AliGRPPreprocessor.cxx:179
 AliGRPPreprocessor.cxx:180
 AliGRPPreprocessor.cxx:181
 AliGRPPreprocessor.cxx:182
 AliGRPPreprocessor.cxx:183
 AliGRPPreprocessor.cxx:184
 AliGRPPreprocessor.cxx:185
 AliGRPPreprocessor.cxx:186
 AliGRPPreprocessor.cxx:187
 AliGRPPreprocessor.cxx:188
 AliGRPPreprocessor.cxx:189
 AliGRPPreprocessor.cxx:190
 AliGRPPreprocessor.cxx:191
 AliGRPPreprocessor.cxx:192
 AliGRPPreprocessor.cxx:193
 AliGRPPreprocessor.cxx:194
 AliGRPPreprocessor.cxx:195
 AliGRPPreprocessor.cxx:196
 AliGRPPreprocessor.cxx:197
 AliGRPPreprocessor.cxx:198
 AliGRPPreprocessor.cxx:199
 AliGRPPreprocessor.cxx:200
 AliGRPPreprocessor.cxx:201
 AliGRPPreprocessor.cxx:202
 AliGRPPreprocessor.cxx:203
 AliGRPPreprocessor.cxx:204
 AliGRPPreprocessor.cxx:205
 AliGRPPreprocessor.cxx:206
 AliGRPPreprocessor.cxx:207
 AliGRPPreprocessor.cxx:208
 AliGRPPreprocessor.cxx:209
 AliGRPPreprocessor.cxx:210
 AliGRPPreprocessor.cxx:211
 AliGRPPreprocessor.cxx:212
 AliGRPPreprocessor.cxx:213
 AliGRPPreprocessor.cxx:214
 AliGRPPreprocessor.cxx:215
 AliGRPPreprocessor.cxx:216
 AliGRPPreprocessor.cxx:217
 AliGRPPreprocessor.cxx:218
 AliGRPPreprocessor.cxx:219
 AliGRPPreprocessor.cxx:220
 AliGRPPreprocessor.cxx:221
 AliGRPPreprocessor.cxx:222
 AliGRPPreprocessor.cxx:223
 AliGRPPreprocessor.cxx:224
 AliGRPPreprocessor.cxx:225
 AliGRPPreprocessor.cxx:226
 AliGRPPreprocessor.cxx:227
 AliGRPPreprocessor.cxx:228
 AliGRPPreprocessor.cxx:229
 AliGRPPreprocessor.cxx:230
 AliGRPPreprocessor.cxx:231
 AliGRPPreprocessor.cxx:232
 AliGRPPreprocessor.cxx:233
 AliGRPPreprocessor.cxx:234
 AliGRPPreprocessor.cxx:235
 AliGRPPreprocessor.cxx:236
 AliGRPPreprocessor.cxx:237
 AliGRPPreprocessor.cxx:238
 AliGRPPreprocessor.cxx:239
 AliGRPPreprocessor.cxx:240
 AliGRPPreprocessor.cxx:241
 AliGRPPreprocessor.cxx:242
 AliGRPPreprocessor.cxx:243
 AliGRPPreprocessor.cxx:244
 AliGRPPreprocessor.cxx:245
 AliGRPPreprocessor.cxx:246
 AliGRPPreprocessor.cxx:247
 AliGRPPreprocessor.cxx:248
 AliGRPPreprocessor.cxx:249
 AliGRPPreprocessor.cxx:250
 AliGRPPreprocessor.cxx:251
 AliGRPPreprocessor.cxx:252
 AliGRPPreprocessor.cxx:253
 AliGRPPreprocessor.cxx:254
 AliGRPPreprocessor.cxx:255
 AliGRPPreprocessor.cxx:256
 AliGRPPreprocessor.cxx:257
 AliGRPPreprocessor.cxx:258
 AliGRPPreprocessor.cxx:259
 AliGRPPreprocessor.cxx:260
 AliGRPPreprocessor.cxx:261
 AliGRPPreprocessor.cxx:262
 AliGRPPreprocessor.cxx:263
 AliGRPPreprocessor.cxx:264
 AliGRPPreprocessor.cxx:265
 AliGRPPreprocessor.cxx:266
 AliGRPPreprocessor.cxx:267
 AliGRPPreprocessor.cxx:268
 AliGRPPreprocessor.cxx:269
 AliGRPPreprocessor.cxx:270
 AliGRPPreprocessor.cxx:271
 AliGRPPreprocessor.cxx:272
 AliGRPPreprocessor.cxx:273
 AliGRPPreprocessor.cxx:274
 AliGRPPreprocessor.cxx:275
 AliGRPPreprocessor.cxx:276
 AliGRPPreprocessor.cxx:277
 AliGRPPreprocessor.cxx:278
 AliGRPPreprocessor.cxx:279
 AliGRPPreprocessor.cxx:280
 AliGRPPreprocessor.cxx:281
 AliGRPPreprocessor.cxx:282
 AliGRPPreprocessor.cxx:283
 AliGRPPreprocessor.cxx:284
 AliGRPPreprocessor.cxx:285
 AliGRPPreprocessor.cxx:286
 AliGRPPreprocessor.cxx:287
 AliGRPPreprocessor.cxx:288
 AliGRPPreprocessor.cxx:289
 AliGRPPreprocessor.cxx:290
 AliGRPPreprocessor.cxx:291
 AliGRPPreprocessor.cxx:292
 AliGRPPreprocessor.cxx:293
 AliGRPPreprocessor.cxx:294
 AliGRPPreprocessor.cxx:295
 AliGRPPreprocessor.cxx:296
 AliGRPPreprocessor.cxx:297
 AliGRPPreprocessor.cxx:298
 AliGRPPreprocessor.cxx:299
 AliGRPPreprocessor.cxx:300
 AliGRPPreprocessor.cxx:301
 AliGRPPreprocessor.cxx:302
 AliGRPPreprocessor.cxx:303
 AliGRPPreprocessor.cxx:304
 AliGRPPreprocessor.cxx:305
 AliGRPPreprocessor.cxx:306
 AliGRPPreprocessor.cxx:307
 AliGRPPreprocessor.cxx:308
 AliGRPPreprocessor.cxx:309
 AliGRPPreprocessor.cxx:310
 AliGRPPreprocessor.cxx:311
 AliGRPPreprocessor.cxx:312
 AliGRPPreprocessor.cxx:313
 AliGRPPreprocessor.cxx:314
 AliGRPPreprocessor.cxx:315
 AliGRPPreprocessor.cxx:316
 AliGRPPreprocessor.cxx:317
 AliGRPPreprocessor.cxx:318
 AliGRPPreprocessor.cxx:319
 AliGRPPreprocessor.cxx:320
 AliGRPPreprocessor.cxx:321
 AliGRPPreprocessor.cxx:322
 AliGRPPreprocessor.cxx:323
 AliGRPPreprocessor.cxx:324
 AliGRPPreprocessor.cxx:325
 AliGRPPreprocessor.cxx:326
 AliGRPPreprocessor.cxx:327
 AliGRPPreprocessor.cxx:328
 AliGRPPreprocessor.cxx:329
 AliGRPPreprocessor.cxx:330
 AliGRPPreprocessor.cxx:331
 AliGRPPreprocessor.cxx:332
 AliGRPPreprocessor.cxx:333
 AliGRPPreprocessor.cxx:334
 AliGRPPreprocessor.cxx:335
 AliGRPPreprocessor.cxx:336
 AliGRPPreprocessor.cxx:337
 AliGRPPreprocessor.cxx:338
 AliGRPPreprocessor.cxx:339
 AliGRPPreprocessor.cxx:340
 AliGRPPreprocessor.cxx:341
 AliGRPPreprocessor.cxx:342
 AliGRPPreprocessor.cxx:343
 AliGRPPreprocessor.cxx:344
 AliGRPPreprocessor.cxx:345
 AliGRPPreprocessor.cxx:346
 AliGRPPreprocessor.cxx:347
 AliGRPPreprocessor.cxx:348
 AliGRPPreprocessor.cxx:349
 AliGRPPreprocessor.cxx:350
 AliGRPPreprocessor.cxx:351
 AliGRPPreprocessor.cxx:352
 AliGRPPreprocessor.cxx:353
 AliGRPPreprocessor.cxx:354
 AliGRPPreprocessor.cxx:355
 AliGRPPreprocessor.cxx:356
 AliGRPPreprocessor.cxx:357
 AliGRPPreprocessor.cxx:358
 AliGRPPreprocessor.cxx:359
 AliGRPPreprocessor.cxx:360
 AliGRPPreprocessor.cxx:361
 AliGRPPreprocessor.cxx:362
 AliGRPPreprocessor.cxx:363
 AliGRPPreprocessor.cxx:364
 AliGRPPreprocessor.cxx:365
 AliGRPPreprocessor.cxx:366
 AliGRPPreprocessor.cxx:367
 AliGRPPreprocessor.cxx:368
 AliGRPPreprocessor.cxx:369
 AliGRPPreprocessor.cxx:370
 AliGRPPreprocessor.cxx:371
 AliGRPPreprocessor.cxx:372
 AliGRPPreprocessor.cxx:373
 AliGRPPreprocessor.cxx:374
 AliGRPPreprocessor.cxx:375
 AliGRPPreprocessor.cxx:376
 AliGRPPreprocessor.cxx:377
 AliGRPPreprocessor.cxx:378
 AliGRPPreprocessor.cxx:379
 AliGRPPreprocessor.cxx:380
 AliGRPPreprocessor.cxx:381
 AliGRPPreprocessor.cxx:382
 AliGRPPreprocessor.cxx:383
 AliGRPPreprocessor.cxx:384
 AliGRPPreprocessor.cxx:385
 AliGRPPreprocessor.cxx:386
 AliGRPPreprocessor.cxx:387
 AliGRPPreprocessor.cxx:388
 AliGRPPreprocessor.cxx:389
 AliGRPPreprocessor.cxx:390
 AliGRPPreprocessor.cxx:391
 AliGRPPreprocessor.cxx:392
 AliGRPPreprocessor.cxx:393
 AliGRPPreprocessor.cxx:394
 AliGRPPreprocessor.cxx:395
 AliGRPPreprocessor.cxx:396
 AliGRPPreprocessor.cxx:397
 AliGRPPreprocessor.cxx:398
 AliGRPPreprocessor.cxx:399
 AliGRPPreprocessor.cxx:400
 AliGRPPreprocessor.cxx:401
 AliGRPPreprocessor.cxx:402
 AliGRPPreprocessor.cxx:403
 AliGRPPreprocessor.cxx:404
 AliGRPPreprocessor.cxx:405
 AliGRPPreprocessor.cxx:406
 AliGRPPreprocessor.cxx:407
 AliGRPPreprocessor.cxx:408
 AliGRPPreprocessor.cxx:409
 AliGRPPreprocessor.cxx:410
 AliGRPPreprocessor.cxx:411
 AliGRPPreprocessor.cxx:412
 AliGRPPreprocessor.cxx:413
 AliGRPPreprocessor.cxx:414
 AliGRPPreprocessor.cxx:415
 AliGRPPreprocessor.cxx:416
 AliGRPPreprocessor.cxx:417
 AliGRPPreprocessor.cxx:418
 AliGRPPreprocessor.cxx:419
 AliGRPPreprocessor.cxx:420
 AliGRPPreprocessor.cxx:421
 AliGRPPreprocessor.cxx:422
 AliGRPPreprocessor.cxx:423
 AliGRPPreprocessor.cxx:424
 AliGRPPreprocessor.cxx:425
 AliGRPPreprocessor.cxx:426
 AliGRPPreprocessor.cxx:427
 AliGRPPreprocessor.cxx:428
 AliGRPPreprocessor.cxx:429
 AliGRPPreprocessor.cxx:430
 AliGRPPreprocessor.cxx:431
 AliGRPPreprocessor.cxx:432
 AliGRPPreprocessor.cxx:433
 AliGRPPreprocessor.cxx:434
 AliGRPPreprocessor.cxx:435
 AliGRPPreprocessor.cxx:436
 AliGRPPreprocessor.cxx:437
 AliGRPPreprocessor.cxx:438
 AliGRPPreprocessor.cxx:439
 AliGRPPreprocessor.cxx:440
 AliGRPPreprocessor.cxx:441
 AliGRPPreprocessor.cxx:442
 AliGRPPreprocessor.cxx:443
 AliGRPPreprocessor.cxx:444
 AliGRPPreprocessor.cxx:445
 AliGRPPreprocessor.cxx:446
 AliGRPPreprocessor.cxx:447
 AliGRPPreprocessor.cxx:448
 AliGRPPreprocessor.cxx:449
 AliGRPPreprocessor.cxx:450
 AliGRPPreprocessor.cxx:451
 AliGRPPreprocessor.cxx:452
 AliGRPPreprocessor.cxx:453
 AliGRPPreprocessor.cxx:454
 AliGRPPreprocessor.cxx:455
 AliGRPPreprocessor.cxx:456
 AliGRPPreprocessor.cxx:457
 AliGRPPreprocessor.cxx:458
 AliGRPPreprocessor.cxx:459
 AliGRPPreprocessor.cxx:460
 AliGRPPreprocessor.cxx:461
 AliGRPPreprocessor.cxx:462
 AliGRPPreprocessor.cxx:463
 AliGRPPreprocessor.cxx:464
 AliGRPPreprocessor.cxx:465
 AliGRPPreprocessor.cxx:466
 AliGRPPreprocessor.cxx:467
 AliGRPPreprocessor.cxx:468
 AliGRPPreprocessor.cxx:469
 AliGRPPreprocessor.cxx:470
 AliGRPPreprocessor.cxx:471
 AliGRPPreprocessor.cxx:472
 AliGRPPreprocessor.cxx:473
 AliGRPPreprocessor.cxx:474
 AliGRPPreprocessor.cxx:475
 AliGRPPreprocessor.cxx:476
 AliGRPPreprocessor.cxx:477
 AliGRPPreprocessor.cxx:478
 AliGRPPreprocessor.cxx:479
 AliGRPPreprocessor.cxx:480
 AliGRPPreprocessor.cxx:481
 AliGRPPreprocessor.cxx:482
 AliGRPPreprocessor.cxx:483
 AliGRPPreprocessor.cxx:484
 AliGRPPreprocessor.cxx:485
 AliGRPPreprocessor.cxx:486
 AliGRPPreprocessor.cxx:487
 AliGRPPreprocessor.cxx:488
 AliGRPPreprocessor.cxx:489
 AliGRPPreprocessor.cxx:490
 AliGRPPreprocessor.cxx:491
 AliGRPPreprocessor.cxx:492
 AliGRPPreprocessor.cxx:493
 AliGRPPreprocessor.cxx:494
 AliGRPPreprocessor.cxx:495
 AliGRPPreprocessor.cxx:496
 AliGRPPreprocessor.cxx:497
 AliGRPPreprocessor.cxx:498
 AliGRPPreprocessor.cxx:499
 AliGRPPreprocessor.cxx:500
 AliGRPPreprocessor.cxx:501
 AliGRPPreprocessor.cxx:502
 AliGRPPreprocessor.cxx:503
 AliGRPPreprocessor.cxx:504
 AliGRPPreprocessor.cxx:505
 AliGRPPreprocessor.cxx:506
 AliGRPPreprocessor.cxx:507
 AliGRPPreprocessor.cxx:508
 AliGRPPreprocessor.cxx:509
 AliGRPPreprocessor.cxx:510
 AliGRPPreprocessor.cxx:511
 AliGRPPreprocessor.cxx:512
 AliGRPPreprocessor.cxx:513
 AliGRPPreprocessor.cxx:514
 AliGRPPreprocessor.cxx:515
 AliGRPPreprocessor.cxx:516
 AliGRPPreprocessor.cxx:517
 AliGRPPreprocessor.cxx:518
 AliGRPPreprocessor.cxx:519
 AliGRPPreprocessor.cxx:520
 AliGRPPreprocessor.cxx:521
 AliGRPPreprocessor.cxx:522
 AliGRPPreprocessor.cxx:523
 AliGRPPreprocessor.cxx:524
 AliGRPPreprocessor.cxx:525
 AliGRPPreprocessor.cxx:526
 AliGRPPreprocessor.cxx:527
 AliGRPPreprocessor.cxx:528
 AliGRPPreprocessor.cxx:529
 AliGRPPreprocessor.cxx:530
 AliGRPPreprocessor.cxx:531
 AliGRPPreprocessor.cxx:532
 AliGRPPreprocessor.cxx:533
 AliGRPPreprocessor.cxx:534
 AliGRPPreprocessor.cxx:535
 AliGRPPreprocessor.cxx:536
 AliGRPPreprocessor.cxx:537
 AliGRPPreprocessor.cxx:538
 AliGRPPreprocessor.cxx:539
 AliGRPPreprocessor.cxx:540
 AliGRPPreprocessor.cxx:541
 AliGRPPreprocessor.cxx:542
 AliGRPPreprocessor.cxx:543
 AliGRPPreprocessor.cxx:544
 AliGRPPreprocessor.cxx:545
 AliGRPPreprocessor.cxx:546
 AliGRPPreprocessor.cxx:547
 AliGRPPreprocessor.cxx:548
 AliGRPPreprocessor.cxx:549
 AliGRPPreprocessor.cxx:550
 AliGRPPreprocessor.cxx:551
 AliGRPPreprocessor.cxx:552
 AliGRPPreprocessor.cxx:553
 AliGRPPreprocessor.cxx:554
 AliGRPPreprocessor.cxx:555
 AliGRPPreprocessor.cxx:556
 AliGRPPreprocessor.cxx:557
 AliGRPPreprocessor.cxx:558
 AliGRPPreprocessor.cxx:559
 AliGRPPreprocessor.cxx:560
 AliGRPPreprocessor.cxx:561
 AliGRPPreprocessor.cxx:562
 AliGRPPreprocessor.cxx:563
 AliGRPPreprocessor.cxx:564
 AliGRPPreprocessor.cxx:565
 AliGRPPreprocessor.cxx:566
 AliGRPPreprocessor.cxx:567
 AliGRPPreprocessor.cxx:568
 AliGRPPreprocessor.cxx:569
 AliGRPPreprocessor.cxx:570
 AliGRPPreprocessor.cxx:571
 AliGRPPreprocessor.cxx:572
 AliGRPPreprocessor.cxx:573
 AliGRPPreprocessor.cxx:574
 AliGRPPreprocessor.cxx:575
 AliGRPPreprocessor.cxx:576
 AliGRPPreprocessor.cxx:577
 AliGRPPreprocessor.cxx:578
 AliGRPPreprocessor.cxx:579
 AliGRPPreprocessor.cxx:580
 AliGRPPreprocessor.cxx:581
 AliGRPPreprocessor.cxx:582
 AliGRPPreprocessor.cxx:583
 AliGRPPreprocessor.cxx:584
 AliGRPPreprocessor.cxx:585
 AliGRPPreprocessor.cxx:586
 AliGRPPreprocessor.cxx:587
 AliGRPPreprocessor.cxx:588
 AliGRPPreprocessor.cxx:589
 AliGRPPreprocessor.cxx:590
 AliGRPPreprocessor.cxx:591
 AliGRPPreprocessor.cxx:592
 AliGRPPreprocessor.cxx:593
 AliGRPPreprocessor.cxx:594
 AliGRPPreprocessor.cxx:595
 AliGRPPreprocessor.cxx:596
 AliGRPPreprocessor.cxx:597
 AliGRPPreprocessor.cxx:598
 AliGRPPreprocessor.cxx:599
 AliGRPPreprocessor.cxx:600
 AliGRPPreprocessor.cxx:601
 AliGRPPreprocessor.cxx:602
 AliGRPPreprocessor.cxx:603
 AliGRPPreprocessor.cxx:604
 AliGRPPreprocessor.cxx:605
 AliGRPPreprocessor.cxx:606
 AliGRPPreprocessor.cxx:607
 AliGRPPreprocessor.cxx:608
 AliGRPPreprocessor.cxx:609
 AliGRPPreprocessor.cxx:610
 AliGRPPreprocessor.cxx:611
 AliGRPPreprocessor.cxx:612
 AliGRPPreprocessor.cxx:613
 AliGRPPreprocessor.cxx:614
 AliGRPPreprocessor.cxx:615
 AliGRPPreprocessor.cxx:616
 AliGRPPreprocessor.cxx:617
 AliGRPPreprocessor.cxx:618
 AliGRPPreprocessor.cxx:619
 AliGRPPreprocessor.cxx:620
 AliGRPPreprocessor.cxx:621
 AliGRPPreprocessor.cxx:622
 AliGRPPreprocessor.cxx:623
 AliGRPPreprocessor.cxx:624
 AliGRPPreprocessor.cxx:625
 AliGRPPreprocessor.cxx:626
 AliGRPPreprocessor.cxx:627
 AliGRPPreprocessor.cxx:628
 AliGRPPreprocessor.cxx:629
 AliGRPPreprocessor.cxx:630
 AliGRPPreprocessor.cxx:631
 AliGRPPreprocessor.cxx:632
 AliGRPPreprocessor.cxx:633
 AliGRPPreprocessor.cxx:634
 AliGRPPreprocessor.cxx:635
 AliGRPPreprocessor.cxx:636
 AliGRPPreprocessor.cxx:637
 AliGRPPreprocessor.cxx:638
 AliGRPPreprocessor.cxx:639
 AliGRPPreprocessor.cxx:640
 AliGRPPreprocessor.cxx:641
 AliGRPPreprocessor.cxx:642
 AliGRPPreprocessor.cxx:643
 AliGRPPreprocessor.cxx:644
 AliGRPPreprocessor.cxx:645
 AliGRPPreprocessor.cxx:646
 AliGRPPreprocessor.cxx:647
 AliGRPPreprocessor.cxx:648
 AliGRPPreprocessor.cxx:649
 AliGRPPreprocessor.cxx:650
 AliGRPPreprocessor.cxx:651
 AliGRPPreprocessor.cxx:652
 AliGRPPreprocessor.cxx:653
 AliGRPPreprocessor.cxx:654
 AliGRPPreprocessor.cxx:655
 AliGRPPreprocessor.cxx:656
 AliGRPPreprocessor.cxx:657
 AliGRPPreprocessor.cxx:658
 AliGRPPreprocessor.cxx:659
 AliGRPPreprocessor.cxx:660
 AliGRPPreprocessor.cxx:661
 AliGRPPreprocessor.cxx:662
 AliGRPPreprocessor.cxx:663
 AliGRPPreprocessor.cxx:664
 AliGRPPreprocessor.cxx:665
 AliGRPPreprocessor.cxx:666
 AliGRPPreprocessor.cxx:667
 AliGRPPreprocessor.cxx:668
 AliGRPPreprocessor.cxx:669
 AliGRPPreprocessor.cxx:670
 AliGRPPreprocessor.cxx:671
 AliGRPPreprocessor.cxx:672
 AliGRPPreprocessor.cxx:673
 AliGRPPreprocessor.cxx:674
 AliGRPPreprocessor.cxx:675
 AliGRPPreprocessor.cxx:676
 AliGRPPreprocessor.cxx:677
 AliGRPPreprocessor.cxx:678
 AliGRPPreprocessor.cxx:679
 AliGRPPreprocessor.cxx:680
 AliGRPPreprocessor.cxx:681
 AliGRPPreprocessor.cxx:682
 AliGRPPreprocessor.cxx:683
 AliGRPPreprocessor.cxx:684
 AliGRPPreprocessor.cxx:685
 AliGRPPreprocessor.cxx:686
 AliGRPPreprocessor.cxx:687
 AliGRPPreprocessor.cxx:688
 AliGRPPreprocessor.cxx:689
 AliGRPPreprocessor.cxx:690
 AliGRPPreprocessor.cxx:691
 AliGRPPreprocessor.cxx:692
 AliGRPPreprocessor.cxx:693
 AliGRPPreprocessor.cxx:694
 AliGRPPreprocessor.cxx:695
 AliGRPPreprocessor.cxx:696
 AliGRPPreprocessor.cxx:697
 AliGRPPreprocessor.cxx:698
 AliGRPPreprocessor.cxx:699
 AliGRPPreprocessor.cxx:700
 AliGRPPreprocessor.cxx:701
 AliGRPPreprocessor.cxx:702
 AliGRPPreprocessor.cxx:703
 AliGRPPreprocessor.cxx:704
 AliGRPPreprocessor.cxx:705
 AliGRPPreprocessor.cxx:706
 AliGRPPreprocessor.cxx:707
 AliGRPPreprocessor.cxx:708
 AliGRPPreprocessor.cxx:709
 AliGRPPreprocessor.cxx:710
 AliGRPPreprocessor.cxx:711
 AliGRPPreprocessor.cxx:712
 AliGRPPreprocessor.cxx:713
 AliGRPPreprocessor.cxx:714
 AliGRPPreprocessor.cxx:715
 AliGRPPreprocessor.cxx:716
 AliGRPPreprocessor.cxx:717
 AliGRPPreprocessor.cxx:718
 AliGRPPreprocessor.cxx:719
 AliGRPPreprocessor.cxx:720
 AliGRPPreprocessor.cxx:721
 AliGRPPreprocessor.cxx:722
 AliGRPPreprocessor.cxx:723
 AliGRPPreprocessor.cxx:724
 AliGRPPreprocessor.cxx:725
 AliGRPPreprocessor.cxx:726
 AliGRPPreprocessor.cxx:727
 AliGRPPreprocessor.cxx:728
 AliGRPPreprocessor.cxx:729
 AliGRPPreprocessor.cxx:730
 AliGRPPreprocessor.cxx:731
 AliGRPPreprocessor.cxx:732
 AliGRPPreprocessor.cxx:733
 AliGRPPreprocessor.cxx:734
 AliGRPPreprocessor.cxx:735
 AliGRPPreprocessor.cxx:736
 AliGRPPreprocessor.cxx:737
 AliGRPPreprocessor.cxx:738
 AliGRPPreprocessor.cxx:739
 AliGRPPreprocessor.cxx:740
 AliGRPPreprocessor.cxx:741
 AliGRPPreprocessor.cxx:742
 AliGRPPreprocessor.cxx:743
 AliGRPPreprocessor.cxx:744
 AliGRPPreprocessor.cxx:745
 AliGRPPreprocessor.cxx:746
 AliGRPPreprocessor.cxx:747
 AliGRPPreprocessor.cxx:748
 AliGRPPreprocessor.cxx:749
 AliGRPPreprocessor.cxx:750
 AliGRPPreprocessor.cxx:751
 AliGRPPreprocessor.cxx:752
 AliGRPPreprocessor.cxx:753
 AliGRPPreprocessor.cxx:754
 AliGRPPreprocessor.cxx:755
 AliGRPPreprocessor.cxx:756
 AliGRPPreprocessor.cxx:757
 AliGRPPreprocessor.cxx:758
 AliGRPPreprocessor.cxx:759
 AliGRPPreprocessor.cxx:760
 AliGRPPreprocessor.cxx:761
 AliGRPPreprocessor.cxx:762
 AliGRPPreprocessor.cxx:763
 AliGRPPreprocessor.cxx:764
 AliGRPPreprocessor.cxx:765
 AliGRPPreprocessor.cxx:766
 AliGRPPreprocessor.cxx:767
 AliGRPPreprocessor.cxx:768
 AliGRPPreprocessor.cxx:769
 AliGRPPreprocessor.cxx:770
 AliGRPPreprocessor.cxx:771
 AliGRPPreprocessor.cxx:772
 AliGRPPreprocessor.cxx:773
 AliGRPPreprocessor.cxx:774
 AliGRPPreprocessor.cxx:775
 AliGRPPreprocessor.cxx:776
 AliGRPPreprocessor.cxx:777
 AliGRPPreprocessor.cxx:778
 AliGRPPreprocessor.cxx:779
 AliGRPPreprocessor.cxx:780
 AliGRPPreprocessor.cxx:781
 AliGRPPreprocessor.cxx:782
 AliGRPPreprocessor.cxx:783
 AliGRPPreprocessor.cxx:784
 AliGRPPreprocessor.cxx:785
 AliGRPPreprocessor.cxx:786
 AliGRPPreprocessor.cxx:787
 AliGRPPreprocessor.cxx:788
 AliGRPPreprocessor.cxx:789
 AliGRPPreprocessor.cxx:790
 AliGRPPreprocessor.cxx:791
 AliGRPPreprocessor.cxx:792
 AliGRPPreprocessor.cxx:793
 AliGRPPreprocessor.cxx:794
 AliGRPPreprocessor.cxx:795
 AliGRPPreprocessor.cxx:796
 AliGRPPreprocessor.cxx:797
 AliGRPPreprocessor.cxx:798
 AliGRPPreprocessor.cxx:799
 AliGRPPreprocessor.cxx:800
 AliGRPPreprocessor.cxx:801
 AliGRPPreprocessor.cxx:802
 AliGRPPreprocessor.cxx:803
 AliGRPPreprocessor.cxx:804
 AliGRPPreprocessor.cxx:805
 AliGRPPreprocessor.cxx:806
 AliGRPPreprocessor.cxx:807
 AliGRPPreprocessor.cxx:808
 AliGRPPreprocessor.cxx:809
 AliGRPPreprocessor.cxx:810
 AliGRPPreprocessor.cxx:811
 AliGRPPreprocessor.cxx:812
 AliGRPPreprocessor.cxx:813
 AliGRPPreprocessor.cxx:814
 AliGRPPreprocessor.cxx:815
 AliGRPPreprocessor.cxx:816
 AliGRPPreprocessor.cxx:817
 AliGRPPreprocessor.cxx:818
 AliGRPPreprocessor.cxx:819
 AliGRPPreprocessor.cxx:820
 AliGRPPreprocessor.cxx:821
 AliGRPPreprocessor.cxx:822
 AliGRPPreprocessor.cxx:823
 AliGRPPreprocessor.cxx:824
 AliGRPPreprocessor.cxx:825
 AliGRPPreprocessor.cxx:826
 AliGRPPreprocessor.cxx:827
 AliGRPPreprocessor.cxx:828
 AliGRPPreprocessor.cxx:829
 AliGRPPreprocessor.cxx:830
 AliGRPPreprocessor.cxx:831
 AliGRPPreprocessor.cxx:832
 AliGRPPreprocessor.cxx:833
 AliGRPPreprocessor.cxx:834
 AliGRPPreprocessor.cxx:835
 AliGRPPreprocessor.cxx:836
 AliGRPPreprocessor.cxx:837
 AliGRPPreprocessor.cxx:838
 AliGRPPreprocessor.cxx:839
 AliGRPPreprocessor.cxx:840
 AliGRPPreprocessor.cxx:841
 AliGRPPreprocessor.cxx:842
 AliGRPPreprocessor.cxx:843
 AliGRPPreprocessor.cxx:844
 AliGRPPreprocessor.cxx:845
 AliGRPPreprocessor.cxx:846
 AliGRPPreprocessor.cxx:847
 AliGRPPreprocessor.cxx:848
 AliGRPPreprocessor.cxx:849
 AliGRPPreprocessor.cxx:850
 AliGRPPreprocessor.cxx:851
 AliGRPPreprocessor.cxx:852
 AliGRPPreprocessor.cxx:853
 AliGRPPreprocessor.cxx:854
 AliGRPPreprocessor.cxx:855
 AliGRPPreprocessor.cxx:856
 AliGRPPreprocessor.cxx:857
 AliGRPPreprocessor.cxx:858
 AliGRPPreprocessor.cxx:859
 AliGRPPreprocessor.cxx:860
 AliGRPPreprocessor.cxx:861
 AliGRPPreprocessor.cxx:862
 AliGRPPreprocessor.cxx:863
 AliGRPPreprocessor.cxx:864
 AliGRPPreprocessor.cxx:865
 AliGRPPreprocessor.cxx:866
 AliGRPPreprocessor.cxx:867
 AliGRPPreprocessor.cxx:868
 AliGRPPreprocessor.cxx:869
 AliGRPPreprocessor.cxx:870
 AliGRPPreprocessor.cxx:871
 AliGRPPreprocessor.cxx:872
 AliGRPPreprocessor.cxx:873
 AliGRPPreprocessor.cxx:874
 AliGRPPreprocessor.cxx:875
 AliGRPPreprocessor.cxx:876
 AliGRPPreprocessor.cxx:877
 AliGRPPreprocessor.cxx:878
 AliGRPPreprocessor.cxx:879
 AliGRPPreprocessor.cxx:880
 AliGRPPreprocessor.cxx:881
 AliGRPPreprocessor.cxx:882
 AliGRPPreprocessor.cxx:883
 AliGRPPreprocessor.cxx:884
 AliGRPPreprocessor.cxx:885
 AliGRPPreprocessor.cxx:886
 AliGRPPreprocessor.cxx:887
 AliGRPPreprocessor.cxx:888
 AliGRPPreprocessor.cxx:889
 AliGRPPreprocessor.cxx:890
 AliGRPPreprocessor.cxx:891
 AliGRPPreprocessor.cxx:892
 AliGRPPreprocessor.cxx:893
 AliGRPPreprocessor.cxx:894
 AliGRPPreprocessor.cxx:895
 AliGRPPreprocessor.cxx:896
 AliGRPPreprocessor.cxx:897
 AliGRPPreprocessor.cxx:898
 AliGRPPreprocessor.cxx:899
 AliGRPPreprocessor.cxx:900
 AliGRPPreprocessor.cxx:901
 AliGRPPreprocessor.cxx:902
 AliGRPPreprocessor.cxx:903
 AliGRPPreprocessor.cxx:904
 AliGRPPreprocessor.cxx:905
 AliGRPPreprocessor.cxx:906
 AliGRPPreprocessor.cxx:907
 AliGRPPreprocessor.cxx:908
 AliGRPPreprocessor.cxx:909
 AliGRPPreprocessor.cxx:910
 AliGRPPreprocessor.cxx:911
 AliGRPPreprocessor.cxx:912
 AliGRPPreprocessor.cxx:913
 AliGRPPreprocessor.cxx:914
 AliGRPPreprocessor.cxx:915
 AliGRPPreprocessor.cxx:916
 AliGRPPreprocessor.cxx:917
 AliGRPPreprocessor.cxx:918
 AliGRPPreprocessor.cxx:919
 AliGRPPreprocessor.cxx:920
 AliGRPPreprocessor.cxx:921
 AliGRPPreprocessor.cxx:922
 AliGRPPreprocessor.cxx:923
 AliGRPPreprocessor.cxx:924
 AliGRPPreprocessor.cxx:925
 AliGRPPreprocessor.cxx:926
 AliGRPPreprocessor.cxx:927
 AliGRPPreprocessor.cxx:928
 AliGRPPreprocessor.cxx:929
 AliGRPPreprocessor.cxx:930
 AliGRPPreprocessor.cxx:931
 AliGRPPreprocessor.cxx:932
 AliGRPPreprocessor.cxx:933
 AliGRPPreprocessor.cxx:934
 AliGRPPreprocessor.cxx:935
 AliGRPPreprocessor.cxx:936
 AliGRPPreprocessor.cxx:937
 AliGRPPreprocessor.cxx:938
 AliGRPPreprocessor.cxx:939
 AliGRPPreprocessor.cxx:940
 AliGRPPreprocessor.cxx:941
 AliGRPPreprocessor.cxx:942
 AliGRPPreprocessor.cxx:943
 AliGRPPreprocessor.cxx:944
 AliGRPPreprocessor.cxx:945
 AliGRPPreprocessor.cxx:946
 AliGRPPreprocessor.cxx:947
 AliGRPPreprocessor.cxx:948
 AliGRPPreprocessor.cxx:949
 AliGRPPreprocessor.cxx:950
 AliGRPPreprocessor.cxx:951
 AliGRPPreprocessor.cxx:952
 AliGRPPreprocessor.cxx:953
 AliGRPPreprocessor.cxx:954
 AliGRPPreprocessor.cxx:955
 AliGRPPreprocessor.cxx:956
 AliGRPPreprocessor.cxx:957
 AliGRPPreprocessor.cxx:958
 AliGRPPreprocessor.cxx:959
 AliGRPPreprocessor.cxx:960
 AliGRPPreprocessor.cxx:961
 AliGRPPreprocessor.cxx:962
 AliGRPPreprocessor.cxx:963
 AliGRPPreprocessor.cxx:964
 AliGRPPreprocessor.cxx:965
 AliGRPPreprocessor.cxx:966
 AliGRPPreprocessor.cxx:967
 AliGRPPreprocessor.cxx:968
 AliGRPPreprocessor.cxx:969
 AliGRPPreprocessor.cxx:970
 AliGRPPreprocessor.cxx:971
 AliGRPPreprocessor.cxx:972
 AliGRPPreprocessor.cxx:973
 AliGRPPreprocessor.cxx:974
 AliGRPPreprocessor.cxx:975
 AliGRPPreprocessor.cxx:976
 AliGRPPreprocessor.cxx:977
 AliGRPPreprocessor.cxx:978
 AliGRPPreprocessor.cxx:979
 AliGRPPreprocessor.cxx:980
 AliGRPPreprocessor.cxx:981
 AliGRPPreprocessor.cxx:982
 AliGRPPreprocessor.cxx:983
 AliGRPPreprocessor.cxx:984
 AliGRPPreprocessor.cxx:985
 AliGRPPreprocessor.cxx:986
 AliGRPPreprocessor.cxx:987
 AliGRPPreprocessor.cxx:988
 AliGRPPreprocessor.cxx:989
 AliGRPPreprocessor.cxx:990
 AliGRPPreprocessor.cxx:991
 AliGRPPreprocessor.cxx:992
 AliGRPPreprocessor.cxx:993
 AliGRPPreprocessor.cxx:994
 AliGRPPreprocessor.cxx:995
 AliGRPPreprocessor.cxx:996
 AliGRPPreprocessor.cxx:997
 AliGRPPreprocessor.cxx:998
 AliGRPPreprocessor.cxx:999
 AliGRPPreprocessor.cxx:1000
 AliGRPPreprocessor.cxx:1001
 AliGRPPreprocessor.cxx:1002
 AliGRPPreprocessor.cxx:1003
 AliGRPPreprocessor.cxx:1004
 AliGRPPreprocessor.cxx:1005
 AliGRPPreprocessor.cxx:1006
 AliGRPPreprocessor.cxx:1007
 AliGRPPreprocessor.cxx:1008
 AliGRPPreprocessor.cxx:1009
 AliGRPPreprocessor.cxx:1010
 AliGRPPreprocessor.cxx:1011
 AliGRPPreprocessor.cxx:1012
 AliGRPPreprocessor.cxx:1013
 AliGRPPreprocessor.cxx:1014
 AliGRPPreprocessor.cxx:1015
 AliGRPPreprocessor.cxx:1016
 AliGRPPreprocessor.cxx:1017
 AliGRPPreprocessor.cxx:1018
 AliGRPPreprocessor.cxx:1019
 AliGRPPreprocessor.cxx:1020
 AliGRPPreprocessor.cxx:1021
 AliGRPPreprocessor.cxx:1022
 AliGRPPreprocessor.cxx:1023
 AliGRPPreprocessor.cxx:1024
 AliGRPPreprocessor.cxx:1025
 AliGRPPreprocessor.cxx:1026
 AliGRPPreprocessor.cxx:1027
 AliGRPPreprocessor.cxx:1028
 AliGRPPreprocessor.cxx:1029
 AliGRPPreprocessor.cxx:1030
 AliGRPPreprocessor.cxx:1031
 AliGRPPreprocessor.cxx:1032
 AliGRPPreprocessor.cxx:1033
 AliGRPPreprocessor.cxx:1034
 AliGRPPreprocessor.cxx:1035
 AliGRPPreprocessor.cxx:1036
 AliGRPPreprocessor.cxx:1037
 AliGRPPreprocessor.cxx:1038
 AliGRPPreprocessor.cxx:1039
 AliGRPPreprocessor.cxx:1040
 AliGRPPreprocessor.cxx:1041
 AliGRPPreprocessor.cxx:1042
 AliGRPPreprocessor.cxx:1043
 AliGRPPreprocessor.cxx:1044
 AliGRPPreprocessor.cxx:1045
 AliGRPPreprocessor.cxx:1046
 AliGRPPreprocessor.cxx:1047
 AliGRPPreprocessor.cxx:1048
 AliGRPPreprocessor.cxx:1049
 AliGRPPreprocessor.cxx:1050
 AliGRPPreprocessor.cxx:1051
 AliGRPPreprocessor.cxx:1052
 AliGRPPreprocessor.cxx:1053
 AliGRPPreprocessor.cxx:1054
 AliGRPPreprocessor.cxx:1055
 AliGRPPreprocessor.cxx:1056
 AliGRPPreprocessor.cxx:1057
 AliGRPPreprocessor.cxx:1058
 AliGRPPreprocessor.cxx:1059
 AliGRPPreprocessor.cxx:1060
 AliGRPPreprocessor.cxx:1061
 AliGRPPreprocessor.cxx:1062
 AliGRPPreprocessor.cxx:1063
 AliGRPPreprocessor.cxx:1064
 AliGRPPreprocessor.cxx:1065
 AliGRPPreprocessor.cxx:1066
 AliGRPPreprocessor.cxx:1067
 AliGRPPreprocessor.cxx:1068
 AliGRPPreprocessor.cxx:1069
 AliGRPPreprocessor.cxx:1070
 AliGRPPreprocessor.cxx:1071
 AliGRPPreprocessor.cxx:1072
 AliGRPPreprocessor.cxx:1073
 AliGRPPreprocessor.cxx:1074
 AliGRPPreprocessor.cxx:1075
 AliGRPPreprocessor.cxx:1076
 AliGRPPreprocessor.cxx:1077
 AliGRPPreprocessor.cxx:1078
 AliGRPPreprocessor.cxx:1079
 AliGRPPreprocessor.cxx:1080
 AliGRPPreprocessor.cxx:1081
 AliGRPPreprocessor.cxx:1082
 AliGRPPreprocessor.cxx:1083
 AliGRPPreprocessor.cxx:1084
 AliGRPPreprocessor.cxx:1085
 AliGRPPreprocessor.cxx:1086
 AliGRPPreprocessor.cxx:1087
 AliGRPPreprocessor.cxx:1088
 AliGRPPreprocessor.cxx:1089
 AliGRPPreprocessor.cxx:1090
 AliGRPPreprocessor.cxx:1091
 AliGRPPreprocessor.cxx:1092
 AliGRPPreprocessor.cxx:1093
 AliGRPPreprocessor.cxx:1094
 AliGRPPreprocessor.cxx:1095
 AliGRPPreprocessor.cxx:1096
 AliGRPPreprocessor.cxx:1097
 AliGRPPreprocessor.cxx:1098
 AliGRPPreprocessor.cxx:1099
 AliGRPPreprocessor.cxx:1100
 AliGRPPreprocessor.cxx:1101
 AliGRPPreprocessor.cxx:1102
 AliGRPPreprocessor.cxx:1103
 AliGRPPreprocessor.cxx:1104
 AliGRPPreprocessor.cxx:1105
 AliGRPPreprocessor.cxx:1106
 AliGRPPreprocessor.cxx:1107
 AliGRPPreprocessor.cxx:1108
 AliGRPPreprocessor.cxx:1109
 AliGRPPreprocessor.cxx:1110
 AliGRPPreprocessor.cxx:1111
 AliGRPPreprocessor.cxx:1112
 AliGRPPreprocessor.cxx:1113
 AliGRPPreprocessor.cxx:1114
 AliGRPPreprocessor.cxx:1115
 AliGRPPreprocessor.cxx:1116
 AliGRPPreprocessor.cxx:1117
 AliGRPPreprocessor.cxx:1118
 AliGRPPreprocessor.cxx:1119
 AliGRPPreprocessor.cxx:1120
 AliGRPPreprocessor.cxx:1121
 AliGRPPreprocessor.cxx:1122
 AliGRPPreprocessor.cxx:1123
 AliGRPPreprocessor.cxx:1124
 AliGRPPreprocessor.cxx:1125
 AliGRPPreprocessor.cxx:1126
 AliGRPPreprocessor.cxx:1127
 AliGRPPreprocessor.cxx:1128
 AliGRPPreprocessor.cxx:1129
 AliGRPPreprocessor.cxx:1130
 AliGRPPreprocessor.cxx:1131
 AliGRPPreprocessor.cxx:1132
 AliGRPPreprocessor.cxx:1133
 AliGRPPreprocessor.cxx:1134
 AliGRPPreprocessor.cxx:1135
 AliGRPPreprocessor.cxx:1136
 AliGRPPreprocessor.cxx:1137
 AliGRPPreprocessor.cxx:1138
 AliGRPPreprocessor.cxx:1139
 AliGRPPreprocessor.cxx:1140
 AliGRPPreprocessor.cxx:1141
 AliGRPPreprocessor.cxx:1142
 AliGRPPreprocessor.cxx:1143
 AliGRPPreprocessor.cxx:1144
 AliGRPPreprocessor.cxx:1145
 AliGRPPreprocessor.cxx:1146
 AliGRPPreprocessor.cxx:1147
 AliGRPPreprocessor.cxx:1148
 AliGRPPreprocessor.cxx:1149
 AliGRPPreprocessor.cxx:1150
 AliGRPPreprocessor.cxx:1151
 AliGRPPreprocessor.cxx:1152
 AliGRPPreprocessor.cxx:1153
 AliGRPPreprocessor.cxx:1154
 AliGRPPreprocessor.cxx:1155
 AliGRPPreprocessor.cxx:1156
 AliGRPPreprocessor.cxx:1157
 AliGRPPreprocessor.cxx:1158
 AliGRPPreprocessor.cxx:1159
 AliGRPPreprocessor.cxx:1160
 AliGRPPreprocessor.cxx:1161
 AliGRPPreprocessor.cxx:1162
 AliGRPPreprocessor.cxx:1163
 AliGRPPreprocessor.cxx:1164
 AliGRPPreprocessor.cxx:1165
 AliGRPPreprocessor.cxx:1166
 AliGRPPreprocessor.cxx:1167
 AliGRPPreprocessor.cxx:1168
 AliGRPPreprocessor.cxx:1169
 AliGRPPreprocessor.cxx:1170
 AliGRPPreprocessor.cxx:1171
 AliGRPPreprocessor.cxx:1172
 AliGRPPreprocessor.cxx:1173
 AliGRPPreprocessor.cxx:1174
 AliGRPPreprocessor.cxx:1175
 AliGRPPreprocessor.cxx:1176
 AliGRPPreprocessor.cxx:1177
 AliGRPPreprocessor.cxx:1178
 AliGRPPreprocessor.cxx:1179
 AliGRPPreprocessor.cxx:1180
 AliGRPPreprocessor.cxx:1181
 AliGRPPreprocessor.cxx:1182
 AliGRPPreprocessor.cxx:1183
 AliGRPPreprocessor.cxx:1184
 AliGRPPreprocessor.cxx:1185
 AliGRPPreprocessor.cxx:1186
 AliGRPPreprocessor.cxx:1187
 AliGRPPreprocessor.cxx:1188
 AliGRPPreprocessor.cxx:1189
 AliGRPPreprocessor.cxx:1190
 AliGRPPreprocessor.cxx:1191
 AliGRPPreprocessor.cxx:1192
 AliGRPPreprocessor.cxx:1193
 AliGRPPreprocessor.cxx:1194
 AliGRPPreprocessor.cxx:1195
 AliGRPPreprocessor.cxx:1196
 AliGRPPreprocessor.cxx:1197
 AliGRPPreprocessor.cxx:1198
 AliGRPPreprocessor.cxx:1199
 AliGRPPreprocessor.cxx:1200
 AliGRPPreprocessor.cxx:1201
 AliGRPPreprocessor.cxx:1202
 AliGRPPreprocessor.cxx:1203
 AliGRPPreprocessor.cxx:1204
 AliGRPPreprocessor.cxx:1205
 AliGRPPreprocessor.cxx:1206
 AliGRPPreprocessor.cxx:1207
 AliGRPPreprocessor.cxx:1208
 AliGRPPreprocessor.cxx:1209
 AliGRPPreprocessor.cxx:1210
 AliGRPPreprocessor.cxx:1211
 AliGRPPreprocessor.cxx:1212
 AliGRPPreprocessor.cxx:1213
 AliGRPPreprocessor.cxx:1214
 AliGRPPreprocessor.cxx:1215
 AliGRPPreprocessor.cxx:1216
 AliGRPPreprocessor.cxx:1217
 AliGRPPreprocessor.cxx:1218
 AliGRPPreprocessor.cxx:1219
 AliGRPPreprocessor.cxx:1220
 AliGRPPreprocessor.cxx:1221
 AliGRPPreprocessor.cxx:1222
 AliGRPPreprocessor.cxx:1223
 AliGRPPreprocessor.cxx:1224
 AliGRPPreprocessor.cxx:1225
 AliGRPPreprocessor.cxx:1226
 AliGRPPreprocessor.cxx:1227
 AliGRPPreprocessor.cxx:1228
 AliGRPPreprocessor.cxx:1229
 AliGRPPreprocessor.cxx:1230
 AliGRPPreprocessor.cxx:1231
 AliGRPPreprocessor.cxx:1232
 AliGRPPreprocessor.cxx:1233
 AliGRPPreprocessor.cxx:1234
 AliGRPPreprocessor.cxx:1235
 AliGRPPreprocessor.cxx:1236
 AliGRPPreprocessor.cxx:1237
 AliGRPPreprocessor.cxx:1238
 AliGRPPreprocessor.cxx:1239
 AliGRPPreprocessor.cxx:1240
 AliGRPPreprocessor.cxx:1241
 AliGRPPreprocessor.cxx:1242
 AliGRPPreprocessor.cxx:1243
 AliGRPPreprocessor.cxx:1244
 AliGRPPreprocessor.cxx:1245
 AliGRPPreprocessor.cxx:1246
 AliGRPPreprocessor.cxx:1247
 AliGRPPreprocessor.cxx:1248
 AliGRPPreprocessor.cxx:1249
 AliGRPPreprocessor.cxx:1250
 AliGRPPreprocessor.cxx:1251
 AliGRPPreprocessor.cxx:1252
 AliGRPPreprocessor.cxx:1253
 AliGRPPreprocessor.cxx:1254
 AliGRPPreprocessor.cxx:1255
 AliGRPPreprocessor.cxx:1256
 AliGRPPreprocessor.cxx:1257
 AliGRPPreprocessor.cxx:1258
 AliGRPPreprocessor.cxx:1259
 AliGRPPreprocessor.cxx:1260
 AliGRPPreprocessor.cxx:1261
 AliGRPPreprocessor.cxx:1262
 AliGRPPreprocessor.cxx:1263
 AliGRPPreprocessor.cxx:1264
 AliGRPPreprocessor.cxx:1265
 AliGRPPreprocessor.cxx:1266
 AliGRPPreprocessor.cxx:1267
 AliGRPPreprocessor.cxx:1268
 AliGRPPreprocessor.cxx:1269
 AliGRPPreprocessor.cxx:1270
 AliGRPPreprocessor.cxx:1271
 AliGRPPreprocessor.cxx:1272
 AliGRPPreprocessor.cxx:1273
 AliGRPPreprocessor.cxx:1274
 AliGRPPreprocessor.cxx:1275
 AliGRPPreprocessor.cxx:1276
 AliGRPPreprocessor.cxx:1277
 AliGRPPreprocessor.cxx:1278
 AliGRPPreprocessor.cxx:1279
 AliGRPPreprocessor.cxx:1280
 AliGRPPreprocessor.cxx:1281
 AliGRPPreprocessor.cxx:1282
 AliGRPPreprocessor.cxx:1283
 AliGRPPreprocessor.cxx:1284
 AliGRPPreprocessor.cxx:1285
 AliGRPPreprocessor.cxx:1286
 AliGRPPreprocessor.cxx:1287
 AliGRPPreprocessor.cxx:1288
 AliGRPPreprocessor.cxx:1289
 AliGRPPreprocessor.cxx:1290
 AliGRPPreprocessor.cxx:1291
 AliGRPPreprocessor.cxx:1292
 AliGRPPreprocessor.cxx:1293
 AliGRPPreprocessor.cxx:1294
 AliGRPPreprocessor.cxx:1295
 AliGRPPreprocessor.cxx:1296
 AliGRPPreprocessor.cxx:1297
 AliGRPPreprocessor.cxx:1298
 AliGRPPreprocessor.cxx:1299
 AliGRPPreprocessor.cxx:1300
 AliGRPPreprocessor.cxx:1301
 AliGRPPreprocessor.cxx:1302
 AliGRPPreprocessor.cxx:1303
 AliGRPPreprocessor.cxx:1304
 AliGRPPreprocessor.cxx:1305
 AliGRPPreprocessor.cxx:1306
 AliGRPPreprocessor.cxx:1307
 AliGRPPreprocessor.cxx:1308
 AliGRPPreprocessor.cxx:1309
 AliGRPPreprocessor.cxx:1310
 AliGRPPreprocessor.cxx:1311
 AliGRPPreprocessor.cxx:1312
 AliGRPPreprocessor.cxx:1313
 AliGRPPreprocessor.cxx:1314
 AliGRPPreprocessor.cxx:1315
 AliGRPPreprocessor.cxx:1316
 AliGRPPreprocessor.cxx:1317
 AliGRPPreprocessor.cxx:1318
 AliGRPPreprocessor.cxx:1319
 AliGRPPreprocessor.cxx:1320
 AliGRPPreprocessor.cxx:1321
 AliGRPPreprocessor.cxx:1322
 AliGRPPreprocessor.cxx:1323
 AliGRPPreprocessor.cxx:1324
 AliGRPPreprocessor.cxx:1325
 AliGRPPreprocessor.cxx:1326
 AliGRPPreprocessor.cxx:1327
 AliGRPPreprocessor.cxx:1328
 AliGRPPreprocessor.cxx:1329
 AliGRPPreprocessor.cxx:1330
 AliGRPPreprocessor.cxx:1331
 AliGRPPreprocessor.cxx:1332
 AliGRPPreprocessor.cxx:1333
 AliGRPPreprocessor.cxx:1334
 AliGRPPreprocessor.cxx:1335
 AliGRPPreprocessor.cxx:1336
 AliGRPPreprocessor.cxx:1337
 AliGRPPreprocessor.cxx:1338
 AliGRPPreprocessor.cxx:1339
 AliGRPPreprocessor.cxx:1340
 AliGRPPreprocessor.cxx:1341
 AliGRPPreprocessor.cxx:1342
 AliGRPPreprocessor.cxx:1343
 AliGRPPreprocessor.cxx:1344
 AliGRPPreprocessor.cxx:1345
 AliGRPPreprocessor.cxx:1346
 AliGRPPreprocessor.cxx:1347
 AliGRPPreprocessor.cxx:1348
 AliGRPPreprocessor.cxx:1349
 AliGRPPreprocessor.cxx:1350
 AliGRPPreprocessor.cxx:1351
 AliGRPPreprocessor.cxx:1352
 AliGRPPreprocessor.cxx:1353
 AliGRPPreprocessor.cxx:1354
 AliGRPPreprocessor.cxx:1355
 AliGRPPreprocessor.cxx:1356
 AliGRPPreprocessor.cxx:1357
 AliGRPPreprocessor.cxx:1358
 AliGRPPreprocessor.cxx:1359
 AliGRPPreprocessor.cxx:1360
 AliGRPPreprocessor.cxx:1361
 AliGRPPreprocessor.cxx:1362
 AliGRPPreprocessor.cxx:1363
 AliGRPPreprocessor.cxx:1364
 AliGRPPreprocessor.cxx:1365
 AliGRPPreprocessor.cxx:1366
 AliGRPPreprocessor.cxx:1367
 AliGRPPreprocessor.cxx:1368
 AliGRPPreprocessor.cxx:1369
 AliGRPPreprocessor.cxx:1370
 AliGRPPreprocessor.cxx:1371
 AliGRPPreprocessor.cxx:1372
 AliGRPPreprocessor.cxx:1373
 AliGRPPreprocessor.cxx:1374
 AliGRPPreprocessor.cxx:1375
 AliGRPPreprocessor.cxx:1376
 AliGRPPreprocessor.cxx:1377
 AliGRPPreprocessor.cxx:1378
 AliGRPPreprocessor.cxx:1379
 AliGRPPreprocessor.cxx:1380
 AliGRPPreprocessor.cxx:1381
 AliGRPPreprocessor.cxx:1382
 AliGRPPreprocessor.cxx:1383
 AliGRPPreprocessor.cxx:1384
 AliGRPPreprocessor.cxx:1385
 AliGRPPreprocessor.cxx:1386
 AliGRPPreprocessor.cxx:1387
 AliGRPPreprocessor.cxx:1388
 AliGRPPreprocessor.cxx:1389
 AliGRPPreprocessor.cxx:1390
 AliGRPPreprocessor.cxx:1391
 AliGRPPreprocessor.cxx:1392
 AliGRPPreprocessor.cxx:1393
 AliGRPPreprocessor.cxx:1394
 AliGRPPreprocessor.cxx:1395
 AliGRPPreprocessor.cxx:1396
 AliGRPPreprocessor.cxx:1397
 AliGRPPreprocessor.cxx:1398
 AliGRPPreprocessor.cxx:1399
 AliGRPPreprocessor.cxx:1400
 AliGRPPreprocessor.cxx:1401
 AliGRPPreprocessor.cxx:1402
 AliGRPPreprocessor.cxx:1403
 AliGRPPreprocessor.cxx:1404
 AliGRPPreprocessor.cxx:1405
 AliGRPPreprocessor.cxx:1406
 AliGRPPreprocessor.cxx:1407
 AliGRPPreprocessor.cxx:1408
 AliGRPPreprocessor.cxx:1409
 AliGRPPreprocessor.cxx:1410
 AliGRPPreprocessor.cxx:1411
 AliGRPPreprocessor.cxx:1412
 AliGRPPreprocessor.cxx:1413
 AliGRPPreprocessor.cxx:1414
 AliGRPPreprocessor.cxx:1415
 AliGRPPreprocessor.cxx:1416
 AliGRPPreprocessor.cxx:1417
 AliGRPPreprocessor.cxx:1418
 AliGRPPreprocessor.cxx:1419
 AliGRPPreprocessor.cxx:1420
 AliGRPPreprocessor.cxx:1421
 AliGRPPreprocessor.cxx:1422
 AliGRPPreprocessor.cxx:1423
 AliGRPPreprocessor.cxx:1424
 AliGRPPreprocessor.cxx:1425
 AliGRPPreprocessor.cxx:1426
 AliGRPPreprocessor.cxx:1427
 AliGRPPreprocessor.cxx:1428
 AliGRPPreprocessor.cxx:1429
 AliGRPPreprocessor.cxx:1430
 AliGRPPreprocessor.cxx:1431
 AliGRPPreprocessor.cxx:1432
 AliGRPPreprocessor.cxx:1433
 AliGRPPreprocessor.cxx:1434
 AliGRPPreprocessor.cxx:1435
 AliGRPPreprocessor.cxx:1436
 AliGRPPreprocessor.cxx:1437
 AliGRPPreprocessor.cxx:1438
 AliGRPPreprocessor.cxx:1439
 AliGRPPreprocessor.cxx:1440
 AliGRPPreprocessor.cxx:1441
 AliGRPPreprocessor.cxx:1442
 AliGRPPreprocessor.cxx:1443
 AliGRPPreprocessor.cxx:1444
 AliGRPPreprocessor.cxx:1445
 AliGRPPreprocessor.cxx:1446
 AliGRPPreprocessor.cxx:1447
 AliGRPPreprocessor.cxx:1448
 AliGRPPreprocessor.cxx:1449
 AliGRPPreprocessor.cxx:1450
 AliGRPPreprocessor.cxx:1451
 AliGRPPreprocessor.cxx:1452
 AliGRPPreprocessor.cxx:1453
 AliGRPPreprocessor.cxx:1454
 AliGRPPreprocessor.cxx:1455
 AliGRPPreprocessor.cxx:1456
 AliGRPPreprocessor.cxx:1457
 AliGRPPreprocessor.cxx:1458
 AliGRPPreprocessor.cxx:1459
 AliGRPPreprocessor.cxx:1460
 AliGRPPreprocessor.cxx:1461
 AliGRPPreprocessor.cxx:1462
 AliGRPPreprocessor.cxx:1463
 AliGRPPreprocessor.cxx:1464
 AliGRPPreprocessor.cxx:1465
 AliGRPPreprocessor.cxx:1466
 AliGRPPreprocessor.cxx:1467
 AliGRPPreprocessor.cxx:1468
 AliGRPPreprocessor.cxx:1469
 AliGRPPreprocessor.cxx:1470
 AliGRPPreprocessor.cxx:1471
 AliGRPPreprocessor.cxx:1472
 AliGRPPreprocessor.cxx:1473
 AliGRPPreprocessor.cxx:1474
 AliGRPPreprocessor.cxx:1475
 AliGRPPreprocessor.cxx:1476
 AliGRPPreprocessor.cxx:1477
 AliGRPPreprocessor.cxx:1478
 AliGRPPreprocessor.cxx:1479
 AliGRPPreprocessor.cxx:1480
 AliGRPPreprocessor.cxx:1481
 AliGRPPreprocessor.cxx:1482
 AliGRPPreprocessor.cxx:1483
 AliGRPPreprocessor.cxx:1484
 AliGRPPreprocessor.cxx:1485
 AliGRPPreprocessor.cxx:1486
 AliGRPPreprocessor.cxx:1487
 AliGRPPreprocessor.cxx:1488
 AliGRPPreprocessor.cxx:1489
 AliGRPPreprocessor.cxx:1490
 AliGRPPreprocessor.cxx:1491
 AliGRPPreprocessor.cxx:1492
 AliGRPPreprocessor.cxx:1493
 AliGRPPreprocessor.cxx:1494
 AliGRPPreprocessor.cxx:1495
 AliGRPPreprocessor.cxx:1496
 AliGRPPreprocessor.cxx:1497
 AliGRPPreprocessor.cxx:1498
 AliGRPPreprocessor.cxx:1499
 AliGRPPreprocessor.cxx:1500
 AliGRPPreprocessor.cxx:1501
 AliGRPPreprocessor.cxx:1502
 AliGRPPreprocessor.cxx:1503
 AliGRPPreprocessor.cxx:1504
 AliGRPPreprocessor.cxx:1505
 AliGRPPreprocessor.cxx:1506
 AliGRPPreprocessor.cxx:1507
 AliGRPPreprocessor.cxx:1508
 AliGRPPreprocessor.cxx:1509
 AliGRPPreprocessor.cxx:1510
 AliGRPPreprocessor.cxx:1511
 AliGRPPreprocessor.cxx:1512
 AliGRPPreprocessor.cxx:1513
 AliGRPPreprocessor.cxx:1514
 AliGRPPreprocessor.cxx:1515
 AliGRPPreprocessor.cxx:1516
 AliGRPPreprocessor.cxx:1517
 AliGRPPreprocessor.cxx:1518
 AliGRPPreprocessor.cxx:1519
 AliGRPPreprocessor.cxx:1520
 AliGRPPreprocessor.cxx:1521
 AliGRPPreprocessor.cxx:1522
 AliGRPPreprocessor.cxx:1523
 AliGRPPreprocessor.cxx:1524
 AliGRPPreprocessor.cxx:1525
 AliGRPPreprocessor.cxx:1526
 AliGRPPreprocessor.cxx:1527
 AliGRPPreprocessor.cxx:1528
 AliGRPPreprocessor.cxx:1529
 AliGRPPreprocessor.cxx:1530
 AliGRPPreprocessor.cxx:1531
 AliGRPPreprocessor.cxx:1532
 AliGRPPreprocessor.cxx:1533
 AliGRPPreprocessor.cxx:1534
 AliGRPPreprocessor.cxx:1535
 AliGRPPreprocessor.cxx:1536
 AliGRPPreprocessor.cxx:1537
 AliGRPPreprocessor.cxx:1538
 AliGRPPreprocessor.cxx:1539
 AliGRPPreprocessor.cxx:1540
 AliGRPPreprocessor.cxx:1541
 AliGRPPreprocessor.cxx:1542
 AliGRPPreprocessor.cxx:1543
 AliGRPPreprocessor.cxx:1544
 AliGRPPreprocessor.cxx:1545
 AliGRPPreprocessor.cxx:1546
 AliGRPPreprocessor.cxx:1547
 AliGRPPreprocessor.cxx:1548
 AliGRPPreprocessor.cxx:1549
 AliGRPPreprocessor.cxx:1550
 AliGRPPreprocessor.cxx:1551
 AliGRPPreprocessor.cxx:1552
 AliGRPPreprocessor.cxx:1553
 AliGRPPreprocessor.cxx:1554
 AliGRPPreprocessor.cxx:1555
 AliGRPPreprocessor.cxx:1556
 AliGRPPreprocessor.cxx:1557
 AliGRPPreprocessor.cxx:1558
 AliGRPPreprocessor.cxx:1559
 AliGRPPreprocessor.cxx:1560
 AliGRPPreprocessor.cxx:1561
 AliGRPPreprocessor.cxx:1562
 AliGRPPreprocessor.cxx:1563
 AliGRPPreprocessor.cxx:1564
 AliGRPPreprocessor.cxx:1565
 AliGRPPreprocessor.cxx:1566
 AliGRPPreprocessor.cxx:1567
 AliGRPPreprocessor.cxx:1568
 AliGRPPreprocessor.cxx:1569
 AliGRPPreprocessor.cxx:1570
 AliGRPPreprocessor.cxx:1571
 AliGRPPreprocessor.cxx:1572
 AliGRPPreprocessor.cxx:1573
 AliGRPPreprocessor.cxx:1574
 AliGRPPreprocessor.cxx:1575
 AliGRPPreprocessor.cxx:1576
 AliGRPPreprocessor.cxx:1577
 AliGRPPreprocessor.cxx:1578
 AliGRPPreprocessor.cxx:1579
 AliGRPPreprocessor.cxx:1580
 AliGRPPreprocessor.cxx:1581
 AliGRPPreprocessor.cxx:1582
 AliGRPPreprocessor.cxx:1583
 AliGRPPreprocessor.cxx:1584
 AliGRPPreprocessor.cxx:1585
 AliGRPPreprocessor.cxx:1586
 AliGRPPreprocessor.cxx:1587
 AliGRPPreprocessor.cxx:1588
 AliGRPPreprocessor.cxx:1589
 AliGRPPreprocessor.cxx:1590
 AliGRPPreprocessor.cxx:1591
 AliGRPPreprocessor.cxx:1592
 AliGRPPreprocessor.cxx:1593
 AliGRPPreprocessor.cxx:1594
 AliGRPPreprocessor.cxx:1595
 AliGRPPreprocessor.cxx:1596
 AliGRPPreprocessor.cxx:1597
 AliGRPPreprocessor.cxx:1598
 AliGRPPreprocessor.cxx:1599
 AliGRPPreprocessor.cxx:1600
 AliGRPPreprocessor.cxx:1601
 AliGRPPreprocessor.cxx:1602
 AliGRPPreprocessor.cxx:1603
 AliGRPPreprocessor.cxx:1604
 AliGRPPreprocessor.cxx:1605
 AliGRPPreprocessor.cxx:1606
 AliGRPPreprocessor.cxx:1607
 AliGRPPreprocessor.cxx:1608
 AliGRPPreprocessor.cxx:1609
 AliGRPPreprocessor.cxx:1610
 AliGRPPreprocessor.cxx:1611
 AliGRPPreprocessor.cxx:1612
 AliGRPPreprocessor.cxx:1613
 AliGRPPreprocessor.cxx:1614
 AliGRPPreprocessor.cxx:1615
 AliGRPPreprocessor.cxx:1616
 AliGRPPreprocessor.cxx:1617
 AliGRPPreprocessor.cxx:1618
 AliGRPPreprocessor.cxx:1619
 AliGRPPreprocessor.cxx:1620
 AliGRPPreprocessor.cxx:1621
 AliGRPPreprocessor.cxx:1622
 AliGRPPreprocessor.cxx:1623
 AliGRPPreprocessor.cxx:1624
 AliGRPPreprocessor.cxx:1625
 AliGRPPreprocessor.cxx:1626
 AliGRPPreprocessor.cxx:1627
 AliGRPPreprocessor.cxx:1628
 AliGRPPreprocessor.cxx:1629
 AliGRPPreprocessor.cxx:1630
 AliGRPPreprocessor.cxx:1631
 AliGRPPreprocessor.cxx:1632
 AliGRPPreprocessor.cxx:1633
 AliGRPPreprocessor.cxx:1634
 AliGRPPreprocessor.cxx:1635
 AliGRPPreprocessor.cxx:1636
 AliGRPPreprocessor.cxx:1637
 AliGRPPreprocessor.cxx:1638
 AliGRPPreprocessor.cxx:1639
 AliGRPPreprocessor.cxx:1640
 AliGRPPreprocessor.cxx:1641
 AliGRPPreprocessor.cxx:1642
 AliGRPPreprocessor.cxx:1643
 AliGRPPreprocessor.cxx:1644
 AliGRPPreprocessor.cxx:1645
 AliGRPPreprocessor.cxx:1646
 AliGRPPreprocessor.cxx:1647
 AliGRPPreprocessor.cxx:1648
 AliGRPPreprocessor.cxx:1649
 AliGRPPreprocessor.cxx:1650
 AliGRPPreprocessor.cxx:1651
 AliGRPPreprocessor.cxx:1652
 AliGRPPreprocessor.cxx:1653
 AliGRPPreprocessor.cxx:1654
 AliGRPPreprocessor.cxx:1655
 AliGRPPreprocessor.cxx:1656
 AliGRPPreprocessor.cxx:1657
 AliGRPPreprocessor.cxx:1658
 AliGRPPreprocessor.cxx:1659
 AliGRPPreprocessor.cxx:1660
 AliGRPPreprocessor.cxx:1661
 AliGRPPreprocessor.cxx:1662
 AliGRPPreprocessor.cxx:1663
 AliGRPPreprocessor.cxx:1664
 AliGRPPreprocessor.cxx:1665
 AliGRPPreprocessor.cxx:1666
 AliGRPPreprocessor.cxx:1667
 AliGRPPreprocessor.cxx:1668
 AliGRPPreprocessor.cxx:1669
 AliGRPPreprocessor.cxx:1670
 AliGRPPreprocessor.cxx:1671
 AliGRPPreprocessor.cxx:1672
 AliGRPPreprocessor.cxx:1673
 AliGRPPreprocessor.cxx:1674
 AliGRPPreprocessor.cxx:1675
 AliGRPPreprocessor.cxx:1676
 AliGRPPreprocessor.cxx:1677
 AliGRPPreprocessor.cxx:1678
 AliGRPPreprocessor.cxx:1679
 AliGRPPreprocessor.cxx:1680
 AliGRPPreprocessor.cxx:1681
 AliGRPPreprocessor.cxx:1682
 AliGRPPreprocessor.cxx:1683
 AliGRPPreprocessor.cxx:1684
 AliGRPPreprocessor.cxx:1685
 AliGRPPreprocessor.cxx:1686
 AliGRPPreprocessor.cxx:1687
 AliGRPPreprocessor.cxx:1688
 AliGRPPreprocessor.cxx:1689
 AliGRPPreprocessor.cxx:1690
 AliGRPPreprocessor.cxx:1691
 AliGRPPreprocessor.cxx:1692
 AliGRPPreprocessor.cxx:1693
 AliGRPPreprocessor.cxx:1694
 AliGRPPreprocessor.cxx:1695
 AliGRPPreprocessor.cxx:1696
 AliGRPPreprocessor.cxx:1697
 AliGRPPreprocessor.cxx:1698
 AliGRPPreprocessor.cxx:1699
 AliGRPPreprocessor.cxx:1700
 AliGRPPreprocessor.cxx:1701
 AliGRPPreprocessor.cxx:1702
 AliGRPPreprocessor.cxx:1703
 AliGRPPreprocessor.cxx:1704
 AliGRPPreprocessor.cxx:1705
 AliGRPPreprocessor.cxx:1706
 AliGRPPreprocessor.cxx:1707
 AliGRPPreprocessor.cxx:1708
 AliGRPPreprocessor.cxx:1709
 AliGRPPreprocessor.cxx:1710
 AliGRPPreprocessor.cxx:1711
 AliGRPPreprocessor.cxx:1712
 AliGRPPreprocessor.cxx:1713
 AliGRPPreprocessor.cxx:1714
 AliGRPPreprocessor.cxx:1715
 AliGRPPreprocessor.cxx:1716
 AliGRPPreprocessor.cxx:1717
 AliGRPPreprocessor.cxx:1718
 AliGRPPreprocessor.cxx:1719
 AliGRPPreprocessor.cxx:1720
 AliGRPPreprocessor.cxx:1721
 AliGRPPreprocessor.cxx:1722
 AliGRPPreprocessor.cxx:1723
 AliGRPPreprocessor.cxx:1724
 AliGRPPreprocessor.cxx:1725
 AliGRPPreprocessor.cxx:1726
 AliGRPPreprocessor.cxx:1727
 AliGRPPreprocessor.cxx:1728
 AliGRPPreprocessor.cxx:1729
 AliGRPPreprocessor.cxx:1730
 AliGRPPreprocessor.cxx:1731
 AliGRPPreprocessor.cxx:1732
 AliGRPPreprocessor.cxx:1733
 AliGRPPreprocessor.cxx:1734
 AliGRPPreprocessor.cxx:1735
 AliGRPPreprocessor.cxx:1736
 AliGRPPreprocessor.cxx:1737
 AliGRPPreprocessor.cxx:1738
 AliGRPPreprocessor.cxx:1739
 AliGRPPreprocessor.cxx:1740
 AliGRPPreprocessor.cxx:1741
 AliGRPPreprocessor.cxx:1742
 AliGRPPreprocessor.cxx:1743
 AliGRPPreprocessor.cxx:1744
 AliGRPPreprocessor.cxx:1745
 AliGRPPreprocessor.cxx:1746
 AliGRPPreprocessor.cxx:1747
 AliGRPPreprocessor.cxx:1748
 AliGRPPreprocessor.cxx:1749
 AliGRPPreprocessor.cxx:1750
 AliGRPPreprocessor.cxx:1751
 AliGRPPreprocessor.cxx:1752
 AliGRPPreprocessor.cxx:1753
 AliGRPPreprocessor.cxx:1754
 AliGRPPreprocessor.cxx:1755
 AliGRPPreprocessor.cxx:1756
 AliGRPPreprocessor.cxx:1757
 AliGRPPreprocessor.cxx:1758
 AliGRPPreprocessor.cxx:1759
 AliGRPPreprocessor.cxx:1760
 AliGRPPreprocessor.cxx:1761
 AliGRPPreprocessor.cxx:1762
 AliGRPPreprocessor.cxx:1763
 AliGRPPreprocessor.cxx:1764
 AliGRPPreprocessor.cxx:1765
 AliGRPPreprocessor.cxx:1766
 AliGRPPreprocessor.cxx:1767
 AliGRPPreprocessor.cxx:1768
 AliGRPPreprocessor.cxx:1769
 AliGRPPreprocessor.cxx:1770
 AliGRPPreprocessor.cxx:1771
 AliGRPPreprocessor.cxx:1772
 AliGRPPreprocessor.cxx:1773
 AliGRPPreprocessor.cxx:1774
 AliGRPPreprocessor.cxx:1775
 AliGRPPreprocessor.cxx:1776
 AliGRPPreprocessor.cxx:1777
 AliGRPPreprocessor.cxx:1778
 AliGRPPreprocessor.cxx:1779
 AliGRPPreprocessor.cxx:1780
 AliGRPPreprocessor.cxx:1781
 AliGRPPreprocessor.cxx:1782
 AliGRPPreprocessor.cxx:1783
 AliGRPPreprocessor.cxx:1784
 AliGRPPreprocessor.cxx:1785
 AliGRPPreprocessor.cxx:1786
 AliGRPPreprocessor.cxx:1787
 AliGRPPreprocessor.cxx:1788
 AliGRPPreprocessor.cxx:1789
 AliGRPPreprocessor.cxx:1790
 AliGRPPreprocessor.cxx:1791
 AliGRPPreprocessor.cxx:1792
 AliGRPPreprocessor.cxx:1793
 AliGRPPreprocessor.cxx:1794
 AliGRPPreprocessor.cxx:1795
 AliGRPPreprocessor.cxx:1796
 AliGRPPreprocessor.cxx:1797
 AliGRPPreprocessor.cxx:1798
 AliGRPPreprocessor.cxx:1799
 AliGRPPreprocessor.cxx:1800
 AliGRPPreprocessor.cxx:1801
 AliGRPPreprocessor.cxx:1802
 AliGRPPreprocessor.cxx:1803
 AliGRPPreprocessor.cxx:1804
 AliGRPPreprocessor.cxx:1805
 AliGRPPreprocessor.cxx:1806
 AliGRPPreprocessor.cxx:1807
 AliGRPPreprocessor.cxx:1808
 AliGRPPreprocessor.cxx:1809
 AliGRPPreprocessor.cxx:1810
 AliGRPPreprocessor.cxx:1811
 AliGRPPreprocessor.cxx:1812
 AliGRPPreprocessor.cxx:1813
 AliGRPPreprocessor.cxx:1814
 AliGRPPreprocessor.cxx:1815
 AliGRPPreprocessor.cxx:1816
 AliGRPPreprocessor.cxx:1817
 AliGRPPreprocessor.cxx:1818
 AliGRPPreprocessor.cxx:1819
 AliGRPPreprocessor.cxx:1820
 AliGRPPreprocessor.cxx:1821
 AliGRPPreprocessor.cxx:1822
 AliGRPPreprocessor.cxx:1823
 AliGRPPreprocessor.cxx:1824
 AliGRPPreprocessor.cxx:1825
 AliGRPPreprocessor.cxx:1826
 AliGRPPreprocessor.cxx:1827
 AliGRPPreprocessor.cxx:1828
 AliGRPPreprocessor.cxx:1829
 AliGRPPreprocessor.cxx:1830
 AliGRPPreprocessor.cxx:1831
 AliGRPPreprocessor.cxx:1832
 AliGRPPreprocessor.cxx:1833
 AliGRPPreprocessor.cxx:1834
 AliGRPPreprocessor.cxx:1835
 AliGRPPreprocessor.cxx:1836
 AliGRPPreprocessor.cxx:1837
 AliGRPPreprocessor.cxx:1838
 AliGRPPreprocessor.cxx:1839
 AliGRPPreprocessor.cxx:1840
 AliGRPPreprocessor.cxx:1841
 AliGRPPreprocessor.cxx:1842
 AliGRPPreprocessor.cxx:1843
 AliGRPPreprocessor.cxx:1844
 AliGRPPreprocessor.cxx:1845
 AliGRPPreprocessor.cxx:1846
 AliGRPPreprocessor.cxx:1847
 AliGRPPreprocessor.cxx:1848
 AliGRPPreprocessor.cxx:1849
 AliGRPPreprocessor.cxx:1850
 AliGRPPreprocessor.cxx:1851
 AliGRPPreprocessor.cxx:1852
 AliGRPPreprocessor.cxx:1853
 AliGRPPreprocessor.cxx:1854
 AliGRPPreprocessor.cxx:1855
 AliGRPPreprocessor.cxx:1856
 AliGRPPreprocessor.cxx:1857
 AliGRPPreprocessor.cxx:1858
 AliGRPPreprocessor.cxx:1859
 AliGRPPreprocessor.cxx:1860
 AliGRPPreprocessor.cxx:1861
 AliGRPPreprocessor.cxx:1862
 AliGRPPreprocessor.cxx:1863
 AliGRPPreprocessor.cxx:1864
 AliGRPPreprocessor.cxx:1865
 AliGRPPreprocessor.cxx:1866
 AliGRPPreprocessor.cxx:1867
 AliGRPPreprocessor.cxx:1868
 AliGRPPreprocessor.cxx:1869
 AliGRPPreprocessor.cxx:1870
 AliGRPPreprocessor.cxx:1871
 AliGRPPreprocessor.cxx:1872
 AliGRPPreprocessor.cxx:1873
 AliGRPPreprocessor.cxx:1874
 AliGRPPreprocessor.cxx:1875
 AliGRPPreprocessor.cxx:1876
 AliGRPPreprocessor.cxx:1877
 AliGRPPreprocessor.cxx:1878
 AliGRPPreprocessor.cxx:1879
 AliGRPPreprocessor.cxx:1880
 AliGRPPreprocessor.cxx:1881
 AliGRPPreprocessor.cxx:1882
 AliGRPPreprocessor.cxx:1883
 AliGRPPreprocessor.cxx:1884
 AliGRPPreprocessor.cxx:1885
 AliGRPPreprocessor.cxx:1886
 AliGRPPreprocessor.cxx:1887
 AliGRPPreprocessor.cxx:1888
 AliGRPPreprocessor.cxx:1889
 AliGRPPreprocessor.cxx:1890
 AliGRPPreprocessor.cxx:1891
 AliGRPPreprocessor.cxx:1892
 AliGRPPreprocessor.cxx:1893
 AliGRPPreprocessor.cxx:1894
 AliGRPPreprocessor.cxx:1895
 AliGRPPreprocessor.cxx:1896
 AliGRPPreprocessor.cxx:1897
 AliGRPPreprocessor.cxx:1898
 AliGRPPreprocessor.cxx:1899
 AliGRPPreprocessor.cxx:1900
 AliGRPPreprocessor.cxx:1901
 AliGRPPreprocessor.cxx:1902
 AliGRPPreprocessor.cxx:1903
 AliGRPPreprocessor.cxx:1904
 AliGRPPreprocessor.cxx:1905
 AliGRPPreprocessor.cxx:1906
 AliGRPPreprocessor.cxx:1907
 AliGRPPreprocessor.cxx:1908
 AliGRPPreprocessor.cxx:1909
 AliGRPPreprocessor.cxx:1910
 AliGRPPreprocessor.cxx:1911
 AliGRPPreprocessor.cxx:1912
 AliGRPPreprocessor.cxx:1913
 AliGRPPreprocessor.cxx:1914
 AliGRPPreprocessor.cxx:1915
 AliGRPPreprocessor.cxx:1916
 AliGRPPreprocessor.cxx:1917
 AliGRPPreprocessor.cxx:1918
 AliGRPPreprocessor.cxx:1919
 AliGRPPreprocessor.cxx:1920
 AliGRPPreprocessor.cxx:1921
 AliGRPPreprocessor.cxx:1922
 AliGRPPreprocessor.cxx:1923
 AliGRPPreprocessor.cxx:1924
 AliGRPPreprocessor.cxx:1925
 AliGRPPreprocessor.cxx:1926
 AliGRPPreprocessor.cxx:1927
 AliGRPPreprocessor.cxx:1928
 AliGRPPreprocessor.cxx:1929
 AliGRPPreprocessor.cxx:1930
 AliGRPPreprocessor.cxx:1931
 AliGRPPreprocessor.cxx:1932
 AliGRPPreprocessor.cxx:1933
 AliGRPPreprocessor.cxx:1934
 AliGRPPreprocessor.cxx:1935
 AliGRPPreprocessor.cxx:1936
 AliGRPPreprocessor.cxx:1937
 AliGRPPreprocessor.cxx:1938
 AliGRPPreprocessor.cxx:1939
 AliGRPPreprocessor.cxx:1940
 AliGRPPreprocessor.cxx:1941
 AliGRPPreprocessor.cxx:1942
 AliGRPPreprocessor.cxx:1943
 AliGRPPreprocessor.cxx:1944
 AliGRPPreprocessor.cxx:1945
 AliGRPPreprocessor.cxx:1946
 AliGRPPreprocessor.cxx:1947
 AliGRPPreprocessor.cxx:1948
 AliGRPPreprocessor.cxx:1949
 AliGRPPreprocessor.cxx:1950
 AliGRPPreprocessor.cxx:1951
 AliGRPPreprocessor.cxx:1952
 AliGRPPreprocessor.cxx:1953
 AliGRPPreprocessor.cxx:1954
 AliGRPPreprocessor.cxx:1955
 AliGRPPreprocessor.cxx:1956
 AliGRPPreprocessor.cxx:1957
 AliGRPPreprocessor.cxx:1958
 AliGRPPreprocessor.cxx:1959
 AliGRPPreprocessor.cxx:1960
 AliGRPPreprocessor.cxx:1961
 AliGRPPreprocessor.cxx:1962
 AliGRPPreprocessor.cxx:1963
 AliGRPPreprocessor.cxx:1964
 AliGRPPreprocessor.cxx:1965
 AliGRPPreprocessor.cxx:1966
 AliGRPPreprocessor.cxx:1967
 AliGRPPreprocessor.cxx:1968
 AliGRPPreprocessor.cxx:1969
 AliGRPPreprocessor.cxx:1970
 AliGRPPreprocessor.cxx:1971
 AliGRPPreprocessor.cxx:1972
 AliGRPPreprocessor.cxx:1973
 AliGRPPreprocessor.cxx:1974
 AliGRPPreprocessor.cxx:1975
 AliGRPPreprocessor.cxx:1976
 AliGRPPreprocessor.cxx:1977
 AliGRPPreprocessor.cxx:1978
 AliGRPPreprocessor.cxx:1979
 AliGRPPreprocessor.cxx:1980
 AliGRPPreprocessor.cxx:1981
 AliGRPPreprocessor.cxx:1982
 AliGRPPreprocessor.cxx:1983
 AliGRPPreprocessor.cxx:1984
 AliGRPPreprocessor.cxx:1985
 AliGRPPreprocessor.cxx:1986
 AliGRPPreprocessor.cxx:1987
 AliGRPPreprocessor.cxx:1988
 AliGRPPreprocessor.cxx:1989
 AliGRPPreprocessor.cxx:1990
 AliGRPPreprocessor.cxx:1991
 AliGRPPreprocessor.cxx:1992
 AliGRPPreprocessor.cxx:1993
 AliGRPPreprocessor.cxx:1994
 AliGRPPreprocessor.cxx:1995
 AliGRPPreprocessor.cxx:1996
 AliGRPPreprocessor.cxx:1997
 AliGRPPreprocessor.cxx:1998
 AliGRPPreprocessor.cxx:1999
 AliGRPPreprocessor.cxx:2000
 AliGRPPreprocessor.cxx:2001
 AliGRPPreprocessor.cxx:2002
 AliGRPPreprocessor.cxx:2003
 AliGRPPreprocessor.cxx:2004
 AliGRPPreprocessor.cxx:2005
 AliGRPPreprocessor.cxx:2006
 AliGRPPreprocessor.cxx:2007
 AliGRPPreprocessor.cxx:2008
 AliGRPPreprocessor.cxx:2009
 AliGRPPreprocessor.cxx:2010
 AliGRPPreprocessor.cxx:2011
 AliGRPPreprocessor.cxx:2012
 AliGRPPreprocessor.cxx:2013
 AliGRPPreprocessor.cxx:2014
 AliGRPPreprocessor.cxx:2015
 AliGRPPreprocessor.cxx:2016
 AliGRPPreprocessor.cxx:2017
 AliGRPPreprocessor.cxx:2018
 AliGRPPreprocessor.cxx:2019
 AliGRPPreprocessor.cxx:2020
 AliGRPPreprocessor.cxx:2021
 AliGRPPreprocessor.cxx:2022
 AliGRPPreprocessor.cxx:2023
 AliGRPPreprocessor.cxx:2024
 AliGRPPreprocessor.cxx:2025
 AliGRPPreprocessor.cxx:2026
 AliGRPPreprocessor.cxx:2027
 AliGRPPreprocessor.cxx:2028
 AliGRPPreprocessor.cxx:2029
 AliGRPPreprocessor.cxx:2030
 AliGRPPreprocessor.cxx:2031
 AliGRPPreprocessor.cxx:2032
 AliGRPPreprocessor.cxx:2033
 AliGRPPreprocessor.cxx:2034
 AliGRPPreprocessor.cxx:2035
 AliGRPPreprocessor.cxx:2036
 AliGRPPreprocessor.cxx:2037
 AliGRPPreprocessor.cxx:2038
 AliGRPPreprocessor.cxx:2039
 AliGRPPreprocessor.cxx:2040
 AliGRPPreprocessor.cxx:2041
 AliGRPPreprocessor.cxx:2042
 AliGRPPreprocessor.cxx:2043
 AliGRPPreprocessor.cxx:2044
 AliGRPPreprocessor.cxx:2045
 AliGRPPreprocessor.cxx:2046
 AliGRPPreprocessor.cxx:2047
 AliGRPPreprocessor.cxx:2048
 AliGRPPreprocessor.cxx:2049
 AliGRPPreprocessor.cxx:2050
 AliGRPPreprocessor.cxx:2051
 AliGRPPreprocessor.cxx:2052
 AliGRPPreprocessor.cxx:2053
 AliGRPPreprocessor.cxx:2054
 AliGRPPreprocessor.cxx:2055
 AliGRPPreprocessor.cxx:2056
 AliGRPPreprocessor.cxx:2057
 AliGRPPreprocessor.cxx:2058
 AliGRPPreprocessor.cxx:2059
 AliGRPPreprocessor.cxx:2060
 AliGRPPreprocessor.cxx:2061
 AliGRPPreprocessor.cxx:2062
 AliGRPPreprocessor.cxx:2063
 AliGRPPreprocessor.cxx:2064
 AliGRPPreprocessor.cxx:2065
 AliGRPPreprocessor.cxx:2066
 AliGRPPreprocessor.cxx:2067
 AliGRPPreprocessor.cxx:2068
 AliGRPPreprocessor.cxx:2069
 AliGRPPreprocessor.cxx:2070
 AliGRPPreprocessor.cxx:2071
 AliGRPPreprocessor.cxx:2072
 AliGRPPreprocessor.cxx:2073
 AliGRPPreprocessor.cxx:2074
 AliGRPPreprocessor.cxx:2075
 AliGRPPreprocessor.cxx:2076
 AliGRPPreprocessor.cxx:2077
 AliGRPPreprocessor.cxx:2078
 AliGRPPreprocessor.cxx:2079
 AliGRPPreprocessor.cxx:2080
 AliGRPPreprocessor.cxx:2081
 AliGRPPreprocessor.cxx:2082
 AliGRPPreprocessor.cxx:2083
 AliGRPPreprocessor.cxx:2084
 AliGRPPreprocessor.cxx:2085
 AliGRPPreprocessor.cxx:2086
 AliGRPPreprocessor.cxx:2087
 AliGRPPreprocessor.cxx:2088
 AliGRPPreprocessor.cxx:2089
 AliGRPPreprocessor.cxx:2090
 AliGRPPreprocessor.cxx:2091
 AliGRPPreprocessor.cxx:2092
 AliGRPPreprocessor.cxx:2093
 AliGRPPreprocessor.cxx:2094
 AliGRPPreprocessor.cxx:2095
 AliGRPPreprocessor.cxx:2096
 AliGRPPreprocessor.cxx:2097
 AliGRPPreprocessor.cxx:2098
 AliGRPPreprocessor.cxx:2099
 AliGRPPreprocessor.cxx:2100
 AliGRPPreprocessor.cxx:2101
 AliGRPPreprocessor.cxx:2102
 AliGRPPreprocessor.cxx:2103
 AliGRPPreprocessor.cxx:2104
 AliGRPPreprocessor.cxx:2105
 AliGRPPreprocessor.cxx:2106
 AliGRPPreprocessor.cxx:2107
 AliGRPPreprocessor.cxx:2108
 AliGRPPreprocessor.cxx:2109
 AliGRPPreprocessor.cxx:2110
 AliGRPPreprocessor.cxx:2111
 AliGRPPreprocessor.cxx:2112
 AliGRPPreprocessor.cxx:2113
 AliGRPPreprocessor.cxx:2114
 AliGRPPreprocessor.cxx:2115
 AliGRPPreprocessor.cxx:2116
 AliGRPPreprocessor.cxx:2117
 AliGRPPreprocessor.cxx:2118
 AliGRPPreprocessor.cxx:2119
 AliGRPPreprocessor.cxx:2120
 AliGRPPreprocessor.cxx:2121
 AliGRPPreprocessor.cxx:2122
 AliGRPPreprocessor.cxx:2123
 AliGRPPreprocessor.cxx:2124
 AliGRPPreprocessor.cxx:2125
 AliGRPPreprocessor.cxx:2126
 AliGRPPreprocessor.cxx:2127
 AliGRPPreprocessor.cxx:2128
 AliGRPPreprocessor.cxx:2129
 AliGRPPreprocessor.cxx:2130
 AliGRPPreprocessor.cxx:2131
 AliGRPPreprocessor.cxx:2132
 AliGRPPreprocessor.cxx:2133
 AliGRPPreprocessor.cxx:2134
 AliGRPPreprocessor.cxx:2135
 AliGRPPreprocessor.cxx:2136
 AliGRPPreprocessor.cxx:2137
 AliGRPPreprocessor.cxx:2138
 AliGRPPreprocessor.cxx:2139
 AliGRPPreprocessor.cxx:2140
 AliGRPPreprocessor.cxx:2141
 AliGRPPreprocessor.cxx:2142
 AliGRPPreprocessor.cxx:2143
 AliGRPPreprocessor.cxx:2144
 AliGRPPreprocessor.cxx:2145
 AliGRPPreprocessor.cxx:2146
 AliGRPPreprocessor.cxx:2147
 AliGRPPreprocessor.cxx:2148
 AliGRPPreprocessor.cxx:2149
 AliGRPPreprocessor.cxx:2150
 AliGRPPreprocessor.cxx:2151
 AliGRPPreprocessor.cxx:2152
 AliGRPPreprocessor.cxx:2153
 AliGRPPreprocessor.cxx:2154
 AliGRPPreprocessor.cxx:2155
 AliGRPPreprocessor.cxx:2156
 AliGRPPreprocessor.cxx:2157
 AliGRPPreprocessor.cxx:2158
 AliGRPPreprocessor.cxx:2159
 AliGRPPreprocessor.cxx:2160
 AliGRPPreprocessor.cxx:2161
 AliGRPPreprocessor.cxx:2162
 AliGRPPreprocessor.cxx:2163
 AliGRPPreprocessor.cxx:2164
 AliGRPPreprocessor.cxx:2165
 AliGRPPreprocessor.cxx:2166
 AliGRPPreprocessor.cxx:2167
 AliGRPPreprocessor.cxx:2168
 AliGRPPreprocessor.cxx:2169
 AliGRPPreprocessor.cxx:2170
 AliGRPPreprocessor.cxx:2171
 AliGRPPreprocessor.cxx:2172
 AliGRPPreprocessor.cxx:2173
 AliGRPPreprocessor.cxx:2174
 AliGRPPreprocessor.cxx:2175
 AliGRPPreprocessor.cxx:2176
 AliGRPPreprocessor.cxx:2177
 AliGRPPreprocessor.cxx:2178
 AliGRPPreprocessor.cxx:2179
 AliGRPPreprocessor.cxx:2180
 AliGRPPreprocessor.cxx:2181
 AliGRPPreprocessor.cxx:2182
 AliGRPPreprocessor.cxx:2183
 AliGRPPreprocessor.cxx:2184
 AliGRPPreprocessor.cxx:2185
 AliGRPPreprocessor.cxx:2186
 AliGRPPreprocessor.cxx:2187
 AliGRPPreprocessor.cxx:2188
 AliGRPPreprocessor.cxx:2189
 AliGRPPreprocessor.cxx:2190
 AliGRPPreprocessor.cxx:2191
 AliGRPPreprocessor.cxx:2192
 AliGRPPreprocessor.cxx:2193
 AliGRPPreprocessor.cxx:2194
 AliGRPPreprocessor.cxx:2195
 AliGRPPreprocessor.cxx:2196
 AliGRPPreprocessor.cxx:2197
 AliGRPPreprocessor.cxx:2198
 AliGRPPreprocessor.cxx:2199
 AliGRPPreprocessor.cxx:2200
 AliGRPPreprocessor.cxx:2201
 AliGRPPreprocessor.cxx:2202
 AliGRPPreprocessor.cxx:2203
 AliGRPPreprocessor.cxx:2204
 AliGRPPreprocessor.cxx:2205
 AliGRPPreprocessor.cxx:2206
 AliGRPPreprocessor.cxx:2207
 AliGRPPreprocessor.cxx:2208
 AliGRPPreprocessor.cxx:2209
 AliGRPPreprocessor.cxx:2210
 AliGRPPreprocessor.cxx:2211
 AliGRPPreprocessor.cxx:2212
 AliGRPPreprocessor.cxx:2213
 AliGRPPreprocessor.cxx:2214
 AliGRPPreprocessor.cxx:2215
 AliGRPPreprocessor.cxx:2216
 AliGRPPreprocessor.cxx:2217
 AliGRPPreprocessor.cxx:2218
 AliGRPPreprocessor.cxx:2219
 AliGRPPreprocessor.cxx:2220
 AliGRPPreprocessor.cxx:2221
 AliGRPPreprocessor.cxx:2222
 AliGRPPreprocessor.cxx:2223
 AliGRPPreprocessor.cxx:2224
 AliGRPPreprocessor.cxx:2225
 AliGRPPreprocessor.cxx:2226
 AliGRPPreprocessor.cxx:2227
 AliGRPPreprocessor.cxx:2228
 AliGRPPreprocessor.cxx:2229
 AliGRPPreprocessor.cxx:2230
 AliGRPPreprocessor.cxx:2231
 AliGRPPreprocessor.cxx:2232
 AliGRPPreprocessor.cxx:2233
 AliGRPPreprocessor.cxx:2234
 AliGRPPreprocessor.cxx:2235
 AliGRPPreprocessor.cxx:2236
 AliGRPPreprocessor.cxx:2237
 AliGRPPreprocessor.cxx:2238
 AliGRPPreprocessor.cxx:2239
 AliGRPPreprocessor.cxx:2240
 AliGRPPreprocessor.cxx:2241
 AliGRPPreprocessor.cxx:2242
 AliGRPPreprocessor.cxx:2243
 AliGRPPreprocessor.cxx:2244
 AliGRPPreprocessor.cxx:2245
 AliGRPPreprocessor.cxx:2246
 AliGRPPreprocessor.cxx:2247
 AliGRPPreprocessor.cxx:2248
 AliGRPPreprocessor.cxx:2249
 AliGRPPreprocessor.cxx:2250
 AliGRPPreprocessor.cxx:2251
 AliGRPPreprocessor.cxx:2252
 AliGRPPreprocessor.cxx:2253
 AliGRPPreprocessor.cxx:2254
 AliGRPPreprocessor.cxx:2255
 AliGRPPreprocessor.cxx:2256
 AliGRPPreprocessor.cxx:2257
 AliGRPPreprocessor.cxx:2258
 AliGRPPreprocessor.cxx:2259
 AliGRPPreprocessor.cxx:2260
 AliGRPPreprocessor.cxx:2261
 AliGRPPreprocessor.cxx:2262
 AliGRPPreprocessor.cxx:2263
 AliGRPPreprocessor.cxx:2264
 AliGRPPreprocessor.cxx:2265
 AliGRPPreprocessor.cxx:2266
 AliGRPPreprocessor.cxx:2267
 AliGRPPreprocessor.cxx:2268
 AliGRPPreprocessor.cxx:2269
 AliGRPPreprocessor.cxx:2270
 AliGRPPreprocessor.cxx:2271
 AliGRPPreprocessor.cxx:2272
 AliGRPPreprocessor.cxx:2273
 AliGRPPreprocessor.cxx:2274
 AliGRPPreprocessor.cxx:2275
 AliGRPPreprocessor.cxx:2276
 AliGRPPreprocessor.cxx:2277
 AliGRPPreprocessor.cxx:2278
 AliGRPPreprocessor.cxx:2279
 AliGRPPreprocessor.cxx:2280
 AliGRPPreprocessor.cxx:2281
 AliGRPPreprocessor.cxx:2282
 AliGRPPreprocessor.cxx:2283
 AliGRPPreprocessor.cxx:2284
 AliGRPPreprocessor.cxx:2285
 AliGRPPreprocessor.cxx:2286
 AliGRPPreprocessor.cxx:2287
 AliGRPPreprocessor.cxx:2288
 AliGRPPreprocessor.cxx:2289
 AliGRPPreprocessor.cxx:2290
 AliGRPPreprocessor.cxx:2291
 AliGRPPreprocessor.cxx:2292
 AliGRPPreprocessor.cxx:2293
 AliGRPPreprocessor.cxx:2294
 AliGRPPreprocessor.cxx:2295
 AliGRPPreprocessor.cxx:2296
 AliGRPPreprocessor.cxx:2297
 AliGRPPreprocessor.cxx:2298
 AliGRPPreprocessor.cxx:2299
 AliGRPPreprocessor.cxx:2300
 AliGRPPreprocessor.cxx:2301
 AliGRPPreprocessor.cxx:2302
 AliGRPPreprocessor.cxx:2303
 AliGRPPreprocessor.cxx:2304
 AliGRPPreprocessor.cxx:2305
 AliGRPPreprocessor.cxx:2306
 AliGRPPreprocessor.cxx:2307
 AliGRPPreprocessor.cxx:2308
 AliGRPPreprocessor.cxx:2309
 AliGRPPreprocessor.cxx:2310
 AliGRPPreprocessor.cxx:2311
 AliGRPPreprocessor.cxx:2312
 AliGRPPreprocessor.cxx:2313
 AliGRPPreprocessor.cxx:2314
 AliGRPPreprocessor.cxx:2315
 AliGRPPreprocessor.cxx:2316
 AliGRPPreprocessor.cxx:2317
 AliGRPPreprocessor.cxx:2318
 AliGRPPreprocessor.cxx:2319
 AliGRPPreprocessor.cxx:2320
 AliGRPPreprocessor.cxx:2321
 AliGRPPreprocessor.cxx:2322
 AliGRPPreprocessor.cxx:2323
 AliGRPPreprocessor.cxx:2324
 AliGRPPreprocessor.cxx:2325
 AliGRPPreprocessor.cxx:2326
 AliGRPPreprocessor.cxx:2327
 AliGRPPreprocessor.cxx:2328
 AliGRPPreprocessor.cxx:2329
 AliGRPPreprocessor.cxx:2330
 AliGRPPreprocessor.cxx:2331
 AliGRPPreprocessor.cxx:2332
 AliGRPPreprocessor.cxx:2333
 AliGRPPreprocessor.cxx:2334
 AliGRPPreprocessor.cxx:2335
 AliGRPPreprocessor.cxx:2336
 AliGRPPreprocessor.cxx:2337
 AliGRPPreprocessor.cxx:2338
 AliGRPPreprocessor.cxx:2339
 AliGRPPreprocessor.cxx:2340
 AliGRPPreprocessor.cxx:2341
 AliGRPPreprocessor.cxx:2342
 AliGRPPreprocessor.cxx:2343
 AliGRPPreprocessor.cxx:2344
 AliGRPPreprocessor.cxx:2345
 AliGRPPreprocessor.cxx:2346
 AliGRPPreprocessor.cxx:2347
 AliGRPPreprocessor.cxx:2348
 AliGRPPreprocessor.cxx:2349
 AliGRPPreprocessor.cxx:2350
 AliGRPPreprocessor.cxx:2351
 AliGRPPreprocessor.cxx:2352
 AliGRPPreprocessor.cxx:2353
 AliGRPPreprocessor.cxx:2354
 AliGRPPreprocessor.cxx:2355
 AliGRPPreprocessor.cxx:2356
 AliGRPPreprocessor.cxx:2357
 AliGRPPreprocessor.cxx:2358
 AliGRPPreprocessor.cxx:2359
 AliGRPPreprocessor.cxx:2360
 AliGRPPreprocessor.cxx:2361
 AliGRPPreprocessor.cxx:2362
 AliGRPPreprocessor.cxx:2363
 AliGRPPreprocessor.cxx:2364
 AliGRPPreprocessor.cxx:2365
 AliGRPPreprocessor.cxx:2366
 AliGRPPreprocessor.cxx:2367
 AliGRPPreprocessor.cxx:2368
 AliGRPPreprocessor.cxx:2369
 AliGRPPreprocessor.cxx:2370
 AliGRPPreprocessor.cxx:2371
 AliGRPPreprocessor.cxx:2372
 AliGRPPreprocessor.cxx:2373
 AliGRPPreprocessor.cxx:2374
 AliGRPPreprocessor.cxx:2375
 AliGRPPreprocessor.cxx:2376
 AliGRPPreprocessor.cxx:2377
 AliGRPPreprocessor.cxx:2378
 AliGRPPreprocessor.cxx:2379
 AliGRPPreprocessor.cxx:2380
 AliGRPPreprocessor.cxx:2381
 AliGRPPreprocessor.cxx:2382
 AliGRPPreprocessor.cxx:2383
 AliGRPPreprocessor.cxx:2384
 AliGRPPreprocessor.cxx:2385
 AliGRPPreprocessor.cxx:2386
 AliGRPPreprocessor.cxx:2387
 AliGRPPreprocessor.cxx:2388
 AliGRPPreprocessor.cxx:2389
 AliGRPPreprocessor.cxx:2390
 AliGRPPreprocessor.cxx:2391
 AliGRPPreprocessor.cxx:2392
 AliGRPPreprocessor.cxx:2393
 AliGRPPreprocessor.cxx:2394
 AliGRPPreprocessor.cxx:2395
 AliGRPPreprocessor.cxx:2396
 AliGRPPreprocessor.cxx:2397
 AliGRPPreprocessor.cxx:2398
 AliGRPPreprocessor.cxx:2399
 AliGRPPreprocessor.cxx:2400
 AliGRPPreprocessor.cxx:2401
 AliGRPPreprocessor.cxx:2402
 AliGRPPreprocessor.cxx:2403
 AliGRPPreprocessor.cxx:2404
 AliGRPPreprocessor.cxx:2405
 AliGRPPreprocessor.cxx:2406
 AliGRPPreprocessor.cxx:2407
 AliGRPPreprocessor.cxx:2408
 AliGRPPreprocessor.cxx:2409
 AliGRPPreprocessor.cxx:2410
 AliGRPPreprocessor.cxx:2411
 AliGRPPreprocessor.cxx:2412
 AliGRPPreprocessor.cxx:2413
 AliGRPPreprocessor.cxx:2414
 AliGRPPreprocessor.cxx:2415
 AliGRPPreprocessor.cxx:2416
 AliGRPPreprocessor.cxx:2417
 AliGRPPreprocessor.cxx:2418
 AliGRPPreprocessor.cxx:2419
 AliGRPPreprocessor.cxx:2420
 AliGRPPreprocessor.cxx:2421
 AliGRPPreprocessor.cxx:2422
 AliGRPPreprocessor.cxx:2423
 AliGRPPreprocessor.cxx:2424
 AliGRPPreprocessor.cxx:2425
 AliGRPPreprocessor.cxx:2426
 AliGRPPreprocessor.cxx:2427
 AliGRPPreprocessor.cxx:2428
 AliGRPPreprocessor.cxx:2429
 AliGRPPreprocessor.cxx:2430
 AliGRPPreprocessor.cxx:2431
 AliGRPPreprocessor.cxx:2432
 AliGRPPreprocessor.cxx:2433
 AliGRPPreprocessor.cxx:2434
 AliGRPPreprocessor.cxx:2435
 AliGRPPreprocessor.cxx:2436
 AliGRPPreprocessor.cxx:2437
 AliGRPPreprocessor.cxx:2438
 AliGRPPreprocessor.cxx:2439
 AliGRPPreprocessor.cxx:2440
 AliGRPPreprocessor.cxx:2441
 AliGRPPreprocessor.cxx:2442
 AliGRPPreprocessor.cxx:2443
 AliGRPPreprocessor.cxx:2444
 AliGRPPreprocessor.cxx:2445
 AliGRPPreprocessor.cxx:2446
 AliGRPPreprocessor.cxx:2447
 AliGRPPreprocessor.cxx:2448
 AliGRPPreprocessor.cxx:2449
 AliGRPPreprocessor.cxx:2450
 AliGRPPreprocessor.cxx:2451
 AliGRPPreprocessor.cxx:2452
 AliGRPPreprocessor.cxx:2453
 AliGRPPreprocessor.cxx:2454
 AliGRPPreprocessor.cxx:2455
 AliGRPPreprocessor.cxx:2456
 AliGRPPreprocessor.cxx:2457
 AliGRPPreprocessor.cxx:2458
 AliGRPPreprocessor.cxx:2459
 AliGRPPreprocessor.cxx:2460
 AliGRPPreprocessor.cxx:2461
 AliGRPPreprocessor.cxx:2462
 AliGRPPreprocessor.cxx:2463
 AliGRPPreprocessor.cxx:2464
 AliGRPPreprocessor.cxx:2465
 AliGRPPreprocessor.cxx:2466
 AliGRPPreprocessor.cxx:2467
 AliGRPPreprocessor.cxx:2468
 AliGRPPreprocessor.cxx:2469
 AliGRPPreprocessor.cxx:2470
 AliGRPPreprocessor.cxx:2471
 AliGRPPreprocessor.cxx:2472
 AliGRPPreprocessor.cxx:2473
 AliGRPPreprocessor.cxx:2474
 AliGRPPreprocessor.cxx:2475
 AliGRPPreprocessor.cxx:2476
 AliGRPPreprocessor.cxx:2477
 AliGRPPreprocessor.cxx:2478
 AliGRPPreprocessor.cxx:2479
 AliGRPPreprocessor.cxx:2480
 AliGRPPreprocessor.cxx:2481
 AliGRPPreprocessor.cxx:2482
 AliGRPPreprocessor.cxx:2483
 AliGRPPreprocessor.cxx:2484
 AliGRPPreprocessor.cxx:2485
 AliGRPPreprocessor.cxx:2486
 AliGRPPreprocessor.cxx:2487
 AliGRPPreprocessor.cxx:2488
 AliGRPPreprocessor.cxx:2489
 AliGRPPreprocessor.cxx:2490
 AliGRPPreprocessor.cxx:2491
 AliGRPPreprocessor.cxx:2492
 AliGRPPreprocessor.cxx:2493
 AliGRPPreprocessor.cxx:2494
 AliGRPPreprocessor.cxx:2495
 AliGRPPreprocessor.cxx:2496
 AliGRPPreprocessor.cxx:2497
 AliGRPPreprocessor.cxx:2498
 AliGRPPreprocessor.cxx:2499
 AliGRPPreprocessor.cxx:2500
 AliGRPPreprocessor.cxx:2501
 AliGRPPreprocessor.cxx:2502
 AliGRPPreprocessor.cxx:2503
 AliGRPPreprocessor.cxx:2504
 AliGRPPreprocessor.cxx:2505
 AliGRPPreprocessor.cxx:2506
 AliGRPPreprocessor.cxx:2507
 AliGRPPreprocessor.cxx:2508
 AliGRPPreprocessor.cxx:2509
 AliGRPPreprocessor.cxx:2510
 AliGRPPreprocessor.cxx:2511
 AliGRPPreprocessor.cxx:2512
 AliGRPPreprocessor.cxx:2513
 AliGRPPreprocessor.cxx:2514
 AliGRPPreprocessor.cxx:2515
 AliGRPPreprocessor.cxx:2516
 AliGRPPreprocessor.cxx:2517
 AliGRPPreprocessor.cxx:2518
 AliGRPPreprocessor.cxx:2519
 AliGRPPreprocessor.cxx:2520
 AliGRPPreprocessor.cxx:2521
 AliGRPPreprocessor.cxx:2522
 AliGRPPreprocessor.cxx:2523
 AliGRPPreprocessor.cxx:2524
 AliGRPPreprocessor.cxx:2525
 AliGRPPreprocessor.cxx:2526
 AliGRPPreprocessor.cxx:2527
 AliGRPPreprocessor.cxx:2528
 AliGRPPreprocessor.cxx:2529
 AliGRPPreprocessor.cxx:2530
 AliGRPPreprocessor.cxx:2531
 AliGRPPreprocessor.cxx:2532
 AliGRPPreprocessor.cxx:2533
 AliGRPPreprocessor.cxx:2534
 AliGRPPreprocessor.cxx:2535
 AliGRPPreprocessor.cxx:2536
 AliGRPPreprocessor.cxx:2537
 AliGRPPreprocessor.cxx:2538
 AliGRPPreprocessor.cxx:2539
 AliGRPPreprocessor.cxx:2540
 AliGRPPreprocessor.cxx:2541
 AliGRPPreprocessor.cxx:2542
 AliGRPPreprocessor.cxx:2543
 AliGRPPreprocessor.cxx:2544
 AliGRPPreprocessor.cxx:2545
 AliGRPPreprocessor.cxx:2546
 AliGRPPreprocessor.cxx:2547
 AliGRPPreprocessor.cxx:2548
 AliGRPPreprocessor.cxx:2549
 AliGRPPreprocessor.cxx:2550
 AliGRPPreprocessor.cxx:2551
 AliGRPPreprocessor.cxx:2552
 AliGRPPreprocessor.cxx:2553
 AliGRPPreprocessor.cxx:2554
 AliGRPPreprocessor.cxx:2555
 AliGRPPreprocessor.cxx:2556
 AliGRPPreprocessor.cxx:2557
 AliGRPPreprocessor.cxx:2558
 AliGRPPreprocessor.cxx:2559
 AliGRPPreprocessor.cxx:2560
 AliGRPPreprocessor.cxx:2561
 AliGRPPreprocessor.cxx:2562
 AliGRPPreprocessor.cxx:2563
 AliGRPPreprocessor.cxx:2564
 AliGRPPreprocessor.cxx:2565
 AliGRPPreprocessor.cxx:2566
 AliGRPPreprocessor.cxx:2567
 AliGRPPreprocessor.cxx:2568
 AliGRPPreprocessor.cxx:2569
 AliGRPPreprocessor.cxx:2570
 AliGRPPreprocessor.cxx:2571
 AliGRPPreprocessor.cxx:2572
 AliGRPPreprocessor.cxx:2573
 AliGRPPreprocessor.cxx:2574
 AliGRPPreprocessor.cxx:2575
 AliGRPPreprocessor.cxx:2576
 AliGRPPreprocessor.cxx:2577
 AliGRPPreprocessor.cxx:2578
 AliGRPPreprocessor.cxx:2579
 AliGRPPreprocessor.cxx:2580
 AliGRPPreprocessor.cxx:2581
 AliGRPPreprocessor.cxx:2582
 AliGRPPreprocessor.cxx:2583
 AliGRPPreprocessor.cxx:2584
 AliGRPPreprocessor.cxx:2585
 AliGRPPreprocessor.cxx:2586
 AliGRPPreprocessor.cxx:2587
 AliGRPPreprocessor.cxx:2588
 AliGRPPreprocessor.cxx:2589
 AliGRPPreprocessor.cxx:2590
 AliGRPPreprocessor.cxx:2591
 AliGRPPreprocessor.cxx:2592
 AliGRPPreprocessor.cxx:2593
 AliGRPPreprocessor.cxx:2594
 AliGRPPreprocessor.cxx:2595
 AliGRPPreprocessor.cxx:2596
 AliGRPPreprocessor.cxx:2597
 AliGRPPreprocessor.cxx:2598
 AliGRPPreprocessor.cxx:2599
 AliGRPPreprocessor.cxx:2600
 AliGRPPreprocessor.cxx:2601
 AliGRPPreprocessor.cxx:2602
 AliGRPPreprocessor.cxx:2603
 AliGRPPreprocessor.cxx:2604
 AliGRPPreprocessor.cxx:2605
 AliGRPPreprocessor.cxx:2606
 AliGRPPreprocessor.cxx:2607
 AliGRPPreprocessor.cxx:2608
 AliGRPPreprocessor.cxx:2609
 AliGRPPreprocessor.cxx:2610
 AliGRPPreprocessor.cxx:2611
 AliGRPPreprocessor.cxx:2612
 AliGRPPreprocessor.cxx:2613
 AliGRPPreprocessor.cxx:2614
 AliGRPPreprocessor.cxx:2615
 AliGRPPreprocessor.cxx:2616
 AliGRPPreprocessor.cxx:2617
 AliGRPPreprocessor.cxx:2618
 AliGRPPreprocessor.cxx:2619
 AliGRPPreprocessor.cxx:2620
 AliGRPPreprocessor.cxx:2621
 AliGRPPreprocessor.cxx:2622
 AliGRPPreprocessor.cxx:2623
 AliGRPPreprocessor.cxx:2624
 AliGRPPreprocessor.cxx:2625
 AliGRPPreprocessor.cxx:2626
 AliGRPPreprocessor.cxx:2627
 AliGRPPreprocessor.cxx:2628
 AliGRPPreprocessor.cxx:2629
 AliGRPPreprocessor.cxx:2630
 AliGRPPreprocessor.cxx:2631
 AliGRPPreprocessor.cxx:2632
 AliGRPPreprocessor.cxx:2633
 AliGRPPreprocessor.cxx:2634
 AliGRPPreprocessor.cxx:2635
 AliGRPPreprocessor.cxx:2636
 AliGRPPreprocessor.cxx:2637
 AliGRPPreprocessor.cxx:2638
 AliGRPPreprocessor.cxx:2639
 AliGRPPreprocessor.cxx:2640
 AliGRPPreprocessor.cxx:2641
 AliGRPPreprocessor.cxx:2642
 AliGRPPreprocessor.cxx:2643
 AliGRPPreprocessor.cxx:2644
 AliGRPPreprocessor.cxx:2645
 AliGRPPreprocessor.cxx:2646
 AliGRPPreprocessor.cxx:2647
 AliGRPPreprocessor.cxx:2648
 AliGRPPreprocessor.cxx:2649
 AliGRPPreprocessor.cxx:2650
 AliGRPPreprocessor.cxx:2651
 AliGRPPreprocessor.cxx:2652
 AliGRPPreprocessor.cxx:2653
 AliGRPPreprocessor.cxx:2654
 AliGRPPreprocessor.cxx:2655
 AliGRPPreprocessor.cxx:2656
 AliGRPPreprocessor.cxx:2657
 AliGRPPreprocessor.cxx:2658
 AliGRPPreprocessor.cxx:2659
 AliGRPPreprocessor.cxx:2660
 AliGRPPreprocessor.cxx:2661
 AliGRPPreprocessor.cxx:2662
 AliGRPPreprocessor.cxx:2663
 AliGRPPreprocessor.cxx:2664
 AliGRPPreprocessor.cxx:2665
 AliGRPPreprocessor.cxx:2666
 AliGRPPreprocessor.cxx:2667
 AliGRPPreprocessor.cxx:2668
 AliGRPPreprocessor.cxx:2669
 AliGRPPreprocessor.cxx:2670
 AliGRPPreprocessor.cxx:2671
 AliGRPPreprocessor.cxx:2672
 AliGRPPreprocessor.cxx:2673
 AliGRPPreprocessor.cxx:2674
 AliGRPPreprocessor.cxx:2675
 AliGRPPreprocessor.cxx:2676
 AliGRPPreprocessor.cxx:2677
 AliGRPPreprocessor.cxx:2678
 AliGRPPreprocessor.cxx:2679
 AliGRPPreprocessor.cxx:2680
 AliGRPPreprocessor.cxx:2681
 AliGRPPreprocessor.cxx:2682
 AliGRPPreprocessor.cxx:2683
 AliGRPPreprocessor.cxx:2684
 AliGRPPreprocessor.cxx:2685
 AliGRPPreprocessor.cxx:2686
 AliGRPPreprocessor.cxx:2687
 AliGRPPreprocessor.cxx:2688
 AliGRPPreprocessor.cxx:2689
 AliGRPPreprocessor.cxx:2690
 AliGRPPreprocessor.cxx:2691
 AliGRPPreprocessor.cxx:2692
 AliGRPPreprocessor.cxx:2693
 AliGRPPreprocessor.cxx:2694
 AliGRPPreprocessor.cxx:2695
 AliGRPPreprocessor.cxx:2696
 AliGRPPreprocessor.cxx:2697
 AliGRPPreprocessor.cxx:2698
 AliGRPPreprocessor.cxx:2699
 AliGRPPreprocessor.cxx:2700
 AliGRPPreprocessor.cxx:2701
 AliGRPPreprocessor.cxx:2702
 AliGRPPreprocessor.cxx:2703
 AliGRPPreprocessor.cxx:2704
 AliGRPPreprocessor.cxx:2705
 AliGRPPreprocessor.cxx:2706
 AliGRPPreprocessor.cxx:2707
 AliGRPPreprocessor.cxx:2708
 AliGRPPreprocessor.cxx:2709
 AliGRPPreprocessor.cxx:2710
 AliGRPPreprocessor.cxx:2711
 AliGRPPreprocessor.cxx:2712
 AliGRPPreprocessor.cxx:2713
 AliGRPPreprocessor.cxx:2714
 AliGRPPreprocessor.cxx:2715
 AliGRPPreprocessor.cxx:2716
 AliGRPPreprocessor.cxx:2717
 AliGRPPreprocessor.cxx:2718
 AliGRPPreprocessor.cxx:2719
 AliGRPPreprocessor.cxx:2720
 AliGRPPreprocessor.cxx:2721
 AliGRPPreprocessor.cxx:2722
 AliGRPPreprocessor.cxx:2723
 AliGRPPreprocessor.cxx:2724
 AliGRPPreprocessor.cxx:2725
 AliGRPPreprocessor.cxx:2726
 AliGRPPreprocessor.cxx:2727
 AliGRPPreprocessor.cxx:2728
 AliGRPPreprocessor.cxx:2729
 AliGRPPreprocessor.cxx:2730
 AliGRPPreprocessor.cxx:2731
 AliGRPPreprocessor.cxx:2732
 AliGRPPreprocessor.cxx:2733
 AliGRPPreprocessor.cxx:2734
 AliGRPPreprocessor.cxx:2735
 AliGRPPreprocessor.cxx:2736
 AliGRPPreprocessor.cxx:2737
 AliGRPPreprocessor.cxx:2738
 AliGRPPreprocessor.cxx:2739
 AliGRPPreprocessor.cxx:2740
 AliGRPPreprocessor.cxx:2741
 AliGRPPreprocessor.cxx:2742
 AliGRPPreprocessor.cxx:2743
 AliGRPPreprocessor.cxx:2744
 AliGRPPreprocessor.cxx:2745
 AliGRPPreprocessor.cxx:2746
 AliGRPPreprocessor.cxx:2747
 AliGRPPreprocessor.cxx:2748
 AliGRPPreprocessor.cxx:2749
 AliGRPPreprocessor.cxx:2750
 AliGRPPreprocessor.cxx:2751
 AliGRPPreprocessor.cxx:2752
 AliGRPPreprocessor.cxx:2753
 AliGRPPreprocessor.cxx:2754
 AliGRPPreprocessor.cxx:2755
 AliGRPPreprocessor.cxx:2756
 AliGRPPreprocessor.cxx:2757
 AliGRPPreprocessor.cxx:2758
 AliGRPPreprocessor.cxx:2759
 AliGRPPreprocessor.cxx:2760
 AliGRPPreprocessor.cxx:2761
 AliGRPPreprocessor.cxx:2762
 AliGRPPreprocessor.cxx:2763
 AliGRPPreprocessor.cxx:2764
 AliGRPPreprocessor.cxx:2765
 AliGRPPreprocessor.cxx:2766
 AliGRPPreprocessor.cxx:2767
 AliGRPPreprocessor.cxx:2768
 AliGRPPreprocessor.cxx:2769
 AliGRPPreprocessor.cxx:2770
 AliGRPPreprocessor.cxx:2771
 AliGRPPreprocessor.cxx:2772
 AliGRPPreprocessor.cxx:2773
 AliGRPPreprocessor.cxx:2774
 AliGRPPreprocessor.cxx:2775
 AliGRPPreprocessor.cxx:2776
 AliGRPPreprocessor.cxx:2777
 AliGRPPreprocessor.cxx:2778
 AliGRPPreprocessor.cxx:2779
 AliGRPPreprocessor.cxx:2780
 AliGRPPreprocessor.cxx:2781
 AliGRPPreprocessor.cxx:2782
 AliGRPPreprocessor.cxx:2783
 AliGRPPreprocessor.cxx:2784
 AliGRPPreprocessor.cxx:2785
 AliGRPPreprocessor.cxx:2786
 AliGRPPreprocessor.cxx:2787
 AliGRPPreprocessor.cxx:2788
 AliGRPPreprocessor.cxx:2789
 AliGRPPreprocessor.cxx:2790
 AliGRPPreprocessor.cxx:2791
 AliGRPPreprocessor.cxx:2792
 AliGRPPreprocessor.cxx:2793
 AliGRPPreprocessor.cxx:2794
 AliGRPPreprocessor.cxx:2795
 AliGRPPreprocessor.cxx:2796
 AliGRPPreprocessor.cxx:2797
 AliGRPPreprocessor.cxx:2798
 AliGRPPreprocessor.cxx:2799
 AliGRPPreprocessor.cxx:2800
 AliGRPPreprocessor.cxx:2801
 AliGRPPreprocessor.cxx:2802
 AliGRPPreprocessor.cxx:2803
 AliGRPPreprocessor.cxx:2804
 AliGRPPreprocessor.cxx:2805
 AliGRPPreprocessor.cxx:2806
 AliGRPPreprocessor.cxx:2807
 AliGRPPreprocessor.cxx:2808
 AliGRPPreprocessor.cxx:2809
 AliGRPPreprocessor.cxx:2810
 AliGRPPreprocessor.cxx:2811
 AliGRPPreprocessor.cxx:2812
 AliGRPPreprocessor.cxx:2813
 AliGRPPreprocessor.cxx:2814
 AliGRPPreprocessor.cxx:2815
 AliGRPPreprocessor.cxx:2816
 AliGRPPreprocessor.cxx:2817
 AliGRPPreprocessor.cxx:2818
 AliGRPPreprocessor.cxx:2819
 AliGRPPreprocessor.cxx:2820
 AliGRPPreprocessor.cxx:2821
 AliGRPPreprocessor.cxx:2822
 AliGRPPreprocessor.cxx:2823
 AliGRPPreprocessor.cxx:2824
 AliGRPPreprocessor.cxx:2825
 AliGRPPreprocessor.cxx:2826
 AliGRPPreprocessor.cxx:2827
 AliGRPPreprocessor.cxx:2828
 AliGRPPreprocessor.cxx:2829
 AliGRPPreprocessor.cxx:2830
 AliGRPPreprocessor.cxx:2831
 AliGRPPreprocessor.cxx:2832
 AliGRPPreprocessor.cxx:2833
 AliGRPPreprocessor.cxx:2834
 AliGRPPreprocessor.cxx:2835
 AliGRPPreprocessor.cxx:2836
 AliGRPPreprocessor.cxx:2837
 AliGRPPreprocessor.cxx:2838
 AliGRPPreprocessor.cxx:2839
 AliGRPPreprocessor.cxx:2840
 AliGRPPreprocessor.cxx:2841
 AliGRPPreprocessor.cxx:2842
 AliGRPPreprocessor.cxx:2843
 AliGRPPreprocessor.cxx:2844
 AliGRPPreprocessor.cxx:2845
 AliGRPPreprocessor.cxx:2846
 AliGRPPreprocessor.cxx:2847
 AliGRPPreprocessor.cxx:2848
 AliGRPPreprocessor.cxx:2849
 AliGRPPreprocessor.cxx:2850
 AliGRPPreprocessor.cxx:2851
 AliGRPPreprocessor.cxx:2852
 AliGRPPreprocessor.cxx:2853
 AliGRPPreprocessor.cxx:2854
 AliGRPPreprocessor.cxx:2855
 AliGRPPreprocessor.cxx:2856
 AliGRPPreprocessor.cxx:2857
 AliGRPPreprocessor.cxx:2858
 AliGRPPreprocessor.cxx:2859
 AliGRPPreprocessor.cxx:2860
 AliGRPPreprocessor.cxx:2861
 AliGRPPreprocessor.cxx:2862
 AliGRPPreprocessor.cxx:2863
 AliGRPPreprocessor.cxx:2864
 AliGRPPreprocessor.cxx:2865
 AliGRPPreprocessor.cxx:2866
 AliGRPPreprocessor.cxx:2867
 AliGRPPreprocessor.cxx:2868
 AliGRPPreprocessor.cxx:2869
 AliGRPPreprocessor.cxx:2870
 AliGRPPreprocessor.cxx:2871
 AliGRPPreprocessor.cxx:2872
 AliGRPPreprocessor.cxx:2873
 AliGRPPreprocessor.cxx:2874
 AliGRPPreprocessor.cxx:2875
 AliGRPPreprocessor.cxx:2876
 AliGRPPreprocessor.cxx:2877
 AliGRPPreprocessor.cxx:2878
 AliGRPPreprocessor.cxx:2879
 AliGRPPreprocessor.cxx:2880
 AliGRPPreprocessor.cxx:2881
 AliGRPPreprocessor.cxx:2882
 AliGRPPreprocessor.cxx:2883
 AliGRPPreprocessor.cxx:2884
 AliGRPPreprocessor.cxx:2885
 AliGRPPreprocessor.cxx:2886
 AliGRPPreprocessor.cxx:2887
 AliGRPPreprocessor.cxx:2888
 AliGRPPreprocessor.cxx:2889
 AliGRPPreprocessor.cxx:2890
 AliGRPPreprocessor.cxx:2891
 AliGRPPreprocessor.cxx:2892
 AliGRPPreprocessor.cxx:2893
 AliGRPPreprocessor.cxx:2894
 AliGRPPreprocessor.cxx:2895
 AliGRPPreprocessor.cxx:2896
 AliGRPPreprocessor.cxx:2897
 AliGRPPreprocessor.cxx:2898
 AliGRPPreprocessor.cxx:2899
 AliGRPPreprocessor.cxx:2900
 AliGRPPreprocessor.cxx:2901
 AliGRPPreprocessor.cxx:2902
 AliGRPPreprocessor.cxx:2903
 AliGRPPreprocessor.cxx:2904
 AliGRPPreprocessor.cxx:2905
 AliGRPPreprocessor.cxx:2906
 AliGRPPreprocessor.cxx:2907
 AliGRPPreprocessor.cxx:2908
 AliGRPPreprocessor.cxx:2909
 AliGRPPreprocessor.cxx:2910
 AliGRPPreprocessor.cxx:2911
 AliGRPPreprocessor.cxx:2912
 AliGRPPreprocessor.cxx:2913
 AliGRPPreprocessor.cxx:2914
 AliGRPPreprocessor.cxx:2915
 AliGRPPreprocessor.cxx:2916
 AliGRPPreprocessor.cxx:2917
 AliGRPPreprocessor.cxx:2918
 AliGRPPreprocessor.cxx:2919
 AliGRPPreprocessor.cxx:2920
 AliGRPPreprocessor.cxx:2921
 AliGRPPreprocessor.cxx:2922
 AliGRPPreprocessor.cxx:2923
 AliGRPPreprocessor.cxx:2924
 AliGRPPreprocessor.cxx:2925
 AliGRPPreprocessor.cxx:2926
 AliGRPPreprocessor.cxx:2927
 AliGRPPreprocessor.cxx:2928
 AliGRPPreprocessor.cxx:2929
 AliGRPPreprocessor.cxx:2930
 AliGRPPreprocessor.cxx:2931
 AliGRPPreprocessor.cxx:2932
 AliGRPPreprocessor.cxx:2933
 AliGRPPreprocessor.cxx:2934
 AliGRPPreprocessor.cxx:2935
 AliGRPPreprocessor.cxx:2936
 AliGRPPreprocessor.cxx:2937
 AliGRPPreprocessor.cxx:2938
 AliGRPPreprocessor.cxx:2939
 AliGRPPreprocessor.cxx:2940
 AliGRPPreprocessor.cxx:2941
 AliGRPPreprocessor.cxx:2942
 AliGRPPreprocessor.cxx:2943
 AliGRPPreprocessor.cxx:2944
 AliGRPPreprocessor.cxx:2945
 AliGRPPreprocessor.cxx:2946
 AliGRPPreprocessor.cxx:2947
 AliGRPPreprocessor.cxx:2948
 AliGRPPreprocessor.cxx:2949
 AliGRPPreprocessor.cxx:2950
 AliGRPPreprocessor.cxx:2951
 AliGRPPreprocessor.cxx:2952
 AliGRPPreprocessor.cxx:2953
 AliGRPPreprocessor.cxx:2954
 AliGRPPreprocessor.cxx:2955
 AliGRPPreprocessor.cxx:2956
 AliGRPPreprocessor.cxx:2957
 AliGRPPreprocessor.cxx:2958
 AliGRPPreprocessor.cxx:2959
 AliGRPPreprocessor.cxx:2960
 AliGRPPreprocessor.cxx:2961
 AliGRPPreprocessor.cxx:2962
 AliGRPPreprocessor.cxx:2963
 AliGRPPreprocessor.cxx:2964
 AliGRPPreprocessor.cxx:2965
 AliGRPPreprocessor.cxx:2966
 AliGRPPreprocessor.cxx:2967
 AliGRPPreprocessor.cxx:2968
 AliGRPPreprocessor.cxx:2969
 AliGRPPreprocessor.cxx:2970
 AliGRPPreprocessor.cxx:2971
 AliGRPPreprocessor.cxx:2972
 AliGRPPreprocessor.cxx:2973
 AliGRPPreprocessor.cxx:2974
 AliGRPPreprocessor.cxx:2975
 AliGRPPreprocessor.cxx:2976
 AliGRPPreprocessor.cxx:2977
 AliGRPPreprocessor.cxx:2978
 AliGRPPreprocessor.cxx:2979
 AliGRPPreprocessor.cxx:2980
 AliGRPPreprocessor.cxx:2981
 AliGRPPreprocessor.cxx:2982
 AliGRPPreprocessor.cxx:2983
 AliGRPPreprocessor.cxx:2984
 AliGRPPreprocessor.cxx:2985
 AliGRPPreprocessor.cxx:2986
 AliGRPPreprocessor.cxx:2987
 AliGRPPreprocessor.cxx:2988
 AliGRPPreprocessor.cxx:2989
 AliGRPPreprocessor.cxx:2990
 AliGRPPreprocessor.cxx:2991
 AliGRPPreprocessor.cxx:2992
 AliGRPPreprocessor.cxx:2993
 AliGRPPreprocessor.cxx:2994
 AliGRPPreprocessor.cxx:2995
 AliGRPPreprocessor.cxx:2996
 AliGRPPreprocessor.cxx:2997
 AliGRPPreprocessor.cxx:2998
 AliGRPPreprocessor.cxx:2999
 AliGRPPreprocessor.cxx:3000
 AliGRPPreprocessor.cxx:3001
 AliGRPPreprocessor.cxx:3002
 AliGRPPreprocessor.cxx:3003
 AliGRPPreprocessor.cxx:3004
 AliGRPPreprocessor.cxx:3005
 AliGRPPreprocessor.cxx:3006
 AliGRPPreprocessor.cxx:3007
 AliGRPPreprocessor.cxx:3008
 AliGRPPreprocessor.cxx:3009
 AliGRPPreprocessor.cxx:3010
 AliGRPPreprocessor.cxx:3011
 AliGRPPreprocessor.cxx:3012
 AliGRPPreprocessor.cxx:3013
 AliGRPPreprocessor.cxx:3014
 AliGRPPreprocessor.cxx:3015
 AliGRPPreprocessor.cxx:3016
 AliGRPPreprocessor.cxx:3017
 AliGRPPreprocessor.cxx:3018
 AliGRPPreprocessor.cxx:3019
 AliGRPPreprocessor.cxx:3020
 AliGRPPreprocessor.cxx:3021
 AliGRPPreprocessor.cxx:3022
 AliGRPPreprocessor.cxx:3023
 AliGRPPreprocessor.cxx:3024
 AliGRPPreprocessor.cxx:3025
 AliGRPPreprocessor.cxx:3026
 AliGRPPreprocessor.cxx:3027
 AliGRPPreprocessor.cxx:3028
 AliGRPPreprocessor.cxx:3029
 AliGRPPreprocessor.cxx:3030
 AliGRPPreprocessor.cxx:3031
 AliGRPPreprocessor.cxx:3032
 AliGRPPreprocessor.cxx:3033
 AliGRPPreprocessor.cxx:3034
 AliGRPPreprocessor.cxx:3035
 AliGRPPreprocessor.cxx:3036
 AliGRPPreprocessor.cxx:3037
 AliGRPPreprocessor.cxx:3038
 AliGRPPreprocessor.cxx:3039
 AliGRPPreprocessor.cxx:3040
 AliGRPPreprocessor.cxx:3041
 AliGRPPreprocessor.cxx:3042
 AliGRPPreprocessor.cxx:3043
 AliGRPPreprocessor.cxx:3044
 AliGRPPreprocessor.cxx:3045
 AliGRPPreprocessor.cxx:3046
 AliGRPPreprocessor.cxx:3047
 AliGRPPreprocessor.cxx:3048
 AliGRPPreprocessor.cxx:3049
 AliGRPPreprocessor.cxx:3050
 AliGRPPreprocessor.cxx:3051
 AliGRPPreprocessor.cxx:3052
 AliGRPPreprocessor.cxx:3053
 AliGRPPreprocessor.cxx:3054
 AliGRPPreprocessor.cxx:3055
 AliGRPPreprocessor.cxx:3056
 AliGRPPreprocessor.cxx:3057
 AliGRPPreprocessor.cxx:3058
 AliGRPPreprocessor.cxx:3059
 AliGRPPreprocessor.cxx:3060
 AliGRPPreprocessor.cxx:3061
 AliGRPPreprocessor.cxx:3062
 AliGRPPreprocessor.cxx:3063
 AliGRPPreprocessor.cxx:3064
 AliGRPPreprocessor.cxx:3065
 AliGRPPreprocessor.cxx:3066
 AliGRPPreprocessor.cxx:3067
 AliGRPPreprocessor.cxx:3068
 AliGRPPreprocessor.cxx:3069
 AliGRPPreprocessor.cxx:3070
 AliGRPPreprocessor.cxx:3071
 AliGRPPreprocessor.cxx:3072
 AliGRPPreprocessor.cxx:3073
 AliGRPPreprocessor.cxx:3074
 AliGRPPreprocessor.cxx:3075
 AliGRPPreprocessor.cxx:3076
 AliGRPPreprocessor.cxx:3077
 AliGRPPreprocessor.cxx:3078
 AliGRPPreprocessor.cxx:3079
 AliGRPPreprocessor.cxx:3080
 AliGRPPreprocessor.cxx:3081
 AliGRPPreprocessor.cxx:3082
 AliGRPPreprocessor.cxx:3083
 AliGRPPreprocessor.cxx:3084
 AliGRPPreprocessor.cxx:3085
 AliGRPPreprocessor.cxx:3086
 AliGRPPreprocessor.cxx:3087
 AliGRPPreprocessor.cxx:3088
 AliGRPPreprocessor.cxx:3089
 AliGRPPreprocessor.cxx:3090
 AliGRPPreprocessor.cxx:3091
 AliGRPPreprocessor.cxx:3092
 AliGRPPreprocessor.cxx:3093
 AliGRPPreprocessor.cxx:3094
 AliGRPPreprocessor.cxx:3095
 AliGRPPreprocessor.cxx:3096
 AliGRPPreprocessor.cxx:3097
 AliGRPPreprocessor.cxx:3098
 AliGRPPreprocessor.cxx:3099
 AliGRPPreprocessor.cxx:3100
 AliGRPPreprocessor.cxx:3101
 AliGRPPreprocessor.cxx:3102
 AliGRPPreprocessor.cxx:3103
 AliGRPPreprocessor.cxx:3104
 AliGRPPreprocessor.cxx:3105
 AliGRPPreprocessor.cxx:3106
 AliGRPPreprocessor.cxx:3107
 AliGRPPreprocessor.cxx:3108
 AliGRPPreprocessor.cxx:3109
 AliGRPPreprocessor.cxx:3110
 AliGRPPreprocessor.cxx:3111
 AliGRPPreprocessor.cxx:3112
 AliGRPPreprocessor.cxx:3113
 AliGRPPreprocessor.cxx:3114
 AliGRPPreprocessor.cxx:3115
 AliGRPPreprocessor.cxx:3116
 AliGRPPreprocessor.cxx:3117
 AliGRPPreprocessor.cxx:3118
 AliGRPPreprocessor.cxx:3119
 AliGRPPreprocessor.cxx:3120
 AliGRPPreprocessor.cxx:3121
 AliGRPPreprocessor.cxx:3122
 AliGRPPreprocessor.cxx:3123
 AliGRPPreprocessor.cxx:3124
 AliGRPPreprocessor.cxx:3125
 AliGRPPreprocessor.cxx:3126
 AliGRPPreprocessor.cxx:3127
 AliGRPPreprocessor.cxx:3128
 AliGRPPreprocessor.cxx:3129
 AliGRPPreprocessor.cxx:3130
 AliGRPPreprocessor.cxx:3131
 AliGRPPreprocessor.cxx:3132
 AliGRPPreprocessor.cxx:3133
 AliGRPPreprocessor.cxx:3134
 AliGRPPreprocessor.cxx:3135
 AliGRPPreprocessor.cxx:3136
 AliGRPPreprocessor.cxx:3137
 AliGRPPreprocessor.cxx:3138
 AliGRPPreprocessor.cxx:3139
 AliGRPPreprocessor.cxx:3140
 AliGRPPreprocessor.cxx:3141
 AliGRPPreprocessor.cxx:3142
 AliGRPPreprocessor.cxx:3143
 AliGRPPreprocessor.cxx:3144
 AliGRPPreprocessor.cxx:3145
 AliGRPPreprocessor.cxx:3146
 AliGRPPreprocessor.cxx:3147
 AliGRPPreprocessor.cxx:3148
 AliGRPPreprocessor.cxx:3149
 AliGRPPreprocessor.cxx:3150
 AliGRPPreprocessor.cxx:3151
 AliGRPPreprocessor.cxx:3152
 AliGRPPreprocessor.cxx:3153
 AliGRPPreprocessor.cxx:3154
 AliGRPPreprocessor.cxx:3155
 AliGRPPreprocessor.cxx:3156
 AliGRPPreprocessor.cxx:3157
 AliGRPPreprocessor.cxx:3158
 AliGRPPreprocessor.cxx:3159
 AliGRPPreprocessor.cxx:3160
 AliGRPPreprocessor.cxx:3161
 AliGRPPreprocessor.cxx:3162
 AliGRPPreprocessor.cxx:3163
 AliGRPPreprocessor.cxx:3164
 AliGRPPreprocessor.cxx:3165
 AliGRPPreprocessor.cxx:3166
 AliGRPPreprocessor.cxx:3167
 AliGRPPreprocessor.cxx:3168
 AliGRPPreprocessor.cxx:3169
 AliGRPPreprocessor.cxx:3170
 AliGRPPreprocessor.cxx:3171
 AliGRPPreprocessor.cxx:3172
 AliGRPPreprocessor.cxx:3173
 AliGRPPreprocessor.cxx:3174
 AliGRPPreprocessor.cxx:3175
 AliGRPPreprocessor.cxx:3176
 AliGRPPreprocessor.cxx:3177
 AliGRPPreprocessor.cxx:3178
 AliGRPPreprocessor.cxx:3179
 AliGRPPreprocessor.cxx:3180
 AliGRPPreprocessor.cxx:3181
 AliGRPPreprocessor.cxx:3182
 AliGRPPreprocessor.cxx:3183
 AliGRPPreprocessor.cxx:3184
 AliGRPPreprocessor.cxx:3185
 AliGRPPreprocessor.cxx:3186
 AliGRPPreprocessor.cxx:3187
 AliGRPPreprocessor.cxx:3188
 AliGRPPreprocessor.cxx:3189
 AliGRPPreprocessor.cxx:3190
 AliGRPPreprocessor.cxx:3191
 AliGRPPreprocessor.cxx:3192
 AliGRPPreprocessor.cxx:3193
 AliGRPPreprocessor.cxx:3194
 AliGRPPreprocessor.cxx:3195
 AliGRPPreprocessor.cxx:3196
 AliGRPPreprocessor.cxx:3197
 AliGRPPreprocessor.cxx:3198
 AliGRPPreprocessor.cxx:3199
 AliGRPPreprocessor.cxx:3200
 AliGRPPreprocessor.cxx:3201
 AliGRPPreprocessor.cxx:3202
 AliGRPPreprocessor.cxx:3203
 AliGRPPreprocessor.cxx:3204
 AliGRPPreprocessor.cxx:3205
 AliGRPPreprocessor.cxx:3206
 AliGRPPreprocessor.cxx:3207
 AliGRPPreprocessor.cxx:3208
 AliGRPPreprocessor.cxx:3209
 AliGRPPreprocessor.cxx:3210
 AliGRPPreprocessor.cxx:3211
 AliGRPPreprocessor.cxx:3212
 AliGRPPreprocessor.cxx:3213
 AliGRPPreprocessor.cxx:3214
 AliGRPPreprocessor.cxx:3215
 AliGRPPreprocessor.cxx:3216
 AliGRPPreprocessor.cxx:3217
 AliGRPPreprocessor.cxx:3218
 AliGRPPreprocessor.cxx:3219
 AliGRPPreprocessor.cxx:3220
 AliGRPPreprocessor.cxx:3221
 AliGRPPreprocessor.cxx:3222
 AliGRPPreprocessor.cxx:3223
 AliGRPPreprocessor.cxx:3224
 AliGRPPreprocessor.cxx:3225
 AliGRPPreprocessor.cxx:3226
 AliGRPPreprocessor.cxx:3227
 AliGRPPreprocessor.cxx:3228
 AliGRPPreprocessor.cxx:3229
 AliGRPPreprocessor.cxx:3230
 AliGRPPreprocessor.cxx:3231
 AliGRPPreprocessor.cxx:3232
 AliGRPPreprocessor.cxx:3233
 AliGRPPreprocessor.cxx:3234
 AliGRPPreprocessor.cxx:3235
 AliGRPPreprocessor.cxx:3236
 AliGRPPreprocessor.cxx:3237
 AliGRPPreprocessor.cxx:3238
 AliGRPPreprocessor.cxx:3239
 AliGRPPreprocessor.cxx:3240
 AliGRPPreprocessor.cxx:3241
 AliGRPPreprocessor.cxx:3242
 AliGRPPreprocessor.cxx:3243
 AliGRPPreprocessor.cxx:3244
 AliGRPPreprocessor.cxx:3245
 AliGRPPreprocessor.cxx:3246
 AliGRPPreprocessor.cxx:3247
 AliGRPPreprocessor.cxx:3248
 AliGRPPreprocessor.cxx:3249
 AliGRPPreprocessor.cxx:3250
 AliGRPPreprocessor.cxx:3251
 AliGRPPreprocessor.cxx:3252
 AliGRPPreprocessor.cxx:3253
 AliGRPPreprocessor.cxx:3254
 AliGRPPreprocessor.cxx:3255
 AliGRPPreprocessor.cxx:3256
 AliGRPPreprocessor.cxx:3257
 AliGRPPreprocessor.cxx:3258
 AliGRPPreprocessor.cxx:3259
 AliGRPPreprocessor.cxx:3260
 AliGRPPreprocessor.cxx:3261
 AliGRPPreprocessor.cxx:3262
 AliGRPPreprocessor.cxx:3263
 AliGRPPreprocessor.cxx:3264
 AliGRPPreprocessor.cxx:3265
 AliGRPPreprocessor.cxx:3266
 AliGRPPreprocessor.cxx:3267
 AliGRPPreprocessor.cxx:3268
 AliGRPPreprocessor.cxx:3269
 AliGRPPreprocessor.cxx:3270
 AliGRPPreprocessor.cxx:3271
 AliGRPPreprocessor.cxx:3272
 AliGRPPreprocessor.cxx:3273
 AliGRPPreprocessor.cxx:3274
 AliGRPPreprocessor.cxx:3275
 AliGRPPreprocessor.cxx:3276
 AliGRPPreprocessor.cxx:3277
 AliGRPPreprocessor.cxx:3278
 AliGRPPreprocessor.cxx:3279
 AliGRPPreprocessor.cxx:3280
 AliGRPPreprocessor.cxx:3281
 AliGRPPreprocessor.cxx:3282
 AliGRPPreprocessor.cxx:3283
 AliGRPPreprocessor.cxx:3284
 AliGRPPreprocessor.cxx:3285
 AliGRPPreprocessor.cxx:3286
 AliGRPPreprocessor.cxx:3287
 AliGRPPreprocessor.cxx:3288
 AliGRPPreprocessor.cxx:3289
 AliGRPPreprocessor.cxx:3290
 AliGRPPreprocessor.cxx:3291
 AliGRPPreprocessor.cxx:3292
 AliGRPPreprocessor.cxx:3293
 AliGRPPreprocessor.cxx:3294
 AliGRPPreprocessor.cxx:3295
 AliGRPPreprocessor.cxx:3296
 AliGRPPreprocessor.cxx:3297
 AliGRPPreprocessor.cxx:3298
 AliGRPPreprocessor.cxx:3299
 AliGRPPreprocessor.cxx:3300
 AliGRPPreprocessor.cxx:3301
 AliGRPPreprocessor.cxx:3302
 AliGRPPreprocessor.cxx:3303
 AliGRPPreprocessor.cxx:3304
 AliGRPPreprocessor.cxx:3305
 AliGRPPreprocessor.cxx:3306
 AliGRPPreprocessor.cxx:3307
 AliGRPPreprocessor.cxx:3308
 AliGRPPreprocessor.cxx:3309
 AliGRPPreprocessor.cxx:3310
 AliGRPPreprocessor.cxx:3311
 AliGRPPreprocessor.cxx:3312
 AliGRPPreprocessor.cxx:3313
 AliGRPPreprocessor.cxx:3314
 AliGRPPreprocessor.cxx:3315
 AliGRPPreprocessor.cxx:3316
 AliGRPPreprocessor.cxx:3317
 AliGRPPreprocessor.cxx:3318
 AliGRPPreprocessor.cxx:3319
 AliGRPPreprocessor.cxx:3320
 AliGRPPreprocessor.cxx:3321
 AliGRPPreprocessor.cxx:3322
 AliGRPPreprocessor.cxx:3323
 AliGRPPreprocessor.cxx:3324
 AliGRPPreprocessor.cxx:3325
 AliGRPPreprocessor.cxx:3326
 AliGRPPreprocessor.cxx:3327
 AliGRPPreprocessor.cxx:3328
 AliGRPPreprocessor.cxx:3329
 AliGRPPreprocessor.cxx:3330
 AliGRPPreprocessor.cxx:3331
 AliGRPPreprocessor.cxx:3332
 AliGRPPreprocessor.cxx:3333
 AliGRPPreprocessor.cxx:3334
 AliGRPPreprocessor.cxx:3335
 AliGRPPreprocessor.cxx:3336
 AliGRPPreprocessor.cxx:3337
 AliGRPPreprocessor.cxx:3338
 AliGRPPreprocessor.cxx:3339
 AliGRPPreprocessor.cxx:3340
 AliGRPPreprocessor.cxx:3341
 AliGRPPreprocessor.cxx:3342
 AliGRPPreprocessor.cxx:3343
 AliGRPPreprocessor.cxx:3344
 AliGRPPreprocessor.cxx:3345
 AliGRPPreprocessor.cxx:3346
 AliGRPPreprocessor.cxx:3347
 AliGRPPreprocessor.cxx:3348
 AliGRPPreprocessor.cxx:3349
 AliGRPPreprocessor.cxx:3350
 AliGRPPreprocessor.cxx:3351
 AliGRPPreprocessor.cxx:3352
 AliGRPPreprocessor.cxx:3353
 AliGRPPreprocessor.cxx:3354
 AliGRPPreprocessor.cxx:3355
 AliGRPPreprocessor.cxx:3356
 AliGRPPreprocessor.cxx:3357
 AliGRPPreprocessor.cxx:3358
 AliGRPPreprocessor.cxx:3359
 AliGRPPreprocessor.cxx:3360
 AliGRPPreprocessor.cxx:3361
 AliGRPPreprocessor.cxx:3362
 AliGRPPreprocessor.cxx:3363
 AliGRPPreprocessor.cxx:3364
 AliGRPPreprocessor.cxx:3365
 AliGRPPreprocessor.cxx:3366
 AliGRPPreprocessor.cxx:3367
 AliGRPPreprocessor.cxx:3368
 AliGRPPreprocessor.cxx:3369
 AliGRPPreprocessor.cxx:3370
 AliGRPPreprocessor.cxx:3371
 AliGRPPreprocessor.cxx:3372
 AliGRPPreprocessor.cxx:3373
 AliGRPPreprocessor.cxx:3374
 AliGRPPreprocessor.cxx:3375
 AliGRPPreprocessor.cxx:3376
 AliGRPPreprocessor.cxx:3377
 AliGRPPreprocessor.cxx:3378
 AliGRPPreprocessor.cxx:3379
 AliGRPPreprocessor.cxx:3380
 AliGRPPreprocessor.cxx:3381
 AliGRPPreprocessor.cxx:3382
 AliGRPPreprocessor.cxx:3383
 AliGRPPreprocessor.cxx:3384
 AliGRPPreprocessor.cxx:3385
 AliGRPPreprocessor.cxx:3386
 AliGRPPreprocessor.cxx:3387
 AliGRPPreprocessor.cxx:3388
 AliGRPPreprocessor.cxx:3389
 AliGRPPreprocessor.cxx:3390
 AliGRPPreprocessor.cxx:3391
 AliGRPPreprocessor.cxx:3392
 AliGRPPreprocessor.cxx:3393
 AliGRPPreprocessor.cxx:3394
 AliGRPPreprocessor.cxx:3395
 AliGRPPreprocessor.cxx:3396
 AliGRPPreprocessor.cxx:3397
 AliGRPPreprocessor.cxx:3398
 AliGRPPreprocessor.cxx:3399
 AliGRPPreprocessor.cxx:3400
 AliGRPPreprocessor.cxx:3401
 AliGRPPreprocessor.cxx:3402
 AliGRPPreprocessor.cxx:3403
 AliGRPPreprocessor.cxx:3404
 AliGRPPreprocessor.cxx:3405
 AliGRPPreprocessor.cxx:3406
 AliGRPPreprocessor.cxx:3407
 AliGRPPreprocessor.cxx:3408
 AliGRPPreprocessor.cxx:3409
 AliGRPPreprocessor.cxx:3410
 AliGRPPreprocessor.cxx:3411
 AliGRPPreprocessor.cxx:3412
 AliGRPPreprocessor.cxx:3413
 AliGRPPreprocessor.cxx:3414
 AliGRPPreprocessor.cxx:3415
 AliGRPPreprocessor.cxx:3416
 AliGRPPreprocessor.cxx:3417
 AliGRPPreprocessor.cxx:3418
 AliGRPPreprocessor.cxx:3419
 AliGRPPreprocessor.cxx:3420
 AliGRPPreprocessor.cxx:3421
 AliGRPPreprocessor.cxx:3422
 AliGRPPreprocessor.cxx:3423
 AliGRPPreprocessor.cxx:3424
 AliGRPPreprocessor.cxx:3425
 AliGRPPreprocessor.cxx:3426
 AliGRPPreprocessor.cxx:3427
 AliGRPPreprocessor.cxx:3428
 AliGRPPreprocessor.cxx:3429
 AliGRPPreprocessor.cxx:3430
 AliGRPPreprocessor.cxx:3431
 AliGRPPreprocessor.cxx:3432
 AliGRPPreprocessor.cxx:3433
 AliGRPPreprocessor.cxx:3434
 AliGRPPreprocessor.cxx:3435
 AliGRPPreprocessor.cxx:3436
 AliGRPPreprocessor.cxx:3437
 AliGRPPreprocessor.cxx:3438
 AliGRPPreprocessor.cxx:3439
 AliGRPPreprocessor.cxx:3440
 AliGRPPreprocessor.cxx:3441
 AliGRPPreprocessor.cxx:3442
 AliGRPPreprocessor.cxx:3443
 AliGRPPreprocessor.cxx:3444
 AliGRPPreprocessor.cxx:3445
 AliGRPPreprocessor.cxx:3446
 AliGRPPreprocessor.cxx:3447
 AliGRPPreprocessor.cxx:3448
 AliGRPPreprocessor.cxx:3449
 AliGRPPreprocessor.cxx:3450
 AliGRPPreprocessor.cxx:3451
 AliGRPPreprocessor.cxx:3452
 AliGRPPreprocessor.cxx:3453
 AliGRPPreprocessor.cxx:3454
 AliGRPPreprocessor.cxx:3455
 AliGRPPreprocessor.cxx:3456
 AliGRPPreprocessor.cxx:3457
 AliGRPPreprocessor.cxx:3458
 AliGRPPreprocessor.cxx:3459
 AliGRPPreprocessor.cxx:3460
 AliGRPPreprocessor.cxx:3461
 AliGRPPreprocessor.cxx:3462
 AliGRPPreprocessor.cxx:3463
 AliGRPPreprocessor.cxx:3464
 AliGRPPreprocessor.cxx:3465
 AliGRPPreprocessor.cxx:3466
 AliGRPPreprocessor.cxx:3467
 AliGRPPreprocessor.cxx:3468
 AliGRPPreprocessor.cxx:3469
 AliGRPPreprocessor.cxx:3470
 AliGRPPreprocessor.cxx:3471
 AliGRPPreprocessor.cxx:3472
 AliGRPPreprocessor.cxx:3473
 AliGRPPreprocessor.cxx:3474
 AliGRPPreprocessor.cxx:3475
 AliGRPPreprocessor.cxx:3476
 AliGRPPreprocessor.cxx:3477
 AliGRPPreprocessor.cxx:3478
 AliGRPPreprocessor.cxx:3479
 AliGRPPreprocessor.cxx:3480
 AliGRPPreprocessor.cxx:3481
 AliGRPPreprocessor.cxx:3482
 AliGRPPreprocessor.cxx:3483
 AliGRPPreprocessor.cxx:3484
 AliGRPPreprocessor.cxx:3485
 AliGRPPreprocessor.cxx:3486
 AliGRPPreprocessor.cxx:3487
 AliGRPPreprocessor.cxx:3488