Matrix4 Matrix4::multiply(Matrix4 a)
{
Matrix4 b;
/*
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
b.m[i][j] = m[0][j] * a.m[i][0] + m[1][j] * a.m[i][1] + m[2][j] * a.m[i][2] + m[3][j] * a.m[i][3];
}
}*/
Vector4 row1(m[0][0], m[1][0], m[2][0], m[3][0]);
Vector4 row2(m[0][1], m[1][1], m[2][1], m[3][1]);
Vector4 row3(m[0][2], m[1][2], m[2][2], m[3][2]);
Vector4 row4(m[0][3], m[1][3], m[2][3], m[3][3]);
Vector4 col1(a.m[0][0], a.m[0][1], a.m[0][2], a.m[0][3]);
Vector4 col2(a.m[1][0], a.m[1][1], a.m[1][2], a.m[1][3]);
Vector4 col3(a.m[2][0], a.m[2][1], a.m[2][2], a.m[2][3]);
Vector4 col4(a.m[3][0], a.m[3][1], a.m[3][2], a.m[3][3]);
b.set(row1.dot(col1), row2.dot(col1), row3.dot(col1), row4.dot(col1),
row1.dot(col2), row2.dot(col2), row3.dot(col2), row4.dot(col2),
row1.dot(col3), row2.dot(col3), row3.dot(col3), row4.dot(col3),
row1.dot(col4), row2.dot(col4), row3.dot(col4), row4.dot(col4));
return b;
}
void TestDim::index() {
Dim sca;
Dim row2(Dim::row_vec(2));
Dim row3(Dim::row_vec(3));
Dim col2(Dim::col_vec(2));
Dim col3(Dim::col_vec(3));
Dim mat22(Dim::matrix(2,2));
Dim mat32(Dim::matrix(3,2));
Dim mat23(Dim::matrix(2,3));
Dim mat33(Dim::matrix(3,3));
CPPUNIT_ASSERT (sca.index_dim(DoubleIndex::one_elt(sca,0,0))==sca);
CPPUNIT_ASSERT (row3.index_dim(DoubleIndex::one_elt(row3,0,0))==sca);
CPPUNIT_ASSERT (row3.index_dim(DoubleIndex::one_row(row3,0))==row3);
CPPUNIT_ASSERT (row3.index_dim(DoubleIndex::cols(row3,0,1))==row2);
CPPUNIT_ASSERT (col3.index_dim(DoubleIndex::one_elt(col3,0,0))==sca);
CPPUNIT_ASSERT (col3.index_dim(DoubleIndex::one_col(col3,0))==col3);
CPPUNIT_ASSERT (col3.index_dim(DoubleIndex::rows(col3,0,1))==col2);
CPPUNIT_ASSERT (mat23.index_dim(DoubleIndex::one_elt(mat23,0,0))==sca);
CPPUNIT_ASSERT (mat23.index_dim(DoubleIndex::one_row(mat23,0))==row3);
CPPUNIT_ASSERT (mat23.index_dim(DoubleIndex::one_col(mat23,0))==col2);
CPPUNIT_ASSERT (mat23.index_dim(DoubleIndex::cols(mat23,0,1))==mat22);
CPPUNIT_ASSERT (mat23.index_dim(DoubleIndex::subrow(mat23,0,0,1))==row2);
CPPUNIT_ASSERT (mat23.index_dim(DoubleIndex::all(mat23))==mat23);
CPPUNIT_ASSERT (mat32.index_dim(DoubleIndex::subcol(mat32,0,1,0))==col2);
CPPUNIT_ASSERT (mat33.index_dim(DoubleIndex::rows(mat33,0,1))==mat23);
CPPUNIT_ASSERT (mat33.index_dim(DoubleIndex::cols(mat33,0,1))==mat32);
}
void BcMat4d::scale( const BcVec4d& Scale )
{
row0( BcVec4d( Scale.x(), 0.0f, 0.0f, 0.0f ) );
row1( BcVec4d( 0.0f, Scale.y(), 0.0f, 0.0f ) );
row2( BcVec4d( 0.0f, 0.0f, Scale.z(), 0.0f ) );
row3( BcVec4d( 0.0f, 0.0f, 0.0f, Scale.w() ) );
}
void CoronaRenderer::setAnimatedTransformationMatrix(Corona::AnimatedAffineTm& atm, mtco_MayaObject *obj)
{
MMatrix to, from;
// a segment contains start and end, 2 mb steps are one segment, 3 mb steps are 2 segments
int numSegments = (obj->transformMatrices.size() - 1) * ((int)this->mtco_renderGlobals->doMb) ;
atm.setSegments(numSegments);
for( size_t mId = 0; mId < (numSegments + 1); mId++)
{
MMatrix c = this->mtco_renderGlobals->globalConversionMatrix;
//logger.debug(MString("globalConv:"));
//logger.debug(MString("") + c[0][0] + " " + c[0][1] + " " + c[0][2] + " " + c[0][3]);
//logger.debug(MString("") + c[1][0] + " " + c[1][1] + " " + c[1][2] + " " + c[1][3]);
//logger.debug(MString("") + c[2][0] + " " + c[2][1] + " " + c[2][2] + " " + c[2][3]);
//logger.debug(MString("") + c[3][0] + " " + c[3][1] + " " + c[3][2] + " " + c[3][3]);
MMatrix t = (obj->transformMatrices[mId] * c).transpose();
Corona::AffineTm tm;
Corona::Float4 row1(t[0][0],t[0][1],t[0][2],t[0][3]);
Corona::Float4 row2(t[1][0],t[1][1],t[1][2],t[1][3]);
Corona::Float4 row3(t[2][0],t[2][1],t[2][2],t[2][3]);
tm = Corona::AffineTm(row1, row2, row3);
atm[mId] = Corona::AffineTm::IDENTITY;
atm[mId] = tm;
}
}
bool ROSToKlampt(const tf::Transform& T,RigidTransform& kT)
{
kT.t.set(T.getOrigin().x(),T.getOrigin().y(),T.getOrigin().z());
Vector3 row1(T.getBasis()[0].x(),T.getBasis()[0].y(),T.getBasis()[0].z());
Vector3 row2(T.getBasis()[1].x(),T.getBasis()[1].y(),T.getBasis()[1].z());
Vector3 row3(T.getBasis()[2].x(),T.getBasis()[2].y(),T.getBasis()[2].z());
kT.R.setRow1(row1);
kT.R.setRow2(row2);
kT.R.setRow3(row3);
return true;
}
// Return a matrix to represent a nonuniform scale with the given factors.
Matrix4x4 scaling(const Vector3D& scale)
{
Vector4D row1(scale[0], 0, 0, 0);
Vector4D row2(0, scale[1], 0, 0);
Vector4D row3(0, 0, scale[2], 0);
Vector4D row4(0, 0, 0, 1);
Matrix4x4 s(row1, row2, row3, row4);
return s;
}
void model1_state::view_t::transform_vector(glm::vec3& p) const
{
glm::vec3 q(p);
glm::vec3 row1(translation[0], translation[3], translation[6]);
glm::vec3 row2(translation[1], translation[4], translation[7]);
glm::vec3 row3(translation[2], translation[5], translation[8]);
p = glm::vec3(glm::dot(q, row1), glm::dot(q, row2), glm::dot(q, row3));
//p->set_x(translation[0] * q.x() + translation[3] * q.y() + translation[6] * q.z());
//p->set_y(translation[1] * q.x() + translation[4] * q.y() + translation[7] * q.z());
//p->set_z(translation[2] * q.x() + translation[5] * q.y() + translation[8] * q.z());
}
// Print a matrix44 to a file
void matrix44::fprint(FILE* file, char* str) const
{
fprintf(file, "%smatrix44:\n", str);
vector4 row0(col[0][0], col[1][0], col[2][0], col[3][0]);
row0.fprint(file, "\t");
vector4 row1(col[0][1], col[1][1], col[2][1], col[3][1]);
row1.fprint(file, "\t");
vector4 row2(col[0][2], col[1][2], col[2][2], col[3][2]);
row2.fprint(file, "\t");
vector4 row3(col[0][3], col[1][3], col[2][3], col[3][3]);
row3.fprint(file, "\t");
}
// Return a matrix to represent a displacement of the given vector.
Matrix4x4 translation(const Vector3D& displacement)
{
Vector4D row1(1, 0, 0, displacement[0]);
Vector4D row2(0, 1, 0, displacement[1]);
Vector4D row3(0, 0, 1, displacement[2]);
Vector4D row4(0, 0, 0, 1);
Matrix4x4 t(row1, row2, row3, row4);
return t;
}
std::vector<QVector> ViewingParams::updateVewingTranformationMatrix(){
QVector row1(eyeCoord[0].getX(),eyeCoord[1].getX(),eyeCoord[2].getX(),eye.getX());
QVector row2(eyeCoord[0].getY(),eyeCoord[1].getY(),eyeCoord[2].getY(),eye.getY());
QVector row3(eyeCoord[0].getZ(),eyeCoord[1].getZ(),eyeCoord[2].getZ(),eye.getZ());
QVector row4(0,0,0,1);
transMatrix.clear();
transMatrix.push_back(row1);
transMatrix.push_back(row2);
transMatrix.push_back(row3);
transMatrix.push_back(row4);
return transMatrix;
}
void
StressDivergenceTruss::computeStiffness(ColumnMajorMatrix & stiff_global)
{
RealGradient orientation( (*_orientation)[0] );
orientation /= orientation.size();
// Now get a rotation matrix
// The orientation is the first row of the matrix.
// Need two other directions.
VectorValue<Real> & row1( orientation );
VectorValue<Real> row3( row1 );
unsigned zero_index(0);
if (row3(1) != 0)
{
zero_index = 1;
}
if (row3(2) != 0)
{
zero_index = 2;
}
row3(zero_index) += 1;
VectorValue<Real> row2 = orientation.cross( row3 );
row3 = orientation.cross( row2 );
Real k = _E_over_L[0] * _area[0];
stiff_global(0,0) = row1(0)*row1(0)*k;
stiff_global(0,1) = row1(0)*row2(0)*k;
stiff_global(0,2) = row1(0)*row3(0)*k;
stiff_global(1,0) = row2(0)*row1(0)*k;
stiff_global(1,1) = row2(0)*row2(0)*k;
stiff_global(1,2) = row2(0)*row3(0)*k;
stiff_global(2,0) = row3(0)*row1(0)*k;
stiff_global(2,1) = row3(0)*row2(0)*k;
stiff_global(2,2) = row3(0)*row3(0)*k;
}
FMatrix OSVRHMDDescription::GetProjectionMatrix(float left, float right, float bottom, float top, float nearClip, float farClip) const
{
// original code
//float sumRightLeft = static_cast<float>(right + left);
//float sumTopBottom = static_cast<float>(top + bottom);
//float inverseRightLeft = 1.0f / static_cast<float>(right - left);
//float inverseTopBottom = 1.0f / static_cast<float>(top - bottom);
//FPlane row1(2.0f * inverseRightLeft, 0.0f, 0.0f, 0.0f);
//FPlane row2(0.0f, 2.0f * inverseTopBottom, 0.0f, 0.0f);
//FPlane row3((sumRightLeft * inverseRightLeft), (sumTopBottom * inverseTopBottom), 0.0f, 1.0f);
//FPlane row4(0.0f, 0.0f, zNear, 0.0f);
// OSVR Render Manager OSVR_Projection_to_D3D with adjustment for unreal (from steamVR plugin)
OSVR_ProjectionMatrix projection;
projection.left = static_cast<double>(left);
projection.right = static_cast<double>(right);
projection.top = static_cast<double>(top);
projection.bottom = static_cast<double>(bottom);
projection.nearClip = static_cast<double>(nearClip);
// @todo Since farClip may be FLT_MAX, round-trip casting to double
// and back (via the OSVR_Projection_to_Unreal call) it should
// be checked for conversion issues.
projection.farClip = static_cast<double>(farClip);
float p[16];
OSVR_Projection_to_Unreal(p, projection);
FPlane row1(p[0], p[1], p[2], p[3]);
FPlane row2(p[4], p[5], p[6], p[7]);
FPlane row3(p[8], p[9], p[10], p[11]);
FPlane row4(p[12], p[13], p[14], p[15]);
FMatrix ret = FMatrix(row1, row2, row3, row4);
//ret.M[3][3] = 0.0f;
//ret.M[2][3] = 1.0f;
//ret.M[2][2] = 0.0f;
//ret.M[3][2] = nearClip;
// This was suggested by Nick at Epic, but doesn't seem to work? Black screen.
//ret.M[2][2] = nearClip / (nearClip - farClip);
//ret.M[3][2] = -nearClip * nearClip / (nearClip - farClip);
// Adjustment suggested on a forum post for an off-axis projection. Doesn't work.
//ret *= 1.0f / ret.M[0][0];
//ret.M[3][2] = GNearClippingPlane;
return ret;
}
TEST(ArgParserTests, getArgv_stringArray_return2DArray)
{
std::vector<String> argArray;
argArray.push_back("stub1");
argArray.push_back("stub2");
argArray.push_back("stub3 space");
const char** argv = ArgParser::getArgv(argArray);
String row1(argv[0]);
String row2(argv[1]);
String row3(argv[2]);
EXPECT_EQ("stub1", row1);
EXPECT_EQ("stub2", row2);
EXPECT_EQ("stub3 space", row3);
delete[] argv;
}
Json::Value SkJSONCanvas::MakeMatrix(const SkMatrix& matrix) {
Json::Value result(Json::arrayValue);
Json::Value row1(Json::arrayValue);
row1.append(Json::Value(matrix[0]));
row1.append(Json::Value(matrix[1]));
row1.append(Json::Value(matrix[2]));
result.append(row1);
Json::Value row2(Json::arrayValue);
row2.append(Json::Value(matrix[3]));
row2.append(Json::Value(matrix[4]));
row2.append(Json::Value(matrix[5]));
result.append(row2);
Json::Value row3(Json::arrayValue);
row3.append(Json::Value(matrix[6]));
row3.append(Json::Value(matrix[7]));
row3.append(Json::Value(matrix[8]));
result.append(row3);
return result;
}
int CalcSphereCenter (const Point<3> ** pts, Point<3> & c)
{
Vec3d row1 (*pts[0], *pts[1]);
Vec3d row2 (*pts[0], *pts[2]);
Vec3d row3 (*pts[0], *pts[3]);
Vec3d rhs(0.5 * (row1*row1),
0.5 * (row2*row2),
0.5 * (row3*row3));
Transpose (row1, row2, row3);
Vec3d sol;
if (SolveLinearSystem (row1, row2, row3, rhs, sol))
{
(*testout) << "CalcSphereCenter: degenerated" << endl;
return 1;
}
c = *pts[0] + sol;
return 0;
}
void TestDim::vec() {
Dim sca;
Dim row2(Dim::row_vec(2));
Dim row3(Dim::row_vec(3));
Dim col2(Dim::col_vec(2));
Dim col3(Dim::col_vec(3));
Dim mat22(Dim::matrix(2,2));
Dim mat32(Dim::matrix(3,2));
Dim mat23(Dim::matrix(2,3));
Dim mat33(Dim::matrix(3,3));
CPPUNIT_ASSERT (vec_dim(Array<const Dim>(sca),true)==sca);
CPPUNIT_ASSERT (vec_dim(Array<const Dim>(sca),false)==sca);
CPPUNIT_ASSERT (vec_dim(Array<const Dim>(sca,sca),true)==row2);
CPPUNIT_ASSERT (vec_dim(Array<const Dim>(sca,sca),false)==col2);
CPPUNIT_ASSERT (vec_dim(Array<const Dim>(sca,sca,sca),true)==row3);
CPPUNIT_ASSERT (vec_dim(Array<const Dim>(sca,sca,sca),false)==col3);
CPPUNIT_ASSERT_THROW(vec_dim(Array<const Dim>(sca,col2),true),DimException);
CPPUNIT_ASSERT (vec_dim(Array<const Dim>(sca,col2),false)==col3);
CPPUNIT_ASSERT (vec_dim(Array<const Dim>(sca,row2),true)==row3);
CPPUNIT_ASSERT_THROW(vec_dim(Array<const Dim>(sca,row2),false),DimException);
CPPUNIT_ASSERT_THROW(vec_dim(Array<const Dim>(sca,mat22),true),DimException);
CPPUNIT_ASSERT_THROW(vec_dim(Array<const Dim>(sca,mat22),false),DimException);
CPPUNIT_ASSERT (vec_dim(Array<const Dim>(col2),true)==col2);
CPPUNIT_ASSERT (vec_dim(Array<const Dim>(col2),false)==col2);
CPPUNIT_ASSERT (vec_dim(Array<const Dim>(col2,col2),true)==mat22);
CPPUNIT_ASSERT (vec_dim(Array<const Dim>(col2,col2),false)==Dim::col_vec(4));
CPPUNIT_ASSERT (vec_dim(Array<const Dim>(col2,col2,col2),true)==mat23);
CPPUNIT_ASSERT (vec_dim(Array<const Dim>(col2,col2,col2),false)==Dim::col_vec(6));
CPPUNIT_ASSERT_THROW(vec_dim(Array<const Dim>(col2,row2),true),DimException);
CPPUNIT_ASSERT_THROW(vec_dim(Array<const Dim>(col2,row2),false),DimException);
CPPUNIT_ASSERT (vec_dim(Array<const Dim>(col2,mat22),true)==mat23);
CPPUNIT_ASSERT_THROW(vec_dim(Array<const Dim>(col2,mat22),false),DimException);
CPPUNIT_ASSERT (vec_dim(Array<const Dim>(col2,mat22,col2),true)==Dim::matrix(2,4));
}
void plot_pad_size_in_layer(TString digiPar="trd.v13/trd_v13g.digi.par", Int_t nlines=1, Int_t nrows_in_sec=0, Int_t alllayers=1)
{
gStyle->SetPalette(1,0);
gROOT->SetStyle("Plain");
gStyle->SetPadTickX(1);
gStyle->SetPadTickY(1);
gStyle->SetOptStat(kFALSE);
gStyle->SetOptTitle(kFALSE);
Bool_t read = false;
TH2I *fLayerDummy = new TH2I("LayerDummy","",1200,-600,600,1000,-500,500);
fLayerDummy->SetXTitle("x-coordinate [cm]");
fLayerDummy->SetYTitle("y-coordinate [cm]");
fLayerDummy->GetXaxis()->SetLabelSize(0.02);
fLayerDummy->GetYaxis()->SetLabelSize(0.02);
fLayerDummy->GetZaxis()->SetLabelSize(0.02);
fLayerDummy->GetXaxis()->SetTitleSize(0.02);
fLayerDummy->GetXaxis()->SetTitleOffset(1.5);
fLayerDummy->GetYaxis()->SetTitleSize(0.02);
fLayerDummy->GetYaxis()->SetTitleOffset(2);
fLayerDummy->GetZaxis()->SetTitleSize(0.02);
fLayerDummy->GetZaxis()->SetTitleOffset(-2);
TString title;
TString title1, title2, title3;
TString buffer;
TString firstModule = "";
Int_t blockCounter(0), startCounter(0); // , stopCounter(0);
Double_t msX(0), msY(0), mpX(0), mpY(0), mpZ(0), psX(0), psY(0);
Double_t ps1X(0), ps1Y(0), ps2X(0), ps2Y(0), ps3X(0), ps3Y(0);
Int_t modId(0), layerId(0);
Double_t sec1(0), sec2(0), sec3(0);
Double_t row1(0), row2(0), row3(0);
std::map<float, TCanvas*> layerView;// map key is z-position of modules
std::map<float, TCanvas*>::iterator it;
ifstream digipar;
digipar.open(digiPar.Data(), ifstream::in);
while (digipar.good()) {
digipar >> buffer;
//cout << "(" << blockCounter << ") " << buffer << endl;
if (blockCounter == 19)
firstModule = buffer;
if (buffer == (firstModule + ":")){
//cout << buffer << " <===========================================" << endl;
read = true;
}
if (read) {
startCounter++;
if (startCounter == 1) // position of module position in x
{
modId = buffer.Atoi();
layerId = (modId & (15 << 4)) >> 4; // from CbmTrdAddress.h
}
if (startCounter == 5) // position of module position in x
mpX = buffer.Atof();
if (startCounter == 6) // position of module position in y
mpY = buffer.Atof();
if (startCounter == 7) // position of module position in z
mpZ = buffer.Atof();
if (startCounter == 8) // position of module size in x
msX = buffer.Atof();
if (startCounter == 9) // position of module size in y
msY = buffer.Atof();
if (startCounter == 12) // sector 1 size in y
sec1 = buffer.Atof();
if (startCounter == 13) // position of pad size in x - do not take the backslash (@14)
ps1X = buffer.Atof();
if (startCounter == 15) // position of pad size in y
ps1Y = buffer.Atof();
if (startCounter == 17) // sector 2 size in y
sec2 = buffer.Atof();
if (startCounter == 18) // position of pad size in x
{
ps2X = buffer.Atof();
psX = ps2X; // for backwards compatibility - sector 2 is default sector
}
if (startCounter == 19) // position of pad size in y
{
ps2Y = buffer.Atof();
psY = ps2Y; // for backwards compatibility - sector 2 is default sector
}
if (startCounter == 21) // sector 3 size in y
sec3 = buffer.Atof();
if (startCounter == 22) // position of pad size in x
ps3X = buffer.Atof();
if (startCounter == 23) // position of pad size in y
ps3Y = buffer.Atof();
// if (startCounter == 23) // last element
// {
// printf("moduleId : %d, %d\n", modId, layerId);
// printf("pad size sector 1: (%.2f cm, %.2f cm) pad area: %.2f cm2\n", ps1X, ps1Y, ps1X*ps1Y);
// printf("pad size sector 2: (%.2f cm, %.2f cm) pad area: %.2f cm2\n", ps2X, ps2Y, ps2X*ps2Y);
// printf("pad size sector 3: (%.2f cm, %.2f cm) pad area: %.2f cm2\n", ps3X, ps3Y, ps3X*ps3Y);
// printf("rows per sector : %.1f %.1f %.1f\n", sec1/ps1Y, sec2/ps2Y, sec3/ps3Y);
// printf("\n");
// }
//printf("module position: (%.1f, %.1f, %.1f) module size: (%.1f, %.1f) pad size: (%.2f, %.2f) pad area: %.2f\n",mpX,mpY,mpZ,2*msX,2*msY,psX,psY,psX*psY);
if (startCounter == 23) { // if last element is reached
startCounter = 0; // reset
if ( alllayers == 0 )
if ( !((layerId == 0) || (layerId == 4) || (layerId == 8)) ) // plot only 1 layer per station
continue;
row1 = sec1 / ps1Y;
row2 = sec2 / ps2Y;
row3 = sec3 / ps3Y;
it = layerView.find(mpZ);
if (it == layerView.end()){
// title.Form("pad_size_layer_at_z_%.2fm",mpZ);
title.Form("%02d_pad_size_layer%02d", layerId, layerId);
layerView[mpZ] = new TCanvas(title,title,1200,1000);
fLayerDummy->DrawCopy("");
// now print cm2 in the center
layerView[mpZ]->cd();
title.Form("cm^{2}"); // print cm2
TPaveText *text = new TPaveText(0 - 28.5,
0 - 28.5,
0 + 28.5,
0 + 28.5
);
text->SetFillStyle(1001);
text->SetLineColor(1);
text->SetFillColor(kWhite);
text->AddText(title);
text->Draw("same");
}
// print pad size in each module
layerView[mpZ]->cd();
// title.Form("%2.0fcm^{2}",psX*psY); // print pad size
// title.Form("%.0f",psX*psY); // print pad size - 1 digit
TPaveText *text = new TPaveText(mpX - msX,
mpY - msY,
mpX + msX,
mpY + msY
);
text->SetFillStyle(1001);
text->SetLineColor(1);
// text->SetFillColor(kViolet);
// vary background color
// if ((int)(psX*psY+.5) == 2)
// {
// text->SetFillColor(kOrange + 9);
// }
// else
if (psX*psY <= 1.1)
{
text->SetFillColor(kOrange + 10);
}
else if (psX*psY <= 2.1)
{
text->SetFillColor(kOrange - 3);
}
else if (psX*psY <= 3.1)
{
text->SetFillColor(kOrange - 4);
}
else if (psX*psY <= 5)
{
text->SetFillColor(kOrange + 10 - ((int)(psX*psY+.5)-1) * 2);
// printf("%2.1f: %d\n", psX*psY, 10 - ((int)(psX*psY+.5)-1) * 2);
}
else if (psX*psY <= 10)
{
text->SetFillColor(kSpring + 10 - ((int)(psX*psY+.5)-4) * 2);
// printf("%2.1f: %d\n", psX*psY, 10 - ((int)(psX*psY+.5)-4) * 2);
}
else if (psX*psY > 10)
{
text->SetFillColor(kGreen);
// printf("%2.1f: %s\n", psX*psY, "green");
}
if (nrows_in_sec == 1) // print number of rows in sector
{
title1.Form("%3.1f - %2.0f", ps1X*ps1Y, row1); // print pad size and nrows - 2 digits - sector 1
title2.Form("%3.1f - %2.0f", ps2X*ps2Y, row2); // print pad size and nrows - 2 digits - sector 2
title3.Form("%3.1f - %2.0f", ps3X*ps3Y, row3); // print pad size and nrows - 2 digits - sector 3
}
else
{
title1.Form("%3.1f",ps1X*ps1Y); // print pad size - 2 digits - sector 1
title2.Form("%3.1f",ps2X*ps2Y); // print pad size - 2 digits - sector 2
title3.Form("%3.1f",ps3X*ps3Y); // print pad size - 2 digits - sector 3
}
if (nlines==1) // plot pad size for central sector only
{
text->AddText(title2);
}
else // plot pad size for all 3 sectors
{
text->AddText(title1);
text->AddText(title2);
text->AddText(title3);
}
text->Draw("same");
//layerView[mpZ]->Update();
}
}
blockCounter++;
}
void BcMat4d::translation( const BcVec4d& Translation )
{
row3( Translation );
}
void TestDim::mul() {
Dim sca;
Dim row2(Dim::row_vec(2));
Dim row3(Dim::row_vec(3));
Dim col2(Dim::col_vec(2));
Dim col3(Dim::col_vec(3));
Dim mat22(Dim::matrix(2,2));
Dim mat32(Dim::matrix(3,2));
Dim mat23(Dim::matrix(2,3));
Dim mat33(Dim::matrix(3,3));
CPPUNIT_ASSERT (mul_dim(sca,sca)==sca);
CPPUNIT_ASSERT (mul_dim(sca,row2)==row2);
CPPUNIT_ASSERT (mul_dim(sca,row3)==row3);
CPPUNIT_ASSERT (mul_dim(sca,col2)==col2);
CPPUNIT_ASSERT (mul_dim(sca,col3)==col3);
CPPUNIT_ASSERT (mul_dim(sca,mat22)==mat22);
CPPUNIT_ASSERT (mul_dim(sca,mat23)==mat23);
CPPUNIT_ASSERT (mul_dim(sca,mat32)==mat32);
CPPUNIT_ASSERT (mul_dim(sca,mat33)==mat33);
CPPUNIT_ASSERT_THROW(mul_dim(row2,sca),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(row2,row2),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(row2,row3),DimException);
CPPUNIT_ASSERT (mul_dim(row2,col2)==sca);
CPPUNIT_ASSERT_THROW(mul_dim(row2,col3),DimException);
CPPUNIT_ASSERT (mul_dim(row2,mat22)==row2);
CPPUNIT_ASSERT_THROW(mul_dim(row2,mat32),DimException);
CPPUNIT_ASSERT (mul_dim(row2,mat23)==row3);
CPPUNIT_ASSERT_THROW(mul_dim(row2,mat33),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(row3,sca),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(row3,row2),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(row3,row3),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(row3,col2),DimException);
CPPUNIT_ASSERT (mul_dim(row3,col3)==sca);
CPPUNIT_ASSERT_THROW(mul_dim(row3,mat22),DimException);
CPPUNIT_ASSERT (mul_dim(row3,mat32)==row2);
CPPUNIT_ASSERT_THROW(mul_dim(row3,mat23),DimException);
CPPUNIT_ASSERT (mul_dim(row3,mat33)==row3);
CPPUNIT_ASSERT (mul_dim(col2,sca)==col2);
CPPUNIT_ASSERT (mul_dim(col2,row2)==mat22);
CPPUNIT_ASSERT (mul_dim(col2,row3)==mat23);
CPPUNIT_ASSERT_THROW(mul_dim(col2,col2),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(col2,col3),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(col2,mat22),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(col2,mat32),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(col2,mat23),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(col2,mat33),DimException);
CPPUNIT_ASSERT (mul_dim(col3,sca)==col3);
CPPUNIT_ASSERT (mul_dim(col3,row2)==mat32);
CPPUNIT_ASSERT (mul_dim(col3,row3)==mat33);
CPPUNIT_ASSERT_THROW(mul_dim(col3,col2),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(col3,col3),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(col3,mat22),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(col3,mat32),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(col3,mat23),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(col3,mat33),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(mat22,sca),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(mat22,row2),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(mat22,row3),DimException);
CPPUNIT_ASSERT (mul_dim(mat22,col2)==col2);
CPPUNIT_ASSERT_THROW(mul_dim(mat22,col3),DimException);
CPPUNIT_ASSERT (mul_dim(mat22,mat22)==mat22);
CPPUNIT_ASSERT_THROW(mul_dim(mat22,mat32),DimException);
CPPUNIT_ASSERT (mul_dim(mat22,mat23)==mat23);
CPPUNIT_ASSERT_THROW(mul_dim(mat22,mat33),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(mat32,sca),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(mat32,row2),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(mat32,row3),DimException);
CPPUNIT_ASSERT (mul_dim(mat32,col2)==col3);
CPPUNIT_ASSERT_THROW(mul_dim(mat32,col3),DimException);
CPPUNIT_ASSERT (mul_dim(mat32,mat22)==mat32);
CPPUNIT_ASSERT_THROW(mul_dim(mat32,mat32),DimException);
CPPUNIT_ASSERT (mul_dim(mat32,mat23)==mat33);
CPPUNIT_ASSERT_THROW(mul_dim(mat32,mat33),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(mat23,sca),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(mat23,row2),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(mat23,row3),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(mat23,col2),DimException);
CPPUNIT_ASSERT (mul_dim(mat23,col3)==col2);
CPPUNIT_ASSERT_THROW(mul_dim(mat23,mat22),DimException);
CPPUNIT_ASSERT (mul_dim(mat23,mat32)==mat22);
CPPUNIT_ASSERT_THROW(mul_dim(mat23,mat23),DimException);
CPPUNIT_ASSERT (mul_dim(mat23,mat33)==mat23);
CPPUNIT_ASSERT_THROW(mul_dim(mat33,sca),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(mat33,row2),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(mat33,row3),DimException);
CPPUNIT_ASSERT_THROW(mul_dim(mat33,col2),DimException);
CPPUNIT_ASSERT (mul_dim(mat33,col3)==col3);
CPPUNIT_ASSERT_THROW(mul_dim(mat33,mat22),DimException);
CPPUNIT_ASSERT (mul_dim(mat33,mat32)==mat32);
CPPUNIT_ASSERT_THROW(mul_dim(mat33,mat23),DimException);
CPPUNIT_ASSERT (mul_dim(mat33,mat33)==mat33);
}
matrix_2x2_t m2t=trans2(m2);
print_util_print_matrix(print_util_get_debug_stream(), m2t.v[0], 2, 2, 2); print_util_dbg_print("\n");
matrix_2x2_t m2i=inv2(m2);
print_util_print_matrix(print_util_get_debug_stream(), m2i.v[0], 2, 2, 2); print_util_dbg_print("\n");
print_util_print_matrix(print_util_get_debug_stream(), madd2(m2, m2t).v[0], 2, 2, 2); print_util_dbg_print("\n");
matrix_2x2_t m2_=mmul2(m2, m2i);
print_util_print_matrix(print_util_get_debug_stream(), m2_.v[0], 2, 2, 2); print_util_dbg_print("\n");
matrix_3x3_t m3={.v={{1, 2, 4},{2,4,2},{4,2,1}}};
print_util_print_matrix(print_util_get_debug_stream(), m3.v[0], 3, 3, 2); print_util_dbg_print("\n");
matrix_3x3_t m3d=diag_3x3(row3(m3, 0));
print_util_print_matrix(print_util_get_debug_stream(), m3d.v[0], 3, 3, 2); print_util_dbg_print("\n");
matrix_3x3_t m3t=trans3(m3);
print_util_print_matrix(print_util_get_debug_stream(), m3t.v[0], 3, 3, 2); print_util_dbg_print("\n");
matrix_3x3_t m3i=inv3(m3);
print_util_print_matrix(print_util_get_debug_stream(), m3i.v[0], 3, 3, 2); print_util_dbg_print("\n");
matrix_3x3_t m3_=mmul3(m3, m3i);
m3_=mmul3(m3, inv3(m3));
print_util_print_matrix(print_util_get_debug_stream(), m3_.v[0], 3, 3, 2); print_util_dbg_print("\n");
matrix_4x4_t m4={.v={{1, 2, 3, 4},{2,4,2, 4},{4,3,2,1}, {5,6,7,5}}};
print_util_print_matrix(print_util_get_debug_stream(), m4.v[0], 4, 4, 2); print_util_dbg_print("\n");
