CDPP / DDServer

Commit bd9dfce2c8b349bae57f4af486fa23dea382bfe0

Authored by Benjamin Renard
1 parent ae283410
Exists in master and in 10 other branches WIP, clean_real, create-user, epntap, evol_9042, fix-cdaweb, livraison-akka, sqlite_test, time-in-double, ubuntu

Add CALLEXT and DECODERS for access to external datasets

Showing 33 changed files with 5727 additions and 2 deletions   Show diff stats
Inline Side-by-side
CMakeLists.txt
  Diff comments   View file @bd9dfce
... ... @@ -25,6 +25,7 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/modules/")
25 25 find_package( Threads REQUIRED )
26 26 find_package( CRYPT REQUIRED )
27 27 find_package( NetCDF REQUIRED )
  28 +find_package( CDF REQUIRED )
28 29  
29 30 get_filename_component(NETCDFLIB_DIR ${NETCDFLIBRARIES} PATH)
30 31  
... ... @@ -36,9 +37,18 @@ configure_file (
36 37 MESSAGE( STATUS "Build DD_Server Project" )
37 38 add_subdirectory(src/CLIENT)
38 39 add_subdirectory(src/SERVER)
  40 +add_subdirectory(src/DECODERS/ascii2nc)
  41 +add_subdirectory(src/DECODERS/cdf2nc)
  42 +add_subdirectory(src/DECODERS/nc2nc)
  43 +add_subdirectory(src/DECODERS/themis/esa2nc)
  44 +add_subdirectory(src/DECODERS/themis/esafull2nc)
  45 +add_subdirectory(src/DECODERS/themis/esamom2nc)
  46 +add_subdirectory(src/DECODERS/themis/fgm2nc)
  47 +add_subdirectory(src/DECODERS/themis/sst2nc)
39 48 add_subdirectory(tests)
40 49  
41 50 install(FILES "scripts/StartServer" DESTINATION . PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
42 51 install(DIRECTORY "src/INCLUDE/" DESTINATION include)
  52 +install(DIRECTORY "src/CALLEXT/" DESTINATION bin/CALLEXT)
43 53  
44 54 SET(CMAKE_VERBOSE_MAKEFILE ON)
... ...
src/CALLEXT/cdaweb_cfg.php 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,9 @@
  1 +<?php
  2 + define("ftp_server", "cdaweb.gsfc.nasa.gov");
  3 + define("ftp_user_name", "anonymous");
  4 + define("ftp_user_pass", "budnik@irap.omp.eu");
  5 + define("ftp_dir", "pub/software/cdawlib/0MASTERS/");
  6 +
  7 + define ("wsdlCDAWEB", "http://cdaweb.gsfc.nasa.gov/WS/jaxrpc?WSDL");
  8 + define ("viewID" , "istp_public");
  9 +?>
0 10 \ No newline at end of file
... ...
src/CALLEXT/createHeaderMAPSKP.php 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,84 @@
  1 +<?php
  2 +/* $Id: createHeaderMAPSKP.php,v 1.5 2008/03/05 14:03:45 elena Exp $ */
  3 +/**
  4 +* \file createHeaderMAPSKP.php
  5 +* \brief Function to create header.nc for MapsKP datasets which are not self-described
  6 +* \todo Exclude absolute path for /usr/local/bin/ncgen
  7 +*/
  8 +
  9 +function createHeaderMAPSKP($remSetID) {
  10 +
  11 + $url = "http://planetoweb.cesr.fr/mapskp-amda/MapskpService.php?";
  12 + $passwd = "ftp://amda:dd;mapskp@";
  13 +
  14 + $args = array('service'=>'getInfoUrl',
  15 + 'datasetId'=>$remSetID);
  16 +
  17 + $url .= http_build_query($args);
  18 + $infoDom = new DOMDocument();
  19 + $infoDom->load($url);
  20 + $File = $infoDom->getElementsByTagName("infoUrl")->item(0)->nodeValue;
  21 +
  22 + $fileName_ = explode("ftp://",$File);
  23 + $fileName = $fileName_[0].$passwd.$fileName_[1];
  24 +
  25 + $infoDom->load($fileName);
  26 +
  27 + $sampling = $infoDom->getElementsByTagName("TIME_RESOLUTION")->item(0)->nodeValue;
  28 + $globalAttrs = ":minSampling = ".$sampling.";";
  29 +
  30 + $params = $infoDom->getElementsByTagName("PARAM_METADATA");
  31 +
  32 + $Dimensions = "Time = unlimited, TimeLength = 17 ";
  33 + $charVariables = "char Time(Time,TimeLength), StartTime(TimeLength), StopTime(TimeLength);";
  34 + $floatVariables = "float ";
  35 +
  36 + $Size = array();
  37 + $addDim = true;
  38 +
  39 + for ($i = 0; $i < $params->length; $i++) {
  40 +
  41 + $Name = $params->item($i)->getElementsByTagName("PARAM_ID")->item(0)->nodeValue;
  42 + $Size[$i] = $params->item($i)->getElementsByTagName("SIZES")->item(0)->nodeValue;
  43 + $Type = $params->item($i)->getElementsByTagName("DATA_TYPE")->item(0)->nodeValue;
  44 +
  45 + if ($i > 0) $floatVariables .= ",";
  46 +
  47 + if ($Size[$i] != "1" ) {
  48 + for ($j = 0; $j < $i+1; $j++)
  49 + if ($Size[$i] == $Size[$j]) {
  50 + if ($i != 0 && $j != $i) $addDim = false;
  51 + break;
  52 + }
  53 + if ($addDim) $Dimensions .= ", Dim".$j." = ".$Size[$j];
  54 + $floatVariables .= $Name."(Time, Dim".$j.")";
  55 + $addDim = true;
  56 + }
  57 + else
  58 + $floatVariables .= $Name."(Time)";
  59 +//
  60 + }
  61 +
  62 +// Create CDL ASCII file
  63 + $cdl = fopen("header.cdl","w");
  64 + fwrite($cdl, "netcdf header { \n \n dimensions: \n");
  65 + fwrite($cdl,$Dimensions."; \n\n");
  66 +
  67 + fwrite($cdl, "variables: \n ");
  68 + fwrite($cdl, $charVariables."\n");
  69 + fwrite($cdl, $floatVariables."; \n \n");
  70 + fwrite($cdl, $globalAttrs."\n");
  71 + fwrite($cdl, "data: \n\n }");
  72 + fclose($cdl);
  73 +// transform to nc
  74 + system("/usr/bin/ncgen -o header.nc header.cdl");
  75 +// make constant Energy Tables in info.nc
  76 +// For MIMI also ...
  77 + if ($remSetID == "RPWS_KEY") {
  78 + $StartTime = $infoDom->getElementsByTagName("START_DATE")->item(0)->nodeValue;
  79 + $function = "make".$remSetID."info";
  80 + include($function.".php");
  81 + if ($OK = $function($StartTime)) system("join_nc ".strtolower($remSetID)."_constant.nc ".strtolower($remSetID)."_info.nc");
  82 + }
  83 + }
  84 +?>
... ...
src/CALLEXT/createHeaderVEXGRAZ.php 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,64 @@
  1 +<?php
  2 +/**
  3 +* @file createHeaderVEXGRAZ.php
  4 +* @version $Id: createHeaderVEXGRAZ.php,v 1.1 2009/03/23 14:02:39 budnik Exp $
  5 +* @brief Function to create header.nc for MapsKP datasets which are not self-described
  6 +* @todo Exclude absolute path for /usr/local/bin/ncgen
  7 +*/
  8 +
  9 +
  10 +function createHeaderVEXGRAZ($remSetID) {
  11 +
  12 + $infoDom = new DOMDocument();
  13 + $infoDom->load(INFODIR."../AmdaInfo/MAG_VSO.xml");
  14 +
  15 + $sampling = $infoDom->getElementsByTagName("TIME_RESOLUTION")->item(0)->nodeValue;
  16 + $globalAttrs = ":minSampling = ".$sampling.";";
  17 +
  18 + $params = $infoDom->getElementsByTagName("PARAM_METADATA");
  19 +
  20 + $Dimensions = "Time = unlimited, TimeLength = 17 ";
  21 + $charVariables = "char Time(Time,TimeLength), StartTime(TimeLength), StopTime(TimeLength);";
  22 + $floatVariables = "float ";
  23 +
  24 + $Size = array();
  25 + $addDim = true;
  26 +
  27 + for ($i = 0; $i < $params->length; $i++) {
  28 +
  29 + $Name = $params->item($i)->getElementsByTagName("PARAM_ID")->item(0)->nodeValue;
  30 + $Size[$i] = $params->item($i)->getElementsByTagName("SIZES")->item(0)->nodeValue;
  31 + $Type = $params->item($i)->getElementsByTagName("DATA_TYPE")->item(0)->nodeValue;
  32 +
  33 + if ($i > 0) $floatVariables .= ",";
  34 +
  35 + if ($Size[$i] != "1" ) {
  36 + for ($j = 0; $j < $i+1; $j++)
  37 + if ($Size[$i] == $Size[$j]) {
  38 + if ($i != 0 && $j != $i) $addDim = false;
  39 + break;
  40 + }
  41 + if ($addDim) $Dimensions .= ", Dim".$j." = ".$Size[$j];
  42 + $floatVariables .= $Name."(Time, Dim".$j.")";
  43 + $addDim = true;
  44 + }
  45 + else
  46 + $floatVariables .= $Name."(Time)";
  47 +//
  48 + }
  49 +
  50 +// Create CDL ASCII file
  51 + $cdl = fopen("header.cdl","w");
  52 + fwrite($cdl, "netcdf header { \n \n dimensions: \n");
  53 + fwrite($cdl,$Dimensions."; \n\n");
  54 +
  55 + fwrite($cdl, "variables: \n ");
  56 + fwrite($cdl, $charVariables."\n");
  57 + fwrite($cdl, $floatVariables."; \n \n");
  58 + fwrite($cdl, $globalAttrs."\n");
  59 + fwrite($cdl, "data: \n\n }");
  60 + fclose($cdl);
  61 +// transform to nc
  62 + system("/usr/local/bin/ncgen -o header.nc header.cdl");
  63 + }
  64 +?>
... ...
src/CALLEXT/createVI.php 0 → 100755
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,298 @@
  1 +<?php
  2 +/*----------------------------------------------------------------------
  3 + * DD SERVER TOOLS
  4 + * data update collection
  5 + * createVI.php
  6 + * 17 Jun 2007 V.1.0
  7 + * 01 Aug 2007 V.1.1 Only one argument in info2nc call
  8 + * 02 Aug 2007 V.1.2 rebuild, clean & cash from templates in DDLIB
  9 + * 05 Sep 2007 V.1.3 creates empty *times.nc
  10 + * 24 Nov 2007 V.1.4 DDrehash -> TimesUpdate
  11 + * 14 Feb 2008 V.1.5 added Mission & Instrument tags ; and createHeader if neccessary
  12 + * 11 Sep 2012 V.1.6 get dataset info from remote DB to keep it at server side in the only one place
  13 + *-----------------------------------------------------------------------*/
  14 +
  15 +function getCDF($remSetID){
  16 +
  17 + $client = new SoapClient(wsdlCDAWEB);
  18 +/* Get "VIEW" descriptions, select "istp_public" and set endPoint address*/
  19 + $metaData = $client->__soapCall("getAllViewDescriptions", array());
  20 +
  21 + for ($k = 0; $k < count($metaData); $k++) {
  22 + if ($metaData[$k]->id != viewID) continue;
  23 + try {
  24 + $client->__setLocation($metaData[$k]->endpointAddress);
  25 + break;
  26 + }
  27 + catch (SoapFault $exception){
  28 + error_log($exception.PHP_EOL, 3, err);
  29 + return false;
  30 + }
  31 + }
  32 + $fileXML = INFODIR.'CDAWEB/'.$remSetID.'.xml';
  33 + if (!file_exists($fileXML)) {
  34 + error_log('No DDServer XML description '.$remSetID.PHP_EOL, 3, err);
  35 + return false;
  36 + }
  37 + $XML= new DomDocument("1.0");
  38 + $XML->load($fileXML);
  39 +
  40 + $Start = $XML->getElementsByTagName('GlobalStart')->item(0)->nodeValue;
  41 + $fileName = strtolower($remSetID)."_00000000_v01.cdf";
  42 + $Stop = strftime("%Y-%m-%dT%H:%M:%S.000Z",strtotime($Start) + 82800);
  43 + $nFiles = 0;
  44 + $INFO_DIR = INFODIR."../CDAWEB/DATASETS/";
  45 +
  46 + while ($nFiles == 0){
  47 + $dataFileDesc = $client->__soapCall("getDataFiles", array($remSetID, $Start, $Stop));
  48 + $nFiles = count($dataFileDesc);
  49 + if ($nFiles > 0) {
  50 + if (!copy($dataFileDesc[0]->name, $INFO_DIR.$fileName)){
  51 + error_log('Cannot copy '.$dataFileDesc[0]->name.PHP_EOL, 3, err);
  52 + return false;
  53 + }
  54 + }
  55 + $Start = strftime("%Y-%m-%dT%H:%M:%S.000Z",strtotime($Stop) + 82800);
  56 + $Stop = strftime("%Y-%m-%dT%H:%M:%S.000Z",strtotime($Start) + 82800);
  57 + }
  58 + if ($nFiles == 0) {
  59 + error_log('No data file '.$remSetID.' '.$Start.PHP_EOL, 3, err);
  60 + return false;
  61 + }
  62 +
  63 + return true;
  64 +}
  65 +
  66 +function getInfoFromRemoteBase($dataBaseID, $remSetID){
  67 +
  68 + $INFO_DIR = INFODIR."../".$dataBaseID."/DATASETS/";
  69 + if (!is_dir($INFO_DIR)) mkdir($INFO_DIR, 0755, true);
  70 +
  71 + switch ($dataBaseID) {
  72 + case 'CDAWEB' :
  73 + require_once "ftpWrapper.php";
  74 + require_once "cdaweb_cfg.php";
  75 +
  76 + $fileName = strtolower($remSetID)."_00000000_v01.cdf";
  77 + if (file_exists($INFO_DIR.$fileName)) return true;
  78 +
  79 + // Get master CDF
  80 + if (!ftpWrapper(ftp_server, ftp_user_name, ftp_user_pass,
  81 + ftp_dir.$fileName, $INFO_DIR.$fileName)) {
  82 + error_log('No master CDF for '.$remSetID.PHP_EOL, 3, err);
  83 + // No master CDF - try regular file
  84 + return getCDF($remSetID);
  85 + }
  86 +
  87 + return true;
  88 +
  89 + break;
  90 + case "MAPSKP":
  91 +
  92 + require_once "mapskp_cfg.php";
  93 +
  94 + $XML_NAME = $remSetID.".xml";
  95 + if (file_exists($INFO_DIR.$XML_NAME)) return true;
  96 +
  97 + $args = array('service'=>'getInfoUrl', 'datasetId'=>$remSetID);
  98 +
  99 + $url = url.http_build_query($args);
  100 +
  101 + $infoDom = new DOMDocument();
  102 + $infoDom->load($url);
  103 + $File = $infoDom->getElementsByTagName("infoUrl")->item(0)->nodeValue;
  104 +
  105 + $fileName_ = explode("ftp://",$File);
  106 + $fileName = $fileName_[0].passwd.$fileName_[1];
  107 +
  108 + if (!copy($fileName,$INFO_DIR.$XML_NAME)) return false;
  109 + return true;
  110 +
  111 + break;
  112 +
  113 + case "VEXGRAZ" :
  114 + $fileName = "MAG_VSO.xml";
  115 + if (file_exists($INFO_DIR.$fileName)) return true;
  116 + return false;
  117 + break;
  118 +
  119 + case "CDPP" :
  120 +
  121 + break;
  122 +
  123 + default:
  124 + }
  125 +
  126 + return true;
  127 +
  128 +};
  129 +
  130 +function getInfoFromAmda($dataBaseID, $remSetID)
  131 +{
  132 +
  133 + global $DDsysInfo;
  134 +
  135 + if (file_exists(BASEDIR.'info.xml')) unlink(BASEDIR.'info.xml');
  136 +
  137 + $DDinfo = new DomDocument("1.0");
  138 + $VI = $DDinfo->createElement("VI");
  139 +
  140 + $InfoArr = $DDsysInfo->getElementsByTagName("VI")->item(0)->childNodes;
  141 + for ($i = 0; $i < $InfoArr->length; $i++)
  142 + if ($InfoArr->item($i)->nodeName != '#text' && $InfoArr->item($i)->nodeName != 'PARAMETER')
  143 + $VI->appendChild($DDinfo->importNode($InfoArr->item($i), true));
  144 + $VI->appendChild($DDinfo->createElement("LocalStart"));
  145 + $VI->appendChild($DDinfo->createElement("LocalStop"));
  146 + $DDinfo->appendChild($VI);
  147 + $DDinfo->save(BASEDIR.'info.xml');
  148 +
  149 + return true;
  150 +}
  151 +
  152 +/**
  153 +* @file createVI.php
  154 +* @brief DD_Server tool <br> Creates New Virtual Instrument
  155 +* @version $Id: createVI.php,v 1.11 2013/09/23 09:02:28 budnik Exp $
  156 +* Creates New VI at DD_Server Side \n
  157 +* Args: dataBaseID ddDataSetID remoteDataSetID \n
  158 +* Env Vars: $DDBASE $DDBASEBIN $DDLIB \n
  159 +* Executables: makeDDsys info2nc TimesUpdate \n
  160 +* Functions: getInfoFromAmda
  161 +*
  162 +* @arg Checks if VI already exists in dataBase desctiptor $DDBASE/DDsys.xml
  163 +* @arg Adds non-existing VI to DDres.xml
  164 +* @arg $DDBASEBIN/makeDDsys creats refer.nc file from DDsys.xml
  165 +* @arg Gets dataSet Info from INFO/DDServer dir
  166 +* @arg Creates dir, *_cash.nc, *_info.nc and empty *_times.nc
  167 +*
  168 +*/
  169 +
  170 + global $DDsysInfo;
  171 +
  172 + define("verbose", true);
  173 +
  174 +
  175 + define("BASEDIR",getenv("DDBASE")."/");
  176 + define("INFODIR",BASEDIR."../INFO/DDServer/");
  177 + define("DDBASEBIN",getenv("DDBASEBIN"));
  178 + define("DDLIB", getenv("DDLIB")."/");
  179 +
  180 + define ("log",BASEDIR."../INFO/addVI.log");
  181 + define ("err",BASEDIR."../INFO/addVI.err");
  182 +
  183 +
  184 + if ($argc != 4) {
  185 + error_log("Usage: php createVI.php <BaseID> <RemSetID> <NewVIName>".PHP_EOL, 3, err);
  186 + exit("Usage: php createVI.php <BaseID> <RemSetID> <NewVIName>".PHP_EOL);
  187 + }
  188 +
  189 + $dataBaseID = strtoupper($argv[1]);
  190 + $remSetID = $argv[2];
  191 + $VIID = strtolower($argv[3]);
  192 +
  193 +
  194 +
  195 + $MAX_VI_NAME_LENGTH = 16;
  196 + $nc_prefix = strlen($VIID) > $MAX_VI_NAME_LENGTH ? substr($VIID,0,15): $VIID;
  197 +
  198 + $newDataSet = false;
  199 + $DDsysRefer = BASEDIR."DDsys.xml";
  200 + if (verbose)
  201 + error_log("request to add Data Set ".$dataBaseID.":".$remSetID." as ".$VIID.PHP_EOL, 3, log);
  202 +// Check if dataSet exists already
  203 + $DDsys = new DomDocument("1.0");
  204 + $DDsys->preserveWhiteSpace = false;
  205 + $DDsys->formatOutput = true;
  206 + $DDsys->load($DDsysRefer);
  207 +
  208 + $xp = new domxpath($DDsys);
  209 + $dataSet = $xp->query("//NAME[.='".$VIID."']");
  210 +
  211 + if ($dataSet->item(0) != NULL)
  212 + if ($dataSet->item(0)->getAttribute("base") != $dataBaseID) {
  213 + error_log(" Data Set ".$VIID." exists! Corresponding BaseID is "
  214 + .$dataSet->item(0)->getAttribute("base")." not ".$dataBaseID.PHP_EOL, 3, err);
  215 +
  216 + $newDataSet = true;
  217 + }
  218 + if ($dataSet->item(0) == NULL) $newDataSet = true;
  219 +
  220 +//-------------- Get Full Dataset Info file from distant database-------------
  221 +//TODO error processing here
  222 + $res = getInfoFromRemoteBase($dataBaseID, $remSetID);
  223 + if (!$res)
  224 + error_log("Error: Can't get dataset info for ".$remSetID." from ".$dataBaseID.PHP_EOL, 3, err);
  225 +
  226 + if (verbose) error_log("Get dataset info for ".$remSetID." from ".$dataBaseID." returns ".$res.PHP_EOL, 3, log);
  227 + if ($newDataSet) {
  228 +
  229 +//----------- Gets INFO from INFO/DDServer -------------------
  230 + if (verbose) error_log("Ready to Add ".$VIID.PHP_EOL, 3, log);
  231 + $DDsysInfo = new DomDocument("1.0");
  232 +
  233 +//----------- Getting INFO file for DataSet
  234 + $XmlName = INFODIR.$dataBaseID."/".$remSetID.".xml";
  235 +
  236 + if (file_exists($XmlName)){
  237 +
  238 + $DDsysInfo->load($XmlName);
  239 + $mission = $DDsysInfo->getElementsByTagName("Mission")->item(0)->nodeValue;
  240 + $instrument = $DDsysInfo->getElementsByTagName("Instrument")->item(0)->nodeValue;
  241 +
  242 +//--------- Check if additional Info should be added to VI
  243 +
  244 + $theFormat = $DDsysInfo->getElementsByTagName("Format")->item(0);
  245 + if ($theFormat != NULL)
  246 + $AddInfo = ($theFormat->nodeValue == "Text");
  247 + if (!$AddInfo)
  248 + $AddInfo = ($DDsysInfo->getElementsByTagName("AdditionalInfoNeed")->item(0) != NULL);
  249 +
  250 + //---------------------------------------------------------
  251 + $newVIdir = BASEDIR.$dataBaseID."/".strtoupper($VIID)."/";
  252 +// New Data Set - add to DDsys.xml
  253 + $base = $xp->query("/DD_BASE")->item(0);
  254 + $newVI= $DDsys->createElement("VI");
  255 + $newName = $DDsys->createElement("NAME",$VIID);
  256 + $newattrBase = new DomAttr('base', $dataBaseID);
  257 + $newattrMission = new DomAttr('mission', $mission);
  258 + $newattrIns = new DomAttr('instrument', $instrument);
  259 + $newName->appendChild($newattrBase);
  260 + $newName->appendChild($newattrMission);
  261 + $newName->appendChild($newattrIns);
  262 + $newVI->appendChild($newName);
  263 + $newVI->appendChild($DDsys->createElement("LOCATION", $newVIdir));
  264 + $newVI->appendChild($DDsys->createElement("TIMES", $VIID."_times.nc"));
  265 + $newVI->appendChild($DDsys->createElement("INFO", $VIID."_info.nc"));
  266 + $newVI->appendChild($DDsys->createElement("CACHE", $VIID."_cash.nc"));
  267 + $base->appendChild($newVI);
  268 +
  269 + $DDsys->save($DDsysRefer);
  270 +// xml to refer.nc
  271 + exec(DDBASEBIN.'/makeDDsys');
  272 +
  273 +// Now make new dir .....
  274 + if (!is_dir(BASEDIR.$dataBaseID)) mkdir(BASEDIR.$dataBaseID."/", 0755, true);
  275 + if (!is_dir($newVIdir)) mkdir($newVIdir, 0755, true);
  276 + copy (DDLIB."Cash.template", $newVIdir."/".$VIID."_cash.nc");
  277 + $SED = "sed 's/NAME/".$nc_prefix."/g' ".DDLIB."Clean.template | sed 's/CACHE/".$VIID."/g' > ".$newVIdir."/clean";
  278 + exec($SED);
  279 + exec('chmod ugo+x '.$newVIdir.'/clean');
  280 +// Now info.nc from metadonnees
  281 + $err = getInfoFromAmda($dataBaseID, $remSetID);
  282 + if ($err) exec(DDBASEBIN.'/info2nc '.$newVIdir.'/'.$VIID.'_info.nc');
  283 +// Create empty times file
  284 + chdir($newVIdir);
  285 + exec(DDBASEBIN.'/TimesUpdate -r '.$VIID.'_times.nc '.$VIID.'_[0-9]*.nc');
  286 +
  287 + if ($AddInfo) {
  288 + $function_name = "createHeader".$dataBaseID;
  289 + require_once(DDLIB.$function_name.".php");
  290 + $function_name($remSetID);
  291 + }
  292 + if (verbose) error_log("Added ".$VIID.PHP_EOL, 3, log);
  293 + }
  294 + else {
  295 + error_log("Error: ".$VIID." not added: no XML DDServer info file ".PHP_EOL, 3, err);
  296 + }
  297 + }
  298 +?>
0 299 \ No newline at end of file
... ...
src/CALLEXT/ddserver_ini.php 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,23 @@
  1 +<?
  2 +/**
  3 +* @file ddserver_ini.php
  4 +* @brief All DD Server External Data initialisations
  5 +*/
  6 +
  7 + define("DDBASEBIN", getenv("DDBASEBIN"));
  8 + define("DDBASE", getenv("DDBASE"));
  9 + define("DDLIB", getenv("DDLIB"));
  10 + $old_include_path = set_include_path("./:".DDLIB);
  11 + /*
  12 + * Open STDERR stream
  13 + */
  14 + $STDERR = fopen("php://stderr","w");
  15 +
  16 +
  17 + if (!function_exists('__autoload')) {
  18 + function __autoload($class_name) {
  19 + require_once $class_name . '.php';
  20 + }
  21 + }
  22 +
  23 +?>
... ...
src/CALLEXT/ftpWrapper.php 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,24 @@
  1 +<?php
  2 +/** \file ftpWrapper.php
  3 +* \brief FTP Wrapper for FTP Servers passive
  4 +*
  5 +?
  6 +/*Wrapper to FTP - standard wrapper doesn't work in our case - we need passive mode */
  7 +function ftpWrapper($ftp_server, $ftp_user_name, $ftp_user_pass, $server_file, $local_file) {
  8 +
  9 + try
  10 + {
  11 + $conn_id = ftp_connect($ftp_server);
  12 + $login_result = ftp_login($conn_id, $ftp_user_name, $ftp_user_pass);
  13 + ftp_pasv($conn_id, true);
  14 + $ftp_get = ftp_get($conn_id, $local_file, $server_file, FTP_BINARY);
  15 + ftp_close($conn_id);
  16 + }
  17 + catch (Exception $e)
  18 + {
  19 + return false;
  20 + }
  21 +
  22 +
  23 + return $ftp_get;
  24 +}
... ...
src/CALLEXT/getDataCDAWEB.php 0 → 100755
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,103 @@
  1 +<?php
  2 +/**
  3 +* @file getDataCDAWEB.php
  4 +* @version $Id: getDataCDAWEB.php,v 1.5 2009/08/26 09:32:40 budnik Exp $
  5 +* @brief DD_Server tools <br> Gets Data from CDAWEB
  6 +*
  7 +* Args: remDataSetID ddVIdir StartTime StopTime \n
  8 +* Env Vars: $DDBASE $DDBASEBIN \n
  9 +* Executables: cdf2nc(DECODERS) TimesUpdate clean
  10 +*
  11 +*
  12 +* @todo General getData.php(dataBaseID)
  13 +*/
  14 +
  15 +/*----------------------------------------------------------------------
  16 + * DD SERVER TOOLS
  17 + * data update collection
  18 + * getDataCDAWEB.php
  19 + * php getDataCDAWEB.php <remDataSetID> <ddVIdir> <StartTime> <StopTime>
  20 + * 17 June 2007 V.1.0
  21 + * 02 Aug 2007 V.1.1
  22 + * 06 Aug 2007 V.1.2, cd to Data directory
  23 + * 23 Aug 2007 V.1.3, Another program for VI times update
  24 + * 23 Aug 2007 V.1.4, ZIP files before updating
  25 + * 23 Nov 2007 V.1.5 Copy LOCK file
  26 + * 21 jan 2008 V.1.6 Process all SOAP exceptions
  27 + * cut file names longer than 32
  28 + *-----------------------------------------------------------------------*/
  29 +
  30 +// Args
  31 + $id = $argv[1];
  32 + $ViDir = $argv[2];
  33 + $Start = $argv[3];
  34 + $Stop = $argv[4];
  35 +// Env variables
  36 + $DDBASEBIN = getenv("DDBASEBIN");
  37 + $DDBASE = getenv("DDBASE");
  38 + $MAX_NAME_LENGTH = 31;
  39 + $MAX_VI_NAME_LENGTH = 16;
  40 +
  41 + $wsdl = "http://cdaweb.gsfc.nasa.gov/WS/istp_public/jaxrpc?WSDL";
  42 +// Opent STDERR stream
  43 + $STDERR = fopen("php://stderr","w");
  44 +
  45 + try {
  46 + $client = new SoapClient($wsdl);
  47 + }
  48 + catch (SoapFault $exception) {
  49 +
  50 +fprintf($STDERR,"CDAWEB WSDL is unreachable \n");
  51 + exit(0);
  52 + }
  53 +
  54 +// Stamp -> this directory is being updated
  55 + $LockName = $ViDir."/LOCK";
  56 + touch($LockName);
  57 +
  58 +fprintf($STDERR,$ViDir." is LOCKED\n");
  59 +
  60 + system("cd ".$ViDir."; ./clean");
  61 +// If name is too long.
  62 + $nc_prefix = strlen($id) > $MAX_VI_NAME_LENGTH ? substr(strtolower($id),0,15): strtolower($id);
  63 +
  64 + try
  65 + {
  66 + $dataFileDesc = $client->__soapCall("getDataFiles", array($id, $Start, $Stop));
  67 +fprintf($STDERR, "FILES GOT ".count($dataFileDesc)."\n");
  68 + }
  69 + catch (SoapFault $exception)
  70 + {
  71 + unlink($LockName);
  72 + fprintf($STDERR, $exception."\n");
  73 + exit(0);
  74 + }
  75 + if (count($dataFileDesc) > 0)
  76 + {
  77 + for ($i = 0; $i < count($dataFileDesc); $i++) {
  78 + $file = $dataFileDesc[$i]->name;
  79 + $fileArr = split("/",$file);
  80 +// fprintf($STDERR, $fileArr[count($fileArr)-1]."\n");
  81 + if (copy($file, $fileArr[count($fileArr)-1])) {
  82 + system($DDBASEBIN."/cdf2nc ".$fileArr[count($fileArr)-1]);
  83 +fprintf($STDERR, "FILES TRANSLATED ".$i."\n");
  84 + $ncFile = str_replace(".cdf", ".nc", $fileArr[count($fileArr)-1]);
  85 + unlink($fileArr[count($fileArr)-1]);
  86 +
  87 + $ncFileTrue = ($strLength = strlen($ncFile)) > $MAX_NAME_LENGTH ?
  88 + $nc_prefix."_".time().$i.".nc" : $ncFile;
  89 +
  90 + rename($ncFile,$ViDir."/".$ncFileTrue);
  91 + system("cd ".$ViDir."; ".$DDBASEBIN."/TimesUpdate -u ".strtolower($id)."_times.nc ".$ncFileTrue);
  92 +fprintf($STDERR, "TIMES IS UPDATED ".$i."\n");
  93 + }
  94 + else fprintf($STDERR, $file." is not found\n");
  95 + }
  96 + }
  97 +
  98 + system("cd ".$ViDir."; ".$DDBASEBIN."/TimesUpdateNoData ".strtolower($id)."_times.nc ".$argv[3]." ".$argv[4]);
  99 + unlink($LockName);
  100 +fprintf($STDERR, "UNLOCK \n");
  101 +
  102 +
  103 +?>
... ...
src/CALLEXT/getDataCDPP.php 0 → 100755
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,119 @@
  1 +<?php
  2 +
  3 +/**
  4 +* @file getDataCDPP.php
  5 +* @version $Id: getDataCDPP.php,v 1.4 2009/08/26 09:32:56 budnik Exp $
  6 +* @brief DD_Server tools <br> Gets Data from CDPP
  7 +*
  8 +* Args: remDataSetID ddVIdir StartTime StopTime \n
  9 +* Env Vars: $DDBASE $DDBASEBIN \n
  10 +* Executables: TimesUpdate TimesUpdateNoData clean
  11 +*
  12 +*
  13 +* @todo General getData.php(dataBaseID)
  14 +*/
  15 +
  16 +/*----------------------------------------------------------------------
  17 + * DD SERVER TOOLS
  18 + * data update collection
  19 + * getDataCDPP.php
  20 + *-----------------------------------------------------------------------*/
  21 +
  22 +// Args
  23 + $id = $argv[1];
  24 + $ViDir = $argv[2];
  25 + $Start = $argv[3];
  26 + $Stop = $argv[4];
  27 +
  28 +
  29 +// Env variables
  30 + $DDBASEBIN = getenv("DDBASEBIN");
  31 + $DDBASE = getenv("DDBASE");
  32 + $MAX_NAME_LENGTH = 31;
  33 + $MAX_VI_NAME_LENGTH = 16;
  34 +
  35 + $wsdl = "http://cdpp2.cesr.fr:8080/AMDA/services/AMDAServer?WSDL";
  36 +// Opent STDERR stream
  37 + $STDERR = fopen("php://stderr","w");
  38 +
  39 + define("restrictions", $DDBASE."/../INFO/CDPP_restrictions.xml");
  40 +
  41 + try {
  42 + $client = new SoapClient($wsdl);
  43 + }
  44 + catch (SoapFault $exception) {
  45 +
  46 +fprintf($STDERR,"CDPP WSDL is unreachable \n");
  47 + exit(-1);
  48 + }
  49 +
  50 +// Stamp -> this directory is being updated
  51 + $LockName = $ViDir."/LOCK";
  52 + touch($LockName);
  53 +
  54 +fprintf($STDERR,$ViDir." is LOCKED\n");
  55 +
  56 + system("cd ".$ViDir."; ./clean");
  57 +// If name is too long....
  58 + $nc_prefix = strlen($id) > $MAX_VI_NAME_LENGTH ? substr(strtolower($id),0,15): strtolower($id);
  59 +
  60 +
  61 +// If restrictions exists...
  62 + $dataset->parameters = null;
  63 + if (file_exists(restrictions)) {
  64 + $restrictionsDom = new DomDocument('1.0');
  65 + $restrictionsDom -> load(restrictions);
  66 +
  67 + $dataSetRestrictions = $restrictionsDom->getElementById($id);
  68 +
  69 + if ($dataSetRestrictions != null) {
  70 + $parametres = $dataSetRestrictions->getElementsByTagName("PARAMETER_ID");
  71 + foreach ($parametres as $parameter) {
  72 + $param_id = phpversion() >= "5.2.0" ? $parameter->getAttribute("xml:id") : $parameter->getAttribute("id");
  73 + $dataset->parameters .= strtoupper($param_id)." ";
  74 + }
  75 + }
  76 + }
  77 + $dataset->datasetID = $id;
  78 + $dataset->timeStart = $Start;
  79 + $dataset->timeStop = $Stop;
  80 + try
  81 + {
  82 + $result = $client->__soapCall("getNcdfUrls", array($dataset));
  83 + }
  84 + catch (SoapFault $exception)
  85 + {
  86 + unlink($LockName);
  87 + fprintf($STDERR, "EXCEPTION".$exception->faultstring."\n");
  88 + exit(-1);
  89 + }
  90 +
  91 + $files = $result->getNcdfUrlsReturn;
  92 +fprintf($STDERR, "FILES GOT ".count($files)."\n");
  93 +
  94 + if (count($files) > 0)
  95 + {
  96 + for ($i = 0; $i < count($files); $i++) {
  97 + $file = count($files) == 1 ? $files : $files[$i];
  98 + $fileArr = split("/",$file);
  99 + $ncFile = $fileArr[count($fileArr)-1];
  100 + $ncFileTrue = ($strLength = strlen($ncFile)) > $MAX_NAME_LENGTH ?
  101 + $nc_prefix."_".time().$i.".nc" : $ncFile;
  102 +
  103 +
  104 + if (copy($file,$ViDir."/".$ncFileTrue)) {
  105 +
  106 + if (strpos($ViDir, "CP_CIS_CODIF_HS_H1_MOMENTS") !== false) system("nc2nc ".$ViDir."/".$ncFileTrue);
  107 +
  108 + system("cd ".$ViDir."; ".$DDBASEBIN."/TimesUpdate -u ".strtolower($id)."_times.nc ".$ncFileTrue);
  109 +fprintf($STDERR, "TIMES IS UPDATED ".$i."\n");
  110 + }
  111 + else fprintf($STDERR, $file." is not found\n");
  112 + }
  113 + }
  114 +
  115 + system("cd ".$ViDir."; ".$DDBASEBIN."/TimesUpdateNoData ".strtolower($id)."_times.nc ".$argv[3]." ".$argv[4]);
  116 + unlink($LockName);
  117 +fprintf($STDERR, "UNLOCK \n");
  118 +
  119 +?>
... ...
src/CALLEXT/getDataMAPSKP.php 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,95 @@
  1 +<?php
  2 +/**
  3 +* @file getDataMAPSKP.php
  4 +* @version $Id: getDataMAPSKP.php,v 1.6 2009/08/26 09:32:56 budnik Exp $
  5 +* @brief DD_Server tools <br> Gets Data from MAPSKP
  6 +*
  7 +* Args: remDataSetID ddVIdir StartTime StopTime \n
  8 +* Env Vars: $DDBASE $DDBASEBIN \n
  9 +* Executables: ascii2nc(DECODERS) TimesUpdate TimesUpdateNoData clean
  10 +*
  11 +*
  12 +* @todo General getData.php(dataBaseID)
  13 +*/
  14 + function name2DD($fileName) {
  15 + $pairs = array(".tab" => ".nc","__" => "_");
  16 + return strtr(strtolower($fileName),$pairs) ;
  17 +}
  18 +// Args
  19 + $id = $argv[1];
  20 + $ViDir = $argv[2];
  21 + $Start = $argv[3];
  22 + $Stop = $argv[4];
  23 +
  24 +// Env variables
  25 + $DDBASEBIN = getenv("DDBASEBIN");
  26 + $DDBASE = getenv("DDBASE");
  27 + $MAX_NAME_LENGTH = 31;
  28 + $MAX_VI_NAME_LENGTH = 16;
  29 +
  30 +// MAPSKP STUFF
  31 + $passwd = "//amda:dd;mapskp@";
  32 + $url = "http://planetoweb.cesr.fr/mapskp-amda/MapskpService.php?";
  33 +
  34 + $args = array('service'=>'getDataUrl',
  35 + 'datasetId'=> $id,
  36 + 'dateBegin'=> strtr($Start,".000Z","Z"),
  37 + 'dateEnd'=> strtr($Stop,".000Z","Z"));
  38 +
  39 +// Open STDERR stream
  40 + $STDERR = fopen("php://stderr","w");
  41 +
  42 +// Lock VI directory for Updating
  43 +// Stamp -> this directory is being updated
  44 + $LockName = $ViDir."/LOCK";
  45 + touch($LockName);
  46 +
  47 +fprintf($STDERR,$ViDir." is LOCKED\n");
  48 +
  49 +// Send - Receive query
  50 + $url .= http_build_query($args);
  51 + $fileList = new DOMDocument();
  52 + $fileList->load($url);
  53 +
  54 + $Files = $fileList->getElementsByTagName("url");
  55 +
  56 + fprintf($STDERR, "FILES RETURN ". $Files->length."\n");
  57 +
  58 +// Clean VI directory
  59 + system("cd ".$ViDir."; ./clean");
  60 +// If name is too long....
  61 + $nc_prefix = strlen($id) > $MAX_VI_NAME_LENGTH ? substr(strtolower($id),0,15): strtolower($id);
  62 +
  63 + if ($Files->length > 0) {
  64 + for ($i = 0; $i < $Files->length; $i++) {
  65 +
  66 + copy($ViDir."/header.nc","temp.nc");
  67 + $fileName_ = explode("//",$Files->item($i)->nodeValue);
  68 + $fileName = $fileName_[0].$passwd.$fileName_[1];
  69 + $fileArr = split("/",$fileName);
  70 +// Copy URL file to DD_Server dir
  71 + $ok = copy($fileName, $fileArr[count($fileArr)-1]);
  72 + if ($ok) {
  73 +// Convert ascii TAB to nc using header.nc
  74 + system($DDBASEBIN."/ascii2nc ".$fileArr[count($fileArr)-1]);
  75 + fprintf($STDERR, "FILE $i TRANSLATED \n");
  76 + unlink($fileArr[count($fileArr)-1]);
  77 + $ncFile = name2DD($fileArr[count($fileArr)-1]);
  78 +// Truncate file if it is too long
  79 + $ncFileTrue = ($strLength = strlen($ncFile)) > $MAX_NAME_LENGTH ?
  80 + $nc_prefix."_".time().$i.".nc" : $ncFile;
  81 +// Move nc file to VIdir
  82 + rename("temp.nc", $ViDir."/".$ncFileTrue);
  83 +
  84 +// Updates VI time info
  85 + system("cd ".$ViDir."; ".$DDBASEBIN."/TimesUpdate -u ".strtolower($id)."_times.nc ".$ncFileTrue);
  86 + }
  87 + }
  88 + fprintf($STDERR, "TIMES IS UPDATED \n");
  89 + }
  90 +
  91 + system("cd ".$ViDir."; ".$DDBASEBIN."/TimesUpdateNoData ".strtolower($id)."_times.nc ".$argv[3]." ".$argv[4]);
  92 +// Unlock VI dir
  93 + unlink($LockName);
  94 + fprintf($STDERR, "UNLOCK \n");
  95 +?>
... ...
src/CALLEXT/getDataSKR.php 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,80 @@
  1 +<?php
  2 +/**
  3 +* @file getDataSKR.php
  4 +* @brief DD_Server tools <br> Gets Data from SKR
  5 +*
  6 +* @arg remDataSetID ddVIdir StartTime StopTime
  7 +* @arg Env Vars: $DDBASE $DDBASEBIN \n
  8 +* @arg Executables: skr2nc(DECODERS) TimesUpdate TimesUpdateNoData clean
  9 +*
  10 +*
  11 +* @todo General getData.php(dataBaseID)
  12 +* @version $Id: $
  13 +* @date 20 june 2008
  14 +*/
  15 +
  16 +// Args
  17 + $id = $argv[1];
  18 + $ViDir = $argv[2];
  19 + $Start = $argv[3];
  20 + $Stop = $argv[4];
  21 +
  22 +// Env variables
  23 + $DDBASEBIN = getenv("DDBASEBIN");
  24 + $DDBASE = getenv("DDBASE");
  25 + $MAX_NAME_LENGTH = 31;
  26 +
  27 +// SKR STUFF
  28 +
  29 + $url = "http://rpwsTeam:KronoS04@www.lesia.obspm.fr/kronos/"
  30 +
  31 +// Open STDERR stream
  32 + $STDERR = fopen("php://stderr","w");
  33 +
  34 +// Lock VI directory for Updating
  35 +// Stamp -> this directory is being updated
  36 + $LockName = $ViDir."/LOCK";
  37 + touch($LockName);
  38 +
  39 +fprintf($STDERR,$ViDir." is LOCKED\n");
  40 +// Send - Receive query
  41 + $url .= http_build_query($args);
  42 + $fileList = new DOMDocument();
  43 + $fileList->load($url);
  44 + $Files = $fileList->getElementsByTagName("url");
  45 +
  46 + fprintf($STDERR, "FILES RETURN ". $Files->length."\n");
  47 +
  48 +// Clean VI directory
  49 + system("cd ".$ViDir."; clean");
  50 + if ($Files->length > 0) {
  51 + for ($i = 0; $i < $Files->length; $i++) {
  52 +
  53 + copy($ViDir."/header.nc","temp.nc");
  54 + $fileName_ = explode("//",$Files->item($i)->nodeValue);
  55 + $fileName = $fileName_[0].$passwd.$fileName_[1];
  56 + $fileArr = split("/",$fileName);
  57 +// Copy URL file to DD_Server dir
  58 + copy($fileName, $fileArr[count($fileArr)-1]);
  59 +// Convert ascii TAB to nc using header.nc
  60 + system($DDBASEBIN."/ascii2nc ".$fileArr[count($fileArr)-1]);
  61 + fprintf($STDERR, "FILE $i TRANSLATED \n");
  62 + unlink($fileArr[count($fileArr)-1]);
  63 + $ncFile = name2DD($fileArr[count($fileArr)-1]);
  64 +// Truncate file if it is too long
  65 + $ncFileTrue = ($strLength = strlen($ncFile)) > $MAX_NAME_LENGTH ?
  66 + "t".substr(substr($ncFile, 0, $strLength-3), $strLength-$MAX_NAME_LENGTH+1, $MAX_NAME_LENGTH-4).".nc" : $ncFile;
  67 +// Move nc file to VIdir
  68 + rename("temp.nc", $ViDir."/".$ncFileTrue);
  69 +
  70 +// Updates VI time info
  71 + system("cd ".$ViDir."; ".$DDBASEBIN."/TimesUpdate -u ".strtolower($id)."_times.nc ".$ncFileTrue);
  72 + }
  73 + fprintf($STDERR, "TIMES IS UPDATED \n");
  74 + }
  75 +
  76 + system("cd ".$ViDir."; ".$DDBASEBIN."/TimesUpdateNoData ".strtolower($id)."_times.nc ".$argv[3]." ".$argv[4]);
  77 +// Unlock VI dir
  78 + unlink($LockName);
  79 + fprintf($STDERR, "UNLOCK \n");
  80 +?>
... ...
src/CALLEXT/getDataTHEMIS.php 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,152 @@
  1 +<?php
  2 +/**
  3 +* @file getDataTHEMIS.php
  4 +* @version $Id: getDataTHEMIS.php,v 1.7 2010/01/11 18:16:46 budnik Exp $
  5 +* @brief DD_Server tools <br> Gets Data from /THEMIS_B1 (NFS)
  6 +*
  7 +* @arg remDataSetID ddVIdir StartTime StopTime \n
  8 +* Env Vars: $DDBASE $DDBASEBIN \n
  9 +* Executables: [DataSet]2nc(DECODERS) TimesUpdate TimesUpdateNoData clean
  10 +*
  11 +*
  12 +* @todo General getData.php(dataBaseID)
  13 +*/
  14 +
  15 +
  16 +
  17 +// Open STDERR stream
  18 + $STDERR = fopen("php://stderr","w");
  19 +
  20 +// Args
  21 + $id = $argv[1];
  22 +
  23 + $ViDir = $argv[2];
  24 + $Start = $argv[3];
  25 + $Stop = $argv[4];
  26 +// NFS direcory
  27 + define('ThemisDir', '/THEMIS_B1/themisdata/');
  28 + define('DataSetDir', ThemisDir.strtr($id,"_","/"));
  29 +// Env variables
  30 + define('DDBASEBIN', getenv("DDBASEBIN"));
  31 + define('DDBASE', getenv("DDBASE"));
  32 +
  33 +
  34 +
  35 + $arr = explode("/", $ViDir);
  36 + $instrument = $arr[5];
  37 + $mission = $arr[4];
  38 + $mode = strpos($arr[6],"_") === false ? $arr[6] : substr($arr[6],0,4);
  39 +
  40 +
  41 + switch ($mode) {
  42 + case "psif" :
  43 + case "psef" :
  44 + case "peif" :
  45 + case "peef" :
  46 + case "peim" :
  47 + case "peem" :
  48 + case "h" :
  49 + case "l" :
  50 + $realDir = DDBASE."/".$mission."/".$instrument."/".$arr[6]."/";
  51 + system("cd $realDir ; ./clean");
  52 + touch($realDir."/LOCK");
  53 +fprintf($STDERR,$realDir." is LOCKED\n");
  54 + break;
  55 + case "peir" :
  56 + case "peer" :
  57 + case "peib" :
  58 + case "peeb" :
  59 + $dirAdd = array("/sp", "/mom");
  60 + $fileAdd = array("s", "");
  61 + $realDir = DDBASE."/".$mission."/".$instrument."/".$mode."/";
  62 + for ($n = 0; $n < 2; $n++) {
  63 + $theDir = $realDir.$dirAdd[$n];
  64 + system("cd $theDir ; ./clean ");
  65 + touch($theDir."/LOCK");
  66 +fprintf($STDERR,$theDir." is LOCKED\n");
  67 + }
  68 + break;
  69 + }
  70 +
  71 +
  72 + switch ($mode) {
  73 + case "peif" :
  74 + case "peef" :
  75 + $program = DDBASEBIN."/themis_esafull2nc ";
  76 + break;
  77 + case "peim" :
  78 + case "peem" :
  79 + $program = DDBASEBIN."/themis_esamom2nc ";
  80 + break;
  81 + case "peir" :
  82 + case "peer" :
  83 + case "peib" :
  84 + case "peeb" :
  85 + $program = DDBASEBIN."/themis_esa2nc ";
  86 + break;
  87 + case "psif" :
  88 + case "psef" :
  89 + $program = DDBASEBIN."/themis_sst2nc ";
  90 + break;
  91 + case "h" :
  92 + case "l" :
  93 + $program = DDBASEBIN."/themis_fgm2nc ";
  94 + break;
  95 + }
  96 +// fprintf($STDERR, "REALDIR ".$realDir." \n");
  97 +
  98 +// Which files
  99 + $currTime = strtotime($Start);
  100 + $stopTime = strtotime($Stop);
  101 +
  102 + $currTime -= 3600.0;
  103 +
  104 + while ($currTime <= $stopTime) {
  105 + $fileName = DataSetDir."/".date('Y', $currTime)."/".$id."_".date('Ymd', $currTime)."_v01.cdf";
  106 +
  107 + if (file_exists($fileName)) {
  108 + system($program." ".$fileName." ".$mission." ".$mode);
  109 + fprintf($STDERR, "FILE $fileName is TRANSLATED \n");
  110 +
  111 + }
  112 + else {
  113 + fprintf($STDERR,"NO SUCH FILE $fileName \n");
  114 + }
  115 + $currTime += 24*60*60;
  116 + }
  117 +
  118 +
  119 + switch ($mode) {
  120 + case "psif" :
  121 + case "psef" :
  122 + case "peif" :
  123 + case "peef" :
  124 + case "peim" :
  125 + case "peem" :
  126 + system("mv ".$mode."[0-9]*.nc $realDir");
  127 + system("cd $realDir ;".DDBASEBIN."/TimesUpdate -u ".$mode."_times.nc ".$mode."[0-9]*.nc; ".DDBASEBIN."/TimesUpdateNoData ".$mode."_times.nc ".$argv[3]." ".$argv[4]);
  128 + unlink($realDir."/LOCK");
  129 + break;
  130 + case "peir" :
  131 + case "peer" :
  132 + case "peib" :
  133 + case "peeb" :
  134 + for ($n = 0; $n < 2; $n++) {
  135 + $theDir = $realDir.$dirAdd[$n];
  136 + system("mv ".$fileAdd[$n].$mode."[0-9]*.nc $theDir");
  137 + system("cd $theDir ;".DDBASEBIN."/TimesUpdate -u ".$mode."_times.nc ".$fileAdd[$n].$mode."[0-9]*.nc; ".DDBASEBIN."/TimesUpdateNoData ".$mode."_times.nc ".$argv[3]." ".$argv[4]);
  138 + unlink($theDir."/LOCK");
  139 + }
  140 + break;
  141 + case "h" :
  142 + case "l" :
  143 + system("mv fgm".$mode."[0-9]*.nc $realDir");
  144 + system("cd $realDir ;".DDBASEBIN."/TimesUpdate -u fgm".$mode."_times.nc fgm".$mode."[0-9]*.nc; ".DDBASEBIN."/TimesUpdateNoData fgm".$mode."_times.nc ".$argv[3]." ".$argv[4]);
  145 + unlink($realDir."/LOCK");
  146 + break;
  147 + }
  148 +
  149 + fprintf($STDERR, "TIMES IS UPDATED \n");
  150 +
  151 + fprintf($STDERR, "UNLOCK \n");
  152 +?>
... ...
src/CALLEXT/getDataVEXGRAZ.php 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,90 @@
  1 +<?php
  2 +
  3 +/**
  4 +* @file getDataVEXGRAZ.php
  5 +* @version $Id: getDataVEXGRAZ.php,v 1.4 2009/08/26 09:32:56 budnik Exp $
  6 +* @brief DD_Server tools <br> Gets Data from VEXGRAZ
  7 +*
  8 +* @arg remDataSetID ddVIdir StartTime StopTime
  9 +* Env Vars: $DDBASE $DDBASEBIN \n
  10 +* Executables: ascii2nc(DECODERS) TimesUpdate TimesUpdateNoData clean
  11 +*
  12 +*/
  13 +
  14 + require_once 'ddserver_ini.php';
  15 + require_once 'vexgraz_ini.php';
  16 +
  17 + function name2DD($fileName) {
  18 +
  19 + $ncName = prefix.substr($fileName,3,11).".nc";
  20 +
  21 + return $ncName;
  22 +}
  23 +
  24 +/*
  25 +* Args
  26 +*/
  27 +
  28 + $id = $argv[1];
  29 + $ViDir = $argv[2];
  30 + $Start = $argv[3];
  31 + $Stop = $argv[4];
  32 +
  33 +/*
  34 +* Lock VI directory for Updating
  35 +* Stamp -> this directory is being updated
  36 +*/
  37 + $LockName = $ViDir."/LOCK";
  38 + touch($LockName);
  39 + fprintf(STDERR,$ViDir." is LOCKED \n");
  40 +
  41 +
  42 +/*
  43 +* Clean VI directory
  44 +*/
  45 + system("cd ".$ViDir."; ./clean");
  46 +
  47 +/*
  48 +* SPASE Web Service getDatasetUrl()
  49 +*/
  50 + $mySpaseDataAccess = new DataAccessSpase();
  51 +
  52 + $urlArray = $mySpaseDataAccess->getDatasetUrl($id, $Start, $Stop);
  53 +
  54 + if ($urlArray !== "NODATA")
  55 + foreach ($urlArray as $theUrl) {
  56 +
  57 + copy($ViDir."/header.nc","temp.nc");
  58 + $fileArr = split("/",$theUrl);
  59 + $fileName = $fileArr[count($fileArr)-1];
  60 +/*
  61 +* Copy URL file to DD_Server dir and
  62 +* Convert ascii TAB to nc using header.nc
  63 +*/
  64 + copy($theUrl, $fileName);
  65 + system(DDBASEBIN."/ascii2nc ".$fileName." 1");
  66 + fprintf(STDERR, "FILE $theUrl TRANSLATED \n");
  67 + unlink($fileName);
  68 + $ncFile = name2DD($fileName);
  69 +/*
  70 +* Move new nc file to VIdir
  71 +*/
  72 + rename("temp.nc", $ViDir."/".$ncFile);
  73 +
  74 +/*
  75 +* Updates VI time info
  76 +*/
  77 + system("cd ".$ViDir."; ".DDBASEBIN."/TimesUpdate -u ".prefix."_times.nc ".$ncFile);
  78 +
  79 + fprintf(STDERR, "TIMES IS UPDATED \n");
  80 + }
  81 +/*
  82 +* Fill NODATA times in VI time info
  83 +*/
  84 + system("cd ".$ViDir."; ".DDBASEBIN."/TimesUpdateNoData ".prefix."_times.nc ".$argv[3]." ".$argv[4]);
  85 +/*
  86 +* Unlock VI dir
  87 +*/
  88 + unlink($LockName);
  89 + fprintf(STDERR, "UNLOCK \n");
  90 +?>
... ...
src/CALLEXT/makeRPWS_KEYinfo.php 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,65 @@
  1 +<?php
  2 +/* $Id: makeRPWS_KEYinfo.php,v 1.1 2008/03/05 14:04:22 elena Exp $ */
  3 +/**
  4 +* \file makeRPWS_KEYinfo.php
  5 +* \brief Function to create energy info.nc for RPWS
  6 +*
  7 +*/
  8 +
  9 + function makeRPWS_KEYinfo($StartTime) {
  10 +
  11 + $OK = false;
  12 + $E_PARAM = "ELECTRIC_SPECTRAL_DENSITIES";
  13 + $M_PARAM = "MAGNETIC_SPECTRAL_DENSITIES";
  14 + $OK = true;
  15 + $url = "http://planetoweb.cesr.fr/mapskp-amda/MapskpService.php?";
  16 + $passwd = "//amda:dd;mapskp@";
  17 +
  18 + $Stop = date("Y-m-d", strtotime("+10 days",strtotime($StartTime)));
  19 +
  20 + $args = array('service'=>'getDataUrl',
  21 + 'datasetId'=> "RPWS_KEY",
  22 + 'dateBegin'=> $StartTime."Z",
  23 + 'dateEnd'=> $Stop."T00:00:00Z");
  24 +
  25 +
  26 + $url .= http_build_query($args);
  27 + $fileList = new DOMDocument();
  28 + $fileList->load($url);
  29 + $Files = $fileList->getElementsByTagName("url");
  30 +
  31 + if ($Files->length > 0) {
  32 +
  33 + $fileName_ = explode("//",$Files->item(0)->nodeValue);
  34 + $fileName = $fileName_[0].$passwd.$fileName_[1];
  35 + $fileArr = split("/",$fileName);
  36 +// Copy URL file VI dir
  37 + copy($fileName, $fileArr[count($fileArr)-1]);
  38 + $file = fopen($fileArr[count($fileArr)-1], "r");
  39 + $buffer = fgets($file);
  40 + $arrFreq = explode(" ", $buffer);
  41 + $Frequency_E = implode(",",array_slice($arrFreq,2,73));
  42 +
  43 + $Frequency_M = implode(",",array_slice($arrFreq,75,42));
  44 +
  45 + fclose($file);
  46 + unlink($fileArr[count($fileArr)-1]);
  47 +
  48 +// Create CDL ASCII file
  49 + $cdl = fopen("constant.cdl","w");
  50 + fwrite($cdl, "netcdf header { \n \n dimensions: \n");
  51 + fwrite($cdl," DIM_E = 73, DIM_M = 42; \n\n");
  52 +
  53 + fwrite($cdl, "variables: \n");
  54 + fwrite($cdl, " float ".$E_PARAM."(DIM_E), ".$M_PARAM."(DIM_M); \n\n");
  55 + fwrite($cdl, ":units = \"Hz\"; \n");
  56 + fwrite($cdl, "data: \n".$E_PARAM." = ".trim($Frequency_E).";\n".$M_PARAM." = ".trim($Frequency_M).";\n }");
  57 + fclose($cdl);
  58 +// transform to nc
  59 + system("/usr/bin/ncgen -o rpws_key_constant.nc constant.cdl");
  60 + $OK = true;
  61 + }
  62 +
  63 + return $OK;
  64 + }
  65 +?>
... ...
src/CALLEXT/mapskp_cfg.php 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,5 @@
  1 +<?php
  2 +
  3 + define("url","http://planetoweb2.cesr.fr/mapskp-amda/MapskpService.php?");
  4 + define("passwd","ftp://amda:dd;mapskp@");
  5 +?>
... ...
src/DECODERS/ascii2nc/CMakeLists.txt 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,24 @@
  1 +
  2 +PROJECT(ascii2nc)
  3 +
  4 +include_directories(
  5 + ${CMAKE_HOME_DIRECTORY}/src/INCLUDE/
  6 + ${NETCDFINCLUDE_DIR}
  7 +)
  8 +
  9 +#Configuration de l'exécutable
  10 +file(
  11 + GLOB_RECURSE
  12 + source_files
  13 + ./*
  14 +)
  15 +
  16 +ADD_EXECUTABLE (ascii2nc ${source_files} )
  17 +
  18 +target_link_libraries(
  19 + ascii2nc
  20 + DD_Client
  21 + ${NETCDFLIBRARY}
  22 +)
  23 +
  24 +install (TARGETS ascii2nc DESTINATION bin)
... ...
src/DECODERS/ascii2nc/ascii2nc.c 0 → 100755
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,249 @@
  1 +
  2 +/** @file ascii2nc.c
  3 +* @brief Stand alone executable to tranform ASCII to DD netCDF
  4 +* @version $Id: ascii2nc.c,v 1.8 2011/09/05 11:26:55 budnik Exp $
  5 +* @arg FileName, [any symbol]
  6 +* 2 args => DOY2DDTime; 3 args => MonthDay2DDTime
  7 +*/
  8 +
  9 +
  10 +#include <stdio.h>
  11 +#include <stdlib.h>
  12 +#include <netcdf.h>
  13 +#include <string.h>
  14 +#include <ctype.h>
  15 +#include <time.h>
  16 +#include <math.h>
  17 +#include <DD.h>
  18 +
  19 +#define MAX_FILE_NAME_LEN 120 /* Max. file name length */
  20 +#define MAXLEN 4096
  21 +
  22 +/*************************************
  23 + Global variables and structures
  24 +**************************************/
  25 +int ncid; /*netCDF file ID*/
  26 +
  27 +char Time[TIMELENGTH];
  28 +char *StartT; // Start time
  29 +char *StopT; // Stop time
  30 +
  31 +size_t TimeCount[2] = {1L, TIMELENGTH};
  32 +size_t Start[2] = {0L, 0L};
  33 +size_t buffCount[2];
  34 +
  35 +/**************************
  36 + Function prototypes
  37 +**************************/
  38 +
  39 +void handle_netcdf_error (int);
  40 +void mapskp2DD(char *buffer, char *Time);
  41 +void monthday2DD(char *buffer, char *Time);
  42 +
  43 +/****************************************************************************
  44 +
  45 +*****************************************************************************/
  46 +int main(int argc, char *argv[])
  47 +{
  48 + FILE *inFile;
  49 + int status, /* netCDF status code */
  50 + dummy, i, j, n;
  51 + int ndims, nvars, ngatts, unlimitdimid;
  52 + int var_ndims, var_dims[NC_MAX_DIMS], var_natts;
  53 + nc_type var_type, t_type;
  54 + char var_name[NC_MAX_NAME+1];
  55 + size_t dimsize, t_length;
  56 + int First = 1;
  57 +
  58 + char fileName[MAX_FILE_NAME_LEN];
  59 + char *buffer, *tempBuff;
  60 +
  61 + float buffFloat[NC_MAX_DIMS][NC_MAX_DIMS], attFloat;
  62 + double buffDouble[NC_MAX_DIMS][NC_MAX_DIMS], attDouble;
  63 + int buffInt[NC_MAX_DIMS][NC_MAX_DIMS], attInt;
  64 + size_t buffSize[NC_MAX_DIMS];
  65 +
  66 + nc_type buffType[NC_MAX_DIMS];
  67 +
  68 + double deltaT, ddTime;
  69 +
  70 + buffer = (char *)malloc(MAXLEN*sizeof(char));
  71 + tempBuff = buffer;
  72 +
  73 + buffCount[0] = 1L;
  74 +
  75 + if (argc <= 1) {
  76 + printf ("** inputFile file is not specified **\n"); /* input file name not specified */
  77 + exit (1);
  78 + }
  79 + else {
  80 + strcpy(fileName, argv[1]); /* Get the input file name */
  81 + }
  82 +
  83 + /***********************************************/
  84 + /* Open Input File */
  85 + /***********************************************/
  86 + if ((inFile = fopen(fileName, "r")) == NULL) {
  87 + printf ("** Cannot open inputFile file: %s **\n", fileName);
  88 + exit (1);
  89 + }
  90 +
  91 +
  92 + status = nc_open("temp.nc", NC_WRITE, &ncid);
  93 + if (status != NC_NOERR) {
  94 + handle_netcdf_error(status);
  95 + exit (1);
  96 + }
  97 +
  98 +
  99 +// Now inquire
  100 +
  101 + status = nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimitdimid);
  102 +
  103 + // printf (" ndims %d, nvars %d, ngatts %d, unlimitdimid %d\n",ndims, nvars, ngatts, unlimitdimid);
  104 +
  105 +
  106 + for (i = 0; i < nvars; i++) {
  107 +
  108 + status = nc_inq_var(ncid, i, var_name, &var_type, &var_ndims, var_dims, &var_natts);
  109 + if (status != NC_NOERR) handle_netcdf_error(status);
  110 + // printf ("\n varname %s, var_type %d, var_ndims %d, var_natts %d ",
  111 + // var_name, var_type, var_ndims, var_natts);
  112 + if ( var_ndims == 1 ) buffSize[i] = 1;
  113 + else {
  114 + status = nc_inq_dimlen(ncid, var_dims[1], &dimsize);
  115 + buffSize[i] = dimsize;
  116 + }
  117 + buffType[i] = var_type;
  118 + }
  119 +
  120 + status = nc_inq_att(ncid, NC_GLOBAL, "minSampling", &t_type, &t_length);
  121 + if (status != NC_NOERR) deltaT = 0.0;
  122 + else
  123 + switch (t_type) {
  124 + case NC_FLOAT: status = nc_get_att_float(ncid, NC_GLOBAL, "minSampling", &attFloat);
  125 + deltaT = (double)(attFloat)/2.0 ;
  126 + break;
  127 + case NC_DOUBLE: status = nc_get_att_double(ncid, NC_GLOBAL, "minSampling", &attDouble);
  128 + deltaT = attDouble/2.0;
  129 + break;
  130 + case NC_INT: status = nc_get_att_int(ncid, NC_GLOBAL, "minSampling", &attInt);
  131 + deltaT = (double)attInt/2.0;
  132 + break;
  133 + default: status = nc_get_att_float(ncid, NC_GLOBAL, "minSampling", &attFloat);
  134 + deltaT = (double)(attFloat)/2.0 ;
  135 + }
  136 + // printf (" deltaT %lf\n", deltaT);
  137 + /***********************************************************************
  138 +
  139 + ***********************************************************************/
  140 +// Skip first line in RPWS_KEY....
  141 + if (strncmp(fileName,"RPWS_KEY",8) == 0) fgets(buffer, MAXLEN, inFile);
  142 +
  143 + while (!feof(inFile) && !ferror(inFile)) {
  144 +
  145 + fgets(buffer, MAXLEN, inFile);
  146 +
  147 + if (strlen(buffer) > 10 && !feof(inFile)) {
  148 +
  149 + if (argc > 2)
  150 + monthday2DD(buffer, Time);
  151 + else
  152 + mapskp2DD(buffer, Time);
  153 +
  154 + status = nc_put_vara_text(ncid, 0, Start, TimeCount, Time);
  155 +
  156 + if (First) {
  157 + // add +/- deltaT from attribute....
  158 + ddTime = DD_Time2Double(Time);
  159 + StartT = Double2DD_Time(ddTime - deltaT);
  160 + status = nc_put_vara_text(ncid, 1, &Start[1], &TimeCount[1], StartT);
  161 + }
  162 + First = 0;
  163 +
  164 +// Time variables are defined already
  165 + for (i = 3; i < nvars; i++) {
  166 + for (j = 0; j < buffSize[i]; j++) {
  167 + while (isspace(buffer[0])) buffer++;
  168 + buffer = strpbrk(buffer," ");
  169 +
  170 + switch (buffType[i]) {
  171 + case NC_FLOAT: sscanf(buffer, "%f", &buffFloat[i][j]); break;
  172 + case NC_DOUBLE: sscanf(buffer, "%lf", &buffDouble[i][j]); break;
  173 + case NC_INT: sscanf(buffer, "%d", &buffInt[i][j]); break;
  174 + default: sscanf(buffer, "%f", &buffFloat[i][j]);
  175 + }
  176 +
  177 + buffCount[1] = buffSize[i];
  178 +
  179 + switch (buffType[i]) {
  180 + case NC_FLOAT: status = nc_put_vara_float(ncid, i, Start, buffCount, &(buffFloat[i][0]));
  181 + break;
  182 + case NC_DOUBLE: status = nc_put_vara_double(ncid, i, Start, buffCount, &(buffDouble[i][0]));
  183 + break;
  184 + case NC_INT: status = nc_put_vara_int(ncid, i, Start, buffCount, &(buffInt[i][0]));
  185 + break;
  186 + default: status = nc_put_vara_float(ncid, i, Start, buffCount, &(buffFloat[i][0]));
  187 + }
  188 + }
  189 + }
  190 +
  191 + Start[0]++;
  192 +// return pointer to the beginning
  193 + buffer = tempBuff;
  194 + } // if ! "\n"
  195 + }
  196 + // add +/- deltaT from attribute....
  197 + ddTime = DD_Time2Double(Time);
  198 + StopT = Double2DD_Time(ddTime + deltaT - 1.0);
  199 + status = nc_put_vara_text(ncid, 2, &Start[1], &TimeCount[1], StopT);
  200 +
  201 + status = nc_close(ncid);
  202 + if (status != NC_NOERR) handle_netcdf_error(status);
  203 + fclose(inFile);
  204 +}
  205 +
  206 +
  207 +
  208 +/*--------------------------------------------------------------------------
  209 + * Handles a netCDF error.
  210 + *--------------------------------------------------------------------------*/
  211 +void handle_netcdf_error(int status) {
  212 + fprintf(stderr, "%s\n", nc_strerror(status));
  213 +}
  214 +/*--------------------------------------------------------------------------
  215 + * MAPSKP time to DD
  216 + *--------------------------------------------------------------------------*/
  217 + void mapskp2DD(char *buffer, char *Time) {
  218 + int err;
  219 + int YEAR, DAY, HOUR, MINUTE, SEC, MSK = 0;
  220 + err = sscanf(buffer, "%d-%dT%d:%d:%d.%d",
  221 + &YEAR, &DAY, &HOUR, &MINUTE, &SEC, &MSK);
  222 + if (err == 5) MSK = 0;
  223 + sprintf(Time,"%04d%03d%02d%02d%02d%03d\0", YEAR, DAY-1, HOUR, MINUTE, SEC, MSK);
  224 +}
  225 +/*--------------------------------------------------------------------------
  226 + * MONTH-DAY time to DD
  227 + *--------------------------------------------------------------------------*/
  228 + void monthday2DD(char *buffer, char *Time) {
  229 +
  230 + int days[12]={31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  231 +
  232 + int i, YEAR, MONTH, DAY, HOUR, MINUTE, SEC, MSK, DOY=0;
  233 +
  234 + sscanf(buffer, "%d-%d-%dT%d:%d:%d.%d",
  235 + &YEAR, &MONTH, &DAY, &HOUR, &MINUTE, &SEC, &MSK);
  236 +
  237 + // Leap year
  238 + // if ((YEAR % 4 == 0) && (YEAR % 100 != 0)) days[1] += 1;
  239 + if (YEAR % 4 == 0) days[1] += 1;
  240 + // if (YEAR % 400 == 0)
  241 + // if (YEAR == 2000) days[1] += 1;
  242 +
  243 + // Sum of days from Jan 1 to the input date
  244 + for (i = 0; i < MONTH - 1; i++) DOY += days[i];
  245 + DOY += DAY;
  246 +
  247 + sprintf(Time,"%04d%03d%02d%02d%02d%03d\0", YEAR, DOY-1, HOUR, MINUTE, SEC, MSK);
  248 +}
  249 +
... ...
src/DECODERS/cdf2nc/CMakeLists.txt 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,26 @@
  1 +
  2 +PROJECT(cdf2nc)
  3 +
  4 +include_directories(
  5 + ${CMAKE_HOME_DIRECTORY}/src/INCLUDE/
  6 + ${NETCDFINCLUDE_DIR}
  7 + ${libcdf_INCLUDE_DIR}
  8 +)
  9 +
  10 +#Configuration de l'exécutable
  11 +file(
  12 + GLOB_RECURSE
  13 + source_files
  14 + ./*
  15 +)
  16 +
  17 +ADD_EXECUTABLE (cdf2nc ${source_files} )
  18 +
  19 +target_link_libraries(
  20 + cdf2nc
  21 + DD_Client
  22 + ${NETCDFLIBRARY}
  23 + ${libcdf_LIBRARIES}
  24 +)
  25 +
  26 +install (TARGETS cdf2nc DESTINATION bin)
... ...
src/DECODERS/cdf2nc/cdf2nc.c 0 → 100755
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,1616 @@
  1 +/**
  2 +* @file cdf2nc.c
  3 +* @version $Id: cdf2nc.c,v 1.7 2014/06/25 10:32:50 budnik Exp $
  4 +* @brief DD Server Decoder
  5 +*/
  6 +
  7 +/*=====================================================================
  8 + * cdf2nc.c
  9 + * V.1.2
  10 + * CDF to NetCDF converter
  11 + * usage: cdf2nc <FILE NAME>.cdf
  12 + *
  13 + * Versions:
  14 + * Aug 4, 2007, V.1.0, Knizhnikova-Fedorova
  15 + * Aug 6, 2007, V.1.1, Fedorov, "Time" dimension
  16 + * Jan 16, 2008 V.1.2 Exclude "false" CDF dimension (1)
  17 + *=====================================================================*/
  18 +
  19 +#include <stdio.h>
  20 +#include <stdlib.h>
  21 +#include <netcdf.h>
  22 +#include <cdf.h>
  23 +#include <string.h>
  24 +#include <time.h>
  25 +#include <math.h>
  26 +#include <DD.h>
  27 +
  28 +#define MAX_FILE_NAME_LEN 120 /* Max. file name length */
  29 +#define MAX_ATTRS 3000 /* Max # of CDF attributes */
  30 +#define UNKNOWN_DT -99 /* Unsupported CDF datatype indicator */
  31 +
  32 +#define DEFAULT_MAPPING_FILE "cdf_to_netcdf_mapping.dat"
  33 +#define MAX_REC_LENGTH NC_MAX_NAME+CDF_ATTR_NAME_LEN+2
  34 + /* Max record length of DEFAULT_MAPPING_FILE */
  35 +
  36 +#define TRUE 1
  37 +#define FALSE 0
  38 +
  39 +#define TIMESHIFT 62167219200.0 /*01/01/1970 - 01/01/0000 Gregorian Calendar*/
  40 +#define UNLIMITDIM "Time" /* Name of unlimided dimension */
  41 +#define DD_TIME_STRING_LEN 17
  42 +
  43 +/*************************************
  44 + Global variables and structures
  45 +**************************************/
  46 +CDFid id; /* CDF file ID */
  47 +int ncid; /* netCDF file ID */
  48 +
  49 +short isTimeSet = 0;
  50 +
  51 +long nZvars, /* Number of zVariables in a CDF file */
  52 + nAttrs; /* Number of attributes (global & variable) in a CDF file */
  53 +
  54 +typedef struct ncdim { /* netCDF dimension structure */
  55 + char name[NC_MAX_NAME+1]; /* Dimension name */
  56 + int size; /* Dimension size */
  57 + int id; /* Dimension id */
  58 +} netcdfDimension;
  59 +
  60 +netcdfDimension ncDims[NC_MAX_DIMS]; /* max dimensions per netCDF file */
  61 +int totNCdims = 0; /* Total # of netCDF dimensions created */
  62 +
  63 +int StartTimeID, StopTimeID, TimeLengthID;
  64 +
  65 +char StartT[TIMELENGTH]; // Start time
  66 +char StopT[TIMELENGTH]; // Stop time
  67 +
  68 +dd_time_t StartTime, StopTime;
  69 +
  70 +typedef struct cdfvar { /* CDF variable structure */
  71 + char name[CDF_VAR_NAME_LEN+1];
  72 + long datatype;
  73 + long numElements; /* string length for CDF_CHAR, 1 otherwise */
  74 + long dimensionality; /* variable dimensionality */
  75 + long dimSizes[CDF_MAX_DIMS]; /* variable dimension sizes */
  76 + long recVariance; /* record variance */
  77 + long numRecs; /* # of records this variable contains */
  78 +} CDFvar;
  79 +
  80 +char SpecialSymbol[9] = {' ', '#', '%', '@', '+', '.', '>', '<', '/'};
  81 +
  82 +/****************************************************************************
  83 + * Arrays to hold the CDF-to-netCDF mapping information that are loaded
  84 + * from the default or user-define mapping file.
  85 + ****************************************************************************/
  86 +char netcdfAttrNames[MAX_ATTRS][NC_MAX_NAME];
  87 +char cdfAttrNames[MAX_ATTRS][CDF_ATTR_NAME_LEN+1];
  88 +char comments[MAX_ATTRS][CDF_ATTR_NAME_LEN+1];
  89 +
  90 +int totAttrsInMappingFile; /* # of attributes in the mapping file */
  91 +char mappingFile[MAX_FILE_NAME_LEN]; /* Mapping file name */
  92 +
  93 +int DEBUG = FALSE;
  94 +
  95 +
  96 +/**************************
  97 + Function prototypes
  98 +**************************/
  99 +int endsWith(char *, char *);
  100 +char * strlaststr(char *, char *);
  101 +void get_cdf_attribute(long, long, long, int);
  102 +void get_cdf_attr_data(char *, long, long, long, int);
  103 +char * cdf_str_datatype (long);
  104 +char * NC_datatype (nc_type);
  105 +nc_type get_netcdf_datatype (long);
  106 +void usage();
  107 +CDFid cdf_open(char *);
  108 +void read_cdf_file_info();
  109 +void get_zVariables();
  110 +void create_netcdf_dimensions (CDFvar, int *, int *);
  111 +int create_netcdf_variable (CDFvar, int, short *);
  112 +void get_cdf_variable_data (long, CDFvar);
  113 +void read_cdf_variable_data (long, long, long, long, long [], void *);
  114 +void removeFilepath();
  115 +void handle_netcdf_error (int);
  116 +void memory_error(char *, char *);
  117 +void cdf_status_handler (CDFstatus, char *);
  118 +void insufficient_memory(); /* used for debug */
  119 +char * getNextArgument (int, char *[], int);
  120 +void parseCmdLine (int, char *[]);
  121 +void errorMsg (char *);
  122 +void map_CDF_attr_to_netCDF (char *, char *);
  123 +char * isotime_to_dd_time (char * str_isotime);
  124 +
  125 +/****************************************************************************
  126 + NOTE:
  127 +
  128 + CDF has the following features that are not supported by netCDF:
  129 +
  130 + - CDF_EPOCH datatype (8-byte real number) that is used to store time
  131 + values referenced from a particular epoch that is
  132 + 01-Jan-0000 00:00:00.000. CDF_EPOCH values are the number of
  133 + milliseconds since the epoch described above.
  134 +
  135 + - CDF_EPOCH16 datatype (16-byte real number) that is used to store time
  136 + values referenced from a particular epoch that is
  137 + 01-Jan-0000 00:00:00.000.000.000.000. CDF_EPOCH16 values are the
  138 + number of milliseconds since the epoch described above.
  139 +
  140 + - CDF global attribute (not variable attribute) can have multiple
  141 + attribute entries and each entry can have a different datatype.
  142 +*****************************************************************************/
  143 +int main(int argc, char *argv[])
  144 +{
  145 + FILE *inFile; /* Pointer to the CDF-to-netCDF mapping file */
  146 + char rec[MAX_REC_LENGTH]; /* CDF-to-netCDF mapping record */
  147 +
  148 + /************************/
  149 + /* netCDF declaration */
  150 + /************************/
  151 + int status, /* netCDF status code */
  152 + dummy, i;
  153 +
  154 + char *ptr, fileName[MAX_FILE_NAME_LEN];
  155 +
  156 + /**********************/
  157 + /* CDF declaration */
  158 + /**********************/
  159 + CDFstatus cstatus; /* CDF status code */
  160 + long attrId; /* CDF attribute ID */
  161 +
  162 + if (argc <= 1)
  163 + usage(); /* CDF input file name not specified */
  164 + else {
  165 + strcpy(fileName, argv[argc-1]); /* Get the input file name */
  166 + strcpy(mappingFile, "UNSPECIFIED");
  167 + parseCmdLine(argc, argv);
  168 + if (strcmp(mappingFile, fileName) == 0)
  169 + errorMsg("** Error - either input file or mapping file is missing");
  170 + if (strcmp(mappingFile,"UNSPECIFIED") == 0)
  171 + {
  172 + strcpy(mappingFile,getenv("DDLIB"));
  173 + strcat(mappingFile, DEFAULT_MAPPING_FILE);
  174 + }
  175 + }
  176 +
  177 + /***********************************************/
  178 + /* Load the CDF-to-netCDF mapping information */
  179 + /***********************************************/
  180 + if ((inFile = fopen(mappingFile, "r")) == NULL) {
  181 + printf ("** Cannot open file: %s **\n", mappingFile);
  182 + exit (1);
  183 + }
  184 +
  185 + totAttrsInMappingFile = 0;
  186 + while (fgets(rec, MAX_REC_LENGTH, inFile) != NULL) {
  187 + rec[strlen(rec)-1] = '\0'; /* Remove the newline character */
  188 +
  189 + /* Process the mapping record if it's not a comment */
  190 + if (rec[0] != '#' && rec[0] != ' ' && strlen(rec) > 0) {
  191 + sscanf(rec, "%s %s",
  192 + netcdfAttrNames[totAttrsInMappingFile],
  193 + cdfAttrNames[totAttrsInMappingFile]);
  194 + ptr = (char *) strstr(rec, "//");
  195 + if (ptr != NULL) {
  196 + ptr += 3;
  197 + strcpy (comments[totAttrsInMappingFile], ptr);
  198 +
  199 + }
  200 + if (DEBUG)
  201 + printf("%s %s %s\n",
  202 + netcdfAttrNames[totAttrsInMappingFile],
  203 + cdfAttrNames[totAttrsInMappingFile],
  204 + comments[totAttrsInMappingFile]);
  205 + totAttrsInMappingFile++;
  206 + }
  207 + }
  208 +
  209 + /***********************************************************
  210 + * Process the CDF information and create a netCDF file
  211 + ***********************************************************/
  212 + // printf ("\nInput file name: %s\n", fileName);
  213 + id = cdf_open (fileName);
  214 +
  215 + /* Remove the file path if it exists (/home/mydata.cdf => mydata.cdf). */
  216 + removeFilepath(fileName);
  217 +
  218 + if (endsWith(fileName,".cdf")) {
  219 + /* Strip off the .cdf file extension. */
  220 + ptr = (char *) strlaststr(fileName, ".cdf");
  221 + if (ptr != NULL) *ptr = '\0';
  222 + }
  223 + strcat(fileName, ".nc");
  224 + status = nc_create(fileName, NC_CLOBBER, &ncid);
  225 + if (status != NC_NOERR) handle_netcdf_error(status);
  226 + // printf ("Output file name: %s\n", fileName);
  227 +
  228 + /***********************************************************************
  229 + * Get the number of dimensions, number of variables, number of global
  230 + * attributes.
  231 + *
  232 + * Note that the information retrieved from read_cdf_file_info are stored
  233 + * into the global variables defined at the top.
  234 + ***********************************************************************/
  235 + read_cdf_file_info ();
  236 + if (DEBUG) printf ("nAttrs=%d, nZvars=%d\n", nAttrs, nZvars);
  237 +
  238 + /* Get the CDF global attributes and create netCDF global attributes. */
  239 + if (DEBUG) printf ("Global attributes:\n");
  240 + dummy = -1;
  241 + for (attrId = 0; attrId < nAttrs; attrId++)
  242 + get_cdf_attribute(attrId, GLOBAL_SCOPE, (long) dummy, dummy);
  243 +
  244 + /* Write the placeholder attributes. */
  245 + for (i=0; i < totAttrsInMappingFile; i++) {
  246 + if (strcmp(cdfAttrNames[i],"*") == 0) {
  247 + status = nc_put_att_text (ncid,
  248 + NC_GLOBAL, /* vavriable ID */
  249 + netcdfAttrNames[i], /* Attribute name */
  250 + strlen(comments[i]), /* # of attr values */
  251 + comments[i]);
  252 + }
  253 + }
  254 +
  255 + /* Process CDF variables and create netCDF variables */
  256 + if (nZvars > 0) get_zVariables();
  257 +
  258 + /* Close the netCDF and CDF files */
  259 + cstatus = CDFlib (CLOSE_, CDF_, NULL_);
  260 + if (cstatus != CDF_OK) cdf_status_handler (cstatus, "CLOSE_, CDF_");
  261 +
  262 + status = nc_close(ncid);
  263 + if (status != NC_NOERR) handle_netcdf_error(status);
  264 +}
  265 +
  266 +
  267 +/*----------------------------------------------------------------------------
  268 + * TRUE if s1 ends with s2. Otherwise, FALSE is returned.
  269 + *---------------------------------------------------------------------------*/
  270 +int endsWith (char *s1, char *s2)
  271 +{
  272 + int i;
  273 + char *ps1, *ps2;
  274 +
  275 + if (strlen(s2) > strlen(s1))
  276 + return FALSE;
  277 +
  278 + ps1 = s1 + strlen(s1) - strlen(s2);
  279 + ps2 = s2;
  280 +
  281 + for (i=0; i < strlen(s2); i++)
  282 + if (*(ps1++) != *(ps2++))
  283 + return FALSE;
  284 +
  285 + return TRUE;
  286 +}
  287 +
  288 +
  289 +/*---------------------------------------------------------------------------------
  290 + * Find the last occurence of s2 in s1. If s21 is not found, s1 is returned.
  291 + *--------------------------------------------------------------------------------*/
  292 +char * strlaststr (char *s1, char *s2)
  293 +{
  294 + char *sc2, *psc1, *ps1;
  295 +
  296 + if (*s2 == '\0')
  297 + return((char *)s1);
  298 +
  299 + ps1 = s1 + strlen(s1);
  300 +
  301 + while(ps1 != s1) {
  302 + --ps1;
  303 + for (psc1 = ps1, sc2 = s2; ; )
  304 + if (*(psc1++) != *(sc2++))
  305 + break;
  306 + else if (*sc2 == '\0')
  307 + return ((char *)ps1);
  308 + }
  309 + return ((char *)NULL);
  310 +}
  311 +
  312 +
  313 +/*--------------------------------------------------------------------------
  314 + * This routine opens a CDF file
  315 + *-------------------------------------------------------------------------*/
  316 +CDFid cdf_open (char *fileName)
  317 +{
  318 + CDFstatus status;
  319 + CDFid id;
  320 + char msg[80];
  321 +
  322 + status = CDFlib (OPEN_, CDF_, fileName, /* in - file name to be opened */
  323 + &id, /* out - CDF file ID */
  324 + NULL_);
  325 + if (status != CDF_OK) {
  326 + strcpy(msg, "OPEN_, CDF_, ");
  327 + strcat(msg, fileName);
  328 + cdf_status_handler (status, msg);
  329 + }
  330 + return id;
  331 +}
  332 +
  333 +
  334 +/*---------------------------------------------------------------------------
  335 + * This routine retrievs the following information:
  336 + *
  337 + * nAttr - number of attributes (including global and variable)
  338 + * nZvars - number of zVariables
  339 + *
  340 + * CDF file can have both rVariables (old style) and zVariables (new style)
  341 + * simultaneously. zVariable is a superset of rVariable, and it is a lot
  342 + * more efficient and offers all the functionality a rVariable offers and
  343 + * more. Treat all CDF variables as zVariables.
  344 + *--------------------------------------------------------------------------*/
  345 +void read_cdf_file_info ()
  346 +{
  347 + CDFstatus status;
  348 +
  349 + status = CDFlib (SELECT_, CDF_zMODE_, zMODEon2,
  350 + GET_, CDF_NUMATTRS_, &nAttrs,
  351 + CDF_NUMzVARS_, &nZvars,
  352 + NULL_);
  353 + if (status != CDF_OK) cdf_status_handler (status, "GET_, CDF_FILEINFO_");
  354 +}
  355 +
  356 +
  357 +/*----------------------------------------------------------------------------
  358 + * This routine retrieves the CDF attribute (global or variable) name
  359 + * and its data for the given CDF attribute ID.
  360 + *---------------------------------------------------------------------------*/
  361 +void get_cdf_attribute(long attrNum, /* in - CDF attribute number/id */
  362 + long scope, /* in - CDF attribute scope */
  363 + long cdfVarId, /* in - CDF variable number/id */
  364 + int netcdfVarId) /* in - netCDF variable ID */
  365 +{
  366 + int ncstatus, i, len;
  367 + long status, numEntries, datatype, attrScope, entryNum,
  368 + numElements;
  369 + nc_type ncDatatype; /* netCDF datatype */
  370 +
  371 + char *cPtr, attrName[CDF_ATTR_NAME_LEN+1],
  372 + mappedAttrName[CDF_ATTR_NAME_LEN+1];
  373 + signed char *scPtr;
  374 + short *sPtr;
  375 + int *iPtr;
  376 + float *fPtr;
  377 + double *dPtr;
  378 +
  379 + status = CDFlib (SELECT_, ATTR_, attrNum,
  380 + GET_, ATTR_NAME_, attrName,
  381 + ATTR_SCOPE_, &attrScope,
  382 + NULL_);
  383 + if (status != CDF_OK) cdf_status_handler (status, "SELECT_, ATTR_");
  384 +
  385 + /****************************************************************/
  386 + /* If the attribute scope is not the requested attribute scope */
  387 + /* (VARIABLE_SCOPE or GLOBAL_SCOPE), do not process the current */
  388 + /* attribute. */
  389 + /****************************************************************/
  390 + if (attrScope != scope) return;
  391 +
  392 + map_CDF_attr_to_netCDF(attrName, mappedAttrName);
  393 + strcpy(attrName, mappedAttrName);
  394 +
  395 + if (attrScope == GLOBAL_SCOPE) {
  396 + status = CDFlib (GET_, ATTR_NUMgENTRIES_, &numEntries, NULL_);
  397 + if (status != CDF_OK)
  398 + cdf_status_handler (status, "GET_, ATTR_NUMgENTRIES_");
  399 + if (DEBUG) printf ("\t%s", attrName);
  400 +
  401 + /*********************************************************************
  402 + * While the CDF global attribute can have multiple entries of
  403 + * of different datatypes, the CDF variable attribute can only have
  404 + * one attribute entry. netCDF doesn't allow more than 1 attribute
  405 + * entry - handle this case
  406 + ********************************************************************/
  407 + for (entryNum=0; entryNum < numEntries; entryNum++) {
  408 + if (entryNum > 0) /* Attribute has more than 1 entry */
  409 + sprintf (attrName, "%s_%d", mappedAttrName, entryNum);
  410 + status = CDFlib (SELECT_, gENTRY_, entryNum,
  411 + GET_, gENTRY_DATATYPE_, &datatype,
  412 + gENTRY_NUMELEMS_, &numElements,
  413 + NULL_);
  414 + if (status == NO_SUCH_ENTRY) return;
  415 + if (status != CDF_OK) cdf_status_handler(status,"GET_ATTR_INFO_");
  416 + get_cdf_attr_data (attrName, gENTRY_DATA_, datatype, numElements,
  417 + netcdfVarId);
  418 + }
  419 + }
  420 + else {
  421 + /*********************************************************************
  422 + * IMPORTANT NOTE:
  423 + * For the variable attribute, entry number is the variable ID.
  424 + *********************************************************************/
  425 + status = CDFlib (SELECT_, zENTRY_, cdfVarId,
  426 + GET_, zENTRY_DATATYPE_, &datatype,
  427 + zENTRY_NUMELEMS_, &numElements,
  428 + NULL_);
  429 + /******************************************************************/
  430 + /* If there's no attribute entry for the current attribute number */
  431 + /* selected, process the next attribute. */
  432 + /******************************************************************/
  433 + if (status == NO_SUCH_ENTRY) return;
  434 +
  435 + if (status != CDF_OK) cdf_status_handler (status,"GET_ATTR_INFO_");
  436 + if (DEBUG) printf ("\t%s", attrName);
  437 + get_cdf_attr_data (attrName, zENTRY_DATA_, datatype, numElements,
  438 + netcdfVarId);
  439 + }
  440 +}
  441 +
  442 +
  443 +/*--------------------------------------------------------------------------
  444 + * This routine retrieves the CDF attribute data (a.k.a. attribute entries)
  445 + * and write its values to the target netCDF file.
  446 + *--------------------------------------------------------------------------*/
  447 +void get_cdf_attr_data (char *attrName, /* in - attribute name */
  448 + long entryData, /* in - type of attr entry data */
  449 + long datatype, /* in - attribute datatype */
  450 + long numElements, /* in - # of attribute values */
  451 + int netcdfVarId) /* in - netCDF variable ID */
  452 +{
  453 + char entryDataType[20], msg[100],
  454 + epString[EPOCH_STRING_LEN+1],
  455 + ep16String[EPOCH16_STRING_LEN+1];
  456 + double epoch16[2];
  457 +
  458 + nc_type ncDatatype; /* netCDF datatype */
  459 + int nc_status, /* netCDF status code */
  460 + varId; /* netCDF variable ID */
  461 + long status; /* CDF status code */
  462 +
  463 + char *cPtr;
  464 + signed char *scPtr;
  465 + short *sPtr;
  466 + int *iPtr, i;
  467 + float *fPtr;
  468 + double *dPtr;
  469 +
  470 + /*************************************************
  471 + * entryData has one of following values:
  472 + *
  473 + * gENTRY_DATA_ - global attribute entry
  474 + * rENTRY_DATA_ - rVariable attribute entry
  475 + * zENTRY_DATA_ - zVariable attribute entry
  476 + *************************************************/
  477 + if (entryData == gENTRY_DATA_) {
  478 + varId = NC_GLOBAL;
  479 + strcpy(entryDataType, "gENTRY_DATA_");
  480 + }
  481 + else {
  482 + varId = netcdfVarId;
  483 + strcpy(entryDataType, "zENTRY_DATA_");
  484 + }
  485 + strcpy (msg, "get_cdf_attr_data, GET_, ");
  486 + strcat (msg, entryDataType);
  487 + strcat (msg, cdf_str_datatype(datatype));
  488 +
  489 + /* Map the CDF datatype to an appropriate netCDF datatype. */
  490 + ncDatatype = get_netcdf_datatype (datatype);
  491 +
  492 + /* Remove trailing blank spaces if there are any */
  493 + for (i=strlen(attrName)-1; i >= 0; i--) {
  494 + if (attrName[i] != ' ') {
  495 + attrName[i+1] = '\0';
  496 + break;
  497 + }
  498 + }
  499 + /* Replace blanks space(s) with underscore(s). */
  500 + for (i=0; i < strlen(attrName); i++) {
  501 + if (attrName[i] == ' ') attrName[i] = '_';
  502 + }
  503 +
  504 + switch (datatype) {
  505 + case CDF_CHAR:
  506 + cPtr = (char *) malloc(numElements * sizeof(char) + 1);
  507 + if (cPtr == NULL) memory_error("get_cdf_attr_data", "NC_CHAR");
  508 + status = CDFlib (GET_, entryData, cPtr, NULL_);
  509 + if (status != CDF_OK) cdf_status_handler (status, msg);
  510 + *(cPtr+numElements) = '\0'; /* End of string mark */
  511 + if (DEBUG) printf (" = \"%s\"", cPtr);
  512 + nc_status = nc_put_att_text(ncid, varId, attrName, numElements, cPtr);
  513 + if (nc_status != NC_NOERR) handle_netcdf_error(nc_status);
  514 + free(cPtr);
  515 + break;
  516 +
  517 + case CDF_BYTE:
  518 + case CDF_INT1:
  519 + scPtr = (signed char *) malloc (sizeof(signed char) * numElements);
  520 + if (scPtr == NULL) memory_error("get_cdf_attr_data", "NC_BYTE");
  521 + status = CDFlib (GET_, entryData, scPtr, NULL_);
  522 + if (status != CDF_OK) cdf_status_handler (status, msg);
  523 + if (DEBUG) {
  524 + printf (" = ");
  525 + for (i=0; i < numElements; i++) {
  526 + if (i > 0) printf (", ");
  527 + printf ("%d", *(scPtr+i));
  528 + }
  529 + }
  530 + nc_status = nc_put_att_schar(ncid, varId, attrName, ncDatatype,
  531 + numElements, scPtr);
  532 + if (nc_status != NC_NOERR) handle_netcdf_error(nc_status);
  533 + free (scPtr);
  534 + break;
  535 +
  536 + case CDF_INT2:
  537 + case CDF_UCHAR:
  538 + case CDF_UINT1:
  539 + sPtr = (short *) malloc (sizeof(short) * numElements);
  540 + if (sPtr == NULL) memory_error("get_cdf_attr_data", "NC_SHORT");
  541 + status = CDFlib (GET_, entryData, sPtr, NULL_);
  542 + if (status != CDF_OK) cdf_status_handler (status, msg);
  543 + if (DEBUG) {
  544 + printf (" = ");
  545 + for (i=0; i < numElements; i++) {
  546 + if (i > 0) printf (", ");
  547 + printf ("%d", *(sPtr+i));
  548 + }
  549 + }
  550 + nc_status = nc_put_att_short(ncid, varId, attrName, ncDatatype,
  551 + numElements, sPtr);
  552 + if (nc_status != NC_NOERR) handle_netcdf_error(nc_status);
  553 + free (sPtr);
  554 + break;
  555 +
  556 + case CDF_INT4:
  557 + case CDF_UINT2:
  558 + iPtr = (int *) malloc (sizeof(int) * numElements);
  559 + if (iPtr == NULL) memory_error("get_cdf_attr_data", "NC_INT");
  560 + status = CDFlib (GET_, entryData, iPtr, NULL_);
  561 + if (status != CDF_OK) cdf_status_handler (status, msg);
  562 + if (DEBUG) {
  563 + printf (" = ");
  564 + for (i=0; i < numElements; i++) {
  565 + if (i > 0) printf (", ");
  566 + printf ("%d", *(iPtr+i));
  567 + }
  568 + }
  569 + nc_status = nc_put_att_int(ncid, varId, attrName, ncDatatype,
  570 + numElements, iPtr);
  571 + if (nc_status != NC_NOERR) handle_netcdf_error(nc_status);
  572 + free (iPtr);
  573 + break;
  574 +
  575 + case CDF_FLOAT:
  576 + case CDF_REAL4:
  577 + fPtr = (float *) malloc (sizeof(float) * numElements);
  578 + if (fPtr == NULL) memory_error("get_cdf_attr_data", "NC_FLOAT");
  579 + status = CDFlib (GET_, entryData, fPtr, NULL_);
  580 + if (status != CDF_OK) cdf_status_handler (status, msg);
  581 + if (DEBUG) {
  582 + printf (" = ");
  583 + for (i=0; i < numElements; i++) {
  584 + if (i > 0) printf (", ");
  585 + printf ("%g", *(fPtr+i));
  586 + }
  587 + }
  588 + nc_status = nc_put_att_float(ncid, varId, attrName, ncDatatype,
  589 + numElements, fPtr);
  590 + if (nc_status != NC_NOERR) handle_netcdf_error(nc_status);
  591 + free (fPtr);
  592 + break;
  593 +
  594 + case CDF_DOUBLE:
  595 + case CDF_REAL8:
  596 + case CDF_UINT4:
  597 + dPtr = (double *) malloc (sizeof(double) * numElements);
  598 + if (dPtr == NULL) memory_error("get_cdf_attr_data", "NC_DOUBLE");
  599 + status = CDFlib (GET_, entryData, dPtr, NULL_);
  600 + if (status != CDF_OK) cdf_status_handler (status, msg);
  601 + if (DEBUG) {
  602 + printf (" = ");
  603 + for (i=0; i < numElements; i++) {
  604 + if (i > 0) printf (", ");
  605 + printf ("%g", *(dPtr+i));
  606 + }
  607 + }
  608 + nc_status = nc_put_att_double(ncid, varId, attrName,
  609 + ncDatatype, numElements, dPtr);
  610 + if (nc_status != NC_NOERR) handle_netcdf_error(nc_status);
  611 + free (dPtr);
  612 + break;
  613 +
  614 + case CDF_EPOCH: /* 8-byte real number */
  615 + dPtr = (double *) malloc (sizeof(double) * numElements);
  616 + if (dPtr == NULL) memory_error("get_cdf_attr_data", "CDF_EPOCH");
  617 + status = CDFlib (GET_, entryData, dPtr, NULL_);
  618 + if (status != CDF_OK) cdf_status_handler (status, msg);
  619 + if (DEBUG) printf (" = ");
  620 + for (i=0; i < numElements; i++) {
  621 + encodeEPOCH (*(dPtr+i), epString);
  622 + nc_status = nc_put_att_text(ncid, varId, attrName,
  623 + EPOCH_STRING_LEN, epString);
  624 + if (nc_status != NC_NOERR) handle_netcdf_error(nc_status);
  625 + if (DEBUG) {
  626 + if (i > 0) printf (", ");
  627 + printf (epString);
  628 + }
  629 + }
  630 + free (dPtr);
  631 + break;
  632 +
  633 + case CDF_EPOCH16: /* 16-byte real number */
  634 + dPtr = (double *) malloc (sizeof(double) * numElements * 2);
  635 + if (dPtr == NULL) memory_error("get_cdf_attr_data", "CDF_EPOCH16");
  636 + status = CDFlib (GET_, entryData, dPtr, NULL_);
  637 + if (status != CDF_OK) cdf_status_handler (status, msg);
  638 + if (DEBUG) printf (" = ");
  639 + for (i=0; i < numElements; i++) {
  640 + epoch16[0] = *(dPtr+i*2);
  641 + epoch16[1] = *(dPtr+i*2+1);
  642 + encodeEPOCH16 (epoch16, ep16String);
  643 + nc_status = nc_put_att_text(ncid, varId, attrName,
  644 + strlen(ep16String), ep16String);
  645 + if (nc_status != NC_NOERR) handle_netcdf_error(nc_status);
  646 + if (DEBUG) {
  647 + if (i > 0) printf (", ");
  648 + printf (ep16String);
  649 + }
  650 + }
  651 + free (dPtr);
  652 + break;
  653 +
  654 + default:
  655 + printf ("** Error in get_cdf_attribute: bad data type");
  656 + }
  657 + if (DEBUG) printf (" ;\n");
  658 +}
  659 +
  660 +
  661 +/*--------------------------------------------------------------------------
  662 + * Get the zVariables in the CDF file.
  663 + *--------------------------------------------------------------------------*/
  664 +void get_zVariables()
  665 +{
  666 + CDFstatus status;
  667 + int i, ncstatus, createUnlimitedDim, unlimitedDimId,
  668 + attrId, netcdfVarId;
  669 + char netcdfDimName[NC_MAX_NAME+1]; /* netCDF dimension name */
  670 + long holdDim, holdDim0;
  671 + long varId,
  672 + recInterval, /* No. of recors to skip */
  673 + dimIndices[CDF_MAX_DIMS], /* Beginning location of the array */
  674 + /* to be dumped */
  675 + dimIntervals[CDF_MAX_DIMS]; /* No. of elements to skip */
  676 + CDFvar var;
  677 + size_t start[NC_MAX_DIMS], /* index for where to read first */
  678 + count[NC_MAX_DIMS]; /* # of values to read */
  679 + short timeDefined = 0;
  680 +
  681 + if (DEBUG) printf ("\n");
  682 +
  683 + createUnlimitedDim = TRUE;
  684 +
  685 + for (varId=0; varId < nZvars; varId++) {
  686 + status = CDFlib (SELECT_,zVAR_, varId,
  687 + GET_, zVAR_NAME_, var.name,
  688 + zVAR_DATATYPE_, &var.datatype,
  689 + zVAR_NUMELEMS_, &var.numElements,
  690 + zVAR_NUMDIMS_, &var.dimensionality,
  691 + zVAR_DIMSIZES_, var.dimSizes,
  692 + zVAR_NUMRECS_, &var.numRecs,
  693 + zVAR_RECVARY_, &var.recVariance,
  694 + NULL_);
  695 + if (status != CDF_OK) cdf_status_handler (status, "GET_, zVARS_");
  696 +
  697 + if (DEBUG) {
  698 + printf ("\nvar name = %s, %s/%d, %d:[",
  699 + var.name, cdf_str_datatype(var.datatype),
  700 + var.numElements, var.dimensionality);
  701 + for (i=0; i < var.dimensionality; i++) {
  702 + if (i > 0) printf (",");
  703 + printf ("%d", var.dimSizes[i]);
  704 + }
  705 + printf("], numRecs = %d\n", var.numRecs);
  706 + }
  707 +
  708 + create_netcdf_dimensions (var, &createUnlimitedDim, &unlimitedDimId);
  709 +
  710 +
  711 + netcdfVarId = create_netcdf_variable (var, unlimitedDimId, &timeDefined);
  712 +
  713 + /* Leave the define mode before adding data */
  714 + ncstatus = nc_enddef(ncid);
  715 + if (ncstatus != NC_NOERR) handle_netcdf_error(ncstatus);
  716 +
  717 + get_cdf_variable_data (varId, var);
  718 +
  719 + /* Enter the define mode before writing netCDF variable attributes */
  720 + /* and creating a variable. */
  721 + ncstatus = nc_redef(ncid);
  722 + if (ncstatus != NC_NOERR) handle_netcdf_error(ncstatus);
  723 +
  724 + /* Get the variable attributes */
  725 + for (attrId = 0; attrId < nAttrs; attrId++)
  726 + get_cdf_attribute(attrId, VARIABLE_SCOPE, varId, netcdfVarId);
  727 + }
  728 +// DD Variables
  729 + nc_def_dim (ncid, "TimeLength", TIMELENGTH, &TimeLengthID);
  730 + nc_def_var (ncid, "StartTime", NC_CHAR, 1, &TimeLengthID, &StartTimeID);
  731 + nc_def_var (ncid, "StopTime", NC_CHAR, 1, &TimeLengthID, &StopTimeID);
  732 + ncstatus = nc_enddef(ncid);
  733 + if (ncstatus != NC_NOERR) handle_netcdf_error(ncstatus);
  734 + start[0] = 0L;
  735 + start[1] = 0L;
  736 + count[0]= 1L;
  737 + count[1] = TIMELENGTH;
  738 + ncstatus = nc_put_vara_text(ncid, StartTimeID, &start[1], &count[1], StartTime);
  739 + if (ncstatus != NC_NOERR) handle_netcdf_error(ncstatus);
  740 + ncstatus = nc_put_vara_text(ncid, StopTimeID, &start[1], &count[1], StopTime);
  741 + if (ncstatus != NC_NOERR) handle_netcdf_error(ncstatus);
  742 +}
  743 +
  744 +
  745 +/*--------------------------------------------------------------------------
  746 + * This routine creates a netCDF dimension.
  747 + *--------------------------------------------------------------------------*/
  748 +void create_netcdf_dimensions (CDFvar var,
  749 + int *createUnlimitedDim,
  750 + int *unlimitedDimId)
  751 +{
  752 + int status, /* netCDF status code */
  753 + i, j, dimensionCreated;
  754 + long dimensionality;
  755 + char netcdfDimName[NC_MAX_NAME+1]; /* netCDF dimension name */
  756 +
  757 + if (*createUnlimitedDim) {
  758 + if (var.recVariance == VARY) {
  759 + status = nc_def_dim(ncid, UNLIMITDIM, NC_UNLIMITED,unlimitedDimId);
  760 + if (status != NC_NOERR) handle_netcdf_error(status);
  761 + *createUnlimitedDim = FALSE;
  762 + }
  763 + }
  764 +
  765 + dimensionality = var.dimensionality;
  766 +
  767 + if (var.datatype == CDF_CHAR) {
  768 + var.dimSizes[dimensionality] = var.numElements;
  769 + dimensionality++;
  770 + }
  771 + else if (var.datatype == CDF_EPOCH) {
  772 + var.dimSizes[dimensionality] = TIMELENGTH; //EPOCH_STRING_LEN;
  773 + dimensionality++;
  774 + }
  775 + else if (var.datatype == CDF_EPOCH16) {
  776 + var.dimSizes[dimensionality] = TIMELENGTH; //EPOCH16_STRING_LEN;
  777 + dimensionality++;
  778 + }
  779 +
  780 + for (i=0; i < dimensionality; i++) {
  781 + dimensionCreated = FALSE;
  782 + for (j=0; j < totNCdims; j++) {
  783 + if (ncDims[j].size == var.dimSizes[i]) {
  784 + dimensionCreated = TRUE;
  785 + break;
  786 + }
  787 + }
  788 + if (!dimensionCreated && var.dimSizes[i] > 1) {
  789 + ncDims[totNCdims].size = var.dimSizes[i];
  790 + sprintf (netcdfDimName, "dim%d", totNCdims);
  791 + strcpy(ncDims[totNCdims].name, netcdfDimName);
  792 + status = nc_def_dim(ncid, /* in */
  793 + ncDims[totNCdims].name, /* in */
  794 + ncDims[totNCdims].size, /* in */
  795 + &ncDims[totNCdims].id); /* out */
  796 + if (status != NC_NOERR) handle_netcdf_error(status);
  797 + totNCdims++;
  798 + }
  799 + }
  800 +}
  801 +
  802 +
  803 +/*--------------------------------------------------------------------------
  804 + * This routine creates a netCDF variable.
  805 + *--------------------------------------------------------------------------*/
  806 +int create_netcdf_variable (CDFvar var, /* in - CDF variable */
  807 + int unlimitedDimId, short *timeDefined) /* in - unlimited dim ID */
  808 +{
  809 + int status, /* netCDF status code */
  810 + i, j, k, ii,
  811 + varId, /* netCDF variable ID */
  812 + dimensionality, /* netCDF dimensionality */
  813 + dims[NC_MAX_DIMS]; /* netCDF dimensions */
  814 + nc_type datatype;
  815 +
  816 + int nc_dimensionality, nc_dims[NC_MAX_DIMS];
  817 + char ourTime[]={"Time\0"};
  818 +
  819 + dimensionality = var.dimensionality;
  820 + datatype = get_netcdf_datatype (var.datatype);
  821 +
  822 + /*********************************************************************
  823 + * While the string value is treated as 0-d in CDF, it is treated as
  824 + * 1-D in netCDF.
  825 + *********************************************************************/
  826 + if (var.datatype == CDF_CHAR) {
  827 + var.dimSizes[dimensionality] = var.numElements;
  828 + dimensionality++;
  829 + }
  830 +
  831 + /*********************************************************************
  832 + * In CDF, CDF_EPOCH and CDF_EPOCH16 are used to store a date and time
  833 + * value into a 8-byte and 16-byte real value, respectively. Since netCDF
  834 + * doesn't support EPOCH, the CDF EPOCH variable needs to be translated
  835 + * as a string value.
  836 + *********************************************************************/
  837 + else if ((var.datatype == CDF_EPOCH) && (! *timeDefined)) {
  838 +
  839 + *timeDefined = 1;
  840 + var.dimSizes[dimensionality] = TIMELENGTH;//EPOCH_STRING_LEN;
  841 + strcpy(var.name, ourTime);
  842 + dimensionality++;
  843 + }
  844 + else if (var.datatype == CDF_EPOCH16) {
  845 + var.dimSizes[dimensionality] = TIMELENGTH;//EPOCH16_STRING_LEN;
  846 + strcpy(var.name, ourTime);
  847 + dimensionality++;
  848 + }
  849 +
  850 + /************************************************************************
  851 + * If CDF's record variance is true, then the netCDF's first dimension
  852 + * reflects the record number.
  853 + ************************************************************************/
  854 + k = 0;
  855 + if (var.recVariance == VARY) {
  856 + dims[k++] = unlimitedDimId;
  857 + dimensionality++;
  858 + }
  859 +
  860 + for (i=0; i < dimensionality; i++) {
  861 + for (j=0; j < totNCdims; j++) {
  862 + if (ncDims[j].size == var.dimSizes[i]) {
  863 + dims[k++] = ncDims[j].id;
  864 + break;
  865 + }
  866 + }
  867 + }
  868 +
  869 + /* Remove trailing blank spaces if there are any */
  870 + for (i=strlen(var.name)-1; i >= 0; i--) {
  871 + if (var.name[i] != ' ') {
  872 + var.name[i+1] = '\0';
  873 + break;
  874 + }
  875 + }
  876 +
  877 +
  878 + /* Replace special symbols with underscore(s). */
  879 + for (ii=0; ii < 9; ii++)
  880 + for (i=0; i < strlen(var.name); i++) {
  881 + if (var.name[i] == SpecialSymbol[ii]) {
  882 + var.name[i] = '_';
  883 + }
  884 + }
  885 +
  886 +
  887 +/* Exclude "false" dimension */
  888 + nc_dimensionality = dimensionality;
  889 + for (i=0; i < dimensionality; i++) {
  890 + if ( var.dimSizes[i] == 1 ) {
  891 + nc_dimensionality--;
  892 + j = i;
  893 + break;
  894 + }
  895 + }
  896 + /* Create a netCDF variable. */
  897 +
  898 + status = nc_def_var(ncid, var.name, datatype, nc_dimensionality, dims, &varId);
  899 +
  900 + if (status != NC_NOERR) handle_netcdf_error(status);
  901 +
  902 + return varId;
  903 +}
  904 +
  905 +
  906 +/*--------------------------------------------------------------------------
  907 + * Get the CDF variable data and write the data just read into the
  908 + * netCDF variable created in create_netcdf_variable.
  909 + *--------------------------------------------------------------------------*/
  910 +void get_cdf_variable_data (long varId, /* in - variable ID/number */
  911 + CDFvar var) /* in - CDF variable structure */
  912 +{
  913 + CDFstatus status; /* CDF status code */
  914 + int ncstatus; /* netCDF status code */
  915 + char epString[EPOCH_STRING_LEN+1];
  916 + char ep16String[EPOCH16_STRING_LEN+1];
  917 +
  918 + double epoch16[2];
  919 +
  920 + size_t start[NC_MAX_DIMS], /* index for where to read first */
  921 + count[NC_MAX_DIMS]; /* # of values to read */
  922 +
  923 + int i, j, k, divide,
  924 + dimensionality,
  925 + numValues; /* # of values on each record */
  926 +
  927 + int nc_dimensionality,
  928 + nc_dimSizes[NC_MAX_DIMS];
  929 +
  930 + char *cPtr;
  931 + signed char *scPtr;
  932 + short *sPtr;
  933 + int *iPtr;
  934 + float *fPtr;
  935 + double *dPtr;
  936 + long recNo,
  937 + totRecs, /* total # of records to read */
  938 + numRecsLeftToRead,
  939 + numRecs; /* # of records to read and write at a time */
  940 +
  941 + dd_time_t curTime;
  942 +
  943 + j = 0;
  944 + start[0] = 0;
  945 + numValues = 1; /* # of values on each CDF record */
  946 +
  947 + if (var.recVariance == VARY) { /* Treat it as a netCDF record variable */
  948 + start[j] = 0; /* start record # */
  949 + count[j++] = var.numRecs; /* # of records to write */
  950 + }
  951 +
  952 + dimensionality = var.dimensionality;
  953 +
  954 + if (var.datatype == CDF_CHAR) {
  955 + var.dimSizes[dimensionality] = var.numElements;
  956 + dimensionality++;
  957 + }
  958 +
  959 + /*********************************************************************
  960 + * In CDF, CDF_EPOCH and CDF_EPOCH16 are used to store a date and time
  961 + * value into a 8-byte and 16-byte real value, respectively. Since netCDF
  962 + * doesn't support EPOCH, the CDF EPOCH variable needs to be translated
  963 + * as a string value.
  964 + *********************************************************************/
  965 + else if (var.datatype == CDF_EPOCH) {
  966 + var.dimSizes[dimensionality] = TIMELENGTH;
  967 + dimensionality++;
  968 + }
  969 + else if (var.datatype == CDF_EPOCH16) {
  970 + var.dimSizes[dimensionality] = TIMELENGTH;
  971 + dimensionality++;
  972 + }
  973 +
  974 + for (i=0; i < dimensionality; i++) {
  975 + start[j] = 0;
  976 + if (var.dimSizes[i] > 1) count[j++] = var.dimSizes[i];
  977 + numValues *= var.dimSizes[i];
  978 + }
  979 +
  980 + if (var.datatype == CDF_EPOCH)
  981 + numValues /= TIMELENGTH;
  982 + else if (var.datatype == CDF_EPOCH16)
  983 + numValues /= TIMELENGTH;
  984 +
  985 + totRecs = var.numRecs; /* total # of records for this var */
  986 + numRecsLeftToRead = var.numRecs;
  987 +
  988 + while (numRecsLeftToRead > 0) {
  989 + recNo = start[0]; /* record # to start reading */
  990 + divide = 1;
  991 + numRecs = numRecsLeftToRead; /* # of records to read at a time */
  992 +
  993 + switch (var.datatype) {
  994 + case CDF_CHAR:
  995 + cPtr = NULL;
  996 + while (cPtr == NULL) {
  997 + cPtr = (char *) malloc (sizeof(char) * numValues * numRecs);
  998 + if (cPtr == NULL) {
  999 + if (DEBUG) insufficient_memory();
  1000 + divide *= 2;
  1001 + numRecs = totRecs / divide;
  1002 + }
  1003 + }
  1004 + read_cdf_variable_data (varId,
  1005 + recNo, /* starting record # */
  1006 + numRecs, /* # of records to read */
  1007 + var.dimensionality,
  1008 + var.dimSizes, /* dimesion sizes */
  1009 + cPtr); /* data pointer */
  1010 + if (DEBUG) {
  1011 + printf (" retrieved CDF data = \n");
  1012 + for (k=0; k < numRecs; k++) {
  1013 + printf("\"");
  1014 + for (i=0; i < numValues; i++)
  1015 + printf ("%c", *(cPtr+(k*numValues+i)));
  1016 + printf("\"\n");
  1017 + }
  1018 + }
  1019 +
  1020 + start[0] = 0;
  1021 + start[1] = 0;
  1022 + if (var.recVariance == VARY) {
  1023 + count[0] = numRecs;
  1024 + }
  1025 +
  1026 + if (DEBUG) {
  1027 + for (i=0; i < dimensionality; i++)
  1028 + printf (" start[%d] = %d, count[%d] = %d\n",
  1029 + i, start[i], i, count[i]);
  1030 + }
  1031 + ncstatus = nc_put_vara_text(ncid, varId, start, count, cPtr);
  1032 + if (ncstatus != NC_NOERR) handle_netcdf_error(ncstatus);
  1033 + if (DEBUG && ncstatus != NC_NOERR) {
  1034 + if (ncstatus != NC_NOERR)
  1035 + printf (" Error putting data...\n");
  1036 + else
  1037 + printf (" Done putting data...\n");
  1038 + }
  1039 + free (cPtr);
  1040 + break;
  1041 +
  1042 + case CDF_BYTE:
  1043 + case CDF_INT1:
  1044 + scPtr = NULL;
  1045 + while (scPtr == NULL) {
  1046 + scPtr =
  1047 + (signed char *) malloc (sizeof(signed char)*numValues*numRecs);
  1048 + if (scPtr == NULL) {
  1049 + if (DEBUG) insufficient_memory();
  1050 + divide *= 2;
  1051 + numRecs = totRecs / divide;
  1052 + }
  1053 + }
  1054 + read_cdf_variable_data (varId,
  1055 + recNo, /* starting record # */
  1056 + numRecs, /* # of records to read */
  1057 + var.dimensionality,
  1058 + var.dimSizes, /* dimesion sizes */
  1059 + scPtr); /* data pointer */
  1060 + if (var.recVariance == VARY)
  1061 + count[0] = numRecs;
  1062 + ncstatus = nc_put_vara_schar(ncid, varId, start, count, scPtr);
  1063 + if (ncstatus != NC_NOERR) handle_netcdf_error(ncstatus);
  1064 + free (scPtr);
  1065 + break;
  1066 +
  1067 + case CDF_INT2:
  1068 + case CDF_UCHAR:
  1069 + case CDF_UINT1:
  1070 + sPtr = NULL;
  1071 + while (sPtr == NULL) {
  1072 + sPtr = (short *) malloc (sizeof(short) * numValues * numRecs);
  1073 + if (sPtr == NULL) {
  1074 + if (DEBUG) insufficient_memory();
  1075 + divide *= 2;
  1076 + numRecs = totRecs / divide;
  1077 + }
  1078 + }
  1079 + read_cdf_variable_data (varId,
  1080 + recNo, /* starting record # */
  1081 + numRecs, /* # of records to read */
  1082 + var.dimensionality,
  1083 + var.dimSizes, /* dimesion sizes */
  1084 + sPtr); /* data pointer */
  1085 + if (var.recVariance == VARY)
  1086 + count[0] = numRecs;
  1087 + ncstatus = nc_put_vara_short(ncid, varId, start, count, sPtr);
  1088 + if (ncstatus != NC_NOERR) handle_netcdf_error(ncstatus);
  1089 + free (sPtr);
  1090 + break;
  1091 +
  1092 + case CDF_INT4:
  1093 + case CDF_UINT2:
  1094 + iPtr = NULL;
  1095 + while (iPtr == NULL) {
  1096 + iPtr = (int *) malloc (sizeof(int) * numValues * numRecs);
  1097 + if (iPtr == NULL) {
  1098 + if (DEBUG) insufficient_memory();
  1099 + divide *= 2;
  1100 + numRecs = totRecs / divide;
  1101 + }
  1102 + }
  1103 + read_cdf_variable_data (varId,
  1104 + recNo, /* starting record # */
  1105 + numRecs, /* # of records to read */
  1106 + var.dimensionality,
  1107 + var.dimSizes, /* dimesion sizes */
  1108 + iPtr); /* data pointer */
  1109 + if (var.recVariance == VARY)
  1110 + count[0] = numRecs;
  1111 + ncstatus = nc_put_vara_int(ncid, varId, start, count, iPtr);
  1112 + if (ncstatus != NC_NOERR) handle_netcdf_error(ncstatus);
  1113 + free (iPtr);
  1114 + break;
  1115 +
  1116 + case CDF_FLOAT:
  1117 + case CDF_REAL4:
  1118 + fPtr = NULL;
  1119 + while (fPtr == NULL) {
  1120 + fPtr = (float *) malloc (sizeof(float) * numValues * numRecs);
  1121 + if (fPtr == NULL) {
  1122 + if (DEBUG) insufficient_memory();
  1123 + divide *= 2;
  1124 + numRecs = totRecs / divide;
  1125 + }
  1126 + }
  1127 + read_cdf_variable_data (varId,
  1128 + recNo, /* starting record # */
  1129 + numRecs, /* # of records to read */
  1130 + var.dimensionality,
  1131 + var.dimSizes, /* dimesion sizes */
  1132 + fPtr); /* data pointer */
  1133 + if (var.recVariance == VARY)
  1134 + count[0] = numRecs;
  1135 + ncstatus = nc_put_vara_float(ncid, varId, start, count, fPtr);
  1136 + if (ncstatus != NC_NOERR) handle_netcdf_error(ncstatus);
  1137 + free (fPtr);
  1138 + break;
  1139 +
  1140 + case CDF_DOUBLE:
  1141 + case CDF_REAL8:
  1142 + case CDF_UINT4:
  1143 + dPtr = NULL;
  1144 + while (dPtr == NULL) {
  1145 + dPtr = (double *) malloc (sizeof(double) * numValues * numRecs);
  1146 + if (dPtr == NULL) {
  1147 + if (DEBUG) insufficient_memory();
  1148 + divide *= 2;
  1149 + numRecs = totRecs / divide;
  1150 + }
  1151 + }
  1152 + read_cdf_variable_data (varId,
  1153 + recNo, /* starting record # */
  1154 + numRecs, /* # of records to read */
  1155 + var.dimensionality,
  1156 + var.dimSizes, /* dimesion sizes */
  1157 + dPtr); /* data pointer */
  1158 + if (var.recVariance == VARY)
  1159 + count[0] = numRecs;
  1160 +
  1161 + ncstatus = nc_put_vara_double(ncid, varId, start, count, dPtr);
  1162 + if (ncstatus != NC_NOERR) handle_netcdf_error(ncstatus);
  1163 + free (dPtr);
  1164 + break;
  1165 +
  1166 + case CDF_EPOCH:
  1167 + dPtr = NULL;
  1168 + while (dPtr == NULL) {
  1169 + dPtr = (double *) malloc (sizeof(double)*numValues*numRecs);
  1170 + if (dPtr == NULL) {
  1171 + if (DEBUG) insufficient_memory();
  1172 + divide *= 2;
  1173 + numRecs = totRecs / divide;
  1174 + }
  1175 + }
  1176 + read_cdf_variable_data (varId,
  1177 + recNo, /* starting record # */
  1178 + numRecs, /* # of records to read */
  1179 + var.dimensionality,
  1180 + var.dimSizes, /* dimesion sizes */
  1181 + dPtr); /* data pointer */
  1182 +
  1183 + count[0] = 1L;
  1184 +
  1185 + /* Get the EPOCH value into a DD Timestring. */
  1186 +
  1187 + for (i = 0; i < numRecs*numValues; i++) {
  1188 + *(dPtr+i) /= 1000.0;
  1189 +
  1190 + *(dPtr+i) -= TIMESHIFT;
  1191 + strcpy(curTime,Double2DD_Time((double)*(dPtr+i)));
  1192 + ncstatus = nc_put_vara_text(ncid, varId, start, count, curTime);
  1193 + if (ncstatus != NC_NOERR) handle_netcdf_error(ncstatus);
  1194 + if ((i == 0) && (isTimeSet == 0)) strcpy(StartTime,curTime);
  1195 + start[0]++;
  1196 + }
  1197 + // First Epoch type is considered as Time
  1198 + if (isTimeSet == 0) strcpy(StopTime,curTime);
  1199 + isTimeSet = 1;
  1200 + free (dPtr);
  1201 + break;
  1202 +
  1203 + case CDF_EPOCH16:
  1204 + dPtr = NULL;
  1205 + while (dPtr == NULL) {
  1206 + dPtr = (double *) malloc (sizeof(double) * numValues*numRecs*2);
  1207 + if (dPtr == NULL) {
  1208 + if (DEBUG) insufficient_memory();
  1209 + divide *= 2;
  1210 + numRecs = totRecs / divide;
  1211 + }
  1212 + }
  1213 + read_cdf_variable_data (varId,
  1214 + recNo, /* starting record # */
  1215 + numRecs, /* # of records to read */
  1216 + var.dimensionality,
  1217 + var.dimSizes, /* dimesion sizes */
  1218 + dPtr); /* data pointer */
  1219 +
  1220 + count[0] = 1L;
  1221 +
  1222 +
  1223 + /* Get all the EPOCH16 values into a single string. */
  1224 + for (i=0; i < numRecs; i++) {
  1225 + epoch16[0] = *(dPtr+i*2);
  1226 + epoch16[1] = *(dPtr+i*2+1);
  1227 + encodeEPOCH16_4 (epoch16, ep16String);
  1228 + ncstatus = nc_put_vara_text(ncid, varId, start, count, isotime_to_dd_time(ep16String));
  1229 + if (ncstatus != NC_NOERR) handle_netcdf_error(ncstatus);
  1230 + if ((i == 0) && (isTimeSet == 0)) strcpy(StartTime,isotime_to_dd_time(ep16String));
  1231 + start[0]++;
  1232 + }
  1233 +
  1234 + free (dPtr);
  1235 + // First Epoch type is considered as Time
  1236 + if (isTimeSet == 0) strcpy(StopTime,isotime_to_dd_time(ep16String));
  1237 + isTimeSet = 1;
  1238 + break;
  1239 +
  1240 + default:
  1241 + printf ("** Error in getVarData: bad type");
  1242 + }
  1243 +
  1244 + numRecsLeftToRead = totRecs - numRecs;
  1245 + if (numRecsLeftToRead > 0) {
  1246 + totRecs = numRecsLeftToRead;
  1247 + start[0] = numRecs;
  1248 + }
  1249 + } /* end of the 'while' loop */
  1250 +
  1251 +}
  1252 +
  1253 +
  1254 +/*--------------------------------------------------------------------------
  1255 + * This routine returns the string representation of the given CDF
  1256 + * datatype.
  1257 + *--------------------------------------------------------------------------*/
  1258 +char * cdf_str_datatype (long type)
  1259 +{
  1260 + switch (type) {
  1261 + case CDF_BYTE:
  1262 + return "CDF_BYTE";
  1263 +
  1264 + case CDF_INT1:
  1265 + return "CDF_INT1";
  1266 +
  1267 + case CDF_CHAR:
  1268 + return "CDF_CHAR";
  1269 +
  1270 + case CDF_INT2:
  1271 + return "CDF_INT2";
  1272 +
  1273 + case CDF_UCHAR:
  1274 + return "CDF_UCHAR";
  1275 +
  1276 + case CDF_UINT1:
  1277 + return "CDF_UINT1";
  1278 +
  1279 + case CDF_INT4:
  1280 + return "CDF_INT4";
  1281 +
  1282 + case CDF_UINT2:
  1283 + return "CDF_UINT2";
  1284 +
  1285 + case CDF_FLOAT:
  1286 + return "CDF_FLOAT";
  1287 +
  1288 + case CDF_REAL4:
  1289 + return "CDF_REAL4";
  1290 +
  1291 + case CDF_DOUBLE:
  1292 + return "CDF_DOUBLE";
  1293 +
  1294 + case CDF_REAL8:
  1295 + return "CDF_REAL8";
  1296 +
  1297 + case CDF_UINT4:
  1298 + return "CDF_UINT4";
  1299 +
  1300 + case CDF_EPOCH:
  1301 + return "CDF_EPOCH";
  1302 +
  1303 + case CDF_EPOCH16:
  1304 + return "CDF_EPOCH16";
  1305 + }
  1306 +}
  1307 +
  1308 +
  1309 +/*--------------------------------------------------------------------------
  1310 + * This routine returns the string representation of the given netCDF
  1311 + * datatype.
  1312 + *--------------------------------------------------------------------------*/
  1313 +char * NC_datatype (nc_type type)
  1314 +{
  1315 + switch (type) {
  1316 + case NC_BYTE:
  1317 + return "byte";
  1318 + case NC_CHAR:
  1319 + return "char";
  1320 + case NC_SHORT:
  1321 + return "short";
  1322 + case NC_INT:
  1323 + return "int";
  1324 + case NC_FLOAT:
  1325 + return "float";
  1326 + case NC_DOUBLE:
  1327 + return "double";
  1328 + default:
  1329 + return "UNKNOWN";
  1330 + }
  1331 +}
  1332 +
  1333 +
  1334 +/*--------------------------------------------------------------------------
  1335 + * This routine returns the netCDF datatype for the given CDF datatype.
  1336 + *--------------------------------------------------------------------------*/
  1337 +nc_type get_netcdf_datatype (long type)
  1338 +{
  1339 + nc_type netcdf_type;
  1340 +
  1341 + switch (type) {
  1342 + case CDF_BYTE:
  1343 + case CDF_INT1:
  1344 + netcdf_type = NC_BYTE;
  1345 + break;
  1346 +
  1347 + case CDF_CHAR:
  1348 + case CDF_EPOCH:
  1349 + case CDF_EPOCH16:
  1350 + netcdf_type = NC_CHAR;
  1351 + break;
  1352 +
  1353 + case CDF_INT2:
  1354 + case CDF_UCHAR:
  1355 + case CDF_UINT1:
  1356 + netcdf_type = NC_SHORT;
  1357 + break;
  1358 +
  1359 + case CDF_INT4:
  1360 + case CDF_UINT2:
  1361 + netcdf_type = NC_INT;
  1362 + break;
  1363 +
  1364 + case CDF_FLOAT:
  1365 + case CDF_REAL4:
  1366 + netcdf_type = NC_FLOAT;
  1367 + break;
  1368 +
  1369 + case CDF_DOUBLE:
  1370 + case CDF_REAL8:
  1371 + case CDF_UINT4:
  1372 + netcdf_type = NC_DOUBLE;
  1373 + break;
  1374 +
  1375 + default: {
  1376 + printf ("** ERROR: Unknown CDF datatype\n");
  1377 + exit (1);
  1378 + }
  1379 + }
  1380 + return netcdf_type;
  1381 +}
  1382 +
  1383 +
  1384 +/*---------------------------------------------------------------------------
  1385 + * Read the CDF variable data for the given CDF variable number.
  1386 + *---------------------------------------------------------------------------*/
  1387 +void read_cdf_variable_data (long varNum, /* CDF variable number */
  1388 + long recNo, /* record # for start reading */
  1389 + long recCount, /* # of records to read */
  1390 + long dim, /* CDF dimensionality */
  1391 + long dimSizes[], /* CDF dimesion sizes */
  1392 + void *data) /* data pointer */
  1393 +{
  1394 + CDFstatus status;
  1395 + int i;
  1396 + long recInterval, /* No. of recors to skip */
  1397 + dimIndices[CDF_MAX_DIMS], /* Beginning location of the array */
  1398 + /* to be dumped */
  1399 + dimIntervals[CDF_MAX_DIMS]; /* No. of elements to skip */
  1400 +
  1401 + recInterval = 1L; /* # of records to skip between writes */
  1402 +
  1403 + for (i=0; i < dim; i++) {
  1404 + dimIndices[i] = 0; /* Dump data from the beginning of array */
  1405 + dimIntervals[i] = 1; /* Dump all the elements in the array */
  1406 + }
  1407 +
  1408 + status = CDFlib (SELECT_,zVAR_, varNum,
  1409 + zVAR_RECNUMBER_, recNo,
  1410 + zVAR_RECCOUNT_, recCount,
  1411 + zVAR_RECINTERVAL_, recInterval,
  1412 + zVAR_DIMINDICES_, dimIndices,
  1413 + zVAR_DIMCOUNTS_, dimSizes,
  1414 + zVAR_DIMINTERVALS_, dimIntervals,
  1415 + GET_, zVAR_HYPERDATA_, data,
  1416 + NULL_);
  1417 + if (status != CDF_OK) cdf_status_handler (status, "GET_, zVAR_HYPERDATA_");
  1418 +}
  1419 +
  1420 +
  1421 +/*--------------------------------------------------------------------------
  1422 + * Remove the filepath from a file name.
  1423 + *
  1424 + * Example:
  1425 + * /home/data/mydata.txt => mydata.txt
  1426 + *--------------------------------------------------------------------------*/
  1427 +void removeFilepath (char *fileName) {
  1428 + char *ptr;
  1429 +
  1430 + ptr = strrchr(fileName, '/'); /* Unix file path separator */
  1431 + if (ptr != NULL) {
  1432 + ptr++;
  1433 + strcpy(fileName, ptr);
  1434 + }
  1435 + else {
  1436 + ptr = strrchr(fileName, '\\'); /* Windows file separator */
  1437 + if (ptr != NULL) {
  1438 + ptr++;
  1439 + strcpy(fileName, ptr);
  1440 + }
  1441 + }
  1442 +}
  1443 +
  1444 +
  1445 +/*--------------------------------------------------------------------------
  1446 + * Handles a CDF error.
  1447 + *--------------------------------------------------------------------------*/
  1448 +void cdf_status_handler (CDFstatus status, char *source)
  1449 +{
  1450 + char message[CDF_STATUSTEXT_LEN+1];
  1451 +
  1452 + CDFerror (status, message); /* Get the appropriate message */
  1453 +
  1454 + if (status < CDF_WARN) {
  1455 + printf ("An error has occurred, halting...\n");
  1456 + printf ("%s\n", message);
  1457 + printf ("** Error source: %s\n", source);
  1458 + exit (status);
  1459 + }
  1460 + else if (status < CDF_OK) {
  1461 + printf ("Warning, function may not have compeleted as expected...\n");
  1462 + printf ("%s\n", message);
  1463 + }
  1464 + else if (status > CDF_OK) {
  1465 + printf ("Function compeleted successfully, but be advised that...\n");
  1466 + printf ("%s\n", message);
  1467 + }
  1468 +}
  1469 +
  1470 +
  1471 +/*--------------------------------------------------------------------------
  1472 + * Handles a netCDF error.
  1473 + *--------------------------------------------------------------------------*/
  1474 +void handle_netcdf_error(int status) {
  1475 +
  1476 + fprintf(stderr, "%s\n", nc_strerror(status));
  1477 +}
  1478 +
  1479 +
  1480 +/*--------------------------------------------------------------------------
  1481 + * Handles a memory allocation error.
  1482 + *--------------------------------------------------------------------------*/
  1483 +void memory_error(char *source, char *datatype) {
  1484 + printf ("** Memory allocation error occurred in %s. data type = %s",
  1485 + source, datatype);
  1486 + exit (1);
  1487 +}
  1488 +
  1489 +void insufficient_memory () {
  1490 + printf("Insufficient memory to load all the records at once");
  1491 +}
  1492 +
  1493 +
  1494 +/*--------------------------------------------------------------------------*/
  1495 +void usage()
  1496 +{
  1497 + printf ("\nDescription:\n");
  1498 + printf (" This program converts a CDF file into a netCDF file.");
  1499 + printf ("\n");
  1500 + printf ("Usage: cdf2nc -[Options] <CDF file name>\n");
  1501 + printf ("\n");
  1502 + printf ("Options:\n");
  1503 + printf (" -map <mapfile> Use the user-supplied mapping file.\n");
  1504 + printf (" -debug Show debug information.\n");
  1505 + printf ("\n");
  1506 + printf ("Examples of usage: \n");
  1507 + printf ("1) cdf-to-netCDF test.cdf\n");
  1508 + printf (" will convert the test.cdf file into the test.nc file.\n\n");
  1509 + printf ("2) cdf-to-netCDF -map mymap.dat test.cdf\n");
  1510 + printf (" will convert the test.cdf file into the test.nc file using\n");
  1511 + printf (" the user-supplied mapping file called 'mymap.dat' instead\n");
  1512 + printf (" of using the default cdf-to-netCDF mapping file.\n");
  1513 + printf ("\n");
  1514 + exit(1);
  1515 +}
  1516 +
  1517 +void parseCmdLine (int argc, char *argv[])
  1518 +{
  1519 + int i;
  1520 + char *nextArg;
  1521 +
  1522 + for (i=0; i < argc; i++) {
  1523 + if (strcmp(argv[i],"-map") == 0) {
  1524 + nextArg = getNextArgument(argc, argv, i);
  1525 + if (strcmp(nextArg, "No next argument") == 0 ||
  1526 + *(nextArg+0) == '-')
  1527 + errorMsg("** Error - mapping file is not defined");
  1528 + else
  1529 + strcpy(mappingFile, nextArg);
  1530 + }
  1531 + else if (strcmp(argv[i],"-debug") == 0)
  1532 + DEBUG = TRUE;
  1533 + }
  1534 +}
  1535 +
  1536 +
  1537 +char * getNextArgument (int argc, char *argv[], int currentIndex)
  1538 +{
  1539 + char *nextArg, msg[30];
  1540 + int nextIndex;
  1541 +
  1542 + nextIndex = currentIndex+1;
  1543 + if (nextIndex == argc) {
  1544 + strcpy (msg, "No next argument");
  1545 + nextArg = msg;
  1546 + }
  1547 + else
  1548 + nextArg = argv[nextIndex];
  1549 +
  1550 + return nextArg;
  1551 +}
  1552 +
  1553 +void errorMsg (char *msg)
  1554 +{
  1555 + printf ("%s\n", msg);
  1556 + exit (1);
  1557 +}
  1558 +
  1559 +
  1560 +void map_CDF_attr_to_netCDF (char *searchAttr, /* in - CDF attr name */
  1561 + char *mappedAttrName) /* out - netCDF attr name */
  1562 +{
  1563 + int i;
  1564 +
  1565 + strcpy(mappedAttrName, searchAttr);
  1566 +
  1567 + for (i=0; i < totAttrsInMappingFile; i++) {
  1568 + if (strcmp(cdfAttrNames[i], searchAttr) == 0) {
  1569 + strcpy(mappedAttrName, netcdfAttrNames[i]);
  1570 + break;
  1571 + }
  1572 + }
  1573 +}
  1574 +
  1575 +/*******************************************************************************
  1576 + *
  1577 + * Convert an ISO 8601 date time to a DD Time string
  1578 + */
  1579 +char * isotime_to_dd_time (char * input)
  1580 +{
  1581 + static char output [DD_TIME_STRING_LEN + 1];
  1582 + int i, count, ddd;
  1583 + int yy, mm, dd, h, m, s, ms;
  1584 + int duration[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
  1585 +
  1586 + count = sscanf (input, "%d-%d-%dT%d:%d:%d.%3d", & yy, & mm, & dd, & h, & m, & s, &ms);
  1587 +
  1588 + if (count != 7) {
  1589 + printf ("Unexpected time format: %s\n", input);
  1590 + strcpy (output, "ERROR ");
  1591 + goto EXIT;
  1592 + }
  1593 +
  1594 + if (leap_year (yy)) duration [2] = 29;
  1595 +
  1596 + ddd = dd - 1; /* Jan-01 : 0 => ddd in [0, 366[ */
  1597 +
  1598 + for (i = 1; i < mm; i++) ddd += duration [i];
  1599 +
  1600 + sprintf (output, "%04.4d%03.3d%02.2d%02.2d%02.2d%03.3d",
  1601 + yy, ddd, h, m, s, ms);
  1602 +
  1603 +EXIT: return output;
  1604 +}
  1605 +/*******************************************************************************
  1606 + *
  1607 + * Check if the given year is a leap one
  1608 + */
  1609 +int leap_year (int year)
  1610 +{
  1611 + if ((year % 400) == 0) return TRUE;
  1612 + if ((year % 100) == 0) return FALSE;
  1613 + if ((year % 4) == 0) return TRUE;
  1614 + return FALSE;
  1615 +}
  1616 +
... ...
src/DECODERS/cdf2nc/cdf_to_netcdf_mapping.dat 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,12 @@
  1 +#netCDF CDF Comment
  2 +#---- --- -------
  3 +history Revise_History // History of revision
  4 +_FillValue FILLVAL // Fill value
  5 +
  6 +# The asterisk (*) is a placeholder indicator and its corresponding mapping
  7 +# attribute is created in the output file. The following example creates
  8 +# 2 attributes (P1 and P2), if uncommented. The value
  9 +# of P1 and P2 will be "Placeholder 1" and "Placeholder 2", resctively.
  10 +
  11 +#P1 * // Value of P1
  12 +#P2 * // Value of P2
... ...
src/DECODERS/nc2nc/CMakeLists.txt 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,24 @@
  1 +
  2 +PROJECT(nc2nc)
  3 +
  4 +include_directories(
  5 + ${CMAKE_HOME_DIRECTORY}/src/INCLUDE/
  6 + ${NETCDFINCLUDE_DIR}
  7 +)
  8 +
  9 +#Configuration de l'exécutable
  10 +file(
  11 + GLOB_RECURSE
  12 + source_files
  13 + ./*
  14 +)
  15 +
  16 +ADD_EXECUTABLE (nc2nc ${source_files} )
  17 +
  18 +target_link_libraries(
  19 + nc2nc
  20 + DD_Client
  21 + ${NETCDFLIBRARY}
  22 +)
  23 +
  24 +install (TARGETS nc2nc DESTINATION bin)
... ...
src/DECODERS/nc2nc/nc2nc.c 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,43 @@
  1 +#include <stdio.h>
  2 +#include <stdlib.h>
  3 +#include <string.h>
  4 +#include <netcdf.h>
  5 +
  6 +
  7 +main(int argc, char **argv)
  8 +{
  9 + int ncID;
  10 + char varname[NC_MAX_NAME];
  11 + int i, ii, j, status, nvars;
  12 +
  13 + char SpecialSymbol[9] = {' ', '#', '%', '@', '+', '.', '>', '<', '-'};
  14 +
  15 + /* open nc file to write */
  16 + if((status = nc_open(argv[1],NC_WRITE|NC_SHARE,&ncID)) != NC_NOERR)
  17 + {
  18 + fprintf(stderr,"Can not open file %s to write\n",argv[1]);
  19 + exit(0);
  20 + }
  21 + /* get info on number of variables */
  22 + status = nc_inq_nvars(ncID, &nvars);
  23 +
  24 + for (j = 0; j < nvars; j++) {
  25 +
  26 + /* get the name of variable by its ID */
  27 + status = nc_inq_varname(ncID, j, varname);
  28 +
  29 + /* Replace special symbols with underscore(s) */
  30 +
  31 + for (ii = 0; ii < 9; ii++)
  32 + for (i = 0; i < strlen(varname); i++) {
  33 + if (varname[i] == SpecialSymbol[ii]) varname[i] = '_';
  34 + }
  35 + /* Rename the variable */
  36 +
  37 + status = nc_rename_var(ncID, j, varname);
  38 + nc_sync(ncID);
  39 +
  40 + }
  41 +
  42 + status = nc_close(ncID);
  43 +}
... ...
src/DECODERS/themis/esa2nc/CMakeLists.txt 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,26 @@
  1 +
  2 +PROJECT(esa2nc)
  3 +
  4 +include_directories(
  5 + ${CMAKE_HOME_DIRECTORY}/src/INCLUDE/
  6 + ${NETCDFINCLUDE_DIR}
  7 + ${libcdf_INCLUDE_DIR}
  8 +)
  9 +
  10 +#Configuration de l'exécutable
  11 +file(
  12 + GLOB_RECURSE
  13 + source_files
  14 + ./*
  15 +)
  16 +
  17 +ADD_EXECUTABLE (esa2nc ${source_files} )
  18 +
  19 +target_link_libraries(
  20 + esa2nc
  21 + DD_Client
  22 + ${NETCDFLIBRARY}
  23 + ${libcdf_LIBRARIES}
  24 +)
  25 +
  26 +install (TARGETS esa2nc DESTINATION bin)
... ...
src/DECODERS/themis/esa2nc/themis_esa2nc.c 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,551 @@
  1 +/**
  2 +* @file themis_esa2nc.c
  3 +* @brief Stand alone executable to tranform Themis (Burst & Reduced modes) CDF to DD netCDF
  4 +* @version $Id: themis_esa2nc.c,v 1.5 2013/11/29 14:11:56 budnik Exp $
  5 +*/
  6 + /**************************************************************/
  7 + /* THEMIS ESA ION AND ELECTRON Burst & Reduced CDF -> DD netCDF */
  8 + /* */
  9 + /* Energy in info file */
  10 + /* New CDF with peib & peir and new params */
  11 + /* 04.01.2008 - 2 files (sp & mom) for peir[b] & peer[b] modes */
  12 + /**************************************************************/
  13 +
  14 +#include <stdio.h>
  15 +#include <stdlib.h>
  16 +#include <netcdf.h>
  17 +#include <cdf.h>
  18 +#include <DD.h>
  19 +#include <string.h>
  20 +#include <time.h>
  21 +#include <math.h>
  22 +
  23 +#define TimeGap 3600.0
  24 +#define Source "themis@cdpp2"
  25 +#define MAX_FILE_NAME_LEN 250 // Max. file name length
  26 +#define MAX_VARS 250 // Max # of VARS in CDF
  27 +
  28 +
  29 +/*************************************
  30 + Global variables and structures
  31 +**************************************/
  32 +long CDFDims, // Number of dimensions in a CDF file
  33 + CDFVars, // Number of variables in a CDF file
  34 + CDFDimSizes[CDF_MAX_DIMS], // Dimension Sizes in a CDF file
  35 + CDFencoding, // Data encoding
  36 + CDFmajority, // Variable majority
  37 + CDFmaxRec, // max Record number
  38 + CDFAttrs; // number of CDF Attributes
  39 +
  40 +
  41 +struct cdfvar { // CDF variable structure
  42 + char name[CDF_VAR_NAME_LEN+1];
  43 + long num; //variable number
  44 + long datatype;
  45 + long numElem; // variable dimensionality
  46 + long recVariance; // variable rec Variance
  47 + long dimVariances[CDF_MAX_DIMS]; // # of data values in dimSizes
  48 +} cdfVar[MAX_VARS];
  49 +
  50 +char mode[4];
  51 +int ncID, ncSpID;
  52 +char ncFile[] = "peir000000000.nc";
  53 +char ncSpFile[] = "speir000000000.nc";
  54 +int TimeDimID, TimeLengthID, DataID, DataSpID, Data2ID;
  55 +int TimeDimSpID, TimeLengthSpID, FluxDimID; // ID of netCDF dimensions
  56 +int TimeDimVector[2], DataDimVector[2], Data2DimVector[2], FluxDimVector[2]; // netCDF Dim vectors
  57 +int TimeDimSpVector[2], DataDimSpVector[2];
  58 +size_t Start[2] = {0L,0L};
  59 +size_t TimeCount[2] = {1L,TIMELENGTH};
  60 +size_t Data1Count[2] = {1L,1L};
  61 +size_t DataCount[2] = {1L,3L};
  62 +size_t Data2Count[2] = {1L,6L};
  63 +size_t FluxCount[2] = {1L,32L};
  64 +
  65 +CDFstatus cstatus; // CDF status code
  66 +
  67 +char Version[]="v01";
  68 +char ThemisID[]="tha\0";
  69 +char ThemisTime[]="tha_peif_time";
  70 +char PAR0[]="tha_peif_delta_time";
  71 +char PAR1[]="tha_peif_mode";
  72 +char PAR2[]="tha_peif_density";
  73 +char PAR3[]="tha_peif_velocity_gse";
  74 +char PAR4[]="tha_peif_t3"; // Diagonilized Temperature
  75 +char PAR5[]="tha_peif_en_eflux";
  76 +char PAR6[]="tha_peif_en_eflux_yaxis";
  77 +char PAR7[]="tha_peif_avgtemp"; // trace of t3 divided by 3
  78 +char PAR8[]="tha_peif_vthermal";
  79 +char PAR9[]="tha_peif_sc_pot";
  80 +char PAR10[]="tha_peif_sc_current";
  81 +char PAR11[]="tha_peif_magt3"; // Temperature in Mag Field frame
  82 +char PAR12[]="tha_peif_ptens"; // Pressure Tensor DSL
  83 +char PAR13[]="tha_peif_mftens"; // Momentum Flux Tensor DSL
  84 +char PAR14[]="tha_peif_flux"; // particle flux
  85 +char PAR15[]="tha_peif_symm"; // Direction of pressure tensor symmetry in DSL
  86 +char PAR16[]="tha_peif_symm_ang"; // Angle between Direction of pressure tensor symmetry and B
  87 +
  88 +
  89 +int StartTimeID, StopTimeID;
  90 +int StartTimeSpID, StopTimeSpID;
  91 +int DeltaTID, DensID, AvTempID, ThVelID, PotID, CurrID, SymAngID; // 1D
  92 +int MfTempID, TempID, ModeID, ModeSpID, VelID, Flux2ID, SymmID; // 2D -> 3
  93 +int prTenID, mfTenID; // 2D -> 6
  94 +int FluxID; // 2D -> 32
  95 +int TimeID; // Time netCDF variable
  96 +int TimeSpID;
  97 +
  98 +char StartT[TIMELENGTH]; // Start time from data
  99 +char StopT[TIMELENGTH]; // Stop time from data
  100 +/**************************
  101 + Function prototypes
  102 +**************************/
  103 +void usage();
  104 +void cdf_handle_error (CDFstatus);
  105 +void nc_handle_error (int);
  106 +void removeFilepath();
  107 +void removeCDFext();
  108 +void removeVers();
  109 +void ncdefine();
  110 +/*--------------------------------------------------------------------------*/
  111 +void usage()
  112 +{
  113 + printf ("\nDescription:\n");
  114 + printf (" This program converts a themis CDF file into a netCDF file.\n");
  115 + printf ("\n");
  116 + printf ("Usage: esa2nc <CDF file name> <ThemisID> <mode>\n");
  117 + printf ("\n");
  118 + printf ("Example: esa2nc testfile tha peif\n");
  119 + printf ("\n");
  120 + exit(1);
  121 +}
  122 +/*--------------------------------------------------------------------------
  123 + * Handles a CDF error.
  124 + *--------------------------------------------------------------------------*/
  125 +void cdf_handle_error(CDFstatus status)
  126 +{
  127 +
  128 + char message[CDF_STATUSTEXT_LEN+1];
  129 +
  130 + CDFerror (status, message); /* Get the appropriate message */
  131 + fprintf (stderr, "CDF: %s\n", message);
  132 +// exit(1);
  133 +}
  134 +/*--------------------------------------------------------------------------
  135 + * Handles a netCDF error.
  136 + *--------------------------------------------------------------------------*/
  137 +void nc_handle_error(int status)
  138 +{
  139 + fprintf(stderr, "%s\n", nc_strerror(status));
  140 + exit(1);
  141 +}
  142 +
  143 +/*--------------------------------------------------------------------------
  144 + * NetCDF File Definition *
  145 + *--------------------------------------------------------------------------*/
  146 + void ncdefine(double Time)
  147 + {
  148 + char *s;
  149 + time_t p;
  150 + int status;
  151 + char *STime;
  152 +
  153 +/*********************** Create netCDF file *****************************/
  154 + memcpy(&(ncFile[0]),&(mode[0]), 4);
  155 + STime = Double2DD_Time(Time);
  156 + memcpy(&(ncFile[4]),&(STime[2]), 9);
  157 + if ((status = nc_create(ncFile, NC_CLOBBER, &ncID)) != NC_NOERR)
  158 + nc_handle_error(status);
  159 +/******************netCDF Dimensions *******************************/
  160 + nc_def_dim (ncID, "Time", NC_UNLIMITED, &TimeDimID);
  161 + nc_def_dim (ncID, "TimeLength", TIMELENGTH, &TimeLengthID);
  162 + nc_def_dim (ncID, "Data",3L, &DataID);
  163 + nc_def_dim (ncID, "Data2",6L, &Data2ID);
  164 +
  165 +/********************netCDF Variables ******************/
  166 + TimeDimVector[0] = TimeDimID;
  167 + DataDimVector[0] = TimeDimID;
  168 + Data2DimVector[0] = TimeDimID;
  169 + TimeDimVector[1] = TimeLengthID;
  170 + DataDimVector[1] = DataID;
  171 + Data2DimVector[1] = Data2ID;
  172 +
  173 +//
  174 + nc_def_var (ncID, "Time", NC_CHAR, 2, TimeDimVector, &TimeID);
  175 +
  176 + nc_def_var (ncID, "DeltaT", NC_DOUBLE, 1, &TimeDimID, &DeltaTID);
  177 + nc_def_var (ncID, "Mode", NC_FLOAT, 2, DataDimVector, &ModeID);
  178 +
  179 + nc_def_var (ncID, "Density", NC_DOUBLE, 1, &TimeDimID, &DensID);
  180 + nc_def_var (ncID, "AvTemp", NC_DOUBLE, 1, &TimeDimID, &AvTempID);
  181 + nc_def_var (ncID, "Potential", NC_DOUBLE, 1, &TimeDimID, &PotID);
  182 + nc_def_var (ncID, "Current", NC_DOUBLE, 1, &TimeDimID, &CurrID);
  183 + nc_def_var (ncID, "SymAngle", NC_DOUBLE, 1, &TimeDimID, &SymAngID);
  184 + nc_def_var (ncID, "V_thermal", NC_DOUBLE, 1, &TimeDimID, &ThVelID);
  185 + nc_def_var (ncID, "Velocity", NC_DOUBLE, 2, DataDimVector, &VelID);
  186 + nc_def_var (ncID, "Temperature", NC_DOUBLE, 2, DataDimVector, &TempID);
  187 + nc_def_var (ncID, "B_Temperature", NC_DOUBLE, 2, DataDimVector, &MfTempID);
  188 + nc_def_var (ncID, "Flux_tot", NC_DOUBLE, 2, DataDimVector, &Flux2ID);
  189 + nc_def_var (ncID, "Symm", NC_DOUBLE, 2, DataDimVector, &SymmID);
  190 + nc_def_var (ncID, "tensor_p", NC_DOUBLE, 2, Data2DimVector, &prTenID);
  191 + nc_def_var (ncID, "tensor_mf", NC_DOUBLE, 2, Data2DimVector, &mfTenID);
  192 +
  193 + nc_def_var (ncID, "StartTime",NC_CHAR, 1, &TimeLengthID, &StartTimeID);
  194 + nc_def_var (ncID, "StopTime",NC_CHAR, 1, &TimeLengthID , &StopTimeID);
  195 +
  196 +
  197 +
  198 +
  199 + nc_put_att_text(ncID, NC_GLOBAL, "Themis", 3, ThemisID);
  200 + nc_put_att_text(ncID, NC_GLOBAL, "Source", 12, Source);
  201 + nc_put_att_text(ncID, DensID, "Units", 5, "cm^-3");
  202 + nc_put_att_text(ncID, TempID, "Units", 2, "eV");
  203 + nc_put_att_text(ncID, TempID, "Frame", 2, "FA");
  204 + nc_put_att_text(ncID, TempID, "Order", 16, "perp1,perp2,para");
  205 + nc_put_att_text(ncID, MfTempID, "Units", 2, "eV");
  206 + nc_put_att_text(ncID, MfTempID, "Frame", 2, "FA");
  207 + nc_put_att_text(ncID, MfTempID, "Order", 16, "perp1,perp2,para");
  208 + nc_put_att_text(ncID, AvTempID, "Units", 2, "eV");
  209 + nc_put_att_text(ncID, prTenID, "Units", 2, "eV");
  210 + nc_put_att_text(ncID, prTenID, "Frame", 3, "DSL");
  211 + nc_put_att_text(ncID, prTenID, "Order", 17, "xx,xy,xz,yy,zz,yz");
  212 + nc_put_att_text(ncID, mfTenID, "Units", 2, "eV");
  213 + nc_put_att_text(ncID, mfTenID, "Frame", 3, "DSL");
  214 + nc_put_att_text(ncID, mfTenID, "Order", 17, "xx,xy,xz,yy,zz,yz");
  215 + nc_put_att_text(ncID, Flux2ID, "Units", 9, "#/sec/cm2");
  216 + nc_put_att_text(ncID, PotID, "Units", 1, "V");
  217 + nc_put_att_text(ncID, SymmID, "Frame", 3, "DSL");
  218 + nc_put_att_text(ncID, CurrID, "Units", 7, "Unknown");
  219 + nc_put_att_text(ncID, SymAngID, "Units", 7, "degrees");
  220 + nc_put_att_text(ncID, VelID, "Units", 4, "km/s");
  221 + nc_put_att_text(ncID, ThVelID, "Units", 4, "km/s");
  222 + nc_put_att_text(ncID, VelID, "Frame", 3, "GSE");
  223 +
  224 +
  225 +
  226 + time(&p);
  227 + s = ctime(&p);
  228 + nc_put_att_text(ncID, NC_GLOBAL, "Created", 24, s);
  229 +
  230 +
  231 +
  232 + memcpy(&(ncSpFile[1]),&(mode[0]), 4);
  233 + STime = Double2DD_Time(Time);
  234 + memcpy(&(ncSpFile[5]),&(STime[2]), 9);
  235 + if ((status = nc_create(ncSpFile, NC_CLOBBER, &ncSpID)) != NC_NOERR)
  236 + nc_handle_error(status);
  237 +
  238 + status = nc_def_dim (ncSpID, "Time", NC_UNLIMITED, &TimeDimSpID);
  239 + status = nc_def_dim (ncSpID, "TimeLength", TIMELENGTH, &TimeLengthSpID);
  240 + status = nc_def_dim (ncSpID, "Data",3L, &DataSpID);
  241 + status = nc_def_dim (ncSpID, "Flux",32L, &FluxDimID);
  242 +
  243 + FluxDimVector[0] = TimeDimSpID;
  244 + FluxDimVector[1] = FluxDimID;
  245 +
  246 +//ModeID, DensID, VelID, TempID;
  247 +
  248 + status = nc_def_var (ncSpID, "Time", NC_CHAR, 2, TimeDimVector, &TimeSpID);
  249 + status = nc_def_var (ncSpID, "Mode", NC_FLOAT, 2, DataDimVector, &ModeSpID);
  250 + status = nc_def_var (ncSpID, "Flux", NC_DOUBLE, 2, FluxDimVector, &FluxID);
  251 +
  252 + status = nc_def_var (ncSpID, "StartTime", NC_CHAR, 1, &TimeLengthSpID, &StartTimeSpID);
  253 + status = nc_def_var (ncSpID, "StopTime", NC_CHAR, 1, &TimeLengthSpID , &StopTimeSpID);
  254 +
  255 + status = nc_put_att_text(ncSpID, FluxID, "Units", 17, "eV/(cm^2-s-sr-eV)");
  256 + status = nc_put_att_text(ncSpID, NC_GLOBAL, "Created", 24, s);
  257 +
  258 + status = nc_enddef(ncID);
  259 + status = nc_enddef(ncSpID);
  260 +
  261 + nc_put_vara_text(ncID, StartTimeID, &(Start[1]), &(TimeCount[1]), Double2DD_Time(Time));
  262 + nc_put_vara_text(ncSpID, StartTimeSpID, &(Start[1]), &(TimeCount[1]), Double2DD_Time(Time));
  263 +
  264 + }
  265 +
  266 + void put_double(RecStart, RecCount, ParCDF, ParNC) {
  267 +
  268 +
  269 + long RecInt = 1;
  270 + long indices[1] = {0}, intervals[1] = {1}, counts[1] = {1};
  271 +
  272 + double *value;
  273 +
  274 + value = (double *)malloc(sizeof(double)*RecCount);
  275 + if ((cstatus = CDFlib (SELECT_, zVAR_, ParCDF,
  276 + zVAR_RECNUMBER_, RecStart ,
  277 + zVAR_RECCOUNT_, RecCount,
  278 + zVAR_RECINTERVAL_, RecInt,
  279 + zVAR_DIMINDICES_, indices,
  280 + zVAR_DIMCOUNTS_, counts,
  281 + zVAR_DIMINTERVALS_, intervals,
  282 + GET_, zVAR_HYPERDATA_, value, NULL_))
  283 + != CDF_OK) cdf_handle_error(cstatus);
  284 + nc_put_var_double(ncID, ParNC, value);
  285 +
  286 + free(value);
  287 + }
  288 +
  289 + void put_double3(RecStart, RecCount, ParCDF, ParNC) {
  290 +
  291 + long RecInt = 1;
  292 + long indices[2] = {0,3}, intervals[1] = {1}, counts[1] = {3};
  293 + double *value;
  294 +
  295 + value = (double *)malloc(sizeof(double)*RecCount*3);
  296 + if ((cstatus = CDFlib (SELECT_, zVAR_, ParCDF,
  297 + zVAR_RECNUMBER_, RecStart ,
  298 + zVAR_RECCOUNT_, RecCount,
  299 + zVAR_RECINTERVAL_, RecInt,
  300 + zVAR_DIMINDICES_, indices,
  301 + zVAR_DIMCOUNTS_, counts,
  302 + zVAR_DIMINTERVALS_, intervals,
  303 + GET_, zVAR_HYPERDATA_, value, NULL_))
  304 + != CDF_OK) cdf_handle_error(cstatus);
  305 + nc_put_var_double(ncID, ParNC, value);
  306 +
  307 + free(value);
  308 + }
  309 +
  310 +void put_double6(RecStart, RecCount, ParCDF, ParNC) {
  311 +
  312 + long RecInt = 1;
  313 + long indices[2] = {0,6}, intervals[1] = {1}, counts[1] = {6};
  314 + double *value;
  315 +
  316 + value = (double *)malloc(sizeof(double)*RecCount*6);
  317 + if ((cstatus = CDFlib (SELECT_, zVAR_, ParCDF,
  318 + zVAR_RECNUMBER_, RecStart ,
  319 + zVAR_RECCOUNT_, RecCount,
  320 + zVAR_RECINTERVAL_, RecInt,
  321 + zVAR_DIMINDICES_, indices,
  322 + zVAR_DIMCOUNTS_, counts,
  323 + zVAR_DIMINTERVALS_, intervals,
  324 + GET_, zVAR_HYPERDATA_, value, NULL_))
  325 + != CDF_OK) cdf_handle_error(cstatus);
  326 + nc_put_var_double(ncID, ParNC, value);
  327 +
  328 + free(value);
  329 + }
  330 +
  331 + void put_mode(RecStart, RecCount, ParCDF, ParNC, ParSpNC) {
  332 +
  333 + float *value;
  334 + long indices[2] = {0,3}, intervals[1] = {1}, counts[1] = {3};
  335 + long RecInt = 1;
  336 +
  337 + value = (float *)malloc(sizeof(float) * RecCount *3);
  338 + if ((cstatus = CDFlib (SELECT_, zVAR_, ParCDF,
  339 + zVAR_RECNUMBER_, RecStart ,
  340 + zVAR_RECCOUNT_, RecCount,
  341 + zVAR_RECINTERVAL_, RecInt,
  342 + zVAR_DIMINDICES_, indices,
  343 + zVAR_DIMCOUNTS_, counts,
  344 + zVAR_DIMINTERVALS_, intervals,
  345 + GET_, zVAR_HYPERDATA_, value, NULL_))
  346 + != CDF_OK) cdf_handle_error(cstatus);
  347 + nc_put_var_float(ncID, ParNC, value);
  348 + nc_put_var_float(ncSpID, ParSpNC, value);
  349 + free(value);
  350 + }
  351 +
  352 +void put_spectra(RecStart, RecCount, ParCDF, ParNC) {
  353 +
  354 + double *value;
  355 + long indices[2] = {0,32}, intervals[1] = {1}, counts[1] = {32};
  356 + long RecInt = 1;
  357 +
  358 + value = (double *)malloc(sizeof(double)*RecCount*32);
  359 + if ((cstatus = CDFlib (SELECT_, zVAR_, ParCDF,
  360 + zVAR_RECNUMBER_, RecStart ,
  361 + zVAR_RECCOUNT_, RecCount,
  362 + zVAR_RECINTERVAL_, RecInt,
  363 + zVAR_DIMINDICES_, indices,
  364 + zVAR_DIMCOUNTS_, counts,
  365 + zVAR_DIMINTERVALS_, intervals,
  366 + GET_, zVAR_HYPERDATA_, value, NULL_))
  367 + != CDF_OK) cdf_handle_error(cstatus);
  368 + nc_put_var_double(ncSpID, ParNC, value);
  369 + free(value);
  370 + }
  371 +/*--------------------------------------------------------------------------*/
  372 +int main(int argc, char *argv[])
  373 +{
  374 + long RecStart = 0, RecCount, RecCountF = 1, RecInt = 1, MaxRec;
  375 + long indices[1] = {0}, counts[1] = {3}, counts2[1] = {6}, countsFlux[1] = {32}, intervals[1] = {1};
  376 + long countsE[1] = {1}, indicesF[2]={0,3}, indicesF2[2]={0,6}, indicesFlux[2] = {0, 32};
  377 + double *value;
  378 + float *value_f;
  379 + size_t numElem;
  380 + long dimN, varN, par0, par1, par2, par3, par4, par5, par6, par7, par8, par9, par10, par11, par12, par13, par14, par15, par16;
  381 +
  382 + CDFid id;
  383 + int i, j, status;
  384 + char fileName[MAX_FILE_NAME_LEN];
  385 + dd_tmstr_t *dtm;
  386 + int First = 1;
  387 + double par[3], parr[6], doubleVal, parD[32];
  388 + float parF[32], par_f[3], parr_f[6], floatVal;
  389 + double DayOld;
  390 +
  391 +
  392 + char *UT;
  393 + char data_set[8]="thx_pexx";
  394 +/*-------------------------------- Arguments Decoding ----------------------------------------*/
  395 + if (argc <= 3) usage(); // CDF input file name and THEMIS Number not specified
  396 + else
  397 + {
  398 + strcpy(fileName, argv[1]);
  399 + strncpy(ThemisID,argv[2],3);
  400 + strncpy(mode,argv[3],4);
  401 + }
  402 +
  403 +/*------------------------------------------ CDF Variables Names Updated according to THEMIS Number -------------*/
  404 +
  405 + memcpy(&(data_set[2]),&(ThemisID[2]),1);
  406 + memcpy(&(data_set[6]),&(mode[2]),2);
  407 +
  408 + memcpy(&(ThemisTime[0]),&(data_set[0]),8);
  409 + memcpy(&(PAR0[0]),&(data_set[0]),8);
  410 + memcpy(&(PAR1[0]),&(data_set[0]),8);
  411 + memcpy(&(PAR2[0]),&(data_set[0]),8);
  412 + memcpy(&(PAR3[0]),&(data_set[0]),8);
  413 + memcpy(&(PAR4[0]),&(data_set[0]),8);
  414 + memcpy(&(PAR5[0]),&(data_set[0]),8);
  415 + memcpy(&(PAR6[0]),&(data_set[0]),8);
  416 + memcpy(&(PAR7[0]),&(data_set[0]),8);
  417 + memcpy(&(PAR8[0]),&(data_set[0]),8);
  418 + memcpy(&(PAR9[0]),&(data_set[0]),8);
  419 + memcpy(&(PAR10[0]),&(data_set[0]),8);
  420 + memcpy(&(PAR11[0]),&(data_set[0]),8);
  421 + memcpy(&(PAR12[0]),&(data_set[0]),8);
  422 + memcpy(&(PAR13[0]),&(data_set[0]),8);
  423 + memcpy(&(PAR14[0]),&(data_set[0]),8);
  424 + memcpy(&(PAR15[0]),&(data_set[0]),8);
  425 + memcpy(&(PAR16[0]),&(data_set[0]),8);
  426 +
  427 +/*********************** Open CDF file *****************************/
  428 + if ((cstatus = CDFopen(fileName, &id)) != CDF_OK)
  429 + cdf_handle_error(cstatus);
  430 + printf(" THEMIS %s %s\n", ThemisID, mode);
  431 +
  432 +/*********** treat all vars as zVars with eliminated false dimensionality **********/
  433 +
  434 + if ((cstatus = CDFlib(SELECT_, CDF_zMODE_, zMODEon2, NULL_)) != CDF_OK)
  435 + cdf_handle_error (cstatus);
  436 +
  437 +/************************ Get CDF Data ************************************/
  438 +
  439 + cstatus = CDFlib(GET_, zVAR_NUMBER_, ThemisTime, &varN, NULL_);
  440 + cstatus = CDFlib( SELECT_, zVAR_, varN, GET_, zVAR_MAXREC_, &MaxRec, NULL_);
  441 +
  442 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR0, &par0, NULL_);
  443 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR1, &par1, NULL_);
  444 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR2, &par2, NULL_);
  445 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR3, &par3, NULL_);
  446 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR4, &par4, NULL_);
  447 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR5, &par5, NULL_);
  448 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR6, &par6, NULL_);
  449 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR7, &par7, NULL_);
  450 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR8, &par8, NULL_);
  451 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR9, &par9, NULL_);
  452 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR10, &par10, NULL_);
  453 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR11, &par11, NULL_);
  454 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR12, &par12, NULL_);
  455 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR13, &par13, NULL_);
  456 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR14, &par14, NULL_);
  457 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR15, &par15, NULL_);
  458 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR16, &par16, NULL_);
  459 +
  460 + RecCount = (long)(MaxRec+1);
  461 + printf(" Max Rec %d\n", MaxRec);
  462 +
  463 + if (MaxRec <= 0) exit(0);
  464 +
  465 + value = (double *)malloc(sizeof(double)* RecCount);
  466 + if ((cstatus = CDFlib (SELECT_,
  467 + zVAR_, varN,
  468 + zVAR_RECNUMBER_, RecStart ,
  469 + zVAR_RECCOUNT_, RecCount,
  470 + zVAR_RECINTERVAL_, RecInt,
  471 + zVAR_DIMINDICES_, indices,
  472 + zVAR_DIMCOUNTS_, countsE,
  473 + zVAR_DIMINTERVALS_, intervals,
  474 + GET_, zVAR_HYPERDATA_, value, NULL_) )
  475 + != CDF_OK) cdf_handle_error(cstatus);
  476 +
  477 + for (i = 0; i < RecCount; i++) {
  478 +
  479 +
  480 + UT = Double2DD_Time(value[i]);
  481 +
  482 + if ((First == 0) && (value[i] - DayOld) > TimeGap) {
  483 +
  484 + printf("GAP %f\n",(value[i] - DayOld)/60.0);
  485 + put_double(RecStart, (long)i - RecStart, par0, DeltaTID);
  486 + put_mode(RecStart, (long)i - RecStart, par1, ModeID, ModeSpID);
  487 + put_double(RecStart, (long)i - RecStart, par2, DensID);
  488 + put_double3(RecStart, (long)i - RecStart, par3, VelID);
  489 + put_double3(RecStart,(long)i - RecStart, par4, TempID);
  490 + put_double3(RecStart, (long)i - RecStart, par11, MfTempID);
  491 + put_double3(RecStart, (long)i - RecStart, par14, Flux2ID);
  492 + put_double3(RecStart, (long)i - RecStart, par15, SymmID);
  493 + put_double6(RecStart, (long)i - RecStart, par12, prTenID);
  494 + put_double6(RecStart, (long)i - RecStart, par13, mfTenID);
  495 + put_double(RecStart, (long)i - RecStart, par7, AvTempID);
  496 + put_double(RecStart, (long)i - RecStart, par8, ThVelID);
  497 + put_double(RecStart, (long)i - RecStart, par9, PotID);
  498 + put_double(RecStart, (long)i - RecStart, par16, SymAngID);
  499 + put_spectra(RecStart, (long)i - RecStart, par5, FluxID);
  500 +
  501 + nc_put_vara_text(ncID,StopTimeID, &Start[1], &TimeCount[1], Double2DD_Time(DayOld));
  502 + nc_put_vara_text(ncSpID,StopTimeSpID, &Start[1], &TimeCount[1], Double2DD_Time(DayOld));
  503 +
  504 + if ((status = nc_close(ncID)) != NC_NOERR) nc_handle_error(status);
  505 + if ((status = nc_close(ncSpID)) != NC_NOERR) nc_handle_error(status);
  506 + First = 1;
  507 + RecStart = (long)i;
  508 + UT = Double2DD_Time(value[i]);
  509 + }
  510 +
  511 + dtm = ReadTime(UT);
  512 + if (First == 1) {
  513 + ncdefine(dtm->times);
  514 +
  515 + First = 0;
  516 + Start[0] = 0;
  517 +
  518 + }
  519 + nc_put_vara_text(ncID, TimeID, Start, TimeCount, UT);
  520 + nc_put_vara_text(ncSpID, TimeSpID, Start, TimeCount, UT);
  521 + Start[0]++;
  522 + DayOld = value[i];
  523 +
  524 + }
  525 + free(value);
  526 + nc_put_vara_text(ncID,StopTimeID, &Start[1], &TimeCount[1], UT);
  527 + nc_put_vara_text(ncSpID,StopTimeSpID, &Start[1], &TimeCount[1], UT);
  528 +
  529 +
  530 + put_double(RecStart, RecCount - RecStart, par0, DeltaTID);
  531 + put_mode(RecStart, RecCount - RecStart, par1, ModeID, ModeSpID);
  532 + put_double(RecStart, RecCount - RecStart, par2, DensID);
  533 + put_double3(RecStart, RecCount - RecStart, par3, VelID);
  534 + put_double3(RecStart, RecCount - RecStart, par4, TempID);
  535 + put_double3(RecStart, RecCount - RecStart, par11, MfTempID);
  536 + put_double3(RecStart, RecCount - RecStart, par14, Flux2ID);
  537 + put_double3(RecStart, RecCount - RecStart, par15, SymmID);
  538 + put_double6(RecStart, RecCount - RecStart, par12, prTenID);
  539 + put_double6(RecStart, RecCount - RecStart, par13, mfTenID);
  540 + put_double(RecStart, RecCount - RecStart, par7, AvTempID);
  541 + put_double(RecStart, RecCount - RecStart, par8, ThVelID);
  542 + put_double(RecStart, RecCount - RecStart, par9, PotID);
  543 + put_double(RecStart, RecCount - RecStart, par16, SymAngID);
  544 + put_spectra(RecStart, RecCount - RecStart, par5, FluxID);
  545 +
  546 +/********************Close Files******************/
  547 + if ((cstatus = CDFlib(CLOSE_, CDF_, NULL_)) != CDF_OK)
  548 + cdf_handle_error (cstatus);
  549 + if ((status = nc_close(ncID)) != NC_NOERR) nc_handle_error(status);
  550 + if ((status = nc_close(ncSpID)) != NC_NOERR) nc_handle_error(status);
  551 +}
