From fe474c19ce0c7e8a8bbc450518b0442e2189d9bf Mon Sep 17 00:00:00 2001
From: Sophie Aerdker <sophie@Sophies-MBP-2.lan>
Date: Fri, 6 Oct 2023 14:32:21 +0200
Subject: [PATCH] fix intendation, whitespaces and variable names, according to
 JD comments

---
 .../crpropa/advectionField/AdvectionField.h   | 123 ++++++----
 src/advectionField/AdvectionField.cpp         | 218 ++++++++++--------
 2 files changed, 200 insertions(+), 141 deletions(-)

diff --git a/include/crpropa/advectionField/AdvectionField.h b/include/crpropa/advectionField/AdvectionField.h
index ee450a954..6002ced97 100644
--- a/include/crpropa/advectionField/AdvectionField.h
+++ b/include/crpropa/advectionField/AdvectionField.h
@@ -129,58 +129,69 @@ class SphericalAdvectionField: public AdvectionField {
 };
 
 /**
- @class 1DAdvectionShock
- @brief Advection field in x-direction with shock at x = 0 and width x_sh approximated by tanh() 
-		with variable compression ratio r_comp = v_up/v_down
+ @class OneDimensionalCartesianShock
+ @brief Advection field in x-direction with shock at x = 0 and width lShock approximated by tanh() 
+		with variable compression ratio vUp/vDown
  */
-class OneDimensionalAdvectionShock: public AdvectionField {
-	double r_comp; //compression ratio of shock
-	double v_up; //upstream velocity 
-	double x_sh; //shock width
-public:/** Constructor
-	@param r_comp //compression ratio of shock
-	@param v_up //upstream velocity 
-	@param x_sh //shock width
+class OneDimensionalCartesianShock: public AdvectionField {
+	double compressionRatio; //compression ratio of shock
+	double vUp; //upstream velocity 
+	double lShock; //shock width
+public:
+/** Constructor
+	@param compressionRatio //compression ratio of shock
+	@param vUpstream //upstream velocity 
+	@param lShock //shock width
 */
-	OneDimensionalAdvectionShock(double r_comp, double v_up, double x_sh);
+	OneDimensionalCartesianShock(double compressionRatio, double vUp, double lShock);
 	Vector3d getField(const Vector3d &position) const;
 	double getDivergence(const Vector3d &position) const;
 
-	void setComp(double r_comp);
-	void setVup(double v_up);
-	void setShockwidth(double x_sh);
+	void setComp(double compressionRatio);
+	void setVup(double vUp);
+	void setShockwidth(double lShock);
 
+	double getComp() const;
+	double getVup() const; 
+	double getShockwidth() const;
 
 	std::string getDescription() const;
 };
 
 /**
- @class 1DSphericalShock
- @brief Advection field in r-direction with shock at r_sh and width l_sh approximated by tanh() 
-		with variable compression ratio r_comp = v_up/v_down
+ @class OneDimensionalSphericalShock
+ @brief Advection field in x-direction with shock at rShock and width lShock approximated by tanh() 
+		with variable compression ratio ratio vUp/vDown
  */
 class OneDimensionalSphericalShock: public AdvectionField {
-	double r_comp; 	//compression ratio of shock
-	double v_up; 	//upstream velocity 
-	double l_sh; 	//shock width
-	double r_sh; 	//shock radius
-	bool cool_ups; 	//flag for upstream cooling
-public:/** Constructor
-	@param r_comp 	//compression ratio of shock
-	@param v_up 	//upstream velocity 
-	@param l_sh 	//shock width
-	@param r_sh 	//shock radius
-	@param cool_ups //flag for upstream cooling
+	double compressionRatio; 	//compression ratio of shock
+	double vUp; 	//upstream velocity 
+	double lShock; 	//shock width
+	double rShock; 	//shock radius
+	bool coolUpstream; 	//flag for upstream cooling
+public:
+/** Constructor
+	@param compressionRatio	//compression ratio of shock
+	@param vUp 	//upstream velocity 
+	@param lShock 	//shock width
+	@param rShock 	//shock radius
+	@param coolUpstream //flag for upstream cooling
 */
-	OneDimensionalSphericalShock(double r_sh, double v_up, double q, double l_sh, bool cool_ups);
+	OneDimensionalSphericalShock(double rShock, double vUp, double compressionRatio, double lShock, bool coolUpstream);
 	Vector3d getField(const Vector3d &position) const;
 	double getDivergence(const Vector3d &position) const;
 
-	void setComp(double q);
-	void setVup(double v_up);
-	void setShockwidth(double l_sh);
-	void setShockRadius(double r_sh);
-	void setCooling(bool cool_ups);
+	void setComp(double compressionRatio);
+	void setVup(double vUp);
+	void setShockwidth(double lShock);
+	void setShockRadius(double rShock);
+	void setCooling(bool coolUpstream);
+
+	double getComp() const; 
+	double getVup() const;
+	double getShockwidth() const;
+	double getShockRadius() const;
+	double getCooling() const;
 
 	std::string getDescription() const;
 };
