source: JEM-EUSO/esaf_lal/tags/v1_r0/esaf/packages/simulation/detector/G4Detector/G4fresnellens/include/FresnelSurface.h @ 117

#ifndef FresnelSurface_HH
#define FresnelSurface_HH
#include "SSurface.h"
#include "FresnelOutput_defs.h"
#include "FixedStack.h"
#include "ParametricSurface.h"
#include "CylindricSurface.h"

#include <string.h>
#include <vector>
//#define DEBUG

namespace G4FresnelLens{
class FresnelSurface : public SSurface {
private:
    double fFilter;

public:
    FresnelSurface(const std::vector<SSurface*>& surf, ParametricSurface*, ParametricSurface*);
    virtual ~FresnelSurface();

    void setSmoothedEdges(double rad);
    double PointOnSurf(double x) { AbstractMethod(); return kInfinity; }
    double DistanceToSurf(const G4ThreeVector& p, const G4ThreeVector& v){ AbstractMethod(); return kInfinity; }
    double DistanceToSurf(const G4ThreeVector& p, const G4ThreeVector& v, FSIntersectedSegment*){ AbstractMethod(); return kInfinity; }
    double DistanceToSurfSafe(const G4ThreeVector& p){ AbstractMethod(); return kInfinity; }
    double DistanceToSurfSafeUp(const G4ThreeVector& p) { return fUpLimit->DistanceToSurfSafe(p); }
    double DistanceToSurfSafeDown(const G4ThreeVector& p) { return fDownLimit->DistanceToSurfSafe(p); }
    double TestEdgeTolerance(int dir, const G4ThreeVector& p, const G4ThreeVector& v) { AbstractMethod(); return kInfinity; }
    bool Point(int i, double step, double& rho, double& z) { AbstractMethod(); return false; }

    #ifdef USE_ROOT
    void draw(const char* rootfile=0, const char* canvasfile=0, double shift=0., const char* prefix="", const char* option="RECREATE");
    #endif

    double GetZ(double rho);
    double GetUpperZ(double rho);
    double GetBottomZ(double rho);
    double GetEdgeZ() { return fSurfaces.back()->GetZ1(); }
    double GetMinZ() { return fDownLimit->GetMinZ(); }
    double GetMaxZ() { return fUpLimit->GetMaxZ(); }

    EInside Inside(double rho, double z, FSIntersectedSegment *intS=0);
    double FindNearestIntersection(const G4ThreeVector& p1, const G4ThreeVector& v, FSIntersectedSegment* intS=0);

    double* CopyTeeth(int& n);
    int     GetNTeeth()     { return theToothN-1; }
    std::vector<SSurface*>& GetTeeth() { return fSurfaces; }
protected:
    #ifdef USE_ROOT
    void FillArray(const char*);
    #endif
    void FillArray(int n, double* rho, double* z);
    void FillArray(const std::vector<SSurface*>& surf);

    /// Surfaces
    ParametricSurface* fUpLimit;
    ParametricSurface* fDownLimit;
    CylindricSurface   fCylinder;
    std::vector<SSurface*>  fSurfaces;
    std::vector<SSurface*>  fSurfacesIns;

    /// tooth indexes
    int     theToothN;
    double* theToothEdges;

    /// points storage
    double  fZscale;

    /// function parameters and chi-square
    double  theMaximalDeviation;

    double fDownSafety;
    double fUpSafety;
    bool   doBelieveToFit;

    double               theLastPerp, theLastZ;    // last position, for "inside" definition
    EInside              theLastInside;            // last inside definition
    FSIntersectedSegment theLastIntSeg;
};

//__________________________________________________________________________________
inline double FresnelSurface::GetUpperZ(double rho){
    return fUpLimit->PointOnSurf(rho);
}

//__________________________________________________________________________________
inline double FresnelSurface::GetBottomZ(double rho){
    return fDownLimit->PointOnSurf(rho);
}

};
#endif