@*******************************************************************************
 * Licensed to the Apache Software Foundation (ASF) under one or more		   *
 * contributor license agreements.  See the NOTICE file distributed with	   *
 * this work for additional information regarding copyright ownership.         *
 * The ASF licenses this file to You under the Apache License, Version 2.0     *
 * (the "License"); you may not use this file except in compliance with        *
 * the License.  You may obtain a copy of the License at                       *
 *                                                                             *
 *    http://www.apache.org/licenses/LICENSE-2.0                               *
 *																			   *
 * Unless required by applicable law or agreed to in writing, software         *
 * distributed under the License is distributed on an "AS IS" BASIS,           *
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    *
 * See the License for the specific language governing permissions and         *
 * limitations under the License.											   *
 *******************************************************************************@ 

@(email: String, vfile: String, dataset: String)

@import helper._ 

@main("Home") {

<div class="jumbotron">
	<div class="row">

		<div class="col-lg-5">
			</br></br>
			<img src="/assets/images/main.jpg" height="480" width="330" />
		</div>
		<div class="col-lg-6">
			<h2>Climate Model Diagnostic Analyzer</h2>
			<br>
			<p> A repository of web services for multi-aspect physics-based and 
				phenomenon-oriented phenomenon-oriented climate model performance
				evaluation and diagnosis through the comprehensive and synergistic 
				use of multiple observational data, reanalysis data, and model outputs.
			</p>
			<br>
			<p> This repository is specially customized to support the 2015 JPL Center
				for Climate Sciences Summer School. The theme of the summer school is 
				<b>Using Satellite Observations to Advance Climate Models</b>. This repository 
				provides datasets and analysis tools for the students to use for their 
				group research projects.
			</p>
			
			<!-- @if(!session.get("username")){ -->
			
			<p>
				@if(false){ <a class="btn btn-primary" href="climate/register"
					role="button">Register &raquo;</a> }
			</p>
			<!-- } -->
		</div>
	</div>
</div>

}