... ...
src/DECODERS/themis/esafull2nc/CMakeLists.txt 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,26 @@
  1 +
  2 +PROJECT(esafull2nc)
  3 +
  4 +include_directories(
  5 + ${CMAKE_HOME_DIRECTORY}/src/INCLUDE/
  6 + ${NETCDFINCLUDE_DIR}
  7 + ${libcdf_INCLUDE_DIR}
  8 +)
  9 +
  10 +#Configuration de l'exécutable
  11 +file(
  12 + GLOB_RECURSE
  13 + source_files
  14 + ./*
  15 +)
  16 +
  17 +ADD_EXECUTABLE (esafull2nc ${source_files} )
  18 +
  19 +target_link_libraries(
  20 + esafull2nc
  21 + DD_Client
  22 + ${NETCDFLIBRARY}
  23 + ${libcdf_LIBRARIES}
  24 +)
  25 +
  26 +install (TARGETS esafull2nc DESTINATION bin)
... ...
src/DECODERS/themis/esafull2nc/themis_esafull2nc.c 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,659 @@
  1 + /**************************************************************/
  2 + /* THEMIS ESA ION AND ELECTRON MOMENTS CDF -> DD netCDF */
  3 + /* 04.01.2008 */
  4 + /* V 1.1 */
  5 + /* Energy in info file */
  6 + /* New CDF with ALL modes and new params */
  7 + /* 04.01.2008 - 2 files for peir & peer modes */
  8 + /**************************************************************/
  9 +
  10 +#include <stdio.h>
  11 +#include <stdlib.h>
  12 +#include <netcdf.h>
  13 +#include <cdf.h>
  14 +#include <DD.h>
  15 +#include <string.h>
  16 +#include <time.h>
  17 +#include <math.h>
  18 +
  19 +#define TimeGap 1800000.0
  20 +#define Source "themis@cdpp2"
  21 +#define MAX_FILE_NAME_LEN 250 // Max. file name length
  22 +#define MAX_VARS 250 // Max # of VARS in CDF
  23 +
  24 +
  25 +/*************************************
  26 + Global variables and structures
  27 +**************************************/
  28 +long CDFDims, // Number of dimensions in a CDF file
  29 + CDFVars, // Number of variables in a CDF file
  30 + CDFDimSizes[CDF_MAX_DIMS], // Dimension Sizes in a CDF file
  31 + CDFencoding, // Data encoding
  32 + CDFmajority, // Variable majority
  33 + CDFmaxRec, // max Record number
  34 + CDFAttrs; // number of CDF Attributes
  35 +
  36 +
  37 +struct cdfvar { // CDF variable structure
  38 + char name[CDF_VAR_NAME_LEN+1];
  39 + long num; //variable number
  40 + long datatype;
  41 + long numElem; // variable dimensionality
  42 + long recVariance; // variable rec Variance
  43 + long dimVariances[CDF_MAX_DIMS]; // # of data values in dimSizes
  44 +} cdfVar[MAX_VARS];
  45 +
  46 +char mode[4];
  47 +int ncID, ncSpID;
  48 +char ncFile[] = "peif000000000.nc";
  49 +int TimeDimID, TimeLengthID, DataID, Data2ID, FluxDimID;;
  50 +int TimeDimVector[2], DataDimVector[2], Data2DimVector[2], FluxDimVector[2]; // netCDF Dim vectors
  51 +size_t Start[2] = {0L,0L};
  52 +size_t TimeCount[2] = {1L,TIMELENGTH};
  53 +size_t Data1Count[2] = {1L,1L};
  54 +size_t DataCount[2] = {1L,3L};
  55 +size_t Data2Count[2] = {1L,6L};
  56 +size_t FluxCount[2] = {1L,32L};
  57 +
  58 +char Version[]="v01";
  59 +char ThemisID[]="tha\0";
  60 +char ThemisTime[]="tha_peif_time";
  61 +char PAR0[]="tha_peif_delta_time";
  62 +char PAR1[]="tha_peif_mode";
  63 +char PAR2[]="tha_peif_density";
  64 +char PAR3[]="tha_peif_velocity_gse";
  65 +char PAR4[]="tha_peif_t3"; // Diagonilized Temperature
  66 +char PAR5[]="tha_peif_en_eflux";
  67 +char PAR6[]="tha_peif_en_eflux_yaxis";
  68 +char PAR7[]="tha_peif_avgtemp"; // trace of t3 divided by 3
  69 +char PAR8[]="tha_peif_vthermal";
  70 +char PAR9[]="tha_peif_sc_pot";
  71 +char PAR10[]="tha_peif_sc_current";
  72 +char PAR11[]="tha_peif_magt3"; // Temperature in Mag Field frame
  73 +char PAR12[]="tha_peif_ptens"; // Pressure Tensor DSL
  74 +char PAR13[]="tha_peif_mftens"; // Momentum Flux Tensor DSL
  75 +char PAR14[]="tha_peif_flux"; // particle flux
  76 +char PAR15[]="tha_peif_symm"; // Direction of pressure tensor symmetry in DSL
  77 +char PAR16[]="tha_peif_symm_ang"; // Angle between Direction of pressure tensor symmetry and B
  78 +
  79 +
  80 +int StartTimeID, StopTimeID;
  81 +int DeltaTID, DensID, AvTempID, ThVelID, PotID, CurrID, SymAngID; // 1D
  82 +int MfTempID, TempID, ModeID, VelID, Flux2ID, SymmID; // 2D -> 3
  83 +int prTenID, mfTenID; // 2D -> 6
  84 +int EnID, FluxID; // 2D -> 32
  85 +int TimeID; // Time netCDF variable
  86 +
  87 +
  88 +char StartT[TIMELENGTH]; // Start time from data
  89 +char StopT[TIMELENGTH]; // Stop time from data
  90 +/**************************
  91 + Function prototypes
  92 +**************************/
  93 +void usage();
  94 +void cdf_handle_error (CDFstatus);
  95 +void nc_handle_error (int);
  96 +void removeFilepath();
  97 +void removeCDFext();
  98 +void removeVers();
  99 +void ncdefine();
  100 +/*--------------------------------------------------------------------------*/
  101 +void usage()
  102 +{
  103 + printf ("\nDescription:\n");
  104 + printf (" This program converts a themis CDF file into a netCDF file.\n");
  105 + printf ("\n");
  106 + printf ("Usage: esa2nc <CDF file name> <ThemisID> <mode>\n");
  107 + printf ("\n");
  108 + printf ("Example: esa2nc testfile tha peif\n");
  109 + printf ("\n");
  110 + exit(1);
  111 +}
  112 +/*--------------------------------------------------------------------------
  113 + * Handles a CDF error.
  114 + *--------------------------------------------------------------------------*/
  115 +void cdf_handle_error(CDFstatus status)
  116 +{
  117 +
  118 + char message[CDF_STATUSTEXT_LEN+1];
  119 +
  120 + CDFerror (status, message); /* Get the appropriate message */
  121 + fprintf (stderr, "CDF: %s\n", message);
  122 +// exit(1);
  123 +}
  124 +/*--------------------------------------------------------------------------
  125 + * Handles a netCDF error.
  126 + *--------------------------------------------------------------------------*/
  127 +void nc_handle_error(int status)
  128 +{
  129 + fprintf(stderr, "%s\n", nc_strerror(status));
  130 + exit(1);
  131 +}
  132 +/*--------------------------------------------------------------------------
  133 + * Remove the filepath from a file name. *
  134 + * Example:
  135 + * /home/data/mydata.txt => mydata.txt
  136 + *--------------------------------------------------------------------------*/
  137 +void removeFilepath (char *fileName)
  138 +{
  139 + char *ptr;
  140 +
  141 + ptr = strrchr(fileName, '/'); // Unix file path separator
  142 + if (ptr != NULL)
  143 + {
  144 + ptr++;
  145 + strcpy(fileName, ptr);
  146 + }
  147 +}
  148 +/*--------------------------------------------------------------------------
  149 + * Decode CDF File Name *
  150 + *--------------------------------------------------------------------------*/
  151 +void removeVers (char *fileName)
  152 +{
  153 + char *ptr;
  154 + char zero = '\0';
  155 + int i;
  156 +
  157 + for (i = 0; i < 9; i++)
  158 + {
  159 + ptr = strchr(fileName, '_');
  160 + if (ptr != NULL)
  161 + {
  162 + ptr++;
  163 + strcpy(fileName, ptr);
  164 + }
  165 + }
  166 + ptr = strchr(fileName, '_'); //
  167 +
  168 + if (ptr != NULL)
  169 + {
  170 + ptr++;
  171 + strncpy(Version, ptr, 2);
  172 + }
  173 + }
  174 +
  175 + /*--------------------------------------------------------------------------
  176 + * Remove the CDF extention *
  177 + *--------------------------------------------------------------------------*/
  178 +void removeCDFext (char *fileName)
  179 +{
  180 + char *ptr;
  181 + char zero = '\0';
  182 +
  183 + ptr = strchr(fileName, '.');
  184 + if (ptr != NULL)
  185 + strcpy(ptr, &zero);
  186 +}
  187 +/*--------------------------------------------------------------------------
  188 + * NetCDF File Definition *
  189 + *--------------------------------------------------------------------------*/
  190 + void ncdefine(double Time)
  191 + {
  192 + char *s;
  193 + time_t p;
  194 + int status;
  195 + char *STime;
  196 +
  197 +/*********************** Create netCDF file *****************************/
  198 + memcpy(&(ncFile[0]),&(mode[0]), 4);
  199 + STime = Double2DD_Time(Time);
  200 + memcpy(&(ncFile[4]),&(STime[2]), 9);
  201 + if ((status = nc_create(ncFile, NC_CLOBBER, &ncID)) != NC_NOERR)
  202 + nc_handle_error(status);
  203 +/******************netCDF Dimensions *******************************/
  204 + nc_def_dim (ncID, "Time", NC_UNLIMITED, &TimeDimID);
  205 + nc_def_dim (ncID, "TimeLength", TIMELENGTH, &TimeLengthID);
  206 + nc_def_dim (ncID, "Data",3L, &DataID);
  207 + nc_def_dim (ncID, "Data2",6L, &Data2ID);
  208 +
  209 + nc_def_dim (ncID, "Flux",32L, &FluxDimID);
  210 +
  211 +/********************netCDF Variables ******************/
  212 + TimeDimVector[0] = TimeDimID;
  213 + DataDimVector[0] = TimeDimID;
  214 + Data2DimVector[0] = TimeDimID;
  215 + TimeDimVector[1] = TimeLengthID;
  216 + DataDimVector[1] = DataID;
  217 + FluxDimVector[0] = TimeDimID;
  218 + FluxDimVector[1] = FluxDimID;
  219 + Data2DimVector[1] = Data2ID;
  220 +
  221 +//ModeID, DensID, VelID, TempID;
  222 + nc_def_var (ncID, "Time", NC_CHAR, 2, TimeDimVector, &TimeID);
  223 +
  224 + nc_def_var (ncID, "DeltaT", NC_DOUBLE, 1, &TimeDimID, &DeltaTID);
  225 + nc_def_var (ncID, "Mode", NC_FLOAT, 2, DataDimVector, &ModeID);
  226 + nc_def_var (ncID, "Density", NC_DOUBLE, 1, &TimeDimID, &DensID);
  227 + nc_def_var (ncID, "AvTemp", NC_DOUBLE, 1, &TimeDimID, &AvTempID);
  228 + nc_def_var (ncID, "Potential", NC_DOUBLE, 1, &TimeDimID, &PotID);
  229 + nc_def_var (ncID, "Current", NC_DOUBLE, 1, &TimeDimID, &CurrID);
  230 + nc_def_var (ncID, "SymAngle", NC_DOUBLE, 1, &TimeDimID, &SymAngID);
  231 + nc_def_var (ncID, "V_thermal", NC_DOUBLE, 1, &TimeDimID, &ThVelID);
  232 + nc_def_var (ncID, "Velocity", NC_DOUBLE, 2, DataDimVector, &VelID);
  233 + nc_def_var (ncID, "Temperature", NC_DOUBLE, 2, DataDimVector, &TempID);
  234 + nc_def_var (ncID, "B_Temperature", NC_DOUBLE, 2, DataDimVector, &MfTempID);
  235 + nc_def_var (ncID, "Flux_tot", NC_DOUBLE, 2, DataDimVector, &Flux2ID);
  236 + nc_def_var (ncID, "Symm", NC_DOUBLE, 2, DataDimVector, &SymmID);
  237 + nc_def_var (ncID, "tensor_p", NC_DOUBLE, 2, Data2DimVector, &prTenID);
  238 + nc_def_var (ncID, "tensor_mf", NC_DOUBLE, 2, Data2DimVector, &mfTenID);
  239 + nc_def_var (ncID, "Flux", NC_DOUBLE, 2, FluxDimVector, &FluxID);
  240 + // nc_def_var (ncID, "Energy", NC_FLOAT, 2, FluxDimVector, &EnID);
  241 + nc_def_var (ncID, "StartTime",NC_CHAR, 1, &TimeLengthID, &StartTimeID);
  242 + nc_def_var (ncID, "StopTime",NC_CHAR, 1, &TimeLengthID , &StopTimeID);
  243 +
  244 +
  245 +
  246 +
  247 + nc_put_att_text(ncID, NC_GLOBAL, "Themis", 3, ThemisID);
  248 + nc_put_att_text(ncID, NC_GLOBAL, "Source", 12, Source);
  249 + nc_put_att_text(ncID, DensID, "Units", 5, "cm^-3");
  250 + nc_put_att_text(ncID, TempID, "Units", 2, "eV");
  251 + nc_put_att_text(ncID, TempID, "Frame", 2, "FA");
  252 + nc_put_att_text(ncID, TempID, "Order", 16, "perp1,perp2,para");
  253 + nc_put_att_text(ncID, MfTempID, "Units", 2, "eV");
  254 + nc_put_att_text(ncID, MfTempID, "Frame", 2, "FA");
  255 + nc_put_att_text(ncID, MfTempID, "Order", 16, "perp1,perp2,para");
  256 + nc_put_att_text(ncID, AvTempID, "Units", 2, "eV");
  257 + nc_put_att_text(ncID, prTenID, "Units", 2, "eV");
  258 + nc_put_att_text(ncID, prTenID, "Frame", 3, "DSL");
  259 + nc_put_att_text(ncID, prTenID, "Order", 17, "xx,xy,xz,yy,zz,yz");
  260 + nc_put_att_text(ncID, mfTenID, "Units", 2, "eV");
  261 + nc_put_att_text(ncID, mfTenID, "Frame", 3, "DSL");
  262 + nc_put_att_text(ncID, mfTenID, "Order", 17, "xx,xy,xz,yy,zz,yz");
  263 + nc_put_att_text(ncID, Flux2ID, "Units", 9, "#/sec/cm2");
  264 + nc_put_att_text(ncID, PotID, "Units", 1, "V");
  265 + nc_put_att_text(ncID, SymmID, "Frame", 3, "DSL");
  266 + nc_put_att_text(ncID, CurrID, "Units", 7, "Unknown");
  267 + nc_put_att_text(ncID, SymAngID, "Units", 7, "degrees");
  268 + nc_put_att_text(ncID, VelID, "Units", 4, "km/s");
  269 + nc_put_att_text(ncID, ThVelID, "Units", 4, "km/s");
  270 + nc_put_att_text(ncID, VelID, "Frame", 3, "GSE");
  271 + nc_put_att_text(ncID, EnID, "Units", 2, "eV");
  272 + nc_put_att_text(ncID, FluxID, "Units", 17, "eV/(cm^2-s-sr-eV)");
  273 +
  274 + time(&p);
  275 + s = ctime(&p);
  276 + nc_put_att_text(ncID, NC_GLOBAL, "Created", 24, s);
  277 +
  278 + nc_enddef(ncID);
  279 +
  280 + nc_put_vara_text(ncID, StartTimeID, &(Start[1]), &(TimeCount[1]), Double2DD_Time(Time));
  281 +
  282 + }
  283 +/*--------------------------------------------------------------------------*/
  284 +int main(int argc, char *argv[])
  285 +{
  286 + long RecStart = 0, RecCount, RecCountF = 1, RecInt = 1, MaxRec;
  287 + long indices[1] = {0}, counts[1] = {3}, counts2[1] = {6}, countsFlux[1] = {32}, intervals[1] = {1};
  288 + long countsE[1] = {1}, indicesF[2]={0,3}, indicesF2[2]={0,6}, indicesFlux[2] = {0, 32};
  289 + double *value;
  290 + float *value_f;
  291 + size_t numElem;
  292 + long dimN, varN, par0, par1, par2, par3, par4, par5, par6, par7, par8, par9, par10, par11, par12, par13, par14, par15, par16;
  293 + CDFstatus cstatus; // CDF status code
  294 + CDFid id;
  295 + int i, j, status;
  296 + char fileName[MAX_FILE_NAME_LEN];
  297 + dd_tmstr_t *dtm;
  298 + int First = 1;
  299 + double par[3], parr[6], doubleVal, parD[32];
  300 + float parF[32], par_f[3], parr_f[6], floatVal;
  301 + long DayOld;
  302 +
  303 +
  304 + char *UT;
  305 + char data_set[8]="thx_pexx";
  306 +/*-------------------------------- Arguments Decoding ----------------------------------------*/
  307 + if (argc <= 3) usage(); // CDF input file name and THEMIS Number not specified
  308 + else
  309 + {
  310 + strcpy(fileName, argv[1]);
  311 + strncpy(ThemisID,argv[2],3);
  312 + strncpy(mode,argv[3],4);
  313 + }
  314 +
  315 +/*------------------------------------------ CDF Variables Names Updated according to THEMIS Number -------------*/
  316 +
  317 + memcpy(&(data_set[2]),&(ThemisID[2]),1);
  318 + memcpy(&(data_set[6]),&(mode[2]),2);
  319 +
  320 + memcpy(&(ThemisTime[0]),&(data_set[0]),8);
  321 + memcpy(&(PAR0[0]),&(data_set[0]),8);
  322 + memcpy(&(PAR1[0]),&(data_set[0]),8);
  323 + memcpy(&(PAR2[0]),&(data_set[0]),8);
  324 + memcpy(&(PAR3[0]),&(data_set[0]),8);
  325 + memcpy(&(PAR4[0]),&(data_set[0]),8);
  326 + memcpy(&(PAR5[0]),&(data_set[0]),8);
  327 + memcpy(&(PAR6[0]),&(data_set[0]),8);
  328 + memcpy(&(PAR7[0]),&(data_set[0]),8);
  329 + memcpy(&(PAR8[0]),&(data_set[0]),8);
  330 + memcpy(&(PAR9[0]),&(data_set[0]),8);
  331 + memcpy(&(PAR10[0]),&(data_set[0]),8);
  332 + memcpy(&(PAR11[0]),&(data_set[0]),8);
  333 + memcpy(&(PAR12[0]),&(data_set[0]),8);
  334 + memcpy(&(PAR13[0]),&(data_set[0]),8);
  335 + memcpy(&(PAR14[0]),&(data_set[0]),8);
  336 + memcpy(&(PAR15[0]),&(data_set[0]),8);
  337 + memcpy(&(PAR16[0]),&(data_set[0]),8);
  338 +
  339 +/*********************** Open CDF file *****************************/
  340 + if ((cstatus = CDFopen(fileName, &id)) != CDF_OK)
  341 + cdf_handle_error(cstatus);
  342 + printf(" THEMIS %s %s\n", ThemisID, mode);
  343 +
  344 +/*********** treat all vars as zVars with eliminated false dimensionality **********/
  345 +
  346 + if ((cstatus = CDFlib(SELECT_, CDF_zMODE_, zMODEon2, NULL_)) != CDF_OK)
  347 + cdf_handle_error (cstatus);
  348 +
  349 + // Remove the file path (/home/data/mydata => mydata)
  350 + removeFilepath(fileName);
  351 + // Remove Version Number
  352 + removeVers(fileName);
  353 +
  354 + // Remove .cdf extension
  355 + removeCDFext(fileName);
  356 +
  357 +/************************ Get CDF Data ************************************/
  358 +
  359 + cstatus = CDFlib(GET_, zVAR_NUMBER_, ThemisTime, &varN, NULL_);
  360 + cstatus = CDFlib( SELECT_, zVAR_, varN, GET_, zVAR_MAXREC_, &MaxRec, NULL_);
  361 +
  362 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR0, &par0, NULL_);
  363 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR1, &par1, NULL_);
  364 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR2, &par2, NULL_);
  365 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR3, &par3, NULL_);
  366 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR4, &par4, NULL_);
  367 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR5, &par5, NULL_);
  368 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR6, &par6, NULL_);
  369 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR7, &par7, NULL_);
  370 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR8, &par8, NULL_);
  371 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR9, &par9, NULL_);
  372 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR10, &par10, NULL_);
  373 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR11, &par11, NULL_);
  374 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR12, &par12, NULL_);
  375 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR13, &par13, NULL_);
  376 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR14, &par14, NULL_);
  377 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR15, &par15, NULL_);
  378 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR16, &par16, NULL_);
  379 +
  380 + RecCount = (long)(MaxRec+1);
  381 + printf(" Max Rec %d\n", MaxRec);
  382 +
  383 + value = (double *)malloc(sizeof(double)* RecCount);
  384 + if ((cstatus = CDFlib (SELECT_,
  385 + zVAR_, varN,
  386 + zVAR_RECNUMBER_, RecStart ,
  387 + zVAR_RECCOUNT_, RecCount,
  388 + zVAR_RECINTERVAL_, RecInt,
  389 + zVAR_DIMINDICES_, indices,
  390 + zVAR_DIMCOUNTS_, countsE,
  391 + zVAR_DIMINTERVALS_, intervals,
  392 + GET_, zVAR_HYPERDATA_, value, NULL_) )
  393 + != CDF_OK) cdf_handle_error(cstatus);
  394 +
  395 + for (i = 0; i < RecCount; i++) {
  396 + UT = Double2DD_Time(value[i]);
  397 + dtm = ReadTime(UT);
  398 + if (First == 1) {
  399 + ncdefine(dtm->times);
  400 + First = 0;
  401 + }
  402 + nc_put_vara_text(ncID, TimeID, Start, TimeCount, UT);
  403 +
  404 + Start[0]++;
  405 +
  406 + }
  407 + nc_put_vara_text(ncID,StopTimeID, &Start[1], &TimeCount[1], UT);
  408 +
  409 + Start[0] = 0L;
  410 +// deltaT
  411 + if ((cstatus = CDFlib (SELECT_, zVAR_, par0,
  412 + zVAR_RECNUMBER_, RecStart ,
  413 + zVAR_RECCOUNT_, RecCount,
  414 + zVAR_RECINTERVAL_, RecInt,
  415 + zVAR_DIMINDICES_, indices,
  416 + zVAR_DIMCOUNTS_, countsE,
  417 + zVAR_DIMINTERVALS_, intervals,
  418 + GET_, zVAR_HYPERDATA_, value, NULL_))
  419 + != CDF_OK) cdf_handle_error(cstatus);
  420 + nc_put_var_double(ncID, DeltaTID, value);
  421 +
  422 +
  423 + free(value);
  424 + value_f = (float *)malloc(sizeof(float)* RecCount * 3);
  425 +
  426 +
  427 +// Mode
  428 + if ((cstatus = CDFlib (SELECT_, zVAR_, par1,
  429 + zVAR_RECNUMBER_, RecStart ,
  430 + zVAR_RECCOUNT_, RecCount,
  431 + zVAR_RECINTERVAL_, RecInt,
  432 + zVAR_DIMINDICES_, indicesF,
  433 + zVAR_DIMCOUNTS_, counts,
  434 + zVAR_DIMINTERVALS_, intervals,
  435 + GET_, zVAR_HYPERDATA_, value_f, NULL_))
  436 + != CDF_OK) cdf_handle_error(cstatus);
  437 + nc_put_var_float(ncID, ModeID, value_f);
  438 + free(value_f);
  439 +
  440 + value = (double *)malloc(sizeof(double)* RecCount * 3);
  441 + // peif_velocity_gse
  442 + if ((cstatus = CDFlib (SELECT_, zVAR_, par3,
  443 + zVAR_RECNUMBER_, RecStart ,
  444 + zVAR_RECCOUNT_, RecCount,
  445 + zVAR_RECINTERVAL_, RecInt,
  446 + zVAR_DIMINDICES_, indicesF,
  447 + zVAR_DIMCOUNTS_, counts,
  448 + zVAR_DIMINTERVALS_, intervals,
  449 + GET_, zVAR_HYPERDATA_, value, NULL_))
  450 + != CDF_OK) cdf_handle_error(cstatus);
  451 +
  452 + nc_put_var_double(ncID, VelID, value);
  453 +
  454 +// temperature
  455 + if ((cstatus = CDFlib (SELECT_, zVAR_, par4,
  456 + zVAR_RECNUMBER_, RecStart ,
  457 + zVAR_RECCOUNT_, RecCount,
  458 + zVAR_RECINTERVAL_, RecInt,
  459 + zVAR_DIMINDICES_, indicesF,
  460 + zVAR_DIMCOUNTS_, counts,
  461 + zVAR_DIMINTERVALS_, intervals,
  462 + GET_, zVAR_HYPERDATA_, value, NULL_))
  463 + != CDF_OK) cdf_handle_error(cstatus);
  464 + nc_put_var_double(ncID, TempID,value);
  465 +
  466 +// temperature regard to B-field
  467 + if ((cstatus = CDFlib (SELECT_, zVAR_, par11,
  468 + zVAR_RECNUMBER_, RecStart ,
  469 + zVAR_RECCOUNT_, RecCount,
  470 + zVAR_RECINTERVAL_, RecInt,
  471 + zVAR_DIMINDICES_, indicesF,
  472 + zVAR_DIMCOUNTS_, counts,
  473 + zVAR_DIMINTERVALS_, intervals,
  474 + GET_, zVAR_HYPERDATA_, value, NULL_))
  475 + != CDF_OK) cdf_handle_error(cstatus);
  476 +
  477 + nc_put_var_double(ncID, MfTempID, value);
  478 +
  479 +// Flux total
  480 + if ((cstatus = CDFlib (SELECT_, zVAR_, par14,
  481 + zVAR_RECNUMBER_, RecStart ,
  482 + zVAR_RECCOUNT_, RecCount,
  483 + zVAR_RECINTERVAL_, RecInt,
  484 + zVAR_DIMINDICES_, indicesF,
  485 + zVAR_DIMCOUNTS_, counts,
  486 + zVAR_DIMINTERVALS_, intervals,
  487 + GET_, zVAR_HYPERDATA_, value, NULL_))
  488 + != CDF_OK) cdf_handle_error(cstatus);
  489 +
  490 + nc_put_var_double(ncID, Flux2ID, value);
  491 +
  492 +
  493 +// symmetry
  494 + if ((cstatus = CDFlib (SELECT_, zVAR_, par15,
  495 + zVAR_RECNUMBER_, RecStart ,
  496 + zVAR_RECCOUNT_, RecCount,
  497 + zVAR_RECINTERVAL_, RecInt,
  498 + zVAR_DIMINDICES_, indicesF,
  499 + zVAR_DIMCOUNTS_, counts,
  500 + zVAR_DIMINTERVALS_, intervals,
  501 + GET_, zVAR_HYPERDATA_, value, NULL_))
  502 + != CDF_OK) cdf_handle_error(cstatus);
  503 +
  504 +
  505 + nc_put_var_double(ncID, SymmID, value);
  506 +
  507 + free(value);
  508 + value = (double *)malloc(sizeof(double)* RecCount * 6);
  509 +
  510 +//
  511 + if ((cstatus = CDFlib (SELECT_, zVAR_, par12,
  512 + zVAR_RECNUMBER_, RecStart ,
  513 + zVAR_RECCOUNT_, RecCount,
  514 + zVAR_RECINTERVAL_, RecInt,
  515 + zVAR_DIMINDICES_, indicesF2,
  516 + zVAR_DIMCOUNTS_, counts2,
  517 + zVAR_DIMINTERVALS_, intervals,
  518 + GET_, zVAR_HYPERDATA_, value, NULL_))
  519 + != CDF_OK) cdf_handle_error(cstatus);
  520 +
  521 +
  522 + nc_put_var_double(ncID, prTenID, value);
  523 +
  524 +// Pressure Tensor with regard to B-field
  525 + if ((cstatus = CDFlib (SELECT_, zVAR_, par13,
  526 + zVAR_RECNUMBER_, RecStart ,
  527 + zVAR_RECCOUNT_, RecCount,
  528 + zVAR_RECINTERVAL_, RecInt,
  529 + zVAR_DIMINDICES_, indicesF2,
  530 + zVAR_DIMCOUNTS_, counts2,
  531 + zVAR_DIMINTERVALS_, intervals,
  532 + GET_, zVAR_HYPERDATA_, value, NULL_))
  533 + != CDF_OK) cdf_handle_error(cstatus);
  534 +
  535 + nc_put_var_double(ncID, mfTenID, value);
  536 + free(value);
  537 + value = (double *)malloc(sizeof(double)* RecCount);
  538 +
  539 +// Density
  540 + if ((cstatus = CDFlib (SELECT_, zVAR_, par2,
  541 + zVAR_RECNUMBER_, RecStart ,
  542 + zVAR_RECCOUNT_, RecCount,
  543 + zVAR_RECINTERVAL_, RecInt,
  544 + zVAR_DIMINDICES_, indices,
  545 + zVAR_DIMCOUNTS_, countsE,
  546 + zVAR_DIMINTERVALS_, intervals,
  547 + GET_, zVAR_HYPERDATA_, value, NULL_))
  548 + != CDF_OK) cdf_handle_error(cstatus);
  549 +
  550 + nc_put_var_double(ncID, DensID, value);
  551 +// Average Temperature
  552 + if ((cstatus = CDFlib (SELECT_, zVAR_, par7,
  553 + zVAR_RECNUMBER_, RecStart ,
  554 + zVAR_RECCOUNT_, RecCount,
  555 + zVAR_RECINTERVAL_, RecInt,
  556 + zVAR_DIMINDICES_, indices,
  557 + zVAR_DIMCOUNTS_, countsE,
  558 + zVAR_DIMINTERVALS_, intervals,
  559 + GET_, zVAR_HYPERDATA_, value, NULL_))
  560 + != CDF_OK) cdf_handle_error(cstatus);
  561 +
  562 +
  563 + nc_put_var_double(ncID, AvTempID, value);
  564 +// Thermal Velocity
  565 + if ((cstatus = CDFlib (SELECT_, zVAR_, par8,
  566 + zVAR_RECNUMBER_, RecStart ,
  567 + zVAR_RECCOUNT_, RecCount,
  568 + zVAR_RECINTERVAL_, RecInt,
  569 + zVAR_DIMINDICES_, indices,
  570 + zVAR_DIMCOUNTS_, countsE,
  571 + zVAR_DIMINTERVALS_, intervals,
  572 + GET_, zVAR_HYPERDATA_, value, NULL_))
  573 + != CDF_OK) cdf_handle_error(cstatus);
  574 +
  575 +
  576 + nc_put_var_double(ncID, ThVelID, value);
  577 +// Potential
  578 + if ((cstatus = CDFlib (SELECT_, zVAR_, par9,
  579 + zVAR_RECNUMBER_, RecStart,
  580 + zVAR_RECCOUNT_, RecCount,
  581 + zVAR_RECINTERVAL_, RecInt,
  582 + zVAR_DIMINDICES_, indices,
  583 + zVAR_DIMCOUNTS_, countsE,
  584 + zVAR_DIMINTERVALS_, intervals,
  585 + GET_, zVAR_HYPERDATA_, value, NULL_))
  586 + != CDF_OK) cdf_handle_error(cstatus);
  587 +
  588 + nc_put_var_double(ncID, PotID, value);
  589 +// Current
  590 + /* if ((cstatus = CDFlib (SELECT_, zVAR_, par10,
  591 + zVAR_RECNUMBER_, RecStart,
  592 + zVAR_RECCOUNT_, RecCount,
  593 + zVAR_RECINTERVAL_, RecInt,
  594 + zVAR_DIMINDICES_, indices,
  595 + zVAR_DIMCOUNTS_, countsE,
  596 + zVAR_DIMINTERVALS_, intervals,
  597 + GET_, zVAR_HYPERDATA_, value, NULL_))
  598 + != CDF_OK) cdf_handle_error(cstatus);
  599 +
  600 +
  601 + nc_put_var_double(ncID, CurrID, value);
  602 + */
  603 +// Symmery Angle with B
  604 + if ((cstatus = CDFlib (SELECT_, zVAR_, par16,
  605 + zVAR_RECNUMBER_, RecStart ,
  606 + zVAR_RECCOUNT_, RecCount,
  607 + zVAR_RECINTERVAL_, RecInt,
  608 + zVAR_DIMINDICES_, indices,
  609 + zVAR_DIMCOUNTS_, countsE,
  610 + zVAR_DIMINTERVALS_, intervals,
  611 + GET_, zVAR_HYPERDATA_, value, NULL_))
  612 + != CDF_OK) cdf_handle_error(cstatus);
  613 +
  614 +
  615 + nc_put_var_double(ncID, SymAngID, value);
  616 +
  617 + free(value);
  618 + value = (double *)malloc(sizeof(double)* RecCount *32);
  619 +
  620 + if ((cstatus = CDFlib (SELECT_, zVAR_, par5,
  621 + zVAR_RECNUMBER_, RecStart ,
  622 + zVAR_RECCOUNT_, RecCount,
  623 + zVAR_RECINTERVAL_, RecInt,
  624 + zVAR_DIMINDICES_, indicesFlux,
  625 + zVAR_DIMCOUNTS_, countsFlux,
  626 + zVAR_DIMINTERVALS_, intervals,
  627 + GET_, zVAR_HYPERDATA_, value, NULL_))
  628 + != CDF_OK) cdf_handle_error(cstatus);
  629 +
  630 +
  631 + nc_put_var_double(ncID, FluxID, value);
  632 +
  633 + /*
  634 + if ((cstatus = CDFlib (SELECT_, zVAR_, par6,
  635 + zVAR_RECNUMBER_, RecStart ,
  636 + zVAR_RECCOUNT_, RecCountF,
  637 + zVAR_RECINTERVAL_, RecInt,
  638 + zVAR_DIMINDICES_, indicesFlux,
  639 + zVAR_DIMCOUNTS_, countsFlux,
  640 + zVAR_DIMINTERVALS_, intervals,
  641 + GET_, zVAR_HYPERDATA_, parF, NULL_))
  642 + != CDF_OK) cdf_handle_error(cstatus);
  643 + */
  644 + /* if (!isnan(parF[0]))
  645 + nc_put_vara_float(ncID, EnID, Start, FluxCount, parF);
  646 + else nc_put_vara_float(ncID, EnID, Start, FluxCount, FillValueF);
  647 + */ // for (j = 0; j < 32; i++) printf(" %f ", parF[j]);
  648 +
  649 +
  650 + // }
  651 +
  652 +
  653 + free(value);
  654 +/********************Close Files******************/
  655 + if ((cstatus = CDFlib(CLOSE_, CDF_, NULL_)) != CDF_OK)
  656 + cdf_handle_error (cstatus);
  657 + if ((status = nc_close(ncID)) != NC_NOERR) nc_handle_error(status);
  658 +
  659 +}
