MinerU Batch 6c82c03b-0a6e-4e43-9cba-36090a56f72c (Part 2/8)

.gitattributes

@@ -1676,3 +1676,11 @@ data/2025/2503_09xxx/2503.09573/48dbe47b-de29-42fc-bf05-7830a092a51d_origin.pdf
 data/2025/2503_09xxx/2503.09594/1a9d7e5b-676e-4927-af63-f7f6355fd077_origin.pdf filter=lfs diff=lfs merge=lfs -text
 data/2025/2503_09xxx/2503.09780/08214423-a242-4bd0-9a40-e8d6d3d1934d_origin.pdf filter=lfs diff=lfs merge=lfs -text
 data/2025/2503_09xxx/2503.09799/13deeb11-b9f7-4b0d-afd2-8ce11506db61_origin.pdf filter=lfs diff=lfs merge=lfs -text
+data/2025/2503_09xxx/2503.09089/c2c2c95f-facf-4f82-977c-1820c00d4eb0_origin.pdf filter=lfs diff=lfs merge=lfs -text
+data/2025/2503_09xxx/2503.09198/ef3c6a72-d844-464a-90c5-502ddc16df65_origin.pdf filter=lfs diff=lfs merge=lfs -text
+data/2025/2503_09xxx/2503.09277/39fed2ad-9645-4fde-a1c3-86b0c99b7b36_origin.pdf filter=lfs diff=lfs merge=lfs -text
+data/2025/2503_09xxx/2503.09501/7c196e4e-1362-4974-a470-65c83d863927_origin.pdf filter=lfs diff=lfs merge=lfs -text
+data/2025/2503_09xxx/2503.09567/17e53201-29b3-43fd-8f2e-78d7b00a58a6_origin.pdf filter=lfs diff=lfs merge=lfs -text
+data/2025/2503_09xxx/2503.09595/b59876e9-da8b-438b-ab54-bb4c4d76820f_origin.pdf filter=lfs diff=lfs merge=lfs -text
+data/2025/2503_11xxx/2503.11701/f561bad2-8e9b-4fb7-9083-b32d2bfd8f1f_origin.pdf filter=lfs diff=lfs merge=lfs -text
+data/2025/2503_13xxx/2503.13502/db12ade8-3943-4647-bb0d-ce8160710750_origin.pdf filter=lfs diff=lfs merge=lfs -text

data/2025/2503_09xxx/2503.09089/c2c2c95f-facf-4f82-977c-1820c00d4eb0_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1fcd0ff4b8f624de14b00fe1f8de43f88471336de8b18bb06c84278e17c1d2e4
+size 777937

data/2025/2503_09xxx/2503.09089/full.md

