Johan Bregeon / gammalib

Commit 1fff8b907ae230b360d833ae0e09cbccfd1662f4

Authored by knodlseder
1 parent a235d9c7

evening save

Inline Side-by-side
Showing 14 changed files with 609 additions and 421 deletions
include/GFitsDblImage.hpp
  View file @1fff8b9
@@ -50,9 +50,12 @@ public: @@ -50,9 +50,12 @@ public:
50 double& operator() (const int& ix, const int& iy); 50 double& operator() (const int& ix, const int& iy);
51 const double& operator() (const int& ix, const int& iy) const; 51 const double& operator() (const int& ix, const int& iy) const;
52 double& operator() (const int& ix, const int& iy, const int& iz); 52 double& operator() (const int& ix, const int& iy, const int& iz);
53 - const double& operator() (const int& ix, const int& iy, const int& iz) const;  
54 - double& operator() (const int& ix, const int& iy, const int& iz, const int& it);  
55 - const double& operator() (const int& ix, const int& iy, const int& iz, const int& it) const; 53 + const double& operator() (const int& ix, const int& iy, const int& iz)
  54 + const;
  55 + double& operator() (const int& ix, const int& iy, const int& iz,
  56 + const int& it);
  57 + const double& operator() (const int& ix, const int& iy, const int& iz,
  58 + const int& it) const;
56 59
57 60
58 // Methods 61 // Methods
include/GFitsTableCol.hpp
  View file @1fff8b9
@@ -30,7 +30,7 @@ @@ -30,7 +30,7 @@
30 * 30 *
31 * @brief Abstract interface for FITS table column 31 * @brief Abstract interface for FITS table column
32 * 32 *
33 - * This class implements a FITS table column. 33 + * This class implements a FITS table column. Vector columns are supported.
34 ***************************************************************************/ 34 ***************************************************************************/
35 class GFitsTableCol { 35 class GFitsTableCol {
36 36
@@ -43,6 +43,7 @@ class GFitsTableCol { @@ -43,6 +43,7 @@ class GFitsTableCol {
43 public: 43 public:
44 // Constructors and destructors 44 // Constructors and destructors
45 GFitsTableCol(); 45 GFitsTableCol();
  46 + GFitsTableCol(const int& length, const int& size = 1);
46 GFitsTableCol(const GFitsTableCol& column); 47 GFitsTableCol(const GFitsTableCol& column);
47 virtual ~GFitsTableCol(); 48 virtual ~GFitsTableCol();
48 49
@@ -50,23 +51,13 @@ public: @@ -50,23 +51,13 @@ public:
50 GFitsTableCol& operator= (const GFitsTableCol& column); 51 GFitsTableCol& operator= (const GFitsTableCol& column);
51 52
52 // Virtual Methods 53 // Virtual Methods
53 - virtual std::string string(const int& row, const int& col = 0) = 0;  
54 - virtual double real(const int& row, const int& col = 0) = 0;  
55 - virtual int integer(const int& row, const int& col = 0) = 0; 54 + virtual std::string string(const int& row, const int& inx = 0) = 0;
  55 + virtual double real(const int& row, const int& inx = 0) = 0;
  56 + virtual int integer(const int& row, const int& inx = 0) = 0;
56 virtual GFitsTableCol* clone(void) const = 0; 57 virtual GFitsTableCol* clone(void) const = 0;
57 - virtual double* ptr_double(void) = 0;  
58 - virtual float* ptr_float(void) = 0;  
59 - virtual short* ptr_short(void) = 0;  
60 - virtual long* ptr_long(void) = 0;  
61 - virtual int* ptr_int(void) = 0;  
62 58
63 // Base class Methods 59 // Base class Methods
64 void name(const std::string& name); 60 void name(const std::string& name);
65 - //void colnum(const int& colnum); //!< DO WE REALLY NEED THIS???  
66 - //void type(const int& type); //!< DO WE REALLY NEED THIS???  
67 - //void repeat(const int repeat); //!< DO WE REALLY NEED THIS???  
68 - //void width(const int width); //!< DO WE REALLY NEED THIS???  
69 - //void length(const int& length); //!< DO WE REALLY NEED THIS???  
70 std::string name(void); 61 std::string name(void);
71 int colnum(void); 62 int colnum(void);
72 int type(void); 63 int type(void);
@@ -94,9 +85,4 @@ private: @@ -94,9 +85,4 @@ private:
94 void connect(__fitsfile* fptr); 85 void connect(__fitsfile* fptr);
95 }; 86 };
96 87
97 -  
98 -/***************************************************************************  
99 - * Inline methods *  
100 - ***************************************************************************/  
101 -  
102 #endif /* GFITSTABLECOL_HPP */ 88 #endif /* GFITSTABLECOL_HPP */
include/GFitsTableDblCol.hpp
  View file @1fff8b9
@@ -10,6 +10,11 @@ @@ -10,6 +10,11 @@
10 * (at your option) any later version. * 10 * (at your option) any later version. *
11 * * 11 * *
12 ***************************************************************************/ 12 ***************************************************************************/
  13 +/**
  14 + * @file GFitsTableDblCol.hpp
  15 + * @brief GFitsTableDblCol class definition.
  16 + * @author J. Knodlseder
  17 + */
13 18
14 #ifndef GFITSTABLEDBLCOL_HPP 19 #ifndef GFITSTABLEDBLCOL_HPP
15 #define GFITSTABLEDBLCOL_HPP 20 #define GFITSTABLEDBLCOL_HPP
@@ -24,30 +29,33 @@ @@ -24,30 +29,33 @@
24 /* __ Structures _________________________________________________________ */ 29 /* __ Structures _________________________________________________________ */
25 30
26 31
27 -/***************************************************************************  
28 - * GFitsTableDblCol class definition * 32 +/***********************************************************************//**
  33 + * @class GFitsTableDblCol
  34 + *
  35 + * @brief Interface for FITS table double precision column
  36 + *
  37 + * This class implements a FITS table double precision column.
29 ***************************************************************************/ 38 ***************************************************************************/
30 class GFitsTableDblCol : public GFitsTableCol { 39 class GFitsTableDblCol : public GFitsTableCol {
31 40
32 public: 41 public:
33 // Constructors and destructors 42 // Constructors and destructors
34 GFitsTableDblCol(); 43 GFitsTableDblCol();
  44 + GFitsTableDblCol(const int& length, const int& size = 1);
35 GFitsTableDblCol(const GFitsTableDblCol& column); 45 GFitsTableDblCol(const GFitsTableDblCol& column);
36 virtual ~GFitsTableDblCol(); 46 virtual ~GFitsTableDblCol();
37 47
38 // Operators 48 // Operators
39 GFitsTableDblCol& operator= (const GFitsTableDblCol& column); 49 GFitsTableDblCol& operator= (const GFitsTableDblCol& column);
  50 + double& operator() (const int& row, const int& inx = 0);
  51 + const double& operator() (const int& row, const int& inx = 0) const;
40 52
41 // Methods 53 // Methods
42 - std::string string(const int& row, const int& col = 0);  
43 - double real(const int& row, const int& col = 0);  
44 - int integer(const int& row, const int& col = 0); 54 + std::string string(const int& row, const int& inx = 0);
  55 + double real(const int& row, const int& inx = 0);
  56 + int integer(const int& row, const int& inx = 0);
45 GFitsTableDblCol* clone(void) const; 57 GFitsTableDblCol* clone(void) const;
46 - double* ptr_double(void);  
47 - float* ptr_float(void);  
48 - short* ptr_short(void);  
49 - long* ptr_long(void);  
50 - int* ptr_int(void); 58 + double* data(void);
51 void set_nullval(const double* value); 59 void set_nullval(const double* value);
52 60
53 private: 61 private:
@@ -55,24 +63,13 @@ private: @@ -55,24 +63,13 @@ private:
55 void init_members(void); 63 void init_members(void);
56 void copy_members(const GFitsTableDblCol& column); 64 void copy_members(const GFitsTableDblCol& column);
57 void free_members(void); 65 void free_members(void);
58 - void load(void); 66 + void fetch_data(void);
59 67
60 // Private data area 68 // Private data area
61 - int m_size; // Size of data area  
62 - double* m_data; // Data area  
63 - double* m_nulval; // NULL value  
64 - int m_anynul; // Number of NULLs encountered 69 + int m_size; //!< Size of data area
  70 + double* m_data; //!< Data area
  71 + double* m_nulval; //!< NULL value
  72 + int m_anynul; //!< Number of NULLs encountered
65 }; 73 };
66 74
67 -  
68 -/***************************************************************************  
69 - * Inline methods *  
70 - ***************************************************************************/  
71 -inline double* GFitsTableDblCol::ptr_double(void) { return m_data; }  
72 -inline  
73 -GFitsTableDblCol* GFitsTableDblCol::clone(void) const  
74 -{  
75 - return new GFitsTableDblCol(*this);  
76 -}  
77 -  
78 #endif /* GFITSTABLEDBLCOL_HPP */ 75 #endif /* GFITSTABLEDBLCOL_HPP */
include/GFitsTableFltCol.hpp
  View file @1fff8b9
@@ -10,6 +10,11 @@ @@ -10,6 +10,11 @@
10 * (at your option) any later version. * 10 * (at your option) any later version. *
11 * * 11 * *
12 ***************************************************************************/ 12 ***************************************************************************/
  13 +/**
  14 + * @file GFitsTableFltCol.hpp
  15 + * @brief GFitsTableFltCol class definition.
  16 + * @author J. Knodlseder
  17 + */
13 18
14 #ifndef GFITSTABLEFLTCOL_HPP 19 #ifndef GFITSTABLEFLTCOL_HPP
15 #define GFITSTABLEFLTCOL_HPP 20 #define GFITSTABLEFLTCOL_HPP
@@ -24,8 +29,12 @@ @@ -24,8 +29,12 @@
24 /* __ Structures _________________________________________________________ */ 29 /* __ Structures _________________________________________________________ */
25 30
26 31
27 -/***************************************************************************  
28 - * GFitsTableFltCol class definition * 32 +/***********************************************************************//**
  33 + * @class GFitsTableFltCol
  34 + *
  35 + * @brief Interface for FITS table floating point column
  36 + *
  37 + * This class implements a FITS table floating point column.
29 ***************************************************************************/ 38 ***************************************************************************/
30 class GFitsTableFltCol : public GFitsTableCol { 39 class GFitsTableFltCol : public GFitsTableCol {
31 40
@@ -43,11 +52,7 @@ public: @@ -43,11 +52,7 @@ public:
43 double real(const int& row, const int& col = 0); 52 double real(const int& row, const int& col = 0);
44 int integer(const int& row, const int& col = 0); 53 int integer(const int& row, const int& col = 0);
45 GFitsTableFltCol* clone(void) const; 54 GFitsTableFltCol* clone(void) const;
46 - double* ptr_double(void);  
47 - float* ptr_float(void);  
48 - short* ptr_short(void);  
49 - long* ptr_long(void);  
50 - int* ptr_int(void); 55 + float* data(void);
51 void set_nullval(const float* value); 56 void set_nullval(const float* value);
52 57
53 private: 58 private:
@@ -58,21 +63,15 @@ private: @@ -58,21 +63,15 @@ private:
58 void load(void); 63 void load(void);
59 64
60 // Private data area 65 // Private data area
61 - int m_size; // Size of data area  
62 - float* m_data; // Data area  
63 - float* m_nulval; // NULL value  
64 - int m_anynul; // Number of NULLs encountered 66 + int m_size; //!< Size of data area
  67 + float* m_data; //!< Data area
  68 + float* m_nulval; //!< NULL value
  69 + int m_anynul; //!< Number of NULLs encountered
65 }; 70 };
66 71
67 72
68 /*************************************************************************** 73 /***************************************************************************
69 * Inline methods * 74 * Inline methods *
70 ***************************************************************************/ 75 ***************************************************************************/
71 -inline float* GFitsTableFltCol::ptr_float(void) { return m_data; }  
72 -inline  
73 -GFitsTableFltCol* GFitsTableFltCol::clone(void) const  
74 -{  
75 - return new GFitsTableFltCol(*this);  
76 -}  
77 76
78 #endif /* GFITSTABLEFLTCOL_HPP */ 77 #endif /* GFITSTABLEFLTCOL_HPP */
include/GFitsTableLngCol.hpp
  View file @1fff8b9
@@ -10,6 +10,11 @@ @@ -10,6 +10,11 @@
10 * (at your option) any later version. * 10 * (at your option) any later version. *
11 * * 11 * *
12 ***************************************************************************/ 12 ***************************************************************************/
  13 +/**
  14 + * @file GFitsTableLngCol.hpp
  15 + * @brief GFitsTableLngCol class definition.
  16 + * @author J. Knodlseder
  17 + */
13 18
14 #ifndef GFITSTABLELNGCOL_HPP 19 #ifndef GFITSTABLELNGCOL_HPP
15 #define GFITSTABLELNGCOL_HPP 20 #define GFITSTABLELNGCOL_HPP
@@ -24,8 +29,12 @@ @@ -24,8 +29,12 @@
24 /* __ Structures _________________________________________________________ */ 29 /* __ Structures _________________________________________________________ */
25 30
26 31
27 -/***************************************************************************  
28 - * GFitsTableLngCol class definition * 32 +/***********************************************************************//**
  33 + * @class GFitsTableLngCol
  34 + *
  35 + * @brief Interface for FITS table long integer column
  36 + *
  37 + * This class implements a FITS table long integer column.
29 ***************************************************************************/ 38 ***************************************************************************/
30 class GFitsTableLngCol : public GFitsTableCol { 39 class GFitsTableLngCol : public GFitsTableCol {
31 40
@@ -37,17 +46,15 @@ public: @@ -37,17 +46,15 @@ public:
37 46
38 // Operators 47 // Operators
39 GFitsTableLngCol& operator= (const GFitsTableLngCol& column); 48 GFitsTableLngCol& operator= (const GFitsTableLngCol& column);
  49 + long& operator() (const int& row, const int& inx = 0);
  50 + const long& operator() (const int& row, const int& inx = 0) const;
40 51
41 // Methods 52 // Methods
42 std::string string(const int& row, const int& col = 0); 53 std::string string(const int& row, const int& col = 0);
43 double real(const int& row, const int& col = 0); 54 double real(const int& row, const int& col = 0);
44 int integer(const int& row, const int& col = 0); 55 int integer(const int& row, const int& col = 0);
45 GFitsTableLngCol* clone(void) const; 56 GFitsTableLngCol* clone(void) const;
46 - double* ptr_double(void);  
47 - float* ptr_float(void);  
48 - short* ptr_short(void);  
49 - long* ptr_long(void);  
50 - int* ptr_int(void); 57 + long* data(void);
51 void set_nullval(const long* value); 58 void set_nullval(const long* value);
52 59
53 private: 60 private:
@@ -55,24 +62,13 @@ private: @@ -55,24 +62,13 @@ private:
55 void init_members(void); 62 void init_members(void);
56 void copy_members(const GFitsTableLngCol& column); 63 void copy_members(const GFitsTableLngCol& column);
57 void free_members(void); 64 void free_members(void);
58 - void load(void); 65 + void fetch_data(void);
59 66
60 // Private data area 67 // Private data area
61 - int m_size; // Size of data area  
62 - long* m_data; // Data area  
63 - long* m_nulval; // NULL value  
64 - int m_anynul; // Number of NULLs encountered 68 + int m_size; //!< Size of data area
  69 + long* m_data; //!< Data area
  70 + long* m_nulval; //!< NULL value
  71 + int m_anynul; //!< Number of NULLs encountered
65 }; 72 };
66 73
67 -  
68 -/***************************************************************************  
69 - * Inline methods *  
70 - ***************************************************************************/  
71 -inline long* GFitsTableLngCol::ptr_long(void) { return m_data; }  
72 -inline  
73 -GFitsTableLngCol* GFitsTableLngCol::clone(void) const  
74 -{  
75 - return new GFitsTableLngCol(*this);  
76 -}  
77 -  
78 #endif /* GFITSTABLELNGCOL_HPP */ 74 #endif /* GFITSTABLELNGCOL_HPP */
src/fits/GFitsHDU.cpp
  View file @1fff8b9
@@ -337,41 +337,7 @@ void GFitsHDU::open(__fitsfile* fptr, int hdunum) @@ -337,41 +337,7 @@ void GFitsHDU::open(__fitsfile* fptr, int hdunum)
337 ***************************************************************************/ 337 ***************************************************************************/
338 void GFitsHDU::save(void) 338 void GFitsHDU::save(void)
339 { 339 {
340 -//cout << "GFitsHDU::save " << m_fitsfile.Fptr << " " << m_hdunum << endl;  
341 - // Move to HDU  
342 -// int status = 0;  
343 -// status = __ffmahd(&m_fitsfile, m_hdunum, NULL, &status);  
344 -  
345 - // If HDU does not yet exist in file then create it now. This works even  
346 - // in the case that the actual HDU has no associated header and/or data  
347 - // (these will be created automatically). However, to make this work we have  
348 - // to set the fitsfile HDU position to the position we want to go. In that  
349 - // was the save members will know that they have to create the HDU ...  
350 -/*  
351 - if (status == 107) {  
352 - m_fitsfile.HDUposition = m_hdunum-1;  
353 - status = 0;  
354 - if (m_data != NULL) {  
355 - switch (m_type) {  
356 - case HT_IMAGE: // Image HDU  
357 - m_data->connect(&m_fitsfile);  
358 - //m_data->save();  
359 - break;  
360 - case HT_ASCII_TABLE: // ASCII Table HDU  
361 - m_data->connect(&m_fitsfile);  
362 - //m_data->save();  
363 - break;  
364 - case HT_BIN_TABLE: // Binary Table HDU  
365 - m_data->connect(&m_fitsfile);  
366 - //m_data->save();  
367 - break;  
368 - default:  
369 - throw GException::fits_unknown_HDU_type(G_SAVE, m_type);  
370 - break;  
371 - }  
372 - }  
373 - }  
374 -*/ 340 +//cout << "GFitsHDU::save entry" << endl;
375 341
376 // Save data and header if they exist 342 // Save data and header if they exist
377 if (m_data != NULL) { 343 if (m_data != NULL) {
@@ -398,6 +364,7 @@ void GFitsHDU::save(void) @@ -398,6 +364,7 @@ void GFitsHDU::save(void)
398 364
399 } // endelse: no data were available 365 } // endelse: no data were available
400 366
  367 +//cout << "GFitsHDU::save exit" << endl;
401 // Return 368 // Return
402 return; 369 return;
403 } 370 }
src/fits/GFitsHeader.cpp
  View file @1fff8b9
@@ -174,6 +174,7 @@ void GFitsHeader::open(__fitsfile* fptr) @@ -174,6 +174,7 @@ void GFitsHeader::open(__fitsfile* fptr)
174 ***************************************************************************/ 174 ***************************************************************************/
175 void GFitsHeader::save(__fitsfile* fptr) 175 void GFitsHeader::save(__fitsfile* fptr)
176 { 176 {
  177 +//cout << "GFitsHeader::save entry" << endl;
177 // Move to HDU 178 // Move to HDU
178 int status = 0; 179 int status = 0;
179 status = __ffmahd(fptr, (fptr->HDUposition)+1, NULL, &status); 180 status = __ffmahd(fptr, (fptr->HDUposition)+1, NULL, &status);
@@ -193,6 +194,7 @@ void GFitsHeader::save(__fitsfile* fptr) @@ -193,6 +194,7 @@ void GFitsHeader::save(__fitsfile* fptr)
193 } 194 }
194 } 195 }
195 196
  197 +//cout << "GFitsHeader::save exit" << endl;
196 // Return 198 // Return
197 return; 199 return;
198 } 200 }
src/fits/GFitsTable.cpp
  View file @1fff8b9
