casa  5.7.0-16
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
CalPointingModelRow.h
Go to the documentation of this file.
1 
2 /*
3  * ALMA - Atacama Large Millimeter Array
4  * (c) European Southern Observatory, 2002
5  * (c) Associated Universities Inc., 2002
6  * Copyright by ESO (in the framework of the ALMA collaboration),
7  * Copyright by AUI (in the framework of the ALMA collaboration),
8  * All rights reserved.
9  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * This library is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY, without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with this library; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
23  * MA 02111-1307 USA
24  *
25  * Warning!
26  * --------------------------------------------------------------------
27  * | This is generated code! Do not modify this file. |
28  * | If you do, all changes will be lost when the file is re-generated. |
29  * --------------------------------------------------------------------
30  *
31  * File CalPointingModelRow.h
32  */
33 
34 #ifndef CalPointingModelRow_CLASS
35 #define CalPointingModelRow_CLASS
36 
37 #include <vector>
38 #include <string>
39 #include <set>
40 
41 #ifndef WITHOUT_ACS
42 #include <asdmIDLC.h>
43 #endif
44 
45 
46 
47 
48 
49 
50 
51 #include <alma/ASDM/Angle.h>
52 
53 
54 
55 #include <alma/ASDM/ArrayTime.h>
56 
57 
58 
59 #include <alma/ASDM/Tag.h>
60 
61 
62 
63 
64 
65 
66 
67 
69 
70 
71 
72 
73 
74 
75 
77 
78 
79 
81 
82 
83 
85 
86 
87 
88 
89 
90 
91 
92 
93 
94 
95 
96 
97 
98 
99 
100 
101 
102 
103 
104 
105 
106 
107 
108 
109 
110 
112 #include <alma/ASDM/NoSuchRow.h>
114 
116 //#include <alma/ASDM/TableStreamReader.h>
117 
118 /*\file CalPointingModel.h
119  \brief Generated from model's revision "-1", branch ""
120 */
121 
122 namespace asdm {
123 
124 //class asdm::CalPointingModelTable;
125 
126 
127 // class asdm::CalDataRow;
128 class CalDataRow;
129 
130 // class asdm::CalReductionRow;
131 class CalReductionRow;
132 
133 
134 class CalPointingModelRow;
136 typedef void (CalPointingModelRow::*CalPointingModelAttributeFromText) (const std::string& s);
137 
147 //friend class asdm::TableStreamReader<CalPointingModelTable, CalPointingModelRow>;
148 
149 public:
150 
151  virtual ~CalPointingModelRow();
152 
157 
162  bool isAdded() const;
163 
165  // Intrinsic Table Attributes //
167 
168 
169  // ===> Attribute antennaName
170 
171 
172 
173 
174 
179  std::string getAntennaName() const;
180 
181 
182 
183 
193  void setAntennaName (std::string antennaName);
194 
195 
196 
197 
198 
199 
200 
201  // ===> Attribute receiverBand
202 
203 
204 
205 
206 
211  ReceiverBandMod::ReceiverBand getReceiverBand() const;
212 
213 
214 
215 
225  void setReceiverBand (ReceiverBandMod::ReceiverBand receiverBand);
226 
227 
228 
229 
230 
231 
232 
233  // ===> Attribute startValidTime
234 
235 
236 
237 
238 
244 
245 
246 
247 
256 
257 
258 
259 
260 
261 
262 
263  // ===> Attribute endValidTime
264 
265 
266 
267 
268 
273  ArrayTime getEndValidTime() const;
274 
275 
276 
277 
286 
287 
288 
289 
290 
291 
292 
293  // ===> Attribute antennaMake
294 
295 
296 
297 
298 
303  AntennaMakeMod::AntennaMake getAntennaMake() const;
304 
305 
306 
307 
315  void setAntennaMake (AntennaMakeMod::AntennaMake antennaMake);
316 
317 
318 
319 
320 
321 
322 
323  // ===> Attribute pointingModelMode
324 
325 
326 
327 
328 
333  PointingModelModeMod::PointingModelMode getPointingModelMode() const;
334 
335 
336 
337 
345  void setPointingModelMode (PointingModelModeMod::PointingModelMode pointingModelMode);
346 
347 
348 
349 
350 
351 
352 
353  // ===> Attribute polarizationType
354 
355 
356 
357 
358 
363  PolarizationTypeMod::PolarizationType getPolarizationType() const;
364 
365 
366 
367 
375  void setPolarizationType (PolarizationTypeMod::PolarizationType polarizationType);
376 
377 
378 
379 
380 
381 
382 
383  // ===> Attribute numCoeff
384 
385 
386 
387 
388 
393  int getNumCoeff() const;
394 
395 
396 
397 
405  void setNumCoeff (int numCoeff);
406 
407 
408 
409 
410 
411 
412 
413  // ===> Attribute coeffName
414 
415 
416 
417 
418 
423  std::vector<std::string > getCoeffName() const;
424 
425 
426 
427 
435  void setCoeffName (std::vector<std::string > coeffName);
436 
437 
438 
439 
440 
441 
442 
443  // ===> Attribute coeffVal
444 
445 
446 
447 
448 
453  std::vector<float > getCoeffVal() const;
454 
455 
456 
457 
465  void setCoeffVal (std::vector<float > coeffVal);
466 
467 
468 
469 
470 
471 
472 
473  // ===> Attribute coeffError
474 
475 
476 
477 
478 
483  std::vector<float > getCoeffError() const;
484 
485 
486 
487 
495  void setCoeffError (std::vector<float > coeffError);
496 
497 
498 
499 
500 
501 
502 
503  // ===> Attribute coeffFixed
504 
505 
506 
507 
508 
513  std::vector<bool > getCoeffFixed() const;
514 
515 
516 
517 
525  void setCoeffFixed (std::vector<bool > coeffFixed);
526 
527 
528 
529 
530 
531 
532 
533  // ===> Attribute azimuthRMS
534 
535 
536 
537 
538 
543  Angle getAzimuthRMS() const;
544 
545 
546 
547 
556 
557 
558 
559 
560 
561 
562 
563  // ===> Attribute elevationRms
564 
565 
566 
567 
568 
573  Angle getElevationRms() const;
574 
575 
576 
577 
586 
587 
588 
589 
590 
591 
592 
593  // ===> Attribute skyRMS
594 
595 
596 
597 
598 
603  Angle getSkyRMS() const;
604 
605 
606 
607 
615  void setSkyRMS (Angle skyRMS);
616 
617 
618 
619 
620 
621 
622 
623  // ===> Attribute reducedChiSquared
624 
625 
626 
627 
628 
633  double getReducedChiSquared() const;
634 
635 
636 
637 
646 
647 
648 
649 
650 
651 
652 
653  // ===> Attribute numObs, which is optional
654 
655 
656 
661  bool isNumObsExists() const;
662 
663 
664 
670  int getNumObs() const;
671 
672 
673 
674 
681  void setNumObs (int numObs);
682 
683 
684 
685 
689  void clearNumObs ();
690 
691 
692 
693 
694  // ===> Attribute coeffFormula, which is optional
695 
696 
697 
702  bool isCoeffFormulaExists() const;
703 
704 
705 
711  std::vector<std::string > getCoeffFormula() const;
712 
713 
714 
715 
722  void setCoeffFormula (std::vector<std::string > coeffFormula);
723 
724 
725 
726 
730  void clearCoeffFormula ();
731 
732 
733 
735  // Extrinsic Table Attributes //
737 
738 
739  // ===> Attribute calDataId
740 
741 
742 
743 
744 
749  Tag getCalDataId() const;
750 
751 
752 
753 
763  void setCalDataId (Tag calDataId);
764 
765 
766 
767 
768 
769 
770 
771  // ===> Attribute calReductionId
772 
773 
774 
775 
776 
781  Tag getCalReductionId() const;
782 
783 
784 
785 
796 
797 
798 
799 
800 
801 
803  // Links //
805 
806 
807 
808 
809 
817 
818 
819 
820 
821 
822 
823 
824 
832 
833 
834 
835 
836 
837 
838 
880  bool compareNoAutoInc(std::string antennaName, ReceiverBandMod::ReceiverBand receiverBand, Tag calDataId, Tag calReductionId, ArrayTime startValidTime, ArrayTime endValidTime, AntennaMakeMod::AntennaMake antennaMake, PointingModelModeMod::PointingModelMode pointingModelMode, PolarizationTypeMod::PolarizationType polarizationType, int numCoeff, std::vector<std::string > coeffName, std::vector<float > coeffVal, std::vector<float > coeffError, std::vector<bool > coeffFixed, Angle azimuthRMS, Angle elevationRms, Angle skyRMS, double reducedChiSquared);
881 
882 
883 
884 
918  bool compareRequiredValue(ArrayTime startValidTime, ArrayTime endValidTime, AntennaMakeMod::AntennaMake antennaMake, PointingModelModeMod::PointingModelMode pointingModelMode, PolarizationTypeMod::PolarizationType polarizationType, int numCoeff, std::vector<std::string > coeffName, std::vector<float > coeffVal, std::vector<float > coeffError, std::vector<bool > coeffFixed, Angle azimuthRMS, Angle elevationRms, Angle skyRMS, double reducedChiSquared);
919 
920 
930 
931 #ifndef WITHOUT_ACS
932 
936  asdmIDL::CalPointingModelRowIDL *toIDL() const;
937 
945  void toIDL(asdmIDL::CalPointingModelRowIDL& x) const;
946 #endif
947 
948 #ifndef WITHOUT_ACS
949 
954  void setFromIDL (asdmIDL::CalPointingModelRowIDL x) ;
955 #endif
956 
961  std::string toXML() const;
962 
969  void setFromXML (std::string rowDoc) ;
970 
973  // binary-deserialization material from an EndianIStream //
975 
976  std::map<std::string, CalPointingModelAttributeFromBin> fromBinMethods;
979 void calDataIdFromBin( EndianIStream& eis);
986 void numCoeffFromBin( EndianIStream& eis);
987 void coeffNameFromBin( EndianIStream& eis);
988 void coeffValFromBin( EndianIStream& eis);
989 void coeffErrorFromBin( EndianIStream& eis);
990 void coeffFixedFromBin( EndianIStream& eis);
991 void azimuthRMSFromBin( EndianIStream& eis);
993 void skyRMSFromBin( EndianIStream& eis);
995 
996 void numObsFromBin( EndianIStream& eis);
998 
999 
1007  static CalPointingModelRow* fromBin(EndianIStream& eis, CalPointingModelTable& table, const std::vector<std::string>& attributesSeq);
1008 
1015  void fromText(const std::string& attributeName, const std::string& t);
1017 
1018 private:
1027 
1028  // This method is used by the Table class when this row is added to the table.
1029  void isAdded(bool added);
1030 
1031 
1041 
1060 
1062  // Intrinsic Table Attributes //
1064 
1065 
1066  // ===> Attribute antennaName
1067 
1068 
1069 
1070  std::string antennaName;
1071 
1072 
1073 
1074 
1075 
1076 
1077  // ===> Attribute receiverBand
1078 
1079 
1080 
1081  ReceiverBandMod::ReceiverBand receiverBand;
1082 
1083 
1084 
1085 
1086 
1087 
1088  // ===> Attribute startValidTime
1089 
1090 
1091 
1093 
1094 
1095 
1096 
1097 
1098 
1099  // ===> Attribute endValidTime
1100 
1101 
1102 
1104 
1105 
1106 
1107 
1108 
1109 
1110  // ===> Attribute antennaMake
1111 
1112 
1113 
1114  AntennaMakeMod::AntennaMake antennaMake;
1115 
1116 
1117 
1118 
1119 
1120 
1121  // ===> Attribute pointingModelMode
1122 
1123 
1124 
1125  PointingModelModeMod::PointingModelMode pointingModelMode;
1126 
1127 
1128 
1129 
1130 
1131 
1132  // ===> Attribute polarizationType
1133 
1134 
1135 
1136  PolarizationTypeMod::PolarizationType polarizationType;
1137 
1138 
1139 
1140 
1141 
1142 
1143  // ===> Attribute numCoeff
1144 
1145 
1146 
1148 
1149 
1150 
1151 
1152 
1153 
1154  // ===> Attribute coeffName
1155 
1156 
1157 
1158  std::vector<std::string > coeffName;
1159 
1160 
1161 
1162 
1163 
1164 
1165  // ===> Attribute coeffVal
1166 
1167 
1168 
1169  std::vector<float > coeffVal;
1170 
1171 
1172 
1173 
1174 
1175 
1176  // ===> Attribute coeffError
1177 
1178 
1179 
1180  std::vector<float > coeffError;
1181 
1182 
1183 
1184 
1185 
1186 
1187  // ===> Attribute coeffFixed
1188 
1189 
1190 
1191  std::vector<bool > coeffFixed;
1192 
1193 
1194 
1195 
1196 
1197 
1198  // ===> Attribute azimuthRMS
1199 
1200 
1201 
1203 
1204 
1205 
1206 
1207 
1208 
1209  // ===> Attribute elevationRms
1210 
1211 
1212 
1214 
1215 
1216 
1217 
1218 
1219 
1220  // ===> Attribute skyRMS
1221 
1222 
1223 
1225 
1226 
1227 
1228 
1229 
1230 
1231  // ===> Attribute reducedChiSquared
1232 
1233 
1234 
1236 
1237 
1238 
1239 
1240 
1241 
1242  // ===> Attribute numObs, which is optional
1243 
1244 
1246 
1247 
1248  int numObs;
1249 
1250 
1251 
1252 
1253 
1254 
1255  // ===> Attribute coeffFormula, which is optional
1256 
1257 
1259 
1260 
1261  std::vector<std::string > coeffFormula;
1262 
1263 
1264 
1265 
1266 
1268  // Extrinsic Table Attributes //
1270 
1271 
1272  // ===> Attribute calDataId
1273 
1274 
1275 
1276  Tag calDataId;
1277 
1278 
1279 
1280 
1281 
1282 
1283  // ===> Attribute calReductionId
1284 
1285 
1286 
1288 
1289 
1290 
1291 
1292 
1294  // Links //
1296 
1297 
1298 
1299 
1300 
1301 
1302 
1303 
1304 
1305 
1306 
1307 
1308 
1309 
1310 
1311 
1312 /*
1314  // binary-deserialization material from an EndianIStream //
1316  std::map<std::string, CalPointingModelAttributeFromBin> fromBinMethods;
1317 void antennaNameFromBin( EndianIStream& eis);
1318 void receiverBandFromBin( EndianIStream& eis);
1319 void calDataIdFromBin( EndianIStream& eis);
1320 void calReductionIdFromBin( EndianIStream& eis);
1321 void startValidTimeFromBin( EndianIStream& eis);
1322 void endValidTimeFromBin( EndianIStream& eis);
1323 void antennaMakeFromBin( EndianIStream& eis);
1324 void pointingModelModeFromBin( EndianIStream& eis);
1325 void polarizationTypeFromBin( EndianIStream& eis);
1326 void numCoeffFromBin( EndianIStream& eis);
1327 void coeffNameFromBin( EndianIStream& eis);
1328 void coeffValFromBin( EndianIStream& eis);
1329 void coeffErrorFromBin( EndianIStream& eis);
1330 void coeffFixedFromBin( EndianIStream& eis);
1331 void azimuthRMSFromBin( EndianIStream& eis);
1332 void elevationRmsFromBin( EndianIStream& eis);
1333 void skyRMSFromBin( EndianIStream& eis);
1334 void reducedChiSquaredFromBin( EndianIStream& eis);
1335 
1336 void numObsFromBin( EndianIStream& eis);
1337 void coeffFormulaFromBin( EndianIStream& eis);
1338 
1339 */
1340 
1342  // text-deserialization material //
1344  std::map<std::string, CalPointingModelAttributeFromText> fromTextMethods;
1345 
1346 void antennaNameFromText (const std::string & s);
1347 
1348 
1349 void receiverBandFromText (const std::string & s);
1350 
1351 
1352 void calDataIdFromText (const std::string & s);
1353 
1354 
1355 void calReductionIdFromText (const std::string & s);
1356 
1357 
1358 void startValidTimeFromText (const std::string & s);
1359 
1360 
1361 void endValidTimeFromText (const std::string & s);
1362 
1363 
1364 void antennaMakeFromText (const std::string & s);
1365 
1366 
1367 void pointingModelModeFromText (const std::string & s);
1368 
1369 
1370 void polarizationTypeFromText (const std::string & s);
1371 
1372 
1373 void numCoeffFromText (const std::string & s);
1374 
1375 
1376 void coeffNameFromText (const std::string & s);
1377 
1378 
1379 void coeffValFromText (const std::string & s);
1380 
1381 
1382 void coeffErrorFromText (const std::string & s);
1383 
1384 
1385 void coeffFixedFromText (const std::string & s);
1386 
1387 
1388 void azimuthRMSFromText (const std::string & s);
1389 
1390 
1391 void elevationRmsFromText (const std::string & s);
1392 
1393 
1394 void skyRMSFromText (const std::string & s);
1395 
1396 
1397 void reducedChiSquaredFromText (const std::string & s);
1398 
1399 
1400 
1401 void numObsFromText (const std::string & s);
1402 
1403 
1404 void coeffFormulaFromText (const std::string & s);
1405 
1406 
1407 
1412  void toBin(EndianOSStream& eoss);
1413 
1423 };
1424 
1425 } // End namespace asdm
1426 
1427 #endif /* CalPointingModel_CLASS */
void setPolarizationType(PolarizationTypeMod::PolarizationType polarizationType)
Set polarizationType with the specified PolarizationTypeMod::PolarizationType.
void antennaNameFromText(const std::string &s)
void numObsFromText(const std::string &s)
std::vector< float > coeffError
===&gt; Attribute coeffError
void(CalPointingModelRow::* CalPointingModelAttributeFromBin)(EndianIStream &eis)
void receiverBandFromText(const std::string &s)
void startValidTimeFromBin(EndianIStream &eis)
void antennaNameFromBin(EndianIStream &eis)
Angle azimuthRMS
===&gt; Attribute azimuthRMS
void setReceiverBand(ReceiverBandMod::ReceiverBand receiverBand)
Set receiverBand with the specified ReceiverBandMod::ReceiverBand.
void setFromXML(std::string rowDoc)
Fill the values of this row from an XML string that was produced by the toXML() method.
void antennaMakeFromBin(EndianIStream &eis)
void polarizationTypeFromText(const std::string &s)
bool isAdded() const
Has this row been added to its table ?
void setCoeffFixed(std::vector< bool > coeffFixed)
Set coeffFixed with the specified std::vector&lt;bool &gt;.
void endValidTimeFromText(const std::string &s)
AntennaMakeMod::AntennaMake getAntennaMake() const
===&gt; Attribute antennaMake
void receiverBandFromBin(EndianIStream &eis)
void setEndValidTime(ArrayTime endValidTime)
Set endValidTime with the specified ArrayTime.
Tag calReductionId
===&gt; Attribute calReductionId
void numCoeffFromBin(EndianIStream &eis)
ArrayTime getStartValidTime() const
===&gt; Attribute startValidTime
void setCoeffName(std::vector< std::string > coeffName)
Set coeffName with the specified std::vector&lt;std::string &gt;.
void coeffFixedFromText(const std::string &s)
double getReducedChiSquared() const
===&gt; Attribute reducedChiSquared
void setPointingModelMode(PointingModelModeMod::PointingModelMode pointingModelMode)
Set pointingModelMode with the specified PointingModelModeMod::PointingModelMode. ...
bool isCoeffFormulaExists() const
===&gt; Attribute coeffFormula, which is optional
void coeffFormulaFromText(const std::string &s)
CalPointingModelRow(CalPointingModelTable &table)
Create a CalPointingModelRow.
void coeffFixedFromBin(EndianIStream &eis)
void setFromIDL(asdmIDL::CalPointingModelRowIDL x)
Fill the values of this row from the IDL struct CalPointingModelRowIDL.
void coeffValFromText(const std::string &s)
void setCoeffVal(std::vector< float > coeffVal)
Set coeffVal with the specified std::vector&lt;float &gt;.
void setCalDataId(Tag calDataId)
Set calDataId with the specified Tag.
std::vector< float > getCoeffVal() const
===&gt; Attribute coeffVal
void coeffFormulaFromBin(EndianIStream &eis)
std::string toXML() const
Return this row in the form of an XML string.
void coeffNameFromBin(EndianIStream &eis)
virtual ~CalPointingModelRow()
friend class asdm::TableStreamReader&lt;CalPointingModelTable, CalPointingModelRow&gt;; ...
void coeffErrorFromBin(EndianIStream &eis)
void skyRMSFromBin(EndianIStream &eis)
void clearNumObs()
Mark numObs, which is an optional field, as non-existent.
void calDataIdFromText(const std::string &s)
void reducedChiSquaredFromBin(EndianIStream &eis)
void calReductionIdFromText(const std::string &s)
void coeffValFromBin(EndianIStream &eis)
PointingModelModeMod::PointingModelMode pointingModelMode
===&gt; Attribute pointingModelMode
Angle getElevationRms() const
===&gt; Attribute elevationRms
The Angle class implements a quantity of angle in radians.
Definition: Angle.h:53
PolarizationTypeMod::PolarizationType getPolarizationType() const
===&gt; Attribute polarizationType
double reducedChiSquared
===&gt; Attribute reducedChiSquared
int numCoeff
===&gt; Attribute numCoeff
void setCoeffError(std::vector< float > coeffError)
Set coeffError with the specified std::vector&lt;float &gt;.
std::vector< std::string > coeffFormula
void calDataIdFromBin(EndianIStream &eis)
void numObsFromBin(EndianIStream &eis)
bool hasBeenAdded
Whether this row has been added to the table or not.
Angle getAzimuthRMS() const
===&gt; Attribute azimuthRMS
void azimuthRMSFromText(const std::string &s)
void elevationRmsFromBin(EndianIStream &eis)
Links *binary deserialization material from an EndianIStream std::map< std::string, CalPointingModelAttributeFromBin > fromBinMethods
std::vector< std::string > getCoeffFormula() const
Get coeffFormula, which is optional.
void pointingModelModeFromText(const std::string &s)
ReceiverBandMod::ReceiverBand getReceiverBand() const
===&gt; Attribute receiverBand
bool isNumObsExists() const
===&gt; Attribute numObs, which is optional
The CalReductionRow class is a row of a CalReductionTable.
int getNumObs() const
Get numObs, which is optional.
The CalPointingModelTable class is an Alma table.
ArrayTime getEndValidTime() const
===&gt; Attribute endValidTime
void coeffErrorFromText(const std::string &s)
void calReductionIdFromBin(EndianIStream &eis)
void azimuthRMSFromBin(EndianIStream &eis)
void endValidTimeFromBin(EndianIStream &eis)
void antennaMakeFromText(const std::string &s)
void setAzimuthRMS(Angle azimuthRMS)
Set azimuthRMS with the specified Angle.
void skyRMSFromText(const std::string &s)
Angle getSkyRMS() const
===&gt; Attribute skyRMS
The ArrayTime class implements the concept of a point in time, implemented as an Interval of time sin...
Definition: ArrayTime.h:89
Angle skyRMS
===&gt; Attribute skyRMS
bool numObsExists
===&gt; Attribute numObs, which is optional
PointingModelModeMod::PointingModelMode getPointingModelMode() const
===&gt; Attribute pointingModelMode
bool equalByRequiredValue(CalPointingModelRow *x)
Return true if all required attributes of the value part are equal to their homologues in x and false...
void pointingModelModeFromBin(EndianIStream &eis)
void setCoeffFormula(std::vector< std::string > coeffFormula)
Set coeffFormula with the specified std::vector&lt;std::string &gt;.
The Tag class is an implementation of a unique index identifying a row of an ASDM table...
Definition: Tag.h:73
void setCalReductionId(Tag calReductionId)
Set calReductionId with the specified Tag.
Links *CalDataRow * getCalDataUsingCalDataId()
calDataId pointer to the row in the CalData table having CalData.calDataId == calDataId ...
void reducedChiSquaredFromText(const std::string &s)
void(CalPointingModelRow::* CalPointingModelAttributeFromText)(const std::string &s)
bool coeffFormulaExists
===&gt; Attribute coeffFormula, which is optional
std::vector< bool > getCoeffFixed() const
===&gt; Attribute coeffFixed
*text deserialization material std::map< std::string, CalPointingModelAttributeFromText > fromTextMethods
Tag getCalReductionId() const
===&gt; Attribute calReductionId
AntennaMakeMod::AntennaMake antennaMake
===&gt; Attribute antennaMake
Angle elevationRms
===&gt; Attribute elevationRms
std::vector< float > getCoeffError() const
===&gt; Attribute coeffError
CalReductionRow * getCalReductionUsingCalReductionId()
calReductionId pointer to the row in the CalReduction table having CalReduction.calReductionId == cal...
void setAntennaMake(AntennaMakeMod::AntennaMake antennaMake)
Set antennaMake with the specified AntennaMakeMod::AntennaMake.
void setReducedChiSquared(double reducedChiSquared)
Set reducedChiSquared with the specified double.
asdmIDL::CalPointingModelRowIDL * toIDL() const
Return this row in the form of an IDL struct.
The CalDataRow class is a row of a CalDataTable.
Definition: CalDataRow.h:130
void setNumObs(int numObs)
Set numObs with the specified int.
ReceiverBandMod::ReceiverBand receiverBand
===&gt; Attribute receiverBand
void setSkyRMS(Angle skyRMS)
Set skyRMS with the specified Angle.
std::vector< std::string > coeffName
===&gt; Attribute coeffName
void numCoeffFromText(const std::string &s)
void elevationRmsFromText(const std::string &s)
void setAntennaName(std::string antennaName)
Set antennaName with the specified std::string.
std::vector< std::string > getCoeffName() const
===&gt; Attribute coeffName
bool compareNoAutoInc(std::string antennaName, ReceiverBandMod::ReceiverBand receiverBand, Tag calDataId, Tag calReductionId, ArrayTime startValidTime, ArrayTime endValidTime, AntennaMakeMod::AntennaMake antennaMake, PointingModelModeMod::PointingModelMode pointingModelMode, PolarizationTypeMod::PolarizationType polarizationType, int numCoeff, std::vector< std::string > coeffName, std::vector< float > coeffVal, std::vector< float > coeffError, std::vector< bool > coeffFixed, Angle azimuthRMS, Angle elevationRms, Angle skyRMS, double reducedChiSquared)
Compare each mandatory attribute except the autoincrementable one of this CalPointingModelRow with th...
void setElevationRms(Angle elevationRms)
Set elevationRms with the specified Angle.
void startValidTimeFromText(const std::string &s)
void toBin(EndianOSStream &eoss)
Serialize this into a stream of bytes written to an EndianOSStream.
CalPointingModelTable & table
The table to which this row belongs.
void clearCoeffFormula()
Mark coeffFormula, which is an optional field, as non-existent.
The CalPointingModelRow class is a row of a CalPointingModelTable.
void setStartValidTime(ArrayTime startValidTime)
Set startValidTime with the specified ArrayTime.
CalPointingModelTable & getTable() const
Return the table to which this row belongs.
bool compareRequiredValue(ArrayTime startValidTime, ArrayTime endValidTime, AntennaMakeMod::AntennaMake antennaMake, PointingModelModeMod::PointingModelMode pointingModelMode, PolarizationTypeMod::PolarizationType polarizationType, int numCoeff, std::vector< std::string > coeffName, std::vector< float > coeffVal, std::vector< float > coeffError, std::vector< bool > coeffFixed, Angle azimuthRMS, Angle elevationRms, Angle skyRMS, double reducedChiSquared)
Compare each mandatory value (i.e.
std::vector< float > coeffVal
===&gt; Attribute coeffVal
ArrayTime startValidTime
===&gt; Attribute startValidTime
ArrayTime endValidTime
===&gt; Attribute endValidTime
PolarizationTypeMod::PolarizationType polarizationType
===&gt; Attribute polarizationType
std::vector< bool > coeffFixed
===&gt; Attribute coeffFixed
void coeffNameFromText(const std::string &s)
void polarizationTypeFromBin(EndianIStream &eis)
int getNumCoeff() const
===&gt; Attribute numCoeff
void setNumCoeff(int numCoeff)
Set numCoeff with the specified int.