Merge branch 'main' into regrow

Author: brownd1978

Detector/ParameterHit.hh

@@ -15,17 +15,18 @@ namespace KinKal {
       using PTRAJ = ParticleTrajectory<KTRAJ>;
       using KTRAJPTR = std::shared_ptr<KTRAJ>;
 
-      // clone op for reinstantiation
+      // copy constructor
       ParameterHit(ParameterHit<KTRAJ> const& rhs):
           time_(rhs.time()),
           params_(rhs.constraintParameters()),
-          pweight_(rhs.pweight()),
+          pweight_(rhs.parameterWeights()),
           weight_(rhs.weight()),
-          pmask_(rhs.pmask()),
-          mask_(rhs.mask()),
-          ncons_(rhs.ncons()){
+          pmask_(rhs.constraintMask()),
+          mask_(rhs.maskMatrix()),
+          ncons_(rhs.numConstrainedParameters()){
         /**/
       };
+      // clone op for reinstantiation
       std::shared_ptr< Hit<KTRAJ> > clone(CloneContext& context) const override{
         auto rv = std::make_shared< ParameterHit<KTRAJ> >(*this);
         return rv;
@@ -47,10 +48,9 @@ namespace KinKal {
       unsigned nDOF() const override { return ncons_; }
       Parameters const& constraintParameters() const { return params_; }
       PMASK const& constraintMask() const { return pmask_; }
-      Weights pweight() const { return pweight_; };
-      PMASK pmask() const { return pmask_; };
-      DMAT mask() const { return mask_; }
-      unsigned ncons() const { return ncons_; };
+      Weights parameterWeights() const { return pweight_; };
+      DMAT maskMatrix() const { return mask_; }
+      unsigned numConstrainedParameters() const { return ncons_; };
     private:
       double time_; // time of this constraint: must be supplied on construction and does not change
       KTRAJPTR reftraj_; // reference WRT this hits weight was calculated

Detector/ResidualHit.hh

@@ -10,7 +10,7 @@ namespace KinKal {
 
   template <class KTRAJ> class ResidualHit : public Hit<KTRAJ> {
     public:
-      // clone op for reinstantiation
+      // copy constructor
       ResidualHit(ResidualHit<KTRAJ> const& rhs): weight_(rhs.weight()){
         /**/
       };

Examples/ScintHit.hh

@@ -17,18 +17,28 @@ namespace KinKal {
       using RESIDHIT = ResidualHit<KTRAJ>;
       using HIT = Hit<KTRAJ>;
       using KTRAJPTR = std::shared_ptr<KTRAJ>;
-      // clone op for reinstantiation
+      // copy constructor
       ScintHit(ScintHit<KTRAJ> const& rhs):
           ResidualHit<KTRAJ>(rhs),
           saxis_(rhs.sensorAxis()),
           tvar_(rhs.timeVariance()),
           wvar_(rhs.widthVariance()),
-          tpca_(rhs.closestApproach()),
+          tpca_(
+                rhs.closestApproach().particleTraj(),
+                saxis_,
+                rhs.closestApproach().hint(),
+                rhs.closestApproach().precision()
+          ),
           rresid_(rhs.refResidual()){
         /**/
       };
+      // clone op for reinstantiation
       std::shared_ptr< Hit<KTRAJ> > clone(CloneContext& context) const override{
         auto rv = std::make_shared< ScintHit<KTRAJ> >(*this);
+        auto ca = rv->closestApproach();
+        auto trajectory = std::make_shared<KTRAJ>(ca.particleTraj());
+        ca.setTrajectory(trajectory);
+        rv->setClosestApproach(ca);
         return rv;
       };
       // ResidualHit interface implementation
@@ -54,6 +64,9 @@ namespace KinKal {
       double wvar_; // variance in transverse position of the sensor/measurement in mm.  Assumes cylindrical error, could be more general
       CA tpca_; // reference time and position of closest approach to the axis
       Residual rresid_; // residual WRT most recent reference parameters
+
+      // modifiers to support cloning
+      void setClosestApproach(const CA& ca){ tpca_ = ca; }
   };
 
   template <class KTRAJ> ScintHit<KTRAJ>::ScintHit(PCA const& pca, double tvar, double wvar) :

Examples/SimpleWireHit.hh

@@ -81,8 +81,7 @@ namespace KinKal {
       auto const& residuals() const { return rresid_; }
       double tot() const { return tot_; }
       double totVariance() const { return totvar_; }
-      // other accessors
-      void setClosestApproach(const CA& ca){ ca_ = ca; }
+
     private:
       BFieldMap const& bfield_; // drift calculation requires the BField for ExB effects
       WireHitState whstate_; // current state
@@ -100,6 +99,9 @@ namespace KinKal {
       double rcell_; // straw radius
       int id_; // id
       void updateResiduals();
+
+      // modifiers to support cloning
+      void setClosestApproach(const CA& ca){ ca_ = ca; }
   };
 
   //trivial 'updater' that sets the wire hit state to null

Examples/StrawXing.hh

@@ -21,9 +21,25 @@ namespace KinKal {
       // construct from PCA and material
       StrawXing(PCA const& pca, StrawMaterial const& smat);
       virtual ~StrawXing() {}
+      // copy constructor
+      StrawXing(StrawXing const& rhs):
+          ElementXing<KTRAJ>(rhs),
+          axis_(rhs.axis_),
+          smat_(rhs.smat_),
+          tpca_(
+                rhs.closestApproach().particleTraj(),
+                axis_,
+                rhs.closestApproach().hint(),
+                rhs.closestApproach().precision()
+          ),
+          toff_(rhs.toff_),
+          sxconfig_(rhs.sxconfig_),
+          varscale_(rhs.varscale_),
+          mxings_(rhs.mxings_),
+          fparams_(rhs.fparams_){
+        /**/
+      }
       // clone op for reinstantiation
-      // ejc TODO does typeof(tpca_) == ClosestApproach<> need a deeper clone?
-      StrawXing(StrawXing const& rhs) = default;
       std::shared_ptr< ElementXing<KTRAJ> > clone(CloneContext& context) const override{
         auto rv = std::make_shared< StrawXing<KTRAJ> >(*this);
         auto ca = rv->closestApproach();
@@ -47,8 +63,7 @@ namespace KinKal {
       auto const& strawMaterial() const { return smat_; }
       auto const& config() const { return sxconfig_; }
       auto precision() const { return tpca_.precision(); }
-      // other accessors
-      void setClosestApproach(const CA& ca){ tpca_ = ca; }
+
     private:
       SensorLine axis_; // straw axis, expressed as a timeline
       StrawMaterial const& smat_;
@@ -58,6 +73,9 @@ namespace KinKal {
       double varscale_; // variance scale
       std::vector<MaterialXing> mxings_;
       Parameters fparams_; // parameter change for forwards time
+
+      // modifiers to support cloning
+      void setClosestApproach(const CA& ca){ tpca_ = ca; }
   };
 
   template <class KTRAJ> StrawXing<KTRAJ>::StrawXing(PCA const& pca, StrawMaterial const& smat) :

Fit/DomainWall.hh

@@ -51,15 +51,16 @@ namespace KinKal {
       auto const& prevWeight() const { return prevwt_; }
       auto const& nextWeight() const { return nextwt_; }
       auto const& fwdCovarianceRotation() const { return dpdpdb_; }
-      void setPrevPtr(DOMAINPTR const& ptr){ prev_ = ptr; }
-      void setNextPtr(DOMAINPTR const& ptr){ next_ = ptr; }
 
     private:
       DOMAINPTR prev_, next_; // pointers to previous and next domains
       DVEC dpfwd_; // parameter change across this domain wall in the forwards time direction
       Weights prevwt_, nextwt_; // cache of weights
       PSMAT dpdpdb_; // forward rotation of covariance matrix going in the forwards direction
 
+      // modifiers to support cloning
+      void setPrevPtr(DOMAINPTR const& ptr){ prev_ = ptr; }
+      void setNextPtr(DOMAINPTR const& ptr){ next_ = ptr; }
   };
 
   template<class KTRAJ> DomainWall<KTRAJ>::DomainWall(

Fit/Material.hh

@@ -39,12 +39,13 @@ namespace KinKal {
       auto const& elementXing() const { return *exingptr_; }
       auto const& elementXingPtr() const { return exingptr_; }
       auto const& referenceTrajectory() const { return exingptr_->referenceTrajectory(); }
-      // other accessors
       auto const& weights() const { return nextwt_; }
-      void setElementXingPtr(EXINGPTR const& ptr){ exingptr_ = ptr; }
     private:
       EXINGPTR exingptr_; // element crossing for this effect
       Weights nextwt_; // cache of weight forwards of this effect.
+
+      // modifiers to support cloning
+      void setElementXingPtr(EXINGPTR const& ptr){ exingptr_ = ptr; }
   };
 
   template<class KTRAJ> Material<KTRAJ>::Material(EXINGPTR const& exingptr, PTRAJ const& ptraj) : exingptr_(exingptr) {

Fit/Measurement.hh

@@ -37,10 +37,11 @@ namespace KinKal {
       std::unique_ptr< Effect<KTRAJ> > clone(CloneContext&) const override;
       // access the underlying hit
       HITPTR const& hit() const { return hit_; }
-      // other accessors
-      void setHitPtr(HITPTR const& ptr){ hit_ = ptr; }
     private:
       HITPTR hit_ ; // hit used for this measurement
+
+      // modifiers to support cloning
+      void setHitPtr(HITPTR const& ptr){ hit_ = ptr; }
   };
 
   template<class KTRAJ> Measurement<KTRAJ>::Measurement(HITPTR const& hit,PTRAJ const& ptraj) : hit_(hit) {