install(TARGETS ${MODULE}
ARCHIVE DESTINATION lib
LIBRARY DESTINATION lib)
-install(FILES ${HDRS} DESTINATION include)
\ No newline at end of file
+install(FILES ${HDRS} DESTINATION include)
+
+# Macros
+install(DIRECTORY macros DESTINATION ANALYSIS/ESDfilter)
\ No newline at end of file
LIBRARY DESTINATION lib)
install(FILES ${HDRS} DESTINATION include)
+# Install macros
+install(FILES AddTaskTender.C DESTINATION ANALYSIS/TenderSupplies)
+
message(STATUS "Build folder: ${AliRoot_BINARY_DIR}")
message(STATUS "Source folder: ${AliRoot_SOURCE_DIR}")
message(STATUS "Installation folder: ${CMAKE_INSTALL_PREFIX}")
-if(CMAKE_BUILD_TYPE)
- message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
-endif(CMAKE_BUILD_TYPE)
+
+# You can change the build type using
+# cmake -DCMAKE_BUILD_TYPE=DEBUG | RELEASE | RELWITHDEBINFO | MINSIZEREL ...
+if (NOT CMAKE_BUILD_TYPE)
+ set(CMAKE_BUILD_TYPE RELWITHDEBINFO)
+endif(NOT CMAKE_BUILD_TYPE)
+message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
+
if(CMAKE_INSTALL_PREFIX STREQUAL "${AliRoot_SOURCE_DIR}")
message(FATAL_ERROR "Please choose a different installation point than the source tree!")
# - GCC_MAJOR.GCC_MINOR.GCC_PATCH
include(CheckCompiler)
-# You can change the build type using
-# cmake -DCMAKE_BUILD_TYPE=DEBUG|RELEASE|RELWITHDEBINFO|MINSIZEREL...
-if (NOT CMAKE_BUILD_TYPE)
- set(CMAKE_BUILD_TYPE RELWITHDEBINFO)
-endif(NOT CMAKE_BUILD_TYPE)
+# Shared library suffix
+if (NOT CMAKE_SYSTEM_NAME STREQUAL Windows)
+ set(CMAKE_SHARED_LIBRARY_SUFFIX .so)
+endif (NOT CMAKE_SYSTEM_NAME STREQUAL Windows)
# ROOT dictionaries and maps
include(CMakeALICE)
endif()
endif(SHUTTLE)
-add_subdirectory(ALIROOT)
\ No newline at end of file
+add_subdirectory(ALIROOT)
endif(DA)
# Install the macros, docs
-install(DIRECTORY macros DESTINATION ACORDE)
-install(DIRECTORY doc DESTINATION ACORDER)
+install(DIRECTORY macros DESTINATION EMCAL)
+install(DIRECTORY doc DESTINATION EMCAL)
message(STATUS "EMCAL enabled")
${AliRoot_SOURCE_DIR}/STEER/STEERBase
)
+option(USE_DLOPEN "Use \"dlopen()\" in favor of \"gSystem->Load()\" to load HLT component libraries." OFF)
+
+if(USE_DLOPEN)
+ add_definitions(-DHAVE_DLFCN_H)
+ message(STATUS "Using dlopen() for HLT component libs.")
+endif(USE_DLOPEN)
+
# Sources in alphabetical order
set(SRCS
AliHLTBlockDataCollection.cxx
add_subdirectory(shuttle)
add_subdirectory(sim)
+include("CMakehltdoc.conf")
+
message(STATUS "HLT enabled")
#for convenience
set(CAGPUDIR ${AliRoot_SOURCE_DIR}/HLT/TPCLib/tracking-ca/cagpu)
+# Module include folder
+include_directories(${AliRoot_SOURCE_DIR}/HLT/TPCLib/tracking-ca/cagpu/cuda
+ ${AliRoot_SOURCE_DIR}/HLT/TPCLib/tracking-ca/cagpu
+ ${AliRoot_SOURCE_DIR}/HLT/TPCLib/tracking-ca
+ )
+
+# Additional include folders in alphabetical order except ROOT
+include_directories(${ROOT_INCLUDE_DIRS}
+ ${AliRoot_SOURCE_DIR}/HLT/BASE
+ )
+
#nvcc fails with std=c++11, remove it temporarily
string(FIND ${CMAKE_CXX_FLAGS} "-std=c++11" STDCXX11FOUND )
if(STDCXX11FOUND GREATER -1)
# not sure why __ROOT__ is used here, could just as well be something else
set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/G__AliHLTTPCCAGPU.cxx PROPERTIES COMPILE_DEFINITIONS "cudaError_t=int;__ROOT__")
-# Module include folder
-include_directories(${AliRoot_SOURCE_DIR}/HLT/TPCLib/tracking-ca/cagpu/cuda
- ${AliRoot_SOURCE_DIR}/HLT/TPCLib/tracking-ca/cagpu
- ${AliRoot_SOURCE_DIR}/HLT/TPCLib/tracking-ca
- )
-
-# Additional include folders in alphabetical order except ROOT
-include_directories(${ROOT_INCLUDE_DIRS}
- ${AliRoot_SOURCE_DIR}/HLT/BASE
- )
-
# Sources in alphabetical order
set(SRCS
${CAGPUDIR}/AliHLTTPCCAGPUTrackerBase.cxx
)
# Headers from sources
-set(HDRS
+set(CINTHDRS
${CAGPUDIR}/AliHLTTPCCAGPUTrackerBase.h
AliHLTTPCCAGPUTrackerNVCC.h
- AliHLTTPCCAGPUTrackerCommon.h
+ )
+
+set(HDRS
+ ${CINTHDRS}
+ ${CAGPUDIR}/AliHLTTPCCAGPUTrackerCommon.h
)
# Generate the dictionary
# It will create G_ARG1.cxx and G_ARG1.h / ARG1 = function first argument
get_directory_property(incdirs INCLUDE_DIRECTORIES)
-generate_dictionary("${MODULE}" "${MODULE}LinkDef.h" "${HDRS}" "${incdirs}")
+generate_dictionary("${MODULE}" "" "${CINTHDRS}" "${incdirs}")
# Generate the ROOT map
# Dependecies
-set(LIBDEPS ${CUDA_LIBRARIES} cuda)
-generate_rootmap("${MODULE}" "${LIBDEPS}" "${CMAKE_CURRENT_SOURCE_DIR}/${MODULE}LinkDef.h")
+generate_rootmap("${MODULE}" "" "")
# Add a library to the project using the specified source files
add_library(${MODULE} SHARED ${SRCS} G__${MODULE}.cxx)
#CUDA run-time and driver
-target_link_libraries(${MODULE} ${CUDA_LIBRARIES} cuda)
+target_link_libraries(${MODULE} ${CUDA_LIBRARIES})
# Additional compilation flags
set_target_properties(${MODULE} PROPERTIES COMPILE_FLAGS "")
-*# Installation
+# Installation
install(TARGETS ${MODULE}
ARCHIVE DESTINATION lib
LIBRARY DESTINATION lib)
#convenience variables
set(CAGPUDIR ${AliRoot_SOURCE_DIR}/HLT/TPCLib/tracking-ca/cagpu)
+#libdir path
+link_directories(${AMDAPPSDKROOT}/lib/x86_64)
+
# build the OpenCL compile wrapper:
# -- checks the correct vendor implementation (AMD)
# -- builds binary code (blob) for the found platform(s)
add_executable(opencl_compiler ${CAGPUDIR}/makefiles/makefile_opencl_compiler.cpp)
-target_link_libraries(opencl_compiler -L${AMDAPPSDKROOT}/lib/x86_64 amdocl64 OpenCL)
+target_link_libraries(opencl_compiler amdocl64 OpenCL)
#convenience variables
-set(CL_SRC AliHLTTPCCAGPUTrackerOpenCL.cl )
+set(CL_SRC ${CAGPUDIR}/opencl/AliHLTTPCCAGPUTrackerOpenCL.cl )
set(CL_BIN ${CMAKE_CURRENT_BINARY_DIR}/AliHLTTPCCAGPUTrackerOpenCLCode.bin )
set(CL_INC
-I${AliRoot_SOURCE_DIR}/HLT/BASE
)
# Headers from sources
-set(HDRS
+set(CINTHDRS
${CAGPUDIR}/AliHLTTPCCAGPUTrackerBase.h
- ${CAGPUDIR}/AliHLTTPCCAGPUTrackerCommon.h
AliHLTTPCCAGPUTrackerOpenCL.h
+)
+
+set(HDRS
+ ${CINTHDRS}
+ ${CAGPUDIR}/AliHLTTPCCAGPUTrackerCommon.h
AliHLTTPCCAGPUTrackerOpenCLInternals.h
)
# Generate the dictionary
# It will create G_ARG1.cxx and G_ARG1.h / ARG1 = function first argument
get_directory_property(incdirs INCLUDE_DIRECTORIES)
-generate_dictionary("${MODULE}" "${MODULE}LinkDef.h" "${HDRS}" "${incdirs}")
+generate_dictionary("${MODULE}" "" "${CINTHDRS}" "${incdirs}")
# Generate the ROOT map
-# Dependecies
-set(LIBDEPS ${CUDA_LIBRARIES} cuda)
-generate_rootmap("${MODULE}" "${LIBDEPS}" "${CMAKE_CURRENT_SOURCE_DIR}/${MODULE}LinkDef.h")
+generate_rootmap("${MODULE}" "" "")
# Add a library to the project using the specified source files
add_library(${MODULE} SHARED ${SRCS} G__${MODULE}.cxx)
-#CUDA run-time and driver
-link_directories(${AMDAPPSDKROOT}/lib/x86_64)
-target_link_libraries(amdocl64 OpenCL)
-
-# Additional compilation flags
-set_target_properties(${MODULE} PROPERTIES COMPILE_FLAGS "")
+#MAD OpenCL run-time and driver
+target_link_libraries(${MODULE} amdocl64 OpenCL)
-*# Installation
+# Installation
install(TARGETS ${MODULE}
ARCHIVE DESTINATION lib
LIBRARY DESTINATION lib)
DISTRIBUTE_GROUP_DOC = NO
SUBGROUPING = YES
TYPEDEF_HIDES_STRUCT = NO
-SYMBOL_CACHE_SIZE = 0
#---------------------------------------------------------------------------
# Build related configuration options
DISTRIBUTE_GROUP_DOC = NO
SUBGROUPING = YES
TYPEDEF_HIDES_STRUCT = NO
-SYMBOL_CACHE_SIZE = 0
#---------------------------------------------------------------------------
# Build related configuration options
The full list of AliRoot configuration parameters
- CMAKE_INSTALL_PREFIX - mandatory standard CMake paramenter. It points to AliRoot installation directory.
- ROOTSYS - mandatory Root installation directory.
- - ALIEN - AliEn2 installation directory. This configuration parameter is mandatory if Root was build with
+ - ALIEN - AliEn2 root installation directory. This configuration parameter is mandatory if Root was build with
AliEn2 support
- FASTJET - FastJet installation point
- ZEROMQ - ZeroMQ custom installation point. Not needed if ZeroMQ is installed on the system.
#include "AliESDEvent.h"
#include "AliESDtrack.h"
- #include "UPGRADE/AliITSUClusterPix.h"
- #include "UPGRADE/AliITSULoader.h"
+ #include "AliITSUClusterPix.h"
+ #include "AliITSULoader.h"
#endif
Int_t GoodTracksITS(const Char_t *dir=".");
#include "AliESDEvent.h"
#include "AliESDtrack.h"
- #include "UPGRADE/AliITSUClusterPix.h"
- #include "UPGRADE/AliITSULoader.h"
+ #include "AliITSUClusterPix.h"
+ #include "AliITSULoader.h"
#endif
Int_t GoodTracksCooked(const Char_t *dir=".");
#include "AliESDEvent.h"
#include "AliESDtrack.h"
- #include "Base/AliSimDigits.h"
- #include "Base/AliTPCParamSR.h"
- #include "Base/AliTPCLoader.h"
- #include "Base/AliTPCcalibDB.h"
- #include "Sim/AliTPC.h"
- #include "Rec/AliTPCClustersRow.h"
+ #include "AliSimDigits.h"
+ #include "AliTPCParamSR.h"
+ #include "AliTPCLoader.h"
+ #include "AliTPCcalibDB.h"
+// #include "AliTPC.h"
+ #include "AliTPCClustersRow.h"
#include "AliCDBManager.h"
#endif
return 2;
}
- AliTPC *TPC=(AliTPC*)rl->GetAliRun()->GetDetector("TPC");
- Int_t ver = TPC->IsVersion();
+ //AliTPC *TPC=(AliTPC*)rl->GetAliRun()->GetDetector("TPC");
+ Int_t ver = 2; //TPC->IsVersion();
cout<<"TPC version "<<ver<<" has been found !\n";
if (ver==1) tpcl->LoadRecPoints();
else if (ver==2) tpcl->LoadDigits();
#include "AliESDEvent.h"
#include "AliESDtrack.h"
- #include "UPGRADE/AliITSUClusterPix.h"
- #include "UPGRADE/AliITSULoader.h"
- #include "UPGRADE/AliITSUGeomTGeo.h"
+ #include "AliITSUClusterPix.h"
+ #include "AliITSULoader.h"
+ #include "AliITSUGeomTGeo.h"
#endif
#include "TFile.h"
#include "TTree.h"
#include "TH1F.h"
-#include "../ITS/UPGRADE/AliITSUClusterPix.h"
-#include "../ITS/UPGRADE/AliITSURecoLayer.h"
-#include "../ITS/UPGRADE/AliITSURecoDet.h"
-#include "../ITS/UPGRADE/AliITSUHit.h"
-#include "../ITS/UPGRADE/AliITSUGeomTGeo.h"
+#include "AliITSUClusterPix.h"
+#include "AliITSURecoLayer.h"
+#include "AliITSURecoDet.h"
+#include "AliITSUHit.h"
+#include "AliITSUGeomTGeo.h"
#include "AliITSsegmentation.h"
#include "AliGeomManager.h"
#include "AliStack.h"
--- /dev/null
+PMD Codes
+++++++++++++++++++++++++++
+Author: Satyajit Jena
+Tue Dec 16 17:12:47 CET 2014
++++++++++++++++++++++++++
+
+CMakeLists.txt : List of modules
+
+PMDbase: PMD base classes
+PMDsim : Simulation Module
+PMDrec : Reconstructoin Module
+DA : Detector Algorithm Module
+
+anal
+ : Analysis related codes, calibration, cleanup
+ : template reader
+
+info/
+ : To keep brief infos
+
+data/
+ : Ascii mapping info + some default data
+macro/
+ : Contains all Example Files
+
+Readme.txt : This file
+
--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+#include "Riostream.h"
+#include "TChain.h"
+#include "TTree.h"
+#include "TH1F.h"
+#include "TH2F.h"
+#include "TCanvas.h"
+#include "TList.h"
+
+#include "AliAnalysisTaskSE.h"
+#include "AliAnalysisManager.h"
+#include "AliStack.h"
+#include "AliESDtrackCuts.h"
+#include "AliESDEvent.h"
+#include "AliVEvent.h"
+#include "AliESDInputHandler.h"
+#include "AliAODEvent.h"
+#include "AliMCEvent.h"
+#include "AliESDPmdTrack.h"
+
+#include "AliPmdCustomCalibTask.h"
+
+/*------------------------------------------------------------------------
+ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+ .
+ . PMD Offiline Calibration Task to run Over
+ . ESDs - can be used in user task
+ . - runs for single module in both plan
+ . - Centrality is not needed for PbPb
+ . - (Let me know if you need any updates)
+ .
+ . Satyajit Jena, IIT Bombay
+ . sjena@cern.ch
+ . 3/8/2011
+ .
+ .
+ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+ ------------------------------------------------------------------------*/
+
+ClassImp(AliPmdCustomCalibTask)
+
+//________________________________________________________________________
+AliPmdCustomCalibTask::AliPmdCustomCalibTask() : AliAnalysisTaskSE(),
+ fOutput(0),
+ fSmn(10),
+ fHistAdcPre(0),
+ fHistAdcCpv(0),
+ fHistClusterXYPre(0),
+ fHistClusterXYCpv(0) {
+ for(Int_t i =0;i<48;i++) {
+ for(Int_t j=0;j<96;j++) {
+ fHistAdcPreRC[i][j] = NULL;
+ fHistAdcCpvRC[i][j] = NULL;
+ }
+ }
+}
+
+//________________________________________________________________________
+AliPmdCustomCalibTask::AliPmdCustomCalibTask(const char *name)
+ :AliAnalysisTaskSE(name),
+ fOutput(0),
+ fSmn(10),
+ fHistAdcPre(0),
+ fHistAdcCpv(0),
+ fHistClusterXYPre(0),
+ fHistClusterXYCpv(0) {
+ for(Int_t i =0;i<48;i++) {
+ for(Int_t j=0;j<96;j++) {
+ fHistAdcPreRC[i][j] = NULL;
+ fHistAdcCpvRC[i][j] = NULL;
+ }
+ }
+ DefineOutput(1, TList::Class()); }
+
+//________________________________________________________________________
+AliPmdCustomCalibTask::~AliPmdCustomCalibTask() {
+ if (fOutput && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) delete fOutput;
+}
+
+//________________________________________________________________________
+void AliPmdCustomCalibTask::UserCreateOutputObjects() {
+ fOutput = new TList();
+ fOutput->SetOwner(kTRUE);
+
+ // Module wise ADC
+ fHistAdcPre = new TH1F("fHistAdcPre", "ADC Distribution for PRE module", 120, 0, 1200);
+ fHistAdcCpv = new TH1F("fHistAdcCpv", "ADC Distribution for CPV module", 120, 0, 1200);
+
+ // XY QA
+ fHistClusterXYPre = new TH2F("fHistClusterXYPre", "ClusterX-Y Plot for PRE module", 400,-200,200,400,-200,200);
+ fHistClusterXYCpv = new TH2F("fHistClusterXYCpv", "ClusterX-Y Plot for CPV module", 400,-200,200,400,-200,200);
+
+ fOutput->Add(fHistAdcPre);
+ fOutput->Add(fHistAdcCpv);
+ fOutput->Add(fHistClusterXYPre);
+ fOutput->Add(fHistClusterXYCpv);
+
+ Char_t *name = new Char_t[100];
+ Char_t *title = new Char_t[200];
+
+ // Cell-wise ADC
+ for(Int_t i = 0; i < 48; i++) {
+ for(Int_t j = 0; j < 96; j++) {
+ sprintf(name,"fHistPreAdcRaw%02dCol%02d",i,j);
+ sprintf(title,"ADC Distribution for PRE | SM %d - Raw%02dCol%02d",fSmn,i,j);
+ fHistAdcPreRC[i][j] = new TH1F(name,title,120,0,1200);
+ fOutput->Add(fHistAdcPreRC[i][j]);
+
+ sprintf(name,"fHistCpvAdcRaw%02dCol%02d",i,j);
+ sprintf(title,"ADC Distribution for CPV | SM %d - Raw%02dCol%02d",fSmn,i,j);
+ fHistAdcCpvRC[i][j] = new TH1F(name,title,120,0,1200);
+ fOutput->Add(fHistAdcCpvRC[i][j]);
+ }
+ }
+
+ PostData(1, fOutput);
+}
+
+//________________________________________________________________________
+void AliPmdCustomCalibTask::UserExec(Option_t *) {
+ AliVEvent *event = InputEvent();
+
+ if (!event) { Printf("ERROR: Could not retrieve event"); return; }
+ AliESDEvent* esd = dynamic_cast<AliESDEvent*>(event);
+ if (!esd) {
+ AliError("Cannot get the ESD event");
+ return;
+ }
+
+
+
+ Int_t npmdcl = esd->GetNumberOfPmdTracks();
+
+ while (npmdcl--) {
+ AliESDPmdTrack *pmdtr = esd->GetPmdTrack(npmdcl);
+
+ Int_t smn = pmdtr->GetSmn();
+
+ if (smn != fSmn) continue; // if not the SM go back
+
+ Float_t adc = pmdtr->GetClusterADC();
+ if(adc>1200) continue;
+
+ Float_t sTag = pmdtr->GetClusterSigmaX();
+ if(sTag < 999. || sTag > 1000.) continue; // Isolated Cell Section
+
+ Int_t det = pmdtr->GetDetector();
+
+ Float_t clsX = pmdtr->GetClusterX();
+ Float_t clsY = pmdtr->GetClusterY();
+
+ Float_t sRowCol = pmdtr->GetClusterSigmaY();
+ Int_t row = (Int_t)sRowCol/100;
+ Int_t col = (Int_t)sRowCol - row*100;
+
+ if(det == 0) {
+ fHistAdcPre->Fill(adc);
+ fHistAdcPreRC[row][col]->Fill(adc);
+ fHistClusterXYPre->Fill(clsX,clsY);
+ } else if(det == 1) {
+ fHistAdcCpv->Fill(adc);
+ fHistAdcCpvRC[row][col]->Fill(adc);
+ fHistClusterXYCpv->Fill(clsX,clsY);
+ }
+ }
+
+ PostData(1, fOutput);
+}
+
+//________________________________________________________________________
+void AliPmdCustomCalibTask::Terminate(Option_t *) {
+ fOutput = dynamic_cast<TList*> (GetOutputData(1));
+ if(!fOutput) { Printf("ERROR: could not retrieve TList fOutput"); return; }
+}
+
+
--- /dev/null
+#ifndef AliPmdCustomCalibTask_h
+#define AliPmdCustomCalibTask_h
+
+
+/*------------------------------------------------------------------------
+ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+ . Satyajit Jena, IIT Bombay
+ . sjena@cern.ch
+ . 3/8/2011
+ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+ ------------------------------------------------------------------------*/
+
+class TH1F;
+class TH2F;
+class TList;
+
+#ifndef ALIANALYSISTASKSE_H
+#include "AliAnalysisTaskSE.h"
+#endif
+
+class AliPmdCustomCalibTask : public AliAnalysisTaskSE {
+ public:
+ AliPmdCustomCalibTask();
+ AliPmdCustomCalibTask(const char *name);
+ virtual ~AliPmdCustomCalibTask();
+
+ virtual void UserCreateOutputObjects();
+ virtual void UserExec(Option_t *option);
+ virtual void Terminate(Option_t *);
+
+ void SetSmn(Int_t i ) {fSmn = i; }
+
+
+ private:
+
+ TList *fOutput; //! Output list
+ Int_t fSmn; //! Module under Consideration
+ TH1F *fHistAdcPre; //! ADC spectrum for PRE for entire module
+ TH1F *fHistAdcCpv; //! ADC spectrum for CPV for entire module
+ TH2F *fHistClusterXYPre; //! cluster XY for PRE for entire module
+ TH2F *fHistClusterXYCpv; //! cluster XY for CPV for entir module
+
+ TH1F *fHistAdcPreRC[48][96]; //! cell-wise ADC PRE
+ TH1F *fHistAdcCpvRC[48][96]; //! cell-wise ADC CPV
+
+ AliPmdCustomCalibTask(const AliPmdCustomCalibTask&); // not implemented
+ AliPmdCustomCalibTask& operator=(const AliPmdCustomCalibTask&); // not implemented
+
+ ClassDef(AliPmdCustomCalibTask, 1); // example of analysis
+};
+
+#endif
+
else
fSimpleOfflineTriggers->GetPosition(globCol, globRow);
- // In case of level0 reject triggers with an odd row-col combination
- // if(type == kTMEMCalLevel0 && (globRow % 2 != 0 || globCol % 2 != 0)) return 0;
-
// get the absolute trigger ID
Int_t absId=-1;
fGeom->GetAbsFastORIndexFromPositionInEMCAL(globCol, globRow, absId);
trg.GetTriggerBits(tbits);
return tbits & (1 << fTriggerBitConfig->GetLevel0Bit());
} else {
- // For Data check from the level0 times if the trigger has fired at level0
+ // For Data check from the level0 times if the trigger has fired at level0,
+ // accept the patch only in case row and col are even
+ Int_t row, col;trg.GetPosition(row, col); // @MF: temporarily for understanding, under the asumption that the L0 algorithm has no overlapping fast-ors, to be replaced by a refined trigger patch selection based on ADC above threshold
+ if(row %2 || col % 2) return false;
Int_t nl0times(0);
Bool_t l0fired(kFALSE);
trg.GetNL0Times(nl0times);
# Installing the macros
install (DIRECTORY macros DESTINATION PWG/EMCAL)
+install (DIRECTORY data DESTINATION PWG/EMCAL)
class AliAnalysisTaskAOD2MuonAOD : public AliAnalysisTaskSE
{
public:
- AliAnalysisTaskAOD2MuonAOD(Int_t mcMode=1, Bool_t withSPDTracklets=kFALSE);
+ AliAnalysisTaskAOD2MuonAOD(Int_t mcMode=3, Bool_t withSPDTracklets=kTRUE);
virtual ~AliAnalysisTaskAOD2MuonAOD();
virtual void UserCreateOutputObjects();
# Sources - alphabetical order
set(SRCS
AliAnalysisTaskMuMu.cxx
- AliHistogramCollection.cxx
+ AliHistogramCollection.cxx
+ AliAnalysisTaskAOD2MuonAOD.cxx
AliAnalysisTaskESDMuonFilter.cxx
AliAnalysisTaskMuonAODfromGeneral.cxx
AliAnalysisTaskFromStandardToMuonAOD.cxx
TString part = from(ix,from.Length()-ix+1);
TObjArray* tmp = part.Tokenize(".");
TObjString* ostr = static_cast<TObjString*>(tmp->First());
- if (!ostr) break;
+ if (!ostr)
+ {
+ std::cerr << "Could not get filter ??? Filename does not look right !!!" << std::endl;
+ return -2;
+ }
filterName = ostr->String();
delete tmp;
ix = filterName.Index("_WITH_");
gSystem->Load("libCDB");
gSystem->Load("libSTEER");
gSystem->Load("libANALYSISalice");
-
- // gSystem->Load("libCORRFW");
- // gSystem->Load("libPWGmuon");
-
- gROOT->LoadMacro("AliAnalysisNonMuonTrackCuts.cxx+");
- gROOT->LoadMacro("AliAnalysisNonPrimaryVertices.cxx+");
- gROOT->LoadMacro("AliAODMuonReplicator.cxx+");
- gROOT->LoadMacro("AliAnalysisTaskESDMuonFilter.cxx+");
- gROOT->LoadMacro("AliAnalysisTaskAOD2MuonAOD.cxx+");
+ gSystem->Load("libCORRFW");
+ gSystem->Load("libPWGmuon");
}
#pragma link off all functions;
#pragma link C++ class AliAODEventInfo+;
+#pragma link C++ class AliAnalysisTaskAOD2MuonAOD+;
#pragma link C++ class AliAnalysisTaskMuonAODfromGeneral+;
#pragma link C++ class AliAnalysisTaskFromStandardToMuonAOD+;
#pragma link C++ class AliAnalysisTaskSingleMu+;
GetTrIso(clsVec, triso, trphiband, trcore);
Int_t nInConePairs = 0;
Double_t onePairMass = 0;
- if(c->GetM02()>0.1 && c->GetM02()<0.3 && isCPV){
- TObjArray *inConeInvMassArr = (TObjArray*)fInConeInvMass.Tokenize(";");
- TObjArray *inConePairClEt = (TObjArray*)fInConePairClEt.Tokenize(";");
- nInConePairs = inConeInvMassArr->GetEntriesFast();
- Int_t nInConePi0 = inConePairClEt->GetEntriesFast();
- if(nInConePairs != nInConePi0)
- printf("Inconsistent number of in cone pairs!!!\n");
- for(int ipair=0;ipair<nInConePairs;ipair++){
- TObjString *obs = (TObjString*)inConeInvMassArr->At(ipair);
- TObjString *obet = (TObjString*)inConePairClEt->At(ipair);
- TString smass = obs->GetString();
- TString spairEt = obet->GetString();
- Double_t pairmass = smass.Atof();
- Double_t pairEt = spairEt.Atof();//this must be zero when inv mass outside pi0 range
- if(0==ipair && nInConePairs==1)
- onePairMass = pairmass;
- if(fDebug)
- printf("=================+++++++++++++++Inv mass inside the cone for photon range: %1.1f,%1.1f,%1.1f+-++++-+-+-+-++-+-+-\n",Et,pairmass,ceiso+triso);
- fEtCandIsoAndIsoWoPairEt->Fill(Et,ceiso+triso,ceiso+triso-pairEt);
- }
+ //---
+ //if(c->GetM02()>0.1 && c->GetM02()<0.3 && isCPV){
+ TObjArray *inConeInvMassArr = (TObjArray*)fInConeInvMass.Tokenize(";");
+ TObjArray *inConePairClEt = (TObjArray*)fInConePairClEt.Tokenize(";");
+ nInConePairs = inConeInvMassArr->GetEntriesFast();
+ Int_t nInConePi0 = inConePairClEt->GetEntriesFast();
+ if(nInConePairs != nInConePi0)
+ printf("Inconsistent number of in cone pairs!!!\n");
+ for(int ipair=0;ipair<nInConePairs;ipair++){
+ TObjString *obs = (TObjString*)inConeInvMassArr->At(ipair);
+ TObjString *obet = (TObjString*)inConePairClEt->At(ipair);
+ TString smass = obs->GetString();
+ TString spairEt = obet->GetString();
+ Double_t pairmass = smass.Atof();
+ Double_t pairEt = spairEt.Atof();//this must be zero when inv mass outside pi0 range
+ if(0==ipair && nInConePairs==1)
+ onePairMass = pairmass;
+ if(fDebug)
+ printf("=================+++++++++++++++Inv mass inside the cone for photon range: %1.1f,%1.1f,%1.1f+-++++-+-+-+-++-+-+-\n",Et,pairmass,ceiso+triso);
+ fEtCandIsoAndIsoWoPairEt->Fill(Et,ceiso+triso,ceiso+triso-pairEt);
}
+ //}
+ //---
Double_t dr = TMath::Sqrt(c->GetTrackDx()*c->GetTrackDx() + c->GetTrackDz()*c->GetTrackDz());
if(Et>10 && Et<15 && dr>0.025){
fHigherPtConeM02->Fill(fHigherPtCone,c->GetM02());
if(lpair.M()>0.11 && lpair.M()<0.165){
fInConePairedClusEtVsCandEt->Fill(EtCl,Et);
fInConePairClEt += Form("%f;",Et);
- continue;
+ //continue;
}
else
fInConePairClEt += Form("%f;",0.0);
- if(lpair.M()>0.52 && lpair.M()<0.58)
- continue;
+ /*if(lpair.M()>0.52 && lpair.M()<0.58)
+ continue;*/
}
totiso += nEt;
if(R<0.04)
# Install the macros
install(DIRECTORY PHOS_PbPb DESTINATION PWGGA/PHOSTasks)
install(DIRECTORY UserTasks/macros DESTINATION PWGGA/PHOSTasks/UserTasks)
+install(DIRECTORY CaloCellQA/macros DESTINATION PWGGA/PHOSTasks/CaloCellQA)
+install(DIRECTORY PHOS_PbPbQA/macros DESTINATION PWGGA/PHOSTasks/PHOS_PbPbQA)
+install(DIRECTORY PHOS_TriggerQA/macros DESTINATION PWGGA/PHOSTasks/PHOS_TriggerQA)
install(FILES PHOS_Correlation/AddTaskPi0Correlations.C DESTINATION PWGGA/PHOSTasks/PHOS_Correlation)
install(FILES PHOS_EpRatio/AddTaskPHOSEpRatio.C DESTINATION PWGGA/PHOSTasks/PHOS_EpRatio)
-install(FILES PHOS_Tagging/AddTaskPHOSTagging.C DESTINATION PWGGA/PHOSTasks/PHOS_Tagging)
\ No newline at end of file
+install(FILES PHOS_Tagging/AddTaskPHOSTagging.C DESTINATION PWGGA/PHOSTasks/PHOS_Tagging)
+
SetCurrentOutputList(0);
- // Cuts
+ TH1* tmpHisto = AddHistogram1D<TH1D>("hVertexAcceptance", "Accepted vertices for different conditions", "", 4, 0, 4, "stage","N^{Events}/cut");
+ tmpHisto->GetXaxis()->SetBinLabel(1, "Triggered all");
+ tmpHisto->GetXaxis()->SetBinLabel(2, "Triggered w/ vertex");
+ tmpHisto->GetXaxis()->SetBinLabel(3, "Pile-up corrected all");
+ tmpHisto->GetXaxis()->SetBinLabel(4, "Pile-up corrected w vertex");
+
TH2* tmpHisto2D = AddHistogram2D<TH2D>("hCentrality", Form("Accepted events in centrality (%s)", fCentralityType.Data()), "COLZ", 102, 0., 102., 4, 0,4,"Centrality","Cut stage","dN^{Events}");
tmpHisto2D->GetYaxis()->SetBinLabel(1, "Before cuts");
tmpHisto2D->GetYaxis()->SetBinLabel(2, "After pile up");
tmpHisto2D->GetYaxis()->SetBinLabel(3, "After vertex demand");
tmpHisto2D->GetYaxis()->SetBinLabel(4, "After vertex cuts");
- TH1* tmpHisto = AddHistogram1D<TH1D>("hTrackAcceptance", "Accepted tracks (0 = before cuts, 1 = after eta, 2 = after pT)", "", 3, 0, 3, "stage","N^{Tracks}/cut");
+ tmpHisto = AddHistogram1D<TH1D>("hTrackAcceptance", "Accepted tracks (0 = before cuts, 1 = after eta, 2 = after pT)", "", 3, 0, 3, "stage","N^{Tracks}/cut");
tmpHisto->GetXaxis()->SetBinLabel(1, "Before cuts");
tmpHisto->GetXaxis()->SetBinLabel(2, "After eta");
tmpHisto->GetXaxis()->SetBinLabel(3, "After p_{T}");
if (!event)
return kFALSE;
- // ### Get centrality values
+ fPrimaryVertex = event->GetPrimaryVertex();
+
+ // ### Create plot for vertex acceptance
+ fHelperClass->SetMaxVtxZ(10000.);
+
+ // Check vertex existance
+ Bool_t hasVertex = kFALSE;
+ if(fUseDefaultVertexCut)
+ {
+ if(fHelperClass->IsVertexSelected2013pA(event))
+ hasVertex = kTRUE;
+ }
+ else
+ {
+ if(!fPrimaryVertex || (fPrimaryVertex->GetNContributors()<2) || (TMath::Sqrt(fPrimaryVertex->GetX()*fPrimaryVertex->GetX() + fPrimaryVertex->GetY()*fPrimaryVertex->GetY()) > 1.0))
+ hasVertex = kTRUE;
+ }
+
+ // All triggered events
+ FillHistogram("hVertexAcceptance", 0.5); // all triggered events all
+ if(hasVertex)
+ FillHistogram("hVertexAcceptance", 1.5); // all triggered events w/ vertex
+
+ // Pile-up corrected events
+ if(!fHelperClass->IsPileUpEvent(event))
+ {
+ FillHistogram("hVertexAcceptance", 2.5); // pile-up corr. events all
+ if(hasVertex)
+ FillHistogram("hVertexAcceptance", 3.5); // pile-up corr. events w/ vertex
+ }
+ fHelperClass->SetMaxVtxZ(10.);
+
+ // ### Get centrality values
AliCentrality* tmpCentrality = event->GetCentrality();
Double_t centralityPercentile = -1.0;
if (tmpCentrality != NULL)
FillHistogram("hCentrality", centralityPercentile, 1.5); // after pileup cut
// ### CUT STAGE 2: Existence of primary vertex
- fPrimaryVertex = event->GetPrimaryVertex();
- if(fUseDefaultVertexCut)
- {
- fHelperClass->SetMaxVtxZ(10000.);
- if(!fHelperClass->IsVertexSelected2013pA(event))
- {
- fHelperClass->SetMaxVtxZ(10.);
- return kFALSE;
- }
- fHelperClass->SetMaxVtxZ(10.);
- }
- else // Vertex cut for pp
- {
- if(!fPrimaryVertex || (fPrimaryVertex->GetNContributors()<2) || (TMath::Sqrt(fPrimaryVertex->GetX()*fPrimaryVertex->GetX() + fPrimaryVertex->GetY()*fPrimaryVertex->GetY()) > 1.0))
- return kFALSE;
- }
+ if(!hasVertex)
+ return kFALSE;
FillHistogram("hVertexZ",fPrimaryVertex->GetZ());
FillHistogram("hCentrality", centralityPercentile, 2.5); // after vertex existance cut
//If there's no background subtraction rhoval=0 and momentum is simply not took into account
AliRhoParameter *rho = 0;
Double_t rhoval = 0;
- TString sname("Rho");
- if (!sname.IsNull()) {
- rho = dynamic_cast<AliRhoParameter*>(InputEvent()->FindListObject(sname));
+ if (!fJetCont->GetRhoName().IsNull()) {
+ rho = dynamic_cast<AliRhoParameter*>(InputEvent()->FindListObject(fJetCont->GetRhoName()));
if(rho) rhoval = rho->GetVal();
}
//It corrects the jet momentum due to D daughters out of the jet
RecalculateMomentum(pjet,fPmissing);
fPtJet=TMath::Sqrt(pjet[0]*pjet[0]+pjet[1]*pjet[1]); //recalculated jet pt
-
+ if((jet->Pt()-jet->Area()*rhoval)<0) fPtJet = -fPtJet;
//debugging histograms
Double_t pmissing=TMath::Sqrt(fPmissing[0]*fPmissing[0]+fPmissing[1]*fPmissing[1]+fPmissing[2]*fPmissing[2]); //recalculated jet total momentum
//It corrects the jet momentum due to D daughters out of the jet
RecalculateMomentum(pjet,fPmissing);
fPtJet=TMath::Sqrt(pjet[0]*pjet[0]+pjet[1]*pjet[1]); //recalculated jet pt
-
+ if((jet->Pt()-jet->Area()*rhoval)<0) fPtJet = -fPtJet;
SideBandBackground(sbcand,jet);
}
//It corrects the jet momentum due to D daughters out of the jet
RecalculateMomentum(pjet,fPmissing);
fPtJet=TMath::Sqrt(pjet[0]*pjet[0]+pjet[1]*pjet[1]); //recalculated jet pt
-
+ if((jet->Pt()-jet->Area()*rhoval)<0) fPtJet = -fPtJet;
MCBackground(charmbg,jet);
}
}
//It corrects the each component of the jet momentum for Z calculation
AliRhoParameter *rho = 0;
Double_t rhoval = 0;
- TString sname("Rho");
- if (!sname.IsNull()) {
- rho = dynamic_cast<AliRhoParameter*>(InputEvent()->FindListObject(sname));
+ if (!fJetCont->GetRhoName().IsNull()) {
+ rho = dynamic_cast<AliRhoParameter*>(InputEvent()->FindListObject(fJetCont->GetRhoName()));
if(rho){
rhoval = rho->GetVal();
pj[0] = jet->Px() - jet->Area()*(rhoval*TMath::Cos(jet->AreaPhi()));
fOutput->Add(fhstat);
const Int_t nbinsmass=300;
- const Int_t nbinsptjet=500;
+ const Int_t nbinspttrack=500;
+ Int_t nbinsptjet=500;
+ if(!fJetCont->GetRhoName().IsNull()) nbinsptjet=400;
const Int_t nbinsptD=100;
const Int_t nbinsz=100;
const Int_t nbinsphi=200;
const Int_t nbinsSpsContrib=100;
const Int_t nbinsSpsA=100;
- const Float_t ptjetlims[2]={0.,200.};
+ const Float_t pttracklims[2]={0.,200.};
+ Float_t ptjetlims[2]={0.,200.};
+ if(!fJetCont->GetRhoName().IsNull()) ptjetlims[0]=-200.;
const Float_t ptDlims[2]={0.,50.};
const Float_t zlims[2]={0.,1.2};
const Float_t philims[2]={0.,6.3};
fhPhiJetTrks->Sumw2();
fhEtaJetTrks = new TH1F("hEtaJetTrks","Jet tracks #eta distribution; #eta", nbinseta,etalims[0],etalims[1]);
fhEtaJetTrks->Sumw2();
- fhPtJetTrks = new TH1F("hPtJetTrks", "Jet tracks Pt distribution; p_{T} (GeV/c)",nbinsptjet,ptjetlims[0],ptjetlims[1]);
+ fhPtJetTrks = new TH1F("hPtJetTrks", "Jet tracks Pt distribution; p_{T} (GeV/c)",nbinspttrack,pttracklims[0],pttracklims[1]);
fhPtJetTrks->Sumw2();
fhEjet = new TH1F("hEjet", "Jet energy distribution;Energy (GeV)",500,0,200);
Double_t phi1=p1->Phi(),eta1=p1->Eta();
//It subtracts the backgroud of jets if it was asked for it.
- TString sname("Rho");
- if (!sname.IsNull()) {
+
+ if (!fJetCont->GetRhoName().IsNull()) {
AliRhoParameter *rho = 0;
- rho = dynamic_cast<AliRhoParameter*>(InputEvent()->FindListObject(sname));
+ rho = dynamic_cast<AliRhoParameter*>(InputEvent()->FindListObject(fJetCont->GetRhoName()));
if(rho){
Double_t pj[3];
Bool_t okpj=p1->PxPyPz(pj);
//jetCont->SetJetAcceptanceType(cutType);
jetCont->SetJetPtCut(jptcut);
jetCont->SetPercAreaCut(percjetareacut);
+ jetCont->SetRhoName(rhoname);
}
taskCorr->SetMC(theMCon);
taskCorr->SetUseReco(reco);
install(DIRECTORY macros DESTINATION PWGPP)
install(DIRECTORY CalibMacros DESTINATION PWGPP)
install(DIRECTORY PilotTrain DESTINATION PWGPP)
+install(DIRECTORY CalibMacros DESTINATION PWGPP)
install(FILES HMPID/AddTaskHmpidQA.C DESTINATION PWGPP/HMPID)
install(FILES T0/AddTaskT0QA.C DESTINATION PWGPP/T0)
install(FILES TOF/AddTaskTOFQA.C
${AliRoot_SOURCE_DIR}/STEER/STEERBase
)
-link_directories(${ROOT_LIBDIR})
-
-# ROOT libraries that are not in root-config --libs
-set(ROOT_DEPENDENCIES Geom VMC Minuit)
-set(ALIROOT_DEPENDENCIES STEERBase ESD MDC RAWDatabase RAWDatarec)
-
# Create an object to be reused in case of static libraries
# Otherwise the sources will be compiled twice
add_library(${MODULE}-object OBJECT alimdc_main.cxx)
# Add a library to the project using the object
add_executable(${MODULE} $<TARGET_OBJECTS:${MODULE}-object>)
-target_link_libraries(${MODULE} STEERBase ESD MDC RAWDatabase RAWDatarec ${ROOT_DEPENDENCIES} ${ROOT_LIBRARIES})
+target_link_libraries(${MODULE} STEERBase ESD MDC RAWDatabase RAWDatarec)
# Compile and link flags
set(MODULE_COMPILE_FLAGS)
set(MODULE_LINK_FLAGS "${DATE_LDFLAGS} ${DATE_LIBS}")
endif(DATE_FOUND)
-# Additional compilation and linking flags
-set(MODULE_COMPILE_FLAGS " ${MODULE_COMPILE_FLAGS}")
-
-# System dependent: Modify the way the library is build
-if(${CMAKE_SYSTEM} MATCHES Darwin)
- set(MODULE_LINK_FLAGS "-undefined dynamic_lookup ${MODULE_LINK_FLAGS}")
-endif(${CMAKE_SYSTEM} MATCHES Darwin)
-
# Setting target compile and linking flags
set_target_properties(${MODULE} PROPERTIES COMPILE_FLAGS "${MODULE_COMPILE_FLAGS}")
set_target_properties(${MODULE} PROPERTIES LINK_FLAGS "${MODULE_LINK_FLAGS}")
# install RPM into $CMAKE_INSTALL_PREFIX/darpms
install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/alimdc-rpm/RPMS/ DESTINATION mdcrpm PATTERN "\\.rpm")
-endif(MDCRPM)
\ No newline at end of file
+endif(MDCRPM)
include_directories(${AliRoot_SOURCE_DIR}/${MODULE})
-# Aditional include folders in alphabetical order except ROOT
-include_directories(${ROOT_INCLUDE_DIRS}
- ${AliRoot_SOURCE_DIR}/RAW/RAWDatabase
- ${AliRoot_SOURCE_DIR}/RAW/RAWDatarec
- ${AliRoot_SOURCE_DIR}/STEER/STEERBase
- )
-
-
-link_directories(${ROOT_LIBDIR})
-
-# Aditional ROOT libraries that are not shoed by root-config --libs
-set(ROOTEXTRALIBS Geom VMC Minuit)
-
# Add an executable to the project using the specified source files
add_executable(${MODULE} dateStream.cxx)
-target_link_libraries(${MODULE} STEERBase RAWDatabase ${ROOTEXTRALIBS} ${ROOT_LIBRARIES})
-# compile and link flags
+# compile and link flags from DATE (probably not needed)
set(MODULE_COMPILE_FLAGS)
set(MODULE_LINK_FLAGS)
set(MODULE_LINK_FLAGS "${DATE_LDFLAGS} ${DATE_LIBS}")
endif(DATE_FOUND)
-# Additional compilation and linking flags
-set(MODULE_COMPILE_FLAGS " ${MODULE_COMPILE_FLAGS}")
-
-# System dependent: Modify the way the library is build
-if(${CMAKE_SYSTEM} MATCHES Darwin)
- set(MODULE_LINK_FLAGS "-undefined dynamic_lookup ${MODULE_LINK_FLAGS}")
-endif(${CMAKE_SYSTEM} MATCHES Darwin)
-
# Setting target compile and linking flags
set_target_properties(${MODULE} PROPERTIES COMPILE_FLAGS "${MODULE_COMPILE_FLAGS}")
set_target_properties(${MODULE} PROPERTIES LINK_FLAGS "${MODULE_LINK_FLAGS}")
/*
Unit test for some functions classes used in the $ALICE_ROOT/TPC/Base directory:
- gSystem->SetIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/ -I$ALICE_ROOT/include -I$ALICE_ROOT/STEER\
- -I$ALICE_ROOT/TPC -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TRD -I$ALICE_ROOT/TOF -I$ALICE_ROOT/RAW -I$ALICE_ROOT/PWG1 -I$ALICE_ROOT/STAT -I$ALICE_ROOT/TPC/Base -I$ALICE_ROOT/TPC/Calib");
-
+
+gSystem->SetIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/ -I$ALICE_ROOT/include -I$ALICE_ROOT/STEER -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TRD -I$ALICE_ROOT/TOF -I$ALICE_ROOT/RAW -I$ALICE_ROOT/STAT -I$ALICE_ROOT/TPC/TPCbase -I$ALICE_ROOT/TPCcalib");
+
+
.L $ALICE_ROOT/TPC/Base/test/UnitTest.C+
- UnitTestAliTPCCalPadTree();
- TestCorrection_AliTPCExBTwistAddCorrectionCompact();
- TestCorrection_AliTPCFCVoltError3DAddCorrectionCompact();
- TestCorrection_AliTPCRocVoltError3DAddCorrectionCompact();
- TestCorrection_AliTPCBoundaryVoltErrorAddCorrectionCompact();
+G UnitTestAliTPCCalPadTree();
+ TestCorrection_AliTPCCorrection_AddCorrectionCompact();
*/
#include "AliTPCFCVoltError3D.h"
#include "AliTPCROCVoltError3D.h"
#include "AliTPCBoundaryVoltError.h"
-
+#include "AliTPCCalibGlobalMisalignment.h"
+#include "AliCDBEntry.h"
+#include "TStopwatch.h"
+#include "TGeoMatrix.h"
+
//
// PARAMETERS to set from outside:
//
//
//
+Bool_t TestCorrection_AliTPCCorrection_AddCorrectionCompact();
+Bool_t TestCorrection_AliTPCExBTwistAddCorrectionCompact();
+Bool_t TestCorrection_AliTPCFCVoltError3DAddCorrectionCompact();
+Bool_t TestCorrection_AliTPCRocVoltError3DAddCorrectionCompact();
+Bool_t TestCorrection_AliTPCBoundaryVoltErrorAddCorrectionCompact();
+Bool_t TestCorrection_AliTPCCalibGlobalMisalignmentAddCorrectionCompact();
+Bool_t TestCorrection_AliTPCComposedCorrectionAddCorrectionCompact();
+
void UnitTestAliTPCCalPadTree(){
//
AliTPCExBTwist *twistY = new AliTPCExBTwist;
twistX->SetXTwist(0.001); // 1 mrad twist in x
twistY->SetYTwist(0.001); // 1 mrad twist in x
- isOK[0]&=compCorrTwist->AddCorrectionCompact(twistX,1);
- isOK[0]&=compCorrTwist->AddCorrectionCompact(twistY,1);
+ isOK[0]&=compCorrTwist->AddCorrectionCompact(twistX,0.5);
+ isOK[0]&=compCorrTwist->AddCorrectionCompact(twistY,0.5);
+ isOK[0]&=compCorrTwist->AddCorrectionCompact(twistX,0.5);
+ isOK[0]&=compCorrTwist->AddCorrectionCompact(twistY,0.5);
isOK[0]&=compCorrTwist->AddCorrectionCompact(twistY,-1);
isOK[0]&=compCorrTwist->AddCorrectionCompact(twistX,-1);
isOK[1]=compCorrTwist->GetCorrections()->GetEntries()==1;
+
AliTPCExBTwist *twistRes=0;
if (isOK[1]==kFALSE){
isOK[2]=kFALSE;
corr1->SetCopperRodShiftC(isec,TMath::Sin(TMath::Pi()*isec/36),kFALSE);
}
//
- isOK[0]&=compCorrComp->AddCorrectionCompact(corr0,1);
- isOK[0]&=compCorrComp->AddCorrectionCompact(corr1,1);
+ isOK[0]&=compCorrComp->AddCorrectionCompact(corr0,0.5);
+ isOK[0]&=compCorrComp->AddCorrectionCompact(corr1,0.5);
+ isOK[0]&=compCorrComp->AddCorrectionCompact(corr0,0.5);
+ isOK[0]&=compCorrComp->AddCorrectionCompact(corr1,0.5);
isOK[0]&=compCorrComp->AddCorrectionCompact(corr1,-1);
isOK[0]&=compCorrComp->AddCorrectionCompact(corr0,-1);
isOK[1]=compCorrComp->GetCorrections()->GetEntries()==1;
matrixDz*=0.5;
corr1->SetROCData(&matrixDz);
//
- isOK[0]&=compCorrROCVoltError3D->AddCorrectionCompact(corr0,1);
- isOK[0]&=compCorrROCVoltError3D->AddCorrectionCompact(corr1,1);
+ isOK[0]&=compCorrROCVoltError3D->AddCorrectionCompact(corr0,0.5);
+ isOK[0]&=compCorrROCVoltError3D->AddCorrectionCompact(corr1,0.5);
+ isOK[0]&=compCorrROCVoltError3D->AddCorrectionCompact(corr0,0.5);
+ isOK[0]&=compCorrROCVoltError3D->AddCorrectionCompact(corr1,0.5);
isOK[0]&=compCorrROCVoltError3D->AddCorrectionCompact(corr1,-1);
isOK[0]&=compCorrROCVoltError3D->AddCorrectionCompact(corr0,-1);
isOK[1]=compCorrROCVoltError3D->GetCorrections()->GetEntries()==1;
corr0->SetBoundariesA(boundaries);
corr1->SetBoundariesA(boundaries);
//
- isOK[0]&=compCorrBoundaryVoltError->AddCorrectionCompact(corr0,1);
- isOK[0]&=compCorrBoundaryVoltError->AddCorrectionCompact(corr1,1);
+ isOK[0]&=compCorrBoundaryVoltError->AddCorrectionCompact(corr0,0.5);
+ isOK[0]&=compCorrBoundaryVoltError->AddCorrectionCompact(corr1,0.5);
+ isOK[0]&=compCorrBoundaryVoltError->AddCorrectionCompact(corr0,0.5);
+ isOK[0]&=compCorrBoundaryVoltError->AddCorrectionCompact(corr1,0.5);
isOK[0]&=compCorrBoundaryVoltError->AddCorrectionCompact(corr1,-1);
isOK[0]&=compCorrBoundaryVoltError->AddCorrectionCompact(corr0,-1);
isOK[1]=compCorrBoundaryVoltError->GetCorrections()->GetEntries()==1;
}
return res;
}
+
+
+
+
+
+Bool_t TestCorrection_AliTPCCalibGlobalMisalignmentAddCorrectionCompact(){
+ //
+ // AliTPCCalibGlobalMisalignmentAddCorrectionCompact
+ // Invariant used in test is not exact it is only approximate - as matrix multiplication is not comulative
+ // !!!! BUG FOUND ????
+ // hmatrix1->GetTranslation()[idelta]=xxx; // does not work as expected Translation is set, visible in Print but not used later
+ const Float_t kEpsilon=0.0001;
+ Bool_t isOK[10]={kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE};
+ Double_t delta[3]={0.01,0.02,0.03};
+
+ AliTPCComposedCorrection *compCorrBoundaryVoltError = new AliTPCComposedCorrection();
+ AliTPCCalibGlobalMisalignment *corr0 = new AliTPCCalibGlobalMisalignment;
+ AliTPCCalibGlobalMisalignment *corr1 = new AliTPCCalibGlobalMisalignment;
+ AliTPCCalibGlobalMisalignment *corr2 = new AliTPCCalibGlobalMisalignment;
+ TObjArray sectorAlign(72);
+
+ TGeoHMatrix *hmatrix0 = new TGeoHMatrix;
+ TGeoHMatrix *hmatrix1 = new TGeoHMatrix;
+ hmatrix0->RotateX(TMath::RadToDeg()*0.0001);
+ hmatrix0->RotateY(TMath::RadToDeg()*0.0002);
+ hmatrix0->RotateZ(TMath::RadToDeg()*0.0003);
+ hmatrix1->SetTranslation(delta);
+ for (Int_t isec=0; isec<72; isec++){
+ if ((isec%2)==0) sectorAlign.AddAt(hmatrix0,isec);
+ if ((isec%2)==1) sectorAlign.AddAt(hmatrix1,isec);
+ }
+ corr0->SetAlignGlobal(hmatrix0);
+ corr1->SetAlignGlobal(hmatrix1);
+ corr0->SetAlignGlobalDelta(hmatrix1);
+ corr1->SetAlignGlobalDelta(hmatrix0);
+ corr2->SetAlignSectors(§orAlign);
+ //
+ isOK[0]&=compCorrBoundaryVoltError->AddCorrectionCompact(corr0,0.5);
+ isOK[0]&=compCorrBoundaryVoltError->AddCorrectionCompact(corr1,0.5);
+ isOK[0]&=compCorrBoundaryVoltError->AddCorrectionCompact(corr0,0.5);
+ isOK[0]&=compCorrBoundaryVoltError->AddCorrectionCompact(corr1,0.5);
+ isOK[0]&=compCorrBoundaryVoltError->AddCorrectionCompact(corr0,-1);
+ isOK[0]&=compCorrBoundaryVoltError->AddCorrectionCompact(corr1,-1);
+ //
+ isOK[0]&=compCorrBoundaryVoltError->AddCorrectionCompact(corr2,1);
+ isOK[0]&=compCorrBoundaryVoltError->AddCorrectionCompact(corr2,-1);
+ //
+ //
+ isOK[1]=compCorrBoundaryVoltError->GetCorrections()->GetEntries()==1;
+ AliTPCCalibGlobalMisalignment *corrRes=0;
+ if (isOK[1]==kFALSE){
+ isOK[2]=kFALSE;
+ isOK[3]=kFALSE;
+ isOK[4]=kFALSE;
+ }else{
+ corrRes= dynamic_cast<AliTPCCalibGlobalMisalignment *>(compCorrBoundaryVoltError->GetSubCorrection(0));
+ if (corrRes==NULL){
+ isOK[2]=kFALSE;
+ isOK[3]=kFALSE;
+ isOK[4]=kFALSE;
+ }else{
+ for (Int_t itrans=0; itrans<3; itrans++){
+ isOK[2+itrans]&=TMath::Abs(corrRes->GetAlignGlobal()->GetTranslation()[itrans])<kEpsilon;
+ for (Int_t isec=0; isec<72; isec++){
+ isOK[2+itrans]&=TMath::Abs(((TGeoHMatrix*)(corrRes->GetAlignSectors()->At(isec)))->GetTranslation()[itrans])<kEpsilon;
+ }
+ }
+ corrRes->GetAlignGlobal()->Print();
+ corrRes->GetAlignSectors()->At(0)->Print();
+ corrRes->GetAlignSectors()->At(1)->Print();
+ }
+ }
+ Bool_t res=kTRUE;
+ for (Int_t i=0; i<5; i++) res&=isOK[i];
+ {
+ if (isOK[0]==kFALSE){
+ ::Error("TestCorrection_AddCorrectionCompact","AliTPCCalibGlobalMisalignment -ADD FAILED");
+ }else{
+ ::Info("TestCorrection_AddCorrectionCompact","AliTPCCalibGlobalMisalignment -ADD OK");
+ }
+ if (isOK[1]==kFALSE){
+ ::Error("TestCorrection_AddCorrectionCompact","AliTPCCalibGlobalMisalignment - wrong entries FAILED");
+ }else{
+ ::Info("TestCorrection_AddCorrectionCompact","AliTPCCalibGlobalMisalignment - entries OK");
+ }
+ if (isOK[2]==kFALSE || isOK[3]==kFALSE ||isOK[4]==kFALSE ){
+ ::Error("TestCorrection_AddCorrectionCompact","AliTPCCalibGlobalMisalignment - inconsitent entries FAILED");
+ }else{
+ ::Info("TestCorrection_AddCorrectionCompact","AliTPCCalibGlobalMisalignment - consistent entries OK");
+ }
+ }
+ return res;
+}
+
+Bool_t TestCorrection_AliTPCCorrection_AddCorrectionCompact(){
+ //
+ //
+ //
+ TestCorrection_AliTPCExBTwistAddCorrectionCompact();
+ TestCorrection_AliTPCFCVoltError3DAddCorrectionCompact();
+ TestCorrection_AliTPCRocVoltError3DAddCorrectionCompact();
+ TestCorrection_AliTPCBoundaryVoltErrorAddCorrectionCompact();
+ TestCorrection_AliTPCCalibGlobalMisalignmentAddCorrectionCompact();
+}
+
+
+Bool_t TestCorrection_AliTPCComposedCorrectionAddCorrectionCompact(){
+ //
+ // Tests of AliTPCComposedCorrection
+ // 1.) Make linear combination correction example using weights.
+ // Test correction checking invariant inverse x orig (there are simpler way to do inversion using AliTPCInverseCorrection)
+ //
+ // 2.) Make compact for of the Composed correction. Test correction checking invariant inverse x orig
+ //
+ const Int_t npointsTest=10000;
+ const Float_t kEpsilon=0.0001; // using Floating point precission
+
+ //
+ // 0.) Read an input OCDB entry
+ //
+ TFile * f = TFile::Open("$ALICE_OCDB/alice/data/2010/OCDB/TPC/Calib/Correction/Run0_999999999_v8_s0.root");
+ AliCDBEntry * entry=(AliCDBEntry*)f->Get("AliCDBEntry");
+ TObjArray * corrArray = (TObjArray *)entry->GetObject();
+ AliTPCComposedCorrection *compInput = (AliTPCComposedCorrection *)corrArray->At(0);
+ //
+ // 1.) Make linear combination correction example using weights.
+ // Test correction checking invariant inverse x orig (there are simpler way to do inversion using AliTPCInverseCorrection)
+ AliTPCComposedCorrection *compInverse = new AliTPCComposedCorrection();
+ Bool_t isOK1[10]={kTRUE};
+ TObjArray * collection= dynamic_cast<TObjArray*>(compInput->GetCorrections());
+ Int_t entries = collection->GetEntries();
+ TVectorD weights(entries+1);
+ for (Int_t i=0; i<entries+1; i++) weights[i]=-1.0;
+ weights[0]=1.;
+ TObjArray * arrayInvariant = new TObjArray(entries+1);
+ arrayInvariant->AddLast(compInput);
+ for (Int_t i=0; i<entries; i++) arrayInvariant->AddLast( collection->At(i));
+ compInverse->SetCorrections( arrayInvariant);
+ compInverse->SetWeights(&weights);
+ compInverse->AddVisualCorrection(compInverse,1);
+ compInput->AddVisualCorrection(compInput,2);
+ TF1 finv1("finv1","AliTPCCorrection::GetCorrXYZ(x,x,100,0,1)",85,245);
+ //
+ TVectorD vecCompInverse(npointsTest);
+ for (Int_t icoord=0; icoord<3; icoord++){
+ for (Int_t ipoint=0; ipoint<npointsTest; ipoint++){
+ Double_t r= 85.+gRandom->Rndm()*150;
+ Double_t phi= gRandom->Rndm()*TMath::TwoPi();
+ Double_t z=500*(gRandom->Rndm()-0.5);
+ vecCompInverse[ipoint]=AliTPCCorrection::GetCorrXYZ(r*TMath::Cos(phi),r*TMath::Sin(phi),z, icoord, 1);
+ }
+ Double_t rms=TMath::RMS(npointsTest,vecCompInverse.GetMatrixArray());
+ Double_t mean=TMath::Mean(npointsTest,vecCompInverse.GetMatrixArray());
+ isOK1[icoord]=TMath::Abs(rms)<kEpsilon;
+ isOK1[icoord]&=TMath::Abs(mean)<kEpsilon;
+ }
+ if (isOK1[0]==kFALSE || isOK1[1]==kFALSE ||isOK1[2]==kFALSE ){
+ ::Error("TestCorrection_AddCorrectionCompact",TString::Format("AliTPCComposedCorrection - Test1 (%d,%d,%d) FAILED",isOK1[0], isOK1[1],isOK1[2]).Data());
+ }else{
+ ::Info("TestCorrection_AddCorrectionCompact","AliTPCComposedCorrection - Test1 OK");
+ }
+ //
+ // 2.) Make compact for of the Composed correction. Test correction checking invariant inverse x orig
+ // This take time - dostortion has to be recalculated
+ AliTPCComposedCorrection *compOutInverseCompact = new AliTPCComposedCorrection();
+ compOutInverseCompact->AddCorrectionCompact(compInput,-1);
+ compOutInverseCompact->AddCorrectionCompact(compInput, 1);
+ compOutInverseCompact->SetOmegaTauT1T2(0,1,1);
+ compInput->SetOmegaTauT1T2(0,1,1);
+ compOutInverseCompact->AddVisualCorrection(compOutInverseCompact,10);
+ compInput->AddVisualCorrection(compInput,2);
+ TStopwatch timer;
+ //
+ TF1 fcomp("fcomp","AliTPCCorrection::GetCorrXYZ(x,x,100,0,10)",85,245);
+ TF1 forig("forig","-AliTPCCorrection::GetCorrXYZ(x,x,100,0,2)",85,245);
+ TF1 fdiff("fdiff","AliTPCCorrection::GetCorrXYZ(x,x,100,0,10)+AliTPCCorrection::GetCorrXYZ(x,x,100,0,2)",85,245);
+ timer.Print();
+
+
+ return kTRUE;
+}
delete fArraySector; // sector matrices
}
+
+
+Bool_t AliTPCCalibGlobalMisalignment::AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight){
+ //
+ // Add correction and make them compact
+ // Assumptions:
+ // - origin of distortion/correction are additive
+ // - only correction ot the same type supported ()
+ if (corr==NULL) {
+ //AliError("Zerro pointer - correction");
+ return kFALSE;
+ }
+ AliTPCCalibGlobalMisalignment* corrC = dynamic_cast<AliTPCCalibGlobalMisalignment *>(corr);
+ if (corrC == NULL) {
+ //AliError(TString::Format("Inconsistent class types: %s\%s",IsA()->GetName(),corr->IsA()->GetName()).Data());
+ return kFALSE;
+ }
+ //
+ AliTPCCalibGlobalMisalignment & add = *corrC;
+ fXShift+=weight*add.fXShift; // Shift in global X [cm]
+ fYShift+=weight*add.fYShift; // Shift in global Y [cm]
+ fZShift+=weight*add.fZShift; // Shift in global Z [cm]
+
+ fRotPhiA+=weight*add.fRotPhiA; // simple rotation of A side read-out plane around the Z axis [rad]
+ fRotPhiC+=weight*add.fRotPhiC; // simple rotation of C side read-out plane around the Z axis [rad]
+ fdRPhiOffsetA+=weight*add.fdRPhiOffsetA; // add a constant offset of dRPhi (or local Y) in [cm]: purely for calibration purposes!
+ fdRPhiOffsetC+=weight*add.fdRPhiOffsetC; // add a constant offset of dRPhi (or local Y) in [cm]: purely for calibration purposes!
+ //
+ // Quadrant alignment
+ //
+ if (add.fQuadrantQ0) {
+ if (fQuadrantQ0) fQuadrantQ0->Add(weight*(*(add.fQuadrantQ0)));
+ if (!fQuadrantQ0) {
+ fQuadrantQ0 = (TVectorD*)(add.fQuadrantQ0->Clone());
+ (*fQuadrantQ0)*=weight;
+ }
+ }
+ if (add.fQuadrantRQ0) {
+ if (fQuadrantRQ0) fQuadrantRQ0->Add(weight*(*(add.fQuadrantRQ0)));
+ if (!fQuadrantRQ0) {
+ fQuadrantRQ0 = (TVectorD*)(add.fQuadrantRQ0->Clone());
+ (*fQuadrantRQ0)*=weight;
+ }
+ }
+ //
+ if (add.fQuadrantQ1) {
+ if (fQuadrantQ1) fQuadrantQ1->Add(weight*(*(add.fQuadrantQ1)));
+ if (!fQuadrantQ1) {
+ fQuadrantQ1 = (TVectorD*)(add.fQuadrantQ1->Clone());
+ (*fQuadrantQ1)*=weight;
+ }
+ }
+ if (add.fQuadrantRQ1) {
+ if (fQuadrantRQ1) fQuadrantRQ1->Add(weight*(*(add.fQuadrantRQ1)));
+ if (!fQuadrantRQ1) {
+ fQuadrantRQ1 = (TVectorD*)(add.fQuadrantRQ1->Clone());
+ (*fQuadrantRQ1)*=weight;
+ }
+ }
+ //
+ if (add.fQuadrantQ2) {
+ if (fQuadrantQ2) fQuadrantQ2->Add(weight*(*(add.fQuadrantQ2)));
+ if (!fQuadrantQ2) {
+ fQuadrantQ2 = (TVectorD*)(add.fQuadrantQ2->Clone());
+ (*fQuadrantQ2)*=weight;
+ }
+ }
+ if (add.fQuadrantRQ2) {
+ if (fQuadrantRQ2) fQuadrantRQ2->Add(weight*(*(add.fQuadrantRQ2)));
+ if (!fQuadrantRQ2) {
+ fQuadrantRQ2 = (TVectorD*)(add.fQuadrantRQ2->Clone());
+ (*fQuadrantQ2)*=weight;
+ }
+ }
+ //
+ // Global alignment - use native ROOT representation
+ //
+ Double_t delta[3]={0};
+ if (add.fMatrixGlobal){
+ TGeoHMatrix matrixW=*(add.fMatrixGlobal);
+ TGeoHMatrix matrixScaled;
+ const Double_t *rotMatrix = matrixW.GetRotationMatrix();
+ const Double_t *transMatrix = matrixW.GetTranslation();
+ matrixScaled.RotateZ(-rotMatrix[1]*TMath::RadToDeg()*weight);
+ matrixScaled.RotateY(rotMatrix[2]*TMath::RadToDeg()*weight);
+ matrixScaled.RotateX(-rotMatrix[5]*TMath::RadToDeg()*weight);
+ for (Int_t i=0; i<3; i++) delta[i]=weight*transMatrix[i];
+ matrixScaled.SetTranslation(delta);
+ // (matrixScaled*matrixW).Print(); in case weight -1 should be unit matrix
+ //
+ if (!fMatrixGlobal) {
+ fMatrixGlobal = new TGeoHMatrix(matrixScaled);
+ }else{
+ ((TGeoHMatrix*)fMatrixGlobal)->Multiply(&matrixScaled);
+ }
+ }
+ if (add.fMatrixGlobalDelta){
+ TGeoHMatrix matrixW=*(add.fMatrixGlobalDelta);
+ TGeoHMatrix matrixScaled;
+ const Double_t *rotMatrix = matrixW.GetRotationMatrix();
+ const Double_t *transMatrix = matrixW.GetTranslation();
+ matrixScaled.RotateZ(-rotMatrix[1]*TMath::RadToDeg()*weight);
+ matrixScaled.RotateY(rotMatrix[2]*TMath::RadToDeg()*weight);
+ matrixScaled.RotateX(-rotMatrix[5]*TMath::RadToDeg()*weight);
+ for (Int_t i=0; i<3; i++) delta[i]=weight*transMatrix[i];
+ matrixScaled.SetTranslation(delta);
+ // (matrixScaled*matrixW).Print(); in case weight -1 should be unit matrix
+ //
+ if (!fMatrixGlobalDelta) {
+ fMatrixGlobalDelta = new TGeoHMatrix(matrixScaled);
+ }else{
+ ((TGeoHMatrix*)fMatrixGlobalDelta)->Multiply(&matrixScaled);
+ }
+ }
+ if (add.fArraySector){
+ if (!fArraySector) {
+ fArraySector = new TObjArray(72);
+ for (Int_t isec=0; isec<72; isec++) fArraySector->AddAt(new TGeoHMatrix,isec);
+ }
+ for (Int_t isec=0; isec<72; isec++){
+ TGeoHMatrix *mat0= (TGeoHMatrix*)fArraySector->At(isec);
+ TGeoHMatrix *mat1= (TGeoHMatrix*)add.fArraySector->At(isec);
+ if (mat0&&mat1){
+ TGeoHMatrix matrixW=*(mat1);
+ TGeoHMatrix matrixScaled;
+ const Double_t *rotMatrix = matrixW.GetRotationMatrix();
+ const Double_t *transMatrix = matrixW.GetTranslation();
+ matrixScaled.RotateZ(-rotMatrix[1]*TMath::RadToDeg()*weight);
+ matrixScaled.RotateY(rotMatrix[2]*TMath::RadToDeg()*weight);
+ matrixScaled.RotateX(-rotMatrix[5]*TMath::RadToDeg()*weight);
+ for (Int_t i=0; i<3; i++) delta[i]=weight*transMatrix[i];
+ matrixScaled.SetTranslation(delta);
+ mat0->Multiply(&matrixScaled);
+ }
+ }
+ }
+ //
+ return kTRUE;
+}
+
+
+
+
void AliTPCCalibGlobalMisalignment::SetQuadranAlign(const TVectorD *quadrantQ0, const TVectorD *quadrantRQ0, const TVectorD *quadrantQ1,const TVectorD *quadrantRQ1, const TVectorD *quadrantQ2, const TVectorD *quadrantRQ2){
//
// Set quadrant alignment
}
}
-void AliTPCCalibGlobalMisalignment::Print(Option_t* /*option*/ ) const {
+void AliTPCCalibGlobalMisalignment::Print(Option_t* option ) const{
//
// Print function to check the settings
//
printf(" - X-Shift: %1.3f cm, Y-Shift: %1.3f cm, Z-Shift: %1.3f cm \n",fXShift,fYShift,fZShift);
printf(" - Phi-Rotations: A side: %1.5f rad, C side: %1.5f rad\n",fRotPhiA,fRotPhiC);
printf(" - dRPhi offsets: A side: %1.5f cm, C side: %1.5f cm\n",fdRPhiOffsetA,fdRPhiOffsetC);
-
-
+ TString opt = option; opt.ToLower();
+ if (opt.Contains("a")){
+ if (GetAlignGlobal()){
+ printf("GetAlignGlobal()\n");
+ GetAlignGlobal()->Print();
+ }
+ if (GetAlignGlobalDelta()){
+ printf("GetAlignGlobalDelta()\n");
+ GetAlignGlobalDelta()->Print();
+ }
+ if (GetAlignSectors()){
+ printf("GetAlignSectors()\n");
+ GetAlignSectors()->Print();
+ }
+ }
}
void AliTPCCalibGlobalMisalignment::AddAlign(const AliTPCCalibGlobalMisalignment & add){
public:
AliTPCCalibGlobalMisalignment();
virtual ~AliTPCCalibGlobalMisalignment();
-
+ virtual Bool_t AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight);
// initialization and update functions
// virtual void Init();
// virtual void Update(const TTimeStamp &timeStamp);
Float_t GetRotPhiC() const {return fRotPhiC;}
Float_t GetdRPhiOffsetA() const {return fdRPhiOffsetA;}
Float_t GetdRPhiOffsetC() const {return fdRPhiOffsetC;}
- virtual void Print(Option_t* option="") const;
+ virtual void Print(Option_t* option="") const ;
void SetQuadranAlign(const TVectorD *quadrantQ0, const TVectorD *quadrantRQ0, const TVectorD *quadrantQ1,const TVectorD *quadrantRQ1, const TVectorD *quadrantQ2, const TVectorD *quadrantRQ2);
//
// Alignment manipulation using TGeoMatrix
Int_t ncorrs= corrC->fCorrections->GetEntries();
Bool_t isOK=kTRUE;
for (Int_t icorr=0; icorr<ncorrs; icorr++){
- isOK&=AddCorrectionCompact(corrC->GetSubCorrection(icorr),weight*(*((corrC->fWeights)))[icorr]);
+ Double_t weight0=((corrC->fWeights)==NULL)?1:(*(corrC->fWeights))[icorr];
+ isOK&=AddCorrectionCompact(corrC->GetSubCorrection(icorr),weight*weight0);
}
return isOK;
}
AliTPCExBBShape::AliTPCExBBShape()
: AliTPCCorrection("exb_bshape","ExB B-shape"),
fC1(0.),fC2(0.),
+ fScaling(1.),
fBField(0)
{
//
//
}
+
+
+
+Bool_t AliTPCExBBShape::AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight){
+ //
+ // Add correction and make them compact
+ // Assumptions:
+ // - origin of distortion/correction are additive
+ // - only correction ot the same type supported ()
+ if (corr==NULL) {
+ AliError("Zerro pointer - correction");
+ return kFALSE;
+ }
+ AliTPCExBBShape* corrC = dynamic_cast<AliTPCExBBShape *>(corr);
+ if (corrC == NULL) {
+ AliError(TString::Format("Inconsistent class types: %s\%s",IsA()->GetName(),corr->IsA()->GetName()).Data());
+ return kFALSE;
+ }
+ fScaling= weight;
+ //
+ return kTRUE;
+}
+
+
void AliTPCExBBShape::Init() {
//
// Initialization funtion
fBField->GetTPCRatInt(xStart,intBStart);
fBField->GetTPCRatInt(xEnd, intBEnd );
- const Float_t intBxOverBz=(intBEnd[0]-intBStart[0]);
- const Float_t intByOverBz=(intBEnd[1]-intBStart[1]);
+ const Float_t intBxOverBz=fScaling*(intBEnd[0]-intBStart[0]);
+ const Float_t intByOverBz=fScaling*(intBEnd[1]-intBStart[1]);
dx[0]=fC2*intBxOverBz-fC1*intByOverBz;
dx[1]=fC1*intBxOverBz+fC2*intByOverBz;
fBField->GetTPCRatInt(xStart,intBStart);
fBField->GetTPCRatInt(xEnd, intBEnd );
- const Float_t intBxOverBz=(intBEnd[0]-intBStart[0]);
- const Float_t intByOverBz=(intBEnd[1]-intBStart[1]);
+ const Float_t intBxOverBz=fScaling*(intBEnd[0]-intBStart[0]);
+ const Float_t intByOverBz=fScaling*(intBEnd[1]-intBStart[1]);
BxByOverBz[0]=intBxOverBz;
BxByOverBz[1]=intByOverBz;
class AliTPCExBBShape : public AliTPCCorrection {
public:
AliTPCExBBShape();
- virtual ~AliTPCExBBShape();
+ virtual ~AliTPCExBBShape();
+ virtual Bool_t AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight);
// initialization and update functions
virtual void Init();
virtual void Print(Option_t* option="") const;
static Double_t GetBFieldXYZ(Double_t gx, Double_t gy, Double_t gz, Int_t axisType);
-
+ Double_t GetScaling() const {return fScaling;}
private:
Float_t fC1; // coefficient C1 (compare Jim Thomas's notes for definitions)
Float_t fC2; // coefficient C2 (compare Jim Thomas's notes for definitions)
-
+ Float_t fScaling; // scaling factor to rescale distortion - for tests purposes only
AliMagF *fBField; // pointer to magnetic field
AliTPCExBBShape & operator =(const AliTPCExBBShape &); // dummy assignment operator
message(FATAL_ERROR "{_detector}${_daname}da.cxx does not contain a description. Please add the description as the first /*comment*/ in the file")
else()
string(SUBSTRING "${tmpinfo}" ${_first_position} ${_second_position} _da_description)
- string(STRIP ${_da_description} _da_description)
+ string(STRIP "${_da_description}" _da_description)
# The variable can be accesed by the parent
set(RPM_DESCRIPTION ${_da_description})
# install RPM into $CMAKE_INSTALL_PREFIX/darpms
install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/da-${_ALGORITHM}-rpm/RPMS/ DESTINATION darpms PATTERN "\\.rpm")
-endmacro()
\ No newline at end of file
+endmacro()
if(error)
message(FATAL_ERROR "Error retrieving ROOT version : ${error}")
endif(error)
- string(STRIP ${ROOT_VERSION} ROOT_VERSION)
+ string(STRIP "${ROOT_VERSION}" ROOT_VERSION)
# Extract major, minor, and patch versions from
string(REGEX REPLACE "^([0-9]+)\\.[0-9][0-9]+\\/[0-9][0-9]+.*" "\\1" ROOT_VERSION_MAJOR "${ROOT_VERSION}")
else()
message(STATUS "ROOT was build with the following features: ${ROOT_FEATURES}")
endif(error)
- string(STRIP ${ROOT_FEATURES} ROOT_FEATURES)
+ string(STRIP "${ROOT_FEATURES}" ROOT_FEATURES)
# Checking for ROOT libdir
execute_process(COMMAND ${ROOT_CONFIG} --libdir OUTPUT_VARIABLE ROOT_LIBDIR ERROR_VARIABLE error OUTPUT_STRIP_TRAILING_WHITESPACE )
if(error)
message(FATAL_ERROR "Error retrieving ROOT libdir: ${error}")
endif(error)
- string(STRIP ${ROOT_LIBDIR} ROOT_LIBDIR)
+ string(STRIP "${ROOT_LIBDIR}" ROOT_LIBDIR)
# Checking for ROOT libs
execute_process(COMMAND ${ROOT_CONFIG} --noldflags --libs OUTPUT_VARIABLE ROOT_LIBS ERROR_VARIABLE error OUTPUT_STRIP_TRAILING_WHITESPACE )
if(error)
message(FATAL_ERROR "Error retrieving ROOT libdir: ${error}")
endif(error)
- string(STRIP ${ROOT_LIBS} ROOT_LIBS)
+ string(STRIP "${ROOT_LIBS}" ROOT_LIBS)
foreach(lib ${ROOT_LIBS})
string(REPLACE "-rdynamic" "" new_lib ${lib})
string(REPLACE "-l" "" lib ${new_lib})
set(ROOT_LIBRARIES ${ROOT_LIBRARIES} ${lib})
endforeach()
- string(STRIP ${ROOT_LIBRARIES} ROOT_LIBRARIES)
+ string(STRIP "${ROOT_LIBRARIES}" ROOT_LIBRARIES)
separate_arguments(ROOT_LIBRARIES)
# Checking for ROOT incdir
if(error)
message(FATAL_ERROR "Error retrieving ROOT incdir: ${error}")
endif(error)
- string(STRIP ${ROOT_INCDIR} ROOT_INCDIR)
+ string(STRIP "${ROOT_INCDIR}" ROOT_INCDIR)
set(ROOT_INCLUDE_DIR ${ROOT_INCDIR})
# Checking for glibs
endif(error)
# Checking for glibs
- string(STRIP ${ROOT_GLIBS} ROOT_GLIBS)
+ string(STRIP "${ROOT_GLIBS}" ROOT_GLIBS)
foreach(lib ${ROOT_GLIBS})
string(REPLACE "-rdynamic" "" new_lib "${lib}")
string(REPLACE "-l" "" lib "${new_lib}")
set(ROOT_GLIBRARIES ${ROOT_GLIBRARIES} ${lib})
endforeach()
- string(STRIP ${ROOT_GLIBRARIES} ROOT_GLIBRARIES)
+ string(STRIP "${ROOT_GLIBRARIES}" ROOT_GLIBRARIES)
separate_arguments(ROOT_GLIBRARIES)
# Checking for AliEn support
#if defined
if(ROOT_HASALIEN)
- string(STRIP ${ROOT_HASALIEN} ROOT_HASALIEN)
+ string(STRIP "${ROOT_HASALIEN}" ROOT_HASALIEN)
if(ROOT_HASALIEN STREQUAL "yes")
if(ALIEN)
add_definitions(-DWITHALIEN)
- # AliEn might bring some system libraries, we need to follow them
- link_directories(${ALIEN}/lib)
- link_directories(${ALIEN}/api/lib)
+ # AliEn might bring some system libraries, we need to use them
+ if(EXISTS "${ALIEN}/lib")
+ link_directories(${ALIEN}/lib)
+ endif()
+
+ # api/lib should always exists
+ if(EXISTS "${ALIEN}/api/lib")
+ link_directories(${ALIEN}/api/lib)
+ endif()
# include for AliEn
- include_directories(${ALIEN}/include)
+ if(EXISTS "${ALIEN}/include")
+ include_directories(${ALIEN}/include)
+ endif()
+
+ # api/include always exists
+ if(EXISTS "${ALIEN}/api/include")
+ include_directories(${ALIEN}/api/include)
+ endif()
set(ROOT_HASALIEN TRUE)
else(ALIEN)
# if defined
if(ROOT_HASXML)
- string(STRIP ${ROOT_HASXML} ROOT_HASXML)
+ string(STRIP "${ROOT_HASXML}" ROOT_HASXML)
if(ROOT_HASXML STREQUAL "yes")
add_definitions(-DWITHXML)
set(ROOT_HASXML TRUE)
endif(error)
if(ROOT_HASOPENGL)
- string(STRIP ${ROOT_HASOPENGL} ROOT_HASOPENGL)
+ string(STRIP "${ROOT_HASOPENGL}" ROOT_HASOPENGL)
if(ROOT_HASOPENGL STREQUAL "yes")
set(ROOT_HASOPENGL TRUE)
else()
if(error)
message(FATAL_ERROR "Error checking ROOT fortran compiler: ${error}")
endif(error)
- string(STRIP ${ROOT_FORTRAN} ROOT_FORTRAN)
+ string(STRIP "${ROOT_FORTRAN}" ROOT_FORTRAN)
# adding the libraries and the inc dir
link_directories(${ROOT_LIBDIR})
endif(ALIROOT_STATIC)
else()
message(FATAL_ERROR "ROOT installation not found! Please point to the ROOT installation using -DROOTSYS=ROOT_INSTALL_DIR.")
-endif(ROOTSYS)
\ No newline at end of file
+endif(ROOTSYS)
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff
