[u/mrichter/AliRoot.git] / doc / Distributed-Analysis / Interactive.tex

%________________________________________________________
\section{Interactive analysis with GRID ESDs}
\label{Note:INTERACTIVE}

Once the first step described in Section \ref{Note:LOCAL} was successful and we are satisfied from both the code and the results, we are ready to validate our code on a larger data sample. In this section we will describe how we can analyze interactively (that is sitting in from of a terminal and getting back the results in our screen) files that are stored in the Grid. We will once again concentrate in the case where we use the \tag\ \cite{Note:RefAlienTutorial,Note:RefEventTagWeb}.

The first thing that we need to create is a collection of tag files by querying the file catalog (for details on this process the reader should look either in the example of section \ref{Note:FLOW} or in \cite{Note:RefFileCatalogMetadataNote,Note:RefFileCatalogMetadataWeb}). These tag files, which are registered in the Grid, are the official ones created as a last step of the reconstruction code \cite{Note:RefEventTagNote}. Once we have a valid xml collection, we launch a ROOT session, we setup the {\ttfamily par file} (the way to do this has been described in detail in section \ref{Note:FLOW}), we apply some selection criteria and we query the \tag which returns the desired events in the proper format (TChain along with the associated list of events that satisfy our cuts). The following lines give a snapshot of how a typical code should look like:

\vspace{0.5 cm}
\textbf{Usage of AliRunTagCuts and AliEventTagCuts classes}
\begin{lstlisting}[language=C++]
  // Case where the tag files are stored in the file catalog
  // tag.xml is the xml collection of tag files that was produced 
  // by querying the file catalog.
  TGrid::Connect("alien://"); 
  TAlienCollection* coll = TAlienCollection::Open("tag.xml");
  TGridResult* tagResult = coll->GetGridResult("");

  // Create a RunTagCut object
  AliRunTagCuts *runCutsObj = new AliRunTagCuts();
  runCutsObj->SetRunId(340);

  // Create an EventTagCut object
  AliEventTagCuts *evCutsObj = new AliEventTagCuts();
  evCutsObj->SetMultiplicityRange(2, 100);

  // Create a new AliTagAnalysis object and chain the grid stored tags
  AliTagAnalysis *tagAna = new AliTagAnalysis(); 
  tagAna->ChainGridTags(tagResult);

  // Cast the output of the query to a TChain
  TChain *analysisChain = tagAna->QueryTags(runCutsObj, evCutsObj);

  // Process the chain with a manager
  AliAnalysisManager *mgr = new AliAnalysisManager();
  AliAnalysisTask *task1 = new AliAnalysisTaskPt("TaskPt");
  mgr->AddTask(task1);

  AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("cchain1", 
  TChain::Class(),AliAnalysisManager::kInputContainer);
  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("chist1", 
  TH1::Class(),AliAnalysisManager::kOutputContainer);
  mgr->ConnectInput(task1,0,cinput1);
  mgr->ConnectOutput(task1,0,coutput1);
  cinput1->SetData(analysisChain);
  
  if (mgr->InitAnalysis()) {
    mgr->PrintStatus();
    analysisChain->Process(mgr);
  }
\end{lstlisting}

\vspace{0.5 cm}
\textbf{Usage of string statements}
\begin{lstlisting}[language=C++]
  // Case where the tag files are stored in the file catalog
  // tag.xml is the xml collection of tag files that was produced 
  // by querying the file catalog.
  TGrid::Connect("alien://"); 
  TAlienCollection* coll = TAlienCollection::Open("tag.xml");
  TGridResult* tagResult = coll->GetGridResult("");

  //Usage of string statements//
  const char* runCutsStr = "fAliceRunId == 340";
  const char* evCutsStr = "fEventTag.fNumberOfTracks >= 2 &&
  fEventTag.fNumberOfTracks <= 100";

  // Create a new AliTagAnalysis object and chain the grid stored tags
  AliTagAnalysis *tagAna = new AliTagAnalysis(); 
  tagAna->ChainGridTags(tagResult);

  // Cast the output of the query to a TChain
  TChain *analysisChain = tagAna->QueryTags(runCutsStr, evCutsStr);

  // Process the chain with a manager
  AliAnalysisManager *mgr = new AliAnalysisManager();
  AliAnalysisTask *task1 = new AliAnalysisTaskPt("TaskPt");
  mgr->AddTask(task1);

  AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("cchain1",
  TChain::Class(),AliAnalysisManager::kInputContainer);
  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("chist1", 
  TH1::Class(),AliAnalysisManager::kOutputContainer);
  mgr->ConnectInput(task1,0,cinput1);
  mgr->ConnectOutput(task1,0,coutput1);
  cinput1->SetData(analysisChain);
  
  if (mgr->InitAnalysis()) {
    mgr->PrintStatus();
    analysisChain->Process(mgr);
  }
