diff --git a/six/modules/c++/cphd/include/cphd/PVP.h b/six/modules/c++/cphd/include/cphd/PVP.h
index edbc2f2d3..57ab46192 100644
--- a/six/modules/c++/cphd/include/cphd/PVP.h
+++ b/six/modules/c++/cphd/include/cphd/PVP.h
@@ -270,6 +270,21 @@ struct SIX_CPHD_API TxAntenna final
     {
         return !((*this) == other);
     }
+    
+    //! Given an initial offset, setup each member relative to it
+    void setOffset(const size_t offset)
+    {
+        txACX.value().param.setOffset(offset);      // 3 blocks
+        txACY.value().param.setOffset(offset + 3);  // 3 blocks
+        txEB.value().param.setOffset(offset + 6);  // 2 blocks
+    }
+    
+    //! Get the offset to the first member
+    //! This assumes the fields are sequential, which isn't necessarily true 
+    const size_t getOffset() const
+    {
+        return txACX.value().param.getOffset();
+    }
 
     //! TxACX PVP Structure
     six::XsElement<PerVectorParameterXYZ> txACX{ "TxACX" };
@@ -307,7 +322,22 @@ struct SIX_CPHD_API RcvAntenna final
     {
         return !((*this) == other);
     }
-
+    
+    //! Given an initial offset, setup each member relative to it
+    void setOffset(const size_t offset)
+    {
+        rcvACX.value().param.setOffset(offset);      // 3 blocks
+        rcvACY.value().param.setOffset(offset + 3);  // 3 blocks
+        rcvEB.value().param.setOffset(offset + 6);  // 2 blocks
+    }
+    
+    //! Get the offset to the first member
+    //! This assumes the fields are sequential, which isn't necessarily true 
+    const size_t getOffset() const
+    {
+        return rcvACX.value().param.getOffset();
+    }
+    
     //! RcvACX PVP Structure
     six::XsElement<PerVectorParameterXYZ> rcvACX{ "RcvACX" };
 
@@ -579,6 +609,26 @@ struct SIX_CPHD_API Pvp final
      *   if format is invalid
      */
     void append(PVPType& param);
