323 | | |
324 | | The humidity(i) and temp(i) data are associated with the coordinate values time(i), lat(i), lon(i), and optionally alt(i). There must be a variable (of any type) with the observation dimension as its outer dimension, with a standard_name attribute "'''station_id'''", whose values uniquely identify the station. All observations with the same station_id are assumed to belong to that station. |
325 | | |
326 | | In some observational networks, station location may change. However, for station feature types this should be infrequent and not overly consequential. In principle, a new station identifier should be assigned. In practice, occasional and small adjustments to station location may not matter for typical processing of data, and generic clients may not detect these changes, eg they may assume that the first location encountered is valid for all other observations at the same station. Specialized clients, of course, may be more careful in examining station location data, and nothing prevents data providers from using a factored representation as in 5.8.2.1, 5.8.2.2, and 5.8.2.3, and also putting location information into the observation record, as in the flattened representation in 5.8.2.5. |
327 | | |
328 | | == 5.8.3 Trajectory Data == |
| 328 | The humidity(i) and temp(i) data are associated with the coordinate values time(i), lat(i), lon(i), and optionally alt(i). All observations with the same station_id are assumed to belong to that station. |
| 329 | |
| 330 | In some observational networks, station location may change. However, for station feature types this should be infrequent and not overly consequential. In principle, a new station identifier should be assigned. In practice, occasional and small adjustments to station location may not matter for typical processing of data for visualization, and generic clients may not detect these changes, eg they may assume that the first location encountered is valid for all other observations at the same station. Specialized clients, of course, may be more careful in examining station location data, and nothing prevents data providers from using a factored representation as in 9.3.1, 9.3.2, and 9.3.3, and also putting location information into the observation record, as in the flattened representation in 9.3.5. |
| 331 | |
| 332 | |
| 333 | == 9.4 Trajectory Data == |
332 | | === 5.8.3.1 Single Trajectory === |
333 | | |
334 | | When a single trajectory is stored in a file, the representation is straightforward: |
335 | | |
336 | | |
337 | | {{{ |
338 | | dimensions: |
339 | | time = 1000 ; |
340 | | |
341 | | variables: |
| 337 | Some assumption are common to all trajectory representations: |
| 338 | |
| 339 | * There must always be a variable (of any type) with standard_name attribute "'''trajectory_id'''", whose values uniquely identify the trajectory. |
| 340 | * The outer dimension of the trajectory_id variable is the 'trajectory dimension'. |
| 341 | * All variables that have the trajectory dimension as their single dimension are considered to be information about that trajectory |
| 342 | * The trajectory_id variable may use missing values. This allows one to reserve more space than is needed. |
| 343 | |
| 344 | === 9.4.1 Multidimensional representation === |
| 345 | |
| 346 | When storing multiple trajectories in the same file, and the number of observations in each trajectory is the same, one can use the multidimensional representation: |
| 347 | |
| 348 | {{{ |
| 349 | dimensions: |
| 350 | obs = 1000 ; |
| 351 | trajectory = 77 ; |
| 352 | |
| 353 | variables: |
| 354 | char trajectory(trajectory, name_strlen) ; |
| 355 | trajectory:standard_name = "station_id"; |
| 356 | trajectory:long_name = "trajectory name" ; |
| 357 | int trajectory_info(trajectory) ; |
| 358 | trajectory_info:long_name = "some kind of trajectory info" |
| 359 | |
| 360 | double time(trajectory, obs) ; |
| 361 | time:long_name = "time" ; |
| 362 | time:units = "days since 1970-01-01 00:00:00" ; |
| 363 | float lon(trajectory, obs) ; |
| 364 | lon:long_name = "longitude" ; |
| 365 | lon:units = "degrees_east" ; |
| 366 | float lat(trajectory, obs) ; |
| 367 | lat:long_name = "latitude" ; |
| 368 | lat:units = "degrees_north" ; |
| 369 | |
| 370 | float z(trajectory, obs) ; |
| 371 | z:long_name = "height above mean sea level" ; |
| 372 | z:units = "km" ; |
| 373 | z:positive = "up" ; |
| 374 | |
| 375 | float O3(trajectory, obs) ; |
| 376 | O3:long_name = "ozone concentration" ; |
| 377 | O3:units = "1e-9" ; |
| 378 | O3:coordinates = "time lon lat z" ; |
| 379 | |
| 380 | float NO3(trajectory, obs) ; |
| 381 | NO3:long_name = "NO3 concentration" ; |
| 382 | NO3:units = "1e-9" ; |
| 383 | NO3:coordinates = "time lon lat z" ; |
| 384 | |
| 385 | attributes: |
| 386 | :CF\:featureType = "trajectory"; |
| 387 | }}} |
| 388 | |
| 389 | The NO3(t,i) and O3(t,i) data are associated with the coordinate values time(t,i), lat(t,i), lon(t,i), and alt(t,i). The trajectory dimension may be the unlimited dimension or not. All variables that have trajectory as their only dimension are considered to be information about that trajectory. |
| 390 | |
| 391 | The time coordinate may use a missing value, which indicates that data is missing for that trajectory and obs index. This allows one to have a variable number of observations for different trajectories, at the cost of some wasted space. The data variables may also use missing data values. |
| 392 | |
| 393 | === 9.4.2 Single Trajectory === |
| 394 | |
| 395 | When a single trajectory is stored in a file, one can use a variation of the Multidimensional representation which removes the trajectory dimension: |
| 396 | |
| 397 | {{{ |
| 398 | dimensions: |
| 399 | time = 42; |
| 400 | |
| 401 | variables: |
| 402 | char trajectory(name_strlen) ; |
| 403 | trajectory:standard_name = "trajectory_id"; |
| 404 | |
377 | | === 5.8.3.2 Multidimensional representation === |
378 | | |
379 | | When storing multiple trajectories in the same file, and the number of observations in each trajectory is the same, one can use the multidimensional representation. |
380 | | |
381 | | |
382 | | {{{ |
383 | | dimensions: |
384 | | obs = 1000 ; |
385 | | trajectory = 77 ; |
386 | | |
387 | | variables: |
388 | | char trajectory(trajectory, name_strlen) ; |
389 | | trajectory:long_name = "trajectory name" ; |
390 | | int trajectory_info(trajectory) ; |
391 | | trajectory_name:long_name = "some kind of trajectory info" |
392 | | |
393 | | double time(trajectory, obs) ; |
394 | | time:long_name = "time" ; |
395 | | time:units = "days since 1970-01-01 00:00:00" ; |
396 | | float lon(trajectory, obs) ; |
397 | | lon:long_name = "longitude" ; |
398 | | lon:units = "degrees_east" ; |
399 | | float lat(trajectory, obs) ; |
400 | | lat:long_name = "latitude" ; |
401 | | lat:units = "degrees_north" ; |
402 | | |
403 | | float z(trajectory, obs) ; |
404 | | z:long_name = "height above mean sea level" ; |
405 | | z:units = "km" ; |
406 | | z:positive = "up" ; |
407 | | |
408 | | float O3(trajectory, obs) ; |
409 | | O3:long_name = "ozone concentration" ; |
410 | | O3:units = "1e-9" ; |
411 | | O3:coordinates = "time lon lat z" ; |
412 | | |
413 | | float NO3(trajectory, obs) ; |
414 | | NO3:long_name = "NO3 concentration" ; |
415 | | NO3:units = "1e-9" ; |
416 | | NO3:coordinates = "time lon lat z" ; |
417 | | |
418 | | attributes: |
419 | | :CF\:featureType = "trajectory"; |
420 | | }}} |
421 | | |
422 | | |
423 | | The NO3(t,i) and O3(t,i) data are associated with the coordinate values time(t,i), lat(t,i), lon(t,i), and alt(t,i). The trajectory dimension may be the unlimited dimension or not. All variables that have trajectory as their only dimension are considered to be information about that trajectory. |
424 | | |
425 | | The time coordinate may use a missing value, which indicates that data is missing for that trajectory and obs index. This allows one to have a variable number of observations for different trajectories, at the cost of some wasted space. The data variables may also use missing data values. |
426 | | |
427 | | === 5.8.3.3 Ragged array (contiguous) representation === |
| 439 | |
| 440 | === 9.4.3 Ragged array (contiguous) representation === |
544 | | |
545 | | variables: |
546 | | float z(z) ; |
547 | | z:long_name = "height above mean sea level" ; |
548 | | z:units = "km" ; |
549 | | z:positive = "up" ; |
550 | | |
| 557 | profile = 142 ; |
| 558 | |
| 559 | variables: |
| 560 | int profile(profile) ; |
| 561 | profile:standard_name = "profile_id"; |
| 562 | double time(profile); |
| 563 | time:long_name = "time" ; |
| 564 | time:units = "days since 1970-01-01 00:00:00" ; |
| 565 | float lon(profile); |
| 566 | lon:long_name = "longitude" ; |
| 567 | lon:units = "degrees_east" ; |
| 568 | float lat(profile); |
| 569 | lat:long_name = "latitude" ; |
| 570 | lat:units = "degrees_north" ; |
| 571 | |
| 572 | float alt(profile, z) ; |
| 573 | alt:long_name = "height above mean sea level" ; |
| 574 | alt:units = "km" ; |
| 575 | alt:positive = "up" ; |
| 576 | |
| 577 | float pressure(profile, z) ; |
| 578 | pressure:long_name = "pressure level" ; |
| 579 | pressure:units = "hPa" ; |
| 580 | pressure:coordinates = "time lon lat alt" ; |
| 581 | |
| 582 | float temperature(profile, z) ; |
| 583 | temperature:long_name = "skin temperature" ; |
| 584 | temperature:units = "Celsius" ; |
| 585 | temperature:coordinates = "time lon lat alt" ; |
| 586 | |
| 587 | float humidity(profile, z) ; |
| 588 | humidity:long_name = "relative humidity" ; |
| 589 | humidity:units = "%" ; |
| 590 | humidity:coordinates = "time lon lat alt" ; |
| 591 | |
| 592 | attributes: |
| 593 | :CF\:featureType = "profile"; |
| 594 | }}} |
| 595 | |
| 596 | The pressure(p,i), temperature(p,i), and humidity(p,i) data is associated with the coordinate values time(p), alt(p,i), lat(p), and lon(p). If the vertical coordinates are the same for all profiles, one can use z(z) instead of alt(profile,z). The time coordinate may depend on z also, eg time(profile,z). |
| 597 | |
| 598 | When there are a variable number of observations for different profiles, use alt(profile, z) with missing values. |
| 599 | |
| 600 | |
| 601 | === 9.5.2 Single Profile === |
| 602 | |
| 603 | When a single profile is stored in a file, one can use a variation of the Multidimensional representation which removes the profile dimension: |
| 604 | |
| 605 | {{{ |
| 606 | dimensions: |
| 607 | z = 42 ; |
| 608 | |
| 609 | variables: |
| 610 | |
| 611 | int profile ; |
| 612 | profile:standard_name = "profile_id"; |
580 | | |
581 | | The pressure(i), temperature(i), and humidity(i) data is associated with the coordinate values time, z(i), lat, and lon. The z coordinate must be ordered. The time coordinate may depend on z also, eg may be time(z). |
582 | | |
583 | | === 5.8.4.2 Multidimensional representation === |
584 | | |
585 | | When storing multiple profiles in the same file, and the vertical levels in each profile are the same, one can use the multidimensional representation: |
586 | | |
587 | | |
588 | | {{{ |
589 | | dimensions: |
590 | | z = 42 ; |
591 | | profile = 142 ; |
592 | | |
593 | | variables: |
594 | | float z(z) ; |
595 | | z:long_name = "height above mean sea level" ; |
596 | | z:units = "km" ; |
597 | | z:positive = "up" ; |
598 | | |
599 | | double time(profile); |
600 | | time:long_name = "time" ; |
601 | | time:units = "days since 1970-01-01 00:00:00" ; |
602 | | float lon(profile); |
603 | | lon:long_name = "longitude" ; |
604 | | lon:units = "degrees_east" ; |
605 | | float lat(profile); |
606 | | lat:long_name = "latitude" ; |
607 | | lat:units = "degrees_north" ; |
608 | | |
609 | | float pressure(profile, z) ; |
610 | | pressure:long_name = "pressure level" ; |
611 | | pressure:units = "hPa" ; |
612 | | pressure:coordinates = "time lon lat z" ; |
613 | | |
614 | | float temperature(profile, z) ; |
615 | | temperature:long_name = "skin temperature" ; |
616 | | temperature:units = "Celsius" ; |
617 | | temperature:coordinates = "time lon lat z" ; |
618 | | |
619 | | float humidity(profile, z) ; |
620 | | humidity:long_name = "relative humidity" ; |
621 | | humidity:units = "%" ; |
622 | | humidity:coordinates = "time lon lat z" ; |
623 | | |
624 | | attributes: |
625 | | :CF\:featureType = "profile"; |
626 | | }}} |
627 | | |
628 | | |
629 | | The pressure(p,i), temperature(p,i), and humidity(p,i) data is associated with the coordinate values time(p), z(i), lat(p), and lon(p). If the vertical coordinates differ for each profile, but the number of levels are the same, one can use z(profile, z), but the z coordinate must be ordered for each profile. |
630 | | |
631 | | The profile dimension may be the unlimited dimension or not. All variables that have profile as their only dimension are considered to be profile information. |
632 | | |
633 | | |
634 | | The time coordinate may depend on z also, eg time(p,z). The time coordinate may use a missing value, which indicates that data is missing for that profile and obs index. This allows one to have a variable number of observations for different profiles, at the cost of some wasted space. The data variables may also use missing data values. |
635 | | |
636 | | === 5.8.4.3 Ragged array (contiguous) representation === |
| 647 | The pressure(i), temperature(i), and humidity(i) data is associated with the coordinate values time, alt(i), lat, and lon. The time coordinate may depend on z also, eg may be time(z). |
| 648 | |
| 649 | |
| 650 | === 9.5.3 Ragged array (contiguous) representation === |
738 | | == 5.8.5 Station Profile Data == |
739 | | |
740 | | When profiles are taken at a set of stations, one gets a time series of profiles at each station, called a stationProfileTimeSeries. |
741 | | |
742 | | === 5.8.5.1 Profile time series at a single station === |
743 | | |
744 | | If there is only one station in a file, and the vertical levels are the same for each profile, one can use a representation that is a variant of Example 5.8.4.2: |
745 | | |
746 | | |
747 | | {{{ |
748 | | dimensions: |
749 | | z = 42 ; |
750 | | time = UNLIMITED ; |
751 | | |
752 | | variables: |
753 | | float z(z) ; |
754 | | z:long_name = "height above mean sea level" ; |
755 | | z:units = "km" ; |
756 | | z:positive = "up" ; |
757 | | |
758 | | double time(time); |
759 | | time:long_name = "time" ; |
760 | | time:units = "days since 1970-01-01 00:00:00" ; |
761 | | float lon; |
762 | | lon:long_name = "longitude" ; |
763 | | lon:units = "degrees_east" ; |
764 | | float lat; |
765 | | lat:long_name = "latitude" ; |
766 | | lat:units = "degrees_north" ; |
767 | | |
768 | | float pressure(time, z) ; |
769 | | pressure:long_name = "pressure level" ; |
770 | | pressure:units = "hPa" ; |
771 | | pressure:coordinates = "time lon lat z" ; |
772 | | |
773 | | float temperature(time, z) ; |
774 | | temperature:long_name = "skin temperature" ; |
775 | | temperature:units = "Celsius" ; |
776 | | temperature:coordinates = "time lon lat z" ; |
777 | | |
778 | | float humidity(time, z) ; |
779 | | humidity:long_name = "relative humidity" ; |
780 | | humidity:units = "%" ; |
781 | | humidity:coordinates = "time lon lat z" ; |
782 | | |
783 | | attributes: |
784 | | :CF\:featureType = "stationProfileTimeSeries"; |
785 | | }}} |
786 | | |
787 | | |
788 | | The pressure(i,j), temperature(i,j), and humidity(i,j) data are associated with the coordinate values time(i), z(j), lat, and lon. |
789 | | |
790 | | === 5.8.5.2 Multidimensional representation === |
791 | | |
792 | | When storing time series of profiles at multiple stations in the same file, if there are the same number of time points and vertical levels for every profile, one can use the multidimensional representation. |
793 | | |
| 753 | |
| 754 | == 9.6 Station Profile Data == |
| 755 | |
| 756 | When profiles are taken at a set of stations, one gets a time series of profiles at each station, called a stationProfile. |
| 757 | |
| 758 | The same assumptions are made as with stationTimeSeries data: |
| 759 | |
| 760 | * The outer dimension of the latitude and longitude coordinates (which must agree) is the 'station dimension'. |
| 761 | * All variables that have the station dimension as their outer dimension are considered to be station information, and are called 'station variables'. |
| 762 | * There must always be a station variable (of any type) with standard_name attribute "'''station_id'''", whose values uniquely identify the station. |
| 763 | * The station_id variable may use missing values. This allows one to reserve more space than is needed for stations. |
| 764 | * There may be station variables with standard_name attribute "'''station_desc'''", "'''station_altitude'''", and "'''station_wmoid'''".. |
| 765 | |
| 766 | === 9.6.1 Multidimensional representation === |
| 767 | |
| 768 | When storing time series of profiles at multiple stations in the same file, if there are the same number of time points for all stations, and te same number of vertical levels for every profile, one can use the multidimensional representation: |
836 | | humidity:coordinates = "time lon lat z" ; |
837 | | |
838 | | attributes: |
839 | | :CF\:featureType = "stationProfileTimeSeries"; |
840 | | }}} |
841 | | |
842 | | |
843 | | The pressure(s,p,i), temperature(s,p,i), and humidity(s,p,i) data is associated with the coordinate values time(s,p), z(i), lat(s), and lon(s). |
844 | | |
845 | | === 5.8.5.3 Ragged array of multidimensional profiles === |
846 | | |
847 | | When the number of profiles for each station varies, one can use (continguous or non-contiguous) ragged arrays for the time series. If each profile has the same number of vertical levels, a multidimensional profile representation can be usedd. Here is the contiguous form: |
848 | | |
849 | | |
850 | | {{{ |
851 | | dimensions: |
852 | | station = 22 ; |
853 | | profile = UNLIMITED ; |
| 811 | humidity:coordinates = "time lon lat alt" ; |
| 812 | |
| 813 | attributes: |
| 814 | :CF\:featureType = "stationProfile"; |
| 815 | }}} |
| 816 | |
| 817 | The pressure(s,p,i), temperature(s,p,i), and humidity(s,p,i) data is associated with the coordinate values time(s,p), z(s,p,i), lat(s), and lon(s). |
| 818 | |
| 819 | The time coordinate may depend on z also, eg time(station,profile,z). If all of the profiles use the same z coordinate, alt(station, profile, z) may be factored out into z(z). |
| 820 | |
| 821 | When there are varying number of profiles for different stations, use time(station, profile) with missing values. When there are varying number of levels for different profiles, use alt(station, profile, z) with missing values. |
| 822 | |
| 823 | === 9.6.2 Profile time series at a single station === |
| 824 | |
| 825 | If there is only one station in a file, one can use a variation of the Multidimensional representation which removes the station dimension: |
| 826 | |
| 827 | {{{ |
| 828 | dimensions: |
| 829 | profile = 30 ; |
857 | | float z(z) ; |
858 | | z:long_name = "height above mean sea level" ; |
859 | | z:units = "km" ; |
860 | | z:positive = "up" ; |
861 | | |
| 833 | float lon ; |
| 834 | lon:long_name = "station longitude"; |
| 835 | lon:units = "degrees_east"; |
| 836 | float lat ; |
| 837 | lat:long_name = "station latitude" ; |
| 838 | lat:units = "degrees_north" ; |
| 839 | char station_name(name_strlen) ; |
| 840 | station_name:long_name = "station name" ; |
| 841 | int station_info(station) ; |
| 842 | station_name:long_name = "some kind of station info" ; |
| 843 | |
| 844 | float alt(profile , z) ; |
| 845 | alt:long_name = "height above mean sea level" ; |
| 846 | alt:units = "km" ; |
| 847 | alt:positive = "up" ; |
| 848 | |
| 849 | double time(profile ) ; |
| 850 | time:long_name = "time of measurement" ; |
| 851 | time:units = "days since 1970-01-01 00:00:00" ; |
| 852 | time:missing_value = -999.9; |
| 853 | |
| 854 | float pressure(profile , z) ; |
| 855 | pressure:long_name = "pressure level" ; |
| 856 | pressure:units = "hPa" ; |
| 857 | pressure:coordinates = "time lon lat alt" ; |
| 858 | |
| 859 | float temperature(profile , z) ; |
| 860 | temperature:long_name = "skin temperature" ; |
| 861 | temperature:units = "Celsius" ; |
| 862 | temperature:coordinates = "time lon lat alt" ; |
| 863 | |
| 864 | float humidity(profile , z) ; |
| 865 | humidity:long_name = "relative humidity" ; |
| 866 | humidity:units = "%" ; |
| 867 | humidity:coordinates = "time lon lat alt" ; |
| 868 | |
| 869 | attributes: |
| 870 | :CF\:featureType = "stationProfile"; |
| 871 | }}} |
| 872 | |
| 873 | The pressure(i,j), temperature(i,j), and humidity(i,j) data are associated with the coordinate values time(p), alt(p,i), lat, and lon. The time coordinate may depend on z also, eg time(profile,z). If all of the profiles use the same z coordinate, alt(profile, z) may be factored out into z(z). |
| 874 | |
| 875 | === 9.6.3 Ragged array of station profile time series === |
| 876 | |
| 877 | When the number of profiles and levels for each station varies, one can use the ragged array representation. This uses the contiguous ragged array representation for profiles (9.5.3), and adds the (factored out) station information with station indexes (9.2.4): |
| 878 | |
| 879 | {{{ |
| 880 | dimensions: |
| 881 | obs = UNLIMITED ; |
| 882 | profiles = 1420 ; |
| 883 | stations = 42; |
| 884 | |
| 885 | variables: |
877 | | time:units = "days since 1970-01-01 00:00:00" ; |
| 905 | time:units = "days since 1970-01-01 00:00:00" ; |
| 906 | float lon(profile); |
| 907 | lon:long_name = "longitude" ; |
| 908 | lon:units = "degrees_east" ; |
| 909 | float lat(profile); |
| 910 | lat:long_name = "latitude" ; |
| 911 | lat:units = "degrees_north" ; |
| 912 | int stationIndex(profile) ; |
| 913 | stationIndex:long_name = "which station this obs is for" ; |
| 914 | stationIndex:standard_name = "ragged_parentIndex" ; |
| 915 | int rowSize(profile) ; |
| 916 | rowSize:long_name = "number of obs for this profile " ; |
| 917 | rowSize:standard_name = "ragged_rowSize" ; |
| 918 | |
| 919 | float z(obs) ; |
| 920 | z:long_name = "height above mean sea level" ; |
| 921 | z:units = "km" ; |
| 922 | z:positive = "up" ; |
| 923 | |
| 924 | float pressure(obs) ; |
| 925 | pressure:long_name = "pressure level" ; |
| 926 | pressure:units = "hPa" ; |
| 927 | pressure:coordinates = "time lon lat z" ; |
| 928 | |
| 929 | float temperature(obs) ; |
| 930 | temperature:long_name = "skin temperature" ; |
| 931 | temperature:units = "Celsius" ; |
| 932 | temperature:coordinates = "time lon lat z" ; |
| 933 | |
| 934 | float humidity(obs) ; |
| 935 | humidity:long_name = "relative humidity" ; |
| 936 | humidity:units = "%" ; |
| 937 | humidity:coordinates = "time lon lat z" ; |
| 938 | |
| 939 | attributes: |
| 940 | :CF\:featureType = "stationProfile"; |
| 941 | }}} |
| 942 | |
| 943 | The profile is associated with a station using the stationIndex(profile). For each profile, the observations must be written contiguously. |
| 944 | |
| 945 | The pressure(i), temperature(i), and humidity(i) data is associated with the coordinate values time(p), z(i), lat(s), and lon(s). The time coordinate may depend on z also, eg time(obs) instead of time(profile). |
| 946 | |
| 947 | === 9.6.4 Flattened representation of multidimensional profiles === |
| 948 | |
| 949 | A variation of multidimensional profiles (9.5.1) allows these to be associated into a station time series. The station information (lat, lon, id) is repeated in each profile: |
| 950 | |
| 951 | {{{ |
| 952 | dimensions: |
| 953 | z = 42 ; |
| 954 | profile = 142 ; |
| 955 | |
| 956 | variables: |
| 957 | int profile(profile) ; |
| 958 | profile:standard_name = "profile_id"; |
| 959 | double time(profile); |
| 960 | time:long_name = "time" ; |
| 961 | time:units = "days since 1970-01-01 00:00:00" ; |
| 962 | float lon(profile); |
| 963 | lon:long_name = "longitude" ; |
| 964 | lon:units = "degrees_east" ; |
| 965 | float lat(profile); |
| 966 | lat:long_name = "latitude" ; |
| 967 | lat:units = "degrees_north" ; |
| 968 | char station_name(profile, name_strlen) ; |
| 969 | station_name:long_name = "station name" ; |
| 970 | station_name:standard_name = "station_id"; |
| 971 | |
| 972 | float alt(profile, z) ; |
| 973 | alt:long_name = "height above mean sea level" ; |
| 974 | alt:units = "km" ; |
| 975 | alt:positive = "up" ; |
| 976 | |
891 | | humidity:coordinates = "time lon lat z" ; |
892 | | |
893 | | attributes: |
894 | | :CF\:featureType = "stationProfileTimeSeries"; |
895 | | }}} |
896 | | |
897 | | |
898 | | The pressure(p,z), temperature(p,z), and humidity(p,z) data is associated with the coordinate values time(p), z(z), lat(s), and lon(s). |
899 | | |
900 | | === 5.8.5.4 Ragged array of ragged array === |
901 | | |
902 | | If the number of vertical levels for the profiles also varies significantly, one can also turn the profiles into a ragged array. Here we show the non-contiguous form: |
903 | | |
| 990 | humidity:coordinates = "time lon lat alt" ; |
| 991 | |
| 992 | attributes: |
| 993 | :CF\:featureType = "stationProfile"; |
| 994 | }}} |
| 995 | |
| 996 | This is the same as 9.5.1, except that a station_id variable is added for each profile, which associates the profile to a station. The station information is repeated for each profile and should be the same for all profiles with the same station_id. |
| 997 | |
| 998 | == 9.7 Section Profile Data == |
| 999 | |
| 1000 | When profiles are taken along a trajectory, one gets a time series of profiles called a section. This looks like a collection of profiles (see 9.5), except that the profile locations are assumed to be a connected set of points along the trajectory. |
| 1001 | |
| 1002 | === 9.7.1 Multidimensional representation === |
| 1003 | |
| 1004 | If there are the same number of profiles for all trajectories, and the same number of vertical levels for every profile, one can use the multidimensional representation: |
| 1005 | |
| 1006 | {{{ |
| 1007 | dimensions: |
| 1008 | section = 22 ; |
| 1009 | profile = 33; |
| 1010 | z = 42 ; |
| 1011 | |
| 1012 | variables: |
| 1013 | float lon(section, profile) ; |
| 1014 | lon:units = "degrees_east"; |
| 1015 | float lat(section, profile) ; |
| 1016 | lat:long_name = "station latitude" ; |
| 1017 | lat:units = "degrees_north" ; |
| 1018 | int section(section) ; |
| 1019 | section:standard_name = "section id" ; |
| 1020 | |
| 1021 | float alt(section, profile , z) ; |
| 1022 | alt:long_name = "height above mean sea level" ; |
| 1023 | alt:units = "km" ; |
| 1024 | alt:positive = "up" ; |
| 1025 | |
| 1026 | double time(section, profile ) ; |
| 1027 | time:long_name = "time of measurement" ; |
| 1028 | time:units = "days since 1970-01-01 00:00:00" ; |
| 1029 | time:missing_value = -999.9; |
| 1030 | |
| 1031 | float pressure(section, profile , z) ; |
| 1032 | pressure:long_name = "pressure level" ; |
| 1033 | pressure:units = "hPa" ; |
| 1034 | pressure:coordinates = "time lon lat alt" ; |
| 1035 | |
| 1036 | float temperature(section, profile , z) ; |
| 1037 | temperature:long_name = "skin temperature" ; |
| 1038 | temperature:units = "Celsius" ; |
| 1039 | temperature:coordinates = "time lon lat alt" ; |
| 1040 | |
| 1041 | float humidity(section, profile , z) ; |
| 1042 | humidity:long_name = "relative humidity" ; |
| 1043 | humidity:units = "%" ; |
| 1044 | humidity:coordinates = "time lon lat alt" ; |
| 1045 | |
| 1046 | attributes: |
| 1047 | :CF\:featureType = "section"; |
| 1048 | }}} |
| 1049 | |
| 1050 | The pressure(s,p,i), temperature(s,p,i), and humidity(s,p,i) data is associated with the coordinate values time(s,p), alt(s,p,i), lat(s,p), and lon(s,p). |
| 1051 | |
| 1052 | The time coordinate may depend on z also, eg time(section,profile,z). If all of the profiles use the same z coordinate, alt(section, profile, z) may be factored out into z(z). |
| 1053 | |
| 1054 | When there are varying number of profiles for different sections, use time(section, profile) with missing values. When there are varying number of levels for different profiles, use alt(section, profile, z) with missing values. |
| 1055 | |
| 1056 | === 9.7.2 Single section in the file === |
| 1057 | |
| 1058 | If there is only one section in the file, one can use a variation of the Multidimensional representation which removes the section dimension: |
| 1059 | |
| 1060 | {{{ |
| 1061 | dimensions: |
| 1062 | profile = 33; |
| 1063 | z = 42 ; |
| 1064 | |
| 1065 | variables: |
| 1066 | float lon(profile) ; |
| 1067 | lon:units = "degrees_east"; |
| 1068 | float lat(profile) ; |
| 1069 | lat:long_name = "station latitude" ; |
| 1070 | lat:units = "degrees_north" ; |
| 1071 | int section ; |
| 1072 | section:standard_name = "section id" ; |
| 1073 | |
| 1074 | float alt(profile , z) ; |
| 1075 | alt:long_name = "height above mean sea level" ; |
| 1076 | alt:units = "km" ; |
| 1077 | alt:positive = "up" ; |
| 1078 | |
| 1079 | double time(profile ) ; |
| 1080 | time:long_name = "time of measurement" ; |
| 1081 | time:units = "days since 1970-01-01 00:00:00" ; |
| 1082 | time:missing_value = -999.9; |
| 1083 | |
| 1084 | float pressure(profile , z) ; |
| 1085 | pressure:long_name = "pressure level" ; |
| 1086 | pressure:units = "hPa" ; |
| 1087 | pressure:coordinates = "time lon lat alt" ; |
| 1088 | |
| 1089 | float temperature(profile , z) ; |
| 1090 | temperature:long_name = "skin temperature" ; |
| 1091 | temperature:units = "Celsius" ; |
| 1092 | temperature:coordinates = "time lon lat alt" ; |
| 1093 | |
| 1094 | float humidity(profile , z) ; |
| 1095 | humidity:long_name = "relative humidity" ; |
| 1096 | humidity:units = "%" ; |
| 1097 | humidity:coordinates = "time lon lat alt" ; |
| 1098 | |
| 1099 | attributes: |
| 1100 | :CF\:featureType = "section"; |
| 1101 | }}} |
| 1102 | |
| 1103 | |
| 1104 | === 9.7.3 Ragged array of sections === |
| 1105 | |
| 1106 | When the number of profiles and levels for each station varies, one can use the ragged array representation. This uses the contiguous ragged array representation for profiles (9.5.3), and adds the (factored out) station information with station indexes (9.2.4): |
955 | | :CF\:featureType = "stationProfileTimeSeries"; |
956 | | }}} |
957 | | |
958 | | |
959 | | The pressure(i), temperature(i), and humidity(i) data is associated with the coordinate values time(p), z(i), lat(s), and lon(s), where p = profileIndex(i), and s = stationIndex(p). |
960 | | |
961 | | == 5.8.6 Section Profile Data == |
962 | | |
963 | | When profiles are taken along a trajectory, one gets a time series of profiles called a section. This looks like a collection of profiles (see 5.8.4.2), except that the profile location are a connected set of points along a trajectory. |
964 | | |
965 | | === 5.8.6.1 Multidimensional representation === |
| 1169 | :CF\:featureType = "stationProfile"; |
| 1170 | }}} |
| 1171 | |
| 1172 | The profile is associated with a station using the stationIndex(profile). For each profile, the observations must be written contiguously. |
| 1173 | |
| 1174 | The pressure(i), temperature(i), and humidity(i) data is associated with the coordinate values time(p), z(i), lat(s), and lon(s). The time coordinate may depend on z also, eg time(obs) instead of time(profile). |
| 1175 | |
| 1176 | === 9.6.4 Flattened representation of multidimensional profiles === |
| 1177 | |
| 1178 | A variation of multidimensional profiles (9.5.1) allows these to be associated into a station time series. The station information (lat, lon, id) is repeated in each profile: |
| 1179 | |
| 1180 | {{{ |
| 1181 | dimensions: |
| 1182 | z = 42 ; |
| 1183 | profile = 142 ; |
| 1184 | |
| 1185 | variables: |
| 1186 | int profile(profile) ; |
| 1187 | profile:standard_name = "profile_id"; |
| 1188 | double time(profile); |
| 1189 | time:long_name = "time" ; |
| 1190 | time:units = "days since 1970-01-01 00:00:00" ; |
| 1191 | float lon(profile); |
| 1192 | lon:long_name = "longitude" ; |
| 1193 | lon:units = "degrees_east" ; |
| 1194 | float lat(profile); |
| 1195 | lat:long_name = "latitude" ; |
| 1196 | lat:units = "degrees_north" ; |
| 1197 | char station_name(profile, name_strlen) ; |
| 1198 | station_name:long_name = "station name" ; |
| 1199 | station_name:standard_name = "station_id"; |
| 1200 | |
| 1201 | float alt(profile, z) ; |
| 1202 | alt:long_name = "height above mean sea level" ; |
| 1203 | alt:units = "km" ; |
| 1204 | alt:positive = "up" ; |
| 1205 | |
| 1206 | float pressure(profile, z) ; |
| 1207 | pressure:long_name = "pressure level" ; |
| 1208 | pressure:units = "hPa" ; |
| 1209 | pressure:coordinates = "time lon lat alt" ; |
| 1210 | |
| 1211 | float temperature(profile, z) ; |
| 1212 | temperature:long_name = "skin temperature" ; |
| 1213 | temperature:units = "Celsius" ; |
| 1214 | temperature:coordinates = "time lon lat alt" ; |
| 1215 | |
| 1216 | float humidity(profile, z) ; |
| 1217 | humidity:long_name = "relative humidity" ; |
| 1218 | humidity:units = "%" ; |
| 1219 | humidity:coordinates = "time lon lat alt" ; |
| 1220 | |
| 1221 | attributes: |
| 1222 | :CF\:featureType = "stationProfile"; |
| 1223 | }}} |
| 1224 | |
| 1225 | This is the same as 9.5.1, except that a station_id variable is added for each profile, which associates the profile to a station. The station information is repeated for each profile and should be the same for all profiles with the same station_id. |
| 1226 | |
| 1227 | == 9.7 Section Profile Data == |
| 1228 | |
| 1229 | When profiles are taken along a trajectory, one gets a time series of profiles called a section. This looks like a collection of profiles (see 9.5), except that the profile locations are a connected set of points along a trajectory. |
| 1230 | |
| 1231 | === 9.7.1 Multidimensional representation === |