ncgen - אונליין בענן

תָכְנִית:

שֵׁם

ncgen - צור מקובץ CDL קובץ netCDF-3, קובץ netCDF-4 או תוכנית C

תַקצִיר

ncgen [-b] [-c] [-f] [-k format_name] [-קוד_פורמט] [-ל תפוקה שפה] [-n] [-o
שם_קובץ_netcdf] [-x] [input_file]

תיאור

ncgen מייצר קובץ .nc בינארי netCDF-3 (כלומר, קלאסי), netCDF-4 (כלומר
קובץ בינארי (משופר) .nc או קובץ בשפת מקור כלשהי שכאשר יבוצע
בנה את קובץ ה-.nc הבינארי המתאים. הקלט אל ncgen הוא תיאור של א
קובץ netCDF בשפה קטנה המכונה CDL (רשת Common Data form Language),
מתואר להלן. הקלט נקרא מקלט סטנדרטי אם לא צוין input_file. אם לא
האפשרויות מצוינות בקריאה ncgen, זה רק בודק את התחביר של CDL הקלט
קובץ, ומייצר הודעות שגיאה עבור כל הפרה של תחביר CDL. אפשרויות נוספות יכולות להיות
משמש, למשל, ליצירת קובץ netCDF המתאים, או ליצירת תוכנית C
המשתמש בממשק C של netCDF כדי ליצור את קובץ netCDF.

שימו לב שגרסה זו של ncgen נקראה במקור ncgen4. לתוכנית ncgen הישנה יותר יש
שונה שמו ל-ncgen3.

ncgen ניתן להשתמש בו עם תוכנית הנלווית ncdump לבצע כמה פעולות פשוטות על
קבצי netCDF. לדוגמה, כדי לשנות שם של ממד בקובץ netCDF, השתמשו ncdump כדי לקבל
גרסת CDL של קובץ netCDF, ערוך את קובץ ה-CDL כדי לשנות את שם המימדים,
ואת השימוש ncgen כדי ליצור את קובץ ה-netCDF המתאים מקובץ ה-CDL הערוך.

אפשרויות

-b צור קובץ netCDF (בינארי). אם ה- -o האפשרות נעדרת, שם קובץ ברירת מחדל
ייבנה משם הבסיס של קובץ ה-CDL, כאשר כל סיומת תוחלף על ידי
הסיומת `.nc'. אם כבר קיים קובץ עם השם שצוין, הוא ייקרא
מוחלף.

-c ליצור C קוד מקור שייצור קובץ netCDF התואם ל- netCDF
מפרט. קוד המקור של C נכתב לפלט סטנדרטי; שווה ערך ל- -lc.

-f ליצור פורטרן 77 קוד מקור שייצור קובץ netCDF התואם ל- netCDF
מפרט. קוד המקור נכתב לפלט סטנדרטי; שווה ערך ל-lf77-.

-o קובץ_netcdf
שם הקובץ שיש להעביר לקריאות ל-"nc_create()". אם אפשרות זו צוינה, היא
מרמז (בהיעדר דגל -l מפורש) על ה-"-bאפשרות זו היא
הכרחי מכיוון שלא ניתן לכתוב קבצי netCDF ישירות לפלט סטנדרטי, מכיוון
הפלט הסטנדרטי אינו ניתן לחיפוש.

-k format_name

-קוד_פורמט
הדגל -k מציין את פורמט הקובץ שייווצר, וכתוצאה מכך, את
מודל נתונים המקובל על ידי ncgen (כלומר netcdf-3 (קלאסי) לעומת netcdf-4 לעומת netcdf-5).
כקיצור דרך, מספר קוד_פורמט ניתן לציין במקום זאת. האפשרי
format_name הערכים עבור האפשרות -k הם:

'classic' או 'nc3' => פורמט קלאסי של netCDF

'היסט 64 סיביות' או 'nc6' => פורמט 64 סיביות של netCDF

'נתונים של 64 סיביות או 'nc5' => פורמט netCDF-5 (נתונים של 64 סיביות)

'netCDF-4' 0r 'nc4' => פורמט netCDF-4 (מודל נתונים משופר)

'מודל קלאסי של netCDF-4' או 'nc7' => פורמט מודל קלאסי של netCDF-4
מְקוּבָּל מספר_פורמט ארגומנטים, שהם רק קיצורי דרך עבור format_names, הם:

3 => פורמט netcdf קלאסי

5 => פורמט netcdf 5

6 => פורמט netCDF 64 סיביות

4 => פורמט netCDF-4 (מודל נתונים משופר)

7 => פורמט דגם קלאסי של netCDF-4
הקוד המספרי "7" משמש מכיוון ש-"7=3+4", קוד זיכרון לפורמט המשתמש ב-
מודל הנתונים netCDF-3 לצורך תאימות עם פורמט האחסון netCDF-4 לצורך ביצועים.
קרדיט מגיע ל-NCO על השימוש בקודים מספריים אלה במקום הישנים והמבלבלים
לעצב מספרים.

הערה: מספרי הפורמטים בגרסה הישנה הם '1', '2', '3', '4', שקולים לשמות הפורמטים
'nc3', 'nc6', 'nc4' או 'nc7' בהתאמה, עדיין מקובלים אך הוצאו משימוש, עקב
בלבול קל בין מספרי פורמטים לשמות פורמטים. שמות בדויים שונים של פורמטים ישנים
מקובלים גם הם אך אינם בשימוש, לדוגמה 'hdf5', 'enhanced-nc3' וכו'. כמו כן, שימו לב ש-v הוא
מקובל על המשמעות של -k עבור תאימות לאחור.

-x אין לאתחל נתונים עם ערכי מילוי. זה יכול להאיץ את יצירתם של קבצי netCDF גדולים.
קבצים במידה רבה, אך מאוחר יותר מנסה לקרוא נתונים שלא נכתבו מהקובץ שנוצר
לא יהיה ניתן לגילוי בקלות.

-l שפת_פלט
הדגל -l מציין את שפת הפלט שיש להשתמש בה בעת יצירת קוד מקור
ייצור או יגדיר קובץ netCDF התואם למפרט netCDF. הפלט
נכתב לפלט סטנדרטי. לשפות הנתמכות כעת יש את
דגלים הבאים.

c|C' => פלט בשפת C.

f77|fortran77' => פלט שפת FORTRAN 77
שימו לב שכרגע רק המודל הקלאסי נתמך.

j|java' => פלט (ניסיוני) של שפת ג'אווה
; מכוון לממשק Unidata Java הקיים, מה שאומר שרק
המודל הקלאסי נתמך.

בחירה מה היא תפוקה פוּרמָט

בחירת פורמט הפלט נקבעת על ידי שלושה דגלים.

-k דגל.

_פוּרמָט תכונה (ראה להלן).

התרחשות of CDF-5 (64 סיביות נתונים) or
מבני netcdf-4 ב-CDL הקלט." השמיים טווח "netCDF-4 מבנים אומר
בונה החל מ- מה היא משופר נתונים מודל, לֹא רק מיוחד קשור לביצועים
תכונות כזה as
_גדלי חתיכות, _רמת ניפוח, _אנדיאניזם, וכו ' השמיים טווח "CDF-5 מבנים אומר
מוּרחָב לא חתום מספר שלם סוגים מותר in מה היא 64 סיבית נתונים מודל.

שימו לב שישנה עמימות בין מקרה netCDF-4 לבין מקרה CDF-5, והוא רק מקרה
נראה סוג לא חתום בקלט.

הכללים הם כדלקמן, לפי סדר היישום.

1. אם מצוין פלט של Fortran או Java, אז ערך הדגל -k הוא 1 (קלאסי).
מודל) ייעשה בו שימוש. סתירות עם השימוש במבנים משופרים ב-CDL יהיו
לדווח על שגיאה.

2. אם מצוינים גם הדגל -k וגם המאפיין _Format, הדגל _Format יהיה
התעלם. אם לא צוין דגל -k, ומצוין ערך מאפיין _Format,
אז ערך הדגל -k יוגדר לזה של המאפיין _Format. אחרת ה-
הדגל -k אינו מוגדר.

3. אם האפשרות -k מוגדרת והיא עקבית עם ה-CDL, ncgen יוציא תוצאה
להגיש בטופס המבוקש, אחרת תדווח על שגיאה.

4. אם הדגל -k אינו מוגדר, ואם ישנם מבני CDF-5, רק ב-CDL, א
ייעשה שימוש בערך דגל -k של 5 (מודל נתונים של 64 סיביות). אם קיימים netCDF-4 אמיתיים.
מבנים ב-CDL, ייעשה שימוש בערך דגל -k של 3 (מודל משופר).

5. אם מאפיינים מיוחדים הקשורים לביצועים מצוינים ב-CDL, ערך דגל -k
ייעשה שימוש ב-4 מתוך 4 (מודל קלאסי של netCDF-XNUMX).

6. אחרת, ncgen יגדיר את הדגל -k ל-1 (מודל קלאסי).

דוגמאות

בדוק את התחביר של קובץ ה-CDLfoo.cdl':

ncgen foo.cdl

מקובץ ה-CDLfoo.cdl', צור קובץ netCDF בינארי שווה ערך בשם `x.nc':

ncgen -o x.nc foo.cdl

מקובץ ה-CDLfoo.cdl', צור תוכנית C המכילה את הפונקציה netCDF
קריאות הדרושות ליצירת קובץ netCDF בינארי שווה ערך בשם `x.nc':

ncgen -lc foo.cdl >xc

נוהג

CDL תחביר סקירה כללית
להלן דוגמה לתחביר CDL, המתאר קובץ netCDF עם מספר ממדים בעלי שם
(קו רוחב, קו אורך וזמן), משתנים (Z, t, p, rh, קו רוחב, קו אורך, זמן), תכונות משתנים (יחידות,
long_name, valid_range, _FillValue), וכמה נתונים. מילות מפתח של CDL מודגשות. (זה
הדוגמה נועדה להמחיש את התחביר; קובץ CDL אמיתי יהיה בעל מידע שלם יותר
קבוצת תכונות כך שהנתונים יהיו בעלי תיאור עצמי מלא יותר.)
netcdf foo { // דוגמה למפרט netCDF ב-CDL

סוגים:
ubyte enum enum_t {Clear = 0, Cumulonimbus = 1, Stratus = 2};
אטום(11) אטום_t;
int(*) vlen_t;

ממדים:
קו רוחב = 10, קו אורך = 5, זמן = בלתי מוגבל ;

משתנים:
ארוך lat(lat), lon(lon), זמן(זמן);
לצוף Z(זמן, רוחב, אורך), t(זמן, רוחב, אורך);
לְהַכפִּיל p(זמן, רוחב, אורך);
ארוך rh(זמן, רוחב, אורך);

מחרוזת מדינה (זמן, רוחב, אורך);
ubyte תָג;

// תכונות משתנות
קו רוחב (lat:long_name = "latitude");
יחידות lat = "מעלות_צפון";
lon:long_name = "קו אורך";
lon:units = "מעלות_מזרח";
זמן:יחידות = "שניות מאז 1992-1-1 00:00:00";

// תכונות משתנות מודפסות
מחרוזת Z: יחידות = "מטרים גיאופוטנציאליים";
לצוף Z: טווח_תקין = 0., 5000.;
לְהַכפִּיל p:_FillValue = -9999.;
ארוך rh:_FillValue = -1;
vlen_t :גלובלט = {17, 18, 19};
נתונים:
lat = 0, 10, 20, 30, 40, 50, 60, 70, 80, 90;
לונג = -140, -118, -96, -84, -52;
קבוצהז {
סוגים:
מתחם cmpd_t { vlen_t פ1; enum_t f2;};
} // קבוצה g
קבוצה: שעה {
משתנים:
/ g /cmpd_t תרכובת;
נתונים:
משתנה מורכב = {{3,4,5}, enum_t.Stratus};
} // קבוצה ח
}

כל משפטי ה-CDL מסתיימים בנקודה-פסיק. ניתן להשתמש ברווחים, טאבים ושורות חדשות.
בחופשיות לקריאה. הערות יכולות להופיע לאחר התווים `//` בכל שורה.

תיאור CDL מורכב מחמישה חלקים אופציונליים: סוגים, ממדים, משתנים, נתונים,
מתחיל עם מילת המפתח סוגים:, מידות:, משתנים:, ו `נתונים:`,
בהתאמה. שימו לב למספר דברים: (1) מילת המפתח כוללת את הנקודתיים הסופיות, כך שיש
אסור שיהיה רווח לפני תו הנקודתיים, ו-(2) מילות המפתח חייבות להיות
אוֹתִיוֹת קְטָנוֹת.

השמיים משתנים: סעיף עשוי להכיל משתנה הצהרות ו תכונה הקצאות. כל
מקטעים עשויים להכיל הקצאות מאפיינים גלובליות.

בנוסף, לאחר ה נתונים: סעיף, המשתמש יכול להגדיר סדרה של קבוצות (ראה את
(דוגמה לעיל). קבוצות עצמן יכולות להכיל סוגים, ממדים, משתנים, נתונים ו
קבוצות (מקוננות) אחרות.

ה-netCDF you סעיף מצהיר על הטיפוסים המוגדרים על ידי המשתמש. ניתן לבנות אותם באמצעות
כל אחד מהסוגים הבאים: enum, vlen, אטום, או מתחם.

netCDF ממד משמש להגדרת צורתו של אחד או יותר מהמרכיבים הרב-ממדיים
משתנים הכלולים בקובץ netCDF. לממד netCDF יש שם וגודל. א
ממד יכול להיות בעל ה- בלתי מוגבל גודל, מה שאומר שמשתנה המשתמש בממד זה יכול
לגדול לכל אורך באותו מימד.

A משתנה מייצג מערך רב-ממדי של ערכים מאותו סוג. למשתנה יש
שם, סוג נתונים וצורה המתוארת על ידי רשימת הממדים שלה. כל משתנה עשוי
יש גם קשורים תכונות (ראה להלן) וכן ערכי נתונים. השם, סוג הנתונים,
וצורת המשתנה מוגדרות על ידי ההכרזה שלו ב- משתנה קטע של CDL
תיאור. למשתנה יכול להיות אותו שם כמו לממד; לפי מוסכמה כגון
המשתנה הוא חד-ממדי ומכיל קואורדינטות של הממד שהוא נותן לו את השם.
לממדים אין צורך שיהיו משתנים תואמים.

netCDF תכונה מכיל מידע על משתנה netCDF או על netCDF כולו
מערך נתונים. מאפיינים משמשים לציון מאפיינים כגון יחידות, ערכים מיוחדים, מקסימום
וערכים מינימליים תקפים, גורמי קנה מידה, קיזוזים ופרמטרים. מידע על מאפיינים
מיוצג על ידי ערכים בודדים או מערכים של ערכים. לדוגמה, "יחידות" היא תכונה
מיוצג על ידי מערך תווים כגון "צלזיוס". לתכונה יש ערך משויך
משתנה, שם, סוג נתונים, אורך וערך. בניגוד למשתנים שהם
מיועד לנתונים, תכונות מיועדות למטא-דאטה (נתונים על נתונים). בניגוד לכך
netCDF-3, סוגי מאפיינים יכולים להיות כל סוג המוגדר על ידי המשתמש, כמו גם הסוג המובנה הרגיל
סוגים.

ב-CDL, תכונה מסומנת על ידי סוג aa, משתנה, ':', ולאחר מכן תכונה.
שם. הסוג הוא אופציונלי ואם חסר, הוא יוסק מהערכים שהוקצו.
לתכונה. ניתן להקצות גלוֹבָּלִי תכונות שאינן קשורות לאף אחת מהן
משתנה ל-netCDF בכללותו על ידי השמטת שם המשתנה בתכונה
הצהרה. שימו לב שישנה עמימות אפשרית במפרט כגון
x : a = ...
במצב זה, x יכול להיות או סוג של תכונה גלובלית, או שם המשתנה
עבור תכונה. מכיוון שיכולים להיות גם סוג בשם x וגם משתנה בשם x, יש
היא עמימות. הכלל הוא שבמצב זה, x יתפרש כסוג אם
אפשרי, ואחרת כמשתנה.

אם לא צוין, סוג הנתונים של תכונה ב-CDL נגזר מסוג ה-
ערך/ים שהוקצו לו. אורך התכונה הוא מספר ערכי הנתונים שהוקצו לו.
אליו, או מספר התווים במחרוזת התווים שהוקצתה לו. מרובים
ערכים מוקצים לתכונות שאינן תווים על ידי הפרדת הערכים באמצעות פסיקים.
ערכים שהוקצו לתכונה חייבים להיות מאותו סוג.

שמות הממדים, המשתנים, המאפיינים, הסוגים והקבוצות של CDL עשויים להכיל כל דבר
תו utf-8 שאינו תו שליטה למעט תו הלוכסן הקדמי (`/'). עם זאת, תווים מסוימים
תווים חייבים להיות מסוג escape אם הם משמשים בשם, כאשר תו ה-escape הוא ה-
קו נטוי לאחור `\'. בפרט, אם התו המוביל של השם הוא ספרה
(0-9), אזי יש להקדים אותו בתו בריחה. בנוסף, התווים `
!"#$%&()*,:;<=>?[]^`´{}|~\' חייב להיות מסומן ב-escape אם הוא מופיע במקום כלשהו בשם. שימו לב גם
ששמות מאפיינים המתחילים בקו תחתון (`_') שמורים לשימוש של
אין להשתמש ב-Unidata וב- בתכונות המוגדרות על ידי המשתמש.

שימו לב גם שהמילים `משתנה`, `מימד`, `נתונים`, `קבוצה` ו-`סוגים` הן חוקיות.
שמות CDL, אך יש להיזהר שיהיה רווח בינם לבין כל נקודתיים שאחריהם
תו כאשר משתמשים בו כשם משתנה. זוהי בעיקר בעיה עם תכונה
הצהרות. לדוגמה, קחו בחשבון זאת.

netcdf ... {
...
משתנים:
מידות int;
dimensions: attribute=0; // פעולה זו תגרום לשגיאה
ממדים: תכונה=0; // זה בסדר.
...
}

האופציונלי נתונים: החלק של מפרט CDL הוא המקום שבו משתני netCDF עשויים להיות
אותחל. התחביר של אתחול הוא פשוט: שם משתנה, סימן שוויון,
ורשימה של קבועים מופרדים בפסיקים (ייתכן ומופרדים באמצעות רווחים, טאבים ושורות חדשות)
מסתיים בנקודה-פסיק. עבור מערכים רב-ממדיים, הממד האחרון משתנה
המהיר ביותר. לכן, סדר שורות ולא סדר עמודות משמש עבור מטריצות. אם פחות ערכים
מסופקים יותר ממה שצריך כדי למלא משתנה, הוא מורחב עם משתנה תלוי-סוג
`fill value`, אשר ניתן לעקוף על ידי מתן ערך עבור משתנה ייחודי
תכונה בשם `_FillValue'. סוגי הקבועים אינם חייבים להתאים לסוג המוצהר עבור
משתנה; כפייה נעשית כדי להמיר מספרים שלמים למספרים צפה, לדוגמה. ה-
ניתן להשתמש בקבוע `_' כדי לציין את ערך המילוי עבור משתנה. אם סוג ה-
המשתנה הוא במפורש `string`, אז ניתן להשתמש בקבוע המיוחד `NIL` כדי לייצג
מחרוזת nil, שאינה זהה למחרוזת באורך אפס.

פרימיטיבי נתונים סוגים
char תווים
בייט נתונים של 8 סיביות
קצר מספרים שלמים חתומים של 16 סיביות
int מספרים שלמים חתומים של 32 סיביות
ארוך (מילה נרדפת ל int)
int64 מספרים שלמים חתומים של 64 סיביות
לצוף נקודה צפה מדויקת יחידה של IEEE (32 סיביות)
ממשי (מילה נרדפת ל לצוף)
לְהַכפִּיל נקודה צפה כפולה בדיוק של IEEE (64 סיביות)
ubyte נתונים לא חתומים של 8 סיביות
ushort מספרים שלמים לא חתומים של 16 סיביות
uint מספרים שלמים לא חתומים של 32 סיביות
uint64 מספרים שלמים לא חתומים של 64 סיביות
מחרוזת מחרוזות באורך שרירותי

CDL תומך בקבוצת-על של טיפוסי נתונים פרימיטיביים של C. שמות הפרימיטיביים
סוגי נתונים הם מילים שמורות ב-CDL, כך ששמות המשתנים, הממדים וה
מאפיינים אינם חייבים להיות שמות טיפוסים פרימיטיביים. בהצהרות, ניתן לציין שמות טיפוסים
באותיות גדולות או קטנות.

בתים נועדו להכיל שמונה ביטים מלאים של נתונים, ולבת אפס אין שום קוד מיוחד.
משמעות, כפי שזה עשוי להיות עבור נתוני אופי. ncgen המתגייר בייט הצהרות ל char
הצהרות בקוד C של הפלט ולקוד הלא סטנדרטי BYTE הצהרה בפלט
קוד פורטרן.

שורטס יכולים להחזיק ערכים בין -32768 ל-32767. ncgen המתגייר קצר הצהרות ל
קצר הצהרות בקוד C של הפלט ולקוד הלא סטנדרטי מספר שלם*2 הצהרה ב
פלט קוד Fortran.

מספרים אינטגרליים יכולים להכיל ערכים בין -2147483648 ל- 2147483647. ncgen המתגייר int הצהרות
ל int הצהרות בקוד C של הפלט ול- מספר שלם הצהרות בפלט של Fortran
קוד. ארוך מקובל כמילה נרדפת ל int בהצהרות CDL, אך הוצא משימוש מאז
כיום קיימות פלטפורמות עם ייצוגים של 64 סיביות עבור קוד C long.

Int64 יכול להכיל ערכים בין -9223372036854775808 ל- 9223372036854775807. ncgen
המתגייר int64 הצהרות ל ארוך ארוך הצהרות בקוד C של הפלט.

צפים יכולים להחזיק ערכים בין -3.4+38 ל-3.4+38 בערך. הייצוג החיצוני שלהם הוא
כמספרים צפה בדיוק יחיד מנורמלים על ידי IEEE של 32 סיביות. ncgen המתגייר לצוף
הצהרות ל לצוף הצהרות בקוד C של הפלט ול- נדל"ן הצהרות בפלט
קוד פורטרן. ממשי מקובל כמילה נרדפת ל לצוף בהצהרות CDL.

כפילים יכולים להחזיק ערכים בין -1.7+308 ל-1.7+308 בערך. הייצוג החיצוני שלהם
הוא כמספרים צפה בדיוק כפול מנורמלים בתקן IEEE של 64 סיביות. ncgen
המתגייר לְהַכפִּיל הצהרות ל לְהַכפִּיל הצהרות בקוד C של הפלט ול- לְהַכפִּיל
דיוק הצהרות בפלט של קוד Fortran.

המקבילים הלא חתומים של סוגי המספרים השלמים הנ"ל ממופים למספרים המתאימים
סוגי C לא חתומים. הטווחים שלהם משתנים כראוי כדי להתחיל מאפס.

הפרשנות הטכנית של סוג ה-char היא שזהו ערך לא חתום של 8 סיביות.
קידוד 256 הערכים האפשריים אינו מוגדר כברירת מחדל. משתנה מסוג char עשוי
יסומן בתכונה "_Encoding" כדי לציין את קבוצת התווים שתשמש: US-
ASCII, ISO-8859-1 וכו'. שימו לב שציון קידוד UTF-8 שווה ערך ל-
ציון US-ASCII הסיבה לכך היא שלא ניתן לאחסן תווי UTF-8 מרובי בתים ב-
תו של 8 סיביות. ערכי UTF-8 החוקיים היחידים של בייט בודד הם, לפי הגדרה, תווים של 7 סיביות אמריקאיות.
קידוד ASCII כאשר הסיבית העליונה מוגדרת לאפס.

מחרוזות מניחות כברירת מחדל כמקודדות באמצעות UTF-8. שימו לב שזה אומר ש
קידודי UTF-8 מרובי בייט עשויים להימצא במחרוזת, כך שייתכן שהמספר
מספר תווי UTF-8 נפרדים במחרוזת קטן ממספר הבייטים של 8 סיביות המשמשים ל
לאחסן את המחרוזת.

CDL קבועים
קבועים המוקצים לתכונות או משתנים יכולים להיות מכל אחד מסוגי netCDF הבסיסיים.
התחביר עבור קבועים דומה לתחביר C, פרט לכך שסיומות הסוג חייבות להיות
מצורף למכנסיים קצרים ולגלימות מצופות כדי להבדיל אותן ממכנסיים ארוכים וכפולים.

A בייט קבוע מיוצג על ידי קבוע מספר שלם עם האות `b' (או `B'). ב
בממשק ה-API הישן של netCDF-2, ניתן היה לייצג קבועי בייט גם באמצעות תווים בודדים או
רצפי בריחה סטנדרטיים של תווים ב-C כגון `a' או `0. זה עדיין נתמך עבור
תאימות לאחור, אך הוצאה משימוש כדי להבהיר את ההבחנה בין המספרים
סוג בייט וסוג תו טקסטואלי. דוגמאות לקבועי בייט כוללים:
0b // בייט אפס
-1b // -1 כבייט של 8 סיביות
255b // גם -1 כבית חתום של 8 סיביות

קצר קבועי מספרים שלמים נועדו לייצוג כמויות חתומות של 16 סיביות. הצורה
של קצר קבוע הוא קבוע שלם עם `s` או `S` נוסף. אם קצר
קבוע שמתחיל ב-'0', הוא מתפרש כאוקטלי, אלא שאם הוא מתחיל ב-'0x',
הוא מתפרש כקבוע הקסדצימלי. לדוגמה:
-2s // קצר -2
0123s // אוקטלי
0x7ffs // הקסדצימלי

int קבועי מספרים שלמים נועדו לייצוג כמויות חתומות של 32 סיביות. צורת
an int קבוע הוא קבוע שלם רגיל, למרות שמקובל לאפשר זאת באופן אופציונלי.
הוסף `l' או `L' יחיד (שוב, מוצדק). היזהרו, עם זאת, הסיומת L היא
מתפרש כמספר שלם של 32 סיביות, ולעולם לא כמספר שלם של 64 סיביות. זה יכול לבלבל
מכיוון שסוג C long יכול להיות באופן דו-משמעי או 32 סיביות או 64 סיביות.

אם int קבוע שמתחיל ב-'0', הוא מתפרש כאוקטלי, אלא שאם הוא מתחיל
עם `0x', הוא מתפרש כקבוע הקסדצימלי (אך ראה קבועים אטומים להלן).
דוגמאות של תקפות int קבועים כוללים:
-2
1234567890L
0123 // אוקטלי
0x7ff // הקסדצימלי

int64 קבועי מספרים שלמים נועדו לייצוג כמויות חתומות של 64 סיביות. הצורה
של int64 קבוע הוא קבוע שלם עם האות `ll' או `LL'. אם int64
קבוע שמתחיל ב-'0', הוא מתפרש כאוקטלי, אלא שאם הוא מתחיל ב-'0x',
הוא מתפרש כקבוע הקסדצימלי. לדוגמה:
-2ll // 2- לא חתום
0123LL // אוקטלי
0x7ffLL //הקסדצימלי

קבועי נקודה צפה מסוג לצוף מתאימים לייצוג נקודה צפה
נתונים בדיוק של כשבע ספרות משמעותיות. צורתו של לצוף קבוע הוא
זהה לקבוע נקודה צפה ב-C עם `f' או `F' מצורפים. לדוגמה,
כל הדברים הבאים מקובלים לצוף קבועים:
-2.0ו
3.14159265358979f // ייקצץ לדיוק נמוך יותר
1. f

קבועי נקודה צפה מסוג לְהַכפִּיל מתאימים לייצוג נקודה צפה
נתונים בדיוק של כשש עשרה ספרות משמעותיות. צורתו של לְהַכפִּיל קבוע הוא
זהה לקבוע נקודה צפה ב-C. ניתן להוסיף `d' או `D' אופציונליים. עבור
לדוגמה, הדברים הבאים כולם מקובלים לְהַכפִּיל קבועים:
-2.0
3.141592653589793
1.0e-20
1. ד

ניתן ליצור קבועי מספרים שלמים לא חתומים על ידי הוספת התו 'U' או 'u' בין
הקבוע וכל מציין גודל נגרר, או מיד בסוף הגודל
מציין. לכן אפשר לומר 10U, 100su, 100000ul, או 1000000llu, לדוגמה.

ניתן להקיף קבועי תווים בודדים במרכאות בודדות. אם רצף של תו אחד או יותר
תווים מוקפים במרכאות כפולות, אזי יש להסיק את פרשנותם מה-
הקשר. אם מערך הנתונים נוצר באמצעות המודל הקלאסי של netCDF, אז כל הקבועים הללו
מתפרשים כמערך תווים, כך שכל תו בקבוע מתפרש כ
אם זה היה תו בודד. אם מערך הנתונים מורחב ב-netCDF, אז הקבוע עשוי
להתפרש כמודל הקלאסי או כמחרוזת אמיתית (ראה להלן) בהתאם ל-
סוג התכונה או המשתנה שבו נמצאת המחרוזת.

הפרשנות של קבועי תווים היא שאלה שנמצאים בטווח ASCII להדפסה
(' '..'~') מניחים שמקודדים כקבוצת משנה בת 1 בייט של UTF-8, השווה ערך ל-
US-ASCII. בכל המקרים, מוסכמות הבריחה הרגילות של מחרוזות C מכובדות עבור ערכים מ
0 עד 127. ערכים גדולים מ-127 מותרים, אך קידודם אינו מוגדר. עבור
ב-netCDF מורחב, השימוש בסוג char הוצא משימוש לטובת סוג string.

כמה דוגמאות לקבועי תווים הן כדלקמן.
'a' // ASCII `a'
"א" // שווה ערך ל-'א'
"שתי שורות" // מחרוזת בת 10 תווים עם שתי שורות חדשות מוטמעות
"a bell:\007" // מחרוזת המכילה פעמון ASCII
שים לב שמערך התווים netCDF "a" יתאים למשתנה בעל אלמנט אחד, מכיוון שאין
מניחים תו NULL מסתיים. עם זאת, בייט אפס במערך תווים הוא
מתפרש כסוף הדמויות המשמעותיות על ידי ה ncdump תוכנית, בעקבות ה
מוסכמה ב-C. לכן, אין להטמיע בייט NULL במחרוזת תווים אלא אם כן
בסוף: השתמשו ב- בייט סוג נתונים במקום זאת עבור מערכי בתים המכילים את הבייט אפס.

מחרוזת קבועים, כמו קבועי תווים, מיוצגים באמצעות מרכאות כפולות. זה
מייצג עמימות פוטנציאלית מכיוון שמחרוזת מרובת תווים עשויה גם להצביע על א
ערך תווים ממדי. הבהרה מתרחשת בדרך כלל לפי ההקשר, אך יש לנקוט משנה זהירות
נלקח כדי לציין אתמחרוזת סוג כדי להבטיח את הבחירה הנכונה. הנחות הן על קבועי מחרוזת
להיות תמיד מקודד ב-UTF-8. משמעות הדבר היא שקבוע המחרוזת עשוי למעשה
מכילים תווי UTF-8 מרובי בתים. ניתן להשתמש בקבוע המיוחד `NIL` כדי לייצג
מחרוזת nil, שאינה זהה למחרוזת באורך אפס.

אטום קבועים מיוצגים כרצפים של ספרות הקסדצימליות שלפניהן 0X או 0x:
0xaa34ffff, לדוגמה. קבועים אלה עדיין יכולים לשמש כקבועים שלמים ויהיו
ניתן לקצר או להרחיב לפי הצורך.

תרכובת קָבוּעַ ביטויים
כדי להקצות ערכים למשתנים (או תכונות) שסוגם הוא מסוג מוגדר על ידי המשתמש,
סימון הקבוע הורחב כך שיכלול רצפים של קבועים הכלולים ב
סוגריים מסולסלים (למשל "{"..."}"). קבוע כזה נקרא קבוע מורכב, ו
ניתן לקנן קבועים מורכבים.

בהינתן טיפוס "T(*) vlen_t", כאשר T הוא טיפוס בסיס שרירותי אחר, קבועים עבורו
יש לפרט כדלקמן.
vlen_t var[2] = {t11,t12,...t1N}, {t21,t22,...t2m};
הערכים tij, מניחים שהם קבועים מסוג T.

בהינתן הסוג "compound cmpd_t {T1 f1; T2 f2...Tn fn}", כאשר ה-Ti הם שרירותיים אחרים
סוגי בסיסים, יש לציין קבועים עבורם באופן הבא.
cmpd_t var[2] = {t11,t12,...t1N}, {t21,t22,...t2n};
הערכים tij, מניחים שהם קבועים מסוג Ti. אם השדות חסרים, אז
הם יוגדרו באמצעות כל ערך מילוי שצוין או ערך ברירת מחדל עבור סוג הבסיס של השדה.

מערכת הכללים הכללית לשימוש בגשרים מוגדרת ב מפרט רשימות נתונים סעיף
לְהַלָן.

סקופינג חוקי
עם הוספת קבוצות, מרחב השמות עבור אובייקטים מוגדרים אינו שטוח עוד.
ניתן להוסיף קידומת של הפניות (שמות) מכל סוג, ממד או משתנה - המילה המוחלטת.
נתיב המציין הצהרה ספציפית. כך אפשר לומר
משתנים:
/g1/g2/t1 גרסה 1;
הסוג שאליו מתייחסים (t1) הוא זה שבתוך קבוצה g2, אשר בתורה מקוננת ב-
קבוצה g1. הדמיון של סימון זה לנתיבי קבצים של יוניקס הוא מכוון, וניתן
התייחסו לקבוצות כאל סוג של מבנה ספריות.

כאשר השם אינו כולל קידומת, אזי כללי טווח מוחלים כדי לאתר את מה שצוין
הצהרה. נכון לעכשיו ישנם שלושה כללים: אחד למידות, אחד לסוגים ו
קבועי ספירה, ואחד עבור כל האחרים.

כאשר משתמשים בשם לא מוגדר של ממד (כמו בהצהרת משתנה), ncgen קודם כל
מחפש בקבוצה המקיפה אותו מיד אחר הממד. אם הוא לא נמצא
שם, ואז זה נראה בקבוצה שמקיפה את הקבוצה הזו. זה ממשיך במעלה
היררכיית קבוצות עד למציאת הממד, או עד שאין עוד קבוצות
לחפש.

2. כאשר משתמשים בשם ללא קידומת של סוג או קבוע ספירה, ncgen מחפש
עץ הקבוצות באמצעות חיפוש עומק-ראשית לפי הזמנה מראש. משמעות הדבר היא שהוא
ימצא את ההצהרה התואמת שקדמה להפניה באופן טקסטואלי בקובץ ה-cdl
קובץ והוא "הגבוה ביותר" בהיררכיית הקבוצות.

3. עבור כל שאר השמות, מתבצע חיפוש רק בקבוצה הסובבת מיד.

הערה אחרונה. הפניות קדימה אינן מותרות. משמעות הדבר היא שציון, למשל
לדוגמה, ‎/g1/g2/t1 ייכשל אם הפניה זו מתרחשת לפני ש-g1 ו/או g2 מוגדרים.

מפרט ספירה קבועים
הפניות לקבועי ספירה (ברשימות נתונים) יכולות להיות דו משמעיות מכיוון שאותן
ניתן להגדיר את שם קבוע הספירה ביותר מספירה אחת. אם קובץ cdl
אם ציין קבוע דו-משמעי, אז ncgen יסמן שגיאה. קבועים כאלה יכולים להיות
מופשט בשתי דרכים.

1. הוסף את קידומת קבוע הספירה בשם הספירה המופרד על ידי a
נְקוּדָה: enum.econst, למשל.

2. אם מקרה אחד אינו מספיק כדי להבהיר את קבוע הספירה, אז מקרה אחד
יש לציין את סוג הספירה המדויק באמצעות נתיב קבוצה: /g1/g2/enum.econst,
למשל.

מיוחד תכונות
ניתן לציין מאפיינים מיוחדים, וירטואליים, כדי לספק מידע הקשור לביצועים
לגבי פורמט הקובץ ולגבי מאפייני משתנה. הקובץ חייב להיות קובץ netCDF-4 עבור
אלה ייכנסו לתוקף.

תכונות וירטואליות מיוחדות אלה אינן למעשה חלק מהקובץ, הן בסך הכל
דרך נוחה להגדיר מאפיינים שונים של הנתונים ב-CDL

התכונות המיוחדות הנתמכות כעת הן כדלקמן: `_Format', `_Fletcher32,
`_ChunkSizes', `_Endianness', `_DeflateLevel', `_Shuffle', ו-`_Storage'.

`_Format' הוא מאפיין גלובלי המציין את גרסת הפורמט netCDF. ערכו חייב להיות
מחרוזת בודדת התואמת לאחד מ-`classic', `64-bit offset', `64-bit data', `netCDF-4', או
`מודל קלאסי של netCDF-4`.

שאר התכונות המיוחדות הן כולן תכונות משתנות. למעשה, כולן אז
למפות לפונקציה מקבילה כלשהי של `nc_def_var_XXX' כפי שמוגדרת בממשק ה-API של netCDF-4.
המאפיינים שהם למעשה בוליאניים (_Fletcher32, _Shuffle, ו-_NOFILL), ה-
ניתן לציין את הערך true באמצעות המחרוזות `true' או `1', או באמצעות המספר השלם 1.
הערך false מצפה למספר `false', `0' או למספר השלם 0. הפעולות הקשורות
עם תכונות אלה הן כדלקמן.

1. `_Fletcher32 מגדיר את המאפיין `fletcher32' עבור משתנה.

2. `_Endianness' הוא או `little' או `big', תלוי באופן שבו המשתנה מאוחסן כאשר
נכתב לראשונה.

3. `_DeflateLevel' הוא מספר שלם בין 0 ל-9 כולל אם בוצעה דחיסה
שצוין עבור המשתנה.

4. `_Shuffle' מציין אם יש להשתמש במסנן הפעולות האקראי.

5. `_Storage' הוא `רציף' או `chunked'.

6. `_ChunkSizes' היא רשימה של גדלי קטעים עבור כל ממד של המשתנה

שים לב שלתכונות כגון "add_offset" או "scale_factor" אין משמעות מיוחדת עבור
ncgen. מאפיינים אלה הם כיום מוסכמות, המטופלות מעל שכבת הספרייה על ידי
חבילות שירות אחרות, לדוגמה NCO.

מפרט רשימות נתונים
ציון רשימות נתונים עבור משתנים בקטע `data:` יכול להיות מסובך במקצת.
ישנם כמה כללים שיש להקפיד עליהם כדי להבטיח ניתוח נכון של רשימות נתונים
על ידי ncgen.

ראשית, הרמה העליונה נחשבת אוטומטית לרשימת פריטים, ולכן אין להתייחס אליה כאל
בתוך {...}. משמעות הדבר היא שאם המשתנה הוא סקלרי, יהיה חלק עליון יחיד-
אלמנט level ואם המשתנה הוא מערך, יהיו N אלמנטים ברמה העליונה. עבור
עבור כל רכיב ברשימה ברמה העליונה, יש להחיל את הכללים הבאים.

1. יש להקיף מופעים בעלי ממדים בלתי מוגבלים (מלבד הממד הראשון)
על ידי {...} על מנת לציין את הגודל.

2. יש להטמיע מופעים מורכבים ב-{...}

3. שדות לא סקלריים של מופעים מורכבים חייבים להיות מוטמעים ב-{...}.

4. מופעים של vlens חייבים להיות מוקפים ב-{...} על מנת לציין את הגודל.

רשימות נתונים הקשורות לתכונות הן באופן מרומז וקטור (כלומר, רשימה) של ערכים של
יש להתחשב בכך בסוג המאפיין והכללים לעיל.

7. אין להשתמש בפלטה אחרת.

שימו לב שאחת התוצאות של כללים אלה היא שמערכים של ערכים לא יכולים לכלול תת-מערכים.
בתוך סוגריים מרובעים. חשבו, לדוגמה, על int var(d1)(d2)...(dn), כאשר אף אחד מ-d2...dn אינו
בלתי מוגבל. רשימת נתונים עבור משתנה זה חייבת להיות רשימה אחת של מספרים שלמים, כאשר ה-
מספר המספרים השלמים אינו עולה על ערכי D=d1*d2*...dn; שימו לב שהרשימה יכולה להיות קצרה יותר
מאשר D, ובמקרה כזה ערכי מילוי ישמשו כדי לרפד את הרשימה.

כלל 6 בנוגע לרשימת נתונים של מאפיינים גורם לתוצאה הבאה. אם סוג ה-
התכונה היא מסוג מורכב (או vlen), ואם מספר הערכים ברשימה הוא אחד,
אז יש לתחום את המופעים המורכבים בסוגריים מרובעים.

מפרט אופי רשימות נתונים
ציון רשימות נתונים עבור משתנים מסוג char טומן בחובו גם כמה סיבוכים. קחו בחשבון, עבור
דוגמה
מידות: u=ללא הגבלה; d1=1; d2=2; d3=3;
d4=4; d5=5; u2=UNLIMITED;
משתנים: char var(d4,d5);
רשימת נתונים: var="1", "שתיים", "שלוש";

יש לנו עשרים אלמנטים של var למלא (d5 X d4) ויש לנו שלוש מחרוזות באורך 1, 3,
5. כיצד ניתן להקצות את התווים במחרוזות לעשרים האלמנטים?

זה מאתגר מכיוון שרצוי לחקות את ה-ncgen המקורי (ncgen3). ה-
אלגוריתם הליבה הוא באופן רעיוני כדלקמן.

1. נניח שיש לנו קבוצת ממדים D1..Dn, כאשר D1 יכול להיות אופציונלי בלתי מוגבל
ממד. ההנחה היא שכל גדלי ה-Di ידועים (כולל בלתי מוגבלים)
ממדים).

2. בהינתן רצף של קבועי מחרוזת או תווים C1..Cm, מטרתנו היא לבנות
מחרוזת בודדת שאורכה הוא מכפלה צולבת של D1 עד Dn. שימו לב שלצורך
באלגוריתם זה, קבועי תווים מטופלים כמחרוזות בגודל 1.

3. בנה את Dx = מכפלה צולבת של D1 עד D(n-1).

4. עבור כל קבוע Ci, הוסף תווי מילוי לפי הצורך כך שאורכו יהיה כפולה של
דן

5. שרשר את C1..Cm שהשתנה כדי לייצר את המחרוזת S.

6. הוסף תווי מילוי ל-S כדי שהאורך שלה יהיה כפולה של Dn.

8. אם S ארוך יותר מ-Dx * Dn, יש לחתוך אותו וליצור אזהרה.

ישנם שלושה מקרים נוספים ראויים לציון.

1. אם יש רק ממד אחד, בלתי מוגבל, אז כל הקבועים הם
תווים משורשרים ומילוי מתווספים לסוף המחרוזת המתקבלת כדי ליצור
אורכו יהיה זהה לממד הבלתי מוגבל. אם האורך גדול מה-
ממד בלתי מוגבל, אז הוא נקטם עם אזהרה.

2. במקרה של תו שהוקלד vlen, לדוגמה "char(*) vlen_t". אנחנו פשוט
שרשור את כל הקבועים ללא מילוי כלל.

3. במקרה של תכונה שהוקלדה באמצעות תו, אנו פשוט משרשרים את כל הקבועים.

ב-netcdf-4, ממדים אחרים מלבד הראשון יכולים להיות בלתי מוגבלים. כמובן לפי הכללים
לעיל, יש להפריד בין המופעים הפנימיים הבלתי מוגבלים על ידי {...}. לדוגמה.
משתנים: char var(u,u2);
רשימת נתונים: var={"1", "שתיים"}, {"שלוש"};
במקרה זה, ל-u יהיה אורך אפקטיבי של שניים. בתוך כל מופע של u2, ה-
הכללים לעיל יחולו, מה שיוביל לכך.
רשימת נתונים: var={"1","t","w","o"}, {"t","h","r","e","e"};
הגודל האפקטיבי של u2 יהיה המקסימום מבין שני אורכי המופע (חמישה במקרה זה)
והקצר יותר יהיה מרופד כדי לייצר זאת.
רשימת נתונים: var={"1","t","w","o","\0"}, {"t","h","r","e","e"};

קחו בחשבון מקרה מורכב אף יותר.
משתנים: char var(u,u2,u3);
רשימת נתונים: var={{"1", "שתיים"}}, {{"שלושה"},{"ארבעה","xy"}};
במקרה זה, ל-u שוב יהיה אורך אפקטיבי של שניים. למידות u2 יהיה
size = max(1,2) = 2; בתוך כל מופע של u2, הכללים לעיל יחולו, מה שיוביל ל
זֶה.
רשימת נתונים: משתנה = {{"1", "t", "w", "o"}}, {{"t", "h", "r", "e", "e"},{"f", "o", "u", "r", "x", "y"}};
הגודל האפקטיבי של u3 יהיה המקסימום מבין שני אורכי המופעים (שישה במקרה זה)
והקצרים יותר יהיו מרופדים כדי לייצר זאת.
רשימת נתונים: משתנה = {{"1", "t", "w", "o", "", "}}, {{"t", "h", "r", "e", "e", "},{"f", "o", "u", "r", "x", "y"}};
שימו לב עם זאת שהמופע הראשון של u2 קצר מהאורך המקסימלי של u2, לכן אנו צריכים
כדי להוסיף מילוי עבור מופע נוסף של u2, וליצור את זה.
רשימת נתונים: משתנה = {{"1", "t", "w", "o", "", "}, {" "", "", "", "", "", "", "}}, {{"t", "h", "r", "e", "e", "}, {"f", "o", "u", "r", "x", "y"}};

השתמש ב-ncgen באינטרנט באמצעות שירותי onworks.net