@@ -0,0 +1,504 @@
+# LocAgent: Graph-Guided LLM Agents for Code Localization
+
+Zhaoling Chen\*, Xiangru Tang\*, Gangda Deng\*, Fang Wu\*, Jialong Wu\*, Zhiwei Jiang, Viktor Prasanna\*, Arman Cohan\*, Xingyao Wang
+
+$^{\spadesuit}$ Yale University  $^{\spadesuit}$ University of Southern California  $^{\spadesuit}$ Stanford University  $^{\spadesuit}$ All Hands AI xiangru.tang@yale.edu, gangdade@usc.edu, xingyao@all-hands.dev
+
+# Abstract
+
+Code localization—identifying precisely where in a codebase changes need to be made—is a fundamental yet challenging task in software maintenance. Existing approaches struggle to efficiently navigate complex codebases when identifying relevant code sections. The challenge lies in bridging natural language problem descriptions with the appropriate code elements, often requiring reasoning across hierarchical structures and multiple dependencies. We introduce LOCAGENT, a framework that addresses code localization through graph-based representation. By parsing codebases into directed heterogeneous graphs, LOCAGENT creates a lightweight representation that captures code structures (files, classes, functions) and their dependencies (imports, invocations, inheritance), enabling LLM agents to effectively search and locate relevant entities through powerful multi-hop reasoning. Experimental results on real-world benchmarks demonstrate that our approach significantly enhances accuracy in code localization. Notably, our method with the fine-tuned Qwen-2.5-Coder-Instruct-32B model achieves comparable results to SOTA proprietary models at greatly reduced cost (approximately  $86\%$  reduction), reaching up to  $92.7\%$  accuracy on file-level localization while improving downstream GitHub issue resolution success rates by  $12\%$  for multiple attempts (Pass@10). Our code is available at https://github.com/gersteinlab/LocAgent.
+
+# 1 Introduction
+
+Code localization can be viewed as an information retrieval (IR) task that aims to identify relevant code snippets given natural language descriptions (Yu et al., 2025; Yang et al., 2024; Xia et al., 2024). Developers spend up to  $66\%$  of their debugging time (Böhme et al., 2017) understanding code to
+
+![](images/c20269c8cebd98330e89168b5cf72fa71b25a1845eac8027149a6e7bbe018c9f.jpg)  
+Figure 1: Code localization across four common programming scenarios. Given a codebase and an issue description, the goal of code localization is to identify the relevant code snippets that require modification to resolve the issue.
+
+make changes, and automated tools often struggle with the same challenge. Poor code localization leads to incomplete fixes, introduces new bugs, and significantly extends development cycles. Unlike traditional retrieval tasks that primarily focus on lexical or semantic matching between queries and documents (Guo et al., 2016, 2020), code localization requires bridging the gap between natural language and programming languages. It also necessitates reasoning capabilities to analyze the issue, while considering the structural and semantic properties of code (Lewis et al., 2020; Guu et al., 2020; Qu et al., 2020). This capability has become fundamental to powerful AI assistants (OpenAI, 2023; Anthropic, 2023), code-aware search engines (PerplexityAI, 2023), and automated programming agents (Cognition.ai, 2024; Wang et al., 2025; Gauthier, 2024). In particular, accurate code localization is crucial for software maintenance and evolution, as it enables precise code modifications for bug fixes, refactoring, and feature additions (Wang et al., 2024), thereby streamlining the development workflow.
+
+Existing approaches to code localization face
+
+significant limitations. Dense retrieval methods require maintaining and continuously updating vector representations of the entire codebase (Wang et al., 2023b; Günther et al., 2023), creating engineering challenges for large, evolving repositories where code changes frequently. While LLMs demonstrate strong code understanding capabilities (Kang et al., 2023; Wu et al., 2023), models with large context windows cannot process entire codebases at once, necessitating strategic navigation through relevant parts. Moreover, issue descriptions often mention only symptoms rather than underlying causes. For instance, a report of 'XSS vulnerability in user profile' might require changes to a shared validation utility used throughout the codebase but not explicitly referenced in the issue. This disconnect between issue descriptions and affected code components presents a substantial challenge for traditional retrieval approaches, which struggle to trace implicit dependencies across the codebase structure. Recent agent-based methods attempt to address these limitations through iterative exploration (Yang et al., 2024; Qin et al., 2024) but still struggle to efficiently navigate and comprehend complex code structures and dependencies, particularly when multi-hop reasoning is required to trace from issue descriptions to affected code regions that aren't directly mentioned.
+
+This raises a key question: How can we design efficient indexing as intermediate representations that are structure-aware and both easy and performant for LLM agents to consume? It is intuitive to design an agentic retrieval system that carefully combines traditional IR methods and LLM agent's reasoning ability to achieve accurate, efficient, and cost-effective code localization in codebases.
+
+To address this challenge, we propose LOCAGENT, a framework that builds directed heterogeneous graph indexing to unify code structures, dependencies, and contents. Our approach leverages a structured graph representation that enables powerful multi-hop reasoning capabilities, allowing agents to navigate complex dependency relationships between code elements even when target code isn't explicitly mentioned in issue descriptions. This graph-based approach significantly outperforms previous methods on challenging localization tasks that require traversing multiple code relationships. Our lightweight representation, coupled with sparse indexing techniques, enables efficient entity search while maintaining rich structural information. The indexing process typically
+
+takes only a few seconds per codebase, making it highly practical for real-time use. The framework integrates a set of unified tools that guide the agent through a systematic exploration of the codebase, allowing autonomous navigation based on contextual needs. Furthermore, by fine-tuning Qwen-2.5-Coder-Instruct (Hui et al., 2024) 7B and 32B models(abbr. as Qwen-2.5-7B and Qwen-2.5-32B respectively), our system achieves performance comparable to state-of-the-art models like Claude-3-5-sonnet-20241022 (Anthropic, 2023) (abbr. as Claude-3.5) while significantly reducing API costs by over  $80\%$  (from \ $0.66 to \$ 0.09 per example), making it practical for real-world deployment.
+
+Additionally, to facilitate a comprehensive evaluation of code localization methods, we introduce LOC-BENCH, a new benchmark specifically designed for this task. Existing benchmarks like SWE-Bench present significant limitations: (1) they risk contamination through data overlap with LLM training sets (Mündler et al., 2024), and (2) they primarily focus on bug fixing, lacking diversity in maintenance scenarios such as feature requests, performance optimizations, and security fixes. In contrast, LOC-BENCH covers diverse scenarios and mitigates potential contamination concerns by incorporating more recent examples from popular Python repositories collected after known LLM training cutoff dates. Additionally, we provide tooling to continuously update the benchmark with new examples, allowing researchers to maintain a fresh evaluation dataset as models evolve and training data cutoffs advance.
+
+Our contributions address critical gaps in existing approaches:
+
+- We introduce a heterogeneous graph representation that captures both explicit and implicit code relationships, enabling efficient multi-hop reasoning. Our lightweight graph-based indexing process takes only seconds per repository and requires minimal storage.  
+- We design unified tools for agent-based code exploration that leverage our graph representation, allowing LLM agents to perform complex multi-hop navigation and reasoning across code dependencies even when target code isn't explicitly mentioned in issue descriptions.  
+- We introduce Loc-Bench, a new benchmark
+
+specifically designed for code localization that addresses limitations in existing datasets. Unlike previous benchmarks dominated by bug reports, Loc-Bench offers a balanced distribution across bug fixes, feature requests, security patches, and performance optimizations.
+
+- By fine-tuning open-source models on this task, we reduce the cost of code localization by  $86\%$  while maintaining competitive performance.
+
+# 2 Related Work
+
+# 2.1 Traditional Retrieval-based Methods
+
+Traditional IR methods rely on lexical or semantic matching to return ranked lists of code snippets. Sparse retrievers, such as BM25 (Robertson et al., 1994, 2009), have demonstrated robustness to domain adaptation. Dense retrievers utilize embeddings for improved semantic searching, including models with open checkpoints such as general text embedding models E5-base-v2 (Wang et al., 2022) and proprietary APIs (VoyageAI, 2024). Code embedding models such as Jina-Code-v2 (Günther et al., 2023), Codesage-large-v2 (Zhang et al., 2024), and CodeRankEmbed (Suresh et al., 2024), trained specifically for code related tasks, showing significant performance in Code2Code and NL2Code semantic search tasks. However, while the embedding models themselves are small, the engineering challenges of maintaining these indexing systems (e.g., storage requirements, update mechanisms, and infrastructure maintenance) make them difficult to adapt to fast-evolving codebases.
+
+# 2.2 LLM-based Generative Retrieval Methods
+
+Recently, LLMs with advanced code reasoning capabilities have demonstrated superior performance by directly processing queries and raw code for code localization (Kang et al., 2023; Wu et al., 2023; Xia et al., 2024; Kang et al., 2024). For example, Agentless (Xia et al., 2024), initially designed for automated program repair, uses a simplistic hierarchical localization process powered by LLM. It employs a straightforward three-phase approach that first localizes relevant code sections before attempting to fix the identified issues, challenging the assumption that complex agent architectures are necessary for effective code understanding and modification tasks.
+
+Expanding on these techniques, agent-based methods utilize multi-step reasoning to enable automated codebase traversal. Specifically, OpenHands (Wang et al., 2025) implements a generalist coding agent that supports bash commands like grep and tools for viewing files. SWE-Agent (Yang et al., 2024) integrates a custom Agent-Computer Interface to support agents to navigate entire repositories. MoatlessTools (Örwall, 2024) combines an agentic searching loop and semantic search to obtain code locations. However, existing agent-based methods face two critical limitations: (a) they primarily navigate codebases through directory traversal rather than understanding semantic relationships, (b) and they struggle to extract and reason about complex cross-file dependencies when these relationships aren't explicitly represented in the repository structure. This significantly impairs their ability to locate code that requires modification when the issue involves interactions between structurally distant components in the codebase.
+
+# 2.3 Graph-based Code Representation Methods
+
+Due to the inherent structure of code, several works have employed graph-based representations to improve code understanding by capturing key relationships between components. Aider (2023) constructs a RepoMap and uses a graph ranking algorithm to identify the most significant contextual elements. Similarly, as a plugin, RepoGraph (Ouyang et al., 2025) performs subgraph retrieval – extracting an ego-network of relevant lines and their neighbors – to provide structured context. CodexGraph (Liu et al., 2024) indexes the repository into a Neo4j graph database, where LLM agents query the database precisely using Cypher. The efficiency of its retrieval process depends heavily on the querying capabilities of the LLM. These methods focus primarily on providing relevant context but do not enhance the traversal process itself, as they do not explicitly model directory structure or file hierarchies.
+
+In contrast, RepoUnderstander (Ma et al., 2024) builds hierarchical and function-call graphs, using Monte Carlo Tree Search (MCTS) guided by an LLM for exploration. While thorough, MCTS introduces extra computational overhead, making it less efficient than simpler traversal methods like BFS, particularly in large repositories. OrcaLoca (Yu et al., 2025) uses a simplified graph
+
+![](images/68d78298f4ef4a0462b402972796e7a35e59e5ec5b78ccafd6cd08b74dd8ad0d.jpg)  
+Figure 2: Overview of LOCAGENT framework. LOCAGENT first parses the given codebase to build a graph-based code representation with various types of entities and relations. It then constructs sparse indexes for exploring structures and searching content. Using these indexes, it performs agent-guided searches that combine the graph and tools.
+
+<table><tr><td rowspan="2">Method</td><td colspan="4">Relation Types</td><td colspan="4">Node Types</td><td rowspan="2">Search/Traversal Strategy</td></tr><tr><td>Contain</td><td>Import</td><td>Inherit</td><td>Invoke</td><td>Directory</td><td>File</td><td>Class</td><td>Function</td></tr><tr><td>CodexGraph(Liu et al., 2024)</td><td>✓</td><td>X</td><td>✓</td><td>✓</td><td>X</td><td>X</td><td>✓</td><td>✓</td><td>Cypher queries</td></tr><tr><td>RepoGraph(Ouyang et al., 2025)</td><td>✓</td><td>X</td><td>✓</td><td>✓</td><td>X</td><td>X</td><td>✓</td><td>✓</td><td>Ego-graph retrieval</td></tr><tr><td>RepoUnderstander(Ma et al., 2024)</td><td>✓</td><td>X</td><td>✓</td><td>✓</td><td>✓</td><td>✓</td><td>✓</td><td>✓</td><td>MCTS</td></tr><tr><td>OrcaLoca(Yu et al., 2025)</td><td>✓</td><td>X</td><td>X</td><td>✓</td><td>✓</td><td>✓</td><td>✓</td><td>✓</td><td>Simple search tools</td></tr><tr><td>LOCAGENT(Ours)</td><td>✓</td><td>✓</td><td>✓</td><td>✓</td><td>✓</td><td>✓</td><td>✓</td><td>✓</td><td>Unified retrieval tools</td></tr></table>
+
+Table 1: Comparison of Graph-Based Code Representation Methods.
+
+enhanced by priority scheduling and context pruning. It maintains efficient search but may miss complex invocation dependencies. Table 1 summarizes the differences between these methods and LOCAGENT. Compared to these approaches, LOCAGENT offers a more comprehensive and unified representation of the repository, along with efficient, unified retrieval tools specifically designed for LLM consumption.
+
+# 3 The LOCAGENT Framework
+
+We introduce LOCAGENT, a graph-oriented LLM-agent framework for code localization. Figure 2 illustrates the overall framework. When given a repository, LOCAGENT can locate all the relevant code sections at various granularities (file, class, function, or line level) for different types of GitHub issues (such as bug reports, feature requests, performance bottlenecks, and security vulnerabilities) through automated in-depth exploration and analysis of the codebase. Section 3.1 proposes a novel graph-based indexing approach as an intermediate
+
+representation for codebases. Section 3.2 presents our agent-based code search on the indexes and Section 3.3 describes our model fine-tuning and distillation process.
+
+# 3.1 Graph-based Code Representation
+
+Codebases contain rich structural information, both explicit and implicit, that is essential for agent reasoning. Building on this insight, we develop a graph-based indexing that comprehensively captures codebase relationships while maintaining a granularity suitable for LLM-agents to retrieve.
+
+Code Graph Construction. We construct a heterogeneous directed graph  $\mathcal{G}(\mathcal{V},\mathcal{E},\mathcal{A},\mathcal{R})$  to index the codebase, where  $\nu = \{v_{i}\}_{i = 1}^{n}$  is the node set and  $\mathcal{E}\subseteq \mathcal{V}\times \mathcal{V}$  is the edge set. Each node  $v\in \mathcal{V}$  and edge  $e\in \mathcal{E}$  has an associated type mapping function. For nodes,  $\tau (v):\mathcal{V}\to \mathcal{A}$  maps to types  $\mathcal{A} = \{\mathrm{directory},\mathrm{file},\mathrm{class},\mathrm{function}\}$ . For edges,  $\phi (e):\mathcal{E}\rightarrow \mathcal{R}$  maps to relationships  $\mathcal{R} = \{\mathrm{contain},\mathrm{import},\mathrm{invoke},\mathrm{inherit}\}$ . In this paper, we focus our study on Python reposito
+
+ries and leave codebases with other programming languages as future work.
+
+First, we include all directories and Python files as nodes. Then, we parse each Python file using the abstract syntax tree (AST) to identify inner functions and classes recursively as nodes. We set the function level as the smallest node granularity and use each function's code content as the document for agent retrieval. This approach creates a good balance of information density between the index and documents, allowing LLMs to reason effectively within their context window limitations.
+
+As shown in Figure 2, all nodes with different types can be connected as a single tree using the contain relationship. This structure supports standard codebase-navigation operations from existing works. Our code graph further incorporates more advanced codebase relationships as edges: (1) the invoke relationship from function/class to function/class, where an invoke to a class represents class instantiation; (2) the import relationship from file to function/class; and (3) the inherit relationship between classes.
+
+Sparse Hierarchical Entity Indexing. We treat nodes in our code graph as entities and build hierarchical indexing based on their contents. For each keyword, we lookup the indexes from top to bottom: (1) We build an entity ID index as a unique identifier for each node using its fully qualified name. For example, a function calculate_sum in the MathUtils class located in src/utils.py would be represented as: src/utils.py:MathUtilscalculate_sum. (2) We construct a global dictionary to map the entity name (e.g., calculate_sum) to all nodes that share the same name. (3) We index entity IDs through an inverted index (i.e., BM25) to handle keyword searches that don't exactly match the IDs or names of entities. (4) For cases where input keywords aren't part of the entities' IDs (e.g., when a keyword refers to a global variable), we build an inverted index that maps code chunk(s) to each entity to cover all possible matches.
+
+Remark. Rather than relying solely on directory structures or hierarchical module indexing, our approach captures module dependencies that transcend directory boundaries. Two modules in distant directories (A and B) may appear unrelated in traditional navigation, but if they invoke each other or share inheritance, they're syntactically close in our graph representation. This syntactic
+
+<table><tr><td>Tool Name</td><td>Input Params</td><td>Output</td></tr><tr><td>SearchEntity</td><td>Keywords</td><td>Related Entities with Code Snippets</td></tr><tr><td>TraverseGraph</td><td>Start Entity IDs Direction Traverse Hops Entity Types Relation Types</td><td>Traversed Subgraph, including Entities and Relations</td></tr><tr><td>RetrieveEntity</td><td>Entity IDs</td><td>Complete Code of Specified Entities</td></tr></table>
+
+Table 2: List of unified APIs provided by LocAgent for code search and exploration.
+
+proximity is essential for code localization because issues typically manifest through call relationships rather than directory structure. By capturing these functional dependencies, our approach efficiently identifies related components even when physically distant in the codebase.
+
+# 3.2 Agent-guided Code Search
+
+We develop tools based on the indexes built offline. During runtime, LOCAGENT takes issue statements as input and launches agents that autonomously use tools to localize target code sections. While the agent may iteratively invoke multiple tools internally to explore the codebase, LOCAGENT presents a simplified interface to users, requiring only a single-turn interaction—users submit an issue statement and receive localization results without additional input. This autonomous, self-contained workflow makes LOCAGENT both easy to deploy and highly practical for real-world use.
+
+Tool Design for Codebase Exploration. Recent works (Örwall, 2024; Wang et al., 2025), inspired by GUI-based IDEs, have developed numerous specialized tools for agents to explore codebases. However, these tools are initially designed for human readability, which sacrifices the compactness and efficiency that LLM agents prefer (Yang et al., 2024). Building upon our graph-based code representation, we can develop tools that support efficient higher-order codebase exploration to address these challenges. We unify all codebase navigation, search, and view operations into three tools (Table 2), introduced as follows.
+
+SearchEntity: This tool searches codebases using keywords to locate relevant entities through our Hierarchical Entity Index. When an exact match isn't found in the upper index, the system performs a fuzzy search using the lower index. For each entity found, we return its code snippet in three detail
+
+levels: fold, preview, and full code (Figure 6). This effectively prevents lengthy code context and reduces noise fed into agents.
+
+**TraverseGraph:** This tool performs a type-aware breadth-first search (BFS) on the code graph, starting from input entities and allowing control over both traversal direction and number of hops. This supports agents to perform arbitrary multi-hop codebase navigation through only one action, significantly improving the efficiency compared with existing agent systems. Note that by allowing agents to select entity types and relation types for each traversal, this tool effectively leverages the LLM agents' coding expertise to generate proper meta paths—a crucial element for heterogeneous graph analysis (Lv et al., 2021). For example, by specifying entity types to {class, function} and relation types to {contain, inherit}, this tool returns the UML diagram. Additionally, we design an expanded tree-based format for the output subgraph that encodes both relation types and directions (Figure 7). (Fatemi et al., 2023) demonstrates that LLM performance on graph reasoning depends on the input graph format. Converting a graph into a tree structure encodes topology through the spatial distance between entity names, thereby deriving better performance. For detailed comparisons with alternative graph formats, please see Appendix A.1.2.
+
+RetreiveEntity: This tool retrieves complete entity attributes for each input entity ID, including essential information such as file path, line number, and code content.
+
+Chain-of-Thought Agent Planning. We use chain-of-thought (CoT) prompting (shown in Appendix D) to guide the agent in solving code localization problems step by step. The agent systematically follows these steps: (1) Keyword extraction. The agent begins by breaking down the issue statement into different categories and then extracts relevant keywords that are closely related to the problem. (2) Linking keywords to code entities. The agent invokes SearchEntity to complete and clarify each extracted keyword.
+
+(3) Generate the logical flow from fault to failure. The agent first identifies the entry points that trigger the problem. Then, it iteratively traverse the codebase with TraverseGraph, retrieves code contents with RetrieveEntity, and searches new keywords with SearchEntity. Finally, it generates the logic flow based on the issue and additional context. (4) Locate the target entities. The agent pinpoints all suspicious code entities that need modification
+
+based on the logic flow. Then, it ranks these entities based on their relevance.
+
+Confidence Estimation Based on Consistency. After generating a complete ranked list of candidate entities, to obtain a more consistent ranking, we measure the consistency (Wang et al., 2023a) of the LLM's predictions across multiple iterations. Specifically, we use the Reciprocal Rank as the initial confidence score for each predicted location. We then aggregate the scores for each entity across iterations to compute its final confidence score. The intuition behind this approach is that if the LLM consistently ranks a location higher in multiple iterations, it is more likely to be relevant.
+
+# 3.3 Open-source Model Fine-tuning
+
+Given the high costs of proprietary LLM APIs and data security concerns, we fine-tuned open-source models to improve their code localization capabilities and enable local deployment. We collect 433 successful trajectories generated with Claude-3.5, where the agent completed tasks from the SWEBench training set. Due to budget constraints, we sample an additional 335 trajectories generated by the initially fine-tuned Qwen2.5-32B model. Importantly, we only select successful trajectories where the model correctly localized the issues, creating a high-quality dataset of correct reasoning paths. These successful examples are then used to refine the same 32B model further, reinforcing effective reasoning patterns through this self-improvement loop. The entire dataset, combining both Claude-3.5 trajectories and successful Qwen2.5-32B samples, was then used to distill knowledge to a smaller 7B model.
+
+To fine-tune the smaller model, we employ Supervised Fine-Tuning (SFT) with LoRA (Hu et al., 2021). Our experiments show that this straightforward distillation method significantly enhances the performance of smaller models. See Appendix C.1.3 for more training details.
+
+# 4 LOC-BENCH: A New Benchmark for Code Localization
+
+# 4.1 Revisiting Existing Benchmark
+
+SWE-Bench(Jimenez et al., 2023) is a widely used benchmark that collects GitHub issues and corresponding code patches that resolve them. Xia et al. (2024); Suresh et al. (2024) adapt its subset, SWE-Bench-Lite, for code localization, treating the patched files and functions as the targets.
+
+However, existing datasets, including SWE-Bench, present challenges for effectively evaluating code localization methods. First, they are at risk of contamination, as they may include data overlapping with the repositories or issues used by modern models during pre-training. Second, existing datasets are not specifically designed for code localization (Tomassi et al., 2019). SWE-Bench, for instance, was created primarily to evaluate end-to-end bug-fixing capabilities, with localization being only an implicit intermediate step. This focus results in datasets dominated by bug reports (85% of SWE-Bench-Lite examples) while severely underrepresenting other common software maintenance tasks such as feature requests (14%), security vulnerabilities (1%), and performance optimizations (0%). This imbalance fails to capture the diverse localization challenges faced in real-world software development.
+
+# 4.2 Dataset Construction
+
+To address the limitations of existing benchmarks, we introduce LOC-BENCH, a new dataset specifically designed for code localization. This dataset collects up-to-date issues from Python repositories to mitigate the influence of pre-training bias in the latest LLMs. Additionally, LOC-BENCH covers wider categories, including bug reports, feature requests, security, and performance issues, enabling a more comprehensive evaluation of code localization methods. The statistics of LOC-BENCH are shown in Table 3.
+
+For the Bug Report category, we collect GitHub issues created after October 2024, which is later than the release dates of most modern LLMs. To enrich the dataset with more instances of security and performance issues, we use the GitHub Search API to search for relevant keywords, such as "latency improvement" for performance-related issues. We exclude instances that involve modifying more than five Python files or more than ten functions in the corresponding patch. For further details, see Appendix B.1.
+
+# 5 Experiments
+
+Our experiments aim to evaluate four key aspects of LOCAGENT: (1) the effectiveness of our graph-based representation and tooling for code localization compared to existing methods, (2) the performance of fine-tuned open-source models as cost-effective alternatives to proprietary LLMs, (3) a detailed analysis of how performance varies across
+
+<table><tr><td>Dataset</td><td>Category</td><td>#Sample</td></tr><tr><td rowspan="4">SWE-Bench-Lite (Total = 300)</td><td>Bug Report</td><td>254</td></tr><tr><td>Feature Request</td><td>43</td></tr><tr><td>Security Issue</td><td>3</td></tr><tr><td>Performance Issue</td><td>0</td></tr><tr><td rowspan="4">Loc-Bench (Totoal = 560)</td><td>Bug Report</td><td>242</td></tr><tr><td>Feature Request</td><td>150</td></tr><tr><td>Security Issue</td><td>29</td></tr><tr><td>Performance Issue</td><td>139</td></tr></table>
+
+Table 3: Distribution of samples across different categories in the SWE-Bench-Lite and Loc-Bench datasets.
+
+task categories, and (4) the contribution of each component in our framework through comprehensive ablation studies. We evaluate on both SWE-Bench-Lite and our introduced Loc-Bench dataset. Additionally, we examine the impact of improved localization on downstream software maintenance tasks.
+
+# 5.1 Experimental Settings
+
+Datasets. We first conduct experiments on SWEBench-Lite, treating the patched files and functions as the targets for localization. Following Suresh et al. (2024), we excluded examples where no existing functions were modified by the patch, ultimately retaining 274 out of the original 300 examples.
+
+Metrics. To assess performance, we use a modified accuracy metric inspired by R-Precision from information retrieval, following Agentless(Xia et al., 2024). To assess performance, we use Acc@k (Accuracy at k) as our evaluation metric, following Agentless(Xia et al., 2024). For each example, we select the top-k predicted locations and consider a localization attempt successful only if all relevant locations are correctly identified within these top-k predictions. This approach measures the ability to fully identify all necessary code sections that require modification. We report results across multiple  $k$  values: file localization at Acc@1, Acc@3, and Acc@5, and function localization at Acc@5 and Acc@10. Additionally, to provide a more relaxed evaluation criteria, we assess module localization, which only requires finding any function within the patched class.
+
+# 5.2 Baselines
+
+We evaluate LOCAGENT against three categories of competitive baselines: (a) Retrieval-based meth
+
+<table><tr><td rowspan="2">Type</td><td rowspan="2">Method</td><td rowspan="2">Loc-Model</td><td colspan="3">File (%)</td><td colspan="2">Module (%)</td><td colspan="2">Function (%)</td></tr><tr><td>Acc@1</td><td>Acc@3</td><td>Acc@5</td><td>Acc@5</td><td>Acc@10</td><td>Acc@5</td><td>Acc@10</td></tr><tr><td rowspan="5">Embedding-Based</td><td colspan="2">BM25 (Robertson et al., 1994)</td><td>38.69</td><td>51.82</td><td>61.68</td><td>45.26</td><td>52.92</td><td>31.75</td><td>36.86</td></tr><tr><td colspan="2">E5-base-v2 (Wang et al., 2022)</td><td>49.64</td><td>74.45</td><td>80.29</td><td>67.88</td><td>72.26</td><td>39.42</td><td>51.09</td></tr><tr><td colspan="2">Jina-Code-v2 (Günther et al., 2023)</td><td>43.43</td><td>71.17</td><td>80.29</td><td>63.50</td><td>72.63</td><td>42.34</td><td>52.19</td></tr><tr><td colspan="2">Codesage-large-v2 (Zhang et al., 2024)</td><td>47.81</td><td>69.34</td><td>78.10</td><td>60.58</td><td>69.71</td><td>33.94</td><td>44.53</td></tr><tr><td colspan="2">CodeRankEmbed (Suresh et al., 2024)</td><td>52.55</td><td>77.74</td><td>84.67</td><td>71.90</td><td>78.83</td><td>51.82</td><td>58.76</td></tr><tr><td rowspan="2">Procedure-Based</td><td rowspan="2">Agentless (Xia et al., 2024)</td><td>GPT-4o</td><td>67.15</td><td>74.45</td><td>74.45</td><td>67.15</td><td>67.15</td><td>55.47</td><td>55.47</td></tr><tr><td>Claude-3.5</td><td>72.63</td><td>79.20</td><td>79.56</td><td>68.98</td><td>68.98</td><td>58.76</td><td>58.76</td></tr><tr><td rowspan="9">Agent-Based</td><td rowspan="2">MoutlessTools (Örwall, 2024)</td><td>GPT-4o</td><td>73.36</td><td>84.31</td><td>85.04</td><td>74.82</td><td>76.28</td><td>57.30</td><td>59.49</td></tr><tr><td>Claude-3.5</td><td>72.63</td><td>85.77</td><td>86.13</td><td>76.28</td><td>76.28</td><td>64.60</td><td>64.96</td></tr><tr><td rowspan="2">SWE-agent (Yang et al., 2024)</td><td>GPT-4o</td><td>57.30</td><td>64.96</td><td>68.98</td><td>58.03</td><td>58.03</td><td>45.99</td><td>46.35</td></tr><tr><td>Claude-3.5</td><td>77.37</td><td>87.23</td><td>90.15</td><td>77.74</td><td>78.10</td><td>64.23</td><td>64.60</td></tr><tr><td rowspan="2">Openhands (Wang et al., 2025)</td><td>GPT-4o</td><td>60.95</td><td>71.90</td><td>73.72</td><td>62.41</td><td>63.87</td><td>49.64</td><td>50.36</td></tr><tr><td>Claude-3.5</td><td>76.28</td><td>89.78</td><td>90.15</td><td>83.21</td><td>83.58</td><td>68.25</td><td>70.07</td></tr><tr><td rowspan="3">LOCAGENT (Ours)</td><td>Qwen2.5-7B(ft)</td><td>70.80</td><td>84.67</td><td>88.32</td><td>81.02</td><td>82.85</td><td>64.23</td><td>71.53</td></tr><tr><td>Qwen2.5-32B(ft)</td><td>75.91</td><td>90.51</td><td>92.70</td><td>85.77</td><td>87.23</td><td>71.90</td><td>77.01</td></tr><tr><td>Claude-3.5</td><td>77.74</td><td>91.97</td><td>94.16</td><td>86.50</td><td>87.59</td><td>73.36</td><td>77.37</td></tr></table>
+
+Table 4: Performance comparison with baseline methods on code localization on SWE-bench lite. Results show the accuracy at file, module, and function levels. For Agent-Based methods, we use GPT-4o-2024-0513 (abbr. as GPT-4o) and Claude-3-5-sonnet-20241022 (abbr. as Claude-3.5) as the localization model. Additionally, the performance of our fine-tuned open-source models, Qwen2.5-7B(ft) and Qwen2.5-32B(ft), are included for comparison.
+
+ods: We include the sparse retrieval approach BM25 (Robertson et al., 1994) and several state-of-the-art embedding models, including the general-purpose E5-base-v2 (Wang et al., 2022) and specialized code embedding models such as JinaCode-v2 (Günther et al., 2023), Codesage-large-v2 (Zhang et al., 2024), and the current SOTA code embedding model CodeRankEmbed (Suresh et al., 2024). Proprietary embedding solutions were excluded due to API costs. (b) Procedure-based methods: We compare against Agentless (Xia et al., 2024), which employs a structured hierarchical approach to code localization without complex agent architectures. (c) Agent-based methods: We include several advanced agent frameworks designed for code exploration and modification, specifically OpenHands (Wang et al., 2025) (using its default CodeActAgent implementation), SWE-Agent (Yang et al., 2024), and MoatlessTools (Örwall, 2024). For implementation details, please refer to Appendix C.1.1.
+
+# 5.3 Evaluation Results on SWE-Bench-Lite
+
+As shown in Table 4, Agent-Based methods consistently outperform other approaches, and our method demonstrates competitive performance by achieving the best results across all levels of code localization. Unlike traditional retrieval-based methods, Agentless identifies only a limited number of locations due to its narrow repository scope, which hinders performance gains when considering a broader set of candidates. The results of the NDCG are presented in Table 11 in the Appendix.
+
+![](images/f929dd53f4adf74c47eab0524e9c10d9df2c8753a81e68bd756d7c86d5d4876b.jpg)
+
+![](images/dd0a043ec99e4aa7d3cdd9cab21f0f8c8ff70d258cc383c3b7961f81be3880dc.jpg)  
+Figure 3: Performance analysis at different difficulty levels for file- and function-level localization. All agent-based methods and Agentless use Claude-3.5 as the localization model. Hop  $N$  refers to the distances between functions mentioned in the issue description and the ground truth patch on our code graph.
+
+To further analyze the results, we examine performance across different task difficulty levels. We measure the task difficulty by calculating the shortest hops between the functions mentioned in the issue descriptions and the patched functions on our code graph (See Appendix C.1.2 for more details). As shown in Figure 3, performance decreases for all methods as the task becomes more challenging. However, Agent-based methods demonstrate better robustness as the difficulty increases, with
+
+![](images/594e4e848668151fa0f0d585dcf3a37fcc51677d8a82c5fdceaf97947d73c7bb.jpg)  
+Figure 4: Comparison of performance between the original and fine-tuned Qwen models. The metrics used are file-level Acc@5 and module/function-level Acc@10. Dashed lines represent the performance of the Claude-3.5 model for reference.
+
+our method maintaining competitive performance across various difficulty levels. Retrieval-based methods, such as E5-Base-v2 and CodeRankEmbed, perform poorly at the function level, even when the patched functions are explicitly mentioned in the query. This is because they treat the query as a whole, failing to capture fine-grained details. Agentless performs even worse than retrieval-based methods when exploration beyond the query is needed ( $hop \geq 0$ ) due to its simplistic localization process and limited view focused only on the repository structure.
+
+# 5.4 Fine-tuned Open-source Models
+
+Figure 4 demonstrates that after fine-tuning, both the 7B and 32B models show significant improvements on this task. LOCAGENT with finetuned Qwen-2.5-Coder-Instruct-32B (abbreviated as Qwen2.5-32B(ft)) achieves performance comparable to Claude-3.5, and LOCAGENT with Qwen2.5-7B(ft) also delivers results on par with that obtained using GPT-4o. As shown in Table 4, our method with Qwen2.5-32B(ft) outperforms nearly all baselines, including those that use larger and more powerful LLMs. The original 7B model performs poorly due to its limited tool-use capability (Chen et al., 2024). These results validate the feasibility of deploying our fine-tuned open-source models as promising alternatives to proprietary APIs, especially in resource-constrained applications.
+
+# 5.5 Efficiency Analysis
+
+Table 5 presents an efficiency analysis comparing agent-based methods in terms of cost and the number of agent interactions required. MoatlessTools demonstrates good cost-efficiency and requires relatively fewer rounds of interaction. However, the
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">LM</td><td rowspan="2">#Round</td><td rowspan="2">Cost($)</td><td>Acc@10</td></tr><tr><td>Cost</td></tr><tr><td rowspan="2">MoatlessTools</td><td>GPT-4o</td><td>5</td><td>0.46</td><td>1.3</td></tr><tr><td>Claude-3.5</td><td>5</td><td>0.46</td><td>1.4</td></tr><tr><td rowspan="2">SWE-agent</td><td>GPT-4o</td><td>8</td><td>0.56</td><td>0.8</td></tr><tr><td>Claude-3.5</td><td>9</td><td>0.67</td><td>1.0</td></tr><tr><td rowspan="2">Openhands</td><td>GPT-4o</td><td>15</td><td>0.83</td><td>0.6</td></tr><tr><td>Claude-3.5</td><td>13</td><td>0.79</td><td>0.9</td></tr><tr><td rowspan="3">Ours</td><td>Claude-3.5</td><td>7</td><td>0.66</td><td>1.2</td></tr><tr><td>Qwen2.5-7B(ft)</td><td>6</td><td>0.05</td><td>13.2</td></tr><tr><td>Qwen2.5-32B(ft)</td><td>9</td><td>0.09</td><td>8.6</td></tr></table>
+
+Table 5: Efficiency analysis comparing the average cost and number of agent interaction rounds required by different methods. The cost-efficiency of each method is evaluated using the ratio of function-level Acc@10 to average cost.  
+
+<table><tr><td>Model Setting</td><td>File Acc@5</td><td>Module Acc@10</td><td>Function Acc@10</td></tr><tr><td>Ours</td><td>88.32</td><td>82.85</td><td>71.53</td></tr><tr><td>w/o TraverseGraph</td><td>86.13</td><td>78.47</td><td>66.06</td></tr><tr><td>Relation Types: contain</td><td>86.50</td><td>79.56</td><td>66.42</td></tr><tr><td>Traverse Hops: 1</td><td>86.86</td><td>80.29</td><td>66.79</td></tr><tr><td>w/o RetrieveEntity</td><td>87.59</td><td>81.39</td><td>69.34</td></tr><tr><td>w/o SearchEntity</td><td>68.98</td><td>61.31</td><td>53.28</td></tr><tr><td>w/o BM25 index</td><td>75.18</td><td>68.98</td><td>60.22</td></tr></table>
+
+Table 6: The ablation study of our model. The metrics used here are file-level Acc@5, module-level Acc@10, and function-level Acc@10. The impact of removing or fixing components is analyzed to observe how each component contributes to the overall accuracy.
+
+dense embeddings it uses make it difficult and slow to adapt to fast-evolving codebases. SWE-agent and Openhands also show moderate costs but still do not match the efficiency of LOCAGENT. For LOCAGENT with Claude-3.5, although more rounds of interaction are required, the cost remains lower than that of Openhands, illustrating the token efficiency of our tool's outputs. LOCAGENT with fine-tuned Qwen models stands out for its superior efficiency<sup>1</sup>. Qwen2.5-7B(ft) is the most cost-efficient option, requiring only $0.05 per example, while Qwen2.5-32B(ft) offers a more cost-effective alternative to Claude-3.5. These results highlight the potential of fine-tuned open-source models as efficient alternatives, providing an optimal balance of cost-effectiveness and performance that surpasses other methods.
+
+# 5.6 Ablation Study
+
+We conduct an ablation study to evaluate the effectiveness of each component of our toolsets. Due to budget constraints, we use the fine-tuned Qwen-2.5-7B as the localization model for these experiments.
+
+(1) Each tool in our toolset plays a critical role in code localization performance. As shown in Table 6, removing any tool, especially the SearchEntity tool, leads to varying degrees of accuracy degradation, particularly in module and function level localization. This highlights the critical role each tool plays in identifying relevant modules and functions.  
+(2) The graph structure provides essential information for accurate code localization. Removing TraverseGraph tool decreases module and function level performance since the agent cannot obtain any structure information about the codebase and relies on reasoning capability to identify call relationship or directory structure. Adding contain relationship provides only marginal improvements compared to fully removing TraverseGraph, emphasizing the importance of the other three relationship types and explaining why our method surpasses others relying only on the repository structure.  
+(3) Multi-hop exploration is crucial for deep code understanding. When compared to the full setting, fixing  $Hops = 1$  leads to a moderate decline in file and module-level accuracy, but it causes a more significant decrease in function-level accuracy, underscoring the importance of multi-hop exploration for identifying relevant entities.  
+(4) Sparse indexing significantly enhances localization performance. Removing SearchEntity tool, or even partial removal of its index, causes a substantial drop in performance across all metrics. This demonstrates the effectiveness of building a sparse index on our code graph for improving localization performance.
+
+# 5.7 Evaluation Results on Loc-Bench
+
+To ensure the robustness and generalization of our methods and fine-tuned Qwen models, and to eliminate potential data leakage, we evaluate our new dataset. Since Loc-Bench includes examples that edit 1 to 5 files, we assess file localization at top-5 and top-10 ranks, and function/module localization at top-10 and top-15 ranks. Table 7 shows that our fine-tuned Qwen2.5-7B model exhibits strong gen
+
+![](images/40113cdec1e1feca7000cb77d3a5294a6135d63a0d343288699aecc05a7b7a58.jpg)
+
+![](images/f3ff500f60d006d9ab2100b2e34cdaaed024cc944a6d5f1861937bb334d1a3cf.jpg)  
+Figure 5: Performance analysis at different difficulty category for file- and function-level localization. All agent-based baselines and Agentless use Claude-3.5 as the localization model.
+
+eralization capabilities, maintaining competitive performance compared to SWE-agent using more expensive and strong model. These results highlight the practicality of the fine-tuned Qwen2.5-7B model for real-world applications. Despite being an open-source alternative, it achieves a performance comparable to Claude-3.5, supporting its feasibility as a cost-effective substitute for commercial models in practical scenarios.
+
+Additionally, we evaluate the performance across four different difficulty categories. Figure 5 clearly shows that our method outperforms other methods in almost all categories of code localization. However, it also highlights a noticeable decrease in performance across the other three categories compared to the Bug Report category. This performance gap likely reflects our training data distribution, which contained more bug report examples, potentially leading to scaffolds better optimized for bug localization tasks. This trend suggests that while our method is highly effective for bug report localization, there is still room for improvement in handling the other categories through more balanced training data and category-specific optimization strategies.
+
+# 5.8 Application: Better Localization Leads to More Solved GitHub Issues
+
+To assess the impact of localization methods on downstream tasks, we evaluated their effectiveness in solving GitHub issues. We choose Agentless as the baseline, ranking among the top-performing
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">Loc Model</td><td colspan="2">File (%)</td><td colspan="2">Module (%)</td><td colspan="2">Function (%)</td></tr><tr><td>Acc@5</td><td>Acc@10</td><td>Acc@10</td><td>Acc@15</td><td>Acc@10</td><td>Acc@15</td></tr><tr><td>IR-Based</td><td>CodeRankEmbed</td><td>74.29</td><td>80.89</td><td>63.21</td><td>67.50</td><td>43.39</td><td>46.61</td></tr><tr><td>Agentless</td><td>Claude-3.5</td><td>67.50</td><td>67.50</td><td>53.39</td><td>53.39</td><td>42.68</td><td>42.68</td></tr><tr><td>OpenHands</td><td>Claude-3.5</td><td>79.82</td><td>80.00</td><td>68.93</td><td>69.11</td><td>59.11</td><td>59.29</td></tr><tr><td>SWE-agent</td><td>Claude-3.5</td><td>77.68</td><td>77.68</td><td>63.57</td><td>63.75</td><td>51.96</td><td>51.96</td></tr><tr><td rowspan="2">LocAgent (Ours)</td><td>Qwen2.5-7B(ft)</td><td>78.57</td><td>79.64</td><td>63.04</td><td>63.04</td><td>51.43</td><td>51.79</td></tr><tr><td>Claude-3.5</td><td>83.39</td><td>86.07</td><td>70.89</td><td>71.07</td><td>59.29</td><td>60.71</td></tr></table>
+
+Table 7: Performance evaluation on the real-world LocBench dataset.  
+
+<table><tr><td>Method</td><td>Localization LM</td><td>Acc@5</td><td>Pass@1</td><td>Pass@10</td></tr><tr><td>Agentless</td><td>Claude-3.5</td><td>58.39</td><td>26.31</td><td>33.58</td></tr><tr><td rowspan="2">Ours</td><td>Qwen2.5-32B(ft)</td><td>69.34</td><td>26.79</td><td>36.13</td></tr><tr><td>Claude-3.5</td><td>73.36</td><td>27.92</td><td>37.59</td></tr></table>
+
+Table 8: Impact of localization accuracy on downstream bug repair tasks.
+
+open-source submissions on SWE-Bench-Lite. For consistency, we utilized Claude-3.5 as the editing model in conjunction with the Agentless editing method. Table 8 shows that the success rate for solving GitHub issues improves significantly with better code localization accuracy.
+
+# 6 Conclusion
+
+In conclusion, LOCAGENT enhances code localization by structuring codebases as graphs, enabling efficient repository-level exploration for LLM agents. With fine-tuned open-source models, our method achieves high localization accuracy while significantly reducing costs compared to larger proprietary models. Experimental results demonstrate the effectiveness of LOCAGENT in identifying relevant code components and improving downstream tasks.
+
+# Limitations
+
+First, our study primarily focused on fine-tuning Qwen-2.5-Coder models. Exploring a broader range of base models, including other open-source LLMs like CodeLlama, Mistral, or Yi, could provide valuable insights into model selection trade-offs. Additionally, investigating different finetuning approaches beyond LoRA, such as full finetuning or other parameter-efficient methods, could potentially yield better performance.
+
+Second, though we demonstrated improved bug repair performance with better localization, we only scratched the surface of potential downstream
+
+applications. Future work should evaluate LocAgent's impact on other software engineering tasks like refactoring, feature addition, security vulnerability patching, and performance optimization. This would provide a more comprehensive understanding of the framework's practical utility.
+
+Moreover, our fine-tuning process relied heavily on trajectories generated by Claude-3.5 and the fine-tuned Qwen2.5-32B model. A more diverse training dataset incorporating examples from different models, tasks, and repositories could improve the robustness and generalization of fine-tuned models. Additionally, analyzing the impact of different dataset compositions and filtering strategies on model performance could yield valuable insights.
+
+Finally, the current evaluation focuses primarily on Python codebases. Extending LOCAGENT to support other programming languages and evaluating its performance across different language paradigms would better demonstrate its generalizability. Further, our evaluation metrics could be expanded to include more nuanced measures of localization quality beyond accuracy and NDCG.
+
+# References
+
+Aider. 2023. Building a better repository map with tree sitter. Accessed: April 15, 2025.  
+Anthropic. 2023. Claude: Conversational ai by anthropic. Accessed: January 21, 2025.  
+artificialanalysis.ai. 2025. Artificial analysis. https://artificialanalysis.ai/models/. Accessed: 2025-04-28.  
+Marcel Böhme, Ezekiel O Soremekun, Sudipta Chattopadhyay, Emamurho Ugherughe, and Andreas Zeller. 2017. Where is the bug and how is it fixed? an experiment with practitioners. In Proceedings of the 2017 11th joint meeting on foundations of software engineering, pages 117-128.
+
+Zehui Chen, Weihua Du, Wenwei Zhang, Kuikun Liu, Jiangning Liu, Miao Zheng, Jingming Zhuo, Songyang Zhang, Dahua Lin, Kai Chen, et al. 2024. T-eval: Evaluating the tool utilization capability of large language models step by step. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 9510-9529.  
+Cognition.ai. 2024. Introducing devin, the first ai software engineer.  
+John Ellson, Emden Gansner, Lefteris Koutsofios, Stephen C North, and Gordon Woodhull. 2002. Graphviz—open source graph drawing tools. In Graph Drawing: 9th International Symposium, GD 2001 Vienna, Austria, September 23–26, 2001 Revised Papers 9, pages 483–484. Springer.  
+Bahare Fatemi, Jonathan Halcrow, and Bryan Perozzi. 2023. Talk like a graph: Encoding graphs for large language models. arXiv preprint arXiv:2310.04560.  
+Paul Gauthier. 2024. How aider scored sota  $26.3\%$  on swe bench lite | aider. Accessed: January 21, 2025.  
+Jiafeng Guo, Yixing Fan, Qingyao Ai, and W Bruce Croft. 2016. A deep relevance matching model for ad-hoc retrieval. In Proceedings of the 25th ACM international on conference on information and knowledge management, pages 55-64.  
+Jiafeng Guo, Yixing Fan, Liang Pang, Liu Yang, Qingyao Ai, Hamed Zamani, Chen Wu, W Bruce Croft, and Xueqi Cheng. 2020. A deep look into neural ranking models for information retrieval. Information Processing & Management, 57(6):102067.  
+Kelvin Guu, Kenton Lee, Zora Tung, Panupong Pasupat, and Mingwei Chang. 2020. Retrieval augmented language model pre-training. In International conference on machine learning, pages 3929-3938. PMLR.  
+Michael Gunther, Louis Milliken, Jonathan Geuter, Georgios Mastrupas, Bo Wang, and Han Xiao. 2023. Jina embeddings: A novel set of high-performance sentence embedding models. Preprint, arXiv:2307.11224.  
+Edward J Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2021. Lora: Low-rank adaptation of large language models. arXiv preprint arXiv:2106.09685.  
+Binyuan Hui, Jian Yang, Zeyu Cui, Jiaxi Yang, Dayiheng Liu, Lei Zhang, Tianyu Liu, Jiajun Zhang, Bowen Yu, Keming Lu, Kai Dang, Yang Fan, Yichang Zhang, An Yang, Rui Men, Fei Huang, Bo Zheng, Yibo Miao, Shanghaoran Quan, Yunlong Feng, Xingzhang Ren, Xuancheng Ren, Jingren Zhou, and Junyang Lin. 2024. Qwen2.5-coder technical report. Preprint, arXiv:2409.12186.  
+Hyperbolic. 2025. Hyperbolic website. https:// hyperbolic.xyz/. Accessed: 2025-04-15.
+
+Carlos E Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan. 2023. Swe-bench: Can language models resolve real-world github issues? arXiv preprint arXiv:2310.06770.  
+Sungmin Kang, Gabin An, and Shin Yoo. 2023. A preliminary evaluation of llm-based fault localization. arXiv preprint arXiv:2308.05487.  
+Sungmin Kang, Gabin An, and Shin Yoo. 2024. A quantitative and qualitative evaluation of llm-based explainable fault localization. Proceedings of the ACM on Software Engineering, 1(FSE):1424-1446.  
+Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, et al. 2020. Retrieval-augmented generation for knowledge-intensive nlp tasks. Advances in Neural Information Processing Systems, 33:9459-9474.  
+Xiangyan Liu, Bo Lan, Zhiyuan Hu, Yang Liu, Zhicheng Zhang, Fei Wang, Michael Shieh, and Wenmeng Zhou. 2024. Codexgraph: Bridging large language models and code repositories via code graph databases. Preprint, arXiv:2408.03910.  
+Qingsong Lv, Ming Ding, Qiang Liu, Yuxiang Chen, Wenzheng Feng, Siming He, Chang Zhou, Jianguo Jiang, Yuxiao Dong, and Jie Tang. 2021. Are we really making much progress? revisiting, benchmarking and refining heterogeneous graph neural networks. In Proceedings of the 27th ACM SIGKDD conference on knowledge discovery & data mining, pages 1150-1160.  
+Yingwei Ma, Qingping Yang, Rongyu Cao, Binhua Li, Fei Huang, and Yongbin Li. 2024. How to understand whole software repository? arXiv e-prints, pages arXiv-2406.  
+Niels Mündler, Mark Müller, Jingxuan He, and Martin Vechev. 2024. Swt-bench: Testing and validating real-world bug-fixes with code agents. Advances in Neural Information Processing Systems, 37:81857-81887.  
+OpenAI. 2023. Chatgpt: Language model by openai. Accessed: January 21, 2025.  
+Siru Ouyang, Wenhao Yu, Kaixin Ma, Zilin Xiao, Zhihan Zhang, Mengzhao Jia, Jiawei Han, Hongming Zhang, and Dong Yu. 2025. Repograph: Enhancing AI software engineering with repository-level code graph. In The Thirteenth International Conference on Learning Representations.  
+PerplexityAI. 2023. Perplexity ai: An ai-powered search engine. Accessed: January 21, 2025.  
+Yihao Qin, Shangwen Wang, Yiling Lou, Jinhao Dong, Kaixin Wang, Xiaoling Li, and Xiaoguang Mao. 2024. Agentfl: Scaling llm-based fault localization to project-level context. arXiv preprint arXiv:2403.16362.
+
+Chen Qu, Liu Yang, Cen Chen, Minghui Qiu, W Bruce Croft, and Mohit Iyyer. 2020. Open-retrieval conversational question answering. In Proceedings of the 43rd International ACM SIGIR conference on research and development in Information Retrieval, pages 539-548.  
+Stephen Robertson, Hugo Zaragoza, et al. 2009. The probabilistic relevance framework: Bm25 and beyond. Foundations and Trends® in Information Retrieval, 3(4):333-389.  
+Stephen E. Robertson, Steve Walker, Susan Jones, Micheline Hancock-Beaulieu, and Mike Gatford. 1994. Okapi at trec-3. In Text Retrieval Conference.  
+Tarun Suresh, Revanth Gangi Reddy, Yifei Xu, Zach Nussbaum, Andriy Mulyar, Brandon Duderstadt, and Heng Ji. 2024. Cornstack: High-quality contrastive data for better code ranking. arXiv preprint arXiv:2412.01007.  
+David A. Tomassi, Naji Dmeiri, Yichen Wang, Antara Bhowmick, Yen-Chuan Liu, Premkumar Devanbu, Bogdan Vasilescu, and Cindy Rubio-Gonzalez. 2019. Bugswarm: Mining and continuously growing a dataset of reproducible failures and fixes. Preprint, arXiv:1903.06725.  
+VoyageAI. 2024. Voyage-code-2: Elevate your code retrieval. Accessed: 2024-02-02.  
+Liang Wang, Nan Yang, Xiaolong Huang, Bixing Jiao, Linjun Yang, Daxin Jiang, Rangan Majumder, and Furu Wei. 2022. Text embeddings by weakly-supervised contrastive pre-training. arXiv preprint arXiv:2212.03533.  
+Xingyao Wang, Boxuan Li, Yufan Song, Frank F. Xu, Xiangru Tang, Mingchen Zhuge, Jiayi Pan, Yueqi Song, Bowen Li, Jaskirat Singh, Hoang H. Tran, Fuqiang Li, Ren Ma, Mingzhang Zheng, Bill Qian, Yanjun Shao, Niklas Muennighoff, Yizhe Zhang, Binyuan Hui, Junyang Lin, Robert Brennan, Hao Peng, Heng Ji, and Graham Neubig. 2025. Open hands: An open platform for AI software developers as generalist agents. In The Thirteenth International Conference on Learning Representations.  
+Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. 2023a. Self-consistency improves chain of thought reasoning in language models. Preprint, arXiv:2203.11171.  
+Yue Wang, Hung Le, Akhilesh Deepak Gotmare, Nghi D. Q. Bui, Junnan Li, and Steven C. H. Hoi. 2023b. Codet5+: Open code large language models for code understanding and generation. Preprint, arXiv:2305.07922.  
+Zora Zhiruo Wang, Akari Asai, Xinyan Velocity Yu, Frank F. Xu, Yiqing Xie, Graham Neubig, and Daniel Fried. 2024. Coderag-bench: Can retrieval augment code generation? Preprint, arXiv:2406.14497.
+
+Yonghao Wu, Zheng Li, Jie M Zhang, Mike Papadakis, Mark Harman, and Yong Liu. 2023. Large language models in fault localisation. arXiv preprint arXiv:2308.15276.  
+Chunqiu Steven Xia, Yinlin Deng, Soren Dunn, and Lingming Zhang. 2024. Agentless: Demystifying llm-based software engineering agents. arXiv preprint arXiv:2407.01489.  
+John Yang, Carlos E Jimenez, Alexander Wettig, Kili-ian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press. 2024. Swe-agent: Agent-computer interfaces enable automated software engineering. arXiv preprint arXiv:2405.15793.  
+Zhongming Yu, Hejia Zhang, Yujie Zhao, Hanxian Huang, Matrix Yao, Ke Ding, and Jishen Zhao. 2025. Ocaloca: An llm agent framework for software issue localization. arXiv preprint arXiv:2502.00350.  
+Dejiao Zhang, Wasi Uddin Ahmad, Ming Tan, Hantian Ding, Ramesh Nallapati, Dan Roth, Xiaofei Ma, and Bing Xiang. 2024. CODE REPRESENTATION LEARNING AT SCALE. In The Twelfth International Conference on Learning Representations.  
+Albert Örwall. 2024. Moatless tools.
+
+# A LOCAGENT Design Details
+
+# A.1 Tool Output Design
+
+# A.1.1 Three-level format for SearchEntity output
+
+Once invoked by the LLM agent, the retrieval APIs search for files, classes, methods, and code snippets in the codebase, and return the results back to the agent. To avoid forming very lengthy code context that may containing noisy information to LLM, we return only necessary information as API outputs. To achieve this, we desgined four granular standard output formats (Figure 6): fold, preview, full code.
+
+# A.1.2 Tree-based Subgraph Formatting for TraverseGraph Output
+
+The TraverseGraph tool traverses the code graph and returns a local subgraph for each input entity. The agent reasons about these subgraphs to understand each entity's complex dependencies. However, reasoning about graphs remains challenging for LLMs. Research by (Fatemi et al., 2023) demonstrates that LLM performance varies significantly based on graph formatting (how graphs are encoded as text). This makes the format design for output subgraphs crucial.
+
+We have developed a new tree-based format, shown in Figure 7, with several features that enhance LLM reasoning: (1) We represent subgraphs as trees, allowing LLMs to use indentation to determine a node's distance from the root, (2) We display complete entity IDs for each node (e.g., django/core-validators.py:RegexValidator) to help LLMs locate nodes easily, and (3) We explicitly specify relation types for each edge, including reversed relations
+
+To evaluate how different graph formats impact code localization performance, we conducted an experiment using 37 challenging samples from SWEBench-Lite. These samples were considered "challenging" because they could not be solved by any baseline agent methods. Using Claude-3.5 as the Localization Model across all settings, we compared various output formats. Table 9 presents our findings. The baseline output formats we tested are described below:
+
+- row: For each line, list one row of the adjacency matrix. For example,
+
+function "fileA.py:funcA" invokes function "fileA.py:funcB", "fileA.py:funcC"
+
+- row (w/ entity attributes): Additionally include entity attributes for format row.  
+- incident: The incident format mentioned in (Fatemi et al., 2023). An integer instead of entity ID is used to represent each node. For example,
+
+Map function "fileA.py:funcA" to index 0. Map function "fileA.py:funcB" to index 1. Map function "fileA.py:funcC" to index 2.
+
+function  $O$  invokes function 1,2.
+
+Graphviz DOT: Represent graph in Graphviz DOT language (Ellson et al., 2002).  
+- JSON: Expand the subgraph as a tree, and convert it to JSON format.
+
+As shown in Table 9, expanding subgraphs as trees (i.e., JSON, tree-based) can significantly improve the performance. Our tree-based format achieves the best overall performance across different levels of localization tasks. We also test returning entity attributes along with subgraphs. We notice that row (w/ entity attributes) consistently underperforms row, indicating the attributes for all the nodes may be very noisy. Besides, although using incident format can simplify the output and show improvements in file-level localization, it degradation the module- and file-level localization.
+
+# A.2 Implementation
+
+To enable the LLM agent to invoke the Code Localization APIs, we handle the interaction differently based on the LLM's capabilities. For LLMs that support tool-calling features, we define the tools as a list of JSON objects, which are then used as parameters for the API calls. For LLMs that do not support tool-calling (such as Qwen), we provide the description of the API and the expected output as part of the LLM's prompt. When the agent decides to invoke a set of retrieval APIs, it responds with a list of API call names and their corresponding arguments. These retrieval API requests are processed locally by searching over the built code graph. The results from executing these APIs locally are returned to the agent.
+
+By default, we query the LLM with a temperature setting of 1.0. We conduct two interactions, after which we rerank the results based on mean reciprocal rank (MRR) scores. We also leverage multiprocessing execution to speed up the process. Since all our tools are read-only, LOCAGENT does
+
+![](images/e3da4d4339e99b1a14d6f8d73ea975c643cc44ad95a8dc1803fff42294d4f99a.jpg)  
+Figure 6: Different output formats designed for efficient agent-code interaction. Left: Full code output when matched entities  $\leq 3$ . Middle: Preview output showing module skeleton for large files. Right: Fold output showing only entity IDs when matches  $>3$ .
+
+![](images/003dcde246a439f5b9b36cc33df7c37daaa5e4eaf0478ed30be80b30cbe72965.jpg)
+
+![](images/86b464c56ef20eb2e4a58b1077f46f88aa113910e37ea427df9e03b94670489d.jpg)
+
+![](images/503072355158697ea6cb6ac7e2712ec0ffc412f1cd70207465e4cb36e21f3c9b.jpg)  
+Figure 7: A truncated example of the expanded tree-based format for the output subgraph of tool TraverseGraph.
+
+not require a specialized Docker environment to operate.
+
+# B Dataset construction and statistics
+
+# B.1 Dataset construction details
+
+Example collection. We collected examples on popular Python repositories on Github follow (Jimenez et al., 2023). To gather issues related to performance and security, we searched for the keywords listed in Table 10 using the GitHub Search APIs. We then used GPT-4o-2024-0513 as the classifier based on the issue descriptions.
+
+Ground Truth Locations. The affected files or functions in the original codebase, as identified in
+
+the patches, are considered the target locations for the given issue. While it is possible to fix a bug in a location different from the ground truth, the extracted ground-truth locations still serve as approximate targets for localization. Additionally, edited code such as documents, import statements, and comments are excluded from the localization target. These elements are not considered relevant for bug localization, as they do not directly impact the functionality of the code or its execution. By filtering out these elements, the focus is maintained on the core code changes that are relevant for localization.
+
+<table><tr><td rowspan="2">Output Format</td><td colspan="3">File(%)</td><td colspan="2">Module(%)</td><td colspan="2">Function(%)</td></tr><tr><td>Acc@1</td><td>Acc@3</td><td>Acc@5</td><td>Acc@5</td><td>Acc@10</td><td>Acc@5</td><td>Acc@10</td></tr><tr><td>row</td><td>41.18</td><td>67.65</td><td>70.59</td><td>61.76</td><td>61.76</td><td>35.29</td><td>38.24</td></tr><tr><td>row (w/ entity attributes)</td><td>41.18</td><td>64.71</td><td>64.71</td><td>50.00</td><td>50.00</td><td>32.35</td><td>32.35</td></tr><tr><td>incident</td><td>41.18</td><td>70.59</td><td>73.53</td><td>55.88</td><td>55.88</td><td>29.41</td><td>32.35</td></tr><tr><td>Graphviz DOT</td><td>41.18</td><td>73.53</td><td>82.35</td><td>64.71</td><td>64.71</td><td>35.29</td><td>35.29</td></tr><tr><td>JSON</td><td>41.18</td><td>67.65</td><td>76.47</td><td>67.65</td><td>70.59</td><td>38.24</td><td>41.18</td></tr><tr><td>tree-based (Ours)</td><td>47.06</td><td>79.41</td><td>79.41</td><td>64.71</td><td>64.71</td><td>38.24</td><td>41.18</td></tr></table>
+
+Table 9: Localization performance under different TraverseGraph output formats.  
+
+<table><tr><td>Category</td><td>Keywords</td></tr><tr><td>Performance</td><td>bottleneck, performance improvement, memory usage optimization, time complexity reduction, latency improvement, scalability improvement, CPU usage reduction, caching improvement, concurrency optimization</td></tr><tr><td>Security</td><td>Out-of-bounds Write, Out-of-bounds Read, NULL Pointer Dereference, Missing Authorization, memory leak fix, security vulnerability, security issue, authentication bypass, authentication issue, better maintained, buffer overflow, denial of service, security hardening, security patch, unsafe deserialization, Use After Free, Integer Overflow or Wraparound, Uncontrolled Resource Consumption, Missing Authentication for Critical Function</td></tr></table>
+
+Table 10: We use these Keywords to search for Performance and Security related issues with Github Search APIs.
+
+# C Additional Experiments
+
+# C.1 Implementation Details
+
+# C.1.1 Baselines Implementation
+
+Regarding the embedding-based methods in our evaluation, these approaches operate primarily at the function level, where each function is embedded as a separate unit. The function's context (its containing file and class) is appended to the function representation before embedding, rather than being embedded separately. While theoretically these methods could employ hierarchical indexing, the standard implementations we evaluated use flat indexing structures where each function is embedded as a single unit.
+
+We use OpenHands's remote runtime feature to parallelize evaluation on OpenHands and SWEagent. We use Openhands version 0.12.0 released on Oct 31, 2024.
+
+# C.1.2 Quantifying Task Difficulty Based on Code Graph Distance
+
+We measure task difficulty by computing the average shortest hop distance between the functions mentioned in the issue descriptions and the patched functions within our code graph. Specifically, we first extract potential function names from each
+
+issue description using GPT-4o-2024-0513, and identify their corresponding nodes in the code graph using the global dictionary. These identified nodes form the set of predicted nodes, denoted as  $\mathcal{C}$ . Similarly, we link the ground truth functions from the patch to their corresponding nodes in the code graph, forming the set of target nodes, denoted as  $\mathcal{T}$ . To quantify the difficulty  $\delta$ , we calculate the average shortest hop distance between the predicted nodes  $\mathcal{C}$  and the target nodes  $\mathcal{T}$ , defined as:
+
+$$
+\delta = \frac {1}{| \mathcal {C} |} \sum_ {c \in \mathcal {C}} \frac {1}{m i n _ {t \in \mathcal {T}} d (c , t) + 1}
+$$
+
+where  $d(c, t)$  represents the shortest hop distance between nodes  $c$  and  $t$  in the graph. For performance analysis stratified by difficulty, we round  $\delta$  down to  $\lfloor \delta \rfloor$  to group samples by difficulty levels, and we exclude samples where the LLM fails to extract any valid function names.
+
+# C.1.3 Training details.
+
+Fine-tuning Settings. We use Qwen-2.5-Coder-Instruct (Hui et al., 2024) 7B and 32B variants as our base models. We fine-tuned Qwen-2.5-Coder-Instruct 7B and 32B models on 768 training samples from the SWE-Bench training dataset, leveraging LoRA
+
+<table><tr><td rowspan="2">Type</td><td rowspan="2">Method</td><td rowspan="2">Loc-Model</td><td colspan="3">File (%)</td><td colspan="2">Module (%)</td><td colspan="2">Function (%)</td></tr><tr><td>NDCG@1</td><td>NDCG@3</td><td>NDCG@5</td><td>NDCG@5</td><td>NDCG@10</td><td>NDCG@5</td><td>NDCG@10</td></tr><tr><td rowspan="5">Embedding-Based</td><td>BM25 (Robertson et al., 2009)</td><td>38.69</td><td>46.5</td><td>50.61</td><td>37.31</td><td>39.86</td><td>26.15</td><td>27.92</td><td></td></tr><tr><td>E5-base-v2 (Wang et al., 2022)</td><td>49.64</td><td>64.19</td><td>66.6</td><td>53.15</td><td>54.45</td><td>31.39</td><td>35.3</td><td></td></tr><tr><td>Jina-Code-v2 (Günther et al., 2023)</td><td>43.43</td><td>59.93</td><td>63.7</td><td>51.02</td><td>54.13</td><td>33.28</td><td>36.44</td><td></td></tr><tr><td>Codesage-large-v2 (Zhang et al., 2024)</td><td>47.81</td><td>60.82</td><td>64.39</td><td>49.38</td><td>52.22</td><td>27.03</td><td>30.74</td><td></td></tr><tr><td>CodeRankEmbed (Suresh et al., 2024)</td><td>52.55</td><td>67.54</td><td>70.39</td><td>57.51</td><td>59.76</td><td>40.28</td><td>42.55</td><td></td></tr><tr><td rowspan="2">Procedure-Based</td><td rowspan="2">Agentless (Xia et al., 2024)</td><td>GPT-4o</td><td>67.15</td><td>71.76</td><td>71.76</td><td>64.31</td><td>64.31</td><td>53.81</td><td>53.81</td></tr><tr><td>Claude-3.5</td><td>72.63</td><td>76.72</td><td>76.87</td><td>67.36</td><td>67.36</td><td>57.55</td><td>57.55</td></tr><tr><td rowspan="9">Agent-Based</td><td rowspan="2">MoatlessTools (Örwall, 2024)</td><td>GPT-4o</td><td>73.36</td><td>80.03</td><td>80.33</td><td>68.57</td><td>69.09</td><td>49.77</td><td>50.62</td></tr><tr><td>Claude-3.5</td><td>72.63</td><td>80.73</td><td>80.88</td><td>69.11</td><td>69.11</td><td>53.03</td><td>53.16</td></tr><tr><td rowspan="2">SWE-agent (Yang et al., 2024)</td><td>GPT-4o</td><td>57.3</td><td>63.96</td><td>64.12</td><td>53.95</td><td>53.95</td><td>42.32</td><td>42.44</td></tr><tr><td>Claude-3.5</td><td>77.37</td><td>84.32</td><td>84.93</td><td>72.77</td><td>72.9</td><td>59.67</td><td>59.79</td></tr><tr><td rowspan="2">Openshands (Wang et al., 2025)</td><td>GPT-4o</td><td>60.95</td><td>67.62</td><td>68.39</td><td>58.18</td><td>58.6</td><td>44.34</td><td>44.66</td></tr><tr><td>Claude-3.5</td><td>76.28</td><td>84.27</td><td>84.43</td><td>75.79</td><td>75.92</td><td>63.13</td><td>63.8</td></tr><tr><td rowspan="3">LocAgent (Ours)</td><td>Qwen2.5-7B(ft)</td><td>70.80</td><td>79.36</td><td>80.9</td><td>70.99</td><td>71.68</td><td>55.62</td><td>58.09</td></tr><tr><td>Qwen2.5-32B(ft)</td><td>75.91</td><td>84.74</td><td>85.64</td><td>76.28</td><td>76.77</td><td>64.27</td><td>65.93</td></tr><tr><td>Claude-3.5</td><td>77.74</td><td>86.19</td><td>87.14</td><td>77.73</td><td>78.1</td><td>64.34</td><td>65.57</td></tr></table>
+
+Table 11: NDCG scores comparison showing ranking quality of different methods.
+
+for efficient adaptation. The training set included 447 samples generated by Claude-3.5, while the remaining samples were iteratively generated using the fine-tuned Qwen2.5-32B model. The fine-tuning process was conducted over 5 epochs with max_token set to  $128k$  and a learning rate of  $2 \times 10^{-4}$ .
+
+# D Prompt
+
+In this section, we go through the prompt template that make up the agent's history.
+
+# Prompt
+
+Given the following GitHub problem description, your objective is to localize the specific files, classes or functions, and lines of code that need modification or contain key information to resolve the issue.
+
+Follow these steps to localize the issue:
+
+Step 1: Categorize and Extract Key Problem Information
+
+- Classify the problem statement into the following categories:  
+Problem description, error trace, code to reproduce the bug, and additional context.  
+- Identify modules in the '{package_name}' package mentioned in each category.  
+- Use extracted keywords and line numbers to search for relevant code references for additional context.
+
+Step 2: Locate Referenced Modules
+
+Accurately determine specific modules
+
+- Explore the repo to familiarize yourself with its structure.
+
+- Analyze the described execution flow to identify specific modules or components being referenced.
+
+- Pay special attention to distinguishing between modules with similar names using context and described execution flow.
+
+- Output Format for collected relevant modules:
+
+- Use the format: 'file path:QualifiedName'
+
+- E.q., for a function `calculate_sum` in the `MathUtilities` class located in `src/helpers/mathHelpers.py`, represent it as:
+
+'src/helpers/mathHelpers.py:MathUtil calculator_sum'.
+
+## Step 3: Analyze and Reproducing the Problem
+
+Clarify the Purpose of the Issue
+
+- If expanding capabilities: Identify where and how to incorporate new behavior, fields, or modules.
+
+- If addressing unexpected behavior: Focus on localizing modules containing potential bugs.
+
+- Reconstruct the execution flow
+
+- Identify main entry points triggering the issue.
+
+- Trace function calls, class interactions, and sequences of events.
+
+- Identify potential breakpoints causing the issue.
+
+Important: Keep the reconstructed flow focused on the problem, avoiding irrelevant details.
+
+## Step 4: Locate Areas for Modification
+
+- Locate specific files, functions, or lines of code requiring changes or containing critical information for resolving the issue.
+
+- Consider upstream and downstream dependencies that may affect or be affected by the issue.
+
+- If applicable, identify where to introduce new fields, functions, or variables.
+
+- Think Thoroughly: List multiple potential solutions and consider edge cases that could impact the resolution.
+
+Output Format for Final Results:
+
+Your final output should list the locations requiring modification, wrapped with triple back ticks
+
+Each location should include the file path, class name (if applicable), function name, or line numbers, ordered by importance.
+
+Your answer would better include about 5 files.
+
+Examples:
+
+full_path1/file1.py
+
+line: 10
+
+class: MyClass1
+
+function: my_function1
+
+full path2/file2.py
+
+line:76
+
+function: MyClass2.my_function2
+
+full_path3/file3.py
+
+line: 24
+
+line: 156
+
+function: my_function3
+
+#
+
+Return just the location(s)
+
+Note: Your thinking should be thorough and so it's fine if it's very long.
+
+Figure 8: The task instruction prompt for LOCAGENT.