\end{lstlisting}


\noindent We will now review the previous lines. Since we would like to access Grid stored files we have to connect to the API server using the corresponding ROOT classes:\\
\\
{\ttfamily TGrid::Connect("alien://");}\\

Then we create a {\ttfamily TAlienCollection} object by opening the xml file (tag.xml) and we convert it to a {\ttfamily TGridResult}:\\
\\
{\ttfamily TAlienCollection* coll = TAlienCollection::Open("tag.xml");}\\
{\ttfamily TGridResult* tagResult = coll->GetGridResult("");}\\

\noindent where \textbf{tag.xml} is the name of the file (which is stored in the working directory) having the collection of tag files. 

The difference of the two cases is located in the way we apply the event tag cuts. In the first case, we create an {\ttfamily AliRunTagCuts} and an {\ttfamily AliEventTagCuts} object and impose our criteria at the run and event level of the \tag, while in the second we use the string statements to do so. The corresponding lines have already been descibe in the previous section. 


Regardless of the way we define our cuts, we need to initialize an {\ttfamily AliTagAnalysis} object and chain the GRID stored tags by providing as an argument to the {\ttfamily ChainGridTags} function the {\ttfamily TGridResult} we had created before:\\
\\
{\ttfamily AliTagAnalysis *tagAna = new AliTagAnalysis();}\\
{\ttfamily tagAna->ChainGridTags(tagResult);}\\

We then query the \tag, using the imposed selection criteria and we end up having the chain of ESD files along with the associated event list (list of the events that fulfill the criteria):\\
\\
{\ttfamily TChain *analysisChain = tagAna->QueryTags(runCutsObj, evCutsObj);}\\
\noindent, for the first case (usage of objects), or: \\
\\
{\ttfamily TChain *analysisChain = tagAna->QueryTags(runCutsStr, evCutsStr);}\\
\noindent, for the second case (usage of sting statements).

Finally we process this {\ttfamily TChain} by invoking our implemented task using a manager:\\
\\
{\ttfamily  AliAnalysisManager *mgr = new AliAnalysisManager();}\\
{\ttfamily  AliAnalysisTask *task1 = new AliAnalysisTaskPt("TaskPt");}\\
{\ttfamily  mgr->AddTask(task1);}\\
{\ttfamily  AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("cchain1", TChain::Class(),AliAnalysisManager::kInputContainer);}\\
{\ttfamily  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("chist1", TH1::Class(),AliAnalysisManager::kOutputContainer);}\\
{\ttfamily  mgr->ConnectInput(task1,0,cinput1);}\\
{\ttfamily  mgr->ConnectOutput(task1,0,coutput1);}\\
{\ttfamily  cinput1->SetData(analysisChain);}\\  
{\ttfamily  if (mgr->InitAnalysis()) {mgr->PrintStatus();analysisChain->Process(mgr);}}\\

