34 #if defined ( _WIN64 ) || defined ( _WIN32 )
46 this->firstModelOnly =
true;
47 this->removeNegativeDensity =
true;
50 this->requestedResolution = -1.0;
51 this->changeMapResolution =
false;
52 this->changeMapResolutionTriLinear =
false;
53 this->resolutionOversampling = 0.5;
56 this->pdbBFactorNewVal = -1.0;
59 this->maxBandwidth = 0;
60 this->rotationUncertainty = 0;
61 this->maxRadius = -1.0;
64 this->usePhase =
true;
67 this->maxSphereDists = 0.0;
71 this->integApproxSteps = 5;
72 this->noIntegrationSpeedup =
false;
75 this->normaliseMap =
false;
78 this->invertMap =
false;
81 this->blurFactor = 350.0;
82 this->maskingThresholdIQRs = 3.0;
83 this->maskMap =
false;
84 this->useCorrelationMasking =
false;
85 this->halfMapKernel = 0.0;
86 this->correlationKernel = 0.0;
87 this->saveMask =
false;
88 this->maskFileName =
"maskFile";
89 this->appliedMaskFileName =
"";
95 this->fourierWeightsFileName =
"";
98 this->reBoxMap =
false;
99 this->boundsExtraSpace = 3.0;
100 this->boundsSimilarityThreshold = 0;
101 this->useSameBounds =
false;
102 this->forceBounds =
new proshade_signed [6];
105 this->moveToCOM =
false;
111 this->addExtraSpace = 10.0;
112 this->coOrdsExtraSpace = 10.0;
115 this->progressiveSphereMapping =
true;
118 this->outName =
"reBoxed";
121 this->computeEnergyLevelsDesc =
true;
122 this->computeTraceSigmaDesc =
true;
123 this->computeRotationFuncDesc =
true;
124 this->enLevMatrixPowerWeight = 1.0;
127 this->peakNeighbours = 1;
128 this->noIQRsFromMedianNaivePeak = -999.9;
131 this->smoothingFactor = 15.0;
134 this->findSymCentre =
false;
135 this->useBiCubicInterpolationOnPeaks =
true;
136 this->maxSymmetryFold = 30;
137 this->supportedSymmetryFold = 5;
138 this->fscThreshold = 0.3;
139 this->peakThresholdMin = 0.75;
140 this->fastISearch =
true;
141 this->symMissPeakThres = 0.3;
142 this->axisErrTolerance = 0.01;
143 this->axisErrToleranceDefault =
true;
144 this->minSymPeak = 0.5;
145 this->requestedSymmetryType =
"";
146 this->requestedSymmetryFold = 0;
154 this->overlayStructureName =
"movedStructure";
155 this->rotTrsJSONFile =
"movedStructureOperations.json";
159 this->messageShift = 0;
171 #if defined ( _WIN64 ) || defined ( _WIN32 )
178 this->task = settings->
task;
181 for (
size_t fIt = 0; fIt < settings->
inputFiles.size(); fIt++ ) { this->inputFiles.push_back ( settings->
inputFiles.at(fIt) ); }
182 this->forceP1 = settings->
forceP1;
202 this->usePhase = settings->
usePhase;
221 this->maskMap = settings->
maskMap;
225 this->saveMask = settings->
saveMask;
236 this->reBoxMap = settings->
reBoxMap;
240 this->forceBounds =
new proshade_signed [6];
241 for (
size_t fbIt = 0; fbIt < 6; fbIt++ ) { this->forceBounds[fbIt] = settings->
forceBounds[fbIt]; }
257 this->outName = settings->
outName;
282 this->axisErrToleranceDefault = settings->axisErrToleranceDefault;
288 this->centrePosition.clear ( );
289 for (
size_t cpIt = 0; cpIt < settings->
centrePosition.size(); cpIt++ )
299 this->verbose = settings->
verbose;
311 #if defined ( _WIN64 ) || defined ( _WIN32 )
318 this->task = taskToPerform;
321 this->forceP1 =
true;
323 this->firstModelOnly =
true;
324 this->removeNegativeDensity =
true;
327 this->requestedResolution = -1.0;
328 this->changeMapResolution =
false;
329 this->changeMapResolutionTriLinear =
false;
330 this->resolutionOversampling = 0.5;
333 this->pdbBFactorNewVal = -1.0;
336 this->maxBandwidth = 0;
337 this->rotationUncertainty = 0;
338 this->maxRadius = -1.0;
341 this->usePhase =
true;
344 this->maxSphereDists = 0.0;
347 this->integOrder = 0;
348 this->integApproxSteps = 5;
349 this->noIntegrationSpeedup =
false;
352 this->normaliseMap =
false;
355 this->invertMap =
false;
358 this->blurFactor = 350.0;
359 this->maskingThresholdIQRs = 3.0;
360 this->maskMap =
false;
361 this->useCorrelationMasking =
false;
362 this->halfMapKernel = 0.0;
363 this->correlationKernel = 0.0;
364 this->saveMask =
false;
365 this->maskFileName =
"maskFile";
366 this->appliedMaskFileName =
"";
372 this->fourierWeightsFileName =
"";
380 this->reBoxMap =
false;
381 this->boundsExtraSpace = 3.0;
382 this->boundsSimilarityThreshold = 0;
383 this->useSameBounds =
false;
384 this->forceBounds =
new proshade_signed [6];
387 this->addExtraSpace = 10.0;
388 this->coOrdsExtraSpace = 10.0;
391 this->progressiveSphereMapping =
true;
394 this->outName =
"reBoxed";
397 this->computeEnergyLevelsDesc =
true;
398 this->computeTraceSigmaDesc =
true;
399 this->computeRotationFuncDesc =
true;
400 this->enLevMatrixPowerWeight = 1.0;
403 this->peakNeighbours = 1;
404 this->noIQRsFromMedianNaivePeak = -999.9;
407 this->smoothingFactor = 15.0;
410 this->findSymCentre =
false;
411 this->useBiCubicInterpolationOnPeaks =
true;
412 this->maxSymmetryFold = 30;
413 this->supportedSymmetryFold = 5;
414 this->fscThreshold = 0.3;
415 this->peakThresholdMin = 0.75;
416 this->fastISearch =
true;
417 this->symMissPeakThres = 0.3;
418 this->axisErrTolerance = 0.01;
419 this->axisErrToleranceDefault =
true;
420 this->minSymPeak = 0.5;
421 this->requestedSymmetryType =
"";
422 this->requestedSymmetryFold = 0;
430 this->overlayStructureName =
"movedStructure";
431 this->rotTrsJSONFile =
"movedStructureOperations.json";
435 this->messageShift = 0;
438 switch ( this->task )
441 std::cerr << std::endl <<
"=====================" << std::endl <<
"!! ProSHADE ERROR !!" << std::endl <<
"=====================" << std::endl << std::flush;
442 std::cerr <<
"Error Code : " <<
"E000014" << std::endl << std::flush;
443 std::cerr <<
"ProSHADE version : " << PROSHADE_VERSION << std::endl << std::flush;
444 std::cerr <<
"File : " <<
"ProSHADE.cpp" << std::endl << std::flush;
445 std::cerr <<
"Line : " << 97 << std::endl << std::flush;
446 std::cerr <<
"Function : " <<
"ProSHADE_settings (Task) constructor" << std::endl << std::flush;
447 std::cerr <<
"Message : " <<
"No task has been specified for task specific constructor." << std::endl << std::flush;
448 std::cerr <<
"Further information : " <<
"This ProSHADE_settings class constructor is intended to\n : set the internal variables to default value given a\n : particular taks. By supplying this task as NA, this beats\n : the purpose of the constructor. Please use the\n : non-argumental constructor if task is not yet known." << std::endl << std::endl << std::flush;
450 exit ( EXIT_FAILURE );
453 this->requestedResolution = 6.0;
454 this->pdbBFactorNewVal = 80.0;
455 this->changeMapResolution =
true;
456 this->maskMap =
false;
457 this->moveToCOM =
true;
458 this->reBoxMap =
false;
462 this->changeMapResolution =
false;
463 this->maskMap =
false;
464 this->moveToCOM =
true;
465 this->reBoxMap =
false;
469 this->requestedResolution = 8.0;
470 this->changeMapResolution =
true;
471 this->maskMap =
false;
472 this->moveToCOM =
false;
473 this->reBoxMap =
false;
477 this->changeMapResolution =
false;
478 this->maskMap =
true;
479 this->moveToCOM =
false;
491 #if defined ( _WIN64 ) || defined ( _WIN32 )
498 delete[] this->forceBounds;
510 if ( lhs.AlmostEquals( rhs ) )
529 #if defined ( _WIN64 ) || defined ( _WIN32 )
549 #if defined ( _WIN64 ) || defined ( _WIN32 )
556 this->requestedResolution = resolution;
569 #if defined ( _WIN64 ) || defined ( _WIN32 )
576 this->pdbBFactorNewVal = newBF;
589 #if defined ( _WIN64 ) || defined ( _WIN32 )
596 this->normaliseMap = normalise;
609 #if defined ( _WIN64 ) || defined ( _WIN32 )
616 this->invertMap = mInv;
629 #if defined ( _WIN64 ) || defined ( _WIN32 )
636 this->verbose = verbosity;
649 #if defined ( _WIN64 ) || defined ( _WIN32 )
656 this->blurFactor = blurFac;
670 #if defined ( _WIN64 ) || defined ( _WIN32 )
677 this->maskingThresholdIQRs = noIQRs;
690 #if defined ( _WIN64 ) || defined ( _WIN32 )
697 this->maskMap = mask;
711 #if defined ( _WIN64 ) || defined ( _WIN32 )
718 this->useCorrelationMasking = corMask;
733 #if defined ( _WIN64 ) || defined ( _WIN32 )
740 this->halfMapKernel = typNoi;
753 #if defined ( _WIN64 ) || defined ( _WIN32 )
760 this->correlationKernel = minMS;
773 #if defined ( _WIN64 ) || defined ( _WIN32 )
780 this->saveMask = savMsk;
793 #if defined ( _WIN64 ) || defined ( _WIN32 )
800 this->maskFileName = mskFln;
813 #if defined ( _WIN64 ) || defined ( _WIN32 )
820 this->appliedMaskFileName = mskFln;
833 #if defined ( _WIN64 ) || defined ( _WIN32 )
840 this->fourierWeightsFileName = fWgFln;
853 #if defined ( _WIN64 ) || defined ( _WIN32 )
860 this->reBoxMap = reBx;
874 #if defined ( _WIN64 ) || defined ( _WIN32 )
881 this->boundsExtraSpace = boundsExSp;
894 #if defined ( _WIN64 ) || defined ( _WIN32 )
901 this->boundsSimilarityThreshold = boundsThres;
915 #if defined ( _WIN64 ) || defined ( _WIN32 )
922 this->useSameBounds = sameB;
936 #if defined ( _WIN64 ) || defined ( _WIN32 )
943 this->outName = oFileName;
956 #if defined ( _WIN64 ) || defined ( _WIN32 )
963 this->changeMapResolution = mrChange;
976 #if defined ( _WIN64 ) || defined ( _WIN32 )
983 this->changeMapResolutionTriLinear = mrChange;
996 #if defined ( _WIN64 ) || defined ( _WIN32 )
1003 this->resolutionOversampling = overS;
1016 #if defined ( _WIN64 ) || defined ( _WIN32 )
1023 this->moveToCOM = com;
1038 #if defined ( _WIN64 ) || defined ( _WIN32 )
1045 if ( this->moveToCOM )
1047 ProSHADE_internal_messages::printWarningMessage ( this->verbose,
"!!! ProSHADE WARNING !!! Requested specific map box centre and also centre of mass centring. These are mutually exclusive - turning COM centring off.",
"WP00067" );
1048 this->moveToCOM =
false;
1052 this->boxCentre.at(0) = xPos;
1053 this->boxCentre.at(1) = yPos;
1054 this->boxCentre.at(2) = zPos;
1067 #if defined ( _WIN64 ) || defined ( _WIN32 )
1074 this->addExtraSpace = exSpace;
1087 #if defined ( _WIN64 ) || defined ( _WIN32 )
1094 this->coOrdsExtraSpace = exSpace;
1107 #if defined ( _WIN64 ) || defined ( _WIN32 )
1114 this->maxBandwidth = band;
1127 #if defined ( _WIN64 ) || defined ( _WIN32 )
1134 this->maxSphereDists = sphDist;
1147 #if defined ( _WIN64 ) || defined ( _WIN32 )
1154 this->integOrder = intOrd;
1168 #if defined ( _WIN64 ) || defined ( _WIN32 )
1175 this->integApproxSteps = noSteps;
1186 #if defined ( _WIN64 ) || defined ( _WIN32 )
1193 this->noIntegrationSpeedup = !speedup;
1206 #if defined ( _WIN64 ) || defined ( _WIN32 )
1213 this->progressiveSphereMapping = progSphMap;
1227 #if defined ( _WIN64 ) || defined ( _WIN32 )
1234 this->computeEnergyLevelsDesc = enLevDesc;
1248 #if defined ( _WIN64 ) || defined ( _WIN32 )
1255 this->computeTraceSigmaDesc = trSigVal;
1269 #if defined ( _WIN64 ) || defined ( _WIN32 )
1276 this->computeRotationFuncDesc = rotfVal;
1290 #if defined ( _WIN64 ) || defined ( _WIN32 )
1297 this->peakNeighbours = pkS;
1312 #if defined ( _WIN64 ) || defined ( _WIN32 )
1319 this->noIQRsFromMedianNaivePeak = noIQRs;
1334 #if defined ( _WIN64 ) || defined ( _WIN32 )
1341 this->usePhase = phaseUsage;
1356 #if defined ( _WIN64 ) || defined ( _WIN32 )
1363 this->enLevMatrixPowerWeight = mPower;
1378 #if defined ( _WIN64 ) || defined ( _WIN32 )
1385 this->smoothingFactor = smFact;
1399 #if defined ( _WIN64 ) || defined ( _WIN32 )
1406 this->symMissPeakThres = mpThres;
1420 #if defined ( _WIN64 ) || defined ( _WIN32 )
1427 this->findSymCentre = sCen;
1441 #if defined ( _WIN64 ) || defined ( _WIN32 )
1448 this->axisErrTolerance = axThres;
1464 #if defined ( _WIN64 ) || defined ( _WIN32 )
1471 this->axisErrToleranceDefault = behav;
1485 #if defined ( _WIN64 ) || defined ( _WIN32 )
1492 this->minSymPeak = minSP;
1505 #if defined ( _WIN64 ) || defined ( _WIN32 )
1512 this->requestedSymmetryType = val;
1525 #if defined ( _WIN64 ) || defined ( _WIN32 )
1532 this->requestedSymmetryFold = val;
1543 #if defined ( _WIN64 ) || defined ( _WIN32 )
1550 this->overlayStructureName = filename;
1561 #if defined ( _WIN64 ) || defined ( _WIN32 )
1568 this->rotTrsJSONFile = filename;
1579 #if defined ( _WIN64 ) || defined ( _WIN32 )
1586 this->useBiCubicInterpolationOnPeaks = bicubPeaks;
1597 #if defined ( _WIN64 ) || defined ( _WIN32 )
1604 this->maxSymmetryFold = maxFold;
1615 #if defined ( _WIN64 ) || defined ( _WIN32 )
1622 this->fscThreshold = fscThr;
1633 #if defined ( _WIN64 ) || defined ( _WIN32 )
1640 this->peakThresholdMin = peakThr;
1651 #if defined ( _WIN64 ) || defined ( _WIN32 )
1658 this->removeNegativeDensity = nDens;
1678 std::stringstream hlpSS;
1679 hlpSS <<
"The bandwidth was determined as: " << this->
maxBandwidth;
1689 this->
supportedSymmetryFold =
static_cast< proshade_unsign
> ( (
static_cast< proshade_double
> ( circumference ) / 2.0 ) / 5.0 );
1693 std::stringstream hlpSS;
1694 hlpSS <<
"The bandwidth was determined as: " << this->
maxBandwidth;
1713 if (
static_cast<proshade_unsign
> ( std::ceil ( ( 360.0 / uncertainty ) / 2 ) ) % 2 == 0 )
1715 this->
maxBandwidth =
static_cast<proshade_unsign
> ( std::ceil ( ( 360.0 / uncertainty ) / 2.0 ) );
1719 this->
maxBandwidth =
static_cast<proshade_unsign
> ( std::ceil ( ( 360.0 / uncertainty ) / 2.0 ) ) + 1;
1723 std::stringstream hlpSS;
1724 hlpSS <<
"The bandwidth was determined from uncertainty " << uncertainty <<
" degrees as: " << this->
maxBandwidth;
1746 std::stringstream hlpSS;
1747 hlpSS <<
"The sphere distances were determined as " << this->
maxSphereDists <<
" Angstroms.";
1756 std::stringstream hlpSS;
1757 hlpSS <<
"The sphere distances were determined as " << this->
maxSphereDists <<
" Angstroms.";
1778 std::stringstream hlpSS;
1779 hlpSS <<
"The integration order was determined as " << this->
integOrder;
1788 std::stringstream hlpSS;
1789 hlpSS <<
"The integration order was determined as " << this->
integOrder;
1823 proshade_unsign theoXDim =
static_cast< proshade_unsign
> ( std::ceil ( xDimAngs / ( this->
requestedResolution / 2.0f ) ) );
1824 proshade_unsign theoYDim =
static_cast< proshade_unsign
> ( std::ceil ( yDimAngs / ( this->
requestedResolution / 2.0f ) ) );
1825 proshade_unsign theoZDim =
static_cast< proshade_unsign
> ( std::ceil ( zDimAngs / ( this->
requestedResolution / 2.0f ) ) );
1831 if (
static_cast< proshade_single
> ( this->
maxRadius * 2.0 ) > std::max ( xDimAngs, std::max( yDimAngs, zDimAngs ) ) )
1839 theoXDim =
static_cast< proshade_unsign
> ( std::ceil ( ( this->
maxRadius * 2.0 ) /
static_cast< proshade_double
> ( this->
requestedResolution / 2.0f ) ) );
1840 theoYDim =
static_cast< proshade_unsign
> ( std::ceil ( ( this->
maxRadius * 2.0 ) /
static_cast< proshade_double
> ( this->
requestedResolution / 2.0f ) ) );
1841 theoZDim =
static_cast< proshade_unsign
> ( std::ceil ( ( this->
maxRadius * 2.0 ) /
static_cast< proshade_double
> ( this->
requestedResolution / 2.0f ) ) );
1846 if ( ( std::isinf ( this->
calcBounds.at(0) ) || std::isinf ( this->calcBounds.at(1) ) || std::isinf ( this->calcBounds.at(2) ) ) && ( this->
maxRadius < 0.0 ) )
1853 theoXDim =
static_cast< proshade_unsign
> ( std::ceil ( this->
calcBounds.at(0) /
static_cast< proshade_double
> ( this->requestedResolution / 2.0f ) ) );
1854 theoYDim =
static_cast< proshade_unsign
> ( std::ceil ( this->
calcBounds.at(1) /
static_cast< proshade_double
> ( this->requestedResolution / 2.0f ) ) );
1855 theoZDim =
static_cast< proshade_unsign
> ( std::ceil ( this->
calcBounds.at(2) /
static_cast< proshade_double
> ( this->requestedResolution / 2.0f ) ) );
1859 proshade_unsign maxDim = std::max ( theoXDim, std::max ( theoYDim, theoZDim ) );
1860 proshade_unsign minDim = std::min ( theoXDim, std::min ( theoYDim, theoZDim ) );
1861 proshade_unsign midDim = 0;
1862 if ( ( xDim < maxDim ) && ( xDim > minDim ) ) { midDim = theoXDim; }
1863 else if ( ( yDim < maxDim ) && ( yDim > minDim ) ) { midDim = theoYDim; }
1864 else { midDim = theoZDim; }
1866 proshade_unsign circ = ( maxDim ) + ( midDim );
1873 proshade_single maxDiag =
static_cast< proshade_single
> ( std::sqrt ( std::pow (
static_cast<proshade_single
> ( maxDim ) * ( this->
requestedResolution / 2.0f ), 2.0f ) +
1874 std::pow (
static_cast<proshade_single
> ( midDim ) * ( this->
requestedResolution / 2.0f ), 2.0f ) ) );
1897 #if defined ( _WIN64 ) || defined ( _WIN32 )
1907 this->noStructures =
static_cast<proshade_unsign
> ( settings->
inputFiles.size() );
1908 this->verbose =
static_cast<proshade_signed
> ( settings->
verbose );
1914 switch ( settings->
task )
1917 throw ProSHADE_exception (
"No task has been specified.",
"E000001", __FILE__, __LINE__, __func__,
"ProSHADE requires to be told which particular functiona-\n : lity (task) is requested from it. In order to do so, the\n : command line arguments specifying task need to be used\n : (if used from command line), or the ProSHADE_settings\n : object needs to have the member variable \'Task\' set to\n : one of the following values: Distances, Symmetry,\n : OverlayMap or MapManip." );
1941 std::cerr << std::endl <<
"=====================" << std::endl <<
"!! ProSHADE ERROR !!" << std::endl <<
"=====================" << std::endl << std::flush;
1942 std::cerr <<
"Error Code : " << err.
get_errc() << std::endl << std::flush;
1943 std::cerr <<
"ProSHADE version : " << PROSHADE_VERSION << std::endl << std::flush;
1944 std::cerr <<
"File : " << err.
get_file() << std::endl << std::flush;
1945 std::cerr <<
"Line : " << err.
get_line() << std::endl << std::flush;
1946 std::cerr <<
"Function : " << err.
get_func() << std::endl << std::flush;
1947 std::cerr <<
"Message : " << err.what() << std::endl << std::flush;
1948 std::cerr <<
"Further information : " << err.
get_info() << std::endl << std::endl << std::flush;
1952 exit ( EXIT_FAILURE );
1958 std::cerr << std::endl <<
"=====================" << std::endl <<
"!! ProSHADE ERROR !!" << std::endl <<
"=====================" << std::endl << std::flush;
1961 #if __cplusplus >= 201103L
1962 std::exception_ptr exc = std::current_exception();
1967 std::rethrow_exception ( exc );
1970 catch (
const std::exception& e )
1972 std::cerr <<
"Caught unknown exception with following information: " << e.what() << std::endl << std::flush;
1975 std::cerr <<
"Unknown error with no further explanation available. Please contact the author for help." << std::endl << std::flush;
1977 std::cerr <<
"Terminating..." << std::endl << std::endl << std::flush;
1981 exit ( EXIT_FAILURE );
1995 #if defined ( _WIN64 ) || defined ( _WIN32 )
2002 if ( this->originalBounds.size() > 0 ) {
for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( this->originalBounds.size() ); iter++ ) {
delete[] this->originalBounds.at(iter); } }
2003 if ( this->reboxedBounds.size() > 0 ) {
for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( this->reboxedBounds.size() ); iter++ ) {
delete[] this->reboxedBounds.at(iter); } }
2004 if ( this->manipulatedMaps.size() > 0 ) {
for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( this->manipulatedMaps.size() ); iter++ ) {
delete[] this->manipulatedMaps.at(iter); } }
2007 this->enLevs.clear ( );
2008 this->trSigm.clear ( );
2009 this->rotFun.clear ( );
2012 if ( this->RecomSymAxes.size() > 0 )
2014 for (
size_t iter = 0; iter < this->RecomSymAxes.size(); iter++ )
2016 delete[] this->RecomSymAxes.at(iter);
2018 this->RecomSymAxes.clear ( );
2029 #if defined ( _WIN64 ) || defined ( _WIN32 )
2037 return ( this->symRecommType );
2044 #if defined ( _WIN64 ) || defined ( _WIN32 )
2051 return ( this->symRecommFold );
2060 void ProSHADE_run::setRecommendedSymmetry ( std::string val )
2063 this->symRecommType = val;
2077 void ProSHADE_run::setRecommendedFold ( proshade_unsign val )
2080 this->symRecommFold = val;
2094 void ProSHADE_run::setRecommendedAxis ( proshade_double* sym )
2109 #if defined ( _WIN64 ) || defined ( _WIN32 )
2119 const struct option_port longopts[] =
2121 {
"version", no_argument,
nullptr,
'v' },
2122 {
"help", no_argument,
nullptr,
'h' },
2123 {
"verbose", required_argument,
nullptr,
'!' },
2124 {
"distances", no_argument,
nullptr,
'D' },
2125 {
"mapManip", no_argument,
nullptr,
'M' },
2126 {
"symmetry", no_argument,
nullptr,
'S' },
2127 {
"symCentre", no_argument,
nullptr,
'I' },
2128 {
"overlay", no_argument,
nullptr,
'O' },
2129 {
"file", required_argument,
nullptr,
'f' },
2130 {
"forceSpgP1", no_argument,
nullptr,
'u' },
2131 {
"removeWaters", no_argument,
nullptr,
'w' },
2132 {
"firstModel", no_argument,
nullptr,
'x' },
2133 {
"resolution", required_argument,
nullptr,
'r' },
2134 {
"bandwidth", required_argument,
nullptr,
'b' },
2135 {
"sphereDists", required_argument,
nullptr,
's' },
2136 {
"extraSpace", required_argument,
nullptr,
'e' },
2137 {
"integOrder", required_argument,
nullptr,
'i' },
2138 {
"integApprox", required_argument,
nullptr,
't' },
2139 {
"invertMap", no_argument,
nullptr,
'@' },
2140 {
"normalise", no_argument,
nullptr,
'#' },
2141 {
"mask", no_argument,
nullptr,
'$' },
2142 {
"saveMask", no_argument,
nullptr,
'%' },
2143 {
"maskFile", required_argument,
nullptr,
'^' },
2144 {
"applyMask", required_argument,
nullptr,
'G' },
2145 {
"maskBlurring", required_argument,
nullptr,
'&' },
2146 {
"maskThreshold", required_argument,
nullptr,
'*' },
2147 {
"mapReboxing", no_argument,
nullptr,
'R' },
2148 {
"boundsSpace", required_argument,
nullptr,
'(' },
2149 {
"boundsThreshold", required_argument,
nullptr,
')' },
2150 {
"sameBoundaries", no_argument,
nullptr,
'-' },
2151 {
"reBoxedFilename", required_argument,
nullptr,
'g' },
2152 {
"pdbTempFact", required_argument,
nullptr,
'd' },
2153 {
"center", no_argument,
nullptr,
'c' },
2154 {
"changeMapResol", no_argument,
nullptr,
'j' },
2155 {
"changeMapTriLin", no_argument,
nullptr,
'a' },
2156 {
"oversamplRate", required_argument,
nullptr,
'K' },
2157 {
"noPhase", no_argument,
nullptr,
'p' },
2158 {
"progressive", no_argument,
nullptr,
'k' },
2159 {
"noEnL", no_argument,
nullptr,
'l' },
2160 {
"noTrS", no_argument,
nullptr,
'm' },
2161 {
"noFRF", no_argument,
nullptr,
'n' },
2162 {
"EnLWeight", required_argument,
nullptr,
'_' },
2163 {
"peakNeigh", required_argument,
nullptr,
'=' },
2164 {
"peakThres", required_argument,
nullptr,
'+' },
2165 {
"missAxThres", required_argument,
nullptr,
'[' },
2166 {
"sameAxComp", required_argument,
nullptr,
']' },
2167 {
"axisComBeh", no_argument,
nullptr,
'q' },
2168 {
"bicubSearch", no_argument,
nullptr,
'A' },
2169 {
"maxSymPrime", required_argument,
nullptr,
'B' },
2170 {
"minPeakHeight", required_argument,
nullptr,
'o' },
2171 {
"fscThres", required_argument,
nullptr,
'C' },
2172 {
"peakMinThres", required_argument,
nullptr,
'E' },
2173 {
"reqSym", required_argument,
nullptr,
'{' },
2174 {
"overlayFile", required_argument,
nullptr,
'}' },
2175 {
"overlayJSONFile", required_argument,
nullptr,
'y' },
2176 {
"angUncertain", required_argument,
nullptr,
';' },
2177 {
"maxRadius", required_argument,
nullptr,
'J' },
2178 {
"fourierWeights", required_argument,
nullptr,
'z' },
2179 {
"keepNegDens", no_argument,
nullptr,
'F' },
2180 {
"coordExtraSpace", required_argument,
nullptr,
'H' },
2181 {
nullptr, 0,
nullptr, 0 }
2185 const char*
const shortopts =
"AaB:b:C:cDd:E:e:Ff:G:g:H:hIi:J:jK:klmMno:Opqr:Rs:St:uvwxy:z:!:@#$%^:&:*:(:):-_:=:+:[:]:{:}:;:";
2191 int opt = getopt_long_port ( argc, argv, shortopts, longopts,
nullptr );
2206 exit ( EXIT_SUCCESS );
2218 this->setVerbosity (
static_cast<proshade_signed
> ( atoi ( optarg ) ) );
2225 this->task = Distances;
2232 this->task = MapManip;
2239 this->task = Symmetry;
2242 const FloatingPoint< proshade_single > lhs1 ( this->requestedResolution ), rhs1 ( -1.0f );
2243 if ( lhs1.AlmostEquals ( rhs1 ) ) { this->requestedResolution = 6.0; }
2245 const FloatingPoint< proshade_double > lhs2 ( this->pdbBFactorNewVal ), rhs2 ( -1.0 );
2246 if ( lhs2.AlmostEquals ( rhs2 ) ) { this->pdbBFactorNewVal = 80.0; }
2247 this->changeMapResolution = !this->changeMapResolution;
2248 this->moveToCOM = !this->moveToCOM;
2256 this->task = OverlayMap;
2263 this->addStructure ( std::string ( optarg ) );
2270 this->forceP1 = !this->forceP1;
2284 this->firstModelOnly = !this->firstModelOnly;
2291 this->setResolution (
static_cast<proshade_single
> ( atof ( optarg ) ) );
2298 this->setBandwidth (
static_cast<proshade_unsign
> ( atoi ( optarg ) ) );
2305 this->setExtraSpace (
static_cast<proshade_single
> ( atof ( optarg ) ) );
2312 this->setCoordExtraSpace (
static_cast<proshade_single
> ( atof ( optarg ) ) );
2319 this->setIntegrationOrder (
static_cast<proshade_unsign
> ( atof ( optarg ) ) );
2326 this->setSphereDistances (
static_cast<proshade_single
> ( atof ( optarg ) ) );
2333 this->setIntegrationApproxSteps (
static_cast<proshade_unsign
> ( atof ( optarg ) ) );
2340 this->setMapInversion (
true );
2347 this->setNormalisation (
true );
2354 this->setMasking (
true );
2361 this->setMasking (
true );
2362 this->setMaskSaving (
true );
2369 this->setMaskFilename (
static_cast<std::string
> ( optarg ) );
2376 this->setAppliedMaskFilename (
static_cast<std::string
> ( optarg ) );
2383 this->setFourierWeightsFilename (
static_cast<std::string
> ( optarg ) );
2390 this->setMaskBlurFactor (
static_cast<proshade_single
> ( atof ( optarg ) ) );
2397 this->setMaskIQR (
static_cast<proshade_single
> ( atof ( optarg ) ) );
2404 this->setMasking (
true );
2405 this->setMapReboxing (
true );
2412 this->setBoundsSpace (
static_cast<proshade_single
> ( atof ( optarg ) ) );
2419 this->setBoundsThreshold (
static_cast<proshade_signed
> ( atoi ( optarg ) ) );
2426 this->setSameBoundaries (
true );
2433 this->setOutputFilename (
static_cast<std::string
> ( optarg ) );
2440 this->setPDBBFactor (
static_cast<proshade_double
> ( atof ( optarg ) ) );
2447 this->moveToCOM = !this->moveToCOM;
2454 this->changeMapResolution = !this->changeMapResolution;
2461 this->setMapResolutionChangeTriLinear (
true );
2468 this->setMapResolutionOverSampling (
static_cast< proshade_single
> ( atof ( optarg ) ) );
2475 this->setPhaseUsage (
false );
2482 this->setProgressiveSphereMapping (
false );
2489 this->setEnergyLevelsComputation (
false );
2496 this->setTraceSigmaComputation (
false );
2503 this->setRotationFunctionComputation (
false );
2510 this->setEnLevShellWeight (
static_cast<proshade_double
> ( atof ( optarg ) ) );
2517 this->setPeakNeighboursNumber (
static_cast<proshade_unsign
> ( atoi ( optarg ) ) );
2524 this->setPeakNaiveNoIQR (
static_cast<proshade_double
> ( atof ( optarg ) ) );
2531 this->setSymmetryCentreSearch (
true );
2538 this->setMissingPeakThreshold (
static_cast<proshade_double
> ( atof ( optarg ) ) );
2545 setAxisComparisonThreshold (
static_cast<proshade_double
> ( atof ( optarg ) ) );
2552 this->setAxisComparisonThresholdBehaviour ( !this->axisErrToleranceDefault );
2559 this->setBicubicInterpolationSearch ( !this->useBiCubicInterpolationOnPeaks );
2566 setMaxSymmetryFold (
static_cast<proshade_unsign
> ( atoi ( optarg ) ) );
2573 this->minSymPeak =
static_cast<proshade_double
> ( atof ( optarg ) );
2580 this->setFSCThreshold (
static_cast<proshade_double
> ( atof ( optarg ) ) );
2587 this->setPeakThreshold (
static_cast<proshade_double
> ( atof ( optarg ) ) );
2594 std::string input =
static_cast<std::string
> ( optarg );
2596 if ( input.at(0) ==
'C' )
2598 this->setRequestedSymmetry (
"C" );
2600 std::string numHlp ( input.begin()+1, input.end() );
2601 if ( numHlp.length() > 0 ) { this->setRequestedFold (
static_cast< proshade_unsign
> ( atoi ( numHlp.c_str() ) ) ); }
2602 else { std::cerr <<
"!!! ProSHADE ERROR !!! The input argument requests search for Cyclic/Dihedral symmetry, but does not specify the requested fold." << std::endl; exit ( EXIT_FAILURE ); }
2606 if ( input.at(0) ==
'D' )
2608 this->setRequestedSymmetry (
"D" );
2610 std::string numHlp ( input.begin()+1, input.end() );
2611 if ( numHlp.length() > 0 ) { this->setRequestedFold (
static_cast< proshade_unsign
> ( atoi ( numHlp.c_str() ) ) ); }
2612 else { std::cerr <<
"!!! ProSHADE ERROR !!! The input argument requests search for Cyclic/Dihedral symmetry, but does not specify the requested fold." << std::endl; exit ( EXIT_FAILURE ); }
2616 if ( input.at(0) ==
'T' )
2618 this->setRequestedSymmetry (
"T" );
2622 if ( input.at(0) ==
'O' )
2624 this->setRequestedSymmetry (
"O" );
2628 if ( input.at(0) ==
'I' )
2630 this->setRequestedSymmetry (
"I" );
2634 std::cerr <<
"!!! ProSHADE ERROR !!! Failed to parse the requested symmetry type. Allowed types are C, D, T, O and I, with C and D requiring to be followed by a number specifying the fold." << std::endl; exit ( EXIT_FAILURE );
2647 this->setOverlaySaveFile (
static_cast<std::string
> ( optarg ) );
2654 this->setOverlayJsonFile (
static_cast<std::string
> ( optarg ) );
2661 this->rotationUncertainty =
static_cast<proshade_double
> ( atof ( optarg ) );
2668 this->maxRadius =
static_cast< proshade_double
> ( atof ( optarg ) );
2675 this->setNegativeDensity (
false );
2685 std::cout <<
"!!! ProSHADE ERROR !!! Unrecognised short option -" <<
static_cast<char> ( optopt ) <<
" . Please use -h for help on the command line options." << std::endl;
2689 std::cout <<
"!!! ProSHADE ERROR !!! Unrecognised long option " << argv[
static_cast<int> (optind)-1] <<
" . Please use -h for help on the command line options." << std::endl;
2693 exit ( EXIT_SUCCESS );
2713 #if defined ( _WIN64 ) || defined ( _WIN32 )
2721 std::stringstream strstr;
2722 strstr.str(std::string());
2723 if ( this->task == NA ) { strstr <<
"NA"; }
2724 if ( this->task == Distances ) { strstr <<
"DISTANCES COMPUTATION"; }
2725 if ( this->task == MapManip ) { strstr <<
"MAP MANIPULATION"; }
2726 if ( this->task == Symmetry ) { strstr <<
"SYMMETRY DETECTION"; }
2727 if ( this->task == OverlayMap ) { strstr <<
"MAP OVERLAY"; }
2728 printf (
"Task to perform : %37s\n", strstr.str().c_str() );
2731 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( this->inputFiles.size() ); iter++ )
2733 strstr.str(std::string());
2734 strstr << this->inputFiles.at(iter);
2735 printf (
"File(s) to process : %37s\n", strstr.str().c_str() );
2738 strstr.str(std::string());
2739 if ( this->forceP1 ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2740 printf (
"Force P1 spacegroup : %37s\n", strstr.str().c_str() );
2742 strstr.str(std::string());
2743 if ( this->
removeWaters ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2744 printf (
"Waters removed : %37s\n", strstr.str().c_str() );
2746 strstr.str(std::string());
2747 if ( this->firstModelOnly ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2748 printf (
"Only 1st model : %37s\n", strstr.str().c_str() );
2750 strstr.str(std::string());
2751 if ( this->removeNegativeDensity ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2752 printf (
"Remove neg. dens. : %37s\n", strstr.str().c_str() );
2755 strstr.str(std::string());
2756 strstr << this->requestedResolution;
2757 printf (
"Resolution (comp) : %37s\n", strstr.str().c_str() );
2759 strstr.str(std::string());
2760 if ( this->changeMapResolution ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2761 printf (
"Change map resol : %37s\n", strstr.str().c_str() );
2763 strstr.str(std::string());
2764 if ( this->changeMapResolutionTriLinear ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2765 printf (
"Change map tri-lin : %37s\n", strstr.str().c_str() );
2767 strstr.str(std::string());
2768 strstr << this->resolutionOversampling;
2769 printf (
"Resolution oversampl: %37s\n", strstr.str().c_str() );
2772 strstr.str(std::string());
2773 strstr << this->pdbBFactorNewVal;
2774 printf (
"PDB B-factor const : %37s\n", strstr.str().c_str() );
2777 strstr.str(std::string());
2778 strstr << this->maxBandwidth;
2779 printf (
"Bandwidth : %37s\n", strstr.str().c_str() );
2781 strstr.str(std::string());
2782 strstr << this->rotationUncertainty;
2783 printf (
"Rotation doubt : %37s\n", strstr.str().c_str() );
2786 strstr.str(std::string());
2787 if ( this->usePhase ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2788 printf (
"Use phase info : %37s\n", strstr.str().c_str() );
2791 strstr.str(std::string());
2792 strstr << this->maxSphereDists;
2793 printf (
"Sphere distances : %37s\n", strstr.str().c_str() );
2796 strstr.str(std::string());
2797 strstr << this->integOrder;
2798 printf (
"Integration order : %37s\n", strstr.str().c_str() );
2801 strstr.str(std::string());
2802 strstr << this->integApproxSteps;
2803 printf (
"Integ. approx. steps: %37s\n", strstr.str().c_str() );
2806 strstr.str(std::string());
2807 if ( this->noIntegrationSpeedup ) { strstr <<
"FALSE"; }
else { strstr <<
"TRUE"; }
2808 printf (
"Integration speedup : %37s\n", strstr.str().c_str() );
2811 strstr.str(std::string());
2812 if ( this->normaliseMap ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2813 printf (
"Map normalisation : %37s\n", strstr.str().c_str() );
2816 strstr.str(std::string());
2817 if ( this->invertMap ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2818 printf (
"Map inversion : %37s\n", strstr.str().c_str() );
2821 strstr.str(std::string());
2822 strstr << this->blurFactor;
2823 printf (
"Map blurring : %37s\n", strstr.str().c_str() );
2825 strstr.str(std::string());
2826 strstr << this->maskingThresholdIQRs;
2827 printf (
"Masking threshold : %37s\n", strstr.str().c_str() );
2829 strstr.str(std::string());
2830 if ( this->maskMap ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2831 printf (
"Map masking : %37s\n", strstr.str().c_str() );
2833 strstr.str(std::string());
2834 if ( this->useCorrelationMasking ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2835 printf (
"Correlation mask : %37s\n", strstr.str().c_str() );
2837 strstr.str(std::string());
2838 strstr << this->halfMapKernel;
2839 printf (
"Half-map kernel : %37s\n", strstr.str().c_str() );
2841 strstr.str(std::string());
2842 strstr << this->correlationKernel;
2843 printf (
"Correlation kernel : %37s\n", strstr.str().c_str() );
2845 strstr.str(std::string());
2846 if ( this->saveMask ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2847 printf (
"Saving mask : %37s\n", strstr.str().c_str() );
2849 strstr.str(std::string());
2850 strstr << this->maskFileName;
2851 printf (
"Map mask filename : %37s\n", strstr.str().c_str() );
2853 strstr.str(std::string());
2854 strstr << this->calcBounds.at(0) <<
" | " << this->calcBounds.at(1) <<
" | " << this->calcBounds.at(2);
2855 printf (
"Calculation bounds : %37s\n", strstr.str().c_str() );
2858 strstr.str(std::string());
2859 if ( this->reBoxMap ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2860 printf (
"Map re-boxing : %37s\n", strstr.str().c_str() );
2862 strstr.str(std::string());
2863 strstr << this->boundsExtraSpace;
2864 printf (
"Bounds extra space : %37s\n", strstr.str().c_str() );
2866 strstr.str(std::string());
2867 strstr << this->boundsSimilarityThreshold;
2868 printf (
"Bounds similarity : %37s\n", strstr.str().c_str() );
2870 strstr.str(std::string());
2871 if ( this->useSameBounds ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2872 printf (
"Same boundaries : %37s\n", strstr.str().c_str() );
2874 strstr.str(std::string());
2875 if ( this->forceBounds !=
nullptr )
2877 strstr << this->forceBounds[0] <<
" - " << this->forceBounds[1] <<
" | " << this->forceBounds[2] <<
" - " << this->forceBounds[3] <<
" | " << this->forceBounds[4] <<
" - " << this->forceBounds[5];
2878 printf (
"Bounds similarity : %37s\n", strstr.str().c_str() );
2882 strstr <<
"Not allocated";
2883 printf (
"Bounds similarity : %37s\n", strstr.str().c_str() );
2887 strstr.str(std::string());
2888 if ( this->moveToCOM ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2889 printf (
"Map COM centering : %37s\n", strstr.str().c_str() );
2891 strstr.str(std::string());
2892 strstr << this->boxCentre.at(0) <<
" ; " << this->boxCentre.at(1) <<
" ; " << this->boxCentre.at(2);
2893 printf (
"BOX centering : %37s\n", strstr.str().c_str() );
2896 strstr.str(std::string());
2897 strstr << this->addExtraSpace;
2898 printf (
"Extra space : %37s\n", strstr.str().c_str() );
2900 strstr.str(std::string());
2901 strstr << this->coOrdsExtraSpace;
2902 printf (
"Extra co-ord space : %37s\n", strstr.str().c_str() );
2905 strstr.str(std::string());
2906 if ( this->progressiveSphereMapping ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2907 printf (
"Progressive spheres : %37s\n", strstr.str().c_str() );
2910 strstr.str(std::string());
2911 strstr << this->outName;
2912 printf (
"Re-boxed filename : %37s\n", strstr.str().c_str() );
2915 strstr.str(std::string());
2916 if ( this->computeEnergyLevelsDesc ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2917 printf (
"Energy lvl desc : %37s\n", strstr.str().c_str() );
2919 strstr.str(std::string());
2920 strstr << this->enLevMatrixPowerWeight;
2921 printf (
"Energy lvl weight : %37s\n", strstr.str().c_str() );
2923 strstr.str(std::string());
2924 if ( this->findSymCentre ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2925 printf (
"Symmetry centre : %37s\n", strstr.str().c_str() );
2927 strstr.str(std::string());
2928 if ( this->computeTraceSigmaDesc ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2929 printf (
"Tr sigma desc : %37s\n", strstr.str().c_str() );
2931 strstr.str(std::string());
2932 if ( this->computeRotationFuncDesc ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2933 printf (
"Full RF desc : %37s\n", strstr.str().c_str() );
2936 strstr.str(std::string());
2937 strstr << this->peakNeighbours;
2938 printf (
"Neightbours to peak : %37s\n", strstr.str().c_str() );
2940 strstr.str(std::string());
2941 strstr << this->noIQRsFromMedianNaivePeak;
2942 printf (
"Peak IQR threshold : %37s\n", strstr.str().c_str() );
2945 strstr.str(std::string());
2946 strstr << this->smoothingFactor;
2947 printf (
"Smoothing factor : %37s\n", strstr.str().c_str() );
2950 strstr.str(std::string());
2951 strstr << this->symMissPeakThres;
2952 printf (
"Missing ax. thres : %37s\n", strstr.str().c_str() );
2954 strstr.str(std::string());
2955 strstr << this->axisErrTolerance;
2956 printf (
"Same ax. threshold : %37s\n", strstr.str().c_str() );
2958 strstr.str(std::string());
2959 if ( this->axisErrToleranceDefault ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2960 printf (
"Same ax. thre. decr.: %37s\n", strstr.str().c_str() );
2962 strstr.str(std::string());
2963 strstr << this->minSymPeak;
2964 printf (
"Min. sym. peak size : %37s\n", strstr.str().c_str() );
2966 strstr.str(std::string());
2967 strstr << this->requestedSymmetryType <<
"-" << this->requestedSymmetryFold;
2968 printf (
"Requested symm. : %37s\n", strstr.str().c_str() );
2970 strstr.str(std::string());
2971 if ( this->useBiCubicInterpolationOnPeaks ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2972 printf (
"Use bicubic interp. : %37s\n", strstr.str().c_str() );
2974 strstr.str(std::string());
2975 strstr << this->maxSymmetryFold;
2976 printf (
"Max symmetry fold : %37s\n", strstr.str().c_str() );
2978 strstr.str(std::string());
2979 strstr << this->fscThreshold;
2980 printf (
"FSC Threshold : %37s\n", strstr.str().c_str() );
2982 strstr.str(std::string());
2983 strstr << this->peakThresholdMin;
2984 printf (
"Peak Threshold : %37s\n", strstr.str().c_str() );
2986 strstr.str(std::string());
2987 if ( this->fastISearch ) { strstr <<
"TRUE"; }
else { strstr <<
"FALSE"; }
2988 printf (
"Fast I Search : %37s\n", strstr.str().c_str() );
2991 strstr.str(std::string());
2992 strstr << this->overlayStructureName;
2993 printf (
"Overlay file : %37s\n", strstr.str().c_str() );
2995 strstr.str(std::string());
2996 strstr << this->rotTrsJSONFile;
2997 printf (
"JSON overlay file : %37s\n", strstr.str().c_str() );
3000 strstr.str(std::string());
3001 strstr << this->verbose;
3002 printf (
"Verbosity : %37s\n", strstr.str().c_str() );
3013 #if defined ( _WIN64 ) || defined ( _WIN32 )
3020 return ( this->enLevs );
3027 #if defined ( _WIN64 ) || defined ( _WIN32 )
3034 return ( this->trSigm );
3041 #if defined ( _WIN64 ) || defined ( _WIN32 )
3048 return ( this->rotFun );
3058 return ( this->noStructures );
3068 return ( this->verbose );
3078 return (
static_cast<proshade_unsign
> ( this->RecomSymAxes.size() ) );
3088 return (
static_cast<proshade_unsign
> ( this->RecomSymAxes.size() ) );
3096 #if defined ( _WIN64 ) || defined ( _WIN32 )
3103 if (
static_cast<proshade_unsign
> ( this->RecomSymAxes.size() ) <= axisNo )
3106 return ( std::vector< std::string > ( ) );
3110 std::vector< std::string > ret;
3113 std::stringstream ssHlp;
3114 ssHlp << this->RecomSymAxes.at(axisNo)[0];
3118 ssHlp << this->RecomSymAxes.at(axisNo)[1];
3122 ssHlp << this->RecomSymAxes.at(axisNo)[2];
3126 ssHlp << this->RecomSymAxes.at(axisNo)[3];
3130 ssHlp << this->RecomSymAxes.at(axisNo)[4];
3134 ssHlp << this->RecomSymAxes.at(axisNo)[5];
3138 ssHlp << this->RecomSymAxes.at(axisNo)[6];
3151 #if defined ( _WIN64 ) || defined ( _WIN32 )
3158 return ( this->allCSymAxes );
3166 #if defined ( _WIN64 ) || defined ( _WIN32 )
3173 return ( this->mapCOMShift );
3181 #if defined ( _WIN64 ) || defined ( _WIN32 )
3188 if ( noStructures <= strNo )
3191 return ( std::vector< proshade_signed > ( ) );
3195 std::vector< proshade_signed > ret;
3213 #if defined ( _WIN64 ) || defined ( _WIN32 )
3220 if ( noStructures <= strNo )
3223 return ( std::vector< proshade_signed > ( ) );
3227 std::vector< proshade_signed > ret;
3247 #if defined ( _WIN64 ) || defined ( _WIN32 )
3254 return ( this->manipulatedMaps.at(strNo)[mapIndex] );
3264 #if defined ( _WIN64 ) || defined ( _WIN32 )
3278 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++)
3280 reboxMap[iter] =
static_cast<double> ( run->
getMapValue ( strNo, iter ) );
3292 #if defined ( _WIN64 ) || defined ( _WIN32 )
3299 if ( this->eulerAngles.size() != 3 )
3301 ProSHADE_internal_messages::printWarningMessage ( this->verbose,
"!!! ProSHADE WARNING !!! Requested rotation/translation values for Overlay functionality without having successfully computed it. Please check the correct task was used and no other warnings/errors were obtained.",
"WO00042" );
3302 return ( std::vector< proshade_double > ( ) );
3306 return ( this->eulerAngles );
3314 #if defined ( _WIN64 ) || defined ( _WIN32 )
3321 if ( this->eulerAngles.size() != 3 )
3323 ProSHADE_internal_messages::printWarningMessage ( this->verbose,
"!!! ProSHADE WARNING !!! Requested rotation/translation values for Overlay functionality without having successfully computed it. Please check the correct task was used and no other warnings/errors were obtained.",
"WO00042" );
3324 return ( std::vector< proshade_double > ( ) );
3328 proshade_double* rotMat =
new proshade_double[9];
3333 std::vector< proshade_double > ret;
3348 #if defined ( _WIN64 ) || defined ( _WIN32 )
3355 if ( this->coordRotationCentre.size() != 3 )
3357 ProSHADE_internal_messages::printWarningMessage ( this->verbose,
"!!! ProSHADE WARNING !!! Requested rotation/translation values for Overlay functionality without having successfully computed it. Please check the correct task was used and no other warnings/errors were obtained.",
"WO00042" );
3358 return ( std::vector< proshade_double > ( ) );
3362 std::vector < proshade_double > ret;
3376 #if defined ( _WIN64 ) || defined ( _WIN32 )
3383 if ( this->overlayTranslation.size() != 3 )
3385 ProSHADE_internal_messages::printWarningMessage ( this->verbose,
"!!! ProSHADE WARNING !!! Requested rotation/translation values for Overlay functionality without having successfully computed it. Please check the correct task was used and no other warnings/errors were obtained.",
"WO00042" );
3386 return ( std::vector< proshade_double > ( ) );
3390 return ( this->overlayTranslation );