... ...
src/DECODERS/themis/esamom2nc/CMakeLists.txt 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,26 @@
  1 +
  2 +PROJECT(esamom2nc)
  3 +
  4 +include_directories(
  5 + ${CMAKE_HOME_DIRECTORY}/src/INCLUDE/
  6 + ${NETCDFINCLUDE_DIR}
  7 + ${libcdf_INCLUDE_DIR}
  8 +)
  9 +
  10 +#Configuration de l'exécutable
  11 +file(
  12 + GLOB_RECURSE
  13 + source_files
  14 + ./*
  15 +)
  16 +
  17 +ADD_EXECUTABLE (esamom2nc ${source_files} )
  18 +
  19 +target_link_libraries(
  20 + esamom2nc
  21 + DD_Client
  22 + ${NETCDFLIBRARY}
  23 + ${libcdf_LIBRARIES}
  24 +)
  25 +
  26 +install (TARGETS esamom2nc DESTINATION bin)
... ...
src/DECODERS/themis/esamom2nc/themis_esamom2nc.c 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,456 @@
  1 + /**************************************************************/
  2 + /* THEMIS ESA ION AND ELECTRON MOMENTS CDF -> DD netCDF */
  3 + /* 04.01.2008 */
  4 + /* V 1.1 */
  5 + /* */
  6 + /* New CDF with ALL modes and new params */
  7 + /* */
  8 + /**************************************************************/
  9 +
  10 +#include <stdio.h>
  11 +#include <stdlib.h>
  12 +#include <netcdf.h>
  13 +#include <cdf.h>
  14 +#include <DD.h>
  15 +#include <string.h>
  16 +#include <time.h>
  17 +#include <math.h>
  18 +
  19 +#define TimeGap 1800000.0
  20 +#define Source "themis@cdpp2"
  21 +#define MAX_FILE_NAME_LEN 250 // Max. file name length
  22 +#define MAX_VARS 250 // Max # of VARS in CDF
  23 +
  24 +
  25 +/*************************************
  26 + Global variables and structures
  27 +**************************************/
  28 +long CDFDims, // Number of dimensions in a CDF file
  29 + CDFVars, // Number of variables in a CDF file
  30 + CDFDimSizes[CDF_MAX_DIMS], // Dimension Sizes in a CDF file
  31 + CDFencoding, // Data encoding
  32 + CDFmajority, // Variable majority
  33 + CDFmaxRec, // max Record number
  34 + CDFAttrs; // number of CDF Attributes
  35 +
  36 +
  37 +struct cdfvar { // CDF variable structure
  38 + char name[CDF_VAR_NAME_LEN+1];
  39 + long num; //variable number
  40 + long datatype;
  41 + long numElem; // variable dimensionality
  42 + long recVariance; // variable rec Variance
  43 + long dimVariances[CDF_MAX_DIMS]; // # of data values in dimSizes
  44 +} cdfVar[MAX_VARS];
  45 +
  46 +char mode[4];
  47 +int ncID;
  48 +char ncFile[] = "peim000000000.nc";
  49 +int TimeDimID, TimeLengthID, DataID, Data2ID;
  50 +int TimeDimVector[2], DataDimVector[2], Data2DimVector[2]; // netCDF Dim vectors
  51 +size_t Start[2] = {0L,0L};
  52 +size_t TimeCount[2] = {1L,TIMELENGTH};
  53 +size_t Data1Count[2] = {1L,1L};
  54 +size_t DataCount[2] = {1L,3L};
  55 +size_t Data2Count[2] = {1L,6L};
  56 +
  57 +char Version[]="v01";
  58 +char ThemisID[]="tha\0";
  59 +char ThemisTime[]="tha_peim_time";
  60 +char PAR0[]="tha_peim_density";
  61 +char PAR1[]="tha_peim_ptot";
  62 +char PAR2[]="tha_peim_flux";
  63 +char PAR3[]="tha_peim_mftens"; // Momentum Flux Tensor DSL
  64 +char PAR4[]="tha_peim_eflux";
  65 +char PAR5[]="tha_peim_velocity_gse";
  66 +char PAR6[]="tha_peim_ptens"; // Pressure Tensor DSL
  67 +char PAR7[]="tha_peim_mag";
  68 +char PAR8[]="tha_peim_velocity_mag";
  69 +char PAR9[]="tha_peim_t3_mag"; // Diagonilized Temperature
  70 +char PAR10[]="tha_peim_ptens_mag"; //
  71 +
  72 +
  73 +int StartTimeID, StopTimeID;
  74 +int DeltaTID, DensID, PtotID; // 1D
  75 +int FluxID, EfluxID, VelID, MagID, VelMagID, TempMagID; // 2D -> 3
  76 +int MfTensID, PtensID, PtensMagID ; // 2D -> 6
  77 +
  78 +int TimeID; // Time netCDF variable
  79 +
  80 +
  81 +char StartT[TIMELENGTH]; // Start time from data
  82 +char StopT[TIMELENGTH]; // Stop time from data
  83 +/**************************
  84 + Function prototypes
  85 +**************************/
  86 +void usage();
  87 +void cdf_handle_error (CDFstatus);
  88 +void nc_handle_error (int);
  89 +void ncdefine();
  90 +/*--------------------------------------------------------------------------*/
  91 +void usage()
  92 +{
  93 + printf ("\nDescription:\n");
  94 + printf (" This program converts a themis CDF file into a netCDF file.\n");
  95 + printf ("\n");
  96 + printf ("Usage: esa2nc <CDF file name> <ThemisID>\n");
  97 + printf ("\n");
  98 + printf ("Example: esa2nc testfile tha\n");
  99 + printf ("\n");
  100 + exit(1);
  101 +}
  102 +/*--------------------------------------------------------------------------
  103 + * Handles a CDF error.
  104 + *--------------------------------------------------------------------------*/
  105 +void cdf_handle_error(CDFstatus status)
  106 +{
  107 +
  108 + char message[CDF_STATUSTEXT_LEN+1];
  109 +
  110 + CDFerror (status, message); /* Get the appropriate message */
  111 + fprintf (stderr, "CDF: %s\n", message);
  112 +// exit(1);
  113 +}
  114 +/*--------------------------------------------------------------------------
  115 + * Handles a netCDF error.
  116 + *--------------------------------------------------------------------------*/
  117 +void nc_handle_error(int status)
  118 +{
  119 + fprintf(stderr, "%s\n", nc_strerror(status));
  120 + exit(1);
  121 +}
  122 +
  123 +
  124 +/*--------------------------------------------------------------------------
  125 + * NetCDF File Definition *
  126 + *--------------------------------------------------------------------------*/
  127 + void ncdefine(double Time)
  128 + {
  129 + char *s;
  130 + time_t p;
  131 + int status;
  132 + char *STime;
  133 +
  134 +/*********************** Create netCDF file *****************************/
  135 + memcpy(&(ncFile[0]),&(mode[0]),4);
  136 + STime = Double2DD_Time(Time);
  137 + memcpy(&(ncFile[4]),&(STime[2]), 9);
  138 + if ((status = nc_create(ncFile, NC_CLOBBER, &ncID)) != NC_NOERR)
  139 + nc_handle_error(status);
  140 +/******************netCDF Dimensions *******************************/
  141 + nc_def_dim (ncID, "Time", NC_UNLIMITED, &TimeDimID);
  142 + nc_def_dim (ncID, "TimeLength", TIMELENGTH, &TimeLengthID);
  143 + nc_def_dim (ncID, "Data",3L, &DataID);
  144 + nc_def_dim (ncID, "Data2",6L, &Data2ID);
  145 +
  146 +/********************netCDF Variables ******************/
  147 + TimeDimVector[0] = TimeDimID;
  148 + DataDimVector[0] = TimeDimID;
  149 + Data2DimVector[0] = TimeDimID;
  150 + TimeDimVector[1] = TimeLengthID;
  151 + DataDimVector[1] = DataID;
  152 +
  153 + Data2DimVector[1] = Data2ID;
  154 +
  155 +//ModeID, DensID, VelID, TempID;
  156 + nc_def_var (ncID, "Time", NC_CHAR, 2, TimeDimVector, &TimeID);
  157 + nc_def_var (ncID, "Density", NC_DOUBLE, 1, &TimeDimID, &DensID);
  158 + nc_def_var (ncID, "Ptot", NC_DOUBLE, 1, &TimeDimID, &PtotID);
  159 + nc_def_var (ncID, "Flux", NC_DOUBLE, 2, DataDimVector, &FluxID);
  160 + nc_def_var (ncID, "MfTens", NC_DOUBLE, 2, Data2DimVector, &MfTensID);
  161 + nc_def_var (ncID, "Eflux", NC_DOUBLE, 2, DataDimVector, &EfluxID);
  162 + nc_def_var (ncID, "Velocity", NC_DOUBLE, 2, DataDimVector, &VelID);
  163 + nc_def_var (ncID, "Ptens", NC_DOUBLE, 2, Data2DimVector, &PtensID);
  164 + nc_def_var (ncID, "Mag", NC_DOUBLE, 2, DataDimVector, &MagID);
  165 + nc_def_var (ncID, "VelocityMag", NC_DOUBLE, 2, DataDimVector, &VelMagID);
  166 + nc_def_var (ncID, "TempMag", NC_DOUBLE, 2, DataDimVector, &TempMagID);
  167 + nc_def_var (ncID, "PtensMag", NC_DOUBLE, 2, Data2DimVector, &PtensMagID);
  168 +
  169 + nc_def_var (ncID, "StartTime",NC_CHAR, 1, &TimeLengthID, &StartTimeID);
  170 + nc_def_var (ncID, "StopTime",NC_CHAR, 1, &TimeLengthID , &StopTimeID);
  171 +
  172 +
  173 +
  174 +
  175 + nc_put_att_text(ncID, NC_GLOBAL, "Themis", 3, ThemisID);
  176 + nc_put_att_text(ncID, NC_GLOBAL, "Source", 12, Source);
  177 + nc_put_att_text(ncID, DensID, "Units", 5, "cm^-3");
  178 +
  179 +
  180 + time(&p);
  181 + s = ctime(&p);
  182 + nc_put_att_text(ncID, NC_GLOBAL, "Created", 24, s);
  183 +
  184 + nc_enddef(ncID);
  185 +
  186 + nc_put_vara_text(ncID, StartTimeID, &(Start[1]), &(TimeCount[1]), Double2DD_Time(Time));
  187 + ;
  188 + }
  189 +/*--------------------------------------------------------------------------*/
  190 +int main(int argc, char *argv[])
  191 +{
  192 + long RecStart = 0, RecCount, RecCountF = 1, RecInt = 1, MaxRec;
  193 + long indices[1] = {0}, counts[1] = {3}, counts2[1] = {6}, intervals[1] = {1};
  194 + long countsE[1] = {1}, indicesF[2]={0,3}, indicesF2[2]={0,6};
  195 + double *value;
  196 + float *value_f;
  197 + size_t numElem;
  198 + long dimN, varN, par0, par1, par2, par3, par4, par5, par6, par7, par8, par9, par10;
  199 + CDFstatus cstatus; // CDF status code
  200 + CDFid id;
  201 + int i, j, status;
  202 + char fileName[MAX_FILE_NAME_LEN];
  203 + dd_tmstr_t *dtm;
  204 + int First = 1;
  205 +
  206 + char *UT;
  207 + char data_set[8]="thx_peim";
  208 +/*-------------------------------- Arguments Decoding ----------------------------------------*/
  209 + if (argc <= 2) usage(); // CDF input file name and THEMIS Number not specified
  210 + else
  211 + {
  212 + strcpy(fileName, argv[1]);
  213 + strncpy(ThemisID,argv[2],3);
  214 + strncpy(mode,argv[3],4);
  215 + }
  216 +
  217 +/*------------------------------------------ CDF Variables Names Updated according to THEMIS Number -------------*/
  218 + memcpy(&(data_set[2]),&(ThemisID[2]),1);
  219 + memcpy(&(data_set[6]),&(mode[2]),2);
  220 +
  221 + memcpy(&(ThemisTime[0]),&(data_set[0]),8);
  222 + memcpy(&(PAR0[0]),&(data_set[0]),8);
  223 + memcpy(&(PAR1[0]),&(data_set[0]),8);
  224 + memcpy(&(PAR2[0]),&(data_set[0]),8);
  225 + memcpy(&(PAR3[0]),&(data_set[0]),8);
  226 + memcpy(&(PAR4[0]),&(data_set[0]),8);
  227 + memcpy(&(PAR5[0]),&(data_set[0]),8);
  228 + memcpy(&(PAR6[0]),&(data_set[0]),8);
  229 + memcpy(&(PAR7[0]),&(data_set[0]),8);
  230 + memcpy(&(PAR8[0]),&(data_set[0]),8);
  231 + memcpy(&(PAR9[0]),&(data_set[0]),8);
  232 + memcpy(&(PAR10[0]),&(data_set[0]),8);
  233 +
  234 +/*********************** Open CDF file *****************************/
  235 + if ((cstatus = CDFopen(fileName, &id)) != CDF_OK)
  236 + cdf_handle_error(cstatus);
  237 + printf(" THEMIS %s \n", ThemisID);
  238 +
  239 +/*********** treat all vars as zVars with eliminated false dimensionality **********/
  240 +
  241 + if ((cstatus = CDFlib(SELECT_, CDF_zMODE_, zMODEon2, NULL_)) != CDF_OK)
  242 + cdf_handle_error (cstatus);
  243 +
  244 +
  245 +/************************ Get CDF Data ************************************/
  246 +
  247 + cstatus = CDFlib(GET_, zVAR_NUMBER_, ThemisTime, &varN, NULL_);
  248 + cstatus = CDFlib( SELECT_, zVAR_, varN, GET_, zVAR_MAXREC_, &MaxRec, NULL_);
  249 +
  250 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR0, &par0, NULL_);
  251 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR1, &par1, NULL_);
  252 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR2, &par2, NULL_);
  253 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR3, &par3, NULL_);
  254 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR4, &par4, NULL_);
  255 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR5, &par5, NULL_);
  256 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR6, &par6, NULL_);
  257 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR7, &par7, NULL_);
  258 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR8, &par8, NULL_);
  259 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR9, &par9, NULL_);
  260 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR10, &par10, NULL_);
  261 +
  262 +
  263 + RecCount = (long)(MaxRec+1);
  264 + printf(" Max Rec %d\n", MaxRec);
  265 + if ( RecCount > 0) {
  266 + value = (double *)malloc(sizeof(double)* RecCount);
  267 + if ((cstatus = CDFlib (SELECT_,
  268 + zVAR_, varN,
  269 + zVAR_RECNUMBER_, RecStart ,
  270 + zVAR_RECCOUNT_, RecCount,
  271 + zVAR_RECINTERVAL_, RecInt,
  272 + zVAR_DIMINDICES_, indices,
  273 + zVAR_DIMCOUNTS_, countsE,
  274 + zVAR_DIMINTERVALS_, intervals,
  275 + GET_, zVAR_HYPERDATA_, value, NULL_) )
  276 + != CDF_OK) cdf_handle_error(cstatus);
  277 +
  278 + for (i = 0; i < RecCount; i++) {
  279 + UT = Double2DD_Time(value[i]);
  280 + dtm = ReadTime(UT);
  281 + if (First == 1) {
  282 + ncdefine(dtm->times);
  283 + First = 0;
  284 + }
  285 + nc_put_vara_text(ncID, TimeID, Start, TimeCount, UT);
  286 +
  287 + Start[0]++;
  288 +
  289 + }
  290 + nc_put_vara_text(ncID,StopTimeID, &Start[1], &TimeCount[1], UT);
  291 +
  292 +
  293 +// Density
  294 + if ((cstatus = CDFlib (SELECT_, zVAR_, par0,
  295 + zVAR_RECNUMBER_, RecStart,
  296 + zVAR_RECCOUNT_, RecCount,
  297 + zVAR_RECINTERVAL_, RecInt,
  298 + zVAR_DIMINDICES_, indices,
  299 + zVAR_DIMCOUNTS_, countsE,
  300 + zVAR_DIMINTERVALS_, intervals,
  301 + GET_, zVAR_HYPERDATA_, value, NULL_))
  302 + != CDF_OK) cdf_handle_error(cstatus);
  303 +
  304 + nc_put_var_double(ncID, DensID, value);
  305 +// Ion Total Pressure
  306 + if ((cstatus = CDFlib (SELECT_, zVAR_, par1,
  307 + zVAR_RECNUMBER_, RecStart,
  308 + zVAR_RECCOUNT_, RecCount,
  309 + zVAR_RECINTERVAL_, RecInt,
  310 + zVAR_DIMINDICES_, indices,
  311 + zVAR_DIMCOUNTS_, countsE,
  312 + zVAR_DIMINTERVALS_, intervals,
  313 + GET_, zVAR_HYPERDATA_, value, NULL_))
  314 + != CDF_OK) cdf_handle_error(cstatus);
  315 +
  316 + nc_put_var_double(ncID, PtotID, value);
  317 +
  318 + free(value);
  319 + value = (double *)malloc(sizeof(double)* RecCount * 3);
  320 + // flux
  321 + if ((cstatus = CDFlib (SELECT_, zVAR_, par2,
  322 + zVAR_RECNUMBER_, RecStart ,
  323 + zVAR_RECCOUNT_, RecCount,
  324 + zVAR_RECINTERVAL_, RecInt,
  325 + zVAR_DIMINDICES_, indicesF,
  326 + zVAR_DIMCOUNTS_, counts,
  327 + zVAR_DIMINTERVALS_, intervals,
  328 + GET_, zVAR_HYPERDATA_, value, NULL_))
  329 + != CDF_OK) cdf_handle_error(cstatus);
  330 +
  331 + nc_put_var_double(ncID, FluxID, value);
  332 +
  333 +// Energy Flux
  334 + if ((cstatus = CDFlib (SELECT_, zVAR_, par4,
  335 + zVAR_RECNUMBER_, RecStart ,
  336 + zVAR_RECCOUNT_, RecCount,
  337 + zVAR_RECINTERVAL_, RecInt,
  338 + zVAR_DIMINDICES_, indicesF,
  339 + zVAR_DIMCOUNTS_, counts,
  340 + zVAR_DIMINTERVALS_, intervals,
  341 + GET_, zVAR_HYPERDATA_, value, NULL_))
  342 + != CDF_OK) cdf_handle_error(cstatus);
  343 + nc_put_var_double(ncID, EfluxID,value);
  344 +
  345 +// Velocity GSE
  346 + if ((cstatus = CDFlib (SELECT_, zVAR_, par5,
  347 + zVAR_RECNUMBER_, RecStart ,
  348 + zVAR_RECCOUNT_, RecCount,
  349 + zVAR_RECINTERVAL_, RecInt,
  350 + zVAR_DIMINDICES_, indicesF,
  351 + zVAR_DIMCOUNTS_, counts,
  352 + zVAR_DIMINTERVALS_, intervals,
  353 + GET_, zVAR_HYPERDATA_, value, NULL_))
  354 + != CDF_OK) cdf_handle_error(cstatus);
  355 +
  356 + nc_put_var_double(ncID, VelID, value);
  357 +
  358 +// Magnetic Field Vector DSL
  359 + if ((cstatus = CDFlib (SELECT_, zVAR_, par7,
  360 + zVAR_RECNUMBER_, RecStart ,
  361 + zVAR_RECCOUNT_, RecCount,
  362 + zVAR_RECINTERVAL_, RecInt,
  363 + zVAR_DIMINDICES_, indicesF,
  364 + zVAR_DIMCOUNTS_, counts,
  365 + zVAR_DIMINTERVALS_, intervals,
  366 + GET_, zVAR_HYPERDATA_, value, NULL_))
  367 + != CDF_OK) cdf_handle_error(cstatus);
  368 +
  369 +
  370 + nc_put_var_double(ncID, MagID, value);
  371 +
  372 +// Velocity Mag
  373 + if ((cstatus = CDFlib (SELECT_, zVAR_, par8,
  374 + zVAR_RECNUMBER_, RecStart ,
  375 + zVAR_RECCOUNT_, RecCount,
  376 + zVAR_RECINTERVAL_, RecInt,
  377 + zVAR_DIMINDICES_, indicesF,
  378 + zVAR_DIMCOUNTS_, counts,
  379 + zVAR_DIMINTERVALS_, intervals,
  380 + GET_, zVAR_HYPERDATA_, value, NULL_))
  381 + != CDF_OK) cdf_handle_error(cstatus);
  382 +
  383 +
  384 + nc_put_var_double(ncID, VelMagID, value);
  385 +
  386 + // Temperature Mag
  387 + if ((cstatus = CDFlib (SELECT_, zVAR_, par9,
  388 + zVAR_RECNUMBER_, RecStart ,
  389 + zVAR_RECCOUNT_, RecCount,
  390 + zVAR_RECINTERVAL_, RecInt,
  391 + zVAR_DIMINDICES_, indicesF,
  392 + zVAR_DIMCOUNTS_, counts,
  393 + zVAR_DIMINTERVALS_, intervals,
  394 + GET_, zVAR_HYPERDATA_, value, NULL_))
  395 + != CDF_OK) cdf_handle_error(cstatus);
  396 +
  397 +
  398 + nc_put_var_double(ncID, TempMagID, value);
  399 +
  400 + free(value);
  401 + value = (double *)malloc(sizeof(double)* RecCount * 6);
  402 +
  403 +// Momentum Flux Tensor
  404 + if ((cstatus = CDFlib (SELECT_, zVAR_, par3,
  405 + zVAR_RECNUMBER_, RecStart ,
  406 + zVAR_RECCOUNT_, RecCount,
  407 + zVAR_RECINTERVAL_, RecInt,
  408 + zVAR_DIMINDICES_, indicesF2,
  409 + zVAR_DIMCOUNTS_, counts,
  410 + zVAR_DIMINTERVALS_, intervals,
  411 + GET_, zVAR_HYPERDATA_, value, NULL_))
  412 + != CDF_OK) cdf_handle_error(cstatus);
  413 +
  414 +
  415 + nc_put_var_double(ncID, MfTensID, value);
  416 +
  417 +// Pressure Tensor
  418 + if ((cstatus = CDFlib (SELECT_, zVAR_, par6,
  419 + zVAR_RECNUMBER_, RecStart ,
  420 + zVAR_RECCOUNT_, RecCount,
  421 + zVAR_RECINTERVAL_, RecInt,
  422 + zVAR_DIMINDICES_, indicesF2,
  423 + zVAR_DIMCOUNTS_, counts,
  424 + zVAR_DIMINTERVALS_, intervals,
  425 + GET_, zVAR_HYPERDATA_, value, NULL_))
  426 + != CDF_OK) cdf_handle_error(cstatus);
  427 +
  428 +
  429 + nc_put_var_double(ncID, PtensID, value);
  430 +
  431 +// Pressure Tensor Mag
  432 + if ((cstatus = CDFlib (SELECT_, zVAR_, par10,
  433 + zVAR_RECNUMBER_, RecStart ,
  434 + zVAR_RECCOUNT_, RecCount,
  435 + zVAR_RECINTERVAL_, RecInt,
  436 + zVAR_DIMINDICES_, indicesF2,
  437 + zVAR_DIMCOUNTS_, counts,
  438 + zVAR_DIMINTERVALS_, intervals,
  439 + GET_, zVAR_HYPERDATA_, value, NULL_))
  440 + != CDF_OK) cdf_handle_error(cstatus);
  441 +
  442 +
  443 + nc_put_var_double(ncID, PtensMagID, value);
  444 +
  445 +
  446 +
  447 + free(value);
  448 +/********************Close Files******************/
  449 + if ((status = nc_close(ncID)) != NC_NOERR) nc_handle_error(status);
  450 + }
  451 + if ((cstatus = CDFlib(CLOSE_, CDF_, NULL_)) != CDF_OK)
  452 + cdf_handle_error (cstatus);
  453 +
  454 +
  455 +
  456 +}
