# Cloud Computing Based on Computational Characteristics for Disaster Monitoring
## 3 Cloud Computing Model for Disaster Monitoring
### Application of MapReduce for Disaster-Monitoring Model
MapReduce's cloud computing model for this type of disaster-monitoring model is expressed as Algorithm 5. ```
1:the serialized remote sensing data. 2:Intermediate results for the next job input. 3:functionMapper(key1, value1)
4:deserialize values1 into metadata and f(t);
5:forallitem\(\in\)f(t)do
6:F(s) =G[item];
7:W(s);
8:f(t) =G^-1[F(s)];
9:endfor
10:key2 = key1; value2 =serialize(metadata, f(t));
11:output(key2, value2);
12:endfunction
```  
**Algorithm 5**The cloud computing model for Frequency Domain Operation  
```
1:the serialized remote sensing data. 2:Intermediate results for the next job input. 3:functionMapper(key1, value1)
4:deserialize values1 into metadata and f(t);
5:forallitem\(\in\)f(t)do
7:F(s) =G[item];
8:W(s);
9:f(t) =G^-1[F(s)];
10:endfor
11:key2 = key1; value2 =serialize(metadata, f(t));
12:output(key2, value2);
13:endfunction
```  
**Algorithm 6**The cloud computing model for the user job input. ```
1:the serialized remote sensing data. 2:Intermediate results for the next job input. 3:functionMapper(key1, value1)
4:deserialize values1 into metadata and f(t);
5:forallitem\(\in\)f(t)do
6:F(s) =G[item];
7:W(s);
8:f(t) =G^-1[F(s)];
9:endfor
10:key2 = key1; value2 =serialize(metadata, f(t));
11:output(key2, value2);
12:endfunction
```  
**Algorithm 7**The cloud computing model for the user job input. ```
1:the serialized remote sensing data. 2:Intermediate results for the user job input. 3:functionMapper(key1, value1)
4:deserialize values1 into metadata and f(t);
5:forallitem\(\in\)f(t)do
7:F(s) =G[item];
8:W(s);
9:f(t) =G^-1[F(s)];
10:endfor
11:key2 = key1; value2 =serialize(metadata, f(t));
12:output(key2, value2);
13:endfunction
```  
**Algorithm 8**The cloud computing model for the user job input. ```
1:the serialized remote sensing data. 2:Intermediate results for the user job input. 3:functionMapper(key1, value1)
4:deserialize values1 into metadata and f(t);
5:forallitem\(\in\)f(t)do
7:F(s) =G[item];
8:W(s);
9:f(t) =G^-1[F(s)];
10:endfor
11:key2 = key1; value2 =serialize(metadata, f(t));
12:output(key2, value2);
14:endfunction
```  
**Algorithm 9**The cloud computing model for the user job input. ```
1:the serialized remote sensing data. 2:Intermediate results for the user job input. 3:functionMapper(key1, value1)
4:deserialize values1 into metadata and f(t);
5:forallitem\(\in\)f(t)do
7:F(s) =G[item];
8:W(s);
9:f(t) =G^-1[F(s)];
10:endfor
11:key2 = key1; value2 =serialize(metadata, f(t));
12:output(key2, value2);
13:endfunction
```  
**Algorithm 10**The cloud computing model for the user job input. ```
1:the serialized remote sensing data. 2:Intermediate results for the user job input. 4:functionMapper(key1, value1)
5:forallitem\(\in\)f(t)do
7:F(s) =G[item];
14:W(s);
15:W(s);
16:f(t) =G^-1[F(s)];
17:endfor
18:key2 = key1; value2 =serialize(metadata, f(t));
19:output(key2, value2);
20:endfunction
```  
**Algorithm 11**Cloud computing model for the user job input. ```
1:the serialized remote sensing data. 3:Intermediate results for the user job input. 4:functionMapper(key1, value1)
5:forallitem\(\in\)f(t)do
7:F(s) =G[item];
19:W(s);
21:forallitem\(\in\)f(t)do
8:F(t) =G[item];



## 4 Experiments and Performance Evaluation

### Description of Computing Models for Use Cases in Cloud Environments

Generally, disaster-monitoring processing with remote-sensing data process starts with data acquisition, passes through remote-sensing image preprocessing, information extraction, and global monitoring applications, and ends with product visualization [34]. The remote-sensing data processing model based on MapReduce can appear complicated, but this complexity is usually because there are many MapReduce jobs, not the complexity of the individual Map or Reduce operations themselves. In other words, in practice we are willing to add more jobs, which does not increase the complexity of the job. These operations are performed as MapReduce jobs by the operation engine working in the Hadoop environment. Therefore, by designing a simpler Map and Reducing functions, the job would be easier to maintain and decompose.