output based on input...

[pruns]

I'm trying to make a program that gives an output in matrix format 2 columns but the rows depends on one of the input numbers. here is a copy of my code and In essence I'm trying to make column 1 my Eprime from 1/27210 until it reaches V1prime and column to the calculations giving real(T). I hope this makes sense if not please let me know. Thanks.

#include <iostream>
#include <cmath>
#include <complex>

using namespace std;

int main()
{
complex<double>i = sqrt( complex<double>(-1) ) ;
double V1 = 0.0;
double a = 0.0;
double m = 1;
double E1 = 0.0;
double V2 = 0.0;
double b = 0.0;
double r = 0.0;
double p = 0.0;
double q = 0.0;
//double Eprime = 0.0;
double V1prime = 0.0;
double V2prime = 0.0;

double z = 0.05292;

cout << "Enter initial energy in meV's: "<< endl;
cin >> E1;

Eprime = E1 / 27210;

cout << "First barrier's potential in meV's " << endl;
cin >> V1;

V1prime = V1 / 27210;

double hbar = 1;

double k1 = sqrt(2 * m * E2 / (pow(hbar,2)));

double gamma2 = sqrt(2 * m * (V1prime - E2)/ (pow(hbar,2)));

cout << "Thickness of first barrier in nm: " << endl;
cin >> r;

a = r / (z);

double psi2 = exp(gamma2 * a);

double k3 = k1;

double w;

cout << "Enter distance of the well in nm: " << endl;
cin >> p;

w = p / (z);

cout << "Second barrier's potential in meV's " << endl;
cin >> V2;

V2prime = V2 / 27210;

double gamma4 = sqrt(2 * m * (V2prime - E2)/ (pow(hbar,2)));

cout << "Thickness of second barrier in nm: " << endl;
cin >> q;

b = q / (z);

double psi4 = exp(gamma4 * b);

double k5 = k3;

complex<double> m1[2][2] = {{ (complex<double>(0.5*(complex<double>(1) + (complex<double>((i * gamma2)/k1))))) , (complex<double>(0.5*(complex<double>(1) + (complex<double>((-i * gamma2)/k1))))) } , { (complex<double>(0.5*(complex<double>(1) + (complex<double>((i * gamma2)/k1))))) , (complex<double>(0.5*(complex<double>(1) + (complex<double>((-i * gamma2)/k1))))) }};

complex<double> m2[2][2] = {{ exp(gamma2 * a), 0} , {0 , exp(gamma2 * a)}};

complex<double> m3[2][2] = {{ (complex<double>(0.5*(complex<double>(1) + (complex<double>((-i * k3)/gamma2))))) , (complex<double>(0.5*(complex<double>(1) + (complex<double>((i * k3)/gamma2))))) } , { (complex<double>(0.5*(complex<double>(1) + (complex<double>((-i * k3)/gamma2))))) , (complex<double>(0.5*(complex<double>(1) + (complex<double>((i * k3)/gamma2))))) }};

complex<double> m4[2][2] = {{ exp(complex<double>(k3 * w * (-i))), 0}, {0, exp(complex<double>(k3 * w * i))}};

complex<double> m5[2][2] = {{ (complex<double>(0.5*(complex<double>(1) + (complex<double>((i * gamma4)/k3))))) , (complex<double>(0.5*(complex<double>(1) + (complex<double>((-i * gamma4)/k3))))) } , { (complex<double>(0.5*(complex<double>(1) + (complex<double>((i * gamma4)/k3))))) , (complex<double>(0.5*(complex<double>(1) + (complex<double>((-i * gamma4)/k3))))) }};

complex<double> m6[2][2] = {{ exp(gamma4 * b), 0} , {0 , exp(gamma4 * b)}};

complex<double> m7[2][2] = {{ (complex<double>(0.5*(complex<double>(1) + (complex<double>((-i * k5)/gamma4))))) , (complex<double>(0.5*(complex<double>(1) + (complex<double>((i * k5)/gamma4))))) } , { (complex<double>(0.5*(complex<double>(1) + (complex<double>((-i * k5)/gamma4))))) , (complex<double>(0.5*(complex<double>(1) + (complex<double>((i * k5)/gamma4))))) }};

complex<double> m8[2][2] = {{ exp(complex<double>(k5 * (w + a + b) * i)), 0} , {0, exp(complex<double>(k5 * (w + a + b) * -i))}};

int (n);
int (j);
int (k);
complex<double> sum = complex<double>(0.0);
for (n=1; n<3; n++)
for (j=1; j<3; j++)
{
//complex<double> (sum) = complex<double> (0);
sum = 0.0;
for (k=1; k<3; k++)
//complex<double> (sum) = complex<double> (sum) + complex<double> (m1[n][k]*m2[k][j]);
sum = sum + m1[n][k]*m2[k][j];
}
complex<double> C[2][2] = { sum };

for (n=1; n<3; n++)
for (j=1; j<3; j++)
{
complex<double> (sum) = 0;
for (k=1; k<3; k++)
sum = sum + C[n][k]*m3[k][j];
}
complex<double> D[2][2] = { sum };

for (n=1; n<3; n++)
for (j=1; j<3; j++)
{
sum = 0;
for (k=1; k<3; k++)
sum = sum + D[n][k]*m4[k][j];
}
complex<double> E[2][2] = { sum };

for (n=1; n<3; n++)
for (j=1; j<3; j++)
{
sum = 0;
for (k=1; k<3; k++)
sum = sum + E[n][k]*m5[k][j];
}
complex<double> F[2][2] = { sum };

for (n=1; n<3; n++)
for (j=1; j<3; j++)
{
sum = 0;
for (k=1; k<3; k++)
sum = sum + F[n][k]*m6[k][j];
}
complex<double> G[2][2] = { sum };

for (n=1; n<3; n++)
for (j=1; j<3; j++)
{
sum = 0;
for (k=1; k<3; k++)
sum = sum + G[n][k]*m7[k][j];
}
complex<double> H[2][2] = { sum };

for (n=1; n<3; n++)
for (j=1; j<3; j++)
{
sum = 0;
for (k=1; k<3; k++)
sum = sum + H[n][k]*m8[k][j];
}
complex<double> mt[2][2] = { sum };

//cout << "\nTranmission matrix position 1,1 is: " << real(mt[0][0]) << endl;

cout << mt[2][2];

complex<double> T = (k5/k1) * 1/(real(mt[0][0]) * real(mt[0][0]));

//cout << "\n\n\t\tT coefficient is (using atomic units): " << real(T) << endl;

double c = 0.0;

cout << "\n\nPlease enter a number to terminate program" << endl;
cin >> c;

return (0);
}

[attaboy]

I don't quite understand your problem....

You want the output to be a matrix with 2 columns.... and n rows (n \in 1,

You're obviously trying to discretely solve a quantum well with finite barriers... But what matrix is that?? (sorry didn't have time to go through all of your code (which is a lot btw))... What exactly does it describe....