@@ -301,7 +301,7 @@ void GFitsTable::save(void) @@ -301,7 +301,7 @@ void GFitsTable::save(void)
301 } 301 }
302 302
303 // Create FITS table 303 // Create FITS table
304 - status = __ffcrtb(&m_fitsfile, m_type, m_rows, tfields, ttype, tform, 304 + status = __ffcrtb(&m_fitsfile, m_type, m_rows, tfields, ttype, tform,
305 tunit, NULL, &status); 305 tunit, NULL, &status);
306 if (status != 0) 306 if (status != 0)
307 throw GException::fits_error(G_SAVE, status); 307 throw GException::fits_error(G_SAVE, status);
@@ -322,6 +322,7 @@ void GFitsTable::save(void) @@ -322,6 +322,7 @@ void GFitsTable::save(void)
322 else if (status != 0) 322 else if (status != 0)
323 throw GException::fits_error(G_SAVE, status); 323 throw GException::fits_error(G_SAVE, status);
324 324
  325 +//cout << "GFitsTable::save exit" << endl;
325 // Return 326 // Return
326 return; 327 return;
327 } 328 }
@@ -370,6 +371,7 @@ void GFitsTable::append_column(GFitsTableCol* column) @@ -370,6 +371,7 @@ void GFitsTable::append_column(GFitsTableCol* column)
370 return; 371 return;
371 } 372 }
372 373
  374 +