+    
+    /*
+     *  \func appendTxAnt
+     *
+     *  \brief Add transmit antenna block to PVP data
+     *
+     *  \throws except::Exception If param offset or size overlaps another parameter, or
+     *   if format is invalid, or the transmit antenna already has been set
+     */
+    void appendTxAnt();
+    
+    /*
+     *  \func appendRcvAnt
+     *
+     *  \brief Add receive antenna block to PVP data
+     *
+     *  \throws except::Exception If param offset or size overlaps another parameter, or
+     *   if format is invalid, or the receive antenna already has been set
+     */
+    void appendRcvAnt();
 
     /*
      *  \func setParameter
diff --git a/six/modules/c++/cphd/include/cphd/PVPBlock.h b/six/modules/c++/cphd/include/cphd/PVPBlock.h
index c4929a84d..c8c6851c5 100644
--- a/six/modules/c++/cphd/include/cphd/PVPBlock.h
+++ b/six/modules/c++/cphd/include/cphd/PVPBlock.h
@@ -86,6 +86,47 @@ struct AddedPVP<std::string>
     }
 };
 
+struct PvpAntenna
+{
+    PvpAntenna() :
+        acx(Vector3()),
+        acy(Vector3()),
+        eb(Vector2()) {};
+    PvpAntenna(Vector3 acx, Vector3 acy, Vector2 eb):
+        acx(acx),
+        acy(acy),
+        eb(eb) {};
+    ~PvpAntenna() = default;
+    PvpAntenna(const PvpAntenna&) = default;
+    PvpAntenna& operator=(const PvpAntenna&) = default;
+    PvpAntenna(PvpAntenna&&) = default;
+    PvpAntenna& operator=(PvpAntenna&&) = default;
+    
+    Vector3 acx;
+    Vector3 acy;
+    Vector2 eb;
+    
+    
+    bool operator==(const PvpAntenna& other) const 
+    {
+        return (acx == other.acx) &&
+               (acy == other.acy) &&
+               (eb == other.eb); 
+    };
+    
+    bool operator!=(const PvpAntenna& other) const 
+    {
+        return !(*this == other); 
+    };
+};
+inline std::ostream& operator<<(std::ostream& os, const PvpAntenna& v)
+{
+    os << v.acx << "\n";
+    os << v.acy << "\n";
+    os << v.eb << "\n";
+    return os;
+}
+
 /*!
  *  \struct PVPBlock
  *
@@ -184,6 +225,8 @@ struct SIX_CPHD_API PVPBlock
     double getTOAE2(size_t channel, size_t set) const;
     double getTdIonoSRP(size_t channel, size_t set) const;
     std::int64_t getSignal(size_t channel, size_t set) const;
+    PvpAntenna getTxAntenna(size_t channel, size_t set) const;
+    PvpAntenna getRcvAntenna(size_t channel, size_t set) const;
 
     template<typename T>
     T getAddedPVP(size_t channel, size_t set, const std::string& name) const
@@ -223,6 +266,8 @@ struct SIX_CPHD_API PVPBlock
     void setTOAE2(double value, size_t channel, size_t set);
     void setTdIonoSRP(double value, size_t channel, size_t set);
     void setSignal(std::int64_t value, size_t channel, size_t set);
+    void setTxAntenna(PvpAntenna value, size_t channel, size_t set);
+    void setRcvAntenna(PvpAntenna value, size_t channel, size_t set);
 
     template<typename T>
     void setAddedPVP(T value, size_t channel, size_t set, const std::string& name)
@@ -312,6 +357,14 @@ struct SIX_CPHD_API PVPBlock
     {
         return mSignalEnabled;
     }
+    bool hasTxAntenna() const
+    {
+        return mTxAntennaEnabled;
+    }
+    bool hasRcvAntenna() const
+    {
+        return mRcvAntennaEnabled;
+    }
 
     /*
      *  \func load
@@ -416,7 +469,8 @@ struct SIX_CPHD_API PVPBlock
                     ampSF == other.ampSF && fxN1 == other.fxN1 &&
                     fxN2 == other.fxN2 && toaE1 == other.toaE1 &&
                     toaE2 == other.toaE2 && tdIonoSRP == other.tdIonoSRP &&
-                    signal == other.signal && addedPVP == other.addedPVP;
+                    signal == other.signal && addedPVP == other.addedPVP &&
+                    txAntenna == other.txAntenna && rcvAntenna == other.rcvAntenna;
         }
         bool operator!=(const PVPSet& other) const
         {
@@ -450,6 +504,8 @@ struct SIX_CPHD_API PVPBlock
         mem::ScopedCopyablePtr<double> toaE2;
         mem::ScopedCopyablePtr<double> tdIonoSRP;
         mem::ScopedCopyablePtr<std::int64_t> signal;
+        mem::ScopedCopyablePtr<PvpAntenna> txAntenna;
+        mem::ScopedCopyablePtr<PvpAntenna> rcvAntenna;
 
         //! (Optional) Additional parameters
         std::unordered_map<std::string,six::Parameter> addedPVP;
@@ -474,6 +530,8 @@ struct SIX_CPHD_API PVPBlock
     bool mToaE2Enabled;
     bool mTDIonoSRPEnabled;
     bool mSignalEnabled;
+    bool mTxAntennaEnabled;
+    bool mRcvAntennaEnabled;
 
     //! Ostream operator
     SIX_CPHD_API friend std::ostream& operator<< (std::ostream& os, const PVPBlock& p);
diff --git a/six/modules/c++/cphd/include/cphd/TestDataGenerator.h b/six/modules/c++/cphd/include/cphd/TestDataGenerator.h
index 1a8b47d37..d3111025a 100644
--- a/six/modules/c++/cphd/include/cphd/TestDataGenerator.h
+++ b/six/modules/c++/cphd/include/cphd/TestDataGenerator.h
@@ -46,6 +46,14 @@ namespace cphd
  */
 SIX_CPHD_API double getRandom();
 
