BDSExtent.hh

/* 
Beam Delivery Simulation (BDSIM) Copyright (C) BDSIM Collaboration, 2001 - 2026.
 
This file is part of BDSIM.
 
BDSIM is free software: you can redistribute it and/or modify 
it under the terms of the GNU General Public License as published 
by the Free Software Foundation version 3 of the License.
 
BDSIM is distributed in the hope that it will be useful, but 
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with BDSIM.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef BDSEXTENT_H
#define BDSEXTENT_H
 
#include <ostream>
#include <utility> // for pair and pair relational operators
#include <vector>
 
#include "globals.hh" // geant4 types / globals
#include "G4ThreeVector.hh"
 
class BDSParticleCoords;
class BDSTiltOffset;
 
class BDSExtent
{
public:
  BDSExtent();
  BDSExtent(const std::pair<G4double, G4double>& extXIn,
            const std::pair<G4double, G4double>& extYIn,
            const std::pair<G4double, G4double>& extZIn);
  BDSExtent(G4double extXNegIn, G4double extXPosIn,
            G4double extYNegIn, G4double extYPosIn,
            G4double extZNegIn, G4double extZPosIn);
  BDSExtent(G4double extXIn, G4double extYIn, G4double extZIn);
  BDSExtent(G4ThreeVector extInNeg, G4ThreeVector extInPos);
  explicit BDSExtent(G4ThreeVector extIn);
            
  virtual ~BDSExtent();
 
  inline std::pair<G4double, G4double> ExtentX() const {return std::make_pair(extXNeg, extXPos);}
  inline std::pair<G4double, G4double> ExtentY() const {return std::make_pair(extYNeg, extYPos);}
  inline std::pair<G4double, G4double> ExtentZ() const {return std::make_pair(extZNeg, extZPos);}
  
  inline G4double XNeg() const {return extXNeg;}
  inline G4double XPos() const {return extXPos;}
  inline G4double YNeg() const {return extYNeg;}
  inline G4double YPos() const {return extYPos;}
  inline G4double ZNeg() const {return extZNeg;}
  inline G4double ZPos() const {return extZPos;}
  
  inline G4ThreeVector ExtentPositive() const
  {return G4ThreeVector(extXPos, extYPos, extZPos);}
 
  inline G4ThreeVector ExtentNegative() const
  {return G4ThreeVector(extXNeg, extYNeg, extZNeg);}
 
  std::vector<G4ThreeVector> AllBoundaryPoints() const;
 
  inline G4double DX() const {return extXPos - extXNeg;}
  inline G4double DY() const {return extYPos - extYNeg;}
  inline G4double DZ() const {return extZPos - extZNeg;}
 
  inline G4bool operator< (const BDSExtent& r) const;
  inline G4bool operator> (const BDSExtent& r) const {return r < (*this);}
  inline G4bool operator<=(const BDSExtent& r) const {return !((*this) > r);}
  inline G4bool operator>=(const BDSExtent& r) const {return !((*this) < r);}
 
  inline G4bool operator==(const BDSExtent& r) const;
  inline G4bool operator!=(const BDSExtent& r) const {return !((*this) == r);}
 
  inline G4bool TransverselyLessThan(const BDSExtent& r) const;
  inline G4bool TransverselyGreaterThan(const BDSExtent& r)   const {return !(this->TransverselyLessThan(r));}
  inline G4bool TransverselyLessEquals(const BDSExtent& r)    const {return !(this->TransverselyGreaterThan(r));}
  inline G4bool TransverselyGreaterEquals(const BDSExtent& r) const {return !(this->TransverselyLessThan(r));}
 
  G4bool Encompasses(const G4ThreeVector& point) const;
 
  G4bool Encompasses(const BDSExtent& other) const;
 
  G4bool Encompasses(G4double x,
                     G4double y,
                     G4double z) const {return Encompasses(G4ThreeVector(x,y,z));}
 
  G4bool Encompasses(const BDSParticleCoords& coords) const;
  
  BDSExtent Tilted(G4double angle) const;
 
  BDSExtent Translate(const G4ThreeVector& offset) const {return Translate(offset.x(), offset.y(), offset.z());}
  BDSExtent Translate(G4double dx, G4double dy, G4double dz) const;
 
  BDSExtent TiltOffset(const BDSTiltOffset* tiltOffset) const;
 
  friend std::ostream& operator<< (std::ostream &out, BDSExtent const &ext);
  
  G4double MaximumAbs() const;
 
  G4double MinimumAbs() const;
 
  G4double MaximumX() const {return std::max(std::abs(extXNeg), std::abs(extXPos));}
  G4double MaximumY() const {return std::max(std::abs(extYNeg), std::abs(extYPos));}
  G4double MaximumZ() const {return std::max(std::abs(extZNeg), std::abs(extZPos));}
 
  G4double MaximumAbsTransverse() const;
 
  G4double MinimumAbsTransverse() const;
  
  G4double TransverseBoundingRadius() const;
 
  BDSExtent ExpandBy(G4double margin) const;
 
  BDSExtent ExpandTransverselyBy(G4double margin) const;
 
  void ExpandToEncompass(const BDSExtent& other);
  
private:
  G4double extXNeg;
  G4double extXPos;
  G4double extYNeg;
  G4double extYPos;
  G4double extZNeg;
  G4double extZPos;
};
 
inline G4bool BDSExtent::operator<(const BDSExtent& r) const
{
  G4bool xOK = (extXNeg > r.extXNeg) && (extXPos < r.extXPos);
  G4bool yOK = (extYNeg > r.extYNeg) && (extYPos < r.extYPos);
  G4bool zOK = (extZNeg > r.extZNeg) && (extZPos < r.extZPos);
  return xOK && yOK && zOK;
}
 
inline G4bool BDSExtent::operator==(const BDSExtent& r) const
{
  G4bool xOK = (extXNeg == r.extXNeg) && (extXPos == r.extXPos);
  G4bool yOK = (extYNeg == r.extYNeg) && (extYPos == r.extYPos);
  G4bool zOK = (extZNeg == r.extZNeg) && (extZPos == r.extZPos);
  return xOK && yOK && zOK;
}
 
inline G4bool BDSExtent::TransverselyLessThan(const BDSExtent& r) const
{
  G4bool xOK = (extXNeg > r.extXNeg) && (extXPos < r.extXPos);
  G4bool yOK = (extYNeg > r.extYNeg) && (extYPos < r.extYPos);
  return xOK && yOK;
}
 
namespace BDS
{
  BDSExtent MaximumCombinedExtent(const BDSExtent& first, const BDSExtent& second);
}
 
#endif