data/2025/2503_09xxx/2503.09198/ef3c6a72-d844-464a-90c5-502ddc16df65_content_list.json

@@ -0,0 +1,1213 @@
+[
+    {
+        "type": "text",
+        "text": "A 3D particle visualization system for temperature management",
+        "text_level": 1,
+        "bbox": [
+            194,
+            112,
+            803,
+            175
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Lange B.  $^{a}$ , Rodriguez N.  $^{a}$ , Puech W.  $^{a}$ , Rey H.  $^{b}$  and Vasques X.  $^{b}$",
+        "bbox": [
+            333,
+            200,
+            661,
+            233
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "$^{a}$  LIRMM, 141 rue ADA, Montpellier, France;",
+        "bbox": [
+            330,
+            234,
+            666,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "<sup>b</sup> IBM, Rue de la vieille poste, Montpellier,",
+        "bbox": [
+            338,
+            252,
+            658,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "France",
+        "bbox": [
+            470,
+            270,
+            527,
+            284
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract",
+        "text_level": 1,
+        "bbox": [
+            465,
+            314,
+            531,
+            328
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper deals with a 3D visualization technique proposed to analyze and manage energy efficiency from a data center. Data are extracted from sensors located in the IBM Green Data Center in Montpellier France. These sensors measure different information such as hygrometry, pressure and temperature. We want to visualize in real-time the large among of data produced by these sensors. A visualization engine has been designed, based on particles system and a client server paradigm. In order to solve performance problems, a Level Of Detail solution has been developed. These methods are based on the earlier work introduced by J. Clark in  $1976^{1}$ . In this paper we introduce a particle method used for this work and subsequently we explain different simplification methods applied to improve our solution.",
+        "bbox": [
+            214,
+            337,
+            785,
+            513
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Keywords: 3D Visualization, Sensors, Particles, Client/Server, Level Of Details",
+        "bbox": [
+            143,
+            526,
+            733,
+            541
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1. INTRODUCTION",
+        "text_level": 1,
+        "bbox": [
+            145,
+            575,
+            370,
+            595
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we present a method to produce a 3D visualization for analyzing and managing temperature. Data are extracted from sensors located in the IBM Green Data Center in Montpellier, which provides many different types of information like temperature, pressure or hygrometry. In our system, sensors are placed in a virtual room and the internal space is modeled using particles. The main constraint here is to produce a real-time rendering. However, latency appears du to the number of vertices. In this paper, we use a solution called LOD (Level Of Detail) to produce multi resolution 3D objects. This solution has been introduced in 1976 by J. Clark<sup>1</sup>. In this paper, J. Clark introduces the use of several mesh resolutions to simplify the 3D scene complexity. In our work, we use various simplification methods to provide interactive rendering and allows rendering the most important part of data extracted from sensors. In this paper, we describe how we create a room, and the methods used to produce different resolution visualization. In Section 2, we introduce related work on particles systems and LOD. In Section 3, we expose our solution to simplify particles system. In Section 4 we give some results and finally, in Section 5 we present our conclusions and future work.",
+        "bbox": [
+            142,
+            609,
+            841,
+            864
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "page_number",
+        "text": "1/10",
+        "bbox": [
+            483,
+            970,
+            514,
+            979
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2. RELATED WORK",
+        "text_level": 1,
+        "bbox": [
+            145,
+            69,
+            375,
+            88
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section we present several previous works concerning data visualization, particle systems and level of detail methods.",
+        "bbox": [
+            143,
+            104,
+            828,
+            136
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Some previous work present solutions to visualize large data flow extracted from mantle convection. M. Damon et al.  $^{2}$  and K. E. Jordan et al.  $^{3}$  present interactive viewers for this kind of data. These data are computed by using Hight Performance Computing (HPC) and visualized on a large display. The rendering is calculated by using another HPC. The data flow is very important and a real-time 3D simulation is hard to obtain. W. Kapfer and",
+        "bbox": [
+            143,
+            138,
+            836,
+            222
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "T. Riser<sup>6</sup> introduce how to use particle system to visualize astronomic simulation, particles representing space objects. The number of particles is extremely important for computing motion in real-time. GPU computing is preferred to render instead of a common HPC solution. To display their data, they have developed their own 3D graphical engine. The space objects are represented by point sprite instead of sphere. Lights are used to give a spherical aspect to the point sprite. This solution allows to render more stars than spherical object method. The 3D engine provides different rendering methods to group space objects: cell simplification or extraction of isosurface. The use of GPU seems quite well for a particle solution, parallel processing allows to render large data; the astrological data seems to be well suited.",
+        "bbox": [
+            143,
+            234,
+            851,
+            404
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In 1976, J. Clark introduces Level Of Detail (LOD) concept<sup>1</sup>. LOD consists of several resolution meshes for using them at different distances from the camera. Firstly, designer produces these meshes. First algorithms, in 1992 Schroeder et al. developed a method by decimation for simplify the mesh<sup>7</sup>. It analyses mesh geometry and evaluates the complexity of triangles. Vertices are removed if only constraints set by the user are respected. Vertices are removed and gaps are filled using triangulation. These algorithms of simplification are not enough to simplify mesh efficiently because shape is not always totally respected. D. Luebke, in 1997, has proposed a taxonomy of mesh simplification<sup>8</sup>. He presented the most used algorithms. He extracted different ways to use each algorithm. But in this paper, only one solution works with volumetric mesh<sup>9</sup>. T. He et al. propose a method based on voxel simplification by using a grid for clustering voxels. A marching cube<sup>10</sup> algorithm was applied to produce a surface mesh. But this simplification algorithm did not preserve the shape of the mesh. In our work, we look for point cloud simplification. Indeed, previous methods which deal with simplification for surface point cloud like<sup>11-13</sup> are not adapted to our case. All of these methods produce LOD for surface mesh and point cloud is extracted from scanner.",
+        "bbox": [
+            143,
+            406,
+            851,
+            676
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3. PROPOSED APPROACH",
+        "text_level": 1,
+        "bbox": [
+            145,
+            710,
+            452,
+            729
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This section presents the different methods that are used to visualize a kind of data from Green Data Center (GDC). The main goal is to be able to visualize in real-time the evolution of temperature in the data center. For this, we use a special particle method. Particles are located using a segmentation algorithm based on Voronoi cell extraction and Delaunay triangulation. The latency due to the large flow of particles is avoided by using a client server paradigm. We improve our solution by using LOD methods to simplify rendering.",
+        "bbox": [
+            143,
+            744,
+            844,
+            847
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "page_number",
+        "text": "2/10",
+        "bbox": [
+            483,
+            970,
+            514,
+            979
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1 Particle systems",
+        "text_level": 1,
+        "bbox": [
+            142,
+            68,
+            333,
+            85
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Rooms are the bases of our study. For modeling a room, we extract the shape of the space representation which is composed by a box with three measures: length  $(l \\in \\mathbb{R})$ , width  $(w \\in \\mathbb{R})$ , height  $(h \\in \\mathbb{R})$ . Sensors are represented by  $S = \\{\\mathrm{S}_1, \\dots, \\mathrm{S}_M\\}$ , where  $M$  is the number of sensors. Sensors  $\\mathrm{S}_i (\\mathrm{i} \\in \\{1, \\dots, M\\})$  are placed on the space on a layer  $\\mathbf{L} \\in \\mathbb{N}$  and have a location represented by:  $\\{\\mathbf{X}_i, \\mathbf{Y}_i, \\mathbf{L}_j\\}$  with  $\\mathbf{X}_i \\in \\mathbb{R}$ ,  $\\mathbf{Y}_i \\in \\mathbb{R}$  and  $j$  is the layer used. For modeling the space inside a room, we use a particle system instead of 2D map representations which have some lacks. $^{14}$  Actually 2D map does not allow having a real visualization of space. A particle visualization gives a better efficiency for modeling space. We use a large number of particles to represent the entire space.  $\\mathbf{N} \\in \\mathbb{N}$  represents the number of particles in the room. It can be calculated using:",
+        "bbox": [
+            138,
+            97,
+            844,
+            270
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "text": "\n$$\nN = \\frac {\\left(\\left(l + 1\\right) \\times (h + 1) \\times (w + 1)\\right)}{\\delta^ {3}} \\tag {1}\n$$\n",
+        "text_format": "latex",
+        "bbox": [
+            179,
+            277,
+            524,
+            316
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where  $\\delta \\in \\mathbb{R}$  is the space between particles. The particle grid is regular. In this model, three layers of temperature sensors compose rooms. They are defined according to their real locations in the data center. Figure ?? presents the different layers of sensors in the data center.",
+        "bbox": [
+            138,
+            329,
+            841,
+            395
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Particles carry information, and flow motion can be simulated if needed by changing the value of particles and the computational cost is inferior.",
+        "bbox": [
+            138,
+            398,
+            836,
+            433
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 Segmentation algorithms",
+        "text_level": 1,
+        "bbox": [
+            140,
+            448,
+            418,
+            467
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In our solution, each sensors has an influence on surrounding particules. To calculate the set of particles in the sensor range, we use two methods: Voronoi cells extraction and Delaunay triangulation.",
+        "bbox": [
+            138,
+            477,
+            834,
+            527
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Voronoi cells is a method to extract a partition of space  $^{15}$ . This method is available for  $\\phi$  dimensions where  $\\phi \\in [1, +\\infty]$ , but most of implementations are done in 2D. Tools for extracting 3D Voronoi diagrams exist: Voro++ and QHull but particles are discrete and these solutions are not suitable because they extract Voronoi diagram in a continuous way. Then we designed our own method based on sphere expansion. We search nearest sensors for each particle. This part allows to weight particles outside the sensors mesh. A second method to weight the interior of the sensors mesh is used. We extract the mesh tetrahedron of sensors using the Delaunay triangulation implemented in QHull. This method was used to analyze the location of particle. We compute the exact location using ray tracing on the soup of tetrahedron. First, we search the nearest particles inside the hull of each tetrahedron. We extract the normal of each face of tetrahedron and we apply these normals on each particle. If the ray cuts three faces or more, the particle is inside the tetrahedron. This method is cost expensive and done in preprocessing. Moreover, particles are static and position didn't need to be update.",
+        "bbox": [
+            138,
+            527,
+            854,
+            768
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.3 Client server paradigm",
+        "text_level": 1,
+        "bbox": [
+            140,
+            782,
+            398,
+            801
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To improve computation, a client server paradigm is used. We define a low cost communication protocol to transfer data from a server to a client. Server computes the modification of particles and the client displays the results. This protocol works in five steps. These steps are: sending header, sending sensor data, sending particle data, sending footer and receiving acknowledgment/language command from client. At each step, the server waits the acknowledgment from the client. We develop two ways to send data. The first sends the entire point cloud (sensors and particles). The biggest problem of this method is the",
+        "bbox": [
+            138,
+            811,
+            849,
+            931
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "page_number",
+        "text": "3/10",
+        "bbox": [
+            480,
+            969,
+            517,
+            979
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "transmission of data. Sensors are sent with their coordinates and their value. We encode these data in bit words. For the particles data, the same method was used. The footer was sent for closing the communication. The second method is used to reduce efficiently the communication cost. We only send modified sensors and particles. The id and the new value is sent instead of coordinates. The last step is the command sent by the client. It allows the user to interact with the server. We use it to modify the camera viewpoint.",
+        "bbox": [
+            138,
+            65,
+            830,
+            167
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 Level of detail for particles",
+        "text_level": 1,
+        "bbox": [
+            142,
+            183,
+            434,
+            200
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Level of detail (LOD) is one of the most important methods in computer graphics. It allows to solve rendering problems or performance problems. This method consists by producing several resolution of a 3D object. In our works, we use some features to define the object resolution: hardware and viewpoint. Hardware and viewpoint do not need the same data structure and we need to recompute it for each modification of the viewpoint or when hardware changes. LOD was defined by two problems statement. The first one uses a sample of original points, the second one uses a new point data set. In this part, we define six methods to produce LOD. The four first methods are for the client, the other are for the server.",
+        "bbox": [
+            138,
+            210,
+            848,
+            363
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Problems statement:",
+        "text_level": 1,
+        "bbox": [
+            140,
+            378,
+            307,
+            392
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For this two approaches, we have a set  $\\omega$  of Vertices  $V$ ,  $V = \\{V_1, \\ldots, V_\\omega\\}$ . Each vertex is defined in  $\\mathbb{R}^3$ . Simplify a mesh using a sample vertex means  $\\omega > \\omega 2$ , where  $\\omega 2$  is the size of the second data set. For approach 1, we obtain a new object  $\\mathrm{V}2 = \\{\\mathrm{V}2_1, \\ldots, \\mathrm{V}2_\\omega\\}$  with fewer points than V but V 2 is a subset of V. For approach 2, we obtain a new object  $\\mathrm{V}3 = \\{\\mathrm{V}3_1, \\ldots, \\mathrm{V}3_\\omega\\}$  with fewer points than V but each point in V 3 is a new vertex.",
+        "bbox": [
+            138,
+            393,
+            854,
+            481
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In Section 2 we have presented methods to produce simplification. A few were designed for volumetric simplification. In this section, we propose several methods to produce different volumetric simplifications on our client. We develop four approaches to simplify 3D objects: clustering, neighbor simplification and two approaches based on server. Clustering method was based on He et al.  $^{9}$  works, it consists of clustering particles using a 3D grid. Cells sizes of grid are set depending to the viewpoint of the camera. Clusters were being weight with the average of the different values of particles. The position is the barycenter of these particles. Figures 1(a)-1(e) give some examples of simplification using clustering solution. Figure 1(a) present the original point of cloud mesh. Figure",
+        "bbox": [
+            138,
+            493,
+            848,
+            647
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1(b) and 1(d) give two different methods for clustering. And finally, Figure 1(c) and 1(e) give the results of clustering methods.",
+        "bbox": [
+            138,
+            657,
+            849,
+            691
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/ae6cbd294176dc493b50c73240c504ea8c9fc09c9e3151fba6f0be709b525025.jpg",
+        "image_caption": [
+            "Figure 1. Clustering method for simplification point cloud."
+        ],
+        "image_footnote": [
+            "The second solution used is based on neighborhood extraction. Before runtime, we extract all neighbors of a particle. We measure the distance between each particle. Some optimization can help to decrease complexity: we can estimate easily in our structure which particle is closer to another one (using the fact that particle grid is regular). After this,"
+        ],
+        "bbox": [
+            148,
+            696,
+            849,
+            821
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "page_number",
+        "text": "4/10",
+        "bbox": [
+            480,
+            969,
+            517,
+            979
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "we extract the main value of particles. We explore each neighbor of particles and we keep the most important. In some cases, the most important can be the high values, in other the low values and in other both of them. This solution is able to produce a low resolution model with the most important information structure. Several low resolution models are created by exploring deeper in neighborhood. Figures 2(a)-2(c) illustrate a neighbor, and two simplifications of this mesh.",
+        "bbox": [
+            140,
+            65,
+            844,
+            167
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/23944f9963b290146f2ac445e8970545bcf00b2949e999067a13468653d749cc.jpg",
+        "image_caption": [
+            "(a) Neighborhood cloud."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            148,
+            172,
+            379,
+            339
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/0e41ba0aeddc8af5f2b6664c64abea63f9b32bfd4692c38f916d07f501d537e5.jpg",
+        "image_caption": [
+            "(b) Simplification neighborhood of 1."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            383,
+            172,
+            612,
+            337
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/c01c12cfcf72e187db35ff49ad4d5edb57331b8d93efa4c1f20941ebf580a3d7.jpg",
+        "image_caption": [
+            "(c) Simplification neighborhood of 2.",
+            "Figure 2. Neighbor method for simplification."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            617,
+            172,
+            846,
+            338
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Other methods were based on server instead of client. Client sent via TCP connection his viewpoint. The server recomputes the particles structure and recreates the entire structure. With this solution, it is possible to produce a point cloud resolution depending on hardware. Figure 3(a) presents particles rendering with a distance of 2 from the camera. Figure 3(b) is the decimation produced with a distance of 3 and Figure 3(c) is a distance of 1.",
+        "bbox": [
+            138,
+            409,
+            852,
+            492
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Another method was based on Voronoi diffusion of temperature. The bandwidth for transmitting data is limited. We developed Voronoi temperature diffusion to solve this communication. In this approach, we update data using sphere expansion. Each time, we update particles depending on their distance from sensors. The more particles are distant from sensors the later they will be refreshed. This method sends only modified particles. The bandwidth is saved and the visualization gives a flow effect. Figure 4(a) represents values at time 0. At time 1, values of sensors change, 4(b). After time 2, we update a first range of particles 4(c) and finally the second range 4(d).",
+        "bbox": [
+            138,
+            506,
+            856,
+            642
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/7eac2440a2fedd66d943c82b390c3a9df5d95d019d523a29c7a3e2f9c7218928.jpg",
+        "image_caption": [
+            "(a) Particles server  $(\\mathrm{D} = 2)$",
+            "Figure 3. Particle simplification using server and distance."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            156,
+            650,
+            380,
+            815
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/c4777a0507eee1c1beaa13c04e351827098bc588e6ced9d8de6cff01430e3df5.jpg",
+        "image_caption": [
+            "(b) Particles produce server  $(\\mathrm{D} = 3)$"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            388,
+            650,
+            612,
+            815
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/5dabdfa6b0129921b2abb27785be9608573a25f26e4646d20c6b92250fad1414.jpg",
+        "image_caption": [
+            "(c) Particles produce by server  $(\\mathrm{D} = 1)$"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            620,
+            650,
+            844,
+            815
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "page_number",
+        "text": "5/10",
+        "bbox": [
+            482,
+            969,
+            514,
+            979
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/e340d9807d4ed601eee3bd74351618a9adfda026a8dbd720f9d2aa40857dad26.jpg",
+        "image_caption": [
+            "(a) Particles and sensors (T = 0)."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            150,
+            66,
+            321,
+            193
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/92c09c0b767ea453098777786fb815e8c2f833a8abc790807397f42e9a6f6887.jpg",
+        "image_caption": [
+            "(b) Sensors update  $(\\mathrm{T} = 1)$ ."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            328,
+            66,
+            496,
+            194
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/416dbc943d118d6834e80c8c5ad759b34f940700b96fd0b87bb23c082f10cf10.jpg",
+        "image_caption": [
+            "(c) First range  $(\\mathrm{T} = 2)$ .",
+            "Figure 4. Simplification using bandwidth size."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            503,
+            68,
+            669,
+            194
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/a79e8f2104ab8c32df4137808fc6b4ce9b7465bfa15c2080bd3aabb2c58986d0.jpg",
+        "image_caption": [
+            "(d) Second range  $(\\mathrm{T} = 3)$ ."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            674,
+            68,
+            848,
+            194
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4. EXPERIMENTAL RESULTS",
+        "text_level": 1,
+        "bbox": [
+            140,
+            287,
+            490,
+            306
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The data are extracted from two rooms of the IBM data center. Firstly, we present our method for rendering the room, and later we present our results using Level Of Detail methods.",
+        "bbox": [
+            138,
+            321,
+            805,
+            371
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Data visualization",
+        "text_level": 1,
+        "bbox": [
+            140,
+            388,
+            346,
+            406
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We want to visualize and manage the consumption of a data center. For the visualization, we want to use an IFC viewer. But the IFC model for GDC is not available yet. Data center extraction of the room space is for the moment done by hand. The room is empty and was represent by a simple shape a box with 4 meters length, 3 meters width and 2.5 meters height. We use point cloud visualization based on particle paradigm. We use the two rooms of the data center and we put the same number of particles (30000) and 35 sensors distributed on three layers at 1 meter; 2 meter and on the ground. We define high and low temperature regarding the real sensors value. Figure 5(a) presents temperature color scale, Figure 5(b) and Figure 5(c) present data center sensors.",
+        "bbox": [
+            138,
+            417,
+            848,
+            571
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The next step is to interpolate data from sensors. For this, we extract the sensor mesh. We use QHULL to produce a soup of tetrahedrons. Particles need to be located. We can determine which tetrahedron is the nearest, we extract the box hull of tetrahedron and we apply for each particle the norms of each tetrahedron face. If these rays cut three or more faces, then particle is inside the tetrahedron. With this method, we can determine exactly the location of each particles regarding to the tetrahedrons, a weight is given to them easily. It was used to apply a coefficient to the value of each vertex of tetrahedron. For the outside particles, another solution was used: Voronoi cells. This method is based on a discrete extraction of Voronoi cells. We use our own method because other method like Voro ++ or QHull extract Voronoi diagram in a continuous way.",
+        "bbox": [
+            138,
+            584,
+            852,
+            755
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/7c729f1706460b0bf0adde7a8dbd071f9ae77f611ef3f85b3d951fb62795016c.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            151,
+            878,
+            367,
+            922
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/8c16ad7a59f34e5974a4322466cec0149f8905a1a1b1cfadff910a3fec50d004.jpg",
+        "image_caption": [
+            "(b) Room one."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            398,
+            763,
+            606,
+            898
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/2eb0e7b79700cbbd72a8a244992163f567dbbd68f9d3db6bad3e5808cda4dabb.jpg",
+        "image_caption": [
+            "(c) Room two."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            643,
+            765,
+            849,
+            898
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "page_number",
+        "text": "6/10",
+        "bbox": [
+            482,
+            969,
+            514,
+            979
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Level of details",
+        "text_level": 1,
+        "bbox": [
+            142,
+            98,
+            325,
+            116
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the earlier days of this project, first solution proposed gives a low frame rates, about 15 FPS (Frame Per Second): visualization was not in real-time (real-time is about 24 FPS). For solving this problem, we define a client server paradigm. This solution allows to produce a real-time rendering on the client. Figure ?? gives an example of LOD for particles. We use Openscenegraph  $^{20}$  as a 3D engine. It owns several features useful in LOD. A special object is defined to manage multi-resolution model. It calculates the distance of the object from the camera. For our experimentation we use five resolutions of mesh. The first mesh was the original mesh, it is set at 0 to 500. The next mesh was set at 500 to 1000, the next at 1000 to 1500 and the other at 1500 to 2000. These three meshes were constructed by specific LOD methods: clustering and significant vertices. Clustering defines a 3D grid inside the room. The size of each cell depends on the viewpoint location. The size of the cluster depends on the visibility of the clustered particles. First results are given Figure 6(a) and 6(b). Value of cluster is an average of clustered value. The number of points of the final mesh depends on the grid size. Table 1 shows the results at several distances.",
+        "bbox": [
+            138,
+            126,
+            857,
+            367
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/389ef0f63a90171c14db5cd9a925792e376222c8c56a5801cacb3dcc99360c96.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>D = 0 to 500</td><td>D = 500 to 1000</td><td>D = 1000 to 1500</td><td>D = 1500 to 2000</td></tr><tr><td>C = X</td><td>30000</td><td>3900</td><td>240</td><td>36</td></tr></table>",
+        "bbox": [
+            143,
+            375,
+            854,
+            450
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/9fbe1142edda7eab13f0abb9592b84e63d1611257e7426d7d569a68b9df82b38.jpg",
+        "image_caption": [
+            "Figure 5. Data use to model the system.",
+            "(a)  $\\mathrm{D} = 500$  to 1000.",
+            "Figure 6. Clustering visualization algorithms."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            158,
+            508,
+            500,
+            705
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/69ae709df8988787ff641b5b6eb5a608ca0636bba7110a3a4735064168d117da.jpg",
+        "image_caption": [
+            "Table 1. Results of clustering simplification.",
+            "(b)  $D = 1000$  to 1500."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            504,
+            508,
+            846,
+            705
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Significant points method extracts the neighbors for each particle. We extract the highest and lowest temperatures, by exploring the neighborhood of a particle, in order to have significant vertices of the model. For the first step of simplified model we explore neighbor. For the second model, we explore neighbor and neighbor of neighbor, etc. This solution simplifies drastically the model. First results are given Figure ??-??. Table 2 shows the number of vertices at several distance.",
+        "bbox": [
+            138,
+            756,
+            843,
+            859
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "page_number",
+        "text": "7/10",
+        "bbox": [
+            482,
+            969,
+            516,
+            979
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/3cd8a951d8771e165427c2faca0d2508e4c8cef94fb244dc3a04f2ca031996a3.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>D = 0 to 500</td><td>D = 500 to 1000</td><td>D = 1000 to 1500</td><td>D = 1500 to 2000</td></tr><tr><td>C = X</td><td>30000</td><td>22950</td><td>4554</td><td>3524</td></tr></table>",
+        "bbox": [
+            143,
+            61,
+            854,
+            137
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/4050e8f862ac40be7bc6d5c239997192325936e244911b8d69fe60a4ab8810b8.jpg",
+        "image_caption": [
+            "(a) Neighborhood 1.",
+            "Figure 7. Clustering visualization algorithms using neighbor."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            153,
+            195,
+            496,
+            402
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/dafb2130c8265a91a7faed53db3de1181cd524770896acda68d5a953df004f87.jpg",
+        "image_caption": [
+            "(b) Neighborhood 2."
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            195,
+            843,
+            402
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The first server solution receives orders from client as presented Section 3.4. We calculate the viewpoint distance and we send data according to it. A new structure is recalculated if the camera is too far from the object. After the recomputing, we send the new data. This solution allows the user to receive more or less data according to its distance to the object. Table 3 shows some different resolutions produced with this method.",
+        "bbox": [
+            138,
+            470,
+            844,
+            555
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/9434d9911bf9b1660b16b84b9672b9a68ac66eec53e61ed383a2c752f12025a2.jpg",
+        "table_caption": [
+            "Table 2. Results of neighbor simplification."
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>D = 0 to 500</td><td>D = 500 to 1000</td><td>D = 1000 to 1500</td><td>D = 1500 to 2000</td></tr><tr><td>C = X</td><td>120000</td><td>30000</td><td>7500</td><td>1875</td></tr></table>",
+        "bbox": [
+            143,
+            566,
+            854,
+            640
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 3. Several resolution of model.",
+        "bbox": [
+            138,
+            674,
+            424,
+            688
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Another solution is to use bandwidth latency. We send data at several times, we do not send the entire set of data but only modified particles. We send at first time the sensors data, and subsequently we send a range of data (the nearest). After few minutes, all data are sent. This solution gives good results, and simulates a thermal diffusion in the whole structure of particles. Figure 8(a)-8(c) illustrate this method.",
+        "bbox": [
+            138,
+            691,
+            852,
+            775
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/2fcee6efa3b1d3c44144e2639f3857a15c4079f838c4f9132953fd427a8b1be9.jpg",
+        "image_caption": [
+            "(a)  $\\mathrm{T} = 0$"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            148,
+            779,
+            380,
+            912
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/b2be70bd4cc7d261ac38e8bc653a0c09c537d49d2a5612ed5c067058a98ef463.jpg",
+        "image_caption": [
+            "(b)  $\\mathrm{T} = 1$"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            383,
+            779,
+            616,
+            912
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/0d4e22f04d3ea25761125c93fc6d70fe856bf840ef353c043f32d21c9633724e.jpg",
+        "image_caption": [
+            "(c)  $\\mathrm{T} = 4$"
+        ],
+        "image_footnote": [],
+        "bbox": [
+            617,
+            779,
+            849,
+            912
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "page_number",
+        "text": "8/10",
+        "bbox": [
+            482,
+            969,
+            514,
+            979
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5. CONCLUSION",
+        "text_level": 1,
+        "bbox": [
+            142,
+            114,
+            339,
+            135
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have presented a method to visualize sensors data extracted from a Green Data Center. This approach produces interpolation visualization for managing and visualizing data. This interpolation used a Delaunay triangulation and a cell extraction based on Voronoi. An unusual way of use particles helps to process data. First results present the solution proposed to visualize the inside of a GDC space. The second results proposed in this paper aim to improve the rendering.",
+        "bbox": [
+            140,
+            148,
+            849,
+            251
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For this, first step introduces a client/server protocol a second step illustrates methods to simplify the model. With these different approaches we improve the rendering time, preserving most important data are kept. In future works, we will work on data \"dressing\". We want to find a way to improve rendering of the scene using meatballs or marching cube algorithms. A main constraint of this work is real-time computation. Future work also concern to add rooms to the visualization. At present, we only visualize a single room. We want to visualize building, and complex form, by using an IFC loader.",
+        "bbox": [
+            140,
+            252,
+            852,
+            371
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS",
+        "text_level": 1,
+        "bbox": [
+            142,
+            402,
+            419,
+            422
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We want to thanks the PSSC (Products and Solutions Support Center) team of IBM Montpellier for having provided the necessary equipment and data need for this experimentation. And we thank the FUI (Fonds Unique Interministriel) for their financial support.",
+        "bbox": [
+            138,
+            438,
+            836,
+            506
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES",
+        "text_level": 1,
+        "bbox": [
+            142,
+            539,
+            310,
+            558
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "[1] Clark, J. H., \"Hierarchical geometric models for visible surface algorithms,\" Communications of the ACM 19(10), 547-554 (1976).",
+            "[2] Damon, M., Kameyama, M., Knox, M., Porter, D., Yuen, D., and Sevre, E., \"Interactive visualization of 3d mantle convection,\" Visual Geosciences (2008).",
+            "[3] Jordan, K. E., Yuen, D. A., Reuteler, D. M., Zhang, S., and Haimes, R., \"Parallel interactive visualization of 3d mantle convection,\" IEEE Comput. Sci. Eng. 3(4), 29-37 (1996).",
+            "[4] Reeves, W. T., \"Particle systems - a technique for modeling a class of fuzzy objects,\" ACM Transactions on Graphics 2, 359-376 (1983).",
+            "[5] Latta, L., \"Building a million particle system,\" (2004).",
+            "[6] Kapferer, W. and Riser, T., \"Visualization needs and techniques for astrophysical simulations,\" New Journal of Physics 10(12), 125008 (15pp) (2008).",
+            "[7] Schroeder, W. J., Zarge, J. A., and Lorensen, W. E., \"Decimation of triangle meshes,\" 65-70 (1992).",
+            "[8] Luebke, D., \"A survey of polygonal simplification algorithms,\" (1997).",
+            "[9] He, T., Hong, L., Kaufman, A., Varshney, A., and Wang, S., \"Voxel based object simplification,\" in [Proc. SIGGRAPH Symposium on Interactive 3D Graphics], 296-303 (1995).",
+            "[10] Lorensen, W. E. and Cline, H. E., \"Marching cubes: A high resolution 3d surface construction algorithm,\" SIGGRAPH Comput. Graph. 21(4), 163-169 (1987).",
+            "[11] Pauly, M., Gross, M., and Kobbelt, L. P., \"Efficient simplification of point-sampled surfaces,\" (2002).",
+            "[12] Moenning, C., , Moenning, C., and Dodgson, N. A., \"Intrinsic point cloud simplification,\""
+        ],
+        "bbox": [
+            140,
+            573,
+            852,
+            931
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "header",
+        "text": "Figure 8. Bandwidth simplification.",
+        "bbox": [
+            140,
+            65,
+            413,
+            80
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "page_number",
+        "text": "9/10",
+        "bbox": [
+            480,
+            969,
+            514,
+            979
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "list",
+        "sub_type": "ref_text",
+        "list_items": [
+            "(2004).",
+            "[13] Song, H. and Feng, H.-Y., \"A progressive point cloud simplification algorithm with preserved sharp edge data,\" The International Journal of Advanced Manufacturing Technology 45, 583-592 (November 2009).",
+            "[14] Buschmann, C., Pfisterer, D., Fischer, S., Fekete, S. P., and Kröller, A., \"Spyglass: a wireless sensor network visualizer,\" SIGBED Rev. 2(1), 1-6 (2005).",
+            "[15] Avis, D. and Bhattacharya, B., \"Algorithms for computing d-dimensional voronoi diagrams and their duals,\" 1, 159-180 (1983).",
+            "[16] Rycroft, C. H., \"Voro++: a three-dimensional voronoi cell library in  $c++$ ,\" Chaos 19 (2009). Lawrence Berkeley National Laboratory.",
+            "[17] Barber, C. B., Dobkin, D. P., and Huhdanpaa, H., \"The quickhull algorithm for convex hulls,\" ACM Trans. Math. Softw. 22(4), 469-483 (1996).",
+            "[18] Snyder, J. M. and Barr, A. H., \"Ray tracing complex models containing surface tessellations,\" SIGGRAPH Comput. Graph. 21(4), 119-128 (1987).",
+            "[19] Hoppe, H., \"Progressive meshes. computer graphics,\" SIGGRAPH96 Proceedings, 99108 (1996).",
+            "[20] Burns, D. and Osfield, R., \"Open scene graph a: Introduction, b: Examples and applications,\" 265 (2004)."
+        ],
+        "bbox": [
+            142,
+            65,
+            849,
+            371
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Further author information:",
+        "bbox": [
+            166,
+            393,
+            388,
+            407
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lange B.: E-mail: benoit.lange@lirmm.fr",
+        "bbox": [
+            166,
+            411,
+            480,
+            426
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rodriguez N.: E-mail: nancy.rodriguez@lirmm.fr",
+        "bbox": [
+            166,
+            428,
+            542,
+            443
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Puech W.: E-mail: william.puech@lirmm.fr",
+        "bbox": [
+            166,
+            445,
+            496,
+            459
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rey H.: E-mail:REYHERVE@fr.ibm.com",
+        "bbox": [
+            166,
+            462,
+            467,
+            477
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vasques X.: E-mail: xaviervasques@fr.ibm.com",
+        "bbox": [
+            166,
+            479,
+            527,
+            494
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "page_number",
+        "text": "10/10",
+        "bbox": [
+            480,
+            969,
+            517,
+            979
+        ],
+        "page_idx": 9
+    }
+]

data/2025/2503_09xxx/2503.09198/ef3c6a72-d844-464a-90c5-502ddc16df65_model.json

@@ -0,0 +1,1639 @@
+[
+    [
+        {
+            "type": "title",
+            "bbox": [
+                0.195,
+                0.113,
+                0.804,
+                0.176
+            ],
+            "angle": 0,
+            "content": "A 3D particle visualization system for temperature management"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.334,
+                0.201,
+                0.663,
+                0.234
+            ],
+            "angle": 0,
+            "content": "Lange B. \\(^{a}\\), Rodriguez N. \\(^{a}\\), Puech W. \\(^{a}\\), Rey H. \\(^{b}\\) and Vasques X. \\(^{b}\\)"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.331,
+                0.236,
+                0.667,
+                0.252
+            ],
+            "angle": 0,
+            "content": "\\(^{a}\\) LIRMM, 141 rue ADA, Montpellier, France;"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.339,
+                0.253,
+                0.659,
+                0.269
+            ],
+            "angle": 0,
+            "content": "<sup>b</sup> IBM, Rue de la vieille poste, Montpellier,"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.471,
+                0.271,
+                0.528,
+                0.285
+            ],
+            "angle": 0,
+            "content": "France"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.467,
+                0.315,
+                0.532,
+                0.329
+            ],
+            "angle": 0,
+            "content": "Abstract"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.215,
+                0.338,
+                0.786,
+                0.514
+            ],
+            "angle": 0,
+            "content": "This paper deals with a 3D visualization technique proposed to analyze and manage energy efficiency from a data center. Data are extracted from sensors located in the IBM Green Data Center in Montpellier France. These sensors measure different information such as hygrometry, pressure and temperature. We want to visualize in real-time the large among of data produced by these sensors. A visualization engine has been designed, based on particles system and a client server paradigm. In order to solve performance problems, a Level Of Detail solution has been developed. These methods are based on the earlier work introduced by J. Clark in \\(1976^{1}\\). In this paper we introduce a particle method used for this work and subsequently we explain different simplification methods applied to improve our solution."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.145,
+                0.527,
+                0.735,
+                0.542
+            ],
+            "angle": 0,
+            "content": "Keywords: 3D Visualization, Sensors, Particles, Client/Server, Level Of Details"
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.147,
+                0.576,
+                0.371,
+                0.596
+            ],
+            "angle": 0,
+            "content": "1. INTRODUCTION"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.143,
+                0.611,
+                0.842,
+                0.866
+            ],
+            "angle": 0,
+            "content": "In this paper, we present a method to produce a 3D visualization for analyzing and managing temperature. Data are extracted from sensors located in the IBM Green Data Center in Montpellier, which provides many different types of information like temperature, pressure or hygrometry. In our system, sensors are placed in a virtual room and the internal space is modeled using particles. The main constraint here is to produce a real-time rendering. However, latency appears du to the number of vertices. In this paper, we use a solution called LOD (Level Of Detail) to produce multi resolution 3D objects. This solution has been introduced in 1976 by J. Clark<sup>1</sup>. In this paper, J. Clark introduces the use of several mesh resolutions to simplify the 3D scene complexity. In our work, we use various simplification methods to provide interactive rendering and allows rendering the most important part of data extracted from sensors. In this paper, we describe how we create a room, and the methods used to produce different resolution visualization. In Section 2, we introduce related work on particles systems and LOD. In Section 3, we expose our solution to simplify particles system. In Section 4 we give some results and finally, in Section 5 we present our conclusions and future work."
+        },
+        {
+            "type": "page_number",
+            "bbox": [
+                0.484,
+                0.971,
+                0.516,
+                0.98
+            ],
+            "angle": 0,
+            "content": "1/10"
+        }
+    ],
+    [
+        {
+            "type": "title",
+            "bbox": [
+                0.147,
+                0.07,
+                0.376,
+                0.089
+            ],
+            "angle": 0,
+            "content": "2. RELATED WORK"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.145,
+                0.105,
+                0.83,
+                0.137
+            ],
+            "angle": 0,
+            "content": "In this section we present several previous works concerning data visualization, particle systems and level of detail methods."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.145,
+                0.139,
+                0.837,
+                0.223
+            ],
+            "angle": 0,
+            "content": "Some previous work present solutions to visualize large data flow extracted from mantle convection. M. Damon et al. \\(^{2}\\) and K. E. Jordan et al. \\(^{3}\\) present interactive viewers for this kind of data. These data are computed by using Hight Performance Computing (HPC) and visualized on a large display. The rendering is calculated by using another HPC. The data flow is very important and a real-time 3D simulation is hard to obtain. W. Kapfer and"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.145,
+                0.235,
+                0.852,
+                0.405
+            ],
+            "angle": 0,
+            "content": "T. Riser<sup>6</sup> introduce how to use particle system to visualize astronomic simulation, particles representing space objects. The number of particles is extremely important for computing motion in real-time. GPU computing is preferred to render instead of a common HPC solution. To display their data, they have developed their own 3D graphical engine. The space objects are represented by point sprite instead of sphere. Lights are used to give a spherical aspect to the point sprite. This solution allows to render more stars than spherical object method. The 3D engine provides different rendering methods to group space objects: cell simplification or extraction of isosurface. The use of GPU seems quite well for a particle solution, parallel processing allows to render large data; the astrological data seems to be well suited."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.145,
+                0.407,
+                0.852,
+                0.678
+            ],
+            "angle": 0,
+            "content": "In 1976, J. Clark introduces Level Of Detail (LOD) concept<sup>1</sup>. LOD consists of several resolution meshes for using them at different distances from the camera. Firstly, designer produces these meshes. First algorithms, in 1992 Schroeder et al. developed a method by decimation for simplify the mesh<sup>7</sup>. It analyses mesh geometry and evaluates the complexity of triangles. Vertices are removed if only constraints set by the user are respected. Vertices are removed and gaps are filled using triangulation. These algorithms of simplification are not enough to simplify mesh efficiently because shape is not always totally respected. D. Luebke, in 1997, has proposed a taxonomy of mesh simplification<sup>8</sup>. He presented the most used algorithms. He extracted different ways to use each algorithm. But in this paper, only one solution works with volumetric mesh<sup>9</sup>. T. He et al. propose a method based on voxel simplification by using a grid for clustering voxels. A marching cube<sup>10</sup> algorithm was applied to produce a surface mesh. But this simplification algorithm did not preserve the shape of the mesh. In our work, we look for point cloud simplification. Indeed, previous methods which deal with simplification for surface point cloud like<sup>11-13</sup> are not adapted to our case. All of these methods produce LOD for surface mesh and point cloud is extracted from scanner."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.147,
+                0.711,
+                0.453,
+                0.731
+            ],
+            "angle": 0,
+            "content": "3. PROPOSED APPROACH"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.145,
+                0.746,
+                0.845,
+                0.848
+            ],
+            "angle": 0,
+            "content": "This section presents the different methods that are used to visualize a kind of data from Green Data Center (GDC). The main goal is to be able to visualize in real-time the evolution of temperature in the data center. For this, we use a special particle method. Particles are located using a segmentation algorithm based on Voronoi cell extraction and Delaunay triangulation. The latency due to the large flow of particles is avoided by using a client server paradigm. We improve our solution by using LOD methods to simplify rendering."
+        },
+        {
+            "type": "page_number",
+            "bbox": [
+                0.485,
+                0.971,
+                0.515,
+                0.98
+            ],
+            "angle": 0,
+            "content": "2/10"
+        }
+    ],
+    [
+        {
+            "type": "title",
+            "bbox": [
+                0.143,
+                0.069,
+                0.334,
+                0.087
+            ],
+            "angle": 0,
+            "content": "3.1 Particle systems"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.14,
+                0.098,
+                0.845,
+                0.271
+            ],
+            "angle": 0,
+            "content": "Rooms are the bases of our study. For modeling a room, we extract the shape of the space representation which is composed by a box with three measures: length \\((l \\in \\mathbb{R})\\), width \\((w \\in \\mathbb{R})\\), height \\((h \\in \\mathbb{R})\\). Sensors are represented by \\(S = \\{\\mathrm{S}_1, \\dots, \\mathrm{S}_M\\}\\), where \\(M\\) is the number of sensors. Sensors \\(\\mathrm{S}_i (\\mathrm{i} \\in \\{1, \\dots, M\\})\\) are placed on the space on a layer \\(\\mathbf{L} \\in \\mathbb{N}\\) and have a location represented by: \\(\\{\\mathbf{X}_i, \\mathbf{Y}_i, \\mathbf{L}_j\\}\\) with \\(\\mathbf{X}_i \\in \\mathbb{R}\\), \\(\\mathbf{Y}_i \\in \\mathbb{R}\\) and \\(j\\) is the layer used. For modeling the space inside a room, we use a particle system instead of 2D map representations which have some lacks.\\(^{14}\\) Actually 2D map does not allow having a real visualization of space. A particle visualization gives a better efficiency for modeling space. We use a large number of particles to represent the entire space. \\(\\mathbf{N} \\in \\mathbb{N}\\) represents the number of particles in the room. It can be calculated using:"
+        },
+        {
+            "type": "equation",
+            "bbox": [
+                0.181,
+                0.279,
+                0.525,
+                0.318
+            ],
+            "angle": 0,
+            "content": "\\[\nN = \\frac {\\left(\\left(l + 1\\right) \\times (h + 1) \\times (w + 1)\\right)}{\\delta^ {3}} \\tag {1}\n\\]"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.139,
+                0.33,
+                0.842,
+                0.396
+            ],
+            "angle": 0,
+            "content": "where \\(\\delta \\in \\mathbb{R}\\) is the space between particles. The particle grid is regular. In this model, three layers of temperature sensors compose rooms. They are defined according to their real locations in the data center. Figure ?? presents the different layers of sensors in the data center."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.139,
+                0.399,
+                0.837,
+                0.434
+            ],
+            "angle": 0,
+            "content": "Particles carry information, and flow motion can be simulated if needed by changing the value of particles and the computational cost is inferior."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.142,
+                0.449,
+                0.419,
+                0.468
+            ],
+            "angle": 0,
+            "content": "3.2 Segmentation algorithms"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.139,
+                0.478,
+                0.836,
+                0.528
+            ],
+            "angle": 0,
+            "content": "In our solution, each sensors has an influence on surrounding particules. To calculate the set of particles in the sensor range, we use two methods: Voronoi cells extraction and Delaunay triangulation."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.139,
+                0.529,
+                0.856,
+                0.769
+            ],
+            "angle": 0,
+            "content": "Voronoi cells is a method to extract a partition of space \\(^{15}\\). This method is available for \\(\\phi\\) dimensions where \\(\\phi \\in [1, +\\infty]\\), but most of implementations are done in 2D. Tools for extracting 3D Voronoi diagrams exist: Voro++ and QHull but particles are discrete and these solutions are not suitable because they extract Voronoi diagram in a continuous way. Then we designed our own method based on sphere expansion. We search nearest sensors for each particle. This part allows to weight particles outside the sensors mesh. A second method to weight the interior of the sensors mesh is used. We extract the mesh tetrahedron of sensors using the Delaunay triangulation implemented in QHull. This method was used to analyze the location of particle. We compute the exact location using ray tracing on the soup of tetrahedron. First, we search the nearest particles inside the hull of each tetrahedron. We extract the normal of each face of tetrahedron and we apply these normals on each particle. If the ray cuts three faces or more, the particle is inside the tetrahedron. This method is cost expensive and done in preprocessing. Moreover, particles are static and position didn't need to be update."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.142,
+                0.783,
+                0.4,
+                0.803
+            ],
+            "angle": 0,
+            "content": "3.3 Client server paradigm"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.139,
+                0.812,
+                0.851,
+                0.933
+            ],
+            "angle": 0,
+            "content": "To improve computation, a client server paradigm is used. We define a low cost communication protocol to transfer data from a server to a client. Server computes the modification of particles and the client displays the results. This protocol works in five steps. These steps are: sending header, sending sensor data, sending particle data, sending footer and receiving acknowledgment/language command from client. At each step, the server waits the acknowledgment from the client. We develop two ways to send data. The first sends the entire point cloud (sensors and particles). The biggest problem of this method is the"
+        },
+        {
+            "type": "page_number",
+            "bbox": [
+                0.482,
+                0.97,
+                0.518,
+                0.981
+            ],
+            "angle": 0,
+            "content": "3/10"
+        }
+    ],
+    [
+        {
+            "type": "text",
+            "bbox": [
+                0.14,
+                0.066,
+                0.831,
+                0.168
+            ],
+            "angle": 0,
+            "content": "transmission of data. Sensors are sent with their coordinates and their value. We encode these data in bit words. For the particles data, the same method was used. The footer was sent for closing the communication. The second method is used to reduce efficiently the communication cost. We only send modified sensors and particles. The id and the new value is sent instead of coordinates. The last step is the command sent by the client. It allows the user to interact with the server. We use it to modify the camera viewpoint."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.143,
+                0.184,
+                0.436,
+                0.202
+            ],
+            "angle": 0,
+            "content": "3.4 Level of detail for particles"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.139,
+                0.212,
+                0.849,
+                0.364
+            ],
+            "angle": 0,
+            "content": "Level of detail (LOD) is one of the most important methods in computer graphics. It allows to solve rendering problems or performance problems. This method consists by producing several resolution of a 3D object. In our works, we use some features to define the object resolution: hardware and viewpoint. Hardware and viewpoint do not need the same data structure and we need to recompute it for each modification of the viewpoint or when hardware changes. LOD was defined by two problems statement. The first one uses a sample of original points, the second one uses a new point data set. In this part, we define six methods to produce LOD. The four first methods are for the client, the other are for the server."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.141,
+                0.379,
+                0.308,
+                0.393
+            ],
+            "angle": 0,
+            "content": "Problems statement:"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.139,
+                0.394,
+                0.856,
+                0.482
+            ],
+            "angle": 0,
+            "content": "For this two approaches, we have a set \\(\\omega\\) of Vertices \\(V\\), \\(V = \\{V_1, \\ldots, V_\\omega\\}\\). Each vertex is defined in \\(\\mathbb{R}^3\\). Simplify a mesh using a sample vertex means \\(\\omega > \\omega 2\\), where \\(\\omega 2\\) is the size of the second data set. For approach 1, we obtain a new object \\(\\mathrm{V}2 = \\{\\mathrm{V}2_1, \\ldots, \\mathrm{V}2_\\omega\\}\\) with fewer points than V but V 2 is a subset of V. For approach 2, we obtain a new object \\(\\mathrm{V}3 = \\{\\mathrm{V}3_1, \\ldots, \\mathrm{V}3_\\omega\\}\\) with fewer points than V but each point in V 3 is a new vertex."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.139,
+                0.494,
+                0.849,
+                0.648
+            ],
+            "angle": 0,
+            "content": "In Section 2 we have presented methods to produce simplification. A few were designed for volumetric simplification. In this section, we propose several methods to produce different volumetric simplifications on our client. We develop four approaches to simplify 3D objects: clustering, neighbor simplification and two approaches based on server. Clustering method was based on He et al. \\(^{9}\\) works, it consists of clustering particles using a 3D grid. Cells sizes of grid are set depending to the viewpoint of the camera. Clusters were being weight with the average of the different values of particles. The position is the barycenter of these particles. Figures 1(a)-1(e) give some examples of simplification using clustering solution. Figure 1(a) present the original point of cloud mesh. Figure"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.14,
+                0.659,
+                0.851,
+                0.693
+            ],
+            "angle": 0,
+            "content": "1(b) and 1(d) give two different methods for clustering. And finally, Figure 1(c) and 1(e) give the results of clustering methods."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.149,
+                0.697,
+                0.851,
+                0.822
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.14,
+                0.843,
+                0.593,
+                0.859
+            ],
+            "angle": 0,
+            "content": "Figure 1. Clustering method for simplification point cloud."
+        },
+        {
+            "type": "image_footnote",
+            "bbox": [
+                0.139,
+                0.86,
+                0.854,
+                0.929
+            ],
+            "angle": 0,
+            "content": "The second solution used is based on neighborhood extraction. Before runtime, we extract all neighbors of a particle. We measure the distance between each particle. Some optimization can help to decrease complexity: we can estimate easily in our structure which particle is closer to another one (using the fact that particle grid is regular). After this,"
+        },
+        {
+            "type": "page_number",
+            "bbox": [
+                0.482,
+                0.97,
+                0.518,
+                0.98
+            ],
+            "angle": 0,
+            "content": "4/10"
+        }
+    ],
+    [
+        {
+            "type": "text",
+            "bbox": [
+                0.141,
+                0.066,
+                0.845,
+                0.168
+            ],
+            "angle": 0,
+            "content": "we extract the main value of particles. We explore each neighbor of particles and we keep the most important. In some cases, the most important can be the high values, in other the low values and in other both of them. This solution is able to produce a low resolution model with the most important information structure. Several low resolution models are created by exploring deeper in neighborhood. Figures 2(a)-2(c) illustrate a neighbor, and two simplifications of this mesh."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.149,
+                0.174,
+                0.38,
+                0.34
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.149,
+                0.341,
+                0.296,
+                0.372
+            ],
+            "angle": 0,
+            "content": "(a) Neighborhood cloud."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.384,
+                0.174,
+                0.613,
+                0.338
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.384,
+                0.341,
+                0.532,
+                0.373
+            ],
+            "angle": 0,
+            "content": "(b) Simplification neighborhood of 1."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.619,
+                0.174,
+                0.848,
+                0.339
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.619,
+                0.341,
+                0.766,
+                0.373
+            ],
+            "angle": 0,
+            "content": "(c) Simplification neighborhood of 2."
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.141,
+                0.393,
+                0.492,
+                0.409
+            ],
+            "angle": 0,
+            "content": "Figure 2. Neighbor method for simplification."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.14,
+                0.41,
+                0.854,
+                0.493
+            ],
+            "angle": 0,
+            "content": "Other methods were based on server instead of client. Client sent via TCP connection his viewpoint. The server recomputes the particles structure and recreates the entire structure. With this solution, it is possible to produce a point cloud resolution depending on hardware. Figure 3(a) presents particles rendering with a distance of 2 from the camera. Figure 3(b) is the decimation produced with a distance of 3 and Figure 3(c) is a distance of 1."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.14,
+                0.507,
+                0.857,
+                0.643
+            ],
+            "angle": 0,
+            "content": "Another method was based on Voronoi diffusion of temperature. The bandwidth for transmitting data is limited. We developed Voronoi temperature diffusion to solve this communication. In this approach, we update data using sphere expansion. Each time, we update particles depending on their distance from sensors. The more particles are distant from sensors the later they will be refreshed. This method sends only modified particles. The bandwidth is saved and the visualization gives a flow effect. Figure 4(a) represents values at time 0. At time 1, values of sensors change, 4(b). After time 2, we update a first range of particles 4(c) and finally the second range 4(d)."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.157,
+                0.651,
+                0.382,
+                0.816
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.156,
+                0.817,
+                0.277,
+                0.849
+            ],
+            "angle": 0,
+            "content": "(a) Particles server \\((\\mathrm{D} = 2)\\)"
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.389,
+                0.651,
+                0.614,
+                0.816
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.389,
+                0.818,
+                0.577,
+                0.849
+            ],
+            "angle": 0,
+            "content": "(b) Particles produce server \\((\\mathrm{D} = 3)\\)"
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.621,
+                0.651,
+                0.846,
+                0.816
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.619,
+                0.818,
+                0.848,
+                0.849
+            ],
+            "angle": 0,
+            "content": "(c) Particles produce by server \\((\\mathrm{D} = 1)\\)"
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.141,
+                0.868,
+                0.595,
+                0.884
+            ],
+            "angle": 0,
+            "content": "Figure 3. Particle simplification using server and distance."
+        },
+        {
+            "type": "page_number",
+            "bbox": [
+                0.483,
+                0.97,
+                0.516,
+                0.98
+            ],
+            "angle": 0,
+            "content": "5/10"
+        }
+    ],
+    [
+        {
+            "type": "image",
+            "bbox": [
+                0.151,
+                0.068,
+                0.323,
+                0.194
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.15,
+                0.196,
+                0.325,
+                0.22
+            ],
+            "angle": 0,
+            "content": "(a) Particles and sensors (T = 0)."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.329,
+                0.068,
+                0.497,
+                0.195
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.332,
+                0.196,
+                0.493,
+                0.207
+            ],
+            "angle": 0,
+            "content": "(b) Sensors update \\((\\mathrm{T} = 1)\\)."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.504,
+                0.069,
+                0.671,
+                0.195
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.517,
+                0.196,
+                0.658,
+                0.208
+            ],
+            "angle": 0,
+            "content": "(c) First range \\((\\mathrm{T} = 2)\\)."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.675,
+                0.069,
+                0.849,
+                0.195
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.685,
+                0.196,
+                0.84,
+                0.208
+            ],
+            "angle": 0,
+            "content": "(d) Second range \\((\\mathrm{T} = 3)\\)."
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.14,
+                0.238,
+                0.496,
+                0.255
+            ],
+            "angle": 0,
+            "content": "Figure 4. Simplification using bandwidth size."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.142,
+                0.288,
+                0.491,
+                0.308
+            ],
+            "angle": 0,
+            "content": "4. EXPERIMENTAL RESULTS"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.139,
+                0.322,
+                0.807,
+                0.372
+            ],
+            "angle": 0,
+            "content": "The data are extracted from two rooms of the IBM data center. Firstly, we present our method for rendering the room, and later we present our results using Level Of Detail methods."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.142,
+                0.39,
+                0.348,
+                0.407
+            ],
+            "angle": 0,
+            "content": "4.1 Data visualization"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.139,
+                0.419,
+                0.849,
+                0.572
+            ],
+            "angle": 0,
+            "content": "We want to visualize and manage the consumption of a data center. For the visualization, we want to use an IFC viewer. But the IFC model for GDC is not available yet. Data center extraction of the room space is for the moment done by hand. The room is empty and was represent by a simple shape a box with 4 meters length, 3 meters width and 2.5 meters height. We use point cloud visualization based on particle paradigm. We use the two rooms of the data center and we put the same number of particles (30000) and 35 sensors distributed on three layers at 1 meter; 2 meter and on the ground. We define high and low temperature regarding the real sensors value. Figure 5(a) presents temperature color scale, Figure 5(b) and Figure 5(c) present data center sensors."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.139,
+                0.585,
+                0.854,
+                0.756
+            ],
+            "angle": 0,
+            "content": "The next step is to interpolate data from sensors. For this, we extract the sensor mesh. We use QHULL to produce a soup of tetrahedrons. Particles need to be located. We can determine which tetrahedron is the nearest, we extract the box hull of tetrahedron and we apply for each particle the norms of each tetrahedron face. If these rays cut three or more faces, then particle is inside the tetrahedron. With this method, we can determine exactly the location of each particles regarding to the tetrahedrons, a weight is given to them easily. It was used to apply a coefficient to the value of each vertex of tetrahedron. For the outside particles, another solution was used: Voronoi cells. This method is based on a discrete extraction of Voronoi cells. We use our own method because other method like Voro ++ or QHull extract Voronoi diagram in a continuous way."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.153,
+                0.879,
+                0.368,
+                0.923
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.399,
+                0.765,
+                0.607,
+                0.9
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.438,
+                0.907,
+                0.547,
+                0.922
+            ],
+            "angle": 0,
+            "content": "(b) Room one."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.645,
+                0.766,
+                0.851,
+                0.9
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.692,
+                0.907,
+                0.8,
+                0.922
+            ],
+            "angle": 0,
+            "content": "(c) Room two."
+        },
+        {
+            "type": "page_number",
+            "bbox": [
+                0.483,
+                0.97,
+                0.516,
+                0.98
+            ],
+            "angle": 0,
+            "content": "6/10"
+        }
+    ],
+    [
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.141,
+                0.066,
+                0.445,
+                0.083
+            ],
+            "angle": 0,
+            "content": "Figure 5. Data use to model the system."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.143,
+                0.099,
+                0.326,
+                0.117
+            ],
+            "angle": 0,
+            "content": "4.2 Level of details"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.14,
+                0.127,
+                0.859,
+                0.368
+            ],
+            "angle": 0,
+            "content": "In the earlier days of this project, first solution proposed gives a low frame rates, about 15 FPS (Frame Per Second): visualization was not in real-time (real-time is about 24 FPS). For solving this problem, we define a client server paradigm. This solution allows to produce a real-time rendering on the client. Figure ?? gives an example of LOD for particles. We use Openscenegraph \\(^{20}\\) as a 3D engine. It owns several features useful in LOD. A special object is defined to manage multi-resolution model. It calculates the distance of the object from the camera. For our experimentation we use five resolutions of mesh. The first mesh was the original mesh, it is set at 0 to 500. The next mesh was set at 500 to 1000, the next at 1000 to 1500 and the other at 1500 to 2000. These three meshes were constructed by specific LOD methods: clustering and significant vertices. Clustering defines a 3D grid inside the room. The size of each cell depends on the viewpoint location. The size of the cluster depends on the visibility of the clustered particles. First results are given Figure 6(a) and 6(b). Value of cluster is an average of clustered value. The number of points of the final mesh depends on the grid size. Table 1 shows the results at several distances."
+        },
+        {
+            "type": "table",
+            "bbox": [
+                0.145,
+                0.376,
+                0.855,
+                0.451
+            ],
+            "angle": 0,
+            "content": "<table><tr><td></td><td>D = 0 to 500</td><td>D = 500 to 1000</td><td>D = 1000 to 1500</td><td>D = 1500 to 2000</td></tr><tr><td>C = X</td><td>30000</td><td>3900</td><td>240</td><td>36</td></tr></table>"
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.141,
+                0.484,
+                0.482,
+                0.501
+            ],
+            "angle": 0,
+            "content": "Table 1. Results of clustering simplification."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.159,
+                0.51,
+                0.501,
+                0.706
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.236,
+                0.706,
+                0.425,
+                0.722
+            ],
+            "angle": 0,
+            "content": "(a) \\(\\mathrm{D} = 500\\) to 1000."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.505,
+                0.51,
+                0.848,
+                0.706
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.576,
+                0.706,
+                0.776,
+                0.721
+            ],
+            "angle": 0,
+            "content": "(b) \\(D = 1000\\) to 1500."
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.14,
+                0.74,
+                0.492,
+                0.757
+            ],
+            "angle": 0,
+            "content": "Figure 6. Clustering visualization algorithms."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.139,
+                0.757,
+                0.844,
+                0.86
+            ],
+            "angle": 0,
+            "content": "Significant points method extracts the neighbors for each particle. We extract the highest and lowest temperatures, by exploring the neighborhood of a particle, in order to have significant vertices of the model. For the first step of simplified model we explore neighbor. For the second model, we explore neighbor and neighbor of neighbor, etc. This solution simplifies drastically the model. First results are given Figure ??-??. Table 2 shows the number of vertices at several distance."
+        },
+        {
+            "type": "page_number",
+            "bbox": [
+                0.483,
+                0.97,
+                0.517,
+                0.98
+            ],
+            "angle": 0,
+            "content": "7/10"
+        }
+    ],
+    [
+        {
+            "type": "table",
+            "bbox": [
+                0.145,
+                0.063,
+                0.855,
+                0.138
+            ],
+            "angle": 0,
+            "content": "<table><tr><td></td><td>D = 0 to 500</td><td>D = 500 to 1000</td><td>D = 1000 to 1500</td><td>D = 1500 to 2000</td></tr><tr><td>C = X</td><td>30000</td><td>22950</td><td>4554</td><td>3524</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.14,
+                0.171,
+                0.474,
+                0.187
+            ],
+            "angle": 0,
+            "content": "Table 2. Results of neighbor simplification."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.154,
+                0.196,
+                0.497,
+                0.403
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.228,
+                0.403,
+                0.422,
+                0.42
+            ],
+            "angle": 0,
+            "content": "(a) Neighborhood 1."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.501,
+                0.196,
+                0.844,
+                0.403
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.575,
+                0.403,
+                0.769,
+                0.42
+            ],
+            "angle": 0,
+            "content": "(b) Neighborhood 2."
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.14,
+                0.441,
+                0.607,
+                0.459
+            ],
+            "angle": 0,
+            "content": "Figure 7. Clustering visualization algorithms using neighbor."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.139,
+                0.471,
+                0.845,
+                0.556
+            ],
+            "angle": 0,
+            "content": "The first server solution receives orders from client as presented Section 3.4. We calculate the viewpoint distance and we send data according to it. A new structure is recalculated if the camera is too far from the object. After the recomputing, we send the new data. This solution allows the user to receive more or less data according to its distance to the object. Table 3 shows some different resolutions produced with this method."
+        },
+        {
+            "type": "table",
+            "bbox": [
+                0.145,
+                0.567,
+                0.855,
+                0.641
+            ],
+            "angle": 0,
+            "content": "<table><tr><td></td><td>D = 0 to 500</td><td>D = 500 to 1000</td><td>D = 1000 to 1500</td><td>D = 1500 to 2000</td></tr><tr><td>C = X</td><td>120000</td><td>30000</td><td>7500</td><td>1875</td></tr></table>"
+        },
+        {
+            "type": "table_caption",
+            "bbox": [
+                0.14,
+                0.675,
+                0.425,
+                0.689
+            ],
+            "angle": 0,
+            "content": "Table 3. Several resolution of model."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.139,
+                0.692,
+                0.854,
+                0.776
+            ],
+            "angle": 0,
+            "content": "Another solution is to use bandwidth latency. We send data at several times, we do not send the entire set of data but only modified particles. We send at first time the sensors data, and subsequently we send a range of data (the nearest). After few minutes, all data are sent. This solution gives good results, and simulates a thermal diffusion in the whole structure of particles. Figure 8(a)-8(c) illustrate this method."
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.15,
+                0.78,
+                0.382,
+                0.913
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.235,
+                0.912,
+                0.299,
+                0.924
+            ],
+            "angle": 0,
+            "content": "(a) \\(\\mathrm{T} = 0\\)"
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.384,
+                0.78,
+                0.617,
+                0.913
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.468,
+                0.912,
+                0.532,
+                0.924
+            ],
+            "angle": 0,
+            "content": "(b) \\(\\mathrm{T} = 1\\)"
+        },
+        {
+            "type": "image",
+            "bbox": [
+                0.619,
+                0.78,
+                0.851,
+                0.913
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "image_caption",
+            "bbox": [
+                0.704,
+                0.912,
+                0.766,
+                0.924
+            ],
+            "angle": 0,
+            "content": "(c) \\(\\mathrm{T} = 4\\)"
+        },
+        {
+            "type": "page_number",
+            "bbox": [
+                0.483,
+                0.97,
+                0.516,
+                0.98
+            ],
+            "angle": 0,
+            "content": "8/10"
+        }
+    ],
+    [
+        {
+            "type": "header",
+            "bbox": [
+                0.141,
+                0.066,
+                0.415,
+                0.082
+            ],
+            "angle": 0,
+            "content": "Figure 8. Bandwidth simplification."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.143,
+                0.115,
+                0.341,
+                0.136
+            ],
+            "angle": 0,
+            "content": "5. CONCLUSION"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.142,
+                0.15,
+                0.851,
+                0.252
+            ],
+            "angle": 0,
+            "content": "In this paper, we have presented a method to visualize sensors data extracted from a Green Data Center. This approach produces interpolation visualization for managing and visualizing data. This interpolation used a Delaunay triangulation and a cell extraction based on Voronoi. An unusual way of use particles helps to process data. First results present the solution proposed to visualize the inside of a GDC space. The second results proposed in this paper aim to improve the rendering."
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.142,
+                0.253,
+                0.854,
+                0.372
+            ],
+            "angle": 0,
+            "content": "For this, first step introduces a client/server protocol a second step illustrates methods to simplify the model. With these different approaches we improve the rendering time, preserving most important data are kept. In future works, we will work on data \"dressing\". We want to find a way to improve rendering of the scene using meatballs or marching cube algorithms. A main constraint of this work is real-time computation. Future work also concern to add rooms to the visualization. At present, we only visualize a single room. We want to visualize building, and complex form, by using an IFC loader."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.143,
+                0.404,
+                0.421,
+                0.424
+            ],
+            "angle": 0,
+            "content": "ACKNOWLEDGMENTS"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.14,
+                0.439,
+                0.838,
+                0.507
+            ],
+            "angle": 0,
+            "content": "We want to thanks the PSSC (Products and Solutions Support Center) team of IBM Montpellier for having provided the necessary equipment and data need for this experimentation. And we thank the FUI (Fonds Unique Interministriel) for their financial support."
+        },
+        {
+            "type": "title",
+            "bbox": [
+                0.143,
+                0.54,
+                0.311,
+                0.559
+            ],
+            "angle": 0,
+            "content": "REFERENCES"
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.142,
+                0.574,
+                0.744,
+                0.606
+            ],
+            "angle": 0,
+            "content": "[1] Clark, J. H., \"Hierarchical geometric models for visible surface algorithms,\" Communications of the ACM 19(10), 547-554 (1976)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.143,
+                0.609,
+                0.81,
+                0.641
+            ],
+            "angle": 0,
+            "content": "[2] Damon, M., Kameyama, M., Knox, M., Porter, D., Yuen, D., and Sevre, E., \"Interactive visualization of 3d mantle convection,\" Visual Geosciences (2008)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.143,
+                0.643,
+                0.831,
+                0.675
+            ],
+            "angle": 0,
+            "content": "[3] Jordan, K. E., Yuen, D. A., Reuteler, D. M., Zhang, S., and Haimes, R., \"Parallel interactive visualization of 3d mantle convection,\" IEEE Comput. Sci. Eng. 3(4), 29-37 (1996)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.143,
+                0.677,
+                0.844,
+                0.71
+            ],
+            "angle": 0,
+            "content": "[4] Reeves, W. T., \"Particle systems - a technique for modeling a class of fuzzy objects,\" ACM Transactions on Graphics 2, 359-376 (1983)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.144,
+                0.712,
+                0.571,
+                0.727
+            ],
+            "angle": 0,
+            "content": "[5] Latta, L., \"Building a million particle system,\" (2004)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.143,
+                0.728,
+                0.783,
+                0.761
+            ],
+            "angle": 0,
+            "content": "[6] Kapferer, W. and Riser, T., \"Visualization needs and techniques for astrophysical simulations,\" New Journal of Physics 10(12), 125008 (15pp) (2008)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.143,
+                0.763,
+                0.837,
+                0.794
+            ],
+            "angle": 0,
+            "content": "[7] Schroeder, W. J., Zarge, J. A., and Lorensen, W. E., \"Decimation of triangle meshes,\" 65-70 (1992)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.143,
+                0.797,
+                0.696,
+                0.812
+            ],
+            "angle": 0,
+            "content": "[8] Luebke, D., \"A survey of polygonal simplification algorithms,\" (1997)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.143,
+                0.814,
+                0.854,
+                0.847
+            ],
+            "angle": 0,
+            "content": "[9] He, T., Hong, L., Kaufman, A., Varshney, A., and Wang, S., \"Voxel based object simplification,\" in [Proc. SIGGRAPH Symposium on Interactive 3D Graphics], 296-303 (1995)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.143,
+                0.848,
+                0.776,
+                0.88
+            ],
+            "angle": 0,
+            "content": "[10] Lorensen, W. E. and Cline, H. E., \"Marching cubes: A high resolution 3d surface construction algorithm,\" SIGGRAPH Comput. Graph. 21(4), 163-169 (1987)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.143,
+                0.882,
+                0.791,
+                0.914
+            ],
+            "angle": 0,
+            "content": "[11] Pauly, M., Gross, M., and Kobbelt, L. P., \"Efficient simplification of point-sampled surfaces,\" (2002)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.143,
+                0.916,
+                0.844,
+                0.932
+            ],
+            "angle": 0,
+            "content": "[12] Moenning, C., , Moenning, C., and Dodgson, N. A., \"Intrinsic point cloud simplification,\""
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.142,
+                0.574,
+                0.854,
+                0.932
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "page_number",
+            "bbox": [
+                0.482,
+                0.97,
+                0.516,
+                0.98
+            ],
+            "angle": 0,
+            "content": "9/10"
+        }
+    ],
+    [
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.143,
+                0.066,
+                0.195,
+                0.08
+            ],
+            "angle": 0,
+            "content": "(2004)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.143,
+                0.083,
+                0.798,
+                0.132
+            ],
+            "angle": 0,
+            "content": "[13] Song, H. and Feng, H.-Y., \"A progressive point cloud simplification algorithm with preserved sharp edge data,\" The International Journal of Advanced Manufacturing Technology 45, 583-592 (November 2009)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.143,
+                0.134,
+                0.841,
+                0.166
+            ],
+            "angle": 0,
+            "content": "[14] Buschmann, C., Pfisterer, D., Fischer, S., Fekete, S. P., and Kröller, A., \"Spyglass: a wireless sensor network visualizer,\" SIGBED Rev. 2(1), 1-6 (2005)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.143,
+                0.168,
+                0.798,
+                0.2
+            ],
+            "angle": 0,
+            "content": "[15] Avis, D. and Bhattacharya, B., \"Algorithms for computing d-dimensional voronoi diagrams and their duals,\" 1, 159-180 (1983)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.144,
+                0.202,
+                0.851,
+                0.235
+            ],
+            "angle": 0,
+            "content": "[16] Rycroft, C. H., \"Voro++: a three-dimensional voronoi cell library in \\( c++ \\),\" Chaos 19 (2009). Lawrence Berkeley National Laboratory."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.143,
+                0.237,
+                0.819,
+                0.268
+            ],
+            "angle": 0,
+            "content": "[17] Barber, C. B., Dobkin, D. P., and Huhdanpaa, H., \"The quickhull algorithm for convex hulls,\" ACM Trans. Math. Softw. 22(4), 469-483 (1996)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.143,
+                0.271,
+                0.773,
+                0.303
+            ],
+            "angle": 0,
+            "content": "[18] Snyder, J. M. and Barr, A. H., \"Ray tracing complex models containing surface tessellations,\" SIGGRAPH Comput. Graph. 21(4), 119-128 (1987)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.144,
+                0.305,
+                0.836,
+                0.336
+            ],
+            "angle": 0,
+            "content": "[19] Hoppe, H., \"Progressive meshes. computer graphics,\" SIGGRAPH96 Proceedings, 99108 (1996)."
+        },
+        {
+            "type": "ref_text",
+            "bbox": [
+                0.143,
+                0.339,
+                0.774,
+                0.372
+            ],
+            "angle": 0,
+            "content": "[20] Burns, D. and Osfield, R., \"Open scene graph a: Introduction, b: Examples and applications,\" 265 (2004)."
+        },
+        {
+            "type": "list",
+            "bbox": [
+                0.143,
+                0.066,
+                0.851,
+                0.372
+            ],
+            "angle": 0,
+            "content": null
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.167,
+                0.394,
+                0.39,
+                0.409
+            ],
+            "angle": 0,
+            "content": "Further author information:"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.167,
+                0.412,
+                0.482,
+                0.427
+            ],
+            "angle": 0,
+            "content": "Lange B.: E-mail: benoit.lange@lirmm.fr"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.168,
+                0.429,
+                0.544,
+                0.444
+            ],
+            "angle": 0,
+            "content": "Rodriguez N.: E-mail: nancy.rodriguez@lirmm.fr"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.168,
+                0.446,
+                0.498,
+                0.46
+            ],
+            "angle": 0,
+            "content": "Puech W.: E-mail: william.puech@lirmm.fr"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.168,
+                0.463,
+                0.468,
+                0.478
+            ],
+            "angle": 0,
+            "content": "Rey H.: E-mail:REYHERVE@fr.ibm.com"
+        },
+        {
+            "type": "text",
+            "bbox": [
+                0.168,
+                0.48,
+                0.529,
+                0.495
+            ],
+            "angle": 0,
+            "content": "Vasques X.: E-mail: xaviervasques@fr.ibm.com"
+        },
+        {
+            "type": "page_number",
+            "bbox": [
+                0.481,
+                0.97,
+                0.519,
+                0.98
+            ],
+            "angle": 0,
+            "content": "10/10"
+        }
+    ]
+]