... ...
src/DECODERS/themis/fgm2nc/CMakeLists.txt 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,26 @@
  1 +
  2 +PROJECT(fgm2nc)
  3 +
  4 +include_directories(
  5 + ${CMAKE_HOME_DIRECTORY}/src/INCLUDE/
  6 + ${NETCDFINCLUDE_DIR}
  7 + ${libcdf_INCLUDE_DIR}
  8 +)
  9 +
  10 +#Configuration de l'exécutable
  11 +file(
  12 + GLOB_RECURSE
  13 + source_files
  14 + ./*
  15 +)
  16 +
  17 +ADD_EXECUTABLE (fgm2nc ${source_files} )
  18 +
  19 +target_link_libraries(
  20 + fgm2nc
  21 + DD_Client
  22 + ${NETCDFLIBRARY}
  23 + ${libcdf_LIBRARIES}
  24 +)
  25 +
  26 +install (TARGETS fgm2nc DESTINATION bin)
... ...
src/DECODERS/themis/fgm2nc/themis_fgm2nc.c 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,351 @@
  1 + /************************************************************/
  2 + /* THEMIS FGM CDF -> DD netCDF */
  3 +/* NaN -> -1.e31 */
  4 + /* 12.10.2007 */
  5 + /* V 1.0 */
  6 + /***********************************************************/
  7 +#include <stdio.h>
  8 +#include <stdlib.h>
  9 +#include <netcdf.h>
  10 +#include <cdf.h>
  11 +#include <DD.h>
  12 +#include <string.h>
  13 +#include <time.h>
  14 +#include <math.h>
  15 +
  16 +#define TimeGap 1800000.0
  17 +#define Source "themis@cdpp2"
  18 +#define MAX_FILE_NAME_LEN 250 // Max. file name length
  19 +#define MAX_VARS 250 // Max # of VARS in CDF
  20 +
  21 +
  22 +/*************************************
  23 + Global variables and structures
  24 +**************************************/
  25 +long CDFDims, // Number of dimensions in a CDF file
  26 + CDFVars, // Number of variables in a CDF file
  27 + CDFDimSizes[CDF_MAX_DIMS], // Dimension Sizes in a CDF file
  28 + CDFencoding, // Data encoding
  29 + CDFmajority, // Variable majority
  30 + CDFmaxRec, // max Record number
  31 + CDFAttrs; // number of CDF Attributes
  32 +
  33 +
  34 +struct cdfvar { // CDF variable structure
  35 + char name[CDF_VAR_NAME_LEN+1];
  36 + long num; //variable number
  37 + long datatype;
  38 + long numElem; // variable dimensionality
  39 + long recVariance; // variable rec Variance
  40 + long dimVariances[CDF_MAX_DIMS]; // # of data values in dimSizes
  41 +} cdfVar[MAX_VARS];
  42 +
  43 +
  44 +int ncID;
  45 +char ncFile[] = "fgmh000000000.nc";
  46 +int TimeDimID, TimeLengthID, DataID; // ID of netCDF dimensions
  47 +int TimeDimVector[2], DataDimVector[2]; // netCDF Dim vectors
  48 +size_t Start[2] = {0L,0L};
  49 +size_t TimeCount[2] = {1L,TIMELENGTH};
  50 +size_t DataCount[2] = {1L,3L};
  51 +
  52 +char Version[]="v01";
  53 +char ThemisID[]="tha\0";
  54 +char ThemisTime[]="tha_fgh_time";
  55 +char PAR0[]="tha_fgh_gse";
  56 +float FillValue[3] = {-1.e31,-1.e31,-1.e31};
  57 +
  58 +int StartTimeID, StopTimeID;
  59 +int FGMID; // Data netCDF Variables
  60 +int TimeID; // Time netCDF variable
  61 +
  62 +char StartT[TIMELENGTH]; // Start time from data
  63 +char StopT[TIMELENGTH]; // Stop time from data
  64 +/**************************
  65 + Function prototypes
  66 +**************************/
  67 +void usage();
  68 +void cdf_handle_error (CDFstatus);
  69 +void nc_handle_error (int);
  70 +void removeFilepath();
  71 +void removeCDFext();
  72 +void removeVers();
  73 +
  74 +/*--------------------------------------------------------------------------*/
  75 +void usage()
  76 +{
  77 + printf ("\nDescription:\n");
  78 + printf (" This program converts a themis CDF file into a netCDF file.\n");
  79 + printf ("\n");
  80 + printf ("Usage: fgm2nc <CDF file name> <ThemisID> <Resolution>\n");
  81 + printf ("\n");
  82 + printf ("Example: fgm2nc testfile tha h\n");
  83 + printf ("\n");
  84 + exit(1);
  85 +}
  86 +/*--------------------------------------------------------------------------
  87 + * Handles a CDF error.
  88 + *--------------------------------------------------------------------------*/
  89 +void cdf_handle_error(CDFstatus status)
  90 +{
  91 +
  92 + char message[CDF_STATUSTEXT_LEN+1];
  93 +
  94 + CDFerror (status, message); /* Get the appropriate message */
  95 + fprintf (stderr, "%s\n", message);
  96 + exit(1);
  97 +}
  98 +/*--------------------------------------------------------------------------
  99 + * Handles a netCDF error.
  100 + *--------------------------------------------------------------------------*/
  101 +void nc_handle_error(int status)
  102 +{
  103 + fprintf(stderr, "%s\n", nc_strerror(status));
  104 + exit(1);
  105 +}
  106 +/*--------------------------------------------------------------------------
  107 + * Remove the filepath from a file name. *
  108 + * Example:
  109 + * /home/data/mydata.txt => mydata.txt
  110 + *--------------------------------------------------------------------------*/
  111 +void removeFilepath (char *fileName)
  112 +{
  113 + char *ptr;
  114 +
  115 + ptr = strrchr(fileName, '/'); // Unix file path separator
  116 + if (ptr != NULL)
  117 + {
  118 + ptr++;
  119 + strcpy(fileName, ptr);
  120 + }
  121 +}
  122 +/*--------------------------------------------------------------------------
  123 + * Decode CDF File Name *
  124 + *--------------------------------------------------------------------------*/
  125 +void removeVers (char *fileName)
  126 +{
  127 + char *ptr;
  128 + char zero = '\0';
  129 + int i;
  130 +
  131 + for (i = 0; i < 9; i++)
  132 + {
  133 + ptr = strchr(fileName, '_');
  134 + if (ptr != NULL)
  135 + {
  136 + ptr++;
  137 + strcpy(fileName, ptr);
  138 + }
  139 + }
  140 + ptr = strchr(fileName, '_'); //
  141 +
  142 + if (ptr != NULL)
  143 + {
  144 + ptr++;
  145 + strncpy(Version, ptr, 2);
  146 + }
  147 + }
  148 +
  149 + /*--------------------------------------------------------------------------
  150 + * Remove the CDF extention *
  151 + *--------------------------------------------------------------------------*/
  152 +void removeCDFext (char *fileName)
  153 +{
  154 + char *ptr;
  155 + char zero = '\0';
  156 +
  157 + ptr = strchr(fileName, '.');
  158 + if (ptr != NULL)
  159 + strcpy(ptr, &zero);
  160 +}
  161 +/*--------------------------------------------------------------------------
  162 + * NetCDF File Definition *
  163 + *--------------------------------------------------------------------------*/
  164 + void ncdefine(double Time, char *Sampling)
  165 + {
  166 + char *s;
  167 + time_t p;
  168 + int status;
  169 + char *STime;
  170 +
  171 +/*********************** Create netCDF file *****************************/
  172 + STime = Double2DD_Time(Time);
  173 +
  174 + memcpy(&(ncFile[3]),&(Sampling[0]), 1);
  175 + memcpy(&(ncFile[4]),&(STime[2]), 9);
  176 + if ((status = nc_create(ncFile, NC_CLOBBER, &ncID)) != NC_NOERR)
  177 + nc_handle_error(status);
  178 +/******************netCDF Dimensions *******************************/
  179 + nc_def_dim (ncID, "Time", NC_UNLIMITED, &TimeDimID);
  180 + nc_def_dim (ncID, "TimeLength", TIMELENGTH, &TimeLengthID);
  181 + nc_def_dim (ncID, "Data",3L, &DataID);
  182 +
  183 +/********************netCDF Variables ******************/
  184 + TimeDimVector[0] = TimeDimID;
  185 + DataDimVector[0] = TimeDimID;
  186 + TimeDimVector[1] = TimeLengthID;
  187 + DataDimVector[1] = DataID;
  188 +
  189 +//ModeID, DensID, VelID, TempID;
  190 + nc_def_var (ncID, "Time", NC_CHAR, 2, TimeDimVector, &TimeID);
  191 + nc_def_var (ncID, "B", NC_FLOAT, 2, DataDimVector, &FGMID);
  192 + nc_def_var (ncID, "StartTime",NC_CHAR, 1, &TimeLengthID, &StartTimeID);
  193 + nc_def_var (ncID, "StopTime",NC_CHAR, 1, &TimeLengthID , &StopTimeID);
  194 +
  195 + nc_put_att_text(ncID, NC_GLOBAL, "Themis", 3, ThemisID);
  196 + nc_put_att_text(ncID, NC_GLOBAL, "Source", 12, Source);
  197 + nc_put_att_text(ncID, NC_GLOBAL, "Resolution", 1, Sampling);
  198 + // nc_put_att_text(ncID, NC_GLOBAL, "Version", 2, Version);
  199 + nc_put_att_text(ncID, FGMID, "Units", 2, "nT");
  200 + nc_put_att_text(ncID, FGMID, "Frame", 3, "GSE");
  201 +
  202 + time(&p);
  203 + s = ctime(&p);
  204 + nc_put_att_text(ncID, NC_GLOBAL, "Created", 24, s);
  205 + nc_enddef(ncID);
  206 + nc_put_vara_text(ncID, StartTimeID, &(Start[1]), &(TimeCount[1]), Double2DD_Time(Time));
  207 +
  208 + }
  209 +/*--------------------------------------------------------------------------*/
  210 +int main(int argc, char *argv[])
  211 +{
  212 + long RecStart = 0, RecCount, RecCountF = 1, RecInt = 1, MaxRec;
  213 + long indices[1] = {0}, counts[1] = {3}, intervals[1] = {1};
  214 + long countsE[1] = {1}, indicesF[2]={0,3};
  215 + double *value;
  216 + size_t numElem;
  217 + long dimN, varN, par0, par1;
  218 + CDFstatus cstatus; // CDF status code
  219 + CDFid id;
  220 + int i, j, status;
  221 + char fileName[MAX_FILE_NAME_LEN];
  222 + char Sampling[1];
  223 + dd_tmstr_t *dtm;
  224 + int First = 1;
  225 + float par[3];
  226 + long DayOld;
  227 +
  228 + char *UT;
  229 +/*-------------------------------- Arguments Decoding ----------------------------------------*/
  230 + if (argc <= 3) usage(); // CDF input file name and HEMIS Number not specified
  231 + else
  232 + {
  233 + strcpy(fileName, argv[1]);
  234 + strncpy(ThemisID, argv[2], 3);
  235 + strncpy(Sampling, argv[3], 1);
  236 + }
  237 +
  238 +
  239 +/*------------------------------------------ CDF Variables Names Updated according to THEMIS Number -------------*/
  240 +
  241 + memcpy(&(ThemisTime[2]),&(ThemisID[2]),1);
  242 + memcpy(&(PAR0[2]),&(ThemisID[2]),1);
  243 + memcpy(&(ThemisTime[6]),&(Sampling[0]),1);
  244 + memcpy(&(PAR0[6]),&(Sampling[0]),1);
  245 +
  246 +/*********************** Open CDF file *****************************/
  247 + if ((cstatus = CDFopen(fileName, &id)) != CDF_OK)
  248 + cdf_handle_error(cstatus);
  249 + printf(" %s %s\n", argv[2],argv[3]);
  250 +
  251 +/*********** treat all vars as zVars with eliminated false dimensionality **********/
  252 +
  253 + if ((cstatus = CDFlib(SELECT_, CDF_zMODE_, zMODEon2, NULL_)) != CDF_OK)
  254 + cdf_handle_error (cstatus);
  255 +
  256 + // Remove the file path (/home/data/mydata => mydata)
  257 + removeFilepath(fileName);
  258 + // Remove Version Number
  259 + removeVers(fileName);
  260 +
  261 + // Remove .cdf extension
  262 + removeCDFext(fileName);
  263 +
  264 +/************************ Get CDF Data ************************************/
  265 +
  266 + if ((cstatus = CDFlib(GET_, zVAR_NUMBER_, ThemisTime, &varN, NULL_)) != CDF_OK)
  267 + cdf_handle_error(cstatus) ;
  268 + if ((cstatus = CDFlib( SELECT_, zVAR_, varN,
  269 + GET_, zVAR_MAXREC_, &MaxRec, NULL_)) != CDF_OK)
  270 + cdf_handle_error(cstatus) ;
  271 +
  272 +
  273 + if ((cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR0, &par0, NULL_)) != CDF_OK)
  274 + cdf_handle_error(cstatus) ;
  275 +
  276 + if ((cstatus = CDFlib( SELECT_, zVAR_, par0,
  277 + GET_, zVAR_DIMSIZES_, CDFDimSizes, NULL_)) != CDF_OK)
  278 + cdf_handle_error (cstatus) ;
  279 +
  280 +
  281 + RecCount = (long)(MaxRec+1);
  282 + printf(" Max Rec %d\n", MaxRec);
  283 + if (MaxRec > 1) {
  284 + value = (double *)malloc(sizeof(double)* RecCount);
  285 + if ((cstatus = CDFlib (SELECT_,
  286 + zVAR_, varN,
  287 + zVAR_RECNUMBER_, RecStart ,
  288 + zVAR_RECCOUNT_, RecCount,
  289 + zVAR_RECINTERVAL_, RecInt,
  290 + zVAR_DIMINDICES_, indices,
  291 + zVAR_DIMCOUNTS_, countsE,
  292 + zVAR_DIMINTERVALS_, intervals,
  293 + GET_, zVAR_HYPERDATA_, value, NULL_) )
  294 + != CDF_OK) cdf_handle_error (cstatus);
  295 +
  296 + for (i = 0; i < RecCount; i++)
  297 + {
  298 +
  299 + UT = Double2DD_Time(value[i]);
  300 + dtm = ReadTime(UT);
  301 +
  302 + if (i > 0 && (value[i]-value[i-1]) > TimeGap)
  303 + {
  304 + printf(" !!! Time GAP -> %f min\n", (value[i]-value[i-1])/60.0);
  305 + nc_put_vara_text(ncID,StopTimeID,&Start[1],&TimeCount[1], Double2DD_Time(dtm->times));
  306 + if ((status = nc_close(ncID)) != NC_NOERR) nc_handle_error(status);
  307 + }
  308 +
  309 + if (First == 1)
  310 + {
  311 + ncdefine(dtm->times, Sampling);
  312 + First = 0;
  313 + DayOld = dtm->day;
  314 + }
  315 + if (i > 0 && (value[i]-value[i-1]) > TimeGap)
  316 + {
  317 + ncdefine(dtm->times, Sampling);
  318 + Start[0] = 0L;
  319 + }
  320 + nc_put_vara_text(ncID, TimeID, Start, TimeCount, Double2DD_Time(dtm->times));
  321 +
  322 +
  323 + RecStart = (long)i;
  324 +
  325 + if ((cstatus = CDFlib (SELECT_, zVAR_, par0,
  326 + zVAR_RECNUMBER_, RecStart ,
  327 + zVAR_RECCOUNT_, RecCountF,
  328 + zVAR_RECINTERVAL_, RecInt,
  329 + zVAR_DIMINDICES_, indicesF,
  330 + zVAR_DIMCOUNTS_, counts,
  331 + zVAR_DIMINTERVALS_, intervals,
  332 + GET_, zVAR_HYPERDATA_, par, NULL_))
  333 + != CDF_OK) cdf_handle_error(cstatus);
  334 + if (!isnan(par[0]))
  335 + nc_put_vara_float(ncID, FGMID, Start, DataCount, par);
  336 + else nc_put_vara_float(ncID, FGMID, Start, DataCount, FillValue);
  337 +
  338 +
  339 + Start[0]++;
  340 + DayOld = dtm->day;
  341 + }
  342 + nc_put_vara_text(ncID,StopTimeID,&Start[1],&TimeCount[1], Double2DD_Time(dtm->times));
  343 + free(value);
  344 +
  345 + if ((status = nc_close(ncID)) != NC_NOERR) nc_handle_error(status);
  346 + }
  347 +/********************Close Files******************/
  348 + if ((cstatus = CDFlib(CLOSE_, CDF_, NULL_)) != CDF_OK)
  349 + cdf_handle_error (cstatus);
  350 +
  351 +}