373 /***********************************************************************//** 375 /***********************************************************************//**
374 * @brief Insert column into the table 376 * @brief Insert column into the table
375 * 377 *
@@ -455,11 +457,17 @@ void GFitsTable::insert_column(int colnum, GFitsTableCol* column) @@ -455,11 +457,17 @@ void GFitsTable::insert_column(int colnum, GFitsTableCol* column)
455 // Connect new memory 457 // Connect new memory
456 m_columns = tmp; 458 m_columns = tmp;
457 459
  460 + // Increment column counter
  461 + m_cols++;
  462 +
458 } // endelse: we made space to insert a column 463 } // endelse: we made space to insert a column
459 464
460 // Insert column pointer 465 // Insert column pointer
461 m_columns[colnum] = column; 466 m_columns[colnum] = column;
462 467
  468 + // Set column attributes
  469 + m_columns[colnum]->m_colnum = colnum + 1; // IS THIS REALLY NEEDED???
  470 +
463 // Return 471 // Return
464 return; 472 return;
465 } 473 }
@@ -613,10 +621,7 @@ void GFitsTable::copy_members(const GFitsTable&amp; table) @@ -613,10 +621,7 @@ void GFitsTable::copy_members(const GFitsTable&amp; table)
613 ***************************************************************************/ 621 ***************************************************************************/
614 void GFitsTable::free_members(void) 622 void GFitsTable::free_members(void)
615 { 623 {
616 - // Free memory  
617 - for (int i = 0; i < m_cols; ++i) {  
618 - if (m_columns[i] != NULL) delete m_columns[i];  
619 - } 624 + // Free memory (don't free associated column pointers explicitely!!!)
620 if (m_columns != NULL) delete [] m_columns; 625 if (m_columns != NULL) delete [] m_columns;
621 626
622 // Mark memory as freed 627 // Mark memory as freed
@@ -664,15 +669,16 @@ char* GFitsTable::get_ttype(const int&amp; colnum) const @@ -664,15 +669,16 @@ char* GFitsTable::get_ttype(const int&amp; colnum) const
664 { 669 {
665 // Initialise result with NULL pointer 670 // Initialise result with NULL pointer
666 char* ptr = NULL; 671 char* ptr = NULL;
667 - 672 +
668 // Get type only if column exists 673 // Get type only if column exists
669 if (m_columns != NULL && colnum >=0 && colnum < m_cols && 674 if (m_columns != NULL && colnum >=0 && colnum < m_cols &&
670 m_columns[colnum] != NULL) { 675 m_columns[colnum] != NULL) {
671 - int size = m_columns[colnum]->m_name.length() + 1;  
672 - ptr = new char[size];  
673 - strncpy(ptr, m_columns[colnum]->m_name.c_str(), size-1);  
674 - }  
675 - 676 + int size = m_columns[colnum]->m_name.length();
  677 + ptr = new char[size+1];
  678 + strncpy(ptr, m_columns[colnum]->m_name.c_str(), size);
  679 + ptr[size] = '\0';
  680 + }
  681 +
676 // Return result 682 // Return result
677 return ptr; 683 return ptr;
678 } 684 }
@@ -691,15 +697,16 @@ char* GFitsTable::get_tform(const int&amp; colnum) const @@ -691,15 +697,16 @@ char* GFitsTable::get_tform(const int&amp; colnum) const
691 { 697 {
692 // Initialise result with NULL pointer 698 // Initialise result with NULL pointer
693 char* ptr = NULL; 699 char* ptr = NULL;
694 - 700 +
695 // Get type only if column exists 701 // Get type only if column exists
696 if (m_columns != NULL && colnum >=0 && colnum < m_cols && 702 if (m_columns != NULL && colnum >=0 && colnum < m_cols &&
697 m_columns[colnum] != NULL) { 703 m_columns[colnum] != NULL) {
698 - int size = m_columns[colnum]->m_format.length() + 1;  
699 - ptr = new char[size];  
700 - strncpy(ptr, m_columns[colnum]->m_format.c_str(), size-1); 704 + int size = m_columns[colnum]->m_format.length();
  705 + ptr = new char[size+1];
  706 + strncpy(ptr, m_columns[colnum]->m_format.c_str(), size);
  707 + ptr[size] = '\0';
701 } 708 }
702 - 709 +
703 // Return result 710 // Return result
704 return ptr; 711 return ptr;
705 } 712 }
@@ -718,15 +725,16 @@ char* GFitsTable::get_tunit(const int&amp; colnum) const @@ -718,15 +725,16 @@ char* GFitsTable::get_tunit(const int&amp; colnum) const
718 { 725 {
719 // Initialise result with NULL pointer 726 // Initialise result with NULL pointer
720 char* ptr = NULL; 727 char* ptr = NULL;
721 - 728 +
722 // Get type only if column exists 729 // Get type only if column exists
723 if (m_columns != NULL && colnum >=0 && colnum < m_cols && 730 if (m_columns != NULL && colnum >=0 && colnum < m_cols &&
724 m_columns[colnum] != NULL) { 731 m_columns[colnum] != NULL) {
725 - int size = m_columns[colnum]->m_unit.length() + 1;  
726 - ptr = new char[size];  
727 - strncpy(ptr, m_columns[colnum]->m_unit.c_str(), size-1); 732 + int size = m_columns[colnum]->m_unit.length();
  733 + ptr = new char[size+1];
  734 + strncpy(ptr, m_columns[colnum]->m_unit.c_str(), size);
  735 + ptr[size] = '\0';
728 } 736 }
729 - 737 +
730 // Return result 738 // Return result
731 return ptr; 739 return ptr;
732 } 740 }
src/fits/GFitsTableCol.cpp
  View file @1fff8b9
@@ -48,6 +48,26 @@ GFitsTableCol::GFitsTableCol() @@ -48,6 +48,26 @@ GFitsTableCol::GFitsTableCol()
48 48
49 49
50 /***********************************************************************//** 50 /***********************************************************************//**
  51 + * @brief Constructor
  52 + *
  53 + * @param[in] length Length of column.
  54 + * @param[in] size Vector size of column.
  55 + ***************************************************************************/
  56 +GFitsTableCol::GFitsTableCol(const int& length, const int& size)
  57 +{
  58 + // Initialise class members for clean destruction
  59 + init_members();
  60 +
  61 + // Set column length and vector size
  62 + m_length = length;
  63 + m_repeat = size;
  64 +
  65 + // Return
  66 + return;
  67 +}
  68 +
  69 +
  70 +/***********************************************************************//**
51 * @brief Copy constructor 71 * @brief Copy constructor
52 * 72 *
53 * @param[in] column Column from which the class instance should be built 73 * @param[in] column Column from which the class instance should be built
src/fits/GFitsTableDblCol.cpp
  View file @1fff8b9
@@ -23,12 +23,7 @@ @@ -23,12 +23,7 @@
23 #define G_STRING "GFitsTableDblCol::string(const int&, const int&)" 23 #define G_STRING "GFitsTableDblCol::string(const int&, const int&)"
24 #define G_REAL "GFitsTableDblCol::real(const int&, const int&)" 24 #define G_REAL "GFitsTableDblCol::real(const int&, const int&)"
25 #define G_INTEGER "GFitsTableDblCol::integer(const int&, const int&)" 25 #define G_INTEGER "GFitsTableDblCol::integer(const int&, const int&)"
26 -#define G_PTR_FLOAT "GFitsTableDblCol::ptr_float()"  
27 -#define G_PTR_DOUBLE "GFitsTableDblCol::ptr_double()"  
28 -#define G_PTR_SHORT "GFitsTableDblCol::ptr_short()"  
29 -#define G_PTR_LONG "GFitsTableDblCol::ptr_long()"  
30 -#define G_PTR_INT "GFitsTableDblCol::ptr_int()"  
31 -#define G_LOAD "GFitsTableDblCol::load()" 26 +#define G_FETCH_DATA "GFitsTableDblCol::fetch_data()"
32 27
33 /* __ Macros _____________________________________________________________ */ 28 /* __ Macros _____________________________________________________________ */
34 29
@@ -43,9 +38,8 @@ @@ -43,9 +38,8 @@
43 = = 38 = =
44 ==========================================================================*/ 39 ==========================================================================*/
45 40
46 -/***************************************************************************  
47 - * Constructor *  
48 - * ----------------------------------------------------------------------- * 41 +/***********************************************************************//**
  42 + * @brief Constructor
49 ***************************************************************************/ 43 ***************************************************************************/
50 GFitsTableDblCol::GFitsTableDblCol() : GFitsTableCol() 44 GFitsTableDblCol::GFitsTableDblCol() : GFitsTableCol()
51 { 45 {
@@ -57,11 +51,35 @@ GFitsTableDblCol::GFitsTableDblCol() : GFitsTableCol() @@ -57,11 +51,35 @@ GFitsTableDblCol::GFitsTableDblCol() : GFitsTableCol()
57 } 51 }
58 52
59 53
60 -/***************************************************************************  
61 - * Copy constructor *  
62 - * ----------------------------------------------------------------------- * 54 +/***********************************************************************//**
  55 + * @brief Constructor
  56 + *
  57 + * @param[in] length Length of column.
  58 + * @param[in] size Vector size of column.
63 ***************************************************************************/ 59 ***************************************************************************/
64 -GFitsTableDblCol::GFitsTableDblCol(const GFitsTableDblCol& column) : GFitsTableCol(column) 60 +GFitsTableDblCol::GFitsTableDblCol(const int& length, const int& size)
  61 + : GFitsTableCol(length, size)
  62 +{
  63 + // Initialise class members for clean destruction
  64 + init_members();
  65 +
  66 + // Setup format
  67 + //m_name = "Test";
  68 + m_format = "1D";
  69 + //m_unit = "deg";
  70 +
  71 + // Return
  72 + return;
  73 +}
  74 +
  75 +
  76 +/***********************************************************************//**
  77 + * @brief Copy constructor
  78 + *
  79 + * @param[in] column Column from which class instance should be built.
  80 + ***************************************************************************/
  81 +GFitsTableDblCol::GFitsTableDblCol(const GFitsTableDblCol& column) :
  82 + GFitsTableCol(column)
65 { 83 {
66 // Initialise class members for clean destruction 84 // Initialise class members for clean destruction
67 init_members(); 85 init_members();
@@ -74,9 +92,8 @@ GFitsTableDblCol::GFitsTableDblCol(const GFitsTableDblCol&amp; column) : GFitsTableC @@ -74,9 +92,8 @@ GFitsTableDblCol::GFitsTableDblCol(const GFitsTableDblCol&amp; column) : GFitsTableC
74 } 92 }
75 93
76 94
77 -/***************************************************************************  
78 - * Destructor *  
79 - * ----------------------------------------------------------------------- * 95 +/***********************************************************************//**
  96 + * @brief Destructor
80 ***************************************************************************/ 97 ***************************************************************************/
81 GFitsTableDblCol::~GFitsTableDblCol() 98 GFitsTableDblCol::~GFitsTableDblCol()
82 { 99 {
@@ -94,9 +111,10 @@ GFitsTableDblCol::~GFitsTableDblCol() @@ -94,9 +111,10 @@ GFitsTableDblCol::~GFitsTableDblCol()
94 = = 111 = =
95 ==========================================================================*/ 112 ==========================================================================*/
96 113
97 -/***************************************************************************  
98 - * Assignment operator *  
99 - * ----------------------------------------------------------------------- * 114 +/***********************************************************************//**
  115 + * @brief Assignment operator
  116 + *
  117 + * @param[in] column Column which should be assigned
100 ***************************************************************************/ 118 ***************************************************************************/
101 GFitsTableDblCol& GFitsTableDblCol::operator= (const GFitsTableDblCol& column) 119 GFitsTableDblCol& GFitsTableDblCol::operator= (const GFitsTableDblCol& column)
102 { 120 {
@@ -122,126 +140,193 @@ GFitsTableDblCol&amp; GFitsTableDblCol::operator= (const GFitsTableDblCol&amp; column) @@ -122,126 +140,193 @@ GFitsTableDblCol&amp; GFitsTableDblCol::operator= (const GFitsTableDblCol&amp; column)
122 } 140 }
123 141
124 142
  143 +/***********************************************************************//**
  144 + * @brief Column data access operator
  145 + *
  146 + * @param[in] row Row of column to access.
  147 + * @param[in] inx Vector index in column row to access
  148 + *
  149 + * Provides access to data in a column. No range checking is performed.
  150 + * Use one of
  151 + * GFitsTableDblCol::string(ix,iy),
  152 + * GFitsTableDblCol::real(ix;iy) or
  153 + * GFitsTableDblCol::integer(ix;iy)
  154 + * if range checking is required.
  155 + ***************************************************************************/
  156 +double& GFitsTableDblCol::operator() (const int& row, const int& inx)
  157 +{
  158 + // If data are not available then load them now
  159 + if (m_data == NULL) fetch_data();
  160 +
  161 + // Calculate pixel offset
  162 + int offset = row * m_repeat + inx;
  163 +
  164 + // Return image pixel
  165 + return m_data[offset];
  166 +}
  167 +
  168 +
  169 +/***********************************************************************//**
  170 + * @brief Column data access operator (const variant)
  171 + *
  172 + * @param[in] row Row of column to access.
  173 + * @param[in] inx Vector index in column row to access
  174 + *
  175 + * Provides access to data in a column. No range checking is performed.
  176 + * Use one of
  177 + * GFitsTableDblCol::string(ix,iy),
  178 + * GFitsTableDblCol::real(ix;iy) or
  179 + * GFitsTableDblCol::integer(ix;iy)
  180 + * if range checking is required.
  181 + ***************************************************************************/
  182 +const double& GFitsTableDblCol::operator() (const int& row, const int& inx)
  183 + const
  184 +{
  185 + // If data are not available then load them now
  186 + if (m_data == NULL) ((GFitsTableDblCol*)this)->fetch_data();
  187 +
  188 + // Calculate pixel offset
  189 + int offset = row * m_repeat + inx;
  190 +
  191 + // Return image pixel
  192 + return m_data[offset];
  193 +}
  194 +
  195 +
125 /*========================================================================== 196 /*==========================================================================
126 = = 197 = =
127 = GFitsTableDblCol public methods = 198 = GFitsTableDblCol public methods =
128 = = 199 = =
129 ==========================================================================*/ 200 ==========================================================================*/
130 201
131 -/***************************************************************************  
132 - * Get string value *  
133 - * ----------------------------------------------------------------------- * 202 +/***********************************************************************//**
  203 + * @brief Get string value
  204 + *
  205 + * @param[in] row Table row.
  206 + * @param[in] inx Table column vector index.
  207 + *
  208 + * @exception GException::out_of_range
  209 + * Table row or vector index are out of valid range.
  210 + *
  211 + * Returns value of specified row and vector index as string.
134 ***************************************************************************/ 212 ***************************************************************************/
135 -std::string GFitsTableDblCol::string(const int& row, const int& col) 213 +std::string GFitsTableDblCol::string(const int& row, const int& inx)
136 { 214 {
137 - // Make sure that data are loaded  
138 - if (m_data == NULL)  
139 - load(); 215 + // If data are not available then load them now
  216 + if (m_data == NULL) fetch_data();
140 217
141 // Check row value 218 // Check row value
142 if (row < 0 || row >= m_length) 219 if (row < 0 || row >= m_length)
143 throw GException::out_of_range(G_STRING, row, 0, m_length-1); 220 throw GException::out_of_range(G_STRING, row, 0, m_length-1);
144 221
145 - // Check col value  
146 - if (col < 0 || col >= m_repeat)  
147 - throw GException::out_of_range(G_STRING, col, 0, m_repeat-1); 222 + // Check inx value
  223 + if (inx < 0 || inx >= m_repeat)
  224 + throw GException::out_of_range(G_STRING, inx, 0, m_repeat-1);
148 225
149 // Get index 226 // Get index
150 - int inx = row * m_repeat + col; 227 + int offset = row * m_repeat + inx;
151 228
152 // Convert double into string 229 // Convert double into string
153 ostringstream s_value; 230 ostringstream s_value;
154 - s_value << scientific << m_data[inx]; 231 + s_value << scientific << m_data[offset];
155 232
156 // Return value 233 // Return value
157 return s_value.str(); 234 return s_value.str();
158 } 235 }
159 236
160 237
161 -/***************************************************************************  
162 - * Get real value *  
163 - * ----------------------------------------------------------------------- * 238 +/***********************************************************************//**
  239 + * @brief Get double precision value
  240 + *
  241 + * @param[in] row Table row.
  242 + * @param[in] inx Table column vector index.
  243 + *
  244 + * @exception GException::out_of_range
  245 + * Table row or vector index are out of valid range.
  246 + *
  247 + * Returns value of specified row and vector index as double precision.
164 ***************************************************************************/ 248 ***************************************************************************/
165 -double GFitsTableDblCol::real(const int& row, const int& col) 249 +double GFitsTableDblCol::real(const int& row, const int& inx)
166 { 250 {
167 - // Make sure that data are loaded  
168 - if (m_data == NULL)  
169 - load(); 251 + // If data are not available then load them now
  252 + if (m_data == NULL) fetch_data();
170 253
171 // Check row value 254 // Check row value
172 if (row < 0 || row >= m_length) 255 if (row < 0 || row >= m_length)
173 throw GException::out_of_range(G_REAL, row, 0, m_length-1); 256 throw GException::out_of_range(G_REAL, row, 0, m_length-1);
174 257
175 - // Check col value  
176 - if (col < 0 || col >= m_repeat)  
177 - throw GException::out_of_range(G_REAL, col, 0, m_repeat-1); 258 + // Check inx value
  259 + if (inx < 0 || inx >= m_repeat)
  260 + throw GException::out_of_range(G_REAL, inx, 0, m_repeat-1);
178 261
179 // Get index 262 // Get index
180 - int inx = row * m_repeat + col; 263 + int offset = row * m_repeat + inx;
181 264
182 // Return value 265 // Return value
183 - return m_data[inx]; 266 + return m_data[offset];
184 } 267 }
185 268
186 269
187 -/***************************************************************************  
188 - * Get int value *  
189 - * ----------------------------------------------------------------------- * 270 +/***********************************************************************//**
  271 + * @brief Get integer value
  272 + *
  273 + * @param[in] row Table row.
  274 + * @param[in] inx Table column vector index.
  275 + *
  276 + * @exception GException::out_of_range
  277 + * Table row or vector index are out of valid range.
  278 + *
  279 + * Returns value of specified row and vector index as integer.
190 ***************************************************************************/ 280 ***************************************************************************/
191 -int GFitsTableDblCol::integer(const int& row, const int& col) 281 +int GFitsTableDblCol::integer(const int& row, const int& inx)
192 { 282 {
193 - // Make sure that data are loaded  
194 - if (m_data == NULL)  
195 - load(); 283 + // If data are not available then load them now
  284 + if (m_data == NULL) fetch_data();
196 285
197 // Check row value 286 // Check row value
198 if (row < 0 || row >= m_length) 287 if (row < 0 || row >= m_length)
199 throw GException::out_of_range(G_INTEGER, row, 0, m_length-1); 288 throw GException::out_of_range(G_INTEGER, row, 0, m_length-1);
200 289
201 // Check col value 290 // Check col value
202 - if (col < 0 || col >= m_repeat)  
203 - throw GException::out_of_range(G_INTEGER, col, 0, m_repeat-1); 291 + if (inx < 0 || inx >= m_repeat)
  292 + throw GException::out_of_range(G_INTEGER, inx, 0, m_repeat-1);
204 293
205 // Get index 294 // Get index
206 - int inx = row * m_repeat + col; 295 + int offset = row * m_repeat + inx;
207 296
208 // Convert double into int 297 // Convert double into int
209 - int value = (int)m_data[inx]; 298 + int value = (int)m_data[offset];
210 299
211 // Return value 300 // Return value
212 return value; 301 return value;
213 } 302 }
214 303
215 304
216 -/***************************************************************************  
217 - * Access to invalid data pointers *  
218 - * ----------------------------------------------------------------------- * 305 +/***********************************************************************//**
  306 + * @brief Clone column
219 ***************************************************************************/ 307 ***************************************************************************/
220 -float* GFitsTableDblCol::ptr_float(void)  
221 -{  
222 - throw GException::fits_invalid_type(G_PTR_FLOAT,  
223 - "No <float> pointer allowed to <double> array");  
224 -}  
225 -short* GFitsTableDblCol::ptr_short(void)  
226 -{  
227 - throw GException::fits_invalid_type(G_PTR_SHORT,  
228 - "No <short> pointer allowed to <double> array");  
229 -}  
230 -long* GFitsTableDblCol::ptr_long(void) 308 +GFitsTableDblCol* GFitsTableDblCol::clone(void) const
231 { 309 {
232 - throw GException::fits_invalid_type(G_PTR_LONG,  
233 - "No <long> pointer allowed to <double> array"); 310 + return new GFitsTableDblCol(*this);
234 } 311 }
235 -int* GFitsTableDblCol::ptr_int(void) 312 +
  313 +
  314 +/***********************************************************************//**
  315 + * @brief Return pointer to double precision column
  316 + ***************************************************************************/
  317 +double* GFitsTableDblCol::data(void)
236 { 318 {
237 - throw GException::fits_invalid_type(G_PTR_INT,  
238 - "No <int> pointer allowed to <double> array"); 319 + return m_data;
239 } 320 }
240 321
241 322
242 -/***************************************************************************  
243 - * Set NULL value *  
244 - * ----------------------------------------------------------------------- * 323 +/***********************************************************************//**
  324 + * @brief Set NULL value
  325 + *
  326 + * @param[in] value Pointer on NULL value
  327 + *
  328 + * Allows the specification of the FITS table NULL value. If value=NULL the
  329 + * data will not be screened for NULL values.
245 ***************************************************************************/ 330 ***************************************************************************/
246 void GFitsTableDblCol::set_nullval(const double* value) 331 void GFitsTableDblCol::set_nullval(const double* value)
247 { 332 {
@@ -258,13 +343,13 @@ void GFitsTableDblCol::set_nullval(const double* value) @@ -258,13 +343,13 @@ void GFitsTableDblCol::set_nullval(const double* value)
258 *m_nulval = *value; 343 *m_nulval = *value;
259 } 344 }
260 345
261 - // Re-load column  
262 - // NOTE: THIS WILL LEAD TO A LOSS OF MODIFICATIONS; ISSUE SAVE BEFORE !!! 346 + // Re-load column
  347 +/*
263 if (m_data != NULL) { 348 if (m_data != NULL) {
264 - //save(); 349 + save();
265 load(); 350 load();
266 } 351 }
267 - 352 +*/
268 // Return 353 // Return
269 return; 354 return;
270 } 355 }
@@ -276,9 +361,8 @@ void GFitsTableDblCol::set_nullval(const double* value) @@ -276,9 +361,8 @@ void GFitsTableDblCol::set_nullval(const double* value)
276 = = 361 = =
277 ==========================================================================*/ 362 ==========================================================================*/
278 363
279 -/***************************************************************************  
280 - * Initialise class members *  
281 - * ----------------------------------------------------------------------- * 364 +/***********************************************************************//**
  365 + * @brief Initialise class members
282 ***************************************************************************/ 366 ***************************************************************************/
283 void GFitsTableDblCol::init_members(void) 367 void GFitsTableDblCol::init_members(void)
284 { 368 {
@@ -293,9 +377,10 @@ void GFitsTableDblCol::init_members(void) @@ -293,9 +377,10 @@ void GFitsTableDblCol::init_members(void)
293 } 377 }
294 378
295 379
296 -/***************************************************************************  
297 - * Copy class members *  
298 - * ----------------------------------------------------------------------- * 380 +/***********************************************************************//**
  381 + * @brief Copy class members
  382 + *
  383 + * @param[in] column Column for which members should be copied.
299 ***************************************************************************/ 384 ***************************************************************************/
300 void GFitsTableDblCol::copy_members(const GFitsTableDblCol& column) 385 void GFitsTableDblCol::copy_members(const GFitsTableDblCol& column)
301 { 386 {
@@ -322,9 +407,8 @@ void GFitsTableDblCol::copy_members(const GFitsTableDblCol&amp; column) @@ -322,9 +407,8 @@ void GFitsTableDblCol::copy_members(const GFitsTableDblCol&amp; column)
322 } 407 }
323 408
324 409
325 -/***************************************************************************  
326 - * Delete class members *  
327 - * ----------------------------------------------------------------------- * 410 +/***********************************************************************//**
  411 + * @brief Delete class members
328 ***************************************************************************/ 412 ***************************************************************************/
329 void GFitsTableDblCol::free_members(void) 413 void GFitsTableDblCol::free_members(void)
330 { 414 {
@@ -341,26 +425,47 @@ void GFitsTableDblCol::free_members(void) @@ -341,26 +425,47 @@ void GFitsTableDblCol::free_members(void)
341 } 425 }
342 426
343 427
344 -/***************************************************************************  
345 - * Load column data *  
346 - * ----------------------------------------------------------------------- * 428 +/***********************************************************************//**
  429 + * @brief Fetch column data
  430 + *
  431 + * @exception GException::fits_error
  432 + * An error occured while loading column data from FITS file.
  433 + *
  434 + * If a FITS file is attached to the column the data are loaded into memory
  435 + * from the FITS file. If no FITS file is attached, memory is allocated
  436 + * to hold the column data and all cells are set to 0.
347 ***************************************************************************/ 437 ***************************************************************************/
348 -void GFitsTableDblCol::load(void) 438 +void GFitsTableDblCol::fetch_data(void)
349 { 439 {
350 // Calculate size of memory 440 // Calculate size of memory
351 m_size = m_repeat * m_length; 441 m_size = m_repeat * m_length;
352 442
353 - // Allocate memory  
354 - if (m_data != NULL) delete [] m_data;  
355 - m_data = new double[m_size];  
356 -  
357 - // Load column data  
358 - int status = 0;  
359 - status = __ffmahd(&m_fitsfile, (m_fitsfile.HDUposition)+1, NULL, &status);  
360 - status = __ffgcv(&m_fitsfile, __TDOUBLE, m_colnum, 1, 1, m_size,  
361 - m_nulval, m_data, &m_anynul, &status);  
362 - if (status != 0)  
363 - throw GException::fits_error(G_LOAD, status); 443 + // Load only if the column has a positive size
  444 + if (m_size > 0) {
  445 +
  446 + // Allocate fresh memory
  447 + if (m_data != NULL) delete [] m_data;
  448 + m_data = new double[m_size];
  449 +
  450 + // If a FITS file is attached then load column data from the FITS
  451 + // file
  452 + if (m_fitsfile.Fptr != NULL) {
  453 + int status = 0;
  454 + status = __ffmahd(&m_fitsfile, (m_fitsfile.HDUposition)+1, NULL,
  455 + &status);
  456 + status = __ffgcv(&m_fitsfile, __TDOUBLE, m_colnum, 1, 1, m_size,
  457 + m_nulval, m_data, &m_anynul, &status);
  458 + if (status != 0)
  459 + throw GException::fits_error(G_FETCH_DATA, status);
  460 + }
  461 +
  462 + // ... otherwise initialise all column values to 0
  463 + else {
  464 + for (int i = 0; i < m_size; ++i)
  465 + m_data[i] = 0.0;
  466 + }
  467 +
  468 + } // endif: column has a positive size
364 469
365 // Return 470 // Return
366 return; 471 return;
src/fits/GFitsTableFltCol.cpp
  View file @1fff8b9
@@ -43,9 +43,8 @@ @@ -43,9 +43,8 @@
43 = = 43 = =
44 ==========================================================================*/ 44 ==========================================================================*/
45 45
46 -/***************************************************************************  
47 - * Constructor *  
48 - * ----------------------------------------------------------------------- * 46 +/***********************************************************************//**
  47 + * @brief Constructor
49 ***************************************************************************/ 48 ***************************************************************************/
50 GFitsTableFltCol::GFitsTableFltCol() : GFitsTableCol() 49 GFitsTableFltCol::GFitsTableFltCol() : GFitsTableCol()
51 { 50 {
@@ -57,11 +56,13 @@ GFitsTableFltCol::GFitsTableFltCol() : GFitsTableCol() @@ -57,11 +56,13 @@ GFitsTableFltCol::GFitsTableFltCol() : GFitsTableCol()
57 } 56 }
58 57
59 58
60 -/***************************************************************************  
61 - * Copy constructor *  
62 - * ----------------------------------------------------------------------- * 59 +/***********************************************************************//**
  60 + * @brief Copy constructor
  61 + *
  62 + * @param[in] column Column from which class instance should be built.
63 ***************************************************************************/ 63 ***************************************************************************/
64 -GFitsTableFltCol::GFitsTableFltCol(const GFitsTableFltCol& column) : GFitsTableCol(column) 64 +GFitsTableFltCol::GFitsTableFltCol(const GFitsTableFltCol& column) :
  65 + GFitsTableCol(column)
65 { 66 {
66 // Initialise class members for clean destruction 67 // Initialise class members for clean destruction
67 init_members(); 68 init_members();
@@ -74,9 +75,8 @@ GFitsTableFltCol::GFitsTableFltCol(const GFitsTableFltCol&amp; column) : GFitsTableC @@ -74,9 +75,8 @@ GFitsTableFltCol::GFitsTableFltCol(const GFitsTableFltCol&amp; column) : GFitsTableC
74 } 75 }
75 76
76 77
77 -/***************************************************************************  
78 - * Destructor *  
79 - * ----------------------------------------------------------------------- * 78 +/***********************************************************************//**
  79 + * @brief Destructor
80 ***************************************************************************/ 80 ***************************************************************************/
81 GFitsTableFltCol::~GFitsTableFltCol() 81 GFitsTableFltCol::~GFitsTableFltCol()
82 { 82 {
@@ -94,9 +94,10 @@ GFitsTableFltCol::~GFitsTableFltCol() @@ -94,9 +94,10 @@ GFitsTableFltCol::~GFitsTableFltCol()
94 = = 94 = =
95 ==========================================================================*/ 95 ==========================================================================*/
96 96
97 -/***************************************************************************  
98 - * Assignment operator *  
99 - * ----------------------------------------------------------------------- * 97 +/***********************************************************************//**
  98 + * @brief Assignment operator
  99 + *
  100 + * @param[in] column Column which should be assigned
100 ***************************************************************************/ 101 ***************************************************************************/
101 GFitsTableFltCol& GFitsTableFltCol::operator= (const GFitsTableFltCol& column) 102 GFitsTableFltCol& GFitsTableFltCol::operator= (const GFitsTableFltCol& column)
102 { 103 {
@@ -128,9 +129,13 @@ GFitsTableFltCol&amp; GFitsTableFltCol::operator= (const GFitsTableFltCol&amp; column) @@ -128,9 +129,13 @@ GFitsTableFltCol&amp; GFitsTableFltCol::operator= (const GFitsTableFltCol&amp; column)
128 = = 129 = =
129 ==========================================================================*/ 130 ==========================================================================*/
130 131
131 -/***************************************************************************  
132 - * Get string value *  
133 - * ----------------------------------------------------------------------- * 132 +/***********************************************************************//**
  133 + * @brief Get string value
  134 + *
  135 + * @param[in] row Table row.
  136 + * @param[in] col Table column vector index.
  137 + *
  138 + * Returns value of specified row and vector index as string.
134 ***************************************************************************/ 139 ***************************************************************************/
135 std::string GFitsTableFltCol::string(const int& row, const int& col) 140 std::string GFitsTableFltCol::string(const int& row, const int& col)
136 { 141 {
@@ -158,9 +163,13 @@ std::string GFitsTableFltCol::string(const int&amp; row, const int&amp; col) @@ -158,9 +163,13 @@ std::string GFitsTableFltCol::string(const int&amp; row, const int&amp; col)
158 } 163 }
159 164
160 165
161 -/***************************************************************************  
162 - * Get real value *  
163 - * ----------------------------------------------------------------------- * 166 +/***********************************************************************//**
  167 + * @brief Get double precision value
  168 + *
  169 + * @param[in] row Table row.
  170 + * @param[in] col Table column vector index.
  171 + *
  172 + * Returns value of specified row and vector index as double precision.
164 ***************************************************************************/ 173 ***************************************************************************/
165 double GFitsTableFltCol::real(const int& row, const int& col) 174 double GFitsTableFltCol::real(const int& row, const int& col)
166 { 175 {
@@ -187,9 +196,13 @@ double GFitsTableFltCol::real(const int&amp; row, const int&amp; col) @@ -187,9 +196,13 @@ double GFitsTableFltCol::real(const int&amp; row, const int&amp; col)
187 } 196 }
188 197
189 198
190 -/***************************************************************************  
191 - * Get int value *  
192 - * ----------------------------------------------------------------------- * 199 +/***********************************************************************//**
  200 + * @brief Get integer value
  201 + *
  202 + * @param[in] row Table row.
  203 + * @param[in] col Table column vector index.
  204 + *
  205 + * Returns value of specified row and vector index as integer.
193 ***************************************************************************/ 206 ***************************************************************************/
194 int GFitsTableFltCol::integer(const int& row, const int& col) 207 int GFitsTableFltCol::integer(const int& row, const int& col)
195 { 208 {
@@ -216,35 +229,31 @@ int GFitsTableFltCol::integer(const int&amp; row, const int&amp; col) @@ -216,35 +229,31 @@ int GFitsTableFltCol::integer(const int&amp; row, const int&amp; col)
216 } 229 }
217 230
218 231
219 -/***************************************************************************  
220 - * Access to invalid data pointers *  
221 - * ----------------------------------------------------------------------- * 232 +/***********************************************************************//**
  233 + * @brief Clone column
222 ***************************************************************************/ 234 ***************************************************************************/
223 -double* GFitsTableFltCol::ptr_double(void) 235 +GFitsTableFltCol* GFitsTableFltCol::clone(void) const
224 { 236 {
225 - throw GException::fits_invalid_type(G_PTR_DOUBLE,  
226 - "No <double> pointer allowed to <float> array"); 237 + return new GFitsTableFltCol(*this);
227 } 238 }
228 -short* GFitsTableFltCol::ptr_short(void)  
229 -{  
230 - throw GException::fits_invalid_type(G_PTR_SHORT,  
231 - "No <short> pointer allowed to <float> array");  
232 -}  
233 -long* GFitsTableFltCol::ptr_long(void)  
234 -{  
235 - throw GException::fits_invalid_type(G_PTR_LONG,  
236 - "No <long> pointer allowed to <float> array");  
237 -}  
238 -int* GFitsTableFltCol::ptr_int(void) 239 +
  240 +
  241 +/***********************************************************************//**
  242 + * @brief Return pointer to floating point column
  243 + ***************************************************************************/
  244 +float* GFitsTableFltCol::data(void)
239 { 245 {
240 - throw GException::fits_invalid_type(G_PTR_INT,  
241 - "No <int> pointer allowed to <float> array"); 246 + return m_data;
242 } 247 }
243 248
244 249
245 -/***************************************************************************  
246 - * Set NULL string *  
247 - * ----------------------------------------------------------------------- * 250 +/***********************************************************************//**
  251 + * @brief Set NULL value
  252 + *
  253 + * @param[in] value Pointer on NULL value
  254 + *
  255 + * Allows the specification of the FITS table NULL value. If value=NULL the
  256 + * data will not be screened for NULL values.
248 ***************************************************************************/ 257 ***************************************************************************/
249 void GFitsTableFltCol::set_nullval(const float* value) 258 void GFitsTableFltCol::set_nullval(const float* value)
250 { 259 {
@@ -261,12 +270,13 @@ void GFitsTableFltCol::set_nullval(const float* value) @@ -261,12 +270,13 @@ void GFitsTableFltCol::set_nullval(const float* value)
261 *m_nulval = *value; 270 *m_nulval = *value;
262 } 271 }
263 272
264 - // Re-load column  
265 - // NOTE: THIS WILL LEAD TO A LOSS OF MODIFICATIONS; ISSUE SAVE BEFORE !!! 273 + // Re-load column
  274 +/*
266 if (m_data != NULL) { 275 if (m_data != NULL) {
267 - //save(); 276 + save();
268 load(); 277 load();
269 } 278 }
  279 +*/
270 280
271 // Return 281 // Return
272 return; 282 return;
@@ -279,9 +289,8 @@ void GFitsTableFltCol::set_nullval(const float* value) @@ -279,9 +289,8 @@ void GFitsTableFltCol::set_nullval(const float* value)
279 = = 289 = =
280 ==========================================================================*/ 290 ==========================================================================*/
281 291
282 -/***************************************************************************  
283 - * Initialise class members *  
284 - * ----------------------------------------------------------------------- * 292 +/***********************************************************************//**
  293 + * @brief Initialise class members
285 ***************************************************************************/ 294 ***************************************************************************/
286 void GFitsTableFltCol::init_members(void) 295 void GFitsTableFltCol::init_members(void)
287 { 296 {
@@ -296,9 +305,10 @@ void GFitsTableFltCol::init_members(void) @@ -296,9 +305,10 @@ void GFitsTableFltCol::init_members(void)
296 } 305 }
297 306
298 307
299 -/***************************************************************************  
300 - * Copy class members *  
301 - * ----------------------------------------------------------------------- * 308 +/***********************************************************************//**
  309 + * @brief Copy class members
  310 + *
  311 + * @param[in] column Column for which members should be copied.
302 ***************************************************************************/ 312 ***************************************************************************/
303 void GFitsTableFltCol::copy_members(const GFitsTableFltCol& column) 313 void GFitsTableFltCol::copy_members(const GFitsTableFltCol& column)
304 { 314 {
@@ -325,9 +335,8 @@ void GFitsTableFltCol::copy_members(const GFitsTableFltCol&amp; column) @@ -325,9 +335,8 @@ void GFitsTableFltCol::copy_members(const GFitsTableFltCol&amp; column)
325 } 335 }
326 336
327 337
328 -/***************************************************************************  
329 - * Delete class members *  
330 - * ----------------------------------------------------------------------- * 338 +/***********************************************************************//**
  339 + * @brief Delete class members
331 ***************************************************************************/ 340 ***************************************************************************/
332 void GFitsTableFltCol::free_members(void) 341 void GFitsTableFltCol::free_members(void)
333 { 342 {
@@ -344,9 +353,8 @@ void GFitsTableFltCol::free_members(void) @@ -344,9 +353,8 @@ void GFitsTableFltCol::free_members(void)
344 } 353 }
345 354
346 355
347 -/***************************************************************************  
348 - * Load column data *  
349 - * ----------------------------------------------------------------------- * 356 +/***********************************************************************//**
  357 + * @brief Load column data
350 ***************************************************************************/ 358 ***************************************************************************/
351 void GFitsTableFltCol::load(void) 359 void GFitsTableFltCol::load(void)
352 { 360 {
src/fits/GFitsTableLngCol.cpp
  View file @1fff8b9
@@ -23,12 +23,7 @@ @@ -23,12 +23,7 @@
23 #define G_STRING "GFitsTableLngCol::string(const int&, const int&)" 23 #define G_STRING "GFitsTableLngCol::string(const int&, const int&)"
24 #define G_REAL "GFitsTableLngCol::real(const int&, const int&)" 24 #define G_REAL "GFitsTableLngCol::real(const int&, const int&)"
25 #define G_INTEGER "GFitsTableLngCol::integer(const int&, const int&)" 25 #define G_INTEGER "GFitsTableLngCol::integer(const int&, const int&)"
26 -#define G_PTR_FLOAT "GFitsTableLngCol::ptr_float()"  
27 -#define G_PTR_DOUBLE "GFitsTableLngCol::ptr_double()"  
28 -#define G_PTR_SHORT "GFitsTableLngCol::ptr_short()"  
29 -#define G_PTR_LONG "GFitsTableLngCol::ptr_long()"  
30 -#define G_PTR_INT "GFitsTableLngCol::ptr_int()"  
31 -#define G_LOAD "GFitsTableLngCol::load()" 26 +#define G_FETCH_DATA "GFitsTableLngCol::fetch_data()"
32 27
33 /* __ Macros _____________________________________________________________ */ 28 /* __ Macros _____________________________________________________________ */
34 29
@@ -43,9 +38,8 @@ @@ -43,9 +38,8 @@
43 = = 38 = =
44 ==========================================================================*/ 39 ==========================================================================*/
45 40
46 -/***************************************************************************  
47 - * Constructor *  
48 - * ----------------------------------------------------------------------- * 41 +/***********************************************************************//**
  42 + * @brief Constructor
49 ***************************************************************************/ 43 ***************************************************************************/
50 GFitsTableLngCol::GFitsTableLngCol() : GFitsTableCol() 44 GFitsTableLngCol::GFitsTableLngCol() : GFitsTableCol()
51 { 45 {
@@ -57,11 +51,13 @@ GFitsTableLngCol::GFitsTableLngCol() : GFitsTableCol() @@ -57,11 +51,13 @@ GFitsTableLngCol::GFitsTableLngCol() : GFitsTableCol()
57 } 51 }
58 52
59 53
60 -/***************************************************************************  
61 - * Copy constructor *  
62 - * ----------------------------------------------------------------------- * 54 +/***********************************************************************//**
  55 + * @brief Copy constructor
  56 + *
  57 + * @param[in] column Column from which class instance should be built.
63 ***************************************************************************/ 58 ***************************************************************************/
64 -GFitsTableLngCol::GFitsTableLngCol(const GFitsTableLngCol& column) : GFitsTableCol(column) 59 +GFitsTableLngCol::GFitsTableLngCol(const GFitsTableLngCol& column) :
  60 + GFitsTableCol(column)
65 { 61 {
66 // Initialise class members for clean destruction 62 // Initialise class members for clean destruction
67 init_members(); 63 init_members();
@@ -74,9 +70,8 @@ GFitsTableLngCol::GFitsTableLngCol(const GFitsTableLngCol&amp; column) : GFitsTableC @@ -74,9 +70,8 @@ GFitsTableLngCol::GFitsTableLngCol(const GFitsTableLngCol&amp; column) : GFitsTableC
74 } 70 }
75 71
76 72
77 -/***************************************************************************  
78 - * Destructor *  
79 - * ----------------------------------------------------------------------- * 73 +/***********************************************************************//**
  74 + * @brief Destructor
80 ***************************************************************************/ 75 ***************************************************************************/
81 GFitsTableLngCol::~GFitsTableLngCol() 76 GFitsTableLngCol::~GFitsTableLngCol()
82 { 77 {
@@ -94,9 +89,10 @@ GFitsTableLngCol::~GFitsTableLngCol() @@ -94,9 +89,10 @@ GFitsTableLngCol::~GFitsTableLngCol()
94 = = 89 = =
95 ==========================================================================*/ 90 ==========================================================================*/
96 91
97 -/***************************************************************************  
98 - * Assignment operator *  
99 - * ----------------------------------------------------------------------- * 92 +/***********************************************************************//**
  93 + * @brief Assignment operator
  94 + *
  95 + * @param[in] column Column which should be assigned
100 ***************************************************************************/ 96 ***************************************************************************/
101 GFitsTableLngCol& GFitsTableLngCol::operator= (const GFitsTableLngCol& column) 97 GFitsTableLngCol& GFitsTableLngCol::operator= (const GFitsTableLngCol& column)
102 { 98 {
@@ -122,129 +118,196 @@ GFitsTableLngCol&amp; GFitsTableLngCol::operator= (const GFitsTableLngCol&amp; column) @@ -122,129 +118,196 @@ GFitsTableLngCol&amp; GFitsTableLngCol::operator= (const GFitsTableLngCol&amp; column)
122 } 118 }
123 119
124 120
  121 +/***********************************************************************//**
  122 + * @brief Column data access operator
  123 + *
  124 + * @param[in] row Row of column to access.
  125 + * @param[in] inx Vector index in column row to access
  126 + *
  127 + * Provides access to data in a column. No range checking is performed.
  128 + * Use one of
  129 + * GFitsTableLngCol::string(ix,iy),
  130 + * GFitsTableLngCol::real(ix;iy) or
  131 + * GFitsTableLngCol::integer(ix;iy)
  132 + * if range checking is required.
  133 + ***************************************************************************/
  134 +long& GFitsTableLngCol::operator() (const int& row, const int& inx)
  135 +{
  136 + // If data are not available then load them now
  137 + if (m_data == NULL) fetch_data();
  138 +
  139 + // Calculate pixel offset
  140 + int offset = row * m_repeat + inx;
  141 +
  142 + // Return image pixel
  143 + return m_data[offset];
  144 +}
  145 +
  146 +
  147 +/***********************************************************************//**
  148 + * @brief Column data access operator (const variant)
  149 + *
  150 + * @param[in] row Row of column to access.
  151 + * @param[in] inx Vector index in column row to access
  152 + *
  153 + * Provides access to data in a column. No range checking is performed.
  154 + * Use one of
  155 + * GFitsTableLngCol::string(ix,iy),
  156 + * GFitsTableLngCol::real(ix;iy) or
  157 + * GFitsTableLngCol::integer(ix;iy)
  158 + * if range checking is required.
  159 + ***************************************************************************/
  160 +const long& GFitsTableLngCol::operator() (const int& row, const int& inx)
  161 + const
  162 +{
  163 + // If data are not available then load them now
  164 + if (m_data == NULL) ((GFitsTableLngCol*)this)->fetch_data();
  165 +
  166 + // Calculate pixel offset
  167 + int offset = row * m_repeat + inx;
  168 +
  169 + // Return image pixel
  170 + return m_data[offset];
  171 +}
  172 +
  173 +
125 /*========================================================================== 174 /*==========================================================================
126 = = 175 = =
127 = GFitsTableLngCol public methods = 176 = GFitsTableLngCol public methods =
128 = = 177 = =
129 ==========================================================================*/ 178 ==========================================================================*/
130 179
131 -/***************************************************************************  
132 - * Get string value *  
133 - * ----------------------------------------------------------------------- * 180 +/***********************************************************************//**
  181 + * @brief Get string value
  182 + *
  183 + * @param[in] row Table row.
  184 + * @param[in] inx Table column vector index.
  185 + *
  186 + * @exception GException::out_of_range
  187 + * Table row or vector index are out of valid range.
  188 + *
  189 + * Returns value of specified row and vector index as string.
134 ***************************************************************************/ 190 ***************************************************************************/
135 -std::string GFitsTableLngCol::string(const int& row, const int& col) 191 +std::string GFitsTableLngCol::string(const int& row, const int& inx)
136 { 192 {
137 - // Make sure that data are loaded  
138 - if (m_data == NULL)  
139 - load(); 193 + // If data are not available then load them now
  194 + if (m_data == NULL) fetch_data();
140 195
141 // Check row value 196 // Check row value
142 if (row < 0 || row >= m_length) 197 if (row < 0 || row >= m_length)
143 throw GException::out_of_range(G_STRING, row, 0, m_length-1); 198 throw GException::out_of_range(G_STRING, row, 0, m_length-1);
144 199
145 - // Check col value  
146 - if (col < 0 || col >= m_repeat)  
147 - throw GException::out_of_range(G_STRING, col, 0, m_repeat-1); 200 + // Check inx value
  201 + if (inx < 0 || inx >= m_repeat)
  202 + throw GException::out_of_range(G_STRING, inx, 0, m_repeat-1);
148 203
149 // Get index 204 // Get index
150 - int inx = row * m_repeat + col; 205 + int offset = row * m_repeat + inx;
151 206
152 // Convert long into string 207 // Convert long into string
153 ostringstream s_value; 208 ostringstream s_value;
154 - s_value << m_data[inx]; 209 + s_value << m_data[offset];
155 210
156 // Return value 211 // Return value
157 return s_value.str(); 212 return s_value.str();
158 } 213 }
159 214
160 215
161 -/***************************************************************************  
162 - * Get real value *  
163 - * ----------------------------------------------------------------------- * 216 +/***********************************************************************//**
  217 + * @brief Get double precision value
  218 + *
  219 + * @param[in] row Table row.
  220 + * @param[in] inx Table column vector index.
  221 + *
  222 + * @exception GException::out_of_range
  223 + * Table row or vector index are out of valid range.
  224 + *
  225 + * Returns value of specified row and vector index as double precision.
164 ***************************************************************************/ 226 ***************************************************************************/
165 -double GFitsTableLngCol::real(const int& row, const int& col) 227 +double GFitsTableLngCol::real(const int& row, const int& inx)
166 { 228 {
167 - // Make sure that data are loaded  
168 - if (m_data == NULL)  
169 - load(); 229 + // If data are not available then load them now
  230 + if (m_data == NULL) fetch_data();
170 231
171 // Check row value 232 // Check row value
172 if (row < 0 || row >= m_length) 233 if (row < 0 || row >= m_length)
173 throw GException::out_of_range(G_REAL, row, 0, m_length-1); 234 throw GException::out_of_range(G_REAL, row, 0, m_length-1);
174 235
175 - // Check col value  
176 - if (col < 0 || col >= m_repeat)  
177 - throw GException::out_of_range(G_REAL, col, 0, m_repeat-1); 236 + // Check inx value
  237 + if (inx < 0 || inx >= m_repeat)
  238 + throw GException::out_of_range(G_REAL, inx, 0, m_repeat-1);
178 239
179 // Get index 240 // Get index
180 - int inx = row * m_repeat + col; 241 + int offset = row * m_repeat + inx;
181 242
182 // Convert long into double 243 // Convert long into double
183 - double value = (double)m_data[inx]; 244 + double value = (double)m_data[offset];
184 245
185 // Return value 246 // Return value
186 return value; 247 return value;
187 } 248 }
188 249
189 250
190 -/***************************************************************************  
191 - * Get int value *  
192 - * ----------------------------------------------------------------------- * 251 +/***********************************************************************//**
  252 + * @brief Get integer value
  253 + *
  254 + * @param[in] row Table row.
  255 + * @param[in] inx Table column vector index.
  256 + *
  257 + * @exception GException::out_of_range
  258 + * Table row or vector index are out of valid range.
  259 + *
  260 + * Returns value of specified row and vector index as integer.
193 ***************************************************************************/ 261 ***************************************************************************/
194 -int GFitsTableLngCol::integer(const int& row, const int& col) 262 +int GFitsTableLngCol::integer(const int& row, const int& inx)
195 { 263 {
196 - // Make sure that data are loaded  
197 - if (m_data == NULL)  
198 - load(); 264 + // If data are not available then load them now
  265 + if (m_data == NULL) fetch_data();
199 266
200 // Check row value 267 // Check row value
201 if (row < 0 || row >= m_length) 268 if (row < 0 || row >= m_length)
202 throw GException::out_of_range(G_INTEGER, row, 0, m_length-1); 269 throw GException::out_of_range(G_INTEGER, row, 0, m_length-1);
203 270
204 - // Check col value  
205 - if (col < 0 || col >= m_repeat)  
206 - throw GException::out_of_range(G_INTEGER, col, 0, m_repeat-1); 271 + // Check inx value
  272 + if (inx < 0 || inx >= m_repeat)
  273 + throw GException::out_of_range(G_INTEGER, inx, 0, m_repeat-1);
207 274
208 // Get index 275 // Get index
209 - int inx = row * m_repeat + col; 276 + int offset = row * m_repeat + inx;
210 277
211 // Convert long into int 278 // Convert long into int
212 - int value = (int)m_data[inx]; 279 + int value = (int)m_data[offset];
213 280
214 // Return value 281 // Return value
215 return value; 282 return value;
216 } 283 }
217 284
218 285
219 -/***************************************************************************  
220 - * Access to invalid data pointers *  
221 - * ----------------------------------------------------------------------- * 286 +/***********************************************************************//**
  287 + * @brief Clone column
222 ***************************************************************************/ 288 ***************************************************************************/
223 -float* GFitsTableLngCol::ptr_float(void) 289 +GFitsTableLngCol* GFitsTableLngCol::clone(void) const
224 { 290 {
225 - throw GException::fits_invalid_type(G_PTR_FLOAT,  
226 - "No <float> pointer allowed to <long> array"); 291 + return new GFitsTableLngCol(*this);
227 } 292 }
228 -double* GFitsTableLngCol::ptr_double(void)  
229 -{  
230 - throw GException::fits_invalid_type(G_PTR_DOUBLE,  
231 - "No <double> pointer allowed to <long> array");  
232 -}  
233 -short* GFitsTableLngCol::ptr_short(void)  
234 -{  
235 - throw GException::fits_invalid_type(G_PTR_SHORT,  
236 - "No <short> pointer allowed to <long> array");  
237 -}  
238 -int* GFitsTableLngCol::ptr_int(void) 293 +
  294 +
  295 +/***********************************************************************//**
  296 + * @brief Return pointer to long integer column
  297 + ***************************************************************************/
  298 +long* GFitsTableLngCol::data(void)
239 { 299 {
240 - throw GException::fits_invalid_type(G_PTR_INT,  
241 - "No <int> pointer allowed to <long> array"); 300 + return m_data;
242 } 301 }
243 302
244 303
245 -/***************************************************************************  
246 - * Set NULL string *  
247 - * ----------------------------------------------------------------------- * 304 +/***********************************************************************//**
  305 + * @brief Set NULL value
  306 + *
  307 + * @param[in] value Pointer on NULL value
  308 + *
  309 + * Allows the specification of the FITS table NULL value. If value=NULL the
  310 + * data will not be screened for NULL values.
248 ***************************************************************************/ 311 ***************************************************************************/
249 void GFitsTableLngCol::set_nullval(const long* value) 312 void GFitsTableLngCol::set_nullval(const long* value)
250 { 313 {
@@ -261,12 +324,13 @@ void GFitsTableLngCol::set_nullval(const long* value) @@ -261,12 +324,13 @@ void GFitsTableLngCol::set_nullval(const long* value)
261 *m_nulval = *value; 324 *m_nulval = *value;
262 } 325 }
263 326
264 - // Re-load column  
265 - // NOTE: THIS WILL LEAD TO A LOSS OF MODIFICATIONS; ISSUE SAVE BEFORE !!! 327 + // Re-load column
  328 +/*
266 if (m_data != NULL) { 329 if (m_data != NULL) {
267 - //save(); 330 + save();
268 load(); 331 load();
269 } 332 }
  333 +*/
270 334
271 // Return 335 // Return
272 return; 336 return;
@@ -279,9 +343,8 @@ void GFitsTableLngCol::set_nullval(const long* value) @@ -279,9 +343,8 @@ void GFitsTableLngCol::set_nullval(const long* value)
279 = = 343 = =
280 ==========================================================================*/ 344 ==========================================================================*/
281 345
282 -/***************************************************************************  
283 - * Initialise class members *  
284 - * ----------------------------------------------------------------------- * 346 +/***********************************************************************//**
  347 + * @brief Initialise class members
285 ***************************************************************************/ 348 ***************************************************************************/
286 void GFitsTableLngCol::init_members(void) 349 void GFitsTableLngCol::init_members(void)
287 { 350 {
@@ -296,9 +359,10 @@ void GFitsTableLngCol::init_members(void) @@ -296,9 +359,10 @@ void GFitsTableLngCol::init_members(void)
296 } 359 }
297 360
298 361
299 -/***************************************************************************  
300 - * Copy class members *  
301 - * ----------------------------------------------------------------------- * 362 +/***********************************************************************//**
  363 + * @brief Copy class members
  364 + *
  365 + * @param[in] column Column for which members should be copied.
302 ***************************************************************************/ 366 ***************************************************************************/
303 void GFitsTableLngCol::copy_members(const GFitsTableLngCol& column) 367 void GFitsTableLngCol::copy_members(const GFitsTableLngCol& column)
304 { 368 {
@@ -325,9 +389,8 @@ void GFitsTableLngCol::copy_members(const GFitsTableLngCol&amp; column) @@ -325,9 +389,8 @@ void GFitsTableLngCol::copy_members(const GFitsTableLngCol&amp; column)
325 } 389 }
326 390
327 391
328 -/***************************************************************************  
329 - * Delete class members *  
330 - * ----------------------------------------------------------------------- * 392 +/***********************************************************************//**
  393 + * @brief Delete class members
331 ***************************************************************************/ 394 ***************************************************************************/
332 void GFitsTableLngCol::free_members(void) 395 void GFitsTableLngCol::free_members(void)
333 { 396 {
@@ -344,26 +407,47 @@ void GFitsTableLngCol::free_members(void) @@ -344,26 +407,47 @@ void GFitsTableLngCol::free_members(void)
344 } 407 }
345 408
346 409
347 -/***************************************************************************  
348 - * Load column data *  
349 - * ----------------------------------------------------------------------- * 410 +/***********************************************************************//**
  411 + * @brief Fetch column data
  412 + *
  413 + * @exception GException::fits_error
  414 + * An error occured while loading column data from FITS file.
  415 + *
  416 + * If a FITS file is attached to the column the data are loaded into memory
  417 + * from the FITS file. If no FITS file is attached, memory is allocated
  418 + * to hold the column data and all cells are set to 0.
350 ***************************************************************************/ 419 ***************************************************************************/
351 -void GFitsTableLngCol::load(void) 420 +void GFitsTableLngCol::fetch_data(void)
352 { 421 {
353 // Calculate size of memory 422 // Calculate size of memory
354 m_size = m_repeat * m_length; 423 m_size = m_repeat * m_length;
355 424
356 - // Allocate memory  
357 - if (m_data != NULL) delete [] m_data;  
358 - m_data = new long[m_size]; 425 + // Load only if the column has a positive size
  426 + if (m_size > 0) {
  427 +
  428 + // Allocate fresh memory
  429 + if (m_data != NULL) delete [] m_data;
  430 + m_data = new long[m_size];
359 431
360 - // Load column data  
361 - int status = 0;  
362 - status = __ffmahd(&m_fitsfile, (m_fitsfile.HDUposition)+1, NULL, &status);  
363 - status = __ffgcv(&m_fitsfile, __TLONG, m_colnum, 1, 1, m_size,  
364 - m_nulval, m_data, &m_anynul, &status);  
365 - if (status != 0)  
366 - throw GException::fits_error(G_LOAD, status); 432 + // If a FITS file is attached then load column data from the FITS
  433 + // file
  434 + if (m_fitsfile.Fptr != NULL) {
  435 + int status = 0;
  436 + status = __ffmahd(&m_fitsfile, (m_fitsfile.HDUposition)+1, NULL,
  437 + &status);
  438 + status = __ffgcv(&m_fitsfile, __TLONG, m_colnum, 1, 1, m_size,
  439 + m_nulval, m_data, &m_anynul, &status);
  440 + if (status != 0)
  441 + throw GException::fits_error(G_FETCH_DATA, status);
  442 + }
  443 +
  444 + // ... otherwise initialise all column values to 0
  445 + else {
  446 + for (int i = 0; i < m_size; ++i)
  447 + m_data[i] = 0;
  448 + }
  449 +
  450 + } // endif: column has a positive size
367 451
368 // Return 452 // Return
369 return; 453 return;
@@ -372,13 +456,13 @@ void GFitsTableLngCol::load(void) @@ -372,13 +456,13 @@ void GFitsTableLngCol::load(void)
372 456
373 /*========================================================================== 457 /*==========================================================================
374 = = 458 = =
375 - = GFitsTableShtCol friends = 459 + = GFitsTableLngCol friends =
376 = = 460 = =
377 ==========================================================================*/ 461 ==========================================================================*/
378 462
379 463
380 /*========================================================================== 464 /*==========================================================================
381 = = 465 = =
382 - = Other functions used by GFitsTableShtCol = 466 + = Other functions used by GFitsTableLngCol =
383 = = 467 = =
384 ==========================================================================*/ 468 ==========================================================================*/
src/rsp/GLATResponse.cpp
  View file @1fff8b9
@@ -425,10 +425,12 @@ void GLATResponse::psf_init(void) @@ -425,10 +425,12 @@ void GLATResponse::psf_init(void)
425 425
426 // Evaluate ntail 426 // Evaluate ntail
427 double denom = psf_base_value(10.0, gtail); 427 double denom = psf_base_value(10.0, gtail);
428 - double ntail = (denom != 0.0) ? ncore * psf_base_value(10.0, gcore) / denom : 0.0; 428 + double ntail = (denom != 0.0)
  429 + ? ncore * psf_base_value(10.0, gcore) / denom : 0.0;
429 430
430 // Calculate PSF dependence 431 // Calculate PSF dependence
431 - GVector psf = ncore * psf_base_vector(u, gcore) + ntail * psf_base_vector(u, gtail); 432 + GVector psf = ncore * psf_base_vector(u, gcore) +
  433 + ntail * psf_base_vector(u, gtail);
432 434
433 // Normalize PSF vector to identical amplitudes at smallest angular 435 // Normalize PSF vector to identical amplitudes at smallest angular
434 // distance. This allows for accurate interpolation afterwards 436 // distance. This allows for accurate interpolation afterwards
@@ -555,7 +557,7 @@ double GLATResponse::psf_base_value(const double&amp; u, const double&amp; gamma) @@ -555,7 +557,7 @@ double GLATResponse::psf_base_value(const double&amp; u, const double&amp; gamma)
555 double c0 = 1.0 - invgamma; 557 double c0 = 1.0 - invgamma;
556 double c1 = 1.0 + u * invgamma; 558 double c1 = 1.0 + u * invgamma;
557 double result = c0 * pow(c1,-gamma); 559 double result = c0 * pow(c1,-gamma);
558 - 560 +
559 // Return result 561 // Return result
560 return result; 562 return result;
561 } 563 }
@@ -567,7 +569,7 @@ GVector GLATResponse::psf_base_vector(const GVector&amp; u, const double&amp; gamma) @@ -567,7 +569,7 @@ GVector GLATResponse::psf_base_vector(const GVector&amp; u, const double&amp; gamma)
567 double c0 = 1.0 - invgamma; 569 double c0 = 1.0 - invgamma;
568 GVector c1 = 1.0 + u * invgamma; 570 GVector c1 = 1.0 + u * invgamma;
569 GVector result = c0 * pow(c1,-gamma); 571 GVector result = c0 * pow(c1,-gamma);
570 - 572 +
571 // Return result 573 // Return result
572 return result; 574 return result;
573 } 575 }
@@ -631,7 +633,7 @@ void GLATResponse::init_members(void) @@ -631,7 +633,7 @@ void GLATResponse::init_members(void)
631 //m_aeff_name.clear(); 633 //m_aeff_name.clear();
632 //m_psf_name.clear(); 634 //m_psf_name.clear();
633 //m_edisp_name.clear(); 635 //m_edisp_name.clear();
634 - 636 +
635 // Initialise PSF members 637 // Initialise PSF members
636 m_psf_angle_num = 0; 638 m_psf_angle_num = 0;
637 m_psf_angle_min = 0.0; 639 m_psf_angle_min = 0.0;
@@ -703,7 +705,7 @@ GVector GLATResponse::get_fits_vector(const GFitsHDU* hdu, const std::string&amp; co @@ -703,7 +705,7 @@ GVector GLATResponse::get_fits_vector(const GFitsHDU* hdu, const std::string&amp; co
703 GFitsTableCol* ptr = hdu->column(colname); 705 GFitsTableCol* ptr = hdu->column(colname);
704 if (ptr == NULL) 706 if (ptr == NULL)
705 throw GException::fits_column_not_found(G_GET_FITS_VECTOR, colname); 707 throw GException::fits_column_not_found(G_GET_FITS_VECTOR, colname);
706 - 708 +
707 // Determine number of entries 709 // Determine number of entries
708 int num = ptr->repeat(); 710 int num = ptr->repeat();
709 711
test/test_GFits.cpp
  View file @1fff8b9
@@ -373,14 +373,25 @@ void test_create(void) @@ -373,14 +373,25 @@ void test_create(void)
373 373
374 // Attach binary table 374 // Attach binary table
375 try { 375 try {
  376 + // Re-open FITS file
376 GFits fits; 377 GFits fits;
377 fits.open("test.fits"); 378 fits.open("test.fits");
  379 +
  380 + // Create binary Table with 10 rows
378 int nrows = 10; 381 int nrows = 10;
379 - int ncols = 5;  
380 - GFitsBinTable table(nrows); 382 + GFitsBinTable table = GFitsBinTable(nrows);
  383 + GFitsTableDblCol first = GFitsTableDblCol(nrows);
  384 + GFitsTableDblCol second = GFitsTableDblCol(nrows);
  385 + table.append_column(&first);
  386 + table.append_column(&second);
  387 + cout << table;
  388 +
  389 + // Create HDU and append to FILE file
381 GFitsHDU hdu(table); 390 GFitsHDU hdu(table);
382 fits.append(&hdu); 391 fits.append(&hdu);
383 - cout << fits; 392 +// cout << fits;
  393 +
  394 + // Save FITS file
384 fits.save(); 395 fits.save();
385 } 396 }
386 catch (exception &e) { 397 catch (exception &e) {