data/2025/2503_09xxx/2503.09198/ef3c6a72-d844-464a-90c5-502ddc16df65_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1ccb0b38b36e023702ff1726eaa2bd337a2762c59724e11e0f0dfcd4402cebf8
+size 964405

data/2025/2503_09xxx/2503.09198/full.md

@@ -0,0 +1,222 @@
+# A 3D particle visualization system for temperature management
+
+Lange B.  $^{a}$ , Rodriguez N.  $^{a}$ , Puech W.  $^{a}$ , Rey H.  $^{b}$  and Vasques X.  $^{b}$
+
+$^{a}$  LIRMM, 141 rue ADA, Montpellier, France;
+
+<sup>b</sup> IBM, Rue de la vieille poste, Montpellier,
+
+France
+
+# Abstract
+
+This paper deals with a 3D visualization technique proposed to analyze and manage energy efficiency from a data center. Data are extracted from sensors located in the IBM Green Data Center in Montpellier France. These sensors measure different information such as hygrometry, pressure and temperature. We want to visualize in real-time the large among of data produced by these sensors. A visualization engine has been designed, based on particles system and a client server paradigm. In order to solve performance problems, a Level Of Detail solution has been developed. These methods are based on the earlier work introduced by J. Clark in  $1976^{1}$ . In this paper we introduce a particle method used for this work and subsequently we explain different simplification methods applied to improve our solution.
+
+Keywords: 3D Visualization, Sensors, Particles, Client/Server, Level Of Details
+
+# 1. INTRODUCTION
+
+In this paper, we present a method to produce a 3D visualization for analyzing and managing temperature. Data are extracted from sensors located in the IBM Green Data Center in Montpellier, which provides many different types of information like temperature, pressure or hygrometry. In our system, sensors are placed in a virtual room and the internal space is modeled using particles. The main constraint here is to produce a real-time rendering. However, latency appears du to the number of vertices. In this paper, we use a solution called LOD (Level Of Detail) to produce multi resolution 3D objects. This solution has been introduced in 1976 by J. Clark<sup>1</sup>. In this paper, J. Clark introduces the use of several mesh resolutions to simplify the 3D scene complexity. In our work, we use various simplification methods to provide interactive rendering and allows rendering the most important part of data extracted from sensors. In this paper, we describe how we create a room, and the methods used to produce different resolution visualization. In Section 2, we introduce related work on particles systems and LOD. In Section 3, we expose our solution to simplify particles system. In Section 4 we give some results and finally, in Section 5 we present our conclusions and future work.
+
+# 2. RELATED WORK
+
+In this section we present several previous works concerning data visualization, particle systems and level of detail methods.
+
+Some previous work present solutions to visualize large data flow extracted from mantle convection. M. Damon et al.  $^{2}$  and K. E. Jordan et al.  $^{3}$  present interactive viewers for this kind of data. These data are computed by using Hight Performance Computing (HPC) and visualized on a large display. The rendering is calculated by using another HPC. The data flow is very important and a real-time 3D simulation is hard to obtain. W. Kapfer and
+
+T. Riser<sup>6</sup> introduce how to use particle system to visualize astronomic simulation, particles representing space objects. The number of particles is extremely important for computing motion in real-time. GPU computing is preferred to render instead of a common HPC solution. To display their data, they have developed their own 3D graphical engine. The space objects are represented by point sprite instead of sphere. Lights are used to give a spherical aspect to the point sprite. This solution allows to render more stars than spherical object method. The 3D engine provides different rendering methods to group space objects: cell simplification or extraction of isosurface. The use of GPU seems quite well for a particle solution, parallel processing allows to render large data; the astrological data seems to be well suited.
+
+In 1976, J. Clark introduces Level Of Detail (LOD) concept<sup>1</sup>. LOD consists of several resolution meshes for using them at different distances from the camera. Firstly, designer produces these meshes. First algorithms, in 1992 Schroeder et al. developed a method by decimation for simplify the mesh<sup>7</sup>. It analyses mesh geometry and evaluates the complexity of triangles. Vertices are removed if only constraints set by the user are respected. Vertices are removed and gaps are filled using triangulation. These algorithms of simplification are not enough to simplify mesh efficiently because shape is not always totally respected. D. Luebke, in 1997, has proposed a taxonomy of mesh simplification<sup>8</sup>. He presented the most used algorithms. He extracted different ways to use each algorithm. But in this paper, only one solution works with volumetric mesh<sup>9</sup>. T. He et al. propose a method based on voxel simplification by using a grid for clustering voxels. A marching cube<sup>10</sup> algorithm was applied to produce a surface mesh. But this simplification algorithm did not preserve the shape of the mesh. In our work, we look for point cloud simplification. Indeed, previous methods which deal with simplification for surface point cloud like<sup>11-13</sup> are not adapted to our case. All of these methods produce LOD for surface mesh and point cloud is extracted from scanner.
+
+# 3. PROPOSED APPROACH
+
+This section presents the different methods that are used to visualize a kind of data from Green Data Center (GDC). The main goal is to be able to visualize in real-time the evolution of temperature in the data center. For this, we use a special particle method. Particles are located using a segmentation algorithm based on Voronoi cell extraction and Delaunay triangulation. The latency due to the large flow of particles is avoided by using a client server paradigm. We improve our solution by using LOD methods to simplify rendering.
+
+# 3.1 Particle systems
+
+Rooms are the bases of our study. For modeling a room, we extract the shape of the space representation which is composed by a box with three measures: length  $(l \in \mathbb{R})$ , width  $(w \in \mathbb{R})$ , height  $(h \in \mathbb{R})$ . Sensors are represented by  $S = \{\mathrm{S}_1, \dots, \mathrm{S}_M\}$ , where  $M$  is the number of sensors. Sensors  $\mathrm{S}_i (\mathrm{i} \in \{1, \dots, M\})$  are placed on the space on a layer  $\mathbf{L} \in \mathbb{N}$  and have a location represented by:  $\{\mathbf{X}_i, \mathbf{Y}_i, \mathbf{L}_j\}$  with  $\mathbf{X}_i \in \mathbb{R}$ ,  $\mathbf{Y}_i \in \mathbb{R}$  and  $j$  is the layer used. For modeling the space inside a room, we use a particle system instead of 2D map representations which have some lacks. $^{14}$  Actually 2D map does not allow having a real visualization of space. A particle visualization gives a better efficiency for modeling space. We use a large number of particles to represent the entire space.  $\mathbf{N} \in \mathbb{N}$  represents the number of particles in the room. It can be calculated using:
+
+$$
+N = \frac {\left(\left(l + 1\right) \times (h + 1) \times (w + 1)\right)}{\delta^ {3}} \tag {1}
+$$
+
+where  $\delta \in \mathbb{R}$  is the space between particles. The particle grid is regular. In this model, three layers of temperature sensors compose rooms. They are defined according to their real locations in the data center. Figure ?? presents the different layers of sensors in the data center.
+
+Particles carry information, and flow motion can be simulated if needed by changing the value of particles and the computational cost is inferior.
+
+# 3.2 Segmentation algorithms
+
+In our solution, each sensors has an influence on surrounding particules. To calculate the set of particles in the sensor range, we use two methods: Voronoi cells extraction and Delaunay triangulation.
+
+Voronoi cells is a method to extract a partition of space  $^{15}$ . This method is available for  $\phi$  dimensions where  $\phi \in [1, +\infty]$ , but most of implementations are done in 2D. Tools for extracting 3D Voronoi diagrams exist: Voro++ and QHull but particles are discrete and these solutions are not suitable because they extract Voronoi diagram in a continuous way. Then we designed our own method based on sphere expansion. We search nearest sensors for each particle. This part allows to weight particles outside the sensors mesh. A second method to weight the interior of the sensors mesh is used. We extract the mesh tetrahedron of sensors using the Delaunay triangulation implemented in QHull. This method was used to analyze the location of particle. We compute the exact location using ray tracing on the soup of tetrahedron. First, we search the nearest particles inside the hull of each tetrahedron. We extract the normal of each face of tetrahedron and we apply these normals on each particle. If the ray cuts three faces or more, the particle is inside the tetrahedron. This method is cost expensive and done in preprocessing. Moreover, particles are static and position didn't need to be update.
+
+# 3.3 Client server paradigm
+
+To improve computation, a client server paradigm is used. We define a low cost communication protocol to transfer data from a server to a client. Server computes the modification of particles and the client displays the results. This protocol works in five steps. These steps are: sending header, sending sensor data, sending particle data, sending footer and receiving acknowledgment/language command from client. At each step, the server waits the acknowledgment from the client. We develop two ways to send data. The first sends the entire point cloud (sensors and particles). The biggest problem of this method is the
+
+transmission of data. Sensors are sent with their coordinates and their value. We encode these data in bit words. For the particles data, the same method was used. The footer was sent for closing the communication. The second method is used to reduce efficiently the communication cost. We only send modified sensors and particles. The id and the new value is sent instead of coordinates. The last step is the command sent by the client. It allows the user to interact with the server. We use it to modify the camera viewpoint.
+
+# 3.4 Level of detail for particles
+
+Level of detail (LOD) is one of the most important methods in computer graphics. It allows to solve rendering problems or performance problems. This method consists by producing several resolution of a 3D object. In our works, we use some features to define the object resolution: hardware and viewpoint. Hardware and viewpoint do not need the same data structure and we need to recompute it for each modification of the viewpoint or when hardware changes. LOD was defined by two problems statement. The first one uses a sample of original points, the second one uses a new point data set. In this part, we define six methods to produce LOD. The four first methods are for the client, the other are for the server.
+
+# Problems statement:
+
+For this two approaches, we have a set  $\omega$  of Vertices  $V$ ,  $V = \{V_1, \ldots, V_\omega\}$ . Each vertex is defined in  $\mathbb{R}^3$ . Simplify a mesh using a sample vertex means  $\omega > \omega 2$ , where  $\omega 2$  is the size of the second data set. For approach 1, we obtain a new object  $\mathrm{V}2 = \{\mathrm{V}2_1, \ldots, \mathrm{V}2_\omega\}$  with fewer points than V but V 2 is a subset of V. For approach 2, we obtain a new object  $\mathrm{V}3 = \{\mathrm{V}3_1, \ldots, \mathrm{V}3_\omega\}$  with fewer points than V but each point in V 3 is a new vertex.
+
+In Section 2 we have presented methods to produce simplification. A few were designed for volumetric simplification. In this section, we propose several methods to produce different volumetric simplifications on our client. We develop four approaches to simplify 3D objects: clustering, neighbor simplification and two approaches based on server. Clustering method was based on He et al.  $^{9}$  works, it consists of clustering particles using a 3D grid. Cells sizes of grid are set depending to the viewpoint of the camera. Clusters were being weight with the average of the different values of particles. The position is the barycenter of these particles. Figures 1(a)-1(e) give some examples of simplification using clustering solution. Figure 1(a) present the original point of cloud mesh. Figure
+
+1(b) and 1(d) give two different methods for clustering. And finally, Figure 1(c) and 1(e) give the results of clustering methods.
+
+Figure 1. Clustering method for simplification point cloud.  
+![](images/ae6cbd294176dc493b50c73240c504ea8c9fc09c9e3151fba6f0be709b525025.jpg)  
+The second solution used is based on neighborhood extraction. Before runtime, we extract all neighbors of a particle. We measure the distance between each particle. Some optimization can help to decrease complexity: we can estimate easily in our structure which particle is closer to another one (using the fact that particle grid is regular). After this,
+
+we extract the main value of particles. We explore each neighbor of particles and we keep the most important. In some cases, the most important can be the high values, in other the low values and in other both of them. This solution is able to produce a low resolution model with the most important information structure. Several low resolution models are created by exploring deeper in neighborhood. Figures 2(a)-2(c) illustrate a neighbor, and two simplifications of this mesh.
+
+![](images/23944f9963b290146f2ac445e8970545bcf00b2949e999067a13468653d749cc.jpg)  
+(a) Neighborhood cloud.
+
+![](images/0e41ba0aeddc8af5f2b6664c64abea63f9b32bfd4692c38f916d07f501d537e5.jpg)  
+(b) Simplification neighborhood of 1.
+
+![](images/c01c12cfcf72e187db35ff49ad4d5edb57331b8d93efa4c1f20941ebf580a3d7.jpg)  
+(c) Simplification neighborhood of 2.  
+Figure 2. Neighbor method for simplification.
+
+Other methods were based on server instead of client. Client sent via TCP connection his viewpoint. The server recomputes the particles structure and recreates the entire structure. With this solution, it is possible to produce a point cloud resolution depending on hardware. Figure 3(a) presents particles rendering with a distance of 2 from the camera. Figure 3(b) is the decimation produced with a distance of 3 and Figure 3(c) is a distance of 1.
+
+Another method was based on Voronoi diffusion of temperature. The bandwidth for transmitting data is limited. We developed Voronoi temperature diffusion to solve this communication. In this approach, we update data using sphere expansion. Each time, we update particles depending on their distance from sensors. The more particles are distant from sensors the later they will be refreshed. This method sends only modified particles. The bandwidth is saved and the visualization gives a flow effect. Figure 4(a) represents values at time 0. At time 1, values of sensors change, 4(b). After time 2, we update a first range of particles 4(c) and finally the second range 4(d).
+
+![](images/7eac2440a2fedd66d943c82b390c3a9df5d95d019d523a29c7a3e2f9c7218928.jpg)  
+(a) Particles server  $(\mathrm{D} = 2)$  
+Figure 3. Particle simplification using server and distance.
+
+![](images/c4777a0507eee1c1beaa13c04e351827098bc588e6ced9d8de6cff01430e3df5.jpg)  
+(b) Particles produce server  $(\mathrm{D} = 3)$
+
+![](images/5dabdfa6b0129921b2abb27785be9608573a25f26e4646d20c6b92250fad1414.jpg)  
+(c) Particles produce by server  $(\mathrm{D} = 1)$
+
+![](images/e340d9807d4ed601eee3bd74351618a9adfda026a8dbd720f9d2aa40857dad26.jpg)  
+(a) Particles and sensors (T = 0).
+
+![](images/92c09c0b767ea453098777786fb815e8c2f833a8abc790807397f42e9a6f6887.jpg)  
+(b) Sensors update  $(\mathrm{T} = 1)$ .
+
+![](images/416dbc943d118d6834e80c8c5ad759b34f940700b96fd0b87bb23c082f10cf10.jpg)  
+(c) First range  $(\mathrm{T} = 2)$ .  
+Figure 4. Simplification using bandwidth size.
+
+![](images/a79e8f2104ab8c32df4137808fc6b4ce9b7465bfa15c2080bd3aabb2c58986d0.jpg)  
+(d) Second range  $(\mathrm{T} = 3)$ .
+
+# 4. EXPERIMENTAL RESULTS
+
+The data are extracted from two rooms of the IBM data center. Firstly, we present our method for rendering the room, and later we present our results using Level Of Detail methods.
+
+# 4.1 Data visualization
+
+We want to visualize and manage the consumption of a data center. For the visualization, we want to use an IFC viewer. But the IFC model for GDC is not available yet. Data center extraction of the room space is for the moment done by hand. The room is empty and was represent by a simple shape a box with 4 meters length, 3 meters width and 2.5 meters height. We use point cloud visualization based on particle paradigm. We use the two rooms of the data center and we put the same number of particles (30000) and 35 sensors distributed on three layers at 1 meter; 2 meter and on the ground. We define high and low temperature regarding the real sensors value. Figure 5(a) presents temperature color scale, Figure 5(b) and Figure 5(c) present data center sensors.
+
+The next step is to interpolate data from sensors. For this, we extract the sensor mesh. We use QHULL to produce a soup of tetrahedrons. Particles need to be located. We can determine which tetrahedron is the nearest, we extract the box hull of tetrahedron and we apply for each particle the norms of each tetrahedron face. If these rays cut three or more faces, then particle is inside the tetrahedron. With this method, we can determine exactly the location of each particles regarding to the tetrahedrons, a weight is given to them easily. It was used to apply a coefficient to the value of each vertex of tetrahedron. For the outside particles, another solution was used: Voronoi cells. This method is based on a discrete extraction of Voronoi cells. We use our own method because other method like Voro ++ or QHull extract Voronoi diagram in a continuous way.
+
+![](images/7c729f1706460b0bf0adde7a8dbd071f9ae77f611ef3f85b3d951fb62795016c.jpg)
+
+![](images/8c16ad7a59f34e5974a4322466cec0149f8905a1a1b1cfadff910a3fec50d004.jpg)  
+(b) Room one.
+
+![](images/2eb0e7b79700cbbd72a8a244992163f567dbbd68f9d3db6bad3e5808cda4dabb.jpg)  
+(c) Room two.
+
+# 4.2 Level of details
+
+In the earlier days of this project, first solution proposed gives a low frame rates, about 15 FPS (Frame Per Second): visualization was not in real-time (real-time is about 24 FPS). For solving this problem, we define a client server paradigm. This solution allows to produce a real-time rendering on the client. Figure ?? gives an example of LOD for particles. We use Openscenegraph  $^{20}$  as a 3D engine. It owns several features useful in LOD. A special object is defined to manage multi-resolution model. It calculates the distance of the object from the camera. For our experimentation we use five resolutions of mesh. The first mesh was the original mesh, it is set at 0 to 500. The next mesh was set at 500 to 1000, the next at 1000 to 1500 and the other at 1500 to 2000. These three meshes were constructed by specific LOD methods: clustering and significant vertices. Clustering defines a 3D grid inside the room. The size of each cell depends on the viewpoint location. The size of the cluster depends on the visibility of the clustered particles. First results are given Figure 6(a) and 6(b). Value of cluster is an average of clustered value. The number of points of the final mesh depends on the grid size. Table 1 shows the results at several distances.
+
+<table><tr><td></td><td>D = 0 to 500</td><td>D = 500 to 1000</td><td>D = 1000 to 1500</td><td>D = 1500 to 2000</td></tr><tr><td>C = X</td><td>30000</td><td>3900</td><td>240</td><td>36</td></tr></table>
+
+![](images/9fbe1142edda7eab13f0abb9592b84e63d1611257e7426d7d569a68b9df82b38.jpg)  
+Figure 5. Data use to model the system.  
+(a)  $\mathrm{D} = 500$  to 1000.  
+Figure 6. Clustering visualization algorithms.
+
+![](images/69ae709df8988787ff641b5b6eb5a608ca0636bba7110a3a4735064168d117da.jpg)  
+Table 1. Results of clustering simplification.  
+(b)  $D = 1000$  to 1500.
+
+Significant points method extracts the neighbors for each particle. We extract the highest and lowest temperatures, by exploring the neighborhood of a particle, in order to have significant vertices of the model. For the first step of simplified model we explore neighbor. For the second model, we explore neighbor and neighbor of neighbor, etc. This solution simplifies drastically the model. First results are given Figure ??-??. Table 2 shows the number of vertices at several distance.
+
+<table><tr><td></td><td>D = 0 to 500</td><td>D = 500 to 1000</td><td>D = 1000 to 1500</td><td>D = 1500 to 2000</td></tr><tr><td>C = X</td><td>30000</td><td>22950</td><td>4554</td><td>3524</td></tr></table>
+
+![](images/4050e8f862ac40be7bc6d5c239997192325936e244911b8d69fe60a4ab8810b8.jpg)  
+(a) Neighborhood 1.  
+Figure 7. Clustering visualization algorithms using neighbor.
+
+![](images/dafb2130c8265a91a7faed53db3de1181cd524770896acda68d5a953df004f87.jpg)  
+(b) Neighborhood 2.
+
+The first server solution receives orders from client as presented Section 3.4. We calculate the viewpoint distance and we send data according to it. A new structure is recalculated if the camera is too far from the object. After the recomputing, we send the new data. This solution allows the user to receive more or less data according to its distance to the object. Table 3 shows some different resolutions produced with this method.
+
+Table 2. Results of neighbor simplification.  
+
+<table><tr><td></td><td>D = 0 to 500</td><td>D = 500 to 1000</td><td>D = 1000 to 1500</td><td>D = 1500 to 2000</td></tr><tr><td>C = X</td><td>120000</td><td>30000</td><td>7500</td><td>1875</td></tr></table>
+
+Table 3. Several resolution of model.
+
+Another solution is to use bandwidth latency. We send data at several times, we do not send the entire set of data but only modified particles. We send at first time the sensors data, and subsequently we send a range of data (the nearest). After few minutes, all data are sent. This solution gives good results, and simulates a thermal diffusion in the whole structure of particles. Figure 8(a)-8(c) illustrate this method.
+
+![](images/2fcee6efa3b1d3c44144e2639f3857a15c4079f838c4f9132953fd427a8b1be9.jpg)  
+(a)  $\mathrm{T} = 0$
+
+![](images/b2be70bd4cc7d261ac38e8bc653a0c09c537d49d2a5612ed5c067058a98ef463.jpg)  
+(b)  $\mathrm{T} = 1$
+
+![](images/0d4e22f04d3ea25761125c93fc6d70fe856bf840ef353c043f32d21c9633724e.jpg)  
+(c)  $\mathrm{T} = 4$
+
+# 5. CONCLUSION
+
+In this paper, we have presented a method to visualize sensors data extracted from a Green Data Center. This approach produces interpolation visualization for managing and visualizing data. This interpolation used a Delaunay triangulation and a cell extraction based on Voronoi. An unusual way of use particles helps to process data. First results present the solution proposed to visualize the inside of a GDC space. The second results proposed in this paper aim to improve the rendering.
+
+For this, first step introduces a client/server protocol a second step illustrates methods to simplify the model. With these different approaches we improve the rendering time, preserving most important data are kept. In future works, we will work on data "dressing". We want to find a way to improve rendering of the scene using meatballs or marching cube algorithms. A main constraint of this work is real-time computation. Future work also concern to add rooms to the visualization. At present, we only visualize a single room. We want to visualize building, and complex form, by using an IFC loader.
+
+# ACKNOWLEDGMENTS
+
+We want to thanks the PSSC (Products and Solutions Support Center) team of IBM Montpellier for having provided the necessary equipment and data need for this experimentation. And we thank the FUI (Fonds Unique Interministriel) for their financial support.
+
+# REFERENCES
+
+[1] Clark, J. H., "Hierarchical geometric models for visible surface algorithms," Communications of the ACM 19(10), 547-554 (1976).  
+[2] Damon, M., Kameyama, M., Knox, M., Porter, D., Yuen, D., and Sevre, E., "Interactive visualization of 3d mantle convection," Visual Geosciences (2008).  
+[3] Jordan, K. E., Yuen, D. A., Reuteler, D. M., Zhang, S., and Haimes, R., "Parallel interactive visualization of 3d mantle convection," IEEE Comput. Sci. Eng. 3(4), 29-37 (1996).  
+[4] Reeves, W. T., "Particle systems - a technique for modeling a class of fuzzy objects," ACM Transactions on Graphics 2, 359-376 (1983).  
+[5] Latta, L., "Building a million particle system," (2004).  
+[6] Kapferer, W. and Riser, T., "Visualization needs and techniques for astrophysical simulations," New Journal of Physics 10(12), 125008 (15pp) (2008).  
+[7] Schroeder, W. J., Zarge, J. A., and Lorensen, W. E., "Decimation of triangle meshes," 65-70 (1992).  
+[8] Luebke, D., "A survey of polygonal simplification algorithms," (1997).  
+[9] He, T., Hong, L., Kaufman, A., Varshney, A., and Wang, S., "Voxel based object simplification," in [Proc. SIGGRAPH Symposium on Interactive 3D Graphics], 296-303 (1995).  
+[10] Lorensen, W. E. and Cline, H. E., "Marching cubes: A high resolution 3d surface construction algorithm," SIGGRAPH Comput. Graph. 21(4), 163-169 (1987).  
+[11] Pauly, M., Gross, M., and Kobbelt, L. P., "Efficient simplification of point-sampled surfaces," (2002).  
+[12] Moenning, C., , Moenning, C., and Dodgson, N. A., "Intrinsic point cloud simplification,"
+
+(2004).  
+[13] Song, H. and Feng, H.-Y., "A progressive point cloud simplification algorithm with preserved sharp edge data," The International Journal of Advanced Manufacturing Technology 45, 583-592 (November 2009).  
+[14] Buschmann, C., Pfisterer, D., Fischer, S., Fekete, S. P., and Kröller, A., "Spyglass: a wireless sensor network visualizer," SIGBED Rev. 2(1), 1-6 (2005).  
+[15] Avis, D. and Bhattacharya, B., "Algorithms for computing d-dimensional voronoi diagrams and their duals," 1, 159-180 (1983).  
+[16] Rycroft, C. H., "Voro++: a three-dimensional voronoi cell library in  $c++$ ," Chaos 19 (2009). Lawrence Berkeley National Laboratory.  
+[17] Barber, C. B., Dobkin, D. P., and Huhdanpaa, H., "The quickhull algorithm for convex hulls," ACM Trans. Math. Softw. 22(4), 469-483 (1996).  
+[18] Snyder, J. M. and Barr, A. H., "Ray tracing complex models containing surface tessellations," SIGGRAPH Comput. Graph. 21(4), 119-128 (1987).  
+[19] Hoppe, H., "Progressive meshes. computer graphics," SIGGRAPH96 Proceedings, 99108 (1996).  
+[20] Burns, D. and Osfield, R., "Open scene graph a: Introduction, b: Examples and applications," 265 (2004).
+
+Further author information:
+
+Lange B.: E-mail: benoit.lange@lirmm.fr
+
+Rodriguez N.: E-mail: nancy.rodriguez@lirmm.fr
+
+Puech W.: E-mail: william.puech@lirmm.fr
+
+Rey H.: E-mail:REYHERVE@fr.ibm.com
+
+Vasques X.: E-mail: xaviervasques@fr.ibm.com