@@ -192,28 +203,33 @@ class OneDimensionalSphericalShock: public AdvectionField {
 		and remains constant. 
  */
 class ObliqueAdvectionShock: public AdvectionField {
-	double r_comp; //compression ratio of shock
-	double vx_up; //upstream velocity x-component
-	double vy; //constant velocity y-component
-	double x_sh; //shock width
+	double compressionRatio; //compression ratio of shock
+	double vXUp; //upstream velocity x-component
+	double vY; //constant velocity y-component
+	double lShock; //shock width
 	
-public:/** Constructor
-	@param r_comp //compression ratio of shock
-	@param vx_up //upstream velocity x-component
-	@param vy //constant velocity y-component
-	@param x_sh //shock width
+public:
+/** Constructor
+	@param compressionRatio //compression ratio of shock
+	@param vXUp //upstream velocity x-component
+	@param vY //constant velocity y-component
+	@param lShock //shock width
 	
 */
-	ObliqueAdvectionShock(double r_comp, double vx_up, double vy, double x_sh);
+	ObliqueAdvectionShock(double compressionRatio, double vXUp, double vY, double lShock);
 	Vector3d getField(const Vector3d &position) const;
 	double getDivergence(const Vector3d &position) const;
 
-	void setComp(double r_comp);
-	void setVup(double vx_up);
-	void setVy(double vy);
-	void setShockwidth(double x_sh);
-
+	void setComp(double compressionRatio);
+	void setVup(double vXUp);
+	void setVy(double vY);
+	void setShockwidth(double lShock);
 
+	double getComp() const; 
+	double getVup() const;
+	double getVy() const;
+	double getShockwidth() const;
+	
 	std::string getDescription() const;
 };
 
@@ -240,7 +256,6 @@ class SphericalAdvectionShock: public AdvectionField {
 	@param r_0 	Position of the shock
 	@param v_0 	Constant velocity (r<<r_o)
 	@param lambda 	Transition width / width of the shock
-	@param r_rot 	Normalization radius for rotation speed
 	@param v_phi 	Rotation speed at r_rot
 */
 	SphericalAdvectionShock(const Vector3d origin, double r_0, double v_0, double lambda);
@@ -262,7 +277,13 @@ class SphericalAdvectionShock: public AdvectionField {
 	double getR0() const;
 	double getV0() const;
 	double getLambda() const;
+	/**
+	 * @param r Normalization radius for rotation speed
+	*/	
 	double getRRot() const;
+	/**
+	 * @param vPhi 	Rotation speed at r_rot
+	*/	
 	double getAzimuthalSpeed() const;
 
 	std::string getDescription() const;
diff --git a/src/advectionField/AdvectionField.cpp b/src/advectionField/AdvectionField.cpp
index 70c5b45ed..8ef321e54 100644
--- a/src/advectionField/AdvectionField.cpp
+++ b/src/advectionField/AdvectionField.cpp
@@ -179,212 +179,250 @@ std::string SphericalAdvectionField::getDescription() const {
 
 //----------------------------------------------------------------
 
-OneDimensionalAdvectionShock::OneDimensionalAdvectionShock(double r_comp, double v_up, double x_sh){
-
-	setComp(r_comp);
-	setVup(v_up);
-	setShockwidth(x_sh);
+OneDimensionalCartesianShock::OneDimensionalCartesianShock(double compressionRatio, double vUp, double lShock){
+	setComp(compressionRatio);
+	setVup(vUp);
+	setShockwidth(lShock);
 	}
 
-Vector3d OneDimensionalAdvectionShock::getField(const Vector3d &position) const {
-
+Vector3d OneDimensionalCartesianShock::getField(const Vector3d &position) const {
 	double x = position.x;
-	double v_down = v_up/r_comp;
+	double vDown = vUp / compressionRatio;
 
-	double a = (v_up + v_down)*0.5;
-	double b = (v_up - v_down)*0.5;
+	double a = (vUp + vDown) * 0.5;
+	double b = (vUp - vDown) * 0.5;
 
 	Vector3d v(0.);
-    v.x = a - b*tanh(x/x_sh);
-
+	v.x = a - b * tanh(x / lShock);
 	return v;
-	}
 
-double OneDimensionalAdvectionShock::getDivergence(const Vector3d &position) const {
+}
 
+double OneDimensionalCartesianShock::getDivergence(const Vector3d &position) const {
 	double x = position.x;
-	double v_down = v_up/r_comp;
+	double vDown = vUp / compressionRatio;
 
-	double a = (v_up + v_down)*0.5;
-	double b = (v_up - v_down)*0.5;
-
-	return -b/x_sh*(1 - tanh(x/x_sh)*tanh(x/x_sh));
-	}
+	double a = (vUp + vDown) * 0.5;
+	double b = (vUp - vDown) * 0.5;
+	return -b / lShock * (1 - tanh(x / lShock) * tanh(x / lShock));
+}
 
-void OneDimensionalAdvectionShock::setComp(double r) {
-	r_comp = r;
+void OneDimensionalCartesianShock::setComp(double r) {
+	compressionRatio = r;
 	return;
 }
 
-void OneDimensionalAdvectionShock::setVup(double v) {
-	v_up = v;
+void OneDimensionalCartesianShock::setVup(double v) {
+	vUp = v;
 	return;
 }
-void OneDimensionalAdvectionShock::setShockwidth(double w) {
-	x_sh = w;
+void OneDimensionalCartesianShock::setShockwidth(double w) {
+	lShock = w;
 	return;
 }
 
-std::string OneDimensionalAdvectionShock::getDescription() const {
-	std::stringstream s;
-	s << "Shock width: " << x_sh / km  << " km, ";
-	s << "Vup: " << v_up / km * sec << " km/s, ";
-	s << "Comp: " << r_comp;
+double OneDimensionalCartesianShock::getComp() const {
+	return compressionRatio;
+}
 
+double OneDimensionalCartesianShock::getVup() const {
+	return vUp;
+}
+
+double OneDimensionalCartesianShock::getShockwidth() const {
+	return lShock;
+}
+
+std::string OneDimensionalCartesianShock::getDescription() const {
+	std::stringstream s;
+	s << "Shock width: " << lShock / km  << " km, ";
+	s << "Vup: " << vUp / km * sec << " km/s, ";
+	s << "Compression: " << compressionRatio;
 	return s.str();
 }
 
 //----------------------------------------------------------------
 
-OneDimensionalSphericalShock::OneDimensionalSphericalShock(double r_sh, double v_up, double q, double l_sh, bool cool_ups){
-
-	setComp(q);
-	setVup(v_up);
-	setShockwidth(l_sh);
-	setShockRadius(r_sh);
-	setCooling(cool_ups);
+OneDimensionalSphericalShock::OneDimensionalSphericalShock(double rShock, double vUp, double compressionRatio, double lShock, bool coolUpstream ){
+	setComp(compressionRatio);
+	setVup(vUp);
+	setShockwidth(lShock);
+	setShockRadius(rShock);
+	setCooling(coolUpstream);
 	}
 
 Vector3d OneDimensionalSphericalShock::getField(const Vector3d &position) const {
-
 	double r = position.getR();
 	Vector3d e_r = position.getUnitVector();
 
-	double v_down = v_up/r_comp;
-	double a = (v_up + v_down)*0.5;
-	double b = (v_up - v_down)*0.5;
+	double vDown = vUp / compressionRatio;
+	double a = (vUp + vDown) * 0.5;
+	double b = (vUp - vDown) * 0.5;
 
 	double v;
-	if (cool_ups == true){
+	if (coolUpstream == true){
 	
-		if (r <= r_sh)
-    		v = a - b*tanh((r-r_sh)/l_sh);
+		if (r <= rShock)
+    		v = a - b * tanh((r-rShock) / lShock);
 		else
-			v = (a - b*tanh((r-r_sh)/l_sh)) * (r_sh/r)*(r_sh/r);
+			v = (a - b * tanh((r-rShock) / lShock)) * (rShock / r) * (rShock / r);
 
 	}
 	else
-		v = (a - b*tanh((r-r_sh)/l_sh)) * (r_sh/r)*(r_sh/r);
+		v = (a - b * tanh((r-rShock) / lShock)) * (rShock / r) * (rShock / r);
 
 	return v * e_r;
 	}
 
 double OneDimensionalSphericalShock::getDivergence(const Vector3d &position) const {
-
 	double r = position.getR();
 	
-	double v_down = v_up/r_comp;
+	double vDown = vUp / compressionRatio;
+	double a = (vUp + vDown) * 0.5;
+	double b = (vUp - vDown) * 0.5;
 
-	double a = (v_up + v_down)*0.5;
-	double b = (v_up - v_down)*0.5;
+	double c = tanh((r-rShock) / lShock);
 
-	if (cool_ups == true){
-		if (r <= r_sh)
-			return 2*a/r - 2*b/r * tanh((r-r_sh)/l_sh) - b/l_sh * (1 - tanh((r-r_sh)/l_sh)*tanh((r-r_sh)/l_sh));
+	if (coolUpstream == true){
+		if (r <= rShock)
+			return 2 * a / r - 2 * b / r * c - b / lShock * (1 - c * c);
 		else
-			return -(r_sh/r)*(r_sh/r) * b/l_sh * (1 - tanh((r-r_sh)/l_sh)*tanh((r-r_sh)/l_sh));
+			return -(rShock / r) * (rShock / r) * b / lShock * (1 - c * c);
 	}
 	else 
-		return -(r_sh/r)*(r_sh/r) * b/l_sh * (1 - tanh((r-r_sh)/l_sh)*tanh((r-r_sh)/l_sh));
+		return -(rShock / r) * (rShock / r) *  b / lShock * (1 - c * c);
 
 }
 
 void OneDimensionalSphericalShock::setComp(double r) {
-	r_comp = r;
+	compressionRatio = r;
 	return;
 }
 
 void OneDimensionalSphericalShock::setVup(double v) {
-	v_up = v;
+	vUp = v;
 	return;
 }
 void OneDimensionalSphericalShock::setShockwidth(double w) {
-	l_sh = w;
+	lShock = w;
 	return;
 }
 
 void OneDimensionalSphericalShock::setShockRadius(double r) {
-	r_sh = r;
+	rShock = r;
 	return;
 }
 
 void OneDimensionalSphericalShock::setCooling(bool c) {
-	cool_ups = c;
+	coolUpstream = c;
 	return;
 }
 
+double OneDimensionalSphericalShock::getComp() const {
+	return compressionRatio;
+}
+
+double OneDimensionalSphericalShock::getVup() const {
+	return vUp;
+}
+
+double OneDimensionalSphericalShock::getShockwidth() const {
+	return lShock;
+}
+
+double OneDimensionalSphericalShock::getShockRadius() const {
+	return rShock;
+}
+
+double OneDimensionalSphericalShock::getCooling() const {
+	return coolUpstream;
+}
+
 std::string OneDimensionalSphericalShock::getDescription() const {
 	std::stringstream s;
-	s << "Shock width: " << l_sh / km  << " km, ";
-	s << "Shock radius: " << r_sh / km  << " km, ";
-	s << "Vup: " << v_up / km * sec << " km/s, ";
-	s << "Comp: " << r_comp;
+	s << "Shock width: " << lShock / km  << " km, ";
+	s << "Shock radius: " << rShock / km  << " km, ";
+	s << "Vup: " << vUp / km * sec << " km/s, ";
+	s << "Comp: " << compressionRatio;
 
 	return s.str();
 }
 
 //----------------------------------------------------------------
 
-ObliqueAdvectionShock::ObliqueAdvectionShock(double r_comp, double vx_up, double vy, double x_sh){
-
-	setComp(r_comp);
-	setVup(vx_up);
-	setVy(vy);
-	setShockwidth(x_sh);
+ObliqueAdvectionShock::ObliqueAdvectionShock(double compressionRatio, double vXUp, double vY, double lShock) {
+	setComp(compressionRatio);
+	setVup(vXUp);
+	setVy(vY);
+	setShockwidth(lShock);
 	}
 
 Vector3d ObliqueAdvectionShock::getField(const Vector3d &position) const {
-
 	double x = position.x;
-	double vx_down = vx_up/r_comp;
+	double vXDown = vXUp / compressionRatio;
 
-	double a = (vx_up + vx_down)*0.5;
-	double b = (vx_up - vx_down)*0.5;
+	double a = (vXUp + vXDown) * 0.5;
+	double b = (vXUp - vXDown) * 0.5;
 
 	Vector3d v(0.);
-    v.x = a - b*tanh(x/x_sh);
-	v.y = vy;
+	v.x = a - b * tanh(x / lShock);
+	v.y = vY;
 
 	return v;
 	}
 
 double ObliqueAdvectionShock::getDivergence(const Vector3d &position) const {
-
 	double x = position.x;
-	double vx_down = vx_up/r_comp;
+	double vXDown = vXUp / compressionRatio;
 	// vy = const
 
-	double a = (vx_up + vx_down)*0.5;
-	double b = (vx_up - vx_down)*0.5;
+	double a = (vXUp + vXDown) * 0.5;
+	double b = (vXUp - vXDown) * 0.5;
 
-	return -b/x_sh*(1 - tanh(x/x_sh)*tanh(x/x_sh));
+	return -b / lShock * (1 - tanh(x / lShock) * tanh(x / lShock));
 	}
 
 void ObliqueAdvectionShock::setComp(double r) {
-	r_comp = r;
+	compressionRatio = r;
 	return;
 }
 
 void ObliqueAdvectionShock::setVup(double v) {
-	vx_up = v;
+	vXUp = v;
 	return;
 } 
 
 void ObliqueAdvectionShock::setVy(double v) {
-	vy = v;
+	vY = v;
 	return;
 } 
 void ObliqueAdvectionShock::setShockwidth(double w) {
-	x_sh = w;
+	lShock = w;
 	return;
 }
 
+double ObliqueAdvectionShock::getComp() const {
+	return compressionRatio;
+}
+
+double ObliqueAdvectionShock::getVup() const {
+	return vXUp;
+}
+
+double ObliqueAdvectionShock::getVy() const {
+	return vY;
+}
+
+double ObliqueAdvectionShock::getShockwidth() const {
+	return lShock;
+}
+
 std::string ObliqueAdvectionShock::getDescription() const {
 	std::stringstream s;
-	s << "Shock width: " << x_sh / km  << " km, ";
-	s << "Vx_up: " << vx_up / km * sec << " km/s, ";
-	s << "Vy: " << vy / km * sec << " km/s, ";
-	s << "Comp: " << r_comp;
+	s << "Shock width: " << lShock / km  << " km, ";
+	s << "Vx_up: " << vXUp / km * sec << " km/s, ";
+	s << "Vy: " << vY / km * sec << " km/s, ";
+	s << "Comp: " << compressionRatio;
 	
 	return s.str();
 }