+/*
+ *  \func getRandomVector2
+ *  \brief generates vector2D type object with random values
+ *
+ *  \return Return vector2D object
+ */
+SIX_CPHD_API Vector2 getRandomVector2();
+
 /*
  *  \func getRandomVector3
  *  \brief generates vector3D type object with random values
diff --git a/six/modules/c++/cphd/source/CPHDXMLParser.cpp b/six/modules/c++/cphd/source/CPHDXMLParser.cpp
index 8cd76a2e8..0f0718572 100644
--- a/six/modules/c++/cphd/source/CPHDXMLParser.cpp
+++ b/six/modules/c++/cphd/source/CPHDXMLParser.cpp
@@ -1460,20 +1460,20 @@ void CPHDXMLParser::parse(const xml::lite::Element& parent, six::XsElement_minOc
 {
     if (const auto pXML = getOptional(parent, o.tag()))
     {
-        o = TxAntenna{};
-        parse(*pXML, value(o).txACX);
-        parse(*pXML, value(o).txACY);
-        parse(*pXML, value(o).txEB);
+        o.value().emplace();
+        parse(getFirstAndOnly(*pXML, "TxACX"), value(o).txACX);
+        parse(getFirstAndOnly(*pXML, "TxACY"), value(o).txACY);
+        parse(getFirstAndOnly(*pXML, "TxEB"), value(o).txEB);
     }
 }
 void CPHDXMLParser::parse(const xml::lite::Element& parent, six::XsElement_minOccurs0<RcvAntenna>& o) const
 {
     if (const auto pXML = getOptional(parent, o.tag()))
     {
-        o = RcvAntenna{};
-        parse(*pXML, value(o).rcvACX);
-        parse(*pXML, value(o).rcvACY);
-        parse(*pXML, value(o).rcvEB);
+        o.value().emplace();
+        parse(getFirstAndOnly(*pXML, "RcvACX"), value(o).rcvACX);
+        parse(getFirstAndOnly(*pXML, "RcvACY"), value(o).rcvACY);
+        parse(getFirstAndOnly(*pXML, "RcvEB"), value(o).rcvEB);
     }
 }
 
diff --git a/six/modules/c++/cphd/source/PVP.cpp b/six/modules/c++/cphd/source/PVP.cpp
index 9b65b7396..35217f188 100644
--- a/six/modules/c++/cphd/source/PVP.cpp
+++ b/six/modules/c++/cphd/source/PVP.cpp
@@ -112,6 +112,30 @@ void Pvp::append(PVPType& param)
     setOffset(currentOffset, param);
 }
 
+void Pvp::appendTxAnt()
+{
+    size_t currentOffset = mParamLocations.size();
+    if(has_value(txAntenna))
+    {
+        throw except::Exception(Ctxt("txAntenna already set"));
+    } 
+    validate(8, currentOffset);
+    txAntenna.value().emplace();
+    value(txAntenna).setOffset(currentOffset);
+}
+
+void Pvp::appendRcvAnt()
+{
+    size_t currentOffset = mParamLocations.size();
+    if(has_value(rcvAntenna))
+    {
+        throw except::Exception(Ctxt("rcvAntenna already set"));
+    } 
+    validate(8, currentOffset);
+    rcvAntenna.value().emplace();
+    value(rcvAntenna).setOffset(currentOffset);
+}
+
 // Assumes addedPVP is already correct size
 void Pvp::setCustomParameter(size_t size, size_t offset, const std::string& format, const std::string& name)
 {
@@ -175,6 +199,14 @@ size_t Pvp::getReqSetSize() const
     {
         res += signal.getSize();
     }
+    if(has_value(txAntenna))
+    {
+        res += 8;
+    }
+    if(has_value(rcvAntenna))
+    {
+        res += 8;
+    }
     for (auto it = addedPVP.begin(); it != addedPVP.end(); ++it)
     {
         res += it->second.getSize();
@@ -253,11 +285,11 @@ std::ostream& operator<< (std::ostream& os, const Pvp& p)
     }
     if (has_value(p.txAntenna))
     {
-        os << "  TxAntenna        : \n" << p.txAntenna << "\n";
+        os <<  p.txAntenna;
     }
     if (has_value(p.rcvAntenna))
     {
-        os << "  RcvAntenna        : \n" << p.rcvAntenna << "\n";
+        os <<  p.rcvAntenna;
     }
     for (auto it = p.addedPVP.begin(); it != p.addedPVP.end(); ++it)
     {
diff --git a/six/modules/c++/cphd/source/PVPBlock.cpp b/six/modules/c++/cphd/source/PVPBlock.cpp
index 1d5bbfc40..68533c147 100644
--- a/six/modules/c++/cphd/source/PVPBlock.cpp
+++ b/six/modules/c++/cphd/source/PVPBlock.cpp
@@ -65,6 +65,15 @@ template <typename T> inline void setData(const double* data_,
     setData(data, dest);
 }
 
+inline void setData(const std::byte* data_,
+                    cphd::Vector2& dest)
+{
+    const void* pData_ = data_;
+    auto data = static_cast<const double*>(pData_);
+    setData(&(data[0]), dest[0]);
+    setData(&(data[1]), dest[1]);
+}
+
 inline void setData(const std::byte* data_,
                     cphd::Vector3& dest)
 {
@@ -92,6 +101,16 @@ template <typename T> inline void getData(std::byte* dest,
     memcpy(dest, value, size);
 }
 
+inline void getData(std::byte* dest_,
+                    const cphd::Vector2& value)
+{
+    void* pDest_ = dest_;
+    auto dest = static_cast<double*>(pDest_);
+
+    getData(&(dest[0]), value[0]);
+    getData(&(dest[1]), value[1]);
+}
+
 inline void getData(std::byte* dest_,
                     const cphd::Vector3& value)
 {
@@ -106,7 +125,6 @@ inline void getData(std::byte* dest_,
 
 namespace cphd
 {
-
 PVPBlock::PVPSet::PVPSet() :
     txTime(six::Init::undefined<double>()),
     txPos(six::Init::undefined<Vector3>()),
@@ -183,6 +201,20 @@ void PVPBlock::PVPSet::write(const PVPBlock& pvpBlock, const Pvp& p, const sys::
         signal.reset(new std::int64_t());
         ::setData(input + p.signal.getByteOffset(), *signal);
     }
+    if (pvpBlock.hasTxAntenna())
+    {
+        txAntenna.reset(new PvpAntenna());
+        ::setData(input + value(p.txAntenna).txACX.value().param.getByteOffset(), txAntenna->acx);
+        ::setData(input + value(p.txAntenna).txACY.value().param.getByteOffset(), txAntenna->acy);
+        ::setData(input + value(p.txAntenna).txEB.value().param.getByteOffset(), txAntenna->eb);
+    }
+    if (pvpBlock.hasRcvAntenna())
+    {
+        rcvAntenna.reset(new PvpAntenna());
+        ::setData(input + value(p.rcvAntenna).rcvACX.value().param.getByteOffset(), rcvAntenna->acx);
+        ::setData(input + value(p.rcvAntenna).rcvACY.value().param.getByteOffset(), rcvAntenna->acy);
+        ::setData(input + value(p.rcvAntenna).rcvEB.value().param.getByteOffset(), rcvAntenna->eb);
+    }
     for (auto it = p.addedPVP.begin(); it != p.addedPVP.end(); ++it)
     {
         if (it->second.getFormat() == "F4")
@@ -367,6 +399,18 @@ void PVPBlock::PVPSet::read(const Pvp& p, sys::ubyte* dest_) const
     {
         ::getData(dest + p.signal.getByteOffset(), *signal);
     }
+    if (txAntenna.get())
+    {
+        ::getData(dest + value(p.txAntenna).txACX.value().param.getByteOffset(), txAntenna->acx);
+        ::getData(dest + value(p.txAntenna).txACY.value().param.getByteOffset(), txAntenna->acy);
+        ::getData(dest + value(p.txAntenna).txEB.value().param.getByteOffset(), txAntenna->eb);
+    }
+    if (rcvAntenna.get())
+    {
+        ::getData(dest + value(p.rcvAntenna).rcvACX.value().param.getByteOffset(), rcvAntenna->acx);
+        ::getData(dest + value(p.rcvAntenna).rcvACY.value().param.getByteOffset(), rcvAntenna->acy);
+        ::getData(dest + value(p.rcvAntenna).rcvEB.value().param.getByteOffset(), rcvAntenna->eb);
+    }
     if (addedPVP.size() != p.addedPVP.size())
     {
         throw except::Exception(Ctxt(
@@ -455,7 +499,9 @@ PVPBlock::PVPBlock(const Pvp& p, const Data& d) :
     mToaE1Enabled(!six::Init::isUndefined<size_t>(p.toaE1.getOffset())),
     mToaE2Enabled(!six::Init::isUndefined<size_t>(p.toaE2.getOffset())),
     mTDIonoSRPEnabled(!six::Init::isUndefined<size_t>(p.tdIonoSRP.getOffset())),
-    mSignalEnabled(!six::Init::isUndefined<size_t>(p.signal.getOffset()))
+    mSignalEnabled(!six::Init::isUndefined<size_t>(p.signal.getOffset())),
+    mTxAntennaEnabled(has_value(p.txAntenna)),
+    mRcvAntennaEnabled(has_value(p.rcvAntenna))
 {
     mPvp = p;
     mNumBytesPerVector = d.getNumBytesPVPSet();
@@ -494,7 +540,9 @@ PVPBlock::PVPBlock(size_t numChannels,
     mToaE1Enabled(!six::Init::isUndefined<size_t>(p.toaE1.getOffset())),
     mToaE2Enabled(!six::Init::isUndefined<size_t>(p.toaE2.getOffset())),
     mTDIonoSRPEnabled(!six::Init::isUndefined<size_t>(p.tdIonoSRP.getOffset())),
-    mSignalEnabled(!six::Init::isUndefined<size_t>(p.signal.getOffset()))
+    mSignalEnabled(!six::Init::isUndefined<size_t>(p.signal.getOffset())),
+    mTxAntennaEnabled(has_value(p.txAntenna)),
+    mRcvAntennaEnabled(has_value(p.rcvAntenna))
 {
     mData.resize(numChannels);
     if(numChannels != numVectors.size())
@@ -841,6 +889,28 @@ std::int64_t PVPBlock::getSignal(size_t channel, size_t set) const
                     "Parameter was not set"));
 }
 
+PvpAntenna PVPBlock::getTxAntenna(size_t channel, size_t set) const
+{
+    verifyChannelVector(channel, set);
+    if (mData[channel][set].txAntenna.get())
+    {
+        return *mData[channel][set].txAntenna;
+    }
+    throw except::Exception(Ctxt(
+                    "Parameter was not set"));
+}
+
+PvpAntenna PVPBlock::getRcvAntenna(size_t channel, size_t set) const
+{
+    verifyChannelVector(channel, set);
+    if (mData[channel][set].rcvAntenna.get())
+    {
+        return *mData[channel][set].rcvAntenna;
+    }
+    throw except::Exception(Ctxt(
+                    "Parameter was not set"));
+}
+
 void PVPBlock::setTxTime(double value, size_t channel, size_t vector)
 {
     verifyChannelVector(channel, vector);
@@ -1027,6 +1097,30 @@ void PVPBlock::setSignal(std::int64_t value, size_t channel, size_t vector)
                             "Parameter was not specified in XML"));
 }
 
+void PVPBlock::setTxAntenna(PvpAntenna value, size_t channel, size_t vector)
+{
+    verifyChannelVector(channel, vector);
+    if (hasTxAntenna())
+    {
+        mData[channel][vector].txAntenna.reset(new PvpAntenna(value));
+        return;
+    }
+    throw except::Exception(Ctxt(
+                            "Parameter was not specified in XML"));
+}
+
+void PVPBlock::setRcvAntenna(PvpAntenna value, size_t channel, size_t vector)
+{
+    verifyChannelVector(channel, vector);
+    if (hasRcvAntenna())
+    {
+        mData[channel][vector].rcvAntenna.reset(new PvpAntenna(value));
+        return;
+    }
+    throw except::Exception(Ctxt(
+                            "Parameter was not specified in XML"));
+}
+
 std::ostream& operator<< (std::ostream& os, const PVPBlock::PVPSet& p)
 {
     os << "  TxTime         : " << p.txTime << "\n"
diff --git a/six/modules/c++/cphd/source/TestDataGenerator.cpp b/six/modules/c++/cphd/source/TestDataGenerator.cpp
index cabf17a47..44281f5bf 100644
--- a/six/modules/c++/cphd/source/TestDataGenerator.cpp
+++ b/six/modules/c++/cphd/source/TestDataGenerator.cpp
@@ -44,6 +44,14 @@ double getRandom()
     return -1000.0  + r * 2000.0;
 }
 
+Vector2 getRandomVector2()
+{
+    Vector2 ret;
+    ret[0] = getRandom();
+    ret[1] = getRandom();
+    return ret;
+}
+
 Vector3 getRandomVector3()
 {
     Vector3 ret;
diff --git a/six/modules/c++/cphd/unittests/test_pvp.cpp b/six/modules/c++/cphd/unittests/test_pvp.cpp
index 79a4128b7..dbf5c30ec 100644
--- a/six/modules/c++/cphd/unittests/test_pvp.cpp
+++ b/six/modules/c++/cphd/unittests/test_pvp.cpp
@@ -49,6 +49,8 @@ TEST_CASE(testAppend)
     pvp.append(pvp.ampSF);
     pvp.appendCustomParameter(8, "S8", "AddedParam1");
     pvp.append(pvp.signal);
+    pvp.appendTxAnt();
+    pvp.appendRcvAnt();
 
     TEST_ASSERT_TRUE(pvp.txTime.getOffset() == 0);
     TEST_ASSERT_TRUE(pvp.txPos.getOffset() == 1);
@@ -56,6 +58,8 @@ TEST_CASE(testAppend)
     TEST_ASSERT_TRUE(pvp.ampSF.getOffset() == 7);
     TEST_ASSERT_TRUE(pvp.addedPVP["AddedParam1"].getOffset() == 8);
     TEST_ASSERT_TRUE(pvp.signal.getOffset() == 16);
+    TEST_ASSERT_TRUE(value(pvp.txAntenna).getOffset() == 17);
+    TEST_ASSERT_TRUE(value(pvp.rcvAntenna).getOffset() == 25);
 }
 
 TEST_CASE(testAddedParamsEqualityOperatorTrue)
@@ -101,10 +105,20 @@ TEST_CASE(testAddedParamsEqualityOperatorFalse)
     TEST_ASSERT_TRUE((pvp1 != pvp3));
 }
 
+TEST_CASE(testAntennaFailure)
+{
+    cphd::Pvp pvp;
+    pvp.appendTxAnt();
+    pvp.appendRcvAnt();
+    TEST_EXCEPTION(pvp.appendTxAnt());
+    TEST_EXCEPTION(pvp.appendRcvAnt());
+}
+
 TEST_MAIN(
         TEST_CHECK(testSimpleEqualityOperatorTrue);
         TEST_CHECK(testAppend);
         TEST_CHECK(testAddedParamsEqualityOperatorTrue);
         TEST_CHECK(testSimpleEqualityOperatorFalse);
         TEST_CHECK(testAddedParamsEqualityOperatorFalse);
+        TEST_CHECK(testAntennaFailure);
         )
\ No newline at end of file
diff --git a/six/modules/c++/cphd/unittests/test_pvp_block.cpp b/six/modules/c++/cphd/unittests/test_pvp_block.cpp
index ffba33abf..17427f95f 100644
--- a/six/modules/c++/cphd/unittests/test_pvp_block.cpp
+++ b/six/modules/c++/cphd/unittests/test_pvp_block.cpp
@@ -143,6 +143,8 @@ TEST_CASE(testPvpOptional)
     pvp.setCustomParameter(1, 30, "F8", "Param1");
     pvp.setCustomParameter(1, 31, "S10", "Param2");
     pvp.setCustomParameter(1, 32, "CI16", "Param3");
+    pvp.appendTxAnt();
+    pvp.appendRcvAnt();
     cphd::PVPBlock pvpBlock(NUM_CHANNELS,
                             std::vector<size_t>(NUM_CHANNELS, NUM_VECTORS),
                             pvp);
@@ -159,6 +161,19 @@ TEST_CASE(testPvpOptional)
             pvpBlock.setFxN1(fxN1, channel, vector);
             const double fxN2 = cphd::getRandom();
             pvpBlock.setFxN2(fxN2, channel, vector);
+            
+            const cphd::PvpAntenna txAnt(
+                cphd::getRandomVector3(),
+                cphd::getRandomVector3(),
+                cphd::getRandomVector2());
+            pvpBlock.setTxAntenna(txAnt, channel, vector);
+                 
+            const cphd::PvpAntenna rcvAnt(
+                cphd::getRandomVector3(),
+                cphd::getRandomVector3(),
+                cphd::getRandomVector2()); 
+            pvpBlock.setRcvAntenna(rcvAnt, channel, vector);
+
             const double addedParam1 = cphd::getRandom();
             pvpBlock.setAddedPVP(addedParam1, channel, vector, "Param1");
             const std::string addedParam2 = "Parameter2";
@@ -169,6 +184,8 @@ TEST_CASE(testPvpOptional)
             TEST_ASSERT_EQ(ampSF, pvpBlock.getAmpSF(channel, vector));
             TEST_ASSERT_EQ(fxN1, pvpBlock.getFxN1(channel, vector));
             TEST_ASSERT_EQ(fxN2, pvpBlock.getFxN2(channel, vector));
+            TEST_ASSERT_EQ(txAnt, pvpBlock.getTxAntenna(channel, vector));
+            TEST_ASSERT_EQ(rcvAnt, pvpBlock.getRcvAntenna(channel, vector));
             TEST_ASSERT_EQ(addedParam1, pvpBlock.getAddedPVP<double>(channel, vector, "Param1"));
             TEST_ASSERT_EQ(addedParam2, pvpBlock.getAddedPVP<std::string>(channel, vector, "Param2"));
             TEST_ASSERT_EQ(addedParam3, pvpBlock.getAddedPVP<cphd::zint32_t >(channel, vector, "Param3"));
diff --git a/six/modules/c++/cphd/unittests/test_pvp_block_round.cpp b/six/modules/c++/cphd/unittests/test_pvp_block_round.cpp
index 51d5bd975..867c5a99e 100644
--- a/six/modules/c++/cphd/unittests/test_pvp_block_round.cpp
+++ b/six/modules/c++/cphd/unittests/test_pvp_block_round.cpp
@@ -65,6 +65,8 @@ void setPVPBlock(const types::RowCol<size_t> dims,
                  bool isTOAE1,
                  bool isTOAE2,
                  bool isSignal,
+                 bool isTxAnt,
+                 bool isRcvAnt,
                  const std::vector<std::string>& addedParams)
 {
     const size_t numChannels = 1;
@@ -106,6 +108,22 @@ void setPVPBlock(const types::RowCol<size_t> dims,
                 const double signal = cphd::getRandom();
                 pvpBlock.setTOAE2(signal, ii, jj);
             }
+            if (isTxAnt)
+            {
+                const cphd::PvpAntenna antenna(
+                    cphd::getRandomVector3(),
+                    cphd::getRandomVector3(),
+                    cphd::getRandomVector2());
+                pvpBlock.setTxAntenna(antenna, ii, jj);
+            }
+            if (isRcvAnt)
+            {
+                const cphd::PvpAntenna antenna(
+                    cphd::getRandomVector3(),
+                    cphd::getRandomVector3(),
+                    cphd::getRandomVector2());
+                pvpBlock.setRcvAntenna(antenna, ii, jj);
+            }
 
             for (size_t idx = 0; idx < addedParams.size(); ++idx)
             {
@@ -186,6 +204,8 @@ TEST_CASE(testPVPBlockSimple)
                 false,
                 false,
                 false,
+                false,
+                false,
                 addedParams);
 
     TEST_ASSERT_TRUE(runTest(scale, writeData, meta, pvpBlock, dims));
@@ -198,9 +218,11 @@ TEST_CASE(testPVPBlockOptional)
     const bool scale = false;
     auto meta = cphd::setUpData(dims, writeData);
     cphd::setPVPXML(meta.pvp);
-    meta.pvp.setOffset(27, meta.pvp.fxN1);
-    meta.pvp.setOffset(28, meta.pvp.fxN2);
-    meta.data.numBytesPVP += 2 * 8;
+    meta.pvp.setOffset(meta.pvp.getReqSetSize(), meta.pvp.fxN1);
+    meta.pvp.setOffset(meta.pvp.getReqSetSize(), meta.pvp.fxN2);
+    meta.pvp.appendTxAnt();
+    meta.pvp.appendRcvAnt();
+    meta.data.numBytesPVP = meta.pvp.getReqSetSize() * 8;
     cphd::PVPBlock pvpBlock(meta.pvp, meta.data);
     std::vector<std::string> addedParams;
     setPVPBlock(dims,
@@ -211,6 +233,8 @@ TEST_CASE(testPVPBlockOptional)
                 false,
                 false,
                 false,
+                true,
+                true,
                 addedParams);
 
     TEST_ASSERT_TRUE(runTest(scale, writeData, meta, pvpBlock, dims));
@@ -238,6 +262,8 @@ TEST_CASE(testPVPBlockAdditional)
                 false,
                 false,
                 false,
+                false,
+                false,
                 addedParams);
 
     TEST_ASSERT_TRUE(runTest(scale, writeData, meta, pvpBlock, dims));