All the needed files to run this example can be found inside the PWG2 module of AliRoot under the AnalysisMacros/Interactive directory.
Commit	Line	Data
76bcc7e6	1	%________________________________________________________
	2	\section{Interactive analysis with GRID ESDs}
	3	\label{Note:INTERACTIVE}
	4
	5	Once the first step described in Section \ref{Note:LOCAL} was successful and we are satisfied from both the code and the results, we are ready to validate our code on a larger data sample. In this section we will describe how we can analyze interactively (that is sitting in from of a terminal and getting back the results in our screen) files that are stored in the Grid. We will once again concentrate in the case where we use the \tag\ \cite{Note:RefAlienTutorial,Note:RefEventTagWeb}.
	6
	7	The first thing that we need to create is a collection of tag files by querying the file catalog (for details on this process the reader should look either in the example of section \ref{Note:FLOW} or in \cite{Note:RefFileCatalogMetadataNote,Note:RefFileCatalogMetadataWeb}). These tag files, which are registered in the Grid, are the official ones created as a last step of the reconstruction code \cite{Note:RefEventTagNote}. Once we have a valid xml collection, we launch a ROOT session, we setup the {\ttfamily par file} (the way to do this has been described in detail in section \ref{Note:FLOW}), we apply some selection criteria and we query the \tag which returns the desired events in the proper format (TChain along with the associated list of events that satisfy our cuts). The following lines give a snapshot of how a typical code should look like:
	8
	9	\vspace{0.5 cm}
	10	\textbf{Usage of AliRunTagCuts and AliEventTagCuts classes}
	11	\begin{lstlisting}[language=C++]
	12	// Case where the tag files are stored in the file catalog
	13	// tag.xml is the xml collection of tag files that was produced
	14	// by querying the file catalog.
	15	TGrid::Connect("alien://");
	16	TAlienCollection* coll = TAlienCollection::Open("tag.xml");
	17	TGridResult* tagResult = coll->GetGridResult("");
	18
	19	// Create a RunTagCut object
	20	AliRunTagCuts *runCutsObj = new AliRunTagCuts();
	21	runCutsObj->SetRunId(340);
	22
	23	// Create an EventTagCut object
	24	AliEventTagCuts *evCutsObj = new AliEventTagCuts();
	25	evCutsObj->SetMultiplicityRange(2, 100);
	26
	27	// Create a new AliTagAnalysis object and chain the grid stored tags
	28	AliTagAnalysis *tagAna = new AliTagAnalysis();
	29	tagAna->ChainGridTags(tagResult);
	30
	31	// Cast the output of the query to a TChain
	32	TChain *analysisChain = tagAna->QueryTags(runCutsObj, evCutsObj);
	33
	34	// Process the chain with a manager
	35	AliAnalysisManager *mgr = new AliAnalysisManager();
	36	AliAnalysisTask *task1 = new AliAnalysisTaskPt("TaskPt");
	37	mgr->AddTask(task1);
	38
	39	AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("cchain1",
	40	TChain::Class(),AliAnalysisManager::kInputContainer);
	41	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("chist1",
	42	TH1::Class(),AliAnalysisManager::kOutputContainer);
	43	mgr->ConnectInput(task1,0,cinput1);
	44	mgr->ConnectOutput(task1,0,coutput1);
	45	cinput1->SetData(analysisChain);
	46
	47	if (mgr->InitAnalysis()) {
	48	mgr->PrintStatus();
	49	analysisChain->Process(mgr);
	50	}
	51	\end{lstlisting}
	52
	53	\vspace{0.5 cm}
	54	\textbf{Usage of string statements}
	55	\begin{lstlisting}[language=C++]
	56	// Case where the tag files are stored in the file catalog
	57	// tag.xml is the xml collection of tag files that was produced
	58	// by querying the file catalog.
	59	TGrid::Connect("alien://");
	60	TAlienCollection* coll = TAlienCollection::Open("tag.xml");
	61	TGridResult* tagResult = coll->GetGridResult("");
	62
	63	//Usage of string statements//
	64	const char* runCutsStr = "fAliceRunId == 340";