... ...
src/DECODERS/themis/sst2nc/CMakeLists.txt 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,26 @@
  1 +
  2 +PROJECT(sst2nc)
  3 +
  4 +include_directories(
  5 + ${CMAKE_HOME_DIRECTORY}/src/INCLUDE/
  6 + ${NETCDFINCLUDE_DIR}
  7 + ${libcdf_INCLUDE_DIR}
  8 +)
  9 +
  10 +#Configuration de l'exécutable
  11 +file(
  12 + GLOB_RECURSE
  13 + source_files
  14 + ./*
  15 +)
  16 +
  17 +ADD_EXECUTABLE (sst2nc ${source_files} )
  18 +
  19 +target_link_libraries(
  20 + sst2nc
  21 + DD_Client
  22 + ${NETCDFLIBRARY}
  23 + ${libcdf_LIBRARIES}
  24 +)
  25 +
  26 +install (TARGETS sst2nc DESTINATION bin)
... ...
src/DECODERS/themis/sst2nc/themis_sst2nc.c 0 → 100644
  Diff comments   View file @bd9dfce
... ... @@ -0,0 +1,363 @@
  1 + /**************************************************************/
  2 + /* THEMIS ESA ION AND ELECTRON MOMENTS CDF -> DD netCDF */
  3 + /* 04.01.2008 */
  4 + /* V 1.1 */
  5 + /* Energy in info file */
  6 + /* New CDF with ALL modes and new params */
  7 + /* 04.01.2008 - 2 files for peir & peer modes */
  8 + /**************************************************************/
  9 +
  10 +#include <stdio.h>
  11 +#include <stdlib.h>
  12 +#include <netcdf.h>
  13 +#include <cdf.h>
  14 +#include <DD.h>
  15 +#include <string.h>
  16 +#include <time.h>
  17 +#include <math.h>
  18 +
  19 +#define TimeGap 3600.0
  20 +#define Source "themis@cdpp2"
  21 +#define MAX_FILE_NAME_LEN 250 // Max. file name length
  22 +#define MAX_VARS 250 // Max # of VARS in CDF
  23 +
  24 +
  25 +/*************************************
  26 + Global variables and structures
  27 +**************************************/
  28 +long CDFDims, // Number of dimensions in a CDF file
  29 + CDFVars, // Number of variables in a CDF file
  30 + CDFDimSizes[CDF_MAX_DIMS], // Dimension Sizes in a CDF file
  31 + CDFencoding, // Data encoding
  32 + CDFmajority, // Variable majority
  33 + CDFmaxRec, // max Record number
  34 + CDFAttrs; // number of CDF Attributes
  35 +
  36 +
  37 +struct cdfvar { // CDF variable structure
  38 + char name[CDF_VAR_NAME_LEN+1];
  39 + long num; //variable number
  40 + long datatype;
  41 + long numElem; // variable dimensionality
  42 + long recVariance; // variable rec Variance
  43 + long dimVariances[CDF_MAX_DIMS]; // # of data values in dimSizes
  44 +} cdfVar[MAX_VARS];
  45 +
  46 +char mode[4];
  47 +int ncID;
  48 +char ncFile[] = "psif000000000.nc";
  49 +int TimeDimID, TimeLengthID, FluxDimID;
  50 +int TimeDimVector[2], FluxDimVector[2]; // netCDF Dim vectors
  51 +
  52 +size_t Start[2] = {0L,0L};
  53 +size_t TimeCount[2] = {1L,TIMELENGTH};
  54 +size_t FluxCount[2] = {1L,16L};
  55 +
  56 +CDFstatus cstatus; // CDF status code
  57 +
  58 +char Version[]="v01";
  59 +char ThemisID[]="tha\0";
  60 +char ThemisTime[]="tha_psif_en_eflux_time";
  61 +char PAR0[]="tha_psif_en_eflux_delta_time";
  62 +char PAR1[]="tha_psif_en_eflux_mode";
  63 +char PAR2[]="tha_psif_en_eflux";
  64 +
  65 +int StartTimeID, StopTimeID;
  66 +int StartTimeSpID, StopTimeSpID;
  67 +int DeltaTID, DensID, AvTempID, ThVelID, PotID, CurrID, SymAngID; // 1D
  68 +int MfTempID, TempID, ModeID, ModeSpID, VelID, Flux2ID, SymmID; // 2D -> 3
  69 +int prTenID, mfTenID; // 2D -> 6
  70 +int FluxID; // 2D -> 32
  71 +int TimeID; // Time netCDF variable
  72 +int TimeSpID;
  73 +
  74 +char StartT[TIMELENGTH]; // Start time from data
  75 +char StopT[TIMELENGTH]; // Stop time from data
  76 +/**************************
  77 + Function prototypes
  78 +**************************/
  79 +void usage();
  80 +void cdf_handle_error (CDFstatus);
  81 +void nc_handle_error (int);
  82 +void removeFilepath();
  83 +void removeCDFext();
  84 +void removeVers();
  85 +void ncdefine();
  86 +/*--------------------------------------------------------------------------*/
  87 +void usage()
  88 +{
  89 + printf ("\nDescription:\n");
  90 + printf (" This program converts a themis CDF file into a netCDF file.\n");
  91 + printf ("\n");
  92 + printf ("Usage: esa2nc <CDF file name> <ThemisID> <mode>\n");
  93 + printf ("\n");
  94 + printf ("Example: esa2nc testfile tha peif\n");
  95 + printf ("\n");
  96 + exit(1);
  97 +}
  98 +/*--------------------------------------------------------------------------
  99 + * Handles a CDF error.
  100 + *--------------------------------------------------------------------------*/
  101 +void cdf_handle_error(CDFstatus status)
  102 +{
  103 +
  104 + char message[CDF_STATUSTEXT_LEN+1];
  105 +
  106 + CDFerror (status, message); /* Get the appropriate message */
  107 + fprintf (stderr, "CDF: %s\n", message);
  108 +// exit(1);
  109 +}
  110 +/*--------------------------------------------------------------------------
  111 + * Handles a netCDF error.
  112 + *--------------------------------------------------------------------------*/
  113 +void nc_handle_error(int status)
  114 +{
  115 + fprintf(stderr, "%s\n", nc_strerror(status));
  116 + exit(1);
  117 +}
  118 +
  119 +/*--------------------------------------------------------------------------
  120 + * NetCDF File Definition *
  121 + *--------------------------------------------------------------------------*/
  122 + void ncdefine(double Time)
  123 + {
  124 + char *s;
  125 + time_t p;
  126 + int status;
  127 + char *STime;
  128 +
  129 +/*********************** Create netCDF file *****************************/
  130 + memcpy(&(ncFile[0]),&(mode[0]), 4);
  131 + STime = Double2DD_Time(Time);
  132 + memcpy(&(ncFile[4]),&(STime[2]), 9);
  133 + if ((status = nc_create(ncFile, NC_CLOBBER, &ncID)) != NC_NOERR)
  134 + nc_handle_error(status);
  135 +/******************netCDF Dimensions *******************************/
  136 + nc_def_dim (ncID, "Time", NC_UNLIMITED, &TimeDimID);
  137 + nc_def_dim (ncID, "TimeLength", TIMELENGTH, &TimeLengthID);
  138 + nc_def_dim (ncID, "Flux", 16L, &FluxDimID);
  139 +
  140 +/********************netCDF Variables ******************/
  141 + TimeDimVector[0] = TimeDimID;
  142 + TimeDimVector[1] = TimeLengthID;
  143 + FluxDimVector[0] = TimeDimID;
  144 + FluxDimVector[1] = FluxDimID;
  145 +//
  146 + nc_def_var (ncID, "Time", NC_CHAR, 2, TimeDimVector, &TimeID);
  147 +
  148 + nc_def_var (ncID, "DeltaT", NC_DOUBLE, 1, &TimeDimID, &DeltaTID);
  149 + nc_def_var (ncID, "Mode", NC_FLOAT, 2, &TimeDimID, &ModeID);
  150 + nc_def_var (ncID, "Flux", NC_DOUBLE, 2, FluxDimVector, &FluxID);
  151 +
  152 + nc_def_var (ncID, "StartTime",NC_CHAR, 1, &TimeLengthID, &StartTimeID);
  153 + nc_def_var (ncID, "StopTime",NC_CHAR, 1, &TimeLengthID , &StopTimeID);
  154 +
  155 +
  156 +
  157 +
  158 + nc_put_att_text(ncID, NC_GLOBAL, "Themis", 3, ThemisID);
  159 + nc_put_att_text(ncID, NC_GLOBAL, "Source", 12, Source);
  160 + nc_put_att_text(ncID, FluxID, "Units", 17, "eV/(cm^2-s-sr-eV)");
  161 +
  162 +
  163 + time(&p);
  164 + s = ctime(&p);
  165 + nc_put_att_text(ncID, NC_GLOBAL, "Created", 24, s);
  166 +
  167 + status = nc_enddef(ncID);
  168 +
  169 +
  170 + nc_put_vara_text(ncID, StartTimeID, &(Start[1]), &(TimeCount[1]), Double2DD_Time(Time));
  171 +
  172 +
  173 + }
  174 +
  175 + void put_double(RecStart, RecCount, ParCDF, ParNC) {
  176 +
  177 +
  178 + long RecInt = 1;
  179 + long indices[1] = {0}, intervals[1] = {1}, counts[1] = {1};
  180 +
  181 + double *value;
  182 +
  183 + value = (double *)malloc(sizeof(double)*RecCount);
  184 + if ((cstatus = CDFlib (SELECT_, zVAR_, ParCDF,
  185 + zVAR_RECNUMBER_, RecStart ,
  186 + zVAR_RECCOUNT_, RecCount,
  187 + zVAR_RECINTERVAL_, RecInt,
  188 + zVAR_DIMINDICES_, indices,
  189 + zVAR_DIMCOUNTS_, counts,
  190 + zVAR_DIMINTERVALS_, intervals,
  191 + GET_, zVAR_HYPERDATA_, value, NULL_))
  192 + != CDF_OK) cdf_handle_error(cstatus);
  193 + nc_put_var_double(ncID, ParNC, value);
  194 +
  195 + free(value);
  196 + }
  197 +
  198 +
  199 + void put_mode(RecStart, RecCount, ParCDF, ParNC) {
  200 +
  201 + float *value;
  202 + long indices[2] = {0,3}, intervals[1] = {1}, counts[1] = {3};
  203 + long RecInt = 1;
  204 +
  205 + value = (float *)malloc(sizeof(float) * RecCount *3);
  206 + if ((cstatus = CDFlib (SELECT_, zVAR_, ParCDF,
  207 + zVAR_RECNUMBER_, RecStart ,
  208 + zVAR_RECCOUNT_, RecCount,
  209 + zVAR_RECINTERVAL_, RecInt,
  210 + zVAR_DIMINDICES_, indices,
  211 + zVAR_DIMCOUNTS_, counts,
  212 + zVAR_DIMINTERVALS_, intervals,
  213 + GET_, zVAR_HYPERDATA_, value, NULL_))
  214 + != CDF_OK) cdf_handle_error(cstatus);
  215 + nc_put_var_float(ncID, ParNC, value);
  216 +
  217 + free(value);
  218 + }
  219 +
  220 +void put_spectra(RecStart, RecCount, ParCDF, ParNC) {
  221 +
  222 + double *value;
  223 + long indices[2] = {0,16}, intervals[1] = {1}, counts[1] = {16};
  224 + long RecInt = 1;
  225 +
  226 + value = (double *)malloc(sizeof(double)*RecCount*16);
  227 + if ((cstatus = CDFlib (SELECT_, zVAR_, ParCDF,
  228 + zVAR_RECNUMBER_, RecStart ,
  229 + zVAR_RECCOUNT_, RecCount,
  230 + zVAR_RECINTERVAL_, RecInt,
  231 + zVAR_DIMINDICES_, indices,
  232 + zVAR_DIMCOUNTS_, counts,
  233 + zVAR_DIMINTERVALS_, intervals,
  234 + GET_, zVAR_HYPERDATA_, value, NULL_))
  235 + != CDF_OK) cdf_handle_error(cstatus);
  236 + nc_put_var_double(ncID, ParNC, value);
  237 + free(value);
  238 + }
  239 +/*--------------------------------------------------------------------------*/
  240 +int main(int argc, char *argv[])
  241 +{
  242 + long RecStart = 0, RecCount, RecCountF = 1, RecInt = 1, MaxRec;
  243 + long indices[1] = {0}, counts[1] = {3}, counts2[1] = {6}, countsFlux[1] = {32}, intervals[1] = {1};
  244 + long countsE[1] = {1}, indicesF[2]={0,3}, indicesF2[2]={0,6}, indicesFlux[2] = {0, 32};
  245 + double *value;
  246 + float *value_f;
  247 + size_t numElem;
  248 + long dimN, varN, par0, par1, par2;
  249 +
  250 + CDFid id;
  251 + int i, j, status;
  252 + char fileName[MAX_FILE_NAME_LEN];
  253 + dd_tmstr_t *dtm;
  254 + int First = 1;
  255 + double DayOld;
  256 +
  257 +
  258 + char *UT;
  259 + char data_set[8]="thx_psxf";
  260 +/*-------------------------------- Arguments Decoding ----------------------------------------*/
  261 + if (argc <= 3) usage(); // CDF input file name and THEMIS Number not specified
  262 + else
  263 + {
  264 + strcpy(fileName, argv[1]);
  265 + strncpy(ThemisID,argv[2],3);
  266 + strncpy(mode,argv[3],4);
  267 + }
  268 +
  269 +/*------------------------------------------ CDF Variables Names Updated according to THEMIS Number -------------*/
  270 +
  271 + memcpy(&(data_set[2]),&(ThemisID[2]),1);
  272 + memcpy(&(data_set[6]),&(mode[2]),2);
  273 +
  274 + memcpy(&(ThemisTime[0]),&(data_set[0]),8);
  275 + memcpy(&(PAR0[0]),&(data_set[0]),8);
  276 + memcpy(&(PAR1[0]),&(data_set[0]),8);
  277 + memcpy(&(PAR2[0]),&(data_set[0]),8);
  278 +
  279 +
  280 +/*********************** Open CDF file *****************************/
  281 + if ((cstatus = CDFopen(fileName, &id)) != CDF_OK)
  282 + cdf_handle_error(cstatus);
  283 + printf(" THEMIS %s %s\n", ThemisID, mode);
  284 +
  285 +/*********** treat all vars as zVars with eliminated false dimensionality **********/
  286 +
  287 + if ((cstatus = CDFlib(SELECT_, CDF_zMODE_, zMODEon2, NULL_)) != CDF_OK)
  288 + cdf_handle_error (cstatus);
  289 +
  290 +/************************ Get CDF Data ************************************/
  291 +
  292 + cstatus = CDFlib(GET_, zVAR_NUMBER_, ThemisTime, &varN, NULL_);
  293 + cstatus = CDFlib( SELECT_, zVAR_, varN, GET_, zVAR_MAXREC_, &MaxRec, NULL_);
  294 +
  295 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR0, &par0, NULL_);
  296 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR1, &par1, NULL_);
  297 + cstatus = CDFlib(GET_, zVAR_NUMBER_, PAR2, &par2, NULL_);
  298 +
  299 +
  300 + RecCount = (long)(MaxRec+1);
  301 + printf(" Max Rec %d\n", MaxRec);
  302 +
  303 + value = (double *)malloc(sizeof(double)* RecCount);
  304 + if ((cstatus = CDFlib (SELECT_,
  305 + zVAR_, varN,
  306 + zVAR_RECNUMBER_, RecStart ,
  307 + zVAR_RECCOUNT_, RecCount,
  308 + zVAR_RECINTERVAL_, RecInt,
  309 + zVAR_DIMINDICES_, indices,
  310 + zVAR_DIMCOUNTS_, countsE,
  311 + zVAR_DIMINTERVALS_, intervals,
  312 + GET_, zVAR_HYPERDATA_, value, NULL_) )
  313 + != CDF_OK) cdf_handle_error(cstatus);
  314 +
  315 + for (i = 0; i < RecCount; i++) {
  316 +
  317 +
  318 + UT = Double2DD_Time(value[i]);
  319 +
  320 + if ((First == 0) && (value[i] - DayOld) > TimeGap) {
  321 +
  322 + printf("GAP %f\n",(value[i] - DayOld)/60.0);
  323 + // put_double(RecStart, (long)i - RecStart, par0, DeltaTID);
  324 + // put_mode(RecStart, (long)i - RecStart, par1, ModeID, ModeSpID);
  325 + put_spectra(RecStart, (long)i - RecStart, par2, FluxID);
  326 +
  327 + nc_put_vara_text(ncID,StopTimeID, &Start[1], &TimeCount[1], Double2DD_Time(DayOld));
  328 +
  329 + if ((status = nc_close(ncID)) != NC_NOERR) nc_handle_error(status);
  330 +
  331 + First = 1;
  332 + RecStart = (long)i;
  333 + UT = Double2DD_Time(value[i]);
  334 + }
  335 +
  336 + dtm = ReadTime(UT);
  337 + if (First == 1) {
  338 + ncdefine(dtm->times);
  339 +
  340 + First = 0;
  341 + Start[0] = 0;
  342 +
  343 + }
  344 + nc_put_vara_text(ncID, TimeID, Start, TimeCount, UT);
  345 +
  346 + Start[0]++;
  347 + DayOld = value[i];
  348 +
  349 + }
  350 + free(value);
  351 + nc_put_vara_text(ncID,StopTimeID, &Start[1], &TimeCount[1], UT);
  352 +
  353 +
  354 + // put_double(RecStart, RecCount - RecStart, par0, DeltaTID);
  355 + // put_mode(RecStart, RecCount - RecStart, par1, ModeID, ModeSpID);
  356 + put_spectra(RecStart, RecCount - RecStart, par2, FluxID);
  357 +
  358 +/********************Close Files******************/
  359 + if ((cstatus = CDFlib(CLOSE_, CDF_, NULL_)) != CDF_OK)
  360 + cdf_handle_error (cstatus);
  361 + if ((status = nc_close(ncID)) != NC_NOERR) nc_handle_error(status);
  362 +
  363 +}
... ...
src/INCLUDE/DD_comm.h
  Diff comments   View file @bd9dfce
... ... @@ -115,8 +115,8 @@
115 115 // String length is counted as 4B + N + r (to completed to 4 bytes)
116 116  
117 117 /*------------ List of External Call of DD_Server and ERRORS -------------------*/
118   -#define ADDDATASETCALL "php %s/createVI.php %s %s %s" /* Format to call to create new VI */
119   -#define GETNEWDATACALL "php %s/getData%s.php %s %s %s %s &" /* Format to call to get new data */
  118 +#define ADDDATASETCALL "php %s/CALLEXT/createVI.php %s %s %s" /* Format to call to create new VI */
  119 +#define GETNEWDATACALL "php %s/CALLEXT/getData%s.php %s %s %s %s &" /* Format to call to get new data */
120 120 #define NOPHP 32512
121 121 #define NOSCRIPT 256
122 122 #define PHPOK 0
... ...