65	const char* evCutsStr = "fEventTag.fNumberOfTracks >= 2 &&
66	fEventTag.fNumberOfTracks <= 100";
67
68	// Create a new AliTagAnalysis object and chain the grid stored tags
69	AliTagAnalysis *tagAna = new AliTagAnalysis();
70	tagAna->ChainGridTags(tagResult);
71
72	// Cast the output of the query to a TChain
73	TChain *analysisChain = tagAna->QueryTags(runCutsStr, evCutsStr);
74
75	// Process the chain with a manager
76	AliAnalysisManager *mgr = new AliAnalysisManager();
77	AliAnalysisTask *task1 = new AliAnalysisTaskPt("TaskPt");
78	mgr->AddTask(task1);
79
80	AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("cchain1",
81	TChain::Class(),AliAnalysisManager::kInputContainer);
82	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("chist1",
83	TH1::Class(),AliAnalysisManager::kOutputContainer);
84	mgr->ConnectInput(task1,0,cinput1);
85	mgr->ConnectOutput(task1,0,coutput1);
86	cinput1->SetData(analysisChain);
87
88	if (mgr->InitAnalysis()) {
89	mgr->PrintStatus();
90	analysisChain->Process(mgr);
91	}
92	\end{lstlisting}
93
94
95	\noindent We will now review the previous lines. Since we would like to access Grid stored files we have to connect to the API server using the corresponding ROOT classes:\\
96	\\
97	{\ttfamily TGrid::Connect("alien://");}\\
98
99	Then we create a {\ttfamily TAlienCollection} object by opening the xml file (tag.xml) and we convert it to a {\ttfamily TGridResult}:\\
100	\\
101	{\ttfamily TAlienCollection* coll = TAlienCollection::Open("tag.xml");}\\
102	{\ttfamily TGridResult* tagResult = coll->GetGridResult("");}\\
103
104	\noindent where \textbf{tag.xml} is the name of the file (which is stored in the working directory) having the collection of tag files.
105
106	The difference of the two cases is located in the way we apply the event tag cuts. In the first case, we create an {\ttfamily AliRunTagCuts} and an {\ttfamily AliEventTagCuts} object and impose our criteria at the run and event level of the \tag, while in the second we use the string statements to do so. The corresponding lines have already been descibe in the previous section.
107
108
109	Regardless of the way we define our cuts, we need to initialize an {\ttfamily AliTagAnalysis} object and chain the GRID stored tags by providing as an argument to the {\ttfamily ChainGridTags} function the {\ttfamily TGridResult} we had created before:\\
110	\\
111	{\ttfamily AliTagAnalysis *tagAna = new AliTagAnalysis();}\\
112	{\ttfamily tagAna->ChainGridTags(tagResult);}\\
113
114	We then query the \tag, using the imposed selection criteria and we end up having the chain of ESD files along with the associated event list (list of the events that fulfill the criteria):\\
115	\\
116	{\ttfamily TChain *analysisChain = tagAna->QueryTags(runCutsObj, evCutsObj);}\\
117	\noindent, for the first case (usage of objects), or: \\
118	\\
119	{\ttfamily TChain *analysisChain = tagAna->QueryTags(runCutsStr, evCutsStr);}\\
120	\noindent, for the second case (usage of sting statements).
121
122	Finally we process this {\ttfamily TChain} by invoking our implemented task using a manager:\\
123	\\
124	{\ttfamily AliAnalysisManager *mgr = new AliAnalysisManager();}\\
125	{\ttfamily AliAnalysisTask *task1 = new AliAnalysisTaskPt("TaskPt");}\\
126	{\ttfamily mgr->AddTask(task1);}\\
127	{\ttfamily AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("cchain1", TChain::Class(),AliAnalysisManager::kInputContainer);}\\
128	{\ttfamily AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("chist1", TH1::Class(),AliAnalysisManager::kOutputContainer);}\\
129	{\ttfamily mgr->ConnectInput(task1,0,cinput1);}\\
130	{\ttfamily mgr->ConnectOutput(task1,0,coutput1);}\\
131	{\ttfamily cinput1->SetData(analysisChain);}\\
132	{\ttfamily if (mgr->InitAnalysis()) {mgr->PrintStatus();analysisChain->Process(mgr);}}\\
133
134	All the needed files to run this example can be found inside the PWG2 module of AliRoot under the AnalysisMacros/Interactive directory.
135